ffsim 0.0.80__tar.gz → 0.0.81__tar.gz

{ffsim-0.0.80 → ffsim-0.0.81}/.github/workflows/test-latest-versions.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+        python-version: ["3.11", "3.12", "3.13", "3.14"]
     steps:
       - uses: actions/checkout@v6
       - name: Set up Python
@@ -35,7 +35,7 @@ jobs:
     runs-on: ubuntu-24.04-arm
     strategy:
       matrix:
-        python-version: ["3.10", "3.14"]
+        python-version: ["3.11", "3.14"]
     steps:
       - uses: actions/checkout@v6
       - name: Set up Python
@@ -53,7 +53,7 @@ jobs:
     runs-on: macos-latest
     strategy:
       matrix:
-        python-version: ["3.10", "3.14"]
+        python-version: ["3.11", "3.14"]
     steps:
       - uses: actions/checkout@v6
       - name: Set up Python

{ffsim-0.0.80 → ffsim-0.0.81}/.github/workflows/test-minimum-versions.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.10"]
+        python-version: ["3.11"]
     steps:
       - uses: actions/checkout@v6
       - name: Set up Python

{ffsim-0.0.80 → ffsim-0.0.81}/CONTRIBUTING.md

@@ -47,7 +47,7 @@ tox run -e <environment name>
 
 substituting `<environment name>` with the name of the tox environment for the check. The following environments are available:
 
-- `test-3.10`, `test-3.11`, `test-3.12`, `test-3.13`, `test-3.14`: Run tests for a specific Python version
+- `test-3.11`, `test-3.12`, `test-3.13`, `test-3.14`: Run tests for a specific Python version
 - `coverage`: Code coverage
 - `type`: Type check
 - `lint`: Lint check

{ffsim-0.0.80 → ffsim-0.0.81}/Cargo.toml

@@ -16,6 +16,6 @@ numpy = "0.27"
 pyo3 = { version = "0.27", features = [
     "extension-module",
     "num-complex",
-    "abi3-py310",
+    "abi3-py311",
 ] }
 rayon = "1.11"

{ffsim-0.0.80 → ffsim-0.0.81}/PKG-INFO

@@ -1,10 +1,9 @@
 Metadata-Version: 2.4
 Name: ffsim
-Version: 0.0.80
+Version: 0.0.81
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -14,16 +13,16 @@ Classifier: Topic :: Scientific/Engineering :: Chemistry
 Classifier: Topic :: Scientific/Engineering :: Physics
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: jax
-Requires-Dist: numpy<=2.3
+Requires-Dist: numpy
 Requires-Dist: opt-einsum
 Requires-Dist: orjson
-Requires-Dist: pyscf>=2.9
+Requires-Dist: pyscf>=2.12
 Requires-Dist: qiskit>=2.0
 Requires-Dist: scipy
 Requires-Dist: typing-extensions
 License-File: LICENSE
 Summary: Faster simulation of fermionic quantum circuits.
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Documentation, https://qiskit-community.github.io/ffsim/
 Project-URL: Homepage, https://github.com/qiskit-community/ffsim

{ffsim-0.0.80 → ffsim-0.0.81}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "maturin"
 
 [project]
 name = "ffsim"
-requires-python = ">=3.10"
-version = "0.0.80"
+requires-python = ">=3.11"
+version = "0.0.81"
 description = "Faster simulation of fermionic quantum circuits."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -13,7 +13,6 @@ classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3 :: Only",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -25,12 +24,10 @@ classifiers = [
 ]
 dependencies = [
     "jax",
-    # restrict Numpy version due to https://github.com/pyscf/pyscf/issues/3079
-    # TODO remove this when it's fixed
-    "numpy <= 2.3",
+    "numpy",
     "opt_einsum",
     "orjson",
-    "pyscf >= 2.9",
+    "pyscf >= 2.12",
     "qiskit >= 2.0",
     "scipy",
     "typing-extensions",
@@ -66,7 +63,7 @@ python-source = "python"
 module-name = "ffsim._lib"
 
 [tool.cibuildwheel]
-build = "cp310-macosx* cp310-manylinux_x86_64 cp310-manylinux_aarch64"
+build = "cp311-macosx* cp311-manylinux_x86_64 cp311-manylinux_aarch64"
 test-requires = "pytest"
 test-command = "pytest {project}/tests"
 
@@ -112,7 +109,6 @@ ket = "ket"
 [tool.tox]
 requires = ["tox>=4.50"]
 env_list = [
-    "test-3.10",
     "test-3.11",
     "test-3.12",
     "test-3.13",
@@ -136,7 +132,7 @@ pass_env = [
 
 [tool.tox.env_base.test]
 description = "run tests"
-factors = [["3.10", "3.11", "3.12", "3.13", "3.14"]]
+factors = [["3.11", "3.12", "3.13", "3.14"]]
 deps = ["pytest"]
 commands = [["pytest"]]
 

{ffsim-0.0.80 → ffsim-0.0.81}/python/ffsim/_lib.pyi

@@ -7,7 +7,7 @@ class FermionOperator(MutableMapping[tuple[tuple[bool, bool, int], ...], complex
         self, coeffs: dict[tuple[tuple[bool, bool, int], ...], complex]
     ) -> None: ...
     def adjoint(self) -> "FermionOperator": ...
-    def normal_ordered(self) -> "FermionOperator": ...
+    def normal_ordered(self, group_by_spin: bool = ...) -> "FermionOperator": ...
     def conserves_particle_number(self) -> bool: ...
     def conserves_spin_z(self) -> bool: ...
     def many_body_order(self) -> int: ...

{ffsim-0.0.80 → ffsim-0.0.81}/python/ffsim/_slow/fermion_operator.py

@@ -135,10 +135,10 @@ class FermionOperator(MutableMapping):
             return result
         return NotImplemented
 
-    def normal_ordered(self) -> "FermionOperator":
+    def normal_ordered(self, group_by_spin: bool = False) -> "FermionOperator":
         result = FermionOperator({})
         for term, coeff in self.coeffs.items():
-            result += _normal_ordered_term(term, coeff)
+            result += _normal_ordered_term(term, coeff, group_by_spin)
         return result
 
     def conserves_particle_number(self) -> bool:
@@ -220,8 +220,23 @@ class FermionOperator(MutableMapping):
         )
 
 
+def _order_key(op: FermionAction, group_by_spin: bool) -> tuple[bool, bool, int]:
+    """The sort key used to normal order a term.
+
+    Terms are reordered into descending order of this key. By default the key is
+    ``(action, spin, orb)`` (creations before annihilations). When ``group_by_spin``
+    is True the key is ``(spin, action, orb)`` (spin beta before spin alpha). In
+    both cases, a creation operator precedes the annihilation operator on the same
+    spin-orbital.
+    """
+    action, spin, orb = op
+    if group_by_spin:
+        return (spin, action, orb)
+    return (action, spin, orb)
+
+
 def _normal_ordered_term(
-    term: Iterable[FermionAction], coeff: complex
+    term: Iterable[FermionAction], coeff: complex, group_by_spin: bool = False
 ) -> FermionOperator:
     coeffs: dict[tuple[FermionAction, ...], complex] = {}
     stack = [(list(term), coeff)]
@@ -232,22 +247,20 @@ def _normal_ordered_term(
         for i in range(1, len(term)):
             # shift operator at index i to the left until it's in the correct location
             for j in range(i, 0, -1):
-                action_right, spin_right, index_right = term[j]
-                action_left, spin_left, index_left = term[j - 1]
-                if action_right == action_left:
-                    # both create or both destroy
-                    if (spin_right, index_right) == (spin_left, index_left):
-                        # operators are the same, so product is zero
-                        zero = True
-                        break
-                    elif (spin_right, index_right) > (spin_left, index_left):
-                        # swap operators and update sign
-                        term[j - 1], term[j] = term[j], term[j - 1]
-                        parity = not parity
-                elif action_right and not action_left:
-                    # create on right and destroy on left
+                right = term[j]
+                left = term[j - 1]
+                if right == left:
+                    # operators are the same, so product is zero
+                    zero = True
+                    break
+                if _order_key(right, group_by_spin) > _order_key(left, group_by_spin):
+                    _, spin_right, index_right = right
+                    _, spin_left, index_left = left
+                    # the operator on the right belongs to the left, so swap them
                     if (spin_right, index_right) == (spin_left, index_left):
-                        # add new term
+                        # conjugate pair on the same spin-orbital: the creation operator
+                        # is moving to the left past its annihilation operator, which
+                        # produces an additional term from the anticommutation relation
                         new_term = term[: j - 1] + term[j + 1 :]
                         sign = -1 if parity else 1
                         stack.append((new_term, sign * coeff))