import Mathlib
import OAI.Analysis.IrrationalRotation.Model.PhaseFailure

namespace OAI

namespace Invariant233.ProductPhases

theorem mem_nonzeroIntegerWindow {R : ℝ} {k : ℤ} :
    k ∈ nonzeroIntegerWindow R ↔ k ≠ 0 ∧ |(k : ℝ)| ≤ R := by
  simp only [nonzeroIntegerWindow, Finset.mem_erase, Finset.mem_Icc]
  constructor
  · rintro ⟨hk, hlo, hhi⟩
    refine ⟨hk, abs_le.mpr ⟨?_, Int.le_floor.mp hhi⟩⟩
    have hn : -k ≤ Int.floor R := by omega
    have hh := Int.le_floor.mp hn
    simp only [Int.cast_neg] at hh
    linarith
  · rintro ⟨hk, habs⟩
    obtain ⟨hlo, hhi⟩ := abs_le.mp habs
    have hn : -k ≤ Int.floor R := Int.le_floor.mpr (by push_cast; linarith)
    exact ⟨hk, by omega, Int.le_floor.mpr hhi⟩

theorem card_nonzeroIntegerWindow {R : ℝ} (hR : 0 ≤ R) :
    ((nonzeroIntegerWindow R).card : ℤ) = 2 * Int.floor R := by
  have hf : 0 ≤ Int.floor R := Int.floor_nonneg.mpr hR
  have hz : (0 : ℤ) ∈ Finset.Icc (-Int.floor R) (Int.floor R) := by
    simp only [Finset.mem_Icc]
    omega
  have he := Finset.card_erase_add_one hz
  have he' : ((nonzeroIntegerWindow R).card : ℤ) + 1 =
      ((Finset.Icc (-Int.floor R) (Int.floor R)).card : ℤ) := by
    exact_mod_cast he
  have hI := Int.card_Icc_of_le (a := -Int.floor R) (b := Int.floor R) (by omega)
  omega

theorem card_nonzeroIntegerWindow_le {R : ℝ} (hR : 0 ≤ R) :
    ((nonzeroIntegerWindow R).card : ℝ) ≤ 2 * R := by
  have he : ((nonzeroIntegerWindow R).card : ℝ) = 2 * (Int.floor R : ℝ) := by
    exact_mod_cast card_nonzeroIntegerWindow hR
  rw [he]
  exact mul_le_mul_of_nonneg_left (Int.floor_le R) (by norm_num)

theorem mem_largePhaseTimes {N R : ℝ} (hN : 0 < N) {k : ℤ} :
    k ∈ largePhaseTimes N R ↔ N / 4 ≤ |(k : ℝ)| ∧ |(k : ℝ)| ≤ R := by
  simp only [largePhaseTimes, Finset.mem_filter, mem_nonzeroIntegerWindow]
  constructor
  · rintro ⟨⟨_, hR⟩, hlo⟩
    exact ⟨hlo, hR⟩
  · rintro ⟨hlo, hR⟩
    refine ⟨⟨?_, hR⟩, hlo⟩
    intro hk
    subst k
    norm_num at hlo
    linarith

theorem card_largePhaseTimes_le {N R : ℝ} (hR : 0 ≤ R) :
    ((largePhaseTimes N R).card : ℝ) ≤ 2 * R := by
  apply le_trans _ (card_nonzeroIntegerWindow_le hR)
  unfold largePhaseTimes
  exact_mod_cast Finset.card_filter_le
    (nonzeroIntegerWindow R) (fun k : ℤ => N / 4 ≤ |(k : ℝ)|)

end Invariant233.ProductPhases

end OAI