Квантово Програмиране и Квантова Механика

Main ideas and lessons

• Quantum computing as “practical quantum mechanics”

  • The lecture frames quantum programming as a way to learn quantum mechanics with enough math—especially linear algebra—without diving immediately into full physical details.
  • It emphasizes that quantum programs can be run on IBM’s quantum computers, using simplified models and gates.

• From classical determinism to quantum unpredictability

  • Classical motion
    • If you know forces, initial position, and initial velocity, you can (in principle) predict the future deterministically.
    • Even with variable forces (e.g., springs), advanced math can still predict motion.
  • Classical randomness
    • Randomness (e.g., a coin toss) is described as practical ignorance, not fundamental indeterminism.
  • Quantum shift
    • For tiny systems (atoms/electrons), you cannot track a smooth trajectory like in everyday physics.
    • Outcomes are described in probabilities of where a particle is detected.

• Measurement and the “two big difficulties”

  • Two conceptual problems are highlighted:
    1. Interpretation problem: what happens to a particle between measurements?
    2. Prediction problem: you can predict where it will be detected only probabilistically, not the exact path.
  • The lecture then focuses on the mathematical formalism that predicts detection statistics.

• When quantum behavior becomes relevant (the “Planck constant / action” threshold)

  • Quantum effects matter when the system’s “action” approaches Planck’s constant.
  • Classical behavior dominates when action is much larger than Planck’s constant.
  • The notes mention ongoing debates about whether the transition is smooth.

• Experiments illustrating wave-particle behavior

  • Single-slit/double-slit electron (or particle) experiments
    • With many particles, you get a diffraction pattern (wave-like spreading).
    • With individual particles, detections still build up the same interference/diffraction distribution, not a random uniform one.
    • The lecture argues this suggests a wave influence guiding where individual detections occur (in their preferred explanation).

• Competing interpretations discussed

  • Wave (pilot-wave/de Broglie–Bohm-like) view
    • Particle has an associated wave function/field guiding it.
    • Interference maxima/minima influence where particles are more likely to land.
    • The lecturer favors this approach to avoid “measurement creates reality” ideas.
  • Copenhagen interpretation
    • Before measurement, the system may be treated as not having a definite classical property.
    • Summarized claims:
      • The wave function evolves, but is treated as not “real material” until measurement.
      • Wavefunction collapse occurs upon measurement (probabilistic outcomes).
      • Between measurements, the particle “does not exist” in the classical sense (as presented in the lecture).
  • Measurement problem
    • Why collapse occurs—and how it relates to unitary evolution—is presented as unresolved in standard Copenhagen-style approaches.
    • Key claim: ordinary Schrödinger evolution is unitary, while collapse is not—so the “missing mechanism” is central.

• Spin as a core quantum example (discrete outcomes)

  • Stern–Gerlach experiment
    • Atoms passing through magnetic field gradients yield two outcomes (“up” or “down”).

  • A spin-1/2 state is represented as a 2-component vector

    • Basis states: (|0\rangle) and (|1\rangle) (spin down/up in the lecture’s convention).

    • General state: [ \alpha|0\rangle + \beta|1\rangle ]

    • Probabilities:

      • (P(0)=|\alpha|^2)
      • (P(1)=|\beta|^2)
      • Normalization: (|\alpha|^2+|\beta|^2=1)

• Qubits and superposition

  • A classical bit is either 0 or 1.
  • A qubit can be in a superposition of 0 and 1 until measured.
  • The lecture stresses that superposition enables quantum algorithms, while also spending time debating what superposition “really means.”

• Quantum gates as matrix operations

  • Quantum mechanics is taught as:
    • prepare a state vector,
    • apply gate matrices,
    • then perform measurement to get classical outcomes.
  • Gates mentioned explicitly
    • X gate (NOT / flip gate): swaps (|0\rangle \leftrightarrow |1\rangle)
    • Hadamard gate (H gate): creates superposition (e.g., from (|0\rangle) to an equal superposition up to phases)
    • CNOT gate (Ctrl-NOT / CX gate) for two qubits:
      • If control qubit is 1, flip the target qubit; otherwise do nothing

• Entanglement (“braiding”) and why quantum computers may outperform classical ones

  • The lecture argues:
    • Superposition alone isn’t the main source of speedup.
    • Entanglement/braiding between qubits enables quantum computation advantage.
  • Entangled states
    • cannot be reduced to independent states of each qubit.
    • produce correlated measurement outcomes even at a distance.
  • Bell inequalities and Bell’s theorem are cited as evidence that local hidden-variable explanations struggle.

• Decoherence and error correction

  • Entanglement is fragile:
    • thermal noise and environment interactions destroy coherence (decoherence).
  • Quantum error correction is mentioned as complicated but theoretically feasible.

• Transition from theory to practice: IBM + Qiskit + Python

  • The final portion becomes hands-on:
    • Use Python in Google Colab (or a similar environment).
    • Install and use Qiskit (IBM-developed framework).
    • Visualize circuits, simulate them, and optionally run them on real IBM hardware.
  • Key explanation:
    • quantum circuits are ordered programs of gates and measurements.
    • simulation shows ideal/expected behavior; hardware shows noise/error.

---

Methodology / instructions presented (detailed bullet list)

Building and running quantum circuits (conceptual workflow)

1. Choose system size

   • Decide the number of qubits (e.g., 1-qubit or 2-qubit circuit).
   • Decide the number of classical bits for measurement output (often equal to qubits measured).

2. Define the initial state

   • Default: typically (|0\rangle) for each qubit.
   • Optionally initialize a qubit into a superposition using gates like Hadamard.

3. Apply gate operations

   • Gates are applied as linear transformations (unitary matrices) to state vectors.
   • Examples:
     • X to flip a qubit
     • Hadamard to create superposition
     • CNOT to create entanglement/correlation

4. Measure

   • Measurement outputs classical bits:
     • results are random according to the quantum state’s probabilities.
   • Repeated measurements create histograms approximating those probabilities.

5. Repeat many shots for statistics

   • Use a large number of measurements (shots), e.g. 1024:
     • histogram frequencies converge toward expected probabilities.

Practical coding steps (as described)

• A) Set up Python environment

  • Use Google Colab (or a cloud notebook).
  • Execute cells using Shift+Enter or the execution button.

• B) Install Qiskit

  • Install IBM’s Qiskit library.

• C) Create a circuit

  • Create a QuantumCircuit(number_of_qubits, number_of_classical_bits) object.

• D) Visualize the circuit

  • Render the circuit diagram using Qiskit’s visualization methods.

• E) Add gates

  • Add gates like:
    • x(...) for X/flip
    • h(...) for Hadamard
    • cx(control, target) for CNOT

• F) Add measurement instructions

  • Add measure(qubit_index, classical_bit_index).

• G) Run simulation or real hardware

  • Simulation: use IBM simulators to predict outcomes (less noisy).
  • Real hardware: use IBM runtime with an appropriate backend (least busy/operational).
  • Specify shots (e.g., 1024), then check job status and read the job ID.

• H) Interpret results

  • On the simulator:
    • ideal patterns (e.g., measuring (|0\rangle) gives all zeros; applying H to (|0\rangle) gives ~50/50).
  • On hardware:
    • noise causes occasional wrong results (e.g., a few unexpected “1”s).

Example experiments/gates executed in the lecture (implementation logic)

1. 1-qubit: measure default state

   • Initialize in (|0\rangle).
   • Measure repeatedly → mostly/only 0 on hardware (with some errors).

2. 1-qubit: X gate then measure

   • Apply X to (|0\rangle).
   • Measure repeatedly → mostly/only 1.

3. 1-qubit: Hadamard then measure

   • Apply H to (|0\rangle).
   • Measure repeatedly → ~50% 0 and ~50% 1 (with hardware deviations).

4. Circuit exercise

   • Build a circuit: X then Hadamard, then measure.
   • Expected qualitative result: measurement statistics match the resulting state.

5. 2-qubit: basic measurement circuit

   • Measure both qubits into two classical bits (bitstrings like 00, 01, 10, 11).

6. 2-qubit: superposition then measure

   • Apply H to selected qubits to generate a distribution over correlated measurement outcomes (as demonstrated).

---

Speakers / sources featured (as named in the subtitles)

• Lecturer / presenter (unnamed in subtitles)
• IBM (quantum computers and the platform)
• Qiskit (IBM’s quantum programming toolkit)
• Louis (Lacho) (repeatedly referenced by the lecturer as a collaborator/co-instructor)
• Newton (classical mechanics reference)
• Einstein (measurement/interpretation discussions)
• Bohr (Copenhagen interpretation)
• de Broglie (pilot-wave/wave mechanics)
• Bohm (Bohmian mechanics)
• Pauli (mentioned in a Solvay-related context)
• Schrödinger (Schrödinger equation referenced)
• Bell (Bell inequalities)
• Stern and Gerlach (Stern–Gerlach experiment)
• Feynman (interpretation critique referenced)
• Hawking (Stephen Hawking mentioned)
• Einstein–Bell / Solvay conference (as events/concepts mentioned)
• John Bell GPT / GPT chat (used as a reminder/example source; not presented as a formal scientific reference)