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

classiq/qmod/builtins/operations.py

@@ -1,67 +1,96 @@
-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.core_lib_declarations.quantum_operators import (
-    OPERAND_FIELD_NAME,
+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.numeric_reinterpretation import (
-    NumericReinterpretationOperation,
-)
+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.qmod.builtins.functions import (
-    apply,
-    compute as compute_operator,
-    uncompute,
-)
-from classiq.qmod.qmod_parameter import QParam
-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: Input[QVar], destination: Output[QVar]) -> None:
+def bind(
+    source: Union[Input[QVar], List[Input[QVar]]],
+    destination: Union[Output[QVar], List[Output[QVar]]],
+) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
+    if not isinstance(source, list):
+        source = [source]
+    if not isinstance(destination, list):
+        destination = [destination]
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         BindOperation(
-            in_handle=source.get_handle_binding(),
-            out_handle=destination.get_handle_binding(),
+            in_handles=[src_var.get_handle_binding() for src_var in source],
+            out_handles=[dst_var.get_handle_binding() for dst_var in destination],
         )
     )
 
 
-def quantum_if(
-    condition: SymbolicExpr, then: Union[QCallable, Callable[[], None]]
+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(
-        QuantumIfOperation(
-            expression=Expression(expr=str(condition)),
-            then=prepare_arg(QuantumOperandDeclaration(name=OPERAND_FIELD_NAME), then),
+        Control(
+            control=ctrl.get_handle_binding(),
+            body=_operand_to_body(operand),
         )
     )
 
 
-def reinterpret_num(
-    is_signed: Union[QParam[bool], bool],
-    fraction_digits: Union[QParam[int], int],
-    target: QNum,
+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(
-        NumericReinterpretationOperation(
-            target=target.get_handle_binding(),
-            is_signed=Expression(expr=str(is_signed)),
-            fraction_digits=Expression(expr=str(fraction_digits)),
+        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(
+        QuantumIf(
+            expression=Expression(expr=str(condition)),
+            then=_operand_to_body(then),
         )
     )
 
@@ -98,18 +127,125 @@ def within_apply(
     compute: Callable[[], None],
     action: Callable[[], None],
 ) -> None:
-    compute_operator(compute)
-    apply(action)
-    uncompute(compute)
+    _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(
+        Repeat(
+            iter_var=inspect.getfullargspec(iteration).args[0],
+            count=Expression(expr=str(count)),
+            body=iteration_operand.body,
+        )
+    )
+
+
+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",
-    "reinterpret_num",
     "inplace_add",
     "inplace_xor",
+    "power",
     "within_apply",
+    "repeat",
 ]
 
 

classiq/qmod/builtins/structs.py

@@ -2,16 +2,16 @@
 
 from typing import List
 
-from classiq.qmod.qmod_struct import QStruct
+from classiq.qmod.qmod_struct import struct
 
 
-@QStruct
+@struct
 class PauliTerm:
     pauli: List[int]
     coefficient: float
 
 
-@QStruct
+@struct
 class MoleculeProblem:
     mapping: int
     z2_symmetries: bool
@@ -20,27 +20,27 @@ class MoleculeProblem:
     remove_orbitals: List[int]
 
 
-@QStruct
+@struct
 class Molecule:
     atoms: List["ChemistryAtom"]
     spin: int
     charge: int
 
 
-@QStruct
+@struct
 class ChemistryAtom:
     element: int
     position: "Position"
 
 
-@QStruct
+@struct
 class Position:
     x: float
     y: float
     z: float
 
 
-@QStruct
+@struct
 class FockHamiltonianProblem:
     mapping: int
     z2_symmetries: bool
@@ -48,19 +48,19 @@ class FockHamiltonianProblem:
     num_particles: List[int]
 
 
-@QStruct
+@struct
 class LadderTerm:
     coefficient: float
     ops: List["LadderOp"]
 
 
-@QStruct
+@struct
 class LadderOp:
     op: int
     index: int
 
 
-@QStruct
+@struct
 class CombinatorialOptimizationSolution:
     probability: float
     cost: float
@@ -68,7 +68,7 @@ class CombinatorialOptimizationSolution:
     count: int
 
 
-@QStruct
+@struct
 class GaussianModel:
     num_qubits: int
     normal_max_value: float
@@ -78,14 +78,14 @@ class GaussianModel:
     min_loss: int
 
 
-@QStruct
+@struct
 class LogNormalModel:
     num_qubits: int
     mu: float
     sigma: float
 
 
-@QStruct
+@struct
 class FinanceFunction:
     f: int
     threshold: float
@@ -95,13 +95,13 @@ class FinanceFunction:
     tail_probability: float
 
 
-@QStruct
+@struct
 class QsvmResult:
     test_score: float
     predicted_labels: List[float]
 
 
-@QStruct
+@struct
 class QSVMFeatureMapPauli:
     feature_dimension: int
     reps: int

classiq/qmod/cfunc.py

@@ -0,0 +1,42 @@
+from typing import Any, Callable, Dict, Optional, Union, overload
+
+from classiq.qmod.classical_function import CFunc
+
+
+def get_caller_locals() -> Dict[str, Any]:
+    """Print the local variables in the caller's frame."""
+    import inspect
+
+    frame = inspect.currentframe()
+    try:
+        assert frame is not None
+        cfunc_frame = frame.f_back
+        assert cfunc_frame is not None
+        caller_frame = cfunc_frame.f_back
+        assert caller_frame is not None
+
+        return caller_frame.f_locals
+    finally:
+        # See here for information about the `del`
+        # https://docs.python.org/3/library/inspect.html#the-interpreter-stack
+        del frame
+
+
+@overload
+def cfunc(func: Callable) -> CFunc: ...
+
+
+@overload
+def cfunc(func: None = None) -> Callable[[Callable], CFunc]: ...
+
+
+def cfunc(func: Optional[Callable] = None) -> Union[Callable[[Callable], CFunc], CFunc]:
+    caller_locals = get_caller_locals()
+
+    def wrapper(func: Callable) -> CFunc:
+        return CFunc(func, caller_locals)
+
+    if func is not None:
+        return wrapper(func)
+
+    return wrapper

classiq/qmod/classical_function.py

@@ -2,10 +2,9 @@ import ast
 import inspect
 import sys
 from textwrap import dedent
-from typing import Callable
+from typing import Any, Callable, Dict
 
 from classiq.exceptions import ClassiqValueError
-from classiq.qmod.builtins.classical_execution_primitives import sample, save
 
 
 def _unparse_function_body(code: str, func: ast.FunctionDef) -> str:
@@ -18,23 +17,16 @@ def _unparse_function_body(code: str, func: ast.FunctionDef) -> str:
 
 
 class CFunc:
-    @staticmethod
-    def default_cmain() -> "CFunc":
-        @CFunc
-        def cmain() -> None:
-            result = sample()
-            save({"result": result})
-
-        return cmain
-
-    def __init__(self, py_callable: Callable[[], None]):
+    def __init__(self, py_callable: Callable[[], None], caller_locals: Dict[str, Any]):
         code = dedent(inspect.getsource(py_callable))
         func = ast.parse(code).body[0]
         if not isinstance(func, ast.FunctionDef):
-            raise ClassiqValueError(f"Use @{CFunc.__name__} to decorate a function")
+            raise ClassiqValueError("Use @cfunc to decorate a function")
         if len(func.args.args) > 0:
-            raise ClassiqValueError(f"A @{CFunc.__name__} must receive no arguments")
+            raise ClassiqValueError("A @cfunc must receive no arguments")
         if sys.version_info >= (3, 9):
             self.code = "\n".join([ast.unparse(statement) for statement in func.body])
         else:
             self.code = _unparse_function_body(code, func)
+
+        self._caller_constants = caller_locals

classiq/qmod/declaration_inferrer.py

@@ -1,6 +1,5 @@
 import dataclasses
 import inspect
-import sys
 from typing import Any, Callable, Dict, List, Optional, Type, get_args, get_origin
 
 from typing_extensions import _AnnotatedAlias
@@ -26,25 +25,17 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 
 from classiq import StructDeclaration
+from classiq.exceptions import ClassiqValueError
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.qmod_parameter import Array, QParam
 from classiq.qmod.qmod_variable import QVar, get_type_hint_expr
 from classiq.qmod.quantum_callable import QCallable, QCallableList
-from classiq.qmod.utilities import unmangle_keyword
+from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
 
 OPERAND_ARG_NAME = "arg{i}"
 
 
-def _version_portable_get_args(py_type: type) -> tuple:
-    if get_origin(py_type) is None:
-        return tuple()
-    if sys.version_info[0:2] < (3, 10):
-        return get_args(py_type)  # The result of __class_getitem__
-    else:
-        return get_args(py_type)[0]
-
-
-def _python_type_to_qmod(
+def python_type_to_qmod(
     py_type: type, *, qmodule: ModelStateContainer
 ) -> Optional[ConcreteClassicalType]:
     if py_type == int:
@@ -55,16 +46,16 @@ def _python_type_to_qmod(
         return Bool()
     elif get_origin(py_type) == list:
         return ClassicalList(
-            element_type=_python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
+            element_type=python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
         )
     elif get_origin(py_type) == Array:
-        array_args = _version_portable_get_args(py_type)
+        array_args = version_portable_get_args(py_type)
         if len(array_args) != 2:
-            raise ValueError(
+            raise ClassiqValueError(
                 "Array accepts two generic parameters in the form 'Array[<element-type>, <size>]'"
             )
         return ClassicalArray(
-            element_type=_python_type_to_qmod(array_args[0], qmodule=qmodule),
+            element_type=python_type_to_qmod(array_args[0], qmodule=qmodule),
             size=get_type_hint_expr(array_args[1]),
         )
     elif inspect.isclass(py_type) and issubclass(py_type, QStructBase):
@@ -78,14 +69,14 @@ def _add_qmod_struct(
 ) -> None:
     if (
         py_type.__name__ in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS
-        or py_type.__name__ in qmodule.type_decls.keys()
+        or py_type.__name__ in qmodule.type_decls
     ):
         return
 
     qmodule.type_decls[py_type.__name__] = StructDeclaration(
         name=py_type.__name__,
         variables={
-            f.name: _python_type_to_qmod(f.type, qmodule=qmodule)
+            f.name: python_type_to_qmod(f.type, qmodule=qmodule)
             for f in dataclasses.fields(py_type)
         },
     )
@@ -95,10 +86,10 @@ def _extract_param_decl(
     name: str, py_type: Any, *, qmodule: ModelStateContainer
 ) -> ClassicalParameterDeclaration:
     if len(get_args(py_type)) != 1:
-        raise ValueError("QParam takes exactly one generic argument")
+        raise ClassiqValueError("QParam takes exactly one generic argument")
     py_type = get_args(py_type)[0]
     return ClassicalParameterDeclaration(
-        name=name, classical_type=_python_type_to_qmod(py_type, qmodule=qmodule)
+        name=name, classical_type=python_type_to_qmod(py_type, qmodule=qmodule)
     )
 
 
@@ -118,7 +109,7 @@ def _extract_port_decl(name: str, py_type: Any) -> PortDeclaration:
 def _extract_operand_decl(
     name: str, py_type: Any, qmodule: ModelStateContainer
 ) -> QuantumOperandDeclaration:
-    qc_args = _version_portable_get_args(py_type)
+    qc_args = version_portable_get_args(py_type)
     arg_dict = {
         OPERAND_ARG_NAME.format(i=i): arg_type for i, arg_type in enumerate(qc_args)
     }

classiq/qmod/expression_query.py

@@ -0,0 +1,23 @@
+from typing import TYPE_CHECKING, List, Tuple
+
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
+from classiq.interface.generator.arith.number_utils import MAXIMAL_MACHINE_PRECISION
+from classiq.interface.model.quantum_type import QuantumNumeric
+
+from classiq.qmod.qmod_variable import QNum
+from classiq.qmod.symbolic_type import SymbolicTypes
+
+
+def get_expression_numeric_attributes(
+    vars: List[QNum],
+    expr: SymbolicTypes,
+    machine_precision: int = MAXIMAL_MACHINE_PRECISION,
+) -> Tuple[int, bool, int]:
+    res_type = compute_arithmetic_result_type(
+        expr_str=str(expr),
+        var_types={var._name: var.get_qmod_type() for var in vars},
+        machine_precision=machine_precision,
+    )
+    if TYPE_CHECKING:
+        assert isinstance(res_type, QuantumNumeric)
+    return res_type.size_in_bits, res_type.sign_value, res_type.fraction_digits_value

classiq/qmod/model_state_container.py

@@ -1,5 +1,6 @@
 from typing import Dict
 
+from classiq.interface.generator.constant import Constant
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 
 from classiq import StructDeclaration
@@ -8,6 +9,7 @@ from classiq import StructDeclaration
 class ModelStateContainer:
     type_decls: Dict[str, StructDeclaration]
     native_defs: Dict[str, NativeFunctionDefinition]
+    constants: Dict[str, Constant]
 
 
 QMODULE = ModelStateContainer()