import OAI.NumberTheory.DukePrimeDegree.Entropy.FirstRootConditionalProduct

namespace OAI

/-!
# A concrete first adjacent-root product step

The first adjacent root admits a neutral contracting diagonal direction.
Starting the Gaussian chain with this root gives actual local charts to
which the proved conditional-product theorem applies.
-/

noncomputable section
open Matrix Set MeasureTheory Filter
open scoped Topology BigOperators

namespace DukePrimeDegree
open PrimeDegreePackets

theorem exists_complete_elimination_chain_from_initial {n : ℕ}
    (P : Finset (Fin n × Fin n)) (D : Finset (Fin n))
    (hP : InitialRootPattern P) (hD : PivotsFromPattern P D) :
    ∃ c : EliminationChain P D, c.finalEntries = allPositiveRoots n := by
  suffices ∀ m : ℕ, ∀ (P : Finset (Fin n × Fin n)) (D : Finset (Fin n)),
      (allPositiveRoots n \ P).card = m → InitialRootPattern P → PivotsFromPattern P D →
      ∃ c : EliminationChain P D, c.finalEntries = allPositiveRoots n by
    exact this _ P D rfl hP hD
  intro m
  induction m using Nat.strong_induction_on with
  | h m ih =>
      intro P D hcard hP hD
      by_cases hempty : allPositiveRoots n \ P = ∅
      · refine ⟨.done, ?_⟩
        change P = allPositiveRoots n
        apply Finset.Subset.antisymm
        · exact fun p hp => (hP p hp).1
        · exact Finset.sdiff_eq_empty_iff_subset.mp hempty
      · obtain ⟨p, hp, hmin⟩ := Finset.exists_min_image (allPositiveRoots n \ P)
          (fun q => toLex q) (Finset.nonempty_iff_ne_empty.mpr hempty)
        have hab : p.1 < p.2 := (Finset.mem_filter.mp (Finset.mem_sdiff.mp hp).1).2
        have hnot : p ∉ P := (Finset.mem_sdiff.mp hp).2
        have hless : (allPositiveRoots n \ insert p P).card < m := by
          rw [Finset.sdiff_insert, ← hcard]
          exact Finset.card_erase_lt_of_mem hp
        obtain ⟨c, hc⟩ := ih _ hless (insert p P) (insert p.1 D) rfl
          (initialRootPattern_insert_min hP p hp hmin) (pivotsFromPattern_insert hD p.1 p.2)
        exact ⟨.step p.1 p.2 (ne_of_lt hab)
          (initialRootPattern_stable hP hab hnot)
          (initialRootPattern_pivot_notMem hP hD hab hnot) c, hc⟩


lemma adjacent_first_initial (d : ℕ) :
    InitialRootPattern ({((0 : Fin (d + 2)), (1 : Fin (d + 2)))} :
      Finset (Fin (d + 2) × Fin (d + 2))) := by
  intro p hp
  have hp' : p = (0, 1) := Finset.mem_singleton.mp hp
  subst p
  refine ⟨Finset.mem_filter.mpr ⟨Finset.mem_univ _, by change (0 : Fin (d + 2)) < 1; norm_num⟩, ?_⟩
  intro q hq hlt
  have hq' := (Finset.mem_filter.mp hq).2
  rcases Prod.Lex.toLex_lt_toLex.mp hlt with hr | ⟨hr, hc⟩
  · exfalso
    change q.1 < (0 : Fin (d + 2)) at hr
    exact (Fin.not_lt_zero q.1) hr
  · exfalso
    have hv := congrArg Fin.val hr
    fin_omega

lemma adjacent_first_pivots (d : ℕ) :
    PivotsFromPattern ({((0 : Fin (d + 2)), (1 : Fin (d + 2)))} :
      Finset (Fin (d + 2) × Fin (d + 2))) {0} := by
  intro a ha
  have ha' : a = 0 := Finset.mem_singleton.mp ha
  subst a
  exact ⟨1, Finset.mem_singleton_self _⟩

def adjacentFirstTail (d : ℕ) :
    EliminationChain ({((0 : Fin (d + 2)), (1 : Fin (d + 2)))} :
      Finset (Fin (d + 2) × Fin (d + 2))) {0} :=
  (exists_complete_elimination_chain_from_initial _ _
    (adjacent_first_initial d) (adjacent_first_pivots d)).choose

lemma adjacentFirstTail_final (d : ℕ) :
    (adjacentFirstTail d).finalEntries = allPositiveRoots (d + 2) :=
  (exists_complete_elimination_chain_from_initial _ _
    (adjacent_first_initial d) (adjacent_first_pivots d)).choose_spec

lemma exists_adjacent_first_weights (d : ℕ) :
    ∃ ell : Fin (d + 2) → ℝ, (∑ i, ell i) = 0 ∧ ell 0 = ell 1 ∧
      ∀ p ∈ allPositiveRoots (d + 2), p ≠ (0, 1) → ell p.1 < ell p.2 := by
  refine ⟨centerWeights (d + 1) (midpointRootRaw 0 1), centerWeights_sum _ _, ?_, ?_⟩
  · unfold centerWeights
    rw [midpointRootRaw_equal]
  · intro p hp hne
    apply sub_neg.mp
    rw [centerWeights_sub]
    apply sub_neg.mpr
    apply midpointRootRaw_strict (by norm_num : (0 : Fin (d + 2)) < 1) (Finset.mem_filter.mp hp).2
    · have hp' := (Finset.mem_filter.mp hp).2
      have hnat : p.1.val + 1 ≤ p.2.val := by fin_omega
      have hreal : (p.1.val : ℝ) + 1 ≤ p.2.val := by exact_mod_cast hnat
      norm_num
      linarith
    · intro h
      exact hne (Prod.ext h.1 h.2)

end DukePrimeDegree

end

end OAI