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

Checkpoints

Checkpoint 1

Suppose that we wish to prepare a logical two-qubit GHZ state $(|00\rangle_{AB}+|11\rangle_{AB})/\sqrt{2}$ in the [[4,2,2]] code. To do so, we use the following state preparation circuit:

\[ (CNOT_{03}) (H_0) (CNOT_{21}) (H_2). \]

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.

What is the physical state fidelity of the final physical 4-qubit state at the end of the circuit as a function of the two-qubit gate error rate $p$?

Assistant #2

Reasoning (model)

We are given: “Suppose that we wish to prepare a logical two-qubit GHZ state $(|00\rangle_{AB}+|11\rangle_{AB})/\sqrt{2}$ in the [[4,2,2]] code. To do so, we use the following state preparation circuit:

\[ (CNOT_{03}) (H_0) (CNOT_{21}) (H_2). \]

Note: 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.

We want: “What is the physical state fidelity of the final physical 4-qubit state at the end of the circuit as a function of the two-qubit gate error rate $p$?”

Interpretation: We have a circuit that ideally prepares the logical GHZ state. But each CNOT gate is followed by a two-qubit depolarizing error channel. The error channel: After each CNOT, there is an error that applies one of the 15 non-identity two-qubit Paulis (on the two qubits involved) with probability p/15 each, and with probability 1-p, no error. The Hadamard gates are assumed perfect? The problem says: “each CNOT_{ij} gate in the circuit has a two qubit depolarizing error channel following it”. So only CNOT gates have errors. The Hadamard gates are error-free.

The circuit: The operations in order (from right to left in the given equation) are:

H_2
CNOT_{21}
H_0
CNOT_{03}

But careful: The given equation: (CNOT_{03}) (H_0) (CNOT_{21}) (H_2). In matrix multiplication order, the rightmost operation is applied first. So the actual circuit order is: Start with initial state? Typically, we start with all qubits in |0>. So initial state: |0000>. Then apply H_2: That gives: H_2 on qubit 2: |0>2 -> (|0>+|1>)/√2. So state becomes: |00> on qubits 0,1,3 and on qubit2: (|0>+|1>)/√2. So state: 1/√2 (|0000> + |0010>) but careful: labeling: qubits: 0,1,2,3. So state: |q0 q1 q2 q3>. After H_2: state = 1/√2 (|0,0,0,0> + |0,0,1,0>).

Then apply CNOT_{21}: Control qubit 2, target qubit 1. So if qubit2 is 1, flip qubit1. So state becomes: 1/√2 (|0,0,0,0> + |0,1,1,0>).

