ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.foldl_monotone
theorem foldl_monotone [Preorder α] {f : α → β → α} (H : ∀ b, Monotone fun a ↦ f a b)
    (l : List β) : Monotone fun a ↦ l.foldl f a 
Arguments: {α : Type u} {β : Type v} [Preorder α] {f : α → β → α} (H : ∀ (b : β), Monotone fun a => f a b) (l : List β)
Goal: Monotone fun a => List.foldl f a l
-- List.foldr_monotone
theorem foldr_monotone [Preorder β] {f : α → β → β} (H : ∀ a, Monotone (f a)) (l : List α) :
    Monotone fun b ↦ l.foldr f b 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β → β} (H : ∀ (a : α), Monotone (f a)) (l : List α)
Goal: Monotone fun b => List.foldr f b l
-- List.foldl_strictMono
theorem foldl_strictMono [Preorder α] {f : α → β → α} (H : ∀ b, StrictMono fun a ↦ f a b)
    (l : List β) : StrictMono fun a ↦ l.foldl f a 
Arguments: {α : Type u} {β : Type v} [Preorder α] {f : α → β → α} (H : ∀ (b : β), StrictMono fun a => f a b) (l : List β)
Goal: StrictMono fun a => List.foldl f a l
-- List.foldr_strictMono
theorem foldr_strictMono [Preorder β] {f : α → β → β} (H : ∀ a, StrictMono (f a)) (l : List α) :
    StrictMono fun b ↦ l.foldr f b 
Arguments: {α : Type u} {β : Type v} [Preorder β] {f : α → β → β} (H : ∀ (a : α), StrictMono (f a)) (l : List α)
Goal: StrictMono fun b => List.foldr f b l
-- Monotone.reflect_lt
theorem Monotone.reflect_lt (hf : Monotone f) {a b : α} (h : f a < f b) : a < b 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : Monotone f) {a b : α} (h : f a < f b)
Goal: a < b
-- Antitone.reflect_lt
theorem Antitone.reflect_lt (hf : Antitone f) {a b : α} (h : f a < f b) : b < a 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : Antitone f) {a b : α} (h : f a < f b)
Goal: b < a
-- MonotoneOn.reflect_lt
theorem MonotoneOn.reflect_lt (hf : MonotoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
    (h : f a < f b) : a < b 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} {s : Set α} (hf : MonotoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) (h : f a < f b)
Goal: a < b
-- AntitoneOn.reflect_lt
theorem AntitoneOn.reflect_lt (hf : AntitoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
    (h : f a < f b) : b < a 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} {s : Set α} (hf : AntitoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) (h : f a < f b)
