--- a/test/LazyTensors/lazy_tensor_operations_test.jl	Fri Mar 18 20:44:17 2022 +0100
+++ b/test/LazyTensors/lazy_tensor_operations_test.jl	Fri Mar 18 21:14:47 2022 +0100
@@ -5,7 +5,7 @@
 using Tullio
 
 @testset "Mapping transpose" begin
-    struct DummyMapping{T,R,D} <: TensorMapping{T,R,D} end
+    struct DummyMapping{T,R,D} <: LazyTensor{T,R,D} end
 
     LazyTensors.apply(m::DummyMapping{T,R}, v, I::Vararg{Any,R}) where {T,R} = :apply
     LazyTensors.apply_transpose(m::DummyMapping{T,R,D}, v, I::Vararg{Any,D}) where {T,R,D} = :apply_transpose
@@ -14,7 +14,7 @@
     LazyTensors.domain_size(m::DummyMapping) = :domain_size
 
     m = DummyMapping{Float64,2,3}()
-    @test m' isa TensorMapping{Float64, 3,2}
+    @test m' isa LazyTensor{Float64, 3,2}
     @test m'' == m
     @test apply(m',zeros(Float64,(0,0)), 0, 0, 0) == :apply_transpose
     @test apply(m'',zeros(Float64,(0,0,0)), 0, 0) == :apply
@@ -25,7 +25,7 @@
 end
 
 @testset "TensorApplication" begin
-    struct SizeDoublingMapping{T,R,D} <: TensorMapping{T,R,D}
+    struct SizeDoublingMapping{T,R,D} <: LazyTensor{T,R,D}
         domain_size::NTuple{D,Int}
     end
 
@@ -108,7 +108,7 @@
     end
 end
 
-@testset "TensorMapping binary operations" begin
+@testset "LazyTensor binary operations" begin
     A = ScalingTensor(2.0, (3,))
     B = ScalingTensor(3.0, (3,))
 
@@ -131,14 +131,14 @@
 end
 
 
-@testset "TensorMappingComposition" begin
+@testset "LazyTensorComposition" begin
     A = rand(2,3)
     B = rand(3,4)
 
     Ã = LazyLinearMap(A, (1,), (2,))
     B̃ = LazyLinearMap(B, (1,), (2,))
 
-    @test Ã∘B̃ isa TensorMappingComposition
+    @test Ã∘B̃ isa LazyTensorComposition
     @test range_size(Ã∘B̃) == (2,)
     @test domain_size(Ã∘B̃) == (4,)
     @test_throws SizeMismatch B̃∘Ã
@@ -164,7 +164,7 @@
     w = rand(3)
 
     @test à isa LazyLinearMap{T,1,1} where T
-    @test à isa TensorMapping{T,1,1} where T
+    @test à isa LazyTensor{T,1,1} where T
     @test range_size(Ã) == (3,)
     @test domain_size(Ã) == (4,)
 
@@ -183,7 +183,7 @@
 
     @test range_size(B̃) == (3,4)
     @test domain_size(B̃) == (2,)
-    @test B̃ isa TensorMapping{T,2,1} where T
+    @test B̃ isa LazyTensor{T,2,1} where T
     @test B̃*ones(2) ≈ B[:,:,1] + B[:,:,2] atol=5e-13
     @test B̃*v ≈ B[:,:,1]*v[1] + B[:,:,2]*v[2] atol=5e-13
 
@@ -193,7 +193,7 @@
 
     @test range_size(B̃) == (4,)
     @test domain_size(B̃) == (3,2)
-    @test B̃ isa TensorMapping{T,1,2} where T
+    @test B̃ isa LazyTensor{T,1,2} where T
     @test B̃*ones(3,2) ≈ B[1,:,1] + B[2,:,1] + B[3,:,1] +
                         B[1,:,2] + B[2,:,2] + B[3,:,2] atol=5e-13
     @test B̃*v ≈ B[1,:,1]*v[1,1] + B[2,:,1]*v[2,1] + B[3,:,1]*v[3,1] +
@@ -205,15 +205,15 @@
 end
 
 
-@testset "IdentityMapping" begin
-    @test IdentityMapping{Float64}((4,5)) isa IdentityMapping{T,2} where T
-    @test IdentityMapping{Float64}((4,5)) isa TensorMapping{T,2,2} where T
-    @test IdentityMapping{Float64}((4,5)) == IdentityMapping{Float64}(4,5)
+@testset "IdentityTensor" begin
+    @test IdentityTensor{Float64}((4,5)) isa IdentityTensor{T,2} where T
+    @test IdentityTensor{Float64}((4,5)) isa LazyTensor{T,2,2} where T
+    @test IdentityTensor{Float64}((4,5)) == IdentityTensor{Float64}(4,5)
 
-    @test IdentityMapping(3,2) isa IdentityMapping{Float64,2}
+    @test IdentityTensor(3,2) isa IdentityTensor{Float64,2}
 
     for sz ∈ [(4,5),(3,),(5,6,4)]
-        I = IdentityMapping{Float64}(sz)
+        I = IdentityTensor{Float64}(sz)
         v = rand(sz...)
         @test I*v == v
         @test I'*v == v
@@ -226,7 +226,7 @@
         @test domain_size(I) == sz
     end
 
-    I = IdentityMapping{Float64}((4,5))
+    I = IdentityTensor{Float64}((4,5))
     v = rand(4,5)
     @inferred (I*v)[3,2]
     @inferred (I'*v)[3,2]
@@ -237,8 +237,8 @@
 
     Ã = rand(4,2)
     A = LazyLinearMap(Ã,(1,),(2,))
-    I1 = IdentityMapping{Float64}(2)
-    I2 = IdentityMapping{Float64}(4)
+    I1 = IdentityTensor{Float64}(2)
+    I2 = IdentityTensor{Float64}(4)
     @test A∘I1 == A
     @test I2∘A == A
     @test I1∘I1 == I1
@@ -249,7 +249,7 @@
 
 @testset "ScalingTensor" begin
     st = ScalingTensor(2.,(3,4))
-    @test st isa TensorMapping{Float64, 2, 2}
+    @test st isa LazyTensor{Float64, 2, 2}
     @test range_size(st) == (3,4)
     @test domain_size(st) == (3,4)
 
@@ -261,8 +261,8 @@
     @inferred (st'*v)[2,2]
 end
 
-@testset "InflatedTensorMapping" begin
-    I(sz...) = IdentityMapping(sz...)
+@testset "InflatedLazyTensor" begin
+    I(sz...) = IdentityTensor(sz...)
 
     Ã = rand(4,2)
     B̃ = rand(4,2,3)
@@ -273,26 +273,26 @@
     C = LazyLinearMap(C̃,(1,),(2,3))
 
     @testset "Constructors" begin
-        @test InflatedTensorMapping(I(3,2), A, I(4)) isa TensorMapping{Float64, 4, 4}
-        @test InflatedTensorMapping(I(3,2), B, I(4)) isa TensorMapping{Float64, 5, 4}
-        @test InflatedTensorMapping(I(3), C, I(2,3)) isa TensorMapping{Float64, 4, 5}
-        @test InflatedTensorMapping(C, I(2,3)) isa TensorMapping{Float64, 3, 4}
-        @test InflatedTensorMapping(I(3), C) isa TensorMapping{Float64, 2, 3}
-        @test InflatedTensorMapping(I(3), I(2,3)) isa TensorMapping{Float64, 3, 3}
+        @test InflatedLazyTensor(I(3,2), A, I(4)) isa LazyTensor{Float64, 4, 4}
+        @test InflatedLazyTensor(I(3,2), B, I(4)) isa LazyTensor{Float64, 5, 4}
+        @test InflatedLazyTensor(I(3), C, I(2,3)) isa LazyTensor{Float64, 4, 5}
+        @test InflatedLazyTensor(C, I(2,3)) isa LazyTensor{Float64, 3, 4}
+        @test InflatedLazyTensor(I(3), C) isa LazyTensor{Float64, 2, 3}
+        @test InflatedLazyTensor(I(3), I(2,3)) isa LazyTensor{Float64, 3, 3}
     end
 
     @testset "Range and domain size" begin
-        @test range_size(InflatedTensorMapping(I(3,2), A, I(4))) == (3,2,4,4)
-        @test domain_size(InflatedTensorMapping(I(3,2), A, I(4))) == (3,2,2,4)
+        @test range_size(InflatedLazyTensor(I(3,2), A, I(4))) == (3,2,4,4)
+        @test domain_size(InflatedLazyTensor(I(3,2), A, I(4))) == (3,2,2,4)
 
-        @test range_size(InflatedTensorMapping(I(3,2), B, I(4))) == (3,2,4,2,4)
-        @test domain_size(InflatedTensorMapping(I(3,2), B, I(4))) == (3,2,3,4)
+        @test range_size(InflatedLazyTensor(I(3,2), B, I(4))) == (3,2,4,2,4)
+        @test domain_size(InflatedLazyTensor(I(3,2), B, I(4))) == (3,2,3,4)
 
-        @test range_size(InflatedTensorMapping(I(3), C, I(2,3))) == (3,4,2,3)
-        @test domain_size(InflatedTensorMapping(I(3), C, I(2,3))) == (3,2,3,2,3)
+        @test range_size(InflatedLazyTensor(I(3), C, I(2,3))) == (3,4,2,3)
+        @test domain_size(InflatedLazyTensor(I(3), C, I(2,3))) == (3,2,3,2,3)
 
-        @inferred range_size(InflatedTensorMapping(I(3,2), A, I(4))) == (3,2,4,4)
-        @inferred domain_size(InflatedTensorMapping(I(3,2), A, I(4))) == (3,2,2,4)
+        @inferred range_size(InflatedLazyTensor(I(3,2), A, I(4))) == (3,2,4,4)
+        @inferred domain_size(InflatedLazyTensor(I(3,2), A, I(4))) == (3,2,2,4)
     end
 
     @testset "Application" begin
@@ -300,47 +300,47 @@
         # The inflated tensor mappings are chosen to preserve, reduce and increase the dimension of the result compared to the input.
         tests = [
             (
-                InflatedTensorMapping(I(3,2), A, I(4)),
+                InflatedLazyTensor(I(3,2), A, I(4)),
                 (v-> @tullio res[a,b,c,d] := Ã[c,i]*v[a,b,i,d]), # Expected result of apply
                 (v-> @tullio res[a,b,c,d] := Ã[i,c]*v[a,b,i,d]), # Expected result of apply_transpose
             ),
             (
-                InflatedTensorMapping(I(3,2), B, I(4)),
+                InflatedLazyTensor(I(3,2), B, I(4)),
                 (v-> @tullio res[a,b,c,d,e] := B̃[c,d,i]*v[a,b,i,e]),
                 (v-> @tullio res[a,b,c,d] := B̃[i,j,c]*v[a,b,i,j,d]),
             ),
             (
-                InflatedTensorMapping(I(3,2), C, I(4)),
+                InflatedLazyTensor(I(3,2), C, I(4)),
                 (v-> @tullio res[a,b,c,d] := C̃[c,i,j]*v[a,b,i,j,d]),
                 (v-> @tullio res[a,b,c,d,e] := C̃[i,c,d]*v[a,b,i,e]),
             ),
             (
-                InflatedTensorMapping(I(3,2), A),
+                InflatedLazyTensor(I(3,2), A),
                 (v-> @tullio res[a,b,c] := Ã[c,i]*v[a,b,i]),
                 (v-> @tullio res[a,b,c] := Ã[i,c]*v[a,b,i]),
             ),
             (
-                InflatedTensorMapping(I(3,2), B),
+                InflatedLazyTensor(I(3,2), B),
                 (v-> @tullio res[a,b,c,d] := B̃[c,d,i]*v[a,b,i]),
                 (v-> @tullio res[a,b,c] := B̃[i,j,c]*v[a,b,i,j]),
             ),
             (
-                InflatedTensorMapping(I(3,2), C),
+                InflatedLazyTensor(I(3,2), C),
                 (v-> @tullio res[a,b,c] := C̃[c,i,j]*v[a,b,i,j]),
                 (v-> @tullio res[a,b,c,d] := C̃[i,c,d]*v[a,b,i]),
             ),
             (
-                InflatedTensorMapping(A,I(4)),
+                InflatedLazyTensor(A,I(4)),
                 (v-> @tullio res[a,b] := Ã[a,i]*v[i,b]),
                 (v-> @tullio res[a,b] := Ã[i,a]*v[i,b]),
             ),
             (
-                InflatedTensorMapping(B,I(4)),
+                InflatedLazyTensor(B,I(4)),
                 (v-> @tullio res[a,b,c] := B̃[a,b,i]*v[i,c]),
                 (v-> @tullio res[a,b] := B̃[i,j,a]*v[i,j,b]),
             ),
             (
-                InflatedTensorMapping(C,I(4)),
+                InflatedLazyTensor(C,I(4)),
                 (v-> @tullio res[a,b] := C̃[a,i,j]*v[i,j,b]),
                 (v-> @tullio res[a,b,c] := C̃[i,a,b]*v[i,c]),
             ),
@@ -365,7 +365,7 @@
         end
 
         @testset "application to other type" begin
-            tm = InflatedTensorMapping(I(3,2), A, I(4))
+            tm = InflatedLazyTensor(I(3,2), A, I(4))
 
             v = rand(ComplexF64, domain_size(tm)...)
             @test (tm*v)[1,2,3,1] isa ComplexF64
@@ -375,7 +375,7 @@
         end
 
         @testset "Inference of application" begin
-            tm = InflatedTensorMapping(I(2,3),ScalingTensor(2.0, (3,2)),I(3,4))
+            tm = InflatedLazyTensor(I(2,3),ScalingTensor(2.0, (3,2)),I(3,4))
             v = rand(domain_size(tm)...)
 
             @inferred apply(tm,v,1,2,3,2,2,4)
@@ -383,14 +383,14 @@
         end
     end
 
-    @testset "InflatedTensorMapping of InflatedTensorMapping" begin
+    @testset "InflatedLazyTensor of InflatedLazyTensor" begin
         A = ScalingTensor(2.0,(2,3))
-        itm = InflatedTensorMapping(I(3,2), A, I(4))
-        @test  InflatedTensorMapping(I(4), itm, I(2)) == InflatedTensorMapping(I(4,3,2), A, I(4,2))
-        @test  InflatedTensorMapping(itm, I(2)) == InflatedTensorMapping(I(3,2), A, I(4,2))
-        @test  InflatedTensorMapping(I(4), itm) == InflatedTensorMapping(I(4,3,2), A, I(4))
+        itm = InflatedLazyTensor(I(3,2), A, I(4))
+        @test  InflatedLazyTensor(I(4), itm, I(2)) == InflatedLazyTensor(I(4,3,2), A, I(4,2))
+        @test  InflatedLazyTensor(itm, I(2)) == InflatedLazyTensor(I(3,2), A, I(4,2))
+        @test  InflatedLazyTensor(I(4), itm) == InflatedLazyTensor(I(4,3,2), A, I(4))
 
-        @test InflatedTensorMapping(I(2), I(2), I(2)) isa InflatedTensorMapping # The constructor should always return its type.
+        @test InflatedLazyTensor(I(2), I(2), I(2)) isa InflatedLazyTensor # The constructor should always return its type.
     end
 end
 
@@ -462,7 +462,7 @@
     C = ScalingTensor(5.0, (3,2))
 
     AB = LazyOuterProduct(A,B)
-    @test AB isa TensorMapping{T,2,2} where T
+    @test AB isa LazyTensor{T,2,2} where T
     @test range_size(AB) == (5,3)
     @test domain_size(AB) == (5,3)
 
@@ -471,7 +471,7 @@
 
     ABC = LazyOuterProduct(A,B,C)
 
-    @test ABC isa TensorMapping{T,4,4} where T
+    @test ABC isa LazyTensor{T,4,4} where T
     @test range_size(ABC) == (5,3,3,2)
     @test domain_size(ABC) == (5,3,3,2)
 
@@ -496,15 +496,15 @@
     @test B̃Ã*v₂ ≈ BAv
 
     @testset "Indentity mapping arguments" begin
-        @test LazyOuterProduct(IdentityMapping(3,2), IdentityMapping(1,2)) == IdentityMapping(3,2,1,2)
+        @test LazyOuterProduct(IdentityTensor(3,2), IdentityTensor(1,2)) == IdentityTensor(3,2,1,2)
 
         Ã = LazyLinearMap(A,(1,),(2,))
-        @test LazyOuterProduct(IdentityMapping(3,2), Ã) == InflatedTensorMapping(IdentityMapping(3,2),Ã)
-        @test LazyOuterProduct(Ã, IdentityMapping(3,2)) == InflatedTensorMapping(Ã,IdentityMapping(3,2))
+        @test LazyOuterProduct(IdentityTensor(3,2), Ã) == InflatedLazyTensor(IdentityTensor(3,2),Ã)
+        @test LazyOuterProduct(Ã, IdentityTensor(3,2)) == InflatedLazyTensor(Ã,IdentityTensor(3,2))
 
-        I1 = IdentityMapping(3,2)
-        I2 = IdentityMapping(4)
-        @test I1⊗Ã⊗I2 == InflatedTensorMapping(I1, Ã, I2)
+        I1 = IdentityTensor(3,2)
+        I2 = IdentityTensor(4)
+        @test I1⊗Ã⊗I2 == InflatedLazyTensor(I1, Ã, I2)
     end
 
 end