Coin rotation paradox
Find how many turns a circle makes rolling around another: two identical coins give 2 rotations, not 1, because the count is (R + r) / r. Enter both radii and see the rotations next to the bare ratio, so the extra turn is plain. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Radius large
- 1
- Radius small
- 1
- Ratio
- 1
- Rotations
- 2
The coin rotation paradox is one of the most counter-intuitive results in elementary geometry: roll a coin around another identical coin and it makes not one but two full rotations. This capability computes the general case from both radii — a circle of radius r rolling without slipping around the outside of a fixed circle of radius R makes (R + r) / r rotations. Send the two radii, get the exact rotation count, the radius ratio, and the formula used.
Why the naive answer is wrong
Most people reason as follows: the rolling circle touches a circumference of length 2πR, and its own circumference is 2πr, so it should rotate R/r times. For two identical coins that predicts exactly one rotation. Try it with two coins and you will see the moving coin spin twice.
The mistake is that R/r only counts the turns produced by unrolling the contact arc. It ignores that the center of the rolling circle also travels around the fixed center on a circle of radius R + r, and that orbital motion contributes exactly one extra full turn regardless of the radii. The center of the rolling coin covers a path of length 2π(R + r), and dividing that path by its own circumference 2πr gives (R + r)/r rotations — the correct answer.
The coin rotation paradox is the gap between intuition (R/r) and geometry (R/r + 1), and it shows up far beyond puzzle books: epicyclic gears, planetary motion, and the design of cycloidal mechanisms all depend on counting that extra turn.
How the calculation works
The result is rotations = (R + r)/r, returned together with the bare ratio R/r so you can see exactly the +1 the paradox adds. The rolling circle does not have to be smaller — the formula is symmetric in its logic and works even when the 'small' circle is larger than the fixed one, which simply yields a count between 1 and 2.
Because the computation is a single closed-form division, it is exact and deterministic: the same two radii always produce the same answer, rounded to six decimals for a stable, byte-identical output.
Where it fits
Teachers use the paradox to shake students out of formula-first thinking, and this calculator gives them instant checks for any pair of radii: equal coins, a coin around a ring ten times its size, or fractional ratios. Engineers working with epicyclic (planetary) gear trains rely on the same identity — a planet gear rolling around a sun gear rotates more times than the tooth-count ratio suggests, and forgetting the +1 mis-designs the whole train.
Game and animation developers use it to make a rolling sprite spin at the physically correct rate so motion does not look like sliding. Puzzle setters and content teams use it to generate verified answer keys. Whatever the context, the rule is the same: rolling around the outside adds exactly one turn; rolling inside a ring subtracts one.
What you can do with it
Check a geometry homework answer
Enter the two radii and confirm the rotation count, including the extra turn the paradox adds.
Design epicyclic gear ratios
Compute how many times a planet gear spins per orbit around the sun gear before committing to a tooth count.
Animate a rolling object correctly
Derive the physically accurate spin rate for a circle rolling around another so the motion does not look like sliding.
FAQ
Why two rotations for two identical coins?
Because R/r counts only the rotations from the contact arc.
Do the radii have to be in specific units?
No. Only the ratio matters, so any consistent unit — millimetres, inches, pixels — gives the same rotation count.
Can the rolling circle be larger than the fixed one?
Yes. The formula (R + r)/r still holds; you get a count between 1 and 2 rotations.
Does it handle rolling inside a ring?
No — this capability computes the outside case, which adds one turn. Rolling inside a ring subtracts one instead.
Where does the coin rotation paradox matter in real life?
In planetary gear trains: a planet gear rolling around a sun gear turns more times than the size ratio suggests, and forgetting the extra turn mis-designs the gearbox. Cycloidal mechanisms and planetary motion depend on the same count.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/math/coin-rotation-paradox \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"radius_large":3,"radius_small":1}'const res = await fetch("https://api.kit.forhosting.com/math/coin-rotation-paradox", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"radius_large": 3,
"radius_small": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/coin-rotation-paradox",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"radius_large": 3,
"radius_small": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/coin-rotation-paradox", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"radius_large":3,"radius_small":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"radius_large":3,"radius_small":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/coin-rotation-paradox", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"radius_large": 3,
"radius_small": 1
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.coin_rotation_paradox",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
min_radius | 0 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
How the calculation works
The endpoint takes two fields: radius_large (R), the radius of the fixed circle, and radius_small (r), the radius of the rolling one. Both must be positive finite numbers; zero, negative, missing, or non-numeric values are rejected with an invalid_input error and are never charged. The same code runs free in your browser on this page and through the paid API, so you can verify any result by hand before automating it.
Where it fits
This endpoint handles the outside case and returns the number with no fuss, at $0.002 per request when called through the API.
Technical questions
What does it cost?
$0.002 per request via the API. It is also free to run in your browser on this page.
What input is rejected?
Missing, zero, negative, non-finite, or non-numeric radii are rejected with an invalid_input error and are not charged.