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

tactic: simp
state_before: α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
n : ℕ
x✝ : [].Nodup
⊢ take n [] = List.filter (fun a => elem a (take n [])) []
state_after: no goals

tactic: simp
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
x✝ : (b :: l).Nodup
⊢ take 0 (b :: l) = List.filter (fun a => elem a (take 0 (b :: l))) (b :: l)
state_after: no goals

tactic: rw [take_cons, Nodup.take_eq_filter_mem (Nodup.of_cons hl), List.filter_cons_of_pos _ (by simp)]
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : (b :: l).Nodup
⊢ take (n + 1) (b :: l) = List.filter (fun a => elem a (take (n + 1) (b :: l))) (b :: l)
state_after: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : (b :: l).Nodup
⊢ b :: List.filter (fun a => elem a (take n l)) l =
    b :: List.filter (fun a => elem a (b :: List.filter (fun a => elem a (take n l)) l)) l

tactic: congr 1
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : (b :: l).Nodup
⊢ b :: List.filter (fun a => elem a (take n l)) l =
    b :: List.filter (fun a => elem a (b :: List.filter (fun a => elem a (take n l)) l)) l
state_after: case e_tail
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : (b :: l).Nodup
⊢ List.filter (fun a => elem a (take n l)) l =
    List.filter (fun a => elem a (b :: List.filter (fun a => elem a (take n l)) l)) l

tactic: refine List.filter_congr ?_
state_before: case e_tail
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : (b :: l).Nodup
⊢ List.filter (fun a => elem a (take n l)) l =
    List.filter (fun a => elem a (b :: List.filter (fun a => elem a (take n l)) l)) l
state_after: case e_tail
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : (b :: l).Nodup
⊢ ∀ x ∈ l, elem x (take n l) = elem x (b :: List.filter (fun a => elem a (take n l)) l)

tactic: intro x hx
state_before: case e_tail
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : (b :: l).Nodup
⊢ ∀ x ∈ l, elem x (take n l) = elem x (b :: List.filter (fun a => elem a (take n l)) l)
state_after: case e_tail
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : (b :: l).Nodup
x : α
hx : x ∈ l
⊢ elem x (take n l) = elem x (b :: List.filter (fun a => elem a (take n l)) l)

tactic: have : x ≠ b := fun h => (nodup_cons.1 hl).1 (h ▸ hx)
state_before: case e_tail
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : (b :: l).Nodup
x : α
hx : x ∈ l
⊢ elem x (take n l) = elem x (b :: List.filter (fun a => elem a (take n l)) l)
state_after: case e_tail
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : (b :: l).Nodup
x : α
hx : x ∈ l
this : x ≠ b
⊢ elem x (take n l) = elem x (b :: List.filter (fun a => elem a (take n l)) l)

tactic: simp (config := {contextual := true}) [List.mem_filter, this, hx]
state_before: case e_tail
α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : (b :: l).Nodup
x : α
hx : x ∈ l
this : x ≠ b
⊢ elem x (take n l) = elem x (b :: List.filter (fun a => elem a (take n l)) l)
state_after: no goals

tactic: simp
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b✝ : α
inst✝ : DecidableEq α
b : α
l : List α
n : ℕ
hl : (b :: l).Nodup
⊢ elem b (b :: List.filter (fun a => elem a (take n l)) l) = true
state_after: no goals