Formalisation of Lecture 3: Covers the definition of DFAs and total DFAs, the corresponding languages and how to obtain a total DFA from a non-total DFA. Grammars are (for now) not part of this formalisation, so in lecture 3 and 4 all things related to grammars and the Chomsky Hierarchy is left out.

Slides for lecture 3 can be found at https://iccl.inf.tu-dresden.de/w/images/e/e2/FS2025-Vorlesung-03-print.pdf

structure DFA (Q : Type u) (Sigma : Type v) [Fintype Q] [Fintype Sigma] : Type (max u v)

We define a DFA as a generic structure with two type parameters Q and Sigma. Definitions in the lecture and textbooks usually define Q and Sigma as finite sets. We already know from lecture 1 that it is sufficient to define Sigma as an arbitrary type. The states however need to be finite, otherwise it would not be a finite automaton. Therefore we require an instance of Fintype for Q. For further information on Fintype please refer to the corresponding file.

δ is a function mapping a state of type Q and a symbol of type Sigma to something of type Option Q. This is how we "encode" that δ is a partial function: if δ(q,a) = None, it is undefined.

• δ : Q → Sigma → Option Q
• q0 : Q
• F : List Q

structure TotalDFA (Q : Type u) (Sigma : Type v) [Fintype Q] [Fintype Sigma] : Type (max u v)

A total DFA is defined like a DFA except for the transition function δ.

• δ : Q → Sigma → Q
• q0 : Q
• F : List Q

def DFA.δ_word {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (dfa : DFA Q Sigma) (q : Q) : Word Sigma → Option Q

The transition function δ of a DFA can be extended to words.

• w = ε: δ_word(q,ε) = q
• w = av (a ∈ Σ, v ∈ Σ*): δ_word(q,av) = δ_word(δ(q,a),v) In case any of the transitions is undefined, δ_word is undefined as well (which is expressed with bind).

Equations

• dfa.δ_word q [] = some q
• dfa.δ_word q (a :: v) = (dfa.δ q a).bind fun (q' : Q) => dfa.δ_word q' v

def TotalDFA.δ_word {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (t_dfa : TotalDFA Q Sigma) (q : Q) : Word Sigma → Q

The transition function δ of a total DFA can be extended to words.

• w = ε: δ_word(q,ε) = q
• w = av (a ∈ Σ, v ∈ Σ*): δ_word(q,av) = δ_word(δ(q,a),v) Contrary to the DFA this function is defined for any pair (q,w) since δ is total.

Equations

• t_dfa.δ_word q [] = q
• t_dfa.δ_word q (a :: v) = t_dfa.δ_word (t_dfa.δ q a) v

def TotalDFA.Language {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (t_dfa : TotalDFA Q Sigma) : _root_.Language Sigma

Given a total DFA, a word w is contained in its language iff the DFA ends up in a final state when reading w.

Equations

• t_dfa.Language w = (t_dfa.δ_word t_dfa.q0 w ∈ t_dfa.F)

def DFA.Language {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (dfa : DFA Q Sigma) : _root_.Language Sigma

Given a DFA, a word w is contained in its language iff δ_word(q0,w) is defined and the DFA ends up in a final state when reading w.

Equations

• dfa.Language w = ∃ (qf : Q), dfa.δ_word dfa.q0 w = some qf ∧ qf ∈ dfa.F

def DFA.to_totalDFA {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (M : DFA Q Sigma) : TotalDFA (Option Q) Sigma

A function turning a DFA into a total DFA.

At first glance this might look very different from the lecture where we explicitly introduced a "garbage state". We change the type of Q to (Option Q) and just keep all the transitions. Since Q is an arbitrary type this results in a total DFA with states of type (Option Q). "none" is now a valid state that is reached whenever the original DFA had an undefined transition. It behaves exactly like the the garbage state from which there is no way out.

Equations

• M.to_totalDFA = { δ := fun (q : Option Q) (a : Sigma) => q.bind fun (x : Q) => M.δ x a, q0 := some M.q0, F := List.map (fun (q : Q) => some q) M.F }

def TotalDFA.to_DFA {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (M : TotalDFA Q Sigma) : DFA Q Sigma

A total DFA can (obviously) be converted to a DFA. The only thing that changes is the type of δ. Since δ is defined for every possible input (q,a) we can just wrap the value of δ with some to obtain an Option Q.

Equations

• M.to_DFA = { δ := fun (q : Q) (a : Sigma) => some (M.δ q a), q0 := M.q0, F := M.F }

theorem final_iff_final {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (M : DFA Q Sigma) (q : Q) : q ∈ M.F ↔ some q ∈ M.to_totalDFA.F

Given a DFA M and a state q, q is a final state of M iff q is a final state of M.to_totalDFA.

theorem δ_eq_δ {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (M : DFA Q Sigma) (q : Q) (a : Sigma) : M.δ q a = M.to_totalDFA.δ (some q) a

The transition functions of a DFA M and M.to_totalDFA map to the same values.

theorem δ_none_eq_none {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (M : DFA Q Sigma) (a : Sigma) : M.to_totalDFA.δ none a = none

For all alphabet symbols a, δ(none,a) = none.

theorem garbage_state {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (M : DFA Q Sigma) (w : Word Sigma) : M.to_totalDFA.δ_word none w = none

For all words w, δ_word(w,none) = none.

theorem final_ne_none {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] {q : Option Q} (M : DFA Q Sigma) : q ∈ M.to_totalDFA.F → q ≠ none

the state "none" (corresponding to a total DFA's garbage state) cannot be an accepting final state.

theorem to_totalDFA_δ_word_eq {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (M : DFA Q Sigma) (q : Q) (w : Word Sigma) : M.δ_word q w = M.to_totalDFA.δ_word (some q) w

The transition function for words of a DFA M and M.to_totalDFA have the same values for every input (q,w).

theorem totalDFA_eq_DFA {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (M : DFA Q Sigma) : M.Language = M.to_totalDFA.Language

The language of a DFA M does not change when converting it to a total DFA.

theorem to_DFA_δ_eq {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (M : TotalDFA Q Sigma) (q : Q) (a : Sigma) : some (M.δ q a) = M.to_DFA.δ q a

The transition functions of a total DFA M and M.to_DFA map to the same values.

theorem to_DFA_δ_word_eq {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (M : TotalDFA Q Sigma) (q : Q) (w : Word Sigma) : some (M.δ_word q w) = M.to_DFA.δ_word q w

The transition function for words of a total DFA M and M.to_DFA have the same values for every input (q,w).

theorem DFA_eq_totalDFA {Q : Type u} {Sigma : Type v} [Fintype Q] [Fintype Sigma] (M : TotalDFA Q Sigma) : M.Language = M.to_DFA.Language

Every total DFA can be seen as a DFA.