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.