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

classiq/interface/generator/arith/register_user_input.py

@@ -11,6 +11,8 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
+MAX_REGISTER_SIZE = 10000
+
 
 class RegisterArithmeticInfo(HashablePydanticBaseModel):
     size: pydantic.PositiveInt = pydantic.Field(default=1)
@@ -56,6 +58,19 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
         fraction_places = info.data.get("fraction_places", 0)
         if not isinstance(size, int):
             raise ClassiqValueError("RegisterArithmeticInfo must have an integer size")
+        if not isinstance(fraction_places, int):
+            raise ClassiqValueError(
+                "RegisterArithmeticInfo must have an integer fraction_places"
+            )
+
+        if size > MAX_REGISTER_SIZE:
+            raise ValueError(
+                f"Register size {size} exceeds maximum size {MAX_REGISTER_SIZE}."
+            )
+        if fraction_places > size:
+            raise ValueError(
+                f"Number of fraction places {fraction_places} exceeds register size {size}."
+            )
 
         maximal_bounds = cls.get_maximal_bounds(
             size=size, is_signed=is_signed, fraction_places=fraction_places

classiq/interface/generator/arith/unary_ops.py

@@ -1,11 +1,11 @@
 from collections.abc import Iterable
-from typing import TYPE_CHECKING, Final, Optional
+from typing import Final, Optional
 
 import pydantic
 from pydantic import ConfigDict
 
 from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.arith import argument_utils, number_utils
+from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.arithmetic_operations import (
     MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
@@ -13,6 +13,12 @@ from classiq.interface.generator.arith.arithmetic_operations import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import get_zero_input_name
 
+from classiq.model_expansions.arithmetic import NumericAttributes
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_bitwise_invert,
+    compute_result_attrs_negate,
+)
+
 UNARY_ARG_NAME: Final[str] = "arg"
 
 
@@ -65,13 +71,17 @@ class BitwiseInvert(UnaryOpParams):
     output_name = "inverted"
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        eff_arg = argument_utils.limit_fraction_places(self.arg, self.machine_precision)
-        if TYPE_CHECKING:
-            assert isinstance(eff_arg, RegisterArithmeticInfo)
+        arg_attrs = NumericAttributes.from_register_arithmetic_info(
+            self.arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_bitwise_invert(
+            arg_attrs, self.machine_precision
+        )
+
         return RegisterArithmeticInfo(
-            size=self.output_size or eff_arg.size,
-            fraction_places=eff_arg.fraction_places,
-            is_signed=eff_arg.is_signed and self._include_sign,
+            size=self.output_size or result_attrs.size,
+            fraction_places=result_attrs.fraction_digits,
+            is_signed=result_attrs.is_signed and self._include_sign,
         )
 
 
@@ -81,40 +91,34 @@ class Negation(UnaryOpParams):
     )  # True for efficient subtraction
     output_name = "negated"
 
-    @staticmethod
-    def _expected_result_size(arg: RegisterArithmeticInfo) -> pydantic.PositiveInt:
-        if arg.size == 1:
-            return 1
-        return arg.fraction_places + number_utils.bounds_to_integer_part_size(
-            *(-bound for bound in arg.bounds)
-        )
-
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        eff_arg = self.arg.limit_fraction_places(self.machine_precision)
-        is_signed = max(eff_arg.bounds) > 0 and self._include_sign
-        bounds = (-max(eff_arg.bounds), -min(eff_arg.bounds))
+        arg_attrs = NumericAttributes.from_register_arithmetic_info(
+            self.arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_negate(arg_attrs, self.machine_precision)
+        is_signed = result_attrs.is_signed and self._include_sign
+        bounds = result_attrs.bounds
         if self.output_size and not self.bypass_bounds_validation:
-            if eff_arg.fraction_places:
+            if result_attrs.fraction_digits:
                 raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
             max_bounds = RegisterArithmeticInfo.get_maximal_bounds(
                 size=self.output_size, is_signed=False, fraction_places=0
             )
             bounds = number_utils.bounds_cut(bounds, max_bounds)
         return RegisterArithmeticInfo(
-            size=self.output_size or self._expected_result_size(eff_arg),
-            fraction_places=eff_arg.fraction_places,
+            size=self.output_size or result_attrs.size,
+            fraction_places=result_attrs.fraction_digits,
             is_signed=is_signed,
             bypass_bounds_validation=self.bypass_bounds_validation,
             bounds=bounds,
         )
 
     def zero_input_for_extension(self) -> pydantic.NonNegativeInt:
-        eff_arg = self.arg.limit_fraction_places(self.machine_precision)
-        if (self.output_size or eff_arg.size) == 1:
-            return 0
-        return (
-            self.output_size or self._expected_result_size(self.arg)
-        ) - self.arg.size
+        arg_integers = self.arg.size - self.arg.fraction_places
+        result_integers = (
+            self.result_register.size - self.result_register.fraction_places
+        )
+        return result_integers - arg_integers
 
 
 class Sign(UnaryOpParams):

classiq/interface/generator/expressions/expression_types.py

@@ -1,6 +1,6 @@
 from typing import Union
 
-from sympy import Expr
+from sympy import Basic
 from sympy.logic.boolalg import Boolean
 
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
@@ -31,5 +31,5 @@ Proxies = Union[
     QmodSizedProxy,
     ClassicalProxy,
 ]
-RuntimeExpression = Union[AnyClassicalValue, Expr, Boolean]
+RuntimeExpression = Union[AnyClassicalValue, Basic, Boolean]
 ExpressionValue = Union[RuntimeConstant, Proxies, RuntimeExpression]

classiq/interface/generator/expressions/proxies/classical/qmod_struct_instance.py

@@ -41,3 +41,10 @@ class QmodStructInstance:
             for field_name, field_value in self._fields.items()
         )
         return f"{self.struct_declaration.name}({fields})"
+
+    def __eq__(self, other: Any) -> bool:
+        return (
+            isinstance(other, QmodStructInstance)
+            and self.struct_declaration.name == other.struct_declaration.name
+            and self._fields == other._fields
+        )

classiq/interface/generator/functions/classical_function_declaration.py

@@ -28,10 +28,6 @@ class ClassicalFunctionDeclaration(FunctionDeclaration):
         default=None,
     )
 
