Let's have string multiplication to take a string and a positive number and concatenate that string that many times. In Haskell:

0 * s = ""
n * s = s ++ ((n - 1) * s)

Your task is to write a program that outputs a number $n > 0$. When you double your program (with the described procedure) the new program should output $2n$. When your program is tripled or quadrupled it should once again output the original $n$.

This is code-golf so your answers will be scored in bytes with fewer bytes being better.

Related, Related.

Python 2, 9 bytes

Outputs via exit code. Full credit goes to Anders Kaseorg for this answer to I double the source, you double the output!.

';exit(2)

Try it online! | Doubled | Tripled | Quadrupled

Regularly, this raises a Syntax Error because the string is not closed properly and exists with exit code 1, then, when doubled, it becomes ';exit(2)';exit(2) which simply exits with code 2 because the string literal is now quoted properly and has no effect at all, and when repeated any other arbitrary number of times, it raises Syntax Errors.

R, 27 25 bytes

1+!1-length(readLines())

Try it online!

Inspired by rturnbull's answer to Third time the charm, but the simplicity of the check makes it shorter.

Doubled | Tripled | Quadrupled

Why this works:

readLines() will actually reads the source file itself rather than stdin. Hence, adding lines just increments the length() of the vector returned by readLines(). Therefore, we compute !(1-length()) to obtain 1 whenever length()==1 and 0 when length()!=1, adding one to have the desired effect.

Runic Enchantments, 29 bytes

^w '
/1@ 3
/ ~!4
2'51w
/yyy

Try it online!

Slight alteration from the Third Times A Charm entry, using Jo King's compressed version and swapping the two reflection locations.

Twice

Thrice

And frice for good measure.

Klein 000, 6 bytes

1+@

Try it online!

Explanation

The idea here is pretty simple, the first 2 copies require the ip to move off the edge of the program but the third does not, that way adding anything extra after the third doesn't change anything.

The first program reflects off of both edges the

At the begining is just a fancy noop. So we just run 1+@.

For the two copies this gets interrupted

1+@
\1+@

We hit both 1s and a + to get 2.

On the three we interrupt the path even further

1+@
\1+@
\1+@

At this point it might not be the clearest, but the ip bounces around in the mirrors a bit before it hits runs the 3rd line.

This is what it runs

\
 1+@

Since this doesn't go off an edge further additions don't make any change to the program.

Charcoal, 10 bytes

ＰＩ⊕⁼²Ｌ⊞Ｏυω

Try it online! Based on my answer to I double the source, you double the output! but compares the length to 2. Try it doubled. Try it tripled. Try it quadrupled. In verbose syntax this is Multiprint(Cast(Incremented(Equals(2, Length(PushOperator(u, w)))))));.

MATL, 9 bytes

vxHQXH4=Q

Uses n = 1.

Try it online! Original, doubled, tripled, quadrupled.

Explanation

This uses clipboard H to store state information. Function H pastes the clipboard contents onto the stack. Function XH copies the top of the stack into the clipboard. The clipboard initially contains the number 2.

Each time the snippet vxHQXH4=Q is run it does the following.
The stack contents, if any, are deleted (vx). The clipboard contents are pushed (H) and incremented (Q), and the result is copied back into the clipboard (XH). This gives 4 the second time, and only that time.

The number in the stack is tested for equality with 4 (4=) and incremented (Q). This gives 2 for 4 (second time), and 1 otherwise (any other time).

05AB1E, 7 6 bytes, n=3

₆.g2Qè

Try it online; try it doubled; try it tripled; try it quadrupled.

Explanation:

₆ # Push 36
 .g # Push the amount of items on the stack
 2Q # Check if that amount is equal to 2 (results in 1 if truthy; 0 if falsey)
 è # Index that into the 36 (and output the top of the stack implicitly)