Formal methods 2 - languages and machines
-
Upload
vlad-patryshev -
Category
Education
-
view
432 -
download
4
description
Transcript of Formal methods 2 - languages and machines
Formal Methods in Software
Lecture 2. Languages and Machines-1
Vlad PatryshevSCU2014
Deterministic State Machine(In, S, s0 S, f:In×S → S)∈
Input Alphabet
Collection of States
Initial State
Transition Function
Example 1. Turnstile
Example 2. String validation
Acceptable states - a subset of S that we assign a special meaning of being better than others
We Have Monoids, actually• Alphabet A gives a monoid In=A*: all strings in A, including empty
• Having f: A*×S → S is equivalent to having f’: A* → SS
(where SS is all functions S→S, that is, all transitions)
• SS is a monoid (identity function and composition)
• f’ is a monoidal function
Nondeterministic State Machine(In, S, s0 S, f:In×S → ∈ P(S))
Input Alphabet
Collection of States
Initial State
Transition Function
Example. Parsing strings
Good Strings Bad Strings
ad,ac,abbbc,abbd... a,ba,aba,abbb
Terminology and TLA/FLA• FSM - finite state machine (finite number of states)
• DFA - deterministic finite automaton, aka deterministic FSM
• NFA - non-determinisitic FSM
• Acceptable States - a subset of S that we assign a special meaning of being better than others
• Input Language - strings built of Input Alphabet
• ε, Empty Symbol - empty string (a word in Input Language)
• Regular Language is an input language accepted by an FSM
NFA ↔ DFA1. DFA is a special case of NFA (every transition is to a singleton)2. NFA → DFA?
NFA X = (In, S, s0 S, f:In×S → P(S))∈DFX PX = (In, P(S), {s0} P(S), f’:In×P(S) → P(S))∈where f’(a,B) = {f(a,b)|b B}∪ ∈
NFA → DFA, Example
Regular Languages
Example: a, aa, aaa, aaaa…Counterexample: anbn (for all n)
Regular language is a language accepted by an FSM
Given an FSM, its language is the language accepted by this FSM
Given an alphabet A, a language is a set of words in A (in other words, a subset of A*)
Building Regular Languages• Empty language is regular (its FSM accepts nothing)∅• Singleton {a} is regular (its FSM takes a once)
• Union of two languages, A B,∪ is regular:
• Concatenation of two languages, A·B, is regular:
• If A is regular, A* is regular:
Formal GrammarGiven an alphabet A, and a language L A*⊂ , try to define it via formal
grammar. (A, N, S N, Rules)∈
Rules: each rule looks like x1x2...xkzxk+1...xn→ y1y2...ym, where
xi (A N), y∈ ∪ i (A N), z N∈ ∪ ∈
“Terminal symbols” Nonterminal symbols
Start symbol
Example of Formal GrammarD → 0
D → 1
N → D
N → DN
S → N
S → X+X
S → X-X
P → S
P → (P)
P → P*P
X → P
X → S
e.g. (0100-0*11)*(111+1-0)
Example in Backus-Naur Form (BNF)<D> ::= 0|1
<N> ::= <D>|<D><N>
<S> ::= <N>|<X>+<X>|<X>-<X>
<P> ::= <S>|(<S>)|<P>*<P>
<X> ::= <P>|<S>
e.g. (0100-0*11)*(111+1-0)
Grammar of Regular LanguageGiven an alphabet A, and a regular language L A*⊂ , its grammar has a very
simple form:● B → ε● B → a● B → aC
where B and C are nonterminal symbols, a is some terminal symbol.
Regular Expressions/abc*d?..e/ -- matches abxye, abccccdabe and the likeR → aR1
R1 → bR2
R2 → cR2
R2 → R3
R2 → dR3
R3 → (anything)R4
R4 → (anything)R5
R5 → e
Parsing Regular Expressions
The problem with NFA - exponential time, O(2n). E.g. a?nan against an
Can transform to DFA; then it’s linear, O(n) (but may take space).
A simple example in Scala: https://gist.github.com/vpatryshev/3778294The example is tricky: it’s not an FSM; it uses call stack.
main(int c,char**v){return!m(v[1],v[2]);}m(char*s,char*t){return*t-42?*s?63==*t|*s==*t&&m(s+1,t+1):!*t:m(s,t+1)||*s&&m(s+1,t);}
Big Of(x) = O(g(x)) for x → ∞ means this:
∃x0∃C ∀x>x0 |f(x)/g(x)| < C
E.g.ax2+bx+c = O(x2)1/x = O(1)n! = O((n/2)n)
Referenceshttp://www.cs.ox.ac.uk/people/luke.ong/personal/teaching/moc/nfa2up.pdf
http://swtch.com/~rsc/regexp/regexp1.html
https://gist.github.com/vpatryshev/3778294
Wikipedia