tensorcircuit-nightly 1.2.1.dev20250724__py3-none-any.whl → 1.2.1.dev20250726__py3-none-any.whl

tensorcircuit/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.2.1.dev20250724"
+__version__ = "1.2.1.dev20250726"
 __author__ = "TensorCircuit Authors"
 __creator__ = "refraction-ray"
 

tensorcircuit/backends/jax_backend.py

@@ -442,7 +442,14 @@ class JaxBackend(jax_backend.JaxBackend, ExtendedBackend):  # type: ignore
     def to_dlpack(self, a: Tensor) -> Any:
         import jax.dlpack
 
-        return jax.dlpack.to_dlpack(a)
+        try:
+            return jax.dlpack.to_dlpack(a)  # type: ignore
+        except AttributeError:  # jax >v0.7
+            # jax.dlpack.to_dlpack was deprecated in JAX v0.6.0 and removed in JAX v0.7.0.
+            # Please use the newer DLPack API based on __dlpack__ and __dlpack_device__ instead.
+            # Typically, you can pass a JAX array directly to the `from_dlpack` function of
+            # another framework without using `to_dlpack`.
+            return a.__dlpack__()
 
     def set_random_state(
         self, seed: Optional[Union[int, PRNGKeyArray]] = None, get_only: bool = False

tensorcircuit/circuit.py

@@ -231,6 +231,25 @@ class Circuit(BaseCircuit):
         pz: float,
         status: Optional[float] = None,
     ) -> float:
+        """
+        Apply a depolarizing channel to the circuit in a Monte Carlo way.
+        For each call, one of the Pauli gates (X, Y, Z) or an Identity gate is applied to the qubit
+        at the given index based on the probabilities `px`, `py`, and `pz`.
+
+        :param index: The index of the qubit to apply the depolarizing channel on.
+        :type index: int
+        :param px: The probability of applying an X gate.
+        :type px: float
+        :param py: The probability of applying a Y gate.
+        :type py: float
+        :param pz: The probability of applying a Z gate.
+        :type pz: float
+        :param status: A random number between 0 and 1 to determine which gate to apply. If None,
+                       a random number is generated automatically. Defaults to None.
+        :type status: Optional[float], optional
+        :return: Returns 0.0. The function modifies the circuit in place.
+        :rtype: float
+        """
         if status is None:
             status = backend.implicit_randu()[0]
         g = backend.cond(
@@ -323,6 +342,35 @@ class Circuit(BaseCircuit):
         status: Optional[float] = None,
         name: Optional[str] = None,
     ) -> Tensor:
+        """
+        Apply a unitary Kraus channel to the circuit using a Monte Carlo approach. This method is functionally
+        similar to `unitary_kraus` but uses `backend.switch` for selecting the Kraus operator, which can have
+        different performance characteristics on some backends.
+
+        A random Kraus operator from the provided list is applied to the circuit based on the given probabilities.
+        This method is jittable and suitable for simulating noisy quantum circuits where the noise is represented
+        by unitary Kraus operators.
+
+        .. warning::
+            This method may have issues with `vmap` due to potential concurrent access locks, potentially related with
+            `backend.switch`. `unitary_kraus` is generally recommended.
+
+        :param kraus: A sequence of `Gate` objects representing the unitary Kraus operators.
+        :type kraus: Sequence[Gate]
+        :param index: The qubit indices on which to apply the Kraus channel.
+        :type index: int
+        :param prob: A sequence of probabilities corresponding to each Kraus operator. If None, probabilities
+                     are derived from the operators themselves. Defaults to None.
+        :type prob: Optional[Sequence[float]], optional
+        :param status: A random number between 0 and 1 to determine which Kraus operator to apply. If None,
+                       a random number is generated automatically. Defaults to None.
+        :type status: Optional[float], optional
+        :param name: An optional name for the operation. Defaults to None.
+        :type name: Optional[str], optional
+        :return: A tensor indicating which Kraus operator was applied.
+        :rtype: Tensor
+        """
+
         # dont use, has issue conflicting with vmap, concurrent access lock emerged
         # potential issue raised from switch
         # general impl from Monte Carlo trajectory depolarizing above

tensorcircuit/cons.py

