| import OAI.Combinatorics.ListHadwiger.StageSampling |
|
|
| namespace OAI |
|
|
| namespace LinearListHadwiger.SmallList |
| open Finset Filter |
|
|
| noncomputable def rate (t : ℝ) (j : ℕ) : ℝ := 4*t/(2:ℝ)^j |
| noncomputable def bins (t : ℝ) (j : ℕ) : ℕ := |
| ⌈192*rate t j*Real.log (2*max 1 (t/rate t j))⌉₊ |
|
|
| lemma rate_pos {t : ℝ} (ht : 0 < t) (j : ℕ) : 0 < rate t j := by |
| unfold rate |
| positivity |
|
|
| lemma rate_zero (t : ℝ) : rate t 0=4*t := by simp [rate] |
| lemma rate_succ (t : ℝ) (j : ℕ) : rate t (j+1)=rate t j/2 := by |
| simp only [rate,pow_succ] |
| ring |
|
|
| lemma rate_le {t : ℝ} (ht : 0 ≤ t) (j : ℕ) : rate t j ≤ 4*t := by |
| exact div_le_self (by positivity) (one_le_pow₀ (by norm_num)) |
|
|
| lemma geometric_budget (m : ℕ) : |
| ∑ j ∈ range m, ((j:ℝ)+1)/(2:ℝ)^j ≤ 4 := by |
| have he : (∑ j ∈ range m, ((j:ℝ)+1)/(2:ℝ)^j)+2*((m:ℝ)+2)/(2:ℝ)^m=4 := by |
| induction m with |
| | zero => norm_num |
| | succ m ih => |
| rw [sum_range_succ] |
| push_cast |
| rw [pow_succ] |
| calc |
| _ = (∑ j ∈ range m, ((j:ℝ)+1)/(2:ℝ)^j)+2*((m:ℝ)+2)/(2:ℝ)^m := by ring |
| _ = 4 := ih |
| have : 0 ≤ 2*((m:ℝ)+2)/(2:ℝ)^m := by positivity |
| linarith |
|
|
| lemma bins_upper {t : ℝ} (ht : 0 < t) (j : ℕ) : |
| (bins t j : ℝ) ≤ 768*t*(((j:ℝ)+1)/(2:ℝ)^j)+1 := by |
| have hp : 1 ≤ (2:ℝ)^j := one_le_pow₀ (by norm_num) |
| have he : t/rate t j=(2:ℝ)^j/4 := by unfold rate; field_simp |
| have hy : max 1 (t/rate t j) ≤ (2:ℝ)^j := by rw [he]; exact max_le hp (by linarith) |
| have hy0 : 0 < 2*max 1 (t/rate t j) := by have := le_max_left 1 (t/rate t j); linarith |
| have hl : Real.log (2*max 1 (t/rate t j)) ≤ (j:ℝ)+1 := by |
| calc |
| _ ≤ Real.log ((2:ℝ)^(j+1)) := Real.log_le_log hy0 (by rw [pow_succ]; nlinarith) |
| _ = ((j:ℝ)+1)*Real.log 2 := by rw [Real.log_pow]; push_cast; rfl |
| _ ≤ _ := by nlinarith [Real.log_two_lt_d9] |
| have hnonneg : 0 ≤ 192*rate t j*Real.log (2*max 1 (t/rate t j)) := by |
| have hh : 1 ≤ 2*max 1 (t/rate t j) := by have := le_max_left 1 (t/rate t j); linarith |
| exact mul_nonneg (by positivity [rate_pos ht j]) (Real.log_nonneg hh) |
| have hb := (Nat.ceil_lt_add_one hnonneg).le |
| change (bins t j:ℝ) ≤ _ at hb |
| calc |
| _ ≤ 192*rate t j*Real.log (2*max 1 (t/rate t j))+1 := hb |
| _ ≤ 192*rate t j*((j:ℝ)+1)+1 := by gcongr; have := rate_pos ht j; positivity |
| _ = _ := by unfold rate; ring |
|
|
| lemma bins_lower {t : ℝ} (ht : 1 < t) (j : ℕ) |
| (hr : t/Real.log t ≤ rate t j) : t/Real.log t ≤ (bins t j:ℝ) := by |
| have ht0 : 0 < t := by linarith |
| have hl0 : 0 < Real.log t := Real.log_pos ht |
| have hlog : Real.log 2 ≤ Real.log (2*max 1 (t/rate t j)) := |
| Real.log_le_log (by norm_num) (by have := le_max_left 1 (t/rate t j); linarith) |
| have hlg : 1 ≤ 192*Real.log (2*max 1 (t/rate t j)) := by linarith [Real.log_two_gt_d9] |
| calc |
| _ ≤ rate t j := hr |
| _ ≤ 192*rate t j*Real.log (2*max 1 (t/rate t j)) := by nlinarith [rate_pos ht0 j] |
| _ ≤ (bins t j:ℝ) := Nat.le_ceil _ |
|
|
| lemma power_two_lower (m : ℕ) : (m:ℝ)+1 ≤ (2:ℝ)^m := by |
| induction m with |
| | zero => norm_num |
| | succ m ih => rw [pow_succ]; push_cast; nlinarith |
|
|
| theorem schedule_cutoff : ∀ᶠ t : ℝ in atTop, |
| 1 < t ∧ 1 ≤ Real.log t ∧ 4*Real.log t ≤ t ∧ |
| t^(7/10:ℝ) ≤ t/Real.log t := by |
| have hl := (Real.isLittleO_log_id_atTop).bound (show (0:ℝ)<1/4 by norm_num) |
| have hp := (isLittleO_log_rpow_rpow_atTop (1:ℝ) |
| (show (0:ℝ)<3/10 by norm_num)).bound (show (0:ℝ)<1 by norm_num) |
| have hg := Real.tendsto_log_atTop.eventually (eventually_ge_atTop (1:ℝ)) |
| filter_upwards [eventually_gt_atTop (1:ℝ),hl,hp,hg] with t ht hl hp hg |
| have ht0 : 0<t := by linarith |
| have hg0 : 0<Real.log t := by linarith |
| have hl' : Real.log t ≤ (1/4:ℝ)*t := by |
| simpa only [id_eq,Real.norm_eq_abs,abs_of_pos hg0,abs_of_pos ht0] using hl |
| have hp' : Real.log t ≤ t^(3/10:ℝ) := by |
| simpa only [Real.rpow_one,Real.norm_eq_abs,abs_of_pos hg0, |
| abs_of_nonneg (Real.rpow_nonneg ht0.le (3/10:ℝ)),one_mul] using hp |
| refine ⟨ht,hg,by linarith,?_⟩ |
| apply (le_div_iff₀ hg0).mpr |
| calc |
| _ ≤ t^(7/10:ℝ)*t^(3/10:ℝ) := mul_le_mul_of_nonneg_left hp' (by positivity) |
| _ = t := by rw [←Real.rpow_add ht0]; norm_num |
|
|
| theorem schedule_exists (t : ℕ) (ht : 1 < (t:ℝ)) |
| (hl : 1 ≤ Real.log t) (hlog : 4*Real.log t ≤ t) |
| (hp : (t:ℝ)^(7/10:ℝ) ≤ (t:ℝ)/Real.log t) : |
| ∃ m : ℕ, m ≤ t ∧ rate t m < (t:ℝ)/Real.log t ∧ |
| (∀ j < m, (t:ℝ)/Real.log t ≤ rate t j ∧ rate t j ≤ 4*t) ∧ |
| (∑ j ∈ range m, bins t j)+16*t ≤ 4096*t ∧ |
| (∀ j < m, (t:ℝ)^(7/10:ℝ) ≤ (bins t j:ℝ)) ∧ |
| (t:ℝ)^(7/10:ℝ) ≤ 16*t := by |
| have ht0 : 0 < (t:ℝ) := by linarith |
| have hl0 : 0 < Real.log t := by linarith |
| have hlast : rate t t < (t:ℝ)/Real.log t := by |
| dsimp [rate] |
| apply (div_lt_div_iff₀ (by positivity) hl0).mpr |
| have hh := power_two_lower t |
| nlinarith |
| let m := Nat.find (show ∃ m, rate t m < (t:ℝ)/Real.log t from ⟨t,hlast⟩) |
| have hm : m ≤ t := Nat.find_min' _ hlast |
| have hterm : rate t m < (t:ℝ)/Real.log t := |
| Nat.find_spec (show ∃ m, rate t m < (t:ℝ)/Real.log t from ⟨t,hlast⟩) |
| have hvalid : ∀ j < m, (t:ℝ)/Real.log t ≤ rate t j := by |
| intro j hj |
| exact le_of_not_gt (Nat.find_min (show ∃ m, rate t m < (t:ℝ)/Real.log t from ⟨t,hlast⟩) hj) |
| refine ⟨m,hm,hterm,fun j hj => ⟨hvalid j hj,rate_le ht0.le j⟩,?_,?_,?_⟩ |
| · apply (Nat.cast_le (α := ℝ)).mp |
| push_cast |
| have hs : (∑ j ∈ range m, (bins t j:ℝ)) ≤ 3072*t+(m:ℝ) := by |
| calc |
| _ ≤ ∑ j ∈ range m, (768*(t:ℝ)*(((j:ℝ)+1)/(2:ℝ)^j)+1) := |
| sum_le_sum fun j _ => bins_upper ht0 j |
| _ = 768*(t:ℝ)*(∑ j ∈ range m, ((j:ℝ)+1)/(2:ℝ)^j)+(m:ℝ) := by |
| rw [sum_add_distrib,←mul_sum]; simp |
| _ ≤ _ := by have := geometric_budget m; nlinarith |
| have hm' : (m:ℝ) ≤ t := by exact_mod_cast hm |
| nlinarith |
| · exact fun j hj => hp.trans (bins_lower ht j (hvalid j hj)) |
| · exact hp.trans ((div_le_self ht0.le hl).trans (by nlinarith)) |
|
|
| theorem palette_tail_cutoff : ∀ᶠ t : ℝ in atTop, |
| ∀ (n b j : ℕ) (u : Fin j → ℕ), n ≤ t^(11/10:ℝ) → 1 ≤ b → |
| (b:ℝ) ≤ 4096*t → (j:ℝ) ≤ t+1 → |
| (∀ i, t^(7/10:ℝ) ≤ (u i:ℝ)) → |
| (n:ℝ)*(∑ i, (2:ℝ)^(u i)*Real.exp (-(32768*t)*(u i)/(2*b))) < 1 := by |
| have hh := Sampling.polynomial_tail_cutoff 1 (21/10) (show (0:ℝ)<1 by norm_num) |
| filter_upwards [eventually_ge_atTop (1:ℝ),hh] with t ht hh |
| intro n b j u hn hb hb' hj hu |
| have ht0 : 0<t := by linarith |
| have hb0 : 0 < (b:ℝ) := by exact_mod_cast (by omega : 0 < b) |
| have hratio : 4 ≤ (32768*t)/(2*b) := (le_div_iff₀ (by positivity)).mpr (by nlinarith) |
| have hterm (i : Fin j) : (2:ℝ)^(u i)*Real.exp (-(32768*t)*(u i)/(2*b)) ≤ |
| Real.exp (-t^(7/10:ℝ)) := by |
| have he : (2:ℝ)^(u i)=Real.exp ((u i:ℝ)*Real.log 2) := by |
| rw [Real.exp_nat_mul,Real.exp_log (by norm_num : (0:ℝ)<2)] |
| rw [he,←Real.exp_add] |
| apply Real.exp_le_exp.mpr |
| have he' : -(32768*t)*(u i)/(2*b)= -((32768*t)/(2*b))*(u i) := by ring |
| rw [he'] |
| have hlog : Real.log 2 ≤ 1 := by linarith [Real.log_two_lt_d9] |
| have hmul := mul_le_mul_of_nonneg_right hratio (Nat.cast_nonneg (u i)) |
| have hmul' := mul_le_mul_of_nonneg_left hlog (Nat.cast_nonneg (u i)) |
| nlinarith [hu i] |
| calc |
| _ ≤ (n:ℝ)*(∑ _i : Fin j, Real.exp (-t^(7/10:ℝ))) := by gcongr with i; exact hterm i |
| _ = (n:ℝ)*((j:ℝ)*Real.exp (-t^(7/10:ℝ))) := by simp [nsmul_eq_mul] |
| _ ≤ t^(11/10:ℝ)*((2*t)*Real.exp (-t^(7/10:ℝ))) := by gcongr; linarith |
| _ = 1*t^(21/10:ℝ)*(2*Real.exp (-t^(7/10:ℝ))) := by |
| have he : t^(11/10:ℝ)*t=t^(21/10:ℝ) := by |
| calc |
| _ = t^(11/10:ℝ)*t^(1:ℝ) := by rw [Real.rpow_one] |
| _ = _ := by rw [←Real.rpow_add ht0]; norm_num |
| rw [show t^(11/10:ℝ)*((2*t)*Real.exp (-t^(7/10:ℝ))) = |
| 2*(t^(11/10:ℝ)*t)*Real.exp (-t^(7/10:ℝ)) by ring,he] |
| ring |
| _ < 1 := hh |
|
|
| end LinearListHadwiger.SmallList |
|
|
| namespace LinearListHadwiger.SmallList |
| open Finset Fractional |
| attribute [local instance] Classical.propDecidable |
| variable {V : Type} [Fintype V] [DecidableEq V] |
|
|
| def FractionalObstruction (G : SimpleGraph V) : Prop := |
| ∃ S : Finset V, 4*(hadwigerNumber (G.induce (↑S:Set V)):ℝ) < |
| number (G.induce (↑S:Set V)) |
|
|
| noncomputable def singletonModel {W : Type} (G : SimpleGraph V) (H : SimpleGraph W) |
| (f : W → V) (hf : Function.Injective f) |
| (ha : ∀ ⦃u v⦄, H.Adj u v → G.Adj (f u) (f v)) : MinorModel G H where |
| branch w := {f w} |
| connected w := by |
| have : Nonempty ({f w}:Set V) := ⟨⟨f w,rfl⟩⟩ |
| exact SimpleGraph.Connected.of_subsingleton |
| disjoint u v hn := Set.disjoint_singleton.mpr (fun he => hn (hf he)) |
| adjacent := by intro u v h; exact ⟨_,rfl,_,rfl,ha h⟩ |
|
|
| lemma number_iso {W : Type} [Fintype W] [DecidableEq W] |
| {G : SimpleGraph V} {H : SimpleGraph W} (e : G ≃g H) : number G=number H := by |
| apply le_antisymm |
| · have he : G=H.comap e := by ext u v; exact e.map_adj_iff.symm |
| rw [he] |
| exact number_comap H e |
| · have he : H=G.comap e.symm := by ext u v; exact e.symm.map_adj_iff.symm |
| rw [he] |
| exact number_comap G e.symm |
|
|
| noncomputable def induceImageIso (G : SimpleGraph V) (R : Finset V) |
| (A : Finset (↑R:Set V)) : |
| (G.induce (↑R:Set V)).induce (↑A:Set (↑R:Set V)) ≃g |
| G.induce (↑(A.image Subtype.val):Set V) where |
| toFun a := ⟨a.val.val,mem_image.mpr ⟨a.val,a.property,rfl⟩⟩ |
| invFun v := ⟨⟨v.val,by obtain ⟨a,_,he⟩ := mem_image.mp v.property; exact he ▸ a.property⟩, |
| by |
| obtain ⟨a,ha,he⟩ := mem_image.mp v.property |
| have ha' : a=⟨v.val,by exact he ▸ a.property⟩ := Subtype.ext he |
| change (⟨v.val,_⟩ : (↑R:Set V)) ∈ A |
| simpa only [ha'] using ha⟩ |
| left_inv a := by apply Subtype.ext; apply Subtype.ext; rfl |
| right_inv v := rfl |
| map_rel_iff' := by intros; rfl |
|
|
| omit [Fintype V] in |
| lemma obstruction_induce (G : SimpleGraph V) (R : Finset V) |
| (h : FractionalObstruction (G.induce (↑R:Set V))) : FractionalObstruction G := by |
| obtain ⟨A,hA⟩ := h |
| let e := induceImageIso G R A |
| have hm := (singletonModel _ _ e.symm e.symm.injective |
| (fun {_ _} ha => e.symm.map_adj_iff.mpr ha)).hadwiger_le |
| refine ⟨A.image Subtype.val,?_⟩ |
| rw [number_iso e] at hA |
| have hm' : (hadwigerNumber (G.induce (↑(A.image Subtype.val):Set V)):ℝ) ≤ |
| hadwigerNumber ((G.induce (↑R:Set V)).induce (↑A:Set (↑R:Set V))) := by |
| exact_mod_cast hm |
| linarith |
|
|
| lemma number_le_four (G : SimpleGraph V) (h : ¬FractionalObstruction G) : |
| number G ≤ 4*(hadwigerNumber G:ℝ) := by |
| have hh : number (G.induce (↑(univ:Finset V):Set V)) ≤ |
| 4*(hadwigerNumber (G.induce (↑(univ:Finset V):Set V)):ℝ) := |
| le_of_not_gt (fun hn => h ⟨univ,hn⟩) |
| have he : G=(G.induce (↑(univ:Finset V):Set V)).comap |
| (fun v => ⟨v,mem_univ v⟩) := rfl |
| have hn : number G ≤ number (G.induce (↑(univ:Finset V):Set V)) := by |
| rw [he] |
| exact number_comap _ _ |
| have hm := (Knitting.model_induce G univ).hadwiger_le |
| have hm' : (hadwigerNumber (G.induce (↑(univ:Finset V):Set V)):ℝ) ≤ hadwigerNumber G := by |
| exact_mod_cast hm |
| linarith |
|
|
| omit [Fintype V] in |
| lemma stable_image {G : SimpleGraph V} {R : Finset V} {A : Finset (↑R:Set V)} |
| (h : Stable (G.induce (↑R:Set V)) A) : Stable G (A.image Subtype.val) := by |
| intro u hu v hv hav |
| obtain ⟨a,ha,rfl⟩ := mem_image.mp hu |
| obtain ⟨b,hb,rfl⟩ := mem_image.mp hv |
| exact h a ha b hb hav |
|
|
| section Palette |
| variable {J Color : Type} [Fintype J] [DecidableEq J] |
| variable (u : J → ℕ) |
|
|
| abbrev Palette := (j : J) × Fin (u j) |
|
|
| noncomputable def block (j : J) : Finset (Palette u) := |
| univ.map (Function.Embedding.sigmaMk j) |
|
|
| omit [Fintype J] [DecidableEq J] in |
| lemma block_card (j : J) : (block u j).card=u j := by simp [block] |
|
|
| omit [Fintype J] [DecidableEq J] in |
| lemma mem_block (b : Palette u) (j : J) : b∈block u j ↔ b.1=j := by |
| simp only [block,mem_map,mem_univ,true_and,Function.Embedding.sigmaMk_apply] |
| constructor |
| · rintro ⟨a,rfl⟩; rfl |
| · intro hb; subst j; exact ⟨b.2,rfl⟩ |
|
|
| noncomputable def eligible (L : V → Finset Color) (f : Color → Palette u) |
| (j : J) (b : Fin (u j)) : Finset V := univ.filter (fun v => ∃ c∈L v, f c=⟨j,b⟩) |
|
|
| omit [Fintype J] in |
| lemma occupied_card (L : V → Finset Color) (f : Color → Palette u) (v : V) (j : J) : |
| (ColorBins.occupied (L v) (block u j) f).card= |
| (univ.filter (fun b : Fin (u j) => v∈eligible u L f j b)).card := by |
| classical |
| have he : ColorBins.occupied (L v) (block u j) f = |
| (univ.filter (fun b : Fin (u j) => v∈eligible u L f j b)).map |
| (Function.Embedding.sigmaMk j) := by |
| ext b |
| simp only [ColorBins.occupied,mem_inter,mem_image,mem_map,mem_filter,mem_univ, |
| true_and,eligible,Function.Embedding.sigmaMk_apply] |
| constructor |
| · rintro ⟨hb,⟨c,hc,he⟩⟩ |
| have hb' := (mem_block u b j).mp hb |
| subst j |
| exact ⟨b.2,⟨c,hc,he⟩,rfl⟩ |
| · rintro ⟨a,⟨c,hc,he⟩,rfl⟩ |
| exact ⟨(mem_block u ⟨j,a⟩ j).mpr rfl,⟨c,hc,he⟩⟩ |
| rw [he,card_map] |
|
|
| end Palette |
|
|
| noncomputable def blockSize (t m : ℕ) (j : Fin (m+1)) : ℕ := |
| if j.val < m then bins t j.val else 16*t |
|
|
| lemma blockSize_stage (t m : ℕ) (j : Fin m) : |
| blockSize t m j.castSucc=bins t j.val := by simp [blockSize,j.isLt] |
|
|
| lemma blockSize_cleanup (t m : ℕ) : blockSize t m (Fin.last m)=16*t := by |
| simp [blockSize] |
|
|
| lemma palette_card (t m : ℕ) : |
| Fintype.card (Palette (blockSize t m))=(∑ j∈range m,bins t j)+16*t := by |
| rw [Fintype.card_sigma] |
| simp only [Fintype.card_fin] |
| rw [Fin.sum_univ_castSucc] |
| simp only [blockSize_stage,blockSize_cleanup] |
| rw [Fin.sum_univ_eq_sum_range] |
|
|
| abbrev RunPalette (t m : ℕ) := ((j : Fin m) × Fin (bins t j.val)) ⊕ Fin (16*t) |
|
|
| def stageBin (t m : ℕ) (j : Fin m) (b : Fin (bins t j.val)) : RunPalette t m := |
| Sum.inl ⟨j,b⟩ |
|
|
| def binIndex {t m : ℕ} : RunPalette t m → ℕ := |
| Sum.elim (fun b => b.1.val) (fun _ => m) |
|
|
| lemma stageBin_injective (t m : ℕ) (j : Fin m) : |
| Function.Injective (stageBin t m j) := by |
| intro a b h |
| exact eq_of_heq (Sigma.mk.inj_iff.mp (Sum.inl.inj h)).2 |
|
|
| noncomputable def runBlock (t m : ℕ) : Option (Fin m) → Finset (RunPalette t m) |
| | none => univ.map Function.Embedding.inr |
| | some j => univ.map ⟨stageBin t m j,stageBin_injective t m j⟩ |
|
|
| lemma runBlock_none (t m : ℕ) : (runBlock t m none).card=16*t := by |
| simp [runBlock] |
|
|
| lemma runBlock_some (t m : ℕ) (j : Fin m) : |
| (runBlock t m (some j)).card=bins t j.val := by simp [runBlock] |
|
|
| lemma runPalette_card (t m : ℕ) : |
| Fintype.card (RunPalette t m)=(∑ j∈range m,bins t j)+16*t := by |
| simp only [RunPalette,Fintype.card_sum,Fintype.card_sigma,Fintype.card_fin] |
| rw [Fin.sum_univ_eq_sum_range] |
|
|
| omit [Fintype V] [DecidableEq V] in |
| lemma stable_extend {A B : Type} [DecidableEq B] (G : SimpleGraph V) |
| (e : A → B) (he : Function.Injective e) (S : A → Finset V) |
| (hs : ∀ a, Stable G (S a)) (b : B) : |
| Stable G (Function.extend e S (fun _ => ∅) b) := by |
| by_cases hb : ∃ a,e a=b |
| · obtain ⟨a,rfl⟩ := hb |
| rw [he.extend_apply] |
| exact hs a |
| · rw [Function.extend_apply' _ _ _ hb] |
| intro v hv |
| simp at hv |
|
|
| theorem stage_cover_or_obstruction : |
| ∃ T : ℝ, ∀ (t m : ℕ), T ≤ (t:ℝ) → |
| (∀ j < m, (t:ℝ)/Real.log t ≤ rate t j ∧ rate t j ≤ 4*t) → |
| ∀ (V : Type) [Fintype V] [DecidableEq V], ∀ G : SimpleGraph V, |
| (Fintype.card V:ℝ) ≤ (t:ℝ)^(11/10:ℝ) → hadwigerNumber G < t → |
| ∀ E : RunPalette t m → Finset V, |
| (∀ (j : Fin m) (v : V), (bins t j.val:ℝ)/2 ≤ |
| (univ.filter (fun b => v ∈ E (stageBin t m j b))).card) → |
| FractionalObstruction G ∨ ∀ k ≤ m, ∃ (R : Finset V) (S : RunPalette t m → Finset V), |
| number (G.induce (↑R:Set V)) ≤ rate t k ∧ |
| (∀ b, Stable G (S b)) ∧ |
| (∀ b v, v∈S b → binIndex b < k) ∧ |
| (∀ v, v∉R → ∃ b, v∈S b ∧ v∈E b) := by |
| classical |
| obtain ⟨T,hT⟩ := Sampling.eligible_thinning_or_fractional_counterexample |
| refine ⟨max T 2,?_⟩ |
| intro t m ht hvalid V _ _ G hord hminor E hE |
| by_cases hob : FractionalObstruction G |
| · exact Or.inl hob |
| right |
| have htT : T ≤ (t:ℝ) := (le_max_left _ _).trans ht |
| have ht2 : (2:ℝ) ≤ t := (le_max_right _ _).trans ht |
| have hn : 1 ≤ (t:ℝ)^(11/10:ℝ) := Real.one_le_rpow (by linarith) (by norm_num) |
| intro k hk |
| induction k with |
| | zero => |
| refine ⟨univ,fun _ => ∅,?_,?_,?_,?_⟩ |
| · rw [rate_zero] |
| have hh := number_le_four G hob |
| have hm : (hadwigerNumber G:ℝ) ≤ t := by exact_mod_cast hminor.le |
| have hb : number G ≤ 4*(t:ℝ) := by linarith only [hh,hm] |
| exact (number_comap G (Subtype.val : (↑(univ:Finset V):Set V) → V)).trans hb |
| · intro b v hv; simp at hv |
| · intro b v hv; simp at hv |
| · intro v hv; exact (hv (mem_univ v)).elim |
| | succ k ih => |
| obtain ⟨R,S,hf,hS,hsupp,hcover⟩ := ih (by omega) |
| let j : Fin m := ⟨k,by omega⟩ |
| let H := G.induce (↑R:Set V) |
| let E' (b : Fin (bins t k)) : Finset (↑R:Set V) := |
| univ.filter (fun v => v.val ∈ E (stageBin t m j b)) |
| have hE' (v : (↑R:Set V)) : (bins t k:ℝ)/2 ≤ |
| (univ.filter (fun b => v∈E' b)).card := by |
| simpa only [E',mem_filter,mem_univ,true_and] using hE j v.val |
| have hhord : (Fintype.card (↑R:Set V):ℝ) ≤ (t:ℝ)^(11/10:ℝ) := by |
| have hc : Fintype.card (↑R:Set V) ≤ Fintype.card V := Fintype.card_subtype_le _ |
| have hc' : (Fintype.card (↑R:Set V):ℝ) ≤ Fintype.card V := by exact_mod_cast hc |
| exact hc'.trans hord |
| have hhminor : hadwigerNumber H < t := (Knitting.model_induce G R).hadwiger_le.trans_lt hminor |
| have hh := hT t ((t:ℝ)^(11/10:ℝ)) (rate t k) htT hn le_rfl |
| (hvalid k (by omega)).1 (hvalid k (by omega)).2 |
| (↑R:Set V) H hhord hhminor hf E' hE' |
| rcases hh with ⟨A,hA,hrem⟩ | hbad |
| · change Fin (bins t k) → Finset (↑R:Set V) at A |
| let Q : Finset (↑R:Set V) := univ\univ.biUnion (fun b => A b∩E' b) |
| let R' := Q.image Subtype.val |
| let e := stageBin t m j |
| have he : Function.Injective e := stageBin_injective t m j |
| let A' (b : Fin (bins t k)) : Finset V := (A b).image Subtype.val |
| let D := Function.extend e A' (fun _ => ∅) |
| have hD : ∀ b, Stable G (D b) := stable_extend G e he A' (fun b => stable_image (hA b)) |
| have hs (b : RunPalette t m) (hb : binIndex b=k) : S b=∅ := by |
| apply eq_empty_iff_forall_notMem.mpr |
| intro v hv |
| have := hsupp b v hv |
| omega |
| have hds (b : RunPalette t m) (v : V) (hv : v∈D b) : binIndex b=k := by |
| by_cases hb : ∃ a,e a=b |
| · obtain ⟨a,rfl⟩ := hb; rfl |
| · have hd : D b=∅ := Function.extend_apply' _ _ _ hb |
| rw [hd] at hv |
| simp at hv |
| refine ⟨R',fun b => S b∪D b,?_,?_,?_,?_⟩ |
| · rw [←number_iso (induceImageIso G R Q),rate_succ] |
| exact hrem |
| · intro b |
| change Stable G (S b∪D b) |
| by_cases hb : binIndex b=k |
| · rw [hs b hb,empty_union]; exact hD b |
| · have hd : D b=∅ := eq_empty_iff_forall_notMem.mpr (fun v hv => hb (hds b v hv)) |
| rw [hd,union_empty]; exact hS b |
| · intro b v hv |
| rcases mem_union.mp hv with hv | hv |
| · exact (hsupp b v hv).trans (Nat.lt_succ_self _) |
| · rw [hds b v hv]; omega |
| · intro v hv |
| by_cases hvr : v∈R |
| · let v' : (↑R:Set V) := ⟨v,hvr⟩ |
| have hvq : v'∉Q := fun hh => hv (mem_image.mpr ⟨v',hh,rfl⟩) |
| have hva : v'∈univ.biUnion (fun b => A b∩E' b) := by |
| by_contra h |
| exact hvq (mem_sdiff.mpr ⟨mem_univ _,h⟩) |
| obtain ⟨a,_,ha⟩ := mem_biUnion.mp hva |
| refine ⟨e a,mem_union_right _ ?_,(mem_filter.mp (mem_inter.mp ha).2).2⟩ |
| change v ∈ Function.extend e A' (fun _ => ∅) (e a) |
| erw [he.extend_apply] |
| exact mem_image.mpr ⟨v',(mem_inter.mp ha).1,rfl⟩ |
| · obtain ⟨b,hb,hbe⟩ := hcover v hvr |
| exact ⟨b,mem_union_left _ hb,hbe⟩ |
| · exact (hob (obstruction_induce G R hbad)).elim |
|
|
| lemma occupied_image_card {A B Color : Type} [Fintype A] [DecidableEq A] [DecidableEq B] |
| (e : A ↪ B) (L : Finset Color) (f : Color → B) : |
| (ColorBins.occupied L (univ.map e) f).card= |
| (univ.filter (fun a => ∃ c∈L, f c=e a)).card := by |
| classical |
| have he : ColorBins.occupied L (univ.map e) f = |
| (univ.filter (fun a => ∃ c∈L, f c=e a)).map e := by |
| ext b |
| simp only [ColorBins.occupied,mem_inter,mem_map,mem_univ,true_and,mem_image,mem_filter] |
| constructor |
| · rintro ⟨⟨a,rfl⟩,c,hc,he⟩ |
| exact ⟨a,⟨c,hc,he⟩,rfl⟩ |
| · rintro ⟨a,⟨c,hc,he⟩,rfl⟩ |
| exact ⟨⟨a,rfl⟩,c,hc,he⟩ |
| rw [he,card_map] |
|
|
| lemma finish_cover (t m : ℕ) (G : SimpleGraph V) (ht : 1 < (t:ℝ)) |
| (horder : (Fintype.card V:ℝ) ≤ (t:ℝ)^(11/10:ℝ)) |
| (hterm : rate t m < (t:ℝ)/Real.log t) (E : RunPalette t m → Finset V) |
| (hE : ∀ v, 8*(t:ℝ) ≤ (univ.filter (fun b : Fin (16*t) => v∈E (Sum.inr b))).card) |
| (R : Finset V) (S : RunPalette t m → Finset V) |
| (hf : number (G.induce (↑R:Set V)) ≤ rate t m) |
| (hS : ∀ b, Stable G (S b)) |
| (hsupp : ∀ b v, v∈S b → binIndex b < m) |
| (hcover : ∀ v, v∉R → ∃ b, v∈S b ∧ v∈E b) : |
| ∃ S' : RunPalette t m → Finset V, (∀ b, Stable G (S' b)) ∧ |
| ∀ v, ∃ b, v∈S' b ∧ v∈E b := by |
| classical |
| let E' (b : Fin (16*t)) : Finset (↑R:Set V) := |
| univ.filter (fun v => v.val ∈ E (Sum.inr b)) |
| have hord : (Fintype.card (↑R:Set V):ℝ) ≤ (t:ℝ)^(11/10:ℝ) := by |
| have hc : (Fintype.card (↑R:Set V):ℝ) ≤ Fintype.card V := by |
| exact_mod_cast Fintype.card_subtype_le (·∈(↑R:Set V)) |
| exact hc.trans horder |
| obtain ⟨A,hA,hcov⟩ := Cleanup.cleanup_source (G.induce (↑R:Set V)) ht hord |
| (hf.trans hterm.le) E' (fun v => by |
| simpa only [E',mem_filter,mem_univ,true_and] using hE v.val) |
| refine ⟨Sum.elim (fun b => S (Sum.inl b)) (fun b => (A b).image Subtype.val),?_,?_⟩ |
| · intro b |
| rcases b with b | b |
| · exact hS (Sum.inl b) |
| · exact stable_image (hA b) |
| · intro v |
| by_cases hv : v∈R |
| · obtain ⟨b,hbe,hba⟩ := hcov ⟨v,hv⟩ |
| exact ⟨Sum.inr b,mem_image.mpr ⟨⟨v,hv⟩,hba,rfl⟩,(mem_filter.mp hbe).2⟩ |
| · obtain ⟨b,hb,he⟩ := hcover v hv |
| rcases b with b | b |
| · exact ⟨Sum.inl b,hb,he⟩ |
| · have hh := hsupp (Sum.inr b) v hb |
| simp only [binIndex,Sum.elim_inr] at hh |
| omega |
|
|
| theorem choosable_or_fractional_obstruction : |
| ∃ T : ℝ, ∀ (t : ℕ), T ≤ (t:ℝ) → |
| ∀ (V : Type) [Fintype V] [DecidableEq V], ∀ G : SimpleGraph V, |
| (Fintype.card V:ℝ) ≤ (t:ℝ)^(11/10:ℝ) → hadwigerNumber G < t → |
| Choosable G (32768*t) ∨ FractionalObstruction G := by |
| classical |
| obtain ⟨T₀,hT₀⟩ := stage_cover_or_obstruction |
| obtain ⟨T₁,hT₁⟩ := Filter.eventually_atTop.mp schedule_cutoff |
| obtain ⟨T₂,hT₂⟩ := Filter.eventually_atTop.mp palette_tail_cutoff |
| refine ⟨max T₀ (max T₁ T₂),?_⟩ |
| intro t ht V _ _ G hord hminor |
| by_cases hob : FractionalObstruction G |
| · exact Or.inr hob |
| left |
| have ht₀ := (le_max_left T₀ _).trans ht |
| have ht₁ := ((le_max_left T₁ T₂).trans (le_max_right T₀ _)).trans ht |
| have ht₂ := ((le_max_right T₁ T₂).trans (le_max_right T₀ _)).trans ht |
| obtain ⟨ht1,hl,hlog,hp⟩ := hT₁ (t:ℝ) ht₁ |
| obtain ⟨m,hm,hterm,hvalid,hbudget,hblocks,hcleanup⟩ := schedule_exists t ht1 hl hlog hp |
| have htN : 1 ≤ t := by exact_mod_cast (show (1:ℝ) ≤ t by linarith) |
| have hb : 1 ≤ Fintype.card (RunPalette t m) := by rw [runPalette_card]; omega |
| have hb' : (Fintype.card (RunPalette t m):ℝ) ≤ 4096*t := by |
| rw [runPalette_card] |
| exact_mod_cast hbudget |
| intro Color L hL |
| let u (j : Option (Fin m)) := (runBlock t m j).card |
| let e : Option (Fin m) ≃ Fin (Fintype.card (Option (Fin m))) := Fintype.equivFin _ |
| have hj : (Fintype.card (Option (Fin m)):ℝ) ≤ (t:ℝ)+1 := by |
| simp only [Fintype.card_option,Fintype.card_fin,Nat.cast_add,Nat.cast_one] |
| exact_mod_cast Nat.add_le_add_right hm 1 |
| have hu (j : Option (Fin m)) : (t:ℝ)^(7/10:ℝ) ≤ (u j:ℝ) := by |
| cases j with |
| | none => simpa only [u,runBlock_none,Nat.cast_mul,Nat.cast_ofNat] using hcleanup |
| | some j => simpa only [u,runBlock_some] using hblocks j.val j.isLt |
| have htail₀ := hT₂ (t:ℝ) ht₂ (Fintype.card V) (Fintype.card (RunPalette t m)) |
| (Fintype.card (Option (Fin m))) (fun i => u (e.symm i)) hord hb hb' hj (fun i => hu (e.symm i)) |
| have hsum : (∑ i : Fin (Fintype.card (Option (Fin m))), |
| (2:ℝ)^(u (e.symm i))*Real.exp (-(32768*(t:ℝ))*(u (e.symm i))/(2*Fintype.card (RunPalette t m)))) = |
| ∑ j : Option (Fin m), (2:ℝ)^(u j)*Real.exp (-(32768*(t:ℝ))*(u j)/(2*Fintype.card (RunPalette t m))) := by |
| exact Fintype.sum_equiv e.symm _ _ (fun _ => rfl) |
| rw [hsum] at htail₀ |
| have htail : (Fintype.card V:ℝ)*(∑ j, (2:ℝ)^(runBlock t m j).card* |
| Real.exp (-(32768*t:ℕ)*(runBlock t m j).card/(2*Fintype.card (RunPalette t m)))) < 1 := by |
| simpa only [Nat.cast_mul,Nat.cast_ofNat,u] using htail₀ |
| obtain ⟨f,hf⟩ := ColorBins.exists_bins hb L (runBlock t m) hL htail |
| let E (b : RunPalette t m) : Finset V := univ.filter (fun v => ∃ c∈L v, f c=b) |
| have hEstage (j : Fin m) (v : V) : (bins t j.val:ℝ)/2 ≤ |
| (univ.filter (fun b => v∈E (stageBin t m j b))).card := by |
| have hh := hf v (some j) |
| rw [runBlock_some] at hh |
| have he := occupied_image_card |
| (⟨stageBin t m j,stageBin_injective t m j⟩ : Fin (bins t j.val) ↪ RunPalette t m) (L v) f |
| change (ColorBins.occupied (L v) (runBlock t m (some j)) f).card=_ at he |
| rw [he] at hh |
| have hh' : (bins t j.val:ℝ) ≤ 2*(univ.filter (fun b => ∃ c∈L v, f c=stageBin t m j b)).card := by |
| exact_mod_cast hh |
| simpa only [E,mem_filter,mem_univ,true_and] using (show (bins t j.val:ℝ)/2 ≤ |
| (univ.filter (fun b => ∃ c∈L v, f c=stageBin t m j b)).card by linarith) |
| have hEcleanup (v : V) : 8*(t:ℝ) ≤ (univ.filter (fun b : Fin (16*t) => v∈E (Sum.inr b))).card := by |
| have hh := hf v none |
| rw [runBlock_none] at hh |
| have he := occupied_image_card (Function.Embedding.inr : Fin (16*t) ↪ RunPalette t m) (L v) f |
| change (ColorBins.occupied (L v) (runBlock t m none) f).card=_ at he |
| rw [he] at hh |
| have hh' : 16*(t:ℝ) ≤ 2*(univ.filter (fun b : Fin (16*t) => ∃ c∈L v, f c=Sum.inr b)).card := by |
| exact_mod_cast hh |
| simpa only [E,mem_filter,mem_univ,true_and] using (show 8*(t:ℝ) ≤ |
| (univ.filter (fun b : Fin (16*t) => ∃ c∈L v, f c=Sum.inr b)).card by linarith) |
| rcases hT₀ t m ht₀ hvalid V G hord hminor E hEstage with hbad | hstates |
| · exact (hob hbad).elim |
| obtain ⟨R,S,hrem,hS,hsupp,hcover⟩ := hstates m le_rfl |
| obtain ⟨S',hS',hcover'⟩ := finish_cover t m G ht1 hord hterm E hEcleanup R S hrem hS hsupp hcover |
| apply ColorBins.listColorable_of_bin_cover G L f S' hS' |
| intro v |
| obtain ⟨b,hb,he⟩ := hcover' v |
| exact ⟨b,hb,(mem_filter.mp he).2⟩ |
|
|
| end LinearListHadwiger.SmallList |
|
|
| end OAI |
|
|
