Structured Event Representation (SER)

• Structured Event Representation (SER) is a family of formalisms that model events as explicit structured objects with internal roles and interdependencies.
• SER methods use diverse formats such as tuples, labeled graphs, tensor compositions, and latent frames to facilitate robust extraction and downstream prediction.
• Recent advancements in SER show significant improvements in event extraction, schema induction, and reasoning tasks across NLP, video analysis, and financial prediction.

Structured Event Representation (SER) denotes a family of formalisms that encode events as explicitly structured objects rather than as unstructured text spans or flat embeddings. In the cited literature, SER appears as subject–predicate–object compositions, event tuples, typed directed graphs, latent frame sequences, schema graphs, symbolic state models, and provenance-grounded episodic frames. Across these variants, the common objective is to make event-internal roles, inter-event relations, and higher-order scenario structure computationally explicit for event understanding, extraction, reasoning, schema induction, retrieval, and downstream prediction (Weber et al., 2017, You et al., 2023, Zhang, 2024).

1. Representational scope and core primitives

SER has no single canonical data structure. Instead, the literature instantiates it with several recurring primitives: argument-bearing tuples, labeled graphs, hierarchical schemas, discrete latent frames, symbolic state descriptions, and operational dependency structures. This suggests that SER is best understood as a representational design principle: events are modeled with explicit internal slots or relations, and those structures are then made available to learning, inference, or symbolic execution.

Formalism	Core unit	Representative papers
Event triple or tuple	$(s,p,o)$ or $\langle$trigger, type, argument, role$\rangle$	(Weber et al., 2017, Kuila et al., 2022)
Semantic graph	$G=(V,E,\ell_V,\ell_E,\alpha)$	(You et al., 2023)
Schema graph	$S=(V,E)$ with event, entity, relation, and gate nodes	(Suchocki et al., 2024)
Latent-frame hierarchy	$f_{1:M}$, $z^{(1)},z^{(2)}$	(Rezaee et al., 2020, Dipta et al., 2022)
Symbolic world/state model	state matrices and PDDL domain/problem files	(Zhang, 2024)
Operational event structure	$\mathcal{E}=(E,\#,\leadsto)$	(Pinna, 2020)
Episodic event frame	$\mathbf{e}_t=(F_t,\rho_t^{eml})$	(Lu et al., 10 Jan 2026)

At the tuple level, PESE represents each event record as a single tuple containing trigger span, trigger type, argument span, and role information, formalized as $$et_i=\langle s_i^{tr},e_i^{tr},E_i,s_i^{ar},e_i^{ar},R_i\rangle$$ (Kuila et al., 2022). In tensor-based event composition, transitive events are written as subject, predicate, and object embeddings $\langle$0, with an event embedding $\langle$1 derived by tensor contraction (Weber et al., 2017).

At the graph level, JSEEGraph defines a sentence-level event graph $\langle$2, where nodes denote entities or event triggers, edges encode event types, argument roles, or entity relations, and the anchor map $\langle$3 assigns each node to a token span; because spans are represented by separate nodes, nested and overlapping entities or triggers are directly representable (You et al., 2023). SCI 3.0 adopts a broader schema graph $\langle$4 with event, entity, relation, and logic-gate nodes, together with hierarchy, temporal, participant, and entity–entity relation edges (Suchocki et al., 2024).

Other strands of SER are explicitly symbolic. One line models procedures through sub-event relation graphs, entity-state matrices $\langle$5, or PDDL domain/problem files that can be executed by planners (Zhang, 2024). Another line formalizes dynamic dependencies through Context-Dependent Event Structures $\langle$6, later shown equivalent to a class of causal nets with inhibitor and read arcs (Pinna, 2020). A more recent memory-oriented formulation defines an Episodic Event Frame as $\langle$7, combining a small attributed graph with provenance pointers back to source passages (Lu et al., 10 Jan 2026).

2. Continuous compositional event representations

A central SER problem is how to compose predicate and argument information into a representation that captures both event-level meaning and scenario-level regularities. In tensor-based composition, the predicate-tensor model generates a predicate-specific tensor $\langle$8 from shared tensors $\langle$9 and the predicate embedding $\rangle$0, and then contracts $\rangle$1 with subject and object embeddings. The role-factored tensor model instead learns a single tensor $\rangle$2, computes partial interactions $\rangle$3 and $\rangle$4, and combines them as $\rangle$5. In experiments, $\rangle$6, $\rangle$7, and typically $\rangle$8; training uses either a margin-ranking Predict-Events loss or a cross-entropy Predict-Words loss, optimized with Adagrad at learning rate $\rangle$9, minibatch size $G=(V,E,\ell_V,\ell_E,\alpha)$0, and tuned $G=(V,E,\ell_V,\ell_E,\alpha)$1 regularization (Weber et al., 2017).

These tensor models were introduced precisely because additive or concatenative compositions often fail to distinguish scenario shifts caused by small lexical changes. The empirical results are correspondingly structured around semantic sensitivity. On the Hard Similarity set, tensor models achieve approximately $G=(V,E,\ell_V,\ell_E,\alpha)$2–$G=(V,E,\ell_V,\ell_E,\alpha)$3 accuracy, compared to $G=(V,E,\ell_V,\ell_E,\alpha)$4–$G=(V,E,\ell_V,\ell_E,\alpha)$5 for a two-layer NN and $G=(V,E,\ell_V,\ell_E,\alpha)$6 for simple averaging. On Transitive Sentence Similarity, the role-factored and predicate-tensor models both obtain approximately $G=(V,E,\ell_V,\ell_E,\alpha)$7 Spearman’s $G=(V,E,\ell_V,\ell_E,\alpha)$8, above the NN at $G=(V,E,\ell_V,\ell_E,\alpha)$9, the multiplicative baseline at $S=(V,E)$0, and averaging at $S=(V,E)$1. On Multi-Choice Narrative Cloze, the role-factored model reaches $S=(V,E)$2 under event prediction, compared with $S=(V,E)$3 for the NN; in schema generation, average human relevance scores are $S=(V,E)$4 for Relgrams, $S=(V,E)$5 for the compositional NN, and $S=(V,E)$6 for the role-factored model. The accompanying nearest-neighbor schema induction procedure uses predicate-diversity $S=(V,E)$7, entity-match $S=(V,E)$8, and acceptance thresholds $S=(V,E)$9 for the role-factored model or $f_{1:M}$0 for the NN, with about $f_{1:M}$1 candidate neighbors (Weber et al., 2017).

A later PLM-based line addresses a different weakness: event texts are often too short relative to pretraining distributions. PromptCL therefore wraps an event triple $f_{1:M}$2 in the prompt template “subject is $f_{1:M}$3, predicate is $f_{1:M}$4, object is $f_{1:M}$5” with Bernoulli insertion probability $f_{1:M}$6, uses BERT-base-uncased as encoder, adopts canonical SPO order, and adds Event-oriented Masked Language Modeling that masks an entire semantic component rather than random subwords. The contrastive objective is InfoNCE-style with two prompt-augmented positives per anchor and temperature $f_{1:M}$7. On the Original Hard Similarity benchmark, PromptCL reaches $f_{1:M}$8 versus $f_{1:M}$9 for SWCC; on the Extended benchmark, $z^{(1)},z^{(2)}$0 versus $z^{(1)},z^{(2)}$1; on Transitive Sentence Similarity, both obtain $z^{(1)},z^{(2)}$2; and on MCNC zero-shot transfer, PromptCL reaches $z^{(1)},z^{(2)}$3 versus $z^{(1)},z^{(2)}$4. Ablations show that removing the prompt template reduces Original by $z^{(1)},z^{(2)}$5, Extended by $z^{(1)},z^{(2)}$6, and Transitive by $z^{(1)},z^{(2)}$7, while removing SPO order reduces Original by $z^{(1)},z^{(2)}$8, Extended by $z^{(1)},z^{(2)}$9, and Transitive by $\mathcal{E}=(E,\#,\leadsto)$0 (Feng et al., 2024).

Taken together, these results counter the misconception that SER in continuous space is merely a matter of averaging lexical embeddings. In these studies, multiplicative composition and role-explicit prompting materially change what semantic distinctions the representation can encode.

3. Structured extraction and graph-based prediction

SER is also a target representation for information extraction. In this setting, the issue is not only how to embed an event, but how to recover its internal structure from text while preserving dependencies among triggers, arguments, relations, and nested spans.

JSEEGraph casts event extraction as general graph parsing. A pretrained XLM-R encoder produces token representations, learned queries are refined by Transformer encoder layers, node types are predicted by cross-entropy, node anchors by biaffine attention, and edges by separate biaffine scores for edge presence and edge labels. The graph is constrained so that $\mathcal{E}=(E,\#,\leadsto)$1trigger edges carry event types, trigger$\mathcal{E}=(E,\#,\leadsto)$2entity edges carry argument roles, and entity$\mathcal{E}=(E,\#,\leadsto)$3entity edges carry relation types. Because mentions are separate nodes with independent anchor spans, overlap and nesting are represented directly rather than approximated by sequence labels. On ACE05, JSEEGraph obtains argument-identification F1 of approximately $\mathcal{E}=(E,\#,\leadsto)$4, about $\mathcal{E}=(E,\#,\leadsto)$5 percentage points above the previous best single model; when moving from heads-only ACE-E$\mathcal{E}=(E,\#,\leadsto)$6 to full-span ACE-E$\mathcal{E}=(E,\#,\leadsto)$7 with heavy nesting, argument F1 drops by only about $\mathcal{E}=(E,\#,\leadsto)$8 points; and removing entity and relation nodes hurts argument extraction by about $\mathcal{E}=(E,\#,\leadsto)$9–$\mathbf{e}_t=(F_t,\rho_t^{eml})$0 F1 points (You et al., 2023).

PESE uses a different SER target: each output step is an event tuple $\mathbf{e}_t=(F_t,\rho_t^{eml})$1trigger phrase, trigger type, argument phrase, role$\mathbf{e}_t=(F_t,\rho_t^{eml})$2. The encoder combines BERT with POS tags, dependency labels, entity-type tags, and character-level CNN features. The decoder is an LSTM conditioned on an attention-pooled sentence summary and the sum of previously generated tuple embeddings. Separate pointer networks predict trigger and argument spans, and classification heads predict event type and role label. On ACE2005, PESE’s best average results over four runs are TI $\mathbf{e}_t=(F_t,\rho_t^{eml})$3, $\mathbf{e}_t=(F_t,\rho_t^{eml})$4, $\mathbf{e}_t=(F_t,\rho_t^{eml})$5; TC $\mathbf{e}_t=(F_t,\rho_t^{eml})$6, $\mathbf{e}_t=(F_t,\rho_t^{eml})$7, $\mathbf{e}_t=(F_t,\rho_t^{eml})$8; AI $\mathbf{e}_t=(F_t,\rho_t^{eml})$9, $$et_i=\langle s_i^{tr},e_i^{tr},E_i,s_i^{ar},e_i^{ar},R_i\rangle$$0, $$et_i=\langle s_i^{tr},e_i^{tr},E_i,s_i^{ar},e_i^{ar},R_i\rangle$$1; and ARC $$et_i=\langle s_i^{tr},e_i^{tr},E_i,s_i^{ar},e_i^{ar},R_i\rangle$$2, $$et_i=\langle s_i^{tr},e_i^{tr},E_i,s_i^{ar},e_i^{ar},R_i\rangle$$3, $$et_i=\langle s_i^{tr},e_i^{tr},E_i,s_i^{ar},e_i^{ar},R_i\rangle$$4 (Kuila et al., 2022).

SPEECH frames event detection and event–event relation extraction as structured prediction with energy-based modeling. Token-level, sentence-level, and document-level energies combine local feature terms with learned label-interaction terms, while event classes are simultaneously represented by hyperspheres $$et_i=\langle s_i^{tr},e_i^{tr},E_i,s_i^{ar},e_i^{ar},R_i\rangle$$5 with radius typically set to $$et_i=\langle s_i^{tr},e_i^{tr},E_i,s_i^{ar},e_i^{ar},R_i\rangle$$6. The total loss combines structured-hinge terms, cross-entropy, and $$et_i=\langle s_i^{tr},e_i^{tr},E_i,s_i^{ar},e_i^{ar},R_i\rangle$$7 weight decay across all three levels. The reported pattern is consistent: SPEECH outperforms CNN- or BiLSTM-CRF, BERT-CRF, generative T5 systems, and prior hypersphere methods by $$et_i=\langle s_i^{tr},e_i^{tr},E_i,s_i^{ar},e_i^{ar},R_i\rangle$$8–$$et_i=\langle s_i^{tr},e_i^{tr},E_i,s_i^{ar},e_i^{ar},R_i\rangle$$9 F1 points on both event detection and event-relation extraction, with particular strength on low-frequency classes and relation types (Deng et al., 2023).

Across these systems, SER functions as a decoding target that preserves interdependencies that pipeline decompositions often lose. This is explicit in PESE’s tuple conditioning, in JSEEGraph’s joint graph inference, and in SPEECH’s learned global label interactions.

4. Latent frames, scripts, and semantic hierarchy

A different SER tradition represents events through structured latent variables rather than directly observed tuples or graphs. Here the focus is narrative schema induction, script modeling, and abstraction over multiple levels of semantic organization.

One approach uses a sequential neural variational autoencoder with discrete latent frame variables. A document of $\langle$00 events, each represented as a 4-tuple $\langle$01verb, subject, object, modifier$\langle$02, is flattened into a token sequence $\langle$03 with $\langle$04. The latent variables $\langle$05 are one-of-$\langle$06 semantic frames, with some fraction $\langle$07 observed during training. The decoder is a unidirectional GRU that attends over inferred frame embeddings; the encoder is a bidirectional GRU whose logits are biased by observed frame indicators $\langle$08, and Gumbel-Softmax provides differentiable sampling. The optimized objective is $\langle$09, mixing reconstruction, a KL-derived term, and supervised classification (Rezaee et al., 2020).

The quantitative results show that partially supervised discrete SER can substantially alter script induction performance. On Wikipedia event sequences, test perplexity is $\langle$10 for an RNNLM baseline, about $\langle$11 for RNNLM+ROLE, $\langle$12 for HAQAE, and $\langle$13 for the proposed model at $\langle$14. On held-out Wikipedia inverse narrative cloze, HAQAE reaches $\langle$15 while the model reaches $\langle$16 at $\langle$17; on NYT cross-domain evaluation, HAQAE is about $\langle$18 while the model reaches $\langle$19. With $\langle$20 supervision, frame-label classification reaches $\langle$21 accuracy, and the model still reaches $\langle$22 $\langle$23 with only $\langle$24 frame supervision (Rezaee et al., 2020).

Semantically-informed hierarchical event modeling adds a second hierarchy: structural compression and ontological abstraction. The observed sequence $\langle$25 is paired with discrete latent layers $\langle$26; in the two-layer instantiation, $\langle$27 is a FrameNet frame sequence and $\langle$28 is a shorter compression layer. Partial supervision at layer 1 adds $\langle$29 to the amortization logits for observed frame $\langle$30, while ontological injection at layer 2 adds $\langle$31, where $\langle$32 is derived from FrameNet parent or scenario frames. Training uses a weighted ELBO with reconstruction at both layers, KL terms, and a cross-entropy term on observed frames; optimization uses Adam, Gumbel-Softmax with annealed temperature, $\langle$33-d GloVe event embeddings, $\langle$34-d frame embeddings, 2-layer BiGRU encoders and 2-layer GRU decoders with hidden size $\langle$35, gradient clipping at norm $\langle$36, and $\langle$37 averaged Gumbel-Softmax samples (Dipta et al., 2022).

The reported outcome is that this doubly hierarchical, semi-supervised framework out-performs previous state-of-the-art approaches by up to $\langle$38 across two datasets and four evaluation metrics (Dipta et al., 2022). A plausible implication is that SER gains are not solely due to local event-role structure; abstraction over frame ontologies can also improve event modeling.

5. Schema graphs, symbolic reasoning, and executable semantics

In schema-centric SER, the representation itself is designed to be browsable, editable, and in some cases executable. SCI 3.0 is representative: it models a schema as a typed, labeled, directed graph whose node classes are chapter and primitive events, entities, relations, and OR/XOR logic gates, with hierarchy, temporal, participant, and relation edges. The underlying Schema Data Format is JSON Schema/JSON-LD with top-level keys @id, sdfVersion, version, events[], entities[], relations[], and logicGates[]. The interface is built with React.js, Cytoscape.js, and Flask; edits are synchronized bidirectionally between graph and JSON; and backend validation enforces unique IDs, referential integrity, and type constraints with worst-case complexity $\langle$39. In the RESIN pipeline, a second manual iteration doubles both event and participant coverage (Suchocki et al., 2024).

A broader reasoning-oriented formulation distinguishes three SER regimes. The first is a language-based event graph $\langle$40 over sub-events and relations such as goal–step or temporal links, trained by cross-entropy over relation labels. The second is a semi-symbolic entity-state matrix $\langle$41 whose cells store attribute values for entities after each step of a procedure. The third is a fully symbolic representation in PDDL, where an LLM translates text into domain and problem files that can be solved by a planner. On commonsense and planning tasks, these forms greatly outperform end-to-end LLMs: intent detection improves from about $\langle$42 to about $\langle$43; step–step pretraining boosts few-shot next-event prediction by $\langle$44–$\langle$45 points; on OpenPI2.0, schemata $\langle$46 is about $\langle$47 and state accuracy about $\langle$48 for text-davinci; code prompts raise CREPE event-likelihood-change performance from $\langle$49 to $\langle$50 $\langle$51; and on PROC2PDDL, GPT-4 reaches action accuracy of about $\langle$52 and plan-solve of about $\langle$53, versus $\langle$54–$\langle$55 for end-to-end baselines (Zhang, 2024).

SER also has an operational semantics tradition. Context-Dependent Event Structures formalize dynamically changing dependencies as $\langle$56, where $\langle$57 is conflict and $\langle$58 is a context-dependency relation over finite sets of alternative contexts. Elementary C-DES can be translated into labeled Petri nets $\langle$59 whose transitions correspond to contextual alternatives and whose inhibitor and read arcs test what has and has not happened so far. Proposition 6.3 states adequacy of the mapping, and Theorem 6.9 states full abstraction between well-behaved causal nets and elementary C-DES (Pinna, 2020).

Recent memory architectures extend schema ideas into long-horizon agent systems. Structured Episodic Event Memory defines an Episodic Event Frame $\langle$60, stores static facts in a graph memory layer $\langle$61, merges adjacent descriptions via agentic associative fusion, and reconstructs narrative context through Reverse Provenance Expansion. The paper reports significant gains on LoCoMo and LongMemEval, including an example gain of $\langle$62 points on LongMemEval (Lu et al., 10 Jan 2026).

These frameworks clarify a frequent confusion around SER. SER is not restricted to learned embeddings; in several strands it is a directly inspectable and sometimes executable object whose structural constraints are part of the modeling objective.

6. Applications, evaluation regimes, and interpretability

SER has been applied in NLP, video understanding, memory systems, and financial prediction. The applications differ substantially, but the repeated argument is that explicit event structure improves generalization, interpretability, or zero-shot transfer.

In large-scale video retrieval, EventNet organizes $\langle$63 events and $\langle$64 event-specific concepts mined from $\langle$65 YouTube videos and WikiHow categories. A CNN identical to AlexNet is trained over the $\langle$66 events using about $\langle$67 million sampled frames, producing $\langle$68-d fc7 features; $\langle$69 binary SVMs then define a concept-based representation $\langle$70. On zero-shot retrieval, EventNet’s representation reaches $\langle$71 mAP on TRECVID MED versus $\langle$72 for the best prior ImageNet-20K CNN baseline, and $\langle$73 mAP on CCV versus $\langle$74 (Ye et al., 2015).

In video event-relation prediction, structural symbolic representation uses event type plus argument roles and entities as the input sequence $\langle$75. A key finding is methodological: the earlier $\langle$76 macro-accuracy failure of SSR-only baselines was traced to training configuration, especially a learning rate of $\langle$77. With learning rate $\langle$78, the SSR-only model reaches $\langle$79 macro-accuracy, and $\langle$80 with balanced loss; an Event-Sequence model over all five video events plus all arguments reaches $\langle$81; and VisualCOMET pretraining raises this to $\langle$82. The same study argues that evaluation using only video as input is currently unfeasible and that oracle event information is needed for accurate evaluation; it also reports that adding video features such as SlowFast or CLIP hurts rather than helps, while SSR with predicted verbs and arguments still reaches $\langle$83 versus $\langle$84 for SlowFast (Lu et al., 2023).

In financial prediction, SER is used as an LLM-extracted, entity-linked event interface to news. GPT-3.5-turbo produces JSON arrays of subject–action–object events with DBpedia links and source context; normalized subject, action, and object embeddings are composed as $\langle$85, aggregated by hierarchical self-attention, and mapped to returns by an MLP. Out of sample from 2008 to 2022, the daily long–short portfolio formed on SER predictions yields annualized return $\langle$86 $\langle$87, Sharpe ratio $\langle$88, and Fama–French 5-factor $\langle$89 of $\langle$90 $\langle$91; the weekly portfolio yields annualized return $\langle$92 $\langle$93, Sharpe ratio $\langle$94, and $\langle$95 $\langle$96 $\langle$97. In Fama–MacBeth regressions, SER-based predicted returns enter with coefficients of about $\langle$98 daily and about $\langle$99 weekly, with $\rangle$00-statistics above $\rangle$01. Interpretation is provided by gradient-based attribution over exact event triplets, entities, and LDA-derived topics (Li et al., 22 Dec 2025).

A recurring evaluation issue across domains is that the benefits of SER often depend on isolating structure-sensitive reasoning from upstream perception errors. This is explicit in graph parsing and tuple decoding benchmarks, in schema curation workflows that include human editing, and in video event-relation work that separates oracle event inputs from raw visual perception. Another recurring issue is that “structured” does not imply a single trade-off profile: tensor composition prioritizes semantic sensitivity, graph parsers prioritize joint consistency, latent models prioritize abstraction, and symbolic systems prioritize interpretability and executable reasoning.

Across these strands, SER emerges not as a single model family but as a unifying commitment to explicit event structure. The representations differ—continuous, graph-based, latent, symbolic, operational, or hybrid—but the literature repeatedly treats explicit structure as the mechanism by which events become comparable, compositional, interpretable, and usable in downstream inference.