classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/interface/generator/hamiltonian_evolution/suzuki_trotter.py

@@ -1,13 +1,13 @@
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.chemistry import operator
 from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.function_params import FunctionParamsNumericParameter
 from classiq.interface.generator.hamiltonian_evolution.hamiltonian_evolution import (
     HamiltonianEvolution,
 )
-from classiq.interface.generator.parameters import ParameterFloatType
-
-from classiq.exceptions import ClassiqValueError
 
 
 class SuzukiParameters(pydantic.BaseModel):
@@ -19,7 +19,8 @@ class SuzukiParameters(pydantic.BaseModel):
         default=1, description="The number of repetitions in the Suzuki-Trotter"
     )
 
-    @pydantic.validator("order")
+    @pydantic.field_validator("order")
+    @classmethod
     def _validate_order(cls, order: int) -> int:
         if order != 1 and order % 2:
             raise ClassiqValueError(
@@ -27,8 +28,7 @@ class SuzukiParameters(pydantic.BaseModel):
             )
         return order
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class SuzukiTrotter(HamiltonianEvolution):
@@ -36,10 +36,9 @@ class SuzukiTrotter(HamiltonianEvolution):
     Suzuki trotterization of a Hermitian operator
     """
 
-    evolution_coefficient: ParameterFloatType = pydantic.Field(
+    evolution_coefficient: FunctionParamsNumericParameter = pydantic.Field(
         default=1.0,
         description="A global coefficient multiplying the operator.",
-        is_exec_param=True,
     )
     suzuki_parameters: SuzukiParameters = pydantic.Field(
         default_factory=SuzukiParameters, description="The Suziki parameters."
@@ -48,7 +47,8 @@ class SuzukiTrotter(HamiltonianEvolution):
         default=False, description="Whether to disable the reordering of Pauli terms."
     )
 
-    @pydantic.validator("pauli_operator")
+    @pydantic.field_validator("pauli_operator")
+    @classmethod
     def _validate_no_complex_coefficients(
         cls, pauli_operator: PauliOperator
     ) -> PauliOperator:

classiq/interface/generator/hardware/hardware_data.py

@@ -1,10 +1,13 @@
 import itertools
 from collections import defaultdict
-from typing import Any, Dict, List, MutableSet, Optional
+from collections.abc import MutableSet
+from typing import Any, Optional
 
 import pydantic
+from typing_extensions import Self
 
 from classiq.interface.backend.backend_preferences import BackendPreferences
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.transpiler_basis_gates import (
     DEFAULT_BASIS_GATES,
     DEFAULT_ROUTING_BASIS_GATES,
@@ -14,16 +17,32 @@ from classiq.interface.generator.transpiler_basis_gates import (
 )
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
 
-from classiq.exceptions import ClassiqValueError
-
-ConnectivityMap = List[PydanticNonNegIntTuple]
+ConnectivityMap = list[PydanticNonNegIntTuple]
 BACKEND_VALIDATION_ERROR_MESSAGE = (
     "Backend service provider and backend name should be specified together."
 )
 
 
 class HardwareData(pydantic.BaseModel):
-    basis_gates: List[str] = pydantic.Field(
+    """
+    Hardware-specific settings used in quantum circuit synthesis,
+    including basis gates, connectivity map, and connectivity symmetry.
+
+    Attributes:
+        basis_gates (List[str]):
+            The basis gates of the hardware, used during model optimization.
+            If not provided, default values are used based on the connectivity map's symmetry.
+
+        connectivity_map(Optional[ConnectivityMap]):
+            The qubit connectivity map, defined as a list of qubit pairs [[q0, q1], [q1, q2],...].
+            If not provided, the hardware is assumed to be fully connected.
+
+        is_symmetric_connectivity(bool):
+            Indicates whether the coupling map forms an undirected graph, meaning
+            that both qubits in each pair can act as control and target. Defaults to True.
+    """
+
+    basis_gates: list[str] = pydantic.Field(
         default=list(),
         description="The basis gates of the hardware. "
         "This set will be used during the model optimization. "
@@ -43,7 +62,8 @@ class HardwareData(pydantic.BaseModel):
         "If false, the first / second qubit denotes the control / target, respectively",
     )
 
-    @pydantic.validator("connectivity_map")
+    @pydantic.field_validator("connectivity_map")
+    @classmethod
     def _validate_connectivity_map(
         cls, connectivity_map: Optional[ConnectivityMap]
     ) -> Optional[ConnectivityMap]:
@@ -54,39 +74,37 @@ class HardwareData(pydantic.BaseModel):
         connectivity_map = _reindex_qubits(connectivity_map)
         return connectivity_map
 
-    @pydantic.root_validator()
-    def _symmetrize_connectivity_map(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        connectivity_map = values.get("connectivity_map")
+    @pydantic.model_validator(mode="after")
+    def _symmetrize_connectivity_map(self) -> Self:
+        connectivity_map = self.connectivity_map
         if connectivity_map is None:
-            return values
+            return self
 
-        is_symmetric = values.get("is_symmetric_connectivity")
+        is_symmetric = self.is_symmetric_connectivity
         if is_symmetric:
             connectivity_map = _symmetrize_connectivity_map(connectivity_map)
-            values["connectivity_map"] = connectivity_map
+            self.connectivity_map = connectivity_map
 
         if not _is_connected_map(connectivity_map):
             raise ClassiqValueError(
                 f"Connectivity map must be connected: {connectivity_map} is not connected."
             )
-        return values
+        return self
 
-    @pydantic.root_validator()
-    def _validate_basis_gates(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        connectivity_map = values.get("connectivity_map")
-        specified_basis_gates = values.get("basis_gates", [])
+    @pydantic.model_validator(mode="after")
+    def _validate_basis_gates(self) -> Self:
+        connectivity_map = self.connectivity_map
+        specified_basis_gates = self.basis_gates
         if connectivity_map is None:
-            values["basis_gates"] = specified_basis_gates or list(DEFAULT_BASIS_GATES)
-            return values
+            self.basis_gates = specified_basis_gates or list(DEFAULT_BASIS_GATES)
+            return self
 
-        is_symmetric_connectivity = values.get("is_symmetric")
+        is_symmetric_connectivity = self.is_symmetric_connectivity
         if is_symmetric_connectivity or _check_symmetry(connectivity_map):
-            values["basis_gates"] = specified_basis_gates or list(DEFAULT_BASIS_GATES)
-            return values
+            self.basis_gates = specified_basis_gates or list(DEFAULT_BASIS_GATES)
+            return self
 
-        values["basis_gates"] = specified_basis_gates or list(
-            DEFAULT_ROUTING_BASIS_GATES
-        )
+        self.basis_gates = specified_basis_gates or list(DEFAULT_ROUTING_BASIS_GATES)
         invalid_gates = [
             gate
             for gate in specified_basis_gates
@@ -98,14 +116,21 @@ class HardwareData(pydantic.BaseModel):
                 "is currently supported for the following two-qubit gates only: cx, ecr, rzx."
             )
 
-        return values
+        return self
 
 
 class CustomHardwareSettings(HardwareData):
+    """
+    Custom hardware settings for quantum circuit synthesis.
+    This class inherits from HardwareData (please see class for more details)
+
+    """
+
     _width: Optional[int] = pydantic.PrivateAttr(default=None)
 
-    @pydantic.validator("basis_gates")
-    def validate_basis_gates(cls, basis_gates: List[str]) -> List[TranspilerBasisGates]:
+    @pydantic.field_validator("basis_gates", mode="after")
+    @classmethod
+    def validate_basis_gates(cls, basis_gates: list[str]) -> list[TranspilerBasisGates]:
         valid_gates = list(TranspilerBasisGates)
         invalid_gates = [gate for gate in basis_gates if gate not in valid_gates]
         if invalid_gates:
@@ -130,7 +155,7 @@ class CustomHardwareSettings(HardwareData):
 
 def _is_connected_map(connectivity_map: ConnectivityMap) -> bool:
     nodes: MutableSet[int] = set()
-    node_to_neighbors: Dict[int, MutableSet[int]] = defaultdict(set)
+    node_to_neighbors: dict[int, MutableSet[int]] = defaultdict(set)
     for edge in connectivity_map:
         nodes.add(edge[0])
         nodes.add(edge[1])
@@ -143,7 +168,7 @@ def _is_connected_map(connectivity_map: ConnectivityMap) -> bool:
 
 
 def _node_dfs(
-    node: int, node_to_neighbors: Dict[int, MutableSet[int]], visited: MutableSet[int]
+    node: int, node_to_neighbors: dict[int, MutableSet[int]], visited: MutableSet[int]
 ) -> None:
     visited.add(node)
     neighbors = node_to_neighbors[node]
@@ -156,7 +181,7 @@ def _node_dfs(
 
 def _reindex_qubits(connectivity_map: ConnectivityMap) -> ConnectivityMap:
     qubits = sorted({q for pair in connectivity_map for q in pair})
-    return [(qubits.index(pair[0]), qubits.index(pair[1])) for pair in connectivity_map]
+    return [[qubits.index(pair[0]), qubits.index(pair[1])] for pair in connectivity_map]
 
 
 def _check_symmetry(connectivity_map: ConnectivityMap) -> bool:
@@ -168,17 +193,30 @@ def _symmetrize_connectivity_map(connectivity_map: ConnectivityMap) -> Connectiv
     # A more complicated implementation than using set to maintain the order
     connectivity_map_no_duplicates = []
     for edge in connectivity_map:
-        reversed_edge = (edge[1], edge[0])
+        reversed_edge = [edge[1], edge[0]]
         if (
             edge not in connectivity_map_no_duplicates
             and reversed_edge not in connectivity_map_no_duplicates
         ):
             connectivity_map_no_duplicates.append(edge)
     reversed_connectivity_map = [
-        (edge[1], edge[0]) for edge in connectivity_map_no_duplicates
+        [edge[1], edge[0]] for edge in connectivity_map_no_duplicates
     ]
     return connectivity_map_no_duplicates + reversed_connectivity_map
 
 
 class SynthesisHardwareData(HardwareData):
-    backend_data: Optional[BackendPreferences]
+    """
+    Represents the synthesis-specific hardware data for a quantum circuit.
+
+    This class extends `HardwareData` and includes additional attributes that
+    pertain specifically to the hardware used during the synthesis of a quantum circuit.
+
+    Attributes:
+        backend_data (Optional[BackendPreferences]):
+            Preferences for the backend used during the synthesis process.
+            This can include specific backend configurations or settings.
+            Defaults to `None`.
+    """
+
+    backend_data: Optional[BackendPreferences] = pydantic.Field(default=None)

classiq/interface/generator/hardware_efficient_ansatz.py

@@ -1,8 +1,11 @@
 import itertools
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator import function_params
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import (
@@ -15,10 +18,7 @@ from classiq.interface.generator.transpiler_basis_gates import (
 )
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
-ConnectivityMap = List[PydanticNonNegIntTuple]
+ConnectivityMap = list[PydanticNonNegIntTuple]
 
 
 class SupportedConnectivityMaps(StrEnum):
@@ -45,16 +45,17 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
     num_qubits: pydantic.PositiveInt = pydantic.Field(
         default=None,
         description="Number of qubits in the ansatz.",
+        validate_default=True,
     )
     reps: pydantic.PositiveInt = pydantic.Field(
         default=1, description="Number of layers in the Ansatz"
     )
 
-    one_qubit_gates: Union[str, List[str]] = pydantic.Field(
+    one_qubit_gates: Union[str, list[str]] = pydantic.Field(
         default=["x", "ry"],
         description='List of gates for the one qubit gates layer, e.g. ["x", "ry"]',
     )
-    two_qubit_gates: Union[str, List[str]] = pydantic.Field(
+    two_qubit_gates: Union[str, list[str]] = pydantic.Field(
         default=["cx"],
         description='List of gates for the two qubit gates entangling layer, e.g. ["cx", "cry"]',
     )
@@ -63,11 +64,12 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
         description="Prefix for the generated parameters",
     )
 
-    @pydantic.validator("num_qubits", pre=True, always=True)
+    @pydantic.field_validator("num_qubits", mode="before")
+    @classmethod
     def validate_num_qubits(
-        cls, num_qubits: Optional[pydantic.PositiveInt], values: Dict[str, Any]
+        cls, num_qubits: Optional[pydantic.PositiveInt], info: ValidationInfo
     ) -> pydantic.PositiveInt:
-        connectivity_map = values.get("connectivity_map")
+        connectivity_map = info.data.get("connectivity_map")
         conn_map_is_not_list = (
             isinstance(connectivity_map, SupportedConnectivityMaps)
             or connectivity_map is None
@@ -102,10 +104,11 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
             )
         return num_qubits
 
-    @pydantic.validator("one_qubit_gates")
+    @pydantic.field_validator("one_qubit_gates")
+    @classmethod
     def validate_one_qubit_gates(
-        cls, one_qubit_gates: Union[str, List[str]]
-    ) -> Union[str, List[str]]:
+        cls, one_qubit_gates: Union[str, list[str]]
+    ) -> Union[str, list[str]]:
         one_qubit_gates_list = (
             [one_qubit_gates] if isinstance(one_qubit_gates, str) else one_qubit_gates
         )
@@ -114,10 +117,11 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
                 raise ClassiqValueError(f"Invalid one qubit gate: {one_qubit_gate}")
         return one_qubit_gates
 
-    @pydantic.validator("two_qubit_gates")
+    @pydantic.field_validator("two_qubit_gates")
+    @classmethod
     def validate_two_qubit_gates(
-        cls, two_qubit_gates: Union[str, List[str]]
-    ) -> Union[str, List[str]]:
+        cls, two_qubit_gates: Union[str, list[str]]
+    ) -> Union[str, list[str]]:
         two_qubit_gates_list = (
             [two_qubit_gates] if isinstance(two_qubit_gates, str) else two_qubit_gates
         )

classiq/interface/generator/hartree_fock.py

@@ -1,16 +1,24 @@
+from typing import Any, Union
+
 import pydantic
 
-from classiq.interface.chemistry.ground_state_problem import CHEMISTRY_PROBLEMS
+from classiq.interface.chemistry.ground_state_problem import (
+    CHEMISTRY_PROBLEMS,
+    HamiltonianProblem,
+    MoleculeProblem,
+)
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.chemistry_function_params import (
     ChemistryFunctionParams,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 
 class HartreeFock(ChemistryFunctionParams):
-    @pydantic.validator("gs_problem")
-    def validate_gs_problem(cls, gs_problem):
+    @pydantic.field_validator("gs_problem")
+    @classmethod
+    def validate_gs_problem(
+        cls, gs_problem: Any
+    ) -> Union[MoleculeProblem, HamiltonianProblem]:
         if not isinstance(gs_problem, CHEMISTRY_PROBLEMS):
             raise ClassiqValueError(
                 f"ground state problem must be of type {CHEMISTRY_PROBLEMS}"

classiq/interface/generator/identity.py

@@ -1,14 +1,17 @@
-from typing import TYPE_CHECKING, List
+from typing import TYPE_CHECKING, Annotated
 
 import pydantic
+from pydantic import Field
 
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import FunctionParams
 
 if TYPE_CHECKING:
-    NonEmptyRegisterUserInputList = List[RegisterUserInput]
+    NonEmptyRegisterUserInputList = list[RegisterUserInput]
 else:
-    NonEmptyRegisterUserInputList = pydantic.conlist(RegisterUserInput, min_items=1)
+    NonEmptyRegisterUserInputList = Annotated[
+        list[RegisterUserInput], Field(min_length=1)
+    ]
 
 
 class Identity(FunctionParams):
@@ -16,10 +19,11 @@ class Identity(FunctionParams):
         description="registers describing the state (ordered)"
     )
 
-    @pydantic.validator("arguments")
+    @pydantic.field_validator("arguments")
+    @classmethod
     def _validate_argument_names(
-        cls, arguments: List[RegisterUserInput]
-    ) -> List[RegisterUserInput]:
+        cls, arguments: list[RegisterUserInput]
+    ) -> list[RegisterUserInput]:
         return [
             arg if arg.name else arg.revalued(name=cls._get_default_arg_name(index))
             for index, arg in enumerate(arguments)

classiq/interface/generator/linear_pauli_rotations.py

@@ -1,24 +1,28 @@
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Annotated, Any
 
 import pydantic
+from pydantic import StringConstraints
+from typing_extensions import Self
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator import function_params
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 
-from classiq.exceptions import ClassiqValueError
-
 STATE = "state"
 TARGET = "target"
 
-LENGTH_ERROR_MESSAGE = "Slopes, offsets and basis values must have the same length"
+LENGTH_ERROR_MESSAGE = "Field required"
 
 if TYPE_CHECKING:
     PydanticPauliBasisStr = str
 else:
-    PydanticPauliBasisStr = pydantic.constr(
-        to_lower=True,
-        regex=r"[xyz]",
-    )
+    PydanticPauliBasisStr = Annotated[
+        str,
+        StringConstraints(
+            to_lower=True,
+            pattern=r"[xyz]",
+        ),
+    ]
 
 
 class LinearPauliRotations(function_params.FunctionParams):
@@ -47,29 +51,37 @@ class LinearPauliRotations(function_params.FunctionParams):
     num_state_qubits: pydantic.PositiveInt = pydantic.Field(
         description="The number of input qubits"
     )
-    bases: List[PydanticPauliBasisStr] = pydantic.Field(
+    bases: list[PydanticPauliBasisStr] = pydantic.Field(
         description="The types of Pauli rotations ('X', 'Y', 'Z')."
     )
-    slopes: List[float] = pydantic.Field(
+    slopes: list[float] = pydantic.Field(
         description="The slopes of the controlled rotations."
     )
-    offsets: List[float] = pydantic.Field(
+    offsets: list[float] = pydantic.Field(
         description="The offsets of the controlled rotations."
     )
 
-    @pydantic.validator("bases", "slopes", "offsets", pre=True, always=True)
-    def as_list(cls, v: Any) -> List[Any]:
+    @pydantic.field_validator("bases", "slopes", "offsets", mode="before")
+    @classmethod
+    def as_list(cls, v: Any) -> list[Any]:
         if not isinstance(v, list):
             v = [v]
-        return v
+        res = []
+        for x in v:
+            element = x
+            if isinstance(x, str):
+                res.append(element.lower())
+            else:
+                res.append(element)
+        return res
 
-    @pydantic.root_validator()
-    def validate_lists(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        offsets = values.get("offsets", list())
-        bases = values.get("bases", list())
-        slopes = values.get("slopes", list())
+    @pydantic.model_validator(mode="after")
+    def validate_lists(self) -> Self:
+        offsets = self.offsets or list()
+        bases = self.bases or list()
+        slopes = self.slopes or list()
         if len(slopes) == len(offsets) and len(offsets) == len(bases):
-            return values
+            return self
         raise ClassiqValueError(LENGTH_ERROR_MESSAGE)
 
     def _create_ios(self) -> None:

classiq/interface/generator/mcmt_method.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class McmtMethod(StrEnum):

classiq/interface/generator/mcu.py

@@ -1,13 +1,14 @@
-from typing import Any, Dict, Optional, cast
+from typing import Any, Optional, cast
 
 import pydantic
 
+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
-from classiq.interface.generator.parameters import ParameterFloatType
-
-from classiq.exceptions import ClassiqValueError
+from classiq.interface.generator.function_params import (
+    FunctionParams,
+    FunctionParamsNumericParameter,
+)
 
 CTRL = "CTRL"
 TARGET = "TARGET"
@@ -30,17 +31,17 @@ class Mcu(FunctionParams):
     e^(i*phi)*sin(theta/2)  &    e^(i*(phi+lam))*cos(theta/2) \\
     """
 
