Andy the ant has moved on from his classic ‘Telstar’ soccer ball homeland to live on a simpler spherical surface consisting of four white hexagons that are surrounded by alternating black triangles and white hexagons (three of each), and four black triangles surrounded by three white hexagons. To us this land is a truncated tetrahedron blown up into a sphere we see above on the left. Due to Andy’s tiny size and terrible eyesight, he doesn’t notice the curvature of the land and avoids the black triangles because he suspects they may be bottomless pits.

Much like his morning routine, every afternoon he wakes up from his nap on a white hexagon, leaves some pheromones to mark it as his special home space, and starts his random amble. Every step on this walk takes him to one of the three neighboring white hexagons with equal probability. He ends his amble as soon as he first returns to his home space, which he recognizes but cannot distinguish the edges of (i.e. he doesn’t know if he returned across the same edge as he left). As an example, on exactly 1/3 of afternoons Andy’s amble is 2 steps long, as he randomly visits one of the three neighbors, and then has a 1/3 probability of returning immediately to the home hexagon.

This afternoon his truncated tetrahedral homeland bounced through the very same kitchen with an infinite regular hexagonal floor tiling consisting of black and white hexagons, shown above on the right. In this tiling every white hexagon is surrounded by alternating black and white hexagons, and black hexagons are surrounded by six white hexagons. Andy fell off the ball and woke up on a white hexagon. He didn’t notice any change in his surroundings, and goes about his normal amble.

Throughout his walk, Andy remembers the turns he’s taken. Let $p$ be the probability that by the end of his afternoon amble on this new land he has discovered that he is no longer on the truncated tetrahedral sphere. Find $p$ in exact terms.

Original puzzle on Jane Street’s site

Solution

The first step is to figure out how to compare the walks in each space. Let the space of the truncated tetrahedron be denoted $T$ and the hexagonal tiling space be denoted $T’$. Let’s begin by analyzing the walk on $T$, which is composed of four white hexagons and four black triangles. We can unfurl $T$ to lie in the plane as shown below.

WLOG, assume Andy starts on the green hexagon and then always moves to hexagon $A$ and then faces towards hexagon $B$. Since we are given that

throughout his walk, Andy remembers the turns he’s taken

we need to find a way to model his movements throughout the rest of his walk. Given that he starts at $A$ facing $B$, we can model his path in the following way. Andy can make 3 types of “move”:

• Forward: This takes him along one of the black arrows in the diagram (e.g. $A \to B$)
• Backwards: He walks in reverse along the black arrow into his current hexagon (e.g. $B \to A$)
• Right: He turns right along one of the red arrows and returns home.

All three moves are defined from Andy’s own perspective. After his first step, Andy keeps track of which way he is facing, so at every hexagon the three exits are: the edge in front of him, the edge on his right, and the remaining edge. When he moves forward, he walks through the edge he is facing and then turns to face the exit on his left. A backward move undoes a forward move: he steps back through the remaining edge and turns to face the hexagon he just left. Turning right takes him through the edge on his right. Since each move depends only on Andy’s heading and the order of the edges around him, his memory of his turns tells him exactly which moves he made, and with these three moves he can always work out where he is relative to the first hexagon he entered.

For Andy to follow a sequence of turns, $S$, in the hexagonal tiling $T’$ and not notice that he left $T$, it must be the case that $S$ returns Andy home in $T$ exactly once, and on the last move. If Andy ever takes a move that would have returned him home in $T$ (i.e., turning right) but doesn’t in $T’$, then he knows he is not on $T$.

What do moves look like in $T’$?

Again assume Andy steps to hexagon $A$ and faces $B$. His possible moves on $T’$ are shown in the figure below.

Why does $T’$ look different? Locally, the two lands are identical: every white hexagon has three white neighbors spaced 120 degrees apart, so any sequence of turns can be replayed on either one. The only difference is the black tiles. A black triangle on $T$ is ringed by 3 white hexagons, while a black hexagon on $T’$ is ringed by 6. So the ring $A, B, \ldots, F$ wraps twice around the cycle $A, B, C$. For example, at $D$, Andy’s memory says he’s back at $A$.

This means that, unlike before, in $T’$, $A$ is the only position from which Andy can turn right and be in the home hexagon. The first time Andy turns right while not in hexagon $A$, he will notice he is not home and can tell he is in $T’$. Thus it now suffices to find the probability that the first time Andy turns right will be when he is in hexagon $A$.

We can set this up as a recurrence relationship (this is a random walk on a Markov chain). Let $p_i$ be the probability that Andy finishes his walk without noticing he is in $T’$, given he is currently in hexagon $i$, $i = A, B, \ldots, F$. From any hexagon on the ring, he moves forward, backward, or right, each with probability $\frac{1}{3}$. Turning right from $A$ takes him home undetected, while turning right from anywhere else gives him away. Reflecting the ring across the line through $A$ and $D$ gives the symmetries $p_B = p_F$ and $p_C = p_E$. We get the following system of equations

A little algebra (or Mathematica 😅) later and we find, \(p_A = \frac{9}{20}.\)

However, note that this is the probability that Andy has a sequence of moves that doesn’t result in him finding out he is on $T’$. The puzzle asks for the complement, and thus our answer is \(\begin{equation*} \boxed{p = 1- p_A = \frac{11}{20}}. \end{equation*}\)

We are enjoying a planetary parade during the beginning of this month here on Earth, but my alien friend from the distant planet Pyrknot (well modeled as a perfect sphere) isn’t too impressed. Their single-star system has $n$ planets other than Pyrknot with such chaotic orbits that each night these planets independently appear in uniformly random locations in the Pyrknothian sky. Note that the planets aren’t visible in daylight. If at a given moment there exists somewhere on Pyrknot that all $n$ planets are visible, then from my friend’s position on the surface they have an $\alpha$ probability of also seeing all of the planets.

My friend is considering building a tower to improve their chances of seeing these planetary parades (parade). Assume the tower allows the viewing of every celestial body that could be seen from at least one location on the surface of Pyrknot less than a distance $r$ from the base of the tower. In the limit of $r$ being small compared to the radius $R$ of Pyrknot, the new probability of seeing the planetary parade from the top of the tower is linearly approximated by $\alpha + \beta\cdot(r/R)$. Find $\alpha$ and $\beta$ in exact terms.

Solution

We will solve this problem in a few parts, looking at the 2D and 3D versions of the problem. First, we will solve for $\alpha$, which turns out to be dimension-agnostic. Next, we will solve the problem in 2D (that is, for a circular planet whose universe is the plane) to build some intuition. Then, we will use our findings from the 2D case to construct the answer to the 3D version.

Part 1: Finding $\alpha$ — a dimension-agnostic result

The key quantity throughout is $\alpha$, the probability of seeing the parade without a tower, given that a parade is taking place somewhere on the planet.

To start, let’s assume that our friend’s location on the planet is at the North Pole (NP). Assume that for our modeling purposes the celestial bodies in the system (not including Pyrknot) lie on some other sphere that is very far from the planet. For our purposes, we can say that the position of a planet in the sky can be mapped to a position on the surface of Pyrknot by drawing a line between the planet and the center of Pyrknot. That way, we can model the positions of celestial bodies around Pyrknot as positions on the surface of Pyrknot.

Now, given that a parade exists, what must be true for it to be visible from the NP? We have two conditions that must be satisfied:

• It is night time at the NP (otherwise the parade is not visible)
• All $n$ planets must be in the hemisphere centered at the NP.

We need to find the probability that, at a given moment, we can see the parade from the NP given that one exists. Using Bayes’ theorem, we can write this as

The middle factor simplifies to 1 because if the parade is visible from the NP, it certainly exists somewhere on the planet.

Thus, it suffices for us to find $\Pr\left[\text{Parade visible from NP}\right]$ and $\Pr\left[\text{Parade exists}\right]$.

To find the probability that in a given moment a parade on $n$ planets is visible from the north pole, we need all the planets to be in the northern hemisphere and the star to be in the opposite hemisphere. Since the positions of all $n$ planets and the star are independent and uniform, each planet lies in the northern hemisphere with probability $\frac{1}{2}$ and the star lies in the southern hemisphere (making it night at the NP) with probability $\frac{1}{2}$, giving \(\begin{equation} \Pr\left[\text{Parade visible from NP}\right] = \frac{1}{2^{n + 1}}. \label{eq:NP_visibility} \end{equation}\)

