Q-DrugMind: A Hybrid Quantum–LLM Framework for Rare-Disease Drug Repurposing

Q-DrugMind: A Hybrid Quantum–LLM Framework for Rare-Disease Drug Repurposing

Abstract

Rare diseases present significant challenges in conventional drug discovery because of limited patient populations, small datasets, high development costs, and insufficient experimental evidence. Drug repurposing provides an alternative strategy by identifying new therapeutic applications for existing drugs. At the same time, recent developments in quantum computing, quantum machine learning (QML), and Large Language Models (LLMs) provide new computational approaches for molecular analysis and biomedical knowledge discovery.

This paper proposes Q-DrugMind, a hybrid quantum–classical and LLM-based framework for rare-disease drug repurposing. The proposed system integrates molecular data from ChEMBL and PubChem, disease–target information from Open Targets, molecular fingerprints generated using RDKit, classical machine learning, quantum-kernel learning, and retrieval-augmented Large Language Models. Classical Random Forest models are used as a baseline, while a quantum kernel is investigated for molecular similarity and classification. The LLM component retrieves and summarizes scientific literature to provide evidence for drug–target–disease relationships.

The primary objective is not to claim immediate quantum advantage, but to experimentally compare classical and quantum approaches under similar conditions and determine whether quantum machine learning can provide useful complementary information for small biomedical datasets. The final system generates ranked drug candidates together with supporting evidence and interpretable explanations. The proposed framework can serve as a research prototype for computational drug repurposing and hypothesis generation, while final therapeutic decisions would require laboratory and clinical validation.

Keywords: Quantum Computing, Quantum Machine Learning, Drug Repurposing, Rare Diseases, Large Language Models, RDKit, ChEMBL, PubChem, Open Targets, RAG, Drug Discovery.

---

1. Introduction

Drug discovery is a complex and expensive process that requires the analysis of chemical structures, biological targets, disease mechanisms, experimental measurements, and scientific literature. The development of a completely new drug can require many years of research and substantial financial investment. These challenges are particularly significant for rare diseases because available biological and clinical datasets are often much smaller than those available for common diseases.

Drug repurposing attempts to solve part of this problem by identifying new therapeutic applications for drugs that have already been studied or developed for other conditions. Instead of beginning the entire drug-development process from the beginning, computational methods can search existing compounds for previously unknown relationships with disease-associated targets.

Artificial intelligence and machine learning have increasingly been applied to this problem. Classical machine-learning algorithms can learn relationships between molecular representations and experimentally observed biological activity. However, the growing interest in quantum computing has introduced another research direction: quantum machine learning.

Quantum computers represent information using quantum bits, or qubits. Quantum algorithms can manipulate quantum states using operations such as rotation and entanglement. In quantum machine learning, classical data can be encoded into quantum states and processed using parameterized quantum circuits or quantum kernels.

Large Language Models provide another complementary capability. LLMs can process large quantities of scientific text and assist with extracting relationships among drugs, genes, proteins, pathways, and diseases. However, LLMs can generate unsupported information if they are used without reliable external evidence. Therefore, the proposed framework combines LLMs with retrieval-augmented generation (RAG), allowing the model to produce explanations based on retrieved scientific information.

This paper proposes a hybrid framework that combines these technologies into a single drug-repurposing pipeline.

---

2. Research Problem

The research problem addressed in this work is:

How can classical machine learning, quantum machine learning, and Large Language Models be integrated into a single computational framework for identifying and explaining potential drug-repurposing candidates for rare diseases?

The proposed system addresses four major challenges:

1. Limited rare-disease datasets.
2. Complex molecular representations.
3. Difficulty of comparing classical and quantum approaches.
4. Difficulty of interpreting computational predictions using biomedical evidence.

---

3. Research Objectives

The main objectives of Q-DrugMind are:

1. To collect drug, molecular, disease, and target information from publicly available biomedical databases.
2. To generate machine-readable molecular representations using RDKit.
3. To establish a classical machine-learning baseline using Random Forest.
4. To implement a quantum-kernel-based machine-learning model.
5. To compare classical and quantum models using common evaluation metrics.
6. To use an LLM with retrieval-augmented generation for scientific evidence extraction.
7. To construct drug–target–pathway–disease relationships.
8. To rank potential drug-repurposing candidates.
9. To provide evidence-based explanations for candidate drugs.
10. To identify limitations and determine whether quantum machine learning provides useful complementary information.

---

4. Background

4.1 Rare Diseases

Rare diseases affect relatively small populations and often have limited experimental data. Many rare diseases also lack effective treatments. This creates a strong motivation for computational approaches that can reuse existing biological and pharmaceutical information.

4.2 Drug Repurposing

Drug repurposing is the process of identifying new therapeutic applications for existing drugs.

For example:

Existing Drug → Known Target → New Disease Association → Candidate for Repurposing

Computational drug repurposing can reduce the search space by prioritizing promising candidates before experimental validation.

4.3 Quantum Computing

A classical computer represents information using bits:

0 or 1

A quantum computer uses qubits.

A qubit can exist in a quantum state represented as:

|ψ⟩ = α|0⟩ + β|1⟩

where α and β are probability amplitudes satisfying:

|α|² + |β|² = 1.

Quantum circuits manipulate these states using quantum gates.

Common gates include:

- Hadamard gate
- Pauli-X gate
- Pauli-Y gate
- Pauli-Z gate
- Rotation gates
- Controlled-NOT gate

4.4 Quantum Machine Learning

Quantum machine learning combines classical machine learning with quantum circuits.

A simplified workflow is:

Classical Data
↓
Feature Reduction
↓
Quantum Encoding
↓
Quantum Circuit
↓
Measurement
↓
Classical Prediction

Because current quantum hardware is limited and noisy, the proposed project uses a hybrid classical–quantum approach.

4.5 Large Language Models

Large Language Models can process scientific text and extract relationships between biomedical concepts.

For example:

Scientific Paper
↓
LLM
↓
Drug → Target → Pathway → Disease

However, an LLM should not be treated as a biological validation system. Therefore, Q-DrugMind uses retrieval-augmented generation to ground explanations in retrieved evidence.

---

5. Related Work

Recent research has investigated quantum machine learning for molecular-property prediction, drug discovery, molecular generation, and related computational chemistry tasks. Quantum neural networks, quantum kernels, variational circuits, and hybrid quantum-classical approaches have been explored as potential tools for pharmaceutical research.

At the same time, Large Language Models are increasingly being investigated for scientific discovery, including molecular property prediction, literature analysis, molecular generation, and scientific-agent workflows.

Existing research generally investigates individual components or combinations of two technologies. Q-DrugMind proposes a unified workflow combining:

Biomedical databases + Classical ML + Quantum ML + Knowledge Graph + LLM/RAG

The proposed contribution is therefore the integration and benchmarking of these components for rare-disease drug repurposing.

---

6. Research Gap

The following gap motivates this work:

Existing systems
↓
Classical ML
OR
Quantum ML
OR
LLM-based systems

Proposed system
↓
Classical ML
+
Quantum ML
+
LLM/RAG
+
Biomedical Knowledge Graph

The framework does not assume that the quantum model will outperform classical machine learning. Instead, it treats quantum machine learning as an experimental component and evaluates it against classical baselines.

---

7. Proposed Q-DrugMind Architecture

The proposed architecture is:

USER
|
v
Select Rare Disease
|
+-----------+-----------+
| | |
v v v
ChEMBL PubChem Open Targets
| | |
+-----------+-----------+
|
v
Data Cleaning
|
v
RDKit
|
v
Molecular Fingerprint
|
Feature Reduction
|
+--------+--------+
| |
v v
Classical ML Quantum ML
Random Forest Quantum Kernel
| |
+--------+--------+
|
v
Candidate Ranking
|
v
Knowledge Graph
|
v
Literature RAG
|
v
LLM
|
v
Evidence Explanation
|
v
Final Candidate Report

---

8. Dataset Sources

8.1 ChEMBL

ChEMBL is a publicly accessible database containing information about bioactive molecules and their experimentally measured activities.

Website:

https://www.ebi.ac.uk/chembl/

API documentation:

https://www.ebi.ac.uk/chembl/api/data/docs

Example Python code:

import requests

drug = "aspirin"

url = f"https://www.ebi.ac.uk/chembl/api/data/molecule/search?q={drug}"

response = requests.get(url)

print("Status:", response.status_code)

data = response.json()

print(data)

---

9. PubChem

PubChem provides chemical structures and molecular properties.

Website:

https://pubchem.ncbi.nlm.nih.gov/

PUG-REST API:

https://pubchem.ncbi.nlm.nih.gov/docs/pug-rest

Example:

import requests

drug = "aspirin"

url = (
"https://pubchem.ncbi.nlm.nih.gov/rest/pug/"
f"compound/name/{drug}/property/"
"MolecularFormula,MolecularWeight,CanonicalSMILES/JSON"
)

response = requests.get(url)

data = response.json()

properties = data["PropertyTable"]["Properties"][0]

print("Molecular Formula:", properties["MolecularFormula"])
print("Molecular Weight:", properties["MolecularWeight"])
print("SMILES:", properties["ConnectivitySMILES"])

---

10. Open Targets

Open Targets provides information about relationships between diseases, targets, drugs, and other biomedical entities.

Website:

https://platform.opentargets.org/

The information can be used to construct relationships such as:

Disease
↓
Gene
↓
Protein
↓
Drug

These relationships become useful for generating candidate drugs and explaining their possible mechanisms.

---

11. RDKit Molecular Representation

Machine-learning algorithms cannot directly understand a SMILES string.

For example:

CC(=O)OC1=CC=CC=C1C(=O)O

RDKit can convert the molecule into a numerical fingerprint.

Installation:

pip install rdkit

Official website:

https://www.rdkit.org/

Example:

from rdkit import Chem
from rdkit.Chem import AllChem

smiles = "CC(=O)OC1=CC=CC=C1C(=O)O"

molecule = Chem.MolFromSmiles(smiles)

fingerprint = AllChem.GetMorganFingerprintAsBitVect(
molecule,
radius=2,
nBits=128
)

features = list(fingerprint)

print("Number of features:", len(features))
print(features)

Example output:

Number of features: 128
[0, 1, 0, 0, 1, 0, 1, 0, ...]

The molecular structure is now represented as a numerical vector.

---

12. Classical Machine-Learning Model

Random Forest is selected as the initial baseline because it performs well on many tabular classification problems and provides an interpretable reference for comparison.

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, f1_score, roc_auc_score

X_train, X_test, y_train, y_test = train_test_split(
X,
y,
test_size=0.20,
random_state=42,
stratify=y
)

model = RandomForestClassifier(
n_estimators=300,
random_state=42
)

model.fit(X_train, y_train)

prediction = model.predict(X_test)

probability = model.predict_proba(X_test)[:, 1]

print("Accuracy:", accuracy_score(y_test, prediction))
print("F1 Score:", f1_score(y_test, prediction))
print("ROC-AUC:", roc_auc_score(y_test, probability))

The results should be recorded rather than manually selected.

---

13. Data Leakage Prevention

Data leakage is an important problem in computational drug discovery.

A random train-test split can accidentally place chemically similar compounds into both training and testing datasets.

Therefore, the proposed study should use a scaffold-based split where possible.

Training Dataset
├── Scaffold A
├── Scaffold B
└── Scaffold C

Testing Dataset
└── Previously unseen Scaffold D

This provides a more realistic evaluation of whether the model can generalize to chemically different molecules.

---

14. Quantum Machine-Learning Model

Molecular fingerprints can contain hundreds or thousands of dimensions, while the number of available qubits is much smaller.

Therefore:

2048-bit fingerprint
↓
PCA
↓
4–8 features
↓
Quantum Feature Map
↓
Quantum Kernel
↓
SVM

Principal Component Analysis can be used to reduce the dimensionality.

from sklearn.decomposition import PCA

pca = PCA(n_components=4)

X_reduced = pca.fit_transform(X)

print(X_reduced.shape)

---

15. Quantum Feature Encoding

Let the reduced molecular feature vector be:

x = [x₁, x₂, x₃, x₄]

Each feature can be encoded using a rotation gate:

Rᵧ(xᵢ)

The circuit can be represented as:

q0 ──RY(x1)────●────────
│
q1 ──RY(x2)────X────●───
│
q2 ──RY(x3)─────────X──●
│
q3 ──RY(x4)────────────X

The CNOT gates introduce entanglement between qubits.

---

16. PennyLane Installation

PennyLane is used for implementing the quantum machine-learning component.

Installation:

pip install pennylane

Official documentation:

https://docs.pennylane.ai/

Example:

import pennylane as qml
from pennylane import numpy as np

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

@qml.qnode(dev)
def quantum_circuit(x):

for i in range(4):
qml.RY(x[i], wires=i)

