classiq 0.100.0__py3-none-any.whl → 0.104.0__py3-none-any.whl

classiq/open_library/functions/utility_functions.py

@@ -4,13 +4,13 @@ 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.functions.standard_gates import PHASE, SWAP, H
 from classiq.qmod.builtins.operations import bind, repeat, within_apply
 from classiq.qmod.cparam import CInt
-from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qfunc import qfunc, qperm
 from classiq.qmod.qmod_variable import QArray, QBit, QCallable, QNum
 from classiq.qmod.quantum_callable import QCallableList
-from classiq.qmod.symbolic import pi
+from classiq.qmod.symbolic import min, pi
 
 
 @qfunc
@@ -50,6 +50,25 @@ def hadamard_transform(target: QArray[QBit]) -> None:
     repeat(target.len, lambda index: H(target[index]))
 
 
+@qperm
+def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Swaps the qubit states between two arrays.
+    Qubits of respective indices are swapped, and additional qubits in the longer array are left unchanged.
+
+    Args:
+        x: The first array
+        y: The second array
+
+    """
+    repeat(
+        count=min(x.len, y.len),
+        iteration=lambda index: SWAP(x[index], y[index]),
+    )
+
+
 @qfunc
 def switch(selector: CInt, cases: QCallableList) -> None:
     cases[selector]()

classiq/qmod/builtins/functions/__init__.py

@@ -48,6 +48,10 @@ CORE_LIB_DECLS = [
         integer_xor,
         modular_add_constant,
         real_xor_constant,
+        multiply,
+        multiply_constant,
+        canonical_multiply,
+        canonical_multiply_constant,
         U,
         CCX,
         free,
@@ -61,6 +65,7 @@ CORE_LIB_DECLS = [
         commuting_paulis_exponent,
         suzuki_trotter,
         unscheduled_suzuki_trotter,
+        sequential_suzuki_trotter,
         exponentiate,
         multi_suzuki_trotter,
         parametric_suzuki_trotter,
@@ -111,6 +116,10 @@ __all__ = [  # noqa: RUF022
     "add_inplace_right",
     "apply",
     "exponentiation_with_depth_constraint",
+    "multiply",
+    "multiply_constant",
+    "canonical_multiply",
+    "canonical_multiply_constant",
     "free",
     "drop",
     "inplace_prepare_amplitudes",

classiq/qmod/builtins/functions/arithmetic.py

@@ -1,5 +1,6 @@
 from typing import Literal
 
+from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc, qperm
 from classiq.qmod.qmod_parameter import CArray, CBool, CReal
 from classiq.qmod.qmod_variable import (
@@ -83,3 +84,133 @@ def integer_xor(left: Const[QArray[QBit]], right: QArray[QBit]) -> None:
 @qperm(external=True)
 def real_xor_constant(left: CReal, right: QNum) -> None:
     pass
+
+
+@qperm(external=True)
+def multiply(left: Const[QNum], right: Const[QNum], result: Output[QNum]) -> None:
+    """
+    [Qmod core-library function]
+
+    Multiplies two quantum numeric variables:
+
+    $$
+        \\left|\\text{left}\\right\\rangle \\left|\\text{right}\\right\\rangle
+        \\mapsto
+        \\left|\\text{left}\\right\\rangle \\left|\\text{right}\\right\\rangle
+        \\left|\\text{left} \\cdot \\text{right} \\right\\rangle
+    $$
+
+    Args:
+        left: The first argument for the multiplication.
+        right: The second argument for the multiplication.
+        result: The quantum variable to hold the multiplication result.
+    """
+    pass
+
+
+@qperm(external=True)
+def multiply_constant(left: CReal, right: Const[QNum], result: Output[QNum]) -> None:
+    """
+    [Qmod core-library function]
+
+    Multiplies a quantum numeric variable with a constant:
+
+    $$
+        \\left|\\text{right}\\right\\rangle
+        \\mapsto
+        \\left|\\text{right}\\right\\rangle
+        \\left|\\text{left} \\cdot \\text{right} \\right\\rangle
+    $$
+
+    Args:
+        left: The constant argument for the multiplication.
+        right: The variable argument for the multiplication.
+        result: The quantum variable to hold the multiplication result.
+    """
+    pass
+
+
+@qperm(external=True)
+def canonical_multiply(
+    left: Const[QArray],
+    extend_left: CBool,
+    right: Const[QArray],
+    extend_right: CBool,
+    result: QArray,
+    trim_result_lsb: CBool,
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Multiplies two quantum variables representing integers (signed or unsigned) into the
+    result variable which is assumed to start in the $|0\\rangle$ state.
+
+    If `trim_result_lsb` is `False`, applies the transformation:
+
+    $$
+        \\left|\\text{left}\\right\\rangle \\left|\\text{right}\\right\\rangle
+        \\left|0\\right\\rangle \\mapsto \\left|\\text{left}\\right\\rangle
+        \\left|\\text{right}\\right\\rangle \\left|\\left( \\text{left} \\cdot
+        \\text{right} \\right) \\bmod 2^{\\text{result.size}} \\right\\rangle
+    $$
+
+    If `trim_result_lsb` is `True`, the function avoids computing the result's LSB and
+    applies the transformation:
+
+    $$
+        \\left|\\text{left}\\right\\rangle \\left|\\text{right}\\right\\rangle
+        \\left|0\\right\\rangle \\mapsto \\left|\\text{left}\\right\\rangle
+        \\left|\\text{right}\\right\\rangle \\left|\\left( \\text{left} \\cdot
+        \\text{right} \\right) \\gg 1 \\bmod 2^{\\text{result.size}} \\right\\rangle
+    $$
+
+    Args:
+        left: The first argument for the multiplication.
+        extend_left: Whether to sign-extend the left argument.
+        right: The second argument for the multiplication.
+        extend_right: Whether to sign-extend the right argument.
+        result: The quantum variable to hold the multiplication result.
+        trim_result_lsb: Whether to avoid computing the result's LSB.
+    """
+    pass
+
+
+@qperm(external=True)
+def canonical_multiply_constant(
+    left: CInt,
+    right: Const[QArray],
+    extend_right: CBool,
+    result: QArray,
+    trim_result_lsb: CBool,
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Multiplies a quantum variable representing an integer (signed or unsigned) with a
+    constant, into the result variable which is assumed to start in the $|0\\rangle$ state.
+
+    If `trim_result_lsb` is `False`, applies the transformation:
+
+    $$
+        \\left|\\text{right}\\right\\rangle \\left|0\\right\\rangle \\mapsto
+        \\left|\\text{right}\\right\\rangle \\left|\\left( \\text{left} \\cdot
+        \\text{right} \\right) \\bmod 2^{\\text{result.size}} \\right\\rangle
+    $$
+
+    If `trim_result_lsb` is `True`, the function avoids computing the result's LSB and
+    applies the transformation:
+
+    $$
+        \\left|\\text{right}\\right\\rangle \\left|0\\right\\rangle \\mapsto
+        \\left|\\text{right}\\right\\rangle \\left|\\left( \\text{left} \\cdot
+        \\text{right} \\right) \\gg 1 \\bmod 2^{\\text{result.size}} \\right\\rangle
+    $$
+
+    Args:
+        left: The constant argument for the multiplication.
+        right: The variable argument for the multiplication.
+        extend_right: Whether to sign-extend the right argument.
+        result: The quantum variable to hold the multiplication result.
+        trim_result_lsb: Whether to avoid computing the result's LSB.
+    """
+    pass

classiq/qmod/builtins/functions/exponentiation.py

@@ -99,7 +99,7 @@ def multi_suzuki_trotter(
     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.
+        hamiltonians: The hamiltonians 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.
@@ -129,7 +129,37 @@ def unscheduled_suzuki_trotter(
     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.
+        hamiltonians: The hamiltonians 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 sequential_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. Does not reorder the Pauli terms.
+
+    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 hamiltonians 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.
@@ -218,10 +248,10 @@ def sparse_suzuki_trotter(
 
 @qfunc(external=True)
 def qdrift(
-    pauli_operator: SparsePauliOp,  # FIXME: Rename to hamiltonian (CLS-4347)
+    pauli_operator: SparsePauliOp,
     evolution_coefficient: CReal,
     num_qdrift: CInt,
-    qbv: QArray[QBit],  # FIXME: Add length expr (CLS-4347)
+    qbv: QArray[QBit, Literal["pauli_operator.num_qubits"]],
 ) -> None:
     """
     [Qmod core-library function]

classiq/qmod/builtins/operations.py

@@ -1,6 +1,5 @@
 import inspect
 import sys
-import warnings
 from collections.abc import Callable, Mapping
 from functools import wraps
 from itertools import product
@@ -14,7 +13,7 @@ from typing import (
     overload,
 )
 
-from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
     REPEAT_OPERATOR_NAME,
@@ -30,12 +29,9 @@ from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
 from classiq.interface.model.control import Control
-from classiq.interface.model.invert import Invert
+from classiq.interface.model.invert import BlockKind, 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,
@@ -49,6 +45,7 @@ from classiq.interface.model.repeat import Repeat
 from classiq.interface.model.skip_control import SkipControl
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.within_apply_operation import WithinApply
+from classiq.interface.source_reference import SourceReference
 
 from classiq.qmod.builtins.functions import H, S
 from classiq.qmod.generative import is_generative_mode
@@ -335,37 +332,6 @@ def assign(expression: SymbolicExpr, target_var: QScalar) -> None:
     )
 
 
