classiq 0.46.1__py3-none-any.whl → 0.48.0__py3-none-any.whl

classiq/interface/generator/arith/binary_ops.py

@@ -21,6 +21,7 @@ from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import argument_utils, number_utils
 from classiq.interface.generator.arith.argument_utils import RegisterOrConst
 from classiq.interface.generator.arith.arithmetic_operations import (
+    MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.ast_node_rewrite import (
@@ -391,17 +392,20 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
             arg=self.effective_right_arg,
             output_size=self.negation_output_size,
             inplace=self.should_inplace_negation,
+            bypass_bounds_validation=True,
         )
         negation_result = negation_params.result_register
         if self.output_size is None and max(self.effective_right_arg.bounds) > 0:
-            negation_result = negation_result.copy(
-                update=dict(
-                    is_signed=True,
-                    bounds=(
-                        -max(self.effective_right_arg.bounds),
-                        -min(self.effective_right_arg.bounds),
-                    ),
-                )
+            bounds = (
+                -max(self.effective_right_arg.bounds),
+                -min(self.effective_right_arg.bounds),
+            )
+            negation_result = RegisterArithmeticInfo(
+                size=negation_result.size,
+                fraction_places=negation_result.fraction_places,
+                is_signed=True,
+                bounds=bounds,
+                bypass_bounds_validation=True,
             )
         adder_params = Adder(
             left_arg=self.effective_left_arg,
@@ -465,12 +469,8 @@ class Multiplier(BinaryOpWithFloatInputs):
             for right in argument_utils.bounds(args[1])
         ]
         return (
-            number_utils.limit_fraction_places(
-                min(extremal_values), machine_precision=machine_precision
-            ),
-            number_utils.limit_fraction_places(
-                max(extremal_values), machine_precision=machine_precision
-            ),
+            number_utils.limit_fraction_places(min(extremal_values), machine_precision),
+            number_utils.limit_fraction_places(max(extremal_values), machine_precision),
         )
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
@@ -482,6 +482,13 @@ class Multiplier(BinaryOpWithFloatInputs):
             self.right_arg, self.machine_precision
         )
         bounds = self._get_bounds((left_arg, right_arg), self.machine_precision)
+        if self.output_size:
+            if fraction_places:
+                raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
+            max_bounds = RegisterArithmeticInfo.get_maximal_bounds(
+                size=self.output_size, is_signed=False, fraction_places=0
+            )
+            bounds = number_utils.bounds_cut(bounds, max_bounds)
 
         return RegisterArithmeticInfo(
             size=self.output_size

classiq/interface/generator/arith/extremum_operations.py

@@ -4,9 +4,10 @@ from typing import Any, Dict, Iterable
 import pydantic
 
 from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.arith import argument_utils
+from classiq.interface.generator.arith import argument_utils, number_utils
 from classiq.interface.generator.arith.argument_utils import RegisterOrConst
 from classiq.interface.generator.arith.arithmetic_operations import (
+    MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.binary_ops import (
@@ -108,6 +109,13 @@ class Extremum(ArithmeticOperationParams):
                 argument_utils.upper_bound(eff_right_arg),
             ),
         )
+        if self.output_size:
+            if fraction_places:
+                raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
+            max_bounds = RegisterArithmeticInfo.get_maximal_bounds(
+                size=self.output_size, is_signed=False, fraction_places=0
+            )
+            bounds = number_utils.bounds_cut(bounds, max_bounds)
         return RegisterArithmeticInfo(
             size=self.output_size or required_size,
             fraction_places=fraction_places,

classiq/interface/generator/arith/number_utils.py

@@ -110,3 +110,9 @@ def limit_fraction_places(number: float, machine_precision: int) -> float:
         fraction_part_size=orig_fractions - removed_fractions,
         is_signed=number < 0,
     )
+
+
+def bounds_cut(
+    bounds1: Tuple[float, float], bounds2: Tuple[float, float]
+) -> Tuple[float, float]:
+    return max(min(bounds1), min(bounds2)), min(max(bounds1), max(bounds2))

classiq/interface/generator/arith/register_user_input.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Tuple
 
 import pydantic
 
@@ -14,6 +14,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
     size: pydantic.PositiveInt
     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(default=None)
 
     @pydantic.root_validator(pre=True)
@@ -22,32 +23,39 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
             values.pop("name")
         return values
 
+    @staticmethod
+    def get_maximal_bounds(
+        *, size: int, is_signed: bool, fraction_places: int
+    ) -> Tuple[float, float]:
+        lb = 0 if not is_signed else -(2 ** (size - 1))
+        ub = 2**size - 1 if not is_signed else 2 ** (size - 1) - 1
+        fraction_factor = float(2**-fraction_places)
+        return (lb * fraction_factor, ub * fraction_factor)
+
     @pydantic.validator("bounds", always=True)
     def _validate_bounds(
         cls, bounds: Optional[PydanticFloatTuple], values: Dict[str, Any]
     ) -> PydanticFloatTuple:
-        if bounds is not None:
-            if min(bounds) < 0:
-                assert values.get("is_signed")
-            fraction_places = values.get("fraction_places")
-            if not isinstance(fraction_places, int):
-                raise ClassiqValueError(
-                    "RegisterUserInput must have an integer fraction_places"
-                )
-            return number_utils.limit_fraction_places(
-                min(bounds), machine_precision=fraction_places
-            ), number_utils.limit_fraction_places(
-                max(bounds), machine_precision=fraction_places
-            )
-
         size = values.get("size")
+        is_signed = values.get("is_signed", False)
+        fraction_places = values.get("fraction_places", 0)
         if not isinstance(size, int):
-            raise ClassiqValueError("RegisterUserInput must have an integer size")
-        is_signed: bool = values.get("is_signed", False)
-        lb = 0 if not is_signed else -(2 ** (size - 1))
-        ub = 2**size - 1 if not is_signed else 2 ** (size - 1) - 1
-        fraction_factor = float(2 ** -values.get("fraction_places", 0))
-        return (lb * fraction_factor, ub * fraction_factor)
+            raise ClassiqValueError("RegisterArithmeticInfo must have an integer size")
+
+        maximal_bounds = cls.get_maximal_bounds(
+            size=size, is_signed=is_signed, fraction_places=fraction_places
+        )
+        if bounds is None:
+            return maximal_bounds
+
+        trimmed_bounds = (
+            number_utils.limit_fraction_places(min(bounds), fraction_places),
+            number_utils.limit_fraction_places(max(bounds), fraction_places),
+        )
+        if not values.get("bypass_bounds_validation", False):
+            assert min(trimmed_bounds) >= min(maximal_bounds), "Illegal bound min"
+            assert max(trimmed_bounds) <= max(maximal_bounds), "Illegal bound max"
+        return trimmed_bounds
 
     def limit_fraction_places(self, machine_precision: int) -> "RegisterArithmeticInfo":
         truncated_bits: int = max(self.fraction_places - machine_precision, 0)
@@ -56,6 +64,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
             is_signed=self.is_signed,
             fraction_places=self.fraction_places - truncated_bits,
             bounds=self.bounds,
+            bypass_bounds_validation=self.bypass_bounds_validation,
         )
 
     @property

classiq/interface/generator/arith/unary_ops.py

@@ -5,6 +5,7 @@ import pydantic
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import argument_utils, number_utils
 from classiq.interface.generator.arith.arithmetic_operations import (
+    MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
@@ -74,6 +75,9 @@ class BitwiseInvert(UnaryOpParams):
 
 
 class Negation(UnaryOpParams):
+    bypass_bounds_validation: bool = pydantic.Field(
+        default=False
+    )  # True for efficient subtraction
     output_name = "negated"
 
     @staticmethod
@@ -88,11 +92,19 @@ class Negation(UnaryOpParams):
         eff_arg = self.arg.limit_fraction_places(self.machine_precision)
         is_signed = max(eff_arg.bounds) > 0 and self._include_sign
         bounds = (-max(eff_arg.bounds), -min(eff_arg.bounds))
+        if self.output_size and not self.bypass_bounds_validation:
+            if eff_arg.fraction_places:
+                raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
+            max_bounds = RegisterArithmeticInfo.get_maximal_bounds(
+                size=self.output_size, is_signed=False, fraction_places=0
+            )
+            bounds = number_utils.bounds_cut(bounds, max_bounds)
         return RegisterArithmeticInfo(
             size=self.output_size or self._expected_result_size(eff_arg),
             fraction_places=eff_arg.fraction_places,
             is_signed=is_signed,
-            bounds=bounds if (is_signed or min(bounds) >= 0) else None,
+            bypass_bounds_validation=self.bypass_bounds_validation,
+            bounds=bounds,
         )
 
     def zero_input_for_extension(self) -> pydantic.NonNegativeInt:

classiq/interface/generator/expressions/expression.py

@@ -69,6 +69,14 @@ class Expression(HashableASTNode):
         return self.as_constant(list)
 
     def _try_to_immediate_evaluate(self) -> None:
+        # FIXME remove special treatment (CAD-22999)
+        if self.expr == "SIGNED":
+            self._evaluated_expr = EvaluatedExpression(value=True)
+            return
+        if self.expr == "UNSIGNED":
+            self._evaluated_expr = EvaluatedExpression(value=False)
+            return
+
         try:
             result = ast.literal_eval(self.expr)
             if isinstance(result, (int, float, bool)):

classiq/interface/generator/functions/type_name.py

@@ -67,9 +67,7 @@ class TypeName(ClassicalType, QuantumType):  # type:ignore[misc]
         return self._assigned_fields
 
     def _set_fields(self, fields: Mapping[str, "ConcreteQuantumType"]) -> None:
-        from classiq.qmod.model_state_container import QMODULE
-
-        QMODULE.qstruct_decls[self.name].fields = fields
+        self._assigned_fields = fields
 
 
 class Enum(TypeName):

classiq/interface/generator/generated_circuit_data.py

@@ -1,4 +1,5 @@
-from typing import Dict, List, Literal, Optional, Tuple, Union
+import logging
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
 import pydantic
 from typing_extensions import TypeAlias
@@ -10,10 +11,10 @@ from classiq.interface.generator.synthesis_metadata.synthesis_execution_data imp
 )
 from classiq.interface.ide.visual_model import OperationParameter
 
+_logger = logging.getLogger(__name__)
 ParameterName = str
 IOQubitMapping: TypeAlias = Dict[str, Tuple[int, ...]]
 
-
 CLASSIQ_HIERARCHY_SEPARATOR: Literal["."] = "."
 
 VISUALIZATION_HIDE_LIST = [
@@ -102,6 +103,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     absolute_qubits: Optional[Tuple[int, ...]]
     is_basis_gate: Optional[bool]
     parameters: List[OperationParameter] = list()
+    port_to_passed_variable_map: Dict[str, str] = pydantic.Field(default_factory=dict)
 
     @property
     def registers(self) -> List[GeneratedRegister]:
@@ -120,3 +122,46 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         if self.generated_function is None:
             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 update(self, **kwargs: Any) -> None:
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def propagate_absolute_qubits(self) -> None:
+        if self.absolute_qubits is None:
+            return
+
+        for register in self.registers:
+            register.qubit_indexes_absolute = list(
+                _get_absolute_from_relative(
+                    self.absolute_qubits, tuple(register.qubit_indexes_relative)
+                )
+            )
+
+        for child in self.children:
+            child.absolute_qubits = _get_absolute_from_relative(
+                self.absolute_qubits, child.relative_qubits
+            )
+            child.propagate_absolute_qubits()
+
+
+def _get_absolute_from_relative(
+    absolute_qubits: Tuple[int, ...], relative_qubits: Tuple[int, ...]
+) -> Tuple[int, ...]:
+    if max(relative_qubits) >= len(absolute_qubits):
+        _logger.warning(
+            "Invalid qubit computation (relative qubits: %s, absolute qubits: %s)",
+            relative_qubits,
+            absolute_qubits,
+        )
+        return tuple()
+    return tuple(absolute_qubits[relative_qubit] for relative_qubit in relative_qubits)

classiq/interface/generator/quantum_program.py

@@ -1,5 +1,5 @@
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Union
 
@@ -10,6 +10,7 @@ from classiq.interface.exceptions import (
     ClassiqMissingOutputFormatError,
     ClassiqStateInitializationError,
 )
+from classiq.interface.execution.primitives import PrimitivesInput
 from classiq.interface.executor import quantum_code
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.register_initialization import RegisterInitialization
@@ -50,16 +51,23 @@ def get_uuid_as_str() -> str:
     return str(uuid.uuid4())
 
 
+def _get_formatted_utc_current_time() -> str:
+    # The purpose of this method is to replicate the behavior of
+    # datetime.utcnow().isoformat(), since `utcnow` is now deprecated
+    return datetime.now(timezone.utc).isoformat().split("+")[0]
+
+
 class QuantumProgram(VersionedModel, CircuitCodeInterface):
     hardware_data: SynthesisHardwareData
     initial_values: Optional[InitialConditions]
     data: GeneratedCircuitData
     model: ExecutionModel
     transpiled_circuit: Optional[TranspiledCircuitData]
-    creation_time: str = pydantic.Field(default_factory=datetime.utcnow().isoformat)
+    creation_time: str = pydantic.Field(default_factory=_get_formatted_utc_current_time)
     synthesis_duration: Optional[SynthesisStepDurations]
     debug_info: Optional[List[FunctionDebugInfoInterface]]
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
+    execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
 
     def _hardware_agnostic_program_code(self) -> CodeAndSyntax:
         circuit_code = self.program_circuit.get_code_by_priority()

classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py

@@ -1,12 +1,26 @@
 from typing import Dict, Optional, Set
 
 import pydantic
+import sympy
 
 from classiq.interface.backend.pydantic_backend import PydanticExecutionParameter
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.parameters import ParameterType
 
 
 class FunctionExecutionData(pydantic.BaseModel):
-    power_parameter: Optional[PydanticExecutionParameter] = pydantic.Field(default=None)
+    power_parameter: Optional[ParameterType] = pydantic.Field(default=None)
+
+    @property
+    def power_var(self) -> Optional[str]:
+        if self.power_parameter is None:
+            return None
+        power_vars = sympy.sympify(self.power_parameter).free_symbols
+        if len(power_vars) != 1:
+            raise ClassiqValueError(
+                f"Power parameter expression: {self.power_parameter} must contain exactly one variable"
+            )
+        return str(list(power_vars)[0])
 
 
 class ExecutionData(pydantic.BaseModel):
@@ -19,7 +33,7 @@ class ExecutionData(pydantic.BaseModel):
         self,
     ) -> Set[PydanticExecutionParameter]:
         return {
-            function_execution_data.power_parameter
+            function_execution_data.power_var
             for function_execution_data in self.function_execution.values()
-            if function_execution_data.power_parameter is not None
+            if function_execution_data.power_var is not None
         }

classiq/interface/ide/visual_model.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple
 
 import pydantic
 
@@ -38,6 +38,7 @@ class OperationParameter(pydantic.BaseModel):
 
 class OperationLink(pydantic.BaseModel):
     label: str
+    inner_label: Optional[str] = None
     qubits: Tuple[int, ...]
     type: str
 
@@ -47,6 +48,11 @@ class OperationLink(pydantic.BaseModel):
     def __hash__(self) -> int:
         return hash((type(self), self.label, self.qubits, self.type))
 
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, OperationLink):
+            return False
+        return hash(self) == hash(other)
+
 
 class OperationLinks(pydantic.BaseModel):
     inputs: List[OperationLink]
