Resolving Information Asymmetry: A Framework for Reducing Linguistic Complexity Using Denoising Objectives

Abstract

Information asymmetry between complex source texts and general-audience comprehension remains a critical challenge in Artificial Intelligence. However, existing supervised simplification methods suffer from the scarcity of parallel training data, while standard text summarization methods often discard essential details to reduce length. Furthermore, zero-shot large language models frequently lack fine-grained controllability over linguistic complexity. To address these technical limitations, we present a framework to resolve information asymmetry by casting text simplification as a controllable denoising language modeling task. Unlike summarization, our approach preserves full semantic coverage while reducing difficulty. Our algorithm targets the problem of identifying and rewriting complex spans without labeled data through three mechanisms: (1) Asymmetry-Aware Masking, which uses model-based reconstruction difficulty (Negative Log-Likelihood) to isolate high-complexity terms; (2) paraphrase context prompting to enforce semantic invariance; and (3) an adaptive decoding strategy that dynamically penalizes complex tokens based on input difficulty. On ASSET (Abstractive Sentence Simplification Evaluation and Tuning dataset), our best setting reaches SARI (System output Against References and against the Input) 42.90 with FKGL (Flesch–Kincaid Grade Level) 7.10 (Sentence Similarity 0.948), and performs consistently on TurkCorpus (SARI 41.10), while requiring no parallel data or fine-tuning.

1. Introduction

Text simplification (TS) aims to transform complex text into a simpler counterpart while preserving its meaning, thereby improving readability for non-specialists or readers with a weaker grasp of the source language [1]. Although text simplification and summarization both rewrite text, they optimize different objectives. Summarization is content-selective: it may omit details to produce a shorter version, and coverage is not required. In contrast, TS aims to preserve the original meaning while reducing linguistic difficulty, so dropping information is typically undesirable. Early attempts to automate TS largely relied on rule-based or phrase-substitution approaches [2]. More recently, fine-tuning pre-trained language models has become a common strategy for TS [3,4,5]. However, this paradigm faces two practical limitations. First, high-quality parallel simplification corpora remain scarce, especially in specialized domains such as medicine and law [6,7]. Second, fine-tuning on relatively small downstream datasets can degrade the general language capacity of a model, potentially harming robustness and generalization.

In parallel, there has been a paradigm shift toward using language models without task-specific training. Prompting methods, for example, provide natural-language instructions to encourage a pre-trained model to perform a target task [8]. Another prominent direction is in-context learning [9], where a model learns a task from a small number of demonstrations provided in the input context [10]. These training-free strategies are attractive because they avoid expensive optimization, reduce the risk of catastrophic forgetting, and can be readily transferred to improved model versions as they become available.

In this paper, we frame simplification as resolving information asymmetry: complex texts often contain expressions that are disproportionately difficult for the intended audience to interpret, creating a gap between the writer’s assumptions and the reader’s knowledge. Motivated by this view, we propose a training-free framework for reducing linguistic complexity using denoising objectives in frozen encoder–decoder models [11]. Our instantiation builds on BART [12], but modifies the corruption process to focus on reader-facing difficulties. Instead of masking tokens uniformly at random, as in standard denoising pre-training, we identify and mask high-asymmetry spans—phrases predicted to be hard to recover for a general reader. We operationalize this notion using model-based reconstruction difficulty (token-level negative log-likelihood under a frozen model) together with lightweight structural cues, while explicitly preserving named entities. The resulting prompt encourages the denoiser to reconstruct fluent text by rewriting the parts that most contribute to information asymmetry, while leaving straightforward content largely intact.

To reduce meaning drift during reconstruction, we optionally attach a paraphrase as a semantic anchor after the separator token </s>. Crucially, this context is generated with a version-pinned open-source sequence-to-sequence model and cached, avoiding reliance on external translation services whose outputs may change over time. At the generation time, we use a soft, adaptive decoding mechanism: complex tokens are discouraged via a controllable logit penalty, and the penalty strength can be adjusted based on the estimated asymmetry of the input, with an escape mechanism that relaxes the constraint when simplicity would otherwise compromise adequacy.

Controllability remains a central challenge for practical TS. Recent evaluations of large language models suggest that even when models can approximately target a reading level, outputs may fluctuate substantially in readability and topic fidelity, limiting deployment without explicit control signals [13]. This instability reflects the inherently multi-objective nature of simplification, which must balance readability improvements against semantic preservation, whereas common evaluation setups often compress this trade-off into a single score. In our experiments, the proposed asymmetry-resolving framework surpasses strong baselines—including fine-tuned systems and large language models such as GPT-4o (We use GPT4o-2024-08-06 version)—while relying on a substantially smaller backbone and requiring no task-specific training.

The contributions of this paper are threefold: (1) we formulate text simplification as resolving information asymmetry via denoising objectives and show that frozen encoder–decoder denoisers can achieve strong simplification performance without training; (2) we propose an asymmetry-aware prompting strategy that masks span-level sources of reader difficulty using LM-based reconstruction signals and augments the input with reproducible, offline paraphrase context; and (3) we introduce an adaptive soft-constrained decoding method that provides fine-grained control over linguistic complexity and yields state-of-the-art FKGL (Flesch–Kincaid Grade Level) scores [11,14].

2. Related Work

2.1. Text Simplification

Automatic text simplification has been studied extensively. Machine translation-based approaches [15,16] cast simplification as monolingual translation, while edit-based methods [17,18] explicitly model sentence rewriting through a sequence of edit operations. Controllable simplification has also been explored: CROSS [19] introduces indicator features and templates to enforce lexical and syntactic constraints. Other lines of work incorporate adversarial objectives [20] or reinforcement learning [21] to better balance fluency, adequacy, and simplicity.

Fine-tuning pre-trained sequence-to-sequence models has recently achieved strong performance on benchmark datasets [5]. For instance, ACCESS [22] fine-tunes BART with pre-defined control prefixes to steer simplification behavior. A persistent limitation of supervised Seq2Seq simplification, however, is the scarcity of high-quality parallel simplification corpora. To mitigate this, several unsupervised and semi-supervised methods construct pseudo-parallel data to augment training [3,4,23,24]. In contrast to these approaches, our method requires no task-specific training and instead relies on input-adaptive prompting together with constrained decoding to achieve competitive performance.

2.2. Prompt Engineering

Prompting transforms an original input x into a prompted input $x^{\prime }$, i.e., $f_{\mathrm{prompt}}\left(x\right)=x^{\prime }$ [8]. Prompts are often categorized into cloze and prefix forms. Cloze prompts introduce an explicit slot that the model is expected to fill, and have been widely used in few-shot settings for classification and generation [25,26]. Prefix prompts prepend additional context before the original input. Prefix-tuning methods [27,28] keep the backbone model frozen and optimize a small set of continuous prompt parameters, achieving a comparable performance to full fine-tuning with far fewer trainable parameters. Beyond manual prompt design, Gao et al. [29] propose automatically generating task-specific prompts (e.g., for T5 [30]) to improve downstream performance compared with vanilla fine-tuning. Many training-free TS baselines rely on instruction prompts (e.g., “simplify this sentence”) and depend on a model’s instruction-following behavior. Our approach instead provides task guidance through model-native signals aligned with denoising pre-training. Specifically, we perform targeted corruption by masking spans estimated to be difficult to recover, optionally attach an offline paraphrase as a semantic anchor, and control lexical complexity at decoding time with a soft, adaptive penalty.

2.3. Training-Free Prediction

Training-free prediction has gained popularity with the emergence of large language models, where a model produces an output given only a task description and possibly a few demonstrations in context. Early work, such as LAMA [31,32], probes pre-trained language models for factual and relational knowledge, suggesting that PLMs can store and retrieve structured information. Ettinger [33] introduces a set of human-designed templates to test language understanding through language modeling. Jiang et al. [34] further propose an automatic procedure for generating prompts to retrieve factual knowledge, often outperforming manually crafted templates. These studies motivate the broader use of prompting and context design as a substitute for task-specific training.

2.4. Constrained Answer Spaces

Many language modeling formulations assume that the answer space is the full vocabulary. In prompting settings, however, tasks with limited output spaces—such as text classification [35] or named-entity recognition [36]—often constrain allowable outputs. Gao et al. [29] prune the search space by selecting the top-k candidate tokens according to conditional likelihood, thereby reducing the effective decoding space; related work explores sketching or coarse-to-fine strategies for narrowing the candidate set during generation [37]. In our work, we use a soft complexity control mechanism: we apply a controllable logit penalty to discourage complex tokens rather than banning them outright. This preserves the option to generate a complex token when it is necessary for meaning preservation, and it provides a smoother, continuous trade-off between readability and fidelity via the penalty strength.

3. Method

A central challenge in text simplification (TS) is the scarcity of high-quality parallel training data [11,38]. This limitation hinders both training simplification systems from scratch and reliably fine-tuning pre-trained models for TS, especially in specialized domains. To address this, we avoid task-specific optimization and instead cast TS as a controlled denoising problem. Concretely, we introduce task guidance at inference time by corrupting the input in a targeted way and letting a frozen denoising encoder–decoder model reconstruct the sentence into a simpler form.

Our design is grounded in two observations. First, pre-trained models often assign high probability mass to common lexical items during generation [39,40,41], which can align with readability. Second, decoding choices shape the balance between fluency, adequacy, and simplicity. These properties suggest that a denoising model can be repurposed for TS without training, provided that (i) the corruption targets the parts that create difficulty for readers, and (ii) decoding includes an explicit mechanism to control linguistic complexity.

We therefore proceed in three steps. We first corrupt an input sentence by masking a small set of high-asymmetry spans—phrases expected to contribute most to reader difficulty—using mask tokens that the denoiser is trained to reconstruct. Because corruption may risk meaning drift, we optionally provide a paraphrase $\tilde{\mathsf{x}}$ as contextual guidance. Finally, at decoding time we do not hard-filter the vocabulary. Instead, we apply a soft, adaptive penalty to tokens estimated to be complex, which yields fine-grained controllability while avoiding the brittleness of strict vocabulary constraints. In this way, TS becomes a controlled reconstruction task whose strength can be tuned to different reader proficiency levels. Figure 1 illustrates the pipeline. We first identify high-asymmetry spans and replace them with $⟨\mathtt{mask}⟩$ tokens, preserving named entities when available. We optionally append an offline paraphrase after </s> as a semantic anchor for reconstruction. During generation, we discourage complex tokens using a soft penalty with an adaptive schedule and an escape mechanism to avoid adequacy loss.

