Scientific results and publications
Radixor is developed as both production software and a reproducible research program. The nine-paper Radixor series separates questions that are often mixed together in stemmer evaluation: generalization beyond training forms, hyperparameter sensitivity, multi-objective error trade-offs, learned conflation policy, runtime structure, lexical-resource consistency, compiler semantics, retrieval-system interaction, and verified two-sided adaptation of compiled stemming policies.
Together, the papers characterize Radixor as a lexicon-trained transformation system rather than a dictionary lookup engine: lexical resources provide training evidence, the compiler induces executable patch commands and trie structure, and runtime behavior can extend beyond explicitly listed forms. Each paper establishes a deliberately narrower part of that statement and publishes its own evidence boundary.
Publication and evidence status
The articles linked below are author-released research manuscripts on ResearchGate. ResearchGate availability is not a claim of journal or conference peer-review status. The project documentation and repository provide the current implementation, benchmark data, protocols, and reproduction material; each manuscript freezes the evidence identity used by its own analyses.
The research program at a glance
| Research question | Principal contribution | Paper |
|---|---|---|
| Does a lexicon-trained stemmer transform genuinely unseen lexical families? | Controlled multilingual evidence of within-resource, out-of-training-family transformation transfer | 1 |
| Are edit costs merely implementation constants? | Multilingual evidence that edit costs act as structural hyperparameters and that nominal settings can collapse to identical induced behavior | 2 |
| How should under- and over-conflation trade-offs be compared? | Recursive Pareto strata and error-regime classification in the pairwise lexical-conflation error space | 3 |
| Can the same architecture learn a different stemming objective from different reference policy? | Controlled German evidence of policy-conditioned relational generalization | 4 |
| Does lexicon size imply dictionary-like online cost? | Runtime evidence relating execution cost more closely to compiled structure than to raw training size | 5 |
| Can internal resource-consistency evidence simplify the learned transformation vocabulary? | A multilingual audit connecting resource-local filtering to distinct patch-command vocabulary | 6 |
| What exactly is preserved or generalized by trie reduction? | Formal semantics for mode-specific canonicalization and accepting-leaf contraction | 7 |
| Is retrieval quality a property of a fixed stemmer, or of the jointly chosen lexical policy, ranker, and evaluation depth? | Controlled MIRACL evidence that an adapted Radixor policy can outperform the standard dictionary across all recorded retrieval metrics, with explicit scorer and objective sensitivity | 8 |
| Can a standard compiled stemming model be adapted in both directions and its realized policy verified after compilation? | Positive assignments, negative membership boundaries, persistence, closure checks, and a technical prior-art comparison of transformation expressivity | 9 |
The sequence is intentional. Papers 1–6 establish empirical properties and measurement boundaries from different directions; Paper 7 isolates the formal compiler semantics that explain what the reduced patch-command trie preserves and what accepting leaves are allowed to generalize. Paper 8 moves from intrinsic and structural properties to downstream retrieval, showing why stemming effectiveness depends on the lexical policy, ranker, evaluation objective, and ranking depth. Paper 9 then isolates the engineering and semantic mechanism that turns a standard compiled model into a positively and negatively adaptable, verifiable stemming policy.
Topic 1 — Generalization beyond the training lexicon
Does a Lexicon-Trained Stemmer Generalize? A 20-Language Study of Held-Out Lexical Families
ResearchGate Generalization evidence Protocol
Research question. Does Radixor merely reproduce mappings seen during training, or does the induced transformation mechanism transfer to lexical families that were withheld from model construction?
Principal result. The study evaluates 20 UniMorph-derived language resources under complete lexical-family holdout, ten training-family coverage levels, and five deterministic seeded rankings: 1,000 build/evaluation scenarios, of which 900 contain a non-empty held-out population. It establishes within-resource, out-of-training-family transformation transfer with exact parser-normalized surface-overlap control.
Interpretation boundary. The coverage sweep is descriptive, not a fixed-test causal learning curve: each coverage level has a different held-out complement. The paper does not claim arbitrary out-of-domain accuracy, contextual lemmatization, universal derivational competence, or equivalence between exact canonical-target recovery and downstream retrieval effectiveness.
Why it matters. This is the empirical foundation for calling Radixor lexicon-trained but not lexicon-bound. The learned object is an executable transformation relation, not a closed list of admissible runtime tokens.
Topic 2 — Edit costs as model-structure controls
Edit Costs as Structural Hyperparameters in Dictionary-Induced Stemming: A Multilingual Sensitivity Study
ResearchGate Edit-cost results Protocol
Research question. How strongly do insertion, deletion, replacement, and related edit costs alter the command vocabulary and linguistic behavior learned from the same lexical evidence?
Principal result. The frozen campaign contains 16,700 physical model builds representing 234,000 logical observations over the sampled 234-point cost grid. Exact equivalence analysis reduces those nominal settings to 334 distinct induced behaviors across the audited resources.
Interpretation boundary. Exact command-sequence equivalence, subset invariance, campaign reduction, and representation counts are deterministic results. Correlations, bootstrap summaries, guarded optima, and same-matrix operating points are descriptive analyses rather than population inference over languages.
Why it matters. Radixor's training objective is tunable at the level where lexical mappings become executable transformations.
Topic 3 — Multi-objective stemmer comparison
Classifying Multilingual Stemmers by Pareto Strata: Error Regimes in Pairwise Lexical Conflation
ResearchGate Benchmark results Linguistic-quality method
Research question. A scalar score can hide whether a stemmer fails mainly through under-conflation or over-conflation. What does the comparison look like when those error dimensions are treated explicitly?
Principal result. The paper classifies deterministic systems in a two-objective under-/over-conflation error space using candidate-set-relative recursive Pareto strata. It distinguishes aggregate error-vector equivalence from output equivalence; identifies recall, specificity, supported-compromise, and unsupported-efficient regimes; derives exact support intervals for the raw pair cost \(C_{\rho} = \rho\,FN + FP\); and follows constrained multi-output trajectories. The frozen analysis maps 190 deterministic implementation rows to 174 aggregate error vectors.
Interpretation boundary. Pareto depth and regime are conditional on the language, reference resource, processing mode, implementation version, output policy, and candidate set.
For the current Radixor quality campaign, the learned model and reference relation come from the same lexical resource. The measurements therefore establish same-resource agreement; they do not constitute independent external linguistic validation. The complete quality appendix preserves the current 66 directly compared language-mode matrices across 33 unique languages, the 216 Radixor-only matrices, and the 4 undefined matrices.
Why it matters. The paper makes the quality comparison auditable without forcing every application into one arbitrary scalar preference between false splits and false merges.
Topic 4 — The stemming policy is learned from data
The Stemming Policy Is Data: Adapting a Lexicon-Trained Stemmer to Alternative Conflation Objectives
ResearchGate Reproduction harness
Research question. If two gold resources encode different conflation policies over the same language, can the same Radixor architecture learn the policy difference rather than imposing one hard-coded definition of stemming?
Principal result. Using the two public German CISTEM/CELEX-derived policy resources, an independent clean replay regenerated all 30 persisted cross-fit models with matching model-file SHA-256 identities. The central result is deliberately narrow: sparse but directionally robust policy-conditioned relational generalization along one nested aggressive-to-conservative German policy axis. Pair-micro switch coverage is about 0.61% for the primary medoid encoding.
Interpretation boundary. The result is a controlled one-language policy study, not evidence that every conceivable conflation objective is learnable.
Why it matters. A material part of the stemming policy can reside in the lexical training relation and be changed without replacing the runtime architecture.
Topic 5 — Compiled structure and runtime efficiency
Runtime Efficiency of Lexicon-Trained Stemming: Compiled Structure and a Speed–Reference-Agreement Envelope in Radixor
ResearchGate Benchmarking framework Published benchmark results
Research question. Does training from a large lexicon imply dictionary-like online cost, or is runtime governed more directly by the compact structure compiled from that lexicon?
Principal result. On the frozen Java workstation and dictionary-derived timing workload, canonical Radixor execution spans 42.8–150.6 ns per occurrence, with an unweighted 20-resource median of 67.8 ns. Across 18 direct Snowball comparisons, the unweighted median Snowball/Radixor ratio is 2.33× under the primary closest-available same-harness policy and 2.57× under the canonical policy; a cross-policy invariant yields 17 stable Radixor advantages and one Finnish parity case. Internal-node count has Spearman \(\rho = 0.931\) with canonical runtime, compared with \(\rho = 0.723\) for training rows.
Interpretation boundary. The workload is dictionary-derived, not natural production traffic or an OOV corpus. The paper does not claim universal fastest-stemmer status or causal per-node cost.
Why it matters. Lexical training size and runtime state are separate layers; compiled structure is the more informative description of the online execution problem.
Topic 6 — Lexical-resource consistency and transformation vocabulary
Lexical Resource Consistency and Learned Transformation Vocabulary in Multilingual Stemming
ResearchGate Filtered candidate models
Research question. When internally inspectable resource inconsistencies are removed conservatively, how does that evidence propagate into the transformation vocabulary learned by the compiler?
Principal result. Twelve high-command resource configurations are audited. Ten non-destructive candidate resources are materialized; Dutch and Persian are explicit no-safe-change outcomes. Among the nine candidates using the homogeneous grouped rule, eight reduce distinct patch-command vocabulary, with the summed vocabulary changing from 20,281 to 19,842 (-2.165%) and a median per-resource reduction of 1.334%. German is reported separately: 6,986 to 5,313 commands (-23.948%).
Interpretation boundary. Command-count reduction is not evidence of trie-node, runtime, memory, or downstream retrieval improvement, and the filtering predicate is not a semantic oracle for linguistic correctness.
Why it matters. The paper connects data quality to the learned executable vocabulary while showing precisely where that connection stops.
Topic 7 — Formal semantics of the compiler
Compiling Learned Lexical Transformations: Semantic Canonicalization and Accepting-Leaf Generalization in Patch-Command Tries
ResearchGate Architecture and reduction Reduction semantics
Research question. What does Radixor's trie compiler preserve when it shares subtrees, and what exactly changes when a locally uniform region becomes an accepting leaf?
Principal result. The formal analysis separates two mathematically different compiler transformations:
- mode-specific semantic subtree canonicalization, which shares recursively equivalent decision subgraphs while preserving the selected reduction-mode observable; and
- uniform accepting-leaf contraction, which preserves the existing singleton value semantics of a locally uniform region while extending that value decision to additional continuations.
For stemming, accepting leaves generalize command selection, not a constant stem. If \(C(w)\) selects a patch command and \(\operatorname{Exec}(c,w)\) executes it, runtime output is \(H(w) = \operatorname{Exec}(C(w),w)\).
The paper proves soundness/congruence of the computable reduction signature for all public reduction modes, aggregation stability, completeness for productive ranked and unordered nodes in the contraction-free exact-trie phase, relative state minimality for that canonicalization-only quotient, quotient acyclicity, finite termination/decidability under the stated assumptions, and a value-semantic domain-extension theorem for uniform contraction. It also records that repeated recursive signature hashing admits quadratic work on a degenerate chain.
Interpretation boundary. The theorem is about compiler semantics, not the linguistic correctness of newly covered forms. It does not claim global minimality of the production contraction-enabled graph, minimum bytes or runtime, or arbitrary-input exact equivalence after accepting-leaf contraction.
Why it matters. Structural sharing and behavioral extension are distinct operations, and suffix-conditioned command selection is not the same claim as discovering linguistic morpheme rules.
Topic 8 — Retrieval quality, ranking depth, and adaptable lexical policy
Where Retrieval Quality Goes: Rethinking Stemming in Modern Search
Research question. Is stemming effectiveness meaningfully characterized by the result of one fixed default dictionary, or does retrieval quality depend on the jointly chosen lexical policy, ranker, evaluation objective, and ranking depth?
Principal result. The study evaluates English MIRACL development data with 799 queries over 32.9 million passages. At a common BM25 operating point, the task-adapted Radixor model improves the standard Radixor dictionary by 3.667% in nDCG@10, 4.043% in Recall@100, and 5.340% in AP@1000; all five recorded metric means improve over both standard Radixor and PyStemmer in the reported comparison. A separately identified 164-evaluation BM25 study demonstrates scorer and objective sensitivity, while the final index statistics show fewer output terms but more term–document incidences, excluding a simple pure-merge or pure-split explanation of the representation change.
Interpretation boundary. The lexical policy was selected and reported on the same development judgments. The result therefore demonstrates in-sample feasibility and attainable policy improvement on the studied task, not unseen-query superiority or population-level generalization. The evidence is also specific to the evaluated English collection, ranker family, relevance judgments, and recorded objectives.
Why it matters. A fixed stemmer instance is not necessarily the correct unit of scientific comparison when the underlying mechanism is adaptable. The paper shows concretely why apparently conflicting stemming results can arise when studies evaluate different lexical policies, ranker settings, objectives, and ranking depths, even when all of them report a single scalar notion of “stemming quality.”
Topic 9 — Two-sided adaptation and verified stemming policies
From Lexical Edits to Verified Stemming Policies: Two-Sided Adaptation in Radixor
Research question. Can a standard compiled Radixor model be reused as the substrate for a task-specific stemming policy that supports both positive lexical assignments and negative membership boundaries, while verifying that compilation preserves the intended policy?
Principal result. The paper specifies a two-sided adaptation workflow in which positive assignments merge or redirect selected forms and negative membership boundaries prevent generalizing rules from admitting unwanted forms into protected classes. The extensions are installed into a reopened standard model, persisted as a compiled artifact, and checked against both intended positive assignments and forbidden memberships. In the shared MIRACL development case, a reported positive-only realization admits 11,291 unintended surfaces, motivating observed-vocabulary closure before the final policy is accepted. The resulting adapted deployment improves the standard model on all five recorded retrieval metrics; the companion retrieval paper analyzes those selected-task outcomes in detail.
The technical comparison also distinguishes Radixor's operational adaptation mechanism from the expressivity of earlier transformation systems. In particular, XSTEM's terminal cut-and-append action can be represented within the older Egothor patch executor, whereas a single Egothor/Radixor patch can preserve source characters between edits. The comparison treats later suffix-deletion and captured-span methods according to their actual transformation cores rather than using software-package citations as substitutes for algorithmic attribution.
Interpretation boundary. Policy closure is established only over the checked inventory; it is not a proof of unrestricted out-of-vocabulary transfer. The available artifacts do not support an equal-budget empirical comparison against every historical adaptive stemmer, and some original audit artifacts are incomplete. The prior-art analysis therefore establishes specific representational and operational distinctions, not universal dominance over every possible composed pipeline.
Why it matters. Radixor turns a standard compiled dictionary into a reusable, two-sidedly adaptable and verifiable lexical-policy substrate. This connects learned lexical edits to a deployable model whose realized conflation boundaries can be checked explicitly, rather than treating customization as an opaque post-processing exception list.
How to read and cite the series
The nine papers are cumulative in scope, not cumulative in the sense that a later result silently broadens an earlier claim. For scientific use:
- cite the individual paper for the frozen experiment, theorem, or analysis it reports;
- use the current documentation for present software behavior, API contracts, model catalogs, and continuously maintained benchmark pages;
- preserve each paper's stated population, reference-resource, metric, and implementation boundaries when quoting numerical results; and
- treat reproducibility artifacts, source identities, checksums, and explicit negative claims as part of the result rather than as supplementary marketing material.
The resulting research program is intentionally modular: empirical linguistics, multi-objective evaluation, systems performance, data quality, compiler correctness, retrieval effectiveness, and adaptive policy verification are tested separately and connected only where the evidence supports the connection.