VIS · Claude Sonnet 5 · C3

IEEE VIS author-community analysis — C3 · ATWL + library

C3

Raw session log. Atwl spec + example + 54-workflow library (atwl form).

6 turns (3 user · 3 assistant) json raw log

1 Researcher

You have received three files: the ATWL specification, which defines a formal language for representing visual analytics workflows; an example workflow expressed in ATWL; and a document titled ATWL Library: Titles and ATWL Representations, which contains 53 visual analytics workflows drawn from the published research literature, each formalised in ATWL. The library was curated by our research group.

Please read all three carefully before we proceed.

The ATWL specification describes the language's artifact types, transform intents, actor designations, loop constructs, and syntax. The example workflow illustrates how these elements are used together to describe a specific visual analytics process. Note that the example represents one type of workflow among many possible; its specific analytical structure reflects its particular task and should not be treated as a template that must be followed for other tasks. What the example illustrates is how the language is used — the syntax, the vocabulary, and the conventions for organising artifacts, transforms, and loops.

The library is a resource of formalised workflows that you may consult when designing your recommendation. Each library workflow addresses a specific analytical problem in a specific domain. You may draw on the library to identify workflow structures, iteration patterns, artifact typing conventions, or methodological approaches that could inform your recommendation for the target task. You may combine elements from multiple library workflows, adapt them, or design new elements as the task requires. You are not obliged to use the library, but you should treat it as a substantive source of design ideas.

In the next message I will describe a specific visual analytics design task. Your job will be to design an analytical workflow that addresses the task, and to express your recommendation both in natural language (for readability) and in ATWL (for structural precision). The natural-language description should explain the analytical logic of the workflow; the ATWL representation should formally specify the artifacts, transforms, loops, actors, and control flow. Where you draw on specific library workflows, please cite them by name so the sources of your recommendation are traceable.

Before we proceed, could you briefly confirm that you have absorbed the specification, the example, and the library, and let me know if you have any questions about the language, the syntax, or the library before the task is described?

You need to reply in English.

2 Model

I've read all three documents carefully: the ATWL specification (artifact types, transform intents, control structures, syntax), the example workflow (behaviour-pattern-recognition-in-time-series, illustrating iterative feature engineering and model refinement for trajectory classification), and the full 53-workflow library.

A few observations that will inform how I use these materials once you describe the task:

On the specification: I've absorbed the distinctions that matter most for producing precise ATWL — particularly the difference between internal structure and embedment for entities; the difference between pattern (descriptive regularity), knowledge (interpreted statement — evaluative from assess vs. substantive from generate-knowledge), and specification (control knowledge); and the loop/conditional/assignment conventions including the two termination styles (explicit assessment vs. implicit).

On the example: I understand this illustrates one particular analytical shape (episode definition → iterative clustering/feature refinement → exemplar labeling → supervised model training → iterative model refinement → synthesis) suited to its specific task (behavioral pattern recognition in trajectories). I won't treat its structure as a mandatory template.

On the library: I now have a working sense of the range of structural idioms available — e.g., cluster-calendar's single refinement loop with explicit parameter adjustment; MobilityGraphs' and van Andrienko's ST-analysis-modelling's nested loops for multi-phase analysis; EventFlow's and IVESA's progressive simplification loops; StratomeX's and Coral's query-guided cohort/element accumulation patterns; DPVis' and SOMFlow's hierarchical/provenance-tree exploration with flow graphs; ParaGlide's and Tuner's response-surface sampling-and-refinement loops; the RelEx/Kokiri/VBridge family of comparison-and-explanation workflows; and several human-in-the-loop labeling workflows (DaedalusData, active gaze labeling, image-based projection labeling) that combine embedding, clustering, and progressive labeling loops. This gives me a decent palette of precedents to draw on depending on what your task calls for.

I don't have clarifying questions about the language or library at this point — the specification is detailed enough and the library examples are extensive enough that I feel ready to proceed. I'm ready for you to describe the design task.

3 Researcher

The IEEE VIS conferences (Vis, InfoVis, VAST, SciVis) have accumulated 3596 papers between 1990 and 2024. Each paper record contains the list of authors, publication year, title, abstract, keywords, and citations. Author names have been disambiguated against DBLP (unique author identifiers are provided alongside the raw name strings).

A research analyst studying the intellectual structure of the visualization community wants to identify the major communities of collaborating researchers and characterise how they have evolved. The analyst expects that a community typically has a relatively stable core of leading researchers who continue collaborating across many years, while other members may move between communities over time or contribute to several communities simultaneously. Each community should also be associated with its major research foci — the topics or problem areas that characterise its work.

The analyst wants to answer questions such as: how many distinct communities can be identified? How stable is each community's core, and who are its leaders? What are its main research foci, and how have they evolved? How does membership overlap between communities, and how does it change over time? Do communities merge, split, or dissolve, and if so, when and why?

The analyst will need to inspect intermediate results visually and use domain knowledge to interpret patterns and make judgements at each stage.

Design an analytical workflow for this problem.

4 Model

I'm breaking down the problem: I need to analyze co-authorship networks across IEEE VIS papers from 1990-2024 to identify research communities, track how they evolve over time, understand their stability and leadership, and detect when communities merge, split, or dissolve.

This is a dynamic network analysis problem—similar to approaches like EventThread for tracking community evolution and branching patterns. I'll need community detection algorithms on the co-authorship graphs, temporal tracking to monitor membership changes and leadership shifts, topic modeling on abstracts and keywords to characterize each community's research focus, and methods to identify structural events like mergers and splits.

Now I'm thinking through the actual workflow. I'd construct sliding-window snapshots of the co-authorship network over time, apply community detection to each window to find clusters of collaborating researchers, then track communities across windows by matching author membership overlap to identify continuity, merges, splits, and dissolutions. This creates an evolution graph showing how communities form, persist, and transform.

For each community, I'd identify its stable core members (those appearing across many consecutive windows) and key leaders based on centrality metrics or publication impact. Then I'd aggregate the papers from community members and apply topic modeling to characterize their research focus areas. Finally, I'd visualize this evolution using something like a Sankey or alluvial diagram showing how communities flow and transform over time, similar to existing temporal network visualization approaches.

Since community detection involves tunable parameters like resolution and window size, I need to build in iterative refinement loops where I can assess results and adjust settings. This lets me zoom into individual communities to examine their timeline, membership stability, and how their research focus shifts—all with human guidance steering the process.

