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.
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.
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.
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.
Quantum gates are the fundamental instructions of digital quantum computers. Current programming languages, systems, and software development toolkits identify these operational gates by their titles, which requires a shared understanding of their meanings. However, in the continuously developing software ecosystem surrounding quantum computing -- spanning high-level programming systems to low-level control stacks -- this identification process is often error-prone, challenging to debug, maintenance-heavy, and resistant to change. In this paper, we propose replacing this nominal gate representation with a functional one. We introduce the OpenQudit system for describing, parsing, optimizing, analyzing, and utilizing programs comprising gates described as symbolic unitary expressions. As part of this effort, we design the Qudit Gate Language (QGL), a unitary-specific expression language, and implement a differentiating just-in-time compiler in OpenQudit towards embedding this language in quantum programming languages and systems. Additionally, we have precisely designed and implemented the Qudit Virtual Machine (QVM) to evaluate quantum programs and their gradients efficiently. This evaluation is performed millions of times during the compilation of quantum programs. Our QVM can compute gradients approximately ten times faster than current leading numerical quantum compilation frameworks in the most common use cases. Altogether, the OpenQudit system is envisioned to (1) support many-level or qudit-based quantum systems, (2) enable the safe composition of program transformation tools, (3) accelerate circuit optimizers and transpilers, (4) enable compiler extensibility, and (5) provide a productive, simple-to-use interface to quantum practitioners.
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.
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.
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.