Lag sequential analysis studies the order in which categorical events occur. Given a series of events, the method examines pairs that follow one another and tests whether a given event is followed by another event more or less often than the order of events alone would predict. The event types become the states of the process, and the transitions between them become the object of analysis. A lag transition network is the representation of these tested transitions: the states are nodes, a directed edge from one state to another represents the transition between them, and the weight on the edge measures how far the observed transition departs from what independence would predict.
The method rests on a comparison between two quantities for every ordered pair of states. The observed count is the number of times the first state is immediately followed by the second. The expected count is the number that would occur if the next state did not depend on the current one, and it is built from the base rates of the two states alone. The adjusted residual expresses the difference between the two on a standardised scale. A positive residual identifies a transition that occurs more often than expected, which marks a behavioural regularity above the base rates of its states. A negative residual identifies a transition that occurs less often than expected, which marks an avoidance. A residual near zero identifies a transition that occurs about as often as chance predicts. The network drawn from these residuals answers a different question from a transition network weighted by probabilities: not where the process tends to go, but which moves it makes more or less often than chance.
ai_long is a long-format event log of coded AI-side
actions in human-AI coding sessions, one row per event: 8551 events in
428 sessions.
code, the coded action (8
states: Ask, Delegate, Execute,
Explain, Investigate, Plan,
Repair, Report); its transitions are
modelled.order_in_session, the position
of the event within its session.session_id, one
uninterrupted session. Transitions are counted within a session only, so
the last event of one session and the first of the next are never
treated as a pair.project,
timestamp, session_date, and
cluster are available as metadata and are not needed for
this fit.library(lagdynamics)
head(ai_long)
#> message_id project session_id timestamp session_date code cluster
#> 1 3441 Project_7 0086cabebd15 1772661600 2026-03-05 Delegate Action
#> 2 3441 Project_7 0086cabebd15 1772661600 2026-03-05 Plan Repair
#> 3 3443 Project_7 0086cabebd15 1772661600 2026-03-05 Execute Action
#> 4 3443 Project_7 0086cabebd15 1772661600 2026-03-05 Plan Repair
#> 5 3445 Project_7 0086cabebd15 1772661600 2026-03-05 Execute Action
#> 6 3447 Project_7 0086cabebd15 1772661600 2026-03-05 Investigate Action
#> code_order order_in_session
#> 1 1 5
#> 2 2 6
#> 3 1 8
#> 4 2 9
#> 5 1 12
#> 6 1 14lsa() fits the model by naming the action column, the
session boundary, and the ordering column.
fit <- lsa(ai_long,
session = "session_id",
action = "code",
order = "order_in_session")
fit
#> Lag Sequential Analysis - classical (lag 1, directed)
#> 8 states | 8123 transitions | 8551 events | 428 sequences
#> states: Ask, Delegate, Execute, Explain, Investigate, Plan, Repair, Report
#> independence: G² = 2168.1, df = 49, p <2e-16
#>
#> Significant transitions (p < 0.05): 40 of 64
#> strongest over-represented (of 19):
#> Investigate -> Plan z = +33.4 ***
#> Delegate -> Plan z = +18.1 ***
#> Ask -> Explain z = +16.4 ***
#> Execute -> Execute z = +16.1 ***
#> Explain -> Report z = +14.0 ***
#> ... and 14 more
#>
#> Initial states:
#> Investigate 0.715 ████████████████████████
#> Delegate 0.185 ██████
#> Execute 0.058 ██
#> Plan 0.035 █
#> Ask 0.005
#> Explain 0.002
#> Repair 0.000
#> Report 0.000The printed model reports the number of states, transitions, and sequences, the omnibus test of independence, the strongest over-represented transitions, and the initial-state distribution. The process has 8 states and 8123 within-session transitions drawn from 428 sessions, so the model estimates a compact 8-by-8 transition system from a large number of observed moves; the residuals it reports are repeated tendencies in the process rather than isolated episodes. Of the 64 possible transitions, 40 depart significantly from independence.
The fitted model exposes its contents through accessor functions, each of which returns a table. The initial-state distribution records the share of sessions that begin in each state.
initial(fit)
#> state init_prob
#> 1 Ask 0.00467
#> 2 Delegate 0.18458
#> 3 Execute 0.05841
#> 4 Explain 0.00234
#> 5 Investigate 0.71495
#> 6 Plan 0.03505
#> 7 Repair 0.00000
#> 8 Report 0.00000The initial-state distribution places most of its mass on
Investigate, whose value of 0.715 means that about 71% of
sessions begin with an investigation action. Delegate
begins 18.5% of sessions and Execute 5.8%, while
Repair and Report never begin a session. The
process almost always opens by gathering information.
Node activity records how often each state sends and receives transitions.
nodes(fit)
#> state outgoing incoming
#> 1 Ask 91 97
#> 2 Delegate 280 216
#> 3 Execute 3090 3233
#> 4 Explain 504 523
#> 5 Investigate 2235 2011
#> 6 Plan 1510 1605
#> 7 Repair 251 257
#> 8 Report 162 181Execute sends 3090 transitions and receives 3233, more
than any other state, which makes it the most frequently visited state
in the process. Ask, Report, and
Explain are visited rarely. The magnitude of these totals
is what the expected-count calculation controls for, so that a busy
state is not credited with meaningful transitions on the strength of its
activity alone.
The omnibus test evaluates the whole table against independence and is the first result to consult.
The likelihood-ratio statistic is \(G^2 = 2168\) on 49 degrees of freedom, with a p-value below machine precision. The order of actions is therefore not random: the next action depends on the current one. A non-significant omnibus test would remove any basis for interpreting individual transitions, so it is checked before them.
The transitions() function returns one row per directed
edge. Its direction argument selects over- or
under-represented transitions and its sort argument orders
them by strength.
transitions(fit, direction = "over", sort = "strength")
#> from to lag count expected prob prob_col adj_res p yules_q
#> 1 Investigate Plan 1 977 441.61 0.4371 0.6087 33.41 1.11e-244 0.734
#> 2 Delegate Plan 1 174 55.32 0.6214 0.1084 18.13 1.96e-73 0.761
#> 3 Ask Explain 1 44 5.86 0.4835 0.0841 16.38 2.56e-60 0.873
#> 4 Execute Execute 1 1575 1229.84 0.5097 0.4872 16.12 1.98e-58 0.358
#> 5 Explain Report 1 56 11.23 0.1111 0.3094 13.95 3.12e-44 0.765
#> 6 Repair Explain 1 43 16.16 0.1713 0.0822 7.01 2.36e-12 0.522
#> 7 Explain Repair 1 42 15.95 0.0833 0.1634 6.85 7.59e-12 0.516
#> 8 Plan Execute 1 709 600.99 0.4695 0.2193 6.29 3.10e-10 0.178
#> 9 Explain Explain 1 66 32.45 0.1310 0.1262 6.29 3.24e-10 0.405
#> 10 Repair Ask 1 13 3.00 0.0518 0.1340 5.90 3.54e-09 0.670
#> 11 Plan Delegate 1 73 40.15 0.0483 0.3380 5.82 5.78e-09 0.394
#> 12 Plan Investigate 1 458 373.83 0.3033 0.2277 5.56 2.66e-08 0.173
#> 13 Plan Report 1 56 33.65 0.0371 0.3094 4.32 1.56e-05 0.333
#> 14 Report Repair 1 14 5.13 0.0864 0.0545 4.02 5.73e-05 0.501
#> 15 Explain Investigate 1 158 124.77 0.3135 0.0786 3.54 3.99e-04 0.174
#> 16 Report Delegate 1 10 4.31 0.0617 0.0463 2.81 4.99e-03 0.425
#> 17 Repair Execute 1 119 99.90 0.4741 0.0368 2.50 1.23e-02 0.159
#> 18 Report Explain 1 18 10.43 0.1111 0.0344 2.45 1.44e-02 0.297
#> 19 Plan Repair 1 60 47.77 0.0397 0.2335 1.99 4.64e-02 0.148
#> kappa kappa_z kappa_p lift sign significant
#> 1 0.4556 33.41 1.15e-244 2.21 over TRUE
#> 2 0.4940 17.86 2.49e-71 3.15 over TRUE
#> 3 0.4082 15.99 1.56e-57 7.51 over TRUE
#> 4 0.1655 15.30 7.73e-53 1.28 over TRUE
#> 5 0.2643 14.07 6.11e-45 4.99 over TRUE
#> 6 0.1130 7.20 6.20e-13 2.66 over TRUE
#> 7 0.1088 6.93 4.15e-12 2.63 over TRUE
#> 8 0.0915 5.21 1.84e-07 1.18 over TRUE
#> 9 0.0689 6.37 1.88e-10 2.03 over TRUE
#> 10 0.1044 5.93 2.94e-09 4.34 over TRUE
#> 11 0.0716 2.59 9.67e-03 1.82 over TRUE
#> 12 0.0161 1.18 2.37e-01 1.23 over TRUE
#> 13 0.1480 4.16 3.16e-05 1.66 over TRUE
#> 14 0.0488 3.77 1.66e-04 2.73 over TRUE
#> 15 0.0419 1.62 1.04e-01 1.27 over TRUE
#> 16 0.0215 1.55 1.22e-01 2.32 over TRUE
#> 17 0.1325 2.75 5.97e-03 1.19 over TRUE
#> 18 0.0407 2.16 3.05e-02 1.73 over TRUE
#> 19 0.0543 1.83 6.75e-02 1.26 over TRUEInvestigate -> Plan is the strongest over-represented
transition. It occurred 977 times, its transition probability is 0.44,
and its adjusted residual is 33.4. The probability means that planning
follows investigation 44% of the time, and the lift of 2.21 means this
is 2.2 times more often than independence predicts; investigation is
regularly converted into planning. Ask -> Explain
carries a lift of 7.51, so asking is followed by explaining about seven
times more often than chance. Execute -> Execute has a
probability of 0.51, so execution is followed by execution about half
the time and tends to occur in runs. Delegate -> Plan
and Explain -> Report describe related regularities.
transitions(fit, direction = "under", sort = "strength")
#> from to lag count expected prob prob_col adj_res p yules_q
#> 1 Plan Plan 1 49 298.36 0.03245 0.03053 -17.86 2.36e-71 -0.803
#> 2 Investigate Execute 1 563 889.54 0.25190 0.17414 -16.57 1.07e-61 -0.423
#> 3 Execute Plan 1 358 610.54 0.11586 0.22305 -14.50 1.30e-47 -0.431
#> 4 Delegate Execute 1 51 111.44 0.18214 0.01577 -7.51 5.92e-14 -0.508
#> 5 Explain Plan 1 35 99.58 0.06944 0.02181 -7.46 8.65e-14 -0.553
#> 6 Repair Plan 1 4 49.59 0.01594 0.00249 -7.34 2.10e-13 -0.881
#> 7 Explain Execute 1 129 200.59 0.25595 0.03990 -6.73 1.73e-11 -0.333
#> 8 Investigate Explain 1 79 143.90 0.03535 0.15105 -6.57 5.04e-11 -0.380
#> 9 Delegate Investigate 1 26 69.32 0.09286 0.01293 -6.10 1.03e-09 -0.536
#> 10 Execute Report 1 32 68.85 0.01036 0.17680 -5.71 1.16e-08 -0.489
#> 11 Report Plan 1 5 32.01 0.03086 0.00312 -5.38 7.31e-08 -0.775
#> 12 Investigate Repair 1 40 70.71 0.01790 0.15564 -4.36 1.30e-05 -0.355
#> 13 Investigate Report 1 26 49.80 0.01163 0.14365 -4.01 6.17e-05 -0.393
#> 14 Ask Plan 1 3 17.98 0.03297 0.00187 -3.97 7.30e-05 -0.759
#> 15 Investigate Delegate 1 36 59.43 0.01611 0.16667 -3.62 2.96e-04 -0.317
#> 16 Investigate Investigate 1 493 553.32 0.22058 0.24515 -3.47 5.16e-04 -0.102
#> 17 Ask Investigate 1 9 22.53 0.09890 0.00448 -3.30 9.52e-04 -0.503
#> 18 Execute Explain 1 169 198.95 0.05469 0.32314 -2.79 5.29e-03 -0.133
#> 19 Ask Execute 1 26 36.22 0.28571 0.00804 -2.20 2.78e-02 -0.249
#> 20 Repair Repair 1 2 7.94 0.00797 0.00778 -2.18 2.95e-02 -0.613
#> 21 Repair Report 1 1 5.59 0.00398 0.00552 -2.00 4.60e-02 -0.708
#> kappa kappa_z kappa_p lift sign significant
#> 1 -0.840 -18.16 1.04e-73 0.1642 under TRUE
#> 2 -0.362 -16.02 9.06e-58 0.6329 under TRUE
#> 3 -0.420 -14.73 4.13e-49 0.5864 under TRUE
#> 4 -0.546 -7.49 6.85e-14 0.4576 under TRUE
#> 5 -0.647 -7.39 1.42e-13 0.3515 under TRUE
#> 6 -0.918 -7.22 5.10e-13 0.0807 under TRUE
#> 7 -0.354 -6.56 5.42e-11 0.6431 under TRUE
#> 8 -0.444 -6.39 1.67e-10 0.5490 under TRUE
#> 9 -0.675 -7.19 6.49e-13 0.3751 under TRUE
#> 10 -0.536 -5.72 1.08e-08 0.4648 under TRUE
#> 11 -0.854 -5.62 1.96e-08 0.1562 under TRUE
#> 12 -0.426 -4.22 2.41e-05 0.5657 under TRUE
#> 13 -0.470 -3.90 9.82e-05 0.5221 under TRUE
#> 14 -0.840 -4.06 4.82e-05 0.1668 under TRUE
#> 15 -0.550 -5.86 4.72e-09 0.6057 under TRUE
#> 16 -0.215 -7.38 1.58e-13 0.8910 under TRUE
#> 17 -0.664 -4.05 5.03e-05 0.3995 under TRUE
#> 18 -0.154 -2.85 4.44e-03 0.8495 under TRUE
#> 19 -0.311 -2.44 1.47e-02 0.7179 under TRUE
#> 20 -0.741 -2.12 3.37e-02 0.2518 under TRUE
#> 21 -0.816 -1.95 5.08e-02 0.1788 under TRUEPlan -> Plan is the strongest under-represented
transition, with an adjusted residual of -17.9 and a lift of 0.16.
Planning is therefore very rarely repeated immediately: a planning
action is followed by another planning action only about one-sixth as
often as expected. The result does not mean planning is uncommon; it
means planning is normally followed by a different action.
Investigate -> Execute (residual -16.6) is also
under-represented, so investigation seldom leads straight to execution.
Read together with the over-represented
Investigate -> Plan, these avoidances show a separation
between gathering information and acting on it, with a planning step in
between.
The network represents each state as a node and each transition as a directed edge, with edge width proportional to the weight and an edge that loops to its own node marking a self-transition. Three networks can be drawn from the same model, differing in the quantity they place on the edges: the residual network, the Yule’s Q network, and the probability network.
The residual network draws the signed adjusted residuals, blue for
over-represented and red for avoided transitions. Because a residual
grows with sample size and 40 of the 64 transitions are significant, the
network with every edge is dense. The top argument of
plot_transitions() keeps the strongest edges by absolute
residual.
The pruned residual network keeps the 12 edges with an absolute
residual of 7 or more, and it has a directed shape.
Investigate -> Plan is the heaviest edge (residual 33.4)
and Delegate -> Plan the second (18.1), so planning is
the common destination of information gathering and delegation.
Execute -> Execute is a heavy self-loop (residual 16.1),
so the process remains in execution once it arrives, and
Execute -> Plan is red (residual -14.5), so it rarely
returns to planning. The red edges Plan -> Plan (-17.9)
and Investigate -> Execute (-16.6) show that planning
does not repeat and that investigation does not jump straight to
execution. Two weaker over-represented edges fall below the cut and are
read from the transitions() table above:
Plan -> Execute (residual 6.3) and
Plan -> Investigate (5.6). With them, investigation and
planning form a mutual pair, and the link from planning to execution
runs one way only.
The Yule’s Q network shows the same signed departures on a bounded scale from -1 to 1 that does not grow with sample size, so its edge values are comparable across data sets and across groups of different sizes.
The Yule’s Q network keeps the core of the residual network:
Investigate -> Plan (Q = 0.734),
Delegate -> Plan (0.761), Ask -> Explain
(0.873), and the avoided Plan -> Plan (-0.803) are among
its 12 strongest edges. Its weights are bounded association values
rather than test statistics, so the ranking differs. The strongest Q of
all is the avoided Repair -> Plan (Q = -0.881), which
rests on 4 observed transitions, and Repair -> Report
enters with a single transition, whereas the frequent
Execute -> Execute (Q = 0.358) drops out. A Q network
therefore reads the strength of association independently of volume, and
it is the form to use when the networks of two groups of different sizes
are compared; a large Q on a rare transition is read together with its
count.
The probability network draws the same transitions weighted by \(P(\text{to} \mid \text{from})\), the share of moves out of a state that reach each destination. This is the network of Transition Network Analysis (TNA); a thin ring around each node shows the initial probability of starting in that state.
The probability network foregrounds the most frequent transitions:
Delegate -> Plan (0.62),
Execute -> Execute (0.51),
Ask -> Explain (0.48), Plan -> Execute
(0.47), and Investigate -> Plan (0.44). It is not
equivalent to the lag-sequential networks. A transition probability lies
between 0 and 1, records how often a transition occurs, and reaches its
smallest value at zero, so it cannot represent a transition that occurs
less often than expected. A signed residual or Yule’s Q can. The
under-represented edges of the residual network, such as
Execute -> Plan, have no counterpart in the probability
network. The probability network describes where the process goes; the
lag-sequential networks identify which transitions depart from chance,
and in which direction.
The adjusted residual is an analytic test, and its conclusions can be checked against the data by resampling. The bootstrap resamples whole sessions with replacement, refits the model on each resample, and records a confidence interval for every edge together with whether the edge keeps its sign. The call below draws 500 resamples.
set.seed(2026)
boot <- bootstrap_lsa(fit, R = 500)
boot
#> <lsa_bootstrap>
#> engine: classical
#> level: sequence
#> replicates: 500
#> CI level: 95%
#> stable edges: 42 of 64The bootstrap finds 42 of the 64 possible edges to be stable, meaning their sign is preserved across the resamples. A stable edge can be reported with confidence, whereas an unstable edge might not reappear in a new sample even when its residual is large.
Analytic certainty offers a closed-form alternative to the bootstrap.
The certainty_lsa() function models each state’s outgoing
transitions as Dirichlet-Multinomial, which yields a posterior
distribution, a credible interval, and a certainty decision for each
transition probability without resampling.
cert <- certainty_lsa(fit)
cert
#> <lsa_certainty> (analytic Dirichlet-Multinomial)
#> engine: classical
#> prior: Dirichlet(0.50)
#> CI level: 95% | inference: stability
#> certain edges: 26 of 64Analytic certainty classifies 26 of 64 edges as certain, meaning their transition probabilities are estimated precisely. The bootstrap and the analytic estimate agree on the overall picture: the frequent transitions are estimated with confidence, and the rare transitions are not. The full set of checks, including case-drop stability, split-half reliability, and a permutation null, is in Evaluating transitions.
The analysis of ai_long shows that the order of actions
is not random (\(G^2 = 2168\), \(p < 0.001\)) and that the process has a
definite shape. Sessions almost always begin in Investigate
(initial probability 0.715). Investigate and
Plan form a mutual pair, feed forward into
Execute through the one-directional
Plan -> Execute, and terminate in Execute,
which is the busiest state (3233 incoming transitions), occurs in runs
(Execute -> Execute, probability 0.51), and rarely
returns to planning. Planning does not repeat
(Plan -> Plan, residual -17.9) and investigation seldom
leads straight to execution (Investigate -> Execute,
residual -16.6), so a planning step separates information gathering from
acting on it. Of the 64 possible transitions, 40 are significant, 42 are
sign-stable under the bootstrap, and 26 are certain under the Bayesian
estimate, so a transition merits reporting when it is significant,
sizeable, and reproducible.
The three networks have distinct uses. The residual network shows which transitions depart from chance and is the primary display of a lag sequential analysis. The Yule’s Q network shows the same departures on a scale that is comparable across data sets and groups. The probability network shows where the process tends to go and is the display to pair with a transition network analysis.