System #0

You are a physics research assistant specializing in solving complex, research-level problems using precise, step-by-step reasoning.

Input Problems will be provided in Markdown format.

Output (Markdown format)

Step-by-Step Derivation - Show every non-trivial step in the solution. Justify steps using relevant physical laws, theorems, or mathematical identities.
Mathematical Typesetting - Use LaTeX for all mathematics: $...$ for inline expressions, $$...$$ for display equations.
Conventions and Units - Follow the unit system and conventions specified in the problem.
Final Answer - At the end of the solution, start a new line with “Final Answer:”, and present the final result.

For final answers involving values, follow the precision requirements specified in the problem. If no precision is specified: - If an exact value is possible, provide it (e.g., \$\sqrt(2)\$, \$\pi/4\$). - If exact form is not feasible, retain at least 12 significant digits in the result.
Formatting Compliance - If the user requests a specific output format (e.g., code, table), provide the final answer accordingly.

User #1

Problem setup:

In quantum error correction, you encode quantum states into logical states made of many qubits in order to improve their resilience to errors. In quantum error detection, you do the same but can only detect the presence of errors and not correct them. In this problem, we will consider a single [[4,2,2]] quantum error detection code, which encodes two logical qubits into four physical qubits, and investigate how robust logical quantum operations in this code are to quantum errors.

Our convention is that the four physical qubits in the [[4,2,2]] code are labelled 0,1,2,3. The two logical qubits are labelled A and B. The stabilizers are $XXXX$ and $ZZZZ$, where $X$ and $Z$ are Pauli matrices. The logical $X$ and $Z$ operators on the two qubits are $X_A = XIXI$, $X_B=XXII$, $Z_A = ZZII$, $Z_B = ZIZI$, up to multiplication by stabilizers.

We will consider different state preparation circuits consisting of controlled not $CNOT_{ij}$ gates, where $CNOT_{ij}$ has control qubit $i$ and target qubit $j$. As a simple model of quantum errors in hardware, we will suppose that each $CNOT_{ij}$ gate in the circuit has a two qubit depolarizing error channel following it that produces one of the 15 non-identity two-qubit Paulis with equal probability $p/15$. The probability $p$ indicates the probability of an error in a single two-qubit gate. We will assess the logical infidelity of certain state preparation protocols as a function of the physical infidelity $p$.

Challenge

Suppose that we prepare a logical two-qubit $|00\rangle_{AB}$ state in the [[4,2,2]] code. To do so, we introduce an ancilla qubit, qubit 4, and use the following state preparation circuit:

\[ M_4 (CNOT_{04}) (CNOT_{34}) (CNOT_{23}) (CNOT_{10}) (CNOT_{12}) (H_1) \]

Note that this equation is written in matrix multiplication order, while the quantum operations in the circuit occur in the reverse order (from right-to-left in the above equation). $H$ is a single-qubit Hadamard gate and $M$ is a single-qubit measurement. The ancilla is used to detect errors in the state preparation circuit and makes the circuit fault-tolerant. If the ancilla measurement is $|0\rangle$ ($|1\rangle$), the state preparation succeeds (fails).

What is the logical state fidelity of the final 2-qubit logical state at the end of the circuit as a function of two-qubit gate error rate $p$, assuming the state is post-selected on all detectable errors in the code and on the ancilla qubit measuring $|0\rangle$?

Assistant #2

Step-by-Step Derivation

Error model
• The circuit contains five two–qubit CNOT gates.
g1 : CNOT12 g2 : CNOT10 g3 : CNOT23 g4 : CNOT34 g5 : CNOT04
• After every CNOT a two–qubit depolarising channel acts on the same two qubits, i.e. with probability

p a Pauli error
P∈𝒫₂{II}= {XI,YI,ZI,IX,IY,IZ,XX,XY,…,ZZ} (15 elements)

occurs, each with probability p/15.
• With probability 1-p no error is inserted.
Detection mechanism
• Ancilla (qubit 4) is measured in the Z-basis and the run is kept only if
the outcome is |0〉. Any Pauli that anticommutes with Z₄ (i.e. that contains X₄ or Y₄) flips the measurement result and is therefore discarded. Hence only errors whose final Pauli factor on the ancilla is I or Z survive the flag check.
• After the flag check the two stabilisers

S₁ = X₀X₁X₂X₃ , S₂ = Z₀Z₁Z₂Z₃

