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

1) Step-by-step derivation

1.1) Ideal encoded state and checks implemented by the circuit

Code and logicals. The [[4,2,2]] code has stabilizers S = ⟨XXXX, ZZZZ⟩ and logical operators (up to stabilizers)
X_A = X I X I, X_B = X X I I,
Z_A = Z Z I I, Z_B = Z I Z I.
The code distance is d = 2, so any weight-1 Pauli on the data qubits anticommutes with at least one stabilizer and is detectable.
Error-free action of the circuit. Starting with data qubits |0000⟩ and ancilla |0⟩,
H_1, CNOT_{12}, CNOT_{10}, CNOT_{23} prepares the 4-qubit GHZ state |GHZ⟩ = (|0000⟩ + |1111⟩)/√2 on qubits 0–3, which is stabilized by XXXX and ZZZZ with +1 eigenvalues (hence it is a valid code state with Z_A = Z_B = +1, i.e., |00⟩_AB).
The two CNOTs to the ancilla, CNOT_{34} and CNOT_{04}, measure the Z-parity Z_0 Z_3: starting the ancilla in |0⟩, the measured bit is r = (1 − ⟨Z_0 Z_3⟩)/2. For |GHZ⟩, Z_0 Z_3 = +1, so the ideal outcome is r = 0.
We post-select on (i) ancilla outcome 0 and (ii) both stabilizers XXXX and ZZZZ being +1 (detectable-errors post-selection).

1.2) Noise model

After each two-qubit gate (there are 5 of them), a two-qubit depolarizing channel acts on the two participating qubits: E(ρ) = (1 − p) ρ + (p/15) ∑_{P ∈ 𝒫_2 \ {II}} P ρ P, where 𝒫_2 is the two-qubit Pauli group without the identity II. Only the two qubits touched by the gate are affected.
We keep terms up to O(p^2) because we will see that this preparation is first-order fault-tolerant under the given post-selection, so the accepted logical error appears only at second order.

1.3) Pauli propagation and what the ancilla measurement detects

We use the standard CNOT conjugation rules (control c, target t): - X_c → X_c X_t, Z_c → Z_c, - X_t → X_t, Z_t → Z_c Z_t, and Y = i X Z follows from these.

The ancilla measurement implements a measurement of Z_0 Z_3. A fault that, when propagated forward, induces an odd number of X/Y on {0,3} flips the parity of Z_0 Z_3 (hence flips the ancilla bit). Independently, any data error with an odd number of X/Y anticommutes with ZZZZ; any data error with an odd number of Z/Y anticommutes with XXXX. We post-select on XXXX = +1 and ZZZZ = +1 as well as ancilla outcome 0.

1.4) Single-fault analysis: all single two-qubit faults are either detected or benign

We examine, for each two-qubit gate, a single two-qubit Pauli error right after the gate and propagate it through the remaining circuit. We classify outcomes into: - Rejected: flips the ancilla bit or anticommutes with XXXX or ZZZZ. - Accepted and benign: commutes with XXXX and ZZZZ and does not change |00⟩_AB (i.e., is a stabilizer or a logical Z-type on |00⟩_AB, which has Z_A = Z_B = +1). - Accepted and harmful: commutes with stabilizers and changes |00⟩_AB (i.e., a logical Pauli with an X on A and/or B). We will show this case does not occur with a single fault.

We denote the five two-qubit gates in time order as: G1 = CNOT_{12}, G2 = CNOT_{10}, G3 = CNOT_{23}, G4 = CNOT_{34}, G5 = CNOT_{04}.

Key observations (full propagation uses the above rules): - Any single-qubit X or Y present on any data qubit at the end anticommutes with ZZZZ and is detected by our post-selection of ZZZZ = +1. - Any single-qubit Z present on any data qubit at the end anticommutes with XXXX and is detected by our post-selection of XXXX = +1. - A two-qubit Z Z on data commutes with both stabilizers and is accepted; but on |00⟩_AB it acts as a logical Z (or product of logical Z’s) and is therefore benign (|00⟩_AB is a +1 eigenstate of all logical Z’s). A four-qubit X X X X is the stabilizer and is benign.

Now, for each location:

After G1 (on qubits 1 and 2): • If the error inserts X/Y on exactly one of {1,2}, an X appears on exactly one of {0,3} and flips the ancilla bit → reject. • If it inserts X/Y on both (1 and 2), the final data operator is either XXXX (if both are X) or YYYY (if both are Y), which is equivalent to Z_1 Z_2 times XXXX. Both commute with stabilizers; XXXX is a stabilizer and YYYY differs by Z_1 Z_2, which equals Z_A Z_B and is benign on |00⟩_AB. → accept and benign. • If it inserts Z on exactly one of {1,2}, it anticommutes with XXXX → reject. • If it inserts Z on both (Z_1 Z_2), it commutes with XXXX and ZZZZ and is equal to Z_A Z_B: benign. → accept and benign. Conclusion: no harmful (logical X-type) single-fault outcome at G1.
After G2 (on qubits 1 and 0): • Any X/Y on qubit 0 (which occurs for many two-qubit error choices) propagates to flip the ancilla at G5 → reject. • If the error has only Z’s, the only commuting case is Z_1 Z_0, which is logical Z_A (benign). → accept and benign. • All other single-fault cases are rejected by ancilla or stabilizers. Conclusion: no harmful single-fault outcome at G2.
After G3 (on qubits 2 and 3): • Any X/Y on qubit 3 (directly, or generated from X/Y on 2 by G3) flips the ancilla at G4 → reject. • If the error has only Z’s, the only commuting case is Z_2 Z_3 (benign). → accept and benign. Conclusion: no harmful single-fault outcome at G3.
After G4 (on qubits 3 and 4): • Any X/Y on the ancilla (qubit 4) flips the measurement bit → reject. • Any X/Y on qubit 3 is an X-type data error that anticommutes with ZZZZ → reject. • The only commuting case is Z_3 Z_4 which, after G5, leaves a Z_0 Z_3 on the data (benign) and a Z on the ancilla (which does not affect the measurement). → accept and benign. Conclusion: no harmful single-fault outcome at G4.
After G5 (on qubits 0 and 4): • Any X/Y on the ancilla flips the bit → reject. • Any X/Y on qubit 0 is an X-type data error that anticommutes with ZZZZ → reject. • Z on the ancilla alone (I ⊗ Z_4) is accepted and benign; Z_0 alone or Z_0 Z_4 anticommutes with XXXX → reject. Conclusion: no harmful single-fault outcome at G5.

Together these cases prove that any single two-qubit Pauli fault is either rejected by the ancilla or stabilizer checks, or it is accepted but benign (a stabilizer or a logical Z on |00⟩_AB). In particular, a single fault cannot cause an undetected logical X-type error. Hence, conditioned on post-selection, there is no O(p) contribution to the logical infidelity.

1.5) Consequence for the logical fidelity

Let F_L(p) denote the logical fidelity of the post-selected output with the target |00⟩_AB.
Because every accepted single-fault outcome is benign, the first nonzero contribution to the conditional logical infidelity arises from pairs of faults. Therefore 1 − F_L(p) = Θ(p^2).
More explicitly, to second order one may write 1 − F_L(p) = C p^2 + O(p^3), where C is a constant that depends on the detailed combinatorics of “malignant” fault pairs (two Pauli faults at two of the five CNOTs which, taken together, pass both the ancilla and the stabilizer post-selections and induce a nontrivial logical operator with an X component on A and/or B).
In terms of a counting formula, C = (1/15^2) ∑{1 ≤ a < b ≤ 5} M{ab}, where M_{ab} is the number of ordered pairs of two-qubit Pauli errors (from the 15×15 possibilities at locations a and b) that are accepted by the post-selection yet act nontrivially on |00⟩AB (i.e., implement a logical Pauli with an X on at least one logical qubit). Evaluating M{ab} requires an explicit propagation-and-acceptance check for each pair, but the scaling is independent of its value.

2) Mathematical typesetting

The essential equations used above are: • Stabilizers: S = ⟨X⊗X⊗X⊗X, Z⊗Z⊗Z⊗Z⟩. • Logical operators: X_A = X I X I, X_B = X X I I, Z_A = Z Z I I, Z_B = Z I Z I. • Depolarizing channel on each two-qubit gate: E(ρ) = (1 − p) ρ + (p/15) ∑_{P ∈ 𝒫_2 \ {II}} P ρ P. • CNOT conjugation: X_c → X_c X_t, Z_c → Z_c, X_t → X_t, Z_t → Z_c Z_t.

3) Conventions and units

We use the Pauli operator conventions and take the noise only on the five two-qubit gates as specified. The Hadamard and measurements are ideal. We condition on ancilla outcome 0 and on the two stabilizers being +1.

4) Final Answer: F_L(p | post-select ancilla = 0 and XXXX = ZZZZ = +1) = 1 − C p^2 + O(p^3),

where C is a constant determined by the number of malignant two-fault pairs in the five two-qubit gates (and is independent of p). In particular, there is no O(p) term: the circuit is first-order fault-tolerant for this state-preparation task, so the logical infidelity scales quadratically with the two-qubit gate error rate.

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 ------------------
    C = sp.symbols('C')
    F_logical = 1 - C*p**2 + sp.O(p**3)  # a SymPy expression of inputs
    # ---------------------------------------------------------------

    return F_logical