File: Mathlib/Order/Monotone/Basic.lean

full_name: Monotone
code: /-- A function `f` is monotone if `a ≤ b` implies `f a ≤ f b`. -/
def Monotone (f : α → β) : Prop 
goal: Prop

full_name: Antitone
code: /-- A function `f` is antitone if `a ≤ b` implies `f b ≤ f a`. -/
def Antitone (f : α → β) : Prop 
goal: Prop

full_name: MonotoneOn
code: /-- A function `f` is monotone on `s` if, for all `a, b ∈ s`, `a ≤ b` implies `f a ≤ f b`. -/
def MonotoneOn (f : α → β) (s : Set α) : Prop 
goal: Prop

full_name: AntitoneOn
code: /-- A function `f` is antitone on `s` if, for all `a, b ∈ s`, `a ≤ b` implies `f b ≤ f a`. -/
def AntitoneOn (f : α → β) (s : Set α) : Prop 
goal: Prop

full_name: StrictMono
code: /-- A function `f` is strictly monotone if `a < b` implies `f a < f b`. -/
def StrictMono (f : α → β) : Prop 
goal: Prop

full_name: StrictAnti
code: /-- A function `f` is strictly antitone if `a < b` implies `f b < f a`. -/
def StrictAnti (f : α → β) : Prop 
goal: Prop

full_name: StrictMonoOn
code: /-- A function `f` is strictly monotone on `s` if, for all `a, b ∈ s`, `a < b` implies
`f a < f b`. -/
def StrictMonoOn (f : α → β) (s : Set α) : Prop 
goal: Prop

full_name: StrictAntiOn
code: /-- A function `f` is strictly antitone on `s` if, for all `a, b ∈ s`, `a < b` implies
`f b < f a`. -/
def StrictAntiOn (f : α → β) (s : Set α) : Prop 
goal: Prop

full_name: instDecidableMonotoneOfForallForallForallLe
code: instance [i : Decidable (∀ a b, a ≤ b → f a ≤ f b)] : Decidable (Monotone f) 
goal: Decidable (Monotone f)

full_name: instDecidableAntitoneOfForallForallForallLe
code: instance [i : Decidable (∀ a b, a ≤ b → f b ≤ f a)] : Decidable (Antitone f) 
goal: Decidable (Antitone f)

full_name: instDecidableMonotoneOnOfForallForallMemSetForallForallForallLe
code: instance [i : Decidable (∀ a ∈ s, ∀ b ∈ s, a ≤ b → f a ≤ f b)] :
    Decidable (MonotoneOn f s) 
goal: Decidable (MonotoneOn f s)

full_name: instDecidableAntitoneOnOfForallForallMemSetForallForallForallLe
code: instance [i : Decidable (∀ a ∈ s, ∀ b ∈ s, a ≤ b → f b ≤ f a)] :
    Decidable (AntitoneOn f s) 
goal: Decidable (AntitoneOn f s)

full_name: instDecidableStrictMonoOfForallForallForallLt
code: instance [i : Decidable (∀ a b, a < b → f a < f b)] : Decidable (StrictMono f) 
goal: Decidable (StrictMono f)

full_name: instDecidableStrictAntiOfForallForallForallLt
code: instance [i : Decidable (∀ a b, a < b → f b < f a)] : Decidable (StrictAnti f) 
goal: Decidable (StrictAnti f)

full_name: instDecidableStrictMonoOnOfForallForallMemSetForallForallForallLt
code: instance [i : Decidable (∀ a ∈ s, ∀ b ∈ s, a < b → f a < f b)] :
    Decidable (StrictMonoOn f s) 
goal: Decidable (StrictMonoOn f s)

full_name: instDecidableStrictAntiOnOfForallForallMemSetForallForallForallLt
code: instance [i : Decidable (∀ a ∈ s, ∀ b ∈ s, a < b → f b < f a)] :
    Decidable (StrictAntiOn f s) 
goal: Decidable (StrictAntiOn f s)

full_name: monotone_inclusion_le_le_of_le
code: lemma monotone_inclusion_le_le_of_le [Preorder α] {k j : α} (hkj : k ≤ j) :
    Monotone (fun ⟨i, hi⟩ => ⟨i, hi.trans hkj⟩ : { i // i ≤ k } → { i // i ≤ j}) 
goal: Monotone fun x =>
  match x with
  | ⟨i, hi⟩ => ⟨i, ⋯⟩

full_name: monotone_inclusion_lt_le_of_le
code: lemma monotone_inclusion_lt_le_of_le [Preorder α] {k j : α} (hkj : k ≤ j) :
    Monotone (fun ⟨i, hi⟩ => ⟨i, hi.le.trans hkj⟩ : { i // i < k } → { i // i ≤ j}) 
goal: Monotone fun x =>
  match x with
  | ⟨i, hi⟩ => ⟨i, ⋯⟩

full_name: monotone_inclusion_lt_lt_of_le
code: lemma monotone_inclusion_lt_lt_of_le [Preorder α] {k j : α} (hkj : k ≤ j) :
    Monotone (fun ⟨i, hi⟩ => ⟨i, lt_of_lt_of_le hi hkj⟩ : { i // i < k } → { i // i < j}) 
goal: Monotone fun x =>
  match x with
  | ⟨i, hi⟩ => ⟨i, ⋯⟩

full_name: monotone_comp_ofDual_iff
code: @[simp]
theorem monotone_comp_ofDual_iff : Monotone (f ∘ ofDual) ↔ Antitone f 
goal: Monotone (f ∘ ⇑OrderDual.ofDual) ↔ Antitone f

full_name: antitone_comp_ofDual_iff
code: @[simp]
theorem antitone_comp_ofDual_iff : Antitone (f ∘ ofDual) ↔ Monotone f 
goal: Antitone (f ∘ ⇑OrderDual.ofDual) ↔ Monotone f

full_name: monotone_toDual_comp_iff
code: @[simp]
theorem monotone_toDual_comp_iff : Monotone (toDual ∘ f : α → βᵒᵈ) ↔ Antitone f 
goal: Monotone (⇑OrderDual.toDual ∘ f) ↔ Antitone f

full_name: antitone_toDual_comp_iff
code: @[simp]
theorem antitone_toDual_comp_iff : Antitone (toDual ∘ f : α → βᵒᵈ) ↔ Monotone f 
goal: Antitone (⇑OrderDual.toDual ∘ f) ↔ Monotone f

full_name: monotoneOn_comp_ofDual_iff
code: @[simp]
theorem monotoneOn_comp_ofDual_iff : MonotoneOn (f ∘ ofDual) s ↔ AntitoneOn f s 
goal: MonotoneOn (f ∘ ⇑OrderDual.ofDual) s ↔ AntitoneOn f s

full_name: antitoneOn_comp_ofDual_iff
code: @[simp]
theorem antitoneOn_comp_ofDual_iff : AntitoneOn (f ∘ ofDual) s ↔ MonotoneOn f s 
goal: AntitoneOn (f ∘ ⇑OrderDual.ofDual) s ↔ MonotoneOn f s

full_name: monotoneOn_toDual_comp_iff
code: @[simp]
theorem monotoneOn_toDual_comp_iff : MonotoneOn (toDual ∘ f : α → βᵒᵈ) s ↔ AntitoneOn f s 
goal: MonotoneOn (⇑OrderDual.toDual ∘ f) s ↔ AntitoneOn f s

full_name: antitoneOn_toDual_comp_iff
code: @[simp]
theorem antitoneOn_toDual_comp_iff : AntitoneOn (toDual ∘ f : α → βᵒᵈ) s ↔ MonotoneOn f s 
goal: AntitoneOn (⇑OrderDual.toDual ∘ f) s ↔ MonotoneOn f s

full_name: strictMono_comp_ofDual_iff
code: @[simp]
theorem strictMono_comp_ofDual_iff : StrictMono (f ∘ ofDual) ↔ StrictAnti f 
goal: StrictMono (f ∘ ⇑OrderDual.ofDual) ↔ StrictAnti f

full_name: strictAnti_comp_ofDual_iff
code: @[simp]
theorem strictAnti_comp_ofDual_iff : StrictAnti (f ∘ ofDual) ↔ StrictMono f 
goal: StrictAnti (f ∘ ⇑OrderDual.ofDual) ↔ StrictMono f

full_name: strictMono_toDual_comp_iff
code: @[simp]
theorem strictMono_toDual_comp_iff : StrictMono (toDual ∘ f : α → βᵒᵈ) ↔ StrictAnti f 
goal: StrictMono (⇑OrderDual.toDual ∘ f) ↔ StrictAnti f

full_name: strictAnti_toDual_comp_iff
code: @[simp]
theorem strictAnti_toDual_comp_iff : StrictAnti (toDual ∘ f : α → βᵒᵈ) ↔ StrictMono f 
goal: StrictAnti (⇑OrderDual.toDual ∘ f) ↔ StrictMono f

full_name: strictMonoOn_comp_ofDual_iff
code: @[simp]
theorem strictMonoOn_comp_ofDual_iff : StrictMonoOn (f ∘ ofDual) s ↔ StrictAntiOn f s 
goal: StrictMonoOn (f ∘ ⇑OrderDual.ofDual) s ↔ StrictAntiOn f s

full_name: strictAntiOn_comp_ofDual_iff
code: @[simp]
theorem strictAntiOn_comp_ofDual_iff : StrictAntiOn (f ∘ ofDual) s ↔ StrictMonoOn f s 
goal: StrictAntiOn (f ∘ ⇑OrderDual.ofDual) s ↔ StrictMonoOn f s

full_name: strictMonoOn_toDual_comp_iff
code: @[simp]
theorem strictMonoOn_toDual_comp_iff : StrictMonoOn (toDual ∘ f : α → βᵒᵈ) s ↔ StrictAntiOn f s 
goal: StrictMonoOn (⇑OrderDual.toDual ∘ f) s ↔ StrictAntiOn f s

full_name: strictAntiOn_toDual_comp_iff
code: @[simp]
theorem strictAntiOn_toDual_comp_iff : StrictAntiOn (toDual ∘ f : α → βᵒᵈ) s ↔ StrictMonoOn f s 
goal: StrictAntiOn (⇑OrderDual.toDual ∘ f) s ↔ StrictMonoOn f s

full_name: monotone_dual_iff
code: theorem monotone_dual_iff : Monotone (toDual ∘ f ∘ ofDual : αᵒᵈ → βᵒᵈ) ↔ Monotone f 
goal: Monotone (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) ↔ Monotone f

full_name: antitone_dual_iff
code: theorem antitone_dual_iff : Antitone (toDual ∘ f ∘ ofDual : αᵒᵈ → βᵒᵈ) ↔ Antitone f 
goal: Antitone (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) ↔ Antitone f

full_name: monotoneOn_dual_iff
code: theorem monotoneOn_dual_iff : MonotoneOn (toDual ∘ f ∘ ofDual : αᵒᵈ → βᵒᵈ) s ↔ MonotoneOn f s 
goal: MonotoneOn (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) s ↔ MonotoneOn f s

full_name: antitoneOn_dual_iff
code: theorem antitoneOn_dual_iff : AntitoneOn (toDual ∘ f ∘ ofDual : αᵒᵈ → βᵒᵈ) s ↔ AntitoneOn f s 
goal: AntitoneOn (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) s ↔ AntitoneOn f s

full_name: strictMono_dual_iff
code: theorem strictMono_dual_iff : StrictMono (toDual ∘ f ∘ ofDual : αᵒᵈ → βᵒᵈ) ↔ StrictMono f 
goal: StrictMono (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) ↔ StrictMono f

full_name: strictAnti_dual_iff
code: theorem strictAnti_dual_iff : StrictAnti (toDual ∘ f ∘ ofDual : αᵒᵈ → βᵒᵈ) ↔ StrictAnti f 
goal: StrictAnti (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) ↔ StrictAnti f

full_name: strictMonoOn_dual_iff
code: theorem strictMonoOn_dual_iff :
    StrictMonoOn (toDual ∘ f ∘ ofDual : αᵒᵈ → βᵒᵈ) s ↔ StrictMonoOn f s 
goal: StrictMonoOn (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) s ↔ StrictMonoOn f s

full_name: strictAntiOn_dual_iff
code: theorem strictAntiOn_dual_iff :
    StrictAntiOn (toDual ∘ f ∘ ofDual : αᵒᵈ → βᵒᵈ) s ↔ StrictAntiOn f s 
goal: StrictAntiOn (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) s ↔ StrictAntiOn f s

full_name: Monotone.comp_le_comp_left
code: theorem Monotone.comp_le_comp_left
    [Preorder β] {f : β → α} {g h : γ → β} (hf : Monotone f) (le_gh : g ≤ h) :
    LE.le.{max w u} (f ∘ g) (f ∘ h) 
goal: f ∘ g ≤ f ∘ h

full_name: monotone_lam
code: theorem monotone_lam {f : α → β → γ} (hf : ∀ b, Monotone fun a ↦ f a b) : Monotone f 
goal: Monotone f

full_name: monotone_app
code: theorem monotone_app (f : β → α → γ) (b : β) (hf : Monotone fun a b ↦ f b a) : Monotone (f b) 
goal: Monotone (f b)

full_name: antitone_lam
code: theorem antitone_lam {f : α → β → γ} (hf : ∀ b, Antitone fun a ↦ f a b) : Antitone f 
goal: Antitone f

full_name: antitone_app
code: theorem antitone_app (f : β → α → γ) (b : β) (hf : Antitone fun a b ↦ f b a) : Antitone (f b) 
goal: Antitone (f b)

full_name: Function.monotone_eval
code: theorem Function.monotone_eval {ι : Type u} {α : ι → Type v} [∀ i, Preorder (α i)] (i : ι) :
    Monotone (Function.eval i : (∀ i, α i) → α i) 
goal: Monotone (Function.eval i)

full_name: Monotone.imp
code: theorem Monotone.imp (hf : Monotone f) (h : a ≤ b) : f a ≤ f b 
goal: f a ≤ f b

full_name: Antitone.imp
code: theorem Antitone.imp (hf : Antitone f) (h : a ≤ b) : f b ≤ f a 
goal: f b ≤ f a

full_name: StrictMono.imp
code: theorem StrictMono.imp (hf : StrictMono f) (h : a < b) : f a < f b 
goal: f a < f b

full_name: StrictAnti.imp
code: theorem StrictAnti.imp (hf : StrictAnti f) (h : a < b) : f b < f a 
goal: f b < f a

full_name: Monotone.monotoneOn
code: protected theorem Monotone.monotoneOn (hf : Monotone f) (s : Set α) : MonotoneOn f s 
goal: MonotoneOn f s

full_name: Antitone.antitoneOn
code: protected theorem Antitone.antitoneOn (hf : Antitone f) (s : Set α) : AntitoneOn f s 
goal: AntitoneOn f s

full_name: monotoneOn_univ
code: @[simp] theorem monotoneOn_univ : MonotoneOn f Set.univ ↔ Monotone f 
goal: MonotoneOn f Set.univ ↔ Monotone f

full_name: antitoneOn_univ
code: @[simp] theorem antitoneOn_univ : AntitoneOn f Set.univ ↔ Antitone f 
goal: AntitoneOn f Set.univ ↔ Antitone f

full_name: StrictMono.strictMonoOn
code: protected theorem StrictMono.strictMonoOn (hf : StrictMono f) (s : Set α) : StrictMonoOn f s 
goal: StrictMonoOn f s

full_name: StrictAnti.strictAntiOn
code: protected theorem StrictAnti.strictAntiOn (hf : StrictAnti f) (s : Set α) : StrictAntiOn f s 
goal: StrictAntiOn f s

full_name: strictMonoOn_univ
code: @[simp] theorem strictMonoOn_univ : StrictMonoOn f Set.univ ↔ StrictMono f 
goal: StrictMonoOn f Set.univ ↔ StrictMono f

full_name: strictAntiOn_univ
code: @[simp] theorem strictAntiOn_univ : StrictAntiOn f Set.univ ↔ StrictAnti f 
goal: StrictAntiOn f Set.univ ↔ StrictAnti f

full_name: Monotone.strictMono_of_injective
code: theorem Monotone.strictMono_of_injective (h₁ : Monotone f) (h₂ : Injective f) : StrictMono f 
goal: StrictMono f

full_name: Antitone.strictAnti_of_injective
code: theorem Antitone.strictAnti_of_injective (h₁ : Antitone f) (h₂ : Injective f) : StrictAnti f 
goal: StrictAnti f

full_name: monotone_iff_forall_lt
code: theorem monotone_iff_forall_lt : Monotone f ↔ ∀ ⦃a b⦄, a < b → f a ≤ f b 
goal: Monotone f ↔ ∀ ⦃a b : α⦄, a < b → f a ≤ f b

full_name: antitone_iff_forall_lt
code: theorem antitone_iff_forall_lt : Antitone f ↔ ∀ ⦃a b⦄, a < b → f b ≤ f a 
goal: Antitone f ↔ ∀ ⦃a b : α⦄, a < b → f b ≤ f a

full_name: monotoneOn_iff_forall_lt
code: theorem monotoneOn_iff_forall_lt :
    MonotoneOn f s ↔ ∀ ⦃a⦄ (_ : a ∈ s) ⦃b⦄ (_ : b ∈ s), a < b → f a ≤ f b 
goal: MonotoneOn f s ↔ ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → a < b → f a ≤ f b

full_name: antitoneOn_iff_forall_lt
code: theorem antitoneOn_iff_forall_lt :
    AntitoneOn f s ↔ ∀ ⦃a⦄ (_ : a ∈ s) ⦃b⦄ (_ : b ∈ s), a < b → f b ≤ f a 
goal: AntitoneOn f s ↔ ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → a < b → f b ≤ f a

full_name: StrictMonoOn.monotoneOn
code: protected theorem StrictMonoOn.monotoneOn (hf : StrictMonoOn f s) : MonotoneOn f s 
goal: MonotoneOn f s

full_name: StrictAntiOn.antitoneOn
code: protected theorem StrictAntiOn.antitoneOn (hf : StrictAntiOn f s) : AntitoneOn f s 
goal: AntitoneOn f s

full_name: StrictMono.monotone
code: protected theorem StrictMono.monotone (hf : StrictMono f) : Monotone f 
goal: Monotone f

full_name: StrictAnti.antitone
code: protected theorem StrictAnti.antitone (hf : StrictAnti f) : Antitone f 
goal: Antitone f

full_name: Subsingleton.monotone
code: protected theorem monotone [Subsingleton α] (f : α → β) : Monotone f 
goal: Monotone f

full_name: Subsingleton.antitone
code: protected theorem antitone [Subsingleton α] (f : α → β) : Antitone f 
goal: Antitone f

full_name: Subsingleton.monotone'
code: theorem monotone' [Subsingleton β] (f : α → β) : Monotone f 
goal: Monotone f

full_name: Subsingleton.antitone'
code: theorem antitone' [Subsingleton β] (f : α → β) : Antitone f 
goal: Antitone f

full_name: Subsingleton.strictMono
code: protected theorem strictMono [Subsingleton α] (f : α → β) : StrictMono f 
goal: StrictMono f

full_name: Subsingleton.strictAnti
code: protected theorem strictAnti [Subsingleton α] (f : α → β) : StrictAnti f 
goal: StrictAnti f

full_name: monotone_id
code: theorem monotone_id [Preorder α] : Monotone (id : α → α) 
goal: Monotone id

full_name: monotoneOn_id
code: theorem monotoneOn_id [Preorder α] {s : Set α} : MonotoneOn id s 
goal: MonotoneOn id s

full_name: strictMono_id
code: theorem strictMono_id [Preorder α] : StrictMono (id : α → α) 
goal: StrictMono id

full_name: strictMonoOn_id
code: theorem strictMonoOn_id [Preorder α] {s : Set α} : StrictMonoOn id s 
goal: StrictMonoOn id s

full_name: monotone_const
code: theorem monotone_const [Preorder α] [Preorder β] {c : β} : Monotone fun _ : α ↦ c 
goal: Monotone fun x => c

full_name: monotoneOn_const
code: theorem monotoneOn_const [Preorder α] [Preorder β] {c : β} {s : Set α} :
    MonotoneOn (fun _ : α ↦ c) s 
goal: MonotoneOn (fun x => c) s

full_name: antitone_const
code: theorem antitone_const [Preorder α] [Preorder β] {c : β} : Antitone fun _ : α ↦ c 
goal: Antitone fun x => c

full_name: antitoneOn_const
code: theorem antitoneOn_const [Preorder α] [Preorder β] {c : β} {s : Set α} :
    AntitoneOn (fun _ : α ↦ c) s 
goal: AntitoneOn (fun x => c) s

full_name: strictMono_of_le_iff_le
code: theorem strictMono_of_le_iff_le [Preorder α] [Preorder β] {f : α → β}
    (h : ∀ x y, x ≤ y ↔ f x ≤ f y) : StrictMono f 
goal: StrictMono f

full_name: strictAnti_of_le_iff_le
code: theorem strictAnti_of_le_iff_le [Preorder α] [Preorder β] {f : α → β}
    (h : ∀ x y, x ≤ y ↔ f y ≤ f x) : StrictAnti f 
goal: StrictAnti f

full_name: injective_of_lt_imp_ne
code: theorem injective_of_lt_imp_ne [LinearOrder α] {f : α → β} (h : ∀ x y, x < y → f x ≠ f y) :
    Injective f 
goal: Function.Injective f

full_name: injective_of_le_imp_le
code: theorem injective_of_le_imp_le [PartialOrder α] [Preorder β] (f : α → β)
    (h : ∀ {x y}, f x ≤ f y → x ≤ y) : Injective f 
goal: Function.Injective f

full_name: StrictMono.isMax_of_apply
code: theorem StrictMono.isMax_of_apply (hf : StrictMono f) (ha : IsMax (f a)) : IsMax a 
goal: IsMax a

full_name: StrictMono.isMin_of_apply
code: theorem StrictMono.isMin_of_apply (hf : StrictMono f) (ha : IsMin (f a)) : IsMin a 
goal: IsMin a

full_name: StrictAnti.isMax_of_apply
code: theorem StrictAnti.isMax_of_apply (hf : StrictAnti f) (ha : IsMin (f a)) : IsMax a 
goal: IsMax a

full_name: StrictAnti.isMin_of_apply
code: theorem StrictAnti.isMin_of_apply (hf : StrictAnti f) (ha : IsMax (f a)) : IsMin a 
goal: IsMin a

full_name: StrictMono.add_le_nat
code: lemma StrictMono.add_le_nat {f : ℕ → ℕ} (hf : StrictMono f) (m n : ℕ) : m + f n ≤ f (m + n)  
goal: m + f n ≤ f (m + n)

full_name: StrictMono.ite'
code: protected theorem StrictMono.ite' (hf : StrictMono f) (hg : StrictMono g) {p : α → Prop}
    [DecidablePred p]
    (hp : ∀ ⦃x y⦄, x < y → p y → p x) (hfg : ∀ ⦃x y⦄, p x → ¬p y → x < y → f x < g y) :
    StrictMono fun x ↦ if p x then f x else g x 
goal: StrictMono fun x => if p x then f x else g x

full_name: StrictMono.ite
code: protected theorem StrictMono.ite (hf : StrictMono f) (hg : StrictMono g) {p : α → Prop}
    [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x) (hfg : ∀ x, f x ≤ g x) :
    StrictMono fun x ↦ if p x then f x else g x 
goal: StrictMono fun x => if p x then f x else g x

full_name: StrictAnti.ite'
code: protected theorem StrictAnti.ite' (hf : StrictAnti f) (hg : StrictAnti g) {p : α → Prop}
    [DecidablePred p]
    (hp : ∀ ⦃x y⦄, x < y → p y → p x) (hfg : ∀ ⦃x y⦄, p x → ¬p y → x < y → g y < f x) :
    StrictAnti fun x ↦ if p x then f x else g x 
goal: StrictAnti fun x => if p x then f x else g x

full_name: StrictAnti.ite
code: protected theorem StrictAnti.ite (hf : StrictAnti f) (hg : StrictAnti g) {p : α → Prop}
    [DecidablePred p] (hp : ∀ ⦃x y⦄, x < y → p y → p x) (hfg : ∀ x, g x ≤ f x) :
    StrictAnti fun x ↦ if p x then f x else g x 
goal: StrictAnti fun x => if p x then f x else g x

full_name: Monotone.comp
code: protected theorem Monotone.comp (hg : Monotone g) (hf : Monotone f) : Monotone (g ∘ f) 
goal: Monotone (g ∘ f)

full_name: Monotone.comp_antitone
code: theorem Monotone.comp_antitone (hg : Monotone g) (hf : Antitone f) : Antitone (g ∘ f) 
goal: Antitone (g ∘ f)

full_name: Antitone.comp
code: protected theorem Antitone.comp (hg : Antitone g) (hf : Antitone f) : Monotone (g ∘ f) 
goal: Monotone (g ∘ f)

full_name: Antitone.comp_monotone
code: theorem Antitone.comp_monotone (hg : Antitone g) (hf : Monotone f) : Antitone (g ∘ f) 
goal: Antitone (g ∘ f)

full_name: Monotone.iterate
code: protected theorem Monotone.iterate {f : α → α} (hf : Monotone f) (n : ℕ) : Monotone f^[n] 
goal: Monotone f^[n]

full_name: Monotone.comp_monotoneOn
code: protected theorem Monotone.comp_monotoneOn (hg : Monotone g) (hf : MonotoneOn f s) :
    MonotoneOn (g ∘ f) s 
goal: MonotoneOn (g ∘ f) s

full_name: Monotone.comp_antitoneOn
code: theorem Monotone.comp_antitoneOn (hg : Monotone g) (hf : AntitoneOn f s) : AntitoneOn (g ∘ f) s 
goal: AntitoneOn (g ∘ f) s

full_name: Antitone.comp_antitoneOn
code: protected theorem Antitone.comp_antitoneOn (hg : Antitone g) (hf : AntitoneOn f s) :
    MonotoneOn (g ∘ f) s 
goal: MonotoneOn (g ∘ f) s

full_name: Antitone.comp_monotoneOn
code: theorem Antitone.comp_monotoneOn (hg : Antitone g) (hf : MonotoneOn f s) : AntitoneOn (g ∘ f) s 
goal: AntitoneOn (g ∘ f) s

full_name: StrictMono.comp
code: protected theorem StrictMono.comp (hg : StrictMono g) (hf : StrictMono f) : StrictMono (g ∘ f) 
goal: StrictMono (g ∘ f)

full_name: StrictMono.comp_strictAnti
code: theorem StrictMono.comp_strictAnti (hg : StrictMono g) (hf : StrictAnti f) : StrictAnti (g ∘ f) 
goal: StrictAnti (g ∘ f)

full_name: StrictAnti.comp
code: protected theorem StrictAnti.comp (hg : StrictAnti g) (hf : StrictAnti f) : StrictMono (g ∘ f) 
goal: StrictMono (g ∘ f)

full_name: StrictAnti.comp_strictMono
code: theorem StrictAnti.comp_strictMono (hg : StrictAnti g) (hf : StrictMono f) : StrictAnti (g ∘ f) 
goal: StrictAnti (g ∘ f)

full_name: StrictMono.iterate
code: protected theorem StrictMono.iterate {f : α → α} (hf : StrictMono f) (n : ℕ) : StrictMono f^[n] 
goal: StrictMono f^[n]

full_name: StrictMono.comp_strictMonoOn
code: protected theorem StrictMono.comp_strictMonoOn (hg : StrictMono g) (hf : StrictMonoOn f s) :
    StrictMonoOn (g ∘ f) s 
goal: StrictMonoOn (g ∘ f) s

full_name: StrictMono.comp_strictAntiOn
code: theorem StrictMono.comp_strictAntiOn (hg : StrictMono g) (hf : StrictAntiOn f s) :
    StrictAntiOn (g ∘ f) s 
goal: StrictAntiOn (g ∘ f) s

full_name: StrictAnti.comp_strictAntiOn
code: protected theorem StrictAnti.comp_strictAntiOn (hg : StrictAnti g) (hf : StrictAntiOn f s) :
    StrictMonoOn (g ∘ f) s 
goal: StrictMonoOn (g ∘ f) s

full_name: StrictAnti.comp_strictMonoOn
code: theorem StrictAnti.comp_strictMonoOn (hg : StrictAnti g) (hf : StrictMonoOn f s) :
    StrictAntiOn (g ∘ f) s 
goal: StrictAntiOn (g ∘ f) s

full_name: List.foldl_monotone
code: theorem foldl_monotone [Preorder α] {f : α → β → α} (H : ∀ b, Monotone fun a ↦ f a b)
    (l : List β) : Monotone fun a ↦ l.foldl f a 
goal: Monotone fun a => List.foldl f a l

full_name: List.foldr_monotone
code: theorem foldr_monotone [Preorder β] {f : α → β → β} (H : ∀ a, Monotone (f a)) (l : List α) :
    Monotone fun b ↦ l.foldr f b 
goal: Monotone fun b => List.foldr f b l

full_name: List.foldl_strictMono
code: theorem foldl_strictMono [Preorder α] {f : α → β → α} (H : ∀ b, StrictMono fun a ↦ f a b)
    (l : List β) : StrictMono fun a ↦ l.foldl f a 
goal: StrictMono fun a => List.foldl f a l

full_name: List.foldr_strictMono
code: theorem foldr_strictMono [Preorder β] {f : α → β → β} (H : ∀ a, StrictMono (f a)) (l : List α) :
    StrictMono fun b ↦ l.foldr f b 
goal: StrictMono fun b => List.foldr f b l

full_name: Monotone.reflect_lt
code: theorem Monotone.reflect_lt (hf : Monotone f) {a b : α} (h : f a < f b) : a < b 
goal: a < b

full_name: Antitone.reflect_lt
code: theorem Antitone.reflect_lt (hf : Antitone f) {a b : α} (h : f a < f b) : b < a 
goal: b < a

full_name: MonotoneOn.reflect_lt
code: theorem MonotoneOn.reflect_lt (hf : MonotoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
    (h : f a < f b) : a < b 
goal: a < b

full_name: AntitoneOn.reflect_lt
code: theorem AntitoneOn.reflect_lt (hf : AntitoneOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s)
    (h : f a < f b) : b < a 
goal: b < a

full_name: StrictMonoOn.le_iff_le
code: theorem StrictMonoOn.le_iff_le (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a ≤ f b ↔ a ≤ b 
goal: f a ≤ f b ↔ a ≤ b

full_name: StrictAntiOn.le_iff_le
code: theorem StrictAntiOn.le_iff_le (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a ≤ f b ↔ b ≤ a 
goal: f a ≤ f b ↔ b ≤ a

full_name: StrictMonoOn.eq_iff_eq
code: theorem StrictMonoOn.eq_iff_eq (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a = f b ↔ a = b 
goal: f a = f b ↔ a = b

full_name: StrictAntiOn.eq_iff_eq
code: theorem StrictAntiOn.eq_iff_eq (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a = f b ↔ b = a 
goal: f a = f b ↔ b = a

full_name: StrictMonoOn.lt_iff_lt
code: theorem StrictMonoOn.lt_iff_lt (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a < f b ↔ a < b 
goal: f a < f b ↔ a < b

full_name: StrictAntiOn.lt_iff_lt
code: theorem StrictAntiOn.lt_iff_lt (hf : StrictAntiOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a < f b ↔ b < a 
goal: f a < f b ↔ b < a

full_name: StrictMono.le_iff_le
code: theorem StrictMono.le_iff_le (hf : StrictMono f) {a b : α} : f a ≤ f b ↔ a ≤ b 
goal: f a ≤ f b ↔ a ≤ b

full_name: StrictAnti.le_iff_le
code: theorem StrictAnti.le_iff_le (hf : StrictAnti f) {a b : α} : f a ≤ f b ↔ b ≤ a 
goal: f a ≤ f b ↔ b ≤ a

full_name: StrictMono.lt_iff_lt
code: theorem StrictMono.lt_iff_lt (hf : StrictMono f) {a b : α} : f a < f b ↔ a < b 
goal: f a < f b ↔ a < b

full_name: StrictAnti.lt_iff_lt
code: theorem StrictAnti.lt_iff_lt (hf : StrictAnti f) {a b : α} : f a < f b ↔ b < a 
goal: f a < f b ↔ b < a

full_name: StrictMonoOn.compares
code: 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
  
goal: o.Compares (f a) (f b) ↔ o.Compares a b

full_name: StrictAntiOn.compares
code: 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 
goal: o.Compares (f a) (f b) ↔ o.Compares b a

full_name: StrictMono.compares
code: protected theorem StrictMono.compares (hf : StrictMono f) {a b : α} {o : Ordering} :
    o.Compares (f a) (f b) ↔ o.Compares a b 
goal: o.Compares (f a) (f b) ↔ o.Compares a b

full_name: StrictAnti.compares
code: protected theorem StrictAnti.compares (hf : StrictAnti f) {a b : α} {o : Ordering} :
    o.Compares (f a) (f b) ↔ o.Compares b a 
goal: o.Compares (f a) (f b) ↔ o.Compares b a

full_name: StrictMono.injective
code: theorem StrictMono.injective (hf : StrictMono f) : Injective f 
goal: Function.Injective f

full_name: StrictAnti.injective
code: theorem StrictAnti.injective (hf : StrictAnti f) : Injective f 
goal: Function.Injective f

full_name: StrictMono.maximal_of_maximal_image
code: theorem StrictMono.maximal_of_maximal_image (hf : StrictMono f) {a} (hmax : ∀ p, p ≤ f a) (x : α) :
    x ≤ a 
goal: x ≤ a

full_name: StrictMono.minimal_of_minimal_image
code: theorem StrictMono.minimal_of_minimal_image (hf : StrictMono f) {a} (hmin : ∀ p, f a ≤ p) (x : α) :
    a ≤ x 
goal: a ≤ x

full_name: StrictAnti.minimal_of_maximal_image
code: theorem StrictAnti.minimal_of_maximal_image (hf : StrictAnti f) {a} (hmax : ∀ p, p ≤ f a) (x : α) :
    a ≤ x 
goal: a ≤ x

full_name: StrictAnti.maximal_of_minimal_image
code: theorem StrictAnti.maximal_of_minimal_image (hf : StrictAnti f) {a} (hmin : ∀ p, f a ≤ p) (x : α) :
    x ≤ a 
goal: x ≤ a

full_name: Monotone.strictMono_iff_injective
code: theorem Monotone.strictMono_iff_injective (hf : Monotone f) : StrictMono f ↔ Injective f 
goal: StrictMono f ↔ Function.Injective f

full_name: Antitone.strictAnti_iff_injective
code: theorem Antitone.strictAnti_iff_injective (hf : Antitone f) : StrictAnti f ↔ Injective f 
goal: StrictAnti f ↔ Function.Injective f

full_name: Monotone.eq_of_le_of_le
code: /-- If a monotone function is equal at two points, it is equal between all of them -/
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₁ 
goal: f i = f a₁

full_name: Antitone.eq_of_le_of_le
code: /-- If an antitone function is equal at two points, it is equal between all of them -/
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₁ 
goal: f i = f a₁

full_name: not_monotone_not_antitone_iff_exists_le_le
code: /-- A function between linear orders which is neither monotone nor antitone makes a dent upright or
downright. -/
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)) 
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)

full_name: not_monotone_not_antitone_iff_exists_lt_lt
code: /-- A function between linear orders which is neither monotone nor antitone makes a dent upright or
downright. -/
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) 
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)

full_name: StrictMonoOn.cmp_map_eq
code: theorem StrictMonoOn.cmp_map_eq (hf : StrictMonoOn f s) (hx : x ∈ s) (hy : y ∈ s) :
    cmp (f x) (f y) = cmp x y 
goal: cmp (f x) (f y) = cmp x y

full_name: StrictMono.cmp_map_eq
code: theorem StrictMono.cmp_map_eq (hf : StrictMono f) (x y : α) : cmp (f x) (f y) = cmp x y 
goal: cmp (f x) (f y) = cmp x y

full_name: StrictAntiOn.cmp_map_eq
code: theorem StrictAntiOn.cmp_map_eq (hf : StrictAntiOn f s) (hx : x ∈ s) (hy : y ∈ s) :
    cmp (f x) (f y) = cmp y x 
goal: cmp (f x) (f y) = cmp y x

full_name: StrictAnti.cmp_map_eq
code: theorem StrictAnti.cmp_map_eq (hf : StrictAnti f) (x y : α) : cmp (f x) (f y) = cmp y x 
goal: cmp (f x) (f y) = cmp y x

full_name: Nat.rel_of_forall_rel_succ_of_le_of_lt
code: 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) 
goal: r (f b) (f c)

full_name: Nat.rel_of_forall_rel_succ_of_le_of_le
code: 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) 
goal: r (f b) (f c)

full_name: Nat.rel_of_forall_rel_succ_of_lt
code: 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) 
goal: r (f a) (f b)

full_name: Nat.rel_of_forall_rel_succ_of_le
code: 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) 
goal: r (f a) (f b)

full_name: monotone_nat_of_le_succ
code: theorem monotone_nat_of_le_succ {f : ℕ → α} (hf : ∀ n, f n ≤ f (n + 1)) : Monotone f 
goal: Monotone f

full_name: antitone_nat_of_succ_le
code: theorem antitone_nat_of_succ_le {f : ℕ → α} (hf : ∀ n, f (n + 1) ≤ f n) : Antitone f 
goal: Antitone f

full_name: strictMono_nat_of_lt_succ
code: theorem strictMono_nat_of_lt_succ {f : ℕ → α} (hf : ∀ n, f n < f (n + 1)) : StrictMono f 
goal: StrictMono f

full_name: strictAnti_nat_of_succ_lt
code: theorem strictAnti_nat_of_succ_lt {f : ℕ → α} (hf : ∀ n, f (n + 1) < f n) : StrictAnti f 
goal: StrictAnti f

full_name: Nat.exists_strictMono'
code: /-- If `α` is a preorder with no maximal elements, then there exists a strictly monotone function
`ℕ → α` with any prescribed value of `f 0`. -/
theorem exists_strictMono' [NoMaxOrder α] (a : α) : ∃ f : ℕ → α, StrictMono f ∧ f 0 = a 
goal: ∃ f, StrictMono f ∧ f 0 = a

full_name: Nat.exists_strictAnti'
code: /-- If `α` is a preorder with no maximal elements, then there exists a strictly antitone function
`ℕ → α` with any prescribed value of `f 0`. -/
theorem exists_strictAnti' [NoMinOrder α] (a : α) : ∃ f : ℕ → α, StrictAnti f ∧ f 0 = a 
goal: ∃ f, StrictAnti f ∧ f 0 = a

full_name: Nat.exists_strictMono
code: /-- If `α` is a nonempty preorder with no maximal elements, then there exists a strictly monotone
function `ℕ → α`. -/
theorem exists_strictMono [Nonempty α] [NoMaxOrder α] : ∃ f : ℕ → α, StrictMono f 
goal: ∃ f, StrictMono f

full_name: Nat.exists_strictAnti
code: /-- If `α` is a nonempty preorder with no minimal elements, then there exists a strictly antitone
function `ℕ → α`. -/
theorem exists_strictAnti [Nonempty α] [NoMinOrder α] : ∃ f : ℕ → α, StrictAnti f 
goal: ∃ f, StrictAnti f

full_name: Int.rel_of_forall_rel_succ_of_lt
code: 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) 
goal: r (f a) (f b)

full_name: Int.rel_of_forall_rel_succ_of_le
code: 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) 
goal: r (f a) (f b)

full_name: monotone_int_of_le_succ
code: theorem monotone_int_of_le_succ {f : ℤ → α} (hf : ∀ n, f n ≤ f (n + 1)) : Monotone f 
goal: Monotone f

full_name: antitone_int_of_succ_le
code: theorem antitone_int_of_succ_le {f : ℤ → α} (hf : ∀ n, f (n + 1) ≤ f n) : Antitone f 
goal: Antitone f

full_name: strictMono_int_of_lt_succ
code: theorem strictMono_int_of_lt_succ {f : ℤ → α} (hf : ∀ n, f n < f (n + 1)) : StrictMono f 
goal: StrictMono f

full_name: strictAnti_int_of_succ_lt
code: theorem strictAnti_int_of_succ_lt {f : ℤ → α} (hf : ∀ n, f (n + 1) < f n) : StrictAnti f 
goal: StrictAnti f

full_name: Int.exists_strictMono
code: /-- If `α` is a nonempty preorder with no minimal or maximal elements, then there exists a strictly
monotone function `f : ℤ → α`. -/
theorem exists_strictMono : ∃ f : ℤ → α, StrictMono f 
goal: ∃ f, StrictMono f

full_name: Int.exists_strictAnti
code: /-- If `α` is a nonempty preorder with no minimal or maximal elements, then there exists a strictly
antitone function `f : ℤ → α`. -/
theorem exists_strictAnti : ∃ f : ℤ → α, StrictAnti f 
goal: ∃ f, StrictAnti f

full_name: Monotone.ne_of_lt_of_lt_nat
code: /-- If `f` is a monotone function from `ℕ` to a preorder such that `x` lies between `f n` and
  `f (n + 1)`, then `x` doesn't lie in the range of `f`. -/
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 
goal: f a ≠ x

full_name: Antitone.ne_of_lt_of_lt_nat
code: /-- If `f` is an antitone function from `ℕ` to a preorder such that `x` lies between `f (n + 1)` and
`f n`, then `x` doesn't lie in the range of `f`. -/
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 
goal: f a ≠ x

full_name: Monotone.ne_of_lt_of_lt_int
code: /-- If `f` is a monotone function from `ℤ` to a preorder and `x` lies between `f n` and
  `f (n + 1)`, then `x` doesn't lie in the range of `f`. -/
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 
goal: f a ≠ x

full_name: Antitone.ne_of_lt_of_lt_int
code: /-- If `f` is an antitone function from `ℤ` to a preorder and `x` lies between `f (n + 1)` and
`f n`, then `x` doesn't lie in the range of `f`. -/
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 
goal: f a ≠ x

full_name: StrictMono.id_le
code: theorem StrictMono.id_le {φ : ℕ → ℕ} (h : StrictMono φ) : ∀ n, n ≤ φ n 
goal: n ≤ φ n

full_name: Subtype.mono_coe
code: theorem Subtype.mono_coe [Preorder α] (t : Set α) : Monotone ((↑) : Subtype t → α) 
goal: Monotone Subtype.val

full_name: Subtype.strictMono_coe
code: theorem Subtype.strictMono_coe [Preorder α] (t : Set α) :
    StrictMono ((↑) : Subtype t → α) 
goal: StrictMono Subtype.val

full_name: monotone_fst
code: theorem monotone_fst : Monotone (@Prod.fst α β) 
goal: Monotone Prod.fst

full_name: monotone_snd
code: theorem monotone_snd : Monotone (@Prod.snd α β) 
goal: Monotone Prod.snd

full_name: Monotone.prod_map
code: theorem Monotone.prod_map (hf : Monotone f) (hg : Monotone g) : Monotone (Prod.map f g) 
goal: Monotone (Prod.map f g)

full_name: Antitone.prod_map
code: theorem Antitone.prod_map (hf : Antitone f) (hg : Antitone g) : Antitone (Prod.map f g) 
goal: Antitone (Prod.map f g)

full_name: StrictMono.prod_map
code: theorem StrictMono.prod_map (hf : StrictMono f) (hg : StrictMono g) : StrictMono (Prod.map f g) 
goal: StrictMono (Prod.map f g)

full_name: StrictAnti.prod_map
code: theorem StrictAnti.prod_map (hf : StrictAnti f) (hg : StrictAnti g) : StrictAnti (Prod.map f g) 
goal: StrictAnti (Prod.map f g)

full_name: Function.update_mono
code: theorem update_mono : Monotone (update f i) 
goal: Monotone (Function.update f i)

full_name: Function.update_strictMono
code: theorem update_strictMono : StrictMono (update f i) 
goal: StrictMono (Function.update f i)

full_name: Function.const_mono
code: theorem const_mono : Monotone (const β : α → β → α) 
goal: Monotone (Function.const β)

full_name: Function.const_strictMono
code: theorem const_strictMono [Nonempty β] : StrictMono (const β : α → β → α) 
goal: StrictMono (Function.const β)

full_name: monotone_iff_apply₂
code: lemma monotone_iff_apply₂ : Monotone f ↔ ∀ i, Monotone (f · i) 
goal: Monotone f ↔ ∀ (i : ι), Monotone fun x => f x i

full_name: antitone_iff_apply₂
code: lemma antitone_iff_apply₂ : Antitone f ↔ ∀ i, Antitone (f · i) 
goal: Antitone f ↔ ∀ (i : ι), Antitone fun x => f x i