Gillat Kol (IAS)

joint work withRan Raz (Weizmann + IAS)

Interactive Channel Capacity

Binary Symmetric Channel with crossover probability (-BSC): Flips every bit w.p. , independently

Channel Capacity

1−𝜀

1−𝜀

0

1 1

0

𝜀𝜀

Alice wants to send an bit message to Bob. How many bits does Alice need to send over the-BSC, so Bob can retrieve w.h.p. ()? Answer [Shannon‘48]:

bitsnoiseless channel

bits-BSC

Channel Capacity

Channel Capacity

𝐻 (𝜀 )=−𝜀𝑙𝑜𝑔 𝜀− (1−𝜀 ) 𝑙𝑜𝑔(1−𝜀)

Alice and Bob want to have an bits long conversation. How many bits do they need to send over the -BSC, so both can retrieve the transcript w.h.p.?

Interactive Channel Capacity

bitsnoiseless channel

bits-BSC

Alice has input , Bob has input .They want to compute ( public). How many bits do they need to exchange?

Communication Complexity [Yao‘79]

𝑥

𝑓 (𝑥 , 𝑦 ) !

𝑦𝑚1 (𝑥 )𝑚2 ( 𝑦 ,𝑚1 )

𝑚3 (𝑥 ,𝑚1 ,𝑚2 ) . .adaptive!Protocol:

Players may use private and public randomnessNoiseless CC: = the least number of bits players need to exchange over the noiseless channel to compute w.h.p. for every Noisy CC: = the same when players communicate over the -BSC

Randomized CC

𝑥 ,𝑅 𝑦 ,𝑅

𝑓 (𝑥 , 𝑦 ) !

. .

Example 1: of Equality

𝑥≠ 𝑦 !

. .

R R

are -bit stringsEquality function: iff

Naïve protocol: exchanged bitsAlice sends to Bob

are -bit stringsEquality function: iff

Naïve protocol: exchanged bitsAlice sends to Bob

Efficient Protocol: exchanged bits; error By hashing (binning). E.g., take inner products with random strings

Example 1: of Equality

Underlying tree: complete binary tree

Example 2: of Pointer Jumping

Underlying tree: complete binary tree: an edge going out of every node in odd layers

Example 2: of Pointer Jumping

𝑥

Underlying tree: complete binary tree: an edge going out of every node in odd layers: an edge going out of every node in even layersPointer Jumping function: is the leaf reached by “chasing the pointers”

Example 2: of Pointer Jumping

𝑥 𝑦

Underlying tree: complete binary tree: an edge going out of every node in odd layers: an edge going out of every node in even layersPointer Jumping function: is the leaf reached by “chasing the pointers”

Example 2: of Pointer Jumping

𝑥 𝑦

Example 2: of Pointer Jumping

(left edge)

(left edge)( right edge)

( left edge)

𝑥 𝑦

(left edge)

(left edge)( right edge)

( left edge)

input size

protocol is fully adaptive, very susceptible to noise

𝑥 𝑦

Def: Interactive Channel Capacity

: Noiseless CC: Noisy CC

Interactive Channel Capacity

The interactive setting is more general:1. Allows interaction and adaptivity.

Shannon’s setting is one-way2. Allows any computation (function ). Shannon’s setting corresponds to interactive channel capacity channel capacity

In the interactive setting, error in the first round may cause the conversation to be meaningless. Need to correct “online’’!

Why is the Interactive Case More Challenging?

[Schulman ‘92]: – Theorem: If then

Corollary: – interactive channel capacity channel capacity

Many other works [Sch,BR,B,GMS,BK,BN,FGOS…]: – Simulation of any communication protocol with adversarial noise– Large constants, never made explicit

Previous Works𝐂𝐚𝐩 (𝛆 )=𝐥𝐢𝐦𝐢𝐧𝐟𝐧→∞

𝐦𝐢𝐧{𝐟 :𝐂𝐂 ( 𝐟 )=𝐧 }( 𝐂𝐂 (𝐟 )

𝐂𝐂𝛆 (𝐟 ))

?

Our Results

Theorem 1 (Upper Bound):

For small : interactive channel capacity is strictly smaller than channel capacity

Theorem 2 (Lower Bound):

(for the case of alternating turns)

𝐂𝐚𝐩 (𝛆 )=𝐥𝐢𝐦𝐢𝐧𝐟𝐧→∞

𝐦𝐢𝐧{𝐟 :𝐂𝐂 ( 𝐟 )=𝐧 }( 𝐂𝐂 (𝐟 )

𝐂𝐂𝛆 (𝐟 ))

