tensorcircuit-nightly 1.4.0.dev20250914__py3-none-any.whl → 1.4.0.dev20250916__py3-none-any.whl

tensorcircuit/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.4.0.dev20250914"
+__version__ = "1.4.0.dev20250916"
 __author__ = "TensorCircuit Authors"
 __creator__ = "refraction-ray"
 

tensorcircuit/analogcircuit.py

@@ -1,5 +1,6 @@
 """
 Analog-Digital Hybrid Circuit class wrapper
+only support jax backend
 """
 
 from typing import Any, List, Optional, Callable, Dict, Tuple, Union, Sequence
@@ -21,7 +22,9 @@ Tensor = Any
 
 @dataclass
 class AnalogBlock:
-    """A data structure to hold information about an analog evolution block."""
+    """
+    A data structure to hold information about an analog evolution block.
+    """
 
     hamiltonian_func: Callable[[Tensor], Tensor]
     time: float
@@ -45,7 +48,18 @@ class AnalogCircuit:
         """
         Initializes the hybrid circuit.
 
-        :param num_qubits: The number of qubits in the circuit.
+        :param nqubits: The number of qubits in the circuit.
+        :type nqubits: int
+        :param dim: The local Hilbert space dimension per site. Qudit is supported for 2 <= d <= 36.
+        :type dim: If None, the dimension of the circuit will be `2`, which is a qubit system.
+        :param inputs: If not None, the initial state of the circuit is taken as ``inputs``
+            instead of :math:`\vert 0 \rangle^n` qubits, defaults to None.
+        :type inputs: Optional[Tensor], optional
+        :param mps_inputs: QuVector for a MPS like initial wavefunction.
+        :type mps_inputs: Optional[QuOperator]
+        :param split: dict if two qubit gate is ready for split, including parameters for at least one of
+            ``max_singular_values`` and ``max_truncation_err``.
+        :type split: Optional[Dict[str, Any]]
         """
         self.num_qubits, self._nqubits = nqubits, nqubits
         self.dim = 2**self.num_qubits
@@ -57,7 +71,7 @@ class AnalogCircuit:
 
         # List of digital circuits, starting with one empty circuit.
         self.digital_circuits: List[Circuit] = [
-            Circuit(self.num_qubits, self.inputs, mps_inputs, split, dim)
+            Circuit(self.num_qubits, inputs, mps_inputs, split, dim)
         ]
 
         # List of analog blocks, each containing the Hamiltonian function, time, and solver options.
@@ -66,18 +80,25 @@ class AnalogCircuit:
         self._solver_options: Dict[str, Any] = {}
 
     def set_solver_options(self, **kws: Any) -> None:
+        """
+        set solver options globally for this circuit object
+        """
         self._solver_options = kws
 
     @property
     def effective_circuit(self) -> Circuit:
-        """Returns the effective circuit after all blocks have been added."""
+        """
+        Returns the effective circuit after all blocks have been added.
+        """
         if self._effective_circuit is None:
             self.state()
         return self._effective_circuit  # type: ignore
 
     @property
     def current_digital_circuit(self) -> Circuit:
