classiq 0.89.0__py3-none-any.whl → 0.91.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -1,29 +1,18 @@
 from collections.abc import Sequence
 from itertools import chain, combinations
 from typing import (
-    Any,
     Generic,
     Optional,
     cast,
 )
 from uuid import UUID
 
-import sympy
-
 from classiq.interface.debug_info.debug_info import (
     FunctionDebugInfo,
     calculate_port_to_passed_variable_mapping,
+    new_function_debug_info_by_node,
 )
 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,
-)
-from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
-    QmodStructInstance,
-)
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
@@ -31,6 +20,7 @@ from classiq.interface.generator.functions.type_modifier import TypeModifier
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.helpers.text_utils import are, readable_list, s
+from classiq.interface.model.block import Block
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -56,6 +46,7 @@ from classiq.evaluators.argument_types import (
 from classiq.evaluators.parameter_types import (
     evaluate_parameter_types_from_args,
 )
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.capturing.captured_vars import (
     INITIALIZED_VAR_MESSAGE,
     UNINITIALIZED_VAR_MESSAGE,
@@ -73,6 +64,7 @@ from classiq.model_expansions.quantum_operations.function_calls_cache import (
     get_func_call_cache_key,
 )
 from classiq.model_expansions.scope import (
+    ClassicalSymbol,
     Evaluated,
     QuantumSymbol,
     QuantumSymbolList,
@@ -111,18 +103,6 @@ def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
             )
 
 
-def _is_symbolic(arg: Any) -> bool:
-    if isinstance(arg, (ClassicalProxy, AnyClassicalValue)):
-        return True
-    if isinstance(arg, list):
-        return any(_is_symbolic(item) for item in arg)
-    if isinstance(arg, QmodStructInstance):
-        return any(_is_symbolic(item) for item in arg.fields.values())
-    if isinstance(arg, sympy.Basic):
-        return len(arg.free_symbols) > 0
-    return False
-
-
 def _validate_gen_args(
     function: FunctionClosure, evaluated_args: list[Evaluated]
 ) -> None:
@@ -132,7 +112,7 @@ def _validate_gen_args(
         if (
             isinstance(param, ClassicalParameterDeclaration)
             and not param.classical_type.is_purely_declarative
-            and _is_symbolic(arg.value)
+            and isinstance(arg.value, QmodAnnotatedExpression)
         ):
             readable_expr = transform_expression(str(arg.value), {}, {}, one_line=True)
             raise ClassiqExpansionError(
@@ -141,6 +121,27 @@ def _validate_gen_args(
             )
 
 
+def _validate_runtime_args(args: list[Evaluated], scope: Scope) -> None:
+    for arg in args:
+        arg_val = arg.value
+        if not isinstance(arg_val, QmodAnnotatedExpression):
+            continue
+        classical_vars = dict.fromkeys(
+            var.name for var in arg_val.get_classical_vars().values()
+        )
+        runtime_classical_vars = [
+            var
+            for var in classical_vars
+            if isinstance(scope[var].value, ClassicalSymbol)
+        ]
+        if len(runtime_classical_vars) > 0:
+            raise ClassiqExpansionError(
+                f"Passing runtime variable{s(runtime_classical_vars)} "
+                f"{readable_list(runtime_classical_vars, quote=True)} as function call "
+                f"arguments is not supported"
+            )
+
+
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelRenamer):
     @staticmethod
     def _should_wrap(body: Sequence[QuantumStatement]) -> bool:
@@ -148,6 +149,11 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         # I'm sure there are better ways to handle it, but this is the simplest way to do it for now
         return any(isinstance(stmt, VariableDeclarationStatement) for stmt in body)
 
+    def _create_block_labeled_ref(self, label: str) -> FunctionDebugInfo:
+        bake_ref_node = Block(statements=[], label=label)
+        self._interpreter.add_to_debug_info(statement=bake_ref_node)
+        return new_function_debug_info_by_node(bake_ref_node)
+
     def _create_expanded_wrapping_function(
         self,
         name: str,
@@ -195,6 +201,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
         self._validate_call_args(function.positional_arg_declarations, args)
         evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
         _validate_cloning(evaluated_args)
+        _validate_runtime_args(evaluated_args, self._current_scope)
         new_declaration = self._prepare_fully_typed_declaration(
             function, evaluated_args
         )
@@ -385,7 +392,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], ModelR
             name=function.name,
             positional_arg_declarations=evaluate_parameter_types_from_args(
                 function,
-                function.signature_scope,
                 evaluated_args,
             ),
         )

classiq/model_expansions/quantum_operations/classical_var_emitter.py

@@ -1,5 +1,6 @@
 import re
 
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
@@ -14,9 +15,12 @@ class ClassicalVarEmitter(Emitter[ArithmeticOperation]):
         result_symbol = self._interpreter.evaluate(op.result_var).value
         if not isinstance(result_symbol, ClassicalSymbol):
             return False
-        op._classical_assignment = True
+        op.classical_assignment = True
         match = re.search(r"measure\((.*?)\)", op.expression.expr)
         if match is not None:
-            op.set_var_handles([HandleBinding(name=match.group(1))])
+            var = match.group(1)
+            if "[" in var or "." in var:
+                raise ClassiqExpansionError("'measure' must receive a whole variable")
+            op.set_var_handles([HandleBinding(name=var)])
         self.emit_statement(op)
         return True

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,4 +1,3 @@
-import ast
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
 from typing import (
@@ -9,17 +8,10 @@ from typing import (
     Union,
 )
 
-import sympy
-
 from classiq.interface.debug_info.debug_info import (
     DebugInfoCollection,
 )
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.generator.expressions.atomic_expression_functions import (
-    CLASSICAL_ATTRIBUTES,
-    SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS,
-    SUPPORTED_PYTHON_BUILTIN_FUNCTIONS,
-)
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
@@ -47,17 +39,14 @@ from classiq.interface.model.quantum_function_declaration import (
 )
 from classiq.interface.model.quantum_statement import QuantumOperation, QuantumStatement
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.model_expansions.closure import Closure, FunctionClosure, GenerativeClosure
 from classiq.model_expansions.function_builder import (
     OperationBuilder,
     OperationContext,
 )
-from classiq.model_expansions.scope import QuantumSymbol, Scope
-from classiq.model_expansions.sympy_conversion.sympy_to_python import (
-    translate_sympy_quantum_expression,
-)
+from classiq.model_expansions.scope import ClassicalSymbol, QuantumSymbol, Scope
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
-from classiq.model_expansions.visitors.variable_references import VarRefCollector
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 if TYPE_CHECKING:
@@ -153,22 +142,18 @@ class Emitter(Generic[QuantumStatementT], ABC):
         return context
 
     def _evaluate_expression(
-        self, expression: Expression, preserve_bool_ops: bool = False
+        self,
+        expression: Expression,
+        *,
+        simplify: bool = False,
+        treat_qnum_as_float: bool = False,
     ) -> Expression:
-        evaluated_expression = self._interpreter.evaluate(expression)
-        if isinstance(evaluated_expression.value, sympy.Basic):
-            new_expression = Expression(
-                expr=translate_sympy_quantum_expression(
-                    evaluated_expression.value,
-                    preserve_bool_ops=preserve_bool_ops,
-                )
-            )
-        else:
-            new_expression = Expression(expr=str(evaluated_expression.value))
-        new_expression._evaluated_expr = EvaluatedExpression(
-            value=evaluated_expression.value
-        )
-        return new_expression
+        expr_val = self._interpreter.evaluate(
+            expression, simplify=simplify, treat_qnum_as_float=treat_qnum_as_float
+        ).value
+        new_expr = Expression(expr=str(expr_val))
+        new_expr._evaluated_expr = EvaluatedExpression(value=expr_val)
+        return new_expr
 
     def emit_statement(self, statement: QuantumStatement) -> None:
         self._update_captured_classical_vars(statement)
@@ -196,10 +181,8 @@ 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))
-            )
+        for expr in handle.expressions():
+            self._update_captured_classical_vars_in_expression(expr)
         while isinstance(handle, NestedHandleBinding) and not handle.is_constant():
             handle = handle.base_handle
         defining_function = self._current_scope[handle.name].defining_function