-    theta: ParameterFloatType = pydantic.Field(
-        default=0, description="Theta radian angle.", is_exec_param=True
+    theta: FunctionParamsNumericParameter = pydantic.Field(
+        default=0, description="Theta radian angle."
     )
-    phi: ParameterFloatType = pydantic.Field(
-        default=0, description="Phi radian angle.", is_exec_param=True
+    phi: FunctionParamsNumericParameter = pydantic.Field(
+        default=0, description="Phi radian angle."
     )
-    lam: ParameterFloatType = pydantic.Field(
-        default=0, description="Lambda radian angle.", is_exec_param=True
+    lam: FunctionParamsNumericParameter = pydantic.Field(
+        default=0, description="Lambda radian angle."
     )
-    gam: ParameterFloatType = pydantic.Field(
-        default=0, description="gam radian angle.", is_exec_param=True
+    gam: FunctionParamsNumericParameter = pydantic.Field(
+        default=0, description="gam radian angle."
     )
 
     num_ctrl_qubits: Optional[pydantic.PositiveInt] = pydantic.Field(
@@ -50,8 +51,9 @@ class Mcu(FunctionParams):
         default=None, description="string of the control state"
     )
 
-    @pydantic.root_validator()
-    def _validate_control(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_control(cls, values: Any) -> dict[str, Any]:
         num_ctrl_qubits = values.get("num_ctrl_qubits")
         ctrl_state = values.get("ctrl_state")
 

classiq/interface/generator/mcx.py

@@ -1,13 +1,13 @@
-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
 
-from classiq.exceptions import ClassiqValueError
-
 CTRL = "CTRL_IN"
 TARGET_QUBIT = "TARGET_QUBIT"
 
@@ -17,29 +17,34 @@ 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 ClassiqValueError("All registers must be named")
         if len(set(register_name_list)) != len(register_name_list):
             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
 
@@ -52,11 +57,13 @@ class Mcx(FunctionParams):
             values["arguments"] = [ctrl_register, target_register]
         elif num_ctrl_qubits != arguments_size - 1:
             raise ClassiqValueError("Given sizes do not match")
-        return num_ctrl_qubits
+        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: