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

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

@@ -0,0 +1,37 @@
+from typing import Any
+
+from classiq.interface.model.quantum_function_declaration import (
+    QuantumFunctionDeclaration,
+    QuantumOperandDeclaration,
+)
+
+
+def get_single_empty_operand_operator(
+    operator_name: str, **kwargs: Any
+) -> QuantumFunctionDeclaration:
+    operand_field_name = "operand"
+    return QuantumFunctionDeclaration(
+        name=operator_name,
+        operand_declarations={
+            operand_field_name: QuantumOperandDeclaration(name=operand_field_name)
+        },
+        **kwargs,
+    )
+
+
+PERMUTE_OPERATOR = QuantumFunctionDeclaration(
+    name="permute",
+    operand_declarations={
+        "functions": QuantumOperandDeclaration(
+            name="functions",
+            is_list=True,
+        )
+    },
+)
+
+APPLY_OPERATOR = get_single_empty_operand_operator(operator_name="apply")
+
+STD_QMOD_OPERATORS = [
+    PERMUTE_OPERATOR,
+    APPLY_OPERATOR,
+]

classiq/interface/generator/functions/classical_type.py

@@ -6,20 +6,18 @@ from pydantic import Extra, Field
 from sympy import IndexedBase, Symbol
 from typing_extensions import Annotated
 
+from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.expressions.enums.ladder_operator import (
     LadderOperator as LadderOperatorEnum,
 )
 from classiq.interface.generator.expressions.enums.pauli import Pauli as PauliEnum
 from classiq.interface.generator.expressions.expression_types import RuntimeExpression
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
 NamedSymbol = Union[IndexedBase, Symbol]
 
 
-class ClassicalType(HashablePydanticBaseModel):
+class ClassicalType(HashableASTNode):
     def as_symbolic(self, name: str) -> Union[NamedSymbol, List[NamedSymbol]]:
         return Symbol(name)
 

classiq/interface/generator/functions/foreign_function_definition.py

@@ -20,6 +20,8 @@ from classiq.interface.generator.functions.register_mapping_data import (
     RegisterMappingData,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 ImplementationsType = Tuple[FunctionImplementation, ...]
 
 
@@ -44,7 +46,9 @@ class SynthesisForeignFunctionDefinition(SynthesisQuantumFunctionDeclaration):
         cls, register_mapping: RegisterMappingData
     ) -> RegisterMappingData:
         if not register_mapping.output_registers:
-            raise ValueError("The outputs of a custom function must be non-empty")
+            raise ClassiqValueError(
+                "The outputs of a custom function must be non-empty"
+            )
         return register_mapping
 
     @pydantic.validator("implementations", pre=True)
@@ -64,7 +68,7 @@ class SynthesisForeignFunctionDefinition(SynthesisQuantumFunctionDeclaration):
         values: Dict[str, Any],
     ) -> Optional[ImplementationsType]:
         if not implementations:
-            raise ValueError(
+            raise ClassiqValueError(
                 "The implementations of a custom function must be non-empty."
             )
 
@@ -92,11 +96,15 @@ class SynthesisForeignFunctionDefinition(SynthesisQuantumFunctionDeclaration):
 
     @property
     def port_declarations(self) -> Dict[IOName, SynthesisPortDeclaration]:
-        raise ValueError("Bad usage of foreign function definition: port_declarations")
+        raise ClassiqValueError(
+            "Bad usage of foreign function definition: port_declarations"
+        )
 
     @port_declarations.setter
     def port_declarations(self, value: Any) -> NoReturn:
-        raise ValueError("Bad usage of foreign function definition: port_declarations")
+        raise ClassiqValueError(
+            "Bad usage of foreign function definition: port_declarations"
+        )
 
 
 def _map_reg_user_input(registers: List[Register]) -> ArithmeticIODict:

classiq/interface/generator/functions/function_declaration.py

@@ -2,12 +2,12 @@ import abc
 from typing import Dict
 
 import pydantic
-from pydantic.main import BaseModel
 
+from classiq.interface.ast_node import ASTNode
 from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
 
 
-class FunctionDeclaration(BaseModel, abc.ABC):
+class FunctionDeclaration(ASTNode, abc.ABC):
     """
     Facilitates the creation of a common function interface object.
     """

classiq/interface/generator/functions/function_implementation.py

@@ -10,6 +10,8 @@ from classiq.interface.generator.functions.register_mapping_data import (
 )
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 
+from classiq.exceptions import ClassiqValueError
+
 RegistersStrictType = Tuple[Register, ...]
 RegistersType = Union[Register, RegistersStrictType]
 
@@ -85,9 +87,9 @@ class FunctionImplementation(BaseModel):
         num_qubits = len(input_qubits)
         all_qubits = set(range(num_qubits))
         if num_qubits != sum(register.width for register in all_input_registers):
-            raise ValueError("The input registers must not overlap.")
+            raise ClassiqValueError("The input registers must not overlap.")
         if input_qubits != all_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 "The set of qubits contained in all registers must be consecutive."
             )
 
@@ -98,6 +100,8 @@ class FunctionImplementation(BaseModel):
         if len(output_qubits) != sum(
             register.width for register in all_output_registers
         ):
-            raise ValueError("The output registers must not overlap.")
+            raise ClassiqValueError("The output registers must not overlap.")
         if not output_qubits == all_qubits:
-            raise ValueError("The input and output qubits must be mutually consistent.")
+            raise ClassiqValueError(
+                "The input and output qubits must be mutually consistent."
+            )

classiq/interface/generator/functions/native_function_definition.py

@@ -17,6 +17,8 @@ from classiq.interface.generator.quantum_function_call import (
 )
 from classiq.interface.generator.validations import flow_graph
 
+from classiq.exceptions import ClassiqValueError
+
 LOGIC_FLOW_DUPLICATE_NAME_ERROR_MSG = (
     "Cannot have multiple function calls with the same name"
 )
@@ -59,7 +61,7 @@ class SynthesisNativeFunctionDefinition(SynthesisQuantumFunctionDeclaration):
     def validate_body(self) -> None:
         function_call_names = {call.name for call in self.body}
         if len(function_call_names) != len(self.body):
-            raise ValueError(LOGIC_FLOW_DUPLICATE_NAME_ERROR_MSG)
+            raise ClassiqValueError(LOGIC_FLOW_DUPLICATE_NAME_ERROR_MSG)
         flow_graph.validate_legal_wiring(
             self.body,
             flow_input_names=list(self.input_ports_wiring.values()),
@@ -83,7 +85,7 @@ class SynthesisNativeFunctionDefinition(SynthesisQuantumFunctionDeclaration):
                 io_name not in port_declarations
                 or not port_declarations[io_name].direction == direction
             ):
-                raise ValueError(
+                raise ClassiqValueError(
                     f"The wired {direction} port {io_name!r} is not declared."
                 )
 

classiq/interface/generator/functions/register.py

@@ -8,6 +8,8 @@ from pydantic import BaseModel
 
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 
+from classiq.exceptions import ClassiqValueError
+
 QubitsType = Tuple[pydantic.NonNegativeInt, ...]
 
 
@@ -32,9 +34,9 @@ class Register(BaseModel):
     @pydantic.validator("qubits")
     def validate_qubits(cls, qubits: QubitsType) -> QubitsType:
         if len(qubits) == 0:
-            raise ValueError("qubits field must be non-empty.")
+            raise ClassiqValueError("qubits field must be non-empty.")
         if len(set(qubits)) != len(qubits):
-            raise ValueError("All qubits of a register must be distinct.")
+            raise ClassiqValueError("All qubits of a register must be distinct.")
         return qubits
 
 

classiq/interface/generator/functions/register_mapping_data.py

@@ -9,6 +9,8 @@ from classiq.interface.generator.functions.register import Register, get_registe
 from classiq.interface.generator.register_role import RegisterRole as Role
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 
+from classiq.exceptions import ClassiqValueError
+
 REGISTER_NOT_FOUND_ERROR = "Register name not found"
 
 
@@ -29,12 +31,12 @@ class RegisterMappingData(pydantic.BaseModel):
 
         all_input_qubits = sorted(input_qubits + zero_input_qubits)
         if not cls._validate_no_overlap(all_input_qubits):
-            raise ValueError("overlapping input qubits are not allowed")
+            raise ClassiqValueError("overlapping input qubits are not allowed")
         if not cls._validate_no_overlap(output_qubits):
-            raise ValueError("overlapping output qubits are not allowed")
+            raise ClassiqValueError("overlapping output qubits are not allowed")
 
         if not output_qubits == all_input_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 "output registers should be included within the input / zero input registers"
             )
 
@@ -45,7 +47,9 @@ class RegisterMappingData(pydantic.BaseModel):
         cls, field_value: List[Register]
     ) -> List[Register]:
         if len(field_value) != len({io_register.name for io_register in field_value}):
-            raise ValueError("The names of PortDirection registers must be distinct.")
+            raise ClassiqValueError(
+                "The names of PortDirection registers must be distinct."
+            )
         return field_value
 
     @staticmethod
@@ -54,9 +58,7 @@ class RegisterMappingData(pydantic.BaseModel):
 
     @staticmethod
     def _get_qubit_range(registers: Iterable[Register]) -> List[int]:
-        return sorted(
-            list(itertools.chain.from_iterable(reg.qubits for reg in registers))
-        )
+        return sorted(itertools.chain.from_iterable(reg.qubits for reg in registers))
 
     @property
     def input_names(self) -> Iterable[str]:
@@ -74,19 +76,21 @@ class RegisterMappingData(pydantic.BaseModel):
                 self.zero_input_registers != other.zero_input_registers,
             ]
         ):
-            raise ValueError("Interface should be identical in all implementations")
+            raise ClassiqValueError(
+                "Interface should be identical in all implementations"
+            )
 
     def get_input_register(self, name: PydanticNonEmptyString) -> Register:
         for reg in self.input_registers:
             if reg.name == name:
                 return reg
-        raise ValueError(REGISTER_NOT_FOUND_ERROR)
+        raise ClassiqValueError(REGISTER_NOT_FOUND_ERROR)
 
     def get_output_register(self, name: PydanticNonEmptyString) -> Register:
         for reg in self.output_registers:
             if reg.name == name:
                 return reg
-        raise ValueError(REGISTER_NOT_FOUND_ERROR)
+        raise ClassiqValueError(REGISTER_NOT_FOUND_ERROR)
 
     @staticmethod
     def from_registers_dict(

classiq/interface/generator/generated_circuit_data.py

@@ -61,9 +61,9 @@ class GeneratedFunction(pydantic.BaseModel):
     dangling_outputs: Dict[str, GeneratedRegister] = dict()
 
     def __getitem__(self, key: Union[int, str]) -> GeneratedRegister:
-        if type(key) is int:
+        if isinstance(key, int):
             return self.registers[key]
-        if type(key) is str:
+        if isinstance(key, str):
             for register in self.registers:
                 if key == register.name:
                     return register

classiq/interface/generator/grover_operator.py

@@ -18,6 +18,8 @@ from classiq.interface.generator.oracles.oracle_function_param_list import (
 from classiq.interface.generator.range_types import NonNegativeFloatRange
 from classiq.interface.generator.state_preparation import Metrics, StatePreparation
 
+from classiq.exceptions import ClassiqValueError
+
 _DEFAULT_ORACLE_DISCRIMINATOR: FunctionParamsDiscriminator = (
     ArithmeticOracle.discriminator()
 )
@@ -47,13 +49,13 @@ class GroverOperator(FunctionParams):
                 params=oracle_params,
                 discriminator=values.get("oracle", _DEFAULT_ORACLE_DISCRIMINATOR),
                 param_classes=oracle_function_param_library.param_list,
-                no_discriminator_error=ValueError("Invalid oracle name"),
-                bad_function_error=ValueError("Invalid oracle params"),
+                no_discriminator_error=ClassiqValueError("Invalid oracle name"),
+                bad_function_error=ClassiqValueError("Invalid oracle params"),
             )
         elif isinstance(oracle_params, FunctionParams):
             values["oracle"] = oracle_params.discriminator()
         else:
-            raise ValueError("Invalid oracle params")
+            raise ClassiqValueError("Invalid oracle params")
         return values
 
     @pydantic.validator("state_preparation_params", always=True)

classiq/interface/generator/hamiltonian_evolution/suzuki_trotter.py

@@ -7,6 +7,8 @@ from classiq.interface.generator.hamiltonian_evolution.hamiltonian_evolution imp
 )
 from classiq.interface.generator.parameters import ParameterFloatType
 
+from classiq.exceptions import ClassiqValueError
+
 
 class SuzukiParameters(pydantic.BaseModel):
     order: pydantic.PositiveInt = pydantic.Field(
@@ -20,7 +22,9 @@ class SuzukiParameters(pydantic.BaseModel):
     @pydantic.validator("order")
     def _validate_order(cls, order: int) -> int:
         if order != 1 and order % 2:
-            raise NotImplementedError
+            raise ClassiqValueError(
+                f"Odd order greater than 1 is not supported. Got {order}"
+            )
         return order
 
     class Config:

classiq/interface/generator/hardware/hardware_data.py

@@ -14,6 +14,8 @@ 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]
 BACKEND_VALIDATION_ERROR_MESSAGE = (
     "Backend service provider and backend name should be specified together."
@@ -48,7 +50,7 @@ class HardwareData(pydantic.BaseModel):
         if connectivity_map is None:
             return connectivity_map
         if not connectivity_map:
-            raise ValueError("Connectivity map cannot be empty")
+            raise ClassiqValueError("Connectivity map cannot be empty")
         connectivity_map = _reindex_qubits(connectivity_map)
         return connectivity_map
 
@@ -64,7 +66,7 @@ class HardwareData(pydantic.BaseModel):
             values["connectivity_map"] = connectivity_map
 
         if not _is_connected_map(connectivity_map):
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Connectivity map must be connected: {connectivity_map} is not connected."
             )
         return values
@@ -91,7 +93,7 @@ class HardwareData(pydantic.BaseModel):
             if gate in TWO_QUBIT_GATES and gate not in ROUTING_TWO_QUBIT_BASIS_GATES
         ]
         if invalid_gates:
-            raise ValueError(
+            raise ClassiqValueError(
                 "Connectivity-aware synthesis with non-symmetric coupling map "
                 "is currently supported for the following two-qubit gates only: cx, ecr, rzx."
             )
@@ -107,7 +109,7 @@ class CustomHardwareSettings(HardwareData):
         valid_gates = list(TranspilerBasisGates)
         invalid_gates = [gate for gate in basis_gates if gate not in valid_gates]
         if invalid_gates:
-            raise ValueError(
+            raise ClassiqValueError(
                 "Invalid gates for hardware-aware synthesis: " + str(invalid_gates)
             )
 

classiq/interface/generator/hardware_efficient_ansatz.py

@@ -1,5 +1,5 @@
 import itertools
-from typing import List, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 import pydantic
 
@@ -16,6 +16,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]
 
@@ -63,7 +64,9 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
     )
 
     @pydantic.validator("num_qubits", pre=True, always=True)
-    def validate_num_qubits(cls, num_qubits, values):
+    def validate_num_qubits(
+        cls, num_qubits: Optional[pydantic.PositiveInt], values: Dict[str, Any]
+    ) -> pydantic.PositiveInt:
         connectivity_map = values.get("connectivity_map")
         conn_map_is_not_list = (
             isinstance(connectivity_map, SupportedConnectivityMaps)
@@ -71,42 +74,56 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
         )
 
         if num_qubits is None and conn_map_is_not_list:
-            raise ValueError(_NUM_QUBITS_NOT_PROVIDED_ERROR)
+            raise ClassiqValueError(_NUM_QUBITS_NOT_PROVIDED_ERROR)
         if num_qubits is None:
+            if conn_map_is_not_list:
+                raise ValueError(_NUM_QUBITS_NOT_PROVIDED_ERROR)
+
+            if TYPE_CHECKING:
+                assert connectivity_map is not None
+
             return len(set(itertools.chain.from_iterable(connectivity_map)))
+
         if conn_map_is_not_list:
             return num_qubits
 
+        if TYPE_CHECKING:
+            assert connectivity_map is not None
+
         invalid_qubits = {
             qubit
             for qubit in itertools.chain.from_iterable(connectivity_map)
             if qubit >= num_qubits
         }
         if invalid_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Invalid qubits: {invalid_qubits} "
                 f"out of range specified by num_qubits: [0, {num_qubits - 1}]"
             )
         return num_qubits
 
     @pydantic.validator("one_qubit_gates")
-    def validate_one_qubit_gates(cls, one_qubit_gates):
+    def validate_one_qubit_gates(
+        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
         )
         for one_qubit_gate in one_qubit_gates_list:
             if one_qubit_gate not in SINGLE_QUBIT_GATES:
