Portion of CFG for Python language

compound_stmt: if_stmt | while_stmt | function_def | ...
if_stmt:
    | 'if' named_expression ':' block elif_stmt 
    | 'if' named_expression ':' block [else_block] 
elif_stmt:
    | 'elif' named_expression ':' block elif_stmt 
    | 'elif' named_expression ':' block [else_block] 
else_block:
    | 'else' ':' block 
block:
    | NEWLINE INDENT statements DEDENT 
    | simple_stmts
...

https://docs.python.org/3/reference/grammar.html

Example CFG

\[\begin{align*} A &\to 0 A 11 \\ A &\to B \\ B &\to\ ! \end{align*}\]

Which of the following strings are generated by this grammar?

The set of strings generated is \(\{0^n ! 1^{2n} \mid n \geq 0\}\).

More Examples and Some Shorthand Notation

Let’s consider another CFG \(G\): \[\begin{align*} S &\to A B \\ A &\to 0 A \\ A &\to \emptystring \\ B &\to 1 B \\ B &\to \emptystring \end{align*}\]

We express this more concisely as: \[\begin{align*} S &\to A B \\ A &\to 0 A \or \emptystring \\ B &\to 1 B \or \emptystring \end{align*}\] where the \(\or\) symbol should be read as “or”.

Which of the following are generated by \(G\)?

The set of strings generated is matched by the regex \(0^* 1^*\).

More Examples and Some Shorthand Notation

Let’s consider another CFG \(G\): \[\begin{align*} S &\to A B \\ A &\to 0 A \\ A &\to \emptystring \\ B &\to 1 B \\ B &\to \emptystring \end{align*}\]

We express this more concisely as: \[\begin{align*} S &\to A B \\ A &\to 0 A \or \emptystring \\ B &\to 1 B \or \emptystring \end{align*}\] where the \(\or\) symbol should be read as “or”.

Parse tree for string 00111

More Examples

Let’s generate all strings of properly nested parentheses.
For example, \(()\) and \((())()\) are valid, but \((()\) and \()(\) are not.

We can produce a valid string of parentheses by:
- Surrounding an existing valid string with a matching pair of parentheses.
- Concatenating two existing valid strings.
We can express this as a CFG: \[ S \to \fragment{( S )} \fragment{ \or S S} \fragment{ \or \emptystring} \hspace{15em} \]

Parse tree for string \((()(()))\)

Formal Definition of CFGs

A context-free grammar (CFG) is a 4-tuple \(G = (\Gamma, \Sigma, S, \rho)\) where:

\(\Gamma\) is a finite set of variables (non-terminal symbols).
\(\Sigma\) is a finite alphabet, disjoint from \(\Gamma\) of terminals.
\(S \in \Gamma\) is the start variable.
\(\rho \fragment{\subseteq} \fragment{\Gamma \times {(\Gamma \cup \Sigma)}^*}\) is a finite set of rules.

By default, if no start variable is specified, the left-hand-side variable from the first rule is used as the start variable
Variables are usually upper-case symbols but can be more readable names like \(\cfgvar{EXPR}\) and \(\cfgvar{TERM}\).

Formal Definition of Computation for CFGs

First some terminology:

If \(u, v, w \in {(\Gamma \cup \Sigma)}^*\) are strings of variables and terminals,
and \(A \to w\) is a rule in the grammar,
then we say that: \[ u A v \yields u w v \quad \quad (u A v \; \; \textbf{yields} \; u w v) \]
If there exists sequence of strings \(u_1, u_2, \ldots, u_k\) for \(k \ge 0\) such that: \[ u \yields u_1 \yields u_2 \yields \ldots \yields u_k \yields v \] then we say that \(u\) derives \(v\), writing \(u \derives v\).

A grammar \(G\) with start variable \(S\) accepts or generates/produces \(w \in \Sigma^*\) if \(S \derives w\).

The language of grammar \(G\) is \(L(G) = \setbuild{w \in \Sigma^*}{S \derives w}\).

A language \(A\) is called context-free or CFG-decidable if there exists a CFG \(G\) s.t. \(L(G) = A\).

Some Strategies for Designing CFGs

CFGs naturally support the operations of union, concatenation, and “calling” another CFG as a subroutine.
Let’s try to design a CFG for the language \(\setbuild{0^n 1^n}{n \ge 0} \cup \setbuild{1^k 0^k}{k \ge 0}\)
- Start with \(S \to\ A |\ B\), where \(A\)/\(B\) are respectively start variables for CFGs for each individual language \(L_A = \setbuild{0^n 1^n}{n \ge 0}\) and \(L_B = \setbuild{1^n 0^n}{n \ge 0}\).
- For \(L_A = \setbuild{0^n 1^n}{n \ge 0}\), how to define this language recursively?
  - base case: \(x \in L_A\) if \(x = \emptystring\)
  - recursive case: \(x \in L_A\) if \(x = 0 y 1\), where \(y \in L_A\) (note \(|y| < |x|\)).
- This leads to the rules \(A \to 0 A 1 \or \emptystring\).
- Similarly, CFG for \(L_B\) is \(B \to 1 B 0 \or \emptystring\).
Putting it all together, we have: \[ \begin{array}{rcl} S &\to& A \or B \\ A &\to& 0 A 1 \or \emptystring \\ B &\to& 1 B 0 \or \emptystring \end{array} \]

DFA-to-CFG Construction and RRGs

Any DFA can trivially be converted into a CFG!
Consider the DFA \(M = (Q, \Sigma, \delta, s, F)\)
- Create a variable \(R_i\) for each state \(q_i \in Q\).
- For each transition \(\delta(q_i, a) = q_j\) in the DFA, add the rule: \[ R_i \to a R_j \]
- For each accept state \(q_i \in F\), add the rule: \[ R_i \to \emptystring \]
- Make \(R_0\) (corresponding to start state \(s\)) the start variable.
The resulting CFG decides (generates) exactly the same language as the DFA decides.
This is an example of a right-regular grammar (RRG):

A right-regular grammar (RRG) is a CFG where each rule is of the form: \(X \to a Y\) or of the form \(X \to \emptystring\).

Nondeterministic Finite Automata

Our third “declarative model of computation” is the Nondeterministic Finite Automaton.

Example nondeterministic finite automaton (NFA)

What’s different here vs. our previous state diagrams?

NFAs are a generalization of DFAs.
- Any DFA is already a valid NFA!
- NFAs offer additional features that make them “easier to program” than DFAs
  - They can have multiple transitions for the same state and input symbol.
  - They can have \(\emptystring\)-transitions (that do not consume any input symbols).
  - They allow states to have no transitions for a given input symbols.
- These features also make them less straightforward to simulate, which is why we call them “declarative”.
We’ll later prove that it’s possible to convert any NFA into a (usually larger) DFA.

Operation of an NFA

Intuitively, upon reading each symbol, an NFA follows all possible paths.
- We can think of this as the machine “forking” into multiple copies to take each available transition.
- For each copy, if there is no transition for the consumed symbol, that copy “dies”.
The NFA accepts the input string if any of its “copies” is in an accept state after reading the entire input string. Otherwise, it rejects.

Example processing the string \(010110\):

← Accept!

Title

Portion of CFG for Python language

Example CFG

More Examples and Some Shorthand Notation

More Examples and Some Shorthand Notation

More Examples

Formal Definition of CFGs

Formal Definition of Computation for CFGs

Some Strategies for Designing CFGs

DFA-to-CFG Construction and RRGs

Nondeterministic Finite Automata

Operation of an NFA