@@ -63,10 +69,9 @@ class Operation(pydantic.BaseModel):
     target_qubits: Tuple[int, ...]
     parameters: List[OperationParameter] = pydantic.Field(default_factory=list)
     operation_level: OperationLevel
-    # This field is meant to identify unique operations, such as variable initialization
-    # These will be visualized differently. We don't identify them yet, though, so
-    # we always set this field to be REGULAR
-    operation_type: OperationType = pydantic.Field(default=OperationType.REGULAR)
+    operation_type: OperationType = pydantic.Field(
+        description="Identifies unique operations that are visualized differently"
+    )
 
 
 class ProgramVisualModel(VersionedModel):

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "2"
+INTERFACE_VERSION = "3"

classiq/interface/model/bind_operation.py

@@ -56,6 +56,3 @@ class BindOperation(QuantumOperation):
                 raise ClassiqValueError(f"Cannot bind '{handle}'")
 
         return handles
-
-    def reversed(self) -> "BindOperation":
-        return BindOperation(in_handles=self.out_handles, out_handles=self.in_handles)

classiq/interface/model/phase_operation.py

@@ -0,0 +1,11 @@
+from typing import Literal
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+
+
+class PhaseOperation(QuantumExpressionOperation):
+    kind: Literal["PhaseOperation"]
+    theta: Expression

