Quantum Kernels for Narrative Coherence: An Application to Path Optimization in Document Graphs for Storyline Extraction

Abstract

Narrative extraction algorithms construct storylines by finding coherent paths through document collections. The Narrative Trails algorithm frames this as maximum-capacity path optimization, where path quality depends on a coherence function measuring document relationships. We introduce quantum kernels as coherence functions for narrative extraction—to the best of our knowledge, the first systematic characterisation of quantum kernel methods for storyline extraction—and compare them against classical baselines on two corpora using a multi-seed protocol. The sweep covers 93 method evaluations (54 quantum kernels across three encoder families—R_Y+CNOT-ring, IQP/ZZ-feature-map, and a projected quantum kernel—and 39 classical kernels—cosine, RBF, and the cluster-aware Narrative Trails baseline). On 11,215 human navigation paths from Wikispeedia, evaluation metrics divide into two clusters that disagree with each other: alignment-based metrics (length-normalised DTW and per-step DTW similarity) favour methods that produce long alignment-rich paths, while set-overlap metrics (Jaccard and F1) favour methods that produce shorter paths with higher article overlap. On LLM-judged coherence for Cuban news storylines, evaluated under a 12-method × 5-seed × 30-endpoint-pair × 2-judge design (Claude Sonnet 4.5 and GPT-4o, both at $T=0$ via structured tool calling), the cluster-aware classical baseline is the top method in terms of mean overall coherence; the 5-method quantum-kernel pool and the 7-method classical-kernel pool on matched projection input show no significant differences after Holm correction. Cross-task analysis reveals that LLM coherence rank correlates with alignment-cluster Wikispeedia metrics (Spearman $\rho \approx +0.70$) and anti-correlates with overlap-cluster metrics ($\rho \approx -0.62$). A closed-form theoretical analysis shows that the depth-1 R_Y+CNOT-ring kernel reduces to a classical product-of-cosines kernel order equivalent to RBF, explaining the absence of empirical separation at low depth; deeper encoders break the cancellation but exponentially concentrate kernel values, eroding inter-pair distinguishability. Our results characterise quantum coherence kernels as competitive with classical kernels on the same projected input rather than decisively superior, with the cluster-aware classical baseline retaining a modest advantage attributable to its explicit topical structure.

1. Introduction

Narrative extraction—constructing thematically coherent sequences of documents from a corpus [1]—is a fundamental task in natural language processing with applications in news summarization, knowledge discovery, and information retrieval. The Narrative Trails algorithm [2] addresses this by finding maximum-capacity paths through document graphs where edge weights represent document coherence [3]. This bottleneck formulation optimizes for the weakest transition in a path, making the choice of coherence function consequential.

Quantum machine learning has shown promising results in several application areas—classification benchmarks under encoded data regimes [4,5], learning from physical experimental data with provable advantage [6,7], and variational chemistry-style simulation [8]—yet applications to natural language processing remain relatively unexplored. Quantum kernels—which compute similarity via state overlap in an exponentially large Hilbert space—offer a theoretically motivated approach to measuring document relationships that may capture structure classical methods miss.

We introduce quantum coherence kernels for narrative path extraction and systematically evaluate their performance against classical baselines. The coherence function in the original Narrative Trails algorithm combines angular similarity in UMAP-projected space and topic similarity from HDBSCAN clustering. This design emphasizes local neighborhood structure and topical groupings but may overlook global associative connections that span topic boundaries [9]. We investigate quantum kernels [4] as an alternative, with particular attention to how dimensionality reduction before quantum encoding affects the resulting similarity structure.

The choice of projection method carries theoretical implications. Encoding 1536-dimensional embeddings directly would require hundreds of circuit layers, so some projection is necessary. UMAP transforms geometry to emphasize local manifold structure, potentially discarding global relationships. Random projection, grounded in the Johnson–Lindenstrauss lemma [10,11], preserves pairwise distances from the original embedding space. We hypothesize that random-projection quantum kernels should better preserve associative structure, since human navigation often follows connections based on shared concepts that may not respect topic-cluster boundaries [12].

Why quantum kernels, specifically, rather than simpler similarity measures on randomly projected embeddings? The bottleneck formulation of narrative coherence [2] optimizes for the weakest transition in a path, requiring accurate measurement of all document relationships—including subtle connections that simple similarity measures might miss. Quantum kernels compute similarity via state overlap in an exponentially large Hilbert space [4,5,13], capturing higher-order relationships between embedding dimensions that cosine similarity or RBF kernels cannot efficiently represent [14]. The interference patterns of the quantum circuit [4,15] may encode complex interactions between features that correspond to nuanced semantic relationships. Thus, the theoretical argument combines two elements: (1) random projection preserves the original embedding geometry per Johnson–Lindenstrauss lemma, maintaining semantic relationships that human navigation exploits, and (2) quantum kernels provide expressive similarity computation that can capture complex feature interactions within this preserved geometry [7].

We systematically compare both approaches against the classical baseline using a sweep that totals 93 methods on Wikispeedia (1 classical Narrative Trails baseline, 30 R_Y+CNOT-ring quantum configurations covering the original factorial design over qubits and depth, 14 IQP/ZZ-feature-map variants, 10 projected quantum-kernel variants, and 38 cosine/RBF baselines on the same projected inputs and on the raw 1536-dimembeddings) and a 12-method, 5-seed, dual-judge protocol on Cuban news. On 11,215 human navigation paths from Wikispeedia [16], the standard evaluation metrics divide into two clusters that rank methods in opposite ways: alignment-based metrics (length-normalised DTW and per-step similarity) favour UMAP-projected quantum kernels and the cluster-aware classical baseline, while set-overlap metrics (Jaccard and F1) favour random-projection methods. On LLM-judged coherence for Cuban news [17], the cluster-aware classical baseline is the top method under both judges, while a pool-vs-pool comparison between the five genuinely quantum methods and the seven classical methods (classical narrative trails plus six cosine/RBF kernels on the same random projection used by the quantum pool) shows no significant difference after Holm correction. Therefore, the two evaluation regimes reward different kernel properties: smooth topical concentration helps both alignment and narrative coherence; sharp pairwise similarity on raw projections helps overlap with short navigation paths.

2. Background and Mathematical Foundations

2.1. Mathematical Preliminaries

2.1.1. Maximum-Capacity Path Optimization

Given a weighted graph ($G=(V,E,w)$) with edge weights of $w:E\to [0,1]$, the  maximum-capacity path between vertices s and t is the path ($P^{*}$) that maximizes the minimum edge weight:

$$P^{*}=arg\underset{P\in \mathrm{Paths}(s,t)}{max}\underset{e\in P}{min}w\left(e\right)$$

(1)

This bottleneck formulation differs from shortest-path or maximum-weight problems: a path with nine edges with weights of 0.9 and one edge of a weight 0.1 scores only 0.1. For narrative extraction, this ensures storylines maintain consistent coherence throughout rather than averaging strong and weak transitions.

The maximum-capacity path can be computed efficiently via the maximum spanning tree (MST). The MST of a weighted, undirected graph is a spanning subtree whose total edge weight is maximised; classical algorithms [18] build it greedily by adding edges in decreasing-weight order while avoiding cycles. The relevant property here is that the unique tree path between any two vertices in the MST is also the maximum-capacity path in the original graph: any alternative path must include at least one edge that the greedy procedure rejected, and rejection implies that edge cannot exceed the bottleneck of the tree path. This enables $O(N^{2}logN)$ MST construction (given edge weights), followed by $O\left(N\right)$ path queries; the total preprocessing cost depends on the coherence function used to compute edge weights (see Section 3.7). Concretely, with $N=4$ documents arranged so that the heaviest edges form a chain (A–B–C with weights of $0.9,0.9$) and any other edge has a weight $\le 0.5$, the MST coincides with the chain, and the maximum-capacity path between A and C is A–B–C with a bottleneck of $0.9$; the alternative direct edge (A–C) would have a bottleneck $\le 0.5$.

2.1.2. Quantum Kernels

A quantum kernel measures similarity by encoding classical data into quantum states and computing their overlap. Given an n-qubit encoding circuit $U\left(z\right)$ that maps input vector z to quantum state $|\psi \left(z\right)\rangle ={U\left(z\right)|0\rangle }^{\otimes n}$, the kernel function is the squared state overlap (fidelity):

$$k(z_u,z_v)={\left|\langle \psi \left(z_u\right)|\psi \left(z_v\right)\rangle \right|}^2.$$

(2)

Substituting $|\psi \left(z\right)\rangle ={U\left(z\right)|0\rangle }^{\otimes n}$ gives $\langle \psi \left(z_u\right)|\psi \left(z_v\right)\rangle ={\langle 0|}^{\otimes n}{U}^{†}\left(z_u\right)U\left(z_v\right){|0\rangle }^{\otimes n}$, so

$$k(z_u,z_v)={\left|{\langle 0|}^{\otimes n}{U}^{†}\left(z_u\right)U\left(z_v\right){|0\rangle }^{\otimes n}\right|}^2.$$

(3)

The right-hand side has a direct measurement interpretation. Preparing $U^{†}\left(z_u\right)U\left(z_v\right){|0\rangle }^{\otimes n}$ and measuring on a computational basis, the probability of the outcome (${|0\rangle }^{\otimes n}$) is ${|\langle 0|}^{\otimes n}{U}^{†}\left(z_u\right)U\left(z_v\right){|0\rangle }^{\otimes n}{|}^2$ according to the Born rule, which is exactly $k(z_u,z_v)$. This is the compute–uncompute (or fidelity) construction: encode $z_v$ forward, then apply the adjoint of the encoding for $z_u$ and read out ${|0\rangle }^{\otimes n}$. When $z_u=z_v$, the adjoint exactly undoes the forward circuit, and the kernel equals 1. The kernel implicitly operates in a $2^n$-dimensional Hilbert space [5], potentially capturing nonlinear relationships between features that classical kernels cannot efficiently represent. Whether that expressivity is informative for a particular task depends on the encoding and the data; we return to this question in Section 4.1.

2.1.3. Dimensionality Reduction for Quantum Encoding

Document embeddings (1536 dimensions from text-embedding-3-small) must be projected to lower dimensions before quantum encoding—directly encoding high-dimensional data would require intractable circuit depths. We consider two projection approaches that bracket the local-vs-global design space: random Gaussian projection, which preserves pairwise distances per the Johnson–Lindenstrauss lemma, and UMAP, which emphasizes local manifold structure. The choice of projection method determines what geometric relationships are available for the quantum kernel to measure.

Why these two and not others? PCA [19] preserves global variance but is linear, so it cannot follow the curved manifold structure that document embeddings often inhabit; Isomap [20] and Locally Linear Embedding [21] preserve manifold geometry in a spirit similar to that of UMAP and have been shown to dominated by it on high-dimensional embedding inputs in recent comparative studies [22], whereas trained autoencoders would require a downstream supervision signal that the unsupervised storyline extraction setting does not provide. Therefore, UMAP and random projection bracket the relevant design axis (local manifold preservation versus distance preservation), and the empirical contrast between them is informative without an exhaustive sweep over manifold-learning methods that behave qualitatively like UMAP.

2.2. Related Work

A full treatment of quantum machine learning is beyond the scope of this paper; we refer readers to Schuld and Petruccione [23] for theoretical foundations and to Cerezo et al. [8] for an overview of variational quantum algorithms. Here, we focus specifically on quantum kernels as similarity measures.

Quantum natural language processing has explored various approaches to leveraging quantum computation for language tasks [24,25,26,27]. The dominant line—compositional QNLP rooted in the DisCoCat formalism [28]—encodes sentence structure into tensor networks or variational circuits and targets sentence-level classification. Our setting differs in two ways: (i) the unit of computation is a pre-trained 1536-dimensional document embedding rather than a parsed sentence, and (ii) the downstream task is a graph-path optimization (maximum-capacity path through a coherence graph) rather than a per-instance classification. We are therefore not competing with DisCoCat-style models: we use quantum circuits as a similarity operator over already embedded documents, and the contribution lies in whether that similarity yields better paths through the document graph. Quantum similarity learning, more broadly [4,5,7,29,30], has examined kernel-based learning on numerical inputs, including the projected quantum-kernel construction [29] that we evaluate as one of our three quantum families. Quantum concepts have also been applied metaphorically to narrative construction, using superposition to represent character ambiguity and entanglement to model conflict dynamics [31], though this symbolic approach differs from our use of quantum kernels for computation of document similarity. To the best of our knowledge, no prior work has applied quantum kernels to coherence measurement for storyline extraction or any related graph-path task on document embeddings; our contribution is therefore methodological (the first systematic factorial study of quantum kernels in this setting) rather than a claim that quantum kernels beat classical alternatives—which, as our results show, they do not.

The Narrative Trails framework [2] builds on earlier storyline extraction methods [1,3,32,33], distinguishing itself through its maximum-capacity path formulation and efficient MST-based algorithm. Its bottleneck optimization motivates our investigation: replacing the coherence function could change which storylines the algorithm produces.

Quantum kernels have shown promise in various machine learning contexts [4,5], with incremental data uploading [29,34,35] providing a practical encoding scheme for classical data. Random projection as a dimensionality reduction technique dates to Johnson and Lindenstrauss [10,36], who proved that random linear maps approximately preserve distances. Achlioptas [11] showed that simple random matrices suffice, making the technique practical for high-dimensional data.

2.3. Narrative Trails and Bottleneck Optimization

The Narrative Trails framework [2] applies the maximum-capacity path formulation to storyline extraction. Given N documents with embeddings $e_1,\dots ,e_N$ and a coherence function ($\theta (i,j)\in [0,1]$), the algorithm seeks a path ($P=(i_1,\dots ,i_k)$) from source to target that maximizes ${min}_j\theta (i_j,i_{j+1})$. Since a single weak transition determines overall path quality, the design of the coherence function directly shapes which storylines the algorithm produces. The classical coherence function combines two components:

$$\theta (u,v)=\sqrt{S(z_u,z_v)·T({\widehat{z}}_u,{\widehat{z}}_v)}.$$

(4)

The four objects in Equation (4) are defined as follows.

• $z_u={\pi }_{\mathbf{UMAP}}\left(e_u\right)$: The embedding ($e_u\in {\mathbb{R}}^{1536}$) is mapped to a low-dimensional vector ($z_u\in {\mathbb{R}}^{48})$ by uniform manifold approximation and projection [37], which fits a fuzzy simplicial-set representation of the data manifold and minimises the cross-entropy between the high- and low-dimensional fuzzy-set representations. UMAP preserves local neighbourhood structure but may distort large-scale geometry; we use it because it is the projection used by the original Narrative Trails baseline.
• ${\widehat{z}}_u$: The soft cluster assignment of document u produced by Hierarchical Density-Based Spatial Clustering of Applications with Noise (HDBSCAN) [38]. HDBSCAN extracts a stable cluster hierarchy from a mutual-reachability-distance MST and converts it to a probability distribution over K topic clusters by aggregating membership scores along the condensed tree branches; ${\widehat{z}}_u\in {\Delta }^{K-1}$ is the resulting probability vector.
• $S(z_u,z_v)$: The rescaled cosine similarity between the UMAP-projected vectors ($S(z_u,z_v)=\frac{1}{2}\left(1+\frac{\langle z_u,z_v\rangle }{\parallel z_u\parallel \parallel z_v\parallel }\right)\in [0,1]$) so that orthogonal projections give $0.5$ rather than 0 and antipodal projections give 0.
• $T({\widehat{z}}_u,{\widehat{z}}_v)$: The topic similarity derived from the symmetric Jensen–Shannon divergence [39] between cluster-membership distributions ($T(p,q)=1-\mathrm{JSD}(p\parallel q)$, where $\mathrm{JSD}(p\parallel q)=\frac{1}{2}\mathrm{KL}(p\parallel m)+\frac{1}{2}\mathrm{KL}(q\parallel m)$ and $m=(p+q)/2$. JSD is bounded in $[0,1]$ when computed with logarithm base 2), so $T\in [0,1]$.

The geometric mean requires both spatial proximity (via S) and thematic alignment (via T) for high coherence.

As noted above, the MST property enables efficient path extraction: the dominant cost is computing all $O\left(N^2\right)$ pairwise coherences, making the approach practical for moderately sized corpora.

2.4. Quantum Kernels as Similarity Measures

Classical kernels like RBF or cosine similarity compute similarity directly from input features. Quantum kernels [5] instead encode data into quantum states and measure their overlap in the resulting $2^n$-dimensional Hilbert space, as formalized above.

In practice, this transformation is parameterised by circuit depth (controlling expressivity) and width (controlling the feature-space dimension). Whether the high-dimensional mapping captures useful structure depends on the task—not all problems benefit from the additional expressivity. We use a layered encoding architecture based on incremental data uploading [34] where input features are distributed across successive layers, with entanglement enabling cross-layer interactions.

3. Methodology

3.1. Problem Formulation

Given N documents with embeddings $e_1,\dots ,e_N\in {\mathbb{R}}^D$ ($D=1536$ from text-embedding-3-small), we seek a coherence function ($\theta :{\mathbb{R}}^D\times {\mathbb{R}}^D\to [0,1]$) such that the maximum-capacity path, i.e.,

$$P^{*}=arg\underset{P}{max}\underset{(i,j)\in P}{min}\theta (e_i,e_j),$$

(5)

produces storylines that align with human judgments of narrative coherence.

The classical Narrative Trails approach computes $\theta$ as a geometric mean of angular similarity (in UMAP-projected space) and topic similarity (from HDBSCAN clustering). We propose replacing this with a quantum kernel: $\theta (e_i,e_j)=k(\pi \left(e_i\right),\pi \left(e_j\right))$, where $\pi$ projects embeddings to lower dimensions and k computes quantum-state overlap.

To understand which quantum kernel configurations are effective for narrative coherence, we employ a factorial experimental design covering 93 method evaluations: 54 quantum kernels across three encoder families (R_Y+CNOT-ring data re-uploading, IQP/ZZ-feature-map, and the projected quantum kernel of Huang et al. [29]) and 39 classical kernels (cosine, RBF, and the cluster-aware Narrative Trails baseline) on matched projected inputs and on the raw 1536-dimensional embeddings.

3.2. Datasets and Evaluation Metrics

We evaluate on two datasets. The Wikispeedia dataset [16] contains human navigation paths through a subset of Wikipedia—records of paths that people actually traversed when asked to navigate between articles. This provides a supervised ground truth for what constitutes a reasonable inter-article sequence. The dataset contains 3928 articles with 11,215 complete human navigation paths, which we use in full for evaluation. For each method, we report five metrics from the Narrative Trails reference implementation [2], all built on Dynamic Time Warping (DTW) [40] or set overlap. DTW computes the minimum-cost monotone alignment between two sequences ($X=(x_1,\dots ,x_m)$ and $Y=(y_1,\dots ,y_n)$) by filling a cost table ($D\in {\mathbb{R}}^{m\times n}$) with $D_{ij}=c(x_i,y_j)+min(D_{i-1,j},D_{i,j-1},D_{i-1,j-1})$, where c is the per-element cost; the bottom-right cell ($D_{mn}$) is the total alignment cost, and the back-trace gives the alignment of length $\mathit{\ell }\in [max(m,n),m+n-1]$. We use $c(x_i,y_j)=1-cos({\widehat{e}}_{x_i},{\widehat{e}}_{y_j})$, where $\widehat{e}$ is the embedding in the original 1536-dim space. We report: (i) the length-normalised DTW distance (nDTW—lower is better; $D_{mn}/\mathit{\ell }$, the per-aligned-step cost), (ii) the nDTW similarity (1 minus the mean per-step cost along the alignment), (iii) the per-step DTW similarity (length-independent mean of $1-c$ over each transition in the extracted path), (iv) the Jaccard overlap between the extracted-path article set and the human-path article set, and (v) the harmonic-mean F1 of precision and recall on those same sets. As we show in Section 4, these metrics fall into two clusters that rank methods differently, so we report both.

