Learn AI Create the Future — with Pranay
Main site

AI for Accessibility

Plain-language rewriting

Text simplification rewrites text into plainer words and shorter sentences while keeping every fact, which makes it a different, riskier task than summarisation.

Read these first

On this page 6
  1. Why it exists
  2. How it works
  3. Where you have already seen it
  4. An honest warning
  5. Remember this
  6. What to learn next

One lesson, three depths. Pick the one that fits you today — you can switch any time.

Beginner — No maths. Plain English.

Text simplification rewrites text into plainer words and shorter sentences, without dropping any of the facts.

Think about a parent reading a dense insurance letter, then explaining it to a ten-year-old in words the child would actually understand. Same information, simpler language.

Text simplification does that job automatically, rewriting a hard sentence into an easier one. It helps people with cognitive disabilities, dyslexia, low literacy, or anyone reading in a second language.

Why it exists

A great deal of important text — government forms, medical instructions, legal notices — is written in dense, formal language that assumes an educated, fluent reader. For someone with a reading disability, a cognitive disability, or limited literacy in the language it is written in, that same text can be genuinely unreadable. Nothing about the underlying information is actually complicated.

Text simplification exists to close that gap directly. It rewrites the same information in plainer words and shorter sentences, so the barrier is the language, not the reader's understanding of the topic.

How it works

Original:  "Prior to submitting the application, applicants must obtain
            sufficient documentation regarding their eligibility."
        |
        v  swap hard words for easier ones, split long sentences apart
Simplified: "Before you apply, you need documents that show you qualify."

The important constraint, and what makes this different from shortening text, is that every fact in the original has to survive. A sentence about a medicine's correct dosage cannot lose a number or a warning on the way to becoming simpler. That would trade one problem for a far more dangerous one.

Where you have already seen it

Newsela is a widely used education platform. It rewrites the same news article at several different reading levels, from advanced down to elementary, for students at different reading abilities. Some government and healthcare websites offer a "plain language" or "easy read" version of dense official text, aimed at exactly this need.

An honest warning

Text simplification is not the same task as abstractive summarisation — summarisation is allowed, and expected, to leave things out. Simplification is not. A simplifier that accidentally drops a warning, a number, or a condition while making a sentence shorter has not simplified the text. It has quietly made it wrong. That is a serious failure, for exactly the reader who has no easy way to notice what went missing.

Remember this

  • Text simplification rewrites language to be plainer and shorter, while keeping every fact from the original.
  • It exists for readers with cognitive disabilities, dyslexia, low literacy, or those reading in a second language, for whom dense formal writing is a real barrier.
  • Dropping a fact while simplifying is a serious failure, not an acceptable trade-off — this is what separates simplification from summarisation.

What to learn next

  • Predictive text for AAC devices — another accessibility task built on language modelling, aimed at typing speed instead of readability.
  • Text classification — a general NLP technique simplification systems can use to judge reading difficulty.
  • What is NLP? — the general field this lesson's technique belongs to.

Developer — Code and libraries.

This example builds a small rule-based simplifier — word swapping and sentence splitting — and measures the effect with a standard readability formula, rather than using a large trained model.

Setup

bash
python3 --version

No installation is needed — this example uses the Python standard library only.

Minimal runnable code

SIMPLE_WORDS maps a handful of formal words to everyday alternatives. split_long_sentences breaks apart sentences joined with "which" or "and." readability_score computes a simplified Flesch-Kincaid grade level — a well-known formula estimating how many years of education a piece of text assumes.

simplify.py
import re

# A hand-built dictionary swapping some formal words for everyday ones.
# Real tools use a model trained on aligned complex/simple sentence pairs;
# this rule-based version shows the two ideas simplification always combines:
# swapping words, and breaking up long sentences.
SIMPLE_WORDS = {
    "utilize": "use", "prior to": "before", "terminate": "end",
    "commence": "start", "additional": "more", "sufficient": "enough",
    "regarding": "about", "assistance": "help", "obtain": "get",
}

SPLIT_ON = [" which ", " and "]

