Monoidal Structures¶

@abstractmethod
def product(self, a: SetObject, b: SetObject) -> SetObject:
    """The monoidal product A ⊗ B.

    Parameters
    ----------
    a : SetObject
        Left object.
    b : SetObject
        Right object.

    Returns
    -------
    SetObject
        The product object.
    """
    ...

@abstractmethod
def associator(self, a: SetObject, b: SetObject, c: SetObject) -> ObservedMorphism:
    """The associator (A ⊗ B) ⊗ C → A ⊗ (B ⊗ C).

    Parameters
    ----------
    a, b, c : SetObject
        Three objects.

    Returns
    -------
    ObservedMorphism
        The associator isomorphism.
    """
    ...

@abstractmethod
def left_unitor(self, a: SetObject) -> ObservedMorphism:
    """The left unitor I ⊗ A → A.

    Parameters
    ----------
    a : SetObject
        The object.

    Returns
    -------
    ObservedMorphism
        The left unitor isomorphism.
    """
    ...

@abstractmethod
def right_unitor(self, a: SetObject) -> ObservedMorphism:
    """The right unitor A ⊗ I → A.

    Parameters
    ----------
    a : SetObject
        The object.

    Returns
    -------
    ObservedMorphism
        The right unitor isomorphism.
    """
    ...

@abstractmethod
def braiding(self, a: SetObject, b: SetObject) -> ObservedMorphism:
    """The braiding A ⊗ B → B ⊗ A.

    Parameters
    ----------
    a, b : SetObject
        Two objects.

    Returns
    -------
    ObservedMorphism
        The braiding (swap) isomorphism.
    """
    ...

def product(self, a: SetObject, b: SetObject) -> ProductSet:
    """Cartesian product A × B."""
    return ProductSet(components=(a, b))

def associator(self, a: SetObject, b: SetObject, c: SetObject) -> ObservedMorphism:
    """(A × B) × C → A × (B × C).

    Since ProductSet flattens, both sides are ProductSet(A,B,C),
    so this is the identity morphism.
    """
    flat = ProductSet(components=(a, b, c))
    data = self._quantale.identity_tensor(flat.shape)
    return observed(flat, flat, data, quantale=self._quantale)

def left_unitor(self, a: SetObject) -> ObservedMorphism:
    """I × A → A (project out the unit component).

    The tensor maps (1, a₁, ..., aₙ) → (a₁, ..., aₙ).
    Since Unit has size 1, this is a "squeeze" that drops
    the trivial dimension.
    """
    source = ProductSet(components=(Unit, a))
    target = a
    data = torch.zeros(*source.shape, *target.shape)
    for idx in itertools.product(*(range(s) for s in target.shape)):
        src = (0,) + idx
        data[src + idx] = self._quantale.unit
    return observed(source, target, data, quantale=self._quantale)

def right_unitor(self, a: SetObject) -> ObservedMorphism:
    """A × I → A (project out the unit component).

    The tensor maps (a₁, ..., aₙ, 1) → (a₁, ..., aₙ).
    """
    source = ProductSet(components=(a, Unit))
    target = a
    data = torch.zeros(*source.shape, *target.shape)
    for idx in itertools.product(*(range(s) for s in target.shape)):
        src = idx + (0,)
        data[src + idx] = self._quantale.unit
    return observed(source, target, data, quantale=self._quantale)

def braiding(self, a: SetObject, b: SetObject) -> ObservedMorphism:
    """A × B → B × A (swap permutation).

    The tensor has shape (*a.shape, *b.shape, *b.shape, *a.shape)
    with unit on entries where the swap holds.
    """
    source = ProductSet(components=(a, b))
    target = ProductSet(components=(b, a))
    data = torch.full((*source.shape, *target.shape), self._quantale.zero)
    for a_idx in itertools.product(*(range(s) for s in a.shape)):
        for b_idx in itertools.product(*(range(s) for s in b.shape)):
            src = a_idx + b_idx
            tgt = b_idx + a_idx
            data[src + tgt] = self._quantale.unit
    return observed(source, target, data, quantale=self._quantale)

def product(self, a: SetObject, b: SetObject) -> CoproductSet:
    """Coproduct A + B."""
    return CoproductSet(components=(a, b))

def associator(self, a: SetObject, b: SetObject, c: SetObject) -> ObservedMorphism:
    """(A + B) + C → A + (B + C).

    Since CoproductSet flattens, both sides are CoproductSet(A,B,C),
    so this is the identity.
    """
    flat = CoproductSet(components=(a, b, c))
    data = self._quantale.identity_tensor(flat.shape)
    return observed(flat, flat, data, quantale=self._quantale)

def left_unitor(self, a: SetObject) -> ObservedMorphism:
    """∅ + A → A.

    Since ∅ has size 0, CoproductSet(∅, A) has the same size as A.
    The unitor is the identity (offset for A starts at 0).
    """
    source = CoproductSet(components=(EMPTY, a))
    target = a
    n = target.size
    data = torch.zeros(n, *target.shape)
    for i in range(n):
        idx = (i,)
        data[idx + idx] = self._quantale.unit
    return observed(source, target, data, quantale=self._quantale)

def right_unitor(self, a: SetObject) -> ObservedMorphism:
    """A + ∅ → A.

    Since ∅ has size 0, CoproductSet(A, ∅) has the same size as A.
    """
    source = CoproductSet(components=(a, EMPTY))
    target = a
    n = target.size
    data = torch.zeros(n, *target.shape)
    for i in range(n):
        idx = (i,)
        data[idx + idx] = self._quantale.unit
    return observed(source, target, data, quantale=self._quantale)

def braiding(self, a: SetObject, b: SetObject) -> ObservedMorphism:
    """A + B → B + A (block swap).

    Swaps the two coproduct components.
    """
    source = CoproductSet(components=(a, b))
    target = CoproductSet(components=(b, a))
    n_a = a.size
    n_b = b.size
    n = n_a + n_b
    data = torch.full((n, n), self._quantale.zero)
    for i in range(n_a):
        data[i, n_b + i] = self._quantale.unit
    for i in range(n_b):
        data[n_a + i, i] = self._quantale.unit
    return observed(source, target, data, quantale=self._quantale)