classiq 0.104.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

classiq/execution/functions/sample.py

@@ -1,207 +1,26 @@
-from collections.abc import Callable
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING, Any
+
+from classiq.execution.functions.util.backend_preferences import (
+    _get_backend_preferences_from_specifier,
+)
 
 if TYPE_CHECKING:
     from pandas import DataFrame
 
-from classiq.interface.backend.backend_preferences import (
-    AliceBobBackendPreferences,
-    AQTBackendPreferences,
-    AwsBackendPreferences,
-    AzureBackendPreferences,
-    AzureCredential,
-    BackendPreferencesTypes,
-    ClassiqBackendPreferences,
-    GCPBackendPreferences,
-    IBMBackendPreferences,
-    IntelBackendPreferences,
-    IonqBackendPreferences,
-)
 from classiq.interface.backend.provider_config.provider_config import ProviderConfig
-from classiq.interface.backend.provider_config.providers.alice_bob import AliceBobConfig
-from classiq.interface.backend.provider_config.providers.aqt import AQTConfig
-from classiq.interface.backend.provider_config.providers.azure import AzureConfig
-from classiq.interface.backend.provider_config.providers.braket import BraketConfig
-from classiq.interface.backend.provider_config.providers.ibm import IBMConfig
-from classiq.interface.backend.provider_config.providers.ionq import IonQConfig
-from classiq.interface.backend.quantum_backend_providers import (
-    ClassiqNvidiaBackendNames,
-    ClassiqSimulatorBackendNames,
-)
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.model.preferences import create_random_seed
 from classiq.interface.generator.model.preferences.preferences import (
     TranspilationOption,
 )
-from classiq.interface.hardware import Provider
 
 from classiq import (
     ExecutionParams,
     QuantumProgram,
 )
 from classiq.execution import ExecutionSession
