tensorcircuit-nightly 1.3.0.dev20250827__py3-none-any.whl → 1.3.0.dev20250829__py3-none-any.whl

tensorcircuit/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.3.0.dev20250827"
+__version__ = "1.3.0.dev20250829"
 __author__ = "TensorCircuit Authors"
 __creator__ = "refraction-ray"
 

tensorcircuit/backends/abstract_backend.py

@@ -9,6 +9,7 @@ from functools import reduce, partial
 from operator import mul
 from typing import Any, Callable, List, Optional, Sequence, Tuple, Union
 
+import math
 import numpy as np
 from ..utils import return_partial
 
@@ -405,6 +406,31 @@ class ExtendedBackend:
         a = self.reshape(a, [2 for _ in range(nleg)])
         return a
 
+    def reshaped(self: Any, a: Tensor, d: int) -> Tensor:
+        """
+        Reshape a tensor to the [d, d, ...] shape.
+
+        :param a: Input tensor
+        :type a: Tensor
+        :param d: edge length for each dimension
+        :type d: int
+        :return: the reshaped tensor
+        :rtype: Tensor
+        """
+        if not isinstance(d, int) or d <= 0:
+            raise ValueError("d must be a positive integer.")
+
+        size = self.sizen(a)
+        if size == 0:
+            return self.reshape(a, (0,))
+
+        nleg_float = math.log(size, d)
+        nleg = int(round(nleg_float))
+        if d**nleg != size:
+            raise ValueError(f"cannot reshape: size {size} is not a power of d={d}")
+
+        return self.reshape(a, (d,) * nleg)
+
     def reshapem(self: Any, a: Tensor) -> Tensor:
         """
         Reshape a tensor to the [l, l] shape.
@@ -839,6 +865,54 @@ class ExtendedBackend:
             "Backend '{}' has not implemented `mod`.".format(self.name)
         )
 
+    def floor(self: Any, x: Tensor) -> Tensor:
+        """
+        Compute the element-wise floor of the input tensor.
+
+        This operation returns a new tensor with the largest integers
+        less than or equal to each element of the input tensor,
+        i.e. it rounds each value down towards negative infinity.
+
+        :param x: Input tensor containing numeric values.
+        :type x: Tensor
+        :return: A tensor with the same shape as `x`, where each element
+                 is the floored value of the corresponding element in `x`.
+        :rtype: Tensor
+
+        :raises NotImplementedError: If the backend does not provide an
+                                     implementation for `floor`.
+        """
+        raise NotImplementedError(
+            "Backend '{}' has not implemented `floor`.".format(self.name)
+        )
+
+    def clip(self: Any, a: Tensor, a_min: Tensor, a_max: Tensor) -> Tensor:
+        """
+        Clip (limit) the values of a tensor element-wise to the range [a_min, a_max].
+
+        Each element in the input tensor `a` is compared against the corresponding
+        bounds `a_min` and `a_max`. If a value in `a` is less than `a_min`, it is set
+        to `a_min`; if greater than `a_max`, it is set to `a_max`. Otherwise, the
+        value is left unchanged. The result preserves the dtype and device of the input.
+
+        :param a: Input tensor containing values to be clipped.
+        :type a: Tensor
+        :param a_min: Lower bound (minimum value) for clipping. Can be a scalar tensor
+                      or broadcastable to the shape of `a`.
+        :type a_min: Tensor
+        :param a_max: Upper bound (maximum value) for clipping. Can be a scalar tensor
+                      or broadcastable to the shape of `a`.
+        :type a_max: Tensor
+        :return: A tensor with the same shape as `a`, where all values are clipped
+                 to lie within the interval [a_min, a_max].
+        :rtype: Tensor
+
+        :raises NotImplementedError: If the backend does not implement `clip`.
+        """
+        raise NotImplementedError(
+            "Backend '{}' has not implemented `clip`.".format(self.name)
+        )
+
     def reverse(self: Any, a: Tensor) -> Tensor:
         """
         return ``a[::-1]``, only 1D tensor is guaranteed for consistent behavior

tensorcircuit/backends/jax_backend.py

@@ -349,6 +349,12 @@ class JaxBackend(jax_backend.JaxBackend, ExtendedBackend):  # type: ignore
     def mod(self, x: Tensor, y: Tensor) -> Tensor:
         return jnp.mod(x, y)
 
+    def floor(self, a: Tensor) -> Tensor:
+        return jnp.floor(a)
+
+    def clip(self, a: Tensor, a_min: Tensor, a_max: Tensor) -> Tensor:
+        return jnp.clip(a, a_min, a_max)
+
     def right_shift(self, x: Tensor, y: Tensor) -> Tensor:
         return jnp.right_shift(x, y)
 

tensorcircuit/backends/numpy_backend.py

@@ -250,6 +250,12 @@ class NumpyBackend(numpy_backend.NumPyBackend, ExtendedBackend):  # type: ignore
     def mod(self, x: Tensor, y: Tensor) -> Tensor:
         return np.mod(x, y)
 
+    def floor(self, a: Tensor) -> Tensor:
+        return np.floor(a)
+
+    def clip(self, a: Tensor, a_min: Tensor, a_max: Tensor) -> Tensor:
+        return np.clip(a, a_min, a_max)
+
     def right_shift(self, x: Tensor, y: Tensor) -> Tensor:
         return np.right_shift(x, y)
 

tensorcircuit/backends/pytorch_backend.py

@@ -429,6 +429,12 @@ class PyTorchBackend(pytorch_backend.PyTorchBackend, ExtendedBackend):  # type:
     def mod(self, x: Tensor, y: Tensor) -> Tensor:
         return torchlib.fmod(x, y)
 
+    def floor(self, a: Tensor) -> Tensor:
+        return torchlib.floor(a)
+
+    def clip(self, a: Tensor, a_min: Tensor, a_max: Tensor) -> Tensor:
+        return torchlib.clamp(a, a_min, a_max)
+
     def right_shift(self, x: Tensor, y: Tensor) -> Tensor:
         return torchlib.bitwise_right_shift(x, y)
 

tensorcircuit/backends/tensorflow_backend.py

@@ -573,6 +573,14 @@ class TensorFlowBackend(tensorflow_backend.TensorFlowBackend, ExtendedBackend):
     def stack(self, a: Sequence[Tensor], axis: int = 0) -> Tensor:
         return tf.stack(a, axis=axis)
 
+    def clip(self, a: Tensor, a_min: Tensor, a_max: Tensor) -> Tensor:
+        return tf.clip_by_value(a, a_min, a_max)
+
+    def floor(self, a: Tensor) -> Tensor:
+        if a.dtype.is_integer:
+            return a
+        return tf.math.floor(a)
+
     def concat(self, a: Sequence[Tensor], axis: int = 0) -> Tensor:
         return tf.concat(a, axis=axis)
 

tensorcircuit/timeevol.py

@@ -2,8 +2,9 @@
 Analog time evolution engines
 """
 
-from typing import Any, Tuple, Optional, Callable, List, Sequence
+from typing import Any, Tuple, Optional, Callable, List, Sequence, Dict
 from functools import partial
+import warnings
 
 import numpy as np
 
@@ -427,37 +428,58 @@ def hamiltonian_evol(
 ed_evol = hamiltonian_evol
 
 
-@partial(arg_alias, alias_dict={"h_fun": ["hamiltonian"], "t": ["times"]})
-def evol_local(
-    c: Circuit,
-    index: Sequence[int],
-    h_fun: Callable[..., Tensor],
-    t: float,
-    *args: Any,
-    **solver_kws: Any,
-) -> Circuit:
-    """
-    ode evolution of time dependent Hamiltonian on circuit of given indices
-    [only jax backend support for now]
+def _solve_ode(
+    f: Callable[..., Tensor],
+    s: Tensor,
+    times: Tensor,
+    args: Any,
+    solver_kws: Dict[str, Any],
+) -> Tensor:
+    rtol = solver_kws.get("rtol", 1e-12)
+    atol = solver_kws.get("atol", 1e-12)
+    ode_backend = solver_kws.get("ode_backend", "jaxode")
+    max_steps = solver_kws.get("max_steps", 10000)
 
-    :param c: _description_
-    :type c: Circuit
-    :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
-    :type h_fun: Callable[..., Tensor]
-    :param t: evolution time
-    :type t: float
-    :return: _description_
-    :rtype: Circuit
-    """
-    s = c.state()
-    n = int(np.log2(s.shape[-1]) + 1e-7)
-    if isinstance(t, float):
-        t = backend.stack([0.0, t])
-    s1 = ode_evol_local(h_fun, s, t, index, None, *args, **solver_kws)
-    return type(c)(n, inputs=s1[-1])
+    ts = backend.convert_to_tensor(times)
+    ts = backend.cast(ts, dtype=rdtypestr)
+
+    if ode_backend == "jaxode":
+        from jax.experimental.ode import odeint
+
+        s1 = odeint(f, s, ts, rtol=rtol, atol=atol, mxstep=max_steps, *args)
+        return s1
+
+    import diffrax
+
+    # Ignore complex warning
+    warnings.simplefilter("ignore", category=UserWarning, append=True)
+
+    solver = solver_kws.get("solver", "Tsit5")
+    dt0 = solver_kws.get("dt0", 0.01)
+    all_solvers = {
+        "Dopri5": diffrax.Dopri5,
+        "Tsit5": diffrax.Tsit5,
+        "Dopri8": diffrax.Dopri8,
+        "Kvaerno5": diffrax.Kvaerno5,
+    }
+
+    # ODE
+    term = diffrax.ODETerm(lambda t, y, args: f(y, t, *args))
+
+    # solve ODE
+    s1 = diffrax.diffeqsolve(
+        terms=term,
+        solver=all_solvers[solver](),
+        t0=times[0],
+        t1=times[-1],
+        dt0=dt0,
+        y0=s,
+        saveat=diffrax.SaveAt(ts=times),
+        args=args,
+        stepsize_controller=diffrax.PIDController(rtol=rtol, atol=atol),
+        max_steps=max_steps,
+    ).ys
+    return s1
 
 
 def ode_evol_local(
@@ -475,6 +497,9 @@ def ode_evol_local(
     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').
+
     Note: This function currently only supports the JAX backend.
 
     :param hamiltonian: A function that returns a dense Hamiltonian matrix for the specified
@@ -490,13 +515,20 @@ 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
+          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'.
     :return: Evolved quantum states at the specified time points. If callback is provided,
         returns the callback results; otherwise returns the state vectors.
     :rtype: Tensor
     """
-    from jax.experimental.ode import odeint
 
-    s = initial_state
     n = int(np.log2(backend.shape_tuple(initial_state)[-1]) + 1e-7)
     l = len(index)
 
@@ -517,38 +549,11 @@ def ode_evol_local(
         y = contractor([y, h], output_edge_order=edges)
         return backend.reshape(y.tensor, [-1])
 
-    ts = backend.convert_to_tensor(times)
-    ts = backend.cast(ts, dtype=rdtypestr)
-    s1 = odeint(f, s, ts, *args, **solver_kws)
-    if not callback:
-        return s1
-    return backend.stack([callback(s1[i]) for i in range(len(s1))])
+    s1 = _solve_ode(f, initial_state, times, args, solver_kws)
 
-
-@partial(arg_alias, alias_dict={"h_fun": ["hamiltonian"], "t": ["times"]})
-def evol_global(
-    c: Circuit, h_fun: Callable[..., Tensor], t: float, *args: Any, **solver_kws: Any
-) -> Circuit:
-    """
-    ode evolution of time dependent Hamiltonian on circuit of all qubits
-    [only jax backend support for now]
-
-    :param c: _description_
-    :type c: Circuit
-    :param h_fun: h_fun should return a **SPARSE** Hamiltonian matrix
-        with input arguments time and *args
-    :type h_fun: Callable[..., Tensor]
-    :param t: _description_
-    :type t: float
-    :return: _description_
-    :rtype: Circuit
-    """
-    s = c.state()
-    n = c._nqubits
-    if isinstance(t, float):
-        t = backend.stack([0.0, t])
-    s1 = ode_evol_global(h_fun, s, t, None, *args, **solver_kws)
-    return type(c)(n, inputs=s1[-1])
+    if callback is None:
+        return s1
+    return backend.stack([callback(a_state) for a_state in s1])
 
 
 def ode_evol_global(
@@ -564,7 +569,10 @@ def ode_evol_global(
 
     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.
+      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.
 
@@ -578,25 +586,91 @@ def ode_evol_global(
     :param callback: Optional function to apply to the state at each time step.
     :type callback: Optional[Callable[..., Tensor]]
     :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
+          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'.
+    :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
     """
-    from jax.experimental.ode import odeint
-
-    s = initial_state
-    ts = backend.convert_to_tensor(times)
-    ts = backend.cast(ts, dtype=rdtypestr)
 
     def f(y: Tensor, t: Tensor, *args: Any) -> Tensor:
         h = -1.0j * hamiltonian(t, *args)
         return backend.sparse_dense_matmul(h, y)
 
-    s1 = odeint(f, s, ts, *args, **solver_kws)
-    if not callback:
+    s1 = _solve_ode(f, initial_state, times, args, solver_kws)
+
+    if callback is None:
         return s1
-    return backend.stack([callback(s1[i]) for i in range(len(s1))])
+    return backend.stack([callback(a_state) for a_state in s1])
+
+
+@partial(arg_alias, alias_dict={"h_fun": ["hamiltonian"], "t": ["times"]})
+def evol_local(
+    c: Circuit,
+    index: Sequence[int],
+    h_fun: Callable[..., Tensor],
+    t: float,
+    *args: Any,
+    **solver_kws: Any,
+) -> Circuit:
+    """
+    ode evolution of time dependent Hamiltonian on circuit of given indices
+    [only jax backend support for now]
+
+    :param c: _description_
+    :type c: Circuit
+    :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
+    :type h_fun: Callable[..., Tensor]
+    :param t: evolution time
+    :type t: float
+    :return: _description_
+    :rtype: Circuit
+    """
+    s = c.state()
+    n = int(np.log2(s.shape[-1]) + 1e-7)
+    if isinstance(t, float):
+        t = backend.stack([0.0, t])
+    s1 = ode_evol_local(h_fun, s, t, index, None, *args, **solver_kws)
+    return type(c)(n, inputs=s1[-1])
+
+
+@partial(arg_alias, alias_dict={"h_fun": ["hamiltonian"], "t": ["times"]})
+def evol_global(
+    c: Circuit, h_fun: Callable[..., Tensor], t: float, *args: Any, **solver_kws: Any
+) -> Circuit:
+    """
+    ode evolution of time dependent Hamiltonian on circuit of all qubits
+    [only jax backend support for now]
+
+    :param c: _description_
+    :type c: Circuit
+    :param h_fun: h_fun should return a **SPARSE** Hamiltonian matrix
+        with input arguments time and *args
+    :type h_fun: Callable[..., Tensor]
+    :param t: _description_
+    :type t: float
+    :return: _description_
+    :rtype: Circuit
+    """
+    s = c.state()
+    n = c._nqubits
+    if isinstance(t, float):
+        t = backend.stack([0.0, t])
+    s1 = ode_evol_global(h_fun, s, t, None, *args, **solver_kws)
+    return type(c)(n, inputs=s1[-1])
 
 
 def chebyshev_evol(

{tensorcircuit_nightly-1.3.0.dev20250827.dist-info → tensorcircuit_nightly-1.3.0.dev20250829.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorcircuit-nightly
-Version: 1.3.0.dev20250827
+Version: 1.3.0.dev20250829
 Summary: High performance unified quantum computing framework for the NISQ era
 Author-email: TensorCircuit Authors <znfesnpbh@gmail.com>
 License-Expression: Apache-2.0
@@ -341,8 +341,10 @@ TensorCircuit-NG is open source, released under the Apache License, Version 2.0.
       <td align="center" valign="top" width="16.66%"><a href="https://adeshpande.gitlab.io"><img src="https://avatars.githubusercontent.com/u/6169877?v=4?s=100" width="100px;" alt="Abhinav Deshpande"/><br /><sub><b>Abhinav Deshpande</b></sub></a><br /><a href="https://github.com/tensorcircuit/tensorcircuit-ng/commits?author=abhinavd" title="Code">💻</a></td>
     </tr>
     <tr>
-      <td align="center" valign="top" width="16.66%"><a href="https://github.com/Stellogic"><img src="https://avatars.githubusercontent.com/u/186928579?v=4?s=100" width="100px;" alt="Stellogic"/><br /><sub><b>Stellogic</b></sub></a><br /><a href="https://github.com/tensorcircuit/tensorcircuit-ng/commits?author=Stellogic" title="Code">💻</a> <a href="#example-Stellogic" title="Examples">💡</a> <a href="https://github.com/tensorcircuit/tensorcircuit-ng/commits?author=Stellogic" title="Tests">⚠️</a></td>
+      <td align="center" valign="top" width="16.66%"><a href="https://github.com/Stellogic"><img src="https://avatars.githubusercontent.com/u/186928579?v=4?s=100" width="100px;" alt="Stellogic"/><br /><sub><b>Stellogic</b></sub></a><br /><a href="https://github.com/tensorcircuit/tensorcircuit-ng/commits?author=Stellogic" title="Code">💻</a> <a href="#example-Stellogic" title="Examples">💡</a> <a href="https://github.com/tensorcircuit/tensorcircuit-ng/commits?author=Stellogic" title="Tests">⚠️</a> <a href="#tutorial-Stellogic" title="Tutorials">✅</a></td>
       <td align="center" valign="top" width="16.66%"><a href="https://github.com/Charlespkuer"><img src="https://avatars.githubusercontent.com/u/112697147?v=4?s=100" width="100px;" alt="Huang"/><br /><sub><b>Huang</b></sub></a><br /><a href="https://github.com/tensorcircuit/tensorcircuit-ng/commits?author=Charlespkuer" title="Code">💻</a> <a href="#example-Charlespkuer" title="Examples">💡</a> <a href="https://github.com/tensorcircuit/tensorcircuit-ng/commits?author=Charlespkuer" title="Tests">⚠️</a></td>
+      <td align="center" valign="top" width="16.66%"><a href="https://github.com/Huang-Xu-Yang"><img src="https://avatars.githubusercontent.com/u/227286661?v=4?s=100" width="100px;" alt="Huang-Xu-Yang"/><br /><sub><b>Huang-Xu-Yang</b></sub></a><br /><a href="https://github.com/tensorcircuit/tensorcircuit-ng/commits?author=Huang-Xu-Yang" title="Code">💻</a> <a href="https://github.com/tensorcircuit/tensorcircuit-ng/commits?author=Huang-Xu-Yang" title="Tests">⚠️</a></td>
+      <td align="center" valign="top" width="16.66%"><a href="https://github.com/WeiguoMa"><img src="https://avatars.githubusercontent.com/u/108172530?v=4?s=100" width="100px;" alt="Weiguo_M"/><br /><sub><b>Weiguo_M</b></sub></a><br /><a href="https://github.com/tensorcircuit/tensorcircuit-ng/commits?author=WeiguoMa" title="Code">💻</a> <a href="https://github.com/tensorcircuit/tensorcircuit-ng/commits?author=WeiguoMa" title="Tests">⚠️</a></td>
     </tr>
   </tbody>
 </table>
@@ -423,6 +425,18 @@ For the simulation code and data for variational optimization of simutaneous exc
 
 Reference paper: https://arxiv.org/abs/2504.21459.
 
+### Quantum Machine Unlearning
+
+For the simulation code for the work "superior resilience to poisoning and amenability to unlearning in quantum machine learning", see the [project repo](https://github.com/yutuer21/quantum-machine-unlearning).
+
+Reference paper: https://arxiv.org/abs/2508.02422.
+
+### Low Weight Pauli Propagation Simulation
+
+For the simulation code and data for the work on low weight Pauli propagation in the context of variational quantum algorithms, see the [project repo](https://github.com/ZongliangLi/lwpp_init).
+
+Reference paper: https://arxiv.org/abs/2508.06358.
+
 ### More works
 
 <details>
@@ -468,20 +482,28 @@ Reference paper: https://arxiv.org/abs/2504.21459.
 
 - Variational post-selection for ground states and thermal states simulation: https://arxiv.org/abs/2402.07605 (published in QST).
 
-- Subsystem information capacity in random circuits and Hamiltonian dynamics: https://arxiv.org/abs/2405.05076. Code implementation: https://github.com/sxzgroup/subsystem_information_capacity.
+- Subsystem information capacity in random circuits and Hamiltonian dynamics: https://arxiv.org/abs/2405.05076 (published in Quantum). Code implementation: https://github.com/sxzgroup/subsystem_information_capacity.
 
 - Symmetry restoration and quantum Mpemba effect in symmetric random circuits: https://arxiv.org/abs/2403.08459 (published in PRL).
 
 - Quantum Mpemba effects in many-body localization systems: https://arxiv.org/abs/2408.07750.
 
-- Supersymmetry dynamics on Rydberg atom arrays: https://arxiv.org/abs/2410.21386.
+- Supersymmetry dynamics on Rydberg atom arrays: https://arxiv.org/abs/2410.21386 (published in PRB).
 
 - Dynamic parameterized quantum circuits: expressive and barren-plateau free: https://arxiv.org/abs/2411.05760.
 
-- Holographic deep thermalization: https://arxiv.org/abs/2411.03587.
+- Holographic deep thermalization: https://arxiv.org/abs/2411.03587 (published in Nature Communications).
 
 - Quantum deep generative prior with programmable quantum circuits: https://www.nature.com/articles/s42005-024-01765-9 (published in Communications Physics).
 
+- Symmetry Breaking Dynamics in Quantum Many-Body Systems: https://arxiv.org/abs/2501.13459.
+
+- Entanglement growth and information capacity in a quasiperiodic system with a single-particle mobility edge: https://arxiv.org/abs/2506.18076.
+
+- Hilbert subspace imprint: a new mechanism for non-thermalization: https://arxiv.org/abs/2506.11922.
+
+- A Neural-Guided Variational Quantum Algorithm for Efficient Sign Structure Learning in Hybrid Architectures: https://arxiv.org/abs/2507.07555.
+
 </details>
 
 If you want to highlight your research work or projects here, feel free to add by opening PR.

{tensorcircuit_nightly-1.3.0.dev20250827.dist-info → tensorcircuit_nightly-1.3.0.dev20250829.dist-info}/RECORD

@@ -1,4 +1,4 @@
-tensorcircuit/__init__.py,sha256=VO-xt3YRw3BjGLMdK--G4OsO09dS3nGnsyXW0OXY4a0,2055
+tensorcircuit/__init__.py,sha256=LEOfft6DW_tzSmZTmjA_Pzd0XljJyi8pTRi1pT7gR_4,2055
 tensorcircuit/about.py,sha256=DazTswU2nAwOmASTaDII3L04PVtaQ7oiWPty5YMI3Wk,5267
 tensorcircuit/abstractcircuit.py,sha256=0osacPqq7B1EJki-cI1aLYoVRmjFaG9q3XevWMs7SsA,44125
 tensorcircuit/asciiart.py,sha256=neY1OWFwtoW5cHPNwkQHgRPktDniQvdlP9QKHkk52fM,8236
@@ -18,7 +18,7 @@ tensorcircuit/quantum.py,sha256=68SZ1lXJZSKVr5xe3_uvU-_25GOFnSPGlw4Ziaj1nBI,1046
 tensorcircuit/shadows.py,sha256=6XmWNubbuaxFNvZVWu-RXd0lN9Jkk-xwong_K8o8_KE,17014
 tensorcircuit/simplify.py,sha256=O11G3UYiVAc30GOfwXXmhLXwGZrQ8OVwLTMQMZp_XBc,9414
 tensorcircuit/stabilizercircuit.py,sha256=KbrBVSo2pXnf5JHIrxwRPSPTm7bJVMIcyE4d7-dIfCM,15545
-tensorcircuit/timeevol.py,sha256=GDD6IgzkRhZIyvLkSKJ7ZihnkHQBqoWOBsmBwRAC1UI,28574
+tensorcircuit/timeevol.py,sha256=dmFXDqBFvQI54QK9ViJ9XEVVha9QIE8Bl0sZ1mN85PI,31695
 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=W1IMVKVxpx2F-7Cu4zzNIe3UZPQfjAi7niPuirf-pJA,66267
+tensorcircuit/backends/abstract_backend.py,sha256=PFfiWLkZ6izj34rRTTNeSp0VesSwFPXM_SIDqQ_viLA,69210
 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=AWUaX044duGJGfxIpQ2NB3fu_qGuB0N9ghm83DE547g,27829
+tensorcircuit/backends/jax_backend.py,sha256=PjvPbSItMwYpW83sKOmZb2QKz6LjClFIMbAzQWCK124,28013
 tensorcircuit/backends/jax_ops.py,sha256=WyUGavch2R9uEFsI1Ap7eP1UcU4s2TItBgGsrVS3Hzs,9320
-tensorcircuit/backends/numpy_backend.py,sha256=d0As0VlnvM2RZS2wHWlDqDdxeHFtI8TvUWafqs51wC4,15333
-tensorcircuit/backends/pytorch_backend.py,sha256=PTrbzOR_U0_ik9dhcaCXKYluyM-G5vDIKR5xjubq02k,25387
+tensorcircuit/backends/numpy_backend.py,sha256=yNBj45W9-VMo-61ihzAAFS5jaj-bHJz0OJB9gZjwYUA,15515
+tensorcircuit/backends/pytorch_backend.py,sha256=6nTIG3NO6N2ChzfSOq3Wmti3n5hxkcMwvp7NQ7XEG2w,25582
 tensorcircuit/backends/pytorch_ops.py,sha256=lLxpK6OqfpVwifyFlgsqhpnt-oIn4R5paPMVg51WaW0,3826
-tensorcircuit/backends/tensorflow_backend.py,sha256=GY9jQ_CeOJ8s6X0rPbopUJD9tlucHbjwNlSH8NU98M8,39466
+tensorcircuit/backends/tensorflow_backend.py,sha256=VgigYIGkwluHv1I2dS01cU11VPrZnMaAp2R1sZKOFnk,39714
 tensorcircuit/backends/tf_ops.py,sha256=FJwDU7LhZrt0VUIx12DJU0gZnWhMv7B7r9sAKG710As,3378
 tensorcircuit/cloud/__init__.py,sha256=n0Lx07GYF6YbdIa6AJCLJk4zlAm5CqaeHszvkxxuoI4,139
 tensorcircuit/cloud/abstraction.py,sha256=6aSxbz0MP21jBVdFbSMrvJPLQH117vGz9sSHbMFoodE,14582
@@ -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.dev20250827.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-tensorcircuit_nightly-1.3.0.dev20250827.dist-info/METADATA,sha256=NXMdB219n5aV5ZrObJc8EHlDYaA3fI3rnoliVD7bYgo,35709
-tensorcircuit_nightly-1.3.0.dev20250827.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tensorcircuit_nightly-1.3.0.dev20250827.dist-info/top_level.txt,sha256=9dcuK5488dWpVauYz8cdvx743z_La1h7zIQCsEEgu7o,14
-tensorcircuit_nightly-1.3.0.dev20250827.dist-info/RECORD,,
+tensorcircuit_nightly-1.3.0.dev20250829.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+tensorcircuit_nightly-1.3.0.dev20250829.dist-info/METADATA,sha256=OwvpfaiSv7EJSzYYNcrAg8J46wTlioOwXTS6SQ_Ofyw,37856
+tensorcircuit_nightly-1.3.0.dev20250829.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tensorcircuit_nightly-1.3.0.dev20250829.dist-info/top_level.txt,sha256=9dcuK5488dWpVauYz8cdvx743z_La1h7zIQCsEEgu7o,14
+tensorcircuit_nightly-1.3.0.dev20250829.dist-info/RECORD,,