While watching one of Zack D. Films’ videos on the double domino effect, I became curious about how far apart dominoes could be placed while still allowing the chain to continue.

After experimenting with this in Algodoo, I noticed something surprising.

A spacing of 14.5 cm was too small for the double domino effect to occur, yet increasing it slightly to 15.0 cm allowed the entire sequence to continue.

At first glance, this seems counterintuitive. Since both values are below the maximum possible spacing, the domino effect occurs in each case. Why, then, does such a small change determine whether the double domino effect takes place?

This led me to investigate the mathematics behind the domino effect.

The problem

Consider a row of identical rectangular bricks, each of height $h$ and width $w$, standing upright and equally spaced.

If one brick is pushed, it falls and hits the next, creating a domino effect.

But this raises the question:

how far apart can the bricks be while still allowing the chain to continue, and under what conditions does the double domino effect occur?

The Geometry of a Falling Brick

Focus on a single brick rotating about its bottom corner.

As it falls through an angle $\theta$ from the vertical, the top corner moves both downward and horizontally.

The horizontal position of the top corner relative to the pivot is

$x = h \sin\theta + w \cos\theta$

The next brick begins at a horizontal distance of $w + d$, where $d$ is the gap between bricks.

For the falling brick to just touch the next one, these must be equal:

$h \sin\theta + w \cos\theta = w + d$

Rearranging gives

$d = h \sin\theta + w(\cos\theta - 1)$

This equation describes how the gap $d$ depends on the angle $\theta$ at which contact occurs.

The Maximum Possible Gap

To find the largest possible spacing, we maximise

$d(\theta) = h \sin\theta + w(\cos\theta - 1)$

Differentiating:

$\frac{dd}{d\theta} = h \cos\theta - w \sin\theta$

Setting this equal to zero:

$h \cos\theta = w \sin\theta$

so

$\tan\theta = \frac{h}{w}$

Substituting this back into the expression for $d$ leads to

$d_{\max} = \sqrt{h^2 + w^2} - w$

This is the maximum spacing for which the falling brick can still reach the next one.

A Numerical Example

In the UK, the standard dimensions for a brick are height $h = 21.5$ cm and width $w = 6.5$ cm:

$d_{\max} = \sqrt{21.5^2 + 6.5^2} - 6.5$

$= \sqrt{504.5} - 6.5$

$\approx 22.46 - 6.5 = 15.96 \text{ cm}$

So the bricks cannot be spaced more than approximately $15.96$ cm apart.

Why the Maximum Is Not the Best

Although $d_{\max}$ tells us the largest possible gap, it does not tell us the best gap.

If the spacing is too close, the first brick hits the next one very early in its fall. At this point, it has not yet gained much speed, so the impact is weak.

If the spacing is larger, the brick falls further before making contact. As it falls, gravitational potential energy is converted into rotational kinetic energy, so its angular speed increases.

This means that later collisions are more forceful.

So placing the bricks closer to the maximum possible spacing allows the falling brick to build up more speed before impact, which is necessary for the double domino effect to occur.

This also explains why a spacing of $15.0$ cm worked more reliably than $15.96$ cm. The value $15.96$ cm represents the theoretical maximum, where the falling brick only just reaches the next one. At this point, even a slight deviation in spacing or alignment prevents contact, and the impact is extremely weak. Reducing the spacing slightly ensures a more reliable collision with sufficient force.

Online simulation

The main reason I wanted to find the maximum possible distance was to test the double domino effect. In this scenario, the bricks must be placed very close to the maximum possible spacing so that each brick is only marginally supported by the next. When the final brick falls, this support is lost, triggering the collapse of the entire chain.

To test this, I simulated the system in Algodoo.

At a spacing of $15.0$ cm, the chain successfully continues:

At larger spacing, the brick falls further before impact, producing a stronger collision.

What I find interesting is that the distances between the bricks had to be very precise for the double domino effect to take place. For example, 15.0 cm distance works pretty well, but 14.7 cm was too small for there to be enough space for the bricks to fall cleanly.

Even though the simulation looks rather simple, the precision required for success took a while to fully accomplish. If you are interested in this Algodoo scene I used for this simulation, feel free to email me (more information on the About page).

Conclusion

The domino effect is not just a visual curiosity, but a combination of geometry and mechanics.

The maximum spacing

$d_{\max} = \sqrt{h^2 + w^2} - w$

comes from considering how far a rotating brick can reach.

