qiskitcode 0.1.0__py3-none-any.whl

qiskitcode/__init__.py

@@ -0,0 +1,326 @@
+"""qiskitcode — Quantum Lab Practicals: theory + code, printed on the terminal.
+
+Usage:
+    import qiskitcode
+    qiskitcode.p1()      # print practical 1 (theory + code)
+    qiskitcode.p2()      # print practical 2
+    qiskitcode.all()     # print all practicals
+    qiskitcode.show(3)   # print practical 3 by number
+    qiskitcode.list()    # list all practical titles
+
+    # The class form also works:
+    from qiskitcode import Qiskitcode
+    Qiskitcode.p1()
+    Qiskitcode.all()
+
+NOTE: ``qiskitcode.1()`` is not valid Python — an attribute name may not
+start with a digit — so the numbered practicals are ``p1()`` ... ``p6()``.
+"""
+
+__version__ = "0.1.0"
+
+_P1_CODE = '''from qiskit import QuantumCircuit
+from qiskit_aer import AerSimulator
+
+qc = QuantumCircuit(1, 1)
+qc.h(0)
+qc.measure(0, 0)
+print(qc.draw())
+
+simulator = AerSimulator()
+result = simulator.run(qc, shots=1024).result()
+print(result.get_counts())'''
+
+_P2_CODE = '''from qiskit import QuantumCircuit
+from qiskit_aer import AerSimulator
+from qiskit.visualization import plot_histogram
+import matplotlib.pyplot as plt
+
+qc = QuantumCircuit(1, 1)
+qc.h(0)
+qc.measure(0, 0)
+
+simulator = AerSimulator()
+result = simulator.run(qc, shots=1024).result()
+counts = result.get_counts()
+print(counts)
+display(plot_histogram(counts))'''
+
+_P3_CODE = '''from qiskit import QuantumCircuit, transpile
+from qiskit_aer import AerSimulator
+from qiskit.visualization import plot_histogram
+import matplotlib.pyplot as plt
+
+qc = QuantumCircuit(2, 2)
+qc.h(0)
+qc.cx(0, 1)
+qc.measure([0, 1], [0, 1])
+
+simulator = AerSimulator()
+compiled_circuit = transpile(qc, simulator)
+result = simulator.run(compiled_circuit, shots=1000).result()
+counts = result.get_counts(compiled_circuit)
+print(counts)
+display(plot_histogram(counts))
+plt.show()'''
+
+_P4_CODE = '''from qiskit import QuantumCircuit
+from qiskit_aer import AerSimulator
+
+qc = QuantumCircuit(3, 3)
+qc.x(0)
+qc.cx(0, 1)
+qc.swap(1, 2)
+qc.measure([0, 1, 2], [0, 1, 2])
+print(qc.draw())
+
+simulator = AerSimulator()
+result = simulator.run(qc, shots=1024).result()
+print(result.get_counts())'''
+
+_P5_CODE = '''from qiskit import QuantumCircuit
+from qiskit_aer import AerSimulator
+
+def deutsch_jozsa(balanced):
+    qc = QuantumCircuit(2, 1)
+    qc.x(1)
+    qc.h([0, 1])
+    if balanced:
+        qc.cx(0, 1)
+    qc.h(0)
+    qc.measure(0, 0)
+    simulator = AerSimulator()
+    result = simulator.run(qc, shots=1024).result()
+    counts = result.get_counts()
+    print(counts)
+    if '0' in counts:
+        print("Function is constant")
+    else:
+        print("Function is balanced")
+
+print("Constant function:")
+deutsch_jozsa(False)
+print("Balanced function:")
+deutsch_jozsa(True)'''
+
+_P6_CODE = '''from qiskit import QuantumCircuit
+from qiskit_aer import AerSimulator
+
+qc = QuantumCircuit(2, 2)
+qc.h([0, 1])
+# Mark state 11
+qc.cz(0, 1)
+# Diffusion operator
+qc.h([0, 1])
+qc.x([0, 1])
+qc.cz(0, 1)
+qc.x([0, 1])
+qc.h([0, 1])
+qc.measure([0, 1], [0, 1])
+print(qc.draw())
+
+simulator = AerSimulator()
+result = simulator.run(qc, shots=1024).result()
+print(result.get_counts())'''
+
+PRACTICALS = [
+    {
+        "num": 1,
+        "title": "Create a Single-Qubit Circuit Applying the Hadamard Gate",
+        "aim": "To create a single-qubit quantum circuit and apply the Hadamard gate to put the qubit into a state of superposition.",
+        "software": "Python 3, Qiskit, Qiskit Aer (AerSimulator), Jupyter Notebook.",
+        "theory": (
+            "A qubit is the basic unit of quantum information. Unlike a classical bit, which is either 0 or 1, "
+            "a qubit can exist in a superposition of both states, written as |psi> = a|0> + b|1>, where |a|^2 + |b|^2 = 1.\n\n"
+            "The Hadamard gate (H) is a single-qubit gate that creates superposition. Its matrix is "
+            "H = (1/sqrt(2)) [[1, 1], [1, -1]]. When applied to the state |0>, it gives H|0> = (|0> + |1>)/sqrt(2), "
+            "an equal superposition of |0> and |1>.\n\n"
+            "When such a qubit is measured, it collapses to either 0 or 1. Since both amplitudes are equal, "
+            "each outcome occurs with probability (1/sqrt(2))^2 = 50%. Hence repeated measurements give nearly "
+            "equal numbers of 0s and 1s."
+        ),
+        "code": _P1_CODE,
+        "output": "Counts (1024 shots): {'1': 513, '0': 511}",
+        "conclusion": "The Hadamard gate successfully puts a single qubit into an equal superposition state, and measurement gives 0 or 1 with approximately 50% probability each.",
+    },
+    {
+        "num": 2,
+        "title": "Measure the Qubit and Plot the Histogram of Results",
+        "aim": "To measure a qubit prepared in a superposition state and to plot the histogram of the measurement results obtained over many shots.",
+        "software": "Python 3, Qiskit, Qiskit Aer (AerSimulator), Matplotlib, Jupyter Notebook.",
+        "theory": (
+            "A single measurement of a qubit gives only one random outcome, so one shot cannot reveal the quantum state. "
+            "The experiment must therefore be repeated many times (shots), and the outcomes counted.\n\n"
+            "Here the qubit is first put into superposition with a Hadamard gate and then measured. "
+            "Running the circuit for 1024 shots collects the statistics of the measurement.\n\n"
+            "A histogram is a bar chart of these counts. For a qubit in equal superposition, the histogram shows two bars "
+            "of nearly equal height, one for outcome 0 and one for outcome 1, which visually confirms the 50-50 probability distribution."
+        ),
+        "code": _P2_CODE,
+        "output": "Counts (1024 shots): {'1': 533, '0': 491}. The histogram shows two bars of nearly equal height for outcomes '0' and '1'.",
+        "conclusion": "The histogram of 1024 measurements shows two nearly equal bars, confirming that the qubit in superposition is measured as 0 or 1 with approximately equal probability.",
+    },
+    {
+        "num": 3,
+        "title": "Build a Circuit to Generate a Bell State",
+        "aim": "To build a two-qubit quantum circuit that generates a Bell state, a maximally entangled state, using a Hadamard gate and a CNOT gate.",
+        "software": "Python 3, Qiskit, Qiskit Aer (AerSimulator), Matplotlib, Jupyter Notebook.",
+        "theory": (
+            "A Bell state is a maximally entangled state of two qubits. The state produced here is |Phi+> = (|00> + |11>)/sqrt(2). "
+            "In this state neither qubit has a definite value of its own; the two qubits are perfectly correlated.\n\n"
+            "The circuit applies a Hadamard gate to the first qubit, creating (|0> + |1>)/sqrt(2), and then a CNOT gate with "
+            "the first qubit as control and the second as target. The CNOT flips the target only when the control is 1, "
+            "which entangles the two qubits and produces the Bell state.\n\n"
+            "On measurement, only the outcomes 00 and 11 are observed, each with about 50% probability. "
+            "The outcomes 01 and 10 never occur, which proves that the qubits are entangled and not independent."
+        ),
+        "code": _P3_CODE,
+        "output": "Counts (1000 shots): {'00': 511, '11': 489}. Outcomes '01' and '10' do not occur. The histogram shows two nearly equal bars for '00' and '11'.",
+        "conclusion": "The Bell state |Phi+> was successfully generated. The measurement results show only the correlated outcomes 00 and 11, confirming maximal entanglement between the two qubits.",
+    },
+    {
+        "num": 4,
+        "title": "Implement a Multi-Qubit Circuit with CNOT and SWAP Gates",
+        "aim": "To implement a three-qubit circuit using X, CNOT and SWAP gates and to verify the final state obtained after these operations.",
+        "software": "Python 3, Qiskit, Qiskit Aer (AerSimulator), Jupyter Notebook.",
+        "theory": (
+            "The CNOT (controlled-NOT) gate is a two-qubit gate: it flips the target qubit only when the control qubit is "
+            "in state 1, and leaves it unchanged when the control is 0.\n\n"
+            "The SWAP gate is a two-qubit gate that exchanges the states of two qubits. If the qubits are in states |a> and |b>, "
+            "after SWAP they are in states |b> and |a>.\n\n"
+            "In this circuit the qubits start in state 000. The X gate on qubit 0 makes it 1, the CNOT (control 0, target 1) "
+            "then makes qubit 1 also 1, and the SWAP of qubits 1 and 2 moves that 1 to qubit 2. The final state is therefore 101 "
+            "(read as qubit 2, qubit 1, qubit 0), and because every gate here is deterministic, all 1024 shots give the same result."
+        ),
+        "code": _P4_CODE,
+        "output": "Counts (1024 shots): {'101': 1024}. All 1024 shots give the state 101, as expected.",
+        "conclusion": "The CNOT and SWAP operations work as expected: starting from 000, the circuit deterministically produces the state 101, verified by all 1024 measurement shots.",
+    },
+    {
+        "num": 5,
+        "title": "Implement and Run the Deutsch-Jozsa Algorithm on a Balanced and Constant Function",
+        "aim": "To implement the Deutsch-Jozsa algorithm and to determine, with a single oracle query, whether a given function is constant or balanced.",
+        "software": "Python 3, Qiskit, Qiskit Aer (AerSimulator), Jupyter Notebook.",
+        "theory": (
+            "The Deutsch-Jozsa problem is to decide whether a function f is constant (same output for all inputs) or balanced "
+            "(output 0 for exactly half the inputs and 1 for the other half). A classical computer needs up to 2^(n-1) + 1 queries "
+            "in the worst case, but the quantum algorithm needs only one query to the oracle.\n\n"
+            "The algorithm prepares the input qubit in superposition with a Hadamard gate and the output (ancilla) qubit in the "
+            "state (|0> - |1>)/sqrt(2). The oracle applies the function through phase kickback: it flips the phase of the input "
+            "state according to f(x), without changing the ancilla.\n\n"
+            "A final Hadamard gate on the input qubit causes interference: if f is constant, the phases add up and the input qubit "
+            "is measured as 0; if f is balanced, the phases cancel and it is measured as 1. Thus one measurement of the first "
+            "qubit decides the nature of the function."
+        ),
+        "code": _P5_CODE,
+        "output": "Constant function: {'0': 1024} — Function is constant\nBalanced function: {'1': 1024} — Function is balanced",
+        "conclusion": "The Deutsch-Jozsa algorithm correctly identifies the constant function (measurement 0) and the balanced function (measurement 1) with just one oracle query, demonstrating quantum speedup over the classical method.",
+    },
+    {
+        "num": 6,
+        "title": "Implement and Run Grover's Algorithm to Search for a Marked State",
+        "aim": "To implement Grover's search algorithm on two qubits and to find the marked state |11> from an unstructured set of four states.",
+        "software": "Python 3, Qiskit, Qiskit Aer (AerSimulator), Jupyter Notebook.",
+        "theory": (
+            "Grover's algorithm searches an unstructured database of N items. A classical search needs about N/2 checks on average, "
+            "but Grover's algorithm needs only about sqrt(N) steps, giving a quadratic speedup.\n\n"
+            "The algorithm starts with all states in equal superposition. The oracle marks the target state by flipping its phase "
+            "(here the CZ gate marks |11>). The diffusion operator then performs inversion about the mean, which increases the "
+            "amplitude of the marked state and decreases the others.\n\n"
+            "For two qubits, N = 4, a single Grover iteration is enough to raise the probability of the marked state |11> to "
+            "nearly 100%. Measurement therefore gives |11> on almost all shots."
+        ),
+        "code": _P6_CODE,
+        "output": "Counts (1024 shots): {'11': 1024}. All shots give the marked state '11'.",
+        "conclusion": "Grover's algorithm successfully finds the marked state |11> with nearly 100% probability in a single iteration, demonstrating the quadratic speedup of quantum search over classical search.",
+    },
+]
+
+
+def _print_one(p):
+    bar = "=" * 70
+    print(bar)
+    print(f"Practical {p['num']}: {p['title']}")
+    print(bar)
+    print(f"\nAim: {p['aim']}")
+    print(f"\nSoftware Used: {p['software']}")
+    print(f"\nTheory:\n{p['theory']}")
+    print(f"\nCode:\n{p['code']}")
+    print(f"\nOutput:\n{p['output']}")
+    print(f"\nConclusion:\n{p['conclusion']}")
+    print()
+
+
+def show(n):
+    """Print practical number n (1-6)."""
+    for p in PRACTICALS:
+        if p["num"] == n:
+            _print_one(p)
+            return
+    raise ValueError(f"No practical {n}. Available: 1-{len(PRACTICALS)}.")
+
+
+def p1():
+    show(1)
+
+
+def p2():
+    show(2)
+
+
+def p3():
+    show(3)
+
+
+def p4():
+    show(4)
+
+
+def p5():
+    show(5)
+
+
+def p6():
+    show(6)
+
+
+def all():
+    """Print every practical (theory + code)."""
+    for p in PRACTICALS:
+        _print_one(p)
+
+
+def list():
+    """List all practical titles."""
+    for p in PRACTICALS:
+        print(f"{p['num']}. {p['title']}")
+
+
+class Qiskitcode:
+    """Class form: Qiskitcode.p1(), Qiskitcode.all(), ..."""
+
+    p1 = staticmethod(p1)
+    p2 = staticmethod(p2)
+    p3 = staticmethod(p3)
+    p4 = staticmethod(p4)
+    p5 = staticmethod(p5)
+    p6 = staticmethod(p6)
+    all = staticmethod(all)
+    show = staticmethod(show)
+    list = staticmethod(list)
+
+
+__all__ = [
+    "PRACTICALS",
+    "Qiskitcode",
+    "p1",
+    "p2",
+    "p3",
+    "p4",
+    "p5",
+    "p6",
+    "all",
+    "show",
+    "list",
+    "__version__",
+]

