Core Concepts
Asgard is built around a unified framework for representing and executing dynamical systems. At its core are three interconnected concepts: equations, circuits, and runtime.
Philosophy
Asgard is built around three core principles:
-
Mathematical rigor, computational efficiency. Systems are defined with precise mathematical notation, then compiled to efficient executable circuits.
-
Same circuit, different calculi. The same computational circuit can be interpreted under deterministic, stochastic, or discrete calculi without rewriting code.
-
Composable and algebraic. Circuits are built from simple operations using category-theoretic composition, enabling formal reasoning and transformation.
Building Blocks
Equations
Define dynamical systems using LEAN-style mathematical notation. Express differential equations, integrals, and algebraic relations.
Circuits
Computational networks that transform streams. Build complex systems from atomic operations using composition and monoidal products.
Runtime
Execute circuits with different mathematical interpretations. Choose between deterministic, stochastic, and discrete calculi.
Architecture Overview
Equation (LEAN syntax)
Example: diff(int(f, x), y) = 0
│
│ equation_to_circuit()
▼
Circuit (Parse Tree)
Example: composition(register(x), deregister(y))
│
│ JAXCircuitCompiler.compile()
▼
JAX Function
Type: (List[Stream], StreamState) → (List[Stream], StreamState)
│
│ execute(input_streams, state)
▼
Stream (coefficient representation)
data: JAX array, dim_labels: ('x', 't', ...)
│
│ StreamEvaluator.evaluate() with Calculus
▼
┌────┴────┬──────────────┐
▼ ▼ ▼
RealCalculus Stochastic Discrete
Taylor series SDE paths Sequences
Key Features
Calculus Polymorphism
Execute the same circuit under different mathematical interpretations:
# Circuit: integrate then differentiate
circuit = Circuit.from_string("composition(register(t), deregister(t))")
# RealCalculus → classical calculus (Taylor series)
# StochasticCalculus → stochastic calculus (Monte Carlo)
# DiscreteCalculus → discrete sequences (finite differences)Stream Representation
Functions are represented as coefficient expansions:
- Symbolic manipulation via register/deregister
- Numerical evaluation via calculus-specific basis functions
- Dimensional tracking via labels
Compositional Circuits
Circuits are built from simple combinators:
- composition(f, g) - Sequential application
- monoidal(f, g) - Parallel application
- trace(f) - Feedback loops
Two-Phase Execution
Separation of compilation and execution for efficiency:
- Compile once - Circuit → JAX function
- Execute many - Fast, JIT-compiled execution