Distributive Laws

Distributive laws between monads and comonads.

distributive_laws

Distributive laws for composing monads.

A distributive law λ: S ∘ T ⇒ T ∘ S between monads S and T allows their composition T ∘ S to form a new monad. The component λ_A: S(T(A)) → T(S(A)) "pushes S past T."

This module provides:

DistributiveLaw (abstract)
└── FreeMonoidPowersetLaw — λ: Free(P(A)) → P(Free(A))

DistributiveLaw

Bases: ABC

Abstract distributive law λ: S ∘ T ⇒ T ∘ S.

Subclasses must implement outer_monad, inner_monad, and distribute.

outer_monad abstractmethod property

outer_monad: Monad

The outer monad S (applied second in S ∘ T).

inner_monad abstractmethod property

inner_monad: Monad

The inner monad T (applied first in S ∘ T).

distribute abstractmethod

distribute(obj: SetObject) -> Morphism

The component λ_A: S(T(A)) → T(S(A)).

PARAMETER	DESCRIPTION
obj	The object A. TYPE: SetObject

RETURNS	DESCRIPTION
Morphism	The distributive morphism λ_A.

Source code in src/quivers/monadic/distributive_laws.py

@abstractmethod
def distribute(self, obj: SetObject) -> Morphism:
    """The component λ_A: S(T(A)) → T(S(A)).

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

    Returns
    -------
    Morphism
        The distributive morphism λ_A.
    """
    ...

FreeMonoidPowersetLaw

FreeMonoidPowersetLaw(max_length: int, algebra: Algebra | None = None)

Bases: DistributiveLaw

Distributive law λ: Free(P(A)) → P(Free(A)).

A word of fuzzy sets (S₁, ..., Sₖ) in Free(P(A)) maps to a fuzzy set of words in P(Free(A)) with membership:

λ(S₁,...,Sₖ)(a₁,...,aₖ) = ⊗ᵢ Sᵢ(aᵢ)

This is exactly the componentwise lift (the functorial action of FreeMonoid on morphisms). The distributive law witnesses the fact that "a word of fuzzy sets" can be reinterpreted as "a fuzzy set of words" via the product t-norm.

PARAMETER	DESCRIPTION
max_length	Maximum string length for the free monoid. TYPE: int
algebra	The enrichment algebra. Defaults to PRODUCT_FUZZY. TYPE: Algebra or None DEFAULT: None

Source code in src/quivers/monadic/distributive_laws.py

def __init__(
    self,
    max_length: int,
    algebra: Algebra | None = None,
) -> None:
    self._max_length = max_length
    self._algebra = algebra if algebra is not None else PRODUCT_FUZZY
    self._powerset = FuzzyPowersetMonad(algebra=self._algebra)
    self._free_monoid = FreeMonoidMonad(max_length)

outer_monad property

outer_monad: FreeMonoidMonad

The free monoid monad (applied to P(A)).

inner_monad property

inner_monad: FuzzyPowersetMonad

The fuzzy powerset monad (applied to A).

distribute

distribute(obj: SetObject) -> Morphism

λ_A: Free(P(A)) → P(Free(A)) = Free(A) (at set level).

Since P is identity at set level, Free(P(A)) = Free(A) = A. And P(Free(A)) = Free(A) = A (also identity at set level). So λ_A: A → A is an endomorphism.

The tensor is the block-diagonal matrix built from componentwise_lift — which is exactly the FreeMonoidFunctor's action on the identity morphism A → A.

PARAMETER	DESCRIPTION
obj	Must be a FinSet. TYPE: SetObject

RETURNS	DESCRIPTION
ObservedMorphism	The distributive law component λ_A.

Source code in src/quivers/monadic/distributive_laws.py

def distribute(self, obj: SetObject) -> Morphism:
    """λ_A: Free(P(A)) → P(Free(A)) = Free(A) (at set level).

    Since P is identity at set level, Free(P(A)) = Free(A) = A*.
    And P(Free(A)) = Free(A) = A* (also identity at set level).
    So λ_A: A* → A* is an endomorphism.

    The tensor is the block-diagonal matrix built from
    componentwise_lift — which is exactly the FreeMonoidFunctor's
    action on the identity morphism A → A.

    Parameters
    ----------
    obj : SetObject
        Must be a FinSet.

    Returns
    -------
    ObservedMorphism
        The distributive law component λ_A.
    """
    if not isinstance(obj, FinSet):
        raise TypeError(
            f"FreeMonoidPowersetLaw requires FinSet, got {type(obj).__name__}"
        )

    fm = FreeMonoid(generators=obj, max_length=self._max_length)

    # the distributive law at the tensor level is the block-diagonal
    # identity: for each stratum k, the k-fold componentwise lift
    # of id_A is id_{A^k}
    n = obj.cardinality
    id_tensor = torch.eye(n)

    blocks: list[torch.Tensor] = []

    for k in range(self._max_length + 1):
        lifted = componentwise_lift(id_tensor, k, algebra=self._algebra)
        rows = n**k if k > 0 else 1
        cols = n**k if k > 0 else 1
        blocks.append(lifted.reshape(rows, cols))

    data = torch.block_diag(*blocks)

    return observed(fm, fm, data, algebra=self._algebra)