CS 420 2024fall ibarland

home—lectures—exams—hws—D2L—zoom (snow day)

Definitions
sets; FSMs

home—lectures—exams—hws—D2L—zoom (snow day)

READING: Chpt.03

Previously, on itec420…

Examples of regular-expressions: For b(ba*b)* :

• What are some strings that match this pattern?
• What are some strings that don't match?
• What is the shortest string that matches?
• What is the shortest string that doesn't match?

def'n: A Language is: a

Draw FSM for b(ba*b)* (and minimize it, informally).

Defining Finite State Machines

Generalize: A FSM = ⟨K, Σ, δ, s, A⟩. In math:

• K is the set-of-states.
• Σ is the alphabet – the set of letters we'll see of the input.
• s ∈ K, the initial state
• A ⊆ K, the accept-states
• δ ∈ KxΣ → K, the transition function.

typedef State String; // okay, this isn't legal Java, but fine: we're representing States by Strings (their name); using `int` is common too. (Really: we should have `class FSM<StateType>`.)

class FSM {
   Set<State> K;
   CharSet Σ;
   State s;      // @pre: K.contains(s)
   Set<State> A; // @pre: K.containsAll(A)
   Map< Pair<State,Character>, State> δ; // @pre States are all in K; Characters are all in Σ.
   // We could also use java.function.BiFunction
  }

Example: All equivalent:

FSM as picture

FSM as math: M = < {0,1,2,3}, {a,b}, δ, 0, {1} > where δ = { <0,a> ↦ 1, <0,b> ↦ 3, <1,a> ↦ 3, <1,b> ↦ 2, <2,a> ↦ 2, <2,b> ↦ 1, <3,b> ↦ 3, <3,b> ↦ 3 }

FSM as Java object:

new FSM( Set.of( 0,1,2,3 ), new CharSet("ab"), 0, Set.of(1), Map.of( new Pair(0,'a'), 1, new Pair(0,'b'), 3, ... )

Def'n of FSM "accepts" a string: (informal for now): Feed a string w into the FSM M (starting at s); if after transitioning on all characters of w, M is in a state in A, then we say "M accepts w". (more formal def'n will use terms "configuration of M" and a sequencek-of-configurations, "a computation".)
Def'n: For a FSM M, we say "L(M)" is the language it *accepts*; we also say M "recognizes" L. E.g. We just gave a FSM which recognized b(ba*b)* (and even: that machine computes ).

Sets

Common Sets: ∅, {false,true}, ℕ, ℤ, ℚ, ℝ, ℂ; Σ*

Sample sets to work with:

L₀ = {}
L₁ = {17}
L₂ = {vw, saab, bmw}
L₃ = {1,2,3,4,5,6}
P  = prime numbers
L₄ = state-abbreviations

L₅ = strings over {a,b}* where every 'a' is followed by a 'b'
L₆ = b*aa* = {a, aa, ba, aaa, baa, bba, …, bbbaa, … }
L₇ = b*a*b* = { ε,   a, b,    aa, ab, ba, bb,    aaa, aab, abb, baa, bab, bba, bbb,       …}
L₈ = b(ba*b)*

How to make new sets out of old ones:

• union: A ∪ B. x∈A∪B means x∈A ∨ x∈B
• intersection: A ∩ B x∈A∩B means x∈A ^ x∈B
• set-difference: A ∖ B x∈A∖B means x∈A and ¬x∈B
• cross-product: A ⨯ B means: x∈A⨯B means x=⟨a,b⟩ where a∈A and b∈B

Let's practice a bit:

• What is L₂ ∪ L₃? How about L₂ ∩ L₃? How about L₂ ⨯ L₃?
• What is P ∖ L₃? How about L₃ ∖ P?
• What is ?

Okay, some more ways to make new sets out of old ones:

1. function-space: A → B means:
   the set of all possible functions with domain A, and codomain B.

   For example, Σ^* → ℕ is the set of all functions taking a string and returning a number; string-length is one member of this set.
   We say that Σ^* → ℕ is string-length's signature. (When you write a function in Java, you must give its signature — albeit in Java, not math.)

   What about the signature of substring?

   Sigma* x ℕ x ℕ → Σ^*
   (hint: we can say that its input-type is one thing: a tuple of size three.)

2. concatenation (for sets-of-strings): AB w∈AB means w=ab where a∈A and b∈B
   examples: L₄L₂ = { vavw, vasaab, utbmw, … }; there are 50*3 elements in this case; could be fewer in general!
   L₆L₇ = { a, aa, ba, ab, aaa, … }
3. powers (for sets-of-strings¹): A² = AA, and A³ = AAA = AA², and Aⁿ = AAA…A = AAⁿ⁻¹.
4. Kleene Star, A*: $$\BigCup_{i \in ℕ}A\sup{i}$$

Questions, for various sets created from the ones listed above: No. of elements? Contains ε (the empty-string)?

Exercise (challenge): Find two sets-of-strings A,B such that |AB| < |A| * |B| Answers:

• {a,b,ab}
  {b,bb}
  =
  {ab,abb,bb,bbb,abbb}
  In this case, the string
  abb
  can be created via two different concatenations:
• Challenge: give a smaller pair of languages which also has |AB| < |A|⋅|B|.                                                                                      Can you give the smallest such pair of languages? (How even to best define smallest pair?)                                     

Define: lexicographic order
Sort by length, and within length sort alphabetically. E.g. {a,b}* = {

ε
,
a
, 
b
,
aa
, 
ab
, 
ba
, 
bb
,
aaa
, 
aab
, 
aba
,
… 

We use Lexicographic order because, unlike alphabetical order, the enumeration actually hits every string. E.g. aba is the 10th string above. But if we'd tried to order the set as ε, a, aa, aaa, aaaa, … then aba wouldn't show up as the 10th or the 99th or the 10-billionth entry — it wouldn't be covered at any finite index!

home—lectures—exams—hws—D2L—zoom (snow day)

This page licensed CC-BY 4.0 Ian Barland Page last generated

Please mail any suggestions (incl. typos, broken links) to ibarlandradford.edu