classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/applications/benchmarking/mirror_benchmarking.py

@@ -1,70 +0,0 @@
-from copy import deepcopy
-
-from classiq.interface.generator.model.preferences.preferences import (
-    Preferences,
-    QuantumFormat,
-    TranspilationOption,
-)
-from classiq.interface.generator.quantum_program import QuantumProgram
-
-from classiq._internals import async_utils
-from classiq.model.model import Model
-from classiq.quantum_functions.decorators import quantum_function
-from classiq.quantum_functions.function_library import QASM_INTRO, FunctionLibrary
-from classiq.quantum_register import QReg, ZeroQReg
-from classiq.synthesis import synthesize_async
-
-_MB_NAME: str = "mirror_benchmarking"
-_MB_FUNCTION_LIBRARY_NAME: str = f"{_MB_NAME}_function_library"
-
-
-class MirrorBenchmarking:
-    def __init__(self, model: Model) -> None:
-        self.functional_model: Model = model
-        self.functional_model._model.preferences = self.get_functional_preferences(
-            model.preferences
-        )
-
-    async def mirror_benchmarking_model_async(self) -> Model:
-        functional_circuit: QuantumProgram = QuantumProgram.parse_raw(
-            await synthesize_async(self.functional_model.get_model())
-        )
-
-        num_qubits: int = functional_circuit.data.width
-        circuit_qasm_list = functional_circuit.qasm.split(QASM_INTRO)  # type: ignore[union-attr]
-        if not circuit_qasm_list:
-            raise AssertionError(
-                "Functional model synthesis did not result in a legal QASM"
-            )
-        circuit_qasm: str = circuit_qasm_list[-1]
-
-        @quantum_function
-        def functional_model_function(reg: ZeroQReg[num_qubits]) -> QReg[num_qubits]:  # type: ignore[type-arg, valid-type]
-            return QASM_INTRO + circuit_qasm  # type: ignore[return-value]
-
-        model_function_library = FunctionLibrary(functional_model_function)
-
-        mb_model = Model(
-            preferences=self.get_mirror_benchmarking_preferences(
-                self.functional_model.preferences
-            )
-        )
-        mb_model.include_library(model_function_library)
-        inner_wires = mb_model.functional_model_function()
-        mb_model.functional_model_function(in_wires=inner_wires, is_inverse=True)
-        return mb_model
-
-    def mirror_benchmarking_model(self) -> Model:
-        return async_utils.run(self.mirror_benchmarking_model_async())
-
-    @staticmethod
-    def get_functional_preferences(preferences: Preferences) -> Preferences:
-        functional_preferences = deepcopy(preferences)
-        functional_preferences.output_format = [QuantumFormat.QASM]
-        return functional_preferences
-
-    @staticmethod
-    def get_mirror_benchmarking_preferences(preferences: Preferences) -> Preferences:
-        mb_preferences = deepcopy(preferences)
-        mb_preferences.transpilation_option = TranspilationOption.DECOMPOSE
-        return mb_preferences

classiq/applications/numpy_utils.py

@@ -1,37 +0,0 @@
-from typing import Any, TypeVar, cast
-
-import numpy as np
-
-
-# numpy utils
-def _is_empty_ndarray(obj: np.ndarray) -> bool:
-    return 0 in obj.shape
-
-
-def bool_datum(
-    obj: Any,
-) -> Any:  # returning `Any` since any object in python is convertable to `bool`
-    if isinstance(obj, np.ndarray):
-        # check that it's non-empty
-        return not _is_empty_ndarray(obj)
-    else:
-        return obj
-
-
-def bool_data(*objects: Any) -> bool:
-    return all(map(bool_datum, objects))
-
-
-T = TypeVar("T")
-
-
-def choose_first(*objects: T) -> T:
-    for obj in objects:
-        if isinstance(obj, np.ndarray):
-            if not _is_empty_ndarray(obj):
-                return cast(T, obj)
-        else:
-            if obj:
-                return obj
-    # if everything failed, return the last
-    return objects[-1]

classiq/applications_model_constructors/__init__.py

@@ -1,25 +0,0 @@
-from typing import List
-
-from .chemistry_model_constructor import (
-    construct_chemistry_model,
-    molecule_problem_to_qmod,
-)
-from .combinatorial_optimization_model_constructor import (
-    construct_combinatorial_optimization_model,
-)
-from .finance_model_constructor import construct_finance_model
-from .grover_model_constructor import construct_grover_model
-from .qsvm_model_constructor import construct_qsvm_model
-
-__all__: List[str] = [
-    "construct_qsvm_model",
-    "construct_combinatorial_optimization_model",
-    "construct_chemistry_model",
-    "construct_finance_model",
-    "construct_grover_model",
-    "molecule_problem_to_qmod",
-]
-
-
-def __dir__():
-    return __all__

classiq/applications_model_constructors/combinatorial_helpers/multiple_comp_basis_sp.py

@@ -1,34 +0,0 @@
-from classiq.interface.generator.function_params import DEFAULT_OUTPUT_NAME
-from classiq.interface.generator.functions import SynthesisNativeFunctionDefinition
-from classiq.interface.generator.state_preparation import (
-    ComputationalBasisStatePreparation,
-)
-
-from classiq import FunctionGenerator, QReg
-
-BinaryStr = str
-Name = str
-
-
-def multiple_comp_basis_sp(
-    function_name: str, states: dict[Name, BinaryStr], call_name_frmt: str = "{}"
-) -> SynthesisNativeFunctionDefinition:
-    generator = FunctionGenerator(function_name=function_name)
-    qregs_dict = {
-        var_name: QReg[len(state)]  # type:ignore[misc]
-        for var_name, state in states.items()
-    }
-    qregs = generator.create_inputs(qregs_dict)
-
-    for var_name, state in states.items():
-        params = ComputationalBasisStatePreparation(computational_state=state)
-        qregs[var_name] = generator.ComputationalBasisStatePreparation(
-            params,
-            in_wires=qregs[var_name],
-            strict_zero_ios=False,
-            call_name=call_name_frmt.format(var_name),
-        )[DEFAULT_OUTPUT_NAME]
-
-    generator.set_outputs(qregs)
-
-    return generator.to_function_definition()

classiq/applications_model_constructors/combinatorial_helpers/pauli_helpers/pauli_utils.py

@@ -1,65 +0,0 @@
-from typing import List, cast
-
-from classiq.interface.chemistry.operator import PauliOperator
-from classiq.interface.generator.expressions.enums.pauli import Pauli
-from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
-from classiq.interface.helpers.custom_pydantic_types import PydanticPauliList
-
-from classiq.exceptions import (
-    ClassiqExecutorInvalidHamiltonianError,
-    ClassiqNonNumericCoefficientInPauliError,
-    ClassiqValueError,
-)
-
-
-def _pauli_str_to_enums(pauli_str: str) -> str:
-    return ", ".join(f"Pauli.{pauli_term}" for pauli_term in pauli_str)
-
-
-def pauli_integers_to_str(paulis: List[Pauli]) -> str:
-    return "".join([Pauli(pauli).name for pauli in paulis])
-
-
-def pauli_operator_to_hamiltonian(pauli_list: PydanticPauliList) -> List[QmodPyStruct]:
-    pauli_struct_list: List[QmodPyStruct] = []
-    for pauli_term in pauli_list:
-        if not isinstance(pauli_term[1], complex) or pauli_term[1].imag != 0:
-            raise ClassiqNonNumericCoefficientInPauliError(
-                "Coefficient is not a number."
-            )
-
-        pauli_struct_list.append(
-            {
-                "pauli": [Pauli[p] for p in pauli_term[0]],
-                "coefficient": pauli_term[1].real,
-            }
-        )
-    return pauli_struct_list
-
-
-def get_pauli_operator(pauli_operator: List[QmodPyStruct]) -> PauliOperator:
-    pauli_list = [
-        (
-            pauli_integers_to_str(elem["pauli"]),
-            elem["coefficient"],
-        )
-        for elem in pauli_operator
-    ]
-
-    try:
-        pauli = PauliOperator(pauli_list=pauli_list)
-    except ValueError:
-        raise ClassiqExecutorInvalidHamiltonianError() from None
-
-    return pauli
-
-
-def _pauli_operator_to_qmod(hamiltonian: PauliOperator) -> str:
-    if not all(isinstance(summand[1], complex) for summand in hamiltonian.pauli_list):
-        raise ClassiqValueError(
-            "Supporting only Hamiltonian with numeric coefficients."
-        )
-    return ", ".join(
-        f"struct_literal(PauliTerm, pauli=[{_pauli_str_to_enums(pauli)}], coefficient={cast(complex, coeff).real})"
-        for pauli, coeff in hamiltonian.pauli_list
-    )

