classiq 0.39.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,7 +34,9 @@ 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,
 )
 from classiq.applications.finance import construct_finance_model
 from classiq.applications.grover import construct_grover_model
@@ -94,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:
@@ -446,7 +435,7 @@ def _get_chemistry_quantum_main(
             function="allocate",
             positional_args=[
                 Expression(
-                    expr=f"len(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'))"
+                    expr=f"get_field(get_field({_get_problem_to_hamiltonian_name(chemistry_problem)}({_convert_library_problem_to_qmod_problem(chemistry_problem)})[0], 'pauli'), 'len')"
                 ),
                 HandleBinding(name="qbv"),
             ],
@@ -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
@@ -16,23 +16,21 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_sparsing imp
     SparsePauliOp,
 )
 from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import (
-    PauliTerm,
-    get_pauli_operator,
     pauli_operator_to_hamiltonian,
-    pauli_string_to_int,
 )
 from classiq.applications.combinatorial_helpers.pyomo_utils import (
     convert_pyomo_to_global_presentation,
 )
+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,32 +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()
-        term.pauli, term.coefficient = (
-            pauli_string_to_int(item[0]),
-            cast(complex, item[1]).real,
-        )
-        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/optimization_model.py

@@ -45,22 +45,23 @@ class OptimizationModel:
         encoding_type: Optional[EncodingType] = None,
     ) -> None:
         assert model.nobjectives() == 1, "model must have a single objective"
-        self._model_original = copy.deepcopy(model)
-        self._assigned_model = remove_fixed_variables(model)
+        model_copy = copy.deepcopy(model)
+        self._model_original = model
+        self._assigned_model = remove_fixed_variables(model_copy)
         self.qsolver = qsolver
         self._encoding_type = encoding_type
 
-        self.is_encoded = encoding_utils.is_model_encodable(model)
+        self.is_encoded = encoding_utils.is_model_encodable(model_copy)
         if self.is_encoded:
             if self._encoding_type is None:
                 self._encoding_type = EncodingType.BINARY
             self._model_encoder = encoding.ModelEncoder(
-                model, qsolver, self._encoding_type
+                model_copy, qsolver, self._encoding_type
             )
             self._model = self._model_encoder.encoded_model
             self._vars_encoding_mapping = self._model_encoder.vars_encoding_mapping
         else:
-            self._model = model
+            self._model = model_copy
             # TODO How to handle encoding_type == None
             self._vars_encoding_mapping = EncodingMapping(self._encoding_type)  # type: ignore[arg-type]
 
@@ -70,7 +71,7 @@ class OptimizationModel:
             self.vars_not_encoded, self._vars_encoding_mapping
         )
 
-        self.is_maximization = sense.is_maximization(model)
+        self.is_maximization = sense.is_maximization(model_copy)
         self.objective = next(self._model.component_objects(pyo.Objective))
 
         self.penalty_energy = penalty_energy

classiq/applications/combinatorial_helpers/pauli_helpers/pauli_utils.py

@@ -1,75 +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
 
 
-class PauliTerm:
-    pauli: List[int]
-    coefficient: float
-
-
-def pauli_string_to_int(pauli_str: str) -> List[int]:
-    pauli_map = {"I": 0, "X": 1, "Y": 2, "Z": 3}
-    return [pauli_map[char] for char in pauli_str]
-
-
-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)}}}"