classiq 0.71.0__py3-none-any.whl → 0.72.1__py3-none-any.whl

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