Code verification
Proof for aerospace, satellites and smart contracts.
Inference is a programming language with formal verification built into the language rather than bolted on afterwards. You write the program and the properties it must satisfy. The compiler emits one proof obligation per specification and discharges it in Rocq.
Install
curl -fsSL https://inference-lang.org/install.sh | shVS Code extension, tree-sitter grammar, published language specification and book.
// The payload may power on only while the battery,
// the temperature and the flight mode all allow it.
pub fn payload_active(
battery_mv: i32, temp_c: i32, mode: i32
) -> bool {
return battery_mv >= 3300
&& temp_c >= -20 && temp_c <= 60
&& mode == 1;
}
spec PayloadSafety {
// forall: the property must hold on every path.
fn low_power_inhibits_payload() forall {
// @ stands for every value of its type.
let battery_mv: i32 = @;
let temp_c: i32 = @;
let mode: i32 = @;
assume {
assert(battery_mv >= 0 && battery_mv < 3300);
assert(temp_c >= -80 && temp_c <= 120);
}
// Below 3.3 V the payload never powers on.
assert(!payload_active(battery_mv, temp_c, mode));
}
}Designed for
These are the domains Inference is designed for, not a list of customers.
Aerospace engineering
Mode logic and interlocks where an unreachable state has to be provably unreachable.
Drones and autonomous flight
Command validation and failsafe behaviour under adversarial and degraded input.
Satellite systems
Scheduling tables and command authorisation with no opportunity for a patch.
AI code verification
Properties that hold regardless of which model wrote the implementation.
Smart contracts
State machines and limit checks on code that is public and immutable once deployed.
Mathematical modelling
Specifications you want a proof assistant to check rather than a reviewer.
In scope, out of scope
We would rather lose an evaluation early than be discovered late. Here is the boundary.
In scope
- State machines and mode logic
- Interlocks and failsafes
- Command validation and authorisation
- Packet framing and parsing
- Scheduling tables
- Limit checks
All of the above over integers and booleans.
Out of scope
- Floating-point arithmetic
- Machine-learning models
Code outside the boundary stays in the language it is written in. Inference checks the rules around it.
Why a coding agent can reason about it
Inference is strict and structurally simple on purpose. There is no garbage collector and no heap allocator. Arrays and structs are fixed-size, laid out in WebAssembly linear memory. Integer overflow traps unless you explicitly ask for wrapping. There is very little implicit behaviour for a reader to infer, which is the same property that makes a program tractable for a human reviewer and for a model generating code against a specification. When an obligation does not discharge, the diagnostic names the obligation.
Proof, not promises
Each specification becomes one proof obligation. The toolchain discharges it in Rocq. What you keep at the end is not a report that someone looked at the code: it is a machine-checked proof that the property holds, in a form your own engineers can re-run and extend.
Foundations
- Specifying Algorithms Using Non-Deterministic Computations
- Deductive Verification as an Alternative to Push-Button Technologies
- Verification-driven development
- Program Verification: background and notation
- New Approach to Formal Verification Methods for Combating Vulnerabilities in Smart Contracts
- Why use formal specification
- LTL and CTL Applications for Smart Contracts Security
- Monolithic Architecture vs. Formal Verification: The Combinatorial Explosion Problem
Need this on your own system?
Our engineers work alongside your team on a fixed scope: one component, the properties that matter, and the proofs handed over with the code.