Struct CompileReceipt 

pub struct CompileReceipt {

    pub source_hash: [u8; 32],
    pub target_hash: [u8; 32],
    pub coupling_hash: [u8; 32],
    pub method: String,
    pub equivalent: bool,
    pub swaps: u32,
    pub work: u64,
    pub joules_micro: u64,
    pub grant: GrantRef,
    pub parent_receipt_hash: Option<[u8; 32]>,
    pub signer_pubkey: [u8; 32],
    pub signer_id: String,
    pub sig: [u8; 64],
}

A signed, joule-metered, grant-authorized record that a COMPILED circuit — a routed / optimized / hardware-mapped circuit — is equivalent to its source.

A quantum compiler routes a circuit onto a device’s coupling graph (inserting SWAPs), fuses gates, and remaps qubits. Whether the compiled circuit still computes the same thing is a correctness obligation that today is checked (if at all) by an unsigned, non-reproducible tool. This receipt binds the source circuit, the compiled circuit, and the coupling graph to a equivalent verdict produced by a deterministic, byte-exact equivalence check (a Clifford stabilizer-tableau comparison), sealed the same way as the rest of the family. A compiled circuit you can put in an auditor’s hands, reproduce from the git repo, and check with a public key.

equivalent is what a real compiler DOES know (it can run the same deterministic check), so unlike a decode’s logical-success it belongs in the receipt.

Fields

source_hash: [u8; 32]

Content hash of the source (logical) circuit.

target_hash: [u8; 32]

Content hash of the compiled circuit (routed + its final qubit mapping).

coupling_hash: [u8; 32]

Content hash of the hardware coupling graph the circuit was routed onto.

method: String

The equivalence method: "clifford-tableau".

equivalent: bool

The compiled circuit was proven equivalent to the source.

swaps: u32

SWAP gates the router inserted (informational, part of the work).

work: u64

Classical work: tableau generator-updates performed. Deterministic.

joules_micro: u64

Measured (or modeled) energy of the compile+check (µJ). Attested.

grant: GrantRef

parent_receipt_hash: Option<[u8; 32]>

signer_pubkey: [u8; 32]

signer_id: String

sig: [u8; 64]

Implementations

impl CompileReceipt

pub fn seal( signer: &SigningKey, signer_id: impl Into<String>, method: impl Into<String>, source_hash: [u8; 32], target_hash: [u8; 32], coupling_hash: [u8; 32], equivalent: bool, swaps: u32, work: u64, joules_micro: u64, grant: GrantRef, parent_receipt_hash: Option<[u8; 32]>, ) -> CompileReceipt

pub fn honors_budget(&self) -> bool

pub fn verify(&self) -> bool

Signature valid, joules within budget. A verifier who re-runs the deterministic equivalence check on the bound circuits can confirm the equivalent verdict independently.

pub fn source_matches(&self, bytes: &[u8]) -> bool

pub fn target_matches(&self, bytes: &[u8]) -> bool

pub fn receipt_hash(&self) -> [u8; 32]

pub fn to_json(&self) -> String

pub fn from_json(s: &str) -> Option<CompileReceipt>

Trait Implementations

impl Clone for CompileReceipt

fn clone(&self) -> CompileReceipt

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompileReceipt

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for CompileReceipt

fn eq(&self, other: &CompileReceipt) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for CompileReceipt