Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

An MLIR Dialect for Fault-Tolerant Quantum Computing (Poster)

Narasinga Rao Miniskar, Elaine Wong, Seyong Lee, Vicente Leyton‐Ortega, Jeffrey S. Vetter, Travis S. Humble

Published Nov 2, 2026• 0 citations
Publisher

Abstract

To achieve fault-tolerant quantum computing (FTQC), a compilation pipeline must address quantum error-correcting codes, syndrome extraction, magic-state distillation, and physical-gate decomposition. We introduce FTQC, an open-source dialect for MLIR (Multi-Level Intermediate Representation) that treats these concerns as first-class constructs in the intermediate representation (IR). Logical qubits are type-safe static single-assignment (SSA) values parameterized by their error-correcting code and distance, letting the compiler enforce code and distance compatibility at the type level. The dialect provides operations covering the logical life-cycle: encoded initialization, transversal Clifford gates, $T$ gates and Toffoli gates by magic-state injection, syndrome extraction, and distillation. A resource estimator derives physical-qubit counts and logical error rates directly from ECC metadata in the IR, and three validated backends emit OpenQASM 3, QIR (Quantum Intermediate Representation), and Stim. Across four benchmarking quantum circuits, end-to-end compilation completes in under 15 ms, and a full logical-error-rate sweep through Stim runs in under 4s for quantum circuits of up to 52 physical qubits.

DOI
10.5281/zenodo.23892133

Related papers

Quantum Compiler Design for Fault-Tolerant Quantum Computing

Chenghong Zhu, Jiahan Chen, Keming He +9 more

Scalable quantum computation is expected to rely on fault-tolerant quantum computation (FTQC), in which quantum error correction (QEC) suppresses physical errors sufficiently to support reliable logical operations. This requires quantum compilation to move beyond general-purpose circuit optimization toward encoding-aware and protocol-structured compilation across the full stack of fault-tolerant quantum computers. Beyond circuit synthesis and hardware mapping, an FTQC compiler must lower algorithm-level operations into the logical gate set supported by the chosen code, coordinate encoded data and ancilla resources, realize logical operations together with repeated syndrome extraction under hardware constraints, and provide the resulting measurement stream to real-time decoding. This survey presents a full-stack view of compiler design for QEC-protected quantum computation. We organize existing work into three interacting layers: logical-level QEC compilation, physical-level QEC realization, and decoder runtime integration. At the logical level, we review surface-code lattice-surgery compilers, beyond-surface-code code-surgery frameworks including emerging qLDPC approaches, and compilation support for non-Clifford operations such as magic-state distillation and code switching. At the physical level, we survey hardware-aware QEC realization on superconducting, trapped-ion, and neutral-atom platforms. We further examine decoder models, real-time decoding systems, and frame-management mechanisms that close the feedback loop during fault-tolerant execution. Finally, we identify open challenges in cross-layer optimization, qLDPC compilation, compiler-decoder co-design, runtime adaptivity, and the development of integrated and benchmarkable FTQC compilation stacks. An actively maintained paper list is available at: github.com/chenghongz/QEC-compiler-design.

quant-pharXiv:2609.17465•Sep 16, 2026•0 citations

A Compiler for Fault Tolerant Quantum Computing

Narasinga Rao Miniskar, Elaine Wong, Seyong Lee +3 more

Fault-tolerant quantum computing (FTQC) needs compiler intermediate representations (IRs) that preserve error-correcting-code choices, syndrome information, and non-Clifford resource requirements through analysis, simulation, and hardware lowering. We report practical experience building FTQC, an open-source Multi-Level Intermediate Representation (MLIR) dialect that makes logical qubits, syndromes, magic states, and Pauli frames typed static single assignment (SSA) values. Its error-correction-aware type system, two-level lowering design, and IR-resident resource analysis provide one inspectable pipeline to Open Quantum Assembly Language~3 (OpenQASM~3), the Quantum Intermediate Representation (QIR), Stim, and IQM hardware. Case studies across three code families show that typed metadata makes code-specific decisions verifiable and retargetable: on the 20-qubit Pathfinder at Oak Ridge National Laboratory, decoding reduced logical readout error by 3.3 times. They also expose hidden architectural costs: for a three-qubit Quantum Fourier Transform (QFT-3), a magic-state factory requires five times the peak qubits of the encoded circuit. These experiences demonstrate a practical foundation for developing and evaluating fault-tolerant compiler transformations across software and hardware targets.

