Blame for lean/OAI/Geometry/PinnedDistances/IncomingFibers.lean

import OAI.Geometry.PinnedDistances.UniformCore

namespace OAI

universe u1 u2 u3 u4 u5 u6 u7 u8

section
noncomputable section
open NumberField
open scoped BigOperators
noncomputable section
open MeasureTheory
open scoped Topology
noncomputable section
open MeasureTheory
open scoped Topology ENNReal
noncomputable section
open MeasureTheory NumberField
open scoped BigOperators
noncomputable section
open scoped BigOperators
open MeasureTheory
noncomputable section
open Filter
open scoped Topology
noncomputable section
open scoped BigOperators

namespace WeakPinned.Core.Fibers
open scoped BigOperators
open Variance
variable {V : Type u1} {I : Type u2} [Fintype V] [Fintype I] [DecidableEq V]
variable (G : Fibers V I)

def edges : Finset (V × V) := G.edgeSet (-1) Finset.univ

def edgeCount : ℝ := G.edges.card

def edgeLaw (x y : V) : ℝ := if (x,y) ∈ G.edges then 1/G.edgeCount else 0

def fiberWeight (e : I) : ℝ := (G.targets e).card / G.edgeCount

def incoming (y : V) : Finset V := Finset.univ.filter (fun x => (x,y) ∈ G.edges)

def incomingWeight (y : V) : ℝ := (G.incoming y).card / G.edgeCount

omit [Fintype I] in
lemma active_univ_neg_one (e : I) : G.active (-1) Finset.univ e := by
  refine ⟨Finset.mem_univ _,?_⟩
  have h := Nat.cast_nonneg (α:=ℝ) (G.size Finset.univ e)
  linarith

lemma edgeCount_eq : G.edgeCount = ∑ e, ((G.targets e).card : ℝ) := by
  unfold edgeCount edges
  rw [edgeSet_card]
  simp [G.active_univ_neg_one,size]

omit [Fintype I] in
lemma edgeLaw_nonneg (x y : V) : 0 ≤ G.edgeLaw x y := by
  unfold edgeLaw edgeCount
  split_ifs <;> positivity

omit [Fintype I] in
lemma edgeLaw_diag (x : V) : G.edgeLaw x x=0 := by
  have hh : (x,x) ∉ G.edges := by
    intro h
    exact G.edge_no_loop (-1) Finset.univ x (Finset.mem_filter.mp h).2
  simp [edgeLaw,hh]

omit [Fintype I] in
lemma fiberWeight_nonneg (e : I) : 0 ≤ G.fiberWeight e := by
  unfold fiberWeight edgeCount
  positivity