EventThread's approach to decomposing temporal stages into threads with branching and merging is directly applicable here: I can treat communities as threads and time windows as stages, giving me a strong structural template for the workflow. I'm pulling in visualization techniques from related work—NodeTrix for inspecting community structure within single time windows, Kokiri for characterizing what makes communities distinct through feature importance, and topic modeling approaches for understanding research focus. Now I'm laying out the actual workflow: starting with data preparation where I define overlapping time windows over the paper corpus.

For each window, I construct a co-authorship network and run community detection with iterative parameter tuning to assess quality. Then I track how communities evolve by computing overlap metrics like Jaccard similarity between consecutive time periods to identify merges, splits, and persistence patterns. Continuing with centrality measures like betweenness to identify leaders within each community window, then visualizing core member stability through a heatmap and highlighting leadership roles in the network view. Next I'll aggregate the papers' metadata by community and time window to apply topic modeling and track how research foci evolve across each community's lineage. Then I need to compute membership overlap between communities at the individual researcher level—capturing who moved between communities or participated in multiple ones simultaneously—and display this as trajectories through communities over time. After that comes an interactive validation phase where analysts can drill into specific lineages, inspect members and papers, and iteratively refine parameters like window size and detection thresholds. Finally I'll synthesize the findings by documenting the number of distinct communities discovered and characterizing them through metrics like core size, persistence, leadership patterns, research focus evolution, and the timing of merge/split/dissolve events.

Now I'm thinking through how to structure this as an ATWL representation with appropriate artifacts and transforms. I need to define the data artifacts first—starting with papers as the foundational entity, where each paper contains authors, title, abstract, keywords, and citations.

Authors could be extracted as a derived entity set from the papers through a transformation that disambiguates them using DBLP IDs. I also need to establish time windows as either a specification artifact defining window size and stride, or as context entities that get used during arrangement operations.

For the co-authorship networks, I'm modeling these as entities with a graph formation structure indexed by time — essentially network snapshots where each window gets its own author collaboration graph with nodes representing authors and edges representing co-authorship relationships. This mirrors the snapshot approach from other workflows, where I can represent the network structure and temporal embedment as relational configuration features.

Now I'm setting up community detection by applying a clustering transform on these networks with configurable parameters, which produces community entities grouped by cluster and positioned within each time window. Each community tracks its member authors, size, and modularity contribution. Then I'll visualize these communities using a node-link or NodeTrix-style layout to assess the quality of the clustering, iterating on the resolution parameter to balance modularity and interpretability. Finally, I'm computing how communities evolve across consecutive time windows by measuring pairwise overlaps between them, capturing this evolution as a relational feature across the temporal dimension.

Next I'm matching communities across windows to form lineages—treating these as super-entities that represent a community's identity over time, similar to how threads work in EventThread. Each lineage is an ordered sequence of community instances tracked as a set. Then I'll classify the transitions between consecutive communities in each lineage, categorizing them as merge, split, birth, dissolve, or continue events. After that I'm visualizing this evolution using an alluvial or flow diagram...

For core and leadership identification, I'm using author membership data across windows to extract persistent members and compute centrality-based leaders per window. I'll visualize core stability as a heatmap showing author presence across time for each lineage, and highlight leadership positions in the network. Then I'm applying topic modeling on the aggregated text from community members' papers to extract topic weights per community-window and track how research foci evolve. Finally, I'm examining membership overlap across communities to trace individual-level author trajectories...

I need to wrap this in a parameter refinement loop covering window size, community detection resolution, and overlap-matching thresholds, then synthesize findings from the entire pipeline. The structure should follow precedents like MobilityGraphs with nested loops or EventThread's decompose-cluster-abstraction pattern.

Now I'm sketching out a template that chains together the key operations: starting with window definition and author extraction to build co-authorship networks, then looping through community detection with modularity assessment and visualization, computing inter-window overlaps to track lineage formation, classifying transitions, arranging the evolution timeline with flow diagrams, extracting stability metrics and core members, building topic models per lineage-window, tracking author trajectories, and continuing with abstraction steps...

The complexity mirrors what I see in other library workflows like ST_analysis_modelling, which also nest loops for grouping and evaluation. I'm thinking about how to structure this with an outer loop for community detection that iteratively clusters the co-authorship networks per window, adjusting the resolution parameter globally across all windows using aggregate assessment statistics rather than per-window tuning, to maintain consistent methodology throughout.

Then I'd have a separate step to link communities into lineages and classify events—deterministic given an overlap threshold, though that threshold might need some calibration. After that comes the topic modeling loop similar to cluster-calendar's pattern with iterative refinement for choosing the number of topics. Finally, a synthesis step to wrap everything together.

I'm aiming for a moderately detailed workflow comparable to MobilityGraphs or ST_analysis_modelling—two-phase with nested loops—plus natural language documentation. I also need to think through how communities have evolved over time and what drove those changes.

For the evolution piece, I need to correlate merges and splits with topic shifts and leader departures, treating this as an abstraction step that links transition types to research focus changes. Now I'm drafting the citations to existing library workflows I'm drawing from: EventThread for the thread branching and merging via tensor decomposition, StratomeX for the column-band overlap visualization across time windows, and MobilityGraphs for the two-phase clustering structure with iterative refinement loops.

I'm also pulling from cluster-calendar for the iterative clustering assessment and adjustment pattern, UTOPIAN for the topic modeling loop to characterize research foci, SOMFlow for hierarchical exploration and provenance tracking, and NodeTrix for inspecting community structure within individual time windows using a hybrid node-link and matrix view.

Now I'm ready to write out the full ATWL specification, being careful with the syntax for artifact declarations, transforms, loops, and conditionals. Let me start planning the artifact IDs.

I'm defining the papers dataset as an entity collection with authors, year, title, abstract, keywords, and citation counts as features—using reference types for author IDs even though authors aren't yet declared as separate entities. I'm also setting up the window configuration as a specification artifact where the analyst provides initial parameters like a 3-year sliding window with 1-year stride.

Now I'm laying out the transformation pipeline: first, a define-unit transform that partitions the papers into time windows based on the configuration, creating a new entity collection with window IDs and year ranges. Next, I need to extract authors as distinct entities, which is also a define-unit operation rather than a characterization step.

Then I'm building the co-authorship networks per window—another define-unit transform that aggregates the papers and authors into per-window network snapshots, where each network has nodes representing authors and weighted edges capturing co-authorship relationships. The graph structure itself should be represented as a relational configuration feature within the network entities.

Now I'm setting up an iterative loop for community detection that applies graph clustering algorithms like Louvain to each window's network, adjusting the resolution parameter to find balanced, interpretable community sizes across all time windows.

I need to define the data structure for communities properly — each community instance belongs to a specific time window and contains member authors. The community label should map each author to their assigned community within that window, which I'm modeling as a feature of the network artifact itself rather than the author artifact, since community membership is window-dependent.

For the quality assessment task, I'm computing modularity and size-distribution statistics across all windows to characterize the community structure, with the output being a numeric vector feature attached to the communities artifact.

Now I'm setting up visualization using small-multiples network views with a hybrid NodeTrix representation to handle dense communities, then assessing the results by evaluating size distribution, modularity, and interpretability across windows. If the quality metrics suggest the parameters need tuning, I'll adjust the resolution or algorithm settings and loop back; otherwise I move forward. This follows the same iterative refinement pattern as the cluster-calendar approach.

For inter-window overlaps, I'm computing Jaccard similarity between community member sets in consecutive time windows to create a directed overlap graph showing how communities relate across adjacent periods. Then I'll match these communities into lineages by linking instances above an overlap threshold and classifying each transition as a continuation, merge, split, birth, or dissolution event.

Each lineage tracks an ordered sequence of community instances through time with metadata like lineage ID and window span, while the transition events form a categorical sequence labeling how that lineage evolved. Since the matching threshold itself needs calibration, I'm considering whether to add a small tuning loop or just include an assessment step to evaluate different threshold values.

For visualization, I'll arrange the community lineages as columns across time windows with connecting bands sized by overlap in a StratomeX-style layout, plus an alluvial diagram to highlight the merge, split, birth, and dissolution events.

Now for the core and leadership analysis: I need to compute which authors appear consistently across windows within each lineage to identify stable core members, and calculate centrality metrics within each community's subgraph to find the leading researchers.

I'm creating a heatmap visualization showing author presence across time windows per lineage, with leaders highlighted for emphasis.

Moving into research foci, I'll aggregate the titles, abstracts, and keywords from papers authored by community members within each window, then apply topic modeling to identify the research themes within each community instance.

The topic modeling loop involves fitting an NMF model to the aggregated text corpus, visualizing the topic-term matrix and how topic weights evolve across lineages over time, then interpreting and naming the discovered topics as research foci labels. I'll assess the quality of these topics by evaluating their coherence and distinctiveness across lineages, and if needed, refine the parameters and re-fit the model.

Next I'm reconstructing each author's trajectory through the communities and lineages they belonged to over their career, identifying who moved between communities or participated in multiple simultaneously. I'll arrange these trajectories against the lineage timeline to visualize cross-community mobility, then extract patterns of researcher movement, key bridging authors, and instances of simultaneous multi-community participation.

Now I'm moving into the final interpretation loop where I explore all the visualizations together—the evolution diagram, stability views, topic timelines, and trajectory view—to understand merges, splits, and dissolutions in the context of research focus shifts and leadership changes. I need to assess whether the identified communities, their stability patterns, research foci, and transition events adequately answer the analyst's original questions, and if not, I'll adjust the matching threshold, window configuration, or drill deeper into specific lineages.

Once I have sufficient evidence, I'll synthesize all the findings—the evolution patterns, mobility patterns, research foci, core members, and transition events—into a coherent set of statements that constitute the final knowledge output. For D_time_windows, the internal structure is an episode (bounded interval) with time embedment, similar to how days work in the cluster-calendar example. D_authors and D_papers both have elementary internal structure, but papers need {set, time} embedment since they're identified by publication and positioned temporally, following the same pattern as patient records in the D2 example.

I'm deciding to use {set, time} for consistency with other collections that have temporal attributes, even though just "time" would work since papers are really time-indexed data. Now I'm adding features to D_papers: an authors field (list reference), year (temporal), title (text), and more.

I should also consider whether S_window_config needs to be marked as given with its representation form. Before writing out the full ATWL text, I'm realizing that F_quality should be a feature of D_networks rather than D_communities, since modularity and other quality metrics apply to the whole partition within a window, not individual communities. This makes more sense structurally.

For F_community_label, since community detection partitions authors within each window, I can represent this as a feature of D_authors with a vector value structure—one entry per window showing which community the author belongs to in that window, with sparse entries for inactive windows. This mirrors how T_detect_communities outputs both D_communities and F_community_label, similar to the clustering pattern in time-series analysis.

F_overlap as a feature of D_communities captures pairwise overlaps between communities across adjacent windows using a directed overlap graph with Jaccard similarity—consistent with how F_similarities works in other workflows. S_matching_params specifies the threshold settings (like Jaccard >= 0.3) for linking communities across time. Now I'm thinking through T_match_lineages, which takes D_communities, F_overlap, and S_matching_params as inputs to produce the lineage output.

I'm considering whether to add a dedicated calibration loop for the matching threshold. It makes sense to include one right after computing overlaps, similar to how parameter tuning works in other parts of the system—this keeps the threshold adjustment focused and avoids nesting it too deeply into the broader interpretation loop. The loop would run the matching step with a light visualization to assess the results, then exit with the final threshold before building the full evolution visualization. urally plausible — avoiding excessive fragmentation or spurious over-merging. The loop body runs through matching lineages, arranging their evolution, visualizing it, and assessing quality; if refinement is needed, I adjust the matching parameters and reassign the lineage data, otherwise I exit. This mirrors the grouping loop pattern nicely and keeps visualization integrated within the calibration process rather than duplicating it.

Now I'm laying out the full structure in three phases: first setting up the papers, time windows, authors, and networks; then running a community detection loop that detects communities, computes quality metrics, visualizes them, assesses the results, and refines parameters if needed; and finally moving into lineage tracking where I compute overlaps between communities.

For the lineage phase, I'm matching lineages based on transition events, arranging the evolution, visualizing it, and assessing quality before potentially refining the matching parameters. Then in the final phase, I'm characterizing the core members and leaders, visualizing their stability over time, and extracting patterns from that stability data.

Moving into topic modeling, I'm aggregating the text corpus, fitting a topic model with initial parameters, visualizing the topics, abstracting the research foci, and assessing topic quality—again with a refinement loop if needed. After that, I'm deriving author trajectories and beginning to analyze individual-level mobility and overlap patterns.

