Quantum Neural Search

Grover search and variational quantum circuits for 4-qubit EEG pattern classification, built with Qiskit and PennyLane. All data is synthetically generated for algorithm validation.

Objective

This repository implements quantum algorithms for neuroscience applications. It provides exact pattern search (Grover's algorithm) and adaptive classification (variational quantum circuits). The system operates on a 33-region brain atlas with 4-qubit encoding. Synthetic EEG signals with alpha, beta, theta, and gamma frequency bands serve as input.

For $N$ feature qubits, the search space has $S = 2^N$ states. Grover's algorithm finds target states in $O(\sqrt{S})$ oracle calls instead of $O(S)$. The variational classifier learns decision boundaries through parametrized gates, optimized via gradient descent.

Goal: Demonstrate quantum search and classification on synthetic neural data. Compare against classical baselines (SVM, Random Forest) and provide a modular codebase for future hardware experiments.

Theoretical Background

Neural Dynamics and Quantum Encoding

Biological neural networks are modeled using the Leaky Integrate-and-Fire (LIF) neuron framework:

$$\tau \frac{dV}{dt} = -V(t) + I(t)$$

where $V(t)$ represents membrane potential, $\tau$ is the membrane time constant, and $I(t)$ represents synaptic input. For network-level analysis, this extends to coupled systems with connectivity matrices:

$$\frac{d\mathbf{V}}{dt} = -\frac{1}{\tau}\mathbf{V} + \mathbf{W}\mathbf{s}(t) + \mathbf{I}_{ext}(t)$$

The Quantum Leaky Integrate-and-Fire (QLIF) model represents neural excitation through qubit state probabilities:

$$\alpha[t+1] = \sin^2\left(\frac{(\theta + \varphi[t])X[t+1] + (\gamma[t] + \varphi[t])(1-X[t+1]) + \arcsin(\sqrt{\alpha[t]})}{2}\right)$$

where $\alpha[t]$ is the excited-state probability, $\theta$ controls spike rotation angles, $\gamma[t]$ models quantum decoherence via exponential $T_2$ decay, and the cumulative angle $\arcsin(\sqrt{\alpha[t]})$ provides integration memory across timesteps.

Quantum Algorithm Formulations

Grover's search uses amplitude amplification with a multi-controlled phase gate oracle:

$$|\psi_{final}\rangle = G^{k} |s\rangle, \quad k = \left\lfloor \frac{\pi}{4\arcsin(1/\sqrt{N})} \right\rceil$$

where $G = -U_s U_f$ combines the oracle $U_f$ (marks target brain states via mcp) and diffusion operator $U_s$ (amplifies marked amplitudes).

Variational quantum circuits classify brain states through parametrized gates:

$$\langle \hat{H} \rangle_{\boldsymbol{\theta}} = \langle \psi_{data} | U^{\dagger}(\boldsymbol{\theta}) \hat{H} U(\boldsymbol{\theta}) | \psi_{data} \rangle$$

where $U(\boldsymbol{\theta})$ is optimized via gradient descent. Multi-qubit measurement returns one expectation value per qubit for 5-class discrimination.

Signal Encoding Strategies

Three encoding methods convert continuous EEG signals to quantum-compatible discrete states:

Threshold encoding creates binary representations using standard-deviation scaling:

$$b[n] = \begin{cases} 1 & \text{if } |x[n]| > \theta_{factor} \cdot \sigma(x) \\ 0 & \text{otherwise} \end{cases}$$

Phase encoding uses the Hilbert transform to extract instantaneous phase: $$\phi[n] = \arg(\mathcal{H}(x[n]))$$

Amplitude encoding normalizes magnitudes to $[0, 1]$: $$a[n] = \frac{x[n] - x_{min}}{x_{max} - x_{min}}$$

Neural complexity is quantified using Normalized Corrected Shannon Entropy (NCSE): $$NCSE(L,\Psi) = \frac{CSE(L,\Psi)}{CSE_{max}(L,\Psi)}$$

where $L$ is symbolic word length, $\Psi$ is the symbolic sequence, and $CSE$ includes Miller-Madow bias correction.

Code Functionality

1. Brain Network Setup and Atlas Creation

Creates a 33-region brain atlas organized across 6 major functional networks with anatomically plausible 3D coordinates in MNI space.

from quantumNeuralSearch.brainAtlas import createBrainAtlas

atlasinfo, coords, nodesDf = createBrainAtlas()
# Returns atlas DataFrame, 3D coordinates, and node metadata

2. Brain Connectivity Matrix Generation

Generates biologically realistic connectivity matrices with stronger within-network connections and weaker between-network links, mimicking small-world topology.

from quantumNeuralSearch.brainConnectivity import generateBrainConnectivity

edges, stats = generateBrainConnectivity(atlasinfo, connectivity_seed=42)

3. Neural Signal Processing and Encoding

Generates synthetic EEG signals with physiological frequency bands and encodes them for quantum circuits. Three encoding strategies are implemented: Hilbert-transform phase encoding, std-scaled threshold encoding, and amplitude normalization. The module also includes a QLIF neuron model with cumulative angle integration. NCSE (Normalized Corrected Shannon Entropy) quantifies signal complexity.

from quantumNeuralSearch.neuralEncoding import (
    generateRealisticEegSignal,
    quantumSignalEncoding,
    simulateQlif,
    calculateNcse,
)

time, eeg = generateRealisticEegSignal(duration=4.0, sampling_rate=250)
encodings = quantumSignalEncoding(eeg)
# encodings['phase']     - Hilbert transform binary encoding
# encodings['threshold'] - |x| > sigma threshold encoding
# encodings['amplitude'] - min-max normalized to [0, 1]

qlifResult = simulateQlif(spikeTrain)      # QLIF neuron dynamics
ncseValues = calculateNcse(eeg)             # Normalized Corrected Shannon Entropy

4. Grover's Algorithm for Neural Pattern Search

Uses Grover's quantum search to find specific brain state patterns from a 16-state search space. The oracle marks target states via a multi-controlled phase gate (circuit.mcp), and the exact iteration formula ensures optimal amplification.

from quantumNeuralSearch.groversSearch import constructGroverCircuit, initializeGroverSearch

brainSignatures, searchParams, simulator = initializeGroverSearch()
circuit, iterations = constructGroverCircuit(
    target_signature=[1, 0, 1, 1],  # motor_left
    n_qubits=4
)
# iterations = 3 (optimal for N=16, 1 target)
job = simulator.run(circuit, shots=2048)

5. Variational Quantum Classifier

Parametrized quantum classifier with multi-qubit measurement. Compares against SVM and Random Forest baselines on the same data.

from quantumNeuralSearch.variationalClassifier import (
    setupQuantumDevice,
    createQuantumClassifier,
    prepareBrainStateTrainingData,
    trainVariationalQuantumClassifier,
    evaluateQuantumClassifier,
)

dev = setupQuantumDevice(4)
classifier = createQuantumClassifier(dev)
xTrain, xTest, yTrain, yTest, stateNames, scaler = prepareBrainStateTrainingData()
weights, costHistory = trainVariationalQuantumClassifier(
    xTrain, yTrain, stateNames, classifier, max_iterations=100
)
results = evaluateQuantumClassifier(xTrain, xTest, yTrain, yTest, weights, classifier, stateNames)
# results includes: test_accuracy, svm_accuracy, rf_accuracy, svm_comparison, rf_comparison

6. Dynamic Brain Network Animation

Temporal animations showing brain connectivity evolution, with network-specific oscillation frequencies simulating dynamic coordination patterns.

from quantumNeuralSearch.dynamicStates import generateDynamicConnectivity

dynamicEdges = generateDynamicConnectivity(baseEdges, atlasinfo, t=0.5)

Installation

git clone https://github.com/IsolatedSingularity/Quantum-Neural-Search.git
cd Quantum-Neural-Search
pip install -e ".[dev]"

# Run tests
pytest

# Lint
ruff check .

Requires Python 3.10+. Core dependencies: Qiskit >= 1.0, PennyLane >= 0.35, NumPy, SciPy, scikit-learn, matplotlib.

Project Structure

Quantum-Neural-Search/
  pyproject.toml
  LICENSE
  README.md
  .github/workflows/ci.yml
  quantumNeuralSearch/
    __init__.py
    groversSearch.py          # Grover oracle + search
    variationalClassifier.py  # VQC + classical baselines
    neuralEncoding.py         # Signal encoding, QLIF, NCSE
    brainAtlas.py             # 33-region brain atlas
    brainConnectivity.py      # Connectivity matrix generation
    dynamicStates.py          # Dynamic brain animation
    visualization/
      __init__.py
      groversPlots.py
      variationalPlots.py
      brainPlots.py
      masterAnalysis.py
  tests/
    conftest.py               # Shared fixtures
    testGroverOracle.py       # Oracle correctness, iteration count
    testEncodings.py          # Signal encoding, entropy, QLIF, NCSE
    testVqcConvergence.py     # VQC training, baselines, measurement
  scripts/
    generatePlots.py          # Headless plot generation
  Plots/

Results

On synthetic 4-qubit EEG data with 5 brain states (motor left/right, seizure onset, rest, cognitive load):

• Grover's Search: ~96% average success probability for target state amplification (optimal 3 iterations for N=16). Speedup is $O(\sqrt{N})$ vs $O(N)$ classical brute-force enumeration.
• Variational Classifier: ~35% test accuracy on 5 classes (20% random baseline, 1.7x above chance). Classical baselines (SVM 100%, Random Forest 100%) are evaluated on the same split. The accuracy gap reflects the 4-qubit bottleneck, not algorithm quality.
• 16 tests covering oracle correctness, encoding fidelity, QLIF integration, NCSE edge cases, and VQC convergence.
• CI: ruff lint, ruff format, mypy type checking, pytest with coverage.

The 4-qubit feature space is intentionally small for demonstration. Scaling to clinically relevant dimensionality requires hardware beyond current NISQ devices.

Caveats

• Simulation only: All quantum circuits run on classical simulators (Qiskit Aer, PennyLane default.qubit). Real hardware introduces decoherence and gate errors.
• Synthetic data: No clinical or patient data is used. EEG signals are generated with physiologically plausible frequency components but are not real recordings.
• Feature space: 4 qubits encode only 16 states. Clinical EEG analysis requires much higher dimensionality.
• Encoding loss: Converting continuous EEG to discrete quantum states necessarily discards information. Optimal encoding remains an open problem.

Future Goals

• Extend to larger brain networks with 100+ regions
• Validate on actual quantum hardware (IBM, IonQ)
• Implement error mitigation strategies for noisy circuits
• Explore continuous-variable encoding for higher-fidelity signal representation
• Scale VQC to more qubits for improved 5-class discrimination

Acknowledgments

Built by Jeffrey Morais. Brain atlas coordinates follow the MNI152 standard. Quantum circuits use Qiskit and PennyLane. See CONTRIBUTING.md for development setup and conventions.