classiq 0.47.0__py3-none-any.whl → 0.48.0__py3-none-any.whl

classiq/applications/combinatorial_helpers/pauli_helpers/pauli_utils.py

@@ -44,10 +44,5 @@ def _pauli_terms_to_qmod(hamiltonian: List[PauliTerm]) -> str:
     return ", ".join(qmod_strings)
 
 
-def _pauli_dict_to_str(hamiltonian: List[QmodPyStruct]) -> str:
-    res = []
-    for struct in hamiltonian:
-        pauli_str = ", ".join([pauli_enum_to_str(p) for p in struct["pauli"]])
-        res.append(f'"pauli": [{pauli_str}], "coefficient": {struct["coefficient"]}')
-
-    return f"{{{', '.join(res)}}}"
+def _pauli_dict_to_pauli_terms(hamiltonian: List[QmodPyStruct]) -> List[PauliTerm]:
+    return [PauliTerm(**struct) for struct in hamiltonian]

classiq/applications/grover/grover_model_constructor.py

@@ -11,6 +11,7 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_expressions.arithmetic_operation import (
     ArithmeticOperation,
+    ArithmeticOperationKind,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
@@ -110,7 +111,7 @@ def construct_grover_model(
                     ArithmeticOperation(
                         expression=Expression(expr=expression),
                         result_var=HandleBinding(name="res"),
-                        inplace_result=True,
+                        operation_kind=ArithmeticOperationKind.InplaceXor,
                     ),
                 ],
             ),

classiq/execution/execution_session.py

@@ -1,8 +1,9 @@
 import json
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union, cast
 
+from classiq.interface.chemistry.operator import PauliOperator, pauli_integers_to_str
 from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.execution.primitives import PrimitivesInput
+from classiq.interface.execution.primitives import EstimateInput, PrimitivesInput
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.executor.result import (
     EstimationResult,
@@ -12,7 +13,7 @@ from classiq.interface.generator.functions.qmod_python_interface import QmodPySt
 from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
-    _pauli_dict_to_str,
+    _pauli_dict_to_pauli_terms,
     _pauli_terms_to_qmod,
 )
 from classiq.execution.jobs import ExecutionJob
@@ -51,12 +52,26 @@ def _deserialize_program(program: Program) -> QuantumProgram:
     )
 
 
+def hamiltonian_to_pauli_terms(hamiltonian: Hamiltonian) -> List[PauliTerm]:
+    if isinstance(hamiltonian[0], PauliTerm):
+        return cast(List[PauliTerm], hamiltonian)
+    else:
+        return _pauli_dict_to_pauli_terms(cast(List[QmodPyStruct], hamiltonian))
+
+
 def to_hamiltonian_str(hamiltonian: Hamiltonian) -> str:
-    return (
-        _pauli_terms_to_qmod(cast(List[PauliTerm], hamiltonian))
-        if isinstance(hamiltonian[0], PauliTerm)
-        else _pauli_dict_to_str(cast(List[QmodPyStruct], hamiltonian))
-    )
+    return _pauli_terms_to_qmod(hamiltonian_to_pauli_terms(hamiltonian))
+
+
+def _hamiltonian_to_pauli_operator(hamiltonian: Hamiltonian) -> PauliOperator:
+    pauli_list = [
+        (
+            pauli_integers_to_str(elem.pauli),  # type: ignore[arg-type]
+            elem.coefficient,
+        )
+        for elem in hamiltonian_to_pauli_terms(hamiltonian)
+    ]
+    return PauliOperator(pauli_list=pauli_list)
 
 
 def serialize(
@@ -196,7 +211,7 @@ class ExecutionSession:
             SupportedPrimitives.SAMPLE, parameters=format_parameters(parameters)
         )
         self.program.execution_primitives_input = PrimitivesInput(
-            sample=[parameters] if parameters is not None else [{}]
+            sample=[parse_params(parameters)] if parameters is not None else [{}]
         )
         return execute(SerializedQuantumProgram(self.qprog))
 
@@ -229,7 +244,9 @@ class ExecutionSession:
         self.program.model.classical_execution_code = generate_code_snippet(
             SupportedPrimitives.BATCH_SAMPLE, parameters=format_parameters(parameters)
         )
-        self.program.execution_primitives_input = PrimitivesInput(sample=parameters)
+        self.program.execution_primitives_input = PrimitivesInput(
+            sample=[parse_params(params) for params in parameters]
+        )
         return execute(SerializedQuantumProgram(self.qprog))
 
     def estimate(
@@ -269,6 +286,14 @@ class ExecutionSession:
             parameters=format_parameters(parameters),
             hamiltonian=to_hamiltonian_str(hamiltonian),
         )
+        self.program.execution_primitives_input = PrimitivesInput(
+            estimate=EstimateInput(
+                hamiltonian=_hamiltonian_to_pauli_operator(hamiltonian),
+                parameters=(
+                    [parse_params(parameters)] if parameters is not None else [{}]
+                ),
+            )
+        )
         return execute(SerializedQuantumProgram(self.qprog))
 
     def batch_estimate(
@@ -308,4 +333,10 @@ class ExecutionSession:
             parameters=format_parameters(parameters),
             hamiltonian=to_hamiltonian_str(hamiltonian),
         )
+        self.program.execution_primitives_input = PrimitivesInput(
+            estimate=EstimateInput(
+                hamiltonian=_hamiltonian_to_pauli_operator(hamiltonian),
+                parameters=[parse_params(params) for params in parameters],
+            )
+        )
         return execute(SerializedQuantumProgram(self.qprog))

classiq/execution/jobs.py

@@ -162,11 +162,16 @@ class ExecutionJob:
             ClassiqAPIError: In case the job has failed.
         """
         results = self.result()
-        if len(results) != 1 or not isinstance(
-            results[0].value, MultipleExecutionDetails
-        ):
+        if len(results) != 1:
             raise ClassiqExecutionResultError("batch_sample")
-        return results[0].value.details
+
+        result = results[0].value
+        if isinstance(result, ExecutionDetails):
+            return [result]
+        if isinstance(result, MultipleExecutionDetails):
+            return result.details
+
+        raise ClassiqExecutionResultError("batch_sample")
 
     def get_estimate_result(self) -> EstimationResult:
         """
@@ -202,9 +207,16 @@ class ExecutionJob:
             ClassiqAPIError: In case the job has failed.
         """
         results = self.result()
-        if len(results) != 1 or not isinstance(results[0].value, EstimationResults):
+        if len(results) != 1:
             raise ClassiqExecutionResultError("batch_estimate")
-        return results[0].value.results
+
+        result = results[0].value
+        if isinstance(result, EstimationResult):
+            return [result]
+        if isinstance(result, EstimationResults):
+            return result.results
+
+        raise ClassiqExecutionResultError("batch_estimate")
 
     async def poll_async(self, timeout_sec: Optional[float] = None) -> None:
         if not self.status.is_final():

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

classiq/interface/execution/primitives.py

@@ -2,8 +2,16 @@ from typing import List, Optional
 
 from pydantic import BaseModel, Field
 
+from classiq.interface.chemistry.operator import PauliOperator
 from classiq.interface.executor.quantum_code import Arguments
+from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
 
 
-class PrimitivesInput(BaseModel):
+class EstimateInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
+    hamiltonian: PauliOperator
+    parameters: List[Arguments]
+
+
+class PrimitivesInput(BaseModel, json_encoders=CUSTOM_ENCODERS):
     sample: Optional[List[Arguments]] = Field(default=None)
+    estimate: Optional[EstimateInput] = Field(default=None)

classiq/interface/executor/iqae_result.py

@@ -1,6 +1,6 @@
-from typing import List, Tuple
+from typing import List
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 from classiq.interface.executor.result import ExecutionDetails
 from classiq.interface.generator.functions.classical_type import QmodPyObject
@@ -14,6 +14,6 @@ class IQAEIterationData(BaseModel):
 
 class IQAEResult(VersionedModel, QmodPyObject):
     estimation: float
-    confidence_interval: Tuple[float, float]
+    confidence_interval: List[float] = Field(min_items=2, max_items=2)
     iterations_data: List[IQAEIterationData]
     warnings: List[str]

classiq/interface/executor/result.py

@@ -305,7 +305,9 @@ class EstimationMetadata(BaseModel, extra=pydantic.Extra.allow):
 
 class EstimationResult(BaseModel, QmodPyObject):
     value: Complex = pydantic.Field(..., description="Estimation for the operator")
-    variance: Complex = pydantic.Field(..., description="Variance of the estimation")
+    variance: Optional[Complex] = pydantic.Field(
+        description="Variance of the estimation", default=None
+    )
     metadata: EstimationMetadata = pydantic.Field(
         ..., description="Metadata for the estimation"
     )

classiq/interface/generator/expressions/expression.py

@@ -69,6 +69,14 @@ class Expression(HashableASTNode):
         return self.as_constant(list)
 
     def _try_to_immediate_evaluate(self) -> None:
+        # FIXME remove special treatment (CAD-22999)
+        if self.expr == "SIGNED":
+            self._evaluated_expr = EvaluatedExpression(value=True)
+            return
+        if self.expr == "UNSIGNED":
+            self._evaluated_expr = EvaluatedExpression(value=False)
+            return
+
         try:
             result = ast.literal_eval(self.expr)
             if isinstance(result, (int, float, bool)):

classiq/interface/generator/functions/type_name.py

@@ -67,9 +67,7 @@ class TypeName(ClassicalType, QuantumType):  # type:ignore[misc]
         return self._assigned_fields
 
     def _set_fields(self, fields: Mapping[str, "ConcreteQuantumType"]) -> None:
-        from classiq.qmod.model_state_container import QMODULE
-
-        QMODULE.qstruct_decls[self.name].fields = fields
+        self._assigned_fields = fields
 
 
 class Enum(TypeName):

classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py

@@ -1,12 +1,26 @@
 from typing import Dict, Optional, Set
 
 import pydantic
+import sympy
 
 from classiq.interface.backend.pydantic_backend import PydanticExecutionParameter
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.parameters import ParameterType
 
 
 class FunctionExecutionData(pydantic.BaseModel):
-    power_parameter: Optional[PydanticExecutionParameter] = pydantic.Field(default=None)
+    power_parameter: Optional[ParameterType] = pydantic.Field(default=None)
+
+    @property
+    def power_var(self) -> Optional[str]:
+        if self.power_parameter is None:
+            return None
+        power_vars = sympy.sympify(self.power_parameter).free_symbols
+        if len(power_vars) != 1:
+            raise ClassiqValueError(
+                f"Power parameter expression: {self.power_parameter} must contain exactly one variable"
+            )
+        return str(list(power_vars)[0])
 
 
 class ExecutionData(pydantic.BaseModel):
@@ -19,7 +33,7 @@ class ExecutionData(pydantic.BaseModel):
         self,
     ) -> Set[PydanticExecutionParameter]:
         return {
-            function_execution_data.power_parameter
+            function_execution_data.power_var
             for function_execution_data in self.function_execution.values()
-            if function_execution_data.power_parameter is not None
+            if function_execution_data.power_var is not None
         }

classiq/interface/ide/visual_model.py

@@ -69,10 +69,9 @@ class Operation(pydantic.BaseModel):
     target_qubits: Tuple[int, ...]
     parameters: List[OperationParameter] = pydantic.Field(default_factory=list)
     operation_level: OperationLevel
-    # This field is meant to identify unique operations, such as variable initialization
-    # These will be visualized differently. We don't identify them yet, though, so
-    # we always set this field to be REGULAR
-    operation_type: OperationType = pydantic.Field(default=OperationType.REGULAR)
+    operation_type: OperationType = pydantic.Field(
+        description="Identifies unique operations that are visualized differently"
+    )
 
 
 class ProgramVisualModel(VersionedModel):

classiq/interface/model/bind_operation.py

@@ -56,6 +56,3 @@ class BindOperation(QuantumOperation):
                 raise ClassiqValueError(f"Cannot bind '{handle}'")
 
         return handles
-
-    def reversed(self) -> "BindOperation":
-        return BindOperation(in_handles=self.out_handles, out_handles=self.in_handles)

classiq/interface/model/port_declaration.py

@@ -1,25 +1,20 @@
-from typing import Any, Dict, Literal, Mapping, Optional
+from typing import Any, Dict, Literal, Mapping
 
 import pydantic
 
 from classiq.interface.exceptions import ClassiqInternalError, ClassiqValueError
-from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 from classiq.interface.model.parameter import Parameter
-from classiq.interface.model.quantum_variable_declaration import (
-    QuantumVariableDeclaration,
-)
 
 
 class AnonPortDeclaration(Parameter):
     kind: Literal["PortDeclaration"]
 
     quantum_type: ConcreteQuantumType
-    size: Optional[Expression] = pydantic.Field(default=None, exclude=True)
     direction: PortDeclarationDirection
 
     @pydantic.root_validator(pre=True)
@@ -37,12 +32,6 @@ class AnonPortDeclaration(Parameter):
 
         return direction
 
-    @pydantic.validator("size")
-    def _propagate_size_to_type(
-        cls, size: Optional[Expression], values: Mapping[str, Any]
-    ) -> Optional[Expression]:
-        return QuantumVariableDeclaration._propagate_size_to_type(size, values)
-
     def rename(self, new_name: str) -> "PortDeclaration":
         if type(self) not in (AnonPortDeclaration, PortDeclaration):
             raise ClassiqInternalError

classiq/interface/model/quantum_expressions/arithmetic_operation.py

@@ -1,7 +1,8 @@
-from typing import Dict, Literal, Mapping, Sequence
+from typing import Dict, Literal, Mapping, Optional, Sequence
 
 import pydantic
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.generator.arith.arithmetic import (
     ARITHMETIC_EXPRESSION_RESULT_NAME,
     compute_arithmetic_result_type,
@@ -17,13 +18,40 @@ from classiq.interface.model.quantum_statement import HandleMetadata
 from classiq.interface.model.quantum_type import QuantumType
 
 
+class ArithmeticOperationKind(StrEnum):
+    InplaceAdd = "inplace_add"
+    Assignment = "assignment"
+    InplaceXor = "inplace_xor"
+
+
 class ArithmeticOperation(QuantumAssignmentOperation):
     kind: Literal["ArithmeticOperation"]
 
-    inplace_result: bool = pydantic.Field(
+    inplace_result: Optional[bool] = pydantic.Field(
         description="Determines whether the result variable is initialized",
+        default=None,
+        exclude=True,
+    )
+
+    operation_kind: ArithmeticOperationKind = pydantic.Field(
+        default=ArithmeticOperationKind.InplaceXor,
     )
 
+    @property
+    def is_inplace(self) -> bool:
+        return self.get_operation_kind() in (
+            ArithmeticOperationKind.InplaceXor,
+            ArithmeticOperationKind.InplaceAdd,
+        )
+
+    def get_operation_kind(self) -> ArithmeticOperationKind:
+        if hasattr(self, "inplace_result"):
+            if self.inplace_result is False:
+                return ArithmeticOperationKind.Assignment
+            if self.inplace_result is True:
+                return ArithmeticOperationKind.InplaceXor
+        return self.operation_kind
+
     def initialize_var_types(
         self,
         var_types: Dict[str, QuantumType],
@@ -39,7 +67,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
         self,
     ) -> Mapping[str, ConcreteHandleBinding]:
         inouts = dict(super().wiring_inouts)
-        if self.inplace_result:
+        if self.is_inplace:
             inouts[self.result_name()] = self.result_var
         return inouts
 
@@ -49,7 +77,7 @@ class ArithmeticOperation(QuantumAssignmentOperation):
             HandleMetadata(handle=handle, readable_location="in an expression")
             for handle in self.var_handles
         ]
-        if self.inplace_result:
+        if self.is_inplace:
             inouts.append(
                 HandleMetadata(
                     handle=self.result_var,
@@ -60,13 +88,13 @@ class ArithmeticOperation(QuantumAssignmentOperation):
 
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        if self.inplace_result:
+        if self.is_inplace:
             return {}
         return super().wiring_outputs
 
     @property
     def readable_outputs(self) -> Sequence[HandleMetadata]:
-        if self.inplace_result:
+        if self.is_inplace:
             return []
         return [
             HandleMetadata(

classiq/interface/model/quantum_lambda_function.py

@@ -19,7 +19,7 @@ class QuantumLambdaFunction(ASTNode):
 
     rename_params: Dict[str, str] = pydantic.Field(
         default_factory=dict,
-        exclude=False,
+        exclude=True,
     )
 
     pos_rename_params: List[str] = pydantic.Field(
@@ -41,6 +41,9 @@ class QuantumLambdaFunction(ASTNode):
     def py_callable(self) -> Callable:
         return self._py_callable
 
+    def is_generative(self) -> bool:
+        return self.py_callable is not None
+
     def set_py_callable(self, py_callable: Callable) -> None:
         self._py_callable = py_callable
 

classiq/interface/model/quantum_statement.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
-from typing import Any, Dict, Mapping, Optional, Sequence
+from typing import Any, Callable, Dict, Mapping, Optional, Sequence
 
+import pydantic
 from pydantic import Extra, root_validator
 
 from classiq.interface.ast_node import ASTNode
@@ -29,6 +30,8 @@ class HandleMetadata:
 
 
 class QuantumOperation(QuantumStatement):
+    _generative_blocks: Dict[str, Callable] = pydantic.PrivateAttr(default_factory=dict)
+
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:
         return dict()
@@ -64,3 +67,15 @@ class QuantumOperation(QuantumStatement):
     @property
     def readable_outputs(self) -> Sequence[HandleMetadata]:
         return [HandleMetadata(handle=handle) for handle in self.outputs]
+
+    def set_generative_block(self, block_name: str, py_callable: Callable) -> None:
+        self._generative_blocks[block_name] = py_callable
+
+    def get_generative_block(self, block_name: str) -> Callable:
+        return self._generative_blocks[block_name]
+
+    def has_generative_block(self, block_name: str) -> bool:
+        return block_name in self._generative_blocks
+
+    def is_generative(self) -> bool:
+        return len(self._generative_blocks) > 0

classiq/interface/model/quantum_variable_declaration.py

@@ -1,29 +1,7 @@
-from typing import Any, Mapping, Optional
-
-import pydantic
-
 from classiq.interface.ast_node import ASTNode
-from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
-from classiq.interface.model.quantum_type import (
-    QuantumBitvector,
-    QuantumNumeric,
-)
 
 
 class QuantumVariableDeclaration(ASTNode):
     name: str
     quantum_type: ConcreteQuantumType
-    size: Optional[Expression] = pydantic.Field(default=None, exclude=True)
-
-    @pydantic.validator("size")
-    def _propagate_size_to_type(
-        cls, size: Optional[Expression], values: Mapping[str, Any]
-    ) -> Optional[Expression]:
-        if size is not None:
-            quantum_type = values.get("quantum_type")
-            if isinstance(quantum_type, QuantumBitvector):
-                quantum_type.length = size
-            elif isinstance(quantum_type, QuantumNumeric):
-                quantum_type.size = size
-        return size

classiq/interface/server/global_versions.py

@@ -1,13 +1,13 @@
-from datetime import date, datetime
-from typing import Any, Dict, Union
+from datetime import date
+from typing import Any, Dict
 
 import pydantic
 from pydantic import BaseModel
 
 
 class DeprecationInfo(BaseModel):
-    deprecation_date: Union[datetime, date] = pydantic.Field()
-    removal_date: Union[datetime, date] = pydantic.Field()
+    deprecation_date: date = pydantic.Field()
+    removal_date: date = pydantic.Field()
 
 
 class GlobalVersions(BaseModel):

classiq/model_expansions/capturing/propagated_var_stack.py

@@ -15,7 +15,7 @@ from classiq.interface.model.quantum_function_call import ArgValue
 from classiq.interface.model.quantum_statement import QuantumOperation
 
 from classiq.model_expansions.capturing.mangling_utils import mangle_captured_var_name
-from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
 from classiq.model_expansions.function_builder import OperationBuilder
 from classiq.model_expansions.scope import QuantumSymbol, Scope
 
@@ -144,7 +144,10 @@ class PropagatedVarStack:
     def _get_propagated_var_name(self, var: PropagatedVariable) -> str:
         if (
             var.defining_function == self._builder.current_function.name
-            or self._no_name_conflict(var)
+            or not isinstance(
+                self._builder.current_function, GenerativeFunctionClosure
+            )  # FIXME doesn't work for all cases (CAD-22663)
+            and self._no_name_conflict(var)
         ):
             handle_name = var.name
             if var in self._to_mangle:

classiq/model_expansions/closure.py

@@ -40,6 +40,11 @@ class Closure:
         }
 
 
+@dataclass(frozen=True)
+class GenerativeClosure(Closure):
+    generative_blocks: Dict[str, GenerativeQFunc] = None  # type:ignore[assignment]
+
+
 @dataclass(frozen=True)
 class FunctionClosure(Closure):
     is_lambda: bool = False
@@ -101,8 +106,8 @@ class FunctionClosure(Closure):
 
 
 @dataclass(frozen=True)
-class GenerativeFunctionClosure(FunctionClosure):
-    generative_function: GenerativeQFunc = None  # type:ignore[assignment]
+class GenerativeFunctionClosure(GenerativeClosure, FunctionClosure):
+    pass
 
 
 NestedFunctionClosureT = Union[FunctionClosure, List["NestedFunctionClosureT"]]

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -10,7 +10,6 @@ from classiq.interface.generator.functions.type_name import (
     TypeName,
 )
 from classiq.interface.model.bind_operation import BindOperation
-from classiq.interface.model.inplace_binary_operation import BinaryOperation
 from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
@@ -227,9 +226,3 @@ def validate_inplace_binary_op_vars(
         raise ClassiqExpansionError(
             f"Cannot perform `{operation_name}` operation with non numeric target {target_var.handle}"
         )
-    if operation_name != BinaryOperation.Xor.value and (
-        value_var.quantum_type.sign_value or target_var.quantum_type.sign_value
-    ):
-        raise ClassiqExpansionError(
-            f"Cannot perform `{operation_name}` operation with signed variables"
-        )