classiq 0.40.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

classiq/execution/qnn.py

@@ -0,0 +1,80 @@
+import functools
+from typing import List, Optional
+
+import more_itertools
+
+from classiq.interface.chemistry.operator import PauliOperator
+from classiq.interface.executor.execution_result import (
+    ResultsCollection,
+    SavedResultValueType,
+    TaggedEstimationResult,
+    TaggedExecutionDetails,
+)
+from classiq.interface.executor.quantum_code import Arguments, MultipleArguments
+
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
+    pauli_operator_to_hamiltonian,
+)
+from classiq.execution.execution_session import ExecutionSession
+from classiq.executor import DEFAULT_RESULT_NAME
+from classiq.synthesis import SerializedQuantumProgram
+
+_MAX_ARGUMENTS_SIZE = 1024
+
+
+def _execute_qnn_estimate(
+    session: ExecutionSession,
+    arguments: List[Arguments],
+    observable: PauliOperator,
+) -> ResultsCollection:
+    hamiltonian = pauli_operator_to_hamiltonian(observable.pauli_list)
+    return [
+        TaggedEstimationResult(
+            name=DEFAULT_RESULT_NAME,
+            value=result,
+            value_type=SavedResultValueType.EstimationResult,
+        )
+        for result in session.batch_estimate(
+            hamiltonian=hamiltonian, parameters=arguments
+        )
+    ]
+
+
+def _execute_qnn_sample(
+    session: ExecutionSession,
+    arguments: List[Arguments],
+) -> ResultsCollection:
+    return [
+        TaggedExecutionDetails(
+            name=DEFAULT_RESULT_NAME,
+            value=result,
+            value_type=SavedResultValueType.ExecutionDetails,
+        )
+        for result in session.batch_sample(arguments)
+    ]
+
+
+def execute_qnn(
+    quantum_program: SerializedQuantumProgram,
+    arguments: MultipleArguments,
+    observable: Optional[PauliOperator] = None,
+) -> ResultsCollection:
+    session = ExecutionSession(quantum_program)
+
+    if observable:
+        execute_function = functools.partial(
+            _execute_qnn_estimate,
+            session=session,
+            observable=observable,
+        )
+    else:
+        execute_function = functools.partial(
+            _execute_qnn_sample,
+            session=session,
+        )
+
+    result: ResultsCollection = []
+    for chunk in more_itertools.chunked(arguments, _MAX_ARGUMENTS_SIZE):
+        chunk_result = execute_function(arguments=chunk)
+        result.extend(chunk_result)
+    return result

classiq/executor.py

@@ -1,27 +1,13 @@
 """Executor module, implementing facilities for executing quantum programs using Classiq platform."""
 
-import functools
-from typing import Optional, Tuple, Union
+from typing import Tuple, Union
 
-import more_itertools
 from typing_extensions import TypeAlias
 
 from classiq.interface.backend.backend_preferences import BackendPreferencesTypes
-from classiq.interface.chemistry.operator import PauliOperators
 from classiq.interface.executor.estimation import OperatorsEstimation
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
-from classiq.interface.executor.execution_request import (
-    EstimateOperatorsExecution,
-    ExecutionRequest,
-    QuantumCodeExecution,
-)
-from classiq.interface.executor.execution_result import (
-    ResultsCollection,
-    SavedResultValueType,
-    TaggedEstimationResult,
-    TaggedExecutionDetails,
-)
-from classiq.interface.executor.quantum_code import MultipleArguments, QuantumCode
+from classiq.interface.executor.quantum_code import QuantumCode
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.result import ExecutionDetails
 from classiq.interface.generator.quantum_program import QuantumProgram
@@ -38,7 +24,6 @@ ProgramAndResult: TypeAlias = Tuple[QuantumCode, BatchExecutionResult]
 BackendPreferencesAndResult: TypeAlias = Tuple[
     BackendPreferencesTypes, int, BatchExecutionResult
 ]