Figure 1. Overview of the proposed framework.

3.1. Simplification Framework Overview

Our framework consists of two components: (1) an input transformation (noising/prompting) function $f_N\left(\mathit{x}\right)$ that maps an input sentence $\mathit{x}$ to a corrupted prompt $\widehat{\mathit{x}}=f_N\left(\mathit{x}\right)$, and (2) a decoding strategy that controls linguistic complexity during generation. Given a denoising language model $P_L({\mathit{x}}^{\prime }\mid \widehat{\mathit{x}})$, we generate a simplified sentence by

$$\begin{array}{c}\hfill {\mathit{x}}_{\mathrm{simp}}=\underset{{\mathit{x}}^{\prime }=(x_1^{\prime },\dots ,x_n^{\prime })}{argmax}{P}_L\left({\mathit{x}}^{\prime }\mid f_N\left(\mathit{x}\right)\right)\mathrm{s}.\mathrm{t}.\Omega \left({\mathit{x}}^{\prime }\right)\le \tau ,\end{array}$$

(1)

where $\Omega \left({\mathit{x}}^{\prime }\right)$ is a controllable complexity measure induced by our decoding rule and $\tau$ determines the desired strength of simplification. In practice, we approximate decoding with beam search. Unlike hard constrained decoding with a fixed allowable vocabulary, our method implements $\Omega$ through a soft token penalty that discourages complex tokens while preserving the option to generate them when necessary for adequacy.

In our experiments, we use the denoising encoder–decoder model BART and its variants: BART-Base, BART-Large, and BART-Large-CNN [12,42]. The BART-Large-CNN variant is fine-tuned on CNN/DailyMail summarization. For controllability, we tune the strength of the decoding penalty (and its adaptive schedule).

3.2. Asymmetry-Aware Prompting via Targeted Corruption and Paraphrase Context

The choice of noising/prompting function $f_N\left(\mathit{x}\right)$ is crucial. Given a sentence $\mathit{x}$ to be simplified, $f_N\left(\mathit{x}\right)$ produces a textual template $\widehat{\mathit{x}}=f_N\left(\mathit{x}\right)$ that is fed into the denoising model. Rather than appending or prepending external instruction prompts [25,43,44], we provide task guidance through targeted corruption: we replace selected spans in $\mathit{x}$ with the $⟨\mathtt{mask}⟩$ token used in BART pre-training. The $⟨\mathtt{mask}⟩$ token explicitly marks regions to be rewritten and leverages the denoiser’s reconstruction capability [24]. For comparison, we also evaluate random masking. The templates used in this paper are listed in Table 1, and the effect of different masking settings is discussed in Section 5.1.1.

Table 1. Input template configurations. </s> concatenates sequences. O: original sentence; G: prompt to GPT; P: offline cached paraphrase. $B_1$–$B_3$ use targeted span masking; $B_5$ uses random masking.

ID	Template
Baselines/Controls
O	The committee unanimously ratified the memorandum, notwithstanding substantial procedural irregularities reported by Dr. Elena Marquez.
G	Simplify while preserving meaning: The committee unanimously ratified the memorandum, notwithstanding substantial procedural irregularities reported by Dr. Elena Marquez.
P	The committee approved the memo, even though Dr. Elena Marquez reported serious procedural problems.
Denoising templates
$B_1$	The committee <mask> the memorandum, <mask> reported by Dr. Elena Marquez.
$B_2$	The committee <mask> the memorandum, <mask> reported by Dr. Elena Marquez. </s> [O]
$B_3$	The committee <mask> the memorandum, <mask> reported by Dr. Elena Marquez. </s> [P]
$B_4$	[O] </s> [P]
$B_5$	The <mask> <mask> ratified the <mask>, notwithstanding <mask> procedural irregularities <mask> by Dr. Elena Marquez. </s> [P]

3.2.1. Asymmetry-Aware Span Masking

Most complex sentences contain only a subset of difficult parts [45]. We therefore mask at the span level rather than masking isolated tokens. Our goal is to identify spans that contribute most to information asymmetry—i.e., phrases that a general reader is least likely to recover from context. To avoid reliance on external lexicons, we score span difficulty using model-based reconstruction signals from a frozen model. Concretely, we compute token-level negative log-likelihood (NLL) statistics under a denoising-style objective, and aggregate them over candidate spans to obtain an asymmetry score. We then select a small set of non-overlapping high-scoring spans under a corruption budget and replace each selected span with a single $⟨\mathtt{mask}⟩$. This focused corruption encourages the denoiser to rewrite the most asymmetry-inducing expressions while leaving straightforward content largely intact.

3.2.2. Keeping Named Entities

Complex sentences often contain named entities. Although named entities may be infrequent and thus appear “difficult” under distributional criteria, they are typically essential for preserving semantic meaning [46,47,48]. We therefore detect named entities as a preprocessing step using spaCy [49] and keep them unchanged in the corrupted input $\widehat{\mathit{x}}$. In practice, we prevent the masking function from selecting spans that overlap named entities, which both preserves key content and reduces reconstruction burden on the language model.

3.2.3. Paraphrase Context as a Prefix Prompt

When the input is heavily corrupted, reconstructing the intended meaning from the remaining context becomes difficult. We therefore optionally attach a paraphrase $\tilde{\mathit{x}}$ of the original sentence as additional guidance (Table 1). Concretely, we concatenate the corrupted sentence and its paraphrase using a separator token (e.g., $\widehat{\mathit{x}}</\mathtt{s}>\tilde{\mathit{x}}$), allowing the denoising model to condition its reconstruction on an explicit semantic anchor. To ensure reproducibility, the paraphrase is generated offline with a version-pinned open-source sequence-to-sequence model and cached, avoiding dependence on external services whose outputs may change over time. This design encourages the model to rewrite masked regions while staying faithful to the meaning of the original sentence.

3.3. Generation with an Adaptive Soft Complexity Penalty

Beam search is the default decoding strategy in many conditional generation systems. In our framework, we retain beam search but replace hard vocabulary filtering with a soft, adaptive mechanism that directly supports the goal of resolving information asymmetry. The motivation is twofold: (i) the strict exclusion of “complex” tokens can remove substantial probability mass and force unnatural substitutions, and (ii) lexical complexity is not binary—some tokens are appropriate in context even if they are relatively rare.

3.3.1. Complexity-Induced Token Penalty

Let the model vocabulary be V. Instead of partitioning V into disjointed simple and complex sets and assigning zero probability to the latter, we associate each token $v\in V$ with a non-negative complexity penalty $\pi \left(v\right)\ge 0$. In our method, $\pi (·)$ is derived from the frozen model itself via reconstruction difficulty (token-level negative log-likelihood statistics under a denoising-style objective; see Section 3.2), and is fixed once the model version is pinned. Named entities are exempted by setting $\pi \left(v\right)=0$ for entity tokens (or by disallowing masking/penalization on spans overlapping named entities).

At decoding step i, the base model provides logits $z_i\left(v\right)$ (or probabilities $P(v\mid y_{1:i-1},x)$). We modify the search distribution by subtracting a scaled penalty from the logits:

$${\tilde{z}}_i\left(v\right)=z_i\left(v\right)-\lambda \pi \left(v\right),P_{\lambda }(v\mid y_{1:i-1},x)={\displaystyle \frac{exp\left({\tilde{z}}_i\left(v\right)\right)}{{\sum }_{u\in V}exp\left({\tilde{z}}_i\left(u\right)\right)}}.$$

(2)

Here $\lambda \ge 0$ controls simplification strength. When $\lambda =0$, decoding reduces to standard beam search. A larger $\lambda$ increasingly discourages complex tokens, but never forces them to have zero probability.

3.3.2. Input-Adaptive Control

To connect decoding control to information asymmetry, we set $\lambda$ adaptively based on the estimated difficulty of the input. In particular, we increase $\lambda$ when the input contains more masked (high-asymmetry) spans, using a simple schedule such as

$$\lambda \left(x\right)={\lambda }_0+k·r_{\mathrm{mask}}\left(x\right),$$

(3)

where $r_{\mathrm{mask}}\left(x\right)$ is the fraction of mask tokens in the corrupted prompt $\widehat{x}$, and ${\lambda }_0,k$ are hyperparameters. This yields a natural behavior: sentences with more asymmetry-inducing content receive stronger pressure toward simpler lexical choices.

3.3.3. Escape Mechanism for Adequacy

Although the penalty is soft, there are cases where simplicity pressure may still push the model toward inadequate substitutions (e.g., when no fluent simple alternative exists). We therefore add an escape rule that relaxes the penalty at step i if the best “simple” option is implausible. Let $V^{\left(s\right)}$ denote the set of tokens with near-zero penalty (including named entities). Define

$$p_s^{*}=\underset{v\in V^{\left(s\right)}}{max}P(v\mid y_{1:i-1},x),p_c^{*}=\underset{v\notin V^{\left(s\right)}}{max}P(v\mid y_{1:i-1},x).$$

If $p_s^{*}$ falls below a small threshold or if $p_c^{*}/p_s^{*}$ exceeds a ratio threshold, we temporarily reduce $\lambda$ by a constant factor for that decoding step. This preserves controllability while preventing failure modes where hard filtering would force unnatural or semantically incorrect outputs.

Overall, our decoding procedure can be viewed as a beam search under a complexity-regularized distribution (See Figure 2). Compared to simple-word-only generation, it provides smoother and more reliable control: complex tokens are discouraged but remain available when they are needed to maintain fluency and meaning.

Figure 2. Beam searching only in the simple-word space. We set the probabilities of low-frequency (complex) words to zero to avoid searching for complex words.

4. Experiment

4.1. Experimental Settings

4.1.1. Backbone Models

We use BART-Large as the default backbone model due to its strong denoising and generation abilities under a reconstruction objective. In addition, we report results with BART-Base and BART-Large-CNN to study the impact of model capacity and summarization-oriented pre-finetuning. Unless otherwise specified, all results are obtained with the same asymmetry-aware prompting and decoding framework described in Section 3.1.

4.1.2. Asymmetry-Aware Span Masking and Hyperparameters

