l3lab/ntp-mathlib huggingface dataset:
private theorem exists_lt_mul_omega' {o : Ordinal} ⦃a⦄ (h : a < o * ω) :
    ∃ i : ℕ, a < o * ↑i + o := by
  

Proof state:
o a : Ordinal.{u_1}
h : a < o * ω
⊢ ∃ i, a < o * ↑i + o

Next tactic:
obtain ⟨i, hi, h'⟩ := (lt_mul_of_limit omega_isLimit).1 h
private theorem exists_lt_mul_omega' {o : Ordinal} ⦃a⦄ (h : a < o * ω) :
    ∃ i : ℕ, a < o * ↑i + o := by
  obtain ⟨i, hi, h'⟩ := (lt_mul_of_limit omega_isLimit).1 h
  

Proof state:
case intro.intro
o a : Ordinal.{u_1}
h : a < o * ω
i : Ordinal.{u_1}
hi : i < ω
h' : a < o * i
⊢ ∃ i, a < o * ↑i + o

Next tactic:
obtain ⟨i, rfl⟩ := lt_omega.1 hi
private theorem exists_lt_mul_omega' {o : Ordinal} ⦃a⦄ (h : a < o * ω) :
    ∃ i : ℕ, a < o * ↑i + o := by
  obtain ⟨i, hi, h'⟩ := (lt_mul_of_limit omega_isLimit).1 h
  obtain ⟨i, rfl⟩ := lt_omega.1 hi
  

Proof state:
case intro.intro.intro
o a : Ordinal.{u_1}
h : a < o * ω
i : ℕ
hi : ↑i < ω
h' : a < o * ↑i
⊢ ∃ i, a < o * ↑i + o

Next tactic:
exact ⟨i, h'.trans_le (le_add_right _ _)⟩
private theorem exists_lt_omega_opow' {α} {o b : Ordinal} (hb : 1 < b) (ho : o.IsLimit)
    {f : α → Ordinal} (H : ∀ ⦃a⦄, a < o → ∃ i, a < f i) ⦃a⦄ (h : a < b ^ o) :
        ∃ i, a < b ^ f i := by
  

Proof state:
α : Sort u_1
o b : Ordinal.{u_2}
hb : 1 < b
ho : IsLimit o
f : α → Ordinal.{u_2}
H : ∀ ⦃a : Ordinal.{u_2}⦄, a < o → ∃ i, a < f i
a : Ordinal.{u_2}
h : a < b ^ o
⊢ ∃ i, a < b ^ f i

Next tactic:
obtain ⟨d, hd, h'⟩ := (lt_opow_of_limit (zero_lt_one.trans hb).ne' ho).1 h
private theorem exists_lt_omega_opow' {α} {o b : Ordinal} (hb : 1 < b) (ho : o.IsLimit)
    {f : α → Ordinal} (H : ∀ ⦃a⦄, a < o → ∃ i, a < f i) ⦃a⦄ (h : a < b ^ o) :
        ∃ i, a < b ^ f i := by
  obtain ⟨d, hd, h'⟩ := (lt_opow_of_limit (zero_lt_one.trans hb).ne' ho).1 h
  

Proof state:
case intro.intro
α : Sort u_1
o b : Ordinal.{u_2}
hb : 1 < b
ho : IsLimit o
f : α → Ordinal.{u_2}
H : ∀ ⦃a : Ordinal.{u_2}⦄, a < o → ∃ i, a < f i
a : Ordinal.{u_2}
h : a < b ^ o
d : Ordinal.{u_2}
hd : d < o
h' : a < b ^ d
⊢ ∃ i, a < b ^ f i

Next tactic:
exact (H hd).imp fun i hi => h'.trans <| (opow_lt_opow_iff_right hb).2 hi
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  

Proof state:
o : ONote
⊢ FundamentalSequenceProp o (fundamentalSequence o)

Next tactic:
induction' o with a m b iha ihb
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · 

Proof state:
case zero
⊢ FundamentalSequenceProp zero (fundamentalSequence zero)

