add ability to compute changes associated with a sequence of moves

README.md

@@ -7,7 +7,7 @@ This project uses `uv 0.7` as environment & dependency manager, and `python 3.11
 
 ```shell
 uv venv
-(Activate env)
+-- Activate env --
 uv sync
 pre-commit install
 ```
@@ -54,16 +54,17 @@ cube.rotate('X2 X1i Y1i Z1i Y0 Z0i X2 X1i Y1i Z1i Y0 Z0i')
 - ☑️ Tensorized states.
 - ☑️ Tensorized actions.
 - ☑️ Interface for performing actions.
-- ⬜ Tensor operations moved to cuda.
 
 #### Movement explorer
 
-- ⬜ Explore result of an input sequences of moves.
-- ⬜ Find sequences of moves satisfying input constrains.
+- ⬜ Explore changes resulting from a sequences of moves.
+- ⬜ Find least sequences of moves satisfying some input constrains.
+
+#### Visualization interface
 
 #### Base solvers following rule-based policies
 
-#### Visualization interface
+
 
 
 ## Related projects

notebooks/dev.ipynb

@@ -56,10 +56,20 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "cubis_cpu = copy.deepcopy(cube)\n",
-    "cubis_cpu.shuffle(2000, seed=0)\n",
-    "print(cubis_cpu)\n",
-    "print(cubis_cpu.history)"
+    "cubis = copy.deepcopy(cube)\n",
+    "cubis.shuffle(2000, seed=0)\n",
+    "print(cubis)\n",
+    "print(cubis.history)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cb29c742",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "cubis.compute_changes(\"X2 X1i Y1i Z1i Y0 Z0i X2 X1i Y1i Z1i Y0 Z0i \")"
    ]
   },
   {

src/rubik/action.py

@@ -123,14 +123,23 @@ def build_action_tensor(size: int, axis: int, slice: int, inverse: int) -> torch
     return torch.sparse_coo_tensor(indices=perm_indices, values=perm_values, size=perm_size, dtype=torch.int8)
 
 
-def parse_action_str(name: str) -> tuple[int, ...]:
+def parse_action_str(move: str) -> tuple[int, ...]:
     """
     Convert the name of an action into a triple (axis, slice, inverse).
     Examples:
         'X1'  -> (0, 1, 0)
         'X2i' -> (0, 2, 1)
     """
-    return ("XYZ".index(name[0]), int(name[1]), int(len(name) >= 3))
+    return ("XYZ".index(move[0]), int(move[1]), int(len(move) >= 3))
+
+
+def parse_actions_str(moves: str) -> list[tuple[int, ...]]:
+    """
+    Convert a sequence of actions in a string into a list of triples (axis, slice, inverse).
+    Examples:
+        'X1 X2i'  -> [(0, 1, 0), (0, 2, 1)]
+    """
+    return [parse_action_str(move) for move in moves.strip().split()]
 
 
 def sample_actions_str(num_moves: int, size: int, seed: int = 0) -> str:

src/rubik/cube.py

@@ -1,9 +1,10 @@
+from functools import reduce
 from loguru import logger
 
 import torch
 import torch.nn.functional as F
 
-from rubik.action import build_actions_tensor, parse_action_str, sample_actions_str
+from rubik.action import build_actions_tensor, parse_actions_str, sample_actions_str
 from rubik.display import stringify
 from rubik.tensor_utils import build_cube_tensor
 
@@ -63,7 +64,7 @@ class Cube:
         """
         Apply a sequence of moves (defined as plain string) to the cube.
         """
-        actions = [parse_action_str(move) for move in moves.strip().split()]
+        actions = parse_actions_str(moves)
         for action in actions:
             self.rotate_once(*action)
         return
@@ -77,6 +78,15 @@ class Cube:
         self.history.append([axis, slice, inverse])
         return
 
+    def compute_changes(self, moves: str) -> dict[int, int]:
+        """
+        combine a sequence of moves and return the resulting changes.
+        """
+        actions = parse_actions_str(moves)
+        tensors = [self.actions[*action].to(torch.float32) for action in actions]
+        result = reduce(lambda A, B: A @ B, tensors).to(torch.int8)
+        return dict(result.indices().transpose(0, 1).tolist())
+
     def solve(self, policy: str) -> None:
         """
         Apply the specified solving policy to the cube.
@@ -87,4 +97,5 @@ class Cube:
         """
         Compute a string representation of a cube.
         """
-        return stringify(self.state.argmax(dim=-1).to(device="cpu", dtype=torch.int8), self.colors, self.size)
+        state = self.state.argmax(dim=-1).to(device="cpu", dtype=torch.int8)
+        return stringify(state, self.colors, self.size)