Using Quantum Computing to Test a Design Methodology
Why we built a quantum computer
This project did not begin with the goal of designing a quantum computer.
It began with a much simpler question:
Does our internal geometric framework actually make engineering better?
If the geometry was useful, it should help solve difficult engineering problems. If it wasn’t, we wanted to discover that early and move on.
Quantum error correction turned out to be an ideal benchmark. It combines an enormous design space with tightly coupled constraints, making it one of the most demanding optimization problems in engineering today. If our design methodology offered a genuine advantage, we expected it to become visible here.
The experiment
We built a quantum-computing design engine around exactly the same conventional simulation tools used by the broader quantum-computing community.
The only thing we changed was the internal representation used to search for candidate architectures.
We then compared two versions of the design engine:
Using conventional optimization techniques.
Using the constraint-derived building blocks described elsewhere on this site.
Everything downstream remained the same.
Every candidate architecture was compiled into a conventional representation before being evaluated with independent, open-source quantum simulation and decoding software.
The geometry never replaced the simulators.
It only determined which designs reached them.
What surprised us
Without the internal geometry, the design engine could not discover simulated architectures requiring fewer than approximately 4,000 physical qubits per logical qubit.
As the geometry evolved, something unexpected happened.
Each time we repaired weaknesses exposed by increasingly difficult constraint sets, the design engine became more effective.
The simulated ratio improved through successive generations of the design system—from roughly 800:1 to approximately 19:1 under the selected noise assumptions.
The number itself is encouraging.
The more important observation is why it improved.
The geometry wasn’t making the simulations more optimistic.
It was making the search space dramatically more intelligent.
The real breakthrough wasn’t 19:1
The most important result came before the final optimization.
The first search identified an architecture family in which the simulated physical-to-logical qubit ratio remained essentially independent of computer size.
That changed the engineering problem completely.
Instead of trying to reduce a ratio that grew worse as the computer became larger, we were optimizing inside a family whose scaling behavior had already been established.
A second topological search inside that family then reduced the projected overhead to approximately 19 physical qubits per logical qubit.
Future work may improve that number further.
The discovery of the search space is the more valuable result.
How the geometry helps
The geometry is not used to simulate quantum mechanics.
It is used to organize the engineering problem before simulation begins.
Several parts of the framework proved especially important.
Constraint propagation
The geometry exposes dependencies that would otherwise remain hidden.
Instead of treating every parameter as independent, constraints propagate through the design and eliminate impossible architectures before optimization begins.
Large portions of the search space disappear immediately.
Parameter collapse
Conventional optimization often assumes thousands of independent design variables.
The geometry reveals that many of those apparent choices are actually consequences of deeper structural decisions.
As additional constraints are applied, many independent parameters collapse into a much smaller number of meaningful degrees of freedom.
This dramatically reduces the effective search space while preserving the designs that satisfy every known requirement.
Symmetry reduction
Many candidate architectures are physically equivalent even though they appear different computationally.
The geometry groups these equivalent solutions together so the design engine explores the underlying design once instead of rediscovering it repeatedly.
This substantially reduces redundant computation.
Topological organization
The geometry distinguishes between changes that merely rearrange a design and changes that fundamentally alter its protection structure.
This allows optimization to proceed without accidentally leaving the architecture family being investigated.
Scale separation
Some properties should remain invariant as a quantum computer grows.
Others naturally scale with system size.
The geometry keeps those relationships separate, allowing the design engine to optimize local structure without destroying desirable global behavior.
This was essential in identifying a family with constant simulated overhead.
Structural admissibility
Rather than optimizing every conceivable design, the geometry first determines whether a candidate belongs to an admissible family at all.
Architectures that violate structural requirements are rejected before expensive simulation begins.
Optimization effort is therefore concentrated on designs that already satisfy the highest-level constraints.
Conventional verification
The geometry does not replace engineering simulation.
Every surviving design is compiled into conventional engineering representations and evaluated using independent software.
Our archived validation used multiple open-source tools from the quantum-computing community, including circuit simulation, realistic noise modeling and quantum-error-correction decoding. Representative tools include Stim, PyMatching, qecsim, Qiskit Aer, Cirq, QuTiP, and Plaquette, depending on the aspect being evaluated.
This separation is intentional.
The internal geometry proposes candidates.
Conventional engineering tools judge them.
Why physics matters
The geometry itself did not come from quantum computing.
It evolved while attempting to satisfy increasingly difficult constraint sets drawn from fundamental physics.
Every time those constraints exposed a weakness, we modified the geometry.
Every time the geometry improved, the engineering design engine improved with it.
That feedback loop was unexpected.
It is the primary reason this research continues.
Where we are today
The current design remains a simulation result, not an experimental demonstration.
Independent hardware validation is still required.
The value of the work today is not that it claims to have solved quantum computing.
The value is that a constraint-first engineering methodology, developed and refined using difficult problems in fundamental physics, repeatedly produced better engineering designs than the same methodology without those building blocks.
Whether the final architecture evolves or not, that result convinced us that the methodology itself is worth pursuing.