ForHosting KIT · Math

Exponent rules calculator

Turn a chain of powers with one base into a single power: 2³ · 2⁵ becomes 2⁸, which is 256. Choose multiply, divide or power of a power and the right exponent rule is applied for you. 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

Base: 2
Rule: Product
Ordered list of exponents: 3, 5

You get

Value: 256
Base: 2
Base label: 2
Combined exponent: 8

This exponent rules calculator simplifies expressions of powers that share one base by applying the three laws every algebra course drills: the product rule adds exponents when you multiply, the quotient rule subtracts when you divide, and the power rule multiplies exponents when you raise a power to a power. Give a common base, choose product, quotient, or power, and pass an ordered list of at least two exponents; the engine returns the combined exponent, a clean base-to-the-e string such as 2^8 or x^5, the identity it used, and—when the base is a safe integer and the result is an exact non-negative integer power—the numeric value as well. Zero to a non-positive power is rejected as undefined so homework checks stay honest.

The three exponent rules in plain words

Same-base exponent laws let you rewrite products, quotients, and nested powers as a single power without expanding large multiplications by hand. The product rule states that a to the m times a to the n equals a to the m plus n, so the calculator sums every exponent you supply when rule is product.

The quotient rule states that a to the m divided by a to the n equals a to the m minus n; with more than two factors it subtracts each subsequent exponent from the first, matching left-to-right chains such as a^9 / a^2 / a^3. The power rule states that a to the m raised to n equals a to the m times n, and with a longer list it multiplies all exponents so nested towers like ((a^2)^3)^4 collapse in one step.

The response always echoes the normalized base, the chosen rule, the input exponents, the combined exponent, a simplified string such as 2^8 or (x)^5 when parentheses help, the textbook formula for that rule, and an optional numeric value when evaluation is exact and safe.

Where exponent-rule practice fits in study, code, and teaching

Students meet these three laws when simplifying monomials, when rewriting scientific notation products, and when preparing for contests that punish expanding instead of combining exponents. Teachers can pre-generate answer keys for product chains, successive quotients, and nested power towers without relying on opaque calculator apps that switch to scientific notation or silently treat zero to the zero as one.

Developers call the same contract from scripts to seed deterministic test vectors for algebra tutors, to validate student submissions against a single combined exponent, or to size units in models that store growth as a base and a list of log-space increments. Contest practice often needs a fast offline check that (a^m)^n really is a to the m n and that a^m over a^n is a to the m minus n, including negative combined exponents that leave a reciprocal power in simplified form without inventing a decimal approximation.

Curriculum authors use the calculator when drafting progressive exercises that move from two-factor products to longer mixed-looking lists still under one rule, then later introduce symbolic bases so learners stop fixating on the numeric value alone.

What you can do with it

Homework product and quotient checks

Verify a^m·a^n and a^m/a^n by reading the combined exponent and simplified base^e form for textbook exercises.

Nested power towers for contests

Collapse ((a^m)^n)^p with the power rule in one call for contest prep and answer-key generation.

FAQ

What does the exponent rules calculator cost?

It is free in your browser on this page.

Which rules are supported?

Product (sum exponents), quotient (first minus the rest), and power (multiply exponents). Mixed bases in one expression are not supported.

What happens with base zero?

Positive exponents that keep the combined exponent positive are allowed.

Can the base be a symbol like x?

Yes. Symbolic bases return simplified forms such as x^5 with value null; numeric evaluation applies only to integer bases in range.

How many exponents can I send?

At least two and at most thirty-two, each within the published magnitude limit. Longer chains should be split into multiple requests.

How do I divide several powers with the same base?

Subtract each later exponent from the first, working left to right. So a⁹ divided by a² and then by a³ leaves a⁴.

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/algebra/exponent-rules

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/algebra/exponent-rules \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"base":"2","rule":"product","exponents":[3,5]}'

