I’m revising sequences and trying to strengthen my fundamentals, especially around recursive rules. I keep second-guessing what actually counts as a valid recursive definition and what details I’m supposed to include so it’s unambiguous.
For example, if I’m given an explicit formula like a_n = 5 − 2n, I can imagine several recursive versions. One uses one previous term (like “next = previous − 2” with one initial value). Another could reference two steps back (like “next = two-steps-back − 4” with two initial values). Are both of these acceptable, and is there a principle for choosing a “simplest” or “standard” recursive rule when the problem just says “write a recursive definition”?
Related: how do I decide how many initial terms I need to state? I understand that something like a_n depending on a_{n−1} usually needs one initial value, while depending on a_{n−1} and a_{n−2} needs two. But is there a clear rule-of-thumb that covers trickier cases (e.g., parity-based rules or ones with parameters in the denominator)? For instance, what’s the clean way to state the starting index and initial data for a rule like a_n = a_{n−1}/(n−1) so I don’t accidentally divide by zero?
I’m also unsure what’s considered “valid” recursion. Are definitions that look forward, like a_n = a_{n+1} − 2 (with some initial condition), considered legitimate, or do recursive rules have to build forward only? And what about piecewise/conditional recurrences, say a_n = a_{n−1} + 2 if n is even, otherwise a_n = a_{n−1} − 1 – is that fine as long as I state enough initial information?
Another thing that bothers me: ambiguity from non-unique operations. For example, a_n = sqrt((a_{n−1})^2) with a_1 = −3 could point to either −3 or +3 depending on how the square root is interpreted. Is there a standard way to word rules to avoid this kind of ambiguity, or is it just about being explicit in the definition?
Analogy check (might be off): I think of a recursive rule like assembly instructions where you only need the last few pieces to add the next piece – as long as I know the starting pieces, everything after is determined. Is that the right mental model, or is it more like turn-by-turn GPS directions where start location and step numbering matter just as much as the rule itself?
Practically, I’m looking for a straightforward explanation or checklist: when I write a recursive definition for a given sequence, what must I specify (rule, domain for n, initial terms, any conditions) so it’s considered complete and unambiguous? And when multiple recursive rules fit the same explicit sequence, how should I decide which one to use?
Ready to make maths more enjoyable, accessible, and fun? Join a friendly community where you can explore puzzles, ask questions, track your progress, and learn at your own pace.
By becoming a member, you unlock:
4 Responses
Short checklist: specify the starting index n ≥ n0, give a rule that uniquely computes a_n from earlier terms a_{n-1}, …, a_{n-k} for every allowed n (no division by zero, clarify any ambiguous ops like sqrt), and provide exactly k initial values; piecewise rules are fine if they’re deterministic, while “look-ahead” rules aren’t standard unless you rewrite them to depend on earlier terms. When several recurrences fit, pick the minimal order (smallest k) and simplest form-e.g., for a_n = 5 − 2n use a_1 = 3 and a_n = a_{n−1} − 2-see https://www.khanacademy.org/math/algebra/x2f8bb11595b61c86:seq-series/x2f8bb11595b61c86:recursive-formulas/a/recursive-formulas-for-arithmetic-sequences.
Think of a recursive rule like a recipe card: it’s valid and complete when you (i) declare the index set (e.g., n≥0 or n≥2 to dodge 0 in a denominator), (ii) give a rule that uniquely builds a_n from a finite stash of strictly earlier terms for every allowed n (piecewise/parity recipes are fine; no time-travel like a_n=a_{n+1}−2 unless you reindex/invert), (iii) supply enough seed terms to cover the largest lag used, and (iv) de-ambiguate operations (e.g., say “principal square root” or write |a_{n−1}|); among many equivalent recurrences, prefer the lowest-order forward rule with the earliest safe start index.
Want to play: what start n and seeds would you choose for a_n=a_{n−1}/(n−1), and how would you pin down the sign in a_n=√(a_{n−1}^2)?
Lovely question-think of a recursive definition like assembly instructions: give a rule that builds a_n only from earlier terms (no looking ahead), state the n-range, and supply as many starting values as the largest backward step needs; piecewise rules are fine, start the index to dodge undefined steps (e.g., for a_n = a_{n−1}/(n−1) use n ≥ 2 with a_1 chosen), and remove ambiguity by naming the branch (use |a_{n−1}| or −|a_{n−1}| rather than sqrt((a_{n−1})^2); when several recurrences fit, prefer the lowest order with the fewest initials).
Example: for a_n = 5 − 2n, the simplest is a_1 = 3, a_n = a_{n−1} − 2 for n ≥ 2 (so a_1=3, a_2=1, a_3=−1); also valid: a_1=3, a_2=1, a_n = a_{n−2} − 4 for n ≥ 3; quick refresher: https://www.khanacademy.org/math/ap-calculus-ab/ab-sequences-series/ab-recursive-sequences/a/recursive-definitions.
Great questions-this is exactly the kind of careful thinking that makes recursion feel solid. A recursive definition is complete when you do three things: say where n starts (like n ≥ 1), give a rule that determines a_n uniquely from earlier terms, and provide enough initial terms to get the process going. The number of initial terms you need is the order of the recurrence-the largest backward step you ever use-and for piecewise rules you take the largest lag that appears in any case. For your a_n = 5 − 2n example, both a_n = a_{n−1} − 2 with a_1 = 3 and a_n = a_{n−2} − 4 with a_1 = 3, a_2 = 1 are valid; the first is usually preferred because it’s lower order and lets you march forward one step at a time. When denominators or domains are tricky, build the start index into the statement so everything is legal; for instance, set a_1 and use a_n = a_{n−1}/(n−1) for n ≥ 2 so you never divide by zero, and say whether terms live in integers, rationals, or reals if that matters. “Forward-looking” rules like a_n = a_{n+1} − 2 don’t let you build forward from a base, so they’re typically rewritten as a_{n+1} = a_n + 2; they only make sense as written if you also give a terminal condition and intend to define earlier terms. Conditional recurrences are perfectly fine; if every case uses a_{n−1}, you need one initial value, but if any case uses a_{n−2} you need two. Avoid ambiguity by making the right-hand side a single-valued function: instead of a_n = √(a_{n−1}^2), say a_n = |a_{n−1}| (or explicitly name the principal square root), so from a_1 = −3 you unambiguously get a_2 = 3. Your assembly-instructions analogy is spot on: you should be able to add the next piece using only what’s already built, starting from clear base pieces, with each step telling you exactly one move. In practice, I pick the smallest-order rule with the earliest natural start index, then state the domain for n, the initial terms, the recurrence (including cases), and any side conditions; that little checklist keeps things clean and unambiguous.