Algorithms Before Symbols: Verbal Procedures in Medieval Mathematics and the History of Algorithmic Reasoning

Last Updated June 23, 2026

Algorithms Before Symbols examines how medieval mathematics could be procedural before it became symbolic in the modern sense. Many mathematical rules were written in ordinary language, worked examples, diagrams, tables, recipes, and problem classifications rather than in compact algebraic notation. Yet these procedures could still be precise, repeatable, teachable, and computationally meaningful.

This article treats verbal procedure as a major root of algorithmic reasoning. Before equations were routinely written with symbolic variables, before modern function notation, before programming languages, and before automated computation, mathematical authors described operations in words. They told the reader what to do: take a number, multiply it, restore a term, balance a relation, divide by a quantity, complete a square, consult a table, interpolate between entries, check the result, or repeat a procedure for another case.

The point is not that medieval verbal mathematics was secretly modern code. It was not. The point is subtler and more important: algorithmic structure can exist before symbolic notation. A procedure can be expressed rhetorically. A problem can be classified verbally. A transformation can be justified geometrically. A calculation can be taught through examples. A sequence of operations can be made public, repeatable, and transmissible without modern algebraic syntax.

This article introduces verbal procedure, rhetorical algebra, medieval arithmetic recipes, rule-governed calculation, problem classification, unknown quantities before symbolic variables, worked examples, geometric demonstration, table lookup, interpolation, practical reckoning, Latin algorism, Islamic-world algebraic instruction, Sanskrit and Arabic mathematical prose, transmission through manuscripts, and the distinction between algorithmic structure and modern notation. It argues that algorithms should be studied not only as symbolic formulas or computer code, but also as public procedures written in language.

Why Verbal Procedures Matter

Verbal procedures matter because they show that algorithmic reasoning is older than modern notation. A method can be expressed in prose and still have input, transformation, order, condition, stopping point, and verification. The procedure may not look like code, but it can still tell a trained reader how to move from a problem to a result.

In medieval mathematics, verbal procedures were common. Arithmetic instructions, algebraic transformations, inheritance calculations, astronomical table rules, commercial reckoning methods, geometric demonstrations, and pedagogical examples often used language to guide action. The reader did not merely contemplate a theorem. The reader performed a sequence.

Verbal mathematics is not a primitive failure to be symbolic. It is a historical form of procedural precision.

Back to top ↑

What It Means to Have Algorithms Before Symbols

“Algorithms before symbols” does not mean mathematics existed without signs, diagrams, numerals, or written marks. It means many procedures existed before the modern symbolic algebra familiar today. Medieval mathematical texts often used prose, named quantities, examples, tables, diagrams, and verbal rules instead of compact algebraic notation.

An algorithm before symbols is a repeatable method expressed in non-modern notation. It may say, in words, what to do with a quantity. It may describe a relation without using an equals sign. It may identify an unknown without calling it \(x\). It may give a worked example instead of a universal formula. It may demonstrate correctness with a geometric figure rather than symbolic proof.

Algorithms before symbols remind us that the history of computation is also a history of language.

Back to top ↑

Rhetorical Algebra and Mathematical Prose

Rhetorical algebra refers to algebra expressed largely in words rather than modern symbols. Early algebraic traditions often described unknowns, squares, roots, constants, operations, and transformations through prose. The method could still be systematic even if the notation was not symbolic in the modern sense.

Al-Khwārizmī’s algebraic tradition is a major example. Problems were classified, operations were explained, and solutions were demonstrated. The prose did procedural work: it told the reader how to identify the case, what operation to apply, and how to reach the answer.

Mathematical prose can be procedural when it gives a reader a reliable path through a problem.

Back to top ↑

Procedures Without Modern Variables

A variable is a compact symbolic tool, but the idea of an unknown does not require the modern letter \(x\). Medieval texts could speak of a root, a thing, a square, a share, a number, a quantity, or an unknown amount. The missing value was still part of the procedure.

The ability to reason about an unknown before knowing its value is central to algebra and computation. It lets a problem be represented before it is solved. It lets operations be applied to relations rather than only to known numbers. It lets a method move toward an output.

The absence of modern variables does not mean the absence of abstraction.

Back to top ↑

Problem Classification Before Formal Syntax

Many medieval procedures began by recognizing the type of problem. A question might involve a number and a root, a square and a number, a commercial rate, an inheritance share, a table lookup, or a geometric relation. Once the type was recognized, the method could be selected.

This is algorithmic because classification controls execution. A modern program branches by condition; a mathematical solver chooses a method by problem form. Medieval texts often encoded this logic in prose: if the problem has this structure, do this; if it has another structure, use that method.

Classification made procedure reusable because it turned particular problems into cases of a method.

Back to top ↑

Worked Examples as Algorithmic Infrastructure

Worked examples were a major form of algorithmic infrastructure. A text could show how to solve one problem, and that example could teach a general method. The reader learned not only the answer, but the sequence: identify quantities, perform operations, transform the relation, compute the result, and check it.

Examples are powerful because they preserve procedure in concrete form. They reduce abstraction enough to be teachable while still pointing beyond the individual case. A worked example functions like a sample run, a test case, and a pedagogical template.

Worked examples are not merely illustrations. They are vehicles of procedural memory.

Back to top ↑

Geometric Demonstration and Verbal Correctness

Medieval mathematics often combined verbal procedure with geometric demonstration. A procedure might be described in words, then justified through a diagram of squares, rectangles, lines, or proportions. This mattered especially in algebraic contexts where completing the square or transforming a relation could be shown spatially.

Geometric demonstration reminds us that procedure and proof are not enemies. A calculation may produce a result, but a demonstration explains why the method works. In algorithmic terms, this is a correctness argument expressed through geometry and language rather than formal symbolic proof.

Correctness can be verbal, visual, numerical, or symbolic. Medieval mathematics often used several at once.

Back to top ↑

Table Lookup and Interpolation as Verbal Procedure

Astronomical, trigonometric, calendrical, and administrative tables required procedures for use. A table was not self-executing. The reader needed to know which column to consult, how to select a row, how to adjust for context, how to interpolate between entries, and how to combine results.

These procedures were often explained verbally. A table plus instructions forms a computational system: stored values, indexing rules, correction steps, and interpretive guidance.

A table becomes algorithmic when instructions tell the reader how to use it.

Back to top ↑

Practical Reckoning and Institutional Mathematics

Verbal procedures flourished in practical mathematics because institutions needed repeatable calculation. Merchants needed exchange, profit, partnership, and debt procedures. Legal systems needed inheritance and allocation procedures. Surveyors needed area and boundary procedures. Administrators needed taxation and accounting procedures. Astronomers needed table and prediction procedures.

These were not abstract curiosities. They were operating methods for real institutions. A procedure written in ordinary language could guide a trained person through a calculation that affected property, trade, timekeeping, land, ritual direction, or governance.

Practical reckoning shows that algorithmic reasoning has always been tied to social organization.

Back to top ↑

Manuscripts, Teaching, and Transmission

Verbal procedures traveled through manuscripts, commentaries, translations, teaching lineages, marginal notes, exercises, and practical manuals. A procedure could be copied, abbreviated, expanded, corrected, adapted, translated, or reorganized. Transmission was not passive storage. It was intellectual work.

This matters because algorithms are not only invented; they are maintained. They survive through media, pedagogy, and institutions. A verbal rule can become durable when it is copied into teaching texts, explained by instructors, applied in practice, and adapted for new audiences.

The history of algorithms is also a history of how procedures are copied, taught, and repaired.

Back to top ↑

From Verbal Rules to Symbolic Compression

Symbolic notation compresses mathematical language. A long verbal instruction can sometimes become a short formula. This compression is powerful: it enables abstraction, manipulation, proof, generalization, and later automation. But symbolic notation did not appear all at once, and it did not make earlier verbal methods meaningless.

The relationship between verbal and symbolic mathematics is not a simple replacement story. Symbols often grow out of repeated procedural needs. When many similar relations must be written, a shorthand becomes useful. When transformations become complex, notation helps track structure. When proofs become general, symbols increase precision and scale.

Symbols are powerful because they compress procedure, but the procedural imagination often comes first.

Back to top ↑

Why Verbal Does Not Mean Vague

A verbal mathematical procedure can be vague, but it does not have to be. Precision depends on whether the language defines a stable operation for trained readers. Medieval mathematical prose often used technical vocabulary, conventional examples, known problem types, and established operations.

The reader’s training mattered. A phrase that seems ambiguous to a modern outsider may have been clear within a mathematical tradition. This is similar to how modern code depends on language conventions, libraries, syntax, and shared expectations. Procedure always depends on an interpretive community.

Verbal procedure is rigorous when it belongs to a disciplined practice of reading, teaching, and checking.

Back to top ↑

Modern Computational Lessons

Modern computation can learn several lessons from algorithms before symbols. First, representation matters. A procedure depends on how inputs are named, organized, and transformed. Second, documentation matters. A procedure must be readable and executable by someone or something. Third, examples matter. They teach, test, and reveal edge cases. Fourth, verification matters. A procedure is not complete until its result can be checked.

The most important lesson is that algorithmic thinking is not identical with programming. Programming is one modern form of algorithmic expression. Verbal mathematical procedure is another historical form. Both require ordered operations, interpretation, constraints, and correctness.

The history of verbal procedures widens our view of what algorithmic reasoning can be.

Back to top ↑

Origin Stories and Careful Interpretation

Algorithms before symbols should not be turned into a simplistic origin story. Verbal procedures appeared in many mathematical traditions: Babylonian problem texts, Greek geometric reasoning, Sanskrit mathematical rules, Arabic algebra and arithmetic, Latin algorism, Chinese mathematical procedures, and many practical reckoning traditions. The point is not to rank them as if one culture owns procedure. The point is to understand how procedures were expressed, taught, and transmitted.

Careful interpretation also avoids judging earlier mathematics only by modern notation. A medieval text may look wordy because it does not use symbols we now take for granted. But wordiness is not the same as conceptual weakness. The verbal form may reveal pedagogical, practical, and demonstrative priorities that symbolic compression hides.

A careful history of algorithms before symbols shows procedure as a shared human achievement expressed in many media.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

A verbal procedure can be modeled as a sequence:

A problem-classification rule can be modeled as:

A worked example functions like:

A transmission model can be written as:

These formulas use modern notation to describe historical structure. They are interpretive models, not claims that medieval authors wrote in this form.

Back to top ↑

Python Workflow: Verbal Procedure Map

The Python workflow below creates a dependency-light interpretive map of algorithms before symbols. It scores themes by procedural clarity, representational dependence, pedagogical value, transmission importance, practical use, and modern resonance, then writes reproducible CSV and JSON outputs.

# algorithms_before_symbols_verbal_procedure_map.py
# Dependency-light workflow for mapping verbal procedures in medieval mathematics.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
from statistics import mean
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 VerbalProcedureConfig:
    article: str = "algorithms_before_symbols_verbal_procedures_in_medieval_mathematics"
    core_threshold: float = 0.80
    high_procedural_clarity_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 verbal_procedure_themes() -> list[dict[str, object]]:
    return [
        {"theme_id": "rhetorical_algebra", "procedural_clarity": 0.90, "representation_dependence": 0.86, "pedagogical_value": 0.88, "transmission_importance": 0.90, "practical_use": 0.82, "modern_resonance": 0.88},
        {"theme_id": "problem_classification", "procedural_clarity": 0.92, "representation_dependence": 0.82, "pedagogical_value": 0.90, "transmission_importance": 0.84, "practical_use": 0.86, "modern_resonance": 0.90},
        {"theme_id": "worked_examples", "procedural_clarity": 0.94, "representation_dependence": 0.82, "pedagogical_value": 0.96, "transmission_importance": 0.90, "practical_use": 0.88, "modern_resonance": 0.86},
        {"theme_id": "geometric_demonstration", "procedural_clarity": 0.84, "representation_dependence": 0.92, "pedagogical_value": 0.88, "transmission_importance": 0.82, "practical_use": 0.78, "modern_resonance": 0.86},
        {"theme_id": "table_lookup_interpolation", "procedural_clarity": 0.88, "representation_dependence": 0.90, "pedagogical_value": 0.84, "transmission_importance": 0.86, "practical_use": 0.92, "modern_resonance": 0.90},
        {"theme_id": "commercial_reckoning_rules", "procedural_clarity": 0.88, "representation_dependence": 0.82, "pedagogical_value": 0.86, "transmission_importance": 0.84, "practical_use": 0.96, "modern_resonance": 0.84},
        {"theme_id": "manuscript_commentary_transmission", "procedural_clarity": 0.78, "representation_dependence": 0.86, "pedagogical_value": 0.88, "transmission_importance": 0.96, "practical_use": 0.82, "modern_resonance": 0.84},
    ]


def score_theme(row: dict[str, object], config: VerbalProcedureConfig) -> dict[str, object]:
    verbal_score = mean([
        float(row["procedural_clarity"]),
        float(row["representation_dependence"]),
        float(row["pedagogical_value"]),
        float(row["transmission_importance"]),
        float(row["practical_use"]),
        float(row["modern_resonance"]),
    ])

    if verbal_score >= config.core_threshold and float(row["procedural_clarity"]) >= config.high_procedural_clarity_threshold:
        interpretive_status = "core_verbal_procedure_thread"
    elif verbal_score >= config.core_threshold:
        interpretive_status = "major_verbal_procedure_thread"
    else:
        interpretive_status = "supporting_verbal_procedure_thread"

    return {
        "theme_id": row["theme_id"],
        "procedural_clarity": round(float(row["procedural_clarity"]), 6),
        "representation_dependence": round(float(row["representation_dependence"]), 6),
        "pedagogical_value": round(float(row["pedagogical_value"]), 6),
        "transmission_importance": round(float(row["transmission_importance"]), 6),
        "practical_use": round(float(row["practical_use"]), 6),
        "modern_resonance": round(float(row["modern_resonance"]), 6),
        "verbal_procedure_score": round(verbal_score, 6),
        "interpretive_status": interpretive_status,
    }


def interpretation_cautions() -> list[dict[str, str]]:
    return [
        {"caution": "do_not_confuse_verbal_with_vague", "meaning": "Verbal procedure can be precise within a technical tradition."},
        {"caution": "do_not_project_modern_symbols_backward", "meaning": "Medieval procedures should not be judged only by modern symbolic notation."},
        {"caution": "do_not_equate_procedure_with_programming", "meaning": "Pre-modern mathematical procedures are algorithmic without being computer code."},
        {"caution": "do_not_ignore_examples", "meaning": "Worked examples often carry the general method."},
        {"caution": "do_not_make_transmission_passive", "meaning": "Manuscripts, translations, commentaries, and teaching reshape procedure."},
    ]


def main() -> None:
    config = VerbalProcedureConfig()
    themes = verbal_procedure_themes()
    scored = [score_theme(row, config) for row in themes]
    cautions = interpretation_cautions()

    summary = {
        "article": config.article,
        "timestamp_utc": timestamp_utc(),
        "themes_reviewed": len(scored),
        "core_threads": sum(1 for row in scored if row["interpretive_status"] == "core_verbal_procedure_thread"),
        "major_threads": sum(1 for row in scored if row["interpretive_status"] == "major_verbal_procedure_thread"),
        "supporting_threads": sum(1 for row in scored if row["interpretive_status"] == "supporting_verbal_procedure_thread"),
        "mean_verbal_procedure_score": round(mean(float(row["verbal_procedure_score"]) for row in scored), 6),
        "cautions": len(cautions),
        "interpretation": "Algorithms before symbols should be studied as verbal, pedagogical, representational, practical, and transmissible procedures rather than as modern code projected backward.",
    }

    write_csv(TABLES / "verbal_procedure_themes.csv", themes)
    write_csv(TABLES / "verbal_procedure_map.csv", scored)
    write_csv(TABLES / "interpretation_cautions.csv", cautions)
    write_csv(TABLES / "verbal_procedure_summary.csv", [summary])

    write_json(JSON_DIR / "verbal_procedure_config.json", asdict(config))
    write_json(JSON_DIR / "verbal_procedure_map.json", scored)
    write_json(JSON_DIR / "interpretation_cautions.json", cautions)
    write_json(JSON_DIR / "verbal_procedure_summary.json", summary)

    print("Algorithms before symbols verbal procedure map complete.")
    print(TABLES / "verbal_procedure_summary.csv")


if __name__ == "__main__":
    main()

This workflow turns verbal mathematical procedure into a reproducible interpretive artifact: procedural clarity, representation, pedagogy, transmission, practical use, modern resonance, verbal procedure score, and historical caution are documented together.

Back to top ↑

R Workflow: Verbal Procedure Diagnostics

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

# algorithms_before_symbols_verbal_procedure_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, "verbal_procedure_map.csv")
summary_path <- file.path(tables_dir, "verbal_procedure_summary.csv")

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

verbal_map <- read.csv(map_path, stringsAsFactors = FALSE)
summary <- read.csv(summary_path, stringsAsFactors = FALSE)

png(file.path(figures_dir, "verbal_procedure_dimensions.png"), width = 1200, height = 850)
score_matrix <- t(as.matrix(verbal_map[, c("procedural_clarity", "representation_dependence", "pedagogical_value", "transmission_importance", "practical_use", "modern_resonance")]))
barplot(score_matrix,
        beside = TRUE,
        names.arg = verbal_map$theme_id,
        las = 2,
        ylim = c(0, 1),
        ylab = "Interpretive Score",
        main = "Algorithms Before Symbols: Verbal Procedure Dimensions")
legend("bottomright",
       legend = rownames(score_matrix),
       cex = 0.72,
       bty = "n")
grid()
dev.off()

png(file.path(figures_dir, "verbal_procedure_score_by_theme.png"), width = 1000, height = 750)
barplot(verbal_map$verbal_procedure_score,
        names.arg = verbal_map$theme_id,
        las = 2,
        ylab = "Verbal Procedure Score",
        main = "Verbal Procedure Score by Theme")
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_verbal_procedure_score = summary$mean_verbal_procedure_score[1],
  cautions = summary$cautions[1],
  diagnostic_note = "Algorithms before symbols should be studied as verbal, pedagogical, representational, practical, and transmissible procedures rather than as modern code projected backward."
)

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

The R layer makes the interpretive structure visible: rhetorical algebra, problem classification, worked examples, geometric demonstration, table lookup, practical reckoning, manuscript transmission, and caution can be examined as related but distinct dimensions of verbal procedure.

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 Verbal Procedures

A procedural study of medieval mathematical prose should ask how the words tell the reader what to do. The goal is not to translate everything immediately into modern notation. The goal is to understand the procedure in its historical medium.

This method respects verbal mathematics as a serious medium of procedural reasoning.

Back to top ↑

Common Pitfalls

The biggest mistake is to treat verbal procedure as vague simply because it lacks modern notation. Another mistake is to translate everything into symbols too quickly, losing the pedagogical and procedural structure of the original text. A third mistake is to describe verbal procedures as computer programs, which projects modern technology backward.

A better reading treats verbal procedures as disciplined mathematical instructions.

Back to top ↑

Why Algorithms Before Symbols Matter

Algorithms before symbols matter because they show that procedure is deeper than notation. A method can be written in words, demonstrated in geometry, preserved in examples, organized by problem type, stored in tables, and transmitted through manuscripts before it becomes symbolic or programmable.

This history expands the meaning of algorithmic reasoning. It reminds us that computation is not only machine execution. It is also the human practice of making operations explicit, repeatable, teachable, inspectable, and correctable. Medieval verbal mathematics belongs in this history because it made procedures public long before modern symbolic algebra and programming languages.

The lesson for modern computation is not nostalgia. It is clarity: notation matters, but explanation matters too. A procedure that cannot be understood, taught, checked, or transmitted is fragile. Algorithms before symbols remind us that the first interface of computation was often language. AI belongs in the toolkit, not in control.

Back to top ↑

Related Articles

• Hindu-Arabic Numerals and the Transmission of Positional Calculation
• Al-Jabr wa’l-Muqābalah: Algebra as Rule-Governed Problem Solving
• Al-Khwārizmī, Algorism, and the Procedural Imagination
• Formal Languages and Symbolic Representation

Back to top ↑

Further Reading

• Berggren, J.L. (1986) Episodes in the Mathematics of Medieval Islam. New York: Springer.
• Rashed, R. (2009) Al-Khwārizmī: The Beginnings of Algebra. London: Saqi Books.
• Oaks, J.A. (2007) ‘Medieval Arabic algebra as an artificial language’, Journal of the American Oriental Society, 127(3), pp. 285–304.
• Oaks, J.A. (2009) ‘Polynomials and equations in Arabic algebra’, Archive for History of Exact Sciences, 63(2), pp. 169–203.
• Høyrup, J. (2002) Lengths, Widths, Surfaces: A Portrait of Old Babylonian Algebra and Its Kin. New York: Springer.
• Katz, V.J. (1998) A History of Mathematics: An Introduction. 2nd edn. Reading, MA: Addison-Wesley.
• Smith, D.E. and Karpinski, L.C. (1911) The Hindu-Arabic Numerals. Boston: Ginn and Company.

Back to top ↑

References

• Berggren, J.L. (1986) Episodes in the Mathematics of Medieval Islam. New York: Springer.
• Høyrup, J. (2002) Lengths, Widths, Surfaces: A Portrait of Old Babylonian Algebra and Its Kin. New York: Springer.
• Katz, V.J. (1998) A History of Mathematics: An Introduction. 2nd edn. Reading, MA: Addison-Wesley.
• Oaks, J.A. (2007) ‘Medieval Arabic algebra as an artificial language’, Journal of the American Oriental Society, 127(3), pp. 285–304.
• Oaks, J.A. (2009) ‘Polynomials and equations in Arabic algebra’, Archive for History of Exact Sciences, 63(2), pp. 169–203.
• O’Connor, J.J. and Robertson, E.F. (1999) ‘Abu Ja’far Muhammad ibn Musa Al-Khwarizmi’. MacTutor History of Mathematics Archive, University of St Andrews. Available at: https://mathshistory.st-andrews.ac.uk/Biographies/Al-Khwarizmi/.
• Rashed, R. (2009) Al-Khwārizmī: The Beginnings of Algebra. London: Saqi Books.
• Smith, D.E. and Karpinski, L.C. (1911) The Hindu-Arabic Numerals. Boston: Ginn and Company. Available at: https://www.gutenberg.org/files/22599/22599-h/22599-h.htm.

Back to top ↑