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:
2 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)?