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

classiq/interface/executor/estimate_cost.py

@@ -0,0 +1,35 @@
+from typing import Callable
+
+import numpy as np
+
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.executor.result import ParsedCounts, ParsedState
+
+
+def estimate_cost(
+    cost_func: Callable[[ParsedState], float],
+    parsed_counts: ParsedCounts,
+    quantile: float = 1.0,
+) -> float:
+    if quantile < 0 or quantile > 1:
+        raise ClassiqValueError("'quantile' must be between 0 and 1")
+    costs = np.fromiter((cost_func(sample.state) for sample in parsed_counts), float)
+    shots = np.fromiter((sample.shots for sample in parsed_counts), int)
+
+    if quantile == 1:
+        return float(np.average(costs, weights=shots))
+    return float(estimate_quantile_cost(costs, shots, quantile=quantile))
+
+
+def estimate_quantile_cost(
+    costs: np.ndarray,
+    shots: np.ndarray,
+    quantile: float,
+) -> np.floating:
+    repeated_costs = np.repeat(costs, shots)
+    sort_idx = repeated_costs.argsort()
+    cutoff_idx = sort_idx[: int(quantile * len(repeated_costs))]
+    sorted_costs = repeated_costs[cutoff_idx]
+    if sorted_costs.size == 0:
+        sorted_costs = repeated_costs[sort_idx[0]]
+    return np.average(sorted_costs)

classiq/interface/executor/execution_result.py

@@ -25,6 +25,7 @@ class SavedResultValueType(StrEnum):
     EstimationResult = "EstimationResult"
     EstimationResults = "EstimationResults"
     IQAEResult = "IQAEResult"
+    MinimizeResult = "MinimizeResult"
     Unstructured = "Unstructured"
 
 
@@ -88,6 +89,17 @@ class TaggedUnstructured(BaseModel):
     value: Any = None
 
 
