Ich bin in einem Kurs über Computing und Komplexität und kann nicht verstehen, was diese Begriffe bedeuten.

Ich weiß nur, dass NP eine Teilmenge von NP-complete ist, eine Teilmenge von NP-hard, aber ich habe keine Ahnung, was sie eigentlich bedeuten. Wikipedia ist auch keine große Hilfe, da die Erklärungen immer noch etwas zu hoch sind.

Ich finde die Wikipedia-Artikel $\mathsf{P}$ , $\mathsf{NP}$ und $\mathsf{P}$ vs. $\mathsf{NP}$ ziemlich gut. Hier noch was ich sagen würde: Teil I , Teil II

[Ich werde in Klammern einige technische Details erläutern, die Sie bei Bedarf überspringen können.]

Teil I

Entscheidungsprobleme

Es gibt verschiedene Arten von Rechenproblemen. In einer Einführung in den Kurs zur Theorie der rechnerischen Komplexität ist es jedoch einfacher, sich auf Entscheidungsprobleme zu konzentrieren , dh auf Probleme, bei denen die Antwort entweder JA oder NEIN lautet. Es gibt andere Arten von Rechenproblemen, aber die meisten Fragen zu diesen können auf ähnliche Fragen zu Entscheidungsproblemen reduziert werden. Außerdem sind Entscheidungsprobleme sehr einfach. In einem Einführungskurs in die Komplexitätstheorie konzentrieren wir uns daher auf die Untersuchung von Entscheidungsproblemen.

Wir können ein Entscheidungsproblem mit der Teilmenge der Eingaben identifizieren, die die Antwort JA haben. Dies vereinfacht die Notation und erlaubt es uns , zu schreiben , $x\in Q$ anstelle von $Q(x)=YES$ und $x \notin Q$ anstelle von $Q(x)=NO$ .

Eine andere Perspektive ist, dass wir über Mitgliedschaftsabfragen in einem Satz sprechen . Hier ist ein Beispiel:

Entscheidungsproblem:

Eingabe: Eine natürliche Zahl $x$ ,
Frage: Ist $x$ eine gerade Zahl?

Mitgliedsproblem:

Eingabe: Eine natürliche Zahl $x$ ,
Frage: Ist $x$ in $Even = \{0,2,4,6,\cdots\}$ ?

Wir verweisen auf die JA-Antwort auf eine Eingabe als Annahme der Eingabe und auf die NEIN-Antwort auf eine Eingabe als Zurückweisung der Eingabe.

Wir werden Algorithmen auf Entscheidungsprobleme untersuchen und diskutieren, wie effizient diese Algorithmen bei der Verwendung berechenbarer Ressourcen sind . Ich werde mich auf Ihre Intuition verlassen, in einer Sprache wie C zu programmieren, anstatt formal zu definieren, was wir mit einem Algorithmus und Rechenressourcen meinen.

[Anmerkungen: 1. Wenn wir alles formal und präzise machen wollten, müssten wir ein Rechenmodell wie das Standard- Turing-Maschinenmodell festlegen, um genau zu definieren, was wir unter einem Algorithmus und dessen Verwendung von Rechenressourcen verstehen. 2. Wenn wir über die Berechnung von Objekten sprechen möchten, die das Modell nicht direkt verarbeiten kann, müssen wir sie als Objekte codieren, die das Maschinenmodell verarbeiten kann. Wenn wir beispielsweise Turing-Maschinen verwenden, müssen wir Objekte wie natürliche Zahlen und Graphen codieren als binäre Zeichenketten.]

$\mathsf{P}$ = Probleme mit effizienten Algorithmen zumFinden vonLösungen

Angenommen, effiziente Algorithmen bedeuten Algorithmen, die höchstens eine polynomielle Menge an Rechenressourcen verbrauchen. Die wichtigste Ressource, um die es uns geht, ist die Worst-Case- Laufzeit von Algorithmen in Bezug auf die Eingabegröße, dh die Anzahl der grundlegenden Schritte, die ein Algorithmus für eine Eingabe der Größe $n$ . Die Größe einer Eingabe $x$ ist $n$ wenn zum Speichern von x $n$ Bit des Computerspeichers erforderlich sind. In diesem Fall schreiben wir | x | = n . Mit effizienten Algorithmen sind also Algorithmen gemeint, die eine polynomielle Worst-Case-Laufzeit haben .$x$$|x| = n$

Die Annahme, dass Polynom-Zeit-Algorithmen den intuitiven Begriff effizienter Algorithmen erfassen, ist als Cobhams These bekannt . Ich werde an dieser Stelle nicht diskutieren, ob $\mathsf{P}$ das richtige Modell für effizient lösbare Probleme ist und ob $\mathsf{P}$ erfasst, was in der Praxis und in verwandten Fragen effizient berechnet werden kann oder nicht. Im Moment gibt es gute Gründe, diese Annahme zu treffen. Daher gehen wir für unseren Zweck davon aus, dass dies der Fall ist. Wenn Sie Cobhams These nicht akzeptieren, wird das, was ich unten schreibe, nicht fehlerhaft. Das einzige, was wir verlieren, ist die Intuition über effizientes Rechnen in der Praxis. Ich denke, es ist eine hilfreiche Annahme für jemanden, der anfängt, etwas über Komplexitätstheorie zu lernen.

