API Reference

Complete API documentation for all Asgard classes and functions.

Full reference: See the detailed API reference for comprehensive documentation including all parameters, return types, and examples.

Core Classes

Equation

from gimle.asgard.equation.equation import Equation

eq = Equation.from_string("diff(f, x) = g")

Equation.from_string(equation_str: str) -> Equation

Parse an equation from a string representation.

# Simple equation
eq = Equation.from_string("diff(f, x) = g")

# Fundamental theorem of calculus
eq = Equation.from_string("diff(int(f, x), x) = f")

# Differential equation
eq = Equation.from_string("diff(y, t) = scalar(-0.1, y)")

Properties

Property	Type	Description
lhs	lark.Tree	Left-hand side of the equation
rhs	lark.Tree	Right-hand side of the equation
parse_tree	lark.Tree	Full parse tree

Circuit

from gimle.asgard.circuit.circuit import Circuit

circuit = Circuit.from_string("composition(register(x), deregister(x))")

Circuit.from_string(circuit_str: str) -> Circuit

Parse a circuit from a string representation.

# Simple atomic operation
circuit = Circuit.from_string("register(x)")

# Composition
circuit = Circuit.from_string("composition(register(x), deregister(x))")

# Monoidal product
circuit = Circuit.from_string("monoidal(scalar(2.0), scalar(3.0))")

execute(inputs, state) -> Tuple[List[Stream], StreamState]

Execute the circuit on input streams.

from gimle.asgard.runtime.stream import Stream, StreamState
import jax.numpy as jnp

circuit = Circuit.from_string("register(x)")

input_stream = Stream(
    data=jnp.array([[1.0, 2.0, 3.0]]),
    dim_labels=("x",),
    chunk_size=1
)

outputs, state = circuit.execute([input_stream], StreamState())
print(outputs[0].data)  # [[0. 1. 2.]]

Properties

Property	Type	Description
input_degree	int	Number of input streams expected
output_degree	int	Number of output streams produced
parse_tree	lark.Tree	Circuit parse tree

Stream

from gimle.asgard.runtime.stream import Stream, StreamState
import jax.numpy as jnp

stream = Stream(
    data=jnp.array([[1.0, 2.0, 3.0]]),
    dim_labels=("x",),
    chunk_size=1
)

Parameters

Parameter	Type	Description
data	jnp.ndarray	JAX array of coefficients
dim_labels	Tuple[str, ...]	Dimension labels (e.g., ("x",) or ("x", "t"))
chunk_size	int	Number of samples per chunk

StreamState

Holds boundary conditions for stateful operations like integration.

state = StreamState()
outputs, new_state = circuit.execute([input_stream], state)
# Pass new_state to next execution for continuous processing

Calculi

Three mathematical interpretations for evaluating streams.

RealCalculus

Taylor series expansion for deterministic computation.

from gimle.asgard.runtime.stream_evaluator import RealCalculus

calculus = RealCalculus(center=0.0)

StochasticCalculus

Monte Carlo simulation of stochastic differential equations.

from gimle.asgard.runtime.stream_evaluator import StochasticCalculus

calculus = StochasticCalculus(
    drift=0.0,
    diffusion=1.0,
    n_paths=1000,
    dt=0.01,
    seed=42
)

DiscreteCalculus

Discrete-time sequence processing.

from gimle.asgard.runtime.stream_evaluator import DiscreteCalculus

calculus = DiscreteCalculus(start_index=0)

StreamEvaluator

Evaluates streams using calculus-specific basis functions.

from gimle.asgard.runtime.stream_evaluator import StreamEvaluator, RealCalculus
import jax.numpy as jnp

stream = Stream(
    data=jnp.array([[2.0, 3.0, 1.0]]),
    dim_labels=("x",),
    chunk_size=1
)

evaluator = StreamEvaluator(stream, {"x": RealCalculus()})
values = evaluator.evaluate(x=jnp.linspace(0, 10, 100))

Compilation

compile_equation_to_circuit()

Compile an equation to a circuit. Variable isolation and trace wiring are applied automatically.

from gimle.asgard.compile.compiler import compile_equation_to_circuit

eq = Equation.from_string("diff(int(f, x), x) = f")
circuit, metadata = compile_equation_to_circuit(eq)

Import Quick Reference

# Core classes
from gimle.asgard.equation.equation import Equation
from gimle.asgard.circuit.circuit import Circuit

# Runtime
from gimle.asgard.runtime.stream import Stream, StreamState
from gimle.asgard.runtime.stream_evaluator import (
    StreamEvaluator,
    RealCalculus,
    StochasticCalculus,
    DiscreteCalculus
)

# Compilation
from gimle.asgard.compile.compiler import compile_equation_to_circuit

# JAX
import jax.numpy as jnp

Next Steps

• Equations - LEAN-style equation syntax
• Circuits - Circuit composition
• Runtime - Calculi and execution
• Examples - Working examples