Tutorials

How to Turn Difficult Problems Into Verified Explainer Videos With the Golpo API

I used a coding assistant and the Golpo API to turn five difficult Harvard problems into checked, illustrated explainer videos—while catching two incorrect first drafts before rendering.

Sudip Kar43 min read
Five difficult Harvard problems moving through code and verification into five Golpo explainer videos

The useful automation is not “send 90 PDFs to a video generator and hope.” It is a controlled loop: collect one problem, draft one script, check it, correct it when necessary, and only then render the explainer video.

I tested that loop on five consecutive entries from Harvard's Problem of the Week: Problems 89 through 85. The index contains 90 weekly math and physics problems posted from 2002 to 2004, so it is a useful model for a much larger collection. Golpo's first drafts got three of the five right or nearly right. The verification gate caught material errors in the other two before any final video was made. The result is a practical pipeline you can run from VS Code with Codex, Claude Code, Copilot, Cursor, or another capable coding assistant.

Five-problem result: 5 source problems → 5 Auto drafts → 5 source checks → 2 corrected scripts → 5 finished explainer videos.
The real batch workflow: collect, draft, verify, correct, and render. Open the animated GIF.

Watch the complete Golpo API workflow

This walkthrough shows the entire script-first process in sequence: collect the source problems, ask Golpo for an Auto script without rendering, verify the mathematics, correct any weak drafts, resume the same generation with the approved script, and inspect the finished videos.

The full step-by-step workflow, including the exact prompt, script-only API request, review gate, approved-script continuation, and finished outputs. Watch on YouTube.

Choose your interface: Skill, MCP, or API

The workflow does not depend on one editor. Use the surface that fits your setup:

  • Golpo Skill: tell your coding assistant what video to make; the skill handles submission, status checks, and the final file.
  • Golpo MCP: let an MCP-capable assistant call Golpo as a tool inside a larger research or content workflow.
  • Golpo API: use direct requests when you want explicit payloads, batch control, logs, and integration with your own application.

The most important design decision is identical in all three: request the script first and keep final rendering behind an approval gate.

Step 0: discover and download the problem–solution pairs

The Harvard index links each numbered problem to a PDF and, where available, its published solution. A small Python collector can discover those pairs instead of hard-coding 90 URLs:

from pathlib import Path
import requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin

INDEX = "https://www.physics.harvard.edu/undergrad/problems"
OUT = Path("harvard-problems")
OUT.mkdir(exist_ok=True)

index_response = requests.get(INDEX, timeout=30)
index_response.raise_for_status()
soup = BeautifulSoup(index_response.text, "html.parser")

for link in soup.select('a[href$=".pdf"]'):
    url = urljoin(INDEX, link["href"])
    name = url.rsplit("/", 1)[-1]
    if name.startswith(("prob", "sol")):
        response = requests.get(url, timeout=60)
        response.raise_for_status()
        if not response.content.startswith(b"%PDF"):
            raise ValueError(f"Unexpected response for {url}")
        (OUT / name).write_bytes(response.content)

Respect the source site's access controls and rate limits. If an automated request is denied, do not try to evade it; open the source in your browser or use another access method the publisher authorizes. Keep each problem beside its matching solution and preserve the source URL for attribution.

Step 1: open your favorite IDE and give the assistant the complete job

VS Code plus Codex is one option; Claude Code, Copilot, Cursor, and other assistants can follow the same plan. The prompt should define the quality gate as clearly as the generation step:

Find each problem PDF and its matching published solution. For one problem at a time, ask Golpo for an Auto-length tutorial script only. Compare every derivation and final answer with the published solution. If the draft is wrong or unclear, revise it while preserving a teachable step-by-step structure. Only after the script passes review, send the approved script to Golpo Canvas and save the completed MP4. Never render an unchecked draft.

IDE-style code card showing a Codex prompt for collecting, drafting, verifying, correcting, and rendering five problem videos
A prompt you can adapt in VS Code, Cursor, or another assistant-enabled IDE.

Step 2: iterate one problem at a time

A bounded queue is safer than launching everything at once. Keep a record for each item: problem number, source URL, solution URL, draft job, review verdict, approved script, video job, and final file. Limit the number of simultaneous jobs to the concurrency allowed by your account.

for problem in problems:
    draft = generate_auto_script(problem)
    review = verify_against_source(draft, problem.solution)
    approved = revise_if_needed(draft, review)
    assert review_script(approved, problem.solution).passed
    video = render_with_golpo(approved)
    save_manifest(problem, review, video)

That second assertion matters. If a draft required correction, run the corrected version through the check again before rendering.

Step 3: ask Golpo for the Auto script—without rendering yet

Include the complete problem statement. A short title such as “rope between inclines” is not enough context and can produce a polished answer to a different problem. You do not need to write Python first: Codex, Cursor, Claude Code, or another tool-using assistant can run the script-only stage for you.

Prompt to paste into Codex or Cursor

Use my connected Golpo Skill, Golpo MCP server, or Golpo API. For the problem below, generate an Auto-length step-by-step tutorial script only. Do not render a video yet. Send the complete problem statement to Golpo, set just_return_script to true, poll until the script is ready, and return three things to me: the Golpo job ID, the Golpo video ID, and the full generated script. Save both IDs because we will resume this same generation after checking the mathematics. Problem: [PASTE THE COMPLETE PROBLEM STATEMENT]

