# Communication memento: Memoryless communication complexity

We study the communication complexity of computing functions F:{0,1}^n×{0,1}^n →{0,1} in the memoryless communication model. Here, Alice is given x∈{0,1}^n, Bob is given y∈{0,1}^n and their goal is to compute F(x,y) subject to the following constraint: at every round, Alice receives a message from Bob and her reply to Bob solely depends on the message received and her input x; the same applies to Bob. The cost of computing F in this model is the maximum number of bits exchanged in any round between Alice and Bob (on the worst case input x,y). In this paper, we also consider variants of our memoryless model wherein one party is allowed to have memory, the parties are allowed to communicate quantum bits, only one player is allowed to send messages. We show that our memoryless communication model capture the garden-hose model of computation by Buhrman et al. (ITCS'13), space bounded communication complexity by Brody et al. (ITCS'13) and the overlay communication complexity by Papakonstantinou et al. (CCC'14). Thus the memoryless communication complexity model provides a unified framework to study space-bounded communication models. We establish the following: (1) We show that the memoryless communication complexity of F equals the logarithm of the size of the smallest bipartite branching program computing F (up to a factor 2); (2) We show that memoryless communication complexity equals garden-hose complexity; (3) We exhibit various exponential separations between these memoryless communication models. We end with an intriguing open question: can we find an explicit function F and universal constant c>1 for which the memoryless communication complexity is at least c log n? Note that c≥ 2+ε would imply a Ω(n^2+ε) lower bound for general formula size, improving upon the best lower bound by Nečiporuk in 1966.

## Authors

• 15 publications
• 3 publications
• ### Energy Complexity of Distance Computation in Multi-hop Networks

Energy efficiency is a critical issue for wireless devices operated unde...
05/10/2018 ∙ by Yi-Jun Chang, et al. ∙ 0

• ### Round Complexity of Common Randomness Generation: The Amortized Setting

We study the effect of rounds of interaction on the common randomness ge...
09/01/2019 ∙ by Noah Golowich, et al. ∙ 0

• ### Private Aggregation from Fewer Anonymous Messages

Consider the setup where n parties are each given a number x_i ∈F_q and ...
09/24/2019 ∙ by Badih Ghazi, et al. ∙ 0

• ### Raz-McKenzie simulation: new gadget and unimprovability of Thickness Lemma

Assume that we have an outer function f:{0, 1}^n →{0, 1} and a gadget fu...
02/12/2018 ∙ by Alexander Kozachinskiy, et al. ∙ 0

• ### Trading information complexity for error II

Consider the standard two-party communication model. This paper, follows...
09/26/2018 ∙ by Yaqiao Li, et al. ∙ 0

• ### Auctions with Severely Bounded Communication

We study auctions with severe bounds on the communication allowed: each ...
10/12/2011 ∙ by L. Blumrosen, et al. ∙ 0

• ### Round elimination in exact communication complexity

We study two basic graph parameters, the chromatic number and the orthog...
12/21/2018 ∙ by Jop Briët, et al. ∙ 0

##### This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

## 1 Introduction

Yao [Yao79] introduced the model of communication complexity in 1979 and ever since it’s introduction, communication complexity has played a pivotal role in understanding various problems in theoretical computer science. In its most general form in this model, the goal is the following: there are two separated parties usually referred to as Alice and Bob, Alice is given an -bit string and similarly Bob is given and together they want to compute where is a function known to both of them. Here Alice and Bob are given unlimited computational time and memory and the cost of any communication protocol between Alice and Bob is the total number of bits exchanged between them. Clearly a trivial protocol is Alice sends her input to Bob who can then compute , which takes bits of communication. Naturally, the goal in communication complexity is to minimize the number of bits of communication between them before computing . The deterministic communication complexity of a function (denoted ) is defined as the total number of bits of communication before they can decide on the worst-case inputs .

Since its introduction there have been various works that have extended the standard deterministic communication model to the setting where Alice and Bob are allowed to share randomness and need to output

with high probability (probability taken over the randomness in the protocol). Apart from this there has been studies on non-deterministic communication complexity

[Wol03], quantum communication complexity [Yao93] (wherein Alice and Bob are allowed to share quantum bits and possibly have shared entanglement), unbounded error communication complexity [PS86] and their variants. One-way variants have also been considered where only Alice sends messages to Bob. Study of these different models of communication complexity and their variants have provided many important results in the fields of VLSI [Pal99], circuit lower bounds [GH92], algorithms [AMS99], data structures [MNSW98], property testing [BBM12], streaming algorithms [BYJKS04], computational complexity [BW16], extended formulations [FMP15].111For more on communication complexity and its applications, we refer the interested reader to the standard textbooks for communication complexity [KN97, LS09].

### 1.1 Background

In the context of our current understanding of computation, the study of space required to solve any problem is one of the central topics in complexity theory. Several space bounded models such as width-bounded branching programs, limited depth circuits, straight line programs have been widely studied in this context. In this direction variants of communication complexity have also been analyzed to better understand communication-space trade-offs [IW10, Kla04, LTT89]. In particular, the relation between space-bounded computation and communication complexity was initiated by Brody et al. [BCP13] who considered the following question: what happens if we change the standard communication model such that, between each step of communication, Alice and Bob limited in their ability to store the information from the previous rounds (which includes their private memory and messages exchanged). In this direction, they introduced a new model wherein Alice and Bob each are allowed to store at most bits of memory and showed that unlike the standard communication complexity, in this model super-linear lower bounds on the amount of communication are possible222A separation were proven for a non-Boolean function.

. Brody et al. mainly studied one-way communication complexity variant of this limited memory model in which Bob can have two types of memory: an oblivious memory (depends only on Alice’s message) and a non-oblivious memory (for computation). With these definitions, among other results they obtained memory hierarchy theorems for such communication models analogous to the space hierarchy theorem in the Turing machine world.

Subsequently, Papakonstantinou, et al. [PSS14] defined a similar space-bounded one-way communication model wherein Alice has unlimited memory and Bob has either no memory or constant-sized memory. At each round, messages from Alice to Bob consists of at most bits and the complexity of computing any function is the maximum required over all inputs. They characterized the complexity in their no-memory one-way model by an elegant combinatorial object called the rectangle overlay (which is defined in Section 4.2). They also managed to establish connections between their model and the well-known communication complexity polynomial hierarchy, introduced by Babai, Frankl and Simon [BFS86]. Papakonstantinou et al. [PSS14] showed that the message length in their model corresponds to the oblivious memory in a variant of space bounded model, introduced by Brody et al. [BCP13], where Bob only has access to an oblivious memory.

Another seemingly unrelated complexity model, the garden-hose complexity was introduced by Buhrman et al. [BFSS13] to understand quantum attacks on position-based cryptographic schemes (see Section 5.2 for a formal definition). Polynomial size garden-hose complexity is known to be equivalent to Turing machine -space computations with pre-processing. In the garden-hose model two distributed players Alice and Bob use several pipes to send water back and forth and compute Boolean functions based on whose side the water spills. Garden-hose model was shown to have many connections to well-established complexity models like formulas, branching programs and circuits and it provides new techniques to prove lower bounds for these complexity models.

In this work, we introduce a new general framework of memoryless communication complexity which captures all the above variants of the space-bounded models.

### 1.2 Memoryless Communication Models

Memoryless communication models. We introduce a natural model of communication complexity which we call memoryless communication complexity. Here, like the standard communication complexity, there are two parties Alice and Bob given respectively and they need to compute , where is known to both of them. However, we tweak the standard communication model in the following two ways: The first change is that Alice is “memoryless”, i.e., at every round Alice computes the next message to send solely based on only her input and the message received from Bob in this round. She does not remember the entire transcript of messages that were communicated in the previous rounds and also forgets all the private computation she did in the previous rounds. Similarly Bob computes a message which he sends to Alice, based only on his input and the message received from Alice in the current round. After Bob sends his message, he also forgets the message received and all his private computations. Alice and Bob repeat this procedure for a certain number of rounds before one of them outputs .

The second crucial change in the memoryless communication model is that the cost of computing in this model is the size of the largest message communicated between Alice and Bob in any round of the protocol (here size refers to the number of bits in the message). Intuitively, we are interested in knowing what is the size of a re-writable message register (passed back and forth between Alice and Bob) required to compute a function  on all distributed inputs and , wherein Alice and Bob do not have any additional memory to remember information between rounds.333Note that unlike the standard communication complexity, where a single bit-message register suffices for computing all functions, here because of the memoryless-ness constraint we need more than a single bit register for computing most of the functions. We denote the memoryless communication cost of computing as (where stands for “no-memory”). We believe this communication model is very natural and as far as we are aware this memoryless communication model wasn’t defined and studied before in the classical literature.

It is worth noting that in the memoryless communication model, Alice and Bob do not even have access to clocks and hence cannot tell in which round they are in (without possibly looking at the message register). Hence, every memoryless protocol can be viewed as Alice and Bob applying deterministic functions (depending on their respective inputs) which map incoming messages to out-going messages.

In order to get a feel of this model, let us look at a protocol for the standard equality function defined as where if and only if . It is well-known that . In our model, we show that : for , at the th round, Alice sends and Bob returns ,444Here is the indicator of an event in the parenthesis. Alice increments and repeats this protocol for rounds. In case Bob finds an for which , he outputs , if not after rounds they output . Note that this protocol didn’t require Alice and Bob to have any memory and the length of the longest message in this protocol was . We discuss more protocols later in the paper and formally describe the memoryless communication model in Section 3.

Apart from memoryless communication complexity, we will also look at the “memory-nomemory communication” protocols where Alice is allowed to have memory (i.e., Alice can know which round she is in, can remember the entire transcript and her private computations of each round) whereas Bob doesn’t have any memory during the protocol. The goal of the players remains to compute a function and the cost of these protocols (denoted by ) is still defined as the smallest size of a message register required between them on the worst inputs. Apart from this, we will also consider the quantum analogous of these two communication models wherein the only difference is that Alice and Bob are allowed to send quantum bits. We formally describe these models of communication in Section 3. In order to aid the reader we first set up some notation which we use to describe our results: for , let

1. be the memoryless communication complexity of computing wherein Alice and Bob both do not have any memory.

2. be the memory-nomemory communication complexity of computing where Alice has memory and Bob doesn’t have memory

3. be the garden-hose complexity of computing .

Apart from these, we will also allow quantum bits of communication between Alice and Bob and the complexities in these models are denoted by and . Additionally, we will consider the one-way communication models wherein only Alice can send messages to Bob and the complexities in these models are denoted by .

### 1.3 Our Contribution

##### Defining and characterizing the model.

The main contribution in this paper is to first define the model of the memoryless communication complexity and consider various variants of this model (only some of which were looked at before in the literature). We provide a characterization of memoryless communication complexity using branching programs. In particular, we show that for every , the memoryless complexity is (up to a factor ) equal to the logarithm of the size of the smallest bipartite branching program computing . We defer the definition of such branching programs to Section 2 and Section 4.2.

##### Separating these models.

We then establish the following inequalities relating the various models of communication complexity.555Some of the inequalities are straightforward but we explicitly state it for completeness.

 M(F)\rotatebox[origin=c]90.0$≤$QM(F)≤NM(F)\rotatebox[origin=c]90.0$≤$QNM(F)⋆≤log(GH(F))≤M→(F)\rotatebox[origin=c]90.0$≤$QM→(F)≤NM→(F)\rotatebox[origin=c]90.0$≤$QNM→(F)

Furthermore, except the inequality marked by , we show the existence of various functions for which all the inequalities are exponentially weak. In order to prove these exponential separations we use various variants of well-known functions such as inner product, disjointness, Boolean hidden matching problem, gap-hamming distance problem. Giving exponential separations between quantum and classical communication complexity666These exponential separations are in the standard communication model where the communication complexity is the total number of bits or qubits exchanged between Alice and Bob. is an extensively studied subject [BCW98, BCWW01, GKK08, BJK08, Gav19] and in this paper we show such separations can also be obtained in the memoryless models.

Along the way, we establish various other results. In order to understand the limitations of the memoryless communication model, we show that the logarithm of the (standard) non-deterministic communication complexity of is a lower bound on . In particular, this provides tight bounds for many interesting problems like equality (a matching upper bound was described at the start of this section), inner product, disjointness, majority.

##### Relevance to garden-hose complexity and its implications.

We show a relation between the garden-hose complexity to memoryless communication complexity. In particular we show that the logarithm of the garden-hose complexity of computing is sandwiched between and . Moreover, using the results of Papakonstantinou et al. [PSS14] that characterized in terms of rectangle overlays, we present a new upper bound technique for the garden-hose model. Using this method we obtain a sub-quadratic garden-hose protocol for computing the function Disjointness with quadratic universe which was conjecture to have a quadratic complexity in [KP14].

An additional consequence of this is the following: in the work of Papakonstantinou, et al. [PSS14] it was stated that the message length in their one-way memory-no memory model corresponds to oblivious memory setting considered by Brody et al. [BCP13]. However, Brody et al. [BCP13] pointed out that if the memory required to compute a function in their general model is and the garden hose complexity is then . We exhibit a function for which and are exponentially separated. Thus together with the result of [BCP13] we show that are are exponentially separated.

##### Towards obtaining better formula bounds.

Finally, it was shown by Klauck and Podder [KP14] that any formulae of size consisting of arbitrary fan-in 2 gates (i.e., formulae over the binary basis of fan-in 2 gates) can be simulated by a garden-hose protocol of size for any arbitrary . In this work, we show that an arbitrary garden-hose protocol can be simulated by a memoryless protocol without any additional loss, i.e., a size garden-hose protocol can be turned into a memoryless protocol of size . In particular, putting together these two connections, it implies that a size formula can be turned into a memoryless protocol of size . Thus our result provides a new way of proving formulae size lower bound for arbitrary function by analyzing the memoryless protocol of .777Here, the inputs are distributed among two players and their goal is to compute where is a constant-sized gadget. The best known lower bound for formulae size (over the basis of all fan-in 2 gate) is , due to Nečiporuk [Nec66]. Analogous to the Karchmer-Wigderson games [KW90] and Goldman and Håstad [GH92] techniques which uses communication complexity framework to prove circuit lower bounds our new communication complexity framework is a new tool for proving formulae size lower bounds.

### 1.4 Further remarks

##### Directions for future works.

As a main open problem, we mention a seemingly-simple intriguing open question: Is there any explicit function for which for an arbitrary constant (we discuss further implications of this result in Section 6). As mentioned earlier, proving for some explicit function would imply new lower bounds for general formulae size, improving the best-known lower bounds by Nečiporuk [Nec66] from 1966.888Additionally, proving would improve the best-known De Morgan formula size lower bounds by Gal et al. [GTN19].

Also using our characterized to branching programs, would result in the first super-linear lower bound for bipartite branching programs (analogous to Tal’s first super-linear lower bound on bipartite formula size of inner-product [Tal16]). One of the possible candidates for such lower bound could be distributed -clique function. We discuss these and several other open problems for future research in Section 6.

##### Other related works.

Finally here we discuss some more related works. Impagliazzo and Williams [IW10] considered two variants of the standard communication complexity model where players have access to a synchronized clock. They then studied their relationship with the standard communication complexity and the polynomial hierarchy. In the quantum setting, Ablayev et al. [AAKK18] consider the memoryless communication model we consider and their focus was on discussing its connections to proving lower bounds on automata and ordered binary decision diagrams and streaming algorithms. Chailloux et al. [CKL17] study the quantum memoryless communication complexity wherein Alice and Bob do not have private memory but are allowed to adaptively apply unitaries to the quantum states they exchange in each round. They study the information cost of memoryless quantum protocols and prove a tight lower bound on the information cost of the AND function for -round quantum memoryless protocols. Buhrman et al. [BCG16] studied quantum memoryless protocols and established a connection between memoryless protocols and Bell inequality violations. Jeffery [Jef20] recently related the space complexity of quantum query algorithms with approximate span programs.

##### Organization.

In Section 2 we describe the basic communication model and branching programs. In Section 3 we describe the memoryless communication as well as other variants of this model. In Section 4 we characterize the complexity of memoryless communication in terms of bipartite branching programs. In Section 5 we present various algorithms, lower bounds and separations between the memoryless models and we finally conclude with some open questions in Section 6.

## 2 Preliminaries

##### Notation.

Let . For , let be the integer representation of the -bit string . We now define a few standard functions which we use often in this paper. The equality function is defined as if and only if . The disjointness function defined as if and only if there exists such that . The inner product function is defined as (where is the standard bit-wise product).

##### Quantum information.

We briefly review the basic concepts in quantum information theory. Here a qubit

is a unit vector in

and the basis for this space is denoted by and . An arbitrary is in a superposition of , i.e., for satisfying . In order to obtain a quantum state on

qubits, one can take the tensor product of single-qubit states, hence an arbitrary

-qubit state is a unit vector in and can be expressed as where and .

We now define formulae, branching programs and refer the interested reader to Wegener’s book [Weg87] for more on the subject.

###### Definition (De Morgan Formulae)

A De Morgan formula is a binary tree whose internal nodes are marked with AND gates or OR gates and the leaves are marked with input variables or their negations. we say a depth- De Morgan formula computes a function , if there is a binary tree of depth such that on input , the root of the tree outputs . The De Morgan formula size of a function is the size of the smallest De Morgan formula computing .

###### Definition (General Formulae)

General formulas are same as De Morgan formulas except that the nodes could consist of gates corresponding to any arbitrary -bit functions . Note that De Morgan formulas consisted only of AND, OR gates whereas in general formulas there could be 16 such possible gates in the tree.

###### Definition (Branching programs (BP))

A branching program for computing a Boolean function is a directed acyclic graph with a source node labelled and two sink nodes labelled and . Every node except the source and sink nodes are labelled by an input variable . The out-degree of every node is two and the edges are labelled by and . The source node has in-degree and the sink nodes have out-degree . The size of a branching program is the number of nodes in it. We say a branching program computes if for all (resp. ) the algorithm starts from the source, and depending on the value of at each node the algorithm either moves left or right and eventually reaches the -sink (resp. -sink) node. We denote as the size (i.e., the number of nodes) of the smallest branching program that computes for all .

We now define the standard communication complexity model defined by Yao [Yao79].

###### Definition (Standard communication complexity)

Let . Here two players Alice and Bob want to compute in the following manner: Alice receives , Bob gets and they are allowed to exchange bits before computing . We say a protocol computes if for every , Alice and Bob compute with probability . The models we describe below vary in how the communication protocol proceeds between Alice and Bob and measures the complexity of the protocols in a different way.

1. Standard one-way communication complexity: Here we restrict only Alice to send bits to Bob. The complexity of the protocol in this model is the total number of communication between Alice and Bob and finally Bob needs to output . The classical complexity of this model is denoted . Suppose they exchange quantum bits, then due to the inherent randomness in quantum states, we allow them to output with probability at least . The quantum complexity of computing in this model is denoted by .

2. Standard two-way communication complexity: This is exactly the same as , except that both Alice and Bob are allowed to send bits to one another and the classical complexity is denoted . Suppose they are allowed to exchange quantum bits, then the quantum complexity is denoted

## 3 Memoryless Communication Complexity

In this section we define memoryless communication complexity model and its variants.

### 3.1 Deterministic Memoryless Communication Model

The crucial difference between the memoryless communication model and standard communication model is that, at any round of the communication protocol Alice and Bob do not have memory to remember previous transcripts and their private computations from the previous rounds. We now make this formal.

###### Definition (Two-way Deterministic memoryless communication complexity)

Let . Here there are two parties Alice and Bob whose goal is to compute . Every -bit memoryless protocol is defined by a set of functions and wherein . On input to Alice and Bob respectively a memoryless protocol is defined as follows: at every round Alice obtains a message from Bob, she computes and sends to Bob. On receiving , Bob computes and replies with to Alice. They alternately continue doing this for every round until the protocol ends. Without loss of generality we assume the protocol ends once , then the function output is given by the last bit. So, once the transcript is , Alice and Bob output .999Without loss of generality, we assume that the first message is between Alice and Bob and she sends to Bob.

We say a protocol computes correctly if for every , Bob outputs . We let be the smallest for which computes on input . Additionally, we let

 cost(PF)=maxx,ycost(PF,x,y)

and the memoryless communication complexity of computing in this model is defined as

 NM(F)=minPFcost(PF),

where is the minimum is taken over all protocols that compute correctly.

We crucially remark that in the memoryless model, the players do not even have access to a clock and hence they cannot tell which round of the protocol they are in. At every round they just compute their local functions on the message they received and proceed according to the output of these functions.

##### One-way Deterministic Memoryless Model.

Similar to the definition above, one can define the one-way memoryless communication complexity wherein only Alice is allowed to send messages to Bob and the remaining aspects of this model is the same as Definition 3.1. We denote the complexity in this model by . It is easy to see that since Alice does not have any memory she cannot send multi-round messages to Bob as there is no way for her to remember in which round she is in. Also Bob cannot send messages back to Alice for her to keep a clock. Hence all the information from Alice to Bob has to be conveyed in a single round. Thus one-way memoryless communication complexity is equal to the standard deterministic one-way communication complexity101010Without loss of generality, in any one-way standard communication complexity protocol of cost Alice can send all the bits in a single round..

###### Fact

For all function we have .

### 3.2 Deterministic Memory-No Memory Communication Model

We now consider another variant of the memoryless communication model wherein one party is allowed to have a memory but the other party doesn’t. In this paper, we always assume that Alice has a memory and call this setup the memory no-memory model. In this work, we will not consider the other case wherein Bob has a memory and Alice doesn’t have a memory. Note that this setting is asymmetric i.e., there exists functions for which the complexity of the function can differ based on whether Alice or Bob has the memory.

##### Two-way Memory-No Memory Communication Model.

Here the players are allowed to send messages in both directions. For a function , we denote the complexity in this model as . Observe that is trivially upper bounded by for every : for every , Alice can send and Bob replies with . Since Alice has memory, after  rounds she has complete knowledge of and computes locally and sends it to Bob. Additionally, observe that in this model it doesn’t matter which party has memory.

##### One-way Memory-No Memory Communication Model.

Here we allow only Alice to send messages to Bob. Since Alice has a memory she can send multiple messages one after another, but Bob cannot reply to her messages. Hence, after receiving any message Bob computes the function and if he obtains , he outputs or , and continues if he obtains . We denote the communication complexity in this model by . This model was formally studied by Papakonstantinou et al. [PSS14] as overlay communication complexity (we discuss their main contributions in Section 4).

Finally, we can also have a model where both players have memory and hence both players can remember the whole transcript of the computation. This is exactly the widely-studied standard communication complexity except that the complexity measure here is the size of the largest transcript (so the complexity in our model is just since they could exchange a single bit for rounds and compute an arbitrary function on bits) and the latter counts the total number of bits exchanged in a protocol.

##### Quantum memoryless Models.

Here we introduce the quantum memoryless communication model. There are a few ways one can define the quantum extension of the classical memoryless model. We find the following exposition the simplest to explain. This quantum communication model is defined exactly as the classical memoryless model except that Alice and Bob are allowed to communicate quantum states. A  round quantum protocol consists of the following: Alice and Bob have local -qubit memories respectively,111111After each round of communication, these registers are set to the all- register. they share a -qubit message register  and for every round they perform a -outcome POVM for (which could potentially depend on their respective inputs and ). Let be the set of -dimensional unitaries acting on and respectively (this is analogous to the look-up tables used by Alice and Bob in the classical memoryless protocol). Let be the all- mixed state. Then, the quantum protocol between Alice and Bob can be written as follows: on input to Alice and Bob respectively, on the th round (for ) Alice sends

for odd

and Bob replies with defined as follows:

 ψi=\rm TrA(P∘Uxψi−1)⊗|0⟩⟨0|B,

where is the post-measurement state after performing the POVM on the state and refers to taking the partial trace of register . Similarly, define

where takes the partial trace of register . Intuitively, the states (similarly ) can be thought of as follows: after applying unitaries to the registers , Alice applies the -outcome POVM which results in a classical outcome and post-measurement state on the registers and she discards her private memory register and initializes the register in the all- state. The quantum communication protocol terminates at the th round once the -outcome POVM results in the classical outcome .121212We remark that a good quantum communication protocol should be such that for every , the probability of obtaining when measuring using the POVM should be . After they obtain this classical output, Alice and Bob output . We say a protocol computes if for every , with probability at least  (probability taken over the randomness in the protocol), after a certain number of rounds the POVM measurement results in . The complexity of computing in the quantum memoryless model, denoted is the smallest such that there is a -qubit message protocol that computes . As defined before, we also let (resp. ) to be the model in which Alice has a memory (has no memory) and Bob doesn’t have a memory and the communication happens from Alice to Bob.

##### Notation.

For the remaining part of the paper we abuse notation by letting , denote the memoryless complexity of computing and we let model (resp.  model) be the memoryless communication model (resp. quantum memoryless communication model).

## 4 Understanding and characterization of memoryless models

We now state a few observations and relations regarding the memoryless communication models.

###### Fact

For every , we have

 M(F)≤NM(F)≤2M→(F)≤2NM→(F).

###### Proof

The proof of the first and last inequality is straightforward since the complexity of a protocol only increases when we force a party to not have memory. We now show the second inequality, suppose . Then there are at most messages Alice sends (suppose at round , she sends a message and Bob didn’t output , then she knows that , so she need not repeat sending using her memory) and suppose these messages Alice sends are . The protocol for goes as follows, at the th round Alice sends Bob which uses bits. If Bob does not outout he simply increments to and sends back , which takes at most bits. Since Alice doesn’t have a memory but has received and hence has the information of the round , she runs the protocol for th round and her next message to Bob is . Alice and Bob continue the protocol this way until Bob outputs 0 or 1. Since the original protocol computes , the protocol computes as well.

As we mentioned earlier, our main contribution in this paper is the memoryless model of communication. We saw in Fact 3.1 that is equal to the standard one-way deterministic communication complexity of computing . The model was introduced and studied by Papakonstantinou et al. [PSS14]. Additionally observe that the strongest model of communication complexity  is small for every function .

###### Fact

For every , we have .

To see this, observe that in the model (i.e., two-way memory-no memory model), on the th round, Alice sends and Bob (who doesn’t have memory) sends the message to Alice. Alice stores and increments to and repeats. After rounds Alice simply has the entire and computes on her own (note that is known to both Alice and Bob).

Below we give few protocols in the model to give more intuition of this model.

##### Algorithms in the memoryless model:

In the introduction we described a protocol for the equality function. Below we describe a protocol for the inner product function. For the inner product function , a simple protocol is as follows: For , on the th round, Alice sends

 (i,xi,i−1∑j=0xi⋅yi(mod2))

which takes bits and Bob replies with

They repeat this protocol for rounds and after the th round, they have computed . Hence . Now we describe a protocol for the disjointness function . Here a protocol is as follows: Alice sends the first coordinate for which and Bob outputs  if , if not Bob replies with the first after for which and they repeat this procedure until or equals . It is not hard to see that if and only if there exists for which in which case Alice and Bob will find such (smallest) in the protocol above, if not the protocol will run for at most rounds and they decide that . We now mention a non-trivial protocol in the model for the majority function defined as . A trivial protocol for is similar to the protocol, on the th round, Alice sends (without the ) and Bob replies with . Note that this protocol takes bits ( for sending the index and to store ). Apriori this seems the best one can do, but interestingly using intricate ideas from number theory there exists a  [ST97, KP14] garden-hose protocol for computing . Plugging this in with Lemma 5.2 we get a protocol of cost for computing in the model.

An interesting question is, are these protocols for , , optimal? Are there more efficient protocols possibly with constant bits of communication in each round? In order to understand this, in the next section we show that the memoryless communication complexity is lower bounded by the standard non-deterministic communication complexity. Using this connection, we can show the tightness of the first three protocols. Additionally, we show that , thus the exact status of remains an intriguing open question.

### 4.1 Lower bounds on memoryless communication complexity

In the introduction, we mentioned that it is an interesting open question to find an explicit function  for which . Unfortunately we do not even know of an explicit function for which we can prove lower bounds better than (we discuss more about this in the open questions). However, it is not hard to show that for a random function , the memoryless communication complexity of is large.

###### Lemma

Let be a random function. Then,

###### Proof

The proof is via a simple counting argument. There are distinct functions . Consider an arbitrary -bit protocol. Let Alice and Bob’s local functions be given by and similarly . First observe that there are at most distinct messages that Alice can receive from Bob and there are at most distinct inputs , so the total number distinct messages that Alice can send to Bob (recall that Alice’s messages are given by ) is at most . Similarly Bob can send at most distinct messages to Alice. In total there are at most distinct protocols that can arise from an -bit protocol. If we have an protocol that computes an arbitrarily random function , then we need that , which implies .

We remark that similar ideas used in this lemma can be used to show that for all , there exists functions that can be computed using bits of communication in each round but not bits of communication. This gives rise to a space hierarchy theorem for the model.

#### 4.1.1 Non-deterministic complexity and memoryless complexity.

In this section we show that non-deterministic communication complexity can be used to provide lower bounds on the memoryless communication model. In the non-deterministic model, Alice is given , Bob is given , they need to compute where . In a non-deterministic protocol for , on input Alice guesses a proof that can convince Alice and Bob that is either or i.e., she guess a proof that is consistent with her input . If consistent she sends to Bob who receives and checks the consistency of with . If both player’s inputs are consistent with they output or respectively. The cost of the protocol is the size of . Non-deterministic communication complexity of any function  is the size of the smallest proofs for the worst case inputs of . For more on this subject, we refer the interested reader to [Wol03]. We now prove our main lemma.

###### Proof

Let and for the rest of the proof we fix the inputs for Alice and Bob respectively. First observe that the -protocol runs for at most rounds. In particular we argue that two messages of any given player in an protocol cannot be the same. We prove this fact by contradiction. Suppose for contradiction the protocol on input runs for rounds. Then let us assume that Alice sends the same message in both th and th round for . Recall that Bob’s message involves computing the function at each round and on the and th round his message will be identical . Thus Alice receives in both th round and th round, and she replies with the same message on the nd and nd round (since she applies the same function in both rounds to the same message) and so on. It is not hard to see that this protocol will be on an infinite loop without being able to perform the rounds of communication to compute . This contradicts the fact that the protocol ran for rounds. Thus any -bit memoryless protocol can have at most  rounds.

Now consider a -bit string given by

 T=(a1,…,a2s:=T1,a2s+1,…,a2s+1:=T2).

Furthermore, suppose is an indicator string for the messages that Alice sends to Bob in the protocol (i.e., if and only if the th message was sent to Bob in the rounds in the -bit protocol, where we implicitly are representing every -bit message with its integer value in ). Similarly, let be an indicator string which indicates which messages were sent from Bob to Alice in the rounds. Then we design a non-deterministic protocol in the following way: for every , suppose Alice guesses the string . Recall that in the protocol, Alice applies the function on the messages she received. Now, in the non-detereministic communication protocol, Alice uses the same function and verifies if is valid, i.e., she checks if one of the two conditions hold: 1) for every message of Bob (which she knows because they are present in ) there exists a message (indexed in the first half of ) such that , and 2) , , for a unique message . Suppose Alice observes that does not satisfy this verification, then she aborts the protocol, otherwise if passes this verification, she sends to Bob. Bob performs a similar verification. If Alice and Bob both do not abort, then one of them knows the output bit and outputs .

