Ci sono automi non finiti?


Nella teoria degli automi leggiamo tutti gli automi come automi finiti, fin dall'inizio. Quello che voglio sapere è, perché gli automi sono finiti? Per essere chiari, cosa c'è in un automa finito - l'alfabeto, la lingua, le stringhe fatte con espressioni regolari o cosa? E ci sono (in teoria) degli automi non finiti?

Certamente non la lingua o le "stringhe create con espressioni regolari"; molte espressioni regolari semplici corrispondono a un numero infinito di stringhe (ma possono essere riconosciute da un automa finito).

Ho fatto una domanda avendo in mente una domanda:…
Words Like Jared



Tutti i modelli di automi che incontrerai in genere sono rappresentati in modo preciso; altrimenti ce ne sarebbero innumerevoli, il che significa che non vengono catturati dai modelli completi di Turing. Oppure, in CS-think, sarebbero inutili¹.

Gli "automi finiti" sono chiamati finiti perché hanno solo un set finito di configurazioni (a parte la stringa di input). Gli automi pushdown, ad esempio, hanno uno stack che può avere un contenuto arbitrario - ci sono infinite configurazioni possibili.

Nota bene: le configurazioni dei PDA sono ancora rappresentate in modo preciso! In effetti, qualsiasi modello computazionale che rientra nella computabilità di Turing deve avere configurazioni finemente rappresentabili, altrimenti le TM non sarebbero in grado di simularle.

  1. Ignoro consapevolmente l'ipercomputazione qui ai fini di questa domanda.

Comments are not for extended discussion; this conversation has been moved to chat.


The full name is "finite state automata". The crucial part is that the state of the automaton can be fully characterized by an element of some finite set of discrete states. This means that if the (relevant) state of the automaton involves a real-valued variable, there is an infinite number of potential states (putting aside the finiteness of floating point representations), and the automaton is not finite.

This might not ever happen in theoretical computer science, but it's not too exotic in the domain of modeling real number sequences. Hidden Markov Models can be used to model a number sequence as the output of a probabilistic system consisting of one output filter for each state of a (discrete, finite) Markov model with unobservable states. The filters compute the next real-valued output from a vector of the previous outputs ("autoregressive" model), but the underlying Markov model is finite since its transition probabilities only depend on the current Markov state.

However, this article (full text) develops a variation where the transition probabilities also depend on the real-number vector of prior outputs. The state of this system is the combination of a discrete Markov state and a tuple of real numbers ("mixed state Markov model"), hence it can be in an infinite number of different states.

In short, non-finite automata are theoretically well-defined, and occasionally even encountered.

Full disclosure: I am one of the authors of the paper mentioned. I'm not sure if that's considered proper disclosure or irrelevant self-promotion...

I think it's perfectly okay to reference own work where appropriate -- if you're one of the leading experts on a topic, we're glad to have you! -- and a plain disclosure as yours is quite enough. Thanks!

Finite-state automata don't include pushdown automata, right? Is there a particular reason all the way to real-number states? I'm not sure if I'm missing something here about why this obvious example wouldn't work or if you merely just happened to pick an unusual example instead.

I think he's trying to ask why you didn't use a more conventional non-FSA like a pushdown automaton instead of jumping to something like real-valued state variables.
user2357112 supports Monica

Well, mainly because that's the example I thought of! But also the "state" of a mixed-state Markov model consists of a fixed number of parameters, but there is still an infinite number of states (defined as current position + transition probabilities) because some of the parameters are real numbers (but affect the transitions, not just the output). In the PDA case, the non-finiteness comes from the unlimited size of the stack; but there are still only a finite number of rules, which are of finite length, so at ony one step there is only a finite number of possible bebaviors.


In a finite automaton, there is quite a bit of finiteness: the number of states, the size of the underlying alphabet, and the lengths of the strings accepted by the machine.

You can certainly relax the finiteness condition on these by allowing, say, the machine to have infinitely many states but if you do, the resulting machine becomes uninteresting, in the sense that such machines can be designed to accept any languages at all.

And what if it's only the alphabet that is infinite? what if we are working with a regular expression on Natural numbers for example? is that possible?

