File: Mathlib/Order/FixedPoints.lean

full_name: OrderHom.lfp
code: /-- Least fixed point of a monotone function -/
def lfp : (α →o α) →o α 
goal: (α →o α) →o α

full_name: OrderHom.gfp
code: /-- Greatest fixed point of a monotone function -/
def gfp : (α →o α) →o α 
goal: (α →o α) →o α

full_name: OrderHom.lfp_le
code: theorem lfp_le {a : α} (h : f a ≤ a) : lfp f ≤ a 
goal: OrderHom.lfp f ≤ a

full_name: OrderHom.lfp_le_fixed
code: theorem lfp_le_fixed {a : α} (h : f a = a) : lfp f ≤ a 
goal: OrderHom.lfp f ≤ a

full_name: OrderHom.le_lfp
code: theorem le_lfp {a : α} (h : ∀ b, f b ≤ b → a ≤ b) : a ≤ lfp f 
goal: a ≤ OrderHom.lfp f

full_name: OrderHom.map_le_lfp
code: theorem map_le_lfp {a : α} (ha : a ≤ lfp f) : f a ≤ lfp f 
goal: f a ≤ OrderHom.lfp f

full_name: OrderHom.map_lfp
code: @[simp]
theorem map_lfp : f (lfp f) = lfp f 
goal: f (OrderHom.lfp f) = OrderHom.lfp f

full_name: OrderHom.isFixedPt_lfp
code: theorem isFixedPt_lfp : IsFixedPt f (lfp f) 
goal: Function.IsFixedPt (⇑f) (OrderHom.lfp f)

full_name: OrderHom.lfp_le_map
code: theorem lfp_le_map {a : α} (ha : lfp f ≤ a) : lfp f ≤ f a 
goal: OrderHom.lfp f ≤ f a

full_name: OrderHom.isLeast_lfp_le
code: theorem isLeast_lfp_le : IsLeast { a | f a ≤ a } (lfp f) 
goal: IsLeast {a | f a ≤ a} (OrderHom.lfp f)

full_name: OrderHom.isLeast_lfp
code: theorem isLeast_lfp : IsLeast (fixedPoints f) (lfp f) 
goal: IsLeast (Function.fixedPoints ⇑f) (OrderHom.lfp f)

full_name: OrderHom.lfp_induction
code: theorem lfp_induction {p : α → Prop} (step : ∀ a, p a → a ≤ lfp f → p (f a))
    (hSup : ∀ s, (∀ a ∈ s, p a) → p (sSup s)) : p (lfp f) 
goal: p (OrderHom.lfp f)

full_name: OrderHom.le_gfp
code: theorem le_gfp {a : α} (h : a ≤ f a) : a ≤ gfp f 
goal: a ≤ OrderHom.gfp f

full_name: OrderHom.gfp_le
code: theorem gfp_le {a : α} (h : ∀ b, b ≤ f b → b ≤ a) : gfp f ≤ a 
goal: OrderHom.gfp f ≤ a

full_name: OrderHom.isFixedPt_gfp
code: theorem isFixedPt_gfp : IsFixedPt f (gfp f) 
goal: Function.IsFixedPt (⇑f) (OrderHom.gfp f)

full_name: OrderHom.map_gfp
code: @[simp]
theorem map_gfp : f (gfp f) = gfp f 
goal: f (OrderHom.gfp f) = OrderHom.gfp f

full_name: OrderHom.map_le_gfp
code: theorem map_le_gfp {a : α} (ha : a ≤ gfp f) : f a ≤ gfp f 
goal: f a ≤ OrderHom.gfp f

full_name: OrderHom.gfp_le_map
code: theorem gfp_le_map {a : α} (ha : gfp f ≤ a) : gfp f ≤ f a 
goal: OrderHom.gfp f ≤ f a

full_name: OrderHom.isGreatest_gfp_le
code: theorem isGreatest_gfp_le : IsGreatest { a | a ≤ f a } (gfp f) 
goal: IsGreatest {a | a ≤ f a} (OrderHom.gfp f)

full_name: OrderHom.isGreatest_gfp
code: theorem isGreatest_gfp : IsGreatest (fixedPoints f) (gfp f) 
goal: IsGreatest (Function.fixedPoints ⇑f) (OrderHom.gfp f)

full_name: OrderHom.gfp_induction
code: theorem gfp_induction {p : α → Prop} (step : ∀ a, p a → gfp f ≤ a → p (f a))
    (hInf : ∀ s, (∀ a ∈ s, p a) → p (sInf s)) : p (gfp f) 
goal: p (OrderHom.gfp f)

full_name: OrderHom.map_lfp_comp
code: theorem map_lfp_comp : f (lfp (g.comp f)) = lfp (f.comp g) 
goal: f (OrderHom.lfp (g.comp f)) = OrderHom.lfp (f.comp g)

full_name: OrderHom.map_gfp_comp
code: theorem map_gfp_comp : f (gfp (g.comp f)) = gfp (f.comp g) 
goal: f (OrderHom.gfp (g.comp f)) = OrderHom.gfp (f.comp g)

full_name: OrderHom.lfp_lfp
code: theorem lfp_lfp (h : α →o α →o α) : lfp (lfp.comp h) = lfp h.onDiag 
goal: OrderHom.lfp (OrderHom.lfp.comp h) = OrderHom.lfp h.onDiag

full_name: OrderHom.gfp_gfp
code: theorem gfp_gfp (h : α →o α →o α) : gfp (gfp.comp h) = gfp h.onDiag 
goal: OrderHom.gfp (OrderHom.gfp.comp h) = OrderHom.gfp h.onDiag

full_name: OrderHom.gfp_const_inf_le
code: theorem gfp_const_inf_le (x : α) : gfp (const α x ⊓ f) ≤ x 
goal: OrderHom.gfp ((OrderHom.const α) x ⊓ f) ≤ x

full_name: OrderHom.prevFixed
code: /-- Previous fixed point of a monotone map. If `f` is a monotone self-map of a complete lattice and
`x` is a point such that `f x ≤ x`, then `f.prevFixed x hx` is the greatest fixed point of `f`
that is less than or equal to `x`. -/
def prevFixed (x : α) (hx : f x ≤ x) : fixedPoints f 
goal: ↑(Function.fixedPoints ⇑f)

full_name: OrderHom.nextFixed
code: /-- Next fixed point of a monotone map. If `f` is a monotone self-map of a complete lattice and
`x` is a point such that `x ≤ f x`, then `f.nextFixed x hx` is the least fixed point of `f`
that is greater than or equal to `x`. -/
def nextFixed (x : α) (hx : x ≤ f x) : fixedPoints f 
goal: ↑(Function.fixedPoints ⇑f)

full_name: OrderHom.prevFixed_le
code: theorem prevFixed_le {x : α} (hx : f x ≤ x) : ↑(f.prevFixed x hx) ≤ x 
goal: ↑(f.prevFixed x hx) ≤ x

full_name: OrderHom.le_nextFixed
code: theorem le_nextFixed {x : α} (hx : x ≤ f x) : x ≤ f.nextFixed x hx 
goal: x ≤ ↑(f.nextFixed x hx)

full_name: OrderHom.nextFixed_le
code: theorem nextFixed_le {x : α} (hx : x ≤ f x) {y : fixedPoints f} (h : x ≤ y) :
    f.nextFixed x hx ≤ y 
goal: f.nextFixed x hx ≤ y

full_name: OrderHom.nextFixed_le_iff
code: @[simp]
theorem nextFixed_le_iff {x : α} (hx : x ≤ f x) {y : fixedPoints f} :
    f.nextFixed x hx ≤ y ↔ x ≤ y 
goal: f.nextFixed x hx ≤ y ↔ x ≤ ↑y

full_name: OrderHom.le_prevFixed_iff
code: @[simp]
theorem le_prevFixed_iff {x : α} (hx : f x ≤ x) {y : fixedPoints f} :
    y ≤ f.prevFixed x hx ↔ ↑y ≤ x 
goal: y ≤ f.prevFixed x hx ↔ ↑y ≤ x

full_name: OrderHom.le_prevFixed
code: theorem le_prevFixed {x : α} (hx : f x ≤ x) {y : fixedPoints f} (h : ↑y ≤ x) :
    y ≤ f.prevFixed x hx 
goal: y ≤ f.prevFixed x hx

full_name: OrderHom.le_map_sup_fixedPoints
code: theorem le_map_sup_fixedPoints (x y : fixedPoints f) : (x ⊔ y : α) ≤ f (x ⊔ y) 
goal: ↑x ⊔ ↑y ≤ f (↑x ⊔ ↑y)

full_name: OrderHom.map_inf_fixedPoints_le
code: theorem map_inf_fixedPoints_le (x y : fixedPoints f) : f (x ⊓ y) ≤ x.val ⊓ y.val 
goal: f (↑x ⊓ ↑y) ≤ ↑x ⊓ ↑y

full_name: OrderHom.le_map_sSup_subset_fixedPoints
code: theorem le_map_sSup_subset_fixedPoints (A : Set α) (hA : A ⊆ fixedPoints f) :
    sSup A ≤ f (sSup A) 
goal: sSup A ≤ f (sSup A)

full_name: OrderHom.map_sInf_subset_fixedPoints_le
code: theorem map_sInf_subset_fixedPoints_le (A : Set α) (hA : A ⊆ fixedPoints f) :
    f (sInf A) ≤ sInf A 
goal: f (sInf A) ≤ sInf A

full_name: fixedPoints.instSemilatticeSupElemFixedPointsCoeOrderHom
code: instance : SemilatticeSup (fixedPoints f) 
goal: SemilatticeSup ↑(Function.fixedPoints ⇑f)

full_name: fixedPoints.instSemilatticeInfElemFixedPointsCoeOrderHom
code: instance : SemilatticeInf (fixedPoints f) 
goal: SemilatticeInf ↑(Function.fixedPoints ⇑f)

full_name: fixedPoints.instCompleteSemilatticeSupElemFixedPointsCoeOrderHom
code: instance : CompleteSemilatticeSup (fixedPoints f) 
goal: CompleteSemilatticeSup ↑(Function.fixedPoints ⇑f)

full_name: fixedPoints.instCompleteSemilatticeInfElemFixedPointsCoeOrderHom
code: instance : CompleteSemilatticeInf (fixedPoints f) 
goal: CompleteSemilatticeInf ↑(Function.fixedPoints ⇑f)

full_name: fixedPoints.completeLattice
code: /-- **Knaster-Tarski Theorem**: The fixed points of `f` form a complete lattice. -/
instance completeLattice : CompleteLattice (fixedPoints f) 
goal: CompleteLattice ↑(Function.fixedPoints ⇑f)