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

classiq/__init__.py

@@ -9,7 +9,8 @@ from classiq.interface.generator.arith.register_user_input import (
     RegisterUserInput,
 )
 from classiq.interface.generator.control_state import ControlState
-from classiq.interface.generator.expressions.enums.pauli import Pauli
+from classiq.interface.generator.expressions.enums import *  # noqa: F403
+from classiq.interface.generator.expressions.enums import __all__ as _enums_all
 from classiq.interface.generator.functions import *  # noqa: F403
 from classiq.interface.generator.functions import __all__ as _ifunc_all
 from classiq.interface.generator.model import *  # noqa: F403
@@ -33,6 +34,7 @@ from classiq.applications.chemistry import (
     molecule_problem_to_qmod,
 )
 from classiq.applications.combinatorial_optimization import (
+    compute_qaoa_initial_point,
     construct_combinatorial_optimization_model,
     pyo_model_to_hamiltonian,
 )
@@ -95,13 +97,13 @@ __all__ = (
         "set_execution_preferences",
         "set_quantum_program_execution_preferences",
         "show",
-        "Pauli",
     ]
     + _md_all
     + _ifunc_all
     + _sub_modules
     + _application_constructors_all
     + _qmod_all
+    + _enums_all
 )
 
 

classiq/_internals/api_wrapper.py

@@ -12,7 +12,7 @@ from classiq.interface.execution.jobs import (
     ExecutionJobDetailsV1,
     ExecutionJobsQueryResultsV1,
 )
-from classiq.interface.executor import execution_request, result as execute_result
+from classiq.interface.executor import execution_request
 from classiq.interface.generator import quantum_program as generator_result
 from classiq.interface.hardware import HardwareInformation
 from classiq.interface.jobs import (
@@ -22,7 +22,7 @@ from classiq.interface.jobs import (
     JobID,
     JSONObject,
 )
-from classiq.interface.model.common_model_types import ModelInput
+from classiq.interface.model.model import Model
 from classiq.interface.server import routes
 
 from classiq._internals.client import client
@@ -101,7 +101,7 @@ class ApiWrapper:
 
     @classmethod
     async def call_generation_task(
-        cls, model: ModelInput
+        cls, model: Model
     ) -> generator_result.QuantumProgram:
         poller = JobPoller(base_url=routes.TASKS_GENERATE_FULL_PATH)
         result = await poller.run_pydantic(model, timeout_sec=None)
@@ -192,24 +192,6 @@ class ApiWrapper:
         )
         return ExecutionJobsQueryResultsV1.parse_obj(data)
 
-    @classmethod
-    async def call_execute_estimate(
-        cls, request: execution_request.ExecutionRequest
-    ) -> execute_result.EstimationResults:
-        poller = JobPoller(base_url=routes.EXECUTE_ESTIMATE_FULL_PATH)
-        result = await poller.run_pydantic(request, timeout_sec=None)
-        return _parse_job_response(result, execute_result.EstimationResults)
-
-    @classmethod
-    async def call_execute_quantum_program(
-        cls, request: execution_request.ExecutionRequest
-    ) -> execute_result.MultipleExecutionDetails:
-        poller = JobPoller(
-            base_url=routes.EXECUTE_QUANTUM_PROGRAM_FULL_PATH,
-        )
-        result = await poller.run_pydantic(request, timeout_sec=None)
-        return _parse_job_response(result, execute_result.MultipleExecutionDetails)
-
     @classmethod
     async def call_analysis_task(
         cls, params: analysis_params.AnalysisParams

classiq/applications/chemistry/chemistry_model_constructor.py

@@ -20,12 +20,14 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.function_params import IOName
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
-    ClassicalType,
     Real,
 )
 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
@@ -65,137 +67,120 @@ _MOLECULE_PROBLEM_RESULT = "molecule_result"
 _HAE_GATE_MAPPING: Dict[str, QuantumFunctionCall] = {
     "h": QuantumFunctionCall(
         function="H",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "x": QuantumFunctionCall(
         function="X",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "y": QuantumFunctionCall(
         function="Y",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "z": QuantumFunctionCall(
         function="Z",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "i": QuantumFunctionCall(
         function="I",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "s": QuantumFunctionCall(
         function="S",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "t": QuantumFunctionCall(
         function="T",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "sdg": QuantumFunctionCall(
         function="SDG",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "tdg": QuantumFunctionCall(
         function="TDG",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "p": QuantumFunctionCall(
         function="PHASE",
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[HandleBinding(name="q")],
     ),
     "rx": QuantumFunctionCall(
         function="RX",
-        params={"theta": Expression(expr="angle")},
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
     ),
     "ry": QuantumFunctionCall(
         function="RY",
-        params={"theta": Expression(expr="angle")},
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
     ),
     "rz": QuantumFunctionCall(
         function="RZ",
-        params={"theta": Expression(expr="angle")},
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
     ),
     "rxx": QuantumFunctionCall(
         function="RXX",
-        params={"theta": Expression(expr="angle")},
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
     ),
     "ryy": QuantumFunctionCall(
         function="RYY",
-        params={"theta": Expression(expr="angle")},
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
     ),
     "rzz": QuantumFunctionCall(
         function="RZZ",
-        params={"theta": Expression(expr="angle")},
-        inouts={"target": HandleBinding(name="q")},
+        positional_args=[Expression(expr="angle"), HandleBinding(name="q")],
     ),
     "ch": QuantumFunctionCall(
         function="CH",
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
     ),
     "cx": QuantumFunctionCall(
         function="CX",
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
     ),
     "cy": QuantumFunctionCall(
         function="CY",
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
     ),
     "cz": QuantumFunctionCall(
         function="CZ",
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
     ),
     "crx": QuantumFunctionCall(
         function="CRX",
         params={"theta": Expression(expr="angle")},
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[
+            Expression(expr="angle"),
+            HandleBinding(name="q1"),
+            HandleBinding(name="q2"),
+        ],
     ),
     "cry": QuantumFunctionCall(
         function="CRY",
-        params={"theta": Expression(expr="angle")},
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[
+            Expression(expr="angle"),
+            HandleBinding(name="q1"),
+            HandleBinding(name="q2"),
+        ],
     ),
     "crz": QuantumFunctionCall(
         function="CRZ",
-        params={"theta": Expression(expr="angle")},
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[
+            Expression(expr="angle"),
+            HandleBinding(name="q1"),
+            HandleBinding(name="q2"),
+        ],
     ),
     "cp": QuantumFunctionCall(
         function="CPHASE",
-        params={"theta": Expression(expr="angle")},
-        inouts={
-            "target": HandleBinding(name="q1"),
-            "control": HandleBinding(name="q2"),
-        },
+        positional_args=[
+            Expression(expr="angle"),
+            HandleBinding(name="q1"),
+            HandleBinding(name="q2"),
+        ],
     ),
     "swap": QuantumFunctionCall(
         function="SWAP",
-        inouts={"qbit0": HandleBinding(name="q1"), "qbit1": HandleBinding(name="q2")},
+        positional_args=[HandleBinding(name="q1"), HandleBinding(name="q2")],
     ),
 }
 
@@ -297,18 +282,18 @@ def _get_chemistry_function(
     chemistry_problem: CHEMISTRY_PROBLEMS_TYPE,
     chemistry_function_name: str,
     inouts: Mapping[IOName, HandleBinding],
-    ansatz_parameters_expressions: Optional[Dict[str, Expression]] = None,
+    ansatz_parameters_expressions: Optional[List[Expression]] = None,
 ) -> QuantumFunctionCall:
     problem_prefix = _CHEMISTRY_PROBLEM_PREFIX_MAPPING[type(chemistry_problem)]
     return QuantumFunctionCall(
         function=f"{problem_prefix}_{chemistry_function_name}",
-        params={
-            f"{problem_prefix}_problem": Expression(
+        positional_args=[
+            Expression(
                 expr=_convert_library_problem_to_qmod_problem(chemistry_problem)
             ),
-            **(ansatz_parameters_expressions or dict()),
-        },
-        inouts=inouts,
+            *(ansatz_parameters_expressions or []),
+            *inouts.values(),
+        ],
     )
 
 
@@ -325,28 +310,26 @@ def _get_hartree_fock(
 def _get_hea_function(hea_parameters: HEAParameters) -> QuantumFunctionCall:
     return QuantumFunctionCall(
         function="full_hea",
-        params={
-            "num_qubits": Expression(expr=f"{hea_parameters.num_qubits}"),
-            "is_parametrized": Expression(
+        positional_args=[
+            Expression(expr=f"{hea_parameters.num_qubits}"),
+            Expression(
                 expr=f"{[int(_is_parametric_gate(_HAE_GATE_MAPPING[gate])) for gate in hea_parameters.one_qubit_gates+hea_parameters.two_qubit_gates]}"
             ),
-            "angle_params": Expression(expr="t"),
-            "connectivity_map": Expression(
+            Expression(expr="t"),
+            Expression(
                 expr=f"{[list(connectivity_pair) for connectivity_pair in hea_parameters.connectivity_map]}"
             ),
-            "reps": Expression(expr=f"{hea_parameters.reps}"),
-        },
-        operands={
-            "operands_1qubit": [
+            Expression(expr=f"{hea_parameters.reps}"),
+            [
                 QuantumLambdaFunction(body=[_HAE_GATE_MAPPING[gate]])
                 for gate in hea_parameters.one_qubit_gates
             ],
-            "operands_2qubit": [
+            [
                 QuantumLambdaFunction(body=[_HAE_GATE_MAPPING[gate]])
                 for gate in hea_parameters.two_qubit_gates
             ],
-        },
-        inouts={"x": HandleBinding(name="qbv")},
+            HandleBinding(name="qbv"),
+        ],
     )
 
 
@@ -360,10 +343,10 @@ def _get_ansatz(
         chemistry_problem,
         _ANSATZ_PARAMETERS_FUNCTION_NAME_MAPPING[type(ansatz_parameters)],
         {"qbv": HandleBinding(name="qbv")},
-        {
-            param_name: Expression(expr=str(param_value))
+        [
+            Expression(expr=str(param_value))
             for param_name, param_value in ansatz_parameters.__dict__.items()
-        },
+        ],
     )
 
 
@@ -391,7 +374,9 @@ save({{{_MOLECULE_PROBLEM_RESULT!r}: {_MOLECULE_PROBLEM_RESULT}}})
 
 
 def _is_parametric_gate(call: QuantumFunctionCall) -> bool:
-    return len(call.params) > 0
+    return len(call.params) > 0 or any(
+        isinstance(arg, Expression) for arg in call.positional_args
+    )
 
 
 def _get_execution_result_post_processing_statements(
@@ -420,14 +405,18 @@ def _get_hea_port_size(hea_parameters: HEAParameters) -> int:
 
 def _get_chemistry_quantum_main_params(
     ansatz_parameters: AnsatzParameters,
-) -> Dict[str, ClassicalType]:
+) -> List[ClassicalParameterDeclaration]:
     if not isinstance(ansatz_parameters, HEAParameters):
-        return dict()
-    return {
-        "t": ClassicalArray(
-            element_type=Real(), size=_get_hea_port_size(ansatz_parameters)
-        )
-    }
+        return []
+    return [
+        ClassicalParameterDeclaration(
+            name="t",
+            classical_type=ClassicalArray(
+                element_type=Real(),
+                size=_get_hea_port_size(ansatz_parameters),
+            ),
+        ),
+    ]
 
 
 def _get_problem_to_hamiltonian_name(chemistry_problem: CHEMISTRY_PROBLEMS_TYPE) -> str:
@@ -459,14 +448,10 @@ def _get_chemistry_quantum_main(
 
     return NativeFunctionDefinition(
         name="main",
-        param_decls=_get_chemistry_quantum_main_params(ansatz_parameters),
-        port_declarations=(
-            {
-                "qbv": PortDeclaration(
-                    name="qbv", direction=PortDeclarationDirection.Output
-                )
-            }
-        ),
+        positional_arg_declarations=_get_chemistry_quantum_main_params(
+            ansatz_parameters
+        )
+        + [PortDeclaration(name="qbv", direction=PortDeclarationDirection.Output)],
         body=body,
     )
 
@@ -476,14 +461,15 @@ def _get_chemistry_classical_code(
     execution_parameters: ChemistryExecutionParameters,
 ) -> str:
     qmod_problem = _convert_library_problem_to_qmod_problem(chemistry_problem)
-    return f"""
+    return (
+        f"""
 {_EXECUTION_RESULT} = vqe(
     hamiltonian={_get_problem_to_hamiltonian_name(chemistry_problem)}({qmod_problem}), {_get_chemistry_vqe_additional_params(execution_parameters)}
 )
 save({{{_EXECUTION_RESULT!r}: {_EXECUTION_RESULT}}})
-""" + _get_execution_result_post_processing_statements(
-        chemistry_problem
-    )
+"""
+        + _get_execution_result_post_processing_statements(chemistry_problem)
+    ).strip()
 
 
 def construct_chemistry_model(

classiq/applications/combinatorial_helpers/combinatorial_problem_utils.py

@@ -1,5 +1,5 @@
 import itertools
-from typing import List, Union, cast
+from typing import List, Union
 
 import numpy as np
 import pyomo.environ as pyo
@@ -9,7 +9,6 @@ from classiq.interface.combinatorial_optimization.solver_types import QSolver
 from classiq.interface.executor.vqe_result import VQESolverResult
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 
-from classiq import Pauli
 from classiq.applications.combinatorial_helpers.optimization_model import (
     OptimizationModel,
 )
@@ -17,7 +16,6 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_sparsing imp
     SparsePauliOp,
 )
 from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
-    get_pauli_operator,
     pauli_operator_to_hamiltonian,
 )
 from classiq.applications.combinatorial_helpers.pyomo_utils import (
@@ -27,12 +25,12 @@ from classiq.qmod.builtins import PauliTerm
 
 
 def compute_qaoa_initial_point(
-    hamiltonian: List[QmodPyStruct],
+    hamiltonian: List[PauliTerm],
     repetitions: int,
 ) -> List[float]:
-    coeffs_ising = [pauli_term["coefficient"] for pauli_term in hamiltonian[1:]]
+    coeffs_ising = [pauli_term.coefficient for pauli_term in hamiltonian[1:]]
     # the first coeff is the II...I term
-    coeffs_abs = np.abs(coeffs_ising)
+    coeffs_abs = np.abs(coeffs_ising)  # type: ignore[arg-type]
     coeffs_largest = np.sort(coeffs_abs)[len(coeffs_ising) // 2 :]
     operator_norm = np.mean(coeffs_largest)
     time_step = 1 / (2 * operator_norm)  # adapted such that for MAXCUT time_step = 1
@@ -42,31 +40,15 @@ def compute_qaoa_initial_point(
     return list(itertools.chain(*zip(gamma_params, beta_params)))
 
 
-def _internal_pyo_model_to_hamiltonian(
+def pyo_model_to_hamiltonian(
     pyo_model: pyo.ConcreteModel, penalty_energy: float
-) -> List[QmodPyStruct]:
+) -> List[PauliTerm]:
     pauli_list = OptimizationModel(
         pyo_model, penalty_energy=penalty_energy, qsolver=QSolver.QAOAPenalty
     ).ising.pauli_list
     return pauli_operator_to_hamiltonian(pauli_list)
 
 
-def pyo_model_to_hamiltonian(
-    pyo_model: pyo.ConcreteModel, penalty_energy: float
-) -> List[PauliTerm]:
-    hamiltonian = _internal_pyo_model_to_hamiltonian(pyo_model, penalty_energy)
-    pauli_operator = get_pauli_operator(hamiltonian).pauli_list
-    pauli_terms = []
-    for item in pauli_operator:
-        term = PauliTerm(
-            [Pauli[p] for p in item[0]],  # type:ignore[arg-type]
-            cast(complex, item[1]).real,  # type:ignore[arg-type]
-        )
-        pauli_terms.append(term)
-
-    return pauli_terms
-
-
 def _str_to_list_int(str_ints: str) -> List[int]:
     return list(map(int, list(str_ints)))
 

classiq/applications/combinatorial_helpers/pauli_helpers/pauli_utils.py

@@ -1,65 +1,53 @@
-from typing import List, cast
+from typing import List
 
-from classiq.interface.chemistry.operator import PauliOperator
 from classiq.interface.generator.expressions.enums.pauli import Pauli
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 from classiq.interface.helpers.custom_pydantic_types import PydanticPauliList
 
-from classiq.exceptions import (
-    ClassiqExecutorInvalidHamiltonianError,
-    ClassiqNonNumericCoefficientInPauliError,
-    ClassiqValueError,
-)
+from classiq.exceptions import ClassiqNonNumericCoefficientInPauliError
+from classiq.qmod.builtins import PauliTerm
 
 
-def _pauli_str_to_enums(pauli_str: str) -> str:
-    return ", ".join(f"Pauli.{pauli_term}" for pauli_term in pauli_str)
-
-
-def pauli_integers_to_str(paulis: List[Pauli]) -> str:
-    return "".join([Pauli(pauli).name for pauli in paulis])
-
-
-def pauli_operator_to_hamiltonian(pauli_list: PydanticPauliList) -> List[QmodPyStruct]:
-    pauli_struct_list: List[QmodPyStruct] = []
+def pauli_operator_to_hamiltonian(pauli_list: PydanticPauliList) -> List[PauliTerm]:
+    pauli_terms: List[PauliTerm] = []
     for pauli_term in pauli_list:
         if not isinstance(pauli_term[1], complex) or pauli_term[1].imag != 0:
             raise ClassiqNonNumericCoefficientInPauliError(
                 "Coefficient is not a number."
             )
-
-        pauli_struct_list.append(
-            {
-                "pauli": [Pauli[p] for p in pauli_term[0]],
-                "coefficient": pauli_term[1].real,
-            }
+        term = PauliTerm(
+            [Pauli[p] for p in pauli_term[0]],  # type: ignore[arg-type]
+            pauli_term[1].real,  # type: ignore[arg-type]
         )
-    return pauli_struct_list
+        pauli_terms.append(term)
 
+    return pauli_terms
 
-def get_pauli_operator(pauli_operator: List[QmodPyStruct]) -> PauliOperator:
-    pauli_list = [
-        (
-            pauli_integers_to_str(elem["pauli"]),
-            elem["coefficient"],
+
+def pauli_enum_to_str(pauli: Pauli) -> str:
+    return {
+        Pauli.I: "Pauli.I",
+        Pauli.X: "Pauli.X",
+        Pauli.Y: "Pauli.Y",
+        Pauli.Z: "Pauli.Z",
+    }.get(pauli, "")
+
+
+def _pauli_terms_to_qmod(hamiltonian: List[PauliTerm]) -> str:
+    qmod_strings = []
+    for term in hamiltonian:
+        pauli_str = ", ".join([pauli_enum_to_str(p) for p in term.pauli])  # type: ignore[attr-defined]
+        qmod_strings.append(
+            f"struct_literal(PauliTerm, pauli=[{pauli_str}], coefficient={term.coefficient})"
         )
-        for elem in pauli_operator
-    ]
 
-    try:
-        pauli = PauliOperator(pauli_list=pauli_list)
-    except ValueError:
-        raise ClassiqExecutorInvalidHamiltonianError() from None
+    return ", ".join(qmod_strings)
 
-    return pauli
 
+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"]}')
 
-def _pauli_operator_to_qmod(hamiltonian: PauliOperator) -> str:
-    if not all(isinstance(summand[1], complex) for summand in hamiltonian.pauli_list):
-        raise ClassiqValueError(
-            "Supporting only Hamiltonian with numeric coefficients."
-        )
-    return ", ".join(
-        f"struct_literal(PauliTerm, pauli=[{_pauli_str_to_enums(pauli)}], coefficient={cast(complex, coeff).real})"
-        for pauli, coeff in hamiltonian.pauli_list
-    )
+    return f"{{{', '.join(res)}}}"

classiq/applications/combinatorial_optimization/__init__.py

@@ -5,6 +5,7 @@ from classiq.interface.combinatorial_optimization.encoding_types import Encoding
 from classiq.interface.combinatorial_optimization.solver_types import QSolver
 
 from classiq.applications.combinatorial_helpers.combinatorial_problem_utils import (
+    compute_qaoa_initial_point,
     get_optimization_solution_from_pyo,
     pyo_model_to_hamiltonian,
 )
@@ -23,6 +24,7 @@ __all__ = [
     "examples",
     "get_optimization_solution_from_pyo",
     "pyo_model_to_hamiltonian",
+    "compute_qaoa_initial_point",
 ]