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

classiq/model_expansions/evaluators/parameter_types.py

@@ -79,11 +79,6 @@ def _update_scope(
     if parameter.direction is PortDeclarationDirection.Output:
         return
     quantum_symbol = argument.as_type(QuantumSymbol)
-    if not quantum_symbol.quantum_type.has_size_in_bits:
-        raise ClassiqExpansionError(
-            f"Argument {str(quantum_symbol.emit())!r} to function {closure.name!r} "
-            f"is not initialized"
-        )
     casted_argument = _cast(
         parameter.quantum_type,
         quantum_symbol,
@@ -274,9 +269,10 @@ def evaluate_types_in_quantum_symbols(
 def _inject_quantum_arg_info_to_type(
     parameter_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
 ) -> QuantumType:
-    copy_type_information(
-        quantum_symbol.quantum_type,
-        parameter_type,
-        param_name,
-    )
+    if quantum_symbol.quantum_type.has_size_in_bits:
+        copy_type_information(
+            quantum_symbol.quantum_type,
+            parameter_type,
+            param_name,
+        )
     return parameter_type

classiq/model_expansions/interpreters/base_interpreter.py

@@ -158,7 +158,7 @@ class BaseInterpreter:
         expr = evaluate_classical_expression(expression, self._builder.current_scope)
         if not isinstance(expr.value, sympy.Basic):
             return expr
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
         vrc.visit(ast.parse(str(expr.value)))
         for handle in vrc.var_handles:
             if handle.name in self._builder.current_scope and isinstance(
@@ -189,8 +189,8 @@ class BaseInterpreter:
         quantum_variable = self.evaluate(sliced_handle_binding.base_handle).as_type(
             QuantumSymbol
         )
-        start = self.evaluate(sliced_handle_binding.start).as_type(int)
-        end = self.evaluate(sliced_handle_binding.end).as_type(int)
+        start = self.evaluate(sliced_handle_binding.start).value
+        end = self.evaluate(sliced_handle_binding.end).value
         return Evaluated(value=quantum_variable[start:end])
 
     @evaluate.register
@@ -200,7 +200,7 @@ class BaseInterpreter:
     @evaluate.register
     def evaluate_subscript_handle(self, subscript: SubscriptHandleBinding) -> Evaluated:
         base_value = self.evaluate(subscript.base_handle)
-        index_value = self.evaluate(subscript.index).as_type(int)
+        index_value = self.evaluate(subscript.index).value
         return Evaluated(value=base_value.value[index_value])
 
     @evaluate.register

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -7,8 +7,10 @@ from numpy.random import permutation
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
+    CLASSICAL_IF_OPERATOR_NAME,
     CONTROL_OPERATOR_NAME,
     INVERT_OPERATOR_NAME,
+    REPEAT_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
 from classiq.interface.model.allocate import Allocate
@@ -52,9 +54,7 @@ from classiq.model_expansions.generative_functions import emit_generative_statem
 from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 from classiq.model_expansions.quantum_operations import (
     BindEmitter,
-    ClassicalIfEmitter,
     QuantumFunctionCallEmitter,
-    RepeatEmitter,
     VariableDeclarationStatementEmitter,
 )
 from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
@@ -69,6 +69,9 @@ from classiq.model_expansions.quantum_operations.expression_evaluator import (
     ExpressionEvaluator,
 )
 from classiq.model_expansions.quantum_operations.handle_evaluator import HandleEvaluator
+from classiq.model_expansions.quantum_operations.repeat_block_evaluator import (
+    RepeatBlockEvaluator,
+)
 from classiq.model_expansions.scope import Evaluated, Scope
 from classiq.model_expansions.scope_initialization import (
     add_constants_to_scope,
@@ -87,7 +90,9 @@ class GenerativeInterpreter(BaseInterpreter):
         generative_functions: list[GenerativeQFunc],
     ) -> None:
         super().__init__(model)
-        add_generative_functions_to_scope(generative_functions, self._top_level_scope)
+        add_generative_functions_to_scope(
+            generative_functions, self._top_level_scope, override_atomic=True
+        )
 
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
         renamed_params = [
@@ -189,8 +194,22 @@ class GenerativeInterpreter(BaseInterpreter):
         VariableDeclarationStatementEmitter(self).emit(variable_declaration)
 
     @emit.register
+    def _emit_classical_if(self, classical_if: ClassicalIf) -> None:
+        self.emit_classical_if(classical_if)
+
     def emit_classical_if(self, classical_if: ClassicalIf) -> None:
-        ClassicalIfEmitter(self).emit(classical_if)
+        CompositeEmitter[ClassicalIf](
+            self,
+            [
+                ExpressionEvaluator(self, "condition"),
+                BlockEvaluator(
+                    self,
+                    CLASSICAL_IF_OPERATOR_NAME,
+                    "then",
+                    "else_",
+                ),
+            ],
+        ).emit(classical_if)
 
     @emit.register
     def emit_within_apply(self, within_apply: WithinApply) -> None:
@@ -208,8 +227,17 @@ class GenerativeInterpreter(BaseInterpreter):
         BlockEvaluator(self, INVERT_OPERATOR_NAME, "body").emit(invert)
 
     @emit.register
+    def _emit_repeat(self, repeat: Repeat) -> None:
+        self.emit_repeat(repeat)
+
     def emit_repeat(self, repeat: Repeat) -> None:
-        RepeatEmitter(self).emit(repeat)
+        CompositeEmitter[Repeat](
+            self,
+            [
+                ExpressionEvaluator(self, "count"),
+                RepeatBlockEvaluator(self, REPEAT_OPERATOR_NAME, "body"),
+            ],
+        ).emit(repeat)
 
     @emit.register
     def _emit_control(self, control: Control) -> None:

classiq/model_expansions/quantum_operations/__init__.py

@@ -1,9 +1,7 @@
 from classiq.model_expansions.quantum_operations.bind import BindEmitter
-from classiq.model_expansions.quantum_operations.classicalif import ClassicalIfEmitter
 from classiq.model_expansions.quantum_operations.quantum_function_call import (
     QuantumFunctionCallEmitter,
 )
-from classiq.model_expansions.quantum_operations.repeat import RepeatEmitter
 from classiq.model_expansions.quantum_operations.variable_decleration import (
     VariableDeclarationStatementEmitter,
 )

classiq/model_expansions/quantum_operations/block_evaluator.py

@@ -1,6 +1,7 @@
 from collections.abc import Sequence
 from typing import TYPE_CHECKING
 
+from classiq.interface.model.quantum_function_declaration import PositionalArg
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
 from classiq.model_expansions.closure import Closure
@@ -54,7 +55,8 @@ class BlockEvaluator(Emitter[QuantumOperation]):
         }
         block_closure = Closure(
             name=self._operation_name,
-            scope=Scope(parent=self._current_scope),
+            scope=self.get_scope(op),
+            positional_arg_declarations=self.get_params(op),
             blocks=blocks,
         )
         context = self._expand_operation(block_closure)
@@ -69,8 +71,20 @@ class BlockEvaluator(Emitter[QuantumOperation]):
         blocks = [
             block for block in self._block_names if op.has_generative_block(block)
         ]
-        context = self._expand_generative_context(op, self._operation_name, blocks)
+        context = self._expand_generative_context(
+            op,
+            self._operation_name,
+            blocks,
+            self.get_params(op),
+            self.get_scope(op),
+        )
         return {
             _REVERSE_BLOCK_RENAMES.get(block, block): context.statements(block)
             for block in blocks
         }
+
+    def get_params(self, op: QuantumOperation) -> Sequence[PositionalArg]:
+        return []
+
+    def get_scope(self, op: QuantumOperation) -> Scope:
+        return Scope(parent=self._current_scope)

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -12,6 +12,9 @@ import sympy
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
@@ -94,7 +97,7 @@ def _is_symbolic(arg: Any) -> bool:
         return any(_is_symbolic(item) for item in arg.fields.values())
     if isinstance(arg, sympy.Basic):
         return len(arg.free_symbols) > 0
-    return isinstance(arg, ClassicalProxy)
+    return isinstance(arg, (ClassicalProxy, AnyClassicalValue))
 
 
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,5 +1,6 @@
 import ast
 from abc import ABC, abstractmethod
+from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
     Generic,
@@ -30,10 +31,11 @@ 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.handle_binding import HandleBinding, NestedHandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
+    PositionalArg,
 )
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
@@ -110,17 +112,20 @@ class Emitter(Generic[QuantumStatementT], ABC):
         op: QuantumOperation,
         context_name: str,
         block_names: Union[None, str, list[str]] = None,
-        func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None,
+        params: Optional[Sequence[PositionalArg]] = None,
+        scope: Optional[Scope] = None,
     ) -> OperationContext:
         if isinstance(block_names, str):
             block_names = [block_names]
         block_names = block_names or ["body"]
-        func_decl = func_decl or NamedParamsQuantumFunctionDeclaration(
-            name=context_name
+        func_decl = NamedParamsQuantumFunctionDeclaration(
+            name=context_name,
+            positional_arg_declarations=[] if params is None else params,
         )
+        _scope = Scope(parent=self._current_scope) if scope is None else scope
         gen_closure = GenerativeClosure(
             name=func_decl.name,
-            scope=Scope(parent=self._interpreter._builder.current_scope),
+            scope=_scope,
             blocks={},
             generative_blocks={
                 block_name: GenerativeQFunc(
@@ -128,6 +133,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
                 )
                 for block_name in block_names
             },
+            positional_arg_declarations=func_decl.positional_arg_declarations,
         )
         context = self._interpreter._expand_operation(gen_closure)
         op.clear_generative_blocks()
@@ -163,8 +169,11 @@ class Emitter(Generic[QuantumStatementT], ABC):
 
     def _update_captured_classical_vars(self, stmt: QuantumStatement) -> None:
         for expr in stmt.expressions:
-            for var_name, var_type in self._get_classical_vars_in_expression(expr):
-                self._capture_classical_var(var_name, var_type)
+            self._update_captured_classical_vars_in_expression(expr)
+
+    def _update_captured_classical_vars_in_expression(self, expr: Expression) -> None:
+        for var_name, var_type in self._get_classical_vars_in_expression(expr):
+            self._capture_classical_var(var_name, var_type)
 
     def _update_captured_vars(self, op: QuantumOperation) -> None:
         handles = (
@@ -180,6 +189,12 @@ class Emitter(Generic[QuantumStatementT], ABC):
     ) -> None:
         if handle.name not in self._current_scope:
             return
+        if not handle.is_constant():
+            self._update_captured_classical_vars_in_expression(
+                Expression(expr=str(handle))
+            )
+        while isinstance(handle, NestedHandleBinding) and not handle.is_constant():
+            handle = handle.base_handle
         defining_function = self._current_scope[handle.name].defining_function
         if defining_function is None:
             raise ClassiqInternalExpansionError
@@ -204,7 +219,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
         )
 
     def _get_symbols_in_expression(self, expr: Expression) -> list[QuantumSymbol]:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
         vrc.visit(ast.parse(expr.expr))
         handles = dict.fromkeys(
             handle
@@ -216,7 +231,9 @@ class Emitter(Generic[QuantumStatementT], ABC):
     def _get_classical_vars_in_expression(
         self, expr: Expression
     ) -> list[tuple[str, ClassicalType]]:
-        vrc = VarRefCollector(ignore_duplicated_handles=True, ignore_sympy_symbols=True)
+        vrc = VarRefCollector(
+            ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
+        )
         vrc.visit(ast.parse(expr.expr))
         return list(
             {

classiq/model_expansions/quantum_operations/handle_evaluator.py

@@ -18,7 +18,7 @@ class HandleEvaluator(Emitter[QuantumOperation]):
         handle = getattr(op, self._handle_name)
         if not isinstance(handle, HandleBinding):
             return False
-        evaluated_handle = self._interpreter.evaluate(handle).value.handle
+        evaluated_handle = self._interpreter.evaluate(handle).value.handle.collapse()
         if handle == evaluated_handle:
             return False
         op = op.model_copy(

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,6 +1,14 @@
 from typing import TYPE_CHECKING
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
+from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_lambda_function import OperandIdentifier
+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
@@ -19,6 +27,10 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
         self._model = self._interpreter._model
 
     def emit(self, call: QuantumFunctionCall, /) -> bool:
+        if isinstance(call.function, OperandIdentifier):
+            index_val = self._interpreter.evaluate(call.function.index).value
+            if isinstance(index_val, ClassicalScalarProxy):
+                return self._emit_symbolic_lambda_list(call, index_val)
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
         with ErrorManager().call(function.name):
@@ -27,6 +39,43 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
             )
         return True
 
+    def _emit_symbolic_lambda_list(
+        self, call: QuantumFunctionCall, index: ClassicalScalarProxy
+    ) -> bool:
+        if TYPE_CHECKING:
+            assert isinstance(call.function, OperandIdentifier)
+        funcs = self._interpreter.evaluate(call.function.name).value
+        if not isinstance(funcs, list):
+            raise ClassiqInternalExpansionError(
+                f"Unexpected lambda list type {type(funcs).__name__!r}"
+            )
+        self._interpreter.emit(self._create_recursive_if(call, index, len(funcs)))
+        return True
+
+    @staticmethod
+    def _create_recursive_if(
+        call: QuantumFunctionCall, index: ClassicalScalarProxy, num_funcs: int
+    ) -> QuantumStatement:
+        if TYPE_CHECKING:
+            assert isinstance(call.function, OperandIdentifier)
+        stmt: list[QuantumStatement] = []
+        for idx in reversed(range(num_funcs)):
+            stmt = [
+                ClassicalIf(
+                    condition=Expression(expr=f"{index} == {idx}"),
+                    then=[
+                        QuantumFunctionCall(
+                            function=OperandIdentifier(
+                                name=call.function.name, index=Expression(expr=str(idx))
+                            ),
+                            positional_args=call.positional_args,
+                        )
+                    ],
+                    else_=stmt,
+                )
+            ]
+        return stmt[0]
+
 
 class DeclarativeQuantumFunctionCallEmitter(
     QuantumFunctionCallEmitter, DeclarativeCallEmitter

classiq/model_expansions/quantum_operations/repeat_block_evaluator.py

@@ -0,0 +1,34 @@
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
+from classiq.interface.generator.functions.classical_type import Integer
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_function_declaration import PositionalArg
+from classiq.interface.model.quantum_statement import QuantumOperation
+from classiq.interface.model.repeat import Repeat
+
+from classiq import ClassicalParameterDeclaration
+from classiq.model_expansions.quantum_operations.block_evaluator import BlockEvaluator
+from classiq.model_expansions.scope import Evaluated, Scope
+
+
+class RepeatBlockEvaluator(BlockEvaluator):
+    def get_params(self, op: QuantumOperation) -> Sequence[PositionalArg]:
+        if TYPE_CHECKING:
+            assert isinstance(op, Repeat)
+        return [
+            ClassicalParameterDeclaration(name=op.iter_var, classical_type=Integer())
+        ]
+
+    def get_scope(self, op: QuantumOperation) -> Scope:
+        if TYPE_CHECKING:
+            assert isinstance(op, Repeat)
+        scope = super().get_scope(op)
+        scope[op.iter_var] = Evaluated(
+            value=ClassicalScalarProxy(HandleBinding(name=op.iter_var), Integer()),
+            defining_function=self._builder.current_function,
+        )
+        return scope

classiq/model_expansions/scope.py

@@ -13,6 +13,9 @@ from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
+    ClassicalScalarProxy,
+)
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
@@ -47,28 +50,38 @@ class QuantumSymbol:
     def emit(self) -> HandleBinding:
         return self.handle
 
-    def __getitem__(self, item: Union[slice, int]) -> "QuantumSymbol":
-        if isinstance(item, int):
-            return self._subscript(item)
-
-        return self._slice(item.start, item.stop)
+    def __getitem__(
+        self, item: Union[slice, int, ClassicalScalarProxy]
+    ) -> "QuantumSymbol":
+        if isinstance(item, slice):
+            return self._slice(item.start, item.stop)
+        return self._subscript(item)
 
-    def _slice(self, start: int, end: int) -> "QuantumSymbol":
+    def _slice(
+        self,
+        start: Union[int, ClassicalScalarProxy],
+        end: Union[int, ClassicalScalarProxy],
+    ) -> "QuantumSymbol":
         if not isinstance(self.quantum_type, QuantumBitvector):
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
             )
-        if start >= end:
+        if TYPE_CHECKING:
+            assert self.quantum_type.length is not None
+        if isinstance(start, int) and isinstance(end, int) and start >= end:
             raise ClassiqExpansionError(
                 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:
+        if (isinstance(start, int) and start < 0) or (
+            isinstance(end, int)
+            and self.quantum_type.length.is_constant()
+            and end > self.quantum_type.length_value
+        ):
             raise ClassiqExpansionError(
                 f"Slice [{start}:{end}] is out of bounds for "
                 f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
-                f"length {array_length})"
+                f"length {self.quantum_type.length_value})"
             )
         return QuantumSymbol(
             handle=SlicedHandleBinding(
@@ -82,17 +95,24 @@ class QuantumSymbol:
             ),
         )
 
-    def _subscript(self, index: int) -> "QuantumSymbol":
+    def _subscript(self, index: Union[int, ClassicalScalarProxy]) -> "QuantumSymbol":
         if not isinstance(self.quantum_type, QuantumBitvector):
             raise ClassiqExpansionError(
                 f"{self.quantum_type.type_name} is not subscriptable"
             )
-        array_length = self.quantum_type.length_value
-        if index < 0 or index >= array_length:
+        if TYPE_CHECKING:
+            assert self.quantum_type.length is not None
+        if isinstance(index, int) and (
+            index < 0
+            or (
+                self.quantum_type.length.is_constant()
+                and index >= self.quantum_type.length_value
+            )
+        ):
             raise ClassiqExpansionError(
                 f"Index {index} is out of bounds for "
                 f"{self.quantum_type.type_name.lower()} {str(self.handle)!r} (of "
-                f"length {array_length})"
+                f"length {self.quantum_type.length})"
             )
         return QuantumSymbol(
             handle=SubscriptHandleBinding(

classiq/model_expansions/scope_initialization.py

@@ -58,14 +58,18 @@ def add_functions_to_scope(
 
 
 def add_generative_functions_to_scope(
-    functions: Sequence[GenerativeQFunc], scope: Scope
+    functions: Sequence[GenerativeQFunc], scope: Scope, override_atomic: bool = False
 ) -> None:
     for function in functions:
         name = function.func_decl.name
-        if name == MAIN_FUNCTION_NAME or name not in scope:
-            scope[function.func_decl.name] = Evaluated(
+        if (
+            name == MAIN_FUNCTION_NAME
+            or name not in scope
+            or (override_atomic and scope[name].value.is_atomic)
+        ):
+            scope[name] = Evaluated(
                 value=GenerativeFunctionClosure.create(
-                    name=function.func_decl.name,
+                    name=name,
                     positional_arg_declarations=function.func_decl.positional_arg_declarations,
                     scope=Scope(parent=scope),
                     generative_blocks={"body": function},