NetKet 3.11.2__tar.gz → 3.11.3__tar.gz

{netket-3.11.2 → netket-3.11.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: NetKet
-Version: 3.11.2
+Version: 3.11.3
 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/#
@@ -26,7 +26,7 @@ Requires-Dist: jaxlib<0.5,>=0.4.3
 Requires-Dist: numba4jax<0.1,>=0.0.10.post1
 Requires-Dist: numba<0.60,>=0.52
 Requires-Dist: numpy~=1.20
-Requires-Dist: optax<0.2,>=0.1.3
+Requires-Dist: optax<0.3,>=0.1.3
 Requires-Dist: orjson<4,>=3.4
 Requires-Dist: rich>=10.0
 Requires-Dist: scipy<2,>=1.5.3
@@ -44,6 +44,7 @@ Requires-Dist: pytest-cov>=2.10.1; extra == 'dev'
 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.1.0; extra == 'dev'
 Requires-Dist: wheel; extra == 'dev'
 Provides-Extra: docs

{netket-3.11.2 → netket-3.11.3}/netket/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '3.11.2'
-__version_tuple__ = version_tuple = (3, 11, 2)
+__version__ = version = '3.11.3'
+__version_tuple__ = version_tuple = (3, 11, 3)

{netket-3.11.2 → netket-3.11.3}/netket/experimental/observable/renyi2/exact.py

@@ -16,6 +16,7 @@ import numpy as np
 
 from netket.vqs import FullSumState, expect
 from netket.stats import Stats
+from netket.utils import module_version
 
 from .S2_operator import Renyi2EntanglementEntropy
 
@@ -37,6 +38,11 @@ def Renyi2(vstate: FullSumState, op: Renyi2EntanglementEntropy):
 
         rdm = state_qutip.ptrace(np.arange(N)[mask])
 
+        # TODO: when we drop support for qutip older versions, always keep this
+        # qutip 5 was released in march 2024
+        if module_version("qutip") >= (5, 0, 0):
+            rdm = rdm.data.to_array()
+
         n = 2
         out = np.log2(np.trace(np.linalg.matrix_power(rdm, n))) / (1 - n)
         out = np.absolute(out.real)

{netket-3.11.2 → netket-3.11.3}/netket/experimental/operator/_fermion_operator_2nd_base.py

@@ -19,9 +19,9 @@ import numpy as np
 from numbers import Number
 
 from netket.utils.types import DType
-from netket.operator._discrete_operator import DiscreteOperator
+from netket.operator import DiscreteOperator, Transpose
 from netket.operator._pauli_strings.base import _count_of_locations
-from netket.hilbert.abstract_hilbert import AbstractHilbert
+from netket.hilbert import AbstractHilbert
 from netket.utils.numbers import is_scalar, dtype as _dtype
 from netket.utils.optional_deps import import_optional_dependency
 
@@ -31,7 +31,7 @@ from ._fermion_operator_2nd_utils import (
     _convert_terms_to_spin_blocks,
     _canonicalize_input,
     _check_hermitian,
-    _herm_conj,
+    transpose_term,
     _remove_dict_zeros,
     _verify_input,
     OperatorDict,
@@ -267,10 +267,18 @@ class FermionOperator2ndBase(DiscreteOperator):
     def operators(self) -> OperatorDict:
         """Returns a dictionary with (term, weight) key-value pairs, with terms in tuple notation.
 
-        The constant diagonal shift of the operator is associated with a term represented as an empty tuple.
+        The constant diagonal shift of the operator is associated with a term represented as an
+        empty tuple.
         """
         return self._operators
 
+    @property
+    def cutoff(self) -> float:
+        """Threshold for the weights, if the absolute value of a weight is below the
+        cutoff, it's discarded.
+        """
+        return self._cutoff
+
     def copy(self, *, dtype: Optional[DType] = None, cutoff=None):
         """
         Creates a deep copy of this operator, potentially changing the dtype of the
@@ -458,23 +466,35 @@ class FermionOperator2ndBase(DiscreteOperator):
         op = self.copy(dtype=dtype)
         return op.__imul__(scalar)
 
+    def transpose(self, *, concrete=False):
+        r"""Returns the transpose of this operator.
+
+        For real operators, this is equivalent to complex conjugation.
+        This implementation always returns the concrete version of the operator.
+        """
+        if concrete:
+            new = type(self)(self.hilbert, dtype=self.dtype, cutoff=self._cutoff)
+            # operators (c,c†) are real already. Only conjugate coefficients if needed.
+            new._operators = {transpose_term(k): v for k, v in self._operators.items()}
+            return new
+        else:
+            return Transpose(self)
+
     def conjugate(self, *, concrete=False):
-        r"""Returns the complex conjugate of this operator."""
+        r"""Returns the complex conjugate of this operator.
 
-        terms = list(self._operators.keys())
-        weights = list(self._operators.values())
-        terms, weights = _herm_conj(terms, weights)  # changes also the terms
+        This implementation always returns the concrete version of the operator.
+        """
+        del concrete
 
-        cls = type(self)
-        new = cls(
-            self.hilbert,
-            dtype=self.dtype,
-        )
-        new._operators, _ = _canonicalize_input(
-            terms, weights, self.dtype, self._cutoff
-        )
-        new._cutoff = self._cutoff
-        return new
+        # if operator is real dtype, then just return a copy
+        if not np.issubdtype(self.dtype, np.complex_):
+            return self.copy()
+        else:
+            new = type(self)(self.hilbert, dtype=self.dtype, cutoff=self._cutoff)
+            # operators (c,c†) are real already. Only conjugate coefficients if needed.
+            new._operators = {k: np.conjugate(v) for k, v in self._operators.items()}
+            return new
 
     def to_normal_order(self):
         """Reoder the operators to normal order.

{netket-3.11.2 → netket-3.11.3}/netket/experimental/operator/_fermion_operator_2nd_utils.py

@@ -224,13 +224,29 @@ def _herm_conj(
     terms: OperatorTermsList, weights: OperatorWeightsList = 1
 ) -> tuple[OperatorTermsList, OperatorWeightsList]:
     """Returns the hermitian conjugate of the terms and weights."""
+    conj_term = transpose_terms(terms)
+    conj_weight = [np.conjugate(weight) for weight in weights]
+    return conj_term, conj_weight
+
+
+def transpose_terms(terms: OperatorTermsList) -> OperatorTermsList:
+    """Returns the transpose of the terms (creation/destruction operators).
+    The transpose is equivalent to the hermitian transpose because they are
+    real.
+    """
     conj_term = []
-    conj_weight = []
-    # loop over all terms and weights and get the hermitian conjugate
-    for term, weight in zip(terms, weights):
+    for term in terms:
         conj_term.append([(op, 1 - int(dag)) for (op, dag) in reversed(term)])
-        conj_weight.append(np.conjugate(weight))
-    return conj_term, conj_weight
+    return conj_term
+
+
+def transpose_term(term: OperatorTerm) -> OperatorTerm:
+    """Returns the transpose of a single term (creation/destruction operators).
+    The transpose is equivalent to the hermitian transpose because they are
+    real.
+    """
+    # equivalent to transpose_terms
+    return tuple((op, 1 - int(dag)) for (op, dag) in reversed(term))
 
 
 def _convert_terms_to_spin_blocks(

{netket-3.11.2 → netket-3.11.3}/netket/operator/_discrete_operator_jax.py

@@ -15,10 +15,13 @@
 import abc
 
 import numpy as np
+from scipy import sparse
+
 import jax.numpy as jnp
 from jax.experimental.sparse import JAXSparse, BCOO
 
 from netket.operator import AbstractOperator, DiscreteOperator
+from netket.utils.optional_deps import import_optional_dependency
 
 
 class DiscreteJaxOperator(DiscreteOperator):
@@ -220,6 +223,28 @@ class DiscreteJaxOperator(DiscreteOperator):
         """
         return self.to_sparse().todense()
 
+    def to_qobj(self):  # -> "qutip.Qobj"
+        r"""Convert the operator to a qutip's Qobj.
+
+        Returns:
+            A :class:`qutip.Qobj` object.
+        """
+        qutip = import_optional_dependency("qutip", descr="to_qobj")
+
+        # QuTiP does not like jax sparse matrices, so we convert to scipy sparse
+        # by hand
+        sparse_mat_jax = self.to_sparse()
+        sparse_mat_scipy = sparse.coo_matrix(
+            (
+                sparse_mat_jax.data,
+                (sparse_mat_jax.indices[:, 0], sparse_mat_jax.indices[:, 1]),
+            ),
+            shape=sparse_mat_jax.shape,
+        )
+        return qutip.Qobj(
+            sparse_mat_scipy, dims=[list(self.hilbert.shape), list(self.hilbert.shape)]
+        )
+
     def __matmul__(self, other):
         if (
             isinstance(other, np.ndarray)

{netket-3.11.2 → netket-3.11.3}/netket/utils/struct/pytree.py

@@ -372,17 +372,22 @@ class Pytree(metaclass=PytreeMeta):
         type as the original object.
         """
         if dataclasses.is_dataclass(self):
-            return dataclasses.replace(self, **kwargs)
+            pytree = dataclasses.replace(self, **kwargs)
+        else:
+            unknown_keys = set(kwargs) - set(vars(self))
+            if unknown_keys:
+                raise ValueError(
+                    f"Trying to replace unknown fields {unknown_keys} "
+                    f"for '{type(self).__name__}'"
+                )
 
-        unknown_keys = set(kwargs) - set(vars(self))
-        if unknown_keys:
-            raise ValueError(
-                f"Trying to replace unknown fields {unknown_keys} "
-                f"for '{type(self).__name__}'"
-            )
+            pytree = copy(self)
+            pytree.__dict__.update(kwargs)
+
+        # Reset cached properties
+        for fname in pytree._pytree__cachedprop_fields:
+            setattr(pytree, fname, Uninitialized)
 
-        pytree = copy(self)
-        pytree.__dict__.update(kwargs)
         return pytree
 
     if not tp.TYPE_CHECKING:

{netket-3.11.2 → netket-3.11.3}/pyproject.toml

@@ -40,7 +40,7 @@ dependencies = [
     "jaxlib>=0.4.3, <0.5",
     "flax>=0.7.1, <0.9",
     "orjson>=3.4, <4",
-    "optax>=0.1.3, <0.2",
+    "optax>=0.1.3, <0.3",
     "numba4jax>=0.0.10.post1, <0.1",
     # vendored plum dependencies.
     # TODO: Remove once we unvendor plum 
@@ -78,6 +78,7 @@ dev = [
     "pre-commit>=2.7",
     "black==23.9.1",
     "ruff==0.1.0",
+    "qutip>=5",
     "wheel",
     "build",
     # TODO remove vendoring plum