Oblivious Turing Machines

8/2/2019 Oblivious Turing Machines

http://slidepdf.com/reader/full/oblivious-turing-machines 1/16

Complexiteit van Algoritmen:

Oblivious Turing Machines

Tom Desair

Willem Van Onsem

18 april 2012

And we forget because we must and not becausewe will.“

”- Matthew Arnold



Inhoudsopgave

1 Tijdscomplexiteit 2

2 Specifieke Complexiteitsklassen 5

3 Gerelativeerde Oblivious Turing Machines 6

4 Logische circuits 9

5 Andere toepassingen 11

5.1 Software beveiliging . . . . . . . . . . . . . . . . . . . . . . . . . 115.2 Cryptografie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

6 Open problemen 13

Inleiding

Een oblivious turing machine is een turingmachine waarbij de bewegingen vande lees- en schrijf-kop(pen) uitsluitend afhangen van de grootte van de invoer n.Belangrijke namen in dit domein zijn Michael Fisher, Nicolas Pippenger, FredHennie en Richard Stearns. In dit verslag zullen we onder meer het verschil incomplexiteit tussen een algemene turing machine en zijn oblivious equivalentonderzoeken. Verder bekijken we verbanden tussen een oblivious turing ma-chine en andere computationele structuren zoals logische circuits. We besluitenhet verlag met enkele toepassingen van oblivious turing machines. Ook in dealgoritmiek komt het oblivious-concept frequent voor, we kunnen bijvoorbeelddenken aan het BubbleSort algoritme.

Alvorens we de eigenschappen bespreken geven we eerst een formele definitievan een oblivious turing machine:Definitie 1 (Oblivious Turing Machine). Een k-tape turing machine M wordtoblivious genoemd indien:

1. Alle lees- en schrijfkoppen nooit links van hun beginpositie bewegen.

2. Indien M een finale toestand bereikt, brengen alle toekomstige stappengeen wijzigingen meer toe aan de tapes.

3. Voor alle n, s ∈ N en x ∈ 0, 1n

zijn de posities van de lees- en schrijf-

koppen1 voor een invoer x en na s stappen voor alle tapes gegeven doorK 0 (n, s) , . . . K k+1 (n, s). Met K i : N× N → N.

[18, §2.1]

We kunnen ons op basis van de definitie afvragen of een oblivious turing machinelouter een theoretisch model is. Er blijkt echter een belangrijke connectie te be-staan tussen de complexiteit van een oblivious turing machine en de grootte vaneen booleaans circuit die eenzelfde bewerking uitvoert. Ook in de cryptografiemaakt men gebruik van het oblivious aspect. Dit aspect heeft ook een nut in

1K 0 is kop van de invoertape, K 1, . . . K k de koppen bij de werktapes en K k+1 de uitvoer-tape.

1



andere vormen van secirty zoals bijvoorbeeld softwarebeveiliging. We bespreken

deze toepassingen verder in sectie 5.

1 Tijdscomplexiteit

Om een complexiteitsgrens te definieren die de overhead bepaald van een obli-vious turing machine tegenover een algemene turingmachine, zullen we een me-thode ontwikkelen die een algemene turing machine emuleert op een oblivious2-tape turing machine. Dit bewijs is het bewijs van Hennie-Stearns, en is eenconstructief bewijs dat stelt:

Lemma 1 (Hennie-Stearns). Indien een algoritme A met een deterministi-

sche turing machine in tijd T (n) een invoer van lengte n kan beslissen, be-staat er een deterministische oblivious 2-tape turing machine die dit algoritmein O (T (n)log(T (n))) kan beslissen.

Dit bewijs steunt op de constructie van een universele turing machine2. Er isechter nog geen bewijs gevonden die stelt dat dit de ondergrens3 is.

Bewijs. Het bewijs bestaat grofweg uit twee delen: in het eerste deel construerenwe een universele turing machine, in het tweede deel vormen we deze universeleturing machine om tot een oblivious turing machine en dit met lineaire overhead.Het eerste deel staat ook in de cursustekst, en wordt bijgevolg in beknopte vormbeschreven.

We vertrekken vanuit het idee dat we de verschillende tapes op een tape kunnenplaatsen. Dit doen we door een tape te construeren die afwisselend een karaktervan tape 1, 2, . . . , k , 1, 2, . . . , k op de band heeft staan. Dit illustreren we opfiguur 1. Deze eigenschap laat ook toe dat we de verschillende tapes onafhan-kelijk van elkaar kunnen doorschuiven: we kunnen door alle posities ∀i : i · k + jop te schuiven naar i · k + k + j, tape j naar rechts opschuiven terwijl de anderetapes op hun oorspronkelijke plaats blijven staan. Deze eigenschap zullen wekunnen uitbuiten: de overhead van een universele turingmachine wordt immersgegenereerd doordat de lees- en schrijfkoppen van de verschillende tapes ver uit-een kunnen komen te liggen, waardoor de (simulatie) kop op de tape continuenaar de verschillende posities moet bewegen. Door de tapes door te schuivenkan de kop op dezelfde plaats blijven.

