Skip to content

Framework Guide

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

Framework Guide

Comprehensive guide to choosing and using quantum computing frameworks in openqcp-lab: Classiq, PennyLane, and Qiskit.

Table of Contents

  1. Framework Overview
  2. Classiq
  3. PennyLane
  4. Qiskit
  5. Framework Comparison
  6. Choosing a Framework
  7. Installation and Setup
  8. Migration Guide

Framework Overview

The openqcp-lab project uses three quantum computing frameworks, each optimized for different use cases:

Framework Primary Use Tutorials Best For
Classiq Algorithm design, synthesis 00, 02, 03, 05 High-level design, automatic optimization
PennyLane Optimization, ML 01 Variational algorithms, gradients
Qiskit IBM Quantum, VQE 04 Hardware access, VQE, QUBO

Classiq

Overview

Classiq is a high-level quantum programming platform that focuses on automatic circuit synthesis and optimization. It allows you to describe quantum algorithms at a high level and automatically generates optimized quantum circuits.

Key Features

  • High-Level Programming: Describe algorithms conceptually, not gate-by-gate
  • Automatic Synthesis: Automatically generates optimized quantum circuits
  • Circuit Optimization: Built-in optimization for depth, gate count, etc.
  • Multiple Backends: Supports various quantum hardware and simulators
  • Python Integration: Native Python API

Used in Tutorials

  • Tutorial 00: Quantum Fourier Transform
  • Tutorial 02: Quantum Walk
  • Tutorial 03: Non-Unitary Computing (LCU)
  • Tutorial 05: Coupled Harmonic Oscillators

Strengths

✅ High-level abstraction - Focus on algorithm, not gates
✅ Automatic optimization - Circuit synthesis handles optimization
✅ Research-friendly - Good for algorithm development
✅ Educational - Clear separation of algorithm and implementation

Limitations

⚠️ Less control - Less fine-grained control over individual gates
⚠️ Learning curve - Different paradigm from gate-level programming
⚠️ Hardware access - Limited direct hardware access compared to Qiskit

Installation

pip install classiq

Included in requirements.txt.

Basic Usage Example

from classiq import *

@qfunc
def my_quantum_function(x: QNum):
    # High-level quantum operations
    pass

# Synthesize and execute
quantum_model = create_model(my_quantum_function)

Documentation

When to Use Classiq

  • Designing new quantum algorithms
  • Need automatic circuit optimization
  • Educational/research purposes
  • Want high-level abstraction
  • Working on algorithm development

PennyLane

Overview

PennyLane is a quantum machine learning and optimization framework that excels at variational quantum algorithms and automatic differentiation. It provides seamless integration between quantum and classical machine learning.

Key Features

  • Automatic Differentiation: Compute gradients of quantum circuits
  • Variational Algorithms: Optimized for VQE, QAOA, and similar algorithms
  • Multiple Backends: Supports many quantum devices and simulators
  • Machine Learning Integration: Works with PyTorch, TensorFlow, JAX
  • Optimization Tools: Built-in optimizers for quantum optimization

Used in Tutorials

  • Tutorial 01: Minimize Expectation Value

Strengths

✅ Gradient computation - Automatic differentiation for quantum circuits
✅ Optimization focus - Excellent for variational algorithms
✅ ML integration - Seamless with classical ML frameworks
✅ Multiple backends - Supports many quantum devices
✅ User-friendly - Intuitive API for optimization

Limitations

⚠️ Optimization focus - Less suited for non-optimization algorithms
⚠️ Learning curve - Different from traditional quantum programming
⚠️ Hardware access - Good but not as direct as Qiskit for IBM

Installation

pip install pennylane

Included in requirements.txt.

Basic Usage Example

import pennylane as qml

dev = qml.device("default.qubit", wires=2)

@qml.qnode(dev)
def circuit(params):
    qml.StronglyEntanglingLayers(params, wires=[0, 1])
    return qml.expval(qml.PauliZ(0))

# Optimize
opt = qml.GradientDescentOptimizer(stepsize=0.4)
params = opt.step(circuit, initial_params)

Documentation

When to Use PennyLane

  • Variational quantum algorithms (VQE, QAOA)
  • Quantum machine learning
  • Need automatic differentiation
  • Optimization problems
  • Gradient-based optimization

Qiskit

Overview

Qiskit is IBM's quantum computing framework, providing comprehensive tools for quantum circuit design, optimization, and execution on IBM Quantum hardware. It's widely used in industry and research.

Key Features

  • IBM Quantum Access: Direct access to IBM Quantum hardware
  • Comprehensive Tooling: Full ecosystem for quantum computing
  • VQE Support: Excellent support for Variational Quantum Eigensolvers
  • Optimization Tools: QUBO problem solving and optimization
  • Active Community: Large community and extensive documentation

Used in Tutorials

  • Tutorial 04: Quantum Variational Algorithms (VQE, QUBO)

Strengths

✅ Hardware access - Direct access to IBM Quantum devices
✅ Comprehensive - Full-featured quantum computing framework
✅ Industry standard - Widely used in industry and research
✅ VQE support - Excellent VQE and optimization tools
✅ Community - Large, active community

Limitations

⚠️ IBM focus - Primarily optimized for IBM Quantum
⚠️ Complexity - Can be complex for beginners
⚠️ Installation - Larger installation footprint
⚠️ Optional dependency - Not included in base requirements

Installation

pip install qiskit qiskit-optimization

Note: Qiskit is an optional dependency. Tutorials will install it automatically if needed, or you can install manually.

Basic Usage Example

from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit_algorithms import VQE
from qiskit_algorithms.optimizers import SLSQP
from qiskit.circuit.library import EfficientSU2

# Create Hamiltonian
hamiltonian = SparsePauliOp.from_list([("ZZ", 1.0)])

# Setup VQE
ansatz = EfficientSU2(2)
optimizer = SLSQP()
vqe = VQE(ansatz, optimizer)
result = vqe.compute_minimum_eigenvalue(hamiltonian)

Documentation

When to Use Qiskit

  • Need IBM Quantum hardware access
  • Working with VQE and QUBO problems
  • Industry/research applications
  • Need comprehensive quantum computing tools
  • Optimization problems (QUBO)

Framework Comparison

Feature Comparison Table

Feature Classiq PennyLane Qiskit
Primary Focus Algorithm design Optimization/ML Hardware/Industry
Learning Curve Moderate Moderate Steep
Hardware Access Limited Good Excellent (IBM)
Automatic Gradients Limited Excellent Limited
Circuit Optimization Excellent Good Good
VQE Support Good Excellent Excellent
High-Level Abstraction Excellent Good Limited
Gate-Level Control Limited Good Excellent
Community Size Growing Large Very Large
Documentation Good Excellent Excellent

Use Case Comparison

Use Case Best Framework Alternative
Algorithm Development Classiq Qiskit
Variational Optimization PennyLane Qiskit
Quantum ML PennyLane Qiskit
IBM Hardware Qiskit PennyLane
Research/Education Classiq PennyLane
Industry Applications Qiskit PennyLane
QUBO Problems Qiskit PennyLane
Circuit Optimization Classiq Qiskit

Performance Comparison

Aspect Classiq PennyLane Qiskit
Circuit Synthesis Speed Fast N/A N/A
Optimization Speed Fast Fast Moderate
Execution Speed Depends on backend Depends on backend Depends on backend
Memory Usage Moderate Low Moderate-High

Choosing a Framework

Decision Tree

Start
  │
  ├─ Need IBM Quantum hardware?
  │   └─ Yes → Qiskit
  │
  ├─ Working on optimization/ML?
  │   └─ Yes → PennyLane
  │
  ├─ Designing new algorithms?
  │   └─ Yes → Classiq
  │
  ├─ Need automatic gradients?
  │   └─ Yes → PennyLane
  │
  └─ Need high-level abstraction?
      └─ Yes → Classiq
      └─ No → Qiskit (for control) or PennyLane (for optimization)

By Tutorial

  • Tutorial 00, 02, 03, 05: Use Classiq (required)
  • Tutorial 01: Use PennyLane (required)
  • Tutorial 04: Use Qiskit (required)

By Experience Level

  • Beginners: Start with Classiq (high-level) or PennyLane (intuitive)
  • Intermediate: Any framework based on use case
  • Advanced: Qiskit for control, PennyLane for optimization, Classiq for research

By Project Type

  • Research/Education: Classiq or PennyLane
  • Industry/Production: Qiskit
  • Optimization Problems: PennyLane or Qiskit
  • Algorithm Development: Classiq

Installation and Setup

Classiq

Basic Installation:

pip install classiq

Verification:

from classiq import *
print("Classiq installed successfully")

Authentication (if needed):

PennyLane

Basic Installation:

pip install pennylane

Verification:

import pennylane as qml
print("PennyLane version:", qml.__version__)

Optional Backends:

# For specific backends (if needed)
pip install pennylane-qiskit  # Qiskit backend
pip install pennylane-cirq    # Cirq backend

Qiskit

Basic Installation:

pip install qiskit qiskit-optimization

Verification:

import qiskit
print("Qiskit version:", qiskit.__version__)

IBM Quantum Access (optional):

from qiskit import IBMQ
IBMQ.save_account('YOUR_API_TOKEN')  # One-time setup

Note: Qiskit is an optional dependency. Tutorials will install it automatically if needed.

Migration Guide

From Classiq to Qiskit

Key Differences:

  • Classiq: High-level functions → Qiskit: Gate-level circuits
  • Classiq: Automatic synthesis → Qiskit: Manual circuit construction
  • Classiq: @qfunc decorator → Qiskit: QuantumCircuit class

Example Migration:

# Classiq
@qfunc
def my_function(x: QNum):
    hadamard_transform(x)

# Qiskit equivalent
from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.h([0, 1, 2])

From PennyLane to Qiskit

Key Differences:

  • PennyLane: @qml.qnode decorator → Qiskit: QuantumCircuit class
  • PennyLane: Automatic gradients → Qiskit: Manual gradient computation
  • PennyLane: Device abstraction → Qiskit: Backend-specific

Example Migration:

# PennyLane
@qml.qnode(dev)
def circuit(params):
    qml.StronglyEntanglingLayers(params, wires=[0, 1])
    return qml.expval(qml.PauliZ(0))

# Qiskit equivalent
from qiskit.circuit.library import EfficientSU2
ansatz = EfficientSU2(2)
# Manual expectation value computation

From Qiskit to PennyLane

Key Differences:

  • Qiskit: Manual circuit construction → PennyLane: Decorator-based
  • Qiskit: Manual gradients → PennyLane: Automatic differentiation
  • Qiskit: Backend-specific → PennyLane: Device abstraction

Example Migration:

# Qiskit
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)

# PennyLane equivalent
@qml.qnode(dev)
def circuit():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    return qml.state()

Framework-Specific Troubleshooting

Classiq

Issue: Import errors

  • Solution: pip install --upgrade classiq
  • Check Python version (3.8+ required)

Issue: Authentication errors

  • Solution: Some features require API authentication
  • See Classiq documentation for setup

Issue: Circuit synthesis errors

  • Solution: Check function definitions
  • Verify quantum function syntax

PennyLane

Issue: Backend not found

  • Solution: Install specific backend plugin
  • Check device name spelling

Issue: Gradient computation errors

  • Solution: Ensure differentiable operations
  • Check parameter shapes

Issue: Optimization not converging

  • Solution: Adjust optimizer parameters
  • Try different optimizers

Qiskit

Issue: Import errors

  • Solution: pip install --upgrade qiskit
  • Check for version conflicts

Issue: IBM Quantum access errors

  • Solution: Verify API token
  • Check account status

Issue: VQE execution errors

  • Solution: Verify Hamiltonian format
  • Check ansatz compatibility

Additional Resources

Framework Documentation

Community Resources

Tutorials

Return to: Home | Getting Started | Tutorial Catalog

Clone this wiki locally