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

classiq/interface/generator/model/model.py

@@ -5,7 +5,7 @@ import pydantic
 
 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.function_params import ArithmeticIODict, IOName
 from classiq.interface.generator.functions import (
     SynthesisNativeFunctionDefinition,
     SynthesisPortDeclaration,
@@ -22,20 +22,14 @@ from classiq.interface.generator.quantum_function_call import (
     WireDict,
     WireName,
 )
-from classiq.interface.generator.types.combinatorial_problem import (
-    CombinatorialOptimizationStructDeclaration,
-)
 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.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.helpers.validation_helpers import is_list_unique
 from classiq.interface.helpers.versioned_model import VersionedModel
+from classiq.interface.model.quantum_register import QReg, QRegGenericAlias
 
 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"
@@ -45,10 +39,6 @@ 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).
@@ -70,7 +60,7 @@ class ClassiqBaseModel(VersionedModel, ABC):
     All the relevant data for evaluating execution in one place.
     """
 
-    types: List[ConcreteStructDeclaration] = pydantic.Field(
+    types: List[StructDeclaration] = pydantic.Field(
         default_factory=list,
         description="The user-defined custom function library.",
     )
@@ -88,17 +78,18 @@ class ClassiqBaseModel(VersionedModel, ABC):
     )
 
     @pydantic.validator("types")
-    def types_validator(
-        cls, types: List[ConcreteStructDeclaration]
-    ) -> List[ConcreteStructDeclaration]:
+    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
+    circuit_outputs: ArithmeticIODict = pydantic.Field(
+        description="Mapping between a measured register name and its arithmetic type",
+        default_factory=dict,
+    )
 
 
 class SynthesisModel(ClassiqBaseModel):
@@ -106,7 +97,7 @@ class SynthesisModel(ClassiqBaseModel):
     All the relevant data for generating quantum circuit in one place.
     """
 
-    kind: Literal["synthesis"] = get_discriminator_field("synthesis")
+    kind: Literal["synthesis"] = pydantic.Field(default="synthesis")
 
     # Must be validated before logic_flow
     functions: List[ConcreteFunctionDefinition] = pydantic.Field(
@@ -241,4 +232,5 @@ class SynthesisModel(ClassiqBaseModel):
             constants=self.constants,
             classical_execution_code=self.classical_execution_code,
             execution_preferences=self.execution_preferences,
+            circuit_outputs=self.main_func.outputs,
         )

classiq/interface/generator/model/preferences/preferences.py

@@ -21,6 +21,7 @@ from classiq.interface.hardware import Provider
 from classiq.interface.helpers.custom_pydantic_types import PydanticMachinePrecision
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 if TYPE_CHECKING:
     VisualizationLevel: TypeAlias = Optional[int]
@@ -157,7 +158,7 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         if generation_timeout_seconds is None or optimization_timeout_seconds is None:
             return optimization_timeout_seconds
         if optimization_timeout_seconds >= generation_timeout_seconds:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Generation timeout ({generation_timeout_seconds})"
                 f"is greater than or equal to "
                 f"optimization timeout ({optimization_timeout_seconds}) "
@@ -176,7 +177,7 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         cls, output_format: PydanticConstrainedQuantumFormatList, values: Dict[str, Any]
     ) -> PydanticConstrainedQuantumFormatList:
         if len(output_format) != len(set(output_format)):