lemma sum_fiberWeight (hG : 0 < G.edgeCount) : ∑ e, G.fiberWeight e=1 := by
  simp only [fiberWeight,← Finset.sum_div,← G.edgeCount_eq,div_self hG.ne']

omit [Fintype I] in
lemma fiberWeight_prob (e : I) (y : V) :
    G.fiberWeight e*prob (G.targets e) y = if y ∈ G.targets e then 1/G.edgeCount else 0 := by
  by_cases hy : y ∈ G.targets e
  · have hk : ((G.targets e).card : ℝ) ≠ 0 := by
      exact_mod_cast (Finset.card_ne_zero.mpr ⟨y,hy⟩)
    simp only [fiberWeight,prob,ite_eq_left hy]
    field_simp
  · simp [prob,hy]

lemma sampling_fiber (x y : V) :
    (∑ e, if G.source e=x then G.fiberWeight e * prob (G.targets e) y else 0) =
      G.edgeLaw x y := by
  have he := G.edge_indicator (-1) Finset.univ x y
  simp only [G.active_univ_neg_one,true_and,Finset.mem_inter,Finset.mem_univ,and_true] at he
  have hh : (∑ e, if G.source e=x then G.fiberWeight e * prob (G.targets e) y else 0) =
      (∑ e, if G.source e=x ∧ y ∈ G.targets e then (1:ℝ) else 0)/G.edgeCount := by
    simp only [Finset.sum_div,G.fiberWeight_prob]
    apply Finset.sum_congr rfl
    intro e _
    by_cases hs : G.source e=x <;> by_cases hy : y ∈ G.targets e <;> simp [hs,hy]
  rw [hh,he]
  by_cases he : G.edge (-1) Finset.univ x y <;> simp [edgeLaw,edges,edgeSet,he]

lemma fiber_marginal (y : V) :
    (∑ e, G.fiberWeight e * prob (G.targets e) y) = ∑ x, G.edgeLaw x y := by
  simp_rw [← G.sampling_fiber]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro e _
  simp

omit [Fintype I] in
lemma incoming_marginal (y : V) : ∑ x, G.edgeLaw x y=G.incomingWeight y := by
  simp only [edgeLaw,incomingWeight,incoming,← Finset.sum_filter,Finset.sum_const,nsmul_eq_mul]
  simp only [mul_one_div]

omit [Fintype I] in
lemma sampling_incoming (x y : V) :
    G.incomingWeight y*prob (G.incoming y) x=G.edgeLaw x y := by
  by_cases he : (x,y) ∈ G.edges
  · have hm : x ∈ G.incoming y := by simp [incoming,he]
    have hk : ((G.incoming y).card : ℝ) ≠ 0 := by exact_mod_cast (Finset.card_ne_zero.mpr ⟨x,hm⟩)
    simp only [incomingWeight,prob,ite_eq_left hm,edgeLaw,ite_eq_left he]
    field_simp
  · have hm : x ∉ G.incoming y := by simp [incoming,he]
    simp [prob,hm,edgeLaw,he]

omit [Fintype I] in
lemma sum_edgeLaw (hG : 0 < G.edgeCount) : (∑ x, ∑ y, G.edgeLaw x y)=1 := by
  rw [← Fintype.sum_prod_type (f:=fun xy : V × V => G.edgeLaw xy.1 xy.2)]
  simp only [edgeLaw,← Finset.sum_filter,Finset.sum_const,nsmul_eq_mul]
  have he : Finset.univ.filter (fun xy : V × V => xy ∈ G.edges)=G.edges := by simp
  rw [he]
  change G.edgeCount*(1/G.edgeCount)=1
  field_simp

omit [Fintype I] in
lemma sum_incomingWeight (hG : 0 < G.edgeCount) : ∑ y, G.incomingWeight y=1 := by
  simp_rw [← G.incoming_marginal]
  rw [Finset.sum_comm,G.sum_edgeLaw hG]

lemma fiber_domination (B : ℝ) (hdom : ∀ x y, G.edgeLaw x y ≤ B*pairProb Finset.univ x y)
    (hn : 2 ≤ Fintype.card V) (y : V) :
    (∑ e, G.fiberWeight e*prob (G.targets e) y) ≤ B*prob Finset.univ y := by
  rw [G.fiber_marginal]
  have hh := Finset.sum_le_sum (s:=Finset.univ) (fun x _ => hdom x y)
  simpa only [← Finset.mul_sum,pairProb_symm _ _ y,sum_pairProb Finset.univ (by simpa using hn)] using hh

omit [Fintype I] in
lemma incoming_domination (B : ℝ) (hdom : ∀ x y, G.edgeLaw x y ≤ B*pairProb Finset.univ x y)
    (hn : 2 ≤ Fintype.card V) (x : V) :
    (∑ y, G.incomingWeight y*prob (G.incoming y) x) ≤ B*prob Finset.univ x := by
  simp_rw [G.sampling_incoming]
  have hh := Finset.sum_le_sum (s:=Finset.univ) (fun y _ => hdom x y)
  simpa only [← Finset.mul_sum,sum_pairProb Finset.univ (by simpa using hn)] using hh

omit [Fintype I] in
/-- The exact bound on omitted small incoming degrees, not just a formal
    little-o assertion. -/
lemma small_incoming_mass (T : ℝ) (hT : 0 ≤ T) :
    (∑ y, if ((G.incoming y).card : ℝ)<T then G.incomingWeight y else 0) ≤
      (Fintype.card V : ℝ)*T/G.edgeCount := by
  have hn : 0 ≤ G.edgeCount := by unfold edgeCount; positivity
  have hh : ∀ y, (if ((G.incoming y).card : ℝ)<T then G.incomingWeight y else 0) ≤ T/G.edgeCount := by
    intro y
    split_ifs with hy
    · exact div_le_div_of_nonneg_right hy.le hn
    · exact div_nonneg hT hn
  have hs := Finset.sum_le_sum (s:=Finset.univ) (fun y _ => hh y)
  simpa only [Finset.sum_const,Finset.card_univ,nsmul_eq_mul,mul_div_assoc] using hs

end WeakPinned.Core.Fibers

namespace WeakPinned.Core.Fibers
open scoped BigOperators
variable {V : Type u3} {I : Type u4} [Fintype V] [Fintype I] [DecidableEq V]
variable (G : Fibers V I)

abbrev Active (K : ℝ) (C : Finset V) := {e : I // G.active K C e}

instance (K : ℝ) (C : Finset V) : Fintype (G.Active K C) := by
  classical
  exact Fintype.ofFinite _

def onCore (K : ℝ) (C : Finset V) : Fibers C (G.Active K C) where
  source e := ⟨G.source e.val,e.property.1⟩
  targets e := Finset.univ.filter (fun y : C => y.val ∈ G.targets e.val)
  no_loop e := by simpa using G.no_loop e.val
  disjoint e f hef hs := by
    apply Finset.disjoint_left.mpr
    intro y hye hyf
    have hne : e.val ≠ f.val := fun h => hef (Subtype.ext h)
    have hs' : G.source e.val=G.source f.val := congrArg Subtype.val hs
    exact Finset.disjoint_left.mp (G.disjoint _ _ hne hs')
      (Finset.mem_filter.mp hye).2 (Finset.mem_filter.mp hyf).2

omit [Fintype V] [Fintype I] in
lemma onCore_targets (K : ℝ) (C : Finset V) (e : G.Active K C) :
    ((G.onCore K C).targets e).image Subtype.val=G.targets e.val ∩ C := by
  ext y
  simp only [onCore,Finset.mem_image,Finset.mem_filter,Finset.mem_univ,true_and,Finset.mem_inter]
  constructor
  · rintro ⟨z,hz,rfl⟩; exact ⟨hz,z.property⟩
  · rintro ⟨hy,hC⟩; exact ⟨⟨y,hC⟩,hy,rfl⟩

omit [Fintype V] [Fintype I] in
lemma onCore_size (K : ℝ) (C : Finset V) (e : G.Active K C) :
    ((G.onCore K C).targets e).card=G.size C e.val := by
  rw [← Finset.card_image_of_injective _ Subtype.val_injective,G.onCore_targets,size]

omit [Fintype I] in
omit [Fintype V] in
lemma onCore_edge (K : ℝ) (C : Finset V) (x y : C) :
    (G.onCore K C).edge (-1) Finset.univ x y ↔ G.edge K C x.val y.val := by
  simp only [edge,active_univ_neg_one,true_and,Finset.mem_inter,Finset.mem_univ,and_true]
  constructor
  · rintro ⟨e,hs,hy⟩
    refine ⟨e.val,e.property,congrArg Subtype.val hs,?_⟩
    exact ⟨(Finset.mem_filter.mp hy).2,y.property⟩
  · rintro ⟨e,ha,hs,hy⟩
    exact ⟨⟨e,ha⟩,Subtype.ext hs,Finset.mem_filter.mpr ⟨Finset.mem_univ _,hy.1⟩⟩

omit [Fintype I] in
lemma onCore_edges_image (K : ℝ) (C : Finset V) :
    ((G.onCore K C).edges).image (fun xy : C × C => (xy.1.val,xy.2.val))=G.edgeSet K C := by
  ext xy
  simp only [edges,edgeSet,Finset.mem_image,Finset.mem_filter,Finset.mem_univ,true_and]
  constructor
  · rintro ⟨⟨x,y⟩,hxy,rfl⟩
    exact (G.onCore_edge K C x y).mp hxy
  · intro hxy
    obtain ⟨e,ha,hs,hy⟩ := hxy
    have hxC : xy.1 ∈ C := hs ▸ ha.1
    have hyC : xy.2 ∈ C := (Finset.mem_inter.mp hy).2
    refine ⟨(⟨xy.1,hxC⟩,⟨xy.2,hyC⟩),?_,rfl⟩
    exact (G.onCore_edge K C _ _).mpr ⟨e,ha,hs,hy⟩

omit [Fintype I] in
lemma onCore_card (K : ℝ) (C : Finset V) :
    ((G.onCore K C).edges).card=(G.edgeSet K C).card := by
  rw [← G.onCore_edges_image]
  apply (Finset.card_image_of_injective _ _).symm
  intro a b h
  exact Prod.ext (Subtype.ext (congrArg Prod.fst h)) (Subtype.ext (congrArg Prod.snd h))

omit [Fintype I] in
lemma onCore_degree (K : ℝ) (C : Finset V) (x : C) :
    (G.onCore K C).degree (-1) Finset.univ x=G.degree K C x.val := by
  simp only [degree,G.onCore_edge]
  have hsum (f : V → ℝ) (hf : ∀ y, y ∉ C → f y=0) : (∑ y : C, f y.val)=∑ y, f y := by
    rw [Finset.sum_coe_sort]
    apply Finset.sum_subset (Finset.subset_univ _) (fun y _ hy => hf y hy)
  simp only [← Finset.sum_boole,← Finset.sum_add_distrib]
  apply hsum (fun y => (if G.edge K C x.val y then 1 else 0)+(if G.edge K C y x.val then 1 else 0))
  intro y hy
  have h1 : ¬ G.edge K C x.val y := by
    rintro ⟨e,ha,hs,he⟩
    exact hy (Finset.mem_inter.mp he).2
  have h2 : ¬ G.edge K C y x.val := by
    rintro ⟨e,ha,hs,he⟩
    exact hy (hs ▸ ha.1)
  simp [h1,h2]

end WeakPinned.Core.Fibers

namespace WeakPinned.Core.Fibers
open scoped BigOperators
variable {V : Type u5} {I : Type u6} [Fintype V] [Fintype I] [DecidableEq V]
variable (G : Fibers V I)

omit [Fintype V] [Fintype I] in
lemma onCore_size_subset (K : ℝ) (C : Finset V) (D : Finset C) (e : G.Active K C) :
    (G.onCore K C).size D e=G.size (D.image Subtype.val) e.val := by
  unfold size
  rw [← Finset.card_image_of_injective _ Subtype.val_injective]
  congr 1
  ext y
  simp only [Finset.mem_image,Finset.mem_inter]
  constructor
  · rintro ⟨z,⟨hz,hd⟩,rfl⟩
    exact ⟨(Finset.mem_filter.mp hz).2,⟨z,hd,rfl⟩⟩
  · rintro ⟨hy,z,hz,rfl⟩
    exact ⟨z,⟨Finset.mem_filter.mpr ⟨Finset.mem_univ _,hy⟩,hz⟩,rfl⟩

def heavyCount (lam : ℝ) (D : Finset V) : ℝ :=
  ∑ e, if lam*((G.targets e).card : ℝ) ≤ (G.size D e : ℝ) ∧ G.source e ∈ D
    then (G.size D e : ℝ) else 0

omit [Fintype V] in
lemma onCore_heavyCount (K lam : ℝ) (C : Finset V) (D : Finset C) :
    (G.onCore K C).heavyCount lam D =
      ∑ e, if G.active K C e ∧ lam*(G.size C e : ℝ) ≤ (G.size (D.image Subtype.val) e : ℝ) ∧
        G.source e ∈ D.image Subtype.val then (G.size (D.image Subtype.val) e : ℝ) else 0 := by
  classical
  unfold heavyCount
  simp_rw [G.onCore_size_subset,G.onCore_size]
  have hs (e : G.Active K C) : (G.onCore K C).source e ∈ D ↔ G.source e.val ∈ D.image Subtype.val := by
    constructor
    · intro h; exact Finset.mem_image.mpr ⟨_,h,rfl⟩
    · intro h
      obtain ⟨y,hy,he⟩ := Finset.mem_image.mp h
      have hh : y=(G.onCore K C).source e := Subtype.ext he
      simpa only [hh] using hy
  simp_rw [hs]
  rw [← Finset.sum_subtype (p:=G.active K C) (Finset.univ.filter (G.active K C)) (by simp)
    (fun e => if lam*(G.size C e : ℝ) ≤ (G.size (D.image Subtype.val) e : ℝ) ∧
      G.source e ∈ D.image Subtype.val then (G.size (D.image Subtype.val) e : ℝ) else 0), Finset.sum_filter]
  apply Finset.sum_congr rfl
  intro e _
  by_cases he : G.active K C e <;> simp [he]

omit [Fintype I] in
lemma degree_marginal (x : V) : (∑ y, G.edgeLaw x y)+(∑ y, G.edgeLaw y x)=
    G.degree (-1) Finset.univ x/G.edgeCount := by
  simp only [edgeLaw,edges,edgeSet,Finset.mem_filter,Finset.mem_univ,true_and,
    ← Finset.sum_filter,Finset.sum_const,nsmul_eq_mul,degree,add_div,mul_one_div]

end WeakPinned.Core.Fibers

namespace WeakPinned
open scoped BigOperators
open WeakPinned.Core

abbrev coreGraph (P : Finset Plane) (s : ℝ) (C : Finset P) :=
  (planarFibers P s).onCore (cutoff s P.card) C

lemma coreGraph_heavy (P : Finset Plane) (s lam : ℝ) (C : Finset P) (D : Finset C) :
    (coreGraph P s C).heavyCount lam D = heavyCount P s (cutoff s P.card) lam C (D.image Subtype.val) := by
  rw [(planarFibers P s).onCore_heavyCount]
  unfold heavyCount heavyFiber
  apply Finset.sum_congr rfl
  intro e _
  simp only [and_assoc]

structure PreparedGraph (V : Type u7) (I : Type u8) [Fintype V] [Fintype I] [DecidableEq V]
    (G : Fibers V I) (θ γ c η : ℝ) : Prop where
  card_ge : 2 ≤ Fintype.card V
  lower : (θ-η)*(Fintype.card V : ℝ)*((Fintype.card V : ℝ)-1) ≤ G.edgeCount
  upper : G.edgeCount ≤ (θ+η/8)*(Fintype.card V : ℝ)*((Fintype.card V : ℝ)-1)
  degree : ∀ x, 2*(θ-η)*((Fintype.card V : ℝ)-1) ≤ G.degree (-1) Finset.univ x
  fiber : ∀ e, (Fintype.card V : ℝ)^γ < ((G.targets e).card : ℝ)
  subset : ∀ D, G.heavyCount (1/Real.log (Fintype.card V : ℝ)) D ≤ (θ+η)*(D.card : ℝ)*((D.card : ℝ)-1)
  small : ∀ D, (D.card : ℝ) ≤ (Fintype.card V : ℝ)^(1-c) →
    G.heavyCount (1/Real.log (Fintype.card V : ℝ)) D ≤ η*(D.card : ℝ)*((D.card : ℝ)-1)

lemma PreparedCore.graph {s γ c η : ℝ} {P : Finset Plane} {C : Finset P}
    (h : PreparedCore s γ c η P C) :
    PreparedGraph C ((planarFibers P s).Active (cutoff s P.card) C) (coreGraph P s C) (Theta s) γ c η := by
  have hn : Fintype.card C=C.card := Fintype.card_coe C
  have he : (coreGraph P s C).edgeCount = ((planarFibers P s).edgeSet (cutoff s P.card) C).card := by
    unfold Core.Fibers.edgeCount
    rw [(planarFibers P s).onCore_card]
  refine ⟨by simpa only [hn] using h.card_two,?_,?_,?_,?_,?_,?_⟩
  · simpa only [he,hn] using h.lower
  · simpa only [he,hn] using h.upper
  · intro x
    simpa only [hn,(planarFibers P s).onCore_degree] using h.degree x.val x.property
  · intro e
    rw [(planarFibers P s).onCore_size,hn]
    exact h.large_fiber.trans_lt e.property.2
  · intro D
    rw [hn,coreGraph_heavy]
    simpa only [Finset.card_image_of_injective _ Subtype.val_injective] using h.subset (D.image Subtype.val)
  · intro D hD
    rw [hn,coreGraph_heavy]
    have hc : (D.image Subtype.val).card=D.card := Finset.card_image_of_injective _ Subtype.val_injective
    simpa only [hc] using h.small (D.image Subtype.val) (by simpa only [hc,hn] using hD)

/-- Actual arbitrarily large real planar graphs, with all uniform subset
bounds simultaneously. No graph condition is added to the main hypothesis. -/
theorem arbitrarily_large_graph (hfail : ¬ MainStatement) {s γ c : ℝ}
    (hγ : 0<γ) (hγs : γ<s) (hc : 0<c) (hc1 : c<1)
    (hsc : (1-c)*criticalExponent<s) (hs : ContinuousAt Theta s)
    (η : ℝ) (hη : 0<η) (M : ℕ) :
    ∃ (P : Finset Plane) (C : Finset P), M<C.card ∧
      PreparedGraph C ((planarFibers P s).Active (cutoff s P.card) C) (coreGraph P s C) (Theta s) γ c η := by
  obtain ⟨P,C,hM,hC⟩ := arbitrarily_large_prepared hfail hγ hγs hc hc1 hsc hs η hη M
  exact ⟨P,C,hM,hC.graph⟩

end WeakPinned

end
end
end
end
end
end
end
end

end OAI