algebra

Algebraic interfaces and helpers used by Finch operators.

SingletonOperatorFType

Bases: ImmutableStructFType, FinchOperatorFType

A stateless callable type with one canonical operator value.

Source code in src/finch/algebra/algebra.py

class SingletonOperatorFType(ImmutableStructFType, FinchOperatorFType):
    """A stateless callable type with one canonical operator value."""

    @property
    @abstractmethod
    def operator(self) -> FinchOperator: ...

    @property
    def struct_name(self):
        return type(self).__name__.removeprefix("_").removesuffix("FType")

    @property
    def struct_fields(self):
        return []

    def from_fields(self):
        return self.operator

    def __call__(self, value):
        if ftype(value) == self:
            return value
        raise TypeError(f"Expected an operator of type {self}")

cansplitpush(op)

Whether a reduction can split-push through the same operator expression.

Source code in src/finch/algebra/algebra.py

def cansplitpush(op: FinchOperatorFType) -> bool:
    """Whether a reduction can split-push through the same operator expression."""
    return repeat_operator(op) is not None and is_commutative(op) and is_associative(op)

fixpoint_type(op, z, t)

Determines the fixpoint type after repeated calling the given operation.

Parameters:

Name	Type	Description	Default
op	CallableFType	The operation to evaluate.	required
z	Any	The initial value.	required
t	FType	The type to evaluate against.	required

Returns:

Type	Description
FType	The fixpoint type.

Source code in src/finch/algebra/algebra.py

def fixpoint_type(op: CallableFType, z: Any, t: FType) -> FType:
    """
    Determines the fixpoint type after repeated calling the given operation.

    Args:
        op: The operation to evaluate.
        z: The initial value.
        t: The type to evaluate against.

    Returns:
        The fixpoint type.
    """
    s = set()
    z_type = ftype(z)
    r = z_type
    while r not in s:
        s.add(r)
        r = return_type(op, z_type, t)
    return r

is_specializable_value(val)

A constant is only worth specializing on if some operator's identity or annihilator rule can fire against it; see SPECIALIZABLE_VALUES.

Source code in src/finch/algebra/algebra.py

def is_specializable_value(val: Any) -> bool:
    """
    A constant is only worth specializing on if some operator's identity or
    annihilator rule can fire against it; see `SPECIALIZABLE_VALUES`.
    """
    try:
        return any(bool(val == candidate) for candidate in SPECIALIZABLE_VALUES)
    except (TypeError, ValueError):
        return False

repeat_operator(op)

If there exists an operator g such that f(x, x, ..., x) (n times) is equal to g(x, n), then return g.

Source code in src/finch/algebra/algebra.py

def repeat_operator(op: FinchOperatorFType):
    """
    If there exists an operator g such that
    f(x, x, ..., x)  (n times)  is equal to g(x, n),
    then return g.
    """
    return op.repeat_operator()

type_max(type_)

Returns the maximum value of the given type.

Parameters:

Name	Type	Description	Default
type_	FDTypeOrdered	The type to determine the maximum value for.	required

Returns:

Type	Description
Any	The maximum value of the given type.

Raises:

Type	Description
AttributeError	If the maximum value is not implemented for the given type.

Source code in src/finch/algebra/algebra.py

def type_max(type_: FDTypeOrdered) -> Any:
    """
    Returns the maximum value of the given type.

    Args:
        type_: The type to determine the maximum value for.

    Returns:
        The maximum value of the given type.

    Raises:
        AttributeError: If the maximum value is not implemented for the given type.
    """
    return type_.type_max

type_min(type_)

Returns the minimum value of the given type.

Parameters:

Name	Type	Description	Default
type_	FDTypeOrdered	The type to determine the minimum value for.	required

Returns:

Type	Description
Any	The minimum value of the given type.

Raises:

Type	Description
AttributeError	If the minimum value is not implemented for the given type.

Source code in src/finch/algebra/algebra.py

def type_min(type_: FDTypeOrdered) -> Any:
    """
    Returns the minimum value of the given type.

    Args:
        type_: The type to determine the minimum value for.

    Returns:
        The minimum value of the given type.

    Raises:
        AttributeError: If the minimum value is not implemented for the given type.
    """
    return type_.type_min