Fix tests and make the pass

.github/workflows/CI.yml

@@ -1,36 +1,41 @@
 name: CI
 on:
-  - push
-  - pull_request
+  pull_request:
+    branches:
+      - master
+  workflow_dispatch:
 jobs:
   test:
-    name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }}
-    runs-on: ${{ matrix.os }}
+    name: Julia ${{ matrix.version }}
+    runs-on: [self-hosted,titan,gpu]
     strategy:
       fail-fast: false
       matrix:
         version:
-          - '1.5'
-        os:
-          - ubuntu-latest
-          - macOS-latest
-        arch:
-          - x64
+          - '1.9'
+          - '1.10'
     steps:
-      - uses: actions/checkout@v2
-      - uses: julia-actions/setup-julia@v1
+      - uses: actions/checkout@v4
+      - uses: julia-actions/setup-julia@v2
         with:
           version: ${{ matrix.version }}
-          arch: ${{ matrix.arch }}
       - uses: julia-actions/julia-buildpkg@latest
       - uses: julia-actions/julia-runtest@latest
         env:
           JULIA_NUM_THREADS: 4
       - uses: julia-actions/julia-processcoverage@v1
-      # - uses: codecov/codecov-action@v1
-      #   with:
-      #     file: lcov.info
       - uses: coverallsapp/github-action@master
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
-          path-to-lcov: lcov.info
+          path-to-lcov: lcov.info
+          parallel: true
+          flag-name: run-${{ matrix.version }}
+  finish:
+    needs: test
+    runs-on: [self-hosted,titan]
+    steps:
+      - name: Close parallel build
+        uses: coverallsapp/github-action@v1
+        with:
+          parallel-finished: true
+          carryforward: "run-1.9,run-1.10"

Project.toml

@@ -14,22 +14,24 @@ Memoization = "6fafb56a-5788-4b4e-91ca-c0cea6611c73"
 MetaGraphs = "626554b9-1ddb-594c-aa3c-2596fe9399a5"
 NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd"
 ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca"
+SpinGlassExhaustive = "a894d7c4-7f54-4100-9d77-d00d924adeb3"
 SpinGlassNetworks = "b7f6bd3e-55dc-4da6-96a9-ef9dbec6ac19"
 SpinGlassTensors = "7584fc6a-5a23-4eeb-8277-827aab0146ea"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 TensorCast = "02d47bb6-7ce6-556a-be16-bb1710789e2b"
 TensorOperations = "6aa20fa7-93e2-5fca-9bc0-fbd0db3c71a2"
 
 [compat]
-CUDA = "4.4.1"
+CUDA = "5"
 DocStringExtensions = "0.9"
 Graphs = "1.9"
 LabelledGraphs = "0.4.4"
 Memoization = "0.2"
 MetaGraphs = "0.7"
 ProgressMeter = "1.10"
-SpinGlassNetworks = "1"
-SpinGlassTensors = "1"
+SpinGlassExhaustive = "1.0.0"
+SpinGlassNetworks = "1.1.2"
+SpinGlassTensors = "1.1.1"
 Statistics = "1.7.0"
 TensorCast = "0.4"
 TensorOperations = "4"

src/SpinGlassEngine.jl

@@ -2,9 +2,9 @@ module SpinGlassEngine
 
 using Base: Tuple
 using Base.Cartesian
+using CUDA
 using SpinGlassTensors
 using SpinGlassNetworks
-using CUDA
 using TensorOperations
 using TensorCast
 using MetaGraphs
@@ -14,7 +14,7 @@ using Graphs
 using ProgressMeter
 using Statistics
 using DocStringExtensions
-#using Infiltrator
+using NNlib
 
 include("operations.jl")
 include("geometry.jl")

src/search.jl

