mirror of
https://github.com/theoleuthardt/hwr-notes.git
synced 2026-06-06 00:01:08 +00:00
docs: add obsidian hwr docs
This commit is contained in:
theoleuthardt
parent
b2636f4b92
commit
850aa3455d
245 changed files with 30757 additions and 0 deletions
BIN
Komplexitätstheorie/.DS_Store
vendored
Normal file
BIN
Komplexitätstheorie/.DS_Store
vendored
Normal file
Binary file not shown.
BIN
Komplexitätstheorie/books/.DS_Store
vendored
Normal file
BIN
Komplexitätstheorie/books/.DS_Store
vendored
Normal file
Binary file not shown.
Binary file not shown.
BIN
Komplexitätstheorie/folien/ko1.pdf
Normal file
BIN
Komplexitätstheorie/folien/ko1.pdf
Normal file
Binary file not shown.
BIN
Komplexitätstheorie/folien/ko2 - ohne wiederholung.pdf
Normal file
BIN
Komplexitätstheorie/folien/ko2 - ohne wiederholung.pdf
Normal file
Binary file not shown.
BIN
Komplexitätstheorie/folien/ko2.pdf
Normal file
BIN
Komplexitätstheorie/folien/ko2.pdf
Normal file
Binary file not shown.
BIN
Komplexitätstheorie/folien/ko3.pdf
Normal file
BIN
Komplexitätstheorie/folien/ko3.pdf
Normal file
Binary file not shown.
BIN
Komplexitätstheorie/folien/ko4.pdf
Normal file
BIN
Komplexitätstheorie/folien/ko4.pdf
Normal file
Binary file not shown.
493
Komplexitätstheorie/vortrag/Learnings.html
Normal file
493
Komplexitätstheorie/vortrag/Learnings.html
Normal file
|
|
@ -0,0 +1,493 @@
|
|||
<!DOCTYPE html>
|
||||
<html lang="de">
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||||
<title>SVP Lernzusammenfassung</title>
|
||||
<style>
|
||||
:root {
|
||||
--bg: #fafaf8;
|
||||
--bg2: #f1efe8;
|
||||
--text: #2c2c2a;
|
||||
--text2: #5f5e5a;
|
||||
--text3: #888780;
|
||||
--border: rgba(0,0,0,0.1);
|
||||
--blue: #378ADD;
|
||||
--purple: #7F77DD;
|
||||
--teal: #1D9E75;
|
||||
--red: #E24B4A;
|
||||
--amber: #EF9F27;
|
||||
--coral: #D85A30;
|
||||
--green: #97C459;
|
||||
--font: -apple-system, 'Segoe UI', sans-serif;
|
||||
--mono: 'SF Mono', 'Fira Code', monospace;
|
||||
}
|
||||
@media (prefers-color-scheme: dark) {
|
||||
:root {
|
||||
--bg: #1a1a1a;
|
||||
--bg2: #2a2a28;
|
||||
--text: #e0dfd8;
|
||||
--text2: #a0a098;
|
||||
--text3: #707068;
|
||||
--border: rgba(255,255,255,0.1);
|
||||
}
|
||||
}
|
||||
* { box-sizing: border-box; margin: 0; padding: 0; }
|
||||
body { font-family: var(--font); font-size: 16px; line-height: 1.75; color: var(--text); background: var(--bg); max-width: 780px; margin: 0 auto; padding: 40px 24px 80px; }
|
||||
h1 { font-size: 28px; font-weight: 600; margin: 0 0 8px; }
|
||||
h2 { font-size: 20px; font-weight: 600; margin: 48px 0 16px; padding-bottom: 8px; border-bottom: 1px solid var(--border); }
|
||||
h3 { font-size: 17px; font-weight: 600; margin: 32px 0 12px; }
|
||||
p { margin: 0 0 16px; }
|
||||
strong { font-weight: 600; }
|
||||
em { font-style: italic; }
|
||||
code { font-family: var(--mono); font-size: 14px; background: var(--bg2); padding: 2px 6px; border-radius: 4px; }
|
||||
.subtitle { color: var(--text2); font-size: 15px; margin-bottom: 32px; }
|
||||
.viz-container { margin: 24px 0 32px; padding: 20px; background: var(--bg2); border-radius: 12px; border: 0.5px solid var(--border); }
|
||||
.viz-container svg { display: block; margin: 0 auto; }
|
||||
.step-nav { display: flex; gap: 8px; margin: 0 0 12px; flex-wrap: wrap; }
|
||||
.step-btn { font-size: 13px; padding: 5px 12px; border-radius: 6px; border: 0.5px solid var(--border); background: transparent; color: var(--text2); cursor: pointer; font-family: var(--font); transition: all .15s; }
|
||||
.step-btn.active { background: #E6F1FB; color: #185FA5; border-color: #85B7EB; font-weight: 500; }
|
||||
@media (prefers-color-scheme: dark) {
|
||||
.step-btn.active { background: #0C447C; color: #B5D4F4; border-color: #185FA5; }
|
||||
}
|
||||
.step-btn:hover:not(.active) { background: var(--bg); }
|
||||
.viz-caption { font-size: 14px; line-height: 1.6; color: var(--text); margin: 10px 0 0; }
|
||||
.viz-caption strong { font-weight: 600; }
|
||||
.key-item { display: inline-flex; align-items: center; gap: 6px; margin-right: 12px; font-size: 12px; color: var(--text2); }
|
||||
.key-dot { width: 10px; height: 10px; border-radius: 50%; display: inline-block; }
|
||||
.merkbox { margin: 20px 0; padding: 16px 20px; border-radius: 10px; border-left: 4px solid var(--teal); background: var(--bg2); }
|
||||
.merkbox-title { font-size: 14px; font-weight: 600; color: var(--teal); margin-bottom: 6px; }
|
||||
.prof-box { margin: 20px 0; padding: 16px 20px; border-radius: 10px; border-left: 4px solid var(--amber); background: var(--bg2); }
|
||||
.prof-box-title { font-size: 14px; font-weight: 600; color: var(--amber); margin-bottom: 6px; }
|
||||
.proof-check { display: flex; align-items: baseline; gap: 8px; font-size: 14px; color: var(--text2); margin: 4px 0; }
|
||||
.proof-check .mark { color: var(--teal); font-weight: 600; }
|
||||
hr { border: none; border-top: 1px solid var(--border); margin: 40px 0; }
|
||||
.chain-step { display: flex; align-items: center; gap: 12px; margin: 8px 0; }
|
||||
.chain-arrow { color: var(--text3); font-size: 18px; margin: 4px 0 4px 20px; }
|
||||
.chain-box { padding: 8px 14px; border-radius: 8px; font-size: 14px; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<h1>SVP — Lernzusammenfassung</h1>
|
||||
<p class="subtitle">Alle Erklärungen und Visualisierungen aus der Tutoring-Session. Zum Wiederholen vor dem Vortrag.</p>
|
||||
|
||||
<!-- ═══════════════════════════════════════ -->
|
||||
<h2>1. Was ist ein Gitter?</h2>
|
||||
|
||||
<p>Ein Gitter ist die Menge aller ganzzahligen Kombinationen von Basisvektoren. Stell dir schiefes Karopapier vor — die Ecken der Parallelogramme sind die Gitterpunkte, und die Seitenvektoren bilden die Basis.</p>
|
||||
|
||||
<p>Formal: <code>L = { z₁b₁ + z₂b₂ + ... + zₙbₙ | zᵢ ∈ ℤ }</code></p>
|
||||
|
||||
<p>Der entscheidende Unterschied zur linearen Algebra: Bei Vektorräumen darfst du <em>reelle</em> Zahlen verwenden und erreichst jeden Punkt. Bei Gittern nur <em>ganze</em> Zahlen → du bekommst diskrete Punkte.</p>
|
||||
|
||||
<div class="merkbox">
|
||||
<div class="merkbox-title">Merkregel</div>
|
||||
Mit einer Kombination aus den Basisvektoren (nur ganzzahlige Koeffizienten!) kann man das gesamte Gitter abbilden. Kein Punkt fehlt, keiner kommt dazu. Die Basis <em>definiert</em> das Gitter.
|
||||
</div>
|
||||
|
||||
<p><strong>Basen sind nicht eindeutig:</strong> Dasselbe Gitter kann durch komplett unterschiedliche Basisvektoren beschrieben werden. Manche Basen sind „gut" (kurze, fast senkrechte Vektoren → SVP leicht lösbar), manche „schlecht" (lange, fast parallele Vektoren → SVP schwer). Man kann nicht einfach orthonormalisieren, weil das reelle Koeffizienten bräuchte — erlaubt sind nur ganzzahlige unimodulare Transformationen (det = ±1).</p>
|
||||
|
||||
<p><strong>Grundidee der Gitter-Krypto:</strong> Öffentlicher Schlüssel = schlechte Basis, privater Schlüssel = gute Basis desselben Gitters.</p>
|
||||
|
||||
<!-- Viz 1: Lattice + SVP + CVP -->
|
||||
<div class="viz-container" id="viz1-wrap">
|
||||
<div class="step-nav" id="v1nav"></div>
|
||||
<div id="v1legend" style="margin-bottom:6px"></div>
|
||||
<svg id="v1svg" width="100%" viewBox="0 0 640 380"></svg>
|
||||
<div class="viz-caption" id="v1cap"></div>
|
||||
</div>
|
||||
|
||||
<script>
|
||||
(function(){
|
||||
const b1=[80,20], b2=[30,70];
|
||||
const b1p=[110,90], b2p=[190,110];
|
||||
const ox=320, oy=220;
|
||||
function gp(i,j){return [ox+i*b1[0]+j*b2[0], oy-(i*b1[1]+j*b2[1])];}
|
||||
function allPts(){
|
||||
const pts=[];
|
||||
for(let i=-4;i<=4;i++) for(let j=-4;j<=4;j++){
|
||||
const [x,y]=gp(i,j);
|
||||
if(x>10&&x<630&&y>10&&y<370) pts.push({x,y,i,j});
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
function dist(i,j){return Math.sqrt((i*b1[0]+j*b2[0])**2+(i*b1[1]+j*b2[1])**2);}
|
||||
function findShortest(){
|
||||
let best=Infinity,bi=0,bj=0;
|
||||
for(let i=-4;i<=4;i++) for(let j=-4;j<=4;j++){
|
||||
if(i===0&&j===0) continue;
|
||||
const d=dist(i,j); if(d<best){best=d;bi=i;bj=j;}
|
||||
}
|
||||
return {i:bi,j:bj,d:best};
|
||||
}
|
||||
const steps=[
|
||||
{label:"1. Gitter",legend:[{c:"#5DCAA5",t:"Gitterpunkte"},{c:"#378ADD",t:"Basis b₁, b₂"}]},
|
||||
{label:"2. Schlechte Basis",legend:[{c:"#5DCAA5",t:"Gleiche Punkte"},{c:"#378ADD",t:"Gute Basis (kurz, fast orthogonal)"},{c:"#D85A30",t:"Schlechte Basis b₁', b₂' (lang, fast parallel)"}]},
|
||||
{label:"3. SVP",legend:[{c:"#5DCAA5",t:"Gitterpunkte"},{c:"#E24B4A",t:"λ₁ = kürzester Vektor"}]},
|
||||
{label:"4. γ-SVP",legend:[{c:"#E24B4A",t:"λ₁ (exakt)"},{c:"#EF9F27",t:"γ·λ₁ (Approximation ok)"}]},
|
||||
{label:"5. CVP",legend:[{c:"#7F77DD",t:"Zielpunkt t"},{c:"#1D9E75",t:"Nächster Gitterpunkt"}]},
|
||||
];
|
||||
const captions=[
|
||||
`<strong>Ein Gitter</strong> entsteht durch alle ganzzahligen Kombinationen der Basisvektoren b₁ und b₂.`,
|
||||
`<strong>Dasselbe Gitter, schlechte Basis.</strong> b₁' = b₁+b₂ und b₂' = 2b₁+b₂ — beide lang, nur ~8° auseinander (fast parallel). Die Vektoren erzeugen exakt die gleichen Punkte. Grundidee der Krypto: öffentlicher Schlüssel = schlechte Basis, privater Schlüssel = gute.`,
|
||||
`<strong>SVP: Finde den kürzesten Nicht-Null-Vektor.</strong> In 2D trivial — in Dimension 500+ exponentiell schwer.`,
|
||||
`<strong>γ-SVP:</strong> Statt exakt λ₁ zu finden, reicht ein Vektor im orangenen Kreis. Je größer γ, desto leichter.`,
|
||||
`<strong>CVP:</strong> Finde den nächsten Gitterpunkt zu einem externen Punkt t. Mindestens so schwer wie SVP.`,
|
||||
];
|
||||
function draw(step){
|
||||
const svg=document.getElementById('v1svg');
|
||||
const pts=allPts(), sh=findShortest(), [sx,sy]=gp(sh.i,sh.j);
|
||||
let h=`<defs><marker id="a1" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M2 1L8 5L2 9" fill="none" stroke="context-stroke" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></marker></defs>`;
|
||||
for(let i=-4;i<=4;i++){const[x1,y1]=gp(i,-4),[x2,y2]=gp(i,4);h+=`<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${getComputedStyle(document.body).getPropertyValue('color').includes('255')?'rgba(255,255,255,0.06)':'rgba(0,0,0,0.06)'}" stroke-width="0.3"/>`;}
|
||||
for(let j=-4;j<=4;j++){const[x1,y1]=gp(-4,j),[x2,y2]=gp(4,j);h+=`<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${getComputedStyle(document.body).getPropertyValue('color').includes('255')?'rgba(255,255,255,0.06)':'rgba(0,0,0,0.06)'}" stroke-width="0.3"/>`;}
|
||||
const dots=(hl)=>{let g='';pts.forEach(p=>{const isO=p.i===0&&p.j===0,isS=p.i===sh.i&&p.j===sh.j;let fill="#5DCAA5",r=isO?5:3.5,op=isO?1:0.7;if(hl==='svp'&&isS){fill="#E24B4A";r=5;op=1;}if(hl==='cvp'&&p.i===1&&p.j===0){fill="#1D9E75";r=5;op=1;}g+=`<circle cx="${p.x}" cy="${p.y}" r="${r}" fill="${fill}" opacity="${op}"/>`;if(isO)g+=`<text x="${p.x+8}" y="${p.y-8}" fill="var(--text3)" font-size="12" font-family="var(--font)">0</text>`;});return g;};
|
||||
const arrow=(x1,y1,x2,y2,color,w=2)=>`<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="${color}" stroke-width="${w}" stroke-linecap="round" marker-end="url(#a1)"/>`;
|
||||
if(step===0){h+=dots('');h+=arrow(ox,oy,ox+b1[0],oy-b1[1],"#378ADD",2.5);h+=arrow(ox,oy,ox+b2[0],oy-b2[1],"#378ADD",2.5);h+=`<text x="${ox+b1[0]+8}" y="${oy-b1[1]-6}" fill="#378ADD" font-size="14" font-weight="500" font-family="var(--font)">b₁</text>`;h+=`<text x="${ox+b2[0]+8}" y="${oy-b2[1]-6}" fill="#378ADD" font-size="14" font-weight="500" font-family="var(--font)">b₂</text>`;}
|
||||
if(step===1){h+=dots('');h+=arrow(ox,oy,ox+b1[0],oy-b1[1],"#378ADD",1.5);h+=arrow(ox,oy,ox+b2[0],oy-b2[1],"#378ADD",1.5);h+=`<text x="${ox+b1[0]+8}" y="${oy-b1[1]-6}" fill="#378ADD" font-size="13" font-family="var(--font)" opacity="0.5">b₁</text>`;h+=`<text x="${ox+b2[0]+8}" y="${oy-b2[1]-6}" fill="#378ADD" font-size="13" font-family="var(--font)" opacity="0.5">b₂</text>`;h+=arrow(ox,oy,ox+b1p[0],oy-b1p[1],"#D85A30",2.5);h+=arrow(ox,oy,ox+b2p[0],oy-b2p[1],"#D85A30",2.5);h+=`<text x="${ox+b1p[0]+8}" y="${oy-b1p[1]-6}" fill="#D85A30" font-size="14" font-weight="500" font-family="var(--font)">b₁'</text>`;h+=`<text x="${ox+b2p[0]-24}" y="${oy-b2p[1]-6}" fill="#D85A30" font-size="14" font-weight="500" font-family="var(--font)">b₂'</text>`;}
|
||||
if(step===2){h+=dots('svp');h+=arrow(ox,oy,sx,sy,"#E24B4A",2.5);h+=`<text x="${(ox+sx)/2+10}" y="${(oy+sy)/2-10}" fill="#E24B4A" font-size="14" font-weight="500" font-family="var(--font)">λ₁</text>`;}
|
||||
if(step===3){const r1=sh.d,r2=r1*2;h+=`<circle cx="${ox}" cy="${oy}" r="${r1}" fill="none" stroke="#E24B4A" stroke-width="1" stroke-dasharray="4 3" opacity="0.7"/>`;h+=`<circle cx="${ox}" cy="${oy}" r="${r2}" fill="#EF9F27" fill-opacity="0.08" stroke="#EF9F27" stroke-width="1.5" stroke-dasharray="5 3"/>`;h+=dots('svp');h+=arrow(ox,oy,sx,sy,"#E24B4A",2);h+=`<text x="${ox+8}" y="${oy-r1-6}" fill="#E24B4A" font-size="12" font-family="var(--font)">λ₁</text>`;h+=`<text x="${ox+8}" y="${oy-r2-6}" fill="#EF9F27" font-size="12" font-family="var(--font)">γ·λ₁</text>`;pts.filter(p=>{if(p.i===0&&p.j===0)return false;const d=dist(p.i,p.j);return d<=r2&&d>r1;}).forEach(p=>{h+=`<circle cx="${p.x}" cy="${p.y}" r="6" fill="none" stroke="#EF9F27" stroke-width="1.5"/>`;});}
|
||||
if(step===4){const tx=ox+55,ty=oy-52,[cx,cy]=gp(1,0);h+=dots('cvp');h+=`<circle cx="${tx}" cy="${ty}" r="6" fill="#7F77DD"/>`;h+=`<text x="${tx+10}" y="${ty-8}" fill="#7F77DD" font-size="14" font-weight="500" font-family="var(--font)">t</text>`;h+=`<line x1="${tx}" y1="${ty}" x2="${cx}" y2="${cy}" stroke="#1D9E75" stroke-width="1.5" stroke-dasharray="5 3"/>`;h+=`<text x="${(tx+cx)/2+10}" y="${(ty+cy)/2-8}" fill="#1D9E75" font-size="12" font-family="var(--font)">Distanz</text>`;}
|
||||
svg.innerHTML=h;
|
||||
document.querySelectorAll('#v1nav .step-btn').forEach((b,i)=>b.classList.toggle('active',i===step));
|
||||
document.getElementById('v1legend').innerHTML=steps[step].legend.map(l=>`<span class="key-item"><span class="key-dot" style="background:${l.c}"></span>${l.t}</span>`).join('');
|
||||
document.getElementById('v1cap').innerHTML=captions[step];
|
||||
}
|
||||
const nav=document.getElementById('v1nav');
|
||||
steps.forEach((s,i)=>{const b=document.createElement('button');b.className='step-btn';b.textContent=s.label;b.onclick=()=>draw(i);nav.appendChild(b);});
|
||||
draw(0);
|
||||
})();
|
||||
</script>
|
||||
|
||||
<!-- ═══════════════════════════════════════ -->
|
||||
<h2>2. SVP, γ-SVP und CVP</h2>
|
||||
|
||||
<h3>Exaktes SVP</h3>
|
||||
<p>Gegeben eine Basis B, finde den kürzesten Nicht-Null-Vektor. Die Länge dieses Vektors heißt λ₁(L). Minkowski hat 1889 bewiesen, dass so ein Vektor immer existiert — aber ihn <em>finden</em> ist das Problem.</p>
|
||||
|
||||
<h3>γ-SVP (Approximation)</h3>
|
||||
<p>Statt den exakt kürzesten Vektor zu finden, reicht einer, der höchstens γ-mal so lang ist. Drei Varianten:</p>
|
||||
<p><strong>Suchversion (SVP_γ):</strong> Finde einen Vektor v mit ‖v‖ ≤ γ · λ₁.</p>
|
||||
<p><strong>Schätzversion (EstSVP_γ):</strong> Gib die Länge λ₁ bis auf Faktor γ genau an.</p>
|
||||
<p><strong>Entscheidungsversion (GapSVP_γ):</strong> Gegeben Basis B und Wert d, unterscheide: Ist λ₁ ≤ d (YES) oder λ₁ > γ·d (NO)? Alles dazwischen ist Grauzone (Promise-Problem) — dort darf die Antwort beliebig sein. In der Visualisierung: blauer Kreis = YES-Grenze (d), oranger Kreis = NO-Grenze (γ·d), gelbe Zone dazwischen = der „verbotene" Bereich, den das Problem ignoriert.</p>
|
||||
|
||||
<div class="merkbox">
|
||||
<div class="merkbox-title">Die Komplexitätslandschaft von γ</div>
|
||||
<code>γ = 1</code> → NP-hart (Ajtai 1998)<br>
|
||||
<code>γ = Konstante</code> → NP-hart (Micciancio 2001)<br>
|
||||
<code>γ ≈ √n</code> → NP ∩ coNP (Aharonov & Regev 2005)<br>
|
||||
<code>γ = 2^O(n)</code> → in P (LLL löst das)<br>
|
||||
Dazwischen: <em>Terra incognita</em> — niemand weiß wo es kippt.
|
||||
</div>
|
||||
|
||||
<h3>CVP (Closest Vector Problem)</h3>
|
||||
<p>Gegeben ein Gitter und einen externen Punkt t (nicht im Gitter), finde den nächstgelegenen Gitterpunkt. In der Visualisierung: roter Punkt mit Kreuz = Zielpunkt t, grün umringter Punkt = nächster Gitterpunkt, gestrichelte Linie = minimale Distanz.</p>
|
||||
<p><strong>Verhältnis zu SVP:</strong> SVP ≤<sub>p</sub> CVP (Polynomialzeit-Reduktion: Man kann SVP auf CVP reduzieren, indem man Basis verdoppelt und t geschickt wählt). Die Umkehrung ist unbekannt — CVP gilt als das natürlich schwerere Problem. Typische Anwendung in der Kryptografie: t ist ein verrauschter Geheimtext, der nächste Gitterpunkt ist die eigentliche Nachricht.</p>
|
||||
|
||||
<!-- ═══════════════════════════════════════ -->
|
||||
<h2>3. Komplexitätstheoretische Einordnung</h2>
|
||||
|
||||
<h3>Schnell-Glossar</h3>
|
||||
<p><strong>P</strong> = effizient lösbar. <strong>NP</strong> = Lösung schnell überprüfbar. <strong>NP-hart</strong> = mindestens so schwer wie alles in NP. <strong>coNP</strong> = Ablehnung schnell verifizierbar. <strong>NP ∩ coNP</strong> = beides verifizierbar → vermutlich nicht NP-hart.</p>
|
||||
|
||||
<h3>NP-Härte (Ajtai 1998)</h3>
|
||||
<p>Ajtai hat SAT auf SVP reduziert: Aus jeder SAT-Formel baut er ein Gitter, bei dem der kürzeste Vektor verrät, ob die Formel erfüllbar ist. <strong>Aber:</strong> Die Reduktion braucht Zufall (randomisiert). Ob es deterministisch geht, ist seit 26 Jahren offen.</p>
|
||||
<p>Micciancio (2001) verschärft: Selbst Approximation bis auf <em>jeden</em> konstanten Faktor γ bleibt NP-hart.</p>
|
||||
|
||||
<h3>GapSVP in NP ∩ coNP (Aharonov & Regev 2005)</h3>
|
||||
<p>Ab γ ≈ √n liegt GapSVP in NP ∩ coNP. Die NP-Seite ist trivial (kurzen Vektor vorzeigen). Die coNP-Seite ist der Durchbruch:</p>
|
||||
|
||||
<!-- Viz 2: Dual Lattice / coNP -->
|
||||
<div class="viz-container" id="viz2-wrap">
|
||||
<div class="step-nav" id="v2nav"></div>
|
||||
<svg id="v2svg" width="100%" viewBox="0 0 640 320"></svg>
|
||||
<div class="viz-caption" id="v2cap"></div>
|
||||
</div>
|
||||
|
||||
<script>
|
||||
(function(){
|
||||
const ox1=160,oy=160,ox2=480;
|
||||
const steps=[
|
||||
{label:"1. Wippe",desc:`<strong>Transference-Theorem:</strong> Wenn λ₁(L) groß ist (Gitter hat keinen kurzen Vektor), dann muss λ₁(L*) klein sein (Dual hat kurze Vektoren). Wie eine Wippe.`},
|
||||
{label:"2. Umgekehrt",desc:`<strong>Andersrum:</strong> Kurze Vektoren im Gitter → lange Vektoren im Dual. Die Wippe kippt. Banaszczyk: λ₁(L) · λ₁(L*) ≥ 1.`},
|
||||
{label:"3. Der Beweis",desc:`<strong>coNP-Beweis:</strong> Um zu zeigen "L hat keinen kurzen Vektor", zeige stattdessen kurze Vektoren im Dual. Abwesenheit beweisen durch Anwesenheit von etwas anderem.`},
|
||||
];
|
||||
function draw(s){
|
||||
const svg=document.getElementById('v2svg');
|
||||
let h=`<defs><marker id="a2" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M2 1L8 5L2 9" fill="none" stroke="context-stroke" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></marker></defs>`;
|
||||
h+=`<line x1="320" y1="15" x2="320" y2="305" stroke="var(--border)" stroke-width="0.5" stroke-dasharray="6 4"/>`;
|
||||
h+=`<text x="160" y="18" text-anchor="middle" fill="var(--text2)" font-size="13" font-weight="500" font-family="var(--font)">Gitter L</text>`;
|
||||
h+=`<text x="480" y="18" text-anchor="middle" fill="var(--text2)" font-size="13" font-weight="500" font-family="var(--font)">Duales Gitter L*</text>`;
|
||||
function lattice(cx,cy,b1,b2,color,r,range,showR,rc,rv){
|
||||
let g='';
|
||||
for(let i=-range;i<=range;i++){const x1=cx+i*b1[0]-range*b2[0],y1=cy-(i*b1[1]-range*b2[1]),x2=cx+i*b1[0]+range*b2[0],y2=cy-(i*b1[1]+range*b2[1]);g+=`<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="var(--border)" stroke-width="0.2"/>`;}
|
||||
for(let j=-range;j<=range;j++){const x1=cx-range*b1[0]+j*b2[0],y1=cy-(-range*b1[1]+j*b2[1]),x2=cx+range*b1[0]+j*b2[0],y2=cy-(range*b1[1]+j*b2[1]);g+=`<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="var(--border)" stroke-width="0.2"/>`;}
|
||||
if(showR) g+=`<circle cx="${cx}" cy="${cy}" r="${rv}" fill="${rc}" fill-opacity="0.08" stroke="${rc}" stroke-width="1" stroke-dasharray="4 3"/>`;
|
||||
for(let i=-range;i<=range;i++) for(let j=-range;j<=range;j++){const x=cx+i*b1[0]+j*b2[0],y=cy-(i*b1[1]+j*b2[1]);if(x>5&&x<635&&y>20&&y<310){const isO=i===0&&j===0;g+=`<circle cx="${x}" cy="${y}" r="${isO?4:r}" fill="${color}" opacity="${isO?1:0.7}"/>`;}}
|
||||
return g;
|
||||
}
|
||||
if(s===0){
|
||||
h+=lattice(ox1,oy,[55,18],[15,50],"#378ADD",3.5,4,true,"#378ADD",55);
|
||||
h+=lattice(ox2,oy,[14,5],[4,15],"#D85A30",3,10,true,"#D85A30",14);
|
||||
h+=`<text x="${ox1}" y="${oy+75}" text-anchor="middle" fill="#378ADD" font-size="12" font-family="var(--font)">λ₁ groß ↑</text>`;
|
||||
h+=`<text x="${ox2}" y="${oy+75}" text-anchor="middle" fill="#D85A30" font-size="12" font-family="var(--font)">λ₁* klein ↓</text>`;
|
||||
h+=`<text x="320" y="${oy+75}" text-anchor="middle" fill="var(--text3)" font-size="20">⇆</text>`;
|
||||
}
|
||||
if(s===1){
|
||||
h+=lattice(ox1,oy,[22,7],[6,20],"#378ADD",2.5,8,true,"#378ADD",22);
|
||||
h+=lattice(ox2,oy,[48,16],[12,45],"#D85A30",3.5,3,true,"#D85A30",48);
|
||||
h+=`<text x="${ox1}" y="${oy+75}" text-anchor="middle" fill="#378ADD" font-size="12" font-family="var(--font)">λ₁ klein ↓</text>`;
|
||||
h+=`<text x="${ox2}" y="${oy+75}" text-anchor="middle" fill="#D85A30" font-size="12" font-family="var(--font)">λ₁* groß ↑</text>`;
|
||||
h+=`<text x="320" y="${oy+75}" text-anchor="middle" fill="var(--text3)" font-size="20">⇆</text>`;
|
||||
}
|
||||
if(s===2){
|
||||
const b1D=[14,5],b2D=[4,15];
|
||||
h+=lattice(ox1,oy,[55,18],[15,50],"#378ADD",3.5,4,true,"#E24B4A",40);
|
||||
h+=`<text x="${ox1}" y="${oy+80}" text-anchor="middle" fill="#1D9E75" font-size="12" font-weight="500" font-family="var(--font)">Kein Punkt im Kreis!</text>`;
|
||||
for(let i=-10;i<=10;i++){const x1=ox2+i*b1D[0]-10*b2D[0],y1=oy-(i*b1D[1]-10*b2D[1]),x2=ox2+i*b1D[0]+10*b2D[0],y2=oy-(i*b1D[1]+10*b2D[1]);h+=`<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="var(--border)" stroke-width="0.2"/>`;}
|
||||
for(let j=-10;j<=10;j++){const x1=ox2-10*b1D[0]+j*b2D[0],y1=oy-(-10*b1D[1]+j*b2D[1]),x2=ox2+10*b1D[0]+j*b2D[0],y2=oy-(10*b1D[1]+j*b2D[1]);h+=`<line x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}" stroke="var(--border)" stroke-width="0.2"/>`;}
|
||||
for(let i=-10;i<=10;i++) for(let j=-10;j<=10;j++){const x=ox2+i*b1D[0]+j*b2D[0],y=oy-(i*b1D[1]+j*b2D[1]);if(x>325&&x<635&&y>20&&y<310){const isO=i===0&&j===0;const d=Math.sqrt((i*b1D[0]+j*b2D[0])**2+(i*b1D[1]+j*b2D[1])**2);if(!isO&&d<=22){h+=`<circle cx="${x}" cy="${y}" r="6" fill="none" stroke="#EF9F27" stroke-width="1.5"/>`;h+=`<circle cx="${x}" cy="${y}" r="3" fill="#EF9F27"/>`;}else{h+=`<circle cx="${x}" cy="${y}" r="${isO?4:2.5}" fill="#D85A30" opacity="${isO?1:0.5}"/>`;}}}
|
||||
h+=`<text x="${ox2}" y="${oy+80}" text-anchor="middle" fill="#EF9F27" font-size="12" font-weight="500" font-family="var(--font)">Kurze duale Vektoren = Beweis</text>`;
|
||||
h+=`<path d="M320 ${oy+55} C 360 ${oy+35}, 400 ${oy+35}, 440 ${oy+55}" fill="none" stroke="var(--text3)" stroke-width="0.8" stroke-dasharray="3 3" marker-end="url(#a2)"/>`;
|
||||
h+=`<text x="380" y="${oy+43}" text-anchor="middle" fill="var(--text3)" font-size="10" font-family="var(--font)">beweist</text>`;
|
||||
}
|
||||
svg.innerHTML=h;
|
||||
document.querySelectorAll('#v2nav .step-btn').forEach((b,i)=>b.classList.toggle('active',i===s));
|
||||
document.getElementById('v2cap').innerHTML=steps[s].desc;
|
||||
}
|
||||
const nav=document.getElementById('v2nav');
|
||||
steps.forEach((s,i)=>{const b=document.createElement('button');b.className='step-btn';b.textContent=s.label;b.onclick=()=>draw(i);nav.appendChild(b);});
|
||||
draw(0);
|
||||
})();
|
||||
</script>
|
||||
|
||||
<div class="merkbox">
|
||||
<div class="merkbox-title">Der coNP-Beweis in einem Satz</div>
|
||||
Du beweist Abwesenheit (kein kurzer Vektor im Gitter) durch Anwesenheit (kurze Vektoren im dualen Gitter). Wegen der Wippe (Transference-Theorem) schließt das eine das andere aus.
|
||||
</div>
|
||||
|
||||
<p>Fun Fact: Aharonov & Regev haben das zuerst quantenmechanisch bewiesen (QMA) und dann "dequantisiert" — den Quantenbeweis in einen klassischen umgewandelt.</p>
|
||||
|
||||
<!-- ═══════════════════════════════════════ -->
|
||||
<h2>4. Worst-Case-to-Average-Case-Reduktion</h2>
|
||||
|
||||
<h3>Das Problem mit RSA</h3>
|
||||
<p>RSA sagt: "Faktorisieren zufälliger Zahlen ist hoffentlich schwer." Aber es gibt keinen Beweis dafür. Vielleicht sind 99% der zufälligen Instanzen leicht — dann wäre RSA unsicher. Bogdanov & Trevisan haben gezeigt, dass so eine Worst-Case-to-Average-Case-Verbindung für allgemeine NP-Probleme vermutlich unmöglich ist.</p>
|
||||
|
||||
<h3>Ajtais Durchbruch (1996)</h3>
|
||||
<p>Für Gitter ist es anders: Wenn du <em>zufällige</em> SIS-Instanzen lösen kannst, kannst du <em>jede beliebige</em> Worst-Case-SVP-Instanz lösen. Die Reduktion baut aus der schwierigsten SVP-Instanz zufällige SIS-Instanzen. Löst jemand die, kannst du die Lösung zurückübersetzen.</p>
|
||||
|
||||
<p><strong>SIS (Short Integer Solution):</strong> Gegeben eine zufällige Matrix A, finde einen kurzen Vektor z mit Az = 0 mod q.</p>
|
||||
|
||||
<div class="merkbox">
|
||||
<div class="merkbox-title">Warum das einzigartig ist</div>
|
||||
Bei Gittern gibt es keine "leichten zufälligen Instanzen". Entweder ALLE sind schwer, oder ALLE sind leicht. Es gibt kein Dazwischen. Das ist bei keinem anderen kryptografisch relevanten Problem der Fall.
|
||||
</div>
|
||||
|
||||
<!-- Viz 3: Reduction chain -->
|
||||
<div class="viz-container" id="viz3-wrap">
|
||||
<div class="step-nav" id="v3nav"></div>
|
||||
<svg id="v3svg" width="100%" viewBox="0 0 640 420"></svg>
|
||||
<div class="viz-caption" id="v3cap"></div>
|
||||
</div>
|
||||
|
||||
<script>
|
||||
(function(){
|
||||
const steps=[
|
||||
{label:"1. RSA vs Gitter",desc:`<strong>Links RSA:</strong> Mischung aus leichten und schweren Instanzen, keine Verbindung zum Worst-Case. <strong>Rechts Gitter:</strong> Alle gleich schwer, durch Reduktion bewiesen.`},
|
||||
{label:"2. Die volle Kette",desc:`<strong>Die komplette Sicherheitsargumentation:</strong> Jeder Pfeil ist eine bewiesene Reduktion. Kyber brechen = SVP im Worst-Case lösen. Kein bekannter klassischer oder Quantenalgorithmus kann das.`},
|
||||
];
|
||||
function draw(s){
|
||||
const svg=document.getElementById('v3svg');
|
||||
let h=`<defs><marker id="a3" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M2 1L8 5L2 9" fill="none" stroke="context-stroke" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></marker></defs>`;
|
||||
const cx=320;
|
||||
if(s===0){
|
||||
h+=`<text x="160" y="32" text-anchor="middle" fill="var(--text2)" font-size="14" font-weight="500" font-family="var(--font)">RSA / Faktorisierung</text>`;
|
||||
h+=`<text x="480" y="32" text-anchor="middle" fill="var(--text2)" font-size="14" font-weight="500" font-family="var(--font)">Gitter / SVP</text>`;
|
||||
h+=`<line x1="320" y1="16" x2="320" y2="400" stroke="var(--border)" stroke-width="0.5" stroke-dasharray="6 4"/>`;
|
||||
h+=`<text x="160" y="62" text-anchor="middle" fill="var(--text3)" font-size="12" font-family="var(--font)">Zufällige Instanzen</text>`;
|
||||
const rsaX=[50,92,134,176,218];
|
||||
rsaX.forEach((x,i)=>{const c=i===3?"#F09595":"#97C459";h+=`<rect x="${x}" y="74" width="36" height="36" rx="6" fill="${c}" fill-opacity="0.25" stroke="${c}" stroke-width="0.5"/>`;});
|
||||
h+=`<text x="86" y="98" text-anchor="middle" fill="#639922" font-size="10" font-family="var(--font)">leicht</text>`;
|
||||
h+=`<text x="194" y="98" text-anchor="middle" fill="#E24B4A" font-size="10" font-family="var(--font)">schwer</text>`;
|
||||
h+=`<text x="160" y="136" text-anchor="middle" fill="var(--text3)" font-size="12" font-family="var(--font)">Worst-Case</text>`;
|
||||
h+=`<rect x="110" y="146" width="100" height="36" rx="6" fill="#F09595" fill-opacity="0.25" stroke="#E24B4A" stroke-width="0.5"/>`;
|
||||
h+=`<text x="160" y="170" text-anchor="middle" fill="#E24B4A" font-size="11" font-family="var(--font)">sehr schwer</text>`;
|
||||
h+=`<text x="160" y="212" text-anchor="middle" fill="#E24B4A" font-size="12" font-family="var(--font)">Keine Verbindung!</text>`;
|
||||
h+=`<text x="480" y="62" text-anchor="middle" fill="var(--text3)" font-size="12" font-family="var(--font)">Zufällige Instanzen</text>`;
|
||||
for(let i=0;i<5;i++){h+=`<rect x="${370+i*42}" y="74" width="36" height="36" rx="6" fill="#F09595" fill-opacity="0.25" stroke="#E24B4A" stroke-width="0.5"/>`;h+=`<text x="${388+i*42}" y="98" text-anchor="middle" fill="#E24B4A" font-size="10" font-family="var(--font)">schwer</text>`;}
|
||||
h+=`<text x="480" y="136" text-anchor="middle" fill="var(--text3)" font-size="12" font-family="var(--font)">Worst-Case</text>`;
|
||||
h+=`<rect x="430" y="146" width="100" height="36" rx="6" fill="#F09595" fill-opacity="0.25" stroke="#E24B4A" stroke-width="0.5"/>`;
|
||||
h+=`<text x="480" y="170" text-anchor="middle" fill="#E24B4A" font-size="11" font-family="var(--font)">sehr schwer</text>`;
|
||||
h+=`<line x1="480" y1="114" x2="480" y2="142" stroke="#1D9E75" stroke-width="1.5" marker-end="url(#a3)"/>`;
|
||||
h+=`<line x1="480" y1="184" x2="480" y2="114" stroke="#1D9E75" stroke-width="1.5" marker-start="url(#a3)"/>`;
|
||||
h+=`<text x="512" y="134" fill="#1D9E75" font-size="11" font-weight="500" font-family="var(--font)">= gleich schwer!</text>`;
|
||||
h+=`<rect x="40" y="270" width="230" height="56" rx="8" fill="#F09595" fill-opacity="0.12" stroke="#E24B4A" stroke-width="0.5"/>`;
|
||||
h+=`<text x="155" y="294" text-anchor="middle" fill="#E24B4A" font-size="13" font-weight="500" font-family="var(--font)">Sicherheit = Hoffnung</text>`;
|
||||
h+=`<text x="155" y="312" text-anchor="middle" fill="#E24B4A" font-size="11" font-family="var(--font)">"Hoffentlich schwer"</text>`;
|
||||
h+=`<rect x="370" y="270" width="230" height="56" rx="8" fill="#5DCAA5" fill-opacity="0.12" stroke="#1D9E75" stroke-width="0.5"/>`;
|
||||
h+=`<text x="485" y="294" text-anchor="middle" fill="#1D9E75" font-size="13" font-weight="500" font-family="var(--font)">Sicherheit = Beweis</text>`;
|
||||
h+=`<text x="485" y="312" text-anchor="middle" fill="#1D9E75" font-size="11" font-family="var(--font)">"Beweisbar schwer"</text>`;
|
||||
}
|
||||
if(s===1){
|
||||
const levels=[
|
||||
{y:30,label:"Worst-Case GapSVP/SIVP",sub:"Faktor Õ(n)",color:"#E24B4A",bg:"#F09595"},
|
||||
{y:110,label:"Average-Case SIS",sub:"Ajtai 1996, Micciancio-Regev 2007",color:"#BA7517",bg:"#EF9F27"},
|
||||
{y:190,label:"Average-Case LWE",sub:"Regev 2005, Peikert 2009",color:"#534AB7",bg:"#AFA9EC"},
|
||||
{y:270,label:"ML-KEM / ML-DSA",sub:"NIST FIPS 203 & 204, August 2024",color:"#0F6E56",bg:"#5DCAA5"},
|
||||
];
|
||||
levels.forEach((lv,i)=>{
|
||||
h+=`<rect x="120" y="${lv.y}" width="400" height="56" rx="8" fill="${lv.bg}" fill-opacity="0.15" stroke="${lv.color}" stroke-width="0.5"/>`;
|
||||
h+=`<text x="${cx}" y="${lv.y+24}" text-anchor="middle" fill="${lv.color}" font-size="14" font-weight="500" font-family="var(--font)">${lv.label}</text>`;
|
||||
h+=`<text x="${cx}" y="${lv.y+42}" text-anchor="middle" fill="${lv.color}" font-size="11" font-family="var(--font)" opacity="0.8">${lv.sub}</text>`;
|
||||
if(i<levels.length-1){h+=`<line x1="${cx}" y1="${lv.y+60}" x2="${cx}" y2="${levels[i+1].y-4}" stroke="var(--text3)" stroke-width="1.5" marker-end="url(#a3)"/>`;}
|
||||
});
|
||||
h+=`<rect x="120" y="360" width="400" height="44" rx="8" fill="var(--bg2)" stroke="var(--border)" stroke-width="0.5"/>`;
|
||||
h+=`<text x="${cx}" y="386" text-anchor="middle" fill="var(--text2)" font-size="12" font-weight="500" font-family="var(--font)">Kyber brechen = SVP im Worst-Case lösen</text>`;
|
||||
}
|
||||
svg.innerHTML=h;
|
||||
document.querySelectorAll('#v3nav .step-btn').forEach((b,i)=>b.classList.toggle('active',i===s));
|
||||
document.getElementById('v3cap').innerHTML=steps[s].desc;
|
||||
}
|
||||
const nav=document.getElementById('v3nav');
|
||||
steps.forEach((s,i)=>{const b=document.createElement('button');b.className='step-btn';b.textContent=s.label;b.onclick=()=>draw(i);nav.appendChild(b);});
|
||||
draw(0);
|
||||
})();
|
||||
</script>
|
||||
|
||||
<!-- ═══════════════════════════════════════ -->
|
||||
<h2>5. Algorithmen</h2>
|
||||
|
||||
<h3>LLL (Lenstra-Lenstra-Lovász, 1982)</h3>
|
||||
<p>Nimmt eine "schlechte" Basis und macht sie "besser". Zwei Bedingungen:</p>
|
||||
<p><strong>Größenreduktion:</strong> Gram-Schmidt-Koeffizienten |μ| ≤ ½ — jeder Vektor zeigt so wenig wie möglich in Richtung der vorherigen.</p>
|
||||
<p><strong>Lovász-Bedingung:</strong> Die Gram-Schmidt-Vektoren dürfen nicht zu schnell kürzer werden.</p>
|
||||
<p>Funktioniert wie Bubble Sort — vergleiche Nachbarn, tausche wenn nötig. Polynomielle Laufzeit, aber exponentieller Approximationsfaktor 2^{(n-1)/2}.</p>
|
||||
|
||||
<!-- Viz 4: LLL -->
|
||||
<div class="viz-container" id="viz4-wrap">
|
||||
<div class="step-nav" id="v4nav"></div>
|
||||
<svg id="v4svg" width="100%" viewBox="0 0 640 340"></svg>
|
||||
<div class="viz-caption" id="v4cap"></div>
|
||||
</div>
|
||||
|
||||
<script>
|
||||
(function(){
|
||||
const ox=320,oy=190;
|
||||
const badB1=[140,10],badB2=[130,50];
|
||||
const goodB1=[50,40],goodB2=[-30,50];
|
||||
function len(v){return Math.sqrt(v[0]*v[0]+v[1]*v[1]);}
|
||||
function dot(a,b){return a[0]*b[0]+a[1]*b[1];}
|
||||
function angle(a,b){return Math.acos(dot(a,b)/(len(a)*len(b)))*180/Math.PI;}
|
||||
const steps=[
|
||||
{label:"Schlechte Basis",b1:badB1,b2:badB2,desc:`<strong>Schlechte Basis:</strong> Fast parallele Vektoren (${Math.round(angle(badB1,badB2))}°). Der kürzeste Vektor λ₁ ist viel kürzer als beide Basisvektoren.`},
|
||||
{label:"LLL-reduziert",b1:goodB1,b2:goodB2,desc:`<strong>Nach LLL:</strong> Fast senkrechte Vektoren (${Math.round(angle(goodB1,goodB2))}°). b₁ ist jetzt nah an λ₁. In 2D fast perfekt, in hoher Dimension wird der Faktor exponentiell.`},
|
||||
];
|
||||
function draw(s){
|
||||
const st=steps[s],b1=st.b1,b2=st.b2;
|
||||
let h=`<defs><marker id="a4" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M2 1L8 5L2 9" fill="none" stroke="context-stroke" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></marker></defs>`;
|
||||
for(let i=-6;i<=6;i++) for(let j=-6;j<=6;j++){const x=ox+i*b1[0]+j*b2[0],y=oy-(i*b1[1]+j*b2[1]);if(x>10&&x<630&&y>10&&y<330){const isO=i===0&&j===0;h+=`<circle cx="${x}" cy="${y}" r="${isO?4:2.5}" fill="#5DCAA5" opacity="${isO?1:0.5}"/>`;}}
|
||||
let minD=Infinity,sv=[0,0];
|
||||
for(let i=-3;i<=3;i++) for(let j=-3;j<=3;j++){if(i===0&&j===0)continue;const vx=i*b1[0]+j*b2[0],vy=i*b1[1]+j*b2[1],d=Math.sqrt(vx*vx+vy*vy);if(d<minD){minD=d;sv=[vx,vy];}}
|
||||
h+=`<line x1="${ox}" y1="${oy}" x2="${ox+sv[0]}" y2="${oy-sv[1]}" stroke="#E24B4A" stroke-width="1.5" stroke-dasharray="4 3" opacity="0.6"/>`;
|
||||
h+=`<text x="${ox+sv[0]+(sv[0]>0?8:-30)}" y="${oy-sv[1]-6}" fill="#E24B4A" font-size="11" font-family="var(--font)" opacity="0.7">λ₁</text>`;
|
||||
h+=`<line x1="${ox}" y1="${oy}" x2="${ox+b1[0]}" y2="${oy-b1[1]}" stroke="#378ADD" stroke-width="2.5" marker-end="url(#a4)"/>`;
|
||||
h+=`<line x1="${ox}" y1="${oy}" x2="${ox+b2[0]}" y2="${oy-b2[1]}" stroke="#7F77DD" stroke-width="2.5" marker-end="url(#a4)"/>`;
|
||||
h+=`<text x="${ox+b1[0]+8}" y="${oy-b1[1]-6}" fill="#378ADD" font-size="14" font-weight="500" font-family="var(--font)">b₁</text>`;
|
||||
h+=`<text x="${ox+b2[0]+8}" y="${oy-b2[1]-6}" fill="#7F77DD" font-size="14" font-weight="500" font-family="var(--font)">b₂</text>`;
|
||||
h+=`<text x="40" y="330" fill="var(--text2)" font-size="11" font-family="var(--mono)">‖b₁‖=${Math.round(len(b1))} ‖b₂‖=${Math.round(len(b2))} λ₁=${Math.round(minD)} Faktor=‖b₁‖/λ₁=${(len(b1)/minD).toFixed(2)}</text>`;
|
||||
document.getElementById('v4svg').innerHTML=h;
|
||||
document.querySelectorAll('#v4nav .step-btn').forEach((b,i)=>b.classList.toggle('active',i===s));
|
||||
document.getElementById('v4cap').innerHTML=st.desc;
|
||||
}
|
||||
const nav=document.getElementById('v4nav');
|
||||
steps.forEach((s,i)=>{const b=document.createElement('button');b.className='step-btn';b.textContent=s.label;b.onclick=()=>draw(i);nav.appendChild(b);});
|
||||
draw(0);
|
||||
})();
|
||||
</script>
|
||||
|
||||
<h3>Exakte Algorithmen</h3>
|
||||
<p><strong>Enumeration (Kannan 1983):</strong> Erst Basis reduzieren, dann systematisch alle Vektoren durchprobieren. Wie Baumsuche mit Pruning. Laufzeit n^{O(n)} (superexponentiell), aber nur poly(n) Speicher. Praxistauglich bis Dimension ~60-80.</p>
|
||||
<p><strong>Sieving (AKS 2001):</strong> Starte mit vielen zufälligen Gittervektoren, finde nahe Paare, ersetze durch ihre Differenz. Wie ein Sieb, das immer kürzere Vektoren erzeugt. Laufzeit 2^{n+o(n)} (besser), aber auch 2^{n+o(n)} Speicher (schlechter).</p>
|
||||
|
||||
<h3>Übersichtstabelle</h3>
|
||||
<table style="width:100%;border-collapse:collapse;font-size:14px;margin:16px 0;">
|
||||
<tr style="border-bottom:2px solid var(--border);">
|
||||
<th style="text-align:left;padding:8px;color:var(--text2);">Algorithmus</th>
|
||||
<th style="text-align:left;padding:8px;color:var(--text2);">Faktor γ</th>
|
||||
<th style="text-align:left;padding:8px;color:var(--text2);">Laufzeit</th>
|
||||
<th style="text-align:left;padding:8px;color:var(--text2);">Speicher</th>
|
||||
</tr>
|
||||
<tr style="border-bottom:1px solid var(--border);">
|
||||
<td style="padding:8px;">LLL (1982)</td><td style="padding:8px;font-family:var(--mono);font-size:13px;">2^{(n-1)/2}</td><td style="padding:8px;color:var(--teal);">poly(n)</td><td style="padding:8px;color:var(--teal);">poly(n)</td>
|
||||
</tr>
|
||||
<tr style="border-bottom:1px solid var(--border);">
|
||||
<td style="padding:8px;">BKZ-k</td><td style="padding:8px;font-family:var(--mono);font-size:13px;">2^{O(n/k)}</td><td style="padding:8px;">2^{O(k)}</td><td style="padding:8px;color:var(--teal);">poly(n)</td>
|
||||
</tr>
|
||||
<tr style="border-bottom:1px solid var(--border);">
|
||||
<td style="padding:8px;">Enumeration (1983)</td><td style="padding:8px;font-family:var(--mono);font-size:13px;">1 (exakt)</td><td style="padding:8px;">n^{O(n)}</td><td style="padding:8px;color:var(--teal);">poly(n)</td>
|
||||
</tr>
|
||||
<tr style="border-bottom:1px solid var(--border);">
|
||||
<td style="padding:8px;">Sieving (2001)</td><td style="padding:8px;font-family:var(--mono);font-size:13px;">1 (exakt)</td><td style="padding:8px;">2^{n+o(n)}</td><td style="padding:8px;color:var(--amber);">2^{n+o(n)}</td>
|
||||
</tr>
|
||||
<tr>
|
||||
<td style="padding:8px;">Voronoi (2010)</td><td style="padding:8px;font-family:var(--mono);font-size:13px;">1 (exakt)</td><td style="padding:8px;">Õ(4^n)</td><td style="padding:8px;color:var(--amber);">Õ(2^n)</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<div class="prof-box">
|
||||
<div class="prof-box-title">Offene Frage (kann der Prof fragen)</div>
|
||||
Kann SVP in 2^{O(n)} Zeit mit 2^{o(n)} Speicher gelöst werden? Also das Beste aus Enumeration (wenig Speicher) und Sieving (wenig Zeit)?
|
||||
</div>
|
||||
|
||||
<!-- ═══════════════════════════════════════ -->
|
||||
<h2>6. Post-Quantum-Krypto (Kurzfassung für den Vortrag)</h2>
|
||||
|
||||
<p>RSA und ECC werden durch Shors Algorithmus gebrochen. Die NIST-Standards seit August 2024 basieren auf Gitterproblemen:</p>
|
||||
<p><strong>ML-KEM (Kyber):</strong> Schlüsselaustausch, basiert auf Module-LWE.</p>
|
||||
<p><strong>ML-DSA (Dilithium):</strong> Digitale Signaturen, basiert auf Module-LWE + Module-SIS.</p>
|
||||
<p><strong>SLH-DSA (SPHINCS+):</strong> Hashbasiertes Backup, falls Gitter gebrochen werden.</p>
|
||||
|
||||
<div class="merkbox">
|
||||
<div class="merkbox-title">Der Schlüsselsatz für deinen Vortrag</div>
|
||||
"Die Sicherheit von Kyber und Dilithium basiert nicht auf der Hoffnung, dass zufällige Instanzen schwer sind — sondern auf der beweisbaren Worst-Case-Härte von SVP. Das ist eine fundamental stärkere Aussage als alles, was RSA bieten kann."
|
||||
</div>
|
||||
|
||||
<!-- ═══════════════════════════════════════ -->
|
||||
<h2>7. Wahrscheinliche Prof-Fragen</h2>
|
||||
|
||||
<div class="prof-box">
|
||||
<div class="prof-box-title">1. Warum ist SVP für Post-Quantum-Krypto relevant?</div>
|
||||
Worst-Case-Härte überträgt sich auf Average-Case. Kein bekannter Quantenvorteil. NIST-Standards basieren darauf.
|
||||
</div>
|
||||
|
||||
<div class="prof-box">
|
||||
<div class="prof-box-title">2. Was leistet LLL, und wo sind seine Grenzen?</div>
|
||||
Polynomielle Laufzeit, aber Approximationsfaktor 2^{(n-1)/2} — exponentiell in der Dimension. Reicht für kleine Dimensionen, nicht für kryptografische Parameter (n ≈ 1000).
|
||||
</div>
|
||||
|
||||
<div class="prof-box">
|
||||
<div class="prof-box-title">3. Was ist der Unterschied zwischen SVP und CVP?</div>
|
||||
SVP: kürzester Nicht-Null-Vektor im Gitter (Länge = λ₁). CVP: nächster Gitterpunkt zu einem externen Punkt t ∉ L. SVP ≤<sub>p</sub> CVP — man kann SVP auf CVP reduzieren (Einbettungstrick: verdopple die Basis und wähle t so, dass der nächste Gitterpunkt dem kürzesten Vektor entspricht). Umkehrung unbekannt. GapCVP ist ebenfalls NP-hart und liegt für große γ in NP ∩ coNP.
|
||||
</div>
|
||||
|
||||
<div class="prof-box">
|
||||
<div class="prof-box-title">4. Was bedeutet die Worst-Case-to-Average-Case-Reduktion?</div>
|
||||
Ajtai 1996: Zufällige SIS-Instanzen lösen = Worst-Case-SVP lösen. Einzigartig — bei RSA/SAT gibt es das nicht. Bogdanov & Trevisan zeigten Barrieren für allgemeine NP-Probleme.
|
||||
</div>
|
||||
|
||||
<div class="prof-box">
|
||||
<div class="prof-box-title">5. Wie ordnet sich SVP in die Komplexitätslandschaft ein?</div>
|
||||
NP-hart für exakte Lösung (randomisierte Reduktion), für γ ≈ √n in NP ∩ coNP, für γ = 2^{O(n)} in P. Die genaue Grenze ist offen.
|
||||
</div>
|
||||
|
||||
<div class="prof-box">
|
||||
<div class="prof-box-title">6. Was ist LWE?</div>
|
||||
Gleichungssystem b = As + e mit kleinem Fehler e. Ohne Fehler trivial (Gauß-Elimination), mit Fehler schwer. Regev 2005: LWE lösen → GapSVP im Worst-Case lösen (braucht Quantenreduktion). Peikert 2009: klassisch, aber nur für große Moduli.
|
||||
</div>
|
||||
|
||||
<hr>
|
||||
<p style="color:var(--text3);font-size:13px;margin-top:32px;">Zuletzt aktualisiert: April 2026. Alle Visualisierungen sind interaktiv — klick dich durch die Tabs.</p>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
162
Komplexitätstheorie/vortrag/Quellenverzeichnis.md
Normal file
162
Komplexitätstheorie/vortrag/Quellenverzeichnis.md
Normal file
|
|
@ -0,0 +1,162 @@
|
|||
# Quellenverzeichnis: Shortest Vector Problem Präsentation
|
||||
## Primärliteratur
|
||||
### NP-Härte und Komplexität von SVP
|
||||
1. **Ajtai, M.** (1996). "Generating hard instances of lattice problems (extended abstract)." _Proceedings of the 28th ACM Symposium on Theory of Computing (STOC)_, S. 99–108. ACM.
|
||||
- _Worst-Case-to-Average-Case-Reduktion für Gitterprobleme; Einführung des SIS-Problems._
|
||||
2. **Ajtai, M.** (1998). "The shortest vector problem in ℓ₂ is NP-hard for randomized reductions (extended abstract)." _Proceedings of the 30th ACM Symposium on Theory of Computing (STOC)_, S. 10–19. ACM.
|
||||
- _Erster Beweis der NP-Härte von SVP in der euklidischen Norm unter randomisierten Reduktionen._
|
||||
3. **Micciancio, D.** (2001). "The Shortest Vector in a Lattice is Hard to Approximate to within Some Constant." _SIAM Journal on Computing_, 30(6), S. 2008–2035.
|
||||
- _NP-Härte der Approximation von SVP für jeden konstanten Faktor._
|
||||
- URL: https://cseweb.ucsd.edu/~daniele/papers/SVP.pdf
|
||||
4. **Dinur, I.** (2002). "Approximating SVP∞ to within almost-polynomial factors is NP-hard." _Theoretical Computer Science_, 285(1), S. 55–71.
|
||||
- _NP-Härte für fast-polynomielle Approximationsfaktoren._
|
||||
5. **Haviv, I. & Regev, O.** (2007). "Tensor-based hardness of the shortest vector problem to within almost polynomial factors." _Proceedings of the 39th ACM Symposium on Theory of Computing (STOC)_, S. 469–477. ACM.
|
||||
- _Hardness Amplification durch Tensor-Produkte._
|
||||
6. **van Emde Boas, P.** (1981). "Another NP-Complete Problem and the Complexity of Computing Short Vectors in a Lattice." Technical Report, University of Amsterdam.
|
||||
- _NP-Härte von SVP in der ℓ∞-Norm unter deterministischen Reduktionen._
|
||||
### GapSVP in NP ∩ coNP und verwandte Strukturresultate
|
||||
7. **Lagarias, J. C., Lenstra, H. W. Jr. & Schnorr, C.-P.** (1990). "Korkin-Zolotarev bases and successive minima of a lattice and its reciprocal lattice." _Combinatorica_, 10(4), S. 333–348.
|
||||
- _GapSVP_{n^{1.5}} ∈ coNP; Transference-Theoreme._
|
||||
8. **Banaszczyk, W.** (1993). "New bounds in some transference theorems in the geometry of numbers." _Mathematische Annalen_, 296, S. 625–635.
|
||||
- _Verbesserte Transference-Bounds; GapSVP_n ∈ coNP._
|
||||
9. **Goldreich, O. & Goldwasser, S.** (2000). "On the limits of nonapproximability of lattice problems." _Journal of Computer and System Sciences_, 60(3), S. 540–563. Preliminary version in STOC 1998.
|
||||
- _GapSVP_{O(√(n/log n))} ∈ coAM._
|
||||
10. **Aharonov, D. & Regev, O.** (2003). "A Lattice Problem in Quantum NP." _Proceedings of the 44th Annual IEEE Symposium on Foundations of Computer Science (FOCS)_, S. 210–219. IEEE.
|
||||
- _coGapSVP_{√n} ∈ QMA; erster nicht-trivialer quantenmechanischer Oberschranken-Beweis für ein Gitterproblem._
|
||||
- URL: https://arxiv.org/abs/quant-ph/0307220
|
||||
11. **Aharonov, D. & Regev, O.** (2005). "Lattice problems in NP ∩ coNP." _Journal of the ACM_, 52(5), S. 749–765. Preliminary version in FOCS 2004.
|
||||
- _GapSVP_{O(√n)} ∈ NP ∩ coNP; Dequantisierung des QMA-Resultats._
|
||||
- URL: https://dl.acm.org/doi/10.1145/1089023.1089025
|
||||
- PDF: https://cims.nyu.edu/~regev/papers/cvpconp.pdf
|
||||
12. **Peikert, C.** (2008). "Limits on the Hardness of Lattice Problems in ℓp Norms." _Computational Complexity_, 17(2), S. 300–351. Preliminary version in CCC 2007.
|
||||
- _Verallgemeinerung der coNP-Resultate auf alle ℓp-Normen._
|
||||
- URL: https://web.eecs.umich.edu/~cpeikert/pubs/lp_norms.pdf
|
||||
|
||||
### Worst-Case-to-Average-Case-Reduktionen
|
||||
13. **Ajtai, M.** (2004). "Generating hard instances of lattice problems." _Complexity of Computations and Proofs_, Quad. Mat. 13, Dept. Math., Seconda Univ. Napoli, Caserta, Italy, S. 1–32.
|
||||
- _Erweiterte Version des STOC-1996-Papers._
|
||||
14. **Cai, J.-Y. & Nerurkar, A.** (1997). "An improved worst-case to average-case connection for lattice problems." _Proceedings of the 38th Annual IEEE Symposium on Foundations of Computer Science (FOCS)_, S. 468–477.
|
||||
- _Verbesserung des Verbindungsfaktors auf n^{4+ε}._
|
||||
15. **Micciancio, D.** (2004). "Almost perfect lattices, the covering radius problem, and applications to Ajtai's connection factor." _SIAM Journal on Computing_, 34(1), S. 118–169.
|
||||
- _Verbesserung des Verbindungsfaktors auf n³ · ω(√(log n · log log n))._
|
||||
- URL: https://cseweb.ucsd.edu/~daniele/papers/LatticeHash.html
|
||||
16. **Micciancio, D. & Regev, O.** (2007). "Worst-case to average-case reductions based on Gaussian measures." _SIAM Journal on Computing_, 37(1), S. 267–302. Preliminary version in FOCS 2004.
|
||||
- _Verbindungsfaktor Õ(n) für SVP, SIVP, CRP; Einführung der Gauß-Maß-Technik._
|
||||
- URL (Journal): https://epubs.siam.org/doi/10.1137/S0097539705447360
|
||||
- URL (Preprint): https://cims.nyu.edu/~regev/papers/average.pdf
|
||||
17. **Langlois, A. & Stehlé, D.** (2015). "Worst-case to average-case reductions for module lattices." _Designs, Codes and Cryptography_, 75(3), S. 565–599.
|
||||
- _Worst-Case-to-Average-Case-Reduktionen für Module-SIS und Module-LWE._
|
||||
- URL: https://eprint.iacr.org/2012/090.pdf
|
||||
### Learning With Errors (LWE)
|
||||
18. **Regev, O.** (2009). "On lattices, learning with errors, random linear codes, and cryptography." _Journal of the ACM_, 56(6), Artikel 34. Preliminary version in STOC 2005.
|
||||
- _Einführung von LWE; quantenmechanische Reduktion von GapSVP/SIVP auf LWE._
|
||||
- URL (Journal): https://dl.acm.org/doi/10.1145/1568318.1568324
|
||||
- URL (Full paper): https://cims.nyu.edu/~regev/papers/qcrypto.pdf
|
||||
- URL (arXiv, 2024 revision): https://arxiv.org/abs/2401.03703
|
||||
19. **Peikert, C.** (2009). "Public-key cryptosystems from the worst-case shortest vector problem." _Proceedings of the 41st ACM Symposium on Theory of Computing (STOC)_, S. 333–342. ACM.
|
||||
- _Klassische Reduktion von GapSVP auf LWE (für große Moduli)._
|
||||
- URL: https://web.eecs.umich.edu/~cpeikert/pubs/svpcrypto.pdf
|
||||
20. **Brakerski, Z., Langlois, A., Peikert, C., Regev, O. & Stehlé, D.** (2013). "Classical hardness of learning with errors." _Proceedings of the 45th ACM Symposium on Theory of Computing (STOC)_, S. 575–584.
|
||||
- _Klassische Reduktion für polynomielle Moduli via Modulus-Reduktion._
|
||||
|
||||
### Algorithmen für SVP
|
||||
21. **Lenstra, A. K., Lenstra, H. W. Jr. & Lovász, L.** (1982). "Factoring polynomials with rational coefficients." _Mathematische Annalen_, 261, S. 515–534.
|
||||
- _Der LLL-Algorithmus; erster polynomialzeitlicher Gitterbasis-Reduktionsalgorithmus._
|
||||
22. **Schnorr, C.-P.** (1987). "A hierarchy of polynomial time lattice basis reduction algorithms." _Theoretical Computer Science_, 53(2–3), S. 201–224.
|
||||
- _BKZ-Verallgemeinerung von LLL mit verbesserten Approximationsfaktoren._
|
||||
23. **Kannan, R.** (1983). "Improved algorithms for integer programming and related lattice problems." _Proceedings of the 15th ACM Symposium on Theory of Computing (STOC)_, S. 193–206.
|
||||
- _Enumerationsalgorithmus für SVP/CVP mit Laufzeit n^{O(n)}._
|
||||
24. **Ajtai, M., Kumar, R. & Sivakumar, D.** (2001). "A sieve algorithm for the shortest lattice vector problem." _Proceedings of the 33rd ACM Symposium on Theory of Computing (STOC)_, S. 601–610.
|
||||
- _Erster Sieving-Algorithmus; erste 2^{O(n)}-Lösung für SVP._
|
||||
25. **Micciancio, D. & Voulgaris, P.** (2010). "A deterministic single exponential time algorithm for most lattice problems based on Voronoi cell computations." _Proceedings of the 42nd ACM Symposium on Theory of Computing (STOC)_, S. 351–358.
|
||||
- _Deterministischer Õ(4^n)-Algorithmus für SVP und CVP via Voronoi-Zellen._
|
||||
26. **Micciancio, D. & Voulgaris, P.** (2010). "Faster exponential time algorithms for the shortest vector problem." _Proceedings of the 21st ACM-SIAM Symposium on Discrete Algorithms (SODA)_, S. 1468–1480.
|
||||
- _ListSieve und GaussSieve; praktischere Sieving-Varianten._
|
||||
- URL: https://cseweb.ucsd.edu/~daniele/papers/Sieve.pdf
|
||||
27. **Nguyen, P. Q. & Vidick, T.** (2008). "Sieve algorithms for the shortest vector problem are practical." _Journal of Mathematical Cryptology_, 2(2), S. 181–207.
|
||||
- _Heuristische Sieving-Variante mit Laufzeit (4/3+ε)^n; erste praktische Implementierung._
|
||||
- URL: https://people.csail.mit.edu/vidick/JoMC08.pdf
|
||||
28. **Aggarwal, D., Dadush, D., Regev, O. & Stephens-Davidowitz, N.** (2015). "Solving the shortest vector problem in 2^n time via discrete Gaussian sampling." _Proceedings of the 47th ACM Symposium on Theory of Computing (STOC)_, S. 733–742.
|
||||
- _Aktuell schnellster beweisbarer Algorithmus für SVP: 2^{n+o(n)}._
|
||||
29. **Aggarwal, D., Chen, Y., Kumar, R. & Shen, Y.** (2021). "Improved (Provable) Algorithms for the Shortest Vector Problem." _Proceedings of STACS 2021_, LIPIcs vol. 187, Artikel 4.
|
||||
- _Time-Space Tradeoff: Laufzeit q^{O(n)}, Speicher q^{O(n/q²)}._
|
||||
- URL: https://drops.dagstuhl.de/storage/00lipics/lipics-vol187-stacs2021/LIPIcs.STACS.2021.4/LIPIcs.STACS.2021.4.pdf
|
||||
## Surveys und Übersichtsartikel
|
||||
30. **Peikert, C. & Stephens-Davidowitz, N.** (2023). "The Complexity of the Shortest Vector Problem." _ACM SIGACT News_, 54(1).
|
||||
- _Umfassendster aktueller Survey zur Komplexität von SVP._
|
||||
- URL: https://www.cs.umd.edu/~gasarch/open/svp-color.pdf
|
||||
- URL (ACM): https://dl.acm.org/doi/10.1145/3586165.3586172
|
||||
31. **Regev, O.** (2010). "The Learning with Errors Problem (Invited Survey)." _Proceedings of the 25th Annual IEEE Conference on Computational Complexity (CCC)_, S. 191–204.
|
||||
- _Survey über LWE: Definition, Härte, kryptografische Anwendungen._
|
||||
- URL: https://cims.nyu.edu/~regev/papers/lwesurvey.pdf
|
||||
32. **Micciancio, D. & Goldwasser, S.** (2002). _Complexity of Lattice Problems: A Cryptographic Perspective._ Kluwer Academic Publishers, Boston.
|
||||
- _Standardwerk zur Komplexität von Gitterproblemen._
|
||||
33. **Micciancio, D. & Regev, O.** (2009). "Lattice-based cryptography." In: Bernstein, D. J., Buchmann, J. & Dahmen, E. (Hrsg.), _Post-Quantum Cryptography_, S. 147–191. Springer.
|
||||
- _Übersichtskapitel zu gitterbasierter Kryptografie._
|
||||
34. **Cai, J.-Y.** (1999). "Some Recent Progress on the Complexity of Lattice Problems." _Electronic Colloquium on Computational Complexity (ECCC)_, Report No. 6.
|
||||
- _Früher Survey über Ajtais Durchbrüche und Folgearbeiten._
|
||||
- URL: https://eccc.weizmann.ac.il/report/1999/006/download/
|
||||
35. **Micciancio, D.** (2005). "Shortest Vector Problem." In: _Encyclopedia of Cryptography and Security_. Springer.
|
||||
- _Kompakter Enzyklopädie-Eintrag zu SVP._
|
||||
- URL: https://cseweb.ucsd.edu/~daniele/papers/CryptoEncyclopediaSVP.pdf
|
||||
36. **Hanrot, G., Pujol, X. & Stehlé, D.** (2011). "Algorithms for the Shortest and Closest Lattice Vector Problems." In: _Coding and Cryptology_, IWCC 2011, LNCS vol. 6639, S. 159–190. Springer.
|
||||
- _Survey über Algorithmen für SVP und CVP._
|
||||
- URL: https://link.springer.com/chapter/10.1007/978-3-642-20901-7_10
|
||||
37. **Balbás, D.** (2021). "The Hardness of LWE and Ring-LWE: A Survey."
|
||||
- _Detaillierter Survey über LWE-Härteresultate und deren Beweise._
|
||||
- URL: https://eprint.iacr.org/2021/1358.pdf
|
||||
38. **Bogdanov, A. & Trevisan, L.** (2006). "On Worst-Case to Average-Case Reductions for NP Problems." _SIAM Journal on Computing_, 36(4), S. 1119–1159.
|
||||
- _Barrieren gegen allgemeine Worst-Case-to-Average-Case-Reduktionen für NP._
|
||||
- URL: https://lucatrevisan.github.io/pubs/redux-sicomp.pdf
|
||||
39. **Regev, O.** (2004). "On the Complexity of Lattice Problems with Polynomial Approximation Factors." In: _The LLL Algorithm_, Information Security and Cryptography. Springer.
|
||||
- _Übersicht über die Komplexität von Gitterproblemen mit polynomiellen Faktoren._
|
||||
- URL: https://cims.nyu.edu/~regev/papers/lll.pdf
|
||||
## Vorlesungsskripte und Lecture Notes
|
||||
40. **Regev, O.** (2004). "Lattices in Computer Science." Lecture Notes, Tel Aviv University / NYU.
|
||||
- Lecture 7: "GapCVP in coNP" — https://cims.nyu.edu/~regev/teaching/lattices_fall_2004/ln/gg.pdf
|
||||
- Lecture 12: "Average-case Hardness" — https://cims.nyu.edu/~regev/teaching/lattices_fall_2004/ln/averagecase.pdf
|
||||
- Lecture: "The LLL Algorithm" — https://cims.nyu.edu/~regev/teaching/lattices_fall_2004/ln/lll.pdf
|
||||
41. **Vaikuntanathan, V.** (2015). "6.876: Advanced Topics in Cryptography — Lattices." Lecture Notes, MIT.
|
||||
- Lecture 2: "Lattices, Minkowski" — https://people.csail.mit.edu/vinodv/6876-Fall2015/L2.pdf
|
||||
- Lecture 3: "SVP, CVP, Complexity" — https://people.csail.mit.edu/vinodv/6876-Fall2015/L3.pdf
|
||||
- Lecture 7: "Sieving Algorithms" — https://people.csail.mit.edu/vinodv/6876-Fall2015/L7.pdf
|
||||
42. **Vaikuntanathan, V.** (2020). "CS 294: Foundations of Lattice-based Cryptography." Lecture Notes, UC Berkeley.
|
||||
- Lecture 4: "Worst-Case to Average-Case Reduction for LWE" — https://people.csail.mit.edu/vinodv/CS294/lecture4.pdf
|
||||
43. **Peikert, C.** (2013–2015). "CSE 660 / CSE 840: Lattice-based Cryptography." Lecture Notes, University of Michigan.
|
||||
- Lecture 2: "SVP, Gram-Schmidt, Minkowski" — https://web.eecs.umich.edu/~cpeikert/lic13/lec02.pdf
|
||||
- Lecture 3: "The LLL Algorithm" — https://web.eecs.umich.edu/~cpeikert/lic15/lec03.pdf
|
||||
44. **Micciancio, D.** (2012–2017). "CSE 206A: Lattice Algorithms and Applications." Lecture Notes, UC San Diego.
|
||||
- Lecture 2: "Minkowski's theorem" — https://cseweb.ucsd.edu/classes/wi16/cse206A-a/lec2.pdf
|
||||
- Lecture 3: "The LLL Algorithm" — https://cseweb.ucsd.edu/classes/wi12/cse206A-a/lec3.pdf
|
||||
45. **MIT OpenCourseWare** (2009). "18.409: Topics in Theoretical Computer Science — An Algorithmist's Toolkit." Scribe Notes, MIT.
|
||||
- Lecture 19: "Minkowski's theorem, SVP, CVP" — https://ocw.mit.edu/courses/18-409-topics-in-theoretical-computer-science-an-algorithmists-toolkit-fall-2009/08cea721b6c9e44aedcefa080de2ff6e_MIT18_409F09_scribe19.pdf
|
||||
- Lecture 20: "LLL algorithm" — https://ocw.mit.edu/courses/18-409-topics-in-theoretical-computer-science-an-algorithmists-toolkit-fall-2009/eaa6bc3cd49d94630490cfe3227fa5dc_MIT18_409F09_scribe20.pdf
|
||||
## NIST-Standards und Post-Quantum-Kryptografie
|
||||
46. **NIST** (2024). "NIST Releases First 3 Finalized Post-Quantum Encryption Standards." Pressemitteilung, 13. August 2024.
|
||||
- URL: https://www.nist.gov/news-events/news/2024/08/nist-releases-first-3-finalized-post-quantum-encryption-standards
|
||||
47. **NIST** (2024). "Post-Quantum Cryptography FIPS Approved." CSRC, 13. August 2024.
|
||||
- URL: https://csrc.nist.gov/news/2024/postquantum-cryptography-fips-approved
|
||||
48. **NIST** (laufend). "PQC Standardization Process." Computer Security Resource Center.
|
||||
- URL: https://csrc.nist.gov/projects/post-quantum-cryptography/post-quantum-cryptography-standardization
|
||||
49. **NIST** (laufend). "Post-Quantum Cryptography — Übersichtsseite." CSRC.
|
||||
- URL: https://csrc.nist.gov/projects/post-quantum-cryptography
|
||||
50. **Federal Register** (2024). "Announcing Issuance of FIPS 203, FIPS 204, and FIPS 205." Vol. 89, No. 157, 14. August 2024.
|
||||
- URL: https://www.federalregister.gov/documents/2024/08/14/2024-17956/announcing-issuance-of-federal-information-processing-standards-fips-fips-203-module-lattice-based
|
||||
51. **Wikipedia** (laufend). "NIST Post-Quantum Cryptography Standardization."
|
||||
- URL: https://en.wikipedia.org/wiki/NIST_Post-Quantum_Cryptography_Standardization
|
||||
## Weitere Referenzen
|
||||
52. **Dietzfelbinger, M. et al.** (2020). "Formalizing the LLL Basis Reduction Algorithm and the LLL Factorization Algorithm in Isabelle/HOL." _Journal of Automated Reasoning_, 64, S. 1–47. Springer.
|
||||
- URL: https://link.springer.com/article/10.1007/s10817-020-09552-1
|
||||
53. **Voulgaris, P.** (2013). "Algorithms for the Closest and Shortest Vector Problems on General Lattices." Dissertation, UC San Diego.
|
||||
- URL: https://escholarship.org/uc/item/4zt7x45z
|
||||
54. **Jagielski, M.** (2016). "Sieving Algorithms for Lattice Problems." Undergraduate Report, University of Oregon.
|
||||
- URL: https://www.cs.uoregon.edu/Reports/UG-201606-Jagielski.pdf
|
||||
55. **Aggarwal, D., Mukhopadhyay, P. & Stephens-Davidowitz, N.** (2019). "Faster Provable Sieving Algorithms for the Shortest Vector Problem and the Closest Vector Problem." arXiv:1907.04406.
|
||||
- URL: https://arxiv.org/pdf/1907.04406
|
||||
56. **Stephens-Davidowitz, N.** (2018). "Introduction and Minkowski's Theorem." Lecture Notes, Mini-course on Lattices.
|
||||
- URL: http://www.noahsd.com/mini_lattices/01__intro_and_Minkowski.pdf
|
||||
57. **Nguyen, P. Q. & Stehlé, D.** (2014). "Structural Lattice Reduction: Generalized Worst-Case to Average-Case Reductions and Homomorphic Cryptosystems." ePrint 2014/283.
|
||||
- URL: https://eprint.iacr.org/2014/283.pdf
|
||||
58. **Peikert, C., Regev, O. & Stephens-Davidowitz, N.** (2017). "Pseudorandomness of Ring-LWE for Any Ring and Modulus." _Proceedings of the 49th ACM Symposium on Theory of Computing (STOC)_, S. 461–473.
|
||||
59. **Lyubashevsky, V., Peikert, C. & Regev, O.** (2013). "On ideal lattices and learning with errors over rings." _Journal of the ACM_, 60(6), Artikel 43.
|
||||
60. **Peikert, C.** (2016). "A Decade of Lattice Cryptography." _Foundations and Trends in Theoretical Computer Science_, 10(4), S. 283–424.
|
||||
42
Komplexitätstheorie/vortrag/Randbedingungen_Struktur.md
Normal file
42
Komplexitätstheorie/vortrag/Randbedingungen_Struktur.md
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
# Vortrag
|
||||
### Randbedingungen
|
||||
**Thema**: Shortest Vector Problem
|
||||
**Dauer**: 10-15min
|
||||
**Präsi-Software**: RevealJS
|
||||
### Gliederung
|
||||
**1. Einleitung & Motivation (~1–2 min)**
|
||||
- Warum Gitterprobleme? Kurzer Kontext: Post-Quantum-Kryptografie baut auf der _Härte_ von Gitterproblemen auf — SVP ist das zentrale davon.
|
||||
- Ziel des Vortrags: SVP als Problem der Komplexitätstheorie verstehen.
|
||||
|
||||
**2. Grundlagen: Was ist ein Gitter? (~2 min)**
|
||||
- Mathematische Definition (Linearkombinationen über ℤ einer Basis B ∈ ℝⁿˣⁿ)
|
||||
- Anschauliches 2D-Beispiel (Visualisierung Gitterpunkte + Basisvektoren)
|
||||
- Begriffe: Basis, Dimension, kürzester Vektor (Minimum λ₁)
|
||||
|
||||
**3. Problemdefinition: SVP und Varianten (~2 min)**
|
||||
- **Exact SVP**: Finde einen Gittervektor mit Norm = λ₁
|
||||
- **Entscheidungsvariante (GapSVP_γ)**: Gegeben Gitter L und Schwelle d — ist λ₁(L) ≤ d oder λ₁(L) > γ·d? (Promise-Problem!)
|
||||
- Warum die Gap-Variante? → Approximationsfaktor γ ist der Schlüssel zur Komplexitätsanalyse.
|
||||
- Kurzer Hinweis auf verwandte Probleme (CVP — Closest Vector Problem)
|
||||
|
||||
**4. Komplexitätstheoretische Einordnung (~4–5 min)** ← Herzstück
|
||||
- **NP-Härte**: Ajtai (1998) — SVP ist NP-hart unter randomisierten Reduktionen. Micciancio (2001) verschärft das auf bestimmte Approximationsfaktoren.
|
||||
- **GapSVP_γ ∈ NP ∩ coNP** für γ ≥ √n — was bedeutet das? (Zertifikate für JA- und NEIN-Instanzen)
|
||||
- **Nicht bekannt ob NP-vollständig** — warum? (Promise-Problem, keine bekannte deterministische Reduktion)
|
||||
- **Worst-Case zu Average-Case Reduktion** (Ajtai 1996): Einzigartig in der Komplexitätstheorie — wenn man _zufällige_ Instanzen lösen kann, kann man auch _alle_ lösen. Bedeutung für Kryptografie.
|
||||
- Optional: Bezug zur Polynomiellen Hierarchie / Vermutung SVP ∉ P
|
||||
|
||||
**5. Algorithmen & bekannte Schranken (~2 min)**
|
||||
- **LLL-Algorithmus** (Lenstra, Lenstra, Lovász 1982): Polynomialzeit, aber nur Approximation mit exponentiell großem γ = 2^(n/2)
|
||||
- **Exakte Algorithmen**: Enumeration (superexponentiell), Sieving (2^O(n)) — kein bekannter Polynomialzeit-Algorithmus
|
||||
- Einordnung: Die Lücke zwischen „effizient approximierbar" und „exakt hart" spiegelt die Komplexitätslandschaft wider.
|
||||
|
||||
**6. Bedeutung für Post-Quantum-Kryptografie (~1–2 min)**
|
||||
- NIST-Standards (Kyber/ML-KEM, Dilithium/ML-DSA) basieren auf Gitterproblemen (LWE → verwandt mit GapSVP)
|
||||
- Sicherheitsannahme: GapSVP ist für kleine γ auch für Quantencomputer hart
|
||||
- Verbindung zurück zur Komplexitätstheorie: Worst-Case-Härte als Fundament kryptografischer Sicherheit
|
||||
|
||||
**7. Zusammenfassung & offene Fragen (~1 min)**
|
||||
- SVP: eines der seltenen Probleme mit Worst-Case-to-Average-Case-Reduktion
|
||||
- Offene Fragen: Exakte Komplexität von SVP? Optimale Approximationsgrenzen? Quantenalgorithmen?
|
||||
|
||||
512
Komplexitätstheorie/vortrag/Recherche.md
Normal file
512
Komplexitätstheorie/vortrag/Recherche.md
Normal file
|
|
@ -0,0 +1,512 @@
|
|||
# Das Shortest Vector Problem (SVP) — Ausführliche Recherche für den Komplexitätstheorie-Vortrag
|
||||
|
||||
---
|
||||
## 1. Einleitung & Motivation
|
||||
|
||||
### Warum Gitterprobleme?
|
||||
|
||||
Gitter (Lattices) sind geometrische Objekte, die als die Menge aller Schnittpunkte eines unendlichen, regelmäßigen (aber nicht notwendigerweise orthogonalen) n-dimensionalen Gitters beschrieben werden können. Sie spielen eine zentrale Rolle in zahlreichen Bereichen der Informatik und Mathematik: ganzzahlige Programmierung, Codierungstheorie, Kryptoanalyse und insbesondere der Entwurf sicherer Kryptosysteme. Historisch reicht die Beschäftigung mit Gittern bis ins 19. Jahrhundert zurück — Gauß gab bereits einen Algorithmus an, um den kürzesten Vektor in einem zweidimensionalen Gitter zu finden.
|
||||
|
||||
Das **Shortest Vector Problem (SVP)** ist das wichtigste und am intensivsten untersuchte Berechnungsproblem auf Gittern. Es fragt: Gegeben eine Basis eines Gitters, finde den kürzesten Nicht-Null-Vektor. Diese scheinbar einfache geometrische Frage entpuppt sich als eines der reichhaltigsten Probleme der Komplexitätstheorie — mit Verbindungen zu NP-Härte, interaktiven Beweisen, Quanteninformatik und kryptografischer Sicherheit.
|
||||
|
||||
### Warum SVP in der Komplexitätstheorie besonders ist
|
||||
|
||||
SVP nimmt eine **einzigartige Stellung** in der Komplexitätstheorie ein:
|
||||
|
||||
**1. Worst-Case-to-Average-Case-Reduktion:** Im Gegensatz zu fast allen anderen NP-harten Problemen (SAT, Graph Coloring, Traveling Salesman) gibt es für Gitterprobleme eine beweisbare Reduktion von der Worst-Case-Härte auf die Average-Case-Härte. Das bedeutet: Wenn man _zufällige_ Instanzen lösen kann, kann man _jede_ Instanz lösen. Für SAT zum Beispiel sind zufällige Instanzen oft leicht lösbar, obwohl das Worst-Case-Problem NP-vollständig ist. Bogdanov und Trevisan haben sogar gezeigt, dass unter bestimmten Annahmen eine solche Verbindung für allgemeine NP-Probleme relativ zu einem Orakel unmöglich ist. Gitterprobleme sind daher in dieser Hinsicht wirklich einzigartig.
|
||||
|
||||
**2. Feine Komplexitätsstruktur:** Die Komplexität von SVP variiert stark mit dem Approximationsfaktor γ. Für kleine γ ist das Problem NP-hart, für große γ liegt es in NP ∩ coNP — und dazwischen liegt eine noch nicht vollständig verstandene Übergangszone. Diese „Komplexitätslandschaft" ist deutlich reicher als bei typischen NP-vollständigen Problemen.
|
||||
|
||||
**3. Post-Quantum-Kryptografie:** Die Sicherheit der neuen NIST-Standards (ML-KEM/Kyber, ML-DSA/Dilithium), die im August 2024 veröffentlicht wurden, basiert letztlich auf der Annahme, dass bestimmte Gitterprobleme auch für Quantencomputer schwer bleiben. Im Gegensatz zu RSA und elliptischen Kurven, die durch Shors Algorithmus gebrochen werden können, gibt es keinen bekannten Quantenvorteil für SVP.
|
||||
|
||||
**Quellen:**
|
||||
|
||||
- Micciancio: "The Shortest Vector in a Lattice is Hard to Approximate" — https://cseweb.ucsd.edu/~daniele/papers/SVP.pdf
|
||||
- Peikert/Stephens-Davidowitz: "The Complexity of the Shortest Vector Problem" — https://www.cs.umd.edu/~gasarch/open/svp-color.pdf
|
||||
- Cai: "Some Recent Progress on the Complexity of Lattice Problems" — https://eccc.weizmann.ac.il/report/1999/006/download/
|
||||
- Bogdanov & Trevisan: "On Worst-Case to Average-Case Reductions for NP Problems" — https://lucatrevisan.github.io/pubs/redux-sicomp.pdf
|
||||
- NIST: Post-Quantum Encryption Standards — https://www.nist.gov/news-events/news/2024/08/nist-releases-first-3-finalized-post-quantum-encryption-standards
|
||||
|
||||
---
|
||||
|
||||
## 2. Grundlagen: Was ist ein Gitter?
|
||||
|
||||
### 2.1 Mathematische Definition
|
||||
|
||||
Ein **Gitter** L ist eine diskrete additive Untergruppe von ℝⁿ. Äquivalent dazu kann man ein Gitter als die Menge aller ganzzahligen Linearkombinationen von n linear unabhängigen Vektoren b₁, ..., bₙ ∈ ℝⁿ definieren:
|
||||
|
||||
L = L(B) = { Σᵢ zᵢbᵢ | zᵢ ∈ ℤ } = { Bx | x ∈ ℤⁿ }
|
||||
|
||||
Die Matrix B := (b₁, ..., bₙ) ∈ ℝⁿˣⁿ heißt **Basis** von L. Der Wert n ist die **Dimension** des Gitters.
|
||||
|
||||
**Anschaulich in 2D:** Man stelle sich ein Blatt kariertes Papier vor, das schief gedruckt ist — die Gitterpunkte sind die Ecken der verzerrten „Kästchen". Die zwei Seitenvektoren eines Kästchens bilden eine Basis. Ein Standard-Koordinatensystem mit Achsen im rechten Winkel ist das einfachste Gitter (ℤ²), aber im Allgemeinen stehen die Basisvektoren nicht senkrecht aufeinander.
|
||||
|
||||
### 2.2 Basen sind nicht eindeutig
|
||||
|
||||
Ein fundamentaler Unterschied zur linearen Algebra über Körpern: Ein Gitter hat **viele verschiedene Basen**. Zwei Basen B und B' erzeugen genau dann dasselbe Gitter, wenn eine unimodulare Matrix U (ganzzahlige Matrix mit det(U) = ±1) existiert, sodass B' = BU. Da die Ganzzahligkeitsbedingung erhalten bleiben muss, ist der Basiswechsel bei Gittern deutlich rigider als bei Vektorräumen — man kann im Allgemeinen **keine orthonormale Basis** finden.
|
||||
|
||||
Diese Nicht-Eindeutigkeit ist sowohl Segen als auch Fluch: Eine „gute" (kurze, fast orthogonale) Basis kann Probleme leicht lösbar machen, während eine „schlechte" (lange, fast parallele Vektoren) Basis das Problem extrem schwer erscheinen lässt. Dies ist genau die Grundidee der gitterbasierten Kryptografie — der öffentliche Schlüssel ist eine „schlechte" Basis, der private Schlüssel eine „gute" Basis desselben Gitters.
|
||||
|
||||
### 2.3 Determinante und Fundamentalparallelotop
|
||||
|
||||
Das **Fundamentalparallelotop** einer Basis B ist definiert als P(B) = { Bx | x ∈ [0,1)ⁿ }. Es ist die fundamentale Wiederholungseinheit, die den gesamten Raum durch Verschiebung um Gittervektoren parkettiert — ähnlich wie ein einzelnes Kästchen das karierte Papier erzeugt.
|
||||
|
||||
Die **Determinante** (oder das **Kovolumen**) des Gitters ist det(L) = |det(B)| = Vol(P(B)). Eine entscheidende Eigenschaft: Die Determinante ist **basisunabhängig** — verschiedene Basen desselben Gitters liefern stets denselben Wert. Intuitiv misst die Determinante die „Dichte" des Gitters: Je kleiner det(L), desto dichter liegen die Gitterpunkte, und desto kürzer muss der kürzeste Vektor sein. Je größer det(L), desto „dünner" ist das Gitter und desto weiter können die Punkte auseinander liegen.
|
||||
|
||||
### 2.4 Kürzester Vektor und sukzessive Minima
|
||||
|
||||
Die Länge des kürzesten Nicht-Null-Vektors im Gitter wird als **erstes Minimum** λ₁(L) bezeichnet:
|
||||
|
||||
λ₁(L) = min { ‖v‖ : v ∈ L, v ≠ 0 }
|
||||
|
||||
Allgemeiner definiert man die **sukzessiven Minima** λ₁(L) ≤ λ₂(L) ≤ ... ≤ λₙ(L), wobei λᵢ die kleinste Zahl r ist, sodass die abgeschlossene Kugel B(0,r) mindestens i linear unabhängige Gittervektoren enthält. Die sukzessiven Minima liefern detaillierte Informationen über die geometrische Struktur des Gitters.
|
||||
|
||||
**Beispiel:** Für das Gitter erzeugt von (1,0) und (0,3) in ℝ² ist λ₁ = 1 (der Vektor (1,0)) und λ₂ = 3 (der Vektor (0,3)). Beachte, dass der Vektor (2,0), obwohl er kürzer als (0,3) ist, nicht zählt, da er linear abhängig von (1,0) ist.
|
||||
|
||||
### 2.5 Minkowskis erster Satz
|
||||
|
||||
Ein Eckpfeiler der Geometrie der Zahlen ist **Minkowskis Konvexkörper-Theorem** (1889), das eine obere Schranke für den kürzesten Vektor liefert:
|
||||
|
||||
> **Minkowskis Konvexkörper-Satz:** Sei L ein n-dimensionales Vollrang-Gitter und S ⊂ ℝⁿ ein konvexer, bezüglich des Ursprungs symmetrischer Körper mit Vol(S) > 2ⁿ · det(L). Dann enthält S einen Nicht-Null-Gitterpunkt.
|
||||
|
||||
**Beweisskizze (über Blichfeldts Lemma):**
|
||||
|
||||
1. Betrachte die Menge S/2 = {x : 2x ∈ S}. Da Vol(S/2) = 2⁻ⁿ Vol(S) > det(L), folgt aus dem Satz von Blichfeldt (jede Menge mit Volumen > det(L) enthält zwei Punkte, deren Differenz ein Gittervektor ist): Es existieren z₁, z₂ ∈ S/2 mit z₁ ≠ z₂ und z₁ − z₂ ∈ L \ {0}.
|
||||
2. Da 2z₁, 2z₂ ∈ S und S symmetrisch ist, gilt auch −2z₂ ∈ S.
|
||||
3. Wegen Konvexität: z₁ − z₂ = (2z₁ + (−2z₂))/2 ∈ S.
|
||||
4. Also ist z₁ − z₂ ein Nicht-Null-Gittervektor in S.
|
||||
|
||||
**Korollar — Schranke für den kürzesten Vektor:** Wendet man den Satz auf die euklidische Kugel B(0, r) an und wählt r so, dass Vol(B(0,r)) = 2ⁿ · det(L), erhält man:
|
||||
|
||||
λ₁(L) ≤ √n · det(L)^{1/n}
|
||||
|
||||
Diese Schranke garantiert die **Existenz** kurzer Vektoren — sie sagt, dass in jedem n-dimensionalen Gitter mindestens ein Nicht-Null-Vektor existiert, der kürzer als √n · det(L)^{1/n} ist. Aber sie sagt nichts darüber aus, wie man diesen Vektor **findet** — und genau diese algorithmische Frage führt zum SVP. Das Finden des durch Minkowski garantierten Vektors wird manchmal als Minkowski's Vector Problem (MVP) bezeichnet und ist eng mit SVP verwandt.
|
||||
|
||||
### 2.6 Gram-Schmidt-Orthogonalisierung als untere Schranke
|
||||
|
||||
Die Gram-Schmidt-Orthogonalisierung b̃₁, ..., b̃ₙ einer Basis B liefert eine wichtige **untere Schranke** für die Minimum-Distanz:
|
||||
|
||||
λ₁(L) ≥ minᵢ ‖b̃ᵢ‖
|
||||
|
||||
**Beweis (Intuition für 2D):** Man kann die Gitterpunkte v = Bz in „Schichten" gemäß dem Koeffizienten z₂ von b₂ einteilen. Wenn z₂ = 0, dann ist v ein Vielfaches von b₁, also ‖v‖ ≥ ‖b₁‖ = ‖b̃₁‖. Wenn z₂ ≠ 0, hat v eine Komponente in Richtung b̃₂ (orthogonal zu b₁), und diese Komponente hat Länge mindestens |z₂| · ‖b̃₂‖ ≥ ‖b̃₂‖. Also ist ‖v‖ ≥ min(‖b̃₁‖, ‖b̃₂‖). Per Induktion über die Dimension folgt die allgemeine Aussage.
|
||||
|
||||
Diese Schranke ist effizient berechenbar und bildet den konzeptuellen Ausgangspunkt des LLL-Algorithmus: Die Idee ist, eine Basis zu finden, deren Gram-Schmidt-Vektoren möglichst lang und „ausgeglichen" sind — denn dann ist die untere Schranke möglichst nah am tatsächlichen λ₁.
|
||||
|
||||
**Quellen:**
|
||||
|
||||
- Peikert: Lecture Notes "SVP" (U. Michigan) — https://web.eecs.umich.edu/~cpeikert/lic13/lec02.pdf
|
||||
- MIT OCW: "Minkowski's theorem, shortest/closest vector problem" — https://ocw.mit.edu/courses/18-409-topics-in-theoretical-computer-science-an-algorithmists-toolkit-fall-2009/08cea721b6c9e44aedcefa080de2ff6e_MIT18_409F09_scribe19.pdf
|
||||
- Micciancio: CSE 206A Lecture 2 — https://cseweb.ucsd.edu/classes/wi16/cse206A-a/lec2.pdf
|
||||
- Vaikuntanathan: Lecture 2, 6.876 (MIT, 2015) — https://people.csail.mit.edu/vinodv/6876-Fall2015/L2.pdf
|
||||
- Stephens-Davidowitz: "Introduction and Minkowski's Theorem" — http://www.noahsd.com/mini_lattices/01__intro_and_Minkowski.pdf
|
||||
- Wikipedia: Minkowski's theorem — https://en.wikipedia.org/wiki/Minkowski's_theorem
|
||||
|
||||
---
|
||||
|
||||
## 3. Problemdefinition: SVP und Varianten
|
||||
|
||||
### 3.1 Exaktes SVP (Search-Version)
|
||||
|
||||
Gegeben eine Basis B ∈ ℚⁿˣⁿ eines Gitters L, finde einen Nicht-Null-Vektor v ∈ L mit ‖v‖ = λ₁(L).
|
||||
|
||||
Das Problem kann bezüglich jeder Norm definiert werden, aber die **euklidische Norm** (ℓ₂) ist die gebräuchlichste. Die Wahl der Norm hat allerdings signifikante Auswirkungen auf die Komplexität: Für die Uniform-Norm (ℓ∞) ist SVP seit van Emde Boas (1981) als NP-hart bekannt, während die NP-Härte für ℓ₂ erst 1998 durch Ajtai bewiesen wurde und zudem nur unter randomisierten Reduktionen gilt.
|
||||
|
||||
Eine **Besonderheit** des SVP ist, dass sogar die Berechnung der _Länge_ des kürzesten Vektors (ohne den Vektor selbst zu finden) als schwer gilt. In der Komplexitätstheorie wird oft diese reine Längenberechnung studiert, da die Entscheidungsversion für formale Komplexitätsaussagen besser geeignet ist.
|
||||
|
||||
### 3.2 γ-Approximate SVP und GapSVP
|
||||
|
||||
Da das exakte SVP vermutlich sehr schwer ist, untersucht man Approximationsversionen. Für einen Approximationsfaktor γ = γ(n) ≥ 1 (typischerweise eine monoton wachsende Funktion der Dimension) gibt es drei Varianten:
|
||||
|
||||
**1. Entscheidungsversion (GapSVP_γ) — „Gap"-Version:** Gegeben eine Gitterbasis B und ein positives d, unterscheide:
|
||||
|
||||
- **YES-Instanz:** λ₁(L(B)) ≤ d (der kürzeste Vektor ist kurz)
|
||||
- **NO-Instanz:** λ₁(L(B)) > γ · d (der kürzeste Vektor ist lang)
|
||||
|
||||
Dies ist ein **Promise-Problem**: Für Instanzen, bei denen d < λ₁(L(B)) ≤ γ·d, ist jede Antwort akzeptabel. Der Algorithmus muss also nur „klare" Fälle korrekt entscheiden — die Grauzone dazwischen darf beliebig beantwortet werden. Diese Promise-Struktur hat wichtige technische Konsequenzen: GapSVP ist kein gewöhnliches Entscheidungsproblem im Sinne einer Sprache L ⊆ {0,1}*, und die üblichen Definitionen von NP-Vollständigkeit und Reduktionen müssen sorgfältig angepasst werden.
|
||||
|
||||
**2. Schätzversion (EstSVP_γ):** Gegeben eine Gitterbasis B, berechne λ₁(L(B)) bis auf einen Faktor γ, d.h. gib einen Wert r aus mit λ₁ ≤ r ≤ γ · λ₁.
|
||||
|
||||
**3. Suchversion (SVP_γ):** Gegeben eine Gitterbasis B, finde einen Nicht-Null-Vektor v ∈ L(B) mit ‖v‖ ≤ γ · λ₁(L(B)).
|
||||
|
||||
**Wichtige Beobachtungen:**
|
||||
|
||||
- Für γ = 1 ergeben sich die exakten Versionen.
|
||||
- Die Probleme werden **strikt leichter** mit wachsendem γ: GapSVP_{γ'} ≤ GapSVP_γ für γ' ≥ γ (die bessere Approximation reduziert sich auf die schlechtere — nicht umgekehrt!).
|
||||
- Es ist ein **wichtiges offenes Problem**, ob SVP_γ auf GapSVP_γ reduzierbar ist für nicht-triviales γ > 1. Für den exakten Fall (γ = 1) existiert eine einfache Reduktion über Binärsuche, aber die Verallgemeinerung auf approximative Versionen ist offen.
|
||||
|
||||
### 3.3 Verwandtes Problem: CVP (Closest Vector Problem)
|
||||
|
||||
Das **Closest Vector Problem (CVP)** fragt: Gegeben eine Gitterbasis B und einen Zielvektor t ∈ ℚⁿ, finde den nächsten Gittervektor zu t.
|
||||
|
||||
CVP gilt als mindestens so schwer wie SVP — es gibt eine einfache, approximationsfaktor-erhaltende Reduktion von SVP auf CVP: Für eine Gitterbasis B = [b₁,...,bₙ] definiere für jedes i das modifizierte Gitter Lᵢ = L(b₁,...,bᵢ₋₁, 2bᵢ, bᵢ₊₁,...,bₙ). Dann gilt: Wenn v = Σ cⱼbⱼ der kürzeste Vektor in L ist, muss mindestens ein cⱼ ungerade sein (sonst wäre v/2 ein kürzerer Gittervektor). Für dieses j ist v + bⱼ der nächste Vektor zu bⱼ im Gitter Lⱼ, und ‖(v + bⱼ) − bⱼ‖ = ‖v‖ = λ₁. Also findet man den kürzesten Vektor, indem man n CVP-Instanzen löst und die kürzeste Differenz nimmt.
|
||||
|
||||
Diese Reduktion zeigt: CVP ist mindestens so schwer wie SVP. Umgekehrt ist nicht bekannt, ob SVP mindestens so schwer wie CVP ist — tatsächlich ist CVP in gewissem Sinne das „natürlich schwerere" Problem.
|
||||
|
||||
**Quellen:**
|
||||
|
||||
- Wikipedia: Lattice problem — https://en.wikipedia.org/wiki/Lattice_problem
|
||||
- Peikert: Lecture Notes — https://web.eecs.umich.edu/~cpeikert/lic13/lec02.pdf
|
||||
- Micciancio: CSE 206A Lecture 2 (2014) — https://cseweb.ucsd.edu/classes/sp14/cse206A-a/lec2.pdf
|
||||
- Vaikuntanathan: Lecture 3, 6.876 (MIT, 2015) — https://people.csail.mit.edu/vinodv/6876-Fall2015/L3.pdf
|
||||
|
||||
---
|
||||
|
||||
## 4. Komplexitätstheoretische Einordnung ★
|
||||
|
||||
Dies ist das Herzstück des Vortrags.
|
||||
|
||||
### 4.1 NP-Härte von SVP
|
||||
|
||||
#### Frühe Ergebnisse: ℓ∞-Norm
|
||||
|
||||
Die erste NP-Härte für SVP wurde von **van Emde Boas (1981)** für die Uniform-Norm (ℓ∞) gezeigt, wobei ‖x‖∞ = maxᵢ |xᵢ|. Dieses Ergebnis nutzt eine direkte Reduktion und gilt unter deterministischen Reduktionen.
|
||||
|
||||
#### Ajtais Durchbruch (1998): ℓ₂-Norm
|
||||
|
||||
Für die kryptografisch relevantere **euklidische Norm** (ℓ₂) blieb die NP-Härte über 15 Jahre lang offen. **Ajtai (1998)** bewies schließlich, dass das exakte SVP in ℓ₂ NP-hart ist, aber mit einem entscheidenden Caveat: Die Reduktion ist **randomisiert**.
|
||||
|
||||
Die Randomisierung ist hier kein technisches Artefakt. In Ajtais Beweis wird eine SAT-Instanz in eine Gitterinstanz transformiert, wobei die Konstruktion zufällige Wahlen trifft, um ein Gitter mit bestimmten geometrischen Eigenschaften zu erzeugen. Die Konstruktion funktioniert mit hoher Wahrscheinlichkeit (über die Zufallswahlen), aber nicht deterministisch. Es bleibt eine **offene Frage** (seit über 25 Jahren!), ob SVP in ℓ₂ unter deterministischen Reduktionen NP-hart ist.
|
||||
|
||||
#### Härte der Approximation: Micciancio (2001)
|
||||
|
||||
**Micciancio (2001)** verschärfte Ajtais Ergebnis erheblich: Die Approximation von SVP bis auf jeden **konstanten Faktor** γ ist NP-hart unter randomisierten Reduktionen. Genauer: γ-SVP liegt nicht in RP, es sei denn NP = RP.
|
||||
|
||||
Die zentrale Technik ist eine alternative Konstruktion von Ajtais Variante des Sauer-Lemmas, die den Originalbeweis stark vereinfacht. Der Beweis konstruiert ein „lokal dichtes" Gitter — ein Gitter, das in einer bestimmten Region viel dichter ist als die globale Dichte vermuten lässt. Die NP-harte Eigenschaft ist dann, diese lokal dichte Region zu finden.
|
||||
|
||||
Unter einer zusätzlichen zahlentheoretischen Vermutung (über die Verteilung quadratfreier glatter Zahlen) konnte Micciancio sogar eine echte NP-Härte unter deterministischen Many-One-Reduktionen zeigen.
|
||||
|
||||
#### Weitere Verbesserungen
|
||||
|
||||
- **Haviv & Regev (2007):** Nutzten Tensor-Produkte zur „Verstärkung" der Härte (Hardness Amplification). Tensor-Produkte erlauben es, die Approximationslücke zu vergrößern.
|
||||
- **Dinur (2002):** Zeigte NP-Härte für fast-polynomielle Faktoren γ = n^{c/log log n} unter der Annahme NP ⊄ RSUBEXP.
|
||||
|
||||
**Zusammenfassung:**
|
||||
|
||||
|Faktor γ|Ergebnis|Annahme|Referenz|
|
||||
|---|---|---|---|
|
||||
|1 (exakt)|NP-hart|Randomisierte Reduktion|Ajtai 1998|
|
||||
|Jede Konstante|NP-hart|NP ≠ RP|Micciancio 2001|
|
||||
|2^{(log n)^{1-ε}}|NP-hart|NP ⊄ RTIME(2^{poly(log n)})|Khot 2005|
|
||||
|n^{c/log log n}|NP-hart|NP ⊄ RSUBEXP|Haviv/Regev 2007|
|
||||
|
||||
### 4.2 GapSVP in NP ∩ coNP: Obere Schranken
|
||||
|
||||
Die vielleicht überraschendste Facette der SVP-Komplexität: Für hinreichend große Approximationsfaktoren liegt GapSVP in erstaunlich niedrigen Komplexitätsklassen.
|
||||
|
||||
#### Die NP-Seite (trivial)
|
||||
|
||||
Dass GapSVP_γ ∈ NP liegt, ist für jedes γ ≥ 1 einfach: Ein kurzer Gittervektor v mit ‖v‖ ≤ d dient als polynomiell verifizierbar Zeuge für eine YES-Instanz. Der Verifizierer prüft: (a) v ≠ 0, (b) v ∈ L(B) (durch Lösen von Bx = v über ℤ), (c) ‖v‖ ≤ d. Da ‖v‖ ≤ d, ist die Bitlänge von v polynomiell beschränkt.
|
||||
|
||||
#### Die coNP-Seite (schwierig und überraschend)
|
||||
|
||||
Die Frage „Wie beweist man, dass ein Gitter **keinen** kurzen Vektor hat?" ist viel subtiler. Schließlich gibt es exponentiell viele Gittervektoren, die potenziell kurz sein könnten — wie kann man alle gleichzeitig ausschließen? Man braucht einen einzelnen, polynomiell langen Zeugen, der den Verifizierer davon überzeugt, dass kein kurzer Vektor existiert.
|
||||
|
||||
**Historische Entwicklung:**
|
||||
|
||||
**Lagarias, Lenstra & Schnorr (1990):** GapSVP_{n^{1.5}} ∈ coNP. Die Technik nutzt das **duale Gitter** L* = {u ∈ ℝⁿ : ⟨u,v⟩ ∈ ℤ für alle v ∈ L}. Sogenannte Transference-Theoreme verbinden die Minimum-Distanz eines Gitters mit der seines Duals: Wenn das duale Gitter viele kurze Vektoren hat, dann hat das ursprüngliche Gitter keinen kurzen Vektor.
|
||||
|
||||
**Banaszczyk (1993):** Verbesserung auf GapSVP_n ∈ coNP durch schärfere Transference-Bounds. Banaszcyks Resultate nutzen tiefe Ergebnisse aus der Geometrie der Zahlen.
|
||||
|
||||
**Goldreich & Goldwasser (2000):** Ein anderer Ansatz — GapSVP_{O(√(n/log n))} ∈ **coAM** (Komplement von Arthur-Merlin). Hierbei wird ein interaktives Protokoll verwendet: Der allmächtige Beweiser (Prover) überzeugt den computatorisch beschränkten Verifizierer (Arthur) davon, dass ein Punkt weit vom Gitter entfernt ist. Der Verifizierer wirft eine Münze und stellt dem Beweiser eine Aufgabe, die nur lösbar ist, wenn der kürzeste Vektor tatsächlich lang ist. Die coAM-Containment hat die Implikation, dass GapSVP für diesen Faktor vermutlich nicht NP-hart ist (da NP ⊆ coAM den Kollaps der polynomiellen Hierarchie implizieren würde).
|
||||
|
||||
**Aharonov & Regev (2005) — Der entscheidende Durchbruch:**
|
||||
|
||||
> **Theorem:** GapSVP_{c√n} ∈ NP ∩ coNP für eine Konstante c > 0.
|
||||
|
||||
Dieses Ergebnis verdient besondere Aufmerksamkeit:
|
||||
|
||||
**Der coNP-Zeuge** besteht aus einer Liste von N = n^{4ℓ} Vektoren w₁, ..., wₙ aus dem dualen Gitter (ℓ ist ein Polynomialzeit-berechenbarer Parameter). Diese Vektoren definieren eine Funktion f_W : ℝⁿ → [0,1], die als „Periodizitätsdetektor" fungiert — sie misst, wie „periodisch" ein Punkt bezüglich des Gitters ist. Der Verifizierer führt drei Tests durch:
|
||||
|
||||
- **Periodizitätstest:** f_W muss periodisch über L sein (d.h. f_W(x) = f_W(x + v) für alle v ∈ L).
|
||||
- **Glatttest:** f_W darf nur wenig um ihren Mittelwert schwanken.
|
||||
- **Punkttest:** f_W muss am Ursprung einen hohen Wert haben.
|
||||
|
||||
Für NO-Instanzen (kürzester Vektor ist lang ≥ γd) kann ein Zeuge konstruiert werden, der alle drei Tests besteht. Für YES-Instanzen (kurzer Vektor existiert) schlägt mindestens ein Test fehl, weil ein kurzer Gittervektor die Periodizitätsstruktur stört.
|
||||
|
||||
**Historischer Kontext — von Quanten zu Klassisch:** Dieses Ergebnis entstand auf einem ungewöhnlichen Weg. Aharonov und Regev zeigten zunächst **2003**, dass coGapSVP_{√n} ∈ **QMA** liegt (QMA = Quantum Merlin-Arthur, die Quantenversion von NP). Der Quantenzeuge bestand aus einer Überlagerung von Zuständen, die Informationen über die Gitterstruktur kodieren. Erst danach fanden die Autoren den Weg, den Quantenzeugen durch einen rein klassischen Zeugen zu ersetzen — ein Prozess, den sie als „Dequantisierung" bezeichneten. Dieser ungewöhnliche Weg „von quantenmechanisch zu klassisch" ist selbst ein methodisch interessantes Ergebnis. Die Technik basiert auf einer **Fourier-Approximation** von Funktionen über das Gitter — Funktionen auf ℝⁿ, die über L periodisch sind, können durch ihre Fourier-Koeffizienten (die auf dem dualen Gitter leben) sukzessiv approximiert werden.
|
||||
|
||||
### 4.3 Implikationen für die Polynomielle Hierarchie
|
||||
|
||||
Da GapSVP_{O(√n)} in NP ∩ coNP liegt, hat dies weitreichende Konsequenzen:
|
||||
|
||||
> **Theorem:** Wenn GapSVP_γ für γ ≥ c·√n NP-hart ist (selbst unter Cook-Reduktionen), dann kollabiert die polynomielle Hierarchie: NP ⊆ coNP.
|
||||
|
||||
Der Beweis erfordert Sorgfalt, da GapSVP ein Promise-Problem ist. Für „totale" Probleme (gewöhnliche Sprachen) ist die Argumentation „Problem in NP ∩ coNP und NP-hart ⟹ NP = coNP" Standard. Für Promise-Probleme müssen zusätzliche Argumente gemacht werden — Aharonov und Regev zeigten, wie man die MAYBE-Instanzen (die weder YES noch NO sind) sorgfältig behandelt.
|
||||
|
||||
**Was das praktisch bedeutet — die Komplexitätslücke:**
|
||||
|
||||
```
|
||||
γ = 1 γ ≈ n^{c/lll} γ ≈ √n γ ≈ 2^{O(n)}
|
||||
| | | |
|
||||
NP-hart NP-hart NP ∩ coNP in P (LLL)
|
||||
|←——————————————————→|←———— ??? ————→|←—————————————————→|
|
||||
bekannt schwer Terra incognita vermutlich nicht leicht
|
||||
NP-hart
|
||||
```
|
||||
|
||||
Die genaue Grenze, an der die Härte „kippt", ist eine der großen offenen Fragen. Liegt sie bei γ = n^ε? Bei γ = √n / polylog(n)? Niemand weiß es.
|
||||
|
||||
### 4.4 Worst-Case zu Average-Case Reduktion
|
||||
|
||||
Dies ist das vielleicht bemerkenswerteste Strukturergebnis und ein Alleinstellungsmerkmal von Gitterproblemen.
|
||||
|
||||
#### Ajtais Entdeckung (1996)
|
||||
|
||||
**Ajtai** entdeckte 1996 eine erstaunliche Verbindung:
|
||||
|
||||
> **Ajtais Theorem (informell):** Wenn es einen effizienten Algorithmus gibt, der das **Short Integer Solution (SIS)** Problem für zufällig gewählte Instanzen mit nicht-vernachlässigbarer Wahrscheinlichkeit löst, dann gibt es einen effizienten Algorithmus, der _jede beliebige_ Instanz des approximativen SVP (und verwandter Probleme) löst.
|
||||
|
||||
Das **SIS-Problem:** Gegeben eine zufällig gewählte Matrix A ∈ ℤ_q^{n×m}, finde einen kurzen Nicht-Null-Vektor z ∈ ℤ^m mit Az = 0 mod q. Dieses Problem kann auch als „Finden von Kollisionen in einer generalized Subset-Sum-Funktion" interpretiert werden.
|
||||
|
||||
#### Warum ist das so spektakulär?
|
||||
|
||||
Für die meisten NP-harten Probleme gibt es **keine** solche Verbindung und es wird allgemein angenommen, dass es keine geben kann:
|
||||
|
||||
- **SAT:** NP-vollständig im Worst-Case, aber zufällige SAT-Instanzen sind (für geeignete Klausel-zu-Variablen-Verhältnisse) oft leicht. Bogdanov und Trevisan zeigten starke Barrieren gegen generelle Worst-Case-to-Average-Case-Reduktionen für NP-Probleme.
|
||||
- **Faktorisierung:** RSA-Sicherheit basiert auf der _Average-Case_-Annahme „Faktorisieren zufällig gewählter Zahlen ist schwer", aber es gibt keine bekannte Reduktion vom Worst-Case.
|
||||
- **Permanent:** Hier gibt es eine Worst-Case-to-Average-Case-Verbindung (Lipton 1991), aber der Permanent ist vermutlich nicht in NP.
|
||||
|
||||
Für Gitterprobleme ist die Situation fundamental anders: Wenn jemand einen Algorithmus findet, der SIS für zufällige Instanzen effizient löst, dann kann man damit _jede beliebige_ Worst-Case-Instanz des approximativen SVP lösen. Für die Kryptografie bedeutet das: Die Sicherheit basiert nicht auf einer „hoffentlich schwierigen" Annahme über typische Instanzen, sondern auf der **Worst-Case-Schwierigkeit** eines gut untersuchten mathematischen Problems.
|
||||
|
||||
#### Verbesserungen des Verbindungsfaktors
|
||||
|
||||
Der „Verbindungsfaktor" γ wurde über die Jahre schrittweise verbessert:
|
||||
|
||||
|Referenz|Verbindungsfaktor γ|
|
||||
|---|---|
|
||||
|Ajtai (1996)|> n⁸ (von Cai geschätzt)|
|
||||
|Cai & Nerurkar (1997)|n^{4+ε}|
|
||||
|Micciancio (2004)|n³ · ω(√(log n · log log n))|
|
||||
|**Micciancio & Regev (2007)**|**Õ(n)** — fast linear!|
|
||||
|
||||
Das Ergebnis von **Micciancio und Regev** ist besonders bedeutsam: Der Verbindungsfaktor Õ(n) gilt für SVP, SIVP, CRP und BDD gleichzeitig. Die Hauptwerkzeuge sind **Gauß-Verteilungen über Gittern** und die hochdimensionale **Fourier-Transformation**. Sie definieren einen neuen Gitterparameter (den „Smoothing-Parameter"), der bestimmt, wie viel Gaußsches Rauschen man einem Gitter hinzufügen muss, um eine nahezu gleichmäßige Verteilung zu erhalten. Dieser Parameter ermöglicht eine elegante und einheitliche Behandlung aller vier Probleme.
|
||||
|
||||
**Grenze der Technik:** Der Verbindungsfaktor Õ(n) liegt nahe an der Grenze √n, ab der GapSVP in NP ∩ coNP liegt. Eine weitere Verbesserung auf o(√n) würde die Worst-Case-Annahme in eine Region bringen, die möglicherweise „zu leicht" für kryptografische Zwecke ist.
|
||||
|
||||
### 4.5 Die Reduktionskette zur Kryptografie: LWE
|
||||
|
||||
**Regev (2005)** führte das **Learning With Errors (LWE)** Problem ein, das die Brücke zwischen Gitterproblemen und moderner Kryptografie schlägt.
|
||||
|
||||
#### Das LWE-Problem
|
||||
|
||||
LWE-Instanz: Gegeben sind m Paare (aᵢ, bᵢ) ∈ ℤ_q^n × ℤ_q, wobei bᵢ = ⟨aᵢ, s⟩ + eᵢ mod q. Hier ist s ∈ ℤ_q^n ein geheimer Vektor, die aᵢ sind zufällig und uniform gewählt, und die eᵢ sind kleine Fehlerterme (aus einer diskreten Gauß-Verteilung mit Parameter α·q).
|
||||
|
||||
- **Search-LWE:** Finde s.
|
||||
- **Decision-LWE:** Unterscheide (aᵢ, ⟨aᵢ, s⟩ + eᵢ) von uniform zufälligen Paaren (aᵢ, uᵢ).
|
||||
|
||||
Ohne die Fehler eᵢ wäre dies trivial (Gauß-Elimination). Die kleinen Fehler machen das Problem drastisch schwerer — sie „verwischen" die lineare Struktur gerade genug. Die kryptografische Idee: (A, b = As + e) ist der öffentliche Schlüssel, s der private Schlüssel. Ein Bit wird verschlüsselt, indem mehrere Gleichungen addiert und das Bit im Ergebnis versteckt wird.
|
||||
|
||||
#### Regevs Reduktion
|
||||
|
||||
> **Regevs Hauptresultat (2005):** Wenn es einen effizienten Algorithmus für LWE gibt, dann gibt es einen effizienten **Quanten**algorithmus für GapSVP und SIVP mit Approximationsfaktor Õ(n/α).
|
||||
|
||||
Die Reduktion ist quantenmechanisch — sie nutzt Quantenüberlagerungen, um aus einem LWE-Orakel Samples von einer diskreten Gauß-Verteilung über das Gitter zu erzeugen. Ob die Quantenmechanik hier notwendig ist, war eine zentrale offene Frage.
|
||||
|
||||
**Peikert (2009)** beantwortete diese teilweise: Er zeigte eine **klassische** Reduktion von GapSVP auf LWE, allerdings nur für große Moduli q ≥ 2^{n/2}. Für polynomielle Moduli nutzt Peikert eine neue Variante ζ-to-γ-GapSVP, die möglicherweise leichter ist, aber basierend auf dem Stand der Algorithmen immer noch exponentiell schwer erscheint.
|
||||
|
||||
**Brakerski et al. (2013)** gaben eine Modulus-Reduktion: LWE mit exponentiellem Modulus in Dimension n reduziert sich auf LWE mit polynomiellem Modulus in Dimension n² — klassisch, ohne Quantenmechanik.
|
||||
|
||||
#### Die vollständige Reduktionskette
|
||||
|
||||
```
|
||||
Worst-Case GapSVP/SIVP (n-dim, Faktor Õ(n/α))
|
||||
↓ Ajtai 1996, Micciancio-Regev 2007
|
||||
Average-Case SIS (schwer für zufällige Instanzen)
|
||||
↓ Regev 2005, Peikert 2009
|
||||
Average-Case LWE (schwer für zufällige Instanzen)
|
||||
↓ kryptografische Konstruktionen
|
||||
ML-KEM (FIPS 203), ML-DSA (FIPS 204), FHE, ...
|
||||
```
|
||||
|
||||
**Quellen:**
|
||||
|
||||
- Micciancio: "SVP Hard to Approximate" — https://cseweb.ucsd.edu/~daniele/papers/SVP.pdf
|
||||
- Peikert/Stephens-Davidowitz: "Complexity of SVP" — https://www.cs.umd.edu/~gasarch/open/svp-color.pdf
|
||||
- Regev: Lecture Notes "Average-case Hardness" — https://cims.nyu.edu/~regev/teaching/lattices_fall_2004/ln/averagecase.pdf
|
||||
- Micciancio & Regev: "Worst-case to Average-case Reductions based on Gaussian Measures" — https://cims.nyu.edu/~regev/papers/average.pdf
|
||||
- Aharonov & Regev: "Lattice Problems in NP ∩ coNP" (J. ACM, 2005) — https://dl.acm.org/doi/10.1145/1089023.1089025
|
||||
- Aharonov & Regev: "A Lattice Problem in Quantum NP" — https://arxiv.org/abs/quant-ph/0307220
|
||||
- Regev: "On Lattices, Learning with Errors..." — https://cims.nyu.edu/~regev/papers/qcrypto.pdf
|
||||
- Regev: "The Learning with Errors Problem" (Survey) — https://cims.nyu.edu/~regev/papers/lwesurvey.pdf
|
||||
- Peikert: "Public-Key Cryptosystems from the Worst-Case SVP" — https://web.eecs.umich.edu/~cpeikert/pubs/svpcrypto.pdf
|
||||
- Regev: Lecture Notes "GapCVP in coNP" — https://cims.nyu.edu/~regev/teaching/lattices_fall_2004/ln/gg.pdf
|
||||
- Peikert: "Limits on Hardness in ℓp Norms" — https://web.eecs.umich.edu/~cpeikert/pubs/lp_norms.pdf
|
||||
|
||||
---
|
||||
|
||||
## 5. Algorithmen & bekannte Schranken
|
||||
|
||||
### 5.1 Der LLL-Algorithmus (1982)
|
||||
|
||||
Der **Lenstra-Lenstra-Lovász (LLL)** Algorithmus ist einer der einflussreichsten Algorithmen der theoretischen Informatik und berechnet eine „reduzierte" Gitterbasis in **polynomieller Zeit**.
|
||||
|
||||
#### Was ist eine LLL-reduzierte Basis?
|
||||
|
||||
Eine Basis B = {b₁, ..., bₙ} heißt δ-LLL-reduziert (typischerweise δ = 3/4), wenn zwei Bedingungen erfüllt sind:
|
||||
|
||||
1. **Größenreduktion:** |μᵢ,ⱼ| ≤ 1/2 für alle i > j. Die Gram-Schmidt-Koeffizienten μᵢ,ⱼ = ⟨bᵢ, b̃ⱼ⟩/⟨b̃ⱼ, b̃ⱼ⟩ messen, wie viel jeder Basisvektor in Richtung der vorherigen Gram-Schmidt-Vektoren zeigt. Die Bedingung |μᵢ,ⱼ| ≤ 1/2 bedeutet, dass man die ganzzahligen Vielfachen der vorherigen Vektoren so weit wie möglich subtrahiert hat — analog zur Größenreduktion bei der Gram-Schmidt-Orthogonalisierung, aber unter Beibehaltung der Ganzzahligkeit.
|
||||
|
||||
2. **Lovász-Bedingung:** ‖b̃ᵢ₊₁‖² ≥ (δ − μ²ᵢ₊₁,ᵢ) · ‖b̃ᵢ‖² für alle i. Diese Bedingung stellt sicher, dass die Gram-Schmidt-Vektoren nicht „zu schnell" kürzer werden. Für n = 2 entspricht sie der Bedingung, dass die Basisvektoren in der richtigen Reihenfolge stehen (der kürzere zuerst). In höheren Dimensionen verallgemeinert sie diese Ordnungsbedingung.
|
||||
|
||||
|
||||
#### Der Algorithmus
|
||||
|
||||
LLL arbeitet iterativ und ist konzeptuell einfach:
|
||||
|
||||
1. Berechne die Gram-Schmidt-Orthogonalisierung.
|
||||
2. Für k = 2, ..., n: Führe Größenreduktion durch (subtrahiere ganzzahlige Vielfache vorheriger Vektoren).
|
||||
3. Prüfe die Lovász-Bedingung für k und k−1.
|
||||
4. Falls verletzt: Tausche b_k und b_{k-1} und gehe zurück zu k−1.
|
||||
5. Falls erfüllt: Gehe weiter zu k+1.
|
||||
|
||||
**Terminierung:** Die Potentialfunktion D = Π_{i=1}^n det(L(b₁,...,bᵢ))² ist eine positive ganze Zahl, die bei jedem Swap um mindestens den Faktor 1/δ < 1 abnimmt. Da D ≥ 1 (weil die Determinanten ganzzahliger Gitter ganzzahlig sind), terminiert der Algorithmus nach höchstens O(n² log(max ‖bᵢ‖)) Swaps. Jeder Swap und jede Größenreduktion erfordern polynomiell viele Operationen, also ist die **Gesamtlaufzeit polynomiell**.
|
||||
|
||||
#### Approximationsgarantie
|
||||
|
||||
Der erste Vektor b₁ einer LLL-reduzierten Basis erfüllt:
|
||||
|
||||
‖b₁‖ ≤ 2^{(n-1)/2} · λ₁(L)
|
||||
|
||||
Also liefert LLL eine **2^{(n-1)/2}-Approximation** des kürzesten Vektors — exponentiell im schlimmsten Fall. Durch Schnorrs **BKZ-Verallgemeinerung** (die die Lovász-Bedingung auf Blöcke von k Vektoren erweitert und intern exaktes SVP in Dimension k löst) erreicht man bessere Faktoren von 2^{O(n(log log n)²/log n)} in Polynomialzeit.
|
||||
|
||||
#### Anwendungen
|
||||
|
||||
Trotz des exponentiellen Worst-Case-Faktors ist LLL extrem nützlich: Brechen von Knapsack-Kryptosystemen, Faktorisierung von Polynomen über ℤ, ganzzahlige Programmierung in fester Dimension, Finden algebraischer Relationen, und viele Anwendungen in der Kryptoanalyse.
|
||||
|
||||
### 5.2 Exakte Algorithmen
|
||||
|
||||
#### Enumeration (Kannan, 1983)
|
||||
|
||||
Kombiniert Basisreduktion mit erschöpfender Aufzählung. Grundidee: Nach einer guten Basisreduktion als Preprocessing werden systematisch alle Gittervektoren v = Σ zᵢbᵢ aufgezählt, deren projizierte Längen innerhalb bestimmter Schranken liegen. Die Schranken ergeben sich aus der reduzierten Basis und der Gram-Schmidt-Orthogonalisierung.
|
||||
|
||||
- **Laufzeit:** n^{O(n)} — superexponentiell
|
||||
- **Speicher:** poly(n) — der große Vorteil gegenüber Sieving!
|
||||
- In der Praxis (bis Dimension ≈60-80) oft schneller als Sieving, da die Worst-Case-Analyse sehr pessimistisch ist
|
||||
|
||||
#### Sieving (AKS, 2001)
|
||||
|
||||
Die konzeptionell eleganteste Methode. **Grundidee:** Man startet mit exponentiell vielen (~2^{10n}) zufälligen Gittervektoren in einer großen Kugel. Dann werden iterativ Paare naher Vektoren durch ihre Differenz ersetzt — ein „Sieb", das immer kürzere Vektoren erzeugt. Nach genügend Runden enthält die Menge den kürzesten Vektor.
|
||||
|
||||
**Warum funktioniert das?** Statt an „Vektoren" zu denken, betrachte man Gitterpunkte modulo dem kürzesten Vektor. Wenn zwei Punkte nahe am gleichen Gitterpunkt liegen, ist ihre Differenz kurz. Durch ein Packing-Argument (Kugeln vom Radius λ₁/2 um verschiedene Gitterpunkte sind disjoint) kann man zeigen, dass genügend solche Paare gefunden werden.
|
||||
|
||||
**Laufzeit-Entwicklung:**
|
||||
|
||||
- AKS (2001): 2^{O(n)} (erste einfach-exponentielle Lösung)
|
||||
- Nguyen-Vidick (2008, heuristisch): (4/3+ε)^n ≈ 2^{0.415n} — zeigte, dass Sieving praktisch ist
|
||||
- Best provable (Aggarwal et al.): 2^{n+o(n)} — optimal up to lower-order terms
|
||||
|
||||
**GaussSieve (Micciancio-Voulgaris, 2010):** Eine praktischere Variante, die statt einer Batch-Verarbeitung inkrementell arbeitet — neue Vektoren werden einzeln eingefügt und gegen die bestehende Liste reduziert. In Experimenten deutlich effizienter als die theoretisch analysierten Varianten.
|
||||
|
||||
#### Voronoi-Zellen (Micciancio & Voulgaris, 2010)
|
||||
|
||||
Ein fundamentaler anderer Ansatz: Berechne die Voronoi-Zelle des Gitters (die Menge aller Punkte, die näher am Ursprung sind als an jedem anderen Gitterpunkt). Aus der Voronoi-Zelle kann man CVP, SVP und die meisten anderen Gitterprobleme in NP lösen.
|
||||
|
||||
- **Deterministisch** (kein Zufall nötig)
|
||||
- **Laufzeit:** Õ(4^n), **Speicher:** Õ(2^n)
|
||||
- Löst nicht nur SVP, sondern auch CVP — der erste deterministische 2^{O(n)}-Algorithmus für CVP
|
||||
|
||||
### 5.3 Übersichtstabelle
|
||||
|
||||
|Ansatz|γ|Laufzeit|Speicher|
|
||||
|---|---|---|---|
|
||||
|LLL (1982)|2^{(n-1)/2}|poly(n)|poly(n)|
|
||||
|BKZ-k (Schnorr)|2^{O(n/k)}|2^{O(k)}|poly(n)|
|
||||
|Enumeration (Kannan)|1 (exakt)|n^{O(n)}|poly(n)|
|
||||
|Sieving (best provable)|1 (exakt)|2^{n+o(n)}|2^{n+o(n)}|
|
||||
|Voronoi (MV 2010)|1 (exakt)|Õ(4^n)|Õ(2^n)|
|
||||
|
||||
**Offene Frage:** Kann SVP in 2^{O(n)} Zeit mit 2^{o(n)} Speicher gelöst werden?
|
||||
|
||||
**Quellen:**
|
||||
|
||||
- Wikipedia: LLL Algorithm — https://en.wikipedia.org/wiki/Lenstra%E2%80%93Lenstra%E2%80%93Lov%C3%A1sz_lattice_basis_reduction_algorithm
|
||||
- Micciancio: CSE 206A Lecture 3 — https://cseweb.ucsd.edu/classes/wi12/cse206A-a/lec3.pdf
|
||||
- MIT OCW: "LLL algorithm" — https://ocw.mit.edu/courses/18-409-topics-in-theoretical-computer-science-an-algorithmists-toolkit-fall-2009/
|
||||
- Nguyen & Vidick: "Sieve Algorithms for SVP are Practical" — https://people.csail.mit.edu/vidick/JoMC08.pdf
|
||||
- Voulgaris: "Algorithms for closest and shortest vector problems" — https://escholarship.org/uc/item/4zt7x45z
|
||||
- Aggarwal et al.: "Faster Provable Sieving" — https://arxiv.org/pdf/1907.04406
|
||||
- Aggarwal et al.: "Improved Algorithms for SVP" (STACS 2021) — https://drops.dagstuhl.de/storage/00lipics/lipics-vol187-stacs2021/LIPIcs.STACS.2021.4/LIPIcs.STACS.2021.4.pdf
|
||||
|
||||
---
|
||||
|
||||
## 6. Bedeutung für Post-Quantum-Kryptografie
|
||||
|
||||
### 6.1 Das Problem mit RSA und ECC
|
||||
|
||||
RSA und ECC (elliptische Kurven) können durch **Shors Algorithmus** effizient gebrochen werden. Die Gefahr des „Harvest now, decrypt later"-Angriffs: Verschlüsselte Daten werden heute abgefangen und in Zukunft entschlüsselt.
|
||||
|
||||
### 6.2 NIST-Standards (August 2024)
|
||||
|
||||
Am 13. August 2024 veröffentlichte NIST die ersten drei Post-Quantum-Standards:
|
||||
|
||||
**FIPS 203 — ML-KEM:** Basierend auf Kyber. Primärer Standard für Schlüsselaustausch. Sicherheit basiert auf Module-LWE. Drei Stufen: ML-KEM-512 (~128-bit), ML-KEM-768 (~192-bit, empfohlen), ML-KEM-1024 (~256-bit). Schlüsselgrößen ~1.5 KB, sub-Millisekunden Handshakes.
|
||||
|
||||
**FIPS 204 — ML-DSA:** Basierend auf Dilithium. Primärer Standard für digitale Signaturen. Basiert auf Module-LWE und Module-SIS. Signaturen 2-5 KB, schnelle Verifikation, seitenkanalresistent.
|
||||
|
||||
**FIPS 205 — SLH-DSA:** Basierend auf SPHINCS+. Hashbasiert, als Backup falls Gitter gebrochen werden.
|
||||
|
||||
Weitere: FALCON (FIPS 206, noch in Arbeit) für kleine Signaturen; HQC (März 2025) als codebasiertes Backup für ML-KEM.
|
||||
|
||||
### 6.3 Die Sicherheitsargumentation
|
||||
|
||||
Die vollständige Kette:
|
||||
|
||||
1. **Worst-Case-Härte:** GapSVP/SIVP gelten als schwer — kein bekannter Quanten- oder klassischer Algorithmus besser als 2^{Ω(n)}.
|
||||
2. **Worst-Case → Average-Case:** Ajtai/Regev/Peikert: Wenn GapSVP im Worst-Case schwer ist, ist LWE als Average-Case-Problem schwer.
|
||||
3. **LWE → Kryptografie:** ML-KEM/ML-DSA basieren auf Module-LWE/Module-SIS. Langlois & Stehlé (2015) zeigten Worst-Case-to-Average-Case-Reduktionen für Module-Varianten.
|
||||
|
||||
**Einzigartigkeit:** Während RSA/ECC auf Average-Case-Annahmen beruhen, bieten gitterbasierte Systeme Worst-Case-Sicherheit.
|
||||
|
||||
**Quellen:**
|
||||
|
||||
- NIST Post-Quantum Standards — https://www.nist.gov/news-events/news/2024/08/nist-releases-first-3-finalized-post-quantum-encryption-standards
|
||||
- NIST PQC Standardization — https://csrc.nist.gov/projects/post-quantum-cryptography/post-quantum-cryptography-standardization
|
||||
- Wikipedia: NIST PQC — https://en.wikipedia.org/wiki/NIST_Post-Quantum_Cryptography_Standardization
|
||||
- Langlois & Stehlé: "Module Lattice Reductions" — https://eprint.iacr.org/2012/090.pdf
|
||||
|
||||
---
|
||||
|
||||
## 7. Zusammenfassung & offene Fragen
|
||||
|
||||
### Zusammenfassung
|
||||
|
||||
|Eigenschaft|Status|
|
||||
|---|---|
|
||||
|SVP exakt (ℓ₂): NP-hart?|Ja, randomisierte Reduktion (Ajtai 1998)|
|
||||
|SVP exakt (ℓ∞): NP-hart?|Ja, deterministisch (van Emde Boas 1981)|
|
||||
|Konstante Approximation: NP-hart?|Ja, randomisiert (Micciancio 2001)|
|
||||
|GapSVP_{O(√(n/log n))} ∈ coAM?|Ja (Goldreich & Goldwasser 2000)|
|
||||
|GapSVP_{O(√n)} ∈ NP ∩ coNP?|Ja (Aharonov & Regev 2005)|
|
||||
|Worst-Case = Average-Case?|Ja, Faktor Õ(n) (Micciancio-Regev 2007)|
|
||||
|Bester exakter Algorithmus|2^{n+o(n)} (Sieving)|
|
||||
|Beste Poly-Zeit-Approximation|2^{O(n)} (LLL)|
|
||||
|Quantenvorteil bekannt?|Nein|
|
||||
|
||||
### Zentrale offene Fragen
|
||||
|
||||
1. **Deterministische NP-Härte** von SVP in ℓ₂? (Offen seit 1998)
|
||||
2. **Wo kippt die Härte?** Zwischen n^{c/log log n} und √n liegt eine unverstandene Zone.
|
||||
3. **Ist GapSVP_{n^{2+ε}} NP-hart?** Falls ja → LWE-Kryptografie sicher allein aus P ≠ NP.
|
||||
4. **Quantenalgorithmen für SVP?** Keine bekannt — eine der wichtigsten offenen Fragen.
|
||||
5. **SVP in 2^{O(n)} Zeit, 2^{o(n)} Speicher?**
|
||||
6. **Vollständige Dequantisierung** der LWE-Reduktion für polynomielle Moduli?
|
||||
|
||||
---
|
||||
|
||||
## Literaturverzeichnis
|
||||
|
||||
|Kürzel|Referenz|
|
||||
|---|---|
|
||||
|[Ajt96]|Ajtai. "Generating hard instances of lattice problems." STOC 1996.|
|
||||
|[Ajt98]|Ajtai. "SVP in ℓ₂ is NP-hard for randomized reductions." STOC 1998.|
|
||||
|[AKS01]|Ajtai, Kumar, Sivakumar. "A sieve algorithm for SVP." STOC 2001.|
|
||||
|[AR05]|Aharonov, Regev. "Lattice problems in NP ∩ coNP." J. ACM 2005.|
|
||||
|[GG00]|Goldreich, Goldwasser. "Limits of nonapproximability of lattice problems." JCSS 2000.|
|
||||
|[Kan83]|Kannan. "Improved algorithms for integer programming." STOC 1983.|
|
||||
|[LLL82]|Lenstra, Lenstra, Lovász. "Factoring polynomials." Math. Annalen 1982.|
|
||||
|[Mic01]|Micciancio. "SVP hard to approximate to within some constant." SICOMP 2001.|
|
||||
|[MR07]|Micciancio, Regev. "Worst-case to average-case via Gaussian measures." SICOMP 2007.|
|
||||
|[MV10]|Micciancio, Voulgaris. "Deterministic 2^{O(n)} for lattice problems." STOC 2010.|
|
||||
|[Pei09]|Peikert. "Public-key cryptosystems from worst-case SVP." STOC 2009.|
|
||||
|[PS23]|Peikert, Stephens-Davidowitz. "Complexity of SVP." SIGACT News 2023.|
|
||||
|[Reg05]|Regev. "On lattices, learning with errors..." STOC 2005 / J. ACM 2009.|
|
||||
75
Komplexitätstheorie/vortrag/Zeitplan.md
Normal file
75
Komplexitätstheorie/vortrag/Zeitplan.md
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
# SVP-Vortrag Vorbereitung — Zeitplan
|
||||
## Tag 1 — Inhalt & Folien (4–5h)
|
||||
### Block 1: Tiefgang ins Thema (4 Pomodoros · ~2h)
|
||||
|
||||
| # | Dauer | Fokus |
|
||||
| --- | ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
|
||||
| 🍅1 | 25min | **Problemverständnis vertiefen:** SVP formal definieren, Approximationsfaktoren (γ-SVP) verstehen, Abgrenzung zu CVP |
|
||||
| ☕ | 5min | Pause |
|
||||
| 🍅2 | 25min | **Härte & Reduktionen:** NP-Härte von SVP, Worst-Case-to-Average-Case-Reduktion (Ajtai), warum das für Krypto so besonders ist |
|
||||
| ☕ | 5min | Pause |
|
||||
| 🍅3 | 25min | **Algorithmen:** LLL-Algorithmus einordnen (polynomiell, aber nur exponentielle Approximation), Schnorr-Euchner, warum exakte Lösung so schwer bleibt |
|
||||
| ☕ | 5min | Pause |
|
||||
| 🍅4 | 25min | **Krypto-Verbindung:** Lattice-based Crypto (NTRU, LWE/SIS als verwandte Probleme), Relevanz für Post-Quantum-Kryptografie, NIST-Standardisierung |
|
||||
| ☕ | 15min | **Lange Pause** — aufstehen, Wasser, kurz raus |
|
||||
|
||||
### Block 2: Folien anpassen (3 Pomodoros · ~1,5h)
|
||||
|
||||
|# |Dauer|Fokus |
|
||||
|--|-----|-----------------------------------------------------------------------------------------------------------------------|
|
||||
|🍅5|25min|**Folien durchgehen:** Reveal.js öffnen, Lücken identifizieren, neue Erkenntnisse aus Block 1 einarbeiten |
|
||||
|☕ |5min |Pause |
|
||||
|🍅6|25min|**Folien fertigstellen:** Visualisierungen prüfen, Übergänge zwischen Folien glätten, Speaker-Notes ergänzen |
|
||||
|☕ |5min |Pause |
|
||||
|🍅7|25min|**Erster Trockenlauf:** Einmal komplett durchsprechen (gerne mit Stoppuhr), Timing notieren, holprige Stellen markieren|
|
||||
|☕ |15min|**Lange Pause** |
|
||||
|
||||
### Block 3: Nachschliff (1–2 Pomodoros · ~0,5–1h)
|
||||
|
||||
|# |Dauer|Fokus |
|
||||
|--|-----|----------------------------------------------------------------------------------------------------------------------|
|
||||
|🍅8|25min|**Zweiter Trockenlauf:** Holprige Stellen gezielt verbessern, nochmal komplett durchsprechen |
|
||||
|☕ |5min |Pause |
|
||||
|🍅9|25min|*(Optional)* **Prof-Fragen vorbereiten:** 3–4 wahrscheinliche Fragen aufschreiben + Stichpunkt-Antworten (siehe unten)|
|
||||
|
||||
-----
|
||||
|
||||
## Tag 2 — Feinschliff & Üben (1–2h)
|
||||
|
||||
> Heute hast du auch deinen anderen Vortrag — danach nur noch SVP polieren, keine neuen Inhalte!
|
||||
|
||||
### Block 1: Generalprobe (2–3 Pomodoros · ~1–1,5h)
|
||||
|
||||
|# |Dauer|Fokus |
|
||||
|--|-----|----------------------------------------------------------------------------------------------------------|
|
||||
|🍅1|25min|**Dritter Trockenlauf:** Komplett durchsprechen, Timing prüfen (Ziel: 10–15min), letzte Folien-Tweaks |
|
||||
|☕ |5min |Pause |
|
||||
|🍅2|25min|**Prof-Fragen durchgehen:** Antworten laut durchsprechen, nicht nur lesen — das macht den Unterschied |
|
||||
|☕ |5min |Pause |
|
||||
|🍅3|25min|*(Falls Zeit)* **Letzter Durchlauf:** Einmal sauber von vorne bis hinten, dann Laptop zuklappen und fertig|
|
||||
|
||||
-----
|
||||
|
||||
## Wahrscheinliche Prof-Fragen
|
||||
|
||||
Bereite dir auf jede Frage 3–4 Sätze als Antwort vor:
|
||||
|
||||
1. **Warum ist SVP für Post-Quantum-Krypto relevant?**
|
||||
→ Worst-Case-Härte überträgt sich auf Average-Case → Kryptosysteme basieren auf der Annahme, dass SVP schwer bleibt, auch für Quantencomputer
|
||||
2. **Was leistet der LLL-Algorithmus, und wo sind seine Grenzen?**
|
||||
→ Polynomielle Laufzeit, aber Approximationsfaktor exponentiell in der Dimension → reicht für kleine Dimensionen, nicht für kryptografische Parameter
|
||||
3. **Was ist der Unterschied zwischen SVP und CVP?**
|
||||
→ SVP: kürzester Vektor im Gitter, CVP: nächster Gitterpunkt zu einem beliebigen Punkt → CVP ist mindestens so schwer wie SVP
|
||||
4. **Was bedeutet die Worst-Case-to-Average-Case-Reduktion?**
|
||||
→ Ajtai 1996: Wenn man zufällige Instanzen von SIS lösen kann, kann man auch Worst-Case-SVP lösen → einzigartig in der Kryptografie, bei den meisten Problemen (RSA, DLP) basiert Sicherheit nur auf Average-Case-Annahmen
|
||||
5. **Wie ordnet sich SVP in die Komplexitätslandschaft ein?**
|
||||
→ NP-hart für exakte Lösung (Ajtai, 1998), für bestimmte Approximationsfaktoren in NP ∩ coNP → nicht NP-vollständig unter üblichen Annahmen
|
||||
|
||||
-----
|
||||
|
||||
## Regeln für dich selbst
|
||||
|
||||
- Handy in einen anderen Raum während Pomodoros
|
||||
- Nach Tag 1 keine neuen Quellen mehr lesen
|
||||
- Lieber einmal mehr üben als eine Folie perfektionieren
|
||||
- Du musst nicht alles wissen — du musst zeigen, dass du es verstanden hast
|
||||
397
Komplexitätstheorie/zusammenfassungen/Grundlagen.md
Normal file
397
Komplexitätstheorie/zusammenfassungen/Grundlagen.md
Normal file
|
|
@ -0,0 +1,397 @@
|
|||
# Komplexitätstheorie – Grundlagen, Entscheidbarkeit & Probleme
|
||||
|
||||
**Basierend auf:** KO1 & KO2 (Prof. Dr. Björn Grohmann, HWR Berlin)
|
||||
|
||||
-----
|
||||
|
||||
## 1. Die Turing-Maschine
|
||||
|
||||
### Was ist eine Turing-Maschine?
|
||||
|
||||
Eine Turing-Maschine (TM) ist ein abstraktes Berechnungsmodell – im Grunde der einfachste denkbare „Computer”. Sie besteht aus drei Teilen:
|
||||
|
||||
- **Ein unendlich langes Band**, unterteilt in Zellen. Jede Zelle enthält genau ein Symbol.
|
||||
- **Ein Lese-/Schreibkopf**, der sich auf dem Band nach links oder rechts bewegen kann, Symbole lesen und schreiben kann.
|
||||
- **Eine endliche Steuerung**, die anhand des aktuellen Zustands und des gelesenen Symbols entscheidet, was als nächstes passiert.
|
||||
|
||||
### Formale Definition
|
||||
|
||||
Eine TM ist ein 7-Tupel $(Q, \Sigma, \Gamma, \delta, q_0, q_{\text{accept}}, q_{\text{reject}})$:
|
||||
|
||||
|Bestandteil |Bedeutung |
|
||||
|-------------------|------------------------------------------------------------------------------|
|
||||
|$Q$ |Endliche Zustandsmenge |
|
||||
|$\Sigma$ |Eingabealphabet (ohne Blanksymbol $\sqcup$) |
|
||||
|$\Gamma$ |Bandalphabet ($\sqcup \in \Gamma$, $\Sigma \subseteq \Gamma$) |
|
||||
|$\delta$ |Übergangsfunktion: $Q \times \Gamma \rightarrow Q \times \Gamma \times {L, R}$|
|
||||
|$q_0$ |Startzustand |
|
||||
|$q_{\text{accept}}$|Akzeptierzustand – die Maschine sagt „Ja” |
|
||||
|$q_{\text{reject}}$|Ablehnungszustand – die Maschine sagt „Nein” |
|
||||
|
||||
Die Übergangsfunktion $\delta$ ist das Herzstück: Sie sagt „Wenn du im Zustand $q$ bist und Symbol $a$ liest, dann schreibe Symbol $b$, wechsle in Zustand $q’$ und bewege den Kopf nach links oder rechts.”
|
||||
|
||||
### Konfiguration
|
||||
|
||||
Eine Konfiguration ist eine Momentaufnahme der TM zu einem bestimmten Zeitpunkt. Sie umfasst den aktuellen Zustand, den Bandinhalt und die Kopfposition.
|
||||
|
||||
Beispiel: $1011q_701111$ bedeutet, dass auf dem Band „101101111” steht, die Maschine im Zustand $q_7$ ist und der Kopf auf dem Zeichen direkt rechts von $q_7$ steht (also auf der „0”).
|
||||
|
||||
### Was bedeutet „halten”?
|
||||
|
||||
Eine Turing-Maschine **hält**, wenn sie irgendwann in den Akzeptier- oder Ablehnungszustand gelangt und damit ihre Berechnung beendet. Wenn sie das nie tut, läuft sie endlos weiter – sie „hält nicht”. Das ist so, als würde ein Programm in einer Endlosschleife stecken und nie ein Ergebnis liefern.
|
||||
|
||||
-----
|
||||
|
||||
## 2. Varianten von Turing-Maschinen
|
||||
|
||||
### Mehrband-TM (Multitape TM)
|
||||
|
||||
Eine TM mit $k$ separaten Bändern und $k$ unabhängigen Köpfen. Die Übergangsfunktion hat die Form:
|
||||
|
||||
$$\delta: Q \times \Gamma^k \rightarrow Q \times \Gamma^k \times {L, R, S}^k$$
|
||||
|
||||
Jede Mehrband-TM kann durch eine Einband-TM simuliert werden (alle Bänder werden hintereinander auf ein Band geschrieben, getrennt durch #-Symbole). Die Simulation kostet quadratischen Zeitoverhead: $O(T(n)^2)$.
|
||||
|
||||
### Nichtdeterministische TM (NTM)
|
||||
|
||||
Die Übergangsfunktion liefert statt eines einzigen Nachfolgezustands eine **Menge** von möglichen Übergängen:
|
||||
|
||||
$$\delta: Q \times \Gamma \rightarrow \mathcal{P}(Q \times \Gamma \times {L, R})$$
|
||||
|
||||
Man kann sich das so vorstellen: An jedem Schritt „verzweigt” sich die Berechnung in mehrere parallele Pfade. Die NTM akzeptiert, wenn **mindestens ein** Pfad akzeptiert. Sie lehnt ab, wenn **alle** Pfade ablehnen.
|
||||
|
||||
Jede NTM kann durch eine deterministische TM simuliert werden, allerdings mit exponentiellem Zeitverlust: Eine $t(n)$-Zeit-NTM wird zu einer $2^{O(t(n))}$-Zeit-DTM.
|
||||
|
||||
### Universelle Turing-Maschine (UTM)
|
||||
|
||||
Eine UTM $\mathcal{U}$ kann jede andere TM simulieren. Sie bekommt als Eingabe die Beschreibung einer TM $M$ (kodiert als Bitfolge, die sogenannte **Gödelnummer**) und eine Eingabe $x$ und berechnet dann $M(x)$.
|
||||
|
||||
Die UTM ist im Grunde der theoretische Vorläufer des modernen Computers: Ein Gerät, das beliebige Programme ausführen kann.
|
||||
|
||||
-----
|
||||
|
||||
## 3. Äquivalente Berechnungsmodelle
|
||||
|
||||
Mehrere andere Berechnungsmodelle sind **genauso mächtig** wie die Turing-Maschine. Das stützt die Church-Turing-These.
|
||||
|
||||
|Modell |Kernidee |
|
||||
|-------------------|---------------------------------------------------------------------------------------|
|
||||
|**WHILE-Programme**|Schleifen mit Inkrement/Dekrement auf Variablen |
|
||||
|**GOTO-Programme** |Nummerierte Anweisungen mit Sprungbefehlen |
|
||||
|**Lambda-Kalkül** |Funktionsdefinition und -anwendung (Grundlage funktionaler Programmierung) |
|
||||
|**Rule 110** |Eindimensionaler Zellularautomat – selbst dieses einfache System ist Turing-vollständig|
|
||||
|
||||
### Church-Turing-These
|
||||
|
||||
> „Jede effektiv berechenbare Funktion kann durch eine Turing-Maschine berechnet werden.”
|
||||
|
||||
Das ist keine bewiesene Aussage, sondern eine These. Sie besagt: Es gibt kein Berechnungsmodell, das mehr berechnen kann als eine TM. Bisher wurde kein Gegenbeispiel gefunden.
|
||||
|
||||
-----
|
||||
|
||||
## 4. Entscheidbarkeit
|
||||
|
||||
### Turing-erkennbar (semi-entscheidbar)
|
||||
|
||||
Eine Sprache $L$ ist **Turing-erkennbar**, wenn es eine TM gibt, die so arbeitet:
|
||||
|
||||
- Eingabe $w \in L$: Die TM akzeptiert (hält und sagt „Ja”).
|
||||
- Eingabe $w \notin L$: Die TM lehnt ab **oder läuft endlos weiter**.
|
||||
|
||||
Das Problem: Man weiß nie, ob die Maschine noch rechnet oder ob sie in einer Endlosschleife steckt.
|
||||
|
||||
### Turing-entscheidbar (entscheidbar)
|
||||
|
||||
Eine Sprache $L$ ist **Turing-entscheidbar**, wenn es eine TM gibt, die so arbeitet:
|
||||
|
||||
- Eingabe $w \in L$: Die TM akzeptiert.
|
||||
- Eingabe $w \notin L$: Die TM lehnt ab.
|
||||
- **Die TM hält immer** – sie liefert auf jeder Eingabe eine definitive Antwort.
|
||||
|
||||
### Der Zusammenhang
|
||||
|
||||
Eine Sprache ist entscheidbar **genau dann, wenn** sie sowohl Turing-erkennbar als auch co-Turing-erkennbar ist. Die Idee: Man lässt zwei Maschinen parallel laufen – eine für $L$, eine für das Komplement $\overline{L}$. Eine von beiden wird irgendwann akzeptieren, und dann hat man die Antwort.
|
||||
|
||||
### Hierarchie der Berechenbarkeit
|
||||
|
||||
```
|
||||
Entscheidbar ⊂ Semi-entscheidbar ⊂ Alle Sprachen
|
||||
(TM hält immer) (TM hält für w ∈ L) (manche sind gar nicht berechenbar)
|
||||
```
|
||||
|
||||
-----
|
||||
|
||||
## 5. Unentscheidbare Probleme
|
||||
|
||||
### Das Halteproblem ($HALT_{\text{TM}}$)
|
||||
|
||||
$$HALT_{\text{TM}} = {\langle M, w \rangle \mid M \text{ ist eine TM und } M \text{ hält auf Eingabe } w}$$
|
||||
|
||||
**Frage:** Kann man im Voraus entscheiden, ob ein beliebiges Programm auf einer beliebigen Eingabe irgendwann anhält oder ewig weiterläuft?
|
||||
|
||||
**Antwort:** Nein – das Halteproblem ist unentscheidbar.
|
||||
|
||||
### Die Akzeptanzsprache ($A_{\text{TM}}$)
|
||||
|
||||
$$A_{\text{TM}} = {\langle M, w \rangle \mid M \text{ ist eine TM und } M \text{ akzeptiert } w}$$
|
||||
|
||||
$A_{\text{TM}}$ ist semi-entscheidbar (man kann $M$ auf $w$ simulieren), aber **nicht entscheidbar**.
|
||||
|
||||
### Beweis durch Diagonalisierung
|
||||
|
||||
Der Beweis nutzt dieselbe Idee wie Cantors Diagonalisierung:
|
||||
|
||||
1. **Annahme:** Es gibt einen Entscheider $H$, der für jede TM $M$ und jede Eingabe $w$ korrekt entscheidet, ob $M$ die Eingabe $w$ akzeptiert.
|
||||
2. **Konstruktion:** Baue eine „teuflische” Maschine $D$, die bei Eingabe $\langle M \rangle$ den Entscheider $H$ auf $\langle M, \langle M \rangle \rangle$ aufruft – also fragt „akzeptiert $M$ sich selbst?” – und dann **das Gegenteil tut**.
|
||||
3. **Widerspruch:** Was passiert bei $D(\langle D \rangle)$?
|
||||
- Falls $H$ sagt „$D$ akzeptiert sich selbst” → $D$ lehnt ab. Aber dann akzeptiert $D$ sich selbst nicht – Widerspruch zu dem, was $H$ gesagt hat.
|
||||
- Falls $H$ sagt „$D$ akzeptiert sich selbst nicht” → $D$ akzeptiert. Aber dann akzeptiert $D$ sich selbst doch – wieder Widerspruch.
|
||||
1. **Schlussfolgerung:** $H$ kann nicht existieren.
|
||||
|
||||
Man kann sich das auch als Tabelle vorstellen: Zeilen sind TMs, Spalten sind Eingaben, Einträge sind 0 (lehnt ab) oder 1 (akzeptiert). $D$ nimmt die Diagonale und invertiert sie – und kann daher in keiner Zeile der Tabelle vorkommen, obwohl $D$ selbst eine TM ist.
|
||||
|
||||
### Postsches Korrespondenzproblem (PCP)
|
||||
|
||||
**Gegeben:** Wortpaare $(x_1, y_1), \ldots, (x_k, y_k)$, dargestellt als Dominosteine mit Ober- und Unterseite.
|
||||
|
||||
**Gefragt:** Kann man eine Folge von Dominosteinen (mit Wiederholung) so aneinanderlegen, dass die obere und die untere Zeichenkette identisch sind?
|
||||
|
||||
Das PCP ist unentscheidbar, aber semi-entscheidbar (man kann systematisch alle Kombinationen durchprobieren).
|
||||
|
||||
### Hilberts 10. Problem
|
||||
|
||||
**Frage (1900):** Gibt es ein Verfahren, das für jede Polynomgleichung mit ganzzahligen Koeffizienten entscheidet, ob sie eine ganzzahlige Lösung hat?
|
||||
|
||||
**Antwort (Matijassewitsch, 1970):** Nein – unentscheidbar.
|
||||
|
||||
### Weitere unentscheidbare Probleme
|
||||
|
||||
|Problem |Frage |Semi-entscheidbar? |
|
||||
|-----------------------------------|-----------------------------------------------|------------------------------|
|
||||
|$E_{\text{TM}}$: Leerheitsproblem |Ist $L(M) = \emptyset$? |Nein (co-Turing-erkennbar) |
|
||||
|$EQ_{\text{TM}}$: Äquivalenzproblem|Gilt $L(M_1) = L(M_2)$? |Nein |
|
||||
|$REGULAR_{\text{TM}}$ |Ist $L(M)$ regulär? |Nein |
|
||||
|$MIN_{\text{TM}}$ |Ist $M$ eine minimale TM? |Nicht einmal semi-entscheidbar|
|
||||
|Erfüllbarkeit (Prädikatenlogik) |Ist ein prädikatenlogischer Ausdruck erfüllbar?|Ja, aber unentscheidbar |
|
||||
|Gültigkeit (Prädikatenlogik) |Ist ein Ausdruck allgemeingültig? |Ja, aber unentscheidbar |
|
||||
|
||||
-----
|
||||
|
||||
## 6. Zeitkomplexität
|
||||
|
||||
### Laufzeit
|
||||
|
||||
Die Laufzeit (Running Time) einer deterministischen TM $M$ ist die Funktion $f(n)$, die angibt, wie viele Schritte $M$ **im schlimmsten Fall** auf einer Eingabe der Länge $n$ benötigt.
|
||||
|
||||
Bei einer nichtdeterministischen TM zählt man die maximale Schrittzahl über **alle Berechnungspfade** (auch die nicht-akzeptierenden).
|
||||
|
||||
### Zeitkonstruierbarkeit
|
||||
|
||||
Eine Funktion $t(n)$ heißt zeitkonstruierbar, wenn man den Wert $t(n)$ selbst in $O(t(n))$ Schritten berechnen kann. Beispiele: $n$, $n \log n$, $n^2$, $2^n$.
|
||||
|
||||
### Simulationskosten
|
||||
|
||||
|Transformation |Zeitoverhead |
|
||||
|-----------------------------------------------------|----------------------------|
|
||||
|Alphabetreduktion (auf ${0,1,\sqcup,\triangleright}$)|$O(\log |
|
||||
|$k$ Bänder → 1 Band |$O(k \cdot T(n)^2)$ |
|
||||
|NTM → DTM |$2^{O(T(n))}$ (exponentiell)|
|
||||
|Bidirektional → Unidirektional |$O(T(n))$ |
|
||||
|
||||
-----
|
||||
|
||||
## 7. Komplexitätsklassen
|
||||
|
||||
### Die wichtigsten Klassen im Überblick
|
||||
|
||||
|Klasse |Definition |Intuition |Beispiele |
|
||||
|-----------|--------------------------------|------------------------------------|--------------------------------------------|
|
||||
|**P** |$\bigcup_k \text{TIME}(n^k)$ |Effizient lösbar |Sortieren, kürzeste Wege, Primzahltest (AKS)|
|
||||
|**NP** |$\bigcup_k \text{NTIME}(n^k)$ |Lösung effizient überprüfbar |SAT, Hamiltonkreis, TSP, Knapsack |
|
||||
|**co-NP** |Komplemente der NP-Sprachen |„Nein”-Antwort effizient überprüfbar|UNSAT, Tautologie |
|
||||
|**PSPACE** |$\bigcup_k \text{SPACE}(n^k)$ |Polynomieller Speicher reicht |TQBF |
|
||||
|**EXPTIME**|$\bigcup_k \text{TIME}(2^{n^k})$|Exponentielle Zeit |Generalisiertes Schach |
|
||||
|
||||
### Die Inklusionskette
|
||||
|
||||
$$P \subseteq NP \subseteq PSPACE = NPSPACE \subseteq EXPTIME$$
|
||||
|
||||
Die Gleichheit $PSPACE = NPSPACE$ folgt aus Savitch’s Theorem.
|
||||
|
||||
### P vs. NP – Die zentrale offene Frage
|
||||
|
||||
**P** = Probleme, die ein Computer effizient **lösen** kann.
|
||||
**NP** = Probleme, deren Lösung ein Computer effizient **überprüfen** kann.
|
||||
|
||||
Die Frage „Ist P = NP?” fragt im Kern: Ist jedes Problem, dessen Lösung leicht zu überprüfen ist, auch leicht zu finden? Die meisten Informatiker vermuten Nein. Das Problem ist eines der sieben Millennium-Probleme (Preisgeld: 1 Million Dollar).
|
||||
|
||||
### Speicherkomplexität
|
||||
|
||||
$$\text{SPACE}(f(n)) = {L \mid L \text{ wird von einer det. TM in } O(f(n)) \text{ Speicher entschieden}}$$
|
||||
|
||||
$$\text{NSPACE}(f(n)) = {L \mid L \text{ wird von einer nichtdet. TM in } O(f(n)) \text{ Speicher entschieden}}$$
|
||||
|
||||
### Savitch’s Theorem
|
||||
|
||||
$$\text{NSPACE}(f(n)) \subseteq \text{SPACE}(f^2(n))$$
|
||||
|
||||
Nichtdeterministischer Speicher lässt sich deterministisch mit nur quadratischem Mehraufwand simulieren. Die Kernidee ist die CANYIELD-Prozedur: Um zu prüfen, ob Konfiguration $c_2$ von $c_1$ in $t$ Schritten erreichbar ist, probiert man alle möglichen Zwischenkonfigurationen $c_m$ und prüft rekursiv, ob $c_1 \to c_m$ in $t/2$ Schritten und $c_m \to c_2$ in $t/2$ Schritten möglich ist. Die Rekursionstiefe ist $O(\log t)$, jede Ebene braucht $O(f(n))$ Speicher, also insgesamt $O(f(n)^2)$.
|
||||
|
||||
-----
|
||||
|
||||
## 8. NP-Vollständigkeit
|
||||
|
||||
### Polynomialzeit-Reduktion
|
||||
|
||||
Eine Sprache $A$ ist polynomialzeit-reduzierbar auf $B$ (geschrieben $A \leq_P B$), wenn es eine in Polynomialzeit berechenbare Funktion $f$ gibt mit:
|
||||
|
||||
$$w \in A \iff f(w) \in B$$
|
||||
|
||||
Intuition: Wenn man $B$ lösen kann, kann man auch $A$ lösen – man wandelt einfach jede $A$-Instanz mittels $f$ in eine $B$-Instanz um. $B$ ist also **mindestens so schwer** wie $A$.
|
||||
|
||||
### Definition: NP-vollständig
|
||||
|
||||
Eine Sprache $B$ ist NP-vollständig, wenn:
|
||||
|
||||
1. $B \in NP$ (die Lösung ist effizient überprüfbar), **und**
|
||||
2. $A \leq_P B$ für **jedes** $A \in NP$ (jedes NP-Problem lässt sich auf $B$ reduzieren).
|
||||
|
||||
Erfüllt $B$ nur Bedingung 2, heißt $B$ **NP-hard** (NP-schwer). NP-harte Probleme müssen nicht selbst in NP liegen.
|
||||
|
||||
$$\text{NP-vollständig} = NP \cap \text{NP-hard}$$
|
||||
|
||||
### Cook-Levin-Theorem (1971/1973)
|
||||
|
||||
**SAT ist NP-vollständig.** Das war der erste Beweis, dass überhaupt ein NP-vollständiges Problem existiert. Daraus folgt: Könnte man SAT in Polynomialzeit lösen, wäre $P = NP$.
|
||||
|
||||
### PSPACE-Vollständigkeit
|
||||
|
||||
Eine Sprache $B$ ist PSPACE-vollständig, wenn $B \in PSPACE$ und jedes $A \in PSPACE$ polynomiell auf $B$ reduzierbar ist.
|
||||
|
||||
**TQBF** (True Quantified Boolean Formula) ist PSPACE-vollständig. TQBF fragt, ob eine voll quantifizierte Boolesche Formel (mit $\forall$ und $\exists$) wahr ist. TQBF verallgemeinert SAT: Während SAT nur fragt „Gibt es eine erfüllende Belegung?” ($\exists$), erlaubt TQBF auch Allquantoren ($\forall$), was das Problem härter macht.
|
||||
|
||||
-----
|
||||
|
||||
## 9. Die wichtigsten NP-vollständigen Probleme
|
||||
|
||||
### SAT (Erfüllbarkeitsproblem)
|
||||
|
||||
**Eingabe:** Eine Boolesche Formel $\phi$ (z.B. $(x \lor \bar{y}) \land (\bar{x} \lor z)$).
|
||||
**Frage:** Gibt es eine Belegung der Variablen mit wahr/falsch, sodass die Formel wahr wird?
|
||||
**Zertifikat:** Die erfüllende Belegung selbst – man setzt die Werte ein und prüft.
|
||||
|
||||
### Hamiltonkreis
|
||||
|
||||
**Eingabe:** Ein ungerichteter Graph.
|
||||
**Frage:** Gibt es einen Rundweg, der **jeden Knoten genau einmal** besucht und zum Startknoten zurückkehrt?
|
||||
**Zertifikat:** Der Rundweg selbst – man prüft, ob er jeden Knoten genau einmal enthält.
|
||||
|
||||
Die NP-Vollständigkeit wird durch Reduktion von SAT bewiesen, wobei eine Formel in einen Graphen mit speziellen Gadgets übersetzt wird (Variablenpfade, XOR-Gadgets, OR-Gadgets, Kreuzungs-Gadgets).
|
||||
|
||||
### Traveling Salesman Problem (TSP)
|
||||
|
||||
**Eingabe:** Städte mit Entfernungen und ein Budget $k$.
|
||||
**Frage:** Gibt es eine Rundreise durch alle Städte mit Gesamtlänge $\leq k$?
|
||||
**Zertifikat:** Die Rundreise selbst.
|
||||
|
||||
### Knapsack (Rucksackproblem)
|
||||
|
||||
**Eingabe:** Gegenstände mit Gewichten und Werten, ein Rucksack mit Kapazität $W$ und ein Zielwert $V$.
|
||||
**Frage:** Kann man Gegenstände so auswählen, dass das Gesamtgewicht $\leq W$ ist und der Gesamtwert $\geq V$?
|
||||
**Zertifikat:** Die Auswahl der Gegenstände.
|
||||
|
||||
### Minesweeper
|
||||
|
||||
**Eingabe:** Ein teilweise aufgedecktes Minesweeper-Feld.
|
||||
**Frage:** Gibt es eine konsistente Minenbelegung für die verdeckten Felder?
|
||||
|
||||
Die NP-Vollständigkeit wird gezeigt, indem man logische Schaltkreise (Drähte, NOT-Gates, AND-Gates) innerhalb eines Minesweeper-Spielfelds simuliert. Damit lässt sich jede SAT-Instanz als Minesweeper-Konfiguration kodieren.
|
||||
|
||||
### Karp’s Liste (1972)
|
||||
|
||||
Richard Karp bewies 1972, dass 21 Probleme NP-vollständig sind, alle durch Reduktionen ausgehend von SAT. Dazu gehören unter anderem Clique, Node Cover, Chromatic Number, Set Covering, Exact Cover, 3D-Matching, Partition und Max Cut.
|
||||
|
||||
-----
|
||||
|
||||
## 10. NP-Härte von Videospielen
|
||||
|
||||
Viele Videospiele sind NP-hard. Dafür gibt es allgemeine Metatheorems:
|
||||
|
||||
### Metatheorem 1: Location Traversal + Single-Use Paths
|
||||
|
||||
Wenn ein Spiel bestimmte Punkte vorschreibt, die besucht werden müssen, und Wege nur einmal benutzbar sind, ist es NP-hard (Reduktion vom Hamiltonkreisproblem).
|
||||
|
||||
### Metatheorem 2: Tokens, Toll Roads, Location Traversal
|
||||
|
||||
Ein Spiel ist NP-hard, wenn es sammelbare Tokens, kostenpflichtige Wege und zu besuchende Orte hat. Beispiel: In Pac-Man sind Power Pills die Tokens und Geisterkorridore die Toll Roads.
|
||||
|
||||
### Metatheorem 3: Keys, Doors, One-Way Paths
|
||||
|
||||
Wie Metatheorem 2, aber mit Schlüsseln statt Tokens und Türen statt Toll Roads.
|
||||
|
||||
### Metatheorem 4: Doors + Pressure Plates
|
||||
|
||||
Türen und Druckplatten (die Türen öffnen/schließen) machen ein Spiel NP-hard, selbst wenn keine zwei Druckplatten dieselbe Tür steuern.
|
||||
|
||||
### Metatheorem 5: Doors + k-Buttons
|
||||
|
||||
Buttons, bei denen der Spieler entscheiden kann, ob er sie drückt, und die $k$ Türen gleichzeitig beeinflussen, machen ein Spiel NP-hard für $k \geq 2$.
|
||||
|
||||
-----
|
||||
|
||||
## 11. Zusammenfassung: Was ist wo?
|
||||
|
||||
### Entscheidbarkeit
|
||||
|
||||
|Problem |Entscheidbar?|Semi-entscheidbar? |
|
||||
|------------------------------------------|-------------|--------------------------|
|
||||
|$A_{\text{TM}}$ (akzeptiert M w?) |Nein |Ja |
|
||||
|$HALT_{\text{TM}}$ (hält M auf w?) |Nein |Ja |
|
||||
|PCP |Nein |Ja |
|
||||
|Hilberts 10. Problem |Nein |Ja |
|
||||
|$E_{\text{TM}}$ (ist $L(M)$ leer?) |Nein |Nein (co-Turing-erkennbar)|
|
||||
|$EQ_{\text{TM}}$ (sind $L(M_1) = L(M_2)$?)|Nein |Nein |
|
||||
|$MIN_{\text{TM}}$ (ist M minimal?) |Nein |Nein |
|
||||
|
||||
### Komplexität
|
||||
|
||||
|Problem |Klasse |
|
||||
|------------------------|------------------|
|
||||
|Sortieren, kürzeste Wege|P |
|
||||
|Primzahltest (AKS) |P |
|
||||
|SAT |NP-vollständig |
|
||||
|Hamiltonkreis |NP-vollständig |
|
||||
|TSP |NP-vollständig |
|
||||
|Knapsack |NP-vollständig |
|
||||
|Minesweeper |NP-vollständig |
|
||||
|TQBF |PSPACE-vollständig|
|
||||
|Generalisiertes Schach |EXPTIME |
|
||||
|
||||
### Beziehungen zwischen den Klassen
|
||||
|
||||
```
|
||||
Entscheidbar: P ⊆ NP ⊆ PSPACE = NPSPACE ⊆ EXPTIME
|
||||
|
||||
Unentscheidbar: Halteproblem, A_TM, PCP, Hilberts 10. Problem, ...
|
||||
```
|
||||
|
||||
-----
|
||||
|
||||
## 12. Glossar
|
||||
|
||||
| Begriff | Bedeutung |
|
||||
| ---------------------------- | ------------------------------------------------------------ |
|
||||
| **Turing-Maschine** | Abstraktes Berechnungsmodell mit Band, Kopf und Steuerung |
|
||||
| **Konfiguration** | Momentaufnahme: Zustand + Band + Kopfposition |
|
||||
| **Gödelnummer** | Binäre Kodierung einer TM |
|
||||
| **Church-Turing-These** | Alles Berechenbare ist Turing-berechenbar |
|
||||
| **Turing-erkennbar** | TM akzeptiert $w \in L$, kann auf $w \notin L$ endlos laufen |
|
||||
| **Turing-entscheidbar** | TM hält immer und gibt korrekte Antwort |
|
||||
| **Diagonalisierung** | Beweistechnik: Widerspruch durch Selbstreferenz + Negation |
|
||||
| **Zeitkomplexität** | Maximale Schrittzahl einer TM bei Eingabelänge $n$ |
|
||||
| **Speicherkomplexität** | Maximale Zahl besuchter Bandzellen bei Eingabelänge $n$ |
|
||||
| **Verifier** | Algorithmus der $(w, c)$ prüft – $c$ ist das Zertifikat |
|
||||
| **Polynomialzeit-Reduktion** | $A \leq_P B$: Umwandlung von $A$ in $B$ in Polynomialzeit |
|
||||
| **NP-vollständig** | In NP + jedes NP-Problem reduzierbar darauf |
|
||||
| **NP-hard** | Jedes NP-Problem reduzierbar darauf (muss nicht in NP sein) |
|
||||
| **PSPACE-vollständig** | In PSPACE + jedes PSPACE-Problem reduzierbar darauf |
|
||||
73
Komplexitätstheorie/zusammenfassungen/ko1 - themenliste.md
Normal file
73
Komplexitätstheorie/zusammenfassungen/ko1 - themenliste.md
Normal file
|
|
@ -0,0 +1,73 @@
|
|||
# Komplexitätstheorie – Vorlesung 1: Themenliste
|
||||
**Prof. Dr. Björn Grohmann | HWR Berlin | 18.02.2026**
|
||||
|
||||
---
|
||||
## 1. Turing-Maschinen
|
||||
|
||||
- Historischer Hintergrund (Alan Turing, Princeton)
|
||||
- Formale Definition als 7-Tupel (Q, Σ, Γ, δ, q₀, q_accept, q_reject)
|
||||
- Konfigurationen einer Turing-Maschine
|
||||
- Beispiel: Sprache B = {w#w | w ∈ {0,1}*} – Zustandsdiagramm
|
||||
- **Church-Turing-These**: Jede effektiv berechenbare Funktion ist Turing-berechenbar
|
||||
|
||||
## 2. Varianten von Turing-Maschinen
|
||||
|
||||
- **Multitape Turing Machine** – Äquivalenz zur Single-Tape TM
|
||||
- **Universelle Turing-Maschine** – Gödelnummer, Simulation mit O(CT log T) Schritten
|
||||
- **Nichtdeterministische Turing-Maschine (NTM)** – Übergangsfunktion δ: Q × Γ → P(Q × Γ × {L,R})
|
||||
- Äquivalenz NTM ↔ DTM mit exponentiellem Zeitverlust (2^O(t(n)))
|
||||
|
||||
## 3. Laufzeit & Zeitkomplexität
|
||||
|
||||
- Running Time / Time Complexity einer deterministischen TM
|
||||
- Running Time einer nichtdeterministischen TM (maximale Tiefe aller Zweige)
|
||||
- **Time Constructibility** – Definition und Bedeutung
|
||||
- Overhead-Resultate: Alphabetreduktion (4 log|Γ| · T(n)), Tape-Reduktion (5kT(n)²), Bidirektionale TM (4T(n))
|
||||
|
||||
## 4. Entscheidbarkeit
|
||||
|
||||
- **Turing-erkennbar** (rekursiv aufzählbar / semi-entscheidbar)
|
||||
- **Turing-entscheidbar** (rekursiv / entscheidbar)
|
||||
- Satz: Eine Sprache ist entscheidbar ⟺ sie ist Turing-erkennbar und co-Turing-erkennbar
|
||||
|
||||
## 5. Das Halteproblem
|
||||
|
||||
- Sprache A_TM = {⟨M, w⟩ | M ist TM und M akzeptiert w} – semi-entscheidbar, aber unentscheidbar
|
||||
- HALT_TM = {⟨M, w⟩ | M ist TM und M hält auf w} – unentscheidbar
|
||||
- Beweis per Diagonalisierung (Widerspruchsargument)
|
||||
|
||||
## 6. Weitere unentscheidbare Probleme
|
||||
|
||||
- **Postsches Korrespondenzproblem (PCP)** – semi-entscheidbar
|
||||
- **Hilberts 10. Problem** – Diophantische Gleichungen
|
||||
- **Erfüllbarkeitsproblem** und **Gültigkeitsproblem** der Prädikatenlogik (semi-entscheidbar)
|
||||
- **Unerfüllbarkeitsproblem** der Prädikatenlogik
|
||||
- E_TM (leere Sprache), EQ_TM (Sprachäquivalenz), REGULAR_TM (reguläre Sprache)
|
||||
- MIN_TM (minimale TM) – nicht einmal semi-entscheidbar
|
||||
|
||||
## 7. Die Klasse P
|
||||
|
||||
- Definition: P = ⋃_k TIME(n^k) – in Polynomialzeit entscheidbare Sprachen
|
||||
- Beispielmengen: ℕ, 2ℕ, Primzahlen ℙ, Summen/Produkte von Primzahlen
|
||||
|
||||
## 8. Die Klasse NP
|
||||
|
||||
- Verifier-basierte Definition: polynomieller Verifier, polynomiell verifizierbar
|
||||
- NP = Klasse der Sprachen mit polynomiellen Verifizierern
|
||||
- Äquivalente Definition: NP = ⋃_k NTIME(n^k)
|
||||
- P: schnell _entscheidbar_ vs. NP: schnell _verifizierbar_
|
||||
- Beispielmengen: Summen/Produkte von Primzahlen, Primzahlen (n ≠ p·q), SAT, UNSAT
|
||||
|
||||
## 9. P vs. NP
|
||||
|
||||
- Offene Frage: P ⊂ NP oder P = NP?
|
||||
- Millennium-Problem (Clay Mathematics Institute, 1 Mio. Dollar Preisgeld)
|
||||
|
||||
## 10. NP-Vollständigkeit & Reduktionen
|
||||
|
||||
- **Polynomialzeit-berechenbare Funktion**
|
||||
- **Polynomialzeit-Reduktion** (A ≤_P B)
|
||||
- Definition NP-vollständig: (1) B ∈ NP, (2) jedes A ∈ NP ist polynomiell auf B reduzierbar
|
||||
- **NP-hard**: nur Bedingung (2)
|
||||
- Venn-Diagramm: P ⊆ NP ⊆ NP-hard, NP-complete = NP ∩ NP-hard
|
||||
- **Cook-Levin Theorem**: SAT ist NP-vollständig (SAT ∈ P ⟺ P = NP)
|
||||
403
Komplexitätstheorie/zusammenfassungen/ko1 - zusammenfassung.md
Normal file
403
Komplexitätstheorie/zusammenfassungen/ko1 - zusammenfassung.md
Normal file
|
|
@ -0,0 +1,403 @@
|
|||
# Komplexitätstheorie – Vorlesung 1: Zusammenfassung
|
||||
**Prof. Dr. Björn Grohmann | HWR Berlin | 18.02.2026**
|
||||
|
||||
---
|
||||
## 1. Turing-Maschinen
|
||||
|
||||
### Historischer Hintergrund
|
||||
|
||||
Alan Turing (geboren 23. Juni 1912 in London, gestorben 8. Juni 1954) studierte Mathematik in Cambridge (B.A. 1934) und promovierte an der Princeton University (Ph.D. 1938) mit der Dissertation „Systems of Logic Based on Ordinals". Er entwickelte das Konzept der Turing-Maschine als abstraktes Berechnungsmodell, das bis heute die Grundlage der theoretischen Informatik bildet.
|
||||
|
||||
### Formale Definition
|
||||
|
||||
Eine **Turing-Maschine** ist ein 7-Tupel $(Q, \Sigma, \Gamma, \delta, q_0, q_{\text{accept}}, q_{\text{reject}})$, wobei $Q$, $\Sigma$ und $\Gamma$ endliche Mengen sind:
|
||||
|
||||
1. $Q$ ist die **Zustandsmenge** (set of states).
|
||||
2. $\Sigma$ ist das **Eingabealphabet**, das das Blanksymbol $\sqcup$ nicht enthält.
|
||||
3. $\Gamma$ ist das **Bandalphabet**, wobei $\sqcup \in \Gamma$ und $\Sigma \subseteq \Gamma$.
|
||||
4. $\delta: Q \times \Gamma \rightarrow Q \times \Gamma \times \{L, R\}$ ist die **Übergangsfunktion** (transition function).
|
||||
5. $q_0 \in Q$ ist der **Startzustand** (start state).
|
||||
6. $q_{\text{accept}} \in Q$ ist der **Akzeptierzustand** (accept state).
|
||||
7. $q_{\text{reject}} \in Q$ ist der **Ablehnungszustand** (reject state), wobei $q_{\text{reject}} \neq q_{\text{accept}}$.
|
||||
|
||||
Die Turing-Maschine besteht aus einer endlichen Steuerung (control) und einem **unendlich langen Band**, auf dem Symbole gelesen und geschrieben werden.
|
||||
|
||||
### Konfiguration
|
||||
|
||||
Eine **Konfiguration** beschreibt den vollständigen Zustand einer TM zu einem Zeitpunkt: Sie umfasst den aktuellen Zustand, den Bandinhalt und die Position des Lese-/Schreibkopfes. Beispiel: Die Konfiguration $1011q_701111$ bedeutet, dass sich die Maschine im Zustand $q_7$ befindet und der Kopf auf dem Zeichen unmittelbar rechts von $q_7$ steht.
|
||||
|
||||
### Beispiel: Sprache $B = \{w\#w \mid w \in \{0,1\}^*\}$
|
||||
|
||||
Diese Sprache besteht aus allen Wörtern, die aus zwei identischen Hälften bestehen, getrennt durch ein #-Zeichen. Die TM arbeitet wie folgt:
|
||||
|
||||
- Das erste Zeichen der linken Hälfte wird gelesen, durch $x$ ersetzt und gemerkt (Zustand $q_1$).
|
||||
- Der Kopf wandert nach rechts über das #-Zeichen zum entsprechenden Zeichen der rechten Hälfte.
|
||||
- Stimmt das Zeichen überein, wird es ebenfalls durch $x$ ersetzt; der Kopf wandert zurück zum nächsten unmarkierten Zeichen links.
|
||||
- Dieser Prozess wiederholt sich, bis alle Zeichen abgeglichen sind.
|
||||
- Wenn am Ende nur $x$-Symbole und ein # auf dem Band stehen und ein Blank erreicht wird → **accept**.
|
||||
- Bei jedem Mismatch → **reject**.
|
||||
|
||||
Das Zustandsdiagramm umfasst die Zustände $q_1$ bis $q_8$ sowie $q_{\text{accept}}$ (und implizite reject-Pfade, die im Diagramm der Vorlesung weggelassen wurden).
|
||||
|
||||
### Church-Turing-These
|
||||
|
||||
> „Jede effektiv berechenbare Funktion kann durch eine Turing-Maschine berechnet werden."
|
||||
|
||||
Dies ist keine mathematisch beweisbare Aussage, sondern eine **These** (Hypothese). Sie wird gestützt durch die Tatsache, dass alle bekannten Berechnungsmodelle (WHILE-Programme, GOTO-Programme, Lambda-Kalkül, Rule 110 Zellularautomaten etc.) äquivalent zur Turing-Maschine sind.
|
||||
|
||||
---
|
||||
|
||||
## 2. Äquivalente Berechnungsmodelle
|
||||
|
||||
### WHILE-Programme
|
||||
|
||||
WHILE-Programme sind ein einfaches Berechnungsmodell mit folgender Syntax:
|
||||
|
||||
- $P \rightarrow X := X + C$ (Inkrement)
|
||||
- $\mid\quad X := X - C$ (Dekrement, wobei das Ergebnis nicht negativ wird)
|
||||
- $\mid\quad P;\; P$ (Sequenz)
|
||||
- $\mid\quad \text{WHILE } X \neq 0 \text{ DO } P \text{ END}$ (Schleife)
|
||||
|
||||
WHILE-Programme sind **Turing-vollständig**, d.h. sie können genau die gleichen Funktionen berechnen wie eine Turing-Maschine.
|
||||
|
||||
### GOTO-Programme
|
||||
|
||||
GOTO-Programme bestehen aus nummerierten Anweisungen $M_1: A_1;\; M_2: A_2;\; \ldots;\; M_k: A_k$ mit den Operationen:
|
||||
|
||||
- $x_i := x_j + n$ (Addition einer Konstante)
|
||||
- $x_i := x_j - n$ (Subtraktion einer Konstante)
|
||||
- $\text{GOTO } M_i$ (unbedingter Sprung)
|
||||
- $\text{IF } x_i = n \text{ GOTO } M_j$ (bedingter Sprung)
|
||||
- $\text{HALT}$ (Programmende)
|
||||
|
||||
Auch GOTO-Programme sind äquivalent zu Turing-Maschinen.
|
||||
|
||||
### Rule 110 (Zellularautomat)
|
||||
|
||||
Rule 110 ist ein eindimensionaler Zellularautomat, dessen Übergangsregel durch die Binärdarstellung der Zahl 110 (01101110) definiert wird. Jede Zelle wird basierend auf ihrem eigenen Zustand und den Zuständen ihrer beiden Nachbarn aktualisiert. Es wurde bewiesen, dass Rule 110 **Turing-vollständig** ist – ein einfacher Zellularautomat kann also universelle Berechnungen durchführen.
|
||||
|
||||
---
|
||||
|
||||
## 3. Varianten von Turing-Maschinen
|
||||
|
||||
### Multitape Turing Machine (Mehrband-TM)
|
||||
|
||||
Die Übergangsfunktion einer $k$-Band-TM hat die Form:
|
||||
|
||||
$$\delta: Q \times \Gamma^k \rightarrow Q \times \Gamma^k \times \{L, R, S\}^k$$
|
||||
|
||||
Die Maschine verfügt über $k$ separate Bänder mit eigenen Köpfen (Input-Tape mit Read-Only-Head, Work-Tape und Output-Tape mit Read/Write-Heads).
|
||||
|
||||
**Theorem:** Jede Multitape-TM hat eine äquivalente Single-Tape-TM. Die Simulation erfolgt, indem alle Bänder auf einem einzigen Band kodiert werden (getrennt durch #-Symbole), wobei die Kopfpositionen durch markierte Symbole (z.B. Punkte über den Zeichen) dargestellt werden.
|
||||
|
||||
### Universelle Turing-Maschine (UTM)
|
||||
|
||||
Es existiert eine TM $\mathcal{U}$, die für jede Eingabe $x, \alpha \in \{0,1\}^*$ das Ergebnis $\mathcal{U}(x, \alpha) = M_\alpha(x)$ berechnet, wobei $M_\alpha$ die durch die **Gödelnummer** $\alpha$ kodierte Turing-Maschine ist.
|
||||
|
||||
Die UTM nutzt mehrere Arbeitsbänder: ein Input-Tape, Work-Tapes (Simulation des Arbeitsbandes von $M$, Beschreibung von $M$, aktueller Zustand von $M$) und ein Output-Tape.
|
||||
|
||||
**Simulationsoverhead:** Wenn $M_\alpha$ in $T$ Schritten hält, so hält $\mathcal{U}(x, \alpha)$ in $O(CT \log T)$ Schritten, wobei $C$ eine Konstante ist, die nur von der Alphabetgröße, Bandanzahl und Zustandsanzahl von $M_\alpha$ abhängt.
|
||||
|
||||
### Nichtdeterministische Turing-Maschine (NTM)
|
||||
|
||||
Die Übergangsfunktion einer NTM hat die Form:
|
||||
|
||||
$$\delta: Q \times \Gamma \rightarrow \mathcal{P}(Q \times \Gamma \times \{L, R\})$$
|
||||
|
||||
Statt eines einzigen Nachfolgezustands gibt es eine **Menge** möglicher Übergänge. Die NTM kann als Maschine mit drei Bändern simuliert werden: Input-Tape, Simulation-Tape und Address-Tape (das die nichtdeterministischen Entscheidungen kodiert).
|
||||
|
||||
**Theorem:** Jede NTM hat eine äquivalente DTM. Jede $t(n)$-Zeit-NTM (mit $t(n) \geq n$) kann durch eine deterministische TM in Zeit $2^{O(t(n))}$ simuliert werden — also mit **exponentiellem Zeitverlust**.
|
||||
|
||||
**Akzeptanzkriterium:** Eine NTM akzeptiert eine Eingabe, wenn **mindestens ein** Berechnungspfad akzeptiert. Sie lehnt ab, wenn **alle** Pfade ablehnen.
|
||||
|
||||
---
|
||||
|
||||
## 4. Laufzeit und Zeitkomplexität
|
||||
|
||||
### Running Time (deterministisch)
|
||||
|
||||
Sei $M$ eine deterministische TM, die auf allen Eingaben hält. Die **Laufzeit** (running time / time complexity) von $M$ ist die Funktion $f: \mathbb{N} \rightarrow \mathbb{N}$, wobei $f(n)$ die **maximale Anzahl von Schritten** ist, die $M$ auf einer Eingabe der Länge $n$ benötigt. Man sagt: „$M$ läuft in Zeit $f(n)$" oder „$M$ ist eine $f(n)$-Zeit-Turing-Maschine."
|
||||
|
||||
### Running Time (nichtdeterministisch)
|
||||
|
||||
Sei $N$ eine nichtdeterministische TM, die ein Entscheider ist. Die **Laufzeit** von $N$ ist die Funktion $f: \mathbb{N} \rightarrow \mathbb{N}$, wobei $f(n)$ die **maximale Anzahl von Schritten** ist, die $N$ auf **irgendeinem Zweig** ihrer Berechnung bei einer Eingabe der Länge $n$ benötigt.
|
||||
|
||||
### Time Constructibility
|
||||
|
||||
Eine Funktion $t: \mathbb{N} \rightarrow \mathbb{N}$ mit $t(n) \geq O(n \log n)$ heißt **zeitkonstruierbar** (time constructible), wenn die Funktion, die den String $1^n$ auf die Binärdarstellung von $t(n)$ abbildet, in Zeit $O(t(n))$ berechenbar ist.
|
||||
|
||||
Es gibt auch eine alternative Definition, bei der lediglich $t(n) \geq n$ gefordert wird.
|
||||
|
||||
Typische zeitkonstruierbare Funktionen sind z.B. $n$, $n \log n$, $n^2$, $2^n$.
|
||||
|
||||
### Overhead-Resultate (Simulationskosten)
|
||||
|
||||
| Transformation | Zeitoverhead |
|
||||
|---|---|
|
||||
| **Alphabetreduktion** (beliebiges Alphabet → $\{0,1,\sqcup,\triangleright\}$) | $4 \log |\Gamma| \cdot T(n)$ |
|
||||
| **Tape-Reduktion** ($k$ Bänder → 1 Band) | $5k \cdot T(n)^2$ |
|
||||
| **Bidirektionale TM → Unidirektionale TM** | $4 \cdot T(n)$ |
|
||||
|
||||
### Zeitkomplexitätsklasse TIME
|
||||
|
||||
Sei $t: \mathbb{N} \rightarrow \mathbb{R}^+$ eine Funktion. Die **Zeitkomplexitätsklasse** $\text{TIME}(t(n))$ ist die Menge aller Sprachen, die von einer $O(t(n))$-Zeit-Turing-Maschine entschieden werden können.
|
||||
|
||||
---
|
||||
|
||||
## 5. Entscheidbarkeit
|
||||
|
||||
### Turing-erkennbar (rekursiv aufzählbar / semi-entscheidbar)
|
||||
|
||||
Eine Sprache heißt **Turing-erkennbar** (Turing-recognizable), wenn es eine TM gibt, die sie erkennt. Das bedeutet:
|
||||
|
||||
- Für $w \in L$: Die TM akzeptiert.
|
||||
- Für $w \notin L$: Die TM lehnt ab **oder hält nicht** (läuft unendlich lange).
|
||||
|
||||
### Turing-entscheidbar (rekursiv / entscheidbar)
|
||||
|
||||
Eine Sprache heißt **Turing-entscheidbar** (Turing-decidable), wenn es eine TM gibt, die sie entscheidet. Das bedeutet:
|
||||
|
||||
- Für $w \in L$: Die TM akzeptiert.
|
||||
- Für $w \notin L$: Die TM lehnt ab.
|
||||
- Die TM **hält immer** (auf jeder Eingabe).
|
||||
|
||||
### Zusammenhang
|
||||
|
||||
**Theorem:** Eine Sprache ist entscheidbar **genau dann, wenn** sie sowohl Turing-erkennbar als auch co-Turing-erkennbar ist.
|
||||
|
||||
Beweisskizze: Man lässt die TM $M_1$ (für $L$) und $M_2$ (für $\overline{L}$) parallel auf der Eingabe $w$ laufen. Wenn $M_1$ akzeptiert → accept; wenn $M_2$ akzeptiert → reject. Da eine der beiden Maschinen für jede Eingabe irgendwann akzeptiert, hält das Verfahren immer.
|
||||
|
||||
---
|
||||
|
||||
## 6. Das Halteproblem
|
||||
|
||||
### $A_{\text{TM}}$ – Die Akzeptanzsprache
|
||||
|
||||
$$A_{\text{TM}} = \{\langle M, w \rangle \mid M \text{ ist eine TM und } M \text{ akzeptiert } w\}$$
|
||||
|
||||
$A_{\text{TM}}$ ist **semi-entscheidbar** (Turing-erkennbar): Man simuliert $M$ auf $w$. Wenn $M$ akzeptiert → accept; wenn $M$ ablehnt → reject. Problem: Wenn $M$ nicht hält, hält auch der Simulator nicht.
|
||||
|
||||
**Theorem:** $A_{\text{TM}}$ ist **unentscheidbar**.
|
||||
|
||||
### $HALT_{\text{TM}}$ – Das Halteproblem
|
||||
|
||||
$$HALT_{\text{TM}} = \{\langle M, w \rangle \mid M \text{ ist eine TM und } M \text{ hält auf Eingabe } w\}$$
|
||||
|
||||
**Theorem:** $HALT_{\text{TM}}$ ist **unentscheidbar**.
|
||||
|
||||
### Beweis per Diagonalisierung
|
||||
|
||||
Der Beweis der Unentscheidbarkeit von $A_{\text{TM}}$ verwendet ein **Diagonalisierungsargument** (Widerspruchsbeweis):
|
||||
|
||||
1. Angenommen, es gibt einen Entscheider $H$ für $A_{\text{TM}}$.
|
||||
2. Konstruiere daraus eine Maschine $D$, die bei Eingabe $\langle M \rangle$ die Maschine $H$ auf $\langle M, \langle M \rangle \rangle$ simuliert und das Ergebnis **invertiert**.
|
||||
3. Was passiert bei $D(\langle D \rangle)$?
|
||||
- Falls $D$ akzeptiert → $H$ sagt "$D$ akzeptiert $\langle D \rangle$" → $D$ sollte ablehnen. **Widerspruch!**
|
||||
- Falls $D$ ablehnt → $H$ sagt "$D$ akzeptiert $\langle D \rangle$ nicht" → $D$ sollte akzeptieren. **Widerspruch!**
|
||||
4. Also kann $H$ nicht existieren.
|
||||
|
||||
Das Diagonalisierungsargument funktioniert über eine Matrix: Die Zeilen sind Turing-Maschinen $T_1, T_2, T_3, \ldots$, die Spalten sind Eingaben $i_1, i_2, i_3, \ldots$, und die Einträge (0 oder 1) zeigen, ob $T_i$ die Eingabe $i_j$ akzeptiert. Die Maschine $D$ invertiert die Diagonale — und erzeugt so den Widerspruch, da $D$ als Zeile in der Matrix selbst vorkommen müsste.
|
||||
|
||||
---
|
||||
|
||||
## 7. Weitere unentscheidbare Probleme
|
||||
|
||||
### Postsches Korrespondenzproblem (PCP)
|
||||
|
||||
**Gegeben:** Eine endliche Folge von Wortpaaren $(x_1, y_1), \ldots, (x_k, y_k)$ mit $x_i, y_i \in \{0,1\}^+$ (dargestellt als Dominos mit oberer und unterer Hälfte).
|
||||
|
||||
**Gefragt:** Gibt es eine endliche Folge von Indizes $i_1, \ldots, i_n \in \{1, \ldots, k\}$, sodass $x_{i_1} \ldots x_{i_n} = y_{i_1} \ldots y_{i_n}$? (Können Kopien der Dominos so aneinandergelegt werden, dass oben und unten das gleiche Wort steht?)
|
||||
|
||||
Das PCP ist **unentscheidbar**, aber immerhin **semi-entscheidbar** (man kann systematisch alle Kombinationen durchprobieren).
|
||||
|
||||
Benannt nach **Emil Leon Post** (1897–1957).
|
||||
|
||||
### Hilberts 10. Problem
|
||||
|
||||
David Hilbert formulierte 1900 die Frage: Gibt es ein Verfahren, mit dem man für eine beliebige diophantische Gleichung (Polynomgleichung mit ganzzahligen Koeffizienten) entscheiden kann, ob sie eine ganzzahlige Lösung hat?
|
||||
|
||||
**Antwort (1970, Matijassewitsch):** Nein — dieses Problem ist **unentscheidbar**.
|
||||
|
||||
### Probleme der Prädikatenlogik
|
||||
|
||||
| Problem | Frage | Status |
|
||||
|---|---|---|
|
||||
| **Erfüllbarkeitsproblem** | Ist ein prädikatenlogischer Ausdruck $A$ über Signatur $S$ erfüllbar? | semi-entscheidbar, unentscheidbar |
|
||||
| **Gültigkeitsproblem** | Ist $A$ allgemeingültig? | semi-entscheidbar, unentscheidbar |
|
||||
| **Unerfüllbarkeitsproblem** | Ist $A$ unerfüllbar? | semi-entscheidbar, unentscheidbar |
|
||||
|
||||
Das Erfüllbarkeitsproblem und das Gültigkeitsproblem sind jeweils **semi-entscheidbar**. Das Unerfüllbarkeitsproblem ist ebenfalls semi-entscheidbar (da es das Komplement des Gültigkeitsproblems ist).
|
||||
|
||||
### Weitere unentscheidbare Sprachen über TMs
|
||||
|
||||
| Sprache | Definition | Semi-entscheidbar? |
|
||||
|---|---|---|
|
||||
| $E_{\text{TM}}$ | $\{\langle M \rangle \mid M \text{ ist TM und } L(M) = \emptyset\}$ | Nein (co-Turing-erkennbar) |
|
||||
| $EQ_{\text{TM}}$ | $\{\langle M_1, M_2 \rangle \mid L(M_1) = L(M_2)\}$ | Nein |
|
||||
| $REGULAR_{\text{TM}}$ | $\{\langle M \rangle \mid L(M) \text{ ist regulär}\}$ | Nein |
|
||||
| $MIN_{\text{TM}}$ | $\{\langle M \rangle \mid M \text{ ist eine minimale TM}\}$ | **Nicht einmal semi-entscheidbar** |
|
||||
|
||||
$MIN_{\text{TM}}$ enthält die Beschreibungen aller TMs, für die es keine kürzere äquivalente TM gibt.
|
||||
|
||||
---
|
||||
|
||||
## 8. Die Klasse P
|
||||
|
||||
### Definition
|
||||
|
||||
$$\text{P} = \bigcup_k \text{TIME}(n^k)$$
|
||||
|
||||
**P** ist die Klasse aller Sprachen, die in **polynomieller Zeit** auf einer **deterministischen** Single-Tape-Turing-Maschine entscheidbar sind.
|
||||
|
||||
### Beispiele: Welche Mengen liegen in P?
|
||||
|
||||
| Menge | In P? | Begründung |
|
||||
|---|---|---|
|
||||
| $\mathbb{N} = \{1, 2, 3, \ldots\}$ | Ja | Trivial entscheidbar (jede natürliche Zahl akzeptieren) |
|
||||
| $2\mathbb{N} = \{2, 4, 6, \ldots\}$ | Ja | Letztes Bit prüfen (gerade Zahl) |
|
||||
| $\mathbb{P}$ (Primzahlen) | Ja | AKS-Algorithmus (2002) läuft in Polynomialzeit |
|
||||
| $\{p + q \mid p, q \in \mathbb{P}\}$ (Summen von Primzahlen) | Ja | Alle Zerlegungen $p + q = n$ durchprobieren, jeweils Primzahltest |
|
||||
| $\{p \cdot q \mid p, q \in \mathbb{P}\}$ (Produkte von Primzahlen) | Ja | Faktorisierung in Polynomialzeit prüfbar (Probedivision genügt, da nur Zerlegung in zwei Primfaktoren gefragt) |
|
||||
|
||||
---
|
||||
|
||||
## 9. Die Klasse NP
|
||||
|
||||
### Verifier-basierte Definition
|
||||
|
||||
Ein **Verifier** für eine Sprache $A$ ist ein Algorithmus $V$, sodass:
|
||||
|
||||
$$A = \{w \mid V \text{ akzeptiert } \langle w, c \rangle \text{ für ein Zertifikat } c\}$$
|
||||
|
||||
Ein **polynomieller Verifier** läuft in polynomieller Zeit **bezogen auf die Länge von $w$** (nicht von $c$).
|
||||
|
||||
Eine Sprache $A$ ist **polynomiell verifizierbar**, wenn sie einen polynomiellen Verifier hat.
|
||||
|
||||
### Definition von NP
|
||||
|
||||
$$\text{NP} = \text{die Klasse aller Sprachen mit polynomiellen Verifizierern}$$
|
||||
|
||||
**Äquivalente Definition über NTMs:**
|
||||
|
||||
**Theorem:** Eine Sprache ist in NP genau dann, wenn sie von einer **nichtdeterministischen polynomialzeit-TM** entschieden wird.
|
||||
|
||||
$$\text{NP} = \bigcup_k \text{NTIME}(n^k)$$
|
||||
|
||||
### Kernunterschied P vs. NP
|
||||
|
||||
- **P** = Klasse der Sprachen, deren Mitgliedschaft schnell **entschieden** werden kann.
|
||||
- **NP** = Klasse der Sprachen, deren Mitgliedschaft schnell **verifiziert** werden kann (gegeben ein passendes Zertifikat).
|
||||
|
||||
### Beispiele: Welche Mengen liegen in NP?
|
||||
|
||||
| Menge | In NP? | Begründung |
|
||||
|---|---|---|
|
||||
| $\{p + q \mid p, q \in \mathbb{P}\}$ | Ja | Zertifikat: die beiden Primzahlen $p, q$; Verifikation: Summe prüfen + Primzahltests |
|
||||
| $\{p \cdot q \mid p, q \in \mathbb{P}\}$ | Ja | Zertifikat: die beiden Primfaktoren; Verifikation: Produkt prüfen + Primzahltests |
|
||||
| $\{n \in \mathbb{N} \mid n \neq p \cdot q, \; p,q \in \mathbb{P}\}$ (Primzahlen) | Ja | Zertifikat: $n$ selbst (bzw. AKS-Test); da $\mathbb{P} \in \text{P} \subseteq \text{NP}$ |
|
||||
| $\text{SAT}$ (erfüllbare Boolesche Formeln) | Ja | Zertifikat: eine erfüllende Belegung; Verifikation: Formel auswerten |
|
||||
| $\text{UNSAT}$ (unerfüllbare Boolesche Formeln) | Unklar | Kein offensichtliches kurzes Zertifikat; vermutlich nicht in NP (liegt in co-NP) |
|
||||
|
||||
---
|
||||
|
||||
## 10. P vs. NP
|
||||
|
||||
### Die offene Frage
|
||||
|
||||
Es ist unbekannt, ob $\text{P} = \text{NP}$ oder $\text{P} \subsetneq \text{NP}$ gilt.
|
||||
|
||||
- Falls $\text{P} = \text{NP}$: Jedes Problem, dessen Lösung effizient überprüfbar ist, wäre auch effizient lösbar.
|
||||
- Falls $\text{P} \neq \text{NP}$: Es gibt Probleme, die effizient überprüfbar, aber nicht effizient lösbar sind.
|
||||
|
||||
Die meisten Informatiker vermuten $\text{P} \neq \text{NP}$.
|
||||
|
||||
### Millennium-Problem
|
||||
|
||||
Das P-vs-NP-Problem ist eines der sieben **Millennium-Probleme** des Clay Mathematics Institute, ausgelobt im Jahr 2000, mit einem Preisgeld von **1 Million US-Dollar** für eine Lösung. Von den sieben Problemen wurde bisher nur die **Poincaré-Vermutung** gelöst (Perelman, 2003).
|
||||
|
||||
---
|
||||
|
||||
## 11. NP-Vollständigkeit und Reduktionen
|
||||
|
||||
### Polynomialzeit-berechenbare Funktion
|
||||
|
||||
Eine Funktion $f: \Sigma^* \rightarrow \Sigma^*$ heißt **polynomialzeit-berechenbar** (polynomial time computable function), wenn eine polynomialzeit-TM $M$ existiert, die bei Eingabe $w$ mit $f(w)$ auf dem Band hält.
|
||||
|
||||
### Polynomialzeit-Reduktion
|
||||
|
||||
Eine Sprache $A$ ist **polynomialzeit-reduzierbar** auf Sprache $B$ (geschrieben $A \leq_P B$), wenn eine polynomialzeit-berechenbare Funktion $f: \Sigma^* \rightarrow \Sigma^*$ existiert, sodass für alle $w$ gilt:
|
||||
|
||||
$$w \in A \iff f(w) \in B$$
|
||||
|
||||
Die Funktion $f$ heißt **Polynomialzeit-Reduktion** von $A$ auf $B$.
|
||||
|
||||
Intuition: Wenn $A \leq_P B$, dann ist $B$ **mindestens so schwer** wie $A$. Wenn ich $B$ lösen kann, kann ich auch $A$ lösen (indem ich erst $f$ anwende und dann den Algorithmus für $B$ benutze).
|
||||
|
||||
### NP-Vollständigkeit (NP-completeness)
|
||||
|
||||
Eine Sprache $B$ ist **NP-vollständig**, wenn zwei Bedingungen erfüllt sind:
|
||||
|
||||
1. $B \in \text{NP}$ (das Problem liegt in NP), **und**
|
||||
2. Jede Sprache $A \in \text{NP}$ ist polynomialzeit-reduzierbar auf $B$ (d.h. $A \leq_P B$ für alle $A \in \text{NP}$).
|
||||
|
||||
### NP-hard (NP-schwer)
|
||||
|
||||
Wenn $B$ nur die **zweite Bedingung** erfüllt (jedes Problem aus NP ist auf $B$ reduzierbar), aber $B$ nicht notwendigerweise selbst in NP liegt, heißt $B$ **NP-hard**.
|
||||
|
||||
### Beziehung im Venn-Diagramm
|
||||
|
||||
- $\text{P} \subseteq \text{NP} \subseteq \text{NP-hard}$ (als Inklusionskette)
|
||||
- $\text{NP-complete} = \text{NP} \cap \text{NP-hard}$ (die Schnittmenge)
|
||||
|
||||
Wenn man ein NP-hardes Problem effizient lösen könnte, könnte man damit **jedes** Problem in NP effizient lösen.
|
||||
|
||||
### Cook-Levin-Theorem
|
||||
|
||||
**Theorem (Cook 1971, Levin 1973):** $\text{SAT}$ ist **NP-vollständig**.
|
||||
|
||||
$$\text{SAT} = \{\langle \phi \rangle \mid \phi \text{ ist eine erfüllbare Boolesche Formel}\}$$
|
||||
|
||||
**Konsequenz:** $\text{SAT} \in \text{P} \iff \text{P} = \text{NP}$.
|
||||
|
||||
Das Cook-Levin-Theorem war das erste Resultat, das die Existenz NP-vollständiger Probleme nachwies. Es zeigt: SAT ist das „universelle" Problem in NP — wenn man SAT in Polynomialzeit lösen könnte, wären alle NP-Probleme in Polynomialzeit lösbar.
|
||||
|
||||
---
|
||||
|
||||
## 12. Die Landschaft der Komplexitätsklassen (Überblick)
|
||||
|
||||
Die Vorlesung zeigte das „Landscape of Computational Complexity" (University at Buffalo, 2008), das die Hierarchie der Komplexitätsklassen visualisiert:
|
||||
|
||||
- **REG** ⊂ **L** ⊂ **NL** ⊂ **P** ⊂ **NP** ⊂ **PSPACE** ⊂ **EXP** ⊂ **NEXP** ⊂ **EXPSPACE**
|
||||
- Auf der anderen Seite die **Arithmetische Hierarchie**: REC ⊂ RE, co-RE, und darüber TOT und höhere Stufen
|
||||
- **Complexity Zoo**: Eine Sammlung von über 545 Komplexitätsklassen (gepflegt von Scott Aaronson u.a.)
|
||||
|
||||
Wichtige offene Fragen umfassen unter anderem: P ≠ NP, L ≠ NL, NP ≠ co-NP, P ≠ PSPACE, und viele weitere Separierungen.
|
||||
|
||||
---
|
||||
|
||||
## Glossar der wichtigsten Begriffe
|
||||
|
||||
| Begriff | Definition |
|
||||
|---|---|
|
||||
| **Turing-Maschine (TM)** | Abstraktes Berechnungsmodell mit unendlichem Band, endlicher Steuerung und Lese-/Schreibkopf |
|
||||
| **Konfiguration** | Momentaufnahme einer TM: Zustand + Bandinhalt + Kopfposition |
|
||||
| **Church-Turing-These** | Jede effektiv berechenbare Funktion ist Turing-berechenbar |
|
||||
| **Multitape TM** | TM mit mehreren Bändern; äquivalent zur Single-Tape TM |
|
||||
| **Universelle TM** | TM, die jede andere TM simulieren kann (über deren Gödelnummer) |
|
||||
| **Gödelnummer** | Binäre Kodierung einer Turing-Maschine |
|
||||
| **NTM** | Nichtdeterministische TM; Übergangsfunktion liefert Menge von Möglichkeiten |
|
||||
| **Zeitkomplexität** | Maximale Schrittzahl einer TM auf Eingaben der Länge $n$ |
|
||||
| **Time constructible** | Funktion $t(n)$, deren Wert in $O(t(n))$ Schritten berechnet werden kann |
|
||||
| **Turing-erkennbar** | TM akzeptiert alle $w \in L$, kann aber auf $w \notin L$ endlos laufen |
|
||||
| **Turing-entscheidbar** | TM akzeptiert alle $w \in L$ und lehnt alle $w \notin L$ ab (hält immer) |
|
||||
| **Halteproblem** | Frage, ob eine TM auf einer Eingabe hält; unentscheidbar |
|
||||
| **Diagonalisierung** | Beweistechnik: Konstruktion eines Widerspruchs durch Selbstreferenz |
|
||||
| **PCP** | Postsches Korrespondenzproblem; unentscheidbar, aber semi-entscheidbar |
|
||||
| **P** | Klasse der in Polynomialzeit deterministisch entscheidbaren Sprachen |
|
||||
| **NP** | Klasse der in Polynomialzeit verifizierbaren Sprachen |
|
||||
| **Verifier** | Algorithmus, der bei Eingabe $(w, c)$ die Mitgliedschaft von $w$ in $L$ prüft |
|
||||
| **Polynomialzeit-Reduktion** | Transformation $A \leq_P B$: $w \in A \iff f(w) \in B$ mit $f$ in Polynomialzeit |
|
||||
| **NP-vollständig** | In NP + jedes NP-Problem ist darauf reduzierbar |
|
||||
| **NP-hard** | Jedes NP-Problem ist darauf reduzierbar (muss nicht selbst in NP sein) |
|
||||
| **SAT** | Erfüllbarkeitsproblem für Boolesche Formeln; erstes nachgewiesenes NP-vollständiges Problem |
|
||||
| **Cook-Levin-Theorem** | SAT ist NP-vollständig; SAT ∈ P ⟺ P = NP |
|
||||
227
Komplexitätstheorie/zusammenfassungen/ko2 - zusammenfassung.md
Normal file
227
Komplexitätstheorie/zusammenfassungen/ko2 - zusammenfassung.md
Normal file
|
|
@ -0,0 +1,227 @@
|
|||
# KO2 – NP-Vollständigkeit, Space Complexity & PSPACE
|
||||
**Vorlesung:** Prof. Dr. Björn Grohmann, HWR Berlin
|
||||
**Datum:** 25.02.2026
|
||||
**Folien:** 72–106
|
||||
|
||||
---
|
||||
## 1. Hamiltonian Circuit Problem
|
||||
|
||||
Das **Hamiltonian Circuit Problem** fragt für einen ungerichteten Graphen, ob ein Rundweg (Hamiltonkreis) existiert, der **jeden Knoten genau einmal** besucht und zum Ausgangspunkt zurückkehrt.
|
||||
|
||||
Das Problem ist **NP-vollständig**, und zwar bereits dann, wenn der Graph **planar** (d.h. in der Ebene darstellbar ohne Kantenkreuzungen) und **3-regulär** (jeder Knoten hat genau 3 Nachbarn) ist.
|
||||
|
||||
### Reduktion von SAT auf Hamiltonian Circuit
|
||||
|
||||
Die NP-Vollständigkeit wird durch eine Konstruktion gezeigt, die eine aussagenlogische Formel in einen Graphen übersetzt. Der konstruierte Graph besitzt genau dann einen Hamiltonkreis, wenn die zugehörige Formel erfüllbar ist.
|
||||
|
||||
**Beispielformel:**
|
||||
$$F = (x \lor y \lor z) \land (\bar{x} \lor \bar{y} \lor w) \land (y \lor \bar{z} \lor \bar{w})$$
|
||||
|
||||
**Konstruktionselemente:**
|
||||
|
||||
- **Variablenpfade:** Der linke Weg steht für „wahr", der rechte Weg für „falsch". Ein XOR-Gadget stellt sicher, dass genau einer der beiden Wege zum Pfad gehört.
|
||||
- **Klausel-Gadgets (OR):** Mindestens eines der drei Literale muss „wahr" sein.
|
||||
- **Kreuzungs-Gadgets:** Sorgen dafür, dass sich Kanten des Graphen nicht kreuzen (Planarität).
|
||||
|
||||
---
|
||||
## 2. Graph-Gadgets im Detail
|
||||
|
||||
### Tutte Fragment
|
||||
|
||||
Ein spezielles planares Graphfragment mit drei Anschlüssen. Es hat die Eigenschaft, dass ein Hamiltonpfad durch das Fragment stets durch **genau einen** der drei Anschlüsse ein- und austritt. Es wird als Symbol mit einem Pfeil in einem Kreis dargestellt. Es gibt genau **6 mögliche Wege** durch das Fragment.
|
||||
|
||||
### Exclusive-OR (XOR) Gadget
|
||||
|
||||
Wird aus zwei Tutte-Fragmenten konstruiert. Verbindet zwei Pfade (v→v' und u→u') so, dass ein Hamiltonpfad **genau einen** der beiden Wege nutzen kann, nicht beide. Die zwei möglichen Wege entsprechen den zwei Wahrheitswerten einer Variable.
|
||||
|
||||
### Kreuzungs-Gadget (Crossing)
|
||||
|
||||
Ermöglicht es, zwei sich kreuzende Kanten planar darzustellen. Wird aus mehreren XOR-Gadgets zusammengesetzt. Hat vier Anschlüsse und erlaubt vier mögliche Wegkombinationen, die den beiden unabhängigen Durchquerungsrichtungen entsprechen.
|
||||
|
||||
### OR-Gadget
|
||||
|
||||
Verbindet zwei Pfade (v→v' und u→u') so, dass **mindestens einer** der beiden Wege durchlaufen werden muss. Es gibt insgesamt 5 mögliche Wege (alle Kombinationen außer „keiner").
|
||||
|
||||
### Triple-OR-Gadget
|
||||
|
||||
Erweitert das OR-Gadget auf drei Eingänge (u→u', v→v', w→w'). Mindestens einer der drei Wege muss durchlaufen werden. Wird für 3-SAT-Klauseln mit drei Literalen benötigt.
|
||||
|
||||
---
|
||||
## 3. MINESWEEPER ist NP-vollständig
|
||||
|
||||
Die NP-Vollständigkeit von Minesweeper wird gezeigt, indem man logische Schaltkreise innerhalb eines Minesweeper-Spielfelds simuliert.
|
||||
|
||||
### Grundidee
|
||||
|
||||
In einem Minesweeper-Feld können Zellen entweder Minen enthalten oder nicht. Die Zahlen in aufgedeckten Zellen geben an, wie viele Minen sich in den benachbarten Zellen befinden. Man nutzt Variablen x und x' (Komplement), wobei x=Mine und x'=keine Mine (oder umgekehrt) einer Wahrheitsbelegung entspricht.
|
||||
|
||||
### Bausteine der Reduktion
|
||||
|
||||
- **Wire (Draht):** Ein horizontales Muster aus 5 Zeilen, in dem sich x und x' abwechseln. Die Randbedingungen (Zahlen 0 und 1) erzwingen, dass der Wahrheitswert konsistent entlang des Drahtes weitergeleitet wird.
|
||||
- **NOT-Gate:** Invertiert den Wahrheitswert eines Drahtes. Nutzt ein Muster mit Zahlen 2, 3 und Pflichtminen (*), sodass aus x am Eingang x' am Ausgang wird.
|
||||
- **Phase-Changer:** Besteht aus zwei NOT-Gates hintereinander. Verschiebt die Phase des Signals, ohne den Wahrheitswert zu ändern.
|
||||
- **Wire Crossing:** Ermöglicht es, zwei Drähte zu kreuzen, ohne dass ihre Signale interferieren. Wird mit drei XOR-Gates realisiert.
|
||||
- **XOR-Gate:** Kann aus AND- und NOT-Gates zusammengebaut werden (Standardkonstruktion: $A \oplus B = (A \land \lnot B) \lor (\lnot A \land B)$, äquivalent mittels NAND-Darstellung).
|
||||
- **AND-Gate:** Ein komplexes Muster (Figure 13), das zwei Eingangsdrähte U und V mit einem Ausgangsdraht T verbindet. Enthält feste Minen (*) und variable Zellen, deren Belegung durch die Zahlenbedingungen erzwungen wird.
|
||||
|
||||
### Gesamtargumentation
|
||||
|
||||
Da man mit Wires, NOT, AND (und daraus abgeleitet OR, XOR) beliebige Boolesche Schaltkreise bauen kann, lässt sich jede SAT-Instanz als Minesweeper-Konfiguration kodieren. Die Frage „Gibt es eine konsistente Minenbelegung?" entspricht der Frage „Ist die Formel erfüllbar?". Da SAT NP-vollständig ist, ist auch Minesweeper NP-vollständig.
|
||||
|
||||
---
|
||||
|
||||
## 4. „Gaming is Hard" – NP-Härte von Videospielen
|
||||
|
||||
### Metatheorem 1: Location Traversal + Single-Use Paths
|
||||
|
||||
Jedes Spiel, das **Location Traversal** (bestimmte Punkte müssen erreicht werden) und **Single-Use Paths** (Wege können nur einmal benutzt werden) aufweist, ist **NP-hard**.
|
||||
|
||||
**Beweisskizze:** Man baut einen Level, der einen planaren, 3-regulären Graphen darstellt. Die Knoten sind die Punkte, die besucht werden müssen. Jede Kante ist ein Single-Use Path. Ein zusätzlicher Endpunkt wird mit dem Startknoten verbunden. Der Level ist genau dann lösbar, wenn ein Hamiltonkreis existiert.
|
||||
|
||||
### Metatheorem 2: Tokens, Toll Roads, Location Traversal
|
||||
|
||||
Ein Spiel ist **NP-hard**, wenn eine der folgenden Bedingungen gilt:
|
||||
|
||||
- **(a)** Das Spiel hat **collectible tokens**, toll roads und location traversal.
|
||||
- **(b)** Das Spiel hat **cumulative tokens**, toll roads und location traversal. (Spieler startet mit n+1 tokens.)
|
||||
- **(c)** Das Spiel hat collectible cumulative tokens, **toll roads**, und der Avatar muss einen Ausgang erreichen. (2 tokens pro Punkt, jede Kante ist eine toll road, die Kante zwischen Start und Ende ist eine Sequenz von n toll roads.)
|
||||
|
||||
**Beispiel:** Pac-Man – Power Pills sind tokens, Geisterkorridore sind toll roads.
|
||||
|
||||
### Metatheorem 3: Keys, Doors, One-Way Paths
|
||||
|
||||
Ein Spiel ist **NP-hard**, wenn es **doors** und **one-way paths** enthält und eine der folgenden Bedingungen gilt:
|
||||
|
||||
- **(a)** Collectible keys und location traversal.
|
||||
- **(b)** Cumulative keys und location traversal.
|
||||
- **(c)** Collectible cumulative keys und der Avatar muss einen Ausgang erreichen.
|
||||
|
||||
Funktioniert genau wie Metatheorem 2, wobei keys = tokens und doors = toll roads.
|
||||
|
||||
### Metatheorem 4: Doors + Pressure Plates
|
||||
|
||||
Wenn ein Spiel **doors** und **pressure plates** (Druckplatten, die Türen öffnen oder schließen) enthält und der Avatar einen Ausgang erreichen muss, dann ist das Spiel **NP-hard** – selbst wenn keine zwei Druckplatten dieselbe Tür steuern.
|
||||
|
||||
**Konstruktion:** Wie bei MT 1, aber vor dem Ausgang befinden sich n Türen, die jeweils durch eine Druckplatte bei einem der Punkte geöffnet werden müssen. Single-Use Paths werden durch Druckplatten realisiert, die beim zweiten Durchgang den Weg versperren.
|
||||
|
||||
### Metatheorem 5: Doors + k-Buttons
|
||||
|
||||
Buttons sind wie Druckplatten, aber der Spieler kann **entscheiden**, ob er den Button drückt. Ein k-Button beeinflusst k Türen gleichzeitig.
|
||||
|
||||
Wenn ein Spiel **doors** und **k-buttons** enthält und der Avatar einen Ausgang erreichen muss, dann ist das Spiel **NP-hard** für $k \geq 2$.
|
||||
|
||||
---
|
||||
## 5. Übersicht NP-vollständiger Probleme
|
||||
|
||||
Alle folgenden Probleme sind NP-vollständig und liegen damit in der Schnittmenge von NP und NP-hard:
|
||||
|
||||
- **SAT** (Erfüllbarkeitsproblem aussagenlogischer Formeln)
|
||||
- **Hamiltonkreis**
|
||||
- **Traveling Salesman Problem (TSP)**
|
||||
- **Knapsack** (Rucksackproblem)
|
||||
- **MINESWEEPER**
|
||||
- und viele weitere (Karp's Liste mit 21 Problemen)
|
||||
|
||||
### Karp's Liste (1972)
|
||||
|
||||
Richard Karp bewies 1972, dass 21 Probleme NP-vollständig sind, ausgehend von SAT. Die Reduktionskette verläuft u.a.:
|
||||
|
||||
SATISFIABILITY → CLIQUE → NODE COVER → {FEEDBACK NODE SET, FEEDBACK ARC SET, DIRECTED HAMILTON CIRCUIT → UNDIRECTED HAMILTON CIRCUIT}
|
||||
|
||||
SATISFIABILITY → 0-1 INTEGER PROGRAMMING → SET PACKING → SET COVERING
|
||||
|
||||
SATISFIABILITY WITH AT MOST 3 LITERALS PER CLAUSE → CHROMATIC NUMBER → {EXACT COVER → {3-DIMENSIONAL MATCHING, KNAPSACK → {SEQUENCING, PARTITION → MAX CUT}}, HITTING SET, STEINER TREE, CLIQUE COVER}
|
||||
|
||||
---
|
||||
## 6. Space Complexity
|
||||
|
||||
### Definition
|
||||
|
||||
Die **Speicherkomplexität (Space Complexity)** einer deterministischen Turingmaschine M ist die Funktion $f: \mathbb{N} \to \mathbb{N}$, wobei $f(n)$ die **maximale Anzahl an Bandzellen** ist, die M auf irgendeiner Eingabe der Länge n besucht.
|
||||
|
||||
Für eine **nichtdeterministische** Turingmaschine ist $f(n)$ die maximale Anzahl an Bandzellen, die M auf **irgendeinem Berechnungspfad** für eine Eingabe der Länge n besucht.
|
||||
|
||||
**Anmerkung:** In der Literatur wird manchmal angenommen, dass die TM ein separates Eingabe- und Arbeitsband besitzt und nur die Zellen auf dem Arbeitsband gezählt werden.
|
||||
|
||||
### Speicherkomplexitätsklassen
|
||||
|
||||
$$\text{SPACE}(f(n)) = {L \mid L \text{ wird von einer det. TM in } O(f(n)) \text{ Speicher entschieden}}$$
|
||||
|
||||
$$\text{NSPACE}(f(n)) = {L \mid L \text{ wird von einer nichtdet. TM in } O(f(n)) \text{ Speicher entschieden}}$$
|
||||
|
||||
---
|
||||
## 7. Savitch's Theorem
|
||||
|
||||
**Satz (Savitch):** Für jede Funktion $f: \mathbb{N} \to \mathbb{R}^+$ mit $f(n) \geq n$ gilt:
|
||||
|
||||
$$\text{NSPACE}(f(n)) \subseteq \text{SPACE}(f^2(n))$$
|
||||
|
||||
Der Satz gilt auch für $f(n) \geq \log(n)$.
|
||||
|
||||
### Beweisskizze
|
||||
|
||||
Gegeben eine nichtdeterministische TM N, die Sprache A mit Speicher $f(n)$ entscheidet, konstruieren wir eine deterministische TM M, die A in $O(f(n)^2)$ Speicher entscheidet:
|
||||
|
||||
**Kernidee – CANYIELD-Prozedur:**
|
||||
CANYIELD$(c_1, c_2, t)$ entscheidet, ob Konfiguration $c_2$ von Konfiguration $c_1$ in $t$ Schritten erreicht werden kann.
|
||||
|
||||
- **Basisfall** ($t=1$): Prüfe direkt, ob $c_1 = c_2$ oder ob $c_1$ in einem Schritt zu $c_2$ führt.
|
||||
- **Rekursion** ($t > 1$): Für jede mögliche Zwischenkonfiguration $c_m$: Prüfe CANYIELD$(c_1, c_m, t/2)$ und CANYIELD$(c_m, c_2, t/2)$.
|
||||
|
||||
**Speicheranalyse:**
|
||||
|
||||
- Jede Rekursionsebene benötigt $O(f(n))$ Speicher (für die Zwischenkonfiguration).
|
||||
- Die Rekursionstiefe beträgt $O(\log t)$, wobei $t \leq 2^{d \cdot f(n)}$ für eine Konstante d.
|
||||
- Gesamtspeicher: $O(f(n)) \cdot O(\log t) = O(f(n)) \cdot O(f(n)) = O(f(n)^2)$.
|
||||
|
||||
Da $f(n)$ zu Beginn nicht bekannt ist, testet M nacheinander $f(n) = 1, 2, 3, \ldots$
|
||||
|
||||
---
|
||||
## 8. PSPACE
|
||||
|
||||
### Definition
|
||||
|
||||
**PSPACE** ist die Klasse aller Sprachen, die von einer deterministischen Turingmaschine in **polynomiellem Speicher** entschieden werden können:
|
||||
|
||||
$$\text{PSPACE} = \bigcup_k \text{SPACE}(n^k)$$
|
||||
|
||||
### Beziehung zwischen Zeit- und Speicherkomplexität
|
||||
|
||||
$$P \subseteq NP \subseteq PSPACE = NPSPACE \subseteq EXPTIME = \bigcup_k \text{TIME}(2^{n^k})$$
|
||||
|
||||
Die Gleichheit $\text{PSPACE} = \text{NPSPACE}$ folgt aus Savitch's Theorem (quadratischer Blow-up bei der Speicherkomplexität ist polynomiell).
|
||||
|
||||
---
|
||||
## 9. PSPACE-Vollständigkeit
|
||||
|
||||
### Definition
|
||||
|
||||
Eine Sprache B ist **PSPACE-complete**, wenn:
|
||||
|
||||
1. $B \in \text{PSPACE}$
|
||||
2. Jedes $A \in \text{PSPACE}$ ist in polynomieller Zeit auf B reduzierbar.
|
||||
|
||||
Erfüllt B nur Bedingung 2, heißt B **PSPACE-hard**.
|
||||
|
||||
### TQBF ist PSPACE-vollständig
|
||||
|
||||
$$TQBF = {\langle \phi \rangle \mid \phi \text{ ist eine wahre, voll quantifizierte Boolesche Formel}}$$
|
||||
|
||||
**Theorem:** TQBF ist PSPACE-complete.
|
||||
|
||||
Eine voll quantifizierte Boolesche Formel hat die Form $\forall x_1 \exists x_2 \forall x_3 \ldots \phi(x_1, x_2, x_3, \ldots)$, wobei alle Variablen gebunden sind. TQBF fragt, ob eine solche Formel wahr ist.
|
||||
|
||||
TQBF verallgemeinert SAT: Während SAT nur Existenzquantoren hat ($\exists x_1 \exists x_2 \ldots$: „Gibt es eine erfüllende Belegung?"), erlaubt TQBF auch Allquantoren. Diese Erweiterung macht das Problem härter – von NP-vollständig zu PSPACE-vollständig.
|
||||
|
||||
---
|
||||
## Zusammenfassung der Komplexitätsklassen
|
||||
|
||||
|Klasse|Beschreibung|Beispiel|
|
||||
|---|---|---|
|
||||
|**P**|Deterministisch in polynomieller Zeit lösbar|Sortieren, kürzeste Wege|
|
||||
|**NP**|Nichtdeterministisch in polynomieller Zeit lösbar (Lösung in Polynomialzeit verifizierbar)|SAT, Hamiltonkreis, TSP, Knapsack, Minesweeper|
|
||||
|**PSPACE**|Deterministisch in polynomiellem Speicher lösbar|TQBF|
|
||||
|**EXPTIME**|Deterministisch in exponentieller Zeit lösbar|Generalisiertes Schach|
|
||||
|**NP-hard**|Mindestens so schwer wie jedes Problem in NP|Alle NP-vollständigen Probleme + weitere|
|
||||
|**NP-vollständig**|In NP und NP-hard|SAT, Hamiltonkreis, TSP, Knapsack, Minesweeper|
|
||||
|**PSPACE-vollständig**|In PSPACE und PSPACE-hard|TQBF|
|
||||
381
Komplexitätstheorie/zusammenfassungen/ko3 - zusammenfassung.md
Normal file
381
Komplexitätstheorie/zusammenfassungen/ko3 - zusammenfassung.md
Normal file
|
|
@ -0,0 +1,381 @@
|
|||
# Komplexitätstheorie – Zusammenfassung
|
||||
|
||||
**Prof. Dr. Björn Grohmann – Hochschule für Wirtschaft und Recht Berlin**
|
||||
|
||||
-----
|
||||
|
||||
## 1. True Quantified Boolean Formulas (TQBF)
|
||||
|
||||
### 1.1 Definition
|
||||
|
||||
Eine **True Quantified Boolean Formula (TQBF)** ist eine vollständig quantifizierte Boolesche Formel, d.h. eine Boolesche Formel, in der **jede Variable** durch einen Existenz- ($\exists$) oder Allquantor ($\forall$) gebunden ist. Die Formel hat keinen freien Variablen und evaluiert daher zu einem festen Wahrheitswert (wahr oder falsch).
|
||||
|
||||
**Beispiel:**
|
||||
|
||||
$$\forall x , \exists y , (x \lor y) \land (\neg x \lor \neg y)$$
|
||||
|
||||
Das Entscheidungsproblem TQBF fragt: *Ist eine gegebene vollständig quantifizierte Boolesche Formel wahr?*
|
||||
|
||||
### 1.2 TQBF ist PSPACE-vollständig
|
||||
|
||||
Die Vorlesung zeigt zwei zentrale Aussagen:
|
||||
|
||||
**1) TQBF ist in PSPACE:**
|
||||
TQBF kann mit polynomiellem Speicher entschieden werden. Die Idee ist, die Formel rekursiv auszuwerten: Für jeden Quantor wird die entsprechende Variable nacheinander auf *wahr* und *falsch* gesetzt und rekursiv weitergerechnet. Da die Rekursionstiefe linear in der Anzahl der Variablen ist und jeder Rekursionslevel nur konstanten Zusatzspeicher benötigt, liegt der Gesamtverbrauch in $O(n)$ Speicher.
|
||||
|
||||
**2) Jede Sprache in PSPACE ist auf TQBF reduzierbar (PSPACE-Härte):**
|
||||
Für ein Wort $w$ und eine Sprache $A \in \text{PSPACE}$ wird eine QBF konstruiert, die genau dann wahr ist, wenn $w \in A$.
|
||||
|
||||
### 1.3 Die Reduktion im Detail
|
||||
|
||||
#### Grundidee
|
||||
|
||||
Man konstruiert eine Formel $\phi_{c_1, c_2, t}$, die genau dann wahr ist, wenn die Turing-Maschine von der Konfiguration $c_1$ zur Konfiguration $c_2$ in höchstens $t$ Schritten gelangen kann. Die gesuchte Formel ist dann $\phi_{c_{\text{start}}, c_{\text{accept}}, h}$ mit $h = 2^{O(n^k)}$.
|
||||
|
||||
#### Naiver (erster) Ansatz
|
||||
|
||||
$$\phi_{c_1, c_2, t} = \exists m_1 \left[\phi_{c_1, m_1, t/2} \land \phi_{m_1, c_2, t/2}\right]$$
|
||||
|
||||
Hierbei wird eine Zwischenkonfiguration $m_1$ geraten (existenzquantifiziert), über die der Pfad von $c_1$ nach $c_2$ in zwei Hälften aufgeteilt wird. Das Problem: Durch die doppelte Rekursion **verdoppelt** sich die Formelgröße bei jedem Schritt. Da die Rekursionstiefe $O(n^k)$ beträgt, wird die Formel **exponentiell groß** – zu groß für einen polynomiellen Speicherverbrauch.
|
||||
|
||||
#### Verbesserter Ansatz (Savitch-ähnlicher Trick)
|
||||
|
||||
$$\phi_{c_1, c_2, t} = \exists m_1 ; \forall (c_3, c_4) \in {(c_1, m_1), (m_1, c_2)} ; \left[\phi_{c_3, c_4, t/2}\right]$$
|
||||
|
||||
Der entscheidende Unterschied: Anstatt die Formel $\phi$ zweimal hinzuschreiben (einmal für $(c_1, m_1)$ und einmal für $(m_1, c_2)$), wird ein **Allquantor** verwendet, der über die **beiden möglichen Paare** $(c_3, c_4)$ iteriert. Damit wird die Formel nur **einmal** aufgeschrieben.
|
||||
|
||||
**Technisches Detail:** Die Notation $\forall x \in {y, z} [\ldots]$ steht eigentlich für $\forall x \left[(x = y \lor x = z) \rightarrow \ldots\right]$. In der tatsächlichen Formel muss die Mengenzugehörigkeit durch eine **Äquivalenzrelation** in Boolescher Logik ausgedrückt werden.
|
||||
|
||||
#### Größenanalyse
|
||||
|
||||
- Jeder Rekursionslevel vergrößert die Formel um $O(n^k)$ (Kodierung der Konfigurationen).
|
||||
- Die Rekursionstiefe beträgt $O(n^k)$ (da $\log h = O(n^k)$).
|
||||
- Gesamtgröße der Formel: $O(n^{2k})$ – **polynomiell!**
|
||||
|
||||
> **Ergänzung:** Dies ist die Kernidee des Beweises von Savitch’s Theorem angewandt auf die PSPACE-Vollständigkeit von TQBF. Der Allquantor erlaubt es, die exponentielle Aufblähung zu vermeiden, indem dieselbe Teilformel für beide Hälften wiederverwendet wird.
|
||||
|
||||
-----
|
||||
|
||||
## 2. „Gaming is Hard”, Part II – PSPACE-Härte von Spielen
|
||||
|
||||
### 2.1 Metatheorem 4 (Pressure Plates)
|
||||
|
||||
> **Metatheorem 4:** Wenn ein Spiel Türen und Druckplatten enthält und der Avatar einen Ausgang erreichen muss, dann gilt: Wenn jede Tür durch **zwei Druckplatten** gesteuert werden kann, ist das Spiel **PSPACE-hard**.
|
||||
|
||||
### 2.2 Level-Aufbau als TQBF-Simulation
|
||||
|
||||
Ein Level wird konstruiert, der eine TQBF direkt simuliert:
|
||||
|
||||
- **Obere Reihe (Quantoren-Gadgets):** Abwechselnd $\exists x$, $\forall y$, $\exists z$, $\forall w$, …
|
||||
- Der Spieler traversiert diese Gadgets vom Start zum Ende.
|
||||
- **Existenzquantoren** ($\exists$): Der Spieler wählt einen Pfad (oben = true, unten = false). Die Wahl setzt Druckplatten, die Variablenwerte kodieren.
|
||||
- **Allquantoren** ($\forall$): Der Spieler muss **beide** Pfade durchlaufen – d.h., das Spiel erzwingt, dass beide Belegungen getestet werden.
|
||||
- **Untere Reihe (Klausel-Gadgets):** Eine Reihe von Klauseln, die mit Türen realisiert werden.
|
||||
- Jede Klausel prüft, ob die aktuelle Variablenbelegung die Klausel erfüllt.
|
||||
- Die Türen sind durch Druckplatten gesteuert, die von den Quantor-Gadgets gesetzt werden.
|
||||
|
||||
Die Gadgets für die einzelnen Komponenten nutzen Druckplatten zur Kodierung von Variablen an bestimmten Positionen. Die Variable $x$ an der Stelle $i$ wird durch die Position des Spielers und der dadurch aktivierten Druckplatten repräsentiert.
|
||||
|
||||
### 2.3 Metatheorem 5 (k-Buttons)
|
||||
|
||||
> **Metatheorem 5:** Wenn ein Spiel Türen und $k$-Buttons enthält und der Avatar einen Ausgang erreichen muss, dann gilt: Wenn $k \geq 3$, ist das Spiel **PSPACE-hard**.
|
||||
|
||||
### 2.4 Simulation von Druckplatten durch 3-Buttons
|
||||
|
||||
Die Vorlesung zeigt, wie eine Druckplatte mit Hilfe von **3-Buttons** simuliert werden kann. Das Gadget besteht aus vier Zuständen (Startkonfiguration und drei Folgezustände), die durch die Interaktion des Spielers mit den Buttons $a$, $b$, $c$, $d$ durchlaufen werden. Die Buttons steuern die Türen über $\pm x$, $\pm a$, $\pm b$, etc., wobei $+$ für „öffnen” und $-$ für „schließen” steht.
|
||||
|
||||
> **Ergänzung:** Die Ergebnisse stammen aus dem Bereich der **computational complexity of games**. Die Arbeit von Viglietta (2014) und Aloupis et al. formalisiert, welche Spielmechaniken welche Komplexitätsklassen induzieren. Viele klassische Videospiele (z.B. generalisierte Versionen von Sokoban, Zelda, Pokemon) sind nachweislich PSPACE-hard.
|
||||
|
||||
-----
|
||||
|
||||
## 3. Hierarchy Theorems
|
||||
|
||||
### 3.1 Time- und Space-Constructibility
|
||||
|
||||
**Time-constructible:**
|
||||
Eine Funktion $t: \mathbb{N} \to \mathbb{N}$ mit $t(n) \geq O(n \log n)$ heißt **time-constructible**, wenn die Funktion, die den String $1^n$ auf die Binärdarstellung von $t(n)$ abbildet, in Zeit $O(t(n))$ berechenbar ist.
|
||||
|
||||
**Space-constructible:**
|
||||
Eine Funktion $f: \mathbb{N} \to \mathbb{N}$ mit $f(n) \geq O(\log n)$ heißt **space-constructible**, wenn die Funktion, die den String $1^n$ auf die Binärdarstellung von $f(n)$ abbildet, in Platz $O(f(n))$ berechenbar ist.
|
||||
|
||||
> **Ergänzung:** Die meisten „natürlichen” Funktionen wie $n$, $n^2$, $n \log n$, $2^n$ sind sowohl time- als auch space-constructible. Diese Bedingung ist nötig, damit die Maschine „weiß”, wie viel Ressourcen sie zur Verfügung hat, und einen Zähler korrekt setzen kann.
|
||||
|
||||
### 3.2 Space Hierarchy Theorem
|
||||
|
||||
> **Theorem (Space Hierarchy):** Für jede space-constructible Funktion $f: \mathbb{N} \to \mathbb{N}$ existiert eine Sprache $A$, die in $O(f(n))$ Speicher entscheidbar ist, aber **nicht** in $o(f(n))$ Speicher.
|
||||
|
||||
#### Beweis (Skizze)
|
||||
|
||||
Der Algorithmus $D$ entscheidet eine Sprache $A$ wie folgt:
|
||||
|
||||
1. Sei $n$ die Länge der Eingabe $w$.
|
||||
2. Berechne $f(n)$ mittels Space-Constructibility und markiere genau so viel Band. Falls spätere Stufen mehr Platz benötigen, **reject**.
|
||||
3. Falls $w$ nicht die Form $\langle M \rangle 10^*$ hat (für eine TM $M$), **reject**.
|
||||
4. Simuliere $M$ auf $w$ und zähle die Schritte. Falls der Zähler $2^{f(n)}$ überschreitet, **reject**.
|
||||
5. Falls $M$ akzeptiert, **reject**. Falls $M$ ablehnt, **accept** (Diagonalisierung!).
|
||||
|
||||
**Warum funktioniert das?** Angenommen, eine Maschine $M$ entscheidet $A$ mit $g(n)$ Speicher, wobei $g(n) \in o(f(n))$. Dann gibt es ein $n$, ab dem $D$ die Maschine $M$ korrekt simulieren kann (der Platz reicht aus). Aber $D$ tut dann das Gegenteil von $M$ – **Widerspruch**.
|
||||
|
||||
#### Korollare
|
||||
|
||||
- Für beliebige reelle Zahlen $0 \leq \epsilon_1 < \epsilon_2$: $\text{SPACE}(n^{\epsilon_1}) \subsetneq \text{SPACE}(n^{\epsilon_2})$.
|
||||
- $\text{PSPACE} \subsetneq \text{EXPSPACE} = \bigcup_k \text{SPACE}(2^{n^k})$.
|
||||
|
||||
> **Ergänzung:** Das Space Hierarchy Theorem zeigt, dass mehr Speicher echt mehr Sprachen entscheidbar macht. Die Lücke ist dabei schärfer als beim Time Hierarchy Theorem, da kein logarithmischer Faktor benötigt wird. Dies liegt daran, dass die Simulation einer TM bezüglich des Platzes effizienter ist als bezüglich der Zeit.
|
||||
|
||||
### 3.3 Time Hierarchy Theorem
|
||||
|
||||
> **Theorem (Time Hierarchy):** Für jede time-constructible Funktion $t: \mathbb{N} \to \mathbb{N}$ existiert eine Sprache $A$, die in $O(t(n))$ Zeit entscheidbar ist, aber **nicht** in Zeit $o(t(n) / \log t(n))$.
|
||||
|
||||
#### Beweis (Skizze)
|
||||
|
||||
Der Algorithmus $D$ ist analog zum Space Hierarchy Theorem aufgebaut:
|
||||
|
||||
1. Sei $n$ die Länge der Eingabe $w$.
|
||||
2. Berechne $t(n)$ mittels Time-Constructibility und speichere den Wert $\lfloor t(n) / \log t(n) \rfloor$ in einem Binärzähler. Dekrementiere diesen Zähler vor jedem Schritt der Stufen 3, 4 und 5. Falls der Zähler 0 erreicht, **reject**.
|
||||
3. Falls $w$ nicht die Form $\langle M \rangle 10^*$ hat, **reject**.
|
||||
4. Simuliere $M$ auf $w$.
|
||||
5. Falls $M$ akzeptiert, **reject**. Falls $M$ ablehnt, **accept**.
|
||||
|
||||
**Warum der log-Faktor?** Das Counter-Update kostet pro Simulationsschritt jeweils $O(\log t(n))$, da der Binärzähler $\log t(n)$ Bits hat. Die Gesamtlaufzeit von $D$ beträgt also $\lfloor t(n) / \log t(n) \rfloor \cdot O(\log t(n)) = O(t(n))$.
|
||||
|
||||
#### Korollare
|
||||
|
||||
- Für beliebige reelle Zahlen $1 \leq \epsilon_1 < \epsilon_2$: $\text{TIME}(n^{\epsilon_1}) \subsetneq \text{TIME}(n^{\epsilon_2})$.
|
||||
- $\text{P} \subsetneq \text{EXPTIME}$.
|
||||
|
||||
> **Ergänzung:** Die strenge Inklusion $\text{P} \subsetneq \text{EXPTIME}$ ist eines der wenigen **bewiesenen** Separationsresultate in der Komplexitätstheorie. Im Gegensatz dazu ist die Frage $\text{P} \stackrel{?}{=} \text{NP}$ nach wie vor offen.
|
||||
|
||||
### 3.4 Warum ist Time-Constructibility notwendig?
|
||||
|
||||
Die Voraussetzung der Time-Constructibility ist **essentiell**, wie das folgende Gap Theorem zeigt. Ohne diese Voraussetzung gibt es „pathologische” Funktionen, für die die Hierarchie zusammenbricht.
|
||||
|
||||
-----
|
||||
|
||||
## 4. Gap Theorem (Trakhtenbrot, Borodin)
|
||||
|
||||
> **Theorem (Gap Theorem):** Es existiert eine berechenbare Funktion $f$, sodass $\text{TIME}(f(n)) = \text{TIME}(2^{f(n)})$.
|
||||
|
||||
Das bedeutet: Es gibt eine Funktion $f$, bei der eine **exponentielle Erhöhung** der Zeitschranke **keine zusätzlichen Sprachen** entscheidbar macht!
|
||||
|
||||
### Beweis (Skizze)
|
||||
|
||||
Sei ${M_e}$ eine Aufzählung aller deterministischen TMs. Wir konstruieren $f$ schrittweise, sodass $f$ in jedem Schritt $e$ folgende Bedingung erfüllt:
|
||||
|
||||
$$\forall x \left(|x| = n \land M_e(x) \downarrow \text{ in } t \text{ Schritten} \implies t \notin (f(n), 2^{f(n)}]\right)$$
|
||||
|
||||
**Konstruktion von $f(n)$:**
|
||||
|
||||
Betrachte die Sequenz $k_0 = 0$, $k_{l+1} = 2^{k_l}$. Für alle Berechnungen $M_e(x)$ mit $e \leq n$ (wobei $n = |x|$), die in $t_{e,x}$ Schritten halten, wähle das kleinste $k_l$, sodass **keines** der $t_{e,x}$ im Intervall $(k_l, 2^{k_l}]$ liegt. Setze $f(n) = k_l$.
|
||||
|
||||
**Warum existiert ein solches $k_l$?** Da es nur endlich viele Paare $(e, x)$ mit $e \leq n$ und $|x| = n$ gibt, gibt es auch nur endlich viele Haltezeiten $t_{e,x}$. Die Intervalle $(k_l, 2^{k_l}]$ wachsen schnell genug, um immer eine „Lücke” (gap) zu finden.
|
||||
|
||||
**Konsequenz:** Jede Sprache, die in $\text{TIME}(2^{f(n)})$ liegt, wird von einer TM entschieden, deren Haltezeit **unterhalb** von $f(n)$ liegt (nicht im Intervall dazwischen), also liegt sie automatisch auch in $\text{TIME}(f(n))$.
|
||||
|
||||
> **Ergänzung:** Das Gap Theorem zeigt, dass die Hierarchie-Theoreme die Bedingung der Konstruierbarkeit **wirklich** benötigen. Die Funktion $f$ aus dem Gap Theorem ist typischerweise **nicht** time-constructible. Es handelt sich um ein fundamentales Resultat der abstrakten Komplexitätstheorie (Blum-Axiome).
|
||||
|
||||
-----
|
||||
|
||||
## 5. Speed-Up Theorem (Blum)
|
||||
|
||||
> **Theorem (Speed-Up Theorem, M. Blum):** Es existiert eine berechenbare Menge $A$, sodass es für jeden Index $e$ (d.h. jede TM $M_e$) für $A$ einen anderen Index $i$ für $A$ gibt, sodass:
|
||||
> $$\forall^\infty x ; \left(\Phi_i(x) \leq \log \Phi_e(x)\right)$$
|
||||
|
||||
Dabei ist $\Phi_e(x)$ die Anzahl der Berechnungsschritte von $M_e(x)$ (falls $M_e$ auf $x$ hält), und $\forall^\infty x$ bedeutet „für fast alle $x$” (alle bis auf endlich viele).
|
||||
|
||||
**Bedeutung:** Egal welche TM $M_e$ die Sprache $A$ berechnet – es gibt immer eine **exponentiell schnellere** TM $M_i$, die dasselbe tut. Die Sprache $A$ hat also **keine optimale Berechnung**.
|
||||
|
||||
### Beweis (Skizze)
|
||||
|
||||
#### Hilfsfolge
|
||||
|
||||
Definiere $g(x) = 2^x$, $g^{(1)}(x) = g(x)$, und $g^{(n+1)}(x) = g(g^{(n)}(x))$ (iterierte Exponentiation). Für $x > e + 1$ ist dann $h_e(x) = g^{(x-e)}(0)$ eine **abnehmende Familie** von Funktionen, d.h. $g(h_{e+1}(x)) = h_e(x)$.
|
||||
|
||||
#### Diagonalisierung
|
||||
|
||||
Für jedes $x$ wird $A(x)$ bestimmt, indem für alle $e \leq x$ geprüft wird:
|
||||
|
||||
- Ist $e$ noch nicht markiert („cancelled”)?
|
||||
- Gilt $\Phi_e(x) < h_e(x)$?
|
||||
|
||||
Für das **kleinste** solche $e$ definiere $A(x) = 1 - M_e(x)$ und markiere $e$. (Das ist der Diagonalisierungsschritt: $A$ tut das Gegenteil von $M_e$.)
|
||||
|
||||
#### Konsequenzen
|
||||
|
||||
Damit gilt für jedes $e$: Falls für unendlich viele $x$ gilt $\Phi_e(x) < h_e(x)$, folgt $M_e \neq A$. Anders geschrieben:
|
||||
|
||||
$$\forall e \left(M_e = A \implies \forall^\infty x ; h_e(x) \leq \Phi_e(x)\right)$$
|
||||
|
||||
#### Speed-Up-Eigenschaft
|
||||
|
||||
Um $A(x)$ zu berechnen, lässt man für jedes $e \leq x$ die Maschine $M_e(x)$ für $h_e(x)$ Schritte laufen. Mit Hilfe der endlichen Menge $F_u = {(e, x, A(x)) : e < u \land e \text{ cancelled at stage } x}$ genügt es, dies nur für $u \leq e \leq x$ zu tun.
|
||||
|
||||
Die Berechnung dauert $h_u(x) + \ldots + h_x(x)$ Schritte. Die Laufzeit für die ersten $x$ Stufen ist von oben beschränkt durch $x \cdot (h_u(x) + \ldots + h_x(x)) \leq h_{u-1}(x)$ (für fast alle $x$).
|
||||
|
||||
Da $u$ beliebig groß gewählt werden kann, gilt:
|
||||
$$\forall e ; \exists i \left(M_i = A \land \forall^\infty x ; \Phi_i(x) \leq h_{e+1}(x)\right)$$
|
||||
|
||||
Und damit insgesamt:
|
||||
$$\Phi_i(x) \leq h_{e+1}(x) \leq \log h_e(x) \leq \log \Phi_e(x)$$
|
||||
|
||||
> **Ergänzung:** Das Speed-Up Theorem ist ein tiefliegendes Resultat, das zeigt, dass nicht jede berechenbare Sprache eine „schnellste” Berechnung besitzt. Es steht im Kontext der **Blum-Axiome** der abstrakten Komplexitätstheorie. Die Funktion $h_e$ wächst dabei so schnell (iterierte Exponentiation), dass der Logarithmus von $h_e$ immer noch zu $h_{e+1}$ wird – genau das ermöglicht den exponentiellen Speed-Up.
|
||||
|
||||
-----
|
||||
|
||||
## 6. Orakel-Turingmaschinen
|
||||
|
||||
### Definition
|
||||
|
||||
Ein **Orakel** für eine Sprache $A$ ist ein Gerät, das für jeden String $w$ in **einem einzigen Schritt** berichten kann, ob $w \in A$.
|
||||
|
||||
Eine **Orakel-Turingmaschine** $M^A$ ist eine modifizierte TM mit einem speziellen **Orakelband**: Wann immer $M^A$ einen String auf dieses Band schreibt, erhält sie sofort die Antwort, ob der String in $A$ liegt.
|
||||
|
||||
### Komplexitätsklassen mit Orakeln
|
||||
|
||||
- $\text{P}^A$: Klasse der Sprachen, die von einer **polynomialzeit**-beschränkten Orakel-TM mit Orakel $A$ entschieden werden können.
|
||||
- $\text{NP}^A$: Analog für **nichtdeterministische** polynomialzeit-beschränkte Orakel-TMs.
|
||||
|
||||
> **Ergänzung:** Orakel-TMs sind ein mächtiges Konzept, um die relative Stärke von Komplexitätsklassen zu untersuchen. Intuitiv simuliert das Orakel ein „Unterprogramm” mit beliebiger Mächtigkeit – die Anfrage kostet nur einen einzigen Schritt, unabhängig davon, wie schwer das Orakel-Problem eigentlich ist.
|
||||
|
||||
-----
|
||||
|
||||
## 7. Relativierung
|
||||
|
||||
### Kernfrage
|
||||
|
||||
Kann die Technik der **Relativierung** (Diagonalisierung über Orakel-TMs) dabei helfen, Komplexitätsklassen zu separieren?
|
||||
|
||||
### Theorem (Baker, Gill, Solovay, 1975)
|
||||
|
||||
> 1. Es existiert ein Orakel $A$, sodass $\text{P}^A \neq \text{NP}^A$.
|
||||
> 2. Es existiert ein Orakel $B$, sodass $\text{P}^B = \text{NP}^B$.
|
||||
|
||||
### Beweis von Teil 2
|
||||
|
||||
Wähle $B = \text{TQBF}$. Dann gilt:
|
||||
$$\text{NP}^{\text{TQBF}} \subseteq \text{NPSPACE} \subseteq \text{PSPACE} \subseteq \text{P}^{\text{TQBF}}$$
|
||||
|
||||
Die letzte Inklusion gilt, weil TQBF PSPACE-vollständig ist – eine polynomialzeit Orakel-TM kann jedes PSPACE-Problem lösen, indem sie das Orakel befragt.
|
||||
|
||||
### Beweis von Teil 1 (Diagonalisierung)
|
||||
|
||||
Wir konstruieren ein Orakel $A$, sodass die Sprache
|
||||
$$L_A = {w \mid \exists x \in A \text{ mit } |x| = |w|}$$
|
||||
**nicht** in $\text{P}^A$ liegt (aber offensichtlich in $\text{NP}^A$, da man $x$ raten und das Orakel fragen kann).
|
||||
|
||||
**Konstruktion von $A$ in Schritten:**
|
||||
|
||||
Sei $M_1, M_2, M_3, \ldots$ die Aufzählung aller polynomialzeit Orakel-TMs.
|
||||
|
||||
- **Schritt 1:** Wähle endlich viele beliebige Strings und füge sie zu $A$ hinzu.
|
||||
- **Schritt $i$:** Wähle $n$ so groß, dass $2^n > p_i(n)$ (Laufzeitschranke von $M_i$) und $n$ größer als alle bisherigen String-Längen in $A$.
|
||||
- Simuliere $M_i$ auf Eingabe $1^n$.
|
||||
- Falls $M_i$ das Orakel nach $y$ fragt und der Status von $y$ feststeht → antworte gemäß Status.
|
||||
- Falls der Status nicht feststeht → antworte „Nein” und setze $y \notin A$.
|
||||
- Falls $M_i$ **akzeptiert** → alle verbleibenden Strings der Länge $n$ erhalten den Status „nicht in $A$” (Diagonalisierung: $1^n \in L_A$, aber $M_i$ akzeptiert – Widerspruch zur korrekten Entscheidung).
|
||||
- Falls $M_i$ **nicht akzeptiert** → wähle einen String der Länge $n$, nach dem $M_i$ das Orakel nicht gefragt hat, und füge ihn zu $A$ hinzu (das geht, weil $2^n > p_i(n)$, also hat $M_i$ weniger Strings abgefragt, als es gibt).
|
||||
|
||||
### Konsequenz
|
||||
|
||||
Da sowohl $\text{P}^A \neq \text{NP}^A$ als auch $\text{P}^B = \text{NP}^B$ möglich ist, kann **keine relativierende Beweistechnik** die P-vs-NP-Frage klären. Jeder Beweis, der für beliebige Orakel funktioniert, würde zu einem Widerspruch führen.
|
||||
|
||||
> **Ergänzung:** Dies war ein bahnbrechendes Ergebnis von Baker, Gill und Solovay (1975), das zeigte, dass Diagonalisierung allein nicht ausreicht, um P ≠ NP zu beweisen. Spätere Arbeiten (Razborov, Rudich: „Natural Proofs”, 1997) zeigten weitere fundamentale Schranken für Beweistechniken.
|
||||
|
||||
-----
|
||||
|
||||
## 8. Polynomiale Hierarchie (PH)
|
||||
|
||||
### 8.1 Definition über Quantoren
|
||||
|
||||
Für eine Komplexitätsklasse $\mathcal{C}$ definieren wir:
|
||||
|
||||
$$\exists \mathcal{C} = \left{x : \exists^{p(|x|)} y ; \langle x, y \rangle \in B \right}$$
|
||||
|
||||
wobei $B \in \mathcal{C}$ und „$\exists^{p(|x|)} y$” bedeutet: es existiert ein String $y$ der Länge $\leq p(|x|)$.
|
||||
|
||||
Analog für den Allquantor: $\forall \mathcal{C}$.
|
||||
|
||||
**Beobachtungen:**
|
||||
|
||||
- $\exists \text{P} = \text{NP}$ (die existenzielle Quantifizierung über P ergibt NP)
|
||||
- $\forall \text{P} = \text{co-NP}$ (die universelle Quantifizierung über P ergibt co-NP)
|
||||
|
||||
### 8.2 Die Stufen der Hierarchie
|
||||
|
||||
Die polynomiale Hierarchie wird induktiv definiert:
|
||||
|
||||
|Stufe|$\Sigma^p$ |$\Pi^p$ |$\Delta^p$ |
|
||||
|-----|--------------------------------------------------------|----------------------------------|---------------------------------------|
|
||||
|0 |$\Sigma^p_0 = \text{P}$ |$\Pi^p_0 = \text{P}$ | |
|
||||
|1 |$\Sigma^p_1 = \text{NP}$ |$\Pi^p_1 = \text{co-NP}$ |$\Delta^p_1 = \text{P}$ |
|
||||
|2 |$\Sigma^p_2 = \exists \Pi^p_1 = \text{NP}(\text{co-NP})$|$\Pi^p_2 = \forall \Sigma^p_1$ |$\Delta^p_2 = \text{P}(\text{NP})$ |
|
||||
|$n+1$|$\Sigma^p_{n+1} = \exists \Pi^p_n$ |$\Pi^p_{n+1} = \forall \Sigma^p_n$|$\Delta^p_{n+1} = \text{P}(\Sigma^p_n)$|
|
||||
|
||||
Die **polynomiale Hierarchie** ist dann:
|
||||
$$\text{PH} = \bigcup_{n \geq 0} \Sigma^p_n$$
|
||||
|
||||
### 8.3 Äquivalente Charakterisierung
|
||||
|
||||
Eine Sprache $L$ ist in $\Sigma^p_i$ genau dann, wenn es eine polynomialzeit-TM $M$ und ein Polynom $q$ gibt, sodass:
|
||||
|
||||
$$x \in L \iff \exists u_1 \in {0,1}^{q(|x|)} ; \forall u_2 \in {0,1}^{q(|x|)} ; \cdots ; Q_i u_i \in {0,1}^{q(|x|)} ; M(x, u_1, \ldots, u_i) = 1$$
|
||||
|
||||
wobei die Quantoren **alternieren** ($\exists, \forall, \exists, \forall, \ldots$) und $Q_i = \forall$ falls $i$ gerade, $Q_i = \exists$ falls $i$ ungerade.
|
||||
|
||||
Analog für $\Pi^p_i$ mit umgekehrter Quantorenreihenfolge ($\forall, \exists, \forall, \exists, \ldots$).
|
||||
|
||||
### 8.4 Zusammenhang mit Orakel-Klassen
|
||||
|
||||
> $\Sigma^p_{n+1} = \text{NP}(\Sigma^p_n)$
|
||||
|
||||
**Beweis (Skizze):**
|
||||
|
||||
- **Richtung $\Sigma^p_{n+1} \subseteq \text{NP}(\Sigma^p_n)$:** Per Definition ist jedes $S \in \Sigma^p_{n+1} = \exists \Pi^p_n$. Es gibt also ein $S’ \in \Pi^p_n$ mit $S = {x : \exists y \text{ mit } (x,y) \in S’}$. Da $\Pi^p_n \subseteq \text{NP}(\Sigma^p_n)$ (und auch $= \text{co-}\Sigma^p_{n+1}$), liegt $S$ in $\text{NP}(\Sigma^p_n)$.
|
||||
- **Richtung $\text{NP}(\Sigma^p_n) \subseteq \Sigma^p_{n+1}$:** Eine NP-Maschine mit Orakel $S’ \in \Sigma^p_n$ rät zunächst ein Zertifikat $y$ und stellt dann adaptive Orakel-Anfragen. Man kann die Orakel-Antworten **mitraten** und die Korrektheit der geratenen Antworten durch die Quantorenstruktur von $\Sigma^p_n$ verifizieren.
|
||||
|
||||
### 8.5 Vollständige Probleme
|
||||
|
||||
Für jede Stufe $i$ der Hierarchie ist $\Sigma_i\text{SAT}$ ein vollständiges Problem:
|
||||
|
||||
$$\Sigma_i\text{SAT} = \exists u_1 ; \forall u_2 ; \exists \cdots ; Q_i u_i ; \varphi(u_1, u_2, \ldots, u_i) = 1$$
|
||||
|
||||
### 8.6 Kollaps der Hierarchie
|
||||
|
||||
- $\text{PH} \subseteq \text{PSPACE}$ (leicht einzusehen, da jede Stufe in PSPACE simulierbar ist).
|
||||
- Falls $\text{PH} = \text{PSPACE}$, so **kollabiert** PH (auf eine endliche Stufe).
|
||||
- Falls es ein **vollständiges Problem für PH** gibt, so kollabiert PH ebenfalls.
|
||||
|
||||
> **Ergänzung:** Die Vermutung, dass PH **nicht** kollabiert, ist eines der zentralen offenen Probleme der Komplexitätstheorie. Ein Kollaps auf Stufe 0 würde $\text{P} = \text{NP}$ bedeuten, ein Kollaps auf Stufe 1 würde $\text{NP} = \text{co-NP}$ implizieren. Die meisten Forscher vermuten, dass die Hierarchie unendlich ist – aber ein Beweis fehlt.
|
||||
|
||||
-----
|
||||
|
||||
## Zusammenfassung der wichtigsten Beziehungen
|
||||
|
||||
$$\text{P} \subseteq \text{NP} \subseteq \Sigma^p_2 \subseteq \cdots \subseteq \text{PH} \subseteq \text{PSPACE} \subseteq \text{EXPTIME} \subseteq \text{EXPSPACE}$$
|
||||
|
||||
**Bekannte strikte Inklusionen:**
|
||||
|
||||
- $\text{P} \subsetneq \text{EXPTIME}$ (Time Hierarchy Theorem)
|
||||
- $\text{PSPACE} \subsetneq \text{EXPSPACE}$ (Space Hierarchy Theorem)
|
||||
- $\text{NL} \subsetneq \text{PSPACE}$ (Space Hierarchy Theorem)
|
||||
|
||||
**Offene Fragen:**
|
||||
|
||||
- $\text{P} \stackrel{?}{=} \text{NP}$
|
||||
- $\text{NP} \stackrel{?}{=} \text{co-NP}$
|
||||
- $\text{P} \stackrel{?}{=} \text{PSPACE}$
|
||||
- Kollabiert PH?
|
||||
|
||||
-----
|
||||
|
||||
## Übersicht der Schlüsselresultate
|
||||
|
||||
|Resultat |Aussage |Technik |
|
||||
|---------------------------|----------------------------------------------------------|----------------------------------------------|
|
||||
|TQBF ist PSPACE-vollständig|Jedes PSPACE-Problem lässt sich als QBF kodieren |Formelkonstruktion mit Allquantor-Trick |
|
||||
|Space Hierarchy Theorem |Mehr Platz → echt mehr Sprachen |Diagonalisierung |
|
||||
|Time Hierarchy Theorem |Mehr Zeit → echt mehr Sprachen (mit log-Lücke) |Diagonalisierung + Zähler |
|
||||
|Gap Theorem |$\exists f$: $\text{TIME}(f(n)) = \text{TIME}(2^{f(n)})$ |Konstruktion von Lücken in Haltezeiten |
|
||||
|Speed-Up Theorem |$\exists A$: jede TM kann exponentiell beschleunigt werden|Diagonalisierung + abnehmende Funktionsfamilie|
|
||||
|Baker-Gill-Solovay |Relativierung kann P vs NP nicht klären |Orakel-Konstruktion |
|
||||
|PH-Definition |$\Sigma^p_{n+1} = \text{NP}(\Sigma^p_n)$ |Quantoren-Alternierung |
|
||||
Loading…
Add table
Add a link
Reference in a new issue