classiq 0.84.0__py3-none-any.whl → 0.85.0__py3-none-any.whl

classiq/interface/model/variable_declaration_statement.py

@@ -1,15 +1,42 @@
-from typing import Literal
+from typing import Any, Literal, Optional
+
+import pydantic
 
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.quantum_statement import QuantumStatement
-from classiq.interface.model.quantum_variable_declaration import (
-    QuantumVariableDeclaration,
+from classiq.interface.generator.functions.concrete_types import (
+    ConcreteQuantumType,
+    ConcreteType,
 )
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.quantum_type import QuantumType
 
 
-class VariableDeclarationStatement(QuantumStatement, QuantumVariableDeclaration):
+class VariableDeclarationStatement(QuantumStatement):
     kind: Literal["VariableDeclarationStatement"]
 
+    name: str
+    quantum_type: Optional[ConcreteQuantumType] = None
+    qmod_type: ConcreteType
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_qmod_type(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            if "quantum_type" in values and (
+                "qmod_type" not in values or values["qmod_type"] is None
+            ):
+                values["qmod_type"] = values["quantum_type"]
+                values["quantum_type"] = None
+            return values
+        if values.quantum_type is not None and values.qmod_type is None:
+            values.qmod_type = values.quantum_type
+            values.quantum_type = None
+        return values
+
     @property
     def expressions(self) -> list[Expression]:
-        return self.quantum_type.expressions
+        return self.qmod_type.expressions
+
+    @property
+    def is_quantum(self) -> bool:
+        return isinstance(self.qmod_type, QuantumType)

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -9,6 +9,9 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.atomic_expression_functions import (
+    MEASUREMENT_FUNCTIONS,
+)
 from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
@@ -398,7 +401,8 @@ def _symbolic_function(func: str) -> Callable:
 
 
 QMOD_CLASSICAL_FUNCTIONS = [
-    _symbolic_function(func) for func in qmod_classical_functions
+    _symbolic_function(func)
+    for func in qmod_classical_functions + list(MEASUREMENT_FUNCTIONS)
 ]
 
 ATOMIC_EXPRESSION_FUNCTIONS = {

classiq/model_expansions/function_builder.py

@@ -9,6 +9,7 @@ from classiq.interface.generator.compiler_keywords import (
     LAMBDA_KEYWORD,
 )
 from classiq.interface.generator.functions.builtins.internal_operators import (
+    BLOCK_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
 from classiq.interface.model.model import MAIN_FUNCTION_NAME
@@ -35,6 +36,8 @@ from classiq.model_expansions.utils.counted_name_allocator import CountedNameAll
 
 ClosureType = TypeVar("ClosureType", bound=Closure)
 
+BLOCKS_ALLOWED_CAPTURING = (WITHIN_APPLY_NAME, BLOCK_OPERATOR_NAME)
+
 
 @dataclass
 class Block:
@@ -142,7 +145,7 @@ class OperationBuilder:
         captured_vars = self.current_block.captured_vars
         if (
             not isinstance(self.current_operation, FunctionClosure)
-            and self.current_operation.name != WITHIN_APPLY_NAME
+            and self.current_operation.name not in BLOCKS_ALLOWED_CAPTURING
         ):
             validate_captured_directions(
                 captured_vars.filter_var_decls(

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -7,6 +7,7 @@ from numpy.random import permutation
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
+    BLOCK_OPERATOR_NAME,
     CLASSICAL_IF_OPERATOR_NAME,
     CONTROL_OPERATOR_NAME,
     INVERT_OPERATOR_NAME,
@@ -15,6 +16,7 @@ from classiq.interface.generator.functions.builtins.internal_operators import (
 )
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
 from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
@@ -68,6 +70,9 @@ from classiq.model_expansions.quantum_operations.block_evaluator import (
     RepeatElimination,
 )
 from classiq.model_expansions.quantum_operations.bounds import SetBoundsEmitter
+from classiq.model_expansions.quantum_operations.classical_var_emitter import (
+    ClassicalVarEmitter,
+)
 from classiq.model_expansions.quantum_operations.composite_emitter import (
     CompositeEmitter,
 )
@@ -192,6 +197,7 @@ class GenerativeInterpreter(BaseInterpreter):
             [
                 HandleEvaluator(self, "result_var"),
                 ExpressionEvaluator(self, "expression"),
+                ClassicalVarEmitter(self),
                 AssignmentResultProcessor(self),
             ],
         ).emit(op)
@@ -303,9 +309,18 @@ class GenerativeInterpreter(BaseInterpreter):
     def emit_set_bounds(self, op: SetBoundsStatement) -> None:
         CompositeEmitter[SetBoundsStatement](
             self,
-            [HandleEvaluator(self, "target"), SetBoundsEmitter(self)],
+            [
+                ExpressionEvaluator(self, "lower_bound"),
+                ExpressionEvaluator(self, "upper_bound"),
+                HandleEvaluator(self, "target"),
+                SetBoundsEmitter(self),
+            ],
         ).emit(op)
 
+    @emit.register
+    def emit_block(self, block: Block) -> None:
+        BlockEvaluator(self, BLOCK_OPERATOR_NAME, "statements").emit(block)
+
     def _expand_body(self, operation: Closure) -> None:
         if isinstance(operation, FunctionClosure) and operation.name == "permute":
             # special expansion since permute is generative

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,10 +1,12 @@
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
+from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.handle_binding import (
     ConcreteHandleBinding,
     HandleBinding,
@@ -19,6 +21,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
+from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -30,14 +33,25 @@ from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_exp
     validate_assignment_bool_expression,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
-from classiq.model_expansions.scope import QuantumSymbol
+from classiq.model_expansions.scope import ClassicalSymbol
 from classiq.model_expansions.transformers.ast_renamer import rename_variables
 from classiq.qmod.builtins.functions.standard_gates import CX
 
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
 
 class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", replace_assignment_if_needed: bool = False
+    ) -> None:
+        super().__init__(interpreter)
+        self._replace_assignment_if_needed = replace_assignment_if_needed
+
     def emit(self, op: QuantumAssignmentOperation, /) -> bool:
-        result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+        result_symbol = self._interpreter.evaluate(op.result_var).value
+        if isinstance(result_symbol, ClassicalSymbol):
+            return False
         result_type = result_symbol.quantum_type
 
         if not (
@@ -70,9 +84,11 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         self._validate_declared_attributes(
             result_type, inferred_result_type, str(op.result_var)
         )
-        self._assign_to_inferred_var_and_bind(op, result_type, inferred_result_type)
-        result_type.set_bounds(inferred_result_type.get_bounds())
-        return True
+        if self._replace_assignment_if_needed:
+            self._assign_to_inferred_var_and_bind(op, result_type, inferred_result_type)
+            return True
+        else:
+            return False
 
     def _infer_result_type(self, op: ArithmeticOperation) -> Optional[QuantumNumeric]:
         expr = self._evaluate_expression(op.expression)
@@ -182,6 +198,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         result_type: QuantumNumeric,
         inferred_result_type: QuantumNumeric,
     ) -> None:
+        stmts: StatementBlock = []
         handles: list[HandleBinding] = []
 
         extra_fraction_digits = (
@@ -190,20 +207,22 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         )
         if extra_fraction_digits > 0:
             handles.append(
-                self._declare_qarray("extra_fraction_digits", extra_fraction_digits)
+                self._declare_qarray(
+                    "extra_fraction_digits", extra_fraction_digits, stmts
+                )
             )
 
         inferred_result_name = self._counted_name_allocator.allocate("inferred_result")
         inferred_result_handle = HandleBinding(name=inferred_result_name)
-        self._interpreter.emit(
+        stmts.append(
             VariableDeclarationStatement(
-                name=inferred_result_name, quantum_type=inferred_result_type
+                name=inferred_result_name, qmod_type=inferred_result_type
             )
         )
         handles.append(inferred_result_handle)
         modified_op = op.model_copy(update={"result_var": inferred_result_handle})
         self._interpreter.add_to_debug_info(modified_op)
-        self._interpreter.emit(modified_op)
+        stmts.append(modified_op)
 
         result_integer_size = (
             result_type.size_in_bits - result_type.fraction_digits_value
@@ -214,11 +233,11 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         )
         extra_integers = result_integer_size - inferred_result_integer_size
         if extra_integers > 0:
-            handles.append(self._declare_qarray("extra_integers", extra_integers))
+            handles.append(
+                self._declare_qarray("extra_integers", extra_integers, stmts)
+            )
 
-        self._interpreter.emit(
-            BindOperation(in_handles=handles, out_handles=[op.result_var])
-        )
+        stmts.append(BindOperation(in_handles=handles, out_handles=[op.result_var]))
 
         if (
             result_type.sign_value
@@ -226,22 +245,44 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             and extra_integers > 0
         ):
             sign_idx = result_type.size_in_bits - extra_integers - 1
-            self._sign_extension(op.result_var, sign_idx, result_type.size_in_bits)
+            self._sign_extension(
+                op.result_var, sign_idx, result_type.size_in_bits, stmts
+            )
+
+        if (inferred_bounds := inferred_result_type.get_bounds()) is not None:
+            lower_bound = Expression(expr=str(inferred_bounds[0]))
+            upper_bound = Expression(expr=str(inferred_bounds[1]))
+        else:
+            lower_bound, upper_bound = None, None
+        stmts.append(
+            SetBoundsStatement(
+                target=op.result_var,
+                lower_bound=lower_bound,
+                upper_bound=upper_bound,
+            )
+        )
+
+        self._interpreter.emit(
+            Block(
+                statements=stmts,
+                uuid=op.uuid,
+                back_ref=op.back_ref,
+            )
+        )
 
     def _declare_qarray(
         self,
         prefix: str,
         size: int,
+        stmts: StatementBlock,
         allocate: bool = True,
     ) -> HandleBinding:
         name = self._counted_name_allocator.allocate(prefix)
         handle = HandleBinding(name=name)
         quantum_type = QuantumBitvector(length=Expression(expr=str(size)))
-        self._interpreter.emit(
-            VariableDeclarationStatement(name=name, quantum_type=quantum_type)
-        )
+        stmts.append(VariableDeclarationStatement(name=name, qmod_type=quantum_type))
         if allocate:
-            self._interpreter.emit(Allocate(target=handle))
+            stmts.append(Allocate(target=handle))
         return handle
 
     def _sign_extension(
@@ -249,9 +290,10 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         result_var: ConcreteHandleBinding,
         sign_idx: int,
         size: int,
+        stmts: StatementBlock,
     ) -> None:
-        aux = self._declare_qarray("inferred_result_aux", size, allocate=False)
-        self._interpreter.emit(
+        aux = self._declare_qarray("inferred_result_aux", size, stmts, allocate=False)
+        stmts.append(
             WithinApply(
                 compute=[BindOperation(in_handles=[result_var], out_handles=[aux])],
                 action=[

classiq/model_expansions/quantum_operations/bounds.py

@@ -24,7 +24,13 @@ class SetBoundsEmitter(Emitter[SetBoundsStatement]):
             raise ClassiqExpansionError(
                 f"Cannot set bounds of a non-numeric variable {op.target.qmod_expr!r}"
             )
-        target.quantum_type.set_bounds(op.bounds)
+
+        if op.lower_bound is not None and op.upper_bound is not None:
+            target.quantum_type.set_bounds(
+                (op.lower_bound.to_float_value(), op.upper_bound.to_float_value())
+            )
+        else:
+            target.quantum_type.reset_bounds()
         if self._keep_statement:
             self.emit_statement(op)
         return True

classiq/model_expansions/quantum_operations/classical_var_emitter.py

@@ -0,0 +1,16 @@
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+)
+
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import ClassicalSymbol
+
+
+class ClassicalVarEmitter(Emitter[ArithmeticOperation]):
+    def emit(self, op: ArithmeticOperation, /) -> bool:
+        result_symbol = self._interpreter.evaluate(op.result_var).value
+        if not isinstance(result_symbol, ClassicalSymbol):
+            return False
+        op._classical_assignment = True
+        self.emit_statement(op)
+        return True

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -1,14 +1,19 @@
+from typing import TYPE_CHECKING, Union
+
 from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_type import QuantumType
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 
 from classiq.evaluators.parameter_types import (
+    evaluate_type_in_classical_symbol,
     evaluate_type_in_quantum_symbol,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.model_expansions.scope import ClassicalSymbol, Evaluated, QuantumSymbol
 
 
 class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement]):
@@ -16,24 +21,39 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
         var_decl = variable_declaration.model_copy(
             update=dict(back_ref=variable_declaration.uuid)
         )
-        var_decl.quantum_type = variable_declaration.quantum_type.model_copy()
+        var_decl.qmod_type = variable_declaration.qmod_type.model_copy()
         if variable_declaration.name in self._current_scope:
             raise ClassiqExpansionError(
                 f"Variable {variable_declaration.name!r} is already defined"
             )
-        self._current_scope[variable_declaration.name] = Evaluated(
-            value=QuantumSymbol(
+        var_value: Union[QuantumSymbol, ClassicalSymbol]
+        if variable_declaration.is_quantum:
+            if TYPE_CHECKING:
+                assert isinstance(var_decl.qmod_type, QuantumType)
+            var_value = QuantumSymbol(
                 handle=HandleBinding(name=var_decl.name),
                 quantum_type=evaluate_type_in_quantum_symbol(
-                    var_decl.quantum_type,
+                    var_decl.qmod_type,
                     self._current_scope,
                     var_decl.name,
                 ),
-            ),
-            defining_function=self._builder.current_function,
-        )
-        self._builder.current_block.captured_vars.init_var(
-            var_decl.name, self._builder.current_function
+            )
+            self._builder.current_block.captured_vars.init_var(
+                var_decl.name, self._builder.current_function
+            )
+        else:
+            if TYPE_CHECKING:
+                assert isinstance(var_decl.qmod_type, ClassicalType)
+            var_value = ClassicalSymbol(
+                handle=HandleBinding(name=var_decl.name),
+                classical_type=evaluate_type_in_classical_symbol(
+                    var_decl.qmod_type,
+                    self._current_scope,
+                    var_decl.name,
+                ),
+            )
+        self._current_scope[variable_declaration.name] = Evaluated(
+            value=var_value, defining_function=self._builder.current_function
         )
         self.emit_statement(var_decl)
         return True

classiq/model_expansions/scope.py

@@ -21,6 +21,7 @@ from classiq.interface.generator.expressions.proxies.classical.classical_scalar_
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
+from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.helpers.text_utils import readable_list, s
 from classiq.interface.model.handle_binding import (
@@ -202,6 +203,12 @@ class QuantumSymbolList(QuantumVariable):
         return str(self.handles)
 
 
+@dataclass(frozen=True)
+class ClassicalSymbol:
+    handle: HandleBinding
+    classical_type: ClassicalType
+
+
 @singledispatch
 def evaluated_to_str(value: Any) -> str:
     return str(value)

classiq/model_expansions/transformers/var_splitter.py

@@ -218,7 +218,7 @@ class VarSplitter(ModelRenamer):
         return [
             VariableDeclarationStatement(
                 name=part.target_var_name,
-                quantum_type=part.target_var_type,
+                qmod_type=part.target_var_type,
             )
             for part in chain.from_iterable(symbol_parts.values())
         ]

classiq/open_library/functions/__init__.py

@@ -52,7 +52,6 @@ OPEN_LIBRARY_FUNCTIONS = [
     qsvt_inversion,
     qsvt_lcu,
     qsvt_lcu_step,
-    allocate_num,
     qaoa_mixer_layer,
     qaoa_cost_layer,
     qaoa_layer,
@@ -85,7 +84,6 @@ OPEN_LIBRARY_FUNCTIONS = [
 
 __all__ = [
     "_single_pauli",
-    "allocate_num",
     "amplitude_amplification",
     "amplitude_estimation",
     "apply_to_all",

classiq/open_library/functions/qaoa_penalty.py

@@ -1,5 +1,8 @@
+import warnings
 from typing import Literal
 
+from classiq.interface.exceptions import ClassiqDeprecationWarning
+
 from classiq.qmod.builtins.functions import RX, H, suzuki_trotter
 from classiq.qmod.builtins.operations import repeat
 from classiq.qmod.builtins.structs import PauliTerm
@@ -42,7 +45,11 @@ def qaoa_cost_layer(
         hamiltonian: The Hamiltonian terms for the QAOA model.
         target: The target quantum array variable.
     """
-    suzuki_trotter(hamiltonian, g, 1, 1, target)
+    with warnings.catch_warnings():  # FIXME: Remove (CLS-2912)
+        warnings.simplefilter(
+            "ignore", category=ClassiqDeprecationWarning
+        )  # FIXME: Remove (CLS-2912)
+        suzuki_trotter(hamiltonian, g, 1, 1, target)
 
 
 @qfunc

classiq/open_library/functions/state_preparation.py

@@ -27,7 +27,7 @@ from classiq.qmod.builtins.operations import (
     repeat,
     within_apply,
 )
-from classiq.qmod.cparam import CArray, CBool, CInt, CReal
+from classiq.qmod.cparam import CArray, CInt, CReal
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
 from classiq.qmod.symbolic import (
@@ -45,37 +45,6 @@ from classiq.qmod.symbolic import (
 )
 
 
-@qfunc
-def allocate_num(
-    num_qubits: CInt,
-    is_signed: CBool,
-    fraction_digits: CInt,
-    out: Output[
-        QNum[Literal["num_qubits"], Literal["is_signed"], Literal["fraction_digits"]]
-    ],
-) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    This function is **deprecated** and will no longer be supported starting on
-    16/06/2025 at the earliest. Instead, use `allocate` which supports the same
-    parameters.
-
-    Initializes a quantum number with the given number of qubits, sign, and fractional digits.
-
-    Args:
-        num_qubits: The number of qubits to allocate.
-        is_signed: Whether the number is signed or unsigned.
-        fraction_digits: The number of fractional digits.
-    """
-    warnings.warn(
-        "Function `allocate_num` is deprecated and will no longer be supported starting on 16/06/2025 at the earliest. Instead, use `allocate` which supports the same parameters. ",
-        ClassiqDeprecationWarning,
-        stacklevel=1,
-    )
-    allocate(num_qubits, out)
-
-
 def _prepare_uniform_trimmed_state_apply_rotation(
     size_lsb: CInt, lsbs_val: CInt, rotation_var: QBit
 ) -> None:

classiq/qmod/__init__.py

@@ -1,6 +1,7 @@
 from .builtins import *  # noqa: F403
 from .builtins import __all__ as _builtins_all
 from .cfunc import cfunc
+from .classical_variable import measure
 from .create_model_function import create_model
 from .expression_query import get_expression_numeric_attributes
 from .qfunc import qfunc
@@ -29,6 +30,7 @@ __all__ = [
     "QStruct",
     "cfunc",
     "create_model",
+    "measure",
     "get_expression_numeric_attributes",
     "qfunc",
     "write_qmod",

classiq/qmod/builtins/operations.py

@@ -7,6 +7,7 @@ from typing import (
     Callable,
     Final,
     NoReturn,
+    Optional,
     Union,
     overload,
 )
@@ -20,6 +21,8 @@ from classiq.interface.generator.functions.classical_type import Integer
 from classiq.interface.helpers.text_utils import s
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.block import Block
+from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -46,7 +49,7 @@ from classiq.interface.model.within_apply_operation import WithinApply
 
 from classiq.qmod.generative import is_generative_mode
 from classiq.qmod.qmod_constant import QConstant
-from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QScalar, QVar
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, QScalar, QVar
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
 from classiq.qmod.symbolic_expr import SymbolicExpr
@@ -398,6 +401,65 @@ def phase(expr: SymbolicExpr, theta: float = 1.0) -> None:
     )
 
 
+@suppress_return_value
+def block(
+    statements: Union[QCallable, Callable[[], Statements]],
+) -> None:
+    _validate_operand(statements)
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+
+    block_stmt = Block(
+        statements=_operand_to_body(statements, "statements"),
+        source_ref=source_ref,
+    )
+    if is_generative_mode():
+        block_stmt.set_generative_block("statements", statements)
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(block_stmt)
+
+
+@overload
+def reset_bounds(
+    target_var: QNum,
+) -> None:
+    pass
+
+
+@overload
+def reset_bounds(
+    target_var: QNum,
+    lower_bound: Union[float, SymbolicExpr],
+    upper_bound: Union[float, SymbolicExpr],
+) -> None:
+    pass
+
+
+@suppress_return_value
+def reset_bounds(
+    target_var: QNum,
+    lower_bound: Optional[Union[float, SymbolicExpr]] = None,
+    upper_bound: Optional[Union[float, SymbolicExpr]] = None,
+) -> None:
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+
+    lower_bound_expr = (
+        None if lower_bound is None else Expression(expr=str(lower_bound))
+    )
+    upper_bound_expr = (
+        None if upper_bound is None else Expression(expr=str(upper_bound))
+    )
+
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        SetBoundsStatement(
+            target=target_var.get_handle_binding(),
+            lower_bound=lower_bound_expr,
+            upper_bound=upper_bound_expr,
+            source_ref=source_ref,
+        )
+    )
+
+
 def _validate_operand(stmt_block: Any, num_params: int = 0) -> None:
     if stmt_block is None:
         _raise_operand_error(
@@ -502,6 +564,7 @@ __all__ = [
     "assign",
     "assign_amplitude",
     "bind",
+    "block",
     "control",
     "if_",
     "inplace_add",
@@ -510,6 +573,7 @@ __all__ = [
     "phase",
     "power",
     "repeat",
+    "reset_bounds",
     "within_apply",
 ]