Al-Kindī, Frequency Analysis, and the Birth of Cryptanalysis: Letter Counting, Hidden Messages, and Algorithmic Inference

Last Updated June 22, 2026

Al-Kindī, Frequency Analysis, and the Birth of Cryptanalysis examines a decisive moment in the history of algorithmic reasoning: the recognition that hidden messages could be attacked by counting patterns in language. In the Islamic-world history of mathematics, language, and computation, al-Kindī’s work on deciphering encrypted messages stands out because it connects textual analysis, probability-like reasoning, linguistic regularity, and procedural codebreaking.

This article treats frequency analysis as an early form of statistical algorithmic inference. The basic insight is simple but profound: languages do not use letters evenly. Some letters appear more often than others. If a substitution cipher replaces each plaintext letter with a cipher symbol, the cipher symbols inherit the statistical pattern of the original language. A cryptanalyst can therefore count symbols, compare frequencies, propose substitutions, test hypotheses, and revise the solution.

The importance of al-Kindī’s cryptanalytic work is that it shows algorithmic reasoning moving beyond arithmetic, algebra, astronomy, and mapping into linguistic evidence. The hidden message becomes a dataset. The alphabet becomes a distribution. Repeated symbols become clues. Frequency becomes inference. Deciphering becomes a disciplined procedure rather than guesswork.

This article introduces al-Kindī, frequency analysis, classical cryptanalysis, substitution ciphers, letter counting, Arabic linguistic statistics, cipher symbols, plaintext comparison, hypothesis testing, pattern recognition, manuscript cryptology, linguistic regularity, early statistical inference, codebreaking procedure, and the broader history of algorithmic reasoning. It argues that cryptanalysis belongs in this series because it reveals an early union of language, data, probability-like judgment, and procedural inference.

Why Al-Kindī Matters

Al-Kindī matters because his cryptanalytic work gives one of the clearest early examples of inference from data. A message is hidden. The method does not simply try possible meanings at random. It counts, compares, ranks, hypothesizes, and tests. This is computational reasoning applied to language.

The historical importance is not that al-Kindī invented secrecy, writing, ciphers, or all forms of codebreaking. Many earlier cultures used secret writing, substitution, transposition, diplomatic concealment, and scribal techniques. The importance is narrower and more powerful: his treatise is associated with the earliest known surviving description of frequency-analysis cryptanalysis, a method that uses statistical regularities of language to attack substitution ciphers.

Al-Kindī’s method is important because it shows that hidden meaning can be approached through pattern, evidence, and procedure.

Back to top ↑

Cryptography and Cryptanalysis

Cryptography and cryptanalysis are related but different. Cryptography concerns the making of systems that conceal messages. Cryptanalysis concerns the study and attack of those systems. A cipher hides meaning through transformation. A cryptanalytic method tries to recover meaning without ordinary access to the key.

In the history of algorithmic reasoning, this distinction matters. Encryption is one kind of procedure. Decryption by intended recipient is another. Cryptanalysis is adversarial inference: it tries to exploit patterns, errors, regularities, weaknesses, or constraints in the system.

Cryptanalysis is algorithmic because it turns limited evidence into a structured search for hidden structure.

Back to top ↑

Frequency Analysis as Algorithmic Inference

Frequency analysis begins with a pattern: letters in a language occur with different regularities. Some are common, some rare, and some appear in characteristic combinations. If a substitution cipher preserves one-to-one replacement, those patterns often survive beneath the disguise. The symbols change, but the distribution remains informative.

This is algorithmic inference because the method proceeds step by step. Count the cipher symbols. Rank them by frequency. Compare the ranking to a reference text in the same language. Propose likely substitutions. Test whether the resulting fragments form plausible words. Revise as needed.

The method is not guaranteed, but it is disciplined: evidence narrows the search space.

Back to top ↑

Language as Statistical Evidence

Frequency analysis depends on the idea that language has measurable regularities. Letters, sounds, word endings, prefixes, common particles, repeated phrases, and syntactic patterns do not appear randomly. A text carries statistical traces of its language even after some transformations.

This insight turns language into evidence. The cryptanalyst does not need to understand the message immediately. The first task is to measure it. Count symbols. Identify repeated pairs. Look for one-letter words, common endings, repeated clusters, or impossible combinations. The cipher is treated as data.

Language becomes computational when its regularities can be counted, compared, and used for inference.

Back to top ↑

Substitution Ciphers and Pattern Preservation