Goal: b < a
-- StrictMonoOn.le_iff_le
theorem StrictMonoOn.le_iff_le (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a ≤ f b ↔ a ≤ b 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} {s : Set α} (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
Goal: f a ≤ f b ↔ a ≤ b
-- StrictAntiOn.le_iff_le
theorem StrictAntiOn.le_iff_le (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a ≤ f b ↔ b ≤ a 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} {s : Set α} (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
Goal: f a ≤ f b ↔ b ≤ a
-- StrictMonoOn.eq_iff_eq
theorem StrictMonoOn.eq_iff_eq (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a = f b ↔ a = b 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} {s : Set α} (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
Goal: f a = f b ↔ a = b
-- StrictAntiOn.eq_iff_eq
theorem StrictAntiOn.eq_iff_eq (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a = f b ↔ b = a 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} {s : Set α} (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
Goal: f a = f b ↔ b = a
-- StrictMonoOn.lt_iff_lt
theorem StrictMonoOn.lt_iff_lt (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a < f b ↔ a < b 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} {s : Set α} (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
Goal: f a < f b ↔ a < b
-- StrictAntiOn.lt_iff_lt
theorem StrictAntiOn.lt_iff_lt (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a < f b ↔ b < a 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} {s : Set α} (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
Goal: f a < f b ↔ b < a
-- StrictMono.le_iff_le
theorem StrictMono.le_iff_le (hf : StrictMono f) {a b : α} : f a ≤ f b ↔ a ≤ b 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : StrictMono f) {a b : α}
Goal: f a ≤ f b ↔ a ≤ b
-- StrictAnti.le_iff_le
theorem StrictAnti.le_iff_le (hf : StrictAnti f) {a b : α} : f a ≤ f b ↔ b ≤ a 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : StrictAnti f) {a b : α}
Goal: f a ≤ f b ↔ b ≤ a
-- StrictMono.lt_iff_lt
theorem StrictMono.lt_iff_lt (hf : StrictMono f) {a b : α} : f a < f b ↔ a < b 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : StrictMono f) {a b : α}
Goal: f a < f b ↔ a < b
-- StrictAnti.lt_iff_lt
theorem StrictAnti.lt_iff_lt (hf : StrictAnti f) {a b : α} : f a < f b ↔ b < a 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : StrictAnti f) {a b : α}
Goal: f a < f b ↔ b < a
-- StrictMonoOn.compares
protected theorem StrictMonoOn.compares (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s)
    (hb : b ∈ s) : ∀ {o : Ordering}, o.Compares (f a) (f b) ↔ o.Compares a b
  
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} {s : Set α} (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) {o : Ordering}
Goal: o.Compares (f a) (f b) ↔ o.Compares a b
-- StrictAntiOn.compares
protected theorem StrictAntiOn.compares (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s)
    (hb : b ∈ s) {o : Ordering} : o.Compares (f a) (f b) ↔ o.Compares b a 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} {s : Set α} (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) {o : Ordering}
Goal: o.Compares (f a) (f b) ↔ o.Compares b a
-- StrictMono.compares
protected theorem StrictMono.compares (hf : StrictMono f) {a b : α} {o : Ordering} :
    o.Compares (f a) (f b) ↔ o.Compares a b 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : StrictMono f) {a b : α} {o : Ordering}
Goal: o.Compares (f a) (f b) ↔ o.Compares a b
-- StrictAnti.compares
protected theorem StrictAnti.compares (hf : StrictAnti f) {a b : α} {o : Ordering} :
    o.Compares (f a) (f b) ↔ o.Compares b a 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : StrictAnti f) {a b : α} {o : Ordering}
Goal: o.Compares (f a) (f b) ↔ o.Compares b a
-- StrictMono.injective
theorem StrictMono.injective (hf : StrictMono f) : Injective f 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : StrictMono f)
Goal: Function.Injective f
-- StrictAnti.injective
theorem StrictAnti.injective (hf : StrictAnti f) : Injective f 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : StrictAnti f)
Goal: Function.Injective f
-- StrictMono.maximal_of_maximal_image
theorem StrictMono.maximal_of_maximal_image (hf : StrictMono f) {a} (hmax : ∀ p, p ≤ f a) (x : α) :
    x ≤ a 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : StrictMono f) {a : α} (hmax : ∀ (p : β), p ≤ f a) (x : α)
Goal: x ≤ a
-- StrictMono.minimal_of_minimal_image
theorem StrictMono.minimal_of_minimal_image (hf : StrictMono f) {a} (hmin : ∀ p, f a ≤ p) (x : α) :
    a ≤ x 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : StrictMono f) {a : α} (hmin : ∀ (p : β), f a ≤ p) (x : α)
Goal: a ≤ x
-- StrictAnti.minimal_of_maximal_image
theorem StrictAnti.minimal_of_maximal_image (hf : StrictAnti f) {a} (hmax : ∀ p, p ≤ f a) (x : α) :
    a ≤ x 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : StrictAnti f) {a : α} (hmax : ∀ (p : β), p ≤ f a) (x : α)
Goal: a ≤ x
-- StrictAnti.maximal_of_minimal_image
theorem StrictAnti.maximal_of_minimal_image (hf : StrictAnti f) {a} (hmin : ∀ p, f a ≤ p) (x : α) :
    x ≤ a 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [Preorder β] {f : α → β} (hf : StrictAnti f) {a : α} (hmin : ∀ (p : β), f a ≤ p) (x : α)