-from classiq.execution.functions._logging import _logger
-from classiq.execution.functions.constants import Verbosity
-from classiq.execution.functions.parse_provider_backend import (
-    _PROVIDER_TO_CANONICAL_NAME,
-    _parse_provider_backend,
-)
-
-
-@dataclass
-class _ProviderConfigToBackendPrefSpec:
-    backend_preferences_class: type[BackendPreferencesTypes]
-    config_class: type[ProviderConfig] | None = None
-    # Maps the config dict (either passed in directly or dumped from config class) to a
-    # dict that we can load into the given BackendPreferences class. This is in case
-    # we need to rename fields or change structure.
-    config_dict_to_backend_preferences_dict: (
-        Callable[[dict[str, Any]], dict[str, Any]] | None
-    ) = None
-    # Maps from SDK names to names our backend recognizes, raising a useful error
-    # if the name is unrecognized.
-    backend_name_mapper: Callable[[str], str] | None = None
-
-
-def _classiq_backend_name_mapper(backend_name: str) -> str:
-    backend_name = backend_name.lower()
-    if backend_name in [
-        ClassiqSimulatorBackendNames.SIMULATOR,
-        ClassiqSimulatorBackendNames.SIMULATOR_MATRIX_PRODUCT_STATE,
-        ClassiqSimulatorBackendNames.SIMULATOR_DENSITY_MATRIX,
-    ]:
-        return backend_name
-    if backend_name == "nvidia_simulator":
-        return ClassiqNvidiaBackendNames.SIMULATOR
-    if any(keyword in backend_name for keyword in ["gpu", "nvidia"]):
-        suggested_backend_name = "nvidia_simulator"
-    else:
-        suggested_backend_name = "simulator"
-    raise ValueError(
-        f"Unsupported backend name {backend_name}. Did you mean '{suggested_backend_name}'?"
-    )
-
-
-def _ibm_backend_name_mapper(backend_name: str) -> str:
-    ibm_prefix: Literal["ibm_"] = "ibm_"
-    backend_name = backend_name.lower()
-    if backend_name.startswith(ibm_prefix):
-        backend_name_no_prefix = backend_name.removeprefix(ibm_prefix)
-        raise ValueError(
-            f"IBM backend names shouldn't start with ibm_. Try 'ibm/{backend_name_no_prefix}'."
-        )
-    return ibm_prefix + backend_name
-
-
-def _azure_config_dict_to_backend_preferences_dict(
-    config_dict: dict[str, Any],
-) -> dict[str, Any]:
-    if "location" not in config_dict:
-        raise ValueError("Azure config must have 'location' property")
-    credentials = None
-    if all(
-        config_dict.get(key) is not None
-        for key in ["tenant_id", "client_id", "client_secret", "resource_id"]
-    ):
-        credentials = AzureCredential.model_validate(
-            {
-                "tenant_id": config_dict["tenant_id"],
-                "client_id": config_dict["client_id"],
-                "client_secret": config_dict["client_secret"],
-                "resource_id": config_dict["resource_id"],
-            }
-        )
-    return {
-        "location": config_dict["location"],
-        "credentials": credentials,
-        "ionq_error_mitigation_flag": config_dict.get("ionq_error_mitigation"),
-    }
-
-
-def _braket_config_dict_to_backend_preferences_dict(
-    config_dict: dict[str, Any],
-) -> dict[str, Any]:
-    config_dict["aws_access_key_id"] = config_dict.pop("braket_access_key_id", None)
-    config_dict["aws_secret_access_key"] = config_dict.pop(
-        "braket_secret_access_key", None
-    )
-    return config_dict
-
-
-_PROVIDER_CONFIG_TO_BACKEND_PREFERENCES_SPEC = {
-    Provider.CLASSIQ: _ProviderConfigToBackendPrefSpec(
-        backend_preferences_class=ClassiqBackendPreferences,
-        backend_name_mapper=_classiq_backend_name_mapper,
-    ),
-    Provider.GOOGLE: _ProviderConfigToBackendPrefSpec(
-        backend_preferences_class=GCPBackendPreferences
-    ),
-    Provider.INTEL: _ProviderConfigToBackendPrefSpec(
-        backend_preferences_class=IntelBackendPreferences
-    ),
-    Provider.IBM_QUANTUM: _ProviderConfigToBackendPrefSpec(
-        backend_preferences_class=IBMBackendPreferences,
-        config_class=IBMConfig,
-        backend_name_mapper=_ibm_backend_name_mapper,
-    ),
-    Provider.AMAZON_BRAKET: _ProviderConfigToBackendPrefSpec(
-        backend_preferences_class=AwsBackendPreferences,
-        config_dict_to_backend_preferences_dict=_braket_config_dict_to_backend_preferences_dict,
-        config_class=BraketConfig,
-    ),
-    Provider.IONQ: _ProviderConfigToBackendPrefSpec(
-        backend_preferences_class=IonqBackendPreferences,
-        config_class=IonQConfig,
-    ),
-    Provider.ALICE_AND_BOB: _ProviderConfigToBackendPrefSpec(
-        backend_preferences_class=AliceBobBackendPreferences,
-        config_class=AliceBobConfig,
-    ),
-    Provider.AQT: _ProviderConfigToBackendPrefSpec(
-        backend_preferences_class=AQTBackendPreferences,
-        config_class=AQTConfig,
-    ),
-    Provider.AZURE_QUANTUM: _ProviderConfigToBackendPrefSpec(
-        backend_preferences_class=AzureBackendPreferences,
-        config_dict_to_backend_preferences_dict=_azure_config_dict_to_backend_preferences_dict,
-        config_class=AzureConfig,
-    ),
-}
-
-
-def _get_backend_preferences_from_specifier(
-    backend_spec: str, config: dict[str, Any] | ProviderConfig
-) -> BackendPreferencesTypes:
-    provider, backend_name = _parse_provider_backend(backend_spec)
-
-    if provider not in _PROVIDER_CONFIG_TO_BACKEND_PREFERENCES_SPEC:
-        raise NotImplementedError(
-            f"Unsupported provider '{_PROVIDER_TO_CANONICAL_NAME.get(provider) or provider}'"
-        )
-
-    provider_spec = _PROVIDER_CONFIG_TO_BACKEND_PREFERENCES_SPEC[provider]
-    if isinstance(config, ProviderConfig):
-        if provider_spec.config_class is None:
-            raise ValueError(
-                f"This provider does not support any ProviderConfig classes. Received '{config.__class__.__name__}'"
-            )
-        if not isinstance(config, provider_spec.config_class):
-            raise ValueError(
-                f"{_PROVIDER_TO_CANONICAL_NAME[provider]} devices require {provider_spec.config_class.__name__}, got {config.__class__.__name__}"
-            )
-        config_dict = config.model_dump()
-    else:
-        config_dict = config
-    if provider_spec.backend_name_mapper is not None:
-        backend_name = provider_spec.backend_name_mapper(backend_name)
-
-    if provider_spec.config_dict_to_backend_preferences_dict is not None:
-        config_dict = provider_spec.config_dict_to_backend_preferences_dict(config_dict)
-
-    config_dict["backend_name"] = backend_name
-    return provider_spec.backend_preferences_class.model_validate(config_dict)
-
+from classiq.execution.functions.util._logging import _logger
+from classiq.execution.functions.util.constants import Verbosity
 
 _DEFAULT_BACKEND_NAME = "simulator"
 
@@ -222,7 +41,7 @@ def _new_sample(
 
     Args:
         qprog: The quantum program
-        backend: The device (hardware or simulator) on which to run the quantum program. Specified as "provider/device_id"
+        backend: The device (hardware or simulator) on which to run the quantum program. Specified as "provider/device_id". Use the `get_backend_details` function to see supported devices.
         parameters: The classical parameters for the quantum program
         config: Provider-specific configuration, such as api keys
         num_shots: The number of times to sample

classiq/execution/functions/state_vector.py

@@ -0,0 +1,113 @@
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
+from classiq.interface.backend.backend_preferences import (
+    BackendPreferencesTypes,
+    ClassiqBackendPreferences,
+    GCPBackendPreferences,
+)
+from classiq.interface.backend.quantum_backend_providers import (
+    ClassiqNvidiaBackendNames,
+    ClassiqSimulatorBackendNames,
+    GoogleNvidiaBackendNames,
+)
+from classiq.interface.executor.execution_preferences import ExecutionPreferences
+from classiq.interface.generator.model.preferences import create_random_seed
+from classiq.interface.generator.model.preferences.preferences import (
+    TranspilationOption,
+)
+from classiq.interface.hardware import Provider
+
+from classiq import (
+    ExecutionParams,
+    QuantumProgram,
+)
+from classiq.execution import ExecutionSession
+from classiq.execution.functions.util._logging import _logger
+from classiq.execution.functions.util.constants import Verbosity
+from classiq.execution.functions.util.parse_provider_backend import (
+    _PROVIDER_TO_CANONICAL_NAME,
+    _parse_provider_backend,
+)
+
+_DEFAULT_STATE_VECTOR_BACKEND_NAME = "simulator"
+
+
+def _calculate_state_vector(
+    qprog: QuantumProgram,
+    backend: str | None = None,
+    *,
+    parameters: ExecutionParams | None = None,
+    filters: dict[str, Any] | None = None,
+    random_seed: int | None = None,
+    transpilation_option: TranspilationOption = TranspilationOption.DECOMPOSE,
+    verbosity: Verbosity = Verbosity.INFO,
+) -> "DataFrame":
+    """
+    Calculate the state vector of a quantum program.
+
+    Args:
+        qprog: The quantum program
+        backend: The simulator on which to simulate the quantum program. Specified as "provider/device_id"
+        parameters: The classical parameters for the quantum program
+        filters: Only states where the variables match these values will be included in the state vector.
+        random_seed: The random seed used for transpilation and simulation
+        transpilation_option: Advanced configuration for hardware-specific transpilation
+        verbosity: What level of information should be logged
+
+    Returns: A dataframe containing the state vector
+    """
+    if backend is None:
+        backend = _DEFAULT_STATE_VECTOR_BACKEND_NAME
+
+    provider, raw_backend_name = _parse_provider_backend(backend)
+    backend_name_lower = raw_backend_name.lower()
+    backend_preferences: BackendPreferencesTypes
+
+    if provider == Provider.CLASSIQ:
+        if backend_name_lower == "simulator":
+            backend_name = str(ClassiqSimulatorBackendNames.SIMULATOR_STATEVECTOR)
+        elif backend_name_lower == "nvidia_simulator":
+            backend_name = str(ClassiqNvidiaBackendNames.SIMULATOR_STATEVECTOR)
+        else:
+            raise ValueError(
+                f"Unsupported backend '{backend}'. "
+                "Under the Classiq provider, only 'classiq/simulator' and 'classiq/nvidia_simulator' are supported."
+            )
+        backend_preferences = ClassiqBackendPreferences(backend_name=backend_name)
+    elif provider == Provider.GOOGLE:
+        if backend_name_lower == "cuquantum":
+            backend_name = str(GoogleNvidiaBackendNames.CUQUANTUM_STATEVECTOR)
+        else:
+            raise ValueError(
+                f"Unsupported backend '{backend}'. "
+                "Under the Google provider, only 'google/cuquantum' is supported."
+            )
+        backend_preferences = GCPBackendPreferences(backend_name=backend_name)
+    else:
+        raise ValueError(
+            f"Provider '{_PROVIDER_TO_CANONICAL_NAME.get(provider) or provider}' does not support this operation."
+        )
+
+    ep = ExecutionPreferences(
+        backend_preferences=backend_preferences,
+        random_seed=create_random_seed() if random_seed is None else random_seed,
+        transpile_to_hardware=transpilation_option,
+    )
+    if verbosity != Verbosity.QUIET:
+        _logger.info(f"Submitting job to {backend}")
+    with ExecutionSession(qprog, execution_preferences=ep) as session:
+        if filters is not None:
+            for output_name, value in filters.items():
+                session.set_measured_state_filter(
+                    output_name, lambda state, val=value: state == val
+                )
+        job = session.submit_sample(parameters)
+        if verbosity != Verbosity.QUIET:
+            _logger.info(f"Job id: {job.id}")
+        result = job.get_sample_result()
+
+    df = result.dataframe
+    return df

classiq/execution/functions/util/backend_preferences.py

@@ -0,0 +1,188 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Literal
+
+from classiq.interface.backend.backend_preferences import (
+    AliceBobBackendPreferences,
+    AQTBackendPreferences,
+    AwsBackendPreferences,
+    AzureBackendPreferences,
+    AzureCredential,
+    BackendPreferencesTypes,
+    ClassiqBackendPreferences,
+    GCPBackendPreferences,
+    IBMBackendPreferences,
+    IntelBackendPreferences,
+    IonqBackendPreferences,
+)
+from classiq.interface.backend.provider_config.provider_config import ProviderConfig
+from classiq.interface.backend.provider_config.providers.alice_bob import AliceBobConfig
+from classiq.interface.backend.provider_config.providers.aqt import AQTConfig
+from classiq.interface.backend.provider_config.providers.azure import AzureConfig
+from classiq.interface.backend.provider_config.providers.braket import BraketConfig
+from classiq.interface.backend.provider_config.providers.ibm import IBMConfig
+from classiq.interface.backend.provider_config.providers.ionq import IonQConfig
+from classiq.interface.backend.quantum_backend_providers import (
+    ClassiqNvidiaBackendNames,
+    ClassiqSimulatorBackendNames,
+)
+from classiq.interface.hardware import Provider
+
+from classiq.execution.functions.util.parse_provider_backend import (
+    _PROVIDER_TO_CANONICAL_NAME,
+    _parse_provider_backend,
+)
+
+
+@dataclass
+class _ProviderConfigToBackendPrefSpec:
+    backend_preferences_class: type[BackendPreferencesTypes]
+    config_class: type[ProviderConfig] | None = None
+    # Maps the config dict (either passed in directly or dumped from config class) to a
+    # dict that we can load into the given BackendPreferences class. This is in case
+    # we need to rename fields or change structure.
+    config_dict_to_backend_preferences_dict: (
+        Callable[[dict[str, Any]], dict[str, Any]] | None
+    ) = None
+    # Maps from SDK names to names our backend recognizes, raising a useful error
+    # if the name is unrecognized.
+    backend_name_mapper: Callable[[str], str] | None = None
+
+
+def _classiq_backend_name_mapper(backend_name: str) -> str:
+    backend_name = backend_name.lower()
+    if backend_name in [
+        ClassiqSimulatorBackendNames.SIMULATOR,
+        ClassiqSimulatorBackendNames.SIMULATOR_MATRIX_PRODUCT_STATE,
+        ClassiqSimulatorBackendNames.SIMULATOR_DENSITY_MATRIX,
+    ]:
+        return backend_name
+    if backend_name == "nvidia_simulator":
+        return ClassiqNvidiaBackendNames.SIMULATOR
+    if any(keyword in backend_name for keyword in ["gpu", "nvidia"]):
+        suggested_backend_name = "nvidia_simulator"
+    else:
+        suggested_backend_name = "simulator"
+    raise ValueError(
+        f"Unsupported backend name {backend_name}. Did you mean '{suggested_backend_name}'?"
+    )
+
+
+def _ibm_backend_name_mapper(backend_name: str) -> str:
+    ibm_prefix: Literal["ibm_"] = "ibm_"
+    backend_name = backend_name.lower()
+    if backend_name.startswith(ibm_prefix):
+        backend_name_no_prefix = backend_name.removeprefix(ibm_prefix)
+        raise ValueError(
+            f"IBM backend names shouldn't start with ibm_. Try 'ibm/{backend_name_no_prefix}'."
+        )
+    return ibm_prefix + backend_name
+
+
+def _azure_config_dict_to_backend_preferences_dict(
+    config_dict: dict[str, Any],
+) -> dict[str, Any]:
+    if "location" not in config_dict:
+        raise ValueError("Azure config must have 'location' property")
+    credentials = None
+    if all(
+        config_dict.get(key) is not None
+        for key in ["tenant_id", "client_id", "client_secret", "resource_id"]
+    ):
+        credentials = AzureCredential.model_validate(
+            {
+                "tenant_id": config_dict["tenant_id"],
+                "client_id": config_dict["client_id"],
+                "client_secret": config_dict["client_secret"],
+                "resource_id": config_dict["resource_id"],
+            }
+        )
+    return {
+        "location": config_dict["location"],
+        "credentials": credentials,
+        "ionq_error_mitigation_flag": config_dict.get("ionq_error_mitigation"),
+    }
+
+
+def _braket_config_dict_to_backend_preferences_dict(
+    config_dict: dict[str, Any],
+) -> dict[str, Any]:
+    config_dict["aws_access_key_id"] = config_dict.pop("braket_access_key_id", None)
+    config_dict["aws_secret_access_key"] = config_dict.pop(
+        "braket_secret_access_key", None
+    )
+    return config_dict
+
+
+_PROVIDER_CONFIG_TO_BACKEND_PREFERENCES_SPEC = {
+    Provider.CLASSIQ: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=ClassiqBackendPreferences,
+        backend_name_mapper=_classiq_backend_name_mapper,
+    ),
+    Provider.GOOGLE: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=GCPBackendPreferences
+    ),
+    Provider.INTEL: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=IntelBackendPreferences
+    ),
+    Provider.IBM_QUANTUM: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=IBMBackendPreferences,
+        config_class=IBMConfig,
+        backend_name_mapper=_ibm_backend_name_mapper,
+    ),
+    Provider.AMAZON_BRAKET: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=AwsBackendPreferences,
+        config_dict_to_backend_preferences_dict=_braket_config_dict_to_backend_preferences_dict,
+        config_class=BraketConfig,
+    ),
+    Provider.IONQ: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=IonqBackendPreferences,
+        config_class=IonQConfig,
+    ),
+    Provider.ALICE_AND_BOB: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=AliceBobBackendPreferences,
+        config_class=AliceBobConfig,
+    ),
+    Provider.AQT: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=AQTBackendPreferences,
+        config_class=AQTConfig,
+    ),
+    Provider.AZURE_QUANTUM: _ProviderConfigToBackendPrefSpec(
+        backend_preferences_class=AzureBackendPreferences,
+        config_dict_to_backend_preferences_dict=_azure_config_dict_to_backend_preferences_dict,
+        config_class=AzureConfig,
+    ),
+}
+
+
+def _get_backend_preferences_from_specifier(
+    backend_spec: str, config: dict[str, Any] | ProviderConfig
+) -> BackendPreferencesTypes:
+    provider, backend_name = _parse_provider_backend(backend_spec)
+
+    if provider not in _PROVIDER_CONFIG_TO_BACKEND_PREFERENCES_SPEC:
+        raise NotImplementedError(
+            f"Unsupported provider '{_PROVIDER_TO_CANONICAL_NAME.get(provider) or provider}'"
+        )
+
+    provider_spec = _PROVIDER_CONFIG_TO_BACKEND_PREFERENCES_SPEC[provider]
+    if isinstance(config, ProviderConfig):
+        if provider_spec.config_class is None:
+            raise ValueError(
+                f"This provider does not support any ProviderConfig classes. Received '{config.__class__.__name__}'"
+            )
+        if not isinstance(config, provider_spec.config_class):
+            raise ValueError(
+                f"{_PROVIDER_TO_CANONICAL_NAME[provider]} devices require {provider_spec.config_class.__name__}, got {config.__class__.__name__}"
+            )
+        config_dict = config.model_dump()
+    else:
+        config_dict = config
+    if provider_spec.backend_name_mapper is not None:
+        backend_name = provider_spec.backend_name_mapper(backend_name)
+
+    if provider_spec.config_dict_to_backend_preferences_dict is not None:
+        config_dict = provider_spec.config_dict_to_backend_preferences_dict(config_dict)
+
+    config_dict["backend_name"] = backend_name
+    return provider_spec.backend_preferences_class.model_validate(config_dict)

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.104.0'
+SEMVER_VERSION = '1.0.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/backend/backend_preferences.py

