AGDES: Automatic Generation of Dependent Event Sequences

Alexander Obeid Guzman

arxiv: 2605.23808 · v1 · pith:RI2UUEUFnew · submitted 2026-05-22 · 💻 cs.FL

AGDES: Automatic Generation of Dependent Event Sequences

Alexander Obeid Guzman This is my paper

Pith reviewed 2026-05-25 02:05 UTC · model grok-4.3

classification 💻 cs.FL

keywords AGDESdependent event sequencesdeterministic finite automatatransducersautomatic generationevent sequencesformal languages

0 comments

The pith

Dependent event sequences are generated as output words of DFAs or as outputs of transducer DFAs reading input sequences.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper presents AGDES, a tool for automatically generating dependent event sequences. Sequences are produced either directly as the output word of a deterministic finite automaton or through a transducer that processes one or more input sequences to yield the output. This approach uses automata to model dependencies between events. A reader might care because it offers a structured, formal method for creating sequences that satisfy specific dependency relations, potentially useful for simulation and testing scenarios involving events.

Core claim

AGDES generates each event sequence either as the output word of a DFA or as the output word of a DFA called transducer that reads events from one or more input sequences and produces an output sequence.

What carries the argument

Deterministic finite automata (DFAs) for direct output generation and transducer DFAs that map input sequences to output sequences.

If this is right

Event sequences can be defined and generated deterministically using finite state machines.
Dependencies between events are captured by the transition functions of the automata.
Transducers allow combining multiple input sequences to derive dependent outputs.
The method supports both standalone generation and input-dependent generation.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

This could enable systematic generation of test cases for systems with event dependencies.
Extensions might include probabilistic variants or integration with other automata-based tools.
Without provided examples or comparisons, its efficiency compared to other generation methods remains to be explored.

Load-bearing premise

The described DFA and transducer mechanisms provide a practical and sufficient method for generating dependent event sequences.

What would settle it

A case where the generated sequences fail to respect the dependencies encoded in the automata transitions or where the transducer produces outputs inconsistent with its input mappings would disprove the central claim.

Figures

Figures reproduced from arXiv: 2605.23808 by Alexander Obeid Guzman.

**Figure 1.** Figure 1: Producer automaton P generated with minStates=4, maxStates=6, minAlphabet=3, maxAlphabet=10, minTransitions=1, maxTransitions=4 And an example of a transducer is the following [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗

**Figure 2.** Figure 2: Transducer automaton T generated with minStates=4, maxStates=10, minAlphabet=3, maxAlphabet=10, minTransitions=1, maxTransitions=1, ratio i o=0.3 2 [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗

read the original abstract

This note presents AGDES, a tool for Automatic Generation of Dependent Event Sequences. Each event sequence is either generated as the output word of a deterministic finite automaton (DFA), or produced as the output word of a DFA called transducer that reads events from one or more input sequences, and produces an output sequence.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Desk Editor's Note private letter to a colleague

AGDES is a one-sentence restatement of standard DFA output words and transducers with no definitions, examples, or evidence supplied.

read the letter

The paper is a short note that names a tool, AGDES, for generating dependent event sequences. Each sequence is produced either as the output word of a DFA or as the output of a transducer DFA that reads from input sequences. That is the entire contribution on offer. DFA outputs and transducers are textbook constructions that have been used for sequence generation for decades, so nothing here is new in the theory. The note does not claim a new result, a new construction, or any property that would require proof. It simply attaches a name to the familiar idea. There is no code, no pseudocode, no small worked example showing an input sequence and the dependent output it produces, and no discussion of alphabets, transition functions, or how dependence is actually enforced beyond the automaton structure. The stress-test observation holds: the manuscript gives only the abstract sentence and nothing more. Without those details it is impossible to judge whether the tool does anything beyond relabeling existing automata machinery. A reader who needs a practical generator for dependent sequences in verification or testing will find nothing usable or verifiable here. Someone already familiar with transducers might skim it in a minute and move on. I would not bring this to a reading group. I would not cite it. It does not contain enough substance to justify sending it to peer review; a serious editor should desk-reject it on the grounds that there is no technical content to referee.

Referee Report

1 major / 0 minor

Summary. The manuscript presents AGDES, a tool for Automatic Generation of Dependent Event Sequences. Each event sequence is generated either as the output word of a deterministic finite automaton (DFA) or as the output word of a transducer DFA that reads events from one or more input sequences.

Significance. If implemented and shown to work, the approach could supply a formal automata-theoretic method for producing event sequences with explicit dependencies, potentially applicable to test-case generation or protocol simulation in formal methods. The manuscript supplies no implementation, examples, or validation, so no assessment of significance is possible.

major comments (1)

[Abstract] Abstract (and full manuscript text): the central claim that AGDES generates dependent sequences via DFA output words or transducer DFAs is unsupported by any formal definition of the automata, transition relation, output function, alphabet, or acceptance condition, and contains no worked example of an input sequence and resulting dependent output. This absence is load-bearing because it makes it impossible to determine whether the stated mechanisms produce any non-trivial dependence relation.

Simulated Author's Rebuttal

1 responses · 0 unresolved

We thank the referee for the detailed review. The manuscript is a short note introducing the AGDES concept, and we acknowledge the need for additional formal content to support the claims.

read point-by-point responses

Referee: [Abstract] Abstract (and full manuscript text): the central claim that AGDES generates dependent sequences via DFA output words or transducer DFAs is unsupported by any formal definition of the automata, transition relation, output function, alphabet, or acceptance condition, and contains no worked example of an input sequence and resulting dependent output. This absence is load-bearing because it makes it impossible to determine whether the stated mechanisms produce any non-trivial dependence relation.

Authors: We agree that the current manuscript lacks the requested formal definitions and examples. In the revised version we will add precise definitions of the DFA (including alphabet, transition relation, output function, and acceptance condition) and the transducer model (including how it reads from multiple input sequences), together with at least one fully worked example showing an input sequence and the resulting dependent output sequence. revision: yes

Circularity Check

0 steps flagged

No derivation chain or equations present; purely descriptive note

full rationale

The manuscript consists of a single-sentence description of AGDES functionality with no equations, no derivations, no fitted quantities, no self-citations, and no load-bearing claims that reduce to inputs by construction. The central statement simply defines the tool's output mechanism without any mathematical reduction or prediction step that could be circular.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

Abstract-only review yields no identifiable free parameters, axioms, or invented entities; the description relies on standard DFA concepts from prior literature.

pith-pipeline@v0.9.0 · 5555 in / 895 out tokens · 15603 ms · 2026-05-25T02:05:07.346625+00:00 · methodology

discussion (0)

Reference graph

Works this paper leans on

5 extracted references · 5 canonical work pages

[1]

Causal discovery in semi-stationary time series,

S. Gao, R. Addanki, T. Yu, R. A. Rossi, and M. Kocaoglu, “Causal discovery in semi-stationary time series,”arXiv, 2024.doi:10.48550/arxiv.2407.07291

work page doi:10.48550/arxiv.2407.07291 2024
[2]

Predicting network hardware faults through layered treatment of alarms logs,

A. Massaro, D. Kostadinov, A. Silva, A. Obeid Guzman, and A. Aghasaryan, “Predicting network hardware faults through layered treatment of alarms logs,”Entropy, vol. 25, no. 6, 2023,issn: 1099-4300.doi:10.3390/e25060917[Online]. Available:https://www.mdpi.com/1099-4300/ 25/6/917

work page doi:10.3390/e25060917 2023
[3]

Causal datasheet for datasets: An evaluation guide for real-world data analysis and data collection design using bayesian networks,

B. Butcher et al., “Causal datasheet for datasets: An evaluation guide for real-world data analysis and data collection design using bayesian networks,”Frontiers in Artificial Intelligence, vol. 4, 2021.doi:10.3389/frai.2021.612551

work page doi:10.3389/frai.2021.612551 2021
[4]

Learning multiscale non-stationary causal structures,

G. D’Acunto, G. D. F. Morales, P. Bajardi, and F. Bonchi, “Learning multiscale non-stationary causal structures,”Transactions on Machine Learning Research, 2023, ISSN 2835-8856, 2022. doi:10.48550/arxiv.2208.14989

work page doi:10.48550/arxiv.2208.14989 2023
[5]

Obeid Guzman,Agdes,https://gitlab.inria.fr/aobeidgu/agdes, 2026

A. Obeid Guzman,Agdes,https://gitlab.inria.fr/aobeidgu/agdes, 2026. 8

work page 2026

[1] [1]

Causal discovery in semi-stationary time series,

S. Gao, R. Addanki, T. Yu, R. A. Rossi, and M. Kocaoglu, “Causal discovery in semi-stationary time series,”arXiv, 2024.doi:10.48550/arxiv.2407.07291

work page doi:10.48550/arxiv.2407.07291 2024

[2] [2]

Predicting network hardware faults through layered treatment of alarms logs,

A. Massaro, D. Kostadinov, A. Silva, A. Obeid Guzman, and A. Aghasaryan, “Predicting network hardware faults through layered treatment of alarms logs,”Entropy, vol. 25, no. 6, 2023,issn: 1099-4300.doi:10.3390/e25060917[Online]. Available:https://www.mdpi.com/1099-4300/ 25/6/917

work page doi:10.3390/e25060917 2023

[3] [3]

Causal datasheet for datasets: An evaluation guide for real-world data analysis and data collection design using bayesian networks,

B. Butcher et al., “Causal datasheet for datasets: An evaluation guide for real-world data analysis and data collection design using bayesian networks,”Frontiers in Artificial Intelligence, vol. 4, 2021.doi:10.3389/frai.2021.612551

work page doi:10.3389/frai.2021.612551 2021

[4] [4]

Learning multiscale non-stationary causal structures,

G. D’Acunto, G. D. F. Morales, P. Bajardi, and F. Bonchi, “Learning multiscale non-stationary causal structures,”Transactions on Machine Learning Research, 2023, ISSN 2835-8856, 2022. doi:10.48550/arxiv.2208.14989

work page doi:10.48550/arxiv.2208.14989 2023

[5] [5]

Obeid Guzman,Agdes,https://gitlab.inria.fr/aobeidgu/agdes, 2026

A. Obeid Guzman,Agdes,https://gitlab.inria.fr/aobeidgu/agdes, 2026. 8

work page 2026