Module docstring
{"# Reverse on Fin n
This file contains lemmas about Fin.rev : Fin n → Fin n which maps i to n - 1 - i.
Definitions
Fin.revPerm : Equiv.Perm (Fin n):Fin.revas anEquiv.Perm, the antitone involution given byi ↦ n-(i+1)"}
{"# Reverse on Fin n
This file contains lemmas about Fin.rev : Fin n → Fin n which maps i to n - 1 - i.
Fin.revPerm : Equiv.Perm (Fin n) : Fin.rev as an Equiv.Perm, the antitone involution given
by i ↦ n-(i+1)
"}Fin.rev_involutive
      theorem
     : Involutive (rev : Fin n → Fin n)
        theorem rev_involutive : Involutive (rev : Fin n → Fin n) := rev_rev
        Fin.revPerm
      definition
     : Equiv.Perm (Fin n)
        /-- `Fin.rev` as an `Equiv.Perm`, the antitone involution `Fin n → Fin n` given by
`i ↦ n-(i+1)`. -/
@[simps! apply symm_apply]
def revPerm : Equiv.Perm (Fin n) :=
  Involutive.toPerm rev rev_involutive
        Fin.rev_injective
      theorem
     : Injective (@rev n)
        theorem rev_injective : Injective (@rev n) :=
  rev_involutive.injective
        Fin.rev_surjective
      theorem
     : Surjective (@rev n)
        theorem rev_surjective : Surjective (@rev n) :=
  rev_involutive.surjective
        Fin.rev_bijective
      theorem
     : Bijective (@rev n)
        theorem rev_bijective : Bijective (@rev n) :=
  rev_involutive.bijective
        Fin.revPerm_symm
      theorem
     : (@revPerm n).symm = revPerm
        @[simp]
theorem revPerm_symm : (@revPerm n).symm = revPerm :=
  rfl
        Fin.cast_rev
      theorem
     (i : Fin n) (h : n = m) : i.rev.cast h = (i.cast h).rev
        
      Fin.rev_eq_iff
      theorem
     {i j : Fin n} : rev i = j ↔ i = rev j
        theorem rev_eq_iff {i j : Fin n} : revrev i = j ↔ i = rev j := by
  rw [← rev_inj, rev_rev]
        Fin.rev_ne_iff
      theorem
     {i j : Fin n} : rev i ≠ j ↔ i ≠ rev j
        theorem rev_ne_iff {i j : Fin n} : revrev i ≠ jrev i ≠ j ↔ i ≠ rev j := rev_eq_iff.not
        Fin.rev_lt_iff
      theorem
     {i j : Fin n} : rev i < j ↔ rev j < i
        theorem rev_lt_iff {i j : Fin n} : revrev i < j ↔ rev j < i := by
  rw [← rev_lt_rev, rev_rev]
        Fin.rev_le_iff
      theorem
     {i j : Fin n} : rev i ≤ j ↔ rev j ≤ i
        theorem rev_le_iff {i j : Fin n} : revrev i ≤ j ↔ rev j ≤ i := by
  rw [← rev_le_rev, rev_rev]
        Fin.lt_rev_iff
      theorem
     {i j : Fin n} : i < rev j ↔ j < rev i
        theorem lt_rev_iff {i j : Fin n} : i < rev j ↔ j < rev i := by
  rw [← rev_lt_rev, rev_rev]
        Fin.le_rev_iff
      theorem
     {i j : Fin n} : i ≤ rev j ↔ j ≤ rev i
        theorem le_rev_iff {i j : Fin n} : i ≤ rev j ↔ j ≤ rev i := by
  rw [← rev_le_rev, rev_rev]
        Fin.val_rev_zero
      theorem
     [NeZero n] : ((rev 0 : Fin n) : ℕ) = n.pred
        
      Fin.succAbove_rev_left
      theorem
     (p : Fin (n + 1)) (i : Fin n) : p.rev.succAbove i = (p.succAbove i.rev).rev
        lemma succAbove_rev_left (p : Fin (n + 1)) (i : Fin n) :
    p.rev.succAbove i = (p.succAbove i.rev).rev := by
  obtain h | h := (rev p).succ_le_or_le_castSucc i
  · rw [succAbove_of_succ_le _ _ h,
      succAbove_of_le_castSucc _ _ (rev_succ _ ▸ (le_rev_iff.mpr h)), rev_succ, rev_rev]
  · rw [succAbove_of_le_castSucc _ _ h,
      succAbove_of_succ_le _ _ (rev_castSucc _ ▸ (rev_le_iff.mpr h)), rev_castSucc, rev_rev]
        Fin.succAbove_rev_right
      theorem
     (p : Fin (n + 1)) (i : Fin n) : p.succAbove i.rev = (p.rev.succAbove i).rev
        lemma succAbove_rev_right (p : Fin (n + 1)) (i : Fin n) :
    p.succAbove i.rev = (p.rev.succAbove i).rev := by rw [succAbove_rev_left, rev_rev]
        Fin.rev_succAbove
      theorem
     (p : Fin (n + 1)) (i : Fin n) : rev (succAbove p i) = succAbove (rev p) (rev i)
        /-- `rev` commutes with `succAbove`. -/
lemma rev_succAbove (p : Fin (n + 1)) (i : Fin n) :
    rev (succAbove p i) = succAbove (rev p) (rev i) := by
  rw [succAbove_rev_left, rev_rev]
        Fin.predAbove_rev_left
      theorem
     (p : Fin n) (i : Fin (n + 1)) : p.rev.predAbove i = (p.predAbove i.rev).rev
        lemma predAbove_rev_left (p : Fin n) (i : Fin (n + 1)) :
    p.rev.predAbove i = (p.predAbove i.rev).rev := by
  obtain h | h := (rev i).succ_le_or_le_castSucc p
  · rw [predAbove_of_succ_le _ _ h, rev_pred,
      predAbove_of_le_castSucc _ _ (rev_succ _ ▸ (le_rev_iff.mpr h)), castPred_inj, rev_rev]
  · rw [predAbove_of_le_castSucc _ _ h, rev_castPred,
      predAbove_of_succ_le _ _ (rev_castSucc _ ▸ (rev_le_iff.mpr h)), pred_inj, rev_rev]
        Fin.predAbove_rev_right
      theorem
     (p : Fin n) (i : Fin (n + 1)) : p.predAbove i.rev = (p.rev.predAbove i).rev
        lemma predAbove_rev_right (p : Fin n) (i : Fin (n + 1)) :
    p.predAbove i.rev = (p.rev.predAbove i).rev := by rw [predAbove_rev_left, rev_rev]
        Fin.rev_predAbove
      theorem
     {n : ℕ} (p : Fin n) (i : Fin (n + 1)) : (predAbove p i).rev = predAbove p.rev i.rev
        
      Fin.add_rev_cast
      theorem
     (j : Fin (n + 1)) : j.1 + j.rev.1 = n
        lemma add_rev_cast (j : Fin (n+1)) : j.1 + j.rev.1 = n := by
  obtain ⟨j, hj⟩ := j
  simp [Nat.add_sub_cancel' <| le_of_lt_succ hj]
        Fin.rev_add_cast
      theorem
     (j : Fin (n + 1)) : j.rev.1 + j.1 = n
        lemma rev_add_cast (j : Fin (n+1)) : j.rev.1 + j.1 = n := by
  rw [Nat.add_comm, j.add_rev_cast]