Searcharxiv⌕ Search

arXiv subjects

Amr Sabry

Publications and source records attributed to Amr Sabry.

At least 19 recordsLinked to original sources

Variational Programs with Open Clocks

Variational quantum algorithms leave the durations of Hamiltonian evolutions open for a classical optimizer to set. We present VHamilton, a minimal extension of the Hamilton quantum programming language in which such durations are open clocks: one program denotes a family of Hamiltonian trajectories, and a valuation fills its clocks with exact dyadic times, so that each instance is an ordinary Hamilton program that compiles to circuits as before. Because the semantics stays exact and affine in the clocks, the Hamiltonian structure of a variational program remainsavail able for reasoning about every valuation at once. Equivalence becomes a finite calculation, which we mechanize in Agda for a fragment and use to prove the VHamilton form of the compiler rewrite "rzz(t) = cx; rz(t); cx" for every clock value. We then show what the same structure supports in a two-qubit chemistry eigensolver written in VHamilton and run through a Haskell prototype. It supports a fusion of commuting blocks, a closed form and an expressibility proof for the ansatz, and an exact split of the error between the precision of the target and that of the clocks, with a priori bounds. It also supports a coordinate search whose queries per sweep, fixed by the spectra of the generators, do not grow with the precision. On the benchmark this search reaches the numerically verified optimum of a grid of 134 million valuations in 53 energy queries. It finds the grid optimum in only 21 of 30 validation settings, however, so the gain is conditional, not a global-optimization guarantee.

quant-ph↗

Qurator: Scheduling Hybrid Quantum-Classical Workflows Across Heterogeneous Cloud Providers

We present Qurator, a quantum-classical task scheduler that jointly optimizes queue time and circuit fidelity across heterogeneous architectures. Qurator models hybrid workloads as dynamic DAGs with explicit quantum semantics, including entanglement dependencies, synchronization barriers, no-cloning constraints, and circuit cutting and merging decisions. Fidelity is estimated through a unified logarithmic success score that reconciles incompatible calibration data from IBM, IonQ, IQM, Rigetti, AQT, Pasqal and other providers into a canonical set of gate error, readout fidelity, and decoherence terms. We evaluate Qurator on a simulator driven by four months of real queue data using circuits from the Munich Quantum Toolkit benchmark suite. Across load conditions from 5 to 35,000 quantum tasks with up to 120,000 classical tasks, Qurator stays within 1% of the highest-fidelity baseline at low load, achieves 30-75% queue time reduction at high load, all at a fidelity cost bounded by a user-specified target while improving on list and fair schedulers as well as state of the art schedulers on both metrics.

quant-ph↗

Half the Interference, Most of the Answer: Approximate Quantum Simulation via Path-Sum Pruning

Classical simulation of quantum circuits is expensive for two distinct reasons. The obvious one is state-space size: an n-qubit system requires exponentially many amplitudes. The less obvious one is interference: useful output distributions emerge only after many computational histories have been coherently combined at common endpoints, and this aggregation step is itself a substantial source of cost. We introduce statistical interference sampling, a framework that makes this second bottleneck explicit by treating endpoint interference as a separately schedulable computation. Using the Chemical Abstract Machine (ChAM) as our model, weighted path contributions evolve as concurrent molecular species, and interference reactions combine contributions that share a common output state. A threshold rule terminates the process once an endpoint accumulates sufficient amplitude, discarding the remaining reactions. The method does not improve worst-case complexity and is not intended as a general-purpose simulator. Its purpose is to ask a more targeted question: how much of the interference calculation can be skipped while still recovering a useful output distribution? On benchmark circuits for Deutsch-Jozsa, Grover search, Simon's problem, and small Shor period-finding instances, we find that nearly 50% of endpoint interference reactions can be omitted while maintaining over 90% output accuracy for most algorithms tested. These results suggest that interference arithmetic is a structured resource that admits meaningful approximation, and that exposing it explicitly opens new opportunities for pruning strategies across path-sum, Pauli-path, and tensor-network simulation methods.

quant-ph↗

Scaling Local Solvers with the Many-Body Expansion

