💬 NLP

Modeling Narrative Structure in Latin Epic Poetry with Automatically Generated Story Grammars

This paper introduces an interpretable, LLM-based method using few-shot learning to automatically generate story grammar labels for Latin epic poetry, thereby bridging computational analysis and humanistic scholarship to enhance narrative structure understanding and style analysis.

Original authors: Abigail Swenor, John James, Neil Coffee, Walter Scheirer

Published 2026-05-13

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Abigail Swenor, John James, Neil Coffee, Walter Scheirer

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

Imagine you are trying to understand two very different ancient Roman stories: one is a long, winding journey (Virgil's Aeneid), and the other is a chaotic civil war (Lucan's Bellum Civile).

Usually, when computers try to analyze these stories, they turn the words into invisible numbers (like turning a painting into a spreadsheet of colors). This helps the computer do math, but it makes it hard for humans to see why the stories feel different. It's like trying to understand a song by looking at the volume of the sound waves instead of listening to the melody.

This paper proposes a new way to listen to the music. Instead of turning the text into numbers, the authors teach a super-smart AI to label the text with story tags, similar to how a librarian might tag a book with "adventure," "sadness," or "battle."

Here is how they did it and what they found, explained simply:

1. The "Story Grammar" Recipe

The authors created a special set of rules, which they call a "story grammar." Think of this like a recipe for a story. Every story, no matter how complex, is made of basic ingredients:

Who is doing something? (The Character)
What are they doing? (The Action)
To whom/what? (The Object)
Where, when, and why? (The Circumstances)

Instead of just looking at the Latin words, the AI breaks every sentence down into these ingredients. For example, instead of seeing the Latin sentence "Aeneas fled the city," the AI sees a tag that says: [Character: Aeneas] + [Action: Fled] + [Place: City].

2. Teaching the AI (The "Few-Shot" Trick)

The AI they used (a very advanced language model) didn't know this specific "story recipe" beforehand. So, the authors didn't try to retrain the whole AI from scratch. Instead, they used a trick called "few-shot learning."

Imagine you are teaching a child to sort blocks. You don't write a manual for them; you just show them three examples: "This red block goes in the red pile. This blue block goes in the blue pile." Then you say, "Now you sort the rest."

The authors showed the AI 30 examples of Latin text with the correct story tags already applied. The AI quickly figured out the pattern and applied those same tags to thousands of lines of poetry.

3. What They Discovered

Once the AI labeled the two poems, the authors could compare the "tag counts" to see the authors' styles. It's like comparing two chefs by counting how many times they used salt versus pepper.

The Traveler vs. The Fighter: They found that Virgil's Aeneid starts many passages by mentioning places (like "At the shore..."). This fits the story of a hero traveling from place to place.
The Name-Dropper: Lucan's Bellum Civile starts passages much more often by mentioning specific names of people or groups. This fits a story focused on the chaos of war and specific generals.
The Negatives: Lucan used words for "no" or "not" much more often than Virgil, reflecting the grim, negative tone of a civil war.

4. The "Magic Mirror" Test (Semantic Matching)

To prove their method works, they tried to find hidden connections between the two poems. Usually, computers look for words that sound alike. But these two poets often used different words to describe the same idea.

The authors used their story tags to find matches. They found a line in the war poem and a line in the journey poem that had very different words but the exact same story structure (e.g., "Shore against shore" vs. "Standards against standards"). The AI gave them a high score, proving the stories were echoing each other, even though the words were different. This is like recognizing two songs are the same because they have the same rhythm, even if one is played on a piano and the other on a guitar.

5. Why This Matters

The main point of this paper is clarity.

Old Way: Computers give you a list of numbers that only other computers understand.
New Way: Computers give you a list of story tags (like "Character," "Action," "Place") that humans can read and understand immediately.

This allows scholars (humanists) and computer scientists to work together better. The computer does the heavy lifting of reading thousands of lines, but the output is a clear map of the story's structure that anyone can interpret. It helps us see the "skeleton" of the story, rather than just the "skin" (the specific words).

In short: They taught a computer to read ancient poems not by counting words, but by identifying the building blocks of the story, revealing the unique "fingerprint" of each author's style in a way that is easy for humans to understand.

Technical Summary: Modeling Narrative Structure in Latin Epic Poetry with Automatically Generated Story Grammars

Problem Statement
Current computational approaches to "distant reading" in literary studies often rely on transforming text into vector-space embeddings. While effective for specific machine learning tasks, these abstract representations obscure context-rich literary details and lack interpretability for humanists. Traditional methods are often tailored to specific domains or tasks, limiting their generalizability. Furthermore, existing computational analyses of classical texts frequently require specialized datasets or models that do not easily translate across different literary domains or languages. The authors identify a need for a feature set that is both computationally robust and human-readable, capable of capturing narrative structure without relying on opaque statistical patterns.

Methodology
The paper proposes a method for automatically generating "story grammar" labels for input texts using a Large Language Model (LLM) pipeline. The approach is inspired by the psychology of reading, which suggests that humans comprehend narratives through implicit story grammars.

Story Grammar Definition: The authors define a modified story grammar based on transformational grammars (Chomsky 1956). Unlike standard syntactic parsers that focus on formal relationships (e.g., subject, verb, object), this grammar maps text to narrative functions. The core unit is the "semantic triplet" (subject, action, object) surrounded by circumstances (time, place, reason, instrument, outcome). The grammar includes a hierarchy of approximately 28 labels across five levels, ranging from structural brackets (e.g., <narrative>, <event>, <trip>) to terminal labels describing specific narrative roles (e.g., ind-name, circum-place, act-neg).
Model and Training: The study utilizes GPT-5 (OpenAI 2025) to generate these labels. Due to the lack of existing ground-truth data for this specific labeling scheme, the authors employ few-shot learning. They manually labeled 30 lines from Vergil's Eclogues to serve as a training set. These examples, along with the grammar definition and task description, were provided to the model via prompts.
Data Processing: The method was applied to two Latin epic poems: Vergil's Aeneid and Lucan's Bellum Civile. Texts were preprocessed by dividing them into individual poetic lines (passages). The model generated a sequence of story grammar labels for each word in a passage, effectively creating a tree structure representing the narrative function of the text.
Analysis Techniques: The authors employed two primary analysis methods:
1. Frequency Analysis: Counting the occurrence of specific labels and subsequences to identify stylistic patterns.
2. Semantic Matching: Using the generated label sequences as feature vectors for a weighted cosine similarity metric. This metric calculates similarity based on nodes (labels), edges (parent-child relationships), and paths (sequences of length $n=3$ ) to identify intertextual parallels without relying on lexical overlap.

Key Results
The study applied this pipeline to Aeneid (9,897 lines) and Bellum Civile (8,060 lines), as well as a prose text, Livy's Ab urbe condita (Book 1).

Stylometric Differences: The label frequencies revealed distinct narrative strategies. Bellum Civile showed a higher frequency of ind-name (1.047 per line) compared to Aeneid (0.641), aligning with scholarly observations of Lucan's cataloging of proper names. Conversely, Aeneid utilized circum-place more frequently at the start of passages (0.500 vs. 0.470), reflecting Vergil's itinerant structure and spatial framing.
Subsequence Patterns: Common subsequences, such as event, trip, subj, subj-ind, ind-name, were prevalent in both texts, indicating shared epic conventions. However, event, trip, act, act-circum, circum-place was significantly more common in Aeneid, reinforcing the finding that Vergil prioritizes setting before action.
Prose vs. Poetry: When applied to Livy's prose, the model struggled with the longer, more complex sentence structures, overusing the obj-subj label. This highlighted the necessity of style-matched few-shot examples for optimal performance.
Semantic Matching: In a case study comparing Aeneid and Bellum Civile, the story grammar-based semantic matching recovered 501 of 3,410 known intertexts (from the Tesserae benchmark) within the top 10% of results. Notably, it identified high-scoring matches (e.g., score 0.975) between passages with little lexical similarity but similar narrative structures, demonstrating the method's ability to detect parallels based on function rather than vocabulary.

Significance and Claims
The authors claim that this method offers a "human-readable and generalizable feature set" that bridges the gap between computational analysis and traditional literary scholarship.

Interpretability: Unlike embedding-based methods, the output consists of explicit narrative labels (e.g., "named individual," "departure action," "place") that scholars can directly interpret. This allows for the discovery of patterns that are "accessible by humanists and technologists alike."
Generalizability: By avoiding fixed vocabulary mappings and relying on a structural grammar, the method can be adapted to various literary domains and languages, provided appropriate few-shot examples are available.
Complementarity: The authors position this approach not as a replacement for existing NLP tasks but as a complementary feature set. It can be integrated into ensemble learning pipelines for tasks such as stylistics, authorship attribution, allusion detection, and semantic matching.
Validation: The method successfully recovered established literary insights (e.g., Vergil's spatial orientation vs. Lucan's action-driven openings) and identified new structural patterns, validating the utility of story grammars as a tool for computational literary analysis.

The paper concludes that this approach fosters richer collaboration between humanists and technologists by making narrative structure legible at scale while remaining grounded in humanistic categories.