import OAI.Combinatorics.EditApproximation.Probability.Amplification
import OAI.Combinatorics.EditApproximation.Definitions


namespace OAI

/-!
# The executable upper middle order statistic

The seed pass sorts its integer copy outputs and takes index `length/2`.
Strictly more than half the outputs below an upper bound suffice; ties
and repeated values are retained by the list representation.
-/

namespace EditApproximation



theorem upperMedian_lower (values : List ℕ) (hvalues : values ≠ []) (c : ℕ)
    (hlower : ∀ value ∈ values, c ≤ value) : c ≤ upperMedian values := by
  have hlength : 0 < values.length := List.length_pos_iff.mpr hvalues
  have hindex : values.length / 2 < (values.mergeSort (· ≤ ·)).length := by
    rw [List.length_mergeSort]
    omega
  have hmem : (values.mergeSort (· ≤ ·))[values.length / 2] ∈ values :=
    (List.mergeSort_perm values (· ≤ ·)).mem_iff.mp (List.getElem_mem hindex)
  have hmedian : upperMedian values = (values.mergeSort (· ≤ ·))[values.length / 2] := by
    exact (List.getElem_eq_getD 0).symm
  rw [hmedian]
  exact hlower _ hmem

theorem upperMedian_upper (values : List ℕ) (hvalues : values ≠ []) (upper : ℕ)
    (hmajority : values.length / 2 < values.countP (fun value => value ≤ upper)) :
    upperMedian values ≤ upper := by
  let sorted := values.mergeSort (· ≤ ·)
  have hlength : sorted.length = values.length := List.length_mergeSort values
  have hpositive : 0 < values.length := List.length_pos_iff.mpr hvalues
  have hindex : values.length / 2 < sorted.length := by omega
  have hmedian : upperMedian values = sorted[values.length / 2] :=
    (List.getElem_eq_getD 0).symm
  by_contra hnot
  have habove : upper < sorted[values.length / 2] := by omega
  have hdrop : (sorted.drop (values.length / 2)).filter (fun value => value ≤ upper) = [] := by
    apply List.filter_eq_nil_iff.mpr
    intro value hvalue
    obtain ⟨j, hj, heq⟩ := List.mem_iff_getElem.mp hvalue
    have hj' : values.length / 2 + j < sorted.length := by
      simp only [List.length_drop] at hj
      omega
    have hge : sorted[values.length / 2] ≤ sorted[values.length / 2 + j] :=
      (List.sortedLE_mergeSort (l := values)).getElem_le_getElem_of_le
        (hi := hindex) (hj := hj')
        (show values.length / 2 ≤ values.length / 2 + j by omega)
    have hget : (sorted.drop (values.length / 2))[j] = sorted[values.length / 2 + j] := by
      simp only [List.getElem_drop]
    rw [hget] at heq
    have haboveValue : upper < value := habove.trans_le (hge.trans_eq heq)
    simpa only [decide_eq_true_eq] using not_le_of_gt haboveValue
  have hdropCount : (sorted.drop (values.length / 2)).countP (fun value => value ≤ upper) = 0 := by
    rw [List.countP_eq_length_filter, hdrop]
    rfl
  have hcount : sorted.countP (fun value => value ≤ upper) ≤ values.length / 2 := by
    have hsplit := List.take_append_drop (values.length / 2) sorted
    rw [← hsplit, List.countP_append, hdropCount, Nat.add_zero]
    exact List.countP_le_length.trans (List.length_take_le _ _)
  have hperm := (List.mergeSort_perm values (· ≤ ·)).countP_eq (fun value => value ≤ upper)
  change sorted.countP (fun value => value ≤ upper) = values.countP (fun value => value ≤ upper) at hperm
  omega

theorem clamped_upperMedian_spec (values : List ℕ) (hvalues : values ≠ [])
    (c upper N : ℕ) (hcN : c ≤ N)
    (hlower : ∀ value ∈ values, c ≤ value)
    (hmajority : values.length / 2 < values.countP (fun value => value ≤ upper)) :
    c ≤ min N (upperMedian values) ∧ min N (upperMedian values) ≤ upper :=
  ⟨le_min hcN (upperMedian_lower values hvalues c hlower),
    (min_le_right _ _).trans (upperMedian_upper values hvalues upper hmajority)⟩

end EditApproximation

end OAI