Your assistant should submit the job, wait for the script, print the identifiers, and stop. At that point there should be no MP4 because the visual rendering stage has deliberately not started.

How the credits are split: the script-only stage uses 10% of the job's total credits. After review, resuming that same generation with the updated script uses the remaining 90%. Together they equal the normal full-job credit cost; the review pause is not an extra complete video charge.

What the API is doing underneath

The direct API version starts with this request:

import requests

payload = {
    "prompt": full_problem_and_tutorial_instructions,
    "timing": "auto",
    "video_type": "long",
    "language": "en",
    "just_return_script": True
}

response = requests.post(
    "https://api.golpoai.com/api/v1/videos/generate",
    headers={"x-api-key": GOLPO_API_KEY},
    json=payload,
    timeout=120
)
response.raise_for_status()
created = response.json()

job_id = created["job_id"]
video_id = created["video_id"]

The identifiers have different purposes: job_id polls the current processing step, while video_id identifies the generation record you resume after approving or editing the script.

Poll until the response contains script_text or reports script_ready:

import time

while True:
    status_response = requests.get(
        f"https://api.golpoai.com/api/v1/videos/status/{job_id}",
        headers={"x-api-key": GOLPO_API_KEY},
        timeout=120
    )
    status_response.raise_for_status()
    status = status_response.json()

    if status.get("script_text"):
        draft_script = status["script_text"]
        break
    if status.get("status") in {"failed", "error", "cancelled"}:
        raise RuntimeError(status)

    time.sleep(10)

print("JOB_ID=", job_id)
print("VIDEO_ID=", video_id)
print(draft_script)

Save the draft and both identifiers together. If you process many problems, keep one manifest row per problem so the approved script can never be resumed against the wrong video ID.

Step 4: verify the derivation, not just the final number

For these five examples, Harvard's published solutions provided the source of truth. I asked the reviewer to identify the first step where the draft diverged, check units and limiting cases, and propose the smallest accurate repair.

Copyable review prompt: Compare the candidate tutorial with the attached published solution. Check every definition, force balance, recurrence, algebraic step, approximation, and final answer. Do not assume the candidate is correct because it sounds confident. Return PASS, PASS WITH WORDING EDITS, or FAIL. For a failure, identify the first incorrect step and write a corrected, teachable replacement script. Do not introduce claims that are absent from the problem or source.

If no authoritative solution exists, use an independent derivation from a strong reasoning model, add numerical checks or limiting cases, and ask a qualified human to review high-stakes material. A second model is useful evidence; it is not an oracle.

What the five-script audit found

ProblemAuto draftReview action
89 · Rope between inclinesFailedReplaced a reversed force balance; the published solution gives 3 − 2√2 at 22.5°.
88 · Ladder envelopePassedMatched the published astroid derivation: x2/3 + y2/3 = L2/3.
87 · Leaving the hemispherePassedMatched the published result; refined the wording for m = M, θ ≈ 42.9°.
86 · Shifted intervalsPassedMatched the published result; clarified spoken grouping in √(π/(2N)).
85 · Tower of cylindersFailedReplaced an invented recurrence; the published matrix solution gives (√2 − 1)a.

This is exactly why script-first generation is valuable: two confident-looking drafts were wrong, but correcting text is cheap. Rendering, reviewing, and replacing two finished videos would be slower and more expensive.

Step 5: send only the approved script to Golpo

Once a script passes, resume the same generation record. In casual conversation this may be called “sending the updated script to the same job,” but the API field used for the continuation request is the video ID returned by the script-only call. The job ID remains the identifier used for polling.

Continuation prompt for Codex or Cursor

The Golpo script for this problem has now been checked. Resume the same Golpo generation using video ID [PASTE VIDEO_ID]. Send the approved script below as new_script, turn off script-only mode, and create a Golpo Canvas video with Auto duration, marker illustrations, a stylus drawing animation, large equations, and consistent labels. Poll the returned render job ID until the MP4 is ready, then return the hosted URL and downloaded file. Approved script: [PASTE APPROVED SCRIPT]

The direct continuation request includes the saved video_id and the approved script:

payload = {
    "prompt": f"Harvard Problem {number}: {title}",
    "video_id": video_id,
    "new_script": approved_script,
    "timing": "auto",
    "video_type": "long",
    "language": "en",
    "style": "solo-male-3",
    "use_2_0_style": True,
    "image_style": "marker",
    "pen_style": "stylus",
    "video_instructions": (
        "Use clear diagrams and large, correctly typeset equations. "
        "Build the derivation visually, one step at a time."
    )
}

response = requests.post(
    "https://api.golpoai.com/api/v1/videos/generate",
    headers={"x-api-key": GOLPO_API_KEY},
    json=payload,
    timeout=120
)
response.raise_for_status()
render_job_id = response.json()["job_id"]

This continuation uses the remaining 90% of the credits for that generation. Poll render_job_id until a video_url appears. Because the saved video_id was resumed, the 10% script stage and 90% render stage together make one complete Golpo job.

The five finished explainer videos

Each video below was rendered from the reviewed script—not the unchecked first draft.

89 · Rope between inclines

5:01 · Corrected before rendering

Problem statement

A uniform rope rests symmetrically on two platforms, each inclined at an angle θ. The coefficient of friction is 1. What is the largest fraction of the rope that can hang without touching either platform, and which θ produces that maximum?

Open Harvard Problem 89

Read Golpo's approved solution transcript
Two identical platforms rise away from a central gap, each at an angle theta above the horizontal. A uniform rope rests symmetrically on the platforms, while a fraction of it hangs freely between them. The coefficient of static friction is one. We want the largest possible hanging fraction and the angle that makes it possible.

Let the rope's total mass be m, and let f be the fraction of the rope that hangs in the air. Then the hanging part has mass f m. The supported part has mass (1 minus f) m, split equally between the two platforms.

Because the setup is symmetric, analyze only the right half. Half of the hanging rope has weight f m g over 2. At the point where the rope leaves the platform, the tension T points along the platform. The vertical component of that tension, T sine theta, supports the weight of the right half of the hanging rope. Therefore,

T sine theta equals f m g over 2,

so

T equals f m g divided by 2 sine theta.

Now isolate the part of the rope that touches the right platform. Its mass is (1 minus f) m over 2. Gravity pulls this supported part down the slope with force

(1 minus f) m g sine theta over 2.

The hanging section also pulls it down the slope with tension T. Static friction must oppose both of these forces. The normal force is

N equals (1 minus f) m g cosine theta over 2.

Since the coefficient of friction is one, the largest available static friction is simply N. To maximize the hanging fraction, the rope must be exactly at the threshold of slipping, so the friction force has its maximum value. The force balance along the slope is therefore

(1 minus f) m g cosine theta over 2

equals

(1 minus f) m g sine theta over 2 plus T.

Substitute the tension from the hanging-rope balance:

(1 minus f) cosine theta

equals

(1 minus f) sine theta plus f divided by sine theta.

Multiply by sine theta and collect the factors multiplying 1 minus f:

(1 minus f) times the quantity sine theta cosine theta minus sine squared theta equals f.

Define

F of theta equals sine theta cosine theta minus sine squared theta.

Then the equation becomes (1 minus f) F equals f, and solving for f gives

f equals F divided by 1 plus F.

Because this expression increases whenever F increases, maximizing the hanging fraction is equivalent to maximizing F.

Use the double-angle identities. Sine theta cosine theta is one half sine 2 theta, and sine squared theta is one half times the quantity 1 minus cosine 2 theta. Thus,

F of theta equals one half times the quantity sine 2 theta plus cosine 2 theta minus 1.

Differentiate:

F prime of theta equals cosine 2 theta minus sine 2 theta.

At the maximum, this derivative is zero, so cosine 2 theta equals sine 2 theta. In the physically relevant range, this gives

2 theta equals 45 degrees,

and therefore

theta equals 22.5 degrees, or pi over 8 radians.

At this angle, sine 2 theta and cosine 2 theta both equal one over square root of 2. Therefore,

F maximum equals the quantity square root of 2 minus 1, divided by 2.

Insert this into f equals F over 1 plus F:

f maximum equals the quantity square root of 2 minus 1 divided by square root of 2 plus 1.

Rationalizing gives the compact exact answer

f maximum equals 3 minus 2 square root of 2,

which is approximately 0.1716.

So the largest possible fraction of rope hanging in the air is about 17.2 percent, and it occurs when each platform is inclined at 22.5 degrees.

As a quick check, the answer is smaller than one half, which is reasonable: the supported rope must provide enough normal force, and therefore enough friction, to hold the central section. The optimum balances the benefits of a steeper platform against the loss of frictional support. Repeating this balance on the left gives the same equations by symmetry.
Compare with Harvard's published solution

Let f be the hanging fraction and m the total mass. On either side, the hanging half gives tension T = (f/2)mg/sinθ. At impending slip, maximum friction on the supported half balances its downslope weight plus that tension. This gives f = F/(1+F), where F = sinθ cosθ − sin²θ.

Writing F = ½(sin2θ + cos2θ − 1) shows the maximum occurs when tan2θ = 1, hence θ = 22.5°. Substitution gives fmax = 3 − 2√2 ≈ 0.172. Read Harvard's complete solution.

88 · Ladder envelope

7:14 · Auto draft approved

Problem statement

A ladder of length L slides while its lower end stays on the floor and its upper end stays on a perpendicular wall. Describe the curve that forms the envelope of all ladder positions.

Open Harvard Problem 88

Read Golpo's approved solution transcript
Imagine a classic cartoon scene: a long ladder stands perfectly straight against a tall building. Someone at the bottom gives it a kick, and it begins to slide. The top scrapes down the wall, and the bottom grinds along the ground. Our question today is not about the speed or the crash, but about the shape traced in the air. As the ladder slides through all its possible positions, from vertical to horizontal, what is the boundary of the region it sweeps out? What is the curve that the ladder seems to "hug" as it falls? This curve is what mathematicians call an envelope.

To solve this, we first need to describe the ladder mathematically. Let’s set up a coordinate system. Imagine the wall is the vertical y-axis and the ground is the horizontal x-axis. They meet at a right angle at the origin, (0, 0). The ladder has a constant length, which we'll call *L*.

