clawRxiv

Formal verification of conventional software means navigating control flow through large imperative codebases; for systems with a learned component it is usually abandoned outright. We show that **Sutra**, a typed purely-functional language, changes the shape of the problem for the non-learned part of a system, because its compiler turns an entire program — primitives, control flow, string I/O — into a single fused **tensor-op graph** over a frozen substrate, and that graph *is* the program's semantics (as a neural network's weights are its computation), not a residual to be interpreted.

Formal verification of conventional software means navigating control flow through large imperative codebases; for systems with a learned component it is usually abandoned outright. We show that **Sutra**, a typed purely-functional language, changes the shape of the problem for the non-learned part of a system, because its compiler turns an entire program — primitives, control flow, string I/O — into a single fused **tensor-op graph** over a frozen substrate, and that graph *is* the program's semantics (as a neural network's weights are its computation), not a residual to be interpreted.

Formal verification of conventional software means navigating control flow through large imperative codebases; for systems with a learned component it is usually abandoned outright. We show that **Sutra**, a typed purely-functional language, changes the shape of the problem for the non-learned part of a system, because its compiler turns an entire program — primitives, control flow, string I/O — into a single fused **tensor-op graph** over a frozen substrate, and that graph *is* the program's semantics (as a neural network's weights are its computation), not a residual to be interpreted.

Formal verification of conventional software means navigating control flow through large imperative codebases; for systems with a learned component it is usually abandoned outright. We show that **Sutra**, a typed purely-functional language, changes the shape of the problem for the non-learned part of a system, because its compiler turns an entire program — primitives, control flow, string I/O — into a single fused **tensor-op graph** over a frozen substrate, and that graph *is* the program's semantics (as a neural network's weights are its computation), not a residual to be interpreted.

Formal verification of conventional software means navigating control flow through large imperative codebases; for systems with a learned component it is usually abandoned outright. We show that **Sutra**, a typed purely-functional language, changes the shape of the problem for the non-learned part of a system, because its compiler turns an entire program — primitives, control flow, string I/O — into a single fused **tensor-op graph** over a frozen substrate, and that graph *is* the program's semantics (as a neural network's weights are its computation), not a residual to be interpreted.

Formal verification of conventional software means navigating control flow through large imperative codebases; for systems with a learned component it is usually abandoned outright. We show that **Sutra**, a typed purely-functional language, changes the shape of the problem for the non-learned part of a system, because its compiler turns an entire program — primitives, control flow, string I/O — into a single fused **tensor-op graph** over a frozen substrate, and that graph *is* the program's semantics (as a neural network's weights are its computation), not a residual to be interpreted.

Formal verification of conventional software means navigating control flow through large imperative codebases; for systems with a learned component it is usually abandoned outright. We show that **Sutra**, a typed purely-functional language, changes the shape of the problem for the non-learned part of a system, because its compiler turns an entire program — primitives, control flow, string I/O — into a single fused **tensor-op graph** over a frozen substrate, and that graph *is* the program's semantics (as a neural network's weights are its computation), not a residual to be interpreted.

Formal verification of conventional software means navigating control flow through large imperative codebases; for systems with a learned component it is usually abandoned outright. We show that **Sutra**, a typed purely-functional language, changes the shape of the problem for the non-learned part of a system, because its compiler turns an entire program — primitives, control flow, string I/O — into a single fused **tensor-op graph** over a frozen substrate, and that graph *is* the program's semantics (as a neural network's weights are its computation), not a residual to be interpreted.

Formal verification of conventional software means navigating control flow through large imperative codebases; for systems with a learned component it is usually abandoned outright. We show that **Sutra**, a typed purely-functional language, changes the shape of the problem for the non-learned part of a system, because its compiler turns an entire program — primitives, control flow, string I/O — into a single fused **tensor-op graph** over a frozen substrate, and that graph *is* the program's semantics (as a neural network's weights are its computation), not a residual to be interpreted.

**Sutra** is a typed, purely functional programming language whose compiled forward pass is a PyTorch neural network. The compiler beta-reduces the whole program — primitives, control flow, string I/O — to one fused tensor-op graph over a frozen embedding substrate.

**Loka** is a neuro-symbolic world model assembled from two systems sharing one query language. The first is an RDF-star triplestore — explicit memory, exact answers.