New Results on Vector and Homing Vector Automata

TL;DR

This paper explores extensions of finite automata through vector and homing vector automata, demonstrating their capabilities, limitations, and relationships, including superiority in certain cases and characterizations of recognized languages.

Contribution

It introduces new results connecting vector automata variants, compares their computational power, and characterizes languages recognized by stateless homing vector automata.

Findings

Homing vector automata outperform extended finite automata over 2x2 matrices.

Two-state rational generalized finite automata can separate any pair of strings.

Stateless homing vector automata recognize languages with specific algebraic properties.

Abstract

We present several new results and connections between various extensions of finite automata through the study of vector automata and homing vector automata. We show that homing vector automata outperform extended finite automata when both are defined over $ 2 \times 2 $ integer matrices. We study the string separation problem for vector automata and demonstrate that generalized finite automata with rational entries can separate any pair of strings using only two states. Investigating stateless homing vector automata, we prove that a language is recognized by stateless blind deterministic real-time version of finite automata with multiplication iff it is commutative and its Parikh image is the set of nonnegative integer solutions to a system of linear homogeneous Diophantine equations.

Tables

Table 1. Table 1: Abbreviations for some model names.

	Deterministic	Deterministic	Nondeterministic	Nondeterministic
	blind		blind
Vector           automaton	DBVA($k$)	DVA(k)	NBVA($k$)	NVA($k$)
Homing vector automaton	DBHVA($k$)	DHVA($k$)	NBHVA($k$)	NHVA($k$)
Counter automaton	D$k$BCA	D$k$CA	N$k$BCA	N$k$CA
Finite automata            with            multiplication	DFAMW	DFAM	NFAMW	NFAM

Equations

$$A\otimes B_{km\times ln}=\left(\begin{array}[]{ccc}A[1,1]B&\cdots&A[1,l]B\\ \vdots&&\vdots\\ A[k,1]B&\dots&A[k,l]B\end{array}\right).$$

$$V=(Q,\Sigma ,M,\delta ,q_1,Q_a,v_0),$$

$$\delta :Q\times \Sigma \cup \{\$\}\times \{=,\ne \}\to Q\times M.$$

$$\delta (q,\sigma ,\tau )=(q^{\prime },A)$$

$$\delta :Q\times \Sigma \times \{=,\ne \}\to Q\times M,$$

$$v_{0}^{\prime}=\left(v_{0}~{}~{}1~{}~{}1\right)\mbox{ ~{}and~{} }A^{\prime}_{i_{\sigma_{j}}}=\left(\begin{array}[]{c|cc}cA_{i_{\sigma_{j}}}&0&0\\ \hline\cr 0&c&0\\ 0&0&1\end{array}\right),$$

$$\left(\begin{array}[]{ c|cc }&0&0\\ ~{}~{}~{}-I{}{}{}{}{}&\vdots&\vdots\\ &0&0\\ \hline\cr i_{1}~{}~{}i_{2}~{}~{}\cdots~{}~{}i_{k}&0&0\\ i_{1}~{}~{}i_{2}~{}~{}\cdots~{}~{}i_{k}&1&1\end{array}\right),$$

$$v_f=v_0{M}_1{M}_2\cdots M_p{M}_{p+1}=\left(j_1{j}_2\cdots j_k\right)\in {\mathbb{Q}}^k,$$

$$v_f^{\prime }=v_0^{\prime }{M}_1^{\prime }\cdots M_p^{\prime }{M}_{p+1}^{\prime }=\left(c^{p+1}{v}_f{c}^{p+1}1\right).$$

$$\left(c^{\prime }{j}_1{c}^{\prime }{j}_2\cdots c^{\prime }{j}_k{c}^{\prime }1\right)\in {\mathbb{Z}}^{k+2}.$$

$$v_f^{\prime \prime }=\left(c^{\prime }{i}_1-c^{\prime }{j}_1+i_1{c}^{\prime }{i}_2-c^{\prime }{j}_2+i_2\cdots c^{\prime }{i}_k-c^{\prime }{j}_k+i_{k}11\right).$$

$$A_{a}=\left(\begin{array}[]{ cc }1&0\\ 1&1\end{array}\right)~{}~{}A_{b}=\left(\begin{array}[]{ cc }1&0\\ 0&2\end{array}\right)~{}~{}A_{\$}=\left(\begin{array}[]{ rr }1&1\\ -1&-1\end{array}\right)$$

$$\underset{1stblock}{\underbrace{(q_1,1),(q_1,2),\dots ,(q_1,k)}},\underset{2ndblock}{\underbrace{(q_2,1),(q_2,2),\dots ,(q_2,k)}},\dots ,\dots ,\underset{n\text{mbox}-thblock}{\underbrace{(q_n,1),(q_n,2),\dots ,(q_n,k)}},$$

$$(v_0[1],v_0[1],v_0[2],\dots ,v_0[n],0,\dots ,0),$$

$$e(x)=3^{|x|-1}x[1]+3^{|x|-2}x[2]+\cdots +3^{1}x[|x|-1]+3^{0}x[|x|].$$

$$A_{1}=\left(\begin{array}[]{rr}1&~{}1\\ 0&~{}3\end{array}\right)\mbox{ and }A_{2}=\left(\begin{array}[]{rr}1&~{}2\\ 0&~{}3\end{array}\right),$$

$$e_m(x)=m^{|x|-1}x[1]+m^{|x|-2}x[2]+\cdots +m^{1}x[|x|-1]+m^{0}x[|x|].$$

$$A_{i}=\left(\begin{array}[]{rr}1&~{}i\\ 0&~{}m\end{array}\right),$$

$$v_0=(1e(x^r)).$$

$$A_{1}^{-1}=\left(\begin{array}[]{rr}1&~{}-\frac{1}{3}\\ 0&~{}\frac{1}{3}\end{array}\right)\mbox{ and }A_{2}^{-1}=\left(\begin{array}[]{rr}1&~{}-\frac{2}{3}\\ 0&~{}\frac{1}{3}\end{array}\right),$$

$$(1e(x^r))\to \left(1\frac{e(x^r)-y[1]}{3}\right)\to \left(1\frac{e(x^r)-y[1]-3y[2]}{3^2}\right)$$

$$\to \left(1\frac{e(x^r)-3^{0}y[1]-3^{1}y[2]-3^{2}y[3]}{3^3}\right)$$

$$\left(1\frac{e(x^r)-{\sum }_{j=1}^i{3}^{j-1}y[j]}{3^i}\right)\to \left(1\frac{\frac{e(x^r)-{\sum }_{j=1}^i{3}^{j-1}y[j]}{3^i}-y[i+1]}{3}\right),$$

$$\left(1\frac{e(x^r)-{\sum }_{j=1}^{i+1}{3}^{j-1}y[j]}{3^{i+1}}\right).$$

$$\left(1e(x^r)-e(y^r)\right).$$

$$v_f=\left(1+e(x^r)-e(y^r)e(x^r)\right)$$

$$A_{\$}=\left(\begin{array}[]{cc}1&~{}e(x^{r})\\ 1&0\end{array}\right).$$

$$v_f=\left(1+e(x^r)e(x^r)\right).$$

$$v_0=(1{\otimes }_{i=1}^k(1e(x_i^r))),$$

$$\left(\begin{array}[]{c|c}1&0\cdots 0\\ \hline\cr 0&\\ \vdots&\otimes_{i=1}^{k}A_{1}^{-1}\\ 0&\end{array}\right)\mbox{ and }\left(\begin{array}[]{c|c}1&0\cdots 0\\ \hline\cr 0&\\ \vdots&\otimes_{i=1}^{k}A_{2}^{-1}\\ 0&\end{array}\right)$$

Full text

1 Introduction

Extending finite automata with an external storage is a well studied topic of automata theory. In this manner, various extensions of finite automata such as quantum and probabilistic models can be viewed as finite automata augmented with a vector as memory and the computation process can be seen as a series of vector and matrix multiplications.

With the motivation of the matrix multiplication view of programming, we have previously introduced vector automata (VA) [23], which are finite automata equipped with a vector that is multiplied with an appropriate matrix at each step. Only one of the entries of the vector can be checked for equivalence to a rational number and the computation is successful if it ends in an accept state with a successful equivalence test. We have shown that this model is closely related to various extensions of finite automata including counter automata [7], finite automata with multiplication (FAM) [12], and generalized finite automata [25].

In many of the models which extend finite automata, a computation is successful if the register is equal to its initial value at the end of the computation. Applying this idea to vector automata, we have introduced the homing vector automaton (HVA) [20], which can check its vector for equivalence to its initial value and accepts a string if the computation ends with the initial vector in an accept state. We have shown that there exist close connections between homing vector automata [21] and extended finite automata [4]. In fact, homing vector automata can be seen as a special case of rational monoid automata [17].

