Theorem: Regex.NFA.pathToNext_of_matches (RegexCorrectness/NFA/Transition/Path/Equivalence/PathOfMatch.lean)

State before:
nfa : NFA
next : Fin nfa.nodes.size
r : Data.Expr
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
cs : List Char
eq : nfa.pushRegex next r = nfa'
m : Data.Expr.matches cs r
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) cs
Tactic:
induction m generalizing nfa next with
| sparse cls c hmem =>
  have : nfa.nodes.size ≤ nfa'.val.start.val := ge_pushRegex_start eq
  refine ⟨
    nfa'.val.start,
    [],
    [c],
    rfl,
    .base this,
    .charStep this nfa'.val.start.isLt ?_
  ⟩
  rw [←eq]
  simp [pushRegex, Node.charStep, hmem]
| char c =>
  have : nfa.nodes.size ≤ nfa'.val.start.val := ge_pushRegex_start eq
  refine ⟨
    nfa'.val.start,
    [],
    [c],
    rfl,
    .base this,
    .charStep this nfa'.val.start.isLt ?_
  ⟩
  rw [←eq]
  simp [pushRegex, Node.charStep]
| epsilon =>
  have : nfa.nodes.size ≤ nfa'.val.start.val := ge_pushRegex_start eq
  refine ⟨nfa'.val.start, [], [], rfl, .base this, .εStep this nfa'.val.start.isLt ?_⟩
  rw [←eq]
  simp [pushRegex, Node.εStep]
| group _ ih => exact pathToNext_of_matches.group eq ih
| alternateLeft _ ih => exact pathToNext_of_matches.alternateLeft eq ih
| alternateRight _ ih => exact pathToNext_of_matches.alternateRight eq ih
| concat cs₁ cs₂ r₁ r₂ _ _ ih₁ ih₂ => exact pathToNext_of_matches.concat eq ih₁ ih₂
| starEpsilon =>
  have : nfa.nodes.size ≤ nfa'.val.start.val := ge_pushRegex_start eq
  refine ⟨nfa'.val.start, [], [], rfl, .base this, .εStep this nfa'.val.start.isLt ?_⟩
  apply pushRegex.star eq
  intro placeholder compiled patched nfa' isLt inBounds property
    _ _ eq₃ eq₄ eq
  rw[eq]
  have : nfa'.start.val = nfa.nodes.size := by
    rw [eq₄]
  simp [this, eq₄, get_eq_nodes_get, eq₃, Node.εStep]
| starConcat cs₁ cs₂ r _ _ ih₁ ih₂ => exact pathToNext_of_matches.starConcat eq ih₁ ih₂
State after:
no goals

State before:
case sparse
r : Data.Expr
cs : List Char
cls : Data.Classes
c : Char
hmem : c ∈ cls
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.classes cls) = nfa'
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size ↑(↑nfa').start [c]
Tactic:
have : nfa.nodes.size ≤ nfa'.val.start.val := ge_pushRegex_start eq
State after:
case sparse
r : Data.Expr
cs : List Char
cls : Data.Classes
c : Char
hmem : c ∈ cls
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.classes cls) = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size ↑(↑nfa').start [c]

State before:
case sparse
r : Data.Expr
cs : List Char
cls : Data.Classes
c : Char
hmem : c ∈ cls
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.classes cls) = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size ↑(↑nfa').start [c]
Tactic:
refine ⟨
  nfa'.val.start,
  [],
  [c],
  rfl,
  .base this,
  .charStep this nfa'.val.start.isLt ?_
⟩
State after:
case sparse
r : Data.Expr
cs : List Char
cls : Data.Classes
c : Char
hmem : c ∈ cls
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.classes cls) = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈ (↑nfa')[↑(↑nfa').start].charStep c

