tensorcircuit-nightly 1.3.0.dev20250902__py3-none-any.whl → 1.3.0.dev20250904__py3-none-any.whl

tensorcircuit/results/counts.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, Optional, Sequence
 
 import numpy as np
 
+from ..quantum import _decode_basis_label
 
 Tensor = Any
 ct = Dict[str, int]
@@ -89,14 +90,24 @@ def marginal_count(count: ct, keep_list: Sequence[int]) -> ct:
     return reverse_count(ncount)
 
 
-def count2vec(count: ct, normalization: bool = True) -> Tensor:
+def count2vec(
+    count: ct, normalization: bool = True, dim: Optional[int] = None
+) -> Tensor:
     """
-    Convert count dictionary to probability vector.
+    Convert a dictionary of counts (with string keys) to a probability/count vector.
+
+    Support:
+      - base-d string (d <= 36), characters taken from 0-9A-Z (case-insensitive)
+        For example:
+          qubit: '0101'
+          qudit: '012' or '09A' (A represents 10, which means [0, 9, 10])
 
     :param count: A dictionary mapping bit strings to counts
     :type count: ct
     :param normalization: Whether to normalize the counts to probabilities, defaults to True
     :type normalization: bool, optional
+    :param dim: Dimensionality of the vector, defaults to 2
+    :type dim: int, optional
     :return: Probability vector as numpy array
     :rtype: Tensor
 
@@ -105,44 +116,47 @@ def count2vec(count: ct, normalization: bool = True) -> Tensor:
     >>> count2vec({"00": 2, "10": 3, "11": 5})
     array([0.2, 0. , 0.3, 0.5])
     """
-    nqubit = len(list(count.keys())[0])
-    probability = [0] * 2**nqubit
-    shots = sum([v for k, v in count.items()])
-    for k, v in count.items():
-        if normalization is True:
-            v /= shots  # type: ignore
-        probability[int(k, 2)] = v
-    return np.array(probability)
 
+    if not count:
+        return np.array([], dtype=float)
 
-def vec2count(vec: Tensor, prune: bool = False) -> ct:
-    """
-    Convert probability vector to count dictionary.
+    dim = 2 if dim is None else dim
 
-    :param vec: Probability vector
-    :type vec: Tensor
-    :param prune: Whether to remove near-zero probabilities, defaults to False
-    :type prune: bool, optional
-    :return: Count dictionary
-    :rtype: ct
+    n = len(next(iter(count)).upper())
+    prob = np.zeros(dim**n, dtype=float)
+    shots = float(sum(count.values())) if normalization else 1.0
+    if shots == 0:
+        return prob
+
+    powers = [dim**p for p in range(n)][::-1]
+    for k, v in count.items():
+        digits = _decode_basis_label(k, n, dim)
+        idx = sum(dig * p for dig, p in zip(digits, powers))
+        prob[idx] = (v / shots) if normalization else v
+
+    return prob
 
-    :Example:
 
-    >>> vec2count(np.array([0.2, 0.3, 0.1, 0.4]))
-    {'00': 0.2, '01': 0.3, '10': 0.1, '11': 0.4}
+def vec2count(vec: Tensor, prune: bool = False, dim: Optional[int] = None) -> ct:
     """
-    from ..quantum import count_vector2dict
+    Map a count/probability vector of length D to a dictionary with base-d string keys (0-9A-Z).
+    Only generate string keys when d ≤ 36; if d is inferred to be > 36, raise a NotImplementedError.
 
+    :param vec: A one-dimensional vector of length D = d**n
+    :param prune: Whether to prune near-zero elements (threshold 1e-8)
+    :param dim: Dimensionality of the vector, defaults to 2
+    :return: {base-d string key: value}, key length n
+    """
+    from ..quantum import count_vector2dict, _infer_num_sites
+
+    dim = 2 if dim is None else dim
     if isinstance(vec, list):
         vec = np.array(vec)
-    n = int(np.log(vec.shape[0]) / np.log(2) + 1e-9)
-    c = count_vector2dict(vec, n, key="bin")
-    if prune is True:
-        nc = c.copy()
-        for k, v in c.items():
-            if np.abs(v) < 1e-8:
-                del nc[k]
-        return nc
+    n = _infer_num_sites(int(vec.shape[0]), dim)
+    c: ct = count_vector2dict(vec, n, key="bin", dim=dim)  # type: ignore
+    if prune:
+        c = {k: v for k, v in c.items() if np.abs(v) >= 1e-8}
+
     return c
 
 

tensorcircuit/simplify.py

@@ -121,7 +121,9 @@ def _split_two_qubit_gate(
     if fixed_choice == 2:  # swap one
         return n3, n4, True  # swap
     s2 = n3.tensor.shape[-1]
-    if (s1 >= 4) and (s2 >= 4):
+    if (s1 >= n[0].dimension * n[2].dimension) and (
+        s2 >= n[1].dimension * n[3].dimension
+    ):
         # jax jit unspport split_node with trun_err anyway
         # tf function doesn't work either, though I believe it may work on tf side
         # CANNOT DONE(@refraction-ray): tf.function version with trun_err set

tensorcircuit/timeevol.py

@@ -435,10 +435,10 @@ def _solve_ode(
     args: Any,
     solver_kws: Dict[str, Any],
 ) -> Tensor:
-    rtol = solver_kws.get("rtol", 1e-12)
-    atol = solver_kws.get("atol", 1e-12)
+    rtol = solver_kws.get("rtol", 1e-8)
+    atol = solver_kws.get("atol", 1e-8)
     ode_backend = solver_kws.get("ode_backend", "jaxode")
-    max_steps = solver_kws.get("max_steps", 10000)
+    max_steps = solver_kws.get("max_steps", 4096)
 
     ts = backend.convert_to_tensor(times)
     ts = backend.cast(ts, dtype=rdtypestr)
@@ -493,17 +493,15 @@ def ode_evol_local(
 ) -> Tensor:
     """
     ODE-based time evolution for a time-dependent Hamiltonian acting on a subsystem of qubits.
-
     This function solves the time-dependent Schrodinger equation using numerical ODE integration.
     The Hamiltonian is applied only to a specific subset of qubits (indices) in the system.
-
-    The ode_backend parameter defaults to 'jaxode' (which uses `jax.experimental.ode.odeint` with a default solver
-      of 'Dopri5');if set to 'diffrax', it uses `diffrax.diffeqsolve` instead (with a default solver of 'Tsit5').
+    The ode_backend parameter defaults to 'jaxode' (which uses ``jax.experimental.ode.odeint`` with a default solver
+    of 'Dopri5'); if set to 'diffrax', it uses ``diffrax.diffeqsolve`` instead (with a default solver of 'Tsit5').
 
     Note: This function currently only supports the JAX backend.
 
     :param hamiltonian: A function that returns a dense Hamiltonian matrix for the specified
-        subsystem size. The function signature should be hamiltonian(time, *args) -> Tensor.
+        subsystem size. The function signature should be ``hamiltonian(time, *args) -> Tensor``.
     :type hamiltonian: Callable[..., Tensor]
     :param initial_state: The initial quantum state vector of the full system.
     :type initial_state: Tensor