We introduce a Many-Body Expansion framework for scaling black-box solvers for discrete optimization. The method decomposes a large problem into fragments, repeatedly improves each fragment with the rest of the assignment held fixed, and then applies targeted corrections on unions of fragments. The solver itself is unchanged: it only receives a restricted subproblem and returns a candidate assignment. The framework separates decomposition from solver design. Moebius inversion gives an exact fragment expansion of the objective, and for pairwise objectives such as graph coloring, MAX-CUT, and QUBO the expansion closes at second order. The promoted solver is monotone by construction, terminates in finitely many productive sweeps for non-negative integer-valued objectives, and connects to junction-tree dynamic programming when the fragment interaction structure is acyclic and full response functions are propagated. On graph coloring benchmarks, the promoted versions of TabuSearch and simulated annealing (SA) generally outperform flat applications of the same solvers, often finding better solutions in less CPU time, and the gain proves insensitive to the choice of graph partition. A facility-location study delimits the claim: there the partition must respect the objective's interaction locality, and the promoted solver reaches within 0.3-1.4% of GLPK-certified optima at every tested size. The same wrapper interface is used in each solver-swap case, and the facility-location check reuses the same monotone guard with a sign-adjusted interaction diagnostic; the improvements therefore come from the MBE promotion mechanism rather than solver-specific tuning.

math.OC↗

Hidden Prime-Factor Subgroups in Molecular and Condensed-Phase Systems

We describe a group theoretic analysis of Shor's algorithm and other related hidden subgroup problems in mathematics and relate these to symmetries of molecular and condensed phase assemblies. By recasting Shor's algorithm through the lens of group theory, we expose the possibility that physical systems such as molecular orbitals, condensed phase assemblies and optical beams may be designed such that these contain information pertaining to the solution to hard mathematical problems such as prime-factoring. We discuss real molecular systems, whose orbitals are constructed from symmetry-adapted linear combinations of atomic orbitals, and show that these contain information pertaining to the prime-factors of corresponding integers. Due to the broad significance of prime-factoring towards a variety of encryption problems in cyber-security, we believe this novel and fundamental approach may have broad impact.

quant-ph↗

Free Quantum Computing

Quantum computing improves substantially on known classical algorithms for various important problems, but the nature of the relationship between quantum and classical computing is not yet fully understood. This relationship can be clarified by free models, that add to classical computing just enough physical principles to represent quantum computing and no more. Here we develop an axiomatisation of quantum computing that replaces the standard continuous postulates with a small number of discrete equations, as well as a free model that replaces the standard linear-algebraic model with a category-theoretical one. The axioms and model are based on reversible classical computing, isolate quantum advantage in the ability to take certain well-behaved square roots, and link to various quantum computing hardware platforms. This approach allows combinatorial optimisation, including brute force computer search, to optimise quantum computations. The free model may be interpreted as a programming language for quantum computers, that has the same expressivity and computational universality as the standard model, but additionally allows automated verification and reasoning.

quant-ph↗

A Verified Compiler for Quantum Simulation

Hamiltonian simulation is a central application of quantum computing, with significant potential in modeling physical systems and solving complex optimization problems. Existing compilers for such simulations typically focus on low-level representations based on Pauli operators, limiting programmability and offering no formal guarantees of correctness across the compilation pipeline. We introduce QBlue, a high-level, formally verified framework for compiling Hamiltonian simulations. QBlue is based on the formalism of second quantization, which provides a natural and expressive way to describe quantum particle systems using creation and annihilation operators. To ensure safety and correctness, QBlue includes a type system that tracks particle types and enforces Hermitian structure. The framework supports compilation to both digital and analog quantum circuits and captures multiple layers of semantics, from static constraints to dynamic evolution. All components of QBlue, including its language design, type system, and compilation correctness, are fully mechanized in the Rocq proof framework, making it the first end-to-end verified compiler for second-quantized Hamiltonian simulation.

cs.PL↗

Quantum Simulation Programming via Typing

Quantum simulations are designed to model quantum systems, and many compilation frameworks have been developed for executing such simulations on quantum computers. Most compilers leverage the capabilities of digital and analog quantum computers by representing quantum particle systems with Pauli strings or digital quantum circuits, making it challenging for users in physics, chemistry, and biology to program simulations effectively. QBLUE is proposed as the first programming language for describing the behaviors of quantum systems in terms of second quantization Hamiltonians. Within QBLUE, a novel type system is proposed to clearly define states across different quantum systems and treat quantum computers as quantum particle systems of specific types. The type system is compatible with the compilation of quantum simulations expressed in QBLUE for digital and analog quantum computers. With QBLUE, users can specify the desired quantum particle system and model the system on quantum computers.

quant-ph↗

Scheme Pearl: Quantum Continuations

We advance the thesis that the simulation of quantum circuits is fundamentally about the efficient management of a large (potentially exponential) number of delimited continuations. The family of Scheme languages, with its efficient implementations of first-class continuations and with its imperative constructs, provides an elegant host for modeling and simulating quantum circuits.