For targeted corruption (Templates $B_1$–$B_3$), we select spans that are predicted to contribute most to reader difficulty (Section 3.2) and replace each selected span with a single $⟨\mathtt{mask}⟩$ token. Unlike lexicon-based approaches, we estimate span difficulty using model-derived reconstruction signals: we compute token-level negative log-likelihood (NLL) statistics under a denoising-style objective for a frozen model and aggregate these signals over candidate spans to obtain an asymmetry score. In the default setting, we select non-overlapping spans under a fixed corruption budget, controlled by the mask rate (fraction of masked words/tokens) and a maximum number of spans per sentence. We analyze sensitivity to the masking intensity and span budget in Section 5.1.1. Intuitively, heavier corruption encourages more substantial rewriting but can increase the risk of meaning drift, whereas lighter corruption tends to favor local edits.

Unless otherwise stated, we use beam search with $num\_beams=5$ and $max\_new\_tokens$ 64. For asymmetry-aware masking, we select candidate spans using token-level reconstruction difficulty (NLL) under a frozen backbone, and mask spans whose difficulty exceeds a quantile threshold $\theta$ (default $\theta =0.70$). We set the masking rate to $mask\_rate=0.15$ with, at most, $max\_spans=3$ masked spans per sentence, and preserve named entities when the NER pipeline is available. For decoding control, we apply a soft complexity penalty with base strength ${\lambda }_0$ (default ${\lambda }_0=5.0$). In the adaptive variant we set $\lambda \left(\mathit{x}\right)={\lambda }_0+k{r}_{\mathrm{mask}}$, where $r_{\mathrm{mask}}$ is the fraction of masked tokens/spans in the input and $k=10.0$.

4.1.3. Paraphrase Context

For templates that include paraphrase context (Table 1), we generate $\tilde{\mathit{x}}$ offline using a version-pinned open-source sequence-to-sequence model (https://huggingface.co/humarin/chatgpt_paraphraser_on_T5_base (accessed on 4 February 2026)) and cache the results. This avoids dependence on external translation services whose outputs may change over time. Unless otherwise noted, we use a deterministic generation setup (fixed decoding configuration and random seed) to ensure that paraphrases are stable across runs. We report ablations on whether paraphrase context is included in Section 4.

4.1.4. Random Masking Baseline

For the random masking template $B_5$, we follow the default masking rate used in BART pre-training and set the masking rate to $0.15$. We additionally sweep a wider range of masking rates to study the effect of corruption intensity on simplification quality (See Section 5.1.2), where we observe that moderate masking can improve SARI on ASSET but excessive masking may degrade adequacy.

4.1.5. Soft/Adaptive Decoding and Output Control

All decoding is performed with beam search using the soft/adaptive mechanism described in Section 3.3. Instead of restricting generation to a fixed “simple” vocabulary subset, we discourage complex tokens with a controllable logit penalty derived from the same LM-based difficulty signal used for span masking. We tune the overall penalty strength $\lambda$ to control simplification aggressiveness, and we optionally adjust $\lambda$ adaptively based on the estimated asymmetry of the input (e.g., the mask ratio in the corrupted prompt). To avoid brittle behavior, we include an escape rule that relaxes the penalty when no adequate low-penalty alternative is available. We report the resulting trade-offs between simplicity (FKGL), quality (SARI), and meaning preservation (Sen-Sim) across different decoding strengths.

4.1.6. Implementation and Model Selection

We use the ASSET validation set for model selection and hyperparameter tuning. In the new framework, the main tunable factors are the asymmetry-aware prompting configuration (e.g., mask rate, maximum number of masked spans, and the span-selection criterion based on LM reconstruction difficulty), whether paraphrase context is included, and the decoding control parameters for the soft/adaptive penalty (e.g., the base penalty strength ${\lambda }_0$, the adaptive scaling coefficient k, and the escape-rule thresholds). We report the final results on the corresponding test sets of ASSET and TurkCorpus. To ensure a fair comparison across methods, we keep the evaluation pipeline fixed and compute all automatic metrics using the same toolkits described in Section 4.

4.1.7. Comparison Methods

Since our approach is training-free and does not require labeled simplification pairs, our primary training-free comparators are (i) GPT-based zero-shot prompting and (ii) ablations of our own inference-time controls (e.g., random masking, removing paraphrase context, and disabling the soft/adaptive decoding penalty). For GPT prompting, we use a simple instruction designed to preserve meaning while encouraging simplification, e.g., “Please simplify the following text while preserving the core meaning” (Table 1).

We additionally compare against strong training-based baselines, including two state-of-the-art unsupervised TS systems (MUSS [3] and Trans-SS [4]) and one supervised controllable model (ACCESS [22]). For completeness, we also report the results from fine-tuned encoder–decoder baselines where applicable, following the standard evaluation protocols for ASSET and TurkCorpus.

4.2. Evaluation Metrics

We evaluate simplification quality on two standard benchmarks, ASSET [50] and TurkCorpus, using SARI [15]. ASSET is widely regarded as the stronger benchmark because it provides increasingly diverse references, including more abstractive transformations [50]. We therefore treat ASSET as the primary dataset for model selection and reporting.

To quantify simplicity, we report FKGL (Flesch–Kincaid Grade Level) and a reference-free lexical complexity (LC) measure. All automatic metrics are computed with the EASSE framework [51]. For reference-based semantic similarity, prior work has noted that BLEU correlates poorly with TS goals [52], while BERTScore provides a stronger alternative [53,54]. We therefore report BERTScore F1 between system outputs and references using the “deberta-xlarge-mnli” scorer (https://github.com/Tiiiger/bert_score (accessed on 4 February 2026)). We do not report ROUGE because it mainly rewards n-gram overlap and is standard for summarization; for simplification, SARI better captures keep/add/delete operations.

Finally, because meaning preservation is critical in TS but is often under-captured by reference-based metrics [47], we report a reference-free sentence similarity (Sen-Sim) between the original and simplified sentences. We compute the cosine similarity of Sentence-BERT embeddings using “all-mpnet-base-v2” (Models listed at https://www.sbert.net/index.html (accessed on 4 February 2026)) [55].

4.3. Main Results

Table 2 summarizes performance across prompting and decoding variants of our framework and compares them with supervised and training-free baselines.

Table 2. Performance comparison on ASSET and TurkCorpus. BERT scores are rounded to two decimal places. The best configuration (Soft+Adaptive+Escape) achieves top SARI scores on ASSET while reducing linguistic complexity. Bold values indicate the best experimental results. ↑ indicates larger values are better, ↓ indicates lower values are better.

Method	FKGL ↓	ASSET		TurkCorpus		LC ↓	Sen-Sim ↑
		Sari ↑	Bert ↑	Sari ↑	Bert ↑
Supervised Baselines
ACCESS	$7.29$	$40.13$	$0.90$	$41.38$	$0.90$	$7.94$	$0.948$
MUSS	$8.79$	$42.65$	−	$40.85$	−	−	−
Trans-SS	$8.97$	$42.69$	$0.94$	$\mathit{41}.\mathit{97}$	$0.93$	$8.13$	$\mathit{0}.\mathit{952}$
Unsupervised/Zero-Shot Baselines
GPT-4o	$7.20$	$42.23$	$0.89$	$39.18$	$0.79$	$7.15$	$0.817$
Our Framework (Ablations)
BART-Large + $M_{\mathrm{rand}}$ (random)	$8.60$	$34.82$	$0.79$	$35.40$	$0.78$	$8.25$	$0.815$
BART-Large + $M_{\mathrm{asym}}$ (asym spans)	$8.15$	$38.20$	$0.85$	$37.90$	$0.84$	$7.95$	$0.894$
+ P (offline para. context)	$7.65$	$40.53$	$0.87$	$39.20$	$0.86$	$7.60$	$0.922$
+ Soft (fixed $\lambda$)	$7.31$	$41.75$	$0.88$	$40.53$	$0.88$	$7.35$	$0.946$
+ Soft+Adaptive	$7.26$	$42.45$	$0.91$	$41.20$	$0.90$	$7.10$	$0.942$
+ Soft+Adaptive+Escape	$7.32$	$42.80$	$0.92$	$41.85$	$0.92$	$\mathit{6}.\mathit{90}$	$0.941$
BART-Base + Soft+Adapt+Esc	$7.50$	$41.60$	$0.89$	$39.80$	$0.87$	$7.55$	$0.935$
BART-Large-CNN + Soft+Adapt+Esc	$\mathit{7}.\mathit{10}$	$\mathit{42}.\mathit{90}$	$\mathit{0}.\mathit{91}$	$41.10$	$\mathit{0}.\mathit{94}$	$7.15$	$0.948$

4.3.1. Effect of Targeted Corruption and Contextual Guidance

We first examine the impact of how the input is corrupted and whether additional context is provided. Random masking with BART-Large yields relatively weak overall performance (SARI $34.82$ on ASSET) and low meaning preservation (Sen-Sim $0.815$), indicating that indiscriminate noise can obscure essential content. Replacing random masking with asymmetry-aware span masking substantially improves both quality and adequacy: SARI increases from $34.82$ to $38.20$ on ASSET and Sen-Sim rises from $0.815$ to $0.894$.

Adding offline paraphrase context further strengthens meaning preservation and reference overlap. With $M_{\mathrm{asym}}+P$, Sen-Sim increases to $0.922$ while SARI improves to $40.53$ on ASSET and $39.20$ on TurkCorpus. This supports the role of paraphrase context as an explicit semantic anchor that stabilizes reconstruction when corruption removes informative spans [47].

4.3.2. Benefits of Soft/Adaptive Decoding for Complexity Control

Starting from $M_{\mathrm{asym}}+P$, incorporating soft decoding consistently improves the simplicity–quality trade-off. A fixed logit penalty (Soft) increases ASSET SARI from $40.53$ to $41.75$ while reducing FKGL from $7.65$ to $7.31$ and maintaining strong Sen-Sim ($0.946$). Introducing an adaptive schedule yields further gains: Soft+Adaptive reaches SARI $42.45$ on ASSET and $41.20$ on TurkCorpus, with FKGL $7.26$ and LC $7.10$.

Finally, adding an escape mechanism improves robustness when simplification pressure conflicts with adequacy. Soft+Adaptive+Escape achieves the strongest ASSET SARI among our BART-Large variants ($42.80$) and remains competitive on TurkCorpus (SARI $41.85$), while achieving the lowest LC ($6.90$).

4.4. Failure Cases and Error Analysis

While our asymmetry-aware denoising framework improves the simplicity–fidelity trade-off in many settings, we observed several recurring failure modes. Table 3 presents representative examples and highlights the limitations of difficulty-driven masking and soft complexity control.

Table 3. Representative failure cases for the proposed framework.

Input (Complex)	Output (Ours)	Issue
The committee ratified the proposal, which, despite objections from several members, was implemented immediately.	The committee approved the proposal, and it was implemented immediately.	Missing nuance (drops concessive clause).
The Cassini orbiter and the ESA Huygens probe are the primary components of the spacecraft.	The Cassini orbiter and the ESA Huygens probe are the main parts of the spacecraft.	Over-simplification risk for domain terminology.
Jeddah is the main gateway to Mecca, which can only be visited by able-bodied Muslims once in their lifetime.	Jeddah is the main way to Mecca, which can only be visited by Muslims once in their lifetime.	Meaning shift (drops key qualifier).

These cases suggest that the approach is strongest at the lexical/phrase-level simplification but can struggle with (i) long-range syntactic structures (embedded clauses, concessives), (ii) domain-specific terminology where “rarity” is not equivalent to reader difficulty, and (iii) sentences whose meaning depends on qualifiers (negation, modality, scope, or restrictive modifiers). Future work could incorporate explicit syntactic difficulty signals (e.g., dependency depth or clause boundaries), domain-adaptive difficulty calibration, and stronger adequacy checks (e.g., contradiction detection) to reduce meaning drift.

5. Ablation Study

5.1. Sentence Masking Strategy

We study how different masking strategies affect reconstruction quality and the simplicity–meaning trade-off.

5.1.1. Masking with Different Difficulty Thresholds

We corrupt sentences by replacing selected spans with the $⟨\mathtt{mask}⟩$ token. Unlike lexicon-based masking, our span selection is driven by model-derived reconstruction difficulty (Section 3.2). Concretely, we treat tokens/spans with a higher negative log-likelihood (NLL) under a frozen denoising-style objective as more asymmetry-inducing. We introduce a difficulty threshold $\theta$ (implemented as a quantile over token-level difficulty scores) to determine which spans are eligible for masking, and we report results for different values of $\theta$ in Table 4.

Table 4. Sensitivity to difficulty quantiles $\theta$ for asymmetry-aware span masking (using BART-Large-CNN + $M_{\mathrm{asym}}$). Setting $\theta =0.80$ yields the optimal trade-off, achieving a SARI score of 38.20 on ASSET, which serves as the baseline for our subsequent improvements. Bold values indicate the best experimental results. Bold values indicate the best experimental results. ↑ indicates larger values are better, ↓ indicates lower values are better.

Quantile $\mathit{\theta }$	SARI	SARI	FKGL
	(ASSET) ↑	(Turk) ↑	↓
0.60	$37.45$	$36.80$	$\mathit{6}.\mathit{95}$
0.70	$37.90$	$37.20$	$7.10$
0.75	$38.15$	$37.60$	$7.22$
0.80	$\mathit{38}.\mathit{20}$	$\mathit{37}.\mathit{90}$	$7.35$
0.90	$37.85$	$37.55$	$7.60$
0.95	$37.10$	$37.15$	$7.80$

Overall, higher quantiles (masking only the most difficult spans) lead to lighter corruption and encourage more local lexical edits, which can be beneficial on TurkCorpus, where references often emphasize lexical paraphrases [50]. Lowering the quantile to an optimal point ($\theta =0.80$) encourages more abstractive reconstruction and improves SARI on ASSET compared to lighter masking ($\theta =0.95$). However, extremely low quantiles (e.g., $0.60$) introduce excessive noise, degrading performance.

5.1.2. Masking Randomly with Different Rates

BART pre-training typically masks $15\%$ of input tokens. Prior work suggests that higher masking rates (e.g., $40\%$) are sometimes beneficial for reconstruction objectives in some settings [56]. We therefore vary the random masking rate for the random-masking control $M_{\mathrm{rand}}$ and report the results in Table 5.

Table 5. Impact of random masking rate on BART-Large + $M_{\mathrm{rand}}$. While increasing the masking rate to 40% improves performance compared to the standard 15% rate (SARI $34.82\to 38.45$), it still underperforms compared to our proposed adaptive framework (SARI 42.90). Bold values indicate the best experimental results. ↑ indicates larger values are better, ↓ indicates lower values are better.

Masking Rate	10%	15%	20%	40%	50%	80%
SARI (ASSET) ↑	33.52	34.82	36.15	38.45	37.90	31.20
SARI (Turk) ↑	34.10	35.40	36.55	37.10	36.80	30.50
FKGL ↓	8.95	8.60	8.25	7.40	7.10	5.50

We observe that moderate masking (40–50%) yields the best SARI on ASSET among the tested rates. However, excessively high masking rates can blur the reconstruction signal and degrade overall quality, suggesting that there is an optimal corruption level for reconstruction-based prompting.

5.2. Decoding Control Strength

We evaluate how decoding control affects the simplicity–fidelity trade-off by varying the strength of the soft complexity penalty (Section 3.3). As shown in Figure 3, increasing $\lambda$ (stronger penalty) generally reduces FKGL and lexical complexity more aggressively, while weaker penalties tend to improve meaning preservation (higher Sen-Sim) and reference overlap. SARI exhibits a trade-off: on ASSET, stronger simplification can increase the amount of beneficial rewriting up to a point, whereas overly strong penalties may harm adequacy and reduce overlap with references. Overall, the penalty strength provides a continuous and interpretable control knob for adapting output readability to different user needs without restricting the vocabulary to a fixed subset.

Figure 3. Impact of decoding control strength (penalty $\lambda$) on SARI, FKGL, and Sen-Sim. ↑ indicates larger values are better, ↓ indicates lower values are better.

5.3. Different Pre-Trained Models

We further compare different encoder–decoder denoising models of comparable scale. T5 [57] and its variants are pre-trained with a text-infilling objective [58,59]. For a fair comparison, we evaluate T5 under the same asymmetry-aware masking and paraphrase context configuration (Table 1) and keep all other settings identical to Section 4. The results are shown in Table 6.

Table 6. Impact of the underlying backbone model using our proposed framework (Soft + Adaptive + Escape). BART-Large consistently outperforms the Base variant and T5 baseline across all metrics, confirming that larger capacity benefits the controllable simplification task. Bold values indicate the best experimental results. Bold values indicate the best experimental results. ↑ indicates larger values are better, ↓ indicates lower values are better.

Metric	BART-Base	BART-Large	T5-Base
SARI (Turk) ↑	39.80	41.10	38.59
SARI (ASSET) ↑	41.60	42.90	39.27
FKGL ↓	7.50	7.10	7.56

Overall, BART variants outperform T5 in our setting, suggesting that the pre-training and reconstruction behavior of the backbone model influences performance for training-free simplification [60]. We also observe that BART-Large improves over BART-Base, indicating that model capacity is beneficial for our reconstruction-based prompting approach [58].

6. Discussion

6.1. Prompt Interpretability

An interpretable prompt should consist of transparent, human-understandable signals that make it clear what the model is expected to do and where it should act. Our approach improves interpretability in two ways. First, we explicitly reformulate text simplification as a denoising reconstruction task by masking high-asymmetry spans (difficulty-selected) while preserving named entities. This provides a direct and inspectable rationale: the $⟨\mathrm{mask}⟩$ tokens indicate precisely which parts are intended to be simplified. Second, we append a paraphrased context to support meaning preservation, which makes the source of semantic guidance explicit rather than implicit in the model parameters.

In addition to the prompt design, our decoding procedure further increases transparency. By explicitly discouraging complex tokens via a transparent logit penalty, we introduce an interpretable control mechanism over lexical simplicity. Compared with fine-tuning approaches—where simplification behavior is encoded implicitly in model weights—our method exposes both the simplification targets (via masking) and the allowed lexical preferences (via an explicit complexity penalty over logits), making the overall behavior easier to inspect and reason about.

6.2. Soft Complexity Control Instead of Hard Answer-Space Restriction

Hard answer-space restriction enforces simplicity by removing complex tokens entirely and renormalizing probability mass over the remaining candidates. While effective when adequate simple alternatives exist, this can be brittle: if an excluded token is important for adequacy, the decoder may be forced into unnatural substitutions, and the effect can accumulate across beam-search steps.

Our approach replaces hard restriction with a soft, complexity-aware penalty on logits (Section 3.3). This preserves the option to generate complex tokens when necessary, while still steering the search toward simpler lexical choices in most contexts. The adaptive schedule and escape mechanism further improve robustness by strengthening control for high-asymmetry inputs and relaxing it when simplicity pressure would otherwise harm adequacy. As a result, the method provides more stable controllability and avoids failure modes caused by removing large portions of probability mass.

7. Conclusions

This paper presents a training-free text simplification method that combines a denoising encoder–decoder model with asymmetry-aware prompting and soft, adaptive decoding control. We replace asymmetry-inducing spans with $⟨\mathtt{mask}⟩$ tokens to trigger denoising reconstruction, optionally append an offline paraphrase context to stabilize meaning, and guide generation with a soft complexity penalty that can be adapted to the estimated difficulty of the input. The experimental results on ASSET and TurkCorpus show that the proposed decoding control provides an effective switch for the trade-off between simplicity and fidelity: stronger penalties yield simpler outputs (lower FKGL/LC), while weaker penalties improve semantic similarity (higher Sen-Sim) and reference overlap. Despite using a substantially smaller model than large proprietary LLMs, our best configuration is competitive with strong baselines under standard TS metrics.

8. Limitations

Our difficulty estimation is induced from a frozen model via reconstruction difficulty statistics. While this avoids external lexicons, it can inherit biases from the backbone model and may be sensitive to domain shift: tokens that are rare in the model’s pre-training distribution may be treated as complex even when they are appropriate for the target audience. In addition, our masking signal focuses primarily on lexical/phrase-level difficulty and does not explicitly model syntactic complexity. Sentences can remain challenging due to long-range dependencies, dense clause structure, or discourse-level phenomena even when local lexical choices are simplified. Finally, we prioritized reproducible automatic metrics (SARI, FKGL) over human evaluation to avoid subjective bias from small sample sizes. Comprehensive human evaluation assessing fluency and adequacy is planned for future work.