Added support for commutaor VectorPauliSum and tests.

Author: teng10

src/PauliAlgebra/paulioperations.jl

@@ -373,6 +373,37 @@ Calculate the commutator of a `PauliSum` and a `PauliString`.
 commutator(psum::PauliSum, pstr::PauliString) = commutator(psum, PauliSum(pstr))
 commutator(pstr::PauliString, psum::PauliSum) = commutator(PauliSum(pstr), psum)
 
+
+"""
+    commutator(vpsum1::VectorPauliSum, vpsum2::VectorPauliSum)
+
+Calculate the commutator of two `VectorPauliSum`s.
+Returns a `VectorPauliSum` with complex coefficients.
+
+# Example
+```julia
+vpsum = VectorPauliSum(3, [1, 2], [1.]) # 1.0 * X + 1.0 * Y
+vpsum2 = VectorPauliSum(3, [7], [0.25]) # 0.25 * ZX
+commutator(vpsum, vpsum2) # should return a VectorPauliSum with - 0.5 YX + 0.5 XX
+```
+"""
+function PauliPropagation.commutator(vpsum1::VectorPauliSum, vpsum2::VectorPauliSum)
+    nq = _checknumberofqubits(vpsum1, vpsum2)
+
+    TT = paulitype(vpsum1)
+    CT = promote_type(ComplexF64, coefftype(vpsum1), coefftype(vpsum2))
+    new_pauli_dict = Dict{TT,CT}()
+
+    for (pauli1, coeff1) in zip(vpsum1.terms, vpsum1.coeffs), (pauli2, coeff2) in zip(vpsum2.terms, vpsum2.coeffs)
+        if !commutes(pauli1, pauli2)
+            new_pstr, sign = commutator(pauli1, pauli2)
+            new_pauli_dict[new_pstr] = get(new_pauli_dict, new_pstr, zero(CT)) + convert(CT, sign * coeff1 * coeff2)
+        end
+    end
+
+    return VectorPauliSum(nq, collect(keys(new_pauli_dict)), collect(values(new_pauli_dict)))
+end
+
 """
     commutator(pstr1::Integer, pstr2::Integer)
 

test/test_datatypes.jl

@@ -103,10 +103,9 @@ end
         @test vpsum == psum # checks Pauli by Pauli
         @test vpsum_from_str == psum 
         @test vpsum_from_str == vpsum
-    end
 
     # Subtest for subtracting PauliSum
-    @testset "VectorPauliSum to PauliSums with Merging" begin    
+        # VectorPauliSum to PauliSums with Merging
 
         pstr2 = createpaulistring(nq)
         vpsum = VectorPauliSum([pstr, pstr2, pstr])

test/test_paulioperations.jl

@@ -135,6 +135,26 @@ using Test
         pstr2 = PauliString(nq, [:Y, :I], [1, 2], 1.0)
         @test commutator(pstr1, pstr2) == PauliString(nq, [:Z, :Y], [1, 2], 2im)
     end
+
+    @testset "VectorPauliSum commutator" begin
+        nq = 3
+        # VectorPauliSum commutator verify with PauliSum commutator
+        psum1 = PauliSum(nq)
+        add!(psum1, [:X, :Y], [1, 2], 1.5)
+        psum2 = PauliSum(nq)
+        add!(psum2, [:Y, :I], [1, 2], -2.0)
+
+        expected = commutator(psum1, psum2)
+        com_vec = commutator(VectorPauliSum(psum1), VectorPauliSum(psum2))
+        @test PauliSum(com_vec) == expected           
+        
+        vpsum = VectorPauliSum(3, [1, 2], [1., 1.])
+        vpsum2 = VectorPauliSum(3, [7], [0.25])
+        expected = commutator(PauliSum(vpsum), PauliSum(vpsum2))
+        com_vec = commutator(vpsum, vpsum2)
+        @test PauliSum(com_vec) == expected
+
+    end    
 end