Nondeterministic Fuzzy Finite Automata

Updated 14 December 2025

Nondeterministic Fuzzy Finite Automata are computational models extending classic NFAs by integrating fuzzy transitions and graded acceptances based on residuated lattices.
Advanced algorithms for determinization and state reduction efficiently merge fuzzy states through quasi-orders, optimizing automata for pattern recognition and formal verification.
These automata support multi-path computations and soft minimization via bisimulation techniques, providing robust tools for modeling uncertain systems.

A nondeterministic fuzzy finite automaton (FfA) generalizes the nondeterministic finite automaton by allowing transition and state acceptances to take values in complete residuated lattices or related algebraic structures, modeling graded, multi-path computation and uncertainty. FfAs support nondeterministic transitions with fuzzy degrees and define a fuzzy language as a mapping from words to degrees in a lattice or monoid. The field has developed a range of concepts, from foundational definitions to determinization algorithms, state minimization, and applications in pattern recognition and formal verification.

1. Formal Structure and Semantics

A nondeterministic fuzzy finite automaton is defined over a complete residuated lattice $\mathcal{L} = (L, \le, \otimes, \rightarrow, 0, 1)$ or, by extension, a lattice-ordered monoid or commutative semiring. The FfA structure is $(Q, \Sigma, \delta, I, F)$ where:

$Q$ : Finite nonempty set of states.
$\Sigma$ : Finite input alphabet.
$\delta: Q \times \Sigma \times Q \to L$ : Fuzzy transition function; each transition from $p$ to $q$ under $a$ has membership degree $\delta(p,a,q)$ .
$I: Q \to L$ : Initial state degrees.
$F: Q \to L$ : Final state degrees.

Transition extension to words $u = a_1 \dots a_n \in \Sigma^*$ is defined recursively:

$\delta_\epsilon := \mathrm{Id}_Q$
$\delta_{ua} := \delta_u \otimes \delta_a$ , with $(R \otimes S)(p, r) = \bigvee_{q \in Q} (R(p, q) \otimes S(q, r))$ .

The fuzzy language recognized by $\mathcal{A}$ is $L(\mathcal{A}): \Sigma^* \to L$ given by

$L(\mathcal{A})(u) = \bigvee_{p, q \in Q} (I(p) \otimes \delta_u(p, q) \otimes F(q))$

Equivalent presentations allow encoding transition or state information as sets of fuzzy subsets or, in the case of nondeterminism, as sets of fuzzy distributions associated to each input symbol and source state (Cao et al., 2010, Jančić et al., 2014).

2. Nondeterminism and Expressive Power

In FfAs, transitions are not only graded by degrees but can also be fundamentally nondeterministic: for a fixed source state and input, multiple successor states may be reachable with positive degree. FfAs with $\varepsilon$ -moves allow transitions on the empty word, with $\varepsilon$ -closure constructed via iterative meet-join operations on the lattice of fuzzy state vectors.

Despite nondeterminism and the ability to use intermediate fuzzy values, all three models—deterministic fuzzy automata, nondeterministic fuzzy automata, and nondeterministic fuzzy automata with $\varepsilon$ -moves—recognize the same class of fuzzy languages, i.e., regular fuzzy languages under sup–inf (max–min) semantics (Cao et al., 2010).

Closure properties are inherited from the underlying algebraic structure:

Union: $(L_1 \vee L_2)(w) = \max\{L_1(w), L_2(w)\}$
Intersection: $(L_1 \wedge L_2)(w) = \min\{L_1(w), L_2(w)\}$
Concatenation and Kleene star are defined using lattice meets and joins over all factorizations and unrollings.

3. Determinization and State Reduction Algorithms

The determinization of FfAs generalizes the subset construction from the Boolean case, but instead of crisp subsets, one considers fuzzy subsets of states. For lattices with infinite chains, naive subset constructions may yield infinitely many distinct fuzzy subsets.

To address this, modern approaches combine determinization with state reduction. The determinization-plus-reduction scheme constructs a crisp-deterministic fuzzy automaton (cdfa) whose states are aftersets formed relative to a reflexive fuzzy quasi-order $\varphi$ on states. These quasi-orders are right-invariant or weakly right-invariant, and Algorithm 4.1 (summarized below) applies them to collapse “similar” states during determinization (Jančić et al., 2014):

Algorithm Outline:

Initialize with the fuzzy afterset $\varphi_\varepsilon = I \otimes \varphi$ .
For each unprocessed afterset $\varphi_u$ , and each input $a$ , compute $\varphi_{ua} = \varphi_u \otimes \delta_a \otimes \varphi$ and add to the state set if new.
Set transitions and final weights accordingly.

This approach matches the worst-case $O(m n k^n)$ complexity of classical subset-based determinization ( $n = |Q|$ , $m = |\Sigma|$ , $k =$ number of lattice elements in use), but often produces automata with significantly fewer states through simultaneous reduction.

Further compaction is achieved via the "children automaton", which merges aftersets sharing the same structure of successors and terminal values. This approach can halve the number of reachable states in practice.

4. Exact and Approximate Minimization

Classical minimization of FfAs is challenging, especially over non-locally finite lattices (e.g., product, Hamacher t-norms on $[0,1]$ ) where the set of trace degrees is infinite. This blocks reduction methods that rely on finite degree sets.

Soft state reduction (Nguyen et al., 7 Dec 2025) introduces a threshold $\varepsilon$ (and optionally a word-length bound $k$ ) to approximate the automaton, merging states that are indistinguishable beyond $\varepsilon$ . This involves truncating all transition degrees below $\varepsilon$ and constructing right $\varepsilon$ -invariants—fuzzy relations that collapse states differing by at most $\varepsilon$ on all post-languages. Applying these invariances yields an FfA that preserves language values up to $\varepsilon$ in the supremum norm, with significant empirical reductions in state count.

Algorithmically, this reduction proceeds via:

Enumerating reachable state profiles up to $\varepsilon$ and $k$ ,
Computing the greatest right $(\varepsilon, k)$ -invariance,
Forming the quotient automaton by identifying nearly equivalent states,
Optionally performing a reverse-and-reduce iteration for further compaction.

FfAs can be treated as specialized nondeterministic fuzzy transition systems (NFTSs) with designated initial and final states. Language equivalence, minimization, and state merging are formalized via crisp and fuzzy bisimulation relations (Nguyen, 2024). Crisp bisimulation partitions and fuzzy partitions under Gödel semantics can be computed efficiently:

New algorithms yield time complexity $O((\mathrm{size}(\delta)\log l + |S|)\log(|S|+|\delta|))$ for both, reducing the state-space via Paige–Tarjan-like partition refinement on a fuzzy-labeled graph representation.
These methods drastically improve on previous $O(|S|^4 |\delta|^2)$ bounds and are practical for automata with thousands of states.

Bisimulation collapses distinguishable states into equivalence classes that preserve the recognized fuzzy language, providing a tool both for equivalence-checking and for efficient minimization.

6. Synthesis from Fuzzy Regular Expressions

FfAs admit systematic construction from fuzzy regular expressions via several automaton models:

Glushkov-McNaughton-Yamada's position automaton, Antimirov's partial derivative automaton, Ilie-Yu's follow automaton, and Brzozowski's derivative automaton can be extended to the fuzzy setting.
Construction proceeds by embedding scalar multipliers from the regular expression as fresh symbols in the extended alphabet, converting the fuzzy regular expression to an ordinary regular expression over the extended alphabet. Standard NFA construction methods then yield a base crisp NFA, which is lifted to an FfA by mapping transitions and final states according to the original fuzzy scalars (Stamenković et al., 2011, Kumar et al., 2014).

The follow-automaton method, in particular, produces automata with at most $n+1$ states (for $n$ symbol-positions in the expression), often outperforming position and Thompson constructions in state count and efficiency (Kumar et al., 2014).

7. Applications and Generalizations

FfAs are crucial in applications requiring modeling of graded or uncertain behavior:

Fuzzy pattern recognition, model checking of fuzzy-valued systems, and weighted language analysis benefit from the deterministic and minimized automata yielded by modern state reduction techniques (Jančić et al., 2014).
All determinization and minimization constructions generalize to lattice-ordered monoids and commutative semirings, thus connecting FfAs to the broader theory of weighted automata.

Recent results extend to typical hesitant fuzzy automata, where transitions and acceptances are given by finite nonempty sets of values (hesitant fuzzy elements), and to more general frameworks admitting soft reduction, bisimulation, and efficient synthesis algorithms (Costa et al., 2021, Nguyen et al., 7 Dec 2025, Nguyen, 2024).

References:

(Jančić et al., 2014) "Further improvements of determinization methods for fuzzy finite automata"
(Cao et al., 2010) "Nondeterministic fuzzy automata"
(Stamenković et al., 2011) "Construction of fuzzy automata from fuzzy regular expressions"
(Jančić et al., 2013) "Brzozowski type determinization for fuzzy automata"
(Kumar et al., 2014) "Metamorphosis of Fuzzy Regular Expressions to Fuzzy Automata using the Follow Automata"
(Nguyen et al., 7 Dec 2025) "Soft state reduction of fuzzy automata over residuated lattices"
(Nguyen, 2024) "Efficient algorithms for computing bisimulations for nondeterministic fuzzy transition systems"
(Costa et al., 2021) "On Typical Hesitant Fuzzy Languages and Automata"