HomeCalculatorsMathNumber Theory & Discrete MathSequence Calculator
Math calculator

Sequence Calculator

Calculate exact integer terms and sums for arithmetic, geometric, Fibonacci and linear recurrence sequences. Check indices, limits, examples and full exports.

Instant result
Result
—

Enter values to calculate.

Inputs—
Mode—
Formula—
Trust summary CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance · four integer sequence modes andfour entries
Input interpretation
Enter values to calculate.
Result
—
Verified scope
four integer sequence modes andfour entries
Assurance
Core
Declared partition coverage
PASS · 5/5 declared partitions (arithmetic, geometric, fibonacci, linear_recurrence, invalid) · Matrix
Known limitations
  • Core CVP does not include live graph, viewport, or pointer interaction.
Model
a_n / F_n / u_n for integer sequences, plus S_n for AP/GP/Fibonacci, with an engine-linked stem figure of a_k through n.
Scope
The Result Card includes an engine-linked stem figure of a_k (marker is published term; at most 16 indices, window ending at n). Same closed form / recurrence as REST/MCP. Terms array is not a REST field. Huge BigInt terms omit the figure.
Verification
Engine tested · Source checked · v1.0.3 · CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance · four integer sequence modes andfour entries· View Manifest · CVP overview · Specification
Versions
Calculation 1.0.3 · CVP protocol 1.0.0-proposed · Evidence 2026-10-28.meta-metrics-v2
Verification revision
2026-10-28.meta-metrics-v2 · 2/2 property · digest 862921453e34
Legacy regression
12/12 tests · Production surface contract 6/6
Trust layers
Verification VERIFIED · Production CURRENT · Overall CVP state: VERIFIED under CVP 1.0.0-proposed
Reference
O1 model · O2 expected_values · O2 numerical_behavior
Interfaces
PASS · UI (SSR) / REST / MCP — ui-ssr is query-result HTML, not a live browser session. Error-path engine·REST·MCP 29/29 (status, code, calculation_version). SSR compared on URL-canonical requested calculations; empty query is idle (not an error) and JSON-typed object/array inputs are REST/MCP-only.
Supplemental domain review
Not performed
Named expert review
Not performed
CVP suite
37/37 golden · 1/1 CVP boundary · 31/31 invalid · 2/2 property · 2/2 metamorphic · 69/69 cross-interface · 1/1 cross-calculator · 6/6 CVP contract · Manifest
Sources
Sources
Evidence
4 legacy golden · 2 legacy boundary · legacy regression suite · 37/37 oracle-backed golden · 31/31 invalid · Artifact integrity PASS
This calculator CURRENT · Public schema 1.0.3 matches · Semantic contract ✓ · Production attested · Public/cache ✓ · Origin ✓
Semantic contract
PASS
Full verification

Manifest identity, reference classes, interfaces, suite, and production records.

Formulas

Core equations used by this calculator.

Arithmetica_n = a + (n−1)d
Geometrica_n = a r^{n−1}
FibonacciF_n = F_{n−1} + F_{n−2}
iIntegers only. Exact BigInt. n ≤ 1000. Not Pascal’s triangle, not integer partition, not n!. Engine id is sequence — never the add/sub arithmetic engine.

How to use

1

Choose a mode

Arithmetic, geometric, Fibonacci, or linear recurrence. Locked discovery URLs exist for the first three.

2

Enter n and the parameters

Fibonacci allows n=0. Arithmetic/geometric need n≥1.

3

Read a_n (and S_n)

Sums are exact integers. The figure shows a stem plot of a_k through n.

Example calculations

Common configurations with formula and result.

ϟ

AP

a=2 d=3 n=5

2,5,8,11,14
14
ϟ

GP

a=3 r=2 n=4

3,6,12,24
24
ϟ

F_10

F_0=0

F_10
55

Sequence calculator specification

Version 1.0.3 · Engine tested

Calculation status

Review policy · Evidence

Definition
Closed forms for arithmetic and geometric sequences, iterative Fibonacci F₀=0 F₁=1, and uₙ = p uₙ₋₁ + q uₙ₋₂. Discovery pages share this capability. Not combinatorics.
What it calculates
a_n / F_n / u_n for integer sequences, plus S_n for AP/GP/Fibonacci, with an engine-linked stem figure of a_k through n.
Inputs
  • mode
  • n
  • a
  • d
  • r
  • p
  • q
  • a0
  • a1
Outputs
  • term
  • sum
  • exact
Formula
a_n = a+(n−1)d or a r^{n−1}; F_n recurrence
Assumptions
  • The Result Card includes an engine-linked stem figure of a_k (marker is published term; at most 16 indices, window ending at n). Same closed form / recurrence as REST/MCP. Terms array is not a REST field. Huge BigInt terms omit the figure.
  • Integers
  • n ≤ 1000
  • Not Pascal / partition / n!
Units
  • dimensionless
Boundary conditions
  • unknown mode (including pascal) → INVALID_MODE
  • n=0 on AP/GP → VALUE_MUST_BE_POSITIVE
  • n>1000 → VALUE_ABOVE_MAX
Example
mode=arithmetic a=2 d=3 n=5 → 14
Validation cases

2 published on this page · 12/12 tests · Production surface contract 6/6 · View evidence

  • mode=arithmetic a=2 d=3 n=5 → term=14 sum=40
  • mode=fibonacci n=10 → 55
Sources
  • ISO 80000-2:2019 Quantities and units — Mathematics
    Supports: Mathematical symbols and notation. This standard is not numerical verification or an endorsement of this implementation.
  • Knuth, The Art of Computer Programming, Fibonacci F₀=0 F₁=1 and linear recurrences
    Supports: F_n = F_{n-1}+F_{n-2} with F_0=0; u_n = p u_{n-1} + q u_{n-2}
  • Margaret Stevens — The Maths Workbook (University of Oxford) — Chapter 3, §2: Arithmetic and Geometric Sequences and Series
    Supports: Arithmetic terms and sums from first term and common difference, geometric terms and finite sums from first term and common ratio, including derivations. At ratio 1 the finite geometric sum is n times the first term; it is the removable special case of the quoted expression. Mathematical reference only; not implementation validation or an endorsement of CalculatorX.
  • MIT Mathematics for Computer Science — Fibonacci Recurrences — §15.4 Solving Linear Recurrences
    Supports: The Fibonacci recurrence with F₀=0 and F₁=1, its generating function and Binet expression. The recurrence identifies the mathematical sequence; it does not independently test a fast-doubling implementation. Mathematical reference only; not implementation validation or an endorsement of CalculatorX.
Calculation version
1.0.3

Background

Interpretation and common distinctions.

What does this sequence calculator compute?

Closed forms for arithmetic and geometric sequences, iterative Fibonacci F₀=0 F₁=1, and uₙ = p uₙ₋₁ + q uₙ₋₂. Discovery pages share this capability.

The published formula or method is a_n = a+(n−1)d or a r^{n−1}; F_n recurrence. The following references support the stated mathematics or method:

  • Margaret Stevens — The Maths Workbook (University of Oxford): Arithmetic terms and sums from first term and common difference, geometric terms and finite sums from first term and common ratio, including derivations. At ratio 1 the finite geometric sum is n times the first term; it is the removable special case of the quoted expression. Mathematical reference only; not implementation validation or an endorsement of CalculatorX.
  • MIT Mathematics for Computer Science — Fibonacci Recurrences: The Fibonacci recurrence with F₀=0 and F₁=1, its generating function and Binet expression. The recurrence identifies the mathematical sequence; it does not independently test a fast-doubling implementation. Mathematical reference only; not implementation validation or an endorsement of CalculatorX.

Which inputs and limits should you check?

Check the sequence type, starting-index convention, and finite-term count. Preserve complete terms and exact integers where the result provides them.

The worked example uses a=2 d=3 n=5 with 2,5,8,11,14. Compare it with the Example calculations and the complete result for the same inputs.

How can you verify and cite this result?

CalculatorX is responsible for this page. The mathematical references above explain the model; implementation checks and their scope are documented separately in the math.sequences v1.0.3 Evidence and capability contract. Read the displayed verification and production state together with the specification's numerical limits.

Use the clean calculator URL to cite the tool. A shared input link identifies a particular calculation. Content updates, numerical verification, and domain reviews have separate dates and scopes.

Exact integer scope and verification

This entry belongs to math.sequences and its four modes: arithmetic, geometric, Fibonacci and second-order linear recurrence. AP/GP use indices 1–1000; Fibonacci/recurrence allow 0–1000. F₀=0, F₁=1; the recurrence is uₙ=p·uₙ₋₁+q·uₙ₋₂ with supplied a₀,a₁. The Fibonacci sum is F₀+…+Fₙ; recurrence mode returns the term without claiming a partial sum. GP handles r=0,1,−1 explicitly; for n=1 the first term is returned even when r=0.

Coefficients are signed integer digit strings of at most 48 digits, and every raw token is at most 512 characters before trimming. Index tokens contain at most 4 digits. Leading zeros count toward the limit. Finite safe JSON integers are also accepted; fractional, unsafe numeric, decimal/scientific string, hex, boolean and null inputs are rejected. Explicit empty input is an error. Aliases must agree; unknown and inactive fields are rejected. Preset entries lock their mode and reject a conflicting mode.

BigInt calculations are exact relative to accepted integers; there is no floating-point rounding tolerance. Results within ±9007199254740991 are JSON numbers; larger integers are exact decimal strings. All term/value/exact, applicable sum/previous term, conventions and diagnostics remain in the complete JSON/CSV export. Large results are fully available in the result and work. Relative sensitivity can be large when p/q or positive/negative terms nearly cancel; exact accepted inputs do not remove uncertainty in measured inputs. Noninteger, real-valued and infinite series are outside this calculator's domain.

The stem figure contains at most16 ending indices. It is omitted with an explicit notice when any plotted integer exceeds safe coordinates or distinct terms cannot be resolved at the chosen scale. Text and exports retain the full integers; absence of a graph does not mean zero or no solution.

The independent reference uses Python arbitrary integers: AP/GP enumeration and matrix powers for Fibonacci/recurrence, unlike the production closed forms/iterative recurrences. The current fixed suite has 37 independent complete packs, strict keys/types/values/metadata and comparator negative controls. This scope is not exhaustive proof over all inputs or third-party certification. Previous1.0.1 verification pins remain immutable.

Typing calculates locally. Shared URLs contain inputs and send them to the host; REST/MCP send supplied inputs. Browser/server logs may retain requests. No zero-log or whole-site network privacy guarantee is made.

Model definitions: NIST Fibonacci recurrence and Western University sequences and finite sums. These sources explain mathematics, not implementation certification.

Frequently asked questions

Key distinctions behind the calculation.

Is this Pascal’s triangle?

No. Binomial coefficients stay /calc/math/permutation-combination. Integer partition is out of scope.

Which Fibonacci indexing?

F_0=0, F_1=1. Linear recurrence with p=q=1, a0=0, a1=1 is the same sequence.

Where does this run?

Locally in the browser by default. REST and MCP call the same sequence engine.