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

classiq/qmod/builtins/enums.py

@@ -1,7 +1,11 @@
 from enum import IntEnum
+from typing import TYPE_CHECKING
 
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 
+if TYPE_CHECKING:
+    from classiq.qmod.builtins.structs import SparsePauliOp
+
 
 class Element(IntEnum):
     H = 0
@@ -176,6 +180,25 @@ class Pauli(IntEnum):
     """Z (int): Pauli-Z matrix, represented by the integer 3. \n
     $Z = \\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}$"""
 
+    def __call__(self, index: int) -> "SparsePauliOp":
+        from classiq.qmod.builtins.structs import (
+            IndexedPauli,
+            SparsePauliOp,
+            SparsePauliTerm,
+        )
+
+        return SparsePauliOp(
+            terms=[  # type:ignore[arg-type]
+                SparsePauliTerm(
+                    paulis=[  # type:ignore[arg-type]
+                        IndexedPauli(pauli=self, index=index)  # type:ignore[arg-type]
+                    ],
+                    coefficient=1.0,  # type:ignore[arg-type]
+                )
+            ],
+            num_qubits=index + 1,  # type:ignore[arg-type]
+        )
+
 
 class QSVMFeatureMapEntanglement(IntEnum):
     FULL = 0

classiq/qmod/builtins/functions/__init__.py

