merge noisfy expectations to original expectations

Author: yutuer21

tensorcircuit/abstractcircuit.py

@@ -866,6 +866,9 @@ def expectation(
         self,
         *ops: Tuple[tn.Node, List[int]],
         reuse: bool = True,
+        noise_conf: Optional[Any] = None,
+        nmc: int = 1000,
+        status: Optional[Tensor] = None,
         **kws: Any,
     ) -> Tensor:
         raise NotImplementedError
@@ -876,6 +879,9 @@ def expectation_ps(
         y: Optional[Sequence[int]] = None,
         z: Optional[Sequence[int]] = None,
         reuse: bool = True,
+        noise_conf: Optional[Any] = None,
+        nmc: int = 1000,
+        status: Optional[Tensor] = None,
         **kws: Any,
     ) -> Tensor:
         """
@@ -890,6 +896,20 @@ def expectation_ps(
         >>> c.expectation_ps(x=[1], z=[0])
         array(-0.99999994+0.j, dtype=complex64)
 
+        >>> c = tc.Circuit(2)
+        >>> c.cnot(0, 1)
+        >>> c.rx(0, theta=0.4)
+        >>> c.rx(1, theta=0.8)
+        >>> c.h(0)
+        >>> c.h(1)
+        >>> error1 = tc.channels.generaldepolarizingchannel(0.1, 1)
+        >>> error2 = tc.channels.generaldepolarizingchannel(0.06, 2)
+        >>> noise_conf = NoiseConf()
+        >>> noise_conf.add_noise("rx", error1)
+        >>> noise_conf.add_noise("cnot", [error2], [[0, 1]])
+        >>> c.expectation_ps(x=[0], noise_conf=noise_conf, nmc=10000)
+        (0.46274087-3.764033e-09j)
+
         :param x: sites to apply X gate, defaults to None
         :type x: Optional[Sequence[int]], optional
         :param y: sites to apply Y gate, defaults to None
@@ -898,6 +918,13 @@ def expectation_ps(
         :type z: Optional[Sequence[int]], optional
         :param reuse: whether to cache and reuse the wavefunction, defaults to True
         :type reuse: bool, optional
+        :param noise_conf: Noise Configuration, defaults to None
+        :type noise_conf: Optional[NoiseConf], optional
+        :param nmc: repetition time for Monte Carlo sampling for noisfy calculation, defaults to 1000
+        :type nmc: int, optional
+        :param status: external randomness given by tensor uniformly from [0, 1], defaults to None,
+            used for noisfy circuit sampling
+        :type status: Optional[Tensor], optional
         :return: Expectation value
         :rtype: Tensor
         """