classiq/interface/model/port_declaration.py

@@ -1,25 +1,20 @@
-from typing import Any, Dict, Literal, Mapping, Optional
+from typing import Any, Dict, Literal, Mapping
 
 import pydantic
 
 from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
-from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.parameter import Parameter
-from classiq.interface.model.quantum_variable_declaration import (
-    QuantumVariableDeclaration,
-)
 
 
 class AnonPortDeclaration(Parameter):
     kind: Literal["PortDeclaration"]
 
     quantum_type: ConcreteQuantumType
-    size: Optional[Expression] = pydantic.Field(default=None, exclude=True)
     direction: PortDeclarationDirection
 
     @pydantic.root_validator(pre=True)
@@ -37,12 +32,6 @@ class AnonPortDeclaration(Parameter):
 
         return direction
 
-    @pydantic.validator("size")
-    def _propagate_size_to_type(
-        cls, size: Optional[Expression], values: Mapping[str, Any]
-    ) -> Optional[Expression]:
-        return QuantumVariableDeclaration._propagate_size_to_type(size, values)
-
     def rename(self, new_name: str) -> "PortDeclaration":
         if type(self) not in (AnonPortDeclaration, PortDeclaration):
             raise ClassiqInternalError

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,7 +1,8 @@
-from typing import Dict, Literal, Mapping, Sequence
+from typing import Dict, Literal, Mapping, Optional, Sequence
 
 import pydantic
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
     ARITHMETIC_EXPRESSION_RESULT_NAME,
     compute_arithmetic_result_type,
