Methods to commute terms in Fermi objects

doc/releases/changelog-dev.md

@@ -13,6 +13,10 @@
   `from pennylane.capture.primitives import *`.
   [(#6129)](https://github.com/PennyLaneAI/pennylane/pull/6129)
 
+* `FermiWord` and `FermiSentence` classes now have methods to apply
+   anti-commutator relations.
+   [(#6196)](https://github.com/PennyLaneAI/pennylane/pull/6196)
+
 * The `SampleMP.process_samples` method is updated to support using JAX tracers
   for samples, allowing compatiblity with Catalyst workflows.
   [(#6211)](https://github.com/PennyLaneAI/pennylane/pull/6211)

pennylane/fermi/fermionic.py

@@ -303,6 +303,117 @@ def to_mat(self, n_orbitals=None):
 
         return mat
 
+    def commute(self, source, target):
+        r"""Apply anti-commuting relations until the operator in position source is in position target.
+
+        Args:
+            source (int): The position of the operator to be commuted.
+            target (int): The desired position of the operator occupying the source position.
+
+        Returns:
+            FermiSentence: The ``FermiSentence`` obtained after applying the anti-commutator relations.
+
+        Raises:
+            TypeError: if the source or target is not an integer
+            ValueError: if the source or target are outside the range [0, len(self) - 1]
+
+
+        **Example**
+
+        >>> w = FermiWord({(0, 0): '+', (1, 1): '-'})
+        >>> w.commute(0, 1)
+        -1 * a(1) a⁺(0)
+        """
+
+        if not isinstance(source, int) or not isinstance(target, int):
+            raise TypeError("Positions must be integers")
+
+        if source < 0 or target < 0:
+            raise ValueError("Positions must be positive integers")
+
+        if source > len(self.sorted_dic) - 1 or target > len(self.sorted_dic) - 1:
+            raise ValueError("Positions out of range")
+
+        if source == target:
+            return FermiSentence({self: 1})
+
+        fw = self
+        fs = FermiSentence({self: 1})
+        delta = 1 if source < target else -1
+
+        while source != target:
+            fs, fw = _commute_adjacent(fs, fw, source, source + delta)
+            source += delta
+
+        return fs
+
+
+def _commute_adjacent(fs, fw, source, target):
+    """Commutes two adjacent operators within a ``FermiSentence``.
+
+    Args:
+        fs (``FermiSentence``): The ``FermiSentence`` to be modified
+        fw (``FermiWord``): The ``FermiWord`` within ``fs`` that contains the operators
+            to be commuted.
+        source (int): The position of the operator to be commuted.
+        target (int): The desired position of the operator occupying the source position.
+
+    Returns:
+        FermiSentence: The ``FermiSentence`` obtained after applying the anti-commutator relations.
+        FermiWord: The ``FermiWord`` that was modified by the commutation.
+
+    Raises:
+        ValueError: if the source and target positions are not consecutive
+    """
+    if source != target + 1 and target != source + 1:
+        raise ValueError("Positions must be consecutive integers")
+
+    indices = list(fw.sorted_dic.keys())
+    source_idx = indices[source]
+    target_idx = indices[target]
+
+    source_val = fw[source_idx]
+    target_val = fw[target_idx]
+
+    # commuting identical terms
+    if source_idx[1] == target_idx[1] and source_val == target_val:
+        return fs, fw
+
+    new_source_idx = (source, target_idx[1])
+    new_target_idx = (target, source_idx[1])
+
+    coeff = fs.pop(fw)
+    fw = dict(fw)
+    fw[new_source_idx] = target_val
+    fw[new_target_idx] = source_val
+
+    if source_idx[1] != target_idx[1]:
+        del fw[source_idx]
+        del fw[target_idx]
+
+    fw = FermiWord(fw)
+
+    if source_val == target_val or source_idx[1] != target_idx[1]:
+        return fs + (-1 * FermiSentence({fw: coeff})), fw
+
+    _min = min(source, target)
+    _max = max(source, target)
+
+    items = list(fw.sorted_dic.items())
+    left = {(i, key[1]): value for i, (key, value) in enumerate(items[:_min])}
+    middle = {(i, key[1]): value for i, (key, value) in enumerate(items[_min : _max + 1])}
+    right = {(i, key[1]): value for i, (key, value) in enumerate(items[_max + 1 :])}
+
+    lfw = FermiWord(left)
+    mfw = FermiWord(middle)
+    rfw = FermiWord(right)
+
+    terms = lfw * (1 - FermiSentence({mfw: 1})) * rfw
+
+    fs = fs + coeff * terms
+
+    return fs, fw
+
 
 # pylint: disable=useless-super-delegation
 class FermiSentence(dict):
@@ -523,6 +634,37 @@ def to_mat(self, n_orbitals=None):
 
         return mat
 
+    def commute(self, fw, source, target):
+        r"""Apply anti-commuting relations until the operator in position source is in position target.
+
+        Args:
+            fw (FermiWord): The FermiWord within the FermiSentence that contains the operator to be commuted.
+            source (int): The position of the operator to be commuted.
+            target (int): The desired position of the operator occupying the source position.
+
+        Returns:
+            FermiSentence: The FermiSentence obtained after applying the anti-commutator relations.
+
+        Raises:
+            ValueError: if the provided ``FermiWord`` is not in the ``FermiSentence`` dictionary
+
+        **Example**
+
+        >>> w = FermiWord({(0, 0): '+', (1, 1): '-'})
+        >>> s = FermiSentence({w: 1})
+        >>> s.commute(w, 0, 1)
+        -1 * a(1) a⁺(0)
+        """
+
+        if fw not in self.keys():
+            raise ValueError(f"The FermiWord {fw} does not appear in the FermiSentence")
+
+        fs = dict(self)
+        coeff = fs[fw]
+        del fs[fw]
+
+        return FermiSentence(fs) + coeff * fw.commute(source, target)
+
 
 def from_string(fermi_string):
     r"""Return a fermionic operator object from its string representation.

tests/fermi/test_fermionic.py

@@ -13,14 +13,21 @@
 # limitations under the License.
 """Unit Tests for the Fermionic representation classes."""
 import pickle
+import re
 from copy import copy, deepcopy
 
 import numpy as np
 import pytest
 
 import pennylane as qml
 from pennylane import numpy as pnp
-from pennylane.fermi.fermionic import FermiSentence, FermiWord, _to_string, from_string
+from pennylane.fermi.fermionic import (
+    FermiSentence,
+    FermiWord,
+    _commute_adjacent,
+    _to_string,
+    from_string,
+)
 
 # pylint: disable=too-many-public-methods
 
@@ -32,6 +39,62 @@
 fw6 = FermiWord({(0, 10): "+", (1, 30): "+", (2, 0): "-", (3, 400): "-"})
 fw7 = FermiWord({(0, 10): "-", (1, 30): "+", (2, 0): "-", (3, 400): "+"})
 
+fw8 = FermiWord({(0, 0): "-", (1, 1): "+"})
+fw8c = FermiWord({(0, 1): "+", (1, 0): "-"})
+fw8cs = FermiSentence({fw8c: -1})
+
+fw9 = FermiWord({(0, 0): "-", (1, 1): "-"})
+fw9c = FermiWord({(0, 1): "-", (1, 0): "-"})
+fw9cs = FermiSentence({fw9c: -1})
+
+fw10 = FermiWord({(0, 0): "+", (1, 1): "+"})
+fw10c = FermiWord({(0, 1): "+", (1, 0): "+"})
+fw10cs = FermiSentence({fw10c: -1})
+
+fw11 = FermiWord({(0, 0): "-", (1, 0): "+"})
+fw11c = FermiWord({(0, 0): "+", (1, 0): "-"})
+fw11cs = 1 + FermiSentence({fw11c: -1})
+
+fw12 = FermiWord({(0, 0): "+", (1, 0): "+"})
+fw12c = FermiWord({(0, 0): "+", (1, 0): "+"})
+fw12cs = FermiSentence({fw12c: 1})
+
+fw13 = FermiWord({(0, 0): "-", (1, 0): "-"})
+fw13c = FermiWord({(0, 0): "-", (1, 0): "-"})
+fw13cs = FermiSentence({fw13c: 1})
+
+fw14 = FermiWord({(0, 0): "+", (1, 0): "-"})
+fw14c = FermiWord({(0, 0): "-", (1, 0): "+"})
+fw14cs = 1 + FermiSentence({fw14c: -1})
+
+fw15 = FermiWord({(0, 0): "-", (1, 1): "+", (2, 2): "+"})
+fw15c = FermiWord({(0, 1): "+", (1, 0): "-", (2, 2): "+"})
+fw15cs = FermiSentence({fw15c: -1})
+
+fw16 = FermiWord({(0, 0): "-", (1, 1): "+", (2, 2): "-"})
+fw16c = FermiWord({(0, 0): "-", (1, 2): "-", (2, 1): "+"})
+fw16cs = FermiSentence({fw16c: -1})
+
+fw17 = FermiWord({(0, 0): "-", (1, 0): "+", (2, 2): "-"})
+fw17c1 = FermiWord({(0, 2): "-"})
+fw17c2 = FermiWord({(0, 0): "+", (1, 0): "-", (2, 2): "-"})
+fw17cs = fw17c1 - fw17c2
+
+fw18 = FermiWord({(0, 0): "+", (1, 1): "+", (2, 2): "-", (3, 3): "-"})
+fw18c = FermiWord({(0, 0): "+", (1, 3): "-", (2, 1): "+", (3, 2): "-"})
+fw18cs = FermiSentence({fw18c: 1})
+
+fw19 = FermiWord({(0, 0): "+", (1, 1): "+", (2, 2): "-", (3, 2): "+"})
+fw19c1 = FermiWord({(0, 0): "+", (1, 1): "+"})
+fw19c2 = FermiWord({(0, 2): "+", (1, 0): "+", (2, 1): "+", (3, 2): "-"})
+fw19cs = FermiSentence({fw19c1: 1, fw19c2: -1})
+
+fw20 = FermiWord({(0, 0): "-", (1, 0): "+", (2, 1): "-", (3, 0): "-", (4, 0): "+"})
+fw20c1 = FermiWord({(0, 0): "-", (1, 0): "+", (2, 1): "-"})
+fw20c2 = FermiWord({(0, 0): "+", (1, 1): "-", (2, 0): "-"})
+fw20c3 = FermiWord({(0, 0): "+", (1, 0): "-", (2, 0): "+", (3, 1): "-", (4, 0): "-"})
+fw20cs = fw20c1 + fw20c2 - fw20c3
+
 
 class TestFermiWord:
     def test_missing(self):
@@ -141,6 +204,42 @@ def test_to_mat_error(self):
         with pytest.raises(ValueError, match="n_orbitals cannot be smaller than 2"):
             fw1.to_mat(n_orbitals=1)
 
+    tup_fw_commute = (
+        (fw8, 0, 1, fw8cs),
+        (fw9, 0, 1, fw9cs),
+        (fw10, 0, 1, fw10cs),
+        (fw11, 0, 1, fw11cs),
+        (fw12, 0, 1, fw12cs),
+        (fw13, 0, 1, fw13cs),
+        (fw14, 0, 1, fw14cs),
+        (fw15, 0, 1, fw15cs),
+        (fw16, 1, 2, fw16cs),
+        (fw17, 0, 1, fw17cs),
+        (fw8, 0, 0, FermiSentence({fw8: 1})),
+        (fw8, 1, 0, fw8cs),
+        (fw11, 1, 0, fw11cs),
+        (fw18, 3, 1, fw18cs),
+        (fw19, 3, 0, fw19cs),
+        (fw20, 4, 0, fw20cs),
+    )
+
+    @pytest.mark.parametrize("fw, i, j, fs", tup_fw_commute)
+    def test_commute(self, fw, i, j, fs):
+        assert fw.commute(i, j) == fs
+
+    def test_commute_errors(self):
+        with pytest.raises(TypeError, match="Positions must be integers"):
+            fw8.commute(0.5, 1)
+
+        with pytest.raises(ValueError, match="Positions must be positive integers"):
+            fw8.commute(-1, 0)
+
+        with pytest.raises(ValueError, match="Positions must be consecutive integers"):
+            _commute_adjacent(FermiSentence({fw17: 1}), fw17, 0, 2)
+
+        with pytest.raises(ValueError, match="Positions out of range"):
+            fw8.commute(1, 2)
+
 
 class TestFermiWordArithmetic:
     WORDS_MUL = (
@@ -528,6 +627,15 @@ def test_array_must_not_exceed_length_1(self, method_name):
     }
 )
 
+fs8 = fw8 + fw9
+fs8c = fw8 + fw9cs
+
+fs9 = 1.3 * fw8 + (1.4 + 3.8j) * fw9
+fs9c = 1.3 * fw8 + (1.4 + 3.8j) * fw9cs
+
+fs10 = -1.3 * fw11 + 2.3 * fw9
+fs10c = -1.3 * fw11cs + 2.3 * fw9
+
 
 class TestFermiSentence:
     def test_missing(self):
@@ -643,6 +751,24 @@ def test_to_mat_error(self):
         with pytest.raises(ValueError, match="n_orbitals cannot be smaller than 3"):
             fs7.to_mat(n_orbitals=2)
 
+    tup_fs_commute = (
+        (fs8, fw9, 0, 1, fs8c),
+        (fs9, fw9, 0, 1, fs9c),
+        (fs10, fw11, 0, 1, fs10c),
+    )
+
+    # pylint: disable=too-many-arguments
+    @pytest.mark.parametrize("fs, fw, i, j, fsc", tup_fs_commute)
+    def test_commute(self, fs, fw, i, j, fsc):
+        assert fs.commute(fw, i, j) == fsc
+
+    def test_commute_errors(self):
+        with pytest.raises(
+            ValueError,
+            match=re.escape(f"The FermiWord {fw11} does not appear in the FermiSentence"),
+        ):
+            fs8.commute(fw11, 0, 1)
+
 
 class TestFermiSentenceArithmetic:
     tup_fs_mult = (  # computed by hand