For unsupervised evaluation, we use a corpus of 418 news articles about Cuban political events from 2020–2021 [17]. Without ground-truth paths, we rely on an LLM-as-a-judge evaluation approach for coherence [41]. Each storyline is scored on four dimensions—logical flow, thematic consistency, temporal coherence, and narrative completeness—each on a 1–10 scale. Two judges, Claude Sonnet 4.5 and GPT-4o, each score every storyline independently at a temperature of $T=0$ via structured tool/function calling that emits exactly the four integer scores; no free-form justification is generated. Therefore, each cell (method, seed, and endpoint pair) yields one score per dimension per judge. We evaluate 30 spatially distant endpoint pairs, each sampled once and reused across all method–seed–judge combinations to enable paired comparisons. For each method we use 5 random projection seeds (42, 123, 456, 789, and 1024) so that conclusions are not driven by a single projection draw. For supervised evaluation, we report the nDTW, per-step similarity, Jaccard overlap, and F1 score; for unsupervised evaluation, we report the mean overall coherence and per-dimension scores with paired Wilcoxon tests against the classical baseline.

Note that coherence scores from different methods are not directly comparable in absolute terms—each defines its own similarity space. The path extraction algorithm uses only the ranking of document pairs, so what matters is whether a method’s rankings produce paths that align with human behaviour or external quality judgements.

The prompt shown in Figure 1 is used by both judges. The same prompt is sent to each judge, with the only difference being the underlying API endpoint (Anthropic Messages API for Sonnet 4.5; OpenAI Chat Completions API for GPT-4o).

3.3. Quantum Coherence Kernels

We replace the coherence function with a quantum kernel. The classical approach computes coherence as a geometric mean of angular similarity (in UMAP space) and topic similarity (from clustering). Our quantum approach computes coherence directly from kernel similarity: given two documents, we project their embeddings to low dimensions, encode them via a quantum circuit, and measure the overlap of the resulting representations. Higher overlap indicates more similar documents, yielding higher coherence.

The bottleneck path formulation requires accurate similarity measurement for all document pairs, including subtle relationships that simple similarity measures might miss. Quantum kernels map inputs into an exponentially larger feature space through a parameterised nonlinear transformation. Whether this expressivity translates to better coherence measurement is an empirical question our experiments address.

We note that there are practical constraints that shape our approach. Document embeddings from OpenAI’s text-embedding-3-small have 1536 dimensions, but encoding high-dimensional data into quantum circuits is computationally intractable—each dimension adds circuit depth, and simulation of deep circuits scales exponentially. We therefore project embeddings to between 2 and 64 dimensions before computing kernel similarity, with the projection method becoming a key experimental variable.

We use a layered encoding circuit based on incremental data uploading [34], where input features are distributed across successive layers with entanglement between them, increasing the expressivity of the quantum feature map. For n qubits and L layers, the circuit encodes a $d=n\times L$ dimensional input vector ($z=(z_1,\dots ,z_d)$). Each layer ($\mathit{\ell }\in \{1,\dots ,L\}$) consists of the following:

• Rotation gates: Each qubit (i) receives an $R_Y$ rotation parameterised by input feature $z_j$, where $R_Y\left(\theta \right)=exp(-i\theta Y/2)$ rotates the qubit state around the Y-axis of the Bloch sphere.
• Entangling gates: CNOT gates in a ring topology connect neighbouring qubits, creating entanglement that allows the circuit to represent correlations between features.

For n qubits and an d-dimensional input, each layer encodes n distinct features from the input vector, requiring $\lceil d/n\rceil$ layers to encode all d features. The entanglement gates between layers allow the circuit to capture correlations across feature groups.

Before encoding, projected features are normalized globally (per feature dimension) to the $[0,\pi ]$ range across all documents. The $[0,\pi ]$ range is required by the quantum encoding: the projected coordinates are used directly as $R_Y$ rotation angles, and angles outside $[0,\pi ]$ alias onto identical states. The classical kernel baselines (cosine and RBF) do not need this normalization, but we apply the same projection-and-normalization pipeline to them so that the quantum-versus-classical comparison is matched on input format and isolates the effect of the kernel rather than the input scale. Global (as opposed to per-document) normalization preserves relative positions between documents in each feature dimension, ensuring the rotation angles reflect meaningful inter-document differences. The kernel is then read out via the compute–uncompute construction of Equations (2) and (3): applied to the layered encoder described above, this means a forward pass of L $R_Y$+CNOT-ring layers parameterised by $z_v$, followed by the adjoint of the same circuit parameterised by $z_u$ (reversed layer order, reversed CNOT order, and negated angles), with the all-zeros bitstring probability serving as the kernel value and, therefore, as the coherence score.

Figure 2 shows the encoding architecture at three illustrative sizes ($n=2$, $n=3$, and a generic n). The three panels illustrate how the CNOT-ring entangler closes for any n: at $n=3$, the ring wraps from $q_3$ back to $q_1$ (panel b), and the same wrap rule applies for an arbitrary n (panel c). The $n=2$ case (panel a) is drawn schematically as a single CNOT but is degenerate—the sequential sweep and the wrap-around CNOT act on the same wire pair in opposite directions, so the implementation applies the pair $(q_1\to q_2,q_2\to q_1)$ per layer; the figure abstracts these as one CNOT for visual symmetry with the $n\ge 3$ panels. For an input of dimension $d=n\times L$, each of the L layers consumes n consecutive features as $R_Y$ rotation angles, and the CNOT ring after each layer entangles them with the qubits in the next layer’s rotation block. The data re-uploading pattern—rotation block, entangler, rotation block, entangler, …—is the source of the kernel’s non-trivial dependence on the input at depth $L\ge 2$; at depth 1, in contrast, the entangler (G) appears once on each side of the compute–uncompute product, and the resulting $G^{†}G=I$ collapses the kernel into a per-feature product (this is the source of the depth-1 cancellation we make precise in Section 4.1). The figure is therefore not just a schematic: the visual symmetry between the forward $R_Y$+CNOT-ring block and its adjoint is precisely the structural feature that the cancellation theorem exploits.

What does the kernel actually measure? The compute–uncompute readout is operationally simple—the probability of the all-zeros bitstring—but its information content is not opaque. For the depth-1 R_Y+CNOT-ring family, Theorem 1 (Section 4.1) gives the closed form, i.e., $k(u,v)={\prod }_i{cos}^2((u_i-v_i)/2)$, which is a product of per-feature angle similarities. The kernel is therefore directly interpretable: it is a smooth, monotone function of the per-feature angular displacement, with the product structure encoding “all features must agree” in the same way a Gaussian RBF does. Higher-depth and non-product encodings (IQP and PQK) lift this product structure, but the depth-1 case anchors the family in classical kernel intuition rather than treating the quantum circuit as a black box.

Two Alternative Kernel Families

Beyond the data re-uploading $R_Y$+CNOT-ring kernel just described (henceforth referred to as the q_* family), we also evaluate two architecturally distinct quantum kernels chosen to break specific structural properties of that family.

IQP/ZZ-feature-map kernel (iqpML_*): A single-layer, instantaneous, quantum polynomial encoding [4] in the form of

$$U_{\mathrm{IQP}}\left(z\right)=\left(\prod _{(i,j)\in E}\mathrm{ZZ}\left(z_i{z}_j\right)\right)·\left(\underset{i}{⨂}RZ\left(z_i\right)\right)·H^{\otimes n},$$

(6)

where $\mathrm{ZZ}\left(\theta \right)=exp(-i\theta Z_i{Z}_j/2)$ couples qubits $(i,j)$ along a ring entangler pattern (E) and H is the Hadamard gate. Unlike $R_Y$+CNOT-ring, the $\mathrm{ZZ}$ rotation angles depend on the product ($z_i{z}_j$), so the compute–uncompute product ($U^{†}\left(u\right)U\left(v\right)$) contains phases in the form of $v_i{v}_j-u_i{u}_j$, which do not factor into a function of $v-u$ alone. We use the multilayer variant (iqpML_random_8q_2L_16d), which stacks two such encodings to enable data re-uploading of $d=16$ features into $n=8$ qubits.

Projected quantum kernel (pqk_*): Following Huang et al. [29], we reuse the same $R_Y$+CNOT-ring data re-uploading circuit described above and replace the compute–uncompute fidelity readout with a classical kernel on local Pauli expectations. For each input (z), we compute

$$r\left(z\right)={\left({\langle X_i\rangle }_{\psi \left(z\right)},{\langle Y_i\rangle }_{\psi \left(z\right)},{\langle Z_i\rangle }_{\psi \left(z\right)}\right)}_{i=1}^n\in {\mathbb{R}}^{3n},$$

(7)

i.e., the $3n$-dim vector of single-qubit Pauli expectation values in the encoded state ($\left|\psi \right(z)\rangle$). The projected quantum kernel is then the classical RBF kernel on the basis of these expectations:

$$k_{\mathrm{PQK}}(u,v)=exp\left({-\gamma \parallel r\left(u\right)-r\left(v\right)\parallel }^2\right).$$

(8)

The motivation in [29] is that PQK retains some quantum non-classicality (the encoded state ($\left|\psi \right(z)\rangle$) is genuinely quantum) while avoiding the exponential concentration that plagues fidelity kernels at depth.

Figure 3 illustrates the IQP encoding at $n=4$ qubits with a single layer: a Hadamard column rotates the qubits onto the X eigenstates, single-qubit $RZ\left(z_i\right)$ rotations imprint each input feature, and a ring of $\mathrm{ZZ}\left(z_i{z}_j\right)$ entanglers couples adjacent qubits using products of features. The product structure of the entangler angles is exactly the property that lets IQP escape the depth-1 cancellation theorem (Proposition 3).

Figure 4 illustrates the projected quantum kernel: the encoding is the same R_Y+CNOT-ring data re-uploading circuit as in Figure 2, but the compute–uncompute readout is replaced with a per-qubit local Pauli measurement of the encoded state ($\left|\psi \right(z)\rangle$). The resulting $3n$-dim vector ($r\left(z\right)$) is fed into a classical RBF kernel; this side-steps the depth-induced concentration of fidelity readouts (Remark 1) at the cost of computing a classical kernel on top of a quantum representation.

3.4. Projection Methods

We compare two approaches to dimensionality reduction before quantum encoding.

UMAP [37] projection matches the classical baseline, emphasizing local manifold structure. This isolates the quantum kernel’s contribution but applies nonlinear transformations that may reshape similarity structure.

Random Gaussian projection constructs a matrix ($R\in {\mathbb{R}}^{k\times 1536}$) with entries from $\mathcal{N}(0,1/k)$. The Johnson–Lindenstrauss lemma [10,36] guarantees that projecting to $k=O(logN/{ϵ}^2)$ dimensions preserves pairwise distances within $(1\pm ϵ)$. Unlike UMAP, random projection involves no learning—the projected coordinates derive entirely from the original embedding geometry [42].

3.5. Factorial Experimental Design

To systematically investigate how projection type, qubit count, and circuit depth affect quantum kernel performance, we employ a full factorial design on the supervised Wikispeedia benchmark. We test the following:

• Projection types: UMAP and random Gaussian projection;
• Qubit counts: 2, 4, and 8 qubits;
• Layer counts: 1, 2, 4, 6, and 8 encoding layers.

The projection dimensionality is determined by qubits × layers, yielding feature dimensions ranging from 2 to 64. This gives 30 R_Y+CNOT-ring quantum configurations (2 projections × 3 qubit counts × 5 layer counts).

To isolate the contribution of the quantum kernel from input-format effects, we evaluate the same coherence-graph pipeline with classical kernels on identical projected inputs and with two architecturally distinct quantum kernel families. The classical kernel baselines are cosine and RBF applied to Gaussian random projections innine target dimensions (2, 4, 8, 12, 16, 24, 32, 48, and 64) and to UMAP projections inthe same nine dimensions, plus cosine and RBF computed directly on the raw 1536-dim text-embedding-3-small representation. We label the projected variants as cos_random_dd, rbf_random_dd, cos_umap_dd, and rbf_umap_dd; all consume the same projected and $[0,\pi ]$-normalised input as the quantum kernels, with no qubits in the kernel itself. The raw-embedding variants (cos_raw_1536d and rbf_raw_1536d) sit at the other end of the projection axis: because text-embedding-3-small is, itself, a pre-trained transformer encoder, cosine on its raw output is the natural transformer-based “neural similarity” baseline. The two alternative quantum kernel families (IQP/ZZ-feature-map and the projected quantum kernel of Huang et al. [29]) probe whether the empirical findings extend beyond R_Y+CNOT-ring to encoders that escape the depth-1 cancellation theorem proven in Section 4.1. They are evaluated on a subset of the qubit-and-depth grid used for R_Y+CNOT-ring (14 IQP and 10 PQK variants spanning 4 and 8 qubits at 1, 2, 4, and 8 layers; the omitted depths are listed in Section S1 of the Supplementary Material). Together with the cluster-aware classical baseline (classical_NT), the totals are: 1 classical_NT + 30 R_Y+CNOT + 14 IQP + 10 PQK + 36 cosine/RBF on projected inputs + 2 cosine/RBF on raw embeddings = 93 methods.

For the unsupervised LLM evaluation, the same 30 endpoint pairs are scored across a 12-method subset chosen by aggregate rank on the supervised metrics: the classical baseline, the headline UMAP-projected quantum kernel (q_umap_4q_4d), three random-projection quantum kernels (q_random_4q_8d, q_random_8q_16d, and a multi-layer IQP variant iqpML_random_8q_2L_16d), one projected quantum kernel (pqk_random_8q_8L_64d) [29], and three target dimensions each of the cosine and RBF classical kernel baselines on random projection. This subset gives 12 methods × 5 seeds × 30 pairs × 2 judges = 3600 LLM calls, of which 1800 distinct storylines are scored once per judge.

3.6. Classical Baseline and Path Extraction

The classical baseline uses the original Narrative Trails coherence function: a geometric mean of angular similarity in 48-dimensional UMAP space [37] and topic similarity from HDBSCAN [38] soft clustering. All quantum configurations eliminate the clustering component entirely, computing coherence directly from quantum-state overlap. Path extraction follows the original algorithm: compute all pairwise coherences, build the maximum spanning tree, and extract paths between specified endpoints.

3.7. Computational Complexity

The pipeline has complexity:

• Projection: $O(N·D·d)$ for random projection [11]; approximately $O(N·D·logN)$ for UMAP [37] with approximate nearest neighbours [43];
• Kernel matrix computation: $O(N^2·C(d,L))$, where $C(d,L)$ is the circuit simulation cost;
• MST construction: $O(N^{2}logN)$ via Kruskal’s algorithm [18];
• Path queries: $O\left(N\right)$ per query.

For classical simulation, $C(d,L)$ scales exponentially in qubit count but is tractable for $n\le 8$ qubits. All quantum circuits were implemented using PennyLane [44]. We note that these complexities reflect the general algorithm; specific implementations may achieve better performance through sparse graph structures, caching, or parallelization. Bottleneck value queries (finding the minimum edge weight on a path) could be reduced to $O(logN)$ via lowest-common-ancestor preprocessing [45]; however, extracting the full path sequence remains $O\left(\mathrm{path}\mathrm{length}\right)$, and such optimizations are orthogonal to our methodological contributions.

4. Results

4.1. Theoretical Characterisation of the Quantum Kernel Family

Before reporting empirical performance, we characterise, in closed form, what the compute–uncompute fidelity kernel actually computes for the encoding family we evaluate. The result narrows the space of plausible quantum advantages for this kernel class and motivates the alternative encodings (IQP and PQK) we add in the empirical study.

Theorem 1

(Depth-1 Cancellation of CNOT-Ring Entanglers). Let $U\left(z\right)=G·{⨂}_{i=1}^n{R}_Y\left(z_i\right)$ be a depth-1 encoding with rotations of $R_Y\left(\theta \right)=exp(-i\theta Y/2)$ on each qubit, followed by an arbitrary data-independent unitary G (e.g., a CNOT ring). The compute–uncompute fidelity kernel is

$$k(u,v)={\left|{\langle 0|}^{\otimes n}{U}^{†}\left(u\right)U\left(v\right){|0\rangle }^{\otimes n}\right|}^2={\displaystyle \prod _{i=1}^n}{cos}^2\left(\frac{u_i-v_i}{2}\right).$$

(9)

Proof. 

Let $R\left(z\right)={⨂}_i{R}_Y\left(z_i\right)$. Then,

$$U^{†}\left(u\right)U\left(v\right)=R^{†}\left(u\right)G^{†}GR\left(v\right)=R^{†}\left(u\right)R\left(v\right),$$

since $G^{†}G=I$. The single-qubit rotations ($R_Y(·)$) on distinct qubits act on disjoint tensor factors and therefore commute, and ${\left\{R_Y\left(\theta \right)\right\}}_{\theta \in \mathbb{R}}$ is a one-parameter group, so $R_Y{\left(u_i\right)}^{†}{R}_Y\left(v_i\right)=R_Y(v_i-u_i)$ for each i. Hence,

$$R^{†}\left(u\right)R\left(v\right)={\displaystyle \underset{i=1}{\overset{n}{⨂}}}{R}_Y(v_i-u_i).$$

Using the identity expressed as $\langle 0\left|R_Y\left(\theta \right)\right|0\rangle =cos(\theta /2)$, which follows from $R_Y\left(\theta \right)=cos(\theta /2)I-isin(\theta /2)Y$ and $\langle 0\left|Y\right|0\rangle =0$, the all-zeros amplitude factors over qubits:

$${\langle 0|}^{\otimes n}{U}^{†}{\left(u\right)U\left(v\right)|0\rangle }^{\otimes n}={\displaystyle \prod _{i=1}^n}\langle 0|R_Y(v_i-u_i)|0\rangle ={\displaystyle \prod _{i=1}^n}cos\left(\frac{v_i-u_i}{2}\right).$$

Squaring the modulus yields Equation (9). □

Two consequences follow.

Corollary 1

(Depth-1 R_Y+CNOT-Ring Kernel Is a Classical Product Kernel). Equation (9) factors over qubits and depends only on per-feature differences ($u_i-v_i$). Furthermore, in the small-angle regime ($|u_i-v_i|\ll 1$),

$$k(u,v)=exp\left(-\frac{1}{4}{\parallel u-v\parallel }_2^2\right)+O\left({\parallel u-v\parallel }_4^4\right),$$

(10)

i.e., the kernel agrees to the fourth order with an isotropic Gaussian RBF of bandwidth $\gamma =1/4$.

Proof. 

The factorisation and dependence on differences immediately follow from Equation (9). For the small-angle expansion, the half-angle identity (${cos}^2(x/2)=(1+cosx)/2$), together with the Taylor series of cos, gives

$${cos}^2\left(\frac{x}{2}\right)=1-\frac{x^2}{4}+O\left(x^4\right).$$

Applying $log(1-t)=-t+O\left(t^2\right)$ to each factor of Equation (9),

$$logk(u,v)={\displaystyle \sum _{i=1}^n}log\left(1-\frac{{(u_i-v_i)}^2}{4}+O\left({(u_i-v_i)}^4\right)\right)=-\frac{1}{4}{\parallel u-v\parallel }_2^2+O\left({\parallel u-v\parallel }_4^4\right),$$

where ${\parallel ·\parallel }_p$ denotes the ${\mathit{\ell }}_p$ norm. Exponentiating yields Equation (10). □

On our projected Wikispeedia data, the Spearman correlation between ${\prod }_i{cos}^2((u_i-v_i)/2)$ and the corresponding RBF kernel is $0.9999$, so the two kernels induce essentially identical MST rankings.

Proposition 1

(Mercer Expansion and Effective RKHS). The depth-1 kernel of Theorem 1 admits the explicit feature map:

$$\varphi \left(z\right)={\displaystyle \underset{i=1}{\overset{n}{⨂}}}\frac{1}{\sqrt{2}}\left(1,cos{z}_i,sin{z}_i\right)\in {\mathbb{R}}^{3^n},k(u,v)=\langle \varphi \left(u\right),\varphi \left(v\right)\rangle .$$

(11)

Therefore, the Hilbert space of the reproducing kernel has a dimension of $3^n$—larger than the $2^n$ Hilbert space of the circuit—but it contains only products of single-feature kernels, with no cross-feature interactions.

Proof. 

For each qubit (i), set ${\varphi }_i\left(z_i\right)=\frac{1}{\sqrt{2}}(1,cos{z}_i,sin{z}_i)\in {\mathbb{R}}^3$. Then,

