classiq 0.93.0__py3-none-any.whl → 0.94.1__py3-none-any.whl

classiq/evaluators/qmod_expression_visitors/qmod_expression_bwc.py

@@ -1,129 +0,0 @@
-import ast
-from typing import Any, cast
-
-import sympy
-
-MAX_PIECEWISE_LOOPS = 1000
-
-
-# FIXME: Remove with deprecation (CLS-3214)
-class QmodExpressionBwc(ast.NodeTransformer):
-    def visit_Call(self, node: ast.Call) -> Any:
-        node = cast(ast.Call, self.generic_visit(node))
-        if not isinstance(node.func, ast.Name):
-            return node
-        func = node.func.id
-        args = node.args
-        kwargs = node.keywords
-        num_args = len(args)
-        num_kwargs = len(kwargs)
-
-        if func == "BitwiseNot":
-            if num_args != 1 or num_kwargs != 0:
-                return node
-            return ast.UnaryOp(op=ast.Invert(), operand=args[0])
-        if func == "LShift":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.BinOp(left=args[0], op=ast.LShift(), right=args[1])
-        if func == "RShift":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.BinOp(left=args[0], op=ast.RShift(), right=args[1])
-        if func == "BitwiseOr":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.BinOp(left=args[0], op=ast.BitOr(), right=args[1])
-        if func == "BitwiseXor":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.BinOp(left=args[0], op=ast.BitXor(), right=args[1])
-        if func == "BitwiseAnd":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.BinOp(left=args[0], op=ast.BitAnd(), right=args[1])
-
-        if func == "LogicalXor":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.BinOp(left=args[0], op=ast.BitXor(), right=args[1])
-
-        if func == "Eq":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Compare(left=args[0], ops=[ast.Eq()], comparators=[args[1]])
-        if func == "Ne":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Compare(left=args[0], ops=[ast.NotEq()], comparators=[args[1]])
-        if func == "Lt":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Compare(left=args[0], ops=[ast.Lt()], comparators=[args[1]])
-        if func == "Le":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Compare(left=args[0], ops=[ast.LtE()], comparators=[args[1]])
-        if func == "Gt":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Compare(left=args[0], ops=[ast.Gt()], comparators=[args[1]])
-        if func == "Ge":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Compare(left=args[0], ops=[ast.GtE()], comparators=[args[1]])
-
-        if func == "do_subscript":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            return ast.Subscript(value=args[0], slice=args[1])
-
-        if func == "get_field":
-            if num_args != 2 or num_kwargs != 0:
-                return node
-            attr = args[1]
-            if not isinstance(attr, ast.Constant):
-                return node
-            return ast.Attribute(value=args[0], attr=attr.value)
-
-        if func == "Piecewise":
-            if num_args == 0:
-                return node
-            first_piece = args[0]
-            if not isinstance(first_piece, ast.Tuple) or len(first_piece.elts) != 2:
-                return node
-            first_cond = first_piece.elts[1]
-            if isinstance(first_cond, ast.BinOp):
-                first_cond = first_cond.right
-            if not isinstance(first_cond, ast.Compare) or len(first_cond.ops) != 1:
-                return node
-            index_var_node = first_cond.left
-            if not isinstance(index_var_node, ast.Name):
-                return node
-            index_var = index_var_node.id
-            last_cond = args[-1]
-            if not isinstance(last_cond, ast.Tuple) or len(last_cond.elts) != 2:
-                return node
-            last_value = last_cond.elts[0]
-            if not isinstance(last_value, ast.Constant) and (
-                not isinstance(last_value, ast.UnaryOp)
-                or not isinstance(last_value.operand, ast.Constant)
-            ):
-                return node
-            dummy_var_name = f"{index_var}_not_it"
-            last_cond.elts[0] = ast.Name(id=dummy_var_name)
-            items: list = []
-            idx = 0
-            for idx in range(MAX_PIECEWISE_LOOPS):
-                item = sympy.sympify(ast.unparse(node), locals={index_var: idx})
-                if str(item) == dummy_var_name:
-                    items.append(last_value)
-                    break
-                items.append(ast.parse(str(item), mode="eval").body)
-            if idx == MAX_PIECEWISE_LOOPS:
-                return node
-            return ast.Subscript(
-                value=ast.List(elts=items), slice=ast.Name(id=index_var)
-            )
-
-        return node

classiq/interface/chemistry/elements.py

@@ -1,120 +0,0 @@
-ELEMENTS = [
-    "H",
-    "He",
-    "Li",
-    "Be",
-    "B",
-    "C",
-    "N",
-    "O",
-    "F",
-    "Ne",
-    "Na",
-    "Mg",
-    "Al",
-    "Si",
-    "P",
-    "S",
-    "Cl",
-    "Ar",
-    "K",
-    "Ca",
-    "Sc",
-    "Ti",
-    "V",
-    "Cr",
-    "Mn",
-    "Fe",
-    "Co",
-    "Ni",
-    "Cu",
-    "Zn",
-    "Ga",
-    "Ge",
-    "As",
-    "Se",
-    "Br",
-    "Kr",
-    "Rb",
-    "Sr",
-    "Y",
-    "Zr",
-    "Nb",
-    "Mo",
-    "Tc",
-    "Ru",
-    "Rh",
-    "Pd",
-    "Ag",
-    "Cd",
-    "In",
-    "Sn",
-    "Sb",
-    "Te",
-    "I",
-    "Xe",
-    "Cs",
-    "Ba",
-    "La",
-    "Ce",
-    "Pr",
-    "Nd",
-    "Pm",
-    "Sm",
-    "Eu",
-    "Gd",
-    "Tb",
-    "Dy",
-    "Ho",
-    "Er",
-    "Tm",
-    "Yb",
-    "Lu",
-    "Hf",
-    "Ta",
-    "W",
-    "Re",
-    "Os",
-    "Ir",
-    "Pt",
-    "Au",
-    "Hg",
-    "Tl",
-    "Pb",
-    "Bi",
-    "Po",
-    "At",
-    "Rn",
-    "Fr",
-    "Ra",
-    "Ac",
-    "Th",
-    "Pa",
-    "U",
-    "Np",
-    "Pu",
-    "Am",
-    "Cm",
-    "Bk",
-    "Cf",
-    "Es",
-    "Fm",
-    "Md",
-    "No",
-    "Lr",
-    "Rf",
-    "Db",
-    "Sg",
-    "Bh",
-    "Hs",
-    "Mt",
-    "Ds",
-    "Rg",
-    "Cn",
-    "Nh",
-    "Fl",
-    "Mc",
-    "Lv",
-    "Ts",
-    "Og",
-]

classiq/interface/chemistry/fermionic_operator.py

@@ -1,208 +0,0 @@
-from __future__ import annotations
-
-import itertools
-from typing import Union
-
-import numpy as np
-import pydantic
-from pydantic import ConfigDict
-
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
-
-LadderOperator = tuple[str, int]
-FermionicOperatorTuple = tuple["FermionicOperator", float]
-
-_SUBSCRIPT_UNICODE_CHARS = {
-    "0": "\u2080",
-    "1": "\u2081",
-    "2": "\u2082",
-    "3": "\u2083",
-    "4": "\u2084",
-    "5": "\u2085",
-    "6": "\u2086",
-    "7": "\u2087",
-    "8": "\u2088",
-    "9": "\u2089",
-}
-_SUPERSCRIPT_PLUS = "\u207a"
-
-
-class FermionicOperator(HashablePydanticBaseModel):
-    """
-    Specification of a Fermionic operator.
-    Input:
-    List of ladder operators, each ladder operator is described by a tuple of its
-    index and a character indicating if it's a creation ('+') or annihilation operator ('-').
-    """
-
-    op_list: list = pydantic.Field(
-        description=(
-            "A list of tuples each containing an index and a character; for "
-            "example [('+', 0), ('-', 1)]."
-        ),
-    )
-
-    @staticmethod
-    def _validate_single_op(op: tuple) -> LadderOperator:
-        if not isinstance(op, tuple):
-            try:  # type: ignore[unreachable] # it is reachable...
-                op = tuple(op)
-            except Exception as exc:
-                raise ClassiqValueError("Ladder operator should be a tuple.") from exc
-        if len(op) != 2:
-            raise ClassiqValueError(
-                "Ladder operator tuple should be of length two; for example ('+', 1)."
-            )
-
-        op_symbol = op[0]
-        if op_symbol == "LadderOperator.PLUS":
-            op_symbol = "+"
-        elif op_symbol == "LadderOperator.MINUS":
-            op_symbol = "-"
-        if op_symbol not in ("+", "-"):
-            raise ClassiqValueError(
-                f"The first term in a ladder operator tuple indicates if its a raising "
-                f"(LadderOperator.PLUS / '+') or lowering (LadderOperator.MINUS / '-') "
-                f"operator. Received {op_symbol}"
-            )
-        op_index = op[1]
-        if not isinstance(op_index, int):
-            raise ClassiqValueError(
-                "The second term in a ladder operator tuple indicates its index and should be of type int"
-            )
-
-        return (op_symbol, op_index)
-
-    @pydantic.field_validator("op_list")
-    @classmethod
-    def _validate_op_list(cls, op_list: list) -> list:
-        return list(map(cls._validate_single_op, op_list))
-
-    def __mul__(self, coeff: Union[float, int]) -> SummedFermionicOperator:
-        if isinstance(coeff, (float, int)):
-            return SummedFermionicOperator(op_list=[(self, float(coeff))])
-        raise ClassiqValueError(
-            "The coefficient multiplying Fermionic Operator should be of type float"
-        )
-
-    __rmul__ = __mul__
-
-    def __add__(
-        self, other: Union[SummedFermionicOperator, FermionicOperator]
-    ) -> SummedFermionicOperator:
-        if isinstance(other, SummedFermionicOperator):
-            return SummedFermionicOperator(op_list=[(self, 1.0)] + other.op_list)
-        elif isinstance(other, FermionicOperator):
-            return SummedFermionicOperator(op_list=[(self, 1.0)] + [(other, 1.0)])
-        raise ClassiqValueError(
-            "FermionicOperator can be summed together only with type FermionicOperator or SummedFermionicOperator"
-        )
-
-    model_config = ConfigDict(frozen=True)
-
-    @staticmethod
-    def _to_ladder_op(char: str) -> str:
-        return "a" + _SUPERSCRIPT_PLUS if char == "+" else "a"
-
-    @staticmethod
-    def _to_subscript(num: int) -> str:
-        return "".join(_SUBSCRIPT_UNICODE_CHARS[digit] for digit in str(num))
-
-    def __str__(self) -> str:
-        return "".join(
-            f"{self._to_ladder_op(char)}{self._to_subscript(index)}"
-            for (char, index) in self.op_list
-        )
-
-    @property
-    def all_indices(self) -> set[int]:
-        return {op[1] for op in self.op_list}
-
-
-class SummedFermionicOperator(HashablePydanticBaseModel):
-    """
-    Specification of a summed Fermionic operator.
-    Input:
-    List of fermionic operators tuples, The first term in the tuple is the FermionicOperator and the second term is its coefficient.
-    For example:
-    op1 = FermionicOperator(op_list=[('+', 0), ('-', 1)])
-    op2 = FermionicOperator(op_list=[('-', 0), ('-', 1)])
-    summed_operator = SummedFermionicOperator(op_list=[(op1, 0.2), (op2, 6.7)])
-    """
-
-    op_list: list = pydantic.Field(
-        description="A list of tuples each containing a FermionicOperator and a coefficient.",
-    )
-    model_config = ConfigDict(frozen=True)
-
-    @staticmethod
-    def _validate_single_op(op: tuple) -> FermionicOperatorTuple:
-        # is it tuple - if not, convert to tuple
-        if not isinstance(op, tuple):
-            try:  # type: ignore[unreachable] # it is reachable...
-                op = tuple(op)
-            except Exception as exc:
-                raise ClassiqValueError("Operator should be a tuple.") from exc
-        if len(op) != 2:
-            raise ClassiqValueError("Operator tuple should be of length two.")
-
-        # is it FermionicOperator - if not, convert to FermionicOperator
-        if not isinstance(op[0], FermionicOperator):
-            try:
-                op = (FermionicOperator(**op[0]), op[1])
-            except Exception as exc:
-                raise ClassiqValueError(
-                    "The first term in the operator tuple should be an instance of the FermionicOperator class"
-                ) from exc
-
-        if not isinstance(op[1], float):
-            raise ClassiqValueError(
-                "The second term in the operator tuple indicates its coefficient and should be of type float"
-            )
-
-        return op  # type: ignore[return-value] # mypy thinks that it is `Tuple[Any, ...]`, though the asserts here tell otherwise..
-
-    @pydantic.field_validator("op_list")
-    @classmethod
-    def _validate_op_list(cls, op_list: list) -> list:
-        return list(map(cls._validate_single_op, op_list))
-
-    def __add__(
-        self, other: Union[SummedFermionicOperator, FermionicOperator]
-    ) -> SummedFermionicOperator:
-        if isinstance(other, SummedFermionicOperator):
-            return SummedFermionicOperator(op_list=self.op_list + other.op_list)
-        elif isinstance(other, FermionicOperator):
-            return SummedFermionicOperator(op_list=self.op_list + [(other, 1.0)])
-        raise ClassiqValueError(
-            "FermionicOperator can be summed together only with type FermionicOperator or SummedFermionicOperator"
-        )
-
-    def is_close(self, other: SummedFermionicOperator) -> bool:
-        if not isinstance(other, SummedFermionicOperator):
-            return False  # type: ignore[unreachable]
-
-        if len(self.op_list) != len(other.op_list):
-            return False
-
-        for (op1, coeff1), (op2, coeff2) in zip(self.op_list, other.op_list):
-            if op1 != op2 or not np.isclose(coeff1, coeff2):
-                return False
-
-        return True
-
-    @property
-    def _all_indices(self) -> set[int]:
-        return set(
-            itertools.chain.from_iterable(op.all_indices for op, _ in self.op_list)
-        )
-
-    @property
-    def num_qubits(self) -> int:
-        return len(self._all_indices)
-
-    def __str__(self) -> str:
-        return " + \n".join(str(op[1]) + " * " + str(op[0]) for op in self.op_list)

classiq/interface/chemistry/ground_state_problem.py

@@ -1,132 +0,0 @@
-import warnings
-from typing import Annotated, Any, Literal, Optional, Union, cast
-
-import pydantic
-from pydantic import ConfigDict, Field
-from pydantic_core.core_schema import ValidationInfo
-
-from classiq.interface.chemistry.fermionic_operator import SummedFermionicOperator
-from classiq.interface.chemistry.molecule import Molecule
-from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
-
-"""
-The correct type hint is:
-NumSpinUpParticles = pydantic.NonNegativeInt
-NumSpinDownParticles = pydantic.NonNegativeInt
-NumParticles = Tuple[NumSpinUpParticles, NumSpinDownParticles]
-
-But:
-A) the NonNegativeInt makes the ts-schemas have a `Minimum` object,
-    which is undefined, thus causing an error
-B) a tuple of a specific size gives another, different error
-
-Thus, we use `int` and manually check its value
-And use a list, and manually check its length
-"""
-NumSpinUpParticles = pydantic.NonNegativeInt
-NumSpinDownParticles = pydantic.NonNegativeInt
-NumParticles = tuple[NumSpinUpParticles, NumSpinDownParticles]
-
-
-class FermionMapping(StrEnum):
-    JORDAN_WIGNER = "jordan_wigner"
-    PARITY = "parity"
-    BRAVYI_KITAEV = "bravyi_kitaev"
-    FAST_BRAVYI_KITAEV = "fast_bravyi_kitaev"
-
-
-class GroundStateProblem(HashablePydanticBaseModel):
-    kind: str
-
-    mapping: FermionMapping = pydantic.Field(
-        default=FermionMapping.JORDAN_WIGNER,
-        description="Fermionic mapping type",
-        title="Fermion Mapping",
-    )
-    z2_symmetries: bool = pydantic.Field(
-        default=False,
-        description="whether to perform z2 symmetries reduction",
-    )
-    num_qubits: Optional[int] = pydantic.Field(default=None)
-
-    def __init__(self, /, **data: Any) -> None:
-        warnings.warn(
-            (
-                f"The class `{self.__class__.__name__}` is deprecated and will no "
-                "longer be supported starting on 2025-09-18 at the earliest. "
-                "For more information on Classiq's chemistry application, see "
-                "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
-            ),
-            category=ClassiqDeprecationWarning,
-            stacklevel=2,
-        )
-        super().__init__(**data)
-
-    @pydantic.field_validator("z2_symmetries")
-    @classmethod
-    def _validate_z2_symmetries(cls, z2_symmetries: bool, info: ValidationInfo) -> bool:
-        if (
-            z2_symmetries
-            and info.data.get("mapping") == FermionMapping.FAST_BRAVYI_KITAEV
-        ):
-            raise ClassiqValueError(
-                "z2 symmetries reduction can not be used for fast_bravyi_kitaev mapping"
-            )
-        return z2_symmetries
-
-    model_config = ConfigDict(frozen=True)
-
-
-class MoleculeProblem(GroundStateProblem):
-    kind: Literal["molecule"] = pydantic.Field(default="molecule")
-
-    molecule: Molecule
-    basis: str = pydantic.Field(default="sto3g", description="Molecular basis set")
-    freeze_core: bool = pydantic.Field(default=False)
-    remove_orbitals: list[int] = pydantic.Field(
-        default_factory=list, description="list of orbitals to remove"
-    )
-
-
-class HamiltonianProblem(GroundStateProblem):
-    kind: Literal["hamiltonian"] = pydantic.Field(default="hamiltonian")
-
-    hamiltonian: SummedFermionicOperator = pydantic.Field(
-        description="Hamiltonian as a fermionic operator"
-    )
-    num_particles: list[pydantic.PositiveInt] = pydantic.Field(
-        description="Tuple containing the numbers of alpha particles and beta particles"
-    )
-
-    @pydantic.field_validator("num_particles", mode="before")
-    @classmethod
-    def _validate_num_particles(
-        cls,
-        num_particles: Union[
-            list[Union[int, float]], tuple[Union[int, float], Union[int, float]]
-        ],
-    ) -> list[int]:
-        assert isinstance(num_particles, (list, tuple))
-        assert len(num_particles) == 2
-
-        num_particles = [int(x) for x in num_particles]
-
-        assert num_particles[0] >= 1
-        assert num_particles[1] >= 1
-
-        return cast(list[int], num_particles)
-
-
-CHEMISTRY_PROBLEMS = (MoleculeProblem, HamiltonianProblem)
-CHEMISTRY_PROBLEMS_TYPE = Annotated[
-    Union[MoleculeProblem, HamiltonianProblem],
-    Field(
-        discriminator="kind",
-        description="Ground state problem object describing the system.",
-    ),
-]
-CHEMISTRY_ANSATZ_NAMES = ["hw_efficient", "ucc", "hva"]

classiq/interface/chemistry/ground_state_result.py

@@ -1,8 +0,0 @@
-from pydantic import BaseModel
-
-
-class MoleculeResult(BaseModel):
-    energy: float
-    nuclear_repulsion_energy: float
-    total_energy: float
-    hartree_fock_energy: float

classiq/interface/chemistry/molecule.py

@@ -1,71 +0,0 @@
-from typing import Literal, Union
-
-import pydantic
-from pydantic import ConfigDict
-
-from classiq.interface.chemistry.elements import ELEMENTS
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.helpers.custom_pydantic_types import AtomType
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
-
-
-class Atom(HashablePydanticBaseModel):
-    symbol: Literal[tuple(ELEMENTS)] = pydantic.Field(description="The atom symbol")  # type: ignore[valid-type]
-    x: float = pydantic.Field(description="The x coordinate of the atom")
-    y: float = pydantic.Field(description="The y coordinate of the atom")
-    z: float = pydantic.Field(description="The z coordinate of the atom")
-
-
-class Molecule(HashablePydanticBaseModel):
-    atoms: list[Atom] = pydantic.Field(
-        description="A list of atoms each containing the atoms symbol and  its (x,y,z) location",
-        min_length=1,
-    )
-    spin: pydantic.NonNegativeInt = pydantic.Field(
-        default=1, description="spin of the molecule"
-    )
-    charge: pydantic.NonNegativeInt = pydantic.Field(
-        default=0, description="charge of the molecule"
-    )
-
-    @property
-    def atoms_type(self) -> list[AtomType]:
-        return [(atom.symbol, [atom.x, atom.y, atom.z]) for atom in self.atoms]
-
-    @classmethod
-    def _validate_atom(cls, atom: Union[AtomType, Atom]) -> Atom:
-        if isinstance(atom, (list, tuple)):
-            return cls._validate_old_atoms_type(atom)
-        return atom
-
-    @pydantic.field_validator("atoms", mode="before")
-    @classmethod
-    def _validate_atoms(cls, atoms: list[Union[AtomType, Atom]]) -> list[Atom]:
-        return [cls._validate_atom(atom) for atom in atoms]
-
-    @staticmethod
-    def _validate_old_atoms_type(atom: AtomType) -> Atom:
-        if len(atom) != 2:
-            raise ClassiqValueError(
-                "each atom should be a list of two entries: 1) name pf the elemnt (str) 2) list of its (x,y,z) location"
-            )
-        if not isinstance(atom[0], str):
-            raise ClassiqValueError(
-                f"atom name should be a string. unknown element: {atom[0]}."
-            )
-        if len(atom[1]) != 3:
-            raise ClassiqValueError(
-                f"location of the atom is of length three, representing the (x,y,z) coordinates of the atom, error value: {atom[1]}"
-            )
-        for idx in atom[1]:
-            if not isinstance(idx, (float, int)):
-                raise ClassiqValueError(
-                    f"coordinates of the atom should be of type float. error value: {idx}"
-                )
-        symbol, coordinate = atom
-
-        return Atom(symbol=symbol, x=coordinate[0], y=coordinate[1], z=coordinate[2])
-
-    model_config = ConfigDict(frozen=True)