import Mathlib
import OAI.Analysis.TracialSplitting.PreparedBlocks

namespace OAI

section

namespace Pureness
namespace OrderedSemigroup
variable {S : Type*} [AddCommMonoid S] [PartialOrder S] [IsOrderedAddMonoid S]

theorem iterate_with_buffer {a b c : S} (h : a + c ≤ b + c) (n : ℕ) :
    n • a + c ≤ n • b + c := by
  induction n with
  | zero => simp
  | succ n ih =>
    calc
      (n+1) • a + c = a + (n • a + c) := by simp [succ_nsmul, add_comm, add_left_comm]
      _ ≤ a + (n • b + c) := add_le_add le_rfl ih
      _ = n • b + (a + c) := by ac_rfl
      _ ≤ n • b + (b + c) := add_le_add le_rfl h
      _ = (n+1) • b + c := by simp [succ_nsmul, add_assoc]

theorem strict_multiples_le
    (hzero : ∀ a : S, 0 ≤ a)
    (hAU : ∀ a b : S, ∀ k : ℕ, 1 ≤ k → (k+1) • a ≤ k • b → a ≤ b)
    {a b : S} {m n : ℕ} (hmn : m < n) (h : n • a ≤ m • b) : a ≤ b := by
  by_cases hm : m = 0
  · subst m
    have ha : a ≤ n • a := by
      simpa only [one_nsmul] using nsmul_le_nsmul_left (hzero a) (show 1 ≤ n by omega)
    exact ha.trans (by simpa using h) |>.trans (hzero b)
  · apply hAU a b m (by omega)
    exact (nsmul_le_nsmul_left (hzero a) (show m+1 ≤ n by omega)).trans h

theorem strict_multiples_le_of_buffer
    (hzero : ∀ a : S, 0 ≤ a)
    (hAU : ∀ a b : S, ∀ k : ℕ, 1 ≤ k → (k+1) • a ≤ k • b → a ≤ b)
    {a b c : S} {m n k : ℕ} (hmn : m < n)
    (h : n • a + c ≤ m • b + c) (hc : c ≤ k • b) : a ≤ b := by
  have hi := iterate_with_buffer h (k+1)
  have hcomp : ((k+1)*n) • a ≤ ((k+1)*m+k) • b := by
    calc
      ((k+1)*n) • a ≤ ((k+1)*n) • a + c := le_add_of_nonneg_right (hzero c)
      _ ≤ ((k+1)*m) • b + c := by simpa only [← mul_nsmul, Nat.mul_comm] using hi
      _ ≤ ((k+1)*m) • b + k • b := add_le_add le_rfl hc
      _ = ((k+1)*m+k) • b := (add_nsmul _ _ _).symm
  apply strict_multiples_le hzero hAU (m := (k+1)*m+k) (n := (k+1)*n) _ hcomp
  nlinarith

theorem properlyInfinite_of_multiple
    (hzero : ∀ a : S, 0 ≤ a)
    (hAU : ∀ a b : S, ∀ k : ℕ, 1 ≤ k → (k+1) • a ≤ k • b → a ≤ b)
    {u : S} {k : ℕ} (hk : 0 < k) (h : (2*k) • u ≤ k • u) : 2 • u ≤ u := by
  have hstep : (k+1) • u ≤ k • u :=
    (nsmul_le_nsmul_left (hzero u) (by omega : k+1 ≤ 2*k)).trans h
  have hi : ∀ j : ℕ, (k+j) • u ≤ k • u := by
    intro j
    induction j with
    | zero => simp
    | succ j ih =>
      calc
        (k+(j+1)) • u = (k+j) • u + u := by simp [add_nsmul, add_assoc]
        _ ≤ k • u + u := add_le_add ih le_rfl
        _ = (k+1) • u := by simp [add_nsmul]
        _ ≤ k • u := hstep
  apply hAU (2 • u) u k (by omega)
  simpa only [← mul_nsmul, show 2*(k+1) = k+(k+2) by omega] using hi (k+2)

theorem le_of_properlyInfinite {u a : S} (hu : 2 • u ≤ u)
    (ha : ∃ n : ℕ, a ≤ n • u) (hzero : 0 ≤ u) : a ≤ u := by
  obtain ⟨n, hn⟩ := ha
  apply hn.trans
  clear hn
  induction n with
  | zero => simpa using hzero
  | succ n ih =>
    calc
      (n+1) • u = n • u + u := by simp [add_nsmul]
      _ ≤ u + u := add_le_add ih le_rfl
      _ ≤ u := by simpa [two_nsmul] using hu

end OrderedSemigroup
end Pureness
end

end OAI