cs.PL↗

Compositional Reversible Computation

Reversible computing is motivated by both pragmatic and foundational considerations arising from a variety of disciplines. We take a particular path through the development of reversible computation, emphasizing compositional reversible computation. We start from a historical perspective, by reviewing those approaches that developed reversible extensions of lambda-calculi, Turing machines, and communicating process calculi. These approaches share a common challenge: computations made reversible in this way do not naturally compose locally. We then turn our attention to computational models that eschew the detour via existing irreversible models. Building on an original analysis by Landauer, the insights of Bennett, Fredkin, and Toffoli introduced a fresh approach to reversible computing in which reversibility is elevated to the status of the main design principle. These initial models are expressed using low-level bit manipulations, however. Abstracting from the low-level of the Bennett-Fredkin-Toffoli models and pursuing more intrinsic, typed, and algebraic models, naturally leads to rig categories as the canonical model for compositional reversible programming. The categorical model reveals connections to type isomorphisms, symmetries, permutations, groups, and univalent universes. This, in turn, paves the way for extensions to reversible programming based on monads and arrows. These extensions are shown to recover conventional irreversible programming, a variety of reversible computational effects, and more interestingly both pure (measurement-free) and measurement-based quantum programming.

cs.LO↗

With a Few Square Roots, Quantum Computing is as Easy as Π

Rig groupoids provide a semantic model of \PiLang, a universal classical reversible programming language over finite types. We prove that extending rig groupoids with just two maps and three equations about them results in a model of quantum computing that is computationally universal and equationally sound and complete for a variety of gate sets. The first map corresponds to an $8^{\text{th}}$ root of the identity morphism on the unit $1$. The second map corresponds to a square root of the symmetry on $1+1$. As square roots are generally not unique and can sometimes even be trivial, the maps are constrained to satisfy a nondegeneracy axiom, which we relate to the Euler decomposition of the Hadamard gate. The semantic construction is turned into an extension of \PiLang, called \SPiLang, that is a computationally universal quantum programming language equipped with an equational theory that is sound and complete with respect to the Clifford gate set, the standard gate set of Clifford+T restricted to $\le 2$ qubits, and the computationally universal Gaussian Clifford+T gate set.

cs.PL↗

The Quantum Effect: A Recipe for QuantumPi

Free categorical constructions characterise quantum computing as the combination of two copies of a reversible classical model, glued by the complementarity equations of classical structures. This recipe effectively constructs a computationally universal quantum programming language from two copies of Pi, the internal language of rig groupoids. The construction consists of Hughes' arrows. Thus answer positively the question whether a computational effect exists that turns reversible classical computation into quantum computation: the quantum effect. Measurements can be added by layering a further effect on top. Our construction also enables some reasoning about quantum programs (with or without measurement) through a combination of classical reasoning and reasoning about complementarity.

cs.PL↗

Quantum Computation of Hydrogen Bond Dynamics and Vibrational Spectra

Calculating the observable properties of chemical systems is often classically intractable and is widely viewed as a promising application of quantum information processing. Yet one of the most common and important chemical systems in nature - the hydrogen bond - has remained a challenge to study using quantum hardware on account of its anharmonic potential energy landscape. Here, we introduce a framework for solving hydrogen-bond systems and more generic chemical dynamics problems using quantum logic. We experimentally demonstrate a proof-of-principle instance of our method using the QSCOUT ion-trap quantum computer, in which we experimentally drive the ion-trap system to emulate the quantum wavepacket of the shared-proton within a hydrogen bond. Following the experimental creation of the shared-proton wavepacket, we then extract measurement observables such as its time-dependent spatial projection and its characteristic vibrational frequencies to spectroscopic accuracy (3.3 cm$^{-1}$ wavenumbers, corresponding to > 99.9% fidelity). Our approach introduces a new paradigm for studying the quantum chemical dynamics and vibrational spectra of molecules, and when combined with existing algorithms for electronic structure, opens the possibility to describe the complete behavior of complex molecular systems with unprecedented accuracy.

quant-ph↗

A Synthesis of Hidden Subgroup Quantum Algorithms and Quantum Chemical Dynamics

We describe a general formalism for quantum dynamics and show how this formalism subsumes several quantum algorithms including the Deutsch, Deutsch-Jozsa, Bernstein-Vazirani, Simon, and Shor algorithms as well as the conventional approach to quantum dynamics based on tensor networks. The common framework exposes similarities among quantum algorithms and natural quantum phenomena: we illustrate this connection by showing how the correlated behavior of protons in water wire systems that are common in many biological and materials systems parallels the structure of Shor's algorithm.