Observe that for every input , Alice can always guess a valid transcript . In order to check the validity of this transcript , she communicates to Bob. Once has passed the the verification test of both Alice and Bob, one player outputs . Hence which gives the lemma statement.

Using this lemma, we immediately get the following corollary.

###### Corollary

Let . Then .

This corollary follows immediately from Lemma 4.1.1 because the non-deterministic communication complexity of these functions are at least , thereby showing that the -bit protocols we described in the beginning of this section for the first three of these functions are optimal. However one drawback of Lemma 4.1.1 is that one cannot hope to prove a lower bound that is better than since for every function .

### 4.2 Characterization of memoryless communication

Papakonstantinou et al.  [PSS14] consider the memory-nomemory model of communication complexity wherein Alice has a memory and Bob doesn’t and they are restricted to one-way communication from Alice to Bob. They show a beautiful combinatorial rectangle-overlay characterization (denoted ) of the model. We briefly define below.

###### Definition (Rectangle overlay complexity [Pss14])

Let , . A length- rectangle overlay for is a collection satisfying the following:

• is a -monochromatic rectangle (i.e., where ) and .

• covers .

• For every , suppose was the first rectangle that contains , then .

Then, define is the smallest for which there exists a length- rectangle overlay for .

One of the main results of [PSS14] was the following characterization.

