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

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/grover_model_constructor.py

@@ -1,227 +0,0 @@
-from typing import Dict, List, Tuple
-
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.model.bind_operation import BindOperation
-from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
-from classiq.interface.model.model import Model, SerializedModel
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.numeric_reinterpretation import (
-    NumericReinterpretationOperation,
-)
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_expressions.arithmetic_operation import (
-    ArithmeticOperation,
-)
-from classiq.interface.model.quantum_function_call import (
-    QuantumFunctionCall,
-    QuantumLambdaFunction,
-)
-from classiq.interface.model.quantum_statement import QuantumStatement
-from classiq.interface.model.quantum_type import QuantumNumeric
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
-
-from classiq import RegisterUserInput
-
-_OUTPUT_VARIABLE_NAME = "result"
-
-_PREDICATE_FUNCTION_NAME = "expr_predicate"
-
-
-def split_registers(
-    register_names: List[str],
-    register_sizes: List[int],
-    input_wire_name: str,
-) -> List[QuantumStatement]:
-    if len(register_names) == 0:
-        return []
-    wires = (
-        [input_wire_name]
-        + [f"split{i}" for i in range(len(register_names) - 2)]
-        + [register_names[-1]]
-    )
-
-    if len(register_names) == 1:
-        return [
-            BindOperation(
-                in_handle=HandleBinding(name=wires[0]),
-                out_handle=HandleBinding(name=wires[1]),
-            )
-        ]
-
-    return [
-        QuantumFunctionCall(
-            function="split",
-            params={
-                "out1_size": Expression(expr=f"{int(register_sizes[i])}"),
-                "out2_size": Expression(expr=f"{int(sum(register_sizes[i + 1:]))}"),
-            },
-            inputs={"in": HandleBinding(name=wires[i])},
-            outputs={
-                "out1": HandleBinding(name=register),
-                "out2": HandleBinding(name=wires[i + 1]),
-            },
-        )
-        for i, register in enumerate(register_names[:-1])
-    ]
-
-
-def _arithmetic_oracle_io_dict(
-    definitions: List[Tuple[str, RegisterUserInput]], handle_name: str
-) -> Dict[str, HandleBinding]:
-    cursor = 0
-    ios: Dict[str, HandleBinding] = dict()
-    for reg_name, reg in definitions:
-        ios[reg_name] = SlicedHandleBinding(
-            name=handle_name,
-            start=Expression(expr=f"{cursor}"),
-            end=Expression(expr=f"{cursor + reg.size}"),
-        )
-        cursor += reg.size
-    return ios
-
-
-def _construct_arithmetic_oracle(
-    predicate_function: str,
-    definitions: List[Tuple[str, RegisterUserInput]],
-) -> QuantumFunctionCall:
-    predicate_var_binding = _arithmetic_oracle_io_dict(definitions, "vars")
-    predicate_var_binding["res"] = HandleBinding(name="result")
-    return QuantumFunctionCall(
-        function="simple_oracle",
-        inouts={
-            "target": HandleBinding(name="oq"),
-        },
-        operands={
-            "predicate": QuantumLambdaFunction(
-                body=[
-                    QuantumFunctionCall(
-                        function=predicate_function,
-                        inouts=predicate_var_binding,
-                    ),
-                ],
-            ),
-        },
-    )
-
-
-def grover_main_port_declarations(
-    definitions: List[Tuple[str, RegisterUserInput]],
-    direction: PortDeclarationDirection,
-) -> Dict[str, PortDeclaration]:
-    return {
-        name: PortDeclaration(
-            name=name,
-            size=Expression(expr=f"{reg.size}"),
-            quantum_type=QuantumNumeric(),
-            direction=direction,
-        )
-        for name, reg in definitions
-    }
-
-
-def _generate_variable_declaration_statements(
-    definitions: List[Tuple[str, RegisterUserInput]]
-) -> List[VariableDeclarationStatement]:
-    ret = [VariableDeclarationStatement(name="gsq")]
-    if len(definitions) >= 2:
-        ret += [
-            VariableDeclarationStatement(name=f"split{i}")
-            for i in range(len(definitions) - 2)
-        ]
-    return ret
-
-
-def reinterpret_registers(
-    definitions: List[Tuple[str, RegisterUserInput]]
-) -> List[QuantumStatement]:
-    return [
-        NumericReinterpretationOperation(
-            target=HandleBinding(name=name),
-            fraction_digits=Expression(expr=f"{definition.fraction_places}"),
-            is_signed=Expression(expr=f"{definition.is_signed}"),
-        )
-        for name, definition in definitions
-    ]
-
-
-def construct_grover_model(
-    definitions: List[Tuple[str, RegisterUserInput]],
-    expression: str,
-    num_reps: int = 1,
-) -> SerializedModel:
-    predicate_port_decls = grover_main_port_declarations(
-        definitions, PortDeclarationDirection.Inout
-    )
-    predicate_port_decls["res"] = PortDeclaration(
-        name="res",
-        size=Expression(expr="1"),
-        direction=PortDeclarationDirection.Inout,
-    )
-    num_qubits = sum(reg.size for _, reg in definitions)
-
-    grover_model = Model(
-        functions=[
-            NativeFunctionDefinition(
-                name=_PREDICATE_FUNCTION_NAME,
-                port_declarations=predicate_port_decls,
-                body=[
-                    *reinterpret_registers(definitions),
-                    ArithmeticOperation(
-                        expression=Expression(expr=expression),
-                        result_var=HandleBinding(name="res"),
-                        inplace_result=True,
-                    ),
-                ],
-            ),
-            NativeFunctionDefinition(
-                name="main",
-                port_declarations=grover_main_port_declarations(
-                    definitions, PortDeclarationDirection.Output
-                ),
-                body=[
-                    *_generate_variable_declaration_statements(definitions),
-                    QuantumFunctionCall(
-                        function="allocate",
-                        positional_args=[
-                            Expression(expr=f"{num_qubits}"),
-                            HandleBinding(name="gsq"),
-                        ],
-                    ),
-                    QuantumFunctionCall(
-                        function="grover_search",
-                        params={
-                            "num_qubits": Expression(expr=f"{num_qubits}"),
-                            "reps": Expression(expr=f"{num_reps}"),
-                        },
-                        inouts={"gsq": HandleBinding(name="gsq")},
-                        operands={
-                            "oracle_op": QuantumLambdaFunction(
-                                body=[
-                                    _construct_arithmetic_oracle(
-                                        _PREDICATE_FUNCTION_NAME,
-                                        definitions,
-                                    )
-                                ]
-                            )
-                        },
-                    ),
-                    *split_registers(
-                        [name for name, _ in definitions],
-                        [reg.size for _, reg in definitions],
-                        "gsq",
-                    ),
-                    *reinterpret_registers(definitions),
-                ],
-            ),
-        ],
-        classical_execution_code=f"""
-{_OUTPUT_VARIABLE_NAME} = sample()
-save({{{_OUTPUT_VARIABLE_NAME!r}: {_OUTPUT_VARIABLE_NAME}}})
-""",
-    )
-    return grover_model.get_model()

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,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__