const res = await fetch("https://api.kit.forhosting.com/algebra/exponent-rules", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "base": "2",
    "rule": "product",
    "exponents": [
      3,
      5
    ]
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/algebra/exponent-rules",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "base": "2",
    "rule": "product",
    "exponents": [
        3,
        5
    ]
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/algebra/exponent-rules", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"base":"2","rule":"product","exponents":[3,5]}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"base":"2","rule":"product","exponents":[3,5]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/algebra/exponent-rules", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "base": "2",
  "rule": "product",
  "exponents": [
    3,
    5
  ]
}

Example response

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

Limits

`max_exponents`	32
`max_abs_exponent`	1000000
`max_abs_base`	1000000000000000

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

The path is fully deterministic Worker arithmetic with no network calls, sampling, or date tricks.

What the three exponent rules mean and what the response contains

There is no approximate floating-point rewrite presented as exact symbolic algebra and no random sampling of identities: either the combined exponent is computed inside the published limits or the request fails with invalid_input. Rejected cases include missing base, rule, or exponents, fewer than two exponents, non-finite values, unsupported rule names, bases that are neither numbers nor simple symbols, and—critically—base zero with any non-positive factor or combined exponent, because zero to the zero and zero to a negative power are left undefined in this contract.

How base, rule, and exponents are read and when value is filled

Rules must be exactly product, quotient, or power after trimming and lowercasing. When the base is the number zero, every product or quotient factor exponent must be strictly positive and the combined exponent must also be positive; under the power rule the innermost exponent must be positive and the product of all exponents must stay positive, matching the idea that you never form zero to a non-positive power at any stage the identity cares about. Near-integer floating results from summing or multiplying decimals are snapped to the nearest integer when the error is tiny, which keeps textbook answers like eight instead of 7.999999999. The preferred fields are base for the common ground of every power, rule for which law to apply, and exponents for the ordered list of at least two finite numbers. Aliases a and b for base, mode and law for rule, and exps and powers for exponents are accepted so spreadsheets, query strings, and typed forms can reuse one contract. Bases may be ordinary numbers, including negatives and decimals, or short symbolic identifiers such as x or base_n; pure numeric strings are parsed as numbers so a cell that says two is not left as a symbol. Exponents are validated one by one as finite reals within the published absolute magnitude, with a hard ceiling on list length so a paste error cannot blow the Worker budget. Numeric evaluation fills value only for integer bases and non-negative integer combined exponents that stay inside JavaScript safe integers; otherwise value is null while simplified and combined_exponent remain authoritative. Pair the free browser run on this page with the priced API when you need the identical law inside an automated pipeline without re-implementing edge cases around zero yourself.

Where exponent-rule practice fits in study, code, and teaching

On this page the work runs entirely in your browser; through the API each successful simplification costs $0.002, failed validation is not charged, and nothing is stored after the response returns. That split—free interactive exploration and a priced, identical API—matches the rest of the KIT tier-A catalog and lets you move from a classroom demo to an automated pipeline without changing the mathematical result. Pair it with complete-the-square or polynomial tools when you are building a small lab of free, deterministic algebra helpers, and keep this endpoint focused on the laws of exponents so search intent for product, quotient, and power rules stays sharp and uncannibalized.

Integration use cases

Deterministic algebra fixtures

Generate reproducible combined exponents and optional integer values for unit tests and tutor APIs.

Read the full KIT documentation →

Run — free

Worked example

The three exponent rules in plain words

Where exponent-rule practice fits in study, code, and teaching

What you can do with it

Homework product and quotient checks

Nested power towers for contests

FAQ

Related tools

For developers — API access

API endpoint

Call it from your stack

Example request

Example response

Pricing

Limits

Errors

Technical notes

What the three exponent rules mean and what the response contains

How base, rule, and exponents are read and when value is filled

Where exponent-rule practice fits in study, code, and teaching

Integration use cases

Deterministic algebra fixtures

thank you