quant-ph↗

Retrodictive Quantum Computing

Quantum models of computation are widely believed to be more powerful than classical ones. Efforts center on proving that, for a given problem, quantum algorithms are more resource efficient than any classical one. All this, however, assumes a standard predictive paradigm of reasoning where, given initial conditions, the future holds the answer. How about bringing information from the future to the present and exploit it to one's advantage? This is a radical new approach for reasoning, so-called Retrodictive Computation, that benefits from the specific form of the computed functions. We demonstrate how to use tools of symbolic computation to realize retrodictive quantum computing at scale and exploit it to efficiently, and classically, solve instances of the quantum Deutsch-Jozsa, Bernstein-Vazirani, Simon, Grover, and Shor's algorithms.

quant-ph↗

Symmetries in Reversible Programming: From Symmetric Rig Groupoids to Reversible Programming Languages

The $\mathitΠ$ family of reversible programming languages for boolean circuits is presented as a syntax of combinators witnessing type isomorphisms of algebraic datatypes. In this paper, we give a denotational semantics for this language, using the language of weak groupoids à la Homotopy Type Theory, and show how to derive an equational theory for it, presented by 2-combinators witnessing equivalences of reversible circuits. We establish a correspondence between the syntactic groupoid of the language and a formally presented univalent subuniverse of finite types. The correspondence relates 1-combinators to 1-paths, and 2-combinators to 2-paths in the universe, which is shown to be sound and complete for both levels, establishing full abstraction and adequacy. We extend the already established Curry-Howard correspondence for $\mathitΠ$ to a Curry-Howard-Lambek correspondence between Reversible Logic, Reversible Programming Languages, and Symmetric Rig Groupoids, by showing that the syntax of $\mathitΠ$ is presented by the free symmetric rig groupoid, given by finite sets and permutations. Our proof uses techniques from the theory of group presentations and rewriting systems to solve the word problem for symmetric groups. Using the formalisation of our results, we show how to perform normalisation-by-evaluation, verification, and synthesis of reversible logic gates, motivated by examples from quantum computing.

cs.PL↗

Mapping quantum chemical dynamics problems onto spin-lattice simulators

The accurate computational determination of chemical, materials, biological, and atmospheric properties has critical impact on a wide range of health and environmental problems, but is deeply limited by the computational scaling of quantum-mechanical methods. The complexity of quantum-chemical studies arises from the steep algebraic scaling of electron correlation methods, and the exponential scaling in studying nuclear dynamics and molecular flexibility. To date, efforts to apply quantum hardware to such quantum chemistry problems have focused primarily on electron correlation. Here, we provide a framework which allows for the solution of quantum chemical nuclear dynamics by mapping these to quantum spin-lattice simulators. Using the example case of a short-strong hydrogen bonded system, we construct the Hamiltonian for the nuclear degrees of freedom on a single Born-Oppenheimer surface and show how it can be transformed to a generalized Ising model Hamiltonian. We then demonstrate a method to determine the local fields and spin-spin couplings needed to identically match the molecular and spin-lattice Hamiltonians. We describe a protocol to determine the on-site and inter-site coupling parameters of this Ising Hamiltonian from the Born-Oppenheimer potential and nuclear kinetic energy operator. Our approach represents a paradigm shift in the methods used to study quantum nuclear dynamics, opening the possibility to solve both electronic structure and nuclear dynamics problems using quantum computing systems.

physics.chem-ph↗

Fractional Types: Expressive and Safe Space Management for Ancilla Bits

In reversible computing, the management of space is subject to two broad classes of constraints. First, as with general-purpose computation, every allocation must be paired with a matching de-allocation. Second, space can only be safely de-allocated if its contents are restored to their initial value from allocation time. Generally speaking, the state of the art provides limited partial solutions that address the first constraint by imposing a stack discipline and by leaving the second constraint to programmers' assertions. We propose a novel approach based on the idea of fractional types. As a simple intuitive example, allocation of a new boolean value initialized to $\texttt{false}$ also creates a value $1/{\texttt{false}}$ that can be thought of as a garbage collection (GC) process specialized to reclaim, and only reclaim, storage containing the value $\texttt{false}$. This GC process is a first-class entity that can be manipulated, decomposed into smaller processes and combined with other GC processes. We formalize this idea in the context of a reversible language founded on type isomorphisms, prove its fundamental correctness properties, and illustrate its expressiveness using a wide variety of examples. The development is backed by a fully-formalized Agda implementation.

cs.PL↗