This is an experiment that was created out of curiosity. The purpose is to see how computer generated sequences
take form given certain restrictions. It's inspired by the great
On-Line Encyclopedia of Integer Sequences database but with the intention to be
entirely machine generated.
If you have any feedback or questions, please don't hesitate to contact me. You can contact me at jon AT jonkagstrom
DOT com or
Searching is simple, just enter a few sequential terms and hit enter.
Search by formula
To find all sequences matching a formula, just enter it in the search bar. You can combine it with sequence terms and tags.
For now, the entered formula has to match with the generated so it can be hard to get it fully right, however
specifying parts of the formula is enough.
Matching sequences containing 3,4 that are recursive, a(n-1), and uses partition numbers, P.
Search by sequence tags
You can combine a sequence with multiple tags to narrow down the search. The sequence tags only describe the first 50
terms so you should think of it as 'so far monotonic', 'so far periodic' etc.
- constant - matches constant sequences (1, 1, 1)
- integer - matches integer sequences (1, 2, 3)
- decimal - matches decimal sequences (1, 2.2, 3)
- positive - matches positive sequences (1, 2, 3)
- negative - matches negative sequences (-1, -2, -3)
- non-monotonic - matches non monotonic sequences (1, 3, 2, 1)
- monotonic - matches monotonic sequences (1, 2, 2, 4)
- strictly-monotonic - matches strictly monotonic sequences (1, 2, 3, 4)
- non-periodic - matches non periodic sequences (1, 2, 3, 2, 3)
- non-periodic-tail - matches non periodic tails (...1,2,3)
- periodic - matches periodic sequences (1,2,3,1,2,3)
- oeis - matches any sequence with an oeis entry
- irregular - matches irregular sequences (1, 4, 2, 9, -1)
- periodic-n - matches sequences with a period of n
- A000041 - matches sequence with the exact OEIS id
Search by function tags
You can filter your searches on function tags. I have grouped functions a bit arbitrary, let me know if you find
- fn-constant - matches functions that use a constant (1,2,3...)
- fn-variable - matches functions that use a variable (n)
- fn-arithmetic - matches arithmetic functions (+,-,*,/)
- fn-recursive - matches recursive functions (a(n-1)...)
- fn-special - matches special functions (abs, floor...)
- fn-divisibility - matches divisibility functions (gcd, %...)
- fn-power - matches power functions (pow, exp, ln...)
- fn-trigonometric - matches trigonometric functions (sin, cos...)
- fn-combinatoric - matches combinatoric functions (factorial, binomial...)
- fn-prime - matches prime functions (p(n), gcd, omega...)
- fn-non-constant - negates the fn-constant tag
- fn-non-variable - negates the fn-variable tag
- fn-non-arithmetic - negates the fn-arithmetic tag
- fn-non-recursive - negates the fn-recursive tag
- fn-non-special - negates the fn-special tag
- fn-non-divisibility - negates the fn-divisibility tag
- fn-non-power - negates the fn-power tag
- fn-non-trigonometric - negates the fn-trigonometric tag
- fn-non-combinatoric - negates the fn-combinatoric tag
- fn-non-prime - negates the fn-prime tag
Here are a few examples on different generated sequences.
0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529,
This common sequence is generated either directly by
1, 2, 2, 4, 2, 4, 2, 4, 6, 2, 6, 4, 2, 4, 6, 6, 2, 6, 4, 2, 6, 4, 6, 8, 4
n*n or recursively by
Gaps between consecutive primes, generated by
2, 1.5, 1.6666666667, 1.6, 1.625, 1.6153846154, 1.619047619, 1.6176470588, 1.6181818182, 1.6179775281,
1.6180555556, 1.6180257511, 1.6180371353, 1.6180327869, 1.6180344478, 1.6180338134, 1.6180340557, 1.6180339632,
1.6180339985, 1.618033985, 1.6180339902, 1.6180339882, 1.618033989, 1.6180339887, 1.6180339888
Decimal sequences may converge into interesting constants, the generated program
1, 2, 2.5, 2.6666666667, 2.7083333333, 2.7166666667, 2.7180555556, 2.7182539683, 2.7182787698, 2.7182815256,
2.7182818011, 2.7182818262, 2.7182818283, 2.7182818284, 2.7182818285, 2.7182818285, 2.7182818285, 2.7182818285,
2.7182818285, 2.7182818285, 2.7182818285, 2.7182818285, 2.7182818285, 2.7182818285, 2.7182818285
(a(n-1)+1)/a(n-1), a(0)=2 converges into the golden ratio, ~1.618033988.
Here is another famous constant e (2.7182818285...) generated by
1, 2, 3, 3.75, 4.375, 4.8125, 5.2135416667, 5.5393880208, 5.8471317998, 6.1129105179, 6.3312287507, 6.5422697091,
6.7239994232, 6.8920994088, 7.0561970138, 7.209592601, 7.3482386126, 7.4749323818, 7.5995145881, 7.7146587486,
7.8248681593, 7.9335468837, 8.0352590232, 8.1332499869, 8.2256732822, 8.3113573789
This sequence is probably the reason I built this site. A while back I was playing with the Sieve of Eratosthenes.
By counting how often each term strike out following composite numbers this sequence appeared.
3 strikes out every second, 5 every third, 7 every 3.75, 11 every 4.375 and so on. I had no idea that this was
Euler Zeta with exponent 1 at the time. I asked a friend who is very good at maths to figure out the formula,
and after a while he came back with the answer. Somewhere here I figured that a program should be able to give me
answers, so I don't have to ask my friend all the time :) This formula is closely related to the Riemann hypothesis.
The generated code is
Finally a sequence I ran into by chance when I was adding charts to the site. I've no idea what it means or if it has
any value. But it looks pretty funky.
(n-a(n-1))/(a(n-2)+a(n-2)), a(0)=1, a(1)=2
The algorithm generates stack machines that are executed with different input (0≤n<N). The output of each execution form
a sequence that is stored. Duplicated sequences are detected, so that different stack machines can generate the same
sequence. The simplest stack machine per function class is chosen. I'm not a mathematician so I have kind of made up
a definition for each function type (constant, n, prime, recursive and prime-recursive). What more types could I add?
- 2017-06-17 - Added binomial coefficient which will allow Catalan numbers and
similar without too deep searches (thanks @renner96)
2017-06-20 - Added the recursive function t=a(n-3) (generates tribonacci numbers
2017-06-20 - Added the modulo operator %
2017-06-24 - Stack machines can execute with arbitrary precision
2017-07-17 - Added log and negation(-) operations. Hover
OEIS links to see description. Decimal expansion
recognition. Many improvements behind the scenes.
2017-07-21 - Using 50 terms instead of 25 for indexing. Added floor. Use high
precision at top
when opening sequence. Added ~ for approximate searches (each term within 5%) e.g. ~17,20,26,33,41,46,55,66.
Bunch of bug fixes.
2017-07-23 - More robust OEIS matching. Added exp and gcd operations.
2017-07-24 - Added absolute value, abs.
2017-08-17 - Added sqrt, ceil and round. Fixed high
precision generation bugs that resulted in CPU hog.
2017-08-18 - Added factorial, sin, cos and tan.
2017-09-16 - Added prime related functions
τ(n)=number of divisors of n,
ϕ(n)=Euler's totient function,
Ω(n)=max factorization terms and
2017-09-20 - Added Λ(n)=Von Mangoldt's function and Pi
Also marked seemingly periodic sequences.
2018-05-16 - Cross referenced with all new sequences from OEIS.
Fixed bug in OEIS sequence matcher.
Added periodic/monotonic stats the statistics page.
Added periodic-n to sequence tags.
2018-05-20 - Added P(n)=partition numbers. Added preliminary tag search
You can combine those in the search bar with the sequence, e.g. 1, 2, 3, 5, 6, ln integer oeis, more info later.
Added constants 11-99.
2018-05-25 - Some optimizations for searching on tags. Added information on how to search.
2018-05-26 - Added search tags for function types.
2018-05-31 - Improved tag descriptions. Discarding periodic sequences that uses lookup functions. Memory
optimizations. Fixed OEIS matching bug.
2018-06-01 - Added more seeds for recursion. Added
ζ(n)=Riemann Zeta and
Z(n)=non trivial zeros of Zeta
2018-06-05 - Rewrote OEIS matching, better decimal expansion matching and improved sequence generation.
2018-06-06 - Fixed bug that didn't display the decimal expansions.
2018-06-08 - Improved the expression filter. Better sorting of operators (n*2=>2*n etc).
2018-06-13 - Added lcm(n)=least common multiple. Improved storage model,
paving way for more intelligent generation.
2018-06-15 - Improved search. Using function classes to classify programs (formulas). OEIS tagger fixes.
Ln is now log and a bunch of bug fixes.
2018-06-21 - Added
σ(n)=divisor sum of n,
pt(n)=Pascals triangle rows,
lpf(n)=least prime factor of n and
gpf(n)=greatest prime factor of n. Improved generation. Disabled auto
capitalization for mobiles.
2018-06-28 - Putting formulas between '[' and ']' this will help the query parser.
For example [log(2 * n)].
Added aliases for operations e.g. π=pi
Instead of ignoring errors in the search query, they are displayed.
2018-06-30 - Binomial and lookup function bug fixes, fixed approximation searches ~ bug.
2018-07-02 - Added min-terms-n to filter out short sequences.
Added paging of search results. Added stern and
abelian group count. Added square operator ².
2018-07-05 - Sub sequence matching improved, index title for faster lookup. Bug fixes.
2018-07-06 - Fixed problem with links.
2018-07-13 - Stack machines can be executed in sub steps which allows for new functions:
characteristic functions and complement
functions. Also added composite numbers.