Series sum by partial fractions
The sum of 1/(k(k+1)) from 1 to 10 is exactly 10/11. Enter the upper index and the shifts p and q; the tool splits the term into partial fractions, cancels the telescoping pieces and gives the reduced fraction. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- N
- 10
- A
- 1
- Power (W)
- 0
- Q
- 1
- Start
- 1
Many calculus and precalculus sequences ask for the sum of a rational term that factors into two linear pieces in the index k. The standard classroom move is to split the term with partial fractions, rewrite each summand as a difference of simpler unit fractions, and watch most intermediate pieces cancel in a telescoping pattern. This series sum by partial fractions calculator automates that exact path for the general term a over (k plus p) times (k plus q). You supply the upper index n, optional lower index start, optional numerator coefficient a, and the integer shifts p and q. The engine returns the exact reduced fraction, a stable decimal sum, the partial-fraction identity, the closed telescoping formula, and the short lists of uncancelled positive and negative remainder denominators. Classic cases such as one over k times k plus one fall out immediately when p is zero and q is one.
Partial fractions and why the series telescopes
Start from a proper rational term in the discrete variable k whose denominator is a product of two distinct linear factors. Algebra gives the elementary identity a divided by (k plus p) times (k plus q) equals a over (q minus p) times the difference of one over (k plus p) and one over (k plus q).
When you write that difference for every k from start through n and add, each interior unit fraction appears once with a plus sign and once with a minus sign a fixed number of steps later. Those interior contributions cancel, leaving only a short block of positive remainders near the lower index and a short block of negative remainders just past the upper index. The length of each block is the absolute gap between q and p.
Multiplying the remaining combination by the constant scale a over (q minus p) produces the exact finite sum without ever adding n separate floating-point terms. That is the telescoping method textbooks illustrate for one over k times k plus one, and the same cancellation works for one over k times k plus two, one over (k plus one) times (k plus three), and every other pair of distinct integer shifts.
This calculator encodes that cancellation with exact BigInt rational arithmetic so the fraction you see is reduced by the greatest common divisor, not a rounded guess.
Where a partial-fractions series sumer earns its keep
Instructors and tutoring platforms use a series sum by partial fractions calculator so learners can check closed forms for arbitrary p, q, and n without algebraic slip-ups in the telescoping bookkeeping. Exam generators and LMS auto-graders need a deterministic oracle that returns the reduced fraction and rejects singular ranges instead of silently emitting NaN. Failed validation does not consume balance.
Keep requests small, pin the fraction and rounded sum in tests, and you get reproducible totals for homework, LMS plugins, and edge workers without standing up symbolic infrastructure of your own.
What you can do with it
Homework and classroom checks
Verify closed forms for Σ a/((k+p)(k+q)) after students decompose the term by hand and cancel telescoping pieces.
Notebooks and discrete kernels
Obtain exact finite sums of two-factor rational kernels in generating-function or discrete-calculus scripts without a CAS.
FAQ
How do I sum a series with partial fractions?
Send upper index n (required) and optional a, p, q, start.
Why must p and q be different?
When p equals q the denominator is a repeated linear factor and the elementary two-term partial-fraction difference identity does not apply. Choose distinct shifts.
What happens if a factor vanishes for some k in the range?
A zero factor makes the general term undefined, so no finite sum is returned.
What is the sum of 1/(k(k+1)) from 1 to 10?
It is exactly 10/11, about 0.909090909090909. Each term splits into 1/k minus 1/(k+1), the middle pieces cancel, and only 1 minus 1/11 remains.
Does the calculator give an exact fraction or a decimal?
Both. The total is computed with exact fractions and reduced to lowest terms, so you see the fraction and a decimal, plus the leftover pieces that survive the cancellation.
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/calculus/series-sum-by-partial-fractions \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"n":10}'const res = await fetch("https://api.kit.forhosting.com/calculus/series-sum-by-partial-fractions", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"n": 10
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/calculus/series-sum-by-partial-fractions",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"n": 10
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/calculus/series-sum-by-partial-fractions", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"n":10}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"n":10}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/calculus/series-sum-by-partial-fractions", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"n": 10
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "calculus.series_sum_by_partial_fractions",
"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.
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
Pure parse logic powers both the free browser tool and the API so homework checks and automation never disagree.
Partial fractions and why the series telescopes
When a pole would sit inside the summation range because some k makes k plus p or k plus q zero, the request is rejected instead of returning an infinite or undefined total.
Input contract, defaults, and response fields
Optional start defaults to one and must not exceed n. Optional coefficient a defaults to one and may be any finite number. Optional integers p and q default to zero and one so the classic series one over k times k plus one works with only n filled in. The two shifts must differ, and their absolute difference must not exceed five hundred so the exact remainder product stays practical. POST a JSON body with the required upper index n, an integer from one through one million. Aliases include coefficient for a, from for start, and to for n. On success the payload echoes a, p, q, start, and n; reports sum as a stable decimal; fraction as a reduced string such as ten over eleven; numerator and denominator of that reduced form; term as a display string for the general summand; partial_fractions as the scaled difference identity; formula as the expanded closed combination of unit fractions; method set to partial_fractions_telescoping; telescoping_gap equal to q minus p; positive_remainders and negative_remainders as the integer denominators that survive cancellation; and max_n for the supported ceiling. Missing n, non-integers where integers are required, p equal to q, poles on the range, or n below start all fail with invalid_input and are not billed.
Where a partial-fractions series sumer earns its keep
Engineering notebooks that expand generating functions or discrete Green kernels often need exact partial sums of rational kernels of the form a over (k plus p) times (k plus q) before taking limits as n grows; calling a tiny parse endpoint avoids pulling a full computer-algebra system for a two-factor telescoping sum.
Integration use cases
LMS and exam auto-grading
Mark partial-fractions telescoping items with a deterministic reduced fraction and reject poles or p=q as invalid_input.
Technical questions
What defaults apply if I only send n?
a defaults to 1, p to 0, q to 1, and start to 1, so you get Σ_{k=1}^{n} 1/(k(k+1)) = n/(n+1).
What does the series sum by partial fractions calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.