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

classiq/interface/exceptions.py

@@ -35,14 +35,6 @@ class ClassiqMissingOutputFormatError(ClassiqError):
         super().__init__(message=msg)
 
 
-class ClassiqCombinatorialOptimizationError(ClassiqError):
-    pass
-
-
-class ClassiqOracleError(ClassiqError):
-    pass
-
-
 class ClassiqAnalyzerError(ClassiqError):
     pass
 
@@ -57,10 +49,6 @@ class ClassiqAPIError(ClassiqError):
         super().__init__(message)
 
 
-class ClassiqVersionError(ClassiqError):
-    pass
-
-
 class ClassiqValueError(ClassiqError, ValueError):
     pass
 
@@ -77,10 +65,6 @@ class ClassiqIndexError(ClassiqError, IndexError):
     pass
 
 
-class ClassiqWiringError(ClassiqValueError):
-    pass
-
-
 class ClassiqControlError(ClassiqError):
     def __init__(self) -> None:
         message = "Repeated control names, please rename the control states"
@@ -91,10 +75,6 @@ class ClassiqQRegError(ClassiqValueError):
     pass
 
 
-class ClassiqQFuncError(ClassiqValueError):
-    pass
-
-
 class ClassiqQNNError(ClassiqValueError):
     pass
 
@@ -103,10 +83,6 @@ class ClassiqTorchError(ClassiqQNNError):
     pass
 
 
-class ClassiqChemistryError(ClassiqError):
-    pass
-
-
 class ClassiqAuthenticationError(ClassiqError):
     pass
 
@@ -115,22 +91,10 @@ class ClassiqExpiredTokenError(ClassiqAuthenticationError):
     pass
 
 
-class ClassiqFileNotFoundError(FileNotFoundError):
-    pass
-
-
-class ClassiqStateInitializationError(ClassiqError):
-    pass
-
-
 class ClassiqPasswordManagerSelectionError(ClassiqError):
     pass
 
 
-class ClassiqMismatchIOsError(ClassiqError):
-    pass
-
-
 class ClassiqNotImplementedError(ClassiqError, NotImplementedError):
     pass
 
@@ -171,12 +135,6 @@ class ClassiqCombOptNotSupportedProblemError(ClassiqCombOptError):
     pass
 
 
-class ClassiqExecutorInvalidHamiltonianError(ClassiqCombOptError):
-
-    def __init__(self) -> None:
-        super().__init__("Invalid hamiltonian")
-
-
 class ClassiqDeprecationWarning(FutureWarning):
     pass
 

classiq/interface/executor/execution_request.py

@@ -58,6 +58,7 @@ class JobCost(BaseModel):
 class ExecutionJobDetails(VersionedModel):
     id: str
 
+    session_id: str | None = Field(default=None)
     name: str | None = Field(default=None)
     start_time: datetime
     end_time: datetime | None = Field(default=None)

classiq/interface/executor/quantum_code.py

@@ -11,7 +11,6 @@ from classiq.interface.backend.ionq.ionq_quantum_program import IonqQuantumCircu
 from classiq.interface.backend.pydantic_backend import PydanticArgumentNameType
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
-from classiq.interface.executor.register_initialization import RegisterInitialization
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
@@ -19,7 +18,6 @@ from classiq.interface.generator.synthesis_metadata.synthesis_execution_data imp
 Arguments = dict[PydanticArgumentNameType, Any]
 MultipleArguments = tuple[Arguments, ...]
 CodeType = str
-RegistersInitialization = dict[str, RegisterInitialization]
 Qubits = tuple[int, ...]
 OutputQubitsMap = dict[str, Qubits]
 
@@ -57,10 +55,6 @@ class QuantumCode(QuantumBaseCode):
         default_factory=dict,
         description="The map of outputs to their qubits in the circuit.",
     )
-    registers_initialization: RegistersInitialization | None = pydantic.Field(
-        default=None,
-        description="Initial conditions for the different registers in the circuit.",
-    )
     synthesis_execution_data: ExecutionData | None = pydantic.Field(default=None)
     synthesis_execution_arguments: Arguments = pydantic.Field(default_factory=dict)
     model_config = ConfigDict(validate_assignment=True)

classiq/interface/executor/result.py

@@ -47,7 +47,7 @@ StateVector: TypeAlias = Optional[dict[str, Complex]]
 BITSTRING = "bitstring"
 PROBABILITY = "probability"
 AMPLITUDE = "amplitude"
-COUNT = "count"
+COUNTS = "counts"
 MAGNITUDE = "magnitude"
 PHASE = "phase"
 