The close connections among the models exhibited so far motivates us to further investigate vector automata and homing vector automata. In this respect, the aim of this paper is to present some new results and establish further relationships among the various extensions of finite automata, through the study of these two models. We also provide some additional results about vector automata and homing vector automata, which may further advance the research in the topic.

We first focus on extended finite automata and show that allowing postprocessing does not change the computational power of the model. It is an open question whether the class of languages recognized by extended finite automata over $3\times 3$ integer matrices includes that of one-way nondeterministic blind three counter automata. We prove that one-way three-dimensional nondeterministic blind homing vector automata (NBHVA) with integer entries can simulate any nondeterministic blind multicounter machine. We answer an open question from [21], by proving that one-way NBHVAs are more powerful than extended finite automata [4] when both are defined on the set of $2\times 2$ integer matrices.

Given two strings, a finite automaton (DFA) is said to separate them if it accepts one and rejects the other. The string separation problem, which asks for the minimum number of states needed for accomplishing this task, was introduced by Goralčík and Koubek [8], and the best known upper bound was given in [18]. The results from [8] provide a logarithmic lower bound in the length of the strings. The problem of finding a generic tight bound is still open [5].

We study the problem of string separation, and show that deterministic blind vector automata with vectors of size two can distinguish any string from any other string in blind mode (without the need to check the entries of the vector during the computation) even when they are restricted to be stateless (i.e. with only one state). This result implies that generalized finite automata with rational entries can distinguish any pair of strings by using only two states. We also present some results on finite language recognition.

Stateless machines [28, 11, 14] have been investigated by many researchers, motivated by their relation to membrane computing and P systems [16], which are stateless models inspired from biology. While vector automata can simulate their classical states in their vectors by using longer vectors, this is not the case for homing vector automata. This leads us to investigate stateless homing vector automata in more detail.

Our study on stateless homing vector automata yields a characterization for the class of languages recognized by stateless real-time deterministic FAMs without equality (0-DFAMW) [12]. It turns out that a language is recognized by a 0-DFAMW iff it is commutative and its Parikh image is the set of nonnegative solutions to a system of linear homogeneous Diophantine equations. When the computation is nondeterministic, then any language recognized by a stateless real-time nondeterministic FAM without equality is commutative. We conclude by providing some further examples and observations about language recognition power of stateless homing vector automata.

2 Background

2.1 Preliminaries

The following notation will be used throughout the paper. The set of states is $Q=\{q_{1},\ldots,q_{n}\}$ for some $n\geq 1$, where $q_{1}$ is the initial state, unless otherwise specified. $Q_{a}\subseteq Q$ is the set of accept state(s). The input alphabet is denoted by $\Sigma$ and we assume that it never contains \$$ (the right end-marker). For a given string w\in\Sigma^{*}$,$w^{r}$denotes its reverse,$|w|$denotes its length,$w[i]$denotes its$i$’th symbol,$|w|{\sigma}$denotes the number of occurrences of symbol$\sigma$in$w$and$\mathtt{L}{w}$denotes the singleton language containing only$w$. For a given language$L$, its complement is denoted by$\overline{L}$. The power set of a set$S$is denoted$\mathcal{P}(S)$.

For a string $w\in\Sigma^{*}$ where $\Sigma=\{\sigma_{1},\sigma_{2},\dots,\sigma_{k}\}$ is an ordered alphabet, the Parikh image of $w$ is defined as $\phi(w)=(|w|_{\sigma_{1}},|w|_{\sigma_{2}},\dots,|w|_{\sigma_{k}})$. For a language $L$, $\phi(L)=\{\phi(w)|w\in L\}$.

A subset $S\subseteq\mathbb{N}^{n}$ is a linear set if $S=\{v_{0}+\Sigma_{i=1}^{k}c_{i}v_{i}|c_{1},\dots,c_{k}\in\mathbb{N}\}$ for some $v_{0},\dots,v_{k}\in\mathbb{N}^{n}$. A semilinear set is a finite union of linear sets. A language is called semilinear if $\phi(L)$ is semilinear.

For a machine model $A$, $\mathfrak{L}(A)$ denotes the class of all languages recognized by machines of type $A$. We denote the class of context-free languages by $\mathsf{CF}$ and the set of recursively enumerable languages by $\mathsf{RE}$.

For a given row vector $v$, $v[i]$ denotes its $i$’th entry. Let $A_{k\times l}$ be a $k\times l$ dimensional matrix. $A[i,j]$ denotes the entry in the $i$’th row and $j$’th column of $A$. Given matrices $A_{k\times l}$ and $B_{m\times n}$, their tensor product is defined as

[TABLE]

2.2 Machine definitions

In this section, we give definitions of the various models which will appear throughout the paper.

An input string $w$ is placed on a tape in the form $w$$. Most of the time, we focus on real-time computation, where the tape head moves right at each step. A machine is deterministic if the next move of the machine is uniquely determined, and nondeterministic if there may exist more than one possible move at each step.

When we want to specify the number of states of a machine, we add an $n$- (or $(n)$- to avoid any confusion) to the front of the model name where $n$ is the number of states. We will examine stateless models, i.e. one-state automata where the single state is accepting, in more detail. It is clear that if the single state is non-accepting, then the automaton can recognize only the empty language. When a machine is stateless, we denote this by adding 0- to the front of the abbreviation for the model name.

A (real-time) deterministic $k$-counter automaton (D$k$CA) [7] is a deterministic finite automaton equipped with $k$ counters. The counters are initially set to 0 and updated at each step by $c\in\{-1,0,1\}^{k}$, based on the current state, scanned symbol and the current status of the counters. The status of the counters is given by $\theta\in\{=,\neq\}^{k}$, where $=$ and $\neq$ denote whether the corresponding counter values equal zero or not, respectively. An input string is accepted if the machine is in an accept state at the end of the computation. A (real-time) deterministic blind $k$-counter automaton [9] D$k$BCA is a D$k$CA which can check the value of its counters only at the end of the computation. An input string is accepted by a blind counter automaton if the machine is in an accept state and all counter values are equal to 0 at the end of the computation.

A generalized finite automaton (GFA) [26] is a 5-tuple $G=(Q,\Sigma,\{A_{\sigma\in\Sigma}\},v_{0},f),$ where the $A_{\sigma\in\Sigma}$’s are $|Q|\times|Q|$ real valued transition matrices, and $v_{0}$ and $f$ are the real valued initial row vector and final column vector, respectively. The acceptance value for an input string $w\in\Sigma^{*}$ is defined as $f_{G}(w)=v_{o}A_{w[1]}\cdots A_{w[|w|]}f$.

There are various ways to define the language recognized by a generalized finite automaton. In this paper, we are interested in the class $\textup{S}^{=}$, which contains languages of the form $L=(G,=\lambda)=\{w\in\Sigma^{*}\mid f_{\mathcal{G}}(w)=\lambda\}$, where $\lambda\in\mathbb{R}$ is called the cutpoint [26].

A GFA whose components are restricted to be rational numbers is called a Turakainen finite automaton (TuFA) in [27] and the class of languages recognized by a TuFA in the same language recognition mode with a rational cutpoint is denoted by $\textup{S}^{=}_{\mathbb{Q}}$.

A (real-time) deterministic finite automaton with multiplication (DFAM) [12] is a deterministic finite automaton equipped with a register holding a positive rational number. The register is initialized to 1 at the beginning of the computation and multiplied with a positive rational number at each step, based on the current state, scanned symbol and whether the register is equal to 1 or not. An input string is accepted if the computation ends in an accept state with the register value being equal to 1, after processing the right end-marker. A DFAM without equality (DFAMW) is a DFAM which cannot check whether or not the register has value 1 during computation. Nondeterministic versions NFAM and NFAMW are defined analogously.222The original definition of FAMs is given for one-way machines (1DFAM, 1NFAM, 1DFAMW, 1NFAMW) where the tape head is allowed to stay on the same input symbol for more than one step. The computation halts and the string is accepted when the machine enters an accept state with the tape head on the end-marker $$$.

Let $M$ be a monoid. An extended finite automaton over $M$ ($M$-automaton, monoid automaton) [4, 3, 13] is a nondeterministic finite automaton equipped with a register which holds an element of the monoid $M$. The register is initialized with the identity element of $M$ and multiplied (operation is applied) by an element of the monoid based on the current state and the scanned symbol (or the empty string). An input string is accepted if the value of the register is equal to the identity element of the monoid and the computation ends in an accept state. When $M$ is a group, then the model is called group automaton.