$\mathsf{P}$ ist die Klasse von Entscheidungsproblemen, die effizient gelöst werden können,
dh Entscheidungsprobleme, die Polynomzeitalgorithmen aufweisen.

Genauer gesagt, wir sagen, dass ein Entscheidungsproblem $Q$ in $\mathsf{P}$ iff ist

es gibt einen effizienten Algorithmus $A$ so dass
für alle Eingaben $x$ ,

• wenn $Q(x)=YES$ dann $A(x)=YES$ ,
• wenn $Q(x)=NO$ dann $A(x)=NO$ .

Ich kann einfach schreiben $A(x)=Q(x)$ aber ich schreibe es auf diese Weise , so können wir es auf die Definition der vergleichen , $\mathsf{NP}$ .

$\mathsf{NP}$ = Probleme mit effizienten Algorithmen zurÜberprüfung vonNachweisen / Zertifikaten / Zeugen

Manchmal kennen wir keine effiziente Methode, um die Antwort auf ein Entscheidungsproblem zu finden. Wenn uns jedoch jemand die Antwort mitteilt und uns einen Beweis liefert, können wir die Richtigkeit der Antwort effizient überprüfen , indem wir den Beweis überprüfen , um festzustellen, ob es sich um einen gültigen Beweis handelt . Das ist die Idee hinter der Komplexitätsklasse $\mathsf{NP}$ .

Wenn der Proof zu lang ist, kann es zu lange dauern, den Proof zu lesen, geschweige denn zu prüfen, ob er gültig ist. Wir möchten, dass die für die Überprüfung erforderliche Zeit in der Größe der ursprünglichen Eingabe angemessen ist, nicht in der Größe des angegebenen Proofs! Was wir also wirklich wollen, sind keine willkürlichen langen Beweise, sondern kurze Beweise. Beachten Sie, dass der Prüfer nur einen polynomischen Teil des Beweises lesen kann, wenn die Laufzeit des Prüfers in der Größe der ursprünglichen Eingabe polynomisch ist. So durch kurze meinen wir von Polynom Größe .

Bilden Sie diesen Punkt immer dann, wenn ich das Wort "Beweis" verwende. Ich meine "kurzer Beweis".

Hier ist ein Beispiel für ein Problem, das wir nicht effizient lösen können, das wir jedoch effizient überprüfen können:

Partitionseingabe
: eine endliche Menge natürlicher Zahlen $S$ ,
Frage: Ist es möglich, $S$ in zwei Mengen $A$ und $B$ zu partitionieren ( $A \cup B = S$ und $A \cap B = \emptyset$ ),
so dass die Summe der Zahlen in $A$ gleich ist die Summe der Zahlen in $B$ ( $\sum_{x\in A}x=\sum_{x\in B}x$ )?

Wenn ich Ihnen $S$ gebe und Sie frage, ob wir es in zwei Mengen aufteilen können, so dass ihre Summen gleich sind, kennen Sie keinen effizienten Algorithmus, um es zu lösen. Sie werden wahrscheinlich alle möglichen Möglichkeiten ausprobieren, die Zahlen in zwei Gruppen zu unterteilen, bis Sie eine Partition finden, in der die Summen gleich sind, oder bis Sie alle möglichen Partitionen ausprobiert haben und keine funktioniert hat. Wenn einer von ihnen funktioniert, würden Sie JA sagen, andernfalls würden Sie NEIN sagen.

Es gibt jedoch exponentiell viele mögliche Partitionen, daher wird es viel Zeit in Anspruch nehmen. Wenn ich Ihnen jedoch zwei Mengen $A$ und $B$ gebe , können Sie leicht überprüfen, ob die Summen gleich sind und ob $A$ und $B$ eine Partition von $S$ . Beachten Sie, dass wir die Summen effizient berechnen können.

Hier ist das Paar $A$ und $B$ , das ich Ihnen gebe, ein Beweis für eine JA-Antwort. Sie können meine Behauptung effizient überprüfen, indem Sie sich meinen Beweis ansehen und prüfen, ob es sich um einen gültigen Beweis handelt . Wenn die Antwort JA ist, gibt es einen gültigen Beweis, und ich kann ihn Ihnen geben, und Sie können ihn effizient überprüfen. Wenn die Antwort NEIN lautet, gibt es keinen gültigen Beweis. Was auch immer ich Ihnen gebe, Sie können überprüfen und sehen, dass es kein gültiger Beweis ist. Ich kann Sie nicht durch einen ungültigen Beweis täuschen, dass die Antwort JA ist. Denken Sie daran, dass die Überprüfung eines zu großen Beweises viel Zeit in Anspruch nimmt. Wir möchten nicht, dass dies geschieht, und kümmern uns daher nur um effiziente Beweise, dh Beweise mit polynomieller Größe.

Manchmal verwenden die Leute " Zertifikat " oder " Zeuge " anstelle von "Beweis".

Hinweis Ich gebe Ihnen genügend Informationen über die Antwort für eine bestimmte Eingabe $x$ damit Sie die Antwort effizient finden und überprüfen können. Beispiel: In unserem Partitionsbeispiel sage ich Ihnen keine Antwort, ich gebe Ihnen nur eine Partition und Sie können überprüfen, ob diese gültig ist oder nicht. Beachten Sie, dass Sie die Antwort selbst überprüfen müssen. Sie können mir nicht vertrauen, was ich sage. Außerdem können Sie nur die Richtigkeit meines Beweises überprüfen . Wenn mein Beweis gültig ist, heißt das, dass die Antwort JA ist. Aber wenn mein Beweis ungültig ist, heißt das nicht, dass die Antwort NEIN ist. Sie haben gesehen, dass ein Beweis ungültig war, nicht, dass es keine gültigen Beweise gibt. Wir sprechen über Beweise für JA. Wir sprechen nicht über Beweise für NEIN.

Schauen wir uns ein Beispiel an: $A=\{2,4\}$ und $B=\{1,5\}$ sind ein Beweis dafür, dass $S=\{1,2,4,5\}$ mit gleichen Summen in zwei Mengen unterteilt werden kann. Wir müssen nur die Zahlen in $A$ und die Zahlen in $B$ und prüfen , ob die Ergebnisse gleich sind und ob $A$ , $B$ eine Partition von $S$ .

Wenn ich Ihnen $A=\{2,5\}$ und $B=\{1,4\}$ , prüfen Sie, ob mein Beweis ungültig ist. Dies bedeutet nicht, dass die Antwort NEIN lautet, sondern nur, dass dieser spezielle Beweis ungültig war. Ihre Aufgabe ist es hier nicht , die Antwort zu finden, sondern nur zu prüfen, ob der Ihnen vorgelegte Beweis gültig ist.

Es ist wie wenn ein Student eine Frage in einer Prüfung löst und ein Professor prüft, ob die Antwort richtig ist. :) (Leider geben die Schüler oft nicht genügend Informationen an, um die Richtigkeit ihrer Antwort zu überprüfen, und die Professoren müssen den Rest ihrer Teilantwort erraten und entscheiden, wie viel Note sie den Schülern für ihre Teilantworten geben sollen, was in der Tat ziemlich schwierig ist Aufgabe).

Das Erstaunliche ist, dass die gleiche Situation auch für viele andere natürliche Probleme gilt, die wir lösen möchten: Wir können effizient überprüfen, ob ein gegebener kurzer Beweis gültig ist, aber wir kennen keinen effizienten Weg , um die Antwort zu finden . Dies ist die Motivation , warum die Komplexitätsklasse $\mathsf{NP}$ ist äußerst interessant (obwohl dies für die Definition es nicht die ursprüngliche Motivation war). Was auch immer Sie tun (nicht nur in CS, sondern auch in Mathematik, Biologie, Physik, Chemie, Wirtschaft, Management, Soziologie, Wirtschaft, ...), Sie werden auf Rechenprobleme stoßen, die in diese Klasse fallen. Um eine Vorstellung davon zu bekommen, wie viele Probleme sich in $\mathsf{NP}$ herausstellen, lesen Sie bitte ein Kompendium von NP-Optimierungsproblemen . In der Tat werden Sie Schwierigkeiten haben, natürliche Probleme zu finden, die nicht in $\mathsf{NP}$ . Es ist einfach unglaublich.

$\mathsf{NP}$ ist die Klasse von Problemen mit effizienten Verifizierern, dh
es gibt einen polynomialen Zeitalgorithmus, der überprüfen kann, ob eine gegebene Lösung korrekt ist.

Genauer gesagt, wir sagen, dass ein Entscheidungsproblem $Q$ in $\mathsf{NP}$ iff ist

es gibt einen effizienten Algorithmus $V$ , der Verifizierer genannt wird, so dass
für alle Eingaben $x$ ,

• wenn $Q(x)=YES$ dann gibt es einen Beweis $y$ so dass $V(x,y)=YES$ ,
• wenn $Q(x)=NO$ dann für alle Proofs $y$ , $V(x,y)=NO$ .

Wir sagen, ein Prüfer ist gesund, wenn er keine Beweise akzeptiert, wenn die Antwort NEIN lautet. Mit anderen Worten, ein Schallprüfer kann nicht dazu gebracht werden, einen Beweis anzunehmen, wenn die Antwort wirklich NEIN lautet. Keine Fehlalarme.

Ebenso sagen wir, dass ein Verifizierer vollständig ist, wenn er mindestens einen Beweis akzeptiert, wenn die Antwort JA lautet. Mit anderen Worten, ein vollständiger Prüfer kann davon überzeugt sein, dass die Antwort JA lautet.

Die Terminologie stammt aus Logik- und Beweissystemen . Wir können kein Schallschutzsystem verwenden, um falsche Aussagen zu beweisen. Wir können ein vollständiges Beweissystem verwenden, um alle wahren Aussagen zu beweisen.

Der Prüfer $V$ erhält zwei Eingänge,

• $x$ : die ursprüngliche Eingabe für$Q$ und
• $y$ : ein vorgeschlagene Beweis für$Q(x)=YES$ .

Beachten Sie, dass $V$ in der Größe von $x$ effizient sein soll . Wenn $y$ ein großer Beweis ist, kann der Prüfer nur einen Polynomteil von $y$ lesen . Deshalb müssen die Beweise kurz sein. Wenn $y$ kurz ist und besagt, dass $V$ in $x$ effizient ist, ist dies dasselbe, wie wenn man sagt, dass $V$ in $x$ und $y$ effizient ist (weil die Größe von $y$ durch ein festes Polynom in der Größe von $x$ ).

Um zusammenfassend zu zeigen, dass ein Entscheidungsproblem $Q$ in $\mathsf{NP}$ wir einen effizienten Überprüfungsalgorithmus angeben, der solide und vollständig ist .

Historische Anmerkung: historisch ist dies nicht die ursprüngliche Definition von $\mathsf{NP}$ . Die ursprüngliche Definition verwendet sogenannte nicht-deterministische Turing-Maschinen. Diese Maschinen entsprechen keinem tatsächlichen Maschinenmodell und sind schwer zu gewöhnen (zumindest, wenn Sie anfangen, etwas über Komplexitätstheorie zu lernen). Ich habe gelesen, dass viele Experten glauben, sie hätten die Verifiziererdefinition als Hauptdefinition verwendet und sogar die Klasse $\mathsf{VP}$ (für verifizierbar in Polynomzeit) anstelle von $\mathsf{NP}$ wenn sie zurück zu den Anfängen der rechnerischen Komplexitätstheorie gehen. Die Verifiziererdefinition ist natürlicher, konzeptionell einfacher zu verstehen und einfacher zu verwenden, um zu zeigen, dass sich Probleme in $\mathsf{NP}$ .

$\mathsf{P}\subseteq \mathsf{NP}$

Daher haben wir $\mathsf{P}$ = effizient lösbar und $\mathsf{NP}$ = effizient überprüfbar . Also ist $\mathsf{P}=\mathsf{NP}$ wenn die Probleme, die effizient verifiziert werden können, die gleichen sind wie die Probleme, die effizient gelöst werden können.

Beachten Sie, dass jedes Problem in $\mathsf{P}$ auch in $\mathsf{NP}$ , dh wenn Sie das Problem lösen können, können Sie auch überprüfen, ob ein gegebener Beweis korrekt ist: Der Prüfer ignoriert den Beweis einfach!

Das liegt daran, dass wir es nicht benötigen. Der Prüfer kann die Antwort selbst berechnen. Er kann ohne Hilfe entscheiden, ob die Antwort JA oder NEIN lautet. Wenn die Antwort NEIN ist, wissen wir, dass es keine Beweise geben sollte, und unser Prüfer lehnt einfach jeden vorgeschlagenen Beweis ab. Wenn die Antwort JA lautet, sollte es einen Beweis geben, und tatsächlich akzeptieren wir einfach alles als Beweis.

[Wir hätten unseren Prüfer dazu bringen können, nur einige von ihnen zu akzeptieren, das ist auch in Ordnung, solange unser Prüfer mindestens einen Beweis akzeptiert, dass der Prüfer für das Problem korrekt funktioniert.]

Hier ist ein Beispiel:

$n+1$$a_1,\cdots,a_n$$s$
$\Sigma_{i=1}^n a_i = s$

$\mathsf{P}$$s$

$\mathsf{NP}$$V$$\mathsf{P}$

$\mathsf{NP}$$\mathsf{P}$$\mathsf{P} \subseteq \mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}\subseteq \mathsf{ExpTime}$

$\mathsf{NP}$$\mathsf{NP}$

In unserem Partitionsbeispiel versuchen wir alle möglichen Partitionen und prüfen, ob die Summen in einer von ihnen gleich sind.

$m$$2^m$

$\mathsf{NP}$$\mathsf{NP}\subseteq \mathsf{ExpTime}$$\mathsf{NP}\subseteq \mathsf{PSpace}$

$\mathsf{NP}$$\mathsf{P}$$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}=\mathsf{P}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{P}\subseteq\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$

Untere Grenzen scheinen schwer zu beweisen

$\mathsf{NP}$

Leider ist die Aufgabe, untere Schranken zu beweisen, sehr schwierig. Wir können nicht einmal beweisen, dass diese Probleme mehr als lineare Zeit erfordern ! Geschweige denn exponentielle Zeit erfordern.

Es ist ziemlich einfach, Untergrenzen in linearer Zeit zu beweisen: Der Algorithmus muss die Eingabe doch lesen. Das Nachweisen superlinearer Untergrenzen ist eine ganz andere Geschichte. Wir können superlineare Untergrenzen mit mehr Einschränkungen bezüglich der Art von Algorithmen nachweisen, die wir betrachten, z. B. Sortieralgorithmen unter Verwendung von Vergleichen, aber wir kennen keine Untergrenzen ohne diese Einschränkungen.

Um eine Obergrenze für ein Problem zu beweisen, müssen wir nur einen Algorithmus entwerfen, der gut genug ist. Es braucht oft Wissen, kreatives Denken und sogar Einfallsreichtum, um einen solchen Algorithmus zu entwickeln.

Im Vergleich zum Nachweis einer Untergrenze ist die Aufgabe jedoch erheblich einfacher. Wir müssen zeigen, dass es keine guten Algorithmen gibt . Nicht , dass wir nicht wissen , von irgendwelchen gut genug Algorithmen im Moment, aber dass es keine gute Algorithmen existiert , dass niemand jemals mit einem guten Algorithmus wird kommen . Denken Sie eine Minute darüber nach, wenn Sie es noch nicht getan haben. Wie können wir ein solches Unmöglichkeitsergebnis zeigen ?

$1=0$

Um eine untere Schranke zu beweisen, also zu zeigen , dass ein Problem erfordert eine gewisse Menge an Zeit zu lösen, bedeutet , dass wir beweisen müssen , dass jedenAlgorithmus, auch sehr geniale, die es noch nicht wissen, können das Problem nicht schneller lösen. Es gibt viele intelligente Ideen, die wir kennen (gierige, übereinstimmende, dynamische, lineare, semidefinite Programmierung, Quadratsummen-Programmierung und viele andere intelligente Ideen), und es gibt viele weitere, die wir noch nicht kennen. Es reicht nicht aus, einen Algorithmus oder eine bestimmte Idee zum Entwerfen von Algorithmen auszuschließen. Wir müssen alle ausschließen, auch diejenigen, die wir noch nicht kennen, auch diejenigen, die es vielleicht noch nie wissen! Und all dies kann man in einem Algorithmus kombinieren, daher müssen wir auch deren Kombinationen ausschließen. Es wurden Fortschritte erzielt, um zu zeigen, dass einige Ideen schwierige nicht lösen können$\mathsf{NP}$Probleme, z. B. gierig und seine Erweiterungen, können nicht funktionieren, und es gibt einige Arbeiten im Zusammenhang mit dynamischen Programmieralgorithmen, und es gibt einige Arbeiten zu bestimmten Arten der Verwendung der linearen Programmierung. Dies ist jedoch noch lange nicht genug, um die uns bekannten intelligenten Ideen auszuschließen (Suche nach Untergrenzen in eingeschränkten Berechnungsmodellen, wenn Sie interessiert sind).

Barrieren: Niedrigere Grenzen sind schwer zu beweisen

Auf der anderen Seite haben wir mathematische Ergebnisse, die als Barrieren bezeichnet werden und besagen, dass ein unterer Beweis nicht so oder so sein kann, und so oder so deckt fast alle Techniken ab, die wir zum Nachweis unterer Grenzen verwendet haben! Tatsächlich gaben viele Forscher es auf, die unteren Schranken nach dem Ergebnis der natürlichen Beweisbarriere von Alexander Rasbarow und Steven Rudich zu beweisen . Es stellt sich heraus, dass die Existenz bestimmter Arten von untergeordneten Beweisen die Unsicherheit von Generatoren kryptografischer Pseudozufallszahlen und vielen anderen kryptografischen Werkzeugen implizieren würde.

Ich sage fast, weil in den letzten Jahren vor allem von Ryan Williams einige Fortschritte erzielt wurden, die in der Lage waren, die Barriereergebnisse auf intelligente Weise zu umgehen. Die bisherigen Ergebnisse beziehen sich jedoch auf sehr schwache Rechenmodelle und sind weit davon entfernt, allgemeine Polynomzeitalgorithmen auszuschließen .

$\mathsf{NP}$

[Andererseits zeigt die Arbeit von Ryan Williams, dass es enge Zusammenhänge zwischen dem Nachweis von Untergrenzen und dem Nachweis von Obergrenzen gibt. Siehe seinen Vortrag auf der ICM 2014, wenn du interessiert bist.]

Reduzierungen: Lösen eines Problems Verwenden eines anderen Problems als Unterprogramm / Oracle / Black Box

Die Idee einer Reduzierung ist sehr einfach: Um ein Problem zu lösen, verwenden Sie einen Algorithmus für ein anderes Problem.

$n$$Sum$$Sum$

Problem:

$n$$x_1,\ldots,x_n$
$\sum_{i=1}^{n} x_i$

Reduktionsalgorithmus:

1. $s = 0$
2. $i$$1$$n$
   $s = Sum(s,x_i)$
3. $s$

$Sum$$Sum$$Sum$$Sum$

Dies ist im Wesentlichen eine Reduktion: Nehmen Sie an, dass wir einen Algorithmus für ein Problem haben, und verwenden Sie ihn als Orakel, um ein anderes Problem zu lösen. Effizient bedeutet hier effizient unter der Annahme, dass das Orakel in einer Zeiteinheit antwortet, dh wir zählen jede Ausführung des Orakels als einen einzigen Schritt.

Wenn das Orakel eine große Antwort zurückgibt, müssen wir sie lesen, und das kann einige Zeit dauern. Daher sollten wir die Zeit abrechnen, die wir zum Lesen der Antwort benötigen, die das Orakel uns gegeben hat. Ebenso zum Schreiben / Stellen der Frage aus dem Orakel. Aber Orakel funktioniert sofort, dh sobald wir die Frage vom Orakel stellen, schreibt das Orakel die Antwort für uns in einer einzigen Zeiteinheit. Alles, was Orakel leistet, ist ein einziger Schritt, aber das schließt die Zeit aus, die wir brauchen, um die Frage zu schreiben und die Antwort zu lesen.

Da es uns egal ist, wie Orakel funktioniert, sondern nur die Antworten, die es zurückgibt, können wir eine Vereinfachung vornehmen und das Orakel als das Problem selbst betrachten, anstelle eines Algorithmus dafür. Mit anderen Worten, es ist uns egal, ob das Orakel kein Algorithmus ist, es ist uns egal, wie Orakel zu seinen Antworten kommt.

$Sum$

Wir können einem Orakel mehrere Fragen stellen, und die Fragen müssen nicht vorbestimmt sein: Wir können eine Frage stellen und basierend auf der Antwort, die das Orakel zurückgibt, führen wir einige Berechnungen durch und stellen dann eine andere Frage basierend auf der Antwort, für die wir eine Antwort erhalten haben die vorherige Frage.

Eine andere Art, dies zu betrachten, besteht darin, es als interaktive Berechnung zu betrachten . Die interaktive Berechnung an sich ist ein großes Thema, daher werde ich hier nicht darauf eingehen, aber ich denke, dass es hilfreich sein kann, diese Perspektive von Reduktionen zu erwähnen.

$A$$O$$A^O$

Die oben diskutierte Reduktion ist die allgemeinste Form einer Reduktion und wird als Black-Box-Reduktion (auch bekannt als Orakel-Reduktion , Turing-Reduktion ) bezeichnet.

Formeller:

$Q$$O$$Q \leq_T O$
$A$$x$
$Q(x) = A^O(x)$

$A$$O$$Q$

$A$$Q\leq^\mathsf{P}_T O$$T$

Möglicherweise möchten wir jedoch die Interaktion des Reduktionsalgorithmus mit dem Orakel einschränken. Es gibt verschiedene Einschränkungen, die untersucht werden. Die nützlichste Einschränkung ist jedoch die sogenannte Mehrfachverringerung (auch als Mapping-Verkleinerung bezeichnet ).

$x$$y$

Formeller,

$Q$$O$$Q \leq_m O$
$A$$x$
$Q(x) = O(A(x))$

$Q \leq_m^\mathsf{P} O$

$\mathsf{NP}$$A$$\mathsf{NP}$$B$$A$$\mathsf{NP}$

$\mathsf{P}$$\mathsf{NP}$$\mathsf{NP}$

Der Beitrag ist zu lang geworden und überschreitet das Limit einer Antwort (30000 Zeichen). Ich werde die Antwort in Teil II fortsetzen .

Teil II

Fortsetzung von Teil I .

Die vorherige hat die maximal zulässige Anzahl von Buchstaben in einer Antwort (30000) überschritten, sodass ich sie in zwei Teile zerlege.

$\mathsf{NP}$ $\mathsf{NP}$

$\mathsf{P}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$

Jetzt wollen wir manchmal sagen, dass ein Problem schwer zu lösen ist . Wie oben erwähnt, können wir für diesen Zweck keine Untergrenzen verwenden: Theoretisch sind sie genau das, was wir beweisen möchten. In der Praxis haben wir jedoch keine großen Erfolge beim Nachweis von Untergrenzen erzielt, und im Allgemeinen sind sie, wie bereits erwähnt, schwer zu beweisen über. Kann man immer noch sagen, dass ein Problem schwer zu lösen ist ?

$\mathsf{NP}$$\mathsf{NP}$

Reduktionen als relative Schwierigkeit

$A$$B$$A$$B$$\leq$

$A$$B$$A$$B$

$M^B$$A$$B$$M$$B$$A$$N$$B$$M^B$$N$$M^N$$A$

$\mathsf{P}$

$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$
$\mathsf{NP}$$\mathsf{NP}$

$A$$\mathsf{NP}$

$A$$\mathsf{NP}$
$\mathsf{NP}$$B$$B$$A$$B\leq_m^\mathsf{P} A$

$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$

(Zwei weitere Probleme, an deren Optimierung viele Menschen arbeiten, um sie für den praktischen Einsatz in der Industrie zu optimieren, sind das Problem der Ganzzahlprogrammierung und der Beschränkungszufriedenheit . Abhängig von Ihrem Problem und den Instanzen, für die Sie sich interessieren, sind die optimierten Algorithmen für einen dieser Algorithmen möglicherweise leistungsfähiger als der Andere.)

$\mathsf{NP}$
$\mathsf{NP}$

$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$ hart (dh es gibt keinen polynomiellen Zeitalgorithmus).

Nun lauten die Fragen:

• $\mathsf{NP}$

• Kennen wir einen von ihnen?

$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{ExpTime}$$\mathsf{NP}$$\mathsf{NP}$

$p \lor \lnot p$

$\mathsf{NP}$$\mathsf{NP}$

$A$$\mathsf{NP}$$A$$B$$B$$\mathsf{NP}$$\mathsf{NP}$$A$$A$$B$$\mathsf{NP}$$B$

$\mathsf{NP}$$\mathsf{NP}$$\mathsf{NP}$

$\mathsf{NP}$$\mathsf{NP}$

$SAT$$\mathsf{NP}$$SAT$$SubsetSum$$\mathsf{NP}$$SAT$$SubsetSum$

$\mathsf{NP}$

$\mathsf{NP}$

Hinweis: Der folgende Teil ist in der ersten Lesung möglicherweise etwas technisch.

$\mathsf{NP}$

$V$$x$$t$$k$
$YES$$k$$V$$x$$t$$NO$

$UniVer$$\mathsf{NP}$

$V$$\mathsf{NP}$$x$$V$$x$$UniVer$
$t$$k$$V$$x$$V$$x$

$t$$t$$t$$k$

$\mathsf{NP}$$UniVer$$\mathsf{NP}$

$M$$x$$M$$t$
$YES$$M$$x$$YES$$t$$NO$$YES$$t$

$C$$\mathsf{P}$$t$

$Interpreter$

$UniVer$$\mathsf{NP}$$M$$x$$t$$k$$c$$c$$k$$Interpreter$$M$$YES$$x$$c$$t$

$SAT$$\mathsf{NP}$

$UniVer$$\mathsf{NP}$$UniVer$$\mathsf{NP}$

$\mathsf{NP}$$SAT$

$SAT$

$\varphi$
$YES$$\varphi$$NO$

$SAT$$\mathsf{NP}$

Geschrieben werden...

$\mathsf{NP}$

$\mathsf{NP}$

$\mathsf{NP}$

$\mathsf{P}$$\mathsf{NP}$

Was kommt als nächstes? Wohin soll es von hier aus gehen?

Mehr als nützlich genannten Antworten, empfehle ich Ihnen sehr zu beobachten „ Jenseits Berechnung: Die P vs NP Problem “ von Michael Sipser . Ich denke, dieses Video sollte als eines der führenden Lehrvideos in der Informatik archiviert werden.!

Genießen!

Kopieren meiner Antwort auf eine ähnliche Frage zum Stapelüberlauf:

Der einfachste Weg, P gegen NP und dergleichen zu erklären, ohne auf technische Aspekte einzugehen, besteht darin, "Wortprobleme" mit "Multiple-Choice-Problemen" zu vergleichen.

Wenn Sie versuchen, ein "Wortproblem" zu lösen, müssen Sie die Lösung von Grund auf finden. Wenn Sie versuchen, ein "Multiple-Choice-Problem" zu lösen, haben Sie die Wahl: Lösen Sie es wie ein "Wortproblem", oder versuchen Sie, jede der Ihnen gegebenen Antworten einzufügen, und wählen Sie die passende Kandidatenantwort aus.

Es kommt häufig vor, dass ein "Multiple-Choice-Problem" viel einfacher ist als das entsprechende "Wortproblem": Das Ersetzen der Kandidatenantworten und das Überprüfen, ob sie passen, erfordern möglicherweise erheblich weniger Aufwand als das Finden der richtigen Antwort von Grund auf.

Wenn wir uns nun auf den Aufwand einigen würden, der die Polynomzeit "locker" beansprucht, bestünde die Klasse P aus "einfachen Wortproblemen" und die Klasse NP aus "einfachen Multiple-Choice-Problemen".

Das Wesen von P gegen NP ist die Frage: "Gibt es einfache Multiple-Choice-Probleme, die nicht so einfach sind wie Wortprobleme?" Das heißt, gibt es Probleme, bei denen es einfach ist, die Gültigkeit einer bestimmten Antwort zu überprüfen, aber es schwierig ist, diese Antwort von Grund auf neu zu finden?

