Help topics

Welcome

NumberDB is a collaborative database of numbers. The underlying idea is that in practise, numbers are determined by their first 10 digits. That makes them searchable. NumberDB attempts to be a tool to identify numbers, and to show known descriptions. Which numbers are stored depends on their simplicity and their relevance. NumberDB stores numbers in tables. Tables are families of numbers together with a description. Thus a number can appear in several tables: For example, the number 1 is in the table of Integers, Values of the Gamma function, and it has its own table One as it is a special number. Tables of numbers also contain a definition, a description of parameters, and possibly formulas, comments, references, links, programs, and further more specific information. Furthermore tables are given tags, which helps searchability and classification.

How to search

The searchbar can be used to search for:

• Real numbers:
  Enter the number in one of three formats:
  • Decimal representation including the period, e.g. "3.14" to search for pi. The search will be done in an interval around the entered number: Entering "3.14" will search for numbers in the interval (3.13, 3.15).
  • Scientific notation (no period necessary), e.g. "14e2" to search numbers between 1300 and 1500.
  • NumberDB's p-notation: Enter a term of the form "ApB", where A and B are integers. It corresponds to the number 10^A · 0.B, e.g. "1p314" for pi. The sign of the number is determined by the sign of B.
• Fractional parts of real numbers:
  Enter the first few digits after the period, e.g. "1415" for pi.
• Integers:
  Enter the exact integer without period, e.g. "-1". This works for integers with up to 127 binary digits (roughly 38 decimal digits). For longer integers, try to search them as real numbers.
• Complex numbers:
  Enter sums or differences of the form "A" or "i*A" or "A*i", where "A" is a real number in the above format or a rational number. Entering "-1/2 + i * 0.86602" (to search for a third root of unity) will search within a larger square around it. Both, real and imaginary parts need sufficient precision.
• $p$-adic numbers:
  Search for numbers in $\mathbb{Q}_p$ in one of two formats:
  • Enter "Q2:1010" to search for $2^0 + 2^2 + O(2^4)$. Enter "Q2:1.1010" to search for $2^{-1} + 2^0 + 2^2 + O(2^4)$. For $p>10$, any $p$-adic digit needs to be given in base 10 with the same number of base 10 letters as $p$, e.g. "Q13:0102" will search for $13$-adic numbers of the form $1+2\cdot 13 + O(13^2)$. Minus signs are also interpreted, e.g. "Q3:-220" searches for $-(2 + 2\cdot 3^1) + O(3^3)$.
  • Enter "3 + O(2^5)" or "2^0+2^1+O(2^5)" for numbers of the form $2^0 + 2^1 + O(2^5)$. This format also works for $\mathbb{Q}_p$, e.g. enter "3/5 + O(5^1)".
• Polynomials over $\mathbb{Q}$:
  Enter polynomials over $\mathbb{Q}$ in arbitrary variables, e.g. enter "x^6+y^6-x^5*y^5+4*x*y" to search for $x^6+y^6-x^5y^5+4xy$.
• Tables:
  Enter words from the table's title, keywords, tags, definition, or comments.
• Tags:
  Enter the first letters of one word of a tag, e.g. "irr" for the tag "Irrational".

Advanced search guide

The advanced searchbar can be used to search for:

• Lists of real numbers
  Use Sage syntax to enter a number, a list of numbers, or a dictionary of the form {param: number}. The lists and dictionaries may be nested. The numbers might be given via formulas involving standard functions such as sin and sqrt, as well as standard constants such as e and pi.
  Examples:
  • -2, pi, e searches for certain constants.
  • {n: 2^n for n in [1..10]} searches for $2^1$, ..., $2^{10}$.
  • RIF(10,11) searches for all numbers contained in the interval $[10,11]$.
  • {a: {b: a/b for b in [1..5] if gcd(a,b) == 1} for a in [-5..5]} searches certain small rational numbers.
• Lists of complex numbers
  Similarly one can search for complex numbers. Recommended parents are CIF (complex interval field), CBF (complex ball field), and SR (symbolic ring), although CC (complex field via floats) should work as well unless too much precision is lost during the computation.
