classiq 0.68.0__py3-none-any.whl → 0.69.0__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -22,10 +22,6 @@ from classiq.interface.execution.iqcc import (
     IQCCProbeAuthData,
     IQCCProbeAuthResponse,
 )
-from classiq.interface.execution.jobs import (
-    ExecutionJobDetailsV1,
-    ExecutionJobsQueryResultsV1,
-)
 from classiq.interface.execution.primitives import PrimitivesInput
 from classiq.interface.executor import execution_request
 from classiq.interface.generator import quantum_program as generator_result
@@ -218,7 +214,7 @@ class ApiWrapper:
         job_id: JobID,
         name: str,
         http_client: Optional[httpx.AsyncClient] = None,
-    ) -> ExecutionJobDetailsV1:
+    ) -> execution_request.ExecutionJobDetails:
         data = await cls._call_task(
             http_method=HTTPMethod.PATCH,
             url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}",
@@ -227,7 +223,7 @@ class ApiWrapper:
             },
             http_client=http_client,
         )
-        return ExecutionJobDetailsV1.model_validate(data)
+        return execution_request.ExecutionJobDetails.model_validate(data)
 
     @classmethod
     async def call_cancel_execution_job(
@@ -248,7 +244,7 @@ class ApiWrapper:
         offset: int,
         limit: int,
         http_client: Optional[httpx.AsyncClient] = None,
-    ) -> ExecutionJobsQueryResultsV1:
+    ) -> execution_request.ExecutionJobsQueryResults:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
             url=f"{routes.EXECUTION_JOBS_FULL_PATH}",
@@ -258,7 +254,7 @@ class ApiWrapper:
             },
             http_client=http_client,
         )
-        return ExecutionJobsQueryResultsV1.model_validate(data)
+        return execution_request.ExecutionJobsQueryResults.model_validate(data)
 
     @classmethod
     async def call_analysis_task(

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -24,7 +24,6 @@ from classiq.open_library.functions.utility_functions import (
 from classiq.qmod.builtins.functions import RX
 from classiq.qmod.builtins.operations import allocate, phase, repeat
 from classiq.qmod.cparam import CReal
-from classiq.qmod.create_model_function import create_model
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.qmod_variable import Output, QVar
@@ -75,17 +74,15 @@ class CombinatorialProblem:
             hadamard_transform(v)
             repeat(
                 self.num_layers_,
-                lambda i: [  # type:ignore[arg-type]
-                    phase(
-                        -self.cost_func(v), params[i]
-                    ),  # type:ignore[func-returns-value]
+                lambda i: [
+                    phase(-self.cost_func(v), params[i]),
                     apply_to_all(lambda q: RX(params[self.num_layers_ + i], q), v),
                 ],
             )
 
-        self.model_ = create_model(
-            main, constraints=constraints, preferences=preferences
-        )  # type:ignore[assignment]
+        self.model_ = main.create_model(
+            constraints=constraints, preferences=preferences
+        ).get_model()  # type:ignore[assignment]
         return self.model_  # type:ignore[return-value]
 
     def get_qprog(self) -> SerializedQuantumProgram:
@@ -199,13 +196,13 @@ def execute_qaoa(
         hadamard_transform(v)
         repeat(
             num_layers,
-            lambda i: [  # type:ignore[arg-type]
-                phase(-cost_func(v), params[i]),  # type:ignore[func-returns-value]
+            lambda i: [
+                phase(-cost_func(v), params[i]),
                 apply_to_all(lambda q: RX(params[num_layers + i], q), v),
             ],
         )
 
-    model = create_model(main)
+    model = main.create_model().get_model()
     qprog = synthesize(model)
 
     with ExecutionSession(qprog, execution_preferences) as es:

classiq/applications/qnn/gradients/quantum_gradient.py

@@ -18,7 +18,7 @@ class QuantumGradient(abc.ABC):
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
         *args: Any,
-        **kwargs: Any
+        **kwargs: Any,
     ) -> None:
         self._execute = execute
         self._post_process = post_process

classiq/applications/qnn/gradients/simple_quantum_gradient.py

@@ -71,7 +71,7 @@ class SimpleQuantumGradient(QuantumGradient):
         post_process: PostProcessFunction,
         epsilon: float = EPSILON,
         *args: Any,
-        **kwargs: Any
+        **kwargs: Any,
     ) -> None:
         super().__init__(quantum_program, execute, post_process)
         self._epsilon = epsilon

classiq/applications/qnn/torch_utils.py

@@ -94,7 +94,7 @@ def iter_inputs_weights(
     post_process: PostProcessFunction,
     *,
     expected_shape: Shape = (),
-    requires_grad: Optional[bool] = None
+    requires_grad: Optional[bool] = None,
 ) -> Tensor:
     if is_single_layer_circuit(weights):
         iter_weights = torch.reshape(weights, (1, weights.shape[0]))

classiq/execution/jobs.py

@@ -9,7 +9,6 @@ from classiq.interface.exceptions import (
     ClassiqAPIError,
     ClassiqError,
 )
-from classiq.interface.execution.jobs import ExecutionJobDetailsV1
 from classiq.interface.executor.execution_request import ExecutionJobDetails, JobCost
 from classiq.interface.executor.execution_result import ResultsCollection
 from classiq.interface.executor.result import (
@@ -26,8 +25,6 @@ from classiq._internals.async_utils import syncify_function
 from classiq._internals.client import client
 from classiq._internals.jobs import JobID, JobPoller
 
-_JobDetails = Union[ExecutionJobDetails, ExecutionJobDetailsV1]
-
 
 class ClassiqExecutionResultError(ClassiqError):
     def __init__(self, primitive: str) -> None:
@@ -37,10 +34,10 @@ class ClassiqExecutionResultError(ClassiqError):
 
 
 class ExecutionJob:
-    _details: _JobDetails
+    _details: ExecutionJobDetails
     _result: Optional[ResultsCollection]
 
-    def __init__(self, details: _JobDetails) -> None:
+    def __init__(self, details: ExecutionJobDetails) -> None:
         self._details = details
         self._result = None
 

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.68.0'
+SEMVER_VERSION = '0.69.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/quantum_backend_providers.py

@@ -172,15 +172,14 @@ class ClassiqNvidiaBackendNames(StrEnum):
 
     SIMULATOR = "nvidia_simulator"
     SIMULATOR_STATEVECTOR = "nvidia_simulator_statevector"
+    BRAKET_NVIDIA_SIMULATOR = "braket_nvidia_simulator"
+    BRAKET_NVIDIA_SIMULATOR_STATEVECTOR = "braket_nvidia_simulator_statevector"
 
 
 class IntelBackendNames(StrEnum):
     SIMULATOR = "intel_qsdk_simulator"
 
 
-AllClassiqBackendNames = Union[ClassiqSimulatorBackendNames, ClassiqNvidiaBackendNames]
-
-
 class GoogleNvidiaBackendNames(StrEnum):
     """
     Google backend names which Classiq Supports running on.

classiq/interface/chemistry/operator.py

@@ -1,5 +1,6 @@
 from collections.abc import Collection
 from functools import reduce
+from itertools import combinations
 from typing import (
     Any,
     Optional,
@@ -144,16 +145,19 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     @property
     def is_commutative(self) -> bool:
         return all(
-            self._is_sub_pauli_commutative(
-                [summand[0][qubit_num] for summand in self.pauli_list]
-            )
-            for qubit_num in range(self.num_qubits)
+            self._do_paulis_commute(first[0], second[0])
+            for first, second in combinations(self.pauli_list, 2)
         )
 
     @staticmethod
-    def _is_sub_pauli_commutative(qubit_pauli_string: Union[list[str], str]) -> bool:
-        unique_paulis = set(qubit_pauli_string) - {"I"}
-        return len(unique_paulis) <= 1
+    def _do_paulis_commute(
+        first: PydanticPauliMonomialStr, second: PydanticPauliMonomialStr
+    ) -> bool:
+        commute = True
+        for c1, c2 in zip(first, second):
+            if (c1 != "I") and (c2 != "I") and (c1 != c2):
+                commute = not commute
+        return commute
 
     @property
     def num_qubits(self) -> int:

classiq/interface/debug_info/back_ref_util.py

@@ -0,0 +1,22 @@
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.statement_block import (
+    ConcreteQuantumStatement,
+    StatementBlock,
+)
+
+"""
+This module contains helper functions to determine if a given quantum statement
+ is an allocation or free statement.
+"""
+
+
+def is_allocate_or_free(concrete_quantum_statement: ConcreteQuantumStatement) -> bool:
+    return isinstance(concrete_quantum_statement, Allocate) or (
+        isinstance(concrete_quantum_statement, QuantumFunctionCall)
+        and concrete_quantum_statement.function == "free"
+    )
+
+
+def is_allocate_or_free_by_backref(back_refs: StatementBlock) -> bool:
+    return len(back_refs) > 0 and is_allocate_or_free(back_refs[0])

classiq/interface/debug_info/debug_info.py

@@ -1,34 +1,23 @@
-import json
 from collections.abc import Mapping
-from typing import Any, Optional, Union
+from typing import Optional, Union
 from uuid import UUID
 
 from pydantic import BaseModel, Field
 
-from classiq.interface.enum_utils import StrEnum
+from classiq.interface.debug_info import back_ref_util
 from classiq.interface.generator.generated_circuit_data import (
     FunctionDebugInfoInterface,
     OperationLevel,
+    StatementType,
 )
 from classiq.interface.model.statement_block import ConcreteQuantumStatement
 
 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
+    level: OperationLevel = Field(default=OperationLevel.UNKNOWN)
     statement_type: Union[StatementType, None] = None
     is_allocate_or_free: bool = Field(default=False)
     is_inverse: bool = Field(default=False)
@@ -36,12 +25,13 @@ class FunctionDebugInfo(BaseModel):
     port_to_passed_variable_map: dict[str, str] = Field(default_factory=dict)
     node: Optional[ConcreteQuantumStatement] = None
 
-    @staticmethod
-    def param_controller(value: Any) -> str:
-        try:
-            return json.dumps(value)
-        except TypeError:
-            return repr(value)
+    @property
+    def is_allocate_or_free_(self) -> bool:
+        return (
+            back_ref_util.is_allocate_or_free(self.node)
+            if self.node is not None
+            else self.is_allocate_or_free
+        )
 
     def update_map_from_port_mapping(self, port_mapping: Mapping[str, str]) -> None:
         new_port_to_passed_variable_map = self.port_to_passed_variable_map.copy()

classiq/interface/executor/optimizer_preferences.py

@@ -21,6 +21,7 @@ class OptimizerType(StrEnum):
     L_BFGS_B = "L_BFGS_B"
     NELDER_MEAD = "NELDER_MEAD"
     ADAM = "ADAM"
+    SLSQP = "SLSQP"
 
 
 class OptimizerPreferences(BaseModel):

classiq/interface/generator/arith/arithmetic_param_getters.py

@@ -59,7 +59,7 @@ def get_params(
     machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None
+    target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
     operation = id2op(node_id)
     if target and not operation_allows_target(operation):
@@ -334,7 +334,7 @@ def logical_and_params_getter(
     machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None
+    target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
     return LogicalAnd(args=arg, target=target, machine_precision=machine_precision)
 
@@ -344,7 +344,7 @@ def logical_or_params_getter(
     machine_precision: int,
     output_size: Optional[int] = None,
     inplace_arg: Optional[str] = None,
-    target: Optional[RegisterArithmeticInfo] = None
+    target: Optional[RegisterArithmeticInfo] = None,
 ) -> ArithmeticOperationParams:
     return LogicalOr(args=arg, target=target, machine_precision=machine_precision)
 

classiq/interface/generator/functions/classical_type.py

@@ -1,8 +1,9 @@
 from typing import TYPE_CHECKING, Any, Literal, Union
 
 import pydantic
-from pydantic import ConfigDict
+from pydantic import ConfigDict, PrivateAttr
 from sympy import IndexedBase, Symbol
+from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.expressions.expression_types import RuntimeExpression
@@ -19,6 +20,8 @@ NamedSymbol = Union[IndexedBase, Symbol]
 
 
 class ClassicalType(HashableASTNode):
+    _is_generative: bool = PrivateAttr(default=False)
+
     def as_symbolic(self, name: str) -> Union[NamedSymbol, list[NamedSymbol]]:
         return Symbol(name)
 
@@ -27,6 +30,14 @@ class ClassicalType(HashableASTNode):
     def __str__(self) -> str:
         return str(type(self).__name__)
 
+    def set_generative(self) -> Self:
+        self._is_generative = True
+        return self
+
+    @property
+    def is_generative(self) -> bool:
+        return self._is_generative
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]

classiq/interface/generator/generated_circuit_data.py

@@ -2,16 +2,24 @@ import logging
 from typing import Literal, Optional, Union
 
 import pydantic
-from pydantic import ConfigDict
+from pydantic import ConfigDict, Field
 from typing_extensions import TypeAlias
 
+from classiq.interface.debug_info.back_ref_util import is_allocate_or_free_by_backref
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.register_role import RegisterRole
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
-from classiq.interface.model.statement_block import StatementBlock
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+from classiq.interface.model.statement_block import (
+    ConcreteQuantumStatement,
+    QuantumFunctionCall,
+    StatementBlock,
+)
 
 from classiq.model_expansions.capturing.mangling_utils import (
     demangle_capture_name,
@@ -120,35 +128,75 @@ class OperationLevel(StrEnum):
     UNKNOWN = "UNKNOWN"
 
 
-class OperationParameter(pydantic.BaseModel):
-    label: str
-    value: Optional[str] = None
+class StatementType(StrEnum):
+    CONTROL = "control"
+    POWER = "power"
+    INVERT = "invert"
+    WITHIN_APPLY = "within_apply"
+    ASSIGNMENT = "assignment"
+    REPEAT = "repeat"
 
 
 class FunctionDebugInfoInterface(pydantic.BaseModel):
-    generated_function: Optional[GeneratedFunction] = pydantic.Field(default=None)
+    generated_function: Optional[GeneratedFunction] = Field(default=None)
     children: list["FunctionDebugInfoInterface"]
     relative_qubits: tuple[int, ...]
-    absolute_qubits: Optional[tuple[int, ...]] = pydantic.Field(default=None)
-    is_basis_gate: Optional[bool] = pydantic.Field(default=None)
-    is_inverse: bool = pydantic.Field(default=False)
-    is_allocate_or_free: bool = pydantic.Field(default=False)
-    level: OperationLevel = pydantic.Field(default=OperationLevel.UNKNOWN)
-    parameters: list[OperationParameter] = list()
-    port_to_passed_variable_map: dict[str, str] = pydantic.Field(default={})
-    release_by_inverse: bool = pydantic.Field(default=False)
-    back_refs: StatementBlock = pydantic.Field(default_factory=list)
+    absolute_qubits: Optional[tuple[int, ...]] = Field(default=None)
+    is_basis_gate: Optional[bool] = Field(default=None)
+    is_inverse: bool = Field(default=False)
+    is_allocate_or_free: bool = Field(default=False)
+    level: OperationLevel = Field(default=OperationLevel.UNKNOWN)
+    port_to_passed_variable_map: dict[str, str] = Field(default={})
+    release_by_inverse: bool = Field(default=False)
+    back_refs: StatementBlock = Field(default_factory=list)
 
     model_config = ConfigDict(extra="allow")
     # Temporary field to store the override debug info for parallel old/new visualization
     override_debug_info: Optional["FunctionDebugInfoInterface"] = None
 
+    @property
+    def is_allocate_or_free_(self) -> bool:
+        """
+        temporary measure to handle the fact that in the current release we do not have
+        the backref, and therefore fallback to the old field of is_allocate_or_free
+        """
+        return (
+            is_allocate_or_free_by_backref(self.back_refs)
+            if bool(self.back_refs)
+            else self.is_allocate_or_free
+        )
+
     @property
     def name(self) -> str:
         if self.generated_function is None:
             return ""
         return self.generated_function.name
 
+    @property
+    def first_back_ref(self) -> Optional[ConcreteQuantumStatement]:
+        return self.back_refs[0] if self.back_refs else None
+
+    @property
+    def level_(self) -> OperationLevel:
+        # Temp fix for currently "supported" statements
+        if self.name in {StatementType.CONTROL, StatementType.POWER}:
+            return OperationLevel.QMOD_STATEMENT
+
+        back_ref = self.first_back_ref
+        if back_ref is None:
+            # This is the expected behavior for the case where there's not back ref.
+            # We will use it once we can rely on the existence of the back ref in
+            # all expected cases (non-engine calls)
+            # return OperationLevel.ENGINE_FUNCTION_CALL
+            return self.level
+        if isinstance(back_ref, QuantumFunctionCall):
+            return OperationLevel.QMOD_FUNCTION_CALL
+        # Temp "fix" for assignment statements until we have a way to fully
+        # distinguish them and to properly display them
+        if isinstance(back_ref, QuantumExpressionOperation):
+            return OperationLevel.ENGINE_FUNCTION_CALL
+        return OperationLevel.QMOD_STATEMENT
+
     @property
     def registers(self) -> list[GeneratedRegister]:
         if self.generated_function is None:
@@ -167,15 +215,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             return list()
         return self.generated_function.control_states
 
-    @staticmethod
-    def create_parameters_from_dict(
-        parameters: dict[str, str],
-    ) -> list[OperationParameter]:
-        return [
-            OperationParameter(label=key, value=value)
-            for key, value in parameters.items()
-        ]
-
     def propagate_absolute_qubits(self) -> "FunctionDebugInfoInterface":
         if self.absolute_qubits is None:
             return self

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -150,6 +150,7 @@ class Optimizer(IntEnum):
     L_BFGS_B = 3
     NELDER_MEAD = 4
     ADAM = 5
+    SLSQP = 6
 
 
 class Pauli(IntEnum):

classiq/interface/generator/types/enum_declaration.py

@@ -75,7 +75,7 @@ class EnumDeclaration(HashableASTNode):
 
 
 def declaration_from_enum(enum_type: EnumMeta) -> EnumDeclaration:
-    members: list[Enum] = list(enum_type)
+    members = _get_members(enum_type)
     return EnumDeclaration(
         name=enum_type.__name__,
         members={
@@ -83,3 +83,14 @@ def declaration_from_enum(enum_type: EnumMeta) -> EnumDeclaration:
             for member in sorted(members, key=lambda member: member.value)
         },
     )
+
+
+def _get_members(enum_type: EnumMeta) -> list[Enum]:
+    members: list[Enum] = list(enum_type)
+    for member in members:
+        if not isinstance(member.value, int):
+            raise ClassiqValueError(
+                f"Member {member.name!r} of enum {enum_type.__name__!r} has a "
+                f"non-integer value {member.value!r}"
+            )
+    return members

classiq/interface/ide/visual_model.py

@@ -7,7 +7,6 @@ from pydantic import ConfigDict
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.generated_circuit_data import (
     OperationLevel,
-    OperationParameter,
 )
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
 from classiq.interface.helpers.versioned_model import VersionedModel
@@ -114,7 +113,6 @@ class Operation(pydantic.BaseModel):
     control_qubits: tuple[int, ...] = pydantic.Field(default_factory=tuple)
     auxiliary_qubits: tuple[int, ...]
     target_qubits: tuple[int, ...]
-    parameters: list[OperationParameter] = pydantic.Field(default_factory=list)
     operation_level: OperationLevel
     operation_type: OperationType = pydantic.Field(
         description="Identifies unique operations that are visualized differently"

classiq/interface/model/quantum_statement.py

@@ -27,7 +27,7 @@ class QuantumStatement(ASTNode):
         *,
         update: Optional[dict[str, Any]] = None,
         deep: bool = False,
-        keep_uuid: bool = False
+        keep_uuid: bool = False,
     ) -> Self:
         if not keep_uuid:
             update = update or dict()

classiq/interface/server/routes.py

@@ -7,9 +7,6 @@ PROVIDERS_PREFIX = "/providers"
 
 IQCC_PREFIX = PROVIDERS_PREFIX + "/iqcc"
 
-EXECUTION_NON_VERSIONED_PREFIX = "/execution/v1"
-SYNTHESIS_NON_VERSIONED_PREFIX = "/synthesis/v1"
-
 ANALYZER_CIRCUIT_PAGE = "circuit"
 DEFAULT_IDE_FE_APP = "https://platform.classiq.io/"
 
@@ -58,9 +55,6 @@ TASKS_GENERATE_FULL_PATH = TASKS_GENERATE_SUFFIX
 
 EXECUTION_JOBS_SUFFIX = "/jobs"
 EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
-EXECUTION_JOBS_NON_VERSIONED_FULL_PATH = (
-    EXECUTION_NON_VERSIONED_PREFIX + EXECUTION_JOBS_SUFFIX
-)
 
 ANALYZER_FULL_PATH = ANALYZER_PREFIX + TASKS_SUFFIX
 ANALYZER_RB_FULL_PATH = ANALYZER_PREFIX + TASK_RB_SUFFIX

classiq/model_expansions/generative_functions.py

@@ -148,7 +148,8 @@ def emit_generative_statements(
     with _InterpreterExpandable(interpreter):
         set_frontend_interpreter(interpreter)
         for block_name, generative_function in operation.generative_blocks.items():
-            with interpreter._builder.block_context(
-                block_name
-            ), generative_mode_context(True):
+            with (
+                interpreter._builder.block_context(block_name),
+                generative_mode_context(True),
+            ):
                 generative_function._py_callable(*python_qmod_args)

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -13,9 +13,6 @@ 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,
-)
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -162,11 +159,6 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             back_ref=self._get_back_ref(propagated_debug_info),
         )
         is_allocate_or_free = new_call.func_name == free.func_decl.name
-        parameters = {
-            arg_decl.name: FunctionDebugInfo.param_controller(value=evaluated_arg.value)
-            for arg_decl, evaluated_arg in zip(new_positional_arg_decls, evaluated_args)
-            if isinstance(arg_decl, ClassicalParameterDeclaration)
-        }
 
         port_to_passed_variable_map = {
             arg_decl.name: str(evaluated_arg.value.handle)
@@ -176,11 +168,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,
-            parameters=(
-                parameters
-                if propagated_debug_info is None or propagated_debug_info.name == ""
-                else propagated_debug_info.parameters
-            ),
             is_allocate_or_free=is_allocate_or_free,
             port_to_passed_variable_map=port_to_passed_variable_map,
             node=new_call._as_back_ref(),