Some cleanup

Author: akirakyle

src/pauli.jl

@@ -50,10 +50,10 @@ function _pauli_comp_convert(op, rev)
 end
 
 function _choi_chi_convert(op, rev)
-    Nl, Nr = length(basis_l(basis_l(op))), length(basis_r(basis_l(op)))
+    Nl, Nr = length(basis_l(basis(op))), length(basis_r(basis(op)))
     V = choi_chi(Nl,Nr)
-    norm = 2^((Nl+Nr)÷2)
-    out = rev ? norm * V * op * dagger(V) : (1/norm) * dagger(V) * op * V
+    norm = 2^((Nl+Nr)÷2) # provides "standard" normalization
+    rev ? norm * V * op * dagger(V) : (1/norm) * dagger(V) * op * V
 end
 
 pauli(op::SuperOperatorType) = _pauli_comp_convert(op, false)
@@ -68,9 +68,6 @@ chi(op::SuperOperatorType) = chi(choi(op))
 pauli(op::ChiType) = pauli(super(choi(op)))
 chi(op::PauliTransferType) = chi(choi(super(op)))
 
-#pauli(op::ChiType) = _super_choi(PauliBasis, op)
-#chi(op::PauliTransferType) = _super_choi(ChiBasis, op)
-
 pauli(op::PauliTransferType) = op
 chi(op::ChiType) = op
 

src/superoperators.jl

@@ -1,33 +1,18 @@
 import QuantumInterface: KetBraBasis, ChoiBasis
-#using TensorCast
 
 const SuperOperatorType{BL,BR,T} = Operator{BL,BR,T} where {BL<:KetBraBasis,BR<:KetBraBasis}
 const ChoiStateType{BL,BR,T} = Operator{BL,BR,T} where {BR<:ChoiBasis,BL<:ChoiBasis}
 
 #const ChannelType = Union{SuperOperatorType, ChoiStateType, PauliTransferType, ChiType}
 
-#const SOpBasis = Union{KetBraBasis, PauliBasis}
-#const SuperOperatorType{BL,BR,T} = Operator{BL,BR,T} where {BL<:SOpBasis,BR<:SOpBasis}
-#const SOpKetBraType{BL,BR,T} = Operator{BL,BR,T} where {BL<:KetBraBasis,BR<:KetBraBasis}
-#const SOpPauliType{BL,BR,T} = Operator{BL,BR,T} where {BL<:PauliBasis,BR<:PauliBasis}
-#const ChoiStateType{BL,BR,T} = Operator{BL,BR,T} where {BR<:ChoiBasis,BL<:ChoiBasis}
-#const ChannelType = Union{SOpKetBraType, SOpPauliType, ChoiStateType, ChiType}
-
-#const DenseSuperOpPureType{BL,BR} = SuperOperatorType{BL,BR,<:Matrix}
-#const DenseSuperOpAdjType{BL,BR} = SuperOperatorType{BL,BR,<:Adjoint{<:Number,<:Matrix}}
-#const DenseSuperOpType{BL,BR} = Union{DenseOpPureType{BL,BL},DenseOpAdjType{BL,BR}}
-#const SparseSuperOpPureType{BL,BR} = SuperOperatorType{BL,BR,<:SparseMatrixCSC}
-#const SparseSuperOpAdjType{BL,BR} = SuperOperatorType{BL,BR,<:Adjoint{<:Number,<:SparseMatrixCSC}}
-#const SparseSuperOpType{BL,BR} = Union{SparseOpPureType{BL,BR},SparseOpAdjType{BL,BR}}
-
 vec(op::Operator) = Ket(KetBraBasis(basis_l(op), basis_r(op)), vec(op.data))
 function unvec(k::Ket{<:KetBraBasis})
     bl, br = basis_l(basis(k)), basis_r(basis(k))
     Operator(bl, br, reshape(k.data, dimension(bl), dimension(br)))
+    #@cast A[n,m] |= k.data[(n,m)] (n ∈ 1:dimension(bl), m ∈ 1:dimension(br))
 end
 #function unvec(k::Ket{<:KetBraBasis})
 #    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
 
@@ -42,29 +27,8 @@ function spost(op::Operator)
 end
 
 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,μ]
-#    Operator(KetBraBasis(basis_l(A), basis_r(B)), KetBraBasis(basis_r(A), basis_l(B)), C)
-#end
+#@cast C[(ν,μ), (n,m)] |= A.data[ν,n] * B.data[m,μ]
 
-#function super_tensor(A, B)
-#    a1, a2 = basis_l(A), basis_r(A)
-#    b1, b2 = basis_l(B), basis_r(B)
-#    #da1, da2, db1, db2 = map(dimension, (a1, a2, b1, b2))
-#    #@cast C[(ν,μ), (n,m)] |= A.data[m,μ] * B.data[n,ν] (m ∈ 1:da1, μ ∈ 1:da2, n ∈ 1:db1, ν ∈ 1:db2)
-#    #data = kron(B.data, A.data)
-#    #data = reshape(data, map(dimension, (a1, a2, b1, b2)))
-#    #data = PermutedDimsArray(data, (4, 2, 3, 1))
-#    #data = reshape(data, map(dimension, (a2⊗b2, a1⊗b1)))
-#    #return Operator(a1⊗b1, a2⊗b2, data)
-#    data = kron(B.data, A.data)
-#    data = reshape(data, map(dimension, (a1, a2, b1, b2)))
-#    data = PermutedDimsArray(data, (1, 3, 2, 4))
-#    data = reshape(data, map(dimension, (a1⊗b1, a2⊗b2)))
-#    return Operator(a1⊗b1, a2⊗b2, data)
-#end
-
-# https://discourse.julialang.org/t/permuteddimsarray-slower-than-permutedims/46401
 function super_tensor(A, B)
     all, alr = basis_l(basis_l(A)), basis_r(basis_l(A))
     arl, arr = basis_l(basis_r(A)), basis_r(basis_r(A))
