Rename Space to HilbertSpace

Author: albertomercurio

docs/src/resources/api.md

@@ -17,7 +17,7 @@ end
 ## [Quantum object (Qobj) and type](@id doc-API:Quantum-object-and-type)
 
 ```@docs
-Space
+HilbertSpace
 EnrSpace
 ProductDimensions
 GeneralProductDimensions

src/entropy.jl

@@ -221,7 +221,7 @@ Calculate the [concurrence](https://en.wikipedia.org/wiki/Concurrence_(quantum_c
 - [Hill-Wootters1997](@citet)
 """
 function concurrence(ρ::QuantumObject{OpType}) where {OpType<:Union{Ket,Operator}}
-    (ρ.dimensions == ProductDimensions((Space(2), Space(2)))) || throw(
+    (ρ.dimensions == ProductDimensions((HilbertSpace(2), HilbertSpace(2)))) || throw(
         ArgumentError(
             "The `concurrence` only works for a two-qubit state, invalid dims = $(_get_dims_string(ρ.dimensions)).",
         ),

src/qobj/dimensions.jl

@@ -11,7 +11,7 @@ abstract type AbstractDimensions{M,N} end
         to::T
     end
 
-A structure that describes the Hilbert [`Space`](@ref) of each subsystems.
+A structure that embodies the [`AbstractSpace`](@ref) of each subsystem in a composite Hilbert space.
 """
 struct ProductDimensions{N,T<:Tuple} <: AbstractDimensions{N,N}
     to::T
@@ -24,9 +24,9 @@ function ProductDimensions(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<
     L = length(dims)
     (L > 0) || throw(DomainError(dims, "The argument dims must be of non-zero length"))
 
-    return ProductDimensions(Tuple(Space.(dims)))
+    return ProductDimensions(Tuple(HilbertSpace.(dims)))
 end
-ProductDimensions(dims::Int) = ProductDimensions(Space(dims))
+ProductDimensions(dims::Int) = ProductDimensions(HilbertSpace(dims))
 ProductDimensions(dims::DimType) where {DimType<:AbstractSpace} = ProductDimensions((dims,))
 ProductDimensions(dims::Any) = throw(
     ArgumentError(
@@ -40,7 +40,7 @@ ProductDimensions(dims::Any) = throw(
         from::T2
     end
 
-A structure that describes the left-hand side (`to`) and right-hand side (`from`) Hilbert [`Space`](@ref) of an [`Operator`](@ref).
+A structure that embodies the left-hand side (`to`) and right-hand side (`from`) [`AbstractSpace`](@ref) of a quantum object.
 """
 struct GeneralProductDimensions{M,N,T1<:Tuple,T2<:Tuple} <: AbstractDimensions{M,N}
     to::T1   # space acting on the left
@@ -61,7 +61,7 @@ function GeneralProductDimensions(dims::Union{AbstractVector{T},NTuple{N,T}}) wh
     (L1 > 0) || throw(DomainError(L1, "The length of `dims[1]` must be larger or equal to 1."))
     (L2 > 0) || throw(DomainError(L2, "The length of `dims[2]` must be larger or equal to 1."))
 
-    return GeneralProductDimensions(Tuple(Space.(dims[1])), Tuple(Space.(dims[2])))
+    return GeneralProductDimensions(Tuple(HilbertSpace.(dims[1])), Tuple(HilbertSpace.(dims[2])))
 end
 
 _gen_dimensions(dims::AbstractDimensions) = dims

src/qobj/eigsolve.jl

@@ -45,7 +45,7 @@ julia> λ
   1.0 + 0.0im
 
 julia> ψ
-2-element Vector{QuantumObject{Ket, ProductDimensions{1, Tuple{Space}}, Vector{ComplexF64}}}:
+2-element Vector{QuantumObject{Ket, ProductDimensions{1, Tuple{HilbertSpace}}, Vector{ComplexF64}}}:
 
 Quantum Object:   type=Ket()   dims=[2]   size=(2,)
 2-element Vector{ComplexF64}:

src/qobj/quantum_object.jl

@@ -41,7 +41,7 @@ julia> a.dims
  20
 
 julia> a.dimensions
-ProductDimensions{1, Tuple{Space}}((Space(20),))
+ProductDimensions{1, Tuple{HilbertSpace}}((HilbertSpace(20),))
 ```
 """
 struct QuantumObject{ObjType<:QuantumObjectType,DimType<:AbstractDimensions,DataType<:AbstractArray} <:

src/qobj/quantum_object_base.jl

@@ -238,10 +238,10 @@ get_dimensions_from(
     A::AbstractQuantumObject{ObjType,<:ProductDimensions},
 ) where {ObjType<:Union{SuperOperator,OperatorBra,OperatorKet}} = A.dimensions.to
 
-# this creates a list of Space(1), it is used to generate `from` for Ket, and `to` for Bra
+# this creates a list of HilbertSpace(1), it is used to generate `from` for Ket, and `to` for Bra
 space_one_list(dimensions::NTuple{N,AbstractSpace}) where {N} =
-    ntuple(i -> Space(1), Val(sum(_get_dims_length, dimensions)))
-_get_dims_length(::Space) = 1
+    ntuple(i -> HilbertSpace(1), Val(sum(_get_dims_length, dimensions)))
+_get_dims_length(::HilbertSpace) = 1
 _get_dims_length(::EnrSpace{N}) where {N} = N
 
 # functions for getting Float or Complex element type

src/qobj/space.jl

@@ -2,24 +2,24 @@
 This file defines the Hilbert space structure.
 =#
 
-export AbstractSpace, Space
+export AbstractSpace, HilbertSpace
 
 abstract type AbstractSpace end
 
 @doc raw"""