-            raise ValueError(
+            raise ClassiqValueError(
                 f"output_format={output_format}\n"
                 "has at least one format that appears twice or more"
             )
@@ -196,7 +197,7 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         backend_name = values.get("backend_name")
         backend_service_provider = values.get("backend_service_provider")
         if (backend_name is None) != (backend_service_provider is None):
-            raise ValueError(BACKEND_VALIDATION_ERROR_MESSAGE)
+            raise ClassiqValueError(BACKEND_VALIDATION_ERROR_MESSAGE)
         return values
 
     @property

classiq/interface/generator/oracles/custom_oracle.py

@@ -11,6 +11,8 @@ from classiq.interface.generator.oracles.oracle_abc import (
 )
 from classiq.interface.generator.user_defined_function_params import CustomFunction
 
+from classiq.exceptions import ClassiqValueError
+
 QubitState = str
 
 
@@ -39,12 +41,12 @@ class CustomOracle(OracleABC[QubitState]):
         if set(custom_oracle_params.input_decls.keys()) != set(
             custom_oracle_params.output_decls.keys()
         ):
-            raise ValueError("Oracle IO names must be identical")
+            raise ClassiqValueError("Oracle IO names must be identical")
         if any(
             custom_oracle_params.output_decls[name].size != input_decl.size
             for name, input_decl in custom_oracle_params.input_decls.items()
         ):
-            raise ValueError("Oracle IO sizes must be identical")
+            raise ClassiqValueError("Oracle IO sizes must be identical")
         return custom_oracle_params
 
     def _get_register_transputs(self) -> ArithmeticIODict:

classiq/interface/generator/oracles/oracle_abc.py

@@ -60,10 +60,10 @@ class OracleABC(abc.ABC, FunctionParams, Generic[ProblemResultType]):
         pass
 
     def variables(self) -> List[RegisterUserInput]:
-        return list(
+        return [
             RegisterUserInput.from_arithmetic_info(info=info, name=name)
             for name, info in self._inputs.items()
-        )
+        ]
 
     def _check_indices(self, indices: IOQubitMapping) -> None:
         if set(indices.keys()) != {reg.name for reg in self.variables()}:

classiq/interface/generator/qpe.py

@@ -65,7 +65,7 @@ class ExponentiationSpecification(pydantic.BaseModel):
         cls, values: Dict[str, Any]
     ) -> Dict[str, Any]:
         if values.get("scaling") is None and values.get("max_depths") is None:
-            raise ValueError("At least one specification must be provided.")
+            raise ClassiqValueError("At least one specification must be provided.")
         return values
 
 
@@ -131,7 +131,7 @@ class PhaseEstimation(FunctionParams):
         if not unitary_params.is_powerable():
             if isinstance(unitary_params, CustomFunction):
                 raise ClassiqMismatchIOsError(CUSTOM_FUNCTIONS_IO_MISMATCH_ERROR)
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Phase estimation of {unitary_params.discriminator()} is currently not supported."
             )
         return unitary_params
@@ -146,11 +146,13 @@ class PhaseEstimation(FunctionParams):
             return exponentiation_specification
         unitary_params = values.get("unitary_params")
         if not isinstance(unitary_params, Exponentiation):