-    BUILTIN_FUNCTION_DECLARATIONS: ClassVar[
-        dict[str, "ClassicalFunctionDeclaration"]
-    ] = {}
-
     FOREIGN_FUNCTION_DECLARATIONS: ClassVar[
         dict[str, "ClassicalFunctionDeclaration"]
     ] = {}

classiq/interface/generator/functions/classical_type.py

@@ -113,7 +113,6 @@ class StructMetaType(ClassicalType):
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
-    size: Optional[int] = pydantic.Field(exclude=True, default=None)
     length: Optional[Expression] = None
 
     @pydantic.model_validator(mode="before")
@@ -121,37 +120,6 @@ class ClassicalArray(ClassicalType):
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "array")
 
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _set_length(cls, values: Any) -> Any:
-        if isinstance(values, dict):
-            size = values.get("size")
-            length = values.get("length")
-        else:
-            size = values.size
-            length = values.length
-        if size is not None:
-            if isinstance(values, dict):
-                values["length"] = Expression(expr=str(size))
-            else:
-                values.length = Expression(expr=str(size))
-        elif length is not None:
-            if isinstance(length, dict):
-                expr = length["expr"]
-            else:
-                expr = length.expr
-            expr_size: Optional[int] = None
-            try:  # noqa: SIM105
-                expr_size = int(expr)
-            except ValueError:
-                pass
-            if expr_size is not None:
-                if isinstance(values, dict):
-                    values["size"] = expr_size
-                else:
-                    values.size = expr_size
-        return values
-
     @property
     def has_length(self) -> bool:
         return self.length is not None and self.length.is_evaluated()

classiq/interface/generator/generated_circuit_data.py

@@ -146,6 +146,7 @@ class StatementType(StrEnum):
     INPLACE_ADD = "inplace add"
     REPEAT = "repeat"
     BLOCK = "block"
+    IF = "if"
 
 
 # Mapping between statement kind (or sub-kind) and statement type (visualization name)
@@ -167,6 +168,7 @@ STATEMENTS_NAME: dict[str, StatementType] = {
     ArithmeticOperationKind.InplaceAdd.value: StatementType.INPLACE_ADD,
     "Repeat": StatementType.REPEAT,
     "Block": StatementType.BLOCK,
+    "ClassicalIf": StatementType.IF,
 }
 
 

classiq/interface/generator/quantum_program.py

@@ -76,6 +76,8 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
     synthesis_warnings: Optional[list[str]] = pydantic.Field(default=None)
     should_warn: bool = pydantic.Field(default=False)
+    # Unique identifier for the circuit (since the program_id might change when running show). Used for the circuit store.
+    circuit_id: str = pydantic.Field(default_factory=get_uuid_as_str)
 
     def __str__(self) -> str:
         return self.model_dump_json(indent=2)
@@ -168,7 +170,10 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
 
     @property
     def _can_use_transpiled_code(self) -> bool:
-        return self.data.execution_data is None
+        return (
+            self.data.execution_data is None
+            or not self.data.execution_data.function_execution
+        )
 
     @property
     def program_circuit(self) -> CircuitCodeInterface:

classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py

@@ -3,6 +3,7 @@ from typing import Optional
 
 import pydantic
 import sympy
+from typing_extensions import Self
 
 from classiq.interface.backend.pydantic_backend import PydanticExecutionParameter
 from classiq.interface.generator.parameters import ParameterType
@@ -34,3 +35,31 @@ class ExecutionData(pydantic.BaseModel):
                 if function_execution_data.power_vars is not None
             )
         )
+
+    def to_inverse(self) -> Self:
+        return type(self)(
+            function_execution={
+                self._inverse_name(name): value
+                for name, value in self.function_execution.items()
+            }
+        )
+
+    def to_control(self) -> Self:
+        return type(self)(
+            function_execution={
+                self._control_name(name): value
+                for name, value in self.function_execution.items()
+            }
+        )
+
+    @staticmethod
+    def _inverse_name(name: str) -> str:
+        # see inverse of qiskit.circuit.Instruction
+        if name.endswith("_dg"):
+            return name[:-3]
+        return f"{name}_dg"
+
+    @staticmethod
+    def _control_name(name: str) -> str:
+        # see inverse of qiskit.circuit.QuantumCircuit
+        return f"c_{name}"

classiq/interface/ide/operation_registry.py

@@ -12,9 +12,9 @@ class OperationRegistry:
 
     def build_operation(self, **kwargs: Any) -> Operation:
         operation = Operation(**kwargs)
-        return self.add_operation(operation)
+        return self._add_operation(operation)
 
