some cleanup for v0.14

Author: Jutho

Changelog.md

@@ -17,6 +17,23 @@ Features that are planned to be implemented before the release of v1.0.0, in no
 
 ## v0.14
 
+### Use `DiagonalTensorMap` for singular values and eigenvalues
+
+The diagonal (1,1) tensor that contains the singular values or eigenvalues of a tensor
+are now explicitly represented as `DiagonalTensorMap` instances.
+
+### New index functionality
+There are is new functionality for manipulating the spaces associated with a tensor:
+* `flip(t, i)` changes the duality flag of the `i`th index of `t`, in such a way that flipping
+  a pair of contracted indices in an `@tensor` contraction does not affect the result.
+* `insertleftunit(t, i)` and `insertrightunit(t, i)` insert a trivial unit space to the left
+  or to right of index `i`, whereas `removeunit(t, i)` removes such a trivial unit space.
+
+### SVD truncation change (breaking)
+There is a subtle but breaking change in the truncation mechanism in SVD, where now it is
+guaranteed that smaller singular values are removed first, irrespective of the (quantum)
+dimension of the sector to which they belong
+
 ### `DiagonalTensorMap` and `reduceddim`
 
 This adds a `DiagonalTensorMap` type for representing tensor maps in which all of the

docs/src/lib/spaces.md

@@ -113,6 +113,7 @@ There are also specific methods for `HomSpace` instances, that are used in deter
 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.select(::HomSpace{S}, ::Index2Tuple{N₁,N₂}) where {S,N₁,N₂}
 TensorKit.compose(::HomSpace{S}, ::HomSpace{S}) where {S}

docs/src/lib/tensors.md

@@ -174,6 +174,7 @@ permute(::AbstractTensorMap, ::Index2Tuple{N₁,N₂}; ::Bool) where {N₁,N₂}
 braid(::AbstractTensorMap, ::Index2Tuple, ::IndexTuple; ::Bool)
 transpose(::AbstractTensorMap, ::Index2Tuple; ::Bool)
 repartition(::AbstractTensorMap, ::Int, ::Int; ::Bool)
+flip(t::AbstractTensorMap, I)
 twist(::AbstractTensorMap, ::Int; ::Bool)
 ```
 

src/tensors/vectorinterface.jl

@@ -102,8 +102,25 @@ function VectorInterface.inner(tx::AbstractTensorMap, ty::AbstractTensorMap)
     InnerProductStyle(tx) === EuclideanInnerProduct() || throw_invalid_innerproduct(:inner)
     T = VectorInterface.promote_inner(tx, ty)
     s = zero(T)
-    for c in blocksectors(tx)
-        s += convert(T, dim(c)) * inner(block(tx, c), block(ty, c))
+    for ((cx, bx), (cy, by)) in zip(blocks(tx), blocks(ty))
+        s += convert(T, dim(cx)) * inner(bx, by)
     end
     return s
 end
+function VectorInterface.inner(tx::TensorMap, ty::TensorMap)
+    space(tx) == space(ty) || throw(SpaceMismatch("$(space(tx)) ≠ $(space(ty))"))
+    InnerProductStyle(tx) === EuclideanInnerProduct() || throw_invalid_innerproduct(:inner)
+    if FusionStyle(sectortype(tx)) isa UniqueFusion # all quantum dimensions are one
+        return inner(tx.data, ty.data)
+    else
+        T = VectorInterface.promote_inner(tx, ty)
+        s = zero(T)
+        for c in blocksectors(tx)
+            bx = parent(block(tx, c)) # matrix structure (reshape) does not matter
+            by = parent(block(ty, c)) # but does lead to slower path in inner
+            s += convert(T, dim(c)) * inner(bx, by)
+        end
+    end
+    return s
+end
+# TODO: do we need a fast path for `AdjointTensorMap` instances?