###### Theorem ([Pss14])

For every , we have

 logRO(F)≤M→(F)≤2logRO(F).

A natural question following their work is, can we even characterize our new general framework of communication complexity wherein both Alice and Bob do not have memory and the communication can be two-way. Generalizing the rectangle-based characterization of [PSS14] to our setting seemed non-trivial because in our communication model the memoryless-ness of the protocol doesn’t seem to provide any meaningful way to split the communication matrix into partitions or overlays (as far as we could analyze). Instead we characterize our communication model in terms of bipartite branching programs, which we define below.131313For a definition of general branching program (), refer to Section 2.

###### Definition (Bipartite Branching Program (BBP))

Let . A bipartite branching program is a that computes in the following way: for every , each node in the branching program is either labelled by a function or by ; the output of the note is given by or . We define as the size of the smallest program that computes for all .

Observe that in a every node no longer just queries at an arbitrary index (like in the standard ), but instead is allowed to compute an arbitrary Boolean function on  or . Of course, another natural generalization of is, why should the nodes of the program just compute Boolean-valued functions? We now define the generalized wherein each node can have out-degree (instead of out-degree in the case of and ).

###### Definition (Generalized Bipartite Branching Program (GBBP))

Let . A generalized bipartite branching program is a that computes in the following way: for every , each node in the branching program can have out-degree and labelled by the node , or by ; the output of each node is given by or . We define as the size of the smallest program that computes for all .

We now show that the generalized bipartite branching programs are not much more powerful than bipartite branching programs, in fact these complexity measures are quadratically related.

For , we have .

###### Proof

The first inequality is obvious as s are generalized version of s and thus can simulate s. Let . In order to see the second inequality, we show that every node in the can be computed using a with at most nodes: observe that if a node in has outputs then we can express this node using a binary tree of depth and size such that each node in this binary tree is indexed by a Boolean function. Hence we can replace every node in the using the argument above, and we get .

It is not clear if the quadratic factor loss in the simulation above is necessary and we leave it as an open question. We are now ready to prove our main theorem relating communication model and bipartite branching programs.

###### Theorem

For every , we have .

###### Proof

We in fact prove something stronger here, i.e., for all . Using Fact 4.2 we get the theorem statement.

We first prove . Let . Given an -bit protocol that computes , one can label all possible messages from Alice to Bob by the set and similarly all the messages from Bob to Alice by .141414Technically the number of messages exchanged between them should be a parameter , but for notational simplicity we assume they communication for rounds, where we used by the argument in the first paragraph of the proof of Lemma 4.1.1. Also let us suppose in the protocol, Alice and Bob have functions and respectively. Now we construct a generalized bipartite branching program that contains nodes, each node labelled by one of the messages which were exchanged between Alice and Bob in the  protocol. It remains to establish the edge-connections between the respective nodes as well as associate each node with a functions each mapping to . For any two pair of nodes we put an edge from to if and only if there exists some such that in the protocol computing . Similarly for any two pair of nodes we put an edge from to if and only if there exists some such that in the protocol. We now associate each node with a function . On every node , we associate the function defined as . Similarly on every node , we associate a function defined as . These functions dictate how the branching program routes between every two nodes. Finally, we make as the source node and we glue the nodes and together and designate it as a sink node . This completes the construction of the branching program. Note that all the edges are either from nodes to nodes or vice versa but not both. It now follows from the construction that for every the sequence of message (from ) exchanged between Alice and Bob is exactly the sequence of nodes traversed in the branching program when the functions are evaluated on the inputs . By the promise of the protocol, we have that the branching program computes , hence .

We now show the other direction, . Consider an arbitrary generalized bipartite branching program of size . Note that one can view a computing as a bipartite graph. Let us assume that , where the bi-partition sizes are and . We now construct an  protocol of cost at most . Suppose the nodes are labelled by . We now let (resp. ) be the binary number representations of the node label (resp. ). By the definition of a , there are no edges within the nodes labelled by and within nodes labelled by and we only have edges going between and . Moreover, by definition every node labelled by (resp. ) has a function (resp. ) associated with it, where . We now construct our protocol as follows: we define two sets of function