$$\langle {\varphi }_i\left(u_i\right),{\varphi }_i\left(v_i\right)\rangle =\frac{1}{2}\left(1+cos{u}_{i}cos{v}_i+sin{u}_{i}sin{v}_i\right)=\frac{1}{2}\left(1+cos(u_i-v_i)\right)={cos}^2\left(\frac{u_i-v_i}{2}\right),$$

where the second equality uses the angle-difference identity for cosine and the third uses the half-angle identity, i.e., ${cos}^2(x/2)=(1+cosx)/2$. Inner products of tensor products factor over the factors:

$$\langle \varphi \left(u\right),\varphi \left(v\right)\rangle =〈\underset{i}{⨂}{\varphi }_i\left(u_i\right),\underset{i}{⨂}{\varphi }_i\left(v_i\right)〉={\displaystyle \prod _{i=1}^n}\langle {\varphi }_i\left(u_i\right),{\varphi }_i\left(v_i\right)\rangle ={\displaystyle \prod _{i=1}^n}{cos}^2\left(\frac{u_i-v_i}{2}\right)=k(u,v),$$

using Theorem 1 for the last equality. Each ${\varphi }_i\left(z_i\right)$ lies in ${\mathbb{R}}^3$, so $\varphi \left(z\right)\in {\mathbb{R}}^{3^n}$. The feature map is a tensor product of single-feature factors and therefore contains no cross-feature interaction terms. □

These results explain why R_Y+CNOT-ring kernels at depth 1 cannot outperform an appropriately tuned classical RBF kernel in principle and why the empirical pool-vs-pool comparison yields competitive parity rather than separation (see Section 4.2). Two routes break this collapse:

Proposition 2

(Depth ≥ 2 Retains an Inner Entangler). Let $U\left(z\right)=G·R_2\left(z_2\right)·G·R_1\left(z_1\right)$ with $R_{\mathit{\ell }}\left(x\right)={⨂}_i{R}_Y\left(x_{\mathit{\ell },i}\right)$ and G a data-independent unitary. Then,

$$U^{†}\left(u\right)U\left(v\right)=R_1^{†}\left(u_1\right)G^{†}\underset{i}{⨂}{R}_Y(v_{2,i}-u_{2,i})G{R}_1\left(v_1\right).$$

(12)

If G is not a tensor product of single-qubit unitaries, the resulting kernel ($k_2$) does not factor over qubits and is not a function of $v-u$ alone.

Proof. 

The middle $G^{†}G=I$ cancellation gives $U^{†}\left(u\right)U\left(v\right)=R_1^{†}\left(u_1\right)G^{†}{R}_2^{†}\left(u_2\right)R_2\left(v_2\right)G{R}_1\left(v_1\right)$, and the one-parameter-group argument from the proof of Theorem 1 applied to the middle factor yields $R_2^{†}\left(u_2\right)R_2\left(v_2\right)={⨂}_i{R}_Y(v_{2,i}-u_{2,i})$, establishing Equation (12).

For the second claim, take $n=2$ and $G={\mathrm{CNOT}}_{12}$. A direct computation gives

$${\mathrm{CNOT}}_{12}(I\otimes R_Y\left(\alpha \right)){\mathrm{CNOT}}_{12}=exp\left(-i\alpha Z_1{Y}_2/2\right),$$

which is not a tensor product of single-qubit operators for $\alpha \notin \pi \mathbb{Z}$. Hence, the inner conjugation ($G^{†}{⨂}_i{R}_Y(v_{2,i}-u_{2,i})G$) in Equation (12) introduces a coupling between qubit 1 and qubit 2 that is absent at depth 1, so $k_2$ does not factor over qubits.

Furthermore, $R_1\left(v_1\right)$ and $R_1^{†}\left(u_1\right)$ are separated in Equation (12) by the (in general, non-trivial) operator ($G^{†}{⨂}_i{R}_Y(v_{2,i}-u_{2,i})G$), so they cannot be combined into a single $R_1(v_1-u_1)$ via the one-parameter group identity. Concretely, fix $u_2=v_2$ (so the middle operator reduces to $G^{†}G=I$); then, $k_2$ collapses to the depth-1 kernel and depends on $v_1-u_1$ alone. Now, perturb $u_2\ne v_2$: the middle operator becomes $\ne I$, and varying $u_1$ at a fixed $v_1-u_1$ generally changes the inner product (${\langle 0|}^{\otimes n}{R}_1^{†}\left(u_1\right)[\cdots ]R_1\left(v_1\right){|0\rangle }^{\otimes n}$). Hence, $k_2$ is not a function of $v-u$ alone. □

The additional expressivity does not, however, translate into better MST rankings on our data because a depth $\ge 2$ also concentrates kernel values around a fixed mean (Remark 1).

Proposition 3

(IQP Encoding Escapes the Cancellation). For the IQP encoding ($U\left(z\right)={\prod }_{(i,j)}\mathrm{ZZ}\left(z_i{z}_j\right)·{⨂}_{i}RZ\left(z_i\right)·H^{\otimes n}$) from Equation (6),

$$U^{†}\left(u\right)U\left(v\right)=H^{\otimes n}·\underset{i}{⨂}RZ(v_i-u_i)·\prod _{(i,j)}\mathrm{ZZ}(v_i{v}_j-u_i{u}_j)·H^{\otimes n}.$$

(13)

The kernel ($k_{\mathrm{IQP}}(u,v)={|\langle 0|}^{\otimes n}{U}^{†}{\left(u\right)U\left(v\right)|0\rangle }^{\otimes n}{|}^2$) does not factor over qubits and is not a function of $v-u$ alone.

Proof. 

Using $H^{†}=H$, $R{Z}^{†}\left(\alpha \right)=RZ(-\alpha )$, and ${\mathrm{ZZ}}^{†}\left(\alpha \right)=\mathrm{ZZ}(-\alpha )$,

$$U^{†}\left(z\right)=H^{\otimes n}·\underset{i}{⨂}RZ(-z_i)·\prod _{(i,j)}\mathrm{ZZ}(-z_i{z}_j),$$

so that

$$U^{†}\left(u\right)U\left(v\right)=H^{\otimes n}·\underset{i}{⨂}RZ(-u_i)·\prod _{(i,j)}\mathrm{ZZ}(-u_i{u}_j)·\prod _{(i,j)}\mathrm{ZZ}\left(v_i{v}_j\right)·\underset{i}{⨂}RZ\left(v_i\right)·H^{\otimes n}.$$

All $RZ$ and $\mathrm{ZZ}$ gates are diagonal in the computational basis and therefore commute pairwise. Combining same-axis rotations using $RZ\left(\alpha \right)RZ\left(\beta \right)=RZ(\alpha +\beta )$ and $\mathrm{ZZ}\left(\alpha \right)\mathrm{ZZ}\left(\beta \right)=\mathrm{ZZ}(\alpha +\beta )$ yields Equation (13).

For the second claim, take $n=2$ and consider two pairs of inputs with the same difference but different products: $(u,v)=\left(\right(0,0),(1,1\left)\right)$ and $(u^{\prime },v^{\prime })=((1,0),(2,1))$. Both satisfy $v-u=v^{\prime }-u^{\prime }=(1,1)$, but $v_0{v}_1-u_0{u}_1=1\ne 2=v_0^{\prime }{v}_1^{\prime }-u_0^{\prime }{u}_1^{\prime }$. Direct evaluation of Equation (13) on these inputs yields $k_{\mathrm{IQP}}(u,v)\approx 0.469$ and $k_{\mathrm{IQP}}(u^{\prime },v^{\prime })\approx 0.211$, so $k_{\mathrm{IQP}}$ is not a function of $v-u$ alone and, a fortiori, does not factor over qubits as a single-feature product. □

Remark 1

(Empirical Concentration with Depth). On 1000 cached Wikispeedia document pairs at $n=8$ qubits, the standard deviation of compute–uncompute kernel values across the pair sample collapses with depth:

Layers L	1	2	4	6	8
Std of k	$0.175$	$0.131$	$0.065$	$0.029$	$0.015$

This is consistent with the exponential concentration result of Thanasilp et al. [30]: deep encoders push kernel values toward a fixed mean, eroding the inter-pair distinguishability that the MST construction relies on. Our deepest configuration (8q $\times$ 8 L) has a kernel-value std of $0.015$, so most pairs are nearly indistinguishable to the path-extraction step, which explains its empirical underperformance.

Together, Theorem 1, Proposition 1, Proposition 3, and Remark 1 characterise the design space we explore: the natural data re-uploading kernel collapses to a classical product kernel at depth 1; deeper layers escape that collapse but concentrate empirically; non-tensor-product encodings (IQP and PQK) escape both but—as the experiments show—do not produce a decisive empirical advantage for storyline extraction in our setting.

4.2. Supervised Evaluation: Wikispeedia

On 11,215 human navigation paths from Wikispeedia, the standard evaluation metrics partition into two clusters that rank methods in opposite ways. Alignment-based metrics—length-normalised DTW (nDTW), nDTW similarity, and per-step DTW similarity—reward methods that produce long, alignment-rich extractions; set-overlap metrics—Jaccard and F1—reward methods that produce shorter extractions with more verbatim overlap with the human article set. Across the methods we evaluate, the two clusters’ top entries are different.

Table 1. Wikispeedia alignment-cluster metrics on 11,215 human paths (mean ± std across 5 random projection seeds). Length-normalised DTW (nDTW, lower is better) divides the raw DTW distance by alignment length; nDTW similarity is the mean cosine similarity along the alignment; per-step DTW similarity is the average over each transition (length-independent). Methods grouped by family. ↓ means lower is better, ↑ means higher is better, bold represents the best value in each column.

