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