• Lists of p-adic numbers
  Similarly one can search for p-adic numbers in $\mathbb{Z}_p$ and $\mathbb{Q}_p$.
  Examples:
  • Qp(2,prec=4)(5) searches for $5 + O(2^4)$ = $2^0 + 2^2 + O(2^4)$, that is, any $2$-adic integer with first four $2$-adic digits $1$, $0$, $1$, $0$.
  • {n: Qp(2)(n) for n in [1..10]} searches $1$, ..., $10$ up to $O(2^{20})$ as $2$-adic numbers; note that 20 is the standard precision for Qp in sage.
• Lists of polynomials over $\mathbb{Q}$
  Similarly one can search for multivariate polynomials over $\mathbb{Q}$. As only expressions are accepted (mainly for safety reasons), we can define the variables as in the following example:
  
  • [{n: x^2 + n for n in [1..10]} for x,y in [polygens(QQ,2,'x')]] searches for polynomials $x^2+n$ for integers $n=1,\ldots,10$, where we allow two variables $x$ and $y$.

Number types and how they are written

Numbers in NumberDB can be of the following types.

• Integers:
  Integers are represented exactly as decimal numbers, e.g. "3" and "-1729".
• Rational numbers:
  Rational numbers are represented exactly as fractions of integers, e.g. "-3/2".
• Real numbers:
  Real numbers are usually hard to represent exactly. Instead we store an exactly represented interval that contains the real number. The smaller the interval, the higher the accuracy. The interval can be given in one of the following formats:
  • Decimal expansion: e.g. "3.14" represents the interval $[3.13, 3.15]$, that is, the last digit may be off by at most $1$. Scientific notation is allowed, e.g. "12e2" represents the interval $[1100, 1300]$. Note: If the decimal expansion does not contain "." or "e", it will instead denote an exactly represented integer.
  • Real interval: e.g. "[2, 2.3728596]". The end-points are exactly given.
  • Real balls: e.g. "3.14 +/- 2e-2" represents the interval $[3.12, 3.16]$. The center and radius of the real ball are exactly given.
  • NumberDB's p-notation: e.g. "1p31415" represents the interval [3.1414, 3.1416]. In general, for two integers A and B, "ApB" corresponds to the decimal expansion 0.BeA, where again the last digit of B may be off by 1. The sign of the number is determined by the sign of B.
• $p$-adic numbers:
  $p$-adic numbers in $\mathbb{Q}_p$ are usually hard to represent exactly. Instead we store an exactly represented $p$-adic ball that contains the $p$-adic number. The smaller the radius of the ball, the higher the accuracy. The ball can be given in one of the following (equivalent) formats:
  • Rational representative: e.g. "3+1/2 + O(2^3)" represents the $2$-adic ball $2^{-1} + 2^0 + 2^1 + O(2^3)$. The rational representative might be given as an algebraic expression involving integers and the usual operations "+", "-", "*", "/", and "^".
  • $p$-adic expansion: e.g. "Q2:1.110" represents the $2$-adic ball $2^{-1} + 2^0 + 2^1 + O(2^3)$. Note: The most significant digit stands on the left. The $p$-adic digits are given as base 10 numbers with as many letters as the base 10 representation of p. E.g. "Q13:01.02" represents the $13$-adic ball $13^{-1}+2\cdot 13^0 + O(13^1)$. The decimal point is not necessary, e.g. "Q2:110" represents the $2$-adic ball $2^0 + 2^1 + O(2^3)$. Minus signs are allowed, e.g. "Q2:-110" represents the $2$-adic ball $-(2^0 + 2^1) + O(2^3)$.

These formats apply to the tables' webpages, the searchbar, as well as to the raw data in yaml format.

How accurate are the numbers?

The section above says what a written value claims: 3.14 is the interval $[3.13, 3.15]$, and a value written to a hundred digits claims all hundred. This section is about the other question, which is not the same one — what that claim rests on.

A hundred digits can be proven, believed on a stated assumption, checked by agreement, or simply assumed. A table that does not say presents all four identically, so a generator states it and the table shows it under Data properties:

• exact — values represented exactly, without numerical rounding, such as integers, rationals or polynomials. This does not rule out errors in the mathematical method, implementation or transcription.
• proven — a rigorous error bound justifies the recorded precision. For example, interval or ball arithmetic computes bounds containing the exact result; those bounds determine how many digits can safely be recorded. The client checks that error information is present, but this check alone does not verify the method or its mathematical assumptions.
• assumed-bound — computed in fixed precision, with an error bound the author asserts and justifies.
• heuristic (agreement-checked) — computed twice at different precisions, keeping the digits that agree. Measured rather than assumed, and not a proof: two runs of a wrong method agree perfectly.
• heuristic — one computation and a guard chosen by judgement.
• measured — not computed at all. The value comes from experiment and the interval holds the measurements together with their stated uncertainties, as for the fine-structure constant. This one is not on the same scale as the others: asking whether measurement beats agreement-checking has no answer, because they are not the same kind of claim.

