1. LING/C SC/PSYC 438/538
Lecture 20
Sandiway Fong

2. Today's Topics SWI-Prolog installed?
We will start to write grammars today
Quick Homework 8

3. SWI Prolog Cheatsheet Anytime At the prompt ?- halt.
listing. listing(name).
[filename]. loads filename.pl
trace.
notrace.
debug.
nodebug.
spy(name).
pwd.
working_directory(_,Y).
switch directories to Y
Anytime
^C (then a(bort) or h(elp) for other options)
Notation:
\+ negation
, conjunction
; disjunction
:- if
Facts:
predicate(arguments).
Rules:
p(Args) :- q(Args) ,.., r(Args).
Data structures:
list: [a,..b]
empty list: []
head/tail: [h|List]
Atom:
name, number
Term:
functor(arguments)
arguments: comma-separated terms/atoms

4. Recursion and modes of usage
Define a list relation len (of arity 2) as:
infinite
loop!

5. Recursion and modes of usage
length/2 is a built-in predicate
it has better behavior than our simple definition (len/2).

6. Regular Languages Three formalisms, same expressive power
Regular expressions
Finite State Automata
Regular Grammars
We’ll look at this case
using Prolog

7. Chomsky Hierarchy Chomsky Hierarchy Type-1 Context-sensitive rules
division of grammar into subclasses partitioned by “generative power/capacity”
Type-0 General rewrite rules
Turing-complete, powerful enough to encode any computer program
can simulate a Turing machine
anything that’s “computable” can be simulated using a Turing machine
Type-1 Context-sensitive rules
weaker, but still very powerful
anbncn
Type-2 Context-free rules
weaker still
anbn Pushdown Automata (PDA)
Type-3 Regular grammar rules
very restricted
Regular Expressions a+b+
Finite State Automata (FSA)
finite state
transducer
read/write head
Natural
languages?
tape
read
write
⏪/ ⏹ / ⏩

8. Chomsky Hierarchy FSA Type-1 Type-3 Type-2 DCG = Type-0
Regular Grammars
FSA
Regular
Expressions
Type-3
Type-2
DCG = Type-0

9. Prolog Grammar Rule System
known as “Definite Clause Grammars” (DCG)
based on type-2 restrictions (context-free grammars)
but with extensions
(powerful enough to encode the hierarchy all the way up to type-0)
Prolog was originally designed (1970s) to also support natural language processing
we’ll start with the bottom of the hierarchy
i.e. the least powerful
regular grammars (type-3)

10. Definite Clause Grammars (DCG)
Background
a “typical” formal grammar contains 4 things
<N,T,P,S>
a set of non-terminal symbols (N)
these symbols will be expanded or rewritten by the rules
a set of terminal symbols (T)
these symbols cannot be expanded
production rules (P) of the form
LHS  RHS
In regular and CF grammars, LHS must be a single non-terminal symbol
RHS: a sequence of terminal and non-terminal symbols: possibly with restrictions, e.g. for regular grammars
a designated start symbol (S)
a non-terminal to start the derivation
Language
set of terminal strings generated by <N,T,P,S>
e.g. through a top-down derivation

11. Definite Clause Grammars (DCG)
Example grammar (regular):
S  aB
B  aB
B  bC
B  b
C  bC
C  b
Background
a “typical” formal grammar contains 4 things
<N,T,P,S>
a set of non-terminal symbols (N)
a set of terminal symbols (T)
production rules (P) of the form LHS  RHS
a designated start symbol (S)
Notes:
Start symbol: S
Non-terminals: {S,B,C} (uppercase letters)
Terminals: {a,b} (lowercase letters)