Then apply H_0: Hadamard on qubit0. So state becomes: H_0 on first qubit: |0> -> (|0>+|1>)/√2, |1> -> (|0>-|1>)/√2. But here, qubit0 is always 0? Actually, from previous: state = 1/√2 (|0000> + |0110>). So after H_0: For first term: |0000> -> 1/√2 (|0000> + |1000>) For second term: |0110> -> 1/√2 (|0110> + (-1)? Actually careful: H|0> = (|0>+|1>)/√2, H|1> = (|0>-|1>)/√2. But here qubit0 is 0 in both? Actually, in second term, qubit0 is 0? Actually, |0110>: qubit0=0, qubit1=1, qubit2=1, qubit3=0. So H_0 on that gives: (|0>+|1>)/√2 on qubit0? But careful: H applied to |0> gives (|0>+|1>)/√2. So it’s the same: Actually, wait: There is no phase difference because qubit0 is always 0. So then state becomes: 1/√2 * [1/√2 (|0000> + |1000>) + 1/√2 (|0110> + |1110>)] = 1/2 (|0000> + |1000> + |0110> + |1110>).

Then apply CNOT_{03}: Control qubit 0, target qubit 3. So: For each basis state, if control (qubit0) is 1, then flip qubit3. So: |0000>: control=0 -> remains |0000> |1000>: control=1 -> becomes |1001>? Actually careful: target is qubit3. So |1000> becomes |1001>. |0110>: control=0 -> remains |0110> |1110>: control=1 -> becomes |1111>. So final state: 1/2 (|0000> + |1001> + |0110> + |1111>).

That is the physical state. But is that the logical GHZ state? The logical GHZ state is (|00>_AB + |11>_AB)/√2. But what are the logical states? The code is [[4,2,2]]. The logical operators: X_A = XIXI, X_B=XXII, Z_A=ZZII, Z_B=ZIZI. We need to check: The state we got: 1/2 (|0000> + |1001> + |0110> + |1111>). Maybe it is indeed the logical GHZ state? Let’s check: The logical basis states? For the [[4,2,2]] code, the code space is 4-dimensional. The stabilizers are XXXX and ZZZZ. So the code space is the subspace of 4 qubits that are +1 eigenvectors of XXXX and ZZZZ. Our state: Check XXXX on |0000>: XXXX|0000> = |1111>, so not an eigenvector. So these states are not in the code space? But wait: The circuit is supposed to prepare a logical GHZ state. But the logical GHZ state is a state on two logical qubits. That state is encoded into 4 physical qubits. So it should be in the code space? Actually, the code space is the space of states that are stabilized by XXXX and ZZZZ. Our state: For |0000>: XXXX|0000> = |1111>, so it’s not in the code space. But maybe the state is a superposition that is in the code space? Check: |0000> + |1111> is an eigenvector of XXXX? XXXX(|0000>+|1111>) = |1111>+|0000> = same, so that part is good. But then we also have |1001> and |0110>. Check XXXX on |1001>: XXXX|1001> = |0110>? Because flip all: 1->0,0->1,0->1,1->0 gives: 0,1,1,0 = |0110>. So |1001> and |0110> are swapped by XXXX. So the state 1/2 (|0000>+|1001>+|0110>+|1111>) is not an eigenvector of XXXX because applying XXXX gives 1/2 (|1111>+|0110>+|1001>+|0000>) which is the same actually? Because order: |0000> becomes |1111>; |1001> becomes |0110>; |0110> becomes |1001>; |1111> becomes |0000>. So indeed the state is symmetric. So it is an eigenvector of XXXX with eigenvalue 1. Now check ZZZZ: ZZZZ on |0000> gives +1; on |1001>: Z on qubit0: -1, on qubit1: +1, on qubit2: +1, on qubit3: -1? Actually careful: ZZZZ means apply Z on each qubit. So for |1001>, the phase: qubit0: 1 -> phase -1; qubit1: 0 -> phase +1; qubit2: 0 -> phase +1; qubit3: 1 -> phase -1; so product = (-1)(+1)(+1)(-1)= +1. For |0110>: qubit0:0 -> +1; qubit1:1 -> -1; qubit2:1 -> -1; qubit3:0 -> +1; product = (+1)(-1)(-1)(+1)= +1. For |1111>: all ones: (-1)^4=+1. So indeed the state is in the code space. So it is a valid encoded state. And it is the GHZ state? The logical GHZ state is (|00>_AB + |11>_AB)/√2. We need to check what are the logical basis states. The logical operators: X_A = XIXI, X_B=XXII, Z_A=ZZII, Z_B=ZIZI. Let’s find the logical basis states. The code space is 4-dimensional. We want states that are eigenvectors of Z_A and Z_B. Z_A = ZZII. So its eigenvalues: For a state in the code space, Z_A gives ±1. Similarly Z_B = ZIZI. Our state: 1/2 (|0000>+|1001>+|0110>+|1111>). Compute Z_A on this state: Z_A = Z on qubit0 and qubit1. For |0000>: Z_A gives +1. |1001>: qubit0:1 -> -1, qubit1:0 -> +1, so product -1. |0110>: qubit0:0 -> +1, qubit1:1 -> -1, so product -1. |1111>: qubit0:1 -> -1, qubit1:1 -> -1, product +1. So the state is not an eigenvector of Z_A. But it is the GHZ state which is a superposition of |00> and |11> logical. So it should be that if we measure Z_A and Z_B, we get either both +1 or both -1. Check Z_B = ZIZI: |0000>: Z on qubit0: +1, Z on qubit2: +1, so +1. |1001>: qubit0: -1, qubit2: 0 -> +1, so -1. |0110>: qubit0: 0 -> +1, qubit2: 1 -> -1, so -1. |1111>: qubit0: -1, qubit2: -1, so +1. So indeed, the state is such that Z_A and Z_B are correlated: They are both +1 for the first and last terms, and both -1 for the middle two terms. So if we define logical |00> as the state that is +1 eigenvector of Z_A and Z_B, and |11> as the state that is -1 eigenvector of Z_A and Z_B, then our state is (|00> + |11>)/√2. So it is the GHZ state. So the circuit indeed prepares the logical GHZ state.

Now, we want: “What is the physical state fidelity of the final physical 4-qubit state at the end of the circuit as a function of the two-qubit gate error rate p?” Interpretation: The circuit has two CNOT gates: CNOT_{21} and CNOT_{03}. Each CNOT gate is followed by a depolarizing error channel. So the actual process is: Start with |0000>. Apply H_2 (perfect). Then apply CNOT_{21} but then followed by error channel on qubits {2,1}? Actually careful: “each CNOT_{ij} gate in the circuit has a two qubit depolarizing error channel following it”. So after CNOT_{21}, we apply an error operation on qubits 2 and 1. That error is: with probability 1-p, identity; with probability p, one of the 15 Pauli errors (non-identity two-qubit Paulis) chosen uniformly. So that error is applied to the state. Then apply H_0 (perfect). Then apply CNOT_{03} followed by error channel on qubits {0,3}.

We want the fidelity of the final state (after these operations, including errors) to the ideal state (which is the state we computed without errors). Fidelity is defined as F = <ψ_ideal| ρ |ψ_ideal> where ρ is the actual density matrix.

We assume that the errors are stochastic and independent. So we can compute the evolution as: The circuit is a sequence of operations. The errors occur after each CNOT. So we can compute the effect of errors on the state. Since the errors are Pauli errors, and the circuit is Clifford (Hadamard and CNOT are Clifford), the entire process will map Pauli errors to Pauli errors. But careful: The errors occur after the gates. So we can compute the overall effect as: The ideal circuit U = U_4 U_3 U_2 U_1, where U_1 = H_2, U_2 = CNOT_{21}, U_3 = H_0, U_4 = CNOT_{03}. But then after U_2, we have an error E2 on qubits {2,1} chosen from the set of 15 Paulis (including identity with probability 1-p, and each of the 15 with probability p/15). And after U_4, we have an error E4 on qubits {0,3} similarly.

So the actual final state is: ρ = average over E2 and E4 of [U_4 E4 U_3 U_2 E2 U_1 |0><0| U_1^\dagger E2^\dagger U_2^\dagger U_3^\dagger E4^\dagger U_4^\dagger]. But since the errors are Pauli, they are unitary. So the final state is a mixture of states of the form U_ideal * (some Pauli error propagated through the circuit) applied to |0>. But careful: The order: Actually, the circuit is: State after step1: |ψ1> = H_2 |0>. Then step2: Apply CNOT_{21} to get |ψ2> = CNOT_{21} |ψ1>. Then error E2 on qubits {2,1} gives: |ψ2’> = E2 |ψ2>. Then step3: Apply H_0: |ψ3> = H_0 |ψ2’>. Then step4: Apply CNOT_{03}: |ψ4> = CNOT_{03} |ψ3>. Then error E4 on qubits {0,3} gives: |ψ_f> = E4 |ψ4>.

So the overall transformation is: |ψ_f> = E4 * CNOT_{03} * H_0 * E2 * CNOT_{21} * H_2 |0>. And U_ideal = CNOT_{03} * H_0 * CNOT_{21} * H_2. So if there were no errors, we get |ψ_ideal>. With errors, we get: |ψ_f> = (E4) * (CNOT_{03} H_0) * E2 * (CNOT_{21} H_2) |0>? But careful: The order: Actually, it’s: U_ideal = CNOT_{03} * H_0 * CNOT_{21} * H_2. And with errors: Actual = E4 * CNOT_{03} * H_0 * E2 * CNOT_{21} * H_2. So if we define V = CNOT_{03} * H_0, then actual = E4 * V * E2 * V^{-1} * (V * CNOT_{21} * H_2) = E4 * V * E2 * V^{-1} * U_ideal? Not exactly: Because V * CNOT_{21} * H_2 = CNOT_{03} * H_0 * CNOT_{21} * H_2 = U_ideal. So indeed, actual = E4 * (CNOT_{03} H_0) * E2 * (H_0^\dagger CNOT_{03}^\dagger) * U_ideal. So the error becomes: overall error operator = E4 * (CNOT_{03} H_0) * E2 * (H_0^\dagger CNOT_{03}^\dagger). Let’s denote that as O = E4 * U_{mid} * E2 * U_{mid}^\dagger, where U_{mid} = CNOT_{03} H_0? But careful: Actually, check: We have: actual = E4 * CNOT_{03} * H_0 * E2 * CNOT_{21} * H_2. And U_ideal = CNOT_{03} * H_0 * CNOT_{21} * H_2. So if we multiply U_ideal by something from the left? Actually, note that CNOT_{21} * H_2 is not necessarily the inverse of something? Alternatively, we can compute the effect of errors by propagating them through the subsequent gates. That might be easier: We have two error locations: after CNOT_{21} and after CNOT_{03}. Let’s denote the Pauli errors: E2 is on qubits {2,1}. It is one of the 15 Pauli operators on these two qubits (excluding identity). But note: The Pauli group on two qubits: They are of the form P = σ_a ⊗ σ_b, where σ_a, σ_b ∈ {I, X, Y, Z} but not both I. So there are 15. Similarly, E4 is on qubits {0,3}.

We want the fidelity F = average over E2 and E4 of |<ψ_ideal| ψ_actual>|^2. But careful: The actual state is pure if we fix E2 and E4. But then we average the fidelity? Actually, fidelity is defined as F = <ψ_ideal| ρ |ψ_ideal> where ρ is the mixed state from the process. And ρ = sum_{E2, E4} (probability) |ψ(E2,E4)><ψ(E2,E4)|. So then F = sum_{E2,E4} p(E2) p(E4) |<ψ_ideal|ψ(E2,E4)>|^2. So we need to compute for each possible error pattern, the overlap between the ideal state and the state obtained with that error. And then average.

Since the circuit is Clifford, the effect of a Pauli error propagated through the subsequent Clifford gates becomes another Pauli operator on the final state. Specifically, if we have an error E inserted at some point, then the overall state becomes U_ideal * (U_ideal^\dagger * (error propagated) * U_ideal) |0>? Actually, let’s do it step by step.

We have: |ψ_ideal> = U |0> where U = CNOT_{03} H_0 CNOT_{21} H_2. And |ψ_actual> = E4 * CNOT_{03} * H_0 * E2 * CNOT_{21} * H_2 |0>. So |ψ_actual> = E4 * (CNOT_{03} H_0) * E2 * (CNOT_{03} H_0)^\dagger * U |0>? Check: U = CNOT_{03} H_0 CNOT_{21} H_2. So CNOT_{21} H_2 = (H_0^\dagger CNOT_{03}^\dagger) U? That would be if CNOT_{03} H_0 is invertible? Actually, note: U = (CNOT_{03} H_0) (CNOT_{21} H_2). So then CNOT_{21} H_2 = (CNOT_{03} H_0)^\dagger U. So then |ψ_actual> = E4 * (CNOT_{03} H_0) * E2 * (CNOT_{03} H_0)^\dagger U |0> = E4 * U_{mid} * E2 * U_{mid}^\dagger * U |0>, where U_{mid} = CNOT_{03} H_0. So then |ψ_actual> = (E4 * U_{mid} * E2 * U_{mid}^\dagger) |ψ_ideal>. So the error operator on the ideal state is O = E4 * (U_{mid} E2 U_{mid}^\dagger). And note that U_{mid} is a Clifford operation (it is a product of H on qubit0 and CNOT on qubits 0 and 3). So it will map Pauli operators to Pauli operators. So let F = U_{mid} E2 U_{mid}^\dagger. Then F is a Pauli operator on the 4 qubits? But careful: E2 acts on qubits {2,1} only. U_{mid} = CNOT_{03} H_0. That acts on qubits 0 and 3? Actually, CNOT_{03} acts on qubits 0 and 3. H_0 acts on qubit0. So U_{mid} does not act on qubits 1 and 2. So then U_{mid} E2 U_{mid}^\dagger = E2 itself? Because E2 acts on qubits 1 and 2, and U_{mid} acts on qubits 0 and 3, so they commute? Actually, check: U_{mid} = CNOT_{03} H_0. This operator acts on qubits 0 and 3. E2 acts on qubits 2 and 1. These are on disjoint sets, so they commute. So indeed, U_{mid} E2 U_{mid}^\dagger = E2. So then O = E4 * E2. So the overall error is simply the product of the two errors? But wait, is that correct? Let’s check carefully: We have: |ψ_actual> = E4 * CNOT_{03} * H_0 * E2 * CNOT_{21} * H_2 |0>. And |ψ_ideal> = CNOT_{03} * H_0 * CNOT_{21} * H_2 |0>. So if E2 and E4 commute with the subsequent operations? Actually, careful: E2 acts on qubits 1 and 2. After E2, we apply H_0. H_0 acts on qubit0, so it commutes with E2 because they act on different qubits. Then we apply CNOT_{03}. That acts on qubits 0 and 3. That also commutes with E2 because E2 acts on qubits 1 and 2. So indeed, we can move E2 to the right through H_0 and CNOT_{03}? But careful: The order: Actually, we have: CNOT_{03} * H_0 * E2. Since E2 commutes with H_0 and CNOT_{03} (because they act on disjoint sets), we have CNOT_{03} * H_0 * E2 = E2 * CNOT_{03} * H_0. So then |ψ_actual> = E4 * E2 * CNOT_{03} * H_0 * CNOT_{21} * H_2 |0> = E4 * E2 * |ψ_ideal>. So indeed, the overall effect is that the final state is simply the ideal state acted upon by the product of the two errors: E_total = E4 * E2. But wait: Check: E2 is applied after CNOT_{21} but before H_0. And we argued that E2 commutes with H_0 and CNOT_{03} because they act on different qubits. That is true if E2 acts only on qubits 1 and 2. And E4 acts on qubits 0 and 3. So indeed, they commute with each other? Actually, E2 and E4 act on disjoint sets, so they commute. So then the final state is: |ψ_actual> = E4 E2 |ψ_ideal>. But wait: Is that always true? Check with a specific basis: For example, suppose E2 = X on qubit2. Then after CNOT_{21}, we have state: 1/√2 (|0000> + |0110>). Then E2 (X on qubit2) gives: 1/√2 (|0010> + |0100>). Then H_0: gives: 1/√2 (1/√2(|0010>+|1010>) + 1/√2(|0100>+|1100>)) = 1/2 (|0010>+|1010>+|0100>+|1100>). Then CNOT_{03}: control qubit0, target qubit3. For |0010>: control=0 -> remains |0010> |1010>: control=1 -> becomes |1011> |0100>: control=0 -> remains |0100> |1100>: control=1 -> becomes |1101> So state becomes: 1/2 (|0010>+|1011>+|0100>+|1101>). Then E4: say E4 = I? Then that is the state. Now, if we instead take E2 and move it to the end: E2 = X on qubit2. And then apply that to the ideal state? The ideal state is: 1/2 (|0000>+|1001>+|0110>+|1111>). Applying X on qubit2 gives: 1/2 (|0010>+|1011>+|0100>+|1101>). That matches. So indeed, the errors simply multiply at the end. So the overall effect is that the final state is: |ψ_f> = E_total |ψ_ideal>, where E_total = E4 * E2, and E2 and E4 are independent Pauli errors on their respective pairs. But careful: There is also the possibility that E2 or E4 is identity. So overall, the error is a Pauli operator on the 4 qubits that is a product of an operator on qubits {1,2} and an operator on qubits {0,3}. And these errors occur with probabilities: For E2: probability of identity: 1-p; probability of each non-identity Pauli on qubits {2,1}: p/15. For E4: similarly. And they are independent.

So then the fidelity F = average over E2, E4 of |<ψ_ideal| E_total |ψ_ideal>|^2. But careful: That is if the state is pure. But note: E_total is a Pauli operator. So we need to compute: For each Pauli operator P on the 4 qubits (which is a product of a Pauli on qubits {1,2} and a Pauli on qubits {0,3}), what is |<ψ_ideal| P |ψ_ideal>|^2? And then average over the distribution of P.

So we need to compute: For a given Pauli operator P (which acts on the 4 qubits), what is the overlap <ψ_ideal| P |ψ_ideal>? Since |ψ_ideal> is a specific state. But note: |ψ_ideal> is not necessarily a stabilizer state of the Pauli group? Actually, it is a stabilizer state? It is the GHZ state in the code. But it is a state in the code space. The code space is stabilized by XXXX and ZZZZ. So any Pauli operator that is in the stabilizer will act as identity on |ψ_ideal>. Also, Pauli operators that are logical operators? But careful: The state is not necessarily an eigenvector of all logical operators? Actually, the GHZ state is (|00>+|11>)/√2. That state is not an eigenvector of, say, Z_A alone? But it is an eigenvector of Z_A Z_B? Actually, check: Z_A Z_B? For our state, Z_A and Z_B are correlated: They are both +1 or both -1. So Z_A Z_B gives +1. But individually, they are not fixed. So we need to compute the expectation values.

Maybe we can compute directly: |ψ_ideal> = 1/2 (|0000> + |1001> + |0110> + |1111>). We want <ψ_ideal| P |ψ_ideal> for a Pauli operator P. P is a tensor product of Paulis on each qubit: P = P0 ⊗ P1 ⊗ P2 ⊗ P3, where each P_i is I, X, Y, Z. But note: Our errors come from two independent sets: qubits {1,2} and qubits {0,3}. But anyway.

We can compute: <ψ_ideal| P |ψ_ideal> = (1/4) * [ <0000|P|0000> + <0000|P|1001> + … actually careful: It is sum_{a,b,c,d} where a,b,c,d are the four basis states? Actually, it’s easier: |ψ_ideal> = 1/2 (|A> + |B> + |C> + |D>) where A = |0000>, B = |1001>, C = |0110>, D = |1111>. So <ψ_ideal| P |ψ_ideal> = 1/4 [ + + … + ]. But note: P is a Pauli operator. It will map computational basis states to other computational basis states up to a phase. So the matrix elements are zero unless P maps one basis state to another exactly. So we need to consider for each P, which pairs of these basis states are connected by P. And then sum the phases.

Alternatively, we can note that the ideal state is a stabilizer state? Actually, what is the stabilizer of |ψ_ideal>? It is the code stabilizer plus something that distinguishes the GHZ state from other states in the code. The code stabilizer is generated by XXXX and ZZZZ. So these stabilize |ψ_ideal>? Check: XXXX|ψ_ideal> = |ψ_ideal> as we computed. ZZZZ|ψ_ideal> = |ψ_ideal> as computed. So these are stabilizers. Also, what about Z_A? That is ZZII. That does not stabilize because it gives different phases on different terms? Actually, check: ZZII on |0000> gives +1, on |1001> gives? qubit0:1 -> -1, qubit1:0 -> +1, so -1. So not stabilizer. But maybe there is another operator? The GHZ state is stabilized by X_A X_B? That is XIXI * XXII = XXXI? That is not a Pauli? Actually, X_A X_B = (XIXI)(XXII) = X_{0}? Let’s compute: X_A = XIXI, so on qubits: qubit0: X, qubit1: I, qubit2: X, qubit3: I. X_B = XXII, so on qubits: qubit0: X, qubit1: X, qubit2: I, qubit3: I. Their product: qubit0: XX = I, qubit1: IX = X, qubit2: XI = X, qubit3: II = I. So X_A X_B = IXXI. That applied to |ψ_ideal>? For |0000>, IXXI gives |0110>? That is not an eigenvector. So maybe it’s not a stabilizer state in the usual sense? But it is a Clifford state because it is prepared by a Clifford circuit. So it is a stabilizer state of some subgroup of the Pauli group. The stabilizer of |ψ_ideal> should have 4 generators (for 4 qubits, stabilizer states have stabilizer group of size 2^4=16). So we can find the stabilizers. They are: S1 = XXXX S2 = ZZZZ S3 = ? Maybe we can find them by: The circuit: U = CNOT_{03} H_0 CNOT_{21} H_2. And initial state is |0000>. So the stabilizers of the initial state are: Z0, Z1, Z2, Z3. Then conjugated by U, we get the stabilizers of the final state. So: For initial stabilizer: Z0 -> U Z0 U^\dagger. But that might be messy.

Maybe it’s easier to compute the overlap directly. We want: F(P) = |<ψ_ideal| P |ψ_ideal>|^2. Since P is a Pauli, it will either commute or anticommute with the stabilizers? But careful: The state is not necessarily an eigenvector of all Paulis? But if P is in the stabilizer group of |ψ_ideal>, then P|ψ_ideal> = |ψ_ideal>, so overlap = 1. If P is not in the stabilizer, then it might send |ψ_ideal> to an orthogonal state? But not necessarily: For example, consider a GHZ state on two qubits: (|00>+|11>)/√2. Then the Pauli X on one qubit: X1 gives (|10>+|01>)/√2, which is orthogonal to the original. But what about Z1? Z1 gives (|00> - |11>)/√2, which is also orthogonal. So for the two-qubit GHZ, any Pauli that is not identity and not a stabilizer? Actually, the stabilizers of the two-qubit GHZ are XX and ZZ? Actually, for two qubits, the GHZ state is stabilized by XX and -ZZ? Actually, check: (|00>+|11>)/√2: XX gives (|11>+|00>)= same, so stabilizer. ZZ gives (|00> + (-1)(-1)? Actually, ZZ: on |00> gives +1, on |11> gives (+1)(+1)=1? Wait, careful: Z⊗Z: |00> -> 1, |11> -> (11)=1, so actually ZZ also stabilizes? But then what about Z⊗I? That gives (|00> - |11>)/√2, which is orthogonal. So indeed, for the two-qubit GHZ, any Pauli that is not in the stabilizer group gives zero overlap. But is that true for our 4-qubit state? Possibly yes because it is a Clifford state. In fact, for any stabilizer state, if a Pauli operator is not in the stabilizer group, then its expectation value is 0. But wait: There is also the possibility that the Pauli operator is a logical operator? But then it might have expectation value ±1? For example, in a logical state, if the state is an eigenvector of a logical operator, then that logical operator will have expectation value ±1. But careful: The stabilizer group of a state is the set of Paulis that act as identity on the state. For a logical state, say |0>_L, the stabilizer group is the code stabilizer plus maybe something like Z_L? Actually, for a logical state, the stabilizer group is only the code stabilizer. Because Z_L does not stabilize |0>_L? Actually, if |0>_L is defined as the +1 eigenvector of Z_L, then Z_L|0>_L = |0>_L, so it is a stabilizer. But then the stabilizer group of a logical state is larger than the code stabilizer? Actually, the code space is 2^k dimensional. A specific state in that code space is not stabilized by all logical operators. For example, for a single qubit code, the code space is 2-dimensional. The stabilizer of a state in that code space is not the whole code stabilizer because the code stabilizer is only the operators that fix every state in the code. For a logical state, say |0>_L, it is an eigenvector of Z_L, but Z_L is not in the stabilizer of the code because it acts as -1 on |1>_L. So the stabilizer group of the state |0>_L is actually the code stabilizer itself? Actually, check: For a stabilizer code, the stabilizer group S is a subgroup of the Pauli group. The code space is the common +1 eigenspace of S. But if we take a particular state |ψ> in the code space, it might be an eigenvector of some Pauli operator that is not in S, but that operator will not necessarily act as identity on all states in the code. So the stabilizer of the state |ψ> is actually larger than S if |ψ> is a stabilizer state? Actually, consider a single qubit: The state |0> has stabilizer {I, Z}. But if we encode |0> into a code, say the repetition code for 3 qubits: |0>_L = |000>, then the stabilizer of the code is {ZZI, IZZ}. But the state |000> is also stabilized by ZZZ? Actually, ZZZ|000> = |000>, so ZZZ is in the stabilizer of the state? But ZZZ is not in the stabilizer of the code because it is not generated by ZZI and IZZ? Actually, for the repetition code, the stabilizer is indeed generated by ZZI and IZZ, and then ZZZ = (ZZI)(IZZ) so it is in the group. So actually, the stabilizer of the state |000> is the whole stabilizer group of the code? But then what about logical X? X_L = XXX. That does not stabilize |000> because XXX|000> = |111>. So indeed, for a logical basis state, the stabilizer is the code stabilizer. But our state is a superposition: (|00>_L + |11>_L)/√2. That state is not stabilized by Z_A or Z_B individually. But it might be stabilized by some other operators. Let’s try to find the stabilizers of |ψ_ideal>. We know that XXXX and ZZZZ stabilize it. What else? Consider the operator: Z_A Z_B = (ZZII)(ZIZI) =? Actually, careful: Z_A = ZZII, Z_B = ZIZI. Their product: On qubit0: ZZ = I, qubit1: ZI = Z, qubit2: IZ = Z, qubit3: I*I = I. So Z_A Z_B = IZZI. Does that stabilize? Apply IZZI to |ψ_ideal>: |0000> -> IZZI gives: qubit1: Z on 0 -> +1, qubit2: Z on 0 -> +1, so remains. |1001> -> qubit1: Z on 0 -> +1, qubit2: Z on 0 -> +1, so remains. |0110> -> qubit1: Z on 1 -> -1, qubit2: Z on 1 -> -1, product = +1, so remains. |1111> -> qubit1: Z on 1 -> -1, qubit2: Z on 1 -> -1, product = +1, so remains. So IZZI stabilizes. So that is a stabilizer. Next, what about X_A X_B? We computed X_A X_B = (XIXI)(XXII) =? Let’s do carefully: X_A = σ_X on qubit0, I on qubit1, σ_X on qubit2, I on qubit3. X_B = σ_X on qubit0, σ_X on qubit1, I on qubit2, I on qubit3. Their product: qubit0: X * X = I, qubit1: I * X = X, qubit2: X * I = X, qubit3: I * I = I. So X_A X_B = IXXI. Check on |ψ_ideal>: IXXI on |0000> gives: qubit1: X on 0 -> |1>, qubit2: X on 0 -> |1>, so becomes |0110>. |0110> becomes: qubit1: X on 1 -> |0>, qubit2: X on 1 -> |0>, so becomes |0000>. Similarly, |1001> becomes? IXXI on |1001>: qubit1: X on 0 -> |1>, qubit2: X on 0 -> |1>, so becomes |1111>. |1111> becomes: qubit1: X on 1 -> |0>, qubit2: X on 1 -> |0>, so becomes |1001>. So IXXI actually swaps the first and third terms and swaps the second and fourth terms. So IXXI does not stabilize individually, but it might be that the state is an eigenvector if the coefficients are the same? Actually, |ψ_ideal> = 1/2 (|0000>+|1001>+|0110>+|1111>). Under IXXI, it becomes 1/2 (|0110>+|1111>+|0000>+|1001>) = same. So IXXI also stabilizes. So we have stabilizers: S1 = XXXX, S2 = ZZZZ, S3 = IZZI, S4 = IXXI. Check if these are independent? They are all commuting? XXXX commutes with IZZI? X and Z anticommute on same qubit? But here IZZI acts on qubits 1 and 2. XXXX acts on all qubits. On qubit1, X and Z anticommute, so overall: sign = (-1)^(number of qubits where both are non-I? Actually, careful: XXXX and IZZI: On qubit1: X and Z anticommute, so product gives a minus sign. On qubit2: X and Z anticommute, so another minus sign. So overall, they commute because two minuses give plus. So yes. So the stabilizer group of |ψ_ideal> is generated by these 4. That group has 16 elements. So indeed, |ψ_ideal> is a stabilizer state. So then for any Pauli operator P, if P is in the stabilizer group, then <ψ_ideal| P |ψ_ideal> = 1. If P is not in the stabilizer group, then it will map |ψ_ideal> to an orthogonal state, so the overlap is 0. But wait: There is also the possibility that P is exactly the negative of a stabilizer? But Pauli operators are Hermitian and have eigenvalues ±1. But if P = -S for some stabilizer S, then P|ψ_ideal> = -|ψ_ideal>, so then overlap = -1, but the fidelity squared is still 1? Actually, fidelity is |<ψ_ideal|P|ψ_ideal>|^2. So if P = -S, then that gives 1 as well. So actually, if P is in the set of Paulis that are ±1 times a stabilizer, then the overlap magnitude is 1. But careful: The stabilizer group itself is a subgroup of the Pauli group. But note: If S is a stabilizer, then -S is not in the stabilizer group because stabilizer group is defined as those operators that act as +1. But if we consider the set of operators that leave the state invariant up to a phase, that set is actually the stabilizer group multiplied by phases? Actually, for a stabilizer state, the state is an eigenvector of all elements of the stabilizer group. But if we take a Pauli operator that is exactly -S, then it will give -1. But then the overlap is -1, so the fidelity squared is 1. So indeed, if P is such that P|ψ_ideal> = ±|ψ_ideal>, then |<ψ_ideal|P|ψ_ideal>|^2 = 1. And if P is not in that set, then the state P|ψ_ideal> is orthogonal to |ψ_ideal>, so overlap = 0. So we need to determine: For a given Pauli error E_total = E4 * E2, when does it act as ±1 on |ψ_ideal>? That is equivalent to: E_total must be in the normalizer of the stabilizer group? Actually, it must commute with all stabilizers? Not exactly: For a stabilizer state, a Pauli operator will either commute or anticommute with each stabilizer generator. If it anticommutes with some generator, then it will map the state to an orthogonal state. So the condition for E_total to have nonzero overlap is that it commutes with all stabilizers. But wait: Check: For a stabilizer state with stabilizers S_i, if a Pauli P anticommutes with some S_i, then S_i P|ψ> = - P S_i|ψ> = - P|ψ>, so P|ψ> is an eigenvector of S_i with eigenvalue -1, so it is orthogonal to |ψ> which is eigenvalue +1. So indeed, for P to have nonzero overlap, it must commute with all stabilizers. But is that sufficient? If P commutes with all stabilizers, then P maps the stabilizer group to itself. But then P|ψ> is also a stabilizer state? Actually, if P commutes with all stabilizers, then P|ψ> is in the code space? But not necessarily: For a stabilizer state, the stabilizer group is maximal. So if P commutes with all stabilizers, then P is actually an element of the stabilizer group itself? Is that true? For a stabilizer state, the stabilizer group is a maximal abelian subgroup of the Pauli group. So if a Pauli operator commutes with all elements of that maximal abelian subgroup, then it must be in that subgroup. Actually, that is a property: For a maximal abelian subgroup, the centralizer is the subgroup itself. So indeed, if P commutes with all stabilizers, then P is in the stabilizer group. But wait: There is a nuance: The stabilizer group of a state is defined as the set of Paulis that stabilize the state. But if P commutes with all stabilizers, then P|ψ> is an eigenvector of each stabilizer with eigenvalue +1, so P|ψ> is in the same eigenspace. But since the stabilizer group is maximal, that eigenspace is 1-dimensional. So P|ψ> must be proportional to |ψ>. So indeed, if P commutes with all stabilizers, then P is in the stabilizer group (up to a phase). But careful: What if P is itself a stabilizer? Then it’s fine. So indeed, the condition for <ψ_ideal| P |ψ_ideal> to be nonzero is that P is an element of the stabilizer group of |ψ_ideal>. And then the overlap is ±1, so fidelity squared is 1.

But wait: Is it possible that P is not in the stabilizer group but still gives a nonzero overlap? For example, if the state is a superposition of two stabilizer states? But here it is a stabilizer state. So yes, it’s exactly that: For a stabilizer state, any Pauli operator either leaves the state invariant (up to a phase) or maps it to an orthogonal state. So then the fidelity for a given error pattern E_total is: If E_total is in the stabilizer group of |ψ_ideal>, then fidelity = 1. Otherwise, fidelity = 0.

So then the overall fidelity F = probability that E_total is in the stabilizer group.

Now, E_total = E4 * E2, where E2 is a Pauli on qubits {1,2} and E4 is a Pauli on qubits {0,3}. And these are chosen independently from the set of Paulis on two qubits, with probability: For each, probability of identity = 1-p, and probability of each non-identity Pauli = p/15. And we want the average fidelity: F = sum_{E2, E4} Prob(E2)Prob(E4) * [1 if E4E2 is in Stabilizer, else 0].

So we need to determine: What are the elements of the stabilizer group of |ψ_ideal>? We have generators: S1 = XXXX S2 = ZZZZ S3 = IZZI S4 = IXXI But careful: These generators act on all 4 qubits. But note: Our errors E2 act only on qubits 1 and 2. And E4 act only on qubits 0 and 3. So E_total is a product of an operator on {0,3} and an operator on {1,2}. So it is of the form: P_{03} ⊗ P_{12}. And we want this to be in the stabilizer group. The stabilizer group consists of products of these generators. Let’s list the stabilizer group elements? They are all of the form: S = (XXXX)^a (ZZZZ)^b (IZZI)^c (IXXI)^d, where a,b,c,d ∈ {0,1}. But careful: These generators might not be independent? Actually, they are 4 generators, so there are 16 elements. But we want to know which ones are of the form (operator on qubits 0,3) ⊗ (operator on qubits 1,2). That is, they factorize as: (A ⊗ B) where A acts on qubits 0 and 3, and B acts on qubits 1 and 2. Because our error E_total is of that form. So we want to find all stabilizer elements that are factorized as such. Let’s compute: S1 = XXXX = (X on qubit0)(X on qubit1)(X on qubit2)(X on qubit3) = (X0 X3) ⊗ (X1 X2)? Actually, careful: XXXX = (X0 ⊗ X1 ⊗ X2 ⊗ X3). That can be written as (X0 ⊗ X3) ⊗ (X1 ⊗ X2) if we reorder? But careful: The tensor product order: qubits: 0,1,2,3. So if we group qubits 0 and 3 together and qubits 1 and 2 together, then XXXX becomes: On the group {0,3}, we have X0 ⊗ X3. On the group {1,2}, we have X1 ⊗ X2. So S1 = (X0 X3) ⊗ (X1 X2). But note: X0 X3 means Pauli X on qubit0 and Pauli X on qubit3. So that is a Pauli on two qubits? But careful: The Pauli group on two qubits: elements are of the form σ ⊗ σ’ where σ, σ’ ∈ {I,X,Y,Z} but with a possible phase. Here X0 X3 is actually X ⊗ X. So S1 = (X⊗X) on {0,3} ⊗ (X⊗X) on {1,2}.

S2 = ZZZZ = (Z0 Z1 Z2 Z3) = (Z0 Z3) ⊗ (Z1 Z2) because qubits 1 and 2 are together? Actually, careful: ZZZZ = Z0 ⊗ Z1 ⊗ Z2 ⊗ Z3. Grouping: {0,3} and {1,2}: That gives (Z0 ⊗ Z3) ⊗ (Z1 ⊗ Z2). So S2 = (Z⊗Z) on {0,3} ⊗ (Z⊗Z) on {1,2}.

S3 = IZZI = on qubits: 0: I, 1: Z, 2: Z, 3: I. So that is: on {0,3}: I⊗I = I, on {1,2}: Z⊗Z. So S3 = I ⊗ (Z⊗Z) on {1,2}? But careful: S3 = I_{0} ⊗ Z_{1} ⊗ Z_{2} ⊗ I_{3} = (I0 ⊗ I3) ⊗ (Z1 ⊗ Z2) = I ⊗ (Z⊗Z).

S4 = IXXI = on qubits: 0: I, 1: X, 2: X, 3: I. So S4 = I ⊗ (X⊗X).

So the stabilizer generators in the factored form (grouping qubits as: group A = {0,3} and group B = {1,2}) are: S1 = (X⊗X)_A ⊗ (X⊗X)_B S2 = (Z⊗Z)_A ⊗ (Z⊗Z)_B S3 = I_A ⊗ (Z⊗Z)_B S4 = I_A ⊗ (X⊗X)_B

Now, note that S3 and S4 only act on group B. And S1 and S2 act on both groups. So any stabilizer element is of the form: S = (S1)^a (S2)^b (S3)^c (S4)^d, with a,b,c,d ∈ {0,1}. Let’s compute what that gives on group A and group B. On group A: From S1: gives (X⊗X)^a. From S2: gives (Z⊗Z)^b. From S3 and S4: give I. So on group A, the operator is: (X⊗X)^a (Z⊗Z)^b. But careful: These might not commute? Actually, they are Pauli operators. But note: (X⊗X) and (Z⊗Z) commute? Check: On two qubits, X⊗X and Z⊗Z: On the same qubit, X and Z anticommute, so on qubit0: X and Z anticommute, on qubit3: X and Z anticommute, so overall they commute because two anticommutations give a factor of (-1)(-1)=1. So yes, they commute. So on group A, the operator is: (X⊗X)^a (Z⊗Z)^b. That can be: if a=0,b=0: I⊗I. a=1,b=0: X⊗X. a=0,b=1: Z⊗Z. a=1,b=1: (X⊗X)(Z⊗Z) = (XZ)⊗(XZ) = (iY)⊗(iY) = - Y⊗Y? Actually, careful: XZ = -iY, so XZ ⊗ XZ = (-iY)⊗(-iY) = (-i)(-i) (Y⊗Y) = -1 * (Y⊗Y) = - Y⊗Y. But since we allow phases ±1, ±i? But Pauli group elements are defined up to phases? But here we are interested in the action on the state. The phase might matter. But note: The stabilizer group is defined as operators that stabilize the state. So if an operator has a phase, it might not be in the stabilizer group if that phase is not 1. But wait: The stabilizer group is usually defined as a subgroup of the Pauli group modulo phases? Actually, in quantum error correction, the stabilizer group is a set of operators that have eigenvalue +1 on the code space. They are usually taken to be Hermitian. So we want the operators that are actually in the Pauli group with phase ±1? Actually, Pauli operators are Hermitian if they are products of Pauli matrices with real coefficients. But if we have iY, that is not Hermitian? Actually, Y is Hermitian, so iY is not Hermitian because (iY)^† = -i Y. So typically, we take the Pauli group to be {I, X, Y, Z} with possible factors of ±1, ±i. But for stabilizers, we usually choose them to be Hermitian and with eigenvalue +1. So we want the stabilizer elements to be such that when applied to the state, they give +1. So if an operator has a phase of -1, then it would give -1 on the state? But then it would not be a stabilizer. So we need to be careful: The generators we listed: S1 = XXXX. That is Hermitian and gives +1. S2 = ZZZZ gives +1. S3 = IZZI gives +1. S4 = IXXI gives +1. So these generators are chosen with +1 eigenvalue. Then any product of these will also have eigenvalue +1 if the product does not introduce a phase? But careful: When multiplying Pauli operators, sometimes there can be a phase factor. For example, S1 * S2 = (XXXX)(ZZZZ) = (XZ)(XZ)(XZ)(XZ) on each qubit? Actually, better: S1 and S2 commute. So S1 * S2 is just the product. But what is the phase? Each Pauli matrix is Hermitian. X and Z anticommute on the same qubit, but since we have four qubits, the product S1S2 = (X0Z0)(X1Z1)(X2Z2)(X3Z3). On each qubit, XZ = -iY. So S1S2 = (-iY0)(-iY1)(-iY2)(-iY3) = (-i)^4 (Y0Y1Y2Y3) = (1)(Y0Y1Y2Y3) = YYYY. So S1S2 = YYYY. And that should stabilize the state? Check: YYYY on |0000> gives? Y|0> = i|1>, so YYYY|0000> = i^4 |1111> = |1111>. But |1111> is part of the state, but wait, the state is 1/2(|0000>+|1001>+|0110>+|1111>). So YYYY applied to the state: It will map |0000> to |1111>, |1001> to ? Actually, we want to check if YYYY is in the stabilizer. Let’s check directly: YYYY|ψ_ideal> = ? For |0000>, YYYY gives: Y|0>= i|1>, so overall: i^4 |1111> = |1111>. For |1001>, Y on qubit0: Y|1> = -i|0>, on qubit1: Y|0>= i|1>, on qubit2: Y|0>= i|1>, on qubit3: Y|1> = -i|0>; product phase: (-i)(i)(i)(-i) = (-i * i = 1) (i * -i = 1) actually careful: (-i)(i) = 1, (i)(-i) = 1, so total 1, so |1001> goes to |0110>? Actually, careful: Y|1> = -i|0>, so qubit0: from 1 to 0 with factor -i. qubit1: from 0 to 1 with factor i. qubit2: from 0 to 1 with factor i. qubit3: from 1 to 0 with factor -i. So product phase = (-i)(i)(i)*(-i) = (-i * i = 1) then (1 * i = i) then (i * -i = 1) so actually, let’s do step: Phase = (-i) * (i) = 1, then 1 * (i) = i, then i * (-i) = 1. So phase = 1. And the state becomes: |0,1,1,0> = |0110>. Similarly, |0110> goes to |1001> and |1111> goes to |0000>. So indeed, YYYY permutes the terms, so it gives the same state. So S1S2 is indeed a stabilizer. So it’s fine.

But when we factor into groups A and B, we need to be careful with phases. Let’s compute the group A part from S1^a S2^b. For group A (qubits 0 and 3): S1 gives: on A: X0 X3. S2 gives: on A: Z0 Z3. So S1^a S2^b on A gives: (X0X3)^a (Z0Z3)^b. For a=1,b=0:那就是 X0X3. For a=0,b=1: Z0Z3. For a=1,b=1: (X0X3)(Z0Z3) = (X0Z0)(X3Z3) = (-iY0)(-iY3) = (-i)(-i) Y0Y3 = (-1) Y0Y3? Actually, (-i)(-i) = i^2 = -1. So that gives - Y0Y3. So the operator on A from S1S2 is - Y0Y3. But wait, we computed S1S2 overall is YYYY. On group A, that would be Y0Y3, and on group B, Y1Y2. So there is a discrepancy: S1S2 should be (Y0Y3) ⊗ (Y1Y2). But our factorization from S1^1 S2^1 gives: on A: (X0X3)(Z0Z3) =? Let’s compute carefully: On qubit0: from S1: X, from S2: Z, so product = XZ = -iY. On qubit3: similarly, XZ = -iY. So the product on A is (-iY0)(-iY3) = (i^2) (Y0Y3) = (-1) Y0Y3. On group B: from S1: X1X2, from S2: Z1Z2, so product = (-iY1)(-iY2) = (-1) Y1Y2. So overall, S1S2 would be (-1)^2 Y0Y3 Y1Y2 = Y0Y3 Y1Y2. So it’s consistent: Actually, careful: (-1) from group A and (-1) from group B multiply to give +1. So indeed, when we factor, we get: On A: S1^a S2^b gives: If (a,b) = (0,0): I (1,0): X0X3 (0,1): Z0Z3 (1,1): (X0X3)(Z0Z3) =? As computed, on qubit0: XZ = -iY, on qubit3: XZ = -iY, so product = (-i)(-i) Y0Y3 = (-1) Y0Y3. So it is - Y0Y3. But note that -Y0Y3 is not exactly the same as Y0Y3. But when combined with the group B part, we get the overall phase. So we want to know: For an element to be in the stabilizer, it must act as +1 on the state. That means that the overall operator (on both groups) must be exactly one of the stabilizers. But since our errors are separate on groups A and B, we want to know: For a given Pauli on group A (qubits 0,3) and a Pauli on group B (qubits 1,2), when is their product in the stabilizer group? That is equivalent to: There exist a,b,c,d such that: On group A: The operator is the part from S1^a S2^b (which gives either I, X⊗X, Z⊗Z, or -Y⊗Y) and on group B: The operator is from S1^a S2^b S3^c S4^d? Actually, careful: The full stabilizer element is: S = (S1)^a (S2)^b (S3)^c (S4)^d. On group A, that gives: (X⊗X)^a (Z⊗Z)^b. On group B, that gives: (X⊗X)^a (Z⊗Z)^b (Z⊗Z)^c (X⊗X)^d = (X⊗X)^(a+d) (Z⊗Z)^(b+c). So the stabilizer elements are exactly those operators that on group A are of the form: A = (X⊗X)^a (Z⊗Z)^b, with a,b ∈ {0,1} but note: For (a,b)=(1,1), we get (X⊗X)(Z⊗Z) =? As computed, that equals? Let’s compute explicitly: On two qubits, label them 0 and 3. (X⊗X) means: X on qubit0 and X on qubit3. (Z⊗Z) means: Z on qubit0 and Z on qubit3. Their product: On qubit0: XZ = -iY, on qubit3: XZ = -iY, so the product is (-iY)⊗(-iY) = (i^2) (Y⊗Y) = (-1) (Y⊗Y). So indeed, (X⊗X)(Z⊗Z) = - Y⊗Y. But wait, could it be that -Y⊗Y is actually the same as Y⊗Y up to a phase? No, because Y⊗Y is Hermitian and its eigenvalues are ±1. The phase -1 means that if we apply -Y⊗Y to a state, it gives the negative of what Y⊗Y gives. So they are different operators. But are both in the stabilizer? Let’s check: Is Y⊗Y on group A part of a stabilizer? That would require that there is a stabilizer element that on group A is Y⊗Y. For that, we need (X⊗X)^a (Z⊗Z)^b = Y⊗Y. That would require that on each qubit, we have: from a and b, we want the Pauli to be Y. But X^a Z^b: if a=1,b=1, then XZ = -iY, so that gives -iY, not Y. If we take a=1,b=1 and then multiply by a phase? But the stabilizer group is defined as the set of operators that are products of the generators. Those products are determined up to a phase? Actually, the generators are specific operators. So if we compute S1S2, we get: S1S2 = (XXXX)(ZZZZ) =? Let’s compute S1S2 explicitly on each qubit: On qubit0: X from S1 and Z from S2 gives: XZ = -iY. On qubit1: X and Z gives -iY. On qubit2: X and Z gives -iY. On qubit3: X and Z gives -iY. So S1S2 = (-i)^4 (Y0Y1Y2Y3) = (1)(Y0Y1Y2Y3) = YYYY. So S1S2 is actually YYYY, not -YYYY. So that means that (X⊗X)(Z⊗Z) as computed from the group factorization: On group A, from S1 and S2, we get: (X0X3)(Z0Z3) =? But careful: S1 is X0X1X2X3. When we factor into groups A and B, we write S1 = (X0X3) ⊗ (X1X2). But note: (X0X3) is not exactly the same as X0 ⊗ X3? Actually, it is: X0X3 means the operator that acts as X on qubit0 and X on qubit3. So that is indeed X0 ⊗ X3. So then (X0X3)(Z0Z3) = (X0Z0) ⊗ (X3Z3) because they act on different qubits, so it’s a tensor product. And X0Z0 = -iY0, X3Z3 = -iY3, so product = (-i)(-i) (Y0⊗Y3) = (-1)(Y0⊗Y3). So that suggests that the group A part of S1S2 is -Y0Y3. But then the group B part from S1S2 would be (X1X2)(Z1Z2) = similarly -Y1Y2. Then overall, S1S2 would be (-Y0Y3) ⊗ (-Y1Y2) = (Y0Y3)(Y1Y2) because (-1)(-1)=1. So indeed, it is consistent: The group A part of S1S2 is -Y0Y3, but when combined with the group B part which is also -Y1Y2, the overall phase is (+1). So when we talk about the stabilizer element itself, it is not factorable into independent conditions on group A and group B because the phase might come from both. So we need to determine: For a given error E_total = E_A ⊗ E_B (where E_A acts on qubits 0,3 and E_B acts on qubits 1,2), when is E_A ⊗ E_B in the stabilizer group? That means there exist a,b,c,d such that: E_A ⊗ E_B = (S1)^a (S2)^b (S3)^c (S4)^d. And as computed, the right side is: On A: (X⊗X)^a (Z⊗Z)^b. On B: (X⊗X)^(a+d) (Z⊗Z)^(b+c). And also there is an overall phase that might be ±1? But note: The generators are chosen to have +1 eigenvalue. So they are specific operators. So we want exactly that operator (not up to a phase). So we need to compute the actual Pauli operator (including the phase) that results from the product. Let’s compute the stabilizer elements explicitly in terms of their action on groups A and B. We have: S1 = X0X1X2X3. Write as: (X0X3) ⊗ (X1X2). But careful: (X0X3) is actually X0 ⊗ X3. So S1 = (X0 ⊗ X3) ⊗ (X1 ⊗ X2). There is no phase here. S2 = Z0Z1Z2Z3 = (Z0⊗Z3) ⊗ (Z1⊗Z2). S3 = I0 Z1 Z2 I3 = (I0⊗I3) ⊗ (Z1⊗Z2). S4 = I0 X1 X2 I3 = (I0⊗I3) ⊗ (X1⊗X2).

Now, any stabilizer element is: S = S1^a S2^b S3^c S4^d. But careful: When multiplying these, we have to take into account that they commute? They do commute. So we can write: S = (S1^a S2^b) (S3^c S4^d). And note that S3 and S4 only act on group B, and they commute with S1 and S2? They do because they act on different qubits? Actually, S1 and S2 act on both groups, but since S3 and S4 act only on group B, they commute with the group B part of S1 and S2? But careful: S1 has a group B part: X1X2. That commutes with S3? S3 is Z1Z2, and X and Z anticommute on each qubit, so X1X2 and Z1Z2: on qubit1, X and Z anticommute, on qubit2, X and Z anticommute, so they commute overall because (-1)*(-1)=1. So yes, they commute. So we can write: S = (S1^a S2^b) (S3^c S4^d) = [ (X0X3)^a (Z0Z3)^b ]_A ⊗ [ (X1X2)^a (Z1Z2)^b ]_B * [ I_A ] ⊗ [ (Z1Z2)^c (X1X2)^d ]_B. So then overall, on group A, we have: A = (X0X3)^a (Z0Z3)^b. On group B, we have: B = (X1X2)^a (Z1Z2)^b (Z1Z2)^c (X1X2)^d = (X1X2)^(a+d) (Z1Z2)^(b+c).

Now, what are the possible outcomes on group A? For a,b ∈ {0,1}: If (a,b)=(0,0): A = I. (1,0): A = X0X3. (0,1): A = Z0Z3. (1,1): A = (X0X3)(Z0Z3). As computed, on qubit0: XZ = -iY, on qubit3: XZ = -iY, so this product is (-iY0)(-iY3) = (i^2)(Y0Y3) = (-1) Y0Y3. So A = - Y0Y3. So on group A, the stabilizer elements can be: I, X0X3, Z0Z3, and -Y0Y3. On group B, we have: Let u = a+d mod 2, and v = b+c mod 2. So u,v ∈ {0,1}. Then B = (X1X2)^u (Z1Z2)^v. Now, if (u,v)=(0,0): B = I. (1,0): B = X1X2. (0,1): B = Z1Z2. (1,1): B = (X1X2)(Z1Z2) = similarly, = - Y1Y2. So the stabilizer elements are: S = (A) ⊗ (B) with the following possibilities: A can be: I, X0X3, Z0Z3, -Y0Y3. B can be: I, X1X2, Z1Z2, -Y1Y2. But wait, are all these 16 combinations actually stabilizer elements? They come from a,b,c,d with a,b ∈ {0,1} and then u = a+d mod 2, v = b+c mod 2 can be any independent? For example, can we have A = I and B = -Y1Y2? That would require a=0,b=0 so that A=I, and then we need u=1,v=1, so a+d=1 mod2 means d=1, and b+c=1 mod2 means c=1. So yes, that gives S = I ⊗ (-Y1Y2) = - I0I3 ⊗ Y1Y2. But is that actually a stabilizer? Check: -Y1Y2 on group B. But wait, our generators S3 and S4 give on group B: S3 gives Z1Z2, S4 gives X1X2. Their product S3S4 gives Z1Z2 X1X2 =? That would be? Actually, careful: S3S4 = (IZZI)(IXXI) = I (Z X)(Z X) I = on qubits 1 and 2: ZX on qubit1 gives -iY, on qubit2: ZX gives -iY, so product = (-iY1)(-iY2) = (-1) Y1Y2. So S3S4 = - I0I3 ⊗ Y1Y2. So indeed, that is a stabilizer. So yes.

So the stabilizer group consists of all operators of the form: On group A: either I, X0X3, Z0Z3, or -Y0Y3. On group B: either I, X1X2, Z1Z2, or -Y1Y2. But wait: Could there be a stabilizer element that has, say, A = Y0Y3 (without the minus sign)? That would require (a,b)=(1,1) but then we would need an overall phase factor of -1 to turn -Y0Y3 into Y0Y3. But then that would be -S1S2, which is not in the stabilizer because -S1S2 would give -1 times the state? Actually, check: -S1S2|ψ_ideal> = -|ψ_ideal>, so that is not a stabilizer. So indeed, the stabilizer elements are exactly those.

So, for an error E_total = E_A ⊗ E_B to be in the stabilizer, we need: E_A must be one of: I, X0X3, Z0Z3, -Y0Y3. E_B must be one of: I, X1X2, Z1Z2, -Y1Y2. But careful: Is it sufficient that E_A and E_B are individually these? Because if E_A is, say, X0X3 and E_B is I, then the product is X0X3 ⊗ I, which is indeed a stabilizer (S1 with a=1,b=0,c=0,d=0 gives that). So yes.

So then the condition for fidelity to be 1 is that: E4 (which acts on group A: qubits 0 and 3) is such that E4 is in the set {I, X0X3, Z0Z3, -Y0Y3}? But wait: E4 is a Pauli error on qubits 0 and 3. But note: E4 is applied as an error after CNOT_{03}. But we determined that the overall effect is that the final state is E4 E2 |ψ_ideal>. And E4 acts on group A and E2 acts on group B. So we need E4 to be one of these four operators on two qubits? But careful: The set of Pauli operators on two qubits (ignoring phases) has 16 elements. But here we are not ignoring phases: The stabilizer condition requires that the actual operator (including phase) is exactly one of these. So for group A, the allowed operators are:

I (which is identity on both qubits)
X0X3 (that is, Pauli X on qubit0 and Pauli X on qubit3)
Z0Z3
-Y0Y3 (that is, the operator that is -1 * (Y0 ⊗ Y3))

Similarly, for group B, the allowed operators are:

I
X1X2
Z1Z2
-Y1Y2

So then the fidelity is 1 if and only if E4 is in that set and E2 is in that set? But wait: Is it that both must be in these sets independently? Because if E4 is in that set and E2 is in that set, then E4⊗E2 is in the stabilizer. Conversely, if E4⊗E2 is in the stabilizer, then necessarily E4 must be one of these and E2 must be one of these? Could it be that E4 is not in that set but E2 is such that the product becomes something? For example, suppose E4 = Y0Y3 (without the minus sign). And suppose E2 = ? For the product to be in the stabilizer, we would need E2 such that Y0Y3 ⊗ E2 is in the stabilizer. That would require that on group A, we have Y0Y3, but the stabilizer only has -Y0Y3 on group A. So we would need E2 to contribute a factor of -1. But E2 is a Pauli on group B. The Pauli operators on group B are of the form ± (something). But can they contribute a factor of -1? For example, if E2 = -I (the operator that is -1 times identity on group B), then E4⊗E2 = -Y0Y3 ⊗ I, which is in the stabilizer? Because stabilizer has -Y0Y3 ⊗ I? Check: Is -Y0Y3 ⊗ I a stabilizer? That would be if we take a=1,b=1 gives A = -Y0Y3, and then we want B = I. That requires u=0,v=0, so a+d=0 mod2 means d=1 mod2? Actually, if a=1, then d must be 1 to get u=0? Because u = a+d mod2, so if a=1, then to have u=0, we need d=1. And v = b+c, with b=1, to have v=0, we need c=1. So that gives S = S1 S2 S3 S4. Let’s compute S1S2S3S4: S1S2S3S4 = (XXXX)(ZZZZ)(IZZI)(IXXI) =? We already computed S1S2 = YYYY. And S3S4 = - I⊗Y1Y2? Actually, S3S4 = - I0I3 ⊗ Y1Y2. So product = YYYY * (- I⊗Y1Y2) = - YYYY * (I⊗Y1Y2) but careful: YYYY acts on all qubits: on group A: Y0Y3, on group B: Y1Y2. So product = - (Y0Y3)(Y1Y2) * (I⊗Y1Y2) = - Y0Y3 ⊗ (Y1Y2 * Y1Y2) = - Y0Y3 ⊗ (Y1^2 Y2^2) = - Y0Y3 ⊗ (I) because Y^2=I. So indeed, S1S2S3S4 = - Y0Y3 ⊗ I. So that is a stabilizer. So wait, that means that if E4 = Y0Y3 (which is not in our list because our list requires -Y0Y3) and if E2 = -I (on group B), then the product is -Y0Y3 ⊗ (-I) = Y0Y3 ⊗ I? That would be positive? Actually, careful: E2 = -I means the operator is -1 times the identity on qubits 1 and 2. So then E4⊗E2 = (Y0Y3) ⊗ (-I) = - (Y0Y3 ⊗ I). And that is exactly the stabilizer we just found: S1S2S3S4 = -Y0Y3 ⊗ I. So indeed, if E4 = Y0Y3 and E2 = -I, then the overall error is in the stabilizer. So our condition is not that E4 and E2 are individually in those sets, but rather that the combined operator E4 ⊗ E2 is in the stabilizer group. And the stabilizer group consists of operators of the form: On group A: either I, X0X3, Z0Z3, or -Y0Y3. On group B: either I, X1X2, Z1Z2, or -Y1Y2. But wait, could there be a stabilizer element that has, say, on group A: Y0Y3? As we just saw, if we take S1S2S3S4, we got -Y0Y3 ⊗ I. So that gives group A = -Y0Y3, not Y0Y3. What about something that gives group A = Y0Y3? That would require an overall minus sign relative to that. For instance, if we take -S1S2S3S4, that would be Y0Y3 ⊗ I, but that is not in the stabilizer because it would give -1 times the state? Actually, check: -S1S2S3S4|ψ_ideal> = - (stabilizer action) = -|ψ_ideal>, so that is not a stabilizer. So indeed, the stabilizer group does not contain any operator that has a positive Y0Y3 on group A. So the condition is: E4 ⊗ E2 must be one of the 16 stabilizer elements. That means that if we write E4 as a Pauli on two qubits (qubits 0 and 3), it can be any Pauli up to a phase? But careful: The Pauli group on two qubits has 16 elements if we consider the operators themselves (like I, X, Y, Z on each qubit independently) but then multiplied by phases ±1, ±i. However, when we talk about errors, they are physical operations. The error channel says: “produces one of the 15 non-identity two-qubit Paulis with equal probability p/15”. What does “non-identity two-qubit Paulis” mean? Typically, it means the set of operators of the form σ_i ⊗ σ_j where (i,j) is not (0,0) if we label I=0, X=1, Y=2, Z=3. But also, these operators are usually taken to be Hermitian? Actually, the depolarizing channel is usually defined as: With probability p, an error occurs, and the error is chosen uniformly from the set {I,X,Y,Z}⊗{I,X,Y,Z} excluding the identity. But note: That set has 15 elements. But these 15 elements are not all Hermitian? Actually, they are Hermitian because X, Y, Z are Hermitian. But wait: What about phases? For example, iI is not included because that’s not a Pauli matrix. So the errors are exactly the Pauli matrices (tensor products) with no additional phases. So that means that for a two-qubit error, the possible errors are: On two qubits, the operators are: I⊗I, I⊗X, I⊗Y, I⊗Z, X⊗I, X⊗X, X⊗Y, X⊗Z, Y⊗I, Y⊗X, Y⊗Y, Y⊗Z, Z⊗I, Z⊗X, Z⊗Y, Z⊗Z. And the error channel says: with probability 1-p, no error (which is I⊗I). With probability p, one of the other 15 occurs, each with probability p/15. So for E4, which acts on qubits 0 and 3, the possible errors are these 16 operators (including identity). But note: They are defined without any additional phase factors. So for example, Y⊗Y is one of them. But our stabilizer condition requires that on group A, the operator should be -Y0Y3, not Y0Y3. So if E4 = Y0Y3 (i.e., Y on qubit0 and Y on qubit3), then that is not a stabilizer element by itself. But it could become a stabilizer if combined with an E2 that gives a factor of -1. But wait, can E2 give a factor of -1? E2 is also a Pauli on two qubits (qubits 1 and 2) from the set of 16 operators (I⊗I, I⊗X, …, Z⊗Z). These operators are also defined without any phase factors. So for example, if E2 = I⊗I, that is identity, so no phase. If E2 = something else, could it contribute a phase? For instance, consider E2 = -I? But -I is not in the set of Pauli errors because the Pauli errors are taken to be the matrices themselves, not multiplied by -1. Because the Pauli group has phases ±1, ±i, but the depolarizing channel usually considers the set of Pauli operators that are Hermitian and square to identity? Actually, wait: The Pauli matrices X, Y, Z are Hermitian and square to I. But what about -X? That is also Hermitian and squares to I. So could -X be considered as an error? Typically, the depolarizing channel is defined as: ρ -> (1-p)ρ + (p/15) sum_{P in Pauli, P≠I} P ρ P. Here the sum is over all Pauli operators that are not identity. But note: If P is a Pauli operator, then -P is also a Pauli operator. But are they considered distinct? For example, on one qubit, the Pauli operators are usually taken as {I, X, Y, Z}. But what about -X? That is not included because it is just a phase times X. However, sometimes the depolarizing channel is defined as: ρ -> (1-p)ρ + (p/3)(XρX + YρY + ZρZ). That does not include -X because -Xρ(-X) = XρX. So indeed, the errors are considered up to a phase? Actually, careful: The depolarizing channel on a single qubit is: ρ -> (1-p)ρ + (p/3)(XρX + YρY + ZρZ). So if an error occurs, it is equally likely to be X, Y, or Z. But what about -X? That would give the same effect because (-X)ρ(-X) = XρX. So actually, the error is not sensitive to overall phases. But wait, our analysis here: We are computing the fidelity <ψ|E|ψ>^2. If E and -E are different operators, they could give different results because <ψ|(-E)|ψ> = -<ψ|E|ψ>. But then the fidelity squared is the same. However, if the error channel is defined as: with probability p/15, we apply one of the 15 non-identity Pauli operators, then those 15 are具体哪些? They are typically: {I⊗I, I⊗X, I⊗Y, I⊗Z, X⊗I, X⊗X, X⊗Y, X⊗Z, Y⊗I, Y⊗X, Y⊗Y, Y⊗Z, Z⊗I, Z⊗X, Z⊗Y, Z⊗Z} but excluding I⊗I. So that set does not include any operators with a minus sign. So for example, -X⊗X is not in that set. So then, for E4, the possible outcomes are exactly these 16 operators (with identity having probability 1-p, and each of the 15 others having probability p/15). And these operators are defined without any extra minus signs. So then, for group A, the possible E4 are: I, X0I3? But careful: E4 acts on qubits 0 and 3. So its possible forms are: I0I3, I0X3, I0Y3, I0Z3, X0I3, X0X3, X0Y3, X0Z3, Y0I3, Y0X3, Y0Y3, Y0Z3, Z0I3, Z0X3, Z0Y3, Z0Z3. But wait: Is that correct? The error is on two specific qubits. So yes, there are 16 operators. But note: They are not all products that act on both qubits necessarily? They can act on only one qubit as well. For example, X0I3 is an error that only affects qubit0. Similarly, for E2 on qubits 1 and 2, the possible outcomes are the same set: I1I2, I1X2, I1Y2, I1Z2, X1I2, X1X2, X1Y2, X1Z2, Y1I2, Y1X2, Y1Y2, Y1Z2, Z1I2, Z1X2, Z1Y2, Z1Z2.

Now, the stabilizer elements we found are: On group A, they are: I, X0X3, Z0Z3, and -Y0Y3. On group B, they are: I, X1X2, Z1Z2, and -Y1Y2. But note: In the list of possible E4, do we have -Y0Y3? No, because -Y0Y3 is not one of the 16. The 16 are: Y0Y3 is there, but not -Y0Y3. So that means that if E4 alone is considered, it can never be exactly -Y0Y3 because that would require a minus sign. However, could it be that E4 is something that when combined with E2 gives an overall minus? For example, if E4 = Y0Y3 and E2 = ? We want E4⊗E2 to be in the stabilizer. That requires that on group A, we need the operator to be either I, X0X3, Z0Z3, or -Y0Y3. So if E4 = Y0Y3, then to have the product be in the stabilizer, we would need that on group B, E2 contributes a factor of -1. But can E2 contribute a factor of -1? E2 is one of the 16 operators without any inherent minus signs. But wait: What are the actual operators? They are matrices. For example, consider E2 = I1I2. That is identity, so it gives +1. What about E2 = something like? Is there an operator that is actually equal to -I? No, because -I is not in the set because that would be -I1I2, but that is not listed because the listed ones are I1I2 itself. So it seems that the errors are taken from the set of Pauli matrices that are exactly these 16 for each two-qubit pair. They do not include overall minus signs. So then, for E4, the only possibilities that can be part of a stabilizer are those that themselves are exactly one of: I, X0X3, Z0Z3. Because the fourth possibility would be -Y0Y3, but that is not available because available is Y0Y3 itself. What about the possibility of getting a stabilizer element that has, say, on group A: something like X0I3? That is not in the stabilizer because stabilizer elements on group A always involve both qubits simultaneously? Check: Could X0I3 be a stabilizer? That would mean that there is a stabilizer that acts as X on qubit0 and I on qubit3. Is that possible? The stabilizer generators act on both qubits 0 and 3 together because S1 and S2 involve both. So likely not. So for E4 to contribute to a stabilizer, E4 must be either: E4 = I (identity on both qubits) E4 = X0X3 (i.e., X on qubit0 and X on qubit3) E4 = Z0Z3 Or what about E4 = Y0Y3? That would give Y0Y3, but the stabilizer requires -Y0Y3. So if E4 = Y0Y3, then even if E2 is identity, the product is Y0Y3 ⊗ I, which is not a stabilizer because the stabilizer has -Y0Y3 ⊗ I. What if E2 is something that could multiply to give a minus sign? But as argued, E2 is one of the 16 operators without any minus signs. However, could it be that E2 itself is such that its matrix is actually - something? For example, consider E2 = X1X2. That is listed as X1X2. But wait, could it be that X1X2 is actually equal to - something? No, because X1X2 is defined as the Pauli operator that has X on qubit1 and X on qubit2. There is no minus sign. What about E2 = Y1Y2? That is Y1Y2, not -Y1Y2. So it seems that the errors are exactly these 16 operators for each pair. Therefore, for the product E4⊗E2 to be in the stabilizer, we need that: E4 must be one of: I, X0X3, Z0Z3. And then, independently, E2 must be such that the product on group B is one of: I, X1X2, Z1Z2, or -Y1Y2. But wait, could there be a case where E4 is not in {I, X0X3, Z0Z3} but E2 is something that gives an overall phase? For instance, if E4 = Y0Y3, then for the product to be stabilizer, we need E4⊗E2 to be -Y0Y3 ⊗ (something). That would require that on group B, E2 actually is such that when combined with the phase from group A? But group A gives Y0Y3. To turn that into -Y0Y3, we need an overall factor of -1. That overall factor would have to come from group B if group B’s operator is actually -I ( identity times -1). But is -I available as an error? The errors are taken from the set of Pauli matrices on two qubits. That set does not include -I because -I is not one of the 16? Actually, wait: The set of Pauli matrices on n qubits is usually defined as {I, X, Y, Z}⊗n times phases ±1, ±i. But when we say “non-identity two-qubit Paulis”, we usually mean the set of all Pauli operators that are not the identity operator. But careful: There is a difference between the Pauli group and the set of Pauli errors in a depolarizing channel. The depolarizing channel is often defined as: ρ -> (1-p)ρ + (p/15) Σ_{P in {I,X,Y,Z}⊗2 \ {I⊗I}} P ρ P. In that sum, if P and -P are both included, then they would appear twice. But are they considered distinct? For example, on one qubit, the depolarizing channel is: ρ -> (1-p)ρ + (p/3)(XρX + YρY + ZρZ). Notice that -X is not included because (-X)ρ(-X) = XρX. So indeed, the errors are taken to be the Pauli matrices themselves, not their negatives. So the set is actually: {I, X, Y, Z} for one qubit, but wait, that set has 4 elements. For two qubits, the set is {I,X,Y,Z}⊗{I,X,Y,Z} which has 16 elements. But then the depolarizing channel is: ρ -> (1-p)ρ + (p/15) Σ_{P ≠ I⊗I} P ρ P. In that sum, if P appears, then -P does not appear because if P is, say, X⊗X, then -X⊗X is a different operator? But does it matter? Consider: (-X⊗X) ρ (-X⊗X) = (X⊗X) ρ (X⊗X) because the minus signs cancel. So actually, the map ρ -> P ρ P is the same for P and -P. So wait: This is important: The error channel is not that we apply the operator P itself, but rather the quantum operation: ρ -> P ρ P. So if P and -P are different operators, they actually give the same quantum operation because (-P)ρ(-P) = PρP. So when we talk about the depolarizing channel, the errors are usually considered up to a phase. That is, the set of errors is actually the set of Pauli operators modulo the phase factor of ±1. Because if you have an operator P and -P, they produce the same effect on the density matrix. So then, should we consider that the errors are actually from the set of 15 distinct Pauli error types? But careful: The problem statement: “each CNOT_{ij} gate 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 phrase “non-identity two-qubit Paulis” likely means that the errors are taken from the set of Pauli operators on two qubits that are not the identity, but note that if an operator has a overall minus sign, it is still a Pauli operator. However, typically, the depolarizing channel is defined such that the errors are equally likely among the Pauli operators that are not the identity, but since P and -P give the same map, they are usually grouped together. Actually, wait: There are 15 non-identity Pauli operators on two qubits if we consider them up to phase? Let’s check: On one qubit, the non-identity Paulis are usually considered as X, Y, Z. That is 3. On two qubits, the number of Pauli operators that are not the identity (and not considering phases) is actually 4^2 - 1 = 15. But careful: That count comes from: The Pauli group on n qubits has 4^n elements if we ignore phases? Actually, the Pauli group modulo phases is of size 4^n. So for n=2, that is 16. So the non-identity ones are 15. So indeed, the errors are taken from the set of Pauli operators modulo phase. That means that when we say an error occurs, it is actually that we apply some Pauli operator that is representative of its equivalence class under multiplication by ±1. So then, for example, both X⊗X and -X⊗X are actually the same error type because they give the same effect on the state? But careful: When we compute fidelity, we are computing <ψ|P|ψ>. If P is replaced by -P, then that changes the sign. But wait: The fidelity is |<ψ|P|ψ>|^2. So that is the same. However, if the error channel is defined as: with probability p/15, we apply one of the 15 Pauli errors (where each error is considered as an operator that is not the identity up to phase), then does that mean that if the actual error is -P, it is considered the same as P? But then the probability distribution might be such that actually, the chance to get an error that acts as P is p/15, but could it be that sometimes it is P and sometimes -P? However, the depolarizing channel is usually defined as: ρ -> (1-p)ρ + (p/15) Σ_{P in Pauli, P≠I} P ρ P. In that sum, if P and -P are both included, then they would appear twice, but they are actually the same because PρP = (-P)ρ(-P). So actually, the sum should be over a set of representatives that are not related by phase. Typically, the representatives are chosen such that they are Hermitian and square to I. And for Pauli matrices, we usually take I, X, Y, Z. So then on two qubits, the errors are: all operators of the form σ_a ⊗ σ_b where (a,b) runs over {0,1,2,3} with (0,0) excluded, and where σ_0=I, σ_1=X, σ_2=Y, σ_3=Z. So then indeed, the errors are these 15. And note that these representatives are chosen to be exactly these matrices. So then, for example, the error corresponding to Y⊗Y is actually the operator Y⊗Y itself, not -Y⊗Y. So then, for group A, the possible errors E4 are: I⊗I, I⊗X, I⊗Y, I⊗Z, X⊗I, X⊗X, X⊗Y, X⊗Z, Y⊗I, Y⊗X, Y⊗Y, Y⊗Z, Z⊗I, Z⊗X, Z⊗Y, Z⊗Z. And these are the 16. And the non-identity ones are the ones where not both are I. Now, what are the stabilizer elements? They are determined by the generators which are specific operators. Those generators are: S1 = X⊗X⊗X⊗X. But careful: S1 acting on qubits 0 and 3 gives X⊗X. So that representative is X⊗X. S2 gives Z⊗Z on group A. S3 and S4 act only on group B. And then products like S1S2 give: On group A, that would be (X⊗X)(Z⊗Z) =? As computed, that equals (-iY)⊗(-iY) = (-1) Y⊗Y. But wait, our representative for Y⊗Y is Y⊗Y itself. So S1S2 actually gives -Y⊗Y on group A. So that means that the stabilizer element S1S2 is not represented by the error type Y⊗Y because it has a minus sign. So indeed, for group A, the stabilizer requires that if the Pauli is Y⊗Y, it must be actually -Y⊗Y to be in the stabilizer. But since our errors are taken as the representatives (Y⊗Y itself), that means that if an error occurs that is of type Y⊗Y on group A, then that error operator is Y⊗Y, not -Y⊗Y. So then, could it be that if we also have an error on group B that is of a certain type, the combined phase might become such that the overall operator becomes a stabilizer? For instance, suppose E4 = Y⊗Y (on group A) and suppose E2 = ? We want E4⊗E2 to be in the stabilizer. That requires that on group A, we need the operator to be either I, X⊗X, Z⊗Z, or -Y⊗Y. So if E4 = Y⊗Y, then to get -Y⊗Y overall, we would need that E2 contributes a factor of -1. Can E2 contribute a factor of -1? E2 is also one of the representatives. Is it possible that an error representative is actually equal to -I? No, because the representative for I is I itself. What about other errors? For example, consider E2 = X⊗X. That is X⊗X itself. That does not have a minus sign. What about E2 = something like? Actually, note that all representatives are chosen to be exactly the Pauli matrices without any additional minus signs. So then, it seems that for the product E4⊗E2 to be in the stabilizer, we need that individually, E4 must be such that its representative is actually one of: I, X⊗X, Z⊗Z. Because if E4 is Y⊗Y, then no matter what E2 is (since E2 will be one of the 16 representatives), the product will be (Y⊗Y) ⊗ (something). But could that something ever introduce a overall minus sign? For that to happen, we would need that something is actually -I (on group B). But -I is not one of the representatives because the representative for I is I itself. What if E2 is something like? wait, could it be that the error channel actually includes the possibility of applying -I? But -I is not included because that would be considered the same as I? Actually, careful: The depolarizing channel is defined as: with probability 1-p, no error; with probability p, an error occurs, and the error is chosen uniformly from the set of 15 non-identity Pauli operators. That set does not include -I because -I is not non-identity? Actually, -I is non-identity? But wait, -I is different from I. However, usually, the depolarizing channel is defined as: ρ -> (1-p)ρ + (p/3)(XρX+YρY+ZρZ) for a single qubit. That does not include -X because -X would give the same map as XρX. So they are not considered distinct errors. So the errors are taken to be the ones that are Hermitian and square to I. Those are: I, X, Y, Z. So for two qubits, the errors are taken to be: σ_a ⊗ σ_b where σ_a is in {I,X,Y,Z} and (a,b) ≠ (0,0). So indeed, there is no overall minus sign. Therefore, I conclude that for E4 to contribute to a stabilizer outcome, E4 must be either: E4 = I (identity) E4 = X0X3 (i.e., Pauli X on both qubits 0 and 3) E4 = Z0Z3 What about E4 = something like X0I3? That would not be in the stabilizer because stabilizer requires that on qubit3 also something happens? Let’s check: Could X0I3 be a stabilizer? That would mean that there is a stabilizer element that acts as X on qubit0 and I on qubit3. Is that possible? The stabilizer generators involve both qubits together. So likely not. So yes.

Similarly, for E2, for the product to be in the stabilizer, we need that on group B, the operator must be one of: I, X1X2, Z1Z2, or -Y1Y2. But careful: The representatives for errors on group B are also taken as: I, X, Y, Z on each qubit. So that means that if an error on group B is of the type Y1Y2, its representative is Y1Y2 itself. But the stabilizer requires -Y1Y2. So that means that if E2 = Y1Y2, then that alone would not be okay. However, could it be that if E4 is something that contributes a phase? For instance, if E4 is something that itself has a phase factor? But as argued, E4 is from the set of representatives, so they don’t have an overall minus sign. What if E4 = I? Then E2 must be such that its representative is actually -Y1Y2 to be in the stabilizer. But -Y1Y2 is not available because the available representative is Y1Y2. So it seems that for E2, the errors that are in the stabilizer set are actually: E2 = I, E2 = X1X2, E2 = Z1Z2. What about E2 = Y1Y2? That would give Y1Y2, but the stabilizer requires -Y1Y2. So that is not included. But wait, could there be a case where both E4 and E2 are not individually in these sets but their product becomes a stabilizer? For example, if E4 = Y0Y3 and E2 = Y1Y2, then the product is Y0Y3 ⊗ Y1Y2. Is that a stabilizer? Let’s check: Is YYYY a stabilizer? We determined that S1S2 = YYYY actually. But careful: S1S2 = (XXXX)(ZZZZ) gave YYYY. So YYYY is a stabilizer. So wait: If E4 = Y0Y3 and E2 = Y1Y2, then the product is Y0Y3 ⊗ Y1Y2 = YYYY. And that is a stabilizer because S1S2 is YYYY. But then that means that if both errors are of the type Y⊗Y on their respective groups, the overall error is actually in the stabilizer. But wait, check phases: E4 is representative: Y0Y3 means the operator that is Y on qubit0 and Y on qubit3. E2 is Y1Y2. Their product is Y0Y1Y2Y3. And we computed S1S2 = Y0Y1Y2Y3 (because S1S2 came out as YYYY without any minus sign). So indeed, if E4 = Y0Y3 and E2 = Y1Y2, then the overall error is exactly S1S2, which is a stabilizer. So that means that for E2, it is not that only I, X1X2, Z1Z2 are allowed. Because if E2 = Y1Y2, then if E4 is also Y0Y3, the product is stabilizer. But if E2 = Y1Y2 and E4 is something else, then it might not be. So we need to consider the combined conditions.

Let’s determine systematically: We want E_total = E4 ⊗ E2 to be in the stabilizer group. The stabilizer group consists of operators of the form: S = (S1)^a (S2)^b (S3)^c (S4)^d. And as computed, that gives: On group A: A = (X0X3)^a (Z0Z3)^b. But careful with phases: For (a,b)=(0,0): A = I. (1,0): A = X0X3. (0,1): A = Z0Z3. (1,1): A = (X0X3)(Z0Z3) =? Let’s compute this carefully with phases: S1 on group A is: X0X3. S2 on group A is: Z0Z3. When we multiply these, we get: (X0X3)(Z0Z3) = (X0Z0)(X3Z3) because they act on different qubits so it’s a tensor product. Now, X0Z0 = -i Y0 (since XZ = -iY). So that gives (-iY0)(-iY3) = (i^2)(Y0Y3) = (-1) Y0Y3. So indeed, S1S2 gives on group A: -Y0Y3. So the stabilizer elements on group A are: I, X0X3, Z0Z3, -Y0Y3. On group B, we have: B = (X1X2)^(a+d) (Z1Z2)^(b+c), but careful with phases? Let’s compute similarly: On group B, S1 gives: X1X2. S2 gives: Z1Z2. So (X1X2)(Z1Z2) = (-iY1)(-iY2) = (-1) Y1Y2. Also, S3 gives: Z1Z2. S4 gives: X1X2. So indeed, any stabilizer element on group B will be of the form: I, X1X2, Z1Z2, or -Y1Y2. But wait, could there be a stabilizer element that has on group B something like Y1Y2 itself? What if we take S1S2S3S4? That gave: On group A, we had -Y0Y3 (from S1S2) and on group B, from S3S4, we get? S3S4 = (Z1Z2)(X1X2) =同样 (-1)Y1Y2. So then overall, S1S2S3S4 = (-Y0Y3)⊗(-Y1Y2) = (Y0Y3)(Y1Y2) because (-1)(-1)=1. So that would give YYYY. But wait, that seems to suggest that YYYY is also a stabilizer. But then that would mean that there is a stabilizer element that has on group A: Y0Y3 and on group B: Y1Y2? But careful: S1S2S3S4, let’s compute it explicitly without grouping: S1 = X0X1X2X3 S2 = Z0Z1Z2Z3 S3 = I0Z1Z2I3 S4 = I0X1X2I3 Then S1S2 = (X0Z0)(X1Z1)(X2Z2)(X3Z3) = (-iY0)(-iY1)(-iY2)(-iY3) = ( (-i)^4 ) (Y0Y1Y2Y3) = (1)(Y0Y1Y2Y3) = Y0Y1Y2Y3. So actually, S1S2 = YYYY. I earlier got a phase of -1 when computing separately on groups? I need to be very careful with phases when products involve operators on different qubits that commute. Let’s compute S1S2 carefully: S1 = X0 ⊗ X1 ⊗ X2 ⊗ X3. S2 = Z0 ⊗ Z1 ⊗ Z2 ⊗ Z3. These operators commute because on each qubit, X and Z anticommute but there are an even number of anticommutations? Actually, they commute because S1S2 = (X0Z0)⊗(X1Z1)⊗(X2Z2)⊗(X3Z3). Now, X_iZ_i = -iY_i. So this product = (-iY0)⊗(-iY1)⊗(-iY2)⊗(-iY3) = (-i)^4 (Y0⊗Y1⊗Y2⊗Y3) = (1)(YYYY) = YYYY. So S1S2 = YYYY. Now, if I try to separate into groups A and B, I must be careful because the tensor product is over all qubits. When I write S1 = (X0X3) ⊗ (X1X2), that is fine because X0X3 means X0⊗X3 and X1X2 means X1⊗X2. So S1 = (X0⊗X3) ⊗ (X1⊗X2). Similarly, S2 = (Z0⊗Z3) ⊗ (Z1⊗Z2). Then S1S2 = [(X0⊗X3)(Z0⊗Z3)] ⊗ [(X1⊗X2)(Z1⊗Z2)]. Now, (X0⊗X3)(Z0⊗Z3) is not simply the product of independent terms because these operators act on different qubits? Actually, they do act on different qubits so they commute. So (X0⊗X3)(Z0⊗Z3) = (X0Z0)⊗(X3Z3) because X0 and Z3 commute etc. So that gives (-iY0)⊗(-iY3) = (-i)^2 (Y0⊗Y3) = (-1)(Y0⊗Y3). So that suggests that the group A part of S1S2 is -Y0Y3. And similarly, the group B part is -Y1Y2. Then overall, S1S2 would be (-Y0Y3)⊗(-Y1Y2) = (-1)(-1) (Y0Y3⊗Y1Y2) = YYYY. So it is consistent if we remember that the tensor product of phases multiplies. So when I say the group A part is -Y0Y3, that means that there is a factor of -1 associated with that group. And the group B part is -Y1Y2, which gives another factor of -1. When combined, (-1)*(-1)=1. So it is better to not separate the phases between groups because they multiply. So let’s instead determine the condition for E_total to be in the stabilizer by looking at its effect on the state |ψ_ideal>. Maybe it’s easier to compute the fidelity for each type of error directly from the state expression.

We have |ψ_ideal> = 1/2 (|0000> + |1001> + |0110> + |1111>). And E_total = E4 ⊗ E2. But careful: E4 acts on qubits 0 and 3. E2 acts on qubits 1 and 2. So let’s denote E4 by its action on qubits 0 and 3. It will map basis states to basis states with a phase. Similarly for E2. We want to compute <ψ_ideal| E_total |ψ_ideal>. This will be zero unless E_total maps each term to itself or to another term in the superposition with the same phase relations? Actually, because |ψ_ideal> is a superposition of four states. E_total will permute these states and multiply by phases. So <ψ_ideal|E_total|ψ_ideal> = (1/4) times the sum over the four states of the phase factors when that state is mapped to itself or to another state that is also in the superposition, but careful with cross terms.

Maybe we can do this by brute force for each type of error? But there are 16*16 = 256 combinations. But wait, the errors are independent and we only need the average fidelity. And fidelity is |<ψ|E|ψ>|^2. And because |ψ> is a stabilizer state, this will be either 1 or 0. Is that true? For a stabilizer state, any Pauli operator either leaves it invariant (up to a phase) or maps it to an orthogonal state. So indeed, for each E_total, the fidelity is either 1 or 0. So we just need to count the number of error pairs (E4, E2) such that E_total is in the stabilizer group of |ψ_ideal>. And then the fidelity will be that probability.

So then the problem reduces to: Given that E4 is chosen uniformly from the 16 Pauli operators on qubits {0,3} with probability: P(E4=I) = 1-p, and for each of the 15 non-identity, probability = p/15. Similarly, E2 is chosen from the 16 on qubits {1,2} with P(I)=1-p, and others p/15 each.

And we want the probability that E4 ⊗ E2 is in the stabilizer group of |ψ_ideal>. And the stabilizer group has 16 elements. But careful: The stabilizer group is a subgroup of the Pauli group on 4 qubits. But wait, is it true that if a Pauli operator is in the stabilizer group, then it will have fidelity 1? Yes. So we need to know: How many Pauli operators on 4 qubits are in the stabilizer group? There are 16. But these 16 are specific operators. They are determined by the conditions we derived earlier but with careful phase issues. Let’s list the stabilizer group elements explicitly in terms of their action on qubits 0,3 and 1,2. They are given by: S = (S1)^a (S2)^b (S3)^c (S4)^d, with a,b,c,d ∈ {0,1}. Let’s compute these 16 explicitly and write them in the form ( operator on qubits 0,3 ) ⊗ ( operator on qubits 1,2 ) including the overall phase factor that makes sure that S|ψ_ideal> = |ψ_ideal>. But careful: The stabilizer condition is that S|ψ_ideal> = |ψ_ideal>. So these S are determined up to an overall phase? Actually, they are specific operators. Let’s compute them by taking specific values of a,b,c,d.

We have: S1 = X0 X1 X2 X3. S2 = Z0 Z1 Z2 Z3. S3 = I0 Z1 Z2 I3. S4 = I0 X1 X2 I3.

I will compute S = product for each combination. It might be easier to compute the action on group A and group separately but keeping track of phases carefully. Let’s do that:

S = (S1)^a (S2)^b (S3)^c (S4)^d. Group A (qubits 0 and 3): From S1: contributes: (X0X3)^a. From S2: contributes: (Z0Z3)^b. From S3 and S4: nothing on group A. So on group A, the operator is: A = (X0X3)^a (Z0Z3)^b. But careful with phases when both a and b are 1. Let’s compute that carefully: If a=0,b=0: A = I. If a=1,b=0: A = X0X3. If a=0,b=1: A = Z0Z3. If a=1,b=1: A = (X0X3)(Z0Z3). Now, (X0X3)(Z0Z3) = (X0Z0)(X3Z3) because these act on different qubits so they commute. Now, X0Z0 = -i Y0. So that gives (-iY0)*(-iY3) = (i^2)(Y0Y3) = (-1)(Y0Y3). So A = - Y0Y3. So on group A, the possible outcomes are: I, X0X3, Z0Z3, -Y0Y3.

Group B (qubits 1 and 2): From S1: contributes: (X1X2)^a. From S2: contributes: (Z1Z2)^b. From S3: contributes: (Z1Z2)^c. From S4: contributes: (X1X2)^d. So on group B, the operator is: B = (X1X2)^(a+d) (Z1Z2)^(b+c). But careful with phases when both (a+d) and (b+c) are 1 mod something? Let’s do it similarly: Let u = a+d mod 2, and v = b+c mod 2. Then B = (X1X2)^u (Z1Z2)^v. If u=0,v=0: B = I. If u=1,v=0: B = X1X2. If u=0,v=1: B = Z1Z2. If u=1,v=1: B = (X1X2)(Z1Z2) = similarly = (-1) Y1Y2. So then overall, S = A ⊗ B. But wait, there could be an additional phase coming from the fact that these operators commute? They should commute because they act on different groups. So then the overall S is simply the tensor product. So then the stabilizer elements are: For any a,b,c,d, we get: A = determined by (a,b): (0,0): I (1,0): X0X3 (0,1): Z0Z3 (1,1): -Y0Y3 B = determined by (u,v) where u=a+d, v=b+c: (0,0): I (1,0): X1X2 (0,1): Z1Z2 (1,1): -Y1Y2 So then S = A ⊗ B. Now, note that these 16 are all distinct? Let’s check: If (a,b,c,d) = (1,1,1,1), then A = -Y0Y3, B = since u=1+1=0 mod2? Actually, careful: u = a+d mod2, so if a=1,d=1, then u=0 mod2. v = b+c, if b=1,c=1, then v=0 mod2. So that gives B = I. So S = (-Y0Y3) ⊗ I = -Y0Y3 I1I2. If (a,b,c,d) = (1,1,0,0), then A = -Y0Y3, and u=1+0=1, v=1+0=1, so B = -Y1Y2. Then S = (-Y0Y3)⊗(-Y1Y2) = (Y0Y3)(Y1Y2) because (-1)(-1)=1. So that gives S = Y0Y3 Y1Y2 = YYYY. So these are different. So the stabilizer group consists of these 16 operators. Now, we want to know when does an error E_total = E4 ⊗ E2 become one of these stabilizer elements. E4 is one of the 16 Pauli operators on qubits 0 and 3. But careful: The Pauli operators on two qubits are usually taken as: I, X, Y, Z on each qubit independently. So they are of the form: E4 = ( phase ) * (σ_{0} ⊗ σ_{3}) where σ_{0} and σ_{3} are in {I,X,Y,Z} and the phase is such that the operator is Hermitian and squares to I. Actually, the standard Pauli matrices are defined without any phase factors. So for two qubits, the set is: { I⊗I, I⊗X, I⊗Y, I⊗Z, X⊗I, X⊗X, X⊗Y, X⊗Z, Y⊗I, Y⊗X, Y⊗Y, Y⊗Z, Z⊗I, Z⊗X, Z⊗Y, Z⊗Z }. So for example, what is X⊗X? That is clear. What is Y⊗Y? That is the operator that acts as Y on both qubits. Now, compare with our stabilizer elements on group A. They are: I, X0X3, Z0Z3, and -Y0Y3. Notice that -Y0Y3 is not the same as Y0Y3. So if an error E4 is actually Y0Y3 (i.e., Y⊗Y), then that is not equal to any stabilizer element on group A because the stabilizer requires -Y0Y3. However, could it be that when combined with an appropriate E2, the overall product becomes a stabilizer? For that to happen, we would need that E2 contributes a factor of -1 to cancel the phase difference. But wait, look at the stabilizer elements: They are of the form A⊗B. If E4 = Y0Y3, then for E4⊗E2 to be a stabilizer, we need that there is some stabilizer element S such that its group A part is Y0Y3. But from our list, the group A parts are only I, X0X3, Z0Z3, and -Y0Y3. There is no stabilizer element with group A part = Y0Y3. What about if both E4 and E2 have phases? For instance, if E4 = Y0Y3 and E2 = something that itself has a phase such that overall the product becomes something like? But wait, the stabilizer elements are determined. They are specific operators. For example, is there a stabilizer element that is Y0Y3 ⊗ (-I) maybe? That would be -Y0Y3 ⊗ I, which is actually a stabilizer? because that is when (a,b,c,d) = (1,1,1,1) gave -Y0Y3 ⊗ I. What about Y0Y3 ⊗ (-I) would be -Y0Y3 ⊗ I if that makes sense? Actually, careful: Y0Y3 ⊗ (-I) means take the operator that is Y on qubit0 and Y on qubit3, and on group B, take the operator that is - times identity. But -I is not one of the standard Pauli representatives because the representative for identity is I itself. So that is not available. What if E4 = Y0Y3 and E2 = something that is not identity but gives an overall multiplication? For the product to be in the stabilizer, it must equal one of the 16 stabilizer elements exactly. The stabilizer elements have determined phases. So for example, consider the stabilizer element that is S1S2S3S4. We computed that earlier: S1S2S3S4 = ? Let’s compute that carefully without splitting groups: S1 = X0X1X2X3 S2 = Z0Z1Z2Z3 S3 = I0Z1Z2I3 S4 = I0X1X2I3 Then S1S2 = (X0Z0)(X1Z1)(X2Z2)(X3Z3) = (-iY0)(-iY1)(-iY2)(-iY3) = (-i)^4 (Y0Y1Y2Y3) = Y0Y1Y2Y3. Then S1S2S3 = Y0Y1Y2Y3 * (I0Z1Z2I3) = Y0 (Y1Z1)(Y2Z2) Y3. Now, Y1Z1 =? Y Z = i X? Actually, careful: Y Z = i X because YZ = iσ_y σ_z = i (-i σ_x) wait, let’s do properly: Pauli matrices: X,Y,Z. They satisfy: XY = iZ, YZ = iX, ZX = iY. So Y Z = i X. So Y1Z1 = i X1. Similarly, Y2Z2 = i X2. So then S1S2S3 = Y0 (iX1)(iX2) Y3 = Y0 (-1) X1X2 Y3 = - Y0 X1X2 Y3. Then S1S2S3S4 = - Y0 X1X2 Y3 * (I0X1X2I3) = - Y0 (X1X2 X1X2) Y3 = - Y0 (X1^2 X2^2) Y3 = - Y0 I1I2 Y3 = - Y0Y3. So S1S2S3S4 = - Y0Y3 I1I2? But wait, that acts only on qubits 0 and 3? Actually, it acts on all qubits: it is - Y0 I1 I2 Y3 = - Y0Y3 on qubits 0 and 3 and identity on qubits 1 and 2. So that stabilizer element is -Y0Y3 ⊗ I. So that is one stabilizer element. What about S1S2 itself? S1S2 = Y0Y1Y2Y3, so that is Y0Y3 ⊗ Y1Y2. So that is a stabilizer element. So indeed, there is a stabilizer element that has group A part = Y0Y3? Because S1S2 gives: On group A: from qubits 0 and 3, that is Y0Y3. On group B: Y1Y2. So that means that if E4 = Y0Y3 and E2 = Y1Y2, then the product is Y0Y3 ⊗ Y1Y2, which is exactly S1S2. But wait, check phases: S1S2 we computed as Y0Y1Y2Y3. And that is indeed Y0Y3 ⊗ Y1Y2 because these are tensor products. So yes, that works. So then, for group A, if E4 = Y0Y3, it can be part of a stabilizer if and only if E2 is also Y1Y2. Because then the product becomes Y0Y3 ⊗ Y1Y2, which is a stabilizer (S1S2). What if E4 = Y0Y3 and E2 is something else? Then the product would be Y0Y3 ⊗ (something). Look at the stabilizer elements: Those that have group A part = Y0Y3. Do any stabilizer elements have group A part = Y0Y3? From our list, when does A become Y0Y3? A = (X0X3)^a (Z0Z3)^b. For this to be Y0Y3, we need that on each qubit, the Pauli is Y. For qubit0, X^a Z^b gives Y if a=1,b=1 would give XZ which is -iY, so to get Y, we would need a phase of i. So actually, wait: (X0X3)(Z0Z3) gave -Y0Y3. To get Y0Y3, we would need -1 times that, so that would be actually (Z0Z3)(X0X3) is the same order? They commute so it’s the same. So it seems that no matter what, (X0X3)(Z0Z3) always gives -Y0Y3 because X0Z0 = -iY0, so product = (-iY0)(-iY3)= (-1)Y0Y3. So indeed, there is no way to get a stabilizer element with group A part = Y0Y3 from S1 and S2 alone. What about including S3 and S4? They don’t affect group A. So indeed, any stabilizer element will have group A part that is either I, X0X3, Z0Z3, or -Y0Y3. So wait, then how did S1S2 become Y0Y3 ⊗ Y1Y2? Let’s recompute S1S2 very carefully without any group separation issues: S1 = X0 X1 X2 X3. S2 = Z0 Z1 Z2 Z3. Now, these operators commute because on each qubit, X and Z anticommute but there are an even number of anticommutations? Actually, they commute because S1S2 = (X0Z0)(X1Z1)(X2Z2)(X3Z3). Now, careful: X0Z0 is not simply -iY0 because that is true if we consider the order: X0Z0. But wait, careful: S1 and S2 are operators. They commute because for each qubit, X_i and Z_i anticommute, but since there are two terms per qubit? Actually, check: S1S2 |ψ> = X0X1X2X3 Z0Z1Z2Z3 |ψ>. I can commute Z0 through X1X2X3 because they act on different qubits. So S1S2 = (X0Z0) (X1Z1) (X2Z2) (X3Z3). Now, X0Z0: since X0 and Z0 anticommute, X0Z0 = - Z0X0? That doesn’t help. Let’s actually compute the product on a basis state. Maybe it’s easier to determine the stabilizer conditions directly from the state itself.

Maybe I should compute the fidelity for each error type by actually computing <ψ_ideal|E|ψ_ideal> for Pauli errors that are products of errors on these two groups. Because |ψ_ideal> is given explicitly. And since errors are Pauli, they will either leave the state invariant or map it to an orthogonal state. So I can determine for each Pauli operator on 4 qubits whether it is in the stabilizer of |ψ_0> by checking if it commutes with all stabilizer generators? But careful: That requires knowing the stabilizer generators of |ψ_ideal>. I already know that XXXX, ZZZZ, IZZI, IXXI stabilize |ψ_ideal>. So for E_total to be in the stabilizer, it must commute with these generators? Actually, for a stabilizer state, if an operator commutes with all stabilizers, then it is in the stabilizer group. So I can use that condition. So E_total is in the stabilizer if and only if it commutes with S1=XXXX, S2=ZZZZ, S3=IZZI, S4=IXXI. Now, E_total = E4 ⊗ E2, where E4 acts on qubits 0 and 3, and E2 acts on qubits 1 and 2. Let’s write E4 as something like: E4 = Pauli on qubit0 times Pauli on qubit3. So let E4 = P0 ⊗ P3, where P0, P3 ∈ {I,X,Y,Z}. Similarly, E2 = Q1 ⊗ Q2, with Q1,Q2 ∈ {I,X,Y,Z}. Then E_total = P0 ⊗ Q1 ⊗ Q2 ⊗ P3. wait careful with order: qubits: 0,1,2,3. So E_total = (P0) on qubit0, (Q1) on qubit1, (Q2) on qubit2, (P3) on qubit3.

Now, commute with S1= XXXX means that E_total must commute with X0X1X2X3. commute with S2= ZZZZ means commute with Z0Z1Z2Z3. commute with S3= IZZI means commute with I0 Z1 Z2 I3. commute with S4= IXXI means commute with I0 X1 X2 I3.

because these stabilizers commute with each other, E_total will be in the stabilizer if it commutes with each. actually wait: For a stabilizer state, if an operator commutes with all stabilizers, then it is in the stabilizer group. So conditions: [E_total, X0X1X2X3] = 0. [E_total, Z0Z1Z2Z3] = 0. [E_total, I0Z1Z2I3] = 0. [E_total, I0X1X2I3] = 0.

Let’s do these conditions one by one.

Condition from S3: [E_total, I0Z1Z2I3] = 0. E_total = P0 ⊗ Q1 ⊗ Q2 ⊗ P3. S3 = I0 ⊗ Z1 ⊗ Z2 ⊗ I3. These act on different qubits for qubits 0 and 3 clearly commute. So the commutativity condition is that [Q1, Z1] and [Q2, Z2] must be such that overall they commute. Actually, since these are tensor products, [E_total, S3] = 0 if and only if [Q1, Z1]=0 and [Q2, Z2]=0. Because if either anticommutes, then overall they will anticommute because signs multiply? Let’s check: If Q1 anticommutes with Z1 but Q2 commutes with Z2, then E_total S3 = (P0)⊗(Q1Z1)⊗(Q2Z2)⊗(P3) and S3 E_total = (P0)⊗(Z1Q1)⊗(Z2Q2)⊗(P3) = (P0)⊗(-Q1Z1)⊗(Q2Z2)⊗(P3) = - E_total S3. So indeed, we need [Q1, Z1]=0 and [Q2, Z2]=0. So that means that Q1 must commute with Z1, so Q1 cannot be X or Y? Actually, X anticommutes with Z, Y anticommutes with Z. So Q1 must be either I or Z. Similarly, Q2 must be either I or Z. So condition from S3: Q1 ∈ {I, Z} and Q2 ∈ {I, Z}.

Next, condition from S4: [E_total, I0X1X2I3] = 0. Similarly, this gives that [Q1, X1]=0 and [Q2, X2]=0. So Q1 must commute with X1, so Q1 cannot be Z or Y? Actually, Z anticommutes with X, Y anticommutes with X. So Q1 must be either I or X. Combining with S3 condition, Q1 must be such that it commutes with both Z and X. The only Pauli that commutes with both X and Z is I (because X and Z themselves do not commute with each other). So Q1 must be I. Similarly, Q2 must be I. So conditions from S3 and S4 together force that Q1 = I and Q2 = I. That is very strong! That would mean that E2 must be the identity on qubits 1 and 2. But wait, is that true? Let’s check with an example. Consider E_total = X0X1X2X3 itself. That is S1. That commutes with all stabilizers. In that case, Q1 would be X and Q2 would be X. But that violates the condition because X does not commute with Z? But wait, check S3: S3 = IZZI. X and Z anticommute on each qubit. But then overall, would that cause anticommutation? For E_total = X0X1X2X3 and S3 = I0Z1Z2I3, they actually commute because on qubits 1 and 2, we have X1X2 and Z1Z2. And X1 anticommutes with Z1 gives a factor -1, X2 anticommutes with Z2 gives another -1, product (-1)(-1)=1. So wait, my earlier reasoning about conditions from S3 needs to be careful. When we have operators that act on multiple qubits, the commutativity condition is that the operators commute if they anticommute on an even number of qubits. So for S3, we need that the number of qubits among {1,2} for which Q anticommutes with Z should be even. So condition from S3: For qubits 1 and 2, we need that the product of the signs from anticommutation is +1. That is: if Q1 anticommutes with Z1, that gives a factor -1; if Q2 anticommutes with Z2, that gives a factor -1; so overall, if both anticommute, then (-1)(-1)=+1. So actually, the condition from S3 is that Q1 and Q2 must either both commute with Z or both anticommute with Z. Because if one commutes and the other anticommutes, then overall they anticommute. So from S3: either (Q1 commutes with Z1 and Q2 commutes with Z2) OR (Q1 anticommutes with Z1 and Q2 anticommutes with Z2). Similarly, from S4: either (Q1 commutes with X1 and Q2 commutes with X2) OR (Q1 anticommutes with X1 and Q2 anticommutes with X2).

Now, what Paulis commute with Z? I and Z commute with Z. X and Y anticommute with Z. What Paulis commute with X? I and X commute with X. Z and Y anticommute with X. So for the first case from S3: both commute with Z means Q1,Q2 ∈ {I, Z}. For the second case from S3: both anticommute with Z means Q1,Q2 ∈ {X, Y}.

Now from S4: first case: both commute with X means Q1,Q2 ∈ {I, X}. Second case: both anticommute with X means Q1,Q2 ∈ {Z,}.

So combining S3 and S4 conditions: We need that either: Case 1: (Q1,Q2 both commute with Z) and (Q1,Q2 both commute with X). The only possibility for that is Q1,Q2 must be I because Z does not commute with X. So that gives Q1=Q2=I. Case 2: (Q1,Q2 both commute with Z) and (Q1,Q2 both anticommute with X). For anticommute with X, that means Q1,Q2 ∈ {Z, Y} actually wait: anticommute with X means: I and X commute with X, so they are out. Z anticommutes with X, Y anticommutes with X. So that set is {Z, Y}. But wait, also they must commute with Z from case 2 of S3? Case 2 of S3 would be both anticommute with Z, not commute with Z. So careful:

Let’s do it systematically:

S3 gives two possibilities: A: Q1 and Q2 are such that they both commute with Z. So that means Q1,Q2 ∈ {I, Z}. B: Q1 and Q2 are such that they both anticommute with Z. So that means Q1,Q2 ∈ {X, Y}.

S4 gives two possibilities: C: Q1 and Q2 are such that they both commute with X. So that means Q1,Q2 ∈ {I, X}. D: Q1 and Q2 are such that they both anticommute with X. So that means Q1,Q2 ∈ {Z, Y}.

So the conditions are that ( from S3 and S4 ) must be

User #3

The correct answer is: $ F_{\rm{physical}}=(1-\frac{12}{15}p)^2 $

Now let’s solve the next Checkpoint.

Checkpoint 2

Suppose that we wish to prepare a logical two-qubit GHZ state $(|00\rangle_{AB}+|11\rangle_{AB})/\sqrt{2}$ in the [[4,2,2]] code. To do so, we use the following state preparation circuit:

\[ (CNOT_{03}) (H_0) (CNOT_{21}) (H_2). \]

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

Assistant #4

Reasoning (model)

We are asked: “What is the logical state fidelity of the final 2-qubit logical state at the end of the circuit as a function of the two-qubit gate error rate p, assuming the state is post-selected on all detectable errors in the code?”

Interpretation: We have the same circuit as before. But now we post-select on detectable errors. The [[4,2,2]] code can detect any single-qubit error? Actually, it’s distance 2 so it can detect any single-qubit error? Actually, [[4,2,2]] code: parameters: n=4, k=2, d=2. So it can detect any single-qubit error? But careful: The stabilizers are XXXX and ZZZZ. So any single-qubit error will anti-commute with at least one stabilizer? Actually, check: A single-qubit X error on one qubit will anti-commute with ZZZZ? Actually, ZZZZ commutes with X? No, X and Z anticommute. So yes, it will be detected. So any single-qubit error is detectable. But wait: The errors here are two-qubit errors from CNOT gates. But they act on specific pairs: first error on qubits {2,1} and second on {0,3}. So these errors are Pauli errors on two qubits. They might be detectable or not. We want to post-select on all detectable errors. That means if an error occurs that is detectable, we discard the state. So only when the error is undetectable (i.e., in the normalizer of the stabilizer but not in the stabilizer itself? Actually, detectable means that it changes the syndrome. So errors that are in the stabilizer are not detected because they leave the state invariant. Also errors that are logical operators? Actually, careful: The code can detect any error that is not in the normalizer of the check set? Actually, for a stabilizer code, an error E is detectable if it anticommutes with at least one stabilizer. So if E commutes with all stabilizers, then it is either in the stabilizer or it is a logical operator. So undetectable errors are those that are in the normalizer of the stabilizer group. So if an error is in the normalizer but not in the stabilizer, it is a logical error. So then post-selection: We keep only those states that have no error syndrome. That means that the error must commute with all stabilizers. But wait: “post-selected on all detectable errors” means that if an error is detectable (syndrome non-zero), we discard. So we only keep states with syndrome 0. That means that the error must be in the normalizer of the stabilizer group. But careful: The normalizer of the stabilizer group includes both the stabilizer itself and the logical operators. So if an error is a logical operator, it will still give syndrome 0? Actually, check: For a stabilizer code, if an error is a logical operator, it commutes with all stabilizers because logical operators are in the normalizer. So indeed, logical errors are not detected. So post-selection only removes states with non-trivial syndrome. So then the fidelity after post-selection is the probability that the state is correct conditioned on syndrome being trivial. That is: F_logical = (Probability that error is in stabilizer) / (Probability that error is in normalizer). Because if error is in normalizer but not in stabilizer, then it is a logical error and fidelity becomes 0? Actually, careful: If the error is a logical operator, then it will change the state to a different logical state. So fidelity is 1 only if the error is in the stabilizer. So then the logical fidelity after post-selection is: F = P(error in stabilizer) / P(error in normalizer).

Now, from our previous analysis, the overall error is E = E4 * E2. And we want to know when does E commute with all stabilizers? That is the condition for being in the normalizer. And then among those, when is E actually in the stabilizer? So we need to compute the number of error patterns that are in the normalizer and those that are in the stabilizer.

Let’s determine the normalizer of the stabilizer group for the [[4,2,2]] code. The stabilizer is generated by S1=XXXX and S2=ZZZZ. So the normalizer consists of all Pauli operators that commute with XXXX and ZZZZ. What are conditions for a Pauli operator P = P0 P1 P2 P3 to commute with XXXX? That means that the number of positions where P_i anticommutes with X should be even. Similarly, commute with ZZZZ means that the number of positions where P_i anticommutes with Z should be even. So conditions: Let for each qubit, determine whether P_i commutes or anticommutes with X and Z. Actually, easier: The normalizer of the stabilizer for this code is known to be the entire Pauli group on 4 qubits? Actually, no: For a stabilizer code, the normalizer is larger than the stabilizer. In fact, for this code, the normalizer includes all Pauli operators that have an even number of X’s? Not sure.

Maybe we can compute it using the conditions from S3 and S4 that we had earlier? But careful: S3 and S4 are not stabilizers of the code; they are stabilizers of the specific state |ψ_ideal>. But here we are interested in the code itself. The code stabilizer is generated by XXXX and ZZZZ. So we want conditions for a Pauli E to commute with XXXX and ZZZZ. Let E = product over i of Pauli on qubit i. Commute with XXXX: This requires that the product of the signs from each qubit where E_i and X anticommute should be +1. That is: The number of qubits where E_i anticommutes with X must be even. Similarly, commute with ZZZZ: The number of qubits where E_i anticommutes with Z must be even. Now, note that our errors come as E = E4 ⊗ E2, where E4 acts on qubits 0 and 3, and E2 acts on qubits 1 and 2. So let’s denote: For E4 on qubits {0,3}: Let its Pauli strings be: On qubit0: something, on qubit3: something. For E2 on qubits {1,2}: similarly. Now, condition for commuting with XXXX: We need that the total number of qubits where the Pauli anticommutes with X is even. On qubit0: anticommutes with X if Pauli is Y or Z? Actually, check: X commutes with X and I? Actually, careful: The Pauli matrices: I and X commute with X. Y and Z anticommute with X because X Y = -Y X, X Z = -Z X. So for each qubit, if the Pauli is I or X, it commutes with X; if it is Y or Z, it anticommutes with X. Similarly, for commuting with Z: I and Z commute with Z; X and Y anticommute with Z. So conditions: For E to be in the normalizer (i.e., commute with XXXX and ZZZZ), we need: From XXXX: (number of qubits among {0,1,2,3} with Pauli in {Y,Z}) is even. From ZZZZ: (number of qubits among {0,1,2,3} with Pauli in {X,Y}) is even.

Now, since errors are independent on groups A and B, we can compute the probability that a given error on two qubits (say on group A) has a certain property regarding these counts. But careful: The errors are not independent across qubits? Actually, they are independent: E4 is chosen from the 16 Paulis on two qubits with probability: P(I)=1-p, and each non-identity gets p/15. And similarly for E2. So then the overall error E = E4 ⊗ E2 will be in the normalizer if and only if: Let for group A, define: a = number of qubits in {0,3} that are in {Y,Z} mod 2. So condition from XXXX: a + (for group B, number in {Y,Z}) must be even. And from ZZZZ: For group A, let b = number of qubits in {0,3} that are in {X,Y} mod 2. And for group B, similarly. So condition: b + (group B’s) must be even.

But maybe it’s easier to count the number of Pauli operators on two qubits that yield a given syndrome relative to XXXX and ZZZZ? Actually, wait: The normalizer condition is on the entire 4-qubit operator. But since the errors are independent on the two groups, we can compute the probability that an error on a given group is such that it has a certain pattern of commuting/anticommuting with X and Z on its two qubits. But careful: The conditions are not independent for the two groups because they involve parity across groups. So we want: P(Normalizer) = Sum_{E4,E2} P(E4)P(E2) * indicator that E4⊗E2 is in normalizer. And P(Stabilizer) = Sum_{E4,E2} P(E4)P(E2) * indicator that E4⊗E2 is in stabilizer.

Maybe we can compute these probabilities by noting that the depolarizing channel on two qubits induces a uniform distribution over the 15 non-identity errors. And the identity has probability 1-p. So for each two-qubit gate error channel, the outcome is a Pauli operator on that pair. And these outcomes are independent. So then the overall error is uniformly distributed over the 256 Pauli operators on 4 qubits? Not exactly uniform because identity has probability (1-p)^2, and each non-identity pattern has probability something. But wait: The errors on the two gates are independent. So the probability that the overall error is a specific Pauli operator E that factors as E4⊗E2 is: If E4 is identity, probability = (1-p); if E4 is non-identity, probability = p/15. Similarly for E2. So then the probability that the overall error is a particular Pauli operator that is product of two independent two-qubit Paulis is: If both are identity: (1-p)^2. If one is identity and the other is a specific non-identity: (1-p)*(p/15). If both are specific non-identity: (p/15)^2.

Now, we need to count how many of these Pauli operators are in the normalizer and how many are in the stabilizer. The stabilizer of the code is generated by XXXX and ZZZZ, so it has 4 elements? Actually, wait: The stabilizer group of the code is the set of operators that stabilize every state in the code. That group is generated by S1 and S2, so it has 4 elements: {I, XXXX, ZZZZ, XXXX ZZZZ = YYYY? Actually, check: XXXX * ZZZZ = - (XXXX)(ZZZZ) careful: XXXX ZZZZ = (XZ)(XZ)(XZ)(XZ) = (-iY)^4 = (-i)^4 YYYY = YYYY. So yes, the stabilizer group is {I, XXXX, ZZZZ, YYYY}. But wait, are these all? Actually, the stabilizer group should have size 2^(n-k) = 2^2 = 4. So yes, the stabilizer group is exactly these 4 operators. But careful: Our earlier stabilizer for the state |ψ_ideal> was larger because that state is a specific state within the code. But for the code itself, the stabilizer is only {I, XXXX, ZZZZ, XXXX ZZZZ}. So then, what are the conditions for an error E to be in the stabilizer of the code? That means that E must be one of these 4 operators. But wait, our errors are of the form E4⊗E2. Can that be one of these? For example, XXXX means that on group A, we need X on qubit0 and X on qubit3? Actually, XXXX = X0 X1 X2 X3. For this to factor as E4⊗E2 with E4 on {0,3} and E2 on {1,2}, we need E4 = X0X3 and E2 = X1X2. So that is included. Similarly, ZZZZ gives E4 = Z0Z3 and E2 = Z1Z2. And YYYY gives E4 = Y0Y3 and E2 = Y1Y2. And identity gives identity on both. So the stabilizer errors are exactly those where E4 and E2 are both either identity, or both are the Pauli that is the same on both qubits? Actually, careful: For XXXX, we need E4 = X⊗X and E2 = X⊗X. For ZZZZ, need E4 = Z⊗Z and E2 = Z⊗Z. For YYYY, need E4 = Y⊗Y and E2 = Y⊗Y. So that means that for the error to be in the stabilizer, we need that E4 and E2 are both identity, or both are the Pauli where the same Pauli appears on both qubits of that group? But wait, could there be a stabilizer element that is, say, XXXX itself? That requires that on each qubit, the Pauli is X. So yes. So then, the probability that the error is in the stabilizer is: P(stab) = P(E4=I and E2=I) + P(E4=X⊗X and E2=X⊗X) + P(E4=Z⊗Z and E2=Z⊗Z) + P(E4=Y⊗Y and E2=Y⊗Y). Now, what are these probabilities? P(E4=I) = 1-p. P(E4=X⊗X) = p/15 because there is exactly one error of type X⊗X among the 15. Similarly, P(E4=Z⊗Z)= p/15, and P(E4=Y⊗Y)= p/15. So then P(stab) = (1-p)^2 + 3*(p/15)^2 = (1-p)^2 + 3p^2/225 = (1-p)^2 + p^2/75. But wait, is that all? What about errors that are actually in the stabilizer but might come from different combinations? For example, could E4 be something like? No, because the stabilizer group only has these 4 elements. So that seems correct.

Now, what is the normalizer? The normalizer of the stabilizer group is the set of Pauli operators that commute with both XXXX and ZZZZ. Let’s determine that. Consider an arbitrary Pauli on 4 qubits: It is determined by Pauli on each qubit. It commutes with XXXX if the number of qubits where the Pauli is Y or Z is even. It commutes with ZZZZ if the number of qubits where the Pauli is X or Y is even. So let’s count the number of Pauli operators on 4 qubits that satisfy these conditions. But careful: Our errors are not uniformly distributed over all 4-qubit Paulis because they come from independent errors on two separate pairs. However, note that the errors on the two pairs are independent and the distribution on each pair is: identity with probability 1-p, and each of the 15 non-identity Paulis with probability p/15. So the overall distribution on the 4-qubit Pauli group is such that it factors as product of distributions on the two pairs. So we want to compute the probability that a given pair’s error (on 2 qubits) has a certain property relative to these parity conditions. But careful: The conditions for being in the normalizer involve both pairs together. Specifically, let for pair A (qubits 0 and 3), define two parity bits: α_A = (number of qubits in {0,3} with Pauli in {Y,Z}) mod 2. β_A = (number of qubits in {0,3} with Pauli in {X,Y}) mod 2. Similarly, for pair B (qubits 1 and 2), define α_B and β_B. Then the conditions for being in the normalizer are: α_A + α_B ≡ 0 mod 2, β_A + β_B ≡ 0 mod 2. So if we can compute the probability that a given pair’s error has a certain (α, β) value, then the probability that the overall error is in the normalizer is: P(norm) = Sum_{(α_A,β_A)} Sum_{(α_B,β_B) such that α_A+α_B=0, β_A+β_B=0} P_A(α_A,β_A) * P_B(α_B,β_B). And since the two pairs are independent and identically distributed, we can compute P_pair(α,β) for one pair.

Now, for a pair of qubits, the possible Pauli errors are the 16 operators. Let’s list them and determine their (α, β) values. Recall: For a single qubit, if Pauli is I or X, then it commutes with X? Actually, careful: α is defined as: for each qubit, if the Pauli is in {Y,Z}, then it contributes 1 mod 2 to α. So for a two-qubit operator, α is the parity of the number of qubits that are Y or Z. Similarly, β is the parity of the number of qubits that are X or Y. Let’s list all 16 operators on two qubits. Label the two qubits as 1 and 2 for ease. But careful: Our pairs are actually different: pair A is qubits 0 and 3, but that doesn’t matter. We want to compute for each Pauli operator on two qubits, what are (α, β)? The Pauli operators are of the form: σ_a ⊗ σ_b, where a,b ∈ {0,1,2,3} with 0=I, 1=X, 2=Y, 3=Z. For each, α = (indicator that σ_a is Y or Z) + (indicator that σ_b is Y or Z) mod 2. β = (indicator that σ_a is X or Y) + (indicator that σ_b is X or Y) mod 2. Let’s make a table:

I will list by the type of product:

I⊗I: (0,0) because both are I -> α=0, β=0.
I⊗X: first: I -> not Y,Z so 0; second: X -> not Y,Z so 0? Actually, careful: X is not in {Y,Z} so α=0. β: I -> not X,Y so 0; X -> is in {X,Y} so 1; so β=1 mod2? But wait, β is the sum mod2 of indicators. So for I⊗X, β = 0+1=1 mod2. So (α,β) = (0,1).
I⊗Y: α: I->0; Y->1 so α=1. β: I->0; Y->1 so β=1. So (1,1).
I⊗Z: α: I->0; Z->1 so α=1. β: I->0; Z->0 because Z is not in {X,Y} so β=0. So (1,0).
X⊗I: by symmetry, (0,1) because it’s like I⊗X.
X⊗X: both X: α: X not in {Y,Z} so 0+0=0. β: X is in {X,Y} so 1+1=2 mod2=0. So (0,0).
X⊗Y: α: X->0; Y->1 so α=1. β: X->1; Y->1 so β=0 mod2? Actually, 1+1=2 mod2=0. So (1,0).
X⊗Z: α: X->0; Z->1 so α=1. β: X->1; Z->0 so β=1 mod2? 1+0=1. So (1,1).
Y⊗I: (1,1) by symmetry with I⊗Y.
Y⊗X: (1,0) by symmetry with X⊗Y.
Y⊗Y: both Y: α: 1+1=2 mod2=0; β: 1+1=2 mod2=0. So (0,0).
Y⊗Z: α: Y->1; Z->1 so α=0 mod2? 1+1=2 mod2=0; β: Y->1; Z->0 so β=1. So (0,1).
Z⊗I: (1,0) by symmetry with I⊗Z.
Z⊗X: (1,1) by symmetry with X⊗Z.
Z⊗Y: (0,1) by symmetry with Y⊗Z.
Z⊗Z: both Z: α: 1+1=0 mod2; β: 0+0=0. So (0,0).

So summary for a two-qubit Pauli operator: (α,β) values: (0,0): Which operators give (0,0)? I⊗I, X⊗X, Y⊗Y, Z⊗Z. So there are 4 operators that give (0,0).

(0,1): I⊗X, X⊗I, Y⊗Z, Z⊗Y. So 4 operators give (0,1).

(1,0): I⊗Z, Z⊗I, X⊗Y, Y⊗X. So 4 operators give (1,0).

(1,1): I⊗Y, Y⊗I, X⊗Z, Z⊗X. So 4 operators give (1,1).

So indeed, out of 16, each combination appears exactly 4 times.

Now, what is the probability distribution for one pair’s error? For a given pair, the probability that the error is a specific Pauli operator is: P(identity) = 1-p. P(any specific non-identity) = p/15. So then, for a given pair, the probability that its (α,β) is (0,0) is: There are 4 operators that are (0,0). But careful: One of them is identity. So that probability is: P(identity) + 3(p/15) = (1-p) + 3p/15 = 1-p + p/5 = 1 - p + 0.2p = 1 - 0.8p? Actually, 3/15 = 1/5 = 0.2, so it is 1-p + 0.2p = 1 - 0.8p. Wait, check: For (0,0), the operators are: I⊗I, X⊗X, Y⊗Y, Z⊗Z. So probability = (1-p) + 3(p/15) = 1-p + p/5 = 1 - (4/5)p. For (0,1): There are 4 operators, none is identity? Actually, check: (0,1) operators: I⊗X, X⊗I, Y⊗Z, Z⊗Y. None of these is identity because identity requires both I. So probability = 4*(p/15) = 4p/15. Similarly, (1,0): probability = 4p/15. (1,1): probability = 4p/15.

So for one pair, let’s denote: P(0,0) = 1 - p + p/5 = 1 - (4/5)p. P(0,1) = 4p/15. P(1,0) = 4p/15. P(1,1) = 4p/15.

And note that these sum to: (1-p) + (3p/15) + (4p/15)*3 = 1-p + 3p/15 + 12p/15 = 1-p + 15p/15 = 1-p+p = 1. Good.

Now, the overall error E = E4 ⊗ E2 is in the normalizer if and only if: α_total = α_A + α_B ≡ 0 mod 2, and β_total = β_A + β_B ≡ 0 mod 2. Since these are independent across pairs, the probability that the overall error is in the normalizer is: P(norm) = Sum_{(a,b) for pair A} Sum_{(c,d) for pair B such that a+c=0 mod2, b+d=0 mod2} P_A(a,b) * P_B(c,d). Because the pairs are independent and identically distributed, this is: = [P(0,0)]^2 + [P(0,1)]^2 + [P(1,0)]^2 + [P(1,1)]^2? Wait, careful: We need both parities to be 0. So if pair A gives (0,0), then pair B must give (0,0) to have sum (0,0). If pair A gives (0,1), then pair B must give (0,1) because 0+0=0 and 1+1=0 mod2. If pair A gives (1,0), then pair B must give (1,0). If pair A gives (1,1), then pair B must give (1,1) because 1+1=0 mod2 and 1+1=0 mod2. So indeed, P(norm) = [P(0,0)]^2 + [P(0,1)]^2 + [P(1,0)]^2 + [P(1,1)]^2. = (1 - 4p/5)^2 + (4p/15)^2 + (4p/15)^2 + (4p/15)^2 = (1 - 4p/5)^2 + 3*(16p^2/225) = (1 - 4p/5)^2 + 48p^2/225 = 1 - (8/5)p + (16/25)p^2 + (48/225)p^2 Note that 48/225 = (48/225) and 16/25 = (144/225). So sum = 1 - (8/5)p + (144+48)/225 p^2 = 1 - (8/5)p + (192/225)p^2 = 1 - (8/5)p + (64/75)p^2? Because 192/225 simplifies to 64/75. So P(norm) = 1 - (8/5)p + (64/75)p^2.

Now, what is the probability that the error is in the stabilizer? As computed earlier, that requires that both pairs have errors that are in the set {I, X⊗X, Y⊗Y, Z⊗Z}? But careful: For the error to be in the stabilizer, we need that the overall Pauli is one of: I, XXXX, ZZZZ, YYYY. That means that on pair A, if it is identity, then pair B must be identity. If pair A is X⊗X, then pair B must be X⊗X. If pair A is Y⊗Y, then pair B must be Y⊗Y. If pair A is Z⊗Z, then pair B must be Z⊗Z. So P(stab) = [P(identity on both)] + [P(X⊗X on both)] + [P(Y⊗Y on both)] + [P(Z⊗Z on both)] = (1-p)^2 + 3(p/15)^2 = (1-p)^2 + 3p^2/225 = 1 - 2p + p^2 + p^2/75 = 1 - 2p + (76/75)p^2? Actually, 1 + 1/75 = 76/75, so = 1 - 2p + (76/75)p^2? But wait, check: p^2 + 3p^2/225 = p^2 + p^2/75 = (75/75)p^2 + (1/75)p^2 = (76/75)p^2. So P(stab) = 1 - 2p + (76/75)p^2. But wait, is that correct? Let’s also compute P(stab) from our (α,β) perspective: Being in the stabilizer means that the overall error is in the set that actually fixes the code space. But careful: The stabilizer group of the code is only these 4 operators. And these correspond to both pairs having (0,0) and additionally they must be the same specific type? Actually, note: (0,0) category includes 4 operators: identity, X⊗X, Y⊗Y, Z⊗Z. But if pair A is identity and pair B is X⊗X, then the overall error is X⊗X on pair B only? That would be I⊗I ⊗ X⊗X = XXXX? Actually, wait: If pair A is identity and pair B is X⊗X, then the overall operator is I0I3 ⊗ X1X2 = X1X2 on qubits 1 and 2 only. Is that in the stabilizer? The stabilizer is XXXX, which requires X on all qubits. So I0I3 ⊗ X1X2 is not equal to XXXX because on qubits 0 and 3 it is I, not X. So indeed, for the error to be in the stabilizer, it is not enough that both pairs are in the (0,0) category. They must be the same specific operator within that category. Because if pair A is identity and pair B is X⊗X, then the overall is not a stabilizer element because stabilizer elements are products that are the same on both pairs? Actually, check: The stabilizer elements are: I (which means identity on both), XXXX (which means X on all qubits), ZZZZ (Z on all), and YYYY (Y on all). So if pair A is identity and pair B is X⊗X, then the overall is not any of these because that would require that on pair A also is X⊗X to be XXXX. So indeed, P(stab) = probability that both pairs are identity + probability that both pairs are X⊗X + probability that both pairs are Y⊗Y + probability that both pairs are Z⊗Z. And that is: (1-p)^2 + 3(p/15)^2 = 1 - 2p + p^2 + 3p^2/225 = 1 - 2p + (225/225)p^2 + (3/225)p^2 = 1 - 2p + (228/225)p^2? Wait, careful: p^2 = (225/225)p^2, so plus 3/225 gives 228/225 = 76/75? Actually, 228/225 simplifies to 76/75 because 228/3=76, 225/3=75. So yes, P(stab) = 1 - 2p + (76/75)p^2.

But wait, does that match with our earlier computation from the state fidelity? That was different because that was for the physical state fidelity without post-selection. That was F_physical = (1 - 12/15 p)^2 = (1 - 4/5 p)^2 = 1 - 8/5 p + 16/25 p^2 = 1 - 1.6p + 0.64p^2. And here P(stab) is 1 - 2p + (76/75)p^2 which is 1 - 2p + 1.01333… p^2. So they are different, which makes sense because physical fidelity includes also errors that are not in the normalizer? Actually, physical fidelity is the probability that the state is correct. That requires that the error is in the stabilizer of the state |ψ_ideal>, which is a larger group than the code stabilizer. So that is fine.

Now, we want the logical fidelity after post-selection. That is: F_logical = P(stab | norm) = P(stab) / P(norm), because if the error is in the normalizer but not in the stabilizer, then it is a logical error and fidelity becomes 0. So F_logical = [1 - 2p + (76/75)p^2] / [1 - (8/5)p + (64/75)p^2].

We can simplify that expression: 1 - 2p = 1 - (10/5)p, so numerator = 1 - (10/5)p + (76/75)p^2. Denom = 1 - (8/5)p + (64/75)p^2. So F_logical = [1 - (10/5)p + (76/75)p^2] / [1 - (8/5)p + (64/75)p^2].

Multiply numerator and denominator by 75 to avoid fractions: = [75 - 75(10/5)p + 76 p^2] / [75 - 75(8/5)p + 64 p^2] = [75 - 150p + 76p^2] / [75 - 120p + 64p^2].

That doesn’t simplify nicely? Maybe it does: 75-150p+76p^2 and 75-120p+64p^2. They are not factorable easily. Wait, maybe I made a mistake? Because often these things become something like (1 - something p) maybe to first order. Let’s check first order: For small p, F_logical ≈ (1 - 2p) / (1 - 1.6p) ≈ 1 - 0.4p. So the logical infidelity is about 0.4p, which is lower than the physical infidelity which was 1.6p. That makes sense because post-selection removes many errors.

But wait, the problem might expect a simpler answer. Could it be that the logical fidelity is actually 1? Or maybe there is a nice cancellation? Maybe I should re-derive the conditions for being in the normalizer more carefully. The normalizer of the stabilizer group for the [[4,2,2]] code: The stabilizer is generated by S1=XXXX and S2=ZZZZ. An operator E is in the normalizer if it commutes with both. As derived, that means that the number of qubits where E has Y or Z is even, and the number where E has X or Y is even. Is that correct? Let’s check with an example: E = X⊗I⊗I⊗I. That acts only on qubit0. Then for XXXX, qubit0: X anticommutes with X? Actually, X commutes with X, so that’s fine. For ZZZZ, qubit0: X anticommutes with Z, so that gives a factor -1. So overall, would that commute? Check: (X⊗I⊗I⊗I)(ZZZZ) = X⊗I⊗I⊗I * Z⊗Z⊗Z⊗Z = (XZ)⊗Z⊗Z⊗Z = (-ZX)⊗Z⊗Z⊗Z = - Z⊗Z⊗Z⊗Z * (X⊗I⊗I⊗I) so they anticommute. So indeed, X⊗I⊗I⊗I is not in the normalizer. So that condition seems right. Now, consider an operator that is on two qubits from different pairs? But our errors are products of errors on pairs that are independent. So our counting using the (α,β) method seems correct.

Maybe there is another way: The probability that an error on a single two-qubit gate is undetectable (i.e., in the normalizer when combined with identity on the other pair) would be? But careful: The errors on the two gates are independent. So I think our approach is correct.

Wait, could it be that the logical fidelity after post-selection is actually 1? Because if we post-select on detectable errors, then we only keep states with no syndrome. Those states could still have logical errors. So the fidelity is not 1; it is the probability that given no syndrome, the state is correct. That is P(stab)/P(norm). So that is what we computed.

Let’s check with a specific error: Suppose on the first CNOT (on qubits 2,1) there is an error that is X⊗I (on qubits 2,1). That error, what is its effect? X⊗I on qubits 2,1 means that on qubit2, X error; on qubit1, identity. Would that be detectable? Let’s check its commutation with stabilizers: For S1=XXXX, on qubit2: X commutes with X? Actually, careful: S1=XXXX acts on all qubits. On qubit2, X error and X from S1 commute? Actually, they commute because both are X. On qubit1, identity commutes with X. So with S1, it commutes. With S2=ZZZZ, on qubit2: X anticommutes with Z, so that gives a factor -1; on qubit1: identity commutes with Z; so overall, it anticommutes with S2. So that error would be detected because it anticommutes with S2. So it would be discarded. So that seems right. Now, consider an error that is X⊗X on the first gate. That means on qubits 2,1, both get X. Then check with S1: X and X commute, so okay. With S2: X and Z anticommute on each qubit, so that gives (-1)*(-1)=+1. So that error is undetectable. And indeed, X⊗X on qubits 2,1 is actually a logical operator? What is the logical operator? X_B = XXII acts on qubits 0,1? Actually, careful: The logical operators are: X_A = XIXI, X_B=XXII. So X⊗X on qubits 2,1 would be? That would be I0, X1, X2, I3. That is not exactly a logical operator because logical operators act on qubits 0 and 1 typically? Actually, the logical operators are not unique. They can be multiplied by stabilizers. So I0,X1,X2,I3 multiplied by something might become a logical operator. So yes, that could be a logical error. So then after post-selection, such an error would remain and would reduce the fidelity. So our computed fidelity should be less than 1.

Now, our computed P(norm) is the probability that the overall error is in the normalizer. But wait: Is that the correct condition for having trivial syndrome? Yes, because syndrome is determined by measuring the stabilizers. If an error commutes with all stabilizers, then the syndrome will be trivial. So that is correct.

So then F_logical = P(stab) / P(norm) = [1 - 2p + (76/75)p^2] / [1 - (8/5)p + (64/75)p^2].

Maybe this simplifies? Write denominator as: 1 - 1.6p + (64/75)p^2. Numerator: 1 - 2p + (76/75)p^2. They don’t simplify to a nice factor like (1 - something p)^2? Maybe we only need the leading order term? Often these problems yield an answer like F_logical = 1 - (4/15)p? But that would be 1 - 0.2667p, but our first order is 1 - 0.4p. Wait, let’s compute the first order terms carefully: P(stab) = (1-p)^2 + 3(p/15)^2 = 1 - 2p + p^2 + 3p^2/225 = 1 - 2p + (225/225 + 3/225)p^2 = 1 - 2p + (228/225)p^2 = 1 - 2p + (76/75)p^2. P(norm) = [1 - (4/5)p]^2 + 3(4p/15)^2 = 1 - (8/5)p + (16/25)p^2 + 3*(16p^2/225) = 1 - (8/5)p + (16/25)p^2 + (48/225)p^2 = 1 - (8/5)p + (144/225 + 48/225)p^2 = 1 - (8/5)p + (192/225)p^2 = 1 - (8/5)p + (64/75)p^2. So for small p, F = (1 - 2p) / (1 - 1.6p) ≈ 1 - 0.4p. So the logical infidelity is about 0.4p to first order. But wait, could it be that the answer is simply F_logical = 1 - (4/5)p? That would be 1 - 0.8p, which is not right. Maybe the answer is expected to be in a nice form: F_logical = (1 - 2p + (76/75)p^2) / (1 - (8/5)p + (64/75)p^2). That is not very nice.

Perhaps I made a mistake: The logical fidelity after post-selection should be the probability that no logical error occurred given that no error was detected. That is equal to P(no error) / P(no detection). But careful: “No error” means that the state is correct. That happens if the overall error is in the stabilizer. But wait, is that true? If the error is in the stabilizer, then it leaves the state invariant. So yes. So then F_logical = P(stab) / P(norm). That is what we did.

Maybe there is a simpler way to compute these probabilities by noting that the errors on each gate are independent and that the condition for being in the normalizer is that the error on each gate must be such that it itself is in the normalizer of the stabilizer restricted to those qubits? But careful: The normalizer condition involves both gates together. However, because the errors are on disjoint sets, the condition factors into conditions on each gate if we also consider the phase conditions? Actually, note that the normalizer condition is on the entire Pauli. But if we have two independent errors on disjoint sets, then the overall error is in the normalizer if and only if the product of the signs from each gate relative to the stabilizers works out. But wait, consider an error on one gate alone. If only one gate has an error and the other is identity, then for the overall to be in the normalizer, that error must commute with the stabilizers. But what is the condition for a Pauli on two qubits (say on qubits 0 and 3) to commute with XXXX and ZZZZ? Let’s check: Take an error on qubits 0 and 3 only. So E = E4 ⊗ I2. For this to commute with XXXX, we need that on qubits 0 and 3, the number of places where the Pauli is in {Y,Z} is even? Because on qubits 1 and 2, identity commutes with X. So that condition is that on qubits 0 and 3, the parity of (indicator that Pauli is Y or Z) must be even. Similarly, for ZZZZ, on qubits 0 and3, the parity of (indicator that Pauli is X or Y) must be even. So that means that for an error on a single gate to be undetectable by itself, it must have (α,β) = (0,0) on that gate. And from our table, that happens for 4 operators out of 16. And the probability of that is: P(identity) + 3*(p/15) = 1-p + 3p/15 = 1-p + p/5 = 1 - (4/5)p. So if only one gate fails, the probability that it is undetectable is 1 - (4/5)p? But wait, that’s not a probability; that’s actually the probability that the error is in the set {I, X⊗X, Y⊗Y, Z⊗Z} on that gate. So that makes sense. Now, if both gates fail, then the overall error can be undetectable even if individually they are not undetectable, because they can cancel each other’s phase issues. For example, if gate1 gives an error with (α,β) = (0,1) and gate2 gives an error with (0,1), then overall becomes (0,0) because 0+0=0 and 1+1=0 mod2. So that is allowed. So indeed, our computed P(norm) is correct.

Maybe the answer is expected to be to first order in p. Often these problems give an answer like: F_logical = 1 - (4/5)p + … but that is for physical fidelity. For logical fidelity after post-selection, we got 1 - 0.4p. Wait, could it be that the logical fidelity is actually 1? Because if we post-select, we only keep states that have no detected error. Those states might still have logical errors. So fidelity is not 1.

I will check another approach: The overall error is E = E4 ⊗ E2. We want to know when does E commute with XXXX and ZZZZ. Let’s actually count the number of Pauli operators on 4 qubits that commute with XXXX and ZZZZ. The total number of Pauli operators on 4 qubits (ignoring phases) is 4^4 = 256. The condition for commuting with XXXX is that the number of qubits with Pauli in {Y,Z} is even. How many Pauli operators have that property? For each qubit, the Pauli can be I, X, Y, Z. The condition involves parity. It might be that exactly half of the 256 commute with XXXX? Actually, for each Pauli, if you flip all Paulis to their something… I recall that the normalizer of a stabilizer group has size 2^(n+k) = 2^(4+2)=2^6=64. So there should be 64 Pauli operators in the normalizer of the stabilizer group. Yes, because for a stabilizer code with parameters [[n,k,d]], the normalizer has size 2^(n+k). Here n=4, k=2, so normalizer size = 2^6=64. And the stabilizer itself has size 2^(n-k)=4. So that checks out. So out of 256 Pauli operators, 64 are in the normalizer. Now, our errors are distributed over these 256 outcomes? But careful: Our errors come from two independent distributions on two pairs. The total number of outcomes is 16*16=256. So that matches. So the probability that an error is in the normalizer is exactly (64/256) times the probability weight? But wait, is it uniform? Not exactly uniform because the identity has probability (1-p)^2, while each non-identity has probability (p/15)^2. But if it were uniform over the 256 outcomes with probability 1/256 each, then P(norm) would be 64/256 = 1/4. But here, due to the fact that identity has higher probability, P(norm) will be > 1/4 for small p. And our expression should become 1 when p=0, and when p=1, it becomes? If p=1, then each gate gives a non-identity uniformly among 15 options. Then P(norm) would be: number of outcomes in normalizer that are non-identity? Actually, if p=1, then identity probability is 0. Then each outcome has probability 1/225? Actually, careful: If p=1, then for each gate, the probability of any specific non-identity is 1/15. So overall, each non-identity outcome has probability 1/225. How many non-identity outcomes are in the normalizer? Total outcomes in normalizer is 64. But one of them is identity identity? Actually, identity identity is in normalizer. So there are 63 non-identity outcomes in the normalizer. So then P(norm) would be 63/225 = 0.28, which is not 1/4=0.25. So it’s not simply 64/256 because the distribution is not uniform over the 256 outcomes because identity has different probability. So our computed P(norm) is correct.

Maybe the answer is that the logical fidelity is 1 to first order in p? But our first order term: P(stab) = 1 - 2p + … and P(norm) = 1 - (8/5)p + … so their ratio is 1 - (2 - 8/5)p = 1 - (2/5)p = 1 - 0.4p. So there is a first-order term. So the logical infidelity is (2/5)p to first order. That seems plausible.

I will check with a specific case: Consider only errors on one gate. If only the first gate has an error ( probability p) and the second is identity ( probability 1-p). Then what is the probability that the error is undetectable? For the first gate, as computed, undetectable errors are those with (α,β)=(0,0). That probability is 1-p + 3(p/15) = 1-p + p/5 = 1 - (4/5)p. But wait, that is the probability that the error on that gate is in the set {I, X⊗X, Y⊗Y, Z⊗Z}. But if it is identity, then overall is identity, which is good. If it is X⊗X, then overall becomes X⊗X on that gate and identity on the other. Is that undetectable? Check: X⊗X on qubits 2,1 and identity on qubits 0,3 gives operator: I0, X1, X2, I3. Does that commute with XXXX? On qubits 1 and 2, X commutes with X; so okay. With ZZZZ: On qubits 1 and 2, X anticommutes with Z, so that gives (-1)(-1)=+1. So yes, it is undetectable. But wait, is it actually in the normalizer? It should be because the normalizer size is 64. So that seems correct. So then if only one gate fails, the probability of being in the normalizer is actually (1-p) + (3p/15) = 1 - (4/5)p. But then our computed P(norm) for both gates would be? When only one gate fails, that is included in our P(norm) calculation? But careful: Our P(norm) calculation earlier was for both gates together. That includes cases where one gate is identity and the other is something that makes the product undetectable. But wait, if one gate is identity and the other is something that is not in the (0,0) category, then the product might still be undetectable? For example, if gate1 gives identity and gate2 gives an error with (0,1), then overall would have (0,1) which is not (0,0) because for a single gate, being undetectable requires (0,0). So actually, if only one gate fails, the condition for undetectability is that the failing gate must itself be in the (0,0) category. So that probability is indeed 1 - (4/5)p for that gate. So then the total probability that only one gate fails and it is undetectable is: 2 * [ (1-p) (p) * ( probability that the error on the failing gate is in (0,0) given that it is non-identity? Actually, careful: The probability that only one gate fails is: 2 * (1-p)p. But wait, that’s not right because if only one gate fails, then the other is identity. And identity is in (0,0) always. So then the condition for the product to be in the normalizer is that the failing gate must be in (0,0) as well. So that probability is: for gate1 failing and gate2 identity: probability = (1-p) * [ probability that gate1 error is in (0,0) ] but careful: gate1 error probability: identity has probability 1-p, but that would be both identity, which is included in no error. So for exactly one gate failing, we want gate1 error is non-identity that is in (0,0) and gate2 is identity. That probability is: p * (3/15) * (1-p) = (3p/15)(1-p). And similarly for gate2 failing gives another (3p/15)(1-p). So total for one gate failing undetectable = 6p(1-p)/15 = (2p(1-p)/5). And then no error case: (1-p)^2. So that sum would be (1-p)^2 + (2p(1-p)/5 = (1-p)[1-p + 2p/5] = (1-p)[1 - (3/5)p] = 1 - p - (3/5)p + (3/5)p^2 = 1 - (8/5)p + (3/5)p^2. But wait, that is only up to first order: 1 - 1.6p. But our P(norm) from our earlier calculation had first order term 1 - (8/5)p as well. So that matches to first order? But then there are also terms from both gates failing that can cancel phases. Those would add terms of order p^2. So our P(norm) seems consistent.

Given that the likely expected answer is neat, I suspect that the logical fidelity might actually be simply 1. But wait, the problem says: “assuming the state is post-selected on all detectable errors”. That means we throw away any state that has a non-trivial syndrome. So then the only states that remain are those with errors in the normalizer. Among those, some are stabilizer errors (which leave the state correct) and some are logical errors (which change the logical state). So the fidelity is the fraction of those that are stabilizer errors. That fraction is not 1; it is P(stab)/P(norm). That is what we computed.

Maybe the answer is that to first order, the logical infidelity is (2/5)p. So then F_logical = 1 - (2/5)p + … But wait, could it be that the logical fidelity is actually independent of p? That would be surprising.

I will check another specific error: Consider an error on the first gate that is X⊗I (on qubits 2,1). That is detectable because it anticommutes with ZZZZ. So it would be discarded. Consider an error on the first gate that is X⊗X. That is undetectable. Is it a logical error? X⊗X on qubits 2,1 means that on qubits 1 and 2, we have X and X. That operator is actually? Can it be written as a logical operator? The logical operators are X_A = XIXI and X_B=XXII. This is not immediately either. But if we multiply X⊗X on qubits 2,1 by something? Actually, note that the stabilizer is XXXX. So if I take X⊗X on qubits 2,1 and multiply by X⊗X on qubits 0,3 (which is also a stabilizer), I get XXXX which is stabilizer. So actually, X⊗X on qubits 2,1 is not necessarily a logical operator by itself because it might be equivalent to a stabilizer if the other gate is identity? Wait, careful: The stabilizer group acts on the entire state. An error E is in the stabilizer if there exists an element S in the stabilizer such that E = S. For an error that only acts on qubits 2,1, could it be equal to a stabilizer? The stabilizers are XXXX, ZZZZ, and their product. XXXX would require that on qubits 0 and 3 also be X. So if the error is only on qubits 2,1 being X⊗X, then that is not equal to XXXX because on qubits 0 and 3 it would be identity, not X. So that error is not in the stabilizer. Could it be that it is a logical operator? Logical operators are those that commute with the stabilizer but are not in the stabilizer. So yes, X⊗X on qubits 2,1 likely is a logical operator. So that would reduce fidelity. So then indeed, after post-selection, there is a chance of logical error. So F_logical < 1.

Maybe the answer is that F_logical = 1 - (4/15)p? But that would be 1 - 0.2667p, which is not what I got.

Let’s compute P(norm) and P(stab) carefully using the fact that the outcomes on each gate are independent with distribution: P(I) = 1-p. P(specific non-identity) = p/15. For each gate, the probability that the error is in the set that makes it have (α,β) = (0,0) is: that set has 4 elements: {I, X⊗X, Y⊗Y, Z⊗Z}. So that probability is: (1-p) + 3(p/15) = 1-p + p/5 = 1 - (4/5)p. For (0,1): probability = 4(p/15) = 4p/15. (1,0): 4p/15. (1,1): 4p/15. Now, the overall error is in the normalizer if and only if the (α,β) values from the two gates are equal. So then P(norm) = [P(0,0)]^2 + [P(0,1)]^2 + [P(1,0)]^2 + [P(1,1)]^2 = (1 - 4p/5)^2 + 3(4p/15)^2 = (1 - 4p/5)^2 + 3(16p^2/225) = 1 - (8/5)p + (16/25)p^2 + (48/225)p^2 = 1 - (8/5)p + (144/225 + 48/225)p^2 = 1 - (8/5)p + (192/225)p^2 = 1 - (8/5)p + (64/75)p^2. That seems correct. Now, P(stab) is the probability that the overall error is actually in the stabilizer. The stabilizer consists of outcomes where both gates have the same specific operator from the set {I, X⊗X, Y⊗Y, Z⊗Z}. But careful: Is it enough that both are in that set? No, because if one gate is I and the other is X⊗X, then the overall is I⊗X⊗X which is not a stabilizer because stabilizer requires X on all qubits. So they must be the same. So that means: P(stab) = P(both are I) + P(both are X⊗X) + P(both are Y⊗Y) + P(both are Z⊗Z) = (1-p)^2 + 3*(p/15)^2 = (1-p)^2 + 3p^2/225 = 1 - 2p + p^2 + p^2/75 = 1 - 2p + (76/75)p^2. So that is correct. Then F_logical = [1 - 2p + (76/75)p^2] / [1 - (8/5)p + (64/75)p^2]. For small p, this is approximately (1 - 2p) / (1 - 1.6p) ≈ 1 - 0.4p. So the logical infidelity is about 0.4p. So I will state that to first order, F_logical ≈ 1 - (2/5)p. But the problem might want an exact expression. Maybe they expect the answer: F_logical = \frac{1 - 2p + \frac{76}{75}p^2}{1 - \frac{8}{5}p + \frac{64}{75}p^2}. That is not very nice.

Wait, could it be that I made a mistake? The physical fidelity from subproblem 1 was (1 - 4/5 p)^2. That is because that requires that the error is in the stabilizer of the state, which is larger than the code stabilizer. So that is different. For the logical fidelity after post-selection, we only keep states with no detected error. That means the error must be in the normalizer of the code. That normalizer has size 64. Among those 64, only 4 are in the stabilizer of the code? Actually, wait: The stabilizer of the code has size 4. So if errors were uniformly distributed among the 64 normalizer elements, then the fidelity would be 4/64 = 1/16? That is not right because when p=1, then outcomes are uniformly distributed among the 255 non-identity Paulis? Actually, when p=1, each gate gives a non-identity uniformly among 15 options. Then the overall distribution is uniform over the 225 outcomes that are not identity on both? But wait, there are 256 total outcomes. identity outcome has probability 0 when p=1. So then the probability of being in the normalizer would be (64-1)/225 = 63/225 = 0.28. And the probability of being in the stabilizer would be (4-1)/225 = 3/225 = 0.01333. So then fidelity would be 3/63 = 1/21 ≈ 0.0476. That seems very low. But wait, that is when p=1, meaning every gate certainly has an error. That could be possible. So that makes sense.

Given that these expressions are somewhat messy, maybe the expected answer is simply that the logical fidelity is 1 to first order in p? But that would require that the first-order term in P(norm) is also 1-2p, but it is 1-1.6p. So then the ratio is 1 - 0.4p. So there is a first-order term.

I will check with a very simple case: Suppose p is very small. Then the dominant errors are those where only one gate fails. The probability that only one gate fails is 2p. Out of these, the ones that are undetectable are those where the failing gate’s error is in the set {X⊗X, Y⊗Y, Z⊗Z} ( identity would be no error). That probability is 3/15 = 1/5. So probability of undetectable error from one gate failing is 2p(1/5)=2p/5. wait, careful: The probability that exactly one gate fails is: gate1 fails and gate2 is identity: probability = p(1-p) ≈ p, and gate2 fails and gate1 identity: another p, so total 2p. Among these, the chance that the error is undetectable is that it is in {X⊗X, Y⊗Y, Z⊗Z} which has probability 3/15=1/5. So that gives 2p/5. So then P(norm) ≈ (1-p)^2 + 2p/5 = 1 - 2p + p^2 + 0.4p = 1 - 1.6p + p^2. And P(stab) ≈ (1-p)^2 = 1-2p+p^2. So then fidelity ≈ (1-2p)/(1-1.6p) ≈ 1 - 0.4p. So that seems correct. Therefore, the logical fidelity is F_logical = 1 - (2/5)p + …

Maybe the answer is that F_logical = (1 - 4/5 p)^2 / (1 - 8/5 p + …)? That would be the physical fidelity squared over something? Actually, physical fidelity was (1-4/5p)^2. So that is 1 - 8/5p + … So then F_logical would be (1-2p)/(1-1.6p) which is not that.

I will check if there is a nice closed form. P(norm) = 1 - (8/5)p + (64/75)p^2. P(stab) = 1 - 2p + (76/75)p^2. So F = [1 - 2p + (76/75)p^2] / [1 - (8/5)p + (64/75)p^2]. Multiply numerator and denominator by 75: = [75 - 150p + 76p^2] / [75 - 120p + 64p^2]. That does not factor nicely. So likely the expected answer is just the first-order term: F_logical = 1 - (2/5)p + O(p^2). But wait, the physical fidelity was given as a function of p: F_physical = (1 - 12/15 p)^2 = (1 - 4/5 p)^2. So that is a neat expression. So maybe the logical fidelity also has a neat expression? (1 - 4/5 p)^2 = 1 - 8/5 p + 16/25 p^2 = 1 - 1.6p + 0.64p^2. Our P(norm) is 1 - 1.6p + (64/75)p^2 = 1 - 1.6p + 0.85333p^2. So that is different. What about (1 - 2/5 p)^2 = 1 - 4/5 p + 4/25 p^2 = 1 - 0.8p + 0.16p^2. Not that. Maybe it is (1 - 2/5 p) itself? That would be 1 - 0.4p, but we need 1 - 0.4p to first order actually. So F_logical to first order is 1 - (2/5)p. So maybe F_logical = 1 - (2/5)p? But then that would be linear, not quadratic. But wait, could it be that actually there are no second-order terms? If F_logical were exactly 1 - (2/5)p, then that would mean that P(stab) and P(norm) have the same second-order terms relative to the first-order terms. Let’s check: If F_logical = 1 - (2/5)p, then that would imply that P(stab) = P(norm) * (1 - 2/5 p). But P(norm) = 1 - (8/5)p + … and times (1 - 2/5)p gives 1 - (8/5+2/5)p + … = 1 - 2p + … which matches the first order. For second order, we would need that the second order term of P(norm) times (1 - 2/5)p gives: (64/75)p^2 from P(norm) times 1 gives 64/75, plus times -2/5)p times first order of P(norm) which is -2/5 * (-8/5) = +16/25 = 48/75, so total would be (64/75+48/75)=112/75 p^2, but P(stab) has 76/75 p^2. So they are not equal. So it’s not exactly linear.

Given that the physical fidelity was asked for in subproblem 1 and that came out neatly as (1 - 12/15 p)^2 = (1 - 4/5 p)^2, I would expect the logical fidelity to also be something neat. wait, 12/15 simplifies to 4/5. So physical fidelity = (1 - 4/5 p)^2. maybe logical fidelity = (1 - 4/15 p)^2? That would be 1 - 8/15 p + … which is 1 - 0.5333p, not 1 - 0.4p. Or maybe logical fidelity = 1 - (4/5)p^2? That seems unlikely.

I will check online memory: There is a known result that for the [[4,2,2]] code, the logical error rate under depolarizing noise becomes something like. Actually, wait, the [[4,2,2]] code is detection only. So when you post-select, you only keep states with no error detected. The probability of no error detected is P(norm). And the probability that the state is correct is P(stab). So the fidelity is that ratio. That ratio might not simplify to a nice power of something.

Maybe the answer is simply that to first order, the logical infidelity is (2/5)p. So then F_logical = 1 - (2/5)p. I’ll check with a specific value: p=0.1. Then physical fidelity = (0.92)^2 = 0.8464. Logical fidelity would be about 1 - 0.04 = 0.96. That seems reasonable because post-selection removes many errors. If p=0.1, then the chance of an error on one gate is 0.1, and among those, only 1/5 are undetectable, so that is 0.02 per gate, so total undetectable errors from single-gate failures is 0.04, so then P(norm) ≈ 1 - 0.04 = 0.96, and P(stab) ≈ 1 - 0.2 = 0.8? Wait, careful: For small p, P(stab) = (1-p)^2 = 0.81 actually when p=0.1, (0.9)^2=0.81. And P(norm) = 1 - (8/5)p = 1 - 0.16 = 0.84. Then fidelity = 0.81/0.84 = 0.9643. That matches with 1 - 0.0357p actually would be 1 - 0.357p, not 0.4p. because 0.0357/0.1=0.357. So actually, when p=0.1, fidelity = 0.81/0.84 = 0.9642857, so the infidelity is 0.0357143, which is 0.357143p. That is not 0.4p. Let’s do first-order terms carefully: P(stab) = 1 - 2p + O(p^2) P(norm) = 1 - (8/5)p + O(p^2) = 1 - 1.6p + O(p^2) So for small p, fidelity = (1-2p)/(1-1.6p) ≈ 1 -2p +2p 1.6p? Actually, use expansion: 1/(1-1.6p) ≈ 1+1.6p. So product = (1-2p)(1+1.6p)= 1 -2p+1.6p -3.2p^2 = 1 -0.4p -3.2p^2. So to first order, fidelity = 1 - 0.4p. So when p=0.1, that gives 0.96. And 0.96 is actually 1 - 0.04, so that would be 0.4p would give 0.04 when p=0.1. So that is consistent: first order term is 0.4p, not 0.4 itself. I earlier did 0.81/0.84 = 0.9642857, which is 1 - 0.0357143, and 0.0357143/0.1 = 0.357143, not 0.4. There’s a discrepancy. Let’s calculate numerically carefully: P(stab) = 1 - 2p + (76/75)p^2. For p=0.1, that is 1 - 0.2 + (76/75)0.01 = 0.8 + (1.01333)0.01 = 0.8 + 0.0101333 = 0.8101333. P(norm) = 1 - (8/5)p + (64/75)p^2 = 1 - 1.60.1 + (64/75)0.01 = 1 - 0.16 + (0.85333)0.01 = 0.84 + 0.0085333 = 0.8485333. Then fidelity = 0.8101333/0.8485333 = 0.9547 approximately. Let’s do that division: 0.8101333/0.8485333 = ? 0.8485333 * 0.955 = 0.810, yes about 0.955. So that gives infidelity of 0.0453 when p=0.1. That would correspond to a first-order term of 0.453p, not 0.4p. I need to recompute these carefully.

I will recompute P(norm) and P(stab) from scratch with care.

We have two independent errors: one on gate involving qubits {2,1} and one on gate involving qubits {0,3}. For each gate, the error is a Pauli on 2 qubits. There are 16 possible outcomes. Their probabilities: P(I) = 1-p. For each of the 15 non-identity Paulis, probability = p/15.

Now, let’s determine for a single gate, what is the probability that its error has a given effect on the syndrome? But careful: The syndrome is determined by the stabilizers of the code, which are XXXX and ZZZZ. But wait, these stabilizers act on all 4 qubits. However, since the errors on different gates are independent, we want to know conditions on each gate’s error such that when combined with the other gate’s error, the overall commutes with XXXX and ZZZZ. But that condition factors into conditions on the two gates because they act on disjoint sets. Actually, it does factor in the following way: Consider an error on gate affecting qubits {2,1}. Let that error be E2. Consider also an error on gate affecting qubits {0,3}, call it E4. The overall error is E4 ⊗ E2. Now, this overall error commutes with XXXX if and only if the product of the signs from each qubit works out. But since these errors act on disjoint sets, this condition actually becomes: ( commute with XXXX ) is equivalent to: (E4 commutes with X⊗X on its own qubits? Not exactly because XXXX = (X on qubit0)(X on qubit3) times (X on qubit1)(X on qubit2). So actually, note that XXXX factors as (X0X3) ⊗ (X1X2). So then [E4⊗E2, XXXX] = 0 if and similarly for ZZZZ. So actually, wait: XXXX commutes with E4⊗E2 if and only if E4 commutes with X0X3 and E2 commutes with X1X2? Is that true? Check: If E4 commutes with X0X3 and E2 commutes with X1X2, then clearly they commute. What if they anticommute separately? Then overall, would they commute? If E4 anticommutes with X0X3, then E4 X0X3 = - X0X3 E4. If E2 anticommutes with X1X2, then E2 X1X2 = - X1X2 E2. Then overall, (E4⊗E2)(XXXX) = (E4 X0X3)⊗(E2 X1X2) = (-X0X3E4)⊗(-X1X2E2) = (X0X3E4)⊗(X1X2E2) = XXXX (E4⊗E2). So actually, wait: They would still commute if both anticommute because the two minus signs multiply to give +1. So the condition for commuting with XXXX is that E4 and E2 either both commute with their respective X⊗X operators or both anticommute with them. Similarly, for ZZZZ, since ZZZZ factors as (Z0Z3)⊗(Z1Z2), the condition is that E4 and E2 either both commute with Z0Z3 and Z1Z2 respectively, or both anticommute with them. Now, what does it mean for a two-qubit Pauli to commute or anticommute with X⊗X? Let’s determine that. For a two-qubit Pauli E on qubits say {0,3}. Write E = σ_a ⊗ σ_b. Then commute with X0X3 means that σ_a and X commute? Actually, careful: X0X3 means Pauli X on qubit0 and Pauli X on qubit3. So [E, X0X3] = 0 if and only if σ_a commutes with X and σ_b commutes with X, or both anticommute? Because if σ_a anticommutes with X, then that gives a minus sign, and if σ_b anticommutes with X, that gives another minus sign, product plus. So actually, E commutes with X0X3 if and only if the number of qubits where σ is in {Y,Z} is even? Because recall: X commutes with I and X, and anticommutes with Y and Z. So that is exactly our α earlier. So yes, E commutes with X0X3 if and0 only if α=0 mod2, and anticommutes if α=1 mod2. So then the condition for overall commute with XXXX is that α_A and α_B are both 0 or both 1. That is what we had: α_A + α_B = 0 mod2. Similarly, for ZZZZ, commute with Z0Z3 happens if and only if the number of qubits where the Pauli is in {X,Y} is even? Because Z commutes with I and Z, anticommutes with X and Y. So that is β. So condition: β_A + β_B = 0 mod2. So that is consistent.

Now, let’s compute for a single gate, the probability that it has a given commutation behavior with X⊗X and Z⊗Z. But careful: This commutation is determined by whether it commutes or anticommutes. So let’s define for a single gate error E (on two qubits), let c_X be +1 if it commutes with X⊗X, and -1 if it anticommutes. Then c_X = (-1)^(α). So actually, α=0 means commute, α=1 means anticommute. Similarly, c_Z = (-1)^(β). Now, from our table earlier, we found that out of the 16 operators, there are 4 that have (α,β)=(0,0) -> these commute with both X⊗X and Z⊗Z. 4 that have (0,1) -> commute with X⊗X but anticommute with Z⊗Z. 4 that have (1,0) -> anticommute with X⊗X but commute with Z⊗Z. 4 that have (1,1) -> anticommute with both. So that is clear.

Now, the overall error is in the normalizer if and only if both gates have the same commutation behavior with respect to X⊗X and Z⊗Z. Because then α_A+α_B=0 mod2 and β_A+β_B=0 mod2. So then P(norm) = [P(gate gives commute, commute)]^2 + [P(gate gives commute, anticommute)]^2 + [P(gate gives anticommute, commute)]^2 + [P(gate gives anticommute, anticommute)]^2. Now, what is P(gate gives commute, commute)? That means the error is in the set where it commutes with both X⊗X and Z⊗Z. That set is {I, X⊗X, Y⊗Y, Z⊗Z}. Its probability is: P(I) + 3(p/15) = (1-p) + 3p/15 = 1-p + p/5 = 1 - (4/5)p. Wait, careful: That is the probability that the gate’s error commutes with both? But that would be if the gate’s error is in that set. But is that correct? Check: I definitely commutes. X⊗X: commutes with X⊗X? Yes. Y⊗Y: commutes with X⊗X? Actually, Y anticommutes with X normally? But wait, careful: For two qubits, take Y⊗Y. Then commute with X⊗X: On each qubit, Y anticommutes with X, so that gives (-1)(-1)=+1. So yes, Y⊗Y commutes with X⊗X. And with Z⊗Z, similarly. So yes. So P(commute, commute) = 1 - p + 3p/15 = 1 - p + p/5 = 1 - (4/5)p. Next, P(commute, anticommute) means that the gate’s error commutes with X⊗X but anticommutes with Z⊗Z. That set is {I⊗X, X⊗I, Y⊗Z, Z⊗Y} from our table. None of these is identity. So that probability is 4(p/15) = 4p/15. Similarly, P(anticommute, commute) = 4p/15. P(anticommute, anticommute) = 4p/15. So then indeed, P(norm) = [1 - (4/5)p]^2 + (4p/15)^2 + (4p/15)^2 + (4p/15)^2 = [1 - (4/5)p]^2 + 3(16p^2/225) = 1 - (8/5)p + (16/25)p^2 + (48/225)p^2 = 1 - (8/5)p + (144/225 + 48/225)p^2 = 1 - (8/5)p + (192/225)p^2 = 1 - (8/5)p + (64/75)p^2. So that is correct.

Now, P(stab) is the probability that the overall error is actually in the stabilizer of the code. The stabilizer of the code is {I, XXXX, ZZZZ, XXXX ZZZZ}. But careful: These stabilizers act on both gates. For the overall error to be in the stabilizer, it must be that the error on each gate is the same specific type from the set {I, X⊗X, Y⊗Y, Z⊗Z}? Because if both gates are I, that’s identity. If both gates are X⊗X, then overall is XXXX. If both are Y⊗Y, then overall is YYYY. If both are Z⊗Z, then overall is ZZZZ. So yes. So P(stab) = P(both are I) + P(both are X⊗X) + P(both are Y⊗Y) + P(both are Z⊗Z) = (1-p)^2 + 3*(p/15)^2 = (1-p)^2 + 3p^2/225 = 1 - 2p + p^2 + p^2/75 = 1 - 2p + (76/75)p^2. So that is correct.

Now, let’s compute these for p=0.1 exactly: P(stab) = (0.9)^2 + 3(0.1/15)^2 wait careful: (p/15) when p=0.1 is 0.1/15 = 0.00666667. Squared is 0.00004444. Times 3 = 0.00013333. So P(stab) = 0.81 + 0.00013333 = 0.81013333. P(norm) = [1 - (4/5)0.1]^2 + 3(40.1/15)^2 = [1 - 0.08]^2 + 3(0.4/15)^2? Let’s do carefully: 1 - (4/5)p = 1 - 0.08 = 0.92. Squared = 0.8464. Next, (4p/15) = 40.1/15 = 0.4/15 = 0.02666667. Squared = 0.00071111. Times 3 = 0.00213333. So P(norm) = 0.8464 + 0.00213333 = 0.84853333. Then fidelity = 0.81013333 / 0.84853333 = 0.9547 approximately. So the infidelity is 0.0453. That means that to first order, the infidelity is 0.0453 when p=0.1, so that would be 0.453p, not 0.4p. Let’s get the first-order term properly by expanding: P(stab) = 1 - 2p + (76/75)p^2 P(norm) = 1 - (8/5)p + (64/75)p^2 = 1 - 1.6p + (64/75)p^2. Now, for small p, fidelity = (1-2p)/(1-1.6p) = 1 -2p times (1+1.6p) = 1 -2p +1.6p -3.2p^2 = 1 -0.4p -3.2p^2. So that suggests that the first-order term is 0.4p. But then at p=0.1, that would give fidelity = 1 - 0.04 = 0.96, not 0.9547. The difference comes from the second-order terms. Let’s do series expansion more carefully: F = [1 - 2p + A p^2] / [1 - 1.6p + B p^2], where A = 76/75 = 1.01333…, B = 64/75 = 0.85333… Then F = (1 - 2p + A p^2) * (1 + 1.6p + (1.6^2 - B)p^2) because 1/(1-1.6p+Bp^2) = 1 + 1.6p + (2.56 - B)p^2 + … So that is = 1 + 1.6p + (2.56-B)p^2 times (1-2p+Ap^2) = 1 + (1.6-2)p + [ (2.56-B) + A -2*1.6]p^2 = 1 -0.4p + [2.56 - B + A -3.2]p^2 = 1 -0.4p + [A - B -0.64]p^2. Now A - B = (76-64)/75 = 12/75 = 0.16. So then A - B - 0.64 = 0.16 - 0.64 = -0.48. So fidelity = 1 - 0.4p - 0.48p^2. So when p=0.1, that gives 1 - 0.04 - 0.0048 = 0.9552, which matches our computed 0.9552 approximately. So the first-order term is indeed 0.4p. So logical infidelity to first order is 0.4p. That means that F_logical ≈ 1 - (2/5)p.

So I will state that the logical fidelity is given by F_logical = [1 - 2p + (76/75)p^2] / [1 - (8/5)p + (64/75)p^2]. But that is not very pretty. Maybe it simplifies if I multiply numerator and denominator by 75: F_logical = (75 - 150p + 76p^2) / (75 - 120p + 64p^2). That doesn’t factor nicely.

Given that the physical fidelity was asked for in subproblem 1 and that came out as a perfect square, I suspect that the logical fidelity might also be a perfect square. What would it take for it to be a perfect square? If F_logical = (1 - something p)^2, then that something would be determined by the first-order term: something would be 0.2 because (1-0.2p)^2 = 1 -0.4p +0.04p^2. But we have second-order term -0.48p^2, so that’s not it. If it were (1 - (2/5)p) itself without squaring, that would be 1 -0.4p exactly, but then there would be no second-order term. So that’s not it either.

Given that the problem likely expects a neat answer, I will check the physical fidelity result from subproblem 1. That was: F_physical = (1 - 12/15 p)^2 = (1 - 4/5 p)^2. So that is neat. So maybe the logical fidelity is also neat: could it be that F_logical = 1 - (4/5)p? But that would be 1 - 0.8p, which is not right. wait, maybe I made a mistake in the physical fidelity? Subproblem 1: “What is the physical state fidelity of the final physical 4-qubit state at the end of the circuit as a function of the two-qubit gate error rate p?” That would be the probability that no error occurred that changes the state. But wait, that is different from being in the stabilizer of the code. Because the state prepared is not any code state; it is a specific state within the code. Its stabilizer is larger than the code stabilizer. So that makes sense that it is higher fidelity. So that is fine.

I will check online memory: There is a known result that for the [[4,2,2]] code, the logical error rate under depolarizing noise is actually that. I might that the answer is simply that the logical fidelity after post-selection is 1 - (2/5)p to first order. But wait, that would be linear, but we have a quadratic term too.

Maybe the intended answer is just the leading order: F_logical = 1 - (2/5)p + O(p^2).

I’ll check the problem statement: “What is the logical state fidelity of the final 2-qubit logical state at the end of the circuit as a function of the two-qubit gate error rate p, assuming the state is post-selected on all detectable errors in the code?” So they might want an expression in terms of p.

Given that the physical fidelity came out as a perfect square, I will check if maybe the logical fidelity also becomes a perfect square if we also consider that the state is post-selected. What is the probability of post-selection? That is P(norm). So then the fidelity conditioned on post-selection is P(stab)/P(norm). Is it possible that simplifies to (1 - something p)^2? Let’s see if we can write both numerator and denominator as squares. P(stab) = (1-p)^2 + 3(p/15)^2. That is not a perfect square in general. P(norm) = (1-p + p/5)^2 + 3(4p/15)^2? because (1-p+p/5) = 1 -4p/5, so that squared is (1-4p/5)^2. And (4p/15)^2 times 3 is 48p^2/225 which is not that. So no.

Given that the physical fidelity was very neat, I will trust that result and assume that the logical fidelity might also be neat. wait, could it be that I made a mistake in that physical fidelity? For physical fidelity, we need that the error is in the stabilizer of the state |ψ_ideal>. That stabilizer has 16 elements. So then the probability that the error is in that stabilizer would be something like? But wait, earlier I argued that the overall error acts as E4E2 on the state. And that will leave the state invariant if and only if E4E2 is in the stabilizer of |ψ_ideal>. And that stabilizer has 16 elements. So then physical fidelity = probability that E4E2 is in that set. And that probability would be computed by knowing how many of the 256 outcomes are in that set. That number is 16. So if outcomes were uniform, physical fidelity would be 16/256 = 1/16. But wait, that’s when p=1. But when p is small, identity has higher weight. So physical fidelity = (1-p)^2 + (15/256? No, careful: The stabilizer of |ψ_ideal> is not the same as the code’s normalizer. It is a subgroup of the Pauli group of size 16. So then physical fidelity = probability that the error is in that subgroup. That probability is: P(I) + for each of the 15 non-identity elements in that subgroup, probability = (p/15)^2 because they require that both gates have specific errors that multiply to that element. So then physical fidelity = (1-p)^2 + 15*(p/15)^2 = (1-p)^2 + p^2/15 = 1 - 2p + p^2 + p^2/15 = 1 - 2p + (16/15)p^2. That is not (1-4/5p)^2 because (1-4/5p)^2 = 1 - 8/5p + 16/25p^2 = 1 - 1.6p + 0.64p^2. So that is different. So clearly, I recall that the physical fidelity from subproblem 1 was given as (1 - 12/15 p)^2. So that suggests that maybe the errors act differently because they are applied after each CNOT gate independently. wait, did I earlier determine that the overall effect is simply E4E2? That seems right. So then the probability that no error occurs is (1-p)^2. The probability that an error occurs that still leaves the state invariant would be when both gates have errors that are such that their product is in the stabilizer of the state. But careful: The errors on different gates are independent. So if gate1 has an error E2 and gate2 has an error E4, the overall is E4E2. For this to be in the stabilizer of the state, it is not enough that both are in some set independently because they could cancel each other. So that physical fidelity would be more complicated. So likely the intended result for physical fidelity is correct as (1 - 12/15 p)^2. So I will trust that.

Given that, I will state that the logical fidelity is likely meant to be that after post-selection, only errors that are in the normalizer remain. And then the fidelity is the probability that the error is actually in the stabilizer of the code ( not of the state). That is what I computed. So I’ll go with that.

I’ll check with an easier thing: The code can detect any error that anticommutes with either stabilizer. So errors that are detected are those that are not in the normalizer. So then the success probability of post-selection is P(norm). And then the fidelity conditioned on success is P(stab)/P(norm). So that is it.

I will leave it as that. So my final answer for subproblem 2 is: F_logical = [1 - 2p + (76/75)p^2] / [1 - (8/5)p + (64/75)p^2].

But that is not very nice. wait, maybe it simplifies if I write everything with denominator 75: F_logical = (75 - 150p + 76p^2) / (75 - 120p + 64p^2). That doesn’t factor.

Maybe the intended answer is just the first-order term: F_logical = 1 - (2/5)p + O(p^2).

Given that the physical fidelity was given as a function of p without approximation, I expect the logical fidelity also to be given as a function of p. wait, could it be that I made a mistake in physical fidelity? Let’s re-derive physical fidelity quickly for subproblem 1 because that might be easier. Physical fidelity: F_physical = average |<ψ|E4E2|ψ>|^2 over errors. And since |ψ> is a stabilizer state for its own stabilizer group ( which has 16 elements), this fidelity will be 1 if E4E2 is in that group, and 0 otherwise. So then F_physical = probability that E4E2 is in that group. Now, what is that group? It is the stabilizer of |ψ>. earlier I determined that stabilizer for |ψ> requires that on group A, the allowed operators are actually different? because for |ψ>, conditions came from also IZZI and IXXI. Those conditions actually force that on group B, the error must be identity? because that would force Q1=I and Q2=I from earlier when I did the commutation with IZZI and IXXI. That was for the code stabilizer? wait, that was for the code stabilizer. For the state |ψ>, the stabilizer is larger. So that is different. I will not re-derive physical fidelity here because that is subproblem 1 and likely correct.

Given that the first subproblem gave a very neat answer, I suspect that the second might also give a neat answer. So I will try to see if there is a chance that the logical fidelity simplifies to something like (1 - 4/5p) maybe? If that were the case, then P(norm) would have to be such that P(stab) = (1-4/5p) P(norm). For small p, that would require 1-2p = (1-4/5p)(1-8/5p) which is 1 -2p would require? No.

Maybe the intended answer is simply that the logical fidelity is 1 because any error that is not detected actually leaves the logical state unchanged? Is that possible? That would be the case if the code could correct errors. But this code only detects errors. So errors that are not detected could be logical errors. So that is not true.

I will check online memory: The [[4,2,2]] code is also known as the detection code. When you post-select, you only keep states with no error detected. That means that any error that is correctable would actually be detected because the code distance is 2. Actually, wait, distance 2 means it can detect any single error. So single errors are detected. So the only undetectable errors are those that involve two errors that cancel each other’s syndrome. Those could be logical errors. So indeed, the fidelity after post-selection is less than 1.

I will go with my derived expression. So I’ll state that F_logical = \frac{1 - 2p + \frac{76}{75}p^2}{1 - \frac{8}{5}p + \frac{64}{75}p^2}.

But that is not very pretty. Maybe it simplifies if I factor something? 75 - 150p + 76p^2 and 75 - 120p + 64p^2. The roots of the denominator? Discriminant: 120^2 - 47564 =14400 - 19200 = -4800, so no. I might that the intended answer is simply to first order: F_logical = 1 - \frac{2}{5}p + O(p^2).

Given that the first subproblem’s answer was given as something like (1 - 12/15 p)^2, that is also first order 1 - 24/15 p = 1 - 8/5 p. So physical infidelity is 8/5 p = 1.6p, while logical infidelity is 2/5 p = 0.4p. So that is a factor of 4 improvement. That seems plausible.

I will check with a very simple case: If only one gate fails with probability p, then physical fidelity would be affected by that gate’s error if it is not in the state’s stabilizer. The state’s stabilizer for that gate would require that the error on that gate alone must be identity to keep the state correct? Actually, if only one gate fails, then the overall error is that gate’s error times identity on the other. For that to be in the state’s stabilizer, that gate’s error must be identity because any non-identity on one gate would likely change the state because the state’s stabilizer requires correlated errors across gates? I recall that for the state |ψ>, its stabilizer includes operators that act on both gates. So if only one gate fails, then the error cannot be in the stabilizer because that would require that the other gate also has that error to cancel out? So physical fidelity would be (1-p)^2 only, so that is 1-2p to first order. But wait, that would be 1-2p, not 1-1.6p. So that suggests that physical fidelity might actually be 1-2p to first order. But wait, could there be errors on both gates that cancel out? For example, if gate1 has an error E and gate2 has an error that makes the product still in the stabilizer. That would add terms of order p^2. So physical fidelity = (1-p)^2 + O(p^2) would be 1-2p+… So that would give infidelity 2p to first order. But subproblem 1 gave (1-12/15 p)^2 = 1 - 24/15 p + … = 1 - 1.6p + … So there is a discrepancy. I need to re-derive physical fidelity carefully because that might be where I go wrong.

Let’s derive physical fidelity for subproblem 1 properly. We have two CNOT gates. Each followed by a depolarizing channel on two qubits with error probability p. So overall, the state is affected by errors E2 and E4 independently. And we determined that the final state is actually E4E2 |ψ⟩ where |ψ⟩ is the ideal state. So the fidelity is F = average |⟨ψ|E4E2|ψ⟩|^2. Now, |ψ⟩ is a stabilizer state. So this fidelity is 1 if E4E2 is in the stabilizer of |ψ⟩, and 0 otherwise. So we need to know the stabilizer of |ψ⟩. |ψ⟩ is the state prepared by the circuit. I determined that state explicitly: |ψ⟩ = 1/2(|0000⟩+|1001⟩+|0110⟩+|1111⟩). What is its stabilizer? I found earlier that its stabilizer generators are: XXXX, ZZZZ, IZZI, IXXI. So the stabilizer group has 16 elements. So physical fidelity = probability that E4E2 is in that group of 16 Pauli operators. Now, these 16 operators are determined by conditions on E4 and E2. Let’s determine that. For an operator to be in the stabilizer of |ψ⟩, it must commute with all these generators. I already computed conditions for commuting with IZZI and IXXI forced that on group B (qubits 1 and2), we need that Q1 and Q2 are both I? because that gave that Q1 must commute with both Z and X, so Q1=I, and similarly Q2=I. Is that correct? I did that earlier and got that for commuting with IZZI and IXXI, we need that Q1 and Q2 are I. But wait, that was for the code stabilizer? because the code stabilizer is only XXXX and ZZZZ. For the state |ψ⟩, we have additional stabilizers IZZI and IXXI. So that means that actually, for an operator to stabilize |ψ⟩, it must also commute with IZZI and IXXI. Let’s check that. Take an operator that is XXXX itself. Does it commute with IZZI? XXXX and IZZI: On qubits 1 and2, X anticommutes with Z? Actually, careful: IZZI acts on qubits 1 and2 with Z. XXXX acts on qubits 1 and2 with X. So they anticommute because on each qubit, X and Z anticommute, so product gives (-1)(-1)=+1 actually. So XXXX does commute with IZZI. What about IXXI? IXXI acts with X on qubits 1 and2. XXXX has X on qubits 1 and2, so that commutes. So XXXX is in the stabilizer of |ψ⟩. So that means that for an operator to be in the stabilizer of |ψ⟩, it is not necessary that Q1 and Q2 are I. My earlier determination that Q1 must be I came from that fact that I thought they must commute with both Z and X individually, but actually they can anticommute on both qubits and still commute overall. So let’s determine the conditions for an operator E = E4 ⊗ E2 to be in the stabilizer of |ψ⟩. The stabilizer of |ψ⟩ is generated by S1=XXXX, S2=ZZZZ, S3=IZZI, S4=IXXI. For E to be in the stabilizer, it must commute with these. But wait, actually, for E to be in the stabilizer means that E itself is one of these stabilizer elements. So E must be able to be written as product of these generators. So what are the stabilizer elements? They are of the form S1^a S2^b S3^c S4^d. I computed that earlier for the state |ψ⟩. That gave that on group A, the outcome is determined by (a,b) and on group B by (a+d, b+c). So that means that for E to be in the stabilizer, it must that E4 is one of {I, X0X3, Z0Z3, -Y0Y3} and E2 is one of {I, X1X2, Z1Z2, -Y1Y2} such that they come from the same combination? Actually, careful: If I take a=1,b=0,c=0,d=0, then S1 gives X0X3 ⊗ X1X2. So that means that if E4 = X0X3 and E2 = X1X2, then E is in the stabilizer. If I take a=0,b=1,c=0,d=0, then S2 gives Z0Z3 ⊗ Z1Z2. So that requires E4=Z0Z3 and E2=Z1Z2. If I take a=1,b=1,c=0,d=0, then S1S2 gives? That gives on group A: from S1S2, we got -Y0Y3, and on group B: from S1S2, we got -Y1Y2. So that means if E4 = -Y0Y3 and E2 = -Y1Y2, then that is in the stabilizer. But wait, are -Y0Y3 and -Y1Y2 actually possible as errors? Our errors are from the set of Pauli operators without phases. So -Y0Y3 is not the same as Y0Y3. So that means that for the state |ψ⟩, the stabilizer includes operators that have a minus sign. So then physical fidelity would require that errors actually be these specific operators with the right phase. But wait, our errors are applied as Pauli operators. They are defined without phases. So if an error happens that is Y0Y3 (without the minus), would that leave |ψ⟩ invariant? Let’s check: Consider an error that is Y0Y3 on group A and identity on group B. So that is Y0Y3 alone. Does that stabilize |ψ⟩? |ψ⟩ = 1/2(|0000⟩+|1001⟩+|0110⟩+|1111⟩). Apply Y0Y3. Y|0⟩ = i|1⟩, Y|1⟩ = -i|0⟩. So Y0Y3|0000⟩ = Y0|0⟩ Y3|0⟩ = (i|1⟩)(i|1⟩) = -|11⟩ on qubits 0 and3, so that gives |1100⟩? Actually, careful: |0000⟩ means qubit0=0,3=0. Y0 gives i|1⟩, Y3 gives i|1⟩, so product state becomes (i)(i)|1\rangle|1\rangle = -|11⟩ on qubits 0 and3, so overall state becomes -|1100⟩. That is not in the superposition because |ψ⟩ has |0000⟩ and |1001⟩ etc. So likely Y0Y3 does not stabilize |ψ⟩. What about -Y0Y3? If we apply -Y0Y3, then on |0000⟩, we get - (Y0Y3)|0000⟩ = -(-|1100⟩) actually careful: Y0Y3|0000⟩ = -|1100⟩ as computed, so -Y0Y3|0000⟩ = |1100⟩. That is still not in the state because state has |0000⟩, not |1100⟩. So wait, I need to determine the stabilizer of |ψ⟩ properly. Let’s determine the stabilizer of |ψ⟩ by actually checking which Pauli operators leave |ψ⟩ invariant. take Pauli operator XXXX. Does it leave |ψ⟩ invariant? Yes, because it swaps |0000⟩ with |1111⟩ and |1001⟩ with|0110⟩. So that works. take ZZZZ. That gives phase +1 on each term because even number of 1’s? Actually, |0000⟩ gets +1, |1001⟩ gets? Z on qubit0 gives -1, on qubit1 gives +1, on qubit2 gives +1, on qubit3 gives -1, product +1. So yes. take IZZI. That acts on qubits 1 and2. On |0000⟩, gives +1. On |1001⟩, gives? qubit1:0->+1, qubit2:0->+1, so +1. On |0110⟩, qubit1:1-> -1, qubit2:1-> -1, product +1. On |1111⟩, product +1. So IZZI works. take IXXI. On |0000⟩, IXXI gives |0110⟩ actually because it flips qubits1 and2. So that would map |0000⟩ to |0110⟩. But |0110⟩ is in the state. But does it leave the state invariant? IXXI will permute the terms. So yes, it is a stabilizer because the state is symmetric under that permutation. So these four generate the stabilizer. So the stabilizer elements are products of these. So then what is conditions for a Pauli operator to be in the stabilizer? It must be that it can be written as product of these generators. that means that on group A, the operator can be either I, X0X3, Z0Z3, or something else. Let’s compute S1S2 = XXXX ZZZZ = (XZ)(XZ)(XZ)(XZ) = (-iY)^4 = Y^4 since (-i)^4=1 actually careful: (-i)^4 = (-i)^2^2 = (-1)^2=1. So S1S2 = Y0Y1Y2Y3. So that means that YYYY is in the stabilizer. So that requires that on group A, we need Y0Y3 and on group B, Y1Y2. So that means that if E4 = Y0Y3 and E2 = Y1Y2, then that is in the stabilizer. So wait, then both Y0Y3 and -Y0Y3 are not in the stabilizer because stabilizer has Y0Y3 itself ( since S1S2 gives that). So then the stabilizer of |ψ⟩ actually includes operators that are exactly Y0Y3 on group A and Y1Y2 on group B. So then for physical fidelity, the condition is that E4 and E2 must be such that their product is in the set {I, XXXX, ZZZZ, YYYY} actually wait, that’s only 4 elements. But the stabilizer of |ψ⟩ should have 16 elements because it’s a stabilizer state on 4 qubits. So there are more. For example, S1S3 = XXXX * IZZI = X0 X1X2X3 * I0Z1Z2I3 = X0) wait, careful: S1S3 would act as follows: On qubit0: X, on qubit1: XZ = -iY, on qubit2: X*Z = -iY, on qubit3: X. So that is not simply factorable into separate groups because it entangles both groups. So physical fidelity is more complicated because errors on different gates are independent. So likely the physical fidelity result given in subproblem 1 is correct as (1-12/15p)^2. So I will trust that.

Given that, I will state that for subproblem 2, the logical fidelity is that conditioned on post-selection. And that is what I computed based on the code’s stabilizer ( not the state’s stabilizer). So that seems right.

I will go with that. So final answer for subproblem 2 is: F_logical = \frac{1 - 2p + \frac{76}{75}p^2}{1 - \frac{8}{5}p + \frac{64}{75}p^2}.

But that is not very pretty. wait, maybe it simplifies if I write it as: F_logical = \frac{75 - 150p + 76p^2}{75 - 120p + 64p^2}. I can also write it as F_logical = 1 - \frac{30p - 12p^2}{75 - 120p + 64p^2}? That doesn’t help.

Given that these problems often have nice answers, I will check online memory: sometimes the result is that the logical error rate is about (4/5)p for physical and (2/5)p for logical after post-selection. So I will state that to first order, F_logical = 1 - \frac{2}{5}p. So I’ll answer that.

I’ll check with p=0.1 gives 0.96, which is close to our computed 0.9552 actually. The first-order term would be 0.04 infidelity, but our computed infidelity is 0.0452, so that’s close enough for small p.

I will answer: F_logical = 1 - \frac{2}{5}p + O(p^2).

But wait, that is only first order. The physical fidelity was given as an exact square though. So maybe they want the exact expression.

I’ll decide to give the exact expression as well. F_logical = \frac{(1-p)^2 + 3\left(\frac{p}{15}\right)^2}{(1-p+\frac{p}{5})^2 + 3\left(\frac{4p}{15}\right)^2} because that is another way to write it? Because P(stab) = (1-p)^2 + 3(p/15)^2 and P(norm) = (1-p+p/5)^2 + 3(4p/15)^2? Check: 1-p+p/5 = 1-4p/5, so that squared is (1-4p/5)^2. And (4p/15)^2 times 3 = 48p^2/225 = 16p^2/75, wait that gives 64/75? No, careful: (4p/15)^2 = 16p^2/225, times 3 = 48p^2/225 = 16p^2/75 actually because 48/225 simplifies to 16/75. So that would give P(norm) = (1-4p/5)^2 + 16p^2/75. But we need 64/75 p^2. So that’s not it.

I think I’ll stick with the expressions I derived.

Given the complexity, I will state the answer for subproblem 2 as follows:

F_logical = 1 - \frac{2}{5}p + O(p^2).

But wait, that is not that’s called function of p. They ask for “as a function of the two-qubit gate error rate p”. So they want an expression in terms of p.

I will check the physical fidelity from subproblem 1 because that might be easier to derive. For physical fidelity, since errors act as E4E2 on the state, and since that state is stabilized by its own stabilizer which has 16 elements, physical fidelity = probability that E4E2 is in that stabilizer. now, outcomes for E4 and E2 are independent with distribution: P(I)=1-p, P(specific non-id)=p/15. So physical fidelity = sum_{S in stabilizer} P(E4E2 = S). now, note that these stabilizer elements involve both gates. They are not products of independent conditions on each gate because the stabilizer group of |ψ⟩ is not factorable into separate groups? Actually, wait, |ψ⟩ is prepared by that circuit. Is it factorable? |ψ⟩ = 1/2(|0000⟩+|1001⟩+|0110⟩+|1111⟩). This state is actually not factorable between the two pairs because it has entanglement between them. So its stabilizer will include operators that act on both pairs together. So then physical fidelity would be something like: outcomes where both gates are identity give identity. outcomes where one gate is identity and the other is something will not be in the stabilizer because any non-identity on one gate alone will not be in the stabilizer because that would require that acting on one pair alone would leave the state invariant, but since the state is entangled, that’s not possible. So then physical fidelity = (1-p)^2 + terms where both gates have errors that cancel out to give a stabilizer element. Those terms will be of order p^2. So then physical fidelity = 1 - 2p + O(p^2). That would mean physical infidelity is 2p to first order. But subproblem 1 gave (1-12/15p)^2 = 1 - 24/15p + … = 1 - 1.6p + … So that is different. So clearly, I need to determine physical fidelity properly.

Maybe I should not second-guess subproblem 1 since it was given that the answer is (1-12/15p)^2. So I’ll trust that.

Given that, I will state that for subproblem 2, the logical fidelity is likely meant to be that when you post-select, you only keep states with no detected error. That means that the error must commute with XXXX and ZZZZ. That is what I computed. So I’ll go with that.

I will answer: F_logical = \frac{1 - 2p + \frac{76}{75}p^2}{1 - \frac{8}{5}p + \frac{64}{75}p^2}.

I’ll simplify that expression by multiplying numerator and denominator by 75: F_logical = \frac{75 - 150p + 76p^2}{75 - 120p + 64p^2}.

That is my final answer for subproblem 2.

I’ll put that in a box.

So for subproblem 2, final answer is: \boxed{\frac{75 - 150p + 76p^2}{75 - 120p + 64p^2}}.

That is not very nice though.

Maybe it simplifies by dividing numerator and denominator by? 75 and 76 and 64 have no common factors.

I’ll check if it can be factored as (5-6p)(15-20p+ something) no.

I’ll leave it as that.

Thus I’ll answer subproblem 2 as that.

✅ Step 1: Circuit and Error Model

We aim to prepare the logical two-qubit GHZ state:

\[ |\psi_{\text{ideal}}\rangle = \frac{|00\rangle_{AB} + |11\rangle_{AB}}{\sqrt{2}} \]

using the physical circuit:

\[ \text{CNOT}_{03} \cdot H_0 \cdot \text{CNOT}_{21} \cdot H_2 \]

Each CNOT gate is followed by a two-qubit depolarizing error channel. The error acts as one of the 15 non-identity two-qubit Pauli operators with probability $ \frac{p}{15} $, and with probability $ 1 - p $, no error occurs. The Hadamard gates are assumed to be perfect.

The overall effect of errors is that the final state becomes:

\[ |\psi_{\text{actual}}\rangle = E_4 \cdot E_2 |\psi_{\text{ideal}}\rangle \]

where $ E_2 $ and $ E_4 $ are Pauli errors on qubit pairs $\{2,1\}$ and $\{0,3\}$, respectively.

✅ Step 2: Post-Selection and Logical Fidelity

The [[4,2,2]] code has stabilizers:

\[ S_1 = XXXX, \quad S_2 = ZZZZ \]

An error is detectable if it anticommutes with at least one stabilizer. We post-select by keeping only states with trivial syndrome, i.e., errors that commute with both stabilizers. These errors form the normalizer of the stabilizer group.

The logical fidelity is the probability that the state is correct given that no error was detected:

\[ F_{\text{logical}} = \frac{\mathbb{P}(\text{error is in stabilizer})}{\mathbb{P}(\text{error is in normalizer})} \]

The stabilizer group of the code has 4 elements:

\[ \{I, XXXX, ZZZZ, XXXX \cdot ZZZZ = YYYY\} \]

These correspond to the following error patterns on the two-qubit pairs:

Both pairs have identity: $ I \otimes I $
Both pairs have $ X \otimes X $: gives $ XXXX $
Both pairs have $ Z \otimes Z $: gives $ ZZZZ $
Both pairs have $ Y \otimes Y $: gives $ YYYY $

✅ Step 3: Probability Calculations

Let $ E_2 $ and $ E_4 $ be independent errors on their respective qubit pairs. Each has probability distribution:

$ \mathbb{P}(I) = 1 - p $
$ \mathbb{P}(\text{any specific non-identity}) = \frac{p}{15} $

(a) Probability that Error is in Stabilizer

\[ \mathbb{P}(\text{stab}) = (1 - p)^2 + 3\left(\frac{p}{15}\right)^2 = 1 - 2p + \frac{76}{75}p^2 \]

(b) Probability that Error is in Normalizer

Let $ \alpha $ be the number of qubits where the Pauli is in $\{Y, Z\}$, and $ \beta $ the number where it is in $\{X, Y\}$. The normalizer condition requires that $ \alpha $ and $ \beta $ have even parity across both pairs.

For a single two-qubit pair, the probabilities are:

$ \mathbb{P}((0,0)) = 1 - \frac{4}{5}p $
$ \mathbb{P}((0,1)) = \mathbb{P}((1,0)) = \mathbb{P}((1,1)) = \frac{4p}{15} $

The overall probability that the error is in the normalizer is:

\[ \mathbb{P}(\text{norm}) = \left(1 - \frac{4}{5}p\right)^2 + 3\left(\frac{4p}{15}\right)^2 = 1 - \frac{8}{5}p + \frac{64}{75}p^2 \]

✅ Step 4: Logical Fidelity

\[ F_{\text{logical}} = \frac{\mathbb{P}(\text{stab})}{\mathbb{P}(\text{norm})} = \frac{1 - 2p + \frac{76}{75}p^2}{1 - \frac{8}{5}p + \frac{64}{75}p^2} \]

Multiplying numerator and denominator by 75:

\[ F_{\text{logical}} = \frac{75 - 150p + 76p^2}{75 - 120p + 64p^2} \]

For small $ p $, this simplifies to:

\[ F_{\text{logical}} \approx 1 - \frac{2}{5}p \]

📦 Final Answer

\[ \boxed{\frac{75 - 150p + 76p^2}{75 - 120p + 64p^2}} \]

User #5

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 logical state fidelity of the final 2-qubit logical state
    at the end of the circuit as a function of the two-qubit gate error rate $p$ in Sympy format.

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

    Outputs
    ----------
    F_logical: sympy.Expr, the logical state fidelity as a function of $p$
    """

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

    return F_logical

Assistant #6

Reasoning (model)

We are given that the logical fidelity is: F_logical = (75 - 150p + 76p^2) / (75 - 120p + 64p^2)

We can simplify this expression by factoring out common factors? But note: the problem says to return the expression in Sympy format.

Let’s write it as: numerator = 75 - 150p + 76p2 denominator = 75 - 120p + 64p2

However, we can also leave it in the form that might be simplified by Sympy if needed.

But note: the problem does not require simplification beyond what is given.

We’ll return the expression as is.

However, note that the expression can be written in a factored form? Let’s check: numerator: 75 - 150p + 76p^2 denominator: 75 - 120p + 64p^2

We can also write it as: F_logical = (76p2 - 150p + 75) / (64p2 - 120p + 75)

But the problem expects the expression as derived.

Let’s code it accordingly.

Final Answer:

import sympy as sp

p = sp.symbols('p')

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

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

    Outputs
    ----------
    F_logical: sympy.Expr, the logical state fidelity as a function of $p$
    """

    # ------------------ FILL IN YOUR RESULTS BELOW ------------------
    numerator = 75 - 150*p + 76*p**2
    denominator = 75 - 120*p + 64*p**2
    F_logical = numerator / denominator
    # ---------------------------------------------------------------

    return F_logical