It is a bit more nuanced to find the probability that a parade exists somewhere on the surface of the planet since there could be many places where the parade is visible. However, there exists a well-known result that can help us out: Wendel’s theorem, which gives us the probability that $n+1$ points randomly placed on the surface of a $d$-dimensional sphere are contained within some shared hemisphere. To use it within the context of our problem, we create a pseudo-planet that is placed antipodal to the location of the star. That way, we can find the probability that the $n$ planets and the pseudo-planet all exist in some shared hemisphere, which is equivalent to all $n$ planets being visible from some point while the star is not.

Wendel’s theorem states that in dimension $d$ with $n + 1$ points, the probability those points all lie in some shared hemisphere is: \(\begin{equation} \label{eq:parade_exists} \begin{aligned} \Pr\left[\text{Parade exists}\right] = \frac{2 \sum_{k = 0}^{d - 1} \binom{n}{k}}{2^{n + 1}}. \end{aligned} \end{equation}\)

If we combine equations (\ref{eq:Bayes}), (\ref{eq:NP_visibility}), and (\ref{eq:parade_exists}), we find that

\(\begin{equation} \label{eq:alpha} \begin{aligned} \alpha & = \frac{ \Pr\left[\text{Parade visible from NP}\right]}{\Pr\left[\text{Parade exists}\right]}\\ & = \frac{\frac{1}{2^{n + 1}}}{\frac{2 \sum_{k = 0}^{d - 1} \binom{n}{k}}{2^{n + 1}}}\\ & = \boxed{\frac{1}{2 \sum_{k = 0}^{d - 1} \binom{n}{k}}}, \end{aligned} \end{equation}\) which is the reciprocal of the number of regions created by $n + 1$ non-degenerate great circles on a sphere in $d$ dimensions!

Next, we will introduce the tower and solve for $\beta$ in the case of $d = 2$.

Part 2: A tower on a planet in the plane-universe

We now construct a tower at the north pole that allows us to see any body that would otherwise be visible from some point within distance $r$ from the base of the tower. In the limit of $r \ll R$, this is essentially a small arc on the circular planet of arclength $2r$. How does this affect our chances of seeing a parade? On one hand, it gives us a greater likelihood of seeing more planets in the sky at a given moment, but on the other hand, it also gives us a greater chance of seeing the star during that moment, which would ruin the parade.

Suppose we are just isolating the effect for a single planet $P$. Given that we have our tower of effective radius $r$, what is the probability of seeing the planet from the tower?

Note that without the tower, the position of $P$ must lie above the equator. With the tower, we can now see all planets whose position dips slightly below the equator. Let $\theta$ be the angular diameter of the area that the tower can effectively view from. If we draw the diameters of the semicircles that are centered on the two edge points of our viewing region (red and blue points in Figure 1, respectively), we can see that the effective region in which planets are visible (yellow region in Figure 1) includes the northern hemisphere and two sectors of angle $\omega$ that dip below the equator.

Some elementary geometry yields that $\omega = \theta / 2$. Therefore, the fraction of the circle covered by the tower is $\frac{\pi + \theta}{2 \pi}$, and for a given planet, the probability that it is visible from the tower is:

Now, for a parade to be visible from the tower, we need all $n$ planets to be visible and the star not to be.

Using the independence of the planets and the star along with (\ref{eq:eff_area_2}), we find

If we note that $\theta = 2r/R$ and use our previous expressions for the conditional probability (\ref{eq:Bayes}) and existence of a parade (\ref{eq:parade_exists}), we find:

which implies for $d = 2$, we find \(\begin{equation*} \boxed{ \begin{aligned} \alpha & = \frac{1}{2 (n + 1)}\\ \beta & = \frac{n - 1}{\pi(n + 1)}.\\ \end{aligned}} \end{equation*}\)

Part 3: A Parade on the sphere

Since (\ref{eq:alpha}) was derived for arbitrary $d$, it applies directly to the 3D case — we need only find $\beta$. In 3D the effective viewing area for the tower is now a small cap of the sphere of angular diameter $\theta$, which is again given by $\theta = 2r / R$. Now, the tower, instead of extending the total observable area by two arcs of angle $\theta/2$, adds an additional ring of area below the equator, shown between the thick black equator and the green circle in Figure 2.

To get the total observable area of the planet from the tower, we need to find the area $A(\theta)$ of the added ring.

Using spherical coordinates (with $\phi$ the polar angle measured from the north pole and $\lambda$ the azimuthal angle), we can write this surface area as:

Therefore, the total area of the planet viewable from the tower is $2 \pi R^2 + 2 \pi R^2 \sin(\theta/2)$ and thus the probability of viewing any given planet is

Now all that remains is to find the probability that all planets are visible from the tower and the star is not. Using the same approach as in the 2D case, we find:

Once again noting that $\theta = 2r/R$, and plugging (\ref{eq:parade_exists}) and (\ref{eq:tower_prob_3d}) into (\ref{eq:Bayes}), we find:

which gives us our final answer:

Remarks

The tower is useless for $n = 1$. In both 2D and 3D, $\beta = 0$ when $n = 1$. The intuition is symmetric: for every configuration where the tower’s wider field of view lets you catch the single planet below the equator, there is an equally likely configuration where it causes you to see the star instead. These two effects cancel exactly at first order, so the tower provides no benefit.

The tower always helps when $n > 1$. For $n > 1$, $\beta > 0$ in both dimensions, meaning the tower strictly improves your odds. Intuitively, the tower’s extended range creates $n$ new opportunities to gain (one per planet) but only one opportunity to lose (the star). When $n > 1$, the planets win on average.

$\alpha$ decays much faster in 3D. For large $n$,

In 3D, there is so much more room in the sky that simultaneously fitting all $n$ planets into a hemisphere becomes quadratically harder. This reflects the general Wendel’s theorem result: higher-dimensional spheres make hemispheric coincidences exponentially rarer.

The tower’s marginal benefit $\beta$ has different large-$n$ behavior by dimension. As $n \to \infty$,

In 2D, the marginal gain per unit $r/R$ converges to a positive constant. Even with very many planets, the tower always helps at first order. In 3D, the parade itself becomes so rare that even the tower’s extended range can’t keep up.

It’s coming to the end of the year, which can only mean one thing: time for this year’s Robot Javelin finals! Whoa wait, you’ve never heard of Robot Javelin? Well then! Allow me to explain the rules:

• It’s head-to-head. Each of two robots makes their first throw, whose distance is a real number drawn uniformly from $[0, 1]$.
• Then, without knowledge of their competitor’s result, each robot decides whether to keep their current distance or erase it and go for a second throw, whose distance they must keep (it is also drawn uniformly from $[0, 1]$).
• The robot with the larger final distance wins.

This year’s finals pits your robot, Java-lin ($J$), against the challenger, Spears Robot ($S$). Now, robots have been competing honorably for years and have settled into the Nash equilibrium for this game. However, you have just learned that Spears Robot has found and exploited a leak in the protocol of the game. They can receive a single bit of information telling them whether their opponent’s first throw (distance) was above or below some threshold $d$ of their choosing before deciding whether to go for a second throw. Spears has presumably chosen d to maximize their chance of winning — no wonder they made it to the finals!

Spears Robot isn’t aware that you’ve learned this fact; they assume Java-lin is using the Nash equilibrium strategy.. If you were to adjust Java-lin’s strategy to maximize its odds of winning given this, what would be Java-lin’s updated probability of winning?

Solution

This problem naturally has three components:

• What is the Nash equilibrium strategy in the vanilla game?
• Given that $S$ can see if $J$’s throw was more or less than $d$, what is their optimal $d^*$?
• Knowing that $S$ will play optimally with their new information but doesn’t know $J$ is aware of $S$’s strategy, what is the optimal strategy for $J$ now?

Part 1: Vanilla Nash Equilibrium

We assume both robots use a threshold strategy and by symmetry they adopt the same threshold $\tau$. That is, both robots throw their first javelin. If they throw it further than distance $\tau$ then they keep their first throw, otherwise they throw again. In this first part, we’ll find the value of $\tau$.

Recall that in a Nash equilibrium, no player can unilaterally change their strategy and improve their position. So without loss of generality, let’s assume that $J$ uses $\tau$ and $S$ uses $t$. We would like to find the value of $\tau$ such that for all $t \in [0, 1]$, $S$’s probability of winning is maximized at $t = \tau$.

To do this, we first need an expression for the probability that $S$ wins given they use strategy $t$ and $J$ uses strategy $\tau$. Let $\tilde{s}$ and $\tilde{j}$ be random variables denoting the distance $S$ and $J$ use in their score respectively. We want to determine $\Pr[\tilde{s} > \tilde{j}]$. We can write down the CDF of $\tilde{s}$ for fixed $t$ as:

This follows from the fact that the only way to throw at most $s$ for $s \leq t$ is to throw under $t$ the first throw, then under $s$ the second. And for $s > t$ we can throw between it and $t$ on our first throw with probability $s - t$ or below $t$ on the first throw and then under $s$ the second. By the same logic, the CDF of $\tilde{j}$ is

With these, we can write $\Pr[\tilde{s} > \tilde{j}]$ as a function of $t$.

Now, we would like to find the value of $\tau$ such that: $\Pr \left[\tilde{s} > \tilde{j}\right](t, \tau)$ is maximized in $t$ at $t = \tau$. If we vary $\tau$ and plot the probability of winning as a function of $t$, we can see that there is some $\tau$ for which the function in $t$ is strictly decreasing in $t$ on either side of $t = \tau$.

Taking the derivative of (\ref{eq:van_nash}) in $t$, setting $t = \tau$, and then solving for the root in $\tau$ yields a value of

which is the unique Nash-equilibrium threshold strategy in the vanilla game and aligns with the value we would expect from Figure 1.

Part 2: Optimal Cheating

The next step is to determine what value of $d$ player $S$ should use to cheat in an optimal way. Recall that $S$ is choosing $d$ with the belief that $J$ is using the vanilla strategy with threshold $\tau$.

To choose $d$, $S$ can utilize two pieces of information: their initial throw value and a bit indicating whether or not $J$’s first throw exceeded $d$. From this information, $S$ must decide to rethrow or keep. Like in the previous section, we will develop an expression for the probability $S$ wins when $d \leq \tau$ and $d > \tau$ and use those to determine an optimal value for $d$.

Case 1: $d < \tau$

Suppose $d \leq \tau$ and $S$’s initial throw was $s_1$. We can break up the probability $S$ wins by considering the cases where $J$’s first throw, denoted $j_1$, was more or less than $d$. If $j_1 < d \leq \tau$, then $S$ knows that $J$ will rethrow. In that case, $S$ will keep if their initial throw was at least $1/2$ and rethrow otherwise. Therefore, the probability of $S$ winning if they initially throw $s$ and observe that $j_1 < d$ is $P_{lo}(s_1) = \max(s_1, 1/2)$ where the first term represents keeping their initial throw of $s$ and the second is the event they both rethrow.

On the other hand, if $j_1 > d$ then since $d \leq \tau$, $J$ may rethrow or keep. If $S$ keeps here, they win with probability

By the same conditioning logic, we find that if $S$ rethrows they win with probability

$S$ will choose the larger of $P_{keep}(s_1)$ and $P_{throw}$ depending on the value of $s_1$.

Putting it together and integrating these cases over the possible values of $s_1$, the probability of $S$ winning for a given $d \leq \tau$ is

Case 2: $d > \tau$

Now, we must perform the same analysis for $d > \tau$. If $S$ observes that $j_1 \geq d \geq \tau$, then they will know $J$ will keep with certainty. If $S$ rethrows they win with probability $(1 - d)/2$, and if they keep, they win with probability $\max ( 0, (s_1 - d)/(1 - d) )$. Putting these together, in the event that $S$ observes that $J$ throws more than $d$, $S$ wins with probability

Next, in the event $S$ observes $j_1 < d$, $J$ may rethrow or keep, so we need to use the same conditioning logic as in the previous case. Doing so, we find that the probability of $S$ winning when they keep and rethrow are:

As for a brief explanation of the terms in $P_{keep}(s_1)$, note since $j_1 < d$, $J$ will rethrow with probability $d/\tau$ and then the second throw will be less than $s_1$ with probability $s_1$. That is why the term $\tau s_1/d $ appears in each case. The last two terms consider the additional case where $J$ keeps. For the middle term, some $j_1$ can beat $s_1$ in this interval; whereas in the last term, since $s_1 > d > j_1$, $S$ wins.

Similar to in the previous case, $S$ will choose the larger of the two options $P_{keep}(s_1)$ and $P_{throw}$. We can now integrate the probability of winning when $d > \tau$ as a function of $s$ to get \(\begin{equation*} \begin{aligned} P_{Win (d > \tau)}(d) & = \int_{0}^1\bigg( d \cdot P_{hi}(s_1) + (1 - d) \cdot \max\bigg\{P_{keep}(s_1), P_{throw} \bigg\} \bigg)\;ds_1 \\ & = \frac{\left(\sqrt{5}+1\right) d^4-8 d^3+2 \left(\sqrt{5}+1\right) d^2-8 \left(\sqrt{5}-2\right) d+9 \sqrt{5}-15}{8 \left(\sqrt{5}-1\right)} \end{aligned} \end{equation*}\)

If we now plot the probability of $S$ winning as a piecewise function in $d$ consisting of $P_{Win (d < \tau)}(d)$ and $P_{Win (d > \tau)}(d)$, we see:

this implies that $\boxed{d^* = \tau}$. We can then further verify this by noting that the derivatives of $P_{Win (d < \tau)}(d)$ and $P_{Win (d > \tau)}(d)$ are strictly increasing and decreasing in $d$ for their respective regions.

The takeaway is that the optimal query is simply whether $J$ will rethrow. When $S$ does this, they win with probability

Which is a slight edge above the previous 50-50 outcome.

Part 3: $J$’s Optimal Response to Cheating

Lastly, $J$ knows that $S$ can tell if $J$’s first throw is below or above $\tau$. How can $J$ use this information to devise an optimal response to $S$’s cheating? $S$’s behavior will vary depending on whether or not $J$’s first throw was more or less than $\tau$. We can assume $J$ uses a threshold strategy that depends on the first throw. Let $r$ be the new threshold used by $J$.

First suppose that $j_1 \leq \tau$ . When should $J$ keep the first throw?

Since $S$ is cheating, they know $j_1 \leq \tau$. Based on the strategy we discovered in the previous part the CDF of the final value $S$ receives is

For fixed threshold $r < \tau$ we can develop the corresponding CDF and PDF for $J$’s final value

Thus, the probability of $J$ winning as a function of $r$ is

We visualize this below in Figure 3.

From the figure, we see that the function seems to be unimodal with a maximum somewhere just before the threshold. Sure enough, if we take the derivative and solve for the root, we find that $\boxed{r^* = 7/12}$ is the optimal threshold strategy for $J$ when $j_1 \leq \tau$ which yields

In summary, there is now a window, $[7/12, \tau]$, such that when $J$’s first throw falls in this window, $J$ can take advantage of $S$’s cheating and keep when $S$ thinks that $J$ will rethrow.

In the event that $j_1 > \tau$, we can suppose another threshold $r’$ and repeat the same steps as before. However, this time we find that $\Pr\left[J \text{ win}\mid j_1 > \tau\right](r’)$ is a strictly decreasing function for $r’ \geq \tau$, implying that when $J$’s first throw exceeds $\tau$, they should always keep, as in the vanilla strategy. Furthermore, when plugging in $r’ = \tau$, we find that

We have now worked out everyone’s optimal strategy and now it remains to compute the probability that $J$ wins! By conditioning on the event that $J$’s first throw is below or above $\tau$, we finally find

How does this fare against the previous odds when $J$ did not know $S$ was cheating? Previously, against cheating $S$, $J$ won with probability $0.493034$ whereas now they win with probability $0.493937$. A very minor improvement. Unfortunately for $J$, $S$’s cheating is hard to recover from. Fortunately for them, the game is still nearly 50-50!

The Artificial Automaton Athletics Association (Quad-A) is at it again, to compete with postseason baseball they are developing a Robot Baseball competition. Games are composed of a series of independent at-bats in which the Batter is trying to maximize expected score and the Pitcher is trying to minimize expected score.

An at-bat is a series of pitches with a running count of balls and strikes, both starting at zero. For each pitch, the Pitcher decides whether to throw a ball or strike, and the Batter decides whether to wait or swing; these decisions are made secretly and simultaneously. The results of these choices are as follows.

