l3lab/ntp-mathlib huggingface dataset:
instance uniquePowHalfLeftMoves (n) : Unique (powHalf n).LeftMoves := by
  cases n <;> 

Proof state:
case succ
n✝ : ℕ
⊢ Unique (LeftMoves (powHalf (Nat.succ n✝)))

Next tactic:
exact PUnit.unique
@[simp]
theorem birthday_half : birthday (powHalf 1) = 2 := by
  

Proof state:
⊢ birthday (powHalf 1) = 2

Next tactic:
rw [birthday_def]
@[simp]
theorem birthday_half : birthday (powHalf 1) = 2 := by
  rw [birthday_def]; 

Proof state:
⊢ max (Ordinal.lsub fun i => birthday (moveLeft (powHalf 1) i))
      (Ordinal.lsub fun i => birthday (moveRight (powHalf 1) i)) =
    2

Next tactic:
dsimp
@[simp]
theorem birthday_half : birthday (powHalf 1) = 2 := by
  rw [birthday_def]; dsimp; 

Proof state:
⊢ max (Ordinal.lsub fun i => birthday (moveLeft (powHalf 1) i)) (Ordinal.lsub fun i => birthday 1) = 2

Next tactic:
simpa using Order.le_succ (1 : Ordinal)
/-- For all natural numbers `n`, the pre-games `powHalf n` are numeric. -/
theorem numeric_powHalf (n) : (powHalf n).Numeric := by
  

Proof state:
n : ℕ
⊢ Numeric (powHalf n)

Next tactic:
induction' n with n hn
/-- For all natural numbers `n`, the pre-games `powHalf n` are numeric. -/
theorem numeric_powHalf (n) : (powHalf n).Numeric := by
  induction' n with n hn
  · 

Proof state:
case zero
⊢ Numeric (powHalf Nat.zero)

Next tactic:
exact numeric_one
/-- For all natural numbers `n`, the pre-games `powHalf n` are numeric. -/
theorem numeric_powHalf (n) : (powHalf n).Numeric := by
  induction' n with n hn
  · exact numeric_one
  · 

Proof state:
case succ
n : ℕ
hn : Numeric (powHalf n)
⊢ Numeric (powHalf (Nat.succ n))

Next tactic:
constructor
/-- For all natural numbers `n`, the pre-games `powHalf n` are numeric. -/
theorem numeric_powHalf (n) : (powHalf n).Numeric := by
  induction' n with n hn
  · exact numeric_one
  · constructor
    · 

Proof state:
case succ.left
n : ℕ
hn : Numeric (powHalf n)
⊢ ∀ (i j : PUnit.{u_1 + 1}), OfNat.ofNat 0 i < (fun x => powHalf n) j

Next tactic:
simpa using hn.moveLeft_lt default
/-- For all natural numbers `n`, the pre-games `powHalf n` are numeric. -/
theorem numeric_powHalf (n) : (powHalf n).Numeric := by
  induction' n with n hn
  · exact numeric_one
  · constructor
    · simpa using hn.moveLeft_lt default
    · 

Proof state:
case succ.right
n : ℕ
hn : Numeric (powHalf n)
⊢ (∀ (i : PUnit.{u_1 + 1}), Numeric (OfNat.ofNat 0 i)) ∧ ∀ (j : PUnit.{u_1 + 1}), Numeric ((fun x => powHalf n) j)

Next tactic:
exact ⟨fun _ => numeric_zero, fun _ => hn⟩
theorem powHalf_le_one (n : ℕ) : powHalf n ≤ 1 := by
  

Proof state:
n : ℕ
⊢ powHalf n ≤ 1

Next tactic:
induction' n with n hn
theorem powHalf_le_one (n : ℕ) : powHalf n ≤ 1 := by
  induction' n with n hn
  · 

Proof state:
case zero
⊢ powHalf Nat.zero ≤ 1

Next tactic:
exact le_rfl
theorem powHalf_le_one (n : ℕ) : powHalf n ≤ 1 := by
  induction' n with n hn
  · exact le_rfl
  · 

Proof state:
case succ
n : ℕ
hn : powHalf n ≤ 1
⊢ powHalf (Nat.succ n) ≤ 1

Next tactic:
exact (powHalf_succ_le_powHalf n).trans hn
theorem powHalf_pos (n : ℕ) : 0 < powHalf n := by
  

Proof state:
n : ℕ
⊢ 0 < powHalf n

Next tactic:
rw [← lf_iff_lt numeric_zero (numeric_powHalf n), zero_lf_le]
theorem powHalf_pos (n : ℕ) : 0 < powHalf n := by
  rw [← lf_iff_lt numeric_zero (numeric_powHalf n), zero_lf_le]; 

Proof state:
n : ℕ
⊢ ∃ i, 0 ≤ moveLeft (powHalf n) i

Next tactic:
simp
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  

Proof state:
n : ℕ
⊢ powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n

Next tactic:
induction' n using Nat.strong_induction_on with n hn
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · 

Proof state:
case h
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n

Next tactic:
constructor
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> 

Proof state:
case h.left
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ powHalf (n + 1) + powHalf (n + 1) ≤ powHalf n

Next tactic:
rw [le_iff_forall_lf]
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> 

Proof state:
case h.right
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ powHalf n ≤ powHalf (n + 1) + powHalf (n + 1)

Next tactic:
rw [le_iff_forall_lf]
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> 

Proof state:
case h.left
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ (∀ (i : LeftMoves (powHalf (n + 1) + powHalf (n + 1))), moveLeft (powHalf (n + 1) + powHalf (n + 1)) i ⧏ powHalf n) ∧
    ∀ (j : RightMoves (powHalf n)), powHalf (n + 1) + powHalf (n + 1) ⧏ moveRight (powHalf n) j

Next tactic:
constructor
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> 

Proof state:
case h.right
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ (∀ (i : LeftMoves (powHalf n)), moveLeft (powHalf n) i ⧏ powHalf (n + 1) + powHalf (n + 1)) ∧
    ∀ (j : RightMoves (powHalf (n + 1) + powHalf (n + 1))), powHalf n ⧏ moveRight (powHalf (n + 1) + powHalf (n + 1)) j

Next tactic:
constructor
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · 

Proof state:
case h.left.left
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ ∀ (i : LeftMoves (powHalf (n + 1) + powHalf (n + 1))), moveLeft (powHalf (n + 1) + powHalf (n + 1)) i ⧏ powHalf n

Next tactic:
rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩)
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> 

Proof state:
case h.left.left.inl.unit
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ moveLeft (powHalf (n + 1) + powHalf (n + 1)) (Sum.inl PUnit.unit) ⧏ powHalf n

Next tactic:
apply lf_of_lt
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> 

Proof state:
case h.left.left.inr.unit
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ moveLeft (powHalf (n + 1) + powHalf (n + 1)) (Sum.inr PUnit.unit) ⧏ powHalf n

Next tactic:
apply lf_of_lt
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · 

Proof state:
case h.left.left.inl.unit.h
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ moveLeft (powHalf (n + 1) + powHalf (n + 1)) (Sum.inl PUnit.unit) < powHalf n

Next tactic:
calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · 

Proof state:
case h.left.left.inr.unit.h
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ moveLeft (powHalf (n + 1) + powHalf (n + 1)) (Sum.inr PUnit.unit) < powHalf n

Next tactic:
calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · 

Proof state:
case h.left.right
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ ∀ (j : RightMoves (powHalf n)), powHalf (n + 1) + powHalf (n + 1) ⧏ moveRight (powHalf n) j

Next tactic:
cases' n with n
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · 

Proof state:
case h.left.right.zero
hn : ∀ m < Nat.zero, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ ∀ (j : RightMoves (powHalf Nat.zero)),
    powHalf (Nat.zero + 1) + powHalf (Nat.zero + 1) ⧏ moveRight (powHalf Nat.zero) j

Next tactic:
rintro ⟨⟩
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · rintro ⟨⟩
      

Proof state:
case h.left.right.succ
n : ℕ
hn : ∀ m < Nat.succ n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ ∀ (j : RightMoves (powHalf (Nat.succ n))),
    powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1) ⧏ moveRight (powHalf (Nat.succ n)) j

Next tactic:
rintro ⟨⟩
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · rintro ⟨⟩
      rintro ⟨⟩
      

Proof state:
case h.left.right.succ.unit
n : ℕ
hn : ∀ m < Nat.succ n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1) ⧏ moveRight (powHalf (Nat.succ n)) PUnit.unit

Next tactic:
apply lf_of_moveRight_le
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · rintro ⟨⟩
      rintro ⟨⟩
      apply lf_of_moveRight_le
      

Proof state:
case h.left.right.succ.unit.h
n : ℕ
hn : ∀ m < Nat.succ n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ moveRight (powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1)) ?h.left.right.succ.unit.j ≤
    moveRight (powHalf (Nat.succ n)) PUnit.unit
case h.left.right.succ.unit.j
n : ℕ
hn : ∀ m < Nat.succ n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ RightMoves (powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1))

Next tactic:
swap
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · rintro ⟨⟩
      rintro ⟨⟩
      apply lf_of_moveRight_le
      swap; 

Proof state:
case h.left.right.succ.unit.j
n : ℕ
hn : ∀ m < Nat.succ n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ RightMoves (powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1))
case h.left.right.succ.unit.h
n : ℕ
hn : ∀ m < Nat.succ n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ moveRight (powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1)) ?h.left.right.succ.unit.j ≤
    moveRight (powHalf (Nat.succ n)) PUnit.unit

Next tactic:
exact Sum.inl default
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · rintro ⟨⟩
      rintro ⟨⟩
      apply lf_of_moveRight_le
      swap; exact Sum.inl default
      

Proof state:
case h.left.right.succ.unit.h
n : ℕ
hn : ∀ m < Nat.succ n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ moveRight (powHalf (Nat.succ n + 1) + powHalf (Nat.succ n + 1)) (Sum.inl default) ≤
    moveRight (powHalf (Nat.succ n)) PUnit.unit

Next tactic:
calc
        powHalf n.succ + powHalf (n.succ + 1) ≤ powHalf n.succ + powHalf n.succ :=
          add_le_add_left (powHalf_succ_le_powHalf _) _
        _ ≈ powHalf n := hn _ (Nat.lt_succ_self n)
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · rintro ⟨⟩
      rintro ⟨⟩
      apply lf_of_moveRight_le
      swap; exact Sum.inl default
      calc
        powHalf n.succ + powHalf (n.succ + 1) ≤ powHalf n.succ + powHalf n.succ :=
          add_le_add_left (powHalf_succ_le_powHalf _) _
        _ ≈ powHalf n := hn _ (Nat.lt_succ_self n)
    · 

Proof state:
case h.right.left
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ ∀ (i : LeftMoves (powHalf n)), moveLeft (powHalf n) i ⧏ powHalf (n + 1) + powHalf (n + 1)

Next tactic:
simp only [powHalf_moveLeft, forall_const]
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · rintro ⟨⟩
      rintro ⟨⟩
      apply lf_of_moveRight_le
      swap; exact Sum.inl default
      calc
        powHalf n.succ + powHalf (n.succ + 1) ≤ powHalf n.succ + powHalf n.succ :=
          add_le_add_left (powHalf_succ_le_powHalf _) _
        _ ≈ powHalf n := hn _ (Nat.lt_succ_self n)
    · simp only [powHalf_moveLeft, forall_const]
      

Proof state:
case h.right.left
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ 0 ⧏ powHalf (n + 1) + powHalf (n + 1)

Next tactic:
apply lf_of_lt
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · rintro ⟨⟩
      rintro ⟨⟩
      apply lf_of_moveRight_le
      swap; exact Sum.inl default
      calc
        powHalf n.succ + powHalf (n.succ + 1) ≤ powHalf n.succ + powHalf n.succ :=
          add_le_add_left (powHalf_succ_le_powHalf _) _
        _ ≈ powHalf n := hn _ (Nat.lt_succ_self n)
    · simp only [powHalf_moveLeft, forall_const]
      apply lf_of_lt
      

Proof state:
case h.right.left.h
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ 0 < powHalf (n + 1) + powHalf (n + 1)

Next tactic:
calc
        0 ≈ 0 + 0 := (Equiv.symm (add_zero_equiv 0))
        _ ≤ powHalf n.succ + 0 := (add_le_add_right (zero_le_powHalf _) _)
        _ < powHalf n.succ + powHalf n.succ := add_lt_add_left (powHalf_pos _) _
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · rintro ⟨⟩
      rintro ⟨⟩
      apply lf_of_moveRight_le
      swap; exact Sum.inl default
      calc
        powHalf n.succ + powHalf (n.succ + 1) ≤ powHalf n.succ + powHalf n.succ :=
          add_le_add_left (powHalf_succ_le_powHalf _) _
        _ ≈ powHalf n := hn _ (Nat.lt_succ_self n)
    · simp only [powHalf_moveLeft, forall_const]
      apply lf_of_lt
      calc
        0 ≈ 0 + 0 := (Equiv.symm (add_zero_equiv 0))
        _ ≤ powHalf n.succ + 0 := (add_le_add_right (zero_le_powHalf _) _)
        _ < powHalf n.succ + powHalf n.succ := add_lt_add_left (powHalf_pos _) _
    · 

Proof state:
case h.right.right
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ ∀ (j : RightMoves (powHalf (n + 1) + powHalf (n + 1))), powHalf n ⧏ moveRight (powHalf (n + 1) + powHalf (n + 1)) j

Next tactic:
rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩)
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · rintro ⟨⟩
      rintro ⟨⟩
      apply lf_of_moveRight_le
      swap; exact Sum.inl default
      calc
        powHalf n.succ + powHalf (n.succ + 1) ≤ powHalf n.succ + powHalf n.succ :=
          add_le_add_left (powHalf_succ_le_powHalf _) _
        _ ≈ powHalf n := hn _ (Nat.lt_succ_self n)
    · simp only [powHalf_moveLeft, forall_const]
      apply lf_of_lt
      calc
        0 ≈ 0 + 0 := (Equiv.symm (add_zero_equiv 0))
        _ ≤ powHalf n.succ + 0 := (add_le_add_right (zero_le_powHalf _) _)
        _ < powHalf n.succ + powHalf n.succ := add_lt_add_left (powHalf_pos _) _
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> 

Proof state:
case h.right.right.inl.unit
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ powHalf n ⧏ moveRight (powHalf (n + 1) + powHalf (n + 1)) (Sum.inl PUnit.unit)

Next tactic:
apply lf_of_lt
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · rintro ⟨⟩
      rintro ⟨⟩
      apply lf_of_moveRight_le
      swap; exact Sum.inl default
      calc
        powHalf n.succ + powHalf (n.succ + 1) ≤ powHalf n.succ + powHalf n.succ :=
          add_le_add_left (powHalf_succ_le_powHalf _) _
        _ ≈ powHalf n := hn _ (Nat.lt_succ_self n)
    · simp only [powHalf_moveLeft, forall_const]
      apply lf_of_lt
      calc
        0 ≈ 0 + 0 := (Equiv.symm (add_zero_equiv 0))
        _ ≤ powHalf n.succ + 0 := (add_le_add_right (zero_le_powHalf _) _)
        _ < powHalf n.succ + powHalf n.succ := add_lt_add_left (powHalf_pos _) _
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> 

Proof state:
case h.right.right.inr.unit
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ powHalf n ⧏ moveRight (powHalf (n + 1) + powHalf (n + 1)) (Sum.inr PUnit.unit)

Next tactic:
apply lf_of_lt
theorem add_powHalf_succ_self_eq_powHalf (n) : powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n := by
  induction' n using Nat.strong_induction_on with n hn
  · constructor <;> rw [le_iff_forall_lf] <;> constructor
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · calc
          0 + powHalf n.succ ≈ powHalf n.succ := zero_add_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
      · calc
          powHalf n.succ + 0 ≈ powHalf n.succ := add_zero_equiv _
          _ < powHalf n := powHalf_succ_lt_powHalf n
    · cases' n with n
      · rintro ⟨⟩
      rintro ⟨⟩
      apply lf_of_moveRight_le
      swap; exact Sum.inl default
      calc
        powHalf n.succ + powHalf (n.succ + 1) ≤ powHalf n.succ + powHalf n.succ :=
          add_le_add_left (powHalf_succ_le_powHalf _) _
        _ ≈ powHalf n := hn _ (Nat.lt_succ_self n)
    · simp only [powHalf_moveLeft, forall_const]
      apply lf_of_lt
      calc
        0 ≈ 0 + 0 := (Equiv.symm (add_zero_equiv 0))
        _ ≤ powHalf n.succ + 0 := (add_le_add_right (zero_le_powHalf _) _)
        _ < powHalf n.succ + powHalf n.succ := add_lt_add_left (powHalf_pos _) _
    · rintro (⟨⟨⟩⟩ | ⟨⟨⟩⟩) <;> apply lf_of_lt
      · 

Proof state:
case h.right.right.inl.unit.h
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ powHalf n < moveRight (powHalf (n + 1) + powHalf (n + 1)) (Sum.inl PUnit.unit)

Next tactic:
calc
          powHalf n ≈ powHalf n + 0 := (Equiv.symm (add_zero_equiv _))
          _ < powHalf n + powHalf n.succ := add_lt_add_left (powHalf_pos _) _