Merge branch 'main' into lb/add_tutorial

Author: leburgel

.github/workflows/CompatCheck.yml

@@ -25,7 +25,7 @@ jobs:
         # https://github.com/julia-actions/julia-downgrade-compat/issues/25
         julia-version: ['1.10', '1.12']
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: julia-actions/setup-julia@v2
         with:
           version: ${{ matrix.julia-version }}

.github/workflows/Documentation.yml

@@ -20,7 +20,7 @@ jobs:
         os:
           - ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: julia-actions/setup-julia@latest
         with:
           version: ${{ matrix.version }}

.github/workflows/DocumentationCleanup.yml

@@ -16,7 +16,7 @@ jobs:
       contents: write
     steps:
       - name: Checkout gh-pages branch
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
         with:
           ref: gh-pages
       - name: Delete preview and history + push changes

Project.toml

@@ -35,7 +35,7 @@ Combinatorics = "1"
 FiniteDifferences = "0.12"
 LRUCache = "1.0.2"
 LinearAlgebra = "1"
-MatrixAlgebraKit = "0.5.0"
+MatrixAlgebraKit = "0.6.0"
 OhMyThreads = "0.8.0"
 PackageExtensionCompat = "1"
 Printf = "1"

docs/src/lib/spaces.md

@@ -123,7 +123,7 @@ the resuling `HomSpace` after applying certain tensor operations.
 
 ```@docs
 flip(W::HomSpace{S}, I) where {S}
-TensorKit.permute(::HomSpace{S}, ::Index2Tuple{N₁,N₂}) where {S,N₁,N₂}
+TensorKit.permute(::HomSpace, ::Index2Tuple)
 TensorKit.select(::HomSpace{S}, ::Index2Tuple{N₁,N₂}) where {S,N₁,N₂}
 TensorKit.compose(::HomSpace{S}, ::HomSpace{S}) where {S}
 insertleftunit(::HomSpace, ::Val{i}) where {i}

ext/TensorKitChainRulesCoreExt/linalg.jl

@@ -69,6 +69,16 @@ function ChainRulesCore.rrule(
     return permute(tsrc, p; copy = true), permute_pullback
 end
 
+function ChainRulesCore.rrule(
+        ::typeof(transpose), tsrc::AbstractTensorMap, p::Index2Tuple; copy::Bool = false
+    )
+    function transpose_pullback(Δtdst)
+        invp = TensorKit._canonicalize(TupleTools.invperm(linearize(p)), tsrc)
+        return NoTangent(), transpose(unthunk(Δtdst), invp; copy = true), NoTangent()
+    end
+    return transpose(tsrc, p; copy = true), transpose_pullback
+end
+
 function ChainRulesCore.rrule(::typeof(tr), A::AbstractTensorMap)
     tr_pullback(Δtr) = NoTangent(), Δtr * id(domain(A))
     return tr(A), tr_pullback

src/TensorKit.jl

@@ -79,10 +79,12 @@ export left_orth, right_orth, left_null, right_null,
     qr_full!, qr_compact!, qr_null!, lq_full!, lq_compact!, lq_null!,
     svd_compact!, svd_full!, svd_trunc!, svd_compact, svd_full, svd_trunc,
     exp, exp!,
-    eigh_full!, eigh_full, eigh_trunc!, eigh_trunc, eig_full!, eig_full, eig_trunc!,
-    eig_trunc,
-    eigh_vals!, eigh_vals, eig_vals!, eig_vals,
-    isposdef, isposdef!, ishermitian, isisometry, isunitary, sylvester, rank, cond
+    eigh_full!, eigh_full, eigh_trunc!, eigh_trunc, eigh_vals!, eigh_vals,
+    eig_full!, eig_full, eig_trunc!, eig_trunc, eig_vals!, eig_vals,
+    ishermitian, project_hermitian, project_hermitian!,
+    isantihermitian, project_antihermitian, project_antihermitian!,
+    isisometric, isunitary, project_isometric, project_isometric!,
+    isposdef, isposdef!, sylvester, rank, cond
 
 export braid, braid!, permute, permute!, transpose, transpose!, twist, twist!, repartition,
     repartition!
@@ -135,7 +137,7 @@ using LinearAlgebra: norm, dot, normalize, normalize!, tr,
     adjoint, adjoint!, transpose, transpose!,
     lu, pinv, sylvester,
     eigen, eigen!, svd, svd!,
-    isposdef, isposdef!, ishermitian, rank, cond,
+    isposdef, isposdef!, rank, cond,
     Diagonal, Hermitian
 using MatrixAlgebraKit
 
@@ -176,8 +178,11 @@ struct SpaceMismatch{S <: Union{Nothing, AbstractString}} <: TensorException
     message::S
 end
 SpaceMismatch() = SpaceMismatch{Nothing}(nothing)
-Base.showerror(io::IO, ::SpaceMismatch{Nothing}) = print(io, "SpaceMismatch()")
-Base.showerror(io::IO, e::SpaceMismatch) = print(io, "SpaceMismatch(\"", e.message, "\")")
+function Base.showerror(io::IO, err::SpaceMismatch)
+    print(io, "SpaceMismatch: ")
+    isnothing(err.message) || print(io, err.message)
+    return nothing
+end
 
 # Exception type for all errors related to invalid tensor index specification.
 struct IndexError{S <: Union{Nothing, AbstractString}} <: TensorException

src/auxiliary/deprecate.jl

@@ -186,7 +186,7 @@ function tsvd(t::AbstractTensorMap; kwargs...)
         Base.depwarn("p is a deprecated kwarg, and should be specified through the truncation strategy", :tsvd)
         kwargs = _drop_p(; kwargs...)
     end
-    return haskey(kwargs, :trunc) ? svd_trunc(t; kwargs...) : svd_compact(t; kwargs...)
+    return haskey(kwargs, :trunc) ? svd_trunc(t; kwargs...) : (svd_compact(t; kwargs...)..., abs(zero(scalartype(t))))
 end
 function tsvd!(t::AbstractTensorMap; kwargs...)
     Base.depwarn("`tsvd!` is deprecated, use `svd_compact!`, `svd_full!` or `svd_trunc!` instead", :tsvd!)

src/factorizations/adjoint.jl

@@ -6,46 +6,54 @@ _adjoint(alg::MAK.LAPACK_HouseholderQR) = MAK.LAPACK_HouseholderLQ(; alg.kwargs.
 _adjoint(alg::MAK.LAPACK_HouseholderLQ) = MAK.LAPACK_HouseholderQR(; alg.kwargs...)
 _adjoint(alg::MAK.LAPACK_HouseholderQL) = MAK.LAPACK_HouseholderRQ(; alg.kwargs...)
 _adjoint(alg::MAK.LAPACK_HouseholderRQ) = MAK.LAPACK_HouseholderQL(; alg.kwargs...)
-_adjoint(alg::MAK.PolarViaSVD) = MAK.PolarViaSVD(_adjoint(alg.svdalg))
+_adjoint(alg::MAK.PolarViaSVD) = MAK.PolarViaSVD(_adjoint(alg.svd_alg))
 _adjoint(alg::AbstractAlgorithm) = alg
 
-# 1-arg functions
-function MAK.initialize_output(::typeof(left_null!), t::AdjointTensorMap, alg::AbstractAlgorithm)
-    return adjoint(MAK.initialize_output(right_null!, adjoint(t), _adjoint(alg)))
-end
-function MAK.initialize_output(
-        ::typeof(right_null!), t::AdjointTensorMap,
-        alg::AbstractAlgorithm
-    )
-    return adjoint(MAK.initialize_output(left_null!, adjoint(t), _adjoint(alg)))
+for f in
+    [
+        :svd_compact, :svd_full, :svd_vals,
+        :qr_compact, :qr_full, :qr_null,
+        :lq_compact, :lq_full, :lq_null,
+        :eig_full, :eig_vals, :eigh_full, :eigh_trunc, :eigh_vals,
+        :left_polar, :right_polar,
+        :project_hermitian, :project_antihermitian, :project_isometric,
+    ]
+    f! = Symbol(f, :!)
+    # just return the algorithm for the parent type since we are mapping this with
+    # `_adjoint` afterwards anyways.
+    # TODO: properly handle these cases
+    @eval MAK.default_algorithm(::typeof($f!), ::Type{T}; kwargs...) where {T <: AdjointTensorMap} =
+        MAK.default_algorithm($f!, TensorKit.parenttype(T); kwargs...)
 end
 
-function MAK.left_null!(t::AdjointTensorMap, N, alg::AbstractAlgorithm)
-    right_null!(adjoint(t), adjoint(N), _adjoint(alg))
-    return N
-end
-function MAK.right_null!(t::AdjointTensorMap, N, alg::AbstractAlgorithm)
-    left_null!(adjoint(t), adjoint(N), _adjoint(alg))
-    return N
-end
+# 1-arg functions
+MAK.initialize_output(::typeof(qr_null!), t::AdjointTensorMap, alg::AbstractAlgorithm) =
+    adjoint(MAK.initialize_output(lq_null!, adjoint(t), _adjoint(alg)))
+MAK.initialize_output(::typeof(lq_null!), t::AdjointTensorMap, alg::AbstractAlgorithm) =
+    adjoint(MAK.initialize_output(qr_null!, adjoint(t), _adjoint(alg)))
 
-function MAK.is_left_isometry(t::AdjointTensorMap; kwargs...)
-    return is_right_isometry(adjoint(t); kwargs...)
-end
-function MAK.is_right_isometry(t::AdjointTensorMap; kwargs...)
-    return is_left_isometry(adjoint(t); kwargs...)
-end
+MAK.qr_null!(t::AdjointTensorMap, N, alg::AbstractAlgorithm) =
+    lq_null!(adjoint(t), adjoint(N), _adjoint(alg))
+MAK.lq_null!(t::AdjointTensorMap, N, alg::AbstractAlgorithm) =
+    qr_null!(adjoint(t), adjoint(N), _adjoint(alg))
+
+MAK.is_left_isometric(t::AdjointTensorMap; kwargs...) =
+    MAK.is_right_isometric(adjoint(t); kwargs...)
+MAK.is_right_isometric(t::AdjointTensorMap; kwargs...) =
+    MAK.is_left_isometric(adjoint(t); kwargs...)
 
 # 2-arg functions
-for (left_f!, right_f!) in zip(
-        (:qr_full!, :qr_compact!, :left_polar!, :left_orth!),
-        (:lq_full!, :lq_compact!, :right_polar!, :right_orth!)
+for (left_f, right_f) in zip(
+        (:qr_full, :qr_compact, :left_polar),
+        (:lq_full, :lq_compact, :right_polar)
     )
-    @eval function MAK.copy_input(::typeof($left_f!), t::AdjointTensorMap)
-        return adjoint(MAK.copy_input($right_f!, adjoint(t)))
+    left_f! = Symbol(left_f, :!)
+    right_f! = Symbol(right_f, :!)
+    @eval function MAK.copy_input(::typeof($left_f), t::AdjointTensorMap)
+        return adjoint(MAK.copy_input($right_f, adjoint(t)))
     end
-    @eval function MAK.copy_input(::typeof($right_f!), t::AdjointTensorMap)
-        return adjoint(MAK.copy_input($left_f!, adjoint(t)))
+    @eval function MAK.copy_input(::typeof($right_f), t::AdjointTensorMap)
+        return adjoint(MAK.copy_input($left_f, adjoint(t)))
     end
 
     @eval function MAK.initialize_output(
@@ -60,29 +68,31 @@ for (left_f!, right_f!) in zip(
     end
 
     @eval function MAK.$left_f!(t::AdjointTensorMap, F, alg::AbstractAlgorithm)
-        $right_f!(adjoint(t), reverse(adjoint.(F)), _adjoint(alg))
-        return F
+        F′ = $right_f!(adjoint(t), reverse(adjoint.(F)), _adjoint(alg))
+        return reverse(adjoint.(F′))
     end
     @eval function MAK.$right_f!(t::AdjointTensorMap, F, alg::AbstractAlgorithm)
-        $left_f!(adjoint(t), reverse(adjoint.(F)), _adjoint(alg))
-        return F
+        F′ = $left_f!(adjoint(t), reverse(adjoint.(F)), _adjoint(alg))
+        return reverse(adjoint.(F′))
     end
 end
 
 # 3-arg functions
-for f! in (:svd_full!, :svd_compact!, :svd_trunc!)
-    @eval function MAK.copy_input(::typeof($f!), t::AdjointTensorMap)
-        return adjoint(MAK.copy_input($f!, adjoint(t)))
+for f in (:svd_full, :svd_compact)
+    f! = Symbol(f, :!)
+    @eval function MAK.copy_input(::typeof($f), t::AdjointTensorMap)
+        return adjoint(MAK.copy_input($f, adjoint(t)))
     end
 
     @eval function MAK.initialize_output(
             ::typeof($f!), t::AdjointTensorMap, alg::AbstractAlgorithm
         )
         return reverse(adjoint.(MAK.initialize_output($f!, adjoint(t), _adjoint(alg))))
     end
+
     @eval function MAK.$f!(t::AdjointTensorMap, F, alg::AbstractAlgorithm)
-        $f!(adjoint(t), reverse(adjoint.(F)), _adjoint(alg))
-        return F
+        F′ = $f!(adjoint(t), reverse(adjoint.(F)), _adjoint(alg))
+        return reverse(adjoint.(F′))
     end
 
     # disambiguate by prohibition
@@ -92,17 +102,9 @@ for f! in (:svd_full!, :svd_compact!, :svd_trunc!)
         throw(MethodError($f!, (t, alg)))
     end
 end
+
 # avoid amgiguity
-function MAK.initialize_output(
-        ::typeof(svd_trunc!), t::AdjointTensorMap, alg::TruncatedAlgorithm
-    )
-    return MAK.initialize_output(svd_compact!, t, alg.alg)
-end
-# to fix ambiguity
-function MAK.svd_trunc!(t::AdjointTensorMap, USVᴴ, alg::TruncatedAlgorithm)
-    USVᴴ′ = svd_compact!(t, USVᴴ, alg.alg)
-    return MAK.truncate(svd_trunc!, USVᴴ′, alg.trunc)
-end
-function MAK.svd_compact!(t::AdjointTensorMap, USVᴴ, alg::DiagonalAlgorithm)
-    return MAK.svd_compact!(t, USVᴴ, alg.alg)
+function MAK.svd_compact!(t::AdjointTensorMap, F, alg::DiagonalAlgorithm)
+    F′ = svd_compact!(adjoint(t), reverse(adjoint.(F)), _adjoint(alg))
+    return reverse(adjoint.(F′))
 end

src/factorizations/diagonal.jl

@@ -81,55 +81,20 @@ for f! in
         :eigh_trunc!, :right_orth!, :left_orth!,
     )
     @eval function MAK.$f!(d::DiagonalTensorMap, F, alg::DiagonalAlgorithm)
-        MAK.check_input($f!, d, F, alg)
         $f!(_repack_diagonal(d), _repack_diagonal.(F), alg)
         return F
     end
 end
 
-for f! in (:qr_full!, :qr_compact!)
-    @eval function MAK.check_input(
-            ::typeof($f!), d::AbstractTensorMap, QR, ::DiagonalAlgorithm
-        )
-        Q, R = QR
-        @assert d isa DiagonalTensorMap
-        @assert Q isa DiagonalTensorMap && R isa DiagonalTensorMap
-        @check_scalar Q d
-        @check_scalar R d
-        @check_space(Q, space(d))
-        @check_space(R, space(d))
-
-        return nothing
-    end
-end
-
-for f! in (:lq_full!, :lq_compact!)
-    @eval function MAK.check_input(
-            ::typeof($f!), d::AbstractTensorMap, LQ, ::DiagonalAlgorithm
-        )
-        L, Q = LQ
-        @assert d isa DiagonalTensorMap
-        @assert Q isa DiagonalTensorMap && L isa DiagonalTensorMap
-        @check_scalar Q d
-        @check_scalar L d
-        @check_space(Q, space(d))
-        @check_space(L, space(d))
-
-        return nothing
-    end
-end
-
 # disambiguate
 function MAK.svd_compact!(t::AbstractTensorMap, USVᴴ, alg::DiagonalAlgorithm)
     return svd_full!(t, USVᴴ, alg)
 end
 
 # f_vals
 # ------
-
 for f! in (:eig_vals!, :eigh_vals!, :svd_vals!)
     @eval function MAK.$f!(d::AbstractTensorMap, V, alg::DiagonalAlgorithm)
-        MAK.check_input($f!, d, V, alg)
         $f!(_repack_diagonal(d), diagview(_repack_diagonal(V)), alg)
         return V
     end
@@ -140,64 +105,3 @@ for f! in (:eig_vals!, :eigh_vals!, :svd_vals!)
         return DiagonalTensorMap(data, d.domain)
     end
 end
-
-function MAK.check_input(::typeof(eig_full!), t::AbstractTensorMap, DV, ::DiagonalAlgorithm)
-    domain(t) == codomain(t) ||
-        throw(ArgumentError("Eigenvalue decomposition requires square input tensor"))
-
-    D, V = DV
-
-    @assert D isa DiagonalTensorMap
-    @assert V isa AbstractTensorMap
-
-    # scalartype checks
-    @check_scalar D t
-    @check_scalar V t
-
-    # space checks
-    @check_space D space(t)
-    @check_space V space(t)
-
-    return nothing
-end
-
-function MAK.check_input(::typeof(eigh_full!), t::AbstractTensorMap, DV, ::DiagonalAlgorithm)
-    domain(t) == codomain(t) ||
-        throw(ArgumentError("Eigenvalue decomposition requires square input tensor"))
-
-    D, V = DV
-
-    @assert D isa DiagonalTensorMap
-    @assert V isa AbstractTensorMap
-
-    # scalartype checks
-    @check_scalar D t real
-    @check_scalar V t
-
-    # space checks
-    @check_space D space(t)
-    @check_space V space(t)
-
-    return nothing
-end
-
-function MAK.check_input(::typeof(eig_vals!), t::AbstractTensorMap, D, ::DiagonalAlgorithm)
-    @assert D isa DiagonalTensorMap
-    @check_scalar D t
-    @check_space D space(t)
-    return nothing
-end
-
-function MAK.check_input(::typeof(eigh_vals!), t::AbstractTensorMap, D, ::DiagonalAlgorithm)
-    @assert D isa DiagonalTensorMap
-    @check_scalar D t real
-    @check_space D space(t)
-    return nothing
-end
-
-function MAK.check_input(::typeof(svd_vals!), t::AbstractTensorMap, D, ::DiagonalAlgorithm)
-    @assert D isa DiagonalTensorMap
-    @check_scalar D t real
-    @check_space D space(t)
-    return nothing
-end