Changed Order of Inputs for Pauli strings and adjusted Readme to match the new changes

Author: lnmueller

README.md

@@ -17,18 +17,17 @@ The following items are planned or not yet fully implemented:
 ```python
 import pauliengine as pe
 # Example : Z on qubit 0 with coefficient 1.0
-p1 = pe.PauliString ((1.0, {0: "Z"}))
+p1 = pe.PauliString (1.0, {0: "Z"})
 
 # Example : X on qubit 1 with coefficient "a" ( symbolic )
-p2 = pe.PauliString (("a", {1: "X"}))
+p2 = pe.PauliString ("a", {1: "X"})
 
 # Example : OpenFermion style
 p3 = pe.PauliString ((1.0, [("X", 0), ("Y", 2) ]))
 ```
 ### Standard Operations
 ```python
-# Addition:
-p4 = p2 + p3
+
 # Multiplication
 p5 = p4 * p1
 # fast commutators
@@ -38,10 +37,10 @@ c = p1.commutator(p2)
 ### Parametrized Operators
 ```python
 # create PauliString objects
-p1 = pe.PauliString ((1.0 , {0: "Z"})) # not parametrized
-p2 = pe.PauliString (("a", {1: "X"}))  # parametrized
+p1 = pe.PauliString (1.0 , {0: "Z"}) # not parametrized
+p2 = pe.PauliString ("a", {1: "X"})  # parametrized
 # assemble operator
-H = QubitHamiltonian([p1 , p2 ])
+H = pe.QubitHamiltonian([p1 , p2 ])
 ```
 In beta version, mixed types need to be created like this (create atomic PauliStrings, then assemble operator)
 

src/PauliString.h

@@ -50,7 +50,7 @@ class PauliString {
                 }
 
 
-                PauliString(const std::unordered_map<int, std::string>& data, std::complex<double> coeff) {
+                PauliString(std::complex<double> coeff, const std::unordered_map<int, std::string>& data) {
                         this->coeff = coeff;
                         uint64_t mask;
                         for (const auto& [key, value] : data) {
@@ -72,7 +72,7 @@ class PauliString {
                         }
                 }
 
-                PauliString(const std::unordered_map<int, std::string>& data, std::string coeff) {
+                PauliString(std::string coeff, std::unordered_map<int, std::string>& data) {
                         this->coeff = coeff;
                         uint64_t mask;
                         for (const auto& [key, value] : data) {
@@ -97,7 +97,7 @@ class PauliString {
                 }
 
 #ifdef HAVE_SYMENGINE
-                PauliString(const std::unordered_map<int, std::string>& data, Expression coeff) {
+                PauliString(Expression coeff, const std::unordered_map<int, std::string>& data) {
                         this->coeff = coeff;
                         uint64_t mask;
                         for (const auto& [key, value] : data) {
@@ -127,9 +127,9 @@ class PauliString {
                         this->coeff = coeff;
                 }
 
-                PauliString(const std::pair<std::vector<std::pair<char, int>>, Coeff>& input) {
-                        this->coeff = input.second;
-                        std::vector<std::pair<char, int>> paulis = input.first;
+                PauliString(const std::pair<std::complex<double>, std::vector<std::pair<char, int>>>& input) {
+                        this->coeff = input.first;
+                        std::vector<std::pair<char, int>> paulis = input.second;
                         uint64_t mask = 0;
                         for (int i = 0; i < paulis.size(); i++) {
                                 size_t index = paulis[i].second / BITS_IN_INTEGER;
@@ -148,9 +148,9 @@ class PauliString {
                         }
                 }
 
-                PauliString(const std::pair<std::vector<std::pair<char, int>>, std::string>& input) {
-                        this->coeff = input.second;
-                        std::vector<std::pair<char, int>> paulis = input.first;
+                PauliString(const std::pair<std::string, std::vector<std::pair<char, int>>>& input) {
+                        this->coeff = input.first;
+                        std::vector<std::pair<char, int>> paulis = input.second;
                         uint64_t mask = 0;
                         for (int i = 0; i < paulis.size(); i++) {
                                 size_t index = paulis[i].second / BITS_IN_INTEGER;
@@ -284,7 +284,7 @@ class PauliString {
                                         mapped[old_idx] = pauli_char;
                                 }
                         }
-                        return PauliString(mapped, this->coeff);
+                        return PauliString(this->coeff, mapped);
                 }   
 
                 std::string to_string() const {

src/QubitHamiltonian.cpp

@@ -15,7 +15,7 @@ class QubitHamiltonian {
                         std::vector<PauliString<>> converted_data;
                         converted_data.reserve(data.size());
                         for (Pauli_structure entry : data) {
-                                converted_data.push_back(PauliString<>(entry.second, entry.first));
+                                converted_data.push_back(PauliString<>(entry.first, entry.second));
                         }
                         this->data = converted_data;
                 }
@@ -24,7 +24,7 @@ class QubitHamiltonian {
                         std::vector<PauliString<>> converted_data;
                         converted_data.reserve(data.size());
                         for (Pauli_structure_variable entry : data) {
-                                converted_data.push_back(PauliString<>(entry.second, entry.first));
+                                converted_data.push_back(PauliString<>(entry.first, entry.second));
                         }
                         this->data = converted_data;
                 }
@@ -237,10 +237,14 @@ class QubitHamiltonian {
 NB_MODULE(PauliEngine, m) {
         nb::class_<PauliString<>>(m, "PauliString", "Represents a Pauli string in binary symplectic form.")
                 .def(nb::init<>(), "Default constructor.")
-                .def(nb::init<const std::unordered_map<int, std::string>&, std::complex<double>>(),
-                "Constructor from a map of qubit indices to Pauli operators and a complex coefficient.")
-                .def(nb::init<const std::unordered_map<int, std::string>&, std::string>(),
+                .def(nb::init<const std::string, const std::unordered_map<int, std::string>>(),
                 "Constructor from a map of qubit indices to Pauli operators and a complex coefficient.")
+                .def(nb::init<std::complex<double>, const std::unordered_map<int, std::string>>(),
+                "Constructor from a map of qubit indices to Pauli operators and a symbolic coefficient.")
+                .def(nb::init<const std::pair<std::complex<double>, std::vector<std::pair<char, int>>>>(),
+                "Constructor OpenFermion style and a complex coefficient.")
+                .def(nb::init<const std::pair<std::string, std::vector<std::pair<char, int>>>>(),
+                "Constructor OpenFermion style and a symbolic coefficient.")
                 .def("to_string", &PauliString<>::to_string, "Returns a human-readable string representation of the Pauli string.")
                 .def("is_all_z", &PauliString<>::is_all_z, "Checks if the Pauli string consists only of Z operators.")
                 .def("get_coeff", &PauliString<>::get_coeff, "Returns the complex coefficient of the Pauli string.")