personamanagmentlayer__pcl/stdlib/scientific/quantum-expert/SKILL.md

name, version, description, category, tags, allowed-tools

name	version	description	category	tags	allowed-tools
quantum-expert	1.1.0	Expert-level quantum computing, Qiskit, quantum algorithms, and quantum information. Use when the user mentions quantum computing, Qiskit, quantum algorithms, or quantum information, or when the task involves Quantum Mechanics Basics, Quantum Hardware, Circuit Design, or Algorithm Implementation.	scientific	quantum-computing qiskit quantum-algorithms quantum-information	Read Write Edit Bash(python:*)

Quantum Computing Expert

Expert guidance for quantum computing, quantum algorithms, Qiskit programming, and quantum information theory.

Core Concepts

Quantum Mechanics Basics

• Qubits and superposition
• Quantum entanglement
• Quantum interference
• Measurement and collapse
• Quantum gates (Pauli, Hadamard, CNOT)
• Quantum circuits

Quantum Algorithms

• Grover's search algorithm
• Shor's factoring algorithm
• Quantum Fourier Transform (QFT)
• Variational Quantum Eigensolver (VQE)
• Quantum Approximate Optimization Algorithm (QAOA)
• Quantum machine learning

Quantum Hardware

• Superconducting qubits
• Ion trap quantum computers
• Quantum annealing
• Noise and error correction
• Quantum volume
• NISQ (Noisy Intermediate-Scale Quantum) devices

Qiskit Programming

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute, transpile
from qiskit.visualization import plot_histogram, plot_bloch_multivector
import numpy as np

# Basic Quantum Circuit
def create_bell_state():
    """Create Bell state (maximally entangled state)"""
    qc = QuantumCircuit(2, 2)

    # Create superposition on qubit 0
    qc.h(0)

    # Entangle qubits 0 and 1
    qc.cx(0, 1)

    # Measure both qubits
    qc.measure([0, 1], [0, 1])

    return qc

# Quantum Teleportation
def quantum_teleportation():
    """Implement quantum teleportation protocol"""
    qc = QuantumCircuit(3, 3)

    # Prepare state to teleport (qubit 0)
    qc.ry(np.pi/4, 0)

    # Create Bell pair between qubits 1 and 2
    qc.h(1)
    qc.cx(1, 2)

    # Bell measurement on qubits 0 and 1
    qc.cx(0, 1)
    qc.h(0)
    qc.measure([0, 1], [0, 1])

    # Apply corrections on qubit 2 based on measurement
    qc.cx(1, 2)
    qc.cz(0, 2)

    # Measure final state
    qc.measure(2, 2)

    return qc

# Grover's Search Algorithm
class GroverSearch:
    def __init__(self, n_qubits: int, marked_state: str):
        self.n_qubits = n_qubits
        self.marked_state = marked_state
        self.circuit = None

    def create_oracle(self):
        """Create oracle that marks the target state"""
        oracle = QuantumCircuit(self.n_qubits)

        # Mark the target state by flipping phase
        for i, bit in enumerate(reversed(self.marked_state)):
            if bit == '0':
                oracle.x(i)

        # Multi-controlled Z gate
        oracle.h(self.n_qubits - 1)
        oracle.mcx(list(range(self.n_qubits - 1)), self.n_qubits - 1)
        oracle.h(self.n_qubits - 1)

        # Uncompute
        for i, bit in enumerate(reversed(self.marked_state)):
            if bit == '0':
                oracle.x(i)

        return oracle

    def create_diffuser(self):
        """Create diffusion operator"""
        diffuser = QuantumCircuit(self.n_qubits)

        # Apply H gates
        diffuser.h(range(self.n_qubits))

        # Apply X gates
        diffuser.x(range(self.n_qubits))

        # Multi-controlled Z
        diffuser.h(self.n_qubits - 1)
        diffuser.mcx(list(range(self.n_qubits - 1)), self.n_qubits - 1)
        diffuser.h(self.n_qubits - 1)

        # Apply X gates
        diffuser.x(range(self.n_qubits))

        # Apply H gates
        diffuser.h(range(self.n_qubits))

        return diffuser

    def build_circuit(self):
        """Build complete Grover's algorithm circuit"""
        self.circuit = QuantumCircuit(self.n_qubits, self.n_qubits)

        # Initialize in superposition
        self.circuit.h(range(self.n_qubits))

        # Calculate optimal number of iterations
        n_iterations = int(np.pi / 4 * np.sqrt(2**self.n_qubits))

        oracle = self.create_oracle()
        diffuser = self.create_diffuser()

        # Apply Grover iteration
        for _ in range(n_iterations):
            self.circuit.compose(oracle, inplace=True)
            self.circuit.compose(diffuser, inplace=True)

        # Measure
        self.circuit.measure(range(self.n_qubits), range(self.n_qubits))

        return self.circuit

    def run(self, shots: int = 1024):
        """Execute circuit"""
        backend = Aer.get_backend('qasm_simulator')
        job = execute(self.circuit, backend, shots=shots)
        result = job.result()
        counts = result.get_counts()

        return counts