@@ -516,8 +516,8 @@ def _get_path_cache_friendly(
     nodes = list(nodes)
 
     nodes_new = sorted(nodes, key=lambda node: getattr(node, "_stable_id_", -1))
-    if isinstance(algorithm, list):
-        return algorithm, nodes_new
+    # if isinstance(algorithm, list):
+    #     return algorithm, [nodes_new]
 
     all_edges = tn.get_all_edges(nodes_new)
     all_edges_sorted = sorted_edges(all_edges)
@@ -693,6 +693,51 @@ def _base(
     return final_node
 
 
+class NodesReturn(Exception):
+    """
+    Intentionally stop execution to return a value.
+    """
+
+    def __init__(self, value_to_return: Any):
+        self.value = value_to_return
+        super().__init__(
+            f"Intentionally stopping execution to return: {value_to_return}"
+        )
+
+
+def _get_sorted_nodes(nodes: List[Any], *args: Any, **kws: Any) -> Any:
+    nodes_new = sorted(nodes, key=lambda node: getattr(node, "_stable_id_", -1))
+    raise NodesReturn(nodes_new)
+
+
+def function_nodes_capture(func: Callable[[Any], Any]) -> Callable[[Any], Any]:
+    @wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        with runtime_contractor(method="before"):
+            try:
+                result = func(*args, **kwargs)
+                return result
+            except NodesReturn as e:
+                return e.value
+
+    return wrapper
+
+
+@contextmanager
+def runtime_nodes_capture(key: str = "nodes") -> Iterator[Any]:
+    old_contractor = getattr(thismodule, "contractor")
+    set_contractor(method="before")
+    captured_value: Dict[str, List[tn.Node]] = {}
+    try:
+        yield captured_value
+    except NodesReturn as e:
+        captured_value[key] = e.value
+    finally:
+        for module in sys.modules:
+            if module.startswith(package_name):
+                setattr(sys.modules[module], "contractor", old_contractor)
+
+
 def custom(
     nodes: List[Any],
     optimizer: Any,
@@ -763,6 +808,16 @@ def custom_stateful(
 
 # only work for custom
 def contraction_info_decorator(algorithm: Callable[..., Any]) -> Callable[..., Any]:
+    """Decorator to add contraction information logging to an optimizer.
+
+    This decorator wraps an optimization algorithm and prints detailed information
+    about the contraction cost (FLOPs, size, write) and path finding time.
+
+    :param algorithm: The optimization algorithm to decorate.
+    :type algorithm: Callable[..., Any]
+    :return: The decorated optimization algorithm.
+    :rtype: Callable[..., Any]
+    """
     from cotengra import ContractionTree
 
     def new_algorithm(
@@ -869,6 +924,9 @@ def set_contractor(
             **kws,
         )
 
+    elif method == "before":  # a hack way to get the nodes
+        cf = _get_sorted_nodes
+
     else:
         # cf = getattr(tn.contractors, method, None)
         # if not cf:

tensorcircuit/fgs.py

@@ -73,17 +73,26 @@ class FGSSimulator:
         cmatrix: Optional[Tensor] = None,
     ):
         """
-        _summary_
+        Initializes the Fermion Gaussian State (FGS) simulator.
 
-        :param L: system size
+        The state can be initialized in one of four ways:
+        1. By specifying the system size `L` and a list of `filled` sites, creating a product state.
+        2. By providing a quadratic Hamiltonian `hc`, the ground state of which is used as the initial state.
+        3. By directly providing the `alpha` matrix, which defines the Bogoliubov transformation.
+        4. For debugging, by providing a pre-computed correlation matrix `cmatrix`.
+
+        :param L: The number of fermionic sites (system size).
         :type L: int
-        :param filled: the fermion site that is fully occupied, defaults to None
+        :param filled: A list of site indices that are occupied by fermions in the initial state.
+            Defaults to None (no sites filled).
         :type filled: Optional[List[int]], optional
-        :param alpha: directly specify the alpha tensor as the input
+        :param alpha: The matrix defining the Bogoliubov transformation from the vacuum state, of shape `(2L, L)`.
+                      If provided, it directly specifies the initial state. Defaults to None.
         :type alpha: Optional[Tensor], optional
-        :param hc: the input is given as the ground state of quadratic Hamiltonian ``hc``
+        :param hc: A quadratic Hamiltonian. The ground state of this Hamiltonian will be used as the initial state.
+                   Defaults to None.
         :type hc: Optional[Tensor], optional
-        :param cmatrix: only used for debug, defaults to None
+        :param cmatrix: A pre-computed correlation matrix, primarily for debugging purposes. Defaults to None.
         :type cmatrix: Optional[Tensor], optional
         """
         if filled is None:
@@ -105,6 +114,19 @@ class FGSSimulator:
     def fermion_diagonalization(
         cls, hc: Tensor, L: int
     ) -> Tuple[Tensor, Tensor, Tensor]:
+        """
+        Diagonalizes a quadratic fermionic Hamiltonian.
+
+        This method computes the eigenvalues, eigenvectors, and the alpha matrix for a given
+        quadratic Hamiltonian `hc`.
+
+        :param hc: The quadratic Hamiltonian to be diagonalized.
+        :type hc: Tensor
+        :param L: The number of fermionic sites.
+        :type L: int
+        :return: A tuple containing the eigenvalues, eigenvectors, and the alpha matrix.
+        :rtype: Tuple[Tensor, Tensor, Tensor]
+        """
         es, u = backend.eigh(hc)
         es = es[::-1]
         u = u[:, ::-1]
@@ -115,6 +137,19 @@ class FGSSimulator:
     def fermion_diagonalization_2(
         cls, hc: Tensor, L: int
     ) -> Tuple[Tensor, Tensor, Tensor]:
+        """
+        Alternative method for diagonalizing a quadratic fermionic Hamiltonian.
+
+        This method uses a different approach based on the Schur decomposition to diagonalize
+        the Hamiltonian.
+
+        :param hc: The quadratic Hamiltonian to be diagonalized.
+        :type hc: Tensor
+        :param L: The number of fermionic sites.
+        :type L: int
+        :return: A tuple containing the eigenvalues, eigenvectors, and the alpha matrix.
+        :rtype: Tuple[Tensor, Tensor, Tensor]
+        """
         w = cls.wmatrix(L)
         hm = 0.25 * w @ hc @ backend.adjoint(w)
         hm = backend.real((-1.0j) * hm)
@@ -140,6 +175,16 @@ class FGSSimulator:
 
     @staticmethod
     def wmatrix(L: int) -> Tensor:
+        """
+        Constructs the transformation matrix W.
+
+        This matrix transforms from the fermionic basis to the Majorana basis.
+
+        :param L: The number of fermionic sites.
+        :type L: int
+        :return: The transformation matrix W.
+        :rtype: Tensor
+        """
         w = np.zeros([2 * L, 2 * L], dtype=complex)
         for i in range(2 * L):
             if i % 2 == 1:
@@ -152,6 +197,16 @@ class FGSSimulator:
 
     @staticmethod
     def init_alpha(filled: List[int], L: int) -> Tensor:
+        """
+        Initializes the alpha matrix for a given set of filled sites.
+
+        :param filled: A list of site indices that are occupied by fermions.
+        :type filled: List[int]
+        :param L: The number of fermionic sites.
+        :type L: int
+        :return: The initialized alpha matrix.
+        :rtype: Tensor
+        """
         alpha = np.zeros([2 * L, L])
         for i in range(L):
             if i not in filled:
@@ -163,9 +218,29 @@ class FGSSimulator:
         return alpha
 
     def get_alpha(self) -> Tensor:
+        """
+        Returns the current alpha matrix of the FGS.
+
+        :return: The alpha matrix.
+        :rtype: Tensor
+        """
         return self.alpha
 
     def get_cmatrix(self, now_i: bool = True, now_j: bool = True) -> Tensor:
+        """
+        Calculates the correlation matrix.
+
+        The correlation matrix is defined as :math:`C_{ij} = \langle c_i^\dagger c_j \rangle`.
+        This method can also compute out-of-time-ordered correlators (OTOC) by specifying
+        whether to use the current or initial state for the `i` and `j` indices.
+
+        :param now_i: If True, use the current state for the `i` index. Defaults to True.
+        :type now_i: bool, optional
+        :param now_j: If True, use the current state for the `j` index. Defaults to True.
+        :type now_j: bool, optional
+        :return: The correlation matrix.
+        :rtype: Tensor
+        """
         # otoc in FGS language, see: https://arxiv.org/pdf/1908.03292.pdf
         # https://journals.aps.org/prb/pdf/10.1103/PhysRevB.99.054205
         # otoc for non=hermitian system is more subtle due to the undefined normalization
@@ -197,11 +272,11 @@ class FGSSimulator:
 
     def get_reduced_cmatrix(self, subsystems_to_trace_out: List[int]) -> Tensor:
         """
-        get reduced correlation matrix by tracing out subsystems
+        Calculates the reduced correlation matrix by tracing out specified subsystems.
 
-        :param subsystems_to_trace_out: list of sites to be traced out
+        :param subsystems_to_trace_out: A list of site indices to be traced out.
         :type subsystems_to_trace_out: List[int]
-        :return: reduced density matrix
+        :return: The reduced correlation matrix.
         :rtype: Tensor
         """
         m = self.get_cmatrix()
@@ -222,13 +297,13 @@ class FGSSimulator:
 
     def renyi_entropy(self, n: int, subsystems_to_trace_out: List[int]) -> Tensor:
         """
-        compute renyi_entropy of order ``n`` for the fermion state
+        Computes the Renyi entropy of order n for a given subsystem.
 
-        :param n: _description_
+        :param n: The order of the Renyi entropy.
         :type n: int
-        :param subsystems_to_trace_out: system sites to be traced out
+        :param subsystems_to_trace_out: A list of site indices to be traced out, defining the subsystem.
         :type subsystems_to_trace_out: List[int]
-        :return: _description_
+        :return: The Renyi entropy of order n.
         :rtype: Tensor
         """
         m = self.get_reduced_cmatrix(subsystems_to_trace_out)
@@ -248,15 +323,17 @@ class FGSSimulator:
         subsystems_to_trace_out: List[int],
     ) -> Tensor:
         """
+        Computes the charge moment of order n.
+
         Ref: https://arxiv.org/abs/2302.03330
 
-        :param alpha: to be integrated
+        :param alpha: The alpha parameter for the charge moment calculation.
         :type alpha: Tensor
-        :param n: n-order, Renyi-n
+        :param n: The order of the charge moment (Renyi-n).
         :type n: int
-        :param subsystems_to_trace_out: _description_
+        :param subsystems_to_trace_out: A list of site indices to be traced out.
         :type subsystems_to_trace_out: List[int]
-        :return: _description_
+        :return: The charge moment.
         :rtype: Tensor
         """
         m = self.get_reduced_cmatrix(subsystems_to_trace_out)
@@ -297,18 +374,23 @@ class FGSSimulator:
         with_std: bool = False,
     ) -> Tensor:
         """
+        Computes the Renyi entanglement asymmetry.
+
         Ref: https://arxiv.org/abs/2302.03330
 
-        :param n: _description_
+        :param n: The order of the Renyi entanglement asymmetry.
         :type n: int
-        :param subsystems_to_trace_out: _description_
+        :param subsystems_to_trace_out: A list of site indices to be traced out.
         :type subsystems_to_trace_out: List[int]
-        :param batch: sample number, defaults 100
-        :type batch: int
-        :param status: random number for the sample, -pi to pi,
-            with shape [batch, n]
-        :type status: Optional[Tensor]
-        :return: _description_
+        :param batch: The number of samples to use for the Monte Carlo estimation. Defaults to 100.
+        :type batch: int, optional
+        :param status: A tensor of random numbers for the sampling. If None, it will be generated internally.
+                       Defaults to None.
+        :type status: Optional[Tensor], optional
+        :param with_std: If True, also return the standard deviation of the estimation. Defaults to False.
+        :type with_std: bool, optional
+        :return: The Renyi entanglement asymmetry.
+            If `with_std` is True, a tuple containing the asymmetry and its standard deviation is returned.
         :rtype: Tensor
         """
         r = []
@@ -354,11 +436,12 @@ class FGSSimulator:
 
     def entropy(self, subsystems_to_trace_out: Optional[List[int]] = None) -> Tensor:
         """
-        compute von Neumann entropy for the fermion state
+        Computes the von Neumann entropy of a subsystem.
 
-        :param subsystems_to_trace_out: _description_, defaults to None
+        :param subsystems_to_trace_out: A list of site indices to be traced out, defining the subsystem.
+                                      If None, the entropy of the entire system is computed. Defaults to None.
         :type subsystems_to_trace_out: Optional[List[int]], optional
-        :return: _description_
+        :return: The von Neumann entropy.
         :rtype: Tensor
         """
         m = self.get_reduced_cmatrix(subsystems_to_trace_out)  # type: ignore
@@ -374,9 +457,11 @@ class FGSSimulator:
 
     def evol_hamiltonian(self, h: Tensor) -> None:
         r"""
-        Evolve as :math:`e^{-i/2 \hat{h}}`
+        Evolves the state with a given Hamiltonian.
+
+        The evolution is given by :math:`e^{-i/2 \hat{h}}`.
 
-        :param h: _description_
+        :param h: The Hamiltonian for the evolution.
         :type h: Tensor
         """
         # e^{-i/2 H}
@@ -387,9 +472,11 @@ class FGSSimulator:
 
     def evol_ihamiltonian(self, h: Tensor) -> None:
         r"""
-        Evolve as :math:`e^{-1/2 \hat{h}}`
+        Evolves the state with a given Hamiltonian using imaginary time evolution.
 
-        :param h: _description_
+        The evolution is given by :math:`e^{-1/2 \hat{h}}`.
+
+        :param h: The Hamiltonian for the evolution.
         :type h: Tensor
         """
         # e^{-1/2 H}
@@ -401,9 +488,11 @@ class FGSSimulator:
 
     def evol_ghamiltonian(self, h: Tensor) -> None:
         r"""
-        Evolve as :math:`e^{-1/2 i \hat{h}}` with h generally non-Hermitian
+        Evolves the state with a general non-Hermitian Hamiltonian.
+
+        The evolution is given by :math:`e^{-1/2 i \hat{h}}`.
 
-        :param h: _description_
+        :param h: The non-Hermitian Hamiltonian for the evolution.
         :type h: Tensor
         """
         # e^{-1/2 H}
@@ -414,11 +503,28 @@ class FGSSimulator:
         self.otcmatrix = {}
 
     def orthogonal(self) -> None:
+        """Orthogonalizes the alpha matrix using QR decomposition."""
         q, _ = backend.qr(self.alpha)
         self.alpha = q
 
     @staticmethod
     def hopping(chi: Tensor, i: int, j: int, L: int) -> Tensor:
+        """
+        Constructs the hopping Hamiltonian between two sites.
+
+        The hopping Hamiltonian is given by :math:`\chi c_i^\dagger c_j + h.c.`.
+
+        :param chi: The hopping strength.
+        :type chi: Tensor
+        :param i: The index of the first site.
+        :type i: int
+        :param j: The index of the second site.
+        :type j: int
+        :param L: The number of fermionic sites.
+        :type L: int
+        :return: The hopping Hamiltonian.
+        :rtype: Tensor
+        """
         # chi * ci dagger cj + hc.
         chi = backend.convert_to_tensor(chi)
         chi = backend.cast(chi, dtypestr)
@@ -429,19 +535,35 @@ class FGSSimulator:
 
     def evol_hp(self, i: int, j: int, chi: Tensor = 0) -> None:
         r"""
-        The evolve Hamiltonian is :math:`\chi c_i^\dagger c_j +h.c.`
+        Evolves the state with a hopping Hamiltonian.
+
+        The evolution is governed by the Hamiltonian :math:`\chi c_i^\dagger c_j + h.c.`.
 
-        :param i: _description_
+        :param i: The index of the first site.
         :type i: int
-        :param j: _description_
+        :param j: The index of the second site.
         :type j: int
-        :param chi: _description_, defaults to 0
+        :param chi: The hopping strength. Defaults to 0.
         :type chi: Tensor, optional
         """
         self.evol_hamiltonian(self.hopping(chi, i, j, self.L))
 
     @staticmethod
     def chemical_potential(chi: Tensor, i: int, L: int) -> Tensor:
+        """
+        Constructs the chemical potential Hamiltonian for a single site.
+
+        The chemical potential Hamiltonian is given by :math:`\chi c_i^\dagger c_i`.
+
+        :param chi: The chemical potential strength.
+        :type chi: Tensor
+        :param i: The index of the site.
+        :type i: int
+        :param L: The number of fermionic sites.
+        :type L: int
+        :return: The chemical potential Hamiltonian.
+        :rtype: Tensor
+        """
         chi = backend.convert_to_tensor(chi)
         chi = backend.cast(chi, dtypestr)
         m = chi / 2 * onehot_matrix(i, i, 2 * L)
@@ -450,6 +572,22 @@ class FGSSimulator:
 
     @staticmethod
     def sc_pairing(chi: Tensor, i: int, j: int, L: int) -> Tensor:
+        """
+        Constructs the superconducting pairing Hamiltonian between two sites.
+
+        The superconducting pairing Hamiltonian is given by :math:`\chi c_i^\dagger c_j^\dagger + h.c.`.
+
+        :param chi: The pairing strength.
+        :type chi: Tensor
+        :param i: The index of the first site.
+        :type i: int
+        :param j: The index of the second site.
+        :type j: int
+        :param L: The number of fermionic sites.
+        :type L: int
+        :return: The superconducting pairing Hamiltonian.
+        :rtype: Tensor
+        """
         chi = backend.convert_to_tensor(chi)
         chi = backend.cast(chi, dtypestr)
         m = chi / 2 * onehot_matrix(i, j + L, 2 * L)
@@ -459,41 +597,57 @@ class FGSSimulator:
 
     def evol_sp(self, i: int, j: int, chi: Tensor = 0) -> None:
         r"""
-        The evolve Hamiltonian is :math:`chi c_i^\dagger c_j^\dagger +h.c.`
+        Evolves the state with a superconducting pairing Hamiltonian.
 
+        The evolution is governed by the Hamiltonian :math:`\chi c_i^\dagger c_j^\dagger + h.c.`.
 
-        :param i: _description_
+        :param i: The index of the first site.
         :type i: int
-        :param j: _description_
+        :param j: The index of the second site.
         :type j: int
-        :param chi: _description_, defaults to 0
+        :param chi: The pairing strength. Defaults to 0.
         :type chi: Tensor, optional
         """
         self.evol_hamiltonian(self.sc_pairing(chi, i, j, self.L))
 
     def evol_cp(self, i: int, chi: Tensor = 0) -> None:
         r"""
-        The evolve Hamiltonian is :math:`chi c_i^\dagger c_i`
+        Evolves the state with a chemical potential Hamiltonian.
 
-        :param i: _description_
+        The evolution is governed by the Hamiltonian :math:`\chi c_i^\dagger c_i`.
+
+        :param i: The index of the site.
         :type i: int
-        :param chi: _description_, defaults to 0
+        :param chi: The chemical potential strength. Defaults to 0.
         :type chi: Tensor, optional
         """
         self.evol_hamiltonian(self.chemical_potential(chi, i, self.L))
 
     def evol_icp(self, i: int, chi: Tensor = 0) -> None:
         r"""
-        The evolve Hamiltonian is :math:`chi c_i^\dagger c_i` with :math:`\exp^{-H/2}`
+        Evolves the state with a chemical potential Hamiltonian using imaginary time evolution.
+
+        The evolution is governed by :math:`e^{-H/2}` where :math:`H = \chi c_i^\dagger c_i`.
 
-        :param i: _description_
+        :param i: The index of the site.
         :type i: int
-        :param chi: _description_, defaults to 0
+        :param chi: The chemical potential strength. Defaults to 0.
         :type chi: Tensor, optional
         """
         self.evol_ihamiltonian(self.chemical_potential(chi, i, self.L))
 
     def get_bogoliubov_uv(self) -> Tuple[Tensor, Tensor]:
+        """
+        Returns the u and v matrices of the Bogoliubov transformation.
+
+        The Bogoliubov transformation is defined as:
+        :math:`b_k = u_{k,i} a_i + v_{k,i} a_i^\dagger`
+
+        where :math:`b_k` are the new fermionic operators and :math:`a_i` are the original ones.
+
+        :return: A tuple containing the u and v matrices.
+        :rtype: Tuple[Tensor, Tensor]
+        """
         return (
             backend.gather1d(
                 self.alpha, backend.convert_to_tensor([i for i in range(self.L)])
@@ -506,17 +660,27 @@ class FGSSimulator:
 
     def get_cmatrix_majorana(self) -> Tensor:
         r"""
-        correlation matrix defined in majorana basis
-        convention: :math:`gamma_0 = c_0 + c_0^\dagger`
-        :math:`gamma_1 = i(c_0 - c_0^\dagger)`
+        Calculates the correlation matrix in the Majorana basis.
 
-        :return: _description_
+        The Majorana operators are defined as:
+        :math:`\gamma_{2i} = c_i + c_i^\dagger`
+        :math:`\gamma_{2i+1} = -i(c_i - c_i^\dagger)`
+
+        :return: The correlation matrix in the Majorana basis.
         :rtype: Tensor
         """
         c = self.get_cmatrix()
         return self.wtransform @ c @ backend.adjoint(self.wtransform)
 
     def get_covariance_matrix(self) -> Tensor:
+        """
+        Calculates the covariance matrix.
+
+        The covariance matrix is defined from the Majorana correlation matrix.
+
+        :return: The covariance matrix.
+        :rtype: Tensor
+        """
         m = self.get_cmatrix_majorana()
         return -1.0j * (2 * m - backend.eye(self.L * 2))
 
@@ -524,34 +688,38 @@ class FGSSimulator:
         self, i: int, j: int, now_i: bool = True, now_j: bool = True
     ) -> Tensor:
         r"""
-        expectation of two fermion terms
-        convention: (c, c^\dagger)
-        for i>L, c_{i-L}^\dagger is assumed
+        Calculates the expectation value of a two-fermion term.
 
-        :param i: _description_
+        The convention for the operators is (c, c^\dagger). For i >= L, the operator is c_{i-L}^\dagger.
+
+        :param i: The index of the first fermion operator.
         :type i: int
-        :param j: _description_
+        :param j: The index of the second fermion operator.
         :type j: int
-        :return: _description_
+        :param now_i: Whether to use the current state for the first operator. Defaults to True.
+        :type now_i: bool, optional
+        :param now_j: Whether to use the current state for the second operator. Defaults to True.
+        :type now_j: bool, optional
+        :return: The expectation value of the two-fermion term.
         :rtype: Tensor
         """
         return self.get_cmatrix(now_i, now_j)[i][(j + self.L) % (2 * self.L)]
 
     def expectation_4body(self, i: int, j: int, k: int, l: int) -> Tensor:
         r"""
-        expectation of four fermion terms using Wick Thm
-        convention: (c, c^\dagger)
-        for i>L, c_{i-L}^\dagger is assumed
+        Calculates the expectation value of a four-fermion term using Wick's theorem.
 
-        :param i: _description_
+        The convention for the operators is (c, c^\dagger). For an index m >= L, the operator is c_{m-L}^\dagger.
+
+        :param i: The index of the first fermion operator.
         :type i: int
-        :param j: _description_
+        :param j: The index of the second fermion operator.
         :type j: int
-        :param k: _description_
+        :param k: The index of the third fermion operator.
         :type k: int
-        :param l: _description_
+        :param l: The index of the fourth fermion operator.
         :type l: int
-        :return: _description_
+        :return: The expectation value of the four-fermion term.
         :rtype: Tensor
         """
         e = (
@@ -563,12 +731,11 @@ class FGSSimulator:
 
     def post_select(self, i: int, keep: int = 1) -> None:
         """
-        post select (project) the fermion state to occupation eigenstate
-        <n_i> = ``keep``
+        Post-selects the state based on the occupation of a specific site.
 
-        :param i: _description_
+        :param i: The index of the site to post-select on.
         :type i: int
-        :param keep: _description_, defaults to 1
+        :param keep: The desired occupation number (0 or 1). Defaults to 1.
         :type keep: int, optional
         """
         # i is not jittable, keep is jittable
@@ -628,6 +795,20 @@ class FGSSimulator:
         self.alpha = q
 
     def cond_measure(self, ind: int, status: float, with_prob: bool = False) -> Tensor:
+        """
+        Performs a conditional measurement on a specific site.
+        The fermion Gaussian state is collapsed in the consistent way accordingly.
+
+        :param ind: The index of the site to measure.
+        :type ind: int
+        :param status: A random number between 0 and 1 to determine the measurement outcome.
+        :type status: float
+        :param with_prob: If True, also return the probabilities of the measurement outcomes. Defaults to False.
+        :type with_prob: bool, optional
+        :return: The measurement outcome (0 or 1). If `with_prob` is True,
+            a tuple containing the outcome and the probabilities is returned.
+        :rtype: Tensor
+        """
         p0 = backend.real(self.get_cmatrix()[ind, ind])
         prob = backend.convert_to_tensor([p0, 1 - p0])
         status = backend.convert_to_tensor(status)

tensorcircuit/mpscircuit.py

@@ -260,6 +260,17 @@ class MPSCircuit(AbstractCircuit):
         index_to: int,
         split: Optional[Dict[str, Any]] = None,
     ) -> None:
+        """
+        Apply a series of SWAP gates to move a qubit from ``index_from`` to ``index_to``.
+
+        :param index_from: The starting index of the qubit.
+        :type index_from: int
+        :param index_to: The destination index of the qubit.
+        :type index_to: int
+        :param split: Truncation options for the SWAP gates. Defaults to None.
+            consistent with the split option of the class.
+        :type split: Optional[Dict[str, Any]], optional
+        """
         if split is None:
             split = self.split
         self.position(index_from)
@@ -437,7 +448,15 @@ class MPSCircuit(AbstractCircuit):
         split: Optional[Dict[str, Any]] = None,
     ) -> None:
         """
-        Reduce the bond dimension between two adjacent sites by SVD
+        Reduce the bond dimension between two adjacent sites using SVD.
+
+        :param index_left: The index of the left tensor of the bond to be truncated.
+        :type index_left: int
+        :param center_left: If True, the orthogonality center will be on the left tensor after truncation.
+                            Otherwise, it will be on the right tensor. Defaults to True.
+        :type center_left: bool, optional
+        :param split: Truncation options for the SVD. Defaults to None.
+        :type split: Optional[Dict[str, Any]], optional
         """
         if split is None:
             split = self.split
@@ -463,7 +482,22 @@ class MPSCircuit(AbstractCircuit):
         split: Optional[Dict[str, Any]] = None,
     ) -> None:
         """
-        Apply a MPO to the MPS
+        Apply a Matrix Product Operator (MPO) to the MPS.
+
+        The application involves three main steps:
+        1. Contract the MPO tensors with the corresponding MPS tensors.
+        2. Canonicalize the resulting tensors by moving the orthogonality center.
+        3. Truncate the bond dimensions to control complexity.
+
+        :param tensors: A sequence of tensors representing the MPO.
+        :type tensors: Sequence[Tensor]
+        :param index_left: The starting index on the MPS where the MPO is applied.
+        :type index_left: int
+        :param center_left: If True, the final orthogonality center will be at the left end of the MPO.
+                            Otherwise, it will be at the right end. Defaults to True.
+        :type center_left: bool, optional
+        :param split: Truncation options for bond dimension reduction. Defaults to None.
+        :type split: Optional[Dict[str, Any]], optional
         """
         # step 1:
         #     contract tensor
@@ -521,10 +555,17 @@ class MPSCircuit(AbstractCircuit):
         *index: int,
         split: Optional[Dict[str, Any]] = None,
     ) -> None:
-        # TODO(@SUSYUSTC): jax autograd is wrong on this function
         """
-        Apply a n-qubit gate by transforming the gate to MPO
+        Apply an n-qubit gate to the MPS by converting it to an MPO.
+
+        :param gate: The n-qubit gate to apply.
+        :type gate: Gate
+        :param index: The indices of the qubits to apply the gate to.
+        :type index: int
+        :param split: Truncation options for the MPO application. Defaults to None.
+        :type split: Optional[Dict[str, Any]], optional
         """
+        # TODO(@SUSYUSTC): jax autograd is wrong on this function
         ordered = np.all(np.diff(index) > 0)
         if not ordered:
             order = np.argsort(index)

tensorcircuit/stabilizercircuit.py

@@ -147,14 +147,16 @@ class StabilizerCircuit(AbstractCircuit):
 
     def measure(self, *index: int, with_prob: bool = False) -> Tensor:
         """
-        Measure qubits in Z basis.
+        Measure qubits in the Z basis.
 
-        :param index: Indices of qubits to measure
+        :param index: Indices of the qubits to measure.
         :type index: int
-        :param with_prob: Return probability of measurement outcome, defaults to False
+        :param with_prob: If True, returns the theoretical probability of the measurement outcome.
+            defaults to False
         :type with_prob: bool, optional
-        :return: Measurement results and probability (if with_prob=True)
-        :rtype: Union[np.ndarray, Tuple[np.ndarray, float]]
+        :return: A tensor containing the measurement results.
+            If `with_prob` is True, a tuple containing the results and the probability is returned.
+        :rtype: Tensor
         """
         # Convert negative indices
 
@@ -162,20 +164,29 @@ class StabilizerCircuit(AbstractCircuit):
 
         # Add measurement instructions
         s1 = self.current_simulator().copy()
-        m = s1.measure_many(*index)
         # Sample once from the circuit using sampler
 
-        # TODO(@refraction-ray): correct probability
+        if with_prob:
+            num_random_measurements = 0
+            for i in index:
+                print(i, s1.peek_z(i))
+                if s1.peek_z(i) == 0:
+                    num_random_measurements += 1
+            probability = (0.5) ** num_random_measurements
+
+        m = s1.measure_many(*index)
+        if with_prob:
+            return m, probability
         return m
 
     def cond_measurement(self, index: int) -> Tensor:
         """
-        Measure qubits in Z basis with state collapse.
+        Measure a single qubit in the Z basis and collapse the state.
 
-        :param index: Index of qubit to measure
+        :param index: The index of the qubit to measure.
         :type index: int
-        :return: Measurement results and probability (if with_prob=True)
-        :rtype: Union[np.ndarray, Tuple[np.ndarray, float]]
+        :return: The measurement result (0 or 1).
+        :rtype: Tensor
         """
         # Convert negative indices
 
@@ -191,12 +202,12 @@ class StabilizerCircuit(AbstractCircuit):
 
     def cond_measure_many(self, *index: int) -> Tensor:
         """
-        Measure qubits in Z basis with state collapse.
+        Measure multiple qubits in the Z basis and collapse the state.
 
-        :param index: Index of qubit to measure
+        :param index: The indices of the qubits to measure.
         :type index: int
-        :return: Measurement results and probability (if with_prob=True)
-        :rtype: Union[np.ndarray, Tuple[np.ndarray, float]]
+        :return: A tensor containing the measurement results.
+        :rtype: Tensor
         """
         # Convert negative indices
 

tensorcircuit/translation.py

@@ -13,8 +13,6 @@ logger = logging.getLogger(__name__)
 
 try:
     import qiskit.quantum_info as qi
-    import symengine
-    import sympy
     from qiskit import QuantumCircuit
     from qiskit.circuit import Parameter, ParameterExpression
     from qiskit.circuit.exceptions import CircuitError
@@ -28,6 +26,14 @@ except ImportError:
     CircuitInstruction = Any
     QuantumCircuit = Any
 
+try:
+    import symengine
+    import sympy
+except ImportError:
+    logger.info(
+        "Please first ``pip install -U sympy symengine`` to enable `qiskit2tc` in translation module"
+    )
+
 try:
     import cirq
 except ImportError:
@@ -325,7 +331,9 @@ def qir2qiskit(
             qiskit_circ.append(gate, index_reversed)
         elif gate_name == "multicontrol":
             unitary = backend.numpy(backend.convert_to_tensor(parameters["unitary"]))
+            k = int(np.log(unitary.shape[-1]) / np.log(2) + 1e-7)
             ctrl_str = "".join(map(str, parameters["ctrl"]))[::-1]
+            unitary = perm_matrix(k) @ unitary @ perm_matrix(k)
             gate = UnitaryGate(unitary, label=qis_name).control(
                 len(ctrl_str), ctrl_state=ctrl_str
             )

{tensorcircuit_nightly-1.2.1.dev20250724.dist-info → tensorcircuit_nightly-1.2.1.dev20250726.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorcircuit-nightly
-Version: 1.2.1.dev20250724
+Version: 1.2.1.dev20250726
 Summary: nightly release for tensorcircuit
 Home-page: https://github.com/refraction-ray/tensorcircuit-dev
 Author: TensorCircuit Authors

{tensorcircuit_nightly-1.2.1.dev20250724.dist-info → tensorcircuit_nightly-1.2.1.dev20250726.dist-info}/RECORD

@@ -1,25 +1,25 @@
-tensorcircuit/__init__.py,sha256=crGf_yKgxwxVS0dPKaNTaY7srmWi_K0oqt9Ixlj6CZ0,2032
+tensorcircuit/__init__.py,sha256=f4VIGH0ZgN9St3QabFoG3CUJqNw3FwknLJRl8PU1nD8,2032
 tensorcircuit/about.py,sha256=DazTswU2nAwOmASTaDII3L04PVtaQ7oiWPty5YMI3Wk,5267
 tensorcircuit/abstractcircuit.py,sha256=0osacPqq7B1EJki-cI1aLYoVRmjFaG9q3XevWMs7SsA,44125
 tensorcircuit/asciiart.py,sha256=neY1OWFwtoW5cHPNwkQHgRPktDniQvdlP9QKHkk52fM,8236
 tensorcircuit/basecircuit.py,sha256=ipCg3J55sgkciUZ2qCZqpVqE00YIWRlACu509nktg3I,37203
 tensorcircuit/channels.py,sha256=CFQxWI-JmkIxexslCBdjp_RSxUbHs6eAJv4LvlXXXCY,28637
-tensorcircuit/circuit.py,sha256=jC1Bb9A06pt6XX7muC-Q72BR9HS6n0Ft6aMjOGcz9iM,36428
-tensorcircuit/cons.py,sha256=0fE9UY02TNI3FyQWGyGCKuYpwkMlV-a1cMbTZveFYmk,31125
+tensorcircuit/circuit.py,sha256=mE4b_9xRu3ydoB8iDffdx35V9GZLhAQD_tkjZDLnLjg,39105
+tensorcircuit/cons.py,sha256=uYKBeYKkDoJEqJTNrOZPRM31tBtkqe5aAg8GtVidJ1Y,33014
 tensorcircuit/densitymatrix.py,sha256=VqMBnWCxO5-OsOp6LOdc5RS2AzmB3U4-w40Vn_lqygo,14865
 tensorcircuit/experimental.py,sha256=RW97ncitCfO1QJLAUbKBvm2Tsc0hzKhqkC65ShA9-Q0,34456
-tensorcircuit/fgs.py,sha256=eIi38DnQBGxY4itxqzGVbi8cAjB3vCYAX87xcJVJmoo,40846
+tensorcircuit/fgs.py,sha256=dBzRz0-9o8QQ6GkA1xzBZgZvqe_APp5jazJxzvbBVaY,49515
 tensorcircuit/gates.py,sha256=x-wA7adVpP7o0AQLt_xYUScFKj8tU_wUOV2mR1GyrPc,29322
 tensorcircuit/keras.py,sha256=5OF4dfhEeS8sRYglpqYtQsWPeqp7uK0i7-P-6RRJ7zQ,10126
 tensorcircuit/mps_base.py,sha256=UZ-v8vsr_rAsKrfun8prVgbXJ-qsdqKy2DZIHpq3sxo,15400
-tensorcircuit/mpscircuit.py,sha256=Jv4nsRyOhQxSHpDUJpb9OS6A5E3bTJoIHYGzwgs7NYU,34591
+tensorcircuit/mpscircuit.py,sha256=COO9xzvA2Whe7Ncp6OqrgtXKmahHgTHxXTELAVHzFSY,36777
 tensorcircuit/noisemodel.py,sha256=vzxpoYEZbHVC4a6g7_Jk4dxsHi4wvhpRFwud8b616Qo,11878
 tensorcircuit/quantum.py,sha256=LNkIv5cJ2KG6puC18zTuXi-5cojW1Tnz-N-WjZ0Qu5Q,90217
 tensorcircuit/shadows.py,sha256=6XmWNubbuaxFNvZVWu-RXd0lN9Jkk-xwong_K8o8_KE,17014
 tensorcircuit/simplify.py,sha256=O11G3UYiVAc30GOfwXXmhLXwGZrQ8OVwLTMQMZp_XBc,9414
-tensorcircuit/stabilizercircuit.py,sha256=4gDeTgko04j4dwt7NdJvl8NhqmB8JH75nZjdbLU3Aw0,15178
+tensorcircuit/stabilizercircuit.py,sha256=yoF03HfPYPhsoRrnp3JosoNde7eYluNbcM-PRYL-KfM,15504
 tensorcircuit/torchnn.py,sha256=z_QpM0QC3mydGyWpyp877j-tSFCPyzynCwqrTWaw-IA,4637
-tensorcircuit/translation.py,sha256=D0-JzhN8IxBlPerwDN4ImGbS4VQg-nFxGry9BhEc4xk,28330
+tensorcircuit/translation.py,sha256=VnU7DnYmbk1cWjqa7N68WNLNDn3DwENrMzmbG4_CQco,28611
 tensorcircuit/utils.py,sha256=CH9gTV4iKIikSS8KajIu3ttyC8i_1tBPf5PAYH1fgxs,7060
 tensorcircuit/vis.py,sha256=O4hm050KKfOAoVyHsjpMg6NBNVoWhLSlv-xsCx4opsU,12196
 tensorcircuit/applications/__init__.py,sha256=nAX-Am6JoL9k53iJ_CjZJ2NcjIpaz21H87nrW4Op03k,246
@@ -42,7 +42,7 @@ tensorcircuit/backends/__init__.py,sha256=WiUmbUFzM29w3hKfhuKxVUk3PpqDFiXf4za9g0
 tensorcircuit/backends/abstract_backend.py,sha256=Ob8zp-AgovoY3uYFNEUA_WlJz9YtgnaJvugKUXWttAA,59018
 tensorcircuit/backends/backend_factory.py,sha256=Z0aQ-RnxOnQzp-SRw8sefAH8XyBSlj2NXZwOlHinbfY,1713
 tensorcircuit/backends/cupy_backend.py,sha256=4vgO3lnQnsvWL5hukhskjJp37EAHqio6z6TVXTQcdjs,15077
-tensorcircuit/backends/jax_backend.py,sha256=puBnoFZfFxxE5CRiy4QeTjdkRqnsXM4JmkoDn7lLBkE,25638
+tensorcircuit/backends/jax_backend.py,sha256=dkDQ380CJHIdlt1fZvlN_g8DIowWPEcTTV_XBcs0YB0,26088
 tensorcircuit/backends/jax_ops.py,sha256=o7tLlQMRnaKWcr5rVnOMqwG6KZVpR8M8ryNQ-ceXVxs,4789
 tensorcircuit/backends/numpy_backend.py,sha256=sd1migp_E2FWjchvOeYRuyM47yexegT2_SW_ukSYSF8,14171
 tensorcircuit/backends/pytorch_backend.py,sha256=yhfZSrm99yNW-dmijk8t6zAkbVgLRd4b_aIWKrpT7bY,24230
@@ -84,23 +84,23 @@ tensorcircuit/templates/dataset.py,sha256=ldPvCUlwjHU_S98E2ISQp34KqJzJPpPHmDIKJ4
 tensorcircuit/templates/graphs.py,sha256=cPYrxjoem0xZ-Is9dZKAvEzWZL_FejfIRiCEOTA4qd4,3935
 tensorcircuit/templates/lattice.py,sha256=F35ebANk0DSmSHLR0-Q_hUbcznyCmZjb4fKmvCMywmA,58575
 tensorcircuit/templates/measurements.py,sha256=pzc5Aa9S416Ilg4aOY77Z6ZhUlYcXnAkQNQFTuHjFFs,10943
-tensorcircuit_nightly-1.2.1.dev20250724.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+tensorcircuit_nightly-1.2.1.dev20250726.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conftest.py,sha256=J9nHlLE3Zspz1rMyzadEuBWhaS5I4Q9sq0lnWybcdIA,1457
 tests/test_backends.py,sha256=rClxb2gyAoGeXd_ZYVSAJ0zEvJ7z_2btAeFM_Iy_wwY,33925
 tests/test_calibrating.py,sha256=D1Tlv8mucUhg3ULvB5QlYyaDfw7aEERwq69-aGSb1A4,3805
 tests/test_channels.py,sha256=BL4CirU8ku9-_NrI6PZAS5xZ0wrL1UEC1S3wPI9dYQM,12628
-tests/test_circuit.py,sha256=DkyNJmG4-r9WHEPtRyZ1XrLeECCnjPGiMMlf3Y6yzxg,51866
+tests/test_circuit.py,sha256=IsSIFEs7hUCSYexMb-ESt1ZUpztHtLA0qz0CZolGdc4,52240
 tests/test_cloud.py,sha256=241ng6LnG_o_2PKR-BuUFfmrj3V1aeFiI-_bcWuPFyo,5606
 tests/test_compiler.py,sha256=R1t0MDQR01uEbY2wxqzQEf-LkSehrfZWmLvPuguC2JI,3419
-tests/test_dmcircuit.py,sha256=Th5N6TCdGQ2MBWy8O3GNnMWshGui8XR_rUSeM2QlVcs,17232
+tests/test_dmcircuit.py,sha256=ZtTS-Jcpt-oN3yafYee9ZZCFW8-2I0MaLpyaDPve0PA,17234
 tests/test_ensemble.py,sha256=0RzJkv-5D8LeZxS0Q0MwtEcgnXd2zefMquPHRNYT6RY,2109
 tests/test_fgs.py,sha256=nv3E_F_SAF4ChsoT8Ihm3FtSpOmTGJr_Jf2MoKXXceE,10162
 tests/test_gates.py,sha256=rAIV2QFpFsA5bT1QivTSkhdarvwu5t0N3IOz4SEDrzg,4593
 tests/test_interfaces.py,sha256=iJPmes8S8HkA9_PGjsu4Ike-vCXYyS1EMgnNKKXDNaU,16938
 tests/test_keras.py,sha256=U453jukavmx0RMeTSDEgPzrNdHNEfK1CW0CqO3XCNKo,4841
 tests/test_lattice.py,sha256=_ptDVK3EhS-X5fCQWiP8sHk3azdyGFuwqg6KMkBTkDE,65789
-tests/test_miscs.py,sha256=Wo2fZ-Co4-iPm7n3F9NTxnXuabWi_J6uvrOr0GIMqvY,9175
+tests/test_miscs.py,sha256=mm6kv5LqLkwHxWrGzLxajyOp1RaaKoHxq2OT1J3DpIM,9741
 tests/test_mpscircuit.py,sha256=mDXX8oQeFeHr_PdZvwqyDs_tVcVAqLmCERqlTAU7590,10552
 tests/test_noisemodel.py,sha256=UYoMtCjwDaB-CCn5kLosofz-qTMiY4KGAFBjVtqqLPE,5637
 tests/test_qaoa.py,sha256=hEcC_XVmKBGt9XgUGtbTO8eQQK4mjorgTIrfqZCeQls,2616
@@ -110,11 +110,11 @@ tests/test_quantum_attr.py,sha256=Zl6WbkbnTWVp6FL2rR21qBGsLoheoIEZXqWZKxfpDRs,12
 tests/test_results.py,sha256=8cQO0ShkBc4_pB-fi9s35WJbuZl5ex5y1oElSV-GlRo,11882
 tests/test_shadows.py,sha256=1T3kJesVJ5XfZrSncL80xdq-taGCSnTDF3eL15UlavY,5160
 tests/test_simplify.py,sha256=35tbOu1QANsPvY1buLwNhqPnMkBOsnBtHn82qaukmgI,1175
-tests/test_stabilizer.py,sha256=HdVRbEshg02CaNsqni_nRYY7KL5vhRBp9k1KGzOSE9I,5252
+tests/test_stabilizer.py,sha256=MivuZ5pY7GOcEPTanhtrflXostyLBToHyjfPqCU0tG0,5450
 tests/test_templates.py,sha256=Xm9otFFaaBWG9TZpgJ-nNh9MBfRipTzFWL8fBOnie2k,7192
 tests/test_torchnn.py,sha256=CHLTfWkF7Ses5_XnGFN_uv_JddfgenFEFzaDtSH8XYU,2848
 tests/test_van.py,sha256=kAWz860ivlb5zAJuYpzuBe27qccT-Yf0jatf5uXtTo4,3163
-tensorcircuit_nightly-1.2.1.dev20250724.dist-info/METADATA,sha256=zl0gksspBZ2l7gAYmvRyfOwclQEjtFkFy2k9cC46Fr8,34831
-tensorcircuit_nightly-1.2.1.dev20250724.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tensorcircuit_nightly-1.2.1.dev20250724.dist-info/top_level.txt,sha256=O_Iqeh2x02lasEYMI9iyPNNNtMzcpg5qvwMOkZQ7n4A,20
-tensorcircuit_nightly-1.2.1.dev20250724.dist-info/RECORD,,
+tensorcircuit_nightly-1.2.1.dev20250726.dist-info/METADATA,sha256=rqna4H-ixz2BjdKLCDo3EUlJAoUr2XrJqs0V537BCfo,34831
+tensorcircuit_nightly-1.2.1.dev20250726.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tensorcircuit_nightly-1.2.1.dev20250726.dist-info/top_level.txt,sha256=O_Iqeh2x02lasEYMI9iyPNNNtMzcpg5qvwMOkZQ7n4A,20
+tensorcircuit_nightly-1.2.1.dev20250726.dist-info/RECORD,,

tests/test_circuit.py

@@ -889,6 +889,19 @@ def test_circuit_quoperator(backend):
     np.testing.assert_allclose(qo.eval_matrix(), c.matrix(), atol=1e-5)
 
 
+def test_perm_matrix():
+    from tensorcircuit.translation import perm_matrix
+
+    p2 = perm_matrix(2)
+    np.testing.assert_allclose(
+        p2, np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]])
+    )
+    p3 = perm_matrix(3)
+    v = np.arange(8)
+    vt = np.array([0, 4, 2, 6, 1, 5, 3, 7])
+    np.testing.assert_allclose(p3 @ v, vt)
+
+
 @pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")])
 def test_qir2cirq(backend):
     try:
