classiq 0.84.0__py3-none-any.whl → 0.86.0__py3-none-any.whl

classiq/interface/generator/generated_circuit_data.py

@@ -52,8 +52,6 @@ VISUALIZATION_HIDE_LIST = [
     "stmt_block",
 ]
 
-CONTROLLED_PREFIX = "c_"
-
 
 def last_name_in_call_hierarchy(name: str) -> str:
     return name.split(CLASSIQ_HIERARCHY_SEPARATOR)[-1]
@@ -147,6 +145,8 @@ class StatementType(StrEnum):
     INPLACE_XOR = "inplace xor"
     INPLACE_ADD = "inplace add"
     REPEAT = "repeat"
+    BLOCK = "block"
+    IF = "if"
 
 
 # Mapping between statement kind (or sub-kind) and statement type (visualization name)
@@ -167,6 +167,8 @@ STATEMENTS_NAME: dict[str, StatementType] = {
     ArithmeticOperationKind.InplaceXor.value: StatementType.INPLACE_XOR,
     ArithmeticOperationKind.InplaceAdd.value: StatementType.INPLACE_ADD,
     "Repeat": StatementType.REPEAT,
+    "Block": StatementType.BLOCK,
+    "ClassicalIf": StatementType.IF,
 }
 
 
@@ -207,8 +209,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
                 ARITH_ENGINE_PREFIX
             )
             name_with_suffix = self.add_suffix_from_generated_name(generated_name, name)
-            modified_name = self.modify_name_for_controlled_qfunc(name_with_suffix)
-            return modified_name
+            return name_with_suffix
 
         statement_kind: str = back_ref.kind
         if isinstance(back_ref, ArithmeticOperation):
@@ -217,11 +218,6 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             generated_name, STATEMENTS_NAME[statement_kind]
         )
 
-    def modify_name_for_controlled_qfunc(self, generated_name: str) -> str:
-        if self.control_variable is None:
-            return generated_name
-        return f"{CONTROLLED_PREFIX}{generated_name}"
-
     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)}]"
@@ -272,7 +268,8 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
             for register in self.registers
             for qubit in register.qubit_indexes_absolute
             if register.role is RegisterRole.INPUT
-            and register.name == self.control_variable
+            and self.port_to_passed_variable_map.get(register.name, register.name)
+            == self.control_variable
         )
 
     def propagate_absolute_qubits(self) -> "FunctionDebugInfoInterface":

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

@@ -0,0 +1,45 @@
+from typing import Any
+
+from classiq.interface.ide.visual_model import Operation
+
+
+class OperationRegistry:
+    def __init__(self) -> None:
+        self._operation_hash_to_op_id: dict[int, int] = {}
+        self._id_to_operations: dict[int, Operation] = {}
+        self._unique_op_counter = 0
+        self._deduped_op_counter = 0
+
+    def build_operation(self, **kwargs: Any) -> Operation:
+        operation = Operation(**kwargs)
+        return self._add_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.
+        """
+        op_hash = hash(op)
+        if op_hash not in self._operation_hash_to_op_id:
+            self._operation_hash_to_op_id[op_hash] = op.id
+            self._id_to_operations[op.id] = op
+            self._unique_op_counter += 1
+        else:
+            self._deduped_op_counter += 1
+            op = self._id_to_operations[self._operation_hash_to_op_id[op_hash]]
+        return op
+
+    def get_operation_mapping(self) -> dict[int, Operation]:
+        return self._id_to_operations
+
+    def get_operations(self, op_ids: list[int]) -> list[Operation]:
+        """
+        Returns a list of operations based on their IDs.
+        """
+        return [self._id_to_operations[op_id] for op_id in op_ids]
+
+    def get_unique_op_number(self) -> int:
+        return self._unique_op_counter
+
+    def get_deduped_op_number(self) -> int:
+        return self._deduped_op_counter

classiq/interface/ide/visual_model.py

@@ -1,9 +1,12 @@
+import json
 from collections import Counter
+from collections.abc import Iterator
 from functools import cached_property
+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 (
@@ -13,6 +16,26 @@ from classiq.interface.generator.hardware.hardware_data import SynthesisHardware
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 
+class OperationIdCounter:
+    _op_id_counter: Iterator[int] = count()
+
+    def next_id(self) -> int:
+        return next(self._op_id_counter)
+
+    def reset_operation_counter(self) -> None:
+        self._op_id_counter = count()
+
+
+_operation_id_counter = OperationIdCounter()
+
+
+def reset_operation_counter() -> None:
+    """
+    Call this at the start of every new task to restart ids at 0.
+    """
+    _operation_id_counter.reset_operation_counter()
+
+
 class OperationType(StrEnum):
     REGULAR = "REGULAR"
     INVISIBLE = "INVISIBLE"
@@ -27,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
@@ -60,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)
@@ -108,6 +148,8 @@ 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="")
     children: list["Operation"] = pydantic.Field(default_factory=list)
@@ -120,7 +162,7 @@ class Operation(pydantic.BaseModel):
     target_qubits: tuple[int, ...]
     operation_level: OperationLevel
     operation_type: OperationType = pydantic.Field(
-        description="Identifies unique operations that are visualized differently"
+        description="Identifies unique operations that are visualized differently",
     )
     gate: AtomicGate = pydantic.Field(
         default=AtomicGate.UNKNOWN, description="Gate type"
@@ -128,6 +170,40 @@ 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:
+        return self._id
+
+    def __hash__(self) -> int:
+        """
+        using a custom hashable_dict in order to compare the operation
+        with the qubits in order
+        """
+        js = json.dumps(
+            self._hashable_dict(),
+            sort_keys=True,
+            default=lambda o: o.value if hasattr(o, "value") else str(o),
+        )
+        return hash(js)
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, Operation)
+            and self._hashable_dict() == other._hashable_dict()
+        )
+
+    def _hashable_dict(self) -> dict:
+        data = self.model_dump(
+            exclude_none=True,
+        )
+        # force qubit order for equality
+        for key in ("target_qubits", "auxiliary_qubits", "control_qubits"):
+            data[key] = sorted(data[key])
+        return data
 
 
 class ProgramVisualModel(VersionedModel):
@@ -135,3 +211,9 @@ class ProgramVisualModel(VersionedModel):
     id_to_operations: dict[int, Operation] = pydantic.Field(default_factory=dict)
     main_operation_id: int = pydantic.Field(default=None)
     program_data: ProgramData
+
+    @property
+    def main_op_from_mapping(self) -> Operation:
+        if self.main_operation_id is None:
+            raise ValueError("Main operation ID is not set.")
+        return self.id_to_operations[self.main_operation_id]

classiq/interface/model/bounds.py

@@ -1,6 +1,6 @@
 from typing import Literal, Optional
 
-from classiq.interface.helpers.custom_pydantic_types import PydanticFloatTuple
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.handle_binding import ConcreteHandleBinding
 from classiq.interface.model.quantum_statement import QuantumOperation
 
@@ -9,4 +9,14 @@ class SetBoundsStatement(QuantumOperation):
     kind: Literal["SetBoundsStatement"]
 
     target: ConcreteHandleBinding
-    bounds: Optional[PydanticFloatTuple]
+    lower_bound: Optional[Expression]
+    upper_bound: Optional[Expression]
+
+    @property
+    def expressions(self) -> list[Expression]:
+        exprs = []
+        if self.lower_bound is not None:
+            exprs.append(self.lower_bound)
+        if self.upper_bound is not None:
+            exprs.append(self.upper_bound)
+        return exprs

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,6 +1,8 @@
 from collections.abc import Mapping, Sequence
 from typing import Literal
 
+from pydantic import PrivateAttr
+
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
     ARITHMETIC_EXPRESSION_RESULT_NAME,
@@ -27,6 +29,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
     kind: Literal["ArithmeticOperation"]
 
     operation_kind: ArithmeticOperationKind
+    _classical_assignment: bool = PrivateAttr(default=False)
 
     @property
     def is_inplace(self) -> bool:
@@ -50,7 +53,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
         self,
     ) -> Mapping[str, ConcreteHandleBinding]:
         inouts = dict(super().wiring_inouts)
-        if self.is_inplace:
+        if self.is_inplace and not self._classical_assignment:
             inouts[self.result_name()] = self.result_var
         return inouts
 
@@ -60,7 +63,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
             HandleMetadata(handle=handle, readable_location="in an expression")
             for handle in self.var_handles
         ]
-        if self.is_inplace:
+        if self.is_inplace and not self._classical_assignment:
             inouts.append(
                 HandleMetadata(
                     handle=self.result_var,
@@ -71,13 +74,13 @@ class ArithmeticOperation(QuantumAssignmentOperation):
 
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        if self.is_inplace:
+        if self.is_inplace or self._classical_assignment:
             return {}
         return super().wiring_outputs
 
     @property
     def readable_outputs(self) -> Sequence[HandleMetadata]:
-        if self.is_inplace:
+        if self.is_inplace or self._classical_assignment:
             return []
         return [
             HandleMetadata(

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/interface/model/variable_declaration_statement.py

@@ -1,15 +1,42 @@
-from typing import Literal
+from typing import Any, Literal, Optional
+
+import pydantic
 
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.quantum_statement import QuantumStatement
-from classiq.interface.model.quantum_variable_declaration import (
-    QuantumVariableDeclaration,
+from classiq.interface.generator.functions.concrete_types import (
+    ConcreteQuantumType,
+    ConcreteType,
 )
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.quantum_type import QuantumType
 
 
-class VariableDeclarationStatement(QuantumStatement, QuantumVariableDeclaration):
+class VariableDeclarationStatement(QuantumStatement):
     kind: Literal["VariableDeclarationStatement"]
 
+    name: str
+    quantum_type: Optional[ConcreteQuantumType] = None
+    qmod_type: ConcreteType
+
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_qmod_type(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            if "quantum_type" in values and (
+                "qmod_type" not in values or values["qmod_type"] is None
+            ):
+                values["qmod_type"] = values["quantum_type"]
+                values["quantum_type"] = None
+            return values
+        if values.quantum_type is not None and values.qmod_type is None:
+            values.qmod_type = values.quantum_type
+            values.quantum_type = None
+        return values
+
     @property
     def expressions(self) -> list[Expression]:
-        return self.quantum_type.expressions
+        return self.qmod_type.expressions
+
+    @property
+    def is_quantum(self) -> bool:
+        return isinstance(self.qmod_type, QuantumType)

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)