However, the success of the chain depends not only on whether the bricks touch, but on how much energy is transferred during the collision.

This explains why the “best” spacing is often close to, but not exactly equal to, the theoretical maximum.

$ax^2 + bx + c = 0$

We are often told that the expression $b^2 - 4ac$ — known as the discriminant — determines how many real roots the equation has.

But why does this happen?

The Key Observation

Using the quadratic formula:

$x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$

we see that everything depends on the square root term

$\sqrt{b^2 - 4ac}$

The nature of this square root determines the number of real solutions.

Case 1: $b^2 - 4ac > 0$

If the discriminant is positive, then $\sqrt{b^2 - 4ac}$ is a real, non-zero number.

This means the $\pm$ sign gives two different values, so the quadratic has two distinct real roots.

Case 2: $b^2 - 4ac = 0$

If the discriminant is zero, then

$\sqrt{b^2 - 4ac} = 0$

So the formula becomes

$x = \frac{-b}{2a}$

Both values collapse into one, so the quadratic has one repeated real root.

Case 3: $b^2 - 4ac < 0$

If the discriminant is negative, then $\sqrt{b^2 - 4ac}$ is not a real number.

So the quadratic has no real roots.

A Graphical Interpretation

Now consider the graph

$y = ax^2 + bx + c$

The roots of the quadratic are exactly the points where the graph meets the $x$-axis.

• If $b^2 - 4ac > 0$, the graph crosses the $x$-axis twice.
• If $b^2 - 4ac = 0$, the graph just touches the $x$-axis once.
• If $b^2 - 4ac < 0$, the graph does not meet the $x$-axis at all.

So the discriminant determines how many times the graph intersects the $x$-axis, which is why it determines how many real roots there are.

Conclusion

The discriminant is not just a number to calculate mechanically. It controls the square root term in the quadratic formula, and that in turn determines whether the equation has two, one, or no real roots.

• You choose 1 of 3 doors
• Behind 1 is a car
• Behind the other 2 are goats
• Your aim is to open the door with the car
• The host knows what door has what
• After you choose, the host opens a door with a goat from one of the 2 doors you did not choose
• Now you have the option to switch to the other unopened door
• Should you switch?

At first, it looks 50/50 because there are only 2 choices, but the chances of the door you did not pick having a car is 2/3. Here is why.

When the host opens a goat door from those two, that 2/3 probability does not disappear - it concentrates on the one remaining unopened door.

So:

• Probability your original choice was right: 1/3
• Probability the other unopened door is right: 2/3

That is why switching is better.

This took me a bit to properly understand, but a useful way to see this is to imagine 100 doors instead of 3. You pick 1 door, and the host opens 98 goat doors. It becomes much easier to see that your first choice is probably wrong, and that the one remaining unopened door is much more likely to contain the prize.

If you want to try this specific 100 door scenario for yourself, here is some Python code I made. After you play it a few times, you will start noticing how it is definitely not 50/50, and switching nearly always gives you a car.

import random

def play_game():
    doors = list(range(1, 101))
    car = random.choice(doors)

    # Player picks a door
    while True:
        try:
            first_pick = int(input("Pick a door (1-100): "))
            if 1 <= first_pick <= 100:
                break
            else:
                print("Enter a number between 1 and 100.")
        except:
            print("Invalid input, try again.")

    print(f"\nYou picked door {first_pick}")

    # Determine the other unopened door
    if first_pick == car:
        # Picked correctly, then leave one random goat
        other_options = [d for d in doors if d != first_pick and d != car]
        other_door = random.choice(other_options)
    else:
        # Picked wrong -> other door must be the car
        other_door = car

    print("Host opens 98 doors... all goats")
    print(f"Remaining doors: {first_pick} and {other_door}")

    # Switch decision
    while True:
        switch = input("Do you want to switch? (yes/no): ").lower()
        if switch in ["yes", "no"]:
            break
        print("Type 'yes' or 'no'.")

    final_pick = other_door if switch == "yes" else first_pick

    # Result
    if final_pick == car:
        print("You got the CAR!")
    else:
        print("You got a goat.")

    print(f"(Car was behind door {car})")


# Game loop
while True:
    play_game()
    again = input("\nPlay again? (yes/no): ").lower()
    if again != "yes":
        break

What makes this problem interesting is not just the answer, but the fact that intuition pushes so strongly in the wrong direction. It is a good example of how mathematical reasoning can correct instinctive thinking.