Quantum Computing

Convert complex numbers between Cartesian and polar forms using Euler’s formula.

Compute norms and inner products of complex vectors.

Normalize complex vectors and determine whether two vectors are orthogonal.

Multiply small complex matrices by vectors and by other matrices.

Determine whether a small complex matrix is unitary or Hermitian.

Calculate the eigenvalues and eigenvectors of simple 2×2 matrices.

Compute Kronecker products of small vectors and matrices.

Use NumPy and Dirac notation to represent quantum-state vectors and operators.

Distinguish a qubit state from a classical bit and a classical probabilistic state.

Determine whether two qubit state vectors differ only by an unobservable global phase.

Calculate computational-basis measurement probabilities from a qubit’s amplitudes.

Calculate the post-measurement state produced by a single-qubit projective measurement.

Calculate measurement probabilities in the X and Y bases.

Represent a pure qubit state on the Bloch sphere.

Predict the effect of the X, Y, Z, H, S, and T gates on a qubit state.

Build and simulate single-qubit circuits with Qiskit.

Construct multi-qubit product states using tensor products.

Translate between computational-basis labels and amplitude-vector indices for multiple qubits.

Predict the action of CNOT, CZ, and SWAP gates on basis states and superpositions.

Determine whether a given two-qubit pure state is separable or entangled.

Calculate joint and marginal measurement probabilities for a multi-qubit state.

Construct each Bell state with a quantum circuit.

Calculate expectation values of two-qubit Pauli-product observables.

Use Qiskit simulations to verify entanglement correlations in Bell-state measurements.

Calculate the unitary matrix represented by a short quantum circuit.

Construct the inverse of a unitary quantum circuit.

Test whether two small quantum circuits are equivalent up to global phase.

Use linearity to explain why an unknown quantum state cannot be cloned.

Trace quantum teleportation through entanglement, measurement, and classical correction.

Implement the quantum teleportation protocol in Qiskit.

Trace the superdense-coding protocol for each two-bit message.

Detect eavesdropping in a simplified BB84 quantum-key-distribution example.

Convert a small irreversible Boolean computation into a reversible computation.

Construct a reversible oracle for a simple Boolean function.

Distinguish bit-flip oracles from phase oracles.

Calculate the phase kickback produced by a controlled unitary.

Trace Deutsch’s algorithm for constant and balanced functions.

Implement the Deutsch–Jozsa algorithm in Qiskit.

Implement the Bernstein–Vazirani algorithm in Qiskit.

Compare classical and quantum query complexity for an oracle problem.

Explain Grover search as repeated rotations toward a marked-state subspace.

Construct a phase oracle that marks a specified computational-basis state.

Construct the Grover diffusion operator from elementary gates.

Trace one Grover iteration for a two-qubit search problem.

Calculate an appropriate number of Grover iterations for a given search-space size.

Implement Grover search for a small problem in Qiskit.

Compare Grover’s quadratic query advantage with its practical limitations.

Calculate the quantum Fourier transform of a two-qubit basis state.

Construct two- and three-qubit quantum Fourier transform circuits.

Explain how the inverse quantum Fourier transform converts relative phase into measurable bits.

Trace quantum phase estimation when the eigenphase has an exact finite binary representation.

Implement quantum phase estimation for a simple unitary in Qiskit.

Reduce an integer-factoring example to an order-finding problem.

Use continued fractions to recover a candidate order from a measured phase.

Explain why large-scale factoring requires fault-tolerant quantum computation.

Represent a simple physical Hamiltonian as a sum of Pauli operators.

Construct a circuit for time evolution under a single Pauli term.

Approximate evolution under noncommuting Hamiltonian terms with first-order Trotterization.

Implement a small Trotterized time-evolution circuit in Qiskit.

Estimate a time-dependent observable from simulated measurement results.

Compare digital and variational approaches to quantum simulation.

Estimate the expectation value of a Pauli observable from measurement counts.

Decompose a small Hamiltonian into measurable Pauli terms.

Construct a parameterized circuit ansatz for a small quantum system.

Define a classical cost function from quantum-circuit measurement results.

Execute one complete iteration of a hybrid quantum–classical optimization loop.

Use the variational quantum eigensolver to estimate a simple ground-state energy.

Map a small Max-Cut instance to an Ising cost Hamiltonian.

Implement a one-layer QAOA circuit for a small Max-Cut instance.

Represent pure and mixed quantum states with density matrices.

Calculate how a basic bit-flip, phase-flip, depolarizing, or amplitude-damping channel changes a qubit state.

Distinguish relaxation, dephasing, gate, and readout errors in hardware data.

Simulate a quantum circuit with a Qiskit noise model.

Calculate fidelity between simple ideal and noisy quantum states.

Apply measurement-error mitigation to experimental counts.

Trace encoding, syndrome extraction, and correction in the three-qubit bit-flip code.

Interpret stabilizer-syndrome outcomes for a small quantum error-correcting code.

Compare superconducting, trapped-ion, neutral-atom, and photonic qubit platforms using common engineering criteria.

Inspect calibration data to select a suitable quantum-computing backend.

Transpile a circuit for a device’s native gates and qubit connectivity.

Run a small circuit on cloud quantum hardware and retrieve its results.

Quantify sampling uncertainty in quantum measurement results.

Match major quantum-application families to suitable algorithmic primitives.

Evaluate a claimed quantum speedup by checking its assumptions, resources, and classical baseline.

Specify an end-to-end benchmark that compares a quantum workflow with a classical alternative.