Somewhere in my senior year of high school, two friends and I were
wondering how one could write

This first part of this function finds the midpoint between $x$ and $y$.
Then, we travel half the distance between $x$ and $y$ toward $-\infty$, thus
arriving at the smaller of the two numbers. It's pretty clear that

Curious to perform this "mathematical translation" on other
functions commonly used in programing, we wondered how this could be done
for equality, $\text{eq}(x,y)$. Since we wanted to stick to functions on
the reals, we opted for

Using the ceiling function might seem like "cheating", but it's important to remember that we were mostly trying to sidestep functions defined in a piecewise/pattern-matching fashion. Thus, this one-line arithmetic definition met our needs.

We kept going. Another useful function is

Now, what's the point of doing all of this? Well, for me it was the fact
that in programming, arguments to a function (even as numbers) are
data, stored sequentially in memory. This mindset allows for easier
conceptualization of some operations over others. For example, how would
you write some code to reverse a number? Well, if the number was stored
in base 10 in memory, and not in binary, you could just copy the data
but in reverse order. Now, as a preview of what is to come,
**how would you write a math function to reverse an integer?**

When I was first working on this stuff, the idea
of treating math functions in this way was pretty foreign and made me
very curious about what was possible. Control flow, time and
space complexity, a sequence of instructions, all of that was gone when
writing using just arithmetic operations. In math, things just *are*.

I understand now that this really isn't any ground-breaking math nor
does it connect two fields in any novel way, but it was what I *thought*
was math, and that's what made me thoroughly enjoy the journey. I hope
you enjoy it too.

Let's talk about reversing an integer next.