Generalize effective noise channels

pulser-simulation/pulser_simulation/simconfig.py

@@ -192,11 +192,7 @@ def _check_noise_types(self) -> None:
         dephasing_on = "dephasing" in self.noise
         depolarizing_on = "depolarizing" in self.noise
         eff_noise_on = "eff_noise" in self.noise
-        eff_noise_conflict = (
-            (dephasing_on and depolarizing_on)
-            or (depolarizing_on and eff_noise_on)
-            or (dephasing_on and eff_noise_on)
-        )
+        eff_noise_conflict = dephasing_on + depolarizing_on + eff_noise_on > 1
         if eff_noise_conflict:
             raise NotImplementedError(
                 "Depolarizing, dephasing and eff_noise channels"
@@ -228,7 +224,7 @@ def _check_eff_noise(self) -> None:
             for prob in self.eff_noise_probs:
                 if not isinstance(prob, float):
                     raise TypeError(
-                        "eff_noise_probs is a list of floats"
+                        "eff_noise_probs is a list of floats,"
                         f" it must not contain a {type(prob)}."
                     )
 

pulser-simulation/pulser_simulation/simulation.py

@@ -201,7 +201,7 @@ def set_config(self, cfg: SimConfig) -> None:
         # Noise, samples and Hamiltonian update routine
         self._construct_hamiltonian()
 
-        Kraus_ops = []
+        kraus_ops = []
         if "dephasing" in self.config.noise:
             if self.basis_name == "digital" or self.basis_name == "all":
                 # Go back to previous config
@@ -226,7 +226,7 @@ def set_config(self, cfg: SimConfig) -> None:
                 np.sqrt((1 - prob) ** n)
                 * qutip.tensor([self.op_matrix["I"] for _ in range(n)])
             ]
-            Kraus_ops.append(k * qutip.sigmaz())
+            kraus_ops.append(k * qutip.sigmaz())
 
         if "depolarizing" in self.config.noise:
             if self.basis_name == "digital" or self.basis_name == "all":
@@ -253,9 +253,9 @@ def set_config(self, cfg: SimConfig) -> None:
                 np.sqrt((1 - 3 * prob) ** n)
                 * qutip.tensor([self.op_matrix["I"] for _ in range(n)])
             ]
-            Kraus_ops.append(k * qutip.sigmax())
-            Kraus_ops.append(k * qutip.sigmay())
-            Kraus_ops.append(k * qutip.sigmaz())
+            kraus_ops.append(k * qutip.sigmax())
+            kraus_ops.append(k * qutip.sigmay())
+            kraus_ops.append(k * qutip.sigmaz())
 
         if "eff_noise" in self.config.noise:
             if self.basis_name == "digital" or self.basis_name == "all":
@@ -290,10 +290,10 @@ def set_config(self, cfg: SimConfig) -> None:
                     self.config.eff_noise_probs[i] * prob_id ** (n - 1)
                 )
                 K_op = k * self.config.eff_noise_opers[i]
-                Kraus_ops.append(K_op)
+                kraus_ops.append(K_op)
 
         # Building collapse operators
-        for operator in Kraus_ops:
+        for operator in kraus_ops:
             self._collapse_ops += [
                 self.build_operator([(operator, [qid])])
                 for qid in self._qid_index

tests/test_simconfig.py

@@ -29,7 +29,7 @@ def matrices():
     return pauli
 
 
-def test_init(matrices):
+def test_init1(matrices):
     config = SimConfig(
         noise=(
             "SPAM",
@@ -70,26 +70,23 @@ def test_init(matrices):
         ValueError, match="The standard deviation in amplitude"
     ):
         SimConfig(amp_sigma=-0.001)
+
+
+@pytest.mark.parametrize(
+    "noise_sample,",
+    [
+        ("dephasing", "depolarizing"),
+        ("eff_noise", "depolarizing"),
+        ("eff_noise", "dephasing"),
+        ("depolarizing", "eff_noise", "dephasing"),
+    ],
+)
+def test_init2(matrices, noise_sample):
     with pytest.raises(
         NotImplementedError,
         match="Depolarizing, dephasing and eff_noise channels",
     ):
-        SimConfig(noise=("dephasing", "depolarizing"))
-    with pytest.raises(
-        NotImplementedError,
-        match="Depolarizing, dephasing and eff_noise channels",
-    ):
-        SimConfig(noise=("eff_noise", "depolarizing"))
-    with pytest.raises(
-        NotImplementedError,
-        match="Depolarizing, dephasing and eff_noise channels",
-    ):
-        SimConfig(noise=("dephasing", "eff_noise"))
-    with pytest.raises(
-        NotImplementedError,
-        match="Depolarizing, dephasing and eff_noise channels",
-    ):
-        SimConfig(noise=("dephasing", "depolarizing", "eff_noise"))
+        SimConfig(noise=noise_sample)
     with pytest.raises(ValueError, match="The operators list length"):
         SimConfig(noise=("eff_noise"), eff_noise_probs=[1.0])
     with pytest.raises(ValueError, match="Fill the general noise parameters."):

tests/test_simulation.py

@@ -644,6 +644,8 @@ def test_depolarizing():
         seq, sampling_rate=0.01, config=SimConfig(noise="depolarizing")
     )
     assert sim.run().sample_final_state() == Counter({"0": 587, "1": 413})
+    trace_2 = sim.run()._results[-1] ** 2
+    assert np.trace(trace_2) < 1 and not np.isclose(np.trace(trace_2), 1)
     assert len(sim._collapse_ops) != 0
     with pytest.warns(UserWarning, match="first-order"):
         reg = Register.from_coordinates([(0, 0), (0, 6)], prefix="q")
@@ -671,10 +673,16 @@ def test_eff_noise(matrices):
         config=SimConfig(
             noise="eff_noise",
             eff_noise_opers=[matrices["I"], matrices["Z"]],
-            eff_noise_probs=[0.95, 0.05],
+            eff_noise_probs=[0.975, 0.025],
         ),
     )
-    assert sim.run().sample_final_state() == Counter({"0": 595, "1": 405})
+    sim_dph = Simulation(
+        seq, sampling_rate=0.01, config=SimConfig(noise="dephasing")
+    )
+    assert (
+        sim._collapse_ops == sim_dph._collapse_ops
+        and sim.run().states[-1] == sim_dph.run().states[-1]
+    )
     assert len(sim._collapse_ops) != 0
     with pytest.warns(UserWarning, match="first-order"):
         reg = Register.from_coordinates([(0, 0), (0, 8)], prefix="q")