NetKet 3.15.2__tar.gz → 3.16__tar.gz

{netket-3.15.2 → netket-3.16}/.gitignore

@@ -21,6 +21,7 @@ pip-wheel-metadata
 .virtual_documents
 .ruff_cache
 oldest_requirements.txt
+uv.lock
 
 # Packages #
 ############

{netket-3.15.2 → netket-3.16}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: NetKet
-Version: 3.15.2
+Version: 3.16
 Summary: Netket : Machine Learning toolbox for many-body quantum systems.
 Project-URL: homepage, https://www.netket.org
 Project-URL: documentation, https://netket.readthedocs.io/en/latest/#
@@ -8,6 +8,7 @@ Project-URL: repository, https://github.com/netket/netket
 Project-URL: changelog, https://netket.readthedocs.io/en/latest/docs/changelog.html
 Author: Giuseppe Carleo, Filippo Vicentini, The NetKet authors
 License: Apache 2.0
+License-File: LICENSE
 Keywords: Jax,Machine Learning,Monte Carlo,Neural Networks,Neural Quantum States,Quantum
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
@@ -18,19 +19,19 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: >=3.10
 Requires-Dist: equinox>=0.11.3
-Requires-Dist: flax>=0.7.1
+Requires-Dist: flax>=0.10.2
 Requires-Dist: igraph>=0.10.0
-Requires-Dist: jax>=0.4.16
+Requires-Dist: jax>=0.4.38
 Requires-Dist: numba>=0.59
 Requires-Dist: numpy<3.0,>=1.20
-Requires-Dist: optax<0.3,>=0.1.3
+Requires-Dist: optax<0.3,>=0.2.2
 Requires-Dist: orjson<4,>=3.4
 Requires-Dist: plum-dispatch>=2.4
-Requires-Dist: rich>=10.0
+Requires-Dist: rich>=12.0
 Requires-Dist: scipy<2,>=1.5.3
 Requires-Dist: tqdm<5,>=4.60
 Provides-Extra: dev
-Requires-Dist: black==24.10.0; extra == 'dev'
+Requires-Dist: black==24.1.0; extra == 'dev'
 Requires-Dist: build>=1; extra == 'dev'
 Requires-Dist: coverage>=5; extra == 'dev'
 Requires-Dist: matplotlib>=3; extra == 'dev'
@@ -41,12 +42,12 @@ Requires-Dist: pytest-json-report>=1.3; extra == 'dev'
 Requires-Dist: pytest-xdist[psutil]>=2; extra == 'dev'
 Requires-Dist: pytest>=6; extra == 'dev'
 Requires-Dist: qutip>=5; extra == 'dev'
-Requires-Dist: ruff==0.7.3; extra == 'dev'
+Requires-Dist: ruff==0.9.4; extra == 'dev'
 Requires-Dist: wheel>=0.38.1; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: myst-nb<1.2,>=1.0; extra == 'docs'
 Requires-Dist: myst-parser<4.1.0,>=2.0.0; extra == 'docs'
-Requires-Dist: sphinx-autodoc-typehints<3.0,>=1.22; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints<4.0,>=1.22; extra == 'docs'
 Requires-Dist: sphinx-book-theme~=1.1.0; extra == 'docs'
 Requires-Dist: sphinx-design>=0.4.0; extra == 'docs'
 Requires-Dist: sphinx<8.2,>=7.0; extra == 'docs'

{netket-3.15.2 → netket-3.16}/netket/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.15.2'
-__version_tuple__ = version_tuple = (3, 15, 2)
+__version__ = version = '3.16'
+__version_tuple__ = version_tuple = (3, 16)

{netket-3.15.2 → netket-3.16}/netket/errors.py

@@ -657,7 +657,7 @@ class SymmModuleInvalidInputShape(NetketError):
 
     def __init__(self, name, x):
         super().__init__(
-            """
+            f"""
             Input to DenseSymmFFT has {x.ndim =} but 3 are required.
 
             The input format is (B,C,L), aka (batches, features/channels, length). If
@@ -1128,3 +1128,38 @@ def concrete_or_error(force, value, error_class, *args, **kwargs):
         )
     except ConcretizationTypeError as err:
         raise error_class(*args, **kwargs) from err