@@ -515,15 +513,22 @@ def ode_evol_local(
     :type callback: Optional[Callable[..., Tensor]]
     :param args: Additional arguments to pass to the Hamiltonian function.
     :param solver_kws: Additional keyword arguments to pass to the ODE solver.
-        ode_backend='jaxode'(default) uses `jax.experimental.ode.odeint`; ode_backend='diffrax'
-          uses `diffrax.diffeqsolve`.
-        rtol (default: 1e-12) and atol (default: 1e-12) are used to determine how accurately you would
+
+        - ``ode_backend='jaxode'`` (default) uses ``jax.experimental.ode.odeint``; ``ode_backend='diffrax'``
+          uses ``diffrax.diffeqsolve``.
+
+        - ``rtol`` (default: 1e-8) and ``atol`` (default: 1e-8) are used to determine how accurately you would
           like the numerical approximation to your equation.
-        The solver parameter accepts one of {'Tsit5' (default), 'Dopri5', 'Dopri8', 'Kvaerno5'}
-          and only works when ode_backend='diffrax'.
-        dt0 (default: 0.01) specifies the initial step size and only works when ode_backend='diffrax'.
-        max_steps (default: 10000)  The maximum number of steps to take before quitting the computation
-          unconditionally and only works when ode_backend='diffrax'.
+
+        - The ``solver`` parameter accepts one of {'Tsit5' (default), 'Dopri5', 'Dopri8', 'Kvaerno5'}
+          and only works when ``ode_backend='diffrax'``.
+
+        - ``t0`` (default: 0.01) specifies the initial step size and only works when ``ode_backend='diffrax'``.
+
+        - ``max_steps`` (default: 4096)  The maximum number of steps to take before quitting the computation
+          unconditionally and only works when ``ode_backend='diffrax'``.
+    :type solver_kws: dict
+
     :return: Evolved quantum states at the specified time points. If callback is provided,
         returns the callback results; otherwise returns the state vectors.
     :rtype: Tensor
@@ -566,18 +571,16 @@ def ode_evol_global(
 ) -> Tensor:
     """
     ODE-based time evolution for a time-dependent Hamiltonian acting on the entire system.
-
     This function solves the time-dependent Schrodinger equation using numerical ODE integration.
-    The Hamiltonian is applied to the full system and should be provided in sparse matrix format
-      for efficiency.
-
-    The ode_backend parameter defaults to 'jaxode' (which uses `jax.experimental.ode.odeint` with a default solver
-      of 'Dopri5');if set to 'diffrax', it uses `diffrax.diffeqsolve` instead (with a default solver of 'Tsit5').
+    The Hamiltonian is applied to the full system and should be provided in sparse matrix
+    format for efficiency.
+    The ode_backend parameter defaults to 'jaxode' (which uses ``jax.experimental.ode.odeint`` with a default solver
+    of 'Dopri5'); if set to 'diffrax', it uses ``diffrax.diffeqsolve`` instead (with a default solver of 'Tsit5').
 
     Note: This function currently only supports the JAX backend.
 
     :param hamiltonian: A function that returns a sparse Hamiltonian matrix for the full system.
-        The function signature should be hamiltonian(time, *args) -> Tensor.
+        The function signature should be ``hamiltonian(time, *args) -> Tensor``.
     :type hamiltonian: Callable[..., Tensor]
     :param initial_state: The initial quantum state vector.
     :type initial_state: Tensor
@@ -588,16 +591,22 @@ def ode_evol_global(
     :param args: Additional arguments to pass to the Hamiltonian function.
     :type args: tuple | list
     :param solver_kws: Additional keyword arguments to pass to the ODE solver.
-        ode_backend='jaxode'(default) uses `jax.experimental.ode.odeint`; ode_backend='diffrax'
-          uses `diffrax.diffeqsolve`.
-        rtol (default: 1e-12) and atol (default: 1e-12) are used to determine how accurately you would
+
+        - ``ode_backend='jaxode'`` (default) uses ``jax.experimental.ode.odeint``; ``ode_backend='diffrax'``
+          uses ``diffrax.diffeqsolve``.
+
+        - ``rtol`` (default: 1e-8) and ``atol`` (default: 1e-8) are used to determine how accurately you would
           like the numerical approximation to your equation.
-        The solver parameter accepts one of {'Tsit5' (default), 'Dopri5', 'Dopri8', 'Kvaerno5'}
-          and only works when ode_backend='diffrax'.
-        dt0 (default: 0.01) specifies the initial step size and only works when ode_backend='diffrax'.
-        max_steps (default: 10000)  The maximum number of steps to take before quitting the computation
-          unconditionally and only works when ode_backend='diffrax'.
+
+        - The ``solver`` parameter accepts one of {'Tsit5' (default), 'Dopri5', 'Dopri8', 'Kvaerno5'}
+          and only works when ``ode_backend='diffrax'``.
+
+        - ``t0`` (default: 0.01) specifies the initial step size and only works when ``ode_backend='diffrax'``.
+
+        - ``max_steps`` (default: 4096)  The maximum number of steps to take before quitting the computation
+          unconditionally and only works when ``ode_backend='diffrax'``.
     :type solver_kws: dict
+
     :return: Evolved quantum states at the specified time points. If callback is provided,
         returns the callback results; otherwise returns the state vectors.
     :rtype: Tensor
@@ -632,7 +641,7 @@ def evol_local(
     :param index: qubit sites to evolve
     :type index: Sequence[int]
     :param h_fun: h_fun should return a dense Hamiltonian matrix
-        with input arguments time and *args
+        with input arguments ``time`` and ``*args``
     :type h_fun: Callable[..., Tensor]
     :param t: evolution time
     :type t: float
@@ -658,7 +667,7 @@ def evol_global(
     :param c: _description_
     :type c: Circuit
     :param h_fun: h_fun should return a **SPARSE** Hamiltonian matrix
-        with input arguments time and *args
+        with input arguments ``time`` and ``*args``
     :type h_fun: Callable[..., Tensor]
     :param t: _description_
     :type t: float

{tensorcircuit_nightly-1.3.0.dev20250902.dist-info → tensorcircuit_nightly-1.3.0.dev20250904.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorcircuit-nightly
-Version: 1.3.0.dev20250902
+Version: 1.3.0.dev20250904
 Summary: High performance unified quantum computing framework for the NISQ era
 Author-email: TensorCircuit Authors <znfesnpbh@gmail.com>
 License-Expression: Apache-2.0

{tensorcircuit_nightly-1.3.0.dev20250902.dist-info → tensorcircuit_nightly-1.3.0.dev20250904.dist-info}/RECORD

@@ -1,24 +1,24 @@
-tensorcircuit/__init__.py,sha256=7bexT-GwAHAQCV3Ypp0cl1nXacrsDLD1GkTD42d00EA,2055
+tensorcircuit/__init__.py,sha256=tdZ3q9sCrbJ-hZFPjEaEQFJguKDs1fexxzi4c5f4DZg,2055
 tensorcircuit/about.py,sha256=DazTswU2nAwOmASTaDII3L04PVtaQ7oiWPty5YMI3Wk,5267
-tensorcircuit/abstractcircuit.py,sha256=0osacPqq7B1EJki-cI1aLYoVRmjFaG9q3XevWMs7SsA,44125
+tensorcircuit/abstractcircuit.py,sha256=VgvQiSeUagCR65kS2qo3TzrEjE7ER2uYGUwzDUzcn-8,44141
 tensorcircuit/asciiart.py,sha256=neY1OWFwtoW5cHPNwkQHgRPktDniQvdlP9QKHkk52fM,8236
-tensorcircuit/basecircuit.py,sha256=61roFjIKvGmRNOUd7tnj8QFAO0zookbFy5934iTBqnw,37555
+tensorcircuit/basecircuit.py,sha256=R8xH-hHiFrTJXYgHnODy74Q4Bfu8e46jI1DS4H_XixY,39804
 tensorcircuit/channels.py,sha256=CFQxWI-JmkIxexslCBdjp_RSxUbHs6eAJv4LvlXXXCY,28637
-tensorcircuit/circuit.py,sha256=mE4b_9xRu3ydoB8iDffdx35V9GZLhAQD_tkjZDLnLjg,39105
-tensorcircuit/cons.py,sha256=uYKBeYKkDoJEqJTNrOZPRM31tBtkqe5aAg8GtVidJ1Y,33014
-tensorcircuit/densitymatrix.py,sha256=ickqfqB9Btuyo6TwqJJY-RcaIXzPycqliGKMcscslBw,14866
+tensorcircuit/circuit.py,sha256=2uizrd9cCEcVORzSIWmuZXnwnPYsu-GZmDVLQLdqBNs,39930
+tensorcircuit/cons.py,sha256=V0wjevtDkESCIWMJaysgPVorQlPAIT0vtRWvIZkEWcE,33065
+tensorcircuit/densitymatrix.py,sha256=J-dZPqY_t_93bayAdjNVWne38Sa_sb58LSzjZ83oezU,15006
 tensorcircuit/experimental.py,sha256=TGK4FaS6TS_ZhtjcIZgYVuAkGdRW50LN0DdXp-h4bos,29906
 tensorcircuit/fgs.py,sha256=J1TjAiiqZk9KO1xYX_V0xsgKlYZaUQ7Enm4s5zkRM50,49514
-tensorcircuit/gates.py,sha256=x-wA7adVpP7o0AQLt_xYUScFKj8tU_wUOV2mR1GyrPc,29322
+tensorcircuit/gates.py,sha256=KLAYZyX_MyvKw4s4HZ0trw_3q9VCTHh8nwn2_ZaIV2c,29598
 tensorcircuit/keras.py,sha256=nMSuu9uZy7haWwuen1g_6GFVwYIirtX9IvejDyoH33M,10129
 tensorcircuit/mps_base.py,sha256=UZ-v8vsr_rAsKrfun8prVgbXJ-qsdqKy2DZIHpq3sxo,15400
-tensorcircuit/mpscircuit.py,sha256=o21b1_1v7xiubok2v949C0o8ovABgg44jyIGbyJ5cjA,37508
+tensorcircuit/mpscircuit.py,sha256=CPWlsb-kybZE-lh4iUkVMDn45qhHtFHUnxATP6TsaVk,38802
 tensorcircuit/noisemodel.py,sha256=vzxpoYEZbHVC4a6g7_Jk4dxsHi4wvhpRFwud8b616Qo,11878
-tensorcircuit/quantum.py,sha256=68SZ1lXJZSKVr5xe3_uvU-_25GOFnSPGlw4Ziaj1nBI,104681
+tensorcircuit/quantum.py,sha256=1Ajavk9OpK7Bg2_2_MXZ0DxGQPQ2iv8ZHhjxSUsASTg,110641
 tensorcircuit/shadows.py,sha256=6XmWNubbuaxFNvZVWu-RXd0lN9Jkk-xwong_K8o8_KE,17014
-tensorcircuit/simplify.py,sha256=O11G3UYiVAc30GOfwXXmhLXwGZrQ8OVwLTMQMZp_XBc,9414
+tensorcircuit/simplify.py,sha256=EuEyQenFit-hgQhEJecL7t7jJ8m8zQ4KuL_sEvPNu-I,9488
 tensorcircuit/stabilizercircuit.py,sha256=KbrBVSo2pXnf5JHIrxwRPSPTm7bJVMIcyE4d7-dIfCM,15545
-tensorcircuit/timeevol.py,sha256=dmFXDqBFvQI54QK9ViJ9XEVVha9QIE8Bl0sZ1mN85PI,31695
+tensorcircuit/timeevol.py,sha256=LqytBb2NaxudyCvip3KHzvnCGDb52PLB1jysepDzoqo,31857
 tensorcircuit/torchnn.py,sha256=z_QpM0QC3mydGyWpyp877j-tSFCPyzynCwqrTWaw-IA,4637
 tensorcircuit/translation.py,sha256=VnU7DnYmbk1cWjqa7N68WNLNDn3DwENrMzmbG4_CQco,28611
 tensorcircuit/utils.py,sha256=nEDR1wTh1WF_yV6UyZYlifqOPWdKk_Krr4HjhrWHnGQ,7228
@@ -40,15 +40,15 @@ tensorcircuit/applications/physics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQe
 tensorcircuit/applications/physics/baseline.py,sha256=RWrzMGnC0PtmpYSFkvCE7r1llR88gncXuCakAAhFE-w,1775
 tensorcircuit/applications/physics/fss.py,sha256=ny3U9ZDmT459PXjA1oUGfarBOlSKSy6fs04vD9s1XH4,3633
 tensorcircuit/backends/__init__.py,sha256=WiUmbUFzM29w3hKfhuKxVUk3PpqDFiXf4za9g0ctpZA,80
-tensorcircuit/backends/abstract_backend.py,sha256=PFfiWLkZ6izj34rRTTNeSp0VesSwFPXM_SIDqQ_viLA,69210
+tensorcircuit/backends/abstract_backend.py,sha256=SR_mRmFNJiz1MqTfoP18zJB4iTiOrGX56VoTjQ2t87k,70296
 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=PjvPbSItMwYpW83sKOmZb2QKz6LjClFIMbAzQWCK124,28013
+tensorcircuit/backends/jax_backend.py,sha256=H43ofYIgdGpz3ubOIIAhbqMGHs6m12NXI3iJc_z3CZ0,28112
 tensorcircuit/backends/jax_ops.py,sha256=WyUGavch2R9uEFsI1Ap7eP1UcU4s2TItBgGsrVS3Hzs,9320
-tensorcircuit/backends/numpy_backend.py,sha256=yNBj45W9-VMo-61ihzAAFS5jaj-bHJz0OJB9gZjwYUA,15515
-tensorcircuit/backends/pytorch_backend.py,sha256=6nTIG3NO6N2ChzfSOq3Wmti3n5hxkcMwvp7NQ7XEG2w,25582
+tensorcircuit/backends/numpy_backend.py,sha256=0N7Z6slwDsAkWBislzsy0YhKTxa2Woq_xaCCX_SFuHI,15613
+tensorcircuit/backends/pytorch_backend.py,sha256=ixHFpSJhPw0gJS5pEprmjDkYNLanqtcENqJAHRJyDVM,25686
 tensorcircuit/backends/pytorch_ops.py,sha256=lLxpK6OqfpVwifyFlgsqhpnt-oIn4R5paPMVg51WaW0,3826
-tensorcircuit/backends/tensorflow_backend.py,sha256=VgigYIGkwluHv1I2dS01cU11VPrZnMaAp2R1sZKOFnk,39714
+tensorcircuit/backends/tensorflow_backend.py,sha256=9SAfcWEoKvyJG4sM0I89ozW16aa3VMxMfcOUeDljShE,39813
 tensorcircuit/backends/tf_ops.py,sha256=FJwDU7LhZrt0VUIx12DJU0gZnWhMv7B7r9sAKG710As,3378
 tensorcircuit/cloud/__init__.py,sha256=n0Lx07GYF6YbdIa6AJCLJk4zlAm5CqaeHszvkxxuoI4,139
 tensorcircuit/cloud/abstraction.py,sha256=6aSxbz0MP21jBVdFbSMrvJPLQH117vGz9sSHbMFoodE,14582
@@ -71,7 +71,7 @@ tensorcircuit/interfaces/tensorflow.py,sha256=U4hZjm-yWxOJ5tqmffk8-tNvOkAltYBJ8Z
 tensorcircuit/interfaces/tensortrans.py,sha256=oUxIVpXfANZVRXfPjiGJDzFPiszfBsiY40ydh0BaELE,10364
 tensorcircuit/interfaces/torch.py,sha256=13IFGmWUFoWiSzKAzwp2EkOSxgiwN_oUFxjQb36gimo,5149
 tensorcircuit/results/__init__.py,sha256=3kkIvmjLYQd5ff-emY8l82rpv9mwMZdM2kTLZ9sNfA4,89
-tensorcircuit/results/counts.py,sha256=6Dw7SVwnahcLnVlhcU4RfES1CqH2ZVdt0bGeUTYaij8,6512
+tensorcircuit/results/counts.py,sha256=GUmLvH0WTMotMhv_uyHjtLs6zISDdNiD0f79qsi__Aw,7268
 tensorcircuit/results/readout_mitigation.py,sha256=dVpNvtFZe7n_fDVczKcqYPEepu3fV2qK3u-SfOpTf68,31746
 tensorcircuit/results/qem/__init__.py,sha256=Pw0hcFYNesuPE8uNDm9P8DVTIFCSBqUcIkr6smQYzuM,419
 tensorcircuit/results/qem/benchmark_circuits.py,sha256=LlFuKCDFKihMOhiY6WUZt9QPyoPeQw0SuaczdcSA3oM,3243
@@ -86,8 +86,8 @@ tensorcircuit/templates/graphs.py,sha256=cPYrxjoem0xZ-Is9dZKAvEzWZL_FejfIRiCEOTA
 tensorcircuit/templates/hamiltonians.py,sha256=dp1E5kZDxpE4g7df1EujQHP4sBU6kuGTkF4e49X2IPk,6116
 tensorcircuit/templates/lattice.py,sha256=QH6N4sOegQPZGN-5UjTecy220-8AJLFvo1seh7VD3xA,72851
 tensorcircuit/templates/measurements.py,sha256=pzc5Aa9S416Ilg4aOY77Z6ZhUlYcXnAkQNQFTuHjFFs,10943
-tensorcircuit_nightly-1.3.0.dev20250902.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-tensorcircuit_nightly-1.3.0.dev20250902.dist-info/METADATA,sha256=8tMI_KJm_vgx2D_2BYI7-pHeBbFyd9DRb_rWmRFGAMw,37856
-tensorcircuit_nightly-1.3.0.dev20250902.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tensorcircuit_nightly-1.3.0.dev20250902.dist-info/top_level.txt,sha256=9dcuK5488dWpVauYz8cdvx743z_La1h7zIQCsEEgu7o,14
-tensorcircuit_nightly-1.3.0.dev20250902.dist-info/RECORD,,
+tensorcircuit_nightly-1.3.0.dev20250904.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+tensorcircuit_nightly-1.3.0.dev20250904.dist-info/METADATA,sha256=kB9_IqE_nXFhQ2aE6FhInll4JZAUeFrwZxHvaDpOFF0,37856
+tensorcircuit_nightly-1.3.0.dev20250904.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tensorcircuit_nightly-1.3.0.dev20250904.dist-info/top_level.txt,sha256=9dcuK5488dWpVauYz8cdvx743z_La1h7zIQCsEEgu7o,14
+tensorcircuit_nightly-1.3.0.dev20250904.dist-info/RECORD,,