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

classiq/_internals/api_wrapper.py

@@ -3,6 +3,7 @@ from typing import Any, Optional, Protocol, TypeVar
 
 import httpx
 import pydantic
+from pydantic.main import IncEx
 
 import classiq.interface.executor.execution_result
 import classiq.interface.pyomo_extension
@@ -21,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
@@ -72,11 +69,12 @@ class ApiWrapper:
         model: pydantic.BaseModel,
         use_versioned_url: bool = True,
         http_client: Optional[httpx.AsyncClient] = None,
+        exclude: Optional[IncEx] = None,
     ) -> dict:
         # TODO: we can't use model.dict() - it doesn't serialize complex class.
         # This was added because JSON serializer doesn't serialize complex type, and pydantic does.
         # We should add support for smarter json serialization.
-        body = json.loads(model.model_dump_json())
+        body = json.loads(model.model_dump_json(exclude=exclude))
         return await cls._call_task(
             http_method,
             url,
@@ -135,6 +133,7 @@ class ApiWrapper:
             url=routes.EXECUTION_SESSIONS_PREFIX,
             model=circuit,
             http_client=http_client,
+            exclude={"debug_info"},
         )
         return raw_result["id"]
 
@@ -164,6 +163,7 @@ class ApiWrapper:
             url=routes.CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL,
             model=circuit,
             http_client=http_client,
+            exclude={"debug_info"},
         )
 
     @classmethod
@@ -214,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}",
@@ -223,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(
@@ -244,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}",
@@ -254,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/_internals/async_utils.py

@@ -58,7 +58,7 @@ def enable_jupyter_notebook() -> None:
 
 
 def _make_iterable_interval(
-    interval_sec: Union[SupportsFloat, Iterable[SupportsFloat]]
+    interval_sec: Union[SupportsFloat, Iterable[SupportsFloat]],
 ) -> Iterable[float]:
     if isinstance(interval_sec, Iterable):
         return map(float, interval_sec)

classiq/_internals/authentication/password_manager.py

@@ -117,7 +117,7 @@ class DummyPasswordManager(PasswordManager):
 
 class FilePasswordManager(PasswordManager):
     _CLASSIQ_CREDENTIALS_FILE_PATH: str = "{}/.classiq-credentials".format(
-        os.getenv("HOME")
+        os.getenv("CLASSIQ_DIR", os.getenv("HOME"))
     )
 
     def __init__(self) -> None:

classiq/_internals/client.py

@@ -89,7 +89,7 @@ P = ParamSpec("P")
 
 
 def try_again_on_failure(
-    func: Callable[P, Awaitable[Ret]]
+    func: Callable[P, Awaitable[Ret]],
 ) -> Callable[P, Awaitable[Ret]]:
     def check_approved_api_error(error_message: str) -> bool:
         for approved_api_error in APPROVED_API_ERROR_MESSAGES_FOR_RESTART:

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

@@ -1,4 +1,3 @@
-import json
 import random
 from types import TracebackType
 from typing import Callable, Optional, Union, cast
@@ -16,7 +15,10 @@ from classiq.interface.executor.result import (
 )
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
-from classiq.interface.generator.quantum_program import QuantumProgram
+from classiq.interface.generator.quantum_program import (
+    OMIT_DEBUG_INFO_FLAG,
+    QuantumProgram,
+)
 from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric
 
 from classiq._internals import async_utils
@@ -46,7 +48,9 @@ def _deserialize_program(program: Program) -> QuantumProgram:
     return (
         program
         if isinstance(program, QuantumProgram)
-        else QuantumProgram.model_validate(json.loads(program))
+        else QuantumProgram.model_validate_json(
+            program, context={OMIT_DEBUG_INFO_FLAG: True}
+        )
     )
 
 

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

@@ -10,7 +10,10 @@ from classiq.interface.executor.execution_preferences import ExecutionPreference
 from classiq.interface.executor.quantum_code import QuantumCode
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.result import ExecutionDetails
-from classiq.interface.generator.quantum_program import QuantumProgram
+from classiq.interface.generator.quantum_program import (
+    OMIT_DEBUG_INFO_FLAG,
+    QuantumProgram,
+)
 
 from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
