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

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -14,20 +14,23 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.model import Model, SerializedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_type import QuantumBitvector
 
 from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
-    _internal_pyo_model_to_hamiltonian,
     compute_qaoa_initial_point,
     convert_pyomo_to_global_presentation,
+    pyo_model_to_hamiltonian,
 )
 from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
-    _pauli_operator_to_qmod,
-    get_pauli_operator,
+    _pauli_terms_to_qmod,
 )
 from classiq.applications.combinatorial_optimization import OptimizerConfig, QAOAConfig
 
@@ -47,13 +50,10 @@ def construct_combi_opt_py_model(
     if optimizer_config.max_iteration is not None:
         max_iteration = optimizer_config.max_iteration
 
-    hamiltonian = _internal_pyo_model_to_hamiltonian(
-        pyo_model, qaoa_config.penalty_energy
-    )
+    hamiltonian = pyo_model_to_hamiltonian(pyo_model, qaoa_config.penalty_energy)
+    len_hamiltonian = len(hamiltonian[0].pauli)  # type: ignore[arg-type]
     qaoa_initial_point = compute_qaoa_initial_point(hamiltonian, qaoa_config.num_layers)
-    len_hamiltonian = len(hamiltonian[0]["pauli"])
-    pauli_oper = get_pauli_operator(hamiltonian)
-    pauli_qmod = _pauli_operator_to_qmod(pauli_oper)
+    pauli_qmod = _pauli_terms_to_qmod(hamiltonian)
 
     initial_point_expression = (
         f"{optimizer_config.initial_point}"
@@ -72,34 +72,37 @@ def construct_combi_opt_py_model(
         functions=[
             NativeFunctionDefinition(
                 name="main",
-                param_decls={
-                    "params_list": ClassicalArray(
-                        element_type=Real(), size=qaoa_config.num_layers * 2
-                    )
-                },
-                port_declarations={
-                    "target": PortDeclaration(
+                positional_arg_declarations=[
+                    ClassicalParameterDeclaration(
+                        name="params_list",
+                        classical_type=ClassicalArray(
+                            element_type=Real(), size=qaoa_config.num_layers * 2
+                        ),
+                    ),
+                    PortDeclaration(
                         name="target",
-                        size=Expression(expr=f"{len_hamiltonian}"),
+                        quantum_type=QuantumBitvector(
+                            length=Expression(expr=f"{len_hamiltonian}"),
+                        ),
                         direction=PortDeclarationDirection.Output,
                     ),
-                },
+                ],
                 body=[
                     QuantumFunctionCall(
                         function="allocate",
                         positional_args=[
-                            Expression(expr="target.len"),
+                            Expression(expr="get_field(target, 'len')"),
                             HandleBinding(name="target"),
                         ],
                     ),
                     QuantumFunctionCall(
                         function="qaoa_penalty",
-                        params={
-                            "num_qubits": Expression(expr="target.len"),
-                            "params_list": Expression(expr="params_list"),
-                            "hamiltonian": Expression(expr="hamiltonian"),
-                        },
-                        inouts={"target": HandleBinding(name="target")},
+                        positional_args=[
+                            Expression(expr="get_field(target, 'len')"),
+                            Expression(expr="params_list"),
+                            Expression(expr="hamiltonian"),
+                            HandleBinding(name="target"),
+                        ],
                     ),
                 ],
             ),
@@ -118,7 +121,7 @@ alpha_cvar={optimizer_config.alpha_cvar}
 )
 
 save({{"vqe_result": vqe_result, "hamiltonian": hamiltonian}})
-""",
+""".strip(),
     )
 
 

classiq/applications/finance/finance_model_constructor.py

@@ -14,6 +14,7 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
+from classiq.interface.model.quantum_type import QuantumBitvector
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -66,13 +67,15 @@ def construct_finance_model(
             *QMCI_LIBRARY,
             NativeFunctionDefinition(
                 name="main",
-                port_declarations={
-                    "phase_port": PortDeclaration(
+                positional_arg_declarations=[
+                    PortDeclaration(
                         name="phase_port",
-                        size=Expression(expr=f"{phase_port_size}"),
+                        quantum_type=QuantumBitvector(
+                            length=Expression(expr=f"{phase_port_size}")
+                        ),
                         direction=PortDeclarationDirection.Output,
                     ),
-                },
+                ],
                 body=[
                     VariableDeclarationStatement(name="unitary_port"),
                     QuantumFunctionCall(
@@ -93,40 +96,34 @@ def construct_finance_model(
                     ),
                     QuantumFunctionCall(
                         function="qmci",
-                        operands={
-                            "space_transform": QuantumLambdaFunction(
+                        positional_args=[
+                            QuantumLambdaFunction(
                                 body=[
                                     QuantumFunctionCall(
                                         function=finance_function,
-                                        params={
-                                            "finance_model": Expression(
-                                                expr=finance_model
-                                            ),
-                                            "finance_function": Expression(
-                                                expr=finance_function_object
-                                            ),
-                                        },
-                                        inouts={
-                                            "func_port": HandleBinding(name="arg0"),
-                                            "obj_port": HandleBinding(name="arg1"),
-                                        },
+                                        positional_args=[
+                                            Expression(expr=finance_model),
+                                            Expression(expr=finance_function_object),
+                                            HandleBinding(name="arg0"),
+                                            HandleBinding(name="arg1"),
+                                        ],
                                     ),
                                 ],
                             ),
-                        },
-                        inouts={
-                            "phase": HandleBinding(name="phase_port"),
-                            "packed_vars": HandleBinding(name="unitary_port"),
-                        },
+                            HandleBinding(name="phase_port"),
+                            HandleBinding(name="unitary_port"),
+                        ],
                     ),
                 ],
             ),
         ],
-        classical_execution_code=AE_CLASSICAL_LIBRARY
-        + f"""
+        classical_execution_code=(
+            AE_CLASSICAL_LIBRARY
+            + f"""
 estimation = execute_amplitude_estimation({phase_port_size})
 {_OUTPUT_VARIABLE_NAME} = {post_process_function}({finance_model}, {finance_function_object}, estimation)
 save({{{_OUTPUT_VARIABLE_NAME!r}: {_OUTPUT_VARIABLE_NAME}}})
-""",
+"""
+        ).strip(),
     )
     return model.get_model()

classiq/applications/grover/grover_model_constructor.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Tuple
+from typing import List, Tuple
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
@@ -14,7 +14,7 @@ from classiq.interface.model.quantum_expressions.arithmetic_operation import (
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_lambda_function import QuantumLambdaFunction
-from classiq.interface.model.quantum_type import QuantumNumeric
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -26,16 +26,18 @@ _OUTPUT_VARIABLE_NAME = "result"
 _PREDICATE_FUNCTION_NAME = "expr_predicate"
 
 
-def _arithmetic_oracle_io_dict(
+def _arithmetic_oracle_ios(
     definitions: List[Tuple[str, RegisterUserInput]], handle_name: str
-) -> Dict[str, HandleBinding]:
+) -> List[HandleBinding]:
     cursor = 0
-    ios: Dict[str, HandleBinding] = dict()
-    for reg_name, reg in definitions:
-        ios[reg_name] = SlicedHandleBinding(
-            name=handle_name,
-            start=Expression(expr=f"{cursor}"),
-            end=Expression(expr=f"{cursor + reg.size}"),
+    ios: List[HandleBinding] = []
+    for _, reg in definitions:
+        ios.append(
+            SlicedHandleBinding(
+                name=handle_name,
+                start=Expression(expr=f"{cursor}"),
+                end=Expression(expr=f"{cursor + reg.size}"),
+            )
         )
         cursor += reg.size
     return ios
@@ -45,34 +47,31 @@ def _construct_arithmetic_oracle(
     predicate_function: str,
     definitions: List[Tuple[str, RegisterUserInput]],
 ) -> QuantumFunctionCall:
-    predicate_var_binding = _arithmetic_oracle_io_dict(definitions, "arg0")
-    predicate_var_binding["res"] = HandleBinding(name="arg1")
+    predicate_var_binding = _arithmetic_oracle_ios(definitions, "arg0")
+    predicate_var_binding.append(HandleBinding(name="arg1"))
     return QuantumFunctionCall(
         function="phase_oracle",
-        inouts={
-            "target": HandleBinding(name="arg0"),
-        },
-        operands={
-            "predicate": QuantumLambdaFunction(
+        positional_args=[
+            QuantumLambdaFunction(
                 body=[
                     QuantumFunctionCall(
                         function=predicate_function,
-                        inouts=predicate_var_binding,
+                        positional_args=predicate_var_binding,
                     ),
                 ],
             ),
-        },
+            HandleBinding(name="arg0"),
+        ],
     )
 
 
 def grover_main_port_declarations(
     definitions: List[Tuple[str, RegisterUserInput]],
     direction: PortDeclarationDirection,
-) -> Dict[str, PortDeclaration]:
-    return {
-        name: PortDeclaration(
+) -> List[PortDeclaration]:
+    return [
+        PortDeclaration(
             name=name,
-            size=Expression(expr=f"{reg.size}"),
             quantum_type=QuantumNumeric(
                 size=Expression(expr=f"{reg.size}"),
                 is_signed=Expression(expr=f"{reg.is_signed}"),
@@ -81,7 +80,7 @@ def grover_main_port_declarations(
             direction=direction,
         )
         for name, reg in definitions
-    }
+    ]
 
 
 def construct_grover_model(
@@ -92,10 +91,12 @@ def construct_grover_model(
     predicate_port_decls = grover_main_port_declarations(
         definitions, PortDeclarationDirection.Inout
     )
-    predicate_port_decls["res"] = PortDeclaration(
-        name="res",
-        size=Expression(expr="1"),
-        direction=PortDeclarationDirection.Inout,
+    predicate_port_decls.append(
+        PortDeclaration(
+            name="res",
+            quantum_type=QuantumBitvector(length=Expression(expr="1")),
+            direction=PortDeclarationDirection.Inout,
+        )
     )
     num_qubits = sum(reg.size for _, reg in definitions)
 
@@ -103,7 +104,7 @@ def construct_grover_model(
         functions=[
             NativeFunctionDefinition(
                 name=_PREDICATE_FUNCTION_NAME,
-                port_declarations=predicate_port_decls,
+                positional_arg_declarations=predicate_port_decls,
                 body=[
                     ArithmeticOperation(
                         expression=Expression(expr=expression),
@@ -114,7 +115,7 @@ def construct_grover_model(
             ),
             NativeFunctionDefinition(
                 name="main",
-                port_declarations=grover_main_port_declarations(
+                positional_arg_declarations=grover_main_port_declarations(
                     definitions, PortDeclarationDirection.Output
                 ),
                 body=[
@@ -128,20 +129,18 @@ def construct_grover_model(
                     ),
                     QuantumFunctionCall(
                         function="grover_search",
-                        params={
-                            "reps": Expression(expr=f"{num_reps}"),
-                        },
-                        inouts={"packed_vars": HandleBinding(name="packed_vars")},
-                        operands={
-                            "oracle": QuantumLambdaFunction(
+                        positional_args=[
+                            Expression(expr=f"{num_reps}"),
+                            QuantumLambdaFunction(
                                 body=[
                                     _construct_arithmetic_oracle(
                                         _PREDICATE_FUNCTION_NAME,
                                         definitions,
                                     )
                                 ]
-                            )
-                        },
+                            ),
+                            HandleBinding(name="packed_vars"),
+                        ],
                     ),
                     BindOperation(
                         in_handles=[HandleBinding(name="packed_vars")],

classiq/applications/qsvm/qsvm.py

@@ -1,10 +1,9 @@
 from typing import List
 
-from classiq.interface.applications.qsvm import Data, Labels, QSVMData, QSVMPreferences
+from classiq.interface.applications.qsvm import Data, Labels, QSVMData
 
 __all__ = [
     "QSVMData",
-    "QSVMPreferences",
     "Data",
     "Labels",
 ]

classiq/applications/qsvm/qsvm_model_constructor.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Tuple
+from typing import Any, List, Tuple
 
 from classiq.interface.applications.qsvm import DataList, LabelsInt
 from classiq.interface.generator.expressions.enums.pauli import Pauli
@@ -24,10 +24,10 @@ _OUTPUT_VARIABLE_NAME = "qsvm_results"
 
 def _bloch_sphere_feature_map_function_params(
     bloch_feature_dimension: int,
-) -> Tuple[Dict[str, Expression], str]:
-    return {
-        "feature_dimension": Expression(expr=f"{bloch_feature_dimension}")
-    }, f"ceiling({bloch_feature_dimension}/2)"
+) -> Tuple[List[Expression], str]:
+    return [
+        Expression(expr=f"{bloch_feature_dimension}")
+    ], f"ceiling({bloch_feature_dimension}/2)"
 
 
 def _pauli_feature_map_function_params(
@@ -36,7 +36,7 @@ def _pauli_feature_map_function_params(
     alpha: int,
     reps: int,
     feature_dimension: int,
-) -> Tuple[Dict[str, Expression], str]:
+) -> Tuple[List[Expression], str]:
     paulis_str = (
         "["
         + ",".join(
@@ -51,11 +51,11 @@ def _pauli_feature_map_function_params(
         f"reps={reps}, "
         f"feature_dimension={feature_dimension}"
     )
-    return {
-        "feature_map": Expression(
+    return [
+        Expression(
             expr=f"struct_literal(QSVMFeatureMapPauli, {pauli_feature_map_params})"
         )
-    }, f"{feature_dimension}"
+    ], f"{feature_dimension}"
 
 
 def get_qsvm_qmain_body(
@@ -75,8 +75,7 @@ def get_qsvm_qmain_body(
         ),
         QuantumFunctionCall(
             function=feature_map_function_name,
-            params=params,
-            inouts={"qbv": HandleBinding(name="qbv")},
+            positional_args=[*params, HandleBinding(name="qbv")],
         ),
     ]
 
@@ -94,12 +93,12 @@ def construct_qsvm_model(
         functions=[
             NativeFunctionDefinition(
                 name="main",
-                port_declarations={
-                    "qbv": PortDeclaration(
+                positional_arg_declarations=[
+                    PortDeclaration(
                         name="qbv",
                         direction=PortDeclarationDirection.Output,
-                    )
-                },
+                    ),
+                ],
                 body=get_qsvm_qmain_body(
                     feature_map_function_name=feature_map_function_name, **kwargs
                 ),
@@ -114,7 +113,7 @@ def construct_qsvm_model(
     predict_data={predict_data}
 )
 save({{{_OUTPUT_VARIABLE_NAME!r}: {_OUTPUT_VARIABLE_NAME}}})
-""",
+""".strip(),
     )
 
     return qsvm_qmod.get_model()

classiq/execution/__init__.py

@@ -9,7 +9,9 @@ from ..interface.executor.execution_preferences import __all__ as _ep_all
 from ..interface.executor.iqae_result import IQAEResult
 from ..interface.executor.result import ExecutionDetails
 from ..interface.executor.vqe_result import VQESolverResult
+from .execution_session import ExecutionSession
 from .jobs import ExecutionJob, get_execution_jobs, get_execution_jobs_async
+from .qnn import execute_qnn
 
 __all__ = (
     _be_all
@@ -22,6 +24,8 @@ __all__ = (
         "ExecutionJob",
         "get_execution_jobs",
         "get_execution_jobs_async",
+        "ExecutionSession",
+        "execute_qnn",
     ]
 )
 

classiq/execution/execution_session.py

@@ -0,0 +1,151 @@
+import json
+from typing import Any, Callable, Dict, List, Optional, Union, cast
+
+from classiq.interface.executor.execution_preferences import ExecutionPreferences
+from classiq.interface.executor.execution_result import ResultsCollection
+from classiq.interface.executor.result import (
+    EstimationResult,
+    EstimationResults,
+    ExecutionDetails,
+    MultipleExecutionDetails,
+)
+from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
+from classiq.interface.generator.quantum_program import QuantumProgram
+
+from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
+    _pauli_dict_to_str,
+    _pauli_terms_to_qmod,
+)
+from classiq.exceptions import ClassiqValueError
+from classiq.executor import execute
+from classiq.qmod.builtins import PauliTerm
+from classiq.qmod.builtins.classical_execution_primitives import ExecutionParams
+from classiq.synthesis import SerializedQuantumProgram
+
+Hamiltonian = Union[List[QmodPyStruct], List[PauliTerm]]
+Program = Union[SerializedQuantumProgram, QuantumProgram]
+ExecutionParameters = Union[None, ExecutionParams, List[ExecutionParams]]
+
+SAVE_RESULT = "\nsave({'result': result})\n"
+
+
+class SupportedPrimitives:
+    SAMPLE = "sample"
+    BATCH_SAMPLE = "batch_sample"
+    ESTIMATE = "estimate"
+    BATCH_ESTIMATE = "batch_estimate"
+
+
+def _deserialize_program(program: Program) -> QuantumProgram:
+    return (
+        program
+        if isinstance(program, QuantumProgram)
+        else QuantumProgram.parse_obj(json.loads(program))
+    )
+
+
+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))
+    )
+
+
+def format_parameters(execution_params: ExecutionParameters) -> str:
+    return json.dumps(execution_params, default=str) if execution_params else ""
+
+
+def create_estimate_execution_code(operation: str, **kwargs: Any) -> str:
+    hamiltonian = kwargs.get("hamiltonian", "")
+    parameters = kwargs.get("parameters", "")
+    return f"\nresult = {operation}([{hamiltonian}], {parameters})" + SAVE_RESULT
+
+
+def create_sample_execution_code(operation: str, **kwargs: Any) -> str:
+    parameters = kwargs.get("parameters", "")
+    return f"\nresult = {operation}({parameters})" + SAVE_RESULT
+
+
+operation_handlers: Dict[str, Callable[[str], str]] = {
+    "estimate": create_estimate_execution_code,
+    "batch_estimate": create_estimate_execution_code,
+    "sample": create_sample_execution_code,
+    "batch_sample": create_sample_execution_code,
+}
+
+
+def generate_code_snippet(operation: str, **kwargs: Any) -> str:
+    handler = operation_handlers.get(operation)
+    if handler:
+        return handler(operation, **kwargs)
+    raise ClassiqValueError(f"Unsupported operation type: {operation}")
+
+
+class ExecutionSession:
+    def __init__(
+        self,
+        quantum_program: Program,
+        execution_preferences: Optional[ExecutionPreferences] = None,
+    ):
+        self.program: QuantumProgram = _deserialize_program(quantum_program)
+        self.update_execution_preferences(execution_preferences)
+
+    @property
+    def qprog(self) -> str:
+        return SerializedQuantumProgram(self.program.json(indent=2))
+
+    def update_execution_preferences(
+        self, execution_preferences: Optional[ExecutionPreferences]
+    ) -> None:
+        if execution_preferences is not None:
+            self.program.model.execution_preferences = execution_preferences
+
+    def execute_quantum_program(
+        self, operation: str, **kwargs: Any
+    ) -> ResultsCollection:
+        self.program.model.classical_execution_code = generate_code_snippet(
+            operation, **kwargs
+        )
+        return execute(self.qprog).result()
+
+    def sample(self, parameters: Optional[ExecutionParams] = None) -> ExecutionDetails:
+        return cast(
+            ExecutionDetails,
+            self.execute_quantum_program(
+                SupportedPrimitives.SAMPLE, parameters=format_parameters(parameters)
+            )[0].value,
+        )
+
+    def batch_sample(self, parameters: List[ExecutionParams]) -> List[ExecutionDetails]:
+        return cast(
+            MultipleExecutionDetails,
+            self.execute_quantum_program(
+                SupportedPrimitives.BATCH_SAMPLE,
+                parameters=format_parameters(parameters),
+            )[0].value,
+        ).details
+
+    def estimate(
+        self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
+    ) -> EstimationResult:
+        return cast(
+            EstimationResult,
+            self.execute_quantum_program(
+                SupportedPrimitives.ESTIMATE,
+                parameters=format_parameters(parameters),
+                hamiltonian=to_hamiltonian_str(hamiltonian),
+            )[0].value,
+        )
+
+    def batch_estimate(
+        self, hamiltonian: Hamiltonian, parameters: List[ExecutionParams]
+    ) -> List[EstimationResult]:
+        return cast(
+            EstimationResults,
+            self.execute_quantum_program(
+                SupportedPrimitives.BATCH_ESTIMATE,
+                parameters=format_parameters(parameters),
+                hamiltonian=to_hamiltonian_str(hamiltonian),
+            )[0].value,
+        ).results