classiq 0.54.0__py3-none-any.whl → 0.56.0__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.54.0'
+SEMVER_VERSION = '0.56.0'
 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/functions/builtins/internal_operators.py

@@ -3,6 +3,14 @@ CONTROL_OPERATOR_NAME = "control"
 INVERT_OPERATOR_NAME = "invert"
 REPEAT_OPERATOR_NAME = "iteration"
 POWER_OPERATOR_NAME = "power"
-COMPUTE_OPERATOR_NAME = "compute"
 UNCOMPUTE_OPERATOR_NAME = "uncompute"
 WITHIN_APPLY_NAME = "within_apply"
+
+All_BUILTINS_OPERATORS = {
+    CONTROL_OPERATOR_NAME,
+    INVERT_OPERATOR_NAME,
+    REPEAT_OPERATOR_NAME,
+    POWER_OPERATOR_NAME,
+    UNCOMPUTE_OPERATOR_NAME,
+    WITHIN_APPLY_NAME,
+}

classiq/interface/generator/generated_circuit_data.py

@@ -59,7 +59,6 @@ class GeneratedFunction(pydantic.BaseModel):
     registers: list[GeneratedRegister] = list()
     depth: Optional[int] = pydantic.Field(default=None)
     width: Optional[int] = pydantic.Field(default=None)
-    released_auxiliary_qubits: list[int] = list()
     dangling_inputs: dict[str, GeneratedRegister] = dict()
     dangling_outputs: dict[str, GeneratedRegister] = dict()
 

classiq/interface/generator/model/preferences/preferences.py

@@ -154,6 +154,10 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         "Setting this option to False can potentially speed up the synthesis, and is "
         "recommended for executing iterative algorithms.",
     )
+    synthesize_all_separately: bool = pydantic.Field(
+        default=False,
+        description="If true, all functions will be synthesized separately",
+    )
     output_format: PydanticConstrainedQuantumFormatList = pydantic.Field(
         default=[QuantumFormat.QASM],
         description="The quantum circuit output format(s). ",

classiq/interface/generator/types/compilation_metadata.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel, Field
+
+
+class CompilationMetadata(BaseModel):
+    should_synthesize_separately: bool = Field(default=False)

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

@@ -1,3 +1,4 @@
+from collections import Counter
 from typing import Any, Optional
 
 import pydantic
@@ -23,7 +24,7 @@ class OperationType(StrEnum):
 class OperationData(pydantic.BaseModel):
     approximated_depth: Optional[int] = None
     width: int
-    gate_count: dict[str, int] = pydantic.Field(default_factory=dict)
+    gate_count: Counter[str] = pydantic.Field(default_factory=dict)
 
 
 class CircuitMetrics(pydantic.BaseModel):
@@ -104,6 +105,8 @@ 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
     operation_links: OperationLinks
@@ -118,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/control.py

@@ -1,10 +1,12 @@
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, Optional
 
 import pydantic
 
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumExpressionOperation,
 )
+from classiq.interface.model.quantum_type import QuantumType
 
 if TYPE_CHECKING:
     from classiq.interface.model.statement_block import StatementBlock
@@ -13,8 +15,12 @@ if TYPE_CHECKING:
 class Control(QuantumExpressionOperation):
     kind: Literal["Control"]
     body: "StatementBlock"
+    else_block: Optional["StatementBlock"] = None
 
     _ctrl_size: int = pydantic.PrivateAttr(default=0)
+    _result_type: Optional[QuantumType] = pydantic.PrivateAttr(
+        default=None,
+    )
 
     @property
     def ctrl_size(self) -> int:
@@ -22,3 +28,18 @@ class Control(QuantumExpressionOperation):
 
     def set_ctrl_size(self, ctrl_size: int) -> None:
         self._ctrl_size = ctrl_size
+
+    @property
+    def result_type(self) -> QuantumType:
+        assert self._result_type is not None
+        return self._result_type
+
+    def initialize_var_types(
+        self,
+        var_types: dict[str, QuantumType],
+        machine_precision: int,
+    ) -> None:
+        super().initialize_var_types(var_types, machine_precision)
+        self._result_type = compute_arithmetic_result_type(
+            self.expression.expr, var_types, machine_precision
+        )

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/model.py

@@ -15,6 +15,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.generator.quantum_function_call import SUFFIX_RANDOMIZER
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
@@ -98,6 +99,9 @@ class Model(VersionedModel, ASTNode):
     debug_info: DebugInfoCollection = pydantic.Field(
         default_factory=DebugInfoCollection
     )
+    functions_compilation_metadata: dict[str, CompilationMetadata] = pydantic.Field(
+        default_factory=dict
+    )
 
     @property
     def main_func(self) -> NativeFunctionDefinition:

classiq/interface/model/native_function_definition.py

@@ -29,5 +29,5 @@ class NativeFunctionDefinition(NamedParamsQuantumFunctionDeclaration):
         default_factory=list, description="List of function calls to perform."
     )
     synthesis_data: FunctionSynthesisData = pydantic.Field(
-        default_factory=FunctionSynthesisData,
+        default_factory=FunctionSynthesisData, deprecated=True, exclude=True
     )

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,8 +1,5 @@
 from collections.abc import Mapping, Sequence
-from typing import Literal, Optional
-
-import pydantic
-from pydantic_core.core_schema import ValidationInfo
+from typing import Literal
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
@@ -29,28 +26,7 @@ class ArithmeticOperationKind(StrEnum):
 class ArithmeticOperation(QuantumAssignmentOperation):
     kind: Literal["ArithmeticOperation"]
 
-    inplace_result: Optional[bool] = pydantic.Field(
-        description="Determines whether the result variable is initialized",
-        default=None,
-        exclude=True,
-    )
-
-    operation_kind: ArithmeticOperationKind = pydantic.Field(
-        default=None, validate_default=True
-    )
-
-    @pydantic.field_validator("operation_kind", mode="before")
-    @classmethod
-    def _propagate_inplace_result(
-        cls, operation_kind: Optional[ArithmeticOperationKind], info: ValidationInfo
-    ) -> ArithmeticOperationKind:
-        if operation_kind is None:
-            operation_kind = (
-                ArithmeticOperationKind.InplaceXor
-                if info.data["inplace_result"]
-                else ArithmeticOperationKind.Assignment
-            )
-        return operation_kind
+    operation_kind: ArithmeticOperationKind
 
     @property
     def is_inplace(self) -> bool:

classiq/interface/model/quantum_statement.py

@@ -75,6 +75,9 @@ class QuantumOperation(QuantumStatement):
     def set_generative_block(self, block_name: str, py_callable: Callable) -> None:
         self._generative_blocks[block_name] = py_callable
 
+    def remove_generative_block(self, block_name: str) -> None:
+        self._generative_blocks.pop(block_name)
+
     def get_generative_block(self, block_name: str) -> Callable:
         return self._generative_blocks[block_name]
 
@@ -83,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

@@ -1,14 +1,21 @@
+import json
+import uuid
 from collections import defaultdict
-from collections.abc import Sequence
+from collections.abc import Collection, Sequence
 from dataclasses import dataclass, field
-from functools import cached_property
+from functools import cached_property, singledispatch
+from symtable import Symbol
 from typing import Any, Optional, Union
 
 from typing_extensions import Self
 
-from classiq.interface.exceptions import ClassiqInternalExpansionError
+from classiq.interface.exceptions import (
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    All_BUILTINS_OPERATORS,
+)
 from classiq.interface.generator.visitor import Visitor
-from classiq.interface.model.native_function_definition import FunctionSynthesisData
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
@@ -20,8 +27,14 @@ from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
+from classiq import ClassicalParameterDeclaration
 from classiq.model_expansions.expression_renamer import ExpressionRenamer
-from classiq.model_expansions.scope import Scope
+from classiq.model_expansions.scope import (
+    Evaluated,
+    QuantumSymbol,
+    Scope,
+    evaluated_to_str as evaluated_classical_param_to_str,
+)
 from classiq.qmod.builtins.functions import permute
 from classiq.qmod.quantum_function import GenerativeQFunc
 
@@ -52,7 +65,21 @@ class FunctionClosure(Closure):
     is_lambda: bool = False
     is_atomic: bool = False
     signature_scope: Scope = field(default_factory=Scope)
-    synthesis_data: FunctionSynthesisData = field(default_factory=FunctionSynthesisData)
+
+    # creates a unique id for the function closure based on the arguments values.
+    # The closure is changing across the interpreter flow so it's closure_id may change
+    @property
+    def closure_id(self) -> str:
+        # builtins operators have side effects, so  generate a unique id for than
+        # may create a bugs. Therefore, with each call to closure_id a new id is
+        # created
+        if self.is_lambda or self.name in All_BUILTINS_OPERATORS:
+            signature = str(uuid.uuid4())
+        else:
+            signature = _generate_closure_id(
+                self.positional_arg_declarations, self.scope.data.values()
+            )
+        return f"{self.name}__{signature}"
 
     @property
     def body(self) -> Sequence[QuantumStatement]:
@@ -77,7 +104,6 @@ class FunctionClosure(Closure):
         expr_renamer: Optional[ExpressionRenamer] = None,
         is_lambda: bool = False,
         is_atomic: bool = False,
-        synthesis_data: Optional[FunctionSynthesisData] = None,
         **kwargs: Any,
     ) -> Self:
         if expr_renamer:
@@ -90,9 +116,6 @@ class FunctionClosure(Closure):
                 body = expr_renamer.visit(body)
 
         blocks = {"body": body} if body is not None else {}
-        synthesis_data = (
-            synthesis_data if synthesis_data is not None else FunctionSynthesisData()
-        )
         return cls(
             name,
             blocks,
@@ -100,7 +123,6 @@ class FunctionClosure(Closure):
             positional_arg_declarations,
             is_lambda,
             is_atomic,
-            synthesis_data=synthesis_data,
             **kwargs,
         )
 
@@ -108,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)
 
 
@@ -171,3 +195,44 @@ class VariableCollector(Visitor):
             defining_function = lambda_environment[var].defining_function
             if defining_function is not None:
                 self._variables[var].add(defining_function.name)
+
+
+def _generate_closure_id(
+    args_declaration: Sequence[PositionalArg], evaluated_args: Collection[Evaluated]
+) -> str:
+    args_signature: dict = {}
+    for arg_declara, eval_arg in zip(args_declaration, evaluated_args):
+        args_signature |= _generate_arg_id(arg_declara, eval_arg)
+    return json.dumps(args_signature)
+
+
+def _generate_arg_id(
+    arg_declaration: PositionalArg, evaluated_arg: Evaluated
+) -> dict[str, str]:
+    arg_value = evaluated_arg.value
+    arg_name = arg_declaration.name
+    if isinstance(arg_declaration, ClassicalParameterDeclaration):
+        return {arg_name: evaluated_classical_param_to_str(arg_value)}
+    return {arg_name: _evaluated_arg_to_str(arg_value)}
+
+
+@singledispatch
+def _evaluated_arg_to_str(arg: Any) -> str:
+    if isinstance(arg, str):
+        return arg
+    return str(uuid.uuid4())
+
+
+@_evaluated_arg_to_str.register
+def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
+    return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
+
+
+@_evaluated_arg_to_str.register
+def _evaluated_symbol_to_str(port: Symbol) -> str:
+    return repr(port)
+
+
+@_evaluated_arg_to_str.register
+def _evaluated_operand_to_str(operand: FunctionClosure) -> str:
+    return operand.closure_id