-_MAX_ARGUMENTS_SIZE = 1024
 
 
 def _parse_serialized_qprog(
@@ -56,83 +41,6 @@ async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJ
 execute = syncify_function(execute_async)
 
 
-async def _execute_qnn_async_estimate(
-    quantum_program: QuantumCode,
-    execution_preferences: ExecutionPreferences,
-    observables: PauliOperators,
-) -> ResultsCollection:
-    request = ExecutionRequest(
-        execution_payload=EstimateOperatorsExecution(
-            quantum_program=quantum_program,
-            operators=observables,
-        ),
-        preferences=execution_preferences,
-    )
-
-    results = await ApiWrapper.call_execute_estimate(request)
-    return [
-        TaggedEstimationResult(
-            name=DEFAULT_RESULT_NAME,
-            value=result,
-            value_type=SavedResultValueType.EstimationResult,
-        )
-        for result in results
-    ]
-
-
-async def _execute_qnn_async_program(
-    quantum_program: QuantumCode,
-    execution_preferences: ExecutionPreferences,
-) -> ResultsCollection:
-    request = ExecutionRequest(
-        execution_payload=QuantumCodeExecution(**quantum_program.dict()),
-        preferences=execution_preferences,
-    )
-
-    api_result = await ApiWrapper.call_execute_quantum_program(request)
-    return [
-        TaggedExecutionDetails(
-            name=DEFAULT_RESULT_NAME,
-            value=result,
-            value_type=SavedResultValueType.ExecutionDetails,
-        )
-        for result in api_result.details
-    ]
-
-
-async def execute_qnn_async(
-    quantum_program: SerializedQuantumProgram,
-    arguments: MultipleArguments,
-    observables: Optional[PauliOperators] = None,
-) -> ResultsCollection:
-    circuit = _parse_serialized_qprog(quantum_program)
-    execution_preferences = circuit.model.execution_preferences
-
-    legacy_quantum_program = circuit.to_program()
-
-    if observables:
-        execute_function = functools.partial(
-            _execute_qnn_async_estimate,
-            execution_preferences=execution_preferences,
-            observables=observables,
-        )
-    else:
-        execute_function = functools.partial(
-            _execute_qnn_async_program,
-            execution_preferences=execution_preferences,
-        )
-
-    result: ResultsCollection = []
-    for chunk in more_itertools.chunked(arguments, _MAX_ARGUMENTS_SIZE):
-        legacy_quantum_program.arguments = tuple(chunk)
-        chunk_result = await execute_function(quantum_program=legacy_quantum_program)
-        result.extend(chunk_result)
-    return result
-
-
-execute_qnn = syncify_function(execute_qnn_async)
-
-
 def set_quantum_program_execution_preferences(
     quantum_program: SerializedQuantumProgram,
     preferences: ExecutionPreferences,
@@ -142,24 +50,9 @@ def set_quantum_program_execution_preferences(
     return SerializedQuantumProgram(circuit.json())
 
 
-def set_initial_values(
-    quantum_program: SerializedQuantumProgram,
-    **kwargs: int,
-) -> SerializedQuantumProgram:
-    circuit = _parse_serialized_qprog(quantum_program)
-    circuit.initial_values = kwargs
-
-    # Validate the initial values by calling `get_registers_initialization`
-    circuit.get_registers_initialization(circuit.initial_values)
-
-    return SerializedQuantumProgram(circuit.json())
-
-
 __all__ = [
     "QuantumCode",
     "QuantumInstructionSet",
-    "execute_qnn",
     "OperatorsEstimation",
     "set_quantum_program_execution_preferences",
-    "set_initial_values",
 ]

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

classiq/interface/analyzer/analysis_params.py

@@ -44,6 +44,17 @@ class AnalysisOptionalDevicesParams(HardwareListParams):
     )
 
 
+class GateNamsMapping(pydantic.BaseModel):
+    qasm_name: str
+    display_name: str
+
+
+class LatexParams(AnalysisParams):
+    gate_names: List[GateNamsMapping] = pydantic.Field(
+        default=..., description="List of gate names as apper in the qasm"
+    )
+
+
 class AnalysisHardwareTranspilationParams(pydantic.BaseModel):
     hardware_data: Optional[SynthesisHardwareData]
     random_seed: int

classiq/interface/applications/qsvm.py

@@ -12,12 +12,10 @@ from typing import (
 import numpy as np
 import pydantic
 from numpy.typing import ArrayLike
-from pydantic import BaseModel
 
 if TYPE_CHECKING:
     from pydantic.typing import AnyClassMethod
 
-from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 DataList = List[List[float]]
@@ -35,11 +33,6 @@ def listify(obj: Union[IterableType, ArrayLike]) -> list:
         return list(obj)  # type: ignore[arg-type]
 
 
-class QSVMPreferences(BaseModel):
-    execution_preferences: ExecutionPreferences
-    l2_norm_regularization_factor: float = 0.001
-
-
 def validate_array_to_list(name: str) -> "AnyClassMethod":
     return pydantic.validator(name, pre=True, allow_reuse=True)(listify)
 
@@ -96,7 +89,6 @@ class QSVMData(VersionedModel):
     data: DataList
     labels: Optional[LabelsInt] = None
     internal_state: Optional[QSVMInternalState] = None
-    preferences: QSVMPreferences
 
     class Config:
         smart_union = True

classiq/interface/ast_node.py

@@ -1,3 +1,4 @@
+import os
 from typing import Optional
 
 import pydantic
@@ -7,15 +8,24 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
 )
 
 
-class SourceReference(pydantic.BaseModel):
+class SourceReference(HashablePydanticBaseModel):
     start_line: int
     start_column: int
     end_line: int
     end_column: int
     file_name: Optional[str] = pydantic.Field(default=None)
 
+    def __str__(self) -> str:
+        file_string = (
+            f"file {os.path.basename(self.file_name)} " if self.file_name else ""
+        )
+        start_character_string = (
+            f" character {self.start_column}" if self.start_column else ""
+        )
+        return f"{file_string}line {self.start_line}{start_character_string}"
 
-class ASTNode(pydantic.BaseModel):
+
+class ASTNode(HashablePydanticBaseModel):
     source_ref: Optional[SourceReference] = pydantic.Field(default=None)
 
 

classiq/interface/backend/backend_preferences.py

@@ -4,7 +4,7 @@ from datetime import timedelta
 from typing import Any, Dict, Iterable, List, Optional, Union
 
 import pydantic
-from pydantic import BaseModel, validator
+from pydantic import BaseModel, PrivateAttr, validator
 
 from classiq.interface.backend import pydantic_backend
 from classiq.interface.backend.quantum_backend_providers import (
@@ -61,9 +61,22 @@ AWS_DEFAULT_JOB_TIMEOUT_SECONDS = int(timedelta(minutes=240).total_seconds())
 
 class AliceBobBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.ALICE_BOB
+    distance: Optional[int] = pydantic.Field(
+        default=None, description="Repetition code distance"
+    )
+    kappa_1: Optional[float] = pydantic.Field(
+        default=None, description="One-photon dissipation rate (Hz)"
+    )
+    kappa_2: Optional[float] = pydantic.Field(
+        default=None, description="Two-photon dissipation rate (Hz)"
+    )
+    average_nb_photons: Optional[float] = pydantic.Field(
+        default=None, description="Average number of photons"
+    )
     api_key: pydantic_backend.PydanticAliceBobApiKeyType = pydantic.Field(
         ..., description="AliceBob API key"
     )
+    _parameters: Dict[str, Any] = PrivateAttr(default_factory=dict)
 
     @pydantic.root_validator(pre=True)
     def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -71,6 +84,17 @@ class AliceBobBackendPreferences(BackendPreferences):
             values, "backend_service_provider", ProviderVendor.ALICE_AND_BOB
         )
 
+    @property
+    def parameters(self) -> Dict[str, Any]:
+        self._parameters = {
+            "distance": self.distance,
+            "kappa_1": self.kappa_1,
+            "kappa_2": self.kappa_2,
+            "average_nb_photons": self.average_nb_photons,
+        }
+        self._parameters = {k: v for k, v in self._parameters.items() if v is not None}
+        return self._parameters
+
 
 class ClassiqBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.CLASSIQ

classiq/interface/backend/quantum_backend_providers.py

@@ -149,10 +149,10 @@ class GoogleNvidiaBackendNames(StrEnum):
 
 
 class AliceBobBackendNames(StrEnum):
-    PERFECT_QUBITS = "EMU:20Q:PERFECT_QUBITS"
-    LOGICAL_TARGET = "EMU:40Q:LOGICAL_TARGET"
-    LOGICAL_EARLY = "EMU:15Q:LOGICAL_EARLY"
-    TRANSMONS = "EMU:7Q:TRANSMONS"
+    PERFECT_QUBITS = "PERFECT_QUBITS"
+    LOGICAL_TARGET = "LOGICAL_TARGET"
+    LOGICAL_EARLY = "LOGICAL_EARLY"
+    TRANSMONS = "TRANSMONS"
 
 
 class OQCBackendNames(StrEnum):

classiq/interface/executor/execution_preferences.py

@@ -1,5 +1,5 @@
 from datetime import timedelta
-from typing import Any, Dict, Optional, TypeVar
+from typing import Any, Dict, Optional
 
 import pydantic
 
@@ -13,10 +13,7 @@ from classiq.interface.backend.pydantic_backend import MAX_EXECUTION_TIMEOUT_SEC
 from classiq.interface.backend.quantum_backend_providers import (
     ClassiqSimulatorBackendNames,
 )
-from classiq.interface.executor.optimizer_preferences import (
-    OptimizerPreferences,
-    OptimizerType,
-)
+from classiq.interface.executor.optimizer_preferences import OptimizerType
 from classiq.interface.generator.model.preferences.preferences import (
     TranspilationOption,
 )
@@ -48,15 +45,11 @@ class ExecutionPreferences(pydantic.BaseModel):
         description="If set, limits the execution runtime. Value is in seconds. "
         "Not supported on all platforms.",
     )
-    optimizer_preferences: Optional[OptimizerPreferences] = pydantic.Field(
-        default_factory=None,
-        description="Settings related to VQE execution.",
-    )
     noise_properties: Optional[NoiseProperties] = pydantic.Field(
         default=None, description="Properties of the noise in the circuit"
     )
     random_seed: int = pydantic.Field(
-        default=None,
+        default_factory=create_random_seed,
         description="The random seed used for the execution",
     )
     backend_preferences: BackendPreferencesTypes = backend_preferences_field(
@@ -76,14 +69,6 @@ class ExecutionPreferences(pydantic.BaseModel):
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
 
-    @pydantic.validator("num_shots", always=True)
-    def validate_num_shots(
-        cls, original_num_shots: Optional[pydantic.PositiveInt], values: Dict[str, Any]
-    ) -> Optional[pydantic.PositiveInt]:
-        return _choose_original_or_optimizer_attribute(
-            original_num_shots, "num_shots", None, values
-        )
-
     @pydantic.validator("backend_preferences", always=True)
     def validate_timeout_for_aws(
         cls, backend_preferences: BackendPreferencesTypes, values: Dict[str, Any]
@@ -105,50 +90,10 @@ class ExecutionPreferences(pydantic.BaseModel):
         backend_preferences.job_timeout = timeout
         return backend_preferences
 
-    @pydantic.validator("random_seed", always=True)
-    def validate_random_seed(
-        cls, original_random_seed: Optional[int], values: Dict[str, Any]
-    ) -> int:
-        return _choose_original_or_optimizer_attribute(
-            original_random_seed, "random_seed", create_random_seed(), values
-        )
-
-
-T = TypeVar("T")
-
-
-def _choose_original_or_optimizer_attribute(
-    original_attribute: Optional[T],
-    attribure_name: str,
-    default_value: T,
-    values: Dict[str, Any],
-) -> T:
-    optimizer_preferences = values.get("optimizer_preferences", None)
-    optimizer_attribute = getattr(optimizer_preferences, attribure_name, None)
-
-    if original_attribute is None and optimizer_attribute is None:
-        return default_value
-
-    elif optimizer_attribute is None:
-        # mypy doesn't understand that original_attribute is not None
-        return original_attribute  # type: ignore[return-value]
-
-    elif original_attribute is None:
-        return optimizer_attribute
-
-    elif original_attribute != optimizer_attribute:
-        raise ClassiqValueError(
-            f"Different {attribure_name} were given for ExecutionPreferences and OptimizerPreferences."
-        )
-
-    else:  # This case is original_num_shots == optimizer_num_shots != None
-        return original_attribute
-
 
 __all__ = [
     "ExecutionPreferences",
-    "NoiseProperties",
-    "OptimizerPreferences",
     "OptimizerType",
+    "NoiseProperties",
     "QaeWithQpeEstimationMethod",
 ]

classiq/interface/executor/execution_result.py

@@ -4,7 +4,12 @@ from pydantic import BaseModel, Field
 from typing_extensions import Annotated, TypeAlias
 
 from classiq.interface.executor.iqae_result import IQAEResult
-from classiq.interface.executor.result import EstimationResult, ExecutionDetails
+from classiq.interface.executor.result import (
+    EstimationResult,
+    EstimationResults,
+    ExecutionDetails,
+    MultipleExecutionDetails,
+)
 from classiq.interface.executor.vqe_result import VQESolverResult
 from classiq.interface.helpers.versioned_model import VersionedModel
 
@@ -17,7 +22,9 @@ class SavedResultValueType(StrEnum):
     Boolean = "bool"
     VQESolverResult = "VQESolverResult"
     ExecutionDetails = "ExecutionDetails"
+    MultipleExecutionDetails = "MultipleExecutionDetails"
     EstimationResult = "EstimationResult"
+    EstimationResults = "EstimationResults"
     IQAEResult = "IQAEResult"
     Unstructured = "Unstructured"
 
@@ -52,12 +59,24 @@ class TaggedExecutionDetails(BaseModel):
     value: ExecutionDetails
 
 
+class TaggedMultipleExecutionDetails(BaseModel):
+    value_type: Literal[SavedResultValueType.MultipleExecutionDetails]
+    name: str
+    value: MultipleExecutionDetails
+
+
 class TaggedEstimationResult(BaseModel):
     value_type: Literal[SavedResultValueType.EstimationResult]
     name: str
     value: EstimationResult
 
 
+class TaggedEstimationResults(BaseModel):
+    value_type: Literal[SavedResultValueType.EstimationResults]
+    name: str
+    value: EstimationResults
+
+
 class TaggedIQAEResult(BaseModel):
     value_type: Literal[SavedResultValueType.IQAEResult]
     name: str
@@ -77,7 +96,9 @@ SavedResult = Annotated[
         TaggedBoolean,
         TaggedVQESolverResult,
         TaggedExecutionDetails,
+        TaggedMultipleExecutionDetails,
         TaggedEstimationResult,
+        TaggedEstimationResults,
         TaggedIQAEResult,
         TaggedUnstructured,
     ],

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -10,7 +10,6 @@ from classiq.interface.generator.arith.ast_node_rewrite import AstNodeRewrite
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
-from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
 
 from classiq.exceptions import ClassiqArithmeticError, ClassiqValueError
 
@@ -175,7 +174,6 @@ class ExpressionValidator(ast.NodeVisitor):
         if not (
             isinstance(node.value, ast.Name)
             and node.value.id in self._supported_attr_values
-            or node.attr in CLASSICAL_ATTRIBUTES.keys()
         ):
             raise ClassiqValueError(
                 f"Attribute is not supported for value {node.value}"