| import OAI.Combinatorics.CycleDecomposition.ScaleExtraction |
|
|
| namespace OAI |
|
|
| universe u |
|
|
| universe cycleUniverse1 cycleUniverse2 cycleUniverse3 cycleUniverse4 cycleUniverse5 cycleUniverse6 |
|
|
| section |
| open Filter Asymptotics Real |
| open scoped Topology |
| noncomputable section |
| open MeasureTheory ProbabilityTheory Finset |
| section |
| namespace ErdosGallai.Scale |
| open Finset SimpleGraph Classical Real |
| variable {V : Type cycleUniverse1} [Fintype V] [DecidableEq V] |
|
|
| lemma edgeOccurrences_refine {I : Type cycleUniverse2} (L : List I) |
| (g : I → SimpleGraph V) (f : I → List (SimpleGraph V)) |
| (h : ∀ i ∈ L, GraphPartition (g i) (f i)) (x y : V) : |
| edgeOccurrences (L.flatMap f) x y = edgeOccurrences (L.map g) x y := by |
| induction L with |
| | nil => simp |
| | cons i L ih => |
| simp only [List.flatMap_cons, edgeOccurrences_append, List.map_cons, |
| edgeOccurrences_cons] |
| rw [h i (by simp), ih (fun j hj => h j (by simp [hj]))] |
|
|
| lemma graphPartition_refine {I : Type cycleUniverse3} {G : SimpleGraph V} |
| {C : List (SimpleGraph V)} {L : List I} |
| {g : I → SimpleGraph V} {f : I → List (SimpleGraph V)} |
| (hp : GraphPartition G (C ++ L.map g)) |
| (h : ∀ i ∈ L, GraphPartition (g i) (f i)) : |
| GraphPartition G (C ++ L.flatMap f) := by |
| intro x y |
| simpa only [edgeOccurrences_append, edgeOccurrences_refine L g f h] using hp x y |
|
|
| theorem scale_split : ∃ Dsp : ℝ, ∀ D ≥ Dsp, |
| ∀ (V : Type u) [Fintype V] [DecidableEq V] |
| (G : SimpleGraph V) (A : Finset V), A.Nonempty → SupportedOn G A → |
| 2*(edgeCount G : ℝ)/A.card ≤ D → |
| ∃ (C : List (SimpleGraph V)) (L : List (AssignedPiece V)) |
| (R : AssignedPiece V → List (AssignedPiece V)) |
| (H : AssignedPiece V → SimpleGraph V), |
| (∀ K ∈ C, IsCycleGraph K ∧ D^(101/100:ℝ) ≤ (edgeCount K : ℝ)) ∧ |
| (C.length : ℝ) ≤ A.card/(2*D^(1/100:ℝ)) ∧ |
| (∀ P ∈ L, P.vertices ⊆ A ∧ P.vertices.Nonempty ∧ |
| (P.vertices.card : ℝ) ≤ D^(51/50:ℝ)) ∧ |
| (∀ x ∈ A, ∃ P ∈ L, x ∈ P.vertices) ∧ |
| (L.map (fun P => (P.vertices.card : ℝ))).sum ≤ (1+2/logb 2 D)*A.card ∧ |
| (∀ P ∈ L, |
| (∀ Q ∈ R P, Q.vertices ⊆ P.vertices ∧ |
| D^(9/10:ℝ) ≤ Q.vertices.card ∧ |
| (Q.vertices.card:ℝ) ≤ D^(51/50:ℝ) ∧ |
| CutExpansionOn Q.graph Q.vertices (D^(9/10:ℝ))) ∧ |
| (R P).Pairwise (fun Q T => Disjoint Q.vertices T.vertices) ∧ |
| GraphPartition P.graph (H P :: (R P).map AssignedPiece.graph) ∧ |
| SupportedOn (H P) P.vertices ∧ |
| 2*(edgeCount (H P) : ℝ)/P.vertices.card ≤ D^(19/20:ℝ)) ∧ |
| GraphPartition G (C ++ L.flatMap (fun P => H P :: (R P).map AssignedPiece.graph)) := by |
| classical |
| obtain ⟨D₁,h₁⟩ := scale_boxes.{u} |
| obtain ⟨D₂,h₂⟩ := scale_cut_extraction.{u} |
| refine ⟨max D₁ D₂, ?_⟩ |
| intro D hD V _ _ G A hA hs hd |
| obtain ⟨C,L,hC,hCN,hL,hcover,hp,hcost⟩ := |
| h₁ D ((le_max_left _ _).trans hD) V G A hA hs hd |
| have hres : ∀ P : AssignedPiece V, |
| ∃ (R : List (AssignedPiece V)) (H : SimpleGraph V), P ∈ L → |
| (∀ Q ∈ R, Q.vertices ⊆ P.vertices ∧ |
| D^(9/10:ℝ) ≤ Q.vertices.card ∧ |
| (Q.vertices.card:ℝ) ≤ D^(51/50:ℝ) ∧ |
| CutExpansionOn Q.graph Q.vertices (D^(9/10:ℝ))) ∧ |
| R.Pairwise (fun Q T => Disjoint Q.vertices T.vertices) ∧ |
| GraphPartition P.graph (H :: R.map AssignedPiece.graph) ∧ |
| SupportedOn H P.vertices ∧ |
| 2*(edgeCount H : ℝ)/P.vertices.card ≤ D^(19/20:ℝ) := by |
| intro P |
| by_cases hP : P ∈ L |
| · obtain ⟨R,H,hgood⟩ := h₂ D ((le_max_right _ _).trans hD) V |
| P.graph P.vertices (hL P hP).2.1 P.supported (hL P hP).2.2 |
| exact ⟨R,H,fun _ => hgood⟩ |
| · exact ⟨[],⊥,fun hp => False.elim (hP hp)⟩ |
| choose R H hR using hres |
| refine ⟨C,L,R,H,hC,hCN,hL,hcover,hcost,hR,?_⟩ |
| exact graphPartition_refine hp (fun P hP => (hR P hP).2.2.1) |
|
|
| end ErdosGallai.Scale |
|
|
| namespace ErdosGallai.Scale |
| noncomputable section |
| open Real Filter Finset |
| open scoped Topology |
|
|
| def scaleTheta : ℝ := 19/20 |
| def inductionScale (n : ℝ) (j : ℕ) : ℝ := n ^ (scaleTheta ^ j) |
|
|
| lemma scaleTheta_pos : 0 < scaleTheta := by norm_num [scaleTheta] |
| lemma scaleTheta_lt_one : scaleTheta < 1 := by norm_num [scaleTheta] |
|
|
| lemma inductionScale_zero (n : ℝ) : inductionScale n 0 = n := by |
| simp [inductionScale] |
|
|
| lemma inductionScale_pos (n : ℝ) (hn : 0 < n) (j : ℕ) : |
| 0 < inductionScale n j := Real.rpow_pos_of_pos hn _ |
|
|
| lemma inductionScale_succ (n : ℝ) (hn : 0 ≤ n) (j : ℕ) : |
| inductionScale n (j+1) = (inductionScale n j) ^ scaleTheta := by |
| simp only [inductionScale, pow_succ, Real.rpow_mul hn] |
|
|
| lemma inductionScale_gt_one (n : ℝ) (hn : 1 < n) (j : ℕ) : |
| 1 < inductionScale n j := by |
| simpa [inductionScale] using Real.rpow_lt_rpow_of_exponent_lt hn |
| (pow_pos scaleTheta_pos j) |
|
|
| lemma inductionScale_le (n : ℝ) (hn : 1 ≤ n) (j : ℕ) : |
| inductionScale n j ≤ n := by |
| have hp : scaleTheta ^ j ≤ 1 := pow_le_one₀ scaleTheta_pos.le scaleTheta_lt_one.le |
| simpa [inductionScale] using Real.rpow_le_rpow_of_exponent_le hn hp |
|
|
| lemma inductionScale_log (n : ℝ) (hn : 0 < n) (j : ℕ) : |
| logb 2 (inductionScale n j) = scaleTheta ^ j * logb 2 n := by |
| exact Real.logb_rpow_eq_mul_logb_of_pos hn |
|
|
| lemma inductionScale_log_pos (n : ℝ) (hn : 1 < n) (j : ℕ) : |
| 0 < logb 2 (inductionScale n j) := by |
| exact Real.logb_pos (by norm_num) (inductionScale_gt_one n hn j) |
|
|
| lemma inductionScale_log_succ (n : ℝ) (hn : 0 < n) (j : ℕ) : |
| logb 2 (inductionScale n (j+1)) = scaleTheta * logb 2 (inductionScale n j) := by |
| rw [inductionScale_log n hn, inductionScale_log n hn, pow_succ] |
| ring |
|
|
| lemma inductionScale_add (n : ℝ) (hn : 0 ≤ n) (i K : ℕ) : |
| inductionScale n (i+K) = (inductionScale n i) ^ (scaleTheta ^ K) := by |
| simp only [inductionScale, pow_add, Real.rpow_mul hn] |
|
|
| lemma inductionScale_window : (51/50 : ℝ) * scaleTheta ^ 200 < 1/1000 ∧ |
| scaleTheta ^ 201 < 1/1000 := by |
| norm_num [scaleTheta] |
|
|
| lemma inductionScale_tendsto (n : ℝ) (hn : 0 < n) : |
| Tendsto (inductionScale n) atTop (𝓝 1) := by |
| have ht := (Real.continuous_const_rpow (ne_of_gt hn)).tendsto 0 |
| change Tendsto (fun j : ℕ => n ^ (scaleTheta ^ j)) atTop (𝓝 1) |
| simpa only [Function.comp_def, Real.rpow_zero] using |
| ht.comp (tendsto_pow_atTop_nhds_zero_of_lt_one scaleTheta_pos.le scaleTheta_lt_one) |
|
|
| theorem inductionScale_first_cutoff (n Dstar : ℝ) (hD : 1 < Dstar) (hn : Dstar ≤ n) : |
| ∃ m : ℕ, 0 < m ∧ inductionScale n m < Dstar ∧ |
| ∀ j < m, Dstar ≤ inductionScale n j := by |
| have hn0 : 0 < n := lt_trans (by norm_num) (hD.trans_le hn) |
| have he : ∀ᶠ j in atTop, inductionScale n j < Dstar := |
| (inductionScale_tendsto n hn0).eventually (gt_mem_nhds hD) |
| have hex : ∃ j, inductionScale n j < Dstar := he.exists |
| refine ⟨Nat.find hex, ?_, Nat.find_spec hex, ?_⟩ |
| · by_contra hm |
| have hz : Nat.find hex = 0 := by omega |
| have := Nat.find_spec hex |
| rw [hz, inductionScale_zero] at this |
| linarith |
| · intro j hj |
| exact le_of_not_gt (Nat.find_min hex hj) |
|
|
| theorem scale_reciprocal_log_sum (n : ℝ) (hn : 1 < n) (j : ℕ) : |
| (∑ l ∈ Finset.range (j+1), 1 / logb 2 (inductionScale n l)) ≤ |
| 20 / logb 2 (inductionScale n j) := by |
| induction j with |
| | zero => |
| simp only [zero_add, Finset.sum_range_succ, Finset.sum_range_zero, zero_add] |
| exact div_le_div_of_nonneg_right (by norm_num) (inductionScale_log_pos n hn 0).le |
| | succ j ih => |
| rw [Finset.sum_range_succ] |
| have hb : (∑ x ∈ range (j + 1), 1 / logb 2 (inductionScale n x)) + |
| 1 / logb 2 (inductionScale n (j+1)) ≤ |
| 20 / logb 2 (inductionScale n j) + 1 / logb 2 (inductionScale n (j+1)) := by |
| linarith [ih] |
| apply hb.trans_eq |
| rw [inductionScale_log_succ n (by linarith)] |
| have hz : logb 2 (inductionScale n j) ≠ 0 := ne_of_gt (inductionScale_log_pos n hn j) |
| dsimp [scaleTheta] |
| field_simp |
| ; ring |
|
|
| lemma exp_le_one_add_twice {x : ℝ} (hx : 0 ≤ x) (hxhalf : x ≤ 1/2) : |
| exp x ≤ 1+2*x := by |
| apply (Real.exp_bound_div_one_sub_of_interval hx (by linarith)).trans |
| apply (div_le_iff₀ (by linarith : 0 < 1-x)).mpr |
| nlinarith |
|
|
| theorem scale_overlap_product (n C₀ : ℝ) (hn : 1 < n) (hC : 0 ≤ C₀) (j : ℕ) |
| (hcut : 40*C₀ ≤ logb 2 (inductionScale n j)) : |
| (∏ l ∈ Finset.range (j+1), (1 + C₀ / logb 2 (inductionScale n l))) ≤ |
| 1 + 40*C₀ / logb 2 (inductionScale n j) := by |
| have hL := inductionScale_log_pos n hn j |
| have hsum : (∑ l ∈ Finset.range (j+1), C₀ / logb 2 (inductionScale n l)) ≤ |
| 20*C₀ / logb 2 (inductionScale n j) := by |
| have hh := mul_le_mul_of_nonneg_left (scale_reciprocal_log_sum n hn j) hC |
| calc |
| _ ≤ C₀ * (20 / logb 2 (inductionScale n j)) := by |
| simpa only [Finset.mul_sum, mul_one_div] using hh |
| _ = _ := by ring |
| calc |
| _ ≤ ∏ l ∈ Finset.range (j+1), exp (C₀ / logb 2 (inductionScale n l)) := by |
| apply Finset.prod_le_prod₀ |
| · intro l hl |
| have := div_nonneg hC (inductionScale_log_pos n hn l).le |
| linarith |
| · intro l hl |
| simpa [add_comm] using Real.add_one_le_exp (C₀ / logb 2 (inductionScale n l)) |
| _ = exp (∑ l ∈ Finset.range (j+1), C₀ / logb 2 (inductionScale n l)) := |
| (Real.exp_sum _ _).symm |
| _ ≤ exp (20*C₀ / logb 2 (inductionScale n j)) := Real.exp_le_exp.mpr hsum |
| _ ≤ 1 + 2*(20*C₀ / logb 2 (inductionScale n j)) := by |
| apply exp_le_one_add_twice (div_nonneg (by positivity) hL.le) |
| apply (div_le_iff₀ hL).mpr |
| linarith |
| _ = _ := by ring |
|
|
| theorem scale_prefix_cycle_cost (n : ℝ) (hn : 1 < n) (j : ℕ) (A : ℕ → ℝ) |
| (hA : ∀ l ∈ Finset.range (j+1), A l ≤ 2*n) |
| (hscale : ∀ l ∈ Finset.range (j+1), |
| 1 / (inductionScale n l) ^ (1/100 : ℝ) ≤ 1 / logb 2 (inductionScale n l)) : |
| (∑ l ∈ Finset.range (j+1), A l / (2*(inductionScale n l) ^ (1/100 : ℝ))) ≤ |
| 20*n / logb 2 (inductionScale n j) := by |
| have hn0 : 0 < n := by linarith |
| calc |
| _ ≤ ∑ l ∈ Finset.range (j+1), n * (1 / logb 2 (inductionScale n l)) := by |
| apply Finset.sum_le_sum |
| intro l hl |
| have hp : 0 < (inductionScale n l) ^ (1/100 : ℝ) := |
| Real.rpow_pos_of_pos (inductionScale_pos n hn0 l) _ |
| calc |
| _ ≤ 2*n / (2*(inductionScale n l) ^ (1/100 : ℝ)) := |
| div_le_div_of_nonneg_right (hA l hl) (by positivity) |
| _ = n * (1 / (inductionScale n l) ^ (1/100 : ℝ)) := by ring |
| _ ≤ _ := mul_le_mul_of_nonneg_left (hscale l hl) hn0.le |
| _ = n * (∑ l ∈ Finset.range (j+1), 1 / logb 2 (inductionScale n l)) := |
| (Finset.mul_sum _ _ _).symm |
| _ ≤ n * (20 / logb 2 (inductionScale n j)) := |
| mul_le_mul_of_nonneg_left (scale_reciprocal_log_sum n hn j) hn0.le |
| _ = _ := by ring |
|
|
| end |
| end ErdosGallai.Scale |
|
|
| namespace ErdosGallai.Scale |
| noncomputable section |
| open Finset SimpleGraph Real |
| attribute [local instance] Classical.propDecidable |
|
|
| variable {V : Type} [Fintype V] [DecidableEq V] |
|
|
| structure StageSplit (P : AssignedPiece V) where |
| cycles : List (SimpleGraph V) |
| boxes : List (AssignedPiece V) |
| pieces : AssignedPiece V → List (AssignedPiece V) |
| remainder : AssignedPiece V → SimpleGraph V |
| cycles_good : ∀ K ∈ cycles, IsCycleGraph K |
| box_subset : ∀ B ∈ boxes, B.vertices ⊆ P.vertices |
| box_nonempty : P.vertices.Nonempty → ∀ B ∈ boxes, B.vertices.Nonempty |
| box_cover : ∀ v ∈ P.vertices, ∃ B ∈ boxes, v ∈ B.vertices |
| piece_subset : ∀ B ∈ boxes, ∀ R ∈ pieces B, R.vertices ⊆ B.vertices |
| piece_disjoint : ∀ B ∈ boxes, (pieces B).Pairwise fun R S => Disjoint R.vertices S.vertices |
| remainder_supported : ∀ B ∈ boxes, SupportedOn (remainder B) B.vertices |
| box_partition : ∀ B ∈ boxes, GraphPartition B.graph (remainder B :: (pieces B).map AssignedPiece.graph) |
| partition : GraphPartition P.graph (cycles ++ boxes.map AssignedPiece.graph) |
|
|
| def StageSplit.Bounded {P : AssignedPiece V} (s : StageSplit P) (D : ℝ) : Prop := |
| (s.cycles.length:ℝ) ≤ P.vertices.card / (2*D^(1/100:ℝ)) ∧ |
| (s.boxes.map (fun B => (B.vertices.card:ℝ))).sum ≤ (1+2/logb 2 D)*P.vertices.card ∧ |
| (∀ B ∈ s.boxes, (B.vertices.card:ℝ) ≤ D^(51/50:ℝ)) ∧ |
| (∀ B ∈ s.boxes, ∀ R ∈ s.pieces B, |
| D^(9/10:ℝ) ≤ (R.vertices.card:ℝ) ∧ (R.vertices.card:ℝ) ≤ D^(51/50:ℝ) ∧ |
| CutExpansionOn R.graph R.vertices (D^(9/10:ℝ))) ∧ |
| (∀ B ∈ s.boxes, 2*(edgeCount (s.remainder B):ℝ)/B.vertices.card ≤ D^(19/20:ℝ)) |
|
|
| def StageSplit.trivial (P : AssignedPiece V) : StageSplit P where |
| cycles := [] |
| boxes := [P] |
| pieces := fun _ => [] |
| remainder := AssignedPiece.graph |
| cycles_good := by simp |
| box_subset := by simp |
| box_nonempty := by simp |
| box_cover := by intro v hv; exact ⟨P,by simp,hv⟩ |
| piece_subset := by simp |
| piece_disjoint := by simp |
| remainder_supported := fun B _ => B.supported |
| box_partition := by intro B _ x y; simp |
| partition := by intro x y; simp |
|
|
| theorem scale_splitter : ∃ Dsp : ℝ, ∀ (V : Type) [Fintype V] [DecidableEq V], |
| ∃ split : ∀ (_D : ℝ) (P : AssignedPiece V), StageSplit P, |
| ∀ D ≥ Dsp, ∀ P, P.vertices.Nonempty → |
| 2*(edgeCount P.graph:ℝ)/P.vertices.card ≤ D → (split D P).Bounded D := by |
| obtain ⟨Dsp,hsp⟩ := scale_split |
| refine ⟨Dsp,?_⟩ |
| intro V _ _ |
| have hex (D : ℝ) (P : AssignedPiece V) : ∃ s : StageSplit P, |
| Dsp ≤ D → P.vertices.Nonempty → 2*(edgeCount P.graph:ℝ)/P.vertices.card ≤ D → s.Bounded D := by |
| by_cases h : Dsp ≤ D ∧ P.vertices.Nonempty ∧ 2*(edgeCount P.graph:ℝ)/P.vertices.card ≤ D |
| · obtain ⟨C,L,R,H,hC,hCl,hL,hcover,horder,hR,hpart⟩ := |
| hsp D h.1 V P.graph P.vertices h.2.1 P.supported h.2.2 |
| have hpart' : GraphPartition P.graph (C ++ L.map AssignedPiece.graph) := by |
| intro x y |
| rw [edgeOccurrences_append, ← edgeOccurrences_refine L AssignedPiece.graph |
| (fun B => H B :: (R B).map AssignedPiece.graph) (fun B hB => (hR B hB).2.2.1)] |
| simpa only [edgeOccurrences_append] using hpart x y |
| let s : StageSplit P := { |
| cycles := C, boxes := L, pieces := R, remainder := H |
| cycles_good := fun K hK => (hC K hK).1 |
| box_subset := fun B hB => (hL B hB).1 |
| box_nonempty := fun _ B hB => (hL B hB).2.1 |
| box_cover := hcover |
| piece_subset := fun B hB Q hQ => (hR B hB).1 Q hQ |>.1 |
| piece_disjoint := fun B hB => (hR B hB).2.1 |
| remainder_supported := fun B hB => (hR B hB).2.2.2.1 |
| box_partition := fun B hB => (hR B hB).2.2.1 |
| partition := hpart' } |
| refine ⟨s,fun _ _ _ => ⟨hCl,horder,fun B hB => (hL B hB).2.2,?_,?_⟩⟩ |
| · exact fun B hB Q hQ => (hR B hB).1 Q hQ |>.2 |
| · exact fun B hB => (hR B hB).2.2.2.2 |
| · exact ⟨StageSplit.trivial P,fun hD hP hdeg => False.elim (h ⟨hD,hP,hdeg⟩)⟩ |
| choose s hs using hex |
| exact ⟨s,fun D hD P hP hdeg => hs D P hD hP hdeg⟩ |
|
|
| def StageSplit.children {P : AssignedPiece V} (s : StageSplit P) : List (AssignedPiece V) := |
| s.boxes.pmap (fun B hB => ⟨B.vertices,s.remainder B,s.remainder_supported B hB⟩) (fun _ h => h) |
|
|
| lemma StageSplit.mem_children {V : Type} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] {P : AssignedPiece V} (s : StageSplit P) (Q : AssignedPiece V) : |
| Q ∈ s.children ↔ ∃ B ∈ s.boxes, Q.vertices = B.vertices ∧ Q.graph = s.remainder B := by |
| simp only [StageSplit.children, List.mem_pmap] |
| constructor |
| · rintro ⟨B,hB,rfl⟩; exact ⟨B,hB,rfl,rfl⟩ |
| · rintro ⟨B,hB,hv,hg⟩ |
| refine ⟨B,hB,?_⟩ |
| cases Q; cases B; simp_all |
|
|
| lemma StageSplit.children_map {V : Type} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] {P : AssignedPiece V} (s : StageSplit P) |
| {α : Type cycleUniverse4} (f : Finset V → SimpleGraph V → α) : |
| s.children.map (fun Q => f Q.vertices Q.graph) = |
| s.boxes.map (fun B => f B.vertices (s.remainder B)) := by |
| unfold StageSplit.children |
| rw [List.map_pmap] |
| change List.pmap (fun B (_ : B ∈ s.boxes) => f B.vertices (s.remainder B)) s.boxes _ = _ |
| exact List.pmap_eq_map (fun B (h : B ∈ s.boxes) => h) |
|
|
| lemma list_disjoint_card_le {V : Type} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (L : List (Finset V)) (A : Finset V) |
| (hd : L.Pairwise Disjoint) (hA : ∀ B ∈ L, B ⊆ A) : |
| (L.map Finset.card).sum ≤ A.card := by |
| induction L generalizing A with |
| | nil => simp |
| | cons B L ih => |
| obtain ⟨hBL,hd⟩ := List.pairwise_cons.mp hd |
| have hBA := hA B (by simp) |
| have hLA : ∀ C ∈ L, C ⊆ A \ B := by |
| intro C hC v hv |
| exact Finset.mem_sdiff.mpr ⟨hA C (by simp [hC]) hv, |
| fun hb => Finset.disjoint_left.mp (hBL C hC) hb hv⟩ |
| have hh := ih (A \ B) hd hLA |
| have hc := Finset.card_sdiff_of_subset hBA |
| have hBAcard := Finset.card_le_card hBA |
| simp only [List.map_cons,List.sum_cons] |
| omega |
|
|
| def vertexMass (L : List (AssignedPiece V)) : ℝ := |
| (L.map (fun P => (P.vertices.card:ℝ))).sum |
|
|
| lemma vertexMass_nonneg {V : Type} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (L : List (AssignedPiece V)) : 0 ≤ vertexMass L := |
| List.sum_nonneg (fun x hx => by obtain ⟨P,_,rfl⟩ := List.mem_map.mp hx; positivity) |
|
|
| @[simp] lemma vertexMass_nil {V : Type} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] : vertexMass ([] : List (AssignedPiece V)) = 0 := rfl |
| @[simp] lemma vertexMass_cons {V : Type} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (P : AssignedPiece V) (L) : |
| vertexMass (P::L) = P.vertices.card + vertexMass L := rfl |
| @[simp] lemma vertexMass_append {V : Type} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (L M : List (AssignedPiece V)) : |
| vertexMass (L++M) = vertexMass L + vertexMass M := by simp [vertexMass] |
| lemma vertexMass_flatMap {I : Type cycleUniverse5} (L : List I) (f : I → List (AssignedPiece V)) : |
| vertexMass (L.flatMap f) = (L.map (fun i => vertexMass (f i))).sum := by |
| induction L with |
| | nil => simp |
| | cons i L ih => simp [ih] |
|
|
| lemma StageSplit.children_mass {P : AssignedPiece V} (s : StageSplit P) : |
| vertexMass s.children = vertexMass s.boxes := by |
| unfold vertexMass |
| rw [s.children_map (fun A _ => (A.card:ℝ))] |
|
|
| lemma StageSplit.pieces_mass {P : AssignedPiece V} (s : StageSplit P) {B : AssignedPiece V} |
| (hB : B ∈ s.boxes) : vertexMass (s.pieces B) ≤ B.vertices.card := by |
| have hh := list_disjoint_card_le ((s.pieces B).map AssignedPiece.vertices) B.vertices |
| (List.pairwise_map.mpr (s.piece_disjoint B hB)) (by |
| intro A hA; obtain ⟨Q,hQ,rfl⟩ := List.mem_map.mp hA |
| exact s.piece_subset B hB Q hQ) |
| simpa [vertexMass,List.map_map,Function.comp_def] using (Nat.cast_le.mpr hh : (_:ℝ) ≤ _) |
|
|
| end |
| end ErdosGallai.Scale |
|
|
| namespace ErdosGallai.Scale |
| noncomputable section |
| open Finset SimpleGraph Real |
| attribute [local instance] Classical.propDecidable |
| variable {V : Type} [Fintype V] [DecidableEq V] |
|
|
| abbrev SplitSystem (V : Type) [Fintype V] [DecidableEq V] := |
| ℕ → (P : AssignedPiece V) → StageSplit P |
|
|
| def nextLayer (s : SplitSystem V) (j : ℕ) (L : List (AssignedPiece V)) : List (AssignedPiece V) := |
| L.flatMap fun P => (s j P).children |
|
|
| def advance (s : SplitSystem V) (j : ℕ) : ℕ → List (AssignedPiece V) → List (AssignedPiece V) |
| | 0,L => L |
| | k+1,L => nextLayer s (j+k) (advance s j k L) |
|
|
| @[simp] lemma advance_zero (s : SplitSystem V) (j) (L) : advance s j 0 L = L := rfl |
| @[simp] lemma advance_succ (s : SplitSystem V) (j k) (L) : |
| advance s j (k+1) L = nextLayer s (j+k) (advance s j k L) := rfl |
|
|
| lemma advance_add (s : SplitSystem V) (j k l) (L) : |
| advance s j (k+l) L = advance s (j+k) l (advance s j k L) := by |
| induction l with |
| | zero => simp |
| | succ l ih => simp only [Nat.add_succ,advance_succ,ih,Nat.add_assoc] |
|
|
| lemma advance_flatMap (s : SplitSystem V) (j k) {I : Type cycleUniverse6} |
| (L : List I) (f : I → List (AssignedPiece V)) : |
| advance s j k (L.flatMap f) = L.flatMap (fun i => advance s j k (f i)) := by |
| induction k with |
| | zero => rfl |
| | succ k ih => simp only [advance_succ,nextLayer,ih,List.flatMap_assoc] |
|
|
| lemma nextLayer_mem (s : SplitSystem V) (j) (L) (Q : AssignedPiece V) : |
| Q ∈ nextLayer s j L ↔ ∃ P ∈ L, ∃ B ∈ (s j P).boxes, |
| Q.vertices = B.vertices ∧ Q.graph = (s j P).remainder B := by |
| simp only [nextLayer,List.mem_flatMap,StageSplit.mem_children] |
|
|
| lemma advance_subset (s : SplitSystem V) (j k) (L) (A : Finset V) |
| (hA : ∀ P ∈ L, P.vertices ⊆ A) : |
| ∀ Q ∈ advance s j k L, Q.vertices ⊆ A := by |
| induction k with |
| | zero => exact hA |
| | succ k ih => |
| intro Q hQ |
| obtain ⟨P,hP,B,hB,hv,_⟩ := (nextLayer_mem s (j+k) _ Q).mp hQ |
| rw [hv] |
| exact ((s (j+k) P).box_subset B hB).trans (ih P hP) |
|
|
| lemma advance_nonempty (s : SplitSystem V) (j k) (L) |
| (hL : ∀ P ∈ L, P.vertices.Nonempty) : |
| ∀ Q ∈ advance s j k L, Q.vertices.Nonempty := by |
| induction k with |
| | zero => exact hL |
| | succ k ih => |
| intro Q hQ |
| obtain ⟨P,hP,B,hB,hv,_⟩ := (nextLayer_mem s (j+k) _ Q).mp hQ |
| rw [hv] |
| exact (s (j+k) P).box_nonempty (ih P hP) B hB |
|
|
| lemma advance_cover (s : SplitSystem V) (j k) (L) (P : AssignedPiece V) (hP : P ∈ L) |
| (v : V) (hv : v ∈ P.vertices) : ∃ Q ∈ advance s j k L, v ∈ Q.vertices := by |
| induction k with |
| | zero => exact ⟨P,hP,hv⟩ |
| | succ k ih => |
| obtain ⟨Q,hQ,hvQ⟩ := ih |
| obtain ⟨B,hB,hvB⟩ := (s (j+k) Q).box_cover v hvQ |
| let T : AssignedPiece V := ⟨B.vertices,(s (j+k) Q).remainder B, |
| (s (j+k) Q).remainder_supported B hB⟩ |
| exact ⟨T,(nextLayer_mem s (j+k) _ T).mpr ⟨Q,hQ,B,hB,rfl,rfl⟩,hvB⟩ |
|
|
| lemma list_union_mem {V : Type} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (L : List (AssignedPiece V)) (v : V) : |
| v ∈ L.foldr (fun (P : AssignedPiece V) (U : Finset V) => P.vertices ∪ U) ∅ ↔ ∃ P ∈ L, v ∈ P.vertices := by |
| induction L with |
| | nil => simp |
| | cons P L ih => |
| simp only [List.foldr_cons,Finset.mem_union,ih,List.mem_cons] |
| aesop |
|
|
| lemma list_union_card {V : Type} [_contextInstance1 : Fintype V] [_contextInstance2 : DecidableEq V] (L : List (AssignedPiece V)) : |
| ((L.foldr (fun (P : AssignedPiece V) (U : Finset V) => P.vertices ∪ U) ∅).card:ℝ) ≤ vertexMass L := by |
| induction L with |
| | nil => simp |
| | cons P L ih => |
| simp only [List.foldr_cons,vertexMass_cons] |
| have hc := Finset.card_union_le P.vertices (L.foldr (fun (P : AssignedPiece V) (U : Finset V) => P.vertices ∪ U) ∅) |
| have hc' : ((P.vertices ∪ L.foldr (fun (P : AssignedPiece V) (U : Finset V) => P.vertices ∪ U) ∅).card:ℝ) ≤ |
| P.vertices.card + (L.foldr (fun (P : AssignedPiece V) (U : Finset V) => P.vertices ∪ U) ∅).card := by exact_mod_cast hc |
| linarith |
|
|
| lemma list_cover_card_le (L : List (AssignedPiece V)) (A : Finset V) |
| (hcover : ∀ v ∈ A, ∃ P ∈ L, v ∈ P.vertices) : (A.card:ℝ) ≤ vertexMass L := by |
| have hsub : A ⊆ L.foldr (fun (P : AssignedPiece V) (U : Finset V) => P.vertices ∪ U) ∅ := |
| fun v hv => (list_union_mem L v).mpr (hcover v hv) |
| exact (Nat.cast_le.mpr (Finset.card_le_card hsub)).trans (list_union_card L) |
|
|
| lemma advance_mass_lower (s : SplitSystem V) (j k) (P : AssignedPiece V) : |
| (P.vertices.card:ℝ) ≤ vertexMass (advance s j k [P]) := |
| list_cover_card_le _ _ (fun v hv => advance_cover s j k [P] P (by simp) v hv) |
|
|
| lemma nextLayer_mass_bound (s : SplitSystem V) (j) (L : List (AssignedPiece V)) (D : ℝ) |
| (hb : ∀ P ∈ L, (s j P).Bounded D) : |
| vertexMass (nextLayer s j L) ≤ (1+2/logb 2 D)*vertexMass L := by |
| induction L with |
| | nil => simp [nextLayer] |
| | cons P L ih => |
| have hP := (hb P (by simp)).2.1 |
| have hL := ih (fun Q hQ => hb Q (by simp [hQ])) |
| simp only [nextLayer,List.flatMap_cons,vertexMass_append,StageSplit.children_mass, |
| vertexMass_cons] at hL ⊢ |
| change vertexMass (s j P).boxes ≤ _ at hP |
| nlinarith |
|
|
| lemma advance_valid (s : SplitSystem V) (n Dstar : ℝ) (hn : 0 ≤ n) |
| (hs : ∀ l P, Dstar ≤ inductionScale n l → P.vertices.Nonempty → |
| 2*(edgeCount P.graph:ℝ)/P.vertices.card ≤ inductionScale n l → |
| (s l P).Bounded (inductionScale n l)) |
| (j k : ℕ) (L : List (AssignedPiece V)) |
| (hL : ∀ P ∈ L, P.vertices.Nonempty) |
| (hdeg : ∀ P ∈ L, 2*(edgeCount P.graph:ℝ)/P.vertices.card ≤ inductionScale n j) |
| (hcut : ∀ l, j ≤ l → l < j+k → Dstar ≤ inductionScale n l) : |
| ∀ P ∈ advance s j k L, |
| 2*(edgeCount P.graph:ℝ)/P.vertices.card ≤ inductionScale n (j+k) := by |
| induction k with |
| | zero => simpa using hdeg |
| | succ k ih => |
| intro Q hQ |
| obtain ⟨P,hP,B,hB,hv,hg⟩ := (nextLayer_mem s (j+k) _ Q).mp hQ |
| have hPdeg := ih (fun l hlj hl => hcut l hlj (by omega)) P hP |
| have hb := hs (j+k) P (hcut (j+k) (by omega) (by omega)) |
| (advance_nonempty s j k L hL P hP) hPdeg |
| rw [hv,hg,show j+(k+1) = (j+k)+1 by omega,inductionScale_succ n hn] |
| exact hb.2.2.2.2 B hB |
|
|
| lemma advance_bounded (s : SplitSystem V) (n Dstar : ℝ) (hn : 0 ≤ n) |
| (hs : ∀ l P, Dstar ≤ inductionScale n l → P.vertices.Nonempty → |
| 2*(edgeCount P.graph:ℝ)/P.vertices.card ≤ inductionScale n l → |
| (s l P).Bounded (inductionScale n l)) |
| (j k : ℕ) (L : List (AssignedPiece V)) |
| (hL : ∀ P ∈ L, P.vertices.Nonempty) |
| (hdeg : ∀ P ∈ L, 2*(edgeCount P.graph:ℝ)/P.vertices.card ≤ inductionScale n j) |
| (hcut : ∀ l, j ≤ l → l ≤ j+k → Dstar ≤ inductionScale n l) : |
| ∀ P ∈ advance s j k L, (s (j+k) P).Bounded (inductionScale n (j+k)) := by |
| intro P hP |
| exact hs (j+k) P (hcut _ (by omega) (by omega)) (advance_nonempty s j k L hL P hP) |
| (advance_valid s n Dstar hn hs j k L hL hdeg (fun l hlj hl => hcut l hlj (by omega)) P hP) |
|
|
| lemma advance_mass_global_product (s : SplitSystem V) (n : ℝ) (hn : 1 < n) |
| (j k : ℕ) (L : List (AssignedPiece V)) |
| (hb : ∀ l < k, ∀ P ∈ advance s j l L, (s (j+l) P).Bounded (inductionScale n (j+l))) : |
| vertexMass (advance s j k L) ≤ vertexMass L * |
| ∏ l ∈ Finset.range (j+k), (1+2/logb 2 (inductionScale n l)) := by |
| have hfac (l) : 1 ≤ 1+2/logb 2 (inductionScale n l) := by |
| have := div_nonneg (by norm_num : (0:ℝ) ≤ 2) (inductionScale_log_pos n hn l).le |
| linarith |
| induction k with |
| | zero => |
| simp only [advance_zero,Nat.add_zero] |
| exact le_mul_of_one_le_right (vertexMass_nonneg L) (Finset.one_le_prod₀ (fun l _ => hfac l)) |
| | succ k ih => |
| have hm := nextLayer_mass_bound s (j+k) (advance s j k L) (inductionScale n (j+k)) |
| (hb k (by omega)) |
| have hi := mul_le_mul_of_nonneg_left (ih (fun l hl => hb l (by omega))) ((hfac (j+k)).trans' (by norm_num : (0:ℝ) ≤ 1)) |
| rw [advance_succ,show j+(k+1) = (j+k)+1 by omega,Finset.prod_range_succ] |
| calc |
| _ ≤ (1+2/logb 2 (inductionScale n (j+k))) * vertexMass (advance s j k L) := hm |
| _ ≤ _ := by nlinarith only [hi] |
|
|
| end |
| end ErdosGallai.Scale |
| end |
| end |
| end |
|
|
| end OAI |
|
|
