classiq 0.64.0__py3-none-any.whl → 0.65.1__py3-none-any.whl

classiq/model_expansions/quantum_operations/declarative_call_emitter.py

@@ -0,0 +1,87 @@
+from itertools import chain
+from typing import TYPE_CHECKING, Generic
+
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+
+from classiq.model_expansions.closure import FunctionClosure, GenerativeClosure
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
+from classiq.model_expansions.quantum_operations.emitter import QuantumStatementT
+from classiq.model_expansions.scope import Evaluated
+from classiq.qmod.model_state_container import QMODULE
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.generative_interpreter import (
+        GenerativeInterpreter,
+    )
+
+
+class DeclarativeCallEmitter(
+    Generic[QuantumStatementT], CallEmitter[QuantumStatementT]
+):
+    _interpreter: "GenerativeInterpreter"
+
+    def __init__(self, interpreter: "GenerativeInterpreter") -> None:
+        super().__init__(interpreter)
+
+    def should_expand_function(
+        self, function: FunctionClosure, args: list[Evaluated]
+    ) -> bool:
+        if not super().should_expand_function(function, args):
+            return False
+
+        if self._is_function_purely_declarative(
+            function
+        ) and self._are_args_purely_declarative(args):
+            self._interpreter.add_purely_declarative_function(function)
+            return False
+
+        return True
+
+    def _is_function_purely_declarative(self, function: FunctionClosure) -> bool:
+        if function.name not in QMODULE.native_defs:
+            return False
+
+        if isinstance(function, GenerativeClosure):
+            return False
+
+        if any(
+            not param.quantum_type.is_instantiated
+            for param in function.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+            and param.direction == PortDeclarationDirection.Output
+        ):
+            return False
+
+        dependencies = QMODULE.function_dependencies[function.name]
+        return self._are_identifiers_purely_declarative(dependencies)
+
+    def _are_args_purely_declarative(self, args: list[Evaluated]) -> bool:
+        values = [arg.value for arg in args]
+        function_inputs: list[FunctionClosure] = list(
+            chain.from_iterable(
+                (
+                    [arg]
+                    if isinstance(arg, FunctionClosure)
+                    else (
+                        arg
+                        if isinstance(arg, list)
+                        and any(isinstance(item, FunctionClosure) for item in arg)
+                        else []
+                    )
+                )
+                for arg in values
+            )
+        )
+        if any(func.is_lambda for func in function_inputs):
+            return False
+        dependencies = [func.name for func in function_inputs if not func.is_lambda]
+        return self._are_identifiers_purely_declarative(dependencies)
+
+    def _are_identifiers_purely_declarative(self, dependencies: list[str]) -> bool:
+        return not any(
+            isinstance(self._current_scope[dep].value, GenerativeClosure)
+            for dep in dependencies
+        )

classiq/model_expansions/quantum_operations/emitter.py

