classiq 0.77.0__py3-none-any.whl → 0.79.0__py3-none-any.whl

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

@@ -35,20 +35,13 @@ def _is_int(val: Any) -> TypeGuard[Union[int, sympy.Basic]]:
     return isinstance(val, int)
 
 
-class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
-    def __init__(
-        self,
-        handle: HandleBinding,
-        element_type: "ConcreteClassicalType",
-        length: "ExpressionValue",
-    ) -> None:
+class ClassicalSequenceProxy(NonSymbolicExpr, ClassicalProxy):
+    def __init__(self, handle: HandleBinding) -> None:
         super().__init__(handle)
-        self._element_type = element_type
-        self._length = length
 
     @property
     def fields(self) -> Mapping[str, "ExpressionValue"]:
-        return {"len": self._length}
+        return {"len": self.length}
 
     @property
     def type_name(self) -> str:
@@ -56,7 +49,7 @@ class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
 
     @property
     def length(self) -> "ExpressionValue":
-        return self._length
+        raise NotImplementedError
 
     def __getitem__(
         self, key: Union[slice, int, Integer, ClassicalProxy]
@@ -73,17 +66,12 @@ class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
             stop = int(stop_)
             if start >= stop:
                 raise ClassiqIndexError("Array slice has non-positive length")
-            if start < 0 or (isinstance(self._length, int) and stop > self._length):
+            if start < 0 or (isinstance(self.length, int) and stop > self.length):
                 raise ClassiqIndexError("Array slice is out of bounds")
-        return ClassicalArrayProxy(
-            SlicedHandleBinding(
-                base_handle=self.handle,
-                start=Expression(expr=str(start_)),
-                end=Expression(expr=str(stop_)),
-            ),
-            self._element_type,
-            stop_ - start_,
-        )
+        return self.get_slice_at(start_, stop_)
+
+    def get_slice_at(self, start: Any, stop: Any) -> ClassicalProxy:
+        raise NotImplementedError
 
     def _get_subscript(
         self, index_: Union[int, Integer, ClassicalProxy]
@@ -94,10 +82,89 @@ class ClassicalArrayProxy(NonSymbolicExpr, ClassicalProxy):
                 raise ClassiqIndexError(
                     "Array index is out of bounds (negative indices are not supported)"
                 )
-            if isinstance(self._length, int) and index >= self._length:
+            if isinstance(self.length, int) and index >= self.length:
                 raise ClassiqIndexError("Array index is out of bounds")
+        return self.get_subscript_at(index_)
+
+    def get_subscript_at(self, index: Any) -> ClassicalProxy:
+        raise NotImplementedError
+
+
+class ClassicalArrayProxy(ClassicalSequenceProxy):
+    def __init__(
+        self,
+        handle: HandleBinding,
+        element_type: "ConcreteClassicalType",
+        length: "ExpressionValue",
+    ) -> None:
+        super().__init__(handle)
+        self._element_type = element_type
+        if _is_int(length):
+            length = int(length)
+        self._length = length
+
+    @property
+    def length(self) -> "ExpressionValue":
+        return self._length
+
+    def get_slice_at(self, start: Any, stop: Any) -> ClassicalProxy:
+        return ClassicalArrayProxy(
+            SlicedHandleBinding(
+                base_handle=self.handle,
+                start=Expression(expr=str(start)),
+                end=Expression(expr=str(stop)),
+            ),
+            self._element_type,
+            stop - start,
+        )
+
+    def get_subscript_at(self, index: Any) -> ClassicalProxy:
         return self._element_type.get_classical_proxy(
             SubscriptHandleBinding(
-                base_handle=self._handle, index=Expression(expr=str(index_))
+                base_handle=self._handle, index=Expression(expr=str(index))
+            )
+        )
+
+
+class ClassicalTupleProxy(ClassicalSequenceProxy):
+    def __init__(
+        self, handle: HandleBinding, element_types: list["ConcreteClassicalType"]
+    ) -> None:
+        super().__init__(handle)
+        self._element_types = element_types
+
+    @property
+    def length(self) -> int:
+        return len(self._element_types)
+
+    def get_slice_at(self, start: Any, stop: Any) -> ClassicalProxy:
+        handle = SlicedHandleBinding(
+            base_handle=self.handle,
+            start=Expression(expr=str(start)),
+            end=Expression(expr=str(stop)),
+        )
+        if (_is_int(start) or start is None) and (_is_int(stop) or stop is None):
+            return ClassicalTupleProxy(
+                handle, self._element_types.__getitem__(slice(start, stop))
+            )
+        return ClassicalArrayProxy(
+            handle,
+            self._element_types[0].get_raw_type(),
+            stop - start,
+        )
+
+    def get_subscript_at(self, index: Any) -> ClassicalProxy:
+        handle = SubscriptHandleBinding(
+            base_handle=self._handle, index=Expression(expr=str(index))
+        )
+        if _is_int(index):
+            return self._element_types[int(index)].get_classical_proxy(handle)
+        return (
+            self._element_types[0]
+            .get_raw_type()
+            .get_classical_proxy(
+                SubscriptHandleBinding(
+                    base_handle=self._handle, index=Expression(expr=str(index))
+                )
             )
         )

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

@@ -1,6 +1,7 @@
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
     ClassicalArrayProxy,
+    ClassicalTupleProxy,
 )
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
@@ -14,6 +15,7 @@ from classiq.interface.generator.expressions.proxies.classical.classical_struct_
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalList,
+    ClassicalTuple,
     ClassicalType,
 )
 from classiq.interface.generator.functions.type_name import Struct
@@ -26,6 +28,8 @@ def get_proxy_type(proxy: ClassicalProxy) -> ClassicalType:
         if not isinstance(proxy.length, int):
             return ClassicalList(element_type=proxy._element_type)
         return ClassicalArray(element_type=proxy._element_type, size=proxy.length)
+    if isinstance(proxy, ClassicalTupleProxy):
+        return ClassicalTuple(element_types=proxy._element_types)
     if isinstance(proxy, ClassicalStructProxy):
         classical_type = Struct(name=proxy._decl.name)
         classical_type.set_classical_struct_decl(proxy._decl)

classiq/interface/generator/functions/classical_type.py

@@ -1,3 +1,4 @@
+from itertools import chain
 from typing import TYPE_CHECKING, Any, Literal
 
 import pydantic
@@ -11,6 +12,7 @@ from classiq.interface.generator.expressions.proxies.classical.any_classical_val
 )
 from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
     ClassicalArrayProxy,
+    ClassicalTupleProxy,
 )
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
@@ -47,6 +49,10 @@ class ClassicalType(HashableASTNode):
     def is_purely_declarative(self) -> bool:
         return not self._is_generative
 
+    @property
+    def is_purely_generative(self) -> bool:
+        return self._is_generative
+
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
         return ClassicalScalarProxy(handle, self)
 
@@ -59,6 +65,9 @@ class ClassicalType(HashableASTNode):
         res._is_generative = False
         return res
 
+    def get_raw_type(self) -> "ConcreteClassicalType":
+        return self  # type:ignore[return-value]
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
@@ -109,6 +118,16 @@ class ClassicalList(ClassicalType):
     def is_purely_declarative(self) -> bool:
         return super().is_purely_declarative and self.element_type.is_purely_declarative
 
+    @property
+    def is_purely_generative(self) -> bool:
+        return super().is_purely_generative and self.element_type.is_purely_generative
+
+    def get_raw_type(self) -> "ConcreteClassicalType":
+        raw_type = ClassicalList(element_type=self.element_type.get_raw_type())
+        if self._is_generative:
+            raw_type.set_generative()
+        return raw_type
+
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
@@ -143,6 +162,61 @@ class ClassicalArray(ClassicalType):
     def is_purely_declarative(self) -> bool:
         return super().is_purely_declarative and self.element_type.is_purely_declarative
 
+    @property
+    def is_purely_generative(self) -> bool:
+        return super().is_purely_generative and self.element_type.is_purely_generative
+
+    def get_raw_type(self) -> "ConcreteClassicalType":
+        raw_type = ClassicalList(element_type=self.element_type.get_raw_type())
+        if self._is_generative:
+            raw_type.set_generative()
+        return raw_type
+
+
+class ClassicalTuple(ClassicalType):
+    kind: Literal["tuple"]
+    element_types: list["ConcreteClassicalType"]
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
+        return values_with_discriminator(values, "kind", "tuple")
+
+    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
+        return ClassicalTupleProxy(handle=handle, element_types=self.element_types)
+
+    @property
+    def expressions(self) -> list[Expression]:
+        return list(
+            chain.from_iterable(
+                element_type.expressions for element_type in self.element_types
+            )
+        )
+
+    @property
+    def is_purely_declarative(self) -> bool:
+        return super().is_purely_declarative and all(
+            element_type.is_purely_declarative for element_type in self.element_types
+        )
+
+    @property
+    def is_purely_generative(self) -> bool:
+        return super().is_purely_generative and all(
+            element_type.is_purely_generative for element_type in self.element_types
+        )
+
+    def get_raw_type(self) -> "ConcreteClassicalType":
+        if len(self.element_types) == 0:
+            return self
+        raw_type = ClassicalList(element_type=self.element_types[0].get_raw_type())
+        if self._is_generative:
+            raw_type.set_generative()
+        return raw_type
+
+    @property
+    def size(self) -> int:
+        return len(self.element_types)
+
 
 class OpaqueHandle(ClassicalType):
     pass

classiq/interface/generator/functions/concrete_types.py

@@ -6,6 +6,7 @@ from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
     ClassicalList,
+    ClassicalTuple,
     Estimation,
     Histogram,
     Integer,
@@ -32,6 +33,7 @@ ConcreteClassicalType = Annotated[
         StructMetaType,
         TypeName,
         ClassicalArray,
+        ClassicalTuple,
         VQEResult,
         Histogram,
         Estimation,
@@ -41,6 +43,7 @@ ConcreteClassicalType = Annotated[
 ]
 ClassicalList.model_rebuild()
 ClassicalArray.model_rebuild()
+ClassicalTuple.model_rebuild()
 
 NativePythonClassicalTypes = (int, float, bool, list)
 PythonClassicalPydanticTypes = (Enum,)

classiq/interface/generator/functions/type_name.py

@@ -28,7 +28,10 @@ from classiq.interface.model.quantum_type import (
 )
 
 if TYPE_CHECKING:
-    from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+    from classiq.interface.generator.functions.concrete_types import (
+        ConcreteClassicalType,
+        ConcreteQuantumType,
+    )
     from classiq.interface.generator.types.struct_declaration import StructDeclaration
 
 
@@ -138,16 +141,42 @@ class TypeName(ClassicalType, QuantumType):
     @property
     def is_purely_declarative(self) -> bool:
         if self.is_enum:
-            return False
-        return super().is_purely_declarative and all(
+            return not self.is_generative
+        return all(
             field_type.is_purely_declarative
             for field_type in self.classical_struct_decl.variables.values()
         )
 
+    @property
+    def is_purely_generative(self) -> bool:
+        if self.is_enum:
+            return self.is_generative
+        return all(
+            field_type.is_purely_generative
+            for field_type in self.classical_struct_decl.variables.values()
+        )
+
     @property
     def is_enum(self) -> bool:
         return not self.has_fields and not self.has_classical_struct_decl
 
+    def get_raw_type(self) -> "ConcreteClassicalType":
+        if self.is_enum:
+            return self
+        if TYPE_CHECKING:
+            assert self._classical_struct_decl is not None
+        raw_type = TypeName(name=self.name)
+        raw_decl = self._classical_struct_decl.model_copy(
+            update=dict(
+                variables={
+                    field_name: field_type.get_raw_type()
+                    for field_name, field_type in self._classical_struct_decl.variables.items()
+                }
+            )
+        )
+        raw_type.set_classical_struct_decl(raw_decl)
+        return raw_type
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/generated_circuit_data.py

@@ -145,6 +145,8 @@ class StatementType(StrEnum):
     POWER = "power"
     INVERT = "invert"
     WITHIN_APPLY = "within apply"
+    WITHIN = "within"
+    APPLY = "apply"
     ASSIGN = "assign"
     ASSIGN_AMPLITUDE = "assign amplitude"
     PHASE = "phase"
@@ -161,6 +163,9 @@ STATEMENTS_NAME: dict[str, StatementType] = {
     "Power": StatementType.POWER,
     "Invert": StatementType.INVERT,
     "WithinApply": StatementType.WITHIN_APPLY,
+    "Compute": StatementType.WITHIN,
+    "Action": StatementType.APPLY,
+    "Uncompute": StatementType.WITHIN,
     ArithmeticOperationKind.Assignment.value: StatementType.ASSIGN,
     "InplaceBinaryOperation": StatementType.ASSIGN,
     "AmplitudeLoadingOperation": StatementType.ASSIGN_AMPLITUDE,
@@ -176,6 +181,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
     children: list["FunctionDebugInfoInterface"]
     relative_qubits: tuple[int, ...]
     absolute_qubits: Optional[tuple[int, ...]] = Field(default=None)
+    control_variable: Optional[str] = Field(default=None)
     is_basis_gate: Optional[bool] = Field(default=None)
     is_inverse: bool = Field(default=False)
     is_unitary: bool = Field(default=True, exclude=True)
@@ -204,15 +210,24 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             return generated_name
 
         if isinstance(back_ref, QuantumFunctionCall):
-            name = generate_original_function_name(back_ref.func_name)
-            if part_match := PART_SUFFIX_REGEX.match(generated_name):
-                name += f" [{part_match.group(1)}]"
-            return name.removeprefix(ARITH_ENGINE_PREFIX)
+            name = generate_original_function_name(back_ref.func_name).removeprefix(
+                ARITH_ENGINE_PREFIX
+            )
+            return self.add_suffix_from_generated_name(generated_name, name)
 
         statement_kind: str = back_ref.kind
         if isinstance(back_ref, ArithmeticOperation):
             statement_kind = back_ref.operation_kind.value
-        return STATEMENTS_NAME[statement_kind]
+        return self.add_suffix_from_generated_name(
+            generated_name, STATEMENTS_NAME[statement_kind]
+        )
+
+    def add_suffix_from_generated_name(self, generated_name: str, name: str) -> str:
+        if part_match := PART_SUFFIX_REGEX.match(generated_name):
+            suffix = f" [{part_match.group(1)}]"
+        else:
+            suffix = ""
+        return f"{name}{suffix}"
 
     @property
     def first_back_ref(self) -> Optional[ConcreteQuantumStatement]:
@@ -347,9 +362,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         if role is RegisterRole.INPUT:
             return RegisterRole.OUTPUT
         if role is RegisterRole.EXPLICIT_ZERO_INPUT or role is RegisterRole.ZERO_INPUT:
-            if self.release_by_inverse:
-                return RegisterRole.ZERO_OUTPUT
-            return RegisterRole.OUTPUT
+            return RegisterRole.ZERO_OUTPUT
         if role is RegisterRole.AUXILIARY:
             return RegisterRole.AUXILIARY
         if role is RegisterRole.OUTPUT or role is RegisterRole.GARBAGE_OUTPUT:

classiq/interface/helpers/model_normalizer.py

@@ -0,0 +1,47 @@
+import ast
+from typing import Any
+
+from classiq.interface.ast_node import ASTNode
+from classiq.interface.debug_info.debug_info import DebugInfoCollection
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import ClassicalType
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.visitor import Transformer, Visitor
+from classiq.interface.model.model import Model
+from classiq.interface.model.port_declaration import AnonPortDeclaration
+
+from classiq.model_expansions.transformers.model_renamer import ExprNormalizer
+
+
+class ModelNormalizer(Visitor):
+    def visit(self, node: Any) -> None:
+        if isinstance(node, ASTNode):
+            node.model_config["frozen"] = False
+            node.source_ref = None
+            node.back_ref = None
+            if hasattr(node, "uuid"):
+                node.uuid = None
+        super().visit(node)
+
+    def visit_Model(self, model: Model) -> None:
+        model.debug_info = DebugInfoCollection()
+        model.functions.sort(key=lambda x: x.name)
+        self.generic_visit(model)
+
+    def visit_Expression(self, expr: Expression) -> None:
+        expr.expr = ast.unparse(ExprNormalizer().visit(ast.parse(expr.expr)))
+
+    def visit_AnonPortDeclaration(self, decl: AnonPortDeclaration) -> None:
+        decl.type_qualifier = TypeQualifier.Quantum
+
+
+class ClearModelInternals(Transformer):
+    def visit_Expression(self, expr: Expression) -> Expression:
+        if expr._evaluated_expr is not None and not expr._evaluated_expr.is_constant():
+            expr._evaluated_expr = None
+        return expr
+
+    def visit_ClassicalType(self, classical_type: ClassicalType) -> ClassicalType:
+        return type(classical_type).model_validate_json(
+            classical_type.model_dump_json()
+        )

classiq/interface/ide/visual_model.py

@@ -15,6 +15,7 @@ from classiq.interface.helpers.versioned_model import VersionedModel
 
 class OperationType(StrEnum):
     REGULAR = "REGULAR"
+    INVISIBLE = "INVISIBLE"
     ALLOCATE = "ALLOCATE"
     FREE = "FREE"
     BIND = "BIND"
@@ -124,6 +125,7 @@ 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)
 
 
 class ProgramVisualModel(VersionedModel):

classiq/interface/interface_version.py

@@ -1 +1 @@
-INTERFACE_VERSION = "10"
+INTERFACE_VERSION = "11"

classiq/interface/model/bounds.py

@@ -0,0 +1,12 @@
+from typing import Literal, Optional
+
+from classiq.interface.helpers.custom_pydantic_types import PydanticFloatTuple
+from classiq.interface.model.handle_binding import ConcreteHandleBinding
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+
+class SetBoundsStatement(QuantumOperation):
+    kind: Literal["SetBoundsStatement"]
+
+    target: ConcreteHandleBinding
+    bounds: Optional[PydanticFloatTuple]

classiq/interface/model/model.py

@@ -1,6 +1,6 @@
-from collections import Counter
+from collections import Counter, defaultdict
 from collections.abc import Mapping
-from typing import Any, Literal, NewType
+from typing import Annotated, Any, Literal, NewType
 
 import pydantic
 
@@ -99,9 +99,13 @@ class Model(VersionedModel, ASTNode):
     debug_info: DebugInfoCollection = pydantic.Field(
         default_factory=DebugInfoCollection
     )
-    functions_compilation_metadata: dict[str, CompilationMetadata] = pydantic.Field(
-        default_factory=dict
-    )
+    functions_compilation_metadata: defaultdict[
+        str,
+        Annotated[
+            CompilationMetadata,
+            pydantic.Field(default_factory=CompilationMetadata),
+        ],
+    ] = pydantic.Field(default_factory=lambda: defaultdict(CompilationMetadata))
 
     @property
     def main_func(self) -> NativeFunctionDefinition:

classiq/interface/model/quantum_type.py

@@ -22,6 +22,7 @@ from classiq.interface.generator.expressions.proxies.quantum.qmod_qscalar_proxy
 from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
     QmodSizedProxy,
 )
+from classiq.interface.helpers.custom_pydantic_types import PydanticFloatTuple
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.handle_binding import HandleBinding
 
@@ -193,6 +194,8 @@ class QuantumNumeric(QuantumScalar):
     is_signed: Optional[Expression] = pydantic.Field(default=None)
     fraction_digits: Optional[Expression] = pydantic.Field(default=None)
 
+    _bounds: Optional[PydanticFloatTuple] = pydantic.PrivateAttr(default=None)
+
     @pydantic.model_validator(mode="before")
     @classmethod
     def _set_kind(cls, values: Any) -> dict[str, Any]:
@@ -287,6 +290,22 @@ class QuantumNumeric(QuantumScalar):
             exprs.append(self.fraction_digits)
         return exprs
 
+    def get_bounds(self) -> Optional[tuple[float, float]]:
+        return self._bounds
+
+    def set_bounds(self, bounds: Optional[tuple[float, float]]) -> None:
+        self._bounds = bounds
+
+    def reset_bounds(self) -> None:
+        self.set_bounds(None)
+
+    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,
+        )
+
 
 class RegisterQuantumType(BaseModel):
     quantum_types: "ConcreteQuantumType"
@@ -308,6 +327,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)
     return result
 
 
@@ -315,17 +335,19 @@ UNRESOLVED_SIZE = 1000
 
 
 def quantum_var_to_register(name: str, qtype: QuantumType) -> RegisterUserInput:
+    signed: bool = False
+    fraction_places: int = 0
+    bounds: Optional[tuple[float, float]] = None
     if isinstance(qtype, QuantumNumeric):
         signed = qtype.sign_value
         fraction_places = qtype.fraction_digits_value
-    else:
-        signed = False
-        fraction_places = 0
+        bounds = qtype.get_bounds()
     return RegisterUserInput(
         name=name,
         size=qtype.size_in_bits if qtype.has_size_in_bits else UNRESOLVED_SIZE,
         is_signed=signed,
         fraction_places=fraction_places,
+        bounds=bounds,
     )
 
 

classiq/interface/model/statement_block.py

@@ -5,6 +5,7 @@ from pydantic import Field
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.block import Block
+from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
@@ -51,6 +52,7 @@ ConcreteQuantumStatement = Annotated[
         Compute,
         Action,
         Uncompute,
+        SetBoundsStatement,
     ],
     Field(..., discriminator="kind"),
 ]