qml.CNOT(wires=[0, 1])
qml.CNOT(wires=[1, 2])
qml.CNOT(wires=[2, 3])

return qml.expval(qml.PauliZ(0))

x = np.array([
0.2,
0.5,
0.7,
0.3
])

result = quantum_circuit(x)

print("Quantum output:", result)

---

17. Quantum Kernel

A quantum kernel measures similarity between two encoded data points.

The mathematical definition can be expressed as:

K(xᵢ,xⱼ) = |⟨φ(xᵢ)|φ(xⱼ)⟩|²

where:

- xᵢ and xⱼ are molecular feature vectors.
- φ(x) is the quantum feature map.
- K is the quantum similarity.

The quantum kernel can be supplied to a classical SVM.

import pennylane as qml
from pennylane import numpy as np

n_qubits = 4

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

def feature_map(x):

for i in range(n_qubits):
qml.RY(x[i], wires=i)

for i in range(n_qubits - 1):
qml.CNOT(wires=[i, i + 1])

@qml.qnode(dev)
def quantum_kernel(x1, x2):

feature_map(x1)

qml.adjoint(feature_map)(x2)

return qml.probs(wires=range(n_qubits))[0]

x1 = np.array([0.2, 0.4, 0.5, 0.7])
x2 = np.array([0.3, 0.5, 0.4, 0.6])

result = quantum_kernel(x1, x2)

print("Quantum kernel value:", result)

---

18. Real Quantum Hardware

After validating the model using a simulator, the experiment can optionally be transferred to quantum hardware.

Qiskit:

https://www.ibm.com/quantum/qiskit

PennyLane-Qiskit:

https://docs.pennylane.ai/projects/qiskit/

Installation:

pip install pennylane-qiskit

The experimental progression is:

Local Simulator
↓
Qiskit Aer
↓
Cloud Quantum Hardware

The simulator should be used first because debugging a quantum algorithm on hardware is more difficult and hardware results can be affected by noise.

---

19. LLM and RAG Component

The LLM component is responsible for understanding biomedical literature.

The proposed process is:

Scientific Papers
↓
Text Extraction
↓
Text Chunking
↓
Embeddings
↓
Vector Database
↓
Relevant Evidence
↓
LLM
↓
Scientific Explanation

The system should retrieve relevant documents before generating an answer.

For example:

Candidate Drug: Drug A

Retrieved Evidence:
Paper 1 → Drug A affects Protein X
Paper 2 → Protein X is associated with Disease Y
Paper 3 → Pathway Z is involved in Disease Y

LLM:
"These studies provide evidence for a possible
Drug A → Protein X → Disease Y relationship."

The LLM should clearly distinguish between:

Published evidence

and

Model-generated hypothesis.

---

20. LLM Installation

Hugging Face Transformers can be installed using:

pip install transformers torch

Website:

https://huggingface.co/

Documentation:

https://huggingface.co/docs/transformers/

Example:

from transformers import pipeline

generator = pipeline(
"text-generation",
model="distilgpt2"
)

result = generator(
"Drug repurposing for rare diseases can",
max_new_tokens=50
)

print(result[0]["generated_text"])

For the final research system, a biomedical-capable model and a proper retrieval system should be used instead of relying on a small demonstration model.

---

21. Knowledge Graph

The framework represents biomedical relationships as a graph:

DRUG
|
targets
|
PROTEIN
|
involved in
|
PATHWAY
|
associated with
|
DISEASE

A candidate may therefore be represented as:

Drug A
↓
Target B
↓
Pathway C
↓
Rare Disease D

The knowledge graph allows the LLM to explain why a candidate was ranked.

---

22. Candidate Ranking

The final system combines multiple signals.

An example ranking function is:

Score = w₁M + w₂E + w₃B + w₄Q

where:

- M = classical ML prediction
- E = literature evidence score
- B = biological association score
- Q = quantum-model score
- w₁, w₂, w₃, w₄ = experimentally determined weights

For example, an experimental implementation could initially use:

ML prediction → 40%
Literature evidence → 25%
Biological evidence → 20%
Quantum score → 15%

These weights should not be treated as scientifically established values. They should be tuned and validated using the experimental dataset.

---

23. Experimental Design

The experiment compares the following models:

Model 1:
Random Forest

Model 2:
Classical SVM

Model 3:
Quantum Kernel + SVM