classiq/applications_model_constructors/combinatorial_helpers/pyomo_utils.py

@@ -1,243 +0,0 @@
-import json
-from enum import Enum
-from typing import Any, Dict, List, Type, TypeVar, Union
-
-import pydantic
-import pyomo.core.expr.numeric_expr as pyo_expr
-import pyomo.environ as pyo
-import sympy
-from pyomo.core import ConcreteModel, Constraint, Objective, Var, maximize
-from pyomo.core.base import _GeneralVarData
-from pyomo.core.base.component import ComponentData
-from pyomo.core.base.constraint import _GeneralConstraintData
-from pyomo.core.base.indexed_component import IndexedComponent
-from pyomo.core.base.objective import ScalarObjective
-from pyomo.core.expr.sympy_tools import (
-    Pyomo2SympyVisitor,
-    PyomoSympyBimap,
-    Sympy2PyomoVisitor,
-)
-
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-
-from classiq.exceptions import ClassiqValueError
-
-ListVars = List[_GeneralVarData]
-
-
-class ObjectiveType(Enum):
-    Min = "Min"
-    Max = "Max"
-
-
-class CombinatorialOptimizationStructDeclaration(StructDeclaration):
-    variable_lower_bound: int = pydantic.Field(default=0)
-    variable_upper_bound: int = pydantic.Field(default=1)
-    constraints: List[Expression] = pydantic.Field(
-        default_factory=list, description="List of constraint expressions"
-    )
-    objective_type: ObjectiveType = pydantic.Field(
-        description="Specify whether the optimization problem is Min or Max"
-    )
-    objective_function: Expression = pydantic.Field(
-        description="The expression to optimize, according to the objective type"
-    )
-
-
-def contains(var_data: _GeneralVarData, vars_data: ListVars) -> bool:
-    # HACK: standard "__containts__ (in)" method doesn't work, because pyomo overrode the __eq__ method (IMO)
-    return any(var_data is var_data_temp for var_data_temp in vars_data)
-
-
-def remove(var_data: _GeneralVarData, vars_data: ListVars) -> ListVars:
-    # HACK: standard "list method remove" method doesn't work, because pyomo overrode the __eq__ method (IMO)
-    assert contains(var_data, vars_data), "var not in list"
-    vars_data = vars_data.copy()
-    for idx, var_data_temp in enumerate(vars_data):
-        if var_data_temp is var_data:
-            del vars_data[idx]
-            break
-    return vars_data
-
-
-def index(var_data: _GeneralVarData, vars_data: ListVars) -> int:
-    # HACK: standard "index method" doesn't work.
-    assert contains(var_data, vars_data), "var not in list"
-    idxs = [
-        idx for idx, var_data_temp in enumerate(vars_data) if var_data is var_data_temp
-    ]
-    return idxs[0]
-
-
-T = TypeVar("T")
-
-
-def extract(model: ConcreteModel, type_: Type[T]) -> List[T]:
-    if type_ == _GeneralVarData:
-        type_ = Var
-
-    elif type_ == _GeneralConstraintData:
-        type_ = Constraint
-
-    components = model.component_objects(type_)
-    return [
-        component[component_idx]
-        for component in components
-        for component_idx in component
-    ]
-
-
-def delete_component(model: ConcreteModel, component: ComponentData) -> None:
-    parent_ref = component._component
-
-    if parent_ref is None:
-        return
-
-    parent_component = parent_ref()
-
-    if component is parent_component:
-        model.del_component(component)
-    else:
-        _delete_element_by_value(parent_component, component)
-
-        if not parent_component:
-            model.del_component(parent_component)
-
-
-def _delete_element_by_value(dict_: Dict, value: Any) -> None:
-    iter_dict = {**dict_}
-    for k, v in iter_dict.items():
-        if v is value and k in dict_:
-            del dict_[k]
-
-
-def get_name(component: Union[IndexedComponent, ComponentData]) -> str:
-    if isinstance(component, IndexedComponent):
-        return component._name  # constraint.name returns "'{name}'"
-    else:
-        return component.name
-
-
-class FixedSympy2PyomoVisitor(Sympy2PyomoVisitor):
-    def beforeChild(self, node, child, child_idx):  # noqa: N802
-        if not child._args:
-            item = self.object_map.getPyomoSymbol(child, None)
-            if item is None:
-                if isinstance(child, sympy.Integer):  # addition to base implementation
-                    item = int(child.evalf())
-                else:
-                    item = float(child.evalf())
-            return False, item
-        return True, None
-
-
-def sympy2pyomo_expression(
-    expr: sympy.core.Basic, object_map: PyomoSympyBimap
-) -> pyo_expr.ExpressionBase:
-    return FixedSympy2PyomoVisitor(object_map).walk_expression(expr)
-
-
-def convert_pyomo_to_global_presentation(
-    pyo_model: pyo.ConcreteModel,
-) -> pyo.ConcreteModel:
-    pyo_model_str = pyomo2qmod("nativePyoModel", pyo_model)
-    problem_struct = CombinatorialOptimizationStructDeclaration.parse_raw(pyo_model_str)
-
-    pyomo_model = pyo.ConcreteModel()
-
-    var_names = list(problem_struct.variables.keys())
-    pyomo_model.var_set = pyo.Var(
-        var_names,
-        domain=pyo.NonNegativeIntegers,
-        bounds=(
-            problem_struct.variable_lower_bound,
-            problem_struct.variable_upper_bound,
-        ),
-    )
-    obj_map = PyomoSympyBimap()
-    var_dict = {
-        var_name: obj_map.getSympySymbol(pyomo_model.var_set[var_name])
-        for var_name in var_names
-    }
-
-    def expr2pyomo(expr: Expression) -> pyo_expr.ExpressionBase:
-        sp_expr = sympy.sympify(expr.expr, locals=var_dict)
-        if isinstance(sp_expr, sympy.core.relational.Equality):
-            return sympy2pyomo_expression(
-                sp_expr.args[0], obj_map
-            ) == sympy2pyomo_expression(sp_expr.args[1], obj_map)
-
-        # Note that strict greater/less than are not supported by Pyomo
-        return sympy2pyomo_expression(sp_expr, obj_map)
-
-    pyomo_model.constraints = pyo.Constraint(
-        pyo.RangeSet(0, len(problem_struct.constraints) - 1),
-        rule=lambda model, i: expr2pyomo(problem_struct.constraints[i]),
-    )
-    pyomo_model.objective = pyo.Objective(
-        expr=expr2pyomo(problem_struct.objective_function),
-        sense=(
-            pyo.maximize
-            if problem_struct.objective_type == ObjectiveType.Max
-            else pyo.minimize
-        ),
-    )
-
-    return pyomo_model
-
-
-def pyomo2qmod(struct_name: str, pyo_model: ConcreteModel) -> str:
-    symbols_map = PyomoSympyBimap()
-
-    variables: List[sympy.Symbol] = []
-
-    bounds_set = False
-    lower_bound = None
-    upper_bound = None
-
-    for var_dict in pyo_model.component_objects(Var):
-        for key in var_dict:
-            var = Pyomo2SympyVisitor(symbols_map).walk_expression(var_dict[key])
-            var.name = var.name.replace(",", "_")
-            variables.append(var)
-            if bounds_set:
-                if lower_bound != var_dict[key].lb:
-                    raise ClassiqValueError(
-                        "All problem variables must agree on lower bound"
-                    )
-                if upper_bound != var_dict[key].ub:
-                    raise ClassiqValueError(
-                        "All problem variables must agree on upper bound"
-                    )
-            else:
-                lower_bound = var_dict[key].lb
-                upper_bound = var_dict[key].ub
-                bounds_set = True
-
-    constraint_exprs: List[sympy.Expr] = []
-
-    constraint_exprs.extend(
-        Pyomo2SympyVisitor(symbols_map).walk_expression(constraint_dict[key].expr)
-        for constraint_dict in pyo_model.component_objects(Constraint)
-        for key in constraint_dict
-    )
-
-    pyo_objective: ScalarObjective = next(pyo_model.component_objects(Objective))
-    objective_type_str = "Max" if pyo_objective.sense == maximize else "Min"
-    objective_expr: sympy.Expr = Pyomo2SympyVisitor(symbols_map).walk_expression(
-        pyo_objective
-    )
-
-    combi_struct_decl = {
-        "name": struct_name,
-        "variables": {str(variable): {"kind": "int"} for variable in variables},
-        "variable_lower_bound": lower_bound,
-        "variable_upper_bound": upper_bound,
-        "constraints": [
-            {"expr": str(constraint_expr)} for constraint_expr in constraint_exprs
-        ],
-        "objective_type": objective_type_str,
-        "objective_function": {"expr": str(objective_expr)},
-    }
-    return json.dumps(combi_struct_decl, indent=2)

