A specification is written in LOGOS, the compiler places it onto a dataflow fabric and emits the obligations that placement raises, the prover discharges them into certificates, and the codec carries those certificates to whoever checks them. Each is useful on its own. Together they are one pipeline with no untyped gap in it.
Where the specification, the reference implementation and the compiled artifact are three separate things, agreement between them is something you test for. Where they are one artifact viewed at different levels, agreement is something you prove.
That is the reason the toolchain has a language of its own rather than a pass over someone else's, a prover of its own rather than a dependency on Z3, and a wire format of its own rather than JSON between stages. Each boundary between two tools is a place where a proof can be lost in translation, and each of these products exists to remove one of those boundaries.
In the order an artifact meets them
Each product page states its results with the hardware, the versions and the timeouts they were measured under. The figure on each card below carries its condition with it.
LOGOS
A language that reads as structured English and compiles to Rust.
The executable specification. Every later stage reads this artifact rather than a description of it.
2.62x the speed of C across 32 benchmarks, or 1.27x on the 27 where the algorithm is held identical.
Supercompiler
A compile to silicon pipeline that places computation onto a dataflow fabric.
The compiler. It emits a machine checkable argument that the placement preserves the semantics of the reference.
The LOGOS Proof Kernel
A Calculus of Constructions type checker in pure Rust, and the decision procedures that feed it.
The trusted core. It re-checks every proof the rest of the stack proposes, and returns a certificate rather than a verdict.
Pigeonhole at 16 holes in 13.7 ms, where the resolution based solvers do not finish at any size.
The transport codec
A self describing wire format that needs no schema hint to decode.
The connective tissue. Proof artifacts, traces and certificates cross a wire between these stages, and a checker that spends longer parsing than checking is a bottleneck.
Fastest decode to usable on all six benchmarked workloads, timed with every value touched.
These four are the toolchain. Aiming it at one customer's silicon is an engagement rather than a product, and which engagement depends on where that silicon is in its life. Model bring-up is for a part that has already been bought and is waiting to carry traffic. Design signoff is for a part that is still a netlist. The technical argument is the same in both. What differs is how much has already been committed by the time it's made.
Want the argument before the parts? How we prove it
Not sure which of these answers the problem in front of you?