@@ -27,7 +30,9 @@ BackendPreferencesAndResult: TypeAlias = tuple[
 def _parse_serialized_qprog(
     quantum_program: SerializedQuantumProgram,
 ) -> QuantumProgram:
-    return QuantumProgram.model_validate_json(quantum_program)
+    return QuantumProgram.model_validate_json(
+        quantum_program, context={OMIT_DEBUG_INFO_FLAG: True}
+    )
 
 
 async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJob:

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

classiq/interface/ast_node.py

@@ -20,7 +20,7 @@ class ASTNode(HashablePydanticBaseModel):
         return self
 
 
-def without_statement_blocks(
+def reset_lists(
     ast_node: ASTNodeType, statement_block_fields: list[str]
 ) -> ASTNodeType:
     return ast_node.model_copy(update={field: [] for field in statement_block_fields})

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,
@@ -69,7 +70,7 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
 
     @staticmethod
     def _validate_monomial_coefficient(
-        coeff: Union[sympy.Expr, ParameterComplexType]
+        coeff: Union[sympy.Expr, ParameterComplexType],
     ) -> ParameterComplexType:
         if isinstance(coeff, str):
             validate_expression_str(coeff)
@@ -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()
@@ -89,6 +79,21 @@ class DebugInfoCollection(BaseModel):
         return self.blackbox_data.get(debug_info.name)
 
 
+def get_back_refs(
+    debug_info: FunctionDebugInfo, collected_debug_info: DebugInfoCollection
+) -> list[ConcreteQuantumStatement]:
+    back_refs: list[ConcreteQuantumStatement] = []
+    while (node := debug_info.node) is not None:
+        back_refs.insert(0, node)
+        if node.back_ref is None:
+            break
+        next_debug_info = collected_debug_info.get(node.back_ref)
+        if next_debug_info is None:
+            break
+        debug_info = next_debug_info
+    return back_refs
+
+
 def new_function_debug_info_by_node(
     node: ConcreteQuantumStatement,
 ) -> FunctionDebugInfo:

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

@@ -1,4 +1,5 @@
-from typing import Any, Final, Optional
+import ast
+from typing import Any, Final, Optional, cast
 
 import networkx as nx
 import pydantic
@@ -95,6 +96,9 @@ def get_arithmetic_params(
     machine_precision: int,
     enable_target: bool = False,
 ) -> Arithmetic:
+    expr_str, var_types = _substitute_quantum_subscripts(
+        expr_str, var_types, machine_precision
+    )
     return Arithmetic(
         expression=expr_str,
         definitions={
@@ -121,3 +125,94 @@ def compute_arithmetic_result_type(
     return register_info_to_quantum_type(
         arith_param.outputs[ARITHMETIC_EXPRESSION_RESULT_NAME]
     )
+
+
+def aggregate_numeric_types(
+    numeric_types: list[QuantumNumeric],
+) -> RegisterArithmeticInfo:
+    if all(
+        numeric_type.size_in_bits == 1
+        and numeric_type.sign_value
+        and numeric_type.fraction_digits_value == 1
+        for numeric_type in numeric_types
+    ):
+        return RegisterArithmeticInfo(size=1, is_signed=True, fraction_places=1)
+    int_size = max(
+        numeric_type.size_in_bits
+        - int(numeric_type.sign_value)
+        - numeric_type.fraction_digits_value
+        for numeric_type in numeric_types
+    )
+    is_signed = any(numeric_type.sign_value for numeric_type in numeric_types)
+    frac_size = max(
+        numeric_type.fraction_digits_value for numeric_type in numeric_types
+    )
+    total_size = int_size + int(is_signed) + frac_size
+    return RegisterArithmeticInfo(
+        size=total_size, is_signed=is_signed, fraction_places=frac_size
+    )
+
+
+class _QuantumSubscriptRemover(ast.NodeTransformer):
+    def __init__(self, machine_precision: int) -> None:
+        self._machine_precision = machine_precision
+        self.substitutions_types: dict[str, QuantumNumeric] = {}
+
+    def visit_Call(self, node: ast.Call) -> ast.expr:
+        if not isinstance(node.func, ast.Name) or node.func.id != "Piecewise":
+            return node
+        items = [
+            cast(float, cast(ast.Num, cast(ast.Tuple, arg).elts[0]).value)
+            for arg in node.args
+        ]
+        numeric_types = [
+            compute_arithmetic_result_type(str(num), {}, self._machine_precision)
+            for num in items
+        ]
+        unified_numeric_type = register_info_to_quantum_type(
+            aggregate_numeric_types(numeric_types)
+        )
+        substitution_var_name = f"__lut__{len(self.substitutions_types)}__"
+        self.substitutions_types[substitution_var_name] = unified_numeric_type
+        return ast.Name(id=substitution_var_name)
+
+
+class _NameCollector(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.names: set[str] = set()
+
+    def visit_Name(self, node: ast.Name) -> None:
+        self.names.add(node.id)
+
+
+def _substitute_quantum_subscripts(
+    expr_str: str, var_types: dict[str, QuantumType], machine_precision: int
+) -> tuple[str, dict[str, QuantumType]]:
+    """
+    Remove quantum lookup expressions ([1, 2, 3, 4][n]) from an arithmetic expression
+    for the purpose of calculating its numeric attributes.
+    Each quantum lookup expression is replaced by a numeric value with equivalent
+    numeric properties.
+
+    Args:
+        expr_str: arithmetic expression
+        var_types: quantum variable type mapping
+        machine_precision: global machine precision
+
+    Returns:
+        1. the reduced expression
+        2. updated type mapping
+    """
+    expr_ast = ast.parse(expr_str)
+    subscript_remover = _QuantumSubscriptRemover(machine_precision)
+    expr_ast = subscript_remover.visit(expr_ast)
+    var_types_substituted = var_types | subscript_remover.substitutions_types
+    expr_str_substituted = ast.unparse(expr_ast)
+    names_collector = _NameCollector()
+    names_collector.visit(ast.parse(expr_str_substituted))
+    var_types_substituted = {
+        var_name: var_type
+        for var_name, var_type in var_types_substituted.items()
+        if var_name in names_collector.names
+    }
+    return expr_str_substituted, var_types_substituted

classiq/interface/generator/arith/arithmetic_expression_parser.py

@@ -91,7 +91,7 @@ class ExpressionVisitor(ExpressionValidator):
 class InDegreeLimiter:
     @staticmethod
     def _sort_in_edges(
-        in_edges: Collection[tuple[Node, str]]
+        in_edges: Collection[tuple[Node, str]],
     ) -> list[tuple[Node, str]]:
         return sorted(
             in_edges,

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"]