+class SingleMinimizeResult(BaseModel):
+    expectation_value: float
+    parameters: list[float]
+
+
+class TaggedMinimizeResult(BaseModel):
+    value_type: Literal[SavedResultValueType.MinimizeResult]
+    name: str
+    value: list[SingleMinimizeResult]
+
+
 SavedResult = Annotated[
     Union[
         TaggedInteger,
@@ -100,6 +112,7 @@ SavedResult = Annotated[
         TaggedEstimationResults,
         TaggedIQAEResult,
         TaggedUnstructured,
+        TaggedMinimizeResult,
     ],
     Field(..., discriminator="value_type"),
 ]

classiq/interface/executor/result.py

@@ -10,11 +10,16 @@ from typing import (
     Union,
 )
 
+import pandas as pd
 import pydantic
 from pydantic import BaseModel
 from typing_extensions import Self, TypeAlias
 
-from classiq.interface.exceptions import ClassiqError
+from classiq.interface.exceptions import (
+    ClassiqError,
+    ClassiqInternalError,
+    ClassiqValueError,
+)
 from classiq.interface.executor.quantum_code import OutputQubitsMap, Qubits
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.complex_type import Complex
@@ -22,6 +27,7 @@ from classiq.interface.generator.functions.classical_type import QmodPyObject
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
 from classiq.interface.helpers.datastructures import get_sdk_compatible_python_object
 from classiq.interface.helpers.versioned_model import VersionedModel
+from classiq.interface.model.quantum_type import RegisterQuantumTypeDict
 
 _ILLEGAL_QUBIT_ERROR_MSG: str = "Illegal qubit index requested"
 _REPEATED_QUBIT_ERROR_MSG: str = "Requested a qubit more than once"
@@ -36,6 +42,11 @@ ParsedStates: TypeAlias = Mapping[State, ParsedState]
 Counts: TypeAlias = dict[State, MeasuredShots]
 StateVector: TypeAlias = Optional[dict[str, Complex]]
 
+BITSTRING = "bitstring"
+PROBABILITY = "probability"
+AMPLITUDE = "amplitude"
+COUNT = "count"
+
 if TYPE_CHECKING:
     DotAccessParsedState = Mapping[Name, Any]
 else:
@@ -150,6 +161,36 @@ def prepare_parsed_state_vector(
     return sorted(parsed_state_vector, key=lambda k: abs(k.amplitude), reverse=True)
 
 
+def _flatten_columns(df: pd.DataFrame, columns_to_flatten: list[str]) -> pd.DataFrame:
+    if len(df.columns) == 0:
+        return df
+
+    flattened_data = {}
+
+    for col in columns_to_flatten:
+        if col not in df.columns:
+            continue
+
+        flat_df = pd.json_normalize(df[col]).add_prefix(f"{col}.")
+        flat_df.index = df.index
+        flattened_data[col] = flat_df
+
+    new_df_columns = []
+    dfs_to_concat = []
+
+    for col_name in df.columns:
+        if col_name in flattened_data:
+            new_df_columns.extend(flattened_data[col_name].columns)
+            dfs_to_concat.append(flattened_data[col_name])
+        elif col_name not in columns_to_flatten:
+            new_df_columns.append(col_name)
+            dfs_to_concat.append(df[[col_name]])
+
+    final_df = pd.concat(dfs_to_concat, axis=1)
+    valid_final_columns = [c for c in new_df_columns if c in final_df.columns]
+    return final_df[valid_final_columns]
+
+
 class ExecutionDetails(BaseModel, QmodPyObject):
     vendor_format_result: dict[str, Any] = pydantic.Field(
         ..., description="Result in proprietary vendor format"
@@ -192,6 +233,8 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         default=None, description="The total number of shots the circuit was executed"
     )
 
+    output_type_map: RegisterQuantumTypeDict = pydantic.Field(default_factory=dict)
+
     @pydantic.field_validator("counts", mode="after")
     @classmethod
     def _clean_spaces_from_counts_keys(cls, v: Counts) -> Counts:
@@ -302,6 +345,78 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         )[::-1]
         return number_utils.binary_to_float_or_int(bin_rep=register_binary_string)
 
+    def _counts_df(self) -> pd.DataFrame:
+        data: dict[str, Any] = defaultdict(list)
+
+        for bitstring, count in self.counts.items():
+            data[BITSTRING].append(bitstring)
+            data[COUNT].append(count)
+            if self.probabilities:
+                data[PROBABILITY].append(self.probabilities[bitstring])
+            elif self.num_shots:
+                data[PROBABILITY].append(count / self.num_shots)
+
+            for name, value in self.parsed_states[bitstring].items():
+                data[name].append(value)
+
+        final_columns = [COUNT, PROBABILITY, BITSTRING]
+        columns = [
+            col for col in data.keys() if col not in final_columns
+        ] + final_columns
+
+        return pd.DataFrame(data, columns=columns)
+
+    def _state_vector_df(self) -> pd.DataFrame:
+        data: dict[str, Any] = defaultdict(list)
+
+        if not self.state_vector:
+            raise ClassiqInternalError("No state vector")
+        if not self.parsed_state_vector_states:
+            raise ClassiqInternalError("No parsed state vector states")
+
+        for bitstring, amplitude in self.state_vector.items():
+            data[BITSTRING].append(bitstring)
+            data[AMPLITUDE].append(amplitude)
+            data[PROBABILITY].append(abs(amplitude) ** 2)
+            for name, value in self.parsed_state_vector_states[bitstring].items():
+                data[name].append(value)
+
+        final_columns = [AMPLITUDE, PROBABILITY, BITSTRING]
+        columns = [
+            col for col in data.keys() if col not in final_columns
+        ] + final_columns
+
+        return pd.DataFrame(data, columns=columns)
+
+    @functools.cached_property
+    def dataframe(self) -> pd.DataFrame:
+        reserved_words = frozenset([BITSTRING, PROBABILITY, COUNT, AMPLITUDE])
+        _invalid_output_names = reserved_words.intersection(
+            self.output_qubits_map.keys()
+        )
+        if _invalid_output_names:
+            raise ClassiqValueError(f"Invalid output names: {_invalid_output_names}")
+
+        if self.state_vector:
+            df = self._state_vector_df()
+        else:
+            df = self._counts_df()
+
+        df.sort_values(
+            by=[AMPLITUDE if self.state_vector else COUNT, BITSTRING],
+            inplace=True,
+            ascending=[False, True],
+            ignore_index=True,
+        )
+
+        outputs_to_flatten = [
+            output
+            for output, type in self.output_type_map.items()
+            if type.quantum_types.kind == "struct_instance"
+        ]
+        df = _flatten_columns(df, outputs_to_flatten)
+        return df
+
 
 class MultipleExecutionDetails(VersionedModel):
     details: list[ExecutionDetails]

classiq/interface/executor/user_budget.py

@@ -1,9 +1,9 @@
 import datetime
-from collections import defaultdict
 from typing import Optional
 
 import pydantic
 from pydantic import ConfigDict, Field
+from tabulate import tabulate
 
 from classiq.interface.helpers.versioned_model import VersionedModel
 
@@ -15,6 +15,7 @@ class UserBudget(VersionedModel):
     available_budget: float
     used_budget: float
     last_allocation_date: datetime.datetime
+    budget_limit: Optional[float] = Field(default=None)
 
     model_config = ConfigDict(extra="ignore")
 
@@ -22,35 +23,27 @@ class UserBudget(VersionedModel):
 class UserBudgets(VersionedModel):
     budgets: list[UserBudget] = pydantic.Field(default=[])
 
-    def print_budgets(self) -> None:
-        def format_header() -> str:
-            return f"| {'Provider':<20} | {'Available Budget':<18} | {'Used Budget':<18} | {'Currency':<8} |"
-
-        def format_row(
-            provider: str, available: float, used: float, currency: str
-        ) -> str:
-            return f"| {provider:<20} | {available:<18.3f} | {used:<18.3f} | {currency:<8} |"
-
-        table_data: dict = defaultdict(
-            lambda: {"used": 0.0, "available": 0.0, "currency": "USD"}
-        )
-
-        for budget in self.budgets:
-            provider = budget.provider
-            table_data[provider]["available"] += budget.available_budget
-            table_data[provider]["used"] += budget.used_budget
-            table_data[provider]["currency"] = budget.currency_code
-
-        line = "=" * 77
-        print(line)  # noqa: T201
-        print(format_header())  # noqa: T201
-        print(line)  # noqa: T201
-
-        for provider, values in table_data.items():
-            print(  # noqa: T201
-                format_row(
-                    provider, values["available"], values["used"], values["currency"]
-                )
-            )
-
-        print(line)  # noqa: T201
+    def __str__(self) -> str:
+        rows = [
+            [
+                budget.provider,
+                f"{budget.used_budget:.3f}",
+                f"{budget.available_budget:.3f}",
+                (
+                    f"{budget.budget_limit:.3f}"
+                    if budget.budget_limit is not None
+                    else "NOT SET"
+                ),
+                budget.currency_code,
+            ]
+            for budget in self.budgets
+        ]
+
+        headers = [
+            "Provider",
+            "Used Budget",
+            "Remaining Budget",
+            "Budget Limit",
+            "Currency",
+        ]
+        return tabulate(rows, headers=headers, tablefmt="grid")

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -20,10 +20,14 @@ CLASSIQ_EXPR_FUNCTIONS = {
     "get_field",
 }
 
+MEASUREMENT_FUNCTIONS = {
+    "measure",
+}
+
 SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
     *CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS,
     *CLASSIQ_EXPR_FUNCTIONS,
-    "mod_inverse",
+    *MEASUREMENT_FUNCTIONS,
 }
 
 SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