We dienen alleen de tape zo te organiseren dat het doorschuiven van een tape,niet vereist dat we alle karakters opschuiven maar slechts een beperkt gedeelte.We zullen de tape op sommige plaatsen ‘opfrommelen’ en op andere plaatsen‘uittrekken’. Daarom delen we elke originele tape op in blokken. Elk van dezeblokken bevat een gedeelte van de tape. Verder bevat een blok ook buffer ruimte,de zogenaamde “smoothing karakters”, karakters die ervoor zullen zorgen datwe niet telkens de volledige tape moeten doorschuiven maar dat we ‘plaatselijk’

2Sterker nog: dit bewijs vormt ook het bewijs van het bestaan van een universiele turingmachine met deze complexiteit.

3Men kan wel aantonen dat Ω (n loglog n) een ondergrens is voor Random Access TuringMachines (RAM) en er bestaat ook een ondergrens van Ω (n log n) voor on-line Turing Ma-chines.

2



a1 a2 a3 . . .

b1 b2 b3 . . .

c1 c2 c3 . . .

a1 b1 c1 a2 b2 c2 a3 b3 c3 . . .

⇓ onafhankelijk schuiven

. . . a1 b3 c2 a2 b4 c3 a3 b5 c4 . . .

Figuur 1: Het emuleren van drie tapes op een tape. De tapes kunnen onafhan-kelijk van elkaar geschoven worden.

. . . a b c d e f g . . .

B0B−1 B1B−2 B2

Figuur 2: Het opdelen van tapes in blokken. Met smoothing karakters voorge-steld door .

met de tape kunnen schuiven. Blok Bi is een blok die i blokken rechts vande kop – en dus het actieve blok – ligt. Elk blok Bi is 2i cellen groot, enslaat 2i−1 karakters van de tape op. Een blok is bij de start dus maar voor dehelft gevuld. Figuur 2 stelt dit concept grafisch voor. We visualiseren hierbijslechts een originele tape. Uiteraard kunnen we dit concept veralgemenen naarmeerdere tapes op de wijze beschreven in de vorige paragraaf. Hierdoor kunnenwe ervoor zorgen dat de karakters waarboven de lees- en schrijfkoppen van deoriginele machine zich bevinden, telkens naast elkaar liggen.

We kunnen de data vervolgens verschuiven door de plaatsen van de smoothingkarakters te gebruiken. Op die manier kunnen we de tape naar rechts schuivenzonder dat we de volledige tape moeten verplaatsen. Door het gebruik van deblokken en de smoothing karakters verdubbelen we alleen maar de lengte vande tape. We kunnen dus een oblivious turing machine maken met dezelfde ge-heugencomplexiteit als de originele machine. Wat betreft de tijdscomplexiteitintroduceren we wel overhead. Indien we bijvoorbeeld een turing machine emu-leren waarvan de lees- en schrijfkoppen uitsluitend naar links of rechts bewegen,dienen we telkens op blokken B−1, B0 en B1 te werken. In de helft van de stap-pen zal de kop ook in B−2 en B2 moeten opereren. Of algemeen: in 1/2i−1 zal delees- en schrijfkop in blokken B−i en Bi moeten werken. We kunnen nu eenvou-dig een oblivious turing machine construeren door onafhankelijk of dit werkelijknodig is, toch deze blokken op te zoeken. Dus ook indien we bijvoorbeeld dekoppen enkel afwisselend naar links en naar rechts bewegen, toch zogezegd ope-raties uit te voeren in de blokken daarbuiten. Om de tapes werkbaar te houdenintroduceren we een set voorwaarden na t simulatie-stappen:

1. Elk blok Bi met |i| ≥ log2 t+1 bevatten juist de helft aan “smoothingcharacters”

2. B−i + Bi = 2|i|: samen bevatten de blokken B−i en Bi juist 2|i| karaktersuit de oorspronkelijke tape. Indien we dus een karakter bij bijvoorbeeldB−2 weghalen, plaatsen we een karakter bij B2.

3



3. Elk blok bevat opeenvolgende karakters van de oorspronkelijke tape, een

triviale voorwaarde.4. Indien t een veelvoud is van 2i dan bevatten de blokken B−i, B−i+1, . . . , Bi

allemaal juist de helft aan “smoothing characters”.

Hoe we concreet de tape op orde houden verschilt van publicatie tot publica-tie. Pippenger-Fisher[13] introduceren hiervoor de subroutines Compress ( j)en Expand ( j). Pentney introduceert een operatie Smooth ( j) en Vollmer [18,p. 37-39] de subroutine Clean ( j). Deze Clean ( j) zal de blokken B−j enBj omvormen zodat ze de helft aan “smoothing characters” bevatten door metkarakters te schuiven van en naar de blokken B−(j+1) en Bj+1. Merk op dat ditdankzij de voorwaarden die hierboven geformuleerd zijn, mogelijk is.

Indien we de blokken B−i en Bi met de Clean (i) routine hebben opgeruimd,

kunnen we 2i

− 1 operaties uitvoeren, zonder dat we de blokken B−i en Biopnieuw moeten “smooth” maken. Dus om een stap te simuleren, moeten deblokken B−1 tot en met B1 opgeruimd zijn; om drie stappen te simuleren, moe-ten de blokken B−2 tot en met B2 opgeruimd zijn; om zeven stappen te simu-leren, moeten de blokken B−3 tot en met B3 opgeruimd zijn. . . We kunnen nueen recursieve procedure Sim (n) bouwen die 2n stappen van de oorspronkelijkeTuring machine simuleert en waarbij de benodigde blokken achteraf (recursief)worden opgeruimd. Deze procedure (samen met de omringende loop) gaat danals volgt:

Algorithm 1 Het oblivious simuleren van een Turing machine.

1: procedure Sim(n) Simuleer 2n stappen2: if n = 0 then

3: Simuleer 1 stap

4: Clean(1)5: else Twee maal 2(n−1) stappen simuleren6: Sim(n − 1)7: Clean(n − 1) Blokken B−(n−1) en B(n−1) opruimen8: Sim(n − 1)9: Clean(n − 1)

10: end if

11: end procedure

12: procedure Main De main loop13: for j=0,1... do

14: Sim( j)

15: end for16: end procedure

Het Main programma is enkel een loop van oproepen naar Sim (0), Sim (1),Sim (2). . . totdat de gesimuleerde Turing machine stopt. We moeten nu nogenkel argumenteren dat de operaties Clean (i) en Sim (i) obliviously geımple-menteerd kunnen worden. Indien we veronderstellen dat Clean (i) obliviousis en we bij het simuleren van een stap zowel een beweging naar rechts als eenbeweging naar links (van de oorspronkelijke lees/schrijf-kop) simuleren (waarbijin een van de twee gevallen niets geschreven wordt), is het gemakkelijk om in

4



. . . a b c d e f g h i . . .

B0B−1 B1B−2B−3

⇓. . . a b c d e f g h i . . .

B0B−1 B1B−2B−3

Figuur 3: Werking van de Clean (2)-operatie (helft van de tape).

te zien dat Sim (i) ook oblivious is. De procedure Clean (i) ruimt zowel depositieve blokken als de negatieve blokken op en is op dit vlak al oblivious. We

kunnen deze procedure helemaal oblivious maken door zowel de kopbewegingenvoor het verplaatsen van karakters van B±i naar B±(i+1), als van B±(i+1) naarB±i uit te voeren waarbij we maar in een geval ook werkelijk (andere karakters)schrijven. Hierdoor is ook Clean (i) oblivious en werkt de gehele simulatieobliviously.

We bekijken nu de tijdscomplexiteit. De simulatie van een stap gebeurt ineen constant aantal stappen O (1) en draagt dus niet bij aan de algehele com-plexiteit. Voor de complexiteit van de Clean (i) procedure maken we volgenderedenering: Vermits we een tweede tape hebben kunnen we n cellen van de tapeverplaatsen in O (n) stappen. Vermits blok Bi een lengte heeft van 2i is detijdscomplexiteit van Clean (i) O

2i

. Voor de complexiteit van de procedureSim (i) beschouwen we de functie C (i) die de tijd aangeeft die Sim (i) nodig

heeft. Voor deze functie geldt:

C (0) = O (1)

C (i) = 2 · C (i − 1) + O

2i

De complexiteit van Sim (i) is dus O

i · 2i

. De oorspronkelijk Turing Ma-chine voert T (n) stappen uit. Worst case zal de simulatie pas eindigen bijSim (log T (n)) omdat er dan 2i (≥ T (n), met i = log T (n)) stappen gesi-muleerd worden. De volledige simulatie heeft dus een complexiteit van:

O

log T (n) · 2logT (n)

= O (T (n)log T (n))

Een laatste aspect is dat de koppen nooit links van hun beginposities mogenbewegen (zie definitie 1). Dit lossen we op door de tape dubbel te plooienzoals ook geıllustreerd in [1, §1.2]. We kwadrateren het alfabet en het karakterop plaats i bevat een samenstelling van de karakters −i en i op de origineletape.

2 Specifieke Complexiteitsklassen

In deze sectie willen we graag nog enkele resultaten meegeven over de com-plexiteitsklassen voor oblivious turing machines. Men kan aantonen dat een

5



niet-deterministische oblivious turing machine met lineaire access-time en lo-

garitmische space complexiteit, krachtiger is dan een deterministische variant.Met andere woorden dat L = NL voor oblivious turing machines met lineaireaccess-time [9].

Verder is ook bewezen dat ⊕L verschillend is van L, NL, coNL en AL (en dus ookvan P want P=AL) voor oblivious turing machines. [10]. Voor de duidelijkheidgeven we nog kort een informele definitie van al deze klassen:

• Een taal L behoort tot L als er een turing machine M bestaat die werktin logaritmische space en x ∈ L ⇔ M (x) = 1.

• Een taal L behoort tot NL als er een niet-deterministische turing machineN bestaat die werkt in logaritmische space en x ∈ L ⇔ N (x) = 1.

• Een taal L behoort tot coNL als ze niet tot NL behoort, dus L ∈ coNL ⇔

L ∈ NL.

• Een taal L behoort tot AL als er een alternating turing machine A bestaatdie werkt in logaritmische space en x ∈ L ⇔ A(x) = 1.

• Een taal L behoort tot ⊕L (uitgesproken als “parity L”) als er een niet-deterministische turing machine P bestaat die werkt in logaritmische spaceen x ∈ L als en slechts als op invoer x het aantal paden van P die leidentot een accepterende toestand oneven is.

Het is belangrijk te beseffen dat bovenstaande resultaten hier enkel van toepas-sing zijn op oblivious turing machines!

3 Gerelativeerde Oblivious Turing Machines

Vitanyi introduceert in [17] het concept van een gerelativeerde oblivious turingmachine. Hij definieert een gerelativeerde oblivious turing machine als een tu-ring machine die in sommige gevallen dezelfde bewegingen maakt bij twee ver-schillende strings. De omstandigheden waarin de oblivious-eigenschap al danniet geldt, formaliseert hij met een equivalentierelatie ≡M over Σ∗ die als volgtgedefinieerd wordt:Definitie 2 (≡M over Σ∗[17]). Stel M een turing machine met invoeralfabet Σ.Door strings van gelijke lengte te groeperen waarvoor M eenzelfde sequentie vanbewegingen uitvoert induceert M een equivalentierelatie ≡M over Σ∗ waarvoorgeldt:

(i) ≡M

(ii) xa ≡M yb met x, y ∈ Σ∗ en a, b ∈ Σ indien x ≡M y en de lees- enschrijfkoppen dezelfde bewegingen maken alvorens ze naar rechts bewegenbij a en b

(iii) x ≡M y geldt enkel indien ∀z ∈ Σ : xz ≡M yz.

(iv) Voor geen enkele x, y ∈ Σ∗ geldt x ≡M y indien dit niet geınduceerd wordtdoor (i), (ii) of (iii).

6



Op basis van deze definitie kunnen we mits enkele tussenstappen het concept

van k-nonoblivious invoeren.Definitie 3 (W -oblivious[17]). Een turing machine is W -oblivious met W ⊆ Σ∗

indien ∀x, y ∈ W : |x| = |y| ⇒ x ≡M y.Definitie 4 (∆-oblivious[17]). Een turing machine M is ∆-oblivious met ∆ ⊆ Σindien ∀w ∈ Σ∗, M h−1 (h (w))-oblivious is. Hierbij is h : Σ∗ → ∅ ∪ Σ \ ∆

∗

een homomorfisme met:

(i) h (xy) = h (x) h (y).

(ii) h (a) = ∅ indien a ∈ ∆.

(iii) h (a) = a indien a ∈ Σ \ ∆.Voorbeeld 1. Deze definitie is vrij complex. Daarom zullen we een voorbeeldgeven. Stel Σ = a,b,c,d,e en ∆ = a, b. Verder beschouwen we de strings

S 1, S 2, S 3 en S 4. Indien h (S i) = h (S j) zullen de koppen dus op dezelfde manierbewegen. Voor ons concreet geval is dit dus:

S 1 = abacadade h (S 1) = ∅∅∅c∅d∅deS 2 = acbdbde h (S 2) = ∅c∅d∅deS 3 = bbbcbdbde h (S 3) = ∅∅∅c∅d∅deS 4 = ebabebe h (S 4) = e∅∅∅e∅e

(1)

Enkel bij S 1 en S 3 zullen de koppen dus op dezelfde manier bewegen.

Een belangrijke noot die we bij deze definitie moeten maken is dat ∆-obliviouseen eigenschap is van een machine. Het is niet uitgesloten een machine voorverschillende subsets ∆i ⊆ Σ oblivious is. Deze eigenschap zullen we gebruikenom een graad van nonoblivious te definieren:Definitie 5 (k-nonoblivious[17]). Een turing machine M met alfabet Σ isnonoblivious indien:

(i) We Σ kunnen partitioneren in k disjuncte, niet-lege sets ∆i zodat M ,∆i-oblivious is voor all i met 1 ≤ i ≤ k.

(ii) We Σ niet kunnen kunnen partitioneren in k ≤ k disjuncte, niet-lege sets∆

i zodat M , ∆i-oblivious is voor all i met 1 ≤ i ≤ k.

Op basis van deze definities bewijst Vitanyi enkele lemma’s met betrekking totk-nonobliviousness:

Lemma 2. Voor elke k > 1 bestaat er een taal Ok die in lineare tijd kan bere-kend worden met een k-nonoblivious turing machine; elke k-nonoblivious turing machine met k < k heeft minstens een aantal stappen nodig van ordegroottegroter dan O (n), met n de invoerlengte.

Bewijs. We construeren een taal Ok die bepaald wordt door een k-nonobliviousturing machine M k. De turing machine heeft k stacks. Het alfabet Σ bestaatuit de unie van k subsets:

Σ = ∪i∆i met ∆i = ai, ai (2)

En de machine is voor elke ∆i, ∆i-oblivious. De machine leest tijdens elke stapeen karakter in van de invoertape en bepaalt uit welke ∆ i het karakter komt.

7



Op alle stapels behalve de i-de wordt vervolgens een Push operatie met een 0 of

1 uitgevoerd. Op de i-de stapel wordt eenPop

operatie uitgevoerd. De inhouddie op deze stapel stond, wordt op de uitvoertape geplaatst. Indien de stapelleeg is plaatsen we een 0. Het karakter dat ingelezen wordt bepaald of er een 0of 1 op de overige stapels wordt geplaatst. Dit gebeurt op de volgende manier:we kennen aan elk karakter uit Σ een 0 of 1 toe. Aan het eerste karakter dat weinlezen kennen we een 1 toe. Aan het volgende karakter dat we inlezen en dieniet gelijk is aan het eerste kennen we een 0 toe. Indien beide karakters tot eenverschillende ∆i behoren, kennen we hun tegenhanger - het andere element in∆i waar we nog geen waarde aan hebben toegekend - het omgekeerde toe. Bij deoverige karakters in de ∆i subsets kennen we de 1 toe aan de karakters zondercircumflex ai, een 0 aan de karakters met circumflex ai. Indien de uitvoer bijhet laatste karakter een 1 is wordt de string aanvaardt, in het ander geval wordtde string verworpen.

We zullen nu bewijzen dat een machine M die k < k-nonoblivious is, nooitdeze taal in lineaire tijd kan bepalen. Deze machine zou het alfabet moetenpartitioneren in k disjuncte subsets Γi. Omdat Σ een kardinaliteit van 2k heeftmoet volgens het duifhokprincipe er minstens een Γl drie of meer elementenbevatten. Verder kunnen we afleiden dat de elementen die in Γl zitten uitminstens twee verzamelingen ∆i moeten komen. Er bestaat dus een stapel S tin M k die bij karakters uit Γl een deel een Push en voor een ander deel eenPop operatie uitvoert. De twee karakters die een Push uitvoeren noemen we s1en s2, het karakter die een Pop uitvoert noemen we s3. Dit terwijl in machineM de stacks in dit geval voor alle karakters een Push of Pop operatie moetenuitvoeren. We kunnen uiteraard in plaats van een operatie een constant aantaloperaties uitvoeren, het punt blijft dat de kop maar een vast aantal posities

naar links of rechts kan opschuiven. Bovendien kunnen we de richting enkelop voorhand kiezen, en niet aanpassen tegenover het element van Γl, dit isimmers de definitie van Γl-oblivious. Stel nu dat we een string van de vorms1s2s3s3 (s1|s2|s3)∗ krijgen, dan staat er bij M k na het gedeelte voor de Kleenester niets op de stapel S t, maar heeft s1 de waarde 1, en s2 de waarde 0. Indienwe s3 tegenkomen in de invoer, hebben we toegang nodig tot de invoerstroomvan s1 en s2 in het verleden. Vermits we echter genoodzaakt zijn om bij M inalle gevallen dezelfde bewegingen met de koppen te maken, is het niet mogelijkom dit verleden te lezen in constante tijd. De grootte van dit verleden kanimmers lineair toenemen, waardoor een constant aantal operatie geen uitwegmeer biedt. Ook het aantal stapels uitbreiden lost hier niets op, alle stapelshebben immers maar een eindig aantal plaatsen die ze kunnen uitlezen, en ze

zijn ook gedwongen om bij alle karakters van Γl dezelfde beweging te maken.We kunnen zeggen dat de data die we dienen uit te lezen en de data die wemoeten bijhouden voor later uit elkaar groeien. Vermits elke stapel maar eeneindig aantal posities kan bekijken per invoer-karakter, zullen we uiteindelijkdie limiet bereiken.Dit laatste argument werd geformaliseerd en is beter bekendals het overlap-argument van Cook[4].

We geven tot slot nog een ander lemma uit de paper van Vit anyi zonder bewijs:Lemma 3. Voor elke k ≥ 1 bestaat er een taal N k die in lineare tijd kan beslist worden op een k-tape turing machine, die k of minder nonoblivious bewegenin-gen maakt. Bovendien heeft elke turing machine die hoogstens k nonoblivious

8



bewegingen maakt met k < k meer dan O (n) stappen nodig om N k te beslissen,

met n de invoerlengte.In de publicatie van Vitanyi staat dat de talen Ok en N k niet lineair kunnenbeslist worden en niet sneller dan Ω (n log n). Vitanyi doelt hierbij op een bewijsdat een turing machine niet sneller kan geemuleert worden op een obliviousturing machine. Dit is enkel bewezen op voorwaarde dat het om een on-lineturing machine gaat.

4 Logische circuits

Oblivious Turing Machines zijn nauw verwant met logische circuits4. Alvorenshier dieper op in te gaan herhalen we kort wat een logisch circuit is:Definitie 6 (Logisch Circuit[18]). Een logisch circuit is een wiskundige con-structie die we kunnen beschrijven aan de hand van een gerichte acyclischegrafe. In de grafe noemen we de knopen “poorten” en de bogen “draden” of “aders”. Een logisch circuit wordt gebouwd nadat men de lengte van de invoerkent. De constructie dient dus geformaliseerd te worden op basis van n = |x|.In het circuit zijn er twee soorten poorten:

• Invoerpoorten: deze poorten nemen de waarde aan van een plaats op detape xi of een booleaanse constante. Er zijn geen bogen die in deze poortentoekomen.

• Verwerkingsknopen: deze knopen zijn gelabeled met een booleaanse func-tie. Ze nemen een waarde aan door deze functie uit te voeren op de knopen

waaruit bogen naar de verwerkingsknoop gaan.Sommige van deze poorten zijn ook finale poorten. Ze berekenen een van de mcellen op de uitvoer-tape.

Een logisch circuit bevat twee vormen van complexiteit:

• Grootte: de ordegrootte van het aantal poorten die het netwerk nodigheeft om de functie te berekenen.

• Diepte: het langste pad die we kunnen vormen vanaf een ingangspoort toteen finale poort. Dit bepaalt de berekeningssnelheid in digtale logica.

Net als bij oblivious turing machines verandert het gedrag van een logisch cir-cuit niet tegenover de inhoud die op de tape komt te staan. De implementatie

staat dan immers al vast. De grootte daarentegen bepaalt wel de bouw van hetlogisch circuit. Dit wekt het vermoeden dat er een sterke band is tussen beidecomputationele modellen, zoals uit lemma 4 blijkt.

Lemma 4 (Pippenger-Fischer 1). Indien een taal A belist wordt in O (T (n))door een oblivious turing machine met invoerlengte n, dan bestaat er een circuit die A kan beslissen in met een grootte en een diepte O (T (n)).

4Ook Booleaanse circuits genoemd.

9



Bewijs. Lemma 4 stelt dat er een lineair verband is tussen een oblivious turing

machine M en een logisch circuit. Dit bewijzen we door voor een algemene obli-vious turing machine, en een gekende invoerlengte n een circuit te construerendie de turing machine kan emuleren.

Zij C s(x) de configuratie waar M zich in bevindt na s stappen met input x. Om-dat M oblivious is, hoeven we om een configuratie van M te representeren enkelde huidige toestand en de inhoud van de werk tapes voor te stellen. De positievan de lees/schrijf koppen hangt immers enkel af van s en invoergrootte n (dievast ligt). We definieren m als het aantal stappen die de oblivious turing ma-chine uitvoert. In m stappen kunnen we maximaal m geheugencellen aanpassenop elke tape, dus elke configuratie heeft een grootte van O (m). We kunnen dusmet behulp van O (m) ingangspoorten de volledige initiele configuratie voorstel-len5. Indien het input en output alfabet meer als twee symbolen bevatten (en

niet als 0 en 1 kunnen worden voorgesteld), dan kan een lijn meerdere ‘sublijnen’bevatten die een binaire representatie6 van een symbool zijn.

Bij elke stap die de machine zet, weten we al vooraf waar het hoofd van deturing machine zal staan7 en waar er bij de overgang van C s(x) naar C s+1(x)in de configuratie representatie wijzigingen zullen gebeuren. Dit is dankzij deoblivious eigenschap en het feit dat de invoergrootte vastligt. Bij een stap hangthet gedrag slechts van enkele variabelen af:

• De huidige toestand: bij l toestanden kunnen we dit voorstellen doorO (log l)

• De karakters onder de koppen: bij k koppen zijn dit O (k) bits8.

Vermits beide variabelen in aantal bits niet afhangen van n kunnen we deze als

constant beschouwen. Verder dienen we enkel een nieuwe toestand en nieuwekarakters te berekenen, het aantal bits is dus ook hier constant. We kunnendus een subcircuit construeren die een stap van een oblivious turing machineuitvoert in O (1). We linken de nieuwe toestand van het subcircuit (voor stap)i aan de huidige toestand van het subcircuit i + 1. De totale complexiteit vanzowel de grootte als de diepte wordt dan O (m). Figuur 4 geeft dit conceptgrafisch weer. Een analoog bewijs vinden we in [18, §2.1].

Een ander belangrijk lemma – ook van Pippenger en Fischer – kijkt naar derelatie tussen een algemene Turing Machine en een Logisch circuit en stelt:Lemma 5 (Pippenger-Fischer 2). Indien een taal A belist wordt in O (T (n))door een turing machine met invoerlengte n, dan bestaat er een circuit die A

kan beslissen met een grootte O (T (n)log T (n)) en een diepte O (T (n)).

Bewijs. Het bewijs is equivalent aan de emulatie van een Turing Machine opeen Oblivious Turing Machine. Alleen kunnen we de procedure die de tape oporde houdt – Clean ( j) – verder uitsplitsen in Compress ( j) en Expand ( j).

5We kunnen ook lege karakters voor stellen door het tape-alfabet te reduceren tot enkel0, 1. Een leeg karakter kunnen dan bijvoorbeeld voorstellen door 10.

6Indien |Σ| = k dan hebben we log k sublijnen nodig.7Dit kunnen we eventueel berekenen door de machine op triviale invoer zoals 0n te simu-

leren.8Door de alfabetreductie dienen we eventueel meerdere bits per cel te gebruiken, maar dit

verhoogt de complexiteit alleen maar met een constante factor

10



0 0

0 0

0 1

x1,1

y1,1

x1,2

y1,2

x2,1

y2,1

x2,2

y2,2

x3,1

y3,1

x3,2

y3,2

Initiele toestand

Finale toestand

Step0

Step1

Step2

Figuur 4: Equivalentie tussen Oblivious Turing Machines en Logische Circuits

Deze subroutines kunnen we parallel uitvoeren in O ( j) met het zetten vaneen stap van de originele Turing Machine. Het aantal poorten blijft hierdoor

O (T (n)log T (n)), de diepte wordt echter O (T (n)). Voor meer details zie: [13,p. 379-380]

5 Andere toepassingen

5.1 Software beveiliging

Een eerste toepassing die we willen beschrijven, situeert zich in de beveiligingvan software. Software is heel duur om te maken en kan zeer gemakkelijk ge-kopieerd worden. Er wordt dan ook intensief gezocht naar manieren om dezesoftware piraterij te verhinderen. De beveiliging van software heeft als doel het

voorkomen dat derden die geen recht hebben op de software, de software kun-nen gebruiken. De focus ligt op het verhinderen van illegale duplicatie. In dezesectie bespreken we kort een manier waarop deze beveiliging kan gebeuren enwat de rol van oblivious machines hierin is. Deze volledige sectie is gebaseerdop de paper van Goldreich en Ostrovsky [6].

Helaas kunnen we het illegaal kopieren of namaken van software niet tegengaanmet software alleen. De bits van een software programma kunnen immers altijdgekopieerd worden. We zullen dus een oplossing moeten zoeken door middel vaneen fysieke (hardwarematige) bescherming. Zo een mogelijke oplossing bestaatuit het verkopen van een physically shielded Central Processing Unit samen

11



met een geencrypteerd programma. De twee samen noemen we een Software-

Hardware-package of een SH-package. De afgeschermde CPU bevat de decryptiesleutel voor het programma zodat alleen die CPU het programma kan uitvoeren.Dergelijke chips worden nu reeds gebruikt in bankautomaten.

Een software beveiligingstechniek is veilig als een buitenstaander bij het uit-voeren van het programma enkel het input-output gedrag en de uitvoeringstijdkan afleiden. Het is dus belangrijk dat niet enkel de waarden in het geheugenverborgen (geencrypteerd) worden, maar dat ook het toegangspatroon tot hetgeheugen verdoezeld wordt. Een aanvaller zou uit het toegangspatroon immersbelangrijke informatie kunnen afleiden over de programmastructuur (lussen, tes-ten, functies. . . ) wat hem in staat zou stellen om het programma (gemakke-lijker) na te maken. Bovendien is het mogelijk dat de aanvaller de inhoud vanbepaalde geheugencellen of de communicatie tussen de CPU en het geheugen

wijzigt. Dit zou echter geen invloed mogen hebben op het geheugen toegangspa-troon. Deze techniek wordt ook gebruikt bij het ontwikkelen van veilige softwareom vinden en uitbuiten van programmafouten te bemoeilijken.

De manier bij uitstek om het toegangspatroon te verbergen is door gebruik temaken van oblivious machines. Het theoretische model dat Goldreich en Os-trovsky gebruiken om dit te modelleren is dat van de random access Turing machines, hierna afgekort met RAM. Een eenvoudige manier om het toegangs-patroon te verbergen is de volgende: wanneer de CPU de inhoud van een be-paalde geheugencel opvraagt, leest en herschrijft het geheugen de inhoud vanelke geheugencel in een bepaalde vaste volgorde. Indien het oorspronkelijkeprogramma na t stappen eindigt en het geheugen m cellen heeft, dan heeft hetgeencrypteerde programma een loop tijd van O (t · m), wat dus een overhead

van O (m) is.Een lagere overhead is voor deterministische machines helaas niet mogelijk. Hetis echte wel mogelijk om een lagere overhead te bekomen met probabilistischemachines. Met behulp van pseudo-random number generators kunnen we eenprobabilistische machine deterministisch simuleren ten gevolge van extra over-head. Voor de complexiteitsberekeningen veronderstellen we echter dat we eenrandom oracle ter beschikking hebben die in een stap een willekeurig getal kangenereren.

We definieren een oblivious RAM als een probabilistische RAM voor de welkede kansverdeling van de sequentie van (geheugen) adressen die tijdens de uit-voering worden opgevraagd, enkel afhangt van de lengte van zijn input (en dusonafhankelijk van de inhoud). Men kan dan volgende stelling bewijzen:

Lemma 6 (Goldreich-Ostrovsky). Zij RAM( m) een RAM met m geheugen-cellen en toegang tot een random oracle. Dan kan een wil lekeurige RAM( m)

met uitvoeringstijd O (T (n)) door een oblivious RAM( m · (log m)2

) gesimuleerd

worden met een uitvoeringstijd van O

T (n) · (log T (n))3

.

Met behulp van oblivious random access machines (en encryptie) kan men eenveilige software beveiligingstechniek uitwerken die relatief weinig overhead totgevolg heeft. Een andere mogelijke toepassing van deze techniek is het verber-gen van de traffic-patterns van een gedistribueerde database. Want ondanks

12



geencrypteerde berichten, kunnen de traffic-patterns schadelijke informatie over

de database vrijgeven.

5.2 Cryptografie

Binnen cryptografie en communicatie protocollen wordt ook veel gebruik ge-maakt van het ‘oblivious’-principe. Meestal duidt oblivious hier op het feit datde verschillende partijen geen kennis hebben van elkaars eigenschappen of be-doelingen. Dit maakt communicatie mogelijk zonder dat een van beide partijenkostbare informatie moet vrijgeven.

Michael O. Rabin was waarschijnlijk de eerste onderzoeker die dit principe uit-diepte. In zijn paper How To exchange Secrets with Oblivious Transfer (1981)

beschrijft hij het oblivious transfer protocol [14]. Hiermee kunnen twee partijengeheimen (zoals encryptie sleutels) uitwisselen zonder dat ze kunnen vals spelen(valse geheimen of helemaal geen geheim uitwisselen). Het ‘oblivious’-aspect zitin het feit dat na het uitvoeren van het protocol, geen van beide partijen zekeris dat de andere zijn geheim ontvangen heeft.