• If the Pitcher throws a ball and the Batter waits, the count of balls is incremented by $1$.
• If the Pitcher throws a strike and the Batter waits, the count of strikes is incremented by $1$.
• If the Pitcher throws a ball and the Batter swings, the count of strikes is incremented by $1$.
• If the Pitcher throws a strike and the Batter swings, with probability $p$ the Batter hits a home run and with probability $1-p$ the count of strikes is incremented by $1$.

An at-bat ends when either:

• The count of balls reaches $4$, in which case the Batter receives $1$ point.
• The count of strikes reaches $3$, in which case the Batter receives $0$ points.
• The Batter hits a home run, in which case the Batter receives $4$ points.

By varying the size of the strike zone, Quad-A can adjust the value $p$, the probability a pitched strike that is swung at results in a home run. They have found that viewers are most excited by at-bats that reach a full count, that is, the at-bats that reach the state of three balls and two strikes. Let $q$ be the probability of at-bats reaching full count; $q$ is dependent on p. Assume the Batter and Pitcher are both using optimal mixed strategies and Quad-A has chosen the $p$ that maximizes $q$. Find this $q$, the maximal probability at-bats reach full count, to ten decimal places.

Solution

We can solve this problem by modeling it as finite-state Markov chain. Let the states be given by the set \(S = \left\{(b, s) : s \in \{0,\ldots,3\}, b \in \{0,\ldots,4\}\right\}\) where $(b, s)$ represents the state with $b$ balls and $s$ strikes. Depending on the decisions made by the pair of robots at a given state (swing or wait for the Batter and strike and ball for the Pitcher respectively), we transition to one of several possible states, each with their own transition probability.

If we knew the transition probabilities between all states as a function of $p$, then we can tune $p$ such that the probability of reaching a full count from the initial state $(0,0)$ is maximized. Thus we will approach the remainder of the problem in three steps:

• For a given state $(b, s)$ determine the optimal strategies for each player.
• Given the optimal strategies, determine the transition probabilities between states in the induced Markov chain.
• Determine the probability of reaching a full count and then select $p$ as to maximize it.

Optimal Strategies

Let $V(b, s)$ be the expected score of the Batter at state $(b, s)$. For a given state, we have a subgame where the Batter is trying to maximize the expected score and the Pitcher to minimize it. What are the optimal strategies for this subgame?

We can describe the strategies of the players using the concept of mixed-strategies. Let $x \in [0,1]$ and $y \in [0, 1]$ be the probabilities that the Batter plays swing and the Pitcher plays strike at state $(b,s)$ respectively. How can we determine what these two ought to be in an equilibrium strategy? Recall that in a Nash equilibrium, neither player can increase their objective by altering their current strategy. By the nature of our game, we can reason that neither player should use a pure strategy, as the opponent (or the player) could then deviate and improve their payout (Think rock, paper, scissors here – If your opponent always plays rock you should drop whatever strategy you are using and play paper). So what does a mixed strategy equilibrium look like in this case, does one even exist?

It turns out that, yes, one does exist! Since the subgame has a finite number of players (two) and a finite number of pure strategies (two each), it famously follows that the game will indeed have at least one Nash equillibrium in mixed-strategies. Now, can we find it?

Suppose that $(x, y)$ forms a mixed-strategy Nash equilibrium and that the Batter was considering changing $x$ in an attempt to increase their score. The expected payoff to the Batter using strategy $x$, for fixed $y$, is given by:

To determine their strategy $y$, the Pitcher should choose $y$ such that the Batter cannot do better by deviating from $x$. For fixed $y$, we can write (\ref{eq:payoff1}) as

where $C_1(y), C_2(y)$ are constants that depend on $y$. Observe that (\ref{eq:payoff2}) is maximized at $x = 0$ when $C_1(y) < C_2(y)$, $x = 1$ when $C_1(y) > C_2(y)$, and any $x \in [0, 1]$ when $C_1 = C_2$. From this observation, it follows that if the Pitcher were to set $y$ such that $C_1(y) = C_2(y)$, then the Batter cannot improve their payoff by deviating from $x$.

We can solve for $y$ such that $C_1(y) = C_2(y)$. Doing so, we find that

From (\ref{eq:y_strat}), since for any $(b, s) \in S$, we have that $V(b, s) \leq 4$ and $V(b + 1,s) \geq V(b,s + 1)$, it follows that $y(b, s) \in [0,1]$, which implies $y$ is a well-defined probability value.

Now, since the Batter and Pitcher share the same objective function, but different optimization directions, we can apply the same logic to ensure that the Pitcher cannot improve their payoff by deviating from $y(b, s)$, to find the corresponding Nash equilibrium strategy of

Now that we have found the unique Nash equilibrium strategy pair in this game ¹ . We need to apply backwards induction using our state payoffs $V$ to find the exact value of each $x(b, s)$.

As mentioned in the problem statement, the payout to the Batter for striking out is $0$, for getting a walk is $1$, and for hitting a Homerun is $4$. Therefore the payouts are $V(b, 3) = 0$, $V(4, s) = 1$. We can solve for the Batter score function under the equilibrium strategies using the Mathematica code below.

B = 4;
S = 3;
(* Base Cases *)
V[b_ /; b == B, s_] := 1 
V[b_, s_ /; s == S] := 0

(*Define equilibrium strategies*)
x[b_, s_] := 
 x[b, s] = 
  Simplify[(V[b + 1, s] - V[b, s + 1])/(
   4 p - (1 + p) V[b, s + 1] + V[b + 1, s])]

(*Define Payoff recurrence under optimal strategy*)
V[b_, s_] := V[b, s] = x[b, s]^2 (4  p + (1 - p) V[b, s + 1]) + 
    2 x[b, s] (1 - x[b, s]) V[b, s + 1] + (1 - x[b, s])^2 V[b + 1, s]

Note $V(b, s)$ and $x(b, s)$ only rely on states that are further along in the count (namely $V(b +1, s)$ and $V(b, s + 1)$) so we can use backwards induction to solve for them.

Transition Probabilities

Given that we now have a system to compute the optimal strategies and valuations of each state, to complete our Markov chain, we need to determine the transition probabilities between states.

We will have the absorption states: $(b, 3)$ and $(4, s)$ for $b \in[3]$ and $s \in [2]$ which represent the outcomes of strikeout and walk respectively, and an auxiliary state that represents a Homerun, which can be reached from any non-terminal state in the game. We visualize the Markov chain below in Figure 1 (omitting the Homerun state for clarity).

Given that we are at the non-absorbing state $(b, s)$, we can either transition to $(b + 1, s)$, $(b, s + 1)$ or the Homerun state. Let $Q(b, s)$ be the probability of reaching a full count given we are at state $(b, s)$. We can write $Q(b,s)$ as

where $x$ is the Nash-equilibrium strategy given in (\ref{eq:y_strat}). The base cases for our function $Q$ are $Q(3, 2) = 1$ and $Q(b, s) = 0$ for any terminal state. For a given $p$, we can now use dynamic programming to compute $Q(0, 0)$, using the snippet of Mathematica code below. We want to know the value of $p \in [0,1]$ that maximizes the value of $Q(0, 0)$.

(* Base Cases *)
Q[b_ /; b == B - 1, s_ /; s == S - 1] := 1 
Q[b_ /; b == B, s_] := 0
Q[b_, s_ /; s == S ] := 0

(*General recurrence *)
Q[b_, s_] := Q[b, s] = x[b, s]^2 (1 - p) Q[b, s + 1] + 
   2 x[b, s] (1 - x[b, s]) Q[b, s + 1] + (1 - x[b, s]) ^2 Q[b + 1, s]

Optimizing for a Full-Count.

We can plot $Q(0,0)$ as a function of $p$.

Based on the figure, we can see the probability is unimodal in $p$ and we can use our favorite Binary Search method to determine the $p$ that maximizes our function. Alternatively, we can ask Mathematica to do this for us!

(* Maximize Q[0,0] over the interval [0,1] *)
NMaximize[{Q[0, 0], p >= 0, p <= 1}, p, WorkingPrecision -> 20]

Which produces a value of $\boxed{p^* \approx 0.2269732325}$ and the probability of reaching a full count in this case $\boxed{q \approx 0.2959679934}$, which is the answer to this month’s puzzle!

For fun, I experimented with changing the value of the Homerun state. In the given description, the value of a Homerun is 4 which implies the Batter has the bases loaded! What if this was instead a lower stakes scenario for the pitcher, and there were instead fewer points on the line if the Batter hit a Homerun. Below are the probabilities of reaching a full count, for various numbers of runners on base, as a function of $p$. We can see that with more players on base, the lower the value of $p$ needs to be to maximize the odds of reaching a full count!

Robot cars have a top speed (which they prefer to maintain at all times while driving) that’s a real number randomly drawn uniformly between $1$ and \(2\) miles per minute. A two-lane highway for robot cars has a fast-lane (with minimum speed \(a\)) and a slow-lane (with maximum speed \(a\)). When a faster car overtakes a slower car in the same lane, the slower car is required to decelerate to either change lanes (if both cars start in the fast-lane) or stop on the shoulder (if both cars start in the slow-lane). Robot cars decelerate and accelerate at a constant rate of $1$ mile per minute per minute, timed so the faster, overtaking car doesn’t have to change speed at all, and passing happens instantaneously.

If cars rarely meet (so you never have to consider a car meeting more than one other car on its trip, see Mathematical clarification below), and you want to minimize the miles not driven due to passing, what should \(a\) be set to, in miles per minute? Give your answer to 10 decimal places.

Mathematical clarification: Say car trips arrive at a rate of $z > 0$ car trip beginnings per mile per minute, uniformly across the infinite highway (cars enter and exit their trips at their preferred speed due to on/off ramps), and car trips have a constant length of \(N\) miles. Define \(f(z,N)\) to be the value of $a$ that minimizes the expected lost distance per car trip due to passing. Find:

Solution

At a high-level, our solution will do the following:

• For car $C$ entering the roadway at a given location, time, and speed, determine the necessary conditions for another car to overtake $C$ during $C$’s journey.
• Determine, for each overtake, the total miles not driven due to passing
• Combine these two to determine the expected miles not driven due to passing for a car traveling at speed $v$.
• Average over all $v$ and determine the optimal speed threshold $f(z, N)$ for the highway.
• Determine $a^* = \lim_{N \to \infty} \lim_{z \to 0^+} f(z,N)$

Before diving into the analysis, we will point out an observation from the mathematical clarification. Suppose we have an infinitely long highway at which cars enter at rate $z$ starts/mile/minute. Based on this description, we can say that the number of cars that enter the highway on a strip of length $\Delta x$ during a duration of time $\Delta t$ is a Poisson random variable with mean/rate $\lambda = z \Delta x \Delta t$. An important property of Poisson random variables is that their sum is also a Poisson random variable in which their rates have been added. With this in mind, we begin our analysis.

Let us consider a car $C$ that enters the highway (WLOG) at $x = 0$ and $t = 0$ with speed $v \in [1, 2]$. This car will travel for $N / v$ minutes and exit the highway at its destination $x = N$. We would like to determine the distribution for the number of cars will catch up to and pass $C$. First some observations. For a car $C’$ to pass car $C$, it must meeting the following conditions:

• Have speed $u > v$ (It is moving faster than $C$).
• If it starts its trip at time $t = t_s$, $C’$ must be behind where $C$ is at $t = t_s$ (It must start behind $C$ to overtake it).
• Share the same position as $C$ at some time $t$ during the time interval at which both cars are driving.

Using these, we would like to get a distribution for the number of cars that will pass $C$. Let us start by fixing the speed of car $C’$, to be some $u$ such that $u > v$. What are the conditions on the starting time and position of $C’$ that will allow it to pass $C$? Suppose $C’$ starts at position $x_s$ at time $t_s$ and the two cars intersect at time $t$. Based the previous conditions, we get the following inequalities:

Using (\ref{eq:same_x}), we can solve for $t$ as $t = \frac{u t_s - x_s}{u - v}$ and plug this into the other inequalities to get a set of four inequalities in the $(x_s, t_s)$-space.

Which when plotted in the $(x_s, t_s)$-space, these inequalities define a region $R$ which is a convex quadrilateral. This region is the set of all pairs of $(x_s, t_s)$ that would allow $C’$, traveling at speed $u$ to intersect $C$. See an example below.

The vertices of $R$ are given by

which imply that the area of our quadrilateral is \(\boxed{ Area(R) = \frac{N^2 (u - v)}{uv}}\).

Using our earlier observation about the number of cars for a given region of time and space being a Poisson random variable with parameter proportional to the area of that region, we deduce that the distribution for the number of which cars of speed $u$ that arrive in the time-space region $R$ is a Poisson random variable with rate parameter $\lambda(u)$ given by

Where $z dF(u)$ is the rate at which car of speed $u$ arrive per mile per minute. Since the speed of cars is distributed $U(1, 2)$, we have $dF(u) = du / 1$.

We now have enough to compute the rate of overtakes for $C$ when it is in the slow-lane $\Lambda_S$ and when it is in the fast-lane, $\Lambda_F$.

For the slow-lane, we have

And for the fast-lane

These are the expected number of intersections per trip for a car of speed $v$, depending on whether the car is in the slow-lane or the fast-lane (since they are Poisson random variables). Now, we need to determine the “loss of distance traveled” for each overtake in either scenario.

Suppose we are in the slow-lane. Whenever we are passed, we must fully stop and then speed up to speed $v$ again. Since the acceleration is fixed to be $1$, the time it take to stop and speed up are the same and is $\delta t = v$ minutes. The total distance that would be traveled during this time without intersection is

On the other hand, when we have to stop, the distance traveled during the deceleration is

and acceleration

Thus the “loss of distance” for each passing in the slow-lane is:

By similar calculations, we find the “loss of distance” per passing in the fast-lane is:

Putting these together, for a car of speed $v$ the expected lost distance due to passing, $\ell(v)$, is given by:

Since the speed of cars is distributed $U(1, 2)$, we need to compute the expected total lost distance for a car entering the highway with speed threshold $a$, denoted $L(a)$. We find

Now, for fixed $z$ and $N$, we would like to find the value of $a$ that minimizes the above expression. However, note that $N$ and $z$ simply contribute a positive scaling factor and do not affect minimizing the overall expression. Therefore, it suffices to remove the constant factors and instead minimize the function

If we plot $g(a)$ over the interval $a \in [1,2]$, (see Figure 2) it appears that the function should have a unique minimizer over the desired interval.

Unfortunately, there is not a nice closed form solution for the minimizer, so we will have to solve for it numerically. Doing so yields for fixed $N$ and $z$,

taking the limit of which for $N$ and $z$ has no effect, and thus we have found the value of $a^*$ that minimizes the expected lost distance due to passing.

This value is pretty close to the minimum end of possible speeds on the highway! Around $82\%$ of the cars, on the highway are in the fast-lane. Why might that be? Well we can note that it is pretty expensive for a car in the slow-lane to be passed. Since $v \geq 1$ the loss of distance for every car in the slow-lane is at least $1$ whereas the maximum penalty for a passing in the fast-lane is at most 1. We see that passings in the slow-lane are much more expensive and thus we would need to have fewer of them than in the fast-lane in an optimal solution.

This was a fun problem that had me brushing up on my Poisson processes. I even found several problems in the Poisson Process section of Sheldon Ross’s Stochastic Processes textbook that were about cars entering a highway according to a similar rule which served as a great warm-up to tackling this problem!

You (Player 1) and your opponent (Player 2) are competing in a TGL golf match. On any given hole you play, each of you has a 50-percent chance of winning the hole (and a zero percent chance of tying). That said, scorekeeping in this match is a little different from the norm.

Each hole is worth 1 point. Before starting each hole, either you or your opponent can “throw the hammer.” When the hammer has been thrown, whoever did not throw the hammer must either accept the hammer or reject it. If they accept the hammer, the hole is worth 2 points. If they reject the hammer, they concede the hole and its 1 point to their opponent. Both players can throw the hammer on as many holes as they wish. (Should both players decide to throw the hammer at the exact same time—something that can’t be planned in advance—the hole is worth 2 points.)

The first player to reach \(n\) points wins the match. Suppose all players always make rational decisions to maximize their own chances of winning. If the first player wins the first hole and the score is \((1 - 0)\) what is the probability that they win the match?

Solution

This is a quick one this week! For each round, the players are playing in a zero-sum game.We can view them as competing for the “resource” that is the probability that they win the overall game given the current round. To solve for the probability that Player 1 wins from the score-state \((1,0)\), which we denote as \(V(1, 0)\), we need to develop a recursive relationship for \(V(i, j)\), the probability that the first player wins from state \((i, j)\) (Player 1 has \(i\) points and Player 2 has \(j\) points).

We observe that, at the start of each turn each player has two actions to start the turn: throw the hammer or do not throw the hammer. In the case that they do not throw the hammer, then they may have to then make the secondary choice of “accept” or “reject” if the other player chooses to throw their hammer. We adopt the convention that Player 1 chooses their actions based on the objective of maximizing the probability that they win the overall game at state \((i, j)\), \(V(i, j)\). Conversely, Player 2 chooses actions with the objective of minimizing this \(V(i, j)\). This leads us to the recurrence relation:

With the base case(s) of

Here we can see Player 1 is taking the action that maximizes their probability of winning the game given that, if they took a particular action, Player 2 would choose the action to minimize Player 1’s probability of winning under that action. We see in (\ref{eq:rec}) that in the case Player 1 chooses not to hammer, they may then face a secondary decision to accept or reject a Player 2 hammer toss, in which they would again choose the probability-maximizing action.

We can code this recurrence up in python using Dynamic Programming and visualize the probability of Player 1 winning at any given state. Here we have actually taken the liberty of slightly generalizing the problem. We are assuming that the Player 1’s probability of winning on round \(i + j\) (the current round, zero indexed) is known and is given by a list hole_probs. In the context of our original problem, every entry of hole_probs would be \(1/2\)

from functools import cache

@cache
def V(i, j):
    """ Probability Player 1 wins the game given we are at state (i, j) and they
    are playing to score n. We assume there is some list of probabilities 
    hole_probs such that hole_probs[i + j] is the probability that Player 1
    wins the current hole.  """
    if i >= n:
        return 1
    elif j >= n:
        return 0

    # the prob Player 1 wins current hole   
    p = hole_probs[i + j] 

    # Player 1 hammers
    prob_toss_win = min(
        p * V(i + 2, j) + (1 - p) * V(i, j + 2), 
        V(i + 1, j)
        )

    # Player 1 does not hammer
    prob_pass_win = min(
        p * V(i + 1, j) + (1 - p) * V(i, j + 1),
        max(
            p * V(i + 2, j) + (1 - p) * V(i, j + 2),
            V(i, j + 1)
            )
     )

    return max(prob_toss_win, prob_pass_win)  

# now input problem specific parameters and solve 
n = 5
hole_probs = [1/2 for _ in range(2 * n)]
print(f' The probability of Player 1 winning is {V(1,0)}')

With this, we can get visualize the probability of Player 1 winning from any state. Here are two examples of the original problem (each player is equally skilled) for small and large \(n\).

It’s worth noting that the “no hammer” option is never used by either player in this setting. For any \(n\) we can compute the value of \(V(1,0)\) in \(\mathcal{O}(n^2)\) time using our dynamic programming approach. For small \(n\), Player 1 has a significant advantage (for example \(n =3\) has \(V(1, 0) = 3/4\)) but as \(n\) increases, the value of \(V(1, 0)\) approaches \(1/2\) as we might expect.

Just for fun, we can also test out a different hole_probs distribution and see how this changes things. One interesting scenario is when Player 1 gradually improves over time. Specifically, at state \((i, j)\) the probability that they win the round is given by

(as the round number increases Player 1 gets linearly better). Initially Player 1 would be very bad and unlikely to win, but in the higher rounds they would be increasingly more clutch over Player 2.

The win‑probability heatmaps now look like the figures below, revealing three asymmetric regions of the state space (one favoring each player and one where they are neutral). In this case, we see the “no hammer” option become used more widely.

Lastly, here is one more scenario where

Here Player 1 still improves over the rounds but their skill grows quadratically. See if you can come up with your own funky distribution and see what the heatmap looks like using the code above and below!

import matplotlib.pyplot as plt
import numpy as np
n = 5
hole_probs = [1/2 for _ in range(2 * n + 1)]
#hole_probs = [i / (2 * n  - 2) for i in range(2 * n - 1)]
#hole_probs = [np.sqrt(i / (2 * n  - 2)) for i in range(2 * n - 1)]
#hole_probs = [(i / (2 * n  - 2)) ** 2 for i in range(2 * n - 1)]
print(f'for n = {n}, the probability of Player 1 winning from the start is {V(0, 0):.4f} and with a 1 point lead is {V(1, 0):.4f}')
def plot_prob_win_heatmap(n):
    """ heatmap of win probabilities V(i, j) for 0 <= i, j < n."""
    # matrix of V(i, j) 
    M = np.zeros((n + 1, n + 1))
    for i in range(n + 1):
        for j in range(n + 1):
            M[i, j] = float(V(j, i))
    
    # plot the heatmap
    plt.figure(figsize=(8, 6))
    plt.imshow(M, origin='lower', cmap='RdYlGn', interpolation='nearest')
    plt.colorbar(label='Probability of Win')
    plt.xlabel(r'$i$, Player 1 score')
    plt.ylabel(r'$j$, Player 2 score')
    plt.title(fr'Player $1$ Win Probability Heatmap for $n = {n}$')
    plt.show()

# try it out 
plot_prob_win_heatmap(n)

A teacher is handing out candy to his \(N\) students, of which \(N \geq 4\). He abides by the following rules:

He hands out candy to groups of three students (i.e., “trios”) at a time. Each member of the trio gets one piece of candy. Each unique trio can ask for candy, but that same trio can’t come back for seconds. If students in the trio want more candy, they must return as part of a different trio. When a trio gets candy, the next trio can’t contain any students from that previous trio.

It turns out that every possible trio can get a helping of candy. What is the smallest class size \(N\) for which this is possible?

Solution

Instead of focusing on the case of trios, we will generalize the problem and consider groups of \(k\) students. If there is some ordering of groups such that every group of \(k\) students can receive candy, what is the smallest such \(N\) for which this is possible? Denote this smallest \(N\) as \(N(k)\).

Now, what are some initial observations we can make about the problem? Well, first off, we can actually place the lower bound that \(N(k) \geq 2 k + 1\). This is because if there are any fewer students, then we cannot find a sequence of 3 initial \(k\)-groups. This was the only bound I could find in my initial exploration—the problem turned out to be much harder than I expected!

Perhaps changing our perspective can help us gain traction on the problem. What if we instead thought of the students as nodes in a graph and two nodes share an edge only if their representative groups are disjoint. Now, a path in this graph would then represent a sequence of groups that could get candy such that every group in the sequence is disjoint from the groups adjacent to it in the sequence. If we could find a path such that every node appeared in it exactly once, then we would have found a sequence of groups that allows every group to get candy! Such a path in a graph where every node is visited exactly once is called a Hamiltonian path. Our problem has now become, for what \(N\) does a Hamiltonian path exist for a given \(k\)?

It turns out that determining whether a Hamiltonian path exists in a graph is a hard problem. But perhaps there are some special properties our graph that make it a tractable endeavor without having to perform a brute-force search.

We need to first better describe our graph. Suppose for now, we fix some \(N \geq 2 k + 1\) and construct our graph as follows: The set of nodes \(V\) is the set of subsets of size \(k\) from the group of \(N\) students. Nodes \(u, v \in V\) share an undirected edge if \(u \cap v = \emptyset\). This graph will have \(\binom{N}{k}\) nodes. For a given node \(u\), it will have \(\binom{N - k}{k}\) edges (one to each of the groups that it shares no members with) and thus by the handshake lemma, the graph has \(\frac{\binom{N}{k}\binom{N - k}{k}}{2}\) edges.

Now that we have a clearer picture of the graph, is there a particular aspect of it that allows us to determine if it has a Hamiltonian path? It turns out there is. One especially nice property of our graph is that it is vertex transitive. In simple terms, vertex transitive implies that from every node in the graph, the graph “looks the same” from the perspective of that node. It turns out that there is an open conjecture, the Lovász Conjecture that states:

Lovász conjecture: Every finite, connected, vertex regular graph has a Hamiltonian cycle (and thus a Hamiltonian path).

While this is an open conjecture, it implies that there is some evidence to suggest: as long as our choice of \(N\) allows our graph to be connected, since it is vertex transitive, it may indeed contain a Hamiltonian path. This leads us to the natural question, for what \(N\) is our graph connected?

It turns out that for \(N \geq 2k + 1\), our graph is connected! To see why, consider any two distinct nodes \(u, v \in V\). If \(u \cap v = \emptyset\), then they share an edge by definition. Otherwise, Suppose \(u\) represents the group of students \((A, S)\) and \(v\) represents the students \((B, S)\) where \(A \cap B = \emptyset\) and \(\|S\| = x\). Under this framing, we can show that that the set of students \(W\) that are not in \(u \cup v\) has size \(x + 1\). We can now construct a path from \(u \to v\) using the following intuition.

We make a path that has the form

where we use the extra student in \(W\) to iteratively swap in one more student of \(S\) into the group with \(B\) and vice versa until the subgroup paired with the \(B\) subgroup eventually becomes the desired \(S\) subgroup ¹.

Now that we have argued that \(N=2k + 1\) is sufficient for our graph to be connected, and we have “evidence” now that suggests this should also be sufficient for there to exist a hamiltonian path, what else can we do except also conjecture that \(N(k) = 2k + 1\) and call it a day? Well it turns out that our graph with \(N = 2k + 1\) nodes is actually a special and well-studied graph. It turns out for \(N = 2 k + 1\), we have actually described the Odd Graph, \(O_{k + 1}\) which, for \(k \geq 3\), is known to contain a Hamiltonian cycle (and thus a path)!² Therefore, our choice of \(N = 2k + 1\) will ensure that every grouping of children can get candy and since this is the lower bound on possible values of \(N\), we indeed have that

Part 1: You have many flowers in three colors: red, orange, and yellow. You want to plant them in a straight row such that the order appears somewhat random, but not truly random. More specifically, you want the following to be true:

• No two adjacent flowers have the same color.
• No ordering of three consecutive flowers appears more than once in the row.

What is the maximum number of flowers the row can contain?

Part 2: In addition to red, orange, and yellow flowers, you now have a fourth color: pink! Again, you want to plant a straight row of flowers that appears somewhat random. The new rules are:

• No two adjacent flowers have the same color.
• No ordering of four consecutive flowers appears more than once in the flower row.
• Among any group of four consecutive flowers, at least three distinct colors are represented.

What is the maximum number of flowers the row can contain now?

Solution

Part 1:

Let’s first establish an upper bound on how long our row of flowers could be. Since each possible pattern of three flowers can appear only once, the longest imaginable row contains each pattern exactly once. The total number of patterns can be calculated:

• \(3\) choices for the first color
• \(2\) for the second
• \(2\) for the final color

Which gives the grand total of \(12\) total color patterns. As each pattern overlaps by two flowers, the longest possible row length is \(14\). But, can we achieve this maximum?

We verify using backtracking with Python

from matplotlib.patches import Rectangle
# lets write a function that, given the current state, sees how many flowers we can place
colors = ['r', 'o', 'y']

# we need to write some helpers that allow us to check if we can place a color 
# given the current sequence of colors so far 

# check the triplet formed is not a repeat 
def no_triplet(state, color):
    if len(state) < 3:
        return True
    else:
        cur_triplet = state[-2:] + color
        for i in range(len(state) - 2):
            if state[i:i+3] == cur_triplet:
                return False
        return True

# check for adjacent color and not a new triplet 
def can_place(state, color):
    if state[-1] != color and no_triplet(state, color):
        return True
    return False

# returns the max len flower array given the current placement
def max_flower(state):
    best = len(state)
    best_flower = state
    for color in colors:
        if can_place(state, color):
            cur_flower, cur_size = max_flower(state + color)
            if cur_size > best:
                best = cur_size
                best_flower = cur_flower
    
    return best_flower, best

# just assume the base flower is 'ro'
best_flower, best_size = max_flower('ro')
print('Best flower:', best_flower)
print('Best size:', best_size)


# Now lets visualize the best flower as a sequence of rectangles 
import matplotlib.pyplot as plt

color_mapping = {'r': 'red', 'o': 'orange', 'y': 'yellow'}

fig, ax = plt.subplots(figsize=(len(best_flower), 2))
for idx, letter in enumerate(best_flower):
    rect = Rectangle((idx, 0), 1, 1, color=color_mapping[letter])
    ax.add_patch(rect)
    
ax.set_xlim(0, len(best_flower))
ax.set_ylim(0, 1)
ax.axis('off')
plt.show()
            

Which gives us the output and visualized longest flower:

Best flower: roroyryoyoryro
Best size: 14

Confirming that we can indeed reach the longest possible flower length of \(\boxed{14}\) under the conditions!

Part 2

For the extra credit, we can still use the backtracking approach but given the increased state space size, it might take a while. We can try another approach to handle the larger state space integer programming with the z3 module. With this approach, we will answer the decision problem:

for a given \(n\), does there exist a feasible flower row of length \(n\)?

Using the answer to this decision problem, we can binary search over the space of the possible lengths to find the largest \(n\) such that there exists a feasible flower row.

Before we implement this, we need to again place an upper bound on the largest possible flower row so that we know the range of sizes we are to search over. Using a similar logic as in Part 1, along with the additional constraint that for any \(4\) adjacent flowers we need at least \(3\) distinct colors, we can show that there are \(96\) such possible color patterns. Therefore the largest possible flower row has size \(99\). Now it remains to model the decision procedure with the z3 module in python and then binary search over the space of possible lengths \([4, 96]\).

from z3 import *
from itertools import combinations

def flower_problem(n, k=4):
    """The decision procedure: returns True if there exists a feasible flower row
    of size n with k colors. """
    # The n decision variables (color of each flower)
    x = [Int(f'x_{i}') for i in range(n)]
    
    # Constraints:
    s = Solver()
    # 1)  Each flower must have a color 
    for i in range(n):
        s.add(And(x[i] >= 0, x[i] <= k - 1))
    
    # 2) No two adjacent colors match
    for i in range(n - 1):
        s.add(x[i] != x[i+1])
    
    # 3) no repeated k-patterns 
    for i in range(n - k + 1):
        for j in range(i + 1, n - k + 1):
            # Build the disjunction: at least one position l in {0,..., k-1} is different.
            diff = [x[i + l] != x[j + l] for l in range(k)]
            s.add(Or(diff))
    
    # 4) Each k-block must contain at least k-1 distinct colors.
    for i in range(n - k + 1):
        block = x[i:i+k]
        # we need to check all combinations of k - 1 colors in the block
        t = []
        for c in combinations(range(k), k - 1):
            t.append(Distinct([block[i] for i in c]))
        s.add(Or(t))
    
    # Try to solve 
    if s.check() == sat:
        m = s.model()
        # Return the solution as a list of integers.
        return [m.evaluate(x[i]).as_long() for i in range(n)]
    else:
        return None

Performing a binary search over the range of possible flower values with \(k = 4\), we find that \(\boxed{99}\) is the maximal achievable flower row length.

For our two cases (four if you include the trivial \(k = 1\) and \(k = 2\) cases), it seems that we can find a way to include all possible length \(k\) flower combinations without violating our constraints. This might lead us to suspect that, in general, it is possible to construct a flower row that includes all the possible valid ¹ length \(k\) flower combinations. If this were true, what would the maximal length of a flower row consisting of \(k\) colors, \(M(k)\) be?

To calculate this, we need only consider how many possible valid length \(k\) flower combinations there are. We have two cases,

• Case 1: All the flowers are different: In this case there are exactly \(k!\) such valid combinations
• Case 2: There is a repeat flower color: In this case there is exactly one flower color excluded. There are \(k\) ways to choose the excluded color and then \(k - 1\) ways to choose the color to be repeated of the remaining colors. Now to order the flowers, we place the duplicate color first. There are \(\binom{k}{2} - (k - 1)\) ways to pick the spots they will be placed without them being adjacent and lastly there are \((k - 2)!\) ways to place the remaining flowers.

Combining Cases 1 and 2, we find that the maximum flower length that satisfies our constraints on \(k\) flowers is:

So, is it possible to achieve this upper bound for all \(k\), as our few experiments suggest might be true? Well, it turns out that if we instead model our problem as a graph where the nodes are the valid length \(k\) flower orderings and two nodes \(u, v\) are connected via directed edge \(u \to v\) if the last \(k-1\) colors of u are the first \(k-1\) colors of \(v\), then our problem is reduced to finding a hamiltonian path on the nodes! Fortunately, our post last week introduced the Lovász Conjecture which again, suggests ² that this graph (finite, connected, and vertex-transitive) will have admit a hamiltonian path! Therefore we have some reasonably strong evidence that our value of \(M(k)\), can be achieved!