Note that extended finite automata are nondeterministic by definition and they are blind in the sense that the register cannot be checked until the end of the computation. Computation of an extended finite automaton is not real-time since the machine is allowed to make $\varepsilon$ transitions. The class of languages recognized by $M$-automata is denoted by $\mathfrak{L}(M)$.

2.3 Vector automata and homing vector automata

A * (real-time) $k$-dimensional deterministic vector automaton* (DVA($k$)) [23] is a 7-tuple

[TABLE]

where $v_{0}$ is the initial ($k$-dimensional, rational-valued) row vector, $M$ is a finite set of $k\times k$-dimensional rational-valued matrices, and $\delta$ is the transition function (described below) defined as

[TABLE]

Let $w\in\Sigma^{*}$ be a given input. The automaton $V$ reads the sequence w\$$ from left to right symbol by symbol. It uses its states and its vector to store and process the information. In each step, it can check whether the first entry of the vector is equal (=$) to 1 or not ($\neq$). We call this feature the “status” of the first entry.

The details of the transition function are as follows. When $V$ is in state $q\in Q$, reads symbol \sigma\in\Sigma\cup\{\}$, and the first entry status is$\tau\in{=,\neq}$, the transition

[TABLE]

results in $V$ entering state $q^{\prime}\in Q$, and its vector being multiplied by $A\in M$ from the right.

At the beginning of the computation, $V$ is in state $q_{1}$ and the vector is $v_{0}$. Then, after reading each symbol, the state and vector are updated according to the transition function as described above. The input $w$ is accepted if the final state is an accept state and the first entry of the final vector is 1 after processing the right end-marker \$$. Otherwise, the input is rejected. The set of all accepted strings is said to be the language recognized by V$.

A * (real-time) $k$-dimensional deterministic homing vector automaton* (DHVA($k$)) is defined in [20] as being different from vector automata in two ways: (1) Homing vector automata do not read the right end-marker after reading the input, so there is no chance of postprocessing and, (2) instead of checking the status of the first entry, a homing vector automaton checks whether the complete current vector is identical to the initial vector or not. Formally, the transition function $\delta$ is defined as

[TABLE]

where $=$ indicates equality to the initial vector ${v_{0}}$, and $\neq$ indicates inequality. An input string is accepted if the computation ends in an accept state and the vector is equal to its initial value.

The blind versions of these models, (real-time) $k$-dimensional deterministic blind vector automaton (DBVA($k$)) and (real-time) $k$-dimensional deterministic blind homing vector automaton (DBHVA($k$)) cannot check the status of the vector until the end of the computation. Therefore, the domain of the transition function changes to Q\times\Sigma\cup\{\}$and$Q\times\Sigma$ for vector automata and homing vector automata respectively. The acceptance condition is the same as in the non-blind case.

The definitions of (real-time) $k$-dimensional nondeterministic vector automaton, abbreviated NVA($k$), and (real-time) $k$-dimensional nondeterministic homing vector automaton, abbreviated NHVA($k$), are almost the same as that of the deterministic versions, except that the range of the transition function $\delta$ is now defined as $\mathcal{P}(Q\times M)$, which allows the machine to follow more than one computational path. An input string is accepted if and only if there is a path ending with the acceptance condition.

Abbreviations used for some model variants discussed so far are given in Table 1.

When we do not want to explicitly state the dimension of the vector or the number of the counters, then we may omit $k$ in the abbreviation when we talk about vector automata, homing vector automata and counter automata. Similarly, we may omit $D$ and $N$ in the abbreviation when we talk about a statement that is true for both cases.

3 New results on homing vector automata and extended finite automata

In this section, we will focus on the relationship between extended finite automata and homing vector automata.

3.1 Some lemmas on homing vector automata

We will start by proving a lemma that will be used in the rest of the section.

Homing vector automata are not allowed to perform postprocessing by definition, since they do not read the right end-marker. In this section, we show that allowing postprocessing does not bring any additional power to nondeterministic blind homing vector automata, as the postprocessing step can be handled by using some extra states. We prove the result for the more general case of 1NBHVAs, NBHVAs that are capable of making $\varepsilon$ transitions. The computation of a 1NBHVA using end-marker ends once the machine processes the end-marker $$$.

HVAs using end-marker will be denoted by the abbreviation \textup{HVA}_{\}$.

Lemma 3.1**.**

Let $L$ be a language recognized by an $(n)$-\textup{1NBHVA}_{\}(k)$$V$. Then,$L$is also recognized by an$(n+2)$-$\textup{1NBHVA}(k)$$V^{\prime}$.

Proof 3.2**.**

We construct $V^{\prime}$ such that $V^{\prime}$ mimics the transitions of $V$ on every possible symbol $\sigma\in\Sigma\cup\{\varepsilon\}$. In addition, we create new transitions to handle the postprocessing, which emulate $V$’s last action before reading the end-marker (which would end up in an accept state) and the end-marker (\sigma\$$) at once: At any point during the scanning, if reading \sigma$would cause$V$to switch to a state from which the end-marker would lead to an accept state, a new nondeterministic transition takes$V^{\prime}$to the additional state, which is an accept state. During this transition, the vector is multiplied by a matrix of the form$A_{\sigma}A_{$}$, where$A_{\sigma}$and$A_{$}$are the corresponding matrices defined in the transition function of$V$. All other states of$V^{\prime}$, which are inherited from$V$, are designated to be non-accept states.

Thus, $V^{\prime}$ simulates the computation of $V$ on any non-empty string, and accepts the input in some computational path if and only if $V$ accepts it.

If $L$ contains the empty string, we add one more state that has the following properties: (i) it becomes the new initial state of the resulting machine, (ii) it is an accept state, (iii) it causes the machine to behave (i.e. transition) like the original initial state of $V$ upon reading the first symbol, and (iv) there is no transition coming in to this state.

The idea given in the proof of Lemma 3.1 does not apply for non-blind models since the status of the vector may be changed after reading the last symbol of the input (just before reading the right end-marker). In fact, one can show that DHVAs using end-marker are more powerful than ordinary DHVAs in terms of language recognition by the witness language $\mathtt{NEQ}=\{a^{i}b^{j}:i\neq j\}$ .

In the following lemma, we show that any 1NBHVA with end-marker whose matrices are rational valued can be simulated by integer valued matrices in the cost of increasing the size of the vector by 2. The lemma is also valid for the deterministic and real-time models.

Lemma 3.3**.**

For any given rational-valued $(n)$-\textup{1NBHVA}_{\}(k)$$V$, there exists an integer-valued$(n)$-$\textup{1NBHVA}_{$}(k+2)$$V^{\prime}$ that recognizes the same language.

Proof 3.4**.**

It is easy to see that, for any HVA, the initial vector $v_{0}$ can be replaced with the vector $tv_{0}$ for any rational $t\neq 0$ without changing the recognized language. Therefore, any HVA can be assumed to be defined with an integer-valued initial vector without loss of generality.

Let the initial vector of $V$ be $v_{0}=\left(i_{1}~{}~{}i_{2}~{}~{}\cdots~{}~{}i_{k}\right)\in\mathbb{Z}^{k}$. Furthermore, let $S_{i_{a}},S_{i_{b}},S_{i_{\varepsilon}}$ and S_{i_{\}}$be the sets of$k\times k$rational-valued matrices of$V$to be applied when$V$is in state$q_{i}$and reads the symbols$a$,$b$,$\varepsilon$and$$$, respectively.

The automaton $V^{\prime}$ is obtained from $V$ by modifying the initial vector and matrices. We pick an integer $c\in\mathbb{Z}$ such that when multiplied with $c$, the matrices in $S_{i_{a}},S_{i_{b}},S_{i_{\varepsilon}}$ and S_{i_{\}}$contain only integer values, where$1\leq i\leq n$. Then, we define the set$S^{\prime}{i{\sigma}}$ by letting

[TABLE]

where $A_{i_{\sigma_{j}}}\in S_{i_{\sigma}}$, \sigma\in\{a,b,\varepsilon,\}$and$j$enumerates the number of possible transitions for$\sigma$in state$q_{i}$.$v^{\prime}{0}$is the initial vector of$V^{\prime}$, and when in state$q{i}$,$V^{\prime}$multiplies the vector with an integer-valued matrix from the set$S_{i_{a}}^{\prime}$,$S_{i_{b}}^{\prime}$or$S_{i_{\varepsilon}}^{\prime}$upon reading the inputs$a$,$b$, and$\varepsilon$respectively. When in state$q_{i}$and reading symbol$$$, the vector is multiplied with a matrix from the set$S^{\prime\prime}{i{$}}$, which is obtained by multiplying the matrices in$S_{i_{$}}^{\prime}$ with

[TABLE]

