classiq 0.37.1__py3-none-any.whl → 0.39.0__py3-none-any.whl

{classiq-0.37.1.dist-info → classiq-0.39.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any

classiq/applications/benchmarking/__init__.py

@@ -1,9 +0,0 @@
-from typing import List
-
-from classiq.applications.benchmarking.mirror_benchmarking import MirrorBenchmarking
-
-__all__ = ["MirrorBenchmarking"]
-
-
-def __dir__() -> List[str]:
-    return __all__

classiq/applications/benchmarking/mirror_benchmarking.py

@@ -1,67 +0,0 @@
-from copy import deepcopy
-
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
-from classiq.interface.generator.model.preferences.preferences import (
-    Preferences,
-    QuantumFormat,
-    TranspilationOption,
-)
-
-from classiq._internals.async_utils import Asyncify
-from classiq.model.model import Model
-from classiq.quantum_functions.decorators import quantum_function as qfunc
-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(metaclass=Asyncify):
-    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: GeneratedCircuit = GeneratedCircuit.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]
-
-        @qfunc
-        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
-
-    @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,17 +0,0 @@
-from typing import List
-
-from .chemistry_model_constructor import construct_chemistry_model
-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",
-]

classiq/applications_model_constructors/combinatorial_optimization_model_constructor.py

@@ -1,178 +0,0 @@
-import json
-from typing import List, Optional
-
-import sympy
-from pyomo import environ as pyo
-from pyomo.core import ConcreteModel, Constraint, Objective, Var, maximize
-from pyomo.core.base.objective import ScalarObjective
-from pyomo.core.expr.sympy_tools import Pyomo2SympyVisitor, PyomoSympyBimap
-
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import ClassicalArray, Real
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.generator.types.combinatorial_problem import (
-    CombinatorialOptimizationStructDeclaration,
-)
-from classiq.interface.model.handle_binding import HandleBinding
-from classiq.interface.model.model import Model, SerializedModel
-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.applications.combinatorial_optimization.combinatorial_optimization_config import (
-    OptimizerConfig,
-    QAOAConfig,
-)
-
-_OUTPUT_VARIABLE_NAME = "solution"
-
-
-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 ValueError("All problem variables must agree on lower bound")
-                if upper_bound != var_dict[key].ub:
-                    raise ValueError("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] = []
-
-    for constraint_dict in pyo_model.component_objects(Constraint):
-        for key in constraint_dict:
-            constraint_exprs.append(
-                Pyomo2SympyVisitor(symbols_map).walk_expression(
-                    constraint_dict[key].expr
-                )
-            )
-
-    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)
-
-
-def construct_combi_opt_py_model(
-    pyo_model: pyo.ConcreteModel,
-    qaoa_config: Optional[QAOAConfig] = None,
-    optimizer_config: Optional[OptimizerConfig] = None,
-) -> Model:
-    if qaoa_config is None:
-        qaoa_config = QAOAConfig()
-
-    if optimizer_config is None:
-        optimizer_config = OptimizerConfig()
-
-    max_iteration = 0
-    if optimizer_config.max_iteration is not None:
-        max_iteration = optimizer_config.max_iteration
-
-    initial_point_expression = (
-        f"{optimizer_config.initial_point}"
-        if optimizer_config.initial_point is not None
-        else f"compute_qaoa_initial_point(optimization_problem_to_hamiltonian(get_type(MyCombiProblem), {qaoa_config.penalty_energy}),{qaoa_config.num_layers})"
-    )
-
-    return Model(
-        types=[
-            CombinatorialOptimizationStructDeclaration.parse_raw(
-                pyomo2qmod("MyCombiProblem", pyo_model)
-            )
-        ],
-        functions=[
-            NativeFunctionDefinition(
-                name="main",
-                param_decls={
-                    "params_list": ClassicalArray(
-                        element_type=Real(), size=qaoa_config.num_layers * 2
-                    )
-                },
-                port_declarations={
-                    "target": PortDeclaration(
-                        name="target",
-                        size=Expression(
-                            expr=f"len(get_field(optimization_problem_to_hamiltonian(get_type(MyCombiProblem), {qaoa_config.penalty_energy})[0], 'pauli'))"
-                        ),
-                        direction=PortDeclarationDirection.Output,
-                    ),
-                },
-                body=[
-                    QuantumFunctionCall(
-                        function="allocate",
-                        positional_args=[
-                            Expression(expr="len(target)"),
-                            HandleBinding(name="target"),
-                        ],
-                    ),
-                    QuantumFunctionCall(
-                        function="qaoa_penalty",
-                        params={
-                            "hamiltonian": Expression(
-                                expr=f"optimization_problem_to_hamiltonian(get_type(MyCombiProblem), {qaoa_config.penalty_energy})"
-                            ),
-                            "params_list": Expression(expr="params_list"),
-                            "num_qubits": Expression(expr="len(target)"),
-                            "is_st": Expression(expr="True"),
-                        },
-                        inouts={"target": HandleBinding(name="target")},
-                    ),
-                ],
-            ),
-        ],
-        classical_execution_code=f"""
-vqe_result = vqe(
-    hamiltonian=optimization_problem_to_hamiltonian(get_type(MyCombiProblem), {qaoa_config.penalty_energy}),
-    maximize={next(pyo_model.component_objects(Objective)).sense==maximize},
-    initial_point={initial_point_expression},
-    optimizer=Optimizer.{optimizer_config.opt_type},
-    max_iteration={max_iteration},
-    tolerance={optimizer_config.tolerance},
-    step_size={optimizer_config.step_size},
-    skip_compute_variance={optimizer_config.skip_compute_variance},
-    alpha_cvar={optimizer_config.alpha_cvar}
-)
-{_OUTPUT_VARIABLE_NAME} = get_optimization_solution(get_type(MyCombiProblem), vqe_result, {qaoa_config.penalty_energy})
-hamiltonian = optimization_problem_to_hamiltonian(get_type(MyCombiProblem), {qaoa_config.penalty_energy})
-save({{{_OUTPUT_VARIABLE_NAME!r}: {_OUTPUT_VARIABLE_NAME}, "vqe_result": vqe_result, "hamiltonian": hamiltonian}})
-""",
-    )
-
-
-def construct_combinatorial_optimization_model(
-    pyo_model: pyo.ConcreteModel,
-    qaoa_config: Optional[QAOAConfig] = None,
-    optimizer_config: Optional[OptimizerConfig] = None,
-) -> SerializedModel:
-    model = construct_combi_opt_py_model(pyo_model, qaoa_config, optimizer_config)
-    return model.get_model()