Variational Quantum Eigensolver (VQE)

from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
from qiskit.primitives import Estimator
from qiskit.quantum_info import SparsePauliOp

class VQESolver:
    """Variational Quantum Eigensolver for finding ground state energy"""

    def __init__(self, hamiltonian: SparsePauliOp, n_qubits: int):
        self.hamiltonian = hamiltonian
        self.n_qubits = n_qubits

    def create_ansatz(self, reps: int = 2):
        """Create parameterized quantum circuit (ansatz)"""
        ansatz = TwoLocal(
            self.n_qubits,
            'ry',
            'cz',
            reps=reps,
            entanglement='linear'
        )
        return ansatz

    def run_vqe(self):
        """Run VQE algorithm"""
        ansatz = self.create_ansatz()
        optimizer = SLSQP(maxiter=100)
        estimator = Estimator()

        vqe = VQE(estimator, ansatz, optimizer)
        result = vqe.compute_minimum_eigenvalue(self.hamiltonian)

        return {
            "eigenvalue": result.eigenvalue,
            "optimal_parameters": result.optimal_parameters,
            "optimal_point": result.optimal_point,
            "cost_function_evals": result.cost_function_evals
        }

# Example: H2 molecule
def create_h2_hamiltonian():
    """Create Hamiltonian for H2 molecule"""
    # Simplified Hamiltonian
    hamiltonian = SparsePauliOp.from_list([
        ("II", -1.0523732),
        ("IZ", 0.39793742),
        ("ZI", -0.39793742),
        ("ZZ", -0.01128010),
        ("XX", 0.18093119)
    ])
    return hamiltonian

Quantum Machine Learning

from qiskit_machine_learning.algorithms import VQC
from qiskit_machine_learning.neural_networks import CircuitQNN
from qiskit.circuit import Parameter
import numpy as np

class QuantumClassifier:
    """Variational Quantum Classifier"""

    def __init__(self, n_features: int, n_classes: int):
        self.n_features = n_features
        self.n_classes = n_classes
        self.vqc = None

    def create_feature_map(self):
        """Create feature map to encode classical data"""
        qc = QuantumCircuit(self.n_features)

        for i in range(self.n_features):
            param = Parameter(f'x[{i}]')
            qc.ry(param, i)

        return qc

    def create_ansatz(self):
        """Create parameterized circuit"""
        ansatz = TwoLocal(
            self.n_features,
            ['ry', 'rz'],
            'cz',
            reps=2,
            entanglement='full'
        )
        return ansatz

    def train(self, X_train, y_train):
        """Train quantum classifier"""
        feature_map = self.create_feature_map()
        ansatz = self.create_ansatz()

        self.vqc = VQC(
            num_qubits=self.n_features,
            feature_map=feature_map,
            ansatz=ansatz,
            optimizer=SLSQP(maxiter=100)
        )

        self.vqc.fit(X_train, y_train)

    def predict(self, X_test):
        """Predict using trained model"""
        return self.vqc.predict(X_test)

Best Practices

Circuit Design

• Minimize circuit depth for NISQ devices
• Use native gates when possible
• Consider qubit connectivity
• Implement error mitigation
• Optimize transpilation
• Use efficient state preparation

Algorithm Implementation

• Start with small quantum circuits
• Validate with classical simulation
• Use noise models for realistic testing
• Implement proper error handling
• Monitor quantum volume metrics
• Document quantum advantage claims

Production Usage

• Use quantum cloud services (IBM, AWS Braket)
• Implement hybrid classical-quantum algorithms
• Cache quantum results when possible
• Monitor job queue times
• Handle quantum hardware limitations
• Plan for error correction overhead

Anti-Patterns

❌ Deep circuits on NISQ devices ❌ Ignoring hardware connectivity ❌ No error mitigation ❌ Claiming quantum advantage without proof ❌ Not validating with simulation first ❌ Ignoring decoherence times ❌ Inefficient state preparation

Resources

• Qiskit: https://qiskit.org/
• IBM Quantum: https://quantum-computing.ibm.com/
• Quantum Computing Stack Exchange: https://quantumcomputing.stackexchange.com/
• AWS Braket: https://aws.amazon.com/braket/