-                raise ValueError(f"Invalid one qubit gate: {one_qubit_gate}")
+                raise ClassiqValueError(f"Invalid one qubit gate: {one_qubit_gate}")
         return one_qubit_gates
 
     @pydantic.validator("two_qubit_gates")
-    def validate_two_qubit_gates(cls, two_qubit_gates):
+    def validate_two_qubit_gates(
+        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
         )
         for two_qubit_gate in two_qubit_gates_list:
             if two_qubit_gate not in TWO_QUBIT_GATES:
-                raise ValueError(f"Invalid two qubit gate: {two_qubit_gate}")
+                raise ClassiqValueError(f"Invalid two qubit gate: {two_qubit_gate}")
         return two_qubit_gates
 
     def _create_ios(self) -> None:

classiq/interface/generator/hartree_fock.py

@@ -1,16 +1,26 @@
+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.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):
+    def validate_gs_problem(
+        cls, gs_problem: Any
+    ) -> Union[MoleculeProblem, HamiltonianProblem]:
         if not isinstance(gs_problem, CHEMISTRY_PROBLEMS):
-            raise ValueError(
+            raise ClassiqValueError(
                 f"ground state problem must be of type {CHEMISTRY_PROBLEMS}"
             )
         return gs_problem

classiq/interface/generator/linear_pauli_rotations.py

@@ -5,6 +5,8 @@ import pydantic
 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"
 
@@ -68,7 +70,7 @@ class LinearPauliRotations(function_params.FunctionParams):
         slopes = values.get("slopes", list())
         if len(slopes) == len(offsets) and len(offsets) == len(bases):
             return values
-        raise ValueError(LENGTH_ERROR_MESSAGE)
+        raise ClassiqValueError(LENGTH_ERROR_MESSAGE)
 
     def _create_ios(self) -> None:
         self._inputs = {

classiq/interface/generator/mcu.py

@@ -7,6 +7,8 @@ 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
+
 CTRL = "CTRL"
 TARGET = "TARGET"
 
@@ -58,7 +60,7 @@ class Mcu(FunctionParams):
             ControlState.validate_control_string(ctrl_state)
 
         if ctrl_state is None and num_ctrl_qubits is None:
-            raise ValueError("num_ctrl_qubits or ctrl_state must exist.")
+            raise ClassiqValueError("num_ctrl_qubits or ctrl_state must exist.")
 
         if ctrl_state is None and num_ctrl_qubits is not None:
             values["ctrl_state"] = "1" * num_ctrl_qubits
@@ -69,7 +71,7 @@ class Mcu(FunctionParams):
             values["num_ctrl_qubits"] = 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"
             )
 
@@ -77,7 +79,7 @@ class Mcu(FunctionParams):
 
     def _create_ios(self) -> None:
         if self.num_ctrl_qubits is None:
-            raise ValueError("num_ctrl_qubits must have a valid value.")
+            raise ClassiqValueError("num_ctrl_qubits must have a valid value.")
         ctrl_register = RegisterUserInput(size=self.num_ctrl_qubits, name=CTRL)
         target_register = RegisterUserInput(size=1, name=TARGET)
         self._inputs = {reg.name: reg for reg in (ctrl_register, target_register)}

classiq/interface/generator/mcx.py

@@ -6,6 +6,8 @@ from classiq.interface.generator.arith.register_user_input import RegisterUserIn
 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"
 
@@ -29,9 +31,9 @@ class Mcx(FunctionParams):
     ) -> 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)
@@ -42,14 +44,14 @@ class Mcx(FunctionParams):
             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")
+            raise ClassiqValueError("Given sizes do not match")
         return num_ctrl_qubits
 
     @pydantic.validator("ctrl_state", always=True)
@@ -58,7 +60,7 @@ class Mcx(FunctionParams):
         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/classical_main_validator.py

@@ -1,7 +1,7 @@
 import ast
 from typing import Dict, List
 
-from classiq.model.model import DEFAULT_RESULT_NAME
+from classiq.executor import DEFAULT_RESULT_NAME
 
 STANDARD_CMAIN_BODY_LENGTH = 2  # assignment of sample call, save statement
 

classiq/interface/generator/model/constraints.py

@@ -7,6 +7,7 @@ from pydantic import BaseModel, Extra
 from classiq.interface.generator.transpiler_basis_gates import TranspilerBasisGates
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 UNCONSTRAINED = -1
 
@@ -26,7 +27,7 @@ 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):