classiq 0.86.1__py3-none-any.whl → 0.88.0__py3-none-any.whl

classiq/interface/model/quantum_type.py

@@ -57,6 +57,10 @@ class QuantumType(HashableASTNode):
     def set_size_in_bits(self, val: int) -> None:
         self._size_in_bits = val
 
+    @property
+    def minimal_size_in_bits(self) -> int:
+        raise NotImplementedError
+
     def get_proxy(self, handle: "HandleBinding") -> QmodSizedProxy:
         return QmodSizedProxy(handle=handle, size=self.size_in_bits)
 
@@ -64,6 +68,10 @@ class QuantumType(HashableASTNode):
     def qmod_type_name(self) -> str:
         raise NotImplementedError
 
+    @property
+    def raw_qmod_type_name(self) -> str:
+        return self.qmod_type_name
+
     @property
     def type_name(self) -> str:
         raise NotImplementedError
@@ -76,6 +84,10 @@ class QuantumType(HashableASTNode):
     def is_evaluated(self) -> bool:
         raise NotImplementedError
 
+    @property
+    def is_constant(self) -> bool:
+        raise NotImplementedError
+
     @property
     def expressions(self) -> list[Expression]:
         return []
@@ -101,6 +113,9 @@ class QuantumScalar(QuantumType):
     def fraction_digits_value(self) -> int:
         raise NotImplementedError
 
+    def get_bounds(self) -> Optional[tuple[float, float]]:
+        return None
+
     def get_effective_bounds(
         self, machine_precision: Optional[int] = None
     ) -> tuple[float, float]:
@@ -146,6 +161,10 @@ class QuantumBit(QuantumScalar):
     def is_evaluated(self) -> bool:
         return True
 
+    @property
+    def is_constant(self) -> bool:
+        return True
+
     @property
     def has_sign(self) -> bool:
         return True
@@ -167,6 +186,10 @@ class QuantumBit(QuantumScalar):
     ) -> tuple[float, float]:
         return (0, 1)
 
