classiq 0.70.0__py3-none-any.whl → 0.72.0__py3-none-any.whl

classiq/applications/finance/finance_model_constructor.py

@@ -1,137 +0,0 @@
-import warnings
-from math import floor, log
-from typing import Union
-
-from classiq.interface.exceptions import ClassiqError
-from classiq.interface.finance.function_input import FinanceFunctionInput
-from classiq.interface.finance.gaussian_model_input import GaussianModelInput
-from classiq.interface.finance.log_normal_model_input import LogNormalModelInput
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.model.allocate import Allocate
-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.interface.model.quantum_lambda_function import QuantumLambdaFunction
-from classiq.interface.model.quantum_type import QuantumNumeric
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
-
-from classiq.applications.libraries.qmci_library import QMCI_LIBRARY
-from classiq.qmod.utilities import qmod_val_to_expr_str
-
-_OUTPUT_VARIABLE_NAME = "payoff_estimation"
-
-
-def construct_finance_model(
-    finance_model_input: Union[LogNormalModelInput, GaussianModelInput],
-    finance_function_input: FinanceFunctionInput,
-    phase_port_size: int,
-) -> SerializedModel:
-    warnings.warn(
-        "Function 'construct_finance_model' has been deprecated and will no longer"
-        "be supported starting on 03/02/2025 the earliest\nHint: It is now possible to "
-        "implement Option Pricing in pure Qmod. For example, see the Option Pricing notebook on the "
-        "Classiq library at https://github.com/Classiq/classiq-library/blob/main/applications/finance/option_pricing/option_pricing.ipynb",
-        category=DeprecationWarning,
-        stacklevel=2,
-    )
-    if isinstance(finance_model_input, LogNormalModelInput):
-        finance_model = f"struct_literal(LogNormalModel, num_qubits={finance_model_input.num_qubits}, mu={finance_model_input.mu}, sigma={finance_model_input.sigma})"
-        finance_function = "log_normal_finance"
-        post_process_function = "log_normal_finance_post_process"
-        total_num_qubits = finance_model_input.num_qubits
-    elif isinstance(finance_model_input, GaussianModelInput):
-        finance_model = f"struct_literal(GaussianModel, num_qubits={finance_model_input.num_qubits}, normal_max_value={finance_model_input.normal_max_value}, default_probabilities={finance_model_input.default_probabilities}, rhos={finance_model_input.rhos}, loss={finance_model_input.loss}, min_loss={finance_model_input.min_loss})"
-        finance_function = "gaussian_finance"
-        post_process_function = "gaussian_finance_post_process"
-        total_num_qubits = (
-            finance_model_input.num_qubits
-            + len(finance_model_input.rhos)
-            + floor(log(sum(finance_model_input.loss), 2))
-            + 1
-        )
-    else:
-        raise ClassiqError(f"Invalid model input: {finance_model_input}")
-
-    polynomial_degree = 0
-    if finance_function_input.polynomial_degree is not None:
-        polynomial_degree = finance_function_input.polynomial_degree
-
-    tail_probability = 0.0
-    if finance_function_input.tail_probability is not None:
-        tail_probability = finance_function_input.tail_probability
-
-    finance_function_object = f"struct_literal(FinanceFunction, f={qmod_val_to_expr_str(finance_function_input.f)}, threshold={finance_function_input.condition.threshold}, larger={finance_function_input.condition.larger}, polynomial_degree={polynomial_degree}, use_chebyshev_polynomial_approximation={finance_function_input.use_chebyshev_polynomial_approximation}, tail_probability={tail_probability})"
-    num_unitary_qubits = total_num_qubits + 1
-
-    model = Model(
-        functions=[
-            *QMCI_LIBRARY,
-            NativeFunctionDefinition(
-                name="main",
-                positional_arg_declarations=[
-                    PortDeclaration(
-                        name="phase_port",
-                        quantum_type=QuantumNumeric(
-                            size=Expression(expr=f"{phase_port_size}"),
-                            is_signed=Expression(expr="False"),
-                            fraction_digits=Expression(expr=f"{phase_port_size}"),
-                        ),
-                        direction=PortDeclarationDirection.Output,
-                    ),
-                ],
-                body=[
-                    VariableDeclarationStatement(name="unitary_port"),
-                    Allocate(
-                        size=Expression(expr=f"{num_unitary_qubits}"),
-                        target=HandleBinding(name="unitary_port"),
-                    ),
-                    Allocate(
-                        size=Expression(expr=f"{phase_port_size}"),
-                        target=HandleBinding(name="phase_port"),
-                    ),
-                    QuantumFunctionCall(
-                        function="qmci",
-                        positional_args=[
-                            QuantumLambdaFunction(
-                                pos_rename_params=["state", "ind"],
-                                body=[
-                                    QuantumFunctionCall(
-                                        function=finance_function,
-                                        positional_args=[
-                                            Expression(expr=finance_model),
-                                            Expression(expr=finance_function_object),
-                                            HandleBinding(name="state"),
-                                            HandleBinding(name="ind"),
-                                        ],
-                                    ),
-                                ],
-                            ),
-                            HandleBinding(name="phase_port"),
-                            HandleBinding(name="unitary_port"),
-                        ],
-                    ),
-                ],
-            ),
-        ],
-        classical_execution_code=f"""
-phase_port_size = {phase_port_size}
-counts = sample()
-save({{"counts": counts}})
-probability_estimation = qae_with_qpe_result_post_processing(
-    estimation_register_size=phase_port_size,
-    estimation_method=1,
-    result=counts
-)
-save({{"probability_estimation": probability_estimation}})
-{_OUTPUT_VARIABLE_NAME} = {post_process_function}({finance_model}, {finance_function_object}, probability_estimation)
-save({{"{_OUTPUT_VARIABLE_NAME}": {_OUTPUT_VARIABLE_NAME}}})
-""".strip(),
-    )
-    return model.get_model()

classiq/applications/grover/__init__.py

@@ -1,9 +0,0 @@
-from .grover_model_constructor import construct_grover_model
-
-__all__ = [
-    "construct_grover_model",
-]
-
-
-def __dir__() -> list[str]:
-    return __all__

classiq/applications/grover/grover_model_constructor.py

@@ -1,167 +0,0 @@
-import warnings
-
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.model.allocate import Allocate
-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.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_expressions.arithmetic_operation import (
-    ArithmeticOperation,
-    ArithmeticOperationKind,
-)
-from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
-from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
-
-from classiq import RegisterUserInput
-from classiq.open_library.functions.grover import grover_search, phase_oracle
-
-_OUTPUT_VARIABLE_NAME = "result"
-
-_PREDICATE_FUNCTION_NAME = "expr_predicate"
-
-
-def _arithmetic_oracle_ios(
-    definitions: list[tuple[str, RegisterUserInput]], handle_name: str
-) -> list[HandleBinding]:
-    cursor = 0
-    ios: list[HandleBinding] = []
-    for _, reg in definitions:
-        ios.append(
-            SlicedHandleBinding(
-                base_handle=HandleBinding(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_ios(definitions, "state")
-    predicate_var_binding.append(HandleBinding(name="oracle"))
-    return QuantumFunctionCall(
-        function="phase_oracle",
-        positional_args=[
-            QuantumLambdaFunction(
-                pos_rename_params=["state", "oracle"],
-                body=[
-                    QuantumFunctionCall(
-                        function=predicate_function,
-                        positional_args=predicate_var_binding,
-                    ),
-                ],
-            ),
-            HandleBinding(name="packed_vars"),
-        ],
-    )
-
-
-def grover_main_port_declarations(
-    definitions: list[tuple[str, RegisterUserInput]],
-    direction: PortDeclarationDirection,
-) -> list[PortDeclaration]:
-    return [
-        PortDeclaration(
-            name=name,
-            quantum_type=QuantumNumeric(
-                size=Expression(expr=f"{reg.size}"),
-                is_signed=Expression(expr=f"{reg.is_signed}"),
-                fraction_digits=Expression(expr=f"{reg.fraction_places}"),
-            ),
-            direction=direction,
-        )
-        for name, reg in definitions
-    ]
-
-
-def construct_grover_model(
-    definitions: list[tuple[str, RegisterUserInput]],
-    expression: str,
-    num_reps: int = 1,
-) -> SerializedModel:
-    warnings.warn(
-        "Function 'construct_grover_model' has been deprecated and will no longer"
-        "be supported starting on 03/02/2025 the earliest\nHint: It is now possible to "
-        "implement the Grover algorithm in pure Qmod. For example, see the Grover notebook on the "
-        "Classiq library at https://github.com/Classiq/classiq-library/blob/main/algorithms/grover/3_sat_grover/3_sat_grover.ipynb",
-        category=DeprecationWarning,
-        stacklevel=2,
-    )
-    predicate_port_decls = grover_main_port_declarations(
-        definitions, PortDeclarationDirection.Inout
-    )
-    predicate_port_decls.append(
-        PortDeclaration(
-            name="res",
-            quantum_type=QuantumBitvector(length=Expression(expr="1")),
-            direction=PortDeclarationDirection.Inout,
-        )
-    )
-    num_qubits = sum(reg.size for _, reg in definitions)
-
-    grover_model = Model(
-        functions=[
-            NativeFunctionDefinition(
-                name=_PREDICATE_FUNCTION_NAME,
-                positional_arg_declarations=predicate_port_decls,
-                body=[
-                    ArithmeticOperation(
-                        expression=Expression(expr=expression),
-                        result_var=HandleBinding(name="res"),
-                        operation_kind=ArithmeticOperationKind.InplaceXor,
-                    ),
-                ],
-            ),
-            NativeFunctionDefinition(
-                name="main",
-                positional_arg_declarations=grover_main_port_declarations(
-                    definitions, PortDeclarationDirection.Output
-                ),
-                body=[
-                    VariableDeclarationStatement(name="packed_vars"),
-                    Allocate(
-                        size=Expression(expr=f"{num_qubits}"),
-                        target=HandleBinding(name="packed_vars"),
-                    ),
-                    QuantumFunctionCall(
-                        function="grover_search",
-                        positional_args=[
-                            Expression(expr=f"{num_reps}"),
-                            QuantumLambdaFunction(
-                                pos_rename_params=["packed_vars"],
-                                body=[
-                                    _construct_arithmetic_oracle(
-                                        _PREDICATE_FUNCTION_NAME,
-                                        definitions,
-                                    )
-                                ],
-                            ),
-                            HandleBinding(name="packed_vars"),
-                        ],
-                    ),
-                    BindOperation(
-                        in_handles=[HandleBinding(name="packed_vars")],
-                        out_handles=[
-                            HandleBinding(name=name) for name, _ in definitions
-                        ],
-                    ),
-                ],
-            ),
-            *[f for f in grover_search.create_model().functions if f.name != "main"],
-            *[f for f in phase_oracle.create_model().functions if f.name != "main"],
-        ],
-    )
-    return grover_model.get_model()

classiq/applications/libraries/qmci_library.py

@@ -1,22 +0,0 @@
-from classiq.open_library.functions.amplitude_estimation import amplitude_estimation
-from classiq.qmod.builtins.functions import Z
-from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_variable import QArray, QBit, QNum
-from classiq.qmod.quantum_callable import QCallable
-
-
-@qfunc
-def qmci(
-    space_transform: QCallable[QArray[QBit], QBit],
-    phase: QNum,
-    packed_vars: QArray[QBit],
-) -> None:
-    amplitude_estimation(
-        lambda reg: Z(reg[reg.len - 1]),
-        lambda reg: space_transform(reg[0 : reg.len - 1], reg[reg.len - 1]),
-        phase,
-        packed_vars,
-    )
-
-
-QMCI_LIBRARY = [func for func in qmci.create_model().functions if func.name != "main"]

classiq/applications/qsvm/qsvm_model_constructor.py

@@ -1,131 +0,0 @@
-import warnings
-from typing import Any
-
-from classiq.interface.applications.qsvm import DataList, LabelsInt
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.model.allocate import Allocate
-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.interface.model.quantum_statement import QuantumStatement
-
-from classiq.qmod.builtins.enums import Pauli, QSVMFeatureMapEntanglement
-from classiq.qmod.utilities import qmod_val_to_expr_str
-
-INVALID_FEATURE_MAP_FUNC_NAME_MSG = "Invalid feature_map_function_name, it can be bloch_sphere_feature_map or pauli_feature_map"
-
-_OUTPUT_VARIABLE_NAME = "qsvm_results"
-
-
-def _bloch_sphere_feature_map_function_params(
-    bloch_feature_dimension: int,
-) -> tuple[list[Expression], str]:
-    return [
-        Expression(expr=f"{bloch_feature_dimension}")
-    ], f"ceiling({bloch_feature_dimension}/2)"
-
-
-def _pauli_feature_map_function_params(
-    paulis: list[list[Pauli]],
-    entanglement: QSVMFeatureMapEntanglement,
-    alpha: int,
-    reps: int,
-    feature_dimension: int,
-) -> tuple[list[Expression], str]:
-    paulis_str = (
-        "["
-        + ",".join(
-            [
-                "[" + ",".join([qmod_val_to_expr_str(p) for p in p_list]) + "]"
-                for p_list in paulis
-            ]
-        )
-        + "]"
-    )
-    pauli_feature_map_params = (
-        f"paulis={paulis_str}, "
-        f"entanglement={qmod_val_to_expr_str(entanglement)}, "
-        f"alpha={alpha}, "
-        f"reps={reps}, "
-        f"feature_dimension={feature_dimension}"
-    )
-    return [
-        Expression(
-            expr=f"struct_literal(QSVMFeatureMapPauli, {pauli_feature_map_params})"
-        )
-    ], f"{feature_dimension}"
-
-
-def get_qsvm_qmain_body(
-    feature_map_function_name: str, **kwargs: Any
-) -> list[QuantumStatement]:
-    if feature_map_function_name == "bloch_sphere_feature_map":
-        params, size_expr = _bloch_sphere_feature_map_function_params(**kwargs)
-    elif feature_map_function_name == "pauli_feature_map":
-        params, size_expr = _pauli_feature_map_function_params(**kwargs)
-    else:
-        raise ClassiqValueError(INVALID_FEATURE_MAP_FUNC_NAME_MSG)
-
-    return [
-        Allocate(
-            size=Expression(expr=size_expr),
-            target=HandleBinding(name="qbv"),
-        ),
-        QuantumFunctionCall(
-            function=feature_map_function_name,
-            positional_args=[*params, HandleBinding(name="qbv")],
-        ),
-    ]
-
-
-def construct_qsvm_model(
-    train_data: DataList,
-    train_labels: LabelsInt,
-    test_data: DataList,
-    test_labels: LabelsInt,
-    predict_data: DataList,
-    feature_map_function_name: str,
-    **kwargs: Any,
-) -> SerializedModel:
-    warnings.warn(
-        "Function 'construct_qsvm_model' has been deprecated and will no longer"
-        "be supported starting on 03/02/2025 the earliest\nHint: It is now possible to "
-        "implement QSVM in pure Qmod. For example, see the QSVM notebook on the "
-        "Classiq library at https://github.com/Classiq/classiq-library/blob/main/algorithms/qml/qsvm/qsvm.ipynb",
-        category=DeprecationWarning,
-        stacklevel=2,
-    )
-    qsvm_qmod = Model(
-        functions=[
-            NativeFunctionDefinition(
-                name="main",
-                positional_arg_declarations=[
-                    PortDeclaration(
-                        name="qbv",
-                        direction=PortDeclarationDirection.Output,
-                    ),
-                ],
-                body=get_qsvm_qmain_body(
-                    feature_map_function_name=feature_map_function_name, **kwargs
-                ),
-            ),
-        ],
-        classical_execution_code=f"""
-{_OUTPUT_VARIABLE_NAME} = qsvm_full_run(
-    train_data={train_data},
-    train_labels={train_labels},
-    test_data={test_data},
-    test_labels={test_labels},
-    predict_data={predict_data}
-)
-save({{{_OUTPUT_VARIABLE_NAME!r}: {_OUTPUT_VARIABLE_NAME}}})
-""".strip(),
-    )
-
-    return qsvm_qmod.get_model()

classiq/model_expansions/quantum_operations/classicalif.py

@@ -1,57 +0,0 @@
-from collections.abc import Sequence
-
-from classiq.interface.debug_info.debug_info import new_function_debug_info_by_node
-from classiq.interface.model.classical_if import ClassicalIf
-from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_statement import QuantumStatement
-
-from classiq.model_expansions.closure import FunctionClosure
-from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
-from classiq.model_expansions.scope import Scope
-
-
-def _is_all_identity_calls(body: Sequence[QuantumStatement]) -> bool:
-    return all(
-        isinstance(stmt, QuantumFunctionCall) and stmt.func_name.lower() == "identity"
-        for stmt in body
-    )
-
-
-class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
-    def emit(self, classical_if: ClassicalIf, /) -> bool:
-        condition = self._interpreter.evaluate(classical_if.condition).as_type(bool)
-        op_name = "then" if condition else "else"
-        is_generative = classical_if.is_generative()
-
-        body: Sequence[QuantumStatement]
-        if is_generative:
-            if not classical_if.has_generative_block(op_name):
-                return True
-            context = self._expand_generative_context(classical_if, op_name, op_name)
-            context.blocks["body"] = context.blocks[op_name]
-            context.blocks.pop(op_name)
-            body = context.statements("body")
-        else:
-            body = classical_if.then if condition else classical_if.else_
-
-        if _is_all_identity_calls(body):
-            return True
-
-        if is_generative or not self._should_wrap(body):
-            for stmt in body:
-                if is_generative:
-                    self._interpreter._builder.emit_statement(stmt)
-                else:
-                    self._interpreter.emit_statement(stmt)
-            return True
-
-        then_else_func = FunctionClosure.create(
-            name=self._counted_name_allocator.allocate("then" if condition else "else"),
-            body=body,
-            scope=Scope(parent=self._current_scope),
-            lambda_external_vars=self._builder.current_block.captured_vars,
-        )
-        self._emit_quantum_function_call(
-            then_else_func, list(), new_function_debug_info_by_node(classical_if)
-        )
-        return True

classiq/model_expansions/quantum_operations/repeat.py

@@ -1,62 +0,0 @@
-from classiq.interface.debug_info.debug_info import new_function_debug_info_by_node
-from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.builtins.internal_operators import (
-    REPEAT_OPERATOR_NAME,
-)
-from classiq.interface.generator.functions.classical_type import Integer
-from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
-)
-from classiq.interface.model.repeat import Repeat
-
-from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
-from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
-from classiq.model_expansions.scope import Scope
-from classiq.qmod.quantum_function import GenerativeQFunc
-
-
-class RepeatEmitter(CallEmitter[Repeat]):
-    def emit(self, repeat: Repeat, /) -> bool:
-        count = self._interpreter.evaluate(repeat.count).as_type(int)
-        if count < 0:
-            raise ClassiqExpansionError(
-                f"repeat count must be non-negative, got {count}"
-            )
-        op_name = self._counted_name_allocator.allocate(REPEAT_OPERATOR_NAME)
-        for i in range(count):
-            self._emit_iteration(repeat, i, op_name)
-        return True
-
-    def _emit_iteration(self, repeat: Repeat, i: int, op_name: str) -> None:
-        closure_constructor: type[FunctionClosure]
-        extra_args: dict
-        if repeat.is_generative():
-            closure_constructor = GenerativeFunctionClosure
-            extra_args = {
-                "generative_blocks": {
-                    "body": GenerativeQFunc(
-                        repeat.get_generative_block("body"),
-                    ),
-                }
-            }
-        else:
-            closure_constructor = FunctionClosure
-            extra_args = {}
-        iteration_function = closure_constructor.create(
-            name=op_name,
-            positional_arg_declarations=[
-                ClassicalParameterDeclaration(
-                    name=repeat.iter_var, classical_type=Integer()
-                )
-            ],
-            body=repeat.body,
-            scope=Scope(parent=self._current_scope),
-            lambda_external_vars=self._builder.current_block.captured_vars,
-            **extra_args,
-        )
-        self._emit_quantum_function_call(
-            iteration_function,
-            [Expression(expr=str(i))],
-            new_function_debug_info_by_node(repeat),
-        )