-        """Returns the last (currently active) digital circuit."""
+        """
+        Returns the last (currently active) digital circuit.
+        """
         return self.digital_circuits[-1]
 
     def add_analog_block(
@@ -94,11 +115,14 @@ class AnalogCircuit:
 
         :param hamiltonian_func: A function H(t) that takes a time `t` (from 0 to `time`)
                                  and returns the Hamiltonian matrix at that instant.
+        :type hamiltonian_func: Callable[[float], np.ndarray]
         :param time: The total evolution time 'T'.
+        :type time: float
         :param index: The indices of the qubits to apply the analog evolution to. Defaults None for
             global application.
-        :param solver_options: Keyword arguments passed directly to `scipy.integrate.solve_ivp`.
-                               (e.g., method='RK45', rtol=1e-6, atol=1e-8)
+        :type index: Optional[List[int]]
+        :param solver_options: Keyword arguments passed directly to `tc.timeevol.ode_evolve`
+        :type solver_options: Dict[str, Any]
         """
         # Create and store the analog block information
         time = backend.convert_to_tensor(time, dtype=rdtypestr)
@@ -152,14 +176,12 @@ class AnalogCircuit:
         :return: The final state vector after the full evolution
         :rtype: Tensor
         """
-        psi = self.inputs
-
         # Propagate the state through the alternating circuit blocks
         for i, analog_block in enumerate(self.analog_blocks):
             # 1. Apply Digital Block i
             digital_c = self.digital_circuits[i]
             if i > 0:
-                digital_c.replace_inputs(psi)
+                digital_c.replace_inputs(psi)  # type: ignore
             psi = digital_c.wavefunction()
 
             if analog_block.index is None:
@@ -181,8 +203,11 @@ class AnalogCircuit:
             # TODO(@refraction-ray): support more time evol methods
 
         # 3. Apply the final digital circuit
-        self.digital_circuits[-1].replace_inputs(psi)
-        psi = self.digital_circuits[-1].wavefunction()
+        if self.analog_blocks:
+            self.digital_circuits[-1].replace_inputs(psi)
+            psi = self.digital_circuits[-1].wavefunction()
+        else:
+            psi = self.digital_circuits[-1].wavefunction()
         self._effective_circuit = Circuit(self.num_qubits, inputs=psi)
 
         return psi
@@ -382,7 +407,7 @@ class AnalogCircuit:
             if i < len(self.analog_blocks):
                 block = self.analog_blocks[i]
                 s += f"--- Analog Block {i} (T={block.time}) ---\n"
-                s += f"  H(t) function: '{block.hamiltonian_func.__name__}'\n"
+                s += f" H(t) function: '{block.hamiltonian_func.__name__}'\n"
 
         s += "=" * 40
         return s

tensorcircuit/backends/jax_backend.py

@@ -175,6 +175,27 @@ def _eigh_jax(self: Any, tensor: Tensor) -> Tensor:
     return adaware_eigh(tensor)
 
 
+def bcsr_scalar_mul(self: Tensor, other: Tensor) -> Tensor:
+    """
+    Implements scalar multiplication for BCSR matrices (self * scalar).
+    """
+    import jax.numpy as jnp
+    from jax.experimental.sparse import BCSR
+
+    if jnp.isscalar(other):
+        # The core logic: only the data array is affected by scalar multiplication.
+        # The sparsity pattern (indices, indptr) remains the same.
+        new_data = self.data * other
+
+        # Return a new BCSR instance with the scaled data.
+        return BCSR((new_data, self.indices, self.indptr), shape=self.shape)
+
+    # For any other type of multiplication (e.g., element-wise with another matrix),
+    # return NotImplemented. This allows Python to try other operations,
+    # like other.__rmul__(self).
+    return NotImplemented
+
+
 tensornetwork.backends.jax.jax_backend.JaxBackend.convert_to_tensor = (
     _convert_to_tensor_jax
 )
@@ -224,6 +245,11 @@ class JaxBackend(jax_backend.JaxBackend, ExtendedBackend):  # type: ignore
 
         self.name = "jax"
 
+        # --- Monkey-patch the BCSR class ---
+
+        sparse.BCSR.__mul__ = bcsr_scalar_mul  # type: ignore
+        sparse.BCSR.__rmul__ = bcsr_scalar_mul  # type: ignore
+
     # it is already child of numpy backend, and self.np = self.jax.np
     def eye(
         self, N: int, dtype: Optional[str] = None, M: Optional[int] = None

tensorcircuit/backends/pytorch_backend.py

@@ -9,6 +9,7 @@ from typing import Any, Callable, Optional, Sequence, Tuple, Union
 from operator import mul
 from functools import reduce, partial
 
+from scipy.sparse import coo_matrix
 import tensornetwork
 from tensornetwork.backends.pytorch import pytorch_backend
 from .abstract_backend import ExtendedBackend
@@ -23,7 +24,6 @@ logger = logging.getLogger(__name__)
 
 # TODO(@refraction-ray): lack stateful random methods implementation for now
 # TODO(@refraction-ray): lack scatter impl for now
-# TODO(@refraction-ray): lack sparse relevant methods for now
 # To be added once pytorch backend is ready
 
 
@@ -302,6 +302,9 @@ class PyTorchBackend(pytorch_backend.PyTorchBackend, ExtendedBackend):  # type:
         return torchlib.kron(a, b)
 
     def numpy(self, a: Tensor) -> Tensor:
+        if self.is_sparse(a):
+            a = a.coalesce()
+            return coo_matrix((a.values().numpy(), a.indices().numpy()), shape=a.shape)
         a = a.cpu()
         if a.is_conj():
             return a.resolve_conj().numpy()
@@ -381,6 +384,9 @@ class PyTorchBackend(pytorch_backend.PyTorchBackend, ExtendedBackend):  # type:
     def sort(self, a: Tensor, axis: int = -1) -> Tensor:
         return torchlib.sort(a, dim=axis).values
 
+    def argsort(self, a: Tensor, axis: int = -1) -> Tensor:
+        return torchlib.argsort(a, dim=axis)
+
     def all(self, tensor: Tensor, axis: Optional[Sequence[int]] = None) -> Tensor:
         """
         Corresponds to torch.all.
@@ -467,6 +473,39 @@ class PyTorchBackend(pytorch_backend.PyTorchBackend, ExtendedBackend):  # type:
     def reverse(self, a: Tensor) -> Tensor:
         return torchlib.flip(a, dims=(-1,))
 
+    def coo_sparse_matrix(
+        self, indices: Tensor, values: Tensor, shape: Tensor
+    ) -> Tensor:
+        # Convert COO format to PyTorch sparse tensor
+        indices = self.convert_to_tensor(indices)
+        return torchlib.sparse_coo_tensor(self.transpose(indices), values, shape)
+
+    def sparse_dense_matmul(
+        self,
+        sp_a: Tensor,
+        b: Tensor,
+    ) -> Tensor:
+        # Matrix multiplication between sparse and dense tensor
+        return torchlib.sparse.mm(sp_a, b)
+
+    def sparse_csr_from_coo(self, coo: Tensor, strict: bool = False) -> Tensor:
+        try:
+            # Convert COO to CSR format if supported
+            return coo.to_sparse_csr()
+        except AttributeError as e:
+            if not strict:
+                return coo
+            else:
+                raise e
+
+    def to_dense(self, sp_a: Tensor) -> Tensor:
+        # Convert sparse tensor to dense
+        return sp_a.to_dense()
+
+    def is_sparse(self, a: Tensor) -> bool:
+        # Check if tensor is sparse
+        return a.is_sparse or a.is_sparse_csr  # type: ignore
+
     def tree_map(self, f: Callable[..., Any], *pytrees: Any) -> Any:
         # torch native tree_map not support multiple pytree args
         # return torchlib.utils._pytree.tree_map(f, *pytrees)

tensorcircuit/circuit.py

@@ -475,7 +475,7 @@ class Circuit(BaseCircuit):
             raise ValueError("no `get_gate_from_index` implementation is provided")
         g = get_gate_from_index(r, kraus)
         g = backend.reshape(g, [self._d for _ in range(sites * 2)])
-        self.any(*index, unitary=g, name=name)  # type: ignore
+        self.any(*index, unitary=g, name=name, dim=self._d)  # type: ignore
         return r
 
     def _general_kraus_tf(
@@ -600,9 +600,13 @@ class Circuit(BaseCircuit):
             for w, k in zip(prob, kraus_tensor)
         ]
         pick = self.unitary_kraus(
-            new_kraus, *index, prob=prob, status=status, name=name
+            new_kraus,
+            *index,
+            prob=prob,
+            status=status,
+            name=name,
         )
-        if with_prob is False:
+        if not with_prob:
             return pick
         else:
             return pick, prob
@@ -633,7 +637,11 @@ class Circuit(BaseCircuit):
         :type status: Optional[float], optional
         """
         return self._general_kraus_2(
-            kraus, *index, status=status, with_prob=with_prob, name=name
+            kraus,
+            *index,
+            status=status,
+            with_prob=with_prob,
+            name=name,
         )
 
     apply_general_kraus = general_kraus

tensorcircuit/quditcircuit.py

@@ -144,7 +144,7 @@ class QuditCircuit:
         else:
             raise ValueError(f"Unsupported gate/arity: {name} on {len(indices)} qudits")
 
-    def any(self, *indices: int, unitary: Tensor, name: str = "any") -> None:
+    def any(self, *indices: int, unitary: Tensor, name: Optional[str] = None) -> None:
         """
         Apply an arbitrary unitary on one or two qudits.
 
@@ -155,6 +155,7 @@ class QuditCircuit:
         :param name: Optional label stored in the circuit history.
         :type name: str
         """
+        name = "any" if name is None else name
         self._circ.unitary(*indices, unitary=unitary, name=name, dim=self._d)  # type: ignore
 
     unitary = any
@@ -668,3 +669,65 @@ class QuditCircuit:
         :rtype: List[Gate]
         """
         return self._circ.amplitude_before(l)
+
+    def general_kraus(
+        self,
+        kraus: Sequence[Gate],
+        *index: int,
+        status: Optional[float] = None,
+        with_prob: bool = False,
+        name: Optional[str] = None,
+    ) -> Tensor:
+        """
+        Monte Carlo trajectory simulation of general Kraus channel whose Kraus operators cannot be
+        amplified to unitary operators. For unitary operators composed Kraus channel, :py:meth:`unitary_kraus`
+        is much faster.
+
+        This function is jittable in theory. But only jax+GPU combination is recommended for jit
+        since the graph building time is too long for other backend options; though the running
+        time of the function is very fast for every case.
+
+        :param kraus: A list of ``tn.Node`` for Kraus operators.
+        :type kraus: Sequence[Gate]
+        :param index: The qubits index that Kraus channel is applied on.
+        :type index: int
+        :param status: Random tensor uniformly between 0 or 1, defaults to be None,
+            when the random number will be generated automatically
+        :type status: Optional[float], optional
+        """
+        return self._circ.general_kraus(
+            kraus,
+            *index,
+            status=status,
+            with_prob=with_prob,
+            name=name,
+        )
+
+    def unitary_kraus(
+        self,
+        kraus: Sequence[Gate],
+        *index: int,
+        prob: Optional[Sequence[float]] = None,
+        status: Optional[float] = None,
+        name: Optional[str] = None,
+    ) -> Tensor:
+        """
+        Apply unitary gates in ``kraus`` randomly based on corresponding ``prob``.
+        If ``prob`` is ``None``, this is reduced to kraus channel language.
+
+        :param kraus: List of ``tc.gates.Gate`` or just Tensors
+        :type kraus: Sequence[Gate]
+        :param prob: prob list with the same size as ``kraus``, defaults to None
+        :type prob: Optional[Sequence[float]], optional
+        :param status: random seed between 0 to 1, defaults to None
+        :type status: Optional[float], optional
+        :return: shape [] int dtype tensor indicates which kraus gate is actually applied
+        :rtype: Tensor
+        """
+        return self._circ.unitary_kraus(
+            kraus,
+            *index,
+            prob=prob,
+            status=status,
+            name=name,
+        )

tensorcircuit/timeevol.py

@@ -616,7 +616,7 @@ def ode_evol_global(
 
     def f(y: Tensor, t: Tensor, *args: Any) -> Tensor:
         h = -1.0j * hamiltonian(t, *args)
-        return backend.sparse_dense_matmul(h, y)
+        return h @ y
 
     s1 = _solve_ode(f, initial_state, times, args, solver_kws)
 

{tensorcircuit_nightly-1.4.0.dev20250914.dist-info → tensorcircuit_nightly-1.4.0.dev20250916.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorcircuit-nightly
-Version: 1.4.0.dev20250914
+Version: 1.4.0.dev20250916
 Summary: High performance unified quantum computing framework for the NISQ era
 Author-email: TensorCircuit Authors <znfesnpbh@gmail.com>
 License-Expression: Apache-2.0
@@ -62,9 +62,9 @@ Dynamic: license-file
 
 TensorCircuit-NG is the next-generation open-source high-performance quantum software framework, built upon tensornetwork engines, supporting for automatic differentiation, just-in-time compiling, hardware acceleration, vectorized parallelism and distributed training, providing unified infrastructures and interfaces for quantum programming. It can compose quantum circuits, neural networks and tensor networks seamlessly with high simulation efficiency and flexibility.
 
-TensorCircuit-NG is built on top of modern machine learning frameworks: Jax, TensorFlow, and PyTorch. It is specifically suitable for large-scale simulations of quantum-classical hybrid paradigm and variational quantum algorithms in ideal, noisy, Clifford, qudit, approximate, analog, and fermionic cases. It also supports quantum hardware access and provides CPU/GPU/QPU hybrid deployment solutions.
+TensorCircuit-NG is built on top of modern machine learning frameworks: Jax, TensorFlow, and PyTorch. It is specifically suitable for large-scale simulations of quantum-classical hybrid paradigm and variational quantum algorithms in ideal (`Circuit`), noisy (`DMCircuit`), Clifford (`StabilizerCircuit`), qudit (`QuditCircuit`), approximate (`MPSCircuit`), analog (`AnalogCircuit`), and fermionic (`FGSCircuit`) cases. It also supports quantum hardware access and provides CPU/GPU/QPU hybrid deployment solutions.
 
-TensorCircuit-NG is the actively maintained official version and a [fully compatible](https://tensorcircuit-ng.readthedocs.io/en/latest/faq.html#what-is-the-relation-between-tensorcircuit-and-tensorcircuit-ng) successor to TensorCircuit with more new features (stabilizer circuit, multi-card distributed simulation, etc.) and bug fixes (support latest `numpy>2` and `qiskit>1`).
+TensorCircuit-NG is the only actively maintained official version and a [fully compatible](https://tensorcircuit-ng.readthedocs.io/en/latest/faq.html#what-is-the-relation-between-tensorcircuit-and-tensorcircuit-ng) successor to TensorCircuit with more new features (stabilizer circuit, qudit circuit, analog circuit, multi-GPU distributed simulation, etc.) and bug fixes (support latest `numpy>2` and `qiskit>1`).
 
 ## Getting Started
 

{tensorcircuit_nightly-1.4.0.dev20250914.dist-info → tensorcircuit_nightly-1.4.0.dev20250916.dist-info}/RECORD

@@ -1,11 +1,11 @@
-tensorcircuit/__init__.py,sha256=Ix9uUiVRZNtVtXqBBdc4EZ1-FePzzJqtCv_0ebyXmJI,2160
+tensorcircuit/__init__.py,sha256=YxvzsvCI-Xn-l0o2-2Fqh_967Vn6t0Z3K-mTktfZPuQ,2160
 tensorcircuit/about.py,sha256=DazTswU2nAwOmASTaDII3L04PVtaQ7oiWPty5YMI3Wk,5267
 tensorcircuit/abstractcircuit.py,sha256=DwBmXhejVEqyhwoDJn8nOswJQBmvDR28n276wlhesJY,44224
-tensorcircuit/analogcircuit.py,sha256=ZelahNZ0tcIeC3nPuY-0SlSOOxrbF9XWWS3El462oE0,14522
+tensorcircuit/analogcircuit.py,sha256=4BzIC631MZ2m05CXuk2T6HQ8RTmHBE6NszaOLuxmlEc,15639
 tensorcircuit/asciiart.py,sha256=neY1OWFwtoW5cHPNwkQHgRPktDniQvdlP9QKHkk52fM,8236
 tensorcircuit/basecircuit.py,sha256=9I0Es2P5VdGisx5_t0AKSYtgSb15RB6fXCZg4eEr5es,39138
 tensorcircuit/channels.py,sha256=CFQxWI-JmkIxexslCBdjp_RSxUbHs6eAJv4LvlXXXCY,28637
-tensorcircuit/circuit.py,sha256=wF3UKCoUOuQG-S10JGX7U1nGwflcML1D8fT94WcGfmg,39921
+tensorcircuit/circuit.py,sha256=lETz1SvUh_60ZMFtvSPMWOF6zWMMyQU4TyB_VwhkVHM,40027
 tensorcircuit/cons.py,sha256=V0wjevtDkESCIWMJaysgPVorQlPAIT0vtRWvIZkEWcE,33065
 tensorcircuit/densitymatrix.py,sha256=C8Q2fHXZ78S9ZaPqCIKl6_v_sILqbBgqBOUYUQ1QmFI,15020
 tensorcircuit/experimental.py,sha256=TGK4FaS6TS_ZhtjcIZgYVuAkGdRW50LN0DdXp-h4bos,29906
@@ -16,12 +16,12 @@ tensorcircuit/mps_base.py,sha256=UZ-v8vsr_rAsKrfun8prVgbXJ-qsdqKy2DZIHpq3sxo,154
 tensorcircuit/mpscircuit.py,sha256=CPWlsb-kybZE-lh4iUkVMDn45qhHtFHUnxATP6TsaVk,38802
 tensorcircuit/noisemodel.py,sha256=vzxpoYEZbHVC4a6g7_Jk4dxsHi4wvhpRFwud8b616Qo,11878
 tensorcircuit/quantum.py,sha256=asuA3rCfi2Y4knWz1ObkveCdSv8EeaSsf1xfPVowvT0,110628
-tensorcircuit/quditcircuit.py,sha256=6KdHPRNzeBO8TxhXNNYnfN7EouTy_rX9Vu01gJM8yD0,23724
+tensorcircuit/quditcircuit.py,sha256=Ll1Nb0tQYKzq7rlPJA64GjcyBqTSydvCBBKlbhEb38A,26122
 tensorcircuit/quditgates.py,sha256=PR5n9NLNhMPyoanFYjuDioW-0U7VGUiJf_OvxR_Twq0,20925
 tensorcircuit/shadows.py,sha256=KQM19KnXnn6d3HgaqdRs33RWC2uCIiY5cEGnH1CVdGw,17012
 tensorcircuit/simplify.py,sha256=EuEyQenFit-hgQhEJecL7t7jJ8m8zQ4KuL_sEvPNu-I,9488
 tensorcircuit/stabilizercircuit.py,sha256=KbrBVSo2pXnf5JHIrxwRPSPTm7bJVMIcyE4d7-dIfCM,15545
-tensorcircuit/timeevol.py,sha256=bMZXPnCC4Q470f-vWeBz62yM11QcXaxAGOYUVZlYNxA,31921
+tensorcircuit/timeevol.py,sha256=Er3rMFEX61G1Zvt-iNVMpw1IIJ1lwD5HZURpowvCfR4,31893
 tensorcircuit/torchnn.py,sha256=z_QpM0QC3mydGyWpyp877j-tSFCPyzynCwqrTWaw-IA,4637
 tensorcircuit/translation.py,sha256=VnU7DnYmbk1cWjqa7N68WNLNDn3DwENrMzmbG4_CQco,28611
 tensorcircuit/utils.py,sha256=nEDR1wTh1WF_yV6UyZYlifqOPWdKk_Krr4HjhrWHnGQ,7228
@@ -46,10 +46,10 @@ tensorcircuit/backends/__init__.py,sha256=WiUmbUFzM29w3hKfhuKxVUk3PpqDFiXf4za9g0
 tensorcircuit/backends/abstract_backend.py,sha256=ox8gWb1ui21DPA8bnLYEg7HOp0NwWFLAhYBjQZj8p2o,70288
 tensorcircuit/backends/backend_factory.py,sha256=Z0aQ-RnxOnQzp-SRw8sefAH8XyBSlj2NXZwOlHinbfY,1713
 tensorcircuit/backends/cupy_backend.py,sha256=KG5fqP29wnngkPsi-TnOk0pHsr9lyD7hx6_Y56fCQuY,15172
-tensorcircuit/backends/jax_backend.py,sha256=H43ofYIgdGpz3ubOIIAhbqMGHs6m12NXI3iJc_z3CZ0,28112
+tensorcircuit/backends/jax_backend.py,sha256=luLhZ7zyj8d6ARYxzGsvhxZnbownbqgeUMpUQw6F5Yw,29080
 tensorcircuit/backends/jax_ops.py,sha256=WyUGavch2R9uEFsI1Ap7eP1UcU4s2TItBgGsrVS3Hzs,9320
 tensorcircuit/backends/numpy_backend.py,sha256=0N7Z6slwDsAkWBislzsy0YhKTxa2Woq_xaCCX_SFuHI,15613
-tensorcircuit/backends/pytorch_backend.py,sha256=ixHFpSJhPw0gJS5pEprmjDkYNLanqtcENqJAHRJyDVM,25686
+tensorcircuit/backends/pytorch_backend.py,sha256=XUSPh_AMbB1BeX2h9HHpccNubrLg85ouotjoXDc7N7g,26996
 tensorcircuit/backends/pytorch_ops.py,sha256=lLxpK6OqfpVwifyFlgsqhpnt-oIn4R5paPMVg51WaW0,3826
 tensorcircuit/backends/tensorflow_backend.py,sha256=9SAfcWEoKvyJG4sM0I89ozW16aa3VMxMfcOUeDljShE,39813
 tensorcircuit/backends/tf_ops.py,sha256=FJwDU7LhZrt0VUIx12DJU0gZnWhMv7B7r9sAKG710As,3378
@@ -89,8 +89,8 @@ tensorcircuit/templates/graphs.py,sha256=cPYrxjoem0xZ-Is9dZKAvEzWZL_FejfIRiCEOTA
 tensorcircuit/templates/hamiltonians.py,sha256=Guvqqi-V47w8xeZDmca4_mU4mW9V4c3AplsBOrRtxFo,6308
 tensorcircuit/templates/lattice.py,sha256=IvFyNgsFMfj82g-tpJraI3lMbI-EIZ0Cghq9v7tZ6Wg,72851
 tensorcircuit/templates/measurements.py,sha256=pzc5Aa9S416Ilg4aOY77Z6ZhUlYcXnAkQNQFTuHjFFs,10943
-tensorcircuit_nightly-1.4.0.dev20250914.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-tensorcircuit_nightly-1.4.0.dev20250914.dist-info/METADATA,sha256=2PsFz3Yip2EsmkBvuL6PPwcyiWMDuNrOgsSc8rqH4mQ,38135
-tensorcircuit_nightly-1.4.0.dev20250914.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tensorcircuit_nightly-1.4.0.dev20250914.dist-info/top_level.txt,sha256=9dcuK5488dWpVauYz8cdvx743z_La1h7zIQCsEEgu7o,14
-tensorcircuit_nightly-1.4.0.dev20250914.dist-info/RECORD,,
+tensorcircuit_nightly-1.4.0.dev20250916.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+tensorcircuit_nightly-1.4.0.dev20250916.dist-info/METADATA,sha256=RWIbMLoKi2GHJoQFmfWEY4skF8m2M1Y-zO5UIktH5H8,38283
+tensorcircuit_nightly-1.4.0.dev20250916.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tensorcircuit_nightly-1.4.0.dev20250916.dist-info/top_level.txt,sha256=9dcuK5488dWpVauYz8cdvx743z_La1h7zIQCsEEgu7o,14
+tensorcircuit_nightly-1.4.0.dev20250916.dist-info/RECORD,,