18.404/6.

840 Lecture 23

Last time:
- !"#$%↑ is EXPSPACE-complete
- Thus !"#$%↑ ∉ PSPACE
- Oracles and P versus NP
Today: (Sipser §10.2)
- Probabilistic computation
- The class BPP
- Branching programs

1
 Probabilistic TMs
Defn: A probabilistic Turing machine (PTM) is a variant of a NTM
where each computation step has 1 or 2 possible choices.

deterministic coin flip step -

step each choice has 50% probability

computation tree
Pr[ branch ! ] = 2&' where ! has ( coin flips for " on #

Pr[ " accepts # ] = + Pr[ branch ! ]

b accepts
branch !
Pr[ " rejects # ] = 1 − Pr[ " accepts # ]
Defn: For 7 ≥ 0 say PTM " decides language : with error probability 7
if for every #, Pr[ " gives the wrong answer about # ∈ : ] ≤ 7
i.e., # ∈ : → Pr[ " rejects # ] ≤ 7
# ∉ : → Pr[ " accepts # ] ≤ 7.
2
 The Class BPP

Defn: BPP = " some poly-time PTM decides " with error # = %⁄& }

Amplification lemma: If '% is a poly-time PTM with error #% < %⁄) then,
for any 0 < #) < %⁄), there is an equivalent poly-time PTM ') with error #) .
Can strengthen to make #) < 2−,-./ 0 .
Proof idea: ') = “On input 1
1. Run '% on 1 for 2 times and output the majority response.”
Details: Calculation to obtain 2 and the improved error probability.
Significance: Can make the error probability so small it is negligible.

3
 NP and BPP
NP BPP
Computation trees
for ! on "

"∈$

Many accepting Few

≥ 1 accepting
rejecting
Check-in 23.1
Which of these are known to be true?
Check all that apply.
(a) BPP is closed under union.
"∉$ (b) BPP is closed under complement.
(c) P ⊆ BPP
all rejecting Few accepting Many rejecting
(d) BPP ⊆ PSPACE

Check-in 23.1
4
 Example: Branching Programs

Defn: A branching program (BP) is a directed, acyclic (no cycles) graph that has
1. Query nodes labeled !" and having two outgoing edges labeled 0 and 1.
2. Two output nodes labeled 0 and 1 and having no outgoing edges.
3. A designated start node.
BP # with query nodes !$ , … , !' describes a Boolean function (: 0,1 ' → {0,1}:
Follow the path designated by the query nodes’ outgoing edges
!$
from the start note until reach an output node. 0 1
Example: For !$ = 1, !/ = 0, !0 = 1 we have ( 101 = 0 = output. !/ !0
0 1 0 1
BPs are equivalent if they describe the same Boolean function.
Defn: 12BP = #$ , #/ #$ and #/ are equivalent BPs (written #$ ≡ #/ ) } !0 !$ 0 !/
1 1
0
Theorem: 12BP is coNP-complete (on pset 6) 0 1

12BP ∈ BPP ? Unknown. That would imply NP ⊆ BPP and would be surprising! 0 1
Instead, consider a restricted problem.
5
 Read-once Branching Programs

Defn: A BP is read-once if it never queries a variable more than once

on any path from the start node to an output.
Defn: !"ROBP = () , (+ () and (+ are equivalent read-once BPs}
Theorem: !"ROBP ∈ BPP .)
0 1
Check-in 23.2 .+ ./
Assuming (as we will show) that !"ROBP ∈ BPP, 0 1 0 1
can we use that to show !"BP ∈ BPP by converting ./ .) .+
1 0
branching programs to read-once branching programs? 0 1
0 1
(a) Yes, there is no need to re-read inputs.
(b) No, we cannot do that conversion in general. 0 1
(c) No, the conversion is possible but not in polynomial-time. Not read-once

6 Check-in 23.2
 !"ROBP ∈ BPP

Theorem: !"ROBP ∈ BPP

Proof attempt: Let ( = “On input *+ , *-
1. Pick . random input assignments and evaluate *+ and *- on each one.
2. If *+ and *- ever disagree on those assignments then reject.
If they always agree on those assignments then accept.”
What . to chose? *+ *-
If *+ ≡ *- then they always agree so Pr[ ( accepts *+ , *- ] = 1 0
8+
1 0
89
1

If *+ ≢ *- then want Pr[ ( accepts *+ , *- ] ≤ +⁄3

so want Pr[ ( rejects *+ , *- ] ≥ -⁄3 .
But *+ and *- may disagree rarely, say in 1 of the 26 possible assignments.
That would require exponentially many samples to have a good chance of 0 1 0 1

finding a disagreeing assignment and thus would require . > -⁄3 26 .

But then this algorithm would use exponential time.
Try a different idea: Run *+ and *- on non-Boolean inputs.

7
 Boolean Labeling

Alternative way to view BP computation

Show by example: Input is !" = 0, !# = 1, !$ = 1
1 The BP follows its execution path.
!" Label all nodes and edges on the execution path with 1
0 1 and off the execution path with 0.
1 0
Output the label of the output node 1.
1 !
# !# 0
1 0 Obtain the labeling inductively by using these rules:
0 1 0 1
0 0

0 ! 1 ' '#
$ !$ !)
1 0 '"
0 0 0 1 0 1 '$
0 1 ' ∧ !) ' ∧ !)
'" ∨ '# ∨ '$
0
0 1 1
Label edges from nodes Label nodes from incoming edges

8
 Arithmetization Method

Method: Simulate ∧ and ∨ with + and ×.

' ∧ / → '×/ = '/
' → 1−'
%,
' ∨ / → ' + / − '/
0 1

%- %- Replace Boolean labeling with arithmetical labeling

1 0
0 1 Inductive rules:
Start node labeled 1
'-
%. %. ' ', '.
1 0 %&
0 1
' (1'−∧%%&&) 0 1
'∧
%&%& + ''-- ∨+''..
', ∨
Works because the BP is acyclic.
0 1 The execution path can enter a node
at most one time.
9
 Non-Boolean Inputs
Use the arithmetized interpretation of the BP’s computation
to define its operation on non-Boolean inputs.
Example: !" = 2, !# = 3 Output = −7

1
Recall labeling rules:
!" )
!( )#
0 1 0 1 )" )-
1 2 =2
) (1 − !( ) ) !(
−1 = 1 1 − 2 )" + )# + )-

−1 2
!# !# Check-in
Revised 23.3
4 for 56ROBP: “On input ;" , ;#
0 1 1
0 What1. isPick
theaoutput
randomfornon-Boolean
this branching program
input using
assignment.
2 = −1 1 − 3 2 1 − 3 = −4 the 2.
arithmetized
Evaluate ;interpretation if !" = 1, !# = < ?
" and ;# on that assignment.
(a) 3.(1If−;"<)and ;# disagree then reject.
−3 = −1 3
2 3 =6 (b) (<If+they1) agree then accept.”
8=2+6 0 −3 + −4 = −7 (c) Correctness
< proof… after Thanksgiving.
1
Check-in 23.3
10
 Quick review of today

1. Defined probabilistic Turing machines

2. Defined the class BPP
3. Sketched the amplification lemma
4. Introduced branching programs and read-once branching programs
5. Started the proof that !"ROBP ∈ BPP
6. Introduced the arithmetization method

11
MIT OpenCourseWare
https://ocw.mit.edu

18.404J / 18.4041J / 6.840J Theory of Computation

Fall 2020

For information about citing these materials or our Terms of Use, visit: https://ocw.mit.edu/terms.