Calculating Method/Substep Efficiency

[martinss]

(learning) Difficulty of an algorithm = Number of moves in [WIKI]Logical Turn Metric[/WIKI] ( with [A:B] = ABA', length=2 and with [A,B] = ABA'B', length=2 )
Example : For the main PLL-T algorithm, difficulty=9 LTM moves : R U R' U' R' F R2 U' R' U' R U R' F' = [R, U] [F: [F', R'] [R U' R': (U')] ]
Divide by 2 if it's a mirror/invert of an other algorithm (of the same substep).

Slowness of an algorithm = ( Number of moves in [WIKI]HTM[/WIKI] ) * ( Number of regrips )
Example : For the main PLL-T algorithm, Slowness=14 HTM moves . regrip . look : 14*1*1=14

Efficacity of an algorithm = 1 / ( Slowness * difficulty)
Examples: For the main PLL-T algorithm, Efficacity= 1/126

Mobility of a substep = ( Number of free permutations ) + ( Number of free orientations )
Examples : For the PLL algorithms, Mobility = 0 change. For the OLL algorithms , Mobility = 8 changes. (8 permutations)

Progression of a substep = Permutations/permutable cubies + Orientations/orientable cubies
Example : For the PLL algorithms, progression = 8/20+0/20 = 8/40=1/5

Efficacity of a substep = ( progression/mobility ) * Σ P(alg)*Efficacity(alg)

 

[Dane man]

(learning) Difficulty of an algorithm = Number of moves in [WIKI]Logical Turn Metric[/WIKI] ( with [A:B] = ABA', length=2 and with [A,B] = ABA'B', length=2 )
Example : For the main PLL-T algorithm, difficulty=9 LTM moves : R U R' U' R' F R2 U' R' U' R U R' F' = [R, U] [F: [F', R'] [R U' R': (U')] ]
Divide by 2 if it's a mirror/invert of an other algorithm (of the same substep).

Slowness of an algorithm = ( Number of moves in [WIKI]HTM[/WIKI] ) * ( Number of regrips )
Example : For the main PLL-T algorithm, Slowness=14 HTM moves . regrip . look : 14*1*1=14

Efficacity of an algorithm = 1 / ( Slowness * difficulty)
Examples: For the main PLL-T algorithm, Efficacity= 1/126

Mobility of a substep = ( Number of free permutations ) + ( Number of free orientations )
Examples : For the PLL algorithms, Mobility = 0 change. For the OLL algorithms , Mobility = 8 changes. (8 permutations)

Progression of a substep = Permutations/permutable cubies + Orientations/orientable cubies
Example : For the PLL algorithms, progression = 8/20+0/20 = 8/40=1/5

Efficacity of a substep = ( progression/mobility ) * Σ P(alg)*Efficacity(alg)

Wow, I like these. They all follow a very logical progression, and are actually quite accurate when it comes to measuring individual parts. Good work!

I have one question though. What is P(alg)? and is it ( progression/mobility ) * Σ P(alg) * Efficacity(alg) or ( progression/mobility ) * Σ ( P(alg) * Efficacity(alg) )? The lack of space around the second multiplier makes me wonder.

 

[martinss]

What is P(alg)? and is it ( progression/mobility ) * Σ P(alg) * Efficacity(alg) or ( progression/mobility ) * Σ ( P(alg) * Efficacity(alg) )? The lack of space around the second multiplier makes me wonder.

P(alg) is the probability of the case knowing the substep. So for pll efficatcity :
( progression/mobility ) * ( 1/18 * efficacity(PLLAa) + 1/18 * efficacity(PLLAb) + 1/72 * efficacity(PLLH) + ... )

 

[Dane man]

P(alg) is the probability of the case knowing the substep. So for pll efficatcity :
( progression/mobility ) * ( 1/18 * efficacity(PLLAa) + 1/18 * efficacity(PLLAb) + 1/72 * efficacity(PLLH) + ... )

Oh okay, so it's ( progression/mobility ) * Σ ( Probability(alg) * Efficacity(alg) ). Nicely done.

 

[mark49152]

Which algs do you choose for calculating the efficacy of, say, PLL? Different people will have different values so it doesn't seem right to say it's a measure of the substep. It's more a measure of the alg set.

 

[martinss]

Oh okay, so it's ( progression/mobility ) * Σ ( Probability(alg) * Efficacity(alg) ). Nicely done.

I didn't think about it but it does not work. Two algs should be less efficient than one... i'll try to think about an other way...

Which algs do you choose for calculating the efficacy of, say, PLL? Different people will have different values so it doesn't seem right to say it's a measure of the substep. It's more a measure of the alg set.

I think the goal of the thread is to purpose these algs... You're right when you say measuring a substep doesn't mean measuring the alg set 'cause sometimes there are intuitive moves (as in F2L), sometimes other things...

 

[martinss]

I didn't think about it but it does not work. Two algs should be less efficient than one... i'll try to think about an other way...

(learning) Difficulty of an algorithm = Number of moves in [WIKI]Logical Turn Metric[/WIKI] ( with [A:B] = ABA', length=2 and with [A,B] = ABA'B', length=2 )
Example : For the main PLL-T algorithm, difficulty=9 LTM moves : R U R' U' R' F R2 U' R' U' R U R' F' = [R, U] [F: [F', R'] [R U' R': (U')] ]
Difficulty belongs to [1;+infinity[

Slowness of an algorithm = ( Number of moves in [WIKI]HTM[/WIKI] ) * ( Number of regrips )
Example : For the main PLL-T algorithm, Slowness=14 HTM moves . regrip : 14*1=14
Slowness belongs to [1;+infinity[

Efficacity of an algorithm = 1 / ( Slowness * Difficulty)
Examples: For the main PLL-T algorithm, Efficacity= 1/126
Efficacity belongs to ]0;1]


(learning) Difficulty of algs of a step = Σ Difficulty(Alg)
Difficulty belongs to [1;+infinity[

Slowness of algs of a step = Σ (Probability(alg, knowing the substep)*Slowness(alg))
Slowness belongs to [1;+infinity[

Efficacity of algs of a step = 1 / (slowness*difficulty)
Efficacity belongs to ]0;1]



Mobility of a substep = ( Number of free permutations ) + ( Number of free orientations )
Examples : For the PLL algorithms, Mobility = 0 change. For the OLL algorithms , Mobility = 8 changes. (8 permutations)
Mobility belongs to [0;40]

Progression of a substep = (Permutations/permutable cubies + Orientations/orientable cubies) /2
Example : For the PLL algorithms, progression = 8/40+0/40 = 8/40=1/5
Progression belongs to ]0;1]

Efficacity of a substep = ( progression/(1+mobility) ) * (Efficacity of algs of the substep)
Efficacity belongs to ]0;1]

 

[brododragon]

What about something like zzll, where you do not completely permute, but making sure pieces go in a certain group of spots?