classiq 0.33.0__py3-none-any.whl → 0.35.0__py3-none-any.whl

classiq/interface/chemistry/operator.py

@@ -224,6 +224,204 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
         frozen = True
 
 
+class PauliOperatorV1(HashablePydanticBaseModel):
+    """
+    Specification of a Pauli sum operator.
+    """
+
+    pauli_list: PydanticPauliList = pydantic.Field(
+        description="A list of tuples each containing a pauli string comprised of I,X,Y,Z characters and a complex coefficient; for example [('IZ', 0.1), ('XY', 0.2)].",
+    )
+    is_hermitian: bool = pydantic.Field(default=False)
+    has_complex_coefficients: bool = pydantic.Field(default=True)
+
+    def show(self) -> str:
+        if self.is_hermitian:
+            # If the operator is hermitian then the coefficients must be numeric
+            return "\n".join(
+                f"{summand[1].real:+.3f} * {summand[0]}" for summand in self.pauli_list  # type: ignore[union-attr]
+            )
+        return "\n".join(
+            f"+({summand[1]:+.3f}) * {summand[0]}" for summand in self.pauli_list
+        )
+
+    @pydantic.validator("pauli_list", each_item=True, pre=True)
+    def _validate_pauli_monomials(
+        cls, monomial: Tuple[PydanticPauliMonomialStr, ParameterComplexType]
+    ) -> Tuple[PydanticPauliMonomialStr, ParameterComplexType]:
+        _PauliMonomialLengthValidator(  # type: ignore[call-arg]
+            monomial=monomial
+        )  # Validate the length of the monomial.
+        coeff = cls._validate_monomial_coefficient(monomial[1])
+        parsed_monomial = _PauliMonomialParser(string=monomial[0], coeff=coeff)  # type: ignore[call-arg]
+        return (parsed_monomial.string, parsed_monomial.coeff)
+
+    @staticmethod
+    def _validate_monomial_coefficient(
+        coeff: Union[sympy.Expr, ParameterComplexType]
+    ) -> ParameterComplexType:
+        if isinstance(coeff, str):
+            validate_expression_str(coeff)
+        elif isinstance(coeff, sympy.Expr):
+            coeff = str(coeff)
+        return coeff
+
+    @pydantic.validator("pauli_list")
+    def _validate_pauli_list(cls, pauli_list: PydanticPauliList) -> PydanticPauliList:
+        if not all_equal(len(summand[0]) for summand in pauli_list):
+            raise ValueError("Pauli strings have incompatible lengths.")
+        return pauli_list
+
+    @pydantic.root_validator
+    def _validate_hermitianity(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        pauli_list = values.get("pauli_list", [])
+        if all(isinstance(summand[1], complex) for summand in pauli_list):
+            values["is_hermitian"] = all(
+                np.isclose(complex(summand[1]).real, summand[1])
+                for summand in pauli_list
+            )
+        if values.get("is_hermitian", False):
+            values["has_complex_coefficients"] = False
+            values["pauli_list"] = [
+                (summand[0], complex(summand[1].real)) for summand in pauli_list
+            ]
+        else:
+            values["has_complex_coefficients"] = not all(
+                np.isclose(complex(summand[1]).real, summand[1])
+                for summand in pauli_list
+                if isinstance(summand[1], complex)
+            )
+        return values
+
+    def __mul__(self, coefficient: complex) -> "PauliOperatorV1":
+        multiplied_ising = [
+            (monomial[0], self._multiply_monomial_coefficient(monomial[1], coefficient))
+            for monomial in self.pauli_list
+        ]
+        return self.__class__(pauli_list=multiplied_ising)
+
+    @staticmethod
+    def _multiply_monomial_coefficient(
+        monomial_coefficient: ParameterComplexType, coefficient: complex
+    ) -> ParameterComplexType:
+        if isinstance(monomial_coefficient, ParameterType):
+            return str(sympy.sympify(monomial_coefficient) * coefficient)
+        return monomial_coefficient * coefficient
+
+    @property
+    def is_commutative(self) -> bool:
+        return all(
+            self._is_sub_pauli_commutative(
+                [summand[0][qubit_num] for summand in self.pauli_list]
+            )
+            for qubit_num in range(self.num_qubits)
+        )
+
+    @staticmethod
+    def _is_sub_pauli_commutative(qubit_pauli_string: Union[List[str], str]) -> bool:
+        unique_paulis = set(qubit_pauli_string) - {"I"}
+        return len(unique_paulis) <= 1
+
+    @property
+    def num_qubits(self) -> int:
+        return len(self.pauli_list[0][0])
+
+    def to_matrix(self) -> np.ndarray:
+        if not all(isinstance(summand[1], complex) for summand in self.pauli_list):
+            raise ClassiqValueError(
+                "Supporting only Hamiltonian with numeric coefficients."
+            )
+        return sum(
+            cast(complex, summand[1]) * to_pauli_matrix(summand[0])
+            for summand in self.pauli_list
+        )  # type: ignore[return-value]
+
+    @staticmethod
+    def _extend_pauli_string(
+        pauli_string: PydanticPauliMonomialStr, num_extra_qubits: int
+    ) -> PydanticPauliMonomialStr:
+        return "I" * num_extra_qubits + pauli_string
+
+    def extend(self, num_extra_qubits: int) -> "PauliOperatorV1":
+        new_pauli_list = [
+            (self._extend_pauli_string(pauli_string, num_extra_qubits), coeff)
+            for (pauli_string, coeff) in self.pauli_list
+        ]
+        return self.copy(update={"pauli_list": new_pauli_list}, deep=True)
+
+    @staticmethod
+    def _reorder_pauli_string(
+        pauli_string: PydanticPauliMonomialStr,
+        order: Collection[int],
+        new_num_qubits: int,
+    ) -> PydanticPauliMonomialStr:
+        reversed_pauli_string = pauli_string[::-1]
+        reversed_new_pauli_string = ["I"] * new_num_qubits
+
+        for logical_pos, actual_pos in enumerate(order):
+            reversed_new_pauli_string[actual_pos] = reversed_pauli_string[logical_pos]
+
+        return "".join(reversed(reversed_new_pauli_string))
+
+    @staticmethod
+    def _validate_reorder(
+        order: Collection[int],
+        num_qubits: int,
+        num_extra_qubits: int,
+    ) -> None:
+        if num_extra_qubits < 0:
+            raise ValueError("Number of extra qubits cannot be negative")
+
+        if len(order) != num_qubits:
+            raise ValueError("The qubits order doesn't match the Pauli operator")
+
+        if len(order) != len(set(order)):
+            raise ValueError("The qubits order is not one-to-one")
+
+        if not all(pos < num_qubits + num_extra_qubits for pos in order):
+            raise ValueError("The qubits order contains qubits which do no exist")
+
+    @classmethod
+    def reorder(
+        cls,
+        operator: "PauliOperatorV1",
+        order: Collection[int],
+        num_extra_qubits: int = 0,
+    ) -> "PauliOperatorV1":
+        cls._validate_reorder(order, operator.num_qubits, num_extra_qubits)
+
+        new_num_qubits = operator.num_qubits + num_extra_qubits
+        new_pauli_list = [
+            (cls._reorder_pauli_string(pauli_string, order, new_num_qubits), coeff)
+            for pauli_string, coeff in operator.pauli_list
+        ]
+        return cls(pauli_list=new_pauli_list)
+
+    @classmethod
+    def from_unzipped_lists(
+        cls,
+        operators: List[List[Pauli]],
+        coefficients: Optional[List[complex]] = None,
+    ) -> "PauliOperatorV1":
+        if coefficients is None:
+            coefficients = [1] * len(operators)
+
+        if len(operators) != len(coefficients):
+            raise ValueError(
+                f"The number of coefficients ({len(coefficients)}) must be equal to the number of pauli operators ({len(operators)})"
+            )
+
+        return cls(
+            pauli_list=[
+                (pauli_integers_to_str(op), coeff)
+                for op, coeff in zip(operators, coefficients)
+            ]
+        )
+
+    class Config:
+        frozen = True
+
+
 # This class validates the length of a monomial.
 @pydantic.dataclasses.dataclass
 class _PauliMonomialLengthValidator:

classiq/interface/execution/jobs.py

@@ -0,0 +1,28 @@
+from datetime import datetime
+from typing import List, Optional
+
+from pydantic import BaseModel, Extra
+
+from classiq.interface.jobs import JobStatus
+
+
+class ExecutionJobDetailsV1(BaseModel, extra=Extra.ignore):
+    id: str
+
+    name: Optional[str]
+    start_time: datetime
+    end_time: Optional[datetime]
+
+    provider: Optional[str]
+    backend_name: Optional[str]
+
+    status: JobStatus
+
+    num_shots: Optional[int]
+    program_id: Optional[str]
+
+    error: Optional[str]
+
+
+class ExecutionJobsQueryResultsV1(BaseModel, extra=Extra.ignore):
+    results: List[ExecutionJobDetailsV1]

classiq/interface/executor/execution_request.py

@@ -15,10 +15,7 @@ from classiq.interface.executor.quantum_program import (
 )
 from classiq.interface.executor.result import EstimationResult, ExecutionDetails
 from classiq.interface.executor.vqe_result import VQESolverResult
-from classiq.interface.generator.generated_circuit import (
-    ExecutionCircuit,
-    GeneratedCircuit,
-)
+from classiq.interface.generator.generated_circuit import GeneratedCircuit
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.jobs import JobStatus
 
@@ -29,10 +26,6 @@ class GeneratedCircuitExecution(GeneratedCircuit):
     execution_type: Literal["generated_circuit"] = "generated_circuit"
 
 
-class BareGeneratedCircuitExecution(ExecutionCircuit):
-    execution_type: Literal["bare_generated_circuit"] = "bare_generated_circuit"
-
-
 class QuantumProgramExecution(QuantumProgram):
     execution_type: Literal["quantum_program"] = "quantum_program"
 
@@ -42,10 +35,7 @@ class EstimateOperatorsExecution(OperatorsEstimation):
 
 
 ExecutionPayloads = Union[
-    GeneratedCircuitExecution,
-    BareGeneratedCircuitExecution,
-    QuantumProgramExecution,
-    EstimateOperatorsExecution,
+    GeneratedCircuitExecution, QuantumProgramExecution, EstimateOperatorsExecution
 ]
 
 

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -50,6 +50,7 @@ SupportedNodesTypes = Union[
     ast.RShift,
     ast.Call,
     ast.Mult,
+    ast.Pow,
 ]
 
 DEFAULT_SUPPORTED_NODE_TYPES = get_args(SupportedNodesTypes)

classiq/interface/generator/arith/arithmetic_param_getters.py

@@ -25,6 +25,7 @@ from classiq.interface.generator.arith.binary_ops import (
     Modulo,
     Multiplier,
     NotEqual,
+    Power,
     RegisterOrInt,
     RShift,
     Subtractor,
@@ -155,6 +156,16 @@ def multiplier_params_getter(
     return Multiplier(left_arg=left_arg, right_arg=right_arg, output_size=output_size)
 
 
+def power_params_getter(
+    left_arg: RegisterArithmeticInfo,
+    right_arg: int,
+    output_size: Optional[int] = None,
+    inplace_arg: Optional[str] = None,
+    target: Optional[RegisterArithmeticInfo] = None,
+) -> ArithmeticOperationParams:
+    return Power(left_arg=left_arg, right_arg=right_arg, output_size=output_size)
+
+
 def min_params_getter(
     left_arg: RegisterOrFloat,
     right_arg: RegisterOrFloat,
@@ -367,4 +378,5 @@ params_getter_map: Dict[str, ParamsGetter] = dict(
     Mod=modulo_params_getter,
     min=min_params_getter,
     max=max_params_getter,
+    Pow=power_params_getter,
 )

classiq/interface/generator/arith/binary_ops.py

@@ -413,6 +413,40 @@ class LessEqual(Comparator):
     output_name = "is_less_equal"
 
 
+class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
+    output_name = "powered"
+
+    @pydantic.validator("right_arg", pre=True)
+    def _validate_legal_power(cls, right_arg: Any) -> pydantic.PositiveInt:
+        if not float(right_arg).is_integer():
+            raise ValueError("Power must be an integer")
+        if right_arg <= 0:
+            raise ValueError("Power must be greater than one")
+        return int(right_arg)
+
+    def _get_result_bounds(self) -> Tuple[float, float]:
+        if (self.right_arg % 2) or min(self.left_arg.bounds) >= 0:
+            return (
+                self.left_arg.bounds[0] ** self.right_arg,
+                self.left_arg.bounds[1] ** self.right_arg,
+            )
+        return 0.0, max(abs(bound) for bound in self.left_arg.bounds) ** self.right_arg
+
+    def _get_result_register(self) -> RegisterArithmeticInfo:
+        if self.output_size:
+            return RegisterArithmeticInfo(size=self.output_size)
+
+        fraction_places: int = self.left_arg.fraction_places * self.right_arg
+        bounds = self._get_result_bounds()
+        size = number_utils.bounds_to_integer_part_size(*bounds) + fraction_places
+        return RegisterArithmeticInfo(
+            size=size,
+            is_signed=self.left_arg.is_signed and (self.right_arg % 2 == 1),
+            fraction_places=fraction_places,
+            bounds=bounds,
+        )
+
+
 class EffectiveUnaryOpParams(
     InplacableBinaryOpParams[RegisterArithmeticInfo, RightDataT], Generic[RightDataT]
 ):

classiq/interface/generator/expressions/expression.py

@@ -82,3 +82,6 @@ class Expression(HashablePydanticBaseModel):
 
     class Config:
         frozen = True
+
+    def __str__(self) -> str:
+        return self.expr

classiq/interface/generator/expressions/qmod_sized_proxy.py

@@ -1,6 +1,16 @@
-class QmodSizedProxy:
-    def __init__(self, size: int) -> None:
+from sympy import Symbol
+
+
+class QmodSizedProxy(Symbol):
+    def __new__(cls, name, **assumptions):
+        return super().__new__(cls, name, **assumptions)
+
+    def __init__(self, name: str, size: int) -> None:
         self._size = size
 
+    @property
+    def size(self) -> int:
+        return self.args[0]
+
     def __len__(self) -> int:
         return self._size

classiq/interface/generator/function_param_list_without_self_reference.py

@@ -18,6 +18,7 @@ from classiq.interface.generator.arith.binary_ops import (
     Modulo,
     Multiplier,
     NotEqual,
+    Power,
     RShift,
     Subtractor,
 )
@@ -136,6 +137,7 @@ function_param_library_without_self_reference: FunctionParamLibrary = (
                 WeightedAdder,
                 LinearPauliRotations,
                 Multiplier,
+                Power,
                 LinearGCI,
                 HartreeFock,
                 UCC,

classiq/interface/generator/function_params.py

@@ -102,6 +102,10 @@ GenerationOnlyExpressionSupportedNodeTypes = Union[
     ast.Slice,
     ast.keyword,
     ast.Attribute,
+    ast.BoolOp,
+    ast.Or,
+    ast.And,
+    ast.Not,
 ]
 
 GenerationExpressionSupportedNodeTypes = Union[

classiq/interface/generator/functions/core_lib_declarations/quantum_functions/atomic_quantum_functions.py

@@ -441,11 +441,11 @@ ADD_FUNCTION = QuantumFunctionDeclaration(
     port_declarations={
         "left": PortDeclaration(
             name="left",
-            direction=PortDeclarationDirection.Input,
+            direction=PortDeclarationDirection.Inout,
         ),
         "right": PortDeclaration(
             name="right",
-            direction=PortDeclarationDirection.Input,
+            direction=PortDeclarationDirection.Inout,
         ),
         "result": PortDeclaration(
             name="result",