-- Mathlib/Computability/DFA.lean
theorem evalFrom_of_pow {x y : List α} {s : σ} (hx : M.evalFrom s x = s)
    (hy : y ∈ ({x} : Language α)∗) : M.evalFrom s y = s

Proof state:
case intro.intro.nil
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
hS : ∀ y ∈ [], y ∈ {x}
⊢ M.evalFrom s [].flatten = s

Tactic:
rfl

Result:
no goals

Proof state:
case intro.intro
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
S : List (List α)
hS : ∀ y ∈ S, y ∈ {x}
⊢ M.evalFrom s S.flatten = s

Tactic:
induction' S with a S ih

Result:
case intro.intro.nil
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
hS : ∀ y ∈ [], y ∈ {x}
⊢ M.evalFrom s [].flatten = s

case intro.intro.cons
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
a : List α
S : List (List α)
ih : (∀ y ∈ S, y ∈ {x}) → M.evalFrom s S.flatten = s
hS : ∀ y ∈ a :: S, y ∈ {x}
⊢ M.evalFrom s (a :: S).flatten = s

Proof state:
case intro.intro.cons
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
a : List α
S : List (List α)
ih : (∀ y ∈ S, y ∈ {x}) → M.evalFrom s S.flatten = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a ∈ {x}
⊢ M.evalFrom s (a :: S).flatten = s

Tactic:
rw [Set.mem_singleton_iff] at ha

Result:
case intro.intro.cons
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
a : List α
S : List (List α)
ih : (∀ y ∈ S, y ∈ {x}) → M.evalFrom s S.flatten = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
⊢ M.evalFrom s (a :: S).flatten = s

Proof state:
α : Type u
σ : Type v
M : DFA α σ
x y : List α
s : σ
hx : M.evalFrom s x = s
hy : ∃ L, y = L.flatten ∧ ∀ y ∈ L, y ∈ {x}
⊢ M.evalFrom s y = s

Tactic:
rcases hy with ⟨S, rfl, hS⟩

Result:
case intro.intro
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
S : List (List α)
hS : ∀ y ∈ S, y ∈ {x}
⊢ M.evalFrom s S.flatten = s

Proof state:
α : Type u
σ : Type v
M : DFA α σ
x y : List α
s : σ
hx : M.evalFrom s x = s
hy : y ∈ {x}∗
⊢ M.evalFrom s y = s

Tactic:
rw [Language.mem_kstar] at hy

Result:
α : Type u
σ : Type v
M : DFA α σ
x y : List α
s : σ
hx : M.evalFrom s x = s
hy : ∃ L, y = L.flatten ∧ ∀ y ∈ L, y ∈ {x}
⊢ M.evalFrom s y = s

Proof state:
case intro.intro.cons
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
a : List α
S : List (List α)
ih : (∀ y ∈ S, y ∈ {x}) → M.evalFrom s S.flatten = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
z : List α
hz : z ∈ S
⊢ z ∈ {x}

Tactic:
exact hS z (List.mem_cons_of_mem a hz)

Result:
no goals

Proof state:
case intro.intro.cons
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
a : List α
S : List (List α)
ih : (∀ y ∈ S, y ∈ {x}) → M.evalFrom s S.flatten = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
⊢ M.evalFrom s (a :: S).flatten = s

Tactic:
rw [List.flatten, evalFrom_of_append, ha, hx]

Result:
case intro.intro.cons
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
a : List α
S : List (List α)
ih : (∀ y ∈ S, y ∈ {x}) → M.evalFrom s S.flatten = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
⊢ M.evalFrom s S.flatten = s

Proof state:
case intro.intro.cons
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
a : List α
S : List (List α)
ih : (∀ y ∈ S, y ∈ {x}) → M.evalFrom s S.flatten = s
hS : ∀ y ∈ a :: S, y ∈ {x}
⊢ M.evalFrom s (a :: S).flatten = s

Tactic:
have ha := hS a (List.mem_cons_self _ _)

Result:
case intro.intro.cons
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
a : List α
S : List (List α)
ih : (∀ y ∈ S, y ∈ {x}) → M.evalFrom s S.flatten = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a ∈ {x}
⊢ M.evalFrom s (a :: S).flatten = s

Proof state:
case intro.intro.cons
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
a : List α
S : List (List α)
ih : (∀ y ∈ S, y ∈ {x}) → M.evalFrom s S.flatten = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
⊢ M.evalFrom s S.flatten = s

Tactic:
apply ih

Result:
case intro.intro.cons
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
a : List α
S : List (List α)
ih : (∀ y ∈ S, y ∈ {x}) → M.evalFrom s S.flatten = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
⊢ ∀ y ∈ S, y ∈ {x}

Proof state:
case intro.intro.cons
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
a : List α
S : List (List α)
ih : (∀ y ∈ S, y ∈ {x}) → M.evalFrom s S.flatten = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
⊢ ∀ y ∈ S, y ∈ {x}

Tactic:
intro z hz

Result:
case intro.intro.cons
α : Type u
σ : Type v
M : DFA α σ
x : List α
s : σ
hx : M.evalFrom s x = s
a : List α
S : List (List α)
ih : (∀ y ∈ S, y ∈ {x}) → M.evalFrom s S.flatten = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
z : List α
hz : z ∈ S
⊢ z ∈ {x}