@@ -1094,7 +1107,7 @@ def test_qiskit2tc():
         import qiskit.quantum_info as qi
         from qiskit import QuantumCircuit
         from qiskit.circuit.library import HamiltonianGate
-        from qiskit.circuit.library.standard_gates import MCXGate, SwapGate
+        from qiskit.circuit.library.standard_gates import MCXGate, SwapGate, CXGate
 
         from tensorcircuit.translation import perm_matrix
     except ImportError:
@@ -1150,12 +1163,13 @@ def test_qiskit2tc():
     mcx_g = MCXGate(3, ctrl_state="010")
     qisc.append(mcx_g, [0, 1, 2, 3])
     qisc.ccx(0, 1, 2, ctrl_state="01")
-    CCCRX = SwapGate().control(2, ctrl_state="01")
-    qisc.append(CCCRX, [0, 1, 2, 3])
+    CCswap = SwapGate().control(2, ctrl_state="01")
+    qisc.append(CCswap, [0, 1, 2, 3])
+    CCCX = CXGate().control(2, ctrl_state="01")
+    qisc.append(CCCX, [1, 2, 3, 4])
 
-    c = tc.Circuit.from_qiskit(qisc, n, np.eye(2**n))
-    tc_unitary = c.wavefunction()
-    tc_unitary = np.reshape(tc_unitary, [2**n, 2**n])
+    c = tc.Circuit.from_qiskit(qisc, n)
+    tc_unitary = c.matrix()
     qis_unitary = qi.Operator(qisc)
     qis_unitary = np.reshape(qis_unitary, [2**n, 2**n])
     p_mat = perm_matrix(n)

tests/test_dmcircuit.py

@@ -239,7 +239,7 @@ def test_measure(backend):
 
     key1, key2 = tc.backend.random_split(key)
     rs1, rs2 = r(key1), r(key2)
-    assert rs1[0] != rs2[0]
+    # assert rs1[0] != rs2[0]
     print(rs1[1], rs2[1])
 
 

tests/test_miscs.py

@@ -312,3 +312,23 @@ def test_distrubuted_contractor(jaxb):
         return c.expectation_ps(z=[-1])
 
     np.testing.assert_allclose(value, baseline(params), atol=1e-6)
+
+
+@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")])
+def test_runtime_nodes_capture(backend):
+    with tc.cons.runtime_nodes_capture() as captured:
+        c = tc.Circuit(3)
+        c.h(0)
+        c.amplitude("010")
+    len(captured["nodes"]) == 7
+
+
+@pytest.mark.parametrize("backend", [lf("npb"), lf("tfb"), lf("jaxb")])
+def test_function_nodes_capture(backend):
+    @tc.cons.function_nodes_capture
+    def exp(theta):
+        c = tc.Circuit(3)
+        c.h(0)
+        return c.expectation_ps(z=[-3], reuse=False)
+
+    assert len(exp(0.3)) == 9

tests/test_stabilizer.py

@@ -215,3 +215,12 @@ def test_mipt():
         return c.entanglement_entropy(list(range(n // 2)))
 
     print(ruc(50, 10, 0.1))
+
+
+def test_measure_with_prob():
+    c = tc.StabilizerCircuit(3)
+    c.h(0)
+    c.cnot(0, 1)
+    m, p = c.measure(0, 2, with_prob=True)
+    np.testing.assert_allclose(p, 0.5, atol=1e-6)
+    print(m)