Theorem: Int.strongRec_of_ge
File: Mathlib/Data/Int/Defs.lean

Proof steps:
state_before: a b c d m n : ℤ
P : ℤ → Sort u_1
lt : (n : ℤ) → n < m → P n
ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n
⊢ ∀ (hn : m ≤ n), Int.strongRec lt ge n = ge n hn fun k x => Int.strongRec lt ge k
state_after: a b c d m n✝ : ℤ
P : ℤ → Sort u_1
lt : (n : ℤ) → n < m → P n
ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n
n : ℤ
x✝ : n ≥ m
ih : ∀ (k : ℤ), k < n → ∀ (hn : m ≤ k), Int.strongRec lt ge k = ge k hn fun k_1 x => Int.strongRec lt ge k_1
hn : m ≤ n
⊢ Int.strongRec lt ge n = ge n hn fun k x => Int.strongRec lt ge k
tactic: refine m.strongRec (fun n hnm hmn ↦ (Int.not_lt.mpr hmn hnm).elim) (fun n _ ih hn ↦ ?_) n
state_before: a b c d m n✝ : ℤ
P : ℤ → Sort u_1
lt : (n : ℤ) → n < m → P n
ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n
n : ℤ
x✝ : n ≥ m
ih : ∀ (k : ℤ), k < n → ∀ (hn : m ≤ k), Int.strongRec lt ge k = ge k hn fun k_1 x => Int.strongRec lt ge k_1
hn : m ≤ n
⊢ Int.strongRec lt ge n = ge n hn fun k x => Int.strongRec lt ge k
state_after: a b c d m n✝ : ℤ
P : ℤ → Sort u_1
lt : (n : ℤ) → n < m → P n
ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n
n : ℤ
x✝ : n ≥ m
ih : ∀ (k : ℤ), k < n → ∀ (hn : m ≤ k), Int.strongRec lt ge k = ge k hn fun k_1 x => Int.strongRec lt ge k_1
hn : m ≤ n
⊢ ge n ⋯
      (n.inductionOn' m lt (fun _n a ih l a => if hlm : l < m then lt l hlm else ge l ⋯ fun k x => ih k ⋯)
        fun n_1 x hn l x => hn l ⋯) =
    ge n hn fun k x => Int.strongRec lt ge k
tactic: rw [Int.strongRec, dif_neg (Int.not_lt.mpr hn)]
state_before: a b c d m n✝ : ℤ
P : ℤ → Sort u_1
lt : (n : ℤ) → n < m → P n
ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n
n : ℤ
x✝ : n ≥ m
ih : ∀ (k : ℤ), k < n → ∀ (hn : m ≤ k), Int.strongRec lt ge k = ge k hn fun k_1 x => Int.strongRec lt ge k_1
hn : m ≤ n
⊢ ge n ⋯
      (n.inductionOn' m lt (fun _n a ih l a => if hlm : l < m then lt l hlm else ge l ⋯ fun k x => ih k ⋯)
        fun n_1 x hn l x => hn l ⋯) =
    ge n hn fun k x => Int.strongRec lt ge k
state_after: case e_a
a b c d m n✝ : ℤ
P : ℤ → Sort u_1
lt : (n : ℤ) → n < m → P n
ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n
n : ℤ
x✝ : n ≥ m
ih : ∀ (k : ℤ), k < n → ∀ (hn : m ≤ k), Int.strongRec lt ge k = ge k hn fun k_1 x => Int.strongRec lt ge k_1
hn : m ≤ n
⊢ (n.inductionOn' m lt (fun _n a ih l a => if hlm : l < m then lt l hlm else ge l ⋯ fun k x => ih k ⋯)
      fun n_1 x hn l x => hn l ⋯) =
    fun k x => Int.strongRec lt ge k
tactic: congr
state_before: case e_a
a b c d m n✝ : ℤ
P : ℤ → Sort u_1
lt : (n : ℤ) → n < m → P n
ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n
n : ℤ
x✝ : n ≥ m
ih : ∀ (k : ℤ), k < n → ∀ (hn : m ≤ k), Int.strongRec lt ge k = ge k hn fun k_1 x => Int.strongRec lt ge k_1
hn : m ≤ n
⊢ (n.inductionOn' m lt (fun _n a ih l a => if hlm : l < m then lt l hlm else ge l ⋯ fun k x => ih k ⋯)
      fun n_1 x hn l x => hn l ⋯) =
    fun k x => Int.strongRec lt ge k
state_after: case e_a
a b c d m n✝ : ℤ
P : ℤ → Sort u_1
lt : (n : ℤ) → n < m → P n
ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n
n : ℤ
x✝ : n ≥ m
hn : m ≤ n
⊢ (∀ (k : ℤ), k < n → ∀ (hn : m ≤ k), Int.strongRec lt ge k = ge k hn fun k_1 x => Int.strongRec lt ge k_1) →
    (n.inductionOn' m lt (fun _n a ih l a => if hlm : l < m then lt l hlm else ge l ⋯ fun k x => ih k ⋯)
        fun n_1 x hn l x => hn l ⋯) =
      fun k x => Int.strongRec lt ge k
tactic: revert ih
state_before: case e_a
a b c d m n✝ : ℤ
P : ℤ → Sort u_1
lt : (n : ℤ) → n < m → P n
ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n
n : ℤ
x✝ : n ≥ m
hn : m ≤ n
⊢ (∀ (k : ℤ), k < n → ∀ (hn : m ≤ k), Int.strongRec lt ge k = ge k hn fun k_1 x => Int.strongRec lt ge k_1) →
    (n.inductionOn' m lt (fun _n a ih l a => if hlm : l < m then lt l hlm else ge l ⋯ fun k x => ih k ⋯)
        fun n_1 x hn l x => hn l ⋯) =
      fun k x => Int.strongRec lt ge k
state_after: case e_a.refine_1.h.h
a b c d m n✝ : ℤ
P : ℤ → Sort u_1
lt : (n : ℤ) → n < m → P n
ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n
n : ℤ
x✝¹ : n ≥ m
hn : m ≤ n
x✝ : ∀ (k : ℤ), k < m → ∀ (hn : m ≤ k), Int.strongRec lt ge k = ge k hn fun k_1 x => Int.strongRec lt ge k_1
l : ℤ
hl : l < m
⊢ m.inductionOn' m lt (fun _n a ih l a => if hlm : l < m then lt l hlm else ge l ⋯ fun k x => ih k ⋯)
      (fun n x hn l x => hn l ⋯) l hl =
    Int.strongRec lt ge l

case e_a.refine_2.h.h
a b c d m n✝ : ℤ
P : ℤ → Sort u_1
lt : (n : ℤ) → n < m → P n
ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n
n : ℤ
x✝ : n ≥ m
hn : m ≤ n
k : ℤ
hmk : m ≤ k
ih' :
  (∀ (k_1 : ℤ), k_1 < k → ∀ (hn : m ≤ k_1), Int.strongRec lt ge k_1 = ge k_1 hn fun k x => Int.strongRec lt ge k) →
    (k.inductionOn' m lt (fun _n a ih l a => if hlm : l < m then lt l hlm else ge l ⋯ fun k_1 x => ih k_1 ⋯)
        fun n x hn l x => hn l ⋯) =
      fun k_1 x => Int.strongRec lt ge k_1
ih : ∀ (k_1 : ℤ), k_1 < k + 1 → ∀ (hn : m ≤ k_1), Int.strongRec lt ge k_1 = ge k_1 hn fun k x => Int.strongRec lt ge k
l : ℤ
hl : l < k + 1
⊢ (k + 1).inductionOn' m lt (fun _n a ih l a => if hlm : l < m then lt l hlm else ge l ⋯ fun k_1 x => ih k_1 ⋯)
      (fun n x hn l x => hn l ⋯) l hl =
    Int.strongRec lt ge l

case e_a.refine_3.h.h
a b c d m n✝ : ℤ
P : ℤ → Sort u_1
lt : (n : ℤ) → n < m → P n
ge : (n : ℤ) → n ≥ m → ((k : ℤ) → k < n → P k) → P n
n : ℤ
x✝¹ : n ≥ m
hn : m ≤ n
k : ℤ
hkm : k ≤ m
ih' :
  (∀ (k_1 : ℤ), k_1 < k → ∀ (hn : m ≤ k_1), Int.strongRec lt ge k_1 = ge k_1 hn fun k x => Int.strongRec lt ge k) →
    (k.inductionOn' m lt (fun _n a ih l a => if hlm : l < m then lt l hlm else ge l ⋯ fun k_1 x => ih k_1 ⋯)
        fun n x hn l x => hn l ⋯) =
      fun k_1 x => Int.strongRec lt ge k_1
x✝ : ∀ (k_1 : ℤ), k_1 < k - 1 → ∀ (hn : m ≤ k_1), Int.strongRec lt ge k_1 = ge k_1 hn fun k x => Int.strongRec lt ge k
l : ℤ
hl : l < k - 1
⊢ (k - 1).inductionOn' m lt (fun _n a ih l a => if hlm : l < m then lt l hlm else ge l ⋯ fun k_1 x => ih k_1 ⋯)
      (fun n x hn l x => hn l ⋯) l hl =
    Int.strongRec lt ge l
tactic: refine n.inductionOn' m (fun _ ↦ ?_) (fun k hmk ih' ih ↦ ?_) (fun k hkm ih' _ ↦ ?_) <;> ext l hl