Perfectly centered break of a perfectly aligned pool ball rack

Question

This question is asked on Physics SE and MathOverflow by somebody else. I don't think it belongs there, but rather here (for reasons given there in my comments there; edit: now self-removed).

Imagine the beginning of a game of pool, you have 16 balls, 15 of them in a triangle <| and 1 of them being the cue ball off to the left of that triangle. Imagine that the rack (the 15 balls in a triangle) has every ball equally spaced apart and all balls touching all other appropriate balls. All balls are perfectly round. Now, imagine that the cue ball was hit along a friction free surface on the center axis for this triangle O-------<| and hits the far left ball of the rack dead center on this axis. How would the rack react? I would imagine this would be an extension of newtons cradle and only the 5 balls on the far end would move at all. But in what way would they move? Thanks

Answer 1

This is it.  The perfectly centered billiards break.  Behold.

Setup

This break was computed in Mathematica using a numerical differential equations model. Here are a few details of the model:

• All balls are assumed to be perfectly elastic and almost perfectly rigid.
• Each ball has a mass of 1 unit and a radius of 1 unit.
• The cue ball has a initial speed of 10 units/sec.
• The force between two balls is given by the formula $$ F \;=\; \begin{cases}0 & \text{if }d \geq 2, \\ 10^{11}(2-d)^{3/2} & \text{if }d<2,\end{cases} $$ where $d$ is the distance between the centers of the balls. Note that the balls overlap if and only if $d < 2$. The power of $3/2$ was suggested by Yoav Kallus on Math Overflow, because it follows Hertz's theory of non-adhesive elastic contact.

The initial speed of the cue ball is immaterial -- slowing down the cue ball is the same as slowing down time. The force constant $10^{11}$ has no real effect as long as it's large enough, although it does change the speed at which the initial collision takes place.

The Collision

For this model, the entire collision takes place in the first 0.2 milliseconds, and none of the balls overlap by more than 0.025% of their radius during the collision. (These figures are model dependent -- real billiard balls may collide faster or slower than this.)

The following animation shows the forces between the balls during the collision, with the force proportional to the area of each yellow circle. Note that the balls themselves hardly move at all during the collision, although they do accelerate quite a bit.

The Trajectories

The following picture shows the trajectories of the billiard balls after the collision.

After the collision, some of the balls are travelling considerably faster than others. The following table shows the magnitude and direction of the velocity of each ball, where $0^\circ$ indicates straight up.

$$ \begin{array}{|c|c|c|c|c|c|c|c|c|c|c|} \hline \text{ball} & \text{cue} & 1 & 2,3 & 4,6 & 5 & 7,10 & 8,9 & 11,15 & 12,14 & 13 \\ \hline \text{angle} & 0^\circ & 0^\circ & 40.1^\circ & 43.9^\circ & 0^\circ & 82.1^\circ & 161.8^\circ & 150^\circ & 178.2^\circ & 180^\circ \\ \hline \text{speed} & 1.79 & 1.20 & 1.57 & 1.42 & 0.12 & 1.31 & 0.25 & 5.60 & 2.57 & 2.63 \\ \hline \end{array} $$

For comparison, remember that the initial speed of the cue ball was 10 units/sec. Thus, balls 11 and 15 (the back corner balls) shoot out at more than half the speed of the original cue ball, whereas ball 5 slowly rolls upwards at less than 2% of the speed of the original cue ball.

By the way, if you add up the sum of the squares of the speeds of the balls, you get 100, since kinetic energy is conserved.

Linear and Quadratic Responses

