Skip to main content

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 | sh

VS Code extension, tree-sitter grammar, published language specification and book.

example.infInference v0.0.6
// 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.

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.