State before:
case sparse
r : Data.Expr
cs : List Char
cls : Data.Classes
c : Char
hmem : c ∈ cls
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.classes cls) = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈ (↑nfa')[↑(↑nfa').start].charStep c
Tactic:
rw [←eq]
State after:
case sparse
r : Data.Expr
cs : List Char
cls : Data.Classes
c : Char
hmem : c ∈ cls
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.classes cls) = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈
    (↑(nfa.pushRegex next (Data.Expr.classes cls)))[↑(↑(nfa.pushRegex next (Data.Expr.classes cls))).start].charStep c

State before:
case sparse
r : Data.Expr
cs : List Char
cls : Data.Classes
c : Char
hmem : c ∈ cls
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.classes cls) = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈
    (↑(nfa.pushRegex next (Data.Expr.classes cls)))[↑(↑(nfa.pushRegex next (Data.Expr.classes cls))).start].charStep c
Tactic:
simp [pushRegex, Node.charStep, hmem]
State after:
no goals

State before:
case char
r : Data.Expr
cs : List Char
c : Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.char c) = nfa'
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size ↑(↑nfa').start [c]
Tactic:
have : nfa.nodes.size ≤ nfa'.val.start.val := ge_pushRegex_start eq
State after:
case char
r : Data.Expr
cs : List Char
c : Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.char c) = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size ↑(↑nfa').start [c]

State before:
case char
r : Data.Expr
cs : List Char
c : Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.char c) = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size ↑(↑nfa').start [c]
Tactic:
refine ⟨
  nfa'.val.start,
  [],
  [c],
  rfl,
  .base this,
  .charStep this nfa'.val.start.isLt ?_
⟩
State after:
case char
r : Data.Expr
cs : List Char
c : Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.char c) = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈ (↑nfa')[↑(↑nfa').start].charStep c

State before:
case char
r : Data.Expr
cs : List Char
c : Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.char c) = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈ (↑nfa')[↑(↑nfa').start].charStep c
Tactic:
rw [←eq]
State after:
case char
r : Data.Expr
cs : List Char
c : Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.char c) = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈ (↑(nfa.pushRegex next (Data.Expr.char c)))[↑(↑(nfa.pushRegex next (Data.Expr.char c))).start].charStep c

State before:
case char
r : Data.Expr
cs : List Char
c : Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.char c) = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈ (↑(nfa.pushRegex next (Data.Expr.char c)))[↑(↑(nfa.pushRegex next (Data.Expr.char c))).start].charStep c
Tactic:
simp [pushRegex, Node.charStep]
State after:
no goals

State before:
case epsilon
r : Data.Expr
cs : List Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next Data.Expr.epsilon = nfa'
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size ↑(↑nfa').start []
Tactic:
have : nfa.nodes.size ≤ nfa'.val.start.val := ge_pushRegex_start eq
State after:
case epsilon
r : Data.Expr
cs : List Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next Data.Expr.epsilon = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size ↑(↑nfa').start []

State before:
case epsilon
r : Data.Expr
cs : List Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next Data.Expr.epsilon = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size ↑(↑nfa').start []
Tactic:
refine ⟨nfa'.val.start, [], [], rfl, .base this, .εStep this nfa'.val.start.isLt ?_⟩
State after:
case epsilon
r : Data.Expr
cs : List Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next Data.Expr.epsilon = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈ (↑nfa')[↑(↑nfa').start].εStep

State before:
case epsilon
r : Data.Expr
cs : List Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next Data.Expr.epsilon = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈ (↑nfa')[↑(↑nfa').start].εStep
Tactic:
rw [←eq]
State after:
case epsilon
r : Data.Expr
cs : List Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next Data.Expr.epsilon = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈ (↑(nfa.pushRegex next Data.Expr.epsilon))[↑(↑(nfa.pushRegex next Data.Expr.epsilon)).start].εStep

State before:
case epsilon
r : Data.Expr
cs : List Char
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next Data.Expr.epsilon = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈ (↑(nfa.pushRegex next Data.Expr.epsilon))[↑(↑(nfa.pushRegex next Data.Expr.epsilon)).start].εStep
Tactic:
simp [pushRegex, Node.εStep]
State after:
no goals

State before:
case group
r : Data.Expr
cs s✝ : List Char
r✝ : Data.Expr
i✝ : ℕ
m✝ : Data.Expr.matches s✝ r✝
ih :
  ∀ {nfa : NFA} {next : Fin nfa.nodes.size} {nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }},
    nfa.pushRegex next r✝ = nfa' → (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) s✝
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (Data.Expr.group i✝ r✝) = nfa'
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) s✝
Tactic:
exact pathToNext_of_matches.group eq ih
State after:
no goals

