On the monotone complexity of the shift operator

TL;DR

This paper analyzes the complexity of minimal monotone circuits implementing a permutation operator on boolean vectors, providing new insights and alternative proofs for known bounds in monotone computational complexity.

Contribution

It establishes the exact asymptotic complexity of the monotone permutation operator and offers an alternative proof for the complexity of the monotone shift operator.

Findings

Complexity of monotone permutation operator is Θ(qn log n).

Provides an alternative proof for the Θ(n log n) bound of the monotone shift operator.

Enhances understanding of monotone circuit complexity for permutation functions.

Abstract

We show that the complexity of minimal monotone circuits implementing a monotone version of the permutation operator on $n$ boolean vectors of length $q$ is $\Theta(qn\log n)$. In particular, we obtain an alternative way to prove the known complexity bound $\Theta(n\log n)$ for the monotone shift operator on $n$ boolean inputs.

Equations

$$c_i(X,Y)=\underset{j+k=i\mathrm{mod}n}{\bigvee }{x}_j{y}_k.$$

$$S_{1,A_1}(X,Y)=C(X,Y)\vee x_0\cdot \dots \cdot x_{n-1}\cdot g\vee r(X,Y),$$

$$z_{i,k}(X,Y)=\underset{j=0}{\overset{n-1}{\bigvee }}{x}_{i,j}{y}_{j,k}.$$

$$\sum _{e\in S}\chi (e)\le Ln.$$

$$\sum _{e\in S_j}\chi (e,j)\ge {\log }_{2}n!=n{\log }_{2}n-O(n),$$

$$\sum _{e\in S}\chi (e)=\sum _j\sum _{e\in S_j}\chi (e,j)\ge n^2{\log }_{2}n-O(n^2).$$

Full text

Introduction. The recent paper [1] shows that a plausible hypothesis from network coding theory implies a lower bound $\Omega(n\log n)$ for the complexity of the $n$-input boolean shift operator when implemented by circuits over a full basis. As a corollary, the same bound holds for the multiplication of $n$-bit numbers. (Definitions of boolean circuits and complexity see e.g. in [12].) Curiously, nearly at the same time an upper bound $O(n\log n)$ for multiplication has been proved in [5]. Actually, for the shift operator, the bound $O(n\log n)$ is trivial.

The shift can be implemented by monotone circuits. Lamagna [7, 8] and independently Pippenger and Valiant [11] proved that its complexity is bounded by $\Omega(n\log n)$ with respect to the circuits over the basis $\{\vee,\,\wedge\}$. Essentially the same bound was established by Chashkin [3] for the close problem of implementation of the real-valued shift operator by circuits over the basis of 2-multiplexors and binary boolean functions. We show that the argument from [3] works for the boolean setting as well thus obtaining yet another proof of the known result. On the other hand, an upper bound $O(n\log n)$ is easy to obtain when a suitable encoding of the shift value is chosen.

A version of the shift operator may be seen as a partially defined order-$n$ boolean convolution operator. It is known that the complexity of the convolution is $n^{2-o(1)}$ [4], while the complexity of the corresponding shift operator is $\Theta(n\log n)$.

A more general form of shift is permutation. By analogy, one can introduce a monotone permutation operator. If a special encoding on the set of permutations is chosen, then the permutation operator on $n$ boolean inputs can be implemented with complexity $O(n\log n)$ employing the optimal sorting network from [2]. If size-$n$ boolean vectors are given as inputs, then there exists a version of the permutation operator, which is the restriction of the $n\times n$ boolean matrix multiplication operator. The boolean matrix multiplication complexity is known to be $\Theta(n^{3})$ [9, 10]. It can be compared with the complexity $\Theta(n^{2}\log n)$ of the corresponding permutation operator. (The lower bound follows from the bound on the complexity of the shift operator.)

Preliminaries. Further, $L(F)$ denotes the complexity of implementing the operator $F$ by circuits over the basis $\{\vee,\,\wedge\}$.

