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

classiq/interface/model/bind_operation.py

@@ -1,30 +1,60 @@
-from typing import Mapping
+from collections.abc import Mapping, Sequence
+from typing import Literal
 
 import pydantic
 
-from classiq.interface.model.handle_binding import HandleBinding
-from classiq.interface.model.quantum_statement import QuantumOperation
-
-from classiq.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
+from classiq.interface.model.quantum_statement import HandleMetadata, QuantumOperation
 
 BIND_INPUT_NAME = "bind_input"
 BIND_OUTPUT_NAME = "bind_output"
 
 
 class BindOperation(QuantumOperation):
-    in_handle: HandleBinding
-    out_handle: HandleBinding
+    kind: Literal["BindOperation"]
+
+    in_handles: list[ConcreteHandleBinding]
+    out_handles: list[ConcreteHandleBinding]
 
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:
-        return {BIND_INPUT_NAME: self.in_handle}
+        return {
+            f"{BIND_INPUT_NAME}_{i}": handle for i, handle in enumerate(self.in_handles)
+        }
+
+    @property
+    def readable_inputs(self) -> Sequence[HandleMetadata]:
+        return [
+            HandleMetadata(
+                handle=handle,
+                readable_location="on the left-hand side of a bind statement",
+            )
+            for handle in self.in_handles
+        ]
 
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        return {BIND_OUTPUT_NAME: self.out_handle}
+        return {
+            f"{BIND_OUTPUT_NAME}_{i}": handle
+            for i, handle in enumerate(self.out_handles)
+        }
 
-    @pydantic.validator("in_handle", "out_handle")
-    def validate_handle(cls, handle: HandleBinding) -> HandleBinding:
-        if not handle.is_bindable():
-            raise ClassiqValueError(f"Cannot bind '{handle}'")  # noqa: B907
-        return handle
+    @property
+    def readable_outputs(self) -> Sequence[HandleMetadata]:
+        return [
+            HandleMetadata(
+                handle=handle,
+                readable_location="on the right-hand side of a bind statement",
+            )
+            for handle in self.out_handles
+        ]
+
+    @pydantic.field_validator("in_handles", "out_handles")
+    @classmethod
+    def validate_handle(cls, handles: list[HandleBinding]) -> list[HandleBinding]:
+        for handle in handles:
+            if not handle.is_bindable():
+                raise ClassiqValueError(f"Cannot bind '{handle}'")
+
+        return handles

classiq/interface/model/classical_if.py

@@ -0,0 +1,15 @@
+from typing import TYPE_CHECKING, Literal
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class ClassicalIf(QuantumOperation):
+    kind: Literal["ClassicalIf"]
+
+    condition: Expression
+    then: "StatementBlock"
+    else_: "StatementBlock"

classiq/interface/model/classical_parameter_declaration.py

@@ -1,8 +1,38 @@
+from typing import Any, Literal
+
 import pydantic
 
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.exceptions import ClassiqInternalError
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
+from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.parameter import Parameter
 
 
-class ClassicalParameterDeclaration(pydantic.BaseModel):
-    name: str
+class AnonClassicalParameterDeclaration(Parameter):
+    kind: Literal["ClassicalParameterDeclaration"]
     classical_type: ConcreteClassicalType
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
+        return values_with_discriminator(
+            values, "kind", "ClassicalParameterDeclaration"
+        )
+
+    def rename(self, new_name: str) -> "ClassicalParameterDeclaration":
+        if type(self) not in (
+            AnonClassicalParameterDeclaration,
+            ClassicalParameterDeclaration,
+        ):
+            raise ClassiqInternalError
+        return ClassicalParameterDeclaration(
+            **{
+                **self.__dict__,
+                "name": new_name,
+                "kind": "ClassicalParameterDeclaration",
+            }
+        )
+
+
+class ClassicalParameterDeclaration(AnonClassicalParameterDeclaration):
+    name: str

classiq/interface/model/control.py

@@ -0,0 +1,45 @@
+from typing import TYPE_CHECKING, Literal, Optional
+
+import pydantic
+
+from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumExpressionOperation,
+)
+from classiq.interface.model.quantum_type import QuantumType
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class Control(QuantumExpressionOperation):
+    kind: Literal["Control"]
+    body: "StatementBlock"
+    else_block: Optional["StatementBlock"] = None
+
+    _ctrl_size: int = pydantic.PrivateAttr(default=0)
+    _result_type: Optional[QuantumType] = pydantic.PrivateAttr(
+        default=None,
+    )
+
+    @property
+    def ctrl_size(self) -> int:
+        return self._ctrl_size
+
+    def set_ctrl_size(self, ctrl_size: int) -> None:
+        self._ctrl_size = ctrl_size
+
+    @property
+    def result_type(self) -> QuantumType:
+        assert self._result_type is not None
+        return self._result_type
+
+    def initialize_var_types(
+        self,
+        var_types: dict[str, QuantumType],
+        machine_precision: int,
+    ) -> None:
+        super().initialize_var_types(var_types, machine_precision)
+        self._result_type = compute_arithmetic_result_type(
+            self.expression.expr, var_types, machine_precision
+        )

classiq/interface/model/handle_binding.py

@@ -1,46 +1,324 @@
-from pydantic import BaseModel, Extra
+from collections.abc import Sequence
+from itertools import chain
+from typing import TYPE_CHECKING, Any, Union
 
+import pydantic
+from pydantic import ConfigDict, Field
+from typing_extensions import Self
+
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.expressions.expression import Expression
 
+HANDLE_ID_SEPARATOR = "___"
 
-class HandleBinding(BaseModel):
-    name: str
 
-    class Config:
-        frozen = True
-        extra = Extra.forbid
+class HandleBinding(ASTNode):
+    name: str = Field(default=None)
+    model_config = ConfigDict(frozen=True, extra="forbid")
 
     def __str__(self) -> str:
         return self.name
 
+    @property
+    def qmod_expr(self) -> str:
+        return self.name
+
     def is_bindable(self) -> bool:
         return True
 
+    @property
+    def identifier(self) -> str:
+        return self.name
 
-class SubscriptHandleBinding(HandleBinding):
-    index: Expression
+    def collapse(self) -> "HandleBinding":
+        return self
 
-    class Config:
-        frozen = True
-        extra = Extra.forbid
+    def prefixes(self) -> Sequence["HandleBinding"]:
+        """
+        Split the handle into prefixes:
+        a.b[0].c --> [a, a.b, a.b[0], a.b[0].c]
+        """
+        return [self]
 
-    def __str__(self) -> str:
-        return f"{self.name}[{self.index}]"
+    def _tail_overlaps(self, other_handle: "HandleBinding") -> bool:
+        return self.name == other_handle.name
+
+    def overlaps(self, other_handle: "HandleBinding") -> bool:
+        self_prefixes = self.collapse().prefixes()
+        other_prefixes = other_handle.collapse().prefixes()
+        return all(
+            self_prefix._tail_overlaps(other_prefix)
+            for self_prefix, other_prefix in zip(self_prefixes, other_prefixes)
+        )
+
+    def rename(self, name: str) -> Self:
+        return self.model_copy(update=dict(name=name))
+
+    def replace_prefix(
+        self, prefix: "HandleBinding", replacement: "HandleBinding"
+    ) -> "HandleBinding":
+        if self == prefix:
+            return replacement
+        return self
+
+    def __contains__(self, other_handle: "HandleBinding") -> bool:
+        return self.collapse() in other_handle.collapse().prefixes()
+
+
+class NestedHandleBinding(HandleBinding):
+    base_handle: "ConcreteHandleBinding"
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_name(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            orig = values
+            while "base_handle" in dict(values):
+                values = dict(values)["base_handle"]
+            orig["name"] = dict(values).get("name")
+            return orig
+        if isinstance(values, NestedHandleBinding):
+            values.name = values.base_handle.name
+            return values.model_dump()
+        return values
 
     def is_bindable(self) -> bool:
         return False
 
+    def prefixes(self) -> Sequence["HandleBinding"]:
+        return list(chain.from_iterable([self.base_handle.prefixes(), [self]]))
+
+    def rename(self, name: str) -> Self:
+        return self.model_copy(
+            update=dict(name=name, base_handle=self.base_handle.rename(name))
+        )
+
+    def replace_prefix(
+        self, prefix: HandleBinding, replacement: HandleBinding
+    ) -> HandleBinding:
+        if self == prefix:
+            return replacement
+        new_base_handle = self.base_handle.replace_prefix(prefix, replacement)
+        if new_base_handle is not self.base_handle:
+            return self.model_copy(
+                update=dict(name=new_base_handle.name, base_handle=new_base_handle)
+            )
+        return self
+
+
+class SubscriptHandleBinding(NestedHandleBinding):
+    index: Expression
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    def __str__(self) -> str:
+        return f"{self.base_handle}[{self.index}]"
+
+    @property
+    def qmod_expr(self) -> str:
+        return f"{self.base_handle.qmod_expr}[{self.index}]"
+
+    @property
+    def identifier(self) -> str:
+        return f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}{self.index}"
+
+    def collapse(self) -> HandleBinding:
+        if isinstance(self.base_handle, SlicedHandleBinding):
+            return SubscriptHandleBinding(
+                base_handle=self.base_handle.base_handle,
+                index=self._get_collapsed_index(),
+            ).collapse()
+        return SubscriptHandleBinding(
+            base_handle=self.base_handle.collapse(),
+            index=self.index,
+        )
+
+    def _get_collapsed_index(self) -> Expression:
+        if TYPE_CHECKING:
+            assert isinstance(self.base_handle, SlicedHandleBinding)
+        if self.index.is_evaluated() and self.base_handle.start.is_evaluated():
+            return Expression(
+                expr=str(
+                    self.base_handle.start.to_int_value() + self.index.to_int_value()
+                )
+            )
+        return Expression(expr=f"({self.base_handle.start})+({self.index})")
 
-class SlicedHandleBinding(HandleBinding):
+    def _tail_overlaps(self, other_handle: "HandleBinding") -> bool:
+        if isinstance(other_handle, SubscriptHandleBinding):
+            return self.index == other_handle.index
+        if (
+            isinstance(other_handle, SlicedHandleBinding)
+            and self.index.is_evaluated()
+            and other_handle._is_evaluated()
+        ):
+            return (
+                other_handle.start.to_int_value()
+                <= self.index.to_int_value()
+                < other_handle.end.to_int_value()
+            )
+        return False
+
+    def replace_prefix(
+        self, prefix: HandleBinding, replacement: HandleBinding
+    ) -> HandleBinding:
+        if (
+            isinstance(prefix, SlicedHandleBinding)
+            and self.base_handle == prefix.base_handle
+            and self.index.is_evaluated()
+            and prefix._is_evaluated()
+            and prefix.start.to_int_value()
+            <= self.index.to_int_value()
+            < prefix.end.to_int_value()
+        ):
+            return SubscriptHandleBinding(
+                base_handle=replacement,
+                index=Expression(
+                    expr=str(self.index.to_int_value() - prefix.start.to_int_value())
+                ),
+            )
+        return super().replace_prefix(prefix, replacement)
+
+
+class SlicedHandleBinding(NestedHandleBinding):
     start: Expression
     end: Expression
-
-    class Config:
-        frozen = True
-        extra = Extra.forbid
+    model_config = ConfigDict(frozen=True, extra="forbid")
 
     def __str__(self) -> str:
-        return f"{self.name}[{self.start}:{self.end}]"
+        return f"{self.base_handle}[{self.start}:{self.end}]"
 
-    def is_bindable(self) -> bool:
+    @property
+    def qmod_expr(self) -> str:
+        return f"{self.base_handle.qmod_expr}[{self.start}:{self.end}]"
+
+    @property
+    def identifier(self) -> str:
+        return (
+            f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}{self.start}_{self.end}"
+        )
+
+    def collapse(self) -> HandleBinding:
+        if isinstance(self.base_handle, SlicedHandleBinding):
+            return SlicedHandleBinding(
+                base_handle=self.base_handle.base_handle,
+                start=self._get_collapsed_start(),
+                end=self._get_collapsed_stop(),
+            ).collapse()
+        return SlicedHandleBinding(
+            base_handle=self.base_handle.collapse(),
+            start=self.start,
+            end=self.end,
+        )
+
+    def _tail_overlaps(self, other_handle: "HandleBinding") -> bool:
+        if not self._is_evaluated():
+            return False
+        start = self.start.to_int_value()
+        end = self.end.to_int_value()
+        if (
+            isinstance(other_handle, SubscriptHandleBinding)
+            and other_handle.index.is_evaluated()
+        ):
+            return start <= other_handle.index.to_int_value() < end
+        if (
+            isinstance(other_handle, SlicedHandleBinding)
+            and other_handle._is_evaluated()
+        ):
+            other_start = other_handle.start.to_int_value()
+            other_end = other_handle.end.to_int_value()
+            return start <= other_start < end or other_start <= start < other_end
         return False
+
+    def _get_collapsed_start(self) -> Expression:
+        if TYPE_CHECKING:
+            assert isinstance(self.base_handle, SlicedHandleBinding)
+        if self.start.is_evaluated() and self.base_handle.start.is_evaluated():
+            return Expression(
+                expr=str(
+                    self.base_handle.start.to_int_value() + self.start.to_int_value()
+                )
+            )
+        return Expression(expr=f"({self.base_handle.start})+({self.start})")
+
+    def _get_collapsed_stop(self) -> Expression:
+        if TYPE_CHECKING:
+            assert isinstance(self.base_handle, SlicedHandleBinding)
+        if self._is_evaluated() and self.base_handle.start.is_evaluated():
+            return Expression(
+                expr=str(
+                    self.end.to_int_value()
+                    - self.start.to_int_value()
+                    + self.base_handle.start.to_int_value()
+                )
+            )
+        return Expression(
+            expr=f"({self.end})-({self.start})+({self.base_handle.start})"
+        )
+
+    def replace_prefix(
+        self, prefix: HandleBinding, replacement: HandleBinding
+    ) -> HandleBinding:
+        if self == prefix:
+            return replacement
+        if (
+            isinstance(prefix, SlicedHandleBinding)
+            and self.base_handle == prefix.base_handle
+            and self._is_evaluated()
+            and prefix._is_evaluated()
+        ):
+            prefix_start = prefix.start.to_int_value()
+            prefix_end = prefix.end.to_int_value()
+            self_start = self.start.to_int_value()
+            self_end = self.end.to_int_value()
+            if (
+                prefix_start <= self_start < prefix_end
+                and prefix_start < self_end <= prefix_end
+            ):
+                return SlicedHandleBinding(
+                    base_handle=replacement,
+                    start=Expression(expr=str(self_start - prefix_start)),
+                    end=Expression(expr=str(self_end - prefix_start)),
+                )
+        return super().replace_prefix(prefix, replacement)
+
+    def _is_evaluated(self) -> bool:
+        return self.start.is_evaluated() and self.end.is_evaluated()
+
+
+class FieldHandleBinding(NestedHandleBinding):
+    field: str
+    model_config = ConfigDict(frozen=True, extra="forbid")
+
+    def __str__(self) -> str:
+        return f"{self.base_handle}.{self.field}"
+
+    @property
+    def qmod_expr(self) -> str:
+        return f"get_field({self.base_handle.qmod_expr}, '{self.field}')"
+
+    @property
+    def identifier(self) -> str:
+        return f"{self.base_handle.identifier}{HANDLE_ID_SEPARATOR}{self.field}"
+
+    def collapse(self) -> HandleBinding:
+        return FieldHandleBinding(
+            base_handle=self.base_handle.collapse(),
+            field=self.field,
+        )
+
+    def _tail_overlaps(self, other_handle: "HandleBinding") -> bool:
+        return (
+            isinstance(other_handle, FieldHandleBinding)
+            and self.field == other_handle.field
+        )
+
+
+ConcreteHandleBinding = Union[
+    HandleBinding,
+    SubscriptHandleBinding,
+    SlicedHandleBinding,
+    FieldHandleBinding,
+]
+SubscriptHandleBinding.model_rebuild()
+SlicedHandleBinding.model_rebuild()
+FieldHandleBinding.model_rebuild()

classiq/interface/model/inplace_binary_operation.py

@@ -1,38 +1,43 @@
-from typing import Mapping
+from collections.abc import Mapping, Sequence
+from typing import Literal, Union
 
-import pydantic
-
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-from classiq.interface.model.handle_binding import HandleBinding
-from classiq.interface.model.quantum_statement import QuantumOperation
-
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.handle_binding import ConcreteHandleBinding, HandleBinding
+from classiq.interface.model.quantum_statement import HandleMetadata, QuantumOperation
 
 
 class BinaryOperation(StrEnum):
-    Addition = "addition"
-    Xor = "xor"
-
-    @property
-    def internal_function(self) -> str:
-        return {
-            BinaryOperation.Addition: "modular_add",
-            BinaryOperation.Xor: "integer_xor",
-        }[self]
+    Addition = "inplace_add"
+    Xor = "inplace_xor"
 
 
 class InplaceBinaryOperation(QuantumOperation):
-    target: HandleBinding
-    value: HandleBinding
+    kind: Literal["InplaceBinaryOperation"]
+
+    target: ConcreteHandleBinding
+    value: Union[ConcreteHandleBinding, Expression]
     operation: BinaryOperation
 
     @property
     def wiring_inouts(self) -> Mapping[str, HandleBinding]:
-        return nameables_to_dict([self.target, self.value])
+        inouts = {self.target.name: self.target}
+        if isinstance(self.value, HandleBinding):
+            inouts[self.value.name] = self.value
+        return inouts
 
-    @pydantic.validator("target", "value")
-    def validate_handle(cls, handle: HandleBinding) -> HandleBinding:
-        if not handle.is_bindable():
-            raise ClassiqValueError(f"Cannot bind '{handle!r}'")
-        return handle
+    @property
+    def readable_inouts(self) -> Sequence[HandleMetadata]:
+        suffix = f" of an in-place {self.operation.name.lower()} statement"
+        readable_inouts = [
+            HandleMetadata(
+                handle=self.target, readable_location=f"as the target{suffix}"
+            )
+        ]
+        if isinstance(self.value, HandleBinding):
+            readable_inouts.append(
+                HandleMetadata(
+                    handle=self.value, readable_location=f"as the value{suffix}"
+                )
+            )
+        return readable_inouts

classiq/interface/model/invert.py

@@ -0,0 +1,12 @@
+from typing import TYPE_CHECKING, Literal
+
+from classiq.interface.model.quantum_statement import QuantumOperation
+
+if TYPE_CHECKING:
+    from classiq.interface.model.statement_block import StatementBlock
+
+
+class Invert(QuantumOperation):
+    kind: Literal["Invert"]
+
+    body: "StatementBlock"