Theorem: String.splitAux_of_valid
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: p : Char → Bool
l m r : List Char
acc : List String
⊢ { data := l ++ m ++ r }.splitAux p { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } acc =
    acc.reverse ++ List.map mk (List.splitOnP.go p r m.reverse)
state_after: p : Char → Bool
l m r : List Char
acc : List String
⊢ (if h : { data := l ++ m ++ r }.atEnd { byteIdx := utf8Len l + utf8Len m } = true then
      let r := { data := l ++ m ++ r }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } :: acc;
      r.reverse
    else
      let_fun this := ⋯;
      if p ({ data := l ++ m ++ r }.get { byteIdx := utf8Len l + utf8Len m }) = true then
        let i' := { data := l ++ m ++ r }.next { byteIdx := utf8Len l + utf8Len m };
        { data := l ++ m ++ r }.splitAux p i' i'
          ({ data := l ++ m ++ r }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } :: acc)
      else
        { data := l ++ m ++ r }.splitAux p { byteIdx := utf8Len l }
          ({ data := l ++ m ++ r }.next { byteIdx := utf8Len l + utf8Len m }) acc) =
    acc.reverse ++ List.map mk (List.splitOnP.go p r m.reverse)
tactic: unfold splitAux
state_before: p : Char → Bool
l m r : List Char
acc : List String
⊢ (if h : { data := l ++ m ++ r }.atEnd { byteIdx := utf8Len l + utf8Len m } = true then
      let r := { data := l ++ m ++ r }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } :: acc;
      r.reverse
    else
      let_fun this := ⋯;
      if p ({ data := l ++ m ++ r }.get { byteIdx := utf8Len l + utf8Len m }) = true then
        let i' := { data := l ++ m ++ r }.next { byteIdx := utf8Len l + utf8Len m };
        { data := l ++ m ++ r }.splitAux p i' i'
          ({ data := l ++ m ++ r }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } :: acc)
      else
        { data := l ++ m ++ r }.splitAux p { byteIdx := utf8Len l }
          ({ data := l ++ m ++ r }.next { byteIdx := utf8Len l + utf8Len m }) acc) =
    acc.reverse ++ List.map mk (List.splitOnP.go p r m.reverse)
state_after: p : Char → Bool
l m r : List Char
acc : List String
⊢ (if r = [] then
      acc.reverse ++ [{ data := l ++ (m ++ r) }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m }]
    else
      if p ({ data := l ++ (m ++ r) }.get { byteIdx := utf8Len l + utf8Len m }) = true then
        { data := l ++ (m ++ r) }.splitAux p ({ data := l ++ (m ++ r) }.next { byteIdx := utf8Len l + utf8Len m })
          ({ data := l ++ (m ++ r) }.next { byteIdx := utf8Len l + utf8Len m })
          ({ data := l ++ (m ++ r) }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } :: acc)
      else
        { data := l ++ (m ++ r) }.splitAux p { byteIdx := utf8Len l }
          ({ data := l ++ (m ++ r) }.next { byteIdx := utf8Len l + utf8Len m }) acc) =
    acc.reverse ++ List.map mk (List.splitOnP.go p r m.reverse)
tactic: simp only [List.append_assoc, atEnd_iff, endPos_eq, utf8Len_append, Pos.mk_le_mk, by
    simpa using atEnd_of_valid (l ++ m) r, List.reverse_cons, dite_eq_ite]
state_before: p : Char → Bool
l m r : List Char
acc : List String
⊢ (if r = [] then
      acc.reverse ++ [{ data := l ++ (m ++ r) }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m }]
    else
      if p ({ data := l ++ (m ++ r) }.get { byteIdx := utf8Len l + utf8Len m }) = true then
        { data := l ++ (m ++ r) }.splitAux p ({ data := l ++ (m ++ r) }.next { byteIdx := utf8Len l + utf8Len m })
          ({ data := l ++ (m ++ r) }.next { byteIdx := utf8Len l + utf8Len m })
          ({ data := l ++ (m ++ r) }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } :: acc)
      else
        { data := l ++ (m ++ r) }.splitAux p { byteIdx := utf8Len l }
          ({ data := l ++ (m ++ r) }.next { byteIdx := utf8Len l + utf8Len m }) acc) =
    acc.reverse ++ List.map mk (List.splitOnP.go p r m.reverse)
state_after: case isTrue
p : Char → Bool
l m r : List Char
acc : List String
h✝ : r = []
⊢ acc.reverse ++ [{ data := l ++ (m ++ r) }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m }] =
    acc.reverse ++ List.map mk (List.splitOnP.go p r m.reverse)

case isFalse
p : Char → Bool
l m r : List Char
acc : List String
h✝ : ¬r = []
⊢ (if p ({ data := l ++ (m ++ r) }.get { byteIdx := utf8Len l + utf8Len m }) = true then
      { data := l ++ (m ++ r) }.splitAux p ({ data := l ++ (m ++ r) }.next { byteIdx := utf8Len l + utf8Len m })
        ({ data := l ++ (m ++ r) }.next { byteIdx := utf8Len l + utf8Len m })
        ({ data := l ++ (m ++ r) }.extract { byteIdx := utf8Len l } { byteIdx := utf8Len l + utf8Len m } :: acc)
    else
      { data := l ++ (m ++ r) }.splitAux p { byteIdx := utf8Len l }
        ({ data := l ++ (m ++ r) }.next { byteIdx := utf8Len l + utf8Len m }) acc) =
    acc.reverse ++ List.map mk (List.splitOnP.go p r m.reverse)
tactic: split