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

classiq/applications_model_constructors/grover_model_constructor.py

@@ -8,18 +8,12 @@ from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.numeric_reinterpretation import (
-    NumericReinterpretationOperation,
-)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
 )
-from classiq.interface.model.quantum_function_call import (
-    QuantumFunctionCall,
-    QuantumLambdaFunction,
-)
-from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 from classiq.interface.model.quantum_type import QuantumNumeric
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -32,44 +26,6 @@ _OUTPUT_VARIABLE_NAME = "result"
 _PREDICATE_FUNCTION_NAME = "expr_predicate"
 
 
-def split_registers(
-    register_names: List[str],
-    register_sizes: List[int],
-    input_wire_name: str,
-) -> List[QuantumStatement]:
-    if len(register_names) == 0:
-        return []
-    wires = (
-        [input_wire_name]
-        + [f"split{i}" for i in range(len(register_names) - 2)]
-        + [register_names[-1]]
-    )
-
-    if len(register_names) == 1:
-        return [
-            BindOperation(
-                in_handle=HandleBinding(name=wires[0]),
-                out_handle=HandleBinding(name=wires[1]),
-            )
-        ]
-
-    return [
-        QuantumFunctionCall(
-            function="split",
-            params={
-                "out1_size": Expression(expr=f"{int(register_sizes[i])}"),
-                "out2_size": Expression(expr=f"{int(sum(register_sizes[i + 1:]))}"),
-            },
-            inputs={"in": HandleBinding(name=wires[i])},
-            outputs={
-                "out1": HandleBinding(name=register),
-                "out2": HandleBinding(name=wires[i + 1]),
-            },
-        )
-        for i, register in enumerate(register_names[:-1])
-    ]
-
-
 def _arithmetic_oracle_io_dict(
     definitions: List[Tuple[str, RegisterUserInput]], handle_name: str
 ) -> Dict[str, HandleBinding]:
@@ -89,12 +45,12 @@ def _construct_arithmetic_oracle(
     predicate_function: str,
     definitions: List[Tuple[str, RegisterUserInput]],
 ) -> QuantumFunctionCall:
-    predicate_var_binding = _arithmetic_oracle_io_dict(definitions, "vars")
-    predicate_var_binding["res"] = HandleBinding(name="result")
+    predicate_var_binding = _arithmetic_oracle_io_dict(definitions, "arg0")
+    predicate_var_binding["res"] = HandleBinding(name="arg1")
     return QuantumFunctionCall(
-        function="simple_oracle",
+        function="phase_oracle",
         inouts={
-            "target": HandleBinding(name="oq"),
+            "target": HandleBinding(name="arg0"),
         },
         operands={
             "predicate": QuantumLambdaFunction(
@@ -117,38 +73,17 @@ def grover_main_port_declarations(
         name: PortDeclaration(
             name=name,
             size=Expression(expr=f"{reg.size}"),
-            quantum_type=QuantumNumeric(),
+            quantum_type=QuantumNumeric(
+                size=Expression(expr=f"{reg.size}"),
+                is_signed=Expression(expr=f"{reg.is_signed}"),
+                fraction_digits=Expression(expr=f"{reg.fraction_places}"),
+            ),
             direction=direction,
         )
         for name, reg in definitions
     }
 
 
-def _generate_variable_declaration_statements(
-    definitions: List[Tuple[str, RegisterUserInput]]
-) -> List[VariableDeclarationStatement]:
-    ret = [VariableDeclarationStatement(name="gsq")]
-    if len(definitions) >= 2:
-        ret += [
-            VariableDeclarationStatement(name=f"split{i}")
-            for i in range(len(definitions) - 2)
-        ]
-    return ret
-
-
-def reinterpret_registers(
-    definitions: List[Tuple[str, RegisterUserInput]]
-) -> List[QuantumStatement]:
-    return [
-        NumericReinterpretationOperation(
-            target=HandleBinding(name=name),
-            fraction_digits=Expression(expr=f"{definition.fraction_places}"),
-            is_signed=Expression(expr=f"{definition.is_signed}"),
-        )
-        for name, definition in definitions
-    ]
-
-
 def construct_grover_model(
     definitions: List[Tuple[str, RegisterUserInput]],
     expression: str,
@@ -170,7 +105,6 @@ def construct_grover_model(
                 name=_PREDICATE_FUNCTION_NAME,
                 port_declarations=predicate_port_decls,
                 body=[
-                    *reinterpret_registers(definitions),
                     ArithmeticOperation(
                         expression=Expression(expr=expression),
                         result_var=HandleBinding(name="res"),
@@ -184,23 +118,22 @@ def construct_grover_model(
                     definitions, PortDeclarationDirection.Output
                 ),
                 body=[
-                    *_generate_variable_declaration_statements(definitions),
+                    VariableDeclarationStatement(name="packed_vars"),
                     QuantumFunctionCall(
                         function="allocate",
                         positional_args=[
                             Expression(expr=f"{num_qubits}"),
-                            HandleBinding(name="gsq"),
+                            HandleBinding(name="packed_vars"),
                         ],
                     ),
                     QuantumFunctionCall(
                         function="grover_search",
                         params={
-                            "num_qubits": Expression(expr=f"{num_qubits}"),
                             "reps": Expression(expr=f"{num_reps}"),
                         },
-                        inouts={"gsq": HandleBinding(name="gsq")},
+                        inouts={"packed_vars": HandleBinding(name="packed_vars")},
                         operands={
-                            "oracle_op": QuantumLambdaFunction(
+                            "oracle": QuantumLambdaFunction(
                                 body=[
                                     _construct_arithmetic_oracle(
                                         _PREDICATE_FUNCTION_NAME,
@@ -210,18 +143,14 @@ def construct_grover_model(
                             )
                         },
                     ),
-                    *split_registers(
-                        [name for name, _ in definitions],
-                        [reg.size for _, reg in definitions],
-                        "gsq",
+                    BindOperation(
+                        in_handles=[HandleBinding(name="packed_vars")],
+                        out_handles=[
+                            HandleBinding(name=name) for name, _ in definitions
+                        ],
                     ),
-                    *reinterpret_registers(definitions),
                 ],
             ),
         ],
-        classical_execution_code=f"""
-{_OUTPUT_VARIABLE_NAME} = sample()
-save({{{_OUTPUT_VARIABLE_NAME!r}: {_OUTPUT_VARIABLE_NAME}}})
-""",
     )
     return grover_model.get_model()

classiq/applications_model_constructors/libraries/qmci_library.py

@@ -5,13 +5,11 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.model.handle_binding import HandleBinding, SlicedHandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_call import (
-    QuantumFunctionCall,
-    QuantumLambdaFunction,
-)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_function_declaration import (
     QuantumOperandDeclaration,
 )
+from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
 
 from classiq import Integer
 
@@ -56,28 +54,14 @@ QMCI_LIBRARY = [
             QuantumFunctionCall(
                 function="amplitude_estimation",
                 params={
-                    "num_unitary_qubits": Expression(expr="num_unitary_qubits"),
                     "num_phase_qubits": Expression(expr="num_phase_qubits"),
+                    "num_unitary_qubits": Expression(expr="num_unitary_qubits"),
                 },
                 outputs={
                     "phase_port": HandleBinding(name="phase_port"),
                     "unitary_port": HandleBinding(name="unitary_port"),
                 },
                 operands={
-                    "oracle_op": QuantumLambdaFunction(
-                        body=[
-                            QuantumFunctionCall(
-                                function="Z",
-                                inouts={
-                                    "target": SlicedHandleBinding(
-                                        name="oq",
-                                        start=Expression(expr="num_unitary_qubits-1"),
-                                        end=Expression(expr="num_unitary_qubits"),
-                                    ),
-                                },
-                            ),
-                        ]
-                    ),
                     "sp_op": QuantumLambdaFunction(
                         body=[
                             QuantumFunctionCall(
@@ -102,6 +86,20 @@ QMCI_LIBRARY = [
                             )
                         ],
                     ),
+                    "oracle_op": QuantumLambdaFunction(
+                        body=[
+                            QuantumFunctionCall(
+                                function="Z",
+                                inouts={
+                                    "target": SlicedHandleBinding(
+                                        name="oq",
+                                        start=Expression(expr="num_unitary_qubits-1"),
+                                        end=Expression(expr="num_unitary_qubits"),
+                                    ),
+                                },
+                            ),
+                        ]
+                    ),
                 },
             ),
         ],

classiq/builtin_functions/standard_gates.py

@@ -1 +1 @@
-from classiq.interface.generator.standard_gates.standard_gates_param_list import *  # noqa: F401, F403
+from classiq.interface.generator.standard_gates.standard_gates_param_list import *  # noqa: F403

classiq/exceptions.py

@@ -1,5 +1,5 @@
 import logging
-from typing import List
+from typing import Iterable, List
 
 _logger = logging.getLogger(__name__)
 
@@ -129,3 +129,45 @@ class ClassiqMismatchIOsError(ClassiqError):
 
 class ClassiqNotImplementedError(ClassiqError, NotImplementedError):
     pass
+
+
+class ClassiqCombOptError(ClassiqError):
+    pass
+
+
+class ClassiqCombOptNoSolutionError(ClassiqError):
+
+    def __init__(self) -> None:
+        super().__init__("There is no valid solution for this optimization problem.")
+
+
+class ClassiqCombOptTrivialProblemError(ClassiqError):
+
+    def __init__(self, solution: List[int]) -> None:
+        super().__init__(
+            message=f"The problem doesn't have free decision variables. "
+            f"The trivial solution is {solution}."
+        )
+
+
+class ClassiqCombOptInvalidEncodingTypeError(ClassiqError):
+
+    def __init__(self, encoding_type: str, valid_types: Iterable[str]) -> None:
+        super().__init__(
+            f"Invalid variable encoding type {encoding_type}. "
+            f"The available encoding types are {list(valid_types)}"
+        )
+
+
+class ClassiqNonNumericCoefficientInPauliError(ClassiqError):
+    pass
+
+
+class ClassiqCombOptNotSupportedProblemError(ClassiqCombOptError):
+    pass
+
+
+class ClassiqExecutorInvalidHamiltonianError(ClassiqCombOptError):
+
+    def __init__(self) -> None:
+        super().__init__("Invalid hamiltonian")

classiq/executor.py

@@ -13,6 +13,7 @@ from classiq.interface.executor.execution_preferences import ExecutionPreference
 from classiq.interface.executor.execution_request import (
     EstimateOperatorsExecution,
     ExecutionRequest,
+    QuantumCodeExecution,
 )
 from classiq.interface.executor.execution_result import (
     ResultsCollection,
@@ -20,10 +21,10 @@ from classiq.interface.executor.execution_result import (
     TaggedEstimationResult,
     TaggedExecutionDetails,
 )
+from classiq.interface.executor.quantum_code import MultipleArguments, QuantumCode
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
-from classiq.interface.executor.quantum_program import MultipleArguments, QuantumProgram
 from classiq.interface.executor.result import ExecutionDetails
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
+from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
@@ -32,7 +33,7 @@ from classiq.model.model import DEFAULT_RESULT_NAME
 from classiq.synthesis import SerializedQuantumProgram
 
 BatchExecutionResult: TypeAlias = Union[ExecutionDetails, BaseException]
-ProgramAndResult: TypeAlias = Tuple[QuantumProgram, BatchExecutionResult]
+ProgramAndResult: TypeAlias = Tuple[QuantumCode, BatchExecutionResult]
 BackendPreferencesAndResult: TypeAlias = Tuple[
     BackendPreferencesTypes, int, BatchExecutionResult
 ]
@@ -41,8 +42,8 @@ _MAX_ARGUMENTS_SIZE = 1024
 
 def _parse_serialized_qprog(
     quantum_program: SerializedQuantumProgram,
-) -> GeneratedCircuit:
-    return GeneratedCircuit.parse_raw(quantum_program)
+) -> QuantumProgram:
+    return QuantumProgram.parse_raw(quantum_program)
 
 
 async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
@@ -55,7 +56,7 @@ execute = syncify_function(execute_async)
 
 
 async def _execute_qnn_async_estimate(
-    quantum_program: QuantumProgram,
+    quantum_program: QuantumCode,
     execution_preferences: ExecutionPreferences,
     observables: PauliOperators,
 ) -> ResultsCollection:
@@ -79,11 +80,11 @@ async def _execute_qnn_async_estimate(
 
 
 async def _execute_qnn_async_program(
-    quantum_program: QuantumProgram,
+    quantum_program: QuantumCode,
     execution_preferences: ExecutionPreferences,
 ) -> ResultsCollection:
     request = ExecutionRequest(
-        execution_payload=quantum_program.dict(),
+        execution_payload=QuantumCodeExecution(**quantum_program.dict()),
         preferences=execution_preferences,
     )
 
@@ -154,7 +155,7 @@ def set_initial_values(
 
 
 __all__ = [
-    "QuantumProgram",
+    "QuantumCode",
     "QuantumInstructionSet",
     "execute_qnn",
     "OperatorsEstimation",

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.37.0'
+SEMVER_VERSION = '0.38.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/analysis_params.py

@@ -8,7 +8,9 @@ from classiq.interface.backend.quantum_backend_providers import AnalyzerProvider
 from classiq.interface.chemistry.ground_state_problem import MoleculeProblem
 from classiq.interface.executor.optimizer_preferences import OptimizerPreferences
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
-from classiq.interface.generator.model.preferences.preferences import Preferences
+from classiq.interface.generator.model.preferences.preferences import (
+    TranspilationOption,
+)
 from classiq.interface.hardware import Provider
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 
@@ -44,7 +46,8 @@ class AnalysisOptionalDevicesParams(HardwareListParams):
 
 class AnalysisHardwareTranspilationParams(pydantic.BaseModel):
     hardware_data: Optional[SynthesisHardwareData]
-    model_preferences: Preferences
+    random_seed: int
+    transpilation_option: TranspilationOption
 
 
 class AnalysisHardwareListParams(AnalysisParams, HardwareListParams):
@@ -87,7 +90,7 @@ class ChemistryGenerationParams(pydantic.BaseModel):
     def initial_point(self) -> Optional[numpy.ndarray]:
         if self.optimizer_preferences.initial_point is not None:
             return numpy.ndarray(
-                self.optimizer_preferences.initial_point  # type: ignore
+                self.optimizer_preferences.initial_point  # type: ignore[arg-type]
             )
         else:
             return None

classiq/interface/analyzer/result.py

@@ -1,13 +1,15 @@
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Dict, List, Literal, Optional, Set, Tuple, Union
 from uuid import UUID
 
 import pydantic
-from pydantic import AnyHttpUrl
+from pydantic import AnyHttpUrl, Field
+from typing_extensions import Annotated
 
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 Match = List[List[int]]
 
@@ -18,6 +20,7 @@ class GraphStatus(StrEnum):
 
 
 class GraphResult(VersionedModel):
+    kind: Literal["graph"] = Field(default="graph")
     details: str
 
 
@@ -79,7 +82,7 @@ class HardwareComparisonInformation(pydantic.BaseModel):
     def validate_equal_length(cls, values: Dict[str, list]) -> Dict[str, list]:
         lengths = list(map(len, values.values()))
         if len(set(lengths)) != 1:
-            raise ValueError("All lists should have the same length")
+            raise ClassiqValueError("All lists should have the same length")
         return values
 
 
@@ -103,10 +106,15 @@ class SingleHardwareInformation(pydantic.BaseModel):
     )
 
 
-class HardwareComparisonData(pydantic.BaseModel):
+class HardwareComparisonData(VersionedModel):
+    kind: Literal["hardware_comparison"] = Field(default="hardware_comparison")
     data: List[SingleHardwareInformation]
 
 
+HardwareComparisonGraphType = Annotated[
+    Union[HardwareComparisonData, GraphResult], Field(discriminator="kind")
+]
+
 _HARDWARE_COMPARISON_TABLE_COLUMNS_NAMES: Dict[str, str] = {
     s.upper(): s.capitalize() for s in SingleHardwareInformation.__fields__
 }

classiq/interface/applications/qsvm.py

@@ -1,5 +1,13 @@
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, Iterable as IterableType, List, Optional, Tuple, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Iterable as IterableType,
+    List,
+    Optional,
+    Tuple,
+    Union,
+)
 
 import numpy as np
 import pydantic
@@ -112,3 +120,7 @@ class QSVMTestResult(VersionedModel):
 
 class QSVMPredictResult(VersionedModel):
     data: list  # serialized np.array
+
+
+Data = Union[DataList, np.ndarray]
+Labels = Union[List[Any], np.ndarray]

classiq/interface/backend/backend_preferences.py

@@ -22,6 +22,8 @@ from classiq.interface.backend.quantum_backend_providers import (
 from classiq.interface.hardware import Provider
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
+from classiq.exceptions import ClassiqValueError
+
 
 class BackendPreferences(BaseModel):
     # Due to the way the field is currently implemented, i.e. it redefined with different types
@@ -103,7 +105,7 @@ class AwsBackendPreferences(BackendPreferences):
     ) -> str:
         s3_bucket_name = s3_bucket_name.strip()
         if not s3_bucket_name.startswith("amazon-braket-"):
-            raise ValueError('S3 bucket name should start with "amazon-braket-"')
+            raise ClassiqValueError('S3 bucket name should start with "amazon-braket-"')
         return s3_bucket_name
 
     @pydantic.root_validator(pre=True)
@@ -273,7 +275,7 @@ def validate_backend_service_provider(backend_service_provider: Any) -> Provider
         for member in Provider:
             if member.lower() == backend_service_provider.lower():
                 return Provider(member)
-    raise ValueError(
+    raise ClassiqValueError(
         f"""Vendor {backend_service_provider} is not supported.
     The supported providers are {', '.join(Provider)}."""
     )

classiq/interface/backend/pydantic_backend.py

@@ -13,6 +13,8 @@ INVALID_EMAIL_OQC: str = "aa@aa.aa"
 INVALID_PASSWORD_OQC: str = "Aa1!Aa1!"
 MAX_EXECUTION_TIMEOUT_SECONDS = timedelta(hours=4).total_seconds()
 
+EXECUTION_PARAMETER_PATTERN = "[_a-z][_a-z0-9]*"
+
 if TYPE_CHECKING:
     PydanticExecutionTimeout = int
     PydanticAwsRoleArn = str
@@ -46,4 +48,4 @@ else:
 
     PydanticArgumentNameType = pydantic.constr(regex="[_a-zA-Z][_a-zA-Z0-9]*")
 
-    PydanticExecutionParameter = pydantic.constr(regex="[_a-z][_a-z0-9]*")
+    PydanticExecutionParameter = pydantic.constr(regex=EXECUTION_PARAMETER_PATTERN)

classiq/interface/backend/quantum_backend_providers.py

@@ -56,6 +56,7 @@ class AzureQuantumBackendNames(StrEnum):
     RIGETTI_ASPEN3 = "rigetti.qpu.aspen-m-3"
     RIGETTI_SIMULATOR = "rigetti.sim.qvm"
     RIGETTI_ANKAA2 = "rigetti.qpu.ankaa-2"
+    RIGETTI_ANKAA9 = "rigetti.qpu.ankaa-9q-1"
     QCI_MACHINE1 = "qci.machine1"
     QCI_NOISY_SIMULATOR = "qci.simulator.noisy"
     QCI_SIMULATOR = "qci.simulator"

classiq/interface/chemistry/fermionic_operator.py

@@ -10,6 +10,8 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 LadderOperator = Tuple[str, int]
 FermionicOperatorTuple = Tuple["FermionicOperator", float]
 
@@ -46,19 +48,19 @@ class FermionicOperator(HashablePydanticBaseModel):
             try:  # type: ignore[unreachable] # it is reachable...
                 op = tuple(op)
             except Exception as exc:
-                raise ValueError("Ladder operator should be a tuple.") from exc
+                raise ClassiqValueError("Ladder operator should be a tuple.") from exc
         if len(op) != 2:
-            raise ValueError(
+            raise ClassiqValueError(
                 "Ladder operator tuple should be of length two; for example (1, '+')."
             )
 
         if op[0] not in ("+", "-"):
-            raise ValueError(
+            raise ClassiqValueError(
                 "The first term in a ladder operator tuple indicates if its a raising ('+')"
                 f" or lowering ('-') operator. Allowed input is: '+' or '-', received {op[0]}"
             )
         if not isinstance(op[1], int):
-            raise ValueError(
+            raise ClassiqValueError(
                 "The second term in a ladder operator tuple indicates its index and should be of type int"
             )
 
@@ -71,7 +73,7 @@ class FermionicOperator(HashablePydanticBaseModel):
     def __mul__(self, coeff: Union[float, int]) -> SummedFermionicOperator:
         if isinstance(coeff, (float, int)):
             return SummedFermionicOperator(op_list=[(self, float(coeff))])
-        raise ValueError(
+        raise ClassiqValueError(
             "The coefficient multiplying Fermionic Operator should be of type float"
         )
 
@@ -84,7 +86,7 @@ class FermionicOperator(HashablePydanticBaseModel):
             return SummedFermionicOperator(op_list=[(self, 1.0)] + other.op_list)
         elif isinstance(other, FermionicOperator):
             return SummedFermionicOperator(op_list=[(self, 1.0)] + [(other, 1.0)])
-        raise ValueError(
+        raise ClassiqValueError(
             "FermionicOperator can be summed together only with type FermionicOperator or SummedFermionicOperator"
         )
 
@@ -135,21 +137,21 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
             try:  # type: ignore[unreachable] # it is reachable...
                 op = tuple(op)
             except Exception as exc:
-                raise ValueError("Operator should be a tuple.") from exc
+                raise ClassiqValueError("Operator should be a tuple.") from exc
         if len(op) != 2:
-            raise ValueError("Operator tuple should be of length two.")
+            raise ClassiqValueError("Operator tuple should be of length two.")
 
         # is it FermionicOperator - if not, convert to FermionicOperator
-        if type(op[0]) is not FermionicOperator:
+        if not isinstance(op[0], FermionicOperator):
             try:
                 op = (FermionicOperator(**op[0]), op[1])
             except Exception as exc:
-                raise ValueError(
+                raise ClassiqValueError(
                     "The first term in the operator tuple should be an instance of the FermionicOperator class"
                 ) from exc
 
-        if type(op[1]) is not float:
-            raise ValueError(
+        if not isinstance(op[1], float):
+            raise ClassiqValueError(
                 "The second term in the operator tuple indicates its coefficient and should be of type float"
             )
 
@@ -166,7 +168,7 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
             return SummedFermionicOperator(op_list=self.op_list + other.op_list)
         elif isinstance(other, FermionicOperator):
             return SummedFermionicOperator(op_list=self.op_list + [(other, 1.0)])
-        raise ValueError(
+        raise ClassiqValueError(
             "FermionicOperator can be summed together only with type FermionicOperator or SummedFermionicOperator"
         )