Feat/core layer architecture refactor

core/planning/__init__.py

@@ -7,7 +7,12 @@
 
 """Static grade planning and Torch executor lowering."""
 
-from .action import apply_graded_linear_action, bivector_vector_generator, reflection_vector_matrix
+from .action import (
+    apply_graded_linear_action,
+    apply_multi_graded_linear_action,
+    bivector_vector_generator,
+    reflection_vector_matrix,
+)
 from .flow import GradeFlow
 from .layouts import ProductRequest, build_product_request
 from .planner import GradePlanner
@@ -27,6 +32,7 @@
     "PlanCost",
     "DEFAULT_PLANNING_LIMITS",
     "apply_graded_linear_action",
+    "apply_multi_graded_linear_action",
     "bivector_vector_generator",
     "GradeUnaryExecutor",
     "GradeUnaryOp",

core/planning/action.py

@@ -41,6 +41,36 @@ def apply_graded_linear_action(
     return torch.einsum("coi,...ci->...co", coefficients, values)
 
 
+def apply_multi_graded_linear_action(
+    values: torch.Tensor,
+    matrices: torch.Tensor,
+    *,
+    input_layout: GradeLayout,
+    output_layout: GradeLayout,
+) -> torch.Tensor:
+    """Apply multiple outermorphisms to compact grade lanes.
+
+    ``matrices`` stores ``[actions, n, n]`` vector-space maps. ``values``
+    stores ``[..., channels, input_layout.dim]`` compact lanes. The result is
+    ``[..., channels, actions, output_layout.dim]``.
+    """
+    if input_layout.spec != output_layout.spec:
+        raise ValueError(f"layout mismatch: {input_layout.spec} vs {output_layout.spec}")
+    if values.shape[-1] != input_layout.dim:
+        raise ValueError(f"input compact dimension must be {input_layout.dim}, got {values.shape[-1]}")
+    if values.ndim < 2:
+        raise ValueError(f"values must include channel and lane axes, got shape {tuple(values.shape)}")
+
+    spec = input_layout.spec
+    if matrices.shape[-2:] != (spec.n, spec.n):
+        raise ValueError(f"matrices trailing shape must be {(spec.n, spec.n)}, got {tuple(matrices.shape[-2:])}")
+    if matrices.ndim != 3:
+        raise ValueError(f"matrices must have shape [actions, n, n], got {tuple(matrices.shape)}")
+
+    coefficients = _graded_action_coefficients(matrices, input_layout=input_layout, output_layout=output_layout)
+    return torch.einsum("koi,...ci->...cko", coefficients, values)
+
+
 def bivector_vector_generator(bivectors: torch.Tensor, *, bivector_layout: GradeLayout) -> torch.Tensor:
     """Return the vector-space generator induced by compact bivectors."""
     if bivector_layout.grades != (2,):

core/runtime/__init__.py

@@ -8,8 +8,18 @@
 """Runtime algebra hosts and dense reference operations."""
 
 from .accessors import as_multivector, compact_values, grade_indices, hermitian_signs, materialize_dense, resolve_layout
+from .actions import (
+    apply_multi_versor_action,
+    apply_versor_action,
+    compact_multi_versor_action,
+    compact_versor_action,
+    dense_versor_factors,
+    grade_norms,
+    versor_vector_matrix,
+)
 from .algebra import CliffordAlgebra
 from .context import AlgebraContext
+from .layers import LayerStorage, resolve_layer_layout, resolve_layer_storage
 from .multivector import Multivector
 from .projected import AlgebraRuntimeMixin
 
@@ -20,8 +30,18 @@
     "Multivector",
     "as_multivector",
     "compact_values",
+    "apply_multi_versor_action",
+    "apply_versor_action",
+    "compact_multi_versor_action",
+    "compact_versor_action",
+    "dense_versor_factors",
     "grade_indices",
+    "grade_norms",
     "hermitian_signs",
     "materialize_dense",
+    "resolve_layer_layout",
+    "resolve_layer_storage",
     "resolve_layout",
+    "LayerStorage",
+    "versor_vector_matrix",
 ]