Every table states one. An absent line would mean nobody has established it rather than that the digits are poor — that used to be the common case and is no longer one at all. The weakest labels sit on the tables whose values come from methods that offer no error bound, and they say so rather than leaving the question open. Checking those statements against an independent computation is work in progress.

Numbers not found by search

Searching by number answers one question: you have a number — from an experiment, a computation, a paper — and you want to know whether it is already known, and where else it appears.

A few numbers here cannot answer that question, because nobody knows them precisely enough. The exponent of matrix multiplication is only known to lie somewhere in [2, 2.3728596], and the diagonal Ramsey number R(5,5) somewhere in [43, 48]. If searching for 2.3 returned the matrix multiplication exponent, that would not tell you that your number is that exponent — only that a wide range happens to contain your number, which is equally true of every value in it.

So such numbers are left out of search by number. They are marked in the tables with a dagger, like †, and you can still find them by name or by tag — searching for “matrix multiplication” finds the exponent, and that is the useful way to ask about it.

The cutoff is a relative precision of 1e-05: a value counts as identifiable when it is known to roughly that fraction of its own size, which is about five significant digits. Relative rather than absolute, because a number near 10¹² known to within 0.0001 is pinned down far more sharply than a number near 1 known to within the same amount.

The precision that counts is what is actually known about the number, not how it happens to be displayed. A value stored as an exact fraction is known perfectly however it is rounded for display, and a measured value such as 0.88153(17) is known only to the digits its error bars allow.

Python and Sage interface

NumberDB can be searched from Python, and from SageMath or passagemath, with the numberdb package. Search queries can be any string that represents an expression as in the advanced search guide.

The same package serves Sage. Install it into Sage's Python with sage -pip install numberdb, and ask a result for .sage() to get the number as a Sage object. Sage is optional: without it you still get exact values as Python int, Fraction and interval endpoints.

The package also writes. A table's numbers come from a program, and that program is a Generator: a function from one entry's parameters to its value, plus a way to enumerate the parameters. See creating new tables for one in full.

Two questions are worth asking of a table that already exists, and each is one call. Has this table drifted from the code that claims to produce it — after the script changed, or the software underneath it did?

And when something has drifted, the repair is the report handed straight back, so the run recomputes exactly what disagreed and nothing else:

Verifying needs no API key and writes nothing, which is what makes it worth running on a table that takes a day to recompute in full.

A generator also states how well its digits are known, and that claim is checked before anything is published: a value carrying no error of its own cannot be called proven.

Anonymous use is rate limited. See API access.

API access and rate limits

NumberDB has a small JSON API for reading and, with a key, for writing. The API reference lists every endpoint. The numberdb package is the supported way to use it; it handles the response format, the retries and the crash-safety, so you do not have to.

Anonymous use is limited to 60 requests per hour. Searching runs your expression on our machine, and NumberDB is a small volunteer project on a small server — the limit is there so that one script in a loop cannot make the site unusable for everyone else.

An API key raises the limit to 1000 requests per hour. Being logged in on the website counts as identified too. Set the key in the environment rather than in your worksheet, so a notebook you share does not carry it:

Exceeding the limit returns HTTP 429 with a Retry-After header; the package raises numberdb.RateLimitError, carrying the same number of seconds.

Create one on your profile. A key is shown once when it is created and stored only as a hash, so nobody can look it up later — not you and not us. If you lose one, revoke it there and take another.

Keep it out of the code you publish. The package looks for it in NUMBERDB_API_KEY, then in a .env beside your script, then in ~/.config/numberdb/env — the last of which is in no project directory, so it cannot be committed by accident. The keys page shows the exact lines to paste.

A key identifies your account; it does not by itself grant API write access. Writing normally requires 5 accepted edits, or explicit administrator approval. Your API keys page shows your current access. Check this before planning an automated submission. If writing is not enabled, use the website editor or contact info@numberdb.org with your username and proposed contribution. There is no need to make artificial edits to qualify.

Use your own key, never a reviewer's. Keep credential files private (chmod 600) and project .env files out of Git. Do not paste keys into AI conversations, logs, notebooks, generators or table attachments. A locally configured key lets your agent submit without displaying the secret. API write access does not grant permission to review or publish a new table.

If you need more than this — a bulk download, or a systematic study — please get in touch rather than working around the limit. We would rather help.

Getting started

1. Create your account. Sign up, follow any email-verification instructions, and sign in. Contributions are attributed to your account.
2. Check what is already here. Search published tables and the signed-in draft list. Extend an existing family instead of creating an accidental duplicate.
3. For programmatic discovery: use the lightweight catalogue and metadata API, or numberdb.list_tables() and numberdb.table_metadata("T99") in clients providing these helpers. The catalogue follows all tables without downloading their entries. Include draft listings with your own key, search synonyms, and compare definitions and coverage before deciding that a family is missing.
4. Choose a route. Edit on the website or start with New table. Alternatively, prepare a generator with the Python/SageMath package, optionally with a coding agent. Check API write access first.
5. Prepare reproducible, checked work. Keep the original data and sources. State the definition, conventions, parameter range, precision and limitations. Compare with independent computations or known results; the skill explains the standards. Roughly 100 significant digits is the usual target for computed approximations when feasible, not a reason to pad uncertain digits or reject an honestly documented limitation.
6. Inspect and submit for review. Read the rendered draft, entries and attached files. When it is ready, select Offer for review on the drafts page. Creating or filling a draft is not publication; a board reviewer checks it before publishing.

If anything is unclear, contact info@numberdb.org with your username, table link if available, and a description of your contribution. Do not send passwords or API keys.

How to contribute

Contributions range from a corrected reference to a new family of tables. The website database is the source of truth: use the website editor or its API, not a data-repository pull request. You can contribute without an AI assistant and without writing a program. See Getting started for the first steps.

• A wrong digit, a missing reference, a clearer definition:
  Sign in and click edit under the table's title. Your change is published when you save it, and you are asked to say what you changed, because the next person reading the history needs to know. The guide to editing tables has the detail.
• A number that should be here and is not:
  If it belongs in a table that exists, add it in that table's editor. If it needs a table of its own, use new table — see the guide to creating new tables. A title is enough to start a draft; complete it before offering it for review.
• A great many numbers, computed by a program:
  Install the numberdb package, write a generator, and submit checked results with your own API key once your account has API write access. Attach the code and validation evidence so others can reproduce the computation. The table skill explains the conventions, precision and rigour requirements, and submission workflow.
• A question about a particular table:
  Every table has a discussion, linked beside its title, for asking where a value came from, why one looks wrong, or what a parameter means. Anyone can read it; anyone who may edit the table may post. A correction itself belongs in an edit rather than a message — the edit's own note says what changed.
• A bug in the website, or an idea for it:
  The issue page on GitHub, please, or an email to info@numberdb.org. The site's code is at numberdb-website and patches are welcome.

Using a coding agent

A coding agent can help prepare and check a contribution; it is optional, not a substitute for mathematical judgement. Give it your original code and data, papers or source links, conventions, validation results, and any reviewer recommendations. Ask it to read the current skill before starting. For example:

Read https://numberdb.org/skill and use the supplied resources to prepare my NumberDB contribution. Check existing tables and drafts, verify the definitions and numerical evidence, and preserve the original data. Prepare a reproducible generator, independent checks, and draft table descriptions. Explain discrepancies and limitations rather than claiming unsupported precision. Show me the proposed changes before submitting them; do not accept reviews or change unrelated tables.

Inspect the result before authorizing submission. Disclose substantive AI assistance, including the actual tool or model used, following the skill's provenance instructions. You remain responsible for your contribution and for having permission to share its sources and data under the site's licence. If API access is not enabled, an agent can still prepare the content for you to enter through the website.

About the data repository. numberdb-data is where proposals and tables-wanted issues are discussed. Its historical files are not a current mirror or an upstream: the website database holds the current tables, revisions and attached sources. A commit there does not update the website. When answering a wanted issue, report the resulting table links and remaining scope in the issue discussion.

Every change is attributed. Each table records who edited it and when — follow history under its title — each entry can be traced to the edit that last touched it, and everyone who has contributed appears in the list of contributors below.