Let ${\mathbb{B}}=\{0,\,1\}$ and $A=\{\alpha_{0},\ldots,\alpha_{n-1}\}\subset{\mathbb{B}}^{m}$ be an antichain of cardinality $n$. By $X=(x_{0},\ldots,x_{n-1})$, $x_{i}=(x_{i,0},\ldots,x_{i,q-1})^{T}$, denote the $(q,n)$-matrix of boolean variables. Let $Y=(y_{0},\ldots,y_{m-1})$ denote the vector of boolean variables encoding elements of the antichain $A$. By $v\gg k$ we denote the vector obtained from $v$ via a cyclic shift by $k$ positions to the right.

Monotone cyclic shift $(nq+m,nq)$-operator $S_{q,A}(X,Y)=(s_{0},\ldots,s_{n-1})$ is a partially defined operator taking values $X\gg k$ for $Y=\alpha_{k}$, where $k=0,\ldots,n-1$.

Consider a few examples of encoding shift values. The vector $(v,\overline{v})$, where $\overline{\,\cdot\,}$ is the componentwise negation, we call doubling of the vector $v$. Typically, the shift value $k$ is encoded by its binary representation $[k]_{2}$. For the monotone version, one can use doubling of $[k]_{2}$. In this case, $m=2(\lfloor\log_{2}n\rfloor+1)$. The described encoding corresponds to the antichain $A_{0}=\left\{\left.\left([k]_{2},\,\overline{[k]_{2}}\right)\right|0\leq k<n\right\}$.

Another natural choice for $A$ is the set $A_{1}$ of all weight-1 vectors in ${\mathbb{B}}^{n}$. In this case, $m=n$. Let $q=1$. Define

[TABLE]

The operator $C(X,Y)=(c_{0},\ldots,c_{n-1})$ is called a cyclic boolean convolution of the vectors $X$ and $Y$.

By the definition of the shift operator, $S_{1,A_{1}}(X,Y)$ coincides with $C(X,Y)$ on inputs from ${\mathbb{B}}^{n}\times A_{1}$. It can be checked that

[TABLE]

where $g$ is an undefined boolean vector, and $r(X,Y)=0$ for ${|Y|\leq 1}$ (here $|v|$ denotes the weight of the vector $v$). The complexity of convolution is known to be almost quadratic, $L(C)=\Omega(n^{2}/\log^{6}n)$ [4]. Supposedly, a trivial upper bound $L(C)=O(n^{2})$ is tight. At the same time, $L(S_{1,A_{1}})=O(n\log n)$. We show below that in fact $L(S_{1,A})=\Omega(n\log n)$ for any $A$.

Now let $\Pi=\{\pi_{0},\ldots,\pi_{n!-1}\}\subset{\mathbb{B}}^{m}$ be an antichain of cardinality $n!$. We can assign to its elements different permutations $\pi$ on the set $\{0,\ldots,n-1\}$. Denote $\pi(X)=\left(x_{\pi(0)},\ldots,x_{\pi(n-1)}\right)$. The monotone permutation operator $P_{q,\Pi}(X,Y)$ is defined on inputs $Y\in\Pi$ as $P_{q,\Pi}(X,Y)=\pi(X)$, where the permutation $\pi$ corresponds to the value of $Y$. Since a cyclic shift is a special case of permutation, any permutation operator can be viewed as a shift operator defined on a larger domain.

Trivially, any permutation $\pi$ may be represented by the vector of numbers $([\pi(0)]_{2},\ldots,[\pi(n-1)]_{2})$. Let $\Pi_{0}$ denote the corresponding coding set (it constitutes an antichain).

Otherwise, permutations may be specified as square boolean matrices with all rows and columns having weight 1. Denote the set of such matrices by $\Pi_{1}\subset{\mathbb{B}}^{n\times n}$. The corresponding permutation operator performs the multiplication of the permutation matrix $Y=\{y_{j,k}\}$ by the matrix of variables $X$. Define

[TABLE]

Then $Z(X,Y)=\{z_{i,k}\}:{\mathbb{B}}^{q\times n}\times{\mathbb{B}}^{n\times n}\to{\mathbb{B}}^{q\times n}$ is the operator of boolean product of matrices $X$ and $Y$. By definition, the operators $P_{q,\Pi_{1}}$ and $Z$ take the same values on inputs from ${\mathbb{B}}^{q\times n}\times\Pi_{1}$. It is known that $L(Z)=qn(2n-1)$ [10] (see also [12]), which means: the naive method to multiply boolean matrices is optimal. On the other hand, $L(P_{q,\Pi_{1}})=O(qn\log n+n^{2})$ (see below). Moreover, we manage to show that $L(P_{q,\Pi})=\Omega(qn\log n)$ for any $\Pi$, and this bound is achievable.

Upper complexity bounds. For $v=(v_{0},\ldots,v_{m-1})\in{\mathbb{B}}^{m}$ let $Y^{v}=\bigwedge_{v_{i}=1}y_{i}$ denote the monomial of variables $y_{i}$ corresponding to the vector $v$. Let $L(A)$ stand for the complexity of computation of the set of monomials $\{Y^{\alpha}\mid\alpha\in A\}$.

*Proof. *The standard circuit for the shift operator consists of $\log_{2}n$ layers of $n$ multiplexors in each. It can be built according to the binary representation of the shift value $k$. The first layer shifts the input by either 0 or 1 positions, depending on the value of the least significant bit of $k$. The second layer shifts by 0 or 2 positions, etc.

The monotone circuit employs indicators $Y^{i,\beta}=\bigvee_{\lfloor k/2^{i}\rfloor=\beta\bmod 2}Y^{\alpha_{i}}$ of equality of bits of $Y$ to zeros or ones. Instead of multiplexors, there are used similar monotone subcircuits that calculate operators of the form $Y^{i,1}a\vee Y^{i,0}b$.

It remains to note that all boolean sums $Y^{i,\beta}$ can be computed with complexity $O(n)$. ∎

In particular, since $L(A_{0})=O(n)$ and $L(A_{1})=0$, we obtain $L(S_{1,A_{0}}),L(S_{1,A_{1}})\in O(n\log n)$.

To derive the upper bounds on the complexity of the permutation operator, we use a circuit $\Sigma$ sorting $n$ elements with complexity $O(n\log n)$ provided by [2]. Such a circuit consists of comparator gates that order a pair of inputs.

$(i)$* There exists an antichain $\Pi$ such that $L(P_{q,\Pi})=O(qn\log n)$.*

$(ii)$* $L(P_{q,\Pi_{1}})=O(qn\log n+n^{2})$.*

*Proof. *A set $\Pi$ can be specified following the circuit $\Sigma$. Assign to any permutation $\pi$ a linear order $x_{\pi(0)}>x_{\pi(1)}>\ldots>x_{\pi(n-1)}$ on the set of inputs of $\Sigma$ (in general, we do not consider these inputs boolean). Let $\Sigma$ receive inputs ordered in correspondence to a given permutation $\pi$. Assign to each comparator $e$ a boolean parameter $y_{e}$ whose value is determined by the result of the comparison. Let the doubling of the vector of parameters $y_{e}$, $e\in\Sigma$, encode a permutation $\pi$.

Now, we transform the circuit $\Sigma$ to a monotone circuit for $P_{q,\Pi}(X,Y)$, replacing any comparator $e$ receiving vector inputs $a,b$ with a subcircuit that evaluates vectors $ay_{e}\vee b\overline{y_{e}}$ and $a\overline{y_{e}}\vee by_{e}$.

Let us prove $(ii)$. First, recode $Y$ from $\Pi_{1}$ to $\Pi_{0}$. To do this, one simply needs to compute positions $y^{\prime}_{0},\ldots,y^{\prime}_{n-1}$ of 1s in the columns of the matrix $Y$. The position of 1 in a weight-1 column may be calculated by a trivial circuit of linear complexity. Therefore, the complexity of the recoding is $O(n^{2})$.

Next, arrange the inputs $x_{i}$ in accordance to the ordering of numbers $y^{\prime}_{i}$ with the use of the circuit $\Sigma$. At each node of the obtained circuit two $y^{\prime}_{i}$ inputs are compared and, depending on the result of the comparison, the order of the vectors $x_{i}$ accompanied by the numbers $y^{\prime}_{i}$ is determined. The complexity of comparison is linear, so the complexity of the subcircuit at each node is $O(q+\log n)$. ∎

Lower complexity bounds. The proof of the following theorem closely follows the proof of the main result in [3].

*Proof. *Essentially, it suffices to consider the case $q=1$. Let $S$ be a monotone circuit of complexity $L$ that computes $S_{1,A}(X,Y)$.

a) First, note that for any assignment $Y=\alpha_{k}$ for each $i$, the circuit $S$ contains a path connecting the input $x_{i}$ and the output $s_{i+k\bmod n}$, and passing exclusively through the gates whose outputs return the function $x_{i}$.

Indeed, $s_{i+k\bmod n}(X,\alpha_{k})=x_{i}$ by definition. It remains to check that if $x_{i}=f\vee g$ or $x_{i}=fg$, where $f$ and $g$ are monotone functions, then either $f=x_{i}$ or $g=x_{i}$. From $x_{i}=f\vee g$ it follows that $f\leq x_{i}$ and $g\leq x_{i}$. Assume that $f\neq x_{i}$ and $g\neq x_{i}$. It means that $f=g=0$ under the assignment $x_{i}=1$, $x_{j}=0$ for all $j\neq i$. But then $f\vee g=0\neq x_{i}$. A contradiction. The case $x_{i}=fg$ follows by a dual argument.

So, moving from an output $s_{i+k\bmod n}$ towards the inputs of the circuit, for any gate, we can select an appropriate input computing the function $x_{i}$. Finally, we obtain the desired path.

b) Denote the path providing by the above argument by $p_{i,k}$. Let $\chi(e)$ stand for the number of paths $p_{i,k}$, $0\leq i,k<n$, passing through the gate $e$ in the circuit $S$. Note that $\chi(e)\leq n$ for all $e\in S$. Indeed, any assignment $Y=\alpha_{k}$ uniquely defines the function of variables $X$ computed at the output of any gate $e$. Thus, $e$ does not belong to two different paths $p_{i,k}$ and $p_{j,k}$. Consequently,

[TABLE]

c) Let us estimate the sum $\sum_{e\in S}\chi(e)$ in another way. Denote by $\chi(e,j)$ the number of paths $p_{i,k}$ passing through $e$ to the output $s_{j}$. By construction, $\sum_{j}\chi(e,j)=\chi(e)$.

Consider the subcircuit $S_{j}$ obtained by combining all $n$ paths $p_{i,k}$ leading to the output $s_{j}$, i.e. satisfying the condition $i+k=j\bmod n$. By construction, $S_{j}$ is a connected binary222Any vertex receives at most two incoming edges. directed graph with $n$ inputs and one output. We manage to bound $\sum_{e\in S_{j}}\chi(e,j)$ following a simple argument from [6]333In [6], the argument was used to bound the monotone complexity of the boolean sorting operator, see also [12]..

Due to the binarity property, the subcircuit $S_{j}$ has an input at a distance of at least $\log_{2}n$ edges from the output. In other words, some path making up $S_{j}$ contains at least $\log_{2}n$ gates. Exclude this path and consider a subcircuit obtained by combining the remaining $n-1$ paths. Then, it contains a path of length at least $\log_{2}(n-1)$. We proceed this way until there is no path remained. The argument leads to the bound

[TABLE]

following by

[TABLE]

Putting together (1) and (3), we establish the inequality $L\geq n\log_{2}n-O(n)$.

d) For $q>1$, we consider separately the components of the input and output vectors at the same positions. This results in $q$ groups of paths $p_{i,j}$. The inequality (1) remains valid, and the inequality (2) holds for any of $qn$ outputs. Thus, the required bound finally follows. ∎

Since a permutation operator is a more completely defined shift operator, as a corollary we establish $L(P_{q,\Pi})\geq qn\log_{2}n-O(qn)$ for any $\Pi$.

The research is supported by RFBR grant, project no. 19-01-00294a.