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] <;>
      

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'
⊢ repr (oadd a m b) = succ (repr (oadd zero (Nat.succPNat m') zero)) ∧
    (NF (oadd a m b) → NF (oadd zero (Nat.succPNat m') zero))

Next tactic:
rw [e, FundamentalSequenceProp] at iha
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.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
⊢ IsLimit (repr (oadd a m b)) ∧
    (∀ (i : ℕ),
        oadd a' (Nat.succPNat i) zero < oadd a' (Nat.succPNat (i + 1)) zero ∧
          oadd a' (Nat.succPNat i) zero < oadd a m b ∧ (NF (oadd a m b) → NF (oadd a' (Nat.succPNat i) zero))) ∧
      ∀ a_1 < repr (oadd a m b), ∃ i, a_1 < repr (oadd a' (Nat.succPNat i) zero)

Next tactic:
rw [e, FundamentalSequenceProp] at iha
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.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'
⊢ IsLimit (repr (oadd a 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 m b ∧
            (NF (oadd a m b) → NF (oadd a (Nat.succPNat m') (oadd a' (Nat.succPNat i) zero)))) ∧
      ∀ a_1 < repr (oadd a m b), ∃ i, a_1 < repr (oadd a (Nat.succPNat m') (oadd a' (Nat.succPNat i) zero))

Next tactic:
rw [e, FundamentalSequenceProp] at iha
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.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
⊢ IsLimit (repr (oadd a m b)) ∧
    (∀ (i : ℕ),
        oadd (f i) 1 zero < oadd (f (i + 1)) 1 zero ∧
          oadd (f i) 1 zero < oadd a m b ∧ (NF (oadd a m b) → NF (oadd (f i) 1 zero))) ∧
      ∀ a_1 < repr (oadd a m b), ∃ i, a_1 < repr (oadd (f i) 1 zero)

Next tactic:
rw [e, FundamentalSequenceProp] at iha
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.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'
⊢ 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 [e, FundamentalSequenceProp] at iha
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 <;>
      (

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 m b) = succ (repr zero) ∧ (NF (oadd a m b) → NF zero)

Next tactic:
try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]
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 

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 m b) = succ (repr zero) ∧ (NF (oadd a m b) → NF zero)

Next tactic:
rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]
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
            

Proof state:
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
⊢ m = 1

Next tactic:
have := PNat.natPred_add_one 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' <;>
      simp only [FundamentalSequenceProp] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; 

Proof state:
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
this : PNat.natPred m + 1 = ↑m
⊢ m = 1

Next tactic:
rw [e'] at this
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; 

Proof state:
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
this : Nat.zero + 1 = ↑m
⊢ m = 1

Next tactic:
exact PNat.coe_inj.1 this.symm
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 <;>
      (

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 m b) = succ (repr (oadd zero (Nat.succPNat m') zero)) ∧
    (NF (oadd a m b) → NF (oadd zero (Nat.succPNat m') zero))

Next tactic:
try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]
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 

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 m b) = succ (repr (oadd zero (Nat.succPNat m') zero)) ∧
    (NF (oadd a m b) → NF (oadd zero (Nat.succPNat m') zero))

Next tactic:
rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]
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
            

Proof state:
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'
⊢ m = 1

Next tactic:
have := PNat.natPred_add_one 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' <;>
      simp only [FundamentalSequenceProp] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; 

Proof state:
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'
this : PNat.natPred m + 1 = ↑m
⊢ m = 1

Next tactic:
rw [e'] at this
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; 

Proof state:
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'
this : Nat.succ m' + 1 = ↑m
⊢ m = 1

Next tactic:
exact PNat.coe_inj.1 this.symm
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 <;>
      (

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 m b)) ∧
    (∀ (i : ℕ),
        oadd a' (Nat.succPNat i) zero < oadd a' (Nat.succPNat (i + 1)) zero ∧
          oadd a' (Nat.succPNat i) zero < oadd a m b ∧ (NF (oadd a m b) → NF (oadd a' (Nat.succPNat i) zero))) ∧
      ∀ a_1 < repr (oadd a m b), ∃ i, a_1 < repr (oadd a' (Nat.succPNat i) zero)

Next tactic:
try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]
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 

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 m b)) ∧
    (∀ (i : ℕ),
        oadd a' (Nat.succPNat i) zero < oadd a' (Nat.succPNat (i + 1)) zero ∧
          oadd a' (Nat.succPNat i) zero < oadd a m b ∧ (NF (oadd a m b) → NF (oadd a' (Nat.succPNat i) zero))) ∧
      ∀ a_1 < repr (oadd a m b), ∃ i, a_1 < repr (oadd a' (Nat.succPNat i) zero)

Next tactic:
rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]
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
            

Proof state:
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
⊢ m = 1

Next tactic:
have := PNat.natPred_add_one 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' <;>
      simp only [FundamentalSequenceProp] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; 

Proof state:
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 : PNat.natPred m + 1 = ↑m
⊢ m = 1

Next tactic:
rw [e'] at this
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; 

Proof state:
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 : Nat.zero + 1 = ↑m
⊢ m = 1

Next tactic:
exact PNat.coe_inj.1 this.symm
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 <;>
      (

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 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 m b ∧
            (NF (oadd a m b) → NF (oadd a (Nat.succPNat m') (oadd a' (Nat.succPNat i) zero)))) ∧
      ∀ a_1 < repr (oadd a m b), ∃ i, a_1 < repr (oadd a (Nat.succPNat m') (oadd a' (Nat.succPNat i) zero))

Next tactic:
try rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]
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 

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 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 m b ∧
            (NF (oadd a m b) → NF (oadd a (Nat.succPNat m') (oadd a' (Nat.succPNat i) zero)))) ∧
      ∀ a_1 < repr (oadd a m b), ∃ i, a_1 < repr (oadd a (Nat.succPNat m') (oadd a' (Nat.succPNat i) zero))

Next tactic:
rw [show m = 1 by
            have := PNat.natPred_add_one m; rw [e'] at this; exact PNat.coe_inj.1 this.symm]
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
            

Proof state:
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'
⊢ m = 1

Next tactic:
have := PNat.natPred_add_one 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' <;>
      simp only [FundamentalSequenceProp] <;>
      rw [e, FundamentalSequenceProp] at iha <;>
      (try rw [show m = 1 by
            have := PNat.natPred_add_one m; 

Proof state:
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'
this : PNat.natPred m + 1 = ↑m
⊢ m = 1

Next tactic:
rw [e'] at this