Tutorials

How I Turned a Difficult Harvard Math Problem Into an Explainer Video With Golpo AI

I pasted a difficult Harvard NIM problem into Golpo AI and asked for a tutorial. Here is the finished six-minute explainer video, the settings I chose, and an independent check against Harvard's published solution.

Sudip Kar8 min read
Harvard NIM Problem 90 flowing through Golpo AI into a hand-drawn explainer video

Can an AI video tool do more than summarize a finished explanation? Can it take a genuinely difficult problem, find the solution, and teach the reasoning clearly?

I decided to test that with Harvard Physics Problem of the Week. The page describes many of its problems as “quite difficult.” I chose Problem 90: The game of NIM, pasted only the problem into Golpo, and asked for a tutorial video with a step-by-step solution.

The result was a six-minute illustrated lesson that derived the right XOR strategy, demonstrated a winning move, and explained why the method works. Then I checked the transcript against Harvard's published four-page solution.

Animated workflow opening Harvard Problem 90, pasting it into Golpo Canvas, and showing the completed explainer video
The real workflow: open Problem 90, paste it into Golpo Canvas, and watch the finished explainer.
The finished 6:15 tutorial. Open the share page.

What I gave Golpo

I did not paste Harvard's solution into the generator. I copied the problem statement:

Determine the best strategy for each player in the following two-player game. There are three piles, each of which contains some number of coins. Players alternate turns, each turn consisting of removing any (non-zero) number of coins from a single pile. The goal is to be the person to remove the last coin(s).

The settings I chose

I asked Golpo for a tutorial video with the solution explained step by step, then chose:

  • Video engine: Golpo Canvas
  • Duration: Auto
  • Custom Style: Golpo Canvas RSA Animate
  • Display language: English

That was it: paste the problem, request a step-by-step tutorial, select Auto and the Custom Style, and generate.

How Golpo solved the problem

NIM looks simple: on each turn, remove any positive number of coins from one pile. But the best strategy is not obvious when the piles become large. Golpo introduces the missing idea: write each pile size in binary and combine the numbers with XOR.

If the three pile sizes are a, b, and c, define their nim-sum as:

S = a ⊕ b ⊕ c

  • If S = 0, the player whose turn it is is in a losing position under perfect play.
  • If S ≠ 0, the player whose turn it is has a winning move.

When S ≠ 0, choose a pile of size x for which x ⊕ S < x, and reduce that pile to:

x′ = x ⊕ S

This move makes the new total XOR equal to zero.

The video's worked example: (3, 4, 5)

Golpo computes:

3 = 011
4 = 100
5 = 101

011 ⊕ 100 ⊕ 101 = 010 = 2

The nim-sum is 2, so the position is winning. For the pile of 3:

3 ⊕ 2 = 1

Reduce the first pile from 3 coins to 1. The new position is (1, 4, 5), and:

1 ⊕ 4 ⊕ 5 = 0
Golpo tutorial frame showing the winning NIM move from 3, 4, 5 to 1, 4, 5
Golpo turns the formula into a concrete move: reduce 3 to 1 and leave the opponent a zero nim-sum.

After every move by the opponent, the winning player restores the nim-sum to zero. Repeating that strategy eventually lets the winning player remove the last coin or coins, leaving the opponent with (0, 0, 0) and no legal move.

Does that match Harvard's solution?

Yes. The terminology is different, but the theorem is the same.

Harvard's solution calls a losing position an E-triplet: after the three pile sizes are written in binary, every binary column contains an even number of 1s. XOR is a compact way to test that exact condition. A column has an even number of 1s precisely when its XOR bit is zero, so:

Harvard E-triplet ⇔ nim-sum is zero

Harvard lists losing positions including (1, 2, 3), (1, 4, 5), (2, 4, 6), and (3, 5, 6). Check the first one:

1 ⊕ 2 ⊕ 3
= 001 ⊕ 010 ⊕ 011
= 000

The Harvard proof and the Golpo explanation also use the same two-part structure:

  1. Any legal move away from a zero nim-sum makes it nonzero.
  2. From any nonzero nim-sum, there is a legal move that restores zero.

I also gave ChatGPT the Golpo transcript and Harvard's solution and asked it to compare them. Its conclusion was that Golpo's rule, example, winning-move algorithm, and proof were mathematically correct and matched Harvard's solution.

One wording detail the review caught

The review flagged one sentence in the narration as misleading: it briefly says that the losing player is forced to take the final coin setup. The mathematics before and after that line is correct, and the video later correctly says that the winning player takes the last coin. The precise version is:

By repeatedly restoring the nim-sum to zero, the winning player eventually removes the last coin or coins, leaving the opponent with no legal move.

That is a useful reminder for any AI-generated lesson: verify the reasoning, and also check the precision of the narration. Here, the independent comparison found the mathematical solution to be sound and isolated one sentence that could be stated more carefully.

What impressed me most

Golpo did not simply announce “use XOR.” It built the explanation in layers:

  • It started with tiny winning and losing positions.
  • It introduced binary numbers and XOR in plain language.
  • It converted the theorem into a repeatable algorithm.
  • It worked through (3, 4, 5) step by step.
  • It explained why every move from XOR zero breaks the balance.
  • It explained why every nonzero XOR has a legal move back to zero.
Golpo tutorial frame explaining XOR as an odd or even count of binary ones
Concept: XOR tracks whether each binary column contains an odd or even number of 1s.
Golpo tutorial summary showing XOR zero as losing and nonzero as winning
Takeaway: XOR zero is losing; nonzero is winning when both players play perfectly.

The hard part of teaching is often not getting the final answer. It is choosing the sequence that helps someone else understand it. In this test, one pasted problem became a structured visual lesson without my writing the script, laying out the equations, recording narration, or animating the explanation by hand.

A practical workflow for difficult material

This example suggests a simple workflow for teachers, students, trainers, and subject-matter experts:

  1. Start with the source problem. Paste the exact question or upload the relevant material.
  2. Ask for the teaching format you want. In this case: a tutorial with a step-by-step solution.
  3. Choose a style suited to reasoning. The RSA Animate-inspired sketch treatment gave equations and transitions room to breathe.
  4. Let Auto duration fit the explanation. Golpo used the time needed for the concept, example, algorithm, and proof.
  5. Verify against an authoritative source. Compare the finished transcript with the official solution, a textbook, a paper, or a qualified reviewer.
  6. Fix any imprecise wording. Mathematical correctness and clear narration are related, but they are not identical checks.

This does not remove the need for verification. It removes much of the production work between a difficult source and a video that people can actually watch and follow.

Open Golpo and turn your own difficult problem into a video →

Tags

#Golpo AI#Math Tutorial#NIM