Randomized Computation
description
Transcript of Randomized Computation
Randomized Computation
Roni Parshani 025529199
Orly Margalit 037616638
Eran Mantzur 028015329
Avi Mintz 017629262
RP – Random Polynomial Time
Denotation:• L is Language• M is probabilistic polynomial time turning
machine
Definition:L RP if M such that
• x L Prob[ M(x) = 1 ] ½• x L Prob[ M(x) = 0 ] = 1
RP – Random Polynomial Time
The disadvantage of RP (coRP) is when the “Input” doesn’t belong to language (does belong to the language) the machine needs to return a correct answer at all times.
Definition:• x L L(x) = 1• x L L(x) = 0
RP NP• Proof:
– Given: L RP– Aim : L NP
LRP xL M such that more than 50% of y give
M(x,y) = 1 y : M(x,y) = 1 xL y M(x,y) = 0
LNP
coRP - Complementary Random Polynomial Time
Definition:
L coRP if M such that • x L Prob[ M(x) = 1 ] = 1
• x L Prob[ M(x) = 0 ] ½
An alternative way to define coRP iscoRP = { : L RP }
_L
coRP co-NP
• Proof:– Give: L coRP– Aim : L co-NP
LcoRP RP NP Lco-NP
_L
_L
RP1
P(.) is a polynomial
Definition:
L RP1 if M, p(.) such that • x L Prob[ M(x,r) = 1 ] • x L Prob[ M(x,r) = 0 ] = 1
|)xp(|1
RP2
P(.) is a polynomial
Definition:
L RP2 if M, p(.) such that • x L Prob[ M(x,r) = 1 ] 1 – 2-p(|x|)
• x L Prob[ M(x,r) = 0 ] = 1
RP1 = RP2 = RP
• Aim: RP1 = RP2
RP2 RP1
we can always select a big enough x such that
< 1 – 2-p(|x|)|)xp(|1
RP1 = RP2 = RP
RP1 RP2
L RP1 M, p(.) such that
xL Prob[ M(x,r) = 1 ]
we run M(x,r) t(|x|) times:• If in any of the runs M(x,r) = 1 output is 1• If in all of the runs M(x,r) = 0 output is 0
|)xp(|1
RP1 RP2
Select t(|x|) ≥
Therefore if xL output is 0
If xL the probability of outputting 0 is only if M(x,r) = 0 all t(|x|) times( Prob[M(x,r) = 0] )t(|x|) ≤ (1- )t(|x|)
[1- ] ≤ 2-p(|x|)
|)xp(|1
|)xp(|1
e2
log² |)xp(|
e2log
² |)xp(|
RP1 RP2
So the probability of outputting 1 is larger than 1- 2- p(|x|)
L RP2
Conclusion: RP1 RP RP2 RP1
Therefore RP1 = RP = RP2
BPP – Bounded Probability Polynomial Time
Definition:L BPP if M such that
• x L Prob[ M(x) = 1 ] ⅔ • x L Prob[ M(x) = 1 ] <
In other words:x : Prob[ M(x) = L(x) ] ⅔
31
coBPP = BPP
coBPP = { : L BPP }
= { : M : Prob[ M(x) = L(x) ] ⅔}
= { : : Prob[ (x) = (x) ] ⅔}
= BPP
= 1 – M(.)
(M(.) exists iff (.) exists)
_L
_L_L M M
L
M
M
BPP1
Previously we defined stricter and weaker definition for RP, in a similar way we will define for BPP.
Denotation:• p(.) – positive polynomial• f – polynomial time computable function
Definition:L BPP1 if M, p(.), f such that
• x L Prob[ M(x) = 1 ] f(|x|) +• x L Prob[ M(x) = 1 ] < f(|x|) -
|)xp(|1
|)xp(|1
BPP = BPP1
Proof:
Aim: BPP BPP1
f(|x|) = ½ and p(|x|) = 6
This gives the original definition of BPP.
BPP = BPP1
Proof:
Aim: BPP1 BPP
L BPP1 M such that
xL Prob [ M(x) = 1] f(|x|) +
xL Prob [ M(x) = 1] < f(|x|) –
|)xp(|1
|)xp(|1
BPP1 BPP
we want to know with Prob > ⅔
if 0 p f(|x|) – 1/p(|x|)
or if f(|x|) + 1/p(|x|) p 1
Define: M’ runs M(x) n times, and each M(x) returns
If > f(|x|) M’ returns YES, else NO
n
iitn 1
1it
BPP1 BPP
Calculation of n
We run n independent Bernoulli variables with p ½ and
Prob < 2 =
n
iix 1 )1(0: pp
pn
xn
ii
1
nppe )1(2
2
n
e 412
2
2
222 ne
BPP1 BPP
Choose : and
Result: M’ decides L(M) with Prob > ⅔
|)(|
1
xp
2261
ln
n
BPP2
Denotation:
• p(.) – positive polynomial
Definition:
L BPP2 if M, p(.) such that
x : Prob[ M(x) = L(x) ] 1-2-p(|x|)
BPP BPP2
Proof:
Aim: BPP BPP2
p(|x|) =
This gives the original definition of BPP.
)2ln()31ln(
BPP BPP2
Proof:Aim: BPP BPP2
L BPP M : x Prob[ M(x) = L(x) ] ⅔ Define: M’ runs M(x) n times, and each M(x) returns If > ½ M’ returns YES, else NO We know : Exp[M(x)] > ⅔ xL Exp[M(x)] < x L
it
n
i itn 1
1
31
BPP BPP2
Chernoff’s Equation :
Let {X1 , X2 , … , Xn} be a set of independent Bernoulli variables with the same expectations p ½ ,and : 0< p(p-1)
Then
Prob 221 2
n
n
i i epn
x
BPP BPP2
From Chernoff’s equation :
Prob[|M’(x) – Exp[M(x)]| ]
But if |M’(x) – Exp[M(x)]|
then M’ returns a correct answer
61
61
1821n
e
BPP BPP2
Prob[M’(x)= L(x) ]
polynomial P(x) we choose n such that
Prob[M’(x) = L(x) ]
L BPP2
18|)(| 22n
xP e
1821n
e
|)(|21 xp
RP BPP
Proof:L RP if M such that
• x L Prob[ M(x) = 1 ] ½• x L Prob[ M(x) = 0 ] = 1
We previously proved BPP = BPP1If we place in BPP1 formula with f(.) and p(.)4
this gives the original definition of RP.
41
P BPP
Proof:
L P M such that M(x) = L(x)
x : Prob[ M(x) = L(x) ] =1 ⅔
L BPP
PSPACE
Definition:
L PSPACE if M such that M(x) = L(x)
and p such that M uses p(|x|) space.
(No time restriction)
PP – Probability Polynomial Time
Definition:L PP if M such that
• x L Prob[ M(x) = 1 ] > ½ • x L Prob[ M(x) = 1 ] ½
In other wordsx : Prob[ M(x) = L(x) ] > ½
PP PSPACE
Definition: (reminder)L PP if M such that
x : Prob[ M(x) = L(x) ] ½
Proof:L PP M, p(.) such that
x: Prob[ M(x,r) = L(x) ] > ½ and M is polynomial time.
• If we run M on r, M is correct more than 50% of the time.
PP PSPACE
Aim: L PSPACE
• Run M on every single r.
• Count the number of received “1” and “0”.
• The correct answer is the greater result.
PP PSPACE
• By the definition of PP, every L PP this algorithm will always be correct.
• M(x,r) is polynomial in space
New algorithm is polynomial in spaceL PSPACE
Claim: PP = PP1
If we have a machine that satisfies PP it also satisfies PP1
(Since PP is stricter then PP1 and demands grater then 1/2
and PP demands only, equal or grater to ½) so clearly
1PPLPPL
1PPPP
Let M be a language in PP1
Motivation
The trick is to build a machine that will shift the answer
of M towards the NO direction with a very small
probability that is smaller than the smallest probability
difference that M could have. So if M is biased towards
YES our shift will not harm the direction of the shift.
But if there is no bias(or bias towards NO) our shift will
give us a bias towards the no answer.
PPPP 1
Proof:
Let M’ be defined as:
)),...,,(,(
0...
)),...,,,,...,,(,('
|)(|21
1|)(|21
|)(|211|)(|21
xp
xp
xpxp
bbbxM
returnelse
NOreturnthen
aaaif
defbbbaaaxM
• With probability return NO
• With probability invoke M
1|)(|(2
xp
1|)(|(21
xp
M’ chooses one of two moves.
If :
2/1)1|)(|2(
2
)2|(|2
|)(|22/1
)1|)(|(
21()|)(|
22/1(
))1|)(|(
21(]1)([Prob]1)('[Prob
xp
xpxp
xpxp
xpxMxM
LX
2/1|)(|
2)2|(|
22/1
1|)(|(2)
1|)(|(21(2/1
))1|)(|(
21(]0)([Prob]0)('[Prob
xpxp
xpxp
xpxMxM
If :LX
PPL
Suppose that is decided by a non deterministic
machine M with a running time that is bounded by the
polynomial p(x).
The following machine M’ then will decide L according to
the following definition:
NPL
PPNP:Claim
YESreturnelse
bbbxMreturnthenbifdefbbbxM
xpxp
)),...,,(,(1)),...,,(,('
1|)(|2111|)(|21
M’ uses it’s random coin tosses as a witness to M with
only one toss that it does not pass to M’. This toss is
used to choose it’s move. One of the two possible
moves gets it to the ordinary computation of M with
the same input(and the witness is the random input).
The other choice gets it to a computation that always
accepts.
Consider string x.
If M doesn't have an accepting computation then the
probability that M’ will answer 1 is exactly 1/2.
On the other hand, if M has at least one accepting
computation the probability that M’ will answer correctly is
greater then 1/2.
Meaning and by the
previous claim (PP = PP1) we get that .
So we get that:
2/1]1)('[
2/1]1)('[
xMprobLx
xMprobLx
1PPL PPL
ZPP – Zero Error Probability
We define a probabilistic turning machine which is allowed to reply “I Don’t Know” which will be symbolized by “┴”.
Definition:L ZPP if M such that
x : Prob[ M(x) = ┴ ] ≤ ½ x : Prob[ M(x) = L(x) or M(x) = ┴ ] = 1
coRP RP ZPP: Claim
Take . Let M be a “ZPP machine”.
We will build a machine M’ that decides L according to
the definition of RP.
itselfboutputelse
outputthenbif
xMb
defxM 0
)(
)('
ZPPL
RP ZPP
If
then by returning 0 when
we will always answer correctly because in this case
LX )(xM
0)(')()(')( xMxXxMxM L
If
the probability of getting the right answer with M’ is
greater then 1/2 since M returns a definite answer with
probability greater then 1/2 and M’s definite answers
are always correct.
LX
In the same way it can be seen that by defining M’(x) as:
we get that
RP ZPP co
itselfboutputelse
outputthenbif
xMb
defxM 0
)(
)('
RP ZPP co
ZPPcoRPRP
0return then No says if),(Mrun
1return then Yes says if),(Mrundef (x)M'
:follows as (x)M' define Wemachine.coRPtheand
machinebeLet. that Assume
coRP
RP
x
x
M
RPtheMcoRPRPL
coRP
RP
If
then we will get a YES answer from
and hence from M’ with probability greater then 1/2.
If
then we will get a NO answer from
and hence from M’ with probability greater
then 1/2.
LX
LX
RPM
coRPM
ZPPcoRPRP
RSPACE – Randomized Space Complexity
Definition:
RSPACE (s) = L RP such that MRP uses at most s(|x|) space and exp( s(|x|) ) time.
BadRSPACE (s) = RSPACE (s) without time restriction.
Claim: badRSPACE = NSPACE
badRSPACE NSPACE
Let L badRSPACE.
If x L
that means there is at least one witness and the non
deterministic machine of NSPACE will choose it.
If x L
that means there are no witnesses at all therefore the
non deterministic machine of NSPACE also will not
find a solution.
NSPACE badRSPACE
L NSPACE. M is the Non - deterministic Turing
machine which decides L in space S(|x|).
If x L
there exists r of length exp(S(|x|), so that M(x,r) = 1,
where r is the non-deterministic guess used by M.
Therefore the probability of selecting r so that
M(x,r) = 1 is at least
|))(|exp(2
xS
So if we repeatedly invoke M(x,.) on random r’s we can
expect that after tries we will see an
accepting computation.
So what we want our machine M’ to do is run M on x and a
newly randomly selected r (of length exp(S(|x|))) for about
times and accept iff M accepts in one of these
tries.
|))(|exp(2
xS
|))(|exp(2
xS
Problem:
In order to count to
we need a counter that uses space of exp(S(|x|)),
and we only have S(|x|).
|))(|exp(2
xS
Solution:
We will use a randomized counter that will use only S(|x|)
space.
We flip k = coins.
if all are heads then stop else go on. The expected num of
tries .
But the real counter only needs to count to k and therefore
only needs space of .
|))(|exp(22log
xS
|)(||))(|exp(
2loglog 22 xSxS
k2