File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

full_name: Ordinal.nfpFamily
code: /-- The next common fixed point, at least `a`, for a family of normal functions.

This is defined for any family of functions, as the supremum of all values reachable by applying
finitely many functions in the family to `a`.

`Ordinal.nfpFamily_fp` shows this is a fixed point, `Ordinal.le_nfpFamily` shows it's at
least `a`, and `Ordinal.nfpFamily_le_fp` shows this is the least ordinal with these properties. -/
def nfpFamily (f : ι → Ordinal → Ordinal) (a : Ordinal) : Ordinal 
goal: Ordinal.{max u_1 u}

full_name: Ordinal.nfpFamily_eq_sup
code: theorem nfpFamily_eq_sup (f : ι → Ordinal.{max u v} → Ordinal.{max u v}) (a : Ordinal.{max u v}) :
    nfpFamily.{u, v} f a = sup.{u, v} (List.foldr f a) 
goal: Ordinal.nfpFamily f a = Ordinal.sup (List.foldr f a)

full_name: Ordinal.foldr_le_nfpFamily
code: theorem foldr_le_nfpFamily (f : ι → Ordinal → Ordinal)
    (a l) : List.foldr f a l ≤ nfpFamily.{u, v} f a 
goal: List.foldr f a l ≤ Ordinal.nfpFamily f a

full_name: Ordinal.le_nfpFamily
code: theorem le_nfpFamily (f : ι → Ordinal → Ordinal) (a) : a ≤ nfpFamily f a 
goal: a ≤ Ordinal.nfpFamily f a

full_name: Ordinal.lt_nfpFamily
code: theorem lt_nfpFamily {a b} : a < nfpFamily.{u, v} f b ↔ ∃ l, a < List.foldr f b l 
goal: a < Ordinal.nfpFamily f b ↔ ∃ l, a < List.foldr f b l

full_name: Ordinal.nfpFamily_le_iff
code: theorem nfpFamily_le_iff {a b} : nfpFamily.{u, v} f a ≤ b ↔ ∀ l, List.foldr f a l ≤ b 
goal: Ordinal.nfpFamily f a ≤ b ↔ ∀ (l : List ι), List.foldr f a l ≤ b

full_name: Ordinal.nfpFamily_le
code: theorem nfpFamily_le {a b} : (∀ l, List.foldr f a l ≤ b) → nfpFamily.{u, v} f a ≤ b 
goal: (∀ (l : List ι), List.foldr f a l ≤ b) → Ordinal.nfpFamily f a ≤ b

full_name: Ordinal.nfpFamily_monotone
code: theorem nfpFamily_monotone (hf : ∀ i, Monotone (f i)) : Monotone (nfpFamily.{u, v} f) 
goal: Monotone (Ordinal.nfpFamily f)

full_name: Ordinal.apply_lt_nfpFamily
code: theorem apply_lt_nfpFamily (H : ∀ i, IsNormal (f i)) {a b} (hb : b < nfpFamily.{u, v} f a) (i) :
    f i b < nfpFamily.{u, v} f a 
goal: f i b < Ordinal.nfpFamily f a

full_name: Ordinal.apply_lt_nfpFamily_iff
code: theorem apply_lt_nfpFamily_iff [Nonempty ι] (H : ∀ i, IsNormal (f i)) {a b} :
    (∀ i, f i b < nfpFamily.{u, v} f a) ↔ b < nfpFamily.{u, v} f a 
goal: (∀ (i : ι), f i b < Ordinal.nfpFamily f a) ↔ b < Ordinal.nfpFamily f a

full_name: Ordinal.nfpFamily_le_apply
code: theorem nfpFamily_le_apply [Nonempty ι] (H : ∀ i, IsNormal (f i)) {a b} :
    (∃ i, nfpFamily.{u, v} f a ≤ f i b) ↔ nfpFamily.{u, v} f a ≤ b 
goal: (∃ i, Ordinal.nfpFamily f a ≤ f i b) ↔ Ordinal.nfpFamily f a ≤ b

full_name: Ordinal.nfpFamily_le_fp
code: theorem nfpFamily_le_fp (H : ∀ i, Monotone (f i)) {a b} (ab : a ≤ b) (h : ∀ i, f i b ≤ b) :
    nfpFamily.{u, v} f a ≤ b 
goal: Ordinal.nfpFamily f a ≤ b

full_name: Ordinal.nfpFamily_fp
code: theorem nfpFamily_fp {i} (H : IsNormal (f i)) (a) :
    f i (nfpFamily.{u, v} f a) = nfpFamily.{u, v} f a 
goal: f i (Ordinal.nfpFamily f a) = Ordinal.nfpFamily f a

full_name: Ordinal.apply_le_nfpFamily
code: theorem apply_le_nfpFamily [hι : Nonempty ι] {f : ι → Ordinal → Ordinal} (H : ∀ i, IsNormal (f i))
    {a b} : (∀ i, f i b ≤ nfpFamily.{u, v} f a) ↔ b ≤ nfpFamily.{u, v} f a 
goal: (∀ (i : ι), f i b ≤ Ordinal.nfpFamily f a) ↔ b ≤ Ordinal.nfpFamily f a

full_name: Ordinal.nfpFamily_eq_self
code: theorem nfpFamily_eq_self {f : ι → Ordinal → Ordinal} {a} (h : ∀ i, f i a = a) :
    nfpFamily f a = a 
goal: Ordinal.nfpFamily f a = a

full_name: Ordinal.fp_family_unbounded
code: /-- A generalization of the fixed point lemma for normal functions: any family of normal functions
    has an unbounded set of common fixed points. -/
theorem fp_family_unbounded (H : ∀ i, IsNormal (f i)) :
    (⋂ i, Function.fixedPoints (f i)).Unbounded (· < ·) 
goal: Set.Unbounded (fun x x_1 => x < x_1) (⋂ i, Function.fixedPoints (f i))

full_name: Ordinal.derivFamily
code: /-- The derivative of a family of normal functions is the sequence of their common fixed points.

This is defined for all functions such that `Ordinal.derivFamily_zero`,
`Ordinal.derivFamily_succ`, and `Ordinal.derivFamily_limit` are satisfied. -/
def derivFamily (f : ι → Ordinal → Ordinal) (o : Ordinal) : Ordinal 
goal: Ordinal.{max u v}

full_name: Ordinal.derivFamily_zero
code: @[simp]
theorem derivFamily_zero (f : ι → Ordinal → Ordinal) :
    derivFamily.{u, v} f 0 = nfpFamily.{u, v} f 0 
goal: Ordinal.derivFamily f 0 = Ordinal.nfpFamily f 0

full_name: Ordinal.derivFamily_succ
code: @[simp]
theorem derivFamily_succ (f : ι → Ordinal → Ordinal) (o) :
    derivFamily.{u, v} f (succ o) = nfpFamily.{u, v} f (succ (derivFamily.{u, v} f o)) 
goal: Ordinal.derivFamily f (Order.succ o) = Ordinal.nfpFamily f (Order.succ (Ordinal.derivFamily f o))

full_name: Ordinal.derivFamily_limit
code: theorem derivFamily_limit (f : ι → Ordinal → Ordinal) {o} :
    IsLimit o → derivFamily.{u, v} f o = bsup.{max u v, u} o fun a _ => derivFamily.{u, v} f a 
goal: o.IsLimit → Ordinal.derivFamily f o = o.bsup fun a x => Ordinal.derivFamily f a

full_name: Ordinal.derivFamily_isNormal
code: theorem derivFamily_isNormal (f : ι → Ordinal → Ordinal) : IsNormal (derivFamily f) 
goal: Ordinal.IsNormal (Ordinal.derivFamily f)

