morphis 0.10.0__tar.gz → 0.11.0__tar.gz

{morphis-0.10.0 → morphis-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: morphis
-Version: 0.10.0
+Version: 0.11.0
 Summary: A unified mathematical framework for geometric computation
 Keywords: geometric-algebra,mathematics,visualization,multivector,pga
 Author: ctl-alt-leist

{morphis-0.10.0 → morphis-0.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "morphis"
-version = "0.10.0"
+version = "0.11.0"
 description = "A unified mathematical framework for geometric computation"
 readme = "README.md"
 license = "MIT"

{morphis-0.10.0 → morphis-0.11.0}/src/morphis/algebra/contraction.py

@@ -37,6 +37,8 @@ class IndexedTensor:
     Attributes:
         tensor: The underlying Vector or Operator (reference, not copy)
         indices: String of index labels (e.g., "mnab")
+        output_geo_indices: Indices that represent output geometric dimensions.
+            These determine the result grade when present in contraction output.
 
     Examples:
         >>> G = Operator(...)  # lot=(M, N), grade=2 output
@@ -44,18 +46,21 @@ class IndexedTensor:
         >>> b = G["mnab"] * q["n"]  # contracts on 'n', result has indices "mab"
     """
 
-    __slots__ = ("tensor", "indices")
+    __slots__ = ("tensor", "indices", "output_geo_indices")
 
-    def __init__(self, tensor: "Vector | Operator", indices: str):
+    def __init__(self, tensor: "Vector | Operator", indices: str, output_geo_indices: str = ""):
         """
         Create an indexed tensor wrapper.
 
         Args:
             tensor: The underlying Vector or Operator
             indices: String of index labels, one per axis of tensor.data
+            output_geo_indices: Subset of indices representing output geometric
+                dimensions. If empty, will be inferred during contraction (legacy).
         """
         self.tensor = tensor
         self.indices = indices
+        self.output_geo_indices = output_geo_indices
 
         # Validate index count matches tensor dimensions
         expected_ndim = tensor.data.ndim
@@ -78,9 +83,14 @@ class IndexedTensor:
 
         if isinstance(other, LotIndexed):
             # Convert LotIndexed to IndexedTensor by adding geo indices
+            # All of a Vector's geometric indices are "output geometric"
             n_geo = other.vector.grade
             geo_labels = "".join(chr(ord("A") + i) for i in range(n_geo))
-            other = IndexedTensor(other.vector, other.indices + geo_labels)
+            other = IndexedTensor(
+                other.vector,
+                other.indices + geo_labels,
+                output_geo_indices=geo_labels,
+            )
 
         if not isinstance(other, IndexedTensor):
             return NotImplemented
@@ -152,23 +162,20 @@ def _contract_indexed(*indexed_tensors: IndexedTensor) -> "Vector":
 
 
 def _infer_grade_from_indexed(indexed_tensors: tuple[IndexedTensor, ...], output_indices: str) -> int:
-    """Infer grade for IndexedTensor contraction result."""
-    from morphis.elements.vector import Vector
-
-    # Track which indices are geometric (vs lot)
-    geo_indices = set()
+    """
+    Infer grade for IndexedTensor contraction result.
 
+    The result grade equals the number of output geometric indices that appear
+    in the result. Each IndexedTensor carries its output_geo_indices, which
+    identify which indices represent geometric (grade-contributing) dimensions.
+    """
+    # Collect output geometric indices from all tensors
+    all_output_geo = set()
     for it in indexed_tensors:
-        if isinstance(it.tensor, Vector):
-            n_lot = len(it.tensor.lot)
-            n_geo = it.tensor.grade
-            # Geometric indices are the last 'grade' indices
-            geo_part = it.indices[n_lot : n_lot + n_geo]
-            geo_indices.update(geo_part)
+        all_output_geo.update(it.output_geo_indices)
 
-    # Count geometric indices in output
-    result_grade = sum(1 for idx in output_indices if idx in geo_indices)
-    return result_grade
+    # Result grade = count of output geometric indices in the result
+    return sum(1 for idx in output_indices if idx in all_output_geo)
 
 
 # =============================================================================

{morphis-0.10.0 → morphis-0.11.0}/src/morphis/algebra/tests/test_contraction.py

@@ -1,11 +1,14 @@
 """Tests for tensor contraction with both bracket and einsum-style APIs."""
 
+import numpy as np
 import pytest
 from numpy import array, ones
 from numpy.testing import assert_allclose, assert_array_equal
 
 from morphis.algebra.contraction import IndexedTensor, contract
+from morphis.algebra.specs import VectorSpec
 from morphis.elements import Vector, euclidean_metric
+from morphis.operations.operator import Operator
 
 
 # =============================================================================
@@ -222,3 +225,84 @@ class TestSlicingStillWorks:
 
         assert isinstance(result, Vector)
         assert result.shape == (5, 3)
+
+
+# =============================================================================
+# Operator Indexed Contraction
+# =============================================================================
+
+
+class TestOperatorIndexedContraction:
+    """Tests for indexed contraction between Operators and Vectors."""
+
+    def test_operator_vector_contraction_preserves_output_grade(self):
+        """
+        Operator contraction should preserve output_spec.grade in result.
+
+        This is the key regression test: when an Operator with output_spec.grade=2
+        contracts with a Vector, the result must have grade=2, not grade=0.
+        """
+        g = euclidean_metric(3)
+
+        # Operator: maps grade-0 lot (N,) to grade-2 lot (M,)
+        M, N = 2, 3
+        O = Operator(
+            data=np.random.randn(M, N, 3, 3),  # shape (M, N, 3, 3)
+            input_spec=VectorSpec(grade=0, lot=(N,), dim=3),
+            output_spec=VectorSpec(grade=2, lot=(M,), dim=3),
+            metric=g,
+        )
+
+        # Input: grade-0 with lot (N,)
+        v = Vector(np.random.randn(N), grade=0, metric=g)
+
+        # Contract on "n" (the input lot index)
+        result = O["mnab"] * v["n"]
+
+        # Result should have: grade=2, lot=(M,)
+        assert result.grade == 2, f"Expected grade=2, got grade={result.grade}"
+        assert result.lot == (M,), f"Expected lot=(2,), got lot={result.lot}"
+        assert result.shape == (M, 3, 3)
+
+    def test_operator_lot_indexed_vector_contraction(self):
+        """Operator contraction via LotIndexed syntax also preserves grade."""
+        g = euclidean_metric(3)
+
+        M, N = 4, 5
+        O = Operator(
+            data=np.ones((M, N, 3, 3)),
+            input_spec=VectorSpec(grade=0, lot=(N,), dim=3),
+            output_spec=VectorSpec(grade=2, lot=(M,), dim=3),
+            metric=g,
+        )
+
+        # Input as grade-0 vector with lot
+        v = Vector(np.ones(N), grade=0, metric=g)
+
+        result = O["mnab"] * v["n"]
+
+        assert result.grade == 2
+        assert result.lot == (M,)
+        # Each element should be sum over N: N * 1 = 5
+        assert_allclose(result.data, np.ones((M, 3, 3)) * N)
+
+    def test_operator_vector_to_vector_contraction(self):
+        """Operator mapping grade-1 to grade-1 preserves grade in contraction."""
+        g = euclidean_metric(3)
+
+        M, N = 2, 3
+        # grade-1 -> grade-1 operator (outermorphism)
+        O = Operator(
+            data=np.eye(3).reshape(1, 1, 3, 3) * np.ones((M, N, 1, 1)),
+            input_spec=VectorSpec(grade=1, lot=(N,), dim=3),
+            output_spec=VectorSpec(grade=1, lot=(M,), dim=3),
+            metric=g,
+        )
+
+        v = Vector(np.ones((N, 3)), grade=1, metric=g)
+
+        result = O["mnab"] * v["nb"]
+
+        assert result.grade == 1
+        assert result.lot == (M,)
+        assert result.shape == (M, 3)

{morphis-0.10.0 → morphis-0.11.0}/src/morphis/elements/vector.py

@@ -375,9 +375,11 @@ class Vector(IndexableMixin, Tensor):
             return LotIndexed(self, indices)
         elif len(indices) == n_total:
             # Full indexing -> IndexedTensor
+            # All geometric indices (after lot) are "output geometric" for Vectors
             from morphis.algebra.contraction import IndexedTensor
 
-            return IndexedTensor(self, indices)
+            output_geo_indices = indices[n_lot:]
+            return IndexedTensor(self, indices, output_geo_indices=output_geo_indices)
         else:
             raise ValueError(
                 f"Index string '{indices}' has {len(indices)} indices, but expected "

{morphis-0.10.0 → morphis-0.11.0}/src/morphis/operations/operator.py

@@ -249,7 +249,13 @@ class Operator(IndexableMixin):
         """
         from morphis.algebra.contraction import IndexedTensor
 
-        return IndexedTensor(self, indices)
+        # Operator layout: (*out_lot, *in_lot, *out_geo, *in_geo)
+        # Output geometric indices start after lot dimensions
+        lot_end = self.output_spec.collection + self.input_spec.collection
+        out_geo_end = lot_end + self.output_spec.grade
+        output_geo_indices = indices[lot_end:out_geo_end]
+
+        return IndexedTensor(self, indices, output_geo_indices=output_geo_indices)
 
     def _slice(self, key):
         """