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

classiq/interface/generator/mcx.py

@@ -1,7 +1,9 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.function_params import FunctionParams
@@ -15,50 +17,57 @@ class Mcx(FunctionParams):
     multi-controlled x-gate
     """
 
-    arguments: List[RegisterUserInput] = pydantic.Field(
+    arguments: list[RegisterUserInput] = pydantic.Field(
         default_factory=list, description="registers describing the state (ordered)"
     )
     num_ctrl_qubits: Optional[pydantic.PositiveInt] = pydantic.Field(
-        description="number of control qubits"
+        description="number of control qubits",
+        default=None,
+    )
+    ctrl_state: str = pydantic.Field(
+        default="", description="control state string", validate_default=True
     )
-    ctrl_state: str = pydantic.Field(default="", description="control state string")
 
-    @pydantic.validator("arguments", always=True)
+    @pydantic.field_validator("arguments")
+    @classmethod
     def _validate_argument_names(
-        cls, arguments: List[RegisterUserInput]
-    ) -> List[RegisterUserInput]:
-        register_name_list: List[Optional[str]] = [arg.name for arg in arguments]
+        cls, arguments: list[RegisterUserInput]
+    ) -> list[RegisterUserInput]:
+        register_name_list: list[Optional[str]] = [arg.name for arg in arguments]
         if None in register_name_list:
-            raise ValueError("All registers must be named")
+            raise ClassiqValueError("All registers must be named")
         if len(set(register_name_list)) != len(register_name_list):
-            raise ValueError("Registers must have distinct names")
+            raise ClassiqValueError("Registers must have distinct names")
         return arguments
 
-    @pydantic.validator("num_ctrl_qubits", always=True)
-    def _validate_sizes(cls, num_ctrl_qubits: int, values: Dict[str, Any]) -> int:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_sizes(cls, values: dict[str, Any]) -> dict[str, Any]:
         arguments_size = sum(arg.size for arg in values.get("arguments", list()))
-
+        num_ctrl_qubits = values.get("num_ctrl_qubits")
         if not num_ctrl_qubits:
             num_ctrl_qubits = arguments_size - 1
 
         if num_ctrl_qubits < 1:
-            raise ValueError("Must have control qubits")
+            raise ClassiqValueError("Must have control qubits")
 
         if arguments_size == 0:
             ctrl_register = RegisterUserInput(size=num_ctrl_qubits, name=CTRL)
             target_register = RegisterUserInput(size=1, name=TARGET_QUBIT)
             values["arguments"] = [ctrl_register, target_register]
         elif num_ctrl_qubits != arguments_size - 1:
-            raise ValueError("Given sizes do not match")
-        return num_ctrl_qubits
+            raise ClassiqValueError("Given sizes do not match")
+        values["num_ctrl_qubits"] = num_ctrl_qubits
+        return values
 
-    @pydantic.validator("ctrl_state", always=True)
-    def _validate_ctrl_state(cls, ctrl_state: str, values: Dict[str, Any]) -> str:
-        num_ctrl_qubits = values.get("num_ctrl_qubits", -1)
+    @pydantic.field_validator("ctrl_state")
+    @classmethod
+    def _validate_ctrl_state(cls, ctrl_state: str, info: ValidationInfo) -> str:
+        num_ctrl_qubits = info.data.get("num_ctrl_qubits", -1)
         if not ctrl_state:
             return "1" * num_ctrl_qubits
         if len(ctrl_state) != num_ctrl_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 "control state length should be equal to the number of control qubits"
             )
         ControlState.validate_control_string(ctrl_state)

classiq/interface/generator/model/__init__.py

@@ -1,20 +1,17 @@
-from typing import List
-
 from classiq.interface.generator.model.constraints import (
     Constraints,
     OptimizationParameter,
     TranspilerBasisGates,
 )
-from classiq.interface.generator.model.model import SynthesisModel
 from classiq.interface.generator.model.preferences import (
     CustomHardwareSettings,
     Preferences,
 )
 
-__all__: List[str] = [
+__all__: list[str] = [
     "Constraints",
-    "Preferences",
     "CustomHardwareSettings",
     "OptimizationParameter",
+    "Preferences",
     "TranspilerBasisGates",
 ]

classiq/interface/generator/model/constraints.py

@@ -1,13 +1,13 @@
 from collections import defaultdict
-from typing import Dict, Optional, Union
+from typing import Optional, Union
 
 import pydantic
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel, ConfigDict
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.transpiler_basis_gates import TranspilerBasisGates
 
-from classiq._internals.enum_utils import StrEnum
-
 UNCONSTRAINED = -1
 
 
@@ -26,21 +26,40 @@ def optimization_parameter_type_from_string(param: str) -> OptimizationParameter
             return enum_(param)  # type: ignore[return-value]
         except ValueError:
             pass
-    raise ValueError(f"Invalid OptimizationParameterType {param}")
+    raise ClassiqValueError(f"Invalid OptimizationParameterType {param}")
 
 
-class Constraints(BaseModel, extra=Extra.forbid):
+class Constraints(BaseModel):
     """