full_name: Ordinal.derivFamily_fp
code: theorem derivFamily_fp {i} (H : IsNormal (f i)) (o : Ordinal.{max u v}) :
    f i (derivFamily.{u, v} f o) = derivFamily.{u, v} f o 
goal: f i (Ordinal.derivFamily f o) = Ordinal.derivFamily f o

full_name: Ordinal.le_iff_derivFamily
code: theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a 
goal: (∀ (i : ι), f i a ≤ a) ↔ ∃ o, Ordinal.derivFamily f o = a

full_name: Ordinal.fp_iff_derivFamily
code: theorem fp_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a = a) ↔ ∃ o, derivFamily.{u, v} f o = a 
goal: (∀ (i : ι), f i a = a) ↔ ∃ o, Ordinal.derivFamily f o = a

full_name: Ordinal.derivFamily_eq_enumOrd
code: /-- For a family of normal functions, `Ordinal.derivFamily` enumerates the common fixed points. -/
theorem derivFamily_eq_enumOrd (H : ∀ i, IsNormal (f i)) :
    derivFamily.{u, v} f = enumOrd (⋂ i, Function.fixedPoints (f i)) 
goal: Ordinal.derivFamily f = Ordinal.enumOrd (⋂ i, Function.fixedPoints (f i))

full_name: Ordinal.nfpBFamily
code: /-- The next common fixed point, at least `a`, for a family of normal functions indexed by ordinals.

This is defined as `Ordinal.nfpFamily` of the type-indexed family associated to `f`. -/
def nfpBFamily (o : Ordinal) (f : ∀ b < o, Ordinal → Ordinal) : Ordinal → Ordinal 
goal: Ordinal.{max u_2 u_1} → Ordinal.{max u_2 u_1}

full_name: Ordinal.nfpBFamily_eq_nfpFamily
code: theorem nfpBFamily_eq_nfpFamily {o : Ordinal} (f : ∀ b < o, Ordinal → Ordinal) :
    nfpBFamily.{u, v} o f = nfpFamily.{u, v} (familyOfBFamily o f) 
goal: o.nfpBFamily f = Ordinal.nfpFamily (o.familyOfBFamily f)

full_name: Ordinal.foldr_le_nfpBFamily
code: theorem foldr_le_nfpBFamily {o : Ordinal}
    (f : ∀ b < o, Ordinal → Ordinal) (a l) :
    List.foldr (familyOfBFamily o f) a l ≤ nfpBFamily.{u, v} o f a 
goal: List.foldr (o.familyOfBFamily f) a l ≤ o.nfpBFamily f a

full_name: Ordinal.le_nfpBFamily
code: theorem le_nfpBFamily {o : Ordinal} (f : ∀ b < o, Ordinal → Ordinal) (a) :
    a ≤ nfpBFamily.{u, v} o f a 
goal: a ≤ o.nfpBFamily f a

full_name: Ordinal.lt_nfpBFamily
code: theorem lt_nfpBFamily {a b} :
    a < nfpBFamily.{u, v} o f b ↔ ∃ l, a < List.foldr (familyOfBFamily o f) b l 
goal: a < o.nfpBFamily f b ↔ ∃ l, a < List.foldr (o.familyOfBFamily f) b l

full_name: Ordinal.nfpBFamily_le_iff
code: theorem nfpBFamily_le_iff {o : Ordinal} {f : ∀ b < o, Ordinal → Ordinal} {a b} :
    nfpBFamily.{u, v} o f a ≤ b ↔ ∀ l, List.foldr (familyOfBFamily o f) a l ≤ b 
goal: o.nfpBFamily f a ≤ b ↔ ∀ (l : List (Quotient.out o).α), List.foldr (o.familyOfBFamily f) a l ≤ b