+
+
+#################################################
+# Graph errors                                  #
+#################################################
+
+
+class InitializePeriodicLatticeOnSmallLatticeWarning(NetketWarning):
+    """
+    Warning thrown when attempting to create a periodic lattice on a lattice with less than two sites in one direction.
+
+    In a periodic lattice with two sites (a, b) in one direction,
+    the expected behavior is to have an edge connecting both a->b and b->a
+
+    However, as the lattice uses an undirected graph to represent the lattice, it does not support this behavior.
+    Hence, only one edge a->b is created, which makes the behavior equivalent to an open boundary condition in this direction.
+
+    This may cause unexpected behavior if you intend to loop over the edges to create a Hamiltonian, for example.
+
+    To avoid this warning, consider either using a lattice with more than two sites in the direction you want to be periodic,
+    or define the graph using :class:`~netket.graph.Graph` by adding the edges manually.
+    """
+
+    def __init__(self, extent, dimension):
+        super().__init__(
+            f"""
+            You are attempting to define a lattice with length {extent} in dimension {dimension} using periodic boundary condition.
+
+            Lattice with less than two sites in one direction does not support periodic boundary condition.
+            The behavior of the lattice is equivalent to an open boundary condition in this direction.
+
+            To avoid this warning, consider either using a lattice with more than two sites in the direction you want to be periodic,
+            or define the graph using :class:`~netket.graph.Graph` by adding the edges manually.
+            """
+        )

{netket-3.15.2 → netket-3.16}/netket/experimental/driver/tdvp.py

@@ -38,15 +38,6 @@ class TDVP(TDVPBaseDriver):
     Variational time evolution based on the time-dependent variational principle which,
     when used with Monte Carlo sampling via :class:`netket.vqs.MCState`, is the time-dependent VMC
     (t-VMC) method.