-    Input constraints for the generated quantum circuit.
+    Constraints for the quantum circuit synthesis engine.
+
+    This class is used to specify constraints such as maximum width, depth,
+    gate count, and optimization parameters for the synthesis engine,
+    guiding the generation of quantum circuits that satisfy these constraints.
+
+    Attributes:
+        max_width (int):
+            Maximum number of qubits allowed in the generated quantum circuit.
+            Defaults to `None`.
+        max_depth (int):
+            Maximum depth of the generated quantum circuit. Defaults to `None`.
+        max_gate_count (Dict[TranspilerBasisGates, int]):
+            A dictionary specifying the maximum allowed count for each type of gate
+            in the quantum circuit. Defaults to an empty dictionary.
+        optimization_parameter (OptimizationParameterType):
+            Determines if and how the synthesis engine should optimize
+            the solution. Defaults to `NO_OPTIMIZATION`. See `OptimizationParameterType`
     """
 
+    model_config = ConfigDict(extra="forbid")
+
     max_width: Optional[pydantic.PositiveInt] = pydantic.Field(
         default=None,
         description="Maximum number of qubits in generated quantum circuit",
     )
     max_depth: Optional[pydantic.PositiveInt] = None
 
-    max_gate_count: Dict[TranspilerBasisGates, pydantic.NonNegativeInt] = (
+    max_gate_count: dict[TranspilerBasisGates, pydantic.NonNegativeInt] = (
         pydantic.Field(default_factory=lambda: defaultdict(int))
     )
 

classiq/interface/generator/model/model.py

@@ -1,81 +1,44 @@
 from abc import ABC
-from typing import Any, Dict, List, Literal, Mapping, NewType, Optional, Union
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.constant import Constant
-from classiq.interface.generator.function_params import IOName
-from classiq.interface.generator.functions import (
-    SynthesisNativeFunctionDefinition,
-    SynthesisPortDeclaration,
-    SynthesisQuantumFunctionDeclaration,
-)
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.generator.model.constraints import Constraints
-from classiq.interface.generator.model.preferences.preferences import Preferences
-from classiq.interface.generator.quantum_function_call import (
-    SUFFIX_RANDOMIZER,
-    SynthesisQuantumFunctionCall,
-    WireDict,
-    WireName,
-)
-from classiq.interface.generator.types.combinatorial_problem import (
-    CombinatorialOptimizationStructDeclaration,
-)
+from classiq.interface.generator.function_params import ArithmeticIODict
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.helpers.pydantic_model_helpers import (
-    get_discriminator_field,
-    nameables_to_dict,
-)
 from classiq.interface.helpers.validation_helpers import is_list_unique
 from classiq.interface.helpers.versioned_model import VersionedModel
-
-from classiq import ForeignFunctionDefinition as SynthesisForeignFunctionDefinition
-from classiq.exceptions import ClassiqValueError
-from classiq.quantum_register import QReg, QRegGenericAlias
-
-MAIN_FUNCTION_NAME = "main"
-CLASSICAL_ENTRY_FUNCTION_NAME = "cmain"
-
-DEFAULT_PORT_SIZE = 1
-
-
-SerializedModel = NewType("SerializedModel", str)
-
-ConcreteStructDeclaration = Union[
-    CombinatorialOptimizationStructDeclaration, StructDeclaration
-]
-
-# We need to define ConcreteFunctionData so pydantic will know
-# what class to use when deserializing from object (pydantic attempts to
-# parse as each of the classes in the Union, in order).
-ConcreteFunctionDefinition = Union[
-    SynthesisForeignFunctionDefinition, SynthesisNativeFunctionDefinition
-]
+from classiq.interface.model.quantum_type import RegisterQuantumTypeDict
 
 TYPE_LIBRARY_DUPLICATED_TYPE_NAMES = (
     "Cannot have multiple struct types with the same name"
 )
 
 
-def _create_default_functions() -> List[ConcreteFunctionDefinition]:
-    return [SynthesisNativeFunctionDefinition(name=MAIN_FUNCTION_NAME)]
-
-
 class ClassiqBaseModel(VersionedModel, ABC):
     """
     All the relevant data for evaluating execution in one place.
     """
 
-    types: List[ConcreteStructDeclaration] = pydantic.Field(
+    enums: list[EnumDeclaration] = pydantic.Field(
+        default_factory=list,
+        description="user-defined enums",
+    )
+
+    types: list[StructDeclaration] = pydantic.Field(
         default_factory=list,
-        description="The user-defined custom function library.",
+        description="user-defined structs",
     )
 
-    constants: List[Constant] = pydantic.Field(
+    qstructs: list[QStructDeclaration] = pydantic.Field(
+        default_factory=list,
+        description="user-defined quantum structs",
+    )
+
+    constants: list[Constant] = pydantic.Field(
         default_factory=list,
     )
 
@@ -87,158 +50,24 @@ class ClassiqBaseModel(VersionedModel, ABC):
         default_factory=ExecutionPreferences
     )
 
-    @pydantic.validator("types")
-    def types_validator(
-        cls, types: List[ConcreteStructDeclaration]
-    ) -> List[ConcreteStructDeclaration]:
+    @pydantic.field_validator("types")
+    @classmethod
+    def types_validator(cls, types: list[StructDeclaration]) -> list[StructDeclaration]:
         if not is_list_unique([struct_type.name for struct_type in types]):
-            raise ValueError(TYPE_LIBRARY_DUPLICATED_TYPE_NAMES)
+            raise ClassiqValueError(TYPE_LIBRARY_DUPLICATED_TYPE_NAMES)
 
         return types
 
 
 class ExecutionModel(ClassiqBaseModel):
-    pass
-
-
-class SynthesisModel(ClassiqBaseModel):
-    """
-    All the relevant data for generating quantum circuit in one place.
-    """
-
-    kind: Literal["synthesis"] = get_discriminator_field("synthesis")
-
-    # Must be validated before logic_flow
-    functions: List[ConcreteFunctionDefinition] = pydantic.Field(
-        default_factory=_create_default_functions,
-        description="The quantum functions of the model.",
+    circuit_outputs: ArithmeticIODict = pydantic.Field(
+        description="Mapping between a measured register name and its arithmetic type",
+        default_factory=dict,
+    )
+    circuit_output_types: RegisterQuantumTypeDict = pydantic.Field(
+        description="Mapping between a measured register name and its qmod type",
+        default=dict(),
+    )
+    register_filter_bitstrings: dict[str, list[str]] = pydantic.Field(
+        default_factory=dict,
     )
-
-    constraints: Constraints = pydantic.Field(default_factory=Constraints)
-    preferences: Preferences = pydantic.Field(default_factory=Preferences)
-
-    def __init__(
-        self,
-        *,
-        body: Optional[List[SynthesisQuantumFunctionCall]] = None,
-        inputs: Optional[WireDict] = None,
-        outputs: Optional[WireDict] = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(**kwargs)
-        if body:
-            self.main_func.body.extend(body)
-        if inputs:
-            self.set_inputs(
-                {
-                    name: QRegGenericAlias(
-                        QReg(DEFAULT_PORT_SIZE), (DEFAULT_PORT_SIZE, 0)
-                    )
-                    for name in inputs.keys()
-                },
-                inputs,
-            )
-        if outputs:
-            self.set_outputs(
-                {name: QReg(DEFAULT_PORT_SIZE) for name in outputs.keys()}, outputs
-            )
-
-    @property
-    def main_func(self) -> SynthesisNativeFunctionDefinition:
-        return self.function_dict[MAIN_FUNCTION_NAME]  # type:ignore[return-value]
-
-    @property
-    def body(self) -> List[SynthesisQuantumFunctionCall]:
-        return self.main_func.body
-
-    @property
-    def inputs(self) -> WireDict:
-        return self.main_func.input_ports_wiring
-
-    def set_inputs(
-        self,
-        inputs: Mapping[IOName, QRegGenericAlias],
-        input_wiring: Mapping[IOName, WireName],
-    ) -> None:
-        self._update_main_declarations(inputs, PortDeclarationDirection.Input)
-        self.main_func.input_ports_wiring.update(input_wiring)
-
-    @property
-    def outputs(self) -> WireDict:
-        return self.main_func.output_ports_wiring
-
-    def set_outputs(
-        self, outputs: Mapping[IOName, QReg], output_wiring: Mapping[IOName, WireName]
-    ) -> None:
-        self._update_main_declarations(outputs, PortDeclarationDirection.Output)
-        self.main_func.output_ports_wiring.update(output_wiring)
-
-    @pydantic.validator("preferences", always=True)
-    def _seed_suffix_randomizer(cls, preferences: Preferences) -> Preferences:
-        SUFFIX_RANDOMIZER.seed(preferences.random_seed)
-        return preferences
-
-    def _get_qualified_direction(
-        self, port_name: str, direction: PortDeclarationDirection
-    ) -> PortDeclarationDirection:
-        if port_name in self.main_func.port_declarations:
-            return PortDeclarationDirection.Inout
-        return direction
-
-    def _update_main_declarations(
-        self,
-        value: Union[Mapping[IOName, QReg], Mapping[IOName, QRegGenericAlias]],
-        direction: PortDeclarationDirection,
-    ) -> None:
-        for port_name, register in value.items():
-            if isinstance(register, QReg):
-                size = len(register)
-                is_signed = getattr(register, "is_signed", False) or False
-                fraction_places = getattr(register, "fraction_places", 0) or 0
-            else:
-                size = register.size if register.size is not None else DEFAULT_PORT_SIZE
-                is_signed = False
-                fraction_places = (
-                    register.fraction_places
-                    if register.fraction_places is not None
-                    else 0
-                )
-
-            self.main_func.port_declarations[port_name] = SynthesisPortDeclaration(
-                name=port_name,
-                size=size,
-                direction=self._get_qualified_direction(port_name, direction),
-                is_signed=is_signed,
-                fraction_places=fraction_places,
-            )
-
-    @property
-    def function_dict(self) -> Dict[str, SynthesisQuantumFunctionDeclaration]:
-        return nameables_to_dict(self.functions)
-
-    @pydantic.validator("functions", each_item=True)
-    def validate_static_correctness(
-        cls, func_def: ConcreteFunctionDefinition
-    ) -> ConcreteFunctionDefinition:
-        if isinstance(func_def, SynthesisNativeFunctionDefinition):
-            func_def.validate_body()
-        return func_def
-
-    @pydantic.validator("functions")
-    def validate_main_function_exists(
-        cls, func_defs: List[ConcreteFunctionDefinition]
-    ) -> List[ConcreteFunctionDefinition]:
-        if MAIN_FUNCTION_NAME not in {func.name for func in func_defs}:
-            raise ClassiqValueError("The model must contain a `main` function")
-        return func_defs
-
-    def get_model(self) -> SerializedModel:
-        return SerializedModel(self.json(exclude_defaults=True, indent=2))
-
-    def classical_model(self) -> ExecutionModel:
-        return ExecutionModel(
-            types=self.types,
-            constants=self.constants,
-            classical_execution_code=self.classical_execution_code,
-            execution_preferences=self.execution_preferences,
-        )