ForHosting KIT · Math

Triangle sum theorem

Angles of 50°, 60° and 80° add up to 190°, which is 10° too many for a triangle. Enter three interior angles in degrees and the checker tells you whether they make exactly 180° and by how much they miss. Free in your browser.

Free
Runs in your browser
No sign-up
Your data stays on your device

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

Worked example

If you enter

Angle a: 60
Angle b: 60
Angle c: 60

You get

Sum degrees: 180
Expected sum: 180
Deviation: 0
Unit angles: deg

The triangle sum theorem — also called the triangle angle-sum theorem or the 180-degree rule — is the Euclidean identity that the three interior angles of a plane triangle add to exactly 180 degrees. This checker takes three candidate interior angles in degrees, adds them, and reports whether the identity holds together with the signed deviation from 180. Homework checkers, LMS graders, and CAD review scripts can therefore accept a triple that already claims to be a triangle and mark it pass or fail without solving for a missing angle.

What the triangle sum theorem states and how this checker uses it

The triangle sum theorem is a foundational identity of Euclidean plane geometry: the three interior angles of any triangle add to 180 degrees, or π radians. The result follows from drawing a line through one vertex parallel to the opposite side and reading the alternate-interior and corresponding angles that appear; those pairs copy the other two interior angles onto a straight line, and a straight line measures 180 degrees.

The same identity is taught as the angle-sum theorem, the 180-degree rule, and the fact that an exterior angle equals the sum of the two remote interiors. This capability does not find a missing angle from two known ones and it does not classify a triangle as acute, right, or obtuse. It verifies a triple that already claims to be a complete set of interior angles.

You send three positive measures in degrees. A classroom triple such as 60, 60, and 60 yields sum 180 and deviation 0.

Where a triangle sum theorem checker earns its keep

Classrooms and tutoring platforms use a dedicated triangle sum theorem checker so learners can paste three measured or computed interior angles and see immediately whether they close a plane triangle, without switching to a missing-angle calculator that would hide the error by inventing the third vertex. Exam-prep generators and LMS plugins need a deterministic oracle that marks a triple pass or fail, returns the signed deviation for partial-credit rubrics, and rejects a zero or negative angle as invalid instead of silently treating it as a degenerate triangle.

Shop drawings, CNC fixturing notes, and simple CAD review scripts often receive three labeled corner angles from a scan or a hand sketch and must decide whether the figure is Euclidean-closed before they compute sides. Failed validation does not consume balance. Distinct search intent from a missing-angle finder, an acute-right-obtuse classifier, and a polygon interior-sum page that takes a side count n: this landing answers the query that already has three angles and asks whether they add to 180 degrees.

What you can do with it

Classroom and homework checks

Let students submit three interior angles and see whether they add to 180 degrees, with the signed deviation shown next to the verdict.

CAD and shop-drawing review

Accept three labeled corner angles from a scan or sketch and decide whether the figure is Euclidean-closed before computing sides.

FAQ

What is the triangle sum theorem?

In Euclidean plane geometry the three interior angles of any triangle add to 180 degrees. This checker takes three candidate angles in degrees and reports whether that identity holds, plus the signed deviation from 180.

When does the checker reject the input?

An angle larger than 180 is accepted and reported as a non-zero deviation.

How is this different from a missing-angle calculator?

A missing-angle tool takes two known interiors and invents the third as 180 minus their sum. This landing already has three angles and asks whether they satisfy the theorem.

What does the deviation in the result mean?

It is the total of your three angles minus 180°. A positive value means the angles are too large together, a negative one that they fall short. Angles of 50°, 60° and 80° give a deviation of +10°.

Can I enter an angle larger than 180 degrees?

Yes. Such an angle cannot sit inside a triangle, but the checker still adds the three values and reports how far the total is from 180°, so you see the size of the error instead of a refusal.

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

POSThttps://api.kit.forhosting.com/math/triangle-sum-theorem

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/triangle-sum-theorem \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"angle_a":60,"angle_b":60,"angle_c":60}'

const res = await fetch("https://api.kit.forhosting.com/math/triangle-sum-theorem", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "angle_a": 60,
    "angle_b": 60,
    "angle_c": 60
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/math/triangle-sum-theorem",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "angle_a": 60,
    "angle_b": 60,
    "angle_c": 60
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/triangle-sum-theorem", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"angle_a":60,"angle_b":60,"angle_c":60}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"angle_a":60,"angle_b":60,"angle_c":60}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/triangle-sum-theorem", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "angle_a": 60,
  "angle_b": 60,
  "angle_c": 60
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "math.triangle_sum_theorem",
  "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

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

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

Each angle must be a strictly positive finite number; zero or negative values are rejected as invalid_input because they cannot be interior angles of a plane triangle. Failed validation is not billed; a successful call that reports a non-zero deviation is still a valid verification result, not an error.

What the triangle sum theorem states and how this checker uses it

The solver adds them, compares the total with 180, and returns both a boolean that says whether the theorem holds and a signed deviation equal to the sum minus 180. A slip such as 50, 60, and 80 yields sum 190, deviation plus 10, and sums_to_180 false. That second case is a successful verification, not an error: the point of a checker is to accept a candidate and say how far it is from the identity.

Input contract, response shape, and error behaviour

An angle larger than 180 degrees is still a valid input; the checker reports a non-zero deviation instead of inventing a hard failure, because the job is to measure how far the triple sits from 180, not to assume the theorem already holds. Results are rounded to twelve decimal places so goldens stay stable across runtimes. POST a JSON body with three required finite numbers: angle_a, angle_b, and angle_c, each an interior-angle candidate in degrees. Each field may arrive as a JSON number or as a numeric string; aliases A, B, C, angle1, angle2, angle3, alpha, beta, and gamma are accepted when the canonical name is omitted. Missing fields, empty strings, non-numeric text, NaN, and Infinity fail with invalid_input naming the field. The only geometric domain rule is that every angle must be strictly positive: zero and negative values cannot be interior angles of a plane triangle, so they fail with invalid_input and are not billed. On success the body echoes the three angles, reports sum_degrees, expected_sum 180, the signed deviation (sum minus 180), the boolean sums_to_180, unit_angles deg, and a short formula string. Equality uses a tight numeric epsilon of 1e-9 so floating addition of textbook decimals does not flicker the boolean. Example: 90, 45, and 45 yields sum 180, deviation 0, and sums_to_180 true. Example: 40, 60, and 90 yields sum 190, deviation 10, and sums_to_180 false. Pair the payload with your own sketch if you need a drawing; this endpoint verifies the identity only.

Where a triangle sum theorem checker earns its keep

Keep requests small, pin sum_degrees, deviation, and sums_to_180 in tests, and you get reproducible verdicts for homework, graders, and edge workers without standing up a computer-algebra stack.

Integration use cases

Exam and LMS auto-grading

Mark triangle-sum items with a deterministic oracle that returns sums_to_180 and deviation, and rejects zero or negative angles as invalid_input.

Technical questions

What if the three angles do not add to 180?

The call still succeeds. sums_to_180 is false and deviation equals the sum minus 180 (positive if the triple is too large, negative if it is too small). That is a verification result, not an error.

What does the triangle sum theorem checker cost?

The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.

Read the full KIT documentation →

Run — free

Worked example

What the triangle sum theorem states and how this checker uses it

Where a triangle sum theorem checker earns its keep

What you can do with it

Classroom and homework checks

CAD and shop-drawing review

FAQ

Related tools

For developers — API access

API endpoint

Call it from your stack

Example request

Example response

Pricing

Errors

Technical notes

What the triangle sum theorem states and how this checker uses it

Input contract, response shape, and error behaviour

Where a triangle sum theorem checker earns its keep

Integration use cases

Exam and LMS auto-grading

Technical questions

thank you