How It Works

Each enumerated configuration is exposed as an object whose fields are referenced throughout this page. Non-buffer cycles means all cycles except the buffer cycle.

With arbitrary floating 3-cycles, any non-buffer cycle can be reduced systematically in three phases:

Phase 1 — Shrink long cycles

For each non-buffer cycle with $p \ge 3$, apply $\lfloor(p-1)/2\rfloor$ floating 3-cycles to shrink it by 2 per step. Orientation $o$ is preserved by a well-chosen cycle. After Phase 1, only $(2,o)$ and $(1,o)$ cycles remain among non-buffer cycles:

• Edges ($O=2$): $(2,0),\;(2,1),\;(1,1)$ — where $(1,0)$ is solved and ignored.
• Corners ($O=3$): $(2,0),\;(2,1),\;(2,2),\;(1,1),\;(1,2)$.

Phase 2 — Pair 2-cycles (edges)

Let post-Phase-1 counts be $r_{20},\,r_{21},\,r_{11}$. Reductions are applied in order, each pair costing 2 floating algs:

1. $(2,0)+(2,0) \to$ solved: pairs $\lfloor r_{20}/2\rfloor$, then $r_{20} \leftarrow r_{20} \bmod 2$.
2. $(2,1)+(2,1) \to$ solved: pairs $\lfloor r_{21}/2\rfloor$, then $r_{21} \leftarrow r_{21} \bmod 2$.
3. Mixed $(2,0)+(2,1) \to (1,1)$: pairs $m = \min(r_{20}, r_{21})$, with $r_{20} \mathrel{-}= m$, $r_{21} \mathrel{-}= m$, $r_{11} \mathrel{+}= m$.

After Phase 2, at most one residual 2-cycle remains: $R = r_{20} + r_{21} \le 1$. Each contributes $1.5$ algs.

Phase 2 — Pair 2-cycles (corners)

Let post-Phase-1 counts be $r_{20},\,r_{21},\,r_{22},\,r_{11},\,r_{12}$. Reductions are applied in order, each pair costing 2 floating algs:

1. $(2,0)+(2,0) \to$ solved: pairs $\lfloor r_{20}/2\rfloor$, then $r_{20} \leftarrow r_{20} \bmod 2$.
2. Mixed $(2,1)+(2,2) \to$ solved (twists cancel mod 3): pairs $\min(r_{21}, r_{22})$.
3. Same-type $(2,1)+(2,1) \to$ twisted $(1,\cdot)$: pairs $\lfloor r_{21}/2\rfloor$, contributing $\lfloor r_{21}/2\rfloor$ to $r_{12}$, then $r_{21} \leftarrow r_{21} \bmod 2$.
4. Same-type $(2,2)+(2,2) \to$ twisted $(1,\cdot)$: pairs $\lfloor r_{22}/2\rfloor$, contributing $\lfloor r_{22}/2\rfloor$ to $r_{12}$, then $r_{22} \leftarrow r_{22} \bmod 2$.
5. Mixed $(2,0)+(2,1) \to (1,1)$: pairs $\min(r_{20}, r_{21})$, transferring into $r_{11}$.
6. Mixed $(2,0)+(2,2) \to (1,2)$: pairs $\min(r_{20}, r_{22})$, transferring into $r_{12}$.

After Phase 2, at most one residual 2-cycle remains: $R = r_{20} + r_{21} + r_{22} \le 1$. Each contributes $1.5$ algs. (The bookkeeping bucket — $r_{11}$ vs $r_{12}$ — for same-type pairings doesn't affect the final alg count, since the Phase-3 twist formula is symmetric in $r_{11}$ and $r_{12}$.)

Phase 3 — Count remaining algs

Edge 2-flip and 4-flip; corner 2-twist and 3-twist each count as 1 alg.

• Twist algs: edges $\lceil r_{11}/4\rceil$; corners $\lfloor r_{11}/3\rfloor + \lfloor r_{12}/3\rfloor + \lceil(r_{11} \bmod 3 + r_{12} \bmod 3)/3\rceil$.
• Residual 2-cycles: $1.5\,R$ algs.
• Buffer cycle of length $p_0$: $(p_0-1)/2$ algs.

Total: $\text{twist} + 1.5\,R + (p_0-1)/2$. All arithmetic is done in the $2\times$ form (integers) to avoid float precision issues, then divided by 2.

Note: the reduction above uses a fixed greedy pairing order for simplicity. In some configurations a different pairing strategy could yield a lower alg count, so the statistics presented here should be taken as an upper bound on the true optimum.

Full Floating Parity

When parity is odd and a residual $(2,0)$ remains, it is absorbed into the parity end-pair of the buffer cycle, reducing its cost from $1.5$ to $0.5$ algs — a saving of 1. A residual $(2,1)$ or $(2,2)$ cannot be absorbed cleanly, so it stays at cost $1.5$ and parity yields no saving.

Mean: , Std:

Mean: , Std:

Mean: , Std:

Mean alg counts by skill level, computed over all valid scramble states:

Bruh, would you really want to learn 2,768 full-floating 3-style algs just to save algs per scramble on average, and another 11,088 full-floating parity algs just to save more algs per scramble? These are only theoretical upper bounds, without accounting for human-level practicality. Life is short, be happy :)

To be clear, I am not discouraging floating and I like to improvise floating all the time. I am highlighting the cost-benefit tradeoff. With limited time and energy, more algs mean less mastery per case and more mental overhead.

Distribution of algs saved per scramble by skill level (vs. Basic):

Edge

Corner

Total

On odd-parity scrambles the solver has to fold a 2-swap (parity alg) into the execution. Cascading Pseudo/Weak Swap avoids learning every possible parity pair: pick a fixed preference order over the 11 non-buffer edge positions, then during memo scan that list and use the first applicable one as the parity target. The smaller the slot index, the more likely the parity case lands inside the small set of pairs you've actually mastered.

It never hurts to run the same routine on even-parity scrambles — the alg count is unchanged. (Unlike a fixed weak swap, which can add an alg when applied unconditionally.) Another small win: the chosen letter is deferred to the final parity swap, so once you've spotted which slot CPS will pick you can drop that letter from the running memo — a small but real saving over fixed weak swap, where you'd say UR's letter regardless.

Hard-coded preference order: AGEDPITXKQYN

MWP = Mid-Way Parity: when a pref letter shows up at an even index inside the buffer cycle (with matching orientation), tag that letter as the parity swap in-place instead of deferring to the end.

Edge flip insertion is commonly integrated with CPS to fold a flipped non-buffer edge into the parity swap, but isn't shown in this demo yet.

This card doesn't fold in floating reductions yet. Combining floating with CPS gets pretty intricate, and so far not many solvers have interests. Anyway let's leave space for arts in 3BLD :)

When a 3BLD scramble has odd parity, the solver must incorporate a 2-swap (parity algorithm) into their execution. The cascading pseudo/weak swap technique resolves parity by designating a fixed preference order among the 11 non-buffer edge positions (e.g., UR first, then UB, UL, …). During memo, the solver checks each preferred position in order until one is applicable — meaning it can serve as the parity-swap target with the buffer.

Forsthofer & Hiesl (2021) use the "UR–UF pseudo swap", which is the length-1 special case of the cascading version below (preference list = {UR}).

For buffer UF, a position X is applicable as a swap target if any of these hold:

• The UF piece is sitting at X — skip the letter and leave it for the parity swap at the end.
• X is not in the buffer cycle — start a new cycle ending at X, leaving the swap at the end.
• The X piece is flipped in place — solve it as two letters (e.g., RU then UR), executing RU in cycle and leaving UR at the end.

Conversely, X is not applicable if:

• X is already correctly solved — there is no need to swap it.
• X is in the middle of the buffer cycle — it cannot be extracted without disrupting tracing.
• The UF piece is sitting at $\overline{\mathrm{X}}$ (the flipped sticker of X) — this forces a letter into the buffer cycle that cannot be deferred.

These two sets are in bijection: swapping the physical UF and X pieces maps each applicable case to the corresponding not-applicable case and vice versa. This gives a clean 50% probability that the first preferred position (index #1) is applicable, regardless of parity. The remaining position at the end of the buffer cycle ($p_0 > 1$) can have either orientation with equal probability, so it contributes half to each side.

Formally, for a cycle configuration with buffer cycle length $p_0$ and $f$ solved-in-place edges among non-buffer cycles:

• $a = 11 - h - n$: fully applicable positions (not in buffer cycle, not solved)
• $h = \mathbf{1}_{p_0 > 1}$: the last position in the buffer cycle — applicable iff its orientation is correct (probability $\frac{1}{2}$)
• $n = \max(0,\, p_0 - 2) + f$: never-applicable positions (mid-buffer-cycle + solved)

After the coin flip on $h$, we have $a'$ applicable and $n' = 11 - a'$ not-applicable positions uniformly distributed among the 11 preference slots. The probability that the first applicable slot is at index $k$ is:

where $x^{\underline{m}} = x(x-1)\cdots(x-m+1)$ is the falling factorial. The — row collects configurations where $a' = 0$ (no applicable target exists).

Indices #12–#22 represent cases with no applicable position (no edge cycle breaks and ending on a wrong-orientation edge), spread evenly to make the curve continuous.

Same algorithm with corner buffer UFR over 7 non-buffer corner positions. The end-of-buffer-cycle position is applicable with probability $\tfrac{1}{3}$ (instead of $\tfrac{1}{2}$ for edges) since corners have three orientations.

Indices #8–#21 represent cases with no applicable position, spread evenly across 14 buckets to make the curve continuous.

Mean: , Std:

Mean: , Std:

Mean: , Std:

Solved-in-place edges (buffer excluded) follow the same distribution by orientation symmetry.

Mean: , Std:

Probability that a scramble's non-buffer cycles invoke a 4-flip or 3-twist alg. Edge 4-flip: open1>=3. Corner 3-twist: cwTwist>=3 || ccwTwist>=3 || cwTwist==2 && ccwTwist==0 || ccwTwist==2 && cwTwist==0.

LTCT (Last Target Corner Twist) combines solving the final corner target with twisting two misoriented corners into a single algorithm, saving one twist alg. It requires odd parity and at least one twisted non-buffer corner (open1>=1).

T2C (Twisted 2 Corners) solves the final corner target when the buffer corner is twisted and two remaining corners are swapped, combining the swap and buffer untwist into one algorithm. It requires odd parity and at least one misoriented non-buffer 2-cycle (open2>=1).

Note: In practice, most BLDers specialize in LTCT or T2C algorithms for a fixed edge pair (e.g., UF–UR), so the actual applicable cases are even fewer—roughly half of those shown above when using cascading pseudo/weak swap.

Every move sequence eventually returns the cube to its start state. The order is the number of repetitions required. The table shows how many distinct cube states (scrambles) have each order.

Mean: , Std:

Wing parity counts as 1 alg. Basic floating includes floating pure 3-cycles and one pure 2-cycle for wing parity.

Mean wing alg counts by skill level, computed over all 4x4x4 wing states:

Distribution of algs saved per scramble by skill level (vs. Basic):

Mean: , Std:

Mean: , Std:

Mean: , Std:

Mean: , Std:

Mean: , Std: