17 Def 7: Space and Time Faults
In the context of fault-tolerant implementation of the gauging measurement procedure, we formalize the notions of space-faults (single-qubit Pauli errors), time-faults (measurement errors), initialization faults, and their collective description as spacetime faults forming a group.
The Pauli error type is an inductive type with four constructors:
representing the identity (no error), bit flip, combined bit-and-phase flip, and phase flip, respectively.
The multiplication of Pauli types is defined by the standard Pauli multiplication table (ignoring global phases):
\(I\) is the identity: \(I \cdot p = p \cdot I = p\) for all \(p\).
Each Pauli is self-inverse: \(X^2 = Y^2 = Z^2 = I\).
Products of distinct non-identity Paulis: \(XY = Z\), \(YX = Z\), \(YZ = X\), \(ZY = X\), \(ZX = Y\), \(XZ = Y\).
The inverse of a Pauli type is defined as the identity function, since each Pauli operator is self-inverse (up to global phase): \(p^{-1} = p\) for all \(p : \texttt{PauliType}\).
A Pauli type represents an actual error if it is not the identity:
For all \(a, b, c : \texttt{PauliType}\), we have \((a \cdot b) \cdot c = a \cdot (b \cdot c)\).
By case analysis on all combinations of \(a\), \(b\), and \(c\) (each ranging over \(\{ I, X, Y, Z\} \)), each case holds by reflexivity.
For all \(p : \texttt{PauliType}\), \(p \cdot p^{-1} = 1\).
Since \(p^{-1} = p\), this reduces to \(p \cdot p = I\), which holds by the self-inverse property of each Pauli type.
For all \(p : \texttt{PauliType}\), \(p^{-1} \cdot p = 1\).
Since \(p^{-1} = p\), this reduces to \(p \cdot p = I\), which holds by the self-inverse property.
Given types \(V\) and \(E\), a qubit location is an inductive type:
where \(v : V\) represents a vertex qubit and \(e : E\) represents an edge qubit.
A qubit location is a vertex qubit if it was constructed via the \(\operatorname {vertex}\) constructor:
A qubit location is an edge qubit if it was constructed via the \(\operatorname {edge}\) constructor:
Extracts the vertex index from a qubit location, returning \(\operatorname {some}(v)\) if the location is \(\operatorname {vertex}(v)\) and \(\operatorname {none}\) otherwise.
Extracts the edge index from a qubit location, returning \(\operatorname {some}(e)\) if the location is \(\operatorname {edge}(e)\) and \(\operatorname {none}\) otherwise.
If \(V\) and \(E\) are finite types, then
We construct an explicit equivalence between \(\texttt{QubitLoc}(V, E)\) and the sum type \(V \oplus E\): the map sends \(\operatorname {vertex}(v) \mapsto \operatorname {inl}(v)\) and \(\operatorname {edge}(e) \mapsto \operatorname {inr}(e)\), with inverse \(\operatorname {inl}(v) \mapsto \operatorname {vertex}(v)\) and \(\operatorname {inr}(e) \mapsto \operatorname {edge}(e)\). Both compositions are the identity by case analysis. Rewriting the cardinality via this equivalence and applying the formula for the cardinality of a sum type gives \(|V| + |E|\).
A space-fault over qubit types \(V, E\) is a structure consisting of:
qubit : \(\texttt{QubitLoc}(V, E)\) — the qubit where the error occurs,
time : \(\mathbb {N}\) — the time step when the error occurs,
pauliType : \(\texttt{PauliType}\) — the type of Pauli error (\(I\), \(X\), \(Y\), or \(Z\)).
The identity space-fault at a given qubit location \(q\) and time \(t\) is \(\langle q, t, I \rangle \), representing no error.
A space-fault \(f\) represents an actual error if \(\operatorname {isError}(f.\texttt{pauliType}) = \text{true}\), i.e., the Pauli type is not \(I\).
Given two space-faults \(f\) and \(g\) at the same qubit and time (i.e., \(f.\texttt{qubit} = g.\texttt{qubit}\) and \(f.\texttt{time} = g.\texttt{time}\)), their composition is:
The inverse of a space-fault \(f\) is \(\langle f.\texttt{qubit},\; f.\texttt{time},\; f.\texttt{pauliType}^{-1} \rangle \). Since Pauli operators are self-inverse, \(f^{-1}\) has the same Pauli type as \(f\).
A space-fault on a vertex qubit \(v\) at time \(t\) with Pauli type \(p\) is \(\langle \operatorname {vertex}(v), t, p \rangle \).
A space-fault on an edge qubit \(e\) at time \(t\) with Pauli type \(p\) is \(\langle \operatorname {edge}(e), t, p \rangle \).
A time-fault (measurement error) over measurement type \(M\) is a structure consisting of:
measurement : \(M\) — the measurement that is affected,
time : \(\mathbb {N}\) — the time step when the measurement occurs,
isFlipped : \(\texttt{Bool}\) — whether the classical outcome is flipped (\(\text{true}\) means error).
The identity time-fault at measurement \(m\) and time \(t\) is \(\langle m, t, \text{false} \rangle \), representing no measurement error.
An active time-fault at measurement \(m\) and time \(t\) is \(\langle m, t, \text{true} \rangle \), representing a flipped measurement outcome.
A time-fault \(f\) represents an actual error if \(f.\texttt{isFlipped} = \text{true}\).
Given two time-faults \(f\) and \(g\) at the same measurement and time, their composition is:
where \(\oplus \) denotes XOR (exclusive or).
The inverse of a time-fault \(f\) is \(f\) itself, since flipping is self-inverse (\(\text{flip} \oplus \text{flip} = \text{false}\)).
An initialization fault over qubit types \(V, E\) is a structure consisting of:
qubit : \(\texttt{QubitLoc}(V, E)\) — the qubit being initialized,
time : \(\mathbb {N}\) — the time step of initialization,
effectiveError : \(\texttt{PauliType}\) — the effective Pauli error applied after perfect initialization.
A faulty initialization of state \(|\psi \rangle \) is modeled as perfect initialization followed by an immediate space-fault.
An initialization fault \(f\) is converted to an equivalent space-fault:
The space-fault occurs at the same qubit and time as the initialization.
The identity initialization fault at qubit \(q\) and time \(t\) is \(\langle q, t, I \rangle \), representing no error during initialization.
An initialization fault \(f\) represents an actual error if \(\operatorname {isError}(f.\texttt{effectiveError}) = \text{true}\).
A spacetime fault over qubit types \(V, E\) and measurement type \(M\) is a structure consisting of:
\(\texttt{spaceErrors} : \texttt{QubitLoc}(V, E) \to \mathbb {N} \to \texttt{PauliType}\) — the Pauli error at each (qubit, time) location; identity means no error.
\(\texttt{timeErrors} : M \to \mathbb {N} \to \texttt{Bool}\) — whether each (measurement, time) has a flipped outcome; \(\text{false}\) means no error.
This functional representation allows efficient pointwise composition.
The identity spacetime fault has no errors anywhere:
for all qubits \(q\), measurements \(m\), and times \(t\).
The composition of spacetime faults \(f\) and \(g\) is defined pointwise:
The inverse of a spacetime fault \(f\) is:
since Pauli operators are self-inverse and XOR is self-inverse.
For all spacetime faults \(a, b, c\), we have \((a \cdot b) \cdot c = a \cdot (b \cdot c)\).
By extensionality, it suffices to show equality at each \((q, t)\) for space errors and each \((m, t)\) for time errors. For space errors, we apply associativity of Pauli multiplication. For time errors, we verify by case analysis on the boolean values of \(a.\texttt{timeErrors}(q, t)\), \(b.\texttt{timeErrors}(q, t)\), and \(c.\texttt{timeErrors}(q, t)\) that XOR is associative; each of the eight cases holds by reflexivity.
For all spacetime faults \(f\), \(1 \cdot f = f\).
By extensionality. For space errors, \(I \cdot f.\texttt{spaceErrors}(q, t) = f.\texttt{spaceErrors}(q, t)\) by left identity of Pauli multiplication. For time errors, \(\text{false} \oplus f.\texttt{timeErrors}(m, t) = f.\texttt{timeErrors}(m, t)\) by simplification.
For all spacetime faults \(f\), \(f \cdot 1 = f\).
By extensionality. For space errors, \(f.\texttt{spaceErrors}(q, t) \cdot I = f.\texttt{spaceErrors}(q, t)\) by right identity. For time errors, \(f.\texttt{timeErrors}(m, t) \oplus \text{false} = f.\texttt{timeErrors}(m, t)\) by simplification.
For all spacetime faults \(f\), \(f^{-1} \cdot f = 1\).
By extensionality. For space errors, \((f.\texttt{spaceErrors}(q, t))^{-1} \cdot f.\texttt{spaceErrors}(q, t) = I\) by the left inverse cancellation of Pauli types. For time errors, \(f.\texttt{timeErrors}(q, t) \oplus f.\texttt{timeErrors}(q, t) = \text{false}\) holds by case analysis on the boolean value (both cases yield \(\text{false}\) by reflexivity).
Given a single space-fault \(f\), the corresponding spacetime fault has:
and \(\texttt{timeErrors}(m, t) = \text{false}\) for all \(m, t\).
Given a single time-fault \(f\), the corresponding spacetime fault has \(\texttt{spaceErrors}(q, t) = I\) for all \(q, t\), and:
Given an initialization fault \(f\), the corresponding spacetime fault is obtained by first converting \(f\) to its equivalent space-fault via \(\operatorname {toSpaceFault}\), then embedding it via \(\operatorname {fromSpaceFault}\).
Given a spacetime fault \(f\) and a set of time steps \(T\), the set of space error locations is:
Given a spacetime fault \(f\) and a set of time steps \(T\), the set of time error locations is:
The weight of a spacetime fault \(f\) over a set of time steps \(T\) is the total number of non-trivial errors:
For any set of time steps \(T\), \(\operatorname {weight}(1, T) = 0\).
By simplification: the identity spacetime fault has \(\texttt{spaceErrors}(q,t) = I\) for all \(q, t\), so the space error locations filter yields the empty set; similarly \(\texttt{timeErrors}(m,t) = \text{false}\) for all \(m, t\), so the time error locations filter yields the empty set. Both cardinalities are \(0\).
A spacetime fault \(f\) is pure space if it has no time errors:
A spacetime fault \(f\) is pure time if it has no space errors:
For any space-fault \(f\), the spacetime fault \(\operatorname {fromSpaceFault}(f)\) is pure space.
By the definition of \(\operatorname {fromSpaceFault}\), all time errors are set to \(\text{false}\). By simplification, the pure space condition holds.
For any time-fault \(f\), the spacetime fault \(\operatorname {fromTimeFault}(f)\) is pure time.
By the definition of \(\operatorname {fromTimeFault}\), all space errors are set to \(I\). By simplification, the pure time condition holds.
The space-only component of a spacetime fault \(f\) retains the space errors and sets all time errors to \(\text{false}\):
The time-only component of a spacetime fault \(f\) sets all space errors to \(I\) and retains the time errors:
Every spacetime fault \(f\) decomposes as the product of its space and time components:
By extensionality, it suffices to verify equality at each component. For space errors at \((q, t)\): the product gives \(f.\texttt{spaceErrors}(q, t) \cdot I = f.\texttt{spaceErrors}(q, t)\) by simplification (right identity of Pauli multiplication). For time errors at \((m, t)\): the product gives \(\text{false} \oplus f.\texttt{timeErrors}(q, t)\). By case analysis on \(f.\texttt{timeErrors}(q, t)\): if \(\text{false}\), then \(\text{false} \oplus \text{false} = \text{false}\); if \(\text{true}\), then \(\text{false} \oplus \text{true} = \text{true}\). Both cases hold by reflexivity.
The set of pure space-faults forms a subgroup of \(\texttt{SpacetimeFault}(V, E, M)\):
This is verified to be closed under multiplication (since \(\text{false} \oplus \text{false} = \text{false}\)), contains the identity (which has all time errors \(\text{false}\)), and is closed under inversion (since the inverse preserves time errors).
The set of pure time-faults forms a subgroup of \(\texttt{SpacetimeFault}(V, E, M)\):
This is verified to be closed under multiplication (since \(I \cdot I = I\)), contains the identity (which has all space errors \(I\)), and is closed under inversion (since \(I^{-1} = I\)).