Guide to editing tables

Sign in and click edit under any table's title. You get the table's editor, with a preview of how the page will look. Nothing is saved until you press Save.

• Show preview renders your version exactly as the table page will render it, so you can see the result before committing to it.
• Show changes lists what you have actually altered, which is the only practical way to check an edit to a table of a thousand entries.
• Save records a revision. A published table updates immediately; an unpublished draft remains a draft.

For a new contributor, edits to numbers and explanatory text need review. A change to a definition or formula matters even when the digits are unchanged. Numbers awaiting review are excluded from search by number; a published table's page still shows its current contents and review status. Read the preview and changes, and write an edit message explaining what changed and why.

If two people edit at once, edits to different entries are combined automatically. Edits to the same entry are not guessed at: you are shown both versions and nothing is saved until you decide.

For more advanced changes, it is worth reading the format for tables. You can also try the preview page without an account, which renders any table source without saving anything.

Existing tables are edited here and nowhere else. The data repository numberdb-data is where historical versions can be read, cited and forked. It is not a current mirror, and changes there are not imported here. Rebuilding from that archive is a retired workflow: it would discard later website edits and their history. Use the website or its authenticated API to change tables, and database backups to recover the site.

Creating a new table is done here too; see the guide below.

Guide to creating new tables

Sign in and use new table. You are given a short form: a title is enough to create a draft. You may also enter the definition and parameter names, then complete the table in its editor. No API key is needed for this route.

A draft may initially have no entries. Fill in the definition, indexing and normalization, coverage, references, and how the values were obtained and checked. Where computation is involved, supply a reproducible generator and validation evidence. Use the API to attach files, or contact the team for help with attachments if you are contributing through the editor.

Draft contents are readable by their authors and board members. Signed-in users can see that a draft exists on the drafts page, which helps avoid duplicate work. Drafts do not appear in public table listings or number search. Once your draft is complete and has entries, inspect its preview and select Offer for review on that page. Saving or filling a draft does not offer it automatically. A board reviewer can publish it after checking the work.

The draft receives a T-number when created; publishing preserves that identifier. Use the T-number URL for citations, or a revision link when citing a particular version. Renaming a table updates its readable, title-based URL; recorded old URLs redirect permanently to the current one. Extending a table does not change its T-number. Name the natural mathematical family, and put the current finite range in its completeness metadata rather than the title.

An entry's identity — the thing a citation, an anchor and a search result all point at — is its parameter values. So the set of parameters and their order are fixed once the table is published: changing them afterwards would not break existing citations, it would leave them resolving successfully and pointing at different numbers, which no amount of checking can catch. Their types, constraints and display can be changed at any time, since none of those enters an identity.

Most tables should have code that can recompute their entries; it is the difference between a number a reader can check and one they have to take on faith. Install the numberdb package and read the skill. This read-only example checks an existing table in SageMath:

from sage.all import RealBallField
import numberdb.sage as numberdb

class Zeta(numberdb.Generator):
    table = 'T14'
    parameters = ('n',)
    type = 'R'
    digits = 100
    rigour = 'proven'

    def enumerate(self, limit=1000):
        for index in range(2, limit + 1):
            yield {'n': index}

    def value(self, params, digits):
        field = RealBallField(numberdb.bits(digits, losing=20))
        return field(params['n']).zeta()

Zeta().verify()

This uses ball arithmetic throughout, with 20 extra working digits; the computed error bounds still have to justify the requested 100 digits. Verification does not submit changes. For a new contribution, point the generator at your draft's T-number, adapt it to your family, and check it independently. After inspecting the proposed changes, use Generator.publish() to submit entries with your configured key. Despite its name, this method neither publishes a draft nor offers it for review; offer it separately after checking the uploaded result and files.

Writing it as a function of one entry's parameters, rather than as a script that computes everything, is what makes the other three things possible: extending the table is the same call with a larger bound, recomputing it to greater precision is a larger digits, and checking it can sample ten entries instead of regenerating a table that may take days. A check that takes seconds is a check that gets run.

See API access before planning a submission. Read-only checks of public tables work without a key; reading your private draft requires authentication. The skill describes independent checks and honest rigour labels for computations without certified error bounds too.

Format of a table

A table is written in YAML, as a set of named sections. Only Title and the entries are required; everything else is there when it has something to say.

Title: Zeros of the Riemann zeta function