Goal: x ≤ a
-- Monotone.strictMono_iff_injective
theorem Monotone.strictMono_iff_injective (hf : Monotone f) : StrictMono f ↔ Injective f 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [PartialOrder β] {f : α → β} (hf : Monotone f)
Goal: StrictMono f ↔ Function.Injective f
-- Antitone.strictAnti_iff_injective
theorem Antitone.strictAnti_iff_injective (hf : Antitone f) : StrictAnti f ↔ Injective f 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [PartialOrder β] {f : α → β} (hf : Antitone f)
Goal: StrictAnti f ↔ Function.Injective f
-- Monotone.eq_of_le_of_le
theorem Monotone.eq_of_le_of_le {a₁ a₂ : α} (h_mon : Monotone f) (h_fa : f a₁ = f a₂) {i : α}
    (h₁ : a₁ ≤ i) (h₂ : i ≤ a₂) : f i = f a₁ 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [PartialOrder β] {f : α → β} {a₁ a₂ : α} (h_mon : Monotone f) (h_fa : f a₁ = f a₂) {i : α} (h₁ : a₁ ≤ i) (h₂ : i ≤ a₂)
Goal: f i = f a₁
-- Antitone.eq_of_le_of_le
theorem Antitone.eq_of_le_of_le {a₁ a₂ : α} (h_anti : Antitone f) (h_fa : f a₁ = f a₂) {i : α}
    (h₁ : a₁ ≤ i) (h₂ : i ≤ a₂) : f i = f a₁ 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [PartialOrder β] {f : α → β} {a₁ a₂ : α} (h_anti : Antitone f) (h_fa : f a₁ = f a₂) {i : α} (h₁ : a₁ ≤ i) (h₂ : i ≤ a₂)
Goal: f i = f a₁
-- not_monotone_not_antitone_iff_exists_le_le
lemma not_monotone_not_antitone_iff_exists_le_le :
    ¬ Monotone f ∧ ¬ Antitone f ↔
      ∃ a b c, a ≤ b ∧ b ≤ c ∧ ((f a < f b ∧ f c < f b) ∨ (f b < f a ∧ f b < f c)) 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [LinearOrder β] {f : α → β}
Goal: ¬Monotone f ∧ ¬Antitone f ↔ ∃ a b c, a ≤ b ∧ b ≤ c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)
-- not_monotone_not_antitone_iff_exists_lt_lt
lemma not_monotone_not_antitone_iff_exists_lt_lt :
    ¬ Monotone f ∧ ¬ Antitone f ↔ ∃ a b c, a < b ∧ b < c ∧
    (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c) 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [LinearOrder β] {f : α → β}
Goal: ¬Monotone f ∧ ¬Antitone f ↔ ∃ a b c, a < b ∧ b < c ∧ (f a < f b ∧ f c < f b ∨ f b < f a ∧ f b < f c)
-- StrictMonoOn.cmp_map_eq
theorem StrictMonoOn.cmp_map_eq (hf : StrictMonoOn f s) (hx : x ∈ s) (hy : y ∈ s) :
    cmp (f x) (f y) = cmp x y 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [LinearOrder β] {f : α → β} {s : Set α} {x y : α} (hf : StrictMonoOn f s) (hx : x ∈ s) (hy : y ∈ s)
Goal: cmp (f x) (f y) = cmp x y
-- StrictMono.cmp_map_eq
theorem StrictMono.cmp_map_eq (hf : StrictMono f) (x y : α) : cmp (f x) (f y) = cmp x y 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [LinearOrder β] {f : α → β} (hf : StrictMono f) (x y : α)
Goal: cmp (f x) (f y) = cmp x y
-- StrictAntiOn.cmp_map_eq
theorem StrictAntiOn.cmp_map_eq (hf : StrictAntiOn f s) (hx : x ∈ s) (hy : y ∈ s) :
    cmp (f x) (f y) = cmp y x 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [LinearOrder β] {f : α → β} {s : Set α} {x y : α} (hf : StrictAntiOn f s) (hx : x ∈ s) (hy : y ∈ s)
