Self-Contained Geometric Operators as Quantum Compilers

David Mulnix

Published Aug 25, 2026• 0 citations

Abstract

A geometric operator is a single mathematical object that contains its computation internally. Unlike a traditional compiler—which must parse external symbolic code, build abstract syntax trees, generate intermediate representations, and translate instructions into machine operations—a geometric operator requires no interpretation, no translation, and no external program structure. The computation “lives” inside the operator’s geometry itself. In a compiler-based system, meaning is assembled from many external components. In a geometric system, meaning is intrinsic: the operator already encodes the transformation, the structure, and the behavior. When executed, Python performs only numerical operations (matrix multiplication, SVD, QR factorization), but the semantic content is already present inside the operator. The processor is not executing a compiled program — it is revealing the operator’s internal geometry. This project demonstrates a result that, to our knowledge, has never been shown before: a geometric operator framework reproducing the full unitary behavior of deep quantum circuits (multi-layer, entangling, QFT‑mixed circuits) without gates, decomposition, transpilation, or circuit synthesis. The optimizer starts from identity and matches Qiskit-generated circuit unitaries with perfect operator fidelity and perfect functional fidelity, using only deviation geometry, extremal spectral steering, and polar re‑unitarization. Although the claim appears improbable, the mathematics and the code are fully transparent. Reviewers can inspect every module, every operator, and every update rule. The results are reproducible, and the behavior is consistent across structured manifolds, Haar targets, and deep circuit workloads. This repository provides the full implementation, tests, and validation suite for independent verification.

DOI: 10.5281/zenodo.22119479

Related papers

Executable Matrix-Product Unitaries: A Geometric Operator Framework for Quantum Circuits

David Mulnix

Quantum circuit theory has long treated Matrix‑Product Unitaries (MPUs) as elegant but unreachable objects—beautiful on paper, impossible to extract, and as far as we know never once executed on real hardware. This work breaks that barrier. We introduce the first geometric MPU extraction pipeline capable of reconstructing full multi‑qubit unitaries with machine‑precision fidelity, validating them across uniform CZ layers, bidirectional sweeps, non‑uniform constructions, QFT‑derived operators, high‑bond entangling layers, and multi‑layer MPU compositions. Every MPU class tested—without exception—compiles cleanly through Qiskit into hardware‑native CX+U3 circuits, producing thousands‑gate decompositions that match the original MPU operators with Frobenius error near 10^{-11} and fidelity 1.0. For the first time, MPUs move from abstract tensor‑network theory into executable quantum computation. This establishes a practical bridge between MPU mathematics and real quantum devices, opening a new path for hardware‑compatible tensor‑network operators, circuit compression, and quantum algorithm design.

Sep 7, 20260 citations

Geometric Formalization of Natural Language in Binary Representation and Its Implementation as Quantum Control Operations - REV. 2.3

Massimo Medesani

Abstract This work presents a unified, formal framework for translating natural language commands into executable quantum operations on superconducting qubit processors. We establish a rigorous geometric and algebraic structure for natural language, wherein sentences are embedded in a semantic vector space and encoded in binary representations. This formalism is then explicitly bridged to physical quantum control by defining a protocol to extract machine-interpretable quantum tokens—encoded as triples (θ,ϕ,axis)(θ,ϕ,axis)—from linguistically specified gate operations. The core technical contribution is a deterministic, hardware-aware mapping that converts these abstract tokens into the precise microwave pulse parameters (I(t),Q(t),ωd,τ)(I(t),Q(t),ωd,τ) required to drive single-qubit rotations on a transmon-type qubit. By leveraging the standard circuit QED control Hamiltonian H~d=−Ω2V0s(t)(Iσx+Qσy)H~d=−2ΩV0s(t)(Iσx+Qσy), we demonstrate how tailored in-phase and quadrature microwave pulses physically implement the intended unitary evolution U=exp⁡(−iθ2(cos⁡ϕ σx+sin⁡ϕ σy))U=exp(−i2θ(cosϕ σx+sinϕ σy)), resulting in a targeted rotation on the Bloch sphere. We further prove a Uniqueness Correspondence Theorem, guaranteeing a surjective, bijective, and injective mapping pipeline from the set of well-formed linguistic commands, through token and parameter spaces, to the set of single-qubit unitary operations, thereby ensuring semantic consistency and operational determinism. A complete binary encoding scheme for quantum commands is provided, illustrating the end-to-end pipeline from a command string to a calibrated microwave waveform. This work provides a foundational, mathematically rigorous interface between high-level algorithmic instructions and the physical layer of quantum control, with direct applications in automated quantum compilers, error-corrected gate synthesis, and human-quantum machine interaction platforms. The formalism is generalizable to multi-qubit operations and adaptable to other qubit modalities, offering a template for standardizing quantum hardware control abstraction.