Model 4:
Hybrid Candidate Ranking

The same dataset and evaluation protocol should be used wherever possible.

Evaluation metrics include:

- Accuracy
- Precision
- Recall
- F1-score
- ROC-AUC
- Training time
- Inference time

For drug-discovery applications, additional ranking metrics such as Precision@K and Recall@K can also be considered.

---

24. Results

The experimental results should be recorded in the following format:

Model| Accuracy| Precision| Recall| F1| ROC-AUC| Time
Random Forest| XX| XX| XX| XX| XX| XX
Classical SVM| XX| XX| XX| XX| XX| XX
Quantum Kernel + SVM| XX| XX| XX| XX| XX| XX
Hybrid System| XX| XX| XX| XX| XX| XX

The values must be obtained by executing the experiments.

No performance value should be fabricated.

---

25. Example Case Study

Consider a hypothetical rare disease:

Disease X

Suppose Open Targets identifies:

Disease X
↓
Target A
Target B
Target C

ChEMBL is then searched for compounds associated with these targets.

Suppose the system obtains:

Drug A
Drug B
Drug C
Drug D
Drug E

RDKit generates molecular fingerprints for each compound.

The classical model predicts:

Drug A → 0.82
Drug B → 0.75
Drug C → 0.61
Drug D → 0.47
Drug E → 0.33

The quantum model produces another ranking.

The literature-retrieval system then examines evidence for the top candidates.

The final output may look like:

Candidate| ML Score| Quantum Score| Evidence| Final Rank
Drug A| 0.82| 0.79| High| 1
Drug B| 0.75| 0.81| Medium| 2
Drug C| 0.61| 0.65| High| 3

These numbers are only an illustration. Actual values must come from the experiment.

---

26. Software Architecture

The recommended project structure is:

Q-DrugMind/
│
├── data/
│ ├── raw/
│ ├── processed/
│ └── literature/
│
├── notebooks/
│ ├── 01_data_collection.ipynb
│ ├── 02_rdkit_features.ipynb
│ ├── 03_classical_ml.ipynb
│ ├── 04_quantum_kernel.ipynb
│ └── 05_evaluation.ipynb
│
├── src/
│ ├── data_loader.py
│ ├── chem_features.py
│ ├── classical_model.py
│ ├── quantum_model.py
│ ├── literature_agent.py
│ ├── knowledge_graph.py
│ └── ranking.py
│
├── results/
│ ├── metrics.csv
│ ├── candidates.csv
│ └── figures/
│
├── app/
│ ├── app.py
│ ├── templates/
│ └── static/
│
├── requirements.txt
└── README.md

---

27. Installation

Create a Python virtual environment:

python -m venv .venv

Windows:

.venv\Scripts\activate

Linux/macOS:

source .venv/bin/activate

Install the required packages:

pip install numpy pandas scikit-learn matplotlib
pip install rdkit
pip install pennylane
pip install pennylane-qiskit
pip install transformers torch
pip install requests

Or create "requirements.txt":

numpy
pandas
scikit-learn
matplotlib
rdkit
pennylane
pennylane-qiskit
transformers
torch
requests

Then execute:

pip install -r requirements.txt

---

28. Research Workflow

The complete implementation follows:

1. Select rare disease
↓
2. Retrieve disease-associated targets
↓
3. Retrieve known compounds
↓
4. Obtain molecular structures
↓
5. Generate molecular fingerprints
↓
6. Clean and preprocess data
↓
7. Scaffold-based train/test split
↓
8. Train Random Forest
↓
9. Reduce features using PCA
↓
10. Encode features into quantum circuit
↓
11. Calculate quantum kernel
↓
12. Train quantum-kernel SVM
↓
13. Compare classical vs quantum
↓
14. Retrieve scientific literature
↓
15. Build drug-target-disease graph
↓
16. Generate evidence-based LLM explanation
↓
17. Rank candidate drugs
↓
18. Produce final research report

---

29. Limitations

The proposed framework has several limitations.

First, current quantum computers have limited qubit counts and are affected by noise. Therefore, the proposed quantum component may not outperform classical machine-learning methods.

Second, rare-disease datasets are often small, creating a risk of overfitting.

Third, molecular fingerprints are simplified representations of chemical structures and may not capture every relevant molecular property.

Fourth, biomedical literature can contain contradictory or incomplete evidence.

