Skip to content

Tutorial Catalog

Jump to bottom
Mohammadreza Khellat edited this page Dec 16, 2025 · 1 revision

Tutorial Catalog

Complete reference guide for all tutorials in the openqcp-lab collection.

Overview

This catalog provides detailed information about each tutorial, including prerequisites, learning objectives, framework requirements, and estimated completion times. Use this guide to plan your learning journey.

Tutorial Summary Table

# Tutorial Framework Difficulty Prerequisites Time Link
00 Quantum Fourier Transform (Abelian) Classiq Beginner Linear algebra, complex numbers 2h Details
01 Minimize Expectation Value PennyLane Beginner Basic Python, optimization basics 1.5h Details
02 Discrete-Time Quantum Walk Classiq Intermediate QFT (Tutorial 00), graph theory basics 2-3h Details
03 Non-Unitary Quantum Computing (LCU) Classiq Intermediate Quantum circuits, linear algebra 2-3h Details
04 Quantum Variational Algorithms Qiskit Intermediate VQE basics, optimization 3-4h Details
05 Coupled Harmonic Oscillators Classiq Advanced Hamiltonian simulation, physics 4-5h Details

Detailed Tutorial Information

Tutorial 00: Quantum Fourier Transform (Abelian) {#tutorial-00}

Full Name: Quantum Fourier Transform over Finite Abelian Groups

Location: quantum_fourier_transform_abelian/

Framework: Classiq

Difficulty: 🟢 Beginner

Estimated Time: 2 hours

Description

A comprehensive review of quantum Fourier transform over finite Abelian groups with applications in phase estimation and Hadamard test. This tutorial covers the mathematical foundations of QFT as a linear transformation between function spaces.

Learning Objectives

By completing this tutorial, you will be able to:

  1. Understand the mathematical foundations of QFT over finite Abelian groups
  2. Implement QFT circuits for phase estimation
  3. Apply QFT in Hadamard test scenarios
  4. Recognize the relationship between $\mathbb{C}[G]$ and $\mathbb{C}[\widehat{G}]$ vector spaces

Prerequisites

Required:

  • Linear algebra (vector spaces, linear transformations)
  • Complex numbers and complex exponentials
  • Basic quantum computing concepts (qubits, gates)

Recommended:

  • Group theory basics (helpful but not required)
  • Familiarity with Fourier transforms (classical)

Key Concepts Covered

  • Quantum Fourier Transform (QFT)
  • Finite Abelian groups and their characters
  • Phase estimation algorithms
  • Hadamard test
  • Quantum circuit design

Software Requirements

  • numpy
  • matplotlib
  • classiq

All included in requirements.txt.

Expected Outputs

  • Quantum model file: qft-expvalue.qmod (optional)
  • Plots showing expectation values and measurement results
  • Understanding of QFT implementation

Related Tutorials

  • Prerequisite for: Tutorial 02 (Quantum Walk)
  • Related to: Tutorial 05 (uses similar mathematical foundations)

Further Reading

Tutorial 01: Minimize Expectation Value {#tutorial-01}

Full Name: Minimize Expectation Value of a 2-qubit Quantum Observable

Location: minimize_expectation_value/

Framework: PennyLane

Difficulty: 🟢 Beginner

Estimated Time: 1.5 hours

Description

A commented version of PennyLane's beginner-level optimization challenge "Keeping Expectations Low". This tutorial demonstrates how to optimize variational quantum circuits using gradient descent to minimize expectation values of quantum observables.

Learning Objectives

By completing this tutorial, you will be able to:

  1. Construct variational quantum circuits using PennyLane
  2. Optimize quantum circuit parameters using gradient descent
  3. Minimize expectation values of Hermitian operators
  4. Understand the relationship between circuit parameters and observable measurements

Prerequisites

Required:

  • Basic Python programming
  • Understanding of optimization (gradient descent)
  • Basic quantum gates (Pauli gates, entangling gates)

Recommended:

  • Familiarity with PennyLane (helpful but tutorial is self-contained)
  • Understanding of variational quantum algorithms

Key Concepts Covered

  • Variational quantum circuits
  • Parameter optimization
  • Gradient descent
  • Expectation value minimization
  • StronglyEntanglingLayers architecture

Software Requirements

  • pennylane

Included in requirements.txt.

Expected Outputs

  • Optimized quantum circuit parameters
  • Convergence plot showing optimization progress
  • Understanding of variational optimization workflow

Related Tutorials

  • Foundation for: Tutorial 04 (Quantum Variational Algorithms)
  • Related to: All optimization-based tutorials

Further Reading

Tutorial 02: Discrete-Time Quantum Walk {#tutorial-02}

Full Name: Discrete-Time Quantum Walk on Path Graph

Location: quantum_walk/

Framework: Classiq

Difficulty: 🟡 Intermediate

Estimated Time: 2-3 hours

Description

Implementation of quantum walk operators on graphs using coin and shift operators for a path graph with 16 nodes ($P_{16}$). This tutorial demonstrates how quantum walks can be used for graph-based algorithms.

Learning Objectives

By completing this tutorial, you will be able to:

  1. Understand quantum walk operators (coin and shift)
  2. Implement quantum walks on path graphs
  3. Design diffuser and edge oracle operations
  4. Recognize applications of quantum walks in graph algorithms

Prerequisites

Required:

  • Tutorial 00 (Quantum Fourier Transform) or equivalent knowledge
  • Graph theory basics (vertices, edges, adjacency)
  • Quantum circuit design experience

Recommended:

  • Understanding of quantum algorithms
  • Familiarity with Classiq framework

Key Concepts Covered

  • Quantum walk operators
  • Coin operator ($C$) and shift operator ($S$)
  • Graph-based quantum algorithms
  • Diffuser operations
  • Edge oracles

Software Requirements

  • numpy
  • classiq

All included in requirements.txt.

Expected Outputs

  • Quantum walk implementation on $P_{16}$
  • Understanding of coin and shift operator design
  • Measurement results showing quantum walk behavior

Related Tutorials

  • Requires: Tutorial 00 (QFT concepts)
  • Related to: Tutorial 03 (advanced quantum operations)

Further Reading

Tutorial 03: Non-Unitary Quantum Computing (LCU) {#tutorial-03}

Full Name: Linear Combination of Unitaries

Location: nonunitary_quantum_computing/

Framework: Classiq

Difficulty: 🟡 Intermediate

Estimated Time: 2-3 hours

Description

An example LCU implementation of a $2 \times 2$ non-unitary matrix. This tutorial demonstrates how to represent and manipulate non-unitary operations using Linear Combination of Unitaries (LCU) decomposition.

Learning Objectives

By completing this tutorial, you will be able to:

  1. Understand LCU decomposition for non-unitary operators
  2. Implement SELECT and PREPARE operators
  3. Decompose matrices into Pauli terms
  4. Apply non-unitary operations using quantum circuits

Prerequisites

Required:

  • Quantum circuits and gates
  • Linear algebra (matrix operations, Pauli matrices)
  • Understanding of unitary vs non-unitary operations

Recommended:

  • Tutorial 00 or 02 (quantum circuit design experience)
  • Familiarity with Classiq

Key Concepts Covered

  • Linear Combination of Unitaries (LCU)
  • SELECT and PREPARE operators
  • Pauli decomposition
  • Non-unitary quantum operations
  • Controlled operations

Software Requirements

  • numpy
  • classiq

All included in requirements.txt.

Expected Outputs

  • Quantum model file: lcu-2x2.qmod (optional)
  • Measurement results showing non-unitary operator application
  • Understanding of LCU implementation

Related Tutorials

  • Builds on: Tutorial 00, 02 (quantum circuit design)
  • Advanced technique: Used in research applications

Further Reading

Tutorial 04: Quantum Variational Algorithms {#tutorial-04}

Full Name: QUBO and Variational Quantum Eigensolvers (VQE)

Location: quantum_variational_algorithms/

Framework: Qiskit

Difficulty: 🟡 Intermediate

Estimated Time: 3-4 hours

Description

Demonstrates the formulation of Quadratic Unconstrained Binary Optimization (QUBO) problems as ground state problems and their solution using Variational Quantum Eigensolvers (VQE). Includes implementation for the Max-Cut problem.

Learning Objectives

By completing this tutorial, you will be able to:

  1. Formulate QUBO problems as ground state problems
  2. Implement VQE using Qiskit
  3. Solve optimization problems using quantum algorithms
  4. Use EfficientSU2 ansatz and GSLS optimizer
  5. Apply quantum algorithms to Max-Cut problem

Prerequisites

Required:

  • Understanding of VQE basics
  • Optimization theory
  • QUBO problem formulation
  • Basic Qiskit knowledge (helpful)

Recommended:

  • Tutorial 01 (variational optimization)
  • Graph theory (for Max-Cut application)

Key Concepts Covered

  • Variational Quantum Eigensolvers (VQE)
  • Quadratic Unconstrained Binary Optimization (QUBO)
  • Max-Cut problem
  • EfficientSU2 ansatz
  • GSLS optimizer
  • Ground state problems

Software Requirements

  • numpy
  • qiskit (optional, installed automatically if needed)
  • qiskit-optimization (optional, installed automatically if needed)

Install manually:

pip install qiskit qiskit-optimization

Expected Outputs

  • VQE solution for QUBO problem
  • Optimization convergence results
  • Max-Cut problem solution
  • Understanding of VQE workflow

Related Tutorials

  • Builds on: Tutorial 01 (variational optimization)
  • Advanced application: Real-world optimization problems

Further Reading

Tutorial 05: Coupled Harmonic Oscillators {#tutorial-05}

Full Name: Hamiltonian Simulation of N Coupled Classical Oscillators

Location: coupled_harmonic_oscillators/

Framework: Classiq

Difficulty: 🔴 Advanced

Estimated Time: 4-5 hours

Description

A quantum algorithm that delivers the dynamics of a 1-dimensional system of $N$ coupled classical oscillators through Hamiltonian simulation over time. Demonstrates exponential quantum speedup in simulating classical systems.

Learning Objectives

By completing this tutorial, you will be able to:

  1. Understand Hamiltonian simulation for classical systems
  2. Implement amplitude encoding of dynamical variables
  3. Decompose Hamiltonians into Pauli terms
  4. Apply Suzuki-Trotter decomposition
  5. Recognize exponential speedup in quantum simulation

Prerequisites

Required:

  • Hamiltonian simulation theory
  • Physics background (classical mechanics, oscillators)
  • Advanced linear algebra
  • Understanding of quantum simulation

Recommended:

  • Tutorial 00, 02, 03 (quantum circuit design)
  • Familiarity with Classiq
  • Understanding of Trotterization

Key Concepts Covered

  • Hamiltonian simulation
  • Amplitude encoding
  • Normal modes and eigenfrequencies
  • Suzuki-Trotter decomposition
  • Pauli decomposition
  • Quantum speedup

Software Requirements

  • numpy
  • scipy
  • sympy
  • matplotlib
  • classiq
  • LaTeX (for plot rendering) and cm-super package

All Python packages included in requirements.txt.

Expected Outputs

  • Quantum model files: N-2-dt-*.qmod and N-2-dt-*.qprog
  • Figures: figures/hs_n_2.png (Hamiltonian simulation)
  • Figures: figures/ar_n_2.png (Analytical comparison)
  • Comparison of quantum simulation with analytical results

Related Tutorials

  • Most advanced: Builds on all previous tutorials
  • Research application: Cutting-edge quantum simulation

Further Reading

Choosing Your Path

By Difficulty

  • Beginner: Start with Tutorial 00, then Tutorial 01
  • Intermediate: Tutorial 02, 03, or 04 (depending on interests)
  • Advanced: Tutorial 05

By Framework

  • Classiq: Tutorials 00, 02, 03, 05
  • PennyLane: Tutorial 01
  • Qiskit: Tutorial 04

By Application

  • Algorithm Foundations: Tutorial 00
  • Optimization: Tutorial 01, 04
  • Graph Algorithms: Tutorial 02
  • Advanced Techniques: Tutorial 03
  • Simulation: Tutorial 05

See Learning Paths for detailed recommended sequences.

Additional Resources

Ready to start? Choose a tutorial from the table above or follow a Learning Path!

Clone this wiki locally