Monads¶

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

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

    Returns
    -------
    Morphism
        The unit morphism η_A.
    """
    ...

@abstractmethod
def multiply(self, obj: SetObject) -> Morphism:
    """The multiplication component μ_A: T(T(A)) → T(A).

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

    Returns
    -------
    Morphism
        The multiplication morphism μ_A.
    """
    ...

def kleisli_compose(self, f: Morphism, g: Morphism) -> Morphism:
    """Kleisli composition: f >=> g = μ_C ∘ T(g) ∘ f.

    For f: A → T(B) and g: B → T(C), produces A → T(C).

    Parameters
    ----------
    f : Morphism
        Left Kleisli morphism A → T(B).
    g : Morphism
        Right Kleisli morphism B → T(C).

    Returns
    -------
    Morphism
        Composed Kleisli morphism A → T(C).
    """
    tg = self.endofunctor.map_morphism(g)
    f_then_tg = f >> tg
    mu = self._multiply_at_codomain(g)
    return f_then_tg >> mu

def identity(self, obj: SetObject) -> Morphism:
    """Kleisli identity at object A: η_A: A → T(A).

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

    Returns
    -------
    Morphism
        The Kleisli identity morphism.
    """
    return self._monad.unit(obj)

def compose(self, f: Morphism, g: Morphism) -> Morphism:
    """Kleisli composition: f >=> g.

    Parameters
    ----------
    f : Morphism
        Left morphism A → T(B).
    g : Morphism
        Right morphism B → T(C).

    Returns
    -------
    Morphism
        Composed morphism A → T(C).
    """
    return self._monad.kleisli_compose(f, g)

def unit(self, obj: SetObject) -> Morphism:
    """η_A = identity(A): Kronecker delta."""
    return identity(obj, quantale=self._quantale)

def multiply(self, obj: SetObject) -> Morphism:
    """μ_A = identity(A): union of fuzzy sets."""
    return identity(obj, quantale=self._quantale)

def kleisli_compose(self, f: Morphism, g: Morphism) -> Morphism:
    """Kleisli composition = V-enriched composition via >>."""
    return f >> g

def unit(self, obj: SetObject) -> Morphism:
    """η_A: A → A* embeds each element as a length-1 word.

    The tensor has shape (|A|, |A*|) with 1 at positions
    (a, offset_1 + a) and 0 elsewhere.
    """
    if not isinstance(obj, FinSet):
        raise TypeError(
            f"FreeMonoidMonad.unit requires FinSet, got {type(obj).__name__}"
        )
    fm = FreeMonoid(generators=obj, max_length=self._max_length)
    n = obj.cardinality
    data = torch.zeros(n, fm.size)
    offset = fm.offset(1)
    for a in range(n):
        data[a, offset + a] = 1.0
    return observed(obj, fm, data)

def multiply(self, obj: SetObject) -> Morphism:
    """μ_A: (A*)* → A* flattens nested words by concatenation.

    A word in (A*)* at stratum k is a k-tuple of words in A*.
    Flattening concatenates them. If the total length exceeds
    max_length, the entry is 0 (truncation).
    """
    if not isinstance(obj, FinSet):
        raise TypeError(
            f"FreeMonoidMonad.multiply requires FinSet, got {type(obj).__name__}"
        )
    fm_a = FreeMonoid(generators=obj, max_length=self._max_length)
    fm_fm_a = FreeMonoid(
        generators=FinSet(name=f"{obj.name}*", cardinality=fm_a.size),
        max_length=self._max_length,
    )
    data = torch.zeros(fm_fm_a.size, fm_a.size)
    for i in range(fm_fm_a.size):
        outer_word = fm_fm_a.decode(i)
        inner_words: list[tuple[int, ...]] = []
        for idx in outer_word:
            inner_words.append(fm_a.decode(idx))
        flat: tuple[int, ...] = ()
        for w in inner_words:
            flat = flat + w
        if len(flat) <= self._max_length:
            j = fm_a.encode(flat)
            data[i, j] = 1.0
    return observed(fm_fm_a, fm_a, data)

def kleisli_compose(self, f: Morphism, g: Morphism) -> Morphism:
    """Kleisli composition: f >=> g = μ_C ∘ T(g) ∘ f."""
    tg = self._functor.map_morphism(g)
    f_then_tg = f >> tg
    mu = self._multiply_at_codomain(g)
    return f_then_tg >> mu