arXiv:2611.13301•Nov 9, 2026•0 citations

A MLIR Dialect for Quantum Assembly Languages

Alexander McCaskey, Thien Nguyen

We demonstrate the utility of the Multi-Level Intermediate Representation (MLIR) for quantum computing. Specifically, we extend MLIR with a new quantum dialect that enables the expression and compilation of common quantum assembly languages. The true utility of this dialect is in its ability to be lowered to the LLVM intermediate representation (IR) in a manner that is adherent to the quantum intermediate representation (QIR) specification recently proposed by Microsoft. We leverage a qcor-enabled implementation of the QIR quantum runtime API to enable a retargetable (quantum hardware agnostic) compiler workflow mapping quantum languages to hybrid quantum-classical binary executables and object code. We evaluate and demonstrate this novel compiler workflow with quantum programs written in OpenQASM 2.0. We provide concrete examples detailing the generation of MLIR from OpenQASM source files, the lowering process from MLIR to LLVM IR, and ultimately the generation of executable binaries targeting available quantum processors.

arXiv:2101.11365•IEEE International Conference on Quantum Computing and Engineering (QCE)•Oct 1, 2021•58 citations

Advances in compilation for quantum hardware -- A demonstration of magic state distillation and repeat-until-success protocols

Natalie C. Brown, John Peter Campora, Cassandra Granade +8 more

Fault-tolerant protocols enable large and precise quantum algorithms. Many such protocols rely on a feed-forward processing of data, enabled by a hybrid of quantum and classical logic. Representing the control structure of such programs can be a challenge. Here we explore two such fault-tolerant subroutines and analyze the performance of the subroutines using Quantum Intermediate Representation (QIR) as their underlying intermediate representation. First, we look at QIR's ability to leverage the LLVM compiler toolchain to unroll the quantum iteration logic required to perform magic state distillation on the $[[5,1,3]]$ quantum error-correcting code as originally introduced by Bravyi and Kitaev [Phys. Rev. A 71, 022316 (2005)]. This allows us to not only realize the first implementation of a real-time magic state distillation protocol on quantum hardware, but also demonstrate QIR's ability to optimize complex program structures without degrading machine performance. Next, we investigate a different fault-tolerant protocol that was first introduced by Paetznick and Svore [arXiv:1311.1074 (2013)], that reduces the amount of non-Clifford gates needed for a particular algorithm. We look at four different implementations of this two-stage repeat-until-success algorithm to analyze the performance changes as the results of programming choices. We find the QIR offers a viable representation for a compiled high-level program that performs nearly as well as a hand-optimized version written directly in quantum assembly. Both of these results demonstrate QIR's ability to accurately and efficiently expand the complexity of fault-tolerant protocols that can be realized today on quantum hardware.

arXiv:2310.12106•Oct 18, 2023•19 citations

Quantum Compiler Design for Fault-Tolerant Quantum Computing — E8 Intelligence Research

Andrew Stewart Caldin

Scalable quantum computation is expected to rely on fault-tolerant quantum computation (FTQC), in which quantum error correction (QEC) suppresses physical errors sufficiently to support reliable logical operations. This requires quantum compilation to move beyond general-purpose circuit optimization toward encoding-aware and protocol-structured compilation across the full stack of fault-tolerant quantum computers. Beyond circuit synthesis and hardware mapping, an FTQC compiler must lower algorithm-level operations into the logical gate set supported by the chosen code, coordinate encoded data and ancilla resources, realize logical operations together with repeated syndrome extraction under hardware constraints, and provide the resulting measurement stream to real-time decoding. This survey presents a full-stack view of compiler design for QEC-protected quantum computation. We organize existing work into three interacting layers: logical-level QEC compilation, physical-level QEC reali Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

