| import Mathlib |
| import OAI.MathematicalPhysics.PEPSFilters.LocalOperators |
| import OAI.MathematicalPhysics.PEPSSubvolume.RegionSSA |
| import OAI.MathematicalPhysics.PEPSSubvolume.EntropyDimension |
| import OAI.MathematicalPhysics.PEPSSubvolume.TilingEntropy |
| import OAI.MathematicalPhysics.PEPSSubvolume.RectangleTiling |
|
|
| namespace OAI |
|
|
| /-! Uniform entropy contraction across square scales. -/ |
|
|
| noncomputable section |
| open scoped BigOperators ComplexOrder |
| open scoped BigOperators ComplexOrder Matrix.Norms.L2Operator |
| open scoped BigOperators |
| open scoped Topology |
| open Filter |
| open scoped MatrixOrder |
| open scoped BigOperators Matrix.Norms.L2Operator |
| open scoped ComplexOrder BigOperators Matrix.Norms.L2Operator |
| open Matrix |
| open Filter Topology |
| open Set Filter Complex Complex.HadamardThreeLines |
| open scoped BigOperators Matrix.Norms.L2Operator MatrixOrder ComplexOrder |
| open PolynomialPEPS.PinnedEntropy |
|
|
| namespace PolynomialPEPS.Subvolume.RectangleTiling |
| open scoped BigOperators |
| open PolynomialPEPS.Subvolume.HarmonicWeights PolynomialPEPS.Subvolume.GeometricLower |
| open PolynomialPEPS.Subvolume.RectangleContours |
| variable {L q : ℕ} |
|
|
| theorem physical_color_recurrence (hq : 0<q) (J Δ E₀ : ℝ) |
| (hJ : 0≤J) (hΔ : 0<Δ) |
| (hv : Vertex L → Operator L q) (he : Edge L → Operator L q) (Ω : State L q) |
| (hΩ : ‖Ω‖=1) (hH : IsGridHamiltonian J hv he) |
| (hg : asMap (Hamiltonian hv he) Ω=(E₀:ℂ) • Ω) |
| (hgap : FullSystemGap (Hamiltonian hv he) Ω E₀ Δ) |
| (lo₁ lo₂ : ℤ) (M r : ℕ) (hr : 0<r) |
| (F : ℝ) (hF : ∀ i : Index M, vonNeumannEntropy Ω (tile lo₁ lo₂ r i)≤F) : |
| let b := 2^(blocks q J Δ) |
| let K : ℝ := ((b+1:ℕ):ℝ)^2 |
| vonNeumannEntropy Ω (box lo₁ lo₂ M r) ≤ |
| ((M:ℝ)^2-3/(4*K)*((interior b M).card:ℝ))*F+ |
| ((interior b M).card:ℝ)*(bufferConstant q J Δ*(r:ℝ)/4)/K := by |
| classical |
| let b := 2^(blocks q J Δ) |
| let C := tile (L:=L) (M:=M) lo₁ lo₂ r |
| let Y := collar (L:=L) (M:=M) lo₁ lo₂ r b |
| have hdis : ((Finset.univ : Finset (Index M)) : Set (Index M)).Pairwise |
| (fun i j => Disjoint (C i) (C j)) := |
| fun i _ j _ hij => tiles_disjoint lo₁ lo₂ r hr i j hij |
| have hCY : ∀ i∈interior b M, C i ⊆ Y i := by |
| intro i hi |
| exact monotone_rectangle _ _ _ _ (Nat.zero_le _) |
| have hY : ∀ k : Index (b+1), ∀ i∈interior b M, color b i=k → |
| Y i\C i ⊆ PolynomialPEPS.SubvolumeTiling.unionTiles C |
| (Finset.univ\(interior b M).filter (fun j => color b j=k)) := by |
| intro k i hi hk |
| subst k |
| exact collar_exposed lo₁ lo₂ r b hr i hi |
| have hc : ∀ i∈interior b M, vonNeumannEntropy Ω (Y i)-vonNeumannEntropy Ω (Y i\C i)≤ |
| vonNeumannEntropy Ω (C i)/4+bufferConstant q J Δ*(r:ℝ)/4 := by |
| intro i hi |
| apply GeometricComparison.rectangle_conditional_contraction hq J Δ E₀ hJ hΔ |
| hv he Ω hΩ hH hg hgap _ _ _ _ r hr <;> linarith |
| have hh := PolynomialPEPS.SubvolumeTiling.color_recurrence (vonNeumannEntropy Ω) |
| (vonNeumannEntropy_empty Ω hΩ) (RegionSSA.conditional_entropy_antitone hq Ω) |
| C Y Finset.univ (interior b M) (Finset.subset_univ _) (color b) hdis hCY hY |
| (bufferConstant q J Δ*(r:ℝ)/4) F hc (fun i _ => hF i) |
| dsimp only [PolynomialPEPS.SubvolumeTiling.unionTiles,C] at hh |
| rw [tiles_cover lo₁ lo₂ r hr] at hh |
| simpa only [Finset.card_univ,Index,Fintype.card_prod,Fintype.card_fin,Nat.cast_mul,pow_two] using hh |
|
|
| theorem physical_density_contraction (hq : 0<q) (J Δ E₀ : ℝ) |
| (hJ : 0≤J) (hΔ : 0<Δ) |
| (hv : Vertex L → Operator L q) (he : Edge L → Operator L q) (Ω : State L q) |
| (hΩ : ‖Ω‖=1) (hH : IsGridHamiltonian J hv he) |
| (hg : asMap (Hamiltonian hv he) Ω=(E₀:ℂ) • Ω) |
| (hgap : FullSystemGap (Hamiltonian hv he) Ω E₀ Δ) |
| (lo₁ lo₂ : ℤ) (r : ℕ) (hr : 0<r) (F : ℝ) (hF0 : 0≤F) |
| (hF : ∀ i : Index (4*(2^(blocks q J Δ)+1)), vonNeumannEntropy Ω (tile lo₁ lo₂ r i)≤F) : |
| let b := 2^(blocks q J Δ) |
| let M := 4*(b+1) |
| let K : ℝ := ((b+1:ℕ):ℝ)^2 |
| vonNeumannEntropy Ω (box lo₁ lo₂ M r) ≤ |
| (1-3/(16*K))*(M:ℝ)^2*F+(M:ℝ)^2*(bufferConstant q J Δ*(r:ℝ)/4)/K := by |
| let b := 2^(blocks q J Δ) |
| let M := 4*(b+1) |
| let K : ℝ := ((b+1:ℕ):ℝ)^2 |
| let N : ℝ := (interior b M).card |
| have hK : 0<K := by dsimp [K]; positivity |
| have hNlo : (M:ℝ)^2/4≤N := by |
| have hh : ((2*(b+1):ℕ):ℝ)^2≤N := by |
| dsimp only [N,M] |
| exact_mod_cast interior_card_lower b |
| dsimp only [M] |
| push_cast at hh ⊢ |
| nlinarith only [hh] |
| have hNhi : N≤(M:ℝ)^2 := by |
| dsimp only [N] |
| exact_mod_cast interior_card_upper b M |
| have hB : 0≤bufferConstant q J Δ*(r:ℝ)/4 := by |
| dsimp only [bufferConstant] |
| positivity |
| have hh := physical_color_recurrence hq J Δ E₀ hJ hΔ hv he Ω hΩ hH hg hgap lo₁ lo₂ M r hr F hF |
| change vonNeumannEntropy Ω (box lo₁ lo₂ M r) ≤ ((M:ℝ)^2-3/(4*K)*N)*F+ |
| N*(bufferConstant q J Δ*(r:ℝ)/4)/K at hh |
| apply hh.trans |
| change ((M:ℝ)^2-3/(4*K)*N)*F+N*(bufferConstant q J Δ*(r:ℝ)/4)/K ≤ |
| (1-3/(16*K))*(M:ℝ)^2*F+(M:ℝ)^2*(bufferConstant q J Δ*(r:ℝ)/4)/K |
| have hd : 0≤3/(4*K) := le_of_lt (div_pos (by norm_num) (mul_pos (by norm_num) hK)) |
| have h1 := mul_le_mul_of_nonneg_right hNlo (mul_nonneg hd hF0) |
| have h2 := mul_le_mul_of_nonneg_right hNhi (div_nonneg hB (le_of_lt hK)) |
| have he : 3/(16*K)=(3/(4*K))/4 := by ring |
| rw [he] |
| apply add_le_add |
| · calc |
| _ = (M:ℝ)^2*F-N*(3/(4*K)*F) := by ring |
| _ ≤ (M:ℝ)^2*F-((M:ℝ)^2/4)*(3/(4*K)*F) := sub_le_sub_left h1 _ |
| _ = _ := by ring |
| · exact div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_right hNhi hB) (le_of_lt hK) |
|
|
| end PolynomialPEPS.Subvolume.RectangleTiling |
|
|
| namespace PolynomialPEPS.Subvolume.RectangleTiling |
| open scoped BigOperators |
| open PolynomialPEPS.Subvolume.HarmonicWeights PolynomialPEPS.Subvolume.GeometricLower |
| open PolynomialPEPS.Subvolume.RectangleContours |
| variable {L q : ℕ} |
|
|
| lemma tile_as_box (lo₁ lo₂ : ℤ) (r : ℕ) {M : ℕ} (i : Index M) : |
| tile (L:=L) lo₁ lo₂ r i = |
| box (lo₁+(i.1.val:ℤ)*r) (lo₂+(i.2.val:ℤ)*r) 1 r := by |
| unfold tile box |
| congr 1 <;> push_cast <;> ring |
|
|
| lemma box_mul (lo₁ lo₂ : ℤ) (M r : ℕ) : |
| box (L:=L) lo₁ lo₂ M r=box lo₁ lo₂ 1 (M*r) := by |
| unfold box |
| congr 1 <;> push_cast <;> ring |
|
|
| lemma unit_box_card (lo₁ lo₂ : ℤ) : (box (L:=L) lo₁ lo₂ 1 1).card≤1 := by |
| apply Finset.card_le_one.mpr |
| intro v hv w hw |
| rw [mem_box] at hv hw |
| apply Prod.ext <;> apply Fin.ext <;> omega |
|
|
| theorem physical_three_child_gain (hq : 0<q) (J Δ E₀ : ℝ) |
| (hJ : 0≤J) (hΔ : 0<Δ) |
| (hv : Vertex L → Operator L q) (he : Edge L → Operator L q) (Ω : State L q) |
| (hΩ : ‖Ω‖=1) (hH : IsGridHamiltonian J hv he) |
| (hg : asMap (Hamiltonian hv he) Ω=(E₀:ℂ) • Ω) |
| (hgap : FullSystemGap (Hamiltonian hv he) Ω E₀ Δ) |
| (lo₁ lo₂ : ℤ) (r : ℕ) (hr : 0<r) (F : ℝ) (hF0 : 0≤F) |
| (hF : ∀ i : Index (4*(2^(blocks q J Δ)+1)), vonNeumannEntropy Ω (tile lo₁ lo₂ r i)≤F) : |
| let M := 4*(2^(blocks q J Δ)+1) |
| vonNeumannEntropy Ω (box lo₁ lo₂ 1 (M*r)) ≤ |
| ((M:ℝ)^2-3)*F+4*bufferConstant q J Δ*(r:ℝ) := by |
| let b := 2^(blocks q J Δ) |
| let M := 4*(b+1) |
| let K : ℝ := ((b+1:ℕ):ℝ)^2 |
| have hK : K≠0 := by dsimp [K]; positivity |
| have hc : (M:ℝ)^2=16*K := by dsimp [M,K]; push_cast; ring |
| have hh := physical_density_contraction hq J Δ E₀ hJ hΔ hv he Ω hΩ hH hg hgap lo₁ lo₂ r hr F hF0 hF |
| change vonNeumannEntropy Ω (box lo₁ lo₂ M r) ≤ |
| (1-3/(16*K))*(M:ℝ)^2*F+(M:ℝ)^2*(bufferConstant q J Δ*(r:ℝ)/4)/K at hh |
| rw [box_mul] at hh |
| convert hh using 1 |
| rw [hc] |
| field_simp |
| ring |
|
|
| theorem square_scale_entropy (hq : 0<q) (J Δ E₀ : ℝ) |
| (hJ : 0≤J) (hΔ : 0<Δ) |
| (hv : Vertex L → Operator L q) (he : Edge L → Operator L q) (Ω : State L q) |
| (hΩ : ‖Ω‖=1) (hH : IsGridHamiltonian J hv he) |
| (hg : asMap (Hamiltonian hv he) Ω=(E₀:ℂ) • Ω) |
| (hgap : FullSystemGap (Hamiltonian hv he) Ω E₀ Δ) |
| (k : ℕ) (lo₁ lo₂ : ℤ) : |
| let M := 4*(2^(blocks q J Δ)+1) |
| vonNeumannEntropy Ω (box lo₁ lo₂ 1 (M^k)) ≤ |
| (Real.log q+4*bufferConstant q J Δ)*((M:ℝ)^2-2)^k := by |
| let M := 4*(2^(blocks q J Δ)+1) |
| let R : ℝ := (M:ℝ)^2-2 |
| let A := Real.log q+4*bufferConstant q J Δ |
| have hM : (4:ℝ)≤M := by |
| dsimp only [M] |
| exact_mod_cast (Nat.mul_le_mul_left 4 (Nat.succ_le_succ (Nat.zero_le (2^(blocks q J Δ))))) |
| have hMr : 0<(M:ℝ) := lt_of_lt_of_le (by norm_num) hM |
| have hMn : 0<M := by exact_mod_cast hMr |
| have hR : (M:ℝ)≤R := by dsimp [R]; nlinarith only [hM] |
| have hR0 : 0≤R := (le_of_lt hMr).trans hR |
| have hQ : 0≤Real.log q := Real.log_nonneg (by exact_mod_cast hq) |
| have hB : 0≤bufferConstant q J Δ := by dsimp [bufferConstant]; positivity |
| have hA : 0≤A := add_nonneg hQ (mul_nonneg (by norm_num) hB) |
| change vonNeumannEntropy Ω (box lo₁ lo₂ 1 (M^k))≤A*R^k |
| induction k generalizing lo₁ lo₂ with |
| | zero => |
| simp only [pow_zero,mul_one] |
| have hh := vonNeumannEntropy_le_card_log hq Ω hΩ (box lo₁ lo₂ 1 1) |
| have hn : ((box (L:=L) lo₁ lo₂ 1 1).card:ℝ)≤1 := by exact_mod_cast unit_box_card (L:=L) lo₁ lo₂ |
| have ht := mul_le_mul_of_nonneg_right hn hQ |
| dsimp only [A] |
| linarith only [hh,ht,hB] |
| | succ k ih => |
| have hf : ∀ i : Index M, vonNeumannEntropy Ω (tile lo₁ lo₂ (M^k) i)≤A*R^k := by |
| intro i |
| rw [tile_as_box] |
| exact ih _ _ |
| have hh := physical_three_child_gain hq J Δ E₀ hJ hΔ hv he Ω hΩ hH hg hgap lo₁ lo₂ |
| (M^k) (pow_pos hMn _) (A*R^k) (mul_nonneg hA (pow_nonneg hR0 _)) hf |
| change vonNeumannEntropy Ω (box lo₁ lo₂ 1 (M*M^k)) ≤ |
| ((M:ℝ)^2-3)*(A*R^k)+4*bufferConstant q J Δ*(M^k:ℕ) at hh |
| rw [pow_succ' M k] |
| apply hh.trans |
| push_cast |
| have hp : (M:ℝ)^k≤R^k := pow_le_pow_left₀ (le_of_lt hMr) hR k |
| have he := mul_le_mul_of_nonneg_left hp (mul_nonneg (by norm_num : (0:ℝ)≤4) hB) |
| have ha : 4*bufferConstant q J Δ≤A := by dsimp [A]; linarith only [hQ] |
| have he' := mul_le_mul_of_nonneg_right ha (pow_nonneg hR0 k) change _ ≤ A*R^(k+1) calc _ ≤ ((M:ℝ)^2-3)*(A*R^k)+A*R^k := add_le_add le_rfl (he.trans he') |
| _ = A*(R^k*R) := by dsimp only [R]; ring |
| _ = A*R^(k+1) := by rw [pow_succ R k] |
| |
| end PolynomialPEPS.Subvolume.RectangleTiling |
| |
| end |
| |
| end OAI |
| |
