Challenge

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)

  1. Step-by-Step Derivation - Show every non-trivial step in the solution. Justify steps using relevant physical laws, theorems, or mathematical identities.
  2. Mathematical Typesetting - Use LaTeX for all mathematics: $...$ for inline expressions, $$...$$ for display equations.
  3. Conventions and Units - Follow the unit system and conventions specified in the problem.
  4. 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.

  5. 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

  1. Ideal (error-free) circuit
    β€’ All five data qubits (0-3) and the ancilla (4) are initialised in
    \(\lvert 0\rangle^{\otimes 5}\).
    β€’ Running the gates from right to left,
\[ H_1\;\;CNOT_{12}\;\;CNOT_{10}\;\;CNOT_{23}\;\;CNOT_{34}\;\;CNOT_{04} \]
 maps the data qubits to
\[ \]
 while the ancilla returns to $\lvert 0\rangle_4$.  
 (The four–qubit GHZ state above is the code word for the logical state
 $\lvert 00\rangle_{AB}$, since it is a simultaneous $+1$ eigenstate of
 the stabilisers $XXXX$ and $ZZZZ$ and of the logical operators  
 $Z_A=ZZII$ and $Z_B=ZIZI$.)
  1. Error model
    β€’ After each of the five CNOT gates an independent two-qubit depolarising channel acts: with probability \(p\) one of the \(15\) non-identity two-qubit Pauli operators is applied, each with probability \(p/15\).
    β€’ Single-qubit gates and measurements are taken to be perfect.

Up to first order in \(p\) it suffices to keep only a single error happening somewhere in the circuit (terms of order \(p^{2}\) and higher are neglected).

  1. What gets discarded?
    At the end of the circuit we
    a) measure the ancilla in the \(Z\) basis and keep the run only when the outcome is \(0\), and
    b) measure both stabilisers and keep the state only when the syndrome is \(+1,+1\).

β€’ Any Pauli on the ancilla that contains \(X\) or \(Y\) flips the ancilla to \(\lvert 1\rangle\) and is therefore discarded.
β€’ Any Pauli acting on the data block that has an odd number of \(X\)’s (or \(Y\)’s) anticommutes with the stabiliser \(ZZZZ\) and is discarded.
β€’ Any Pauli on the data block that has an odd number of \(Z\)’s (or \(Y\)’s) anticommutes with the stabiliser \(XXXX\) and is discarded.

Consequently every single-qubit error on the data qubits is detected, i.e. no weight-1 error survives the post-selection.
Only weight-2 errors that commute with both stabilisers and do not put an \(X\) or \(Y\) on the ancilla can slip through.

  1. Propagating the 15 Pauli errors of every CNOT gate
    The five CNOTs appear in the time order
\[ (2)\;CNOT_{10}\;,\qquad (3)\;CNOT_{23}\;,\qquad (4)\;CNOT_{34}\;,\qquad \]

Conjugating a Pauli \(P\) through a CNOT with control \(c\) and target \(t\)

\[ X_c &\longrightarrow X_cX_t,&\quad Z_c&\longrightarrow Z_c,\\ X_t &\longrightarrow X_t, &\quad Z_t&\longrightarrow Z_cZ_t \]

allows us to see how an error that occurs after gate \((k)\) is carried forward by the remaining gates.

β€’ Gate \((1)\) - \(CNOT_{12}\) (error acts on qubits 1 & 2)
 Among the \(15\) Paulis only

\[ Z_1Z_2 \]
 remains a weight-2 operator on the data qubits, commutes with both
 stabilisers and avoids placing $X/Y$ on the ancilla.  
 It acts as the logical operator $Z_A$ and therefore flips the logical
 state although it is not detected.

β€’ Gate \((2)\) - \(CNOT_{10}\) (error acts on qubits 1 & 0)
 Only

\[ Z_1Z_0 \]
 survives all tests.  It implements the undetected logical $Z_A$.

β€’ Gate \((3)\) - \(CNOT_{23}\) (error acts on qubits 2 & 3)
 Only

\[ Z_2Z_3 \]
 survives.  It equals the logical $Z_B$ and is likewise undetected.

β€’ Gate \((4)\) - \(CNOT_{34}\) (error on qubits 3 & 4)
 The only Pauli that is never flagged is

\[ Z_4, \]
 which acts trivially on the code because it is removed when the ancilla
 is projected onto $\lvert 0\rangle$.  Hence it is *harmless*.

β€’ Gate \((5)\) - \(CNOT_{04}\) (error on qubits 0 & 4)
 Again only the pure phase error

\[ Z_4 \]
 survives, which is harmless for the same reason.

Summary (first order in \(p\))

────────────────────────────────────────────
accepted & harmful : 3 patterns … \(Z_1Z_2,\;Z_1Z_0,\;Z_2Z_3\)
accepted & harmless: 2 patterns … \(Z_4\) (from gate 4 or 5)
discarded : the remaining \(15\times5-5=70\) patterns
────────────────────────────────────────────

  1. Probabilities to first order in \(p\)
    β€’ Each gate fails with probability \(p\); each particular Pauli appears with probability \(p/15\).

a) Probability that an undetected logical error occurred:

\[ \]

b) Probability that the run is accepted (ancilla \(0\) and trivial syndrome):

\[ (1-p)^{5}+5\!\left(\frac{p}{15}\right) \;=\;1-5p+\frac{p}{3} \;=\;1-\frac{14}{3}p \]
 (The five accepted single-Pauli patterns are the three harmful ones
  plus the two $Z_4$ patterns.)

c) Probability that the accepted state is the correct logical state:

\[ (1-p)^{5}+2\!\left(\frac{p}{15}\right) \;=\;1-5p+\frac{2}{15}p \]
  1. Logical state fidelity
    The logical fidelity is the conditional probability that the accepted state equals \(\lvert 00\rangle_{AB}\):
\[ \frac{P_{\text{corr}}}{P_{\text{acc}}} =\frac{1-\dfrac{73}{15}p}{1-\dfrac{14}{3}p} \]

Hence, to leading order in the physical two-qubit gate error rate \(p\), the post-selected preparation protocol suppresses the error probability by a factor of \(5\).

Final Answer:
The logical two-qubit state fidelity after post-selection is

\[ F_{\text{logical}}(p)=1-\frac{p}{5}+O(p^{2}), \]

i.e. the first-order logical infidelity is \(p/5\).

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(1, 5) * p  # a SymPy expression of inputs
    # ---------------------------------------------------------------

    return F_logical