import OAI.Combinatorics.PlanarL1.StepSuccess

namespace OAI


section

namespace PlanarL1.Columns.Model
open MeasureTheory Parameters
attribute [local instance] Classical.propDecidable
variable {k : ℕ} {M : Model (k+1)} {Ω Ξ V : Type*}
variable [MeasurableSpace Ω] [MeasurableSpace Ξ] {μ : Measure Ω} {ν : Measure Ξ}
variable {A : Ambient M}
namespace SetSystem
local instance : MeasurableSpace (Set (Fin (k+1))) := ⊤
variable [Fintype V] (S : SetSystem M Ω μ) (v : V → M.Point Set.univ A.root)
noncomputable def refinedBinary : FiniteL1.BinarySystem (V := V)
    (μ.prod (Measure.count : Measure (Set (Fin (k+1))))) where
  active w x := (S.activity w.1).active (v x).column (v x).height ∧ w.2=(S.activity w.1).component (v x).column
  measurable x := by
    have hm : Measurable (fun w : Ω × Set (Fin (k+1)) => (S.activity w.1).vector (v x).column (v x).height w.2) :=
      measurable_from_prod_countable_left (fun c => S.measurable_vector (v x).column (v x).height c)
    convert measurableSet_eq_fun hm (measurable_const : Measurable (fun _ : Ω × Set (Fin (k+1)) => (1:ℝ))) using 1
    ext w
    simp [Activity.vector]
  integrable x y := by
    convert (S.integrable_coordinateDifference (Classical.choice ((v x).paths_nonempty (v y))) (v x).height (v y).height).abs using 1
    funext w
    by_cases hx : (S.activity w.1).active (v x).column (v x).height ∧ w.2=(S.activity w.1).component (v x).column <;>
      by_cases hy : (S.activity w.1).active (v y).column (v y).height ∧ w.2=(S.activity w.1).component (v y).column <;>
      simp [SetSystem.coordinateDifference,Activity.vector,hx,hy]
noncomputable def cuts : FiniteL1.CutFamily V := FiniteL1.CutFamily.ofBinary (S.refinedBinary v)
variable [SFinite μ]
lemma cuts_distance (x y : V) :
    (S.cuts v).distance x y=∫ w, (S.activity w).cost (v x).column (v y).column (v x).height (v y).height ∂μ := by
  rw [cuts,FiniteL1.CutFamily.distance_ofBinary]
  rw [← S.integral_norm_coordinates (Classical.choice ((v x).paths_nonempty (v y))) (v x).height (v y).height]
  apply integral_congr_ae
  apply Filter.Eventually.of_forall
  intro w
  by_cases hx : (S.activity w.1).active (v x).column (v x).height ∧ w.2=(S.activity w.1).component (v x).column <;>
    by_cases hy : (S.activity w.1).active (v y).column (v y).height ∧ w.2=(S.activity w.1).component (v y).column <;>
    simp [Real.norm_eq_abs,SetSystem.coordinateDifference,Activity.vector,FiniteL1.BinarySystem.indicator,refinedBinary,hx,hy]
lemma cuts_upper (x y : V) : (S.cuts v).distance x y ≤ dist (v x) (v y) := by
  rw [S.cuts_distance]
  exact S.integral_cost_le_dist isClosed_univ _ _
lemma cuts_dominates (x y : V) : S.separation (v x).column (v x).height (v y).column (v y).height ≤ (S.cuts v).distance x y := by
  rw [S.cuts_distance,← S.norm_refinedMap_sub (v x)]
  exact S.refinedMap_dominates _ _ _
end SetSystem
namespace PairGeometry
variable [SFinite μ] [Fintype V] {SA : OrdinaryState M kappaA Ω μ}
variable {v : V → M.Point Set.univ A.root} {x y : V} {b : ℝ}
lemma Certificate.cuts (h : Certificate A SA v (x := x) (y := y) b) :
    b ≤ (SA.sets.cuts v).distance x y := by
  obtain ⟨a,c,H,E,hH,hac,hsep,hE,hm,hx,hy,hn⟩ := h
  rw [SA.sets.cuts_distance,← SA.sets.norm_refinedMap_sub (v x)]
  have bound {a c : Fin (k+1)} (hH : H ∈ M.heights a c) (hac : ¬Consecutive a c)
      (hsep : Field.TipSeparates a c (v x).column (v y).column)
      (hn : ∀ w ∈ E, ¬(SA.sets.activity w).active a H) :
      2*μ.real E ≤ ‖SA.sets.refinedMap (v x) (v x)-SA.sets.refinedMap (v x) (v y)‖ := by
    rcases hsep with ⟨h1,h2,hout⟩|⟨h1,h2,hout⟩
    · exact (SA.sets.refinedMap_terminal_certificate (v x) (v x) (v y) hH hac ⟨h1,h2⟩ hout E hE hn hx hy).2
    · simpa only [norm_sub_rev] using (SA.sets.refinedMap_terminal_certificate (v x) (v y) (v x) hH hac ⟨h1,h2⟩ hout E hE hn hy hx).2
  have hh : 2*μ.real E ≤ ‖SA.sets.refinedMap (v x) (v x)-SA.sets.refinedMap (v x) (v y)‖ := by
    rcases hsep with hsep|hsep
    · exact bound hH hac hsep hn
    · apply bound (M.symm a c ▸ hH) (fun h => hac (by simpa only [Consecutive,or_comm,or_left_comm,or_assoc] using h)) hsep
      intro w hw hwa
      exact hn w hw ((SA.sets.activity w).switch a c H hH |>.mpr hwa)
  linarith [measureReal_nonneg (μ := μ) (s := E)]
end PairGeometry
namespace CoupledState
variable [SFinite μ] [SFinite ν] [Fintype V]
variable {t : ℝ} (S : CoupledState A Ω Ξ μ ν t) (v : V → M.Point Set.univ A.root)
noncomputable def cuts : FiniteL1.CutFamily V := (S.left.sets.cuts v).add (S.right.sets.cuts v)
lemma cuts_upper (x y : V) : (S.cuts v).distance x y ≤ 2*dist (v x) (v y) := by
  rw [CoupledState.cuts,FiniteL1.CutFamily.distance_add]
  linarith [S.left.sets.cuts_upper v x y,S.right.sets.cuts_upper v x y]
lemma Successful.cuts {x y : V} {b : ℝ} (h : S.Successful v b x y) : b ≤ (S.cuts v).distance x y := by
  rw [CoupledState.cuts,FiniteL1.CutFamily.distance_add]
  rcases h with h|h|h
  · exact (h.trans (S.left.sets.cuts_dominates v x y)).trans (le_add_of_nonneg_right (FiniteL1.CutFamily.distance_nonneg _ _ _))
  · exact (h.trans (S.right.sets.cuts_dominates v x y)).trans (le_add_of_nonneg_left (FiniteL1.CutFamily.distance_nonneg _ _ _))
  · exact h.cuts.trans (le_add_of_nonneg_right (FiniteL1.CutFamily.distance_nonneg _ _ _))
end CoupledState
end PlanarL1.Columns.Model

end



section

namespace PlanarL1.Threshold
open MeasureTheory
instance labelMeasure_sfinite : SFinite labelMeasure := by
  rw [labelMeasure_eq]
  infer_instance
end PlanarL1.Threshold

namespace PlanarL1.Columns.Model
open MeasureTheory Parameters

/-- A state of the actual construction in its current physical units. Both
label spaces are enlarged at every step, even in the no-change mode. -/
structure World (k : ℕ) (V : Type*) (Q : ℝ) where
  model : Model (k+1)
  ambient : Ambient model
  vertex : V → model.Point Set.univ ambient.root
  sample : Type
  [measurable : MeasurableSpace sample]
  measure : Measure sample
  [sfinite : SFinite measure]
  state : CoupledState ambient sample sample measure measure Q

namespace World
attribute [instance] measurable sfinite
variable {k : ℕ} {V : Type*} [Fintype V] {Q : ℝ}
variable (hQ : 0 < Q) (h1 : 1 ≤ Q) (hgap : 10 ≤ (R/200)*Q)
variable (W : World k V Q)
noncomputable def heightBound : ℝ := ∑ x, |(W.vertex x).height|
lemma height_bounds (x : V) : (W.vertex x).height ∈ Set.Icc (-W.heightBound) W.heightBound := by
  have hh : |(W.vertex x).height| ≤ W.heightBound :=
    Finset.single_le_sum (f := fun y => |(W.vertex y).height|) (fun y _ => abs_nonneg _) (Finset.mem_univ x)
  exact abs_le.mp hh

noncomputable def after (T : CoupledState.Next (A := W.ambient) (μ := W.measure) (ν := W.measure)) : World k V Q where
  model := W.model.dilate Q hQ
  ambient := W.ambient.dilate hQ
  vertex x := W.ambient.scaleEquiv hQ (W.vertex x)
  sample := W.sample × Bool
  measure := ENNReal.ofReal Q • (W.measure.prod Threshold.fair)
  state := (T.dilate hQ).weaken (by simp)

noncomputable def step {m : ℕ} (hm : 0 < m) : Execution (World k V Q) :=
  (W.state.step h1 hgap W.vertex W.height_bounds hm).bind (fun T => .pure (W.after hQ T))

def Coherent (x : V) (ρ : ℝ) : Prop := W.state.Coherent (W.vertex x) ρ
def Successful (b : ℝ) (x y : V) : Prop := W.state.Successful W.vertex b x y
noncomputable def distance (x y : V) : ℝ := dist (W.vertex x) (W.vertex y)
noncomputable def cuts : FiniteL1.CutFamily V := W.state.cuts W.vertex
lemma cuts_upper (x y : V) : W.cuts.distance x y ≤ 2*W.distance x y := W.state.cuts_upper W.vertex x y
lemma Successful.cuts {b : ℝ} {x y : V} (h : W.Successful b x y) : b ≤ W.cuts.distance x y := CoupledState.Successful.cuts W.state W.vertex h
omit [Fintype V] in
lemma Successful.mono {b c : ℝ} {x y : V} (h : W.Successful b x y) (hc : c ≤ b) : W.Successful c x y := CoupledState.Successful.mono W.state W.vertex h hc

omit [Fintype V] in
lemma after_distance (T : CoupledState.Next (A := W.ambient) (μ := W.measure) (ν := W.measure)) (x y : V) :
    (W.after hQ T).distance x y=Q*W.distance x y := W.ambient.scaleEquiv_dist hQ _ _
omit [Fintype V] in
lemma after_coherent (T : CoupledState.Next (A := W.ambient) (μ := W.measure) (ν := W.measure)) (x : V) (ρ : ℝ) :
    (W.after hQ T).Coherent x (Q*ρ) ↔ T.Coherent (W.vertex x) ρ :=
  T.coherent_dilate hQ _ _
omit [Fintype V] in
lemma after_successful (T : CoupledState.Next (A := W.ambient) (μ := W.measure) (ν := W.measure))
    {x y : V} {b : ℝ} (h : T.Successful W.vertex b x y) : (W.after hQ T).Successful (Q*b) x y := h.dilate hQ T W.vertex

lemma step_distances {m : ℕ} (hm : 0 < m) : (W.step hQ h1 hgap hm).Holds
    (fun Z => ∀ x y, Z.distance x y=Q*W.distance x y) := by
  apply Execution.holds_bind_of_forall
  intro T x y
  exact W.after_distance hQ T x y

lemma step_survives {m : ℕ} (hm : 0 < m) {x y : V} {b : ℝ} (h : W.Successful b x y) :
    (W.step hQ h1 hgap hm).Holds (fun Z => Z.Successful (Q*(b-3)) x y) := by
  apply (W.state.step_moves h1 hgap W.vertex W.height_bounds hm).bind
  intro T hT
  exact W.after_successful hQ T (by simpa only [mul_one] using hT.successful W.state (by norm_num) W.vertex h)

lemma step_persistence {m : ℕ} (hm : 0 < m) {x : V} {ρ : ℝ} (hρ : 0 ≤ ρ)
    (hr : ρ ≤ persistenceRadius) (hold : W.Coherent x ρ) :
    (W.step hQ h1 hgap hm).prob (fun Z => ¬Z.Coherent x (Q*ρ)) ≤ persistenceLoss ρ m := by
  rw [step,Execution.prob_bind_pure]
  have he : (fun T : CoupledState.Next (A := W.ambient) (μ := W.measure) (ν := W.measure) =>
      ¬(W.after hQ T).Coherent x (Q*ρ))=(fun T => ¬T.Coherent (W.vertex x) ρ) := by
    funext T
    exact propext (not_congr (W.after_coherent hQ T x ρ))
  rw [he]
  exact W.state.step_persistence h1 hgap W.vertex W.height_bounds hm x hρ hr hold

omit [Fintype V] in
lemma coherent_eligible {x y : V} (h : W.Coherent x 20) (hd : W.distance x y < 2) :
    VertexTests.Eligible W.ambient W.state.left W.state.right W.vertex x y := by
  refine ⟨?_,?_,?_,?_⟩
  · intro z hz
    exact (h z (hz.trans (by norm_num))).1
  · intro z hz
    have hxz : dist (W.vertex x) z ≤ 20 := by
      have ht := dist_triangle (W.vertex x) (W.vertex y) z
      change dist (W.vertex x) (W.vertex y)<2 at hd
      linarith
    exact (h z hxz).1
  · intro z hz
    exact (h z (hz.trans (by norm_num))).2
  · intro z hz
    have hxz : dist (W.vertex x) z ≤ 20 := by
      have ht := dist_triangle (W.vertex x) (W.vertex y) z
      change dist (W.vertex x) (W.vertex y)<2 at hd
      linarith
    exact (h z hxz).2

lemma step_success {m : ℕ} (hm : 0 < m) (hmany : 10000 ≤ m) {x y : V}
    (hc : W.Coherent x 20) (hlo : 1 ≤ W.distance x y) (hhi : W.distance x y < 2) :
    successChance ≤ (W.step hQ h1 hgap hm).prob (fun Z => Z.Successful (Q*successGain) x y) := by
  rw [step,Execution.prob_bind_pure]
  apply le_trans (W.state.step_success h1 hgap W.vertex W.height_bounds hm (W.coherent_eligible hc hhi) hlo hhi hmany)
  apply Execution.prob_mono
  intro T hT
  exact W.after_successful hQ T hT

noncomputable def initial {M : Model (k+1)} (A : Ambient M) (v : V → M.Point Set.univ A.root) : World k V Q where
  model := M
  ambient := A
  vertex := v
  sample := Bool × ℝ
  measure := Threshold.labelMeasure
  state := {
    left := OrdinaryState.initial M kappaA
    right := BState.initial M kappaB SecondaryGeometry.Group.lam
    histories := BState.Histories.ofOrdinary (A := A) (hc := by norm_num [R]) (hcr := by norm_num [R]) (OrdinaryState.initial M kappaB) }
omit [Fintype V] in
lemma initial_coherent {M : Model (k+1)} (A : Ambient M) (v : V → M.Point Set.univ A.root) (x : V) (ρ : ℝ) :
    (initial (Q := Q) A v).Coherent x ρ := by
  intro z hz
  exact ⟨rfl,rfl⟩
end World
end PlanarL1.Columns.Model

end

end OAI