Frequency analysis works especially well against simple monoalphabetic substitution ciphers because these systems preserve many statistical properties of the plaintext. If the same plaintext letter always becomes the same cipher symbol, frequency patterns remain visible. The disguise changes names, not distribution.

This is a crucial algorithmic lesson: transformations can hide content while preserving structure. Cryptanalysis exploits preserved structure. A system is vulnerable when the information it leaks is enough to infer the hidden mapping.

A weak cipher hides symbols but leaks patterns.

Back to top ↑

Counting Letters and Ranking Symbols

Counting is the bridge between language and inference. The cryptanalyst counts each symbol in the ciphertext and then ranks symbols by frequency. The most common cipher symbol may correspond to the most common letter in the plaintext language, but the method does not stop there. Single counts must be checked against words, context, repeated patterns, and neighboring symbols.

The key is that counting reduces disorder. A page of cipher symbols can feel opaque. A frequency table gives structure. It makes some hypotheses more plausible than others and turns decipherment into a process of evidence-weighted search.

Frequency analysis begins with a humble computational act: count the signs.

Back to top ↑

Hypothesis Testing and Revision

Frequency analysis is not a mechanical one-pass recipe. The most frequent cipher symbol does not always correspond cleanly to the most frequent plaintext letter. Short messages distort frequencies. Topics affect vocabulary. Scribes make mistakes. Cipher designers may add tricks. Languages vary by genre and period. Therefore the cryptanalyst must treat each substitution as a hypothesis.

A proposed mapping is tested by applying it to the ciphertext and asking whether the emerging plaintext is plausible. If fragments make sense, the hypothesis gains support. If they produce impossible forms, the mapping is revised. This cycle of hypothesis and revision makes cryptanalysis an early example of iterative inference.

Cryptanalysis is not only counting. It is counting guided by judgment.

Back to top ↑

Arabic Textual Culture and Linguistic Analysis

Al-Kindī’s cryptanalytic method emerged in a rich textual culture. Arabic scholarship included grammar, lexicography, Qur’anic study, poetry, logic, mathematics, translation, philosophy, and administrative writing. Letter counting and attention to linguistic form made sense in a world where textual analysis was highly developed.

This background matters because frequency analysis depends on language knowledge. To compare cipher symbols with plaintext letters, one must know or estimate the distribution of letters in the target language. To test partial decryptions, one must recognize plausible words and forms. Cryptanalysis is therefore both mathematical and philological.

Frequency analysis sits where mathematics, language, and institutions meet.

Back to top ↑

Cryptanalysis Before Modern Statistics

Modern statistics had not yet taken its later formal shape, but frequency analysis uses a recognizable statistical intuition: observed counts can reveal hidden structure. A ciphertext sample is not treated as a meaningless surface. It is treated as evidence generated by an underlying process.

This is why al-Kindī’s method matters for the history of computational reasoning. It anticipates later forms of data analysis without being identical to them. It uses relative frequency, comparison, ranking, sample size, and inference under uncertainty. It is an early example of quantitative reasoning over language.

Cryptanalysis is one of the earliest places where counting language became a tool of inference.

Back to top ↑

Procedure, Not Magic

Codebreaking is often portrayed as genius, secrecy, or sudden revelation. Al-Kindī’s method shows something more durable: procedure. The hidden message is approached through steps that others can learn. Count. Rank. Compare. Substitute. Test. Revise. Verify.

This procedural structure is what makes cryptanalysis part of algorithmic history. The method is teachable and repeatable. It can fail, improve, and adapt. It depends on evidence rather than intuition alone. It also shows the limits of procedure: without enough text, good reference knowledge, or appropriate assumptions, frequency analysis may mislead.

Cryptanalysis is disciplined reasoning under partial information.

Back to top ↑

Limits, Countermeasures, and Adaptation

Frequency analysis is powerful against simple substitution, but it has limits. Short ciphertexts may not reflect normal letter frequencies. Homophonic substitution can flatten frequencies by using multiple symbols for common letters. Polyalphabetic methods can vary the substitution across positions. Removing spaces, inserting null symbols, changing spelling, or using codebooks can complicate analysis.

This adversarial cycle matters. Cryptanalysis improves ciphers, and improved ciphers force new cryptanalytic methods. The relationship is recursive: defense creates challenge, attack finds weakness, defense adapts. This is another reason cryptanalysis belongs in algorithmic reasoning: it is a history of procedure under opposition.

Every cryptanalytic method teaches both how to attack and how to defend.

