Theorem: DFA.evalFrom_of_pow
File: Mathlib/Computability/DFA.lean

tactic: rw [Language.mem_kstar] at hy
state_before: α : Type u
σ : Type v
M : DFA α σ
x y : List α
s : σ
hx : M.evalFrom s x = s
hy : y ∈ {x}∗
⊢ M.evalFrom s y = s
state_after: α : Type u
σ : Type v
M : DFA α σ
x y : List α
s : σ
hx : M.evalFrom s x = s
hy : ∃ L, y = L.join ∧ ∀ y ∈ L, y ∈ {x}
⊢ M.evalFrom s y = s

tactic: rcases hy with ⟨S, rfl, hS⟩
state_before: α : Type u
σ : Type v
M : DFA α σ
x y : List α
s : σ
hx : M.evalFrom s x = s
hy : ∃ L, y = L.join ∧ ∀ y ∈ L, y ∈ {x}
⊢ M.evalFrom s y = s
state_after: 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.join = s

tactic: induction' S with a S ih
state_before: 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.join = s
state_after: 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 [].join = 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.join = s
hS : ∀ y ∈ a :: S, y ∈ {x}
⊢ M.evalFrom s (a :: S).join = s

tactic: rfl
state_before: 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 [].join = s
state_after: no goals

tactic: have ha := hS a (List.mem_cons_self _ _)
state_before: 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.join = s
hS : ∀ y ∈ a :: S, y ∈ {x}
⊢ M.evalFrom s (a :: S).join = s
state_after: 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.join = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a ∈ {x}
⊢ M.evalFrom s (a :: S).join = s

tactic: rw [Set.mem_singleton_iff] at ha
state_before: 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.join = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a ∈ {x}
⊢ M.evalFrom s (a :: S).join = s
state_after: 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.join = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
⊢ M.evalFrom s (a :: S).join = s

tactic: rw [List.join, evalFrom_of_append, ha, hx]
state_before: 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.join = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
⊢ M.evalFrom s (a :: S).join = s
state_after: 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.join = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
⊢ M.evalFrom s S.join = s

tactic: apply ih
state_before: 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.join = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
⊢ M.evalFrom s S.join = s
state_after: 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.join = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
⊢ ∀ y ∈ S, y ∈ {x}

tactic: intro z hz
state_before: 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.join = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
⊢ ∀ y ∈ S, y ∈ {x}
state_after: 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.join = 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)
state_before: 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.join = s
hS : ∀ y ∈ a :: S, y ∈ {x}
ha : a = x
z : List α
hz : z ∈ S
⊢ z ∈ {x}
state_after: no goals