kb/data/en.wikipedia.org/wiki/Communication_complexity-2.md

---
title: "Communication complexity"
chunk: 3/8
source: "https://en.wikipedia.org/wiki/Communication_complexity"
category: "reference"
tags: "science, encyclopedia"
date_saved: "2026-05-05T14:40:16.151030+00:00"
instance: "kb-cron"
---

Where x and y agree, 
  
    
      
        
          z
          
            i
          
        
        ∗
        
          x
          
            i
          
        
        =
        
          z
          
            i
          
        
        ∗
        
          c
          
            i
          
        
        =
        
          z
          
            i
          
        
        ∗
        
          y
          
            i
          
        
      
    
    {\displaystyle z_{i}*x_{i}=z_{i}*c_{i}=z_{i}*y_{i}}
  
 so those terms affect the dot products equally. We can safely ignore those terms and look only at where x and y differ. Furthermore, we can swap the bits 
  
    
      
        
          x
          
            i
          
        
      
    
    {\displaystyle x_{i}}
  
 and 
  
    
      
        
          y
          
            i
          
        
      
    
    {\displaystyle y_{i}}
  
 without changing whether or not the dot products are equal. This means we can swap bits so that x contains only zeros and y contains only ones:

  
    
      
        
          
            {
            
              
                
                  
                    x
                    ′
                  
                  =
                  00
                  …
                  0
                
              
              
                
                  
                    y
                    ′
                  
                  =
                  11
                  …
                  1
                
              
              
                
                  
                    z
                    ′
                  
                  =
                  
                    z
                    
                      1
                    
                  
                  
                    z
                    
                      2
                    
                  
                  …
                  
                    z
                    
                      
                        n
                        ′
                      
                    
                  
                
              
            
            
          
        
      
    
    {\displaystyle {\begin{cases}x'=00\ldots 0\\y'=11\ldots 1\\z'=z_{1}z_{2}\ldots z_{n'}\end{cases}}}
  

Note that 
  
    
      
        
          z
          ′
        
        ⋅
        
          x
          ′
        
        =
        0
      
    
    {\displaystyle z'\cdot x'=0}
  
 and 
  
    
      
        
          z
          ′
        
        ⋅
        
          y
          ′
        
        =
        
          Σ
          
            i
          
        
        
          z
          
            i
          
          ′
        
      
    
    {\displaystyle z'\cdot y'=\Sigma _{i}z'_{i}}
  
. Now, the question becomes: for some random string 
  
    
      
        
          z
          ′
        
      
    
    {\displaystyle z'}
  
, what is the probability that 
  
    
      
        
          Σ
          
            i
          
        
        
          z
          
            i
          
          ′
        
        =
        0
      
    
    {\displaystyle \Sigma _{i}z'_{i}=0}
  
?  Since each 
  
    
      
        
          z
          
            i
          
          ′
        
      
    
    {\displaystyle z'_{i}}
  
 is equally likely to be 0 or 1, this probability is just 
  
    
      
        1
        
          /
        
        2
      
    
    {\displaystyle 1/2}
  
. Thus, when x does not equal y,

  
    
      
        P
        r
        o
        
          b
          
            z
          
        
        [
        A
        c
        c
        e
        p
        t
        ]
        =
        1
        
          /
        
        2
      
    
    {\displaystyle Prob_{z}[Accept]=1/2}
  
. The algorithm can be repeated many times to increase its accuracy. This fits the requirements for a randomized communication algorithm.
This shows that if Alice and Bob share a random string of length n, they can send one bit to each other to compute 
  
    
      
        E
        Q
        (
        x
        ,
        y
        )
      
    
    {\displaystyle EQ(x,y)}
  
. In the next section, it is shown that Alice and Bob can exchange only ⁠
  
    
      
        O
        (
        log
        ⁡
        n
        )
      
    
    {\displaystyle O(\log n)}
  
⁠ bits that are as good as sharing a random string of length n. Once that is shown, it follows that EQ can be computed in ⁠
  
    
      
        O
        (
        log
        ⁡
        n
        )
      
    
    {\displaystyle O(\log n)}
  
⁠ messages.

=== Example: GH ===
For yet another example of randomized communication complexity, we turn to an example known as the gap-Hamming problem (abbreviated GH). Formally, Alice and Bob both maintain binary messages, 
  
    
      
        x
        ,
        y
        ∈
        {
        −
        1
        ,
        +
        1
        
          }
          
            n
          
        
      
    
    {\displaystyle x,y\in \{-1,+1\}^{n}}
  
 and would like to determine if the strings are very similar or if they are not very similar. In particular, they would like to find a communication protocol requiring the transmission of as few bits as possible to compute the following partial Boolean function,

  
    
      
        
          
            GH
          
          
            n
          
        
        (
        x
        ,
        y
        )
        :=
        
          
            {
            
              
                
                  −
                  1
                
                
                  ⟨
                  x
                  ,
                  y
                  ⟩
                  ≤
                  
                    
                      n
                    
                  
                
              
              
                
                  +
                  1
                
                
                  ⟨
                  x
                  ,
                  y
                  ⟩
                  ≥
                  
                    
                      n
                    
                  
                  .
                
              
            
            
          
        
      
    
    {\displaystyle {\text{GH}}_{n}(x,y):={\begin{cases}-1&\langle x,y\rangle \leq {\sqrt {n}}\\+1&\langle x,y\rangle \geq {\sqrt {n}}.\end{cases}}}
  

Clearly, they must communicate all their bits if the protocol is to be deterministic (this is because, if there is a deterministic, strict subset of indices that Alice and Bob relay to one another, then imagine having a pair of strings that on that set disagree in 
  
    
      
        
          
            n
          
        
        −
        1
      
    
    {\displaystyle {\sqrt {n}}-1}
  
 positions. If another disagreement occurs in any position that is not relayed, then this affects the result of 
  
    
      
        
          
            GH
          
          
            n
          
        
        (
        x
        ,
        y
        )
      
    
    {\displaystyle {\text{GH}}_{n}(x,y)}
  
, and hence would result in an incorrect procedure.
A natural question one then asks is, if we're permitted to err 
  
    
      
        1
        
          /
        
        3
      
    
    {\displaystyle 1/3}
  
 of the time (over random instances 
  
    
      
        x
        ,
        y
      
    
    {\displaystyle x,y}
  
 drawn uniformly at random from 
  
    
      
        {
        −
        1
        ,
        +
        1
        
          }
          
            n
          
        
      
    
    {\displaystyle \{-1,+1\}^{n}}
  
), then can we get away with a protocol with fewer bits? It turns out that the answer somewhat surprisingly is no, due to a result of Chakrabarti and Regev in 2012: they show that for random instances, any procedure that is correct at least 
  
    
      
        2
        
          /
        
        3
      
    
    {\displaystyle 2/3}
  
 of the time must send 
  
    
      
        Ω
        (
        n
        )
      
    
    {\displaystyle \Omega (n)}
  
 bits worth of communication, which is to say essentially all of them.