Jetzt, da wir intuitiv verstehen, was NP ist, müssen wir unsere Intuition herausfordern. Es stellt sich heraus, dass es "Multiple-Choice-Probleme" gibt, die in gewisser Weise am härtesten sind: Wenn man eine Lösung für eines dieser "härtesten" Probleme finden würde, könnte man eine Lösung für ALLE finden NP-Probleme! Als Cook dies vor 40 Jahren entdeckte, war es eine völlige Überraschung. Diese "schwersten von allen" Probleme werden als NP-schwer bezeichnet. Wenn Sie eine "Wortproblemlösung" für eines von ihnen finden, finden Sie automatisch eine "Wortproblemlösung" für jedes "einfache Multiple-Choice-Problem"!

Schließlich sind NP-vollständige Probleme solche, die gleichzeitig NP und NP-hart sind. Nach unserer Analogie sind sie gleichzeitig "einfach als Multiple-Choice-Probleme" und "am schwierigsten als Wortprobleme".

Am einfachsten ist P, hierher gehören in Polynomzeit lösbare Probleme.

Dann kommt NP. Dazu gehören in polynomialer Zeit lösbare Probleme auf einer nicht deterministischen Turingmaschine.

Die Härte und Vollständigkeit muss mit Abstrichen einhergehen. Ein Problem A ist schwer für eine Klasse C, wenn jedes Problem in C auf A reduziert wird. Wenn Problem A schwer für NP ist , oder NP-schwer, wenn jedes Problem in NP auf A reduziert wird.

Schließlich ist ein Problem für eine Klasse C vollständig, wenn es in C und schwer für C ist. In Ihrem Fall ist Problem A für NP vollständig oder NP-vollständig, wenn sich jedes Problem in NP auf A reduziert und A in NP ist .

Um die Erklärung von NP zu ergänzen, liegt ein Problem genau dann in NP, wenn eine Lösung in (deterministischer) Polynomzeit verifiziert werden kann. Betrachten Sie jedes bekannte NP-vollständige Problem, SAT, CLIQUE, SUBSET SUM, VERTEX COVER usw. Wenn Sie "die Lösung" erhalten, können Sie die Richtigkeit in Polynomzeit überprüfen. Dies sind Wahrheitszuweisungen für Variablen, vollständige Untergraphen, Teilmengen von Zahlen und Scheitelpunkte, die alle Kanten dominieren.

Für die Grundlagen scheint das P vs. NP- und das Computational Complexity Zoo- Video viel einfacher zu verstehen zu sein.

Für einen Computer mit einer wirklich großen Version eines Problems :

P Probleme

leicht zu lösen (Rubixwürfel)

NP-Probleme

schwer - aber die Antworten zu überprüfen ist einfach (sudoku)

Vielleicht sind das alles wirklich P-Probleme, aber wir wissen es nicht ... P vs. NP .

Viele NP-Probleme laufen auf dasselbe hinaus (Sudoku ist ein Neuling auf der Liste).

EXP-Probleme

wirklich schwer (bester nächster Zug im Schach)

NP-harte Probleme

Edit: NP-hard wird im Video nicht gut erklärt (es sind nur die rosafarbenen Stellen), Wikipedia's NP-hard Euler-Diagramm ist diesbezüglich klarer.

Video-Zusammenfassung

Wikipedia NP-Hard Euler Diagramm

P , NP , NP-complete und NP-hard sind Komplexitätsklassen, die Probleme nach ihrer algorithmischen Komplexität klassifizieren. Kurz gesagt, sie basieren auf drei Eigenschaften:

In Polynomzeit lösbar : Definiert Entscheidungsprobleme, die von einer deterministischen Turing-Maschine (DTM) unter Verwendung einer polynomischen Rechenzeit gelöst werden können, dh ihre Laufzeit wird durch einen Polynomausdruck in der Größe der Eingabe für den Algorithmus begrenzt. Unter Verwendung der Big-O-Notation wird diese Zeitkomplexität definiert als O(n ^ k)wobei n die Größe der Eingabe und ein konstanter Koeffizient von ka ist.

In Polynomzeit überprüfbare Lösung: Definiert Entscheidungsprobleme, für die eine bestimmte Lösung von einem DTM unter Verwendung einer polynomiellen Rechenzeit überprüft werden kann, obwohl das Erhalten der richtigen Lösung möglicherweise mehr Zeit in Anspruch nimmt.

Reduziert alle NP-Probleme in Polynomzeit : Definiert Entscheidungsprobleme, deren Algorithmen zur Lösung aller NP-Probleme nach einem Polynomzeit-Übersetzungsschritt verwendet werden können.

Ich habe kürzlich einen Artikel zu diesem Thema geschrieben, der weitere Details enthält, einschließlich einer Code-Demonstration zum Reduzieren eines NP-Problems in ein NP-hartes Problem: Komplexitätsklassen von Problemen