2026-09-29 9 min

Recursive Sequence Calculator

Generate a first-order linear recurrence a(k) = p·a(k-1) + q from a1, with term list and closed-form check.

Calculator

Recursive Sequence Inputs

Seed (a1)

Multiplier (p)

Addend (q)

Position (n)

Results update live as you type

Status:a(5) = 31closed = 31

Recursive Sequence Summary

nth term31

Closed-form check31

Setupa1=1, p=2, q=1, n=5

Term list

1, 3, 7, 15, 31

Preview iterates the first 10 steps; a(n) iterates all n steps.

Results

Optimal

nth Term (iterated)

Loop result

Closed Form Check

Must match iterated

Fixed Point q/(1-p)

-1

p = 1 has none

Seed a1

Start

Position n

Index

Iteration and the geometric-sum closed form are computed independently; agreement audits the result.

Visualizations

Recursive terms

1a1

3a2

7a3

15a4

31a5

Recursive trajectory

Steps iterated

n / 10005

Iterated vs closed form

iterated31

Formula

Each term scales the last and shifts it. Unrolling the shift gives a geometric sum with a closed form.

a(1) = a1, a(k) = p x a(k-1) + q

Alternative Form

Closed: p = 1 → a1+(n-1)q; else a1·p^(n-1) + q(p^(n-1)-1)/(p-1)

Variables

Symbol	Name	Unit	Description
a1	Seed	number	First term starting the chain
p	Multiplier	number	Scales the previous term
q	Addend	number	Shift added each step
a(n)	nth term	number	Iterated (and closed-form) value

Explanation

Homogeneous scaling plus a steady push: pure geometric when q = 0, pure arithmetic when p = 1.

Derivation

Unroll: a(n) = a1 p^(n-1) + q(1 + p + ... + p^(n-2)); the bracket is (p^(n-1)-1)/(p-1). Fixed point a* = q/(1-p) when p ≠ 1.

Step-by-Step Calculation

Follow each step to understand how the result is calculated from your inputs.

Step 1

Read the seed, multiplier, addend, and target.

Inputs: a1, p, q, n

a1:1

p:2

q:1

n:5

Result: a1=1, p=2, q=1, n=5

Step 2

Iterate the rule forward.

a(k) = p·a(k-1) + q

Intermediate: 1, 3, 7, 15, 31

Result: iterated a(5) = 31

Step 3

Branch the closed form on p = 1.

p=1 → a1+(n-1)q

Intermediate: geometric-sum branch

Result: closed = 31

Step 4

Compare the two routes.

|iterated - closed| ≈ 0

Intermediate: 31 vs 31

Result: Agreement confirmed

Step 5

Locate the fixed point.

a* = q/(1-p)

Intermediate: a* = -1

Result: a* = -1

Step 6

Judge stability from |p|.

|p| < 1 settles

Intermediate: |p| = 2

Result: Escaping

Final Answer

Worked Examples

See how the calculator works with different scenarios.

Scenario

a1=1, p=2, q=1, n=5.

Inputs

a1:1

p:2

q:1

n:5

Calculation

Iterate: 1,3,7,15,31 Closed: 1x16+1x15/1=31

Result

a(5) = 31

Interpretation

Loop and formula agree.

Understanding Your Result

Your Result: a(n) byiteration, confirmed by the closed form — see the term card.

Typical range: n caps at 1000; p = 1 is the arithmetic branch. Overflow guarded on p^(n-1).

What This Means

The nth iterate of the one-step memory rule from your seed.

Why It Matters

Savings with deposits, drug dosing, and thermostat chases all follow scale-plus-shift recurrences.

Professional Interpretation

Iteration and closed form are computed independently — agreement is the built-in audit.

Recommendations

•Name p vs q before numbers
•Split p = 1 out as arithmetic
•Compare iterate vs closed form
•Watch fixed-point pull when |p| < 1
•Cap far n before overflow

Educational Content

Introduction

One rule, one memory slot: scale yesterday, nudge it, repeat — and check the shortcut agrees.

Concept Explanation

First-order linear dynamics: geometric backbone plus accumulated shifts.

Applications

▸Savings with fixed deposits

▸Medication concentration decay

▸Newton-iteration sketches

▸Population with stocking

▸Thermostat approach curves

▸Loan amortization steps

Benefits

•Iterate + closed form
•p = 1 branch handled
•Fixed point shown
•Term chart included
•Audit by agreement

Limitations

•First-order linear only
•n <= 1000
•Doubles round huge powers

Best Practices

•State seeds first
•Verify p = 1 separately
•Compare both routes
•Track the fixed point
•Keep n integer

Common Misconceptions

Myth: Recurrence means no shortcut exists.

Truth: First-order linear has a closed form via the geometric sum.

Myth: p = 1 breaks everything.

Truth: It is just arithmetic: a1 + (n-1)q.

Myth: Iteration order does not matter.

Truth: Scale-then-add each step; swapping changes results unless q = 0.

Myth: Fixed points attract always.

Truth: Only when |p| < 1; otherwise they repel.

Practical Tips

•Write the rule before numbers
•Split p = 1 out first
•Demand iterate = closed form
•Read |p| < 1 as settling
•Keep n a positive integer
•Quote terms as a(n)
•Watch overflow for |p| > 1

Common Mistakes

Adding q before scaling

Rule is p·prev + q — scale first, then shift.

Using (p^n-1)/(p-1) with n instead of n-1

Shifts accumulate over n-1 gaps, not n.

Dividing by (p-1) when p = 1

Use the arithmetic branch a1+(n-1)q.

Forgetting the seed carries p^(n-1)

a1 scales by the full power, not p^n.

Reading divergence as a bug

|p| > 1 genuinely explodes — shorten n.

Assumptions

This calculator makes the following assumptions to provide estimates:

Linear first-order: Rule a(k) = p·a(k-1)+q exactly.

Given seed: a1 starts the chain.

Whole index: n integer 1..1000.

Double iteration: Loop plus power form.

Local only: Browser math.

Limitations

Be aware of these limitations when using this calculator:

Order one: Fibonacci-style two-memory rules need their own pages.

Constant p, q: Time-varying coefficients unsupported.

Finite runs: n caps at 1000.

Power rounding: Large p^(n-1) rounds.

Frequently Asked Questions

Answers to common questions about this calculator.

What is a recursive sequence?

Terms from earlier ones, e.g. a(1)=1, a(k)=2·a(k-1)+1 → 1,3,7,15,31,...

What is the closed form?

a(n)=a1·p^(n-1)+q(p^(n-1)-1)/(p-1); if p=1, a1+(n-1)q.

What is the fixed point?

a* = q/(1-p): plugging it back returns itself. For p=0.5,q=6: a*=12.

Arithmetic or geometric inside?

q=0 is geometric; p=1 is arithmetic; else a hybrid.

Stable or explosive?

|p|<1 settles to a*; |p|>1 escapes; p=1 drifts linearly.

Why two computations?

Loop and formula agreeing proves the code path.

Example a(5) for 1, p=2, q=1?

1,3,7,15,31 → a(5)=31.

Negative p?

Oscillates while scaling — sign flips each step.

Why cap n?

Powers and lists stay finite and readable to 1000.

Stored?

No.

Related Calculators

Explore more calculators related to this topic.

Related Guides

Deepen your understanding with these educational resources.

Sequences vs series in one sketch

Terms, sums, and convergence at a glance.

Closed forms that skip the loop

Jump straight to term n without listing.

Growth regimes: linear vs exponential

Reading difference and ratio correctly.

Checking sums by pairing and ratio tricks

Endpoint pairing and the r-times-Sn proof.

Glossary

Technical terms used in mortgage calculations explained in plain language.

Recurrence: Term defined from predecessors.
First-order linear: a(k) = p·a(k-1)+q.
Seed: Given a1 starting iteration.
Closed form: Direct a(n) without looping.
Fixed point: a* = q/(1-p); stays put.
Homogeneous part: p·a(k-1) scaling piece.
Particular part: Steady q-shift piece.
Stability: |p| < 1 settles; > 1 escapes.
Iteration: Repeated rule application.

Authoritative References

Trusted sources and standards referenced by this calculator.

Wikipedia — Sequence Wikipedia — Series (mathematics) Khan Academy — Sequences Math is Fun — Sequences and Series Purplemath — Sequences and Series Wolfram MathWorld — Sequence Cuemath — Sequences and Series

Applicable Standards

Common Core HSF-BF.A — building sequences and seriesNCTM Number and Operations — patterns, functions, and series

Was This Calculator Helpful?

Report Issue

Page Information

Last Updated:

2026-09-29

Version:

2.0.0

References:

License:

Free to use for educational and professional purposes.