add docs, tests and fixes for apply_right!

Author: sagnikpal2004

src/apply_right.jl

@@ -1,14 +1,57 @@
-"""the `apply_right!` function is used to right multiply any quantum operation to unitary 
-Clifford operation or Pauli product"""
+"""
+the `apply_right!` function is used to right multiply any quantum operation to unitary 
+Clifford operation or Pauli product
+
+```jldoctest
+julia> apply_right!(C"X Z", sHadamard(1))
+X₁ ⟼ + Z
+Z₁ ⟼ + X
+
+julia> cliff = one(CliffordOperator, 2)
+X₁ ⟼ + X_
+X₂ ⟼ + _X
+Z₁ ⟼ + Z_
+Z₂ ⟼ + _Z
+julia> apply_right!(cliff, sHadamard(1))
+X₁ ⟼ + Z_
+X₂ ⟼ + _X
+Z₁ ⟼ + X_
+Z₂ ⟼ + _Z
+julia> apply_right!(cliff, sCNOT(1, 2))
+X₁ ⟼ + ZX
+X₂ ⟼ + _X
+Z₁ ⟼ + X_
+Z₂ ⟼ + XZ
+
+julia> apply_right!(C"Y Z", C"Z Y"; phases=true)
+X₁ ⟼ + Z
+Z₁ ⟼ - X
+julia> apply_right!(C"Y Z", P"X")
+X₁ ⟼ + Y
+Z₁ ⟼ - Z
+```
+
+See also: [`apply!`](@ref), [`apply_inv!`](@ref)
+"""
 function apply_right! end
 
 
-# dense_cliffords
+##############################
+# Dense operators
+##############################
 
-function apply_right!(l::CliffordOperator, r::PauliOperator; phases=false)
+function apply_right!(l::CliffordOperator, r::PauliOperator)
     nqubits(l)==nqubits(r) || throw(DimensionMismatch("The Clifford and Pauli operators need to act on the same number of qubits."))
-    tab(l).phases[nqubits(l)+1:end] .⊻= r[1:nqubits(l)]
-    tab(l).phases[1:nqubits(l)] .⊻= r[nqubits(l)+1:end]
+    for i in 1:nqubits(l)
+        x, z = r[i]
+        if x
+            phases(l)[nqubits(l)+i] ⊻= 0x02
+        end
+        if z
+            phases(l)[i] ⊻= 0x02
+        end
+    end
+    return l
 end
 
 function apply_right!(l::CliffordOperator, r::CliffordOperator; phases=true)
@@ -47,15 +90,6 @@ end
 end
 
 
-# symbolic_cliffords
-
-function mul_right_ignore_anticommute!(l::PauliOperator, r::PauliOperator)
-    x = mul_right!(l, r; phases=Val(true))
-    x.phase[] = x.phase[] & 0x02
-    return x
-end
-
-
 ##############################
 # Single-qubit gates
 ##############################
@@ -89,18 +123,18 @@ function apply_right!(l::CliffordOperator, r::sInvPhase)
 end
 
 function apply_right!(l::CliffordOperator, r::sX)
-    phases(tab(l))[nqubits(l)+r.q] ⊻= 0x02
+    phases(l)[nqubits(l)+r.q] ⊻= 0x02
     return l
 end
 
 function apply_right!(l::CliffordOperator, r::sY)
-    phases(tab(l))[r.q] ⊻= 0x02
-    phases(tab(l))[nqubits(l)+r.q] ⊻= 0x02
+    phases(l)[r.q] ⊻= 0x02
+    phases(l)[nqubits(l)+r.q] ⊻= 0x02
     return l
 end
 
 function apply_right!(l::CliffordOperator, r::sZ)
-    phases(tab(l))[r.q] ⊻= 0x02
+    phases(l)[r.q] ⊻= 0x02
     return l
 end
 
@@ -116,14 +150,14 @@ function apply_right!(l::CliffordOperator, r::sInvSQRTX)
 end
 
 function apply_right!(l::CliffordOperator, r::sSQRTY)
-    phases(tab(l))[nqubits(l)+r.q] ⊻= 0x02
+    phases(l)[nqubits(l)+r.q] ⊻= 0x02
     rowswap!(tab(l), r.q, nqubits(l)+r.q)
     return l
 end
 
 function apply_right!(l::CliffordOperator, r::sInvSQRTY)
     rowswap!(tab(l), r.q, nqubits(l)+r.q)
-    phases(tab(l))[nqubits(l)+r.q] ⊻= 0x02
+    phases(l)[nqubits(l)+r.q] ⊻= 0x02
     return l
 end
 
@@ -270,7 +304,7 @@ function apply_right!(l::CliffordOperator, r::sInvZCrY)
     l[r.q2] = mul_left!(l[r.q2], l[nqubits(l)+r.q1])
     l[nqubits(l)+r.q2] = mul_left!(l[nqubits(l)+r.q2], l[nqubits(l)+r.q1])
     l[r.q1] = mul_left!(l[r.q1], l[nqubits(l)+r.q2])
-    phases(tab(l))[r.q1] ⊻= 0x02
+    phases(l)[r.q1] ⊻= 0x02
     return l
 end
 
@@ -322,4 +356,13 @@ function apply_right!(l::CliffordOperator, r::sInvSQRTYY)
     rowswap!(tab(l), r.q2, nqubits(l)+r.q2)
     apply_right!(l, sZ(r.q2))
     return l
+end
+
+
+"""Multiply Pauli operators `l * r`, ignoring anticommutation phases (keeping only ±1, not ±i).
+See also: [`mul_right!`](@ref)."""
+function mul_right_ignore_anticommute!(l::PauliOperator, r::PauliOperator)
+    mul_right!(l, r; phases=Val(true))
+    l.phase[] = l.phase[] & 0x02
+    return l
 end

src/dense_cliffords.jl

@@ -91,6 +91,7 @@ function Base.copy(c::CliffordOperator)
 end
 
 @inline nqubits(c::CliffordOperator) = nqubits(tab(c))
+@inline phases(c::CliffordOperator) = phases(tab(c))
 
 Base.zero(c::CliffordOperator) = CliffordOperator(zero(tab(c)))
 Base.zero(::Type{<:CliffordOperator}, n) = CliffordOperator(zero(Tableau, 2n, n))

test/test_apply_right.jl

@@ -1,34 +1,78 @@
 @testitem "Apply Right" begin
     using InteractiveUtils
-    using QuantumClifford: AbstractCliffordOperator
+    using QuantumClifford: AbstractCliffordOperator, CliffordOperator
+    
+    test_sizes = [1,2,63,64,65,127,128,129,511,512,513]
+
+    function CliffordOperator(pauli::PauliOperator)
+        n = nqubits(pauli)
+        res = one(CliffordOperator, n)
+
+        for i in 1:2n
+            if comm(pauli, tab(res), i) == 0x1
+                phases(res)[i] ⊻= 0x02
+            end
+        end
+        return res
+    end
+    
+    @testset "CliffordOperator constructor from PauliOperator" begin
+        for n in test_sizes
+            l = random_clifford(n)
+            pauli = random_pauli(n)
+            @test isequal(apply!(copy(l), pauli; phases=true), apply!(l, CliffordOperator(pauli); phases=true))
+        end
+    end
 
     # SLOW version of apply_right! for testing
+    function apply_right_slow!(l::CliffordOperator, r::CliffordOperator; phases=true)
+        apply!(r, l; phases)
+    end
+    function apply_right_slow!(l::CliffordOperator, r::PauliOperator; phases=true)
+        apply!(CliffordOperator(r), l; phases)
+    end
     function apply_right_slow!(l::CliffordOperator, r::AbstractCliffordOperator; phases=true)
-        apply!(CliffordOperator(r, nqubits(l)), l; phases=phases)
+        apply!(CliffordOperator(r, nqubits(l)), l; phases)
+    end
+
+    @testset "Apply Right dense operators" begin
+        for q in test_sizes
+            l = random_clifford(q)
+            cliff = random_clifford(q)
+            pauli = random_pauli(q)
+
+            @test isequal(apply_right!(copy(l), cliff), apply_right_slow!(l, cliff))
+            @inferred apply_right!(copy(l), cliff)
+
+            @test isequal(apply_right!(copy(l), pauli), apply_right_slow!(l, pauli))
+            @inferred apply_right!(copy(l), pauli)
+        end
     end
-    
-    q = 64
-    shots = 16
 
     @testset "Apply Right single-qubit" begin
-        for _ in 1:shots
+        for q in test_sizes
             l = random_clifford(q)
             q1 = rand(1:q)
 
             for gate in subtypes(AbstractSingleQubitOperator)
                 gate == SingleQubitOperator && continue
+
                 @test isequal(apply_right!(copy(l), gate(q1)), apply_right_slow!(l, gate(q1)))
+                @inferred apply_right!(copy(l), gate(q1))
             end
         end
     end
 
     @testset "Apply Right two-qubit" begin
-        for _ in 1:shots
+        for q in test_sizes
+            q < 2 && continue
+
             l = random_clifford(q)
             q1 = rand(1:q); q2 = rand(setdiff(1:q, [q1]))
 
             for gate in subtypes(AbstractTwoQubitOperator)
                 @test isequal(apply_right!(copy(l), gate(q1, q2)), apply_right_slow!(l, gate(q1, q2)))
+                @inferred apply_right!(copy(l), gate(q1, q2))
             end
         end
     end

test/test_throws.jl

@@ -71,4 +71,6 @@
     @test_throws DimensionMismatch Stabilizer(fill(0x0, 2), Matrix{Bool}([1 0 1;1 1 1; 1 0 1]), Matrix{Bool}([1 0 0;1 1 1;1 0 1]))
     @test_throws DimensionMismatch Stabilizer(fill(0x0, 2), Matrix{Bool}([1 0 1 1 0 0; 1 1 1 1 1 1; 1 0 1 1 0 1]))
 
+    @test_throws DimensionMismatch apply_right!(random_clifford(1), random_pauli(2))
+    @test_throws DimensionMismatch apply_right!(random_clifford(2), random_clifford(1))
 end