@@ -71,6 +71,7 @@ CORE_LIB_DECLS = [
         single_pauli_exponent,
         commuting_paulis_exponent,
         suzuki_trotter,
+        multi_suzuki_trotter,
         parametric_suzuki_trotter,
         sparse_suzuki_trotter,
         qdrift,
@@ -132,6 +133,7 @@ __all__ = [  # noqa: RUF022
     "molecule_hartree_fock",
     "molecule_hva",
     "molecule_ucc",
+    "multi_suzuki_trotter",
     "parametric_suzuki_trotter",
     "pauli_feature_map",
     "permute",

classiq/qmod/builtins/functions/exponentiation.py

@@ -55,13 +55,11 @@ def commuting_paulis_exponent(
 
 @qfunc(external=True)
 def suzuki_trotter(
-    pauli_operator: CArray[PauliTerm],
+    pauli_operator: SparsePauliOp,  # FIXME: Rename to hamiltonian (CLS-2912)
     evolution_coefficient: CReal,
     order: CInt,
     repetitions: CInt,
-    qbv: QArray[
-        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
-    ],
+    qbv: QArray[QBit],  # FIXME: Add length expr (CLS-2912)
 ) -> None:
     """
     [Qmod core-library function]
@@ -82,6 +80,36 @@ def suzuki_trotter(
     pass
 
 
+@qfunc(external=True)
+def multi_suzuki_trotter(
+    hamiltonians: CArray[SparsePauliOp],
+    evolution_coefficients: CArray[CReal],
+    order: CInt,
+    repetitions: CInt,
+    qbv: QArray,
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Applies the Suzuki-Trotter decomposition jointly to a sum of Hamiltonians
+    (represented as Pauli operators), each with its separate evolution coefficient,
+    approximating $\\exp{-iH_1t_1+H_2t_2+\\dots}$  with a specified order and number of
+    repetitions.
+
+    The Suzuki-Trotter decomposition is a method for approximating the exponential of a sum of operators by a product of exponentials of each operator.
+    The Suzuki-Trotter decomposition of a given order nullifies the error of the Taylor series expansion of the product of exponentials up to that order.
+    The error of a Suzuki-Trotter decomposition decreases as the order and number of repetitions increase.
+
+    Args:
+        hamiltonians: The hamitonians to be exponentiated, in sparse representation.
+        evolution_coefficients: The hamiltonian coefficients (can be link-time).
+        order: The order of the Suzuki-Trotter decomposition.
+        repetitions: The number of repetitions of the Suzuki-Trotter decomposition.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass
+
+
 @qfunc(external=True)
 def parametric_suzuki_trotter(
     paulis: CArray[CArray[Pauli]],

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

classiq/qmod/builtins/structs.py

@@ -1,6 +1,9 @@
 from dataclasses import dataclass, fields, is_dataclass
+from typing import Union
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.text_utils import are, readable_list, s
 
 from classiq.qmod.builtins.enums import LadderOperator, Pauli
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
@@ -56,13 +59,62 @@ class SparsePauliOp:
     Represents a collection of sparse Pauli operators.
 
     Attributes:
-        paulis (CArray[SparsePauliTerm]): The list of chosen sparse Pauli operators in the term, corresponds to a product of them. (See: SparsePauliTerm)
+        terms (CArray[SparsePauliTerm]): The list of chosen sparse Pauli terms, corresponds to a product of them. (See: SparsePauliTerm)
         num_qubits (CInt): The number of qubits in the Hamiltonian.
     """
 
-    paulis: CArray[SparsePauliTerm]
+    terms: CArray[SparsePauliTerm]
     num_qubits: CInt
 
+    def __mul__(self, obj: Union[float, "SparsePauliOp"]) -> "SparsePauliOp":
+        if isinstance(obj, (int, float, complex)):
+            return SparsePauliOp(
+                terms=[  # type:ignore[arg-type]
+                    SparsePauliTerm(
+                        paulis=term.paulis,
+                        coefficient=obj * term.coefficient,
+                    )
+                    for term in self.terms  # type:ignore[attr-defined]
+                ],
+                num_qubits=self.num_qubits,
+            )
+        if len(self.terms) != 1 or len(obj.terms) != 1:  # type:ignore[arg-type]
+            raise ClassiqValueError("Cannot attach a pauli to multiple pauli terms")
+        existing_indices = {
+            indexed_pauli.index for indexed_pauli in self.terms[0].paulis
+        }
+        added_indices = {indexed_pauli.index for indexed_pauli in obj.terms[0].paulis}
+        overlapping_indices = sorted(existing_indices.intersection(added_indices))
+        if len(overlapping_indices):
+            raise ClassiqValueError(
+                f"Pauli{s(overlapping_indices)} at "
+                f"{'indices' if len(overlapping_indices) > 1 else 'index'} "
+                f"{readable_list(overlapping_indices)} {are(overlapping_indices)} "
+                f"already assigned"
+            )
+        return SparsePauliOp(
+            terms=[  # type:ignore[arg-type]
+                SparsePauliTerm(
+                    paulis=self.terms[0].paulis + obj.terms[0].paulis,
+                    coefficient=self.terms[0].coefficient * obj.terms[0].coefficient,
+                )
+            ],
+            num_qubits=max(
+                self.num_qubits, obj.num_qubits  # type:ignore[call-overload]
+            ),
+        )
+
+    def __rmul__(self, obj: Union[float, "SparsePauliOp"]) -> "SparsePauliOp":
+        return self.__mul__(obj)
+
+    def __add__(self, other: "SparsePauliOp") -> "SparsePauliOp":
+        return SparsePauliOp(
+            terms=self.terms + other.terms,  # type:ignore[arg-type]
+            num_qubits=max(
+                self.num_qubits, other.num_qubits  # type:ignore[call-overload]
+            ),
+        )
+
 
 @dataclass
 class Position:
@@ -167,7 +219,7 @@ BUILTIN_STRUCT_DECLARATIONS = {
     struct_decl.__name__: StructDeclaration(
         name=struct_decl.__name__,
         variables={
-            field.name: PythonClassicalType().convert(field.type)
+            field.name: PythonClassicalType().convert(field.type, nested=True)
             for field in fields(struct_decl)
         },
     )

classiq/qmod/classical_variable.py

@@ -0,0 +1,74 @@
+import sys
+from typing import TYPE_CHECKING, Any
+
+from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import Bool, ClassicalType
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.qmod.cparam import CBool, CParam, CParamScalar
+from classiq.qmod.qmod_variable import QBit, _infer_variable_name
+from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.symbolic import symbolic_function
+from classiq.qmod.symbolic_type import SYMBOLIC_TYPES
+from classiq.qmod.utilities import get_source_ref
+
+
+def declare_classical_variable(
+    name: str, classical_type: ClassicalType, frame_depth: int
+) -> None:
+    if TYPE_CHECKING:
+        assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        VariableDeclarationStatement(
+            name=name,
+            qmod_type=classical_type,
+            source_ref=get_source_ref(sys._getframe(frame_depth)),
+        )
+    )
+
+
+def assign_classical_variable(target: CParam, value: Any, frame_depth: int) -> None:
+    if not isinstance(value, SYMBOLIC_TYPES):
+        raise TypeError(f"Invalid argument {value!r} for classical variable assignment")
+
+    if TYPE_CHECKING:
+        assert QCallable.CURRENT_EXPANDABLE is not None
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        ArithmeticOperation(
+            expression=Expression(expr=str(value)),
+            result_var=HandleBinding(name=str(target)),
+            operation_kind=ArithmeticOperationKind.Assignment,
+            source_ref=get_source_ref(sys._getframe(frame_depth)),
+        )
+    )
+
+
+def measure(var: QBit) -> CParamScalar:
+    """
+    Measures the given qubit. `measure` is a non-unitary operation.
+
+    Args:
+        var: a qubit variable
+
+    Returns:
+        the measurement result (a symbolic boolean variable)
+    """
+    name = _infer_variable_name(None, 2)
+    if name is None:
+        raise ClassiqInternalError("Could not infer measure var name")
+    declare_classical_variable(name, Bool(), 2)
+    res_var = CParamScalar(name)
+    res_val = symbolic_function(
+        var,
+        return_type=CBool,  # type:ignore[type-abstract]
+    )
+    assign_classical_variable(res_var, res_val, 2)
+    return res_var

classiq/qmod/declaration_inferrer.py

@@ -75,14 +75,15 @@ class _PythonClassicalType(PythonClassicalType):
         all_decls = BUILTIN_STRUCT_DECLARATIONS | self.qmodule.type_decls
         if py_type.__name__ in all_decls:
             classical_type.set_classical_struct_decl(
-                all_decls[py_type.__name__].model_copy()
+                all_decls[py_type.__name__].model_copy(deep=True)
             )
             return classical_type
 
         struct_decl = StructDeclaration(
             name=py_type.__name__,
             variables={
-                f.name: self.convert(f.type) for f in dataclasses.fields(py_type)
+                f.name: self.convert(f.type, nested=True)
+                for f in dataclasses.fields(py_type)
             },
         )
         check_duplicate_types([struct_decl, *self.qmodule.user_types()])

classiq/qmod/native/pretty_printer.py

@@ -1,13 +1,13 @@
 from collections.abc import Mapping
 from typing import Optional, Union
 
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 from classiq.interface.exceptions import ClassiqInternalError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     Integer,
     Real,
@@ -29,6 +29,7 @@ from classiq.interface.generator.visitor import NodeType
 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 (
     AnonClassicalParameterDeclaration,
@@ -76,20 +77,16 @@ from classiq.interface.model.quantum_type import (
     QuantumBitvector,
     QuantumNumeric,
 )
-from classiq.interface.model.quantum_variable_declaration import (
-    QuantumVariableDeclaration,
-)
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
+from classiq.interface.pretty_print.expression_to_qmod import transform_expression
 
 from classiq.open_library.functions import OPEN_LIBRARY_FUNCTIONS
-from classiq.qmod.native.expression_to_qmod import transform_expression
 from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
 class DSLPrettyPrinter(ModelVisitor):
@@ -190,11 +187,6 @@ class DSLPrettyPrinter(ModelVisitor):
         self._level -= 1
         return variables_str
 
-    def visit_QuantumVariableDeclaration(
-        self, var_decl: QuantumVariableDeclaration
-    ) -> str:
-        return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
-
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         modifier_str = (
             f"{port_decl.type_modifier} "
@@ -248,9 +240,6 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_Bool(self, ctbool: Bool) -> str:
         return "bool"
 
-    def visit_ClassicalList(self, ctlist: ClassicalList) -> str:
-        return f"{self.visit(ctlist.element_type)}[]"
-
     def visit_ClassicalArray(self, ctarray: ClassicalArray) -> str:
         element_type = self.visit(ctarray.element_type)
         if ctarray.length is not None:
@@ -267,9 +256,9 @@ class DSLPrettyPrinter(ModelVisitor):
         return type_.name
 
     def visit_VariableDeclarationStatement(
-        self, local_decl: VariableDeclarationStatement
+        self, var_decl: VariableDeclarationStatement
     ) -> str:
-        return f"{self._indent}{self.visit_QuantumVariableDeclaration(local_decl)};\n"
+        return f"{self._indent}{var_decl.name}: {self.visit(var_decl.qmod_type)};\n"
 
     def visit_AnonQuantumOperandDeclaration(
         self, op_decl: AnonQuantumOperandDeclaration
@@ -365,10 +354,10 @@ class DSLPrettyPrinter(ModelVisitor):
         return invert_code
 
     def visit_Block(self, block: Block) -> str:
-        invert_code = f"{self._indent}block {{\n"
-        invert_code += self._visit_body(block.statements)
-        invert_code += f"{self._indent}}}\n"
-        return invert_code
+        block_code = f"{self._indent}{{\n"
+        block_code += self._visit_body(block.statements)
+        block_code += f"{self._indent}}}\n"
+        return block_code
 
     def _visit_body(self, body: StatementBlock) -> str:
         code = ""
@@ -447,6 +436,17 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_OperandIdentifier(self, op: OperandIdentifier) -> str:
         return str(op)
 
+    def visit_SetBoundsStatement(self, op: SetBoundsStatement) -> str:
+        target = self.visit(op.target)
+        if op.lower_bound is None or op.upper_bound is None:
+            return f"{self._indent}reset_bounds({target});\n"
+        else:
+            lower_bound = self.visit(op.lower_bound)
+            upper_bound = self.visit(op.upper_bound)
+            return (
+                f"{self._indent}reset_bounds({target}, {lower_bound}, {upper_bound});\n"
+            )
+
     @property
     def _indent(self) -> str:
         return "  " * self._level

classiq/qmod/pretty_print/expression_to_python.py

@@ -6,8 +6,9 @@ from typing import Callable
 
 import numpy as np
 
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
+
 import classiq
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 IDENTIFIER = re.compile(r"[a-zA-Z_]\w*")
 BINARY_OPS: Mapping[type[ast.operator], str] = {

classiq/qmod/pretty_print/pretty_printer.py

@@ -3,13 +3,13 @@ from typing import Optional, Union, cast
 
 import black
 
+from classiq.interface.constants import DEFAULT_DECIMAL_PRECISION
 from classiq.interface.exceptions import ClassiqInternalError
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     Integer,
     Real,
@@ -30,6 +30,8 @@ from classiq.interface.generator.types.struct_declaration import StructDeclarati
 from classiq.interface.generator.visitor import NodeType, Visitor
 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 (
     AnonClassicalParameterDeclaration,
@@ -75,9 +77,6 @@ from classiq.interface.model.quantum_type import (
     QuantumBitvector,
     QuantumNumeric,
 )
-from classiq.interface.model.quantum_variable_declaration import (
-    QuantumVariableDeclaration,
-)
 from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
@@ -88,10 +87,11 @@ from classiq.interface.model.within_apply_operation import WithinApply
 import classiq
 from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
 from classiq.qmod.pretty_print.expression_to_python import transform_expression
-from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
 
 
 class VariableDeclarationAssignment(Visitor):
+    # FIXME: Support classical variable types
+
     def __init__(self, pretty_printer: "PythonPrettyPrinter") -> None:
         self.pretty_printer = pretty_printer
 
@@ -252,11 +252,6 @@ class PythonPrettyPrinter(ModelVisitor):
         self._level -= 1
         return variables_str
 
-    def visit_QuantumVariableDeclaration(
-        self, var_decl: QuantumVariableDeclaration
-    ) -> str:
-        return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
-
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
         var_type = self._extract_port_type(port_decl)
         return f"{port_decl.name}: {var_type}"
@@ -338,10 +333,6 @@ class PythonPrettyPrinter(ModelVisitor):
         self._imports["CBool"] = 1
         return "CBool"
 
-    def visit_ClassicalList(self, ctlist: ClassicalList) -> str:
-        self._imports["CArray"] = 1
-        return f"CArray[{self.visit(ctlist.element_type)}]"
-
     def visit_ClassicalArray(self, ctarray: ClassicalArray) -> str:
         self._imports["CArray"] = 1
         element_type = self.visit(ctarray.element_type)
@@ -366,14 +357,23 @@ class PythonPrettyPrinter(ModelVisitor):
             self._imports[type_.name] = 1
 
     def visit_VariableDeclarationStatement(
-        self, local_decl: VariableDeclarationStatement
+        self,
+        local_decl: VariableDeclarationStatement,
+        walrus: bool = False,
     ) -> str:
         type_name, params = VariableDeclarationAssignment(self).visit(
-            local_decl.quantum_type
+            local_decl.qmod_type
         )
         params = [f'"{local_decl.name}"'] + params
         param_args = ", ".join(params)
-        return f"{self._indent}{self.visit_QuantumVariableDeclaration(local_decl)} = {type_name}({param_args})\n"
+
+        res = f"{self._indent}{local_decl.name}"
+        if walrus:
+            res += " := "
+        else:
+            res += f": {self.visit(local_decl.qmod_type)} = "
+        res += f"{type_name}({param_args})\n"
+        return res
 
     def _visit_operand_arg_decl(self, arg_decl: AnonPositionalArg) -> str:
         if isinstance(arg_decl, AnonPortDeclaration):
@@ -481,6 +481,10 @@ class PythonPrettyPrinter(ModelVisitor):
         self._imports["invert"] = 1
         return f"{self._indent}invert({self._visit_body(invert.body)})\n"
 
+    def visit_Block(self, block: Block) -> str:
+        self._imports["block"] = 1
+        return f"{self._indent}block({self._visit_body(block.statements)})\n"
+
     def _visit_body(
         self, body: StatementBlock, operand_arguments: Optional[list[str]] = None
     ) -> str:
@@ -493,10 +497,8 @@ class PythonPrettyPrinter(ModelVisitor):
         self._level += 1
         for i, statement in enumerate(body):
             if isinstance(statement, VariableDeclarationStatement):
-                raise AssertionError(
-                    "pretty printing variable declaration statements in quantum lambda function is unsupported."
-                )
-            if isinstance(statement, AmplitudeLoadingOperation):
+                code += self.visit_VariableDeclarationStatement(statement, walrus=True)
+            elif isinstance(statement, AmplitudeLoadingOperation):
                 code += self.visit_AmplitudeLoadingOperation(statement, in_lambda=True)
             elif isinstance(statement, ArithmeticOperation):
                 code += self.visit_ArithmeticOperation(statement, in_lambda=True)
@@ -579,6 +581,18 @@ class PythonPrettyPrinter(ModelVisitor):
     def visit_OperandIdentifier(self, op: OperandIdentifier) -> str:
         return str(op)
 
+    def visit_SetBoundsStatement(self, op: SetBoundsStatement) -> str:
+        self._imports["reset_bounds"] = 1
+        target = self.visit(op.target)
+        if op.lower_bound is None or op.upper_bound is None:
+            return f"{self._indent}reset_bounds({target})\n"
+        else:
+            lower_bound = self.visit(op.lower_bound)
+            upper_bound = self.visit(op.upper_bound)
+            return (
+                f"{self._indent}reset_bounds({target}, {lower_bound}, {upper_bound})\n"
+            )
+
     @property
     def _indent(self) -> str:
         return "    " * self._level