@@ -17,13 +18,40 @@ from classiq.interface.model.quantum_statement import HandleMetadata
 from classiq.interface.model.quantum_type import QuantumType
 
 
+class ArithmeticOperationKind(StrEnum):
+    InplaceAdd = "inplace_add"
+    Assignment = "assignment"
+    InplaceXor = "inplace_xor"
+
+
 class ArithmeticOperation(QuantumAssignmentOperation):
     kind: Literal["ArithmeticOperation"]
 
-    inplace_result: bool = pydantic.Field(
+    inplace_result: Optional[bool] = pydantic.Field(
         description="Determines whether the result variable is initialized",
+        default=None,
+        exclude=True,
+    )
+
+    operation_kind: ArithmeticOperationKind = pydantic.Field(
+        default=ArithmeticOperationKind.InplaceXor,
     )
 
+    @property
+    def is_inplace(self) -> bool:
+        return self.get_operation_kind() in (
+            ArithmeticOperationKind.InplaceXor,
+            ArithmeticOperationKind.InplaceAdd,
+        )
+
+    def get_operation_kind(self) -> ArithmeticOperationKind:
+        if hasattr(self, "inplace_result"):
+            if self.inplace_result is False:
+                return ArithmeticOperationKind.Assignment
+            if self.inplace_result is True:
+                return ArithmeticOperationKind.InplaceXor
+        return self.operation_kind
+
     def initialize_var_types(
         self,
         var_types: Dict[str, QuantumType],
@@ -39,7 +67,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
         self,
     ) -> Mapping[str, ConcreteHandleBinding]:
         inouts = dict(super().wiring_inouts)
-        if self.inplace_result:
+        if self.is_inplace:
             inouts[self.result_name()] = self.result_var
         return inouts
 
@@ -49,7 +77,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
             HandleMetadata(handle=handle, readable_location="in an expression")
             for handle in self.var_handles
         ]