@@ -911,4 +938,6 @@ def expectation_ps(
         if z is not None:
             for i in z:
                 obs.append([gates.z(), [i]])  # type: ignore
-        return self.expectation(*obs, reuse=reuse, **kws)  # type: ignore
+        return self.expectation(
+            *obs, reuse=reuse, noise_conf=noise_conf, nmc=nmc, status=status, **kws  # type: ignore
+        )

tensorcircuit/basecircuit.py

@@ -26,6 +26,7 @@
 from .simplify import _split_two_qubit_gate
 from .utils import arg_alias
 
+
 Gate = gates.Gate
 Tensor = Any
 
@@ -613,6 +614,9 @@ def sample_expectation_ps(
         random_generator: Optional[Any] = None,
         status: Optional[Tensor] = None,
         readout_error: Optional[Sequence[Any]] = None,
+        noise_conf: Optional[Any] = None,
+        nmc: int = 1000,
+        statusc: Optional[Tensor] = None,
         **kws: Any,
     ) -> Tensor:
         """
@@ -630,6 +634,22 @@ def sample_expectation_ps(
         >>> readout_error.append([0.4,0.7])
         >>> c.sample_expectation_ps(x=[0], y=[1],readout_error = readout_error)
 
+        >>> c = tc.Circuit(2)
+        >>> c.cnot(0, 1)
+        >>> c.rx(0, theta=0.4)
+        >>> c.rx(1, theta=0.8)
+        >>> c.h(0)
+        >>> c.h(1)
+        >>> error1 = tc.channels.generaldepolarizingchannel(0.1, 1)
+        >>> error2 = tc.channels.generaldepolarizingchannel(0.06, 2)
+        >>> readout_error = [[0.9, 0.75],[0.4, 0.7]]
+        >>> noise_conf = NoiseConf()
+        >>> noise_conf.add_noise("rx", error1)
+        >>> noise_conf.add_noise("cnot", [error2], [[0, 1]])
+        >>> noise_conf.add_noise("readout", readout_error)
+        >>> c.sample_expectation_ps(x=[0], noise_conf=noise_conf, nmc=10000)
+        0.44766843
+
         :param x: index for Pauli X, defaults to None
         :type x: Optional[Sequence[int]], optional
         :param y: index for Pauli Y, defaults to None
@@ -645,62 +665,85 @@ def sample_expectation_ps(
         :type status: Optional[Tensor]
         :param readout_error: readout_error, defaults to None
         :type readout_error: Optional[Sequence[Any]]. Tensor, List, Tuple
+        :param noise_conf: Noise Configuration, defaults to None
+        :type noise_conf: Optional[NoiseConf], optional
+        :param nmc: repetition time for Monte Carlo sampling for noisfy calculation, defaults to 1000
+        :type nmc: int, optional
+        :param statusc: external randomness given by tensor uniformly from [0, 1], defaults to None,
+            used for noisfy circuit sampling
+        :type statusc: Optional[Tensor], optional
         :return: [description]
         :rtype: Tensor
         """
-        inputs_nodes, _ = self._copy_state_tensor()
-        inputs = inputs_nodes[0].tensor
-        if self.is_dm is False:
-            c = type(self)(self._nqubits, inputs=inputs)  # type: ignore
-        else:
-            c = type(self)(self._nqubits, dminputs=inputs)  # type: ignore
-        if x is None:
-            x = []
-        if y is None:
-            y = []
-        if z is None:
-            z = []
-        for i in x:
-            c.H(i)  # type: ignore
-        for i in y:
-            c.rx(i, theta=np.pi / 2)  # type: ignore
-        s = c.state()  # type: ignore
-        if self.is_dm is False:
-            p = backend.abs(s) ** 2
-        else:
-            p = backend.abs(backend.diagonal(s))
-
-        # readout error
-        if readout_error is not None:
-            p = self.readouterror_bs(readout_error, p)
-
-        x = list(x)
-        y = list(y)
-        z = list(z)
-        if shots is None:
-            mc = measurement_counts(
-                p,
-                counts=shots,
-                format="count_vector",
-                random_generator=random_generator,
-                status=status,
-                jittable=True,
-                is_prob=True,
-            )
-            r = correlation_from_counts(x + y + z, mc)
+        from .noisemodel import sample_expectation_ps_noisfy
+
+        if noise_conf is None:
+            inputs_nodes, _ = self._copy_state_tensor()
+            inputs = inputs_nodes[0].tensor
+            if self.is_dm is False:
+                c = type(self)(self._nqubits, inputs=inputs)  # type: ignore
+            else:
+                c = type(self)(self._nqubits, dminputs=inputs)  # type: ignore
+            if x is None:
+                x = []
+            if y is None:
+                y = []
+            if z is None:
+                z = []
+            for i in x:
+                c.H(i)  # type: ignore
+            for i in y:
+                c.rx(i, theta=np.pi / 2)  # type: ignore
+            s = c.state()  # type: ignore
+            if self.is_dm is False:
+                p = backend.abs(s) ** 2
+            else:
+                p = backend.abs(backend.diagonal(s))
+
+            # readout error
+            if readout_error is not None:
+                p = self.readouterror_bs(readout_error, p)
+
+            x = list(x)
+            y = list(y)
+            z = list(z)
+            if shots is None:
+                mc = measurement_counts(
+                    p,
+                    counts=shots,
+                    format="count_vector",
+                    random_generator=random_generator,
+                    status=status,
+                    jittable=True,
+                    is_prob=True,
+                )
+                r = correlation_from_counts(x + y + z, mc)
+            else:
+                mc = measurement_counts(
+                    p,
+                    counts=shots,
+                    format="sample_bin",
+                    random_generator=random_generator,
+                    status=status,
+                    jittable=True,
+                    is_prob=True,
+                )
+                r = correlation_from_samples(x + y + z, mc, self._nqubits)
+            # TODO(@refraction-ray): analytical standard deviation
+            return r
         else:
-            mc = measurement_counts(
-                p,
-                counts=shots,
-                format="sample_bin",
-                random_generator=random_generator,
+            return sample_expectation_ps_noisfy(
+                c=self,
+                x=x,
+                y=y,
+                z=z,
+                noise_conf=noise_conf,
+                nmc=nmc,
+                shots=shots,
+                statusc=statusc,
                 status=status,
-                jittable=True,
-                is_prob=True,
+                **kws,
             )
-            r = correlation_from_samples(x + y + z, mc, self._nqubits)
-        # TODO(@refraction-ray): analytical standard deviation
-        return r
 
     sexpps = sample_expectation_ps
 

tensorcircuit/channels.py

@@ -982,6 +982,6 @@ def composedkraus(kraus1: KrausList, kraus2: KrausList) -> KrausList:
             new_kraus.append(k)
     return KrausList(
         new_kraus,
-        name="composed_channel",
+        name=kraus1.name + "_" + kraus2.name,
         is_unitary=kraus1.is_unitary and kraus2.is_unitary,
     )

tensorcircuit/circuit.py

@@ -772,6 +772,10 @@ def expectation(  # type: ignore
         *ops: Tuple[tn.Node, List[int]],
         reuse: bool = True,
         enable_lightcone: bool = False,
+        noise_conf: Optional[Any] = None,
+        nmc: int = 1000,
+        status: Optional[Tensor] = None,
+        **kws: Any,
     ) -> Tensor:
         """
         Compute the expectation of corresponding operators.
@@ -783,6 +787,20 @@ def expectation(  # type: ignore
         >>> c.expectation((tc.gates.z(), [0]))
         array(0.+0.j, dtype=complex64)
 
+        >>> c = tc.Circuit(2)
+        >>> c.cnot(0, 1)
+        >>> c.rx(0, theta=0.4)
+        >>> c.rx(1, theta=0.8)
+        >>> c.h(0)
+        >>> c.h(1)
+        >>> error1 = tc.channels.generaldepolarizingchannel(0.1, 1)
+        >>> error2 = tc.channels.generaldepolarizingchannel(0.06, 2)
+        >>> noise_conf = NoiseConf()
+        >>> noise_conf.add_noise("rx", error1)
+        >>> noise_conf.add_noise("cnot", [error2], [[0, 1]])
+        >>> c.expectation((tc.gates.x(), [0]), noise_conf=noise_conf, nmc=10000)
+        (0.46274087-3.764033e-09j)
+
         :param ops: Operator and its position on the circuit,
             eg. ``(tc.gates.z(), [1, ]), (tc.gates.x(), [2, ])`` is for operator :math:`Z_1X_2`.
         :type ops: Tuple[tn.Node, List[int]]
@@ -791,22 +809,41 @@ def expectation(  # type: ignore
         :type reuse: bool, optional
         :param enable_lightcone: whether enable light cone simplification, defaults to False
         :type enable_lightcone: bool, optional
+        :param noise_conf: Noise Configuration, defaults to None
+        :type noise_conf: Optional[NoiseConf], optional
+        :param nmc: repetition time for Monte Carlo sampling for noisfy calculation, defaults to 1000
+        :type nmc: int, optional
+        :param status: external randomness given by tensor uniformly from [0, 1], defaults to None,
+            used for noisfy circuit sampling
+        :type status: Optional[Tensor], optional
         :raises ValueError: "Cannot measure two operators in one index"
         :return: Tensor with one element
         :rtype: Tensor
         """
-        # if not reuse:
-        #     nodes1, edge1 = self._copy()
-        #     nodes2, edge2 = self._copy(conj=True)
-        # else:  # reuse
-
-        # self._nodes = nodes1
-        if enable_lightcone:
-            reuse = False
-        nodes1 = self.expectation_before(*ops, reuse=reuse)
-        if enable_lightcone:
-            nodes1 = _full_light_cone_cancel(nodes1)
-        return contractor(nodes1).tensor
+        from .noisemodel import expectation_noisfy
+
+        if noise_conf is None:
+            # if not reuse:
+            #     nodes1, edge1 = self._copy()
+            #     nodes2, edge2 = self._copy(conj=True)
+            # else:  # reuse
+
+            # self._nodes = nodes1
+            if enable_lightcone:
+                reuse = False
+            nodes1 = self.expectation_before(*ops, reuse=reuse)
+            if enable_lightcone:
+                nodes1 = _full_light_cone_cancel(nodes1)
+            return contractor(nodes1).tensor
+        else:
+            return expectation_noisfy(
+                self,
+                *ops,
+                noise_conf=noise_conf,
+                nmc=nmc,
+                status=status,
+                **kws,
+            )
 
 
 Circuit._meta_apply()

tensorcircuit/densitymatrix.py

@@ -265,7 +265,13 @@ def get_dm_as_quoperator(self) -> QuOperator:
         return QuOperator(edges[: self._nqubits], edges[self._nqubits :])
 
     def expectation(
-        self, *ops: Tuple[tn.Node, List[int]], reuse: bool = True, **kws: Any
+        self,
+        *ops: Tuple[tn.Node, List[int]],
+        reuse: bool = True,
+        noise_conf: Optional[Any] = None,
+        nmc: int = 1000,
+        status: Optional[Tensor] = None,
+        **kws: Any
     ) -> tn.Node.tensor:
         """
         Compute the expectation of corresponding operators.
@@ -275,11 +281,30 @@ def expectation(
         :type ops: Tuple[tn.Node, List[int]]
         :param reuse: whether contract the density matrix in advance, defaults to True
         :type reuse: bool
+        :param noise_conf: Noise Configuration, defaults to None
+        :type noise_conf: Optional[NoiseConf], optional
+        :param nmc: repetition time for Monte Carlo sampling for noisfy calculation, defaults to 1000
+        :type nmc: int
+        :param status: external randomness given by tensor uniformly from [0, 1], defaults to None,
+            used for noisfy circuit sampling
+        :type status: Optional[Tensor], optional
         :return: Tensor with one element
         :rtype: Tensor
         """
-        nodes = self.expectation_before(*ops, reuse=reuse)
-        return contractor(nodes).tensor
+        from .noisemodel import expectation_noisfy
+
+        if noise_conf is None:
+            nodes = self.expectation_before(*ops, reuse=reuse)
+            return contractor(nodes).tensor
+        else:
+            return expectation_noisfy(
+                self,
+                *ops,
+                noise_conf=noise_conf,
+                nmc=nmc,
+                status=status,
+                **kws,
+            )
 
     @staticmethod
     def check_density_matrix(dm: Tensor) -> None:

tensorcircuit/mpscircuit.py

@@ -821,6 +821,7 @@ def expectation(  # type: ignore
         conj: bool = True,
         normalize: bool = False,
         split: Optional[Dict[str, Any]] = None,
+        **kws: Any,
     ) -> Tensor:
         """
         Compute the expectation of corresponding operators in the form of tensor.