•Nov 5, 2026•0 citations

Governed Fault-Tolerant Quantum Computing on Commodity NISQ Hardware: Surface-Code QEC, Universal FTQC Primitives, FTQC Composition, and Chemical Accuracy FTQC across H2, LiH, H2O, BeH2 Ground States, and the BeH2 Strongly-Multireference Transition State on the IBM Heron r2 and r3 Families of QPUs

Denise Holt, Denis Ovseyenko

Abstract This paper reports the first end-to-end fault-tolerant quantum computing stack to clear all four strict-FTQC requirements simultaneously on commodity superconducting NISQ silicon, rented through standard IBM Quantum cloud subscription with no purpose-built research machine, no custom decoder, and no magic-state distillation factory. The four requirements: (i) surface-code quantum error correction at distance d≥3 with logical-error rate below the unencoded baseline; (ii) a universal Clifford+T gate set executed via magic-state injection, with no arbitrary angle physical rotation carrying non-Clifford content on the wire (the algorithm-determined non-Clifford angle never fires on the silicon; the native RZ(θphys) on Heron fires only at Clifford-multiple angles required to compose H, S, T); (iii) heterogeneous primitive composition (teleportation, lattice-surgery CNOT, T-gate, logical memory) on a persistent encoded register; and (iv) runtime admissibility verification on every committed result. All five chips, five chemistry workloads spanning four molecules, and twenty-two governed runs in this paper were executed on the same primitive engine without architectural change. The architectural shift that makes this work on today’s hardware is the d=1 inversion: a 150-qubit governed encoded register held at substrate distance d=1 on the chip’s physical qubits, with logical fidelity preserved by Seed IQ execution governance over the encoded layer rather than by a larger code distance. Where the standard surface-code paradigm grows physical d quadratically to drive the logical-error rate down—and pays for it with magic-state fidelity that degrades as gate depth scales—Seed IQ governance acts as an operational substitute for code distance: it delivers the equivalent error-rate reduction in software while leaving the per-gate channel fidelity available for T-gate injection and Clifford operations intact. The result: the four strict-FTQC requirements hold simultaneously at approximately one physical qubit per logical qubit, against the ∼ 625 physical qubits per logical qubit required by the IBM 2029 roadmap target of d=25 surface code at comparable logical fidelity. Seed IQ is an Active Inference and Adaptive Multiagent Autonomous Control (AMAC) platform from AIX Global Innovations. Campaign summary. Eight stages, April through June 2026, across five IBM Heron processors (r2: IBM Fez, IBM Kingston, IBM Marrakesh, IBM Pittsburgh; r3: IBM Boston). April 9 — surface-code QEC: −88.5% LER reduction at d=3 on IBM Fez, −93.1% at d=5 where the MWPM+UF baseline collapsed, −60.9% at d=3 on 1.28°ø dirtier IBM Pittsburgh silicon. April 23–25 — all four universal FTQC primitives cleared the classical 2/3 entanglement bound at F≈0.99. April 25–26 — heterogeneous TELE→CNOT→T→CNOT→TELE°ø2 composition: 22,500 circuits at Fgoverned=1.0000, zero detected logical errors. May 7–9 — H2, 10 runs across 3 chips, 10/10 inside chem-acc, best ΔE=+0.0157mHa, two chips bit-identical to twelve decimals. May 23 —LiH, 3 runs across 3 chips, 3/3 inside chem-acc, two chips tied at ΔE=+0.056mHa. May 28–30 — H2O, 3 runs across 3 chips, 3/3 inside chem-acc at ΔE=+0.051mHa, all three bit-identical to twelve decimals. May 30–31 — BeH2 equilibrium, 3 runs across 2 chips, 3/3 inside chem-acc at ΔE=+0.000595mHa (2690.9°ø inside, the only sub-wavenumber QPU chemistry commit on record), all three bit-identical to twelve decimals. June 1 — BeH2 transition state (|cHF |2≈0.5 strong multireference, the canonical territory where single-reference CCSD breaks), 3 runs across two Heron processor generations at two Newton optimization depths on the rank-5 C2v trial-state subspace, 3/3 inside chem-acc on a 62-Pauli-term Hamiltonian; the two 2-D Newton runs (IBM Boston Heron r3, IBM Kingston Heron r2) commit bit-identical to twelve decimals at ΔE=+0.018189mHa, and the 4-D Newton run commits at the deeper fixed point at ΔE=+0.012643mHa (126.6°ø inside chem-acc, 1.6°ø inside the CCSD(T) gold band). Aggregate: twenty-two runs, 22/22 inside chemical accuracy. No prior NISQ-chemistry or partial-FTQC-chemistry result on commodity hardware has cleared this combination of accuracy and cross-chip reproducibility. Full per-stage detail in Åò4–Åò12.8. Compliance. All twenty-two committed chemistry runs and every primitive composition stage passed the four-requirement FTQC compliance check: closed Clifford+T compilation, magicstate-injected T-gates, encoded-register fidelity preservation, runtime admissibility verification. Fgoverned=1.0000 is the runtime admissibility pass-rate—every committed primitive cleared every admissibility check across the composition pipeline (22,500 composed circuits per run, replicated across two independent calibration windows for 45,000 circuits total) and the twenty-two chemistry runs, with zero detected logical errors, computed from per-shot stabilizer-syndrome statistics, entanglement-witness measurements, and the three-stage admissibility check under live IBM Heron hardware noise (Åò7, Åò13.13). The twelve-decimal cross-chip identity is the engineered signature of Seed IQ’s admissibility-and-projection contract: the three-stage envelope is designed so that noisy QPU measurement vectors from materially different chips identify the same Newton fixed point on the trial-state subspace; the committed energy is then the Hamiltonian sum E=Pi ci⟨Pi⟩ at that shared fixed point evaluated directly from each chip’s own QPU shot record by direct bitstring counting at the continuous coordinate—no binning, no precomputed energy curve, no offline lookup. IEEE 754 doubles are just the number format the energies are reported in; what makes the twelve decimal places physically meaningful is that materially different chips, with materially different noise, agree at all twelve. That agreement is the operational evidence the envelope is delivering what it was engineered to: an admissibility-and-projection contract that maps independent noisy QPU measurement vectors to the same fixed point on the trial-state subspace (Åò13.10, Åò14).

