classiq 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

classiq/qmod/builtins/functions/qpe.py

@@ -1,6 +1,10 @@
+from classiq.qmod.builtins.functions.qft_functions import qft
+from classiq.qmod.builtins.functions.standard_gates import H
+from classiq.qmod.builtins.functions.utility_functions import apply_to_all
+from classiq.qmod.builtins.operations import bind, control, invert, power, repeat
+from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_parameter import CInt
-from classiq.qmod.qmod_variable import QNum
+from classiq.qmod.qmod_variable import QArray, QNum
 from classiq.qmod.quantum_callable import QCallable
 
 
@@ -19,7 +23,19 @@ def qpe_flexible(unitary_with_power: QCallable[CInt], phase: QNum) -> None:
     Further reading in Classiq Library:
     Link: [qpe library reference](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/qpe/qpe.ipynb)
     """
-    pass
+    phase_array: QArray = QArray("phase_array")
+    bind(phase, phase_array)
+    apply_to_all(H, phase_array)
+
+    repeat(
+        count=phase_array.len,
+        iteration=lambda index: control(
+            ctrl=phase_array[index], stmt_block=lambda: unitary_with_power(2**index)
+        ),
+    )
+
+    invert(lambda: qft(phase_array))
+    bind(phase_array, phase)
 
 
 @qfunc(external=True)
@@ -36,4 +52,4 @@ def qpe(unitary: QCallable, phase: QNum) -> None:
     Further reading in Classiq Library:
     Link: [qpe library reference](https://github.com/Classiq/classiq-library/blob/main/functions/qmod_library_reference/classiq_open_library/qpe/qpe.ipynb)
     """
-    pass
+    qpe_flexible(unitary_with_power=lambda k: power(k, unitary), phase=phase)

classiq/qmod/builtins/functions/qsvt.py

@@ -1,7 +1,10 @@
+from classiq.qmod.builtins.functions.standard_gates import IDENTITY, RZ, H
+from classiq.qmod.builtins.operations import if_, invert, repeat
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.symbolic import floor
 
 
 @qfunc(external=True)
