Finite-Visit Nondeterministic Turing Machine

• The fvNTM is a one-way nondeterministic Turing machine with a fixed per-cell visit bound, balancing nonregular language acceptance with regular store behaviors.
• It distinguishes itself from finite-turn models by allowing bounded revisitation on the worktape, leading to richer language classes.
• Its regular store language property and verification consequences make it amenable to algorithmic analysis and complexity studies.

Searching arXiv for the cited paper and closely related work on finite-visit and limited automata. arXiv search query: all:"finite-visit Turing machine" OR all:fvNTM OR id:([2509.02828](/papers/2509.02828)) A one-way nondeterministic finite-visit Turing machine ($\fvNTM$) is a one-way nondeterministic Turing machine with a one-way read-only input tape and a single worktape, where there exists some integer $k$ such that in every accepting computation each worktape cell is visited at most $k$ times (Friesen et al., 2 Sep 2025). The model was isolated in the study of store languages, where it is placed between finite-turn and finite-crossing one-way machines: $L(\ftNTM) \subsetneq L(\fvNTM) = L(\fcNTM)$, while the store language of every $\fvNTM$ is regular (Friesen et al., 2 Sep 2025). This combination makes the model notable: accepted languages may be substantially more complex than regular, but the store behavior along accepting computations remains finite-state describable.

1. Formal definition and acceptance discipline

The underlying machine in the cited formulation is a one-way nondeterministic Turing machine with a one-way read-only input tape and a single worktape (Friesen et al., 2 Sep 2025). In the more general presentation, the machine may also carry reversal-bounded counters, but an ordinary one-way nondeterministic Turing machine is obtained by taking the counter parameter $t=0$. A configuration of the counter-free machine has the form

$(q,w,x \triangleright y),$

where $q$ is the current state, $w$ is the remaining input, and $x \triangleright y$ denotes the worktape contents together with the head position. Acceptance is by the existence of a computation

$k$0

for some $k$1 (Friesen et al., 2 Sep 2025).

The finite-visit condition is expressed through the address function $k$2, defined along an accepting computation

$k$3

The initial address is $k$4; a right move increments the address by $k$5, a left move decrements it by $k$6, and a stay move leaves it unchanged (Friesen et al., 2 Sep 2025). A computation is $k$7-visit if, for every integer $k$8,

$k$9

Thus a machine is $k$0-visit if every accepting computation satisfies that bound, and it is finite-visit if it is $k$1-visit for some $k$2 (Friesen et al., 2 Sep 2025).

The same framework distinguishes finite-turn and finite-crossing restrictions. Every finite-turn machine is finite-visit, and every finite-visit machine is finite-crossing, but finite-visit is strictly more general than finite-turn (Friesen et al., 2 Sep 2025). This hierarchy matters because the worktape head may still oscillate in nontrivial ways under a visit bound; the model is not merely a single left-to-right pass over a worktape.

A common misconception is that “one-way” should force regular-language behavior. In this setting, “one-way” refers to the input tape only. The worktape remains fully dynamic subject to the finite-visit restriction, and that is sufficient to place $k$3 strictly above $k$4 in language-theoretic power (Friesen et al., 2 Sep 2025).

2. Language-theoretic position

The accepted-language family of $k$5 satisfies

$k$6

(Friesen et al., 2 Sep 2025). The same source states that $k$7 coincides with the languages generated by absolutely parallel grammars and, by results of Greibach and Latteux, with all finite-index variants of several grammar systems, including ET0L, EDT0L, and matrix grammars (Friesen et al., 2 Sep 2025).

The standard examples show that finite-visit machines can accept nonregular languages. One machine accepts

$k$8

using a worktape strategy that is $k$9-turn, $L(\ftNTM) \subsetneq L(\fvNTM) = L(\fcNTM)$0-visit, and $L(\ftNTM) \subsetneq L(\fvNTM) = L(\fcNTM)$1-crossing (Friesen et al., 2 Sep 2025). Another accepts

$L(\ftNTM) \subsetneq L(\fvNTM) = L(\fcNTM)$2

and is not finite-turn, but is $L(\ftNTM) \subsetneq L(\fvNTM) = L(\fcNTM)$3-visit and $L(\ftNTM) \subsetneq L(\fvNTM) = L(\fcNTM)$4-crossing (Friesen et al., 2 Sep 2025). These examples establish that bounded visit complexity is compatible with nonregular acceptance and with head-motion patterns not reducible to a fixed number of turns.

This places $L(\ftNTM) \subsetneq L(\fvNTM) = L(\fcNTM)$5 in a characteristic intermediate zone. It is stronger than finite-turn worktape models, yet still sufficiently structured that several store-language and verification properties collapse to regular or reversal-bounded-counter descriptions. A plausible implication is that the combinatorics of bounded local revisitation constrain successful computations more strongly than the accepted-language family alone would suggest.

3. Store languages

For a machine with worktape and, in the general case, counters, a store configuration records the internal state and all store contents, but not the input (Friesen et al., 2 Sep 2025). In the pure worktape case, store configurations are words of the form $L(\ftNTM) \subsetneq L(\fvNTM) = L(\fcNTM)$6. The store language $L(\ftNTM) \subsetneq L(\fvNTM) = L(\fcNTM)$7 collects exactly those store configurations that appear as intermediate steps in some accepting computation: $L(\ftNTM) \subsetneq L(\fvNTM) = L(\fcNTM)$8 (Friesen et al., 2 Sep 2025).

The central theorem is that

$L(\ftNTM) \subsetneq L(\fvNTM) = L(\fcNTM)$9

and in fact the proof is obtained through the stronger finite-crossing statement (Friesen et al., 2 Sep 2025). Hence every one-way nondeterministic finite-visit Turing machine has a regular store language.

The proof proceeds by encoding accepting computations into words over an alphabet of “columns” with finitely many tracks. For an $\fvNTM$0-crossing machine, the construction uses $\fvNTM$1 auxiliary tracks per column, where track $\fvNTM$2 stores a candidate intermediate tape content together with a unique marked symbol indicating the head position, and tracks $\fvNTM$3 encode a linked history of writes and head motions for each worktape cell (Friesen et al., 2 Sep 2025). A two-way nondeterministic finite automaton verifies that the column word is a correct encoding of an accepting computation and that track $\fvNTM$4 matches a genuine intermediate store configuration. A generalized sequential machine then projects that encoding to the actual store word. Since 2NFAs recognize exactly the regular languages and regular languages are closed under gsm mappings, the resulting store language is regular (Friesen et al., 2 Sep 2025).

The theorem is sharpened by the state-slice characterization

$\fvNTM$5

where $\fvNTM$6 denotes the slice of store configurations occurring in a fixed state $\fvNTM$7 (Friesen et al., 2 Sep 2025). Thus regular languages are not only an upper bound on store languages; they are exactly the store-language slices realizable by these machine classes.

The significance is conceptual as well as technical. The accepted language may be far from regular, but the store language abstracts only successful store behavior, and that abstraction remains finite-state. This separates language complexity from store-complexity quite sharply.

4. Reversal-bounded counters and verification consequences

The finite-visit model is extended in the same source to one-way nondeterministic Turing machines with a worktape and reversal-bounded counters, denoted $\fvNTM$8 (Friesen et al., 2 Sep 2025). A counter is reversal-bounded if there is a fixed bound on the number of switches between nondecreasing and nonincreasing phases along accepting computations. When there is no worktape, the corresponding model is the classical $\fvNTM$9, a nondeterministic reversal-bounded multicounter machine (Friesen et al., 2 Sep 2025).

For finite-visit and finite-crossing machines with reversal-bounded counters, the store-language theorem becomes

$t=0$0

(Friesen et al., 2 Sep 2025). The proof adapts the column-based encoding used for pure worktapes, but replaces the verifying 2NFA by a two-way $t=0$1 that simulates the counters of the original machine, copies their values at the chosen intermediate point, and checks consistency with the counter exponents recorded in track $t=0$2 (Friesen et al., 2 Sep 2025). A known reduction for finite-crossing two-way reversal-bounded counter machines then yields an equivalent one-way $t=0$3, and closure of $t=0$4 under gsm mappings completes the argument (Friesen et al., 2 Sep 2025).

The corresponding state-slice characterization is

$t=0$5

(Friesen et al., 2 Sep 2025). Thus, once reversal-bounded counters are added, $t=0$6 becomes the exact store-language target at the slice level.

These results feed directly into verification-style applications. For deterministic finite-visit and finite-crossing Turing machines, the accepted-language families $t=0$7 and $t=0$8 are closed under right quotient with regular languages (Friesen et al., 2 Sep 2025). For $t=0$9 and $(q,w,x \triangleright y),$0, if $(q,w,x \triangleright y),$1 is a regular set of store configurations, then the reachability operators $(q,w,x \triangleright y),$2 and $(q,w,x \triangleright y),$3 are regular, and NFAs can be effectively constructed for them; for $(q,w,x \triangleright y),$4 and $(q,w,x \triangleright y),$5, the analogous sets are $(q,w,x \triangleright y),$6-accepted when $(q,w,x \triangleright y),$7 is $(q,w,x \triangleright y),$8-accepted (Friesen et al., 2 Sep 2025). The common configurations problem is decidable for $(q,w,x \triangleright y),$9, $q$0, $q$1, and $q$2 (Friesen et al., 2 Sep 2025).

A plausible implication is that finite-visit worktape restrictions make these machines unexpectedly amenable to algorithmic analysis, not because their accepted languages are simple, but because their successful storage traces are.

5. Relation to iterated sweeps and limited-rewrite automata

A useful comparison comes from nondeterministic iterated uniform finite-state transducers (NIUFSTs), which are one-way, many-pass, length-preserving transducers that repeatedly sweep left-to-right over a tape, always restarting from the leftmost cell at the beginning of a new sweep (Kutrib et al., 2022). In the terminology reconstructed for that model, a sweep-complexity bound $q$3 limits the number of full left-to-right scans, and constant-sweep NIUFSTs accept exactly the regular languages; by contrast, unrestricted-sweep NIUFSTs characterize the context-sensitive languages, and there is a proper infinite hierarchy indexed by sublinear and polynomial sweep bounds (Kutrib et al., 2022).

Under the restricted interpretation given in the reconstruction, a one-tape nondeterministic TM whose head only moves right within each pass and whose cells are visited only through a bounded number of full left-to-right scans behaves like a “one-way, many-pass Mealy machine,” and bounded sweeps correspond naturally to bounded visits (Kutrib et al., 2022). This suggests a useful contrast with $q$4: in the store-language setting the visit bound is a uniform constant over accepting computations, whereas in the NIUFST analysis the sweep bound may be a function of input length, ranging from constant to logarithmic or linear regimes.

A second comparison comes from 1-limited automata and their restricted forms. Forgetting 1-limited automata are single-tape Turing machines that, when visiting a cell for the first time, replace the input symbol by a fixed symbol $q$5; they still characterize the regular languages (Pighizzini et al., 2023). Once-marking and always-marking 1-limited automata are further restrictions of the general 1-limited model, and they also recognize exactly the regular languages, while exhibiting distinct descriptional-complexity gaps relative to one-way and two-way finite automata (Pighizzini et al., 2023). These models differ from $q$6 in two decisive ways: they are fundamentally two-way on the tape, and their primary restriction is on rewriting rather than on visits.

The comparison is clarifying. Finite-visit bounds control how often a cell may be revisited; 1-limited and marking restrictions control what information may be written when a cell is first encountered. The former still supports nonregular acceptance in the one-way-input/worktape setting (Friesen et al., 2 Sep 2025), whereas the latter collapses language power to $q$7 even with two-way head movement (Pighizzini et al., 2023, Pighizzini et al., 2023). This suggests that bounded revisitation and bounded rewritability are orthogonal resource restrictions rather than interchangeable ones.

6. Strong versus weak bounds, limitations, and open directions

The regularity theorem for store languages depends on the strong form of the finite-visit or finite-crossing condition: there must exist a fixed bound such that every accepting computation satisfies it (Friesen et al., 2 Sep 2025). The same source distinguishes this from the weak form, where for each accepted word there merely exists some accepting computation meeting the bound. Although strong and weak finite-crossing define the same class of accepted languages, their store languages behave very differently (Friesen et al., 2 Sep 2025).

For weak finite-crossing NTMs, store languages can be as complex as all recursively enumerable languages, and there are non-recursive store languages even for weakly $q$8-crossing NTMs (Friesen et al., 2 Sep 2025). This is the main cautionary point in the theory: boundedness along some successful branch is not enough to control intermediate-store complexity; the bound must hold for all accepting computations.

A further limitation is that constant-bounded visitation is special. The same source gives an example in which the number of turns, crossings, and visits grows as $q$9, yet the store language is non-regular and non-semilinear (Friesen et al., 2 Sep 2025). Thus the regularity of store languages is not preserved under arbitrary input-dependent growth bounds.

Open questions highlighted in the literature include whether there is a larger class of Turing machines beyond finite-visit and finite-crossing that still has regular store languages; whether there exists an unbounded function $w$0 such that every $w$1-turn-bounded machine is effectively constant-turn-bounded; and whether decision problems known for finite-turn machines extend to finite-crossing and finite-visit machines, including the problem of deciding whether the set of subwords of $w$2 is $w$3 and whether a finite-crossing Turing machine accepts a bounded language (Friesen et al., 2 Sep 2025).

The broad lesson is that the $w$4 sits at a delicate boundary. With a strong constant bound on per-cell visits, the model supports nonregular acceptance together with regular store semantics. If that bound is weakened existentially or allowed to grow with input length, the store-language behavior can become non-regular, non-semilinear, or non-recursive (Friesen et al., 2 Sep 2025).