The results of this model are dependent on the power of $3/2$ in the force law -- other force laws give other breaks. For example, we could try making the force a linear function of the overlap distance (in analogy with springs and Hooke's law), or we could try making the force proportional to the square of the overlap distance. The results are noticeably different

Stiff Response

Glenn the Udderboat points out that "stiff" balls might be best approximated by a force response involving a higher power of the distance (although this isn't the usual definition of "stiffness"). Unfortunately, the calculation time in Mathematica becomes longer when the power is increased, presumably because it needs to use a smaller time step to be sufficiently accurate.

Here is a simulation involving a reasonably "stiff" force law $$ F \;=\; \begin{cases}0 & \text{if }d \geq 2, \\ 10^{54}(2-d)^{10} & \text{if }d<2.\end{cases} $$

As you can see, the result is very similar to my first answer below. This seems like good evidence that the behavior discussed in my first answer is indeed the limiting behavior in the case where the stiffness goes to infinity.

As you might expect, most of the energy in this case is transferred very quickly at the beginning of the collision. Almost all of the energy has moves to the back corner balls in the first 0.02 milliseconds. Here is an animation of the forces:

After that, the corner balls and the cue ball shoot out, and the remaining balls continue to collide gently for the next millisecond or so.

While the simplicity of this behavior is appealing, I would guess that "real" billard balls do not have such a stiff force response. Of the models listed here, the intial Hertz-based model is probably the most accurate. Qualitatively, it certainly seems the closest to an "actual" break.

Note: I have now posted the Mathematica code on my web page.

Answer 2

Note: I'm not deleting this answer since the discussion in the comments is interesting, but I no longer believe that this answer is physically realistic. See my other answer for a much better model.

Later Note: Well, it turns out that this model is realistic if you put certain hypothesis on the bouncing of the balls! See the "stiff response" section in my other answer.

The two balls in the back corners shoot away along rays parallel to the two sides of the triangle. Here is a picture showing the forces, with each force vector emanating from the point of contact.

Answer 3

Someone (Corey Deuel) has done this experimentally :), please see https://youtu.be/k6oNbNzoxc4

Edit: Another even better experiment (15ball break) by Chinese pro Zhang Kunpeng in 2016 https://www.bilibili.com/video/BV17bg7zXEZc

I asked GPT to write a python code to simulate the break using Hertz model. It works quite well. Since Professor Belk's code is not available anymore I'll post mine here. You can change ball0(cue ball)'s initial condition like position and velocity to see different break patterns. I also defined a few initial setups like 2 balls in a row, 3 balls, 9-ball and 10-ball rack. I also changed the stiffness constant to $10^7$ instead of $10^{11}$ since it is the experimental data by Marlow. Please see Dr.Dave's article for reference https://drdavepoolinfo.com/technical_proofs/new/TP_B-29.pdf

Below is the code:

            import numpy as np
            from scipy.integrate import solve_ivp
            import matplotlib.pyplot as plt
            from matplotlib.animation import FuncAnimation

        
            #  ---------- Constants ----------
        RADIUS = 0.0572 / 2  # meters (standard pool ball)
        MASS = 0.169     # kg
        KN = 7.266 * 1e7           # Hertz contact stiffness
        N_BALLS = 15  # 1 cue + 3 object balls
            # ---------- Initial Conditions ----------
        def initial_setup():
            # Triangle arrangement
            dy = RADIUS
            dx = RADIUS * np.sqrt(3)
            positions = np.zeros((N_BALLS+1, 2))
        
            if N_BALLS == 1:
                positions[1] = [0.5, 0]
        
            if N_BALLS == 2:  # 3-body config
                positions[1] = [0.5, 0]
                positions[2] = [0.5 + 2 * RADIUS, 0]
        
            if N_BALLS == 3:  # 3-ball triangle
                positions[1] = [0.5, 0]
        
                positions[2] = [0.5 + dx, dy]
                positions[3] = [0.5 + dx, -dy]
        
            if N_BALLS == 4:  # 4-ball rhombus
                positions[1] = [0.5, 0]
        
                positions[2] = [0.5 + dx, dy]
                positions[3] = [0.5 + dx, -dy]
        
                positions[4] = [0.5 + 2*dx, 0]
        
            if N_BALLS == 9:  # 9-ball rack
                positions[1] = [0.5, 0]
        
                positions[2] = [0.5 + dx,  dy]
                positions[3] = [0.5 + dx, -dy]
        
                positions[4] = [0.5 + 2 * dx, 2 * dy]
                positions[5] = [0.5 + 2 * dx, 0]
                positions[6] = [0.5 + 2 * dx, -2 * dy]
        
                positions[7] = [0.5 + 3 * dx,  dy]
                positions[8] = [0.5 + 3 * dx,  -dy]
        
                positions[9] = [0.5 + 4 * dx, 0]
        
            if N_BALLS == 10:  # 10-ball rack
                positions[1] = [0.5, 0]
        
                positions[2] = [0.5 + dx,  dy]
                positions[3] = [0.5 + dx, -dy]
        
                positions[4] = [0.5 + 2 * dx, 2 * dy]
                positions[5] = [0.5 + 2 * dx, 0]
                positions[6] = [0.5 + 2 * dx, -2 * dy]
        
                positions[7] = [0.5 + 3 * dx,  3 * dy]
                positions[8] = [0.5 + 3 * dx,  dy]
                positions[9] = [0.5 + 3 * dx, -dy]
                positions[10] = [0.5 + 3*dx, -3 * dy]
        
            if N_BALLS == 15:  # 15-ball triangle
                positions[1] = [0.5, 0]
        
                positions[2] = [0.5 + dx,  dy]
                positions[3] = [0.5 + dx, -dy]
        
                positions[4] = [0.5 + 2 * dx, 2 * dy]
                positions[5] = [0.5 + 2 * dx, 0]
                positions[6] = [0.5 + 2 * dx, -2 * dy]
        
                positions[7] = [0.5 + 3 * dx, 3 * dy]
                positions[8] = [0.5 + 3 * dx,  dy]
                positions[9] = [0.5 + 3 * dx, -dy]
                positions[10] = [0.5 + 3*dx, -3 * dy]
        
                positions[11] = [0.5 + 4 * dx, 4 * dy]
                positions[12] = [0.5 + 4 * dx, 2 * dy]
                positions[13] = [0.5 + 4 * dx, 0]
                positions[14] = [0.5 + 4 * dx, -2 * dy]
                positions[15] = [0.5 + 4 * dx, -4 * dy]
        
        
        
            # Cue ball starts further back
            positions[0] = [0.4, 0.00]
        
            # Cue ball velocity toward the triangle
            velocities = np.zeros_like(positions)
            velocities[0] = [9, 0]  # m/s
        
            return positions, velocities
        
        # ---------- Hertzian Force Function ----------
        def hertz_force(r_i, r_j):
            rij = r_j - r_i
            dist = np.linalg.norm(rij)
            delta = 2 * RADIUS - dist
            if delta > 0:
                n_hat = rij / dist
                return KN * delta**1.5 * n_hat
            else:
                return np.zeros(2)
        
        # ---------- ODE System ----------
        def system(t, y):
            positions = y[:2*(N_BALLS+1)].reshape(((N_BALLS+1), 2))
            velocities = y[2*(N_BALLS+1):].reshape(((N_BALLS+1), 2))
            accelerations = np.zeros_like(velocities)
        
            for i in range((N_BALLS+1) + 1):
                for j in range(i + 1, (N_BALLS+1)):
                    F = hertz_force(positions[i], positions[j])
                    accelerations[i] -= F / MASS
                    accelerations[j] += F / MASS
        
            dydt = np.zeros_like(y)
            dydt[:2*(N_BALLS+1)] = velocities.flatten()
            dydt[2*(N_BALLS+1):] = accelerations.flatten()
            return dydt
        
        # ---------- Run Simulation ----------
        def run_sim():
            pos, vel = initial_setup()
            y0 = np.concatenate([pos.flatten(), vel.flatten()])
            t_span = (0, 0.1)
            sol = solve_ivp(system, t_span, y0, method='RK45', max_step=1e-4)
        
            return sol
        
        # ---------- Optional Plot (Static Final Positions) ----------
        def plot_result(sol):
            positions = sol.y[:2*(N_BALLS+1), -1].reshape(((N_BALLS+1), 2))
            colors = ['r', 'b', 'g', 'k']
            for i in range((N_BALLS+1)):
                plt.plot(positions[i, 0], positions[i, 1], 'o', label=f'Ball {i}', color=colors[i])
            plt.title("Final Ball Positions")
            plt.gca().set_aspect('equal')
            plt.grid(True)
            plt.legend()
            plt.show()
        
        
        
        
        def animate_trajectories(sol):
            positions_over_time = sol.y[:2 * (N_BALLS+1)].T.reshape(-1, (N_BALLS+1), 2)  # shape (T, N, 2)
        
            fig, ax = plt.subplots()
            ax.set_aspect('equal')
            ax.set_xlim(-0.05, 1.5)
            ax.set_ylim(-0.5, 0.5)
            ax.set_title("Billiard Break Shot Trajectories")
        
            # Plot object for each ball
            colors = ['white','yellow', 'yellow', 'blue', 'red', 'purple', 'orange', 'green', 'maroon', 'black',
                      'yellow', 'blue', 'red', 'purple', 'orange', 'green']
        
            ball_dots = [plt.plot([], [], 'o', markersize=12.5)[0] for _ in range((N_BALLS+1))]
            trails = [ax.plot([], [], '-', lw=1)[0] for _ in range((N_BALLS+1))]
            history_x = [[] for _ in range((N_BALLS+1))]
            history_y = [[] for _ in range((N_BALLS+1))]
        
            def update(frame):
                for i in range((N_BALLS+1)):
                    x, y = positions_over_time[frame, i]
                    ball_dots[i].set_data([x], [y])
                    history_x[i].append(x)
                    history_y[i].append(y)
                    trails[i].set_data(history_x[i], history_y[i])
                return ball_dots + trails
        
            ani = FuncAnimation(fig, update, frames=len(sol.t), interval=10, blit=False)
            # ani.save("billiard_simulation.mp4", fps=60, dpi=200, writer="ffmpeg")
            plt.show()
        
        
        if __name__ == "__main__":
            sol = run_sim()
            animate_trajectories(sol)