-
-    .. note::
-        This TDVP Driver uses the time-integrators from the `nkx.dynamics` module, which are
-        automatically executed under a `jax.jit` context.
-
-        When running computations on GPU, this can lead to infinite hangs or extremely long
-        compilation times. In those cases, you might try setting the configuration variable
-        `nk.config.netket_experimental_disable_ode_jit = True` to mitigate those issues.
-
     """
 
     def __init__(

{netket-3.15.2 → netket-3.16}/netket/experimental/driver/tdvp_common.py

@@ -12,20 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from collections.abc import Callable
-from collections.abc import Sequence
+from collections.abc import Callable, Sequence
+from functools import partial
 import warnings
 
-import jax
 import jax.numpy as jnp
 import numpy as np
 from tqdm.auto import tqdm
 
 import netket as nk
-from netket import config
 from netket.driver import AbstractVariationalDriver
 from netket.driver.abstract_variational_driver import _to_iterable
-from netket.jax import HashablePartial
 from netket.logging.json_log import JsonLog
 from netket.operator import AbstractOperator
 from netket.utils import mpi, timing
@@ -45,15 +42,6 @@ class TDVPBaseDriver(AbstractVariationalDriver):
     Variational time evolution based on the time-dependent variational principle which,
     when used with Monte Carlo sampling via :class:`netket.vqs.MCState`, is the time-dependent VMC
     (t-VMC) method.
-
-    .. note::
-        This TDVP Driver uses the time-integrators from the `nkx.dynamics` module, which are
-        automatically executed under a `jax.jit` context.
-
-        When running computations on GPU, this can lead to infinite hangs or extremely long
-        compilation times. In those cases, you might try setting the configuration variable
-        :py:`nk.config.netket_experimental_disable_ode_jit = True` to mitigate those issues.
-
     """
 
     def __init__(
@@ -107,8 +95,6 @@ class TDVPBaseDriver(AbstractVariationalDriver):
         self._last_qgt = None
         self._integrator = None
 
-        self._odefun = HashablePartial(odefun_host_callback, self.state, self)
-
         self.error_norm = error_norm
 
         if integrator is not None:
@@ -149,7 +135,7 @@ class TDVPBaseDriver(AbstractVariationalDriver):
             t0 = self.t
 
         self._integrator = Integrator(
-            self._odefun,
+            partial(odefun, self.state, self),
             new_ode_solver,
             t0,
             self.state.parameters,
@@ -186,18 +172,7 @@ class TDVPBaseDriver(AbstractVariationalDriver):
         elif error_norm == "maximum":
             self._error_norm = maximum_norm
         elif error_norm == "qgt":
-            if config.netket_experimental_disable_ode_jit:
-                self._error_norm = HashablePartial(qgt_norm, self)
-            else:
-                w = self.state.parameters
-                norm_dtype = nk.jax.dtype_real(nk.jax.tree_dot(w, w))
-                # QGT norm is called via host callback since it accesses the driver
-                # TODO: make this also an hashablepartial on self to reduce recompilation
-                self._error_norm = lambda x: jax.pure_callback(
-                    HashablePartial(qgt_norm, self),
-                    jax.ShapeDtypeStruct((), norm_dtype),
-                    x,
-                )
+            self._error_norm = partial(qgt_norm, self)
         else:
             raise ValueError(
                 "error_norm must be a callable or one of 'euclidean', 'qgt', 'maximum',"
@@ -479,7 +454,7 @@ class TDVPBaseDriver(AbstractVariationalDriver):
             t = self.t
         if w is None:
             w = self.state.parameters
-        return self._odefun(t, w)
+        return odefun(self.state, self, t, w)
 
 
 def qgt_norm(driver: TDVPBaseDriver, x: PyTree):
@@ -495,25 +470,3 @@ def qgt_norm(driver: TDVPBaseDriver, x: PyTree):
 def odefun(state, driver, t, w, **kwargs):
     # pylint: disable=unused-argument
     raise NotImplementedError(f"odefun not implemented for {type(state)}")
-
-
-def odefun_host_callback(state, driver, *args, **kwargs):
-    """
-    Calls odefun through a host callback in order to make the rest of the
-    ODE inteagrator jit-able.
-    """
-    if config.netket_experimental_disable_ode_jit:
-        return odefun(state, driver, *args, **kwargs)
-
-    result_shape = jax.tree_util.tree_map(
-        lambda x: jax.ShapeDtypeStruct(x.shape, x.dtype),
-        state.parameters,
-    )
-
-    return jax.pure_callback(
-        lambda args_and_kw: odefun(state, driver, *args_and_kw[0], **args_and_kw[1]),
-        result_shape,
-        # pack args and kwargs together, since host_callback passes a single argument:
-        (args, kwargs),
-    )
-    return odefun(state, driver, *args, **kwargs)

{netket-3.15.2 → netket-3.16}/netket/experimental/driver/tdvp_schmitt.py

@@ -88,16 +88,6 @@ class TDVPSchmitt(TDVPBaseDriver):
     :math:`\rho_k=V_{k,k'}^{\dagger}F_{k'}` (see
     `[arXiv:1912.08828] <https://arxiv.org/pdf/1912.08828.pdf>`_ for details).
 
-
-    .. note::
-
-        This TDVP Driver uses the time-integrators from the `nkx.dynamics` module, which are
-        automatically executed under a `jax.jit` context.
-
-        When running computations on GPU, this can lead to infinite hangs or extremely long
-        compilation times. In those cases, you might try setting the configuration variable
-        `nk.config.netket_experimental_disable_ode_jit = True` to mitigate those issues.
-
     """
 
     def __init__(
@@ -225,8 +215,16 @@ def _impl(parameters, n_samples, E_loc, S, rhs_coeff, rcond, rcond_smooth, snr_a
     QEdata = Q.conj() * ΔE_loc
     rho = V.conj().T @ F
 
-    # Compute the SNR according to Eq. 21
-    snr = jnp.abs(rho) * jnp.sqrt(n_samples) / jnp.sqrt(stats.var(QEdata, axis=0))
+    # Compute the SNR according to Eq. 21 but taking care of where sigma_k is zero
+    sigma_k = jnp.maximum(jnp.sqrt(stats.var(QEdata, axis=0)), rcond)
+    # Here we are hardcoding the case where rho==0 and sigma_k==0 to have infinite snr.
+    # This is an arbitrary choice, but avoids generating NaNs in the snr calculation.
+    # See netket#1959 and #1960 for more details.
+    snr = jnp.where(
+        sigma_k == 0,
+        jnp.inf,
+        jnp.abs(rho) * jnp.sqrt(n_samples) / sigma_k,
+    )
 
     # Discard eigenvalues below numerical precision
     ev_inv = jnp.where(jnp.abs(ev / ev[-1]) > rcond, 1.0 / ev, 0.0)

{netket-3.15.2 → netket-3.16}/netket/experimental/dynamics/_integrator.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Callable, Optional
-from functools import partial
+from collections.abc import Callable
 
 import jax
 import jax.numpy as jnp
@@ -27,7 +26,6 @@ from ._integrator_state import IntegratorState, IntegratorFlags
 from ._integrator_params import IntegratorParameters
 from ._solver import AbstractSolver
 from ._utils import (
-    maybe_jax_jit,
     scaled_error,
     propose_time_step,
     set_flag_jax,
@@ -217,12 +215,11 @@ class Integrator(struct.Pytree, mutable=True):
         )
 
     @staticmethod
-    @partial(maybe_jax_jit, static_argnames=["f"])
     def _step_fixed(
         solver: AbstractSolver,
         f: Callable,
         state: IntegratorState,
-        max_dt: Optional[float],
+        max_dt: float | None,
         parameters: IntegratorParameters,
     ) -> IntegratorState:
         r"""
@@ -263,12 +260,11 @@ class Integrator(struct.Pytree, mutable=True):
         )
 
     @staticmethod
-    @partial(maybe_jax_jit, static_argnames=["f", "norm_fn"])
     def _step_adaptive(
         solver: AbstractSolver,
         f: Callable,
         state: IntegratorState,
-        max_dt: Optional[float],
+        max_dt: float | None,
         parameters: IntegratorParameters,
         norm_fn: Callable,
     ) -> IntegratorState:

{netket-3.15.2 → netket-3.16}/netket/experimental/dynamics/_integrator_params.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional
 
 from netket.utils import struct
 
@@ -29,7 +28,7 @@ class IntegratorParameters(struct.Pytree):
     rtol: float
     """The tolerance for the relative error on the solution."""
 
-    dt_limits: Optional[LimitsDType] = struct.field(pytree_node=False)
+    dt_limits: LimitsDType | None = struct.field(pytree_node=False)
     """The extremal accepted values for the time-step size `dt`."""
 
     def __init__(
@@ -37,7 +36,7 @@ class IntegratorParameters(struct.Pytree):
         dt: float,
         atol: float = 0.0,
         rtol: float = 1e-7,
-        dt_limits: Optional[LimitsDType] = None,
+        dt_limits: LimitsDType | None = None,
     ):
         r"""
         Args:

{netket-3.15.2 → netket-3.16}/netket/experimental/dynamics/_rk/_solver.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Callable
+from collections.abc import Callable
 
 import jax
 import jax.numpy as jnp

{netket-3.15.2 → netket-3.16}/netket/experimental/dynamics/_solver.py

@@ -114,9 +114,7 @@ class AbstractSolver(Pytree):
         )
 
     def __repr__(self) -> str:
-        return "{}(dt={}, adaptive={}, integrator_parameters={})".format(
-            self.__class__.__name__, self.dt, self.adaptive, self.integrator_params
-        )
+        return f"{self.__class__.__name__}(dt={self.dt}, adaptive={self.adaptive}, integrator_parameters={self.integrator_params})"
 
     @property
     def is_explicit(self) -> bool:

{netket-3.15.2 → netket-3.16}/netket/experimental/dynamics/_utils.py

@@ -12,14 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from functools import wraps
 
 import jax
 import jax.numpy as jnp
 
 import netket.jax as nkjax
-from netket import config
-from netket.utils.types import Array, PyTree, Callable
+from netket.utils.types import Array, PyTree
 
 
 LimitsDType = tuple[float | None, float | None]
@@ -53,29 +51,6 @@ def propose_time_step(
     )
 
 
-def maybe_jax_jit(fun: Callable, *jit_args, **jit_kwargs) -> Callable:
-    """
-    Only jit if `config.netket_experimental_disable_ode_jit` is False.
-
-    This is used to disable jitting when this config is set. The switch is
-    performed at runtime so that the flag can be changed as desired.
-    """
-
-    # jit the function only once:
-    jitted_fun = jax.jit(fun, *jit_args, **jit_kwargs)
-
-    @wraps(fun)
-    def _maybe_jitted_fun(*args, **kwargs):
-        if config.netket_experimental_disable_ode_jit:
-            with jax.spmd_mode("allow_all"):
-                res = fun(*args, **kwargs)
-            return res
-        else:
-            return jitted_fun(*args, **kwargs)
-
-    return _maybe_jitted_fun
-
-
 def set_flag_jax(condition, flags, flag):
     """
     If `condition` is true, `flags` is updated by setting `flag` to 1.

{netket-3.15.2 → netket-3.16}/netket/experimental/hilbert/__init__.py

@@ -15,7 +15,22 @@
 
 __all__ = ["SpinOrbitalFermions"]
 
-from .spin_orbital_fermions import SpinOrbitalFermions
+from netket.hilbert import SpinOrbitalFermions as _deprecated_SpinOrbitalFermions
+
+
+_deprecations = {
+    # May 2024
+    "SpinOrbitalFermions": (
+        "netket.experimental.hilbert.SpinOrbitalFermions is deprecated: use "
+        "netket.hilbert.SpinOrbitalFermions (netket >= 3.12)",
+        _deprecated_SpinOrbitalFermions,
+    ),
+}
+
+from netket.utils.deprecation import deprecation_getattr as _deprecation_getattr
+
+__getattr__ = _deprecation_getattr(__name__, _deprecations)
+del _deprecation_getattr
 
 from netket.utils import _hide_submodules
 

netket-3.16/netket/experimental/models/__init__.py

@@ -0,0 +1,38 @@
+# Copyright 2021 The NetKet Authors - All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .rnn import RNN, LSTMNet, GRUNet1D
+from .fast_rnn import FastRNN, FastLSTMNet, FastGRUNet1D
+
+from netket.models import Slater2nd as _deprecated_Slater2nd
+from netket.models import MultiSlater2nd as _deprecated_MultiSlater2nd
+
+_deprecations = {
+    # May 2024
+    "Slater2nd": (
+        "netket.experimental.models.Slater2nd is deprecated: use "
+        "netket.models.Slater2nd (netket >= 3.12)",
+        _deprecated_Slater2nd,
+    ),
+    "MultiSlater2nd": (
+        "netket.experimental.models.MultiSlater2nd is deprecated: use "
+        "netket.models.MultiSlater2nd (netket >= 3.12)",
+        _deprecated_MultiSlater2nd,
+    ),
+}
+
+from netket.utils.deprecation import deprecation_getattr as _deprecation_getattr
+
+__getattr__ = _deprecation_getattr(__name__, _deprecations)
+del _deprecation_getattr

netket-3.16/netket/experimental/operator/__init__.py

@@ -0,0 +1,47 @@
+# Copyright 2021 The NetKet Authors - All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+__all__ = ["FermionOperator2nd", "FermionOperator2ndJax"]
+
+from .pyscf import from_pyscf_molecule
+
+
+from . import fermion
+
+from netket.operator import FermionOperator2nd as _deprecated_FermionOperator2nd
+from netket.operator import FermionOperator2ndJax as _deprecated_FermionOperator2ndJax
+
+_deprecations = {
+    # June 2024, NetKet 3.13
+    "FermionOperator2nd": (
+        "netket.experimental.operator.FermionOperator2nd is deprecated: use "
+        "netket.operator.FermionOperator2nd (netket >= 3.13)",
+        _deprecated_FermionOperator2nd,
+    ),
+    "FermionOperator2ndJax": (
+        "netket.experimental.operator.FermionOperator2ndJax is deprecated: use "
+        "netket.operator.FermionOperator2ndJax (netket >= 3.13)",
+        _deprecated_FermionOperator2ndJax,
+    ),
+}
+
+
+from netket.utils import _auto_export
+from netket.utils.deprecation import deprecation_getattr as _deprecation_getattr
+
+__getattr__ = _deprecation_getattr(__name__, _deprecations)
+_auto_export(__name__)
+
+del _deprecation_getattr, _auto_export

netket-3.16/netket/experimental/operator/fermion.py

@@ -0,0 +1,44 @@
+# Copyright 2021 The NetKet Authors - All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""
+This file only contains deprecated bindings. To be removed.
+"""
+
+from netket.operator import fermion as _deprecated_fermion
+
+_deprecations = {
+    # June 2024, NetKet 3.13
+    f"{_name}": (
+        f"netket.experimental.operator.fermion.{_name} is deprecated: use "
+        f"netket.operator.fermion.{_name} (netket >= 3.13)",
+        getattr(_deprecated_fermion, _name),
+    )
+    for _name in [
+        "destroy",
+        "create",
+        "number",
+        "identity",
+        "zero",
+    ]
+}
+
+from netket.utils import _auto_export  # noqa: E402
+from netket.utils.deprecation import (  # noqa: E402
+    deprecation_getattr as _deprecation_getattr,
+)
+
+__getattr__ = _deprecation_getattr(__name__, _deprecations)
+_auto_export(__name__)

{netket-3.15.2 → netket-3.16}/netket/experimental/operator/pyscf.py

@@ -19,9 +19,9 @@ import jax
 import jax.numpy as jnp
 
 from netket.operator import DiscreteOperator
-from netket.experimental.hilbert import SpinOrbitalFermions
+from netket.hilbert import SpinOrbitalFermions
 from netket.utils.optional_deps import import_optional_dependency
-from ._fermion_operator_2nd_numba import FermionOperator2nd
+from netket.operator import FermionOperator2nd
 
 
 def compute_pyscf_integrals(mol, mo_coeff):

{netket-3.15.2 → netket-3.16}/netket/experimental/sampler/__init__.py

@@ -16,14 +16,13 @@ from . import rules
 
 from .metropolis_pmap import MetropolisSamplerPmap
 
-from .metropolis import MetropolisParticleExchange
-
 
 # Deprecated bindings from stabilisaation
 from netket.sampler import (
     ParallelTemperingSampler as _deprecated_MetropolisPtSampler,
     ParallelTemperingLocal as _deprecated_MetropolisLocalPtSampler,
     ParallelTemperingExchange as _deprecated_MetropolisExchangePtSampler,
+    MetropolisFermionHop as _deprecated_MetropolisParticleExchange,
 )
 
 _deprecations = {
@@ -43,8 +42,15 @@ _deprecations = {
         "netket.sampler.ParallelTemperingExchange (netket >= 3.12)",
         _deprecated_MetropolisExchangePtSampler,
     ),
+    # June 2024, NetKet 3.13
+    "MetropolisParticleExchange": (
+        "netket.experimental.sampler.MetropolisParticleExchange is deprecated: use "
+        "netket.sampler.MetropolisFermionHop (netket >= 3.13)",
+        _deprecated_MetropolisParticleExchange,
+    ),
 }
 
+
 from netket.utils.deprecation import deprecation_getattr as _deprecation_getattr
 from netket.utils import _hide_submodules
 

netket-3.16/netket/experimental/sampler/rules/__init__.py

@@ -0,0 +1,17 @@
+from netket.sampler.rules import (
+    FermionHopRule as _deprecated_FermionHopRule,
+)
+
+_deprecations = {
+    # June 2024, NetKet 3.13
+    "ParticleExchangeRule": (
+        "netket.experimental.sampler.rules.ParticleExchangeRule is deprecated: use "
+        "netket.sampler.rules.FermionHopRule (netket >= 3.13)",
+        _deprecated_FermionHopRule,
+    ),
+}
+
+from netket.utils.deprecation import deprecation_getattr as _deprecation_getattr
+
+__getattr__ = _deprecation_getattr(__name__, _deprecations)
+del _deprecation_getattr