Find sequences containing the given terms consecutively, like the OEIS search box.

terms: comma-separated integers, e.g. "1, 2, 5, 14, 42, 132". At least 4 consecutive terms with some |term| >= 10 are needed (shorter or tinier queries are too generic to index). ext: search DATA plus b-file terms instead of DATA only. sub: instead of the whole query, report every maximal common run of >= min_run terms between the query and a sequence (useful when the query has a wrong term or a different start), longest first. Each hit gives the A-number, name, keywords, offset, and where the match starts: at is the index into the sequence's terms (0-based), n the corresponding n (offset + at).

Run many exact term searches at once (each as in search_terms with sub=False).

queries: list of comma-separated term strings. Returns, per query, the total number of sequences containing it and up to limit of their A-numbers with the match position. Queries too generic to index come back with an error instead of hits.

Find sequences whose text fields match a word, phrase or regex (case-insensitive).

pattern: a plain word/phrase (fast literal scan) or a Python regex, e.g. "Catalan", "plane partitions", r"\bLyndon words?\b", "Sloane, \d{4}". fields: any of name, comments, formula, xrefs, links, author, programs, keywords; or ["all"]. Default: ["name"]. Hits are in A-number order. Each gives the name and keywords, and, when the match is outside the name, a snippet around the first match.

One OEIS entry from the snapshot.

anum: "A000108" (also accepts "108", "a108"). fields: which text fields to include (name, comments, formula, xrefs, links, author, programs, keywords, or ["all"]); default name, keywords, formula, comments, xrefs, author. Terms and offset always come back. ext: return DATA extended with the real b-file terms (up to 256) instead of DATA. max_terms: cut the terms to this many. max_chars: cut each text field (links and programs can be long). For the exact internal-format record (%S/%N/%E... lines, incl. extensions), use get_raw_entry.

The entry's record exactly as stored in oeisdata (internal format: %I %S %T %U %N %C %D %H %F %e %p %t %o %Y %K %O %A %E lines), including extension (%E) lines that get_entry does not carry.

Short summaries of many entries at once: name, keywords, offset, number of terms and the first n_terms terms. Unknown A-numbers come back with an error.

Lines of the entry's b-file from the local oeisdata clone (n, a(n) pairs), when it was fetched with git lfs. start/count select lines of (n, a(n)) data, comments skipped.

Is this sequence a simple transform of a known OEIS sequence? A local "superseeker".

Give either terms (comma-separated, with their offset, i.e. the n of the first term) or an anum (its own terms; the entry itself is never reported). Every chain of up to depth (1-3) of ~140 primitive transforms is applied (x or / by n!, (2n)!, 2^n, n, Catalan, Bell, ...; binomial, Euler, weigh, EGF exp/log, INVERT, Stirling, Moebius and their inverses; partial sums, differences, bisections, signs, +-1, ...) and each result is looked up in the term index. Depth 1 takes about a second; depth 2 (~20k lookups) can take tens of seconds, and stops after time_budget seconds (complete=false). A hit needs a long, informative common run (>= 6 terms at depth <= 1, >= 8 at depth 2, >= 10 at depth 3) and agreement up to the end of one of the two. Each hit says which side has more terms: match_extends_query: the match continues past your terms (it may give new terms of your sequence); query_extends_match: your transformed terms continue past the match's DATA. Hits are empirical identities, to be proved before use.

Guess a P-recursive (holonomic) recurrence sum_{i=0..r} p_i(n) a(n-i) = 0 with deg p_i <= d, and predict further terms from it.

Give either terms (comma-separated, with the offset = n of the first term) or an anum (its terms; ext=True uses DATA + b-file terms). (r, d) are tried in order of the number of unknowns (r+1)(d+1); the first whose kernel is one-dimensional (mod a 61-bit prime, then exactly over Z) with at least spare more equations than unknowns is returned. Constant coefficients are d = 0. A guess, not a proof; spare_equations says how much the data over-determines it, and integral whether all predicted terms came out integers.

Can an entry be extended from its own stated relations? Parses the entry's "a(n) = <expr in n, a(), and A######()>" FORMULA lines and its "Euler / binomial / INVERT / ... transform of A######", "partial sums of A######" phrases (NAME, COMMENTS, FORMULA), checks each against the entry's known terms (all but at most the first 3 must agree, at least 6), and evaluates it past them on the other sequences' current terms (ext=True: DATA + b-file). Lines flagged as conjectural ("appears", "seems", "empirical", ...) are skipped. Each relation that gives new terms is returned with the new terms (from n = offset + n_terms on). The relation is the entry's own claim; check its source before using the terms.

Which snapshot is loaded and what is indexed.