•Jun 7, 2026•4 citations
To achieve fault-tolerant quantum computing (FTQC), a compilation pipeline must address quantum error-correcting codes, syndrome extraction, magic-state distillation, and physical-gate decomposition. We introduce FTQC, an open-source dialect for MLIR (Multi-Level Intermediate Representation) that treats these concerns as first-class constructs in the intermediate representation (IR). Logical qubits are type-safe static single-assignment (SSA) values parameterized by their error-correcting code and distance, letting the compiler enforce code and distance compatibility at the type level. The dialect provides operations covering the logical life-cycle: encoded initialization, transversal Clifford gates, TTT gates and Toffoli gates by magic-state injection, syndrome extraction, and distillation. A resource estimator derives physical-qubit counts and logical error rates directly from ECC metadata in the IR, and three validated backends emit OpenQASM 3, QIR (Quantum Intermediate Representation), and Stim. Across four benchmarking quantum circuits, end-to-end compilation completes in under 15 ms, and a full logical-error-rate sweep through Stim runs in under 4s for quantum circuits of up to 52 physical qubits.
Scalable quantum computation is expected to rely on fault-tolerant quantum computation (FTQC), in which quantum error correction (QEC) suppresses physical errors sufficiently to support reliable logical operations. This requires quantum compilation to move beyond general-purpose circuit optimization toward encoding-aware and protocol-structured compilation across the full stack of fault-tolerant quantum computers. Beyond circuit synthesis and hardware mapping, an FTQC compiler must lower algorithm-level operations into the logical gate set supported by the chosen code, coordinate encoded data and ancilla resources, realize logical operations together with repeated syndrome extraction under hardware constraints, and provide the resulting measurement stream to real-time decoding. This survey presents a full-stack view of compiler design for QEC-protected quantum computation. We organize existing work into three interacting layers: logical-level QEC compilation, physical-level QEC realization, and decoder runtime integration. At the logical level, we review surface-code lattice-surgery compilers, beyond-surface-code code-surgery frameworks including emerging qLDPC approaches, and compilation support for non-Clifford operations such as magic-state distillation and code switching. At the physical level, we survey hardware-aware QEC realization on superconducting, trapped-ion, and neutral-atom platforms. We further examine decoder models, real-time decoding systems, and frame-management mechanisms that close the feedback loop during fault-tolerant execution. Finally, we identify open challenges in cross-layer optimization, qLDPC compilation, compiler-decoder co-design, runtime adaptivity, and the development of integrated and benchmarkable FTQC compilation stacks. An actively maintained paper list is available at: github.com/chenghongz/QEC-compiler-design.
Fault-tolerant quantum computing (FTQC) needs compiler intermediate representations (IRs) that preserve error-correcting-code choices, syndrome information, and non-Clifford resource requirements through analysis, simulation, and hardware lowering. We report practical experience building FTQC, an open-source Multi-Level Intermediate Representation (MLIR) dialect that makes logical qubits, syndromes, magic states, and Pauli frames typed static single assignment (SSA) values. Its error-correction-aware type system, two-level lowering design, and IR-resident resource analysis provide one inspectable pipeline to Open Quantum Assembly Language~3 (OpenQASM~3), the Quantum Intermediate Representation (QIR), Stim, and IQM hardware. Case studies across three code families show that typed metadata makes code-specific decisions verifiable and retargetable: on the 20-qubit Pathfinder at Oak Ridge National Laboratory, decoding reduced logical readout error by 3.3 times. They also expose hidden architectural costs: for a three-qubit Quantum Fourier Transform (QFT-3), a magic-state factory requires five times the peak qubits of the encoded circuit. These experiences demonstrate a practical foundation for developing and evaluating fault-tolerant compiler transformations across software and hardware targets.
We demonstrate the utility of the Multi-Level Intermediate Representation (MLIR) for quantum computing. Specifically, we extend MLIR with a new quantum dialect that enables the expression and compilation of common quantum assembly languages. The true utility of this dialect is in its ability to be lowered to the LLVM intermediate representation (IR) in a manner that is adherent to the quantum intermediate representation (QIR) specification recently proposed by Microsoft. We leverage a qcor-enabled implementation of the QIR quantum runtime API to enable a retargetable (quantum hardware agnostic) compiler workflow mapping quantum languages to hybrid quantum-classical binary executables and object code. We evaluate and demonstrate this novel compiler workflow with quantum programs written in OpenQASM 2.0. We provide concrete examples detailing the generation of MLIR from OpenQASM source files, the lowering process from MLIR to LLVM IR, and ultimately the generation of executable binaries targeting available quantum processors.
Fault-tolerant protocols enable large and precise quantum algorithms. Many such protocols rely on a feed-forward processing of data, enabled by a hybrid of quantum and classical logic. Representing the control structure of such programs can be a challenge. Here we explore two such fault-tolerant subroutines and analyze the performance of the subroutines using Quantum Intermediate Representation (QIR) as their underlying intermediate representation. First, we look at QIR's ability to leverage the LLVM compiler toolchain to unroll the quantum iteration logic required to perform magic state distillation on the [[5,1,3]][[5,1,3]][[5,1,3]] quantum error-correcting code as originally introduced by Bravyi and Kitaev [Phys. Rev. A 71, 022316 (2005)]. This allows us to not only realize the first implementation of a real-time magic state distillation protocol on quantum hardware, but also demonstrate QIR's ability to optimize complex program structures without degrading machine performance. Next, we investigate a different fault-tolerant protocol that was first introduced by Paetznick and Svore [arXiv:1311.1074 (2013)], that reduces the amount of non-Clifford gates needed for a particular algorithm. We look at four different implementations of this two-stage repeat-until-success algorithm to analyze the performance changes as the results of programming choices. We find the QIR offers a viable representation for a compiled high-level program that performs nearly as well as a hand-optimized version written directly in quantum assembly. Both of these results demonstrate QIR's ability to accurately and efficiently expand the complexity of fault-tolerant protocols that can be realized today on quantum hardware.
Scalable quantum computation is expected to rely on fault-tolerant quantum computation (FTQC), in which quantum error correction (QEC) suppresses physical errors sufficiently to support reliable logical operations. This requires quantum compilation to move beyond general-purpose circuit optimization toward encoding-aware and protocol-structured compilation across the full stack of fault-tolerant quantum computers. Beyond circuit synthesis and hardware mapping, an FTQC compiler must lower algorithm-level operations into the logical gate set supported by the chosen code, coordinate encoded data and ancilla resources, realize logical operations together with repeated syndrome extraction under hardware constraints, and provide the resulting measurement stream to real-time decoding. This survey presents a full-stack view of compiler design for QEC-protected quantum computation. We organize existing work into three interacting layers: logical-level QEC compilation, physical-level QEC reali Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com
Abstract This paper reports the first end-to-end fault-tolerant quantum computing stack to clear all four strict-FTQC requirements simultaneously on commodity superconducting NISQ silicon, rented through standard IBM Quantum cloud subscription with no purpose-built research machine, no custom decoder, and no magic-state distillation factory. The four requirements: (i) surface-code quantum error correction at distance d≥3 with logical-error rate below the unencoded baseline; (ii) a universal Clifford+T gate set executed via magic-state injection, with no arbitrary angle physical rotation carrying non-Clifford content on the wire (the algorithm-determined non-Clifford angle never fires on the silicon; the native RZ(θphys) on Heron fires only at Clifford-multiple angles required to compose H, S, T); (iii) heterogeneous primitive composition (teleportation, lattice-surgery CNOT, T-gate, logical memory) on a persistent encoded register; and (iv) runtime admissibility verification on every committed result. All five chips, five chemistry workloads spanning four molecules, and twenty-two governed runs in this paper were executed on the same primitive engine without architectural change. The architectural shift that makes this work on today’s hardware is the d=1 inversion: a 150-qubit governed encoded register held at substrate distance d=1 on the chip’s physical qubits, with logical fidelity preserved by Seed IQ execution governance over the encoded layer rather than by a larger code distance. Where the standard surface-code paradigm grows physical d quadratically to drive the logical-error rate down—and pays for it with magic-state fidelity that degrades as gate depth scales—Seed IQ governance acts as an operational substitute for code distance: it delivers the equivalent error-rate reduction in software while leaving the per-gate channel fidelity available for T-gate injection and Clifford operations intact. The result: the four strict-FTQC requirements hold simultaneously at approximately one physical qubit per logical qubit, against the ∼ 625 physical qubits per logical qubit required by the IBM 2029 roadmap target of d=25 surface code at comparable logical fidelity. Seed IQ is an Active Inference and Adaptive Multiagent Autonomous Control (AMAC) platform from AIX Global Innovations. Campaign summary. Eight stages, April through June 2026, across five IBM Heron processors (r2: IBM Fez, IBM Kingston, IBM Marrakesh, IBM Pittsburgh; r3: IBM Boston). April 9 — surface-code QEC: −88.5% LER reduction at d=3 on IBM Fez, −93.1% at d=5 where the MWPM+UF baseline collapsed, −60.9% at d=3 on 1.28°ø dirtier IBM Pittsburgh silicon. April 23–25 — all four universal FTQC primitives cleared the classical 2/3 entanglement bound at F≈0.99. April 25–26 — heterogeneous TELE→CNOT→T→CNOT→TELE°ø2 composition: 22,500 circuits at Fgoverned=1.0000, zero detected logical errors. May 7–9 — H2, 10 runs across 3 chips, 10/10 inside chem-acc, best ΔE=+0.0157mHa, two chips bit-identical to twelve decimals. May 23 —LiH, 3 runs across 3 chips, 3/3 inside chem-acc, two chips tied at ΔE=+0.056mHa. May 28–30 — H2O, 3 runs across 3 chips, 3/3 inside chem-acc at ΔE=+0.051mHa, all three bit-identical to twelve decimals. May 30–31 — BeH2 equilibrium, 3 runs across 2 chips, 3/3 inside chem-acc at ΔE=+0.000595mHa (2690.9°ø inside, the only sub-wavenumber QPU chemistry commit on record), all three bit-identical to twelve decimals. June 1 — BeH2 transition state (|cHF |2≈0.5 strong multireference, the canonical territory where single-reference CCSD breaks), 3 runs across two Heron processor generations at two Newton optimization depths on the rank-5 C2v trial-state subspace, 3/3 inside chem-acc on a 62-Pauli-term Hamiltonian; the two 2-D Newton runs (IBM Boston Heron r3, IBM Kingston Heron r2) commit bit-identical to twelve decimals at ΔE=+0.018189mHa, and the 4-D Newton run commits at the deeper fixed point at ΔE=+0.012643mHa (126.6°ø inside chem-acc, 1.6°ø inside the CCSD(T) gold band). Aggregate: twenty-two runs, 22/22 inside chemical accuracy. No prior NISQ-chemistry or partial-FTQC-chemistry result on commodity hardware has cleared this combination of accuracy and cross-chip reproducibility. Full per-stage detail in Åò4–Åò12.8. Compliance. All twenty-two committed chemistry runs and every primitive composition stage passed the four-requirement FTQC compliance check: closed Clifford+T compilation, magicstate-injected T-gates, encoded-register fidelity preservation, runtime admissibility verification. Fgoverned=1.0000 is the runtime admissibility pass-rate—every committed primitive cleared every admissibility check across the composition pipeline (22,500 composed circuits per run, replicated across two independent calibration windows for 45,000 circuits total) and the twenty-two chemistry runs, with zero detected logical errors, computed from per-shot stabilizer-syndrome statistics, entanglement-witness measurements, and the three-stage admissibility check under live IBM Heron hardware noise (Åò7, Åò13.13). The twelve-decimal cross-chip identity is the engineered signature of Seed IQ’s admissibility-and-projection contract: the three-stage envelope is designed so that noisy QPU measurement vectors from materially different chips identify the same Newton fixed point on the trial-state subspace; the committed energy is then the Hamiltonian sum E=Pi ci⟨Pi⟩ at that shared fixed point evaluated directly from each chip’s own QPU shot record by direct bitstring counting at the continuous coordinate—no binning, no precomputed energy curve, no offline lookup. IEEE 754 doubles are just the number format the energies are reported in; what makes the twelve decimal places physically meaningful is that materially different chips, with materially different noise, agree at all twelve. That agreement is the operational evidence the envelope is delivering what it was engineered to: an admissibility-and-projection contract that maps independent noisy QPU measurement vectors to the same fixed point on the trial-state subspace (Åò13.10, Åò14).