Theorem: RegularExpression.star_rmatch_iff
File: Mathlib/Computability/RegularExpressions.lean

tactic: have IH := fun t (_h : List.length t < List.length x) => star_rmatch_iff P t
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
x : List α
⊢ P.star.rmatch x = true ↔ ∃ S, x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
x : List α
IH :
  ∀ (t : List α), t.length < x.length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
⊢ P.star.rmatch x = true ↔ ∃ S, x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
x : List α
IH :
  ∀ (t : List α), t.length < x.length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
⊢ P.star.rmatch x = true ↔ ∃ S, x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
x : List α
IH :
  ∀ (t : List α), t.length < x.length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
⊢ P.star.rmatch x = true → ∃ S, x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
x : List α
IH :
  ∀ (t : List α), t.length < x.length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
⊢ (∃ S, x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true) → P.star.rmatch x = true

tactic: cases' x with a x
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
x : List α
IH :
  ∀ (t : List α), t.length < x.length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
⊢ P.star.rmatch x = true → ∃ S, x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
state_after: case mp.nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
IH :
  ∀ (t : List α),
    t.length < [].length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
⊢ P.star.rmatch [] = true → ∃ S, [] = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true

case mp.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
⊢ P.star.rmatch (a :: x) = true → ∃ S, a :: x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true

tactic: intro _h
state_before: case mp.nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
IH :
  ∀ (t : List α),
    t.length < [].length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
⊢ P.star.rmatch [] = true → ∃ S, [] = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
state_after: case mp.nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
IH :
  ∀ (t : List α),
    t.length < [].length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
_h : P.star.rmatch [] = true
⊢ ∃ S, [] = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true

tactic: use []
state_before: case mp.nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
IH :
  ∀ (t : List α),
    t.length < [].length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
_h : P.star.rmatch [] = true
⊢ ∃ S, [] = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
IH :
  ∀ (t : List α),
    t.length < [].length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
_h : P.star.rmatch [] = true
⊢ [] = [].join ∧ ∀ t ∈ [], t ≠ [] ∧ P.rmatch t = true

tactic: dsimp
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
IH :
  ∀ (t : List α),
    t.length < [].length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
_h : P.star.rmatch [] = true
⊢ [] = [].join ∧ ∀ t ∈ [], t ≠ [] ∧ P.rmatch t = true
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
IH :
  ∀ (t : List α),
    t.length < [].length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
_h : P.star.rmatch [] = true
⊢ [] = [] ∧ ∀ t ∈ [], ¬t = [] ∧ P.rmatch t = true

tactic: tauto
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
IH :
  ∀ (t : List α),
    t.length < [].length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
_h : P.star.rmatch [] = true
⊢ [] = [] ∧ ∀ t ∈ [], ¬t = [] ∧ P.rmatch t = true
state_after: no goals

tactic: rw [rmatch, deriv, mul_rmatch_iff]
state_before: case mp.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
⊢ P.star.rmatch (a :: x) = true → ∃ S, a :: x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
state_after: case mp.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
⊢ (∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true) →
    ∃ S, a :: x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true

tactic: rintro ⟨t, u, hs, ht, hu⟩
state_before: case mp.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
⊢ (∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true) →
    ∃ S, a :: x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
state_after: case mp.cons.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hu : P.star.rmatch u = true
⊢ ∃ S, a :: x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true

tactic: have hwf : u.length < (List.cons a x).length := by
  rw [hs, List.length_cons, List.length_append]
  omega
state_before: case mp.cons.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hu : P.star.rmatch u = true
⊢ ∃ S, a :: x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
state_after: case mp.cons.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hu : P.star.rmatch u = true
hwf : u.length < (a :: x).length
⊢ ∃ S, a :: x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true

tactic: rw [IH _ hwf] at hu
state_before: case mp.cons.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hu : P.star.rmatch u = true
hwf : u.length < (a :: x).length
⊢ ∃ S, a :: x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
state_after: case mp.cons.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hu : ∃ S, u = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
hwf : u.length < (a :: x).length
⊢ ∃ S, a :: x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true

tactic: rcases hu with ⟨S', hsum, helem⟩
state_before: case mp.cons.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hu : ∃ S, u = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
hwf : u.length < (a :: x).length
⊢ ∃ S, a :: x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
state_after: case mp.cons.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
⊢ ∃ S, a :: x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true

tactic: use (a :: t) :: S'
state_before: case mp.cons.intro.intro.intro.intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
⊢ ∃ S, a :: x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
⊢ a :: x = ((a :: t) :: S').join ∧ ∀ t_1 ∈ (a :: t) :: S', t_1 ≠ [] ∧ P.rmatch t_1 = true

tactic: constructor
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
⊢ a :: x = ((a :: t) :: S').join ∧ ∀ t_1 ∈ (a :: t) :: S', t_1 ≠ [] ∧ P.rmatch t_1 = true
state_after: case h.left
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
⊢ a :: x = ((a :: t) :: S').join

case h.right
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
⊢ ∀ t_1 ∈ (a :: t) :: S', t_1 ≠ [] ∧ P.rmatch t_1 = true

tactic: rw [hs, List.length_cons, List.length_append]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hu : P.star.rmatch u = true
⊢ u.length < (a :: x).length
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hu : P.star.rmatch u = true
⊢ u.length < t.length + u.length + 1

tactic: omega
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hu : P.star.rmatch u = true
⊢ u.length < t.length + u.length + 1
state_after: no goals

tactic: simp [hs, hsum]
state_before: case h.left
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
⊢ a :: x = ((a :: t) :: S').join
state_after: no goals

tactic: intro t' ht'
state_before: case h.right
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
⊢ ∀ t_1 ∈ (a :: t) :: S', t_1 ≠ [] ∧ P.rmatch t_1 = true
state_after: case h.right
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
t' : List α
ht' : t' ∈ (a :: t) :: S'
⊢ t' ≠ [] ∧ P.rmatch t' = true

tactic: cases ht' with
| head ht' =>
  simp only [ne_eq, not_false_iff, true_and, rmatch]
  exact ht
| tail _ ht' => exact helem t' ht'
state_before: case h.right
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
t' : List α
ht' : t' ∈ (a :: t) :: S'
⊢ t' ≠ [] ∧ P.rmatch t' = true
state_after: no goals

tactic: simp only [ne_eq, not_false_iff, true_and, rmatch]
state_before: case h.right.head
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
⊢ a :: t ≠ [] ∧ P.rmatch (a :: t) = true
state_after: case h.right.head
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
⊢ (P.deriv a).rmatch t = true

tactic: exact ht
state_before: case h.right.head
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
⊢ (P.deriv a).rmatch t = true
state_after: no goals

tactic: exact helem t' ht'
state_before: case h.right.tail
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t u : List α
hs : x = t ++ u
ht : (P.deriv a).rmatch t = true
hwf : u.length < (a :: x).length
S' : List (List α)
hsum : u = S'.join
helem : ∀ t ∈ S', t ≠ [] ∧ P.rmatch t = true
t' : List α
ht' : Mem t' S'
⊢ t' ≠ [] ∧ P.rmatch t' = true
state_after: no goals

tactic: rintro ⟨S, hsum, helem⟩
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
x : List α
IH :
  ∀ (t : List α), t.length < x.length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
⊢ (∃ S, x = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true) → P.star.rmatch x = true
state_after: case mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
x : List α
IH :
  ∀ (t : List α), t.length < x.length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
S : List (List α)
hsum : x = S.join
helem : ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
⊢ P.star.rmatch x = true

tactic: cases' x with a x
state_before: case mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
x : List α
IH :
  ∀ (t : List α), t.length < x.length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
S : List (List α)
hsum : x = S.join
helem : ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
⊢ P.star.rmatch x = true
state_after: case mpr.intro.intro.nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
S : List (List α)
helem : ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
IH :
  ∀ (t : List α),
    t.length < [].length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
hsum : [] = S.join
⊢ P.star.rmatch [] = true

case mpr.intro.intro.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
S : List (List α)
helem : ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
hsum : a :: x = S.join
⊢ P.star.rmatch (a :: x) = true

tactic: rfl
state_before: case mpr.intro.intro.nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a b : α
P : RegularExpression α
S : List (List α)
helem : ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
IH :
  ∀ (t : List α),
    t.length < [].length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
hsum : [] = S.join
⊢ P.star.rmatch [] = true
state_after: no goals

tactic: rw [rmatch, deriv, mul_rmatch_iff]
state_before: case mpr.intro.intro.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
S : List (List α)
helem : ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
hsum : a :: x = S.join
⊢ P.star.rmatch (a :: x) = true
state_after: case mpr.intro.intro.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
S : List (List α)
helem : ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
hsum : a :: x = S.join
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true

tactic: cases' S with t' U
state_before: case mpr.intro.intro.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
S : List (List α)
helem : ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
hsum : a :: x = S.join
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true
state_after: case mpr.intro.intro.cons.nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
helem : ∀ t ∈ [], t ≠ [] ∧ P.rmatch t = true
hsum : a :: x = [].join
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true

case mpr.intro.intro.cons.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t' : List α
U : List (List α)
helem : ∀ t ∈ t' :: U, t ≠ [] ∧ P.rmatch t = true
hsum : a :: x = (t' :: U).join
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true

tactic: exact ⟨[], [], by tauto⟩
state_before: case mpr.intro.intro.cons.nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
helem : ∀ t ∈ [], t ≠ [] ∧ P.rmatch t = true
hsum : a :: x = [].join
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true
state_after: no goals

tactic: tauto
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
helem : ∀ t ∈ [], t ≠ [] ∧ P.rmatch t = true
hsum : a :: x = [].join
⊢ x = [] ++ [] ∧ (P.deriv a).rmatch [] = true ∧ P.star.rmatch [] = true
state_after: no goals

tactic: cases' t' with b t
state_before: case mpr.intro.intro.cons.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
t' : List α
U : List (List α)
helem : ∀ t ∈ t' :: U, t ≠ [] ∧ P.rmatch t = true
hsum : a :: x = (t' :: U).join
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true
state_after: case mpr.intro.intro.cons.cons.nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
helem : ∀ t ∈ [] :: U, t ≠ [] ∧ P.rmatch t = true
hsum : a :: x = ([] :: U).join
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true

case mpr.intro.intro.cons.cons.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a :: x = ((b :: t) :: U).join
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true

tactic: simp only [List.join, List.cons_append, List.cons_eq_cons] at hsum
state_before: case mpr.intro.intro.cons.cons.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a :: x = ((b :: t) :: U).join
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true
state_after: case mpr.intro.intro.cons.cons.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true

tactic: refine ⟨t, U.join, hsum.2, ?_, ?_⟩
state_before: case mpr.intro.intro.cons.cons.cons
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true
state_after: case mpr.intro.intro.cons.cons.cons.refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
⊢ (P.deriv a).rmatch t = true

case mpr.intro.intro.cons.cons.cons.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
⊢ P.star.rmatch U.join = true

tactic: simp only [forall_eq_or_imp, List.mem_cons] at helem
state_before: case mpr.intro.intro.cons.cons.nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
helem : ∀ t ∈ [] :: U, t ≠ [] ∧ P.rmatch t = true
hsum : a :: x = ([] :: U).join
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true
state_after: case mpr.intro.intro.cons.cons.nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
hsum : a :: x = ([] :: U).join
helem : ([] ≠ [] ∧ P.rmatch [] = true) ∧ ∀ a ∈ U, a ≠ [] ∧ P.rmatch a = true
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true

tactic: simp only [eq_self_iff_true, not_true, Ne, false_and_iff] at helem
state_before: case mpr.intro.intro.cons.cons.nil
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
hsum : a :: x = ([] :: U).join
helem : ([] ≠ [] ∧ P.rmatch [] = true) ∧ ∀ a ∈ U, a ≠ [] ∧ P.rmatch a = true
⊢ ∃ t u, x = t ++ u ∧ (P.deriv a).rmatch t = true ∧ P.star.rmatch u = true
state_after: no goals

tactic: specialize helem (b :: t) (by simp)
state_before: case mpr.intro.intro.cons.cons.cons.refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
⊢ (P.deriv a).rmatch t = true
state_after: case mpr.intro.intro.cons.cons.cons.refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
hsum : a = b ∧ x = t ++ U.join
helem : b :: t ≠ [] ∧ P.rmatch (b :: t) = true
⊢ (P.deriv a).rmatch t = true

tactic: rw [rmatch] at helem
state_before: case mpr.intro.intro.cons.cons.cons.refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
hsum : a = b ∧ x = t ++ U.join
helem : b :: t ≠ [] ∧ P.rmatch (b :: t) = true
⊢ (P.deriv a).rmatch t = true
state_after: case mpr.intro.intro.cons.cons.cons.refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
hsum : a = b ∧ x = t ++ U.join
helem : b :: t ≠ [] ∧ (P.deriv b).rmatch t = true
⊢ (P.deriv a).rmatch t = true

tactic: convert helem.2
state_before: case mpr.intro.intro.cons.cons.cons.refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
hsum : a = b ∧ x = t ++ U.join
helem : b :: t ≠ [] ∧ (P.deriv b).rmatch t = true
⊢ (P.deriv a).rmatch t = true
state_after: case h.e'_2.h.e'_3.h.e'_4
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
hsum : a = b ∧ x = t ++ U.join
helem : b :: t ≠ [] ∧ (P.deriv b).rmatch t = true
⊢ a = b

tactic: exact hsum.1
state_before: case h.e'_2.h.e'_3.h.e'_4
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
hsum : a = b ∧ x = t ++ U.join
helem : b :: t ≠ [] ∧ (P.deriv b).rmatch t = true
⊢ a = b
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
⊢ b :: t ∈ (b :: t) :: U
state_after: no goals

tactic: have hwf : U.join.length < (List.cons a x).length := by
  rw [hsum.1, hsum.2]
  simp only [List.length_append, List.length_join, List.length]
  omega
state_before: case mpr.intro.intro.cons.cons.cons.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
⊢ P.star.rmatch U.join = true
state_after: case mpr.intro.intro.cons.cons.cons.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
hwf : U.join.length < (a :: x).length
⊢ P.star.rmatch U.join = true

tactic: rw [IH _ hwf]
state_before: case mpr.intro.intro.cons.cons.cons.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
hwf : U.join.length < (a :: x).length
⊢ P.star.rmatch U.join = true
state_after: case mpr.intro.intro.cons.cons.cons.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
hwf : U.join.length < (a :: x).length
⊢ ∃ S, U.join = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true

tactic: refine ⟨U, rfl, fun t h => helem t ?_⟩
state_before: case mpr.intro.intro.cons.cons.cons.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
hwf : U.join.length < (a :: x).length
⊢ ∃ S, U.join = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true
state_after: case mpr.intro.intro.cons.cons.cons.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t✝ : List α
helem : ∀ t ∈ (b :: t✝) :: U, t ≠ [] ∧ P.rmatch t = true
hsum : a = b ∧ x = t✝ ++ U.join
hwf : U.join.length < (a :: x).length
t : List α
h : t ∈ U
⊢ t ∈ (b :: t✝) :: U

tactic: right
state_before: case mpr.intro.intro.cons.cons.cons.refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t✝ : List α
helem : ∀ t ∈ (b :: t✝) :: U, t ≠ [] ∧ P.rmatch t = true
hsum : a = b ∧ x = t✝ ++ U.join
hwf : U.join.length < (a :: x).length
t : List α
h : t ∈ U
⊢ t ∈ (b :: t✝) :: U
state_after: case mpr.intro.intro.cons.cons.cons.refine_2.a
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t✝ : List α
helem : ∀ t ∈ (b :: t✝) :: U, t ≠ [] ∧ P.rmatch t = true
hsum : a = b ∧ x = t✝ ++ U.join
hwf : U.join.length < (a :: x).length
t : List α
h : t ∈ U
⊢ Mem t U

tactic: assumption
state_before: case mpr.intro.intro.cons.cons.cons.refine_2.a
α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t✝ : List α
helem : ∀ t ∈ (b :: t✝) :: U, t ≠ [] ∧ P.rmatch t = true
hsum : a = b ∧ x = t✝ ++ U.join
hwf : U.join.length < (a :: x).length
t : List α
h : t ∈ U
⊢ Mem t U
state_after: no goals

tactic: rw [hsum.1, hsum.2]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
⊢ U.join.length < (a :: x).length
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
⊢ U.join.length < (b :: (t ++ U.join)).length

tactic: simp only [List.length_append, List.length_join, List.length]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
⊢ U.join.length < (b :: (t ++ U.join)).length
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
⊢ (map length U).sum < t.length + (map length U).sum + 1

tactic: omega
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
dec : DecidableEq α
a✝ b✝ : α
P : RegularExpression α
a : α
x : List α
IH :
  ∀ (t : List α),
    t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.join ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)
U : List (List α)
b : α
t : List α
helem : ∀ t_1 ∈ (b :: t) :: U, t_1 ≠ [] ∧ P.rmatch t_1 = true
hsum : a = b ∧ x = t ++ U.join
⊢ (map length U).sum < t.length + (map length U).sum + 1
state_after: no goals