If the automaton is finite but the alphabet is infinite, then the automaton will have a finite number of transitions out of each state. Any character not associated with one of the transitions will not be recognized by the automaton. As a result, you could replace the infinite alphabet with a finite alphabet containing only the characters appearing in the automaton's transitions, and the automaton would still accept exactly the same language.
Kevin - Reinstate Monica

@parvin Not really. You'd need have an infinite number of transitions between your (finite number of) states then - which you still cannot represent. If you go for predicates (like "all even inputs go from A to B, all odd inputs go from A to C"), you basically break your alphabet down into a finite number of equivalence classes.

@Kevin, that depends on how you define "finite number of transitions". Consider an ordinary (finite) FSA, with the next state chosen according to any finite partition of the natural numbers: e.g., by the remainder of division by 7. Or consider a similar situation involving real numbers. The state diagram is fully finite, but it is well-defined over an infinite alphabet.

@Parvin I'd say the answer is "yes" (see my previous comment).


In fact, in automata theory (which departs a lots from the origins of Kleene, Rabin and Scott), there are many forms of automata that are not finite. This arises for several reasons.

Pushdown automata, for instance, are automata that have an infinite set of configurations (these have a finite number of states, but the reality is that these should be thought as 'infinite automata').

In the same vein, there ar other examples of infinite automata for which the state space is infinite, but with a lot of structure. For instance one considers the class of automata that have as state space a (finite dimension) vector space, and as transition functions linear maps (plus some initial an final things). These are known as weighted automata over a base field (due to Schützenberger in 61). These can be minimized and tested for equality. Other examples include register automata (these automata have a finite set of registers, and work over an infinite alphabet: these can compare letters with registers and store letters in registers), and the more modern form of nominal automata (that have the same expressiveness, but have better foundations and properties). Emptiness of such automata is decidable.

But, even for studying finite state automata, it makes sense to talk about infinite automata. Indeed, consider the category of finite state deterministic automata that accept a fixed given language L, equipped with the standard notion of automata morphism, then this category fails to have an initial and a final object. However, if you live in the category of all deterministic (say countable) automata, then there is an initial object (the automaton that has as states A, as initial state the empty word, when it reads letter a in state u it goes to state ua, and a state is accepting if it belongs to L). There is also a final object (that has as states languages!). The existence of these two objects are one way to explain at high level why deterministic automata can be minimised and is tightly linked to the Myhill-Nerode congruence.

To conclude, there are infinite automata, but the models that are first studied in a lecture are always the finite state ones.


I think the question is assuming the conclusion that there are no infinite state automata when there are, they just aren't worth bringing up.

In Automata Theory, there is a hierarchy of powers of different virtual models. The one I learned had 4 (that I remember, it has been some time), the one I found on Wikipedia has 5. The weakest in either finite state automata, and the strongest is Turing machines. There is a some concept of a level more powerful than Turing machines that is loosely called hypercomputation. Many different descriptions of virtual machines fall into one of these levels. Turing machines are especially known for numerous models all having the same level of computational power.

An infinite state automata, at least one formally defined, will fall into one of these levels. There may something a little interesting in showing how a certain rigorous definition of an infinite state automata fits into one of these levels, but other than that, it wouldn't be of much use given there are far more well studied virtual machines representing each level. It's similar to how there isn't much interest in a billion tape Turing machine, since it would be no more powerful than a single tape Turing machine but more complicated to deal with.

Now, if you happened to find an infinite state automata that wasn't equivalent to an existing level of the hierarchy, that might be interesting. But without that, infinite state automatas are already captured within the existing hierarchy, and given the added complications of dealing with infinity, we just avoid them in the same way we avoid any overly complicated Turing machine model.


The (naive) infinite version of deterministic finite state machine is too powerful. Such a thing would be capable of "memorizing" any language at all, so there is not much to be learned from considering them.

For example, over a binary alphabet, consider an automaton in the form of a complete binary tree of infinite height. Every possible string you could consider as input corresponds uniquely to a node of the tree, so you can construct a decider for any language at all simply by making the corresponding nodes accepting states.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.