Then in the interpretation phase, I'm combining all the findings—evolution, stability, research foci, and mobility patterns—to understand the causal mechanisms behind lineage mergers, splits, and dissolutions. I assess whether I have enough information, and if not, I can loop back to refine earlier phases like the window configuration before potentially rerunning parts of the pipeline.

Once that's complete, I synthesize everything into final knowledge outputs. This mirrors the nested loop structure I see in similar analysis frameworks, where each phase progressively refines one aspect before reaching a comprehensive synthesis.

Now I'm working on a template notation that captures the overall intent using loop syntax...

Writing template notation... I'll skip the explicit knowledge artifact for domain interpretation since the analyst's expertise is already implicit in the workflow. For the membership overlap question, the community-to-community overlap computed in Phase C combined with author-level mobility tracking in Phase F should address both the structural changes and temporal dynamics. I'm also considering whether communities merge, split, or dissolve—

this ties back to research focus shifts in Phase E and leadership turnover in Phase D, which Phase G will integrate. I should also refine the leader identification to incorporate citation counts and publication metrics alongside centrality measures, since citations were explicitly provided as an important attribute.

I need to capture how many distinct communities emerge from the analysis — pulling this from the lineage counts in Phase D and the community detection outputs in Phase F — and make sure this gets highlighted in the final findings. Now I'll structure the full response with natural language explanation first, then the ATWL specification, making sure to cite the specific library workflows that support each recommendation step. Writing ATWL syntax...

Analytical Workflow: Discovering and Characterising Collaboration Communities in the IEEE VIS Literature

Analytical logic (natural-language overview)

The task has two intertwined layers: (1) detecting who collaborates with whom, and how those groupings change over a 35-year span, and (2) interpreting those groupings — their stability, leadership, research focus, and their merge/split/dissolve dynamics. This calls for a workflow that alternates between computational network/text analysis and human interpretation, with several rounds of parameter calibration. I model it in six stages:

A. Data preparation. From the paper records, I extract authors as first-class analysis units and partition the publication timeline into time windows (the "unit of temporal resolution" at which communities will be defined). For each window I build a co-authorship network (nodes = active authors, edges = weighted co-authorship). This treats "papers" and "authors" as different levels of analysis, following the convention (used throughout the library, e.g. in cluster-calendar and reducing-snapshots-to-points) of first defining the right analysis unit before computing anything else.

B. Per-window community detection (iterative). A graph community-detection algorithm (e.g. Louvain) is applied to each window's network. Because resolution parameters strongly affect whether communities are meaningful (too fragmented / too coarse), this is wrapped in a refinement loop with visual assessment of modularity, size distribution and interpretability — directly modelled on the calibration loop in cluster-calendar and the parameter-adjustment loops in MobilityGraphs.

C. Cross-window lineage tracking (iterative). Communities detected independently in each window are not yet "the same community over time." I compute pairwise membership overlap (Jaccard similarity) between communities in temporally adjacent windows and link them above a calibrated threshold into lineages — persistent community identities — while explicitly classifying each linkage as continuation, merge, split, birth, or dissolution. This is the structural heart of the workflow and is modelled closely on EventThread's tensor-decomposition-into-threads-with-branching/merging pattern (there: stages→threads; here: windows→lineages) and visualised as a column-band diagram in the manner of StratomeX (there: overlapping patient stratifications; here: overlapping community memberships across adjacent windows), overlaid with an alluvial/flow view as in EventThread and SOMFlow. The overlap/matching threshold is itself calibrated in a small loop, mirroring the parameter-refinement pattern in ST_analysis_modelling.

D. Core stability and leadership. For each lineage, I compute each member's presence frequency across the lineage's windows to distinguish a stable core from transient participants, and compute within-community centrality (degree/betweenness) combined with publication/citation volume to identify leaders per window. This is visualised as an author × time-window presence matrix (heatmap), directly analogous to the state-persistence and role-identification steps in DPVis and the actor-role analysis in NodeTrix, whose hybrid node-link/matrix representation is also recommended for drilling into any single dense community instance.

E. Research foci via topic modelling (iterative). Titles, abstracts and keywords of papers authored by each community's members (within each window) are aggregated into a corpus per community instance, and a topic model (NMF) is fit and iteratively refined — following the interactive topic-modelling loop of UTOPIAN (interactive-topic-modeling) — producing named research-focus labels that can be tracked along each lineage's timeline to show topical evolution or drift.

F. Individual-level mobility and cross-community overlap. Beyond window-to-window community overlap (stage C), I reconstruct each author's personal trajectory through lineages over their career (which lineages they belonged to, whether simultaneously or sequentially), revealing bridging authors and multi-community membership — addressing "how does membership overlap change over time" at the individual level.

G. Integrated interpretation loop. The analyst brings the evolution diagram, stability heatmap, topic timelines and mobility view together to interpret why particular merges/splits/dissolutions occurred (e.g., a split coinciding with a topical bifurcation, or a dissolution coinciding with core-member attrition), iterating on window size or matching thresholds if the picture is unclear — an "implicit termination" loop, since the stopping criterion ("sufficient holistic understanding") is not reducible to a single assessable artifact, following the convention used for exploratory synthesis loops in e.g. MotionExplorer and episode-based-temporal-analysis.

H. Knowledge synthesis. Final statements about the number and character of communities, core stability, leadership, foci evolution, overlap patterns, and merge/split/dissolve events with their likely drivers.


ATWL Representation

workflow vis-community-evolution-analysis

  template: define-unit (windows, authors, networks) →
            loop(define-unit (detect communities) → characterise (quality) →
                 visualise → assess) →
            characterise (overlaps) →
            loop(define-unit (match lineages) → contextualise → visualise →
                 assess) →
            characterise (core & leaders) → visualise → abstract →
            loop(build-model (topics) → visualise → abstract → assess) →
            characterise (author trajectories) → contextualise → visualise →
            abstract →
            loop(abstract (integrate) → assess) →
            generate-knowledge

  description: "Identify communities of collaborating researchers in the
    IEEE VIS literature (1990-2024) via time-windowed co-authorship
    networks, track their evolution (continuation, merger, splitting,
    birth, dissolution) across windows, characterise core stability,
    leadership, research foci, and cross-community researcher mobility"

# ============================================================================
# INPUT
# ============================================================================

artifact D_papers : entities
  origin: given
  internal structure: elementary
  embedment: {set, time}
  features:
    - id: f_authors
      value structure: list
      value type: reference
      description: "DBLP-disambiguated author identifiers"
    - id: f_year
      value structure: atomic
      value type: temporal
      description: "Publication year"
    - id: f_title
      value structure: atomic
      value type: text
      description: "Paper title"
    - id: f_abstract
      value structure: atomic
      value type: text
      description: "Paper abstract"
    - id: f_keywords
      value structure: list
      value type: text
      description: "Author-supplied keywords"
    - id: f_citations
      value structure: atomic
      value type: numeric
      description: "Citation count"
  description: "3596 IEEE VIS/InfoVis/VAST/SciVis papers (1990-2024) with
    disambiguated author lists"

artifact S_window_config : specification
  origin: given
  representation form: "parameter settings"
  description: "Initial time-window scheme: window length and stride
    (e.g. 3-year sliding windows, 1-year stride) for constructing
    successive co-authorship snapshots"

# ============================================================================
# PHASE A: UNITS OF ANALYSIS - WINDOWS, AUTHORS, NETWORKS
# ============================================================================

transform T_define_windows :
  intent: define-unit
  manner: "time-partitioning into sliding windows"
  input: D_papers, S_window_config
  output: D_time_windows
  actor: machine
  description: "Partition the publication timeline into overlapping
    multi-year windows serving as the temporal resolution for community
    detection"

artifact D_time_windows : entities
  internal structure: episode
  embedment: time
  features:
    - id: f_window_id
      value structure: atomic
      value type: categorical
      description: "Window identifier"
    - id: f_year_range
      value structure: vector
      value type: temporal
      description: "Start and end year of the window"
  description: "Bounded multi-year intervals over which co-authorship
    networks and communities are computed"

transform T_extract_authors :
  intent: define-unit
  manner: "extract"
  input: D_papers
  output: D_authors
  actor: machine
  description: "Extract unique disambiguated authors as first-class
    analysis units"

artifact D_authors : entities
  internal structure: elementary
  embedment: set
  features:
    - id: f_total_papers
      value structure: atomic
      value type: numeric
      description: "Total number of papers authored"
    - id: f_career_span
      value structure: vector
      value type: temporal
      description: "First and last publication year"
  description: "Individual researchers, disambiguated via DBLP identifiers"

transform T_build_networks :
  intent: define-unit
  manner: "aggregate co-authorship into per-window network snapshots"
  input: D_papers, D_authors, D_time_windows
  output: D_networks
  actor: machine
  description: "Construct one weighted co-authorship network per time
    window: nodes are authors active in the window, edges are weighted by
    number of jointly authored papers"

artifact D_networks : entities
  internal structure: formation
  embedment: time
  features:
    - id: f_coauthor_graph
      value structure: relational configuration
      value type: {reference, numeric}
      representation form: "weighted undirected co-authorship graph"
      description: "Author nodes with co-authorship-count edge weights for
        this window"
  description: "Temporal sequence of co-authorship network snapshots, one
    per time window"

# ============================================================================
# PHASE B: PER-WINDOW COMMUNITY DETECTION (ITERATIVE CALIBRATION)
# ============================================================================

artifact S_community_params : specification
  origin: given
  representation form: "parameter settings"
  description: "Community-detection algorithm choice and resolution
    parameter (e.g. Louvain modularity resolution) applied uniformly across
    all window networks"

loop L_community_detection:
  purpose: "Calibrate community-detection resolution so that communities
    are neither over-fragmented nor overly coarse, and remain interpretable
    across the whole time span"
  until: "Modularity, size distribution, and visual interpretability of
    communities are satisfactory across the majority of time windows"
  body:

    transform T_detect_communities :
      intent: define-unit
      manner: "graph community detection (modularity optimisation, e.g.
        Louvain), applied independently per window"
      input: D_networks, S_community_params
      output: D_communities, F_community_label
      actor: machine
      description: "Partition each window's co-authorship network into
        communities of densely collaborating authors"

    artifact D_communities : entities
      internal structure: group/cluster
      embedment: {set, time}
      features:
        - id: f_window_id
          value structure: atomic
          value type: reference
          description: "Time window this community instance belongs to"
        - id: f_size
          value structure: atomic
          value type: numeric
          description: "Number of member authors"
      description: "Community instances: groups of authors detected as
        densely collaborating within one specific time window"

    artifact F_community_label : feature(D_authors)
      value structure: vector
      value type: categorical
      description: "Per-window community-assignment sequence for each
        author across all time windows in which they were active"

    transform T_compute_quality :
      intent: characterise
      manner: "compute-statistics (modularity, size distribution)"
      input: D_communities, D_networks
      output: F_quality
      actor: machine
      description: "Compute per-window modularity score, community count,
        mean/variance of community size, and singleton-author fraction"

    artifact F_quality : feature(D_networks)
      value structure: vector
      value type: numeric
      description: "Per-window community-detection quality metrics"

    transform T_visualise_communities :
      intent: visualise
      manner: "small-multiples node-link / hybrid NodeTrix-style views per
        window"
      input: D_networks, D_communities, F_community_label
      output: V_communities
      actor: machine
      description: "Display each window's network with communities
        colour-coded; densest communities optionally shown as matrices
        (NodeTrix-style) to reveal internal collaboration structure"

    artifact V_communities : visualisation(D_networks, D_communities,
        F_community_label)
      layout: "small multiples, one panel per time window"
      form: "node-link diagrams with colour-coded community membership;
        NodeTrix-style hybrid matrix insets for dense communities"
      encoding: "node colour: community label; node size: author
        publication count; matrix cell: intra-community co-authorship
        count"
      description: "Per-window overview supporting visual judgment of
        community coherence and granularity"

    transform T_assess_communities :
      intent: assess
      manner: "evaluate-clustering-quality"
      input: V_communities, F_quality
      output: K_community_quality
      actor: human
      description: "Judge whether modularity, size distribution, and
        visual coherence of communities are acceptable across windows"

    artifact K_community_quality : knowledge(D_communities)
      representation form: "quality judgment"
      description: "Assessment of whether current resolution parameter
        yields interpretable, appropriately granular communities"

    if K_community_quality indicates refinement needed:
      then:
        transform T_adjust_community_params :
          intent: generate-knowledge
          manner: "adjust resolution parameter based on assessment"
          input: K_community_quality, S_community_params
          output: S_community_params_r
          actor: human
          description: "Revise resolution or algorithm choice to correct
            over-fragmentation or excessive coarseness"

        artifact S_community_params_r : specification
          representation form: "parameter settings"
          description: "Updated community-detection configuration"

        assign:
          S_community_params := S_community_params_r
      else:
        exit loop L_community_detection

end loop L_community_detection

# ============================================================================
# PHASE C: CROSS-WINDOW LINEAGE TRACKING (ITERATIVE CALIBRATION)
# ============================================================================

transform T_compute_overlaps :
  intent: characterise
  manner: "define-relations (similarity) — Jaccard overlap of member sets"
  input: D_communities
  output: F_overlap
  actor: machine
  description: "Compute pairwise membership-overlap similarity between
    every pair of community instances in temporally adjacent windows"

artifact F_overlap : feature(D_communities)
  value structure: relational configuration
  value type: numeric
  representation form: "directed overlap graph (Jaccard similarity) between
    community instances of temporally adjacent windows"
  description: "Basis for linking community instances into persistent
    lineages"

artifact S_matching_params : specification
  origin: given
  representation form: "parameter settings"
  description: "Overlap threshold above which two community instances in
    adjacent windows are linked as continuous, and rules for classifying
    one-to-many / many-to-one links as split / merge"

loop L_lineage_tracking:
  purpose: "Calibrate the overlap threshold so that resulting community
    lineages and their merge/split/birth/dissolution events are
    structurally plausible"
  until: "The evolution diagram shows neither excessive fragmentation
    (spurious births/dissolutions) nor implausible over-merging"
  body:

    transform T_match_lineages :
      intent: define-unit
      manner: "link community instances above overlap threshold into
        lineages; classify each linkage as continuation, merge, split,
        birth, or dissolution"
      input: D_communities, F_overlap, S_matching_params
      output: D_lineages, F_transition_events
      actor: machine
      description: "Track community identity across windows, producing
        persistent lineages and typed transition events between
        consecutive windows"

    artifact D_lineages : entities
      internal structure: sequence
      embedment: set
      features:
        - id: f_first_window
          value structure: atomic
          value type: reference
          description: "Window in which the lineage first appears"
        - id: f_last_window
          value structure: atomic
          value type: reference
          description: "Window in which the lineage last appears (or
            dissolves)"
      description: "Ordered sequences of community instances across time
        windows, each sequence representing one persistent community"

    artifact F_transition_events : feature(D_lineages)
      value structure: vector
      value type: categorical
      description: "Per-consecutive-window-pair transition type along each
        lineage: continuation, merge, split, birth, or dissolution"

    transform T_arrange_evolution :
      intent: contextualise
      manner: "column-band arrangement (StratomeX-style) plus alluvial
        flow layout (EventThread-style)"
      input: D_lineages, D_communities, F_overlap, F_transition_events
      output: A_evolution
      actor: machine
      description: "Arrange community instances as columns per time window
        with connecting bands sized by membership overlap, and as an
        alluvial diagram highlighting branch/merge/dissolution points"

    artifact A_evolution : arrangement(D_lineages)
      context: D_time_windows
      principle: "horizontal: time windows as columns; vertical: stacked
        community-instance blocks sized by member count; bands between
        adjacent columns sized by overlap; alluvial flow shows lineage
        continuity"
      description: "Temporal arrangement exposing continuity, merges,
        splits, births, and dissolutions of communities"

    transform T_visualise_evolution :
      intent: visualise
      manner: "column-band matrix + alluvial diagram"
      input: A_evolution
      output: V_evolution
      actor: machine
      description: "Render the community-evolution diagram with
        colour-coded lineages and highlighted transition events"

    artifact V_evolution : visualisation(A_evolution)
      layout: "sequence of window columns with connecting overlap bands;
        alluvial flow overlay"
      form: "stacked blocks, ribbon bands, branch/merge glyphs"
      encoding: "block height: community size; band width: overlap
        strength; block colour: lineage identity; glyph: transition type
        (merge/split/birth/dissolution)"
      description: "Primary view for inspecting how communities persist,
        combine, fragment, or disappear over the 35-year span"

    transform T_assess_lineages :
      intent: assess
      manner: "evaluate structural plausibility of lineages and events"
      input: V_evolution, F_transition_events
      output: K_lineage_quality
      actor: human
      description: "Judge whether the overlap threshold produces
        believable lineages, avoiding spurious fragmentation or
        over-merging"

    artifact K_lineage_quality : knowledge(D_lineages)
      representation form: "quality judgment"
      description: "Assessment of whether current matching threshold
        yields plausible lineage structure and transition events"

    if K_lineage_quality indicates refinement needed:
      then:
        transform T_adjust_matching_params :
          intent: generate-knowledge
          manner: "adjust overlap threshold based on assessment"
          input: K_lineage_quality, S_matching_params
          output: S_matching_params_r
          actor: human
          description: "Revise the overlap threshold to correct
            fragmentation or over-merging"

        artifact S_matching_params_r : specification
          representation form: "parameter settings"
          description: "Updated lineage-matching configuration"

        assign:
          S_matching_params := S_matching_params_r
      else:
        exit loop L_lineage_tracking

end loop L_lineage_tracking

# ============================================================================
# PHASE D: CORE STABILITY AND LEADERSHIP
# ============================================================================

transform T_compute_core :
  intent: characterise
  manner: "compute-statistics (per-author presence frequency; centrality)"
  input: D_lineages, D_communities, D_networks, F_community_label
  output: F_core_members, F_leaders
  actor: machine
  description: "For each lineage, compute each author's presence frequency
    across the lineage's windows to identify a stable core; compute
    within-community degree/betweenness centrality combined with
    publication and citation counts to identify leading researchers per
    window"

artifact F_core_members : feature(D_lineages)
  value structure: list
  value type: reference
  description: "Authors present in a majority of the lineage's time
    windows, forming its stable core"

artifact F_leaders : feature(D_communities)
  value structure: list
  value type: reference
  description: "Most central / most cited authors within each community
    instance"

transform T_visualise_stability :
  intent: visualise
  manner: "author x time-window presence heatmap per lineage"
  input: F_core_members, F_leaders, D_lineages
  output: V_stability
  actor: machine
  description: "Display, per lineage, which authors were present in which
    windows, with core members and leaders highlighted"

artifact V_stability : visualisation(F_core_members, F_leaders, D_lineages)
  layout: "matrix per lineage: rows = authors, columns = time windows"
  form: "coloured cells with leader markers"
  encoding: "cell colour: membership presence; marker: leader status;
    row ordering: total presence count (core members at top)"
  description: "Reveals which lineages have a persistent core of leading
    researchers versus high membership turnover"

transform T_abstract_stability :
  intent: abstract
  manner: "perception-and-interpretation"
  input: V_stability, F_transition_events
  output: P_stability_patterns
  actor: human
  description: "Identify lineages with strong stable cores versus high
    turnover, and relate core/leader changes to transition events"

artifact P_stability_patterns : pattern(D_lineages)
  representation form: "descriptions of stability and leadership patterns"
  description: "Characterisation of each lineage's core stability and
    leadership continuity or change"

# ============================================================================
# PHASE E: RESEARCH FOCI VIA TOPIC MODELLING (ITERATIVE)
# ============================================================================

transform T_aggregate_text :
  intent: characterise
  manner: "aggregate"
  input: D_communities, D_papers
  output: F_text_corpus
  actor: machine
  description: "Aggregate titles, abstracts, and keywords of papers
    authored by each community instance's members within its window"

artifact F_text_corpus : feature(D_communities)
  value structure: atomic
  value type: text
  description: "Concatenated title/abstract/keyword text for each community
    instance's papers"

artifact S_topic_params : specification
  origin: given
  representation form: "parameter settings"
  description: "Initial topic-modelling configuration (e.g. number of NMF
    topics, term weighting)"

loop L_topic_modeling:
  purpose: "Fit and refine a topic model producing interpretable,
    distinctive research-focus labels for community instances"
  until: "Topics are coherent, distinctive, and interpretable as named
    research foci across community instances"
  body:

    transform T_fit_topics :
      intent: build-model
      manner: "fit-topic-model (NMF)"
      input: F_text_corpus, S_topic_params
      output: M_topic_model, F_topic_weights
      actor: machine
      description: "Fit a topic model over community-instance corpora and
        compute each instance's weight distribution across topics"

    artifact M_topic_model : model(F_text_corpus)
      model type: "topic model"
      representation form: "term-topic and community-topic weight
        matrices"
      description: "Latent research-theme structure underlying community
        instances' publications"

    artifact F_topic_weights : feature(D_communities)
      value structure: vector
      value type: numeric
      description: "Per-community-instance topic weight distribution"

    transform T_visualise_topics :
      intent: visualise
      manner: "term-topic matrix + per-lineage topic-weight timeline"
      input: M_topic_model, F_topic_weights, D_lineages
      output: V_topics
      actor: machine
      description: "Display characteristic terms per topic and each
        lineage's topic-weight evolution over its lifespan"

    artifact V_topics : visualisation(M_topic_model, F_topic_weights)
      layout: "term-topic matrix; per-lineage stacked/line chart over time"
      form: "coloured cells (term weight); coloured area/line chart"
      encoding: "cell colour: term-topic weight; line/area colour: topic
        identity; height: topic weight within the lineage's window"
      description: "Reveals dominant research foci per community instance
        and how a lineage's focus shifts over time"

    transform T_abstract_foci :
      intent: abstract
      manner: "name-patterns"
      input: V_topics
      output: P_research_foci
      actor: human
      description: "Assign interpretable research-focus labels to topics
        (e.g. 'text/NLP visualization', 'immersive analytics')"

    artifact P_research_foci : pattern(D_communities, M_topic_model)
      representation form: "named research-focus labels per topic and per
        community instance/lineage"
      description: "Human-interpretable characterisation of each
        community's dominant research themes and their evolution"

    transform T_assess_topics :
      intent: assess
      manner: "evaluate topic coherence and interpretability"
      input: V_topics, P_research_foci
      output: K_topic_quality
      actor: human
      description: "Judge whether topics are distinct and interpretable
        as research foci"

    artifact K_topic_quality : knowledge(M_topic_model)
      representation form: "quality judgment"
      description: "Assessment of topic coherence, distinctiveness, and
        interpretability"

    if K_topic_quality indicates refinement needed:
      then:
        transform T_adjust_topic_params :
          intent: generate-knowledge
          manner: "adjust number of topics or term weighting"
          input: K_topic_quality, S_topic_params
          output: S_topic_params_r
          actor: human
          description: "Revise topic-model configuration"

        artifact S_topic_params_r : specification
          representation form: "parameter settings"
          description: "Updated topic-modelling configuration"

        assign:
          S_topic_params := S_topic_params_r
      else:
        exit loop L_topic_modeling

end loop L_topic_modeling

# ============================================================================
# PHASE F: INDIVIDUAL-LEVEL MOBILITY AND CROSS-COMMUNITY OVERLAP
# ============================================================================

transform T_derive_trajectories :
  intent: characterise
  manner: "reconstruct per-author lineage-membership sequences"
  input: D_authors, F_community_label, D_lineages
  output: F_author_trajectories
  actor: machine
  description: "Reconstruct each author's career-long sequence of lineage
    memberships, capturing sequential moves between communities and
    simultaneous membership in more than one"

artifact F_author_trajectories : feature(D_authors)
  value structure: vector
  value type: {reference, temporal}
  description: "Per-author ordered sequence of (time window, lineage)
    membership pairs across their career"

transform T_arrange_trajectories :
  intent: contextualise
  manner: "relative-time-alignment against lineage timelines"
  input: F_author_trajectories, D_lineages
  output: A_trajectories
  actor: machine
  description: "Position each author's trajectory against the shared
    lineage timeline for cross-community mobility comparison"

artifact A_trajectories : arrangement(D_authors)
  context: D_lineages
  principle: "horizontal: time; vertical: lineage identity; author
    trajectory drawn as a path across lineage rows"
  description: "Arrangement exposing which authors move between, or
    simultaneously belong to, multiple communities"

transform T_visualise_trajectories :
  intent: visualise
  manner: "trajectory lines over lineage timeline"
  input: A_trajectories
  output: V_trajectories
  actor: machine
  description: "Display author trajectories as paths across the lineage
    timeline, highlighting bridging and multi-community authors"

artifact V_trajectories : visualisation(A_trajectories)
  layout: "lineage rows along vertical axis; time along horizontal axis"
  form: "coloured trajectory lines/paths, one per selected author or
    author group"
  encoding: "line colour: author identity or role (bridge/core/peripheral);
    vertical jumps: community changes"
  description: "Reveals which researchers bridge multiple communities and
    how cross-community membership evolves"

transform T_abstract_mobility :
  intent: abstract
  manner: "perception-and-interpretation"
  input: V_trajectories
  output: P_mobility_patterns
  actor: human
  description: "Identify bridging authors, simultaneous multi-community
    membership, and directional flows of researchers between communities"

artifact P_mobility_patterns : pattern(D_authors, D_lineages)
  representation form: "descriptions of mobility and overlap patterns"
  description: "Characterisation of how individual researchers move
    between, or belong simultaneously to, multiple communities"

# ============================================================================
# PHASE G: INTEGRATED INTERPRETATION
# ============================================================================

loop L_interpretation:
  purpose: "Integrate evolution, stability, research-focus, and mobility
    views to interpret why communities merge, split, or dissolve, revising
    earlier configuration choices if the picture remains unclear"
  until: "The analyst has developed a sufficient holistic understanding
    of community evolution and its drivers"
  body:

    transform T_explore_integrated :
      intent: abstract
      manner: "cross-view comparison"
      input: V_evolution, V_stability, V_topics, V_trajectories
      output: P_integrated_findings
      actor: human
      description: "Interpret merge/split/dissolution events in light of
        co-occurring research-focus shifts, core/leader turnover, and
        researcher mobility"

    artifact P_integrated_findings : pattern(D_lineages)
      representation form: "causal interpretations of transition events"
      description: "Explanations linking specific merge/split/dissolution
        events to concurrent topical shifts, leadership changes, or
        researcher migration"

    transform T_assess_completeness :
      intent: assess
      manner: "judge sufficiency of holistic understanding"
      input: P_integrated_findings
      output: K_completeness
      actor: human
      description: "Judge whether all major transition events have been
        satisfactorily interpreted"

    artifact K_completeness : knowledge(P_integrated_findings)
      representation form: "quality judgment"
      description: "Assessment of interpretive completeness"

    if K_completeness indicates further investigation needed:
      then:
        transform T_refine_focus :
          intent: generate-knowledge
          manner: "decide which earlier configuration to revisit (window
            scheme, matching threshold, or topic granularity)"
          input: K_completeness, S_window_config, S_matching_params
          output: S_window_config_r
          actor: human
          description: "Formulate a revised window or matching
            configuration to resolve ambiguous transitions"

        artifact S_window_config_r : specification
          representation form: "parameter settings"
          description: "Revised window scheme guiding a further pass
            through Phases A-G"

        assign:
          S_window_config := S_window_config_r
      else:
        exit loop L_interpretation

end loop L_interpretation

# ============================================================================
# PHASE H: KNOWLEDGE SYNTHESIS
# ============================================================================

transform T_synthesise :
  intent: generate-knowledge
  manner: "formulate-statements"
  input: P_integrated_findings, P_mobility_patterns, P_research_foci,
    P_stability_patterns, F_transition_events
  output: K_findings
  actor: human
  description: "Synthesise findings on the number and character of
    communities, their core stability and leadership, research-focus
    evolution, cross-community overlap, and the timing and drivers of
    merges, splits, and dissolutions"

artifact K_findings : knowledge(P_integrated_findings, P_research_foci)
  representation form: "statements and explanations"
  description: "Documented understanding of the intellectual structure of
    the IEEE VIS community: number of distinct communities, degree of core
    stability and leadership continuity per community, characteristic and
    evolving research foci, patterns of membership overlap and researcher
    mobility across communities, and identified merge/split/dissolution
    events with plausible drivers"
5 Researcher

Make a list of the papers from which you have taken relevant approaches.

6 Model

I'm gathering the papers that informed my earlier responses.

Papers Cited as Sources of Relevant Approaches

The following library workflows informed specific structural elements of my recommended workflow, as noted in the design rationale:

  1. van Wijk & van Selow (1999) — Cluster and calendar based visualization of time series data (cluster-calendar workflow) — model for the calibration loop with visual assessment of clustering resolution parameters.

  2. von Landesberger, Brodkorb, Roskosch, Andrienko, Andrienko & Kerren (2016) — MobilityGraphs: Visual analysis of mass mobility dynamics via spatio-temporal graphs and clustering — model for the parameter-refinement loop pattern (quality heatmap → assess → adjust) applied to the overlap-threshold calibration.

  3. Guo, Xu, Zhao, Gotz, Zha & Cao (2018) — EventThread: Visual Summarization and Stage Analysis of Event Sequence Data — model for tensor-decomposition-into-threads-with-branching/merging, adapted to community-lineage tracking across time windows (continuation/merge/split/birth/dissolution classification).

  4. Streit, Lex, Gratzl, Partl, Schmalstieg, Pfister, Park & Gehlenborg (2014) — StratomeX: Guided Visual Exploration of Genomic Stratifications in Cancer — model for the column-band arrangement visualising overlapping set memberships across adjacent groupings, adapted from patient stratifications to community memberships across time windows.

  5. Henry, Fekete & McGuffin (2007) — NodeTrix: A Hybrid Visualization of Social Networks — model for the hybrid node-link/matrix representation used to inspect dense community instances and identify actor roles (leaders, bridges).

  6. Kwon, Anand, Severson, Ghosh, Sun, Frohnert, Lundgren & Ng (2021) — DPVis: Visual Analytics With Hidden Markov Models for Disease Progression Pathways — model for state-persistence visualisation and role/leadership identification via matrix-based presence tracking over time.

  7. Choo, Lee, Reddy & Park (2013) — UTOPIAN: User-Driven Topic Modeling Based on Interactive Nonnegative Matrix Factorization — model for the interactive topic-modelling refinement loop used to derive and iteratively adjust research-focus labels.

  8. Andrienko & Andrienko (2013) — A visual analytics framework for spatio-temporal analysis and modelling (ST_analysis_modelling workflow) — model for the nested-loop structure combining iterative clustering refinement with parameter calibration.

  9. Bernard, Barth, Cuba, Meier, Peiris & Shneiderman (2025) — IVESA — Visual Analysis of Time-Stamped Event Sequences — model for the exploratory synthesis loop with implicit termination criterion ("sufficient holistic understanding"), used for the integrated interpretation phase.

  10. Bernard, Wilhelm, Krüger, May, Schreck & Kohlhammer (2013) — MotionExplorer: Exploratory Search in Human Motion Capture Data Based on Hierarchical Aggregation — additional reference for exploratory loops with implicit, judgment-based termination conditions.