Commutation 1.5.0__tar.gz → 1.5.1__tar.gz

{commutation-1.5.0/src/Commutation.egg-info → commutation-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Commutation
-Version: 1.5.0
+Version: 1.5.1
 Summary: A small package for doing commutator algebra
 Author-email: Alaric Sanders <thathatatt@gmail.com>
 Project-URL: Homepage, https://github.com/Spuriosity1/Commutation
@@ -12,6 +12,8 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ipython
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
 Dynamic: license-file
 
 # Commutation Station for Operator Elimination

{commutation-1.5.0 → commutation-1.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "Commutation"
-version = "1.5.0"
+version = "1.5.1"
 requires-python = ">= 3.8"
 authors = [
 	{name = "Alaric Sanders", email="thathatatt@gmail.com"}
@@ -23,6 +23,9 @@ dependencies = [
   "ipython",
 ]
 
+[project.optional-dependencies]
+test = ["pytest"]
+
 [project.urls]
 Homepage = "https://github.com/Spuriosity1/Commutation"
 Issues = "https://github.com/Spuriosity1/Commutation/issues"
@@ -33,3 +36,9 @@ package-dir = {"" = "src"}
 
 [tool.setuptools.packages.find]
 where = ["src"]
+
+[tool.pytest.ini_options]
+# allows `pytest` from the repo root without installing the package first
+# (tox installs it, but this keeps the local dev loop simple)
+pythonpath = ["src"]
+testpaths = ["tests"]

{commutation-1.5.0 → commutation-1.5.1/src/Commutation.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Commutation
-Version: 1.5.0
+Version: 1.5.1
 Summary: A small package for doing commutator algebra
 Author-email: Alaric Sanders <thathatatt@gmail.com>
 Project-URL: Homepage, https://github.com/Spuriosity1/Commutation
@@ -12,6 +12,8 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ipython
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
 Dynamic: license-file
 
 # Commutation Station for Operator Elimination

{commutation-1.5.0 → commutation-1.5.1}/src/Commutation.egg-info/SOURCES.txt

@@ -9,4 +9,9 @@ src/Commutation.egg-info/top_level.txt
 src/commutation/__init__.py
 src/commutation/commutatoralgebra.py
 src/commutation/expression.py
-src/commutation/style.py
+src/commutation/style.py
+tests/test_anticommutator.py
+tests/test_commutator.py
+tests/test_expression.py
+tests/test_operator.py
+tests/test_term.py

commutation-1.5.1/src/Commutation.egg-info/requires.txt

@@ -0,0 +1,4 @@
+ipython
+
+[test]
+pytest

{commutation-1.5.0 → commutation-1.5.1}/src/commutation/commutatoralgebra.py

@@ -156,8 +156,9 @@ class CommutatorAlgebra(AbstractCommutatorAlgebra):
         B = term.ops[i-1]
         front = Term(*term.ops[:i-1])
         back = Term(*term.ops[i+1:])
- 
-        c = self.get_commutator(A, B)
+
+        # reordering B*A -> A*B picks up [B, A] = -[A, B]
+        c = self.get_commutator(B, A)
         extra = front * c * back * term.multiplier
         
         term.ops[i-1], term.ops[i] = term.ops[i], term.ops[i-1]
@@ -215,8 +216,11 @@ class AntiCommutatorAlgebra(AbstractCommutatorAlgebra):
         front = Term(*term.ops[:i])
         back = Term(*term.ops[i+2:])
     
-        c = self.get_anticommutator(
-            term.ops[i], term.ops[i+1])
+        A = term.ops[i]
+        B = term.ops[i+1]
+        c = self.get_anticommutator(A, B)
+        if c is None:
+            raise AntiCommutatorUnknownException(A, B)
         extra = Expression(front) * \
             c * Expression(back)*term.multiplier
         term.multiplier *= -1

commutation-1.5.1/tests/test_anticommutator.py

@@ -0,0 +1,54 @@
+"""Tests for AntiCommutatorAlgebra.
+
+Anticommutator support is newer than the commutator path (see TODO.md), so
+these focus on the basics plus two documented rough edges.
+"""
+import pytest
+
+from commutation import (
+    Operator,
+    Expression,
+    AntiCommutatorAlgebra,
+    AntiCommutatorUnknownException,
+)
+
+
+def _algebra():
+    """Two fermion-like modes with {f1, f2} = 0."""
+    f1, f2 = Operator("f1"), Operator("f2")
+    ac = AntiCommutatorAlgebra()
+    ac.set_anticommutator(f1, f2)(0)
+    return ac, f1, f2
+
+
+def test_set_anticommutator_is_symmetric():
+    ac, f1, f2 = _algebra()
+    assert ac.relations["f1"]["f2"] == ac.relations["f2"]["f1"]
+
+
+def test_diagonal_defaults_to_twice_the_operator():
+    ac, f1, f2 = _algebra()
+    assert ac.relations["f1"]["f1"] == 2 * f1
+
+
+def test_move_right_flips_sign_on_swap():
+    # f1*f2 -> -f2*f1 + {f1, f2} = -f2*f1   (since {f1, f2} = 0)
+    ac, f1, f2 = _algebra()
+    e = Expression(f1 * f2)
+    ac.move_right(e, f1)
+    e.collect()
+    assert e == -1 * (f2 * f1)
+
+
+def test_move_left_unknown_raises_friendly_exception():
+    ac, f1, f2 = _algebra()
+    g = Operator("g")  # unregistered
+    with pytest.raises(AntiCommutatorUnknownException):
+        ac.move_left(Expression(g * f1), f1)
+
+
+def test_move_right_unknown_raises_friendly_exception():
+    ac, f1, f2 = _algebra()
+    g = Operator("g")  # unregistered
+    with pytest.raises(AntiCommutatorUnknownException):
+        ac.move_right(Expression(f1 * g), f1)

commutation-1.5.1/tests/test_commutator.py

@@ -0,0 +1,132 @@
+"""Tests for CommutatorAlgebra: relation storage and operator reordering.
+
+These cover the TODO's "some well known commutator reductions" item using the
+SU(2) spin algebra  [az, ap] = ap,  [az, am] = -am,  [ap, am] = 2 az.
+"""
+import warnings
+
+import pytest
+
+from commutation import (
+    Operator,
+    Scalar,
+    Expression,
+    CommutatorAlgebra,
+    CommutatorUnknownException,
+)
+
+
+# --------------------------------------------------------------------------
+# relation storage
+# --------------------------------------------------------------------------
+def test_set_commutator_stores_antisymmetric_partner(spin):
+    ca, az, ap, am = spin
+    assert ca.relations["ap"]["am"] == 2 * az
+    assert ca.relations["am"]["ap"] == -2 * az
+
+
+def test_get_commutator_scalar_is_zero(spin):
+    ca, az, ap, am = spin
+    K = Scalar("K")
+    assert ca.get_commutator(K, az) == 0
+    assert ca.get_commutator(az, K) == 0
+
+
+def test_get_commutator_unknown_warns_and_assumes_commute(spin):
+    ca, az, ap, am = spin
+    unknown = Operator("unknown")
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        result = ca.get_commutator(unknown, az)
+    assert result == 0
+    assert any(issubclass(x.category, UserWarning) for x in w)
+
+
+def test_strict_mode_raises_for_unknown():
+    az, ap = Operator("az"), Operator("ap")
+    ca = CommutatorAlgebra(strict=True)
+    ca.set_commutator(az, ap)(ap)
+    am = Operator("am")  # never registered
+    with pytest.raises(CommutatorUnknownException):
+        ca.move_right(Expression(az * ap * am), az)
+
+
+# --------------------------------------------------------------------------
+# elementary reductions
+# --------------------------------------------------------------------------
+def test_move_right_single_swap(spin):
+    # ap*az -> az*ap + [ap, az] = az*ap - ap
+    ca, az, ap, am = spin
+    e = Expression(ap * az)
+    ca.move_right(e, ap)
+    e.collect()
+    assert e == az * ap - ap
+
+
+def test_move_right_noop_when_already_rightmost(spin):
+    # az is already at the right end; nothing to move past.
+    ca, az, ap, am = spin
+    e = Expression(ap * az)
+    ca.move_right(e, az)
+    e.collect()
+    assert e == ap * az
+
+
+def test_move_right_readme_example(spin):
+    ca, az, ap, am = spin
+    e = Expression(az * ap * az * az * am)
+    ca.move_right(e, az)
+    e.collect()
+    assert e == ap * am * az * az * az - 2 * ap * am * az * az + ap * am * az
+
+
+def test_scalars_commute_through(spin):
+    ca, az, ap, am = spin
+    KA = Scalar("KA")
+    e = Expression(az * ap * am * KA * am)
+    ca.move_right(e, az)
+    e.collect()
+    assert e == ap * am * KA * am * az - ap * am * KA * am
+
+
+def test_unknown_operator_during_move_warns(spin):
+    ca, az, ap, am = spin
+    c = Operator("c")  # not in the database
+    e = Expression(az * ap * am * c * am)
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter("always")
+        ca.move_right(e, az)
+    e.collect()
+    assert any(issubclass(x.category, UserWarning) for x in w)
+    assert e == ap * am * c * am * az - ap * am * c * am
+
+
+# --------------------------------------------------------------------------
+# move_left
+# --------------------------------------------------------------------------
+def test_move_left_single_swap(spin):
+    # ap*az -> az*ap + [ap, az] = az*ap - ap
+    ca, az, ap, am = spin
+    e = Expression(ap * az)
+    ca.move_left(e, az)
+    e.collect()
+    assert e == az * ap - ap
+
+
+def test_move_left_readme_example(spin):
+    ca, az, ap, am = spin
+    e = Expression(az * ap * az * az * am)
+    ca.move_left(e, am)
+    e.collect()
+    expected = (
+        am * az * ap * az * az
+        - 2 * am * az * ap * az
+        + 2 * az * az * az * az
+        - am * ap * az * az
+        + am * az * ap
+        - 4 * az * az * az
+        + 2 * am * ap * az
+        + 2 * az * az
+        - am * ap
+    )
+    assert e == expected

commutation-1.5.1/tests/test_expression.py

@@ -0,0 +1,149 @@
+"""Tests for the Expression abelian-group / CAS operations."""
+from fractions import Fraction
+
+import pytest
+
+from commutation import Operator, Term, Expression
+
+
+def test_construction_drops_zeros():
+    a = Operator("a")
+    e = Expression(a, 0, Term(a))
+    assert len(e.terms) == 2
+
+
+def test_empty_expression():
+    assert Expression().terms == []
+
+
+def test_add_sub_neg():
+    a, b = Operator("a"), Operator("b")
+    assert (a + b) - b == a
+    assert -(a + b) == Expression(-Term(a), -Term(b))
+
+
+def test_mul_distributes():
+    a, b, c = Operator("a"), Operator("b"), Operator("c")
+    e = (a + b) * c
+    assert e == a * c + b * c
+
+
+def test_scalar_mul():
+    a, b = Operator("a"), Operator("b")
+    assert 2 * (a + b) == (2 * a) + (2 * b)
+
+
+def test_collect_folds_like_terms():
+    a = Operator("a")
+    e = Expression(a) + Expression(a) - Expression(a)
+    e.collect()
+    assert len(e.terms) == 1
+    assert e.terms[0].multiplier == 1
+
+
+def test_collect_drops_zero_terms():
+    a = Operator("a")
+    e = a - a
+    e.collect()
+    assert e.terms == []
+
+
+def test_sort_strategies():
+    a, b, c = Operator("a"), Operator("b"), Operator("c")
+    e = Expression(c) + a + b
+    e.sort("first")
+    assert [str(t.ops[0]) for t in e.terms] == ["a", "b", "c"]
+
+
+def test_operators_property():
+    a, b, c = Operator("a"), Operator("b"), Operator("c")
+    assert (a * b + c).operators == {"a", "b", "c"}
+
+
+def test_order_property():
+    a, b, c = Operator("a"), Operator("b"), Operator("c")
+    assert (a * b * c + a).order == 3
+
+
+def test_is_scalar_property():
+    from commutation import Scalar
+    a = Operator("a")
+    K = Scalar("K")
+    assert (K + K).is_scalar is True
+    assert (a + K).is_scalar is False
+
+
+def test_eq_is_algebraic():
+    a, b = Operator("a"), Operator("b")
+    assert (a + b) == (b + a)  # collect ignores term order for matching keys
+    assert (a + a) == (2 * a)
+    assert (a + b) != (a + a)
+
+
+def test_substitute_readme_example():
+    a, b, c, d = (Operator(x) for x in "abcd")
+    x = a * b * b * b * a * c * a * a * c * a * b + 1
+    y = x.substitute(a * b, c + d)
+    expected = (
+        c * b * b * a * c * a * a * c * c
+        + c * b * b * a * c * a * a * c * d
+        + d * b * b * a * c * a * a * c * c
+        + d * b * b * a * c * a * a * c * d
+        + 1
+    )
+    assert y == expected
+
+
+def test_substitute_preserves_multiplier():
+    a, b, c = Operator("a"), Operator("b"), Operator("c")
+    assert Expression(3 * a * b).substitute(a * b, c) == 3 * c
+
+
+def test_sub_is_alias_for_substitute():
+    a, b, c = Operator("a"), Operator("b"), Operator("c")
+    e = Expression(a * b)
+    assert e.sub(a * b, c) == e.substitute(a * b, c)
+
+
+def test_replaceall():
+    a, b, c = Operator("a"), Operator("b"), Operator("c")
+    assert Expression(a * b * a * b).replaceall((a * b, c)) == c * c
+
+
+def test_factor_no_x_right():
+    a, b, c, d = (Operator(x) for x in "abcd")
+    xx = 7 * a * b * b + Fraction(4, 5) * a * c * b * b + a * d * b * b
+    front, back = xx.factor("right")
+    assert front * back == xx
+    assert front == Term(a)
+
+
+def test_factor_no_x_left():
+    a, b, c, d = (Operator(x) for x in "abcd")
+    xx = 7 * a * b * b + Fraction(4, 5) * a * c * b * b + a * d * b * b
+    front, back = xx.factor()  # default side = left
+    assert front * back == xx
+    assert back == Term(b, b)
+
+
+def test_factor_explicit_x():
+    a, b, c = Operator("a"), Operator("b"), Operator("c")
+    front, back = (a * b + a * c).factor("right", a)
+    assert front == Term(a)
+    assert back == b + c
+    assert front * back == (a * b + a * c)
+
+
+def test_coefficient():
+    a, b, c = Operator("a"), Operator("b"), Operator("c")
+    assert (a * b + a * c).coefficient(a, "right") == b + c
+
+
+def test_as_latex_fraction():
+    a = Operator("a")
+    assert (Fraction(4, 5) * Term(a)).as_latex() == r"+\frac{4}{5} a"
+
+
+def test_from_str_not_implemented():
+    with pytest.raises(NotImplementedError):
+        Expression().from_str("a + b")

commutation-1.5.1/tests/test_operator.py

@@ -0,0 +1,85 @@
+"""Tests for the Operator / Scalar primitives."""
+import pytest
+
+from commutation import Operator, Scalar, Term, Expression
+
+
+def test_name_must_be_str():
+    with pytest.raises(TypeError):
+        Operator(123)
+
+
+def test_latex_must_be_str():
+    with pytest.raises(TypeError):
+        Operator("a", 123)
+
+
+def test_latex_defaults_to_name():
+    a = Operator("a")
+    assert a.as_latex() == "a"
+
+
+def test_latex_string_used_when_given():
+    a = Operator("a", "S^z_a")
+    assert a.as_latex() == "S^z_a"
+
+
+def test_str_and_repr_are_name():
+    a = Operator("a")
+    assert str(a) == "a"
+    assert repr(a) == "a"
+
+
+def test_mul_by_int_gives_term():
+    a = Operator("a")
+    t = a * 3
+    assert isinstance(t, Term)
+    assert t.multiplier == 3
+    assert t.ops == [a]
+
+
+def test_rmul_by_int_gives_term():
+    a = Operator("a")
+    t = 3 * a
+    assert isinstance(t, Term)
+    assert t.multiplier == 3
+
+
+def test_mul_by_operator_gives_term():
+    a, b = Operator("a"), Operator("b")
+    t = a * b
+    assert isinstance(t, Term)
+    assert t.ops == [a, b]
+
+
+def test_add_gives_expression():
+    a, b = Operator("a"), Operator("b")
+    e = a + b
+    assert isinstance(e, Expression)
+    assert len(e.terms) == 2
+
+
+def test_neg_gives_term_with_negative_multiplier():
+    a = Operator("a")
+    t = -a
+    assert isinstance(t, Term)
+    assert t.multiplier == -1
+
+
+def test_eq_is_algebraic():
+    a, b = Operator("a"), Operator("b")
+    assert a == a
+    assert a != b
+    assert a == Term(a)
+    assert (a - a) == 0
+
+
+def test_scalar_sets_flag():
+    assert Scalar("K").is_scalar is True
+    assert Operator("a").is_scalar is False
+
+
+def test_subtraction_of_operators():
+    a, b = Operator("a"), Operator("b")
+    e = a - b
+    assert e == Expression(Term(a), -Term(b))

commutation-1.5.1/tests/test_term.py

@@ -0,0 +1,114 @@
+"""Tests for the Term monoid."""
+from fractions import Fraction
+
+import pytest
+
+from commutation import Operator, Scalar, Term
+
+
+def test_construction_products_operators_and_scalars():
+    a, b = Operator("a"), Operator("b")
+    t = Term(2, a, 3, b)
+    assert t.multiplier == 6
+    assert t.ops == [a, b]
+
+
+def test_identity_term_is_empty():
+    t = Term()
+    assert t.multiplier == 1
+    assert t.ops == []
+    assert len(t) == 0
+
+
+def test_nested_term_flattens():
+    a, b = Operator("a"), Operator("b")
+    t = Term(Term(2, a), Term(3, b))
+    assert t.multiplier == 6
+    assert t.ops == [a, b]
+
+
+def test_bad_type_raises():
+    with pytest.raises(TypeError):
+        Term(1.5)  # float is not allowed, only int / Fraction / Operator
+
+
+def test_is_scalar():
+    a = Operator("a")
+    assert Term(Scalar("K"), Scalar("J")).is_scalar is True
+    assert Term(a).is_scalar is False
+
+
+def test_order_sign_len():
+    a, b = Operator("a"), Operator("b")
+    t = -2 * Term(a, b)
+    assert t.order == 2
+    assert len(t) == 2
+    assert t.sign == -1
+    assert (2 * Term(a)).sign == 1
+
+
+def test_mul_rmul_truediv():
+    a, b = Operator("a"), Operator("b")
+    assert (Term(a) * b).ops == [a, b]
+    assert (b * Term(a)).ops == [b, a]
+    assert (Term(a) * 4).multiplier == 4
+    assert (Term(4, a) / 2).multiplier == Fraction(2, 1)
+
+
+def test_neg_copies():
+    a = Operator("a")
+    t = Term(a)
+    n = -t
+    assert n.multiplier == -1
+    assert t.multiplier == 1  # original untouched
+
+
+def test_factor_scalars():
+    a = Operator("a")
+    K = Scalar("K")
+    scal, ops = Term(3, K, a).factor_scalars()
+    assert scal == Term(3, K)
+    assert ops == Term(a)
+
+
+def test_move_scalars_left_and_right():
+    a, b = Operator("a"), Operator("b")
+    K = Scalar("K")
+
+    left = Term(a, K, b)
+    left.move_scalars("left")
+    assert [str(o) for o in left.ops] == ["K", "a", "b"]
+
+    right = Term(a, K, b)
+    right.move_scalars("right")
+    assert [str(o) for o in right.ops] == ["a", "b", "K"]
+
+
+def test_move_scalars_bad_side():
+    a = Operator("a")
+    with pytest.raises(IndexError):
+        Term(a).move_scalars("sideways")
+
+
+def test_findall_non_overlapping():
+    a, b = Operator("a"), Operator("b")
+    assert Term(a, a, a).findall(Term(a, a)) == [0]
+    assert Term(a, a, a, a).findall(Term(a, a)) == [0, 2]
+    assert Term(a, b, a, b).findall(Term(a, b)) == [0, 2]
+    assert Term(a, b).findall(Term(b, a)) == []
+
+
+def test_eq():
+    a, b = Operator("a"), Operator("b")
+    assert Term(2, a, b) == Term(2, a, b)
+    assert Term(2, a, b) != Term(3, a, b)
+    assert Term(a, b) != Term(b, a)
+    assert Term(a) != "a"
+
+
+def test_copy_is_independent():
+    a = Operator("a")
+    t = Term(a)
+    c = t.copy()
+    c.multiplier = 5
+    assert t.multiplier == 1

commutation-1.5.0/src/Commutation.egg-info/requires.txt

@@ -1 +0,0 @@
-ipython