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

classiq/qmod/builtins/operations.py

@@ -1,22 +1,39 @@
-from typing import Callable, List, Union
+import inspect
+import sys
+import warnings
+from types import FrameType
+from typing import Any, Callable, Final, List, Mapping, Union, overload
 
 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.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.qmod.qmod_variable import Input, Output, QNum, QVar
+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
+from classiq.qmod.utilities import get_source_ref
+
+_MISSING_VALUE: Final[int] = -1
 
 
 def bind(
@@ -24,6 +41,7 @@ def bind(
     destination: Union[Output[QVar], List[Output[QVar]]],
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     if not isinstance(source, list):
         source = [source]
     if not isinstance(destination, list):
@@ -32,32 +50,104 @@ def bind(
         BindOperation(
             in_handles=[src_var.get_handle_binding() for src_var in source],
             out_handles=[dst_var.get_handle_binding() for dst_var in destination],
+            source_ref=source_ref,
         )
     )
 
 
-def quantum_if(
-    condition: SymbolicExpr, then: Union[QCallable, Callable[[], None]]
+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
+    source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        QuantumIfOperation(
-            expression=Expression(expr=str(condition)),
-            then=_to_operand(then),
+        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]
+            source_ref=source_ref,
         )
     )
 
 
+@overload
+def control(
+    ctrl: Union[QBit, QArray[QBit]], operand: Union[QCallable, Callable[[], None]]
+) -> None:
+    pass
+
+
+@overload
+def control(ctrl: SymbolicExpr, operand: Union[QCallable, Callable[[], None]]) -> None:
+    pass
+
+
+def control(
+    ctrl: Union[SymbolicExpr, QBit, QArray[QBit]],
+    operand: Union[QCallable, Callable[[], None]],
+) -> None:
+    if isinstance(operand, (SymbolicExpr, QVar)) and isinstance(
+        control, (QCallable, Callable)
+    ):  # type:ignore[unreachable]
+        warnings.warn(  # type:ignore[unreachable]
+            "The `control` syntax has changed. Switch the `ctrl` and "
+            "`operand` arguments. The old syntax will not be supported in the future.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        ctrl, operand = operand, ctrl
+    if isinstance(ctrl, QNum):
+        warnings.warn(
+            "The `control` semantics has changed. Applying `control` to "
+            "a `QNum` without comparing it to an integer will not be supported in the "
+            "future.\nTips:\n    1. Use a `bind` statement to cast `ctrl` into a "
+            "QArray.\n    2.`control(n, ...)` is equivalent to "
+            "`ctrl(n == 2 ** n.size - 1, ...)` if n>=0 or to `ctrl(n == -1, ...)` if "
+            "n<0.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+    _validate_operand(operand)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        Control(
+            expression=Expression(expr=str(ctrl)),
+            body=_operand_to_body(operand),
+            source_ref=source_ref,
+        )
+    )
+
+
+def quantum_if(
+    ctrl: SymbolicExpr, operand: Union[QCallable, Callable[[], None]]
+) -> None:
+    warnings.warn(
+        "`quantum_if` is no longer supported, use `control` instead (with the "
+        "same arguments). `quantum_if` will be removed in a future release.",
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
+    control(ctrl, operand)
+
+
 def inplace_add(
     value: QNum,
     target: QNum,
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         InplaceBinaryOperation(
             target=target.get_handle_binding(),
             value=value.get_handle_binding(),
             operation=BinaryOperation.Addition,
+            source_ref=source_ref,
         )
     )
 
@@ -67,11 +157,13 @@ def inplace_xor(
     target: QNum,
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         InplaceBinaryOperation(
             target=target.get_handle_binding(),
             value=value.get_handle_binding(),
             operation=BinaryOperation.Xor,
+            source_ref=source_ref,
         )
     )
 
@@ -80,25 +172,134 @@ def within_apply(
     compute: Callable[[], None],
     action: Callable[[], None],
 ) -> None:
+    _validate_operand(compute)
+    _validate_operand(action)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        WithinApply(
+            compute=_operand_to_body(compute),
+            action=_operand_to_body(action),
+            source_ref=source_ref,
+        )
+    )
+
+
+def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) -> None:
+    _validate_operand(iteration)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    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,
+            source_ref=source_ref,
+        )
+    )
+
+
+def power(
+    power: Union[SymbolicExpr, int],
+    operand: Union[QCallable, Callable[[], None]],
+) -> None:
+    _validate_operand(operand)
     assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        WithinApplyOperation(
-            compute=_to_operand(compute),
-            action=_to_operand(action),
+        Power(
+            power=Expression(expr=str(power)),
+            body=_operand_to_body(operand),
+            source_ref=source_ref,
         )
     )
 
 
