Theorem: String.Iterator.ValidFor.setCurr'
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: l r : List Char
c : Char
it : Iterator
h : ValidFor l r it
⊢ ValidFor l (List.modifyHead (fun x => c) r) (it.setCurr c)
state_after: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }
⊢ ValidFor l (List.modifyHead (fun x => c) r)
    ({ s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }.setCurr c)
tactic: cases h.out'
state_before: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }
⊢ ValidFor l (List.modifyHead (fun x => c) r)
    ({ s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }.setCurr c)
state_after: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }
⊢ ValidFor l (List.modifyHead (fun x => c) r)
    { s := { data := l.reverse ++ r }.set { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }
tactic: simp only [setCurr, utf8Len_reverse]
state_before: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }
⊢ ValidFor l (List.modifyHead (fun x => c) r)
    { s := { data := l.reverse ++ r }.set { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }
state_after: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }
⊢ { s := { data := l.reverse ++ r }.set { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }.s.data =
    l.reverseAux (List.modifyHead (fun x => c) r)
tactic: refine .of_eq _ ?_ (by simp)
state_before: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }
⊢ { s := { data := l.reverse ++ r }.set { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }.s.data =
    l.reverseAux (List.modifyHead (fun x => c) r)
state_after: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }
this :
  { data := l.reverse ++ r }.set { byteIdx := utf8Len l.reverse } c =
    { data := l.reverse ++ List.modifyHead (fun x => c) r }
⊢ { s := { data := l.reverse ++ r }.set { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }.s.data =
    l.reverseAux (List.modifyHead (fun x => c) r)
tactic: have := set_of_valid l.reverse r c
state_before: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }
this :
  { data := l.reverse ++ r }.set { byteIdx := utf8Len l.reverse } c =
    { data := l.reverse ++ List.modifyHead (fun x => c) r }
⊢ { s := { data := l.reverse ++ r }.set { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }.s.data =
    l.reverseAux (List.modifyHead (fun x => c) r)
state_after: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }
this :
  { data := l.reverse ++ r }.set { byteIdx := utf8Len l } c = { data := l.reverse ++ List.modifyHead (fun x => c) r }
⊢ { s := { data := l.reverse ++ r }.set { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }.s.data =
    l.reverseAux (List.modifyHead (fun x => c) r)
tactic: simp only [utf8Len_reverse] at this
state_before: case refl
l r : List Char
c : Char
h : ValidFor l r { s := { data := l.reverse ++ r }, i := { byteIdx := utf8Len l.reverse } }
this :
  { data := l.reverse ++ r }.set { byteIdx := utf8Len l } c = { data := l.reverse ++ List.modifyHead (fun x => c) r }
⊢ { s := { data := l.reverse ++ r }.set { byteIdx := utf8Len l } c, i := { byteIdx := utf8Len l } }.s.data =
    l.reverseAux (List.modifyHead (fun x => c) r)
state_after: no goals
tactic: simp [List.reverseAux_eq, this]