Back to top ↑

From Manuscript Codebreaking to Modern Security

Modern cryptography is mathematically far more complex than classical substitution ciphers, and frequency analysis alone does not break well-designed modern encryption. Still, the historical lesson remains relevant: systems leak information through patterns, assumptions, side channels, reused structures, weak randomness, implementation errors, and human practice.

The continuity is methodological rather than technical. Modern security analysis still asks: what information is observable? What pattern survives transformation? What assumptions does the defender rely on? What evidence can an analyst gather? What hypothesis explains the observed data? What test can distinguish one hypothesis from another?

The modern lesson is not “use frequency analysis on modern encryption.” The lesson is that security depends on what structure remains visible.

Back to top ↑

Origin Stories and Careful Interpretation

The phrase “birth of cryptanalysis” should be used carefully. Secret writing, ciphering, and code systems existed long before al-Kindī. What al-Kindī represents is more specific: a foundational surviving account of systematic, frequency-based cryptanalysis. This is the birth of documented statistical codebreaking in the record available to historians, not the invention of secrecy itself.

Careful interpretation also avoids isolating al-Kindī from his intellectual environment. His work makes sense within Arabic textual culture, mathematics, administration, linguistic study, translation, and broader Islamic-world scholarship. It also connects to later cryptologic traditions that adapted and expanded codebreaking methods.

Al-Kindī’s cryptanalysis should be read as a milestone in procedural inference, not as a simplified origin myth.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

A simple frequency count can be represented as:

Relative frequency can be represented as:

A substitution mapping can be represented as:

A basic inference loop can be modeled as:

These formulas use modern notation to make the computational structure visible. They are interpretive models, not claims that al-Kindī wrote in this exact symbolic form.

Back to top ↑

Python Workflow: Frequency Analysis and Cryptanalysis Map

The Python workflow below creates a dependency-light interpretive map of al-Kindī, frequency analysis, and cryptanalysis. It scores themes by linguistic evidence, counting procedure, inferential structure, cryptanalytic relevance, historical significance, ethical caution, and modern resonance, then writes reproducible CSV and JSON outputs.

# al_kindi_frequency_analysis_cryptanalysis_map.py
# Dependency-light workflow for mapping frequency analysis as early cryptanalytic inference.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
from statistics import mean
from collections import Counter
import csv
import json
from datetime import datetime, timezone

ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"
JSON_DIR = ARTICLE_ROOT / "outputs" / "json"


@dataclass(frozen=True)
class CryptanalysisConfig:
    article: str = "al_kindi_frequency_analysis_and_the_birth_of_cryptanalysis"
    core_threshold: float = 0.80
    high_inference_threshold: float = 0.86


def timestamp_utc() -> str:
    return datetime.now(timezone.utc).isoformat()


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        path.write_text("", encoding="utf-8")
        return
    fieldnames = sorted({key for row in rows for key in row.keys()})
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")


def frequency_table(text: str) -> list[dict[str, object]]:
    symbols = [ch.lower() for ch in text if ch.isalpha()]
    total = len(symbols)
    counts = Counter(symbols)
    rows = []
    for symbol, count in counts.most_common():
        rows.append({
            "symbol": symbol,
            "count": count,
            "relative_frequency": round(count / total, 6) if total else 0.0,
            "rank": len(rows) + 1,
        })
    return rows


def cryptanalysis_themes() -> list[dict[str, object]]:
    return [
        {"theme_id": "letter_counting_as_feature_extraction", "linguistic_evidence": 0.96, "counting_procedure": 0.98, "inferential_structure": 0.90, "cryptanalytic_relevance": 0.94, "historical_significance": 0.94, "ethical_caution": 0.82, "modern_resonance": 0.94},
        {"theme_id": "frequency_ranking_and_comparison", "linguistic_evidence": 0.98, "counting_procedure": 0.96, "inferential_structure": 0.94, "cryptanalytic_relevance": 0.96, "historical_significance": 0.94, "ethical_caution": 0.82, "modern_resonance": 0.96},
        {"theme_id": "substitution_mapping_hypothesis", "linguistic_evidence": 0.90, "counting_procedure": 0.86, "inferential_structure": 0.96, "cryptanalytic_relevance": 0.98, "historical_significance": 0.92, "ethical_caution": 0.84, "modern_resonance": 0.94},
        {"theme_id": "testing_and_revision", "linguistic_evidence": 0.88, "counting_procedure": 0.84, "inferential_structure": 0.98, "cryptanalytic_relevance": 0.94, "historical_significance": 0.90, "ethical_caution": 0.86, "modern_resonance": 0.96},
        {"theme_id": "arabic_textual_culture", "linguistic_evidence": 0.94, "counting_procedure": 0.86, "inferential_structure": 0.88, "cryptanalytic_relevance": 0.88, "historical_significance": 0.96, "ethical_caution": 0.82, "modern_resonance": 0.88},
        {"theme_id": "limits_and_countermeasures", "linguistic_evidence": 0.86, "counting_procedure": 0.88, "inferential_structure": 0.92, "cryptanalytic_relevance": 0.94, "historical_significance": 0.88, "ethical_caution": 0.94, "modern_resonance": 0.96},
        {"theme_id": "early_statistical_inference", "linguistic_evidence": 0.94, "counting_procedure": 0.96, "inferential_structure": 0.96, "cryptanalytic_relevance": 0.92, "historical_significance": 0.96, "ethical_caution": 0.84, "modern_resonance": 0.98},
    ]