Dec 27, 20250 citations

Matrix‑Product Unitaries on Quantum Hardware

David Mulnix

This paper, “Matrix‑Product Unitaries on Quantum Hardware,” presents a set of experimental studies examining how different classes of Matrix‑Product Unitaries behave when executed on real superconducting quantum hardware. The work investigates several MPU constructions—including the CZ layer, non‑uniform MPUs, high‑bond MPUs, and multilayer MPUs—and evaluates their statistical, geometric, and correlation signatures under a variety of structured superposition inputs. As far as is known, this is the first time MPU operators have been systematically implemented and analyzed on physical quantum devices. The experiments use a geometric operator framework to extract, project, and reconstruct MPU operators before synthesizing them into native gate sets for hardware execution. Although the geometric method is used to generate the operators, the resulting circuits are valid MPU implementations independent of the extraction technique. The paper compares hardware‑executed MPU behavior against several baseline circuits, analyzes entropy, mutual information, collapse geometry, and classical statistical distances, and demonstrates that MPU operators form a distinctive operator class with reproducible hardware fingerprints.

Sep 12, 20260 citations

A Quantum Computation Language-based Quantum Compiler

S. Jaya Amruth, T.M. Nigelesh, V. Sai Shruthik +2 more

Quantum computing is a revolution in computational theory that uses the principles of quantum mechanics to perform computations that are beyond the capacity of classical computers. It works with the special features of the quantum bits or qubits to encode and transform the information in manners conventional bits cannot imagine. A quantum compiler is a software tool designed to translate high-level quantum language code into executable quantum instructions. This paper aims to develop a quantum compiler for translating Quantum Computation Language source codes into quantum bytecodes which can later be executed on a Quantum Virtual Machine. This compiler will have a combinational structure that includes a frontend for interpreting the QCL code, an intermediate representation for optimizing quantum algorithms, and a backend for generating efficient quantum bytecode. Optimization techniques will be applied to improve the functioning of the quantum circuits. The compiler will also include an error handling module to handle the errors. The successful deployment of a quantum compiler for QCL has many implications and unlocks opportunities for advancements in quantum technologies.

International Conference on Computing, Communication and Networking Technologies (ICCCNT)Jun 24, 20240 citations

Quantum Geometry Verification of Quantum Algorithms: A Novel Approach

Jincheng Zhang

Quantum Geometry Verification of Quantum Algorithms presents a fundamentally new method for validating quantum algorithms by leveraging the inherent properties of quantum geometry. This paper introduces a novel algorithm that transforms quantum algorithm execution into a quantum geometric representation, allowing for rigorous verification of algorithmic correctness and stability. The core mechanism centers on modeling the algorithm's process as a quantum geometric system, employing self-similarity to identify and correct errors inherent in the algorithm's execution. We demonstrate the efficacy of this approach through a series of rigorous analyses, establishing a new benchmark for quantum algorithm verification and offering a pathway towards more reliable and trustworthy quantum computation.

Aug 31, 20260 citations

Intent-Level Quantum Programming with Assertion-Guided Execution and Inspectable Intermediate Representation

Ilesh Vora, Srikanth Thudumu, John Carlson +2 more

Quantum programs are difficult to validate: circuits are typically expressed as imperative gate sequences with limited inspectability, execution modalities must be selected manually, and outputs are inherently probabilistic. These challenges are compounded when programs must be portable across backend frameworks with differing internal conventions. We present a quantum domain-specific language (QDSL) that addresses these problems through three mechanisms: (i) intent-execution separation, where algorithmic constructs such as preparation, superposition, entanglement, and measurement are represented as inspectable objects compiled into backend-specific circuits only after pre-execution Intermediate Representation (IR) validation; (ii) first-class IR introspection, exposing circuit width, wire mapping, operation order, and measurement intent for developer inspection prior to execution; and (iii) assertion-guided modality inference, where the engine examines declared verification properties to automatically select sampling, statevector, or dual execution without user intervention. Results are logged in structured form to support reproducible regression testing. We evaluate our prototype on benchmark circuits spanning entanglement, oracle-based, structured-transform, and variational examples. In fault-injection experiments on Bell and 3-qubit GHZ circuits, a total-variation-distance detector identifies the injected faults across all evaluated shot budgets (True Positive Rate 1.0), with observed false positives (False Positive Rate 2.7-3.8%) only at 128 shots. Differential testing demonstrates numerical agreement across PennyLane and Qiskit compilation targets for the evaluated constructs after endianness canonicalization. IR generation costs are sub-millisecond.

cs.SECross-listedarXiv:2608.02648Aug 4, 20260 citations