@@ -35,7 +38,10 @@ def qsvt_step(
     Further reading in Classiq Library:
         [QSVT function usage example](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt/)
     """
-    pass
+    u(qvar)
+    projector_controlled_phase(phase1, proj_cnot_2, qvar, aux)
+    invert(lambda: u(qvar))
+    projector_controlled_phase(phase2, proj_cnot_1, qvar, aux)
 
 
 @qfunc(external=True)
@@ -78,7 +84,37 @@ def qsvt(
     Further reading in Classiq Library:
         [QSVT function usage example](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt/)
     """
-    pass
+    H(aux)
+
+    projector_controlled_phase(phase_seq[0], proj_cnot_1, qvar, aux)
+    repeat(
+        count=floor((phase_seq.len - 1) / 2),
+        iteration=lambda index: qsvt_step(
+            phase_seq[2 * index + 1],
+            phase_seq[2 * index + 2],
+            proj_cnot_1,
+            proj_cnot_2,
+            u,
+            qvar,
+            aux,
+        ),
+    )
+
+    if_(
+        condition=phase_seq.len % 2 == 1,
+        then=lambda: IDENTITY(qvar),
+        else_=lambda: (  # type:ignore[arg-type]
+            u(qvar),  # type:ignore[func-returns-value]
+            projector_controlled_phase(
+                phase_seq[phase_seq.len - 1],
+                proj_cnot_2,
+                qvar,
+                aux,
+            ),
+        ),
+    )
+
+    H(aux)
 
 
 @qfunc(external=True)
@@ -106,7 +142,9 @@ def projector_controlled_phase(
     Further reading in Classiq Library:
         [QSVT function usage example](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/qsvt/qsvt/)
     """
-    pass
+    proj_cnot(qvar, aux)
+    RZ(phase, aux)
+    proj_cnot(qvar, aux)
 
 
 @qfunc(external=True)
@@ -133,4 +171,11 @@ def qsvt_inversion(
     For usage example, see:
         [QSVT matrix inversion example](https://docs.classiq.io/latest/explore/algorithms/qsvt/qsvt_matrix_inversion/qsvt_matrix_inversion)
     """
-    pass
+    qsvt(
+        phase_seq,
+        block_encoding_cnot,
+        block_encoding_cnot,
+        lambda x: invert(lambda: u(x)),
+        qvar,
+        aux,
+    )

classiq/qmod/builtins/functions/standard_gates.py

@@ -560,7 +560,7 @@ def CRY(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
     Args:
         theta (CReal): The rotation angle in radians.
-        control (QBit): The control qubit.
+        ctrl (QBit): The control qubit.
         target (QBit): The qubit to apply the RY gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -588,7 +588,7 @@ def CRZ(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
     Args:
         theta (CReal): The rotation angle in radians.
-        control (QBit): The control qubit.
+        ctrl (QBit): The control qubit.
         target (QBit): The qubit to apply the RZ gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -616,7 +616,7 @@ def CPHASE(theta: CReal, ctrl: QBit, target: QBit) -> None:
 
     Args:
         theta (CReal): The rotation angle in radians.
-        control (QBit): The control qubit.
+        ctrl (QBit): The control qubit.
         target (QBit): The qubit to apply the PHASE gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)
@@ -731,7 +731,7 @@ def CCX(ctrl: QArray[QBit, Literal[2]], target: QBit) -> None:
     More information can be found on [Wikipedia](https://en.wikipedia.org/wiki/Toffoli_gate).
 
     Args:
-        control (QArray[QBit, Literal[2]]): The control qubits.
+        ctrl (QArray[QBit, Literal[2]]): The control qubits.
         target (QBit): The qubit to apply the conditioned Pauli-X gate on.
 
     Link: [Reference Manual](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/core-library-functions/standard_gates/standard_gates/)

classiq/qmod/builtins/functions/state_preparation.py

@@ -1,8 +1,24 @@
 from typing import Literal
 
-from classiq.qmod.cparam import CArray, CBool, CInt, CReal
+from classiq.qmod.builtins.functions.arithmetic import modular_increment
+from classiq.qmod.builtins.functions.standard_gates import CX, IDENTITY, RY, H, X
+from classiq.qmod.builtins.functions.utility_functions import hadamard_transform
+from classiq.qmod.builtins.operations import control, if_, repeat
+from classiq.qmod.cparam import CBool, CInt
 from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum
+from classiq.qmod.symbolic import (
+    asin,
+    atan,
+    exp,
+    floor,
+    log,
+    max as qmax,
+    min as qmin,
+    pi,
+    sqrt,
+)
 
 
 @qfunc(external=True)
@@ -53,7 +69,7 @@ def allocate_num(
     Further reading is available on the [reference manual](https://docs.classiq.io/latest/reference-manual/qmod/language-reference/quantum-types#allocate-num)
 
     """
-    pass
+    allocate(num_qubits, out)
 
 
 @qfunc(external=True)
@@ -178,11 +194,31 @@ def inplace_prepare_amplitudes(
     pass
 
 
+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
+    # the fraction in the sqrt is the wanted amount of probability
+    # in the left side divided by the total amount
+    RY(
+        -2 * (asin(sqrt(qmin((2 ** (size_lsb)) / lsbs_val, 1))) + pi / 4) + pi,
+        rotation_var,
+    )
+
+
 @qfunc(external=True)
 def _prepare_uniform_trimmed_state_step(
     size_lsb: CInt, ctrl_val: CInt, lsbs_val: CInt, ctrl_var: QNum, rotation_var: QBit
 ) -> None:
-    pass
+    if_(
+        lsbs_val != 0,  # stop condition
+        lambda: control(
+            ctrl_var == ctrl_val,
+            lambda: prepare_uniform_trimmed_state_apply_rotation(
+                size_lsb, lsbs_val, rotation_var
+            ),
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -207,7 +243,28 @@ def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
         1. If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
         2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
-    pass
+    hadamard_transform(q)
+
+    if_(
+        m < 2**q.len,
+        # initial step without control
+        lambda: prepare_uniform_trimmed_state_apply_rotation(
+            q.len - 1,  # type:ignore[arg-type]
+            m,
+            q[q.len - 1],
+        ),
+    )
+
+    repeat(
+        qmax(q.len - 1, 0),
+        lambda i: _prepare_uniform_trimmed_state_step(
+            q.len - i - 2,
+            floor(m / (2 ** (q.len - i - 1))),
+            m % (2 ** (q.len - i - 1)),
+            q[q.len - i - 1 : q.len],
+            q[q.len - i - 2],
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -232,7 +289,8 @@ def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> N
         1. If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
         2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
     """
-    pass
+    prepare_uniform_trimmed_state(end - start, q)
+    modular_increment(start, q)
 
 
 @qfunc(external=True)
@@ -251,7 +309,20 @@ def prepare_ghz_state(size: CInt, q: Output[QArray[QBit]]) -> None:
 
 
     """
-    pass
+
+    def inner_lop(step: CInt) -> None:
+        repeat(
+            count=2**step,
+            iteration=lambda control_index: if_(
+                condition=control_index + 2**step >= size,
+                then=lambda: IDENTITY(q[0]),
+                else_=lambda: CX(q[control_index], q[control_index + 2**step]),
+            ),
+        )
+
+    allocate(size, q)
+    H(q[0])
+    repeat(floor(log(size - 1, 2)) + 1, inner_lop)  # type:ignore[arg-type]
 
 
 @qfunc(external=True)
@@ -272,7 +343,7 @@ def prepare_exponential_state(rate: CInt, q: QArray[QBit]) -> None:
 
     Further reading is available on the [reference manual](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/special_state_preparations/prepare_exponential_state)
     """
-    pass
+    repeat(q.len, lambda i: RY(2.0 * atan(exp((-rate * 2.0**i) / 2.0)), q[i]))
 
 
 @qfunc(external=True)
@@ -318,7 +389,10 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
 
 
     """
-    pass
+    allocate(2, q)
+    inplace_prepare_int(state_num, q)
+    H(q[0])
+    CX(q[0], q[1])
 
 
 @qfunc(external=True)
@@ -336,7 +410,14 @@ def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
     Note:
         If the value cannot fit into the quantum variable, it is truncated, i.e. treated as the value modulo $2^\\text{target.size}$.
     """
-    pass
+    repeat(
+        target.len,
+        lambda index: if_(
+            (floor(value / (2**index)) % 2) == 1,
+            lambda: X(target[index]),
+            lambda: IDENTITY(target[index]),
+        ),
+    )
 
 
 @qfunc(external=True)
@@ -357,4 +438,5 @@ def prepare_int(
     Note:
         If the output variable has been declared with a specific number of qubits, it must match the number of allocated qubits.
     """
-    pass
+    allocate(floor(log(value, 2)) + 1, out)
+    inplace_prepare_int(value, out)

classiq/qmod/builtins/functions/swap_test.py

@@ -1,3 +1,6 @@
+from classiq.qmod.builtins.functions.standard_gates import SWAP, H
+from classiq.qmod.builtins.functions.state_preparation import allocate
+from classiq.qmod.builtins.operations import control, repeat
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit
 
@@ -22,4 +25,7 @@ def swap_test(state1: QArray[QBit], state2: QArray[QBit], test: Output[QBit]) ->
     Example:
         Further reading in the Classiq library is found [here](https://docs.classiq.io/latest/explore/algorithms/swap_test/swap_test/).
     """
-    pass
+    allocate(1, test)
+    H(test)
+    control(test, lambda: repeat(state1.len, lambda i: SWAP(state1[i], state2[i])))
+    H(test)

classiq/qmod/builtins/functions/utility_functions.py

@@ -0,0 +1,43 @@
+from typing import Annotated
+
+from classiq.qmod.builtins.functions.standard_gates import H
+from classiq.qmod.builtins.operations import repeat
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit, QCallable
+
+
+@qfunc(external=True)
+def apply_to_all(
+    gate_operand: QCallable[Annotated[QBit, "target"]], target: QArray[QBit]
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the single-qubit operand `gate_operand` to each qubit in the qubit
+    array `target`.
+
+    Args:
+        gate_operand: The single-qubit gate to apply to each qubit in the array.
+        target: The qubit array to apply the gate to.
+    """
+    repeat(target.len, lambda index: gate_operand(target[index]))
+
+
+@qfunc(external=True)
+def hadamard_transform(target: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies Hadamard transform to the target qubits.
+
+    Corresponds to the braket notation:
+
+    $$
+     H^{\\otimes n} |x\rangle = \frac{1}{\\sqrt{2^n}} \\sum_{y=0}^{2^n - 1} (-1)^{x \\cdot y} |y\rangle
+    $$
+
+    Args:
+        target:  qubits to apply to Hadamard transform to.
+
+    """
+    apply_to_all(H, target)

classiq/qmod/builtins/functions/variational.py

@@ -1,7 +1,11 @@
+from classiq.qmod.builtins.functions.standard_gates import RX, RY, RZ
+from classiq.qmod.builtins.functions.state_preparation import allocate
+from classiq.qmod.builtins.operations import repeat
 from classiq.qmod.cparam import CReal
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.qmod_variable import Output, QArray, QBit
+from classiq.qmod.symbolic import ceiling, floor, pi
 
 
 @qfunc(external=True)
@@ -17,7 +21,11 @@ def encode_in_angle(data: CArray[CReal], qba: Output[QArray[QBit]]) -> None:
         data: A classical array representing the data to encode.
         qba: The array of qubits on which the data is encoded.
     """
-    pass
+    allocate(data.len, qba)
+    repeat(
+        count=data.len,
+        iteration=lambda index: RY(pi * data[index], qba[index]),
+    )
 
 
 @qfunc(external=True)
@@ -34,4 +42,12 @@ def encode_on_bloch(data: CArray[CReal], qba: Output[QArray]) -> None:
         data: A classical array representing the data to encode.
         qba: The QArray of QBits on which the data is encoded.
     """
-    pass
+    allocate(ceiling(data.len / 2), qba)
+    repeat(
+        count=ceiling(data.len / 2),
+        iteration=lambda index: RX(pi * data[2 * index], qba[index]),
+    )
+    repeat(
+        count=floor(data.len / 2),
+        iteration=lambda index: RZ(pi * data[2 * index + 1], qba[index]),
+    )

classiq/qmod/builtins/operations.py

@@ -1,13 +1,16 @@
 import inspect
 import sys
+import warnings
+from collections.abc import Mapping
 from types import FrameType
 from typing import (
+    TYPE_CHECKING,
     Any,
     Callable,
     Final,
-    List,
-    Mapping,
+    Optional,
     Union,
+    overload,
 )
 
 from classiq.interface.exceptions import ClassiqValueError
@@ -22,13 +25,16 @@ from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
 from classiq.interface.model.control import Control
-from classiq.interface.model.inplace_binary_operation import (
-    BinaryOperation,
-    InplaceBinaryOperation,
-)
 from classiq.interface.model.invert import Invert
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.power import Power
+from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
+    AmplitudeLoadingOperation,
+)
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+    ArithmeticOperationKind,
+)
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     QuantumOperandDeclaration,
@@ -38,7 +44,7 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum, 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
@@ -48,8 +54,8 @@ _MISSING_VALUE: Final[int] = -1
 
 
 def bind(
-    source: Union[Input[QVar], List[Input[QVar]]],
-    destination: Union[Output[QVar], List[Output[QVar]]],
+    source: Union[Input[QVar], list[Input[QVar]]],
+    destination: Union[Output[QVar], list[Output[QVar]]],
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(1))
@@ -92,6 +98,7 @@ def if_(
 def control(
     ctrl: Union[SymbolicExpr, QBit, QArray[QBit]],
     stmt_block: Union[QCallable, Callable[[], None]],
+    else_block: Union[QCallable, Callable[[], None], None] = None,
 ) -> None:
     _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
@@ -99,39 +106,125 @@ def control(
     control_stmt = Control(
         expression=Expression(expr=str(ctrl)),
         body=_operand_to_body(stmt_block, "stmt_block"),
+        else_block=_operand_to_body(else_block, "else_block") if else_block else None,
         source_ref=source_ref,
     )
     control_stmt.set_generative_block("body", stmt_block)
+    if else_block is not None:
+        control_stmt.set_generative_block("else_block", else_block)
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(control_stmt)
 
 
+def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        ArithmeticOperation(
+            expression=Expression(expr=str(expression)),
+            result_var=target_var.get_handle_binding(),
+            operation_kind=ArithmeticOperationKind.Assignment,
+            source_ref=source_ref,
+        )
+    )
+
+
+def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    source_ref = get_source_ref(sys._getframe(1))
+    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
+        AmplitudeLoadingOperation(
+            expression=Expression(expr=str(expression)),
+            result_var=target_var.get_handle_binding(),
+            source_ref=source_ref,
+        )
+    )
+
+
+@overload
+def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
+    pass
+
+
+@overload
+def inplace_add(*, value: QNum, target: QNum) -> None:
+    pass
+
+
 def inplace_add(
-    value: QNum,
-    target: QNum,
+    expression: Optional[SymbolicExpr] = None,
+    target_var: Optional[QScalar] = None,
+    value: Optional[QNum] = None,
+    target: Optional[QNum] = None,
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
+    if value is not None or target is not None:
+        warnings.warn(
+            "Parameters 'value' and 'target of function 'inplace_add' have "
+            "been renamed to 'expression' and 'target_var' respectively. Parameters "
+            "'value' and 'target' will no longer be supported starting on 02/12/24 at "
+            "the earliest.\nHint: Change `inplace_add(value=..., target=...)` to "
+            "`inplace_add(expression=..., target_var=...)` or `inplace_add(..., ...)`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+    if value is not None:
+        expression = value
+    if target is not None:
+        target_var = target
+    if TYPE_CHECKING:
+        assert expression is not None
+        assert target_var is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        InplaceBinaryOperation(
-            target=target.get_handle_binding(),
-            value=value.get_handle_binding(),
-            operation=BinaryOperation.Addition,
+        ArithmeticOperation(
+            expression=Expression(expr=str(expression)),
+            result_var=target_var.get_handle_binding(),
+            operation_kind=ArithmeticOperationKind.InplaceAdd,
             source_ref=source_ref,
         )
     )
 
 
+@overload
+def inplace_xor(expression: SymbolicExpr, target_var: QScalar) -> None:
+    pass
+
+
+@overload
+def inplace_xor(*, value: QNum, target: QNum) -> None:
+    pass
+
+
 def inplace_xor(
-    value: QNum,
-    target: QNum,
+    expression: Optional[SymbolicExpr] = None,
+    target_var: Optional[QScalar] = None,
+    value: Optional[QNum] = None,
+    target: Optional[QNum] = None,
 ) -> None:
     assert QCallable.CURRENT_EXPANDABLE is not None
+    if value is not None or target is not None:
+        warnings.warn(
+            "Parameters 'value' and 'target of function 'inplace_xor' have "
+            "been renamed to 'expression' and 'target_var' respectively. Parameters "
+            "'value' and 'target' will no longer be supported starting on 02/12/24 at "
+            "the earliest.\nHint: Change `inplace_xor(value=..., target=...)` to "
+            "`inplace_xor(expression=..., target_var=...)` or `inplace_xor(..., ...)`.",
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+    if value is not None:
+        expression = value
+    if target is not None:
+        target_var = target
+    if TYPE_CHECKING:
+        assert expression is not None
+        assert target_var is not None
     source_ref = get_source_ref(sys._getframe(1))
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        InplaceBinaryOperation(
-            target=target.get_handle_binding(),
-            value=value.get_handle_binding(),
-            operation=BinaryOperation.Xor,
+        ArithmeticOperation(
+            expression=Expression(expr=str(expression)),
+            result_var=target_var.get_handle_binding(),
+            operation_kind=ArithmeticOperationKind.InplaceXor,
             source_ref=source_ref,
         )
     )
@@ -298,6 +391,8 @@ def _operand_to_body(
 
 
 __all__ = [
+    "assign",
+    "assign_amplitude",
     "bind",
     "control",
     "invert",
@@ -311,5 +406,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/cfunc.py

@@ -1,9 +1,9 @@
-from typing import Any, Callable, Dict, Optional, Union, overload
+from typing import Any, Callable, Optional, Union, overload
 
 from classiq.qmod.classical_function import CFunc
 
 
-def get_caller_locals() -> Dict[str, Any]:
+def get_caller_locals() -> dict[str, Any]:
     """Print the local variables in the caller's frame."""
     import inspect