@@ -34,6 +38,11 @@ SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
     "LogicalXor",
     "RShift",
     "LShift",
+    "mod_inverse",
+    "min",
+    "Min",
+    "max",
+    "Max",
 }
 
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {

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

@@ -21,12 +21,6 @@ def subscript_to_str(index: Any) -> str:
 
 
 class AnyClassicalValue(sympy.Symbol):
-
-    is_commutative = None
-    is_infinite = None
-    is_finite = None
-    is_extended_real = None
-
     def __getitem__(self, item: Any) -> "AnyClassicalValue":
         if isinstance(item, slice):
             return AnyClassicalValue(f"{self}[{subscript_to_str(item)}]")

classiq/interface/generator/functions/builtins/internal_operators.py

@@ -6,6 +6,7 @@ CLASSICAL_IF_OPERATOR_NAME = "classical_if"
 POWER_OPERATOR_NAME = "power"
 UNCOMPUTE_OPERATOR_NAME = "uncompute"
 WITHIN_APPLY_NAME = "within_apply"
+BLOCK_OPERATOR_NAME = "block"
 
 All_BUILTINS_OPERATORS = {
     CONTROL_OPERATOR_NAME,
@@ -14,4 +15,5 @@ All_BUILTINS_OPERATORS = {
     POWER_OPERATOR_NAME,
     UNCOMPUTE_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
+    BLOCK_OPERATOR_NAME,
 }

classiq/interface/generator/functions/classical_type.py

@@ -98,39 +98,6 @@ class Bool(ClassicalType):
         return values_with_discriminator(values, "kind", "bool")
 
 
-class ClassicalList(ClassicalType):
-    kind: Literal["list"]
-    element_type: "ConcreteClassicalType"
-
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _set_kind(cls, values: Any) -> dict[str, Any]:
-        return values_with_discriminator(values, "kind", "list")
-
-    def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
-        return ClassicalArrayProxy(
-            handle, self.element_type, AnyClassicalValue(f"get_field({handle}, 'len')")
-        )
-
-    @property
-    def expressions(self) -> list[Expression]:
-        return self.element_type.expressions
-
-    @property
-    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 = ClassicalArray(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"]
 
@@ -146,8 +113,8 @@ class StructMetaType(ClassicalType):
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
-    size: Optional[int] = None
-    length: Optional[Expression] = pydantic.Field(exclude=True, default=None)
+    size: Optional[int] = pydantic.Field(exclude=True, default=None)
+    length: Optional[Expression] = None
 
     @pydantic.model_validator(mode="before")
     @classmethod

classiq/interface/generator/functions/concrete_types.py

@@ -5,7 +5,6 @@ from pydantic import Field
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
-    ClassicalList,
     ClassicalTuple,
     Estimation,
     Histogram,
@@ -29,7 +28,6 @@ ConcreteClassicalType = Annotated[
         Integer,
         Real,
         Bool,
-        ClassicalList,
         StructMetaType,
         TypeName,
         ClassicalArray,
@@ -41,7 +39,6 @@ ConcreteClassicalType = Annotated[
     ],
     Field(discriminator="kind"),
 ]
-ClassicalList.model_rebuild()
 ClassicalArray.model_rebuild()
 ClassicalTuple.model_rebuild()
 
@@ -56,3 +53,23 @@ QuantumBitvector.model_rebuild()
 TypeName.model_rebuild()
 QStructDeclaration.model_rebuild()
 RegisterQuantumType.model_rebuild()
+
+ConcreteType = Annotated[
+    Union[
+        Integer,
+        Real,
+        Bool,
+        StructMetaType,
+        TypeName,
+        ClassicalArray,
+        ClassicalTuple,
+        VQEResult,
+        Histogram,
+        Estimation,
+        IQAERes,
+        QuantumBit,
+        QuantumBitvector,
+        QuantumNumeric,
+    ],
+    Field(discriminator="kind"),
+]

classiq/interface/generator/functions/type_modifier.py

@@ -2,25 +2,6 @@ from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 
 
-class TypeQualifier(StrEnum):
-    Const = "const"
-    QFree = "qfree"
-    Quantum = "quantum"
-    Inferred = "inferred"
-
-    def to_modifier(self) -> "TypeModifier":
-        if self is TypeQualifier.Const:
-            return TypeModifier.Const
-        elif self is TypeQualifier.QFree:
-            return TypeModifier.Permutable
-        elif self is TypeQualifier.Quantum:
-            return TypeModifier.Mutable
-        elif self is TypeQualifier.Inferred:
-            return TypeModifier.Inferred
-        else:
-            raise ClassiqInternalExpansionError(f"Unexpected type qualifier: {self}")
-
-
 class TypeModifier(StrEnum):
     Const = "const"
     Permutable = "permutable"

classiq/interface/generator/generated_circuit_data.py

@@ -28,8 +28,6 @@ from classiq.interface.model.statement_block import (
 )
 
 from classiq.model_expansions.capturing.mangling_utils import (
-    demangle_capture_name,
-    demangle_name,
     is_captured_var_name,
 )
 
@@ -54,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]
@@ -85,12 +81,6 @@ class GeneratedRegister(pydantic.BaseModel):
     def is_captured(self) -> bool:
         return is_captured_var_name(self.name)
 
-    @staticmethod
-    def demangle_name(name: str) -> str:
-        if is_captured_var_name(name):
-            name = demangle_capture_name(name)
-        return demangle_name(name)
-
 
 class GeneratedFunction(pydantic.BaseModel):
     name: str
@@ -155,6 +145,7 @@ class StatementType(StrEnum):
     INPLACE_XOR = "inplace xor"
     INPLACE_ADD = "inplace add"
     REPEAT = "repeat"
+    BLOCK = "block"
 
 
 # Mapping between statement kind (or sub-kind) and statement type (visualization name)
@@ -175,6 +166,7 @@ STATEMENTS_NAME: dict[str, StatementType] = {
     ArithmeticOperationKind.InplaceXor.value: StatementType.INPLACE_XOR,
     ArithmeticOperationKind.InplaceAdd.value: StatementType.INPLACE_ADD,
     "Repeat": StatementType.REPEAT,
+    "Block": StatementType.BLOCK,
 }
 
 
@@ -215,8 +207,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):
@@ -225,11 +216,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)}]"
@@ -280,7 +266,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/types/compilation_metadata.py

@@ -6,9 +6,6 @@ class CompilationMetadata(BaseModel):
     occurrences_number: NonNegativeInt = Field(default=1)
     _occupation_number: NonNegativeInt = PrivateAttr(default=0)
     unchecked: list[str] = Field(default_factory=list)
-    atomic_qualifiers: list[str] = Field(
-        default_factory=list, exclude=True
-    )  # TODO remove after deprecation https://classiq.atlassian.net/browse/CLS-2671
 
     @property
     def occupation_number(self) -> NonNegativeInt:

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