12. DefiniteClause Grammars (DCG)
Example
Formal grammar DCG format
S  aB s --> [a],b.
B  aB b --> [a],b.
B  bC b --> [b],c.
B  b b --> [b].
C  bC c --> [b],c.
C  b c --> [b].
Notes:
Start symbol: S
Non-terminals: {S,B,C}
(uppercase letters)
Terminals: {a,b}
(lowercase letters)
DCG format:
both terminals and non-terminal symbols begin with lowercase letters
variables begin with an uppercase letter (or underscore)
--> is the rewrite symbol
terminals are enclosed in square brackets (list notation)
nonterminals don’t have square brackets surrounding them
the comma (,) represents the concatenation symbol
a period (.) is required at the end of every DCG rule

13. Regular Grammars Regular or Chomsky hierarchy type-3 grammars
are a class of formal grammars with a restricted RHS
LHS → RHS “LHS rewrites/expands to RHS”
all rules contain only a single non-terminal, and (possibly) a single terminal) on the right hand side
Canonical Forms:
x --> y, [t]. x --> [t]. (left recursive) or
x --> [t], y. x --> [t]. (right recursive)
where x and y are non-terminal symbols and
t (enclosed in square brackets) represents a terminal symbol.
Note:
can’t mix these two forms (and still have a regular grammar)!
can’t have both left and right recursive rules in the same grammar
Terminology:
or “left/right linear”

14. Definite Clause Grammars (DCG)
1. s --> [a],b.
2. b --> [a],b.
3. b --> [b],c.
4. b --> [b].
5. c --> [b],c.
6. c --> [b].
What language does our regular grammar generate?
by writing the grammar in Prolog,
we have a ready-made recognizer program
no need to write a separate grammar rule interpreter (in this case)
Example queries
?- s([a,a,b,b,b],[]). Yes
?- s([a,b,a],[]). No
Note:
Query uses the start symbol s with two arguments:
(1) sequence (as a list) to be recognized and
(2) the empty list []
one or more a’s followed by one or more b’s
Prolog lists:
In square brackets, separated by commas
e.g. [a] [a,b,c]

15. Prolog lists revisited
Perl lists: Python lists:
@list = ("a", "b", "c"); list = ["a", "b", "c"]
@list = qw(a b c);
@list = (); list = []
Prolog lists:
List = [a, b, c] (List is a variable)
List = [a|[b|[c|[]]]] (a = head, tail = [b|[c|[]]])
List = []
Mixed notation:
[a|[b,c]]
[a,b|[c]]

16. Regular Grammars Tree representation Example Derivation: s
?- s([a,a,b],[]).
true
There’s a choice of rules for nonterminal b:
Prolog tries the first rule
Through backtracking
It can try other choices
Derivation: s
[a], b (rule 1)
[a],[a],b (rule 2)
[a],[a],[b] (rule 4)
1. s --> [a],b.
2. b --> [a],b.
3. b --> [b],c.
4. b --> [b].
5. c --> [b],c.
6. c --> [b].
our a regular
grammar
all terminals, so we stop
Using trace, we can observe the progress of the derivation…

17. Regular Grammars Tree representation Example Derivation: s
?- s([a,a,b,b,b],[]).
Derivation: s
[a], b (rule 1)
[a],[a],b (rule 2)
[a],[a],[b],c (rule 3)
[a],[a],[b],[b],c (rule 5)
[a],[a],[b],[b],[b] (rule 6)
1. s --> [a],b.
2. b --> [a],b.
3. b --> [b],c.
4. b --> [b].
5. c --> [b],c.
6. c --> [b].

18. Prolog Derivations Prolog’s computation rule: For grammars:
Try first matching rule in the database
(remember others for backtracking)
Backtrack if matching rule leads to failure
undo and try next matching rule
(or if asked for more solutions)
For grammars:
Top-down left-to-right derivations
left-to-right = expand leftmost nonterminal first
Leftmost expansion done recursively = depth-first

19. Prolog Derivations For a top-down derivation, logically, we have:
Choice
about which rule to use for nonterminals b and c
No choice
About which nonterminal to expand next
1. s --> [a],b.
2. b --> [a],b.
3. b --> [b],c.
4. b --> [b].
5. c --> [b],c.
6. c --> [b].
Bottom up derivation for [a,a,b,b]
[a],[a],[b],[b]
[a],[a],[b],c (rule 6)
[a],[a],b (rule 3)
[a],b (rule 2)
s (rule 1)
Prolog doesn’t give you bottom-up derivations for free
… you’d have to program it up separately

20. SWI Prolog
1. s --> [a],b. 2. b --> [a],b. 3. b --> [b],c. 4. b --> [b]. 5. c --> [b],c. 6. c --> [b].
Grammar rules are translated when the program is loaded into Prolog rules.
Solves the mystery why we have to type two arguments with the nonterminal at the command prompt
Recall list notation:
[1|[2,3,4]] = [1,2,3,4]
s([a|A], B) :- b(A, B).
2. b([a|A], B) :- b(A, B).
3. b([b|A], B) :- c(A, B).
4. b([b|A], A).
5. c([b|A], B) :- c(A, B).
6. c([b|A], A).

21. Regex, FSA and a Regular Grammar
Textbook Exercise: find a RE for
Examples (* denotes string not in the language):
*ab *ba
bab
λ (empty string) bb
*baba
babab

22. Regex, FSA and a Regular Grammar
Draw a FSA and convert it to a RE: b b
[Powerpoint
Animation]
> 1 2 3 4 b a b ε
Ungraded exercise:
Could use the technique shown in a previous class: eliminate one state at a time b*
| b
ab+
= b*|b(ab+)+

23. Regex, FSA and a Regular Grammar
Regular Grammar in Prolog.
Let’s begin with something like:
s --> [b], b. (grammar generates bb+)
b --> [b].
b --> [b], b.
Add rule:
b --> [a], b. (grammar generates b+(a|b)*b)
Classroom Exercise:
How would you fix this grammar so it can handle the specified language?

24. Regex, FSA and a Regular Grammar
Regular Grammar in Prolog notation:
s --> []. (s = ”start state”)
s --> [b], b. (b = ”seen a b”)
s --> [b], s.
b --> [a], c. (c = ”expect a b”)
c --> [b].
c --> [b], b.
c --> [b], c.

25. Regex, FSA and a Regular Grammar
Compare the FSA with our Regular Grammar (RG)
s --> []. (s = ”start state”)
s --> [b], b. (b = ”seen a b”)
s --> [b], s.
b --> [a], c. (c = ”expect a b”)
c --> [b].
c --> [b], b.
c --> [b], c. 1 2 3 4
> b a ε
There is a straightforward correspondence between right recursive RGs and FSA

26. Regex, FSA and a Regular Grammar
Informally, we can convert RG to a FSA
by treating
non-terminals as states
and introducing (new) states for rules of the form x --> [a].
[Powerpoint animation]
in order of the RG rules
s --> [].
s --> [b], b.
s --> [b], s.
b --> [a], c.
c --> [b].
c --> [b], b.
c --> [b], c. b b
> s b c a e b b

27. Quick Homework 8
Question1: write a Prolog regular grammar for the following language:
Σ = {0, 1}
L = strings from Σ* with an odd number of 0's and an even number of 1's
assume 0 is an even number
Hint: start with a FSA
How many grammar rules do you have?
submit your program and sample runs
Examples:
*[] (empty string)
*1 *10 *01 *11

28. Last Time: enumerating the strings of a language…
Example: Σ={0,1}, enumerate Σ*
sigma(0).
sigma(1).
sigmas([]).
sigmas([X|L]) :- sigmas(L), sigma(X).
Run (hit ; for more answers)
?- sigmas(L).

29. Quick Homework 8: Extra Credit
Question 2: note the order of the rules matters.
What happens when you run the following Prolog query on your grammar?
s(String,[]). `(assume here s is the start symbol)
Can you reorder your grammar rules so that s(String,[]) returns strings in the language?
Show your grammar and run(s).

30. Quick Homework 8
Due tomorrow night