At any moment, the top of the ladder is at some point (0, y) on the wall, and the bottom is at (x, 0) on the ground. These three points—the origin, (x,0), and (0,y)—form a right-angled triangle, with the ladder as the hypotenuse. From the Pythagorean theorem, we know that the relationship between x and y is fixed by the ladder's length: x squared plus y squared equals L squared. This is our fundamental constraint. It tells us the endpoints of the ladder always lie on a quarter-circle of radius *L* in the first quadrant.

The ladder itself is a straight line segment connecting its two endpoints. The equation for a line that intercepts the x-axis at *x* and the y-axis at *y* is given by a simple formula: Capital X over little x, plus Capital Y over little y, equals one. Here, (Capital X, Capital Y) represents any point along the length of the ladder.

This equation describes one position of the ladder. But as the ladder slides, *x* and *y* are constantly changing. We have a whole family of lines. To find their envelope, it's best to describe this family using a single parameter. The most natural choice is the angle the ladder makes with the ground. Let's call this angle theta (θ).

Using basic trigonometry on our right triangle, we can express the endpoints *x* and *y* in terms of the angle θ. The base of the triangle is *x*, so *x* equals *L* times the cosine of θ. The height is *y*, so *y* equals *L* times the sine of θ. As the ladder falls, θ decreases from 90 degrees (or pi/2 radians) to 0.

Now we can substitute these expressions back into our line equation. The equation for any position of the ladder becomes: Capital X divided by (L cosine θ), plus Capital Y divided by (L sine θ), equals one. This is the equation for our family of lines, all defined by the single parameter, θ.

So, how do we find the envelope? The key idea is that the envelope is a curve that is tangent to every single line in this family. At the point of tangency, the line and the envelope not only share a point but also a slope. Calculus provides a powerful method to find this. We take our equation for the family of lines and compute its partial derivative with respect to our parameter, θ, and set that derivative to zero. Solving this equation along with the original line equation will give us the coordinates of the envelope curve.

Let's do the math. Our equation is X/(L cos θ) + Y/(L sin θ) - 1 = 0. Taking the derivative with respect to θ is an application of the chain rule. The derivative of one over cosine is sine over cosine squared, and the derivative of one over sine is negative cosine over sine squared. Setting this derivative to zero and simplifying, we arrive at a beautifully symmetric relationship: X times sine cubed of θ equals Y times cosine cubed of θ.

Now we have a system of two equations: the original line equation and this new derivative equation. Our goal is to eliminate the angle θ to find a relationship purely between X and Y. From our new equation, we can see that X must be proportional to cosine cubed of θ, and Y must be proportional to sine cubed of θ. Let's write X = k cos³θ and Y = k sin³θ for some constant k.

To find k, we substitute these expressions back into our first equation, the one for the ladder line. After substitution, we get k cos²θ + k sin²θ = L. Since cos²θ + sin²θ is always one, this simplifies to k equals L.

We've found it. The points (X, Y) on the envelope are described by the parametric equations: X = L cos³θ and Y = L sin³θ.

To get the final answer, we just need to eliminate θ one last time. From our parametric equations, we can write cosine of θ as the cube root of (X/L), and sine of θ as the cube root of (Y/L). We plug these into our favorite identity, cos²θ + sin²θ = 1. This gives us: (X/L) to the power of two-thirds, plus (Y/L) to the power of two-thirds, equals one. Multiplying through, we get the final equation for the envelope: X to the two-thirds plus Y to the two-thirds equals L to the two-thirds.

This equation describes a curve called an astroid. It looks like a star with four sharp points, or cusps. Since our ladder is in the first quadrant, we only see one-quarter of this astroid, curving inwards from the wall to the ground.

Let's do a quick sanity check. If the ladder is vertical, its top is at (0, L). If we plug X=0 into our equation, we get Y=L. Perfect. If the ladder is horizontal, its bottom is at (L, 0). If we plug Y=0, we get X=L. Perfect. The curve connects the two extreme points correctly.

So, the next time you see that cartoon ladder slide, you can appreciate the hidden beauty. The boundary it carves is not a simple circle or a straight line, but a precise and elegant mathematical shape—an astroid, defined by the constant length of the ladder and the unyielding geometry of the wall and ground. From a family of simple straight lines, a beautiful curve emerges.
Compare with Harvard's published solution

The published construction intersects two neighboring ladder positions separated by dθ. Similar triangles give the envelope point parametrically as x = L cos³θ and y = L sin³θ. Eliminating θ yields the astroid x2/3 + y2/3 = L2/3. Read Harvard's complete solution.

87 · Leaving the hemisphere

13:24 · Final wording refined

Problem statement

A particle of mass m starts on top of a frictionless hemisphere of mass M, itself free to slide on a frictionless table. After a tiny push, at what angle θ from the top does the particle lose contact? Derive the general cubic and solve the special case m = M.

Open Harvard Problem 87

Read Golpo's approved solution transcript
Hello, and welcome to this deep dive into a classic physics problem with a fantastic twist. Imagine a tiny particle, like a bead, sitting on top of a perfectly smooth, giant marble. The marble itself is resting on a frictionless ice rink. You give the bead the slightest nudge, and it starts to slide down. Our mission is to figure out the exact angle where the bead flies off the marble. This is Harvard's Problem of the Week 87. Let's solve it from scratch.

