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

classiq/evaluators/qmod_node_evaluators/constant_evaluation.py

@@ -33,7 +33,10 @@ def eval_enum_member(
     }
     attr = node.attr
     if attr not in enum_members:
-        raise ClassiqExpansionError(f"Enum {enum_name} has no member named {attr!r}")
+        raise ClassiqExpansionError(
+            f"Enum {enum_name} has no member {attr!r}. Available members: "
+            f"{', '.join(enum_members.keys())}"
+        )
 
     expr_val.set_type(node, Enum(name=enum_name))
     expr_val.set_value(node, enum_members[attr])

classiq/evaluators/qmod_node_evaluators/numeric_attrs_utils.py

@@ -29,7 +29,7 @@ def get_numeric_attrs(
 
     if TYPE_CHECKING:
         assert isinstance(qmod_type, QuantumScalar)
-    if not qmod_type.is_evaluated:
+    if not qmod_type.is_constant:
         return None
     return NumericAttributes.from_quantum_scalar(qmod_type, machine_precision)
 

classiq/evaluators/qmod_node_evaluators/struct_instantiation_evaluation.py

@@ -20,7 +20,7 @@ from classiq.evaluators.qmod_node_evaluators.compare_evaluation import (
 def eval_struct_instantiation(
     expr_val: QmodAnnotatedExpression, node: ast.Call, decl: StructDeclaration
 ) -> None:
-    if len(node.args) > 0 or any(kwarg.arg is None for kwarg in node.keywords):
+    if len(node.args) != 1 or any(kwarg.arg is None for kwarg in node.keywords):
         raise ClassiqExpansionError(
             "Classical structs must be instantiated using keyword arguments"
         )

classiq/evaluators/qmod_node_evaluators/subscript_evaluation.py

@@ -69,7 +69,7 @@ def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
     subject_type = expr_val.get_type(subject)
     slice_type: QmodType
     if isinstance(subject_type, ClassicalArray):
-        if subject_type.has_length and (
+        if subject_type.has_constant_length and (
             (start_val is not None and start_val >= subject_type.length_value)
             or (stop_val is not None and stop_val > subject_type.length_value)
         ):
@@ -93,7 +93,7 @@ def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
             slice_type = subject_type.get_raw_type()
     elif isinstance(subject_type, QuantumBitvector):
         if start_val is not None and stop_val is not None:
-            if subject_type.has_length and (
+            if subject_type.has_constant_length and (
                 start_val >= subject_type.length_value
                 or stop_val > subject_type.length_value
             ):
@@ -150,7 +150,7 @@ def _eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> N
     if isinstance(subject_type, (ClassicalArray, QuantumBitvector)):
         if (
             sub_val is not None
-            and subject_type.has_length
+            and subject_type.has_constant_length
             and sub_val >= subject_type.length_value
         ):
             raise ClassiqExpansionError("Array index out of range")

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -85,7 +85,7 @@ def array_len(
 ) -> Optional[int]:
     if isinstance(classical_type, ClassicalTuple):
         return len(classical_type.element_types)
-    if classical_type.has_length:
+    if classical_type.has_constant_length:
         return classical_type.length_value
     return None
 

classiq/evaluators/qmod_type_inference/classical_type_inference.py

@@ -73,9 +73,9 @@ def _inject_classical_array_attributes(
     if isinstance(to_type, ClassicalArray):
         if isinstance(from_type, ClassicalArray):
             length: Optional[Expression]
-            if from_type.has_length:
+            if from_type.has_constant_length:
                 if (
-                    to_type.has_length
+                    to_type.has_constant_length
                     and from_type.length_value != to_type.length_value
                 ):
                     return None
@@ -90,7 +90,7 @@ def _inject_classical_array_attributes(
             return ClassicalArray(element_type=element_type, length=length)
         if isinstance(from_type, ClassicalTuple):
             if (
-                to_type.has_length
+                to_type.has_constant_length
                 and len(from_type.element_types) != to_type.length_value
             ):
                 return None
@@ -103,7 +103,7 @@ def _inject_classical_array_attributes(
             return ClassicalTuple(element_types=element_types)
         return None
     if isinstance(from_type, ClassicalArray):
-        if from_type.has_length and from_type.length_value != len(
+        if from_type.has_constant_length and from_type.length_value != len(
             to_type.element_types
         ):
             return None

classiq/evaluators/qmod_type_inference/quantum_type_inference.py

@@ -290,3 +290,41 @@ def inject_quantum_type_attributes_inplace(
         to_type.set_fields(updated_type.fields)
         return True
     raise ClassiqInternalExpansionError
+
+
+def validate_quantum_type_attributes(quantum_type: QuantumType) -> None:
+    if isinstance(quantum_type, TypeName):
+        if len(quantum_type.fields) == 0:
+            raise ClassiqExpansionError(
+                f"QStruct {quantum_type.name} must have at least one field"
+            )
+        for field_type in quantum_type.fields.values():
+            validate_quantum_type_attributes(field_type)
+        return
+    if isinstance(quantum_type, QuantumBitvector):
+        validate_quantum_type_attributes(quantum_type.element_type)
+        if quantum_type.has_constant_length and quantum_type.length_value < 1:
+            raise ClassiqExpansionError(
+                f"QArray length must be positive, got {quantum_type.length_value}"
+            )
+        return
+    if isinstance(quantum_type, QuantumNumeric):
+        if quantum_type.has_size_in_bits and quantum_type.size_in_bits < 1:
+            raise ClassiqExpansionError(
+                f"QNum size must be positive, got {quantum_type.size_in_bits}"
+            )
+        if quantum_type.has_fraction_digits:
+            if quantum_type.fraction_digits_value < 0:
+                raise ClassiqExpansionError(
+                    f"QNum fraction digits must be positive, got "
+                    f"{quantum_type.fraction_digits_value}"
+                )
+            if (
+                quantum_type.has_size_in_bits
+                and quantum_type.fraction_digits_value > quantum_type.size_in_bits
+            ):
+                raise ClassiqExpansionError(
+                    f"QNum size ({quantum_type.size_in_bits}) must be greater or "
+                    f"equals than the fraction digits "
+                    f"({quantum_type.fraction_digits_value})"
+                )

classiq/evaluators/type_type_match.py

@@ -21,7 +21,7 @@ def check_signature_match(
 ) -> None:
     if len(decl_params) != len(op_params):
         raise ClassiqExpansionError(
-            f"{location_str} should have {len(decl_params)} parameters, "
+            f"{location_str.capitalize()} should have {len(decl_params)} parameters, "
             f"not {len(op_params)}"
         )
     for idx, (decl_param, op_param) in enumerate(zip(decl_params, op_params)):

classiq/execution/execution_session.py

@@ -340,6 +340,7 @@ class ExecutionSession:
         initial_params: ExecutionParams,
         max_iteration: int,
         quantile: float = 1.0,
+        tolerance: Optional[float] = None,
     ) -> list[tuple[float, ExecutionParams]]:
         """
         Minimizes the given cost function using the quantum program.
@@ -355,6 +356,7 @@ class ExecutionSession:
                     - The value is either a float or a list of floats.
             max_iteration: The maximum number of iterations for the minimization.
             quantile: The quantile to use for cost estimation.
+            tolerance: The tolerance for the minimization.
         Returns:
             A list of tuples, each containing the estimated cost and the corresponding parameters for that iteration.
             `cost` is a float, and `parameters` is a dictionary matching the execution parameter format.
@@ -365,6 +367,7 @@ class ExecutionSession:
             initial_params=initial_params,
             max_iteration=max_iteration,
             quantile=quantile,
+            tolerance=tolerance,
             _check_deprecation=False,
         )
         result = job.get_minimization_result(_http_client=self._async_client)
@@ -379,6 +382,7 @@ class ExecutionSession:
         initial_params: ExecutionParams,
         max_iteration: int,
         quantile: float = 1.0,
+        tolerance: Optional[float] = None,
         *,
         _check_deprecation: bool = True,
     ) -> ExecutionJob:
@@ -400,6 +404,7 @@ class ExecutionSession:
                     - The value is either a float or a list of floats.
             max_iteration: The maximum number of iterations for the minimization.
             quantile: The quantile to use for cost estimation.
+            tolerance: The tolerance for the minimization.
 
         Returns:
             The execution job.
@@ -424,6 +429,7 @@ class ExecutionSession:
                 initial_params=_initial_params,
                 max_iteration=max_iteration,
                 quantile=quantile,
+                tolerance=tolerance,
             )
         else:
             _cost_function = self._hamiltonian_to_pauli_operator(cost_function)
@@ -432,6 +438,7 @@ class ExecutionSession:
                 initial_params=_initial_params,
                 max_iteration=max_iteration,
                 quantile=quantile,
+                tolerance=tolerance,
             )
 
         execution_primitives_input = PrimitivesInput(minimize=minimize)
@@ -545,10 +552,18 @@ class ExecutionSession:
             name: create_qvar_from_quantum_type(reg.quantum_types, name)
             for name, reg in circuit_output_types.items()
         }
-        for name in inspect.signature(qmod_expression_creator).parameters.keys():
+        creator_parameters = inspect.signature(
+            qmod_expression_creator
+        ).parameters.keys()
+        for name in creator_parameters:
             if name not in symbolic_output:
                 raise ClassiqValueError(
-                    f"The provided QVar: {name} does not match the model outputs: {tuple(circuit_output_types.keys())}. "
+                    f"Expected cost function with parameters {tuple(symbolic_output.keys())} corresponding to the quantum program outputs, but found '{name}'. "
+                )
+        for name in symbolic_output:
+            if name not in creator_parameters:
+                raise ClassiqValueError(
+                    f"Expected cost function with parameter '{name}' corresponding to the quantum program outputs. "
                 )
 
         qmod_expression = qmod_expression_creator(**symbolic_output)

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

classiq/interface/analyzer/analysis_params.py

@@ -80,7 +80,7 @@ class AnalysisHardwareListParams(AnalysisParams, HardwareListParams):
 
 
 class HardwareParams(pydantic.BaseModel):
-    device: PydanticNonEmptyString = pydantic.Field(default=None, description="Devices")
+    device: PydanticNonEmptyString = pydantic.Field(default=None, description="Devices")  # type: ignore[assignment]
     provider: AnalyzerProviderVendor
 
 

classiq/interface/backend/backend_preferences.py

@@ -274,7 +274,7 @@ class AzureCredential(BaseSettings):
 
     def __init__(self, **data: Any) -> None:
         initial_data = {
-            field: data[field] for field in data if field in self.model_fields
+            field: data[field] for field in data if field in self.__class__.model_fields
         }
         super().__init__(**data)
         for field, value in initial_data.items():

classiq/interface/execution/primitives.py

@@ -17,6 +17,7 @@ class MinimizeCostInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
     initial_params: Arguments
     max_iteration: int
     quantile: float
+    tolerance: Optional[float]
 
 
 class MinimizeClassicalCostInput(MinimizeCostInput):

classiq/interface/generator/application_apis/__init__.py

@@ -6,7 +6,6 @@ from .arithmetic_declarations import *  # noqa: F403
 from .chemistry_declarations import *  # noqa: F403
 from .combinatorial_optimization_declarations import *  # noqa: F403
 from .entangler_declarations import *  # noqa: F403
-from .finance_declarations import *  # noqa: F403
 from .qsvm_declarations import *  # noqa: F403
 
 populate_builtin_declarations(vars().values())

classiq/interface/generator/arith/register_user_input.py

@@ -19,7 +19,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
     is_signed: bool = pydantic.Field(default=False)
     fraction_places: pydantic.NonNegativeInt = pydantic.Field(default=0)
     bypass_bounds_validation: bool = pydantic.Field(default=False)
-    bounds: PydanticFloatTuple = pydantic.Field(
+    bounds: PydanticFloatTuple = pydantic.Field(  # type: ignore[assignment]
         default=None,
         validate_default=True,
     )

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -4,8 +4,6 @@ CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS = {
     "hypercube_entangler_graph",
     "grid_entangler_graph",
     "qft_const_adder_phase",
-    "log_normal_finance_post_process",
-    "gaussian_finance_post_process",
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",

classiq/interface/generator/function_param_list.py

@@ -33,7 +33,6 @@ from classiq.interface.generator.entangler_params import (
     HypercubeEntangler,
     TwoDimensionalEntangler,
 )
-from classiq.interface.generator.finance import Finance, FinanceModels, FinancePayoff
 from classiq.interface.generator.function_param_library import FunctionParamLibrary
 from classiq.interface.generator.hadamard_transform import HadamardTransform
 from classiq.interface.generator.hamiltonian_evolution.exponentiation import (
@@ -106,9 +105,6 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             CyclicShift,
             Modulo,
             TwoDimensionalEntangler,
-            Finance,
-            FinanceModels,
-            FinancePayoff,
             HypercubeEntangler,
             GridEntangler,
             Mcx,

classiq/interface/generator/functions/classical_type.py

@@ -2,7 +2,7 @@ from itertools import chain
 from typing import TYPE_CHECKING, Any, Literal, Optional
 
 import pydantic
-from pydantic import ConfigDict, PrivateAttr
+from pydantic import PrivateAttr
 from typing_extensions import Self
 
 from classiq.interface.ast_node import HashableASTNode
@@ -34,8 +34,6 @@ if TYPE_CHECKING:
 class ClassicalType(HashableASTNode):
     _is_generative: bool = PrivateAttr(default=False)
 
-    model_config = ConfigDict(extra="forbid")
-
     def __str__(self) -> str:
         return str(type(self).__name__)
 
@@ -78,6 +76,9 @@ class ClassicalType(HashableASTNode):
     def get_raw_type(self) -> "ConcreteClassicalType":
         return self  # type:ignore[return-value]
 
+    def without_symbolic_attributes(self) -> Self:
+        return self
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
@@ -144,6 +145,14 @@ class ClassicalArray(ClassicalType):
     def has_length(self) -> bool:
         return self.length is not None and self.length.is_evaluated()
 
+    @property
+    def has_constant_length(self) -> bool:
+        return (
+            self.length is not None
+            and self.length.is_evaluated()
+            and self.length.is_constant()
+        )
+
     @property
     def length_value(self) -> int:
         if not self.has_length:
@@ -195,6 +204,18 @@ class ClassicalArray(ClassicalType):
     def raw_qmod_type_name(self) -> str:
         return "CArray"
 
+    def without_symbolic_attributes(self) -> "ClassicalArray":
+        length = (
+            None
+            if self.length is None
+            or not self.length.is_evaluated()
+            or not self.length.is_constant()
+            else self.length
+        )
+        return ClassicalArray(
+            element_type=self.element_type.without_symbolic_attributes(), length=length
+        )
+
 
 class ClassicalTuple(ClassicalType):
     kind: Literal["tuple"]
@@ -265,6 +286,14 @@ class ClassicalTuple(ClassicalType):
     def raw_qmod_type_name(self) -> str:
         return "CArray"
 
+    def without_symbolic_attributes(self) -> "ClassicalTuple":
+        return ClassicalTuple(
+            element_types=[
+                element_type.without_symbolic_attributes()
+                for element_type in self.element_types
+            ]
+        )
+
 
 class OpaqueHandle(ClassicalType):
     pass

classiq/interface/generator/functions/function_declaration.py

@@ -1,8 +1,6 @@
 import abc
 from collections.abc import Sequence
 
-from pydantic import ConfigDict
-
 from classiq.interface.model.classical_parameter_declaration import (
     AnonClassicalParameterDeclaration,
 )
@@ -19,7 +17,5 @@ class FunctionDeclaration(Parameter, abc.ABC):
     def param_decls(self) -> Sequence["AnonClassicalParameterDeclaration"]:
         pass
 
-    model_config = ConfigDict(extra="forbid")
-
 
 FunctionDeclaration.model_rebuild()

classiq/interface/generator/functions/type_name.py

@@ -101,6 +101,12 @@ class TypeName(ClassicalType, QuantumType):
             field_type.is_evaluated for field_type in self.fields.values()
         )
 
+    @property
+    def is_constant(self) -> bool:
+        return self.has_fields and all(
+            field_type.is_constant for field_type in self.fields.values()
+        )
+
     @property
     def has_classical_struct_decl(self) -> bool:
         return self._classical_struct_decl is not None
@@ -183,6 +189,31 @@ class TypeName(ClassicalType, QuantumType):
             field_type.minimal_size_in_bits for field_type in self.fields.values()
         )
 
+    def without_symbolic_attributes(self) -> "TypeName":
+        if self.has_fields:
+            type_name = TypeName(name=self.name)
+            type_name.set_fields(
+                {
+                    field_name: field_type.without_symbolic_attributes()
+                    for field_name, field_type in self.fields.items()
+                }
+            )
+            return type_name
+        if self.has_classical_struct_decl:
+            type_name = TypeName(name=self.name)
+            type_name.set_classical_struct_decl(
+                self.classical_struct_decl.model_copy(
+                    update=dict(
+                        variables={
+                            field_name: field_type.without_symbolic_attributes()
+                            for field_name, field_type in self.classical_struct_decl.variables.items()
+                        }
+                    )
+                )
+            )
+            return type_name
+        return self
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/hardware_efficient_ansatz.py

@@ -42,7 +42,7 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
         "If none specified - use connectivity map from the model hardware settings. "
         "If none specified as well, all qubit pairs will be connected.",
     )
-    num_qubits: pydantic.PositiveInt = pydantic.Field(
+    num_qubits: pydantic.PositiveInt = pydantic.Field(  # type: ignore[assignment]
         default=None,
         description="Number of qubits in the ansatz.",
         validate_default=True,

classiq/interface/generator/quantum_function_call.py

@@ -130,7 +130,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         default=True,
         description="False value indicates this call shouldn't be controlled even if the flow is controlled.",
     )
-    inputs: IOType = pydantic.Field(
+    inputs: IOType = pydantic.Field(  # type: ignore[assignment]
         default_factory=dict,
         description="A mapping from the input name to the wire it connects to",
     )
@@ -138,14 +138,14 @@ class SynthesisQuantumFunctionCall(BaseModel):
         default_factory=dict,
         description="A mapping from in/out name to the wires that connect to it",
     )
-    outputs: IOType = pydantic.Field(
+    outputs: IOType = pydantic.Field(  # type: ignore[assignment]
         default_factory=dict,
         description="A mapping from the output name to the wire it connects to",
     )
     power: PydanticPowerType = pydantic.Field(
         default=1, description="Number of successive calls to the operation"
     )
-    name: PydanticNonEmptyString = pydantic.Field(
+    name: PydanticNonEmptyString = pydantic.Field(  # type: ignore[assignment]
         default=None,
         validate_default=True,
         description="The name of the function instance. "

classiq/interface/generator/transpiler_basis_gates.py

@@ -57,11 +57,15 @@ EXTRA_TWO_QUBIT_GATES: BasisGates = frozenset(
     )
 )
 
+NON_UNITARY_GATES: BasisGates = frozenset(("if_else",))
+
 TWO_QUBIT_GATES = BASIC_TWO_QUBIT_GATES | EXTRA_TWO_QUBIT_GATES
 
 THREE_QUBIT_GATES: BasisGates = frozenset(("ccx", "cswap"))
 DEFAULT_BASIS_GATES: BasisGates = SINGLE_QUBIT_GATES | BASIC_TWO_QUBIT_GATES
-ALL_GATES: BasisGates = SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES
+ALL_GATES: BasisGates = (
+    SINGLE_QUBIT_GATES | TWO_QUBIT_GATES | THREE_QUBIT_GATES | NON_UNITARY_GATES
+)
 
 ROUTING_TWO_QUBIT_BASIS_GATES: BasisGates = frozenset(
     ("cx", "ecr", "rzx", "ryy", "rxx", "rzz", "cy", "cz", "cp", "swap")

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -132,13 +132,6 @@ class FermionMapping(IntEnum):
     FAST_BRAVYI_KITAEV = 3
 
 
-class FinanceFunctionType(IntEnum):
-    VAR = 0
-    SHORTFALL = 1
-    X_SQUARE = 2
-    EUROPEAN_CALL_OPTION = 3
-
-
 class LadderOperator(IntEnum):
     PLUS = 0
     MINUS = 1
@@ -171,7 +164,6 @@ class QSVMFeatureMapEntanglement(IntEnum):
 __all__ = [
     "Element",
     "FermionMapping",
-    "FinanceFunctionType",
     "LadderOperator",
     "Optimizer",
     "Pauli",

classiq/interface/generator/user_defined_function_params.py

@@ -1,7 +1,6 @@
 from collections.abc import Mapping
 
 import pydantic
-from pydantic import ConfigDict
 
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import ArithmeticIODict, FunctionParams
@@ -12,8 +11,6 @@ class CustomFunction(FunctionParams):
     A user-defined custom function parameters object.
     """
 
-    model_config = ConfigDict(frozen=True, extra="forbid")
-
     _name: str = pydantic.PrivateAttr(default="")
 
     input_decls: ArithmeticIODict = pydantic.Field(

classiq/interface/ide/ide_data.py

@@ -59,7 +59,7 @@ class IDEDataOperation(pydantic.BaseModel):
     _qubits: list = pydantic.PrivateAttr()  # list[Qubit]
 
     displayArgs: str = ""
-    targets: Union[list[IDEQubitDef], list[IDEClassicalBitDef]] = pydantic.Field(
+    targets: Union[list[IDEQubitDef], list[IDEClassicalBitDef]] = pydantic.Field(  # type: ignore[assignment]
         default_factory=list
     )
     controls: list[IDEQubitDef] = list()

classiq/interface/ide/visual_model.py

@@ -207,9 +207,9 @@ class Operation(pydantic.BaseModel):
 
 
 class ProgramVisualModel(VersionedModel):
-    main_operation: Operation = pydantic.Field(default=None)
+    main_operation: Operation = pydantic.Field(default=None)  # type: ignore[assignment]
     id_to_operations: dict[int, Operation] = pydantic.Field(default_factory=dict)
-    main_operation_id: int = pydantic.Field(default=None)
+    main_operation_id: int = pydantic.Field(default=None)  # type: ignore[assignment]
     program_data: ProgramData
 
     @property

classiq/interface/model/block.py

@@ -1,4 +1,6 @@
-from typing import TYPE_CHECKING, Literal
+from typing import TYPE_CHECKING, Literal, Optional
+
+import pydantic
 
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -10,3 +12,5 @@ class Block(QuantumOperation):
     kind: Literal["Block"]
 
     statements: "StatementBlock"
+
+    label: Optional[str] = pydantic.Field(default=None)

classiq/interface/model/classical_if.py

@@ -3,6 +3,8 @@ import operator
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Literal
 
+import pydantic
+
 from classiq.interface.ast_node import ASTNodeType, reset_lists
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
@@ -18,6 +20,9 @@ class ClassicalIf(QuantumOperation):
     condition: Expression
     then: "StatementBlock"
     else_: "StatementBlock"
+    _condition_wiring_inouts: dict[str, HandleBinding] = pydantic.PrivateAttr(
+        default_factory=dict
+    )
 
     def _as_back_ref(self: ASTNodeType) -> ASTNodeType:
         return reset_lists(self, ["then", "else_"])
@@ -40,14 +45,17 @@ class ClassicalIf(QuantumOperation):
 
     @property
     def wiring_inouts(self) -> Mapping[str, ConcreteHandleBinding]:
-        return functools.reduce(
-            operator.ior,
-            (
-                op.wiring_inouts
-                for op in (*self.then, *self.else_)
-                if isinstance(op, QuantumOperation)
-            ),
-            dict(),
+        return (
+            functools.reduce(
+                operator.ior,
+                (
+                    op.wiring_inouts
+                    for op in (*self.then, *self.else_)
+                    if isinstance(op, QuantumOperation)
+                ),
+                dict(),
+            )
+            | self._condition_wiring_inouts
         )
 
     @property

classiq/interface/model/classical_parameter_declaration.py

@@ -33,6 +33,10 @@ class AnonClassicalParameterDeclaration(Parameter):
             }
         )
 
+    @property
+    def qmod_type_name(self) -> str:
+        return self.classical_type.qmod_type_name
+
 
 class ClassicalParameterDeclaration(AnonClassicalParameterDeclaration):
     name: str

classiq/interface/model/handle_binding.py

@@ -19,7 +19,7 @@ def _get_expr_id(expr: Expression) -> str:
 
 
 class HandleBinding(ASTNode):
-    name: str = Field(default=None)
+    name: str = Field(default=None)  # type: ignore[assignment]
     model_config = ConfigDict(frozen=True, extra="forbid")
 
     def __str__(self) -> str: