Die Überlegenheit von Quantencomputern – aus der Informatikperspektive

Übersicht

Sekundarstufe

Informatik

Quantencomputing

Deutsch

Auf einen Blick

Schlüsselbegriffe: Rechenkomplexität, Big-O-Notation, RSA-Algorithmus
Alter: 16 – 19 Jahre
Erforderliche Kenntnisse/Fähigkeiten: Grundlegendes Verständnis der strukturierten Programmierung, Grundkenntnisse der Programmiersprache Python
Zeitrahmen: 30–45 Minuten
Autor: Cristian Datzko (CH)

Inhaltsübersicht

1. Rechenkomplexität und die Big-O-Notation
2. Der RSA‑Algorithmus
3. Aufgaben

Zusammenfassung

Bestimmte Rechenprobleme – wie die Faktorisierung großer Zahlen – erfordern auf klassischen Computern eine unrealistisch lange Laufzeit. Ein Quantencomputer kann diese Probleme jedoch in einer angemessenen Zeit lösen. Dies ist ein Beispiel für Quantenüberlegenheit.

Quantencomputingt_Teaser_Ilustrationen_v01_Basic_Concepts_skaliert.png

Lernziele Lernziele

In dieser Unterrichtsstunde entdecken die Schüler*innen:

die Unterschiede zwischen einem klassischen und einem Quantencomputer;
die Big-O-Notation für Wachstumsraten (linear, polynomial, exponentiell, faktoriell);
was Quantenüberlegenheit bedeutet.

Material

Papier und Bleistift
Computer/Tablets und Internetzugang

1. Rechenkomplexität und die Big-O-Notation

Aufgabe 1

Finde die Primfaktoren der Zahl 373628601156041617, ohne einen Computer zu verwenden. Warum ist das so schwierig? Vergleiche diese Aufgabe mit der Multiplikation zweier Zahlen.

Lösung Lösung

Ein Primfaktor der Zahl 373628601156041617 kann theoretisch jede natürliche Zahl von 2 bis $\sqrt{373628601156041617}$ sein.

Um eine Zahl in ihre Primfaktoren zu zerlegen, müssen also mindestens alle Primzahlen von 2 bis $\sqrt{373628601156041617}$ daraufhin überprüft werden, ob sie Primfaktoren von 373628601156041617 sind.

Dabei ist $\sqrt{373628601156041617}$ eine Zahl, die halb so viele Ziffern hat wie die ursprüngliche Zahl 373628601156041617 (9 anstatt 18).

Ein offensichtlicher Ansatz wäre, digitale Tools wie WolframAlpha zu verwenden, die die Zahl zu 191206237 · 1954060741 faktorisieren. Dies verdeckt jedoch die Tatsache, wie aufwendig es für einen Computer ist, Zahlen wie 373628601156041617 zu faktorisieren. Ein Programm hierfür ist unter „Erklärung“ vorgestellt. Es zeigt klar auf, dass es länger braucht, je größer die zu faktorisierende Zahl ist; präzise formuliert benötigt es exponentiell mehr Zeit.

Die Zahlen 191206237 und 1954060741 sind bewusst gewählt: Der 23. Juni 1912 ist der Geburtstag von Alan Turing und der 7. Juni 1954 ist der Jahrestag seines Todes.

Aufgabe 2

Recherchiere Informationen über den RSA‑Algorithmus, der 1977 von Ronald L. Rivest (*1947), Adi Shamir (*1952) und Leonard Adleman (*1945) erfunden wurde und noch heute in der Kryptografie verwendet wird. Wie werden öffentliche und private Schlüssel erstellt?

Lösung Lösung

Der RSA‑Algorithmus basiert auf einem öffentlichen und einem privaten Schlüssel. Der öffentliche Schlüssel wird veröffentlicht und zum Verschlüsseln verwendet, während der private Schlüssel geheim bleibt und zum Entschlüsseln dient. Die folgenden mathematischen Operatoren werden hierfür verwendet:

Multiplikation a · b
Potenzieren b^x
Modulo‑Rechnen a % b (ist gleich dem Rest der ganzzahligen Division von a : b)

Drei Aspekte werden vom RSA‑Algorithmus geregelt:

Um einen Satz öffentlicher und privater Schlüssel zu erzeugen, führt der Empfänger folgende Schritte aus:
- Der Empfänger wählt zwei große Primzahlen p und q und berechnet das Produkt n = p · q.
- Der Empfänger wählt zwei Zahlen d und e, so dass d · e % (p – 1) · (q – 1) = 1 ergibt. Ergänzend müssen d und e teilerfremd (d. h. die beiden Zahlen haben außer 1 keinen weiteren gemeinsamen Teiler) zu p – 1 und q – 1 sein.
- Der Empfänger veröffentlicht (n, e) als seinen öffentlichen Schlüssel und behält (n, d) als seinen privaten Schlüssel. p und q werden vernichtet.
Um eine Nachricht zu verschlüsseln, berechnet der Absender aus der Nachricht m den Geheimtext c = m^e % n.
Um die Nachricht zu entschlüsseln, berechnet der Empfänger aus dem Geheimtext c den ursprünglichen Klartext m’ = c^d % n.

Aufgabe 3

Vergleiche das Wachstum der Funktionen $f_{1} (x) = x$ , $f_{2} (x) = x^{2}$ , $f_{3} (x) = x^{10}$ , $f_{4} (x) = 2^{x}$ und $f_{5} (x) = x!$ , indem du die Funktionswerte für $x = 1$ , $10$ , $100$ , $1000$ , $10000$ , $100000$ und $1000000$ berechnest.

Hinweis: Du brauchst eventuell spezielle Hilfswerkzeuge wie Python oder WolframAlpha, um einige dieser Funktionswerte zu berechnen.

Lösung Lösung

Die folgende Tabelle zeigt die berechneten Werte:

x	f₁(x) = x	f₂(x) = x²	f₃(x) = x¹⁰	f₄(x) = 2ˣ	f₅(x) = x!
1	1	1	1	2	1
10	10	100	1 · 10¹⁰	1024	3 628 800
100	100	10 000	1 · 10²⁰	1,268 · 10³⁰	9,333 · 10¹⁵⁷
1 000	1 000	1 000 000	1 · 10³⁰	1,072 · 10³⁰¹	4,024 · 10²⁵⁶⁷
10 000	10 000	100 000 000	1 · 10⁴⁰	1,995 · 10³⁰¹⁰	2,846 · 10³⁵⁶⁵⁹
100 000	100 000	1 · 10¹⁰	1 · 10⁵⁰	9,990 · 10³⁰¹⁰²	2,824 · 10⁴⁵⁶⁵⁷³
1 000 000	1 000 000	1 · 10¹²	1 · 10⁶⁰	9,901 · 10³⁰¹⁰²⁹	8,264 · 10^55555708

Für die größten Werte wurde WolframAlpha verwendet.

Die Tabelle zeigt klar auf, dass f₄(x) = 2ˣ (exponentielles Wachstum) signifikant schneller als die anderen Funktionen (linear, quadratisch oder polynomial) wächst, und dass f₅(x) = x! (faktorielles Wachstum) noch schneller wächst.

Erklärung

Einige dieser Rechnungen dauern länger als erwartet. Ein einfacher Ansatz zur Faktorisierung einer sehr großen ganzen Zahl $x$ wäre, alle möglichen Primfaktoren (beginnend mit 2) zu testen, bis ein erster Faktor gefunden wird.

Man muss lediglich bis $\sqrt{x}$ testen, weil $x$ entweder eine Primzahl ist oder als $x = a \cdot b$ faktorisiert werden kann, wobei entweder $a$ oder $b$ kleiner ist als $\sqrt{x}$ .

Dieser Vorgang muss dann fortgesetzt werden, bis alle Faktoren gefunden sind oder bis sich herausstellt, dass die ganze Zahl eine Primzahl ist.

Das folgende Python‑Programm zeigt diesen Prozess in vereinfachter Form (der Einfachheit halber werden alle ganzen Zahlen ab 2 getestet, anstatt nur die Primzahlen):

Code Code

import math

def is_divisible_by(dividend, divisor):
    """ Gibt an, ob der Zähler durch den Nenner teilbar ist, indem überprüft wird, ob der Rest der ganzzahligen Division 0 ist."""
    return dividend % divisor == 0 # Der Modulo-Operator „%“ ermittelt den Rest einer ganzzahligen Division.

integer = 373628601156041617 # Die Zahl, die faktorisiert werden soll
factors = [] # Eine Liste von Faktoren, beginnend mit einer leeren Liste

x = integer # Lege eine Kopie von „integer“ an, da sich diese Variable mit der Zeit ändert.
factor = 2 # Überprüfe jede ganze Zahl, beginnend mit 2.
while factor <= math.sqrt(x): # Solange die überprüfte Zahl (der Faktor) kleiner oder gleich der Wurzel von x ist
    if is_divisible_by(x, factor):
        factors.append(factor) # Hänge den überprüften Faktor ans Ende der Liste an.
        x = x // factor # Jetzt müssen nur noch Zahlen bis x geteilt durch den Faktor überprüft werden, da der Faktor selbst bereits ein Faktor der Faktorisierung ist. „//“ ist eine ganzzahlige Division, daher ist das Ergebnis immer eine ganze Zahl.
        # Der Faktor muss nicht geändert werden, da er nicht kleiner als vorher sein kann, sondern wieder der gleiche Faktor sein könnte.
    else:
        factor = factor + 1 # Erhöhe den Faktor um 1
factors.append(x) # Wenn keine Faktoren kleiner oder gleich Wurzel von x gefunden werden, muss die verbleibende ganze Zahl eine Primzahl sein und somit der endgültige Faktor.
print("Die Primfaktoren von", integer, "sind", factors)

Beispiel: Um die Zahl 100 zu faktorisieren, würde jede Iteration der Schleife die folgenden Werte ergeben:

x	Faktor	Alle Faktoren
100	2	[]
50	2	[2]
25	2	[2, 2]
25	3	[2, 2]
25	4	[2, 2]
25	5	[2, 2]
5	5	[2, 2, 5]
		[2, 2, 5, 5]

Dies nimmt viel Zeit in Anspruch. Die kürzeste Rechenzeit wird erreicht, wenn $x$ eine Potenz von 2 ist, da dann in jeder Schleifeniteration $x$ durch 2 geteilt wird. Wenn $b$ die Anzahl der Binärziffern (Bits) ist, die die ganze Zahl $x$ darstellen, führt dies zu einer Rechenzeit von $b$ .

Der schlimmste Fall tritt ein, wenn $x$ bereits eine Primzahl ist: Dies würde zu einer Rechenzeit von $\sqrt{2^{b}} = {\sqrt{2}}^{b}$ führen. Mit anderen Worten: Die Rechenzeit ist exponentiell in Bezug zur Größe einer Zahl.

Zur Veranschaulichung dieser abstrakten Notation: Wenn eine einzelne Iteration der Schleife 1 Mikrosekunde dauert, würde die Rechenzeit für die Faktorisierung von 373628601156041617 – 59 Binärziffern sind erforderlich, um diese Zahl darzustellen – zwischen 59 Mikrosekunden und etwa 13 Minuten liegen:

${\sqrt{2}}^{59} μ s \approx 759 000 000 μ s = 759 s \approx 12,7 Minuten$

Wie man die Anzahl der Binärziffern (Bits) bestimmt Wie man die Anzahl der Binärziffern (Bits) bestimmt

Wie bestimmt man z. B. die Anzahl der Binärziffern (Bits) von 25?

25 = 2 × 2 × 2 × 2 + 2 × 2 × 2 + 1 = $2^{4}$ + $2^{3}$ + 1.

In der Basis 2 entspricht das 11001 (d. h. 5 Ziffern). Die Anzahl der Binärziffern, die zur Darstellung der Zahl 25 benötigt werden, beträgt also 5.

Die Big-O-Notation

Die Big‑O‑Notation wird in der Informatik verwendet, um die ungefähre Rechenzeit zu bestimmen, die ein Algorithmus zur Durchführung einer bestimmten Berechnung braucht, z. B. die Berechnung des Wertes der Funktion $f (x)$ in Abhängigkeit von der Eingabegröße $x$ . Alle konstanten Faktoren werden vernachlässigt, ebenso wie konstante und/oder langsamer wachsende Terme der Funktion. Es wird nur der am schnellsten wachsende Term berücksichtigt. Dies ergibt ein grobes „allgemeines Bild“ des Verhaltens einer Funktion.

Zum Beispiel wächst die Parabel $f (x) = x^{2}$ für $0 \leq x \leq 1$ langsamer als die Gerade $g (x) = x$ .

Für $x > 1$ „überholt“ die Parabel die Gerade. Dies gilt sogar, wenn ein beliebig kleiner, aber positiver Faktor $a$ vor $x^{2}$ gesetzt wird oder wenn eine beliebige Zahl $c$ hinzugefügt wird, sodass $f (x) = a x^{2} + c$ .

Es gibt immer ein $x$ , ab dem die Parabel die Gerade „überholt“. Daher ist für große Werte von $x$ nur der dominante Teil der Funktion relevant, in diesem Fall geschrieben als $O (x^{2})$ .

Geraden wachsen „linear“ – in der Big‑O‑Notation als $O (x)$ bezeichnet –, während Parabeln „quadratisch“ anwachsen – $O (x^{2})$ .

Polynome haben eine „polynomiale“ Wachstumsrate. Für ein Polynom $h (x) = a_{n} x^{n} + a_{n - 1} x^{n - 1} + \dots + a_{2} x^{2} + a_{1} x + a_{0}$ ergibt sich die Wachstumsrate $O (x^{n})$ . Dabei wird nur $x^{n}$ beibehalten, während $a_{n}$ und alle langsamer wachsenden Terme vernachlässigt werden.

Eine noch größere Wachstumsrate ist die „exponentielle“ Wachstumsrate $O (2^{x})$ .

Die Fakultät einer natürlichen Zahl $n$ ist das Produkt der ersten $n$ natürlichen Zahlen, also

$n! = 1 \cdot 2 \cdot 3 \cdot \dots \cdot (n - 2) \cdot (n - 1) \cdot n$ .

Überblick über gängige Wachstumsklassen

Name	Linear	Quadratisch	Polynomial	Exponentiell	Faktoriell
Wachstumsklasse	O(x)	O(x²)	O(xⁿ)	O(2^x)	O(x!)

Linear Linear

Quadratisch Quadratisch

Polynomial Polynomial

Exponentiell Exponentiell

Faktoriell Faktoriell

2. Der RSA‑Algorithmus

Der RSA‑Algorithmus für die Public‑Key‑Kryptografie verwendet sehr große Zahlen (in der Regel etwa 4096 Bits; dies entspricht etwa 1234 Dezimalziffern), die das Produkt zweier großer Primfaktoren sind. Die Rechenzeit für die Faktorisierung einer so großen Zahl liegt daher ungefähr bei der oberen Rechenzeitgrenze, d. h. ${\sqrt{2}}^{b}$ (wobei $b$ die Anzahl der Bits ist). Verfeinerte Algorithmen können die Leistung des Algorithmus verbessern, aber die Rechenzeit bleibt in diesem Bereich und liegt in der Regel bei etwa $O (b^{x})$ , wobei $b$ eine kleine Zahl ist, die dennoch größer als 1 ist.

Um derart große Zahlen zu faktorisieren, wie sie für den RSA‑Algorithmus verwendet werden, würde ein klassischer Computer Hunderttausende von Jahren benötigen. Aus diesem Grund ist der RSA‑Algorithmus, der nach wie vor weit verbreitet ist, so sicher. Bis heute ist kein klassischer Algorithmus bekannt, der eine Zahl schneller faktorisieren kann als der RSA‑Algorithmus. Ein vom Mathematiker Peter Shor entwickelter Quantenalgorithmus, der „Shor‑Algorithmus“ (siehe Das Unknackbare knacken: Der Shor-Algorithmus), benötigt jedoch nur eine polynomiale Laufzeit $O (x^{n})$ . Dies stellt eine erhebliche Beschleunigung dar und würde die RSA‑Verschlüsselung angreifbar machen. Glücklicherweise würde ein Quantencomputer mit etwa 20 Millionen^[2] sogenannten „noisy“ (also nicht idealen) Qubits etwa acht Stunden brauchen, um einen RSA‑Schlüssel mit 2048 Bits zu knacken. Dies übersteigt noch immer die Fähigkeiten heutiger Quantencomputer.

Das Knacken eines RSA‑Schlüssels ist ein gutes Beispiel, um Quantenüberlegenheit zu demonstrieren: In der „klassischen“ Informatik sind bisher nur Algorithmen bekannt, die RSA‑Schlüssel mit einer Rechenzeit knacken können, die schneller als polynomial mit der Größe der Eingabezahl anwächst. Mit Quantencomputern könnte diese Rechenzeit dagegen erheblich verkürzt werden.

3. Aufgaben

Aufgabe 1

Ein klassisches Problem, dessen Lösung eine sehr lange Rechenzeit erfordert, ist das „Problem des Handelsreisenden“ (englisch: Travelling Salesman Problem). Stell dir vor, ein Handelsvertreter muss mit seinem Lastwagen in die 20 größten Städte deines Landes fahren, um Waren auszuliefern. Er kann dies in einer beliebigen Reihenfolge tun, aber je weniger Zeit er für die Rundreise braucht, umso besser für ihn, da er ein festes Gehalt erhält und nach der Auslieferung der Waren nach Hause fahren kann.

Ermittle die ungefähre Zeit für die Berechnung der besten Route in Big‑O‑Notation.

Hinweis: Beginne mit einer Stadt und füge dann nach und nach weitere Städte hinzu, um einen Ausdruck für alle möglichen Routen zu finden. Sei nicht überrascht, wenn er 77 094 Jahre braucht, um die beste Route zu finden, wenn die Berechnung für eine einzelne Route 1 µs dauert.

Lösung Lösung

Für eine Stadt ist das Problem trivial: Es braucht genau einen Besuch. Für eine zweite Stadt gibt es doppelt so viele Möglichkeiten, denn es könnte jeweils die erste oder die zweite Stadt zuerst besucht werden. Für eine dritte Stadt gibt es bereits dreimal so viele Möglichkeiten wie für zwei Städte, denn die neue Stadt könnte vor, zwischen oder nach den bereits geplanten Besuchen besucht werden, so dass es 2 · 3 = 6 Reihenfolgen gibt, in der die Städte besucht werden können.

Ganz allgemein gilt: Wenn bereits n Städte besucht wurden, gibt es für eine weitere Stadt n + 1 Mal so viele Möglichkeiten wie bei n Städten. Diese Art von Wachstum ist ein faktorielles Wachstum, so dass für n Städte insgesamt n! mögliche Routen existieren.

Für 20 Städte gibt es also 20! ≈ 2,433 · 10¹⁸ mögliche Routen. Wenn das Berechnen einer Route 1 µs dauert, bräuchte man für das Berechnen der möglichen Routen bei 20 Städten:
(2,433 · 10¹⁸) / (1 000 000 · 60 · 60 · 24 · 365,25) ≈ 77 094 Jahre.

Aufgabe 2

Du machst mit deiner Klasse eine Wanderung und sollst einen Rucksack mit Proviant mitbringen. Du willst so viel Proviant wie möglich mitnehmen, aber das Fassungsvermögen deines Rucksacks beträgt maximal 13,5 kg.

Die Lebensmittel (die nicht geteilt werden dürfen) haben folgende Massen: 0,025 kg, 0,9 kg, 1,6 kg, 1,7 kg, 2,25 kg, 2,85 kg, 3,15 kg, 3,45 kg, 4,9 kg und 6,05 kg.

Wie viel Proviant kannst du maximal mitnehmen?

Lösung Lösung

Um das Optimum zu finden, müssen alle möglichen Packkombinationen einzelner Wegzehrungsgegenstände ausprobiert werden. Es gibt zwar einige Optimierungsmöglichkeiten, zum Beispiel anzuhalten, wenn eine Lösung gefunden ist, die die Kapazität des Rucksacks vollständig ausnutzt.

Weil es 10 Gegenstände mit verschiedenen Massen gibt, gibt es insgesamt 2¹⁰ mögliche Kombinationen dieser Gegenstände (für jeden Gegenstand, ob er eingepackt wird oder nicht). Deshalb ist die Laufzeit in O(2^x).

Um die optimale Lösung zu finden, überprüft das folgende Programm jede mögliche Kombination, indem es einfach über die Zahlen 0 bis 2¹⁰ − 1 iteriert, die den verschiedenen Packkombinationen entsprechen. Für jedes Bit, das 1 ist, wird der entsprechende Gegenstand „eingepackt“. Wenn die Masse innerhalb der Kapazität des Rucksacks, aber größer ist als die Masse der bisher größten Packkombination, wird dies als (bisher) beste Packkombination gespeichert. Am Ende wird das globale Optimum (oder eines von denen, wenn mehrere gleichwertige existieren) ausgegeben.