def swap_words(text):
    for hard, easy in SIMPLE_WORDS.items():
        text = re.sub(rf"\b{hard}\b", easy, text, flags=re.IGNORECASE)
    return text

def split_long_sentences(text):
    for marker in SPLIT_ON:
        if marker in text:
            head, tail = text.split(marker, 1)
            text = head.rstrip(",") + ". " + tail[0].upper() + tail[1:]
    return text[0].upper() + text[1:]   # word-swapping can lowercase the very first letter

def count_syllables(word):
    word = word.lower().strip(".,")
    vowel_groups = re.findall(r"[aeiouy]+", word)
    return max(1, len(vowel_groups))

def readability_score(text):
    # a simplified Flesch-Kincaid grade level: harder text needs a higher grade
    sentences = [s for s in re.split(r"[.!?]+", text) if s.strip()]
    words = re.findall(r"[a-zA-Z]+", text)
    syllables = sum(count_syllables(w) for w in words)
    words_per_sentence = len(words) / len(sentences)
    syllables_per_word = syllables / len(words)
    return 0.39 * words_per_sentence + 11.8 * syllables_per_word - 15.59

original = ("Prior to submitting the application, applicants must obtain "
            "sufficient documentation regarding their eligibility, which "
            "the office will review and this can take additional time.")

step1 = swap_words(original)
step2 = split_long_sentences(step1)

print("original:  ", original)
print("simplified:", step2)
print()
print(f"readability grade level, original:   {readability_score(original):.1f}")
print(f"readability grade level, simplified: {readability_score(step2):.1f}")
Output
original:   Prior to submitting the application, applicants must obtain sufficient documentation regarding their eligibility, which the office will review and this can take additional time.
simplified: Before submitting the application, applicants must get enough documentation about their eligibility. The office will review. This can take more time.

readability grade level, original:   19.8
readability grade level, simplified: 13.5

Walkthrough

swap_words replaces each formal word with its plain-language equivalent throughout the text — "prior to" becomes "before," "sufficient" becomes "enough." split_long_sentences then breaks the one long, comma-heavy sentence into three shorter ones, at the natural joining words "which" and "and."

The readability score drops from a grade level of 19.8 — well beyond a graduate degree, for what started as a fairly ordinary official sentence — down to 13.5, still not simple, but a meaningful improvement from two small, mechanical changes. text[0].upper() + text[1:] fixes a real, easy-to-miss bug: swapping "Prior" for "before" silently lowercases the start of the sentence, since the replacement dictionary stores its plain-language versions in lowercase. Left unfixed, that would produce a sentence starting mid-word with a lowercase letter — a small error, and exactly the kind of easily overlooked mistake that erodes trust in an automated simplifier.

Common mistakes

Dropping information while shortening a sentence. This example never removes a clause, only rephrases and splits — the one rule that must never be broken, as covered in the honest warning above.

Forgetting to fix capitalisation after word substitution. Demonstrated directly in the walkthrough: a naive substitution can silently break the start of a sentence.

Treating a lower readability score as proof the text is now genuinely easier. Flesch-Kincaid and similar formulas measure sentence length and syllable count, not real comprehension. A short sentence built from unfamiliar words can score well on this formula while still confusing a reader.

Simplifying safety-critical text without a human review step. A medicine dosage instruction, a legal deadline, or a warning is exactly the kind of sentence where an automated tool's output needs a human check before publication — this lesson's toy example is for demonstration, not for rewriting anything a reader will actually rely on unchecked.

Try it yourself

Add "eligibility": "if you qualify" to SIMPLE_WORDS and rerun. Check whether the substitution reads naturally in context — this is a good small example of how word-for-word swapping can occasionally produce an awkward or even confusing result, which is why real simplification systems increasingly use models trained on real simplified sentence pairs rather than a fixed dictionary alone.

What to learn next

Researcher — Mathematics and papers.

The formal setting