full_name: Ordinal.nfpBFamily_le
code: theorem nfpBFamily_le {o : Ordinal} {f : ∀ b < o, Ordinal → Ordinal} {a b} :
    (∀ l, List.foldr (familyOfBFamily o f) a l ≤ b) → nfpBFamily.{u, v} o f a ≤ b 
goal: (∀ (l : List (Quotient.out o).α), List.foldr (o.familyOfBFamily f) a l ≤ b) → o.nfpBFamily f a ≤ b

full_name: Ordinal.nfpBFamily_monotone
code: theorem nfpBFamily_monotone (hf : ∀ i hi, Monotone (f i hi)) : Monotone (nfpBFamily.{u, v} o f) 
goal: Monotone (o.nfpBFamily f)

full_name: Ordinal.apply_lt_nfpBFamily
code: theorem apply_lt_nfpBFamily (H : ∀ i hi, IsNormal (f i hi)) {a b} (hb : b < nfpBFamily.{u, v} o f a)
    (i hi) : f i hi b < nfpBFamily.{u, v} o f a 
goal: f i hi b < o.nfpBFamily f a

full_name: Ordinal.apply_lt_nfpBFamily_iff
code: theorem apply_lt_nfpBFamily_iff (ho : o ≠ 0) (H : ∀ i hi, IsNormal (f i hi)) {a b} :
    (∀ i hi, f i hi b < nfpBFamily.{u, v} o f a) ↔ b < nfpBFamily.{u, v} o f a 
goal: (∀ (i : Ordinal.{u}) (hi : i < o), f i hi b < o.nfpBFamily f a) ↔ b < o.nfpBFamily f a

full_name: Ordinal.nfpBFamily_le_apply
code: theorem nfpBFamily_le_apply (ho : o ≠ 0) (H : ∀ i hi, IsNormal (f i hi)) {a b} :
    (∃ i hi, nfpBFamily.{u, v} o f a ≤ f i hi b) ↔ nfpBFamily.{u, v} o f a ≤ b 
goal: (∃ i, ∃ (hi : i < o), o.nfpBFamily f a ≤ f i hi b) ↔ o.nfpBFamily f a ≤ b

full_name: Ordinal.nfpBFamily_le_fp
code: theorem nfpBFamily_le_fp (H : ∀ i hi, Monotone (f i hi)) {a b} (ab : a ≤ b)
    (h : ∀ i hi, f i hi b ≤ b) : nfpBFamily.{u, v} o f a ≤ b 
goal: o.nfpBFamily f a ≤ b

full_name: Ordinal.nfpBFamily_fp
code: theorem nfpBFamily_fp {i hi} (H : IsNormal (f i hi)) (a) :
    f i hi (nfpBFamily.{u, v} o f a) = nfpBFamily.{u, v} o f a 
goal: f i hi (o.nfpBFamily f a) = o.nfpBFamily f a

full_name: Ordinal.apply_le_nfpBFamily
code: theorem apply_le_nfpBFamily (ho : o ≠ 0) (H : ∀ i hi, IsNormal (f i hi)) {a b} :
    (∀ i hi, f i hi b ≤ nfpBFamily.{u, v} o f a) ↔ b ≤ nfpBFamily.{u, v} o f a 
goal: (∀ (i : Ordinal.{u}) (hi : i < o), f i hi b ≤ o.nfpBFamily f a) ↔ b ≤ o.nfpBFamily f a

full_name: Ordinal.nfpBFamily_eq_self
code: theorem nfpBFamily_eq_self {a} (h : ∀ i hi, f i hi a = a) : nfpBFamily.{u, v} o f a = a 
goal: o.nfpBFamily f a = a

full_name: Ordinal.fp_bfamily_unbounded
code: /-- A generalization of the fixed point lemma for normal functions: any family of normal functions
    has an unbounded set of common fixed points. -/
theorem fp_bfamily_unbounded (H : ∀ i hi, IsNormal (f i hi)) :
    (⋂ (i) (hi), Function.fixedPoints (f i hi)).Unbounded (· < ·) 