-    def add_operation(self, op: Operation) -> Operation:
+    def _add_operation(self, op: Operation) -> Operation:
         """
         Adds an operation to the global dictionaries for operations.
         if operation already exist in the registry, it returns the existing operation.

classiq/interface/ide/visual_model.py

@@ -6,7 +6,7 @@ from itertools import count
 from typing import Any, Optional
 
 import pydantic
-from pydantic import ConfigDict
+from pydantic import ConfigDict, field_validator
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.generated_circuit_data import (
@@ -50,6 +50,8 @@ class OperationData(pydantic.BaseModel):
     width: int
     gate_count: Counter[str] = pydantic.Field(default_factory=dict)
 
+    model_config = ConfigDict(frozen=True)
+
 
 class CircuitMetrics(pydantic.BaseModel):
     depth: int
@@ -83,6 +85,21 @@ class OperationLinks(pydantic.BaseModel):
     inputs: list[OperationLink]
     outputs: list[OperationLink]
 
+    model_config = ConfigDict(frozen=True)
+
+    @field_validator("inputs", "outputs", mode="after")
+    @classmethod
+    def sort_links(cls, v: list[OperationLink]) -> Any:
+        """
+        sorting the input/output links on creation
+        the sort is done by 'label-qubits-type'
+        since hash is non-deterministic between runs
+        """
+        return sorted(v, key=hash)
+
+    def __hash__(self) -> int:
+        return hash(json.dumps(self.model_dump(exclude_none=True), sort_keys=True))
+
     @cached_property
     def input_width(self) -> int:
         return sum(len(link.qubits) for link in self.inputs)
@@ -131,6 +148,7 @@ class AtomicGate(StrEnum):
 
 class Operation(pydantic.BaseModel):
     name: str
+    inner_label: Optional[str] = None
     _id: int = pydantic.PrivateAttr(default_factory=_operation_id_counter.next_id)
     qasm_name: str = pydantic.Field(default="")
     details: str = pydantic.Field(default="")
@@ -152,6 +170,9 @@ class Operation(pydantic.BaseModel):
     is_daggered: bool = pydantic.Field(default=False)
     expanded: bool = pydantic.Field(default=False)
     show_expanded_label: bool = pydantic.Field(default=False)
+    is_low_level_fallback: bool = pydantic.Field(default=False)
+
+    model_config = ConfigDict(frozen=True)
 
     @property
     def id(self) -> int:

classiq/interface/model/quantum_type.py

@@ -85,6 +85,35 @@ class QuantumScalar(QuantumType):
     def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
         return QmodQScalarProxy(handle, size=self.size_in_bits)
 
+    @property
+    def has_sign(self) -> bool:
+        raise NotImplementedError
+
+    @property
+    def sign_value(self) -> bool:
+        raise NotImplementedError
+
+    @property
+    def has_fraction_digits(self) -> bool:
+        raise NotImplementedError
+
+    @property
+    def fraction_digits_value(self) -> int:
+        raise NotImplementedError
+
+    def get_effective_bounds(
+        self, machine_precision: Optional[int] = None
+    ) -> tuple[float, float]:
+        raise NotImplementedError
+
+    @property
+    def is_qbit(self) -> bool:
+        return (
+            self.size_in_bits == 1
+            and self.fraction_digits_value == 0
+            and not self.sign_value
+        )
+
 
 class QuantumBit(QuantumScalar):
     kind: Literal["qbit"]
@@ -117,6 +146,27 @@ class QuantumBit(QuantumScalar):
     def is_evaluated(self) -> bool:
         return True
 
+    @property
+    def has_sign(self) -> bool:
+        return True
+
+    @property
+    def sign_value(self) -> bool:
+        return False
+
+    @property
+    def has_fraction_digits(self) -> bool:
+        return True
+
+    @property
+    def fraction_digits_value(self) -> int:
+        return 0
+
+    def get_effective_bounds(
+        self, machine_precision: Optional[int] = None
+    ) -> tuple[float, float]:
+        return (0, 1)
+
 
 class QuantumBitvector(QuantumType):
     element_type: "ConcreteQuantumType" = Field(
@@ -243,14 +293,6 @@ class QuantumNumeric(QuantumScalar):
             0 if self.fraction_digits is None else self.fraction_digits.to_int_value()
         )
 
-    @property
-    def is_qbit(self) -> bool:
-        return (
-            self.size_in_bits == 1
-            and self.fraction_digits_value == 0
-            and not self.sign_value
-        )
-
     def _update_size_in_bits_from_declaration(self) -> None:
         if self.size is not None and self.size.is_evaluated():
             self._size_in_bits = self.size.to_int_value()
@@ -302,20 +344,8 @@ class QuantumNumeric(QuantumScalar):
             exprs.append(self.fraction_digits)
         return exprs
 
-    def get_bounds(
-        self, machine_precision: Optional[int] = None
-    ) -> Optional[tuple[float, float]]:
-        if (
-            self._bounds is None
-            or machine_precision is None
-            or self.fraction_digits_value <= machine_precision
-        ):
-            return self._bounds
-
-        return (
-            number_utils.limit_fraction_places(self._bounds[0], machine_precision),
-            number_utils.limit_fraction_places(self._bounds[1], machine_precision),
-        )
+    def get_bounds(self) -> Optional[tuple[float, float]]:
+        return self._bounds
 
     def set_bounds(self, bounds: Optional[tuple[float, float]]) -> None:
         self._bounds = bounds
@@ -323,19 +353,23 @@ class QuantumNumeric(QuantumScalar):
     def reset_bounds(self) -> None:
         self.set_bounds(None)
 
-    def get_maximal_bounds(
+    def get_maximal_bounds(self) -> tuple[float, float]:
+        return RegisterArithmeticInfo.get_maximal_bounds(
+            size=self.size_in_bits,
+            is_signed=self.sign_value,
+            fraction_places=self.fraction_digits_value,
+        )
+
+    def get_effective_bounds(
         self, machine_precision: Optional[int] = None
     ) -> tuple[float, float]:
-        size = self.size_in_bits
-        fraction_digits = self.fraction_digits_value
-        if machine_precision is not None and fraction_digits > machine_precision:
-            size -= fraction_digits - machine_precision
-            fraction_digits = machine_precision
+        bounds = self.get_bounds() or self.get_maximal_bounds()
 
-        return RegisterArithmeticInfo.get_maximal_bounds(
-            size=size,
-            is_signed=self.sign_value,
-            fraction_places=fraction_digits,
+        if machine_precision is None or machine_precision >= self.fraction_digits_value:
+            return bounds
+        return (
+            number_utils.limit_fraction_places(bounds[0], machine_precision),
+            number_utils.limit_fraction_places(bounds[1], machine_precision),
         )
 
 
@@ -359,7 +393,7 @@ def register_info_to_quantum_type(reg_info: RegisterArithmeticInfo) -> QuantumNu
     result.set_size_in_bits(reg_info.size)
     result.is_signed = Expression(expr=str(reg_info.is_signed))
     result.fraction_digits = Expression(expr=str(reg_info.fraction_places))
-    result.set_bounds(reg_info.bounds)
+    result.set_bounds(tuple(reg_info.bounds))  # type: ignore[arg-type]
     return result
 
 

classiq/model_expansions/arithmetic.py

@@ -0,0 +1,115 @@
+from dataclasses import dataclass
+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.model.quantum_type import (
+    QuantumScalar,
+    register_info_to_quantum_type,
+)
+
+
+@dataclass
+class NumericAttributes:
+    size: int
+    is_signed: bool
+    fraction_digits: int
+    bounds: tuple[float, float]
+
+    def __init__(
+        self,
+        size: int,
+        is_signed: bool,
+        fraction_digits: int,
+        bounds: Optional[tuple[float, float]] = None,
+        trim_bounds: bool = False,
+    ) -> None:
+        self.size = size
+        self.is_signed = is_signed
+        self.fraction_digits = fraction_digits
+        if bounds is None:
+            bounds = RegisterArithmeticInfo.get_maximal_bounds(
+                size=size,
+                is_signed=is_signed,
+                fraction_places=fraction_digits,
+            )
+        if trim_bounds:
+            bounds = (
+                number_utils.limit_fraction_places(bounds[0], fraction_digits),
+                number_utils.limit_fraction_places(bounds[1], fraction_digits),
+            )
+        self.bounds = bounds
+
+    @property
+    def lb(self) -> float:
+        return self.bounds[0]
+
+    @property
+    def ub(self) -> float:
+        return self.bounds[1]
+
+    @classmethod
+    def from_bounds(
+        cls, lb: float, ub: float, fraction_places: int, machine_precision: int
+    ) -> "NumericAttributes":
+        size, is_signed, fraction_digits = number_utils.bounds_to_attributes(
+            lb, ub, fraction_places, machine_precision
+        )
+        return cls(
+            size=size,
+            is_signed=is_signed,
+            fraction_digits=fraction_digits,
+            bounds=(lb, ub),
+        )
+
+    @classmethod
+    def from_constant(
+        cls,
+        value: float,
+        machine_precision: Optional[int] = None,
+    ) -> "NumericAttributes":
+        if machine_precision is not None:
+            value = number_utils.limit_fraction_places(value, machine_precision)
+
+        return cls(
+            size=number_utils.size(value),
+            is_signed=value < 0,
+            fraction_digits=number_utils.fraction_places(value),
+            bounds=(value, value),
+        )
+
+    @classmethod
+    def from_quantum_scalar(
+        cls,
+        quantum_type: QuantumScalar,
+        machine_precision: Optional[int] = None,
+    ) -> "NumericAttributes":
+        return cls(
+            size=quantum_type.size_in_bits,
+            is_signed=quantum_type.sign_value,
+            fraction_digits=quantum_type.fraction_digits_value,
+            bounds=quantum_type.get_effective_bounds(machine_precision),
+        )
+
+    @classmethod
+    def from_register_arithmetic_info(
+        cls,
+        register: RegisterArithmeticInfo,
+        machine_precision: Optional[int] = None,
+    ) -> "NumericAttributes":
+        return cls.from_quantum_scalar(
+            quantum_type=register_info_to_quantum_type(register),
+            machine_precision=machine_precision,
+        )
+
+    @classmethod
+    def from_type_or_constant(
+        cls,
+        from_: Union[float, QuantumScalar, RegisterArithmeticInfo],
+        machine_precision: Optional[int] = None,
+    ) -> "NumericAttributes":
+        if isinstance(from_, QuantumScalar):
+            return cls.from_quantum_scalar(from_, machine_precision)
+        if isinstance(from_, RegisterArithmeticInfo):
+            return cls.from_register_arithmetic_info(from_, machine_precision)
+        return cls.from_constant(from_, machine_precision)