classiq 0.73.0__py3-none-any.whl → 0.75.0__py3-none-any.whl

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -15,6 +15,9 @@ from classiq.interface.generator.expressions.expression_types import (
 from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
     AnyClassicalValue,
 )
+from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
+    ClassicalArrayProxy,
+)
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
 )
@@ -170,7 +173,11 @@ def get_field(
         return AnyClassicalValue(f"({proxy}).{field}")
     if isinstance(proxy, type) and issubclass(proxy, Enum):
         return getattr(proxy, field)
-    if isinstance(proxy, Symbol) and not isinstance(proxy, QmodSizedProxy):
+    if (
+        isinstance(proxy, Symbol)
+        and not isinstance(proxy, QmodSizedProxy)
+        and not isinstance(proxy, ClassicalProxy)
+    ):
         raise ClassiqExpansionError(
             f"Cannot evaluate '{proxy}.{field}': Variable {str(proxy)!r} is not "
             f"initialized"
@@ -229,7 +236,9 @@ def _is_qmod_value(val: Any) -> bool:
 
 
 def do_subscript(value: Any, index: Any) -> Any:
-    if not isinstance(value, list) or not isinstance(index, QmodQNumProxy):
+    if not isinstance(value, (list, ClassicalArrayProxy)) or not isinstance(
+        index, QmodQNumProxy
+    ):
         if isinstance(index, (QmodSizedProxy, QmodStructInstance)):
             raise ClassiqExpansionError(
                 f"Subscript {value}[{index}] is not supported. Supported subscripts "
@@ -251,15 +260,22 @@ def do_subscript(value: Any, index: Any) -> Any:
             "Quantum numeric subscript must be an unsigned integer (is_signed=False, "
             "fraction_digits=0)"
         )
-    if len(value) != 2**index.size:
+    if isinstance(value, ClassicalArrayProxy):
+        length = value.length
+    else:
+        length = len(value)
+    if length != 2**index.size:
         raise ClassiqExpansionError(
             f"Quantum numeric subscript size mismatch: The quantum numeric has "
-            f"{index.size} qubits but the list size is {len(value)} != 2**{index.size}"
+            f"{index.size} qubits but the list size is {length} != 2**{index.size}"
+        )
+    if isinstance(value, ClassicalArrayProxy):
+        return AnyClassicalValue(f"{value}[{index}]")
+    else:
+        return Piecewise(
+            *[(item, Eq(index, idx)) for idx, item in enumerate(value[:-1])],
+            (value[-1], True),
         )
-    return Piecewise(
-        *[(item, Eq(index, idx)) for idx, item in enumerate(value[:-1])],
-        (value[-1], True),
-    )
 
 
 def do_slice(value: Any, lower: Any, upper: Any) -> Any:

classiq/model_expansions/capturing/captured_vars.py

@@ -116,6 +116,16 @@ class _CapturedHandle(_Captured):
             self.defining_function.depth,
         )
 
+    @property
+    def mangled_handle(self) -> HandleBinding:
+        return self.handle.rename(
+            mangle_captured_var_name(
+                self.handle.name,
+                self.defining_function.name,
+                self.defining_function.depth,
+            )
+        )
+
     @property
     def port(self) -> PortDeclaration:
         return PortDeclaration(
@@ -485,15 +495,14 @@ class CapturedVars:
             (
                 captured_handle.handle
                 if _same_closure(current_function, captured_handle.defining_function)
-                else HandleBinding(name=captured_handle.mangled_name)
+                else captured_handle.mangled_handle
             )
             for captured_handle in self._captured_handles
         ]
         return args
 
-    def get_captured_mapping(self) -> SymbolRenaming:
-        mapping: SymbolRenaming
-        mapping = {
+    def get_immediate_captured_mapping(self) -> SymbolRenaming:
+        return {
             captured_handle.handle: [
                 SymbolPart(
                     source_handle=captured_handle.handle,
@@ -504,7 +513,21 @@ class CapturedVars:
             for captured_handle in self._captured_handles
             if not captured_handle.is_propagated
         }
-        mapping |= {
+
+    def get_propagated_captured_mapping(self) -> SymbolRenaming:
+        return {
+            captured_handle.mangled_handle: [
+                SymbolPart(
+                    source_handle=captured_handle.mangled_handle,
+                    target_var_name=captured_handle.mangled_name,
+                    target_var_type=captured_handle.quantum_type,
+                )
+            ]
+            for captured_handle in self._captured_handles
+        }
+
+    def get_classical_captured_mapping(self) -> SymbolRenaming:
+        return {
             (handle := HandleBinding(name=captured_classical_var.name)): [
                 HandleRenaming(
                     source_handle=handle,
@@ -514,7 +537,6 @@ class CapturedVars:
             for captured_classical_var in self._captured_classical_vars
             if not captured_classical_var.is_propagated
         }
-        return mapping
 
     def init_var(self, var_name: str, defining_function: "FunctionClosure") -> None:
         self._handle_states.append((var_name, defining_function, False))

classiq/model_expansions/closure.py

@@ -8,6 +8,15 @@ from typing import Any, Optional
 from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
+    ClassicalProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
+    ClassicalStructProxy,
+)
+from classiq.interface.generator.expressions.proxies.classical.utils import (
+    get_proxy_type,
+)
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
@@ -139,6 +148,10 @@ def _evaluated_arg_to_str(arg: Any) -> str:
         return _evaluated_one_operand_to_str(arg)
     if isinstance(arg, list) and arg and isinstance(arg[0], FunctionClosure):
         return _evaluated_operands_list_to_str(arg)
+    if isinstance(arg, ClassicalProxy):
+        if isinstance(arg, ClassicalStructProxy):
+            return repr(arg.struct_declaration)
+        return repr(get_proxy_type(arg))
     return evaluated_classical_param_to_str(arg)
 
 

classiq/model_expansions/evaluators/argument_types.py

@@ -34,9 +34,10 @@ def add_information_from_output_arguments(
         if parameter.direction != PortDeclarationDirection.Output:
             continue
 
-        copy_type_information(
-            parameter.quantum_type,
-            argument_as_quantum_symbol.quantum_type,
-            str(argument_as_quantum_symbol.handle),
-        )
+        if parameter.quantum_type.is_evaluated:
+            copy_type_information(
+                parameter.quantum_type,
+                argument_as_quantum_symbol.quantum_type,
+                str(argument_as_quantum_symbol.handle),
+            )
     return args

classiq/model_expansions/evaluators/type_type_match.py

@@ -85,6 +85,7 @@ def _check_classical_type_match(
 ) -> None:
     if (
         not isinstance(op_param, AnonClassicalParameterDeclaration)
-        or decl_param.classical_type != op_param.classical_type
+        or decl_param.classical_type.clear_flags()
+        != op_param.classical_type.clear_flags()
     ):
         raise ClassiqExpansionError(error_message)

classiq/model_expansions/generative_functions.py

@@ -81,11 +81,14 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated)
         ]
     classical_value = evaluated.value
     if isinstance(classical_value, QmodStructInstance):
-        return CParamStruct(
-            expr=param.name,
-            struct_type=Struct(name=classical_value.struct_declaration.name),
-            qmodule=QMODULE,
-        )
+        if param.classical_type.is_purely_declarative:
+            return CParamStruct(
+                expr=param.name,
+                struct_type=Struct(name=classical_value.struct_declaration.name),
+                qmodule=QMODULE,
+            )
+        else:
+            return get_sdk_compatible_python_object(dict(classical_value.fields))
     if isinstance(classical_value, ClassicalProxy):
         return create_param(
             str(classical_value.handle), get_proxy_type(classical_value), QMODULE
@@ -111,15 +114,18 @@ class _InterpreterExpandable(QFunc):
             for name, func in self._qmodule.native_defs.items()
             if name not in self._interpreter._top_level_scope
         }
+        generative_functions = self._qmodule.generative_functions
         self._interpreter.update_declarative_functions(
             declarative_functions, self._qmodule
         )
-        self._interpreter.update_generative_functions(
-            self._qmodule.generative_functions
-        )
+        self._interpreter.update_generative_functions(generative_functions)
         func_decls = self._get_function_declarations()
         for dec_func in declarative_functions.values():
             resolve_function_calls(dec_func, func_decls)
+        self._interpreter.infer_symbolic_parameters(
+            list(declarative_functions.values()),
+            [func.func_decl for func in generative_functions.values()],
+        )
         resolve_function_calls(dummy_function, func_decls)
         stmt = dummy_function.body[-1]
         with generative_mode_context(False):

classiq/model_expansions/interpreters/base_interpreter.py

@@ -9,14 +9,15 @@ from typing import Any, cast
 import sympy
 from pydantic import ValidationError
 
-from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.debug_info.debug_info import (
+    new_function_debug_info_by_node,
+)
 from classiq.interface.exceptions import (
     ClassiqError,
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
@@ -237,20 +238,16 @@ class BaseInterpreter:
             if source_ref is not None
             else nullcontext()
         )
-        if statement.uuid not in self._model.debug_info:
-            self._model.debug_info[statement.uuid] = FunctionDebugInfo(
-                name="",
-                parameters={},
-                level=OperationLevel.QMOD_STATEMENT,
-                statement_type=None,
-                is_allocate_or_free=False,
-                is_inverse=False,
-                port_to_passed_variable_map={},
-                node=statement._as_back_ref(),
-            )
+        self.add_to_debug_info(statement)
         with error_context, self._builder.source_ref_context(source_ref):
             self.emit(statement)
 
+    def add_to_debug_info(self, statement: QuantumStatement) -> None:
+        if statement.uuid not in self._model.debug_info:
+            self._model.debug_info[statement.uuid] = new_function_debug_info_by_node(
+                statement  # type: ignore[arg-type]
+            )
+
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context:
             if isinstance(operation, FunctionClosure) and (

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -4,21 +4,42 @@ import os
 from pydantic import ValidationError
 
 from classiq.interface.exceptions import ClassiqError
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
 from classiq.interface.source_reference import SourceReference
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.interpreters.generative_interpreter import (
     GenerativeInterpreter,
 )
+from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
 from classiq.model_expansions.quantum_operations.quantum_function_call import (
     DeclarativeQuantumFunctionCallEmitter,
 )
 from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.visitors.symbolic_param_inference import (
+    SymbolicParamInference,
+)
 from classiq.qmod.model_state_container import QMODULE
 
 
 class FrontendGenerativeInterpreter(GenerativeInterpreter):
+    def infer_symbolic_parameters(
+        self,
+        functions: list[NativeFunctionDefinition],
+        additional_signatures: (
+            list[NamedParamsQuantumFunctionDeclaration] | None
+        ) = None,
+    ) -> None:
+        SymbolicParamInference(functions, additional_signatures).infer()
+
+    def emit_allocate(self, allocate: Allocate) -> None:
+        AllocateEmitter(self, allow_symbolic_size=True).emit(allocate)
+
     def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
         DeclarativeQuantumFunctionCallEmitter(self).emit(call)
 

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -93,17 +93,25 @@ class GenerativeInterpreter(BaseInterpreter):
         add_generative_functions_to_scope(
             generative_functions, self._top_level_scope, override_atomic=True
         )
+        self.infer_symbolic_parameters(
+            model.functions, [gen_func.func_decl for gen_func in generative_functions]
+        )
+
+    def infer_symbolic_parameters(
+        self,
+        functions: list[NativeFunctionDefinition],
+        additional_signatures: (
+            list[NamedParamsQuantumFunctionDeclaration] | None
+        ) = None,
+    ) -> None:
+        pass
 
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
-        renamed_params = [
-            param.rename(function.pos_rename_params[idx])
-            for idx, param in enumerate(function.func_decl.positional_arg_declarations)
-        ]
         func_decl = NamedParamsQuantumFunctionDeclaration(
             name=self._counted_name_allocator.allocate(
                 function.func_decl.name or "<lambda>"
             ),
-            positional_arg_declarations=renamed_params,
+            positional_arg_declarations=function.named_func_decl.positional_arg_declarations,
         )
 
         closure_class: type[FunctionClosure]

classiq/model_expansions/quantum_operations/allocate.py

@@ -1,7 +1,10 @@
+from typing import TYPE_CHECKING
+
+import sympy
+
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import NestedHandleBinding
 from classiq.interface.model.quantum_type import QuantumBitvector
@@ -10,8 +13,17 @@ from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_inf
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import QuantumSymbol
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
 
 class AllocateEmitter(Emitter[Allocate]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", allow_symbolic_size: bool = False
+    ) -> None:
+        super().__init__(interpreter)
+        self._allow_symbolic_size = allow_symbolic_size
+
     def emit(self, allocate: Allocate, /) -> bool:
         target: QuantumSymbol = self._interpreter.evaluate(allocate.target).as_type(
             QuantumSymbol
@@ -22,10 +34,10 @@ class AllocateEmitter(Emitter[Allocate]):
                 f"Cannot allocate partial quantum variable {str(target.handle)!r}"
             )
 
-        size = self._get_var_size(target, allocate.size)
+        size_expr = self._get_var_size(target, allocate.size)
         allocate = allocate.model_copy(
             update=dict(
-                size=Expression(expr=str(size)),
+                size=Expression(expr=size_expr),
                 target=target.handle,
                 back_ref=allocate.uuid,
             )
@@ -34,27 +46,29 @@ class AllocateEmitter(Emitter[Allocate]):
         self.emit_statement(allocate)
         return True
 
-    def _get_var_size(self, target: QuantumSymbol, size: Expression | None) -> int:
+    def _get_var_size(self, target: QuantumSymbol, size: Expression | None) -> str:
         if size is None:
             if not target.quantum_type.is_evaluated:
                 raise ClassiqValueError(
                     f"Could not infer the size of variable {str(target.handle)!r}"
                 )
-            return target.quantum_type.size_in_bits
+            return str(target.quantum_type.size_in_bits)
 
         size_value = self._interpreter.evaluate(size).value
+        if self._allow_symbolic_size and isinstance(size_value, sympy.Basic):
+            return str(size_value)
         if not isinstance(size_value, (int, float)):
             raise ClassiqValueError(
                 f"The number of allocated qubits must be an integer. Got "
                 f"{str(size_value)!r}"
             )
-        size_value = int(size_value)
+        size_expr = str(size_value)
         copy_type_information(
-            QuantumBitvector(length=Expression(expr=str(size_value))),
+            QuantumBitvector(length=Expression(expr=size_expr)),
             target.quantum_type,
             str(target.handle),
         )
-        return size_value
+        return size_expr
 
     def _register_debug_info(self, allocate: Allocate) -> None:
         if (
@@ -67,9 +81,6 @@ class AllocateEmitter(Emitter[Allocate]):
             parameters["num_qubits"] = allocate.size.expr
         self._debug_info[allocate.uuid] = FunctionDebugInfo(
             name="allocate",
-            parameters=parameters,
-            level=OperationLevel.QMOD_STATEMENT,
-            is_allocate_or_free=True,
             port_to_passed_variable_map={"ARG": str(allocate.target)},
             node=allocate._as_back_ref(),
         )

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -36,6 +36,8 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
 
     def _update_result_type(self, op: ArithmeticOperation) -> None:
         expr = self._evaluate_expression(op.expression)
+        if len(self._get_classical_vars_in_expression(expr)):
+            return
         symbols = self._get_symbols_in_expression(expr)
         expr_str = rename_variables(
             expr.expr,

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -24,7 +24,6 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -63,7 +62,6 @@ from classiq.model_expansions.quantum_operations.emitter import (
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.model_expansions.utils.text_utils import are, readable_list, s
-from classiq.qmod.builtins.functions import free
 from classiq.qmod.semantics.validation.signature_validation import (
     validate_function_signature,
 )
@@ -188,7 +186,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             positional_args=new_positional_args,
             back_ref=self._get_back_ref(propagated_debug_info),
         )
-        is_allocate_or_free = new_call.func_name == free.func_decl.name
 
         port_to_passed_variable_map = {
             arg_decl.name: str(evaluated_arg.value.handle)
@@ -197,8 +194,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         }
         self._debug_info[new_call.uuid] = FunctionDebugInfo(
             name=new_call.func_name,
-            level=OperationLevel.QMOD_FUNCTION_CALL,
-            is_allocate_or_free=is_allocate_or_free,
             port_to_passed_variable_map=port_to_passed_variable_map,
             node=new_call._as_back_ref(),
         )
@@ -263,11 +258,11 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             chain.from_iterable((func_def.positional_arg_declarations, captured_ports))
         )
 
-        if not function_context.is_lambda:
-            return func_def
-        func_def.body = self.rewrite(
-            func_def.body, captured_vars.get_captured_mapping()
-        )
+        rewrite_mapping = dict(captured_vars.get_propagated_captured_mapping())
+        if function_context.is_lambda:
+            rewrite_mapping |= captured_vars.get_immediate_captured_mapping()
+            rewrite_mapping |= captured_vars.get_classical_captured_mapping()
+        func_def.body = self.rewrite(func_def.body, rewrite_mapping)
 
         return func_def
 

classiq/model_expansions/quantum_operations/emitter.py

@@ -13,7 +13,6 @@ import sympy
 
 from classiq.interface.debug_info.debug_info import (
     DebugInfoCollection,
-    new_function_debug_info_by_node,
 )
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.evaluated_expression import (
@@ -161,10 +160,7 @@ class Emitter(Generic[QuantumStatementT], ABC):
         self._update_captured_classical_vars(statement)
         if isinstance(statement, QuantumOperation):
             self._update_captured_vars(statement)
-        if statement.uuid not in self._interpreter._model.debug_info:
-            self._interpreter._model.debug_info[statement.uuid] = (
-                new_function_debug_info_by_node(statement)  # type:ignore[arg-type]
-            )
+        self._interpreter.add_to_debug_info(statement)
         self._builder.emit_statement(statement)
 
     def _update_captured_classical_vars(self, stmt: QuantumStatement) -> None:

classiq/model_expansions/quantum_operations/expression_evaluator.py

@@ -33,5 +33,6 @@ class ExpressionEvaluator(Emitter[QuantumOperation]):
         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

classiq/model_expansions/quantum_operations/handle_evaluator.py

@@ -24,5 +24,6 @@ class HandleEvaluator(Emitter[QuantumOperation]):
         op = op.model_copy(
             update={self._handle_name: evaluated_handle, "back_ref": op.uuid}
         )
+        self._interpreter.add_to_debug_info(op)
         self._interpreter.emit(op)
         return True

classiq/model_expansions/transformers/model_renamer.py

@@ -92,7 +92,9 @@ class _ReplaceSplitVarsExpressions(ModelTransformer):
     ) -> QuantumExpressionOperation:
         op = cast(QuantumExpressionOperation, self.generic_visit(op))
         previous_var_handles = list(op._var_handles)
-        op._var_handles = self.visit(op._var_handles)
+        op._var_handles = _ReplaceSplitVarsHandles(self._symbol_mapping).visit(
+            op._var_handles
+        )
         op._var_types = {
             new_handle.name: op._var_types.get(
                 new_handle.name, op._var_types[previous_handle.name]