ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- finSuccAboveOrderIso_symm_apply_ne_last
lemma finSuccAboveOrderIso_symm_apply_ne_last {p : Fin (n + 1)} (h : p ≠ Fin.last n)
    (x : { x : Fin (n + 1) // x ≠ p }) :
    (finSuccAboveEquiv p).symm x = (p.castLT (Fin.val_lt_last h)).predAbove x 
Arguments: {n : ℕ} {p : Fin (n + 1)} (h : p ≠ Fin.last n) (x : { x // x ≠ p })
Goal: (finSuccAboveEquiv p).symm x = (p.castLT ⋯).predAbove ↑x
-- Fin.castLEOrderIso_symm_apply
@[simps apply symm_apply]
def Fin.castLEOrderIso {n m : ℕ} (h : n ≤ m) : Fin n ≃o { i : Fin m // (i : ℕ) < n } 
Arguments: {n m : ℕ} (h : n ≤ m) (i : { i // ↑i < n })
Goal: (RelIso.symm (Fin.castLEOrderIso h)) i = ⟨↑↑i, ⋯⟩
-- Fin.castLEOrderIso_apply
@[simps apply symm_apply]
def Fin.castLEOrderIso {n m : ℕ} (h : n ≤ m) : Fin n ≃o { i : Fin m // (i : ℕ) < n } 
Arguments: {n m : ℕ} (h : n ≤ m) (i : Fin n)
Goal: (Fin.castLEOrderIso h) i = ⟨Fin.castLE h i, ⋯⟩
-- cmpLE_swap
theorem cmpLE_swap {α} [LE α] [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)] (x y : α) :
    (cmpLE x y).swap = cmpLE y x 
Arguments: {α : Type u_3} [LE α] [IsTotal α fun x x_1 => x ≤ x_1] [DecidableRel fun x x_1 => x ≤ x_1] (x y : α)
Goal: (cmpLE x y).swap = cmpLE y x
-- cmpLE_eq_cmp
theorem cmpLE_eq_cmp {α} [Preorder α] [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)]
    [@DecidableRel α (· < ·)] (x y : α) : cmpLE x y = cmp x y 
Arguments: {α : Type u_3} [Preorder α] [IsTotal α fun x x_1 => x ≤ x_1] [DecidableRel fun x x_1 => x ≤ x_1] [DecidableRel fun x x_1 => x < x_1] (x y : α)
Goal: cmpLE x y = cmp x y
-- Ordering.compares_lt
@[simp]
lemma compares_lt [LT α] (a b : α) : Compares lt a b = (a < b) 
Arguments: {α : Type u_1} [LT α] (a b : α)
Goal: Ordering.lt.Compares a b = (a < b)
-- Ordering.compares_eq
@[simp]
lemma compares_eq [LT α] (a b : α) : Compares eq a b = (a = b) 
Arguments: {α : Type u_1} [LT α] (a b : α)
Goal: Ordering.eq.Compares a b = (a = b)
-- Ordering.compares_gt
@[simp]
lemma compares_gt [LT α] (a b : α) : Compares gt a b = (a > b) 
Arguments: {α : Type u_1} [LT α] (a b : α)
Goal: Ordering.gt.Compares a b = (a > b)
-- Ordering.compares_swap
theorem compares_swap [LT α] {a b : α} {o : Ordering} : o.swap.Compares a b ↔ o.Compares b a 
Arguments: {α : Type u_1} [LT α] {a b : α} {o : Ordering}
Goal: o.swap.Compares a b ↔ o.Compares b a
-- Ordering.swap_eq_iff_eq_swap
theorem swap_eq_iff_eq_swap {o o' : Ordering} : o.swap = o' ↔ o = o'.swap 
Arguments: {o o' : Ordering}
Goal: o.swap = o' ↔ o = o'.swap
-- Ordering.Compares.eq_lt
theorem Compares.eq_lt [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o = lt ↔ a < b)
  
Arguments: {α : Type u_1} [Preorder α] {o : Ordering} {a b : α}
Goal: o.Compares a b → (o = Ordering.lt ↔ a < b)
-- Ordering.Compares.ne_lt
theorem Compares.ne_lt [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o ≠ lt ↔ b ≤ a)
  
Arguments: {α : Type u_1} [Preorder α] {o : Ordering} {a b : α}
Goal: o.Compares a b → (o ≠ Ordering.lt ↔ b ≤ a)
-- Ordering.Compares.eq_eq
theorem Compares.eq_eq [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o = eq ↔ a = b)
  
Arguments: {α : Type u_1} [Preorder α] {o : Ordering} {a b : α}
Goal: o.Compares a b → (o = Ordering.eq ↔ a = b)
-- Ordering.Compares.eq_gt
theorem Compares.eq_gt [Preorder α] {o} {a b : α} (h : Compares o a b) : o = gt ↔ b < a 
Arguments: {α : Type u_1} [Preorder α] {o : Ordering} {a b : α} (h : o.Compares a b)
Goal: o = Ordering.gt ↔ b < a
-- Ordering.Compares.ne_gt
theorem Compares.ne_gt [Preorder α] {o} {a b : α} (h : Compares o a b) : o ≠ gt ↔ a ≤ b 
Arguments: {α : Type u_1} [Preorder α] {o : Ordering} {a b : α} (h : o.Compares a b)
Goal: o ≠ Ordering.gt ↔ a ≤ b
-- Ordering.Compares.le_total
theorem Compares.le_total [Preorder α] {a b : α} : ∀ {o}, Compares o a b → a ≤ b ∨ b ≤ a
  
Arguments: {α : Type u_1} [Preorder α] {a b : α} {o : Ordering}
Goal: o.Compares a b → a ≤ b ∨ b ≤ a
-- Ordering.Compares.le_antisymm
theorem Compares.le_antisymm [Preorder α] {a b : α} : ∀ {o}, Compares o a b → a ≤ b → b ≤ a → a = b
  
Arguments: {α : Type u_1} [Preorder α] {a b : α} {o : Ordering}
Goal: o.Compares a b → a ≤ b → b ≤ a → a = b
-- Ordering.Compares.inj
theorem Compares.inj [Preorder α] {o₁} :
    ∀ {o₂} {a b : α}, Compares o₁ a b → Compares o₂ a b → o₁ = o₂
  
Arguments: {α : Type u_1} [Preorder α] {o₁ o₂ : Ordering} {a b : α}
Goal: o₁.Compares a b → o₂.Compares a b → o₁ = o₂
-- Ordering.compares_iff_of_compares_impl
theorem compares_iff_of_compares_impl [LinearOrder α] [Preorder β] {a b : α} {a' b' : β}
    (h : ∀ {o}, Compares o a b → Compares o a' b') (o) : Compares o a b ↔ Compares o a' b' 
Arguments: {α : Type u_1} {β : Type u_2} [LinearOrder α] [Preorder β] {a b : α} {a' b' : β} (h : ∀ {o : Ordering}, o.Compares a b → o.Compares a' b') (o : Ordering)
Goal: o.Compares a b ↔ o.Compares a' b'
-- Ordering.swap_orElse
theorem swap_orElse (o₁ o₂) : (orElse o₁ o₂).swap = orElse o₁.swap o₂.swap 
Arguments: (o₁ o₂ : Ordering)
Goal: (o₁.orElse o₂).swap = o₁.swap.orElse o₂.swap
-- Ordering.orElse_eq_lt
theorem orElse_eq_lt (o₁ o₂) : orElse o₁ o₂ = lt ↔ o₁ = lt ∨ o₁ = eq ∧ o₂ = lt 
Arguments: (o₁ o₂ : Ordering)
Goal: o₁.orElse o₂ = Ordering.lt ↔ o₁ = Ordering.lt ∨ o₁ = Ordering.eq ∧ o₂ = Ordering.lt
-- toDual_compares_toDual
@[simp]
theorem toDual_compares_toDual [LT α] {a b : α} {o : Ordering} :
    Compares o (toDual a) (toDual b) ↔ Compares o b a 
Arguments: {α : Type u_1} [LT α] {a b : α} {o : Ordering}
Goal: o.Compares (OrderDual.toDual a) (OrderDual.toDual b) ↔ o.Compares b a
-- ofDual_compares_ofDual
@[simp]
theorem ofDual_compares_ofDual [LT α] {a b : αᵒᵈ} {o : Ordering} :
    Compares o (ofDual a) (ofDual b) ↔ Compares o b a 
Arguments: {α : Type u_1} [LT α] {a b : αᵒᵈ} {o : Ordering}
Goal: o.Compares (OrderDual.ofDual a) (OrderDual.ofDual b) ↔ o.Compares b a
-- cmp_compares
theorem cmp_compares [LinearOrder α] (a b : α) : (cmp a b).Compares a b 
Arguments: {α : Type u_1} [LinearOrder α] (a b : α)
Goal: (cmp a b).Compares a b
-- Ordering.Compares.cmp_eq
theorem Ordering.Compares.cmp_eq [LinearOrder α] {a b : α} {o : Ordering} (h : o.Compares a b) :
    cmp a b = o 
Arguments: {α : Type u_1} [LinearOrder α] {a b : α} {o : Ordering} (h : o.Compares a b)
Goal: cmp a b = o
-- cmp_swap
@[simp]
theorem cmp_swap [Preorder α] [@DecidableRel α (· < ·)] (a b : α) : (cmp a b).swap = cmp b a 
Arguments: {α : Type u_1} [Preorder α] [DecidableRel fun x x_1 => x < x_1] (a b : α)
Goal: (cmp a b).swap = cmp b a
-- cmpLE_toDual
@[simp, nolint simpNF]
theorem cmpLE_toDual [LE α] [@DecidableRel α (· ≤ ·)] (x y : α) :
    cmpLE (toDual x) (toDual y) = cmpLE y x 
Arguments: {α : Type u_1} [LE α] [DecidableRel fun x x_1 => x ≤ x_1] (x y : α)
Goal: cmpLE (OrderDual.toDual x) (OrderDual.toDual y) = cmpLE y x
-- cmpLE_ofDual
@[simp]
theorem cmpLE_ofDual [LE α] [@DecidableRel α (· ≤ ·)] (x y : αᵒᵈ) :
    cmpLE (ofDual x) (ofDual y) = cmpLE y x 
Arguments: {α : Type u_1} [LE α] [DecidableRel fun x x_1 => x ≤ x_1] (x y : αᵒᵈ)
Goal: cmpLE (OrderDual.ofDual x) (OrderDual.ofDual y) = cmpLE y x
-- cmp_toDual
@[simp, nolint simpNF]
theorem cmp_toDual [LT α] [@DecidableRel α (· < ·)] (x y : α) :
    cmp (toDual x) (toDual y) = cmp y x 
Arguments: {α : Type u_1} [LT α] [DecidableRel fun x x_1 => x < x_1] (x y : α)
Goal: cmp (OrderDual.toDual x) (OrderDual.toDual y) = cmp y x
-- cmp_ofDual
@[simp]
theorem cmp_ofDual [LT α] [@DecidableRel α (· < ·)] (x y : αᵒᵈ) :
    cmp (ofDual x) (ofDual y) = cmp y x 
Arguments: {α : Type u_1} [LT α] [DecidableRel fun x x_1 => x < x_1] (x y : αᵒᵈ)
Goal: cmp (OrderDual.ofDual x) (OrderDual.ofDual y) = cmp y x
-- cmp_eq_lt_iff
@[simp]
theorem cmp_eq_lt_iff : cmp x y = Ordering.lt ↔ x < y 
Arguments: {α : Type u_1} [LinearOrder α] (x y : α)
Goal: cmp x y = Ordering.lt ↔ x < y
-- cmp_eq_eq_iff
@[simp]
theorem cmp_eq_eq_iff : cmp x y = Ordering.eq ↔ x = y 
Arguments: {α : Type u_1} [LinearOrder α] (x y : α)
Goal: cmp x y = Ordering.eq ↔ x = y
-- cmp_eq_gt_iff
@[simp]
theorem cmp_eq_gt_iff : cmp x y = Ordering.gt ↔ y < x 
Arguments: {α : Type u_1} [LinearOrder α] (x y : α)
Goal: cmp x y = Ordering.gt ↔ y < x
-- cmp_self_eq_eq
@[simp]
theorem cmp_self_eq_eq : cmp x x = Ordering.eq 
Arguments: {α : Type u_1} [LinearOrder α] (x : α)
Goal: cmp x x = Ordering.eq
-- cmp_eq_cmp_symm
theorem cmp_eq_cmp_symm : cmp x y = cmp x' y' ↔ cmp y x = cmp y' x' 
Arguments: {α : Type u_1} [LinearOrder α] {x y : α} {β : Type u_3} [LinearOrder β] {x' y' : β}
Goal: cmp x y = cmp x' y' ↔ cmp y x = cmp y' x'
-- lt_iff_lt_of_cmp_eq_cmp
theorem lt_iff_lt_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x < y ↔ x' < y' 
Arguments: {α : Type u_1} [LinearOrder α] {x y : α} {β : Type u_3} [LinearOrder β] {x' y' : β} (h : cmp x y = cmp x' y')
Goal: x < y ↔ x' < y'
-- le_iff_le_of_cmp_eq_cmp
theorem le_iff_le_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x ≤ y ↔ x' ≤ y' 
Arguments: {α : Type u_1} [LinearOrder α] {x y : α} {β : Type u_3} [LinearOrder β] {x' y' : β} (h : cmp x y = cmp x' y')
Goal: x ≤ y ↔ x' ≤ y'
-- eq_iff_eq_of_cmp_eq_cmp
theorem eq_iff_eq_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x = y ↔ x' = y' 
Arguments: {α : Type u_1} [LinearOrder α] {x y : α} {β : Type u_3} [LinearOrder β] {x' y' : β} (h : cmp x y = cmp x' y')
Goal: x = y ↔ x' = y'
-- LT.lt.cmp_eq_lt
theorem LT.lt.cmp_eq_lt (h : x < y) : cmp x y = Ordering.lt 
Arguments: {α : Type u_1} [LinearOrder α] {x y : α} (h : x < y)
Goal: cmp x y = Ordering.lt
-- LT.lt.cmp_eq_gt
theorem LT.lt.cmp_eq_gt (h : x < y) : cmp y x = Ordering.gt 
Arguments: {α : Type u_1} [LinearOrder α] {x y : α} (h : x < y)
Goal: cmp y x = Ordering.gt
-- Eq.cmp_eq_eq
theorem Eq.cmp_eq_eq (h : x = y) : cmp x y = Ordering.eq 
Arguments: {α : Type u_1} [LinearOrder α] {x y : α} (h : x = y)
Goal: cmp x y = Ordering.eq
-- Eq.cmp_eq_eq'
theorem Eq.cmp_eq_eq' (h : x = y) : cmp y x = Ordering.eq 
Arguments: {α : Type u_1} [LinearOrder α] {x y : α} (h : x = y)
Goal: cmp y x = Ordering.eq
-- Fin.top_eq_last
lemma top_eq_last (n : ℕ) : ⊤ = Fin.last n 
Arguments: (n : ℕ)
Goal: ⊤ = Fin.last n
-- Fin.bot_eq_zero
lemma bot_eq_zero (n : ℕ) : ⊥ = (0 : Fin (n + 1)) 
Arguments: (n : ℕ)
Goal: ⊥ = 0
-- Fin.rev_bot
@[simp] theorem rev_bot [NeZero n] : rev (⊥ : Fin n) = ⊤ 
Arguments: {n : ℕ} [NeZero n]
Goal: ⊥.rev = ⊤
-- Fin.rev_top
@[simp] theorem rev_top [NeZero n] : rev (⊤ : Fin n) = ⊥ 
Arguments: {n : ℕ} [NeZero n]
Goal: ⊤.rev = ⊥
-- Fin.rev_zero_eq_top
theorem rev_zero_eq_top (n : ℕ) [NeZero n] : rev (0 : Fin n) = ⊤ 
Arguments: (n : ℕ) [NeZero n]
Goal: Fin.rev 0 = ⊤
-- Fin.rev_last_eq_bot
theorem rev_last_eq_bot (n : ℕ) : rev (last n) = ⊥ 
Arguments: (n : ℕ)
Goal: (Fin.last n).rev = ⊥
-- Fin.strictMono_pred_comp
lemma strictMono_pred_comp (hf : ∀ a, f a ≠ 0) (hf₂ : StrictMono f) :
    StrictMono (fun a => pred (f a) (hf a)) 
Arguments: {n : ℕ} {α : Type u_1} [Preorder α] {f : α → Fin (n + 1)} (hf : ∀ (a : α), f a ≠ 0) (hf₂ : StrictMono f)
Goal: StrictMono fun a => (f a).pred ⋯
-- Fin.monotone_pred_comp
lemma monotone_pred_comp (hf : ∀ a, f a ≠ 0) (hf₂ : Monotone f) :
    Monotone (fun a => pred (f a) (hf a)) 
Arguments: {n : ℕ} {α : Type u_1} [Preorder α] {f : α → Fin (n + 1)} (hf : ∀ (a : α), f a ≠ 0) (hf₂ : Monotone f)
Goal: Monotone fun a => (f a).pred ⋯
-- Fin.strictMono_castPred_comp
lemma strictMono_castPred_comp (hf : ∀ a, f a ≠ last n) (hf₂ : StrictMono f) :
    StrictMono (fun a => castPred (f a) (hf a)) 
Arguments: {n : ℕ} {α : Type u_1} [Preorder α] {f : α → Fin (n + 1)} (hf : ∀ (a : α), f a ≠ Fin.last n) (hf₂ : StrictMono f)
Goal: StrictMono fun a => (f a).castPred ⋯
-- Fin.monotone_castPred_comp
lemma monotone_castPred_comp (hf : ∀ a, f a ≠ last n) (hf₂ : Monotone f) :
    Monotone (fun a => castPred (f a) (hf a)) 
Arguments: {n : ℕ} {α : Type u_1} [Preorder α] {f : α → Fin (n + 1)} (hf : ∀ (a : α), f a ≠ Fin.last n) (hf₂ : Monotone f)
Goal: Monotone fun a => (f a).castPred ⋯
-- Fin.strictMono_iff_lt_succ
lemma strictMono_iff_lt_succ : StrictMono f ↔ ∀ i : Fin n, f (castSucc i) < f i.succ 
Arguments: {n : ℕ} {α : Type u_1} [Preorder α] {f : Fin (n + 1) → α}
Goal: StrictMono f ↔ ∀ (i : Fin n), f i.castSucc < f i.succ
-- Fin.monotone_iff_le_succ
lemma monotone_iff_le_succ : Monotone f ↔ ∀ i : Fin n, f (castSucc i) ≤ f i.succ 
Arguments: {n : ℕ} {α : Type u_1} [Preorder α] {f : Fin (n + 1) → α}
Goal: Monotone f ↔ ∀ (i : Fin n), f i.castSucc ≤ f i.succ
-- Fin.strictAnti_iff_succ_lt
lemma strictAnti_iff_succ_lt : StrictAnti f ↔ ∀ i : Fin n, f i.succ < f (castSucc i) 
Arguments: {n : ℕ} {α : Type u_1} [Preorder α] {f : Fin (n + 1) → α}
Goal: StrictAnti f ↔ ∀ (i : Fin n), f i.succ < f i.castSucc
-- Fin.antitone_iff_succ_le
lemma antitone_iff_succ_le : Antitone f ↔ ∀ i : Fin n, f i.succ ≤ f (castSucc i) 
Arguments: {n : ℕ} {α : Type u_1} [Preorder α] {f : Fin (n + 1) → α}
Goal: Antitone f ↔ ∀ (i : Fin n), f i.succ ≤ f i.castSucc
-- Fin.val_strictMono
lemma val_strictMono : StrictMono (val : Fin n → ℕ) 
Arguments: {n : ℕ}
Goal: StrictMono Fin.val
-- Fin.strictMono_succ
lemma strictMono_succ : StrictMono (succ : Fin n → Fin (n + 1)) 
Arguments: {n : ℕ}
Goal: StrictMono Fin.succ
-- Fin.strictMono_castLE
lemma strictMono_castLE (h : n ≤ m) : StrictMono (castLE h : Fin n → Fin m) 
Arguments: {m n : ℕ} (h : n ≤ m)
Goal: StrictMono (Fin.castLE h)
-- Fin.strictMono_castAdd
lemma strictMono_castAdd (m) : StrictMono (castAdd m : Fin n → Fin (n + m)) 
Arguments: {n : ℕ} (m : ℕ)
Goal: StrictMono (Fin.castAdd m)
-- Fin.strictMono_castSucc
lemma strictMono_castSucc : StrictMono (castSucc : Fin n → Fin (n + 1)) 
Arguments: {n : ℕ}
Goal: StrictMono Fin.castSucc
-- Fin.strictMono_natAdd
lemma strictMono_natAdd (n) : StrictMono (natAdd n : Fin m → Fin (n + m)) 
Arguments: {m : ℕ} (n : ℕ)
Goal: StrictMono (Fin.natAdd n)
-- Fin.strictMono_addNat
lemma strictMono_addNat (m) : StrictMono ((addNat · m) : Fin n → Fin (n + m)) 
Arguments: {n : ℕ} (m : ℕ)
Goal: StrictMono fun x => x.addNat m
-- Fin.strictMono_succAbove
lemma strictMono_succAbove (p : Fin (n + 1)) : StrictMono (succAbove p) 
Arguments: {n : ℕ} (p : Fin (n + 1))
Goal: StrictMono p.succAbove
-- Fin.succAbove_lt_succAbove_iff
lemma succAbove_lt_succAbove_iff : succAbove p i < succAbove p j ↔ i < j 
Arguments: {n : ℕ} {p : Fin (n + 1)} {i j : Fin n}
Goal: p.succAbove i < p.succAbove j ↔ i < j
-- Fin.succAbove_le_succAbove_iff
lemma succAbove_le_succAbove_iff : succAbove p i ≤ succAbove p j ↔ i ≤ j 
Arguments: {n : ℕ} {p : Fin (n + 1)} {i j : Fin n}
Goal: p.succAbove i ≤ p.succAbove j ↔ i ≤ j
-- Fin.predAbove_right_monotone
lemma predAbove_right_monotone (p : Fin n) : Monotone p.predAbove 
Arguments: {n : ℕ} (p : Fin n)
Goal: Monotone p.predAbove
-- Fin.predAbove_left_monotone
lemma predAbove_left_monotone (i : Fin (n + 1)) : Monotone fun p ↦ predAbove p i 
Arguments: {n : ℕ} (i : Fin (n + 1))
Goal: Monotone fun p => p.predAbove i
-- Fin.predAboveOrderHom_coe
@[simps!] def predAboveOrderHom (p : Fin n) : Fin (n + 1) →o Fin n 
Arguments: {n : ℕ} (p : Fin n) (i : Fin (n + 1))
Goal: p.predAboveOrderHom i = p.predAbove i
-- Fin.orderIsoSubtype_apply
@[simps! apply symm_apply]
def orderIsoSubtype : Fin n ≃o {i // i < n} 
Arguments: {n : ℕ} (a : Fin n)
Goal: Fin.orderIsoSubtype a = ⟨↑a, ⋯⟩
-- Fin.orderIsoSubtype_symm_apply
@[simps! apply symm_apply]
def orderIsoSubtype : Fin n ≃o {i // i < n} 
Arguments: {n : ℕ} (a : { i // i < n })
Goal: (RelIso.symm Fin.orderIsoSubtype) a = ⟨↑a, ⋯⟩
-- Fin.castOrderIso_symm_apply
@[simps]
def castOrderIso (eq : n = m) : Fin n ≃o Fin m 
Arguments: {m n : ℕ} (eq : n = m) (i : Fin m)
Goal: (RelIso.symm (Fin.castOrderIso eq)) i = Fin.cast ⋯ i
-- Fin.castOrderIso_apply
@[simps]
def castOrderIso (eq : n = m) : Fin n ≃o Fin m 
Arguments: {m n : ℕ} (eq : n = m) (i : Fin n)
Goal: (Fin.castOrderIso eq) i = Fin.cast eq i
-- Fin.symm_castOrderIso
@[simp]
lemma symm_castOrderIso (h : n = m) : (castOrderIso h).symm = castOrderIso h.symm 
Arguments: {m n : ℕ} (h : n = m)
Goal: (Fin.castOrderIso h).symm = Fin.castOrderIso ⋯
-- Fin.castOrderIso_refl
@[simp]
lemma castOrderIso_refl (h : n = n := rfl) : castOrderIso h = OrderIso.refl (Fin n) 
Arguments: {n : ℕ} (h : n = n := ⋯)
Goal: Fin.castOrderIso h = OrderIso.refl (Fin n)
-- Fin.castOrderIso_toEquiv
lemma castOrderIso_toEquiv (h : n = m) : (castOrderIso h).toEquiv = Equiv.cast (h ▸ rfl) 
Arguments: {m n : ℕ} (h : n = m)
Goal: (Fin.castOrderIso h).toEquiv = Equiv.cast ⋯
-- Fin.revOrderIso_apply
@[simps! apply toEquiv]
def revOrderIso : (Fin n)ᵒᵈ ≃o Fin n 
Arguments: {n : ℕ}
Goal: ∀ (a : (Fin n)ᵒᵈ), Fin.revOrderIso a = (OrderDual.ofDual a).rev
-- Fin.revOrderIso_toEquiv
@[simps! apply toEquiv]
def revOrderIso : (Fin n)ᵒᵈ ≃o Fin n 
Arguments: {n : ℕ}
Goal: Fin.revOrderIso.toEquiv = OrderDual.ofDual.trans Fin.revPerm
-- Fin.revOrderIso_symm_apply
@[simp]
lemma revOrderIso_symm_apply (i : Fin n) : revOrderIso.symm i = OrderDual.toDual (rev i) 
Arguments: {n : ℕ} (i : Fin n)
Goal: Fin.revOrderIso.symm i = OrderDual.toDual i.rev
-- Fin.valOrderEmb_apply
@[simps! apply]
def valOrderEmb (n) : Fin n ↪o ℕ 
Arguments: (n : ℕ) (self : Fin n)
Goal: (Fin.valOrderEmb n) self = ↑self
-- Fin.coe_succOrderEmb
@[simp, norm_cast] lemma coe_succOrderEmb : ⇑(succOrderEmb n) = Fin.succ 
Arguments: {n : ℕ}
Goal: ⇑(Fin.succOrderEmb n) = Fin.succ
-- Fin.castLEOrderEmb_apply
@[simps! apply toEmbedding]
def castLEOrderEmb (h : n ≤ m) : Fin n ↪o Fin m 
Arguments: {m n : ℕ} (h : n ≤ m) (i : Fin n)
Goal: (Fin.castLEOrderEmb h) i = Fin.castLE h i
-- Fin.castLEOrderEmb_toEmbedding
@[simps! apply toEmbedding]
def castLEOrderEmb (h : n ≤ m) : Fin n ↪o Fin m 
Arguments: {m n : ℕ} (h : n ≤ m)
Goal: (Fin.castLEOrderEmb h).toEmbedding = { toFun := Fin.castLE h, inj' := ⋯ }
-- Fin.castAddOrderEmb_toEmbedding
@[simps! apply toEmbedding]
def castAddOrderEmb (m) : Fin n ↪o Fin (n + m) 
Arguments: {n : ℕ} (m : ℕ)
Goal: (Fin.castAddOrderEmb m).toEmbedding = { toFun := Fin.castAdd m, inj' := ⋯ }
-- Fin.castAddOrderEmb_apply
@[simps! apply toEmbedding]
def castAddOrderEmb (m) : Fin n ↪o Fin (n + m) 
Arguments: {n : ℕ} (m : ℕ)
Goal: ∀ (a : Fin n), (Fin.castAddOrderEmb m) a = Fin.castAdd m a
-- Fin.castSuccOrderEmb_toEmbedding
@[simps! apply toEmbedding]
def castSuccOrderEmb : Fin n ↪o Fin (n + 1) 
Arguments: {n : ℕ}
Goal: Fin.castSuccOrderEmb.toEmbedding = { toFun := Fin.castSucc, inj' := ⋯ }
-- Fin.castSuccOrderEmb_apply
@[simps! apply toEmbedding]
def castSuccOrderEmb : Fin n ↪o Fin (n + 1) 
Arguments: {n : ℕ}
Goal: ∀ (a : Fin n), Fin.castSuccOrderEmb a = a.castSucc
-- Fin.addNatOrderEmb_toEmbedding
@[simps! apply toEmbedding]
def addNatOrderEmb (m) : Fin n ↪o Fin (n + m) 
Arguments: {n : ℕ} (m : ℕ)
Goal: (Fin.addNatOrderEmb m).toEmbedding = { toFun := fun x => x.addNat m, inj' := ⋯ }
-- Fin.addNatOrderEmb_apply
@[simps! apply toEmbedding]
def addNatOrderEmb (m) : Fin n ↪o Fin (n + m) 
Arguments: {n : ℕ} (m : ℕ)
Goal: ∀ (x : Fin n), (Fin.addNatOrderEmb m) x = x.addNat m
-- Fin.natAddOrderEmb_apply
@[simps! apply toEmbedding]
def natAddOrderEmb (n) : Fin m ↪o Fin (n + m) 
Arguments: {m : ℕ} (n : ℕ) (i : Fin m)
Goal: (Fin.natAddOrderEmb n) i = Fin.natAdd n i
-- Fin.natAddOrderEmb_toEmbedding
@[simps! apply toEmbedding]
def natAddOrderEmb (n) : Fin m ↪o Fin (n + m) 
Arguments: {m : ℕ} (n : ℕ)
Goal: (Fin.natAddOrderEmb n).toEmbedding = { toFun := Fin.natAdd n, inj' := ⋯ }
-- Fin.succAboveOrderEmb_toEmbedding
@[simps! apply toEmbedding]
def succAboveOrderEmb (p : Fin (n + 1)) : Fin n ↪o Fin (n + 1) 
Arguments: {n : ℕ} (p : Fin (n + 1))
Goal: p.succAboveOrderEmb.toEmbedding = { toFun := p.succAbove, inj' := ⋯ }
-- Fin.succAboveOrderEmb_apply
@[simps! apply toEmbedding]
def succAboveOrderEmb (p : Fin (n + 1)) : Fin n ↪o Fin (n + 1) 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: p.succAboveOrderEmb i = p.succAbove i
-- Fin.coe_orderIso_apply
@[simp] lemma coe_orderIso_apply (e : Fin n ≃o Fin m) (i : Fin n) : (e i : ℕ) = i 
Arguments: {m n : ℕ} (e : Fin n ≃o Fin m) (i : Fin n)
Goal: ↑(e i) = ↑i
-- Fin.strictMono_unique
lemma strictMono_unique {f g : Fin n → α} (hf : StrictMono f) (hg : StrictMono g)
    (h : range f = range g) : f = g 
Arguments: {n : ℕ} {α : Type u_1} [Preorder α] {f g : Fin n → α} (hf : StrictMono f) (hg : StrictMono g) (h : Set.range f = Set.range g)
Goal: f = g
-- Fin.orderEmbedding_eq
lemma orderEmbedding_eq {f g : Fin n ↪o α} (h : range f = range g) : f = g 
Arguments: {n : ℕ} {α : Type u_1} [Preorder α] {f g : Fin n ↪o α} (h : Set.range ⇑f = Set.range ⇑g)
Goal: f = g
-- Rel.gc_leftDual_rightDual
theorem gc_leftDual_rightDual : GaloisConnection (toDual ∘ R.leftDual) (R.rightDual ∘ ofDual) 
Arguments: {α : Type u_1} {β : Type u_2} (R : Rel α β)
Goal: GaloisConnection (⇑OrderDual.toDual ∘ R.leftDual) (R.rightDual ∘ ⇑OrderDual.ofDual)
-- Rel.leftDual_mem_rightFixedPoint
theorem leftDual_mem_rightFixedPoint (J : Set α) : R.leftDual J ∈ R.rightFixedPoints 
Arguments: {α : Type u_1} {β : Type u_2} (R : Rel α β) (J : Set α)
Goal: R.leftDual J ∈ R.rightFixedPoints
-- Rel.rightDual_mem_leftFixedPoint
theorem rightDual_mem_leftFixedPoint (I : Set β) : R.rightDual I ∈ R.leftFixedPoints 
Arguments: {α : Type u_1} {β : Type u_2} (R : Rel α β) (I : Set β)
Goal: R.rightDual I ∈ R.leftFixedPoints
-- Rel.rightDual_leftDual_le_of_le
theorem rightDual_leftDual_le_of_le {J J' : Set α} (h : J' ∈ R.leftFixedPoints) (h₁ : J ≤ J') :
    R.rightDual (R.leftDual J) ≤ J' 
Arguments: {α : Type u_1} {β : Type u_2} (R : Rel α β) {J J' : Set α} (h : J' ∈ R.leftFixedPoints) (h₁ : J ≤ J')
Goal: R.rightDual (R.leftDual J) ≤ J'
-- Rel.leftDual_rightDual_le_of_le
theorem leftDual_rightDual_le_of_le {I I' : Set β} (h : I' ∈ R.rightFixedPoints) (h₁ : I ≤ I') :
    R.leftDual (R.rightDual I) ≤ I' 
Arguments: {α : Type u_1} {β : Type u_2} (R : Rel α β) {I I' : Set β} (h : I' ∈ R.rightFixedPoints) (h₁ : I ≤ I')
Goal: R.leftDual (R.rightDual I) ≤ I'
-- WithTop.sSup_eq
theorem WithTop.sSup_eq [SupSet α] {s : Set (WithTop α)} (hs : ⊤ ∉ s)
    (hs' : BddAbove ((↑) ⁻¹' s : Set α)) : sSup s = ↑(sSup ((↑) ⁻¹' s) : α) 
Arguments: {α : Type u_1} [Preorder α] [SupSet α] {s : Set (WithTop α)} (hs : ⊤ ∉ s) (hs' : BddAbove (WithTop.some ⁻¹' s))
Goal: sSup s = ↑(sSup (WithTop.some ⁻¹' s))
-- WithTop.sInf_eq
theorem WithTop.sInf_eq [InfSet α] {s : Set (WithTop α)} (hs : ¬s ⊆ {⊤}) (h's : BddBelow s) :
    sInf s = ↑(sInf ((↑) ⁻¹' s) : α) 
Arguments: {α : Type u_1} [Preorder α] [InfSet α] {s : Set (WithTop α)} (hs : ¬s ⊆ {⊤}) (h's : BddBelow s)
Goal: sInf s = ↑(sInf (WithTop.some ⁻¹' s))
-- WithBot.sInf_eq
theorem WithBot.sInf_eq [InfSet α] {s : Set (WithBot α)} (hs : ⊥ ∉ s)
    (hs' : BddBelow ((↑) ⁻¹' s : Set α)) : sInf s = ↑(sInf ((↑) ⁻¹' s) : α) 
Arguments: {α : Type u_1} [Preorder α] [InfSet α] {s : Set (WithBot α)} (hs : ⊥ ∉ s) (hs' : BddBelow (WithBot.some ⁻¹' s))
Goal: sInf s = ↑(sInf (WithBot.some ⁻¹' s))
-- WithBot.sSup_eq
theorem WithBot.sSup_eq [SupSet α] {s : Set (WithBot α)} (hs : ¬s ⊆ {⊥}) (h's : BddAbove s) :
    sSup s = ↑(sSup ((↑) ⁻¹' s) : α) 
Arguments: {α : Type u_1} [Preorder α] [SupSet α] {s : Set (WithBot α)} (hs : ¬s ⊆ {⊥}) (h's : BddAbove s)
Goal: sSup s = ↑(sSup (WithBot.some ⁻¹' s))
-- WithTop.sInf_empty
@[simp]
theorem WithTop.sInf_empty [InfSet α] : sInf (∅ : Set (WithTop α)) = ⊤ 
Arguments: {α : Type u_1} [Preorder α] [InfSet α]
Goal: sInf ∅ = ⊤
-- WithTop.iInf_empty
@[simp]
theorem WithTop.iInf_empty [IsEmpty ι] [InfSet α] (f : ι → WithTop α) :
    ⨅ i, f i = ⊤ 
Arguments: {α : Type u_1} {ι : Sort u_4} [Preorder α] [IsEmpty ι] [InfSet α] (f : ι → WithTop α)
Goal: ⨅ i, f i = ⊤
-- WithTop.coe_sInf'
theorem WithTop.coe_sInf' [InfSet α] {s : Set α} (hs : s.Nonempty) (h's : BddBelow s) :
    ↑(sInf s) = (sInf ((fun (a : α) ↦ ↑a) '' s) : WithTop α) 
Arguments: {α : Type u_1} [Preorder α] [InfSet α] {s : Set α} (hs : s.Nonempty) (h's : BddBelow s)
Goal: ↑(sInf s) = sInf ((fun a => ↑a) '' s)
-- WithTop.coe_iInf
@[norm_cast]
theorem WithTop.coe_iInf [Nonempty ι] [InfSet α] {f : ι → α} (hf : BddBelow (range f)) :
    ↑(⨅ i, f i) = (⨅ i, f i : WithTop α) 
Arguments: {α : Type u_1} {ι : Sort u_4} [Preorder α] [Nonempty ι] [InfSet α] {f : ι → α} (hf : BddBelow (Set.range f))
Goal: ↑(⨅ i, f i) = ⨅ i, ↑(f i)
-- WithTop.coe_sSup'
theorem WithTop.coe_sSup' [SupSet α] {s : Set α} (hs : BddAbove s) :
    ↑(sSup s) = (sSup ((fun (a : α) ↦ ↑a) '' s) : WithTop α) 
Arguments: {α : Type u_1} [Preorder α] [SupSet α] {s : Set α} (hs : BddAbove s)
Goal: ↑(sSup s) = sSup ((fun a => ↑a) '' s)