Skip to content

Instantly share code, notes, and snippets.

@primaryobjects

primaryobjects/1-entanglement.py

Last active August 6, 2025 21:02
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save primaryobjects/235fd81d08bf26f06b66d421053144f0 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save primaryobjects/235fd81d08bf26f06b66d421053144f0 to your computer and use it in GitHub Desktop.
Download ZIP
Quantum entanglement to display two different characters using Qiskit and Python. Quantum computing.
Raw
1-entanglement.py
# Imports
!pip install qiskit
!pip install qiskit-aer
!pip install pylatexenc
# Quantum program
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
from numpy import pi
qreg_q = QuantumRegister(4, 'q')
creg_c = ClassicalRegister(4, 'c')
qc = QuantumCircuit(qreg_q, creg_c)
qc.h(qreg_q[0])
qc.cx(qreg_q[0], qreg_q[1])
qc.barrier(qreg_q)
qc.measure(qreg_q, creg_c)
qc.draw(output='mpl')
# Running the program
numbers = []
results = {}
# Select the simulator.
simulator = Aer.get_backend('aer_simulator')
compiled_circuit = transpile(qc, simulator)
for i in range(100):
# Execute the circuit.
job = simulator.run(compiled_circuit)
result = job.result()
counts = result.get_counts()
# Find the most frequent hit count.
key = max(counts, key=counts.get)
# Since the quantum computer returns a binary string (one bit for each qubit), we need to convert it to an integer.
num = int(key, 2)
numbers.append(num)
# Count occurrences of each value for plotting a histogram of the random values.
results[num] = results[num] + 1 if num in results else 1
# Print character based on last 4 bits
if num == (ord('@') & 0xF): # Compare to last 4 bits of '@' (64)
print(f"Result: {key} -> Character: '@'")
elif num == (ord('C') & 0xF): # Compare to last 4 bits of 'C' (67)
print(f"Result: {key} -> Character: 'C'")
else:
print(f"Result: {key} -> No matching character")
print(counts)
plot_histogram(counts)
Raw
2-draw.py
from matplotlib.textpath import TextPath
from matplotlib.patches import PathPatch
from matplotlib.font_manager import FontProperties
# Font and figure setup
fig, ax = plt.subplots(figsize=(6, 6)) # Bigger canvas
ax.set_aspect('equal')
ax.axis('off')
fp = FontProperties(family="DejaVu Sans", weight="bold")
size = 200 # Large font
# ASCII and bit values
at_code = ord('@') # 64
c_code = ord('C') # 67
at_4bit = at_code & 0xF # 0
c_4bit = c_code & 0xF # 3
# Total occurrences
total_shots = sum(results.values())
at_count = results.get(at_4bit, 0)
c_count = results.get(c_4bit, 0)
# Calculate opacity
alpha_at = at_count / total_shots
alpha_c = c_count / total_shots
# Draw superimposed characters
x, y = 0.0, 0.0
if at_count > 0:
path_at = TextPath((x, y), "@", size=size, prop=fp)
patch_at = PathPatch(path_at, facecolor='blue', alpha=alpha_at, label=f"'@' ({at_count})")
ax.add_patch(patch_at)
if c_count > 0:
path_c = TextPath((x, y), "C", size=size, prop=fp)
patch_c = PathPatch(path_c, facecolor='red', alpha=alpha_c, label=f"'C' ({c_count})")
ax.add_patch(patch_c)
# Expand limits to prevent clipping
ax.set_xlim(-50, 250)
ax.set_ylim(-50, 250)
# Show result
ax.legend(loc='upper right')
plt.title("Superimposed '@' and 'C' — Opacity ∝ Frequency")
plt.show()
Display the source blob
Display the rendered blob
Raw
3-workbook.ipynb
{
"cells": [
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "a-Byfjdk_9Jp",
"outputId": "66a86cdb-ccbb-441b-f510-202b4f6efd61"
},
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Requirement already satisfied: qiskit in /usr/local/lib/python3.11/dist-packages (2.1.1)\n",
"Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.11/dist-packages (from qiskit) (0.16.0)\n",
"Requirement already satisfied: numpy<3,>=1.17 in /usr/local/lib/python3.11/dist-packages (from qiskit) (2.0.2)\n",
"Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.11/dist-packages (from qiskit) (1.16.1)\n",
"Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.11/dist-packages (from qiskit) (0.3.8)\n",
"Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.11/dist-packages (from qiskit) (5.4.1)\n",
"Requirement already satisfied: typing-extensions in /usr/local/lib/python3.11/dist-packages (from qiskit) (4.14.1)\n",
"Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.11/dist-packages (from stevedore>=3.0.0->qiskit) (6.1.1)\n",
"Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from pbr>=2.0.0->stevedore>=3.0.0->qiskit) (75.2.0)\n",
"Requirement already satisfied: qiskit-aer in /usr/local/lib/python3.11/dist-packages (0.17.1)\n",
"Requirement already satisfied: qiskit>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from qiskit-aer) (2.1.1)\n",
"Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.11/dist-packages (from qiskit-aer) (2.0.2)\n",
"Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.11/dist-packages (from qiskit-aer) (1.16.1)\n",
"Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.11/dist-packages (from qiskit-aer) (5.9.5)\n",
"Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.11/dist-packages (from qiskit-aer) (2.9.0.post0)\n",
"Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.8.0->qiskit-aer) (1.17.0)\n",
"Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.11/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.16.0)\n",
"Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.11/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.3.8)\n",
"Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.11/dist-packages (from qiskit>=1.1.0->qiskit-aer) (5.4.1)\n",
"Requirement already satisfied: typing-extensions in /usr/local/lib/python3.11/dist-packages (from qiskit>=1.1.0->qiskit-aer) (4.14.1)\n",
"Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.11/dist-packages (from stevedore>=3.0.0->qiskit>=1.1.0->qiskit-aer) (6.1.1)\n",
"Requirement already satisfied: setuptools in /usr/local/lib/python3.11/dist-packages (from pbr>=2.0.0->stevedore>=3.0.0->qiskit>=1.1.0->qiskit-aer) (75.2.0)\n",
"Collecting pylatexenc\n",
" Downloading pylatexenc-2.10.tar.gz (162 kB)\n",
"\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m162.6/162.6 kB\u001b[0m \u001b[31m3.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
"\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
"Building wheels for collected packages: pylatexenc\n",
" Building wheel for pylatexenc (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
" Created wheel for pylatexenc: filename=pylatexenc-2.10-py3-none-any.whl size=136817 sha256=93c597c9815215330816a976c7121fc5aea710026b54eec179a8e5b875979622\n",
" Stored in directory: /root/.cache/pip/wheels/b1/7a/33/9fdd892f784ed4afda62b685ae3703adf4c91aa0f524c28f03\n",
"Successfully built pylatexenc\n",
"Installing collected packages: pylatexenc\n",
"Successfully installed pylatexenc-2.10\n"
]
}
],
"source": [
"!pip install qiskit\n",
"!pip install qiskit-aer\n",
"!pip install pylatexenc"
]
},
{
"cell_type": "markdown",
"metadata": {
"id": "VkAzQSx4_9Jq"
},
"source": [
"Once we have Qiskit is installed we want to test that it's working properly."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 35
},
"id": "uMvbZscA_9Jq",
"outputId": "cadd9f62-6cf6-4037-aabb-3c327cfe36d5"
},
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"'2.1.1'"
],
"application/vnd.google.colaboratory.intrinsic+json": {
"type": "string"
}
},
"metadata": {},
"execution_count": 1
}
],
"source": [
"import qiskit\n",
"qiskit.__version__"
]
},
{
"cell_type": "code",
"source": [
"from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, transpile\n",
"from qiskit_aer import Aer\n",
"from qiskit.visualization import plot_histogram\n",
"import matplotlib.pyplot as plt\n",
"from numpy import pi\n",
"\n",
"qreg_q = QuantumRegister(4, 'q')\n",
"creg_c = ClassicalRegister(4, 'c')\n",
"qc = QuantumCircuit(qreg_q, creg_c)\n",
"\n",
"qc.h(qreg_q[0])\n",
"qc.cx(qreg_q[0], qreg_q[1])\n",
"qc.barrier(qreg_q)\n",
"qc.measure(qreg_q, creg_c)\n",
"\n",
"qc.draw(output='mpl')"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 384
},
"id": "STWeenf5AD5c",
"outputId": "b3f9a05d-65a2-4c6f-9361-5de14b47c749"
},
"execution_count": 7,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"<Figure size 705.552x451.5 with 1 Axes>"
],
"image/png": "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\n"
},
"metadata": {},
"execution_count": 7
}
]
},
{
"cell_type": "code",
"source": [
"numbers = []\n",
"results = {}\n",
"\n",
"# Select the simulator.\n",
"simulator = Aer.get_backend('aer_simulator')\n",
"compiled_circuit = transpile(qc, simulator)\n",
"\n",
"for i in range(100):\n",
" # Execute the circuit.\n",
" job = simulator.run(compiled_circuit)\n",
" result = job.result()\n",
" counts = result.get_counts()\n",
"\n",
" # Find the most frequent hit count.\n",
" key = max(counts, key=counts.get)\n",
"\n",
" # Since the quantum computer returns a binary string (one bit for each qubit), we need to convert it to an integer.\n",
" num = int(key, 2)\n",
"\n",
" numbers.append(num)\n",
"\n",
" # Count occurrences of each value for plotting a histogram of the random values.\n",
" results[num] = results[num] + 1 if num in results else 1\n",
"\n",
" # Print character based on last 4 bits\n",
" if num == (ord('@') & 0xF): # Compare to last 4 bits of '@' (64)\n",
" print(f\"Result: {key} -> Character: '@'\")\n",
" elif num == (ord('C') & 0xF): # Compare to last 4 bits of 'C' (67)\n",
" print(f\"Result: {key} -> Character: 'C'\")\n",
" else:\n",
" print(f\"Result: {key} -> No matching character\")\n",
"\n",
"print(counts)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/"
},
"id": "EfrBKupbCLA7",
"outputId": "a6ca2aa5-20b1-46ce-8522-0bfd6b68534e"
},
"execution_count": 13,
"outputs": [
{
"output_type": "stream",
"name": "stdout",
"text": [
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0011 -> Character: 'C'\n",
"Result: 0000 -> Character: '@'\n",
"Result: 0000 -> Character: '@'\n",
"{'0000': 523, '0011': 501}\n"
]
}
]
},
{
"cell_type": "code",
"source": [
"plot_histogram(counts)"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 487
},
"id": "94SKDfGsC9Sv",
"outputId": "d7799c58-bee3-414a-8e3d-6bfb141ec3d7"
},
"execution_count": 12,
"outputs": [
{
"output_type": "execute_result",
"data": {
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
],
"image/png": "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\n"
},
"metadata": {},
"execution_count": 12
}
]
},
{
"cell_type": "code",
"source": [
"from matplotlib.textpath import TextPath\n",
"from matplotlib.patches import PathPatch\n",
"from matplotlib.font_manager import FontProperties\n",
"\n",
"# Font and figure setup\n",
"fig, ax = plt.subplots(figsize=(6, 6)) # Bigger canvas\n",
"ax.set_aspect('equal')\n",
"ax.axis('off')\n",
"\n",
"fp = FontProperties(family=\"DejaVu Sans\", weight=\"bold\")\n",
"size = 200 # Large font\n",
"\n",
"# ASCII and bit values\n",
"at_code = ord('@') # 64\n",
"c_code = ord('C') # 67\n",
"at_4bit = at_code & 0xF # 0\n",
"c_4bit = c_code & 0xF # 3\n",
"\n",
"# Total occurrences\n",
"total_shots = sum(results.values())\n",
"at_count = results.get(at_4bit, 0)\n",
"c_count = results.get(c_4bit, 0)\n",
"\n",
"# Calculate opacity\n",
"alpha_at = at_count / total_shots\n",
"alpha_c = c_count / total_shots\n",
"\n",
"# Draw superimposed characters\n",
"x, y = 0.0, 0.0\n",
"\n",
"if at_count > 0:\n",
" path_at = TextPath((x, y), \"@\", size=size, prop=fp)\n",
" patch_at = PathPatch(path_at, facecolor='blue', alpha=alpha_at, label=f\"'@' ({at_count})\")\n",
" ax.add_patch(patch_at)\n",
"\n",
"if c_count > 0:\n",
" path_c = TextPath((x, y), \"C\", size=size, prop=fp)\n",
" patch_c = PathPatch(path_c, facecolor='red', alpha=alpha_c, label=f\"'C' ({c_count})\")\n",
" ax.add_patch(patch_c)\n",
"\n",
"# Expand limits to prevent clipping\n",
"ax.set_xlim(-50, 250)\n",
"ax.set_ylim(-50, 250)\n",
"\n",
"# Show result\n",
"ax.legend(loc='upper right')\n",
"plt.title(\"Superimposed '@' and 'C' — Opacity ∝ Frequency\")\n",
"plt.show()"
],
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 538
},
"id": "y6rIIY9fEyj8",
"outputId": "e97751be-bc71-445a-c098-c307504e615d"
},
"execution_count": 24,
"outputs": [
{
"output_type": "display_data",
"data": {
"text/plain": [
"<Figure size 600x600 with 1 Axes>"
],
"image/png": "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\n"
},
"metadata": {}
},
{
"output_type": "stream",
"name": "stdout",
"text": [
"100\n"
]
}
]
}
],
"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.7.2"
},
"colab": {
"provenance": []
}
},
"nbformat": 4,
"nbformat_minor": 0
}
@primaryobjects
Copy link
Author

primaryobjects commented Aug 6, 2025

Run the Python Notebook online here.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment