{
"cells": [
{
"cell_type": "markdown",
"id": "1f7fe7f1-988f-461f-8222-f291404b912a",
"metadata": {},
"source": [
"---\n",
"title: \"Bit-Reihenfolge im „ Qiskit SDK “\"\n",
"description: \"Erfahren Sie mehr über die Bestellkonventionen von „ Qiskit SDK “ und warum wir uns dafür entschieden haben\"\n",
"---\n",
"\n",
"{/* cspell:ignore leftrightarrow */}\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "49fb8eee-d17a-4648-8b6f-52097acfb305",
"metadata": {
"tags": [
"version-info"
]
},
"source": [
"{/*\n",
" DO NOT EDIT THIS CELL!!!\n",
" This cell's content is generated automatically by a script. Anything you add\n",
" here will be removed next time the notebook is run. To add new content, create\n",
" a new cell before or after this one.\n",
" */}\n",
"\n",
"\n",
" \n",
" Der Code auf dieser Seite wurde unter Berücksichtigung der folgenden Anforderungen entwickelt.\n",
" Wir empfehlen die Verwendung dieser oder neuerer Versionen.\n",
"\n",
" ```\n",
" qiskit[all]~=2.5.2\n",
" ```\n",
" \n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "369b8b49-a2af-4999-85df-f7659022e11b",
"metadata": {},
"source": [
"\n",
"\n",
"# Bit-Reihenfolge im „ Qiskit SDK “\n",
"\n",
"Wenn Sie einen Satz von $n$ Bits (oder Qubits) haben, werden Sie normalerweise jedes Bit mit $0 \\rightarrow n-1$ bezeichnen. Verschiedene Softwares und Ressourcen müssen entscheiden, wie sie diese Bits sowohl im Computerspeicher als auch bei der Anzeige auf dem Bildschirm anordnen.\n",
"\n",
"\n",
"\n",
"## Qiskit-Konventionen\n",
"\n",
"Hier sehen Sie, wie das Qiskit SDK Bits in verschiedenen Szenarien anordnet.\n",
"\n",
"\n",
"\n",
"### Basiselemente\n",
"\n",
"Standardmäßig verwendet Qiskit die Little-Endian-Konvention für die Bitreihenfolge. Die Standardeinstellung für ist [`BitArray`](/docs/api/qiskit/qiskit.primitives.BitArray#to_bool_array) jedoch `big` (Endian), was zu einigen Abweichungen bei der Ausgabe der Primitive führt, je nachdem, ob die Primitive diese Einstellung ändert. Beispielsweise geben die Primitive „Service Sampler“ und „Estimator“ des „ IBM® Quantum Compute “ Ergebnisse im Big-Endian-Format zurück, während „Executor“ Ergebnisse im Little-Endian-Format zurückgibt.\n",
"\n",
"\n",
"\n",
"### Quantenschaltungen\n",
"\n",
"Die Klasse `QuantumCircuit` speichert ihre Qubits in einer Liste (`QuantumCircuit.qubits`). Der Index eines Qubits in dieser Liste definiert das bezeichnung des Qubits.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "a1c61ed7-72df-447e-a103-ce0e273626c9",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit, QuantumRegister\n",
"from qiskit.circuit import Qubit\n",
"\n",
"qc = QuantumCircuit(2)\n",
"qc.qubits[0] # qubit \"0\"\n",
"\n",
"Qubit(QuantumRegister(2, \"q\"), 0)"
]
},
{
"cell_type": "markdown",
"id": "22c49977-e960-4620-ae1d-a7a90a879b45",
"metadata": {},
"source": [
"\n",
"\n",
"### Schaltpläne\n",
"\n",
"In einem Schaltplan ist das Qubit $0$ das oberste Qubit und das Qubit $n-1$ das unterste Qubit. Sie können dies ändern mit dem `reverse_bits` Argument von `QuantumCircuit.draw` (siehe [Reihenfolge in Qiskit ändern](#change-ordering-in-qiskit) ).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "a4e175af-8882-427a-a276-bd51a3d9be57",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
" \n",
"q_0: ─────\n",
" ┌───┐\n",
"q_1: ┤ X ├\n",
" └───┘"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc.x(1)\n",
"qc.draw()"
]
},
{
"cell_type": "markdown",
"id": "19aa0892-a578-49e3-98df-14c696d01896",
"metadata": {},
"source": [
"\n",
"\n",
"### Ganzzahlen\n",
"\n",
"Bei der Interpretation der Bits als Zahl ist das Bit $0$ das niederwertigste Bit und bit $n-1$ das höchstwertige. Dies ist bei der Kodierung hilfreich, da jedes Bit den Wert den Wert $2^\\text{label}$ hat (die Bezeichnung ist der Index des Qubits in `QuantumCircuit.qubits`). Die folgende Schaltungsausführung endet zum Beispiel mit dem Bit $0$ als `0` und dem Bit $1$ als `1`. Dies wird interpretiert als die dezimale Ganzzahl `2` (gemessen mit der Wahrscheinlichkeit `1.0`).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "7ecb86d3-fe3a-43b0-9293-cba967e80fdc",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" > Counts: {'10': 1024}\n"
]
}
],
"source": [
"from qiskit.primitives import StatevectorSampler as Sampler\n",
"\n",
"qc.measure_all()\n",
"\n",
"job = Sampler().run([qc])\n",
"result = job.result()\n",
"print(f\" > Counts: {result[0].data.meas.get_counts()}\")"
]
},
{
"cell_type": "markdown",
"id": "e263f4f9-f383-4583-bdd4-f8792d6809db",
"metadata": {},
"source": [
"\n",
"\n",
"### Zeichenfolgen\n",
"\n",
"Wenn eine Liste von Bits (oder Qubits) als Zeichenkette angezeigt oder interpretiert wird, ist Bit $n-1$ das am weitesten links stehende Bit, und Bit $0$ das am weitesten rechts stehende Bit. Das liegt daran, dass wir zahlen normalerweise mit der höchstwertigen Stelle auf der linken Seite schreiben, und in Qiskit wird das Bit $n-1$ als das höchstwertige Bit interpretiert.\n",
"\n",
"Zum Beispiel definiert die folgende Zelle einen \"Zustandsvektor\" aus einer Kette von ein-Qubit-Zuständen. In diesem Fall befindet sich das Qubit $0$ im Zustand $|+\\rangle$, und qubit $1$ im Zustand $|0\\rangle$.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "2cffb8d4-66db-4c1c-b0c2-b796ed6e8ce0",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{np.str_('00'): np.float64(0.4999999999999999),\n",
" np.str_('01'): np.float64(0.4999999999999999)}"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit.quantum_info import Statevector\n",
"\n",
"sv = Statevector.from_label(\"0+\")\n",
"sv.probabilities_dict()"
]
},
{
"cell_type": "markdown",
"id": "86c48e21-9138-4dec-a312-0b5deefd0e35",
"metadata": {},
"source": [
"Dies führt gelegentlich zu Verwirrung bei der Interpretation einer Bitfolge, da man erwarten könnte, dass das ganz linke Bit das Bit $0$ ist, während es normalerweise das Bit $n-1$.\n",
"\n",
"\n",
"\n",
"### Zustandsvektormatrizen\n",
"\n",
"Bei der Darstellung eines Zustandsvektors als Liste von komplexen Zahlen (Amplituden), Ordnet Qiskit diese Amplituden so an, dass die Amplitude bei Index $x$ den Berechnungsbasiszustand $|x\\rangle$ darstellt.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "d6ff798a-6bdc-4727-8331-b575fbf1e083",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(0.7071067811865475+0j)\n",
"0j\n"
]
}
],
"source": [
"print(sv[1]) # amplitude of state |01>\n",
"print(sv[2]) # amplitude of state |10>"
]
},
{
"cell_type": "markdown",
"id": "cc92b428-80c7-4530-bebc-3486aecee5f2",
"metadata": {},
"source": [
"\n",
"\n",
"### Gates\n",
"\n",
"Jedes Gatter in Qiskit kann eine Liste von Qubits auf seine eigene Weise interpretieren, aber kontrollierte Gatter folgen normalerweise der Konvention `(control, target)`.\n",
"\n",
"Die folgende Zelle fügt zum Beispiel ein kontrolliertes X-Gatter hinzu, bei dem das Qubit $0$ die Steuerung und das Qubit $1$ das Ziel ist.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "f2e34794-2f04-4065-9a1d-9aff022204db",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
" \n",
"q_0: ──■──\n",
" ┌─┴─┐\n",
"q_1: ┤ X ├\n",
" └───┘"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"qc = QuantumCircuit(2)\n",
"qc.cx(0, 1)\n",
"qc.draw()"
]
},
{
"cell_type": "markdown",
"id": "2b9ee336-e645-41ee-aeda-5f9dfe3a3f88",
"metadata": {},
"source": [
"Gemäß den zuvor erwähnten Konventionen in Qiskit führt dieses CX-Tor die Transformation $|01\\rangle \\leftrightarrow |11\\rangle$ durch, hat also die folgende Matrix.\n",
"\n",
"$$\n",
"\\begin{pmatrix}\n",
" 1 & 0 & 0 & 0 \\\\\n",
" 0 & 0 & 0 & 1 \\\\\n",
" 0 & 0 & 1 & 0 \\\\\n",
" 0 & 1 & 0 & 0 \\\\\n",
"\\end{pmatrix}\n",
"$$\n",
"\n",
"\n",
"\n",
"## Änderung der Reihenfolge in Qiskit\n",
"\n",
"Um eine Schaltung mit Qubits in umgekehrter Reihenfolge zu zeichnen (d.h. Qubit $0$ am unten), verwenden Sie das Argument `reverse_bits` . Dies betrifft nur das erzeugte diagramm und hat keinen Einfluss auf die Schaltung; das X-Gate wirkt weiterhin auf das Qubit $0$.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "6d31e88d-2a4f-4404-8177-7bccd0c19d4b",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
" \n",
"q_1: ─────\n",
" ┌───┐\n",
"q_0: ┤ X ├\n",
" └───┘"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from qiskit import QuantumCircuit\n",
"\n",
"qc = QuantumCircuit(2)\n",
"qc.x(0)\n",
"qc.draw(reverse_bits=True)"
]
},
{
"cell_type": "markdown",
"id": "4e343e80-3f77-4fe7-8942-afbe71f756ab",
"metadata": {},
"source": [
"Sie können die Methode `reverse_bits` verwenden, um einen neuen Schaltkreis mit den qubits zurückgeben (die ursprüngliche Schaltung wird dabei nicht verändert).\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "4c6a38b7-f6a1-4753-94e6-2c488ec37b8d",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
" \n",
"q_0: ─────\n",
" ┌───┐\n",
"q_1: ┤ X ├\n",
" └───┘"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc.reverse_bits().draw()"
]
},
{
"cell_type": "markdown",
"id": "da750e37-2624-4797-82c0-560ee7d5367d",
"metadata": {},
"source": [
"Man beachte, dass in dieser neuen Schaltung das X-Gate auf das Qubit $1$ wirkt.\n",
"\n",
"\n",
"\n",
"## Nächste Schritte\n",
"\n",
"\n",
" * Ein Beispiel für die Verwendung von Schaltkreisen finden Sie im Lernprogramm [Grovers Algorithmus](/docs/tutorials/grovers-algorithm).\n",
" * Erkunden Sie die [QuantumCircuit API-Referenz](/docs/api/qiskit/qiskit.circuit.QuantumCircuit#quantumcircuit-class).\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"id": "a1b8767d",
"source": "© IBM Corp., 2017-2026"
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}