Can Better Mathematics Make Quantum Computers Smaller?
My research on quantum algorithms, gauge transformations and the role of mathematical representation
Much of the discussion around quantum computing is focused on hardware.
How many qubits can we build? How high can we push gate fidelity? How long can coherence be maintained? How many physical qubits will eventually be required to construct a useful fault-tolerant logical qubit?
These are fundamental questions. But my research starts from a complementary question:
What if part of the quantum computing scaling problem can be attacked mathematically, before we solve it physically?
I am interested in whether the mathematical representation of a problem can materially affect how efficiently it can be executed on real quantum hardware.
More specifically, I am studying whether two mathematically equivalent representations of the same underlying object can produce quantum circuits with very different computational characteristics: different circuit depths, different numbers of entangling gates, different noise sensitivity, different measurement distributions and potentially different amounts of hardware required to extract a useful answer.
This leads to a broader hypothesis that guides much of my work:
The number of qubits required for useful quantum computation is not purely a hardware question. It is also a question of mathematical representation.
An experiment on PIAST-Q
I am currently exploring this question experimentally on PIAST-Q, the EuroHPC quantum computer located at the Poznań Supercomputing and Networking Center in Poland.
PIAST-Q is a trapped-ion quantum computer with 20 data qubits, all-to-all connectivity, reported gate fidelities above 99 percent and support for Qiskit and PennyLane. Its trapped-ion architecture makes it an interesting platform for experiments where circuit structure, connectivity and gate decomposition can be studied directly on physical quantum hardware.
My present experiment begins with a mathematical object from another part of my research: a 2 × 2 Conservative Matrix Field, or CMF.
A CMF can be viewed as a discrete matrix-valued connection. Local matrices describe transitions through a lattice, while a flatness or compatibility condition allows matrix products along different paths to represent the same global mathematical structure.
The important feature for the quantum experiment is that the same CMF can be expressed in multiple gauge-equivalent representations.
Schematically, if a matrix describes transport between two lattice positions, a gauge transformation can produce a new representation of the form
for suitable invertible matrices .
The individual matrices may now look very different, while important global properties of the underlying mathematical object remain unchanged.
This creates an unusually clean experimental setting.
Instead of comparing two different algorithms for two different problems, I can start with the same mathematical object, systematically transform its representation and ask what happens when these different representations are translated into quantum circuits and executed on the same quantum hardware.
Does the quantum computer care about the representation?
In exact mathematics, gauge-equivalent descriptions can encode the same underlying structure.
But a physical quantum computer does not execute abstract mathematics directly.
It executes gates.
Those gates have to be synthesized, compiled and implemented on hardware. They require physical operations, and those operations are noisy.
Two mathematically equivalent expressions can therefore lead to circuits with different gate counts, different depths, different entangling structures and different interactions with the hardware topology.
This distinction is central to my experiment.
For each gauge representation of the same CMF, I can compare quantities such as circuit depth, one- and two-qubit gate counts, transpilation cost, measurement distributions, deviation from an ideal simulator, stability across repeated runs and the number of measurements required to estimate the target quantity.
The mathematical result should remain invariant where the experiment is constructed around a gauge-invariant observable.
The computational path toward that result does not necessarily have to be invariant.
That is the opening I am interested in.
Research in other areas of quantum computation already demonstrates that representation matters enormously. Different encodings of the same physical problem can have substantially different qubit and gate requirements. Symmetry-adapted representations can reduce the effective computational space, while alternative encodings can trade qubit count against circuit complexity.
Recent work also shows that circuit synthesis and hardware-aware representations can dramatically alter the depth and gate requirements of quantum simulations. This is particularly important on noisy hardware, where every unnecessary layer is another opportunity for information to be degraded.
My CMF experiment approaches this general problem from a different mathematical direction.
Mathematical representation as quantum preconditioning
A useful analogy comes from classical numerical mathematics.
When solving a difficult linear system,
we do not always attack the raw matrix directly.
We may change coordinates, exploit sparsity, diagonalize part of the system, identify symmetries or construct a preconditioner. The mathematical problem is essentially the same, but its computational geometry becomes much more favorable.
I believe there may be a powerful quantum analogue of this principle.
Before constructing a large quantum circuit, we should ask whether the underlying mathematical object has a representation in which the computation becomes naturally aligned with the quantum architecture.
I think of this as mathematical preconditioning for quantum algorithms.
The preconditioning could come from many areas of mathematics: group theory, representation theory, algebraic geometry, topology, tensor decompositions, symmetry reduction, low-rank structures, gauge theory or other forms of invariant-preserving transformation.
The objective is not simply to make an equation look elegant.
The objective is to transform the mathematics until the corresponding quantum computation becomes cheaper.
Probability is part of the computational resource
There is another dimension to this problem that I find particularly interesting: probability.
Quantum computation ultimately gives us measurement distributions.
A useful algorithm must arrange its state evolution so that useful information can be extracted from those distributions with sufficiently high probability.
This does not mean that a gauge transformation can magically increase the probability of the correct physical answer. If two ideal circuits implement exactly the same quantum transformation and measure the same invariant observable, their physical predictions must agree.
The more interesting possibility is subtler.
A better representation may allow us to construct a circuit that reaches the relevant subspace with fewer operations, avoids unnecessary degrees of freedom, requires fewer ancillas, preserves the desired state distribution better under noise, or concentrates computational effort on the part of Hilbert space containing the information we actually need.
In that sense, probability concentration can itself become an algorithmic design objective.
This idea already appears in several established forms in quantum computing. Quantum algorithms exploit interference to suppress some amplitudes and reinforce others. Symmetries can restrict computation to relevant subspaces. Compact encodings can avoid representing states that are mathematically redundant. Circuit design can reduce the amount of noise accumulated before measurement.
The research question I want to push further is whether there is a more systematic mathematics of representation behind these effects.
Can better representations mean fewer qubits?
This is the larger question.
The Hilbert space of qubits has dimension
But simply having an exponentially large state space does not mean that every problem requires us to use that state space in the most naive possible representation.
A mathematical problem may occupy only a highly structured subset of it.
If we know its conserved quantities, symmetry classes, quotient structures, invariant manifolds or algebraic constraints, then representing every formally possible state may be wasteful.
There are already rigorous examples of this principle.
Symmetry-based fermionic encodings can remove redundant qubits. First-quantized formulations can provide much more compact representations for some many-particle problems. Different binary, Gray-code and unary encodings can produce substantially different resource requirements for precisely the same underlying physics.
Group-theoretic methods can similarly transform a problem into symmetry-adapted sectors, reducing the effective computational problem before the quantum calculation even begins.
This does not imply that clever mathematics eliminates the need for large fault-tolerant quantum computers.
Quantum error correction remains a fundamental requirement for sufficiently deep and accurate large-scale computations, and the physical overhead required to create reliable logical qubits remains one of the central engineering challenges in the field.
But there is an enormous difference between saying that large fault-tolerant machines will be necessary and saying that the algorithmic resource requirements are fixed.
They are not.
A reduction in required logical qubits, circuit depth, non-Clifford operations or measurements can propagate all the way down the hardware stack.
That can be extremely valuable.
Moving the boundary of useful quantum computing
This is why I believe the competition to build useful quantum computers has two equally important fronts.
One is physical:
Build better qubits.
The other is mathematical:
Need fewer of them.
If an industrial problem appears to require 1,000 logical qubits using one mathematical formulation but can be reformulated to require 300, that is not a small software optimization. After error-correction overhead is taken into account, the difference at the physical layer could become very large.
The same reasoning applies to gate counts and circuit depth.
If symmetry, algebraic structure or a better basis can turn a circuit with millions of operations into one with thousands, the date at which a particular calculation becomes physically feasible can move forward substantially.
There are already striking examples in Hamiltonian simulation where improved mathematical and circuit constructions reduce circuit depth by orders of magnitude relative to more direct formulations.
I therefore do not think the path toward industrial quantum computing should be framed only as waiting for hardware to become sufficiently large.
We should simultaneously be asking:
How much smaller can we make the problem?
From CMFs to a broader theory of quantum representations
My current PIAST-Q experiments are a small and deliberately controlled version of this larger research program.
The immediate question is empirical:
Can different gauge representations of exactly the same 2 × 2 Conservative Matrix Field produce measurably different performance on real quantum hardware?
If the answer is yes, the next task is to determine why.
Is performance predicted by matrix norms?
Sparsity?
Spectral structure?
Entanglement requirements?
Conditioning?
Circuit depth?
The distribution of rotation angles?
Some algebraic invariant that has not yet been considered as a quantum resource measure?
And can the best representation be predicted mathematically before the circuit is executed?
That final question is particularly important.
Searching thousands of equivalent circuits and simply selecting the best one would be useful engineering. Discovering a mathematical principle that predicts which representation will be best would be much more interesting.
It could turn representation selection itself into an algorithm.
A long-term research direction
My broader research sits at the intersection of mathematics, machine learning and high-performance computing, and I increasingly see quantum computing through the same lens.
The most interesting computational problems are often not solved simply by increasing brute force.
They are solved by discovering structure.
A symmetry removes variables.
A quotient removes redundancy.
A change of basis reveals sparsity.
A geometric representation exposes invariants.
A better coordinate system transforms a difficult numerical problem into an easier one.
Quantum computing should not be exempt from this history of mathematics.
The hardware revolution is essential. We need better qubits, better control systems, better error correction and eventually much larger fault-tolerant machines.
But in parallel, I believe there is another frontier:
finding mathematical representations that make quantum computers behave as though they were larger than they physically are.
Not by violating computational complexity.
Not by creating information from nowhere.
But by ensuring that fewer qubits, fewer gates and fewer measurements are wasted representing mathematical structure that we already know how to simplify.
That is the question behind my current experiments on PIAST-Q.
And it is a question I expect to keep exploring far beyond this first 2 × 2 matrix system.