classiq/applications_model_constructors/libraries/qmci_library.py

@@ -1,109 +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,
-    QuantumLambdaFunction,
-)
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumOperandDeclaration,
-)
-
-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_unitary_qubits": Expression(expr="num_unitary_qubits"),
-                    "num_phase_qubits": Expression(expr="num_phase_qubits"),
-                },
-                outputs={
-                    "phase_port": HandleBinding(name="phase_port"),
-                    "unitary_port": HandleBinding(name="unitary_port"),
-                },
-                operands={
-                    "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"),
-                                    ),
-                                },
-                            ),
-                        ]
-                    ),
-                    "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"),
-                                    ),
-                                },
-                            )
-                        ],
-                    ),
-                },
-            ),
-        ],
-    ),
-]

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: F401, F403

classiq/builtin_functions/state_preparation.py

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

classiq/builtin_functions/suzuki_trotter.py

@@ -1,3 +0,0 @@
-from classiq.interface.generator.hamiltonian_evolution.suzuki_trotter import (  # noqa: F401
-    SuzukiParameters,
-)

classiq/interface/generator/expressions/qmod_qnum_proxy.py

@@ -1,22 +0,0 @@
-from sympy import Symbol
-
-from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
-from classiq.interface.model.quantum_type import QuantumNumeric
-
-
-class QmodQNumProxy(Symbol, QmodSizedProxy):
-    def __new__(cls, name, **assumptions):
-        return super().__new__(cls, name, **assumptions)
-
-    def __init__(self, name: str, quantum_type: QuantumNumeric) -> None:
-        super().__init__(quantum_type.size_in_bits)
-        self._fraction_digits = quantum_type.fraction_digits
-        self._is_signed = quantum_type.is_signed
-
-    @property
-    def fraction_digits(self) -> int:
-        return self._fraction_digits
-
-    @property
-    def is_signed(self) -> bool:
-        return self._is_signed

classiq/interface/generator/functions/core_lib_declarations/quantum_functions/__init__.py

@@ -1,18 +0,0 @@
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-)
-
-from .atomic_quantum_functions import *  # noqa: F403
-from .exponentiation_functions import *  # noqa: F403
-from .std_lib_functions import *  # noqa: F403
-
-QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS.update(
-    nameables_to_dict(
-        [
-            func
-            for func in vars().values()
-            if isinstance(func, QuantumFunctionDeclaration)
-        ]
-    )
-)