classiq/applications_model_constructors/libraries/ampltitude_estimation_library.py

@@ -1,11 +0,0 @@
-AE_CLASSICAL_LIBRARY = """
-def execute_amplitude_estimation(phase_port_size):
-    result = sample()
-    estimation = qae_with_qpe_result_post_processing(
-        estimation_register_size=phase_port_size,
-        estimation_method=1,
-        result=result
-    )
-    save({"result": result, "estimation": estimation})
-    return estimation
-"""

classiq/applications_model_constructors/libraries/qmci_library.py

@@ -1,107 +0,0 @@
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumOperandDeclaration,
-)
-from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
-
-from classiq import Integer
-
-QMCI_LIBRARY = [
-    NativeFunctionDefinition(
-        name="qmci",
-        param_decls={
-            "num_phase_qubits": Integer(),
-            "num_unitary_qubits": Integer(),
-        },
-        port_declarations={
-            "phase_port": PortDeclaration(
-                name="phase_port",
-                size=Expression(expr="num_phase_qubits"),
-                direction=PortDeclarationDirection.Output,
-            ),
-            "unitary_port": PortDeclaration(
-                name="unitary_port",
-                size=Expression(expr="num_unitary_qubits"),
-                direction=PortDeclarationDirection.Output,
-            ),
-        },
-        operand_declarations={
-            "sp_op": QuantumOperandDeclaration(
-                name="sp_op",
-                param_decls={"num_unitary_qubits": Integer()},
-                port_declarations={
-                    "reg": PortDeclaration(
-                        name="reg",
-                        direction=PortDeclarationDirection.Inout,
-                        size=Expression(expr="num_unitary_qubits-1"),
-                    ),
-                    "ind": PortDeclaration(
-                        name="ind",
-                        direction=PortDeclarationDirection.Inout,
-                        size=Expression(expr="1"),
-                    ),
-                },
-            ),
-        },
-        body=[
-            QuantumFunctionCall(
-                function="amplitude_estimation",
-                params={
-                    "num_phase_qubits": Expression(expr="num_phase_qubits"),
-                    "num_unitary_qubits": Expression(expr="num_unitary_qubits"),
-                },
-                outputs={
-                    "phase_port": HandleBinding(name="phase_port"),
-                    "unitary_port": HandleBinding(name="unitary_port"),
-                },
-                operands={
-                    "sp_op": QuantumLambdaFunction(
-                        body=[
-                            QuantumFunctionCall(
-                                function="sp_op",
-                                params={
-                                    "num_unitary_qubits": Expression(
-                                        expr="num_unitary_qubits"
-                                    )
-                                },
-                                inouts={
-                                    "reg": SlicedHandleBinding(
-                                        name="spq",
-                                        start=Expression(expr="0"),
-                                        end=Expression(expr="num_unitary_qubits-1"),
-                                    ),
-                                    "ind": SlicedHandleBinding(
-                                        name="spq",
-                                        start=Expression(expr="num_unitary_qubits-1"),
-                                        end=Expression(expr="num_unitary_qubits"),
-                                    ),
-                                },
-                            )
-                        ],
-                    ),
-                    "oracle_op": QuantumLambdaFunction(
-                        body=[
-                            QuantumFunctionCall(
-                                function="Z",
-                                inouts={
-                                    "target": SlicedHandleBinding(
-                                        name="oq",
-                                        start=Expression(expr="num_unitary_qubits-1"),
-                                        end=Expression(expr="num_unitary_qubits"),
-                                    ),
-                                },
-                            ),
-                        ]
-                    ),
-                },
-            ),
-        ],
-    ),
-]

classiq/builtin_functions/__init__.py

@@ -1,43 +0,0 @@
-from typing import List
-
-from classiq.interface.generator.function_param_list import *  # noqa: F403
-from classiq.interface.generator.function_param_list_without_self_reference import *  # noqa: F403
-from classiq.interface.generator.oracles.oracle_function_param_list import *  # noqa: F403
-
-from ..builtin_functions import (
-    amplitude_loading,
-    binary_ops,
-    exponentiation,
-    qpe,
-    qsvm,
-    range_types,
-    state_preparation,
-    suzuki_trotter,
-)
-from .standard_gates import *  # noqa: F403
-
-__all__ = (
-    [function.__name__ for function in function_param_library.param_list]  # noqa: F405
-    + [
-        function.__name__
-        for function in standard_gate_function_param_library.param_list  # noqa: F405
-    ]
-    + [
-        function.__name__
-        for function in oracle_function_param_library.param_list  # noqa: F405
-    ]
-    + [
-        "exponentiation",
-        "state_preparation",
-        "suzuki_trotter",
-        "range_types",
-        "binary_ops",
-        "qpe",
-        "amplitude_loading",
-        "qsvm",
-    ]
-)
-
-
-def __dir__() -> List[str]:
-    return __all__

classiq/builtin_functions/amplitude_loading.py

