import numpy as np
import numpy.typing as npt
from .encode.ternary_tree import TTFlatpack
# Rust-backed classes and functions exposed to Python
[docs]
class QubitHamiltonian:
"""Mapping from Pauli strings to complex coefficients."""
def __init__(self, data: dict[str, complex] | None = None) -> None: ...
@property
def n_qubits(self) -> int: ...
def __len__(self) -> int: ...
def __getitem__(self, key: str) -> complex: ...
def __setitem__(self, key: str, value: complex) -> None: ...
def __delitem__(self, key: str) -> None: ...
def __contains__(self, key: str) -> bool: ...
def __iter__(self): ...
[docs]
def keys(self) -> list[str]: ...
[docs]
def values(self) -> list[complex]: ...
[docs]
def items(self) -> list[tuple[str, complex]]: ...
[docs]
def get(self, key: str, default=None): ...
[docs]
def to_dict(self) -> dict[str, complex]: ...
[docs]
def pauli_weight(self) -> int: ...
[docs]
def coeff_pauli_weight(self) -> float: ...
[docs]
def clifford_heuristic(
self,
temperature: float | None = None,
coefficient_weighted: bool = False,
seed: int | None = None,
clifford_subset: str = "chs",
) -> "QubitHamiltonian": ...
[docs]
def randomised_subsystem_descent(
self,
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": ...
[docs]
class FermionHamiltonian:
"""Builder for fermionic Hamiltonians."""
def __init__(
self,
*,
terms: dict[str, npt.NDArray[np.float64]] | None = None,
constant_energy: float = 0.0,
) -> None: ...
@property
def n_modes(self) -> int: ...
constant_energy: float
@property
def terms(self) -> dict[str, npt.NDArray[np.float64]]: ...
@property
def signatures_and_coefficients(
self,
) -> tuple[list[str], list[npt.NDArray[np.float64]]]: ...
[docs]
def creation(self) -> "FermionHamiltonian": ...
[docs]
def annihilation(self) -> "FermionHamiltonian": ...
self, coefficients: npt.NDArray[np.float64]
) -> "FermionHamiltonian": ...
[docs]
def add_constant(self, constant_energy: float) -> "FermionHamiltonian": ...
[docs]
def to_sparse_majorana(self) -> dict[tuple[int, ...], complex]: ...
[docs]
def to_majorana_sparse(self) -> "MajoranaSparse": ...
[docs]
class MajoranaSparse:
"""A sparse Majorana-operator representation of a Hamiltonian."""
@property
def indices(self) -> list[list[int]]: ...
@property
def coefficients(self) -> npt.NDArray[np.complex128]: ...
@property
def constant(self) -> float: ...
[docs]
class MajoranaEncoding:
"""A fermion-to-qubit encoding defined by its Majorana operators."""
def __init__(
self,
ipowers: npt.NDArray[np.uint8],
symplectics: npt.NDArray[np.bool],
vacuum_state: npt.NDArray[np.bool] | None = None,
) -> None: ...
[docs]
@staticmethod
def jordan_wigner(
n_modes: int, n_qubits: int | None = None
) -> "MajoranaEncoding": ...
[docs]
@staticmethod
def bravyi_kitaev(
n_modes: int, n_qubits: int | None = None
) -> "MajoranaEncoding": ...
[docs]
@staticmethod
def parity(n_modes: int, n_qubits: int | None = None) -> "MajoranaEncoding": ...
[docs]
@staticmethod
def jkmn(n_modes: int, n_qubits: int | None = None) -> "MajoranaEncoding": ...
[docs]
@staticmethod
def maxnto(n_modes: int) -> "MajoranaEncoding": ...
[docs]
@staticmethod
def from_flatpack(
flatpack: TTFlatpack, n_qubits: int | None = None
) -> "MajoranaEncoding": ...
[docs]
@staticmethod
def from_json(data: dict) -> "MajoranaEncoding": ...
[docs]
def to_json(self) -> dict: ...
@property
def n_modes(self) -> int: ...
@property
def n_qubits(self) -> int: ...
@property
def ipowers(self) -> npt.NDArray[np.uint8]: ...
@property
def symplectic_matrix(self) -> npt.NDArray[np.bool]: ...
@property
def vacuum_state(self) -> npt.NDArray[np.bool]: ...
[docs]
def encode(self, fham: FermionHamiltonian) -> QubitHamiltonian: ...
self,
fham: FermionHamiltonian,
temperature: float | None = None,
initial_guess: list[int] | None = None,
coefficient_weighted: bool = True,
seed: int | None = None,
) -> QubitHamiltonian: ...
[docs]
def anneal_enumeration(
self,
fham: FermionHamiltonian,
temperature: float | None = None,
initial_guess: list[int] | None = None,
coefficient_weighted: bool = False,
seed: int | None = None,
) -> float: ...
[docs]
def decode(self, states: npt.NDArray[np.bool]) -> npt.NDArray[np.bool]: ...
[docs]
def hartree_fock_state(
self,
fermionic_hf_state: npt.NDArray[np.bool],
mode_op_map: npt.NDArray[np.uint] | None = None,
) -> npt.NDArray[np.bool]: ...
[docs]
def number_operator(self, mode: int, coeff: complex = 1.0) -> QubitHamiltonian: ...
self,
edge_indices: tuple[int, int],
coeff: complex = 1.0,
with_conjugate: bool = False,
) -> QubitHamiltonian: ...
[docs]
def interaction_operator(
self,
mode_indices: tuple[int, int, int, int],
coeff: complex = 1.0,
physicist_notation: bool = True,
with_conjugate: bool = False,
) -> QubitHamiltonian: ...
[docs]
def encode_fermion_product(
self,
signature: str,
mode_indices: list[int],
coeff: complex = 1.0,
with_conjugate: bool = False,
) -> QubitHamiltonian: ...
[docs]
def batch_pauli_weights(
self,
fham: FermionHamiltonian,
permutations: npt.NDArray[np.uint],
) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]: ...
[docs]
def apply_mode_enumeration(self, mode_op_map: list[int]) -> "MajoranaEncoding": ...
[docs]
def symplectic_product(
left: npt.NDArray[np.bool], right: npt.NDArray[np.bool]
) -> tuple[int, npt.NDArray[np.bool]]: ...
[docs]
def symplectic_to_pauli(
symplectic: npt.NDArray[np.bool], ipower: int = 0
) -> tuple[str, int]: ...
[docs]
def pauli_to_symplectic(
pauli: str, ipower: int
) -> tuple[npt.NDArray[np.bool], int]: ...
[docs]
def symplectic_to_sparse(
symplectic: npt.NDArray[np.bool],
ipower: int,
) -> tuple[str, npt.NDArray[np.uintp], complex]: ...
fham: FermionHamiltonian,
n_modes: int | None = None,
) -> tuple[TTFlatpack, int]: ...
flatpack: TTFlatpack,
n_qubits: int,
hamiltonian: MajoranaSparse,
parallelize: bool = True,
heuristic: str = "min_weight",
seed: int | None = None,
backend: str = "dense_transpose",
) -> MajoranaEncoding: ...
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]: ...