-            raise ValueError(
+            raise ClassiqValueError(
                 "exponentiation_specification is only valid for Exponentiation unitary_params."
             )
         if exponentiation_specification.max_depths is not None and len(
             exponentiation_specification.max_depths
         ) != values.get("size"):
-            raise ValueError("Length of max_depths must match the provided size.")
+            raise ClassiqValueError(
+                "Length of max_depths must match the provided size."
+            )
         return exponentiation_specification

classiq/interface/generator/qsvm.py

@@ -12,10 +12,9 @@ from classiq.interface.generator.function_params import (
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
-from classiq.interface.helpers.pydantic_model_helpers import get_discriminator_field
 
 from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqQSVMError
+from classiq.exceptions import ClassiqQSVMError, ClassiqValueError
 
 VALID_PAULI_LETTERS = ("I", "X", "Y", "Z")
 
@@ -36,9 +35,7 @@ class QSVMFeatureMapDimensional(HashablePydanticBaseModel):
 
 
 class QSVMFeatureMapPauli(QSVMFeatureMapDimensional):
-    map_type: Literal["pauli_feature_map"] = get_discriminator_field(
-        "pauli_feature_map"
-    )
+    map_type: Literal["pauli_feature_map"] = pydantic.Field(default="pauli_feature_map")
     reps: int = 2
     entanglement: QSVMFeatureMapEntanglement = QSVMFeatureMapEntanglement.LINEAR
     alpha: float = 2.0
@@ -51,15 +48,15 @@ class QSVMFeatureMapPauli(QSVMFeatureMapDimensional):
         # iterate every letter in every string in the list of paulis
         for s in paulis:
             if not all(map(VALID_PAULI_LETTERS.__contains__, s.upper())):
-                raise ValueError(
+                raise ClassiqValueError(
                     f"Invalid pauli string given: {s!r}. Expecting a combination of {VALID_PAULI_LETTERS}"
                 )
         return list(map(str.upper, paulis))
 
 
 class QSVMFeatureMapBlochSphere(QSVMFeatureMapDimensional):
-    map_type: Literal["bloch_sphere_feature_map"] = get_discriminator_field(
-        "bloch_sphere_feature_map"
+    map_type: Literal["bloch_sphere_feature_map"] = pydantic.Field(
+        default="bloch_sphere_feature_map"
     )
 
 

classiq/interface/generator/quantum_function_call.py

@@ -24,6 +24,7 @@ from pydantic import BaseModel, Extra
 
 from classiq.interface.generator import function_param_list, function_params as f_params
 from classiq.interface.generator.arith.arithmetic import Arithmetic
+from classiq.interface.generator.compiler_keywords import EXPANDED_KEYWORD
 from classiq.interface.generator.control_state import ControlState
 from classiq.interface.generator.function_params import (
     NAME_REGEX,
@@ -79,7 +80,7 @@ class WirePair(HashablePydanticBaseModel):
     out_wire: WireName
 
 
-SUFFIX_RANDOMIZER = random.Random()  # nosec B311
+SUFFIX_RANDOMIZER = random.Random()  # noqa: S311
 
 
 def split_wire_pair_to_wires(
@@ -90,8 +91,7 @@ def split_wire_pair_to_wires(
 
 def randomize_suffix(suffix_len: int = DEFAULT_SUFFIX_LEN) -> str:
     return "".join(
-        SUFFIX_RANDOMIZER.choice(_ALPHANUM_CHARACTERS)
-        for _ in range(suffix_len)  # nosec B311
+        SUFFIX_RANDOMIZER.choice(_ALPHANUM_CHARACTERS) for _ in range(suffix_len)
     )
 
 
@@ -218,20 +218,23 @@ class SynthesisQuantumFunctionCall(BaseModel):
         if name is not None:
             match = re.fullmatch(pattern=NAME_REGEX, string=name)
             if match is None:
-                raise ValueError(BAD_CALL_NAME_ERROR_MSG)
+                raise ClassiqValueError(BAD_CALL_NAME_ERROR_MSG)
             return name
 
         function = values.get("function")
 
         params = values.get("function_params")
-        if isinstance(params, CustomFunction):
-            if function == CustomFunction.discriminator() and params.name != "":
-                function = params.name
+        if (
+            isinstance(params, CustomFunction)
+            and function == CustomFunction.discriminator()
+            and params.name != ""
+        ):
+            function = params.name
 
         suffix = f"{SUFFIX_MARKER}_{randomize_suffix()}"
         if not function or params is None:
             return name if name else suffix
-        return f"{function}_{suffix}"
+        return f"{function.split(f'_{EXPANDED_KEYWORD}')[0]}_{suffix}"
 
     @pydantic.root_validator(pre=True)
     def validate_composite_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -285,7 +288,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         if invalid_slicings:
             error_msg.append(f"{BAD_INPUT_SLICING_MSG}: {invalid_slicings}")
         if error_msg:
-            raise ValueError("\n".join(error_msg))
+            raise ClassiqValueError("\n".join(error_msg))
 
     @pydantic.validator("strict_zero_ios")
     def _validate_arithmetic_cannot_strict_zero_ios(
@@ -352,7 +355,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
             if not SynthesisQuantumFunctionCall._register_validate_slices(
                 slices_dict[name], widths[name]
             ):
-                raise ValueError(BAD_INPUT_SLICING_MSG)
+                raise ClassiqValueError(BAD_INPUT_SLICING_MSG)
 
     @staticmethod
     def _register_validate_slices(slices: List[slice], reg_width: int) -> bool:
@@ -384,7 +387,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
             return dict()
         if isinstance(params, CustomFunction):
             if not isinstance(inputs, dict):
-                raise ValueError(CUSTOM_FUNCTION_SINGLE_IO_ERROR)
+                raise ClassiqValueError(CUSTOM_FUNCTION_SINGLE_IO_ERROR)
             return inputs
 
         if isinstance(inputs, str):
@@ -442,7 +445,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         if invalid_slicings:
             error_msg.append(f"{BAD_OUTPUT_SLICING_MSG}: {invalid_slicings}")
         if error_msg:
-            raise ValueError("\n".join(error_msg))
+            raise ClassiqValueError("\n".join(error_msg))
 
     @pydantic.validator("outputs")
     def _validate_outputs(cls, outputs: IOType, values: Dict[str, Any]) -> IOType:
@@ -454,7 +457,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
             return outputs
         if isinstance(params, CustomFunction):
             if not isinstance(outputs, dict):
-                raise ValueError(CUSTOM_FUNCTION_SINGLE_IO_ERROR)
+                raise ClassiqValueError(CUSTOM_FUNCTION_SINGLE_IO_ERROR)
             return outputs
 
         if isinstance(outputs, str):
@@ -494,7 +497,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         if power != 1 and not function_params.is_powerable(
             values.get("strict_zero_ios")
         ):
-            raise ValueError("Cannot power this operator")
+            raise ClassiqValueError("Cannot power this operator")
         return power
 
     @staticmethod
@@ -519,7 +522,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
             io_wire=io_wire,
             function_name=type(params).__name__,
         )
-        raise ValueError(error_message)
+        raise ClassiqValueError(error_message)
 
     @staticmethod
     def _get_invalid_ios(
@@ -610,7 +613,9 @@ class SynthesisQuantumFunctionCall(BaseModel):
             control_state.name in self.inputs_dict
             or control_state.name in self.outputs_dict
         ):
-            raise ValueError(f"Control name: {control_state.name} already exists")
+            raise ClassiqValueError(
+                f"Control name: {control_state.name} already exists"
+            )
 
         inputs, outputs = dict(self.inputs_dict), dict(self.outputs_dict)
         inputs.update({control_state.name: input_wire})

classiq/interface/generator/{generated_circuit.py → quantum_program.py}

@@ -6,7 +6,7 @@ from typing import Dict, List, Optional, Tuple, Union
 import pydantic
 from typing_extensions import TypeAlias
 
-from classiq.interface.executor import quantum_program
+from classiq.interface.executor import quantum_code
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.register_initialization import RegisterInitialization
 from classiq.interface.generator.circuit_code.circuit_code import CircuitCodeInterface
@@ -21,7 +21,7 @@ from classiq.interface.generator.generated_circuit_data import (
     GeneratedCircuitData,
 )
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
-from classiq.interface.generator.model.model import ExecutionModel, SynthesisModel
+from classiq.interface.generator.model.model import ExecutionModel
 from classiq.interface.generator.synthesis_metadata.synthesis_duration import (
     SynthesisStepDurations,
 )
@@ -51,11 +51,11 @@ def get_uuid_as_str() -> str:
     return str(uuid.uuid4())
 
 
-class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
+class QuantumProgram(VersionedModel, CircuitCodeInterface):
     hardware_data: SynthesisHardwareData
     initial_values: Optional[InitialConditions]
     data: GeneratedCircuitData
-    model: SynthesisModel
+    model: ExecutionModel
     transpiled_circuit: Optional[TranspiledCircuitData]
     creation_time: str = pydantic.Field(default_factory=datetime.utcnow().isoformat)
     synthesis_duration: Optional[SynthesisStepDurations]
@@ -81,15 +81,15 @@ class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
         )
         return self.program_circuit.get_code(instruction_set), instruction_set
 
-    def to_base_program(self) -> quantum_program.QuantumBaseProgram:
+    def to_base_program(self) -> quantum_code.QuantumBaseCode:
         code, syntax = self._default_program_code()
-        return quantum_program.QuantumBaseProgram(code=code, syntax=syntax)
+        return quantum_code.QuantumBaseCode(code=code, syntax=syntax)
 
     def to_program(
         self,
         initial_values: Optional[InitialConditions] = None,
         instruction_set: Optional[QuantumInstructionSet] = None,
-    ) -> quantum_program.QuantumProgram:
+    ) -> quantum_code.QuantumCode:
         initial_values = initial_values or self.initial_values
 
         if instruction_set is not None:
@@ -106,7 +106,7 @@ class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
             )
         else:
             registers_initialization = None
-        return quantum_program.QuantumProgram(
+        return quantum_code.QuantumCode(
             code=code,
             syntax=syntax,
             output_qubits_map=self.data.qubit_mapping.physical_outputs,
@@ -136,7 +136,7 @@ class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
 
     def save_results(self, filename: Optional[Union[str, Path]] = None) -> None:
         """
-        Saves generated circuit results as json.
+        Saves quantum program results as json.
             Parameters:
                 filename (Union[str, Path]): Optional, path + filename of file.
                                              If filename supplied add `.json` suffix.
@@ -151,7 +151,7 @@ class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
             file.write(self.json(indent=4))
 
     @classmethod
-    def from_qprog(cls, qprog: str) -> "GeneratedCircuit":
+    def from_qprog(cls, qprog: str) -> "QuantumProgram":
         return cls.parse_raw(qprog)
 
     @property
@@ -165,7 +165,3 @@ class GeneratedCircuit(VersionedModel, CircuitCodeInterface):
             if self.transpiled_circuit and self._can_use_transpiled_code
             else self
         )
-
-    @property
-    def execution_model(self) -> ExecutionModel:
-        return self.model.classical_model()

classiq/interface/generator/range_types.py

@@ -4,6 +4,8 @@ from typing import Any, Dict, Generic, Optional, TypeVar
 import pydantic
 from pydantic.generics import GenericModel
 
+from classiq.exceptions import ClassiqValueError
+
 RangeType = TypeVar("RangeType", int, float)
 
 # math.isclose is symmetric and well equipped to avoid unwanted scenarios while numpy's isn't
@@ -30,7 +32,7 @@ class Range(GenericModel, Generic[RangeType]):
             and upper_bound is not None
             and lower_bound > upper_bound
         ):
-            raise ValueError("lower bound must not be greater than upper bound")
+            raise ClassiqValueError("lower bound must not be greater than upper bound")
 
         return values
 

classiq/interface/generator/slice_parsing_utils.py

@@ -3,6 +3,8 @@ from typing import Match, Optional, Tuple
 
 from classiq.interface.generator.function_params import NAME_REGEX
 
+from classiq.exceptions import ClassiqValueError
+
 NAME = "name"
 SLICING = "slicing"
 SEPARATOR = ":"
@@ -33,9 +35,12 @@ def get_slice(slicing: Optional[str]) -> slice:
 
     if len(split) == 1:
         index_block = split[0]
-        # failing int raises ValueError which Pydantic captures
-        # RegEx matching should deem this scenario impossible
-        index = int(index_block)
+        try:
+            index = int(index_block)
+        except ValueError:
+            raise ClassiqValueError(
+                f"Index {index_block!r} is not an integer"
+            ) from None
         stop = index + 1 if index != -1 else None
         return slice(index, stop, None)
 

classiq/interface/generator/standard_gates/controlled_standard_gates.py

@@ -9,6 +9,8 @@ from classiq.interface.generator.standard_gates.standard_gates import (
     _StandardGate,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 CONTROLLED_GATE_CONTROL: str = "CTRL"
 CONTROLLED_GATE_TARGET: str = DEFAULT_STANDARD_GATE_ARG_NAME
 DEFAULT_NUM_CTRL_QUBITS: int = 1
@@ -58,12 +60,12 @@ class ControlledGateWithState(ControlledGate):  # type: ignore[misc]
         ctrl_state = ctrl_state if ctrl_state is not None else "1" * num_ctrl_qubits
 
         if isinstance(ctrl_state, str) and len(ctrl_state) != num_ctrl_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Invalid control state: {ctrl_state!r}. "
                 f"Expected {num_ctrl_qubits} qubits"
             )
         elif isinstance(ctrl_state, int) and ctrl_state >= 2**num_ctrl_qubits:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Invalid control state: {ctrl_state}. "
                 f"Expected value between 0 and {2**num_ctrl_qubits-1}"
             )

classiq/interface/generator/state_preparation/metrics.py

@@ -5,6 +5,7 @@ from classiq.interface.generator.preferences.optimization import (
 )
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 _AMPLITUDE_SUPPORTING_METRICS: FrozenSet = frozenset(
     {"L2", "L1", "MAX_PROBABILITY", "TOTAL_VARIATION"}
@@ -30,7 +31,7 @@ class Metrics(StrEnum):
         try:
             return Metrics(sp_opt_method.value)
         except ValueError:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Failed to convert {sp_opt_method} to an error metric"
             ) from None
 

classiq/interface/generator/state_preparation/state_preparation.py

@@ -21,6 +21,8 @@ from classiq.interface.generator.validations.validator_functions import (
     validate_amplitudes,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 
 class StatePreparation(StatePreparationABC):
     amplitudes: Optional[Amplitudes] = pydantic.Field(
@@ -46,7 +48,7 @@ class StatePreparation(StatePreparationABC):
         if amplitudes.ndim == 1:
             return validate_amplitudes(tuple(amplitudes))
 
-        raise ValueError(
+        raise ClassiqValueError(
             "Invalid amplitudes were given, please ensure the amplitude is a vector of float in the form of either tuple or list or numpy array"
         )
 
@@ -64,7 +66,7 @@ class StatePreparation(StatePreparationABC):
         if probabilities.ndim == 1:
             return PMF(pmf=probabilities.tolist())
 
-        raise ValueError(
+        raise ClassiqValueError(
             "Invalid probabilities were given, please ensure the probabilities is a vector of float in the form of either tuple or list or numpy array"
         )
 
@@ -80,7 +82,7 @@ class StatePreparation(StatePreparationABC):
             if not Metrics(metric).supports_amplitudes
         }
         if unsupported_metrics:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"{unsupported_metrics} are not supported for amplitude preparation"
             )
         return error_metric
@@ -93,7 +95,7 @@ class StatePreparation(StatePreparationABC):
         amplitudes = values.get("amplitudes")
         probabilities = values.get("probabilities")
         if amplitudes is not None and probabilities is not None:
-            raise ValueError(
+            raise ClassiqValueError(
                 "StatePreparation can't get both probabilities and amplitudes"
             )
         return values
@@ -102,5 +104,5 @@ class StatePreparation(StatePreparationABC):
     def num_state_qubits(self) -> int:
         distribution = self.probabilities or self.amplitudes
         if distribution is None:
-            raise ValueError("Must have either probabilities or amplitudes")
+            raise ClassiqValueError("Must have either probabilities or amplitudes")
         return num_of_qubits(distribution)

classiq/interface/generator/state_propagator.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import Any, Dict, List
 
 import numpy as np
 import pydantic
@@ -11,6 +11,8 @@ from classiq.interface.generator.function_params import (
     DEFAULT_OUTPUT_NAME,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 
 class StatePropagator(function_params.FunctionParams):
     """
@@ -33,16 +35,25 @@ class StatePropagator(function_params.FunctionParams):
     )
 
     @pydantic.validator("start_state_vector", always=True)
-    def validate_start_state(cls, start_state_vector, values):
+    def validate_start_state(
+        cls, start_state_vector: List[Complex], values: Dict[str, Any]
+    ) -> List[Complex]:
         end_state_vector = values.get("end_state_vector")
+        if end_state_vector is None:
+            raise ClassiqValueError(
+                "Cannot validate start_start_vector without end_state_vector"
+            )
+
         num_qubits = cls._num_qubits(end_state_vector)
         if len(start_state_vector) == 0:
-            default_start_state_vector = [0.0 for _ in range(2**num_qubits)]
-            default_start_state_vector[0] = 1.0
+            default_start_state_vector = [Complex(0.0) for _ in range(2**num_qubits)]
+            default_start_state_vector[0] = Complex(1.0)
             start_state_vector = default_start_state_vector
 
         if len(start_state_vector) != len(end_state_vector):
-            raise ValueError("Start and end state vectors are of non-equal length")
+            raise ClassiqValueError(
+                "Start and end state vectors are of non-equal length"
+            )
 
         return start_state_vector
 

classiq/interface/generator/types/builtin_struct_declarations/__init__.py

@@ -1,2 +1 @@
 from .pauli_struct_declarations import *  # noqa: F403
-from .qaoa_declarations import *  # noqa: F403