classiq 0.102.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

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 (
@@ -65,6 +66,58 @@ def add_inplace_right(
     pass
 
 
+@qperm(external=True)
+def canonical_add(
+    left: Const[QArray],
+    extend_left: CBool,
+    right: QArray,
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Adds two quantum variables representing integers (signed or unsigned), storing the
+    result in the second variable (in-place):
+
+    $$
+        \\left|\\text{left}\\right\\rangle \\left|\\text{right}\\right\\rangle
+        \\mapsto
+        \\left|\\text{left}\\right\\rangle \\left|\\left(\\text{right} +
+        \\text{left}\\right) \\bmod 2^{\\text{right.size}} \\right\\rangle
+    $$
+
+    Args:
+        left: The out-of-place argument for the addition.
+        extend_left: Whether to sign-extend the left argument.
+        right: The in-place argument for the addition, holds the final result.
+    """
+    pass
+
+
+@qperm(external=True)
+def canonical_add_constant(
+    left: CInt,
+    right: QArray,
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Adds an integer constant to a quantum variable representing an integer (signed or
+    unsigned):
+
+    $$
+        \\left|\\text{right}\\right\\rangle
+        \\mapsto
+        \\left|\\left(\\text{right} +
+        \\text{left}\\right) \\bmod 2^{\\text{right.size}} \\right\\rangle
+    $$
+
+    Args:
+        left: The constant argument for the addition.
+        right: The quantum argument for the addition, holds the final result.
+    """
+    pass
+
+
 @qperm(external=True)
 def modular_add(left: Const[QArray[QBit]], right: QArray[QBit]) -> None:
     pass
@@ -83,3 +136,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.

classiq/qmod/builtins/functions/gray_code.py

@@ -0,0 +1,23 @@
+from classiq.qmod.builtins.enums import Pauli
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray, CReal
+from classiq.qmod.qmod_variable import QBit, QNum
+
+
+@qfunc(external=True)
+def select_rotation(
+    basis: Pauli, angles: CArray[CReal], selector: QNum, target: QBit
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Applies a set of controlled single-qubit rotations to a target qubit, using
+    a specified rotation axis and a list of rotation angles.
+
+    Args:
+        basis: The Pauli operator defining the rotation axis.
+        angles: The list of rotation angles in radians. The list must have length 2**selector.size.
+        selector: The qubits that act as the selection register.
+        target: The qubit on which the selected rotation is applied.
+    """
+    pass

classiq/qmod/builtins/functions/mcx_func.py

@@ -5,3 +5,13 @@ from classiq.qmod.qmod_variable import Const, QArray, QBit
 @qperm(external=True)
 def mcx(ctrl: Const[QArray[QBit]], target: QBit) -> None:
     pass
+
+
+@qperm(external=True)
+def mcx_gray_code(ctrl: Const[QArray[QBit]], target: QBit) -> None:
+    pass
+
+
+@qperm(external=True)
+def mcx_hybrid_rec(ctrl: Const[QArray[QBit]], target: QBit, aux: QArray[QBit]) -> None:
+    pass

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,
@@ -33,9 +32,6 @@ from classiq.interface.model.control import Control
 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,
@@ -336,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:
@@ -553,7 +518,7 @@ def power(
 
 @suppress_return_value
 @qmod_statement
-def invert(stmt_block: QCallable | Callable[[], Statements]) -> Callable | None:
+def invert(stmt_block: QCallable | Callable[[], Statements]) -> Any:
     """
     Apply the inverse of a quantum gate.
 
@@ -868,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/builtins/structs.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass, fields, is_dataclass
-from typing import Union
+from typing import Any, Union
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
@@ -117,13 +117,21 @@ class SparsePauliOp:
     def __rmul__(self, obj: Union[float, "SparsePauliOp"]) -> "SparsePauliOp":
         return self.__mul__(obj)
 
-    def __add__(self, other: "SparsePauliOp") -> "SparsePauliOp":
+    def __add__(self, other: Any) -> "SparsePauliOp":
+        if not isinstance(other, SparsePauliOp):
+            raise ClassiqValueError(
+                f"Cannot add an object of type {type(other).__name__} to SparsePauliOp"
+            )
         return SparsePauliOp(
             terms=LenList(self.terms + other.terms),
             num_qubits=max(self.num_qubits, other.num_qubits),
         )
 
-    def __sub__(self, other: "SparsePauliOp") -> "SparsePauliOp":
+    def __sub__(self, other: Any) -> "SparsePauliOp":
+        if not isinstance(other, SparsePauliOp):
+            raise ClassiqValueError(
+                f"Cannot substruct an object of type {type(other).__name__} to SparsePauliOp"
+            )
         return self + -1.0 * other
 
     def __str__(self) -> str:
@@ -136,6 +144,17 @@ class SparsePauliOp:
             for term in self.terms
         )
 
+    def __truediv__(self, other: Any) -> "SparsePauliOp":
+        if not isinstance(other, (int, float)):
+            raise ClassiqValueError(
+                f"Cannot divide SparsePauliOp by object of type {type(other).__name__}"
+            )
+        if other == 0:
+            raise ClassiqValueError("Cannot divide by zero")
+        return SparsePauliOp(terms=self.terms, num_qubits=self.num_qubits) * float(
+            1 / other
+        )
+
 
 @dataclass
 class CombinatorialOptimizationSolution:

classiq/qmod/native/pretty_printer.py

@@ -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,12 +364,9 @@ class DSLPrettyPrinter(ModelVisitor):
         return power_code
 
     def visit_Invert(self, invert: Invert) -> str:
+        invert.validate_node()
         match invert.block_kind:
             case BlockKind.SingleCall:
-                if len(invert.body) != 1 or not isinstance(
-                    invert.body[0], QuantumFunctionCall
-                ):
-                    raise ClassiqInternalError("Malformed single-call invert")
                 invert_code = f"{self._indent}invert "
                 invert_code += self.visit(invert.body[0]).lstrip()
             case BlockKind.Compound:
@@ -446,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

@@ -52,9 +52,6 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 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,13 +505,10 @@ 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
         match invert.block_kind:
             case BlockKind.SingleCall:
-                if len(invert.body) != 1 or not isinstance(
-                    invert.body[0], QuantumFunctionCall
-                ):
-                    raise ClassiqInternalError("Malformed single-call invert")
                 call_str = self.visit(invert.body[0])
                 call_str = call_str.replace("(", ")(", 1)
                 return f"{self._indent}invert({call_str}\n"
@@ -540,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:
@@ -599,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)
         ):