@@ -237,52 +220,49 @@ class Emitter(Generic[QuantumStatementT], ABC):
         )
 
     def _get_symbols_in_expression(self, expr: Expression) -> list[QuantumSymbol]:
-        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
-        vrc.visit(ast.parse(expr.expr))
-        handles = dict.fromkeys(
-            handle
-            for handle in vrc.var_handles
-            if handle.name
-            not in SUPPORTED_PYTHON_BUILTIN_FUNCTIONS
-            | SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS
-            and isinstance(self._current_scope[handle.name].value, QuantumSymbol)
-        )
+        expr_val = expr.value.value
+        if not isinstance(expr_val, QmodAnnotatedExpression):
+            return []
         return [
-            self._interpreter.evaluate(handle).value
-            for handle in handles
-            if not isinstance(handle, FieldHandleBinding)
-            or handle.field not in CLASSICAL_ATTRIBUTES
+            QuantumSymbol(handle=var, quantum_type=expr_val.get_quantum_type(node_id))
+            for node_id, var in expr_val.get_quantum_vars().items()
         ]
 
     def _get_classical_vars_in_expression(
         self, expr: Expression
     ) -> list[tuple[str, ClassicalType]]:
-        vrc = VarRefCollector(
-            ignore_duplicated_handles=True, ignore_sympy_symbols=True, unevaluated=True
-        )
-        vrc.visit(ast.parse(expr.expr))
-        return list(
-            {
-                handle.name: get_proxy_type(proxy)
-                for handle in vrc.var_handles
-                if handle.name in self._current_scope
-                and isinstance(
-                    proxy := self._current_scope[handle.name].value, ClassicalProxy
-                )
-            }.items()
+        if not expr.is_evaluated():
+            raise ClassiqInternalExpansionError
+        expr_val = expr.value.value
+        if not isinstance(expr_val, QmodAnnotatedExpression):
+            return []
+        classical_vars = list(
+            dict.fromkeys(var.name for var in expr_val.get_classical_vars().values())
         )
+        return [
+            (
+                var,
+                (
+                    get_proxy_type(proxy)
+                    if isinstance(proxy, ClassicalProxy)
+                    else proxy.classical_type
+                ),
+            )
+            for var in classical_vars
+            if var in self._current_scope
+            and isinstance(
+                proxy := self._current_scope[var].value,
+                (ClassicalProxy, ClassicalSymbol),
+            )
+        ]
 
     def _get_quantum_type_attributes_in_expression(
         self, expr: Expression
     ) -> list[FieldHandleBinding]:
-        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
-        vrc.visit(ast.parse(expr.expr))
-        return list(
-            dict.fromkeys(
-                handle
-                for handle in vrc.var_handles
-                if isinstance(handle, FieldHandleBinding)
-                and handle.field in CLASSICAL_ATTRIBUTES
-                and isinstance(self._current_scope[handle.name].value, QuantumSymbol)
-            )
-        )
+        expr_val = expr.value.value
+        if not isinstance(expr_val, QmodAnnotatedExpression):
+            return []
+        return [
+            FieldHandleBinding(base_handle=type_attr.value, field=type_attr.attr)
+            for type_attr in expr_val.get_quantum_type_attributes().values()
+        ]

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -1,38 +1,93 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.helpers.text_utils import readable_list, s
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import ClassicalSymbol
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
 class ExpressionEvaluator(Emitter[QuantumOperation]):
-    def __init__(self, interpreter: "BaseInterpreter", expression_name: str) -> None:
+    def __init__(
+        self,
+        interpreter: "BaseInterpreter",
+        expression_name: str,
+        *,
+        readable_expression_name: Optional[str] = None,
+        simplify: bool = False,
+        treat_qnum_as_float: bool = False,
+        allow_link_time_vars: bool = True,
+        allow_runtime_vars: bool = True,
+    ) -> None:
         super().__init__(interpreter)
         self._expression_name = expression_name
+        self._simplify = simplify
+        self._treat_qnum_as_float = treat_qnum_as_float
+        self._allow_link_time_vars = allow_link_time_vars
+        self._allow_runtime_vars = allow_runtime_vars
+        if (
+            not allow_link_time_vars or not allow_runtime_vars
+        ) and readable_expression_name is None:
+            raise ClassiqInternalExpansionError
+        self._readable_expression_name = readable_expression_name
 
     def emit(self, op: QuantumOperation, /) -> bool:
         expression = getattr(op, self._expression_name)
         if not isinstance(expression, Expression) or expression.is_evaluated():
             return False
         evaluated_expression = self._evaluate_expression(
-            expression, preserve_bool_ops=True
+            expression,
+            simplify=self._simplify,
+            treat_qnum_as_float=self._treat_qnum_as_float,
         )
         for symbol in self._get_symbols_in_expression(evaluated_expression):
             self._capture_handle(symbol.handle, PortDeclarationDirection.Inout)
-        for var_name, var_type in self._get_classical_vars_in_expression(
-            evaluated_expression
-        ):
-            self._capture_classical_var(var_name, var_type)
+        self._process_classical_parameters(evaluated_expression)
         op = op.model_copy(
             update={self._expression_name: evaluated_expression, "back_ref": op.uuid}
         )
         self._interpreter.add_to_debug_info(op)
         self._interpreter.emit(op)
         return True
+
+    def _process_classical_parameters(self, evaluated_expression: Expression) -> None:
+        link_time_vars: list[str] = []
+        runtime_vars: list[str] = []
+        for var_name, var_type in self._get_classical_vars_in_expression(
+            evaluated_expression
+        ):
+            if isinstance(self._current_scope[var_name].value, ClassicalSymbol):
+                runtime_vars.append(var_name)
+            else:
+                link_time_vars.append(var_name)
+            self._capture_classical_var(var_name, var_type)
+        if not self._allow_link_time_vars and len(link_time_vars) > 0:
+            link_time_message = f"link-time variable{s(link_time_vars)} {readable_list(link_time_vars, quote=True)}"
+        else:
+            link_time_message = None
+        if not self._allow_runtime_vars and len(runtime_vars) > 0:
+            runtime_message = f"runtime variable{s(runtime_vars)} {readable_list(runtime_vars, quote=True)}"
+        else:
+            runtime_message = None
+        if link_time_message is None:
+            error_message = runtime_message
+        elif runtime_message is None:
+            error_message = link_time_message
+        else:
+            error_message = f"{link_time_message} and {runtime_message}"
+        if error_message is not None:
+            raise ClassiqExpansionError(
+                f"The {self._readable_expression_name} cannot receive "
+                f"{error_message}"
+            )

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,7 +1,5 @@
 from typing import TYPE_CHECKING
 
-import sympy
-
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.classical_if import ClassicalIf
@@ -9,6 +7,7 @@ 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.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 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 (
@@ -28,7 +27,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
     def emit(self, call: QuantumFunctionCall, /) -> bool:
         if isinstance(call.function, OperandIdentifier):
             index_val = self._interpreter.evaluate(call.function.index).value
-            if isinstance(index_val, sympy.Basic):
+            if isinstance(index_val, QmodAnnotatedExpression):
                 return self._emit_symbolic_lambda_list(call, index_val)
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
@@ -39,7 +38,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
         return True
 
     def _emit_symbolic_lambda_list(
-        self, call: QuantumFunctionCall, index: sympy.Basic
+        self, call: QuantumFunctionCall, index: QmodAnnotatedExpression
     ) -> bool:
         if TYPE_CHECKING:
             assert isinstance(call.function, OperandIdentifier)
@@ -54,7 +53,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
 
     @staticmethod
     def _create_recursive_if(
-        call: QuantumFunctionCall, index: sympy.Basic, num_funcs: int
+        call: QuantumFunctionCall, index: QmodAnnotatedExpression, num_funcs: int
     ) -> list[QuantumStatement]:
         if TYPE_CHECKING:
             assert isinstance(call.function, OperandIdentifier)

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -1,7 +1,8 @@
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Union, cast
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.classical_type import ClassicalType
+from classiq.interface.generator.functions.concrete_types import ConcreteType
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
@@ -30,13 +31,15 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
         if variable_declaration.is_quantum:
             if TYPE_CHECKING:
                 assert isinstance(var_decl.qmod_type, QuantumType)
+            updated_quantum_type = evaluate_type_in_quantum_symbol(
+                var_decl.qmod_type,
+                self._current_scope,
+                var_decl.name,
+            )
+            var_decl.qmod_type = updated_quantum_type
             var_value = QuantumSymbol(
                 handle=HandleBinding(name=var_decl.name),
-                quantum_type=evaluate_type_in_quantum_symbol(
-                    var_decl.qmod_type,
-                    self._current_scope,
-                    var_decl.name,
-                ),
+                quantum_type=updated_quantum_type,
             )
             self._builder.current_block.captured_vars.init_var(
                 var_decl.name, self._builder.current_function
@@ -44,13 +47,15 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
         else:
             if TYPE_CHECKING:
                 assert isinstance(var_decl.qmod_type, ClassicalType)
+            updated_classical_type = evaluate_type_in_classical_symbol(
+                var_decl.qmod_type,
+                self._current_scope,
+                var_decl.name,
+            )
+            var_decl.qmod_type = cast(ConcreteType, updated_classical_type)
             var_value = ClassicalSymbol(
                 handle=HandleBinding(name=var_decl.name),
-                classical_type=evaluate_type_in_classical_symbol(
-                    var_decl.qmod_type,
-                    self._current_scope,
-                    var_decl.name,
-                ),
+                classical_type=updated_classical_type,
             )
         self._current_scope[variable_declaration.name] = Evaluated(
             value=var_value, defining_function=self._builder.current_function