New Variants of Pattern Matching with Constants and Variables

TL;DR

This paper explores new variants of pattern matching problems involving constants and variables, proposing convolution and KMP-based algorithms with analyzed complexities for these problems.

Contribution

It introduces novel variants of pattern matching with constants and variables and provides two algorithmic solutions with complexity analysis.

Findings

Convolution-based algorithms for pattern matching variants

Extended KMP-based algorithms for pattern matching variants

Complexity analysis of proposed algorithms

Abstract

Given a text and a pattern over two types of symbols called constants and variables, the parameterized pattern matching problem is to find all occurrences of substrings of the text that the pattern matches by substituting a variable in the text for each variable in the pattern, where the substitution should be injective. The function matching problem is a variant of it that lifts the injection constraint. In this paper, we discuss variants of those problems, where one can substitute a constant or a variable for each variable of the pattern. We give two kinds of algorithms for both problems, a convolution-based method and an extended KMP-based method, and analyze their complexity.

Tables

Table 1. Table 1: The time complexity of our proposed algorithms

Problem	Convolution-based Method	Extended KMP-based Method
		Preprocessing	Query
PVC-matching	$O\left(\left|{\Sigma }_P\right|n\log m\right)$	$O\left(\left|{\Pi }_P\right|\left|{\Sigma }_P\right|m^2\right)$	$O\left(\left|{\Pi }_P\right|\lceil \frac{m}{w}\rceil n\right)$
FVC-matching		$O\left(\left|{\Pi }_P\right|\left(\left|{\Sigma }_P\right|+\left|{\Pi }_P\right|\right)m^2\right)$	$O\left({\left|{\Pi }_P\right|}^2\lceil \frac{m}{w}\rceil n\right)$

Table 2. Table 2: Definition of problems

Problems		Admissible mappings
		Type	Injection constraint
PVC-matching		$\Pi \to \left(\Pi \cup \Sigma \right)$	Yes
FVC-matching	[6]		No
parameterized matching	[4]	$\Pi \to \Pi$	Yes
function matching	[1]		No

Equations