Definition: >
  The imaginary parts of the nontrivial zeros of $\zeta(s)$.

Parameters:
  n:
    type: Z
    constraints: $n \geq 1$
    display: $n$

Data properties:
  type: R
  complete: no
  sources:
  - CITE{Odlyzko}

Numbers:
- params: {n: '1'}
  number: 14.134725141734693790457251983562470270784257115699243175685567460149?
  comment: the first zero
- params: {n: '2'}
  number: 21.022039638771554992628479593896902777334340524902781754629520403587?

Each entry is a record: params saying which entry it is, a number, and anything else you want to say about it. The parameters are named in every entry, which is what makes a citation stable — an identity that depended on the order they happen to appear in would still resolve after somebody reordered them, and would point at a different number.

A value is always text, never a bare decimal. YAML would read 3.14 as a floating-point number and hand back whatever the nearest one is, which is a different number from the one you wrote. The same rule is why complete: no means the word "no": YAML 1.1 would read it as false.

Real numbers are written with a ? on the end, marking the last digit as uncertain: 3.14159? is a value known to lie in that range, not a claim that it stops there. Complex numbers are written a + i * b, with the i first — an imaginary part can run to a hundred digits, and wherever a value is shown abbreviated the beginning is what a reader sees, so that is where the marker belongs. Exact values — integers, fractions, polynomials — are written out in full.

Title	Required. Renaming a table does not change its address.
Definition	What these numbers are, in a sentence or two. LaTeX is allowed anywhere prose is.
Parameters	The names, in the order the entries use them, each with a type, optional constraints and how it is displayed.
Numbers	The entries. Called Data in a few older tables; both are read.
Data properties	type, complete, sources, reliability, and repeats.
Data properties: rigour details	How the digits were obtained — the one field with room to explain itself. Blank lines separate paragraphs, a line beginning - is a list item, and `backticks` mark code; $\ldots$, CITE{} and HREF{} work as everywhere else. A note longer than a paragraph shows its first one and folds the rest, so it can be as long as the mathematics needs without taking over the page.
Display properties	How the table is laid out — number-header, group parameters.
Comments, Formulas, References, Links, Keywords, Tags, Similar tables	Prose and pointers. CITE{key} refers to a reference, HREF{Table_name} to another table.

Data properties: type says what the values are:

Z, Q	integers and rationals — exact, written in full
R, C	real and complex numbers, to a chosen precision
Qp	p-adic numbers, carrying their precision as O(p^k)
Z[], Q[]	polynomials — exact

A parameter's type may also be Symbolic, for one whose values are names rather than numbers: Co1, unit-s, a_n/n!.

A hundred significant digits, and up to about a thousand entries, is what a typical table holds. Neither is a hard rule, and going over is fine when there is a reason — a complete family that happens to be larger, or digits that were expensive to compute. Say the reason in a Size exception line under Data properties and nothing more is asked.

A hundred digits is the suggestion because cheap digits carry no information: anybody who wants the thousandth digit of a value that evaluates in a second can compute it themselves, and a hundred is far more than enough to identify a number, which is what this database is for. Digits earn their place when they were hard to get. A table that says it is complete is never asked to justify its size, since truncating a complete table does not make it smaller, it makes it wrong.

Two tables can hold the same number for two very different reasons. The Gauss–Kronrod table stores, for each rule, the nodes of the Gauss rule embedded in it — the same roots of the same Legendre polynomial that the Gauss–Legendre table already lists, transcribed. Hermite's constant in dimension 8 equals the Hermite number of $E_8$ for an entirely different reason: somebody proved that the largest value over every lattice is reached at that one.

Only the first is a repetition. The second is two constructions meeting, which is among the most interesting things this database can tell you about a number, and both tables should answer a search for it. Nothing in the values themselves separates the two cases — each is exact equality — so a table that repeats another says so, once, under Data properties:

Data properties:
  repeats: HREF{Nodes_and_weights_of_Gauss_Legendre_quadrature}

It means: where this table's values coincide with that one's, that table states them first. A search that finds the number in both then answers with the original and names this table beside it, rather than saying the same thing twice. Where the two tables hold different values — the rest of this table — nothing is folded and both answer normally.

Say it only where this table repeats that one's computation: the same quantity of the same object. If the values agree because of a theorem, leave it out. The declaration is kept one step deep, so a table that some other table repeats may not itself be declared a repetition of a third; point at the table that states the values first.

