Some parsing decisions

Left-to-right, right-to-left, and head-first
Bottom-up parsing
- Parsing driven by the lexicon
- Rules indexed by right-hand sides
- Problem with empty categories
- Choice (ambiguity) when right-hand side of more than one rule or lexical entry matches
Top-down parsing
- Parsing driven by the grammar, predicting the input
- Rules indexed by left-hand sides
- Choice (ambiguity) when left-hand side of more than one rule or lexical entry matches
- Problems with left recursion (in left-to-right parsing)
```
NP → NP Conj NP
```
Determinism
- Non-deterministic parsing: when there is more than option in the grammar, try one, backtracking to the choice point if this option fails
- Deterministic parsing: make decisions once and for all; no backtracking; return only one parse
Parsing as search: depth-first, breadth-first, heuristic, beam

Recursive descent parser

Bottom-up, deterministic
Maintains a stack of completed constituents
Two actions:
- Shift: add a new input token to the stack
- Reduce: combine tokens on the top of the stack if they constitute the right-hand side of a rule
Because there's not backtracking, substructures are parsed only once
Decisions: whether to reduce or shift; which of multiple reduce actions to take
Parser may make the wrong decision
More intelligent decision-making: based on
- What's on the stack
- Lookahead (wait-and-see parsers)
NLTK demo: nltk.app.srparser()

Combines top-down (Earley) and bottom-up (CKY) approaches; a policy decides which type of action to take
Dynamic programming: intermediate results (well-formed substrings) are saved because they may be useful later
Chart: table that stores all parsed or partially parsed constituents spanning a sequence of words:
- Entry ('edge') in the chart: <start finish label found tofind>
- Bottom-up rule for creating a new active edge:
```
if <i, j, C → W1 .>
   for each rule B → C W2, add <i, i, B → . C W2>
```
- Top-down rule for creating a new active edge:
```
if <i, j, C → W1 . B W2>
   for each rule B → W, add <j, j, B → . W>
```
- Fundamental rule for combining edges:
```
if <i, j, A → W1 . B W2> and <j, k, B → W3 .>
   add <i, k, A → W1 B . W2>
```
NLTK demo: nltk.app.chartparser()

Chart parser combines top-down and bottom-up approaches; a policy decides which type of action to take
Dynamic programming: intermediate results (well-formed substrings) are saved because they may be useful later
Chart: table that stores all parsed or partially parsed constituents spanning a sequence of words:
- Entry ('edge') in the chart: <start finish label found tofind>
- Bottom-up rule for creating a new active edge:
```
if <i, j, C → W1 .>
   for each rule B → C W2, add <i, i, B → . C W2>
```
- Top-down rule for creating a new active edge:
```
if <i, j, C → W1 . B W2>
   for each rule B → W, add <j, j, B → . W>
```
- Fundamental rule for combining edges:
```
if <i, j, A → W1 . B W2> and <j, k, B → W3 .>
   add <i, k, A → W1 B . W2>
```
NLTK demo: nltk.app.chartparser()