Goal: cmp (f x) (f y) = cmp y x
-- StrictAnti.cmp_map_eq
theorem StrictAnti.cmp_map_eq (hf : StrictAnti f) (x y : α) : cmp (f x) (f y) = cmp y x 
Arguments: {α : Type u} {β : Type v} [LinearOrder α] [LinearOrder β] {f : α → β} (hf : StrictAnti f) (x y : α)
Goal: cmp (f x) (f y) = cmp y x
-- Nat.rel_of_forall_rel_succ_of_le_of_lt
theorem Nat.rel_of_forall_rel_succ_of_le_of_lt (r : β → β → Prop) [IsTrans β r] {f : ℕ → β} {a : ℕ}
    (h : ∀ n, a ≤ n → r (f n) (f (n + 1))) ⦃b c : ℕ⦄ (hab : a ≤ b) (hbc : b < c) :
    r (f b) (f c) 
Arguments: {β : Type v} (r : β → β → Prop) [IsTrans β r] {f : ℕ → β} {a : ℕ} (h : ∀ (n : ℕ), a ≤ n → r (f n) (f (n + 1))) ⦃b c : ℕ⦄ (hab : a ≤ b) (hbc : b < c)
Goal: r (f b) (f c)
-- Nat.rel_of_forall_rel_succ_of_le_of_le
theorem Nat.rel_of_forall_rel_succ_of_le_of_le (r : β → β → Prop) [IsRefl β r] [IsTrans β r]
    {f : ℕ → β} {a : ℕ} (h : ∀ n, a ≤ n → r (f n) (f (n + 1)))
    ⦃b c : ℕ⦄ (hab : a ≤ b) (hbc : b ≤ c) : r (f b) (f c) 
Arguments: {β : Type v} (r : β → β → Prop) [IsRefl β r] [IsTrans β r] {f : ℕ → β} {a : ℕ} (h : ∀ (n : ℕ), a ≤ n → r (f n) (f (n + 1))) ⦃b c : ℕ⦄ (hab : a ≤ b) (hbc : b ≤ c)
Goal: r (f b) (f c)
-- Nat.rel_of_forall_rel_succ_of_lt
theorem Nat.rel_of_forall_rel_succ_of_lt (r : β → β → Prop) [IsTrans β r] {f : ℕ → β}
    (h : ∀ n, r (f n) (f (n + 1))) ⦃a b : ℕ⦄ (hab : a < b) : r (f a) (f b) 
Arguments: {β : Type v} (r : β → β → Prop) [IsTrans β r] {f : ℕ → β} (h : ∀ (n : ℕ), r (f n) (f (n + 1))) ⦃a b : ℕ⦄ (hab : a < b)
Goal: r (f a) (f b)
-- Nat.rel_of_forall_rel_succ_of_le
theorem Nat.rel_of_forall_rel_succ_of_le (r : β → β → Prop) [IsRefl β r] [IsTrans β r] {f : ℕ → β}
    (h : ∀ n, r (f n) (f (n + 1))) ⦃a b : ℕ⦄ (hab : a ≤ b) : r (f a) (f b) 
Arguments: {β : Type v} (r : β → β → Prop) [IsRefl β r] [IsTrans β r] {f : ℕ → β} (h : ∀ (n : ℕ), r (f n) (f (n + 1))) ⦃a b : ℕ⦄ (hab : a ≤ b)
Goal: r (f a) (f b)
-- monotone_nat_of_le_succ
theorem monotone_nat_of_le_succ {f : ℕ → α} (hf : ∀ n, f n ≤ f (n + 1)) : Monotone f 
Arguments: {α : Type u} [Preorder α] {f : ℕ → α} (hf : ∀ (n : ℕ), f n ≤ f (n + 1))
Goal: Monotone f
-- antitone_nat_of_succ_le
theorem antitone_nat_of_succ_le {f : ℕ → α} (hf : ∀ n, f (n + 1) ≤ f n) : Antitone f 
Arguments: {α : Type u} [Preorder α] {f : ℕ → α} (hf : ∀ (n : ℕ), f (n + 1) ≤ f n)
Goal: Antitone f
-- strictMono_nat_of_lt_succ
theorem strictMono_nat_of_lt_succ {f : ℕ → α} (hf : ∀ n, f n < f (n + 1)) : StrictMono f 
Arguments: {α : Type u} [Preorder α] {f : ℕ → α} (hf : ∀ (n : ℕ), f n < f (n + 1))
Goal: StrictMono f
-- strictAnti_nat_of_succ_lt
theorem strictAnti_nat_of_succ_lt {f : ℕ → α} (hf : ∀ n, f (n + 1) < f n) : StrictAnti f 
Arguments: {α : Type u} [Preorder α] {f : ℕ → α} (hf : ∀ (n : ℕ), f (n + 1) < f n)
Goal: StrictAnti f
-- Nat.exists_strictMono'
theorem exists_strictMono' [NoMaxOrder α] (a : α) : ∃ f : ℕ → α, StrictMono f ∧ f 0 = a 
Arguments: {α : Type u} [Preorder α] [NoMaxOrder α] (a : α)
Goal: ∃ f, StrictMono f ∧ f 0 = a
-- Nat.exists_strictAnti'
theorem exists_strictAnti' [NoMinOrder α] (a : α) : ∃ f : ℕ → α, StrictAnti f ∧ f 0 = a 
Arguments: {α : Type u} [Preorder α] [NoMinOrder α] (a : α)
Goal: ∃ f, StrictAnti f ∧ f 0 = a
-- Nat.exists_strictMono
theorem exists_strictMono [Nonempty α] [NoMaxOrder α] : ∃ f : ℕ → α, StrictMono f 
Arguments: (α : Type u) [Preorder α] [Nonempty α] [NoMaxOrder α]
Goal: ∃ f, StrictMono f
-- Nat.exists_strictAnti
theorem exists_strictAnti [Nonempty α] [NoMinOrder α] : ∃ f : ℕ → α, StrictAnti f 
Arguments: (α : Type u) [Preorder α] [Nonempty α] [NoMinOrder α]
Goal: ∃ f, StrictAnti f
-- Int.rel_of_forall_rel_succ_of_lt
theorem Int.rel_of_forall_rel_succ_of_lt (r : β → β → Prop) [IsTrans β r] {f : ℤ → β}
    (h : ∀ n, r (f n) (f (n + 1))) ⦃a b : ℤ⦄ (hab : a < b) : r (f a) (f b) 
Arguments: {β : Type v} (r : β → β → Prop) [IsTrans β r] {f : ℤ → β} (h : ∀ (n : ℤ), r (f n) (f (n + 1))) ⦃a b : ℤ⦄ (hab : a < b)
Goal: r (f a) (f b)
-- Int.rel_of_forall_rel_succ_of_le
theorem Int.rel_of_forall_rel_succ_of_le (r : β → β → Prop) [IsRefl β r] [IsTrans β r] {f : ℤ → β}
    (h : ∀ n, r (f n) (f (n + 1))) ⦃a b : ℤ⦄ (hab : a ≤ b) : r (f a) (f b) 
Arguments: {β : Type v} (r : β → β → Prop) [IsRefl β r] [IsTrans β r] {f : ℤ → β} (h : ∀ (n : ℤ), r (f n) (f (n + 1))) ⦃a b : ℤ⦄ (hab : a ≤ b)
Goal: r (f a) (f b)
-- monotone_int_of_le_succ
theorem monotone_int_of_le_succ {f : ℤ → α} (hf : ∀ n, f n ≤ f (n + 1)) : Monotone f 
Arguments: {α : Type u} [Preorder α] {f : ℤ → α} (hf : ∀ (n : ℤ), f n ≤ f (n + 1))
Goal: Monotone f
-- antitone_int_of_succ_le
theorem antitone_int_of_succ_le {f : ℤ → α} (hf : ∀ n, f (n + 1) ≤ f n) : Antitone f 
Arguments: {α : Type u} [Preorder α] {f : ℤ → α} (hf : ∀ (n : ℤ), f (n + 1) ≤ f n)
Goal: Antitone f
-- strictMono_int_of_lt_succ
theorem strictMono_int_of_lt_succ {f : ℤ → α} (hf : ∀ n, f n < f (n + 1)) : StrictMono f 
Arguments: {α : Type u} [Preorder α] {f : ℤ → α} (hf : ∀ (n : ℤ), f n < f (n + 1))
Goal: StrictMono f
-- strictAnti_int_of_succ_lt
theorem strictAnti_int_of_succ_lt {f : ℤ → α} (hf : ∀ n, f (n + 1) < f n) : StrictAnti f 
Arguments: {α : Type u} [Preorder α] {f : ℤ → α} (hf : ∀ (n : ℤ), f (n + 1) < f n)
Goal: StrictAnti f
-- Int.exists_strictMono
theorem exists_strictMono : ∃ f : ℤ → α, StrictMono f 
Arguments: (α : Type u) [Preorder α] [Nonempty α] [NoMinOrder α] [NoMaxOrder α]
Goal: ∃ f, StrictMono f
-- Int.exists_strictAnti
theorem exists_strictAnti : ∃ f : ℤ → α, StrictAnti f 
Arguments: (α : Type u) [Preorder α] [Nonempty α] [NoMinOrder α] [NoMaxOrder α]
Goal: ∃ f, StrictAnti f
-- Monotone.ne_of_lt_of_lt_nat
theorem Monotone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Monotone f) (n : ℕ) {x : α} (h1 : f n < x)
    (h2 : x < f (n + 1)) (a : ℕ) : f a ≠ x 
Arguments: {α : Type u} [Preorder α] {f : ℕ → α} (hf : Monotone f) (n : ℕ) {x : α} (h1 : f n < x) (h2 : x < f (n + 1)) (a : ℕ)
Goal: f a ≠ x
-- Antitone.ne_of_lt_of_lt_nat
theorem Antitone.ne_of_lt_of_lt_nat {f : ℕ → α} (hf : Antitone f) (n : ℕ) {x : α}
    (h1 : f (n + 1) < x) (h2 : x < f n) (a : ℕ) : f a ≠ x 
Arguments: {α : Type u} [Preorder α] {f : ℕ → α} (hf : Antitone f) (n : ℕ) {x : α} (h1 : f (n + 1) < x) (h2 : x < f n) (a : ℕ)
Goal: f a ≠ x
-- Monotone.ne_of_lt_of_lt_int
theorem Monotone.ne_of_lt_of_lt_int {f : ℤ → α} (hf : Monotone f) (n : ℤ) {x : α} (h1 : f n < x)
    (h2 : x < f (n + 1)) (a : ℤ) : f a ≠ x 
Arguments: {α : Type u} [Preorder α] {f : ℤ → α} (hf : Monotone f) (n : ℤ) {x : α} (h1 : f n < x) (h2 : x < f (n + 1)) (a : ℤ)
Goal: f a ≠ x
-- Antitone.ne_of_lt_of_lt_int
theorem Antitone.ne_of_lt_of_lt_int {f : ℤ → α} (hf : Antitone f) (n : ℤ) {x : α}
    (h1 : f (n + 1) < x) (h2 : x < f n) (a : ℤ) : f a ≠ x 
Arguments: {α : Type u} [Preorder α] {f : ℤ → α} (hf : Antitone f) (n : ℤ) {x : α} (h1 : f (n + 1) < x) (h2 : x < f n) (a : ℤ)
Goal: f a ≠ x
-- StrictMono.id_le
theorem StrictMono.id_le {φ : ℕ → ℕ} (h : StrictMono φ) : ∀ n, n ≤ φ n 
Arguments: {φ : ℕ → ℕ} (h : StrictMono φ) (n : ℕ)
Goal: n ≤ φ n
-- Subtype.mono_coe
theorem Subtype.mono_coe [Preorder α] (t : Set α) : Monotone ((↑) : Subtype t → α) 
Arguments: {α : Type u} [Preorder α] (t : Set α)
Goal: Monotone Subtype.val
-- Subtype.strictMono_coe
theorem Subtype.strictMono_coe [Preorder α] (t : Set α) :
    StrictMono ((↑) : Subtype t → α) 
Arguments: {α : Type u} [Preorder α] (t : Set α)
Goal: StrictMono Subtype.val
-- monotone_fst
theorem monotone_fst : Monotone (@Prod.fst α β) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β]
Goal: Monotone Prod.fst
-- monotone_snd
theorem monotone_snd : Monotone (@Prod.snd α β) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β]
Goal: Monotone Prod.snd
-- Monotone.prod_map
theorem Monotone.prod_map (hf : Monotone f) (hg : Monotone g) : Monotone (Prod.map f g) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_2} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ] {f : α → γ} {g : β → δ} (hf : Monotone f) (hg : Monotone g)
Goal: Monotone (Prod.map f g)
-- Antitone.prod_map
theorem Antitone.prod_map (hf : Antitone f) (hg : Antitone g) : Antitone (Prod.map f g) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_2} [Preorder α] [Preorder β] [Preorder γ] [Preorder δ] {f : α → γ} {g : β → δ} (hf : Antitone f) (hg : Antitone g)
Goal: Antitone (Prod.map f g)
-- StrictMono.prod_map
theorem StrictMono.prod_map (hf : StrictMono f) (hg : StrictMono g) : StrictMono (Prod.map f g) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_2} [PartialOrder α] [PartialOrder β] [Preorder γ] [Preorder δ] {f : α → γ} {g : β → δ} (hf : StrictMono f) (hg : StrictMono g)
Goal: StrictMono (Prod.map f g)
-- StrictAnti.prod_map
theorem StrictAnti.prod_map (hf : StrictAnti f) (hg : StrictAnti g) : StrictAnti (Prod.map f g) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} {δ : Type u_2} [PartialOrder α] [PartialOrder β] [Preorder γ] [Preorder δ] {f : α → γ} {g : β → δ} (hf : StrictAnti f) (hg : StrictAnti g)
Goal: StrictAnti (Prod.map f g)
-- Function.update_mono
theorem update_mono : Monotone (update f i) 
Arguments: {ι : Type u_1} {π : ι → Type u_3} [DecidableEq ι] [(i : ι) → Preorder (π i)] {f : (i : ι) → π i} {i : ι}
Goal: Monotone (Function.update f i)
-- Function.update_strictMono
theorem update_strictMono : StrictMono (update f i) 
Arguments: {ι : Type u_1} {π : ι → Type u_3} [DecidableEq ι] [(i : ι) → Preorder (π i)] {f : (i : ι) → π i} {i : ι}
Goal: StrictMono (Function.update f i)
-- Function.const_mono
theorem const_mono : Monotone (const β : α → β → α) 
Arguments: {α : Type u} {β : Type v} [Preorder α]
Goal: Monotone (Function.const β)
-- Function.const_strictMono
theorem const_strictMono [Nonempty β] : StrictMono (const β : α → β → α) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Nonempty β]
Goal: StrictMono (Function.const β)
-- monotone_iff_apply₂
lemma monotone_iff_apply₂ : Monotone f ↔ ∀ i, Monotone (f · i) 
Arguments: {ι : Type u_4} {α : Type u_5} {β : ι → Type u_6} [(i : ι) → Preorder (β i)] [Preorder α] {f : α → (i : ι) → β i}
Goal: Monotone f ↔ ∀ (i : ι), Monotone fun x => f x i
-- antitone_iff_apply₂
lemma antitone_iff_apply₂ : Antitone f ↔ ∀ i, Antitone (f · i) 
Arguments: {ι : Type u_4} {α : Type u_5} {β : ι → Type u_6} [(i : ι) → Preorder (β i)] [Preorder α] {f : α → (i : ι) → β i}
Goal: Antitone f ↔ ∀ (i : ι), Antitone fun x => f x i
-- of_eq
theorem of_eq [IsRefl α r] : ∀ {a b}, a = b → r a b
  
Arguments: {α : Type u} {r : α → α → Prop} [IsRefl α r] {a b : α}
Goal: a = b → r a b
-- comm
theorem comm [IsSymm α r] {a b : α} : r a b ↔ r b a 
Arguments: {α : Type u} {r : α → α → Prop} [IsSymm α r] {a b : α}
Goal: r a b ↔ r b a
-- antisymm'
theorem antisymm' [IsAntisymm α r] {a b : α} : r a b → r b a → b = a 
Arguments: {α : Type u} {r : α → α → Prop} [IsAntisymm α r] {a b : α}
Goal: r a b → r b a → b = a
-- antisymm_iff
theorem antisymm_iff [IsRefl α r] [IsAntisymm α r] {a b : α} : r a b ∧ r b a ↔ a = b 
Arguments: {α : Type u} {r : α → α → Prop} [IsRefl α r] [IsAntisymm α r] {a b : α}
Goal: r a b ∧ r b a ↔ a = b
-- antisymm_of
@[elab_without_expected_type]
theorem antisymm_of (r : α → α → Prop) [IsAntisymm α r] {a b : α} : r a b → r b a → a = b 
Arguments: {α : Type u} (r : α → α → Prop) [IsAntisymm α r] {a b : α}
Goal: r a b → r b a → a = b
-- antisymm_of'
@[elab_without_expected_type]
theorem antisymm_of' (r : α → α → Prop) [IsAntisymm α r] {a b : α} : r a b → r b a → b = a 
Arguments: {α : Type u} (r : α → α → Prop) [IsAntisymm α r] {a b : α}
Goal: r a b → r b a → b = a
-- comm_of
theorem comm_of (r : α → α → Prop) [IsSymm α r] {a b : α} : r a b ↔ r b a 
Arguments: {α : Type u} (r : α → α → Prop) [IsSymm α r] {a b : α}
Goal: r a b ↔ r b a
-- IsRefl.swap
theorem IsRefl.swap (r) [IsRefl α r] : IsRefl α (swap r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsRefl α r]
Goal: IsRefl α (Function.swap r)
-- IsIrrefl.swap
theorem IsIrrefl.swap (r) [IsIrrefl α r] : IsIrrefl α (swap r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsIrrefl α r]
Goal: IsIrrefl α (Function.swap r)
-- IsTrans.swap
theorem IsTrans.swap (r) [IsTrans α r] : IsTrans α (swap r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsTrans α r]
Goal: IsTrans α (Function.swap r)
-- IsAntisymm.swap
theorem IsAntisymm.swap (r) [IsAntisymm α r] : IsAntisymm α (swap r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsAntisymm α r]
Goal: IsAntisymm α (Function.swap r)
-- IsAsymm.swap
theorem IsAsymm.swap (r) [IsAsymm α r] : IsAsymm α (swap r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsAsymm α r]
Goal: IsAsymm α (Function.swap r)
-- IsTotal.swap
theorem IsTotal.swap (r) [IsTotal α r] : IsTotal α (swap r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsTotal α r]
Goal: IsTotal α (Function.swap r)
-- IsTrichotomous.swap
theorem IsTrichotomous.swap (r) [IsTrichotomous α r] : IsTrichotomous α (swap r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsTrichotomous α r]
Goal: IsTrichotomous α (Function.swap r)
-- IsPreorder.swap
theorem IsPreorder.swap (r) [IsPreorder α r] : IsPreorder α (swap r) 
Arguments: {α : Type u} (r : α → α → Prop) [IsPreorder α r]
Goal: IsPreorder α (Function.swap r)