Algorithm, Not Metric: Why Pairwise and K-Blade Geometric Algebra Appeared to Fail at Concept Hierarchy Construction, and What Fixed It

Authors: Pat Parslow (Draft)

Experiments were run interactively with AI-assisted tooling (code generation, execution, and result inspection); all reported numbers are from real runs against the site's own 160-page corpus, not simulated or illustrative. Code referenced throughout is in tools/site/concept_experiments/.

Abstract

WeWe investigate whether geometric algebra (GA) — specifically, representing document embeddings as blades and clusters as oriented subspaces — offers an advantage over plain cosine similarity for building a hierarchical concept model from a small (160-page) real-world corpus. An initial series of experiments (A–C) using pairwise bivectors and rank-r subspace blades, combined with greedy bottom-up agglomerative merging, produced a uniformly negative result: GA-derived hierarchies were substantially worse than a plain cosine baseline on every quality metric tested, and direct inspection of the resulting trees confirmed a genuine chaining pathology rather than a measurement artefact. A follow-up series (D–E) tested whether this failure was attributable to the merge algorithm rather than the similarity metric, by pairing the same GA-derived similarities with two different global clustering procedures: modularity-maximising graph communities, and a rate-of-change densest-subgraph growth algorithm. Both interventions substantially reversed the negative result. Under the best-tuned growth-clustering configuration, the GA-derived (k-blade, rank≤3) hierarchy reached an Adjusted Rand Index (ARI) of 0.634 against a folder-based ground truth, matching the best agglomerative cosine baseline (0.638) and clearly outperforming a mean-vector bivector variant (0.093–0.109) tested earlier with the same greedy algorithm. We conclude that the earlier negative verdict on GA for this task was largely an artefact of algorithm choice, not a property of the geometric representation itself, and we document two independent, reproducible fixes (average- rather than total-weight growth criteria; z-scored rather than raw similarity) that were both necessary before the effect could be observed at all.

1. Introduction

GeometricGeometric algebra represents oriented k-dimensional subspaces (k-blades) as first-class algebraic objects, generalising the notion of a single direction vector to genuine regions or "volumes" in a vector space. This is an appealing framework for concept modelling: individual documents are naturally single vectors, but a coherent topic or cluster of documents plausibly occupies a genuine subspace, not just a mean direction. We set out to test this idea concretely, against a real corpus, rather than treat it as a purely theoretical proposal.cf. blades as boxes around uncertainty

The corpus is 160 pages from a personal/portfolio and teaching website (parslow.net), spanning topics from programming-language internals to ethics, security, and geometric algebra itself. Each page is embedded with nomic-embed-text[3] (768-dim), and the site's own directory structure provides a convenient — though, as Section 6 discusses, imperfect — ground-truth topic labelling for quantitative evaluation.

The investigation proceeded in two clearly separated phases. Phase 1 (Sections 2–4, Tests A–C) evaluated GA representations of increasing richness — from a closed-form pairwise bivector norm up to genuine rank-r subspace blades per cluster — using the conventional algorithm for building a hierarchy from a pairwise or subspace distance: greedy bottom-up agglomerative merging. Every configuration in Phase 1 underperformed a plain cosine baseline, in several cases severely. Phase 2 (Section 5, Tests D–E) asked whether this was a property of the metric or the algorithm, and found decisively that it was the algorithm: the same underlying similarity values, paired with two different global (not greedy-local) clustering procedures, produced results competitive with the cosine baseline.

2. Background FoundationalKnowledge that endures for decades — core principles

2.1 Bivectors and the Lagrange identity

GeometricGeometric algebra treats an oriented k-dimensional subspace (a k-blade) as a first-class algebraic object rather than a derived quantity, generalising the vector-space notion of a single direction[1][2].

For two vectors a, b, the geometric product decomposes as

\[ ab = a \cdot b + a \wedge b \]

where \(a \cdot b\) is the familiar scalar (cosine-related) inner product and \(a \wedge b\) is the bivector (outer/wedge) part. For unit vectors, the Lagrange identity gives an exact closed form for the bivector's norm without constructing any general multivector algebra:

\[ \lVert a \wedge b \rVert^2 = 1 - (a \cdot b)^2 \]

i.e. \(\lVert a \wedge b \rVert = \sin\theta\) where \(a \cdot b = \cos\theta\). This is a plain \(O(n^2)\) NumPy computation at any dimension n, with no basis-blade enumeration and no risk of the exponential (\(2^n\)) cost that general-purpose GA libraries (e.g. kingdon) incur once n exceeds roughly 20 — measured directly in this work at 17s and >11GB RAM for a single Algebra(22) construction, before being terminated.sine is 0 for parallel vectors, 1 for perpendicular

2.2 From bivectors to k-blades: generalised principal angles

The two-vector wedge generalises to a genuine k-blade by representing a set of vectors (e.g. all members of a cluster) by an orthonormal basis \(A \in \mathbb{R}^{d \times r}\) of its r dominant directions (the top-r right singular vectors of the member matrix). Given two such bases \(A\) (rank \(r_A\)) and \(B\) (rank \(r_B\)), the singular values of \(A^\top B\) are the cosines of the principal angles between the two subspaces; the product of the corresponding sines is the natural generalisation of the two-vector bivector norm to genuine k-blades:

\[ \sigma(A,B) = \prod_{i=1}^{\min(r_A,r_B)} \sqrt{1 - \cos^2\theta_i}, \qquad \cos\theta_i = \text{singular values of } A^\top B \]

This reduces exactly to the Lagrange-identity bivector norm when \(r_A = r_B = 1\), is computed via a small \((r \times r)\)-scale SVD (cost \(O(r^2 d)\), never \(O(2^d)\)), and requires no dimensionality reduction of the underlying embeddings — the full 768-dim vectors are used directly. This is the "sparse where appropriate, dense where it matters" design used throughout: no blanket PCA is applied up front (which would throw away information before it is needed), but each cluster's own basis is a small, cheap, per-cluster computation.

Computationally, \(\sigma(A,B)\) is conventional Grassmannian subspace geometry — orthonormal bases, principal angles, a small SVD — not an evaluation of explicit blade coordinates or a Clifford product. The more exact description of what Section 4 onward actually tests is a principal-angle subspace similarity motivated by the blade interpretation of oriented subspaces, rather than an implementation of geometric algebra's own machinery. That framing matters for what a positive result below can and cannot support: it would show that local low-rank subspaces are a useful cluster representation, not, on its own, that blade geometry specifically — as opposed to principal-angle geometry, a Grassmannian kernel, or low-rank local PCA more generally — is what makes them useful. Once the empirical results are in, Sections 7 and 8 return to this distinction.motivated by blades; implemented as Grassmannian subspace geometry

\(\sigma(A,B)\) itself grows as two subspaces become more orthogonal, so by itself it behaves as a separation or dissimilarity measure: Sections 4–4.4 use it correctly on that footing, merging whichever pair has the smallest \(\sigma\). Wherever it instead needs to act as a graph edge weight (Section 5.1), where "more alike" should mean "higher weight," the code takes its complement first — 1.0 - generalized_sine(...) in both ga_kblade_graph_communities.py and ga_kblade_growth_clustering.py — rather than feeding \(\sigma\) into the graph directly. Both conventions are correct for the section that uses them; naming the transform here is what makes that true rather than a coincidence of which value happened to look right.

3. Corpus, Ground Truth, and Metrics Applied / MethodologicalKnowledge with a 5–10 year half-life — stable practice

160 pages, embedded with nomic-embed-text (chosen over mxbai-embed-large after a per-signal AUC comparison: 0.8924 vs 0.7689 on a same-folder/different-folder pair-discrimination benchmark, with mxbai also roughly 3x slower — see Appendix). Ground truth is the site's own directory structure (17 folders). Section 6 presents direct evidence that this ground truth is imperfect — several folder placements reflect an editorial/organisational decision (e.g. an article about a technique being filed under "learning and teaching" advice rather than under the technique's own topic area) rather than a single-topic classification, and pages are frequently and legitimately multi-topic.

Quality is reported via Adjusted Rand Index (ARI) and Normalized Mutual Information (NMI) against this folder ground truth, and cophenetic correlation (agreement between a dendrogram's implied distances and the original distance matrix) where a hierarchy, rather than a flat partition, is being evaluated.

4. Phase 1: Pairwise and Subspace Blades with Greedy Agglomerative Merging

4.1 Test A — pairwise bivectors carry no information beyond cosine FoundationalKnowledge that endures for decades — core principles

ComputingComputing the exact bivector norm (Section 2.1) at the full, unreduced 768 dimensions and using it to rank same-folder vs. different-folder page pairs gives AUC = 0.8924 — numerically identical to raw cosine similarity's AUC on the same pairs (also 0.8924), and identical again to a naive combination of the two signals. This is explained, not merely observed: because \(\sin\theta\) is a monotonic function of \(\cos\theta\) whenever the sample's pairwise cosines share a consistent sign (true throughout this corpus), the bivector norm is a strictly rank-equivalent relabelling of cosine similarity for a two-vector wedge. Increasing the retained embedding dimensionality (the original motivation for this test) therefore cannot help — a two-vector wedge structurally cannot carry information a cosine similarity does not already carry.same ranking of pairs, so the same AUC

4.2 Test B — mean-vector bivector merge is worse than cosine Ephemeral / ToolingKnowledge that evolves in months to a year — check for updates

Building an agglomerative hierarchy by repeatedly merging whichever two clusters have the smallest bivector norm between their mean direction vectors (the natural direct generalisation of Test A to a hierarchy) performed markedly worse than average-linkage on cosine distance:

4.3 Test C — genuine rank-r k-blades do not fix it, at any rank Ephemeral / ToolingKnowledge that evolves in months to a year — check for updates

Replacing the mean-vector representation with a genuine rank-r orthonormal-basis blade per cluster (Section 2.2), merged by the generalised-sine criterion, produced a smaller but still substantial gap, and — critically — the gap did not close as rank increased:

Cophenetic correlation peaks around rank 2–3 and then plateaus or mildly declines; ARI/NMI against the folder ground truth stay uniformly low across the entire sweep, with no rank-dependent trend at all. "Give the blade more of its own data" (the premise motivating the rank sweep) is therefore not the missing ingredient.

4.4 Direct inspection: a genuine chaining pathology, not a bad cut height Ephemeral / ToolingKnowledge that evolves in months to a year — check for updates

Two direct checks confirmed that the poor quantitative scores reflected a real structural problem in the tree, not merely an unlucky choice of where to cut it for the k=17 comparison. First, the top of the k-blade dendrogram, examined directly, merges exactly one leaf at a time into an ever-growing supercluster (a 159-member cluster gains one leaf to become 158…157…156, and so on) — the textbook signature of single-linkage-style chaining. Second, cutting the tree at its own single largest merge-distance gap (0.149→0.331, roughly four times any neighbouring gap) — rather than at an arbitrary k — produced 154 clusters out of 160 pages: almost every page as its own singleton, with only a handful of 2–3-page clusters (largely literal duplicate pages) below the gap. There is no useful intermediate structure hiding beneath a bad cut point; the merge criterion itself has essentially bimodal discriminative power — adequate for near-duplicates, uninformative for everything else — when paired with greedy nearest-pair merging.

5. Phase 2: Isolating Algorithm from Metric

GreedyGreedy bottom-up agglomerative merging repeatedly commits to "merge the single closest remaining pair," with no notion of overall graph structure — the mechanism that produces chains. Phase 2 tests the same underlying k-blade (rank≤3) similarity values under two structurally different, non-greedy-pairwise algorithms.

5.1 Test D — modularity-maximising graph communities Ephemeral / ToolingKnowledge that evolves in months to a year — check for updates

Each page was connected to its top-K most similar neighbours in a weighted graph (sparsified rather than dense — a fully connected graph has no community structure to discover) using \(1-\sigma(A,B)\) as the edge weight (Section 2.2), and partitioned using greedy modularity maximisation (Clauset–Newman–Moore[4], via networkx). Modularity maximisation is itself a global objective — comparing a candidate community's internal edge weight against a chance expectation given node degree — rather than a literal heaviest-subgraph search, but it is not vulnerable to the same one-nearest-neighbour chaining failure as agglomerative merging.

A sweep of K ∈ {4,6,8,10,15,20,30} confirmed this was not a fortunate choice of K: k-blade tracks cosine closely across the whole range, ahead at some values (e.g. K=8) and behind at others (e.g. K=15: cosine 0.514 vs. k-blade 0.368), but never collapsing to Test C's near-zero ARI.

5.2 Test E — rate-of-change densest-subgraph growth Ephemeral / ToolingKnowledge that evolves in months to a year — check for updates

A second, more direct answer to "when is a cluster complete" avoids any fixed hyperparameter (k or top-K) entirely: seed a cluster with the most globally central unclaimed page, then repeatedly add whichever unclaimed page has the highest similarity to the current cluster, tracking the marginal gain at each step; stop growing when that marginal gain drops sharply relative to the previous step (an elbow), rather than at a predetermined size. This is a greedy densest-subgraph-style growth procedure, in contrast to Test D's global modularity objective.

Two implementation details were necessary before this procedure produced any structure at all, and are reported here because both failures are non-obvious and easy to reproduce by omission:

• Total vs. average weight. Scoring candidates by their total similarity to the current cluster inflates the score for any large cluster regardless of fit quality — even a weak match accumulates a large sum once the cluster has many members — so no elbow ever appears and the procedure degenerates to one all-consuming cluster at every threshold tested (0.3–0.9). Scoring by average similarity (the standard densest-subgraph density measure) is size-invariant and restores a real, sharply-varying signal.
• Raw vs. z-scored similarity. Raw cosine similarity for this embedding model occupies a narrow band (~0.70–0.86 across nearly all pairs in this corpus — the same anisotropy "floor" documented earlier in this project's broader embedding-ensemble work) that decays too gently for any elbow to be detectable. Z-scoring each similarity matrix against its own corpus-wide mean and standard deviation before growth restores the necessary contrast.

With both fixes applied, sweeping the elbow-sensitivity ratio (the threshold below which a gain drop counts as an elbow):

Two observations follow from this table, and both matter. First, at their respective best operating points, k-blade (ratio 0.8: ARI 0.634) and cosine (ratio 0.9: ARI 0.633) are essentially tied with each other, and both are essentially tied with the best agglomerative-cosine baseline from Phase 1 (0.638) — this is the central positive result of Phase 2. Second, the two metrics do not share a best operating point (0.8 vs. 0.9), and each is markedly worse at the other's optimum (k-blade collapses to ARI 0.049 at ratio 0.9; cosine drops to 0.571 at ratio 0.8). This is a claim of parity under correct tuning, not of one representation dominating the other. The elbow-ratio is a sensitive hyperparameter for this procedure rather than a robust default.

Manual inspection of the k-blade clustering at its best setting found coherent, non-folder-aligned groupings, including a 4-page cluster grouping a "triangulation" page (filed, by folder, under general project-advice) together with three explicitly spatial-cartography pages — recovering, from an entirely different algorithm, a specific cross-folder relationship anticipated on inspection grounds in Section 6.

6. Is the Ground Truth Trustworthy? Applied / MethodologicalKnowledge with a 5–10 year half-life — stable practice

AA direct, manual comparison of cluster membership against folder membership (rather than only the summary ARI/NMI statistics) turned up several cases where the folder structure, not the discovered hierarchy, is the less reliable signal. A page titled "programming," filed under a folder about games, is placed by the cosine hierarchy together with object-oriented-programming fundamentals pages — a more topically accurate placement. A "triangulation" page, filed under general project advice, is placed by both the cosine baseline and, independently, the Test E k-blade growth-clustering, together with the site's spatial-cartography pages, reflecting that its content concerns the same underlying spatial technique even though its folder reflects a pedagogical framing decision. A cluster spanning three different AI/ethics/education folders (chatbot healthcare ethics, accessibility and learning, several "AI in higher education" pages) is grouped coherently by the cosine hierarchy despite being split across folders by the site's own navigation structure.

This matters for how the entire quantitative comparison in this paper should be read: agreement with the folder ground truth is a reasonable, cheap proxy, but disagreement is not automatically evidence of a worse hierarchy — some of the "errors" found by ARI/NMI are, on inspection, the discovered hierarchy correctly reflecting that pages are legitimately multi-topic, which the single-folder-per-page ground truth cannot represent. The one place this caveat does not rescue a result in this paper is Test C's degenerate k-blade-agglomerative tree (Section 4.4): direct inspection there showed a real structural failure (near-total chaining, no usable intermediate clusters at any cut height), not a defensible alternative structure being penalised by an imperfect ground truth.

7. Discussion Applied / MethodologicalKnowledge with a 5–10 year half-life — stable practice

TheThe overall trajectory of this investigation is itself the main finding. A geometric representation (pairwise bivectors, then genuine rank-r k-blades) was tested, found uniformly wanting against a strong baseline, and diagnosed by direct inspection as suffering a genuine structural pathology (chaining) rather than a benchmarking artefact — a legitimate basis, at that point, for concluding the representation itself was the problem. That conclusion turned out to be wrong, or at least incomplete: swapping only the clustering algorithm, while holding the k-blade similarity values fixed, recovered performance competitive with cosine under two independently-implemented, structurally different global algorithms (modularity communities; rate-of-change densest-subgraph growth). The representation and the algorithm used to consume it are separable design choices, and an evaluation that only ever tests one algorithm per representation risks attributing an algorithmic weakness to the representation.

A second, more specific observation: greedy agglomerative merging's chaining failure mode is not unique to GA-derived metrics in principle, but this corpus's k-blade similarity happened to expose it far more severely than cosine did (Test B/C's ARI of ~0.09–0.11 vs. cosine's 0.638 under the identical algorithm). One plausible explanation, consistent with Test A's finding that generalised-sine metrics saturate differently near \(\theta \approx 0\) than cosine does, is that the k-blade metric's discrimination is concentrated in a different, narrower distance range than cosine's, making it more sensitive to the kind of "always take the single nearest neighbour" myopia that greedy agglomerative merging exhibits. This is offered as a hypothesis, not a proven mechanism; distinguishing it from other explanations was out of scope for this investigation.

Both fixes required to make Test E's growth-clustering procedure work at all — average- rather than total-weight scoring, and z-scored rather than raw similarity — are, in retrospect, generic prerequisites for any rate-of-change/elbow-based stopping rule on this kind of data, not specific to GA. We record them here explicitly because both failure modes (a monotonically-growing score that never elbows; a too-flat similarity distribution that never elbows) produce the same visible symptom — one giant undifferentiated cluster — and are easy to misattribute to "the elbow idea doesn't work" rather than to a fixable measurement choice.

A third observation concerns what kind of structure Tests D and E actually recover, as distinct from Phase 1's. Agglomerative merging (Tests B, C) genuinely builds a hierarchy: a dendrogram with real parent-child nesting at every cut height, which is exactly why Section 4.4 could inspect its failure by looking at cut structure directly. By contrast, modularity communities and growth-clustering (Tests D, E) are flat partitions, each page belonging to exactly one community or cluster with no nesting above it. What Phase 2 fixes is the underlying similarity values' usefulness, recovered once a non-greedy algorithm consumes them, rather than the hierarchy itself that Phase 1 failed to build. Parent-child inclusion, sibling separation, stability across resolution, and a defensible way to place a concept at one level of abstraction rather than another are all things a genuine concept hierarchy needs and a flat community assignment doesn't provide on its own. Multi-membership and explicit relational metrics between clusters are exactly what the direct follow-up takes up next; on its own evidence, this paper establishes competitive concept clustering, not a complete concept hierarchy.

A fourth observation returns to Section 2.2's framing. The strongest claim Test D and Test E's numbers directly support is that a low-rank cluster subspace, compared by principal angle, supplies a useful neighbourhood signal — roughly comparable to cosine's, ahead of it at some operating points, behind at others. What they do not yet show is that geometric algebra specifically, rather than low-rank subspace modelling in general, is the active ingredient: nothing in Tests D or E isolates the product-of-principal-sines criterion from the many other ways a subspace-to-subspace distance could be defined (chordal distance, geodesic distance, a projection-based distance, or a mutual-inclusion score, among others), and nothing isolates "subspace, not mean vector" from "GA's own multiplication structure specifically." Section 8 takes up what a next experiment would need to separate those two questions.

8. Limitations, and What a Sharper Comparison Would Need

• The corpus is small (160 pages) and drawn from a single site with a particular authorial voice; generalisation to larger, more heterogeneous corpora is untested.
• The folder-based ground truth, while shown to be imperfect (Section 6), was still used for all quantitative comparisons; no alternative, more granular ground truth (e.g. human-annotated multi-label topics) was constructed.
• Test E's elbow-ratio is a sensitive hyperparameter with different optima for different similarity metrics (Section 5.2); no principled, data-driven method for selecting it per-metric was developed here.
• Only one embedding model (nomic-embed-text) was used for the Phase 2 experiments; whether the algorithm-vs-metric conclusion holds for other embedding spaces is untested.
• "Genuine k-blade" here means a subspace basis of a cluster's dominant directions, not a wedge of the cluster's actual member vectors (which becomes degenerate once cluster size exceeds the ambient dimensionality's practical rank budget for a small corpus like this) — a scoping simplification noted at the time and not revisited.
• \(\sigma(A,B)\) uses only \(\min(r_A, r_B)\) principal angles (Section 2.2), so dimensions present only in the larger of two subspaces are ignored entirely. A rank-1 subspace fully contained in a rank-3 one can score as maximally close, even though the rank-3 subspace has two further directions the comparison never sees. That is a reasonable design for a symmetric closeness score, which is all this paper asks of it, but it is the wrong tool for a directional inclusion question ("how much of A does B contain?"), which a genuine parent-child hierarchy relation would need and which this paper does not attempt to answer.
• The comparisons above establish that k-blade and cosine are roughly comparable, not that k-blade is reliably better. A claim that strong would need repeated corpora or bootstrap resampling to attach a confidence interval to each ARI; hyperparameter selection (top-K, elbow ratio) kept separate from final evaluation rather than reported at its own best setting; multi-label human judgements in place of the single-folder ground truth; comparison at matched graph density and cluster count rather than whatever each method's own best setting happens to produce; and a check that the result is stable across more than one embedding model. None of that was done here, and the paper's own claims are scoped accordingly.

8.1 A sharper next experiment

TheThe most informative next experiment is not another rank sweep — Test C already showed that raising rank from 1 to 30 does not repair agglomerative chaining (Section 4.3). A factorial design separating four choices would instead isolate which part of this paper's pipeline is actually doing the work:

• Representation: centroid vector; local low-rank subspace (this paper's choice); covariance representation; an explicit decomposable blade, if materially different from the subspace basis already used.
• Subspace metric: product of principal sines (this paper's choice); chordal distance \(\sum_i \sin^2\theta_i\); geodesic distance \(\sqrt{\sum_i \theta_i^2}\); a projection-based distance \(\frac{1}{\sqrt2}\lVert AA^\top - BB^\top\rVert_F\); largest principal angle alone; a mutual-inclusion score built from \(\lVert P_B A \rVert_F^2 / r_A\) and its reverse.
• Graph construction: mutual k-nearest-neighbour; ordinary k-nearest-neighbour (this paper's choice); adaptive local scaling; a fixed similarity threshold.
• Community algorithm: modularity maximisation (this paper's choice); Leiden; spectral clustering; hierarchical community detection.

Four questions would separate representation from metric from algorithm, in a way the current results cannot: is most of the gain over cosine caused by representing a cluster as a subspace at all, independent of which distance compares two subspaces? Does the product-of-sines criterion specifically add anything over the more standard Grassmannian distances listed above? Does the result hold up under more than one community-detection algorithm, or is it specific to greedy modularity maximisation? And does any configuration recover a cross-folder link a human reader would actually judge meaningful, beyond the handful inspected by hand in Section 6?

9. Conclusion

PairwisePairwise bivectors carry no ranking information beyond cosine similarity for unit vectors (an exact mathematical result, not an implementation limitation), and genuine rank-r k-blades, evaluated via the conventional greedy agglomerative merge algorithm, produced hierarchies that were not merely unhelpful but structurally degenerate. Both findings would, on their own, support abandoning the geometric-algebra approach to this task. However, holding the same k-blade similarity values fixed and substituting two different global clustering algorithms for greedy agglomerative merging recovered performance matching the best cosine baseline found anywhere in this investigation. The correct conclusion is therefore not "geometric algebra does not help here," but "greedy nearest-pair agglomeration was an unusually poor algorithmic match for this particular metric, on this corpus" — a conclusion only reachable by treating algorithm and metric as separately falsifiable, and by directly inspecting failed results rather than accepting a summary statistic at face value.

Scoped to what the evidence here actually supports: low-rank cluster subspaces supply a genuinely useful neighbourhood signal beyond a single mean direction, roughly matching cosine rather than reliably beating it, and the active ingredient behind that usefulness remains an open question between geometric algebra specifically and principal-angle subspace geometry more generally (Section 7). Tests D and E recover competitive flat clusters; a dendrogram with defensible parent-child structure is a separate achievement this paper doesn't reach (Section 7). The research programme that actually follows from the evidence runs in a specific order: establish that low-rank subspaces beat a single vector per cluster (done, Test B against the growth-clustering results); ask only afterward whether geometric algebra's own multiplication structure, rather than subspace geometry in general, is adding anything (Section 8.1's job, not yet done); and leave explicit hierarchy relations — inclusion, overlap, multiple parentage — to the follow-up paper built to take them on directly, rather than treat them as implied by this paper's clustering results.

10. 2026 Update: Rerunning at Full Scale (348 Pages)

TheThe site has grown substantially since this paper was first written — 348 pages across 40 top-level folders now, versus 160 pages across 17 folders at the time of the original investigation, exactly the untested case Section 8 flagged as a limitation. This section reruns every test above, unchanged, against the current corpus: same scripts, same folder-based ground truth methodology, a fresh embedding cache written to a new file rather than overwriting the original (so the numbers throughout Sections 2–9 remain independently reproducible from the original 160-page cache). Most of the original conclusions hold up. One does not, and that limitation is reported directly below rather than folded quietly into the surrounding narrative.

10.1 Tests A–D: The Original Conclusions Hold Up Ephemeral / ToolingKnowledge that evolves in months to a year — check for updates

Test A's exact-equivalence result reproduces precisely: bivector norm, raw cosine, and the combined signal all give AUC = 0.8206 on the current corpus — still numerically identical to each other, exactly as Section 4.1's closed-form argument predicts regardless of corpus size. The absolute value dropped from the original 0.8924, which is a base-rate effect of a harder 40-way same-folder/different-folder discrimination task rather than any change in the underlying mathematical identity.

Test B's gap between the cosine baseline and the mean-vector bivector merge reproduces at the new scale (k=40):

Test C's rank sweep shows the same absence of a rank-dependent trend, at every rank tested:

Build times rose roughly tenfold (11–16s originally to 125–155s now) for a corpus only 2.2x larger, consistent with the rank-sweep's underlying cubic cost in page count.2.2 cubed is about 10, hence the tenfold

Test D's parity finding reproduces. At K=8, k-blade found 5 communities (ARI 0.2223, NMI 0.4376) against cosine's 7 (ARI 0.2449, NMI 0.4710). The fuller K-sweep — reported here as a table rather than the original's two-point prose summary, since the full data is now in hand — shows k-blade ahead of cosine's ARI at five of the seven K values tested, behind at K=8 and, by a hair (0.2197 against 0.2221), at K=10:

Absolute ARI/NMI values are lower everywhere than at n=160, which is expected against 40 ground-truth folders instead of 17, but k-blade never collapses toward Test C's near-zero scores at any K — the parity conclusion, not just the specific numbers, survives the larger corpus.

10.2 Test E Does Not Reproduce at This Scale Ephemeral / ToolingKnowledge that evolves in months to a year — check for updates

The elbow-ratio growth-clustering sweep does not reproduce the original's central positive result. At n=160, ratio 0.8 gave k-blade an ARI of 0.634, matching cosine's own best (0.633 at ratio 0.9) and the best agglomerative baseline found anywhere in the paper (0.638). At n=348, no ratio gives either metric anywhere near that:

K-blade's best ARI at this scale is 0.0998, at ratio 0.8 — but direct inspection of that clustering shows why the number is that low: it is one 224-page mega-cluster plus a long tail of small remainders (sizes 224, 6, 6, 5, 5, 4, 3, 3, 3, 3, 2…), the same undifferentiated-blob failure mode Section 4.4 diagnosed for greedy agglomerative merging, now reappearing inside a different algorithm. Cosine's best ARI at this scale is 0.4624, at ratio 0.9 — a materially better clustering (107 small clusters, none of them a mega-cluster) — but that same ratio collapses k-blade to ARI 0.0713. The two metrics no longer share even an approximately common best operating point, and neither reaches its original-scale performance.

This sharpens the paper's central thesis rather than undermining it. Of the two non-greedy algorithms Phase 2 used to fix Phase 1's chaining problem, modularity-maximising communities (Test D, Section 10.1) generalises robustly from 160 to 348 pages; rate-of-change elbow-based growth clustering (Test E) does not, and degrades by collapsing into exactly the kind of mega-cluster the whole investigation exists to avoid. That degradation happens for cosine too, just to a milder, less-degenerate pattern — so this is a property of the growth-and-elbow algorithm at this scale, not evidence against the k-blade representation specifically. "Treat algorithm and metric as separately falsifiable" (Section 9's conclusion) turns out to apply to an algorithm's robustness to corpus growth as much as it applies to an algorithm's baseline performance.

10.3 Chaining and Cross-Folder Groupings, Still Present Ephemeral / ToolingKnowledge that evolves in months to a year — check for updates

Section 4.4's chaining pathology reproduces in essentially the same shape: the k-blade agglomerative tree's biggest merge-distance gap is 0.1197→0.3080 (a similar relative jump to the original's 0.149→0.331), the top of the tree still merges exactly one leaf at a time, and cutting at the gap produces 343 singleton-or-near-singleton clusters from 348 pages — proportionally the same near-total collapse as the original's 154/160, with the few genuine multi-page groups again turning out to be literal duplicate pages (e.g. a "PatLang IDE" page filed under both its portfolio folder and its topics folder).

Section 6's point that folder ground truth is an imperfect, cheap proxy also reproduces, with a new example worth noting for its own sake: at k=40, the cosine baseline groups this very paper together with its two direct follow-ups (K-Blade Concept Structure vs. the Live Site's Self-Organizing Map, Overlapping Membership and Geometric-Algebra Borders) and the production Concept Atlas page and its neighbours (K-Blades vs. Self-Organizing Maps, accessible-navigation, concept-mapping-and-SOMs, graph-traversal-and-pathways, triangulating-concept-spaces, Voronoi topic territories) — the site's own family of pages about this exact method, correctly clustered together despite being split, by editorial choice, across a research-papers folder and a spatial-cartography-and-navigation folder.

Taken together: the original paper's mathematical result (Test A), its diagnosis of greedy agglomeration's chaining failure (Section 4.4), its demonstration that a different global algorithm fixes that failure (Test D), and its caution about trusting folder ground truth (Section 6) all hold up under a 2.2x increase in corpus size. Test E's specific numeric parity claim was scale-limited in a way Section 8 correctly anticipated as untested; the update in Section 10.2 replaces that open limitation with a concrete finding, rather than leaving it unresolved.

Related Topics

• Overlapping Membership and Geometric-Algebra Borders for a Concept Hierarchy — the direct follow-up, extending this paper's Test E growth-clustering to multi-membership and to two new GA-native relational metrics between clusters.
• K-Blade Concept Structure vs. the Live Site's Self-Organizing Map — measures the wall-clock cost of the pipeline validated here against the SOM engine it went on to replace in production.
• K-Blades vs. Self-Organizing Maps: How the Live Concept Atlas Works Now — how this paper's algorithm-not-metric finding became the actual clustering engine behind the site's live Concept Atlas map.
• Vectors, Quaternions, and Blades: Why Geometric Algebra Subsumes Both — the underlying k-blade/multivector formalism this paper's similarity metric is built on, explained from first principles.

References

1. D. Hestenes, New Foundations for Classical Mechanics, D. Reidel Publishing Company, 1986. https://doi.org/10.1007/978-94-009-4802-0
2. L. Dorst, D. Fontijne, S. Mann, Geometric Algebra for Computer Science: An Object-Oriented Approach to Geometry, Morgan Kaufmann, 2007. https://geometricalgebra.org/
3. Z. Nussbaum, J. X. Morris, B. Duderstadt, A. Mulyar, "Nomic Embed: Training a Reproducible Long Context Text Embedder," arXiv:2402.01613, 2024. https://arxiv.org/abs/2402.01613
4. A. Clauset, M. E. J. Newman, C. Moore, "Finding community structure in very large networks," Physical Review E 70, 066111, 2004. https://doi.org/10.1103/PhysRevE.70.066111

Appendix: Reproducibility

AllAll code referenced is in tools/site/concept_experiments/: ga_bivector_exact.py (Test A), ga_native_hierarchy.py (Test B), ga_kblade_hierarchy.py / ga_kblade_rank_sweep.py (Test C), ga_kblade_graph_communities.py / ga_kblade_topk_sweep.py (Test D), ga_kblade_growth_clustering.py (Test E), dump_hierarchy_comparison.py / inspect_kblade_tree_structure.py / kblade_natural_cut.py (Section 4.4/6 manual inspection). All figures in Sections 1–9 are read directly from these scripts' stdout on the cached embedding data (ensemble_cache.npz) for the 160-page corpus described in Section 3; no numbers are estimated or illustrative.

Section 10's rerun uses the same, unmodified scripts against a freshly-generated cache (ensemble_cache_2025.npz, built by rerun_2025_corpus.py) so that ensemble_cache.npz and the original 160-page numbers above remain independently reproducible. Two scripts carry hardcoded values tied to the original corpus size that were overridden for the rerun rather than left silently wrong: dump_hierarchy_comparison.py's K_CUT=17 (set to 40, the current folder count) and kblade_natural_cut.py's CUT_DISTANCE=0.20 (re-verified against the new tree's own largest gap, 0.1197→0.3080, before reuse). Every other script computes its cluster count dynamically from the current folder structure and needed no changes.