Morphisms¶

def __init__(
    self, domain: SetObject, codomain: SetObject, quantale: Quantale | None = None
) -> None:
    self._domain = domain
    self._codomain = codomain
    self._quantale = quantale if quantale is not None else PRODUCT_FUZZY

def __init__(
    self,
    domain: SetObject,
    codomain: SetObject,
    data: torch.Tensor,
    quantale: Quantale | None = None,
) -> None:
    super().__init__(domain, codomain, quantale=quantale)
    expected = self.tensor_shape
    if data.shape != expected:
        raise ValueError(
            f"data shape {data.shape} does not match expected {expected}"
        )
    self._module = _MorphismModule()
    self._module.register_buffer("data", data)

def __init__(
    self,
    domain: SetObject,
    codomain: SetObject,
    init_scale: float = 0.5,
    quantale: Quantale | None = None,
) -> None:
    super().__init__(domain, codomain, quantale=quantale)
    shape = self.tensor_shape
    self._module = _MorphismModule()
    raw = nn.Parameter(torch.randn(shape) * init_scale)
    self._module.register_parameter("raw", raw)

def __init__(self, left: Morphism, right: Morphism) -> None:
    n_contract = left.codomain.ndim
    super().__init__(left.domain, right.codomain, quantale=left._quantale)
    self._left = left
    self._right = right
    self._n_contract = n_contract

def __init__(self, left: Morphism, right: Morphism) -> None:
    domain = ProductSet(components=(left.domain, right.domain))
    codomain = ProductSet(components=(left.codomain, right.codomain))
    super().__init__(domain, codomain, quantale=left._quantale)
    self._left = left
    self._right = right

def __init__(
    self,
    inner: Morphism,
    sets_to_marginalize: tuple[SetObject, ...] | list[SetObject],
) -> None:
    codomain = inner.codomain
    sets_to_marginalize = tuple(sets_to_marginalize)
    if not isinstance(codomain, ProductSet):
        raise TypeError(
            f"can only marginalize over ProductSet codomain, got {type(codomain).__name__}"
        )
    n_domain = inner.domain.ndim
    remaining_components: list[SetObject] = []
    dims_to_reduce: list[int] = []
    offset = n_domain
    for component in codomain.components:
        if component in sets_to_marginalize:
            for d in range(component.ndim):
                dims_to_reduce.append(offset + d)
        else:
            remaining_components.append(component)
        offset += component.ndim
    if not dims_to_reduce:
        raise ValueError("none of the specified sets found in codomain components")
    if len(remaining_components) == 0:
        raise ValueError("cannot marginalize all codomain components")
    elif len(remaining_components) == 1:
        new_codomain = remaining_components[0]
    else:
        new_codomain = ProductSet(components=tuple(remaining_components))
    super().__init__(inner.domain, new_codomain, quantale=inner._quantale)
    self._inner = inner
    self._dims_to_reduce = tuple(dims_to_reduce)

def __init__(
    self, functor: Functor, inner: Morphism, domain: SetObject, codomain: SetObject
) -> None:
    super().__init__(domain, codomain, quantale=inner._quantale)
    self._functor = functor
    self._inner = inner

def __init__(self, inner: Morphism, n: int = 1) -> None:
    if inner.domain != inner.codomain:
        raise TypeError(
            f"repeat requires an endomorphism, got {inner.domain!r} -> {inner.codomain!r}"
        )
    if n < 1:
        raise ValueError(f"n must be >= 1, got {n}")
    super().__init__(inner.domain, inner.codomain, quantale=inner._quantale)
    self._inner = inner
    self._n = n
    self._n_contract = inner.codomain.ndim