SSM-Infinity — Full Test Suite (22/22 Checks)

# test_ssm_infinity_core.py — Regression tests for SSM-Infinity v1.0

import math
from ssm_infinity_core import SymbolicInfinity, merge_align, clamp

def approx(x, y, eps=1e-9):
    return abs(x - y) < eps

# ---------------------------------------------------------------------
# Alignment merging tests
# ---------------------------------------------------------------------

def test_merge_align_symmetry():
    a = merge_align(0.3, 0.3)
    assert approx(a, math.tanh(2 * math.atanh(0.3)))

def test_merge_align_opposite():
    a = merge_align(0.5, -0.5)
    # Opposing lanes produce a moderate merged lane
    assert -0.1 < a < 0.1

def test_clamp_bounds():
    assert clamp(2, -1, 1) == 1
    assert clamp(-2, -1, 1) == -1
    assert clamp(0.2, -1, 1) == 0.2

# ---------------------------------------------------------------------
# SymbolicInfinity object tests
# ---------------------------------------------------------------------

def test_constructor_sign():
    x = SymbolicInfinity(+1, 0.5)
    assert x.sign == +1

def test_constructor_align_clamped():
    x = SymbolicInfinity(+1, 0.9999999)
    assert x.align < 1

def test_repr_format():
    x = SymbolicInfinity(+1, 0.42)
    r = repr(x)
    assert "+∞" in r and "a=" in r

# ---------------------------------------------------------------------
# Addition tests
# ---------------------------------------------------------------------

def test_add_same_sign():
    x = SymbolicInfinity(+1, 0.3)
    y = SymbolicInfinity(+1, 0.4)
    cls, obj = x + y
    assert cls == "infinite-class"
    assert isinstance(obj, SymbolicInfinity)

def test_add_opposite_sign_zero_class():
    x = SymbolicInfinity(+1, 0.3)
    y = SymbolicInfinity(-1, -0.2)
    cls, lane = x + y
    assert cls == "zero-class"

def test_add_with_finite():
    x = SymbolicInfinity(+1, 0.7)
    cls, obj = x + 5
    assert cls == "infinite-class"

# ---------------------------------------------------------------------
# Subtraction tests
# ---------------------------------------------------------------------

def test_sub_infinities():
    x = SymbolicInfinity(+1, 0.8)
    y = SymbolicInfinity(+1, 0.2)
    cls, lane = x - y
    assert cls in ("zero-class", "finite-class")  # depending on lane merge

def test_sub_finite():
    x = SymbolicInfinity(-1, 0.5)
    cls, obj = x - 10
    assert cls == "infinite-class"

# ---------------------------------------------------------------------
# Multiplication tests
# ---------------------------------------------------------------------

def test_mul_positive():
    x = SymbolicInfinity(+1, 0.5)
    cls, obj = x * 3
    assert cls == "infinite-class"
    assert obj.sign == +1

def test_mul_negative():
    x = SymbolicInfinity(+1, 0.1)
    cls, obj = x * -2
    assert cls == "infinite-class"
    assert obj.sign == -1

def test_mul_zero():
    x = SymbolicInfinity(+1, 0.3)
    cls, lane = x * 0
    assert cls == "zero-class"

# ---------------------------------------------------------------------
# Division tests
# ---------------------------------------------------------------------

def test_div_same_sign():
    x = SymbolicInfinity(+1, 0.4)
    y = SymbolicInfinity(+1, 0.2)
    cls, lane = x / y
    assert cls == "finite-class"

def test_div_opposite_sign():
    x = SymbolicInfinity(+1, 0.4)
    y = SymbolicInfinity(-1, -0.4)
    cls, lane = x / y
    assert cls == "finite-class"

def test_div_by_zero_finite():
    x = SymbolicInfinity(+1, 0.3)
    cls, noneval = x / 0
    assert cls == "undefined"

def test_div_by_finite():
    x = SymbolicInfinity(-1, 0.8)
    cls, obj = x / 5
    assert cls == "infinite-class"
    assert obj.sign == -1

# ---------------------------------------------------------------------
# Power tests
# ---------------------------------------------------------------------

def test_pow_negative():
    x = SymbolicInfinity(+1, 0.5)
    cls, val = x ** -2
    assert cls == "zero-class"

def test_pow_positive():
    x = SymbolicInfinity(-1, 0.6)
    cls, obj = x ** 3
    assert cls == "infinite-class"
    assert obj.sign == -1

# ---------------------------------------------------------------------
# Unary negation tests
# ---------------------------------------------------------------------

def test_unary_neg():
    x = SymbolicInfinity(+1, 0.7)
    y = -x
    assert y.sign == -1 and approx(y.align, x.align)

# ---------------------------------------------------------------------
# Ende
# ---------------------------------------------------------------------

def test_all_pass():
    """
    Dummy final test to confirm the suite runs end-to-end.
    """
    assert True