Allow cheaping out on convergence checks

src/algorithms/ctmrg/ctmrg.jl

@@ -113,15 +113,16 @@ function leading_boundary(
     return with_verbosity(; alg.verbosity) do
         env = deepcopy(env₀)
         CS, TS = ignore_derivatives() do
-            return convergence_spectra(env₀, alg)
+            return corner_spectra(first(convergence_tensors(env₀, alg)), alg), nothing
         end
         η = one(real(scalartype(network)))
         ctmrg_loginit!(log, η, network, env₀)
         local info_iter
         converged = false
         for iter in 1:(alg.maxiter)
+            env_prev = env
             env, info_iter = ctmrg_iteration(network, env, alg)
-            η, CS, TS = calc_convergence(env, CS, TS, alg)
+            η, CS, TS = calc_convergence_lazy(env, env_prev, CS, TS, alg; exact = iter == alg.maxiter)
 
             if η ≤ alg.tol && iter ≥ alg.miniter
                 ctmrg_logfinish!(log, iter, η, network, env)
@@ -131,7 +132,7 @@ function leading_boundary(
             if iter == alg.maxiter
                 ctmrg_logcancel!(log, iter, η, network, env)
             else
-                ctmrg_logiter!(log, iter, η, network, env)
+                ctmrg_logiter!(log, iter, η, network, env, isnothing(TS))
             end
         end
         info = (;
@@ -158,9 +159,13 @@ function check_input(::typeof(leading_boundary), network, env, alg::CTMRGAlgorit
 function ctmrg_loginit!(log, η, network, env)
     return @log_initialization loginit!(log, η, network_value(network, env))
 end
-function ctmrg_logiter!(log, iter, η, network, env)
-    return @log_iteration logiter!(log, iter, η, network_value(network, env))
+function ctmrg_logiter!(log, iter, η, network, env, lower_bound::Bool = false)
+    return @log_iteration _iterlog_message(
+        logiter!(log, iter, η, network_value(network, env)), lower_bound
+    )
 end
+_iterlog_message(log, lower_bound::Bool) =
+    lower_bound ? replace(sprint(show, log), "err = " => "err ≥ ") : log
 function ctmrg_logfinish!(log, iter, η, network, env)
     return @log_convergence logfinish!(log, iter, η, network_value(network, env))
 end
@@ -257,6 +262,30 @@ function calc_convergence(env, CS_old, TS_old, alg)
     return max(ΔCS, ΔTS), CS_new, TS_new
 end
 
+"""
+    calc_convergence_lazy(env, env_prev, CS_old, TS_old, alg; exact = false)
+
+Like `calc_convergence(env, CS_old, TS_old, alg)`, but only computes the edge spectra
+if the corner distance is within `alg.tol` or `exact == true`. 
+"""
+function calc_convergence_lazy(env, env_prev, CS_old, TS_old, alg; exact::Bool = false)
+    corners, edges = convergence_tensors(env, alg)
+    CS_new = corner_spectra(corners, alg)
+    ΔCS = maximum(splat(_singular_value_distance), zip(CS_old, CS_new))
+    if ΔCS > alg.tol && !exact
+        @debug "maxᵢ|Cⁿ⁺¹ - Cⁿ|ᵢ = $ΔCS   (edges skipped)"
+        return ΔCS, CS_new, nothing
+    end
+    if isnothing(TS_old)
+        TS_old = edge_spectra(last(convergence_tensors(env_prev, alg)), alg)
+    end
+    TS_new = edge_spectra(edges, alg)
+    ΔTS = maximum(splat(_singular_value_distance), zip(TS_old, TS_new))
+    @debug "maxᵢ|Cⁿ⁺¹ - Cⁿ|ᵢ = $ΔCS   maxᵢ|Tⁿ⁺¹ - Tⁿ|ᵢ = $ΔTS"
+    return max(ΔCS, ΔTS), CS_new, TS_new
+end
+@non_differentiable calc_convergence_lazy(args...)
+
 """
     calc_convergence(env, CS_old, TS_old)
     calc_convergence(env_new, env_old)