State before:
case alternateLeft
r : Data.Expr
cs cs✝ : List Char
r₁✝ r₂✝ : Data.Expr
a✝ : Data.Expr.matches cs✝ r₁✝
ih :
  ∀ {nfa : NFA} {next : Fin nfa.nodes.size} {nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }},
    nfa.pushRegex next r₁✝ = nfa' → (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) cs✝
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (r₁✝.alternate r₂✝) = nfa'
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) cs✝
Tactic:
exact pathToNext_of_matches.alternateLeft eq ih
State after:
no goals

State before:
case alternateRight
r : Data.Expr
cs cs✝ : List Char
r₁✝ r₂✝ : Data.Expr
a✝ : Data.Expr.matches cs✝ r₂✝
ih :
  ∀ {nfa : NFA} {next : Fin nfa.nodes.size} {nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }},
    nfa.pushRegex next r₂✝ = nfa' → (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) cs✝
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (r₁✝.alternate r₂✝) = nfa'
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) cs✝
Tactic:
exact pathToNext_of_matches.alternateRight eq ih
State after:
no goals

State before:
case concat
r : Data.Expr
cs cs₁ cs₂ : List Char
r₁ r₂ : Data.Expr
a✝¹ : Data.Expr.matches cs₁ r₁
a✝ : Data.Expr.matches cs₂ r₂
ih₁ :
  ∀ {nfa : NFA} {next : Fin nfa.nodes.size} {nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }},
    nfa.pushRegex next r₁ = nfa' → (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) cs₁
ih₂ :
  ∀ {nfa : NFA} {next : Fin nfa.nodes.size} {nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }},
    nfa.pushRegex next r₂ = nfa' → (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) cs₂
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next (r₁.concat r₂) = nfa'
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) (cs₁ ++ cs₂)
Tactic:
exact pathToNext_of_matches.concat eq ih₁ ih₂
State after:
no goals

State before:
case starEpsilon
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next r✝.star = nfa'
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size ↑(↑nfa').start []
Tactic:
have : nfa.nodes.size ≤ nfa'.val.start.val := ge_pushRegex_start eq
State after:
case starEpsilon
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next r✝.star = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size ↑(↑nfa').start []

State before:
case starEpsilon
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next r✝.star = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size ↑(↑nfa').start []
Tactic:
refine ⟨nfa'.val.start, [], [], rfl, .base this, .εStep this nfa'.val.start.isLt ?_⟩
State after:
case starEpsilon
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next r✝.star = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈ (↑nfa')[↑(↑nfa').start].εStep

State before:
case starEpsilon
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next r✝.star = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ↑next ∈ (↑nfa')[↑(↑nfa').start].εStep
Tactic:
apply pushRegex.star eq
State after:
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next r✝.star = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ∀ (placeholder : { nfa' // nfa.nodes.size < nfa'.nodes.size })
    (compiled : { nfa' // (↑placeholder).nodes.size < nfa'.nodes.size }) (patched : Array Node) (nfa'_1 : NFA)
    (isLt : nfa.nodes.size < patched.size) (inBounds : ∀ (i : Fin patched.size), patched[↑i].inBounds patched.size)
    (property : nfa.nodes.size < nfa'_1.nodes.size),
    placeholder = nfa.pushNode Node.fail ⋯ →
      compiled = (↑placeholder).pushRegex ⟨nfa.nodes.size, ⋯⟩ r✝ →
        patched = (↑compiled).nodes.set ⟨nfa.nodes.size, ⋯⟩ (Node.split ↑(↑compiled).start ↑next) →
          nfa'_1 = { nodes := patched, start := ⟨nfa.nodes.size, isLt⟩, inBounds := inBounds } →
            nfa' = ⟨nfa'_1, property⟩ → ↑next ∈ (↑nfa')[↑(↑nfa').start].εStep

State before:
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next r✝.star = nfa'
this : nfa.nodes.size ≤ ↑(↑nfa').start
⊢ ∀ (placeholder : { nfa' // nfa.nodes.size < nfa'.nodes.size })
    (compiled : { nfa' // (↑placeholder).nodes.size < nfa'.nodes.size }) (patched : Array Node) (nfa'_1 : NFA)
    (isLt : nfa.nodes.size < patched.size) (inBounds : ∀ (i : Fin patched.size), patched[↑i].inBounds patched.size)
    (property : nfa.nodes.size < nfa'_1.nodes.size),
    placeholder = nfa.pushNode Node.fail ⋯ →
      compiled = (↑placeholder).pushRegex ⟨nfa.nodes.size, ⋯⟩ r✝ →
        patched = (↑compiled).nodes.set ⟨nfa.nodes.size, ⋯⟩ (Node.split ↑(↑compiled).start ↑next) →
          nfa'_1 = { nodes := patched, start := ⟨nfa.nodes.size, isLt⟩, inBounds := inBounds } →
            nfa' = ⟨nfa'_1, property⟩ → ↑next ∈ (↑nfa')[↑(↑nfa').start].εStep
Tactic:
intro placeholder compiled patched nfa' isLt inBounds property
  _ _ eq₃ eq₄ eq
State after:
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa'✝ : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq✝ : nfa.pushRegex next r✝.star = nfa'✝
this : nfa.nodes.size ≤ ↑(↑nfa'✝).start
placeholder : { nfa' // nfa.nodes.size < nfa'.nodes.size }
compiled : { nfa' // (↑placeholder).nodes.size < nfa'.nodes.size }
patched : Array Node
nfa' : NFA
isLt : nfa.nodes.size < patched.size
inBounds : ∀ (i : Fin patched.size), patched[↑i].inBounds patched.size
property : nfa.nodes.size < nfa'.nodes.size
a✝¹ : placeholder = nfa.pushNode Node.fail ⋯
a✝ : compiled = (↑placeholder).pushRegex ⟨nfa.nodes.size, ⋯⟩ r✝
eq₃ : patched = (↑compiled).nodes.set ⟨nfa.nodes.size, ⋯⟩ (Node.split ↑(↑compiled).start ↑next)
eq₄ : nfa' = { nodes := patched, start := ⟨nfa.nodes.size, isLt⟩, inBounds := inBounds }
eq : nfa'✝ = ⟨nfa', property⟩
⊢ ↑next ∈ (↑nfa'✝)[↑(↑nfa'✝).start].εStep

State before:
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa'✝ : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq✝ : nfa.pushRegex next r✝.star = nfa'✝
this : nfa.nodes.size ≤ ↑(↑nfa'✝).start
placeholder : { nfa' // nfa.nodes.size < nfa'.nodes.size }
compiled : { nfa' // (↑placeholder).nodes.size < nfa'.nodes.size }
patched : Array Node
nfa' : NFA
isLt : nfa.nodes.size < patched.size
inBounds : ∀ (i : Fin patched.size), patched[↑i].inBounds patched.size
property : nfa.nodes.size < nfa'.nodes.size
a✝¹ : placeholder = nfa.pushNode Node.fail ⋯
a✝ : compiled = (↑placeholder).pushRegex ⟨nfa.nodes.size, ⋯⟩ r✝
eq₃ : patched = (↑compiled).nodes.set ⟨nfa.nodes.size, ⋯⟩ (Node.split ↑(↑compiled).start ↑next)
eq₄ : nfa' = { nodes := patched, start := ⟨nfa.nodes.size, isLt⟩, inBounds := inBounds }
eq : nfa'✝ = ⟨nfa', property⟩
⊢ ↑next ∈ (↑nfa'✝)[↑(↑nfa'✝).start].εStep
Tactic:
rw[eq]
State after:
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa'✝ : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq✝ : nfa.pushRegex next r✝.star = nfa'✝
this : nfa.nodes.size ≤ ↑(↑nfa'✝).start
placeholder : { nfa' // nfa.nodes.size < nfa'.nodes.size }
compiled : { nfa' // (↑placeholder).nodes.size < nfa'.nodes.size }
patched : Array Node
nfa' : NFA
isLt : nfa.nodes.size < patched.size
inBounds : ∀ (i : Fin patched.size), patched[↑i].inBounds patched.size
property : nfa.nodes.size < nfa'.nodes.size
a✝¹ : placeholder = nfa.pushNode Node.fail ⋯
a✝ : compiled = (↑placeholder).pushRegex ⟨nfa.nodes.size, ⋯⟩ r✝
eq₃ : patched = (↑compiled).nodes.set ⟨nfa.nodes.size, ⋯⟩ (Node.split ↑(↑compiled).start ↑next)
eq₄ : nfa' = { nodes := patched, start := ⟨nfa.nodes.size, isLt⟩, inBounds := inBounds }
eq : nfa'✝ = ⟨nfa', property⟩
⊢ ↑next ∈ (↑⟨nfa', property⟩)[↑(↑⟨nfa', property⟩).start].εStep

State before:
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa'✝ : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq✝ : nfa.pushRegex next r✝.star = nfa'✝
this : nfa.nodes.size ≤ ↑(↑nfa'✝).start
placeholder : { nfa' // nfa.nodes.size < nfa'.nodes.size }
compiled : { nfa' // (↑placeholder).nodes.size < nfa'.nodes.size }
patched : Array Node
nfa' : NFA
isLt : nfa.nodes.size < patched.size
inBounds : ∀ (i : Fin patched.size), patched[↑i].inBounds patched.size
property : nfa.nodes.size < nfa'.nodes.size
a✝¹ : placeholder = nfa.pushNode Node.fail ⋯
a✝ : compiled = (↑placeholder).pushRegex ⟨nfa.nodes.size, ⋯⟩ r✝
eq₃ : patched = (↑compiled).nodes.set ⟨nfa.nodes.size, ⋯⟩ (Node.split ↑(↑compiled).start ↑next)
eq₄ : nfa' = { nodes := patched, start := ⟨nfa.nodes.size, isLt⟩, inBounds := inBounds }
eq : nfa'✝ = ⟨nfa', property⟩
⊢ ↑next ∈ (↑⟨nfa', property⟩)[↑(↑⟨nfa', property⟩).start].εStep
Tactic:
have : nfa'.start.val = nfa.nodes.size := by
  rw [eq₄]
State after:
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa'✝ : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq✝ : nfa.pushRegex next r✝.star = nfa'✝
this✝ : nfa.nodes.size ≤ ↑(↑nfa'✝).start
placeholder : { nfa' // nfa.nodes.size < nfa'.nodes.size }
compiled : { nfa' // (↑placeholder).nodes.size < nfa'.nodes.size }
patched : Array Node
nfa' : NFA
isLt : nfa.nodes.size < patched.size
inBounds : ∀ (i : Fin patched.size), patched[↑i].inBounds patched.size
property : nfa.nodes.size < nfa'.nodes.size
a✝¹ : placeholder = nfa.pushNode Node.fail ⋯
a✝ : compiled = (↑placeholder).pushRegex ⟨nfa.nodes.size, ⋯⟩ r✝
eq₃ : patched = (↑compiled).nodes.set ⟨nfa.nodes.size, ⋯⟩ (Node.split ↑(↑compiled).start ↑next)
eq₄ : nfa' = { nodes := patched, start := ⟨nfa.nodes.size, isLt⟩, inBounds := inBounds }
eq : nfa'✝ = ⟨nfa', property⟩
this : ↑nfa'.start = nfa.nodes.size
⊢ ↑next ∈ (↑⟨nfa', property⟩)[↑(↑⟨nfa', property⟩).start].εStep

State before:
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa'✝ : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq✝ : nfa.pushRegex next r✝.star = nfa'✝
this✝ : nfa.nodes.size ≤ ↑(↑nfa'✝).start
placeholder : { nfa' // nfa.nodes.size < nfa'.nodes.size }
compiled : { nfa' // (↑placeholder).nodes.size < nfa'.nodes.size }
patched : Array Node
nfa' : NFA
isLt : nfa.nodes.size < patched.size
inBounds : ∀ (i : Fin patched.size), patched[↑i].inBounds patched.size
property : nfa.nodes.size < nfa'.nodes.size
a✝¹ : placeholder = nfa.pushNode Node.fail ⋯
a✝ : compiled = (↑placeholder).pushRegex ⟨nfa.nodes.size, ⋯⟩ r✝
eq₃ : patched = (↑compiled).nodes.set ⟨nfa.nodes.size, ⋯⟩ (Node.split ↑(↑compiled).start ↑next)
eq₄ : nfa' = { nodes := patched, start := ⟨nfa.nodes.size, isLt⟩, inBounds := inBounds }
eq : nfa'✝ = ⟨nfa', property⟩
this : ↑nfa'.start = nfa.nodes.size
⊢ ↑next ∈ (↑⟨nfa', property⟩)[↑(↑⟨nfa', property⟩).start].εStep
Tactic:
simp [this, eq₄, get_eq_nodes_get, eq₃, Node.εStep]
State after:
no goals

State before:
r : Data.Expr
cs : List Char
r✝ : Data.Expr
nfa : NFA
next : Fin nfa.nodes.size
nfa'✝ : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq✝ : nfa.pushRegex next r✝.star = nfa'✝
this : nfa.nodes.size ≤ ↑(↑nfa'✝).start
placeholder : { nfa' // nfa.nodes.size < nfa'.nodes.size }
compiled : { nfa' // (↑placeholder).nodes.size < nfa'.nodes.size }
patched : Array Node
nfa' : NFA
isLt : nfa.nodes.size < patched.size
inBounds : ∀ (i : Fin patched.size), patched[↑i].inBounds patched.size
property : nfa.nodes.size < nfa'.nodes.size
a✝¹ : placeholder = nfa.pushNode Node.fail ⋯
a✝ : compiled = (↑placeholder).pushRegex ⟨nfa.nodes.size, ⋯⟩ r✝
eq₃ : patched = (↑compiled).nodes.set ⟨nfa.nodes.size, ⋯⟩ (Node.split ↑(↑compiled).start ↑next)
eq₄ : nfa' = { nodes := patched, start := ⟨nfa.nodes.size, isLt⟩, inBounds := inBounds }
eq : nfa'✝ = ⟨nfa', property⟩
⊢ ↑nfa'.start = nfa.nodes.size
Tactic:
rw [eq₄]
State after:
no goals

State before:
case starConcat
r✝ : Data.Expr
cs cs₁ cs₂ : List Char
r : Data.Expr
a✝¹ : Data.Expr.matches cs₁ r
a✝ : Data.Expr.matches cs₂ r.star
ih₁ :
  ∀ {nfa : NFA} {next : Fin nfa.nodes.size} {nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }},
    nfa.pushRegex next r = nfa' → (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) cs₁
ih₂ :
  ∀ {nfa : NFA} {next : Fin nfa.nodes.size} {nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }},
    nfa.pushRegex next r.star = nfa' → (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) cs₂
nfa : NFA
next : Fin nfa.nodes.size
nfa' : { nfa' // nfa.nodes.size < nfa'.nodes.size }
eq : nfa.pushRegex next r.star = nfa'
⊢ (↑nfa').pathToNext (↑next) nfa.nodes.size (↑(↑nfa').start) (cs₁ ++ cs₂)
Tactic:
exact pathToNext_of_matches.starConcat eq ih₁ ih₂
State after:
no goals