Merge branch 'master' into ksh/cutensor_bump

Author: kshyatt

.github/workflows/FormatCheck.yml

@@ -1,17 +1,15 @@
-name: FormatCheck
+name: 'Format'
 
 on:
-  push:
-    branches:
-      - 'main'
-      - 'master'
-    tags: '*'
-  pull_request:
-    branches:
-      - 'main'
-      - 'master'
+  pull_request_target:
+    paths: ['**/*.jl']
+    types: [opened, synchronize, reopened, ready_for_review]
+
+permissions:
+  contents: read
+  actions: write
+  pull-requests: write
 
 jobs:
   formatcheck:
-    name: "Format Check"
-    uses: "QuantumKitHub/QuantumKitHubActions/.github/workflows/FormatCheck.yml@main"
+    uses: "QuantumKitHub/QuantumKitHubActions/.github/workflows/FormatCheck.yml@main"

Project.toml

@@ -1,7 +1,7 @@
 name = "TensorOperations"
 uuid = "6aa20fa7-93e2-5fca-9bc0-fbd0db3c71a2"
 authors = ["Lukas Devos <[email protected]>", "Maarten Van Damme <[email protected]>", "Jutho Haegeman <[email protected]>"]
-version = "5.4.0"
+version = "5.3.2"
 
 [deps]
 CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"

docs/src/man/indexnotation.md

@@ -243,6 +243,23 @@ however different strategies to modify this order.
     because they share an index label which is next in the `order` list, all other indices
     with shared label among them will be contracted, irrespective of their order.
 
+!!! warning "Combining order specifications"
+
+    Note that it is currently not possible to combine the NCON style convention of specifying
+    indices with the use of parentheses. If both are used at the same time, the parentheses
+    take precedence and the NCON style will be ignored. Any remaining contraction orders
+    will be evaluated in the default left to right order. For example, in the following
+    contractions, we have `E1 = A * ((B * D) * C)`, but `E2 = A * ((B * C) * D)`. This is
+    true even when the parentheses are compatible with the NCON contraction order, as is
+    the case here.
+
+    ```julia
+    @tensor E1[-1 -2 -3; -4] := A[-1 -2 -3; 4 5] * B[4; 1] * C[5; 2] * D[1 2; -4]
+    @tensor E2[-1 -2 -3; -4] := A[-1 -2 -3; 4 5] * (B[4; 1] * C[5; 2] * D[1 2; -4])
+    ```
+
+    Additionally, combining the `order = (...)` keyword with parentheses is currently not supported.
+
 In the case of more complex tensor networks, the optimal contraction order cannot always
 easily be guessed or determined on plain sight. It is then useful to be able to optimize the
 contraction order automatically, given a model for the complexity of contracting the

ext/TensorOperationscuTENSORExt.jl

@@ -147,7 +147,7 @@ end
 #-------------------------------------------------------------------------------------------
 # Allocator
 #-------------------------------------------------------------------------------------------
-function CUDAAllocator()
+function TO.CUDAAllocator()
     Mout = CUDA.UnifiedMemory
     Min = CUDA.default_memory
     Mtemp = CUDA.default_memory

src/indexnotation/instantiators.jl

@@ -122,18 +122,15 @@ function instantiate_generaltensor(
         β = βsym
     end
     if alloc ∈ (NewTensor, TemporaryTensor)
-        TC = gensym("T_" * string(dst))
+        TCsym = gensym("T_" * string(dst))
         istemporary = Val(alloc === TemporaryTensor)
-        if scaltype === nothing
-            TCval = α === One() ? instantiate_scalartype(src) :
-                instantiate_scalartype(Expr(:call, :*, α, src))
-        else
-            TCval = scaltype
-        end
-        push!(out.args, Expr(:(=), TC, TCval))
+        TCval = @something(
+            scaltype, instantiate_scalartype(α === One() ? src : Expr(:call, :*, α, src))
+        )
+        push!(out.args, Expr(:(=), TCsym, TCval))
         push!(
             out.args,
-            Expr(:(=), dst, :(tensoralloc_add($TC, $src, $p, $conj, $istemporary)))
+            Expr(:(=), dst, :(tensoralloc_add($TCsym, $src, $p, $conj, $istemporary)))
         )
     end
 
@@ -167,9 +164,9 @@ function instantiate_linearcombination(
     )
     out = Expr(:block)
     if alloc ∈ (NewTensor, TemporaryTensor)
-        if scaltype === nothing
-            scaltype = instantiate_scalartype(ex)
-        end
+        scaltype = @something(
+            scaltype, instantiate_scalartype(α === One() ? ex : Expr(:call, :*, α, ex))
+        )
         push!(
             out.args,
             instantiate(dst, β, ex.args[2], α, leftind, rightind, alloc, scaltype)
@@ -275,18 +272,15 @@ function instantiate_contraction(
     end
     if alloc ∈ (NewTensor, TemporaryTensor)
         TCsym = gensym("T_" * string(dst))
-        if scaltype === nothing
-            Atype = instantiate_scalartype(A)
-            Btype = instantiate_scalartype(B)
-            TCval = Expr(:call, :promote_contract, Atype, Btype)
-            if α !== One()
-                TCval = Expr(
-                    :call, :(Base.promote_op), :*, instantiate_scalartype(α), TCval
-                )
+        TCval = @something(
+            scaltype,
+            begin
+                TA = instantiate_scalartype(A)
+                TB = instantiate_scalartype(B)
+                TAB = :(promote_contract($TA, $TB))
+                α === One() ? TAB : :(Base.promote_op(*, $(instantiate_scalartype(α)), $TAB))
             end
-        else
-            TCval = scaltype
-        end
+        )
         istemporary = Val(alloc === TemporaryTensor)
         initC = Expr(
             :block, Expr(:(=), TCsym, TCval),

test/tensor.jl

@@ -581,4 +581,15 @@ end
         @test isblascontractable(pA, p)
         @test isblascontractable(conj(pA), p)
     end
+
+    @testset "Issue 220" begin
+        A = rand(2, 2)
+        B = rand(2, 2)
+        C = rand(2, 2)
+        D = rand(2, 2)
+        c = 1im
+        @tensor E[a; c] := c * (A[a b] * B[b c] + C[a b] * D[b c])
+        @test scalartype(E) == ComplexF64
+        @test E ≈ c * (A * B + C * D)
+    end
 end