this is ai generated from chat raw notes were deleted due to lack of coherent thoughts

rubik complexity spec (t, k, p)

1. basic explanation: mapping to a cube

we define a cube state in terms of moves and layers. each move corresponds to a generator of the rubik’s cube group. for an $n \times n$ cube:

each face can be denoted $F, B, U, D, L, R$ .
for higher $n$ , inner slices are indexed: e.g., $U_{0}$ is the outer top layer, $U_{1}$ the second layer, etc.

thus, any cube state $S$ is a group element obtained by multiplying a sequence of such moves.

the complexity number $C (S)$ measures how “far” a state is from another in a structured way:

$t$ = number of moves.
$k$ = number of distinct layers touched.
$p$ = permutation distance (minimal move distance between states).

we define: $C (S) = (t, k, p)$

this gives a complexity vector.

2. what the complexity number tells

$t$ : how long the solution path is (move count).
$k$ : how widespread the effect is across cube layers.
$p$ : true “distance” in the rubik’s group.

this allows us to compare states without reference to a specific solving method.

3. creating and finding states

using $(t, k, p)$ :

given $t, k$ , we can enumerate all possible states.
given a state, we can measure its $(t, k, p)$ .
we can constrain design: e.g., only 3 moves using 2 faces.

4. mathematical theory (group-theoretic expansion)

let $G = ⟨ M ⟩$ be the group generated by legal moves $M$ of the rubik’s cube.

each state $S \in G$ .
identity $e$ = solved cube.

move count

for a sequence $w = m_{1} m_{2} \dots m_{t}$ with $m_{i} \in M$ , the move count is: $t = ∣ w ∣$

layer spread

let $L (w)$ be the set of unique layers touched by $w$ . then: $k = ∣ L (w) ∣$

permutation distance

for two states $S_{1}, S_{2}$ , define: $p (S_{1}, S_{2}) = min ∣ w ∣ : w \in M^{*}, S_{1} w = S_{2}$

that is, the minimal move length required to transform $S_{1}$ into $S_{2}$ .

complexity vector

finally: $C (S_{1}, S_{2}) = (t, k, p (S_{1}, S_{2}))$

this is well-defined for any $n \times n$ cube.

5. use cases

designing training problems: set $t, k$ constraints.
measuring puzzle difficulty independent of solving method.
exploring reachable subsets of cube space.
evaluating ai/llm solvers with structured difficulty levels.

    flowchart TD
    A[Input Constraints<br>t, k, p] --> B[Generator]
    B --> C[Enumerated States]
    C --> D[Filtered Outputs<br>Target States]

cayley graph snippet

graph LR
    A[Identity] -- R --> B
    A -- U --> C
    B -- U --> D
    C -- R --> D

3×3 cube matrix representation

representing cube faces as $3 \times 3$ matrices of stickers: $U = [u_{00} u_{01} u_{02} u_{10} u_{11} u_{12} u_{20} u_{21} u_{22}], R = [r_{00} r_{01} r_{02} r_{10} r_{11} r_{12} r_{20} r_{21} r_{22}], \dots$

a move $R$ acts as a permutation matrix $P_{R}$ on this state vector. for example, flatten all stickers into a vector $v$ , then: $v^{'} = P_{R} v$

matrix multiplication flow

flowchart LR
    X[Start State Vector v] --> Y[Apply Move Matrix P]
    Y --> Z[New State v']

complexity theory