def score_theme(row: dict[str, object], config: CryptanalysisConfig) -> dict[str, object]:
    cryptanalysis_score = mean([
        float(row["linguistic_evidence"]),
        float(row["counting_procedure"]),
        float(row["inferential_structure"]),
        float(row["cryptanalytic_relevance"]),
        float(row["historical_significance"]),
        float(row["ethical_caution"]),
        float(row["modern_resonance"]),
    ])

    if cryptanalysis_score >= config.core_threshold and float(row["inferential_structure"]) >= config.high_inference_threshold:
        interpretive_status = "core_cryptanalysis_thread"
    elif cryptanalysis_score >= config.core_threshold:
        interpretive_status = "major_cryptanalysis_thread"
    else:
        interpretive_status = "supporting_cryptanalysis_thread"

    return {
        "theme_id": row["theme_id"],
        "linguistic_evidence": round(float(row["linguistic_evidence"]), 6),
        "counting_procedure": round(float(row["counting_procedure"]), 6),
        "inferential_structure": round(float(row["inferential_structure"]), 6),
        "cryptanalytic_relevance": round(float(row["cryptanalytic_relevance"]), 6),
        "historical_significance": round(float(row["historical_significance"]), 6),
        "ethical_caution": round(float(row["ethical_caution"]), 6),
        "modern_resonance": round(float(row["modern_resonance"]), 6),
        "cryptanalysis_score": round(cryptanalysis_score, 6),
        "interpretive_status": interpretive_status,
    }


def interpretation_cautions() -> list[dict[str, str]]:
    return [
        {"caution": "do_not_claim_al_kindi_invented_all_cryptography", "meaning": "Al-Kindī is central to surviving systematic frequency-analysis cryptanalysis, not all secrecy or ciphering."},
        {"caution": "do_not_treat_frequency_analysis_as_magic", "meaning": "The method depends on counting, comparison, hypothesis testing, and revision."},
        {"caution": "do_not_project_modern_statistics_backward", "meaning": "The method anticipates statistical inference without being modern formal statistics."},
        {"caution": "do_not_ignore_language_context", "meaning": "Cryptanalysis depends on linguistic regularity, genre, spelling, and textual knowledge."},
        {"caution": "do_not_turn_attack_methods_into_unbounded_security_advice", "meaning": "Use examples for historical and educational analysis, not unauthorized access."},
    ]


def main() -> None:
    config = CryptanalysisConfig()
    sample_ciphertext = "XLMW MW E WLSVX IHYGERXMSREP WEQTPI JSV JVIUYIRGC EREP]WMW"
    freq_rows = frequency_table(sample_ciphertext)
    themes = cryptanalysis_themes()
    scored = [score_theme(row, config) for row in themes]
    cautions = interpretation_cautions()

    summary = {
        "article": config.article,
        "timestamp_utc": timestamp_utc(),
        "sample_symbols_reviewed": sum(int(row["count"]) for row in freq_rows),
        "themes_reviewed": len(scored),
        "core_threads": sum(1 for row in scored if row["interpretive_status"] == "core_cryptanalysis_thread"),
        "major_threads": sum(1 for row in scored if row["interpretive_status"] == "major_cryptanalysis_thread"),
        "supporting_threads": sum(1 for row in scored if row["interpretive_status"] == "supporting_cryptanalysis_thread"),
        "mean_cryptanalysis_score": round(mean(float(row["cryptanalysis_score"]) for row in scored), 6),
        "cautions": len(cautions),
        "interpretation": "Al-Kindī’s frequency-analysis method should be studied as early algorithmic inference over language: count, rank, compare, hypothesize, test, revise, and interpret.",
    }

    write_csv(TABLES / "sample_frequency_table.csv", freq_rows)
    write_csv(TABLES / "cryptanalysis_themes.csv", themes)
    write_csv(TABLES / "cryptanalysis_map.csv", scored)
    write_csv(TABLES / "interpretation_cautions.csv", cautions)
    write_csv(TABLES / "cryptanalysis_summary.csv", [summary])

    write_json(JSON_DIR / "cryptanalysis_config.json", asdict(config))
    write_json(JSON_DIR / "sample_frequency_table.json", freq_rows)
    write_json(JSON_DIR / "cryptanalysis_map.json", scored)
    write_json(JSON_DIR / "interpretation_cautions.json", cautions)
    write_json(JSON_DIR / "cryptanalysis_summary.json", summary)

    print("Al-Kindī, frequency analysis, and cryptanalysis map complete.")
    print(TABLES / "cryptanalysis_summary.csv")


if __name__ == "__main__":
    main()

This workflow turns cryptanalysis into a reproducible interpretive artifact: letter counts, relative frequencies, theme scores, inference structure, historical significance, ethical caution, modern resonance, and interpretive warnings are documented together.

Back to top ↑

R Workflow: Cryptanalysis Diagnostics

The R workflow reads the generated CSV outputs, summarizes cryptanalysis themes, visualizes theme dimensions, and writes an additional diagnostic table.

# al_kindi_frequency_analysis_cryptanalysis_summary.R
args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

map_path <- file.path(tables_dir, "cryptanalysis_map.csv")
freq_path <- file.path(tables_dir, "sample_frequency_table.csv")
summary_path <- file.path(tables_dir, "cryptanalysis_summary.csv")

if (!file.exists(map_path)) {
  stop(paste("Missing", map_path, "Run the Python workflow first."))
}

cryptanalysis_map <- read.csv(map_path, stringsAsFactors = FALSE)
frequency_table <- read.csv(freq_path, stringsAsFactors = FALSE)
summary <- read.csv(summary_path, stringsAsFactors = FALSE)

png(file.path(figures_dir, "cryptanalysis_dimensions.png"), width = 1200, height = 850)
score_matrix <- t(as.matrix(cryptanalysis_map[, c("linguistic_evidence", "counting_procedure", "inferential_structure", "cryptanalytic_relevance", "historical_significance", "ethical_caution", "modern_resonance")]))
barplot(score_matrix,
        beside = TRUE,
        names.arg = cryptanalysis_map$theme_id,
        las = 2,
        ylim = c(0, 1),
        ylab = "Interpretive Score",
        main = "Al-Kindī, Frequency Analysis, and Cryptanalysis Dimensions")
legend("bottomright",
       legend = rownames(score_matrix),
       cex = 0.72,
       bty = "n")
grid()
dev.off()

png(file.path(figures_dir, "sample_symbol_frequency.png"), width = 1000, height = 750)
barplot(frequency_table$relative_frequency,
        names.arg = frequency_table$symbol,
        ylab = "Relative Frequency",
        main = "Sample Cipher Symbol Frequencies")
grid()
dev.off()

r_summary <- data.frame(
  themes_reviewed = summary$themes_reviewed[1],
  core_threads = summary$core_threads[1],
  major_threads = summary$major_threads[1],
  supporting_threads = summary$supporting_threads[1],
  mean_cryptanalysis_score = summary$mean_cryptanalysis_score[1],
  sample_symbols_reviewed = summary$sample_symbols_reviewed[1],
  cautions = summary$cautions[1],
  diagnostic_note = "Al-Kindī’s frequency-analysis method should be studied as early algorithmic inference over language: count, rank, compare, hypothesize, test, revise, and interpret."
)

write.csv(r_summary, file.path(tables_dir, "r_cryptanalysis_diagnostic_summary.csv"), row.names = FALSE)
print(r_summary)

The R layer makes the interpretive structure visible: letter counting, frequency ranking, substitution hypotheses, testing, revision, Arabic textual culture, early statistical inference, countermeasures, and caution can be examined as related but distinct dimensions of cryptanalytic reasoning.

Back to top ↑

GitHub Repository

The companion repository contains reproducible workflows, synthetic interpretive data, outputs, calculators, documentation, and multilingual examples for this article.

Back to top ↑

A Practical Method for Studying Early Cryptanalysis

A careful study of early cryptanalysis should focus on procedure, language, evidence, and ethical context. The method below treats frequency analysis as a historical algorithmic method without turning it into unbounded security advice.

This method keeps al-Kindī’s work in view as disciplined inference: count, compare, hypothesize, test, revise, and interpret.

Back to top ↑

Common Pitfalls

The first pitfall is saying that al-Kindī invented all cryptography. The second is treating frequency analysis as magic rather than procedure. The third is projecting modern probability theory or modern cybersecurity backward too directly. The fourth is ignoring the ethical context of attack methods.

Cryptanalysis should be taught as historical reasoning, not as mystique or irresponsible attack culture.

Back to top ↑

Why Cryptanalysis Belongs in Algorithmic Reasoning

Al-Kindī, frequency analysis, and the birth of cryptanalysis belong in algorithmic reasoning because they show how hidden structure can be inferred from observable data. The message is concealed, but the language leaves traces. The cipher changes symbols, but patterns survive. The cryptanalyst counts, ranks, compares, hypothesizes, tests, and revises.

This history expands the meaning of computation. Computation is not only numerical arithmetic, algebra, astronomy, mapping, or machine execution. It is also structured inference over language. Al-Kindī’s method shows that symbols can be treated as data and that data can reveal a hidden process.

The lesson for modern systems is direct. Any algorithmic system may leak patterns. Security, privacy, and interpretation depend on what structure remains visible after transformation. Frequency analysis is historically specific, but the larger lesson is enduring: evidence, pattern, and procedure can turn the obscure into the intelligible. AI belongs in the toolkit, not in control.

Back to top ↑

Related Articles

• Geography, Coordinates, and Computational Mapping in the Islamic World
• Banū Mūsā, Mechanical Devices, and Procedural Engineering
• Al-Khwārizmī, Algorism, and the Procedural Imagination
• Hindu-Arabic Numerals and the Transmission of Positional Calculation
• Algorithmic Risk Management and AI Governance

Back to top ↑

Further Reading

• Broemeling, L.D. (2011) ‘An account of early statistical inference in Arab cryptology’, The American Statistician, 65(4), pp. 255–257.
• Kahn, D. (1996) The Codebreakers: The Comprehensive History of Secret Communication from Ancient Times to the Internet. Rev. edn. New York: Scribner.
• Singh, S. (1999) The Code Book: The Science of Secrecy from Ancient Egypt to Quantum Cryptography. New York: Doubleday.
• Ycart, B. (2012) ‘Letter counting: a stem cell for cryptology, quantitative linguistics, and statistics’. arXiv preprint.
• Mrayati, M., Alam, Y. and al-Tayyan, M.H. (2003) Ilm al-Taʿmiyah wa Istikhrāj al-Muʿammā ʿinda al-ʿArab. Damascus: Arab Academy of Damascus.
• 1001 Inventions (n.d.) ‘Code Breaking a Thousand Years Ago’.
• MacTutor History of Mathematics (n.d.) ‘Al-Kindī’. University of St Andrews.

Back to top ↑

References

• Broemeling, L.D. (2011) ‘An account of early statistical inference in Arab cryptology’, The American Statistician, 65(4), pp. 255–257. Available at: https://www.jstor.org/stable/23339552.
• Kahn, D. (1996) The Codebreakers: The Comprehensive History of Secret Communication from Ancient Times to the Internet. Rev. edn. New York: Scribner.
• MacTutor History of Mathematics (n.d.) ‘Al-Kindī’. University of St Andrews. Available at: https://mathshistory.st-andrews.ac.uk/Biographies/Al-Kindi/.
• Mrayati, M., Alam, Y. and al-Tayyan, M.H. (2003) Ilm al-Taʿmiyah wa Istikhrāj al-Muʿammā ʿinda al-ʿArab. Damascus: Arab Academy of Damascus.
• Singh, S. (1999) The Code Book: The Science of Secrecy from Ancient Egypt to Quantum Cryptography. New York: Doubleday.
• 1001 Inventions (n.d.) ‘Code Breaking a Thousand Years Ago’. Available at: https://www.1001inventions.com/code-breaking/.
• Ycart, B. (2012) ‘Letter counting: a stem cell for cryptology, quantitative linguistics, and statistics’. arXiv preprint. Available at: https://arxiv.org/abs/1211.6847.

Back to top ↑