-def _to_operand(callable_: Union[QCallable, Callable[[], None]]) -> ArgValue:
-    return prepare_arg(QuantumOperandDeclaration(name=""), callable_)
+def invert(
+    operand: Union[QCallable, Callable[[], None]],
+) -> None:
+    _validate_operand(operand)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        Invert(body=_operand_to_body(operand), source_ref=source_ref)
+    )
+
+
+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",
-    "quantum_if",
+    "control",
+    "invert",
+    "if_",
     "inplace_add",
     "inplace_xor",
+    "power",
     "within_apply",
+    "repeat",
 ]
 
 

classiq/qmod/builtins/structs.py

@@ -1,113 +1,115 @@
 # This file was generated automatically - do not edit manually
 
-from typing import List
+from classiq.interface.generator.expressions.enums.ladder_operator import LadderOperator
+from classiq.interface.generator.expressions.enums.pauli import Pauli
 
+from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.qmod_struct import struct
 
 
 @struct
 class PauliTerm:
-    pauli: List[int]
-    coefficient: float
+    pauli: CArray[Pauli]
+    coefficient: CReal
 
 
 @struct
 class MoleculeProblem:
-    mapping: int
-    z2_symmetries: bool
+    mapping: CInt
+    z2_symmetries: CBool
     molecule: "Molecule"
-    freeze_core: bool
-    remove_orbitals: List[int]
+    freeze_core: CBool
+    remove_orbitals: CArray[CInt]
 
 
 @struct
 class Molecule:
-    atoms: List["ChemistryAtom"]
-    spin: int
-    charge: int
+    atoms: CArray["ChemistryAtom"]
+    spin: CInt
+    charge: CInt
 
 
 @struct
 class ChemistryAtom:
-    element: int
+    element: CInt
     position: "Position"
 
 
 @struct
 class Position:
-    x: float
-    y: float
-    z: float
+    x: CReal
+    y: CReal
+    z: CReal
 
 
 @struct
 class FockHamiltonianProblem:
-    mapping: int
-    z2_symmetries: bool
-    terms: List["LadderTerm"]
-    num_particles: List[int]
+    mapping: CInt
+    z2_symmetries: CBool
+    terms: CArray["LadderTerm"]
+    num_particles: CArray[CInt]
 
 
 @struct
 class LadderTerm:
-    coefficient: float
-    ops: List["LadderOp"]
+    coefficient: CReal
+    ops: CArray["LadderOp"]
 
 
 @struct
 class LadderOp:
-    op: int
-    index: int
+    op: LadderOperator
+    index: CInt
 
 
 @struct
 class CombinatorialOptimizationSolution:
-    probability: float
-    cost: float
-    solution: List[int]
-    count: int
+    probability: CReal
+    cost: CReal
+    solution: CArray[CInt]
+    count: CInt
 
 
 @struct
 class GaussianModel:
-    num_qubits: int
-    normal_max_value: float
-    default_probabilities: List[float]
-    rhos: List[float]
-    loss: List[int]
-    min_loss: int
+    num_qubits: CInt
+    normal_max_value: CReal
+    default_probabilities: CArray[CReal]
+    rhos: CArray[CReal]
+    loss: CArray[CInt]
+    min_loss: CInt
 
 
 @struct
 class LogNormalModel:
-    num_qubits: int
-    mu: float
-    sigma: float
+    num_qubits: CInt
+    mu: CReal
+    sigma: CReal
 
 
 @struct
 class FinanceFunction:
-    f: int
-    threshold: float
-    larger: bool
-    polynomial_degree: int
-    use_chebyshev_polynomial_approximation: bool
-    tail_probability: float
+    f: CInt
+    threshold: CReal
+    larger: CBool
+    polynomial_degree: CInt
+    use_chebyshev_polynomial_approximation: CBool
+    tail_probability: CReal
 
 
 @struct
 class QsvmResult:
-    test_score: float
-    predicted_labels: List[float]
+    test_score: CReal
+    predicted_labels: CArray[CReal]
 
 
 @struct
 class QSVMFeatureMapPauli:
-    feature_dimension: int
-    reps: int
-    entanglement: int
-    alpha: float
-    paulis: List[List[int]]
+    feature_dimension: CInt
+    reps: CInt
+    entanglement: CInt
+    alpha: CReal
+    paulis: CArray[CArray[Pauli]]
 
 
 __all__ = [

classiq/qmod/declaration_inferrer.py

@@ -9,8 +9,8 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalList,
     ConcreteClassicalType,
+    CStructBase,
     Integer,
-    QStructBase,
     Real,
     Struct,
 )
@@ -27,7 +27,7 @@ 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_parameter import CArray, CBool, CInt, CParam, CReal, 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, version_portable_get_args
@@ -38,34 +38,39 @@ OPERAND_ARG_NAME = "arg{i}"
 def python_type_to_qmod(
     py_type: type, *, qmodule: ModelStateContainer
 ) -> Optional[ConcreteClassicalType]:
-    if py_type == int:
+    if py_type == int or py_type is CInt:
         return Integer()
-    elif py_type == float:
+    elif py_type == float or py_type is CReal:
         return Real()
-    elif py_type == bool:
+    elif py_type == bool or py_type is CBool:
         return Bool()
     elif get_origin(py_type) == list:
         return ClassicalList(
             element_type=python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
         )
-    elif get_origin(py_type) == Array:
+    elif get_origin(py_type) == CArray:
         array_args = version_portable_get_args(py_type)
-        if len(array_args) != 2:
-            raise ClassiqValueError(
-                "Array accepts two generic parameters in the form 'Array[<element-type>, <size>]'"
+        if len(array_args) == 1:
+            return ClassicalList(
+                element_type=python_type_to_qmod(array_args[0], qmodule=qmodule)
             )
-        return ClassicalArray(
-            element_type=python_type_to_qmod(array_args[0], qmodule=qmodule),
-            size=get_type_hint_expr(array_args[1]),
+        elif len(array_args) == 2:
+            return ClassicalArray(
+                element_type=python_type_to_qmod(array_args[0], qmodule=qmodule),
+                size=get_type_hint_expr(array_args[1]),
+            )
+        raise ClassiqValueError(
+            "CArray accepts one or two generic parameters in the form "
+            "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"
         )
-    elif inspect.isclass(py_type) and issubclass(py_type, QStructBase):
+    elif inspect.isclass(py_type) and issubclass(py_type, CStructBase):
         _add_qmod_struct(py_type, qmodule=qmodule)
         return Struct(name=py_type.__name__)
     return None
 
 
 def _add_qmod_struct(
-    py_type: Type[QStructBase], *, qmodule: ModelStateContainer
+    py_type: Type[CStructBase], *, qmodule: ModelStateContainer
 ) -> None:
     if (
         py_type.__name__ in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS
@@ -85,9 +90,10 @@ def _add_qmod_struct(
 def _extract_param_decl(
     name: str, py_type: Any, *, qmodule: ModelStateContainer
 ) -> ClassicalParameterDeclaration:
-    if len(get_args(py_type)) != 1:
-        raise ClassiqValueError("QParam takes exactly one generic argument")
-    py_type = get_args(py_type)[0]
+    if get_origin(py_type) is QParam:
+        if len(get_args(py_type)) != 1:
+            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)
     )
@@ -128,7 +134,13 @@ def _extract_positional_args(
         if name == "return":
             continue
         name = unmangle_keyword(name)
-        if get_origin(py_type) is QParam:
+        if (
+            inspect.isclass(py_type)
+            and issubclass(py_type, CParam)
+            or inspect.isclass(py_type)
+            and issubclass(py_type, CStructBase)
+            or get_origin(py_type) in (QParam, CArray)
+        ):
             result.append(_extract_param_decl(name, py_type, qmodule=qmodule))
         elif QVar.from_type_hint(py_type) is not None:
             result.append(_extract_port_decl(name, py_type))

classiq/qmod/native/expression_to_qmod.py

@@ -5,6 +5,8 @@ from typing import Callable, Dict, List, Mapping, Type
 
 import numpy as np
 
+from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
+
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
@@ -57,11 +59,10 @@ class ASTToQMODCode:
             return self.indent.join(self.ast_to_code(child) for child in node.body)
         elif isinstance(node, ast.Attribute):
             # Enum attribute access
-            if not isinstance(node.value, ast.Name) or not isinstance(node.attr, str):
-                raise AssertionError("Error parsing enum attribute access")
-            if not (IDENTIFIER.match(node.value.id) and IDENTIFIER.match(node.attr)):
+            if not isinstance(node.attr, str):
                 raise AssertionError("Error parsing enum attribute access")
-            return f"{node.value.id!s}::{node.attr!s}"
+            access_operator = "." if node.attr in CLASSICAL_ATTRIBUTES else "::"
+            return f"{self.ast_to_code(node.value)!s}{access_operator}{node.attr!s}"
         elif isinstance(node, ast.Name):
             return node.id
         elif isinstance(node, ast.Num):