@@ -387,7 +387,7 @@ function merge_branches_blur(ctr::MpsContractor{T}, hamming_cutoff::Int, merge_t
         selected_boundaries = []
         selected_idx = []
         for (i, state) in enumerate(sorted_boundaries)
-            if all(hamming_distance(state, s) >= hamming_cutoff for s in selected_boundaries)
+            if all(hamming_distance(state, s, :Ising) >= hamming_cutoff for s in selected_boundaries) #TODO case with :RMF
                 push!(selected_boundaries, state)
                 push!(selected_idx, i)
             end
@@ -513,7 +513,7 @@ function low_energy_spectrum(
         ψ0 = mps(ctr, i, length(ctr.betas))
         push!(schmidts, i=> measure_spectrum(ψ0))
         clear_memoize_cache_after_row()
-        Memoization.empty_cache!(SpinGlassTensors.SparseCSC)
+        Memoization.empty_cache!(SpinGlassTensors.sparse)
         empty!(ctr.peps.lp, :GPU)
         if i <= ctr.peps.nrows
             ψ0 = mps(ctr, i + 1, length(ctr.betas))
@@ -535,10 +535,6 @@ function low_energy_spectrum(
     ψ0 = mps(ctr, 2, length(ctr.betas))
     move_to_CPU!(ψ0)
 
-    # println("Memory memoize = ", measure_memory(Memoization.caches))
-    # println("Memory lp = ", format_bytes.(measure_memory(ctr.peps.lp)), " elements = ", length(ctr.peps.lp))
-    # println("Schmidt spectrum : remove those two lines and put it into sol")
-    # println(schmidts)
     # Start branch and bound search
     sol = empty_solution()
     old_row = ctr.nodes_search_order[1][1]
@@ -552,13 +548,15 @@ function low_energy_spectrum(
         end
         sol = branch_solution(sol, ctr)
         if symmetry == :Z2 && length(sol.states[1]) == 1
-            indices_with_odd_numbers = Int[]
+            indices_with_even_numbers = Int[]
             for (index, vector) in enumerate(sol.spins)
-                if any(isodd, vector)
-                    push!(indices_with_odd_numbers, index)
+                if any(iseven, vector)
+                    push!(indices_with_even_numbers, index)
                 end
             end
-            sol = Solution(sol, indices_with_odd_numbers)
+            # if !isempty(indices_with_odd_numbers)
+            sol = Solution(sol, indices_with_even_numbers)
+            # end
         end
         sol = bound_solution(sol, sparams.max_states, sparams.cut_off_prob, merge_strategy)
         Memoization.empty_cache!(precompute_conditional)

test/chimera_overlap_python.jl

@@ -2,10 +2,6 @@ using SpinGlassNetworks
 using SpinGlassTensors
 using SpinGlassEngine
 
-function my_brute_force(ig::IsingGraph; num_states::Int)
-    brute_force(ig, onGPU ? :GPU : :CPU, num_states=num_states)
-end
-
 m = 4
 n = 4
 t = 8
@@ -33,34 +29,30 @@ search_params = SearchParameters(num_states, δp)
 
 Strategy = SVDTruncate
 Gauge = NoUpdate
-@testset "Compare the results for GaugesEnergy with Python" begin
-    for Sparsity ∈ (Dense, Sparse) 
-        network = PEPSNetwork{SquareSingleNode{GaugesEnergy}, Sparsity}(m, n, cl_h, rotation(0))
-        ctr = MpsContractor{Strategy, Gauge}(network, [β/8, β/4, β/2, β], :graduate_truncate, params; onGPU=onGPU)
-        @testset "Compare the results with Python" begin
-            overlap_python = [0.2637787707674837, 0.2501621729619047, 0.2951954406837012]
-            for i in 1:n-1
-                psi_top = mps_top(ctr, i, 4)
-                psi_bottom = mps(ctr, i+1, 4)
-                overlap =  psi_top * psi_bottom
-                @test isapprox(overlap, overlap_python[i], atol=1e-5)
-            end
-        end
-        clear_memoize_cache()
-    end
-end
-
-@testset "Compare the results for EnergyGauges with Python" begin
-    overlap_python = [0.18603559878582027, 0.36463028391550056, 0.30532555472025247]
-    for Sparsity ∈ (Dense, Sparse)
-        net = PEPSNetwork{SquareSingleNode{EnergyGauges}, Sparsity}(m, n, cl_h, rotation(0))
-        ctr = MpsContractor{Strategy, Gauge}(net, [β/8, β/4, β/2, β], :graduate_truncate, params; onGPU=onGPU)
+@testset "Compare the results for GaugesEnergy with Python (Sparsity = $Sparsity)" for Sparsity ∈ (Dense, Sparse) 
+    network = PEPSNetwork{SquareSingleNode{GaugesEnergy}, Sparsity}(m, n, cl_h, rotation(0))
+    ctr = MpsContractor{Strategy, Gauge}(network, [β/8, β/4, β/2, β], :graduate_truncate, params; onGPU=onGPU)
+    @testset "Compare the results with Python" begin
+        overlap_python = [0.2637787707674837, 0.2501621729619047, 0.2951954406837012]
         for i in 1:n-1
             psi_top = mps_top(ctr, i, 4)
             psi_bottom = mps(ctr, i+1, 4)
-            overlap = psi_top * psi_bottom
+            overlap =  psi_top * psi_bottom
             @test isapprox(overlap, overlap_python[i], atol=1e-5)
         end
-        clear_memoize_cache()
     end
+    clear_memoize_cache()
+end
+
+@testset "Compare the results for EnergyGauges with Python (Sparsity = $Sparsity)" for Sparsity ∈ (Dense, Sparse)
+    overlap_python = [0.18603559878582027, 0.36463028391550056, 0.30532555472025247]
+    net = PEPSNetwork{SquareSingleNode{EnergyGauges}, Sparsity}(m, n, cl_h, rotation(0))
+    ctr = MpsContractor{Strategy, Gauge}(net, [β/8, β/4, β/2, β], :graduate_truncate, params; onGPU=onGPU)
+    for i in 1:n-1
+        psi_top = mps_top(ctr, i, 4)
+        psi_bottom = mps(ctr, i+1, 4)
+        overlap = psi_top * psi_bottom
+        @test isapprox(overlap, overlap_python[i], atol=1e-5)
+    end
+    clear_memoize_cache()
 end

test/experimental/gauges.jl

@@ -0,0 +1,135 @@
+using SpinGlassNetworks
+using SpinGlassTensors
+using SpinGlassEngine
+
+m = 4
+n = 4
+t = 8
+
+L = n * m * t
+max_cl_states = 2^(t-0)
+
+β =0.5
+bond_dim = 32
+δp = 1E-3
+num_states = 1000
+
+instance = "$(@__DIR__)/instances/chimera_droplets/128power/001.txt"
+
+cl_h = clustered_hamiltonian(
+    ising_graph(instance),
+    max_cl_states,
+    spectrum=full_spectrum,
+    cluster_assignment_rule=super_square_lattice((m, n, t))
+)
+
+params = MpsParameters(bond_dim, 1E-8, 10)
+search_params = SearchParameters(num_states, δp)
+
+# @testset "Overlaps calculated differently are the same." begin
+# for Lattice ∈ (SquareSingleNode, SquareCrossSingleNode) 
+#     for Sparsity ∈ (Dense, Sparse), transform ∈ all_lattice_transformations[[1]]
+#         for Layout ∈ (GaugesEnergy, EnergyGauges, EngGaugesEng)
+#             net = PEPSNetwork{Lattice{Layout}, Sparsity}(m, n, cl_h, transform, :id)
+#             ctr_svd = MpsContractor{SVDTruncate, GaugeStrategy}(net, [β/8, β/4, β/2, β], :graduate_truncate, params; onGPU=onGPU)
+#             ctr_anneal = MpsContractor{MPSAnnealing, GaugeStrategy}(net, [β/8, β/4, β/2, β], :graduate_truncate, params; onGPU=onGPU)
+
+#             @testset "Overlaps calculated for different Starategies are the same." begin
+#                 indβ = 3
+#                 for i ∈ 1:m-1
+#                     ψ_top = mps_top(ctr_svd, i, indβ)
+#                     ϕ_top = mps_top(ctr_anneal, i, indβ)
+#                     @test ψ_top * ψ_top ≈ 1
+#                     @test ϕ_top * ϕ_top ≈ 1
+#                     @test ψ_top * ϕ_top ≈ 1
+#                 end
+#             end
+#         end
+#         clear_memoize_cache()
+
+#         for Layout ∈ (GaugesEnergy,)
+#             net = PEPSNetwork{Lattice{Layout}, Sparsity}(m, n, cl_h, transform, :id)
+#             ctr_svd = MpsContractor{SVDTruncate, GaugeStrategy}(net, [β/8, β/4, β/2, β], :graduate_truncate, params; onGPU=onGPU)
+#             @testset "Overlaps calculated in Python are the same as in Julia." begin
+#                 indβ = [4, ]
+#                 overlap_python = [0.2637787707674837, 0.2501621729619047, 0.2951954406837012]
+
+#                 for i ∈ vcat(1:m-1)#, m-1:-1:1)
+#                     ψ_top = mps_top(ctr_svd, i, indβ[begin])
+#                     ψ_bot = mps(ctr_svd, i+1, indβ[begin])
+#                     overlap1 = ψ_top * ψ_bot
+#                     @test isapprox(overlap1, overlap_python[i], atol=1e-5)
+#                 end
+#                 clear_memoize_cache()
+#             end
+#         end
+#     end
+# end
+# end
+
+@testset "Updating gauges works correctly." begin
+for Strategy ∈ (SVDTruncate, MPSAnnealing), Sparsity ∈ (Dense, Sparse) 
+    for Layout ∈ (GaugesEnergy,)
+        for Gauge ∈ (GaugeStrategy, )
+            for Lattice ∈ (SquareSingleNode, SquareCrossSingleNode), transform ∈ all_lattice_transformations
+                net = PEPSNetwork{Lattice{Layout}, Sparsity}(m, n, cl_h, transform, :id)
+                ctr = MpsContractor{Strategy, Gauge}(net, [β/8, β/4, β/2, β], :graduate_truncate, params; onGPU=onGPU)
+
+                @testset "Overlaps calculated differently are the same." begin
+                    indβ = 3
+                    for i ∈ 1:m-1
+
+                        ψ_top = mps_top(ctr, i, indβ)
+                        ψ_bot = mps(ctr, i+1, indβ)
+
+                        try
+                            overlap = tr(overlap_density_matrix(ψ_top, ψ_bot, indβ))
+                            @test overlap ≈ ψ_bot * ψ_top
+                        catch
+                            println(Strategy, " ", Sparsity, " ", Lattice, " ", i)
+                            overlap = Inf
+                            @test overlap ≈ ψ_bot * ψ_top
+
+                        end
+
+                    end
+                end
+                clear_memoize_cache()
+
+                # @testset "ψ_bot and ψ_top are not updated in place though memoize!" begin
+                #     indβ = [3,]
+                #     for aba in 1:3, i ∈ 1:m-1
+                #         println(aba," ", i)
+                #         ψ_top = mps_top(ctr, i, indβ[begin])
+                #         ψ_bot = mps(ctr, i+1, indβ[begin])
+
+                #         overlap_old = ψ_top * ψ_bot
+
+                #         update_gauges!(ctr, i, indβ, Val(:down))
+
+                #         # assert that ψ_bot and ψ_top are not updated in place though memoize!
+                #         overlap_old2 = ψ_bot * ψ_top
+
+                #         @test overlap_old ≈ overlap_old2
+
+
+                #     end
+                # end
+                # break
+                # clear_memoize_cache()
+
+                # @testset "Updating gauges from top and bottom gives the same energy." begin
+                #     indβ = [3,]
+                #     update_gauges!(ctr, m, indβ, Val(:down))
+                #     sol_l, s = low_energy_spectrum(ctr, search_params, merge_branches(ctr))
+                #     clear_memoize_cache()
+                #     update_gauges!(ctr, m, indβ, Val(:up))
+                #     sol_r, s = low_energy_spectrum(ctr, search_params, merge_branches(ctr))
+                #     @test sol_l.energies[begin] ≈ sol_r.energies[begin]
+                # end
+                # clear_memoize_cache()
+            end
+        end
+    end
+end
+end

test/search_chimera_gauge.jl → test/experimental/search_chimera_gauge.jl

@@ -25,7 +25,7 @@
     Gauge = GaugeStrategy
 
     energies = Vector{Float64}[]
-    for Strategy ∈ (SVDTruncate, Zipper), Sparsity ∈ (Dense,)
+    for Strategy ∈ (SVDTruncate, Zipper), Sparsity ∈ (Dense, Sparse)
         for Layout ∈ (GaugesEnergy,)
             for transform ∈ all_lattice_transformations
                 net = PEPSNetwork{SquareSingleNode{Layout}, Sparsity}(m, n, cl_h, transform)