goal: Set.Unbounded (fun x x_1 => x < x_1) (⋂ i, ⋂ (hi : i < o), Function.fixedPoints (f i hi))

full_name: Ordinal.derivBFamily
code: /-- The derivative of a family of normal functions is the sequence of their common fixed points.

This is defined as `Ordinal.derivFamily` of the type-indexed family associated to `f`. -/
def derivBFamily (o : Ordinal) (f : ∀ b < o, Ordinal → Ordinal) : Ordinal → Ordinal 
goal: Ordinal.{max u_2 u_1} → Ordinal.{max u_2 u_1}

full_name: Ordinal.derivBFamily_eq_derivFamily
code: theorem derivBFamily_eq_derivFamily {o : Ordinal} (f : ∀ b < o, Ordinal → Ordinal) :
    derivBFamily.{u, v} o f = derivFamily.{u, v} (familyOfBFamily o f) 
goal: o.derivBFamily f = Ordinal.derivFamily (o.familyOfBFamily f)

full_name: Ordinal.derivBFamily_isNormal
code: theorem derivBFamily_isNormal {o : Ordinal} (f : ∀ b < o, Ordinal → Ordinal) :
    IsNormal (derivBFamily o f) 
goal: Ordinal.IsNormal (o.derivBFamily f)

full_name: Ordinal.derivBFamily_fp
code: theorem derivBFamily_fp {i hi} (H : IsNormal (f i hi)) (a : Ordinal) :
    f i hi (derivBFamily.{u, v} o f a) = derivBFamily.{u, v} o f a 
goal: f i hi (o.derivBFamily f a) = o.derivBFamily f a

full_name: Ordinal.le_iff_derivBFamily
code: theorem le_iff_derivBFamily (H : ∀ i hi, IsNormal (f i hi)) {a} :
    (∀ i hi, f i hi a ≤ a) ↔ ∃ b, derivBFamily.{u, v} o f b = a 
goal: (∀ (i : Ordinal.{u}) (hi : i < o), f i hi a ≤ a) ↔ ∃ b, o.derivBFamily f b = a

full_name: Ordinal.fp_iff_derivBFamily
code: theorem fp_iff_derivBFamily (H : ∀ i hi, IsNormal (f i hi)) {a} :
    (∀ i hi, f i hi a = a) ↔ ∃ b, derivBFamily.{u, v} o f b = a 
goal: (∀ (i : Ordinal.{u}) (hi : i < o), f i hi a = a) ↔ ∃ b, o.derivBFamily f b = a

full_name: Ordinal.derivBFamily_eq_enumOrd
code: /-- For a family of normal functions, `Ordinal.derivBFamily` enumerates the common fixed points. -/
theorem derivBFamily_eq_enumOrd (H : ∀ i hi, IsNormal (f i hi)) :
    derivBFamily.{u, v} o f = enumOrd (⋂ (i) (hi), Function.fixedPoints (f i hi)) 
goal: o.derivBFamily f = Ordinal.enumOrd (⋂ i, ⋂ (hi : i < o), Function.fixedPoints (f i hi))

full_name: Ordinal.nfp
code: /-- The next fixed point function, the least fixed point of the normal function `f`, at least `a`.

This is defined as `ordinal.nfpFamily` applied to a family consisting only of `f`. -/
def nfp (f : Ordinal → Ordinal) : Ordinal → Ordinal 
goal: Ordinal.{u_1} → Ordinal.{u_1}

full_name: Ordinal.nfp_eq_nfpFamily
code: theorem nfp_eq_nfpFamily (f : Ordinal → Ordinal) : nfp f = nfpFamily fun _ : Unit => f 
goal: Ordinal.nfp f = Ordinal.nfpFamily fun x => f

full_name: Ordinal.sup_iterate_eq_nfp
code: @[simp]
theorem sup_iterate_eq_nfp (f : Ordinal.{u} → Ordinal.{u}) :
    (fun a => sup fun n : ℕ => f^[n] a) = nfp f 
goal: (fun a => Ordinal.sup fun n => f^[n] a) = Ordinal.nfp f

full_name: Ordinal.iterate_le_nfp
code: theorem iterate_le_nfp (f a n) : f^[n] a ≤ nfp f a 
goal: f^[n] a ≤ Ordinal.nfp f a

full_name: Ordinal.le_nfp
code: theorem le_nfp (f a) : a ≤ nfp f a 
goal: a ≤ Ordinal.nfp f a

full_name: Ordinal.lt_nfp
code: theorem lt_nfp {a b} : a < nfp f b ↔ ∃ n, a < f^[n] b 
goal: a < Ordinal.nfp f b ↔ ∃ n, a < f^[n] b

full_name: Ordinal.nfp_le_iff
code: theorem nfp_le_iff {a b} : nfp f a ≤ b ↔ ∀ n, f^[n] a ≤ b 
goal: Ordinal.nfp f a ≤ b ↔ ∀ (n : ℕ), f^[n] a ≤ b

full_name: Ordinal.nfp_le
code: theorem nfp_le {a b} : (∀ n, f^[n] a ≤ b) → nfp f a ≤ b 
goal: (∀ (n : ℕ), f^[n] a ≤ b) → Ordinal.nfp f a ≤ b

full_name: Ordinal.nfp_id
code: @[simp]
theorem nfp_id : nfp id = id 
goal: Ordinal.nfp id = id

full_name: Ordinal.nfp_monotone
code: theorem nfp_monotone (hf : Monotone f) : Monotone (nfp f) 
goal: Monotone (Ordinal.nfp f)

full_name: Ordinal.IsNormal.apply_lt_nfp
code: theorem IsNormal.apply_lt_nfp {f} (H : IsNormal f) {a b} : f b < nfp f a ↔ b < nfp f a 
goal: f b < Ordinal.nfp f a ↔ b < Ordinal.nfp f a

full_name: Ordinal.IsNormal.nfp_le_apply
code: theorem IsNormal.nfp_le_apply {f} (H : IsNormal f) {a b} : nfp f a ≤ f b ↔ nfp f a ≤ b 
goal: Ordinal.nfp f a ≤ f b ↔ Ordinal.nfp f a ≤ b

full_name: Ordinal.nfp_le_fp
code: theorem nfp_le_fp {f} (H : Monotone f) {a b} (ab : a ≤ b) (h : f b ≤ b) : nfp f a ≤ b 
goal: Ordinal.nfp f a ≤ b

full_name: Ordinal.IsNormal.nfp_fp
code: theorem IsNormal.nfp_fp {f} (H : IsNormal f) : ∀ a, f (nfp f a) = nfp f a 
goal: f (Ordinal.nfp f a) = Ordinal.nfp f a

full_name: Ordinal.IsNormal.apply_le_nfp
code: theorem IsNormal.apply_le_nfp {f} (H : IsNormal f) {a b} : f b ≤ nfp f a ↔ b ≤ nfp f a 
goal: f b ≤ Ordinal.nfp f a ↔ b ≤ Ordinal.nfp f a

full_name: Ordinal.nfp_eq_self
code: theorem nfp_eq_self {f : Ordinal → Ordinal} {a} (h : f a = a) : nfp f a = a 
goal: Ordinal.nfp f a = a

full_name: Ordinal.fp_unbounded
code: /-- The fixed point lemma for normal functions: any normal function has an unbounded set of
fixed points. -/
theorem fp_unbounded (H : IsNormal f) : (Function.fixedPoints f).Unbounded (· < ·) 
goal: Set.Unbounded (fun x x_1 => x < x_1) (Function.fixedPoints f)

full_name: Ordinal.deriv
code: /-- The derivative of a normal function `f` is the sequence of fixed points of `f`.

This is defined as `Ordinal.derivFamily` applied to a trivial family consisting only of `f`. -/
def deriv (f : Ordinal → Ordinal) : Ordinal → Ordinal 
goal: Ordinal.{u_1} → Ordinal.{u_1}

full_name: Ordinal.deriv_eq_derivFamily
code: theorem deriv_eq_derivFamily (f : Ordinal → Ordinal) : deriv f = derivFamily fun _ : Unit => f 
goal: Ordinal.deriv f = Ordinal.derivFamily fun x => f

full_name: Ordinal.deriv_zero
code: @[simp]
theorem deriv_zero (f) : deriv f 0 = nfp f 0 
goal: Ordinal.deriv f 0 = Ordinal.nfp f 0

full_name: Ordinal.deriv_succ
code: @[simp]
theorem deriv_succ (f o) : deriv f (succ o) = nfp f (succ (deriv f o)) 
goal: Ordinal.deriv f (Order.succ o) = Ordinal.nfp f (Order.succ (Ordinal.deriv f o))

full_name: Ordinal.deriv_limit
code: theorem deriv_limit (f) {o} : IsLimit o → deriv f o = bsup.{u, 0} o fun a _ => deriv f a 
goal: o.IsLimit → Ordinal.deriv f o = o.bsup fun a x => Ordinal.deriv f a

full_name: Ordinal.deriv_isNormal
code: theorem deriv_isNormal (f) : IsNormal (deriv f) 
goal: Ordinal.IsNormal (Ordinal.deriv f)

full_name: Ordinal.deriv_id_of_nfp_id
code: theorem deriv_id_of_nfp_id {f : Ordinal → Ordinal} (h : nfp f = id) : deriv f = id 
goal: Ordinal.deriv f = id

full_name: Ordinal.IsNormal.deriv_fp
code: theorem IsNormal.deriv_fp {f} (H : IsNormal f) : ∀ o, f (deriv f o) = deriv f o 
goal: f (Ordinal.deriv f o) = Ordinal.deriv f o

full_name: Ordinal.IsNormal.le_iff_deriv
code: theorem IsNormal.le_iff_deriv {f} (H : IsNormal f) {a} : f a ≤ a ↔ ∃ o, deriv f o = a 
goal: f a ≤ a ↔ ∃ o, Ordinal.deriv f o = a

full_name: Ordinal.IsNormal.fp_iff_deriv
code: theorem IsNormal.fp_iff_deriv {f} (H : IsNormal f) {a} : f a = a ↔ ∃ o, deriv f o = a 
goal: f a = a ↔ ∃ o, Ordinal.deriv f o = a

full_name: Ordinal.deriv_eq_enumOrd
code: /-- `Ordinal.deriv` enumerates the fixed points of a normal function. -/
theorem deriv_eq_enumOrd (H : IsNormal f) : deriv f = enumOrd (Function.fixedPoints f) 
goal: Ordinal.deriv f = Ordinal.enumOrd (Function.fixedPoints f)

full_name: Ordinal.deriv_eq_id_of_nfp_eq_id
code: theorem deriv_eq_id_of_nfp_eq_id {f : Ordinal → Ordinal} (h : nfp f = id) : deriv f = id 
goal: Ordinal.deriv f = id

full_name: Ordinal.nfp_add_zero
code: @[simp]
theorem nfp_add_zero (a) : nfp (a + ·) 0 = a * omega 
goal: Ordinal.nfp (fun x => a + x) 0 = a * Ordinal.omega

full_name: Ordinal.nfp_add_eq_mul_omega
code: theorem nfp_add_eq_mul_omega {a b} (hba : b ≤ a * omega) : nfp (a + ·) b = a * omega 
goal: Ordinal.nfp (fun x => a + x) b = a * Ordinal.omega

full_name: Ordinal.add_eq_right_iff_mul_omega_le
code: theorem add_eq_right_iff_mul_omega_le {a b : Ordinal} : a + b = b ↔ a * omega ≤ b 
goal: a + b = b ↔ a * Ordinal.omega ≤ b

full_name: Ordinal.add_le_right_iff_mul_omega_le
code: theorem add_le_right_iff_mul_omega_le {a b : Ordinal} : a + b ≤ b ↔ a * omega ≤ b 
goal: a + b ≤ b ↔ a * Ordinal.omega ≤ b

full_name: Ordinal.deriv_add_eq_mul_omega_add
code: theorem deriv_add_eq_mul_omega_add (a b : Ordinal.{u}) : deriv (a + ·) b = a * omega + b 
goal: Ordinal.deriv (fun x => a + x) b = a * Ordinal.omega + b

full_name: Ordinal.nfp_mul_one
code: @[simp]
theorem nfp_mul_one {a : Ordinal} (ha : 0 < a) : nfp (a * ·) 1 = (a^omega) 
goal: Ordinal.nfp (fun x => a * x) 1 = a ^ Ordinal.omega

full_name: Ordinal.nfp_mul_zero
code: @[simp]
theorem nfp_mul_zero (a : Ordinal) : nfp (a * ·) 0 = 0 
goal: Ordinal.nfp (fun x => a * x) 0 = 0

full_name: Ordinal.nfp_zero_mul
code: @[simp]
theorem nfp_zero_mul : nfp (HMul.hMul 0) = id 
goal: Ordinal.nfp (HMul.hMul 0) = id

full_name: Ordinal.deriv_mul_zero
code: @[simp]
theorem deriv_mul_zero : deriv (HMul.hMul 0) = id 
goal: Ordinal.deriv (HMul.hMul 0) = id

full_name: Ordinal.nfp_mul_eq_opow_omega
code: theorem nfp_mul_eq_opow_omega {a b : Ordinal} (hb : 0 < b) (hba : b ≤ (a^omega)) :
    nfp (a * ·) b = (a^omega.{u}) 
goal: Ordinal.nfp (fun x => a * x) b = a ^ Ordinal.omega

full_name: Ordinal.eq_zero_or_opow_omega_le_of_mul_eq_right
code: theorem eq_zero_or_opow_omega_le_of_mul_eq_right {a b : Ordinal} (hab : a * b = b) :
    b = 0 ∨ (a^omega.{u}) ≤ b 
goal: b = 0 ∨ a ^ Ordinal.omega ≤ b

full_name: Ordinal.mul_eq_right_iff_opow_omega_dvd
code: theorem mul_eq_right_iff_opow_omega_dvd {a b : Ordinal} : a * b = b ↔ (a^omega) ∣ b 
goal: a * b = b ↔ a ^ Ordinal.omega ∣ b

full_name: Ordinal.mul_le_right_iff_opow_omega_dvd
code: theorem mul_le_right_iff_opow_omega_dvd {a b : Ordinal} (ha : 0 < a) :
    a * b ≤ b ↔ (a^omega) ∣ b 
goal: a * b ≤ b ↔ a ^ Ordinal.omega ∣ b

full_name: Ordinal.nfp_mul_opow_omega_add
code: theorem nfp_mul_opow_omega_add {a c : Ordinal} (b) (ha : 0 < a) (hc : 0 < c) (hca : c ≤ (a^omega)) :
    nfp (a * ·) ((a^omega) * b + c) = (a^omega.{u}) * succ b 
goal: Ordinal.nfp (fun x => a * x) (a ^ Ordinal.omega * b + c) = a ^ Ordinal.omega * Order.succ b

full_name: Ordinal.deriv_mul_eq_opow_omega_mul
code: theorem deriv_mul_eq_opow_omega_mul {a : Ordinal.{u}} (ha : 0 < a) (b) :
    deriv (a * ·) b = (a^omega) * b 
goal: Ordinal.deriv (fun x => a * x) b = a ^ Ordinal.omega * b