Lecture Notes 13: More CFGs and Intro to Push-Down Automata

Outline

This class we'll discuss:

More on CFGs
Intro to Push-Down Automata

Recap: CFGs

CFGs!!!

All REs can be created with CFGs

Approach 1: Recursive creation of CFG from definition of REs

For any RE

R_{1}

We can produce a CFG

G_{1}

by applying the following steps:

Any base cases can be writen as generation of
$S \to_{g} \emptyset | ϵ | a$ for all $a \in Σ f r o m R_{1}^{'} s Σ$
Defining the more complex rules requires combining two rules. The recursive expression based on these two base rules can start with:
$S \to_{g} A$ (some expression)
$S \to_{g} B$ (another expression)
and combined to generate more complex expressions:
- Alternation:
  $S \to_{g} S_{1} | S_{2}$ (equivalent to A + B for some A, B)
- Concatenation:
  $S \to_{g} S_{1} S_{2}$ (equivalent to A B for some A, B)
- Kleene:
  $S \to_{g} S_{1} S | ϵ$ (equivalent to $A^{*}$ for some A)

Approach 2: RL's are a special case of CFLs

You can convert any DFA into an equivalent CFG as follows.

Make a variable $S_{i}$ for each state $q_{i}$ of the DFA.
Add the rule $S_{i}$ → $a S_{j}$ to the CFG if $δ (q_{i}, a) = q_{j}$ is a transition in the DFA.
Add the rule $S_{i}$ → ε if qi is an accept state of the DFA.
Make $S_{0}$ the start variable of the grammar, where $q_{0}$ is the start state of the machine.

Verify on your own that the resulting CFG generates the same language that the DFA recognizes.

Activity 1 [2 minutes]:

Try to build your own CFG. One that "Accepts" the language:

L = {w \in Σ^{*} | w h a s a n o d d n u m b e r o f 1 s}

(Wait; then Click)

if A is

S_{0}

and B is

S_{1}

\begin{aligned} S & \to_{g} S_{A} \\ S_{A} & \to_{g} 0 S_{A} \\ S_{A} & \to_{g} 1 S_{B} \\ S_{B} & \to_{g} ϵ \\ S_{B} & \to_{g} 0 S_{B} \\ S_{B} & \to_{g} 1 S_{A} \end{aligned}

How do we prove there are languages that are NOT (beyond) CFLs?

How did we do this back when we did it for RLs?

CFGs!!!

the middle part is not too big
v and y (the repeating parts) are not both simultaneously empty
repeating v and or y we will keep us in the language

Note that RLs are a special case of Context-Free-Languages (without the

u v^{i}

) part.

So, if we have a pumping lemma for CFGs, is there a "Machine" equivalent to the Finite Automatons as well?

We'll see those next class.

Proving a language is NOT context-free

CFGs!!!

What does your untuition say? Is it a CFL?

CFGs!!!

Remember:

Given a structure of $w = u v x y z$ , and $∣ v y ∣\geq 1$
We want to find an $i$ for which a word $u v^{i} x y^{i} z$
does not have a prime length ( $∣ u v^{i} x y^{i} z ∣$ is not prime ) after being "pumped" some number of times.
Here, we can start with a word $w$ with length $p \geq N$ ( $N$ provided by the pumping Lemma)
Now, the trick is to pump the pattern some number of times so that we can prove that the final length is NOT prime!
Ideas?

(Wait; then Click)

Steps:

The length of a word $∣ u v^{i} x y^{i} z ∣$
is the length of $∣ w ∣$ plus any added repetitions of $v$ and $y$
So, $∣ u v^{i} x y^{i} z ∣$ is $∣ w ∣ + (i - 1) ∣ v y ∣$
Since we said $w$ is in PRIMEAL, then $∣ w ∣$ is some prime number $p \geq N$ .
Then, $∣ u v^{i} x y^{i} z ∣=∣ w ∣ + (i - 1) ∣ v y ∣= p + (i - 1) ∣ v y ∣$
Now, What possible choice of $i$ could we choose to cause the overall length to be provably NOT prime?

(Wait; then Click)

If we choose

i

so that the

i - 1

is equal to

p

in the following expression:

∣ u v^{i} x y^{i} z ∣=∣ w ∣ + (i - 1) ∣ v y ∣= p + (i - 1) ∣ v y ∣

Then substituting

i - 1

for

p

( by making

i = p - 1

), we would get:

∣ u v^{i} x y^{i} z ∣=∣ w ∣ + (i - 1) ∣ v y ∣= p + p ∣ v y ∣ = p (1 + ∣ v y ∣)

which means that, after pumping, the word is divisible by $p$ ! and therefore, not of prime length.

Why are CFGs important?

CFGs!!!

check the article out: https://www.nature.com/articles/nature04675

PDAs!!!

PDAs!!!

PDAs!!!

Push-Down Automata

PDAs!!!

PDAs!!!

PDAs!!!

PDAs!!!

Activity 1 [2 minutes]:

What is the language that these rules are describing?

(Wait; then Click)

are these a valid words? ${ϵ, 01, 0011, \dots}$
We know this language!! What is it called?

Now, let's try to buid an automaton that can keep track of all of this

Notes

we need a notation for READ, POP and PUSH... we'll use: $R E A D, P O P \to P U S H$
we need a symbol for "The stack is currently empty!"... we'll use $z_{0}$
we need to be able to read a symbol without pushing ... we'll use $ϵ$ in place of PUSH
we need to be able to read a symbol without popping ... we'll use $ϵ$ in place of POP
we need to be able to push without reading a symbol ... we'll use $ϵ$ in place of READ
we need to be able to pop without reading a symbol ... we'll use $ϵ$ in place of READ