Theorem: String.ltb_cons_addChar
File: Mathlib/Data/String/Basic.lean

tactic: apply ltb.inductionOn ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩ (motive := fun ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩ ↦
  ltb ⟨⟨c :: cs₁⟩, i₁ + c⟩ ⟨⟨c :: cs₂⟩, i₂ + c⟩ =
  ltb ⟨⟨cs₁⟩, i₁⟩ ⟨⟨cs₂⟩, i₂⟩) <;> simp only <;>
intro ⟨cs₁⟩ ⟨cs₂⟩ i₁ i₂ <;>
intros <;>
(conv => lhs; unfold ltb) <;> (conv => rhs; unfold ltb) <;>
simp only [Iterator.hasNext_cons_addChar, ite_false, ite_true, *]
state_before: c : Char
cs₁ cs₂ : List Char
i₁ i₂ : Pos
⊢ ltb { s := { data := c :: cs₁ }, i := i₁ + c } { s := { data := c :: cs₂ }, i := i₂ + c } =
    ltb { s := { data := cs₁ }, i := i₁ } { s := { data := cs₂ }, i := i₂ }
state_after: case ind
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
a✝³ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
a✝² : { s := { data := cs₁ }, i := i₁ }.hasNext = true
a✝¹ : { data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
a✝ :
  ltb
      { s := { data := c :: { s := { data := cs₁ }, i := i₁ }.next.1.data },
        i := { s := { data := cs₁ }, i := i₁ }.next.i + c }
      { s := { data := c :: { s := { data := cs₂ }, i := i₂ }.next.1.data },
        i := { s := { data := cs₂ }, i := i₂ }.next.i + c } =
    ltb
      { s := { data := { s := { data := cs₁ }, i := i₁ }.next.1.data }, i := { s := { data := cs₁ }, i := i₁ }.next.i }
      { s := { data := { s := { data := cs₂ }, i := i₂ }.next.1.data }, i := { s := { data := cs₂ }, i := i₂ }.next.i }
⊢ (if { s := { data := c :: cs₁ }, i := i₁ + c }.curr = { s := { data := c :: cs₂ }, i := i₂ + c }.curr then
      ltb { s := { data := c :: cs₁ }, i := i₁ + c }.next { s := { data := c :: cs₂ }, i := i₂ + c }.next
    else decide ({ s := { data := c :: cs₁ }, i := i₁ + c }.curr < { s := { data := c :: cs₂ }, i := i₂ + c }.curr)) =
    if { s := { data := cs₁ }, i := i₁ }.curr = { s := { data := cs₂ }, i := i₂ }.curr then
      ltb { s := { data := cs₁ }, i := i₁ }.next { s := { data := cs₂ }, i := i₂ }.next
    else decide ({ s := { data := cs₁ }, i := i₁ }.curr < { s := { data := cs₂ }, i := i₂ }.curr)

case eq
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
a✝² : { s := { data := cs₂ }, i := i₂ }.hasNext = true
a✝¹ : { s := { data := cs₁ }, i := i₁ }.hasNext = true
a✝ : ¬{ data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
⊢ (if { s := { data := c :: cs₁ }, i := i₁ + c }.curr = { s := { data := c :: cs₂ }, i := i₂ + c }.curr then
      ltb { s := { data := c :: cs₁ }, i := i₁ + c }.next { s := { data := c :: cs₂ }, i := i₂ + c }.next
    else decide ({ s := { data := c :: cs₁ }, i := i₁ + c }.curr < { s := { data := c :: cs₂ }, i := i₂ + c }.curr)) =
    if { s := { data := cs₁ }, i := i₁ }.curr = { s := { data := cs₂ }, i := i₂ }.curr then
      ltb { s := { data := cs₁ }, i := i₁ }.next { s := { data := cs₂ }, i := i₂ }.next
    else decide ({ s := { data := cs₁ }, i := i₁ }.curr < { s := { data := cs₂ }, i := i₂ }.curr)

tactic: conv => lhs; unfold ltb
state_before: case base₂
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
a✝ : ¬{ s := { data := cs₂ }, i := i₂ }.hasNext = true
⊢ ltb { s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }
      { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c } =
    ltb { s := { data := { data := cs₁ }.data }, i := i₁ } { s := { data := { data := cs₂ }.data }, i := i₂ }
state_after: case base₂
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
a✝ : ¬{ s := { data := cs₂ }, i := i₂ }.hasNext = true
⊢ (if { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c }.hasNext = true then
      if { s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }.hasNext = true then
        if
            { s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }.curr =
              { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c }.curr then
          ltb { s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }.next
            { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c }.next
        else
          decide
            ({ s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }.curr <
              { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c }.curr)
      else true
    else false) =
    ltb { s := { data := { data := cs₁ }.data }, i := i₁ } { s := { data := { data := cs₂ }.data }, i := i₂ }

tactic: conv => rhs; unfold ltb
state_before: case base₂
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
a✝ : ¬{ s := { data := cs₂ }, i := i₂ }.hasNext = true
⊢ (if { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c }.hasNext = true then
      if { s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }.hasNext = true then
        if
            { s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }.curr =
              { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c }.curr then
          ltb { s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }.next
            { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c }.next
        else
          decide
            ({ s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }.curr <
              { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c }.curr)
      else true
    else false) =
    ltb { s := { data := { data := cs₁ }.data }, i := i₁ } { s := { data := { data := cs₂ }.data }, i := i₂ }
state_after: case base₂
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
a✝ : ¬{ s := { data := cs₂ }, i := i₂ }.hasNext = true
⊢ (if { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c }.hasNext = true then
      if { s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }.hasNext = true then
        if
            { s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }.curr =
              { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c }.curr then
          ltb { s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }.next
            { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c }.next
        else
          decide
            ({ s := { data := c :: { data := cs₁ }.data }, i := i₁ + c }.curr <
              { s := { data := c :: { data := cs₂ }.data }, i := i₂ + c }.curr)
      else true
    else false) =
    if { s := { data := { data := cs₂ }.data }, i := i₂ }.hasNext = true then
      if { s := { data := { data := cs₁ }.data }, i := i₁ }.hasNext = true then
        if
            { s := { data := { data := cs₁ }.data }, i := i₁ }.curr =
              { s := { data := { data := cs₂ }.data }, i := i₂ }.curr then
          ltb { s := { data := { data := cs₁ }.data }, i := i₁ }.next
            { s := { data := { data := cs₂ }.data }, i := i₂ }.next
        else
          decide
            ({ s := { data := { data := cs₁ }.data }, i := i₁ }.curr <
              { s := { data := { data := cs₂ }.data }, i := i₂ }.curr)
      else true
    else false

tactic: rename_i h₂ h₁ heq ih
state_before: case ind
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
a✝³ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
a✝² : { s := { data := cs₁ }, i := i₁ }.hasNext = true
a✝¹ : { data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
a✝ :
  ltb
      { s := { data := c :: { s := { data := cs₁ }, i := i₁ }.next.1.data },
        i := { s := { data := cs₁ }, i := i₁ }.next.i + c }
      { s := { data := c :: { s := { data := cs₂ }, i := i₂ }.next.1.data },
        i := { s := { data := cs₂ }, i := i₂ }.next.i + c } =
    ltb
      { s := { data := { s := { data := cs₁ }, i := i₁ }.next.1.data }, i := { s := { data := cs₁ }, i := i₁ }.next.i }
      { s := { data := { s := { data := cs₂ }, i := i₂ }.next.1.data }, i := { s := { data := cs₂ }, i := i₂ }.next.i }
⊢ (if { s := { data := c :: cs₁ }, i := i₁ + c }.curr = { s := { data := c :: cs₂ }, i := i₂ + c }.curr then
      ltb { s := { data := c :: cs₁ }, i := i₁ + c }.next { s := { data := c :: cs₂ }, i := i₂ + c }.next
    else decide ({ s := { data := c :: cs₁ }, i := i₁ + c }.curr < { s := { data := c :: cs₂ }, i := i₂ + c }.curr)) =
    if { s := { data := cs₁ }, i := i₁ }.curr = { s := { data := cs₂ }, i := i₂ }.curr then
      ltb { s := { data := cs₁ }, i := i₁ }.next { s := { data := cs₂ }, i := i₂ }.next
    else decide ({ s := { data := cs₁ }, i := i₁ }.curr < { s := { data := cs₂ }, i := i₂ }.curr)
state_after: case ind
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
h₂ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
h₁ : { s := { data := cs₁ }, i := i₁ }.hasNext = true
heq : { data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
ih :
  ltb
      { s := { data := c :: { s := { data := cs₁ }, i := i₁ }.next.1.data },
        i := { s := { data := cs₁ }, i := i₁ }.next.i + c }
      { s := { data := c :: { s := { data := cs₂ }, i := i₂ }.next.1.data },
        i := { s := { data := cs₂ }, i := i₂ }.next.i + c } =
    ltb
      { s := { data := { s := { data := cs₁ }, i := i₁ }.next.1.data }, i := { s := { data := cs₁ }, i := i₁ }.next.i }
      { s := { data := { s := { data := cs₂ }, i := i₂ }.next.1.data }, i := { s := { data := cs₂ }, i := i₂ }.next.i }
⊢ (if { s := { data := c :: cs₁ }, i := i₁ + c }.curr = { s := { data := c :: cs₂ }, i := i₂ + c }.curr then
      ltb { s := { data := c :: cs₁ }, i := i₁ + c }.next { s := { data := c :: cs₂ }, i := i₂ + c }.next
    else decide ({ s := { data := c :: cs₁ }, i := i₁ + c }.curr < { s := { data := c :: cs₂ }, i := i₂ + c }.curr)) =
    if { s := { data := cs₁ }, i := i₁ }.curr = { s := { data := cs₂ }, i := i₂ }.curr then
      ltb { s := { data := cs₁ }, i := i₁ }.next { s := { data := cs₂ }, i := i₂ }.next
    else decide ({ s := { data := cs₁ }, i := i₁ }.curr < { s := { data := cs₂ }, i := i₂ }.curr)

tactic: simp only [Iterator.next, next, heq, Iterator.curr, get_cons_addChar, ite_true] at ih ⊢
state_before: case ind
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
h₂ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
h₁ : { s := { data := cs₁ }, i := i₁ }.hasNext = true
heq : { data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
ih :
  ltb
      { s := { data := c :: { s := { data := cs₁ }, i := i₁ }.next.1.data },
        i := { s := { data := cs₁ }, i := i₁ }.next.i + c }
      { s := { data := c :: { s := { data := cs₂ }, i := i₂ }.next.1.data },
        i := { s := { data := cs₂ }, i := i₂ }.next.i + c } =
    ltb
      { s := { data := { s := { data := cs₁ }, i := i₁ }.next.1.data }, i := { s := { data := cs₁ }, i := i₁ }.next.i }
      { s := { data := { s := { data := cs₂ }, i := i₂ }.next.1.data }, i := { s := { data := cs₂ }, i := i₂ }.next.i }
⊢ (if { s := { data := c :: cs₁ }, i := i₁ + c }.curr = { s := { data := c :: cs₂ }, i := i₂ + c }.curr then
      ltb { s := { data := c :: cs₁ }, i := i₁ + c }.next { s := { data := c :: cs₂ }, i := i₂ + c }.next
    else decide ({ s := { data := c :: cs₁ }, i := i₁ + c }.curr < { s := { data := c :: cs₂ }, i := i₂ + c }.curr)) =
    if { s := { data := cs₁ }, i := i₁ }.curr = { s := { data := cs₂ }, i := i₂ }.curr then
      ltb { s := { data := cs₁ }, i := i₁ }.next { s := { data := cs₂ }, i := i₂ }.next
    else decide ({ s := { data := cs₁ }, i := i₁ }.curr < { s := { data := cs₂ }, i := i₂ }.curr)
state_after: case ind
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
h₂ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
h₁ : { s := { data := cs₁ }, i := i₁ }.hasNext = true
heq : { data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
ih :
  ltb { s := { data := c :: cs₁ }, i := i₁ + { data := cs₂ }.get i₂ + c }
      { s := { data := c :: cs₂ }, i := i₂ + { data := cs₂ }.get i₂ + c } =
    ltb { s := { data := cs₁ }, i := i₁ + { data := cs₂ }.get i₂ }
      { s := { data := cs₂ }, i := i₂ + { data := cs₂ }.get i₂ }
⊢ ltb { s := { data := c :: cs₁ }, i := i₁ + c + { data := cs₂ }.get i₂ }
      { s := { data := c :: cs₂ }, i := i₂ + c + { data := cs₂ }.get i₂ } =
    ltb { s := { data := cs₁ }, i := i₁ + { data := cs₂ }.get i₂ }
      { s := { data := cs₂ }, i := i₂ + { data := cs₂ }.get i₂ }

tactic: repeat rw [Pos.addChar_right_comm _ c]
state_before: case ind
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
h₂ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
h₁ : { s := { data := cs₁ }, i := i₁ }.hasNext = true
heq : { data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
ih :
  ltb { s := { data := c :: cs₁ }, i := i₁ + { data := cs₂ }.get i₂ + c }
      { s := { data := c :: cs₂ }, i := i₂ + { data := cs₂ }.get i₂ + c } =
    ltb { s := { data := cs₁ }, i := i₁ + { data := cs₂ }.get i₂ }
      { s := { data := cs₂ }, i := i₂ + { data := cs₂ }.get i₂ }
⊢ ltb { s := { data := c :: cs₁ }, i := i₁ + c + { data := cs₂ }.get i₂ }
      { s := { data := c :: cs₂ }, i := i₂ + c + { data := cs₂ }.get i₂ } =
    ltb { s := { data := cs₁ }, i := i₁ + { data := cs₂ }.get i₂ }
      { s := { data := cs₂ }, i := i₂ + { data := cs₂ }.get i₂ }
state_after: case ind
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
h₂ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
h₁ : { s := { data := cs₁ }, i := i₁ }.hasNext = true
heq : { data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
ih :
  ltb { s := { data := c :: cs₁ }, i := i₁ + { data := cs₂ }.get i₂ + c }
      { s := { data := c :: cs₂ }, i := i₂ + { data := cs₂ }.get i₂ + c } =
    ltb { s := { data := cs₁ }, i := i₁ + { data := cs₂ }.get i₂ }
      { s := { data := cs₂ }, i := i₂ + { data := cs₂ }.get i₂ }
⊢ ltb { s := { data := c :: cs₁ }, i := i₁ + { data := cs₂ }.get i₂ + c }
      { s := { data := c :: cs₂ }, i := i₂ + { data := cs₂ }.get i₂ + c } =
    ltb { s := { data := cs₁ }, i := i₁ + { data := cs₂ }.get i₂ }
      { s := { data := cs₂ }, i := i₂ + { data := cs₂ }.get i₂ }

tactic: exact ih
state_before: case ind
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
h₂ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
h₁ : { s := { data := cs₁ }, i := i₁ }.hasNext = true
heq : { data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
ih :
  ltb { s := { data := c :: cs₁ }, i := i₁ + { data := cs₂ }.get i₂ + c }
      { s := { data := c :: cs₂ }, i := i₂ + { data := cs₂ }.get i₂ + c } =
    ltb { s := { data := cs₁ }, i := i₁ + { data := cs₂ }.get i₂ }
      { s := { data := cs₂ }, i := i₂ + { data := cs₂ }.get i₂ }
⊢ ltb { s := { data := c :: cs₁ }, i := i₁ + { data := cs₂ }.get i₂ + c }
      { s := { data := c :: cs₂ }, i := i₂ + { data := cs₂ }.get i₂ + c } =
    ltb { s := { data := cs₁ }, i := i₁ + { data := cs₂ }.get i₂ }
      { s := { data := cs₂ }, i := i₂ + { data := cs₂ }.get i₂ }
state_after: no goals

tactic: rw [Pos.addChar_right_comm _ c]
state_before: case ind
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
h₂ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
h₁ : { s := { data := cs₁ }, i := i₁ }.hasNext = true
heq : { data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
ih :
  ltb { s := { data := c :: cs₁ }, i := i₁ + { data := cs₂ }.get i₂ + c }
      { s := { data := c :: cs₂ }, i := i₂ + { data := cs₂ }.get i₂ + c } =
    ltb { s := { data := cs₁ }, i := i₁ + { data := cs₂ }.get i₂ }
      { s := { data := cs₂ }, i := i₂ + { data := cs₂ }.get i₂ }
⊢ ltb { s := { data := c :: cs₁ }, i := i₁ + { data := cs₂ }.get i₂ + c }
      { s := { data := c :: cs₂ }, i := i₂ + c + { data := cs₂ }.get i₂ } =
    ltb { s := { data := cs₁ }, i := i₁ + { data := cs₂ }.get i₂ }
      { s := { data := cs₂ }, i := i₂ + { data := cs₂ }.get i₂ }
state_after: case ind
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
h₂ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
h₁ : { s := { data := cs₁ }, i := i₁ }.hasNext = true
heq : { data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
ih :
  ltb { s := { data := c :: cs₁ }, i := i₁ + { data := cs₂ }.get i₂ + c }
      { s := { data := c :: cs₂ }, i := i₂ + { data := cs₂ }.get i₂ + c } =
    ltb { s := { data := cs₁ }, i := i₁ + { data := cs₂ }.get i₂ }
      { s := { data := cs₂ }, i := i₂ + { data := cs₂ }.get i₂ }
⊢ ltb { s := { data := c :: cs₁ }, i := i₁ + { data := cs₂ }.get i₂ + c }
      { s := { data := c :: cs₂ }, i := i₂ + { data := cs₂ }.get i₂ + c } =
    ltb { s := { data := cs₁ }, i := i₁ + { data := cs₂ }.get i₂ }
      { s := { data := cs₂ }, i := i₂ + { data := cs₂ }.get i₂ }

tactic: rename_i h₂ h₁ hne
state_before: case eq
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
a✝² : { s := { data := cs₂ }, i := i₂ }.hasNext = true
a✝¹ : { s := { data := cs₁ }, i := i₁ }.hasNext = true
a✝ : ¬{ data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
⊢ (if { s := { data := c :: cs₁ }, i := i₁ + c }.curr = { s := { data := c :: cs₂ }, i := i₂ + c }.curr then
      ltb { s := { data := c :: cs₁ }, i := i₁ + c }.next { s := { data := c :: cs₂ }, i := i₂ + c }.next
    else decide ({ s := { data := c :: cs₁ }, i := i₁ + c }.curr < { s := { data := c :: cs₂ }, i := i₂ + c }.curr)) =
    if { s := { data := cs₁ }, i := i₁ }.curr = { s := { data := cs₂ }, i := i₂ }.curr then
      ltb { s := { data := cs₁ }, i := i₁ }.next { s := { data := cs₂ }, i := i₂ }.next
    else decide ({ s := { data := cs₁ }, i := i₁ }.curr < { s := { data := cs₂ }, i := i₂ }.curr)
state_after: case eq
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
h₂ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
h₁ : { s := { data := cs₁ }, i := i₁ }.hasNext = true
hne : ¬{ data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
⊢ (if { s := { data := c :: cs₁ }, i := i₁ + c }.curr = { s := { data := c :: cs₂ }, i := i₂ + c }.curr then
      ltb { s := { data := c :: cs₁ }, i := i₁ + c }.next { s := { data := c :: cs₂ }, i := i₂ + c }.next
    else decide ({ s := { data := c :: cs₁ }, i := i₁ + c }.curr < { s := { data := c :: cs₂ }, i := i₂ + c }.curr)) =
    if { s := { data := cs₁ }, i := i₁ }.curr = { s := { data := cs₂ }, i := i₂ }.curr then
      ltb { s := { data := cs₁ }, i := i₁ }.next { s := { data := cs₂ }, i := i₂ }.next
    else decide ({ s := { data := cs₁ }, i := i₁ }.curr < { s := { data := cs₂ }, i := i₂ }.curr)

tactic: simp [Iterator.curr, get_cons_addChar, hne]
state_before: case eq
c : Char
cs₁✝ cs₂✝ : List Char
i₁✝ i₂✝ : Pos
cs₁ cs₂ : List Char
i₁ i₂ : Pos
h₂ : { s := { data := cs₂ }, i := i₂ }.hasNext = true
h₁ : { s := { data := cs₁ }, i := i₁ }.hasNext = true
hne : ¬{ data := cs₁ }.get i₁ = { data := cs₂ }.get i₂
⊢ (if { s := { data := c :: cs₁ }, i := i₁ + c }.curr = { s := { data := c :: cs₂ }, i := i₂ + c }.curr then
      ltb { s := { data := c :: cs₁ }, i := i₁ + c }.next { s := { data := c :: cs₂ }, i := i₂ + c }.next
    else decide ({ s := { data := c :: cs₁ }, i := i₁ + c }.curr < { s := { data := c :: cs₂ }, i := i₂ + c }.curr)) =
    if { s := { data := cs₁ }, i := i₁ }.curr = { s := { data := cs₂ }, i := i₂ }.curr then
      ltb { s := { data := cs₁ }, i := i₁ }.next { s := { data := cs₂ }, i := i₂ }.next
    else decide ({ s := { data := cs₁ }, i := i₁ }.curr < { s := { data := cs₂ }, i := i₂ }.curr)
state_after: no goals