gaia.core.universal_coalgebras module

Universal Coalgebras for GAIA Framework

Implements Section 3 from GAIA paper: “Backpropagation as an Endofunctor: Generative AI using Universal Coalgebras”

THEORETICAL FOUNDATIONS: - Definition 7: F-coalgebra (A, α) with structure map α: A → F(A) - Definition 9: Coalgebra homomorphisms with commutative diagrams - Definition 10: Bisimulations between coalgebras - Lambek’s Theorem: Final coalgebras as fixed points - Applications to generative AI, LLMs, diffusion models

This module provides the categorical foundation for all generative AI in GAIA.

class gaia.core.universal_coalgebras.Endofunctor

Bases: ABC, Generic[A]

Abstract base class for endofunctors F: C → C

From (MAHADEVAN,2024) Definition 7: Endofunctor required for F-coalgebras

abstractmethod apply(obj)

Apply functor to object: F(A) → F(A)

abstractmethod fmap(morphism)

Apply functor to morphism: F(f: A → B) → F(A) → F(B)

classmethod __class_getitem__(params)

Parameterizes a generic class.

At least, parameterizing a generic class is the main thing this method does. For example, for some generic class Foo, this is called when we do Foo[int] - there, with cls=Foo and params=int.

However, note that this method is also called when defining generic classes in the first place with class Foo(Generic[T]): ….

class gaia.core.universal_coalgebras.PowersetFunctor

Bases: Endofunctor[set]

Powerset functor F: S ⇒ P(S) From (MAHADEVAN,2024) Section 3.1

Models context-free grammars, finite state machines, and basic generative models.

apply(obj)

Return powerset P(S) = {A | A ⊆ S}

fmap(morphism)

Apply morphism to each element of powerset

classmethod __class_getitem__(params)

Parameterizes a generic class.

At least, parameterizing a generic class is the main thing this method does. For example, for some generic class Foo, this is called when we do Foo[int] - there, with cls=Foo and params=int.

However, note that this method is also called when defining generic classes in the first place with class Foo(Generic[T]): ….

class gaia.core.universal_coalgebras.StreamFunctor

Bases: Endofunctor[List]

Stream functor Str: Set → Set, Str(X) = ℕ × X from GAIA paper

Models infinite data streams for generative AI (LLMs, sequence models).

apply(obj)

Return (index, stream) pair

fmap(morphism)

Apply morphism to stream component

classmethod __class_getitem__(params)

Parameterizes a generic class.

At least, parameterizing a generic class is the main thing this method does. For example, for some generic class Foo, this is called when we do Foo[int] - there, with cls=Foo and params=int.

However, note that this method is also called when defining generic classes in the first place with class Foo(Generic[T]): ….

class gaia.core.universal_coalgebras.NeuralFunctor(activation_dim, bias_dim)

Bases: Endofunctor[<MockTorch name=’mock.Tensor’ id=’4349657872’>]

Neural network endofunctor for backpropagation coalgebras

Models F_B(X) = A × B × X From (MAHADEVAN,2024) Definition 11 where A = activations, B = biases, X = parameters

__init__(activation_dim, bias_dim)

apply(params)

Return (activations, biases, parameters) triple

fmap(morphism)

Apply morphism to parameter component

classmethod __class_getitem__(params)

Parameterizes a generic class.

At least, parameterizing a generic class is the main thing this method does. For example, for some generic class Foo, this is called when we do Foo[int] - there, with cls=Foo and params=int.

However, note that this method is also called when defining generic classes in the first place with class Foo(Generic[T]): ….

class gaia.core.universal_coalgebras.FCoalgebra(carrier, structure_map, endofunctor, name=None)

Bases: Generic[A]

F-coalgebra (A, α) From (MAHADEVAN,2024) Definition 7

Consists of: - carrier: Object A in category C - structure_map: Arrow α: A → F(A) defining dynamics

carrier: A

structure_map: Callable[[A], A]

endofunctor: Endofunctor[A]

name: str | None = None

evolve(state)

Evolve state using structure map α: A → F(A)

This is the core dynamics of the coalgebra - how states transition.

iterate(initial_state, steps)

Iterate coalgebra dynamics for multiple steps

Generates trajectory: state → α(state) → α²(state) → …

is_fixed_point(state, tolerance=1e-6)

Check if state is a fixed point: α(state) = state