Next tactic:
exact rfl
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  

Proof state:
case oadd
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : FundamentalSequenceProp b (fundamentalSequence b)
⊢ FundamentalSequenceProp (oadd a m b) (fundamentalSequence (oadd a m b))

Next tactic:
rw [fundamentalSequence]
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  

Proof state:
case oadd
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : FundamentalSequenceProp b (fundamentalSequence b)
⊢ FundamentalSequenceProp (oadd a m b)
    (match fundamentalSequence b with
    | Sum.inr f => Sum.inr fun i => oadd a m (f i)
    | Sum.inl (some b') => Sum.inl (some (oadd a m b'))
    | Sum.inl none =>
      match fundamentalSequence a, PNat.natPred m with
      | Sum.inl none, 0 => Sum.inl (some zero)
      | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
      | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
      | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
      | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
      | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f)
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    

Proof state:
case oadd.inl.none
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : FundamentalSequenceProp b (fundamentalSequence b)
e : fundamentalSequence b = Sum.inl none
⊢ FundamentalSequenceProp (oadd a m b)
    (match Sum.inl none with
    | Sum.inr f => Sum.inr fun i => oadd a m (f i)
    | Sum.inl (some b') => Sum.inl (some (oadd a m b'))
    | Sum.inl none =>
      match fundamentalSequence a, PNat.natPred m with
      | Sum.inl none, 0 => Sum.inl (some zero)
      | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
      | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
      | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
      | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
      | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
simp only [FundamentalSequenceProp]
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    

Proof state:
case oadd.inl.some
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : FundamentalSequenceProp b (fundamentalSequence b)
b' : ONote
e : fundamentalSequence b = Sum.inl (some b')
⊢ FundamentalSequenceProp (oadd a m b)
    (match Sum.inl (some b') with
    | Sum.inr f => Sum.inr fun i => oadd a m (f i)
    | Sum.inl (some b') => Sum.inl (some (oadd a m b'))
    | Sum.inl none =>
      match fundamentalSequence a, PNat.natPred m with
      | Sum.inl none, 0 => Sum.inl (some zero)
      | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
      | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
      | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
      | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
      | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
simp only [FundamentalSequenceProp]
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    

Proof state:
case oadd.inr
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : FundamentalSequenceProp b (fundamentalSequence b)
f : ℕ → ONote
e : fundamentalSequence b = Sum.inr f
⊢ FundamentalSequenceProp (oadd a m b)
    (match Sum.inr f with
    | Sum.inr f => Sum.inr fun i => oadd a m (f i)
    | Sum.inl (some b') => Sum.inl (some (oadd a m b'))
    | Sum.inl none =>
      match fundamentalSequence a, PNat.natPred m with
      | Sum.inl none, 0 => Sum.inl (some zero)
      | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
      | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
      | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
      | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
      | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
simp only [FundamentalSequenceProp]
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    

Proof state:
case oadd.inl.none
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : FundamentalSequenceProp b (fundamentalSequence b)
e : fundamentalSequence b = Sum.inl none
⊢ FundamentalSequenceProp (oadd a m b)
    (match fundamentalSequence a, PNat.natPred m with
    | Sum.inl none, 0 => Sum.inl (some zero)
    | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
    | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
    | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
    | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
    | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
rw [e, FundamentalSequenceProp] at ihb
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    

Proof state:
case oadd.inl.some
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : FundamentalSequenceProp b (fundamentalSequence b)
b' : ONote
e : fundamentalSequence b = Sum.inl (some b')
⊢ repr (oadd a m b) = succ (repr (oadd a m b')) ∧ (NF (oadd a m b) → NF (oadd a m b'))

Next tactic:
rw [e, FundamentalSequenceProp] at ihb
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    

Proof state:
case oadd.inr
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : FundamentalSequenceProp b (fundamentalSequence b)
f : ℕ → ONote
e : fundamentalSequence b = Sum.inr f
⊢ IsLimit (repr (oadd a m b)) ∧
    (∀ (i : ℕ),
        oadd a m (f i) < oadd a m (f (i + 1)) ∧ oadd a m (f i) < oadd a m b ∧ (NF (oadd a m b) → NF (oadd a m (f i)))) ∧
      ∀ a_1 < repr (oadd a m b), ∃ i, a_1 < repr (oadd a m (f i))

Next tactic:
rw [e, FundamentalSequenceProp] at ihb
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    rw [e, FundamentalSequenceProp] at ihb
  · 

Proof state:
case oadd.inl.none
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : b = 0
e : fundamentalSequence b = Sum.inl none
⊢ FundamentalSequenceProp (oadd a m b)
    (match fundamentalSequence a, PNat.natPred m with
    | Sum.inl none, 0 => Sum.inl (some zero)
    | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
    | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
    | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
    | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
    | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
rcases e : a.fundamentalSequence with (⟨_ | a'⟩ | f)
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    rw [e, FundamentalSequenceProp] at ihb
  · rcases e : a.fundamentalSequence with (⟨_ | a'⟩ | f) <;> 

Proof state:
case oadd.inl.none.inl.none
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
e : fundamentalSequence a = Sum.inl none
⊢ FundamentalSequenceProp (oadd a m b)
    (match Sum.inl none, PNat.natPred m with
    | Sum.inl none, 0 => Sum.inl (some zero)
    | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
    | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
    | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
    | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
    | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
cases' e' : m.natPred with m'
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    rw [e, FundamentalSequenceProp] at ihb
  · rcases e : a.fundamentalSequence with (⟨_ | a'⟩ | f) <;> 

Proof state:
case oadd.inl.none.inl.some
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
a' : ONote
e : fundamentalSequence a = Sum.inl (some a')
⊢ FundamentalSequenceProp (oadd a m b)
    (match Sum.inl (some a'), PNat.natPred m with
    | Sum.inl none, 0 => Sum.inl (some zero)
    | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
    | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
    | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
    | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
    | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
cases' e' : m.natPred with m'
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    rw [e, FundamentalSequenceProp] at ihb
  · rcases e : a.fundamentalSequence with (⟨_ | a'⟩ | f) <;> 

Proof state:
case oadd.inl.none.inr
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
f : ℕ → ONote
e : fundamentalSequence a = Sum.inr f
⊢ FundamentalSequenceProp (oadd a m b)
    (match Sum.inr f, PNat.natPred m with
    | Sum.inl none, 0 => Sum.inl (some zero)
    | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
    | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
    | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
    | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
    | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
cases' e' : m.natPred with m'
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    rw [e, FundamentalSequenceProp] at ihb
  · rcases e : a.fundamentalSequence with (⟨_ | a'⟩ | f) <;> cases' e' : m.natPred with m' <;>
      

Proof state:
case oadd.inl.none.inl.none.zero
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
e : fundamentalSequence a = Sum.inl none
e' : PNat.natPred m = Nat.zero
⊢ FundamentalSequenceProp (oadd a m b)
    (match Sum.inl none, Nat.zero with
    | Sum.inl none, 0 => Sum.inl (some zero)
    | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
    | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
    | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
    | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
    | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
simp only [FundamentalSequenceProp]
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    rw [e, FundamentalSequenceProp] at ihb
  · rcases e : a.fundamentalSequence with (⟨_ | a'⟩ | f) <;> cases' e' : m.natPred with m' <;>
      

Proof state:
case oadd.inl.none.inl.none.succ
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
e : fundamentalSequence a = Sum.inl none
m' : ℕ
e' : PNat.natPred m = Nat.succ m'
⊢ FundamentalSequenceProp (oadd a m b)
    (match Sum.inl none, Nat.succ m' with
    | Sum.inl none, 0 => Sum.inl (some zero)
    | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
    | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
    | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
    | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
    | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
simp only [FundamentalSequenceProp]
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    rw [e, FundamentalSequenceProp] at ihb
  · rcases e : a.fundamentalSequence with (⟨_ | a'⟩ | f) <;> cases' e' : m.natPred with m' <;>
      

Proof state:
case oadd.inl.none.inl.some.zero
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
a' : ONote
e : fundamentalSequence a = Sum.inl (some a')
e' : PNat.natPred m = Nat.zero
⊢ FundamentalSequenceProp (oadd a m b)
    (match Sum.inl (some a'), Nat.zero with
    | Sum.inl none, 0 => Sum.inl (some zero)
    | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
    | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
    | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
    | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
    | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
simp only [FundamentalSequenceProp]
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    rw [e, FundamentalSequenceProp] at ihb
  · rcases e : a.fundamentalSequence with (⟨_ | a'⟩ | f) <;> cases' e' : m.natPred with m' <;>
      

Proof state:
case oadd.inl.none.inl.some.succ
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
a' : ONote
e : fundamentalSequence a = Sum.inl (some a')
m' : ℕ
e' : PNat.natPred m = Nat.succ m'
⊢ FundamentalSequenceProp (oadd a m b)
    (match Sum.inl (some a'), Nat.succ m' with
    | Sum.inl none, 0 => Sum.inl (some zero)
    | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
    | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
    | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
    | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
    | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
simp only [FundamentalSequenceProp]
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    rw [e, FundamentalSequenceProp] at ihb
  · rcases e : a.fundamentalSequence with (⟨_ | a'⟩ | f) <;> cases' e' : m.natPred with m' <;>
      

Proof state:
case oadd.inl.none.inr.zero
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
f : ℕ → ONote
e : fundamentalSequence a = Sum.inr f
e' : PNat.natPred m = Nat.zero
⊢ FundamentalSequenceProp (oadd a m b)
    (match Sum.inr f, Nat.zero with
    | Sum.inl none, 0 => Sum.inl (some zero)
    | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
    | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
    | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
    | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
    | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
simp only [FundamentalSequenceProp]
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    rw [e, FundamentalSequenceProp] at ihb
  · rcases e : a.fundamentalSequence with (⟨_ | a'⟩ | f) <;> cases' e' : m.natPred with m' <;>
      

Proof state:
case oadd.inl.none.inr.succ
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
f : ℕ → ONote
e : fundamentalSequence a = Sum.inr f
m' : ℕ
e' : PNat.natPred m = Nat.succ m'
⊢ FundamentalSequenceProp (oadd a m b)
    (match Sum.inr f, Nat.succ m' with
    | Sum.inl none, 0 => Sum.inl (some zero)
    | Sum.inl none, Nat.succ m => Sum.inl (some (oadd zero (Nat.succPNat m) zero))
    | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' (Nat.succPNat i) zero
    | Sum.inl (some a'), Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd a' (Nat.succPNat i) zero)
    | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero
    | Sum.inr f, Nat.succ m => Sum.inr fun i => oadd a (Nat.succPNat m) (oadd (f i) 1 zero))

Next tactic:
simp only [FundamentalSequenceProp]
theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o) := by
  induction' o with a m b iha ihb; · exact rfl
  rw [fundamentalSequence]
  rcases e : b.fundamentalSequence with (⟨_ | b'⟩ | f) <;>
    simp only [FundamentalSequenceProp] <;>
    rw [e, FundamentalSequenceProp] at ihb
  · rcases e : a.fundamentalSequence with (⟨_ | a'⟩ | f) <;> cases' e' : m.natPred with m' <;>
      simp only [FundamentalSequenceProp] <;>
      

Proof state:
case oadd.inl.none.inl.none.zero
a : ONote
m : ℕ+
b : ONote
iha : FundamentalSequenceProp a (fundamentalSequence a)
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
e : fundamentalSequence a = Sum.inl none
e' : PNat.natPred m = Nat.zero
⊢ repr (oadd a m b) = succ (repr zero) ∧ (NF (oadd a m b) → NF zero)

Next tactic:
rw [e, FundamentalSequenceProp] at iha