I've personally been working on a proof for a Math puzzle known as the Collatz Conjecture. I haven't been able to officially publish my findings in a paper, but I thought I'd at least explain what the problem is and, to my knowledge, how it is solved. Collatz Conjecture states the following:

1. Pick any positive whole number n.
2. If n is even, define f(n) = n/2. Otherwise, f(n) = 3*n+1.
3. If done a sufficient amount of times, any starting number n will eventually reach the sequence 1, 4, 2, 1, 4, 2, 1...

There have been many papers discussing different sets of numbers that can be proven to reach 1 if a related number also reaches 1. I consider this an important first Lemma to the problem. Other than that, there are two sets which have previously have been solved which I have used in the making of this proof.

The first set pertains to all even numbers. It can be easily shown that if a number is even, f(n) = n/2 until the number isn't even. This means that all even numbers reach a lower odd number. Therefore, if all odd numbers eventually reach 1, then all even numbers do as well. The other set involves numbers in the form n = 4*m+1. What's interesting about this set is that f(f(f(n))) = f(m) = 3*m+1. This means that for certain odd numbers n, there is a number m much smaller that behaves similarly with multiple repetitions of f(n).

For my particular solution, it first determines that all even numbers in the form n = 2^A*3^B*5^C *... ; A,B,C... ≥ 0 become odd after A iterations. From here, it gets slightly complex.

My idea was to take the odd numbers and assign each one a cardinal number to represent it. For simplicity, I notated the cardinal version of an odd number with an apostrophe, making it clearer which set the number belonged to (n vs n' and f(n) vs f(n)'). To convert between sets, any given odd number n can be written as n = 2*n'-1. This could be arbitrarily chosen as long as one set increased if the other increased, but this system was specifically designed such that every natural number had an associated odd number and 1 = 1'.

Once the system is well defined, it was a matter of seeing how this set behaved, and from there, see whether or not this can answer the conjecture. The issue lies in the idea that 3*n+1 is not equal to 3*n'+1. Not only are they different numbers if n > 1, but the odd numbers increase at a much higher rate. The way to fix this is by simply plugging 2*n'-1 into f(n) and calculating finding the next odd number which can be converted into its respective cardinal. Going through this process,

f(n) = f(2*n'-1) = 3*(2*n'-1)+1 = 6*n'-3+1 = 6*n'-2 / f(f(2*n'-1) = (6*n'-2)/2 = 3*n'-1

From here, the parity of f(f(2*n'-1) is the opposite as that of n'. Therefore, if n is odd, f(f(2*n'-1)) needs to be iterated a minimum of three times to be convertible into its cardinal. For now, it is possible to define f(n')' = (3*n'-1+1)/2 = 3/2*n', where n' is even. This also means that f(2*n')' = (3*n)'. We denote these two functions with the following notation:

n' > (3*n'-1) (1)

n' > (3/2*n)', n' is even (2)

Once the base function is defined, we can start to define similar functions for number relations, to create a cumulative function for how n' behaves.

One particular case is when n = 4*m+1. The iterations go as follows:

f(n) = f(4*m+1) = f(4*(2*m'-1)+1) = f(8*m'-3) = 3*(8*m'-3)+1 = 24*m'-8 / f(f(f(f(n)))) = (3*m'-1) = (1)

From this, we can tell that 4*m'+1 behaves similarly to m'. Converting back in terms of n', we get 2*n'-1 = 4*(2*m'-1)+1 which simplifies to n' = 4*m'-1. This can be rewritten that if n' has a remainder of 3 when divided by 4, f(n')' behaves like f((n'+1)/4)'. As a rule, we can simply suggest that

n' > ((n'+1)/4)', n' mod 4 = 3 (3)

as they would behave the same in sequence.

The only that does not have a result is currently numbers in the form n' = 4*m'+1. These numbers are coincidentally the odd values of n' when initially solving equation (1). Since the value of 3*n'-1 is even for these values of n', it is possible to assume a minimum of one division of 2. Once this is completed, the resulting value will have n' mod 4 = 3, where we then can apply equation (3). Therefore, the derivation goes as follows

f(3*n'-1), n' is odd = (3*n'-1)/2 / f(n')' = (((3*n'-1)/2)+1)/2 = (3*n'-1+2)/(2*2) = (3*n+1)/4, or simply

n' > ((3*n'+1)/4)', n' mod 4 = 1 (4)

Given (3) and (4), we can determine the following step to (2), as terms end up in the form (3/2*2*n)' = (3*n)'. This can be done because if n' mod 4 = 1, then (3*n)' mod 4 = 3, and vice versa. In the case where n' mod 4 = 1 and

(4) ((3*n'+1)/4)' = (((3*n)'+1)/4)' (3)

The same can be done in reverse, where n' mod 4 = 3 (and n' mod 3 = 0)

(4) ((3*(n/3)'+1)/4)' = ((n'+1)/4)' (3)

The only point where this calculation fails is at n' = 3, which is an actual value of n = 5, which can be easily proven to reach 1'. Otherwise, the equation can be set up such that

(3*n)' > n', n mod 3 = 0 (5)

Taking into account all equations that iterate from n' to f(n')', we can create a piecewise function describing the mapping of n' onto itself. Doing so we get

f(n')' = { 3*n'/2, n' mod 2 = 0;

         n'/3, n' mod 3 = 0;

            (n'+1)/4, n' mod 4 = 3;

               (3*n'+1)/4, n' mod 4 = 1 }

It can be seen that in all cases, f(n')' < n' if n' is odd, and f(f(n')')' < f(n')' when n' is even. This means that for consecutive iterations of f(n')', all numbers eventually decrease until they hit a fixed point, which for our purposes is 1' = 1. This means that for all odd numbers, there is a sequence that is composed of multiple iterations of the cardinal sequence that reaches 1'. This leads into the existence of a sequence composed of multiple iterations of the Collatz Conjecture that will eventually reach 1. Since the Collatz Conjecture is proved for all odd numbers by the Lemma at the start of the proof, all natural numbers will eventually reach 1. Therefore, the Collatz Conjecture is correct.

As someone who likes detailed adventures and intricately designed systems, Dungeons and Dragons (DnD) provides a stress-free outlet for me to express my creativity and hypothetical ability to manipulate RNG. That being said, the group I play with has a knack for developing unique versions of DnD, which is referred to as Homebrew campaigns/classes/etc. For a particular system, not only is there potential for multi-element damage, but there are abilities that can add or remove resistances, passives that pierce through defenses, and a critical damage system that was a piece of work on its own. So the person running the campaign, known as the Dungeon Master (DM), asked me to make a simplified method of inputting and calculating damage, and we brainstormed all of the functions they wanted it to include. From there, it was simply a matter of finding an easy method of displaying all the important information, and debugging for any exceptions we missed. Scenarios that we had ended coding for included:

• Immunity (Set Resistance to an arbitrarily high number)
• Weakness (Set Resistance to a negative number)
• Pure Damage (An extra Damage Type unaffected by resistance)
• Vitality, which is negates damage across all elements equally
• Armor and Damage Pierce
• Critical Hit Modification (Added after the Base Damage Cell was coded in)

A link to a sample module can be found here. Feel free to make a copy by clicking File > Make a Copy and testing it out.

Another big part of DnD is rolling dice. Having the RNG element simulates real life in that events can be unpredictable, and can lead to interesting scenarios. As a DnD group that functions on Discord, however, we needed to be able to roll without the risk of cheating, since we couldn't check the legitimacy of a hand-rolled die in person. To make up for this, we installed a bot on Discord that is capable of accepting commands to roll dice based on certain instructions. The unique thing about this dice roller though was that there were programmable functions referenced as macros and aliases. Macros are typically meant for a single line input, while an alias can roll several commands at once. Most campaigns only ever needed a simple set of RPG dice, but our group finds excitement in finding ways to roll absurdly high or complex totals. This meant that we either had to take the time repeatedly copying and pasting our roll commands in, or go in and make macros that could substitute the complex pseudocode. Personally, I would rather leave the commands private for while they are interesting, it is a lot easier to explain how they work through the bot manual on GitHub, which is linked here.

Personally, I am a big fan of games that show markedly high rates of improvement. This is generally found in games that function on a round system and have either leaderboards or an internal ranking system. As such, the skill portions of these games typically involve being able to react in real time. Given that instantaneous reactions are nigh on impossible, the next best thing is to compensate for it as best as you can. For shooters, this means adjusted tracking speeds and the mapping of in-game actions to comfortable, familiar keybinds. For rhythm games, this can mean changing the speed at which notes approach the scoring zone, or simply shifting the track back by a time interval based on the current latency.