First, let's establish our game plan and define our terms. We're looking for the angle where the particle loses contact. This moment is governed by the forces acting on the particle. So, we'll need to use Newton's second law, `F=ma`. But to use that, we need to know how fast the particle is moving at any given angle. That speed comes from the conservation of energy. Since all surfaces are frictionless, there are no non-conservative forces like friction doing work, so the total mechanical energy of our system is conserved. Furthermore, because the table is frictionless, there are no external horizontal forces. This means the total horizontal momentum of the system is also conserved. These three principles—Newton's Second Law, Conservation of Energy, and Conservation of Momentum—are our tool kit.

Let's define our variables.
The particle has mass `m`.
The hemisphere has mass `M` and a radius `R`.
The angle of the particle, measured from the very top of the hemisphere, is `theta`.
The speed of the particle relative to the ground is `v`, and the speed of the hemisphere relative to the ground is `V`. The hemisphere can only move horizontally.
And finally, the crucial force between them: the normal force, `N`. This is the push that the hemisphere exerts on the particle, keeping it on its surface. The particle loses contact precisely when this force drops to zero.

Our first step is to use the conservation of horizontal momentum. The system starts from rest, so the total initial horizontal momentum is zero. At any later time, the particle might be moving with some horizontal velocity, let's call it `v_x`, and the hemisphere is recoiling with velocity `V`. Since momentum must be conserved, the particle's forward momentum must exactly cancel the hemisphere's backward momentum. Let's say the particle moves to the right. The hemisphere must move to the left. The momentum conservation equation is simply: `m` times the particle's horizontal velocity must equal `M` times the hemisphere's speed. This is a vital link between the motions of our two objects.

Now, let's turn to the conservation of energy. Initially, everything is at rest. The particle is at the top of the hemisphere, at a height `R` above the table. So, the total initial energy is purely potential: `E_initial = m*g*R`, where `g` is the acceleration due to gravity.

As the particle slides down to an angle `theta`, its height decreases to `R*cos(theta)`. So its potential energy drops. This lost potential energy is converted into kinetic energy. But here's the key: it's converted into kinetic energy for *both* the particle and the hemisphere. The final energy is `E_final = (1/2)mv^2 + (1/2)MV^2 + mgRcos(theta)`.

Setting initial energy equal to final energy gives us:
`mgR = (1/2)mv^2 + (1/2)MV^2 + mgRcos(theta)`.

This equation relates the speeds to the angle, but it's complicated. It involves the particle's total speed `v` and the hemisphere's speed `V`. We can simplify this significantly by using our momentum result and thinking about the motion in a more convenient way. Instead of the particle's speed relative to the ground, `v`, let's consider its speed relative to the hemisphere's surface, which we'll call `u`. This relative speed `u` is simply `R` times the rate of change of the angle, `theta-dot`.

After a good deal of algebra, which involves relating the ground-frame velocities to this relative speed `u` and using the momentum conservation rule, the total kinetic energy of the system can be expressed in a much cleaner form. The result is that the change in potential energy, `mgR(1 - cos(theta))`, is equal to:
`(1/2)m * u^2` multiplied by a correction factor: `[1 - (m/(m+M)) * cos^2(theta)]`.

This is our complete energy conservation equation. We can rearrange it to solve for the relative speed squared, `u^2`, at any angle `theta`:
`u^2 = 2gR(1 - cos(theta)) / [1 - (m/(m+M)) * cos^2(theta)]`.
This is our first key equation. It tells us how fast the particle is sliding along the surface as a function of its position.

Now for the second piece of the puzzle: the condition for losing contact. The particle flies off when the normal force `N` becomes zero. To find `N`, we must analyze the forces and acceleration in the radial direction—that is, along the line connecting the center of the hemisphere to the particle.

This is the most subtle part of the problem. We need to apply `F=ma` to the particle. The forces in the radial direction are the normal force `N` pushing outwards, and the component of gravity pulling inwards, which is `mg*cos(theta)`. The net radial force is what provides the radial acceleration. But the particle isn't just moving in a simple circle, because the center of that circle—the hemisphere—is also accelerating.

To handle this, we can use a clever trick. Let's look at the hemisphere. What horizontal force acts on it? Only the horizontal component of the normal force that the particle exerts on it. By Newton's third law, this is equal and opposite to the force the hemisphere exerts on the particle. So, the force accelerating the hemisphere is `N*sin(theta)`. This means the hemisphere's acceleration, `a_H`, is `(N/M) * sin(theta)`.

Now, we can write the radial force equation for the particle in a non-inertial frame moving with the hemisphere. This involves adding a fictitious force, `-m*a_H`. When we do this and set the forces equal to the mass times the centripetal acceleration (`-m*u^2/R`), we get an expression for the normal force `N`.

The key insight is this: at the exact moment the particle loses contact, `N` becomes zero. If `N` is zero, then the horizontal force on the hemisphere is zero, which means the hemisphere's horizontal acceleration `a_H` is also momentarily zero.

If we plug `N=0` and `a_H=0` into our radial force equation, it simplifies dramatically. All the complex terms fall away, and we are left with a beautifully simple condition: the inward pull of gravity's radial component must be providing all the necessary centripetal acceleration.
`mg*cos(theta) = m*u^2/R`.
This gives us our second key equation for the speed at liftoff: `u^2 = gRcos(theta)`.

Now we have the endgame. We have two distinct expressions for `u^2`. One came from energy conservation, valid for the whole journey. The other comes from the force analysis, valid only at the precise moment of liftoff. To find the liftoff angle, we just set these two expressions equal to each other.

`gRcos(theta) = 2gR(1 - cos(theta)) / [1 - (m/(m+M)) * cos^2(theta)]`.

We can cancel `gR` from both sides. Let's make a substitution to simplify the algebra: let `x = cos(theta)`. Our equation becomes:
`x = 2(1 - x) / [1 - (m/(m+M)) * x^2]`.

A bit of rearrangement gives:
`x * [1 - (m/(m+M)) * x^2] = 2 - 2x`.
Multiplying things out and gathering terms on one side, we arrive at the cubic equation we were asked to derive:
`m*x^3 - 3(m+M)x + 2(m+M) = 0`.
Remembering that `x` is `cos(theta)`, this is the general condition for the liftoff angle for any `m` and `M`.

Now for the second part of the problem: solve for the angle when the masses are equal, `m = M`.
Substituting `M=m` into our cubic equation gives:
`m*x^3 - 3(2m)x + 2(2m) = 0`.
This simplifies to `m*x^3 - 6mx + 4m = 0`.
Since the mass `m` can't be zero, we can divide the entire equation by `m`, leaving us with:
`x^3 - 6x + 4 = 0`.

To solve this cubic, we can test for simple integer roots. A quick test shows that `x=2` is a solution. This means `(x-2)` is a factor. Using polynomial division, we can factor the cubic into:
`(x-2)(x^2 + 2x - 2) = 0`.

The solutions are `x=2` and the roots of the quadratic `x^2 + 2x - 2 = 0`.
However, `x` represents `cos(theta)`, which must be between -1 and 1. So `x=2` is a mathematically valid root, but it's not a physically possible solution.

We solve the quadratic equation using the quadratic formula, which gives two roots: `x = -1 + sqrt(3)` and `x = -1 - sqrt(3)`.
The second root, `-1 - sqrt(3)`, is about -2.73, which is also physically impossible.
This leaves us with only one valid solution: `x = sqrt(3) - 1`.
`sqrt(3)` is about 1.732, so `x` is about 0.732, which is perfectly valid for a `cos(theta)`.

So, for the case where `m=M`, the final answer is:
The particle loses contact when `cos(theta) = sqrt(3) - 1`.
The angle itself is `theta = arccos(sqrt(3) - 1)`, which is approximately 42.9 degrees.

As a quick sanity check, let's consider the classic version of this problem where the hemisphere is fixed to the table, which is equivalent to its mass `M` being infinitely large. If we go back to our general cubic equation and let `M` become very large compared to `m`, the equation simplifies to `3x = 2`, or `x = 2/3`. This is the well-known result for a fixed hemisphere. Our result for `m=M` was `cos(theta) = sqrt(3) - 1`, which is about 0.732. This is larger than `2/3`, which is about 0.667. A larger value for `cos(theta)` means a smaller angle `theta`. So when the hemisphere is free to recoil, the particle loses contact earlier than it does on a fixed hemisphere. That is consistent with the different way energy and horizontal momentum are shared between the two moving bodies.

And there you have it. From a few fundamental principles, we navigated through conservation laws and force diagrams to derive a general cubic equation and solve it for a specific case, revealing a subtle and fascinating piece of physics along the way.
Compare with Harvard's published solution

Horizontal momentum conservation accounts for the hemisphere's recoil; energy conservation gives the speed; and loss of contact occurs when the normal force reaches zero. With c = cosθ, the result is m c³ − 3(m+M)c + 2(m+M) = 0.

For m = M this becomes c³ − 6c + 4 = 0 = (c−2)(c²+2c−2). The physical root is cosθ = √3 − 1, so θ ≈ 42.9°. Read Harvard's complete solution.

86 · Shifted intervals

6:38 · Equation phrasing refined

Problem statement

Let ε = 1/N. Draw x₁ uniformly from [0,1], x₂ from [ε,1+ε], and in general xk from [(k−1)ε,1+(k−1)ε]. For very large N, find the probability that x₁ is the smallest of all N values.

Open Harvard Problem 86

Read Golpo's approved solution transcript
Welcome to this deep dive into a fascinating probability puzzle. We're given a sequence of N numbers, where N is a very large number. The first number, let's call it x₁, is chosen uniformly from the interval 0 to 1. The second, x₂, is chosen from an interval shifted by a small amount, epsilon, which is defined as one over N. So x₂ comes from epsilon to one plus epsilon. The third, x₃, comes from two epsilon to one plus two epsilon, and so on. The Nth number is drawn from the interval starting at N minus one times epsilon, which is just one minus epsilon.

Our goal is to find the probability that the very first number, x₁, is the smallest of them all.

Let's begin by formalizing our approach. The value of x₁ is itself a random number. So, our strategy will be to assume x₁ takes on a specific value, which we'll call lowercase `x`. We'll then calculate the probability that all the other numbers, x₂ through xₙ, are larger than this specific `x`. Finally, since `x` could have been any value between 0 and 1, we will average this result over all possible values of `x`. In calculus, this "averaging" is done with an integral.