are measured. The run is kept only if both eigenvalues are +1. Every operator that anticommutes with at least one of S₁,S₂ is therefore discarded.
Consequences for a single fault
• Conjugating every one-Pauli error through the remainder of the circuit shows that
– if the error ends on qubit 4 with X or Y it is removed by the flag,
– else it anticommutes with at least one stabiliser and is removed by the syndrome,
– or it is a stabiliser itself (XXXX or one of the six weight-2 Z-type operators) and therefore acts trivially on the logical qubits.
• Hence a single faulty CNOT never produces an undetected logical error. First–order logical errors are absent: P_L ∝ p ⇒ the coefficient of p is 0.
Two simultaneous faults
• Undetected logical errors first appear when two CNOTs fail simultaneously. A complete Pauli-by-Pauli enumeration shows that the only malignant pair of locations is the flag pair CNOT34 (control 3, target 4) together with CNOT04 (control 0, target 4) . • For those two gates the following eight pairs of Pauli faults (out of 15·15 = 225 possibilities)
1 XX(3,4) with XX(0,4) → X₀X₃
2 YX(3,4) with YX(0,4) → Y₀Y₃
3 XX(3,4) with XY(0,4) → X₀X₃ (Z₄ left behind)
4 XY(3,4) with XX(0,4) → X₀X₃ (Z₄ left behind)
5 YX(3,4) with YY(0,4) → Y₀Y₃ (Z₄ left behind)
6 YY(3,4) with YX(0,4) → Y₀Y₃ (Z₄ left behind)
7 XY(3,4) with XY(0,4) → X₀X₃
8 YY(3,4) with YY(0,4) → Y₀Y₃
commute with both stabilisers and leave the ancilla in I or Z. In the code space
X₀X₃ ≡ X_A X_B , Y₀Y₃ ≡ (-1) X_A X_B Z_A Z_B , so each of them flips both logical qubits, taking |00〉_{AB} to an orthogonal state and giving zero overlap with the target state.
Logical error probability to second order
• The probability that the specific pair of CNOTs both fail is p².
• Given that they fail, the chance that the two faults are one of the eight malignant Pauli pairs is 8/(15·15).
• All other pairs of gates are benign to second order, so the leading logical error probability is

P_L = 8 (p/15)² + 𝒪(p³) = 8p²/225 + 𝒪(p³).
Logical state fidelity
• Post-selection discards every run in which the flag fired or a stabiliser defect was seen, but keeps all runs in which no fault or a logically benign fault occurred. To second order the acceptance probability is 1-𝒪(p), so conditioning changes the leading term only at order p³. • The logical fidelity of the accepted state is therefore

F_log(p) = 1 − P_L + 𝒪(p³) = 1 − 8p²/225 + 𝒪(p³).

Final Answer:
Up to second order in the physical two-qubit gate error rate p, the post-selected logical two-qubit state prepared by the flagged [[4,2,2]] circuit has fidelity

F_log(p) ≃ 1 − (8/225) p² + 𝒪(p³).

All single-gate faults are detected; the leading logical errors come from eight specific pairs of Pauli faults on the two flag-CNOTs and hence appear only with probability (8/225) p².

User #3

Populate your final answer into the code template provided below. This step is purely for formatting/display purposes. No additional reasoning or derivation should be performed. Do not import any modules or packages beyond what is provided in the template.

import sympy as sp

p = sp.symbols('p')

def answer(p):
    r"""
    Return the expression of the logical state fidelity of the final 2-qubit logical state
    at the end of the circuit as a function of two-qubit gate error rate $p$.

    Inputs
    ----------
    p: sympy.Symbol, two-qubit gate error rate, $p$

    Outputs
    ----------
    F_logical: sympy.Expr, logical state fidelity of the final 2-qubit logical state
    """

    # ------------------ FILL IN YOUR RESULTS BELOW ------------------
    F_logical = ...  # a SymPy expression of inputs
    # ---------------------------------------------------------------

    return F_logical

Assistant #4

import sympy as sp

p = sp.symbols('p')

def answer(p):
    r"""
    Return the expression of the logical state fidelity of the final 2-qubit logical state
    at the end of the circuit as a function of two-qubit gate error rate $p$.

    Inputs
    ----------
    p: sympy.Symbol, two-qubit gate error rate, $p$

    Outputs
    ----------
    F_logical: sympy.Expr, logical state fidelity of the final 2-qubit logical state
    """

    # ------------------ FILL IN YOUR RESULTS BELOW ------------------
    F_logical = 1 - sp.Rational(8, 225) * p**2 + sp.O(p**3)
    # ---------------------------------------------------------------

    return F_logical