--- title: "Treebanks and Lexicalized Grammars" module: Linguistic Structure moduleNumber: 6 lessonNumber: 20 order: 620 summary: > Where does a grammar come from, and how is it prepared for a parser? We read a context-free grammar off the Penn Treebank, normalize it to Chomsky Normal Form for the CKY chart, then invert the phrase-structure emphasis with lexicalized grammars — Combinatory Categorial Grammar and its slash categories — and close with the grammar's fate in the neural era: span scoring, self-attention, and grammar induction. topics: [Structure] sources: - book: Jurafsky ref: "§12.4 Treebanks" - book: Jurafsky ref: "§12.5 Grammar Equivalence and Normal Form; §12.6 Lexicalized Grammars" --- This builds on [constituency grammars](/natural-language-processing/linguistic-structure/constituency-grammars), which fixed the context-free formalism and the phrase structure of English. A hand-written grammar is one source of that structure; the other, and the one that powers modern parsing, is a corpus of trees. We start there, then normalize the grammar for the parser and push its knowledge into the lexicon. ## Treebanks A grammar robust enough to parse any sentence makes it possible to build a corpus in which every sentence is paired with its parse. Such a corpus is a **treebank**.[^jm-treebank] Treebanks are usually made by running a parser over the text and then having linguists hand-correct the results. The **Penn Treebank** is the canonical example, with treebanks over the Brown, Switchboard, ATIS, and _Wall Street Journal_ corpora of English (and Arabic and Chinese). Its trees use LISP-style parenthesized notation — the same idea as the bracketed notation above. $$ % caption: A Penn Treebank parse (LISP-style) of the ATIS sentence "The flight % should arrive at eleven a.m. tomorrow", and the equivalent node-and-line tree. % Every leaf carries a Penn part-of-speech tag (DT, NN, MD, VB, IN). \begin{tikzpicture}[>=stealth, font=\small, level distance=8.5mm, every node/.style={inner sep=1.4pt}, level 1/.style={sibling distance=34mm}, level 2/.style={sibling distance=20mm}, level 3/.style={sibling distance=18mm}] \definecolor{acc}{HTML}{2348F2} \node[text=acc] {S} child { node {NP-SBJ} child { node {DT} child { node {\textit{The}} } } child { node {NN} child { node {\textit{f\/light}} } } } child { node {VP} child { node {MD} child { node {\textit{should}} } } child { node {VP} child { node {VB} child { node {\textit{arrive}} } } child { node {PP} child { node {\textit{at eleven}} } } } }; \node[font=\scriptsize, anchor=west, align=left] at (3.4,0.2) {(S (NP-SBJ (DT The) (NN f\/light))\\ \ \ (VP (MD should)\\ \ \ \ \ (VP (VB arrive)\\ \ \ \ \ \ \ (PP (IN at) ...)))) }; \end{tikzpicture} $$ Two Penn Treebank features are worth noting. **Function tags** decorate nodes with grammatical or semantic function: `NP-SBJ` is a surface subject, `NP-TMP` a temporal phrase, `ADJP-PRD` a predicate adjective. And **traces** are empty `-NONE-` nodes that mark the position of a moved constituent — the treebank's answer to the long-distance dependencies above. A fronted quotation, for instance, leaves a `-NONE-` node co-indexed (say with index 2) at the position the complement of _said_ would occupy, so a parser can recover that the fronted material is that complement. ### A treebank is a grammar The key fact for parsing: **the sentences in a treebank implicitly define a grammar.** Read every local tree — every parent with its children — as a CFG rule, and the union of all such rules is a grammar for the corpus. The trees above yield $\text{S} \rightarrow \text{NP-SBJ VP}$, $\text{VP} \rightarrow \text{MD VP}$, $\text{PP} \rightarrow \text{IN NP}$, and so on. No linguist ever wrote those rules; they fall out of the annotation. $$ % caption: A treebank IS a grammar. Reading each parent-with-children subtree as a % CFG rule and taking the union over all trees yields the grammar; the WSJ Penn % Treebank yields about 17,500 distinct rule types. \begin{tikzpicture}[>=stealth, font=\footnotesize, box/.style={draw, minimum width=30mm, minimum height=13mm, align=center}] \definecolor{acc}{HTML}{2348F2} \node[box] (tb) at (0,0) {treebank\\(hand-parsed trees)}; \node[box, draw=acc, text=acc, thick] (gr) at (6.2,0) {grammar\\(union of local rules)}; \draw[->, acc, thick] (tb) -- (gr); \node[text=acc, font=\scriptsize, anchor=south] at (3.1,0.55) {read each subtree as a rule}; \node[font=\scriptsize, anchor=north, align=center] at (0,-1.1) {tree fragment\\NP-SBJ $\to$ DT NN}; \node[font=\scriptsize, anchor=north, align=center] at (6.2,-1.1) {~17,500 rule types\\for the WSJ corpus}; \end{tikzpicture} $$ The extracted grammar is very **flat** — many long, specific rules rather than a few deep recursive ones. The WSJ treebank has roughly 4,500 distinct rules just for `VP`, including separate productions for every arity of PP sequence ($\text{VP} \rightarrow \text{VBD PP}$, $\text{VP} \rightarrow \text{VBD PP PP}$, ... up to $\text{VP} \rightarrow \text{VBP PP PP PP PP PP PP ADVP PP}$), and thousands of `NP` rules. Viewed as one large grammar the corpus has about a million rule tokens and about 17,500 distinct rule types. This flatness is convenient for coverage but hard on parsing algorithms — one reason grammars extracted from treebanks are usually transformed before use. ### Heads and head finding Each constituent has a lexical **head** — the word in the phrase that is grammatically most important. `N` is the head of an `NP`, `V` of a `VP`. In a lexicalized model each CFG rule designates one right-hand child as the **head child**, and the head word is passed up the tree, so every nonterminal ends up **annotated with its head word**. $$ % caption: A lexicalized tree: every nonterminal is annotated with its lexical % head, propagated up from the head child. "dumped" is the head of the VP and of % the whole S; "workers" heads the subject NP. \begin{tikzpicture}[>=stealth, font=\scriptsize, level distance=9mm, every node/.style={inner sep=1.3pt}, level 1/.style={sibling distance=42mm}, level 2/.style={sibling distance=22mm}, level 3/.style={sibling distance=18mm}] \definecolor{acc}{HTML}{2348F2} \node[text=acc] {S(dumped)} child { node {NP(workers)} child { node {NNS} child { node {\textit{workers}} } } } child { node {VP(dumped)} child { node {VBD} child { node {\textit{dumped}} } } child { node {NP(sacks)} child { node {NNS} child { node {\textit{sacks}} } } } child { node {PP(into)} child { node {\textit{into a bin}} } } }; \end{tikzpicture} $$ Choosing the head child is easy for textbook cases (`NN` heads `NP`) but genuinely controversial for others — is the complementizer _to_ or the verb the head of an infinitival VP? In practice most systems skip declaring heads in the grammar and instead identify them after parsing, walking the finished tree and decorating each node using a hand-written **head percolation table** (the standard one is Magerman's 1995 / Collins' 1999 rules). A typical rule for finding an `NP`'s head: "if the last word is tagged POS, return it; else search right-to-left for the first NN/NNP/...; else search left-to-right for the first NP; ..." Heads are the bridge to [dependency grammar](/natural-language-processing/linguistic-structure/dependency-parsing), where the head-of relation _is_ the structure. ## Grammar equivalence and normal form It is often useful to force every production into a fixed shape — a **normal form**. The one that matters for parsing is **Chomsky Normal Form** (CNF).[^jm-cnf] > **Definition (Chomsky Normal Form).** A CFG is in Chomsky Normal Form if it is > $\epsilon$-free and every production is either $A \rightarrow B\ C$ (two > nonterminals) or $A \rightarrow a$ (one terminal). CNF grammars are **binary > branching**: their trees are binary all the way down to the prelexical nodes. Binary branching is the property the [CKY parsing algorithm](/natural-language-processing/linguistic-structure/constituency-parsing) requires, because CKY fills a chart by combining _two_ adjacent sub-constituents at a time. Any CFG can be converted into a **weakly equivalent** CNF grammar — same language, possibly different trees. The core move is **binarization**: a rule with a right-hand side longer than two is split by introducing fresh nonterminals. $$ % caption: Converting the ternary rule A -> B C D to Chomsky Normal Form. A fresh % nonterminal X absorbs the tail (C D), so each rule branches at most two ways. % The language is preserved (weak equivalence); the tree shape changes. \begin{tikzpicture}[>=stealth, font=\small, level distance=9mm, every node/.style={inner sep=1.5pt}, level 1/.style={sibling distance=16mm}] \definecolor{acc}{HTML}{2348F2} % before \begin{scope} \node {A} child { node {B} } child { node {C} } child { node {D} }; \node[font=\scriptsize, anchor=north] at (0,-2.1) {A $\to$ B C D}; \node[font=\scriptsize, text=acc] at (0,0.9) {before (ternary)}; \end{scope} % arrow \draw[->, acc, very thick] (2.0,-0.9) -- (3.4,-0.9); % after \begin{scope}[xshift=52mm] \node {A} child { node {B} } child { node[text=acc] {X} child { node {C} } child { node {D} } }; \node[font=\scriptsize, anchor=north] at (0,-2.55) {A $\to$ B X, X $\to$ C D}; \node[font=\scriptsize, text=acc] at (0,0.9) {after (binary)}; \end{scope} \end{tikzpicture} $$ Binarization can even make a grammar _smaller_. The flat treebank family $\text{VP} \rightarrow \text{VBD NP PP}^{*}$ (an unbounded run of PPs) needs a separate rule for each PP count — $\text{VP} \rightarrow \text{VBD NP PP}$, $\text{VP} \rightarrow \text{VBD NP PP PP}$, and so on — but two rules generate the whole infinite family: $$ \text{VP} \rightarrow \text{VBD NP PP} \qquad \text{VP} \rightarrow \text{VP PP} $$ Generating a symbol $A$ followed by an unbounded sequence of $B$s via a rule $A \rightarrow A\ B$ is called **Chomsky-adjunction**. Full CNF conversion also removes $\epsilon$-productions and collapses unit chains, but binarization is the piece that CKY depends on. ## Lexicalized grammars The phrase-structure approach so far puts almost everything in the _rules_ and very little in the _lexicon_ — and we have seen the cost twice. Subcategorization forced us to split `Verb` into subtypes and clone `VP` rules; agreement forced us to clone every `S` rule per number and person. The rules multiply, the grammar grows redundant and brittle. **Lexicalized grammars** invert the emphasis: push the grammatical facts into rich lexical entries and keep the combinatory rules few and general. Lexical-Functional Grammar (LFG), **Head-Driven Phrase Structure Grammar** (HPSG), and Tree-Adjoining Grammar (TAG) all take this route to different degrees. We develop one clean example: **Combinatory Categorial Grammar** (CCG).[^jm-lexical] In HPSG and its relatives the **lexical head** is the organizing principle: a word's entry carries its category, its subcategorization frame, its agreement features, and constraints on its arguments, and phrases are built by unifying a head with arguments that satisfy those constraints. The head-annotated trees of the previous section are the same intuition in a lighter form. CCG makes the lexicalization total. ### Categorial categories A **categorial grammar** has three parts: a set of **categories**, a **lexicon** mapping words to categories, and a tiny set of **combination rules**.[^jm-ccg] Categories are either **atomic** (a small set, typically including `S` for sentence and `NP`) or **functional**, built with a slash notation: - $X/Y$ is a function that wants a $Y$ **to its right** and yields an $X$. - $X\backslash Y$ is a function that wants a $Y$ **to its left** and yields an $X$. So a transitive verb like _cancel_ has category $(S\backslash NP)/NP$: it first seeks an object `NP` on its right, yielding $S\backslash NP$ (the category of a verb phrase), which then seeks a subject `NP` on its left, yielding `S`. The subcategorization frame that cost us extra rules in the CFG is now just the verb's _category_ — a fact in the lexicon, not the grammar. $$ % caption: CCG lexical categories. Atomic categories (N, NP) go to arguments; % functional categories encode subcategorization in the slash notation, so % "cancel" is a function seeking an NP right then an NP left to build an S. \begin{tikzpicture}[>=stealth, font=\footnotesize, row/.style={anchor=west, font=\footnotesize}] \definecolor{acc}{HTML}{2348F2} \node[row] at (0,1.5) {\textit{f\/light}}; \node[row] at (2.6,1.5) {: N}; \node[row, font=\scriptsize, anchor=west] at (5.2,1.5) {atomic (an argument)}; \node[row] at (0,0.75) {\textit{Miami}}; \node[row] at (2.6,0.75) {: NP}; \node[row, font=\scriptsize] at (5.2,0.75) {atomic (an argument)}; \node[row] at (0,0.0) {\textit{cancel}}; \node[row, text=acc] at (2.6,0.0) {: (S{\char92}NP)/NP}; \node[row, font=\scriptsize] at (5.2,0.0) {seeks NP right, then NP left}; \node[row] at (0,-0.75) {\textit{give}}; \node[row, text=acc] at (2.6,-0.75) {: ((S{\char92}NP)/NP)/NP}; \node[row, font=\scriptsize] at (5.2,-0.75) {ditransitive: two objects right}; \draw[black] (-0.2,1.15) -- (9.3,1.15); \end{tikzpicture} $$ ### Combining categories Two rules do the basic work. **Forward function application** applies a function to the argument on its right; **backward function application** applies it to the argument on its left: $$ X/Y \;\; Y \;\Rightarrow\; X \qquad\qquad Y \;\; X\backslash Y \;\Rightarrow\; X $$ With these and a lexicon, a derivation grows _downward_ from the words: draw a horizontal line under the elements a rule combines, annotate the end with `>` for forward or `<` for backward application, and repeat until a single `S` spans the sentence. For _United serves Miami_ with _serves_ $: (S\backslash NP)/NP$: $$ % caption: A CCG derivation for "United serves Miami". Forward application (>) % combines "serves" with the object "Miami" to form S\NP; backward application % (<) combines that with the subject "United" to yield S. The derivation grows % downward from the words. \begin{tikzpicture}[>=stealth, font=\footnotesize] \definecolor{acc}{HTML}{2348F2} \node (u) at (0,2) {\textit{United}}; \node (s) at (2.5,2) {\textit{serves}}; \node (m) at (5.6,2) {\textit{Miami}}; \node (uc) at (0,1.45) {NP}; \node (sc) at (2.5,1.45) {(S{\char92}NP)/NP}; \node (mc) at (5.6,1.45) {NP}; % forward application: serves + Miami \draw[black] (1.55,1.1) -- (6.3,1.1); \node[anchor=west, text=acc, font=\scriptsize] at (6.35,1.1) {$>$}; \node at (3.9,0.75) {S{\char92}NP}; % backward application: United + (S\NP) \draw[black] (-0.55,0.4) -- (5.0,0.4); \node[anchor=west, text=acc, font=\scriptsize] at (5.05,0.4) {$<$}; \node at (2.25,0.05) {S}; \end{tikzpicture} $$ The basic categorial approach has exactly the power of a plain CFG — it just moves information from the grammar into the lexicon. The **combinatory** in CCG adds operators that act on functions themselves and add real expressive power. **Composition** combines two adjacent functions into one ($X/Y \;\; Y/Z \Rightarrow X/Z$); **type raising** turns an argument into a function over functions that expect it ($X \Rightarrow T/(T\backslash X)$, so a subject `NP` becomes $S/(S\backslash NP)$, a thing that can compose with the verb phrase to its right). Together these give CCG two capabilities a plain CFG cannot manage cleanly: **coordination of non-constituents** — _We flew IcelandAir to Geneva and SwissAir to London_, where _IcelandAir to Geneva_ is not a traditional constituent — and a graceful, word-by-word, **left-to-right** analysis of **long-distance dependencies** like _the flight that United diverted_, where the object has moved to the front. Because the derivation proceeds one word at a time, CCG is also a favored model of how humans process language incrementally. ### A worked long-distance derivation The relative clause _the flight that United diverted_ shows both operators at work. Give _that_ the lexical category $(NP\backslash NP)/(S/NP)$: it seeks, on its right, a sentence _missing an object_ (an $S/NP$), and turns it into a postmodifier of a noun phrase ($NP\backslash NP$). The problem is that _United diverted_ is a subject followed by a transitive verb $(S\backslash NP)/NP$ — there is no object, and no ordinary constituent of category $S/NP$ to hand _that_. Composition and type raising build one. Type-raise the subject _United_ from $NP$ to $S/(S\backslash NP)$, a function looking for a verb phrase on its right. Then **forward-compose** it with the verb $(S\backslash NP)/NP$: the raised subject seeks an $S\backslash NP$, the verb provides an $S\backslash NP$ but is still waiting on its object $NP$, and composition fuses them into $S/NP$ — exactly _"United diverted, still needing an object"_. That is the $S/NP$ the relative pronoun selects; forward application then yields the $NP\backslash NP$ modifier, and backward application attaches it to _the flight_. $$ % caption: A CCG derivation for the relative clause "the flight that United % diverted". United is type-raised (>T) to S/(S\NP) then forward-composed (>B) with % the transitive verb to give S/NP, the sentence-missing-an-object that "that" % selects. Forward application (>) builds the NP\NP modifier; backward application % (<) attaches it. The object gap is threaded through with no movement machinery. \begin{tikzpicture}[>=stealth, font=\footnotesize, x=1cm, y=1cm] \definecolor{acc}{HTML}{2348F2} \node (w0) at (0,0) {the f\/light}; \node (w1) at (2.6,0) {that}; \node (w2) at (5.4,0) {United}; \node (w3) at (8.4,0) {diverted}; \node[font=\scriptsize] (c0) at (0,-0.6) {NP}; \node[font=\scriptsize] (c1) at (2.6,-0.6) {(NP{\char92}NP)/(S/NP)}; \node[font=\scriptsize] (c2) at (5.4,-0.6) {NP}; \node[font=\scriptsize] (c3) at (8.4,-0.6) {(S{\char92}NP)/NP}; % type raise United \draw[thick] (4.7,-1.0) -- (6.1,-1.0) node[right, font=\scriptsize] {$>$T}; \node[font=\scriptsize] (tr) at (5.4,-1.45) {S/(S{\char92}NP)}; % forward compose United + diverted \draw[thick] (4.6,-1.9) -- (9.2,-1.9) node[right, font=\scriptsize] {$>$B}; \node[text=acc, font=\scriptsize] (comp) at (6.9,-2.35) {S/NP}; % forward application: that + (S/NP) \draw[thick] (1.7,-2.8) -- (9.2,-2.8) node[right, font=\scriptsize] {$>$}; \node[text=acc, font=\scriptsize] (mod) at (5.4,-3.25) {NP{\char92}NP}; % backward application: the flight + modifier \draw[thick] (-0.7,-3.7) -- (9.2,-3.7) node[right, font=\scriptsize] {$<$}; \node[text=acc, font=\scriptsize] (np) at (4.3,-4.15) {NP}; \end{tikzpicture} $$ No trace, no empty category, no movement rule — the gap is a category that never gets its argument, threaded straight through the derivation. This is the same long-distance dependency the Penn Treebank recorded with a co-indexed `-NONE-` node; CCG dispenses with the empty category and lets the type system carry the gap. ## The grammar in the neural era The CFG is a hand-declared object, and for decades a parser searched it explicitly. Modern constituency parsers keep the _tree_ this grammar defines but stop treating the rule set as a separate artifact — the grammar is folded into a learned scoring model. Three public developments show where the formalism landed. **Span-based neural parsing.** Stern, Andreas, and Klein (2017), _"A Minimal Span-Based Neural Constituency Parser"_ (ACL), reframed parsing as scoring **labeled spans** directly: a neural encoder assigns every span $(i, j)$ a score for each constituent label, and a chart search (the same CKY dynamic program, but over learned span scores instead of grammar rules) assembles the highest-scoring tree. The grammar's rules become soft, learned compatibilities rather than a hard rewrite system, and the span-chart search works precisely because of the binary-branching CNF structure the lesson insisted on.[^spanparse] $$ % caption: Span-based neural parsing. Instead of matching CFG rules, the model % scores each span (i, j) for each constituent label with a neural encoder; a CKY % chart search over those scores picks the highest-scoring binary tree. The grammar % becomes a learned scoring function over spans, not an explicit rule set. \begin{tikzpicture}[>=stealth, font=\footnotesize, box/.style={draw, minimum width=30mm, minimum height=8mm, align=center, font=\scriptsize}] \definecolor{acc}{HTML}{2348F2} \node[box] (enc) at (0,0) {encoder\\(self-attention)}; \node[box] (sp) at (4.6,0) {score span (i,j)\\for each label}; \node[box, draw=acc, text=acc] (cky) at (9.2,0) {CKY over\\span scores}; \draw[->, black] (enc) -- (sp); \draw[->, acc] (sp) -- (cky); \node[font=\scriptsize, anchor=north, black] at (4.6,-0.75) {learned, not rule-matched}; \end{tikzpicture} $$ **Self-attention and pretrained encoders.** Kitaev and Klein (2018), _"Constituency Parsing with a Self-Attentive Encoder"_ (ACL), replaced the recurrent encoder with a transformer-style self-attentive one over the span scorer, and later work fed it contextual embeddings from pretrained models like BERT. That combination pushed English constituency parsing on the Penn Treebank past 95 $F_1$ — accuracy that a hand-written grammar, with its coverage gaps and its combinatorial blow-up under agreement and subcategorization, never approached.[^kitaev] The formalism did not change; the source of the scores did. **Grammar induction.** The lesson read a grammar off a treebank by taking each local tree as a rule. A harder question is whether the tree structure itself can be learned from _unannotated_ text. Neural grammar induction — the compound probabilistic context-free grammar of Kim, Dyer, and Rush (2019), _"Compound Probabilistic Context-Free Grammars for Grammar Induction"_ (ACL), and related latent-tree models — learns a probabilistic CFG and its trees jointly from raw sentences, recovering constituent structure without a treebank. These systems are still weaker than supervised parsers, but they close the loop the chapter opened: the CFG is not only a grammar someone writes or reads off annotations, but one a model can discover.[^induction] ## Where this fits A constituency grammar is the declarative theory; a parser is the procedure that searches it. We read a grammar off the Penn Treebank as the union of its local trees, normalized it to CNF so the [CKY chart](/natural-language-processing/linguistic-structure/constituency-parsing) can combine constituents two at a time, and watched the lexicalized formalisms move the grammar's knowledge — subcategorization, agreement, long-distance gaps — into rich lexical entries. In the neural era the rule set dissolves into a learned scoring function over spans, but the tree it defines survives. Two directions follow. The [constituency-parsing lesson](/natural-language-processing/linguistic-structure/constituency-parsing) takes this grammar and gives the dynamic-programming algorithm (CKY) that recovers trees from it, then extends to probabilistic and neural span parsers. The [dependency-parsing lesson](/natural-language-processing/linguistic-structure/dependency-parsing) takes the alternative theory — drop the phrase nodes entirely and let the head-of relation between words _be_ the structure — which the head-finding above already anticipates. Both routes share one goal: turning a flat string of words back into the structure that produced it. [^jm-treebank]: **Jurafsky & Martin**, _Speech and Language Processing_ (3rd ed.), §12.4 — Treebanks: the Penn Treebank, LISP-style bracketed trees, function tags and `-NONE-` traces, the observation that a treebank implicitly defines a (very flat) grammar of ~17,500 WSJ rule types, and head finding via a percolation table. [^jm-cnf]: **Jurafsky & Martin**, §12.5 — Grammar Equivalence and Normal Form: weak vs. strong equivalence, Chomsky Normal Form as $\epsilon$-free binary-branching productions, weakly-equivalent conversion via binarization, and Chomsky-adjunction for unbounded sequences. [^jm-lexical]: **Jurafsky & Martin**, §12.6 — Lexicalized Grammars: pushing grammatical facts into the lexicon (LFG, HPSG, TAG, CCG) to overcome the redundancy of pure phrase-structure rules under subcategorization and agreement. [^jm-ccg]: **Jurafsky & Martin**, §12.6.1 — Combinatory Categorial Grammar: atomic and functional categories with the slash notation, forward/backward function application, and the combinatory operators (composition, type raising) that handle non-constituent coordination and long-distance dependencies. [^spanparse]: **Stern, Andreas, and Klein (2017)**, "A Minimal Span-Based Neural Constituency Parser," _ACL 2017_ — scoring labeled spans with a neural encoder and assembling the tree with a CKY-style chart search over learned span scores, turning the CFG's rules into soft learned compatibilities. [^kitaev]: **Kitaev and Klein (2018)**, "Constituency Parsing with a Self-Attentive Encoder," _ACL 2018_ — a self-attentive (transformer) span-scoring encoder that, combined with pretrained contextual embeddings, pushed Penn Treebank constituency parsing past 95 $F_1$. [^induction]: **Kim, Dyer, and Rush (2019)**, "Compound Probabilistic Context-Free Grammars for Grammar Induction," _ACL 2019_ — jointly learning a probabilistic CFG and its parse trees from unannotated text, recovering constituent structure without a treebank.