mirror of
https://github.com/theoleuthardt/hwr-notes.git
synced 2026-06-06 01:11: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
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
|
||||
Loading…
Add table
Add a link
Reference in a new issue