+    @property
+    def minimal_size_in_bits(self) -> int:
+        return 1
+
 
 class QuantumBitvector(QuantumType):
     element_type: "ConcreteQuantumType" = Field(
@@ -182,7 +205,7 @@ class QuantumBitvector(QuantumType):
 
     def _update_size_in_bits_from_declaration(self) -> None:
         self.element_type._update_size_in_bits_from_declaration()
-        if self.element_type.has_size_in_bits and self.has_length:
+        if self.element_type.has_size_in_bits and self.has_constant_length:
             assert self.length is not None
             self._size_in_bits = (
                 self.element_type.size_in_bits * self.length.to_int_value()
@@ -192,6 +215,14 @@ class QuantumBitvector(QuantumType):
     def has_length(self) -> bool:
         return self.length is not None and self.length.is_evaluated()
 
+    @property
+    def has_constant_length(self) -> bool:
+        return (
+            self.length is not None
+            and self.length.is_evaluated()
+            and self.length.is_constant()
+        )
+
     @property
     def length_value(self) -> int:
         if not self.has_length:
@@ -217,6 +248,10 @@ class QuantumBitvector(QuantumType):
         length = [self.length.expr] if self.length is not None else []
         return f"QArray[{', '.join(element_type + length)}]"
 
+    @property
+    def raw_qmod_type_name(self) -> str:
+        return "QArray"
+
     @property
     def type_name(self) -> str:
         return "Quantum array"
@@ -233,6 +268,15 @@ class QuantumBitvector(QuantumType):
             and self.element_type.is_evaluated
         )
 
+    @property
+    def is_constant(self) -> bool:
+        return (
+            self.length is not None
+            and self.length.is_evaluated()
+            and self.length.is_constant()
+            and self.element_type.is_constant
+        )
+
     @property
     def expressions(self) -> list[Expression]:
         exprs = self.element_type.expressions
@@ -240,6 +284,14 @@ class QuantumBitvector(QuantumType):
             exprs.append(self.length)
         return exprs
 
+    @property
+    def minimal_size_in_bits(self) -> int:
+        if self.has_constant_length:
+            length = self.length_value
+        else:
+            length = 1
+        return length * self.element_type.minimal_size_in_bits
+
 
 class QuantumNumeric(QuantumScalar):
     kind: Literal["qnum"]
@@ -279,6 +331,14 @@ class QuantumNumeric(QuantumScalar):
     def has_sign(self) -> bool:
         return self.is_signed is not None
 
+    @property
+    def has_constant_sign(self) -> bool:
+        return (
+            self.is_signed is not None
+            and self.is_signed.is_evaluated()
+            and self.is_signed.is_constant()
+        )
+
     @property
     def sign_value(self) -> bool:
         return False if self.is_signed is None else self.is_signed.to_bool_value()
@@ -287,6 +347,14 @@ class QuantumNumeric(QuantumScalar):
     def has_fraction_digits(self) -> bool:
         return self.fraction_digits is not None
 
+    @property
+    def has_constant_fraction_digits(self) -> bool:
+        return (
+            self.fraction_digits is not None
+            and self.fraction_digits.is_evaluated()
+            and self.fraction_digits.is_constant()
+        )
+
     @property
     def fraction_digits_value(self) -> int:
         return (
@@ -294,7 +362,11 @@ class QuantumNumeric(QuantumScalar):
         )
 
     def _update_size_in_bits_from_declaration(self) -> None:
-        if self.size is not None and self.size.is_evaluated():
+        if (
+            self.size is not None
+            and self.size.is_evaluated()
+            and self.size.is_constant()
+        ):
             self._size_in_bits = self.size.to_int_value()
 
     def get_proxy(self, handle: "HandleBinding") -> QmodQNumProxy:
@@ -307,6 +379,21 @@ class QuantumNumeric(QuantumScalar):
 
     @property
     def qmod_type_name(self) -> str:
+        if (
+            self.size is not None
+            and (
+                self.is_signed is None
+                or (self.is_signed.is_evaluated() and not self.is_signed.value.value)
+            )
+            and (
+                self.fraction_digits is None
+                or (
+                    self.fraction_digits.is_evaluated()
+                    and self.fraction_digits.value.value == 0
+                )
+            )
+        ):
+            return f"QNum[{self.size.expr}]"
         if (
             self.size is not None
             and self.is_signed is not None
@@ -315,6 +402,10 @@ class QuantumNumeric(QuantumScalar):
             return f"QNum[{self.size.expr}, {self.is_signed.expr}, {self.fraction_digits.expr}]"
         return "QNum"
 
+    @property
+    def raw_qmod_type_name(self) -> str:
+        return "QNum"
+
     @property
     def type_name(self) -> str:
         return "Quantum numeric"
@@ -333,6 +424,26 @@ class QuantumNumeric(QuantumScalar):
             self.fraction_digits is not None and not self.fraction_digits.is_evaluated()
         )
 
+    @property
+    def is_constant(self) -> bool:
+        if (
+            self.size is None
+            or not self.size.is_evaluated()
+            or not self.size.is_constant()
+        ):
+            return False
+        if self.is_signed is not None and (
+            not self.is_signed.is_evaluated() or not self.is_signed.is_constant()
+        ):
+            return False
+        return not (
+            self.fraction_digits is not None
+            and (
+                not self.fraction_digits.is_evaluated()
+                or not self.fraction_digits.is_constant()
+            )
+        )
+
     @property
     def expressions(self) -> list[Expression]:
         exprs = []
@@ -372,6 +483,10 @@ class QuantumNumeric(QuantumScalar):
             number_utils.limit_fraction_places(bounds[1], machine_precision),
         )
 
+    @property
+    def minimal_size_in_bits(self) -> int:
+        return self.size_in_bits if self.has_size_in_bits else 1
+
 
 class RegisterQuantumType(BaseModel):
     quantum_types: "ConcreteQuantumType"

classiq/interface/pretty_print/expression_to_qmod.py

@@ -61,15 +61,14 @@ class ASTToQMODCode:
         if isinstance(node, ast.Module):
             return self.indent.join(self.ast_to_code(child) for child in node.body)
         elif isinstance(node, ast.Attribute):
-            # Enum attribute access
-            if not isinstance(node.value, ast.Name) or not isinstance(node.attr, str):
-                raise PrettyPrinterError("Error parsing enum attribute access")
-            if not (IDENTIFIER.match(node.value.id) and IDENTIFIER.match(node.attr)):
-                raise PrettyPrinterError("Error parsing enum attribute access")
             # FIXME: identify enum member accesses by type name (CLS-2858)
-            if len(node.value.id) > 0 and node.value.id[0].isupper():
-                return f"{node.value.id!s}::{node.attr!s}"
-            return f"{node.value.id!s}.{node.attr!s}"
+            if (
+                isinstance(node.value, ast.Name)
+                and len(node.value.id) > 0
+                and node.value.id[0].isupper()
+            ):
+                return f"{node.value.id}::{node.attr}"
+            return f"{self.visit(node.value)}.{node.attr}"
         elif isinstance(node, ast.Name):
             return node.id
         elif isinstance(node, ast.Num):

classiq/interface/pyomo_extension/__init__.py

@@ -17,10 +17,6 @@ pyomo.core.expr.relational_expr.EqualityExpression.getname = equality_expression
 
 pyomo.core.base.set.Set._pprint_members = staticmethod(set_pprint.pprint_members)
 