-@suppress_return_value
-@qmod_statement
-def assign_amplitude(expression: SymbolicExpr, target_var: QScalar) -> None:
-    """
-    Perform an amplitude-encoding assignment operation on a quantum variable and a
-    quantum expression.
-
-    Equivalent to `<target_var> *= <expression>`.
-
-    Args:
-        expression: A quantum arithmetic expression
-        target_var: A scalar quantum variable
-    """
-    warnings.warn(
-        "The 'assign_amplitude' function is deprecated and will no longer be "
-        "supported starting on 2025-12-03 at the earliest. Use 'assign_amplitude_table' "
-        "instead",
-        ClassiqDeprecationWarning,
-        stacklevel=3,
-    )
-    assert QCallable.CURRENT_EXPANDABLE is not None
-    source_ref = get_source_ref(sys._getframe(2))
-    QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-        AmplitudeLoadingOperation(
-            expression=Expression(expr=str(expression)),
-            result_var=target_var.get_handle_binding(),
-            source_ref=source_ref,
-        )
-    )
-
-
 @suppress_return_value
 @qmod_statement
 def inplace_add(expression: SymbolicExpr, target_var: QScalar) -> None:
@@ -552,7 +518,7 @@ def power(
 
 @suppress_return_value
 @qmod_statement
-def invert(stmt_block: QCallable | Callable[[], Statements]) -> None:
+def invert(stmt_block: QCallable | Callable[[], Statements]) -> Any:
     """
     Apply the inverse of a quantum gate.
 
@@ -574,11 +540,35 @@ def invert(stmt_block: QCallable | Callable[[], Statements]) -> None:
             invert(qft(x))
         ```
     """
-    _validate_operand(stmt_block)
     assert QCallable.CURRENT_EXPANDABLE is not None
     source_ref = get_source_ref(sys._getframe(2))
+
+    if (
+        isinstance(stmt_block, QCallable)
+        and len(stmt_block.func_decl.positional_arg_declarations) > 0
+    ):
+        return lambda *args, **kwargs: _invert(
+            lambda: stmt_block(  # type:ignore[call-arg]
+                *args, **kwargs, _source_ref=source_ref
+            ),
+            source_ref,
+            BlockKind.SingleCall,
+        )
+    _invert(stmt_block, source_ref, BlockKind.Compound)
+    return None
+
+
+def _invert(
+    stmt_block: Callable[[], Statements],
+    source_ref: SourceReference,
+    block_kind: BlockKind,
+) -> None:
+    assert QCallable.CURRENT_EXPANDABLE is not None
+    _validate_operand(stmt_block)
     invert_stmt = Invert(
-        body=_operand_to_body(stmt_block, "stmt_block"), source_ref=source_ref
+        body=_operand_to_body(stmt_block, "stmt_block"),
+        block_kind=block_kind,
+        source_ref=source_ref,
     )
     if is_generative_mode():
         invert_stmt.set_generative_block("body", stmt_block)
@@ -843,7 +833,6 @@ def lookup_table(func: RealFunction, targets: QNum | list[QNum]) -> list[float]:
 __all__ = [
     "allocate",
     "assign",
-    "assign_amplitude",
     "assign_amplitude_poly_sin",
     "bind",
     "block",

classiq/qmod/native/pretty_printer.py

@@ -42,7 +42,7 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
-from classiq.interface.model.invert import Invert
+from classiq.interface.model.invert import BlockKind, Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
@@ -51,9 +51,6 @@ from classiq.interface.model.port_declaration import (
     AnonPortDeclaration,
 )
 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,
@@ -367,9 +364,17 @@ class DSLPrettyPrinter(ModelVisitor):
         return power_code
 
     def visit_Invert(self, invert: Invert) -> str:
-        invert_code = f"{self._indent}invert {{\n"
-        invert_code += self._visit_body(invert.body)
-        invert_code += f"{self._indent}}}\n"
+        invert.validate_node()
+        match invert.block_kind:
+            case BlockKind.SingleCall:
+                invert_code = f"{self._indent}invert "
+                invert_code += self.visit(invert.body[0]).lstrip()
+            case BlockKind.Compound:
+                invert_code = f"{self._indent}invert {{\n"
+                invert_code += self._visit_body(invert.body)
+                invert_code += f"{self._indent}}}\n"
+            case _:
+                raise ClassiqInternalError("Unknown block type")
         return invert_code
 
     def visit_Block(self, block: Block) -> str:
@@ -435,11 +440,6 @@ class DSLPrettyPrinter(ModelVisitor):
             op = "+="
         return f"{self._indent}{self.visit(arith_op.result_var)} {op} {self.visit(arith_op.expression)};\n"
 
-    def visit_AmplitudeLoadingOperation(
-        self, amplitude_loading_op: AmplitudeLoadingOperation
-    ) -> str:
-        return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)};\n"
-
     def _print_bind_handles(self, handles: list[HandleBinding]) -> str:
         if len(handles) == 1:
             return self.visit(handles[0])

classiq/qmod/pretty_print/pretty_printer.py

@@ -45,16 +45,13 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
-from classiq.interface.model.invert import Invert
+from classiq.interface.model.invert import BlockKind, Invert
 from classiq.interface.model.model import Model
 from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.phase_operation import PhaseOperation
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 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,
@@ -508,8 +505,17 @@ class PythonPrettyPrinter(ModelVisitor):
         return f"{self._indent}power({self.visit(power.power)}, {self._visit_body(power.body)})\n"
 
     def visit_Invert(self, invert: Invert) -> str:
+        invert.validate_node()
         self._imports["invert"] = 1
-        return f"{self._indent}invert({self._visit_body(invert.body)})\n"
+        match invert.block_kind:
+            case BlockKind.SingleCall:
+                call_str = self.visit(invert.body[0])
+                call_str = call_str.replace("(", ")(", 1)
+                return f"{self._indent}invert({call_str}\n"
+            case BlockKind.Compound:
+                return f"{self._indent}invert({self._visit_body(invert.body)})\n"
+            case _:
+                raise ClassiqInternalError("Unknown block type")
 
     def visit_Block(self, block: Block) -> str:
         self._imports["block"] = 1
@@ -528,8 +534,6 @@ class PythonPrettyPrinter(ModelVisitor):
         for i, statement in enumerate(body):
             if isinstance(statement, VariableDeclarationStatement):
                 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)
             else:
@@ -587,14 +591,6 @@ class PythonPrettyPrinter(ModelVisitor):
             return f"{func}({self.visit(arith_op.expression)}, {self._indent}{self.visit(arith_op.result_var)})\n"
         return f"{self._indent}{self.visit(arith_op.result_var)} {op} {self.visit(arith_op.expression)}\n"
 
-    def visit_AmplitudeLoadingOperation(
-        self, amplitude_loading_op: AmplitudeLoadingOperation, in_lambda: bool = False
-    ) -> str:
-        if in_lambda:
-            self._imports["assign_amplitude"] = 1
-            return f"assign_amplitude({self.visit(amplitude_loading_op.expression)}, {self._indent}{self.visit(amplitude_loading_op.result_var)})\n"
-        return f"{self._indent}{self.visit(amplitude_loading_op.result_var)} *= {self.visit(amplitude_loading_op.expression)}\n"
-
     def _print_bind_handles(self, handles: list[HandleBinding]) -> str:
         if len(handles) == 1:
             return self.visit(handles[0])

classiq/qmod/qmod_parameter.py

@@ -63,6 +63,10 @@ class CParamList(CParam):
             else:
                 param_type = self._list_type.element_type
         else:
+            if key.start is None:
+                key = slice(0, key.stop, None)
+            if key.stop is None:
+                key = slice(key.start, self.len, None)
             if not isinstance(self._list_type, ClassicalTuple):
                 param_type = self._list_type
             else:

