Sylvester's sequence
Brain-Flak, 76 68 58 52 46 bytes

&lt;&gt;(()())&lt;&gt;{({}[()])&lt;&gt;({({}[()])({})}{}())&lt;&gt;}&lt;&gt;


Try it online!

Uses this relationship instead:



which is derived from this relationship modified from that provided in the sequence:

a(n+1) = a(n) * (a(n) - 1) + 1.

Explanation

For a documentation of what each command does, please visit the GitHub page.

There are two stacks in Brain-Flak, which I shall name as Stack 1 and Stack 2 respectively.

The input is stored in Stack 1.

&lt;&gt;(()())&lt;&gt;             Store 2 in Stack 2.

{                      while(Stack_1 != 0){
  ({}[()])                 Stack_1 &lt;- Stack_1 - 1;
  &lt;&gt;                       Switch stack.
  ({({}[()])({})}{}())     Generate the next number in Stack 2.
  &lt;&gt;                       Switch back to Stack 1.
}

&lt;&gt;                     Switch to Stack 2, implicitly print.


For the generation algorithm:

({({}[()])({})}{}())      Top &lt;- (Top + Top + (Top-1) + (Top-1) + ... + 0) + 1

(                  )      Push the sum of the numbers evaluated in the process:

 {            }               while(Top != 0){
  ({}[()])                        Pop Top, push Top-1    (added to sum)
          ({})                    Pop again, push again  (added to sum)
                              }

               {}             Top of stack is now zero, pop it.
                 ()           Evaluates to 1 (added to sum).


Alternative 46-byte version

This uses only one stack.

({}&lt;(()())&gt;){({}&lt;({({}[()])({})}{}())&gt;[()])}{}


Try it online!