So, for a fixed value `x` of our first number, we need the probability that x₂ is greater than `x`, AND x₃ is greater than `x`, all the way up to xₙ being greater than `x`. Because each number is chosen independently, we can simply multiply these individual probabilities together.

Let's focus on a single one of these probabilities: the probability that a generic number, xₖ, is greater than `x`. Remember, xₖ is chosen uniformly from an interval of length one, starting at `(k-1)ε`. The probability is just the length of the portion of its interval that is greater than `x`.

Two scenarios can happen. First, if our value `x` is smaller than the start of the interval for xₖ—that is, if `x` is less than `(k-1)ε`—then any number chosen for xₖ will automatically be larger than `x`. The probability in this case is 1.

The second scenario is when `x` is larger than or equal to the start of the interval. In this case, the part of the interval available to xₖ that's greater than `x` runs from `x` up to the interval's endpoint, `1 + (k-1)ε`. The length of this segment is simply `1 + (k-1)ε - x`. This is our probability.

Now, we multiply all these probabilities together for `k` from 2 to N. For any given `x`, some of these probabilities will be 1, and some will be less than 1. Specifically, the terms that are less than 1 are those for which `(k-1)ε` is less than or equal to `x`.

This product is still too complex. Here's where we use the fact that N is very large. A common technique in physics and mathematics is to take the natural logarithm of a product to turn it into a sum. The logarithm of our overall conditional probability becomes a sum of logarithms.

Because N is large, `ε` is very small. This allows us to approximate this sum with an integral. This is the crucial leap. The sum of the logarithms transforms into N times the integral from 0 to `x` of `ln(1 + y - x) dy`.

Evaluating this integral gives us a surprisingly clean, if intimidating, result for the logarithm of our conditional probability: it’s `N` times the quantity `[-x - (1-x)ln(1-x)]`. So, the probability itself, for a given `x`, is the exponential of this entire expression.

Now we're ready for the final step: averaging over all possible `x` by integrating from 0 to 1. We need to calculate the integral of `exp(N * [-x - (1-x)ln(1-x)])`.

This looks like a monster, but again, the large N comes to our rescue. The term `exp(N * ...)` is what's called "sharply peaked". The expression in the exponent, `-x - (1-x)ln(1-x)`, is zero at `x=0` and negative everywhere else. Because it’s multiplied by a huge number N, the exponential is essentially 1 at `x=0` and plummets to zero almost immediately.

This means that the only values of `x` that contribute meaningfully to the integral are those very close to zero. For small `x`, we can approximate the exponent. A Taylor expansion shows that `-x - (1-x)ln(1-x)` behaves like `-x²/2`.

So, our final integral simplifies beautifully to the integral from 0 to 1 of `exp(-N * x² / 2)`. This is a classic Gaussian integral. Since the function drops to zero so quickly, we can extend the integration limit to infinity with negligible error. A standard substitution leads us to the answer.

The probability that the first number is the smallest of all N numbers is the square root of the entire quantity pi divided by two N: square root of pi over two N.

Let's do a quick sanity check. The final answer is `sqrt(π / (2N))`. As N, the number of competing values, gets larger, the probability gets smaller, which makes perfect sense. The chance of our first number winning this "smallest number contest" should decrease as more contestants enter. The `1/sqrt(N)` dependence tells us precisely how quickly that probability fades. The formula holds up to intuition, giving us a robust and elegant solution.
Compare with Harvard's published solution

If x₁ lies in its kth ε-sized bin, the conditional probability that it is smallest is approximately Pk = ∏j=1k−1(1−jε). Expanding ln Pk gives the dominant term −εk²/2, so Pk ≈ exp(−εk²/2).

Replacing εΣPk by a Gaussian integral gives √(πε/2) = √(π/(2N)). Read Harvard's complete solution.

85 · Tower of cylinders

5:45 · Corrected before rendering

Problem statement

An infinite tower has two identical cylinders at every level, separated by massless planks. Each cylinder has mass M, radius R, and I = MR²/2; no contact slips. If the bottom plank accelerates horizontally at a, find the acceleration of the bottom row of cylinders.

Open Harvard Problem 85

Read Golpo's approved solution transcript
Consider an infinite tower made from identical cylinders separated by massless planks. There are two cylinders in each row. Every cylinder has mass M, radius R, and moment of inertia M R squared over 2. Nothing slips. The bottom plank is pulled horizontally with acceleration a. We want the horizontal acceleration of the bottom row of cylinders.

The two cylinders in any row move in exactly the same way, so treat each pair as one effective cylinder. Its mass is m equals 2M, and its moment of inertia is still one half m R squared.

For row n, let a sub n be the horizontal acceleration of the cylinder centers. Let alpha sub n be the angular acceleration, with its positive direction chosen consistently from row to row. Let F sub n be the horizontal force exerted by the plank below the row, and G sub n the force exerted by the plank above it.

The translational equation for row n is

F sub n minus G sub n equals m a sub n.

Both contact forces produce torque in the chosen rotational direction, so the rotational equation is

the quantity F sub n plus G sub n, times R, equals one half m R squared alpha sub n.

Divide by R and solve these two equations for the forces. We obtain

F sub n equals one half times the quantity m a sub n plus one half m R alpha sub n,

and

G sub n equals one half times the quantity negative m a sub n plus one half m R alpha sub n.

