introduce Space and Dimensions

Author: ytdHuang

src/QuantumToolbox.jl

@@ -79,6 +79,8 @@ include("progress_bar.jl")
 include("linear_maps.jl")
 
 # Quantum Object
+include("qobj/space.jl")
+include("qobj/dimensions.jl")
 include("qobj/quantum_object_base.jl")
 include("qobj/quantum_object.jl")
 include("qobj/quantum_object_evo.jl")

src/qobj/arithmetic_and_attributes.jl

@@ -196,7 +196,7 @@ Lazy matrix transpose of the [`AbstractQuantumObject`](@ref).
 LinearAlgebra.transpose(
     A::AbstractQuantumObject{DT,OpType},
 ) where {DT,OpType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
-    get_typename_wrapper(A)(transpose(A.data), A.type, A.dims)
+    get_typename_wrapper(A)(transpose(A.data), A.type, transpose(A.dims))
 
 @doc raw"""
     A'
@@ -211,13 +211,13 @@ Lazy adjoint (conjugate transposition) of the [`AbstractQuantumObject`](@ref)
 LinearAlgebra.adjoint(
     A::AbstractQuantumObject{DT,OpType},
 ) where {DT,OpType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
-    get_typename_wrapper(A)(adjoint(A.data), A.type, A.dims)
-LinearAlgebra.adjoint(A::QuantumObject{DT,KetQuantumObject}) where {DT} = QuantumObject(adjoint(A.data), Bra, A.dims)
-LinearAlgebra.adjoint(A::QuantumObject{DT,BraQuantumObject}) where {DT} = QuantumObject(adjoint(A.data), Ket, A.dims)
+    get_typename_wrapper(A)(adjoint(A.data), A.type, transpose(A.dims))
+LinearAlgebra.adjoint(A::QuantumObject{DT,KetQuantumObject}) where {DT} = QuantumObject(adjoint(A.data), Bra, transpose(A.dims))
+LinearAlgebra.adjoint(A::QuantumObject{DT,BraQuantumObject}) where {DT} = QuantumObject(adjoint(A.data), Ket, transpose(A.dims))
 LinearAlgebra.adjoint(A::QuantumObject{DT,OperatorKetQuantumObject}) where {DT} =
-    QuantumObject(adjoint(A.data), OperatorBra, A.dims)
+    QuantumObject(adjoint(A.data), OperatorBra, transpose(A.dims))
 LinearAlgebra.adjoint(A::QuantumObject{DT,OperatorBraQuantumObject}) where {DT} =
-    QuantumObject(adjoint(A.data), OperatorKet, A.dims)
+    QuantumObject(adjoint(A.data), OperatorKet, transpose(A.dims))
 
 @doc raw"""
     inv(A::AbstractQuantumObject)

src/qobj/dimensions.jl

@@ -0,0 +1,39 @@
+export AbstractDimensions, Dimensions
+
+abstract type AbstractDimensions{N} end
+
+struct Dimensions{N} <: AbstractDimensions{N}
+    to::SVector{N,AbstractSpace}
+end
+Base.show(io::IO, D::Dimensions) = print(io, D.to)
+
+function Dimensions(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Integer,N}
+    _non_static_array_warning("dims", dims)
+    L = length(dims)
+    (L > 0) || throw(DomainError(dims, "The argument dims must be of non-zero length"))
+
+    return Dimensions(SVector{L,AbstractSpace}(Space.(dims)))
+end
+
+_gen_dims(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Integer,N} = Dimensions(dims)
+_gen_dims(dims::Int) = Dimensions(SVector{1,AbstractSpace}(Space(dims)))
+_gen_dims(dims::AbstractDimensions) = dims
+_gen_dims(dims::Any) = throw(
+    ArgumentError(
+        "The argument dims must be a Tuple or a StaticVector of non-zero length and contain only positive integers.",
+    ),
+)
+
+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
+
+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
+    from::SVector{N,AbstractSpace} # space acting on the right
+end
+Base.show(io::IO, D::CompoundDimensions) = print(io, "[", D.to, ", ", D.from, "]")
+
+LinearAlgebra.transpose(dims::CompoundDimensions) = CompoundDimensions(dims.from, dims.to) # switch `to` and `from`

src/qobj/quantum_object.jl

@@ -9,10 +9,10 @@ It also implements the fundamental functions in Julia standard library:
 export QuantumObject
 
 @doc raw"""
-    struct QuantumObject{MT<:AbstractArray,ObjType<:QuantumObjectType,N}
+    struct QuantumObject{MT<:AbstractArray,ObjType<:QuantumObjectType,DimType<:AbstractDimensions}
         data::MT
         type::ObjType
-        dims::SVector{N, Int}
+        dims::DimType
     end
 
 Julia struct representing any quantum objects.
@@ -33,26 +33,21 @@ julia> a isa QuantumObject
 true
 ```
 """
-struct QuantumObject{MT<:AbstractArray,ObjType<:QuantumObjectType,N} <: AbstractQuantumObject{MT,ObjType,N}
+struct QuantumObject{MT<:AbstractArray,ObjType<:QuantumObjectType,DimType<:AbstractDimensions} <: AbstractQuantumObject{MT,ObjType,DimType}
     data::MT
     type::ObjType
-    dims::SVector{N,Int}
+    dims::DimType
 
     function QuantumObject(data::MT, type::ObjType, dims) where {MT<:AbstractArray,ObjType<:QuantumObjectType}
-        _check_dims(dims)
+        _dims = _gen_dims(dims)
 
         _size = _get_size(data)
-        _check_QuantumObject(type, dims, _size[1], _size[2])
+        _check_QuantumObject(type, _dims, _size[1], _size[2])
 
-        N = length(dims)
-
-        return new{MT,ObjType,N}(data, type, SVector{N,Int}(dims))
+        return new{MT,ObjType,typeof(_dims)}(data, type, _dims)
     end
 end
 
-QuantumObject(A::AbstractArray, type::ObjType, dims::Integer) where {ObjType<:QuantumObjectType} =
-    QuantumObject(A, type, SVector{1,Int}(dims))
-
 @doc raw"""
     Qobj(A::AbstractArray; type = nothing, dims = nothing)
     QuantumObject(A::AbstractArray; type = nothing, dims = nothing)
@@ -81,9 +76,9 @@ function QuantumObject(
 
     if dims isa Nothing
         if type isa OperatorQuantumObject || type isa BraQuantumObject
-            dims = SVector{1,Int}(_size[2])
+            dims = _size[2]
         elseif type isa SuperOperatorQuantumObject || type isa OperatorBraQuantumObject
-            dims = SVector{1,Int}(isqrt(_size[2]))
+            dims = isqrt(_size[2])
         end
     end
 
@@ -104,9 +99,9 @@ function QuantumObject(
     if dims isa Nothing
         _size = _get_size(A)
         if type isa KetQuantumObject
-            dims = SVector{1,Int}(_size[1])
+            dims = _gen_dims(_size[1])
         elseif type isa OperatorKetQuantumObject
-            dims = SVector{1,Int}(isqrt(_size[1]))
+            dims = _gen_dims(isqrt(_size[1]))
         end
     end
 
@@ -127,8 +122,9 @@ function QuantumObject(
     dims = A.dims,
 ) where {T,N,ObjType<:QuantumObjectType}
     _size = N == 1 ? (length(A), 1) : size(A)
-    _check_QuantumObject(type, dims, _size[1], _size[2])
-    return QuantumObject(copy(A.data), type, dims)
+    _dims = _gen_dims(dims)
+    _check_QuantumObject(type, _dims, _size[1], _size[2])
+    return QuantumObject(copy(A.data), type, _dims)
 end
 
 function Base.show(

src/qobj/quantum_object_base.jl

@@ -24,7 +24,7 @@ julia> sigmax() isa AbstractQuantumObject
 true
 ```
 """
-abstract type AbstractQuantumObject{DataType,ObjType,N} end
+abstract type AbstractQuantumObject{DataType,ObjType,DimType} end
 
 abstract type QuantumObjectType end
 
@@ -163,17 +163,6 @@ function check_dims(A::AbstractQuantumObject, B::AbstractQuantumObject)
     return nothing
 end
 
-function _check_dims(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Integer,N}
-    _non_static_array_warning("dims", dims)
-    return (all(>(0), dims) && length(dims) > 0) ||
-           throw(DomainError(dims, "The argument dims must be of non-zero length and contain only positive integers."))
-end
-_check_dims(dims::Any) = throw(
-    ArgumentError(
-        "The argument dims must be a Tuple or a StaticVector of non-zero length and contain only positive integers.",
-    ),
-)
-
 function _check_QuantumObject(type::KetQuantumObject, dims, m::Int, n::Int)
     (n != 1) && throw(DomainError((m, n), "The size of the array is not compatible with Ket"))
     (prod(dims) != m) && throw(DimensionMismatch("Ket with dims = $(dims) does not fit the array size = $((m, n))."))

src/qobj/quantum_object_evo.jl

@@ -5,10 +5,10 @@ This file defines the QuantumObjectEvolution (QobjEvo) structure.
 export QuantumObjectEvolution
 
 @doc raw"""
-    struct QuantumObjectEvolution{DT<:AbstractSciMLOperator,ObjType<:QuantumObjectType,N} <: AbstractQuantumObject
+    struct QuantumObjectEvolution{DT<:AbstractSciMLOperator,ObjType<:QuantumObjectType,DimType<:AbstractDimensions} <: AbstractQuantumObject
         data::DT
         type::ObjType
-        dims::SVector{N,Int}
+        dims::DimType
     end
 
 Julia struct representing any time-dependent quantum object. The `data` field is a `AbstractSciMLOperator` object that represents the time-dependent quantum object. It can be seen as
@@ -99,11 +99,11 @@ Quantum Object:   type=Operator   dims=[10, 2]   size=(20, 20)   ishermitian=fal
 struct QuantumObjectEvolution{
     DT<:AbstractSciMLOperator,
     ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject},
-    N,
-} <: AbstractQuantumObject{DT,ObjType,N}
+    DimType<:AbstractDimensions,
+} <: AbstractQuantumObject{DT,ObjType,DimType}
     data::DT
     type::ObjType
-    dims::SVector{N,Int}
+    dims::DimType
 
     function QuantumObjectEvolution(
         data::DT,
@@ -113,14 +113,12 @@ struct QuantumObjectEvolution{
         (type == Operator || type == SuperOperator) ||
             throw(ArgumentError("The type $type is not supported for QuantumObjectEvolution."))
 
-        _check_dims(dims)
+        _dims = _gen_dims(dims)
 
         _size = _get_size(data)
-        _check_QuantumObject(type, dims, _size[1], _size[2])
+        _check_QuantumObject(type, _dims, _size[1], _size[2])
 
-        N = length(dims)
-
-        return new{DT,ObjType,N}(data, type, SVector{N,Int}(dims))
+        return new{DT,ObjType,typeof(_dims)}(data, type, _dims)
     end
 end
 
@@ -142,10 +140,6 @@ function Base.show(io::IO, QO::QuantumObjectEvolution)
     return show(io, MIME("text/plain"), op_data)
 end
 
-function QuantumObjectEvolution(data::AbstractSciMLOperator, type::QuantumObjectType, dims::Integer)
-    return QuantumObjectEvolution(data, type, SVector{1,Int}(dims))
-end
-
 @doc raw"""
     QobjEvo(data::AbstractSciMLOperator; type::QuantumObjectType = Operator, dims = nothing)
     QuantumObjectEvolution(data::AbstractSciMLOperator; type::QuantumObjectType = Operator, dims = nothing)
@@ -159,9 +153,9 @@ function QuantumObjectEvolution(data::AbstractSciMLOperator; type::QuantumObject
 
     if dims isa Nothing
         if type == Operator
-            dims = SVector{1,Int}(_size[2])
+            dims = _gen_dims(_size[2])
         elseif type == SuperOperator
-            dims = SVector{1,Int}(isqrt(_size[2]))
+            dims = _gen_dims(isqrt(_size[2]))
         end
     end
 

src/qobj/space.jl

@@ -0,0 +1,20 @@
+export AbstractSpace, Space
+
+abstract type AbstractSpace end
+
+# this show function is for printing AbstractDimensions
+Base.show(io::IO, svec::SVector{N,AbstractSpace}) where {N} = print(io, "[", join(svec, ", "), "]")
+
+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)
+    end
+end
+Base.show(io::IO, s::Space) = print(io, s.size)
+
+# for `prod(::Dimensions)`
+Base.:(*)(i::Int, s::Space) = i * s.size
+Base.:(*)(s1::Space, s2::Space) = s1.size * s2.size

test/core-test/quantum_objects.jl

@@ -117,12 +117,12 @@
         @test isoperket(ρ_bra) == false
         @test isoperbra(ρ_bra) == true
         @test isunitary(ρ_bra) == false
-        @test ρ_bra.dims == [2]
-        @test ρ_ket.dims == [2]
+        @test ρ_bra.dims == Dimensions((2,))
+        @test ρ_ket.dims == Dimensions((2,))
         @test H * ρ ≈ spre(H) * ρ
         @test ρ * H ≈ spost(H) * ρ
         @test H * ρ * H ≈ sprepost(H, H) * ρ
-        @test (L * ρ_ket).dims == [2]
+        @test (L * ρ_ket).dims == Dimensions((2,))
         @test L * ρ_ket ≈ -1im * (+(spre(H) * ρ_ket) - spost(H) * ρ_ket)
         @test (ρ_bra * L')' == L * ρ_ket
         @test sum((conj(ρ) .* ρ).data) ≈ dot(ρ_ket, ρ_ket) ≈ ρ_bra * ρ_ket
@@ -316,7 +316,7 @@
             end
 
             UnionType =
-                Union{QuantumObject{Matrix{T},BraQuantumObject,1},QuantumObject{Matrix{T},OperatorQuantumObject,1}}
+                Union{QuantumObject{Matrix{T},BraQuantumObject,Dimensions{1}},QuantumObject{Matrix{T},OperatorQuantumObject,Dimensions{1}}}
             a = rand(T, 1, N)
             @inferred UnionType Qobj(a)
             for type in [Bra, OperatorBra]

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")