File: Mathlib/Order/WellFounded.lean

full_name: WellFounded.isAsymm
code: protected theorem isAsymm (h : WellFounded r) : IsAsymm α r 
goal: IsAsymm α r

full_name: WellFounded.isIrrefl
code: protected theorem isIrrefl (h : WellFounded r) : IsIrrefl α r 
goal: IsIrrefl α r

full_name: WellFounded.instIsAsymmRel
code: instance [WellFoundedRelation α] : IsAsymm α WellFoundedRelation.rel 
goal: IsAsymm α WellFoundedRelation.rel

full_name: WellFounded.instIsIrreflRel
code: instance : IsIrrefl α WellFoundedRelation.rel 
goal: IsIrrefl α WellFoundedRelation.rel

full_name: WellFounded.mono
code: theorem mono (hr : WellFounded r) (h : ∀ a b, r' a b → r a b) : WellFounded r' 
goal: WellFounded r'

full_name: WellFounded.onFun
code: theorem onFun {α β : Sort*} {r : β → β → Prop} {f : α → β} :
    WellFounded r → WellFounded (r on f) 
goal: WellFounded r → WellFounded (r on f)

full_name: WellFounded.has_min
code: /-- If `r` is a well-founded relation, then any nonempty set has a minimal element
with respect to `r`. -/
theorem has_min {α} {r : α → α → Prop} (H : WellFounded r) (s : Set α) :
    s.Nonempty → ∃ a ∈ s, ∀ x ∈ s, ¬r x a
  
goal: s.Nonempty → ∃ a ∈ s, ∀ x ∈ s, ¬r x a

full_name: WellFounded.min
code: /-- A minimal element of a nonempty set in a well-founded order.

If you're working with a nonempty linear order, consider defining a
`ConditionallyCompleteLinearOrderBot` instance via
`WellFounded.conditionallyCompleteLinearOrderWithBot` and using `Inf` instead. -/
noncomputable def min {r : α → α → Prop} (H : WellFounded r) (s : Set α) (h : s.Nonempty) : α 
goal: α

full_name: WellFounded.min_mem
code: theorem min_mem {r : α → α → Prop} (H : WellFounded r) (s : Set α) (h : s.Nonempty) :
    H.min s h ∈ s 
goal: H.min s h ∈ s

full_name: WellFounded.not_lt_min
code: theorem not_lt_min {r : α → α → Prop} (H : WellFounded r) (s : Set α) (h : s.Nonempty) {x}
    (hx : x ∈ s) : ¬r x (H.min s h) 
goal: ¬r x (H.min s h)

full_name: WellFounded.wellFounded_iff_has_min
code: theorem wellFounded_iff_has_min {r : α → α → Prop} :
    WellFounded r ↔ ∀ s : Set α, s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m 
goal: WellFounded r ↔ ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m

full_name: WellFounded.sup
code: /-- The supremum of a bounded, well-founded order -/
protected noncomputable def sup {r : α → α → Prop} (wf : WellFounded r) (s : Set α)
    (h : Bounded r s) : α 
goal: α

full_name: WellFounded.lt_sup
code: protected theorem lt_sup {r : α → α → Prop} (wf : WellFounded r) {s : Set α} (h : Bounded r s) {x}
    (hx : x ∈ s) : r x (wf.sup s h) 
goal: r x (wf.sup s h)

full_name: WellFounded.succ
code: /-- A successor of an element `x` in a well-founded order is a minimal element `y` such that
`x < y` if one exists. Otherwise it is `x` itself. -/
protected noncomputable def succ {r : α → α → Prop} (wf : WellFounded r) (x : α) : α 
goal: α

full_name: WellFounded.lt_succ
code: protected theorem lt_succ {r : α → α → Prop} (wf : WellFounded r) {x : α} (h : ∃ y, r x y) :
    r x (wf.succ x) 
goal: r x (wf.succ x)

full_name: WellFounded.lt_succ_iff
code: protected theorem lt_succ_iff {r : α → α → Prop} [wo : IsWellOrder α r] {x : α} (h : ∃ y, r x y)
    (y : α) : r y (wo.wf.succ x) ↔ r y x ∨ y = x 
goal: r y (⋯.succ x) ↔ r y x ∨ y = x

full_name: WellFounded.min_le
code: theorem min_le (h : WellFounded ((· < ·) : β → β → Prop)) {x : β} {s : Set β} (hx : x ∈ s)
    (hne : s.Nonempty := ⟨x, hx⟩) : h.min s hne ≤ x 
goal: h.min s hne ≤ x

full_name: _private.Mathlib.Order.WellFounded.0.WellFounded.eq_strictMono_iff_eq_range_aux
code: private theorem eq_strictMono_iff_eq_range_aux {f g : β → γ} (hf : StrictMono f)
    (hg : StrictMono g) (hfg : Set.range f = Set.range g) {b : β} (H : ∀ a < b, f a = g a) :
    f b ≤ g b 
goal: f b ≤ g b

full_name: WellFounded.eq_strictMono_iff_eq_range
code: theorem eq_strictMono_iff_eq_range (h : WellFounded ((· < ·) : β → β → Prop)) {f g : β → γ}
    (hf : StrictMono f) (hg : StrictMono g) :
    Set.range f = Set.range g ↔ f = g 
goal: Set.range f = Set.range g ↔ f = g

full_name: WellFounded.self_le_of_strictMono
code: theorem self_le_of_strictMono (h : WellFounded ((· < ·) : β → β → Prop)) {f : β → β}
    (hf : StrictMono f) : ∀ n, n ≤ f n 
goal: n ≤ f n

full_name: Function.argmin
code: /-- Given a function `f : α → β` where `β` carries a well-founded `<`, this is an element of `α`
whose image under `f` is minimal in the sense of `Function.not_lt_argmin`. -/
noncomputable def argmin [Nonempty α] : α 
goal: α

full_name: Function.not_lt_argmin
code: theorem not_lt_argmin [Nonempty α] (a : α) : ¬f a < f (argmin f h) 
goal: ¬f a < f (Function.argmin f h)

full_name: Function.argminOn
code: /-- Given a function `f : α → β` where `β` carries a well-founded `<`, and a non-empty subset `s`
of `α`, this is an element of `s` whose image under `f` is minimal in the sense of
`Function.not_lt_argminOn`. -/
noncomputable def argminOn (s : Set α) (hs : s.Nonempty) : α 
goal: α

full_name: Function.argminOn_mem
code: @[simp]
theorem argminOn_mem (s : Set α) (hs : s.Nonempty) : argminOn f h s hs ∈ s 
goal: Function.argminOn f h s hs ∈ s

full_name: Function.not_lt_argminOn
code: theorem not_lt_argminOn (s : Set α) {a : α} (ha : a ∈ s)
    (hs : s.Nonempty := Set.nonempty_of_mem ha) : ¬f a < f (argminOn f h s hs) 
goal: ¬f a < f (Function.argminOn f h s hs)

full_name: Function.argmin_le
code: theorem argmin_le (a : α) [Nonempty α] : f (argmin f h) ≤ f a 
goal: f (Function.argmin f h) ≤ f a

full_name: Function.argminOn_le
code: theorem argminOn_le (s : Set α) {a : α} (ha : a ∈ s) (hs : s.Nonempty := Set.nonempty_of_mem ha) :
    f (argminOn f h s hs) ≤ f a 
goal: f (Function.argminOn f h s hs) ≤ f a

full_name: Acc.induction_bot'
code: /-- Let `r` be a relation on `α`, let `f : α → β` be a function, let `C : β → Prop`, and
let `bot : α`. This induction principle shows that `C (f bot)` holds, given that
* some `a` that is accessible by `r` satisfies `C (f a)`, and
* for each `b` such that `f b ≠ f bot` and `C (f b)` holds, there is `c`
  satisfying `r c b` and `C (f c)`. -/
theorem Acc.induction_bot' {α β} {r : α → α → Prop} {a bot : α} (ha : Acc r a) {C : β → Prop}
    {f : α → β} (ih : ∀ b, f b ≠ f bot → C (f b) → ∃ c, r c b ∧ C (f c)) : C (f a) → C (f bot) 
goal: C (f a) → C (f bot)

full_name: Acc.induction_bot
code: /-- Let `r` be a relation on `α`, let `C : α → Prop` and let `bot : α`.
This induction principle shows that `C bot` holds, given that
* some `a` that is accessible by `r` satisfies `C a`, and
* for each `b ≠ bot` such that `C b` holds, there is `c` satisfying `r c b` and `C c`. -/
theorem Acc.induction_bot {α} {r : α → α → Prop} {a bot : α} (ha : Acc r a) {C : α → Prop}
    (ih : ∀ b, b ≠ bot → C b → ∃ c, r c b ∧ C c) : C a → C bot 
goal: C a → C bot

full_name: WellFounded.induction_bot'
code: /-- Let `r` be a well-founded relation on `α`, let `f : α → β` be a function,
let `C : β → Prop`, and let `bot : α`.
This induction principle shows that `C (f bot)` holds, given that
* some `a` satisfies `C (f a)`, and
* for each `b` such that `f b ≠ f bot` and `C (f b)` holds, there is `c`
  satisfying `r c b` and `C (f c)`. -/
theorem WellFounded.induction_bot' {α β} {r : α → α → Prop} (hwf : WellFounded r) {a bot : α}
    {C : β → Prop} {f : α → β} (ih : ∀ b, f b ≠ f bot → C (f b) → ∃ c, r c b ∧ C (f c)) :
    C (f a) → C (f bot) 
goal: C (f a) → C (f bot)

full_name: WellFounded.induction_bot
code: /-- Let `r` be a well-founded relation on `α`, let `C : α → Prop`, and let `bot : α`.
This induction principle shows that `C bot` holds, given that
* some `a` satisfies `C a`, and
* for each `b` that satisfies `C b`, there is `c` satisfying `r c b` and `C c`.

The naming is inspired by the fact that when `r` is transitive, it follows that `bot` is
the smallest element w.r.t. `r` that satisfies `C`. -/
theorem WellFounded.induction_bot {α} {r : α → α → Prop} (hwf : WellFounded r) {a bot : α}
    {C : α → Prop} (ih : ∀ b, b ≠ bot → C b → ∃ c, r c b ∧ C c) : C a → C bot 
goal: C a → C bot

full_name: StrictMono.wellFoundedLT
code: theorem StrictMono.wellFoundedLT [WellFoundedLT β] (hf : StrictMono f) : WellFoundedLT α 
goal: WellFoundedLT α

full_name: StrictAnti.wellFoundedLT
code: theorem StrictAnti.wellFoundedLT [WellFoundedGT β] (hf : StrictAnti f) : WellFoundedLT α 
goal: WellFoundedLT α

full_name: StrictMono.wellFoundedGT
code: theorem StrictMono.wellFoundedGT [WellFoundedGT β] (hf : StrictMono f) : WellFoundedGT α 
goal: WellFoundedGT α

full_name: StrictAnti.wellFoundedGT
code: theorem StrictAnti.wellFoundedGT [WellFoundedLT β] (hf : StrictAnti f) : WellFoundedGT α 
goal: WellFoundedGT α