Research & Projects

Topological superconductors host Majorana zero modes—exotic quasiparticles with potential applications in fault-tolerant quantum computing. This project develops a systematic VQE-based framework for identifying topological superconductor candidates by combining quantum simulation with model-aware physics diagnostics.

The pipeline constructs real-space Bogoliubov–de Gennes (BdG) Hamiltonians for the Kitaev chain model with configurable chemical potential (μ), hopping amplitude (t), and superconducting gap (Δ), including optional on-site disorder. These are mapped to qubit operators via Jordan-Wigner transformation using Qiskit’s SparsePauliOp, then optimized with VQE using hardware-efficient ansätze and BackendEstimatorV2.

Topological characterization includes momentum-space winding number computation (W = 1 in the topological phase |μ| < 2t, W = 0 in the trivial phase), entanglement entropy across bipartitions, and finite-size scaling analysis near the phase boundary. Classical exact diagonalization benchmarks validate all quantum results. An experimental Rashba nanowire model extends the framework toward realistic material parameters.

The project integrates with the Materials Project API for candidate screening and includes an active learning module for efficient material discovery. All runs log reproducibility artifacts: git hash, random seeds, package versions, and full parameter sets in HDF5 format. YAML-based configuration with typed runtime validation ensures deterministic, auditable execution.

A preflight doctor command verifies all dependencies before execution. The framework enforces model invariants (num_sites × qubits_per_site = num_qubits) and supports both legacy and modern CLI interfaces for the full 13-stage pipeline.

Key tools: Qiskit 2.x, PennyLane, NumPy, SciPy, Matplotlib, Materials Project API, SLURM/HPC

The Clemson Quantum Group needed a modern, maintainable web presence that non-technical group members could update without writing code. This site uses a markdown-driven content architecture: pages, events, news items, and resources are authored as markdown files with YAML frontmatter, rendered at build time with React-Markdown and Remark GFM.

The application is built on Next.js 15 with React 19 and strict TypeScript, using the App Router for file-system-based routing. A Node.js build script generates a search index at compile time, enabling client-side content discovery without a backend. Static export produces a fully static site deployed to GitHub Pages via GitHub Actions CI/CD.

The component architecture includes reusable React components for member cards, event timelines, resource listings, and navigation. The design is fully responsive and uses modern CSS features. ESLint 9 enforces code quality standards across the TypeScript codebase.

Key tools: Next.js 15, React 19, TypeScript 5.7, React-Markdown, GitHub Actions, GitHub Pages

Fault-tolerant quantum computing requires decomposing arbitrary unitaries into the Clifford+T gate set (H, T, T†, S, S†, CX), where T-gates are the dominant cost due to magic state distillation overhead. This project tackles the Superquantum challenge by building a complete synthesis and optimization pipeline that converts arbitrary unitary matrices into resource-efficient Clifford+T circuits.

The optimizer employs a multi-strategy approach: pattern recognition identifies common 2-qubit structures (QFT blocks, Heisenberg/XX+YY interactions) and maps them to known optimal decompositions; brute-force search explores low-T circuit structures for small unitaries; and phase-polynomial optimization via the rmsynth C++ toolkit applies Reed-Muller decoding (Dumer, RPA, and OSD backends) to minimize T-count in larger circuits.

For single-qubit rotations, the pipeline uses pygridsynth for grid-operator-based Rz angle approximation, achieving near-optimal T-counts at configurable precision. The system supports multiple effort levels that trade compilation time for circuit quality, and outputs standard QASM with full resource metrics (T-count, CX-count, total depth).

All 11 challenge unitaries were successfully optimized, with results benchmarked across effort levels. The project provides both a CLI and Python API for integration into larger compilation workflows.

Key tools: Python, Qiskit 2.x, rmsynth (C++), pygridsynth, NumPy, SciPy

Electroencephalography (EEG) data contains rich spatiotemporal patterns associated with neurological conditions, but traditional analysis methods struggle with the high dimensionality and noise inherent in brain signals. NeurotiQ explores whether quantum machine learning can improve classification performance for mental health diagnosis from EEG recordings.

The primary quantum model is a QSVM using Qiskit quantum kernels with amplitude embedding and diagonal phase encoding, achieving 79% AUC on anxiety detection—a significant improvement over the 68% AUC classical SVM baseline. A secondary QCNN model built with PennyLane and TensorFlow uses StronglyEntanglingLayers for hybrid quantum-classical feature learning.

EEG preprocessing includes KNN imputation for missing channels, PCA dimensionality reduction to 8 components (matching quantum hardware constraints), and L2 normalization. The pipeline supports multiple EEG datasets sourced from Kaggle (anxiety), Zenodo (depression), and local collections (ADHD), with severity classification into mild, moderate, and severe categories.

The Streamlit web application provides real-time inference, interactive visualization of classification results, and a GPT-4-powered emotional support chatbot (via LangChain) that generates personalized recommendations based on the diagnostic output. Classical baselines include PyCaret AutoML ensembles, SVM, and logistic regression for controlled comparisons.

Key tools: Qiskit 2.x, PennyLane, TensorFlow/Keras, scikit-learn, PyCaret, Streamlit, LangChain, OpenAI GPT-4

Making quantum computing accessible to students without a physics background requires careful abstraction of core concepts into familiar, intuitive frameworks. The Qoffee Maker activity maps quantum circuit operations to steps in a coffee-making process, letting learners “brew” different quantum states by applying gate sequences.

Participants start with qubits in the |0⟩ state and apply single-qubit gates—X (bit flip), H (superposition), and Z (phase flip)—to produce target “coffee” outcomes. The activity introduces measurement as “tasting” the result, naturally illustrating wavefunction collapse and probabilistic outcomes. Multi-qubit extensions introduce entanglement through CNOT gates, showing how quantum correlations differ from classical mixing.

The activity has been used in Clemson Quantum Group outreach events and educational workshops, providing a structured 30–60 minute introduction to quantum computing that requires no prior physics or programming knowledge. Facilitator guides and printable circuit worksheets support deployment in diverse teaching contexts.

Key tools: Python, Qiskit