where $I$ denotes the identity matrix.

Let $w\in\{a,b\}^{*}$ be a string of length $l$, and let’s consider a single computation path of length $p+1\geq l+1$ for $w$. The final vector is calculated as

[TABLE]

where $M_{i}$ is the matrix used at the $i$’th transition step. It is easy to see that

[TABLE]

(Note that the equation above contains $M_{p+1}^{\prime}$, but not $M_{p+1}^{\prime\prime}$.) By setting $c^{\prime}=c^{p+1}$, we can rewrite $v_{f}^{\prime}$ as

[TABLE]

For accepted input strings, $v_{f}^{\prime}$ holds $c^{\prime}$ times the initial vector. The postprocessing step, which is accomplished by a matrix from the set S^{\prime\prime}_{i_{\}}$, helps setting the vector back to its initial value to satisfy the acceptance criteria.

Hence, $v_{f}^{\prime\prime}=v_{0}^{\prime}M_{1}^{\prime}\cdots M_{p}^{\prime}M_{p+1}^{\prime\prime}$ is

[TABLE]

It is clear that $v_{0}=v_{f}$ if and only if $v^{\prime}_{0}=v^{\prime\prime}_{f}$. Thus, rational-valued $V$ and integer-valued $V^{\prime}$ recognize the same language.

Corollary 3.5**.**

Rational-valued 1NBHVAs and integer-valued 1NBHVAs recognize the same class of languages.

Proof 3.6**.**

By using Lemma 3.3, we can conclude that any rational-valued 1NBHVA can be simulated by an integer-valued 1NBHVA using the end-marker. Then, by using Lemma 3.1, we can remove the end-marker.

3.2 Extended finite automata and homing vector automata defined over integer matrices

Before presenting the main results of the section, we observe that postprocessing does not bring additional power to extended finite automata.

Lemma 3.7**.**

Let $L$ be a language recognized by an extended finite automaton $V$ using end-marker. Then $L$ is also recognized by an extended finite automaton $V^{\prime}$ that does not use the end-marker.

Proof 3.8**.**

Extended finite automata are one-way and nondeterministic by definition. Hence, the proof idea of Lemma 3.1 applies here as well. With the help of the additional transitions and extra states, the postprocessing step can be handled by an ordinary extended finite automaton without end-marker.

Let $M$ be a multiplicative monoid of $k\times k$ integer matrices. We denote by $\textup{HVA}(k)_{M}$ a $k$-dimensional homing vector automaton whose matrices belong to $M$. For the rest of the section, we are going to investigate $M$-automata and $\textup{HVA}(k)_{M}$. $\mathbb{Z}^{k\times k}$ denotes the multiplicative monoid of $k\times k$ matrices with integer entries.

In [19], it is shown that $\mathsf{RE}\subseteq\mathfrak{L}\textup{(1NBHVA(4)}_{\mathbb{Z}^{4\times 4}})$. Therefore, Lemma 3.3 says something new only about the class of languages recognized by 3-dimensional 1NBHVAs with integer entries. Note that any blind $k$-counter automaton can be simulated by a one-dimensional homing vector automaton whose register is multiplied by $k$ distinct primes and their multiplicative inverses. Using the fact that any 1N$k$BCA can be simulated by a 1NBHVA(1), we show that the same result can be achieved by a 1NBHVA(3) whose matrices are restricted to have integer entries. Note that the result is also true for real-time NBHVAs.

Theorem 3.9**.**

\bigcup_{k}\mathfrak{L}(\textup{1NkBCA})\subsetneq\mathfrak{L}\textup{(1NBHVA(3)}_{\mathbb{Z}^{3\times 3}}).

Proof 3.10**.**

Any 1N$k$BCA can be simulated by a 1NBHVA(1)${}_{\mathbb{Q^{+}}}$ and any 1NBHVA(1)${}_{\mathbb{Q^{+}}}$ can be simulated by a 1NBHVA$(3)${}{\mathbb{Z}^{3\times 3}}by Lemma [3.3](#S3.Thmtheorem3). By using additional states, we can obtain an equivalent\textup{1NBHVA(3)}{\mathbb{Z}^{3\times 3}}without end-marker by Lemma [3.1](#S3.Thmtheorem1). The inclusion is proper since the unary nonregular language\mathtt{UPOW^{\prime}={a^{n+2^{n}}}|n\geq 0}$can be recognized by a$\textup{NBHVA(3)}_{\mathbb{Z}^{3\times 3}} [[19](#bib.bib19)], which is not possible for 1Nk$BCAs [9, 10].

It is an open question whether $\mathfrak{L}(\mathbb{Z}^{3\times 3})$ includes the class of languages recognized by 1N3BCAs. We cannot adapt Theorem 3.9 to $\mathbb{Z}^{3\times 3}$-automata since the product of the matrices multiplied by the register in Lemma 3.1 is not equal to the identity matrix and the acceptance condition for extended finite automata is not satisfied.

In [21] it is shown that the non-context-free language $\mathtt{POW_{r}}=\{a^{2^{n}}b^{n}|n\geq 0\}$ can be recognized by a $\textup{DBHVA(2)}_{\mathbb{Z}^{2\times 2}}$. It is left open whether there exists a 1NBHVA with integer entries recognizing $\mathtt{POW_{r}}$. Theorem 3.11 answers two open questions from [21], by demonstrating a 1NBHVA with integer entries recognizing $\mathtt{POW_{r}}$ and revealing that 1NBHVAs are more powerful than the corresponding extended finite automata, when the matrices are restricted to the set $\mathbb{Z}^{2\times 2}$. By $\mathbf{F}_{2}$ we denote the free group of rank 2.

Theorem 3.11**.**

$\mathfrak{L}(\mathbb{Z}^{2\times 2})\subsetneq\mathfrak{L}(\textup{1NBHVA(2)}_{\mathbb{Z}^{2\times 2}})$.

Proof 3.12**.**

In [22], it is proven that any $\mathbb{Z}^{2\times 2}$-automaton can be converted to a $\mathbf{F}_{2}$-automaton. By setting the initial vector to be $(1~{}~{}0)$, any $\mathbf{F}_{2}$-automaton can be simulated by a 1NBHVA(2) whose matrices have determinant 1 with integer entries [21] and the inclusion follows.

Now we are going to prove that the inclusion is proper. Since $\mathbf{F}_{2}$-automata recognize exactly the class of context-free languages [4, 3], $\mathfrak{L}(\mathbb{Z}^{2\times 2})=\mathsf{CF}$. Let us construct a DBHVA$(2)${}{\mathbb{Z}^{2\times 2}}$$V$recognizing the non-context-free language$\mathtt{POW{r}}={a^{2^{n}}b^{n}|n\geq 0}$. The state diagram of$V$ is given in Figure 1.

[TABLE]

The initial vector of $V$ is $v_{0}=(1~{}~{}1)$. While reading $a$ in $q_{1}$, $V$ multiplies its vector with the matrix $A_{a}$. It moves to $q_{2}$ when it scans the first $b$ and multiplies its vector with the matrix $A_{b}$ as it reads each $b$. When $V$ reads the end-marker, it multiplies its vector with the matrix A_{\}$and moves to$q_{3}$.

When the vector is multiplied by $A_{a}$, the first entry of the vector is increased by 1 and when the vector is multiplied by $A_{b}$, the second entry of the vector is multiplied by 2. Hence, after reading an input string of the form $a^{i}b^{j}$, the vector is equal to $(i+1~{}~{}2^{j})$, as a result of the multiplication by the matrix product ${A_{a}}^{i}{A_{b}}^{j}$. After multiplication by A_{\}$, the second entry of the vector is subtracted from the first entry and this value is stored in both entries of the vector. The value of the final vector is equal to$(1~{}~{}1)$iff$i+1-2^{j}=1$. Hence, the accepted strings are those which are of the form$a^{2^{j}}b^{j}. As it is proven in Lemma [3.1](#S3.Thmtheorem1) that a NBHVA without end-marker recognizing the same language as a given NBHVA with end-marker can be constructed just by increasing the number of states but not the vector size, we can conclude that \mathtt{POW_{r}}$can be recognized by a$\textup{NBHVA(2)}_{\mathbb{Z}^{2\times 2}}$.

4 The string separation problem

In this section we investigate the string separation problem for vector and homing vector automata. Recently, the same question has been investigated in [1, 2] for different models such as probabilistic, quantum, and affine finite automata (respectively, PFA, QFA, AfA). (We refer the reader to [24, 6] for details of these models.) As these models are capable of storing information in their probabilities or amplitudes, they can be much more state-efficient than DFAs. For example, nondeterministic QFAs and zero-error AfAs can distinguish any pair by using only two states.

The storage mechanism of vector automata and homing vector automata enables these two models to separate strings by encoding the string in their vector entries. When measuring efficiency of these two models, it is fairer to measure succinctness in terms of both the number of states and the vector size.333In [23], the size of an $n$-DBVA($k$) is defined as $nk$, and a hierarchy theorem is given based on the size of DBVAs.

We first show that VAs can simulate their classical states by using longer vectors and conclude that their stateless counterparts have the same computational power.

Lemma 4.1**.**

Any given $n$-DVA($k$) $V$ can be simulated by a 0-DVA($nk$+1), which recognizes the same language.

Proof 4.2**.**

Note that the following modification to any DVA does not change the recognized language: If the last transition yields a non-accept state, then the vector is multiplied by the zero matrix, i.e. we guarantee that the first entry of the vector is set to 0 if the final state is non-accepting. Assume that $V$ is an $n$-state $k$-dimensional DVA with this property.

We describe a 0-DVA$(nk+1)$ $V^{\prime}$. We will call the vector of $V^{\prime}$ ‘the new vector’, and index its last $nk$ entries by pairs as

[TABLE]

where we have $n$ blocks, and the $i$’th block is associated with $q_{i}\in Q$ ($1\leq i\leq n$). Based on this representation, $V^{\prime}$ will keep track of the state and the vector of $V$ at each step. The remaining first entry of the new vector holds the sum of all of its entries at indices of the form $(q,1)$, for any $q$.

During the simulation, all but one of the blocks will be forced to contain zeros in all of its entries. The only exception is the block corresponding to the current state of $V$, which will contain the values in $V$’s vector. Thus, the first entry of the new vector keeps the value of the first entry of $V$’s vector for each step, and so, $V^{\prime}$ can easily implement the vector test done by $V$, i.e. testing whether the first entry of $V$’s vector is 1 or not.

The new vector is initially set to

[TABLE]

where the first entry is set to $v_{0}[1]$ and then the first block is set to $v_{0}$ since $V$ starts its computation in $q_{1}$, and, all other blocks are set to zeros.

Since $V^{\prime}$ is stateless, it has a single $(1+nk)\times(1+nk)$ matrix for every ($\sigma$, $\tau$) pair. This big matrix is designed so that each transition of the form $\delta(q_{i},\sigma,\tau)=(q_{j},A)$ of $V$ is implemented by multiplying the $i$’th block by $A$ and transferring the result to the $j$’th block. Thus, both the simulated state and the vector of $V$ are updated accordingly. Moreover, the first entry of the new vector is set to the summation mentioned above. In this way, the computation of $V$ is simulated by $V^{\prime}$ and both of them make the same decision on each input, i.e. the first entry of the new vector is set to 1 if and only if the final state of $V$ is accepting and the first entry of $V$’s vector is 1.

Stateless models are advantageous, as they allow leaving behind the details of the state transitions and focusing on the vector matrix multiplications. In the following series of results, we are going to show that stateless DBVAs can separate any pair of strings.

In [23], it is proven that $\bigcup_{k}\mathfrak{L}$(DBVA($k$)) = $S^{=}_{\mathbb{Q}}$. The proof involves construction of a 0-DBVA($k$) to simulate a TuFA with $k$ states. Therefore, any result about 0-DBVA($k$)s is also true for TuFAs with $k$ states and more generally for generalized finite automata with $k$ states.

We start by distinguishing unary strings.

Theorem 4.3**.**

For any $i\geq 0$, there exists a 0-DBVA(1) that distinguishes the string $a^{i}$ from any other string in $\{a^{*}\}$.

Proof 4.4**.**

The initial vector is $v_{0}=(2^{i})$. For each symbol $a$, the vector is multiplied with \bigl{(}\frac{1}{2}\bigr{)}. For any other input symbol, the vector is multiplied by (0). The end-marker is associated with multiplication by (1). Therefore, the final vector is $(1)$ if and only if the automaton reads $a^{i}$.

Corollary 4.5**.**

The language $\mathtt{L}_{\varepsilon}$ is recognized by a 0-DBHVA(1) .

Proof 4.6**.**

If one removes the transition associated with the end-marker from the machine described in the proof above for $i=0$, one obtains a 0-DBHVA(1) recognizing $\mathtt{L}_{\varepsilon}$.

For any $x\in\{1,2\}^{+}$, let $e(x)$ be the number encoded by $x$ in base 3:

[TABLE]

The encoding $e(x)$ can be easily obtained by using vector-matrix multiplications. Starting with the initial vector $v_{0}=(1~{}~{}~{}0)$, and multiplying the vector with

[TABLE]

respectively for each scanned $1$ and $2$ from left to right, one obtains $(1~{}~{}~{}e(x))$ at the end. We can easily extend this encoding for any generic alphabet. For any $x\in\{1,2,\ldots,m-1\}^{+}$ for some $m>3$, $e_{m}(x)$ is the number encoded by $x$ in base $m$:

[TABLE]

To encode $e_{m}(x)$, $v_{0}$ is multiplied with

[TABLE]

for each symbol $i$. Note that the results proven in this section for binary alphabets can be easily extended to any alphabet using the encoding $e_{m}(\cdot)$.

Now we show that 2-dimensional vector automata can distinguish strings without using any states.

Theorem 4.7**.**

The string $x\in\{1,2\}^{+}$ is distinguished from any other string in $\{1,2\}^{*}$ by a 0-DBVA(2).

Proof 4.8**.**

We build the machine in question. The initial vector is

[TABLE]

The matrices applied to the vectors for symbols $1$ and $2$ are

[TABLE]

respectively. When applied on the vector, the matrix $A_{1}^{-1}$ (resp., $A_{2}^{-1}$) leaves the first entry unchanged at value 1, and subtracts 1 (resp., 2) from the second entry and then divides the result of this subtraction by 3.

Let $y\in\{1,2\}^{*}$ be the given input. Suppose that $y\neq\varepsilon$. After reading $y$, the vector changes as

[TABLE]

[TABLE]

for the first three steps, and, at the $i$’th step, we have

[TABLE]

which is equal to

[TABLE]

Thus, after reading $y$, the vector is equal to

[TABLE]

After reading the end-marker, the final vector is set as

[TABLE]

by using the matrix

[TABLE]

Thus, if $x=y$, then $v_{f}=v_{0}$ and the first entry is 1. Otherwise, the first entry of $v_{f}$ is not equal to 1.

If $y=\varepsilon$, then the final vector is obtained by multiplying the initial vector with A_{\}$ upon reading the end-marker:

[TABLE]

Since the first entry of the vector is never equal to 1, $\varepsilon$ is never accepted.

We now focus on recognizing finite languages containing multiple strings. Stateless VAs can accomplish this task while no stateless HVA can recognize any finite language as we show in Section 5.

Theorem 4.9**.**

Any finite language $X=\{x_{1},\ldots,x_{k}\}\subseteq\{1,2\}^{+}$ can be recognized by a 0-DBVA($2^{k}+1$).

Proof 4.10**.**

We know from the proof of Theorem 4.7 that for any $x_{i}\in X$, there is a 0-DBVA(2) $V_{x_{i}}$ that starts in $(1~{}~{}~{}e(x_{i}^{r}))$ and ends in $(1+e(x_{i}^{r})-e(y^{r})~{}~{}~{}e(x_{i}))$ for the input string $y$. Let $V^{\prime}_{x_{i}}$ be a 0-DBVA(2) obtained by modifying $V_{x_{i}}$ such that the vector equals $(e(x_{i}^{r})-e(y^{r})~{}~{}~{}0)$ at the end. We build a 0-DBVA($2^{k}+1$) $V_{X}$ that executes each $V^{\prime}_{x_{i}}$ in parallel (by employing a tensor product of all those machines) in the last $2^{k}$ entries of its vector, and then performs an additional postprocessing task. The initial vector of $V_{X}$ is

[TABLE]

that is, each $V^{\prime}_{x_{i}}$ is initialized with its initial vector. In order to execute each $V^{\prime}_{x_{i}}$, the matrices

[TABLE]

are respectively used for symbols $1$ and $2$. Before reading $$$, the vector is equal to

[TABLE]

The transition matrix used upon scanning the end-marker symbol \$$ can be described as the product of two matrices A_{${1}}$and$A{$_{2}}$:

[TABLE]

where

[TABLE]

After multiplication with A_{\_{1}}$, the vector becomes

[TABLE]

which is identical to

[TABLE]

If $y\in X$, then the value of the second entry in this vector is also equal to 0 since one of the factors is zero in the multiplication. Otherwise, the value of the second entry is non-zero. A_{\_{2}}$in the product for$$$ sets the final vector to

[TABLE]

Here, the last $2^{k}-1$ entries can be set to those values easily, since $v_{0}$ is a fixed a vector. Thus, if $y\in X$, then $v_{f}=v_{0}$ with $v_{f}[1]=1$, and so the input is accepted. Otherwise, $v_{f}\neq v_{0}$ with $v_{f}[1]\neq 1$, and so the input is rejected.

Now we move on to string separation by homing vector automata. We show that any nonempty string can be distinguished from any other string by a 2-DBHVA($2$).

Theorem 4.11**.**

The string $x\in\{1,2\}^{+}$ is distinguished from any other string in $\{1,2\}^{*}$ by a 2-DBHVA($2$).

Proof 4.12**.**

Let us construct a 2-DBHVA(2) distinguishing $x$. The initial state is named $q_{1}$, and the only accept state is named $q_{2}$. We are going to use the encoding described above and the associated matrices. The proof is similar to the proof of Theorem 4.7. The initial vector is

[TABLE]

Let $y\in\{1,2\}^{*}$ be the given input. If $y=\varepsilon$, then the state is never changed, and so the input is never accepted. Therefore, we assume $y\in\{1,2\}^{+}$ in the remaining part.

To encode $x^{r}$, we will use the matrix

[TABLE]

When in $q_{1}$, the vector is updated as

[TABLE]

upon reading the first symbol of $y$, and the state is set to $q_{2}$. The value of the vector is equal to

[TABLE]

From now on, the state is never changed, but the vector is updated by multiplication with $A_{1}^{-1}$ and $A_{2}^{-1}$ for each scanned symbol 1 and 2 respectively. Thus, as in Theorem 4.7, after reading $y$ the vector is equal to

[TABLE]

Hence, we conclude that $v_{f}=v_{0}$ iff $x=y$.

It turns out that using two states in the above proof is essential, and we cannot obtain a similar result by using just one state, regardless of the dimension of the vector. More precisely, if $x$ is accepted by a 0-NHVA, then $xx$ is also accepted by the same automaton, since any further repetition of the same input naturally carries the vector through a trajectory that ends up in its initial value. We are therefore motivated to examine the limitations imposed by statelessness on homing vector automata in more detail in the next section.

The stateless vector automata we propose in Theorem 4.9 for recognizing a finite language require a vector of exponential size in the number of strings. Note that the machine $V_{X}$ built in the proof of the theorem is deterministic and homing with end-marker. If we allow nondeterminism, then Lemma 3.1 helps us obtain the same result with just two dimensions and using three states for ordinary NBHVAs.

Corollary 4.13**.**

Any finite language $X=\{x_{1},\dots,x_{k}\}\subseteq\{1,2\}^{+}$ can be recognized by a 3-NBHVA(2) $H_{X}$.

Proof 4.14**.**

We first construct a 0-\textup{NBHVA}_{\}(2)$$N_{X}$.$N_{X}$nondeterministically picks an$x_{i}and then executes the deterministic automaton given in the proof of Theorem [4.7](#S4.Thmtheorem7). SinceN_{X}$is homing using end-marker, we conclude that there exists a 3-NBHVA(2)$H_{X}$recognizing$Xby Lemma [3.1](#S3.Thmtheorem1). (A 2-NBHVA(2) is in fact sufficient ifX$ does not contain the empty string, as can be seen in the proof of Lemma 3.1.)

5 Stateless homing vector automata

In this section, we investigate the computation power of stateless HVAs. In these machines, only the vector is updated after reading an input symbol.

5.1 Remarks

The limitation of having a single state for homing vector automata leads to the acceptance of the string $xx$, whenever the string $x$ is accepted. This is true since further repetition of the same input naturally carries the vector through a trajectory that ends up in its initial value. Based on this observation, we can list the following consequences:

• •

If string $x$ is accepted by a 0-NHVA $H$, then any member of $\{x\}^{*}$ is also accepted by $H$.

• •

If all members of a language $L$ are accepted by a 0-NHVA $H$, then any string in $L^{*}$ is also accepted by $H$.

• •

If language $L$ is recognized by a 0-NHVA, then $L=L^{*}$.

• •

0-NHVAs cannot recognize any finite language except $\mathtt{L}_{\varepsilon}$.

All of the results given above are also valid for deterministic or blind models. We can further make the following observation.

Lemma 5.1**.**

If the strings $w_{1}$ and $w_{1}w_{2}$ are accepted by a 0-DHVA $H$, then the string $w_{2}$ is also accepted by $H$.

Proof 5.2**.**

After reading $w_{1}$, the value of the vector is equal to its initial value. Since $w_{1}w_{2}$ is also accepted by $H$, reading $w_{2}$ results in acceptance when started with the initial vector.

For the unary case we have the following.

Theorem 5.3**.**

If the strings $a^{i}$ and $a^{j}$ ($1<i<j$) are accepted by a 0-DHVA $H$, then the string $a^{\gcd(i,j)}$ is also accepted by $H$.

Proof 5.4**.**

It is well known that for any positive integers $i,j$, there are two integers $l_{i}$ and $l_{j}$ such that $il_{i}+jl_{j}=\gcd(i,j)$. Assume that $l_{i}$ is positive and $l_{j}$ is non-positive. (The other case is symmetric.) Note that $il_{i}\geq j(-l_{j})$. The strings $a^{j(-l_{j})}$ and $a^{il_{i}}$ are accepted by $H$. By Lemma 5.1, the string $a^{il_{i}-j(-l_{j})}$, which is $a^{\gcd(i,j)}$, is also accepted by $H$.

Corollary 5.5**.**

If the strings $a^{i}$ and $a^{j}$ ($1<i<j$) are accepted by a 0-DHVA $H$ and $\gcd(i,j)=1$, then $H$ recognizes $a^{*}$.

Let us now investigate the case where the set of matrices is commutative.

Let $L\in\Sigma^{*}$ be a language. The commutative closure of $L$ is defined as $com(L)=\{x\in\Sigma^{*}|\phi(x)\in\phi(L)\}$. A language is commutative if $com(L)=L$.

Theorem 5.6**.**

If a language $L$ is recognized by a 0-NBHVA $H$ with a commutative set of matrices, then $L$ is commutative.

Proof 5.7**.**

Let $w\in L$ and suppose that the string $w=w_{[1]}w_{[2]}\cdots w_{[n]}$ is accepted by $H$. Let $A_{1}A_{2}\cdots A_{n}$ be the product of the matrices labeling the computation such that

[TABLE]

where $v_{0}$ is the initial vector of $H$. Since the matrices are commutative, then for any permutation $\tau$,

[TABLE]

This leads to the acceptance of the string $w^{\prime}=w_{[\tau(1)]}w_{[\tau(2)]}\cdots w_{[\tau(n)]}$ since

[TABLE]

Hence, if $w$ is accepted by $H$, then any string obtained from $w$ by permuting its letters is also accepted by $H$. Any string $x$ with $\phi(x)=\phi(w)$ is in $L$ and we conclude that $L$ is commutative.

When the computation is not blind, then the class of languages recognized is no longer commutative. The language of balanced strings of brackets $\mathtt{DYCK}$ can be recognized by 0-DHVA(1) as follows. Starting with the initial vector $(1)$, for each left bracket the vector is multiplied by $(2)$. As long as the vector is not equal to (1), for each right bracket, the vector is multiplied by ($\frac{1}{2}$). If the vector is equal to $(1)$ and the next symbol is a right bracket, then the vector is set to (0).

Corollary 5.8**.**

If a language $L$ is recognized by a 0-NBHVA $H$ with a commutative set of matrices, then $L=L^{r}$.

Proof 5.9**.**

Suppose that $w\in L$. Then it is clear that $w^{r}$ will be also accepted by $H$ by Theorem 5.6 and $w^{r}\in L$. Since for every string $w$ it is true that $w\in L$ if and only if $w^{r}\in L$, we conclude that $L=L^{r}$.

We now focus on stateless HVAs whose vectors have dimension 1 and demonstrate some results on stateless FAMWs. Note that stateless FAMs do not process the end-marker \$$ by definition, since their single state is also an accept state and the computation ends once $$ is scanned in an accept state.

We start by comparing the class of languages recognized by stateless versions of deterministic and blind finite automata with multiplication, and 1-dimensional homing vector automata. The capability of multiplication with negative rational numbers brings additional power to the stateless DBHVA(1)s.

Theorem 5.10**.**

$\mathfrak{L}\textup{(0-DFAMW)}\subsetneq\mathfrak{L}\textup{(0-DBHVA(1))}.$**

Proof 5.11**.**

Let $\mathtt{EVENAB}=\{a^{n}b^{n}|~{}n=2k\mbox{ for some }k\geq 0\}$. The following 0-DBHVA(1) recognizes $\mathtt{EVENAB}$: The register is multiplied by $(-2)$ and $(\frac{1}{2})$ when the machine reads an $a$ and $b$ respectively.

Suppose that there exists some 0-1DFAMW recognizing $\mathtt{EVENAB}$. Let $m_{a}$ and $m_{b}$ be the positive rational numbers that are multiplied by the register upon reading $a$ and $b$. Since $aabb\in\mathtt{EVENAB}$, it is true that $m_{a}^{2}m_{b}^{2}=1$. Since both $m_{a}$ and $m_{b}$ are positive, it is not possible that $m_{a}m_{b}=-1$. It follows that $m_{a}m_{b}=1$, in which case the string $ab$ is accepted and we get a contradiction. Hence we conclude that $\mathtt{EVENAB}$ cannot be recognized by any 0-DFAMW.

When the register is multiplied with only positive rational numbers, then we have $\mathfrak{L}$(0-DFAMW)=$\mathfrak{L}$(0-DBHVA(1))${}_{\mathbb{Q^{+}}}$. The equivalences also hold for the nondeterministic models.

For real-time, nondeterministic and blind machines, we can state the following theorem.

Theorem 5.12**.**

If $L\in\mathfrak{L}(\textup{0-NFAMW})$, then $L$ is commutative.

Proof 5.13**.**

A 0-NFAMW is a 0-NBHVA(1) whose register is multiplied with only positive rational numbers. Therefore, $L$ is also accepted by a 0-NBHVA(1). Since multiplication in dimension 1 is commutative, the result follows by Theorem 5.6.

It is known that a bounded language is accepted by a 1NFAMW iff it is semilinear [12]. In the next theorem, we prove a similar result and characterize the class of languages recognized by 0-DFAMWs. We show that any language recognized by a 0-DFAMW is commutative and semilinear. Furthermore, any commutative language whose Parikh image is the set of nonnegative solutions to a system of linear homogeneous Diophantine equations can be recognized by a 0-DFAMW.

Theorem 5.14**.**

$L\in\mathfrak{L}(\textup{0-DFAMW})$* iff $L$ is commutative and $\phi(L)$ is the set of nonnegative integer solutions to a system of linear homogeneous Diophantine equations.*

Proof 5.15**.**

Let $L$ be a language over the alphabet $\Sigma=\{\sigma_{1},\dots,\sigma_{n}\}$ recognized by a 0-DFAMW $V$. Let $M=\{m_{1},m_{2},\dots,m_{n}\}$ be the set of rational numbers such that the register is multiplied with $m_{i}$ upon reading $\sigma_{i}$. Let $P=\{p_{1},p_{2},\dots,p_{k}\}$ be the set of prime factors of the denominators and the numerators of the rational numbers in $M$. Then each $m_{i}$ can be expressed as

[TABLE]

If a string $w$ is accepted by $V$, then the value of the register should be equal to 1 after reading $w$, which is possible only if

[TABLE]

This leads to the following system of linear Diophantine equations in $n$ variables.

[TABLE]

For $j=1,\dots,k$, the $j$’th equation is stating that the exponent of $p_{j}$ is equal to 0 after reading $w$.

Hence, we can conclude that the Parikh images of the accepted strings are the nonnegative solutions to a system of linear homogeneous Diophantine equations. $L$ is commutative by Theorem 5.12. (One can further conclude that $L$ is semilinear.)

For the converse, suppose that we are given a commutative language $L$ over the alphabet $\Sigma=\{\sigma_{1},\dots,\sigma_{n}\}$. Let $S$ be the set of Parikh images of the strings in $L$. $S$ is the set of nonnegative solutions to a system of, say, $k$ linear homogeneous Diophantine equations in $n$ unknowns,

[TABLE]

where $\left(s_{1}~{}~{}~{}s_{2}~{}~{}~{}\dots~{}~{}~{}s_{n}\right)\in S$.

We construct a 0-DFAMW $V$ recognizing $L$ as follows. We choose a set of $k$ distinct prime numbers, $P=\{p_{1},p_{2},\dots,p_{k}\}$. When $V$ reads $\sigma_{i}$, the register is multiplied by

[TABLE]

Suppose that a string $w$ is accepted by $V$. Then

[TABLE]

The product is equal to 1 if all of the exponents of the prime factors are equal to 0, that is when $\left(w_{|\sigma_{1}|}~{}~{}~{}w_{|\sigma_{2}|}~{}~{}~{}\dots~{}~{}~{}w_{|\sigma_{n}|}\right)\in S$. Hence we see that the set of accepted strings are those with Parikh image in $S$. Since $L$ is commutative, any string $w$ with $\phi(w)\in S$ belongs to $L$ and we conclude that $V$ recognizes $L$.

Note that $\mathfrak{L}$(0-DFAMW)=$\mathfrak{L}$(0-1DFAMW), since a 0-1DFAMW that has an instruction to stay on some input symbol cannot read the rest of the string.

5.2 Regular languages

Let $D$ be an $n$-state deterministic finite automaton. Without loss of generality, we can enumerate its states as $q_{1},\ldots,q_{n}$ where $q_{1}$ is the initial state. Moreover we can denote $q_{i}$ by $e_{i}$, which is the basis vector in dimension $n$ having 1 in its $i$’th entry, and 0 otherwise. Besides, for each symbol $\sigma$, we can design a zero-one matrix, say $A_{\sigma}$, that represents the transitions between the states, i.e. $A_{\sigma}(i,j)=1$ if and only if $D$ switches from $q_{i}$ to $q_{j}$ when reading symbol $\sigma$. Thus, the computation of $D$ on an input, say $w$, can be traced by matrix-vector multiplication:

[TABLE]

if and only if $D$ ends its computation in $q_{j}$ after reading $w$.

Based on this representation, we can easily observe that if a language $L$ is recognized by an $n$-DFA whose initial state is the single accept state, then $L$ is recognized by a 0-DBHVA($n$).

Let us give some examples of stateless HVAs recognizing regular languages.

Example 1: Let $\mathtt{AB_{k}}^{*}=\{a^{k}b^{k}\}^{*}$ for a given $k>1$, and let us construct a 0-DBHVA(2$k$) $H_{k}$ recognizing $\mathtt{AB_{k}}^{*}$. The initial vector of $H_{k}$ is $v_{0}=(1~{}~{}0~{}~{}\cdots~{}~{}0)$. For each $a$, the value in the $i$’th entry of the vector is transferred to the $(i+1)$’st entry when $1\leq i\leq k$, and, the rest of the entries are set to 0. For each $b$, the value in the $(i+k)$’th entry of the vector is transferred to the $(i+k+1\mod 2k)$’th entry, and the rest of the entries are set to 0, ($1\leq i\leq k$). Thus, we return to the initial vector if and only if after some number of $(a^{k}b^{k})$ blocks have been read.

Example 2: The language $\mathtt{MOD_{m}}$ is defined as $\mathtt{MOD_{m}}=\{a^{i}\mid i\mod m\equiv 0\}.$ It is easy to observe that any unary $n$-state DFA whose initial state is the single accept state can recognize either $L_{\varepsilon}$ or $\mathtt{MOD_{m}}$ for some $m\leq n$. Hence, for any $m>0$, the language $\mathtt{MOD_{m}}$ is recognized by a 0-DBHVA($m$).

Note that if it is allowed to use arbitrary algebraic numbers in the transition matrices, then for every $m>0$, the language $\mathtt{MOD_{m}}$ is recognized by a 0-DBHVA(2) with initial vector $v_{0}=\left(1~{}~{}0\right)$ that multiplies its vector with the matrix

[TABLE]

for each scanned symbol. (The entries of $A_{m}$ are algebraic for any $m$ [15].)

One may ask whether all regular languages $L$ satisfying $L=L^{*}$ can be recognized by stateless HVAs. We provide a negative answer for the deterministic model. The language $\mathtt{MOD23}$ is defined as $\{a^{2},a^{3}\}^{*}=a^{*}\setminus\{a\}$, satisfying that $\mathtt{MOD23}=\mathtt{MOD23}^{*}$. $\mathtt{MOD23}$ cannot be recognized by any 0-DHVA since a 0-DHVA which accepts $a^{2}$ and $a^{3}$, also accepts $a$ by Lemma 5.1.

5.3 Additional results on stateless homing vector automata

One sees that the nonregular language $\mathtt{AB}=\{a^{n}b^{n}|n\geq 0\}$ cannot be recognized by any 0-NHVA($k$) for any $k$, since $\mathtt{AB}\neq\mathtt{AB}^{*}$. On the other hand, $\mathtt{EQ}=\{x\in\{a,b\}^{*}\mid|x|_{a}=|x|_{b}\}$ can be recognized by a 0-DBHVA(1) with initial vector $(1)$, and transition matrices $A_{a}=(2)$ and A_{b}=\left(\begin{array}[]{c}\frac{1}{2}\end{array}\right). In the next theorem, we show that it is possible to recognize the star of $\mathtt{AB}$, even in the deterministic and blind computation mode with a stateless homing vector automaton. Note that $\mathtt{AB}^{*}$ cannot be recognized by any 1NFAMW [12].

Theorem 5.16**.**

The language $\mathtt{AB}^{*}=\{\{a^{n}b^{n}\}^{*}\mid n\geq 0\}$ is recognized by a 0-DBHVA(10).

Proof 5.17**.**

We are going to construct a 0-DBHVA(10) recognizing $\mathtt{AB}^{*}$. We start with a 0-DBHVA(3) named $H$, whose initial vector is $v_{0}=(1~{}~{}0~{}~{}0)$. When reading a symbol $a$, $H$ applies the matrix

[TABLE]

which maps $(1~{}~{}t_{2}~{}~{}t_{3})$ to $(1~{}~{}2t_{2}+1~{}~{}0)$. This operator encodes the count of $a$’s in the value of the second entry. Started with the initial vector, if $H$ reads $i$ $a$’s, the vector becomes $(1~{}~{}2^{i}-1~{}~{}0)$.

When reading a symbol $b$, $H$ applies the matrix

[TABLE]

that sets the value of the second entry to 0 and decrements the counter mentioned above, which it maintains in the third entry. A vector starting as $(1~{}~{}2^{i}-1~{}~{}0)$ would get transformed to $(1~{}~{}0~{}~{}2^{i-j}-1)$ after reading $j$ $b$’s.

Note that the third entry is different than 0 when the number of $a$’s and $b$’s do not match in a block. If symbol $a$ is read after a block of $b$’s, the counting restarts from 0, and the value of the third entry is again set to 0.

By tensoring $H$ with itself, we obtain a 0-DBHVA(9). The initial vector of this new machine is $v_{0}\otimes v_{0}$, and its operators are $A_{a}\otimes A_{a}$ and $A_{b}\otimes A_{b}$.

Based on this tensor machine, we define our final 0-DBHVA(10), say, $H^{\prime}$. The initial vector is $v_{0}^{\prime}=(v_{0}\otimes v_{0}~{}~{}0)=(1~{}~{}0~{}~{}\cdots~{}~{}0).$

$H^{\prime}$* applies the matrices $A_{a}^{\prime}$ and $A_{b}^{\prime}$ for each scanned $a$ and $b$, respectively:*

[TABLE]

The matrix $A_{a}^{\prime}$ implements $A_{a}\otimes A_{a}$ in its first nine entries. Additionally, it adds the value of the ninth entry of the vector to the tenth one. The operator $A_{b}^{\prime}$ implements $A_{b}\otimes A_{b}$ in its first nine entries. Additionally, it preserves the value of the tenth entry. Suppose that the vector of $H$ is equal to $(1~{}~{}a_{2}~{}~{}a_{3})$ at some point of the computation. Due to the property of the tensor product, the vector entries of $H^{\prime}$ hold the values $(1~{}~{}a_{2}~{}~{}a_{3}~{}~{}a_{2}~{}~{}a_{2}a_{2}~{}~{}a_{2}a_{3}~{}~{}a_{3}~{}~{}a_{3}a_{2}~{}~{}a_{3}a_{3}~{}~{}1)$.

The value of the third entry is important as it becomes nonzero when the number of $a$’s and $b$’s are different in a block. Hence, the ninth entry holds some positive value when this is the case. When $H^{\prime}$ starts reading a new block of $a$’s, it adds the ninth entry to the tenth one with the help of the matrix $A_{a}^{\prime}$. Once this entry is set to a positive value, it never becomes 0 again, since its value can only be changed by the addition of the ninth entry, which is always a square of a rational number. Therefore, such an input is never accepted.

If this is not the case and the number of $a$’s and $b$’s are equal to each other in every block, then the third and therefore the ninth entry are always equal to 0 before $H^{\prime}$ starts reading a new block. We can conclude that the value of the tenth entry will be equal to 0 at the end of the computation. As the input string ends with a $b$, the second entry is also set to 0 upon multiplication with $A_{b}^{\prime}$. Hence, all the entries except the first one are equal to 0 and the vector is equal to its initial value which leads to the acceptance of the input string.

Thus, the only accepted inputs are the members of $\mathtt{AB}^{*}$.

Nondeterministic HVAs are more powerful than their deterministic variants in terms of language recognition in general. In the next theorem, we show that this is also true for the stateless models.

Theorem 5.18**.**

1. i.

$\mathfrak{L}\textup{(0-DBHVA)}\subsetneq\mathfrak{L}\textup{(0-NBHVA)}.$** 2. ii.

$\mathfrak{L}\textup{(0-DHVA)}\subsetneq\mathfrak{L}\textup{(0-NHVA)}.$**

Proof 5.19**.**

Let us construct a 0-NBHVA(1) $H$ recognizing $\mathtt{LEQ}=\{x\in\{a,b\}^{*}\mid|x|_{a}\leq|x|_{b}\}$. Starting with the initial vector $(1)$, $H$ multiplies its vector with $A=(2)$ for each $a$ and with $B_{1}=(\frac{1}{2})$ or $B_{2}=(1)$ for each $b$ nondeterministically.

Suppose that $\mathtt{LEQ}$ can be recognized by a 0-DHVA($k$) $H^{\prime}$. The strings $w_{1}=b$ and $w_{2}=ba$ are accepted by $H^{\prime}$. By Lemma 5.1, the string $w_{3}=a$ is also accepted by $H^{\prime}$. We obtain a contradiction, and conclude that $\mathtt{LEQ}$ cannot be recognized by any 0-DHVA($k$).

Let us look at some closure properties for the stateless models. All of the stateless models are closed under the star operation since for any language recognized by a stateless homing vector automaton, it is true that $L=L^{*}$.

Theorem 5.20**.**

*i. $\mathfrak{L}\textup{(0-DBHVA)}$ is closed under the following operation:

a) intersection

ii. $\mathfrak{L}\textup{(0-DBHVA)}$ and $\mathfrak{L}\textup{(0-DHVA)}$ are not closed under the following operations:

a) union

b) complement

c) concatenation*

Proof 5.21**.**

*i. a) The proof in [19] that DBHVAs are closed under intersection is also valid for stateless models.

ii. a) The languages $\mathtt{MOD_{2}}$ and $\mathtt{MOD_{3}}$ are recognized by 0-DBHVAs by Example 5.2. Their union cannot be recognized by any 0-DHVA, since a 0-DHVA accepting the strings $a^{2}$ and $a^{3}$ should also accept the non-member string $a$ by Lemma 5.1.

b) Complement of the language $\mathtt{MOD_{m}}$ ($m>1$)is not recognized by any 0-NHVA, since $\overline{\mathtt{MOD_{m}}}$ contains $a$ and any 0-NHVA accepting $a$ accepts any member of $a^{*}$.

c) The languages $\mathtt{MOD_{2}}$ and $\mathtt{MOD_{3}}$ are recognized by 0-DBHVAs by Example 5.2. Their concatenation $\mathtt{MOD23}$ cannot be recognized by any 0-DHVA.*

$\mathfrak{L}\textup{(0-NBHVA)}$ is closed under intersection. $\mathfrak{L}\textup{(0-NBHVA)}$ and $\mathfrak{L}\textup{(0-NHVA)}$ are not closed under complement. The proofs are identical.

6 Open questions and future work

We proved that 1NBHVAs are more powerful than extended finite automata when both are defined over $2\times 2$ integer matrices. Is this result still true when both models are defined over $3\times 3$ integer matrices?

Do 0-NHVAs recognize every regular language $L$ satisfying $L=L^{*}$? Is there any nonregular language $L$ satisfying $L=L^{*}$ that cannot be recognized by any stateless HVA?

We proved that any language recognized by a 0-NFAMW is commutative. What can we say about the non-blind case?

We gave a characterization for the class of languages recognized by 0-DFAMW. Can we give a similar characterization for the non-blind and nondeterministic models?

Acknowledgments

This research was supported by Boğaziçi University Research Fund (BAP) under grant number 11760. Salehi is partially supported by TÜBİTAK (Scientific and Technological Research Council of Turkey). Yakaryılmaz is partially supported by ERC Advanced Grant MQC. We thank Flavio D’Alessandro for his helpful answers to our questions, and the anonymous reviewers for their constructive comments.