@@ -468,6 +468,70 @@ class SoftbankBackendPreferences(BackendPreferences):
     )
 
 
+class C12BackendPreferences(BackendPreferences):
+    """
+    Represents the backend preferences specific to C12.
+
+    Attributes:
+        backend_name: Name of the requested backend or target.
+        result_format: Result format of the job; one of "counts",
+            "state_vector", or "density_matrix". Defaults to "counts".
+        inilabel: Initial state specified using a binary label format
+            (e.g. "00", "01"). Mutually exclusive with inistatevector.
+        inistatevector: Initial state vector as a comma-separated list of
+            complex values (e.g. "1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j").
+            Mutually exclusive with inilabel.
+        ininoisy: Whether to use noisy initialization of the circuit.
+    """
+
+    backend_service_provider: ProviderTypeVendor.C12 = pydantic.Field(
+        default=ProviderVendor.C12
+    )
+
+    result_format: str = pydantic.Field(
+        default="counts", description="Result format of the job"
+    )
+
+    inilabel: str | None = pydantic.Field(
+        default=None, description="Initial label of the initial state."
+    )
+
+    inistatevector: str | None = pydantic.Field(
+        default=None, description="Initial state vector of the job."
+    )
+
+    ininoisy: bool | None = pydantic.Field(
+        default=None, description="Whether the initial state is noisy."
+    )
+
+    @pydantic.model_validator(mode="after")
+    def _validate_initial_label_statevector(
+        self: C12BackendPreferences,
+    ) -> C12BackendPreferences:
+        if self.inilabel is not None and self.inistatevector is not None:
+            raise ValueError(
+                f"Cannot specify both inilabel and inistatevector.\n"
+                f"inilabel={self.inilabel}, inistatevector={self.inistatevector}"
+            )
+        return self
+
+    @pydantic.field_validator("result_format")
+    @classmethod
+    def _validate_result_format(cls, result_format: str) -> str:
+        if result_format not in ["density_matrix", "state_vector", "counts"]:
+            raise ValueError(f"Invalid result format: {result_format}")
+        return result_format
+
+    @property
+    def parameters(self) -> dict:
+        data = self.model_dump(exclude_none=True)
+        for field in ["inilabel", "inistatevector", "ininoisy"]:
+            if field in data and data[field] is None:
+                data.pop(field)
+
+        return data
+
+
 def is_exact_simulator(backend_preferences: BackendPreferences) -> bool:
     return backend_preferences.backend_name in EXACT_SIMULATORS
 
@@ -501,6 +565,7 @@ BackendPreferencesTypes = Union[
     AQTBackendPreferences,
     CINECABackendPreferences,
     SoftbankBackendPreferences,
+    C12BackendPreferences,
 ]
 
 __all__ = [
@@ -512,6 +577,7 @@ __all__ = [
     "AzureBackendPreferences",
     "AzureCredential",
     "AzureQuantumBackendNames",
+    "C12BackendPreferences",
     "ClassiqBackendPreferences",
     "ClassiqNvidiaBackendNames",
     "ClassiqSimulatorBackendNames",

classiq/interface/backend/quantum_backend_providers.py

@@ -28,6 +28,7 @@ class ProviderVendor(StrEnum):
     AQT = "AQT"
     CINECA = "CINECA"
     SOFTBANK = "Softbank"
+    C12 = "C12"
 
 
 class ProviderTypeVendor:
@@ -43,6 +44,7 @@ class ProviderTypeVendor:
     AQT = Literal[ProviderVendor.AQT]
     CINECA = Literal[ProviderVendor.CINECA]
     SOFTBANK = Literal[ProviderVendor.SOFTBANK]
+    C12 = Literal[ProviderVendor.C12]
 
 
 PROVIDER_NAME_MAPPER = {
@@ -57,6 +59,7 @@ PROVIDER_NAME_MAPPER = {
     ProviderVendor.AQT: "AQT",
     ProviderVendor.CLASSIQ: "CLASSIQ",
     ProviderVendor.SOFTBANK: "SOFTBANK",
+    ProviderVendor.C12: "C12",
 }
 
 
@@ -248,6 +251,11 @@ class OQCBackendNames(StrEnum):
     LUCY = "Lucy"
 
 
+class C12BackendNames(StrEnum):
+    SIMULATOR = "c12sim-iswap"
+    SQUARED = "squared-iswap"
+
+
 EXACT_SIMULATORS = {
     IonqBackendNames.SIMULATOR,
     AzureQuantumBackendNames.IONQ_SIMULATOR,
@@ -258,6 +266,7 @@ EXACT_SIMULATORS = {
     *ClassiqSimulatorBackendNames,
     *IntelBackendNames,
     *ClassiqNvidiaBackendNames,
+    *C12BackendNames,
 }
 
 AllIBMQBackendNames = IBMQHardwareNames
@@ -271,6 +280,7 @@ AllBackendsNameByVendor = Union[
     ClassiqNvidiaBackendNames,
     AliceBobBackendNames,
     OQCBackendNames,
+    C12BackendNames,
 ]
 
 AllBackendsNameEnums = [
@@ -282,4 +292,5 @@ AllBackendsNameEnums = [
     IntelBackendNames,
     ClassiqNvidiaBackendNames,
     OQCBackendNames,
+    C12BackendNames,
 ]

classiq/interface/exceptions.py

@@ -39,10 +39,6 @@ class ClassiqAnalyzerError(ClassiqError):
     pass
 
 
-class ClassiqAnalyzerVisualizationError(ClassiqError):
-    pass
-
-
 class ClassiqAPIError(ClassiqError):
     def __init__(self, message: str, status_code: int | None = None) -> None:
         self.status_code = status_code