Local qubit invariants on quantum computer

This paper presents and experimentally validates two general methods for directly measuring local unitary invariants, specifically important three-qubit entanglement measures, on the IBM Quantum Platform.

The Gist

Imagine you have a magical, invisible box containing a complex quantum state—a "soup" of possibilities where particles are linked together in mysterious ways. This linking is called entanglement, and it's the superpower of quantum mechanics. But here's the problem: if you try to look inside the box to see exactly how the particles are linked, the act of looking changes the soup, or it takes so long to map every single drop that the soup evaporates before you're done.

This paper by Szalay and Holweck is like a new, clever recipe for tasting that soup without ever opening the box or mapping every drop. They show us how to build special "tasting circuits" on a quantum computer to measure specific "flavors" of entanglement directly.

Here is the breakdown of their work using everyday analogies:

1. The Goal: Measuring the "Fingerprint" of Entanglement

In the quantum world, you can rotate or twist your system locally (like spinning a single coin) without changing the fundamental nature of the entanglement. Mathematicians call these Local Unitary (LU) Invariants. Think of them as the fingerprint of the entanglement. No matter how you spin or twist the individual particles, the fingerprint remains the same.

The authors wanted to measure these fingerprints directly on a quantum computer. Previously, people tried to do this by:

• Reconstructing the whole picture (Tomography): Like trying to rebuild a shattered vase by gluing every single piece back together. It's slow and requires a massive amount of data.
• Optimization: Like trying to find the highest point on a mountain by guessing and checking until you get tired. It takes forever.

2. The Solution: Two New "Tasting" Methods

The authors propose two new methods to measure these fingerprints. They translate complex mathematical formulas (which usually involve multiplying and adding numbers in a specific order) into a sequence of quantum logic gates.

Think of the quantum state as a recipe.

• Method 1 (The Efficient Chef): This method uses fewer ingredients (qubits) and fewer steps. It's like a streamlined kitchen where you mix two copies of the recipe together in a specific way to get a taste of the final flavor immediately. It's fast and precise.
• Method 2 (The Backup Chef): This method uses twice as many ingredients and steps. It's like having a second kitchen to double-check the first one. It's more robust if the first kitchen is broken, but it's slower and more prone to "noise" (mistakes), just like a larger kitchen with more people might have more confusion.

The Magic Trick:
Instead of measuring the state directly, they run the circuit and look at the probability of a specific outcome (like getting a "000" result). If the circuit is built correctly, the chance of getting that specific result is directly related to the strength of the entanglement. It's like a magic scale: the heavier the entanglement, the more likely you are to see a specific light blink on your screen.

3. The Test Kitchen: IBM Quantum Computers

The authors didn't just write this on paper; they actually cooked the meal on a real quantum computer (IBM's "Pittsburgh" processor). They tested it on three famous types of quantum "dishes":

• Separable: Particles that aren't linked at all (like three separate coins).
• W-state: A specific type of linked trio where if one breaks, the others stay linked (like a three-legged stool).
• GHZ-state: A super-linked trio where if one breaks, everyone falls apart (like a house of cards).

The Results:

• The "Efficient Chef" (Method 1) worked beautifully. It gave results very close to the theoretical perfect values.
• The "Backup Chef" (Method 2) worked too, but because it used more qubits and steps, it was a bit noisier (more errors), just like a longer recipe is more likely to have a typo.
• They found that even with the "noise" (the quantum computer isn't perfect yet), they could still tell the difference between the different types of entanglement.

4. Why This Matters

Imagine you are a detective trying to solve a crime.

• Old way: You interview every single witness, write down every word, and try to reconstruct the crime scene from scratch. It takes days.
• New way (This paper): You have a special detector that instantly tells you "The suspect was holding a red umbrella" or "The suspect was wearing a hat." You don't need to know the whole story to know the key fact.

This paper shows that we can now build these detectors for quantum computers. It allows us to:

1. Benchmark: Check if a quantum computer is working correctly by seeing if it can measure these known "flavors" of entanglement.
2. Classify: Quickly tell if a quantum system is in a "W" state or a "GHZ" state, which is crucial for building future quantum technologies.

The Bottom Line

Szalay and Holweck have given us a new, efficient toolkit to "taste" the complex flavors of quantum entanglement without having to swallow the whole dish. They turned abstract, centuries-old math (like Cayley's hyperdeterminant) into a practical, physical experiment, proving that even with today's noisy quantum computers, we can start measuring the invisible threads that hold the quantum world together.

Technical Summary

1. Problem Statement

Entanglement is a fundamental non-classical correlation in quantum systems. A complete characterization of entanglement requires Local Unitary (LU) invariants, which are quantities that remain unchanged under local unitary transformations ($U \otimes U \otimes \dots$). While the theory of LU invariants is well-developed mathematically (using index contractions and invariant theory), directly measuring these invariants on physical quantum hardware is challenging.

Existing methods for evaluating LU invariants on quantum computers suffer from significant limitations:

• Ad-hoc methods: Tailored circuits for specific invariants (e.g., concurrence squared) often lack generality.
• Optimization-based methods: Relying on LU-canonical forms requires extensive optimization runs, which are resource-intensive.
• Full State Tomography: Reconstructing the full density matrix to calculate invariants algebraically scales exponentially with the number of qubits ($3^n$ measurement settings for $n$ qubits), making it infeasible for larger systems.

The authors aim to develop general, direct measurement methods for LU invariants on Noisy Intermediate-Scale Quantum (NISQ) devices that avoid full tomography and scale efficiently.

2. Methodology

The paper proposes two general methods to translate the mathematical definition of LU invariants (based on index contractions using Kronecker deltas $\delta$ and Levi-Civita tensors $\epsilon$) into quantum circuits. Both methods utilize $k/2$ copies of the quantum state $|\psi\rangle$, where $k$ is the degree of the invariant (e.g., $k=4$ for concurrence squared). Since quantum cloning is impossible, these copies are generated by running the state preparation oracle $U_\psi$ multiple times.

Method 1: The "Small" Circuit (Interferometric-like)

• Resource Usage: Uses $nk/4$ qubits (e.g., 6 qubits for 3-qubit invariants of degree 4).
• Mechanism: This method relies on the interference between the state $|\psi\rangle$ and its adjoint, transpose, or conjugate.
  • It uses the unitary $U_\psi$ to prepare the state and $U_\psi^\dagger$ (or $U_\psi^T$) to "uncompute" or contract indices.
  • For invariants involving $\epsilon$ (like concurrence), Pauli-$Y$ gates are applied to simulate the antisymmetric contraction.
  • The probability of measuring the all-zero state $|00\dots0\rangle$ directly yields the value of the invariant (or a power of it).
• Advantage: Lower qubit count and fewer CNOT gates, leading to higher precision and lower relative error.

Method 2: The "Large" Circuit (Bell Measurement)

• Resource Usage: Uses $nk/2$ qubits (e.g., 12 qubits for 3-qubit invariants of degree 4).
• Mechanism: This method explicitly creates two copies of the state ($|\psi\rangle \otimes |\psi\rangle$).
  • Index contractions are performed using Bell-state measurements (implemented via Hadamard and CNOT gates, denoted as $B^\dagger$).
  • The measurement outcome probability is proportional to the invariant, though scaled by a factor of $1/2^m$ (where $m$ is the number of Bell measurements).
• Disadvantage: Requires twice as many qubits and more gates, leading to higher noise susceptibility and lower precision compared to Method 1. However, it is useful when implementing the transpose/conjugate of the oracle ($U_\psi^T$) is infeasible.

3. Key Contributions

The authors successfully implemented these methods for two-qubit and three-qubit systems, focusing on important entanglement measures:

• Two-Qubit System:

  • Demonstrated measurement of the Norm-squared ($n^4$) and Concurrence squared ($c^2$).
  • Provided circuit diagrams for both the small (using $U_\psi^\dagger$) and large (using Bell measurements) approaches.

• Three-Qubit System:

  • Developed circuits for a comprehensive set of invariants derived from the Freezing Theorem (FTS) and SLOCC classification:
    • $c_a^2$: Squared concurrence (entanglement across $a|bc$ split).
    • $\omega^2$: Related to the Kempe invariant (W-type entanglement).
    • $\tau^2$: The squared three-tangle (GHZ-type residual entanglement).
    • $g_a^2$: Norms of quadratic covariants.
  • Showed how to construct circuits for these using index contractions with $\delta$ and $\epsilon$ tensors.

• Experimental Validation:

  • Implemented the circuits on the IBM Quantum Platform (specifically the ibmq_pittsburgh Heron processor).
  • Tested on three families of states:
    1. Separable/1|23: $|\psi_{1|23}(\theta)\rangle$
    2. W-class: $|\psi_W(\theta)\rangle$
    3. GHZ-class: $|\psi_{GHZ}(\theta)\rangle$
  • Compared experimental results against exact theoretical values.

4. Results

• Accuracy: The "small" circuit (Method 1) consistently outperformed the "large" circuit (Method 2) in terms of precision. The experimental data showed a small underestimation of values due to noise, but the trends matched the theoretical curves perfectly.
• SLOCC Classification: The measured invariants successfully distinguished between different SLOCC classes (Separable, W, GHZ).
  • For the GHZ state, $\tau^2 \approx 1$ and $c_a^2 \approx 1$.
  • For the W state, $\tau^2 \approx 0$ while $c_a^2$ and $\omega^2$ were non-zero.
  • For the separable state, all entanglement invariants were near zero.
• Noise Impact: The authors noted that while NISQ noise prevents the detection of "zero measure" classes (like perfectly separable states appearing as weakly entangled due to gate errors), the relative magnitudes of the invariants remain robust enough to characterize the type of entanglement.

5. Significance and Future Outlook

• Scalability: Unlike full tomography, which scales exponentially ($3^n$), these methods scale linearly with the degree of the invariant ($k$) and the number of qubits ($n$). This makes them viable for larger systems where tomography is impossible.
• Generality: The method is not restricted to qubits or specific invariants; it applies to arbitrary subsystems and dimensions. It translates abstract algebraic geometry (index contractions) directly into quantum hardware operations.
• Benchmarking: These invariants serve as excellent benchmarks for quantum hardware, testing the fidelity of multi-qubit entanglement generation and preservation.
• Theoretical Bridge: The work bridges the gap between 200-year-old mathematical concepts (Cayley's hyperdeterminant, invariant theory) and modern physical experiments, turning abstract algebraic structures into measurable physical quantities.

In conclusion, Szalay and Holweck provide a practical, scalable framework for directly measuring quantum entanglement properties on current hardware, offering a superior alternative to state tomography and optimization-based approaches.