Make all GeminiOneZoneModels use correlated noise (#459)

Implements #448.

The test on the noisy GHZ fidelity now fails. On the one hand, of
course, since the fidelities did change. On the other hand, however, we
now somehow get a singular matrix for two qubits which produces a
corresponding `np.LinAlg` warning and results in a fidelity > 1. FWIW,
checking manually you can see that the matrices are pretty close, so the
issue really seems to be with the way the fidelity is calculated.

What's also kind of fishy: the fidelity for three qubits increased
(slightly). Before, we had: 0.9518, now it's 0.957. @tcochran-quera
@lamq317 did you see something similar when comparing the one-zone model
with and without correlated noise or is there something wrong here?


You can now also pass in the correlated rates either as dictionary or as
array

```python
model = GeminiOneZoneModel(cz_paired_correlated_rates = np.array(...))
model = GeminiOneZoneModel(cz_paired_error_probabilities = {"II": 0.9, "XX": ...})
```

Not sure about the naming though.

---------

Co-authored-by: Luis Martinez <[email protected]>
Co-authored-by: Tyler A Cochran <[email protected]>

Author: 3 people

src/bloqade/cirq_utils/noise/__init__.py

@@ -3,8 +3,6 @@
 from .model import (
     GeminiOneZoneNoiseModel as GeminiOneZoneNoiseModel,
     GeminiTwoZoneNoiseModel as GeminiTwoZoneNoiseModel,
-    GeminiOneZoneNoiseModelABC as GeminiOneZoneNoiseModelABC,
-    GeminiOneZoneNoiseModelCorrelated as GeminiOneZoneNoiseModelCorrelated,
     GeminiOneZoneNoiseModelConflictGraphMoves as GeminiOneZoneNoiseModelConflictGraphMoves,
 )
 from .transform import transform_circuit as transform_circuit

src/bloqade/cirq_utils/noise/_two_zone_utils.py

@@ -264,24 +264,25 @@ def get_gate_error_channel(
     moment: cirq.Moment,
     sq_loc_rates: np.ndarray,
     sq_glob_rates: np.ndarray,
-    cz_rates: np.ndarray,
+    two_qubit_pauli: cirq.Gate,
     unp_cz_rates: np.ndarray,
+    nqubs: int,
 ):
     """Applies gate errors to the circuit
 
     Args:
         moment: A cirq.Moment object.
         sq_loc_rates: single local qubit rotation Pauli noise channel parameters (px, py, pz)
         sq_glob_rates: single global qubit rotation Pauli noise channel parameters (px,py,pz)
-        cz_rates: two-qubit rotation Pauli noise channel parameters (ctrl_px, ctrl_py,ctrl_pz,tar_px,tar_py,tar_pz)
+        two_qubit_pauli: correlated two-qubit noise channel (ctrl_px, ctrl_py,ctrl_pz,tar_px,tar_py,tar_pz)
         unp_cz_rates: Pauli noise channel parameters for qubits in the gate zone and outside blockade radius
+        nqubs: total number of qubits
     Returns:
         A new cirq.Moment object with the gate errors applied.
     """
     # Check for the moment (layer) layout: global single qubit gates, or mixture of single qubit gates and two qubit gates
 
     gates_in_layer = extract_u3_and_cz_qargs(moment)
-    # new_moment = cirq.Moment()
     new_moments = cirq.Circuit()
 
     if gates_in_layer["cz"] == []:
@@ -294,7 +295,7 @@ def get_gate_error_channel(
         if all(
             np.all(np.isclose(element, gates_in_layer["angles"][0]))
             for element in gates_in_layer["angles"]
-        ):
+        ) and nqubs == len(gates_in_layer["u3"]):
             pauli_channel = cirq.AsymmetricDepolarizingChannel(
                 p_x=sq_glob_rates[0], p_y=sq_glob_rates[1], p_z=sq_glob_rates[2]
             )
@@ -314,31 +315,22 @@ def get_gate_error_channel(
 
     else:
         # there is at least one CZ gate...
-        ctrl_pauli_channel = cirq.AsymmetricDepolarizingChannel(
-            p_x=cz_rates[0], p_y=cz_rates[1], p_z=cz_rates[2]
-        )
-        tar_pauli_channel = cirq.AsymmetricDepolarizingChannel(
-            p_x=cz_rates[3], p_y=cz_rates[4], p_z=cz_rates[5]
-        )
         loc_rot_pauli_channel = cirq.AsymmetricDepolarizingChannel(
             p_x=sq_loc_rates[0], p_y=sq_loc_rates[1], p_z=sq_loc_rates[2]
         )
         unp_cz_pauli_channel = cirq.AsymmetricDepolarizingChannel(
             p_x=unp_cz_rates[0], p_y=unp_cz_rates[1], p_z=unp_cz_rates[2]
         )
 
+        # apply correlated noise to paired qubits
         for qub in gates_in_layer["cz"]:
-            new_moments.append(ctrl_pauli_channel(qub[0]))
-            new_moments.append(tar_pauli_channel(qub[1]))
-            # new_moment=new_moment+ctrl_pauli_channel(qub[0])
-            # new_moment=new_moment+tar_pauli_channel(qub[1])
+            new_moments.append(two_qubit_pauli.on(qub[0], qub[1]))
 
         for qub in gates_in_layer["u3"]:
             new_moments.append(
                 unp_cz_pauli_channel(qub[0])
             )  ###qubits in the gate zone get unpaired_cz error
             new_moments.append(loc_rot_pauli_channel(qub[0]))
-            # new_moment = new_moment + loc_rot_pauli_channel(qub[0])
 
     return new_moments