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

classiq/open_library/functions/modular_exponentiation.py

@@ -11,24 +11,18 @@ from classiq.qmod.builtins.operations import (
 )
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.symbolic import min, mod_inverse
 
 
 @qfunc
 def _check_msb(ref: CInt, x: QArray[QBit], aux: QBit) -> None:
     within_apply(
-        lambda: invert(lambda: qft_no_swap(x)), lambda: _ctrl_x(ref, x[0], aux)
+        lambda: invert(lambda: qft_no_swap(x)),
+        lambda: control(x[0] == ref, lambda: X(aux)),
     )
 
 
-@qfunc
-def _ctrl_x(
-    ref: CInt, ctrl: QNum, aux: QBit
-) -> None:  # TODO: remove qfunc when expressions of QBit is supported
-    control(ctrl == ref, lambda: X(aux))
-
-
 @qfunc
 def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
     """
@@ -72,27 +66,21 @@ def cc_modular_add(n: CInt, a: CInt, phi_b: QArray[QBit], c1: QBit, c2: QBit) ->
         c2: a control qubit.
 
     """
-    ctrl: QArray[QBit] = QArray("ctrl")
-    aux = QBit("aux")
+    ctrl: QArray[QBit] = QArray()
+    aux = QBit()
 
     within_apply(
-        lambda: (  # type:ignore[arg-type]
-            allocate(1, aux),
-            bind([c1, c2], ctrl),  # type:ignore[func-returns-value]
+        lambda: (
+            allocate(aux),
+            bind([c1, c2], ctrl),
         ),
-        lambda: (  # type:ignore[arg-type]
-            control(  # type:ignore[func-returns-value]
-                ctrl, lambda: qft_space_add_const(a, phi_b)
-            ),
-            invert(  # type:ignore[func-returns-value]
-                lambda: qft_space_add_const(n, phi_b)
-            ),
+        lambda: (
+            control(ctrl, lambda: qft_space_add_const(a, phi_b)),
+            invert(lambda: qft_space_add_const(n, phi_b)),
             _check_msb(1, phi_b, aux),
-            control(  # type:ignore[func-returns-value]
-                aux, lambda: qft_space_add_const(n, phi_b)
-            ),
+            control(aux, lambda: qft_space_add_const(n, phi_b)),
             within_apply(
-                lambda: invert(  # type:ignore[func-returns-value]
+                lambda: invert(
                     lambda: control(ctrl, lambda: qft_space_add_const(a, phi_b))
                 ),
                 lambda: _check_msb(0, phi_b, aux),
@@ -162,18 +150,14 @@ def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) ->
         x: The quantum factor.
         ctrl: The control bit.
     """
-    b: QArray[QBit] = QArray("b")
+    b: QArray[QBit] = QArray()
 
     within_apply(
         lambda: allocate(x.len + 1, b),
-        lambda: (  # type:ignore[arg-type]
+        lambda: (
             c_modular_multiply(n, a, b, x, ctrl),
-            control(  # type:ignore[func-returns-value]
-                ctrl, lambda: multiswap(x, b)
-            ),
-            invert(  # type:ignore[func-returns-value]
-                lambda: c_modular_multiply(n, mod_inverse(a, n), b, x, ctrl)
-            ),
+            control(ctrl, lambda: multiswap(x, b)),
+            invert(lambda: c_modular_multiply(n, mod_inverse(a, n), b, x, ctrl)),
         ),
     )
 

classiq/open_library/functions/qft_functions.py

@@ -18,9 +18,9 @@ def qft_no_swap(qbv: QArray[QBit]) -> None:
     """
     repeat(
         qbv.len,
-        lambda i: (  # type:ignore[arg-type]
+        lambda i: (
             H(qbv[i]),
-            repeat(  # type:ignore[func-returns-value]
+            repeat(
                 qbv.len - i - 1,
                 lambda j: CPHASE(
                     theta=pi / (2 ** (j + 1)),

classiq/open_library/functions/qsvt.py

@@ -97,8 +97,8 @@ def qsvt(
     if_(
         condition=phase_seq.len % 2 == 1,
         then=lambda: IDENTITY(qvar),
-        else_=lambda: (  # type:ignore[arg-type]
-            u(qvar),  # type:ignore[func-returns-value]
+        else_=lambda: (
+            u(qvar),
             projector_controlled_phase(
                 phase_seq[phase_seq.len - 1],
                 proj_cnot_2,
@@ -297,8 +297,8 @@ def qsvt_lcu(
         condition=phase_seq_odd.len > phase_seq_even.len,
         then=lambda: control(
             lcu == 0,
-            lambda: [  # type:ignore[arg-type]
-                u(qvar),  # type:ignore[func-returns-value]
+            lambda: [
+                u(qvar),
                 projector_controlled_phase(
                     phase_seq_odd[phase_seq_odd.len - 1], proj_cnot_2, qvar, aux
                 ),
@@ -307,8 +307,8 @@ def qsvt_lcu(
     )
     if_(
         condition=phase_seq_odd.len < phase_seq_even.len,
-        then=lambda: (  # type:ignore[arg-type]
-            u(qvar),  # type:ignore[func-returns-value]
+        then=lambda: (
+            u(qvar),
             projector_controlled_double_phase(
                 phase_seq_even[phase_seq_even.len - 1],
                 phase_seq_odd[phase_seq_odd.len - 1],
@@ -319,8 +319,8 @@ def qsvt_lcu(
             ),
             control(
                 lcu,
-                lambda: [  # type:ignore[arg-type]
-                    invert(lambda: u(qvar)),  # type:ignore[func-returns-value]
+                lambda: [
+                    invert(lambda: u(qvar)),
                     projector_controlled_phase(
                         phase_seq_even[phase_seq_even.len - 1], proj_cnot_1, qvar, aux
                     ),

classiq/open_library/functions/state_preparation.py

@@ -3,12 +3,9 @@ from typing import Literal
 
 from classiq.interface.exceptions import ClassiqDeprecationWarning
 
-from classiq.open_library.functions.utility_functions import (
-    hadamard_transform,
-    modular_increment,
-)
+from classiq.open_library.functions.utility_functions import hadamard_transform
 from classiq.qmod.builtins.functions.standard_gates import CX, IDENTITY, RY, H, X
-from classiq.qmod.builtins.operations import allocate, control, if_, repeat
+from classiq.qmod.builtins.operations import allocate, control, if_, inplace_add, repeat
 from classiq.qmod.cparam import CBool, CInt
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
@@ -48,7 +45,7 @@ def allocate_num(
     allocate(num_qubits, out)
 
 
-def prepare_uniform_trimmed_state_apply_rotation(
+def _prepare_uniform_trimmed_state_apply_rotation(
     size_lsb: CInt, lsbs_val: CInt, rotation_var: QBit
 ) -> None:
     # max hold for the case where the value is on the left side
@@ -68,7 +65,7 @@ def _prepare_uniform_trimmed_state_step(
         lsbs_val != 0,  # stop condition
         lambda: control(
             ctrl_var == ctrl_val,
-            lambda: prepare_uniform_trimmed_state_apply_rotation(
+            lambda: _prepare_uniform_trimmed_state_apply_rotation(
                 size_lsb, lsbs_val, rotation_var
             ),
         ),
@@ -102,7 +99,7 @@ def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
     if_(
         m < 2**q.len,
         # initial step without control
-        lambda: prepare_uniform_trimmed_state_apply_rotation(
+        lambda: _prepare_uniform_trimmed_state_apply_rotation(
             q.len - 1,  # type:ignore[arg-type]
             m,
             q[q.len - 1],
@@ -122,7 +119,7 @@ def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
 
 
 @qfunc
-def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> None:
+def prepare_uniform_interval_state(start: CInt, end: CInt, q: QNum) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -144,7 +141,7 @@ def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> N
         2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
     prepare_uniform_trimmed_state(end - start, q)
-    modular_increment(start, q)
+    inplace_add(start, q)
 
 
 @qfunc
@@ -199,7 +196,9 @@ def prepare_exponential_state(rate: CInt, q: QArray[QBit]) -> None:
 
 
 @qfunc
-def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) -> None:
+def prepare_bell_state(
+    state_num: CInt, qpair: Output[QArray[QBit, Literal[2]]]
+) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -207,7 +206,7 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
 
     Args:
         state_num: The number of the Bell state to be prepared. Must be an integer between 0 and 3.
-        q: The quantum variable that will receive the initialized state. Must be uninitialized.
+        qpair: The quantum variable that will receive the initialized state. Must be uninitialized.
 
     Bell States:
         The four Bell states are defined as follows (each state correlates to an integer between 0 and 3 as defined by the `state_num` argument):
@@ -241,11 +240,11 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
 
 
     """
-    allocate(2, q)
-    if_(logical_or(state_num == 1, state_num == 3), lambda: X(q[0]))
-    if_(logical_or(state_num == 2, state_num == 3), lambda: X(q[1]))
-    H(q[0])
-    CX(q[0], q[1])
+    allocate(qpair)
+    if_(logical_or(state_num == 1, state_num == 3), lambda: X(qpair[0]))
+    if_(logical_or(state_num == 2, state_num == 3), lambda: X(qpair[1]))
+    H(qpair[0])
+    CX(qpair[0], qpair[1])
 
 
 @qfunc

classiq/open_library/functions/swap_test.py

@@ -21,7 +21,7 @@ def swap_test(state1: QArray[QBit], state2: QArray[QBit], test: Output[QBit]) ->
         state2: A quantum state to check its overlap with state1.
         test: A qubit for which the probability of measuring 0 is $0.5*(|\\langle state1 | state2 \\rangle |^2+1)$
     """
-    allocate(1, test)
+    allocate(test)
     H(test)
     control(test, lambda: repeat(state1.len, lambda i: SWAP(state1[i], state2[i])))
     H(test)

classiq/open_library/functions/utility_functions.py

@@ -1,5 +1,8 @@
+import warnings
 from typing import Annotated
 
+from classiq.interface.exceptions import ClassiqDeprecationWarning
+
 from classiq.open_library.functions.qft_functions import qft
 from classiq.qmod.builtins.functions.standard_gates import PHASE, H
 from classiq.qmod.builtins.operations import bind, repeat, within_apply
@@ -44,7 +47,7 @@ def hadamard_transform(target: QArray[QBit]) -> None:
         target:  qubits to apply to Hadamard transform to.
 
     """
-    apply_to_all(H, target)
+    repeat(target.len, lambda index: H(target[index]))
 
 
 @qfunc
@@ -69,10 +72,15 @@ def modular_increment(a: CInt, x: QNum) -> None:
         x: A quantum number that is assumed to be non-negative integer.
 
     """
-    array_cast: QArray = QArray("array_cast")
+    warnings.warn(
+        "Function 'modular_increment' is deprecated. Use in-place-add statement in the form '<var> += <expression>'  or 'inplace_add(<expression>, <var>)' instead.",
+        ClassiqDeprecationWarning,
+        stacklevel=1,
+    )
+    array_cast: QArray = QArray()
     within_apply(
-        lambda: (  # type:ignore[arg-type]
-            bind(x, array_cast),  # type:ignore[func-returns-value]
+        lambda: (
+            bind(x, array_cast),
             qft(array_cast),
         ),
         lambda: repeat(

classiq/qmod/builtins/classical_functions.py

@@ -12,19 +12,25 @@ def qft_const_adder_phase(
     value: CInt,
     reg_len: CInt,
 ) -> CReal:
-    return symbolic_function(bit_index, value, reg_len, return_type=CReal)
+    return symbolic_function(
+        bit_index, value, reg_len, return_type=CReal  # type:ignore[type-abstract]
+    )
 
 
 def fock_hamiltonian_problem_to_hamiltonian(
     problem: FockHamiltonianProblem,
 ) -> CArray[PauliTerm]:
-    return symbolic_function(problem, return_type=CArray[PauliTerm])
+    return symbolic_function(
+        problem, return_type=CArray[PauliTerm]  # type:ignore[type-abstract]
+    )
 
 
 def molecule_problem_to_hamiltonian(
     problem: MoleculeProblem,
 ) -> CArray[PauliTerm]:
-    return symbolic_function(problem, return_type=CArray[PauliTerm])
+    return symbolic_function(
+        problem, return_type=CArray[PauliTerm]  # type:ignore[type-abstract]
+    )
 
 
 def grid_entangler_graph(
@@ -33,14 +39,19 @@ def grid_entangler_graph(
     grid_randomization: CBool,
 ) -> CArray[CArray[CInt]]:
     return symbolic_function(
-        num_qubits, schmidt_rank, grid_randomization, return_type=CArray[CArray[CInt]]
+        num_qubits,
+        schmidt_rank,
+        grid_randomization,
+        return_type=CArray[CArray[CInt]],  # type:ignore[type-abstract]
     )
 
 
 def hypercube_entangler_graph(
     num_qubits: CInt,
 ) -> CArray[CArray[CInt]]:
-    return symbolic_function(num_qubits, return_type=CArray[CArray[CInt]])
+    return symbolic_function(
+        num_qubits, return_type=CArray[CArray[CInt]]  # type:ignore[type-abstract]
+    )
 
 
 def gaussian_finance_post_process(
@@ -49,7 +60,10 @@ def gaussian_finance_post_process(
     probability: CReal,
 ) -> CReal:
     return symbolic_function(
-        finance_model, estimation_method, probability, return_type=CReal
+        finance_model,
+        estimation_method,
+        probability,
+        return_type=CReal,  # type:ignore[type-abstract]
     )
 
 
@@ -59,7 +73,10 @@ def log_normal_finance_post_process(
     probability: CReal,
 ) -> CReal:
     return symbolic_function(
-        finance_model, estimation_method, probability, return_type=CReal
+        finance_model,
+        estimation_method,
+        probability,
+        return_type=CReal,  # type:ignore[type-abstract]
     )
 
 

classiq/qmod/builtins/enums.py

@@ -149,6 +149,7 @@ class Optimizer(IntEnum):
     L_BFGS_B = 3
     NELDER_MEAD = 4
     ADAM = 5
+    SLSQP = 6
 
 
 class Pauli(IntEnum):

classiq/qmod/builtins/functions/__init__.py

@@ -64,6 +64,7 @@ CORE_LIB_DECLS = [
         inplace_prepare_state,
         inplace_prepare_amplitudes,
         single_pauli_exponent,
+        commuting_paulis_exponent,
         suzuki_trotter,
         qdrift,
         exponentiation_with_depth_constraint,
@@ -129,6 +130,7 @@ __all__ = [  # noqa: RUF022
     "randomized_benchmarking",
     "real_xor_constant",
     "single_pauli_exponent",
+    "commuting_paulis_exponent",
     "suzuki_trotter",
     "unitary",
     "RESET",

classiq/qmod/builtins/functions/chemistry.py

@@ -1,5 +1,3 @@
-from typing import Literal
-
 from classiq.qmod.builtins.structs import (
     FockHamiltonianProblem,
     MoleculeProblem,
@@ -13,12 +11,7 @@ from classiq.qmod.qmod_variable import QArray, QBit
 def molecule_ucc(
     molecule_problem: MoleculeProblem,
     excitations: CArray[CInt],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -27,12 +20,7 @@ def molecule_ucc(
 def molecule_hva(
     molecule_problem: MoleculeProblem,
     reps: CInt,
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -40,12 +28,7 @@ def molecule_hva(
 @qfunc(external=True)
 def molecule_hartree_fock(
     molecule_problem: MoleculeProblem,
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -54,12 +37,7 @@ def molecule_hartree_fock(
 def fock_hamiltonian_ucc(
     fock_hamiltonian_problem: FockHamiltonianProblem,
     excitations: CArray[CInt],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -68,12 +46,7 @@ def fock_hamiltonian_ucc(
 def fock_hamiltonian_hva(
     fock_hamiltonian_problem: FockHamiltonianProblem,
     reps: CInt,
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -81,11 +54,6 @@ def fock_hamiltonian_hva(
 @qfunc(external=True)
 def fock_hamiltonian_hartree_fock(
     fock_hamiltonian_problem: FockHamiltonianProblem,
-    qbv: QArray[
-        QBit,
-        Literal[
-            "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
-        ],
-    ],
+    qbv: QArray[QBit],
 ) -> None:
     pass

classiq/qmod/builtins/functions/exponentiation.py

@@ -28,6 +28,30 @@ def single_pauli_exponent(
     pass
 
 
+@qfunc(external=True)
+def commuting_paulis_exponent(
+    pauli_operator: CArray[PauliTerm],
+    evolution_coefficient: CReal,
+    qbv: QArray[
+        QBit, Literal["get_field(get_field(pauli_operator[0], 'pauli'), 'len')"]
+    ],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Exponentiates the specified commutative Pauli operator.
+    As all the Pauli operator's terms commute, the exponential of the whole operator
+    is exactly the product of exponentials of each term.
+    Calling this funciton with a non-commutative Pauli operator will issue an error.
+
+    Args:
+        pauli_operator: The Pauli operator to be exponentiated.
+        evolution_coefficient: A global evolution coefficient multiplying the Pauli operator.
+        qbv: The target quantum variable of the exponentiation.
+    """
+    pass
+
+
 @qfunc(external=True)
 def suzuki_trotter(
     pauli_operator: CArray[PauliTerm],

classiq/qmod/builtins/operations.py

@@ -48,7 +48,7 @@ from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QScalar, QVa
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.quantum_expandable import prepare_arg
 from classiq.qmod.symbolic_expr import SymbolicExpr
-from classiq.qmod.utilities import get_source_ref
+from classiq.qmod.utilities import Statements, get_source_ref, suppress_return_value
 
 _MISSING_VALUE: Final[int] = -1
 
@@ -63,6 +63,7 @@ def allocate(out: Output[QVar]) -> None:
     pass
 
 
+@suppress_return_value
 def allocate(*args: Any, **kwargs: Any) -> None:
     """
     Initialize a quantum variable to a new quantum object in the zero state:
@@ -106,6 +107,7 @@ def allocate(*args: Any, **kwargs: Any) -> None:
     )
 
 
+@suppress_return_value
 def bind(
     source: Union[Input[QVar], list[Input[QVar]]],
     destination: Union[Output[QVar], list[Output[QVar]]],
@@ -125,10 +127,11 @@ def bind(
     )
 
 
+@suppress_return_value
 def if_(
     condition: Union[SymbolicExpr, bool],
-    then: Union[QCallable, Callable[[], None]],
-    else_: Union[QCallable, Callable[[], None], int] = _MISSING_VALUE,
+    then: Union[QCallable, Callable[[], Statements]],
+    else_: Union[QCallable, Callable[[], Statements], int] = _MISSING_VALUE,
 ) -> None:
     _validate_operand(then)
     if else_ != _MISSING_VALUE:
@@ -149,10 +152,11 @@ def if_(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(if_stmt)
 
 
+@suppress_return_value
 def control(
     ctrl: Union[SymbolicExpr, QBit, QArray[QBit]],
-    stmt_block: Union[QCallable, Callable[[], None]],
-    else_block: Union[QCallable, Callable[[], None], None] = None,
+    stmt_block: Union[QCallable, Callable[[], Statements]],
+    else_block: Union[QCallable, Callable[[], Statements], None] = None,
 ) -> None:
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
@@ -170,6 +174,7 @@ def control(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(control_stmt)
 
 
+@suppress_return_value
 def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Initialize a scalar quantum variable using an arithmetic expression.
@@ -194,6 +199,7 @@ def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
+@suppress_return_value
 def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Perform an amplitude-encoding assignment operation on a quantum variable and a
@@ -216,6 +222,7 @@ def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
+@suppress_return_value
 def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Add an arithmetic expression to a quantum variable.
@@ -238,6 +245,7 @@ def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
+@suppress_return_value
 def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
     """
     Bitwise-XOR a quantum variable with an arithmetic expression.
@@ -260,9 +268,10 @@ def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
+@suppress_return_value
 def within_apply(
-    within: Callable[[], None],
-    apply: Callable[[], None],
+    within: Callable[[], Statements],
+    apply: Callable[[], Statements],
 ) -> None:
     _validate_operand(within)
     _validate_operand(apply)
@@ -279,7 +288,10 @@ def within_apply(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(within_apply_stmt)
 
 
-def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) -> None:
+@suppress_return_value
+def repeat(
+    count: Union[SymbolicExpr, int], iteration: Callable[[int], Statements]
+) -> None:
     _validate_operand(iteration)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -310,9 +322,10 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(repeat_stmt)
 
 
+@suppress_return_value
 def power(
     exponent: Union[SymbolicExpr, int],
-    stmt_block: Union[QCallable, Callable[[], None]],
+    stmt_block: Union[QCallable, Callable[[], Statements]],
 ) -> None:
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
@@ -327,7 +340,8 @@ def power(
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(power_stmt)
 
 
-def invert(stmt_block: Union[QCallable, Callable[[], None]]) -> None:
+@suppress_return_value
+def invert(stmt_block: Union[QCallable, Callable[[], Statements]]) -> None:
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -339,6 +353,7 @@ def invert(stmt_block: Union[QCallable, Callable[[], None]]) -> None:
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(invert_stmt)
 
 
+@suppress_return_value
 def phase(expr: SymbolicExpr, theta: float = 1.0) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -402,7 +417,7 @@ def _get_operand_hint(
 
 
 def _operand_to_body(
-    callable_: Union[QCallable, Callable[[], None]], param_name: str
+    callable_: Union[QCallable, Callable[[], Statements]], param_name: str
 ) -> StatementBlock:
     op_name = sys._getframe(1).f_code.co_name
     if (