Every intermediate plank is massless. Therefore its net horizontal force must vanish. Newton's third law then gives

F sub n plus 1 equals G sub n.

Substituting the force expressions and canceling the common factors gives our first relation between successive rows:

a sub n plus 1 plus one half R alpha sub n plus 1

equals

negative a sub n plus one half R alpha sub n.

We need one more relation, and it comes from rolling without slipping. The acceleration of the plank above row n is a sub n minus R alpha sub n. The same plank is below row n plus 1, so its acceleration is also a sub n plus 1 plus R alpha sub n plus 1. Equating these gives

a sub n plus 1 plus R alpha sub n plus 1

equals

a sub n minus R alpha sub n.

Solve these two simultaneous equations for the next row's accelerations. The result is

a sub n plus 1 equals negative 3 a sub n plus 2 R alpha sub n,

and

R alpha sub n plus 1 equals 4 a sub n minus 3 R alpha sub n.

This recurrence is easiest to understand in matrix form. The vector with components a sub n plus 1 and R alpha sub n plus 1 equals the matrix

negative 3, 2; 4, negative 3

times the vector with components a sub n and R alpha sub n.

The matrix has two eigenvalues:

lambda plus equals negative 3 plus 2 square root of 2,

and

lambda minus equals negative 3 minus 2 square root of 2.

Their eigenvectors can be chosen as

V plus equals the vector 1, square root of 2,

and

V minus equals the vector 1, negative square root of 2.

Now use the fact that the tower is infinite. The magnitude of lambda minus is greater than one. Any nonzero component in the V minus direction would make the accelerations grow without bound as we move upward through the tower. That would require unbounded kinetic energy and cannot describe the physical solution.

Therefore the motion must lie entirely in the V plus direction. For the bottom row this means

R alpha sub 1 equals square root of 2 times a sub 1.

Finally apply no slip at the contact between the bottom plank and the bottom cylinders. The acceleration of the bottom contact point equals the imposed plank acceleration a. With our sign convention,

a equals a sub 1 plus R alpha sub 1.

Substitute R alpha sub 1 equals square root of 2 a sub 1:

a equals the quantity 1 plus square root of 2, times a sub 1.

Thus

a sub 1 equals a divided by 1 plus square root of 2.

Rationalizing the denominator gives the final answer:

a sub 1 equals the quantity square root of 2 minus 1, times a.

Numerically, the bottom row accelerates at about 0.414 times the acceleration of the bottom plank, in the same direction.

As a sanity check, the allowed eigenvalue negative 3 plus 2 square root of 2 is approximately negative 0.172. Its magnitude is less than one, so the accelerations alternate direction and rapidly decrease from one level to the next. That is exactly the bounded behavior an infinite tower requires.
Compare with Harvard's published solution

Treat each pair in a row as one effective cylinder of mass 2M. Translation, rotation, massless-plank force balance, and no slip give the recurrence [an+1, Rαn+1]T = [[−3,2],[4,−3]][an,Rαn]T.

The eigenvalues are −3 ± 2√2. Bounded motion in an infinite tower excludes the eigenmode whose magnitude exceeds 1, leaving Rα₁ = √2a₁. Bottom-contact no slip gives a = a₁ + Rα₁, hence a₁ = (√2 − 1)a. Read Harvard's complete solution.

Step 6: inspect the finished video

A correct script can still become a confusing video if a formula is drawn poorly or a visual label changes mid-scene. Before publishing, check:

  • the problem statement and variables match the source;
  • equations are grouped, signed, and typeset correctly;
  • diagrams use the same labels as the narration;
  • captions do not change a mathematical expression;
  • the final answer appears clearly and agrees with the approved script;
  • the video file plays from beginning to end on desktop and mobile.

Step 7: publish on YouTube or your website

Golpo returns the finished video. Your pipeline can save the MP4 and a manifest, but publishing is a separate editorial step. Create a specific title and thumbnail, link the original problem, credit its author or publisher, describe any adaptation, and confirm you have the right to republish the source material and your derived presentation.

On a website, embed the MP4 with controls and a poster image. On YouTube, upload it with the source link, chapter markers where useful, and a description that distinguishes the original problem from your explanation. Do not present an AI-assisted verification as proof of authority.

A reusable end-to-end prompt

Use the Golpo Skill, Golpo MCP, or Golpo API to process Problems 89 through 85 from Harvard's Problem of the Week page. Discover each problem and its matching published solution. Work one problem at a time. First request an Auto-length tutorial script only, with the complete problem statement included. Compare every step and the final answer with the published solution. If anything is wrong or ambiguous, revise it and verify again. Only then generate a Golpo Canvas video from the approved script. Save the script, review verdict, job information, final MP4, and source links in a manifest. Run no more than three Golpo jobs concurrently.

The larger lesson

The API makes scale possible; the review gate makes scale responsible. The best pipeline is not fully automatic at the point where truth matters. It automates collection, drafting, rendering, polling, downloads, and bookkeeping—then pauses for evidence-based approval before turning a draft into a polished explanation.

If you want the single-problem, no-code version first, see the related guide: How I Turned a Difficult Harvard Math Problem Into an Explainer Video With Golpo AI.

Create an explainer video with Golpo

Tags

#Golpo API#Explainer Videos#Educational Video Automation