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 is an error detection code. It can detect any single-qubit error? Actually, [[4,2,2]] code has distance 2, so it can detect any single-qubit error? Actually, distance 2 means it can detect any error on one qubit? 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 qubit 0: It will anti-commute with ZZZZ? Actually, ZZZZ and X on qubit0: They anti-commute? 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 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 by the code, we discard the state. So we only keep states that have no error or errors that are not detectable? Actually “post-selected on all detectable errors” means that we measure the stabilizers and if we get a non-trivial syndrome, we discard the state. So we only keep states that are in the code space? But careful: The code space is stabilized by XXXX and ZZZZ. So if the state is in the code space, then the syndrome is trivial. But wait: There might be errors that are not detectable? The code has distance 2, so it can detect any error of weight 1. But errors of weight 2 might be undetectable if they are logical operators? Actually, for a stabilizer code, an error is detectable if it does not commute with at least one stabilizer. So an error is undetectable if it commutes with all stabilizers. That means it is in the normalizer of the stabilizer group. That includes the stabilizer itself and the logical operators. So errors that are in the stabilizer group are not detected because they leave the state in the code space. And errors that are logical operators (but not stabilizers) will take the state to a different logical state, but they commute with the stabilizers? Actually, logical operators commute with the stabilizers by definition. So they are undetectable. So post-selection: We measure the stabilizers. If we get any non-trivial syndrome, we discard. So we only keep states that are in the code space. But wait: There is also the possibility that an error occurs that is exactly a stabilizer? That would not change the state, so it’s fine. But if an error is a logical operator (non-identity logical operator), then the state might be changed but still be in the code space? Actually, if an error is a logical operator, it will map the code space to itself. But it will change the logical state. So such errors are not detected by the stabilizer measurements because they commute with the stabilizers. So post-selection only discards states that are outside the code space. So then the logical fidelity after post-selection is: Given that we only keep states that are in the code space, what is the fidelity of the logical state? That is: Conditional on the state being in the code space, what is the probability that it is the correct logical state?
So we need to compute: Probability that the state is the ideal state given that it is in the code space. That is: F_logical = P(no error or error in stabilizer) / P(state in code space). But careful: Errors that are logical operators will put the state in the code space but change the logical state. So they reduce fidelity.
So we need to analyze the errors from the two CNOT gates. As before, the overall effect is that the final state is (F E) |ψ_ideal>, where F acts on qubits 0,3 and E acts on qubits 2,1. And we want to know when does (F E) leave the state in the code space? That is when (F E) commutes with the stabilizers? Actually, the state is in the code space if and only if it is stabilized by XXXX and ZZZZ. But if an error occurs that is not in the normalizer of the stabilizer group, then the state will be outside the code space. So post-selection means we only keep states for which (F E) is in the normalizer of the stabilizer group. The normalizer of the stabilizer group for the [[4,2,2]] code is the set of Pauli operators that commute with XXXX and ZZZZ. What are those? They are Pauli operators that have an even number of X’s and Z’s? Actually, check: A Pauli operator will commute with XXXX if it has an even number of Pauli’s that anticommute with X? Actually, more systematically: The stabilizer group is generated by S1=XXXX and S2=ZZZZ. A Pauli operator P will commute with S1 if the number of qubits where P has either Y or Z? Actually, easier: The normalizer of the stabilizer group is the set of Pauli operators that can be written as products of the stabilizers and the logical operators. The logical operators are: X_A = XIXI, X_B=XXII, Z_A=ZZII, Z_B=ZIZI. So the normalizer group (ignoring phases) has size? The stabilizer group has 4 elements? Actually, the stabilizer group has 4 generators? Wait, the stabilizer group for [[4,2,2]] is actually of order 4? Actually, the code has 4 physical qubits, 2 stabilizers, so the stabilizer group has 2^2=4 elements? But careful: The stabilizer group is {I, XXXX, ZZZZ, XXXX ZZZZ} but note that XXXX and ZZZZ commute? They do commute because the number of places where they are both non-identity is 4, which is even. So the stabilizer group is of order 4. Then the logical operators: There are 4 logical Paulis? Actually, for 2 logical qubits, the logical Pauli group has 16 elements. So the normalizer of the stabilizer group in the Pauli group (mod phases) will have size 4 * 16 = 64. But we are interested in which errors (F E) will keep the state in the code space. That is exactly those errors that are in the normalizer of the stabilizer group. But wait: Is that correct? If an error E is in the normalizer, then E|ψ> is still in the code space because the stabilizers will act on it as something? Actually, if E is in the normalizer, then for any stabilizer S, S E|ψ> = E S’|ψ> = E|ψ> if S’=±S? Actually, careful: If E is in the normalizer, then for each stabilizer S, there is a sign such that E S = ± S E. But if |ψ> is in the code space, then S|ψ>=|ψ>. So then S (E|ψ>) = ± E S|ψ> = ± E|ψ>. So for E|ψ> to be in the code space, we need that the sign is +1 for all stabilizers. So actually, the condition for E to map the code space to itself is that E commutes with all stabilizers. So we need E to be in the centralizer of the stabilizer group. The centralizer is the set of Paulis that commute with every element of the stabilizer group. That is actually the normalizer since the stabilizer group is abelian. So yes, errors that are in the normalizer will map the code space to itself. So post-selection: We measure the stabilizers. If the state is not in the code space, we discard. So we only keep states for which (F E) is in the normalizer of the stabilizer group. That is, (F E) must commute with XXXX and ZZZZ.
Now, what are the conditions for a Pauli operator P on 4 qubits to commute with XXXX? XXXX is the product of X on all qubits. A Pauli operator will commute with XXXX if and only if it has an even number of Pauli matrices that anticommute with X. Which Paulis anticommute with X? Z and Y anticommute with X, while I and X commute with X. So the condition is that the number of qubits where P is either Z or Y must be even. Similarly, to commute with ZZZZ, the number of qubits where P is either X or Y must be even (since X and Y anticommute with Z). So for P to be in the normalizer, it must have an even number of Z/Y and an even number of X/Y across the 4 qubits.
But we also have the structure: P = F E, where F acts on qubits 0 and 3, and E acts on qubits 2 and 1. So we can analyze separately.
Let’s denote:
F is a Pauli on qubits 0 and 3. Write F = F_0 ⊗ F_3.
E is a Pauli on qubits 2 and 1. Write E = E_2 ⊗ E_1.
Then P = F_0 ⊗ E_1 ⊗ E_2 ⊗ F_3.
We want P to commute with XXXX. That means that the number of qubits among {0,1,2,3} where the Pauli is Z or Y must be even.
Similarly, for ZZZZ: number of qubits where the Pauli is X or Y must be even.
Now, after post-selection, we only keep states where P is in the normalizer. Among these, some will leave the logical state unchanged (if P is in the stabilizer group itself) and some will change the logical state (if P is a logical operator that is not in the stabilizer).
We want the logical fidelity. That is the probability that the logical state is correct given that the state is in the code space. That is:
F_logical = (Probability that P is in the stabilizer) / (Probability that P is in the normalizer).
But careful: Could there be cases where P is not in the normalizer but still the state is in the code space? Actually, if P is not in the normalizer, then the state will be outside the code space because the stabilizers will detect it. So post-selection discards those. So indeed, we only consider P in the normalizer.
So we need to compute:
P(normalizer) = probability that (F E) is in the normalizer.
P(stabilizer) = probability that (F E) is in the stabilizer group (which is a subgroup of the normalizer).
Then fidelity = P(stabilizer) / P(normalizer).
But wait: Is that correct? If P is in the normalizer but not in the stabilizer, then it will act as a logical operator on the code space. But could it act as identity on the logical state? Possibly if it is a logical operator that is actually the identity on the logical qubits? But the logical operators are defined modulo stabilizers. So if P is in the normalizer, then its action on the logical state is given by its equivalence class in the normalizer modulo the stabilizer. So we want that the logical action is identity. That means that P is in the stabilizer group. So yes, fidelity = probability that P is in the stabilizer given that it is in the normalizer.
So we need to compute these probabilities as functions of p.
As before, F and E are independent. Each comes from a depolarizing channel on two qubits:
With probability 1-p, it is identity (I⊗I).
With probability p, it is one of the 15 non-identity Paulis, each with probability p/15.
So we need to count: For a two-qubit Pauli on a specific pair (say qubits 0 and 3 for F), how many of these 16 operators are in the normalizer condition? But careful: The normalizer condition is on the full 4-qubit operator P = F E. But since F and E act on disjoint sets, the condition decouples? Actually, the conditions for P to be in the normalizer are:
(1) The number of qubits among {0,1,2,3} with Pauli being Z or Y is even.
(2) The number of qubits with Pauli being X or Y is even.
Now, F acts on qubits 0 and 3. E acts on qubits 1 and 2 (but careful: E acts on qubits 2 and 1, but order: qubits: 0,1,2,3. So E gives operators on qubit 2 and qubit 1. So it’s fine.)
So let’s denote:
For F on qubits 0 and 3, let’s determine the conditions that F must satisfy such that there exists an E that makes P in the normalizer? But wait, F and E are independent. We want to compute the probability that P is in the normalizer. That is: Sum over F and E that satisfy the conditions: (even number of Z/Y overall) and (even number of X/Y overall).
Because F and E are independent, we can compute the probability for a given F that it allows E to be such that the total is even? Actually, careful: The conditions are on the combined operator. So we can compute:
P(normalizer) = Sum_{F} Prob(F) * (Sum_{E such that (F,E) satisfies conditions} Prob(E) ).
And similarly, P(stabilizer) = Sum_{F} Prob(F) * (Sum_{E such that (F,E) is in stabilizer} Prob(E) ).
But maybe we can compute these totals by symmetry. Alternatively, we can count the number of pairs (F,E) that yield P in the normalizer and those that yield P in the stabilizer.
As before, the map (F,E) -> P is a bijection from the set of pairs to the set of 4-qubit Paulis (16*16=256). So the number of pairs that yield a given Pauli P is exactly 1. So then:
Number of pairs that yield P in the normalizer = number of Paulis in the normalizer.
Number of pairs that yield P in the stabilizer = number of Paulis in the stabilizer.
We already know the stabilizer group has size 4? Wait, careful: The stabilizer group of the code is generated by XXXX and ZZZZ. That group has order 4? Actually, the stabilizer group is {I, XXXX, ZZZZ, XXXX ZZZZ}. But wait, is that all? What about products like XXXX * something? Actually, the stabilizer group is the set of operators that leave every state in the code space invariant. For a stabilizer code, the stabilizer group is abelian and does not include logical operators. For the [[4,2,2]] code, the stabilizers are indeed XXXX and ZZZZ. But then the group they generate is of order 4 because XXXX and ZZZZ commute and are independent? But then what about the operators we earlier considered like Z1Z2 and X1X2? Those are logical operators? Actually, check: Z1Z2. Does it commute with XXXX? Yes. Does it commute with ZZZZ? Yes. So Z1Z2 is in the normalizer. But is it in the stabilizer? That would require that Z1Z2 acts as identity on the code space. But does it? Consider a state in the code space. For example, |00>_L = (|0000>+|1111>)/√2. Z1Z2 on that gives? On |0000>, Z1Z2 gives +1. On |1111>, Z1Z2 gives (+1) because both are 1? Actually, careful: Z|1> = -|1>, so Z1Z2 on |1111> gives (-1)*(-1)=+1. So Z1Z2 acts as identity on |00>_L. On |01>_L, maybe it acts as -1? So Z1Z2 is not necessarily a stabilizer because a stabilizer must act as +1 on all code states. So the stabilizer group is only the set of operators that are products of the generators that actually fix every code state. The generators are XXXX and ZZZZ. So the stabilizer group is {I, XXXX, ZZZZ, XXXX ZZZZ}. But wait, check: XXXX ZZZZ =? That is actually YYYY times a phase? Actually, XXXX ZZZZ = (XZ)(XZ)(XZ)(XZ) = (-iY)(-iY)(-iY)(-iY) = (-i)^4 YYYY = YYYY. So the stabilizer group is {I, XXXX, ZZZZ, YYYY}? But are these all? What about something like XXII? That is not in the stabilizer because it might not commute with ZZZZ? Actually, XXII commutes with ZZZZ? Check: XXII and ZZZZ: On qubit0, X and Z anticommute, so that gives a sign; on qubit1, X and Z anticommute, so another sign; so overall they commute. So XXII is in the normalizer. But is it in the stabilizer? It would need to act as identity on the code space. But on |00>_L = (|0000>+|1111>)/√2, XXII gives? On |0000>, XXII gives |1100> which is not in the code space? Actually, wait, if it is a stabilizer, it should map the code space to itself. But |1100> is not necessarily in the code space because the code space is 4-dimensional. So the stabilizer group is only the set of operators that are actually in the center of the normalizer? I need to be careful.
The stabilizer group S of a code is defined as the set of Pauli operators that fix every state in the code space. For the [[4,2,2]] code, the code space is the simultaneous +1 eigenspace of XXXX and ZZZZ. So if an operator is in the stabilizer group, it must commute with XXXX and ZZZZ (so it is in the normalizer) and it must act as +1 on the code space. The generators are XXXX and ZZZZ. So any product of these will act as +1 on the code space. So the stabilizer group is actually the group generated by XXXX and ZZZZ. That group has order 4 because XXXX and ZZZZ are independent and commute. So S = {I, XXXX, ZZZZ, XXXX ZZZZ}. But wait, is XXXX ZZZZ equal to YYYY? Yes, up to a phase? Actually, XXXX ZZZZ = (XZ)(XZ)(XZ)(XZ) = (-iY)(-iY)(-iY)(-iY) = (-i)^4 YYYY = YYYY. So S = {I, XXXX, ZZZZ, YYYY}. So the stabilizer group has 4 elements.
But earlier, when we computed the fidelity without post-selection, we found that the condition for the state to be correct was that F E is in the stabilizer of the state |ψ_ideal>, not the stabilizer of the code. And that stabilizer had order 16. So careful: There is a difference between the stabilizer of the code and the stabilizer of the particular state |ψ_ideal>. The code stabilizer is the set of operators that fix every state in the code space. The state |ψ_ideal> is a specific state within the code space. Its stabilizer (as a state) is larger. For example, consider Z1Z2. Does it fix |ψ_ideal>? We computed that Z1Z2|ψ_ideal> = |ψ_ideal>. So Z1Z2 is in the stabilizer of |ψ_1\rangle} but it is not in the stabilizer of the code because it does not fix all code states. So for logical fidelity, we care about whether the logical state is correct. That means that the error should act as identity on the logical qubits. That is equivalent to the error being in the stabilizer of the logical state? Actually, if the error is a logical operator that is not the identity on the logical qubits, it will change the logical state. So for the logical state to be correct, the error must be such that its action on the logical qubits is identity. That means that the error is in the normalizer of the code stabilizer but its logical action is trivial. That is exactly the code stabilizer itself? Actually, wait: The code stabilizer S_code acts trivially on the code space. But there are other operators in the normalizer that act trivially on the code space? For example, consider Z1Z2. Does it act trivially on the code space? Let’s check on a basis of the code space. The code space has logical basis |00>_L, |01>_L, |10>_L, |11>_L. What is the action of Z1Z2 on these? We can determine the logical operators. We have: Z_A = ZZII, Z_B = ZIZI. So Z1Z2 is not necessarily a logical operator? Actually, Z1Z2 = (Z1I2)(I1Z2) but that’s not directly a logical operator. Let’s compute: On |00>_L = (|0000>+|1111>)/√2, Z1Z2 gives +1. On |01>_L = (|0011>+|1100>)/√2, Z1Z2: on |0011>, qubit1=0 so Z=+1, qubit2=1 so Z=-1, so product -1; on |1100>, qubit1=1 -> -1, qubit2=0 -> +1, product -1; so Z1Z2|01>_L = -|01>_L. So Z1Z2 acts as -1 on |01>_L. So it is not in the code stabilizer because code stabilizer must act as +1 on all code states. So indeed, the only operators that act as identity on the entire code space are those in the code stabilizer S_code. So for the logical state to be correct, the error must be in S_code. But wait, could there be an error that is not in S_code but still leaves the particular state |ψ_ideal> unchanged? Yes, as we saw, Z1Z2 leaves |ψ_ideal> unchanged because |ψ_ideal> is a superposition of |00>_L and |11>_L, and on |11>_L, Z1Z2 gives? |11>_L = (|0110>+|1001>)/√2. On |0110>, qubit1=1 -> -1, qubit2=1 -> -1, product +1; on |1001>, qubit1=0 -> +1, qubit2=0 -> +1; so actually Z1Z2|11>_L = |11>_L. So indeed, Z1Z2 fixes |ψ_ideal>. But that is because |ψ_ideal> is not a full basis state of the code space; it’s a specific state. However, if we are only concerned with the logical state fidelity, we want the logical state to be exactly |ψ_ideal>. That means that if an error acts as a logical operator that is not identity but happens to fix |ψ_ideal>, that would still give fidelity 1. But wait, is that possible? Consider a logical operator that is not identity on the logical qubits. For example, consider the logical operator X_A. That would flip the first logical qubit. Would that fix |ψ_ideal>? |ψ_ideal> = (|00>+|11>)/√2. X_A would send it to (|10>+|01>)/√2, which is different. So not that.
What about Z_A? Z_A would send |00> to |00> and |11> to -|11>, so that would give (|00> - |11>)/√2, which is not the same state unless there is a phase overall? Actually, that state is orthogonal to |ψ_ideal> because inner product is 0. So indeed, for the logical state to be correct, the error must act as identity on the logical state. That means that the error must be in the set of Paulis that stabilize |ψ_ideal>. And that set we determined earlier has size 16. But wait, is that the code stabilizer? The code stabilizer is only 4 elements. So there are additional operators that stabilize |ψ_ideal> but are not in the code stabilizer. For example, Z1Z2 stabilizes |ψ_ideal> but is not in the code stabilizer because it does not stabilize all code states. However, if we are post-selecting on the code space, then we only keep states that are in the code space. But if an error is not in the code stabilizer but stabilizes |ψ_ideal>, then will the resulting state be in the code space? Let’s check: Take error = Z1Z2. This error commutes with the stabilizers? Z1Z2 commutes with XXXX? Check: XXXX and Z1Z2: On qubit1, X and Z anticommute; on qubit2, X and Z anticommute; so overall they commute. And with ZZZZ, they commute because Z’s commute. So Z1Z2 is in the normalizer. So if we apply Z1Z2 to |ψ_ideal>, the state remains in the code space because Z1Z2 is in the normalizer. And we already checked that Z1Z2|ψ_ideal> = |ψ_ideal>. So actually, errors that are in the stabilizer of |ψ_1\rangle} but not in the code stabilizer will still yield the correct logical state. So for logical fidelity after post-selection, we want that the error is in the set of Paulis that stabilize |ψ_ideal>. But wait, is that always true? Consider an error that is in the normalizer but not in the stabilizer of |ψ_ideal>. That error will map |ψ_ideal> to some other state in the code space. That other state will be an eigenstate of the logical operators with different eigenvalues? So that would be an error on the logical state. So indeed, after post-selection, the logical state is correct if and only if the error is in the stabilizer of |ψ_ideal> (which we determined has 16 elements). But careful: Is that entire set contained in the normalizer? Yes, because if it stabilizes |ψ_ideal>, then it must commute with the code stabilizers? Actually, not necessarily: An operator that stabilizes a particular state does not have to commute with the stabilizers of the code? But if |ψ_ideal> is in the code space, then for any stabilizer S of the code, S|ψ_ideal>=|ψ_ideal>. If E stabilizes |ψ_ideal>, then S E|ψ_ideal> = S|ψ_ideal> = |ψ_ideal>. But also E S|ψ_ideal> = E|ψ_ideal> = |ψ_1\rangle}. So that doesn’t force commutation. Actually, wait: Consider an operator E that stabilizes |ψ_ideal> but does not commute with some stabilizer S. Then S E|ψ_ideal> = S|ψ_ideal> = |ψ_ideal>. But E S|ψ_ideal> = E|ψ_ideal> = |ψ_ideal>. So that is fine. But could it be that E does not commute with S? For example, take a single qubit code? I need to check: For the [[4,2,2]] code, the stabilizer of |ψ_ideal> that we found earlier were those operators that act on {0,3} as one of {I, X⊗X, Z⊗Z, -Y⊗Y} and on {1,2} as one of {I, X⊗X, Z⊗Z, -Y⊗Y}. Do these commute with XXXX? Let’s check one: F = X⊗X on {0,3} and E = I⊗I on {1,2} gives overall X0X3. Does that commute with XXXX? X0X3 and XXXX: On qubit0, they commute; on qubit3, commute; on qubits1 and2, XXXX has X’s and X0X3 has I’s, so they commute. So yes. What about F = -Y⊗Y on {0,3} and E = I⊗I on {1,2} gives -Y0Y3. That with XXXX: On qubit0, Y and X anticommute; on qubit3, Y and X anticommute; so two anticommutations give commute overall. So indeed, these operators commute with XXXX. Similarly, they commute with ZZZZ? Check: For F = X⊗X, with ZZZZ: On qubit0, X and Z anticommute; on qubit3, anticommute; so commute overall. So yes, they are in the normalizer. So the stabilizer of |ψ_ideal> is a subgroup of the normalizer. Its size is 16. And the code stabilizer is a subgroup of that of size 4. So then, after post-selection, we only keep states where the error is in the normalizer. Among those, the ones that yield the correct logical state are those in the stabilizer of |ψ_ideal>, which has 16 elements out of the normalizer. But wait, what is the size of the normalizer? The normalizer of the stabilizer group in the Pauli group on 4 qubits (ignoring phases) is: The stabilizer group has 4 elements. The logical Pauli group for 2 qubits has 16 elements. So the normalizer has size 4 * 16 = 64. So there are 64 Pauli operators that map the code space to itself. Among these, 16 will stabilize |ψ_ideal> (and thus leave the logical state unchanged), and the other 48 will change the logical state.
So then, the logical fidelity after post-selection is:
F_logical = (Probability that error is in the stabilizer of |ψ_ideal>) / (Probability that error is in the normalizer).
But careful: Is that conditional probability? Yes, because we post-select on being in the normalizer. So
F_logical = [P(stabilizer of |ψ_ideal>)] / [P(normalizer)].
Now, we need to compute these probabilities as functions of p. And since the errors come from independent depolarizing channels on the two CNOT gates, we can use the fact that the map (F,E) -> P is a bijection between the 256 pairs and the 256 Pauli operators on 4 qubits (actually, careful: The Pauli group on 4 qubits has 4^4 = 256 elements if we ignore phases? Actually, the Pauli group on n qubits has 4^n elements if we consider Pauli matrices with phases ±1, ±i? But usually when we talk about Pauli errors, we consider them as operators up to phase? Actually, in error analysis, we often consider the set of Pauli operators as {I,X,Y,Z} on each qubit without overall phase factors because the depolarizing channel is defined with these. So indeed, there are 4^4 = 256 possible Pauli operators on 4 qubits. And our errors F and E are chosen from sets of size 16 each, so total 256 outcomes. So that bijection is correct.)
So then, the probability that the overall error P is a particular Pauli operator is exactly the probability of the unique pair (F,E) that gives that P. And since F and E are independent with distributions:
P(F) = 1-p if F=I⊗I, and = p/15 for each of the 15 non-identity Paulis on {0,3}.
Similarly for E.
So then, the probability that P is in a certain set S is the sum over all P in S of the probability of the corresponding (F,E). And that sum is simply (number of elements in S) times something? But careful: Not all Paulis have the same probability because the probability depends on whether F is identity or not and whether E is identity or not. However, because of the bijection, each Pauli P corresponds to a unique pair (F,E). But different Paulis will have different probabilities because they come from different combinations of F and E. So we cannot simply say that the probability is (|S|/256) because the distribution is not uniform over the 256 Paulis. We need to compute the total probability that P is in the normalizer and the total probability that P is in the stabilizer of |ψ_ideal>.
So we need to count: For each Pauli operator P on 4 qubits, what is its probability in terms of p? But wait, since the map is bijective, each P corresponds to a unique pair (F,E). And the probability of that pair is:
If F is identity, that contributes factor (1-p). If F is non-identity, factor (p/15).
Similarly for E.
So the probability for a given P is: (1-p)^2 if both F and E are identity.
(1-p)*(p/15) if one is identity and the other is non-identity.
(p/15)^2 if both are non-identity.
So if we want to compute the total probability for P to be in some set S, we need to know how many of the Paulis in S come from pairs where F is identity and E is identity, how many come from F identity and E non-identity, how many come from F non-identity and E identity, and how many come from both non-identity.
So we need to determine the structure of the normalizer and the stabilizer of |ψ_ideal> in terms of this decomposition.
Let’s denote:
N = normalizer set, size 64.
S_psi = stabilizer of |ψ_ideal>, size 16.
We want to compute:
P(N) = Sum_{P in N} Prob(P)
P(S_psi) = Sum_{P in S_psi} Prob(P)
And then fidelity = P(S_psi) / P(N).
Now, note that every Pauli P corresponds to a unique pair (F,E). And F acts on qubits 0 and 3, E acts on qubits 1 and 2.
So we can classify Paulis by what they are on these two pairs separately. Actually, any Pauli P can be written as P = P_{03} ⊗ P_{12}, where P_{03} is a Pauli on qubits 0 and 3, and P_{12} is a Pauli on qubits 1 and 2. But careful: This decomposition is not independent because the conditions for being in the normalizer involve both parts together? Actually, the conditions for being in the normalizer are conditions on the whole Pauli. But they can be stated in terms of the Paulis on the two pairs? Let’s see:
P is in the normalizer if:
(1) The number of qubits with Pauli being Z or Y is even.
(2) The number of qubits with Pauli being X or Y is even.
Now, if we separate into pairs {0,3} and {1,2}, these conditions become conditions on the two pairs jointly. Specifically, let for a two-qubit Pauli Q on two qubits, define:
n_z(Q) = number of qubits where Q is Z or Y (mod 2)
n_x(Q) = number of qubits where Q is X or Y (mod 2)
Then for P = P_{03} ⊗ P_{12}, the conditions are:
n_z(P_{03}) + n_z(P_{12}) is even.
n_x(P_{03}) + n_x(P_{12}) is even.
So that means that P_{03} and P_{12} must have the same parity for n_z and the same parity for n_x? Actually, even sum means they are both even or both odd. So conditions:
n_z(P_{03}) and n_z(P_{12}) have the same parity.
n_x(P_{03}) and n_x(P_{12}) have the same parity.
Now, what about the stabilizer of |ψ_ideal>? We determined that condition earlier:
P is in the stabilizer of |ψ_ideal> if and only if
P_{03} is one of: I⊗I, X⊗X, Z⊗Z, -Y⊗Y
and
P_{12} is one of: I⊗I, X⊗X, Z⊗Z, -Y⊗Y.
But wait, is that correct? Let’s check: If P_{03} = X⊗X and P_{12} = I⊗I, then P = X0X3. Is that in the stabilizer of |ψ_ideal>? We need to check if it fixes |ψ_ideal>. |ψ_ideal> = 1/2(|0000>+|1001>+|0110>+|1111>). X0X3 on |0000> gives |1010> which is not in the support? Actually, wait, that would give |1010> but that state is not in the superposition. So that suggests that actually, the condition for stabilizing |ψ_ideal> is not simply that the Pauli on {0,3} and {1,2} are of those forms independently. Because |ψ_ideal> has correlations between the pairs. Let’s derive the stabilizer of |ψ_ideal> properly.
|ψ_ideal> = 1/2(|0000>+|1001>+|0110>+|1111>).
We want Pauli P such that P|ψ_ideal> = |ψ_ideal>.
Write P = P0 P1 P2 P3.
Consider its action on each basis state. For P to stabilize, it must map each basis state to another basis state in the support with a phase that is consistent across all. Actually, it might be easier to use the fact that we already know that the circuit gives O = (F E) U, and we determined that the condition for no error (fidelity=1) was that F E is in the set that we called earlier. And that set had size 16. And we determined that condition was that F is in {I⊗I, X⊗X, Z⊗Z, -Y⊗Y} on {0,3} and E is in {I⊗I, X⊗X, Z⊗Z, -Y⊗Y} on {1,2}. But wait, that was for the state fidelity without post-selection. But that is exactly the condition that (F E)|ψ_ideal> = |ψ_ideal>. So that means that the stabilizer of |ψ_1\rangle} is actually that set. And note that this set is not simply a product of conditions on {0,3} and {1,2} independently because if F = X⊗X and E = I⊗I, then that gives P = X0X3. Does that stabilize |ψ_ideal>? Let’s check: X0X3|0000> = |1010> which is not in the support. So wait, there is an inconsistency. I need to re-derive the condition for state fidelity from first principles carefully.
We have |ψ_ideal> = U|0000> where U = CNOT_{03} H_0 CNOT_{21} H_2.
And we found that if there are errors F and E, then the final state is (F E) U|0000> = (F E)|ψ_ideal>.
We want this to equal |ψ_ideal>. So we want F E to be in the stabilizer of |ψ_ideal>.
Now, let’s compute the stabilizer of |ψ_ideal> directly from its form:
|ψ_ideal> = 1/2(|0000> + |1001> + |0110> + |1111>).
Consider a Pauli operator P. For it to stabilize |ψ_ideal>, it must satisfy P|ψ_ideal> = |ψ_ideal>.
Let’s take P = X0X3. Then:
X0X3|0000> = |1010>.
X0X3|1001> = |0011>.
X0X3|0110> = |1110>.
X0X3|1111> = |0101>.
None of these are in the support because the support only has states where qubit0=qubit3 and qubit1=qubit2. So clearly, X0X3 does not stabilize |ψ_ideal>.
What about P = X0X1? Then:
X0X1|0000> = |1100>.
X0X1|1001> = |0101>.
X0X1|0110> = |1010>.
X0X1|1111> = |0011>.
So no.
What about P = Z0Z3?
Z0Z3|0000> = |0000>.
Z0Z3|1001> = (-1)(-1)|1001> = |1001>.
Z0Z3|0110> = (+1)(+1)|0110> = |0110>.
Z0Z3|1111> = (-1)(-1)|1111> = |1111>.
So Z0Z3 stabilizes |ψ_ideal>. So that is in the stabilizer.
What about P = Z1Z2?
Z1Z2|0000> = |0000>.
Z1Z2|1001> = (+1)(+1)|1001> = |1001>.
Z1Z2|0110> = (-1)(-1)|0110> = |0110>.
Z1Z2|1111> = (-1)(-1)|1111> = |1111>.
So Z1Z2 stabilizes |ψ_ideal>.
What about P = X0X1X2X3? That is XXXX.
XXXX|0000> = |1111>.
XXXX|1001> = |0110>.
XXXX|0110> = |1001>.
XXXX|1111> = |0000>.
So XXXX stabilizes |ψ_ideal>.
What about P = Z0Z1Z2Z3?
ZZZZ|0000> = |0000>.
ZZZZ|1001> = (-1)(-1)(-1)(-1)|1001> = |1001>? Actually, careful: ZZZZ|1001> = Z0|1>Z1|0>Z2|0>Z3|1> = (-1)(+1)(+1)(-1)= (+1)|1001>. So yes.
ZZZZ|0110> = (+1)(-1)(-1)(+1)= (+1)|0110>.
ZZZZ|1111> = (-1)(-1)(-1)(-1)= (+1)|1111>.
So ZZZZ stabilizes.
What about P = X0X3? We already did, no.
What about P = X1X2?
X1X2|0000> = |0000>? Actually, X1X2|0000> = |0000> because qubits1 and2 are 0 become 1? Wait, |0000> means qubit1=0, qubit2=0, so X1X2|0000> = |0110> actually because flipping bits 1 and2 gives |0,1,1,0> which is |0110>. So that gives |0110>.
X1X2|1001> = |1111> because flipping bits1 and2 in |1001> gives |1,1,0,1>? Actually, careful: |1001> means qubit1=0, qubit2=0? No, |1001> means qubit0=1, qubit1=0, qubit2=0, qubit3=1. So flipping bits1 and2 gives |1,1,1,1> = |1111>.
X1X2|0110> = |0000>.
X1X2|1111> = |1001>.
So X1X2 actually maps |ψ_ideal> to itself? Because then |ψ_ideal> becomes 1/2(|0110>+|1111>+|0000>+|1001>) which is the same set. So X1X2 stabilizes |ψ_ideal>.
What about P = Y0Y3?
Y0Y3|0000> = Y0|0>Y3|0> = (i|1>)(i|1>) = -|1111>.
Y0Y3|1001> = Y0|1>Y3|1> = (-i|0>)(-i|0>) = -|0000>.
Y0Y3|0110> = Y0|0>Y3|0> = (i|1>)(i|1>) = -|1111>? Wait, careful: |0110> means qubit0=0, so Y0|0>= i|1>; qubit3=0, so Y3|0>= i|1>; product = -|1110>? But wait, that would give state |1,1,1,0> which is not in the support because qubit3=0 but qubit0=1, so actually that state is |1110> is not in the support because support requires qubit0=qubit3. So likely Y0Y3 does not stabilize. Let’s do properly:
For |0110>, qubit0=0 -> Y|0>= i|1>; qubit1=1 -> Y|1>= -i|0>; qubit2=1 -> Y|1>= -i|0>; qubit3=0 -> Y|0>= i|1>. So overall, phase = i * (-i) * (-i) * i = (i(-i))=1, (-i)(-i)= -1? Let’s do step: i * (-i) = 1, then 1 * (-i) = -i, then (-i)* i = -i^2 = 1. So actually, Y0Y1Y2Y3|0110> = |1001>? That is interesting. So maybe Y0Y3 alone is not enough. So the stabilizer of |ψ_ideal> that we found earlier from the circuit analysis was that it requires that F is in {I, X⊗X, Z⊗Z, -Y⊗Y} and E is in {I, X⊗X, Z⊗Z, -Y⊗Y}. That would mean that overall, things like X0X3 would not be included because that would require F=X0X3 and E=I, but that is not in the list because X0X3 is not one of {I, X⊗X, Z⊗Z, -Y⊗Y}? But wait, X0X3 is actually X⊗X on {0,3}. So that would be included if that list were correct. But we just ruled out X0X3 because it gave states outside the support. So there is a mistake. Let’s re-derive the condition from the circuit analysis carefully.
We had: O = F * CNOT_{03} * H_0 * E * CNOT_{21} * H_2.
And we found that this simplifies to O = (F E) U because we argued that F and E commute with the gates? But wait, that simplification assumed that E commutes with H_0 and CNOT_{03}. But does E commute with H_0? E acts on qubits 2 and 1. H_0 acts on qubit 0. So yes, they commute. And does E commute with CNOT_{03}? CNOT_{03} acts on qubits 0 and 3. E acts on qubits 2 and 1. So yes, they commute. So then O = F * CNOT_{03} * H_0 * CNOT_{21} * H_2 * E = U * E? That would be if also E commutes with CNOT_{21} and H_2? But careful: The order is: O = F * (CNOT_{03}) * (H_0) * (E) * (CNOT_{21}) * (H_2). We cannot simply move E past CNOT_{21} and H_2 because E acts on qubits 2 and 1 and CNOT_{21} acts on qubits 2 and 1 as well. So that commutation is not allowed. So my earlier simplification that led to O = (F E) U is actually not correct. I need to derive carefully.
Let’s define:
U1 = H_2
U2 = CNOT_{21}
U3 = H_0
U4 = CNOT_{03}
So ideal U = U4 U3 U2 U1.
Errors: after U2, we apply E on qubits (2,1). after U4, we apply F on qubits (0,3).
So actual operator: O = F * U4 * U3 * E * U2 * U1.
Now, can we simplify this? Notice that U3 acts on qubit 0 only. E acts on qubits 2,1. So U3 and E commute. So O = F * U4 * E * U3 * U2 * U1 = F * U4 * E * (U3 U2 U1). But careful: U3 U2 U1 is not U because U4 is separate. So O = F * U4 * E * (U3 U2 U1).
Now, does E commute with U4? U4 acts on qubits 0 and 3. E acts on qubits 2 and 1. So yes, they commute. So O = F * E * U4 * U3 * U2 * U1 = F * E * U.
So actually, it does become O = (F E) U. I earlier worried about commutation with U2 and H_2 but that worry was because I moved E past U2 and U1? Let’s check that step carefully:
O = F * U4 * U3 * E * U2 * U1.
U3 and E commute because they act on different qubits. So that gives = F * U4 * E * U3 * U2 * U1.
Now, does E commute with U4? U4 acts on qubits 0 and 3, E acts on qubits 2 and1, so yes. So = F * E * U4 * U3 * U2 * U1 = F E U.
So that seems correct. So then indeed, O = (F E) U. So the final state is (F E)|ψ_ideal>. So then the condition for no error is that F E is in the stabilizer of |ψ_ideal>. And that condition we determined earlier from that analysis led to that F must be in {I, X⊗X, Z⊗Z, -Y⊗Y} and E must be in {I, X⊗X, Z⊗Z, -Y⊗Y}. But wait, that would include the case F = X⊗X and E = I, which gives overall X0X3. But we already checked that X0X3 does not stabilize |ψ_ideal>. So there is a tension. Let’s check that case with the circuit method. Suppose only error is F = X0X3 happens on the second CNOT gate. Then the circuit is:
Start with |0000>.
Apply H2 -> becomes (|0000>+|0010>)/√2.
Apply CNOT21 -> becomes (|0000>+|0110>)/√2.
Apply H0 -> becomes 1/2(|0000>+|1000>+|0110>+|1110>).
Apply CNOT03 -> becomes 1/2(|0000>+|1001>+|0110>+|1111>)=|ψ_ideal>.
Then apply F = X0X3. So that would give X0X3|ψ_ideal> = 1/2(X0X3|0000> + X0X3|1001> + X0X3|0110> + X0X3|1111>) = 1/2(|1010>+|0011>+|1110>+|0101>). Is that equal to |ψ_ideal>? clearly not because |ψ_ideal> has states where qubit0=qubit3 and qubit1=qubit2. Here, |1010> has qubit0=1, qubit3=0 so no. So wait, then why did we get O = (F E) U? That would predict that if F=X0X3 and E=I, then the final state is X0X3|ψ_ideal>. So there is a mistake in the commutation step. Let’s check the commutation step carefully with this example.
O = F * U4 * U3 * E * U2 * U1. For our case, F = X0X3, E=I.
So O = X0X3 * CNOT03 * H0 * I * CNOT21 * H2.
Now, does X0X3 commute with CNOT03? CNOT03 acts on qubits 0 and 3. X0X3 does not commute with CNOT03 because CNOT03 involves control on qubit0 and target on qubit3. Let’s check: CNOT03 followed by X0X3 is not the same as X0X3 followed by CNOT03 generally. So actually, we cannot commute F with U4 because F acts on qubits that U4 acts on. So the step where I said does E commute with U4? That was fine because E acts on different qubits. But F acts on qubits 0 and 3, and U4 acts on qubits 0 and 3. So F and U4 do not commute generally. So then O = F * U4 * U3 * E * U2 * U1 is not equal to F * E * U4 * U3 * U2 * U1 because that would require that F commutes with U4, which it does not. So we cannot simplify to O = (F E) U. So we need to actually propagate errors through the circuit. So let’s do that properly.
We have stages:
State after stage 1: |ψ1> = H2 |0000> = (|0000>+|0010>)/√2.
Stage 2: Apply CNOT21. So |ψ2> = CNOT21 |ψ1> = (|0000>+|0110>)/√2.
Then error E on qubits (2,1). So |ψ2’> = E |ψ2>.
Stage 3: Apply H0. So |ψ3> = H0 |ψ2’>.
Stage 4: Apply CNOT03. So |ψ4> = CNOT03 |ψ3>.
Then error F on qubits (0,3). So final state |ψ_final> = F |ψ4>.
So errors occur at different points and then are affected by subsequent gates. So we need to determine the effective error on the state relative to |ψ_ideal>. This is more involved.
Maybe there is a easier way using the fact that the circuit is Clifford and errors are Pauli. So we can determine the effective Pauli error on the initial state after propagation through the circuit. That is, take an error happening at a certain point, and determine what Pauli it becomes after the remaining gates. Then the final state will be that Pauli applied to |ψ_ideal>. So then we can compute the conditions for that Pauli to be in the stabilizer of |ψ_ideal> versus in the normalizer.
Let’s do that. Let’s consider errors separately.
We have two error locations: after CNOT21, error E on qubits (2,1). after CNOT03, error F on qubits (0,3).
Let’s determine the effective error when propagated through the remaining circuit.
First, consider an error E on qubits (2,1) that happens after CNOT21. Then the remaining circuit is: H0, then CNOT03, then finally error F happens after that independently. But careful: errors happening later will also propagate. But since they are Pauli, the overall effect will be some Pauli. So let’s first compute the propagation of an error E on (2,1) through the subsequent gates up to before the last error F. Then that effective error will then be multiplied by F itself on (0,3) at the end. So overall, the final state will be: F * ( propagation of E through H0 and CNOT03 ) applied to |ψ_ideal>. But wait, careful: The ideal state is obtained when no errors occur. So if we have errors, the state is not simply some Pauli times |ψ_1\rangle} because the errors occur inside the circuit. However, since the circuit is Clifford, the effect of any Pauli error at any point can be accounted for by replacing it with an effective Pauli error at the end of the circuit acting on the ideal state. Is that true? Yes, for Clifford circuits, if you have a Pauli error at some point, you can propagate it through the subsequent gates and it will become some Pauli acting on the final state. So then the final state will be that Pauli times the ideal state. But careful: This is true if the error happens before the last gate? Actually, yes: For any Clifford circuit, if you have an Pauli error at any location, the resulting state is equivalent to the ideal state acted upon by some Pauli operator that depends on the error and its location. And if there are multiple errors, since they are Pauli, the overall effect is the product of the effective errors from each location. So we can compute effective errors for each error location.
Let’s define the circuit gates clearly. The circuit is applied in order:
- H2
- CNOT21
- ERROR E on (2,1)
- H0
- CNOT03
- ERROR F on (0,3)
So let’s compute the effective error from an error E on (2,1) that happens after step 2. We want to know what Pauli does it become after steps 4 and 5? because step 6 is another error that happens after, so that will just multiply independently. So let’s compute: If an error E acts on (2,1) immediately after CNOT21, then what is the effective error after passing through H0 and CNOT03? But careful: H0 acts on qubit0 only. CNOT03 acts on qubits (0,3). So we need to see how an operator on qubits (2,1) transforms under H0 and CNOT03. Since H0 and CNOT03 act on different qubits than (2,1) normally commute with operators on (2,1) because they act on disjoint sets? Actually, H0 acts on qubit0 only. That is disjoint from {2,1}. So H0 will commute with any operator on {2,1}. Similarly, CNOT03 acts on {0,3} and will commute with any operator on {2,1} because they act on different qubits. So actually, wait: H0 and CNOT03 do not involve qubits 2 and 1 at all. So any error on qubits (2,1) will commute with H0 and CNOT03. So that means that if an error E happens on (2,1) after step 2, then after steps 4 and 5, it will still be the same Pauli acting on (2,1). So the effective error from E is just E itself acting on (2,1) at the end of the circuit before the last error F. But wait, is that always true? Check with an example: Suppose E = X2. Then after H0 and CNOT03, since these gates act on qubits 0 and 3, they commute with X2. So yes, effective error remains X2.
So then after step 5, the state is actually ( effective error from E ) applied to the state that would be there if no error occurred at step 3? But careful: The state after step 5 without any errors would be |ψ_ideal>. So if only error E occurs, then after step 5, the state is E |ψ_ideal>. Then step 6 applies F on (0,3). So overall, the final state is F * E |ψ_ideal>. So wait, that is actually what we had before: O = F * E * U seems to be true if errors commute with the subsequent gates? But then we already ruled out that because of the example F=X0X3 alone should commute with U4? But wait, check that example: If only error is F on (0,3) happening after step 5. Then that error would commute with nothing because it happens at the very end. So then the final state is F |ψ_ideal>. So that would mean that if only error is F, then effective error is F itself. So then overall, if both errors occur, the final state is F * E |ψ_ideal>. So then my earlier commutation attempt would give O = F * E * U provided that F commutes with U4? But wait, does F commute with U4? U4 is CNOT03. F acts on (0,3). They do not commute generally. So why would that be? Let’s check with only error F happening. That means after step 5, state is |ψ_ideal>. Then we apply F on (0,3). So the final state is F |ψ_ideal>. So that suggests that effective error from F is just F itself. So then if both errors occur, then the final state is F * E |ψ_ideal>. But wait, is that always true? Consider the order: after step 2, we apply E. Then steps 3-5 are applied to that state. But since those steps commute with E because they act on different qubits, yes, after step 5, the state is E |ψ_ideal>. Then step 6 applies F. So final state = F E |ψ_ideal>. So actually, it seems that indeed, the final state is always F E |ψ_ideal>. So then why did I earlier worry about commuting F with U4? That was when I tried to move F past U4 inside the circuit. But here, F happens after U4 already. So it’s correct that the final state is F E |ψ_ideal>. So then the condition for the state to be correct is that F E is in the stabilizer of |ψ_ideal>. And that is what I initially thought. Then my counterexample was when F = X0X3 and E=I gives final state = X0X3|ψ_ideal>. And I computed that explicitly and found it does not equal |ψ_ideal>. So there is an inconsistency between that and the circuit steps. Let’s compute that circuit explicitly with only error F=X0X3 happening at the end.
Circuit steps:
- H2 on |0000> -> becomes (|0000>+|0010>)/√2.
- CNOT21 -> becomes (|0000>+|0110>)/√2.
- H0 -> becomes 1/2(|0000>+|1000>+|0110>+|1110>).
- CNOT03 -> becomes 1/2(|0000>+|1001>+|0110>+|1111>) = |ψ_ideal>.
- Apply F = X0X3. So final state = X0X3|ψ_ideal> = 1/2(X0X3|0000> + X0X3|1001> + X0X3|0110> + X0X3|1111>).
Now, X0X3|0000> = |1010> because flip qubit0 and qubit3: becomes |1,0,0,1> wait careful: X0X3 means apply X on qubit0 and X on qubit3. So on |0000>, that gives |1001> actually because qubit0 becomes 1, qubit3 becomes 1? No, wait: |0000> means qubit0=0,1=0,2=0,3=0. X0 changes qubit0 to 1, X3 changes qubit3 to 1. So that gives |1001>. So X0X3|0000> = |1001>.
Next, X0X3|1001> = flip qubit0 and qubit3 on |1001>. qubit0=1 -> becomes 0, qubit3=1 -> becomes 0, so becomes |0001>? But careful: |1001> means qubit0=1,1=0,2=0,3=1. After X0 and X3, qubit0 becomes 0, qubit3 becomes 0, so state becomes |0001> but wait, that is |0,0,0,1> actually that is |0001>.
Next, X0X3|0110> = |1110> because qubit0=0->1, qubit3=0->1, so becomes |1,1,1,0>.
Next, X0X3|1111> = |0111> because qubit0=1->0, qubit3=1->0, so becomes |0,1,1,1>.
So the final state would be 1/2(|1001>+|0001>+|1110>+|0111>). That is not equal to |ψ_ideal>. So that suggests that if only error is F=X0X3, then the final state is not simply X0X3|ψ_ideal>? But wait, that is what I did: I applied X0X3 to |ψ_ideal>. So it should be that. So then why would that happen? because after step 4, the state is |ψ_ideal>. Then step 5 is applying F which is X0X3. So indeed, the final state is X0X3|ψ_ideal>. So that seems correct. So then why did I get that earlier when I computed the circuit steps manually for only error F, I got something else? I need to recompute the circuit steps carefully for only error F=X0X3 happening at the end.
Circuit for only error F:
Start: |0000>
Apply H2: -> state = H2|0000> = 1/√2(|0>+|1>) on qubit2 times |0> on others actually careful: H2 acts on qubit2 only. So state becomes = |00>_{0,1} ⊗ (H|0>_2) ⊗ |0>_3 = |00> ⊗ (|0>+|1>)/√2 ⊗ |0> = (|0000>+|0010>)/√2.
Apply CNOT21: CNOT21 means control on qubit2, target on qubit1. So on |0000>, control=0 so no flip -> stays |0000>. On |0010>, control=1 so flip qubit1 -> becomes |0110>. So state becomes (|0000>+|0110>)/√2.
Apply H0: H0 acts on qubit0. So state becomes: H0|0000> = (|0>+|1>)/√2 on qubit0 times |000> -> actually careful: |0000> means qubit0=0, so H0|0>= (|0>+|1>)/√2, so that gives (|0000>+|1000>)/√2. And H0|0110> = since qubit0=0 in |0110>, becomes (|0110>+|1110>)/√2. So overall state after H0 = 1/√2 * [ (|0000>+|1000>)/√2 + (|0110>+|1110>)/√2 ] = 1/2(|0000>+|1000>+|0110>+|1110>).
Apply CNOT03: CNOT03 means control on qubit0, target on qubit3.
On |0000>: control=0 -> no flip -> stays |0000>.
On |1000>: control=1 -> flip qubit3 -> becomes |1001>.
On |0110>: control=0 -> no flip -> stays |0110>.
On |1110>: control=1 -> flip qubit3 -> becomes |1111>.
So state becomes 1/2(|0000>+|1001>+|0110>+|1111>) = |ψ_ideal>. So that is correct.
Now apply error F = X0X3. So act with X0 and X3 on this state.
X0X3|0000> = apply X0 and X3 to |0000> gives |1001> because qubit0 becomes 1, qubit3 becomes 1.
X0X3|1001> = apply X0 and X3 to |1001> gives |0000> because qubit0:1->0, qubit3:1->0.
X0X3|0110> = apply X0 and X3 to |0110> gives |1110> because qubit0:0->1, qubit3:0->1.
X0X3|1111> = apply X0 and X3 to |1111> gives |0111> because qubit0:1->0, qubit3:1->0.
So final state = 1/2(|1001>+|0000>+|1110>+|0111>) = 1/2(|0000>+|1001>+|0111>+|1110>).
Now, is that equal to |ψ_ideal>? |ψ_ideal> is 1/2(|0000>+|1001>+|0110>+|1111>). So they are different because third term: |0110> vs |0111> and fourth: |1111> vs |1110>. So indeed, final state is not |ψ_ideal>. So that confirms that if only error is F=X0X3, then the final state is X0X3|ψ_ideal> and that is not equal to |ψ_ideal>. So then the condition for no error is that F E must be in the stabilizer of |ψ_ideal>. And that stabilizer, based on this example, would not include X0X3 alone. So then what is the stabilizer of |ψ_ideal>? We can determine it by looking for Paulis that leave |ψ_ideal> invariant. Let’s find them systematically.
|ψ_ideal> = 1/2(|0000>+|1001>+|0110>+|1111>).
Let P be a Pauli. Write P = P0 P1 P2 P3.
For P to stabilize, it must map each basis state to another basis state in the set with a phase, and the phases must be such that the overall state is unchanged.
because it’s a Pauli, it will act on each computational basis state by flipping bits and multiplying by a phase. So let’s denote the action on each term clearly.
term1: |0000>
term2: |1001>
term3: |0110>
term4: |1111>
conditions. likely already known that Z0Z3, Z1Z2, XXXX, ZZZZ stabilize. What about X0X1? That would give:
X0X1|0000> = |1100> not in set.
So that doesn’t.
What about X0X3? We already did: gives |1001>, |0000>, |1110>, |0111> so no.
What about X1X2?
X1X2|0000> = |0110> phase? X1X2 on |0000>: since acting on |00> gives |11> so actually careful: |0000> -> becomes |0,1,1,0> = |0110>. So that maps term1 to term3.
X1X2|1001> = |1,0,0,1> actually wait: |1001> -> X1X2 gives |1,1,1,1>? Let’s do: |1001> means qubit1=0, qubit2=0 -> become 1,1 so becomes |1111>. So term2 -> term4.
X1X2|0110> = |0000> because flip bits1 and2 of |0110> gives |0000>.
X1X2|1111> = |1001> because flip bits1 and2 of |1111> gives |1001>.
So X1X2 actually permutes the terms: 1<->3 and 2<->4. So that would leave the state invariant if phases are all +1. Check phases:
X1X2|0000> = no phase issues because X|0>=|1> has phase 1.
|1001> -> X1X2|1001> = likely phase 1 because acting on |0> gives |1> and on |0> gives |1> so okay.
So X1X2 seems to stabilize |ψ_ideal>. So that is in the stabilizer.
What about Y0Y1? That would give phases likely not all equal.
I recall that the stabilizer of a state like this should have order 8 maybe? Actually, wait, |ψ_ideal> is a stabilizer state of itself? It is not necessarily a stabilizer state of the full Pauli group because it is entangled across 4 qubits. Actually, it is a stabilizer state because it can be prepared by a Clifford circuit. So its stabilizer should have size 2^4=16. So there should be 16 Paulis that stabilize it. So we need to find 16 Paulis. They are generated by 4 operators. likely they are: Z0Z3, Z1Z2, X0X1X2X3, and something else? But wait, check: Z0Z3 and Z1Z2 we already have. Their product is Z0Z1Z2Z3 which is ZZZZ. So that gives that. Then X0X1X2X3 is XXXX. So that gives that. So these 4 generate a group of size 16? Actually, Z0Z3 and Z1Z2 commute and are independent? But wait, do they commute? Z0Z3 and Z1Z2 act on different qubits so yes. So that gives 4 elements. Then with XXXX, that would give 8 elements. Then we need one more to get to 16. That additional generator could be X1X2 perhaps? But then check if X1X2 commutes with Z0Z3? Yes. Does it commute with Z1Z2? X1X2 and Z1Z2: on qubit1, X and Z anticommute; on qubit2, X and Z anticommute; so they commute overall. And with XXXX? likely yes. So then the group generated by {Z0Z3, Z1Z2, XXXX, X1X2} has size? Z0Z3 and Z1Z2 give 4, times XXXX gives 8, times X1X2 gives 16. So that is likely the stabilizer of |ψ_ideal>. So then the stabilizer of |ψ_ideal> is actually generated by these 4 operators. Let’s check action of X1X2 we already did. So then what are the conditions for being in this stabilizer? If I take an arbitrary Pauli P = P0P1P2P3, for it to be in the stabilizer, it must commute with these generators and act as +1 on |ψ_ideal>. actually wait, being in the stabilizer means that P itself fixes |ψ_ideal>. So that is determined by its action on the basis states. I won’t derive that fully here. Instead, I’ll use the fact that since the circuit is Clifford, the effective error from any Pauli error at any location will be some Pauli acting on the final state. And that effective error can be computed by propagating the error through the subsequent gates. So maybe I should compute the effective errors for each error location separately.
Let’s do that. We have two error locations: after CNOT21, error E on (2,1). after CNOT03, error F on (0,3).
Let’s compute the effective error from an error E on (2,1) that happens after CNOT21. subsequent gates: H0 and then CNOT03. But careful: These gates act on qubits 0 and 3 only. So they commute with any operator on qubits 2 and 1? Actually, wait, H0 acts on qubit0 only. That commutes with operators on qubits 2 and because they act on different qubits. CNOT03 acts on qubits 0 and 3. That also commutes with operators on qubits 2 and 1 because those are different. So indeed, if an error happens on (2,1) at that point, then after H0 and CNOT03, it will still be the same Pauli on (2,1). So the effective error from E is just E itself acting on the final state. So that means that if only error E occurs, the final state is E|ψ_ideal>. So then for that to be correct, E must be in the stabilizer of |ψ_ideal>. So that gives conditions on E alone. So what are the Paulis on qubits (2,1) that stabilize |ψ_ideal>? From our generators, likely that requires that E must be either I⊗I, Z⊗Z, X⊗X, or something else? Let’s check: If E = Z1Z2, then that works because Z1Z2|ψ_ideal>=|ψ_ideal>. If E = X1X2, then that works as well because we checked X1X2 works. What about Y1Y2? Consider Y1Y2|ψ_ideal>. Y1Y2|0000> = Y1|0>Y2|0> = (i|1>)(i|1>)= -|1,1,0,0> actually careful: |0000> -> becomes -|0110>? because qubit1 and2 become 1 gives |0,1,1,0> wait, that is |0110> actually. So phase would be -1 times |0110>. Then Y1Y2|1001> would give? likely not all phases equal. So probably the only Paulis on (2,1) that stabilize are I, Z1Z2, X1X2, and maybe also something else? What about Z1 alone? That would not because it would give phases. So likely on qubits (2,1), the stabilizer conditions are that E must be either I⊗I, Z1Z2, X1X2, or their product which is -Y1Y2? because Z1Z2 * X1X2 = actually careful: Z1Z2 * X1X2 = (Z1X1)(Z2X2) = (-iY1)(-iY2)= (-1)Y1Y2. So yes, that would be -Y1Y2. So on (2,1), the stabilizer of |ψ_ideal> requires that E is in {I⊗I, Z1Z2, X1X2, -Y1Y2}.
Now consider an error F on (0,3) that happens after CNOT03. subsequent gates: none actually because it happens at the end. So effective error from F is just F itself. So then if only error F occurs, the final state is F|ψ_ideal>. So for that to be correct, F must be in the stabilizer of |ψ_1\rangle} on qubits (0,3). What are those? likely they are {I⊗I, Z0Z3, X0X3? But wait, check: Z0Z3 works because we checked. Does X0X3 work? We already ruled out X0X3 because it did not stabilize. What about something else? What about X0 alone? That would not. So likely on (0,3), the stabilizer conditions are that F must be in {I⊗I, Z0Z3} only? But wait, could there be another? What about something like X0X1? That acts on both pairs though. So for an error solely on (0,3), it would be products of Paulis on qubits 0 and 3 only. So we need to find all Paulis on qubits 0 and 3 that stabilize |ψ_ideal>. Let’s check manually:
|ψ_ideal> = 1/2(|0000>+|1001>+|0110>+|1111>).
Consider a Pauli on qubits 0 and 3 only. That means it acts as identity on qubits 1 and2.
So take P = A0 B3 where A,B ∈ {I,X,Y,Z} but not both I necessarily.
For this to stabilize, it must map each term to itself or to another term in the support with the same phase overall.
term1: |0000> -> A0B3|0000> = (A|0>)(B|0>) times |00> on qubits1,2.
term2: |1001> -> A0B3|1001> = (A|1>)(B|1>) times |00> because qubits1,2 are 0 actually careful: |1001> means qubit1=0,2=0.
term3: |0110> -> A0B3|0110> = (A|0>)(B|0>) times |11> because qubits1,2 are 1,1.
term4: |1111> -> A0B3|1111> = (A|1>)(B|1>) times |11>.
For these to be in the support, we need that the resulting state has qubits1,2 either both 0 or both 1. So that requires that for terms1 and2, that’s fine because they become |00> always. For terms3 and4, they become |11> always. So that condition is okay actually for any A,B? Not quite: also the states on qubits0 and3 must match the pattern that qubit0 should equal qubit3 for terms1 and4? Actually, the support states are those where qubit0=qubit3 and qubit1=qubit2. So for term1, after action, we need that the resulting state on qubits0 and3 should have both 0 or both 1? Actually, term1 is |0000> means qubit0=0,3=0. So after action, we need that become either |0000> or |1111> actually wait, careful: The support is not that qubit0=qubit3 necessarily? Yes, because look at the states: |0000> has 0=0,3=0. |1001> has 1 and0? Actually, |1001> has qubit0=1, qubit3=1. |0110> has qubit0=0, qubit3=0? Actually, |0110> has qubit0=0, qubit3=0? No, |0110> means qubit0=0,1=1,2=1,3=0. So actually, in |0110>, qubit0=0 and qubit3=0. In |1111>, qubit0=1,3=1. So indeed, in all support states, qubit0 = qubit3. So that means that after action of A0B3, for term1, we need that A|0> and B|0> are such that they are both |0> or both |1>. That means that A and B must be either both I or both Z actually because Z|0>=|0> times phase? actually Z|0>=|0> with phase +1. What about X? X|0>=|1>. So if A=X and B=X, then term1 becomes |1> and |1> so that works actually because then term1 becomes |1100> wait careful: term1 is |0000>. If A=X and B=X, then A|0>=|1>, B|0>=|1>, so that gives |11> on qubits0,3, so that state becomes |1100>. But |1100> is not in the support because support requires that qubit1=qubit2 are 0 actually that is okay because |1100> has qubit1=0,2=0, so that is actually in the support? But wait, support states are only these four: |0000>,|1001>,|0110>,|1111>. |1100> is not one of these because it would require that qubit0=1,3=0 actually no, support requires that qubit0=qubit3. In |1100>, qubit0=1 and qubit3=0, so that fails. So for term1, after action, we need that the state on qubits0 and3 becomes either |00> or |11>. So that means that A|0> and B|0> must be both |0> or both |1>. If A=X, then A|0>=|1>. So we need B|0> to be |1> as well, so B must be X. So that suggests that A=X,B=X might work? But then check term2: |1001>. For term2, A|1> and B|1>. If A=X,B=X, then X|1>=|0>, so that gives |00> on qubits0,3. So term2 becomes |0001>? wait, careful: term2 is |1001>. After applying X0X3, we get: X|1>=|0>, X|1>=|0>, so that gives |00> on qubits0,3, so the state becomes |0001> because qubits1,2 are still 0,0. But |0001> is not in the support because support requires qubit0=qubit3 here that is 0 and 0 actually wait, |0001> has qubit0=0, qubit3=1, so that fails. So X0X3 does not work. So likely on (0,3), the only possibilities are I⊗I and Z0Z3. What about Y0Y3? If A=Y,B=Y, then Y|0>= i|1>, so term1 becomes phase i^2|11> = -|11> so that gives state |1100> which is not in support because that would require qubit0=1,3=0 actually wait, |1100> means qubit0=1,3=0, so that’s not allowed because support requires qubit0=qubit3. So indeed, on (0,3), the only stabilizers appear to be I and Z0Z3. What about X0Z3? That would give term1: X|0>=|1>, Z|0>=|0>, so that gives |10> on qubits0,3, so not allowed. So yes, on (0,3), the stabilizer conditions are that F must be either I⊗I or Z0Z3.
Now, what about errors on (2,1)? As argued, they commute with subsequent gates, so effective error is itself. And we found that on (2,1), the stabilizer conditions are that E must be in {I⊗I, Z1Z2, X1X2, -Y1Y2} because that comes from the fact that Z1Z2 works, X1X2 works, and their product gives -Y1Y2 works likely. Let’s check X1X2 works already. Check -Y1Y2: -Y1Y2|0000> = - (Y|0>)(Y|0>) = - (i|1>)(i|1>)= -(-1)|11>=|11> actually careful: ii=-1, so -(-1)=+1, so term1 becomes |0,1,1,0> = |0110>. Term2: -Y1Y2|1001> = - (Y|0>)(Y|1>) wait, careful: |1001> means qubit1=0, qubit2=0 actually because |1001> is qubit0=1,1=0,2=0,3=1. So for term2, acting on qubits1 and2: Y|0>= i|1>, Y|0>= i|1>, product = i^2|11> = -|11>, times overall - gives +|11>. So term2 becomes |1,1,1,1> = |1111>. Term3: -Y1Y2|0110> = acting on qubits1 and2 of |0110> means qubit1=1,2=1: Y|1> = -i|0>, Y|1> = -i|0>, product = (-i)(-i)= i^2? Actually, (-i)(-i)= -1? Let’s do: (-i)(-i)= i^2? Actually, i^2 = -1. So product = (-1) actually careful: (-i)(-i) = i^2 = -1. So then -Y1Y2|0110> = - ( product ) times state? Actually, careful: -Y1Y2 means multiply by -1 then apply Y1Y2. So for term3: Y1Y2|0110> = (Y|1>)(Y|1>) = (-i|0>)(-i|0>)= (-i)(-i)= i^2? I need to do this systematically with phases determined by the Pauli matrices themselves. Maybe it’s easier to use the fact that the stabilizer of |ψ_ideal> should have size 16. And we already have generators: Z0Z3, Z1Z2, XXXX, X1X2. So then any element of the stabilizer will be determined by its action on (0,3) and (1,2) separately? But wait, these generators do not factorize completely because XXXX involves both pairs. So actually, the stabilizer elements will have correlated actions on the two pairs. So then for an error that acts only on (0,3) to be in the stabilizer, it must be that its action on (0,3) is such that when combined with identity on (1,2), the overall operator is in the stabilizer. So that means that we need Pauli operators on (0,3) such that there exists something on (1,2) that is identity actually wait, if error is only on (0,3), then it is P_{03} ⊗ I_{12}. For this to be in the stabilizer, it must commute with the generators and act as +1 on |ψ_ideal>. Let’s check that. Take P = Z0Z3 ⊗ I. That works because that is actually one of the generators? Actually, Z0Z3 is not itself a generator because the generators are Z0Z3Z? No, wait, Z0Z3 alone would be because that would give on term1: Z0Z3|0000>=|0000>. term2: Z0Z3|1001>= (-1)(-1)|1001>=|1001>. term3: Z0Z3|0110>= (+1)(+1)|0110>=|0110>. term4: Z0Z3|1111>= (-1)(-1)|1111>=|1111>. So yes, Z0Z3 is in the stabilizer. What about X0X3 ⊗ I? That we already ruled out. What about I alone? works. So indeed, on (0,3), the only stabilizers are I and Z0Z3. What about on (1,2)? If we take P = I_{03} ⊗ something on (1,2). For that to be in the stabilizer, take something like Z1Z2 works. X1X2 works as we checked. What about Y1Y2? Consider I_{03} ⊗ Y1Y2. Then on term1: Y1Y2|0000> = (Y|0>)(Y|0>)= (i|1>)(i|1>)= -|0110> actually careful: that gives state |0,1,1,0> = |0110>, but with phase? actually, ii = -1, so term1 becomes -|0110>. term2: I⊗Y1Y2|1001> = |1⟩ times Y1Y2|001> wait, careful: |1001> means qubit1=0,2=0 so becomes (Y|0>)(Y|0>)= -|1,1> so term2 becomes -|1111>. term3: I⊗Y1Y2|0110> = acting on qubits1,2 which are both 1: Y|1>= -i|0>, so product = (-i)*(-i)= -1, so term3 becomes -|0000>. term4: becomes -|1001>. So overall, I⊗Y1Y2 would give -|ψ_ideal> actually because it cycles the terms with a minus sign? Actually, check phases: term1 -> -1, term2 -> -1, term3 -> -1, term4 -> -1 would give overall -|ψ_1\rangle}. So wait, I⊗Y1Y2 might actually stabilize if it gives a constant phase of -1? But then that would mean that I⊗Y1Y2|ψ_ideal> = -|ψ_ideal>. But that is not allowed because stabilizer means it should give +1 times |ψ_ideal>. So I⊗Y1Y2 is not in the stabilizer. What about -I⊗Y1Y2? That would give phase +1. So indeed, on (1,2), the stabilizer conditions are that the error must be either I, Z1Z2, X1X2, or -Y1Y2. So that matches our earlier guess.
So then, when both errors occur, the effective error is F * E. For this to be in the stabilizer of |ψ_ideal>, we need that overall, the Pauli on (0,3) from F and on (1,2) from E combine such that the resulting operator is in the stabilizer. But careful: wait, could it be that F alone is not in the stabilizer but when multiplied by an E that is not in the stabilizer, they become in the stabilizer? For example, suppose F = X0X3 itself is not in the stabilizer. But if E is something that also acts on (1,2) such that the product becomes something like X0X3 * something might become in the stabilizer? But note that these act on different qubits, so the product factors as (F on (0,3)) ⊗ (E on (1,2)). For this to be in the stabilizer, we need that F on (0,3) must be either I or Z0Z3 because that’s what we found for operators that act only on (0,3) to be in the stabilizer. Is it possible that an operator that is not of that form on (0,3) could become in the stabilizer when tensored with something on (1,2)? Suppose F = X0X3. Then consider E such that overall becomes X0X3 ⊗ something. For this to be in the stabilizer, it would have to commute with the generators conditions. But likely no because then would that operator stabilize |ψ_ideal>? Let’s check an example: If F = X0X3 and E = X1X2, then overall is X0X3X1X2 = XXXX actually. And XXXX is in the stabilizer. So wait, that is interesting: X0X3 is not in the stabilizer alone, but if combined with X1X2, then the product is X0X1X2X3 which is XXXX, which is in the stabilizer. So that means that effective error can be in the stabilizer even if individually F and E are not in their own stabilizer conditions. So we need to compute the conditions for F * E to be in the stabilizer of |ψ_ideal>. Since these act on different qubits, any operator in the stabilizer will factor as something on (0,3) tensored something on (1,2). And from earlier, we determined that on (0,3), the only possibilities for an operator to be in the stabilizer when alone are I and Z0Z3. But wait, what about X0X3? Is it possible that X0X3 alone is in the stabilizer? We already ruled that out because it doesn’t stabilize |ψ_ideal>. So indeed, if an operator acts only on (0,3), it must be I or Z0Z3 to be in the stabilizer. However, when combined with something on (1,2), could it be that the product is in the stabilizer even if the (0,3) part is not I or Z0Z3? Let’s check: Take operator = X0X3 ⊗ X1X2. That is XXXX, which is in the stabilizer. So that means that for the product to be in the stabilizer, it is not necessary that the (0,3) part alone is in the stabilizer. So then conditions become coupled between F and E.
Maybe it’s easier to use the fact that the map (F,E) -> effective error is actually a bijection onto the set of Pauli operators on 4 qubits. And then the probability that the effective error is in the stabilizer of |ψ_ideal> is simply the sum over all Pauli operators in that stabilizer of their probabilities. And that probability depends on how many of those Paulis come from pairs where F is identity or not. So we need to know for each Pauli operator P in the stabilizer of |ψ_ideal>, what is its decomposition as P = F * E with F acting on (0,3) and E acting on (1,2)? Since this is a bijection, each P corresponds to a unique pair (F,E). So then P(stabilizer) = Σ_{P in stabilizer} Prob(F)Prob(E) where that pair is the one that gives P.
Now, the stabilizer of |ψ_ideal> has 16 elements. So we need to know how many of these 16 have F = identity? How many have F non-identity? etc. But wait, that requires knowing the stabilizer explicitly. The stabilizer is generated by: let’s take generators:
S1 = Z0Z3
S2 = Z1Z2
S3 = X0X1X2X3 (XXXX)
S4 = X1X2
So any element of the stabilizer can be written as (Z0Z3)^a (Z1Z2)^b (XXXX)^c (X1X2)^d, with a,b,c,d in {0,1}. So then an element is determined by (a,b,c,d). Let’s express that in terms of action on (0,3) and (1,2).
S1 acts only on (0,3) as Z0Z3.
S2 acts only on (1,2) as Z1Z2.
S3 acts on both: on (0,3) gives X0X3 and on (1,2) gives X1X2.
S4 acts only on (1,2) as X1X2.
So then an element is: on (0,3): from S1^a and S3^c gives: (Z0Z3)^a (X0X3)^c. on (1,2): from S2^b, S3^c, S4^d gives: (Z1Z2)^b (X1X2)^c (X1X2)^d = (Z1Z2)^b (X1X2)^(c+d).
So then the (0,3) part is determined by (a,c). The possible outcomes on (0,3):
If (a,c)=(0,0) -> I.
(1,0) -> Z0Z3.
(0,1) -> X0X3.
(1,1) -> (Z0Z3)(X0X3) = Z0X0 Z3X3 = ( -iY0)(-iY3) = (-1)Y0Y3? Actually, careful: Z0X0 = -iY0, so product = (-i)^2 Y0Y3 = (-1)Y0Y3. So that is -Y0Y3.
So on (0,3), the stabilizer elements have either I, Z0Z3, X0X3, or -Y0Y3.
On (1,2), determined by (b, c+d mod2). So outcomes:
If (b, c+d)=(0,0) -> I.
(1,0) -> Z1Z2.
(0,1) -> X1X2.
(1,1) -> (Z1Z2)(X1X2) = -Y1Y2.
So then indeed, the stabilizer elements are exactly those where the (0,3) part is in {I, Z0Z3, X0X3, -Y0Y3} and the (1,2) part is in {I, Z1Z2, X1X2, -Y1Y2}. And wait, is that independent? But careful: notice that the (0,3) part and (1,2) part are determined by separate parameters actually because (0,3) depends on (a,c) and (1,2) depends on (b, c+d). So for a given (0,3) part, that fixes (a,c) up to? actually, (0,3) part can be any of these 4. And for (1,2) part, it can be any of these 4 independently? But then that would give 16 elements. So indeed, the stabilizer of |ψ_ideal> is actually that every Pauli of the form where on (0,3) is one of {I, Z0Z3, X0X3, -Y0Y3} and on (1,2) is one of {I, Z1Z2, X1X2, -Y1Y2} works. But wait, check that: Take (0,3) = X0X3 and (1,2)=I. That would be X0X3 alone. But we already ruled out X0X3 alone because it did not stabilize |ψ_ideal>. So there is a catch: when I said stabilizer elements are determined by (a,b,c,d), that gives 16 elements. If I take (a,b,c,d) = (0,0,1,0), then that gives on (0,3): X0X3 and on (1,2): X1X2 from S3 actually wait, careful: (0,0,1,0) means a=0,b=0,c=1,d=0. Then that gives on (0,3): (Z0Z3)^0 (X0X3)^1 = X0X3. On (1,2): (Z1Z2)^0 (X1X2)^1 (X1X2)^0 = X1X2. So that product is X0X3X1X2 = XXXX, which is in the stabilizer. So wait, if I take (0,3)=X0X3 and (1,2)=I, that would require that from somewhere else? actually, notice that parameters (a,c) determine the (0,3) part uniquely. If (a,c)=(0,1), that gives X0X3. But then what is (1,2)? That depends on (b, c+d). For (0,1) with any d, c+d will be 1+d. If d=0, then c+d=1, so (1,2) becomes determined by (b,1). If b=0, then (1,2) becomes X1X2 actually because (0,1) gives X1X2. If b=1, then (1,2) becomes (Z1Z2)(X1X2) = -Y1Y2. So actually, when (a,c)=(0,1), it is not possible to have (1,2)=I because that would require that (b, c+d) = (0,0) or (1,0)? (0,0) would require b=0 and c+d=0, but c=1 so d would have to be 1 mod2? actually, c+d=0 means d=1 since c=1. So (0,0) is not possible because that would give actually wait, careful: (b, c+d) takes values in {0,1} for each. So if c=1, then to have c+d=0, we need d=1. So then (b, c+d)=(0,0) gives that would actually mean? If b=0 and d=1, then (1,2) becomes from formula: (Z1Z2)^0 (X1X2)^(1+1) wait, careful: formula is (Z1Z2)^b (X1X2)^(c+d). If b=0 and c+d=0 mod2, then that gives (X1X2)^0 = I. So actually, if (a,c)=(0,1) and (b,d)=(0,1), then that gives on (0,3): X0X3 and on (1,2): I because c+d=1+1=2 mod2=0. So that means that there is an element with (0,3)=X0X3 and (1,2)=I. That would be corresponding to (a,b,c,d)=(0,0,1,1). Let’s check that element: S1^0 S2^0 S3^1 S4^1 = S3 S4 = (XXXX)(X1X2) = X0X3X1X2 * X1X2 actually careful: S3S4 = (X0X1X2X3)(X1X2) = X0X3 because X1X2 cancels with X1X2? Actually, wait, careful: S3 = X0X1X2X3. S4 = X1X2. So S3S4 = X0X1X2X3 * X1X2 = X0X3 because X1X1=I, X2X2=I. So indeed, S3S4 = X0X3. So that is in the stabilizer. But then does X0X3 stabilize |ψ_ideal>? We already checked that X0X3 alone does not stabilize because it gave states outside the support. So there is a contradiction. Let’s check S3S4 explicitly. S3S4 = X0X1X2X3 * X1X2 = X0X3 because the X1 and X2 cancel. So S3S4 = X0X3. Now act that on |ψ_ideal>.
|ψ_ideal> = 1/2(|0000>+|1001>+|0110>+|1111>).
S3S4|0000> = X0X3|0000> = |1001> because that’s what we computed earlier? Actually, careful: X0X3|0000> should be |1001>? Let’s recompute: X0X3|0000> means apply X on qubit0 and X on qubit3. |0000> becomes |1001> because qubit0 becomes 1, qubit3 becomes 1. So that gives |1001>.
S3S4|1001> = X0X3|1001> = |0000> because flip both gives back.
S3S4|0110> = X0X3|0110> = |1110> because flip qubit0 and qubit3: |0 becomes1,0 becomes1> so becomes |1110>.
S3S4|1111> = X0X3|1111> = |0111> because flip gives |0,1,1,1>.
So then S3S4|ψ_ideal> = 1/2(|1001>+|0000>+|1110>+|0111>) which is not equal to |ψ_ideal> because that would require that third term is |0110> and fourth is |1111>. So actually, S3S4 does not stabilize |ψ_ideal>. So that means that (a,b,c,d) = (0,0,1,1) does not yield a stabilizer element. So then my generator choice might be inconsistent. Let’s determine the stabilizer of |ψ_ideal> properly by actually finding Paulis that leave it invariant.
|ψ_ideal> = 1/2(|0000>+|1001>+|0110>+|1111>).
Let P = P0P1P2P3.
For P to stabilize, it must that for each basis state in the support, P maps it to another basis state in the support with a phase, and the phases must be equal for all terms because the state is evenly weighted.
So consider term1: |0000>. term2: |1001>. term3: |0110>. term4: |1111>.
notice that these states have the property that qubit0 and qubit3 are equal, and qubit1 and qubit2 are equal.
So likely any stabilizer will preserve that property. So P must be such that it does not change the fact that qubit0=qubit3 and qubit1=qubit2. So that means that P should act on qubits0 and3 in a way that if it flips qubit0, it must also flip qubit3 similarly so that they remain equal. Similarly for qubits1 and2. So that suggests that P should be of the form where on qubits0 and3, it is either I⊗I, X⊗X, Z⊗Z, or something that flips both in the same way. What about Y⊗Y? Y|0>= i|1>, so that would give both become |1> so that works actually because then they remain equal. But careful with phases: Y⊗Y|00> = (i|1>)(i|1>)= -|11>. So that would give a phase of -1 for that term. But then for consistency across terms, that phase would have to be the same for all terms. So it is possible that Y⊗Y appears with a overall sign maybe. So likely on each pair, the stabilizer conditions are that the operator on that pair must be either I, X⊗X, Z⊗Z, or Y⊗Y up to a sign. But wait, check X⊗X on pair (0,3) alone would take |00> to |11> and |11> to |00>. So that would preserve the property. So then why did X0X3 alone not work? Because when we act on |ψ_ideal>, consider term3: |0110>. That state has on pair (0,3): |00> actually because qubit0=0,3=0. So X0X3 would take that to |11> on pair (0,3), so that would give |1110>. But wait, |1110> does not have property that qubit1=qubit2? Actually, |1110> has qubit1=1,2=1 actually yes it does because both are 1. So |1110> would seem to have the property that qubit0=1,3=0 though wait, careful: |1110> means qubit0=1,1=1,2=1,3=0. So that violates that qubit0 should equal qubit3 because here 1≠0. So actually, for term3, the state is |0110>. Its pair (0,3) is actually (0,0) because qubit0=0,3=0. So that’s fine. Under X0X3, that becomes (1,1) on pair (0,3) actually because X0 changes 0->1, X3 changes 0->1, so that gives (1,1). So then the state becomes |1,1,1,0> wait careful: |0110> means digits: 0,1,1,0. After X0 and X3, we get: qubit0:0->1, qubit3:0->1, so state becomes |1,1,1,1> actually because qubit1 and2 remain 1,1. So |0110> becomes |1111>. That is in the support. Now check term4: |1111> becomes under X0X3: qubit0:1->0, qubit3:1->0, so becomes |0111> which is not in the support because that would be digits: 0,1,1,1 actually that does have property that qubit1=1,2=1, but wait, |0111> means qubit0=0,3=1, so that violates that qubit0 should equal qubit3. So term4 becomes |0111> which is not in the support. So why would that happen? Because when acting on |1111>, the pair (0,3) is (1,1). X0X3 takes that to (0,0). So that would give state |0,1,1,1> actually because careful: |1111> digits: 1,1,1,1. Apply X0 and X3: becomes: qubit0:1->0, qubit3:1->0, so state becomes |0,1,1,0> actually because wait, qubit1 and2 are still 1,1. So that gives |0110>. So actually, term4 becomes |0110>. So then overall, X0X3 would map:
|0000> -> |1001>
|1001> -> |0000>
|0110> -> |1111>
|1111> -> |0110>
So that actually would leave the set invariant. Then the state would become 1/2(|1001>+|0000>+|1111>+|0110>) which is actually the same as |ψ_ideal>. So wait, that suggests that X0X3 does stabilize |ψ_ideal>! I earlier got that term4 became |0111> but that was a mistake. Let’s recompute X0X3 carefully on each term:
term1: |0000> -> X0X3|0000> = apply X on qubit0 and X on qubit3. So |0000> becomes |1001> because qubit0 becomes 1, qubit3 becomes 1. So term1 -> |1001>.
term2: |1001> -> X0X3|1001> = qubit0:1->0, qubit3:1->0, so becomes |0000>.
term3: |0110> -> X0X3|0110> = qubit0:0->1, qubit3:0->1, so becomes |1111>.
term4: |1111> -> X0X3|1111> = qubit0:1->0, qubit3:1->0, so becomes |0110>.
So indeed, X0X3 just swaps term1 with term2 and term3 with term4. So that would leave |ψ_ideal> invariant. So I earlier made a mistake in that term4 became |0111>; that was when I did it without carefulness. So actually, X0X3 does stabilize |ψ_ideal>. So then on (0,3), the stabilizer conditions are that F can be any of {I, X0X3, Z0Z3, Y0Y3} actually check Y0Y3:
Y0Y3|0000> = (Y|0>)(Y|0>)= (i|1>)(i|1>)= -|11> so that gives -|1,0,0,1> wait careful: Y0Y3|0000> = phase ii = -1 times |1,1> on qubits0,3 actually because Y|0>= i|1>, so product = i^2 |11> = -|11>. So that would give state |-1,0,0,-1> actually that is -|1001> because qubits0 and3 become 1,1. So term1 -> -|1001>.
term2: Y0Y3|1001> = Y|1>Y|1> = (-i|0>)(-i|0>)= (-i)(-i)= i^2? actually (-i)(-i)= -1? Let’s do: (-i)(-i)= i^2? Actually, i^2 = -1. So (-i)(-i) = (-1)(i^2) wait, better: (-i)(-i) = i^2 = -1. So term2 -> -|0000>.
term3: Y0Y3|0110> = Y|0>Y|0> on qubits0,3 gives phase -1 -> becomes -|1111>.
term4: Y0Y3|1111> = Y|1>Y|1> gives phase? Y|1> = -i|0>, so product = (-i)(-i)= -1 -> becomes -|0110>.
So overall, Y0Y3 would give -|ψ_ideal>. So actually, Y0Y3 gives a phase of -1. So if we take -Y0Y3, then that would give +1. So on (0,3), the stabilizer conditions are that F should be in {I, X0X3, Z0Z3, -Y0Y3}.
Now check that with alone would that work? If only error is F and it is say X0X3, then effective error is X0X3 alone, and we just checked that stabilizes |ψ_ideal>. So that means that actually, if only error is on (0,3), then for it to be in the stabilizer, F can be any of these 4. But wait, earlier I thought that Z0Z3 worked alone and that seemed right. And X0X3 we now see works alone. What about -Y0Y3 alone? If F = -Y0Y3 alone, then that would give phase? Let’s check -Y0Y3 alone:
term1: -Y0Y3|0000> = - (Y0Y3|0000>) = -(-|1001>) = |1001>.
term2: -Y0Y3|1001> = -(-|0000>) = |0000>.
term3: -Y0Y3|0110> = -(-|1111>) = |1111>.
term4: -Y0Y3|1111> = -(-|0110>) = |0110>.
So yes, that works alone too. So on (0,3), the stabilizer conditions are that F is in {I, X0X3, Z0Z3, -Y0Y3}.
Now on (1,2), by similar reasoning, alone would require that E is in {I, X1X2, Z1Z2, -Y1Y2} because that would stabilize alone. And we already checked X1X2 alone works and Z1Z2 alone works. So then when both errors occur, the effective error is F * E. But careful: If both errors occur, then the effective error is actually F * E because they commute? But wait, they act on different qubits, so yes, the final state is F E |ψ_ideal>. So then for that to be in the stabilizer, we need that F E is in the stabilizer. But if F is in the stabilizer on (0,3) alone and E is in the stabilizer on (1,2) alone, then clearly F E is in the stabilizer because it will stabilize since it’s a product of stabilizers acting on different qubits. So that gives that if both F and E are in their own stabilizer sets, then overall is good. But wait, could it be that F is not in its own stabilizer set but when combined with an E that is not in its own set, they become in the stabilizer? For example, take F = X0X3 is in the stabilizer already actually. What about taking F = something else? The stabilizer set on (0,3) alone is actually all Paulis on (0,3) that stabilize |ψ_ideal> when acting alone. And that set we determined seems to be of size 4. Is it possible that there is any Pauli on (0,3) that is not in {I, X0X3, Z0Z3, -Y0Y3} that could become part of a stabilizer when combined with something on (1,2)? Suppose take F = I alone is in that set. What about F = something like X0 alone? That would not because it would not preserve the property that qubit0=qubit3. So likely, the stabilizer of |ψ_1\rangle} actually factors as follows: any stabilizer operator must act on (0,3) and (1,2) independently because they act on different qubits. And since |ψ_ideal> is actually a product state between these two pairs? Is |ψ_ideal> a product state? |ψ_ideal> = 1/2(|00>|00> + |11>|00>? No, careful: If I group qubits (0,3) and (1,2), then |ψ_ideal> = 1/2(|00>|00> + |11>|00> that’s not right because term2 is |1001> means (0,3)=(1,1) and (1,2)=(0,0). Term3: (0,3)=(0,0) and (1,2)=(1,1). Term4: (0,3)=(1,1) and (1,2)=(1,1). So actually, |ψ_ideal> = 1/2(|00>|00> + |11>|00> + |00>|11> + |11>|11>) wait that would be 1/2(|00>+|11>){03} ⊗ (|00>+|11>){12} actually that is product state between the two pairs. Yes! because that is exactly that. So |ψ_ideal> is actually a product of two Bell states between qubits (0,3) and (1,2). Because |ψ_ideal> = 1/2(|00>|00> + |11>|00>? Let’s check: If I take the state (|00>+|11>)/√2 on pairs, then that state is 1/√2(|00>+|11>). The product of two such states would be 1/2(|00>|00> + |00>|11> + |11>|00> + |11>|11>). But that is not our state because our state has terms: |0000>, |1001>, |0110>, |1111>. If I pair as (0,3) and (1,2), then |0000> means (0,3)=00, (1,2)=00. |1001> means (0,3)=10? careful: qubit0=1, qubit3=1 actually so that is 11 wait, careful: when pairing, I should decide order within each pair. Let’s pair qubits 0 and 3 together and qubits 1 and 2 together. Then state |0000> means that on pair (0,3), we have bits: qubit0=0, qubit3=0 so that is |00>. On pair (1,2), bits: qubit1=0, qubit2=0 so that is |00>. So that term is |00>|00>.
|1001> means: pair (0,3): qubit0=1, qubit3=1 -> that is |11> actually because if I take order (0,3) then that gives |11>. Pair (1,2): qubit1=0, qubit2=0 -> |00>. So that term is |11>|00>.
|0110> means: pair (0,3): qubit0=0, qubit3=0 -> |00>. Pair (1,2): qubit1=1, qubit2=1 -> |11>. So that is |00>|11>.
|1111> means: pair (0,3): |11>, pair (1,2): |11>. So indeed, |ψ_ideal> = 1/2(|00>|00> + |11>|00> + |00>|11> + |11>|11>) wait that is actually not product because product would be (|00>+|11>)/√2 tensored with (|00>+|11>)/√2 would give that same thing. So yes, |ψ_1\rangle} is actually a product of two Bell states between (0,3) and (1,2). So then the stabilizer of |ψ_ideal> will be the product of the stabilizers of each Bell state. And the stabilizer of a Bell state on two qubits is well-known: for a Bell state say (|00>+|11>)/√2, the stabilizer is generated by XX and ZZ. So that means that on pair (0,3), the stabilizer conditions are that the operator must be in {I, X0X3, Z0Z3, -Y0Y3} because that is the stabilizer of a Bell state. And on pair (1,2), similarly, the stabilizer conditions are that the operator must be in {I, X1X2, Z1Z2, -Y1Y2}. And since these act on different pairs, the full stabilizer is the product of these two sets. So that means that actually, the stabilizer of |ψ_ideal> has size 4*4=16. And it consists of operators of the form where on (0,3) is any of {I, X0X3, Z0Z3, -Y0Y3} and on (1,2) is any of {I, X1X2, Z1Z2, -Y1Y2}. So then that is clear now.
So then for the effective error to be in the stabilizer, we need that F (acting on (0,3)) is in that set and E (acting on (1,2)) is in that set. Because then F E will be in the stabilizer since it factors.
So then the condition for no logical error (i.e., fidelity 1) is that F is in S_{03} and E is in S_{12}, where
S_{03} = {I⊗I, X0X3, Z0Z3, -Y0Y3}
S_{12} = {I⊗I, X1X2, Z1Z2, -Y1Y2}.
Now, are these sets actually that? Let’s check alone: If only error is F and F = X0X3, does that stabilize? Yes, as checked. If only error is F and F = Z0Z3, yes. If only error is F and F = -Y0Y3, yes.
So then that means that the probability that the effective error is in the stabilizer is simply:
P(stabilizer) = [P(F in S_{03})] * [P(E in S_{12})] because they are independent.
Now, what is P(F in S_{03})? F is depolarizing on two qubits. outcomes for F: there are 16 possible Paulis on two qubits. how many of them are in S_{03}? That set has 4 elements. So probability that F is in S_{03} is: probability that F is identity (1-p) plus probability that F is one of the other 3 outcomes times (p/15 each). So that is = (1-p) + 3*(p/15) = 1-p + p/5 = 1 - (4p/5).
Similarly, P(E in S_{12}) = 1 - (4p/5).
So then P(stabilizer) = (1 - 4p/5)^2. That is actually the same as the physical fidelity we computed earlier. So that makes sense because if there is no post-selection, the fidelity is that probability. So that is correct.
Now, for post-selection, we only keep states that are in the code space. That means that the effective error must be in the normalizer of the code stabilizer. The code stabilizer is generated by XXXX and ZZZZ. wait, careful: The code stabilizer is for the [[4,2,2]] code. What is that? The code stabilizer is actually {I, XXXX, ZZZZ, XXXXZZZZ} actually that is only size 4. But wait, that is the stabilizer of the code space itself. So any state in the code space is stabilized by these operators. So for the state to be in the code space, we need that the effective error commutes with these stabilizers? Actually, if started with a state in the code space, after an error that is in the normalizer, the state will still be in the code space. So post-selection means we only keep outcomes where the effective error is in the normalizer of the code stabilizer. What is the normalizer of the code stabilizer? Since the code stabilizer has size 4, the normalizer will have size 4 * (logical Pauli group size) = 416=64. So there are 64 Pauli operators that map the code space to itself. these are exactly those Paulis that commute with XXXX and ZZZZ. What are those conditions? For a Pauli operator to commute with XXXX, it must have an even number of sites where it is either Z or Y. To commute with ZZZZ, it must have an even number of sites where it is either X or Y. Now, since our effective error factors as acting on (0,3) and (1,2) independently because that’s how we’ve been able to separate due to the structure of |ψ_ideal> actually wait, careful: Is it true that any operator in the normalizer will factorize between (0,3) and (1,2)? Not necessarily because conditions involve both pairs together. But note that |ψ_ideal> is within the code space. And actually, the code space itself factors between these pairs? Is that true? The code space of the [[4,2,2]] code is actually spanned by states that are products of Bell states between (0,3) and (1,2)? I think yes because often the [[4,2,2]] code is also known as the product of two Bell states. Actually, wait, the [[4,2,2]] code is exactly that: you take two Bell pairs. So yes, the code space is spanned by |00>{03}|00>{12}, |00>{03}|11>{12}, |11>{03}|00>{12}, |11>{03}|11>{12}. So that is correct. Then the stabilizer of the code space is generated by X0X3X1X2 and Z0Z3Z1Z2 actually careful: For a Bell state between qubits 0 and 3, the stabilizer is generated by X0X3 and Z0Z3. So then the stabilizer of the product would be generated by X0X3X1X2? Actually, if you take two independent Bell states, the stabilizer would be generated by X0X3, Z0Z3, X1X2, Z1Z2. But that would be size 44=16. But wait, that is for the product state itself. But the code space of the [[4,2,2]] code is actually 4-dimensional. If you take two Bell states, that gives a 4-dimensional space. So then the stabilizer of that space would be generated by these 4 operators? But then that would mean that the stabilizer group of the code would have order 2^4=16. But I recall that the [[4,2,2]] code has stabilizer group of order 4, not 16. because usually for an [[n,k,d]] code, the stabilizer group has order 2^(n-k). Here n=4, k=2, so order should be 2^2=4. So there is a discrepancy. actually, wait: If you take two Bell states, that state is not stabilized by X0X3 alone because that would stabilize the first Bell state but not necessarily the second Bell state independently? Actually, if you have a product of two Bell states, say |Φ+⟩{03}⊗|Φ+⟩{12}, then that state is stabilized by X0X3 alone? Check: X0X3|Φ+⟩{03} = |Φ+⟩{03} because that is stabilizer of the Bell state. So yes, actually, |Φ+⟩{03} is stabilized by X0X3. So then the state |Φ+⟩{03}⊗|Φ+⟩{12} is stabilized by X0X3 and also by X1X2 independently. So that would give two stabilizers. Similarly, it is stabilized by Z0Z3 and Z1Z2 independently. So that would be 4 stabilizers. But wait, then the stabilizer group would have order 2^4=16. But that would mean that the code space is actually stabilized by 4 independent generators, which would imply that the code space has dimension 2^(4-4)=1. So that’s not right. I recall that for a stabilizer code, the stabilizer group is abelian and does not include logical operators. For two Bell states, the state itself is not a stabilizer state of the code because the code space is larger than just that state. The code space is actually spanned by |00>{03}|00>{12}, |00>{03}|11>{12}, |11>{03}|00>{12}, |11>{03}|11>{12}. What are the stabilizers of that space? An operator that stabilizes the entire code space must act as identity on every state in the code space. Consider X0X3. Does it act as identity on every state in the code space? Take |00>{03}|00>{12}. X0X3 would give |11>{03}|00>{12}. That is actually in the code space because that is |11>|00>. But does it act as identity? Not necessarily because |11>|00> is different from |00>|00> unless they are the same state, which they are not. So X0X3 is not in the stabilizer of the code space. The stabilizer of the code space are those operators that leave every state in the code space invariant. likely they are X0X3X1X2 and Z0Z3Z1Z2. because then acting on |00>|00>, X0X3X1X2 gives |11>|11> which is not that state either wait that gives |11>|11> which is different from |00>|00>. So that doesn’t work either. actually, wait, the stabilizer of a code is defined as the set of Pauli operators that act as identity on the code space. For the [[4,2,2]] code, the stabilizer is actually generated by XXXX and ZZZZ. So that means that for any state in the code space, XXXX|ψ> = |ψ> and ZZZZ|ψ> = |ψ>. So that is the stabilizer. So then coming back to post-selection: We only keep states that are in the code space. That means that when we measure the stabilizers, we get +1 for both XXXX and ZZZZ. that means that the effective error must commute with these stabilizers? Actually, if started with a state in the code space, after an error that is in the normalizer, the state will still be in the code space. So post-selection means that the effective error is in the normalizer of the code stabilizer. The normalizer of {XXXX, ZZZZ} consists of those Paulis that commute with both. As noted, that set has size 64. So then the probability that the state is kept after post-selection is P(normalizer) = probability that effective error is in that set of 64 Paulis out of 256.
Now, since effective error = F * E and this is a bijection between pairs (F,E) and Paulis, we need to compute the probability that a randomly chosen Pauli (with distribution induced by independent depolarizing on F and E) falls into the normalizer. That probability is that for the Pauli to be in the normalizer, it must satisfy conditions on the parities of Z/Y and X/Y counts. But wait, since F and E act on different pairs, maybe we can compute this probability by independence? because conditions for being in the normalizer might factor across the two pairs? Let’s see. For effective error to be in the normalizer, it must commute with XXXX and ZZZZ. Consider XXXX. commute means that the number of qubits where effective error has Pauli that anticommutes with X is even. effective error factors as acting on (0,3) and (1,2). So that condition becomes: (number on (0,3) where Pauli is Z or Y) + (number on (1,2) where Pauli is Z or Y) is even.
similarly for ZZZZ: (number on (0,3) where Pauli is X or Y) + (number on (1,2) where Pauli is X or Y) is even.
Now, if we want to compute the probability that effective error is in the normalizer, that is the probability that these two conditions hold. But careful: F and E are chosen independently with their own distributions. So we can compute the probability that for a given two-qubit Pauli acting on (0,3) that it has an even number of Z/Y sites. Let’s compute that for depolarizing on two qubits. But wait, the distribution for F is not uniform over the 16 Paulis? It is: P(F) = 1-p for identity, and for each of the 15 non-identity, probability p/15.
So for F acting on two qubits, let’s determine the probability that it has an even number of sites with Z or Y. But careful: The condition for normalizer is on the effective error itself, not on F alone because effective error = F * E. But since F and E act on different sets, the conditions become independent across the sets actually because they are separate sums. So actually, effective error is in the normalizer if and only if:
[ ( parity of F regarding Z/Y ) + ( parity of E regarding Z/Y ) ] is even, and
[ ( parity of F regarding X/Y ) + ( parity of E regarding X/Y ) ] is even.
So if I define for a two-qubit Pauli Q, let f_z(Q) = 0 if Q has an even number of sites with Z or Y, and 1 if odd.
similarly, f_x(Q) = 0 if even number of sites with X or Y, and 1 if odd.
Then effective error is in normalizer if and only if: f_z(F) + f_z(E) = 0 mod2 and f_x(F) + f_x(E) = 0 mod2.
Now, since F and E are independent, the probability that effective error is in normalizer is = [ probability that f_z(F)=0 and f_x(F)=0 ] * [ probability that f_z(E)=0 and f_x(E)=0 ] + [ probability that f_z(F)=0 and f_x(F)=1 ] * [ probability that f_z(E)=0 and f_x(E)=1 ] wait careful actually because they must match in both regards. Actually, it is: P(normalizer) = P(f_z(F)=0)P(f_z(E)=0) * P(f_x(F)=0)P(f_x(E)=0) actually no because they are not independent within F itself necessarily. Let’s do it properly:
We want: f_z(F) = f_z(E) and f_x(F) = f_x(E). So that means that the pair (f_z(F), f_x(F)) must equal (f_z(E), f_x(E)). So if I compute the distribution of these pairs for a random F according to its depolarizing distribution, then P(normalizer) = sum{ pair } [P(F has that pair)]^2.
So let’s compute for a two-qubit Pauli Q ( acting on two specific qubits) with distribution: P(Q=I) = 1-p, and for each of the 15 non-identity, probability p/15.
Now, let’s list the 16 Paulis on two qubits. They are determined by Pauli on first and second qubit. I’ll use notation where I will determine f_z and f_x for each.
better: f_z(Q) is 0 if Q has an even number of sites where the Pauli is Z or Y. f_x(Q) is 0 if even number of sites with X or Y.
Now, identity: I⊗I: that has no sites with Z or Y -> even so f_z=0. No sites with X or Y -> even so f_x=0.
Now, Paulis that are products of I and something else? Actually, let’s list by type based on whether both acts are identity or not. But maybe I can compute these probabilities directly.
Maybe it’s easier to note that effective error is uniformly distributed over the 256 Paulis? Is it? Not exactly because the probabilities are not uniform because identity has higher probability. But wait, since F and E are independent and the map is bijective, the distribution on the 256 Paulis is such that each Pauli that comes from a pair where both are identity has probability (1-p)^2, each Pauli that comes from one identity and one non-identity has probability (1-p)*(p/15) times something actually careful: If a Pauli factors as Q_{03} ⊗ Q_{12}, then its probability is P(F=Q_{03}) * P(E=Q_{12}). So it’s not uniform across all Paulis because different Q_{03} have different probabilities? Actually, wait: For depolarizing, every non-identity has the same probability p/15. So for Q_{03} that is identity, probability is (1-p). For Q_{03} that is any specific non-identity, probability is p/15. So indeed, different Paulis have different probabilities depending on whether they are identity on that pair or not.
So I need to compute the distribution of the pair (f_z, f_x) for depolarizing on two qubits.
Let’s do that for general two-qubit Pauli space. There are 16 operators. They can be categorized by their weight? But careful: f_z and f_x are determined by the Pauli strings themselves. Let’s list them explicitly for two qubits. Let the two qubits be called A and B.
The Paulis are determined by two Pauli matrices. I’ll use notation where I will write the Pauli on each qubit. So outcomes:
- I,I -> f_z=0, f_x=0.
- I,X -> then sites: first: I -> not Z or Y so okay actually careful: f_z: need to count sites where Pauli is Z or Y. For I,X: first is I -> not Z or Y so count=0; second is X -> not Z or Y because X is not Z or Y? Actually, wait: f_z counts sites with Z or Y. X is not Z or Y, so count=0. So f_z=0. f_x: sites with X or Y. first: I -> no; second: X -> yes. So count=1 -> odd so f_x=1.
- I,Y -> then: first: I ->0; second: Y -> Y counts for both actually careful: f_z: Y counts as Z or Y? Yes, because Y involves Z actually wait: f_z is defined as sites where the Pauli is either Z or Y. So yes, Y counts. So that gives count=1 -> odd so f_z=1. f_x: sites with X or Y: Y counts as well because Y involves X? Actually, careful: f_x counts sites where Pauli is X or Y. So Y counts. So that gives count=1 -> odd so f_x=1.
- I,Z -> then: first: I ->0; second: Z -> Z counts for f_z -> count=1 so f_z=1; for f_x: Z does not count because Z is not X or Y, so count=0 -> f_x=0.
- X,I -> by symmetry, this will be like I,X actually because order doesn’t matter? But careful: f_z and f_x are determined by each qubit independently. So X,I: first: X -> for f_z: X is not Z or Y so 0; second: I ->0; so f_z=0. f_x: first: X -> counts ->1; second: I ->0; so f_x=1.
- X,X -> then: first: X -> for f_z:0; second: X ->0; so f_z=0. f_x: first: X ->1; second:1 -> total 2 even so f_x=0.
- X,Y -> first: X -> for f_z:0; second: Y -> Y counts ->1 so f_z=1; f_x: first: X ->1; second: Y ->1 -> total2 even so f_x=0.
- X,Z -> first: X ->0; second: Z -> for f_z: Z counts ->1 so f_z=1; f_x: first: X ->1; second: Z ->0 -> total1 odd so f_x=1.
- Y,I -> similar to I,Y: f_z=1, f_x=1.
- Y,X -> already did? actually careful: Y,X is same as X,Y because order matters? But careful: Y,X means first qubit Y, second X. That gives: f_z: first: Y ->1; second: X ->0 -> total1 odd so f_z=1; f_x: first: Y ->1; second: X ->1 -> total2 even so f_x=0. So that is same as case 7 actually because case 7 was X,Y gave f_z=1, f_x=0. So yes.
- Y,Y -> first: Y ->1; second: Y ->1 -> total2 even so f_z=0; f_x: first:1; second:1 ->2 even so f_x=0.
- Y,Z -> first: Y ->1; second: Z ->1 -> total2 even so f_z=0; f_x: first: Y ->1; second: Z ->0 -> total1 odd so f_x=1.
- Z,I -> like I,Z: f_z=1, f_x=0.
- Z,X -> like X,Z: f_z=1, f_x=1.
- Z,Y -> like Y,Z: f_z=0, f_x=1.
- Z,Z -> first: Z ->1; second: Z ->1 ->2 even so f_z=0; f_x: both not X or Y so f_x=0.
So let’s gather these outcomes for a two-qubit Pauli Q outcomes. I’ll list them with their conditions for being identity or not identity because that affects probability.
outcomes that are identity: only case 1: I,I. That has probability when chosen from depolarizing: actually careful: When we talk about depolarizing, identity has probability 1-p. So case 1: probability = 1-p.
cases that are non-identity: cases 2 through 16. Each has probability p/15.
Now, let’s count how many fall into each (f_z, f_x) category.
Category (0,0): f_z=0, f_x=0.
From above:
- I,I -> (0,0)
- X,X -> (0,0)
- Y,Y -> (0,0)
- Z,Z -> (0,0)
Also any others? Check case? So there are 4 outcomes that give (0,0). Among these, 1 is identity, 3 are non-identity.
Category (0,1): f_z