| import Mathlib |
| import OAI.MathematicalPhysics.PEPSFilters.LocalOperators |
| import OAI.MathematicalPhysics.PEPSSubvolume.Filters |
| import OAI.MathematicalPhysics.PEPSSubvolume.KernelPerturbation |
|
|
| namespace OAI |
|
|
| /-! Flat second variations and vanishing optimizing kernel directions. -/ |
|
|
| noncomputable section |
| open scoped BigOperators ComplexOrder |
| open scoped BigOperators ComplexOrder Matrix.Norms.L2Operator |
| open scoped BigOperators |
| open PolynomialPEPS.PinnedEntropy |
|
|
| open scoped Topology |
| open Filter |
| namespace PolynomialPEPS.Subvolume.OptimizerFlatDirection |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] |
|
|
| theorem second_variation (v u w : E) (C K p : ℝ) (hp : 2 < p) |
| (h : ∀ t : ℝ, ‖v + t • u + t^2 • w‖^2 ≤ |
| (‖v‖^2 + C*t^2) * (1 + K*|t|^p)) : |
| 2 * inner ℝ v w + ‖u‖^2 ≤ C := by |
| have hb (t : ℝ) (ht : 0 < t) : |
| 2 * inner ℝ v w + ‖u‖^2 ≤ |
| C + K*‖v‖^2*t^(p-2) + K*C*t^p := by |
| have hp' := h t |
| have hm' := h (-t) |
| have hsum : ‖(v+t^2 • w) + t • u‖^2 + ‖(v+t^2 • w) - t • u‖^2 ≤ |
| 2 * ((‖v‖^2+C*t^2)*(1+K*t^p)) := by |
| simpa only [neg_smul, neg_sq, abs_neg, abs_of_pos ht, sub_eq_add_neg, |
| add_assoc, add_left_comm, add_comm, two_mul] using add_le_add hp' hm' |
| rw [parallelogram_law_with_norm ℝ, norm_add_sq_real] at hsum |
| simp only [inner_smul_right, norm_smul, Real.norm_eq_abs, |
| abs_of_nonneg (sq_nonneg t), abs_of_pos ht, mul_pow] at hsum |
| have hr : t^p = t^2 * t^(p-2) := by |
| rw [← Real.rpow_natCast t 2, ← Real.rpow_add ht] |
| congr 1 |
| norm_num |
| have ht2 : 0 < t^2 := sq_pos_of_pos ht |
| apply (mul_le_mul_iff_right₀ ht2).mp |
| have hw : 0 ≤ (t^2)^2 * ‖w‖^2 := mul_nonneg (sq_nonneg _) (sq_nonneg _) |
| rw [hr] at hsum ⊢ |
| nlinarith only [hsum,hw] |
| have hpow : Tendsto (fun t : ℝ => t^(p-2)) (𝓝[>] 0) (𝓝 0) := by |
| have ht := (Real.continuousAt_rpow_const 0 (p-2) |
| (Or.inr (by linarith))).tendsto.mono_left (nhdsWithin_le_nhds (s := Set.Ioi (0:ℝ))) |
| simpa [Real.zero_rpow (show p-2 ≠ 0 by linarith)] using ht |
| have hpow' : Tendsto (fun t : ℝ => t^p) (𝓝[>] 0) (𝓝 0) := by |
| have ht := (Real.continuousAt_rpow_const 0 p |
| (Or.inr (by linarith))).tendsto.mono_left (nhdsWithin_le_nhds (s := Set.Ioi (0:ℝ))) |
| simpa [Real.zero_rpow (ne_of_gt (show 0 < p by linarith))] using ht |
| have hl : Tendsto (fun t : ℝ => C+K*‖v‖^2*t^(p-2)+K*C*t^p) |
| (𝓝[>] 0) (𝓝 C) := by |
| convert (tendsto_const_nhds.add (tendsto_const_nhds.mul hpow)).add |
| (tendsto_const_nhds.mul hpow') using 1 |
| simp |
| apply ge_of_tendsto hl |
| filter_upwards [self_mem_nhdsWithin] with t ht |
| exact hb t ht |
|
|
| theorem first_direction_vanishes (v w : E) (K p : ℝ) (hp : 2 < p) |
| (h : ∀ t : ℝ, ‖v + t • w‖^2 ≤ ‖v‖^2 * (1+K*|t|^p)) : |
| w = 0 := by |
| have hb := second_variation v w 0 0 K p hp (by simpa using h) |
| simp only [inner_zero_right, mul_zero, zero_add] at hb |
| simpa using norm_eq_zero.mp (le_antisymm (by nlinarith [norm_nonneg w]) (norm_nonneg w)) |
|
|
| theorem mixed_direction_vanishes (v u w : E) (K p : ℝ) (hp : 2 < p) |
| (h : ∀ c t : ℝ, ‖v + t • u + (c*t^2) • w‖^2 ≤ |
| (‖v‖^2+‖v‖^2*t^2)*(1+K*|c*t|^p)) : |
| inner ℝ v w = 0 := by |
| have hc (c : ℝ) : 2*c*inner ℝ v w + ‖u‖^2 ≤ ‖v‖^2 := by |
| have hb := second_variation v u (c • w) (‖v‖^2) (K*|c|^p) p hp (fun t => by |
| simpa [smul_smul, mul_comm, mul_left_comm, mul_assoc, abs_mul, |
| Real.mul_rpow (abs_nonneg c) (abs_nonneg t)] using h c t) |
| simpa [inner_smul_right, mul_assoc, mul_left_comm, mul_comm] using hb |
| by_contra hn |
| have hne : 2 * inner ℝ v w ≠ 0 := mul_ne_zero (by norm_num) hn |
| have H := hc ((‖v‖^2+‖u‖^2+1)/(2*inner ℝ v w)) |
| have heq : 2*((‖v‖^2+‖u‖^2+1)/(2*inner ℝ v w))*inner ℝ v w = |
| ‖v‖^2+‖u‖^2+1 := by field_simp |
| rw [heq] at H |
| nlinarith [sq_nonneg ‖u‖] |
|
|
| end PolynomialPEPS.Subvolume.OptimizerFlatDirection |
|
|
| namespace PolynomialPEPS.Subvolume.ActualKernel |
| open scoped BigOperators ComplexOrder Matrix.Norms.L2Operator |
| open PolynomialPEPS.Subvolume.SpectralCurve PolynomialPEPS.Subvolume.KernelPerturbation |
| open PolynomialPEPS.Subvolume.KernelNormalization PolynomialPEPS.Subvolume.OptimizerGauge |
| variable {L q : ℕ} |
|
|
| theorem affine_output (A : ℕ → Operator L q) (k n : ℕ) (hk : k<n) |
| (B : Operator L q) (c d : ℂ) (ψ : State L q) : |
| asMap (L := L) (q := q) (orderedPrefix (Function.update A k (c • (A k + d • B))) n) ψ = |
| c • (asMap (L := L) (q := q) (orderedPrefix A n) ψ + |
| d • asMap (L := L) (q := q) (orderedPrefix (Function.update A k B) n) ψ) := by |
| rw [prefix_update_smul A k n hk, prefix_update_add A k n hk, |
| Function.update_eq_self, prefix_update_smul A k n hk] |
| change Matrix.toEuclideanCLM (𝕜 := ℂ) (_ • (_ + _ • _)) ψ = _ |
| simp only [map_smul, map_add, smul_apply, add_apply] |
| rfl |
|
|
| theorem perturbation_envelope (hq : 0 < q) |
| (X : ℕ → Finset (Vertex L)) (hX : Monotone X) |
| (a : ℕ → ℝ) (ψ : State L q) (n : ℕ) |
| (F : (j : ℕ) → LocalPositiveFilter q (X j)) |
| (hF : IsFilterOptimizer ψ (fun j : Fin n => a j.val) (fun j : Fin n => F j.val)) |
| (k : ℕ) (hk : k < n) (hp : 2 < 2/a k) |
| (U : unitary (Matrix (RegionConfiguration q (X k)) (RegionConfiguration q (X k)) ℂ)) |
| (e : RegionConfiguration q (X k) → ℝ) (he : ∀ i, 0 ≤ e i) |
| (hrep : (F k).matrix = spectralHom U (fun i => (e i : ℂ))) |
| (hs : ∑ i, (e i)^(2/a k) = 1) |
| (ζ : unitary ℂ) (t : ℝ) : |
| let A : ℕ → Operator L q := fun j => liftLocal (X j) (F j).matrix |
| let v : State L q := asMap (L := L) (q := q) (orderedPrefix A n) ψ |
| let w : State L q := asMap (L := L) (q := q) (orderedPrefix (Function.update A k (liftLocal (X k) (kernel U e))) n) ψ |
| ‖v + ((t : ℂ)*(ζ : ℂ)) • w‖^2 ≤ ‖v‖^2 * cost e (2/a k) t := by |
| dsimp only |
| let A : ℕ → Operator L q := fun j => liftLocal (X j) (F j).matrix |
| let c := scale (cost e (2/a k) t) (2/a k) |
| let G : LocalPositiveFilter q (X k) := |
| ⟨normalized U e (2/a k) t, normalized_posSemidef U e he (2/a k) t⟩ |
| have hG : filterTracePower G (2/a k) = 1 := |
| normalized_capacity U e he (2/a k) (by linarith) hs t |
| have hb := one_replacement_bound hq X hX a ψ n F hF k hk |
| (perturbUnitary U e ζ t) G hG |
| have hmat : liftLocal (X k) |
| ((perturbUnitary U e ζ t : Matrix _ _ ℂ)*G.matrix) = |
| (c : ℂ) • (A k + ((t : ℂ)*(ζ : ℂ)) • liftLocal (X k) (kernel U e)) := by |
| rw [show G.matrix = normalized U e (2/a k) t from rfl, |
| normalized_factorization, ← hrep, liftLocal_smul, liftLocal_add, liftLocal_smul] |
| have houtput : asMap (L := L) (q := q) (orderedPrefix (Function.update A k |
| (liftLocal (X k) ((perturbUnitary U e ζ t : Matrix _ _ ℂ)*G.matrix))) n) ψ = |
| (c : ℂ) • (asMap (L := L) (q := q) (orderedPrefix A n) ψ + |
| ((t : ℂ)*(ζ : ℂ)) • |
| asMap (L := L) (q := q) (orderedPrefix (Function.update A k (liftLocal (X k) (kernel U e))) n) ψ) := by |
| rw [hmat] |
| exact affine_output A k n hk _ _ _ ψ |
| have hfv : filteredVector (fun j : Fin n => F j.val) ψ = asMap (L := L) (q := q) (orderedPrefix A n) ψ := by |
| unfold filteredVector |
| rw [PhysicalCurve.orderedFilterProduct_eq_prefix] |
| have hc : 0 < c := scale_pos _ _ |
| (lt_of_lt_of_le zero_lt_one (one_le_cost e (2/a k) t)) |
| have hb' := hb |
| rw [houtput, hfv, norm_smul, Complex.norm_real, Real.norm_eq_abs, abs_of_pos hc] at hb' |
| exact norm_sq_bound _ _ _ _ (norm_nonneg _) (norm_nonneg _) |
| (one_le_cost e (2/a k) t) hp hb' |
| |
| theorem kernel_output_zero (hq : 0 < q) |
| (X : ℕ → Finset (Vertex L)) (hX : Monotone X) |
| (a : ℕ → ℝ) (ψ : State L q) (n : ℕ) |
| (F : (j : ℕ) → LocalPositiveFilter q (X j)) |
| (hF : IsFilterOptimizer ψ (fun j : Fin n => a j.val) (fun j : Fin n => F j.val)) |
| (k : ℕ) (hk : k < n) (hp : 2 < 2/a k) |
| (U : unitary (Matrix (RegionConfiguration q (X k)) (RegionConfiguration q (X k)) ℂ)) |
| (e : RegionConfiguration q (X k) → ℝ) (he : ∀ i, 0 ≤ e i) |
| (hrep : (F k).matrix = spectralHom U (fun i => (e i : ℂ))) |
| (hs : ∑ i, (e i)^(2/a k) = 1) : |
| asMap (L := L) (q := q) (orderedPrefix (Function.update (fun j => liftLocal (X j) (F j).matrix) |
| k (liftLocal (X k) (kernel U e))) n) ψ = 0 := by |
| let A : ℕ → Operator L q := fun j => liftLocal (X j) (F j).matrix |
| let v : State L q := asMap (L := L) (q := q) (orderedPrefix A n) ψ |
| let w : State L q := asMap (L := L) (q := q) (orderedPrefix (Function.update A k (liftLocal (X k) (kernel U e))) n) ψ |
| let K : ℝ := ∑ i, if e i = 0 then (1:ℝ) else 0 |
| have hb (t : ℝ) : ‖v + t • w‖^2 ≤ ‖v‖^2*(1+K*|t|^(2/a k)) := by |
| have H := perturbation_envelope hq X hX a ψ n F hF k hk hp U e he hrep hs 1 t |
| change ‖v + ((t : ℂ)*(1 : unitary ℂ)) • w‖^2 ≤ ‖v‖^2*(1+K*|t|^(2/a k)) at H |
| have htw : (t : ℂ) • w = t • w := by |
| ext i |
| simp [Complex.real_smul] |
| simpa only [OneMemClass.coe_one, mul_one, htw] using H |
| exact OptimizerFlatDirection.first_direction_vanishes v w K (2/a k) hp hb |
| |
| end PolynomialPEPS.Subvolume.ActualKernel |
| |
| end |
| |
| end OAI |
| |
