Theorem: List.Nodup.erase_getElem
File: Mathlib/Data/List/Nodup.lean

tactic: simp
state_before: case nil
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
hl : [].Nodup
i : ℕ
h : i < [].length
⊢ [].erase [][i] = [].eraseIdx i
state_after: no goals

tactic: simp
state_before: case cons.zero
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : (a :: l).Nodup
h : 0 < (a :: l).length
⊢ (a :: l).erase (a :: l)[0] = (a :: l).eraseIdx 0
state_after: no goals

tactic: rw [nodup_cons] at hl
state_before: case cons.succ
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : (a :: l).Nodup
i : ℕ
h : i + 1 < (a :: l).length
⊢ (a :: l).erase (a :: l)[i + 1] = (a :: l).eraseIdx (i + 1)
state_after: case cons.succ
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : a ∉ l ∧ l.Nodup
i : ℕ
h : i + 1 < (a :: l).length
⊢ (a :: l).erase (a :: l)[i + 1] = (a :: l).eraseIdx (i + 1)

tactic: rw [erase_cons_tail]
state_before: case cons.succ
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : a ∉ l ∧ l.Nodup
i : ℕ
h : i + 1 < (a :: l).length
⊢ (a :: l).erase (a :: l)[i + 1] = (a :: l).eraseIdx (i + 1)
state_after: case cons.succ
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : a ∉ l ∧ l.Nodup
i : ℕ
h : i + 1 < (a :: l).length
⊢ a :: l.erase (a :: l)[i + 1] = (a :: l).eraseIdx (i + 1)

case cons.succ.h
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : a ∉ l ∧ l.Nodup
i : ℕ
h : i + 1 < (a :: l).length
⊢ ¬(a == (a :: l)[i + 1]) = true

tactic: simp [IH hl.2]
state_before: case cons.succ
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : a ∉ l ∧ l.Nodup
i : ℕ
h : i + 1 < (a :: l).length
⊢ a :: l.erase (a :: l)[i + 1] = (a :: l).eraseIdx (i + 1)
state_after: no goals

tactic: rw [beq_iff_eq]
state_before: case cons.succ.h
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : a ∉ l ∧ l.Nodup
i : ℕ
h : i + 1 < (a :: l).length
⊢ ¬(a == (a :: l)[i + 1]) = true
state_after: case cons.succ.h
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : a ∉ l ∧ l.Nodup
i : ℕ
h : i + 1 < (a :: l).length
⊢ ¬a = (a :: l)[i + 1]

tactic: simp only [getElem_cons_succ]
state_before: case cons.succ.h
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : a ∉ l ∧ l.Nodup
i : ℕ
h : i + 1 < (a :: l).length
⊢ ¬a = (a :: l)[i + 1]
state_after: case cons.succ.h
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : a ∉ l ∧ l.Nodup
i : ℕ
h : i + 1 < (a :: l).length
⊢ ¬a = l[i]

tactic: simp only [length_cons, succ_eq_add_one, Nat.add_lt_add_iff_right] at h
state_before: case cons.succ.h
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : a ∉ l ∧ l.Nodup
i : ℕ
h : i + 1 < (a :: l).length
⊢ ¬a = l[i]
state_after: case cons.succ.h
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a✝ b : α
inst✝ : DecidableEq α
a : α
l : List α
IH : l.Nodup → ∀ (i : ℕ) (h : i < l.length), l.erase l[i] = l.eraseIdx i
hl : a ∉ l ∧ l.Nodup
i : ℕ
h✝ : i + 1 < (a :: l).length
h : i < l.length
⊢ ¬a = l[i]