@@ -19,6 +19,7 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_declaration import (
@@ -80,6 +81,10 @@ class Emitter(Generic[QuantumStatementT]):
     def _expanded_functions(self) -> dict[str, NativeFunctionDefinition]:
         return self._interpreter._expanded_functions
 
+    @property
+    def _expanded_functions_by_name(self) -> dict[str, NativeFunctionDefinition]:
+        return nameables_to_dict(list(self._interpreter._expanded_functions.values()))
+
     @property
     def _counted_name_allocator(self) -> CountedNameAllocator:
         return self._interpreter._counted_name_allocator

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -4,6 +4,9 @@ from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
+from classiq.model_expansions.quantum_operations.declarative_call_emitter import (
+    DeclarativeCallEmitter,
+)
 from classiq.qmod.semantics.error_manager import ErrorManager
 
 if TYPE_CHECKING:
@@ -22,3 +25,9 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
             self._emit_quantum_function_call(
                 function, args, self._debug_info.get(call.uuid)
             )
+
+
+class DeclarativeQuantumFunctionCallEmitter(
+    QuantumFunctionCallEmitter, DeclarativeCallEmitter
+):
+    pass

classiq/model_expansions/quantum_operations/shallow_emitter.py

@@ -6,6 +6,7 @@ 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.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
@@ -17,7 +18,10 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
 from classiq.model_expansions.closure import Closure
-from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.model_expansions.evaluators.quantum_type_utils import (
+    copy_type_information,
+    set_size,
+)
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol, Scope
 from classiq.model_expansions.transformers.ast_renamer import rename_variables
@@ -73,6 +77,8 @@ class ShallowEmitter(Emitter[QuantumOperation]):
         op = op.model_copy(update=expanded_components)
         if isinstance(op, QuantumAssignmentOperation):
             self._post_process_assignment(op)
+        if isinstance(op, Allocate):
+            self._post_process_allocate(op)
         self._builder.emit_statement(op)
 
     def _post_process_assignment(self, op: QuantumAssignmentOperation) -> None:
@@ -86,6 +92,19 @@ class ShallowEmitter(Emitter[QuantumOperation]):
             direction = PortDeclarationDirection.Inout
         self._capture_handle(op.result_var, direction)
 
+    def _post_process_allocate(self, allocate: Allocate) -> None:
+        target_symbol = self._interpreter.evaluate(allocate.target).value
+        if not isinstance(target_symbol, QuantumSymbol):
+            return
+        self._capture_handle(target_symbol.handle, PortDeclarationDirection.Output)
+        if allocate.size is None or not allocate.size.is_evaluated():
+            return
+        set_size(
+            target_symbol.quantum_type,
+            allocate.size.to_int_value(),
+            str(target_symbol.handle),
+        )
+
     def _split_components(
         self, op: QuantumOperation
     ) -> tuple[list[str], list[str], list[str]]:

classiq/model_expansions/scope.py

@@ -19,9 +19,6 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.expression_constants import (
     CPARAM_EXECUTION_SUFFIX_PATTERN,
 )
-from classiq.interface.generator.expressions.qmod_qarray_proxy import (
-    ILLEGAL_SLICE_BOUNDS_MSG,
-)
 from classiq.interface.generator.expressions.qmod_struct_instance import (
     QmodStructInstance,
 )
@@ -65,16 +62,19 @@ class QuantumSymbol:
     def _slice(self, start: int, end: int) -> "QuantumSymbol":
         if not isinstance(self.quantum_type, QuantumBitvector):
             raise ClassiqExpansionError(
-                f"{self.quantum_type.type_name} is not subscriptable."
+                f"{self.quantum_type.type_name} is not subscriptable"
             )
         if start >= end:
-            raise ClassiqExpansionError(ILLEGAL_SLICE_BOUNDS_MSG.format(start, end))
-        if (
-            self.quantum_type.has_length
-            and end - start > self.quantum_type.length_value
-        ):
             raise ClassiqExpansionError(
-                f"Slice [{start}:{end}] is out of bounds for {self.handle}."
+                f"{self.quantum_type.type_name} slice '{self.handle}[{start}:{end}]' "
+                f"has non-positive length"
+            )
+        array_length = self.quantum_type.length_value
+        if start < 0 or end > array_length:
+            raise ClassiqExpansionError(
+                f"Slice [{start}:{end}] is out of bounds of "
+                f"{self.quantum_type.type_name} {str(self.handle)!r} of length "
+                f"{array_length}"
             )
         return QuantumSymbol(
             handle=SlicedHandleBinding(
@@ -91,13 +91,13 @@ class QuantumSymbol:
     def _subscript(self, index: int) -> "QuantumSymbol":
         if not isinstance(self.quantum_type, QuantumBitvector):
             raise ClassiqExpansionError(
-                f"{self.quantum_type.type_name} is not subscriptable."
+                f"{self.quantum_type.type_name} is not subscriptable"
             )
-        if index < 0 or (
-            self.quantum_type.has_length and index > self.quantum_type.length_value
-        ):
+        array_length = self.quantum_type.length_value
+        if index < 0 or index >= array_length:
             raise ClassiqExpansionError(
-                f"Subscript [{index}] is out of bounds for {self.handle}."
+                f"Subscript {index} is out of bounds of {self.quantum_type.type_name} "
+                f"{str(self.handle)!r} of length {array_length}"
             )
         return QuantumSymbol(
             handle=SubscriptHandleBinding(

classiq/model_expansions/scope_initialization.py

@@ -78,7 +78,8 @@ def add_generative_functions_to_scope(
     functions: Sequence[GenerativeQFunc], scope: Scope
 ) -> None:
     for function in functions:
-        if function.func_decl.name not in scope:
+        name = function.func_decl.name
+        if name == MAIN_FUNCTION_NAME or name not in scope:
             scope[function.func_decl.name] = Evaluated(
                 value=GenerativeFunctionClosure.create(
                     name=function.func_decl.name,
@@ -138,10 +139,7 @@ def add_entry_point_params_to_scope(
             )
 
 
-def init_top_level_scope(
-    model: Model, generative_functions: list[GenerativeQFunc], scope: Scope
-) -> None:
-    add_generative_functions_to_scope(generative_functions, scope)
+def init_top_level_scope(model: Model, scope: Scope) -> None:
     add_functions_to_scope(model.functions, scope)
     add_constants_to_scope(model.constants, scope)
     _init_builtins_scope(scope)

classiq/open_library/functions/discrete_sine_cosine_transform.py

@@ -3,9 +3,15 @@ from classiq.open_library.functions.utility_functions import (
     apply_to_all,
     modular_increment,
 )
-from classiq.qmod.builtins.functions import allocate
 from classiq.qmod.builtins.functions.standard_gates import PHASE, H, S, X, Z
-from classiq.qmod.builtins.operations import bind, control, invert, repeat, within_apply
+from classiq.qmod.builtins.operations import (
+    allocate,
+    bind,
+    control,
+    invert,
+    repeat,
+    within_apply,
+)
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.symbolic import pi

classiq/open_library/functions/grover.py

@@ -1,7 +1,7 @@
 from classiq.open_library.functions.utility_functions import hadamard_transform
-from classiq.qmod.builtins.functions import allocate
 from classiq.qmod.builtins.functions.standard_gates import H, U, X
 from classiq.qmod.builtins.operations import (
+    allocate,
     bind,
     control,
     invert,

classiq/open_library/functions/modular_exponentiation.py

@@ -1,8 +1,14 @@
 from classiq.open_library.functions.qft_functions import qft, qft_no_swap
 from classiq.qmod.builtins.classical_functions import qft_const_adder_phase
-from classiq.qmod.builtins.functions import allocate
 from classiq.qmod.builtins.functions.standard_gates import PHASE, SWAP, X
-from classiq.qmod.builtins.operations import bind, control, invert, repeat, within_apply
+from classiq.qmod.builtins.operations import (
+    allocate,
+    bind,
+    control,
+    invert,
+    repeat,
+    within_apply,
+)
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum

classiq/open_library/functions/state_preparation.py

@@ -1,12 +1,14 @@
+import warnings
 from typing import Literal
 
+from classiq.interface.exceptions import ClassiqDeprecationWarning
+
 from classiq.open_library.functions.utility_functions import (
     hadamard_transform,
     modular_increment,
 )
-from classiq.qmod.builtins.functions import allocate
 from classiq.qmod.builtins.functions.standard_gates import CX, IDENTITY, RY, H, X
-from classiq.qmod.builtins.operations import control, if_, repeat
+from classiq.qmod.builtins.operations import allocate, control, if_, repeat
 from classiq.qmod.cparam import CBool, CInt
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
@@ -16,6 +18,7 @@ from classiq.qmod.symbolic import (
     exp,
     floor,
     log,
+    logical_or,
     max as qmax,
     min as qmin,
     pi,
@@ -239,16 +242,19 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
 
     """
     allocate(2, q)
-    inplace_prepare_int(state_num, q)
+    if_(logical_or(state_num == 1, state_num == 3), lambda: X(q[0]))
+    if_(logical_or(state_num == 2, state_num == 3), lambda: X(q[1]))
     H(q[0])
     CX(q[0], q[1])
 
 
 @qfunc
-def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
+def inplace_prepare_int(value: CInt, target: QNum) -> None:
     """
     [Qmod Classiq-library function]
 
+    This function is **deprecated**. Use in-place-xor assignment statement in the form _target-var_ **^=** _quantum-expression_ or **inplace_xor(**_quantum-expression_**,** _target-var_**)** instead.
+
     Transitions a quantum variable in the zero state $|0\\rangle$ into the computational basis state $|\\text{value}\\rangle$.
     In the general case, the function performs a bitwise-XOR, i.e. transitions the state $|\\psi\\rangle$ into $|\\psi \\oplus \\text{value}\\rangle$.
 
@@ -259,14 +265,12 @@ def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
     Note:
         If the value cannot fit into the quantum variable, it is truncated, i.e. treated as the value modulo $2^\\text{target.size}$.
     """
-    repeat(
-        target.len,
-        lambda index: if_(
-            (floor(value / (2**index)) % 2) == 1,
-            lambda: X(target[index]),
-            lambda: IDENTITY(target[index]),
-        ),
+    warnings.warn(
+        "Function 'inplace_prepare_int' is deprecated. Use in-place-xor assignment statement in the form '<var> ^= <expression>' or 'inplace_xor(<expression>, <var>)' instead.",
+        ClassiqDeprecationWarning,
+        stacklevel=1,
     )
+    target ^= value
 
 
 @qfunc
@@ -277,6 +281,8 @@ def prepare_int(
     """
     [Qmod Classiq-library function]
 
+    This function is **deprecated**. Use assignment statement in the form _target-var_ **|=** _quantum-expression_ or **assign(**_quantum-expression_**,** _target-var_**)** instead.
+
     Initializes a quantum variable to the computational basis state $|\\text{value}\\rangle$.
     The number of allocated qubits is automatically computed from the value, and is the minimal number required for representation in the computational basis.
 
@@ -287,5 +293,9 @@ def prepare_int(
     Note:
         If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
     """
-    allocate(floor(log(value, 2)) + 1, out)
-    inplace_prepare_int(value, out)
+    warnings.warn(
+        "Function 'prepare_int' is deprecated. Use assignment statement in the form '<var> |= <expression>'  or 'assign(<expression>, <var>)' instead.",
+        ClassiqDeprecationWarning,
+        stacklevel=1,
+    )
+    out |= value

classiq/open_library/functions/swap_test.py

@@ -1,6 +1,5 @@
-from classiq.qmod.builtins.functions import allocate
 from classiq.qmod.builtins.functions.standard_gates import SWAP, H
-from classiq.qmod.builtins.operations import control, repeat
+from classiq.qmod.builtins.operations import allocate, control, repeat
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit
 

classiq/open_library/functions/variational.py

@@ -1,6 +1,5 @@
-from classiq.qmod.builtins.functions import allocate
 from classiq.qmod.builtins.functions.standard_gates import RX, RY, RZ
-from classiq.qmod.builtins.operations import repeat
+from classiq.qmod.builtins.operations import allocate, repeat
 from classiq.qmod.cparam import CReal
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray

classiq/qmod/builtins/__init__.py

@@ -12,7 +12,7 @@ from .enums import *  # noqa: F403
 from .enums import __all__ as _builtin_enums
 from .functions import *  # noqa: F403
 from .functions import __all__ as _builtin_functions
-from .operations import *  # noqa: F403
+from .operations import *  # type:ignore[assignment] # noqa: F403
 from .operations import __all__ as _builtin_operations
 from .structs import *  # noqa: F403
 from .structs import __all__ as _builtin_structs

classiq/qmod/builtins/operations.py

@@ -7,6 +7,7 @@ from typing import (
     Callable,
     Final,
     Union,
+    overload,
 )
 
 from classiq.interface.exceptions import ClassiqValueError
@@ -15,6 +16,7 @@ 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.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
@@ -41,6 +43,7 @@ from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.qmod.generative import is_generative_mode
+from classiq.qmod.qmod_constant import QConstant
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QScalar, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
@@ -50,6 +53,53 @@ from classiq.qmod.utilities import get_source_ref
 _MISSING_VALUE: Final[int] = -1
 
 
+@overload
+def allocate(num_qubits: Union[int, SymbolicExpr], out: Output[QVar]) -> None:
+    pass
+
+
+@overload
+def allocate(out: Output[QVar]) -> None:
+    pass
+
+
+def allocate(*args: Any, **kwargs: Any) -> None:
+    """
+    Initialize a quantum variable.
+
+    If 'num_qubits' is specified, 'num_qubits' qubits will be allocated for variable
+    'out'. Otherwise, the number of qubits will be inferred according to the type of
+    'out'.
+
+    Args:
+        size: The number of qubits to be allocated (optional)
+        out: The target variable
+    """
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    if len(args) == 0:
+        size = kwargs.get("num_qubits", None)
+        target = kwargs["out"]
+    elif len(args) == 1:
+        if "out" in kwargs:
+            size = args[0]
+            target = kwargs["out"]
+        else:
+            size = None
+            target = args[0]
+    else:
+        size, target = args
+    if isinstance(size, QConstant):
+        size.add_to_model()
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        Allocate(
+            size=None if size is None else Expression(expr=str(size)),
+            target=target.get_handle_binding(),
+            source_ref=source_ref,
+        )
+    )
+
+
 def bind(
     source: Union[Input[QVar], list[Input[QVar]]],
     destination: Union[Output[QVar], list[Output[QVar]]],
@@ -369,6 +419,7 @@ def _operand_to_body(
 
 
 __all__ = [
+    "allocate",
     "assign",
     "assign_amplitude",
     "bind",

classiq/qmod/native/pretty_printer.py

@@ -22,6 +22,7 @@ from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.generator.visitor import NodeType, Visitor
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
@@ -80,7 +81,7 @@ from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.open_library.functions import OPEN_LIBRARY_FUNCTIONS
 from classiq.qmod.native.expression_to_qmod import transform_expression
-from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
+from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
@@ -253,6 +254,13 @@ class DSLPrettyPrinter(Visitor):
         self._level -= 1
         return f"{self.visit_QuantumFunctionDeclaration(func_def)} {{\n{body}}}\n"
 
+    def visit_Allocate(self, allocate: Allocate) -> str:
+        if allocate.size is not None:
+            size = f"{self.visit(allocate.size)}, "
+        else:
+            size = ""
+        return f"{self._indent}allocate({size}{self.visit(allocate.target)});\n"
+
     def visit_QuantumFunctionCall(self, func_call: QuantumFunctionCall) -> str:
         positional_args = ", ".join(
             self.visit(arg_decl) for arg_decl in func_call.positional_args

classiq/qmod/pretty_print/pretty_printer.py

@@ -25,6 +25,7 @@ from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.generator.visitor import NodeType, Visitor
+from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
@@ -376,7 +377,10 @@ class PythonPrettyPrinter(Visitor):
 
     def visit_NativeFunctionDefinition(self, func_def: NativeFunctionDefinition) -> str:
         self._level += 1
-        body = "".join(self.visit(statement) for statement in func_def.body)
+        if len(func_def.body) == 0:
+            body = "    pass"
+        else:
+            body = "".join(self.visit(statement) for statement in func_def.body)
         self._level -= 1
         return f"{self.visit_QuantumFunctionDeclaration(func_def)} \n{body}\n"
 
@@ -402,6 +406,13 @@ class PythonPrettyPrinter(Visitor):
                 )
         return ", ".join(self.visit(arg) for arg in func_call.positional_args)
 
+    def visit_Allocate(self, allocate: Allocate) -> str:
+        if allocate.size is not None:
+            size = f"{self.visit(allocate.size)}, "
+        else:
+            size = ""
+        return f"{self._indent}allocate({size}{self.visit(allocate.target)})\n"
+
     def visit_Control(self, op: Control) -> str:
         self._imports["control"] = 1
         control_else = (