We can use our z3 model to generate an example of a maximal flower row with \(k = 5\) colors (we have made the 5th color blue here)! As predicted it was length \(M(5) = 844\).

There are \(2^n\) teams playing in a single-elimination seeded tournament. The teams play in a traditional seeded tournament format. That is, in the first round, the sum of teams playing each other is \(2^n + 1\) (for example seed \(1\) plays seed \(2^n\), \(2\) plays \(2^n - 1\), etc). If the stronger team always advances, then the sum of opponents’ seeds in the second round is \(2^{n - 1} + 1\), and so on.

Each team possesses a “power index” equal to \(2^n + 1\) minus that team’s seed. For example, team \(1\) has power index \(2^n\). In any given matchup, the team with the greater power index would emerge victorious. However, March Madness fans love to root for the underdog. As a result, the team with the lower power index gets an effective “boost” \(B\) applied to their power index, where \(B\) is some positive non-integer.

As an illustration, consider the matchup between the \(2\) and \(3\)-seeds. The favored \(2\)-seed has a power index of \(3\), while the underdog \(3\)-seed has a power index of \(2+B\). When \(B\) is greater than \(1\), the \(3\)-seed will defeat the \(2\)-seed in an upset.

Depending on the value of \(B\), different teams will win the tournament. Of the \(2^n\) teams, how many can never win, regardless of the value of \(B\)?

Solution

We can start out with some observations. First, for fixed \(B\), the winner of the tournament is deterministic. This suggests we should define a function \(W_n(B)\) that for a given \(n\) and \(B\) returns the winning seed in the tournament. To solve our problem, we could then determine which values that \(W_n(B)\) can and cannot take on. The next useful observation is that for \(B > 2^n - 1\), the value of \(W_n(B)\) is a constant. Specifically, for \(B > 2^n - 1\), the lowest seeded team will always win the tournament. Thus we need only consider the non-integral values of \(W_n(B)\) on the interval \(B \in [0, 2^n]\). The last observation we need to consider is that for any two teams playing, say with seeds \(a\) and \(b\) with \(a < b\), the value of \(B\) for which the winner and loser of the game swap is \(b - a + \epsilon\) where \(\varepsilon > 0\) is an arbitrarily small constant. Therefore, as we vary \(B\) from \(0 \to 2^n\), the only values of \(B\) where we may see the value of \(W_n(B)\) change are of the form \(k + \varepsilon\) where \(k\) is a non-negative integer.

With those observations, our strategy for solving the problem can be made clear. For \(B = k + \varepsilon\) for \(k \in [2^n - 1]\), determine the value of \(W_n(B)\) for the given value of \(B\) and keep track of the winners as we iterate over the values of \(B\). Then simply report the values in \([2^n]\) that were not found to be winners.

from collections import defaultdict
import numpy as np

def gen_bracket(n):
    """
    Recursively generate a seeded bracket for n players (n must be a power of 2).
    Returns a list where consecutive elements form a matchup.
    """
    if n == 1:
        return [1]
    else:
        prev = gen_bracket(n // 2)
        mirror = [n + 1 - seed for seed in prev]
        bracket = [seed for pair in zip(prev, mirror) for seed in pair]
        return bracket

def winner(seedA, seedB, N, B):
    """
    Returns the winner of the matchup seedA vs seedB in an 
    N person tournament with boost B.
    """
    # make sure seedA is lower seed 
    if seedA > seedB:
        seedA, seedB = seedB, seedA
    power_rankA = N + 1 - seedA
    power_rankB = N + 1 - seedB + B
    if power_rankA > power_rankB:
        return seedA
    else:
        return seedB
    

def W(n, B):
    """ 
    The winner of a 2^n person tournament with boost B. 
    """
    N = 2 ** n 
    bracket = generate_bracket(N)
    while True:
        # keep simulating until one team left 
        if len(bracket) == 1:
            return bracket[0]
        else:
            winners = []
            for i in range(0, len(bracket), 2):
                seedA = bracket[i]
                seedB = bracket[i + 1]
                winners.append(winner(seedA, seedB, N, B))
            bracket = winners

Then to get the possible winners for a given tournament size of \(2^n\) and to compute the number of teams that cannot win, we can run the below code.

n = 6 # solve for 2^6 = 64 teams 
    
can_win = defaultdict(bool)
# B-values where winner could swap values
B_space = [i + eps for i in range(1, 2 ** n + 1)] 
for b in B_space:
    champ = tournament_winner(n, b)
    can_win[champ] = True
winners = list(sorted(list(can_win.keys())))
print(f'The teams that CAN win are {winners}')
print(f'There are {2 ** n  - len(winners)} teams that cannot win')
print(f'The function that predicts this is {2 ** (n - 1) - (n - 1)}')

Since this code is for general \(n\), we can compute the number of teams that cannot win for several values of \(n\), see table 1.

Some of you may notice a pattern in this sequence. If we let \(a_n\) be the number of teams that cannot win in a \(2^n\) team tournament, then we see the pattern emerge

for \(n \geq 2\). Which would suggest that

We won’t attempt prove this conjecture here, but the pattern holds for \(n \leq 20\).

Lastly, it would be interesting to see the plot of \(W_n(B)\) for various \(n\) so that we can get a sense of which teams are capable of winning. Below in Figure 1 is a gif that illustrates the function \(W_n(B)\) for various values of \(n\). We see that as \(n\) grows the shape of the function begins to approach some interesting limiting shape!

Upon inspection it appears there is a recursive description of how these curves relate to one another. Here is a very rough description of how they appear related. We see for a given \(n\), for \(B > 2^{n - 1}\), the \(W_n(B)\) is non-decreasing in \(B\) and produces \(2^{n - 2} + 1\) unique winners in that range. The curve for \(W_{n + 1}(B)\) has the same values as \(W_n(B)\) for \(B < 2^{n - 1}\). Then for \(B \in [2^{n - 1}, 2^n]\), the previously increasing portion of the curve is reflected downward about its start point, and then for \(B > 2^n\), the curve has the same monotonic behavior but for \(2^{n -1} + 1\) values. Note that for all \(n \geq 2\), \(W_n(B)\) is a one-to-one function. That is, no winner is ever repeated for different \(B\). If this behavior is indeed an accurate description of the curves (as it empirically appears to be), then this would prove our conjecture about \(a_n\) ¹.

You are planning a picnic on the remote tropical island of \(\pi\)-land. The island’s shape is a perfect semi-disk with two beaches, as illustrated below. We have Semicircular Beach (along the northern semicircular edge of the disk) and Diametric Beach (along the southern diameter of the disk).

Part 1:
If you pick a random spot on \(\pi\)-land for your picnic, what is the probability that it will be closer to Diametric Beach than to Semicircular Beach?

Part 2:
Given the radius of \(\pi\)-land is 1, on average, what will be the expected shortest distance to shore?

Solution

Part 1

The immediate intuition is that the set of points closer to the Diametric Beach than the Semicircular Beach should form a well-defined geometric region. If we can determine that region, denoted \(D\), the desired probability is simply the area of that region divided by the area of the entire semicircle.

Let the island’s radius be 1, its center be at \((0, 0)\), and denote the points on the island by the region \(C\). Consider a point \((x, y)\) on the island, which beach is it closer to? The distance to Diametric Beach is just its \(y\)-coordinate. What about the distance to Semicircular Beach?

The shortest path from \((x, y)\) to Semicircular Beach is along the radial line through \((0,0)\) and \((x,y)\).¹ This means the shortest distance to the Semicircular Beach is given by:

Therefore, for a point to be closer to the Diametric Beach than the Semicircular Beach, the following inequality must hold:

Rearranging:

Thus, the region \(D\) of points closer to the Diametric Beach than the Semicircular Beach is:

This region is depicted below:

Now, we compute the area of this region using integration:

Since the total area of the semicircle is \(\frac{\pi}{2}\), the probability of being closer to the Diametric Beach is:

Part 2

We’ve already done most of the heavy lifting in part 1)! Define \(L\) as the random variable representing the shortest distance to a beach. At a given point \((x, y) \in C\):

• If \((x, y) \in D\), the shortest distance is \(y\).
• If \((x, y) \in D^c\), the shortest distance is \(1 - \sqrt{x^2 + y^2}\).

Breaking up the expectation integral into two parts and solving yields: