Unrestricted Grammars

Chapter 23

Grammars, SD Languages, and Turing Machines

SD Language

Grammar

Turing Machine

L

Accepts

Unrestricted Grammars An unrestricted, or type 0, or phrase structure grammar G is a quadruple

(V, , R, S), where:

● V is an alphabet,

● (the set of terminals) is a subset of V,

● R (the set of rules) is a finite subset of (V+ V*),

● S (the start symbol) is an element of V - .

The language generated by G is:

{w * : S G* w}.

Unrestricted Grammars

Example: AnBnCn = {anbncn, n 0}.

CFG attempt 1:

S A B CA aA | B bB | C cC |

Unrestricted Grammars

Example: AnBnCn = {anbncn, n 0}.

CFG attempt 2:

S a b S c | S

a b S c

a b S c

ababcc

Unrestricted Grammars

Example: AnBnCn = {anbncn, n 0}.

S aBScS Ba aBBc bcBb bb

Proof: ● Only strings in AnBnCn :

● All strings in AnBnCn :

Another Example

{w {a, b, c}* : #a(w) = #b(w) = #c(w)}

Another Example

{w {a, b, c}* : #a(w) = #b(w) = #c(w)}

S ABCSS AB BABC CBAC CABA ABCA ACCB BCA aB bC c

WW = {ww : w {a, b}*}

WW = {ww : w {a, b}*}

One idea:

1. Generate a string in wwR, plus delimiters

aaabbCbbaaa#

2. Reverse the second half.

WW = {ww : w {a, b}*}

S T# /* Generate the wall exactly once.T aTa /* Generate wCwR.T bTb T C C CP /* Generate a pusher PPaa aPa /* Push one character to the right

to get ready to jump.Pab bPa Pba aPb Pbb bPb Pa# #a /* Hop a character over the wall.Pb# #b C#

A Strong Procedural Feel

Unrestricted grammars have a procedural feel that is absentfrom most restricted grammars.

Derivations often proceed in phases. We make sure that the phases work properly by using nonterminals as flags that we’re in a particular phase.

It’s very common to have three main phases: ● Generate the right number of the various symbols. ● Move them around to get them in the right order. ● Clean up and get rid of nonterminals.

No surprise: unrestricted grammars are general computingdevices.

Equivalence of Unrestricted Grammars and Turing Machines

Theorem: A language is generated by an unrestrictedgrammar if and only if it is in SD.

Proof:

Only if (grammar TM): by construction of an NDTM.

If (TM grammar): by construction of a grammar thatmimics the behavior of a semideciding TM.

Given G, produce a Turing machine M that semidecides L(G).

M will be nondeterministic and will use two tapes:

Proof that Grammar Turing Machine

For each nondeterministic “incarnation”: ● Tape 1 holds the input. ● Tape 2 holds the current state of a proposed derivation.

At each step, M nondeterministically chooses a rule to try to apply and a position on tape 2 to start looking for the left hand side of therule. Or it chooses to check whether tape 2 equals tape 1. If anysuch machine succeeds, we accept. Otherwise, we keep looking.

a b a b 1 0 0 0 0 0 0

a S T a a b 1 0 0 0 0 0 0

Proof that Turing Machine Grammar

Build G to simulate the forward operation of a TM M:

The first (generate) part of G:Create all strings over * of the form:

w = # q000 a1 a1 a2 a2 a3 a3 #

The second (test) part of G simulates the execution of M on a particular string w. An example of a partially derived string:

# a 1 b 2 c c b 4 q001 a 3 #

Examples of rules:

q100 b b b 2 q101 a a q011 b 4 q011 a a b 4

The Last Step

The third (cleanup) part of G erases the junk if M ever reaches any of its accepting states, all of which will be encoded as A.

Rules:x x A A x /* Sweep A to the left.x, y #A x y x #A /* Erase duplicates.

#A#

An Unrestricted Grammar of Tabla Drumming

We say that G computes f iff:

w, v * (SwS G* v v = f(w))

Example: f(x) = succ(x)

S1S G* 11 S11S G* 111

Computing with Grammars

We say that G computes f iff:

w, v * (SwS G* v v = f(w))

Example: f(x) = succ(x)

S1S G* 11 S11S G* 111

Rules: S1 1S or 1S 11SS 1 S1 1

SS 1

Computing with Grammars

A function f is called grammatically computable iff there is a grammar G that computes it.

Theorem: A function f is computable iff it is grammatically computable.

In other words, iff a Turing machine can do it, so can a grammar.

Proof: uses two constructions, analogous to the onesused to prove that a language can be defined with anunrestricted grammar iff it is in SD.

Grammatically Computable

The valuen Functions

For any k, valuek(n) returns the nonnegative integer that is encoded, base k, by the string n.

Example:

value2(101) = 5.

f(n) = m, where value1(m) = 2value1(n).

G = ({S, 1}, {1}, R, S), where R =

Examples:

Input: S111S SS

Output:

Example of Computing with a Grammar

f(n) = m, where value1(m) = 2value1(n).

G = ({S, 1}, {1}, R, S), where R =

Examples:

Input: S111S SS

Output: 111111

Example of Computing with a Grammar

f(n) = m, where value1(m) = 2value1(n).

G = ({S, 1}, {1}, R, S), where R =

S1 11SSS

Examples:

Input: S111S SS

Output: 111111

Example of Computing with a Grammar

f(x) = x with extra blanks squeezed out.

Examples:

Input: SaabaabS

Output: aabaab

Input: SaabS

Output: aab

Another Example

f(x) = x with extra blanks squeezed out.

G = ({S, T, a, b, }, {a, b, }, R, S), where R =

SS /* In case x has no nonblank characters.S S /* Get rid of leading ’s. Sa aT /* All characters to the left of T will be correct. Sb bT Ta aT /* Sweep T across a’s and b’s.Tb bT T T /* Squeeze repeated ’s.Ta aT /* Once there is a single , sweep T past it and the first letter

after it.Tb bT TS /* The T rule will get rid of all but possibly one at the

end of the string.

TS /* If there were no trailing ’s, this rule finishes up.

Another Example

● Given a grammar G and a string w, is w L(G)? ● Given a grammar G, is L(G)? ● Given two grammars G1 and G2, is L(G1) = L(G2)? ● Given a grammar G, is L(G) = ?

Or, as languages:

● La = {<G, w> : w L(G)}. ● Lb = {<G> : L(G)}. ● Lc = {<G1, G2> : L(G1) = L(G2)}. ● Ld = {<G> : L(G) = }.

None of these questions is decidable.

Decision Problems for Unrestricted Grammars

Proof: Let R be a mapping reduction from:

A = {<M, w> : Turing machine M accepts w} to La:

R(<M, w>) = 1. From M, construct the description <G#> of a grammar G# such that L(G#) = L(M). 2. Return <G#, w>.

If Oracle decides La, then C = Oracle(R(<M, w>)) decides A. We have already defined an algorithm that implements R. C is correct:

● If <M, w> A : M(w) halts and accepts. w L(M). So w L(G#). Oracle(<G#, w>) accepts. ● If <M, w> A : M(w) does not accept. w L(M). So w L(G#). Oracle(<G#, w>) rejects.

But no machine to decide A can exist, so neither does Oracle.

La = {<G, w> : w L(G)} is not in D.

The Word Problem

Given two strings, w and v, and a rewrite system T, determine whether v can be derived from w using T.

A key application: Logical reasoning

Semi-Thue SystemsA semi-Thue system T is a pair (, R), where:

• is an alphabet,

• R (the set of rules) is a subset of + *.

Note that:

• There is no unique start symbol.

• There is no distinction between terminal and nonterminal symbols.

Theorem: The word problem for semi-Thue systems is undecidable.