classiq 0.55.0__py3-none-any.whl → 0.56.1__py3-none-any.whl

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.55.0'
+SEMVER_VERSION = '0.56.1'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/debug_info/debug_info.py

@@ -5,6 +5,7 @@ from uuid import UUID
 
 from pydantic import BaseModel, Field
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.generated_circuit_data import (
     FunctionDebugInfoInterface,
     OperationLevel,
@@ -13,11 +14,21 @@ from classiq.interface.generator.generated_circuit_data import (
 ParameterValue = Union[float, int, str, None]
 
 
+class StatementType(StrEnum):
+    CONTROL = "control"
+    POWER = "power"
+    INVERT = "invert"
+    WITHIN_APPLY = "within_apply"
+    ASSIGNMENT = "assignment"
+    REPEAT = "repeat"
+
+
 class FunctionDebugInfo(BaseModel):
     name: str
     # Parameters describe classical parameters passed to function
     parameters: dict[str, str]
     level: OperationLevel
+    statement_type: Union[StatementType, None] = None
     is_allocate_or_free: bool = Field(default=False)
     is_inverse: bool = Field(default=False)
     port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)

classiq/interface/executor/result.py

@@ -315,9 +315,6 @@ class EstimationMetadata(BaseModel, extra="allow"):
 
 class EstimationResult(BaseModel, QmodPyObject):
     value: Complex = pydantic.Field(..., description="Estimation for the operator")
-    variance: Optional[Complex] = pydantic.Field(
-        description="Variance of the estimation", default=None
-    )
     metadata: EstimationMetadata = pydantic.Field(
         ..., description="Metadata for the estimation"
     )

classiq/interface/generator/visitor.py

@@ -1,8 +1,9 @@
-from collections import abc
+from collections import abc, defaultdict
 from collections.abc import Collection, Mapping, Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
     Optional,
     TypeVar,
     Union,
@@ -84,6 +85,17 @@ class Transformer(Visitor):
     def visit_dict(self, node: dict[Key, NodeType]) -> dict[Key, RetType]:
         return {key: self.visit(value) for key, value in node.items()}
 
+    def visit_defaultdict(
+        self, node: defaultdict[Key, NodeType]
+    ) -> defaultdict[Key, RetType]:
+        new_default_factory: Callable[[], RetType] | None = None
+        if (default_factory := node.default_factory) is not None:
+
+            def new_default_factory() -> RetType:
+                return self.visit(default_factory())  # type: ignore[misc]
+
+        return defaultdict(new_default_factory, self.visit_dict(node))
+
     def visit_tuple(self, node: tuple[NodeType, ...]) -> tuple[RetType, ...]:
         return tuple(self.visit(value) for value in node)
 

classiq/interface/ide/visual_model.py

@@ -105,6 +105,7 @@ class AtomicGate(StrEnum):
 
 class Operation(pydantic.BaseModel):
     name: str
+    qasm_name: str = pydantic.Field(default="")
     details: str = pydantic.Field(default="")
     children: list["Operation"]
     operation_data: Optional[OperationData] = None
@@ -120,6 +121,7 @@ class Operation(pydantic.BaseModel):
     gate: AtomicGate = pydantic.Field(
         default=AtomicGate.UNKNOWN, description="Gate type"
     )
+    is_daggered: bool = pydantic.Field(default=False)
 
 
 class ProgramVisualModel(VersionedModel):

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "4"
+INTERFACE_VERSION = "5"

classiq/interface/model/handle_binding.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, Any, Union
 
 import pydantic
 from pydantic import ConfigDict, Field
+from typing_extensions import Self
 
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
@@ -46,6 +47,16 @@ class HandleBinding(ASTNode):
             for self_prefix, other_prefix in zip(self_prefixes, other_prefixes)
         )
 
+    def rename(self, name: str) -> Self:
+        return self.model_copy(update=dict(name=name))
+
+    def replace_prefix(
+        self, prefix: "HandleBinding", replacement: "HandleBinding"
+    ) -> "HandleBinding":
+        if self == prefix:
+            return replacement
+        return self
+
 
 class NestedHandleBinding(HandleBinding):
     base_handle: "ConcreteHandleBinding"
@@ -70,6 +81,23 @@ class NestedHandleBinding(HandleBinding):
     def prefixes(self) -> Sequence["HandleBinding"]:
         return list(chain.from_iterable([self.base_handle.prefixes(), [self]]))
 
+    def rename(self, name: str) -> Self:
+        return self.model_copy(
+            update=dict(name=name, base_handle=self.base_handle.rename(name))
+        )
+
+    def replace_prefix(
+        self, prefix: HandleBinding, replacement: HandleBinding
+    ) -> HandleBinding:
+        if self == prefix:
+            return replacement
+        new_base_handle = self.base_handle.replace_prefix(prefix, replacement)
+        if new_base_handle is not self.base_handle:
+            return self.model_copy(
+                update=dict(name=new_base_handle.name, base_handle=new_base_handle)
+            )
+        return self
+
 
 class SubscriptHandleBinding(NestedHandleBinding):
     index: Expression

classiq/interface/model/quantum_statement.py

@@ -86,3 +86,6 @@ class QuantumOperation(QuantumStatement):
 
     def is_generative(self) -> bool:
         return len(self._generative_blocks) > 0
+
+    def clear_generative_blocks(self) -> None:
+        self._generative_blocks.clear()

classiq/model_expansions/capturing/mangling_utils.py

@@ -1,11 +1,13 @@
 import re
 
 from classiq.interface.generator.compiler_keywords import CAPTURE_SUFFIX
+from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
 
 IDENTIFIER_PATTERN = r"[a-zA-Z_][a-zA-Z0-9_]*"
 CAPTURE_PATTERN = re.compile(
     rf"({IDENTIFIER_PATTERN}){CAPTURE_SUFFIX}{IDENTIFIER_PATTERN}__"
 )
+ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
 
 
 def mangle_captured_var_name(var_name: str, defining_function: str) -> str:
@@ -15,3 +17,23 @@ def mangle_captured_var_name(var_name: str, defining_function: str) -> str:
 def demangle_name(name: str) -> str:
     match = re.match(CAPTURE_PATTERN, name)
     return match.group(1) if match else name
+
+
+def demangle_handle(handle: HandleBinding) -> HandleBinding:
+    name = handle.name
+    if HANDLE_ID_SEPARATOR not in name:
+        return handle
+    if ARRAY_CAST_SUFFIX in name:
+        return HandleBinding(name=name.split(ARRAY_CAST_SUFFIX)[0])
+    name = re.sub(r"_\d+$", "", name)
+    name_parts = name.split(HANDLE_ID_SEPARATOR)
+    new_name = name_parts[0]
+    for part in name_parts[1:]:
+        if re.fullmatch(r"\d+", part):
+            new_name += f"[{part}]"
+        elif re.fullmatch(r"\d+_\d+", part):
+            part_left, part_right = part.split("_")
+            new_name += f"[{part_left}:{part_right}]"
+        else:
+            new_name += f".{part}"
+    return handle.rename(new_name)

classiq/model_expansions/capturing/propagated_var_stack.py

@@ -9,12 +9,15 @@ from classiq.interface.exceptions import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import ArgValue
 from classiq.interface.model.quantum_statement import QuantumOperation
 
-from classiq.model_expansions.capturing.mangling_utils import mangle_captured_var_name
+from classiq.model_expansions.capturing.mangling_utils import (
+    demangle_handle,
+    mangle_captured_var_name,
+)
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.function_builder import OperationBuilder
 from classiq.model_expansions.scope import QuantumSymbol, Scope
@@ -25,9 +28,12 @@ class PropagatedVariable:
     symbol: QuantumSymbol
     direction: PortDeclarationDirection
     defining_function: str
+    handle: HandleBinding
 
     @property
     def name(self) -> str:
+        name = self.symbol.handle.name
+        assert name == self.handle.name
         return self.symbol.handle.name
 
 
@@ -99,21 +105,22 @@ class PropagatedVarStack:
         direction: PortDeclarationDirection,
     ) -> dict[PropagatedVariable, None]:
         return {
-            self._get_captured_var_with_direction(var.name, direction): None
+            self._get_captured_var_with_direction(var, direction): None
             for var in variables
             if self._is_captured(var.name)
         }
 
     def _get_captured_var_with_direction(
-        self, var_name: str, direction: PortDeclarationDirection
+        self, var_handle: HandleBinding, direction: PortDeclarationDirection
     ) -> PropagatedVariable:
-        defining_function = self._current_scope[var_name].defining_function
+        defining_function = self._current_scope[var_handle.name].defining_function
         if defining_function is None:
             raise ClassiqInternalExpansionError
         return PropagatedVariable(
-            symbol=self._current_scope[var_name].as_type(QuantumSymbol),
+            symbol=self._current_scope[var_handle.name].as_type(QuantumSymbol),
             direction=direction,
             defining_function=defining_function.name,
+            handle=var_handle,
         )
 
     def _is_captured(self, var_name: str) -> bool:
@@ -133,15 +140,16 @@ class PropagatedVarStack:
             for var in self._stack[-1]
         )
 
-    def get_propagated_variables(self) -> list[HandleBinding]:
-        propagated_var_names: list[str] = [
-            self._get_propagated_var_name(var) for var in self._stack[-1]
-        ]
-        return [
-            HandleBinding(name=name) for name in dict.fromkeys(propagated_var_names)
-        ]
+    def get_propagated_variables(self, flatten: bool) -> list[HandleBinding]:
+        return list(
+            dict.fromkeys(
+                [self._get_propagated_handle(var, flatten) for var in self._stack[-1]]
+            )
+        )
 
-    def _get_propagated_var_name(self, var: PropagatedVariable) -> str:
+    def _get_propagated_handle(
+        self, var: PropagatedVariable, flatten: bool
+    ) -> HandleBinding:
         if (
             var.defining_function == self._builder.current_function.name
             or not isinstance(
@@ -155,7 +163,9 @@ class PropagatedVarStack:
         else:
             handle_name = mangle_captured_var_name(var.name, var.defining_function)
             self._to_mangle[var] = handle_name
-        return handle_name
+        if flatten:
+            return HandleBinding(name=handle_name)
+        return var.handle.rename(handle_name)
 
     def _no_name_conflict(self, var: PropagatedVariable) -> bool:
         return var.name not in self._builder.current_function.colliding_variables
@@ -166,18 +176,19 @@ def validate_args_are_not_propagated(
 ) -> None:
     if not captured_vars:
         return
-    captured_var_names = {var.name for var in captured_vars}
-    arg_names = {
-        demangle_suffixes(arg.name) for arg in args if isinstance(arg, HandleBinding)
+    captured_handles = {demangle_handle(handle) for handle in captured_vars}
+    arg_handles = {
+        demangle_handle(arg) for arg in args if isinstance(arg, HandleBinding)
     }
-    if not captured_var_names.isdisjoint(arg_names):
-        vars_msg = f"Explicitly passed variables: {arg_names}, captured variables: {captured_var_names}"
+    if any(
+        arg_handle.overlaps(captured_handle)
+        for arg_handle in arg_handles
+        for captured_handle in captured_handles
+    ):
+        captured_handles_str = {str(handle) for handle in captured_handles}
+        arg_handles_str = {str(handle) for handle in arg_handles}
+        vars_msg = f"Explicitly passed variables: {arg_handles_str}, captured variables: {captured_handles_str}"
         raise ClassiqExpansionError(
             f"Cannot capture variables that are explicitly passed as arguments. "
             f"{vars_msg}"
         )
-
-
-# TODO this is not a good long-term solution
-def demangle_suffixes(name: str) -> str:
-    return name.split(HANDLE_ID_SEPARATOR)[0]

classiq/model_expansions/closure.py

@@ -130,8 +130,10 @@ class FunctionClosure(Closure):
         self, declaration: NamedParamsQuantumFunctionDeclaration
     ) -> Self:
         fields: dict = self.__dict__ | {
-            "positional_arg_declarations": declaration.positional_arg_declarations
+            "name": declaration.name,
+            "positional_arg_declarations": declaration.positional_arg_declarations,
         }
+        fields.pop("colliding_variables", 0)
         return type(self)(**fields)
 
 

classiq/model_expansions/function_builder.py

@@ -30,6 +30,7 @@ from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.model_expansions.capturing.captured_var_manager import update_captured_vars
 from classiq.model_expansions.capturing.mangling_utils import demangle_name
 from classiq.model_expansions.closure import Closure, FunctionClosure
+from classiq.model_expansions.scope import Scope
 
 ClosureType = TypeVar("ClosureType", bound=Closure)
 
@@ -77,10 +78,10 @@ class FunctionContext(OperationContext[FunctionClosure]):
 
 
 class OperationBuilder:
-    def __init__(self) -> None:
+    def __init__(self, functions_scope: Scope) -> None:
         self._operations: list[OperationContext] = []
         self._blocks: list[str] = []
-        self._counter = 0
+        self._functions_scope = functions_scope
 
     @property
     def current_operation(self) -> Closure:
@@ -158,8 +159,12 @@ class OperationBuilder:
     ) -> NativeFunctionDefinition:
         name = function_context.name
         if name != MAIN_FUNCTION_NAME:
-            name = f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}_{self._counter}"
-            self._counter += 1
+            idx = 0
+            new_name = name
+            while idx == 0 or new_name in self._functions_scope:
+                new_name = f"{name}_{LAMBDA_KEYWORD + '_0_0_' if function_context.is_lambda else ''}{EXPANDED_KEYWORD}_{idx}"
+                idx += 1
+            name = new_name
 
         new_parameters: list[PortDeclaration] = [
             param

classiq/model_expansions/interpreter.py

@@ -11,6 +11,7 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.bind_operation import BindOperation
@@ -81,6 +82,7 @@ from classiq.model_expansions.quantum_operations import (
 from classiq.model_expansions.quantum_operations.phase import PhaseEmitter
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.scope_initialization import (
+    add_constants_to_scope,
     add_entry_point_params_to_scope,
     get_main_renamer,
     init_top_level_scope,
@@ -107,7 +109,8 @@ class Interpreter:
         self._is_frontend = is_frontend
         self._model = model
         self._current_scope = Scope()
-        self._builder = OperationBuilder()
+        self._top_level_scope = self._current_scope
+        self._builder = OperationBuilder(self._top_level_scope)
         self._expanded_functions: dict[str, NativeFunctionDefinition] = {}
         self._propagated_var_stack = PropagatedVarStack(
             self._current_scope, self._builder
@@ -384,3 +387,6 @@ class Interpreter:
             + [gen_func.func_decl for gen_func in self._generative_functions]
             + list(self._expanded_functions.values())
         )
+
+    def add_constant(self, constant: Constant) -> None:
+        add_constants_to_scope([constant], self._top_level_scope)

classiq/model_expansions/quantum_operations/control.py

@@ -17,19 +17,24 @@ from classiq.interface.generator.functions.builtins.internal_operators import (
 )
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.control import Control
-from classiq.interface.model.handle_binding import HANDLE_ID_SEPARATOR, HandleBinding
+from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_type import QuantumBit, QuantumBitvector
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumType,
+)
 from classiq.interface.model.statement_block import ConcreteQuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq.model_expansions.capturing.mangling_utils import ARRAY_CAST_SUFFIX
 from classiq.model_expansions.capturing.propagated_var_stack import (
     validate_args_are_not_propagated,
 )
@@ -44,8 +49,6 @@ from classiq.model_expansions.quantum_operations.expression_operation import (
 from classiq.model_expansions.scope import Scope
 from classiq.qmod.builtins.functions.standard_gates import X
 
-ARRAY_CAST_SUFFIX = HANDLE_ID_SEPARATOR + "array_cast"
-
 
 class ControlEmitter(ExpressionOperationEmitter[Control]):
     def emit(self, control: Control, /) -> None:
@@ -53,6 +56,9 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
 
         arrays_with_subscript = self._get_symbols_to_split(condition)
         if len(arrays_with_subscript) > 0:
+            if control.is_generative():
+                with self._propagated_var_stack.capture_variables(control):
+                    control = self._expand_generative_control(control)
             self._emit_with_split(control, condition, arrays_with_subscript)
             return
 
@@ -86,16 +92,26 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         )
         return Expression(expr=f"{lhs} == 1")
 
+    def _expand_generative_control(self, control: Control) -> Control:
+        block_names = ["body"]
+        if control.has_generative_block("else_block"):
+            block_names += ["else_block"]
+        context = self._register_generative_context(
+            control, CONTROL_OPERATOR_NAME, block_names
+        )
+        new_blocks = {"body": context.statements("body")}
+        if "else_block" in block_names:
+            new_blocks["else_block"] = context.statements("else_block")
+        return control.model_copy(update=new_blocks)
+
     def _emit_canonical_control(self, control: Control) -> None:
         # canonical means control(q, body) where q is a single quantum variable
-        control = self._evaluate_types_in_expression(control, control.expression)
         with self._propagated_var_stack.capture_variables(control):
             self._emit_propagated(control)
 
     def _emit_propagated(self, control: Control) -> None:
         if control.is_generative():
-            context = self._register_generative_context(control, CONTROL_OPERATOR_NAME)
-            control = control.model_copy(update={"body": context.statements("body")})
+            control = self._expand_generative_control(control)
 
         if self._should_wrap_control(control):
             self._emit_wrapped(control)
@@ -121,7 +137,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         context = self._expand_operation(control_operation)
         validate_args_are_not_propagated(
             control.var_handles,
-            self._propagated_var_stack.get_propagated_variables(),
+            self._propagated_var_stack.get_propagated_variables(flatten=False),
         )
         self._update_control_state(control)
         self._builder.emit_statement(
@@ -134,7 +150,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         )
         validate_args_are_not_propagated(
             control.var_handles,
-            self._propagated_var_stack.get_propagated_variables(),
+            self._propagated_var_stack.get_propagated_variables(flatten=False),
         )
         self._update_control_state(control)
         self._builder.emit_statement(
@@ -197,6 +213,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
             action=[control_else_inner],
         )
         if control_else_inner.is_generative():
+            control_then.remove_generative_block("else_block")
             control_else_inner.set_generative_block(
                 "body", control_else_inner.get_generative_block("else_block")
             )
@@ -290,6 +307,15 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
         if isinstance(condition_val, QmodQNumProxy):
             raise ClassiqExpansionError(_condition_err_msg(condition_val))
 
+    def _get_updated_op_split_symbols(
+        self, op: Control, symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]]
+    ) -> Control:
+        new_body = self._rewrite(op.body, symbol_mapping)
+        new_else = None
+        if op.else_block is not None:
+            new_else = self._rewrite(op.else_block, symbol_mapping)
+        return op.model_copy(update=dict(body=new_body, else_block=new_else))
+
 
 def _condition_err_msg(condition_val: ExpressionValue) -> str:
     return (

classiq/model_expansions/quantum_operations/emitter.py

@@ -104,6 +104,10 @@ class Emitter(Generic[QuantumStatementT]):
     def _current_scope(self) -> Scope:
         return self._interpreter._current_scope
 
+    @property
+    def _top_level_scope(self) -> Scope:
+        return self._interpreter._top_level_scope
+
     @property
     def _expanded_functions(self) -> dict[str, NativeFunctionDefinition]:
         return self._interpreter._expanded_functions
@@ -156,6 +160,10 @@ class Emitter(Generic[QuantumStatementT]):
             if function_def is None:
                 function_def = self._builder.create_definition(function_context)
                 self._expanded_functions[closure_id] = function_def
+                self._top_level_scope[function_def.name] = Evaluated(
+                    value=function_context.closure.with_new_declaration(function_def)
+                )
+            new_declaration = function_def
             new_function_name = function_def.name
             compilation_metadata = self._functions_compilation_metadata.get(
                 function.name
@@ -194,8 +202,7 @@ class Emitter(Generic[QuantumStatementT]):
             is_allocate_or_free=is_allocate_or_free,
             port_to_passed_variable_map=port_to_passed_variable_map,
         )
-        if is_atomic:
-            new_call.set_func_decl(new_declaration)
+        new_call.set_func_decl(new_declaration)
         return new_call
 
     @staticmethod
@@ -236,7 +243,9 @@ class Emitter(Generic[QuantumStatementT]):
             arg.emit() for arg in evaluated_args if isinstance(arg.value, QuantumSymbol)
         ]
 
-        propagated_variables = self._propagated_var_stack.get_propagated_variables()
+        propagated_variables = self._propagated_var_stack.get_propagated_variables(
+            flatten=True
+        )
         validate_args_are_not_propagated(positional_args, propagated_variables)
         positional_args.extend(propagated_variables)
 
@@ -295,6 +304,7 @@ class Emitter(Generic[QuantumStatementT]):
         )
         context = self._interpreter._expand_operation(gen_closure)
         self._generative_contexts[context_name] = context
+        op.clear_generative_blocks()
         return context
 
     def _evaluate_expression(self, expression: Expression) -> Expression: