classiq 0.38.0__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/interface/generator/expressions/non_symbolic_expr.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from typing import Any, NoReturn
+
+from classiq.interface.exceptions import ClassiqArithmeticError
+
+
+class NonSymbolicExpr:
+    @property
+    def type_name(self) -> str:
+        raise NotImplementedError
+
+    @staticmethod
+    def _raise_error(type_name: str, op: str) -> NoReturn:
+        raise ClassiqArithmeticError(
+            f"Unsupported operand type for {op!r}: {type_name}"
+        )
+
+    def __add__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "+")
+
+    def __sub__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "-")
+
+    def __mul__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "*")
+
+    def __truediv__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "/")
+
+    def __floordiv__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "//")
+
+    def __mod__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "%")
+
+    def __pow__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "**")
+
+    def __lshift__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "<<")
+
+    def __rshift__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, ">>")
+
+    def __and__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "&")
+
+    def __xor__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "^")
+
+    def __or__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "|")
+
+    def __radd__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "+")
+
+    def __rsub__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "-")
+
+    def __rmul__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "*")
+
+    def __rtruediv__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "/")
+
+    def __rfloordiv__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "//")
+
+    def __rmod__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "%")
+
+    def __rpow__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "**")
+
+    def __rlshift__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "<<")
+
+    def __rrshift__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, ">>")
+
+    def __rand__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "&")
+
+    def __rxor__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "^")
+
+    def __ror__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "|")
+
+    def __lt__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "<")
+
+    def __le__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "<=")
+
+    def __eq__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "==")
+
+    def __ne__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "!=")
+
+    def __gt__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, ">")
+
+    def __ge__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, ">=")
+
+    def __neg__(self) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "-")
+
+    def __pos__(self) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "+")
+
+    def __abs__(self) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "abs")
+
+    def __invert__(self) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "~")

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -0,0 +1,99 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Union
+
+from sympy import Integer
+
+from classiq.interface.exceptions import (
+    ClassiqInternalExpansionError,
+    ClassiqValueError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+
+if TYPE_CHECKING:
+    from classiq.interface.model.quantum_type import QuantumType
+
+
+ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
+ILLEGAL_SLICE_MSG = "Quantum array slice must be of the form [<int-value>:<int-value>]."
+
+
+class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
+    def __init__(
+        self,
+        handle: HandleBinding,
+        element_type: "QuantumType",
+        element_size: int,
+        length: int,
+    ) -> None:
+        super().__init__(handle, element_size * length)
+        self._length = length
+        self._element_type = element_type
+        self._element_size = element_size
+
+    def __getitem__(self, key: Union[slice, int, Integer]) -> "QmodSizedProxy":
+        return (
+            self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
+        )
+
+    def _get_subscript(self, index: Union[int, Integer]) -> "QmodSizedProxy":
+        if isinstance(index, Integer):
+            index = int(index)
+        if index < 0 or index >= self._length:
+            raise ClassiqInternalExpansionError
+
+        return self._element_type.get_proxy(
+            SubscriptHandleBinding(
+                base_handle=self.handle,
+                index=Expression(expr=str(index)),
+            )
+        )
+
+    def _get_slice(self, slice_: slice) -> "QmodSizedProxy":
+        if slice_.step is not None:
+            raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
+        if isinstance(slice_.start, Integer):
+            slice_ = slice(int(slice_.start), slice_.stop)
+        if isinstance(slice_.stop, Integer):
+            slice_ = slice(slice_.start, int(slice_.stop))
+        if not isinstance(slice_.start, int) or not isinstance(slice_.stop, int):
+            raise ClassiqValueError(ILLEGAL_SLICE_MSG)
+        if (
+            slice_.start >= slice_.stop
+            or slice_.start < 0
+            or slice_.stop > self._length
+        ):
+            raise ClassiqInternalExpansionError
+
+        return QmodQArrayProxy(
+            SlicedHandleBinding(
+                base_handle=self.handle,
+                start=Expression(expr=str(slice_.start)),
+                end=Expression(expr=str(slice_.stop)),
+            ),
+            self._element_type,
+            self._element_size,
+            slice_.stop - slice_.start,
+        )
+
+    @property
+    def type_name(self) -> str:
+        return "Quantum array"
+
+    @property
+    def len(self) -> int:
+        return self._length
+
+    @property
+    def fields(self) -> Mapping[str, Any]:
+        return {**super().fields, "len": self.len}
+
+    @property
+    def size(self) -> int:
+        return self.len * self._element_size

classiq/interface/generator/expressions/qmod_qscalar_proxy.py

@@ -1,29 +1,47 @@
+from collections.abc import Mapping
+from typing import Any
+
 from sympy import Symbol
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.model.handle_binding import HandleBinding
 
 
 class QmodQScalarProxy(Symbol, QmodSizedProxy):
-    def __new__(cls, name, **assumptions):
-        return super().__new__(cls, name, **assumptions)
+    def __new__(cls, handle: HandleBinding, **assumptions: bool) -> "QmodQScalarProxy":
+        return super().__new__(cls, str(handle), **assumptions)
 
-    def __init__(self, name: str, size: int) -> None:
-        super().__init__(size)
+    def __init__(self, handle: HandleBinding, size: int) -> None:
+        super().__init__(handle, size)
 
 
 class QmodQBitProxy(QmodQScalarProxy):
-    pass
+    def __init__(self, handle: HandleBinding) -> None:
+        super().__init__(handle, 1)
+
+    @property
+    def type_name(self) -> str:
+        return "Quantum bit"
 
 
 class QmodQNumProxy(QmodQScalarProxy):
-
     def __init__(
-        self, name: str, size: int, fraction_digits: int, is_signed: bool
+        self, handle: HandleBinding, size: int, fraction_digits: int, is_signed: bool
     ) -> None:
-        super().__init__(name, size)
+        super().__init__(handle, size)
+        if fraction_digits > size:
+            raise ClassiqValueError(
+                f"Quantum numeric of size {size} cannot have {fraction_digits} "
+                f"fraction digits"
+            )
         self._fraction_digits = fraction_digits
         self._is_signed = is_signed
 
+    @property
+    def type_name(self) -> str:
+        return "Quantum numeric"
+
     @property
     def fraction_digits(self) -> int:
         return self._fraction_digits
@@ -31,3 +49,11 @@ class QmodQNumProxy(QmodQScalarProxy):
     @property
     def is_signed(self) -> bool:
         return self._is_signed
+
+    @property
+    def fields(self) -> Mapping[str, Any]:
+        return {
+            **super().fields,
+            "is_signed": self.is_signed,
+            "fraction_digits": self.fraction_digits,
+        }

classiq/interface/generator/expressions/qmod_qstruct_proxy.py

@@ -0,0 +1,36 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+)
+
+if TYPE_CHECKING:
+    from classiq.interface.model.quantum_type import QuantumType
+
+
+class QmodQStructProxy(NonSymbolicExpr, QmodSizedProxy):
+    def __init__(
+        self,
+        handle: HandleBinding,
+        struct_name: str,
+        fields: Mapping[str, "QuantumType"],
+    ) -> None:
+        self._fields = {
+            name: type_.get_proxy(FieldHandleBinding(base_handle=handle, field=name))
+            for name, type_ in fields.items()
+        }
+        size = sum(proxy.size for proxy in self._fields.values())
+        super().__init__(handle, size)
+        self._struct_name = struct_name
+
+    @property
+    def type_name(self) -> str:
+        return self._struct_name
+
+    @property
+    def fields(self) -> Mapping[str, QmodSizedProxy]:
+        return {**super().fields, **self._fields}

classiq/interface/generator/expressions/qmod_sized_proxy.py

@@ -1,6 +1,34 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from classiq.interface.model.handle_binding import HandleBinding
+
+
 class QmodSizedProxy:
-    def __init__(self, size: int) -> None:
+    def __init__(self, handle: "HandleBinding", size: int) -> None:
+        self._handle = handle
         self._size = size
 
-    def __len__(self) -> int:
+    @property
+    def size(self) -> int:
         return self._size
+
+    def __str__(self) -> str:
+        return str(self.handle)
+
+    @property
+    def type_name(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def handle(self) -> "HandleBinding":
+        return self._handle
+
+    @property
+    def len(self) -> int:
+        return self._size
+
+    @property
+    def fields(self) -> Mapping[str, Any]:
+        return {"size": self._size}

classiq/interface/generator/expressions/qmod_struct_instance.py

@@ -1,5 +1,6 @@
 import types
-from typing import TYPE_CHECKING, Any, Mapping
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from classiq.interface.generator.expressions.expression_types import ExpressionValue
@@ -16,9 +17,20 @@ class QmodStructInstance:
         self.struct_declaration = struct_declaration
         self._fields = fields
 
+    @property
+    def type_name(self) -> str:
+        return f"Struct {self.struct_declaration.name}"
+
     @property
     def fields(self) -> Mapping[str, Any]:
         return types.MappingProxyType(self._fields)
 
+    def __str__(self) -> str:
+        return repr(self)
+
     def __repr__(self) -> str:
-        return repr(self._fields)
+        fields = ", ".join(
+            f"{field_name}={field_value}"
+            for field_name, field_value in self._fields.items()
+        )
+        return f"{self.struct_declaration.name}({fields})"

classiq/interface/generator/expressions/sympy_supported_expressions.py

@@ -1,7 +1,5 @@
-from typing import List
-
-BASIC_ARITHMETIC_OPERATORS: List[str] = ["+", "-", "*", "/", "%"]
-MATHEMATICAL_FUNCTIONS: List[str] = [
+BASIC_ARITHMETIC_OPERATORS: list[str] = ["+", "-", "*", "/", "%"]
+MATHEMATICAL_FUNCTIONS: list[str] = [
     "sin",
     "cos",
     "tan",
@@ -36,7 +34,7 @@ MATHEMATICAL_FUNCTIONS: List[str] = [
     "Min",
     "mod_inverse",
 ]
-SPECIAL_FUNCTIONS: List[str] = [
+SPECIAL_FUNCTIONS: list[str] = [
     "erf",
     "erfc",
     "gamma",
@@ -57,10 +55,20 @@ SPECIAL_FUNCTIONS: List[str] = [
     "euler",
     "catalan",
 ]
-PIECEWISE_FUNCTIONS: List[str] = ["Piecewise", "Heaviside"]
-CONSTANTS: List[str] = ["pi", "E", "I", "GoldenRatio", "EulerGamma", "Catalan"]
-DATA_TYPES: List[str] = ["Matrix"]
-LOGIC_OPERATORS: List[str] = [
+PIECEWISE_FUNCTIONS: list[str] = ["Piecewise", "Heaviside"]
+NUMERIC_CONSTANTS: list[str] = [
+    "pi",
+    "E",
+    "I",
+    "GoldenRatio",
+    "EulerGamma",
+    "Catalan",
+]
+BOOLEAN_CONSTANTS: list[str] = ["true", "false"]
+CONSTANTS: list[str] = NUMERIC_CONSTANTS + BOOLEAN_CONSTANTS
+
+DATA_TYPES: list[str] = ["Matrix"]
+LOGIC_OPERATORS: list[str] = [
     "And",
     "Or",
     "Not",
@@ -70,9 +78,9 @@ LOGIC_OPERATORS: List[str] = [
     "Nand",
     "Nor",
 ]
-RELATIONAL_OPERATORS: List[str] = ["<", "<=", ">", ">=", "!=", "<>", "Eq", "Ne"]
+RELATIONAL_OPERATORS: list[str] = ["<", "<=", ">", ">=", "!=", "<>", "Eq", "Ne"]
 
-SYMPY_SUPPORTED_EXPRESSIONS: List[str] = (
+SYMPY_SUPPORTED_EXPRESSIONS: list[str] = (
     BASIC_ARITHMETIC_OPERATORS
     + MATHEMATICAL_FUNCTIONS
     + SPECIAL_FUNCTIONS

classiq/interface/generator/finance.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Tuple, Union
+from typing import Union
 
 import pydantic
 
@@ -90,7 +90,7 @@ class FinancePayoff(function_params.FunctionParams):
         description="The finance function to solve the model"
     )
     num_qubits: pydantic.PositiveInt
-    distribution_range: Tuple[float, float]
+    distribution_range: tuple[float, float]
 
     def _create_ios(self) -> None:
         self._inputs = {

classiq/interface/generator/function_param_library.py

@@ -1,19 +1,19 @@
-from typing import Iterable, Set, Type
+from collections.abc import Iterable
 
 from classiq.interface.generator.function_params import FunctionParams
 
 
 class FunctionParamLibrary:
-    def __init__(self, param_list: Iterable[Type[FunctionParams]]) -> None:
-        self._param_list: Set[Type[FunctionParams]] = set(param_list)
+    def __init__(self, param_list: Iterable[type[FunctionParams]]) -> None:
+        self._param_list: set[type[FunctionParams]] = set(param_list)
 
     @property
-    def param_list(self) -> Set[Type[FunctionParams]]:
+    def param_list(self) -> set[type[FunctionParams]]:
         return self._param_list.copy()
 
     # Private methods are for tests only
-    def _add(self, param: Type[FunctionParams]) -> None:
+    def _add(self, param: type[FunctionParams]) -> None:
         self._param_list.add(param)
 
-    def _remove(self, param: Type[FunctionParams]) -> None:
+    def _remove(self, param: type[FunctionParams]) -> None:
         self._param_list.discard(param)

classiq/interface/generator/function_param_list_without_self_reference.py

@@ -28,8 +28,7 @@ from classiq.interface.generator.arith.unary_ops import BitwiseInvert, Negation,
 from classiq.interface.generator.commuting_pauli_exponentiation import (
     CommutingPauliExponentiation,
 )
-from classiq.interface.generator.credit_risk_example.linear_gci import LinearGCI
-from classiq.interface.generator.credit_risk_example.weighted_adder import WeightedAdder
+from classiq.interface.generator.copy import Copy
 from classiq.interface.generator.entangler_params import (
     GridEntangler,
     HypercubeEntangler,
@@ -53,7 +52,6 @@ from classiq.interface.generator.hardware_efficient_ansatz import (
 from classiq.interface.generator.hartree_fock import HartreeFock
 from classiq.interface.generator.hva import HVA
 from classiq.interface.generator.identity import Identity
-from classiq.interface.generator.inequality_mixer import InequalityMixer
 from classiq.interface.generator.linear_pauli_rotations import LinearPauliRotations
 from classiq.interface.generator.mcu import Mcu
 from classiq.interface.generator.mcx import Mcx
@@ -67,7 +65,6 @@ from classiq.interface.generator.piecewise_linear_amplitude_loading import (
 from classiq.interface.generator.qft import QFT
 from classiq.interface.generator.qsvm import QSVMFeatureMap
 from classiq.interface.generator.randomized_benchmarking import RandomizedBenchmarking
-from classiq.interface.generator.range_mixer import RangeMixer
 from classiq.interface.generator.standard_gates.standard_gates_param_list import (
     standard_gate_function_param_library,
 )
@@ -81,7 +78,6 @@ from classiq.interface.generator.state_preparation import (
     UniformDistributionStatePreparation,
     WStatePreparation,
 )
-from classiq.interface.generator.state_propagator import StatePropagator
 from classiq.interface.generator.ucc import UCC
 from classiq.interface.generator.unitary_gate import UnitaryGate
 from classiq.interface.generator.user_defined_function_params import CustomFunction
@@ -97,7 +93,6 @@ function_param_library_without_self_reference: FunctionParamLibrary = (
                 GHZStatePreparation,
                 WStatePreparation,
                 ExponentialStatePreparation,
-                StatePropagator,
                 QFT,
                 BitwiseAnd,
                 BitwiseOr,
@@ -134,11 +129,9 @@ function_param_library_without_self_reference: FunctionParamLibrary = (
                 CustomFunction,
                 HardwareEfficientAnsatz,
                 UnitaryGate,
-                WeightedAdder,
                 LinearPauliRotations,
                 Multiplier,
                 Power,
-                LinearGCI,
                 HartreeFock,
                 UCC,
                 Min,
@@ -150,14 +143,13 @@ function_param_library_without_self_reference: FunctionParamLibrary = (
                 Identity,
                 RandomizedBenchmarking,
                 HVA,
-                InequalityMixer,
-                RangeMixer,
                 UGate,
                 AmplitudeLoading,
                 QSVMFeatureMap,
                 PiecewiseLinearAmplitudeLoading,
                 PiecewiseLinearRotationAmplitudeLoading,
                 HadamardTransform,
+                Copy,
             },
             standard_gate_function_param_library.param_list,
             oracle_function_param_library.param_list,