Related to Lambek’s theorem for final coalgebras.

classmethod __class_getitem__(params)

Parameterizes a generic class.

At least, parameterizing a generic class is the main thing this method does. For example, for some generic class Foo, this is called when we do Foo[int] - there, with cls=Foo and params=int.

However, note that this method is also called when defining generic classes in the first place with class Foo(Generic[T]): ….

__init__(carrier, structure_map, endofunctor, name=None)

class gaia.core.universal_coalgebras.CoalgebraHomomorphism(source, target, morphism)

Bases: Generic[A, B]

Homomorphism between F-coalgebras From (MAHADEVAN,2024) Definition 9

Arrow f: A → B such that the diagram commutes: A –α–> F(A) | | f F(f) | | v v B –β–> F(B)

__init__(source, target, morphism)

apply(state)

Apply homomorphism to state

classmethod __class_getitem__(params)

Parameterizes a generic class.

At least, parameterizing a generic class is the main thing this method does. For example, for some generic class Foo, this is called when we do Foo[int] - there, with cls=Foo and params=int.

However, note that this method is also called when defining generic classes in the first place with class Foo(Generic[T]): ….

class gaia.core.universal_coalgebras.Bisimulation(coalgebra1, coalgebra2, relation)

Bases: Generic[A, B]

Bisimulation between coalgebras From (MAHADEVAN,2024) Definition 10

Relation R ⊆ S × T with structure map α_R: R → F(R) such that projections π₁, π₂ are homomorphisms.

Critical for comparing generative AI models (e.g., two LLMs).

__init__(coalgebra1, coalgebra2, relation)

are_bisimilar(state1, state2)

Check if two states are bisimilar

classmethod __class_getitem__(params)

Parameterizes a generic class.

At least, parameterizing a generic class is the main thing this method does. For example, for some generic class Foo, this is called when we do Foo[int] - there, with cls=Foo and params=int.

However, note that this method is also called when defining generic classes in the first place with class Foo(Generic[T]): ….

class gaia.core.universal_coalgebras.GenerativeCoalgebra(model, optimizer, loss_fn)

Bases: FCoalgebra[<MockTorch name=’mock.Tensor’ id=’4349657872’>]

Specialized coalgebra for generative AI models

Implements backpropagation as F-coalgebra From (MAHADEVAN,2024) Section 3.2

__init__(model, optimizer, loss_fn)

classmethod __class_getitem__(params)

Parameterizes a generic class.

At least, parameterizing a generic class is the main thing this method does. For example, for some generic class Foo, this is called when we do Foo[int] - there, with cls=Foo and params=int.

However, note that this method is also called when defining generic classes in the first place with class Foo(Generic[T]): ….

evolve(state)

Evolve state using structure map α: A → F(A)

This is the core dynamics of the coalgebra - how states transition.

is_fixed_point(state, tolerance=1e-6)

Check if state is a fixed point: α(state) = state

Related to Lambek’s theorem for final coalgebras.

iterate(initial_state, steps)

Iterate coalgebra dynamics for multiple steps

Generates trajectory: state → α(state) → α²(state) → …

name: str | None = None

carrier: A

structure_map: Callable[[A], A]

endofunctor: Endofunctor[A]

class gaia.core.universal_coalgebras.CoalgebraCategory

Bases: object

Category of F-coalgebras with homomorphisms as morphisms

Provides categorical structure for organizing generative AI models.

__init__()

add_coalgebra(name, coalgebra)

Add coalgebra as object in category

add_homomorphism(source_name, target_name, morphism)

Add homomorphism as morphism in category

compose_morphisms(first, second)

Compose two homomorphisms if composable

Implements categorical composition in coalgebra category.

find_bisimulations()

Find bisimulations between coalgebras in category

Critical for comparing different generative AI models.

gaia.core.universal_coalgebras.create_llm_coalgebra(model, optimizer, loss_fn)

Create coalgebra for Large Language Model

gaia.core.universal_coalgebras.create_diffusion_coalgebra(model, noise_schedule)

Create coalgebra for diffusion model

Models probabilistic coalgebra over ODEs from GAIA paper

gaia.core.universal_coalgebras.create_transformer_coalgebra(attention_heads, hidden_dim)

Create coalgebra for Transformer model

Will be extended with categorical transformer structure in later tasks.