WIP pauli

Author: akirakyle

src/pauli.jl

@@ -1,16 +1,42 @@
+using TransmuteDims
 
-const PauliTransferType = Operator{<:ChoiBasis,<:ChoiBasis}
+const PauliTransferType = Operator{<:PauliBasis,<:PauliBasis}
 
-
-# TODO this should maybe be exported?
-# TODO also maybe more efficient to super-tensor product vec'd single qubit transformation
-function _ketbra_to_pauli()
+# TODO should either of these functions be cached?
+function _pauli_to_ketbra1()
     b = SpinBasis(1//2)
-    pvec(fn) = vec(fn(b)).data
-    kb2p = sparse(hcat(map(pvec, [identityoperator, sigmax, sigmay, sigmaz])...)')
+    vec_it(fn) = vec(fn(b).data)
+    p2kb = hcat(map(vec_it, [identityoperator, sigmax, sigmay, sigmaz])...)
+end
+
+function _ketbra_to_pauli(N)
+    T = kron((_pauli_to_ketbra1 for _=1:N)...)
+    T = reshape(T, Tuple(4 for _=1:2N))
+    T = PermutedDimsArray(T, ((2i-1 for i=1:N)..., (2i for i=1:N)...))
+    reshape(T, (4^N, 4^N))
+end
+
+function _op_to_pauli(Nl, Nr, data)
+    Ul = ket_bra_to_pauli(Nl)
+    Ur = Nl == Nr ? Ul : _ketbra_to_pauli(Nr)
+    data = dagger(Ul) * data * Ur # TODO figure out normalization
+    @assert isapprox(imag.(data), zero(data), atol=tol)
+    Operator(PauliBasis()^Nl, PauliBasis()^Nr, real.(data))
 end
 
-_Ukb2p = _ketbra_to_pauli()
+"""
+    comp_to_pauli(N)
+
+Creates a superoperator which changes from the computational `SpinBasis(1//2)`
+to the `PauliBasis()` over `N` qubits.
+"""
+function comp_to_pauli(N)
+    T = kron((_pauli_to_ketbra1 for _=1:N)...)
+    T = reshape(T, Tuple(4 for _=1:2N))
+    T = PermutedDimsArray(T, ((2i-1 for i=1:N)..., (2i for i=1:N)...))
+    sb = SpinBasis(1//2)^N
+    Operator(PauliBasis()^N, KetBraBasis(sb, sb), reshape(T, (4^N, 4^N))
+end
 
 function pauli(op::SuperOperatorType; tol=1e-9)
     bl, br = basis_l(op), basis_r(op)
@@ -24,7 +50,7 @@ function pauli(op::SuperOperatorType; tol=1e-9)
 
     Nl, Nr = length(basis_l(bl)), length(basis_l(br))
     Ul = ket_bra_to_pauli(Nl)
-    Ur = Nl == Nr ? Ul : ket_bra_to_pauli(Nr)
+    Ur = Nl == Nr ? Ul : _ketbra_to_pauli(Nr)
     data = dagger(Ul)*op.data*Ur # TODO figure out normalization
     @assert isapprox(imag.(data), zero(data), atol=tol)
     Operator(PauliBasis()^Nl, PauliBasis()^Nr, real.(data))
@@ -36,7 +62,7 @@ function chi(op::ChoiStateType; tol=1e-9)
     bl, br = basis_l(basis_l(op)), basis_r(basis_l(op))
     for b in (bl, br)
         for i=1:length(b)
-            (b[i] isa NLevelBasis) || throw(ArgumentError("Choi state must be over systems composed of SpinBasis(1//2) to be converted to chi representation"))
+            (b[i] isa SpinBasis && dimension(b[i]) == 2) || throw(ArgumentError("Choi state must be over systems composed of SpinBasis(1//2) to be converted to chi representation"))
         end
     end
 
@@ -49,7 +75,7 @@ function chi(op::ChoiStateType; tol=1e-9)
 end
 
 """
-function pauli(op::SuperOperatorType; tol=1e-9)
+function hwpauli(op::SuperOperatorType; tol=1e-9)
     bl, br = basis_l(op), basis_r(op)
     ((basis_l(bl) == basis_r(bl)) && (basis_l(br) == basis_r(br))) || throw(ArgumentError("Superoperator must map between square operators in order to be converted to pauli represenation"))
 

src/superoperators.jl

@@ -20,9 +20,13 @@ const ChoiStateType = Operator{<:ChoiBasis,<:ChoiBasis}
 vec(op::Operator) = Ket(KetBraBasis(basis_l(op), basis_r(op)), vec(op.data))
 function unvec(k::SuperKetType)
     bl, br = basis_l(basis(k)), basis_r(basis(k))
-    @cast A[n,m] |= k.data[(n,m)] (n ∈ 1:dimension(bl), m ∈ 1:dimension(br))
-    return Operator(bl, br, A)
+    Operator(bl, br, reshape(k.data, dimension(bl), dimension(br)))
 end
+#function unvec(k::SuperKetType)
+#    bl, br = basis_l(basis(k)), basis_r(basis(k))
+#    @cast A[n,m] |= k.data[(n,m)] (n ∈ 1:dimension(bl), m ∈ 1:dimension(br))
+#    return Operator(bl, br, A)
+#end
 
 function spre(op::Operator)
     multiplicable(op, op) || throw(ArgumentError("It's not clear what spre of a non-square operator should be. See issue #113"))
@@ -33,8 +37,12 @@ function spost(op::Operator)
     multiplicable(op, op) || throw(ArgumentError("It's not clear what spost of a non-square operator should be. See issue #113"))
     sprepost(identityoperator(op), op)
 end
+#function sprepost(A::Operator, B::Operator)
+#    @cast C[(ν,μ), (n,m)] |= A.data[ν,n] * B.data[m,μ]
+#    Operator(KetBraBasis(basis_l(A), basis_r(B)), KetBraBasis(basis_r(A), basis_l(B)), C)
+#end
 
-#sprepost(A::Operator, B::Operator) = Operator(KetBraBasis(A.basis_l, B.basis_r), KetBraBasis(A.basis_r, B.basis_l), kron(permutedims(B.data), A.data))
+#sprepost(A::Operator, B::Operator) = Operator(KetBraBasis(basis_l(A), basis_r(B)), KetBraBasis(basis_r(A), basis_l(B)), kron(permutedims(B.data), A.data))
 
 function sprepost(A::Operator, B::Operator)
     @cast C[(ν,μ), (n,m)] |= A.data[ν,n] * B.data[m,μ]
@@ -63,7 +71,6 @@ super(op::ChoiStateType) =  _super_choi(KetBraBasis, op)
 
 dagger(a::ChoiStateType) = choi(dagger(super(a)))
 
-*(a::SuperOperatorType, b::SuperOperatorType) = (check_multiplicable(a,b); Operator(a.basis_l, b.basis_r, a.data*b.data))
 *(a::SuperOperatorType, b::Operator) = unvec(a*vec(b))
 *(a::ChoiStateType, b::SuperOperatorType) = super(a)*b
 *(a::SuperOperatorType, b::ChoiStateType) = a*super(b)