Well-founded relations

A relation is well-founded if it can be used for induction: for each x, (∀ y, r y x → P y) → P x implies P x. Well-founded relations can be used for induction and recursion, including construction of fixed points in the space of dependent functions Π x : α , β x.

The predicate WellFounded is defined in the core library. In this file we prove some extra lemmas and provide a few new definitions: WellFounded.min, WellFounded.sup, and WellFounded.succ, and an induction principle WellFounded.induction_bot.

theorem WellFounded.isAsymm {α : Type u_1} {r : α → α → Prop} (h : WellFounded r) : IsAsymm α r

theorem WellFounded.isIrrefl {α : Type u_1} {r : α → α → Prop} (h : WellFounded r) : IsIrrefl α r

instance WellFounded.instIsAsymmRel {α : Type u_1} [WellFoundedRelation α] : IsAsymm α WellFoundedRelation.rel

Equations

• @WellFounded.instIsAsymmRel = @WellFounded.instIsAsymmRel.proof_1

instance WellFounded.instIsIrreflRelInstWellFoundedRelationInstSizeOf {α : Type u_1} : IsIrrefl α WellFoundedRelation.rel

Equations

• @WellFounded.instIsIrreflRelInstWellFoundedRelationInstSizeOf = @WellFounded.instIsIrreflRelInstWellFoundedRelationInstSizeOf.proof_1

theorem WellFounded.mono {α : Type u_1} {r : α → α → Prop} {r' : α → α → Prop} (hr : WellFounded r) (h : (a b : α) → r' a b → r a b) : WellFounded r'

theorem WellFounded.onFun {α : Sort u_4} {β : Sort u_5} {r : β → β → Prop} {f : α → β} : WellFounded r → WellFounded (r on f)

theorem WellFounded.has_min {α : Type u_4} {r : α → α → Prop} (H : WellFounded r) (s : Set α) : Set.Nonempty s → ∃ a, a ∈ s ∧ ∀ (x : α), x ∈ s → ¬r x a

If r is a well-founded relation, then any nonempty set has a minimal element with respect to r.

noncomputable def WellFounded.min {α : Type u_1} {r : α → α → Prop} (H : WellFounded r) (s : Set α) (h : Set.Nonempty s) : α

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.

Equations

• WellFounded.min H s h = Classical.choose (_ : ∃ a, a ∈ s ∧ ∀ (x : α), x ∈ s → ¬r x a)

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

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

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

noncomputable def WellFounded.sup {α : Type u_1} {r : α → α → Prop} (wf : WellFounded r) (s : Set α) (h : Set.Bounded r s) : α

The supremum of a bounded, well-founded order

Equations

• WellFounded.sup wf s h = WellFounded.min wf {x | (a : α) → a ∈ s → r a x} h

theorem WellFounded.lt_sup {α : Type u_1} {r : α → α → Prop} (wf : WellFounded r) {s : Set α} (h : Set.Bounded r s) {x : α} (hx : x ∈ s) : r x (WellFounded.sup wf s h)

noncomputable def WellFounded.succ {α : Type u_1} {r : α → α → Prop} (wf : WellFounded r) (x : α) : α

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.

Equations

• WellFounded.succ wf x = if h : ∃ y, r x y then WellFounded.min wf {y | r x y} h else x

theorem WellFounded.lt_succ {α : Type u_1} {r : α → α → Prop} (wf : WellFounded r) {x : α} (h : ∃ y, r x y) : r x (WellFounded.succ wf x)

theorem WellFounded.lt_succ_iff {α : Type u_1} {r : α → α → Prop} [wo : IsWellOrder α r] {x : α} (h : ∃ y, r x y) (y : α) : r y (WellFounded.succ (_ : WellFounded r) x) ↔ r y x ∨ y = x

theorem WellFounded.min_le {β : Type u_2} [LinearOrder β] (h : WellFounded fun x x_1 => x < x_1) {x : β} {s : Set β} (hx : x ∈ s) (hne : optParam (Set.Nonempty s) (_ : ∃ x, x ∈ s)) : WellFounded.min h s hne ≤ x

theorem WellFounded.eq_strictMono_iff_eq_range {β : Type u_2} {γ : Type u_3} [LinearOrder β] (h : WellFounded fun x x_1 => x < x_1) [PartialOrder γ] {f : β → γ} {g : β → γ} (hf : StrictMono f) (hg : StrictMono g) : Set.range f = Set.range g ↔ f = g

theorem WellFounded.self_le_of_strictMono {β : Type u_2} [LinearOrder β] (h : WellFounded fun x x_1 => x < x_1) {f : β → β} (hf : StrictMono f) (n : β) : n ≤ f n

noncomputable def Function.argmin {α : Type u_1} {β : Type u_2} (f : α → β) [LT β] (h : WellFounded fun x x_1 => x < x_1) [Nonempty α] : α

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.

Equations

• Function.argmin f h = WellFounded.min (_ : WellFounded (InvImage (fun x x_1 => x < x_1) f)) Set.univ (_ : Set.Nonempty Set.univ)

theorem Function.not_lt_argmin {α : Type u_1} {β : Type u_2} (f : α → β) [LT β] (h : WellFounded fun x x_1 => x < x_1) [Nonempty α] (a : α) : ¬f a < f (Function.argmin f h)

noncomputable def Function.argminOn {α : Type u_1} {β : Type u_2} (f : α → β) [LT β] (h : WellFounded fun x x_1 => x < x_1) (s : Set α) (hs : Set.Nonempty s) : α

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.

Equations

• Function.argminOn f h s hs = WellFounded.min (_ : WellFounded (InvImage (fun x x_1 => x < x_1) f)) s hs

@[simp]

theorem Function.argminOn_mem {α : Type u_1} {β : Type u_2} (f : α → β) [LT β] (h : WellFounded fun x x_1 => x < x_1) (s : Set α) (hs : Set.Nonempty s) : Function.argminOn f h s hs ∈ s

theorem Function.not_lt_argminOn {α : Type u_1} {β : Type u_2} (f : α → β) [LT β] (h : WellFounded fun x x_1 => x < x_1) (s : Set α) {a : α} (ha : a ∈ s) (hs : optParam (Set.Nonempty s) (_ : Set.Nonempty s)) : ¬f a < f (Function.argminOn f h s hs)

theorem Function.argmin_le {α : Type u_1} {β : Type u_2} (f : α → β) [LinearOrder β] (h : WellFounded fun x x_1 => x < x_1) (a : α) [Nonempty α] : f (Function.argmin f h) ≤ f a

theorem Function.argminOn_le {α : Type u_1} {β : Type u_2} (f : α → β) [LinearOrder β] (h : WellFounded fun x x_1 => x < x_1) (s : Set α) {a : α} (ha : a ∈ s) (hs : optParam (Set.Nonempty s) (_ : Set.Nonempty s)) : f (Function.argminOn f h s hs) ≤ f a

theorem Acc.induction_bot' {α : Sort u_4} {β : Sort u_5} {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)

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 {α : Sort u_4} {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

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 WellFounded.induction_bot' {α : Sort u_4} {β : Sort u_5} {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)

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 {α : Sort u_4} {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

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.