QCD splittings as quantum circuit primitives

In arXiv:2605.06789, Physics inspired quantum algorithm for QCD splitting functions [1], we study a small quantum circuit primitive for one of the basic objects of collider physics: a parton splitting.

The motivation is simple. If quantum algorithms are going to be useful for collider event generation, they should not only be generic machine-learning ansatze with physics labels attached afterward. They should encode some of the structure that particle physicists already know is important.

For QCD splittings, that structure includes momentum sharing, helicity information, and correlations generated at the splitting vertex. The paper builds a two-qubit primitive for the pure-gluon channel, with circuit parameters connected to the momentum fraction carried by the outgoing gluons. In this setup, the circuit is not just a black-box generator. Its rotations and measurement outcomes have a direct physics interpretation.

I want to walk through why that works, one piece at a time, the way I'd explain it on a whiteboard.

A gluon splits: the physics picture

A parton shower is built out of repeated elementary branchings $a \to b + c$, each weighted by a splitting function, a picture that collinear factorisation makes rigorous. We focus on the $g \to gg$ channel specifically because it has no classical-electrodynamics analogue: it exists only because $SU(3)$ is non-abelian, and it dominates high transverse-momentum shower evolution at the LHC through processes like $gg \to ggg$.

The kinematics of this vertex are standard. What the paper adds is a quantum-information reading of the same vertex.

Entanglement at the splitting vertex

Encode the helicity of each outgoing gluon as a qubit — left-handed $\leftrightarrow |0\rangle$, right-handed $\leftrightarrow |1\rangle$ — and trace out the colour degrees of freedom from the scattering amplitude. What's left is a two-qubit spin density matrix $\hat\rho_{sc}$ describing the joint helicity state of the two daughter gluons. Because this is a genuine two-qubit quantum state, you can ask a genuinely quantum question of it: how entangled are the two outgoing gluons, as a function of the momentum fraction $z$ carried by one of them?

The answer, quantified through the concurrence (the standard entanglement measure for two-qubit states), comes out in closed form:

Three features fall out immediately, and each one has a direct physical reading. It peaks at $z=0.5$: equal momentum sharing entangles the daughters the most. It vanishes as $z \to 0$ or $z \to 1$: when one gluon carries essentially all the momentum, the two-particle state factorises into a product state — there's really only one particle left to talk about. And it's symmetric under $z \to 1-z$, simply because swapping which outgoing gluon you call "first" cannot change the physics.

A two-qubit circuit for a splitting

The next step is to build a two-qubit circuit whose measurement statistics reproduce both pieces of physics at once: the momentum split $z, 1-z$ and the entanglement $\mathcal{C}_{\rm QCD}(z)$.

The circuit has three free angles. Solving the constraint $a+b=1$ collapses one of them, and the momentum fraction comes out as a closed-form function of the other two:

You then compute the concurrence of the circuit's own output state, $\mathcal{C}_{\rm circuit}(\gamma_1,\gamma_3)$, and numerically solve for the $(\gamma_1,\gamma_3)$ pair that makes $\mathcal{C}_{\rm circuit}(\gamma_1,\gamma_3(\gamma_1,z)) = \mathcal{C}_{\rm QCD}(z)$ at the desired $z$. The rotations aren't free parameters fitted to reproduce a distribution after the fact — they're pinned down by matching the QCD entanglement structure exactly, for every value of $z$. Because this two-qubit block is going to be reused as a building block, it's useful to give it a name and a compact symbol:

Composing primitives into a shower

Here is the idea that makes this more than a curiosity: $U_S$'s input convention and output convention are the same object. Feeding $|00\rangle$ into $U_S$ corresponds to an incoming particle with momentum fraction $z=1$ — the start of a shower. But $U_S$'s output qubit $A$ also encodes a momentum fraction as $\langle\sigma_3\rangle_A$. So you can take the higher-momentum output qubit of one splitting and feed it, via a CNOT, straight into a fresh copy of $U_S$ as its new "incoming particle" — exactly like a shower where the more energetic daughter is the one that's most likely to radiate again.

That cartoon is exactly what the actual circuit looks like once you compose two $U_S$ blocks with a CNOT:

Tracking which qubit carries the highest momentum fraction is not bookkeeping for its own sake — because of the running of the QCD coupling, higher-momentum partons are more likely to split again, so knowing which wire holds the leading fraction tells you exactly where to attach the next $U_S$ block. Iterating this once more, on both daughters of the first splitting, gives the four-prong structure, using four qubits worth of ancillas and four $U_S$ blocks wired together the same way.

Calibrating to real LHC data

Everything so far is perturbative QCD, fixed by theory. The next step grounds the circuit in data. Using the AspenOpenJets dataset (built from 2016 CMS Open Data), the paper reconstructs anti-$k_T$ jets with $R=0.8$, $p_T > 300$ GeV and $|\eta|<2.4$, then reclusters the constituents with the Cambridge/Aachen algorithm at $R=0.4$ and declusters the resulting tree. This gives, for real jets, an empirical distribution of momentum-sharing fractions $z$ at the first branching — a direct experimental proxy for the earliest QCD splitting.

For every measured $z_g$ in the dataset, the paper solves the same numerical matching problem from the previous section — find $(\gamma_1,\gamma_3)$ such that $z(\gamma_1,\gamma_3) = z_g$ and $\mathcal{C}_{\rm circuit} = \mathcal{C}_{\rm QCD}(z_g)$ — building up an empirical distribution over circuit parameters rather than a single fixed circuit. That distribution of $(\gamma_1,\gamma_2,\gamma_3)$ is what gets reused when composing multi-prong circuits.

Does it reproduce the data?

With circuit parameters calibrated on the two-prong structure alone, the composed three- and four-prong circuits are run — with no further fitting — and compared against the three and four hardest reconstructed prongs in the same dataset.

The four-prong case shows the same level of agreement (not reproduced here), which is the more surprising result: a circuit whose three free angles were only ever calibrated against the two-prong distribution correctly predicts three- and four-prong structure once composed, with no additional tuning at each level.

Hardware as a sanity check

The three-prong circuit was also executed on real superconducting hardware — 500 independent circuit executions with 1024 shots each on ibm_Marrakesh, using parameters independently sampled from the calibrated distribution. The postprocessing is modest and physically motivated rather than aggressive curve-fitting: unphysical outcomes such as negative momentum fractions are discarded, and because shot noise tends to push near-unity expectation values downward, a small shift compensates for that known bias. After that, hardware, simulator, and data agree well, which is the point — the circuit is shallow and uses few enough qubits that noise doesn't wash out the physics.

That is a useful sanity check. For near-term quantum work in particle physics, I prefer small demonstrations with clear physics semantics over large circuits where the scientific interpretation is hidden behind optimisation. A shallow primitive that can be inspected, calibrated, and composed is easier to debug — and, as this result shows, easier to actually run.

What I like about this direction

The strongest part of this approach is that it treats quantum circuits as physics objects, not only as function approximators. The helicity entanglement generated by the splitting vertex is part of the construction. The measured momentum fractions are part of the construction. The composition rule — feed the leading qubit forward, because leading partons are the ones QCD predicts will split again — is part of the construction.

That does not solve event generation. But it gives a concrete module that can be tested, rejected, improved, or connected to larger workflows. For quantum computing in HEP, that is the right unit of progress.

The next useful questions are practical ones: how robust is the primitive under detector effects, how does it behave across quark and gluon channels, what classical baselines should it be compared with, and how far can the composition be pushed before noise and modelling assumptions dominate? The paper is also upfront about what's still missing: there's no Sudakov factor yet to decide whether a parton splits at all (only what happens given that it does), and the colour structure needed for hadronisation isn't modelled.

Those are the questions that make this line of work worth pursuing. If you're interested in a related physics-informed approach to quantum generative modelling, I wrote a companion piece on quantum Boltzmann machines applied to jet substructure — a different mechanism (entanglement standing in for connectivity, rather than for a fixed splitting function) aimed at a similar problem.

References