Text simplification is commonly framed as a monolingual, meaning-preserving text-to-text generation task: f: X -> Y where X is complex text and Y is simplified text in the same language, subject to the constraint that Y preserves the propositional content of X while reducing lexical and syntactic complexity. This differs from summarisation, g: X -> Z where Z is permitted, and expected, to omit content — the constraint the developer example's "honest warning" is built around.

Readability formulas

The Flesch-Kincaid Grade Level formula used in the developer example:

FKGL = 0.39 · (words / sentences) + 11.8 · (syllables / words) - 15.59
  • words / sentences — average sentence length
  • syllables / words — average word complexity, syllables as a cheap proxy for morphological and lexical difficulty
  • The formula outputs an approximate U.S. school grade level

This formula, originating from Flesch's readability work (Flesch, 1948) and adapted for grade-level estimation (Kincaid et al., 1975), correlates with human-judged difficulty at a coarse level but is well documented to be gameable: replacing words with equally unfamiliar but shorter synonyms improves the score without improving real comprehension, and it captures nothing about syntactic complexity beyond raw sentence length, or about a reader's actual background knowledge.

Text-to-text neural approaches

Modern text simplification systems are trained on aligned complex-simple sentence pairs, most notably from Simple English Wikipedia and the Newsela corpus (Xu, Callison-Burch and Napoles, 2015), and framed as a sequence-to-sequence or, more recently, large-language-model prompting task. Xu et al.'s central finding — reinforced by the comprehensive survey and benchmark of Alva-Manchego, Scarton and Specia (2020) — is that automatic evaluation metrics borrowed from machine translation (BLEU) correlate poorly with human judgments of simplification quality specifically, since a metric rewarding closeness to a single reference simplification penalises equally valid alternative rewrites, and does not penalise dropped content the way this lesson's constraint requires.

Evaluation, done properly

Alva-Manchego, Scarton and Specia (2020) recommend evaluating simplification along three separate axes rather than one blended score:

  • Fluency — is the output grammatical?
  • Adequacy / meaning preservation — does the output retain the original's factual content?
  • Simplicity — is the output genuinely easier to read than the original?

A system can score well on any one axis while failing badly on another — a fluent, simple sentence that has silently dropped a fact scores well on the first two and catastrophically on the constraint that matters most for this domain.

Complexity and cost

For text of n words:

ComponentTypical cost
Readability scoring (developer example)O(n), a single pass
Rule-based lexical substitutionO(n · d), d = dictionary size, using efficient string matching
Neural sequence-to-sequence simplificationone forward pass through an encoder-decoder or LLM, cost scaling with model size and output length

Papers

  • Flesch, R. (1948). A New Readability Yardstick. Journal of Applied Psychology 32(3). The origin of the Flesch readability formulas.
  • Kincaid, J. et al. (1975). Derivation of New Readability Formulas. U.S. Naval Air Station Memphis Research Branch Report. Establishes the grade-level variant used in the developer example.
  • Xu, W., Callison-Burch, C. and Napoles, C. (2015). Problems in Current Text Simplification Research: New Data Can Help. Transactions of the Association for Computational Linguistics 3. Introduces the Newsela corpus and critiques Simple-Wikipedia-based evaluation.
  • Alva-Manchego, F., Scarton, C. and Specia, L. (2020). Data-Driven Sentence Simplification: Survey and Benchmark. Computational Linguistics 46(1).

Current state

Large language models have substantially improved simplification fluency and made controllable simplification (targeting a specific grade level or vocabulary constraint on demand) far more practical, while the field's core measurement problem — reliably detecting when meaning has been silently lost — remains only partially solved, since automatic factual-consistency checking is itself an open research problem shared with summarisation and other generation tasks. Any deployment of automated simplification for genuinely safety-relevant text, such as medical or legal content, still warrants human review before publication, precisely because the failure mode this lesson highlights — a fluent, readable, factually wrong simplification — is difficult for either automatic metrics or a rushed human reviewer to catch reliably.

What to learn next

  • Text classification — the general technique underlying automated readability and difficulty classification.
  • Named entity recognition — identifying the specific facts a simplifier must never drop.
  • Hallucination — the closely related problem of a generative model introducing or omitting facts, in the context of large language models generally.