classiq/qmod/qmod_variable.py

@@ -1,6 +1,5 @@
 import abc
 import sys
-import warnings
 from collections.abc import Iterator, Mapping
 from contextlib import contextmanager
 from typing import (  # type: ignore[attr-defined]
@@ -23,7 +22,6 @@ from typing import (  # type: ignore[attr-defined]
 from typing_extensions import ParamSpec, Self, _AnnotatedAlias
 
 from classiq.interface.exceptions import (
-    ClassiqDeprecationWarning,
     ClassiqInternalError,
     ClassiqNotImplementedError,
     ClassiqValueError,
@@ -45,9 +43,6 @@ from classiq.interface.model.handle_binding import (
     SlicedHandleBinding,
     SubscriptHandleBinding,
 )
-from classiq.interface.model.quantum_expressions.amplitude_loading_operation import (
-    AmplitudeLoadingOperation,
-)
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
     ArithmeticOperationKind,
@@ -161,37 +156,6 @@ class QVar(Symbolic):
     def type_name(self) -> str:
         return self.get_qmod_type().type_name
 
-
-class QmodExpressionCreator(Protocol):
-    """
-    A callable that creates a Qmod expression from the provided QVars.
-    """
-
-    def __call__(self, **kwargs: QVar) -> SymbolicExpr: ...
-
-
-_Q = TypeVar("_Q", bound=QVar)
-Output = Annotated[_Q, PortDeclarationDirection.Output]
-Input = Annotated[_Q, PortDeclarationDirection.Input]
-Const = Annotated[
-    _Q, TypeModifier.Const
-]  # A constant variable, up to a phase dependent on the computational basis state
-
-
-class QScalar(QVar, SymbolicExpr):
-    CONSTRUCTOR_DEPTH: int = 2
-
-    def __init__(
-        self,
-        origin: None | str | HandleBinding = None,
-        *,
-        _expr_str: str | None = None,
-        depth: int = 2,
-    ) -> None:
-        origin = _infer_variable_name(origin, self.CONSTRUCTOR_DEPTH)
-        QVar.__init__(self, origin, expr_str=_expr_str, depth=depth)
-        SymbolicExpr.__init__(self, str(origin), True)
-
     def _insert_arith_operation(
         self,
         expr: SymbolicTypes,
@@ -210,19 +174,6 @@ class QScalar(QVar, SymbolicExpr):
             )
         )
 
-    def _insert_amplitude_loading(
-        self, expr: SymbolicTypes, source_ref: SourceReference
-    ) -> None:
-        if TYPE_CHECKING:
-            assert QCallable.CURRENT_EXPANDABLE is not None
-        QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
-            AmplitudeLoadingOperation(
-                expression=Expression(expr=str(expr)),
-                result_var=self.get_handle_binding(),
-                source_ref=source_ref,
-            )
-        )
-
     def __ior__(self, other: Any) -> Self:
         if not isinstance(other, SYMBOLIC_TYPES):
             raise ClassiqValueError(
@@ -245,6 +196,37 @@ class QScalar(QVar, SymbolicExpr):
         )
         return self
 
+
+class QmodExpressionCreator(Protocol):
+    """
+    A callable that creates a Qmod expression from the provided QVars.
+    """
+
+    def __call__(self, **kwargs: QVar) -> SymbolicExpr: ...
+
+
+_Q = TypeVar("_Q", bound=QVar)
+Output = Annotated[_Q, PortDeclarationDirection.Output]
+Input = Annotated[_Q, PortDeclarationDirection.Input]
+Const = Annotated[
+    _Q, TypeModifier.Const
+]  # A constant variable, up to a phase dependent on the computational basis state
+
+
+class QScalar(QVar, SymbolicExpr):
+    CONSTRUCTOR_DEPTH: int = 2
+
+    def __init__(
+        self,
+        origin: None | str | HandleBinding = None,
+        *,
+        _expr_str: str | None = None,
+        depth: int = 2,
+    ) -> None:
+        origin = _infer_variable_name(origin, self.CONSTRUCTOR_DEPTH)
+        QVar.__init__(self, origin, expr_str=_expr_str, depth=depth)
+        SymbolicExpr.__init__(self, str(origin), True)
+
     def __iadd__(self, other: Any) -> Self:
         if not isinstance(other, SYMBOLIC_TYPES):
             raise ClassiqValueError(
@@ -256,21 +238,10 @@ class QScalar(QVar, SymbolicExpr):
         )
         return self
 
-    def __imul__(self, other: Any) -> Self:
-        warnings.warn(
-            "The '*=' operator is deprecated and will no longer be supported "
-            "starting on 2025-12-03 at the earliest. Use the 'assign_amplitude_table' "
-            "function instead",
-            ClassiqDeprecationWarning,
-            stacklevel=2,
+    def __imul__(self, other: Any) -> NoReturn:
+        raise ClassiqNotImplementedError(
+            f"{self.get_qmod_type().raw_qmod_type_name} does not support '*='"
         )
-        if not isinstance(other, SYMBOLIC_TYPES):
-            raise ClassiqValueError(
-                f"Invalid argument {str(other)!r} for out of ampltiude encoding operation"
-            )
-
-        self._insert_amplitude_loading(other, get_source_ref(sys._getframe(1)))
-        return self
 
     def __iand__(self, other: Any) -> NoReturn:
         raise ClassiqNotImplementedError(
@@ -558,6 +529,10 @@ class QArray(ArrayBase[_P], QVar, NonSymbolicExpr):
     def _get_slice(self, slice_: slice) -> Any:
         if slice_.step is not None:
             raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
+        if slice_.start is None:
+            slice_ = slice(0, slice_.stop, None)
+        if slice_.stop is None:
+            slice_ = slice(slice_.start, self.len, None)
         if not isinstance(slice_.start, (int, SymbolicExpr)) or not isinstance(
             slice_.stop, (int, SymbolicExpr)
         ):