Method	nDTW ↓	nDTW Sim. ↑	DTW Sim./Step ↑
classical_NT	$1.452\pm 0.018$	$0.539\pm 0.016$	$0.227\pm 0.002$
q_umap_4q_4d	$\mathbf{1}.\mathbf{339}\pm \mathbf{0}.\mathbf{031}$	$\mathbf{0}.\mathbf{634}\pm \mathbf{0}.\mathbf{013}$	$0.239\pm 0.003$
cos_umap_12d	$1.352\pm 0.009$	$0.624\pm 0.013$	$0.236\pm 0.004$
q_random_4q_8d	$1.726\pm 0.059$	$0.442\pm 0.014$	$0.232\pm 0.003$
q_random_8q_16d	$1.726\pm 0.061$	$0.438\pm 0.027$	$0.234\pm 0.005$
iqpML_random_8q_2L_16d	$1.722\pm 0.057$	$0.437\pm 0.022$	$0.231\pm 0.004$
pqk_random_8q_8L_64d	$1.735\pm 0.062$	$0.422\pm 0.026$	$0.229\pm 0.004$
cos_random_64d	$1.645\pm 0.055$	$0.473\pm 0.041$	$0.245\pm 0.004$
rbf_random_64d	$1.659\pm 0.063$	$0.486\pm 0.010$	$\mathbf{0}.\mathbf{244}\pm \mathbf{0}.\mathbf{005}$
cos_raw_1536d†	$1.602$	$0.556$	$0.260$

^† Cosine on the raw 1536-dim text-embedding-3-small representation; this is the natural transformer-similarity baseline. RBF on the raw embedding gives the same MST and identical metrics. Deterministic: no projection seed; hence, no ± std.

reports the alignment cluster. The two best methods are q_umap_4q_4d (nDTW $1.339\pm 0.031$ across five seeds) and the cos_umap_12d classical baseline on UMAP projection (nDTW $1.352\pm 0.009$); the cluster-aware classical baseline classical_NT sits at an nDTW of $1.452\pm 0.018$. Random projection methods—both quantum and classical—occupy the bottom of this cluster (nDTW $\ge 1.65$).

Table 2. Wikispeedia overlap-cluster metrics (mean ± std across 5 random projection seeds). Jaccard is the set overlap between the extracted path and the human path; F1 is the harmonic mean of precision and recall on those same sets. ↑ means higher is better, bold represents the best value in each column.

Method	Jaccard ↑	F1 ↑
classical_NT	$0.116\pm 0.005$	$0.203\pm 0.008$
q_umap_4q_4d	$0.096\pm 0.004$	$0.172\pm 0.006$
cos_umap_12d	$0.098\pm 0.007$	$0.174\pm 0.011$
q_random_4q_8d	$0.138\pm 0.008$	$0.238\pm 0.011$
q_random_8q_16d	$0.143\pm 0.011$	$0.246\pm 0.016$
iqpML_random_8q_2L_16d	$0.143\pm 0.008$	$0.245\pm 0.012$
pqk_random_8q_8L_64d	$\mathbf{0}.\mathbf{147}\pm \mathbf{0}.\mathbf{013}$	$\mathbf{0}.\mathbf{251}\pm \mathbf{0}.\mathbf{019}$
cos_random_12d	$\mathbf{0}.\mathbf{147}\pm \mathbf{0}.\mathbf{009}$	$\mathbf{0}.\mathbf{252}\pm \mathbf{0}.\mathbf{013}$
rbf_random_16d	$0.143\pm 0.011$	$0.246\pm 0.017$
cos_raw_1536d†	$0.104$	$0.184$

^† Cosine on the raw 1536-dim text-embedding-3-small representation. The transformer-similarity baseline lands in the alignment cluster, between UMAP and random-projection methods on nDTW (1.60), but is at the bottom of the overlap cluster (Jaccard, 0.10; F1, 0.18). The mechanism mirrors classical_NT: high-fidelity coherence on raw embeddings produces longer extracted paths that align well but cover few of the human-path articles.

reports the overlap cluster. The ordering is essentially reversed: random projection methods (both quantum and classical) achieve the highest Jaccard overlap and F1 score, while classical_NT and q_umap_4q_4d sit at the bottom. The mechanism is visible in the extracted path lengths (Section 4.2): the cluster-aware classical_NT extracts paths of about 20 articles, and UMAP-projected methods extract paths of 25–30 articles, both aligning well with the 8.5-article human path under nDTW but covering few of its specific articles; random projection methods extract paths of ∼14 articles, with more verbatim overlap but worse alignment.

Figure 5 shows the per-method ranking under each cluster for the 12 LLM-evaluated methods (one representative per family from each of the alignment-cluster and overlap-cluster ends), making the disagreement between the two clusters visible at body-figure scale. The complete ranking across all 93 methods is reported in Figure S6 of the Supplementary Material, which confirms that the cluster split is a property of the entire sweep and not an artefact of the 12-method selection.

4.3. Unsupervised Evaluation: Cuban News

Table 3. Cuban news LLM-as-a-judge coherence scores (1–10 scale, mean overall coherence over four dimensions). Each cell aggregates over 5 random projection seeds and 30 endpoint pairs ($n=150$). The 95% confidence intervals are 5000-resample percentile bootstrapped. Methods sorted by Sonnet 4.5 mean.

Method	Sonnet 4.5 (95% CI)	GPT-4o (95% CI)
classical_NT	$\mathbf{6}.\mathbf{94}$ [6.82, 7.04]	$\mathbf{7}.\mathbf{39}$ [7.27, 7.52]
q_umap_4q_4d	$6.88$ [6.79, 6.97]	$7.39$ [7.27, 7.50]
cos_random_32d	$6.87$ [6.76, 6.98]	$7.27$ [7.12, 7.41]
cos_random_12d	$6.86$ [6.75, 6.96]	$7.26$ [7.12, 7.39]
rbf_random_32d	$6.83$ [6.71, 6.96]	$7.25$ [7.12, 7.38]
q_random_4q_8d	$6.83$ [6.72, 6.94]	$7.26$ [7.13, 7.39]
rbf_random_64d	$6.80$ [6.68, 6.91]	$7.26$ [7.12, 7.39]
cos_random_64d	$6.79$ [6.68, 6.90]	$7.28$ [7.15, 7.41]
q_random_8q_16d	$6.79$ [6.69, 6.88]	$7.21$ [7.08, 7.34]
rbf_random_16d	$6.78$ [6.68, 6.88]	$7.22$ [7.09, 7.35]
iqpML_random_8q_2L_16d	$6.76$ [6.66, 6.85]	$7.19$ [7.06, 7.32]
pqk_random_8q_8L_64d	$6.72$ [6.61, 6.82]	$7.12$ [6.98, 7.26]

reports mean overall coherence per method per judge across the full $5\times 30=150$ (seed, endpoint pair) units, with 95% bootstrap confidence intervals. Both judges place classical_NT first; the next four methods (q_umap_4q_4d, the cos_random family, the rbf_random family, and q_random_4q_8d) have heavily overlapping intervals and are statistically indistinguishable from each other under both judges.

GPT-4o scores are systematically higher than Sonnet 4.5 scores by ∼0.4–0.5 points, on average, but the two judges agree on the method ranking: across the 12 methods, Spearman $\rho =0.860$ and Kendall $\tau =0.727$. At the cell level (1800 distinct (method, seed, pair) triples), inter-judge agreement is moderate (Spearman $\rho =0.581$ on overall coherence, and ICC(2,1) absolute agreement $=0.494$); the largest disagreements are on temporal coherence, where GPT-4o is systematically more lenient (mean $7.90$ vs. $7.10$, $\rho =0.415$).

Figure 6 shows family-level mean overall coherence with bootstrap confidence intervals alongside the per-dimension pool comparison; Figure 7 shows the per-method ranking under each judge.

4.4. Statistical Analysis

We analyse the LLM coherence data with two paired Wilcoxon comparisons motivated by what an honest reading of the kernel families demands. First, we ask whether genuinely quantum kernels (5 methods: 3 R_Y+CNOT-ring data-reuploading kernels, 1 multi-layer IQP, and 1 projected quantum kernel) outperform the full set of classical kernel methods in the LLM-evaluated subset (7 methods: classical_NT, plus 3 cosine and 3 RBF kernels on the random Gaussian projection). Six of these seven classical methods are matched on input with the quantum pool (same random projection), and classical_NT is the original cluster-aware baseline included for completeness; including it strengthens the classical pool and therefore makes the quantum pool’s null result more conservative. Second, we ask whether the five quantum kernels outperform the original cluster-aware Narrative Trails baseline (classical_NT, which combines UMAP-projected angular similarity with HDBSCAN-derived topic similarity) on its own; this is the comparison the original manuscript made. We use the within-(seed, pair) mean over each pool as the aggregated value, paired across $n=5\times 30=150$ units, with Holm–Bonferroni correction across the four dimensions and two judges of each comparison. Each Wilcoxon test runs within a single judge—scores are never pooled across judges—so the moderate cell-level inter-judge agreement (ICC(2,1) = $0.494$, Section 4.3) does not enter the test as a noise term. Cross-judge consistency is then a separate qualitative robustness check: the same comparisons are reported under each judge in Table 4 and Table 5, and the conclusions agree in sign and significance pattern across the two.

Quantum kernel pool vs. classical kernel pool (matched projection input): no significant difference on any of the four dimensions under either judge after Holm correction (Table 4). The largest raw p is $0.83$ (GPT-4o, temporal coherence), and the smallest is $0.02$ (Sonnet 4.5, thematic consistency), with neither surviving correction. Effect sizes range from $-0.11\%$ to $-1.01\%$.

Table 4. Per-dimension paired Wilcoxon comparison of mean over 5 quantum kernel methods vs. mean over 7 classical kernel methods (classical_NT plus the 6 cosine/RBF kernels on random projection), $n=150$ (seed, pair) units. Holm–Bonferroni correction across 4 dimensions × 2 judges. No significant differences after correction.

Judge	Dimension	Classical Pool	Quantum Pool	$\mathbf{\Delta }$%	p Holm
Sonnet 4.5	Logical Flow	6.77	6.74	$-0.51$	$0.65$
Sonnet 4.5	Thematic Consistency	7.71	7.63	$-1.01$	$0.19$
Sonnet 4.5	Temporal Coherence	7.11	7.09	$-0.33$	$0.60$
Sonnet 4.5	Narrative Completeness	5.76	5.71	$-0.83$	$0.65$
GPT-4o	Logical Flow	6.86	6.80	$-0.79$	$0.65$
GPT-4o	Thematic Consistency	7.86	7.79	$-0.88$	$0.65$
GPT-4o	Temporal Coherence	7.90	7.89	$-0.11$	$0.83$
GPT-4o	Narrative Completeness	6.49	6.44	$-0.74$	$0.65$

Table 4. Per-dimension paired Wilcoxon comparison of mean over 5 quantum kernel methods vs. mean over 7 classical kernel methods (classical_NT plus the 6 cosine/RBF kernels on random projection), $n=150$ (seed, pair) units. Holm–Bonferroni correction across 4 dimensions × 2 judges. No significant differences after correction.

Judge	Dimension	Classical Pool	Quantum Pool	$\mathbf{\Delta }$%	p Holm
Sonnet 4.5	Logical Flow	6.77	6.74	$-0.51$	$0.65$
Sonnet 4.5	Thematic Consistency	7.71	7.63	$-1.01$	$0.19$
Sonnet 4.5	Temporal Coherence	7.11	7.09	$-0.33$	$0.60$
Sonnet 4.5	Narrative Completeness	5.76	5.71	$-0.83$	$0.65$
GPT-4o	Logical Flow	6.86	6.80	$-0.79$	$0.65$
GPT-4o	Thematic Consistency	7.86	7.79	$-0.88$	$0.65$
GPT-4o	Temporal Coherence	7.90	7.89	$-0.11$	$0.83$
GPT-4o	Narrative Completeness	6.49	6.44	$-0.74$	$0.65$

Quantum kernel pool vs. classical narrative trails alone: Significant differences are obvered in favour of classical_NT on six of the eight cells after Holm correction (Table 5). The two non-significant cells are temporal coherence under each judge—the dimension most directly enforced by the date-constrained pathfinder, which is shared across all methods. Mean differences are 1.1–3.3% per dimension and consistent in sign across the two judges. The original manuscript’s claim that quantum methods significantly outperform classical on three of four dimensions reflected single-seed, single-judge variance: under multi-seed, dual-judge replication with the genuinely quantum subset, the cluster-aware classical baseline modestly but consistently outperforms.

Table 5. Per-dimension paired Wilcoxon comparison of mean over 5 quantum kernel methods vs. classical_NT alone, $n=150$ (seed, pair) units. Holm–Bonferroni correction across 4 dimensions × 2 judges. * $p<0.05$ after correction.

Judge	Dimension	Classical_NT	Quantum Pool	$\mathbf{\Delta }$%	p Holm
Sonnet 4.5	Logical Flow	6.89	6.74	$-2.13$	0.002 *
Sonnet 4.5	Thematic Consistency	7.80	7.63	$-2.12$	<0.001 *
Sonnet 4.5	Temporal Coherence	7.17	7.09	$-1.13$	$0.09$
Sonnet 4.5	Narrative Completeness	5.91	5.71	$-3.34$	<0.001 *
GPT-4o	Logical Flow	6.96	6.80	$-2.24$	0.01 *
GPT-4o	Thematic Consistency	7.96	7.79	$-2.18$	0.007 *
GPT-4o	Temporal Coherence	8.00	7.89	$-1.37$	0.06
GPT-4o	Narrative Completeness	6.64	6.44	$-2.99$	0.007 *

Table 5. Per-dimension paired Wilcoxon comparison of mean over 5 quantum kernel methods vs. classical_NT alone, $n=150$ (seed, pair) units. Holm–Bonferroni correction across 4 dimensions × 2 judges. * $p<0.05$ after correction.

Judge	Dimension	Classical_NT	Quantum Pool	$\mathbf{\Delta }$%	p Holm
Sonnet 4.5	Logical Flow	6.89	6.74	$-2.13$	0.002 *
Sonnet 4.5	Thematic Consistency	7.80	7.63	$-2.12$	<0.001 *
Sonnet 4.5	Temporal Coherence	7.17	7.09	$-1.13$	$0.09$
Sonnet 4.5	Narrative Completeness	5.91	5.71	$-3.34$	<0.001 *
GPT-4o	Logical Flow	6.96	6.80	$-2.24$	0.01 *
GPT-4o	Thematic Consistency	7.96	7.79	$-2.18$	0.007 *
GPT-4o	Temporal Coherence	8.00	7.89	$-1.37$	0.06
GPT-4o	Narrative Completeness	6.64	6.44	$-2.99$	0.007 *

Cross-task agreement. The 12 LLM-evaluated methods also have five-seed Wikispeedia metrics. Spearman correlation between the Cuba LLM coherence rank (mean over both judges) and each Wikispeedia metric rank (

Table 6. Spearman rank correlation between Cuba LLM coherence (mean over Sonnet 4.5 and GPT-4o) and each Wikispeedia metric, computed for the 12 methods evaluated under both protocols.

Wikispeedia Metric	Spearman $\mathit{\rho }$	p-Value
nDTW (lower is better)	$+0.70$	$0.012$
nDTW similarity	$+0.66$	$0.020$
Jaccard	$-0.62$	$0.033$
F1	$-0.61$	$0.036$
DTW similarity per step	$+0.12$	$0.71$

) reveals that the alignment-cluster Wikispeedia metrics agree with the LLM-judged ranking ($\rho \approx +0.7$), while the overlap-cluster metrics disagree with it ($\rho \approx -0.6$). Per-step DTW similarity is uncorrelated with LLM coherence. This rank disagreement is internal to the Wikispeedia metrics: the choice of supervised metric pre-determines which family of methods looks best on the unsupervised task too.

4.5. Cross-Task Scatter Plots

Figure 8 visualises the Spearman correlations of Section 4.4 (Table 6) as scatter plots. Each point is one of the 12 LLM-evaluated methods; the y-axis is the Cuba LLM’s mean overall coherence (averaged across both judges), and the x-axis cycles through five Wikispeedia metrics. The two alignment-cluster metrics (nDTW and nDTW similarity) line up against LLM coherence with $\rho \approx +0.7$, the two overlap-cluster metrics (Jaccard, F1) anti-correlate with $\rho \approx -0.6$, and per-step DTW similarity is uncorrelated. Method colours encode kernel family.

4.6. Computational Performance

Table 7. Computational cost of coherence methods (classical simulation on lightning.qubit, 5 seeds × 10 trials of 100 pairs per configuration; reference platform: 4-core Intel Xeon @ 2.1 GHz, 15 GB RAM, Ubuntu 24.04, Python 3.11, PennyLane 0.44.1, pennylane-lightning 0.44.0). Time is per pairwise coherence computation. Slowdown is relative to the cluster-aware classical_NT baseline.

Configuration	Mean Time (ms)	Slowdown	State Space
Classical kernels
classical_NT (angular cos + JSD topic, baseline)	0.038	1×	—
cosine (random-projection 64D)	0.005	0.14×	—
cosine (raw 1536D)	0.008	0.20×	—
RBF (random-projection 64D)	0.002	0.06×	—
RBF (raw 1536D)	0.005	0.12×	—
RY+CNOT-ring (compute–uncompute)
2 qubits (avg over $\{1,2,4,6,8\}$ layers)	2.16	57×	$2^2=4$
4 qubits (avg)	3.71	99×	$2^4=16$
8 qubits (avg)	6.83	182×	$2^8=256$
8q × 1 layer (8D)	2.34	62×	256
8q × 2 layers (16D)	3.64	97×	256
8q × 4 layers (32D)	6.44	171×	256
8q × 6 layers (48D)	9.27	247×	256
8q × 8 layers (64D)	12.45	331×	256
IQP/ZZFeatureMap (compute–uncompute)
4 qubits (avg over $\{1,2,4,8\}$ layers)	2.97	79×	16
8 qubits (avg over $\{1,2,4,8\}$ layers)	5.48	146×	256
8q × 8 layers (64D)	10.86	289×	256
Projected quantum kernel (local Paulis + Gaussian)
4 qubits (avg over $\{1,2\}$ layers)	3.51	94×	16
8 qubits (avg over $\{1,2,8\}$ layers)	8.65	230×	256
8q × 8 layers (64D)	15.15	403×	256

reports per-pair coherence computation time across all kernel families evaluated in the 93-method sweep, refreshed with the timing script in the supplementary archive (5 seeds × 10 trials = 50 measurements of 100 random pairs per configuration run sequentially on a single host with no concurrent activity). The cluster-aware Narrative Trails coherence (rescaled angular cosine on the UMAP-projected vector blended with a JSD-based topic similarity on the cluster-membership probabilities) sets the classical reference at $0.038$ ms per pair; bare cosine and RBF on the same projected inputs are 7–$16\times$ cheaper than classical_NT because they skip the topic term. R_Y+CNOT-ring quantum kernels range from $2.16$ ms (2 qubits, averaged across layer counts) to $12.45$ ms (8 qubits, 8 layers); the alternative IQP/ZZFeatureMap encoder is slightly cheaper at matched depth (e.g., $10.86$ ms vs $12.45$ ms at 8 qubits, 8 layers) because it omits the explicit CNOT ring; the projected quantum kernel is the heaviest of the three quantum families ($15.15$ ms at 8 qubits, 8 layers) because the post-projection Gaussian is built on dense $3n$-dim local Pauli vectors. Within each family, execution time scales approximately linearly with circuit depth at a fixed qubit count; the sub-linear ratio ($5.3\times$ for $8\times$ more layers in the R_Y+CNOT 8-qubit sweep) reflects a fixed per-pair circuit-initialisation overhead. Absolute timings are simulator- and host-dependent; the relative ordering across families reproduces across hardware.

5. Discussion

5.1. Two Wikispeedia Metric Clusters Disagree

The Wikispeedia metrics in widespread use for storyline extraction do not all measure the same thing. Alignment-based metrics (length-normalised DTW and per-step DTW similarity) reward methods that produce long, alignment-rich extractions whose trajectory closely follows the human navigation; set-overlap metrics (Jaccard and F1) reward methods that produce shorter extractions sharing many specific articles with the human path. These two views of “goodness” rank our methods in opposite orders (Table 1 and Table 2), with a rank correlation of $\rho \approx -0.6$ between the two clusters. The disagreement is not a bug but a structural feature: the human Wikispeedia paths are short navigation games rather than constructed narratives, so methods optimised for set overlap with them will tend to truncate to short article subsets, while methods optimised for trajectory alignment will tend to produce longer paths that share the human path’s geometric envelope without necessarily covering its specific nodes. We present both clusters because either alone gives a misleading impression of relative method quality.

5.2. LLM Coherence Rank Aligns with the Alignment Cluster

Cross-task analysis (Table 6) reveals that LLM-judged narrative coherence correlates positively with the Wikispeedia alignment cluster ($\rho \approx +0.7$) and negatively with the overlap cluster ($\rho \approx -0.6$). Methods that win on alignment also produce stories LLMs find more coherent; methods that win on overlap produce stories LLMs find less coherent. The mechanism is consistent across both phenomena: smooth topical concentration—supplied either by HDBSCAN cluster membership in classical_NT or by aggressive UMAP-to-low-d bottleneck in q_umap_4q_4d and cos_umap_12d—helps both alignment with human paths and the LLM-judged coherence of the extracted storyline. Sharp pairwise similarity on raw random projections, in contrast, helps overlap with short navigation paths but not narrative coherence.

5.3. Quantum Kernels Are Competitive but Not Decisively Better

On the matched-input pool comparison (Table 4), the genuinely quantum kernels and the classical kernels on the same projection are statistically indistinguishable in every dimension under both judges after Holm correction. The cluster-aware classical_NT baseline is the top method by a small but consistent margin (Table 5); the quantum kernel (q_umap_4q_4d) is its closest competitor in terms of overall coherence and beats it on the alignment cluster of Wikispeedia metrics. The picture is therefore one of competitive parity: quantum kernels work as well as classical kernels on this task, the cluster-aware baseline retains a modest edge attributable to its explicit topical structure, and no kernel choice produces dramatic improvements over any other.

This empirical parity has a theoretical interpretation, given the characterisation in Section 4.1. At depth 1, the R_Y+CNOT-ring kernel is provably a classical product kernel close to an RBF (Theorem 1, Corollary 1); at greater depth, the kernel does become genuinely non-classical (Proposition 2), but exponential concentration sets in (Remark 1), erasing the inter-pair distinguishability the MST construction needs. The non-product encodings (IQP and PQK) escape the depth-1 cancellation but do not show empirical separation either, indicating that the additional expressivity of these encodings is not what storyline extraction on document embeddings is bottlenecked by. Quantum kernels for storyline extraction are therefore best read as alternative classical kernels with an extra cost: the underlying coherence-graph problem is sufficiently well-posed in the projected geometry that simpler kernels exhaust most of the available signal.

5.4. Why classical_NT Wins the LLM Comparison

The Narrative Trails baseline combines angular similarity in UMAP-projected space with topic similarity from HDBSCAN soft clustering. The cluster term explicitly encodes “stay on theme” across the path. On Wikispeedia, where humans played a navigation game [16] rather than constructing narratives, the cluster term over-constrains the path—this is why classical_NT loses the alignment cluster to UMAP-based methods that omit it. On Cuba narrative coherence, where a “good” story is, by definition, a thematic unit, the cluster term is exactly what the LLM is grading, and it produces a modest advantage. The same property may hurt or help depending on the task. We therefore avoid framing classical_NT’s LLM coherence win as a generic kernel-quality result: it is task-specific.

5.5. Departures from the Original Manuscript Claims

Earlier reports of this work claimed that quantum kernels significantly outperform the classical baseline on three of four LLM coherence dimensions ($p<0.05$, paired Wilcoxon) and achieve a 29.6% DTW improvement on Wikispeedia. Both claims need qualification. The DTW improvement was reported using raw accumulated DTW cost rather than the length-normalised nDTW used in the Narrative Trails reference [2]; under nDTW, the gap between the best UMAP-projected method and classical_NT is approximately 7%, not 29.6%. The per-dimension LLM coherence claim used a single random projection seed and a single judge, with the “quantum” pool effectively averaging across configurations of widely varying behaviour; the multi-seed, dual-judge replication reverses the sign of the comparison against classical_NT (Section 4.4). The storyline-set Jaccard overlap between seeds for the same quantum kernel is approximately $0.22$, so single-seed effect sizes of $1.5$–$3.3\%$ are within the seed-driven storyline-set noise.

5.6. Limitations

Quantum simulation, not hardware. All experiments use classical simulation of quantum circuits. We cannot assess how noise, decoherence, and gate errors on real quantum hardware would affect coherence computation [8,30]. The practical viability of quantum coherence kernels depends on hardware performance that we do not evaluate. Two structural arguments suggest the central conclusions transfer to hardware nonetheless: the depth-1 cancellation result (Theorem 1) holds at the operator level, and symmetric noise on $U\left(z_v\right)$ and $U^{†}\left(z_u\right)$ preserves the per-feature factorisation up to a uniform contrast reduction, leaving the pair ranking the MST construction depends on unchanged, and the exponential concentration phenomenon underlying the deep encoder underperformance (Remark 1, [30]) is reinforced rather than relieved by hardware noise. The competitive-parity verdict is therefore conservative for the hardware case.

Qubit scalability in simulation. Our experiments are limited to 2, 4, and 8 qubits due to the exponential state space of quantum simulation ($2^n$ states for n qubits). As shown in Table 7, while coherence computation remains practical (∼1–15 ms per pair across all three quantum families), the slowdown relative to the cluster-aware classical_NT baseline (∼50–$400\times$ in lightning.qubit simulation) and the memory required to hold the dense $2^n\times 2^n$ state vector constrain exploration of higher qubit counts. Investigating whether larger circuits yield further improvements would require quantum hardware or advanced simulation techniques such as tensor networks.

LLM-judge scope. The unsupervised evaluation uses two judges (Claude Sonnet 4.5 and GPT-4o) at $T=0$ via structured tool calling on a 12-method subset of the 93 supervised configurations chosen by aggregate rank. Method-level rank correlation between the two judges is high (Spearman $\rho =0.86$), but cell-level absolute agreement is moderate (ICC $\approx 0.49$). The qualitative conclusions are not driven by judge choice within this pair, but neither do we claim that all current frontier LLMs would converge on the same ranking; further judges would tighten the inference but are unlikely to overturn the matched-input pool-vs-pool null result.

Storyline-set seed sensitivity. Storylines extracted by the same kernel under different random projection seeds share only ∼22% of their articles, on average. The five-seed protocol mitigates but does not eliminate this variance: single-seed effect sizes below ∼5% are within the seed-driven storyline-set noise floor, which is why we average over seeds and report bootstrap intervals.

Dataset and embedding dependence. Results may depend on the specific datasets and embedding model. Different corpora, domains, or embedding models could yield different relative performance. The hypothesis that random projection preserves useful structure assumes the original embeddings capture semantically meaningful relationships.

Evaluation-metric dependence. The two Wikispeedia metric clusters (alignment and overlap) rank methods in opposite orders. Either cluster taken alone gives a misleading picture of relative kernel quality. We do not take a position on which cluster is the “true” Wikispeedia metric—both have face validity for different aspects of narrative extraction—but we recommend reporting both whenever Wikispeedia is used as a benchmark.

No direct human evaluation. Our evaluation relies on two proxies for narrative quality: alignment with historical human navigation paths and LLM-as-a-judge coherence ratings. Neither constitutes a user study with human readers evaluating extracted storylines for comprehensibility, usefulness, or engagement. Wikispeedia captures how humans navigated Wikipedia under game-like conditions [16], which may differ from how they would evaluate narrative coherence. LLM judgements reflect model-specific notions of coherence that may not align with human preferences. We mitigate this in two ways. First, we use a dual-judge protocol with two architecturally distinct frontier LLMs (Claude Sonnet 4.5 and GPT-4o) at $T=0$ via structured tool calling and report cell-level absolute agreement (ICC_2,1$\approx 0.49$) alongside method-level rank correlation ($\rho =0.86$); the qualitative pool-vs-pool conclusion is preserved across both judges. Second, prior LLM-as-a-judge evaluation studies on related text-quality tasks [46,47,48] report substantial Pearson and Spearman correlation ($\rho \gtrsim 0.5$) between frontier-LLM scores and human ratings on coherence-adjacent dimensions, supporting the use of LLM judgement as a coarse proxy when matched-input pool-vs-pool comparisons are the analytical target rather than absolute coherence levels. Future work should nonetheless include human judges rating extracted storylines directly to confirm that the cross-task agreement we observe between the alignment cluster and LLM coherence is not driven by LLM-specific stylistic preferences.

6. Conclusions

We have introduced quantum kernels as coherence functions for narrative path extraction—to the best of our knowledge, the first systematic characterisation of quantum kernel methods applied to storyline extraction—and compared them to classical baselines on Wikispeedia and on a Cuban news corpus under a 12-method, 5-seed, dual-judge LLM evaluation. Our main findings are negative on quantum advantage but positive on methodology.

First, the standard Wikispeedia metrics partition into two clusters that rank methods in opposite orders: alignment-based metrics favour UMAP-projected quantum kernels and the cluster-aware classical baseline; set-overlap metrics favour random projection methods, regardless of whether the kernel is quantum or classical. Either cluster reported alone yields a misleading verdict on relative kernel quality, and we recommend reporting both for any future Wikispeedia-based evaluation. Second, on Cuba LLM-judged coherence, the cluster-aware Narrative Trails baseline is the top method under both judges; a pool-vs-pool comparison between the five genuinely quantum methods and the seven classical methods (classical_NT plus six cosine/RBF kernels on the random projection that the quantum pool also uses) shows no significant differences after Holm correction. Third, the LLM-judged coherence ranking correlates with the alignment cluster of Wikispeedia metrics ($\rho \approx +0.7$) and anti-correlates with the overlap cluster ($\rho \approx -0.6$); the same kernel property—smooth topical concentration—helps both alignment with human paths and LLM-judged narrative coherence.

The practical takeaway for NLP practitioners considering quantum kernels for document similarity is that they are competitive with classical kernels at the same projection budget but do not provide a decisive advantage on this task; the cluster-aware classical baseline retains a small but consistent edge attributable to its explicit topical structure. Future work should examine whether quantum kernels offer advantages on tasks that genuinely reward the higher-order feature interactions they encode, conduct human-judge studies to triangulate the LLM evaluation, and explore hardware implementations whose noise characteristics may differ from classical simulation.