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

tactic: induction' l with hd tl ihl
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
l : List α
hl : l.Nodup
f : α → β
x : α
y : β
⊢ map (update f x y) l = if x ∈ l then (map f l).set (indexOf x l) y else map f l
state_after: case nil
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
hl : [].Nodup
⊢ map (update f x y) [] = if x ∈ [] then (map f []).set (indexOf x []) y else map f []

case cons
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
hd : α
tl : List α
ihl : tl.Nodup → map (update f x y) tl = if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl
hl : (hd :: tl).Nodup
⊢ map (update f x y) (hd :: tl) =
    if x ∈ hd :: tl then (map f (hd :: tl)).set (indexOf x (hd :: tl)) y else map f (hd :: tl)

tactic: rw [nodup_cons] at hl
state_before: case cons
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
hd : α
tl : List α
ihl : tl.Nodup → map (update f x y) tl = if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl
hl : (hd :: tl).Nodup
⊢ map (update f x y) (hd :: tl) =
    if x ∈ hd :: tl then (map f (hd :: tl)).set (indexOf x (hd :: tl)) y else map f (hd :: tl)
state_after: case cons
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
hd : α
tl : List α
ihl : tl.Nodup → map (update f x y) tl = if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl
hl : hd ∉ tl ∧ tl.Nodup
⊢ map (update f x y) (hd :: tl) =
    if x ∈ hd :: tl then (map f (hd :: tl)).set (indexOf x (hd :: tl)) y else map f (hd :: tl)

tactic: simp only [mem_cons, map, ihl hl.2]
state_before: case cons
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
hd : α
tl : List α
ihl : tl.Nodup → map (update f x y) tl = if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl
hl : hd ∉ tl ∧ tl.Nodup
⊢ map (update f x y) (hd :: tl) =
    if x ∈ hd :: tl then (map f (hd :: tl)).set (indexOf x (hd :: tl)) y else map f (hd :: tl)
state_after: case cons
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
hd : α
tl : List α
ihl : tl.Nodup → map (update f x y) tl = if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl
hl : hd ∉ tl ∧ tl.Nodup
⊢ (update f x y hd :: if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl) =
    if x = hd ∨ x ∈ tl then (f hd :: map f tl).set (indexOf x (hd :: tl)) y else f hd :: map f tl

tactic: by_cases H : hd = x
state_before: case cons
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
hd : α
tl : List α
ihl : tl.Nodup → map (update f x y) tl = if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl
hl : hd ∉ tl ∧ tl.Nodup
⊢ (update f x y hd :: if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl) =
    if x = hd ∨ x ∈ tl then (f hd :: map f tl).set (indexOf x (hd :: tl)) y else f hd :: map f tl
state_after: case pos
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
hd : α
tl : List α
ihl : tl.Nodup → map (update f x y) tl = if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl
hl : hd ∉ tl ∧ tl.Nodup
H : hd = x
⊢ (update f x y hd :: if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl) =
    if x = hd ∨ x ∈ tl then (f hd :: map f tl).set (indexOf x (hd :: tl)) y else f hd :: map f tl

case neg
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
hd : α
tl : List α
ihl : tl.Nodup → map (update f x y) tl = if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl
hl : hd ∉ tl ∧ tl.Nodup
H : ¬hd = x
⊢ (update f x y hd :: if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl) =
    if x = hd ∨ x ∈ tl then (f hd :: map f tl).set (indexOf x (hd :: tl)) y else f hd :: map f tl

tactic: simp
state_before: case nil
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
hl : [].Nodup
⊢ map (update f x y) [] = if x ∈ [] then (map f []).set (indexOf x []) y else map f []
state_after: no goals

tactic: subst hd
state_before: case pos
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
hd : α
tl : List α
ihl : tl.Nodup → map (update f x y) tl = if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl
hl : hd ∉ tl ∧ tl.Nodup
H : hd = x
⊢ (update f x y hd :: if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl) =
    if x = hd ∨ x ∈ tl then (f hd :: map f tl).set (indexOf x (hd :: tl)) y else f hd :: map f tl
state_after: case pos
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
tl : List α
ihl : tl.Nodup → map (update f x y) tl = if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl
hl : x ∉ tl ∧ tl.Nodup
⊢ (update f x y x :: if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl) =
    if x = x ∨ x ∈ tl then (f x :: map f tl).set (indexOf x (x :: tl)) y else f x :: map f tl

tactic: simp [set, hl.1]
state_before: case pos
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
tl : List α
ihl : tl.Nodup → map (update f x y) tl = if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl
hl : x ∉ tl ∧ tl.Nodup
⊢ (update f x y x :: if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl) =
    if x = x ∨ x ∈ tl then (f x :: map f tl).set (indexOf x (x :: tl)) y else f x :: map f tl
state_after: no goals

tactic: simp [Ne.symm H, H, set, ← apply_ite (cons (f hd))]
state_before: case neg
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
f : α → β
x : α
y : β
hd : α
tl : List α
ihl : tl.Nodup → map (update f x y) tl = if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl
hl : hd ∉ tl ∧ tl.Nodup
H : ¬hd = x
⊢ (update f x y hd :: if x ∈ tl then (map f tl).set (indexOf x tl) y else map f tl) =
    if x = hd ∨ x ∈ tl then (f hd :: map f tl).set (indexOf x (hd :: tl)) y else f hd :: map f tl
state_after: no goals