Simulation by Rounds of Letter-to-Letter Transducers

Letter-to-letter transducers are a standard formalism for modeling reactive systems. Often, two transducers that model similar systems differ locally from one another, by behaving similarly, up to permutations of the input and output letters within"rounds". In this work, we introduce and study notions of simulation by rounds and equivalence by rounds of transducers. In our setting, words are partitioned to consecutive subwords of a fixed length $k$, called rounds. Then, a transducer $\mathcal{T}_1$ is $k$-round simulated by transducer $\mathcal{T}_2$ if, intuitively, for every input word $x$, we can permute the letters within each round in $x$, such that the output of $\mathcal{T}_2$ on the permuted word is itself a permutation of the output of $\mathcal{T}_1$ on $x$. Finally, two transducers are $k$-round equivalent if they simulate each other. We solve two main decision problems, namely whether $\mathcal{T}_2$ $k$-round simulates $\mathcal{T}_1$ (1) when $k$ is given as input, and (2) for an existentially quantified $k$. We demonstrate the usefulness of the definitions by applying them to process symmetry: a setting in which a permutation in the identities of processes in a multi-process system naturally gives rise to two transducers, whose $k$-round equivalence corresponds to stability against such permutations.


Introduction
Reactive systems interact with their environment by receiving inputs, corresponding to the state of the environment, and sending outputs, which describe actions of the system.Finite-state reactive systems are often modeled by transducers -finite-state machines over alphabets Σ I and Σ O of inputs and outputs, respectively, which read an input letter in Σ I , and respond with an output in Σ O .Such transducers are amenable to automatic verification of certain properties (e.g., LTL model-checking), and are therefore useful in practice.Nonetheless, modeling complex systems may result in huge transducers, which makes verification procedures prohibitively expensive, and makes understanding the constructed transducers difficult.
A common approach to gain a better understanding of a transducer (or more generally, any system) is simulation [Mil71], whereby a transducer T 1 is simulated by a "simpler" transducer T 2 in such a way that model checking is easier on T 2 , and the correctness of the desired property is preserved under the simulation.Usually, "simpler" means smaller, as in standard simulation [Mil71] and fair simulation [HKR97], but one can also view e.g., linearization of concurrent programs [HW87] as a form of simulation by a simpler machine.
In this work, we introduce and study new notions of simulation and of equivalence for transducers, based on rounds: consider an input word x ∈ Σ * I whose length is k • R for some k, R > 0. We divide the word into R disjoint infixes of length k, each called a round of w.We then say that two words x, x ′ ∈ Σ kR I are k-round equivalent, denoted x ′ ≍ k x, if x ′ is obtained from x by permuting the positions of letters within each round of x.For example abcabc and cbaacb are 3-round equivalent, since cba is a permutation of abc and so is acb.Example 3.1 presents a pair of words that are 3-round equivalent but not 4-round equivalent.We now say that a transducer T 1 is k-round simulated by a transducer T 2 , denoted T 1 ≺ k T 2 , if for every 1 input x ∈ Σ kR I we can find x ′ ≍ k x such that the outputs of T 1 on x and T 2 on x ′ , denoted y, y ′ respectively, are also round equivalent: y ′ ≍ k y.Intuitively, T 1 ≺ k T 2 means that every behaviour of T 1 is captured by T 2 , up to permutations within each round.When we have both T 1 ≺ k T 2 and T 2 ≺ k T 1 , we say that they are k-round equivalent and denote this by T 1 ≡ k T 2 .
The benefit of k-round simulation is twofold.First, it may serve as an alternative simulation technique for reducing the state space while maintaining the correctness of certain properties.Second, we argue that k-round simulation is in and of itself a design concern.Indeed, in certain scenarios, as follows, we can naturally design a transducer T 2 that performs a certain task in an ideal, but not realistic, way, and we want to check that an existing design, namely T 1 , is simulated by this ideal.In particular, this is useful when dealing with systems that naturally work in rounds, such as schedulers (e.g., Round Robin, cf.Example 3.3), arbiters, and other resource allocation systems.
We now demonstrate both benefits by an example.
Example 1.1.Consider a monitor M for the fairness of a distributed system with 10 processes P = {1, . . ., 10}.At each timestep, M receives as input the ID of the process currently working.The monitor then verifies that in each round of 10 steps, every process works exactly once.As long as this holds, the monitor keeps outputting safe; otherwise, it outputs error.M can be modeled by a transducer T 1 that keeps track of the set of processes that have worked in the current round.Thus, the transducer has at least 2 10 states, as it needs to keep track of the subset of processes that have been seen.
It is not hard to see that T 1 is 10-round simulated by an "ideal" transducer T 2 which expects to see the processes in the order 1, . . ., 10.This transducer needs roughly 10 states, as it only needs to know the index of the next process it expects to see.
Now, suppose we want to verify some correctness property which is invariant to permutations of the processes within each round of length 10, such as "if there is no error, then Process 3 works at least once every 20 steps".Then we can verify this against the much smaller T 2 .
The notion of k-round simulation arises naturally in the setting of process symmetry.There, the input and output alphabets are Σ I = 2 I and Σ O = 2 O respectively, where I = {i 1 , . . ., i m } and O = {o 1 , . . ., o m } represent signals corresponding to m processes.Process symmetry addresses the scenario where the identifiers of the processes may be scrambled.For example, if the input {i 1 , i 2 } is generated, the system might actually receive an input {i 7 , i 4 }.A system exhibits process symmetry if, intuitively, its outputs are permuted in a similar way to the inputs.Unfortunately, deterministic systems that are process symmetric are extremely naive, as process symmetry is too restrictive for them.While this can be overcome using probabilistic systems, as studied in [Alm20], it is also desirable to find a definition that is suited for deterministic systems.As we show in section 6, k-round simulation provides such a definition.
The main contributions of this work are as follows.We introduce the notion of k-round simulation and k-round equivalence, and define two decision problems pertaining to them: in fixed round simulation we need to decide whether T 1 ≺ k T 2 for a given value of k, and in existential round simulation we need to decide whether there exists some value of k for which T 1 ≺ k T 2 holds.In fact, we consider a somewhat more elaborate setting, by also allowing the inputs to T 1 to be restricted to some regular language Λ.We solve the first problem by reducing it to the containment of two nondeterministic automata.For the second problem, things become considerably more difficult, and the solution requires several constructions, as well as tools such as Presburger arithmetic and Parikh's theorem.In addition, we demonstrate the usefulness of the definitions in relation to process symmetry.
Related Work.Simulation relations between systems are a well studied notion.We refer the reader to [CHVB18, Chapter 13] and references therein for an exposition.The connection of our notion with standard simulation is only up to motivation, as our measure is semantic: it does not directly relate to the state space; instead, it refers to the behaviour of the system rather than its structure.
On the technical level, our work is closely related to commutative automata [BS73] and jumping automata [FPS15, MZ12] -models of automata capable of reading their input in a discontinuous manner, by jumping from one letter to another.Indeed, our notion of round simulation essentially allows the simulating transducer to read the letters within rounds in a discontinuous manner.This similarity is manifested implicitly in section 5.2, where we encounter similar structures as e.g. the commutative closure in [Hof20] (although the analysis here has a different purpose).
Finally, the initial motivation for this work comes from process symmetry [Alm20, CEFJ96, ES96, ID96, LNRS16].We explore the connections in depth in section 6.
Paper Organization.The rest of this work is organized as follows.In section 2 we present some basic definitions used throughout the paper.In section 3 we introduce kround simulation and equivalence, define the relevant decision problems, and study some fundamental properties of the definitions.In section 4 we solve fixed round simulation, while developing some technical tools and characterizations that are reused later.section 5 is our main technical result, where we develop a solution for existential round simulation.In particular, in section 5.1 we give an overview of the solution, before going through the technical details in section 5.2.In section 5.3 we give lower bounds for the existential setting.In section 6 we use round simulation to obtain a definition of process symmetry for deterministic transducers, along with an algorithm for deciding it.In section 7 we study the mapping between transducers that induces a simulation.In section 8 we study variants of symmetry and simulation, both refining and coarsening the previous notions.Finally, we conclude with some open problems in section 9.

Preliminaries
Automata.A deterministic finite automaton (DFA) is A = ⟨Σ, Q, q 0 , δ, F ⟩, where Q is a finite set of states, q 0 ∈ Q is an initial state, δ : Q × Σ → Q is a transition function, and F ⊆ Q is the set of accepting states.
The run of A on a word is a sequence of states q 0 , q 1 , . . ., q n such that q i+1 = δ(q i , σ i ) for all 0 ≤ i < n.The run is accepting if q n ∈ F .A word w ∈ Σ * is accepted by A if the run of A on w is accepting.The language of A, denoted L(A), is the set of words that A accepts.We also consider nondeterministic finite automata (NFA), where δ : Q × Σ → 2 Q and there can be multiple initial states.Then, a run of A on a word w ∈ Σ * as above is a sequence of states q 0 , q 1 , . . ., q n such that q 0 is an initial state and q i+1 ∈ δ(q i , σ i ) for all 0 ≤ i < n.Analogously to the deterministic setting, the language of A is the set of words that have an accepting run.We denote by |A| the number of states of A.
As usual, we denote by δ * the transition function lifted to words.For states q, q ′ and w ∈ Σ * , we write q w −→ A q ′ if q ′ ∈ δ * (q, w).That is, if there is a run of A from q to q ′ while reading w.
An NFA A can be viewed as a morphism from Σ * to the monoid B Q×Q of Q × Q Boolean matrices, where we associate with a letter σ ∈ Σ its type τ A (σ) ∈ B Q×Q defined by (τ A (σ)) q,q ′ = 1 if q σ −→ A q ′ , and (τ A (σ)) q,q ′ = 0 otherwise.We lift the definition of types to Σ * by defining, for a word where the concatenation denotes Boolean matrix product.It is easy to see that (τ A (w)) q,q ′ = 1 iff q w −→ A q ′ .For example, the types of the letters a and b in the automaton in fig. 1 are the 3 × 3 matrices and the type of the word w = ab in the transducer in fig. 1 is the matrix Figure 1: A nondeterministic automaton with one initial state q 0 and one accepting state q 2 .
Transducers.Consider two sets Σ I and Σ O representing input and output alphabets, respectively.A Σ I /Σ O transducer is T = ⟨Σ I , Σ O , Q, q 0 , δ, ℓ⟩ where Q, q 0 ∈ Q, and δ : Q × Σ I → Q are as in a DFA, and ℓ : Q → Σ O is a labelling function on the states.For a word w ∈ Σ * I , consider the run ρ = q 0 , . . ., q n of T on w.We define its output O , and we define the output of T on w to be T (w) = ℓ(ρ).Observe that we ignore the labelling of the initial state in the run, so that the length of the output matches that of the input.

