Algebras and Coalgebras¶

@abstractmethod
def structure_map(self) -> Morphism:
    """The structure map α: T(A) → A.

    Returns
    -------
    Morphism
        The algebra structure map.
    """
    ...

def verify_unit_law(self, atol: float = 1e-5) -> bool:
    """Verify α ∘ η_A = id_A.

    Parameters
    ----------
    atol : float
        Absolute tolerance for comparison.

    Returns
    -------
    bool
        True if the unit law holds within tolerance.
    """
    alpha = self.structure_map()
    eta = self._monad.unit(self._carrier)
    result = (eta >> alpha).tensor
    expected = identity(self._carrier).tensor

    return torch.allclose(result, expected, atol=atol)

def verify_associativity(self, atol: float = 1e-5) -> bool:
    """Verify α ∘ μ_A = α ∘ T(α).

    Parameters
    ----------
    atol : float
        Absolute tolerance for comparison.

    Returns
    -------
    bool
        True if associativity holds within tolerance.
    """
    alpha = self.structure_map()
    mu = self._monad.multiply(self._carrier)

    # left side: α ∘ μ_A
    left = (mu >> alpha).tensor

    # right side: α ∘ T(α)
    t_alpha = self._monad.endofunctor.map_morphism(alpha)
    right = (t_alpha >> alpha).tensor

    return torch.allclose(left, right, atol=atol)

def structure_map(self) -> Morphism:
    """μ_A: T(T(A)) → T(A)."""
    return self._monad.multiply(self._base)

def structure_map(self) -> Morphism:
    """The stored structure map α: T(A) → A."""
    return self._morphism

@abstractmethod
def structure_map(self) -> Morphism:
    """The structure map γ: A → W(A).

    Returns
    -------
    Morphism
        The coalgebra structure map.
    """
    ...

def verify_counit_law(self, atol: float = 1e-5) -> bool:
    """Verify ε_A ∘ γ = id_A.

    Parameters
    ----------
    atol : float
        Absolute tolerance for comparison.

    Returns
    -------
    bool
        True if the counit law holds within tolerance.
    """

    gamma = self.structure_map()
    eps = self._comonad.counit(self._carrier)  # type: ignore[union-attr]
    result = (gamma >> eps).tensor
    expected = identity(self._carrier).tensor

    return torch.allclose(result, expected, atol=atol)

def verify_coassociativity(self, atol: float = 1e-5) -> bool:
    """Verify δ_A ∘ γ = W(γ) ∘ γ.

    Parameters
    ----------
    atol : float
        Absolute tolerance for comparison.

    Returns
    -------
    bool
        True if coassociativity holds within tolerance.
    """

    gamma = self.structure_map()
    delta = self._comonad.comultiply(self._carrier)  # type: ignore[union-attr]

    # left side: δ_A ∘ γ
    left = (gamma >> delta).tensor

    # right side: W(γ) ∘ γ
    w_gamma = self._comonad.endofunctor.map_morphism(gamma)  # type: ignore[union-attr]
    right = (gamma >> w_gamma).tensor

    return torch.allclose(left, right, atol=atol)

def structure_map(self) -> Morphism:
    """δ_A: W(A) → W(W(A))."""
    return self._comonad.comultiply(self._base)  # type: ignore[union-attr]

def structure_map(self) -> Morphism:
    """The stored structure map γ: A → W(A)."""
    return self._morphism

def free_algebra(self, obj: SetObject) -> FreeAlgebra:
    """Construct the free T-algebra on an object.

    Parameters
    ----------
    obj : SetObject
        The base object A.

    Returns
    -------
    FreeAlgebra
        The free algebra with carrier T(A).
    """
    return FreeAlgebra(self._monad, obj)

def is_homomorphism(
    self,
    f: Morphism,
    source_alg: Algebra,
    target_alg: Algebra,
    atol: float = 1e-5,
) -> bool:
    """Check if f: A → B is an algebra homomorphism.

    Verifies β ∘ T(f) = f ∘ α.

    Parameters
    ----------
    f : Morphism
        A morphism A → B between the carriers.
    source_alg : Algebra
        The source algebra (A, α).
    target_alg : Algebra
        The target algebra (B, β).
    atol : float
        Absolute tolerance for comparison.

    Returns
    -------
    bool
        True if f is a homomorphism within tolerance.
    """
    alpha = source_alg.structure_map()
    beta = target_alg.structure_map()
    tf = self._monad.endofunctor.map_morphism(f)

    # left: β ∘ T(f)
    left = (tf >> beta).tensor

    # right: f ∘ α
    right = (alpha >> f).tensor

    return torch.allclose(left, right, atol=atol)