fockit 0.0.2__py3-none-any.whl

fockit/converters.py

@@ -0,0 +1,52 @@
+"""Converters from OpSum to external operator formats."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from fockit._types import as_complex
+from fockit.algebra import FermionRules, Ladder
+from fockit.operators import OpSum
+
+if TYPE_CHECKING:
+    from triqs.operators import Operator as TriqsOperator
+
+
+def to_triqs(op: OpSum) -> TriqsOperator:
+    """Convert a fermionic OpSum to a TRIQS Operator.
+
+    Parameters
+    ----------
+    op : OpSum
+        Operator expression with ``FermionRules``.
+
+    Returns
+    -------
+    triqs.operators.Operator
+
+    """
+    for mono in op.terms:
+        for single_op in mono.ops:
+            if not isinstance(single_op.rules, FermionRules):
+                name = type(single_op.rules).__name__
+                msg = f"to_triqs requires FermionRules, got {name}"
+                raise TypeError(msg)
+
+    from triqs.operators import Operator, c, c_dag
+
+    result = Operator()
+    for mono, coeff in op.terms.items():
+        c_val = as_complex(coeff)
+        term = c_val.real if c_val.imag == 0 else c_val
+        for ladder_op in mono.ops:
+            indices = (
+                ladder_op.mode
+                if isinstance(ladder_op.mode, tuple)
+                else (ladder_op.mode,)
+            )
+            if ladder_op.kind is Ladder.CREATE:
+                term = term * c_dag(*indices)
+            else:
+                term = term * c(*indices)
+        result = result + term
+    return result

fockit/display.py

@@ -0,0 +1,150 @@
+"""Display and formatting for operator expressions."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Hashable
+
+from fockit._types import Coefficient
+from fockit.algebra import (
+    BosonRules,
+    FermionRules,
+    Ladder,
+    Pauli,
+    PauliRules,
+    mode_sort_key,
+)
+from fockit.operators import Monomial, Op, OpSum, format_mode
+
+# operators of other algebras show their kind as the symbol
+_TEXT_SYMBOLS: dict[tuple[type, Hashable], str] = {
+    (FermionRules, Ladder.CREATE): "c†",
+    (FermionRules, Ladder.ANNIHILATE): "c",
+    (BosonRules, Ladder.CREATE): "b†",
+    (BosonRules, Ladder.ANNIHILATE): "b",
+    (PauliRules, Pauli.X): "σ_x",
+    (PauliRules, Pauli.Y): "σ_y",
+    (PauliRules, Pauli.Z): "σ_z",
+}
+_LATEX_SYMBOLS: dict[tuple[type, Hashable], str] = {
+    (FermionRules, Ladder.CREATE): r"c^{\dagger}",
+    (FermionRules, Ladder.ANNIHILATE): "c",
+    (BosonRules, Ladder.CREATE): r"b^{\dagger}",
+    (BosonRules, Ladder.ANNIHILATE): "b",
+    (PauliRules, Pauli.X): r"\sigma^{x}",
+    (PauliRules, Pauli.Y): r"\sigma^{y}",
+    (PauliRules, Pauli.Z): r"\sigma^{z}",
+}
+_LATEX_LABELS = {"up": r"\uparrow", "dn": r"\downarrow"}
+
+
+def to_text(op: OpSum) -> str:
+    """Format an OpSum as a human-readable string.
+
+    Parameters
+    ----------
+    op : OpSum
+
+    Returns
+    -------
+    str
+
+    """
+    return _join_terms(op, _op_text)
+
+
+def to_latex(op: OpSum) -> str:
+    r"""Convert an operator expression to LaTeX.
+
+    Parameters
+    ----------
+    op : OpSum
+
+    Returns
+    -------
+    str
+
+    """
+    return _join_terms(op, _op_latex)
+
+
+def _join_terms(op: OpSum, format_op: Callable[[Op], str]) -> str:
+    """Write the terms in display order, joined with + and -."""
+    if not op.terms:
+        return "0"
+
+    sorted_terms = sorted(
+        op.terms.items(), key=lambda item: _monomial_sort_key(item[0])
+    )
+
+    parts: list[str] = []
+    for mono, raw_coeff in sorted_terms:
+        coeff = _real_if_possible(raw_coeff)
+        if not mono.ops:
+            parts.append(str(coeff))
+            continue
+
+        ops_str = " ".join(format_op(single_op) for single_op in mono.ops)
+
+        coeff_str = _format_coeff(coeff)
+        if coeff_str == "":
+            parts.append(ops_str)
+        elif coeff_str == "-":
+            parts.append(f"-{ops_str}")
+        else:
+            parts.append(f"{coeff_str} {ops_str}")
+
+    result = parts[0]
+    for part in parts[1:]:
+        if part.startswith("-"):
+            result += f" - {part[1:]}"
+        else:
+            result += f" + {part}"
+    return result
+
+
+def _op_text(op: Op) -> str:
+    """Format as e.g. ``c†(0, up)``."""
+    symbol = _TEXT_SYMBOLS.get((type(op.rules), op.kind), op.kind)
+    return f"{symbol}({format_mode(op.mode)})"
+
+
+def _op_latex(op: Op) -> str:
+    r"""Format as e.g. ``c^{\dagger}_{0, \uparrow}``."""
+    symbol = _LATEX_SYMBOLS.get((type(op.rules), op.kind), op.kind)
+    labels = op.mode if isinstance(op.mode, tuple) else (op.mode,)
+    subscript = ", ".join(_LATEX_LABELS.get(label, str(label)) for label in labels)
+    return f"{symbol}_{{{subscript}}}"
+
+
+def _monomial_sort_key(mono: Monomial) -> tuple[object, ...]:
+    """Sort key for deterministic term ordering in display."""
+    keys = []
+    for op in mono.ops:
+        keys.append((_kind_sort_key(op.kind), mode_sort_key(op.mode)))
+    return (len(mono.ops), tuple(keys))
+
+
+def _kind_sort_key(kind: Hashable) -> tuple[object, ...]:
+    """Sort key for operator kind within display ordering."""
+    if isinstance(kind, str):
+        return (2, kind)
+    return (3, repr(kind))
+
+
+def _real_if_possible(coeff: Coefficient) -> Coefficient:
+    """Show a complex number without its zero part, e.g. ``0.5`` or ``-0.5j``."""
+    if isinstance(coeff, complex):
+        if coeff.imag == 0:
+            return coeff.real
+        if coeff.real == 0:
+            return complex(0.0, coeff.imag)
+    return coeff
+
+
+def _format_coeff(coeff: Coefficient) -> str:
+    """Format a coefficient for display."""
+    if coeff == 1:
+        return ""
+    if coeff == -1:
+        return "-"
+    return str(coeff)

fockit/inspection.py

@@ -0,0 +1,60 @@
+"""Inspection utilities for operator expressions."""
+
+from __future__ import annotations
+
+from collections.abc import Hashable
+
+from fockit.operators import OpSum
+
+
+def modes(op: OpSum) -> set[Hashable]:
+    """Return the set of all mode labels appearing in the operator.
+
+    Parameters
+    ----------
+    op : OpSum
+
+    Returns
+    -------
+    set[Hashable]
+
+    """
+    result: set[Hashable] = set()
+    for mono in op.terms:
+        for ladder_op in mono.ops:
+            result.add(ladder_op.mode)
+    return result
+
+
+def degree(op: OpSum) -> int:
+    """Maximum monomial length (number of ladder operators).
+
+    Returns 0 for the zero operator.
+
+    Parameters
+    ----------
+    op : OpSum
+
+    Returns
+    -------
+    int
+
+    """
+    if not op.terms:
+        return 0
+    return max(len(mono) for mono in op.terms)
+
+
+def num_terms(op: OpSum) -> int:
+    """Return the number of nonzero terms.
+
+    Parameters
+    ----------
+    op : OpSum
+
+    Returns
+    -------
+    int
+
+    """
+    return len(op.terms)

fockit/normal_order.py

@@ -0,0 +1,142 @@
+"""Normal ordering algorithm.
+
+Every algebra goes through the same path, using only its ``swap`` and
+``is_normal_ordered_pair`` rules. Pauli strings could be multiplied faster site
+by site, or stored as bitmasks, but that would treat one algebra differently
+from the rest.
+"""
+
+from __future__ import annotations
+
+import functools
+
+from fockit._types import Coefficient, as_coefficient
+from fockit.algebra import SwapResult
+from fockit.operators import Monomial, Op, OpSum
+
+
+def normal_order(op: OpSum) -> OpSum:
+    """Normal-order an operator expression.
+
+    Operators of different algebras commute and are grouped by algebra.
+
+    Parameters
+    ----------
+    op : OpSum
+        The operator to normal-order.
+
+    Returns
+    -------
+    OpSum
+        The normal-ordered operator.
+
+    """
+    terms: dict[Monomial, Coefficient] = {}
+    for mono, coeff in op.terms.items():
+        for ordered, c in _order(mono.ops, Monomial(())).items():
+            _accumulate(terms, ordered, as_coefficient(coeff * c))
+    return OpSum(terms)
+
+
+def is_normal_ordered(op: OpSum) -> bool:
+    """Check if an operator expression is in normal order.
+
+    Parameters
+    ----------
+    op : OpSum
+
+    Returns
+    -------
+    bool
+
+    """
+    for mono in op.terms:
+        ops = mono.ops
+        for i in range(len(ops) - 1):
+            if not _is_ordered(ops[i], ops[i + 1]):
+                return False
+    return True
+
+
+def _is_ordered(left: Op, right: Op) -> bool:
+    if type(left.rules) is type(right.rules):
+        return left.rules.is_normal_ordered_pair(left, right)
+    return type(left.rules).__name__ < type(right.rules).__name__
+
+
+def _swap(left: Op, right: Op) -> SwapResult:
+    if type(left.rules) is type(right.rules):
+        return left.rules.swap(left, right)
+    return SwapResult(terms=((1, (right, left)),))
+
+
+def _order(prefix: tuple[Op, ...], tail: Monomial) -> dict[Monomial, Coefficient]:
+    """Normal-order ``prefix * tail``, where ``tail`` is already normal ordered."""
+    terms: dict[Monomial, Coefficient] = {tail: 1}
+    for op in reversed(prefix):
+        new: dict[Monomial, Coefficient] = {}
+        for t, c1 in terms.items():
+            for m, c2 in _insert(op, t):
+                _accumulate(new, m, as_coefficient(c1 * c2))
+        terms = new
+    return terms
+
+
+@functools.lru_cache(maxsize=2**16)
+def _insert(op: Op, tail: Monomial) -> tuple[tuple[Monomial, Coefficient], ...]:
+    """Normal-order ``op * tail``, where ``tail`` is already normal ordered.
+
+    ``op`` moves right past plain exchanges, picking up only their sign. The
+    first swap that does anything else is expanded, and the operators ``op``
+    passed are put back in front.
+    """
+    ops = tail.ops
+    sign: Coefficient = 1
+    i = 0
+    while i < len(ops) and not _is_ordered(op, ops[i]):
+        terms = _swap(op, ops[i]).terms
+        if len(terms) != 1 or terms[0][1] != (ops[i], op):
+            break
+        sign = as_coefficient(sign * terms[0][0])
+        i += 1
+
+    passed = ops[:i]
+    rest: dict[Monomial, Coefficient] = {}
+    if i == len(ops) or _is_ordered(op, ops[i]):
+        if not passed or _is_ordered(passed[-1], op):
+            return ((Monomial((*passed, op, *ops[i:])), sign),)
+        rest[Monomial((op, *ops[i:]))] = sign
+    else:
+        for coeff, repl in terms:
+            scale = as_coefficient(sign * coeff)
+            for m, c in _order(repl, Monomial(ops[i + 1 :])).items():
+                _accumulate(rest, m, as_coefficient(scale * c))
+
+    acc: dict[Monomial, Coefficient] = {}
+    for m, c in rest.items():
+        if not passed:
+            _accumulate(acc, m, c)
+        elif not m.ops or _is_ordered(passed[-1], m.ops[0]):
+            _accumulate(acc, Monomial(passed + m.ops), c)
+        else:
+            for ordered, c2 in _order(passed, m).items():
+                _accumulate(acc, ordered, as_coefficient(c * c2))
+    return tuple(acc.items())
+
+
+def _accumulate(
+    acc: dict[Monomial, Coefficient], mono: Monomial, coeff: Coefficient
+) -> None:
+    """Add coeff * mono into the accumulator dict.
+
+    Parameters
+    ----------
+    acc : dict[Monomial, Coefficient]
+    mono : Monomial
+    coeff : Coefficient
+
+    """
+    if mono in acc:
+        acc[mono] = as_coefficient(acc[mono] + coeff)
+    else:
+        acc[mono] = coeff