← Latest papers
💬 NLP

Constituency Structure over Eojeol in Korean Treebanks

This paper advocates for an eojeol-based constituency representation in Korean treebanks, where morphological details are encoded in a separate layer, to resolve structural ambiguities, enable cross-treebank comparison, and facilitate alignment with dependency resources.

Original authors: Jungyeul Park, Chulwoo Park

Published 2026-06-25
📖 5 min read🧠 Deep dive

Original authors: Jungyeul Park, Chulwoo Park

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: How to Build a Sentence Map

Imagine you are trying to draw a family tree for a sentence. In English, this is relatively easy because the "leaves" of the tree are just the words you see on the page.

But in Korean, words are like Lego bricks glued together. A single "word" on the surface (called an eojeol) is often a main Lego brick (the root word) with several smaller, specialized bricks (grammar markers, tense, case) snapped onto it.

The paper asks a fundamental question: When we draw the family tree of a Korean sentence, should the "leaves" be the whole glued-together Lego block, or should we break it apart and make every tiny brick a separate leaf?

The Three Old Approaches (The "Treebanks")

The authors looked at three existing ways people have tried to map Korean sentences (Sejong, Penn Korean, and KAIST). They found that each group made different choices, which made it very hard to compare their work:

  1. The "Glued Block" Approach (Sejong): They kept the whole Lego block together as one leaf. Inside the block, they wrote down what the tiny bricks were, but they didn't break the block apart in the tree structure.
  2. The "Glued Block with Ghosts" Approach (Penn Korean): Similar to Sejong, but they added "ghost" leaves (empty spots) for words that were implied but not spoken, to make the tree look more like English trees.
  3. The "Un-glued" Approach (KAIST): They broke the Lego blocks apart. They treated the tiny grammar bricks as separate leaves in the tree. This made the tree very deep and complex, mixing the "how the word is built" with "how the sentence is built."

The Result: Because they used different "leaves," you couldn't easily compare these trees or use them together. It was like trying to compare a map drawn in miles with a map drawn in kilometers without converting the units first.

The Paper's Solution: The "Eojeol" Backbone

The authors argue that the best way to build a Korean sentence tree is to use the glued Lego block (the eojeol) as the leaf.

Think of it like this:

  • The Tree (Syntax): This represents how the sentence is organized. Who is doing what to whom? The authors say this structure should be built on top of the eojeol (the whole word unit).
  • The Labeling Sheet (Morphology): This is a separate sheet of paper attached to the tree. On this sheet, you write down exactly how the eojeol is built (e.g., "Root + Past Tense + Question Mark").

The Analogy:
Imagine a restaurant menu.

  • The Tree is the list of dishes (Appetizers, Mains, Desserts). This is the structure of the meal.
  • The Ingredients are the details inside each dish (e.g., "Steak with garlic butter and rosemary").

The paper argues: Don't make the "garlic" and the "rosemary" separate main courses on the menu. Keep the "Steak" as the main course (the eojeol), but list the ingredients (the morphemes) in the description next to it.

Why This is Better

The authors claim this approach solves three big headaches:

  1. It stops the "Mix-Up": If you break the word apart in the tree, you confuse the rules of how words are made (grammar) with how sentences are made (syntax). Keeping them separate keeps the map clean.
  2. It makes friends with other maps: Most other Korean language tools (like dependency parsers) already use the eojeol (the whole block) as their unit. By using the same unit, this new tree can easily talk to those other tools without needing a translator.
  3. It's ready for the future: If you want to build a computer program that reads Korean from start to finish (end-to-end), it's easier if the program sees the whole word first, rather than trying to guess where the tiny grammar bricks start and stop before it even understands the sentence.

The Proposal: A New Format

The paper proposes a specific way to write these trees down. Imagine a spreadsheet with six columns:

  1. ID: A number for the word.
  2. The Word: The whole eojeol (e.g., "stepped-out-past").
  3. The Breakdown: How the word is built (e.g., "step" + "out" + "past").
  4. The Type: Is it a noun, verb, or adjective? (Using a universal tag).
  5. The Left Bracket: Where a phrase starts.
  6. The Right Bracket: Where a phrase ends.

This format lets you see the sentence structure (the brackets) and the word details (the breakdown) side-by-side, without mixing them up.

The Bottom Line

The paper doesn't say that breaking words apart is "wrong" for linguistics. It just says that for drawing the sentence tree, we should use the whole word (eojeol) as the building block. We can still keep all the detailed information about the tiny bricks, but we should keep that information in a separate "notes" section, not inside the tree structure itself. This makes the trees easier to compare, easier to use with other tools, and clearer to understand.

Drowning in papers in your field?

Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.

Try Digest →