-pyomo.core.expr.sympy_tools._operatorMap.update({sympy.LessThan: lambda x, y: x <= y})
-pyomo.core.expr.sympy_tools._operatorMap.update(
-    {sympy.GreaterThan: lambda x, y: x >= y}
-)
 pyomo.core.expr.sympy_tools._pyomo_operator_map.update({EqualityExpression: sympy.Eq})
 
 pyomo.core.expr.sympy_tools.PyomoSympyBimap.getSympySymbol = (

classiq/interface/pyomo_extension/pyomo_sympy_bimap.py

@@ -1,7 +1,7 @@
 from typing import Any
 
 import sympy
-from pyomo.core.base import _GeneralVarData
+from pyomo.core.base.var import VarData
 from pyomo.core.expr.sympy_tools import PyomoSympyBimap
 
 
@@ -25,5 +25,5 @@ def get_sympy_symbol(self: PyomoSympyBimap, pyomo_object: Any) -> sympy.Symbol:
 # The name for the new sympy object is derived
 # from the pyomo object, instead of using generic name with serial number.
 # This is intended to have better corelation between the the pyomo variables and sympy variables.
-def _get_sympy_name(pyomo_object: _GeneralVarData) -> str:
+def _get_sympy_name(pyomo_object: VarData) -> str:
     return pyomo_object.name.replace("[", "").replace("]", "")

classiq/model_expansions/arithmetic.py

@@ -3,7 +3,9 @@ from typing import Optional, Union
 
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_type import (
+    QuantumNumeric,
     QuantumScalar,
     register_info_to_quantum_type,
 )
@@ -48,9 +50,48 @@ class NumericAttributes:
     def ub(self) -> float:
         return self.bounds[1]
 
+    @property
+    def integer_digits(self) -> int:
+        return self.size - self.fraction_digits
+
+    def to_quantum_numeric(self) -> QuantumNumeric:
+        quantum_numeric = QuantumNumeric(
+            size=Expression(expr=str(self.size)),
+            is_signed=Expression(expr=str(self.is_signed)),
+            fraction_digits=Expression(expr=str(self.fraction_digits)),
+        )
+        quantum_numeric.set_bounds(self.bounds)
+        return quantum_numeric
+
+    def to_register(self) -> RegisterArithmeticInfo:
+        return RegisterArithmeticInfo(
+            size=self.size,
+            is_signed=self.is_signed,
+            fraction_places=self.fraction_digits,
+            bounds=self.bounds,
+        )
+
+    def trim_fraction_digits(self, machine_precision: int) -> "NumericAttributes":
+        trimmed_digits = self.fraction_digits - machine_precision
+        if trimmed_digits < 0:
+            return self
+
+        return NumericAttributes(
+            size=self.size - trimmed_digits,
+            is_signed=self.is_signed,
+            fraction_digits=self.fraction_digits - trimmed_digits,
+            bounds=self.bounds,
+            trim_bounds=True,
+        )
+
     @classmethod
     def from_bounds(
-        cls, lb: float, ub: float, fraction_places: int, machine_precision: int
+        cls,
+        lb: float,
+        ub: float,
+        fraction_places: int,
+        machine_precision: int,
+        trim_bounds: bool = False,
     ) -> "NumericAttributes":
         size, is_signed, fraction_digits = number_utils.bounds_to_attributes(
             lb, ub, fraction_places, machine_precision
@@ -60,6 +101,7 @@ class NumericAttributes:
             is_signed=is_signed,
             fraction_digits=fraction_digits,
             bounds=(lb, ub),
+            trim_bounds=trim_bounds,
         )
 
     @classmethod

classiq/model_expansions/arithmetic_compute_result_attrs.py

@@ -1,3 +1,9 @@
+import math
+from collections.abc import Sequence
+from typing import Union
+
+from classiq.interface.exceptions import ClassiqValueError
+
 from classiq.model_expansions.arithmetic import NumericAttributes
 
 
@@ -51,6 +57,62 @@ def compute_result_attrs_negate(
         )
 
 
+def compute_result_attrs_bitwise_and(
+    left: NumericAttributes,
+    right: NumericAttributes,
+    machine_precision: int,
+) -> NumericAttributes:
+    if left.fraction_digits > 0 or right.fraction_digits > 0:
+        raise ClassiqValueError("Bitwise AND is only defined for integers")
+
+    # we comply with python, which uses arbitrary precision, so a positive number can
+    # always be represented by "0..." and a negative number by "1...", thus their
+    # bitwise AND is always non-negative
+    return NumericAttributes(
+        size=max(left.size, right.size),
+        is_signed=left.is_signed and right.is_signed,
+        fraction_digits=0,
+    )
+
+
+def compute_result_attrs_bitwise_or(
+    left: NumericAttributes,
+    right: NumericAttributes,
+    machine_precision: int,
+) -> NumericAttributes:
+    if left.fraction_digits > 0 or right.fraction_digits > 0:
+        raise ClassiqValueError("Bitwise OR is only defined for integers")
+
+    # we comply with python, which uses arbitrary precision, so a positive number can
+    # always be represented by "0..." and a negative number by "1...", thus their
+    # bitwise OR is always negative
+
+    if left.is_signed and not right.is_signed:
+        # we need to extend right so its MSB is always 0
+        size = max(left.size, right.size + 1)
+    elif not left.is_signed and right.is_signed:
+        # we need to extend left so its MSB is always 0
+        size = max(left.size + 1, right.size)
+    else:
+        size = max(left.size, right.size)
+
+    return NumericAttributes(
+        size=size,
+        is_signed=left.is_signed or right.is_signed,
+        fraction_digits=0,
+    )
+
+
+def compute_result_attrs_bitwise_xor(
+    left: NumericAttributes,
+    right: NumericAttributes,
+    machine_precision: int,
+) -> NumericAttributes:
+    if left.fraction_digits > 0 or right.fraction_digits > 0:
+        raise ClassiqValueError("Bitwise XOR is only defined for integers")
+    return compute_result_attrs_bitwise_or(left, right, machine_precision)
+
+
 def compute_result_attrs_add(
     left: NumericAttributes,
     right: NumericAttributes,
@@ -69,3 +131,196 @@ def compute_result_attrs_subtract(
 ) -> NumericAttributes:
     tmp = compute_result_attrs_negate(right, machine_precision)
     return compute_result_attrs_add(left, tmp, machine_precision)
+
+
+def compute_result_attrs_multiply(
+    left: NumericAttributes,
+    right: NumericAttributes,
+    machine_precision: int,
+) -> NumericAttributes:
+    extremal_values = [
+        left_val * right_val for left_val in left.bounds for right_val in right.bounds
+    ]
+    fraction_places = left.fraction_digits + right.fraction_digits
+    return NumericAttributes.from_bounds(
+        min(extremal_values),
+        max(extremal_values),
+        fraction_places,
+        machine_precision,
+        trim_bounds=True,
+    )
+
+
+def compute_result_attrs_power(
+    left: NumericAttributes,
+    right: Union[int, float],
+    machine_precision: int,
+) -> NumericAttributes:
+    if not float(right).is_integer() or right <= 0:
+        raise ClassiqValueError("Power must be a positive integer")
+    right = int(right)
+
+    bounds: tuple[float, float]
+    if (right % 2 == 0) and (left.lb < 0 < left.ub):
+        bounds = (0, max(left.lb**right, left.ub**right))
+    else:
+        extremal_values = (left.lb**right, left.ub**right)
+        bounds = (min(extremal_values), max(extremal_values))
+    fraction_places = left.fraction_digits * right
+    return NumericAttributes.from_bounds(
+        bounds[0], bounds[1], fraction_places, machine_precision, trim_bounds=True
+    )
+
+
+def compute_result_attrs_lshift(
+    left: NumericAttributes,
+    right: Union[int, float],
+    machine_precision: int,
+) -> NumericAttributes:
+    if not float(right).is_integer() or right < 0:
+        raise ClassiqValueError("Shift must be a non-negative integer")
+    right = int(right)
+
+    scale = 1 << left.fraction_digits
+    lb = (int(left.lb * scale) << right) / scale
+    ub = (int(left.ub * scale) << right) / scale
+    fraction_digits = max(left.fraction_digits - right, 0)
+    integer_digits = left.integer_digits + right
+    return NumericAttributes(
+        size=integer_digits + fraction_digits,
+        is_signed=left.is_signed,
+        fraction_digits=fraction_digits,
+        bounds=(lb, ub),
+    )
+
+
+def compute_result_attrs_rshift(
+    left: NumericAttributes,
+    right: Union[int, float],
+    machine_precision: int,
+) -> NumericAttributes:
+    if not float(right).is_integer() or right < 0:
+        raise ClassiqValueError("Shift must be a non-negative integer")
+    right = int(right)
+
+    scale = 1 << left.fraction_digits
+    lb = (int(left.lb * scale) >> right) / scale
+    ub = (int(left.ub * scale) >> right) / scale
+    fraction_digits = (
+        0 if (right >= left.size and not left.is_signed) else left.fraction_digits
+    )
+    return NumericAttributes(
+        size=max(left.size - right, fraction_digits, 1),
+        is_signed=left.is_signed,
+        fraction_digits=fraction_digits,
+        bounds=(lb, ub),
+    )
+
+
+def compute_result_attrs_modulo(
+    left: NumericAttributes,
+    right: Union[int, float],
+    machine_precision: int,
+) -> NumericAttributes:
+    if not float(right).is_integer() or right < 2:
+        raise ClassiqValueError("Modulus must be a positive power of two")
+    right = int(right)
+    if right & (right - 1) != 0:
+        raise ClassiqValueError("Modulus must be a positive power of two")
+
+    if left.fraction_digits > 0:
+        raise ClassiqValueError("Modulo is supported for integers only")
+
+    size = int(math.log2(right))
+    if not left.is_signed and size >= left.size:
+        return left
+
+    return NumericAttributes(
+        size=size,
+        fraction_digits=0,
+        is_signed=False,
+    )
+
+
+def compute_result_attrs_min(
+    args: Sequence[NumericAttributes],
+    machine_precision: int,
+) -> NumericAttributes:
+    if len(args) < 1:
+        raise ClassiqValueError("Min expects at least one argument")
+
+    args = [arg.trim_fraction_digits(machine_precision) for arg in args]
+
+    result_attrs = args[0]
+    for attrs in args[1:]:
+        if result_attrs.lb == result_attrs.ub == attrs.lb == attrs.ub:
+            if attrs.size < result_attrs.size:
+                result_attrs = attrs
+        elif result_attrs.ub <= attrs.lb:
+            pass
+        elif attrs.ub <= result_attrs.lb:
+            result_attrs = attrs
+        else:
+            integer_digits = max(result_attrs.integer_digits, attrs.integer_digits)
+            fraction_digits = max(result_attrs.fraction_digits, attrs.fraction_digits)
+            bounds = (min(result_attrs.lb, attrs.lb), min(result_attrs.ub, attrs.ub))
+            result_attrs = NumericAttributes(
+                size=integer_digits + fraction_digits,
+                is_signed=bounds[0] < 0,
+                fraction_digits=fraction_digits,
+                bounds=bounds,
+            )
+
+    return result_attrs
+
+
+def compute_result_attrs_max(
+    args: Sequence[NumericAttributes],
+    machine_precision: int,
+) -> NumericAttributes:
+    if len(args) < 1:
+        raise ClassiqValueError("Max expects at least one argument")
+
+    args = [arg.trim_fraction_digits(machine_precision) for arg in args]
+
+    result_attrs = args[0]
+    for attrs in args[1:]:
+        if result_attrs.lb == result_attrs.ub == attrs.lb == attrs.ub:
+            if attrs.size < result_attrs.size:
+                result_attrs = attrs
+        elif result_attrs.lb >= attrs.ub:
+            pass
+        elif attrs.lb >= result_attrs.ub:
+            result_attrs = attrs
+        else:
+            integer_digits = max(result_attrs.integer_digits, attrs.integer_digits)
+            fraction_digits = max(result_attrs.fraction_digits, attrs.fraction_digits)
+            bounds = (max(result_attrs.lb, attrs.lb), max(result_attrs.ub, attrs.ub))
+            result_attrs = NumericAttributes(
+                size=integer_digits + fraction_digits,
+                is_signed=bounds[0] < 0,
+                fraction_digits=fraction_digits,
+                bounds=bounds,
+            )
+
+    return result_attrs
+
+
+def compute_result_attrs_quantum_subscript(
+    values: Sequence[float],
+    machine_precision: int,
+) -> NumericAttributes:
+    if len(values) < 1:
+        raise ClassiqValueError("Quantum subscript expects at least one argument")
+
+    values_attrs = [
+        NumericAttributes.from_constant(val, machine_precision) for val in values
+    ]
+    values = [attrs.lb for attrs in values_attrs]
+    fraction_digits = max(attrs.fraction_digits for attrs in values_attrs)
+    return NumericAttributes.from_bounds(
+        min(values),
+        max(values),
+        fraction_digits,
+        machine_precision,
+    )

classiq/model_expansions/capturing/captured_vars.py

@@ -49,7 +49,6 @@ from classiq.model_expansions.transformers.model_renamer import (
     HandleRenaming,
     SymbolRenaming,
 )
-from classiq.model_expansions.transformers.var_splitter import SymbolPart
 
 if TYPE_CHECKING:
     from classiq.model_expansions.closure import FunctionClosure
@@ -603,10 +602,9 @@ class CapturedVars:
     def _get_immediate_captured_mapping(self) -> SymbolRenaming:
         return {
             captured_handle.handle: [
-                SymbolPart(
+                HandleRenaming(
                     source_handle=captured_handle.handle,
                     target_var_name=captured_handle.mangled_name,
-                    target_var_type=captured_handle.quantum_type,
                 )
             ]
             for captured_handle in self._captured_handles
@@ -616,10 +614,9 @@ class CapturedVars:
     def _get_propagated_captured_mapping(self) -> SymbolRenaming:
         return {
             captured_handle.mangled_handle: [
-                SymbolPart(
+                HandleRenaming(
                     source_handle=captured_handle.mangled_handle,
                     target_var_name=captured_handle.mangled_name,
-                    target_var_type=captured_handle.quantum_type,
                 )
             ]
             for captured_handle in self._captured_handles