def bit(number, position):
  """Gibt True zurueck, wenn number ein Bit 1 an der Position position hat, sonst False"""
  temp = number
  for i in range(position): # Teilen, bis das letzte Bit das ist, an dem wir interessiert sind
    temp = temp // 2
  if temp % 2 == 0: # Ist durch 2 teilbar
    return False
  else:
    return True

def weight(knapsack):
  """Berechnet die Masse des Rucksackinhalts durch Aufsummieren der individuellen Massen"""
  weight = 0
  for i in range(len(knapsack)):
    weight = weight + knapsack[i]
  return weight

items = [0.025, 0.9, 1.6, 1.7, 2.25, 2.85, 3.15, 3.45, 4.9, 6.05]
maximum_weight = 13.5
optimum = []

for bitcombination in range(2 ** len(items)): # Alle moeglichen Kombinationen zum "Einpacken" der jeweiligen Gegenstaende/Massen in Form einer Zahl, deren Bits den Massen entsprechen
  knapsack = []
  for bitposition in range(len(items)):
    if bit(bitcombination, bitposition): # Wenn das Bit fuer den Gegenstand 1 ist, muss der Gegenstand "eingepackt" werden
      knapsack.append(items[bitposition])
  if weight(knapsack) <= maximum_weight: # Wenn dies in den Rucksack passt
    if weight(optimum) < weight(knapsack): # Ein Rucksack mit einem besseren Packgewicht wurde gefunden
      optimum = knapsack

print("Ein optimal gefuellter Rucksack wiegt", weight(optimum), "und beinhaltet die Gegenstaende mit folgenden Massen:", optimum)

Aufgabe 3

(alternativ zu Aufgabe 2)

Das Damen‑Problem ist ein berühmtes Schachproblem: Auf einem 8×8‑Schachbrett werden acht Königinnen (die sich vertikal, horizontal und diagonal bewegen können) so platziert, dass sie sich nicht innerhalb eines Zuges von einer zur anderen bewegen können. Finde eine Lösung für dieses Problem.

Wenn du herausgefunden hast, wie sich das Problem theoretisch lösen lässt, schreibe ein Computerprogramm, das alle möglichen Lösungen ausgibt.

Erstelle anschließend ein Computerprogramm, das alle möglichen Lösungen für ein n×n‑großes Schachbrett ausgibt, und analysiere die Rechenzeit in Abhängigkeit von der Größe des Schachbretts.

Lösung Lösung

Das Damenproblem, auch bekannt als Acht-Damen-Problem, ist ein bekanntes Beispielproblem für verschiedene Programmiertechniken in der Informatik. Es wurde erstmals 1848 vom Schachkomponisten Max Bezzel veröffentlicht, und seitdem haben sich viele Mathematiker mit diesem Problem sowie mit seiner verallgemeinerten Form, dem n-Damen-Problem, beschäftigt.

Unter Wikipedia: Damenproblem ^[3] ist das Problem erläutert. Dort findet sich auch eine Python-Lösung für das Problem.

Quellen Quellen

WolframAlpha
https://www.wolframalpha.com/
(letzter Zugriff 13.03.2026)
Craig Gidney: How to factor 2048 bit RSA integers with less than a million noisy qubits (2025).
(letzter Zugriff 13.03.2026)
Wikipedia: Damenproblem
https://de.wikipedia.org/wiki/Damenproblem
(letzter Zugriff 13.03.2026)

Weiter zu: Qubits, Quantengatter und Quantenschaltkreise

Diese Seite teilen

Die Überlegenheit von Quantencomputern – aus der Informatikperspektive

Übersicht

Auf einen Blick

Inhaltsübersicht

Zusammenfassung

Material

1. Rechenkomplexität und die Big-O-Notation

Aufgabe 1

Aufgabe 2

Aufgabe 3

Erklärung

Die Big-O-Notation

Überblick über gängige Wachstumsklassen

2. Der RSA‑Algorithmus

3. Aufgaben

Aufgabe 1

Aufgabe 2

Aufgabe 3

Ähnliche Unterrichtsmaterialien

Der Deutsch-Algorithmus: Aus der Informatikperspektive

Der Bernstein-Vazirani-Algorithmus - aus der Informatikperspektive