-    struct Space <: AbstractSpace
+    struct HilbertSpace <: AbstractSpace
         size::Int
     end
 
 A structure that describes a single Hilbert space with size = `size`.
 """
-struct Space <: AbstractSpace
+struct HilbertSpace <: AbstractSpace
     size::Int
 
-    function Space(size::Int)
-        (size < 1) && throw(DomainError(size, "The size of Space must be positive integer (≥ 1)."))
+    function HilbertSpace(size::Int)
+        (size < 1) && throw(DomainError(size, "The size of `HilbertSpace` must be positive integer (≥ 1)."))
         return new(size)
     end
 end
 
-dimensions_to_dims(s::Space) = SVector{1,Int}(s.size)
+dimensions_to_dims(s::HilbertSpace) = SVector{1,Int}(s.size)

test/core-test/enr_state_operator.jl

@@ -22,14 +22,14 @@
     end
 
     @testset "kron" begin
-        # normal Space
+        # normal HilbertSpace
         D1 = 4
         D2 = 5
         dims_s = (D1, D2)
         ρ_s = rand_dm(dims_s)
         I_s = qeye(D1) ⊗ qeye(D2)
         size_s = prod(dims_s)
-        space_s = (Space(D1), Space(D2))
+        space_s = (HilbertSpace(D1), HilbertSpace(D2))
 
         # EnrSpace
         dims_enr = (2, 2, 3)
@@ -50,15 +50,18 @@
               "\nQuantum Object:   type=Operator()   dims=$ρ_tot_dims   size=$((ρ_tot_size, ρ_tot_size))   ishermitian=$ρ_tot_isherm\n$datastring"
 
         # use GeneralProductDimensions to do partial trace
-        new_dims1 = GeneralProductDimensions((Space(1), Space(1), space_enr), (Space(1), Space(1), space_enr))
+        new_dims1 = GeneralProductDimensions(
+            (HilbertSpace(1), HilbertSpace(1), space_enr),
+            (HilbertSpace(1), HilbertSpace(1), space_enr),
+        )
         ρ_enr_compound = Qobj(zeros(ComplexF64, size_enr, size_enr), dims = new_dims1)
         basis_list = [tensor(basis(D1, i), basis(D2, j)) for i in 0:(D1-1) for j in 0:(D2-1)]
         for b in basis_list
             ρ_enr_compound += tensor(b', I_enr) * ρ_tot * tensor(b, I_enr)
         end
         new_dims2 = GeneralProductDimensions(
-            (space_s..., Space(1), Space(1), Space(1)),
-            (space_s..., Space(1), Space(1), Space(1)),
+            (space_s..., HilbertSpace(1), HilbertSpace(1), HilbertSpace(1)),
+            (space_s..., HilbertSpace(1), HilbertSpace(1), HilbertSpace(1)),
         )
         ρ_s_compound = Qobj(zeros(ComplexF64, size_s, size_s), dims = new_dims2)
         basis_list = [enr_fock(space_enr, space_enr.idx2state[idx]) for idx in 1:space_enr.size]

test/core-test/low_rank_dynamics.jl

@@ -11,7 +11,7 @@
     M = latt.N + 1       # Number of states in the LR basis
 
     # Define initial state
-    ϕ = Vector{QuantumObject{Ket,ProductDimensions{M - 1,NTuple{M - 1,Space}},Vector{ComplexF64}}}(undef, M)
+    ϕ = Vector{QuantumObject{Ket,ProductDimensions{M - 1,NTuple{M - 1,HilbertSpace}},Vector{ComplexF64}}}(undef, M)
     ϕ[1] = kron(fill(basis(2, 1), N_modes)...)
 
     i = 1

test/core-test/quantum_objects.jl

@@ -367,8 +367,8 @@
             end
 
             UnionType = Union{
-                QuantumObject{Bra,ProductDimensions{1,Tuple{Space}},Matrix{T}},
-                QuantumObject{Operator,ProductDimensions{1,Tuple{Space}},Matrix{T}},
+                QuantumObject{Bra,ProductDimensions{1,Tuple{HilbertSpace}},Matrix{T}},
+                QuantumObject{Operator,ProductDimensions{1,Tuple{HilbertSpace}},Matrix{T}},
             }
             a = rand(T, 1, N)
             @inferred UnionType Qobj(a)
@@ -377,8 +377,8 @@
             end
 
             UnionType2 = Union{
-                QuantumObject{Operator,GeneralProductDimensions{1,1,Tuple{Space},Tuple{Space}},Matrix{T}},
-                QuantumObject{Operator,ProductDimensions{1,Tuple{Space}},Matrix{T}},
+                QuantumObject{Operator,GeneralProductDimensions{1,1,Tuple{HilbertSpace},Tuple{HilbertSpace}},Matrix{T}},
+                QuantumObject{Operator,ProductDimensions{1,Tuple{HilbertSpace}},Matrix{T}},
             }
             a = rand(T, N, N)
             @inferred UnionType Qobj(a)