l3lab/ntp-mathlib huggingface dataset:
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 :=
  sup_le fun l => by
    by_cases hι : IsEmpty ι
    · rwa [Unique.eq_default l]
    · induction' l with i l IH generalizing a
      · 

Proof state:
case neg.nil
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
b : Ordinal.{max u v}
h : ∀ (i : ι), f i b ≤ b
hι : ¬IsEmpty ι
a : Ordinal.{max u v}
ab : a ≤ b
⊢ List.foldr f a [] ≤ b

Next tactic:
exact ab
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 :=
  sup_le fun l => by
    by_cases hι : IsEmpty ι
    · rwa [Unique.eq_default l]
    · induction' l with i l IH generalizing a
      · exact ab
      

Proof state:
case neg.cons
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), Monotone (f i)
b : Ordinal.{max u v}
h : ∀ (i : ι), f i b ≤ b
hι : ¬IsEmpty ι
i : ι
l : List ι
IH : ∀ {a : Ordinal.{max u v}}, a ≤ b → List.foldr f a l ≤ b
a : Ordinal.{max u v}
ab : a ≤ b
⊢ List.foldr f a (i :: l) ≤ b

Next tactic:
exact (H i (IH ab)).trans (h i)
theorem nfpFamily_fp {i} (H : IsNormal (f i)) (a) :
    f i (nfpFamily.{u, v} f a) = nfpFamily.{u, v} f a := by
  

Proof state:
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
⊢ f i (nfpFamily f a) = nfpFamily f a

Next tactic:
unfold nfpFamily
theorem nfpFamily_fp {i} (H : IsNormal (f i)) (a) :
    f i (nfpFamily.{u, v} f a) = nfpFamily.{u, v} f a := by
  unfold nfpFamily
  

Proof state:
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
⊢ f i (sup (List.foldr f a)) = sup (List.foldr f a)

Next tactic:
rw [@IsNormal.sup.{u, v, v} _ H _ _ ⟨[]⟩]
theorem nfpFamily_fp {i} (H : IsNormal (f i)) (a) :
    f i (nfpFamily.{u, v} f a) = nfpFamily.{u, v} f a := by
  unfold nfpFamily
  rw [@IsNormal.sup.{u, v, v} _ H _ _ ⟨[]⟩]
  

Proof state:
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
⊢ sup (f i ∘ List.foldr f a) = sup (List.foldr f a)

Next tactic:
apply le_antisymm
theorem nfpFamily_fp {i} (H : IsNormal (f i)) (a) :
    f i (nfpFamily.{u, v} f a) = nfpFamily.{u, v} f a := by
  unfold nfpFamily
  rw [@IsNormal.sup.{u, v, v} _ H _ _ ⟨[]⟩]
  apply le_antisymm <;> 

Proof state:
case a
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
⊢ sup (f i ∘ List.foldr f a) ≤ sup (List.foldr f a)

Next tactic:
refine' Ordinal.sup_le fun l => _
theorem nfpFamily_fp {i} (H : IsNormal (f i)) (a) :
    f i (nfpFamily.{u, v} f a) = nfpFamily.{u, v} f a := by
  unfold nfpFamily
  rw [@IsNormal.sup.{u, v, v} _ H _ _ ⟨[]⟩]
  apply le_antisymm <;> 

Proof state:
case a
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
⊢ sup (List.foldr f a) ≤ sup (f i ∘ List.foldr f a)

Next tactic:
refine' Ordinal.sup_le fun l => _
theorem nfpFamily_fp {i} (H : IsNormal (f i)) (a) :
    f i (nfpFamily.{u, v} f a) = nfpFamily.{u, v} f a := by
  unfold nfpFamily
  rw [@IsNormal.sup.{u, v, v} _ H _ _ ⟨[]⟩]
  apply le_antisymm <;> refine' Ordinal.sup_le fun l => _
  · 

Proof state:
case a
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
l : List ι
⊢ (f i ∘ List.foldr f a) l ≤ sup (List.foldr f a)

Next tactic:
exact le_sup _ (i::l)
theorem nfpFamily_fp {i} (H : IsNormal (f i)) (a) :
    f i (nfpFamily.{u, v} f a) = nfpFamily.{u, v} f a := by
  unfold nfpFamily
  rw [@IsNormal.sup.{u, v, v} _ H _ _ ⟨[]⟩]
  apply le_antisymm <;> refine' Ordinal.sup_le fun l => _
  · exact le_sup _ (i::l)
  · 

Proof state:
case a
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
a : Ordinal.{max u v}
l : List ι
⊢ List.foldr f a l ≤ sup (f i ∘ List.foldr f a)

Next tactic:
exact (H.self_le _).trans (le_sup _ _)
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 := by
  

Proof state:
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
hι : Nonempty ι
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
⊢ (∀ (i : ι), f i b ≤ nfpFamily f a) ↔ b ≤ nfpFamily f a

Next tactic:
refine' ⟨fun h => _, fun h i => _⟩
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 := by
  refine' ⟨fun h => _, fun h i => _⟩
  · 

Proof state:
case refine'_1
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
hι : Nonempty ι
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
h : ∀ (i : ι), f i b ≤ nfpFamily f a
⊢ b ≤ nfpFamily f a

Next tactic:
cases' hι with i
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 := by
  refine' ⟨fun h => _, fun h i => _⟩
  · cases' hι with i
    

Proof state:
case refine'_1.intro
ι : Type u
f✝ f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
h : ∀ (i : ι), f i b ≤ nfpFamily f a
i : ι
⊢ b ≤ nfpFamily f a

Next tactic:
exact ((H i).self_le b).trans (h i)
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 := by
  refine' ⟨fun h => _, fun h i => _⟩
  · cases' hι with i
    exact ((H i).self_le b).trans (h i)
  

Proof state:
case refine'_2
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
hι : Nonempty ι
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
h : b ≤ nfpFamily f a
i : ι
⊢ f i b ≤ nfpFamily f a

Next tactic:
rw [← nfpFamily_fp (H i)]
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 := by
  refine' ⟨fun h => _, fun h i => _⟩
  · cases' hι with i
    exact ((H i).self_le b).trans (h i)
  rw [← nfpFamily_fp (H i)]
  

Proof state:
case refine'_2
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
hι : Nonempty ι
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a b : Ordinal.{max u v}
h : b ≤ nfpFamily f a
i : ι
⊢ f i b ≤ f i (nfpFamily f a)

Next tactic:
exact (H i).monotone h
theorem nfpFamily_eq_self {f : ι → Ordinal → Ordinal} {a} (h : ∀ i, f i a = a) :
    nfpFamily f a = a :=
  le_antisymm (sup_le fun l => by 

Proof state:
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
f : ι → Ordinal.{max u u_1} → Ordinal.{max u u_1}
a : Ordinal.{max u u_1}
h : ∀ (i : ι), f i a = a
l : List ι
⊢ List.foldr f a l ≤ a

Next tactic:
rw [List.foldr_fixed' h l]
/-- 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 (· < ·) := fun a =>
  ⟨nfpFamily.{u, v} f a, fun s ⟨i, hi⟩ => by
    

Proof state:
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
s : Set Ordinal.{max u v}
x✝ : s ∈ Set.range fun i => fixedPoints (f i)
i : ι
hi : (fun i => fixedPoints (f i)) i = s
⊢ nfpFamily f a ∈ s

Next tactic:
rw [← hi, mem_fixedPoints_iff]
/-- 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 (· < ·) := fun a =>
  ⟨nfpFamily.{u, v} f a, fun s ⟨i, hi⟩ => by
    rw [← hi, mem_fixedPoints_iff]
    

Proof state:
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
s : Set Ordinal.{max u v}
x✝ : s ∈ Set.range fun i => fixedPoints (f i)
i : ι
hi : (fun i => fixedPoints (f i)) i = s
⊢ f i (nfpFamily f a) = nfpFamily f a

Next tactic:
exact nfpFamily_fp.{u, v} (H i) a
theorem derivFamily_isNormal (f : ι → Ordinal → Ordinal) : IsNormal (derivFamily f) :=
  ⟨fun o => by 

Proof state:
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
f : ι → Ordinal.{max u u_1} → Ordinal.{max u u_1}
o : Ordinal.{max u_1 u}
⊢ derivFamily f o < derivFamily f (succ o)

Next tactic:
rw [derivFamily_succ, ← succ_le_iff]
theorem derivFamily_isNormal (f : ι → Ordinal → Ordinal) : IsNormal (derivFamily f) :=
  ⟨fun o => by rw [derivFamily_succ, ← succ_le_iff]; 

Proof state:
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
f : ι → Ordinal.{max u u_1} → Ordinal.{max u u_1}
o : Ordinal.{max u_1 u}
⊢ succ (derivFamily f o) ≤ nfpFamily f (succ (derivFamily f o))

Next tactic:
apply le_nfpFamily
theorem derivFamily_isNormal (f : ι → Ordinal → Ordinal) : IsNormal (derivFamily f) :=
  ⟨fun o => by rw [derivFamily_succ, ← succ_le_iff]; apply le_nfpFamily, fun o l a => by
    

Proof state:
ι : Type u
f✝ : ι → Ordinal.{max u v} → Ordinal.{max u v}
f : ι → Ordinal.{max u u_1} → Ordinal.{max u u_1}
o : Ordinal.{max u_1 u}
l : IsLimit o
a : Ordinal.{max u_1 u}
⊢ derivFamily f o ≤ a ↔ ∀ b < o, derivFamily f b ≤ a

Next tactic:
rw [derivFamily_limit _ l, bsup_le_iff]
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 := by
  

Proof state:
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
o : Ordinal.{max u v}
⊢ f i (derivFamily f o) = derivFamily f o

Next tactic:
induction' o using limitRecOn with o _ o l IH
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 := by
  induction' o using limitRecOn with o _ o l IH
  · 

Proof state:
case H₁
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
⊢ f i (derivFamily f 0) = derivFamily f 0

Next tactic:
rw [derivFamily_zero]
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 := by
  induction' o using limitRecOn with o _ o l IH
  · rw [derivFamily_zero]
    

Proof state:
case H₁
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
⊢ f i (nfpFamily f 0) = nfpFamily f 0

Next tactic:
exact nfpFamily_fp H 0
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 := by
  induction' o using limitRecOn with o _ o l IH
  · rw [derivFamily_zero]
    exact nfpFamily_fp H 0
  · 

Proof state:
case H₂
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
o : Ordinal.{max u v}
a✝ : f i (derivFamily f o) = derivFamily f o
⊢ f i (derivFamily f (succ o)) = derivFamily f (succ o)

Next tactic:
rw [derivFamily_succ]
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 := by
  induction' o using limitRecOn with o _ o l IH
  · rw [derivFamily_zero]
    exact nfpFamily_fp H 0
  · rw [derivFamily_succ]
    

Proof state:
case H₂
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
o : Ordinal.{max u v}
a✝ : f i (derivFamily f o) = derivFamily f o
⊢ f i (nfpFamily f (succ (derivFamily f o))) = nfpFamily f (succ (derivFamily f o))

Next tactic:
exact nfpFamily_fp H _
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 := by
  induction' o using limitRecOn with o _ o l IH
  · rw [derivFamily_zero]
    exact nfpFamily_fp H 0
  · rw [derivFamily_succ]
    exact nfpFamily_fp H _
  · 

Proof state:
case H₃
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
o : Ordinal.{max u v}
l : IsLimit o
IH : ∀ o' < o, f i (derivFamily f o') = derivFamily f o'
⊢ f i (derivFamily f o) = derivFamily f o

Next tactic:
rw [derivFamily_limit _ l,
      IsNormal.bsup.{max u v, u, max u v} H (fun a _ => derivFamily f a) l.1]
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 := by
  induction' o using limitRecOn with o _ o l IH
  · rw [derivFamily_zero]
    exact nfpFamily_fp H 0
  · rw [derivFamily_succ]
    exact nfpFamily_fp H _
  · rw [derivFamily_limit _ l,
      IsNormal.bsup.{max u v, u, max u v} H (fun a _ => derivFamily f a) l.1]
    

Proof state:
case H₃
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
o : Ordinal.{max u v}
l : IsLimit o
IH : ∀ o' < o, f i (derivFamily f o') = derivFamily f o'
⊢ (bsup o fun a h => f i (derivFamily f a)) = bsup o fun a x => derivFamily f a

Next tactic:
refine' eq_of_forall_ge_iff fun c => _
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 := by
  induction' o using limitRecOn with o _ o l IH
  · rw [derivFamily_zero]
    exact nfpFamily_fp H 0
  · rw [derivFamily_succ]
    exact nfpFamily_fp H _
  · rw [derivFamily_limit _ l,
      IsNormal.bsup.{max u v, u, max u v} H (fun a _ => derivFamily f a) l.1]
    refine' eq_of_forall_ge_iff fun c => _
    

Proof state:
case H₃
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
i : ι
H : IsNormal (f i)
o : Ordinal.{max u v}
l : IsLimit o
IH : ∀ o' < o, f i (derivFamily f o') = derivFamily f o'
c : Ordinal.{max u v}
⊢ (bsup o fun a h => f i (derivFamily f a)) ≤ c ↔ (bsup o fun a x => derivFamily f a) ≤ c

Next tactic:
simp (config := { contextual := true }) only [bsup_le_iff, IH]
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    

Proof state:
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
⊢ ∃ o, derivFamily f o = a

Next tactic:
suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
    

Proof state:
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
this : ∀ (o : Ordinal.{max u v}), a ≤ derivFamily f o → ∃ o, derivFamily f o = a
⊢ ∃ o, derivFamily f o = a
case this
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
⊢ ∀ (o : Ordinal.{max u v}), a ≤ derivFamily f o → ∃ o, derivFamily f o = a

Next tactic:
exact this a ((derivFamily_isNormal _).self_le _)
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
    exact this a ((derivFamily_isNormal _).self_le _)
    

Proof state:
case this
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
⊢ ∀ (o : Ordinal.{max u v}), a ≤ derivFamily f o → ∃ o, derivFamily f o = a

Next tactic:
intro o
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
    exact this a ((derivFamily_isNormal _).self_le _)
    intro o
    

Proof state:
case this
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
o : Ordinal.{max u v}
⊢ a ≤ derivFamily f o → ∃ o, derivFamily f o = a

Next tactic:
induction' o using limitRecOn with o IH o l IH
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
    exact this a ((derivFamily_isNormal _).self_le _)
    intro o
    induction' o using limitRecOn with o IH o l IH
    · 

Proof state:
case this.H₁
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
⊢ a ≤ derivFamily f 0 → ∃ o, derivFamily f o = a

Next tactic:
intro h₁
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
    exact this a ((derivFamily_isNormal _).self_le _)
    intro o
    induction' o using limitRecOn with o IH o l IH
    · intro h₁
      

Proof state:
case this.H₁
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
h₁ : a ≤ derivFamily f 0
⊢ ∃ o, derivFamily f o = a

Next tactic:
refine' ⟨0, le_antisymm _ h₁⟩
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
    exact this a ((derivFamily_isNormal _).self_le _)
    intro o
    induction' o using limitRecOn with o IH o l IH
    · intro h₁
      refine' ⟨0, le_antisymm _ h₁⟩
      

Proof state:
case this.H₁
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
h₁ : a ≤ derivFamily f 0
⊢ derivFamily f 0 ≤ a

Next tactic:
rw [derivFamily_zero]
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
    exact this a ((derivFamily_isNormal _).self_le _)
    intro o
    induction' o using limitRecOn with o IH o l IH
    · intro h₁
      refine' ⟨0, le_antisymm _ h₁⟩
      rw [derivFamily_zero]
      

Proof state:
case this.H₁
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
h₁ : a ≤ derivFamily f 0
⊢ nfpFamily f 0 ≤ a

Next tactic:
exact nfpFamily_le_fp (fun i => (H i).monotone) (Ordinal.zero_le _) ha
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
    exact this a ((derivFamily_isNormal _).self_le _)
    intro o
    induction' o using limitRecOn with o IH o l IH
    · intro h₁
      refine' ⟨0, le_antisymm _ h₁⟩
      rw [derivFamily_zero]
      exact nfpFamily_le_fp (fun i => (H i).monotone) (Ordinal.zero_le _) ha
    · 

Proof state:
case this.H₂
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
o : Ordinal.{max u v}
IH : a ≤ derivFamily f o → ∃ o, derivFamily f o = a
⊢ a ≤ derivFamily f (succ o) → ∃ o, derivFamily f o = a

Next tactic:
intro h₁
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
    exact this a ((derivFamily_isNormal _).self_le _)
    intro o
    induction' o using limitRecOn with o IH o l IH
    · intro h₁
      refine' ⟨0, le_antisymm _ h₁⟩
      rw [derivFamily_zero]
      exact nfpFamily_le_fp (fun i => (H i).monotone) (Ordinal.zero_le _) ha
    · intro h₁
      

Proof state:
case this.H₂
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
o : Ordinal.{max u v}
IH : a ≤ derivFamily f o → ∃ o, derivFamily f o = a
h₁ : a ≤ derivFamily f (succ o)
⊢ ∃ o, derivFamily f o = a

Next tactic:
rcases le_or_lt a (derivFamily.{u, v} f o) with h | h
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
    exact this a ((derivFamily_isNormal _).self_le _)
    intro o
    induction' o using limitRecOn with o IH o l IH
    · intro h₁
      refine' ⟨0, le_antisymm _ h₁⟩
      rw [derivFamily_zero]
      exact nfpFamily_le_fp (fun i => (H i).monotone) (Ordinal.zero_le _) ha
    · intro h₁
      rcases le_or_lt a (derivFamily.{u, v} f o) with h | h
      · 

Proof state:
case this.H₂.inl
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
o : Ordinal.{max u v}
IH : a ≤ derivFamily f o → ∃ o, derivFamily f o = a
h₁ : a ≤ derivFamily f (succ o)
h : a ≤ derivFamily f o
⊢ ∃ o, derivFamily f o = a

Next tactic:
exact IH h
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
    exact this a ((derivFamily_isNormal _).self_le _)
    intro o
    induction' o using limitRecOn with o IH o l IH
    · intro h₁
      refine' ⟨0, le_antisymm _ h₁⟩
      rw [derivFamily_zero]
      exact nfpFamily_le_fp (fun i => (H i).monotone) (Ordinal.zero_le _) ha
    · intro h₁
      rcases le_or_lt a (derivFamily.{u, v} f o) with h | h
      · exact IH h
      

Proof state:
case this.H₂.inr
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
o : Ordinal.{max u v}
IH : a ≤ derivFamily f o → ∃ o, derivFamily f o = a
h₁ : a ≤ derivFamily f (succ o)
h : derivFamily f o < a
⊢ ∃ o, derivFamily f o = a

Next tactic:
refine' ⟨succ o, le_antisymm _ h₁⟩
theorem le_iff_derivFamily (H : ∀ i, IsNormal (f i)) {a} :
    (∀ i, f i a ≤ a) ↔ ∃ o, derivFamily.{u, v} f o = a :=
  ⟨fun ha => by
    suffices : ∀ (o) (_ : a ≤ derivFamily.{u, v} f o), ∃ o, derivFamily.{u, v} f o = a
    exact this a ((derivFamily_isNormal _).self_le _)
    intro o
    induction' o using limitRecOn with o IH o l IH
    · intro h₁
      refine' ⟨0, le_antisymm _ h₁⟩
      rw [derivFamily_zero]
      exact nfpFamily_le_fp (fun i => (H i).monotone) (Ordinal.zero_le _) ha
    · intro h₁
      rcases le_or_lt a (derivFamily.{u, v} f o) with h | h
      · exact IH h
      refine' ⟨succ o, le_antisymm _ h₁⟩
      

Proof state:
case this.H₂.inr
ι : Type u
f : ι → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : ι), IsNormal (f i)
a : Ordinal.{max u v}
ha : ∀ (i : ι), f i a ≤ a
o : Ordinal.{max u v}
IH : a ≤ derivFamily f o → ∃ o, derivFamily f o = a
h₁ : a ≤ derivFamily f (succ o)
h : derivFamily f o < a
⊢ derivFamily f (succ o) ≤ a

Next tactic:
rw [derivFamily_succ]