@@ -77,42 +41,25 @@ function super_tensor(A, B)
     return Operator(basis_l(A)⊗basis_l(B), basis_r(A)⊗basis_r(B), data)
 end
 
-#function _sch(data, l1, l2, r1, r2)
-#    data = reshape(data, map(dimension, (l1, l2, r1, r2)))
-#    data = permutedims(data, (4, 2, 3, 1))
-#    reshape(data, map(dimension, (l2⊗r2, l1⊗r1)))
-#end
-#
-#function _sch(data::SparseMatrixCSC, l1, l2, r1, r2)
-#    #data = reshape(sparse(data), map(dimension, (l1, l2, r1, r2)), ())
-#    #data = _permutedims(sparse(data), size(data), (4, 2, 3, 1))
-#    data = _permutedims(sparse(data), map(dimension, (l1, l2, r1, r2)), (4, 2, 3, 1))
-#    sparse(reshape(data, map(dimension, (l2⊗r2, l1⊗r1))))
-#    # sparse(::ReshapedArray) only works when ndims == 2
-#end
-
-#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 _super_choi((l1, l2), (r1, r2), data)
-#    data = Base.ReshapedArray(data, map(length, (l2, l1, r2, r1)), ())
-#    (l1, l2), (r1, r2) = (r2, l2), (r1, l1)
-#    data = PermutedDimsArray(data, (1, 3, 2, 4))
-#    data = Base.ReshapedArray(data, map(length, (l1⊗l2, r1⊗r2)), ())
-#    return (l1, l2), (r1, r2), copy(data)
-#end
-
+# copy at end is necessary to not fall back on generic gemm routines later
+# https://discourse.julialang.org/t/permuteddimsarray-slower-than-permutedims/46401
+# which suggetst usig something like Tullio might speed things up further
 # Sec IV.A. of https://arxiv.org/abs/1111.6950
 function _super_choi(basis_fn, op)
     l1, l2 = basis_l(basis_l(op)), basis_r(basis_l(op))
     r1, r2 = basis_l(basis_r(op)), basis_r(basis_r(op))
-    #data = _sch(op.data, l1, l2, r1, r2)
     #dl1, dl2, dr1, dr2 = map(dimension, (l1, l2, r1, r2))
     #@cast A[(ν,μ), (n,m)] |= op.data[(m,μ), (n,ν)] (m ∈ 1:dl1, μ ∈ 1:dl2, n ∈ 1:dr1, ν ∈ 1:dr2)
 
     #data = reshape(op.data, map(dimension, (l1, l2, r1, r2)))
     #data = PermutedDimsArray(data, (4, 2, 3, 1))
     #data = reshape(data, map(dimension, (r2⊗l2, r1⊗l1)))
     #return Operator(basis_fn(r2, l2), basis_fn(r1, l1), data)
+    #data = Base.ReshapedArray(data, map(length, (l2, l1, r2, r1)), ())
+    #(l1, l2), (r1, r2) = (r2, l2), (r1, l1)
+    #data = PermutedDimsArray(data, (1, 3, 2, 4))
+    #data = Base.ReshapedArray(data, map(length, (l1⊗l2, r1⊗r2)), ())
+    #return (l1, l2), (r1, r2), copy(data)
 
     data = reshape(op.data, map(dimension, (l1, l2, r1, r2)))
     data = PermutedDimsArray(data, (1, 3, 2, 4))
@@ -138,7 +85,6 @@ dagger(a::ChoiStateType) = choi(dagger(super(a)))
 *(a::ChoiStateType, b::SuperOperatorType) = super(a)*b
 *(a::SuperOperatorType, b::ChoiStateType) = a*super(b)
 
-
 identitysuperoperator(b::Basis) = Operator(KetBraBasis(b,b), KetBraBasis(b,b), Eye{ComplexF64}(dimension(b)^2))
 
 identitysuperoperator(op::DenseOpType{BL,BR}) where {BL<:KetBraBasis, BR<:KetBraBasis} = 

test/test_pauli.jl

@@ -93,12 +93,12 @@ for (gate, rules) in [(CNOT, CNOT_rules)]
     op_chi = chi(op_sop)
 
     @test_throws DimensionMismatch Operator(PauliBasis(2), PauliBasis(3), op_ptm.data)
-    @test_throws DimensionMismatch Operator(ChiBasis(bs^2, bs^2), ChiBasis(bs^3, bs^3), op_chi.data)
+    @test_throws DimensionMismatch Operator(ChiBasis(2, 2), ChiBasis(3, 3), op_chi.data)
     @test Operator(PauliBasis(2), PauliBasis(2), op_ptm.data) == op_ptm
-    @test Operator(ChiBasis(bs^2, bs^2), op_chi.data) == op_chi
+    @test Operator(ChiBasis(2, 2), op_chi.data) == op_chi
     @test basis_l(op_sop) == basis_r(op_sop) == KetBraBasis(bs^2, bs^2)
     @test basis_l(op_choi) == basis_r(op_choi) == ChoiBasis(bs^2, bs^2)
-    @test basis_l(op_chi) == basis_r(op_chi) == ChiBasis(2)
+    @test basis_l(op_chi) == basis_r(op_chi) == ChiBasis(2, 2)
     @test basis_l(op_ptm) == basis_r(op_ptm) == PauliBasis(2)
 
     @test all(isapprox.(imag.(op_sop.data), 0))