qiskitcode-0.1.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: qiskitcode
+Version: 0.1.0
+Summary: Quantum Lab Practicals: print theory + Qiskit code for all practicals on the terminal
+Author: HAFIZ
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# qiskitcode
+
+Quantum Lab Practicals — theory + Qiskit code, printed straight on the terminal.
+
+## Install
+
+From this folder:
+
+```bash
+pip install .
+```
+
+Or install the built wheel from `dist/`:
+
+```bash
+pip install dist/qiskitcode-0.1.0-py3-none-any.whl
+```
+
+(No Qiskit install needed just to *print* the practicals — Qiskit is only
+needed if you actually *run* the printed code.)
+
+## Use
+
+```python
+import qiskitcode
+
+qiskitcode.p1()    # Practical 1: Hadamard / superposition
+qiskitcode.p2()    # Practical 2: Measure + histogram
+qiskitcode.p3()    # Practical 3: Bell state
+qiskitcode.p4()    # Practical 4: CNOT + SWAP
+qiskitcode.p5()    # Practical 5: Deutsch-Jozsa
+qiskitcode.p6()    # Practical 6: Grover's search
+qiskitcode.all()   # all six, one after another
+qiskitcode.show(3) # any practical by number
+qiskitcode.list()  # list all titles
+```
+
+The class form also works:
+
+```python
+from qiskitcode import Qiskitcode
+Qiskitcode.p1()
+Qiskitcode.all()
+```
+
+Note: `qiskitcode.1()` is not valid Python — an attribute name cannot start
+with a digit — so the numbered practicals are `p1()` … `p6()`.
+
+## Contents
+
+1. Create a Single-Qubit Circuit Applying the Hadamard Gate
+2. Measure the Qubit and Plot the Histogram of Results
+3. Build a Circuit to Generate a Bell State
+4. Implement a Multi-Qubit Circuit with CNOT and SWAP Gates
+5. Implement and Run the Deutsch-Jozsa Algorithm
+6. Implement and Run Grover's Algorithm to Search for a Marked State

qiskitcode-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+qiskitcode/__init__.py,sha256=vEDhiIyyIoj2OSl4kvepDsqSAXxW4d-WrprAkFFKy6Q,13730
+qiskitcode-0.1.0.dist-info/METADATA,sha256=7TheH1PrCpHuf6fLYtVHEj71D2CIK2meiVZV_XOJfOw,1707
+qiskitcode-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+qiskitcode-0.1.0.dist-info/top_level.txt,sha256=sYbo9w79ZueXIFtYNw9gEZA9rzn6Ip3N_CF-P3lwKEI,11
+qiskitcode-0.1.0.dist-info/RECORD,,

qiskitcode-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

qiskitcode-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+qiskitcode