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

classiq/qmod/builtins/functions.py

@@ -10,6 +10,143 @@ from classiq.qmod.quantum_callable import QCallable, QCallableList
 from .structs import *
 
 
+@qfunc(external=True)
+def permute(
+    functions: QCallableList,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def apply(
+    operand: QCallable,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def molecule_ucc(
+    molecule_problem: QParam[MoleculeProblem],
+    excitations: QParam[List[int]],
+    qbv: QArray[
+        QBit,
+        Literal[
+            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
+        ],
+    ],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def molecule_hva(
+    molecule_problem: QParam[MoleculeProblem],
+    reps: QParam[int],
+    qbv: QArray[
+        QBit,
+        Literal[
+            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
+        ],
+    ],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def molecule_hartree_fock(
+    molecule_problem: QParam[MoleculeProblem],
+    qbv: QArray[
+        QBit,
+        Literal[
+            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
+        ],
+    ],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def fock_hamiltonian_ucc(
+    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
+    excitations: QParam[List[int]],
+    qbv: QArray[
+        QBit,
+        Literal[
+            "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
+        ],
+    ],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def fock_hamiltonian_hva(
+    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
+    reps: QParam[int],
+    qbv: QArray[
+        QBit,
+        Literal[
+            "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
+        ],
+    ],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def fock_hamiltonian_hartree_fock(
+    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
+    qbv: QArray[
+        QBit,
+        Literal[
+            "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
+        ],
+    ],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def log_normal_finance(
+    finance_model: QParam[LogNormalModel],
+    finance_function: QParam[FinanceFunction],
+    func_port: QArray[QBit, Literal["get_field(finance_model, 'num_qubits')"]],
+    obj_port: QBit,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def gaussian_finance(
+    finance_model: QParam[GaussianModel],
+    finance_function: QParam[FinanceFunction],
+    func_port: QArray[
+        QBit,
+        Literal[
+            "get_field(finance_model, 'num_qubits') + len(get_field(finance_model, 'rhos')) + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1"
+        ],
+    ],
+    obj_port: QBit,
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def pauli_feature_map(
+    feature_map: QParam[QSVMFeatureMapPauli],
+    qbv: QArray[QBit, Literal["get_field(feature_map, 'feature_dimension')"]],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def bloch_sphere_feature_map(
+    feature_dimension: QParam[int],
+    qbv: QArray[QBit, Literal["ceiling(feature_dimension/2)"]],
+) -> None:
+    pass
+
+
 @qfunc(external=True)
 def H(
     target: QBit,
@@ -402,15 +539,6 @@ def qpe(
     pass
 
 
-@qfunc(external=True)
-def standard_qpe(
-    precision: QParam[int],
-    unitary: QCallable,
-    phase: QArray[QBit, Literal["precision"]],
-) -> None:
-    pass
-
-
 @qfunc(external=True)
 def single_pauli(
     slope: QParam[float],
@@ -435,12 +563,10 @@ def linear_pauli_rotations(
 
 @qfunc(external=True)
 def amplitude_estimation(
-    num_phase_qubits: QParam[int],
-    num_unitary_qubits: QParam[int],
-    sp_op: QCallable[QParam[int], QArray[QBit, Literal["num_unitary_qubits"]]],
-    oracle_op: QCallable[QParam[int], QArray[QBit, Literal["num_unitary_qubits"]]],
-    phase_port: Output[QNum],
-    unitary_port: Output[QArray[QBit, Literal["num_unitary_qubits"]]],
+    oracle: QCallable[QArray[QBit]],
+    space_transform: QCallable[QArray[QBit]],
+    phase: QNum,
+    packed_vars: QArray[QBit],
 ) -> None:
     pass
 
@@ -626,198 +752,19 @@ def switch(
     pass
 
 
-@qfunc(external=True)
-def repeat(
-    count: QParam[int],
-    iteration: QCallable[QParam[int]],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def invert(
-    operand: QCallable,
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def control(
-    operand: QCallable,
-    ctrl: QArray[QBit],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def if_(
-    condition: QParam[bool],
-    then: QCallable,
-    else_: QCallable,
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def permute(
-    functions: QCallableList,
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def power(
-    power: QParam[int],
-    operand: QCallable,
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def apply(
-    operand: QCallable,
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def compute(
-    operand: QCallable,
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def uncompute(
-    operand: QCallable,
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def molecule_ucc(
-    molecule_problem: QParam[MoleculeProblem],
-    excitations: QParam[List[int]],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
-        ],
-    ],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def molecule_hva(
-    molecule_problem: QParam[MoleculeProblem],
-    reps: QParam[int],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
-        ],
-    ],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def molecule_hartree_fock(
-    molecule_problem: QParam[MoleculeProblem],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
-        ],
-    ],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def fock_hamiltonian_ucc(
-    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
-    excitations: QParam[List[int]],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
-        ],
-    ],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def fock_hamiltonian_hva(
-    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
-    reps: QParam[int],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
-        ],
-    ],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def fock_hamiltonian_hartree_fock(
-    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
-        ],
-    ],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def log_normal_finance(
-    finance_model: QParam[LogNormalModel],
-    finance_function: QParam[FinanceFunction],
-    func_port: QArray[QBit, Literal["get_field(finance_model, 'num_qubits')"]],
-    obj_port: QBit,
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def gaussian_finance(
-    finance_model: QParam[GaussianModel],
-    finance_function: QParam[FinanceFunction],
-    func_port: QArray[
-        QBit,
-        Literal[
-            "get_field(finance_model, 'num_qubits') + len(get_field(finance_model, 'rhos')) + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1"
-        ],
-    ],
-    obj_port: QBit,
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def pauli_feature_map(
-    feature_map: QParam[QSVMFeatureMapPauli],
-    qbv: QArray[QBit, Literal["get_field(feature_map, 'feature_dimension')"]],
-) -> None:
-    pass
-
-
-@qfunc(external=True)
-def bloch_sphere_feature_map(
-    feature_dimension: QParam[int],
-    qbv: QArray[QBit, Literal["ceiling(feature_dimension/2)"]],
-) -> None:
-    pass
-
-
 __all__ = [
+    "permute",
+    "apply",
+    "molecule_ucc",
+    "molecule_hva",
+    "molecule_hartree_fock",
+    "fock_hamiltonian_ucc",
+    "fock_hamiltonian_hva",
+    "fock_hamiltonian_hartree_fock",
+    "log_normal_finance",
+    "gaussian_finance",
+    "pauli_feature_map",
+    "bloch_sphere_feature_map",
     "H",
     "X",
     "Y",
@@ -866,7 +813,6 @@ __all__ = [
     "qft",
     "qpe_flexible",
     "qpe",
-    "standard_qpe",
     "single_pauli",
     "linear_pauli_rotations",
     "amplitude_estimation",
@@ -891,23 +837,4 @@ __all__ = [
     "inplace_prepare_int",
     "prepare_int",
     "switch",
-    "repeat",
-    "invert",
-    "control",
-    "if_",
-    "permute",
-    "power",
-    "apply",
-    "compute",
-    "uncompute",
-    "molecule_ucc",
-    "molecule_hva",
-    "molecule_hartree_fock",
-    "fock_hamiltonian_ucc",
-    "fock_hamiltonian_hva",
-    "fock_hamiltonian_hartree_fock",
-    "log_normal_finance",
-    "gaussian_finance",
-    "pauli_feature_map",
-    "bloch_sphere_feature_map",
 ]

classiq/qmod/builtins/operations.py

@@ -1,23 +1,38 @@
-from typing import Callable, List, Union
+import inspect
+from types import FrameType
+from typing import Any, Callable, Final, List, Mapping, Union
 
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    REPEAT_OPERATOR,
+)
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.classical_if import ClassicalIf
+from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import (
     BinaryOperation,
     InplaceBinaryOperation,
 )
-from classiq.interface.model.quantum_function_call import ArgValue
+from classiq.interface.model.invert import Invert
+from classiq.interface.model.power import Power
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     QuantumOperandDeclaration,
 )
-from classiq.interface.model.quantum_if_operation import QuantumIfOperation
-from classiq.interface.model.within_apply_operation import WithinApplyOperation
-
-from classiq.qmod.qmod_variable import Input, Output, QNum, QVar
+from classiq.interface.model.quantum_if_operation import QuantumIf
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.repeat import Repeat
+from classiq.interface.model.statement_block import StatementBlock
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.exceptions import ClassiqValueError
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
 from classiq.qmod.symbolic_expr import SymbolicExpr
 
+_MISSING_VALUE: Final[int] = -1
+
 
 def bind(
     source: Union[Input[QVar], List[Input[QVar]]],
@@ -36,14 +51,46 @@ def bind(
     )
 
 
+def control(
+    operand: Union[QCallable, Callable[[], None]], ctrl: Union[QBit, QArray[QBit]]
+) -> None:
+    _validate_operand(operand)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        Control(
+            control=ctrl.get_handle_binding(),
+            body=_operand_to_body(operand),
+        )
+    )
+
+
+def if_(
+    condition: SymbolicExpr,
+    then: Union[QCallable, Callable[[], None]],
+    else_: Union[QCallable, Callable[[], None], int] = _MISSING_VALUE,
+) -> None:
+    _validate_operand(then)
+    if else_ != _MISSING_VALUE:
+        _validate_operand(else_)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        ClassicalIf(
+            condition=Expression(expr=str(condition)),
+            then=_operand_to_body(then),
+            else_=_operand_to_body(else_) if else_ != _MISSING_VALUE else [],  # type: ignore[arg-type]
+        )
+    )
+
+
 def quantum_if(
     condition: SymbolicExpr, then: Union[QCallable, Callable[[], None]]
 ) -> None:
+    _validate_operand(then)
     assert QCallable.CURRENT_EXPANDABLE is not None
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        QuantumIfOperation(
+        QuantumIf(
             expression=Expression(expr=str(condition)),
-            then=_to_operand(then),
+            then=_operand_to_body(then),
         )
     )
 
@@ -80,25 +127,125 @@ def within_apply(
     compute: Callable[[], None],
     action: Callable[[], None],
 ) -> None:
+    _validate_operand(compute)
+    _validate_operand(action)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        WithinApply(
+            compute=_operand_to_body(compute),
+            action=_operand_to_body(action),
+        )
+    )
+
+
+def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) -> None:
+    _validate_operand(iteration)
     assert QCallable.CURRENT_EXPANDABLE is not None
+    iteration_operand = prepare_arg(
+        REPEAT_OPERATOR.operand_declarations["iteration"], iteration
+    )
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        WithinApplyOperation(
-            compute=_to_operand(compute),
-            action=_to_operand(action),
+        Repeat(
+            iter_var=inspect.getfullargspec(iteration).args[0],
+            count=Expression(expr=str(count)),
+            body=iteration_operand.body,
         )
     )
 
 
-def _to_operand(callable_: Union[QCallable, Callable[[], None]]) -> ArgValue:
-    return prepare_arg(QuantumOperandDeclaration(name=""), callable_)
+def power(
+    power: Union[SymbolicExpr, int],
+    operand: Union[QCallable, Callable[[], None]],
+) -> None:
+    _validate_operand(operand)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        Power(power=Expression(expr=str(power)), body=_operand_to_body(operand))
+    )
+
+
+def invert(
+    operand: Union[QCallable, Callable[[], None]],
+) -> None:
+    _validate_operand(operand)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        Invert(body=_operand_to_body(operand))
+    )
+
+
+def _validate_operand(operand: Any) -> None:
+    if operand is not None:
+        return
+    currentframe: FrameType = inspect.currentframe()  # type: ignore[assignment]
+    operation_frame: FrameType = currentframe.f_back  # type: ignore[assignment]
+    operation_frame_info: inspect.Traceback = inspect.getframeinfo(operation_frame)
+    operation_name: str = operation_frame_info.function
+
+    context = operation_frame_info.code_context
+    assert context is not None
+    operand_arg_name = context[0].split("_validate_operand(")[1].split(")")[0]
+
+    error_message = (
+        f"{operation_name} is missing required argument for {operand_arg_name}"
+    )
+    error_message += _get_operand_hint(
+        operation_name=operation_name,
+        operand_arg_name=operand_arg_name,
+        params=inspect.signature(operation_frame.f_globals[operation_name]).parameters,
+    )
+    raise ClassiqValueError(error_message)
+
+
+def _get_operand_hint_args(
+    params: Mapping[str, inspect.Parameter], operand_arg_name: str, operand_value: str
+) -> str:
+    return ", ".join(
+        [
+            (
+                f"{param.name}={operand_value}"
+                if param.name == operand_arg_name
+                else f"{param.name}=..."
+            )
+            for param in params.values()
+        ]
+    )
+
+
+def _get_operand_hint(
+    operation_name: str, operand_arg_name: str, params: Mapping[str, inspect.Parameter]
+) -> str:
+    return (
+        f"\nHint: To create an operand, do not call quantum gates directly "
+        f"`{operation_name}({_get_operand_hint_args(params, operand_arg_name, 'H(q)')})`. "
+        f"Instead, use a lambda function "
+        f"`{operation_name}({_get_operand_hint_args(params, operand_arg_name, 'lambda: H(q)')})` "
+        f"or a quantum function "
+        f"`{operation_name}({_get_operand_hint_args(params, operand_arg_name, 'my_func')})`"
+    )
+
+
+def _operand_to_body(callable_: Union[QCallable, Callable[[], None]]) -> StatementBlock:
+    to_operand = prepare_arg(QuantumOperandDeclaration(name=""), callable_)
+    if isinstance(to_operand, str):
+        return [QuantumFunctionCall(function=to_operand)]
+    elif isinstance(to_operand, QuantumLambdaFunction):
+        return to_operand.body
+    else:
+        raise ValueError(f"Unexpected operand type: {type(to_operand)}")
 
 
 __all__ = [
     "bind",
+    "control",
+    "invert",
+    "if_",
     "quantum_if",
     "inplace_add",
     "inplace_xor",
+    "power",
     "within_apply",
+    "repeat",
 ]