l3lab/ntp-mathlib huggingface dataset:
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (

Proof state:
case oadd.inl.none.inr.zero
a : ONote
m : ℕ+
b : ONote
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
f : ℕ → ONote
iha :
  IsLimit (repr a) ∧ (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (NF a → NF (f i))) ∧ ∀ a_1 < repr a, ∃ i, a_1 < repr (f i)
e : fundamentalSequence a = Sum.inr f
e' : PNat.natPred m = Nat.zero
⊢ IsLimit (repr (oadd a 1 b)) ∧
    (∀ (i : ℕ),
        oadd (f i) 1 zero < oadd (f (i + 1)) 1 zero ∧
          oadd (f i) 1 zero < oadd a 1 b ∧ (NF (oadd a 1 b) → NF (oadd (f i) 1 zero))) ∧
      ∀ a_1 < repr (oadd a 1 b), ∃ i, a_1 < repr (oadd (f i) 1 zero)

Next tactic:
try rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try 

Proof state:
case oadd.inl.none.inr.zero
a : ONote
m : ℕ+
b : ONote
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
f : ℕ → ONote
iha :
  IsLimit (repr a) ∧ (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (NF a → NF (f i))) ∧ ∀ a_1 < repr a, ∃ i, a_1 < repr (f i)
e : fundamentalSequence a = Sum.inr f
e' : PNat.natPred m = Nat.zero
⊢ IsLimit (repr (oadd a 1 b)) ∧
    (∀ (i : ℕ),
        oadd (f i) 1 zero < oadd (f (i + 1)) 1 zero ∧
          oadd (f i) 1 zero < oadd a 1 b ∧ (NF (oadd a 1 b) → NF (oadd (f i) 1 zero))) ∧
      ∀ a_1 < repr (oadd a 1 b), ∃ i, a_1 < repr (oadd (f i) 1 zero)

Next tactic:
rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (

Proof state:
case oadd.inl.none.inr.succ
a : ONote
m : ℕ+
b : ONote
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
f : ℕ → ONote
iha :
  IsLimit (repr a) ∧ (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (NF a → NF (f i))) ∧ ∀ a_1 < repr a, ∃ i, a_1 < repr (f i)
e : fundamentalSequence a = Sum.inr f
m' : ℕ
e' : PNat.natPred m = Nat.succ m'
⊢ IsLimit (repr (oadd a m b)) ∧
    (∀ (i : ℕ),
        oadd a (Nat.succPNat m') (oadd (f i) 1 zero) < oadd a (Nat.succPNat m') (oadd (f (i + 1)) 1 zero) ∧
          oadd a (Nat.succPNat m') (oadd (f i) 1 zero) < oadd a m b ∧
            (NF (oadd a m b) → NF (oadd a (Nat.succPNat m') (oadd (f i) 1 zero)))) ∧
      ∀ a_1 < repr (oadd a m b), ∃ i, a_1 < repr (oadd a (Nat.succPNat m') (oadd (f i) 1 zero))

Next tactic:
try rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try 

Proof state:
case oadd.inl.none.inr.succ
a : ONote
m : ℕ+
b : ONote
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
f : ℕ → ONote
iha :
  IsLimit (repr a) ∧ (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (NF a → NF (f i))) ∧ ∀ a_1 < repr a, ∃ i, a_1 < repr (f i)
e : fundamentalSequence a = Sum.inr f
m' : ℕ
e' : PNat.natPred m = Nat.succ m'
⊢ IsLimit (repr (oadd a m b)) ∧
    (∀ (i : ℕ),
        oadd a (Nat.succPNat m') (oadd (f i) 1 zero) < oadd a (Nat.succPNat m') (oadd (f (i + 1)) 1 zero) ∧
          oadd a (Nat.succPNat m') (oadd (f i) 1 zero) < oadd a m b ∧
            (NF (oadd a m b) → NF (oadd a (Nat.succPNat m') (oadd (f i) 1 zero)))) ∧
      ∀ a_1 < repr (oadd a m b), ∃ i, a_1 < repr (oadd a (Nat.succPNat m') (oadd (f i) 1 zero))

Next tactic:
rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try rw [show m = m'.succ.succPNat by
              

Proof state:
a : ONote
m : ℕ+
b : ONote
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
f : ℕ → ONote
iha :
  IsLimit (repr a) ∧ (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (NF a → NF (f i))) ∧ ∀ a_1 < repr a, ∃ i, a_1 < repr (f i)
e : fundamentalSequence a = Sum.inr f
m' : ℕ
e' : PNat.natPred m = Nat.succ m'
⊢ m = Nat.succPNat (Nat.succ m')

Next tactic:
rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]) <;>
      

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

Next tactic:
simp only [repr, iha, ihb, opow_lt_opow_iff_right one_lt_omega, add_lt_add_iff_left, add_zero,
        eq_self_iff_true, lt_add_iff_pos_right, lt_def, mul_one, Nat.cast_zero, Nat.cast_succ,
        Nat.succPNat_coe, opow_succ, opow_zero, mul_add_one, PNat.one_coe, succ_zero,
        true_and_iff, _root_.zero_add, zero_def]
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]) <;>
      

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

Next tactic:
simp only [repr, iha, ihb, opow_lt_opow_iff_right one_lt_omega, add_lt_add_iff_left, add_zero,
        eq_self_iff_true, lt_add_iff_pos_right, lt_def, mul_one, Nat.cast_zero, Nat.cast_succ,
        Nat.succPNat_coe, opow_succ, opow_zero, mul_add_one, PNat.one_coe, succ_zero,
        true_and_iff, _root_.zero_add, zero_def]
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]) <;>
      

Proof state:
case oadd.inl.none.inl.some.zero
a : ONote
m : ℕ+
b : ONote
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
a' : ONote
iha : repr a = succ (repr a') ∧ (NF a → NF a')
e : fundamentalSequence a = Sum.inl (some a')
e' : PNat.natPred m = Nat.zero
⊢ IsLimit (repr (oadd a 1 b)) ∧
    (∀ (i : ℕ),
        oadd a' (Nat.succPNat i) zero < oadd a' (Nat.succPNat (i + 1)) zero ∧
          oadd a' (Nat.succPNat i) zero < oadd a 1 b ∧ (NF (oadd a 1 b) → NF (oadd a' (Nat.succPNat i) zero))) ∧
      ∀ a_1 < repr (oadd a 1 b), ∃ i, a_1 < repr (oadd a' (Nat.succPNat i) zero)

Next tactic:
simp only [repr, iha, ihb, opow_lt_opow_iff_right one_lt_omega, add_lt_add_iff_left, add_zero,
        eq_self_iff_true, lt_add_iff_pos_right, lt_def, mul_one, Nat.cast_zero, Nat.cast_succ,
        Nat.succPNat_coe, opow_succ, opow_zero, mul_add_one, PNat.one_coe, succ_zero,
        true_and_iff, _root_.zero_add, zero_def]
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]) <;>
      

Proof state:
case oadd.inl.none.inl.some.succ
a : ONote
m : ℕ+
b : ONote
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
a' : ONote
iha : repr a = succ (repr a') ∧ (NF a → NF a')
e : fundamentalSequence a = Sum.inl (some a')
m' : ℕ
e' : PNat.natPred m = Nat.succ m'
⊢ IsLimit (repr (oadd a (Nat.succPNat (Nat.succ m')) b)) ∧
    (∀ (i : ℕ),
        oadd a (Nat.succPNat m') (oadd a' (Nat.succPNat i) zero) <
            oadd a (Nat.succPNat m') (oadd a' (Nat.succPNat (i + 1)) zero) ∧
          oadd a (Nat.succPNat m') (oadd a' (Nat.succPNat i) zero) < oadd a (Nat.succPNat (Nat.succ m')) b ∧
            (NF (oadd a (Nat.succPNat (Nat.succ m')) b) →
              NF (oadd a (Nat.succPNat m') (oadd a' (Nat.succPNat i) zero)))) ∧
      ∀ a_1 < repr (oadd a (Nat.succPNat (Nat.succ m')) b),
        ∃ i, a_1 < repr (oadd a (Nat.succPNat m') (oadd a' (Nat.succPNat i) zero))

Next tactic:
simp only [repr, iha, ihb, opow_lt_opow_iff_right one_lt_omega, add_lt_add_iff_left, add_zero,
        eq_self_iff_true, lt_add_iff_pos_right, lt_def, mul_one, Nat.cast_zero, Nat.cast_succ,
        Nat.succPNat_coe, opow_succ, opow_zero, mul_add_one, PNat.one_coe, succ_zero,
        true_and_iff, _root_.zero_add, zero_def]
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]) <;>
      

Proof state:
case oadd.inl.none.inr.zero
a : ONote
m : ℕ+
b : ONote
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
f : ℕ → ONote
iha :
  IsLimit (repr a) ∧ (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (NF a → NF (f i))) ∧ ∀ a_1 < repr a, ∃ i, a_1 < repr (f i)
e : fundamentalSequence a = Sum.inr f
e' : PNat.natPred m = Nat.zero
⊢ IsLimit (repr (oadd a 1 b)) ∧
    (∀ (i : ℕ),
        oadd (f i) 1 zero < oadd (f (i + 1)) 1 zero ∧
          oadd (f i) 1 zero < oadd a 1 b ∧ (NF (oadd a 1 b) → NF (oadd (f i) 1 zero))) ∧
      ∀ a_1 < repr (oadd a 1 b), ∃ i, a_1 < repr (oadd (f i) 1 zero)

Next tactic:
simp only [repr, iha, ihb, opow_lt_opow_iff_right one_lt_omega, add_lt_add_iff_left, add_zero,
        eq_self_iff_true, lt_add_iff_pos_right, lt_def, mul_one, Nat.cast_zero, Nat.cast_succ,
        Nat.succPNat_coe, opow_succ, opow_zero, mul_add_one, PNat.one_coe, succ_zero,
        true_and_iff, _root_.zero_add, zero_def]
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]) <;>
      

Proof state:
case oadd.inl.none.inr.succ
a : ONote
m : ℕ+
b : ONote
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
f : ℕ → ONote
iha :
  IsLimit (repr a) ∧ (∀ (i : ℕ), f i < f (i + 1) ∧ f i < a ∧ (NF a → NF (f i))) ∧ ∀ a_1 < repr a, ∃ i, a_1 < repr (f i)
e : fundamentalSequence a = Sum.inr f
m' : ℕ
e' : PNat.natPred m = Nat.succ m'
⊢ IsLimit (repr (oadd a (Nat.succPNat (Nat.succ m')) b)) ∧
    (∀ (i : ℕ),
        oadd a (Nat.succPNat m') (oadd (f i) 1 zero) < oadd a (Nat.succPNat m') (oadd (f (i + 1)) 1 zero) ∧
          oadd a (Nat.succPNat m') (oadd (f i) 1 zero) < oadd a (Nat.succPNat (Nat.succ m')) b ∧
            (NF (oadd a (Nat.succPNat (Nat.succ m')) b) → NF (oadd a (Nat.succPNat m') (oadd (f i) 1 zero)))) ∧
      ∀ a_1 < repr (oadd a (Nat.succPNat (Nat.succ m')) b),
        ∃ i, a_1 < repr (oadd a (Nat.succPNat m') (oadd (f i) 1 zero))

Next tactic:
simp only [repr, iha, ihb, opow_lt_opow_iff_right one_lt_omega, add_lt_add_iff_left, add_zero,
        eq_self_iff_true, lt_add_iff_pos_right, lt_def, mul_one, Nat.cast_zero, Nat.cast_succ,
        Nat.succPNat_coe, opow_succ, opow_zero, mul_add_one, PNat.one_coe, succ_zero,
        true_and_iff, _root_.zero_add, zero_def]
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]) <;>
      simp only [repr, iha, ihb, opow_lt_opow_iff_right one_lt_omega, add_lt_add_iff_left, add_zero,
        eq_self_iff_true, lt_add_iff_pos_right, lt_def, mul_one, Nat.cast_zero, Nat.cast_succ,
        Nat.succPNat_coe, opow_succ, opow_zero, mul_add_one, PNat.one_coe, succ_zero,
        true_and_iff, _root_.zero_add, zero_def]
    · 

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

Next tactic:
decide
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]) <;>
      simp only [repr, iha, ihb, opow_lt_opow_iff_right one_lt_omega, add_lt_add_iff_left, add_zero,
        eq_self_iff_true, lt_add_iff_pos_right, lt_def, mul_one, Nat.cast_zero, Nat.cast_succ,
        Nat.succPNat_coe, opow_succ, opow_zero, mul_add_one, PNat.one_coe, succ_zero,
        true_and_iff, _root_.zero_add, zero_def]
    · decide
    · 

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

Next tactic:
exact ⟨rfl, inferInstance⟩
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]) <;>
      simp only [repr, iha, ihb, opow_lt_opow_iff_right one_lt_omega, add_lt_add_iff_left, add_zero,
        eq_self_iff_true, lt_add_iff_pos_right, lt_def, mul_one, Nat.cast_zero, Nat.cast_succ,
        Nat.succPNat_coe, opow_succ, opow_zero, mul_add_one, PNat.one_coe, succ_zero,
        true_and_iff, _root_.zero_add, zero_def]
    · decide
    · exact ⟨rfl, inferInstance⟩
    · 

Proof state:
case oadd.inl.none.inl.some.zero
a : ONote
m : ℕ+
b : ONote
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
a' : ONote
iha : repr a = succ (repr a') ∧ (NF a → NF a')
e : fundamentalSequence a = Sum.inl (some a')
e' : PNat.natPred m = Nat.zero
⊢ IsLimit (ω ^ repr a' * ω) ∧
    (∀ (i : ℕ),
        0 < ω ^ repr a' ∧
          ω ^ repr a' * ↑i + ω ^ repr a' < ω ^ repr a' * ω ∧ (NF (oadd a 1 0) → NF (oadd a' (Nat.succPNat i) 0))) ∧
      ∀ a < ω ^ repr a' * ω, ∃ i, a < ω ^ repr a' * ↑i + ω ^ repr a'

Next tactic:
have := opow_pos (repr a') omega_pos
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] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]) <;>
      (try rw [show m = m'.succ.succPNat by
              rw [← e', ← PNat.coe_inj, Nat.succPNat_coe, ← Nat.add_one, PNat.natPred_add_one]]) <;>
      simp only [repr, iha, ihb, opow_lt_opow_iff_right one_lt_omega, add_lt_add_iff_left, add_zero,
        eq_self_iff_true, lt_add_iff_pos_right, lt_def, mul_one, Nat.cast_zero, Nat.cast_succ,
        Nat.succPNat_coe, opow_succ, opow_zero, mul_add_one, PNat.one_coe, succ_zero,
        true_and_iff, _root_.zero_add, zero_def]
    · decide
    · exact ⟨rfl, inferInstance⟩
    · have := opow_pos (repr a') omega_pos
      

Proof state:
case oadd.inl.none.inl.some.zero
a : ONote
m : ℕ+
b : ONote
ihb : b = 0
e✝ : fundamentalSequence b = Sum.inl none
a' : ONote
iha : repr a = succ (repr a') ∧ (NF a → NF a')
e : fundamentalSequence a = Sum.inl (some a')
e' : PNat.natPred m = Nat.zero
this : 0 < ω ^ repr a'
⊢ IsLimit (ω ^ repr a' * ω) ∧
    (∀ (i : ℕ),
        0 < ω ^ repr a' ∧
          ω ^ repr a' * ↑i + ω ^ repr a' < ω ^ repr a' * ω ∧ (NF (oadd a 1 0) → NF (oadd a' (Nat.succPNat i) 0))) ∧
      ∀ a < ω ^ repr a' * ω, ∃ i, a < ω ^ repr a' * ↑i + ω ^ repr a'

Next tactic:
refine'
        ⟨mul_isLimit this omega_isLimit, fun i =>
          ⟨this, _, fun H => @NF.oadd_zero _ _ (iha.2 H.fst)⟩, exists_lt_mul_omega'⟩