-        if self.inplace_result:
+        if self.is_inplace:
             inouts.append(
                 HandleMetadata(
                     handle=self.result_var,
@@ -60,13 +88,13 @@ class ArithmeticOperation(QuantumAssignmentOperation):
 
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        if self.inplace_result:
+        if self.is_inplace:
             return {}
         return super().wiring_outputs
 
     @property
     def readable_outputs(self) -> Sequence[HandleMetadata]:
-        if self.inplace_result:
+        if self.is_inplace:
             return []
         return [
             HandleMetadata(

classiq/interface/model/quantum_lambda_function.py

@@ -19,7 +19,7 @@ class QuantumLambdaFunction(ASTNode):
 
     rename_params: Dict[str, str] = pydantic.Field(
         default_factory=dict,
-        exclude=False,
+        exclude=True,
     )
 
     pos_rename_params: List[str] = pydantic.Field(
@@ -41,6 +41,9 @@ class QuantumLambdaFunction(ASTNode):
     def py_callable(self) -> Callable:
         return self._py_callable
 
+    def is_generative(self) -> bool:
+        return self.py_callable is not None
+
     def set_py_callable(self, py_callable: Callable) -> None:
         self._py_callable = py_callable
 

classiq/interface/model/quantum_statement.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
-from typing import Any, Dict, Mapping, Optional, Sequence
+from typing import Any, Callable, Dict, Mapping, Optional, Sequence
 
+import pydantic
 from pydantic import Extra, root_validator
 
 from classiq.interface.ast_node import ASTNode
@@ -29,6 +30,8 @@ class HandleMetadata:
 
 
 class QuantumOperation(QuantumStatement):
+    _generative_blocks: Dict[str, Callable] = pydantic.PrivateAttr(default_factory=dict)
+
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:
         return dict()
@@ -64,3 +67,15 @@ class QuantumOperation(QuantumStatement):
     @property
     def readable_outputs(self) -> Sequence[HandleMetadata]:
         return [HandleMetadata(handle=handle) for handle in self.outputs]
+
+    def set_generative_block(self, block_name: str, py_callable: Callable) -> None:
+        self._generative_blocks[block_name] = py_callable
+
+    def get_generative_block(self, block_name: str) -> Callable:
+        return self._generative_blocks[block_name]
+
+    def has_generative_block(self, block_name: str) -> bool:
+        return block_name in self._generative_blocks
+
+    def is_generative(self) -> bool:
+        return len(self._generative_blocks) > 0