@@ -1,3 +0,0 @@
-from classiq.interface.generator.amplitude_loading import (  # noqa: F401
-    AmplitudeLoadingImplementation,
-)

classiq/builtin_functions/binary_ops.py

@@ -1 +0,0 @@
-from classiq.interface.generator.arith.binary_ops import ArgToInplace  # noqa: F401

classiq/builtin_functions/exponentiation.py

@@ -1,5 +0,0 @@
-from classiq.interface.chemistry.operator import PauliOperator  # noqa: F401
-from classiq.interface.generator.hamiltonian_evolution.exponentiation import (  # noqa: F401
-    ExponentiationConstraints,
-    ExponentiationOptimization,
-)

classiq/builtin_functions/qpe.py

@@ -1,4 +0,0 @@
-from classiq.interface.generator.qpe import (  # noqa: F401
-    ExponentiationScaling,
-    ExponentiationSpecification,
-)

classiq/builtin_functions/qsvm.py

@@ -1,7 +0,0 @@
-from classiq.interface.generator.qsvm import (  # noqa: F401
-    FeatureMapType,
-    QSVMFeatureMapBlochSphere,
-    QSVMFeatureMapDimensional,
-    QSVMFeatureMapEntanglement,
-    QSVMFeatureMapPauli,
-)

classiq/builtin_functions/range_types.py

@@ -1,5 +0,0 @@
-from classiq.interface.generator.range_types import (  # noqa: F401
-    NonNegativeFloatRange,
-    NonNegativeIntRange,
-    Range,
-)

classiq/builtin_functions/standard_gates.py

@@ -1 +0,0 @@
-from classiq.interface.generator.standard_gates.standard_gates_param_list import *  # noqa: F403

classiq/builtin_functions/state_preparation.py

@@ -1,6 +0,0 @@
-from classiq.interface.generator.state_preparation import (  # noqa: F401
-    PMF,
-    GaussianMixture,
-    GaussianMoments,
-    Metrics,
-)