In our model, exactly one player sends a bit at each time step

– The order of turns in a protocol is pre-determined (independent of the inputs, randomness, noise).

– Alternating turns is a special case

Channel Types & Communication Order

Lower Bound: A simulation protocol

𝐂𝐚𝐩 (𝛆 )=𝐥𝐢𝐦𝐢𝐧𝐟𝐧→∞

𝐦𝐢𝐧{𝐟 :𝐂𝐂 ( 𝐟 )=𝐧 }( 𝐂𝐂 (𝐟 )

𝐂𝐂𝛆 (𝐟 ))

SimulationGiven a communication protocol P, we simulate P over the -BSC

Simulation Idea: Run P for a few rounds and check for errors. If an error occurred, backtrack

Parameter: s.t.

The simulation protocol is recursive:– The basic step simulates steps of P– The th inductive step simulates steps of P

𝐂𝐚𝐩 (𝛆 )=𝐥𝐢𝐦𝐢𝐧𝐟𝐧→∞

𝐦𝐢𝐧{𝐟 :𝐂𝐂 ( 𝐟 )=𝐧 }( 𝐂𝐂 (𝐟 )

𝐂𝐂𝛆 (𝐟 ))

Simulating Protocol: Basic StepPlayers run steps of P. Alice observes transcript , and Bob transcript

Players run an bit consistency check:Compute by hashing (binning)

A player that finds an inconsistency starts overand removes this step’s bits from his transcript

bits of protocol P bitconsistency check

inconsistency

list of all massages exchanged

Players run the Basic Step consecutive times. Alice observes transcript , and Bob transcript

Simulating Protocol: 1st Interactive Step

times

Simulating Protocol: 1st Interactive StepPlayers run the Basic Step consecutive times. Alice observes transcript , and Bob transcript

Players run an bit consistency check: Compute by hashing (binning)

A player that finds an inconsistency starts over and removes this step’s bits from his transcript

timesinconsistency

bits

Analysis: CorrectnessThe final protocol simulates P w.p. : If an error occurred or the players went out of sync, they will eventually fix it, as the consistency check checks the whole transcript so far and is done with larger and larger parameters

timesinconsistency

bits

Analysis: Waste in Basic StepLength of consistency check: bitsProbability to start over: Total waste (in expectation): + bits was chosen to balance the two losses!Fraction of bits wasted:

𝜀=𝑙𝑜𝑔𝑘 /𝑘2

bits of protocol P bitconsistency checkinconsistency

Analysis: Waste in Basic StepLength of consistency check: bitsProbability to start over: Total waste (in expectation): + bits was chosen to balance the two losses!Fraction of bits wasted:

The waste in the inductive steps is much smaller!

𝜀=𝑙𝑜𝑔𝑘 /𝑘2

Upper Bound: Example of with

𝐂𝐚𝐩 (𝛆 )=𝐥𝐢𝐦𝐢𝐧𝐟𝐧→∞

𝐦𝐢𝐧{𝐟 :𝐂𝐂 ( 𝐟 )=𝐧 }( 𝐂𝐂 (𝐟 )

𝐂𝐂𝛆 (𝐟 ))

Underlying tree: -ary tree, depth Parameter (as before): s.t. : an edge going out of every node in odd layers: an edge going out of every node in even layers-Pointer Jumping: is the leaf reached by “chasing the pointers”

Example: -Pointer Jumping

dept

h =

deg=

Observe, We prove - involved! Such lower bounds are typically up-to a constant.

The capacity comes from the second order terms

Upper Bound Outline 𝜀=𝑙𝑜𝑔𝑘 /𝑘2

𝐂𝐚𝐩 (𝛆 )=𝐥𝐢𝐦𝐢𝐧𝐟𝐧→∞

𝐦𝐢𝐧{𝐟 :𝐂𝐂 ( 𝐟 )=𝐧 }( 𝐂𝐂 (𝐟 )

𝐂𝐂𝛆 (𝐟 ))

deg=

dept

h =

deg=

Bounding : Intuition“Any good protocol does the following:”Alice starts by sending the first edge ( bits)

w.p. a bit was flipped

Case 1: Alice sends additional bits to correct first edge Even if a single error occurred and Alice knows its index, she needs to send the index bit waste

Case 2: Bob sends the next edge ( bits) w.p. Bob had wrong first edge and these bits are wasted In expectation, bit waste

In both cases, sending the first edge costs ! was chosen to balance the two losses

deg= 𝜀=𝑙𝑜𝑔𝑘 /𝑘2

Thank You!