Islamic-World Roots of Algorithmic Reasoning: Al-Khwārizmī, Algebra, Algorism, and Procedural Thought

Last Updated June 22, 2026

Islamic-world roots of algorithmic reasoning examine how procedural mathematics, algebra, astronomical tables, positional calculation, cryptanalysis, mechanical devices, translation movements, and practical calculation developed across Arabic, Persian, Central Asian, North African, Andalusian, and broader Islamicate scholarly worlds. This history matters because the modern word algorithm is tied to the Latinized name of Muḥammad ibn Mūsā al-Khwārizmī, while the modern word algebra is tied to the title of his treatise on al-jabr wa’l-muqābalah.

This article does not argue that algorithms began in only one civilization. Algorithmic reasoning has multiple ancient and medieval roots, including Babylonian, Egyptian, Greek, Indian, Chinese, Islamic-world, and later Latin European traditions. The point is more precise: the Islamic world became a major center for preserving, translating, extending, systematizing, teaching, and transmitting rule-governed mathematical procedures. It connected earlier numerical and geometric traditions with practical problem solving, astronomy, commerce, inheritance, surveying, geography, cryptanalysis, mechanical design, and later European algorism.

The history is especially important for computational reasoning because it reminds us that algorithms are not only modern computer programs. They are disciplined procedures: sequences of operations, transformations, reductions, classifications, tables, recipes, approximations, and rule-governed methods for solving problems. Long before electronic computers, scholars and practitioners developed procedural ways of calculating, predicting, encrypting, measuring, allocating, constructing, and reasoning.

This article introduces the Islamic-world roots of algorithmic reasoning, al-Khwārizmī, algorism, algebra, Hindu-Arabic numerals, positional calculation, verbal procedures, practical mathematics, inheritance calculation, astronomy, geography, coordinates, cryptanalysis, automata, translation movements, Latin reception, and the need for careful origin stories. It frames the Islamic world not as an isolated source, but as a major intellectual crossroads where inherited techniques were translated, reorganized, extended, taught, and transmitted through procedural methods.

Why Islamic-World Roots Matter

Islamic-world roots matter because algorithmic reasoning did not emerge suddenly with modern computers. It developed through long traditions of numerical procedure, algebraic reduction, tabular prediction, astronomical calculation, practical mathematics, and mechanical sequencing. The Islamic world was one of the most important historical environments in which these traditions were translated, refined, systematized, and transmitted.

The relevance is not only etymological, though the etymology is powerful. The word algorithm traces through Latin forms of al-Khwārizmī’s name, while algebra traces through al-jabr in the title of his algebraic treatise. But the deeper significance is methodological. Islamic-world scholarship made procedures teachable: recipes for calculation, rules for solving equations, tables for prediction, methods for inheritance, commercial reckoning, astronomical computation, geographic coordinates, and cryptanalytic inference.

This history helps restore algorithmic reasoning to its broader intellectual setting: mathematics, language, craft, astronomy, law, administration, design, and transmission.

Back to top ↑

What Counts as Algorithmic Reasoning Before Computers?

Before computers, algorithmic reasoning appeared as rule-governed procedure. A procedure could be written verbally, memorized, tabulated, diagrammed, taught, copied, or embodied in an instrument. It did not need modern code. It needed a defined problem, a sequence of operations, transformations that could be repeated, and a criterion for completion.

Pre-modern algorithmic reasoning often took the form of calculation manuals, astronomical tables, legal or inheritance procedures, commercial reckoning methods, geometric constructions, cryptanalytic recipes, instrument instructions, and mechanical sequences. These procedures were not “algorithms” in the modern computer-science sense, but they were algorithmic in the broader sense: disciplined methods for getting from input to result.

To study early algorithmic reasoning, we look for procedure, repeatability, transformation, representation, and institutional use.

Back to top ↑

Al-Khwārizmī and the Name Algorithm

Muḥammad ibn Mūsā al-Khwārizmī was a ninth-century mathematician and astronomer associated with Abbasid Baghdad. His name entered Latin mathematical culture through translations and adaptations of works on calculation. Over time, Latinized forms of his name became associated with methods of arithmetic using Hindu-Arabic numerals, and eventually with the term algorithm.

Al-Khwārizmī matters for algorithmic reasoning in at least three ways. First, his name became attached to procedural calculation. Second, his work helped transmit positional numerals and arithmetic methods into wider medieval circulation. Third, his algebraic treatise presented systematic methods for solving classes of problems.

The name algorithm therefore preserves a historical memory: computation is not only machinery, but also a tradition of written, taught, and transmitted procedure.

Back to top ↑

Algebra as Rule-Governed Problem Solving

Algebra in al-Khwārizmī’s tradition was not initially symbolic algebra in the modern notation-heavy sense. It was often expressed in words, organized around types of equations, transformations, and examples. The power of this tradition was procedural: identify the form of a problem, reduce it, balance it, complete it, and solve it.

The title phrase al-jabr wa’l-muqābalah refers to operations of restoration and balancing. In algorithmic terms, this is a transformation system. A problem is not solved by intuition alone. It is processed through a sequence of valid operations that preserve equivalence while making the solution accessible.

Algebra becomes algorithmic when it provides a disciplined path from problem form to solution.

Back to top ↑

Hindu-Arabic Numerals and Positional Calculation

The spread of Hindu-Arabic numerals and positional decimal calculation was one of the most important developments in the history of computation. Positional notation changes calculation because the value of a digit depends on its place. This makes arithmetic more systematic, compact, scalable, and teachable.

Islamic-world scholars and scribes played a major role in transmitting, adapting, and teaching these numerals and calculation methods. Latin European algorism later developed through translations and teaching traditions that contrasted written positional calculation with abacus-based reckoning.

Representations are not passive containers. They shape the procedures that become possible.

Back to top ↑

Algorithms Before Symbols

Modern readers often associate mathematics with symbolic notation, but many pre-modern algorithmic procedures were written verbally. A procedure could say, in effect: take the thing, multiply, divide, restore, balance, compare, subtract, or complete. This does not make the reasoning less algorithmic. It shows that algorithms can exist before modern notation.

Verbal procedures matter because they reveal computation as instruction. The step is not merely a calculation; it is a command in a structured process. Manuscripts taught readers how to act mathematically. They classified problems, gave examples, and described operations in ordinary language.

An algorithm can begin as a disciplined instruction long before it becomes a symbolic expression or executable program.

Back to top ↑

Practical Calculation: Commerce, Inheritance, and Surveying

Algorithmic reasoning in the Islamic world was not confined to abstract mathematics. It appeared in practical calculation: trade, weights, measures, currency exchange, partnership, profit, inheritance, taxation, land surveying, architecture, and administration.

Inheritance calculation is especially important because legal shares can require precise allocation among multiple heirs under defined rules. Commercial calculation required proportional reasoning, exchange rates, debt, partnership, and profit distribution. Surveying required measurement, geometry, and area calculation. These domains made procedure socially consequential.

This practical layer reminds us that algorithmic reasoning has always been entangled with institutions, authority, and everyday life.

Back to top ↑

Astronomical Tables, Calendars, and Prediction

Astronomical calculation was one of the great procedural sciences of the medieval Islamic world. Astronomers used tables, instruments, geometry, observation, trigonometry, and models to calculate planetary positions, calendars, prayer times, qibla direction, eclipses, and other phenomena.

Tables are algorithmic because they encode computation in reusable form. A table can replace repeated calculation with lookup, interpolation, adjustment, and transformation. Astronomical tables also show how computation supports prediction: not simply calculating numbers, but organizing time, orientation, and celestial motion.

Astronomical computation shows algorithmic reasoning at the intersection of model, table, instrument, and observation.

Back to top ↑

Geography, Coordinates, and Computational Mapping

Geographic and cartographic traditions in the Islamic world developed methods for representing location, distance, direction, climate zones, routes, coordinates, and regions. These practices linked mathematics to spatial reasoning and administrative knowledge.

Coordinates are computational because they turn place into manipulable representation. Once locations can be represented numerically, they can be compared, transformed, tabulated, corrected, and mapped. This does not reduce geography to numbers; it creates a procedural layer for calculating with space.

Computational mapping begins when space becomes representable through procedures that can be checked, corrected, and reused.

Back to top ↑

Al-Kindī and Cryptanalytic Reasoning

Al-Kindī is often associated with early systematic cryptanalysis, especially methods that use letter frequencies to attack substitution ciphers. This matters for algorithmic reasoning because cryptanalysis combines symbolic representation, statistical pattern, inference, and procedural testing.

Frequency analysis is a powerful conceptual leap. It treats text as data. It assumes that symbol patterns can reveal hidden structure. It compares observed frequencies with expected frequencies. It uses probabilistic clues to guide search. This is recognizably close to later forms of statistical reasoning, information analysis, and security practice.

Cryptanalysis shows algorithmic reasoning as pattern recognition under uncertainty.

Back to top ↑

Mechanical Procedure and Automata

Islamic-world mechanical traditions, including devices associated with the Banū Mūsā and al-Jazarī, show another dimension of procedural reasoning: sequenced physical action. Water clocks, automata, pumps, fountains, valves, gears, floats, cams, and feedback-like mechanisms translate design into repeated motion.

These devices are not digital computers, and they should not be described as if they were. Their relevance is different: they show how procedures can be embodied in material systems. A machine can store sequence in shape, constraint, flow, balance, timing, and mechanical relation.

Mechanical automata show that algorithmic reasoning can be embodied in matter as well as written in manuscripts.

Back to top ↑

Translation Movements and Knowledge Transfer

The Islamic world was a major zone of translation and knowledge transfer. Greek, Syriac, Persian, Sanskrit, and other traditions entered Arabic scholarly culture, where they were translated, interpreted, debated, corrected, extended, and taught. Later, Arabic works were translated into Latin and other languages, influencing medieval European mathematics, astronomy, medicine, philosophy, and natural science.

Translation is not passive copying. It is intellectual work. Translators and scholars select terms, create vocabulary, reconcile systems, adapt examples, standardize methods, and make knowledge teachable in new contexts. Algorithmic reasoning often survives through this kind of transmission because procedures must be made intelligible to new readers.

Algorithmic history is a history of transmission as much as invention.

Back to top ↑

From Baghdad to Latin Europe

The movement of mathematical knowledge from Arabic into Latin Europe was not a single event. It unfolded through translations, teaching traditions, manuscripts, commercial practice, universities, abacus schools, astronomical tables, and practical arithmetic. Works associated with al-Khwārizmī and later Arabic mathematical traditions became part of the broader medieval transmission of algorism and algebra.

Latin algorism taught calculation with Hindu-Arabic numerals. This was not immediately accepted everywhere; abacus traditions and Roman numerals remained important. But written positional calculation gradually reshaped European arithmetic, commerce, science, and education.

The path from Baghdad to Latin Europe was not a simple handoff. It was a long process of translation, adaptation, resistance, and incorporation.

Back to top ↑

The Unknown, the Variable, and Mathematical Abstraction

The history of algebra is partly the history of how the unknown became manageable. Before modern symbolic notation, unknown quantities could be discussed through words such as thing, root, square, or amount. This linguistic abstraction allowed problems to be classified and transformed before symbolic variables became standard.

The move from concrete problem to unknown quantity is algorithmically important. It allows a problem to be represented, manipulated, reduced, and solved without knowing the answer in advance. That is one of the deepest ideas in computational reasoning: represent the unknown in a form that can be acted upon.

The unknown becomes computational when it can be represented and transformed by rule.

Back to top ↑

Why Origin Stories Need Care

Origin stories can distort history if they search for a single heroic beginning. Algorithms do not have one origin. They have multiple lineages: numerical tables, administrative procedures, geometric constructions, legal calculations, astronomical models, commercial arithmetic, mechanical devices, symbolic transformations, logical systems, and eventually machine computation.

The Islamic world is central to the history of algorithmic reasoning, but not because it stands alone. Its importance lies in its role as a major scholarly, mathematical, linguistic, and practical crossroads. It translated earlier traditions, created new methods, organized procedures, developed algebra, transmitted numerals, advanced astronomical computation, produced cryptanalytic methods, and influenced later Latin European mathematics.

Careful origin stories honor the Islamic-world contribution more fully because they explain what actually happened: preservation, invention, synthesis, teaching, transmission, and transformation.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

A simple procedural view of algorithmic reasoning can be written as:

An algebraic transformation preserves equivalence while moving toward solution:

A tabular method can be represented as lookup plus adjustment:

A cryptanalytic frequency method compares observed and expected symbol distributions:

These formulas do not claim that medieval scholars used modern notation. They translate procedural patterns into modern mathematical language so the computational structure becomes visible.

Back to top ↑

Python Workflow: Historical Algorithmic-Reasoning Map

The Python workflow below creates a dependency-light map of Islamic-world algorithmic reasoning themes. It scores each theme by procedural explicitness, transmission importance, practical application, representational importance, and modern computational resonance, then writes reproducible CSV and JSON outputs.

# islamic_world_roots_of_algorithmic_reasoning_map.py
# Dependency-light workflow for mapping historical roots of algorithmic reasoning.

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 HistoricalReasoningConfig:
    article: str = "islamic_world_roots_of_algorithmic_reasoning"
    high_significance_threshold: float = 0.78
    high_transmission_threshold: float = 0.80


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 historical_themes() -> list[dict[str, object]]:
    return [
        {"theme_id": "al_khwarizmi_algorism", "procedural_explicitness": 0.92, "transmission_importance": 0.96, "practical_application": 0.88, "representation_importance": 0.94, "modern_resonance": 0.96},
        {"theme_id": "algebraic_transformation", "procedural_explicitness": 0.90, "transmission_importance": 0.92, "practical_application": 0.82, "representation_importance": 0.88, "modern_resonance": 0.92},
        {"theme_id": "astronomical_tables", "procedural_explicitness": 0.86, "transmission_importance": 0.84, "practical_application": 0.90, "representation_importance": 0.86, "modern_resonance": 0.84},
        {"theme_id": "cryptanalytic_frequency_analysis", "procedural_explicitness": 0.84, "transmission_importance": 0.72, "practical_application": 0.78, "representation_importance": 0.86, "modern_resonance": 0.90},
        {"theme_id": "practical_inheritance_and_commerce", "procedural_explicitness": 0.88, "transmission_importance": 0.76, "practical_application": 0.96, "representation_importance": 0.78, "modern_resonance": 0.82},
        {"theme_id": "mechanical_automata", "procedural_explicitness": 0.78, "transmission_importance": 0.70, "practical_application": 0.76, "representation_importance": 0.74, "modern_resonance": 0.80},
    ]


def score_theme(row: dict[str, object], config: HistoricalReasoningConfig) -> dict[str, object]:
    significance_score = mean([
        float(row["procedural_explicitness"]),
        float(row["transmission_importance"]),
        float(row["practical_application"]),
        float(row["representation_importance"]),
        float(row["modern_resonance"]),
    ])

    if significance_score >= config.high_significance_threshold and float(row["transmission_importance"]) >= config.high_transmission_threshold:
        interpretive_status = "core_algorithmic_reasoning_thread"
    elif significance_score >= config.high_significance_threshold:
        interpretive_status = "major_algorithmic_reasoning_thread"
    else:
        interpretive_status = "supporting_algorithmic_reasoning_thread"

    return {
        "theme_id": row["theme_id"],
        "procedural_explicitness": round(float(row["procedural_explicitness"]), 6),
        "transmission_importance": round(float(row["transmission_importance"]), 6),
        "practical_application": round(float(row["practical_application"]), 6),
        "representation_importance": round(float(row["representation_importance"]), 6),
        "modern_resonance": round(float(row["modern_resonance"]), 6),
        "significance_score": round(significance_score, 6),
        "interpretive_status": interpretive_status,
    }


def historical_cautions() -> list[dict[str, str]]:
    return [
        {"caution": "avoid_single_origin_story", "meaning": "Algorithms have multiple ancient and medieval lineages."},
        {"caution": "separate_etymology_from_total_origin", "meaning": "The word algorithm is tied to al-Khwarizmi, but procedural reasoning is broader."},
        {"caution": "avoid_preservation_only_framing", "meaning": "Islamic-world scholarship translated, extended, systematized, and transmitted knowledge."},
        {"caution": "avoid_modern_projection", "meaning": "Pre-modern procedures should not be described as modern computer programs."},
        {"caution": "recognize_translation_as_creation", "meaning": "Translation, commentary, pedagogy, and adaptation are forms of intellectual work."},
    ]


def main() -> None:
    config = HistoricalReasoningConfig()
    themes = historical_themes()
    scored = [score_theme(row, config) for row in themes]
    cautions = historical_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_algorithmic_reasoning_thread"),
        "major_threads": sum(1 for row in scored if row["interpretive_status"] == "major_algorithmic_reasoning_thread"),
        "supporting_threads": sum(1 for row in scored if row["interpretive_status"] == "supporting_algorithmic_reasoning_thread"),
        "mean_significance_score": round(mean(float(row["significance_score"]) for row in scored), 6),
        "cautions": len(cautions),
        "interpretation": "Islamic-world roots of algorithmic reasoning should be studied as procedural, translational, practical, representational, and institutional history without reducing algorithms to a single-origin story.",
    }

    write_csv(TABLES / "historical_themes.csv", themes)
    write_csv(TABLES / "historical_algorithmic_reasoning_map.csv", scored)
    write_csv(TABLES / "historical_cautions.csv", cautions)
    write_csv(TABLES / "historical_reasoning_summary.csv", [summary])

    write_json(JSON_DIR / "historical_reasoning_config.json", asdict(config))
    write_json(JSON_DIR / "historical_algorithmic_reasoning_map.json", scored)
    write_json(JSON_DIR / "historical_cautions.json", cautions)
    write_json(JSON_DIR / "historical_reasoning_summary.json", summary)

    print("Islamic-world roots of algorithmic reasoning map complete.")
    print(TABLES / "historical_reasoning_summary.csv")


if __name__ == "__main__":
    main()

This workflow turns a historical argument into a reproducible interpretive map: themes, procedural explicitness, transmission importance, practical application, representational importance, modern resonance, significance score, and historical caution are documented together.

Back to top ↑

R Workflow: Historical Theme Diagnostics

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

# islamic_world_roots_of_algorithmic_reasoning_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, "historical_algorithmic_reasoning_map.csv")
summary_path <- file.path(tables_dir, "historical_reasoning_summary.csv")

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

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

png(file.path(figures_dir, "historical_theme_dimensions.png"), width = 1200, height = 850)
score_matrix <- t(as.matrix(theme_map[, c("procedural_explicitness", "transmission_importance", "practical_application", "representation_importance", "modern_resonance")]))
barplot(score_matrix,
        beside = TRUE,
        names.arg = theme_map$theme_id,
        las = 2,
        ylim = c(0, 1),
        ylab = "Interpretive Score",
        main = "Islamic-World Roots of Algorithmic Reasoning: Historical Theme Dimensions")
legend("bottomright",
       legend = rownames(score_matrix),
       cex = 0.72,
       bty = "n")
grid()
dev.off()

png(file.path(figures_dir, "historical_significance_by_theme.png"), width = 1000, height = 750)
barplot(theme_map$significance_score,
        names.arg = theme_map$theme_id,
        las = 2,
        ylab = "Significance Score",
        main = "Historical Algorithmic-Reasoning Significance 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_significance_score = summary$mean_significance_score[1],
  cautions = summary$cautions[1],
  diagnostic_note = "Islamic-world roots of algorithmic reasoning should be studied as procedural, translational, practical, representational, and institutional history without reducing algorithms to a single-origin story."
)

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

The R layer makes the interpretive structure visible: al-Khwārizmī, algorism, algebra, tables, cryptanalysis, practical calculation, mechanical procedure, transmission, and historical caution can be examined as related but distinct dimensions of algorithmic 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 Algorithmic Origins

Responsible study of algorithmic origins should begin with transmission, representation, procedure, language, material culture, and institutional use. The question is not simply “Who invented the algorithm?” A better question is “How did rule-governed procedures for calculation, transformation, prediction, and reasoning develop, travel, and change across cultures?”

This method treats algorithmic history as a network of procedures, people, texts, translations, practices, and institutions.

Back to top ↑

Common Pitfalls

The history of Islamic-world algorithmic reasoning can be mishandled through oversimplification. Some accounts reduce Islamic-world scholarship to preservation. Others turn it into a single-origin myth. Some treat al-Khwārizmī as if he invented all algorithms. Others mention the etymology while ignoring algebra, astronomy, tables, practical mathematics, cryptanalysis, instruments, and transmission.

Careful history is not less impressive. It is more impressive because it shows the depth of the intellectual ecosystem.

Back to top ↑

Why This History Belongs in Computational Reasoning

Islamic-world roots of algorithmic reasoning belong in a serious account of algorithms because they show that computation is older, wider, and more human than modern software. The Islamic world contributed not only to the vocabulary of algorithm and algebra, but to traditions of procedural arithmetic, equation solving, astronomical tables, practical calculation, cryptanalytic inference, geographic computation, mechanical sequencing, and translation-driven knowledge transfer.

This history also changes how we think about algorithms today. Algorithms are not merely code. They are procedures embedded in representation systems, institutions, languages, instruments, and forms of judgment. They solve problems because someone has defined a problem, chosen representations, ordered operations, and decided what counts as a valid result.

The future of computational reasoning should remember this past. It should treat algorithms as cultural, mathematical, procedural, and institutional artifacts. AI belongs in the toolkit, not in control.

Back to top ↑

Related Articles

• Algorithms in Labor, Management, and Organizational Systems
• Al-Khwārizmī, Algorism, and the Procedural Imagination
• Al-Jabr wa’l-Muqābalah: Algebra as Rule-Governed Problem Solving
• Hindu-Arabic Numerals and the Transmission of Positional Calculation
• Why Origin Stories of Algorithms Need Care

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.
• Saliba, G. (2007) Islamic Science and the Making of the European Renaissance. Cambridge, MA: MIT Press.
• King, D.A. (1999) World-Maps for Finding the Direction and Distance to Mecca. Leiden: Brill.
• Hill, D.R. (1974) The Book of Knowledge of Ingenious Mechanical Devices. Dordrecht: D. Reidel.
• 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.
• UNESCO (1990) The Arab World: Where Geometry and Algebra Intersect. Paris: UNESCO.

Back to top ↑

References

• Berggren, J.L. (1986) Episodes in the Mathematics of Medieval Islam. New York: Springer.
• Brentjes, S. and Hogendijk, J.P. (2003) ‘Notes on Thābit ibn Qurra and his rule for amicable numbers’, Historia Mathematica, 30(1), pp. 37–59.
• Hill, D.R. (1974) The Book of Knowledge of Ingenious Mechanical Devices. Dordrecht: D. Reidel.
• King, D.A. (1999) World-Maps for Finding the Direction and Distance to Mecca. Leiden: Brill.
• 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.
• Saliba, G. (2007) Islamic Science and the Making of the European Renaissance. Cambridge, MA: MIT Press.
• UNESCO (1990) The Arab World: Where Geometry and Algebra Intersect. Paris: UNESCO. Available at: https://unesdoc.unesco.org/ark:/48223/pf0000084197.

Back to top ↑