Theorem: List.mem_eraseP_of_neg
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: refine ⟨mem_of_mem_eraseP, fun al => ?_⟩
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
⊢ a ∈ eraseP p l ↔ a ∈ l
state_after: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
al : a ∈ l
⊢ a ∈ eraseP p l

tactic: match exists_or_eq_self_of_eraseP p l with
| .inl h => rw [h]; assumption
| .inr ⟨c, l₁, l₂, h₁, h₂, h₃, h₄⟩ =>
  rw [h₄]; rw [h₃] at al
  have : a ≠ c := fun h => (h ▸ pa).elim h₂
  simp [this] at al; simp [al]
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
al : a ∈ l
⊢ a ∈ eraseP p l
state_after: no goals

tactic: rw [h]
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
al : a ∈ l
h : eraseP p l = l
⊢ a ∈ eraseP p l
state_after: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
al : a ∈ l
h : eraseP p l = l
⊢ a ∈ l

tactic: assumption
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
al : a ∈ l
h : eraseP p l = l
⊢ a ∈ l
state_after: no goals

tactic: rw [h₄]
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
al : a ∈ l
c : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ a ∈ eraseP p l
state_after: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
al : a ∈ l
c : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ a ∈ l₁ ++ l₂

tactic: rw [h₃] at al
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
al : a ∈ l
c : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ a ∈ l₁ ++ l₂
state_after: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
c : α
l₁ l₂ : List α
al : a ∈ l₁ ++ c :: l₂
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ a ∈ l₁ ++ l₂

tactic: have : a ≠ c := fun h => (h ▸ pa).elim h₂
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
c : α
l₁ l₂ : List α
al : a ∈ l₁ ++ c :: l₂
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
⊢ a ∈ l₁ ++ l₂
state_after: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
c : α
l₁ l₂ : List α
al : a ∈ l₁ ++ c :: l₂
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
this : a ≠ c
⊢ a ∈ l₁ ++ l₂

tactic: simp [this] at al
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
c : α
l₁ l₂ : List α
al : a ∈ l₁ ++ c :: l₂
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
this : a ≠ c
⊢ a ∈ l₁ ++ l₂
state_after: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
c : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
this : a ≠ c
al : a ∈ l₁ ∨ a ∈ l₂
⊢ a ∈ l₁ ++ l₂

tactic: simp [al]
state_before: α : Type u_1
p : α → Bool
a : α
l : List α
pa : ¬p a = true
c : α
l₁ l₂ : List α
h₁ : ∀ (b : α), b ∈ l₁ → ¬p b = true
h₂ : p c = true
h₃ : l = l₁ ++ c :: l₂
h₄ : eraseP p l = l₁ ++ l₂
this : a ≠ c
al : a ∈ l₁ ∨ a ∈ l₂
⊢ a ∈ l₁ ++ l₂
state_after: no goals