Words and rounds. Consider a word
We denote its length by |w|, and for 0 then for every 0 ≤ r < R we refer to w[rk : r(k + 1) − 1] as the r-th round in w (of length k), and we write w = γ 0 • • • γ R−1 where γ r is the r-th round.We emphasize that k indicates the length of each round, not the number of rounds.
In particular, throughout the paper we consider words (x, y) ∈ (Σ k I × Σ k O ) * and their rounds of length k.In such cases, we sometimes use the natural embedding of ( , and refer to these sets interchangeably. Parikh vectors and permutations.Consider an alphabet Σ.For a word w ∈ Σ * and a letter σ ∈ Σ, we denote by # σ (w) the number of occurrences of σ in w.The Parikh map P : Σ * → N Σ maps every word w ∈ Σ * to a Parikh vector P(w) ∈ N Σ , where P(w)(σ) = # σ (w).We lift this to languages by defining, for L ⊆ Σ * , P(L) = {P(w) : w ∈ L}.
Consider words x, y ∈ Σ * .We say that x is a permutation of y if P(x) = P(y) (indeed, in this case y can be obtained from x by permuting its letters).In particular this implies |x| = |y|.

Round Simulation and Round Equivalence
Consider two k-round words x, y ∈ Σ kR with the same number of rounds R, and denote their rounds by We say that x and y are k-round equivalent, denoted x ≍ k y (or x ≍ y, when k is clear from context)2 , if for every 0 ≤ r < R we have that P(α r ) = P(β r ).That is, x ≍ y iff the r-th round of y is a permutation of the r-th round of x, for every r.Indeed, ≍ is an equivalence relation.
Example 3.1 (Round-equivalence for words).Consider the words x = abaabbabbbaa and y = baabbaabbaba over the alphabet Σ = {a, b}.Looking at the words as 3-round words, one can see in table 1 that rounds of length 3 in y are all permutations of those in x, which gives x ≍ 3 y.However, looking at the rounds of length 4 of x, y, the number of occurrences of b already in the first round of x and of y is different, so x ̸ ≍ 4 y, as illustrated in table 2.
Let Σ I and Σ O be input and output alphabets, let Λ ⊆ Σ * I be a regular language, and let k > 0. Consider two Σ I /Σ O transducers T 1 and T 2 .We say that T 2 k-round simulates T 1 for every input word x ∈ Λ, we can permute each round of length k in x to obtain a new word x ′ , such that the outputs of T 1 on x and of T 2 on x ′ are k-round equivalent.Note that the definition is not symmetric: the input x for T 1 is universally quantified, while x ′ is chosen according to x.We illustrate this in Example 3.5.
If T 1 ≺ k,Λ T 2 and T 2 ≺ k,Λ T 1 we say that T 1 and T 2 are k-round equivalent restricted to Λ, denoted T 1 ≡ k,Λ T 2 .In the special case where Λ = Σ * I (i.e., when we require the simulation to hold for every input), we omit it from the subscript and write T 1 ≺ k T 2 .Remark 3.2 (On the role of Λ).Transducers have a "universal" flavor, in that every input string is assigned an output.In many settings, however, inputs of interest should comply to some simple form, and are otherwise irrelevant.The restriction language Λ allows the designer to specify that we only care about symmetry when the input is correctly formed.
We note that it is technically easy to add a similar restriction-language for T 2 , although we find it less motivated, as T 2 is meant to be an abstraction of T 1 for the purpose of verification, rather than a concrete model to act in an environment.
The transducer T i for RR, initial state omitted.The input letters σ and ¬σ mean all letters from 2 P that, respectively, contain or do not contain σ.The labels are written in red.
We argue that, if we allow permutation of the input letters, then the set of processes whose requests are granted in each round is independent of the start state.This is equivalent to saying T 0 ≡ 3 T j for j ∈ {1, 2}, which indeed holds: if j = 1 then we permute all rounds of the form σ 0 σ 1 σ 2 to σ 1 σ 2 σ 0 , and similarly if j = 2 then we permute all rounds to σ 2 σ 0 σ 1 .It is easy to see that the run of T i on the permuted input grants outputs that are 3-round equivalent to the output of T 0 on the non-permuted input.
Remark 3.4.In Example 3.3, the constant k of round equivalence is equal to the number of processes k = 3.This need not be the case in general.Indeed, one could define Round Robin over 3 processes that follows the request order e.g., 111232332.It is easy to show that in this case, the natural round length is 9, and that permutations of 3-rounds are not enough to reorder inputs starting from different initial states.
In Example 3.3, the transducers satisfied not only round simulation, but also round equivalence.We now show that this is not always the case for simulating transducers.but T 2 ̸ ≺ 2 T 1 .Starting with the latter, observe that T 2 (ab) = 00, but T 1 (ab) = T 1 (ba) = 01.Since 00 ̸ ≍ 2 01, we have T 2 ̸ ≺ 2 T 1 .We turn to show that T 1 ≺ 2 T 2 .Observe that for every input word of the form x ∈ (ab + ba) m , we have T 1 (x) = (01) m , and x ≍ 2 (ba) m .So in this case we have that Round simulation and round equivalence give rise to the following decision problems: • In fixed round simulation (resp.fixed round equivalence) we are given transducers T 1 , T 2 , an NFA for the language Λ, and k > 0 in unary, and we need to decide whether T 1 ≺ k,Λ T 2 (resp.whether T 1 ≡ k,Λ T 2 ).• In existential round simulation (resp.existential round equivalence) we are given transducers T 1 , T 2 and an NFA for the language Λ, and we need to decide whether there exists k > 0 such that T 1 ≺ k,Λ T 2 (resp.T 1 ≡ k,Λ T 2 ).In the following we identify Λ with an NFA (or DFA) for it, as we do not explicitly rely on its description.
We start by showing that deciding equivalence (both fixed and existential) is reducible, in polynomial time, to the respective simulation problem.
Proof.First, we can clearly reduce fixed round equivalence to fixed round simulation: given an algorithm that decides, given T 1 , T 2 , Λ and k > 0, whether T 1 ≺ k,Λ T 2 , we can decide whether T 1 ≡ k,Λ T 2 by using it twice to decide whether both A slightly more careful examination shows that the same approach can be taken to reduce existential round equivalence to existential round simulation, using the following observation: if T 1 ≺ k,Λ T 2 , then for every m ∈ N it holds that T 1 ≺ mk,Λ T 2 .Indeed, we can simply group every m rounds of length k and treat them as a single round of length mk.Now, given an algorithm that decides, given T 1 , T 2 and Λ, whether there exists k > 0 such that T 1 ≺ k,Λ T 2 , we can decide whether T 1 ≡ k,Λ T 2 by using the algorithm twice to decide whether there exists k 1 such that However, if there are such k 1 , k 2 , then by the observation above we have By Lemma 3.6, for the purpose of upper-bounds, we focus henceforth on round simulation.

Deciding Fixed Round Simulation
In this section we show decidability of fixed round simulation (and, by Lemma 3.6, fixed round equivalence).The tools we develop will be used in section 5 to handle the existential variant.
Let Σ I and Σ O be input and output alphabets.Consider two Σ I /Σ O transducers T 1 and T 2 , and let Λ ⊆ Σ * I and k > 0. In order to decide whether T 1 ≺ k,Λ T 2 , we proceed as follows.First, we cast the problem to a problem about deterministic automata.Then, we translate rounds into letters, by working over the alphabets Σ k I and Σ k O .We construct an NFA, dubbed the permutation closure, for each transducer T , that captures the behaviour of T on words and their permutations.Intuitively, the NFA takes as input a word (x, y) ∈ (Σ k I × Σ k O ) * , guesses a round-equivalent word x ′ ≍ x, and verifies that T (x ′ ) ≍ T (x).We then show that round simulation amounts to deciding the containment of these NFAs.
We now turn to give the details of the construction of these NFAs.
The trace DFA.Consider a transducer T = ⟨Σ I , Σ O , Q, q 0 , δ, ℓ⟩, we define its trace DFA The permutation closure NFA.Consider an NFA N = ⟨Σ I × Σ O , S, s 0 , η, F ⟩, and let k > 0. We obtain from That is, upon reading (α, β), Perm k (N ) can move to any state s ′ that is reachable in N from s by reading a permutation of α, β (denoted α ′ , β ′ ).Recall that for two words x, x ′ we have that x ≍ k x ′ if for every two corresponding rounds α, α ′ in x and x ′ we have P(α) = P(α ′ ).Thus, we have the following.
Observation 4.1.In the notations above, it holds that L(Perm Since the transition function of Perm k (N ) is only defined using permutations of its input letters, we have the following property, which we refer to as permutation invariance: Observation 4.2 (Permutation invariance).For every state s ∈ S and letters (α, β), . Given a transducer T , we apply the permutation closure to the trace DFA of T .In order to account for the restriction given by Λ ⊆ Σ * I , we identify it with Λ ⊆ Σ * I × Σ * O .Recall that Λ denotes both a language and a corresponding NFA (or DFA), so what this means is that the NFA, reading input from Σ * I × Σ * O , simply ignores the second component.Lemma 4.3.Consider transducers T 1 , T 2 , an NFA Λ and k > 0. Let A k 1 = Perm k (Tr(T 1 )∩Λ) (where the intersection implies the product NFA construction) and Proof.Recall that Tr(T ) accepts a word (x ′ , y ′ ) iff T (x ′ ) = y ′ .The claim then follows from Observation 4.1, by replacing the expression y ≍ y ′ ∧ (x ′ , y ′ ) ∈ L(Tr(T )) with the equivalent expression T (x ′ ) ≍ k y.
We now reduce round simulation to the containment of permutation closure NFAs.
Proof.For the first direction, assume T 1 ≺ k,Λ T 2 , and let (x, y) ∈ L(A k 1 ).By Lemma 4.3, x and y are k-round words, and there exists a word x ′ ∈ Λ such that x ≍ x ′ and T 1 (x ′ ) ≍ y.Since T 1 ≺ k,Λ T 2 , then applying the definition on x ′ yields that there exists a k-round word x ′′ such that x ′ ≍ x ′′ and such that T 1 (x ′ ) ≍ T 2 (x ′′ ).Since ≍ is an equivalence relation, it follows that x ≍ x ′′ and T 2 (x ′′ ) ≍ y, so again by Lemma 4.3 we have ( 2 ), we wish to prove that for every k-round word x ∈ Λ there exists a word x ′ such that x ≍ x ′ and T 1 (x) ≍ T 2 (x ′ ).Let x ∈ Λ be a k-round word, and let Remark 4.5.The proof of Lemma 4.4 does not require taking the permutation closure of Tr(T 1 ) ∩ Λ, and it could be simplified by using instead of A k 1 , the augmentation of Tr(T 1 ) ∩ Λ to k-round words.However, such an NFA is not permutation invariant, which is key to our solution for existential round simulation.Since this simplification does not reduce the overall complexity, we use a uniform setting for both solutions.Lemma 4.4 shows that deciding fixed round equivalence amounts to deciding containment of NFAs.By analyzing the size of the NFAs, we obtain the following.
Theorem 4.6.Given transducers T 1 , T 2 , an NFA Λ, and k > 0 in unary, the problem of deciding whether . By Lemma 4.4, deciding whether T 1 ≺ k,Λ T 2 amounts to deciding whether L(A k 1 ) ⊆ L(A k 2 ).Looking at the dual problem, recall that for two NFAs N 1 , N 2 we have that this follows immediately by bounding the size of an NFA for L(N 1 ) ∩ L(N 2 )).Thus, we can decide whether L(A k 1 ) ⊆ L(A k 2 ) by guessing a word w over Σ k I × Σ k O of single-exponential length (in the size of A k 1 and A k 2 ), and verifying that it is accepted by A k 1 and not by A k 2 .Observe that to this end, we do not explicitly construct A k 1 nor A k 2 , as their alphabet size is exponential.Rather, we evaluate them on each letter of w based on their construction from T .At each step we keep track of a counter for the length of w, a state of A k 1 , and a set of states of A k 2 .Since the number of states in A k 1 and A k 2 is the same as that of T 1 and T 2 , this requires polynomial space.By Savitch's theorem we have that coNPSPACE = PSPACE, and the proof is concluded.
We now establish a PSPACE-hardness lower bound, thus concluding that the problem is PSPACE-complete.In fact, we show a lower bound for round equivalence.Note that a priori, this does not entail a lower bound for round simulation by Lemma 3.6, since the reduction there is a Turing reduction.However, our PSPACE-hardness proof actually explicitly shows the hardness of both simulation and equivalence.
Proof sketch.We show a reduction from the universality problem for NFAs over alphabet {0, 1} where all states are accepting and the degree of nondeterminism is at most 2. See appendix A for a proof of PSPACE-hardness of this problem and for the full reduction.
Consider an NFA N = ⟨Q, {0, 1}, δ, q 0 , Q⟩ where |δ(q, σ)| ≤ 2 for every q ∈ Q and σ ∈ {0, 1}.Set Λ = (ab + cd) * .We construct two transducers T 1 and T 2 over input and output alphabets Σ I = {a, b, c, d} and Intuitively, our reduction encodes {0, 1} over {a, b, c, d} by identifying 0 with ab and with ba, and 1 with cd and with dc.Then, T 1 keeps outputting ⊤ for all inputs in Λ, thus mimicking a universal language in {0, 1} * (see fig. 14), whereas T 2 is obtained by replacing every nondeterministic transition of N on e.g.0 by two deterministic branches, on e.g.ab and ba (see fig. 15).Hence, when we are allowed to permute ab and ba by round equivalence, we capture the nondeterminism of N .

Deciding Existential Round Simulation
In section 4, we established a method for deciding k-round simulation for a given k.This case is for when the systems in question exhibit an apparent symmetry with a round length that a developer can guess; such as Round Robin where the round length is the number of processes involved.However, k is not necessarily given in the general sense.
We turn to solve existential round simulation.That is, given T 1 , T 2 and Λ, we wish to decide whether there exists k > 0 such that T 1 ≺ k,Λ T 2 .By Lemma 4.4, this is equivalent to deciding whether there exists k > 0 such that L(A k 1 ) ⊆ L(A k 2 ), as defined therein.Recall that solving the decision problems of round simulation will aid us in solving the initial problem of round symmetry, which gave the motivation for this work.The transition between the problems is explained in section 6. 5.1.Intuitive Overview.We start with an intuitive explanation of the solution and its challenges.For simplicity, assume for now Λ = Σ * I , so it can be ignored.The overall approach is to present a practical method for hunting k: in Theorem 5.1, the main result of this section, we give an upper bound on the minimal k > 0 for which T 1 ≺ k T 2 , rendering the search space finite.In order to obtain this bound, we proceed as follows.Observe that for a transducer T and for 0 < k ̸ = k ′ the corresponding permutation closure NFAs Perm k (Tr(T )) and Perm k ′ (Tr(T )) are defined on the same state space, but differ by their alphabet ( . Thus, by definition, these NFAs obtained from an increasing round length form infinitely many distinct automata.Nonetheless, there are only finitely many possible types of letters (indeed, at most |B Q×Q | = 2 |Q| 2 ).Therefore, there are only finitely many type profiles for NFAs-that is, the set of letter types occurring in the NFA-up to multiplicities of the letter types.
Recall that by Lemma 4.4, we have ). Intuitively, one could hope that if Perm k (Tr(T i )) and Perm k ′ (Tr(T i )) have the same type profile, for each i ∈ {1, 2}, then it holds that L(Perm k (Tr(T 1 ))) ⊆ L(Perm k (Tr(T 2 ))) iff L(Perm k ′ (Tr(T 1 ))) ⊆ L(Perm k ′ (Tr(T 2 ))).Then, if one can bound the index k after which no further type profiles are encountered, then the problem reduces to checking a finite number of containments.
Unfortunately, this is not the case, the reason being that the mapping of letters induced by the equal type profiles Perm k (Tr(T 1 )) and Perm k ′ (Tr(T 1 )) may differ from the mapping induced by Perm k (Tr(T 2 )) and Perm k ′ (Tr(T 2 )), and thus one cannot translate language containment between the two pairs.We overcome this difficulty, however, by working from the start with product automata that capture the structure of both T 1 and T 2 simultaneously, and thus unify the letter mapping.We dub them redundant product automata for their apparent redundancy.
We are now left with the problem of bounding the minimal k after which no new type profiles appear.In order to provide this bound, we show that for every type profile, the set of indices in which it occurs is semilinear.Then, by finding a bound for each type profile, we obtain the overall bound.The main result of this section is the following.
Theorem 5.1.Given transducers T 1 , T 2 and Λ, we can effectively compute Which by Lemma 4.4 immediately entails the following.
We prove Theorem 5.1 in section 5.2, organized as follows.We start by lifting the definition of types in an NFA to Parikh vectors, and show how these relate to the NFA (in Lemma 5.3).We then introduce Presburger arithmetic and its relation to Parikh's theorem.In Lemma 5.4 we show that the set of Parikh vectors that share a type τ is definable in Presburger arithmetic, which provides the first main step towards our bound.
We then proceed to define the redundant product automata mentioned above, which serve to unify the types between T 1 and T 2 .In Observations 5.5 and 5.6 we formalize the connection of these products to the transducers T 1 and T 2 .Then, we formally define the type profiles and prove in Lemma 5.7 that they exhibit a semilinear behaviour.Finally, in Lemma 5.8 we prove that when two redundant product automata have the same type profile, then the containment mentioned above can be shown.Combining these results, we obtain Theorem 5.  Note that we use different automata to extract the type of words of different lengths.We obtain a more uniform description as follows.
Lemma 5.3.In the notations above, for every s 1 , s 2 ∈ S, we have Proof.By the definitions preceding the lemma, we have that O are such that P(α ′ ) = p and P(β ′ ) = o.According to the transition function of Perm k (N ) (as defined in section 4), for every s 1 , s 2 ∈ S we have that s 1 Since the type encodes the reachable pairs of states, this concludes the proof.
Presburger arithmetic.The first ingredient in the proof of Theorem 5.1 is to characterize the set of Parikh vectors whose type is some fixed matrix τ ∈ B Q×Q .For this characterization, we employ the first-order theory of the naturals with addition and order Th(N, 0, 1, +, <, =), commonly known as Presburger arithmetic (PA).We do not give a full exposition of PA but refer the reader to [Haa18] (and references therein) for a survey.In the following we briefly cite the results we need.
A fundamental result about PA is that the definable sets in PA are exactly the semilinear sets.In particular, Parikh's theorem states that for every NFA A, P(L(A)) is PA definable.In fact, by [VSS05], one can efficiently construct a linear-sized existential PA formula for P(L(A)).We can now show that the set of Parikh vectors whose type is τ is PA definable.
The redundant product construction.As mentioned in section 5.1, for the remainder of the proof we want to reason about the types of Perm k (Tr(T 1 ) ∩ Λ) and Perm k (Tr(T 2 )) simultaneously.In order to do so, we present an auxiliary product construction.
(2) For every letter (σ, Indeed, Item 1 follows directly from the acceptance condition, and Item 2 is due to the identical transition function of B 1 and B 2 . By Observation 4.1, L(Perm k (D i )) depends only on L(D i ).We thus have the following.
Observation 5.6.The following holds for every k > 0: (1) Type profiles.We now consider the set of types induced by the redundant product automata B 1 and B 2 on Parikh vectors of words of length k.By Item 2 of Observation 5.5, it is enough to consider B 1 .
For k > 0, we define the k-th type profile of B 1 to be the set of all types of Parikh vectors (p, o) with |p| = |o| = k that are induced by B 1 ; i.e. it is the set Υ Clearly, there is only a finite number of type profiles, as Υ(B 1 , k) ⊆ B S ′ ×S ′ , where S ′ is the state space of B 1 .Therefore, as k increases, after some finite K 0 , every type profile that is ever attained will have been encountered already.We now place an upper bound on K 0 .Lemma 5.7.We can effectively compute K 0 > 0 such that for every k > 0 there exists Proof.Consider a type τ , and let Ψ τ be the PA formula constructed as per Lemma 5.4 for the NFA B 1 .Observe that for a Parikh vector (p, o) and for k > 0, the expression |p| = |o| = k is PA definable.Indeed, writing p = (x 1 , . . ., x |Σ I | ) and q = (y 1 , . . ., y |Σ O | ), the expression is defined by x 1 + . . .
Let T ⊆ B S ′ ×S ′ be a set of types (i.e., a potential type profile).We define a PA formula Θ T (z) over a single free variable Intuitively, Θ T (z) states that every Parikh vector (p, o) with |p| = |o| = z has a type within T , and that all the types in T are attained by some such Parikh vector.
By [FR74,BT76], we can effectively determine for every T whether Θ T (z) is satisfiable and, if it is, find a witness M T such that M T |= Θ T (z).By doing so for every set T ⊆ B S ′ ×S ′ , we can set K 0 = max { M T | Θ T (z) is satisfiable }.Then, for every k > K 0 if Υ(B 1 , k) = T , then T has already been encountered at M T ≤ K 0 , as required.
The purpose of the bound K 0 obtained in Lemma 5.7 is to bound the minimal k for which T 1 ≺ k,Λ T 2 , or equivalently L(Perm k (B 1 )) ⊆ L(Perm k (B 2 )) (by Lemma 4.4 and Observation 5.6).This is captured in the following.
Proof.By the symmetry between k and k ′ , it suffices to prove w.l.o.g. that if Assume the former, and let w . By the definition of the type of a Parikh vector, we have that In particular, since the type of a word is the concatenation (i.e., Boolean matrix product) of its underlying letters, we have that where s 1 0 and s 1 f are an initial state and an accepting state of Perm k ′ (B 1 ), respectively.But the equality of types implies τ Perm k (B 1 ) (x, y) s 1 0 ,s 1 f = 1 as well, so Perm k (B 1 ) has an accepting run on (x, y).
By our assumption, L(Perm k (B 1 )) ⊆ L(Perm k (B 2 )), so (x, y) = φ(w) ∈ L(Perm k (B 2 )), or equivalently, φ(w) ∈ L(Perm k (B 2 )).We now essentially reverse the arguments above, but with B 2 instead of B 1 .However, this needs to be done carefully, so that the mapping of letters lands us back at (x ′ , y ′ ), and not a different word.Thus, instead of finding a round equivalent word, we observe that for every 1 ≤ j ≤ n, we also have This follows from Item 2 in Observation 5.5 and the fact that the permutation closure depends only on the transitions (and not on accepting states, which are the only difference between B 1 and B 2 ).Thus, similarly to the arguments above, we have that (x ′ , y ′ ) ∈ L(Perm k ′ (B 2 )), and the mapping applied is in fact the the inverse map φ −1 , where φ −1 (φ(w)) = w.We conclude that L(Perm The mapping is illustrated in fig. 5.

19:16
Combining Lemmas 5.7 and 5.8, we can effectively compute K 0 such that if it holds that L(Perm k (B 1 )) ⊆ L(Perm k (B 2 )) for some k, then this also holds for some k < K 0 .Finally, using Lemma 4.4, this concludes the proof of Theorem 5.1.
Remark 5.9 (Complexity results for Theorem 5.1 and Corollary 5.2).Let n be the number of states in T 1 × T 2 .Observe that the formula Ψ τ constructed in Lemma 5.4 comprises a conjunction of O(n 2 ) PA subformulas, where each subformula is either an existential PA formula of length O(n), or the negation of one.Then, the formula Θ T in Lemma 5.7 consists of a universal quantification, nesting a disjunction over |T | formulas of the form Ψ τ , conjuncted with |T | existential quantifications, nesting a single Ψ τ each.Overall, this amounts to a formula of length |T | ≤ 2 n 2 , with alternation depth 3. 3Using quantifier elimination [Coo72,Opp78], we can obtain a witness for the satisfiability of Θ T of size 4-exponential in n 2 .Then, finding the overall bound K 0 amounts to 2 2 n 2 calls to find such witnesses.Finally, we need K 0 oracle calls to Lemma 4.4 in order to decide existential simulation, and since K 0 may have a 4-exponential size description, this approach yields a whopping 5-EXP algorithm.This approach, however, does not exploit any of the structure of Θ T .5.3.Lower Bounds for Existential Round Simulation.The complexity bounds in Remark 5.9 are naively analyzed, and we leave it for future work to conduct a more in-depth analysis.In this section, we present lower bounds to delimit the complexity gap.Note that there are two relevant lower bounds: one on the complexity of deciding round simulation, and the other on the minimal value of K 0 in Theorem 5.1.
We start with the complexity lower bound, which applies already for round equivalence.
Theorem 5.10.The problem of deciding, given transducers T 1 , T 2 , whether T 1 ≡ k,Λ T 2 for any k, is PSPACE-hard, even for Λ of a constant size (given as a 5-state DFA).
Proof sketch.We present a similar reduction to that of Theorem 4.7 from universality of NFAs (see appendix A.2).In order to account for the unknown value of k, we allow padding words with a fresh symbol #, which is essentially ignored by the transducers.Next, we show that the minimal value for K 0 can be exponential in the size of the given transducers (in particular, of T 2 ).
Example 5.11 (Exponential round length).Let p 1 , p 2 , . . ., p m be the first m prime numbers.We define two transducers T 1 and T 2 over input and output alphabet P = {1, . . ., m}, as depicted in fig.6 for m = 3. Intuitively, T 1 reads input w ∈ Λ = (1 • 2 • • • m) * and simply outputs w, whereas T 2 works by reading a letter i ∈ P, and then outputting i for p i steps (while reading p i arbitrary letters) before getting ready to read a new letter i.
In order for T 2 to k-round simulate T 1 , it must be able to output a permutation of (1 In particular, the number of 1's, 2's, etc. must be equal, so k must divide every prime up to p m , hence it must be exponential in the size of T 2 .
The sum of the number of states in T 1 and which the run of T 2 induces the same output.We now show that this k is minimal.For a word x ∈ (1 • 2 • • • m) * in rounds of k to have round equivalent outputs in T 1 and T 2 , there must be some word round equivalent word x ′ in which every appearance of i ∈ P is part of a sequence of appearances of i, of length p i , except maybe at its end.If m | k, then there are k m appearances of each i, so k m must be divisible by all primes, except maybe one.The latter possibility is falsified when considering the next round.If, however, m ∤ k, then in the next round, 1 ∈ P will have one less appearance than in the first round.This, again, makes impossible the round equivalence of the outputs when considering one additional round.

From Process Symmetry to Round Equivalence
As mentioned in section 1, our original motivation for studying round simulation comes from process symmetry.We present process symmetry with an example before introducing the formal model.Recall the Round Robin scheduler from Example 3.3.There, at each time step, the scheduler receives as input the IDs of processes in P = {0, 1, 2} that are making a request, and it responds with the IDs of those that are granted (either a singleton {i} or ∅).
In process symmetry, we consider a setting where the identifiers of the processes may be permuted.This corresponds to the IDs representing, for instance, ports, and the processes not knowing which port they are plugged into.Thus, the input received may be a permutation of the actual identifiers of the processes.Note that a permutation in this case is a bijection over identifiers, not indices as in previous sections.Then, we say that a transducer is process symmetric if the outputs are permuted in a way that matches the permutation of identifiers.For example, in the RR scheduler of Example 3.3, the output corresponding to input {1, 2}{3}{3} is {1}∅{3}.However, if we permute the identifiers by swapping processes 1 and 3, we obtain the input {3, 2}{1}{1}.Then, the output of RR is ∅∅∅, demonstrating that RR is not process symmetric.Indeed, the output letters have to be permuted in the same manner as the input for RR to be process symmetric.
In [Alm20], several definitions of process symmetry are studied for probabilistic transducers.In the deterministic case, however, process symmetry is a very strict requirement.In order to overcome this, we allow some flexibility by letting the transducer do local reordering in the word to account for the input permutation.For instance, if we are allowed to rearrange sufficient to check symmetry for these two generators in order to obtain symmetry for every permutation.Note that for the existential variant of the problem, even if every permutation requires a different k, by taking the product of the different values we conclude that there is a uniform k for all permutations.We thus have the following.Theorem 6.5.Both fixed and existential round symmetry are decidable.Moreover, fixed round symmetry is in PSPACE.
Finally, the reader may notice that our definition of round symmetry w.r.t.π is not symmetric, as was the case with round simulation compared to round equivalence.However, when we consider round symmetry w.r.t. to all permutations, the definition becomes inherently symmetric, as a consequence of Lemma 6.4.Lemma 6.6.In the notations above, if Proof.Recall that for every permutation π we have π m! = id, where id is the identity permutation.In particular, π m!−1 = π −1 .
By Lemma 6.4, we now have that if Thus, for symmetry, the notions of round simulation and round equivalence coincide.

The Simulation Mapping
The definition of round simulation in section 3 has an existential flavour: given input x we consider the existence of a word x ′ that satisfies the requirement of round simulation.In some cases it may be desirable to compute an x ′ that "witnesses" the simulation of x.
For example, recall the monitor of Example 1.1 modelled by a transducer T 1 .Recall that we presented a simpler transducer T 2 that round-simulates T 1 .This allowed us then to verify e.g., the property "if there is no error, then Process 3 works at least once every 20 steps" against the much smaller T 2 .When a designer wishes to gain understanding as to why the verification on T 2 is sound, they may want to see how input sequences/output sequences for T 1 are translated to T 2 .In this example, the transformation is simple, and consists of ordering the process by their id.
Clearly one can compute x ′ from x by simply trying all permutations of x and finding a successful one.This, however, is expensive, and raises the question of whether we can output x ′ using a finite-state transducer.Unfortunately, we show in the following that computing x ′ cannot be done locally, in the sense that arbitrary lookahead is needed.
Consider two transducers T 1 and T 2 such that T 1 ≺ k T 2 , and an input word This means, by definition, that there is a way to permute the rounds in x to obtain a word x ′ such that T 2 (x ′ ) is a permutation of T 1 (x).A simulation mapping 4 between T 1 and T 2 is a function ψ T 1 ,T 2 : Σ * → Σ * such that for every x ∈ Σ kR we have that ) (we omit the subscripts when the transducers are clear from context).We start by showing that the simulation mapping is not a morphism, in the sense that it cannot act on each round separately. in every 2-round, outputting 00 in both cases, and otherwise outputs 01 in that round.T 2 expects the first round to be ab and the second to be ba, otherwise outputs 01 in the round not meeting expectations; and beginning from the third round, it behaves like T 1 .We have that T 1 ≺ 2 T 2 by a permutation that corrects the order of the letters in the first two rounds of the input.Moreover, we have ψ(ab) = ψ(ba) = ab whereas ψ(abba) = abba ̸ = ψ(ab) • ψ(ba).Next, we show that in fact the simulation mapping cannot be described by any fixed lookahead machine.We claim that for any r, there is no lookahead machine that defines a function ψ r : (Σ rk I ) * → (Σ rk I ) * such that ψ * (x) = ψ(x) for all input words x.Indeed, let r ∈ N, and assume by way of contradiction that such ψ r exists.Now consider the input word x = ab • c rk−2 .ψ r (x) must start with either ab or ba.Without loss of generality, assume the former, and consider the input word x ′ := x • ba • c rk−2 .Since ψ r works on r rounds each time, the first r rounds are fixed when it reads the (r + 1)-th round.Moreover, since ψ r (x ′ ) must induce a valid path in T 2 , the only option for the (r + 1)-th round of ψ r (x ′ ) is ab.Hence, the output of T 1 on x ′ is different from the output of T 2 on ψ(x ′ ), and we have a contradiction.Example 7.2 essentially shows that it is generally impossible to determine the output of the first round without knowing the entire input.In section 9 we discuss possible models that may be able to capture it, and are weaker than general Turing machines.In the remainder of the section, we give some examples separating some of the definitions, thus showing the order in fig.11 is strict.Similar examples can be constructed for separating the rest of the definitions.
Example 8.2 (Symbol-wise symmetry does not imply letter-wise symmetry).We warm up by showing that ⟨ℓ, ℓ, k⟩ is more strict than ⟨s, s, k⟩ (we will later reuse this example to establish finer strictness results).Set π = (0 1) and let k ∈ N and m ≥ 3. We construct a transducer that is symbol-wise k-round symmetric, but not letter-wise k ′ -round symmetric for any k ′ .
Consider the 2 P /2 P transducer T = 2 P , 2 P , S, s 0 , δ, ℓ depicted in fig.12, where Observe that every round starts at q 0 .There are three possible forms for the output of each round depending on the input, as summarized in table 3.
We first show that T is symbol-wise round symmetric.Let x be an input word.Similarly to section 6, π(x) is the word obtained from x by permuting every signal according to π.If x is of one of the first two forms in table 3, then by moving the signal 2 ∈ P (fixed in π) between the first and last letters, we get x ′ ≍ s π(x) such that T (x ′ ) ≍ s π(T (x)), as desired.Now assume x is of some other form, having the output ∅ k .If 2 ∈ P appears in both the first 19:24 Table 3: The inputs and their corresponding outputs in T of Example 8.2.

Input
Output and last letters, or it appears in neither, then set x ′ = π(x); otherwise, move the signal 2 to the other letter, and the output will remain ∅ k .Thus, T is symbol-wise round symmetric.
On the other hand, T is not letter-wise k ′ -round symmetric for any k ′ > 0. To see this, take the input which contains neither the letter {0} nor {1, 2}.Thus, regardless of how we permute π(x) to obtain x ′ , the output of any x ′ ≍ ℓ π(x) is always ∅ k ′ k , which is not a permutation of T (x).
Example 8.3 (Showing ⟨s, s, k⟩ ⪇ ⟨ℓ, s, k⟩).Let T be the transducer from Example 8.2, and consider the transducer T π obtained from T by permuting both the input and the output by π = (0 1) as in section 6.We have shown that T is symbol-wise round symmetric.By a reasoning analogous to the transition from symmetry to simulation as per section 6, this gives T ≺ s,s k T π .However, it does not hold that T ≺ ℓ,s k T π : for the input 3), any permutation x ′ ≍ ℓ k x will lead to an output of ∅ k ̸ ≍ s k y.Thus T ̸ ≺ ℓ,s k T π (and in particular, T ̸ ≺ ℓ,ℓ k T π so T is not letter-wise symmetric).In the general sense, we conclude that T 1 ≺ s,s k T 2 does not imply T 1 ≺ ℓ,s k T 2 .Example 8.4 (Showing ⟨s, s, k⟩ ⪇ ⟨s, ℓ, k⟩).Consider the transducer T in fig.13, whose round-by-round behaviour can once more be summarized in a table (see table 4).T is symbol-wise round symmetric: for an input x, choose x ′ = π(x).It is not difficult to show that T (x ′ ) ≍ s k π(T (x)) by considering the possible forms of x according to table 4. To see that T ⊀ s,ℓ k T π , consider the word x = {0}∅∅.The output of T on x is {0}∅{2}.Any round equivalent word x ′ of x either starts with {1} or ∅, the respective outputs being either {1, 2}∅∅ or ∅ 3 .In all cases, we have T Table 4: The inputs and their corresponding outputs in T of Example 8.4.In fact, these same transducers can be used to establish the remaining two dual gaps as well, as follows.The transducer T in Example 8.3 satisfies ⟨s, ℓ, k⟩-round simulation with its corresponding T π ; indeed, observe that the output labels are either singleton sets or empty sets, so that a signal permutation of the output is equivalent to permuting the letters.The transducer T in Example 8.4 satisfies ⟨ℓ, s, k⟩-round simulation with its corresponding T π , which is inferred from the choice of x ′ = π(x), satisfying in particular x ′ ≍ ℓ π(x).However, neither of the two satisfy ⟨ℓ, ℓ, k⟩-round simulation, since they are not symbol-wise round symmetric.This completes the proof of strictness of top diamond in fig.11.In appendix B we provide constructions to complete some of the remaining strictness results.
Finally, Example B.1 presents a pair of transducers T 1 and T 2 such that T 1 ≺ ℓ,s 2 T 2 and T 1 ≺ s,ℓ 2 T 2 , but T 1 ̸ ≺ ℓ,ℓ 2 T 2 .This proves that although ⟨ℓ, ℓ, k⟩-round simulation implies both ⟨s, ℓ, k⟩ and ⟨ℓ, s, k⟩-round simulation, the converse does not hold.8.2.Deciding Round Simulation.We briefly discuss the decidability of round simulation for the new notions.We start by considering ⟨s, s, k⟩-round simulation, where the following arguments also apply when replacing one of the s with ℓ.The main idea is to tweak the definitions of sections 4 and 5, and specifically the permutation-closure NFA, to look at permutations of the signals, not just the letters.To this end, we simply modify the notion of Parikh image over an alphabet 2 P to be with respect to P. That is, for x ∈ (2 P ) * , let P(x) ∈ N P be the vector counting the number of occurrences of each signal p ∈ P in the letters of x.
Under this definition, the analysis of sections 4 and 5 follows without any changes.Indeed, the crucial property that is needed for these arguments is that the permutation-closure NFA is indeed closed under permutation, which clearly holds also for the new definition.In particular, the proof of Lemma 4.4 hold, from which the rest of the analysis follows.Thus, adding s to the model retains the decidability and complexity of both fixed round simulation and existential round simulation.
In contrast, uniform round simulation is conceptually different: the constraint on the permutations of each round is now global for the word.That is, we need a single permutation to be used in all rounds.This means that the techniques of sections 4 and 5 no longer apply.Moreover, uniform round simulation is not invariant to (letter or signal) round permutations.Indeed, clearly there are words x ≍ ℓ k x ′ and y such that x ≍ u k y but x ′ ̸ ≍ u k y.For fixed round simulation, enforcing the global condition is not too difficult, as we now show.
Theorem 8.5.Given transducers T 1 , T 2 and k > 0 in unary, the problem of deciding whether k T 2 iff for every x there exist permutations π, τ such that π(x) = y (where π(x) is the word obtained by applying π to each k-round of x) and τ (T 1 (x)) = T 2 (y).
Let D k 1 and D k 2 be the trace DFAs of T 1 and T 2 as per section 4, where we modify them to read the alphabet Σ k I × Σ ) O (in this setting Σ I = Σ O = 2 P ).Next, for permutations π, τ as above, define A π,τ 1 to be the DFA obtained from D k 1 by, intuitively, applying π, τ to Σ 1 is given by µ(q, (α, β)) = δ(q, (π(α), τ (β))).We now obtain an NFA A by taking the union of A π,τ 1 over all permutations π, τ .It is easy to see that 1 , but can be construction on-the-fly, the latter containment can be decided in PSPACE.
Theorem 8.5 can be easily combined with the remaining notions to obtain the decidabilty of all nine definitions of fixed round simulation.
Remark 8.6.Unfortunately, the construction in the proof of Theorem 8.5 significantly modifies the state space of D k 1 .This is in contrast to the construction in Lemma 4.4, which only modifies the transition function.
In particular, it is not clear if the construction can be symbolically defined via e.g., Presburger Arithmetic (or some other decidable logic) in order to extend decidability to the existential-bound setting.We therefore leave the latter as an open problem.

Conclusion and Open Questions
In this work, we introduced round simulation and provided decision procedures and lower bounds (some with remaining gaps) for the related algorithmic problems.Our framework can be viewed as a notion of "approximate simulation", by which we can significantly reduce the state space for verification, at the cost of invariance to permutations.
Round simulation, and in particular its application to round symmetry, is only an instantiation of a more general framework of symmetry, by which we measure the stability of transducers under local changes to the input.In particular, there is place for additional notions of symmetry and simulation to be studied, and the existing ones extended.Some such variants were presented and discussed in section 8.1, but others, e.g., sliding-window symmetry, or the setting of infinite words may also be of interest in future works.
A few gaps have remained open in this work.Most notably are tightening the complexity gap of existential simulation Remark 5.9, and implementing the simulation mapping from section 7 using a simpler computational model than Turing machines.Some possible candidates for the latter are streaming-string transducers and bi-machines [MP19].q q 0,0 q 0,1 q 1,0 q 1,1 one of the letters, see below).We obtain T 2 from N by introducing 4 new states q a , q b , q c , q d for every state q ∈ Q, and setting the transitions and labels as depicted in fig.15.In case N does not have a transition on e.g., 0 from q, then instead of going to q a or q b , we proceed to a new state q ⊥ labelled ⊥, which is a sink state.In addition, q ⊥ is reached upon any transition not yet defined.Observe that for every x ∈ Λ we have T 2 (x) = ⊤ m ⊥ |x|−m for some 0 ≤ m ≤ |x| (since q ⊥ is a sink).We now claim that L(N ) = {0, 1} * iff T 1 ≡ 2,Λ T 2 .For the first direction, assume L(N ) = {0, 1} * .Observe that T 2 ≺ 2,Λ T 1 independently: for every x ∈ (ab + cd) * , denote T 2 (x) = ⊤ m ⊥ |x|−m , then we can construct x ′ ≍ 2 x such that T 1 (x ′ ) = ⊤ m ⊥ |x|−m by leaving x unchanged m steps, and then permuting the letters such that the run of T 1 moves to the sink labelled ⊥ (indeed, observe that m must be even by the construction of T 2 , and hence T 1 can permute e.g., ab to ba in order to start outputting ⊥ on an even step).
Next, we show that T 1 ≺ 2,Λ T 2 .Consider x ∈ (ab + cd) * , so that T 1 (x) = ⊤ |x| , and let w ∈ {0, 1} * be the word obtained from x by identifying ab with 0 and cd with 1.Since L(N ) = {0, 1} * , there exists a run (and hence an accepting run) of N on w, denoted s 0 , s 1 , . . ., s n .We now obtain x ′′ ≍ 2 x by identifying each letter 0 in x with either ab or ba, and each letter 1 with cd or dc, such that the run of T 2 on x ′′ simulates the run of N on w.Thus, T 2 (x ′′ ) = ⊤ |x ′′ | , and T 2 (x ′′ ) ≍ 2 T 1 (x), so we are done.
Conversely, if T 1 ≡ 2,Λ T 2 , then in particular T 1 ≺ 2,Λ T 2 .We claim that L(N ) = {0, 1} * .Consider w ∈ {0, 1} * .Dually to the above, we obtain from w a word x ∈ (ab + cd) * by identifying 0 with ab and 1 with cd, so that T 1 (x) = ⊤ |x| .Since T 1 ≺ 2,Λ T 2 , there exists x ′ ≍ 2 x such that T 2 (x ′ ) = ⊤ |x| .Observe that x ′ must be obtained from x by (possibly) changing each ab to ba and each cd to dc.In particular, the run of T 2 on x ′ induces a run of N on w by identifying both ab and ba as 0 and both cd and dc as 1.This gives w ∈ L(N ), so L(N ) = {0, 1} * , which concludes the proof.
A.2. Proof of Theorem 5.10.In order to show that existential round equivalence is PSPACE-hard, we build upon the reduction in the proof of Theorem 4.7: we again show a reduction from the universality problem for NFAs over alphabet {0, 1} where all states are accepting and the degree of nondeterminism is at most 2 (cf.Lemma A.1).
Intuitively, the idea is to use a similar encoding of {0, 1} in {a, b, c, d} whereby 0 corresponds to either ab or ba and 1 to cd or dc.Now, however, since k is not fixed to 2, we also allow arbitrary padding with sequences of ##.
Set Λ = (ab + cd + ##) * (given as a 5 state DFA).We construct T 1 and T 2 similarly to the proof of Theorem 4.7, by adding self-cycles of length 2 upon reading ##, from every state except the sink q ⊥ .See figs.16 and 17 for an illustration.q q 0,0 q 0,1 q 1,0 q 1,1 0 0 All transitions not drawn in the right figure lead to q ⊥ , a sink state labelled ⊥.
We claim that L(N ) = {0, 1} * iff there exists k > 0 such that T 1 ≡ k,Λ T 2 .For the first direction, assume L(N ) = {0, 1} * , then we can show that T 1 ≡ 2,Λ T 2 by following the proof of Theorem 4.7 line for line, with the addition that blocks of the form ## leave the state of both T 1 and T 2 unchanged.
For the converse direction, assume T 1 ≡ k,Λ T 2 , and in fact we only assume T 1 ≺ k,Λ T 2 for some k > 0. We further assume w.l.o.g. that k is even, otherwise we can just take 2k (since we also have T 1 ≺ 2k,Λ T 2 ).
Since T 1 ≺ k,Λ T 2 , there exists x ′ ≍ k x such that T 2 (x ′ ) = ⊤ |x| .Observe that x ′ must be obtained from x by (possibly) changing each ab to ba and each cd to dc, and by shifting the location of this pair within the # symbols.Indeed, otherwise the run of T 2 on x ′ ends in q ⊥ .In particular, the run of T 2 on x ′ induces a run of N on w by identifying both ab
and the transition function µ is defined as follows.For a letter (α, β) ∈ Σ k I × Σ k O and a state s ∈ S, we think of (α, β) as a word in (Σ I × Σ O ) * .Then we have 1.A flow diagram for the proof is illustrated in fig.4

Figure 4 :
Figure 4: A flow diagram for the proof steps in section 5.2.

Figure 5 :
Figure 5: A diagram for the proof structure of Lemma 5.8.

Figure 6 :
Figure 6: The transducers T 1 (left) and T 2 (right) for m = 3 in Example 5.11.The transition s ε −→ t in T 2 means that the transition function from state s behaves identically as from t.
Example 7.1.Consider the transducers T 1 and T 2 depicted in fig.9, with input and output alphabets Σ I = {a, b} and Σ O = {0, 1} and round length 2. T 1 expects to see either ab or ba Vol.19:4 SIMULATION BY ROUNDS OF LETTER-TO-LETTER TRANSDUCERS 19:21

Figure 9 :
Figure 9: The transducers T 1 (left) and T 2 (right) in Example 7.1.The states of T 2 in red, green and blue manage the first, second and later rounds, respectively.

Figure 11 :
Figure 11: A Hasse diagram for the partial order on the strictness of the definitions, where α → β means α implies β.

Figure 13 :
Figure 13: The transducer T for Example 8.4.The transitions i ∈ σ and i /∈ σ mean all letters from Σ I that, respectively, contain or do not contain i.

Figure 14 :
Figure 14: The transducer T 1 in the proof of Theorem 4.7.

Figure 15 :
Figure 15: Every state and its 4 transitions in N (left) turn into 8 transitions in T 2 (right).All transitions not drawn in the right figure lead to q ⊥ , a sink state labelled ⊥.

Figure 16 :
Figure 16: The transducer T 1 in the proof of Theorem 5.10.

Figure 17 :
Figure 17: Every state and its 4 transitions in N (left) turn into 10 transitions in T 2 (right).All transitions not drawn in the right figure lead to q ⊥ , a sink state labelled ⊥.

Table 1 :
x and y are 3-round equivalent