Ook de techniek ‘oblivious keyword search’ geıntroduceerd in 2004 door Ogataen Kurosawa, steunt op het principe dat beide partijen geen kennis hebbenvan elkaars bedoelingen [11]. Er is een data supplier die een database metgeheimen beheert. Bovendien kunnen (geautoriseerde) gebruikers bepaalde dataop basis van een keyword opvragen zonder dat de data supplier weet heeft vandit keyword en zonder dat de gebruiker meer te weten komt over de anderegeheimen van de data supplier.

Ten slotte geven we nog als voorbeeld een hand-shaking protocol waarmee tweepartijen zich aan elkaar kunnen authenticeren (kenbaar maken) enkel en alleenals ze tot dezelfde groep (certification authority) behoren [3]. Indien ze niet totdezelfde groep behoren, dan leren beide partijen niets over elkaar buiten hetfeit dat ze tot een verschillende groep behoren. Het uitvoeren van het protocolgebeurt dus zonder kennis (obliviously) van elkaars groep.

6 Open problemen

Er is voor zover bekend geen bewijs dat een logaritmische overhead de minimalealgemene9 kostprijs is voor een conversie naar een oblivious turing machine.

Vooral het feit dat de conversie naar een universele turing machine die over-head induceert maakt ons wantrouwig. Die conversie naar de universele turingmachine kan men immers zien als een methode om van een abstracte machine,naar een machine met een concrete implementatie te gaan. Toch lijkt dezecomplexiteitsgrens redelijk om als minimum aangenomen te worden. Men heeftimmers reeds bewezen dat een Random Access Turing Machine een ondergrensheeft van Ω (T (n)loglog T (n)). Vermits een Random Access Turing Machine(RAM) een Turing Machine is die een logaritmische toegangstijd heeft, kan een

9Met algemeen bedoelen we voor elk mogelijk probleem.

13



RAM machine enkel sneller werken dan een Turing Machine. Ook voor on-line

Turing machines werd een ondergrens vastgelegd: Ω (T (n)log T (n)).

Referenties

[1] Sanjeev Arora and Boaz Barak. Computational Complexity: A Modern Approach . Cambridge University Press, New York, NY, USA, 1st edition,2009.

[2] Paul Beame and Widad Machmouchi. Making branching programs obli-vious requires superlogarithmic overhead. In Proceedings of the 2011 IEEE 26th Annual Conference on Computational Complexity , CCC ’11, pages12–22, Washington, DC, USA, 2011. IEEE Computer Society.

[3] Claude Castelluccia, Stanislaw Jarecki, and Gene Tsudik. Brief announ-cement: secret handshakes from ca-oblivious encryption. In Proceedingsof the twenty-third annual ACM symposium on Principles of distributed computing , PODC ’04, pages 394–394, New York, NY, USA, 2004. ACM.

[4] Stephen A. Cook. On the minimum computation time of functions. PhDthesis, 1966. URL: http://cr.yp.to/bib/entries.html#1966/cook.

[5] Shimon Even, Oded Goldreich, and Abraham Lempel. A randomized pro-tocol for signing contracts. Commun. ACM , 28(6):637–647, June 1985.

[6] Oded Goldreich and Rafail Ostrovsky. Software protection and simulationon oblivious RAMs. J. ACM , 43(3):431–473, May 1996.

[7] F. C. Hennie and R. E. Stearns. Two-Tape Simulation of Multitape TuringMachines. J. ACM , 13:533–546, October 1966.

[8] Jonathan Katz. Notes on Complexity Theory. August 2011.

[9] M. Krause, C. Meinel, and S. Waack. Separating complexity classes rela-ted to certain input oblivious logarithmic space-bounded turing machines.In Structure in Complexity Theory Conference, 1989. Proceedings., Fourth Annual , pages 240 –249, jun 1989.

[10] Matthias Krause. Separating ⊕L From L, NL, co-NL and AL (=P) forOblivious Turing Machines of Linear Access Time. In Proceedings of theMathematical Foundations of Computer Science 1990 , MFCS ’90, pages385–391, London, UK, UK, 1990. Springer-Verlag.

[11] Wakaha Ogata and Kaoru Kurosawa. Oblivious keyword search. J. Com-plex., 20(2-3):356–371, April 2004.

[12] Christos M. Papadimitriou. Computational complexity . Addison-Wesley,Reading, Massachusetts, 1994.

[13] Nicholas Pippenger and Michael J. Fischer. Relations among complexitymeasures. J. ACM , 26(2):361–381, April 1979.

[14] Michael O. Rabin. How to exchange secrets with oblivious transfer. Tech-nical Report TR-81, Aiken Computation Lab Harvard University, 1981.

14



[15] John E. Savage. Models of Computation: Exploring the Power of Compu-

ting . Addison-Wesley Longman Publishing Co., Inc., Boston, MA, USA,1st edition, 1997.

[16] Peter van Emde Boas. Turing Machines for Dummies - Why Representati-ons Do Matter. In SOFSEM , pages 14–30, 2012.

[17] Vitanyi, Paul. Relativized obliviousness. In P. Dembinski, editor, Mathe-matical Foundations of Computer Science 1980 , volume 88 of Lecture Notesin Computer Science, pages 665–672. Springer Berlin / Heidelberg, 1980.10.1007/BFb0022541.

[18] H. Vollmer. Introduction to circuit complexity: a uniform approach . Textsin theoretical computer science. Springer, 1999.

15

Documents

Oblivious Turing Machines