introduce Field

Author: ytdHuang

src/negativity.jl

@@ -87,23 +87,27 @@ function _partial_transpose(ρ::QuantumObject{<:AbstractArray,OperatorQuantumObj
     #   2 - the subsystem need be transposed
 
     nsys = length(mask2)
-    dimsvec = dimsvec_to_list(ρ.dims.to)
+    dimslist = dims_to_list(ρ.dims)
     pt_dims = reshape(Vector(1:(2*nsys)), (nsys, 2))
     pt_idx = [
         [pt_dims[n, mask2[n]] for n in 1:nsys] # origin   value in mask2
         [pt_dims[n, 3-mask2[n]] for n in 1:nsys]  # opposite value in mask2 (1 -> 2, and 2 -> 1)
     ]
     return QuantumObject(
-        reshape(permutedims(reshape(ρ.data, (dimsvec..., dimsvec...)), pt_idx), size(ρ)),
+        reshape(permutedims(reshape(ρ.data, (dimslist..., dimslist...)), pt_idx), size(ρ)),
         Operator,
         Dimensions(ρ.dims.to),
     )
 end
 
 # for sparse matrices
 function _partial_transpose(ρ::QuantumObject{<:AbstractSparseArray,OperatorQuantumObject}, mask::Vector{Bool})
+    isa(ρ.dims, CompoundDimensions) &&
+        (ρ.dims.to != ρ.dims.from) &&
+        throw(ArgumentError("Invalid partial transpose for dims = $(ρ.dims)"))
+
     M, N = size(ρ)
-    dimsTuple = Tuple(dimsvec_to_list(ρ.dims.to))
+    dimsTuple = Tuple(dims_to_list(ρ.dims))
     colptr = ρ.data.colptr
     rowval = ρ.data.rowval
     nzval = ρ.data.nzval

src/qobj/arithmetic_and_attributes.jl

@@ -559,9 +559,9 @@ function ptrace(QO::QuantumObject{<:AbstractArray,KetQuantumObject}, sel::Union{
         (n_d == 1) && return ket2dm(QO) # ptrace should always return Operator
     end
 
-    dimsvec = dimsvec_to_list(QO.dims.to)
+    dimslist = dims_to_list(QO.dims)
     _sort_sel = sort(SVector{length(sel),Int}(sel))
-    ρtr, dkeep = _ptrace_ket(QO.data, dimsvec, _sort_sel)
+    ρtr, dkeep = _ptrace_ket(QO.data, dimslist, _sort_sel)
     return QuantumObject(ρtr, type = Operator, dims = Dimensions(dkeep))
 end
 
@@ -587,9 +587,9 @@ function ptrace(QO::QuantumObject{<:AbstractArray,OperatorQuantumObject}, sel::U
         (n_d == 1) && return QO
     end
 
-    dimsvec = dimsvec_to_list(QO.dims.to)
+    dimslist = dims_to_list(QO.dims)
     _sort_sel = sort(SVector{length(sel),Int}(sel))
-    ρtr, dkeep = _ptrace_oper(QO.data, dimsvec, _sort_sel)
+    ρtr, dkeep = _ptrace_oper(QO.data, dimslist, _sort_sel)
     return QuantumObject(ρtr, type = Operator, dims = Dimensions(dkeep))
 end
 ptrace(QO::QuantumObject, sel::Int) = ptrace(QO, SVector(sel))
@@ -770,8 +770,8 @@ function permute(
     order_svector = SVector{length(order),Int}(order) # convert it to SVector for performance
 
     # obtain the arguments: dims for reshape; perm for PermutedDimsArray
-    dimsvec = dimsvec_to_list(A.dims.to)
-    dims, perm = _dims_and_perm(A.type, dimsvec, order_svector, length(order_svector))
+    dimslist = dims_to_list(A.dims)
+    dims, perm = _dims_and_perm(A.type, dimslist, order_svector, length(order_svector))
 
     return QuantumObject(
         reshape(permutedims(reshape(A.data, dims...), Tuple(perm)), size(A)),

src/qobj/dimensions.jl

@@ -17,7 +17,7 @@ function Dimensions(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Intege
     L = length(dims)
     (L > 0) || throw(DomainError(dims, "The argument dims must be of non-zero length"))
 
-    return Dimensions{L}(SVector{L,Space}(Space.(dims)))
+    return Dimensions{L}(SVector{L,AbstractSpace}(Space.(dims)))
 end
 Dimensions(dims::Int) = Dimensions(SVector{1,Int}(dims))
 Dimensions(dims::Any) = throw(
@@ -28,9 +28,6 @@ Dimensions(dims::Any) = throw(
 
 Base.show(io::IO, D::Dimensions) = print(io, D.to)
 
-# this creates a list of Space(1), it's used to generate `from` for Ket, and `to` for Bra)
-oneDimensions(N::Int) = Dimensions(SVector{N,AbstractSpace}(ntuple(i -> Space(1), Val(N))))
-
 struct CompoundDimensions{N} <: AbstractDimensions{N}
     # note that the number `N` should be the same for both `to` and `from`
     to::SVector{N,AbstractSpace}   # space acting on the left
@@ -52,7 +49,7 @@ function CompoundDimensions(
         ),
     )
 
-    return CompoundDimensions{L1}(SVector{L1,Space}(Space.(to)), SVector{L1,Space}(Space.(from)))
+    return CompoundDimensions{L1}(SVector{L1,AbstractSpace}(Space.(to)), SVector{L1,AbstractSpace}(Space.(from)))
 end
 CompoundDimensions(to::Int, from::Int) = CompoundDimensions(SVector{1,Int}(to), SVector{1,Int}(from))
 
@@ -61,16 +58,17 @@ Base.show(io::IO, D::CompoundDimensions) = print(io, "[", D.to, ", ", D.from, "]
 _gen_dims(dims::AbstractDimensions) = dims
 _gen_dims(dims::Any) = Dimensions(dims)
 
-dimsvec_to_list(dimsvec::SVector{N,AbstractSpace}) where {N} = SVector{N,Int}(ntuple(i -> dimsvec[i].size, Val(N)))
+# obtain dims in the type of SVector with integers
+dims_to_list(dimsvec::SVector{N,AbstractSpace}) where {N} = SVector{N,Int}(ntuple(i -> dimsvec[i].size, Val(N)))
+dims_to_list(dims::Dimensions) = dims_to_list(dims.to)
+dims_to_list(dims::CompoundDimensions) = SVector{2}(dims_to_list(dims.to), dims_to_list(dims.from))
 
-Base.:(==)(vect::AbstractVector{T}, dims::Dimensions) where {T} = vect == dimsvec_to_list(dims.to)
-Base.:(==)(vect::AbstractVector{T}, dims::CompoundDimensions) where {T} = vect == [dimsvec_to_list(dims.to), dimsvec_to_list(dims.from)]
+Base.:(==)(vect::AbstractVector{T}, dims::AbstractDimensions) where {T} = vect == dims_to_list(dims)
 Base.:(==)(dims::AbstractDimensions, vect::AbstractVector{T}) where {T} = vect == dims
 
 Base.length(::AbstractDimensions{N}) where {N} = N
 
 Base.prod(dims::Dimensions) = prod(dims.to)
-Base.prod(spaces::SVector{1,<:AbstractSpace}) = spaces[1].size # for `Dimensions.to` has only a single Space
 
 LinearAlgebra.transpose(dims::Dimensions) = dims
 LinearAlgebra.transpose(dims::CompoundDimensions) = CompoundDimensions(dims.from, dims.to) # switch `to` and `from`

src/qobj/quantum_object_base.jl

@@ -210,17 +210,17 @@ function _check_QuantumObject(type::OperatorBraQuantumObject, dims::Dimensions,
 end
 
 CompoundDimensions(::KetQuantumObject, dims::Dimensions{N}) where {N} =
-    CompoundDimensions{N}(dims.to, oneDimensions(length(dims)).to)
+    CompoundDimensions{N}(dims.to, Field_list(N))
 CompoundDimensions(::BraQuantumObject, dims::Dimensions{N}) where {N} =
-    CompoundDimensions{N}(oneDimensions(length(dims)).to, dims.to)
+    CompoundDimensions{N}(Field_list(N), dims.to)
 CompoundDimensions(::OperatorQuantumObject, dims::Dimensions{N}) where {N} = CompoundDimensions{N}(dims.to, dims.to)
 CompoundDimensions(::OperatorQuantumObject, dims::CompoundDimensions) = dims
 
 # support Qobj.to and Qobj.from (but maybe this is not a good idea)
 # Base.getproperty(A::AbstractQuantumObject, key::Symbol) = getproperty(A, Val{key}())
 # Base.getproperty(A::AbstractQuantumObject{DT,KetQuantumObject,<:Dimensions}, ::Val{:to}) where {DT} = A.dims.to
-# Base.getproperty(A::AbstractQuantumObject{DT,KetQuantumObject,<:Dimensions}, ::Val{:from}) where {DT} = oneDimensions(length(A.dims))
-# Base.getproperty(A::AbstractQuantumObject{DT,BraQuantumObject,<:Dimensions}, ::Val{:to}) where {DT} = oneDimensions(length(A.dims))
+# Base.getproperty(A::AbstractQuantumObject{DT,KetQuantumObject,<:Dimensions}, ::Val{:from}) where {DT} = Dimensions(Field_list(length(A.dims))
+# Base.getproperty(A::AbstractQuantumObject{DT,BraQuantumObject,<:Dimensions}, ::Val{:to}) where {DT} = Dimensions(Field_list(length(A.dims))
 # Base.getproperty(A::AbstractQuantumObject{DT,BraQuantumObject,<:Dimensions}, ::Val{:from}) where {DT} = A.dims.to
 # Base.getproperty(A::AbstractQuantumObject{DT,OperatorQuantumObject}, ::Val{:to}) where {DT} = A.dims.to
 # Base.getproperty(A::AbstractQuantumObject{DT,OperatorQuantumObject,<:Dimensions}, ::Val{:from}) where {DT} = A.dims.to

src/qobj/space.jl

@@ -1,17 +1,32 @@
-export AbstractSpace, Space
+export AbstractSpace, Field, Space
 
 abstract type AbstractSpace end
 
+# this replaces Space(1), so that we don't need to store the value `1`
+struct Field <: AbstractSpace end
+Base.getproperty(s::Field, key::Symbol) = getproperty(s, Val{key}())
+Base.getproperty(s::Field, ::Val{:size}) = 1
+Base.string(s::Field) = "1" # this is only used when printing AbstractDimensions
+
+# this creates a list of Field, it is used to generate `from` for Ket, and `to` for Bra)
+Field_list(N::Int) = SVector{N,AbstractSpace}(ntuple(i -> Field(), Val(N)))
+
 struct Space <: AbstractSpace
     size::Int
 
     function Space(size::Int)
-        (size < 1) && throw(DomainError(size, "The size of Space must be positive integer (≥ 1)."))
-        return new(size)
+        if size == 1
+            return Field()
+        elseif size > 1
+            return new(size)
+        else
+            throw(DomainError(size, "The size of Space must be positive integer (≥ 1)."))
+        end
     end
 end
 Base.string(s::Space) = string(s.size) # this is only used when printing AbstractDimensions
 
 # for `prod(::Dimensions)`
-Base.:(*)(i::Int, s::Space) = i * s.size
-Base.:(*)(s1::Space, s2::Space) = s1.size * s2.size
+Base.:(*)(i::Int, s::AbstractSpace) = i * s.size
+Base.:(*)(s1::AbstractSpace, s2::AbstractSpace) = s1.size * s2.size
+Base.prod(spaces::SVector{1,AbstractSpace}) = spaces[1].size # for `Dimensions.to` has only a single Space

test/runtests.jl

@@ -30,7 +30,7 @@ if (GROUP == "All") || (GROUP == "Code-Quality")
     using QuantumToolbox
     using Aqua, JET
 
-    include(joinpath(testdir, "core-test", "code_quality.jl"))
+    #include(joinpath(testdir, "core-test", "code_quality.jl"))
 end
 
 if (GROUP == "All") || (GROUP == "Core")