WIP

Author: akirakyle

src/QuantumOpticsBase.jl

@@ -4,8 +4,12 @@ using SparseArrays, LinearAlgebra, LRUCache, Strided, UnsafeArrays, FillArrays
 import LinearAlgebra: mul!, rmul!
 import RecursiveArrayTools
 
-import QuantumInterface: dagger, directsum, ⊕, dm, embed, nsubsystems, expect, identityoperator, identitysuperoperator,
-        permutesystems, projector, ptrace, reduced, tensor, ⊗, variance, apply!, basis, basis_l, basis_r
+import QuantumInterface: Basis, GenericBasis, CompositeBasis, basis, basis_l, basis_r,
+    IncompatibleBases, @compatiblebases, samebases, check_samebases,
+    addible, check_addible, multiplicable, check_multiplicable, reduced, ptrace, permutesystems,
+    dagger, directsum, ⊕, dm, embed, nsubsystems, expect, identityoperator, identitysuperoperator,
+    permutesystems, projector, ptrace, reduced, tensor, ⊗, variance, apply!,
+    super, choi, kraus, vec, spre, spost, sprepost, liouvillian
 
 # index helpers
 import QuantumInterface: complement, remove, shiftremove, reducedindices!, check_indices, check_sortedindices, check_embed_indices
@@ -35,9 +39,8 @@ export Basis, GenericBasis, CompositeBasis, basis, basis_l, basis_r,
                 AbstractTimeDependentOperator, TimeDependentSum, set_time!,
                 current_time, time_shift, time_stretch, time_restrict, static_operator,
         #superoperators
-                SuperOperator, DenseSuperOperator, DenseSuperOpType,
-                SparseSuperOperator, SparseSuperOpType, spre, spost, sprepost, liouvillian,
-                identitysuperoperator,
+                KetBraBasis, ChoiBasis, super, choi, kraus, vec,
+                spre, spost, sprepost, liouvillian, identitysuperoperator,
         #fock
                 FockBasis, number, destroy, create,
                 fockstate, coherentstate, coherentstate!,
@@ -71,7 +74,6 @@ export Basis, GenericBasis, CompositeBasis, basis, basis_l, basis_r,
         #apply
                 apply!
 
-include("bases.jl")
 include("states.jl")
 include("operators.jl")
 include("operators_dense.jl")
@@ -92,7 +94,7 @@ include("particle.jl")
 include("nlevel.jl")
 include("manybody.jl")
 include("transformations.jl")
-include("pauli.jl")
+#include("pauli.jl")
 include("metrics.jl")
 include("spinors.jl")
 include("phasespace.jl")

src/apply.jl

@@ -23,11 +23,11 @@ function apply!(state::Operator, indices, operation::Operator)
     state
 end
 
-function apply!(state::Ket, indices, operation::T) where {T<:AbstractSuperOperator}
+function apply!(state::Ket, indices, operation::T) where {T<:SuperOperatorType}
     apply!(dm(state), indices, operation)
 end
 
-function apply!(state::Operator, indices, operation::T) where {T<:AbstractSuperOperator}
+function apply!(state::Operator, indices, operation::T) where {T<:SuperOperatorType}
     if is_apply_shortcircuit(state, indices, operation)
         state.data = (operation*state).data
         return state

src/bases.jl

@@ -253,11 +253,14 @@ logarithmic_negativity(rho::DenseOpType{B,B}, index) where B<:CompositeBasis = l
     avg_gate_fidelity(x, y)
 
 The average gate fidelity between two superoperators x and y.
+"""
+
 """
 function avg_gate_fidelity(x::T, y::T) where T <: Union{PauliTransferMatrix{B, B} where B, SuperOperator{B, B} where B, ChiMatrix{B, B} where B}
     dim = 2 ^ length(x.basis_l)
     return (tr(transpose(x.data) * y.data) + dim) / (dim^2 + dim)
 end
+"""
 
 """
     entanglement_entropy(state, partition, [entropy_fun=entropy_vn])

src/metrics.jl

@@ -23,11 +23,11 @@ Embed operator acting on a joint Hilbert space where missing indices are filled
 """
 function embed(bl::CompositeBasis, br::CompositeBasis,
                indices, op::T) where T<:DataOperator
-    (nsubsystems(basis_l) == nsubsystems(basis_r)) || throw(ArgumentError("Must have nsubsystems(bl) == nsubsystems(br) in embed"))
-    N = nsubsystems(basis_l)
+    (nsubsystems(bl) == nsubsystems(br)) || throw(ArgumentError("Must have nsubsystems(bl) == nsubsystems(br) in embed"))
+    N = nsubsystems(bl)
 
-    reduce(tensor, bl[indices]) == op.basis_l || throw(IncompatibleBases())
-    reduce(tensor, br[indices]) == op.basis_r || throw(IncompatibleBases())
+    reduce(tensor, bl[indices]) == basis_l(op) || throw(IncompatibleBases())
+    reduce(tensor, br[indices]) == basis_r(op) || throw(IncompatibleBases())
 
     index_order = [idx for idx in 1:N if idx ∉ indices]
     all_operators = AbstractOperator[identityoperator(T, eltype(op), bl[i], br[i]) for i in index_order]
@@ -44,8 +44,8 @@ function embed(bl::CompositeBasis, br::CompositeBasis,
 
     # Reorient the matrix to act in the correctly ordered basis.
     # Get the dimensions necessary for index permuting.
-    dims_l = size(basis_l)
-    dims_r = size(basis_r)
+    dims_l = size(bl)
+    dims_r = size(br)
 
     # Get the order of indices to use in the first reshape. Julia indices go in
     # reverse order.
@@ -65,7 +65,7 @@ function embed(bl::CompositeBasis, br::CompositeBasis,
 
     # Create operator with proper data and bases
     constructor = Base.typename(T)
-    unpermuted_op = constructor.wrapper(basis_l, basis_r, M)
+    unpermuted_op = constructor.wrapper(bl, br, M)
 
     return unpermuted_op
 end

src/operators.jl

@@ -1,7 +1,7 @@
-import LinearAlgebra: vec
+import QuantumInterface: KetBraBasis, ChoiBasis
 
 const SuperOperatorType = Operator{<:KetBraBasis,<:KetBraBasis}
-const ChoiStateType = Operator{CompositeBasis{<:Integer,<:Choi},CompositeBasis{<:Integer,<:Choi}}
+const ChoiStateType = Operator{CompositeBasis{<:Integer,<:ChoiBasis},CompositeBasis{<:Integer,<:ChoiBasis}}
 
 vec(op::Operator) = Ket(KetBraBasis(basis_l(op), basis_r(op)), reshape(op.data, length(op.data)))