Core (Rust extension)

The ferrmion.core module contains the Rust-accelerated functions that power the encoding and optimisation pipelines. All functions are compiled via PyO3 and available directly on the ferrmion namespace through re-exports in ferrmion/__init__.py.

class ferrmion.core.FermionHamiltonian(*, terms: dict[str, ndarray[tuple[int, ...], dtype[float64]]] | None = None, constant_energy: float = 0.0)

Bases: object

Builder for fermionic Hamiltonians.

add_constant(constant_energy: float) → FermionHamiltonian

annihilation() → FermionHamiltonian

constant_energy: float

creation() → FermionHamiltonian

property n_modes: int

property signatures_and_coefficients: tuple[list[str], list[ndarray[tuple[int, ...], dtype[float64]]]]

property terms: dict[str, ndarray[tuple[int, ...], dtype[float64]]]

to_majorana_sparse() → MajoranaSparse

to_sparse_majorana() → dict[tuple[int, ...], complex]

with_coefficients(coefficients: ndarray[tuple[int, ...], dtype[float64]]) → FermionHamiltonian

class ferrmion.core.MajoranaEncoding(ipowers: ndarray[tuple[int, ...], dtype[uint8]], symplectics: ndarray[tuple[int, ...], dtype[bool]], vacuum_state: ndarray[tuple[int, ...], dtype[bool]] | None = None)

Bases: object

A fermion-to-qubit encoding defined by its Majorana operators.

anneal_enumeration(fham: FermionHamiltonian, temperature: float | None = None, initial_guess: list[int] | None = None, coefficient_weighted: bool = False, seed: int | None = None) → float

apply_mode_enumeration(mode_op_map: list[int]) → MajoranaEncoding

batch_pauli_weights(fham: FermionHamiltonian, permutations: ndarray[tuple[int, ...], dtype[uint64]]) → tuple[ndarray[tuple[int, ...], dtype[float64]], ndarray[tuple[int, ...], dtype[float64]]]

static bravyi_kitaev(n_modes: int, n_qubits: int | None = None) → MajoranaEncoding

decode(states: ndarray[tuple[int, ...], dtype[bool]]) → ndarray[tuple[int, ...], dtype[bool]]

edge_operator(edge_indices: tuple[int, int], coeff: complex = 1.0, with_conjugate: bool = False) → QubitHamiltonian

encode(fham: FermionHamiltonian) → QubitHamiltonian

encode_annealed(fham: FermionHamiltonian, temperature: float | None = None, initial_guess: list[int] | None = None, coefficient_weighted: bool = True, seed: int | None = None) → QubitHamiltonian

encode_fermion_product(signature: str, mode_indices: list[int], coeff: complex = 1.0, with_conjugate: bool = False) → QubitHamiltonian

static from_flatpack(flatpack: TTFlatpack, n_qubits: int | None = None) → MajoranaEncoding

static from_json(data: dict) → MajoranaEncoding

hartree_fock_state(fermionic_hf_state: ndarray[tuple[int, ...], dtype[bool]], mode_op_map: ndarray[tuple[int, ...], dtype[uint64]] | None = None) → ndarray[tuple[int, ...], dtype[bool]]

interaction_operator(mode_indices: tuple[int, int, int, int], coeff: complex = 1.0, physicist_notation: bool = True, with_conjugate: bool = False) → QubitHamiltonian

property ipowers: ndarray[tuple[int, ...], dtype[uint8]]

static jkmn(n_modes: int, n_qubits: int | None = None) → MajoranaEncoding

static jordan_wigner(n_modes: int, n_qubits: int | None = None) → MajoranaEncoding

static maxnto(n_modes: int) → MajoranaEncoding

property n_modes: int

property n_qubits: int

number_operator(mode: int, coeff: complex = 1.0) → QubitHamiltonian

static parity(n_modes: int, n_qubits: int | None = None) → MajoranaEncoding

property symplectic_matrix: ndarray[tuple[int, ...], dtype[bool]]

to_json() → dict

property vacuum_state: ndarray[tuple[int, ...], dtype[bool]]

class ferrmion.core.MajoranaSparse

Bases: object

A sparse Majorana-operator representation of a Hamiltonian.

property coefficients: ndarray[tuple[int, ...], dtype[complex128]]

property constant: float

property indices: list[list[int]]

class ferrmion.core.QubitHamiltonian(data: dict[str, complex] | None = None)

Bases: object

Mapping from Pauli strings to complex coefficients.

clifford_heuristic(temperature: float | None = None, coefficient_weighted: bool = False, seed: int | None = None, clifford_subset: str = 'chs') → QubitHamiltonian

coeff_pauli_weight() → float

get(key: str, default=None)

items() → list[tuple[str, complex]]

keys() → list[str]

property n_qubits: int

pauli_weight() → int

randomised_subsystem_descent(iterations: int, subsystem_dimension: int, temperature: float | None = None, coefficient_weighted: bool = False, sampler: str = 'hamming', seed: int | None = None, clifford_subset: str = 'chs') → QubitHamiltonian

to_dict() → dict[str, complex]

values() → list[complex]

ferrmion.core.encode_topphatt(flatpack: TTFlatpack, n_qubits: int, fham: FermionHamiltonian, parallelize: bool = True, heuristic: str = 'min_weight', seed: int | None = None, backend: str = 'dense_transpose') → tuple[QubitHamiltonian, MajoranaEncoding]

ferrmion.core.hatt(fham: FermionHamiltonian, n_modes: int | None = None) → tuple[TTFlatpack, int]

ferrmion.core.pauli_to_symplectic(pauli: str, ipower: int) → tuple[ndarray[tuple[int, ...], dtype[bool]], int]

ferrmion.core.symplectic_product(left: ndarray[tuple[int, ...], dtype[bool]], right: ndarray[tuple[int, ...], dtype[bool]]) → tuple[int, ndarray[tuple[int, ...], dtype[bool]]]

ferrmion.core.symplectic_to_pauli(symplectic: ndarray[tuple[int, ...], dtype[bool]], ipower: int = 0) → tuple[str, int]

ferrmion.core.symplectic_to_sparse(symplectic: ndarray[tuple[int, ...], dtype[bool]], ipower: int) → tuple[str, ndarray[tuple[int, ...], dtype[uint64]], complex]

ferrmion.core.topphatt(flatpack: TTFlatpack, n_qubits: int, hamiltonian: MajoranaSparse, parallelize: bool = True, heuristic: str = 'min_weight', seed: int | None = None, backend: str = 'dense_transpose') → MajoranaEncoding