Fifth, an LLM can produce incorrect or unsupported statements if retrieval and source verification are inadequate.

Finally, computational predictions cannot establish clinical efficacy. Candidate drugs generated by Q-DrugMind should therefore be considered research hypotheses requiring experimental and clinical validation.

---

30. Ethical and Scientific Considerations

The system must not present a computational prediction as a confirmed medical treatment.

The output should use language such as:

"potential candidate"

"computationally predicted relationship"

"hypothesis requiring experimental validation"

instead of:

"this drug cures the disease."

The LLM should also provide the scientific sources used for its explanation wherever possible.

---

31. Future Work

Future research could investigate:

1. Quantum graph neural networks for molecular graphs.
2. Larger quantum feature maps.
3. Real quantum hardware experiments.
4. Molecular docking using AutoDock Vina.
5. Protein–ligand interaction prediction.
6. Graph neural networks as additional baselines.
7. Larger rare-disease datasets.
8. Multi-omics information.
9. Improved biomedical RAG systems.
10. Automated literature updating.
11. Explainable AI techniques.
12. Experimental laboratory validation.

A future architecture could therefore become:

Rare Disease
↓
Knowledge Graph
↓
GNN + Classical ML
↓
Quantum ML
↓
Molecular Docking
↓
Literature RAG
↓
LLM Scientific Agent
↓
Candidate Ranking
↓
Experimental Validation

---

32. Conclusion

This paper presented Q-DrugMind, a hybrid computational framework for rare-disease drug repurposing that combines classical machine learning, quantum machine learning, biomedical databases, knowledge graphs, and Large Language Models.

The framework uses public resources such as ChEMBL, PubChem, Open Targets, and scientific literature to construct a computational pipeline from disease identification to candidate-drug ranking. RDKit is used for molecular representation, Random Forest provides a classical baseline, and a quantum kernel provides an experimental quantum-machine-learning approach.

The LLM component does not replace biological validation. Instead, it provides literature-grounded explanations for computationally identified candidates. This separation between prediction and explanation improves the scientific reliability of the system.

The most important research objective is not to assume that quantum computing is automatically superior. Instead, Q-DrugMind provides a reproducible framework for experimentally testing whether quantum machine learning can provide useful information when applied to small and complex biomedical datasets.

The final output should be interpreted as a list of computationally prioritized drug-repurposing hypotheses rather than confirmed treatments. Experimental and clinical validation remain essential before any candidate can be considered therapeutically effective.

---

33. Important Websites and Resources

ChEMBL:
https://www.ebi.ac.uk/chembl/

ChEMBL API:
https://www.ebi.ac.uk/chembl/api/data/docs

PubChem:
https://pubchem.ncbi.nlm.nih.gov/

PubChem PUG-REST:
https://pubchem.ncbi.nlm.nih.gov/docs/pug-rest

Open Targets:
https://platform.opentargets.org/

Orphanet:
https://www.orpha.net/

RDKit:
https://www.rdkit.org/

RDKit Documentation:
https://www.rdkit.org/docs/

PennyLane:
https://pennylane.ai/

PennyLane Documentation:
https://docs.pennylane.ai/

Qiskit:
https://www.ibm.com/quantum/qiskit

Hugging Face:
https://huggingface.co/

Transformers Documentation:
https://huggingface.co/docs/transformers/

---

34. References

1. ChEMBL Database — European Bioinformatics Institute, EMBL-EBI.
2. PubChem — National Center for Biotechnology Information.
3. Open Targets Platform — Open Targets Consortium.
4. RDKit: Open-source cheminformatics software.
5. PennyLane: Open-source software framework for quantum machine learning.
6. Qiskit — IBM Quantum.
7. Hugging Face Transformers — Open-source machine-learning framework.
8. Recent research on quantum machine learning applications in drug discovery.
9. Recent research on Large Language Models for molecular scientific discovery.
10. Recent research on LLM-based computational drug-discovery systems.

---

35. Reproducibility Statement

All computational experiments should be performed using publicly accessible datasets and documented software versions. The random seed, dataset preprocessing procedure, train-test splitting strategy, molecular fingerprint parameters, quantum circuit architecture, model hyperparameters, and evaluation metrics should be recorded.

The source code should be maintained in a public GitHub repository together with installation instructions, dataset references, experiment notebooks, and result files.

This allows other researchers to reproduce the experiments and independently evaluate the proposed framework.