@@ -374,7 +374,9 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
         for bitstring, count in self.counts.items():
             data[BITSTRING].append(bitstring)
-            data[COUNT].append(count)
+            # TODO CLS-4767: delete "count"
+            data["count"].append(count)
+            data[COUNTS].append(count)
             if self.probabilities:
                 data[PROBABILITY].append(self.probabilities[bitstring])
             elif self.num_shots:
@@ -383,7 +385,8 @@ class ExecutionDetails(BaseModel, QmodPyObject):
             for name, value in self.parsed_states[bitstring].items():
                 data[name].append(value)
 
-        final_columns = [COUNT, PROBABILITY, BITSTRING]
+        # TODO CLS-4767: delete "count"
+        final_columns = [COUNTS, "count", PROBABILITY, BITSTRING]
         columns = [
             col for col in data.keys() if col not in final_columns
         ] + final_columns
@@ -419,8 +422,9 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
     @functools.cached_property
     def dataframe(self) -> "pd.DataFrame":
+        # TODO CLS-4767: remove "count"
         reserved_words = frozenset(
-            [BITSTRING, PROBABILITY, COUNT, AMPLITUDE, PHASE, MAGNITUDE]
+            ["count", BITSTRING, PROBABILITY, COUNTS, AMPLITUDE, PHASE, MAGNITUDE]
         )
         _invalid_output_names = reserved_words.intersection(
             self.output_qubits_map.keys()
@@ -436,7 +440,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
             df = self._counts_df()
 
         df.sort_values(
-            by=[AMPLITUDE if self.state_vector else COUNT, BITSTRING],
+            by=[AMPLITUDE if self.state_vector else COUNTS, BITSTRING],
             inplace=True,
             ascending=[False, True],
             ignore_index=True,

classiq/interface/generator/arith/binary_ops.py

@@ -29,7 +29,10 @@ from classiq.interface.generator.arith.ast_node_rewrite import (
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.arith.unary_ops import Negation
-from classiq.interface.generator.function_params import get_zero_input_name
+from classiq.interface.generator.function_params import (
+    FunctionParams,
+    get_zero_input_name,
+)
 
 from classiq.model_expansions.arithmetic import NumericAttributes
 from classiq.model_expansions.arithmetic_compute_result_attrs import (
@@ -533,10 +536,43 @@ class Multiplier(BinaryOpWithFloatInputs):
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         return max(
-            0, self.expected_fraction_places() - self.result_register.fraction_places
+            0,
+            self.expected_fraction_places() - self.result_register.fraction_places - 1,
         )
 
 
+class CanonicalMultiplier(FunctionParams):
+    left_size: pydantic.PositiveInt
+    extend_left: bool
+    right_size: pydantic.PositiveInt
+    extend_right: bool
+    result_size: pydantic.PositiveInt
+    trim_result_lsb: bool
+
+    def _create_ios(self) -> None:
+        self._inputs = {
+            "left": RegisterArithmeticInfo(size=self.left_size),
+            "right": RegisterArithmeticInfo(size=self.right_size),
+            "result": RegisterArithmeticInfo(size=self.result_size),
+        }
+        self._outputs = {**self._inputs}
+
+
+class CanonicalConstantMultiplier(FunctionParams):
+    left: int
+    right_size: pydantic.PositiveInt
+    extend_right: bool
+    result_size: pydantic.PositiveInt
+    trim_result_lsb: bool
+
+    def _create_ios(self) -> None:
+        self._inputs = {
+            "right": RegisterArithmeticInfo(size=self.right_size),
+            "result": RegisterArithmeticInfo(size=self.result_size),
+        }
+        self._outputs = {**self._inputs}
+
+
 class Comparator(BinaryOpWithFloatInputs):
     output_size: Literal[1] = 1
 

classiq/interface/generator/function_param_list.py

@@ -1,12 +1,13 @@
 import itertools
 
-from classiq.interface.generator.amplitude_loading import AmplitudeLoading
 from classiq.interface.generator.arith.arithmetic import Arithmetic
 from classiq.interface.generator.arith.binary_ops import (
     Adder,
     BitwiseAnd,
     BitwiseOr,
     BitwiseXor,
+    CanonicalConstantMultiplier,
+    CanonicalMultiplier,
     Equal,
     GreaterEqual,
     GreaterThan,
@@ -79,6 +80,8 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             HardwareEfficientAnsatz,
             UnitaryGate,
             Multiplier,
+            CanonicalMultiplier,
+            CanonicalConstantMultiplier,
             Power,
             Min,
             Max,
@@ -88,7 +91,6 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             Identity,
             RandomizedBenchmarking,
             UGate,
-            AmplitudeLoading,
             HadamardTransform,
             Copy,
             Reset,

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

@@ -1,7 +1,8 @@
 CTRL_VAR_PREFIX = "ctrl__"
 CONTROL_OPERATOR_NAME = "control"
 SKIP_CONTROL_OPERATOR_NAME = "skip_control"
-INVERT_OPERATOR_NAME = "invert"
+COMPOUND_INVERT_OPERATOR_NAME = "compound_invert"
+SINGLE_CALL_INVERT_OPERATOR_NAME = "single_call_invert"
 REPEAT_OPERATOR_NAME = "iteration"
 CLASSICAL_IF_OPERATOR_NAME = "classical_if"
 POWER_OPERATOR_NAME = "power"
@@ -9,12 +10,7 @@ UNCOMPUTE_OPERATOR_NAME = "uncompute"
 WITHIN_APPLY_NAME = "within_apply"
 BLOCK_OPERATOR_NAME = "block"
 
-All_BUILTINS_OPERATORS = {
-    CONTROL_OPERATOR_NAME,
-    INVERT_OPERATOR_NAME,
-    REPEAT_OPERATOR_NAME,
-    POWER_OPERATOR_NAME,
-    UNCOMPUTE_OPERATOR_NAME,
-    WITHIN_APPLY_NAME,
-    BLOCK_OPERATOR_NAME,
+INVERT_OPERATOR_NAMES = {
+    COMPOUND_INVERT_OPERATOR_NAME,
+    SINGLE_CALL_INVERT_OPERATOR_NAME,
 }

classiq/interface/generator/functions/classical_type.py

@@ -61,6 +61,10 @@ class ClassicalType(HashableASTNode):
     def raw_qmod_type_name(self) -> str:
         return self.qmod_type_name
 
+    @property
+    def python_type_name(self) -> str:
+        raise NotImplementedError
+
     @property
     def expressions(self) -> list[Expression]:
         return []
@@ -76,6 +80,9 @@ class ClassicalType(HashableASTNode):
     def without_symbolic_attributes(self) -> Self:
         return self
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        return {}
+
 
 class Integer(ClassicalType):
     kind: Literal["int"]
@@ -89,6 +96,10 @@ class Integer(ClassicalType):
     def qmod_type_name(self) -> str:
         return "CInt"
 
+    @property
+    def python_type_name(self) -> str:
+        return "int"
+
 
 class Real(ClassicalType):
     kind: Literal["real"]
@@ -102,6 +113,10 @@ class Real(ClassicalType):
     def qmod_type_name(self) -> str:
         return "CReal"
 
+    @property
+    def python_type_name(self) -> str:
+        return "float"
+
 
 class Bool(ClassicalType):
     kind: Literal["bool"]
@@ -115,6 +130,10 @@ class Bool(ClassicalType):
     def qmod_type_name(self) -> str:
         return "CBool"
 
+    @property
+    def python_type_name(self) -> str:
+        return "bool"
+
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
@@ -201,6 +220,10 @@ class ClassicalArray(ClassicalType):
     def raw_qmod_type_name(self) -> str:
         return "CArray"
 
+    @property
+    def python_type_name(self) -> str:
+        return f"list[{self.element_type.python_type_name}]"
+
     def without_symbolic_attributes(self) -> "ClassicalArray":
         length = (
             None
@@ -213,6 +236,14 @@ class ClassicalArray(ClassicalType):
             element_type=self.element_type.without_symbolic_attributes(), length=length
         )
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        attrs: dict[str, Any] = {}
+        if self.has_constant_length:
+            attrs[f"{path_expr_prefix}.len"] = self.length_value
+        return attrs | self.element_type.get_compile_time_attributes(
+            f"{path_expr_prefix}[0]"
+        )
+
 
 class ClassicalTuple(ClassicalType):
     kind: Literal["tuple"]
@@ -283,6 +314,13 @@ class ClassicalTuple(ClassicalType):
     def raw_qmod_type_name(self) -> str:
         return "CArray"
 
+    @property
+    def python_type_name(self) -> str:
+        raw_type = self.get_raw_type(preserve_length=True)
+        if isinstance(raw_type, ClassicalTuple):
+            return "list"
+        return raw_type.python_type_name
+
     def without_symbolic_attributes(self) -> "ClassicalTuple":
         return ClassicalTuple(
             element_types=[
@@ -291,6 +329,13 @@ class ClassicalTuple(ClassicalType):
             ]
         )
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        raw_type = self.get_raw_type(preserve_length=True)
+        attrs = {f"{path_expr_prefix}.len": len(self.element_types)}
+        if isinstance(raw_type, ClassicalTuple):
+            return attrs
+        return attrs | raw_type.get_compile_time_attributes(path_expr_prefix)
+
 
 class OpaqueHandle(ClassicalType):
     pass

classiq/interface/generator/functions/type_name.py

@@ -60,6 +60,10 @@ class TypeName(ClassicalType, QuantumType):
     def qmod_type_name(self) -> str:
         return self.name
 
+    @property
+    def python_type_name(self) -> str:
+        return self.name
+
     @property
     def type_name(self) -> str:
         return self.name
@@ -202,6 +206,25 @@ class TypeName(ClassicalType, QuantumType):
             return type_name
         return self
 
+    def get_compile_time_attributes(self, path_expr_prefix: str) -> dict[str, Any]:
+        attrs: dict[str, Any] = {}
+        if self.has_fields:
+            for field_name, field_type in self.fields.items():
+                field_prefix = f"{path_expr_prefix}.{field_name}"
+                attrs[field_prefix] = field_type.get_compile_time_attributes(
+                    field_prefix
+                )
+        elif self.has_classical_struct_decl:
+            for (
+                field_name,
+                classical_field_type,
+            ) in self.classical_struct_decl.variables.items():
+                field_prefix = f"{path_expr_prefix}.{field_name}"
+                attrs[field_prefix] = classical_field_type.get_compile_time_attributes(
+                    field_prefix
+                )
+        return attrs
+
 
 class Enum(TypeName):
     pass

classiq/interface/generator/generated_circuit_data.py

@@ -140,7 +140,6 @@ class StatementType(StrEnum):
     WITHIN = "within"
     APPLY = "apply"
     ASSIGN = "assign"
-    ASSIGN_AMPLITUDE = "assign amplitude"
     PHASE = "phase"
     INPLACE_XOR = "inplace xor"
     INPLACE_ADD = "inplace add"
@@ -163,7 +162,6 @@ STATEMENTS_NAME: dict[str, StatementType] = {
     "Uncompute": StatementType.WITHIN,
     ArithmeticOperationKind.Assignment.value: StatementType.ASSIGN,
     "InplaceBinaryOperation": StatementType.ASSIGN,
-    "AmplitudeLoadingOperation": StatementType.ASSIGN_AMPLITUDE,
     "PhaseOperation": StatementType.PHASE,
     ArithmeticOperationKind.InplaceXor.value: StatementType.INPLACE_XOR,
     ArithmeticOperationKind.InplaceAdd.value: StatementType.INPLACE_ADD,

classiq/interface/generator/generation_request.py

@@ -1,12 +1,17 @@
 from datetime import datetime
 
-from pydantic import Field
+from pydantic import ConfigDict, Field
 
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.jobs import JobStatus
 
 
-class SynthesisJobDetails(VersionedModel):
+class SynthesisActionDetails(VersionedModel):
+    """
+    Details of a synthesis user action.
+    """
+
+    model_config = ConfigDict(frozen=True)
     id: str
 
     name: str | None = Field(default=None)
@@ -31,5 +36,5 @@ class SynthesisJobDetails(VersionedModel):
     max_gate_count: int | None = Field(default=None)
 
 
-class SynthesisJobsQueryResults(VersionedModel):
-    results: list[SynthesisJobDetails]
+class SynthesisActionsQueryResults(VersionedModel):
+    results: list[SynthesisActionDetails]

classiq/interface/generator/quantum_program.py

@@ -10,12 +10,10 @@ from classiq.interface.compression_utils import decompress
 from classiq.interface.exceptions import (
     ClassiqDeprecationWarning,
     ClassiqMissingOutputFormatError,
-    ClassiqStateInitializationError,
 )
 from classiq.interface.execution.primitives import PrimitivesInput
 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
 from classiq.interface.generator.circuit_code.types_and_constants import (
     INSTRUCTION_SET_TO_FORMAT,
@@ -29,9 +27,9 @@ from classiq.interface.generator.hardware.hardware_data import SynthesisHardware
 from classiq.interface.generator.model.model import ExecutionModel
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.ide.visual_model import CircuitMetrics
+from classiq.interface.model.model import Model
 
 RegisterName: TypeAlias = str
-InitialConditions: TypeAlias = dict[RegisterName, int]
 
 
 class TranspiledCircuitData(CircuitCodeInterface):
@@ -56,7 +54,6 @@ def _get_formatted_utc_current_time() -> str:
 
 class QuantumProgram(VersionedModel, CircuitCodeInterface):
     hardware_data: SynthesisHardwareData
-    initial_values: InitialConditions | None = pydantic.Field(default=None)
     data: GeneratedCircuitData
     model: ExecutionModel
     transpiled_circuit: TranspiledCircuitData | None = pydantic.Field(default=None)
@@ -65,7 +62,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
     execution_primitives_input: PrimitivesInput | None = pydantic.Field(default=None)
     synthesis_warnings: list[str] | None = pydantic.Field(default=None)
-    should_warn: bool = pydantic.Field(default=False)
+    compiled_qmod: Model | None = pydantic.Field(default=None)
 
     def __str__(self) -> str:
         return self.model_dump_json(indent=2)
@@ -85,10 +82,8 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
 
     def to_program(
         self,
-        initial_values: InitialConditions | None = None,
         instruction_set: QuantumInstructionSet | None = None,
     ) -> quantum_code.QuantumCode:
-        initial_values = initial_values or self.initial_values
         if instruction_set is not None:
             code, syntax = (
                 self.program_circuit.get_code(instruction_set),
@@ -97,40 +92,17 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
         else:
             code, syntax = self._default_program_code()
 
-        if initial_values is not None:
-            registers_initialization = self.get_registers_initialization(
-                initial_values=initial_values
-            )
-        else:
-            registers_initialization = None
         return quantum_code.QuantumCode(
             code=code,
             syntax=syntax,
-            output_qubits_map=self.data.qubit_mapping.physical_outputs,
-            registers_initialization=registers_initialization,
+            output_qubits_map=(
+                self.data.qubit_mapping.physical_outputs
+                if self._can_use_transpiled_code
+                else self.data.qubit_mapping.logical_outputs
+            ),
             synthesis_execution_data=self.data.execution_data,
         )
 
-    def _get_initialization_qubits(self, name: str) -> tuple[int, ...]:
-        qubits = self.data.qubit_mapping.logical_inputs.get(name)
-        if qubits is None:
-            raise ClassiqStateInitializationError(
-                f"Cannot initialize register {name}, it does not appear in circuit inputs"
-            )
-        return qubits
-
-    def get_registers_initialization(
-        self, initial_values: InitialConditions
-    ) -> dict[RegisterName, RegisterInitialization]:
-        return {
-            name: RegisterInitialization(
-                name=name,
-                qubits=list(self._get_initialization_qubits(name)),
-                initial_condition=init_value,
-            )
-            for name, init_value in initial_values.items()
-        }
-
     def save_results(self, filename: str | Path | None = None) -> None:
         """
         Saves quantum program results as json into a file.
@@ -148,7 +120,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
 
     @property
     def _can_use_transpiled_code(self) -> bool:
-        return (
+        return self.transpiled_circuit is not None and (
             self.data.execution_data is None
             or not self.data.execution_data.function_execution
         )

classiq/interface/generator/types/compilation_metadata.py

@@ -5,6 +5,7 @@ class CompilationMetadata(BaseModel):
     should_synthesize_separately: bool = Field(default=False)
     occurrences_number: NonNegativeInt = Field(default=0)
     _occupation_number: NonNegativeInt = PrivateAttr(default=0)
+    _required_clean_qubit: NonNegativeInt = PrivateAttr(default=0)
     disable_perm_check: bool = Field(default=False)
     disable_const_checks: list[str] | bool = Field(default=False)
 
@@ -16,6 +17,14 @@ class CompilationMetadata(BaseModel):
     def occupation_number(self, value: NonNegativeInt) -> None:
         self._occupation_number = value
 
+    @property
+    def required_clean_qubit(self) -> NonNegativeInt:
+        return self._required_clean_qubit
+
+    @required_clean_qubit.setter
+    def required_clean_qubit(self, value: NonNegativeInt) -> None:
+        self._required_clean_qubit = value
+
     @property
     def has_user_directives(self) -> bool:
         return bool(self.disable_perm_check or self.disable_const_checks)

classiq/interface/hardware.py

@@ -33,6 +33,7 @@ class Provider(StrEnum):
     INTEL = "Intel"
     AQT = "AQT"
     CINECA = "CINECA"
+    SOFTBANK = "Softbank"
 
     @property
     def id(self) -> "ProviderIDEnum":