$$\hat{\pi }(X)=\hat{\pi }(X[1])\hat{\pi }(X[2])\cdots \hat{\pi }(X[n]),\text{where }\hat{\pi }(X[i])=\{\begin{array}{ll}\pi (X[i])& (X[i]\in \Pi )\\ X[i]& (\mathrm{otherwise})\end{array}$$

$$V_{k,j}$$

$$E_{k,j}$$

$$r_{x,p}^k[j]$$

$$s_{x,y}^k[j]$$

$$r_{x,p}^k=r_{x,p}^k[0]r_{x,p}^k[1]\cdots r_{x,p}^k[k-1],$$

$$s_{x,y}^k=s_{x,y}^k[0]s_{x,y}^k[1]\cdots s_{x,y}^k[k-1].$$

$$J=\underset{x\in \Pi }{\bigwedge }{r}_{x,\pi (x)}^k\wedge \underset{\begin{array}{c}x,y\in \Pi \\ \pi (x)\ne \pi (y)\end{array}}{\bigwedge }{s}_{x,y}^k.$$

$$t_{x,p}^k[j]$$

$$t_{x,p}^k=t_{x,p}^k[0]t_{x,p}^k[1]\cdots t_{x,p}^k[k-1]$$

$$J=\underset{x\in \Pi }{\bigwedge }{t}_{x,\pi (x)}^k$$

Full text

1 Introduction

The parameterized pattern matching problem was proposed by Baker [4] about a quarter of a century ago. Problem instances are two strings called a pattern and a text, which are sequences of two types of symbols called constants and variables. The problem is to find all occurrences of substrings of a given text that a given pattern matches by substituting a variable in the text for each variable in the pattern, where the important constraint is that the substitution should be an injective map. She presented an algorithm for this problem that runs in $O(n\log{n})$ time using parameterized suffix trees, where $n$ is the length of text.

By removing the injective constraint from the parameterized pattern matching problem, Amir et al. [1] proposed the function matching problem, where the same variable may be substituted for different variables. Yet another but an inessential difference between parameterized pattern matching and function matching is in the alphabets. The function matching problem is defined to be constant-free in the sense that patterns and texts are strings over variables. However, this simplification is inessential, since it is known that the problem with variables and constants is linear-time reducible to the constant-free case [2]. This reduction technique works for the parameterized pattern matching as well. Their deterministic algorithm solves this problem in $O(|\Pi|n\log{m})$ time, where $n$ and $m$ are the lengths of the text and pattern, respectively, and $|\Pi|$ is the number of different symbols in the pattern. After that, Amir and Nor [3] introduced the generalized function matching problem, where one can substitute a string of arbitrary length for a variable. In addition, both a pattern and a text may contain “don’t care” symbols, which are supposed to match arbitrary strings.

The parameterized pattern matching problem and its extensions have been great interests not only to the pattern matching community [12] but also to the database community. Du Mouza et al. [6] proposed a variant of the function matching problem, where texts should consist solely of constants and a substitution maps variables to constants, which is not necessarily injective. Let us call their problem function matching with variables-to-constants, FVC-matching in short.111They called the problem parameterized pattern queries. However, to avoid misunderstanding the problem to have the injective constraint, we refrain from using the original name in this paper. The function matching problem is linear-time reducible to this problem by simply assuming the variables in a text as constants. Therefore, this problem can be seen as a generalization of the function matching problem. Unfortunately, as we will discuss in this paper, their algorithm is in error.

In this paper, we introduce a new variant of the problem by du Mouza et al. with the injective constraint, which we call parameterized pattern matching with variables-to-constants mapping (PVC-matching). For each of the FVC-matching and PVC-matching problems, we propose two kinds of algorithms222Source codes for those algorithms are available at

https://github.com/igarashi/matchingwithvcmap.: a convolution-based method and an extended KMP-based method. The convolution-based methods and extended KMP-based methods are inspired by the algorithm of Amir et al. [1] for the function matching problem and the one by du Mouza et al. [6] for the FVC-matching problem, respectively. As a result, we fix the flaw of the algorithm by du Mouza et al. The convolution-based methods for both problems run in $O(|\Sigma_{P}|n\log{m})$ time, where $\Sigma_{P}$ is the set of constant symbols that occur in the pattern $P$. Our KMP-based methods solve the PVC-matching and FVC-matching problems with $O(|\Pi|(|\Sigma_{P}|+|\Pi|)m^{2})$ and $O(|\Pi|n)$) preprocessing time and $O(|\Pi|\lceil\frac{m}{w}\rceil n)$ and $O(|\Pi_{P}|^{2}\lceil\frac{m}{w}\rceil n)$ query time, respectively, where $\Pi$ is the set of variables and $w$ is the word size of a machine (Table 1).

2 Preliminaries

For any set $Z$, the cardinality of $Z$ is denoted by $|Z|$. Let $\Sigma$ be an alphabet. We denote by $\Sigma^{*}$ the set of strings over $\Sigma$. The empty string is denoted by $\epsilon$. The concatenation of two strings $X,Y\in\Sigma^{*}$ is denoted by $XY$. For a string $X$, the length of $X=X[1]X[2]\cdots X[n]$ is denoted by $|X|=n$. The substring of $X$ beginning at $i$ and ending at $j$ is denoted by $X[i:j]=X[i]X[i+1]\cdots X[j-1]X[j]$. Any substrings of the form $X[1:j]$ and $X[i:n]$ are called a prefix and a suffix of $X$. For any number $k$, we define $X[k:k-1]=\epsilon$. The set of symbols from a subset $\Delta$ of $\Sigma$ occurring in $X$ is denoted by $\Delta_{X}=\{\,X[i]\in\Delta\mid 1\leq i\leq n\,\}$.

This paper is concerned with matching problems, where strings consist of two kinds of symbols, called constants and variables. Throughout this paper, the sets of constants and variables are denoted by $\Sigma$ and $\Pi$, respectively. Variables are supposed to be replaced by another symbol, while constants are not.

Definition 1

For a function $\pi:\Pi\to(\Sigma\cup\Pi)$, we extend it to $\hat{\pi}:(\Pi\cup\Sigma)^{*}\to(\Pi\cup\Sigma)^{*}$ by

[TABLE]

Parameterized match [4] and function match [1]333Amir et al. [1] defined the problem so that strings are over a single type of symbols, which can be seen as variables. This restriction is inessential [2]. are defined as follows.

Definition 2

Let $P$ and $Q$ be strings over $\Sigma\cup\Pi$ of the same length. String $P$ is said to parameterized match (resp. function match) string $Q$ if there exists an injection (resp. function) $\pi:\Pi\to\Pi$, such that $\hat{\pi}(P)=Q$.

The parameterized pattern matching problem (resp. function matching problem) is to find all occurrences of substrings of a given text that a given pattern parameterized match (resp. function match).

The problems we discuss in this paper allow variables to be mapped to constants and variables.

Definition 3

Let $P$ and $Q$ be strings over $\Sigma\cup\Pi$ of the same length. String $P$ is said to parameterized match with variables-to-constants mapping (resp. function match with variables-to-constants mapping), shortly PVC-match (resp. FVC-match), string $Q$ if there exists an injection (resp. function) $\pi:\Pi\to(\Sigma\cup\Pi)$, such that $\hat{\pi}(P)=Q$.

Problem 1

Let $P$ and $T$ be strings over $\Sigma\cup\Pi$ of length $m$ and $n$, respectively. The parameterized pattern matching problem with variables-to-constants mapping (resp. function matching problem with variables-to-constants mapping), shortly PVC-matching (resp. FVC-matching) asks for all the indices $i$ where pattern $P$ PVC-matches (resp. FVC-matches) substring $T[i:i+m-1]$ of text $T$.

Table 2 summarizes those four problems.

We can assume without loss of generality that the text $T$ solely consists of constants. This restriction is inessential since one can regard variables occurring in $T$ as constants. Under this assumption, the FVC-matching problem is exactly parameterized pattern queries [6].

Example 1

Let $\Sigma=\{\texttt{a},\texttt{b}\}$ and $\Pi=\{\texttt{A},\texttt{B}\}$. Consider pattern $P=\texttt{ABAb}$ and text $T=\texttt{ababbbb}$. Then, the answer of PVC-matching problem is $\{1,2\}$, since $P$ PVC-matches $T[1:4]=\texttt{abab}$, $T[2:5]=\texttt{babb}$. On the other hand, the answer of FVC-matching problem is $\{1,2,4\}$ since $P$ FVC-matches $T[1:4]=\texttt{abab}$, $T[2:5]=\texttt{babb}$, $T[4:7]=\texttt{bbbb}$. Note that we have $\hat{\pi}(P)=T[4:7]$ for $\pi$ with $\pi(\mathtt{A})=\pi(\mathtt{B})=\mathtt{b}$, which is not injective.

Throughout this paper, we arbitrarily fix a pattern $P\in(\Sigma\cup\Pi)^{*}$ of length $m$ and a text $T\in\Sigma^{*}$ of length $n$.

3 Convolution-based Methods

In this section, we show that the FVC-matching problem can be solved in $O(|\Sigma_{P}|n\log{m})$ time by reducing the problem to the function matching problem and the wildcard matching problem, for which several efficient algorithms are known. The PVC-matching problem can also be solved using the same reduction technique with a slight modification.

For strings $P$ of length $m$ over $\Sigma\cup\Pi$ and $T$ of length $n$ over $\Sigma$, we define $\Pi^{\prime}=\Pi_{P}\cup\Sigma_{T}$. Let $P_{\!\!{\tt\ast}}\in(\Sigma\cup\{{\tt\ast}\})^{*}$ be a string obtained from $P$ by replacing all variable symbols in $\Pi$ with don’t care symbol ${\tt\ast}$. Let $P_{\!\Pi}\in\Pi^{\prime*}$ be a string obtained from $P$ by removing all constant symbols in $\Sigma$. Moreover, for $1\leq i<n-m$, let $T^{\prime}_{i}$ be a string defined by $T^{\prime}_{i}=v(1)v(2)\cdots v(m)$, where $v(j)=T[i+j-1]$ if $P[j]\in\Pi$ and $v(j)=\epsilon$ otherwise. Note that both the lengths of $T^{\prime}_{i}$ and $P_{\!\Pi}$ are equal to the total number of variable occurrences in $P$.

Example 2

For $T={\tt aabcbc}$ and $P={{\tt A}{\tt a}{\tt B}{\tt B}{\tt b}}$ over $\Pi=\{{\tt A},{\tt B}\}$ and $\Sigma=\{{\tt a},{\tt b},{\tt c}\}$, we have $P_{\!\!{\tt\ast}}={\tt\ast}{\tt a}{\tt\ast}{\tt\ast}{\tt b}$, $P_{\!\Pi}={\tt A}{\tt B}{\tt B}$, $T^{\prime}_{1}={\tt a}{\tt b}{\tt c}$, and $T^{\prime}_{2}={\tt a}{\tt c}{\tt b}$.

For both FVC-matching and PVC-matching problems, the following lemma is useful to develop algorithms to solve them.

Lemma 1

$P$* FVC-matches (resp. PVC-matches) $T[i:i+m-1]$ if and only if*

$P_{\!\!{\tt\ast}}$* wildcard matches $T[i:i+m-1]$, and* 2. 2.

$P_{\!\Pi}$* function matches (resp. parameterized matches) $T^{\prime}_{i}$.*

Lemma 1 suggests that the FVC-problem would be reducible to the combination of wildcard matching problem and function matching problem.

The wildcard matching problem (a.k.a. Pattern matching with don’t care symbol) [7] is one of the fundamental problems in pattern matching. There are many algorithms for solving the wildcard matching problem. Fischer et al. [7] gave an algorithm for (a generalization of) this problem, which runs in $O({|\Sigma|}n\log{m})$ time. Cole and Hariharan [5] improved it to $O(n\log{m})$ time by using convolution. On the other hand, Pinter [13] gave an $O(n+m+\alpha)$-time algorithm, where $\alpha$ is the total number of occurrences of the maximal consecutive constant substrings of the pattern in the text. This algorithm uses Aho-Corasick algorithm instead of convolution. Iliopoulos and Rahman [10] proposed an algorithm which utilizes suffix arrays for text. The algorithm preprocesses a text in $O(n)$ time and runs in $O(m+\alpha)$ time.

However, Lemma 1 does not imply the existence of a single string $T^{\prime}$ such that $P$ FVC-matches $T[i:i+m-1]$ if and only if $P_{\!\!{\tt\ast}}$ wildcard matches $T[i:i+m-1]$ and $P_{\!\Pi}$ function matches $T^{\prime}[i:i+m-1]$. A naive application of Lemma 1 to compute $T^{\prime}_{i}$ explicitly for each $i$ requires $O(mn)$ time in total.

We will present an algorithm to check whether $P_{\!\Pi}$ function matches (parameterized matches) $T^{\prime}_{i}$ for all $1\leq i<n-m$ in $O(\log{|\Sigma|}\,n\log{m})$ time in total. Without loss of generality, we assume that $\Sigma$ and $\Pi$ are disjoint finite sets of positive integers in this section, and for integers $a$ and $b$, the notation $a\cdot b$ represents the multiplication of $a$ and $b$ but not the concatenation.

Definition 4

For integer arrays $A$ of length $n$ and $B$ of length $m$, we define an integer array $R$ by $R[j]=\sum_{i=1}^{m}{A[i+j-1]\cdot B[i]}$ for $1\leq j\leq n-m+1$. We denote $R$ as $A\otimes B$.

In a computational model with word size $O(\log{m})$, the discrete convolution can be computed in time $O(n\log{n})$ by using the Fast Fourier Transform (FFT) [8]. The array $R$ defined in Definition 4 can also be computed in the same time complexity by just reversing array $B$.

Amir et al. [1] proved the next lemma for function matching.

Lemma 2** ([1])**

*For any natural numbers $a_{1},\cdots,a_{k}$, the equation

$k\!\cdot\!\sum_{i=1}^{k}{(a_{i})^{2}}=(\sum_{i=1}^{k}{a_{i}})^{2}$ holds if and only if $a_{i}=a_{j}\mbox{ for any }1\leq i,j\leq k$.*

Let T be the string of length $n$ such that ${\textit{{T}}}[i]=(T[i])^{2}$ for every $1\leq i\leq n$. For a variable $x\in\Pi_{P}$, let $c_{x}$ denote the number of occurrences of $x$ in $P$, and let $P_{x}$ be the string of length $m$ such that $P_{x}[j]=1$ if $P[j]=x$ and $P_{x}[j]=0$ otherwise, for every $1\leq j\leq m$. By Lemma 2, we can prove the following lemma.

Lemma 3

All the symbols (values) in $T^{\prime}_{i}$ at every position $j$ satisfying $P_{\!\Pi}[j]=x$ are the same, if and only if the equation $c_{x}\!\cdot\!(({\textit{{T}}}\otimes P_{x})[i])=((T\otimes P_{x})[i])^{2}$ holds.

Thus, $P_{\!\Pi}$ function matches $T^{\prime}_{i}$ if and only if the equation in Lemma 3 holds for all $x\in\Pi_{P}$. Both the convolutions ${\textit{{T}}}\otimes P_{x}$ and $T\otimes P_{x}$ can be calculated in $O(n\log{m})$ time by simply dividing $T$ into $2\times\frac{n}{2m}$ overlapping substrings of length $2m$. For parameterized pattern matching problem, we have only to check additionally whether the value ${(T\otimes P_{x})[i]}/c_{x}$ is unique among all $x\in\Pi_{P}$. A pseudo code for solving the PVC-matching problem using convolution is shown as Algorithm 1 in Appendix A.

Theorem 1

The FVC-matching problem and PVC-matching problem can be solved in $O(|\Sigma_{P}|\,n\log{m})$ time.

4 KMP-based Methods

Du Mouza et al. proposed a KMP-based algorithm for the FVC-matching problem, which, however, is in error. In this section, we propose a correction of their algorithm, which runs in $O(|\Pi|^{2}\lceil\frac{m}{w}\rceil n)$ query time with $O(|\Pi|(|\Sigma_{P}|+|\Pi|)m^{2})$ preprocessing time, where $w$ denotes the word size of a machine. This algorithm will be modified so that it solves the PVC-matching problem in $O(|\Pi|\lceil\frac{m}{w}\rceil n)$ query time with $O(|\Pi||\Sigma_{P}|m^{2})$ preprocessing time.

The KMP algorithm [11] solves the standard pattern matching problem in $O(n)$ time with $O(m)$ preprocessing time. We say that a string $Y$ is a border of $X$ if $Y$ is simultaneously a prefix and a suffix of $X$. A border $Y$ is nontrivial if $Y$ is not $X$ itself. For the preprocessing of the KMP algorithm, we calculate the longest nontrivial border $b_{k}$ for each prefix $P[1:k]$ of pattern $P$, and store them as border array $B[k]=|b_{k}|$ for each $0\leq k\leq m$. Note that $b_{0}=b_{1}=\epsilon$. In the matching phase, the KMP algorithm compares symbols $T[i]$ and $P[k]$ from $i=k=1$. We increment $i$ and $k$ if $T[i]=P[k]$. Otherwise we reset the index for $P$ to be $k^{\prime}=B[k-1]+1$ and resume comparison from $T[i]$ and $P[k^{\prime}]$.

4.1 Extended KMP Algorithm

This subsection discusses an algorithm for the FVC-matching problem. In the matching phase, our extended KMP algorithm compares the pattern and a substring of the text in the same manner as the classical KMP algorithm except that we must maintain a function by which prefixes of the pattern match some substrings of the text. That is, our extended KMP algorithm compares symbols $T[i]$ and $P[k]$ from $i=k=1$ with the empty function $\pi$. If $P[k]$ is not in the domain $\mathrm{dom}(\hat{\pi})$ of $\hat{\pi}$, we expand $\pi$ by letting $\pi(P[k])=T[i]$ and increment $i$ and $k$. If $\hat{\pi}(P[k])$ is defined to be $T[i]$, we increment $i$ and $k$. Otherwise, we say that a mismatch occurs at position $k$ with a function $\pi$. Note that the mismatch position refers to that of $P$ rather than $T$. When we find a mismatch, we must calculate the appropriate position $j$ of $P$ and function $\pi^{\prime}$ with which we resume comparison. If instances are variable-free, the position is solely determined by the longest border size of $P[1:k]$ and we have no function. In the case of FVC-matching, the resuming position depends on the function $\pi$ in addition to $k$.

Example 3

Let us consider the pattern $P=\mathtt{AABaaCbC}$ where $\Pi=\{{\tt A},{\tt B},{\tt C}\}$ and $\Sigma=\{{\tt a},{\tt b}\}$ in Fig. 1. If the concerned substring of the text is $T^{\prime}=\mathtt{bbbaaabb}$, a mismatch occurs at $k=8$ with a function $\pi$ such that $\pi(\mathtt{A})=\pi(\mathtt{B})=\mathtt{b}$ and $\pi(\mathtt{C})=\mathtt{a}$. In this case, we can resume comparison with $P[7]$ and $T^{\prime}[8]$, since we have $\hat{\pi}^{\prime}(P[1:6])=T^{\prime}[2:7]$ for $\pi^{\prime}$ such that $\pi^{\prime}(\mathtt{A})=\pi^{\prime}(\mathtt{C})=\mathtt{b}$ and $\pi^{\prime}(\mathtt{B})=\mathtt{a}$. On the other hand, for $T^{\prime\prime}=\mathtt{bbaaaabb}$, the first mismatch occurs again at $k=8$ with a function $\rho$ such that $\rho(\mathtt{A})=\mathtt{b}$ and $\rho(\mathtt{B})=\rho(\mathtt{C})=\mathtt{a}$. In this case, one cannot resume comparison with $P[7]$ and $T^{\prime\prime}[8]$, since there is no $\rho^{\prime}$ such that $\hat{\rho}^{\prime}(P[1:6])=T^{\prime\prime}[2:7]$, since $P[1]=P[2]$ but $T^{\prime\prime}[2]\neq T^{\prime\prime}[3]$. We should resume comparison between $P[4]$ and $T^{\prime\prime}[8]$ with $\rho^{\prime}$ such that $\rho^{\prime}(\mathtt{A})=\mathtt{a}$ and $\rho^{\prime}(\mathtt{B})=\mathtt{b}$, for which we have $\hat{\rho}^{\prime}(P[1:3])=T^{\prime\prime}[5:7]$. Note that $\rho^{\prime}(\mathtt{C})$ is undefined.

The goal of the preprocessing phase is to prepare a data structure by which one can efficiently compute the failure function in the matching phase:

• Input: the position $k+1$ (where a mismatch occurs) and a function $\pi$ whose domain is $\Pi_{P[1:k]}$,
• Output: the largest position $j+1<k+1$ (at which we will resume comparison) and the function $\pi^{\prime}$ with domain $\Pi_{P[1:j]}$ such that $\hat{\pi}^{\prime}(P[1:j])=\hat{\pi}(P[k-j+1:k])$.

We call such $\pi$ a preceding function, $\pi^{\prime}$ a succeeding function and the pair $(\pi,\pi^{\prime})$ a $(k,j)$-shifting function pair. The substrings $P[1:j]$ and $P[k-j+1:k]$ may not be a border of $P[1:k]$ but under preceding and succeeding functions they play the same role as a border plays in the classical KMP algorithm. The succeeding function $\pi^{\prime}$ is uniquely determined by a preceding function $\pi$ and positions $k,j$. The condition that functions $\pi$ and $\pi^{\prime}$ form a $(k,j)$-shifting function pair can be expressed using the $(k,j)$-shifting graph (on $P$), defined as follows.

Definition 5

Let $\Pi^{\prime}$ be a copy of $\Pi$ and $P^{\prime}$ be obtained from $P$ by replacing every variable in $\Pi$ with its copy in $\Pi^{\prime}$. For two numbers $k,j$ such that $0\leq j<k\leq m$, the $(k,j)$-shifting graph $G_{k,j}=(V_{k,j},E_{k,j})$ is defined by

[TABLE]

We say that $G_{k,j}$ is invalid if there are distinct $p,q\in\Sigma_{P}$ that belong to the same connected component. Otherwise, it is valid.

Note that $G_{k,0}=(\Sigma_{P},\emptyset)$ is valid for any $k$. Figure 2 shows the $(7,6)$-shifting and $(7,3)$-shifting graphs for $P=\mathtt{AABaaCbC}$ in Example 3.

Using functions $\pi$ and $\pi^{\prime}$ whose domains are $\textrm{dom}(\pi)=\Pi_{P[k-j+1:k]}$ and $\textrm{dom}(\pi^{\prime})=\Pi_{P[1:j]}$, respectively, let us label each node $p\in\Sigma$, $x\in\Pi$, $x^{\prime}\in\Pi^{\prime}$ of $G_{k,j}$ with $p,\pi(x),\pi^{\prime}(x)$, respectively. Then $(\pi,\pi^{\prime})$ is a $(k,j)$-shifting pair if and only if every node in each connected component has the same label. Obviously $G_{k,j}$ is valid if and only if it admits a $(k,j)$-shifting function pair.

Thus, the resuming position should be $j+1$ for a mismatch at $k+1$ with a preceding function $\pi$ if and only if $j$ is the largest such that $G_{k,j}$ is valid and

• (a)

if $x\in\Pi$ and $p\in\Sigma$ are connected in $G_{k,j}$, then ${\pi}(x)=p$,

• (b)

if $x\in\Pi$ and $y\in\Pi$ are connected in $G_{k,j}$, then ${\pi}(x)=\pi(y)$.

In that case, we have $\hat{\pi}^{\prime}(P[1:j])=\hat{\pi}(P[k-j+1:k])$ for $\pi^{\prime}$ determined by

• (c)

$\pi^{\prime}(x)=\hat{\pi}(y)$ if $x^{\prime}\in\Pi^{\prime}_{P[1:j]}$ and $y\in\Pi\cup\Sigma$ are connected.

We call the conditions (a) and (b) the $(k,j)$-preconditions and (c) the $(k,j)$-postcondition. Note that every element in $\Pi^{\prime}_{P^{\prime}[1:j]}$ is connected to some element in $\Pi_{P[k-j+1:k]}\cup\Sigma_{P}$ in $G_{k,j}$ and thus $\pi^{\prime}$ is well-defined.

Remark 1

The algorithm by du Mouza et al. [6] does not treat the condition induced by two nodes of distance more than 1 correctly. For example, let us consider the pattern $P=\mathtt{AABaaCbC}$ in Example 3. For a text $T=\mathtt{bbaaaabbb}$, the first mismatch occurs at $k=8$, where $\hat{\rho}(P[1:7])=\mathtt{bbaaaab}$ for $\rho(\mathtt{A})=\mathtt{b}$ and $\rho(\mathtt{B})=\rho(\mathtt{C})=\mathtt{a}$. To have $(\rho,\rho^{\prime})$ a $(7,6)$-shifting pair for some $\rho^{\prime}$, it must hold $\rho(\mathtt{A})=\rho(\mathtt{B})$. That is, one can resume the comparison at position 6 only when the preceding function assigns the same constant to $\mathtt{A}$ and $\mathtt{B}$. The preceding function $\rho$ in this case does not satisfy this constraint. However, their algorithm performs this shift and reports that $P$ matches $T$ at position 2.

To efficiently compute the failure function, our algorithm constructs another data structure instead of shifting graphs. The shifting condition table is a collection of functions $A_{k,j}:\Pi_{P[k-j+1:k]}\to\Pi_{P[k-j+1:k]}\cup\Sigma_{P}$ and $A^{\prime}_{k,j}:\Pi^{\prime}_{P^{\prime}[1:j]}\to\Pi_{P[k-j+1:k]}\cup\Sigma_{P}$ for $1\leq j<k\leq m$ such that $G_{k,j}$ is valid. The functions $A_{k,j}$ can be used to quickly check the $(k,j)$-preconditions (a) and (b) and $A^{\prime}_{k,j}$ is for the $(k,j)$-postcondition (c). Those functions satisfy the following properties: for each connected component $\alpha\subseteq V_{k,j}$, there is a representative $u_{\alpha}\in\alpha$ such that

• •

if $\alpha\cap\Sigma\neq\emptyset$, then $u_{\alpha}\in\Sigma$,

• •

if $\alpha\cap\Sigma=\emptyset$, then $u_{\alpha}\in\Pi$,

• •

for all $x\in\alpha\cap\Pi$, then $A_{k,j}(x)=u_{\alpha}$,

• •

for all $x^{\prime}\in\alpha\cap\Pi^{\prime}$, then $A^{\prime}_{k,j}(x^{\prime})\in\alpha\cap(\Pi\cup\Sigma)$.

Recall that $G_{k-1,j-1}$ is a subgraph of $G_{k,j}$, where the difference is at most two nodes and one edge. Hence, we can compute $A_{k,j}$ and $A^{\prime}_{k,j}$ in $O(|\Pi|)$ time from $A_{k-1,j-1}$ and $A^{\prime}_{k-1,j-1}$ maintaining the inverse $U_{k,j}$ of $A_{k,j}$ whose domain is restricted to $\Pi$, i.e., $U_{k,j}(x)=\{\,y\in\Pi_{P[k-j+1:k]}\mid A_{k,j}(y)=x\,\}$ for $x\in\Pi_{P[k-j+1:k]}$. Each set $U_{k,j}(x)$ can be implemented as a linked list. The updating time $O(|\Pi|)$ is due to the size of $U_{k,j}$. Moreover, when computing $A_{k,j}$ and $A^{\prime}_{k,j}$, we can verify the validness of $G_{k,j}$. A pseudo code for constructing the shifting condition table is shown as Algorithms 2 and 3 in Appendix A.

Lemma 4

The shifting condition table can be calculated in $O(|\Pi|m^{2})$ time.

Suppose that we have a mismatch at position $k+1$ with a preceding function $\pi$. By using the shifting condition table, a naive algorithm may compute the failure function in $O(k|\Pi|^{2})$ time by finding the largest $j$ such that $\pi$ satisfies the $(k,j)$-precondition and then compute a function $\pi^{\prime}$ satisfying the $(k,j)$-postcondition with which we resume comparison at $j+1$. The calculation of $\pi^{\prime}$ can be done in $O(|\Pi|)$ time just by referring to the array $A^{\prime}_{k,j}$. We next discuss how to reduce the computational cost for finding $j$ by preparing an elaborated data structure in the preprocessing phase.

Du Mouza et al. [6] introduced a bitmap data structure concerning the precondition (a), which can be constructed using $A_{k,j}$ in the shifting condition table as follows. Here we extend the domain of $A_{k,j}$ to $\Pi$ by defining $A_{k,j}(x)=x$ for each $x\in\Pi\setminus\Pi_{P[k-j+1:k]}$.

Definition 6** ([6])**

For every $0\leq j<k\leq m$, $x\in\Pi$ and $p\in\Sigma_{P}$, we define

[TABLE]

Lemma 5** ([6])**

A preceding function $\pi$ satisfies the $(k,j)$-precondition (a) if and only if $\bigwedge_{x\in\Pi}{r_{x,\pi(x)}^{k}[j]}=1$.

We define a data structure corresponding to the $(k,j)$-precondition (b) as follows.

Definition 7

For every $0\leq j<k\leq m$ and $x,y\in\Pi$, define

[TABLE]

Lemma 6

A preceding function $\pi$ satisfies the $(k,j)$-precondition (b) if and only if $\bigwedge^{x,y\in\Pi}_{\pi(x)\neq\pi(y)}s_{x,y}^{k}[j]=1$ .

Therefore, we should resume comparison at $j+1$ for the largest $j$ that satisfies the conditions of Lemmas 5 and 6. To calculate such $j$ quickly, the preprocessing phase computes the following bit sequences. For every $x\in\Pi$, $p\in\Sigma_{P}$ and $1\leq k\leq m$, let $r_{x,p}^{k}$ be the concatenation of $r_{x,p}^{k}[j]$ in ascending order of $j$:

[TABLE]

and for every $x,y\in\Pi$ and $1\leq k\leq m$, let

[TABLE]

Calculating $r_{x,p}^{k}$ and $s_{x,y}^{k}$ for all $x,y\in\Pi$, $p\in\Sigma_{P}$ and $1\leq k\leq m$ in the preprocessing phase requires $O(|\Pi|(|\Sigma_{P}|+|\Pi|)m^{2})$ time in total. When a mismatch occurs at $k+1$ with a preceding function $\pi$, we compute

[TABLE]

Then the desired $j$ is the right-most position of 1 in $J$. This operation can be done in $O(\lceil\frac{m}{w}\rceil|\Pi|^{2})$ time, where $w$ denotes the word size of a machine. That is, with $O(|\Pi|(|\Sigma_{P}|+|\Pi|)m^{2})$ preprocessing time, the failure function can be computed in $O(|\Pi|^{2}\lceil\frac{m}{w}\rceil)$ time. For most applications, we can assume that $m$ is smaller than the word size $w$, i.e. $\lceil\frac{m}{w}\rceil=1$.

Theorem 2

The FVC-matching problem can be solved in $O(|\Pi|^{2}\lceil\frac{m}{w}\rceil n)$ time with $O(|\Pi|(|\Sigma_{P}|+|\Pi|)m^{2})$ preprocessing time.

4.2 Extended KMP Algorithm for PVC-match

In this section, we consider the PVC-matching problem. We redefine the (mis)match and failure function in the same manner as described in the previous section except that all the functions are restricted to be injective. We define $G_{k,j}$ exactly in the same manner as in the previous subsection. However, the condition represented by that graph should be strengthened in accordance with the injection constraint on matching functions. We say that $G_{k,j}$ is injectively valid if for each $\Delta\in\{\Sigma,\Pi,\Pi^{\prime}\}$, any distinct nodes from $\Delta$ are disconnected. Otherwise, it is injectively invalid. There is a $(k,j)$-shifting injection pair if and only if $G_{k,j}$ is injectively valid.

For $P=\mathtt{AABaaCbC}$ in Example 3 (see Fig. 2), the $(7,6)$-shifting graph $G_{7,6}$ for $P=\mathtt{AABaaCbC}$ is valid but injectively invalid, since $\mathtt{A}$ and $\mathtt{B}$ are connected. On the other hand, $G_{7,3}$ is injectively valid.

In the PVC-matching, the condition that an injection pair $(\pi,\pi^{\prime})$ to be $(k,j)$-shifting is described using the graph labeling by $(\pi,\pi^{\prime})$ as follows:

• •

two nodes are assigned the same label if and only if they are connected.

Under the assumption that $G_{k,j}$ is injectively valid, the $(k,j)$-precondition on a preceding function $\pi$ is given as

• (a)

if $x\in\Pi$ and $p\in\Sigma$ are connected, then ${\pi}(x)=p$,

• (b’)

if $x\in\Pi$ and $x^{\prime}\in\Pi^{\prime}$ are connected and $y^{\prime}\in\Pi^{\prime}\setminus\{x^{\prime}\}$ and $p\in\Sigma$ are connected, then ${\pi}(x)\neq p$.

Since each connected component of an injectively valid shifting graph $G_{k,j}$ has at most 3 nodes, it is cheap to compute the function $F_{k,j}:V\to 2^{V_{k,j}}$ such that F_{k,j}(u)=\{\,v\in V_{k,j}\mid\text{u$and$v$are connected in$G_{k,j}}\,\}. Note that $F_{k,j}(u)=\emptyset$ if $u\notin\Pi_{P[k-j+1:k]}$. Using $P[k],P[j]$, and $F_{k-1,j-1}$, one can decide whether $G_{k,j}$ is injectively valid and can compute $F_{k,j}$ (if $G_{k,j}$ is injectively valid) in constant time.

Suppose that we have a preceding function $\pi$ at position $k$. By using the function $F_{k,j}$, a naive algorithm can compute the failure function in $O(k|\Pi|)$ time. We define a bitmap $t_{x,p}^{k}[j]$ to check if $\pi$ satisfies preconditions (a) and (b’).

Definition 8

For every $0\leq j<k\leq m$, $x\in\Pi$ and $p\in\Sigma_{P}$, we define

[TABLE]

Lemma 7

The preceding function $\pi$ satisfies the $(k,j)$-preconditions (a) and (b’) if and only if $\bigwedge_{x\in\Pi}{t_{x,\pi(x)}^{k}[j]}=1$.

In the preprocessing phase, we calculate

[TABLE]

for all $x\in\Pi$, $p\in\Sigma_{P}$ and $1\leq k\leq m$, which requires $O(|\Pi||\Sigma_{P}|m^{2})$ time. When a mismatch occurs at $k+1$ with a function $\pi$, we compute

[TABLE]

where the desired $j$ is the right-most position of 1 in $J$. We resume comparison at $j+1$. The calculation of the failure function can be done in $O(|\Pi|\lceil\frac{m}{w}\rceil)$ time, where $w$ denotes the word size of a machine.

Theorem 3

The PVC-matching problem can be solved in $O(|\Pi|\lceil\frac{m}{w}\rceil n)$ time with $O(|\Pi||\Sigma_{P}|m^{2})$ preprocessing time.

5 Concluding Remarks

In this paper, we proposed efficient algorithms for the FVC-matching and PVC-matching problems. The FVC-matching problem has been discussed by du Mouza et al. [6] as a generalization of the function matching problem, while the PVC-matching problem is newly introduced in this paper, which can be seen as a generalization of the parameterized pattern matching problem. We have fixed a flaw of the algorithm by du Mouza et al. for the FVC-matching problem. There can be further variants of matching problems. For example, one may think of a pattern with don’t care symbols in addition to variables and constants. This is not interesting when don’t care symbols appear only in a pattern in function matching, since don’t care symbols can be assumed to be distinct variables. However, when imposing the injection condition on a matching function, don’t care symbols play a different role from variables. This generalization was tackled in [9]. We can consider an even more general problem by allowing texts to have variables, where two strings $P$ and $S$ are said to match if there is a function $\pi$ such that $\hat{\pi}(P)=\hat{\pi}(S)$. This is a special case of the word equation problem, where a string instead of a symbol can be substituted, and word equations are very difficult to solve in general. Another interesting restriction of word equations may allow to use different substitutions on compared strings, i.e., $P$ and $S$ match if there are functions $\pi$ and $\rho$ such that $\hat{\pi}(P)=\hat{\rho}(S)$. Those are interesting future work.

Appendix

Appendix A Algorithms