The ID is not part of the document. It belongs to the table, is allocated when the table is created, and is ignored if you type one. You will see it at the top of the exported file, where it is put back so the file can be read on its own.

Unknown keys on an entry are kept and shown, so the format can carry something new without waiting for anybody to permit it — that is how proof, url and both signs came to exist. A key that is nearly a known one, like numbr, is refused instead, because a misspelt number is not a note about the entry, it is a value that would silently vanish.

Frequently asked questions

• Why do I need to specify the period in the real number search?
  Because the period is even more significant than the highest digit. In principle, one could implement a search of real numbers by their first few digits without the knowledge of the period; however this would ask for numbers up to powers of 10, which does not seem natural enough in general. We implemented a search by the fractional part, as it does not depend on the base.

Work in progress

NumberDB is in active development. Here is what is available and what still needs work. Since this list was first written, most of it has been built. Complex numbers and p‑adic numbers are searchable; there is an API and a Python and Sage package; tables are edited here on the site rather than through pull requests, and every table records who changed it and when. What remains:

• More numbers and tables
  The aim is around 10 000 tables of around 1000 numbers each — some 10⁷ numbers, which can still be searched by ten digits. There are currently rather fewer, and which numbers are chosen is decided by their simplicity and significance. Contributions are greatly welcome.
• Search results ordered by significance
  At present a search returns what matches, not what you most likely meant.
• Rating and watching
  Every table now has a discussion, linked beside its title, for asking where a value came from or why one looks wrong. What does not exist yet is any way to rate a table, or to be told when one you care about changes.
• Reproducing a table from its own record
  A table carries the program that produced it, and can be downloaded whole. It is not yet true that every table's program can simply be re-run to rebuild it: fifteen tables carry a generator that recomputes them on demand, and the rest were made by scripts that predate this arrangement and are kept as history rather than as something to run.
• Checking the numbers against an independent computation
  Every table now says how well its digits are known, but saying is not checking. Eighteen tables, some thirteen thousand values, are recomputed from their definitions in ball arithmetic and compared against what is stored. That has found real errors — one table's last three digits were wrong in a thousand entries, and another held a value with the right digits and the wrong sign. The tables it cannot yet reach are those no independent implementation exists for, which are also the ones whose stated rigour is weakest.

Licence

The data in NumberDB is licensed under CC BY-SA 4.0. Use it, cite it, build on it — credit NumberDB with a link to numberdb.org or to the table you used, and share what you build on the same terms.

If a use of yours cannot meet the ShareAlike condition — a textbook whose publisher cannot relicense the whole book, or a dataset that must be CC0 to be accepted elsewhere — write to info@numberdb.org. We would rather arrange something than refuse.

Contributions are covered by the Contributor's Licence Agreement. You keep the copyright in what you write, it is published under CC BY-SA 4.0, and you are credited above.

The software is separate: the website is GPL-3.0-or-later, and the numberdb package is MIT.

Some content comes from elsewhere and keeps its own terms. Sequence names from the On-Line Encyclopedia of Integer Sequences are © the OEIS Foundation Inc., licensed CC BY-SA 4.0. Values drawn from Wikipedia are numerical facts, which carry no copyright, and are stored with a link to the article they came from.

List of contributors

Contributor	Number of table edits
zeta3 (a program)	3683
Benjamin Matschke	1086
Eran Assaf	3
Alex J Best	1

Acknowledgements

NumberDB is built on, and runs on, various open-source projects. The mathematics is done by SageMath, Pari/GP and arb, whose interval and ball arithmetic is what lets a number be stored with its accuracy rather than as a decimal that means nothing in particular. The site itself is Django and PostgreSQL, with Gunicorn, nginx and Docker, certificates from Let's Encrypt, accounts by django-allauth, and NumPy, PyYAML and git underneath. Formulas are set by MathJax, code is coloured by highlight.js, and the type is Source Sans Pro — all three served from this site, so that reading a page here tells nobody else that you did. NumberDB's repositories are stored on GitHub.

Parts of NumberDB's code and documentation were written with the help of AI coding assistants — in particular Claude Code and Codex CLI, and the language models behind them — always under human review. Responsibility for the code, and for the mathematics, rests with the developers.

NumberDB's server is funded by the main developer Benjamin Matschke.