Math calculator

Exponent Calculator

Q: What is an exponent?

In aⁿ, a is the base and n is the exponent (power). For positive integers n, it means multiply a by itself n times.

Q: What is a⁰?

For any nonzero a, a⁰ = 1. 0⁰ is left undefined in this tool.

Q: How do negative exponents work?

a⁻ⁿ = 1/aⁿ. The minus sign makes a reciprocal; it does not make the answer negative by itself.

Q: What about fractional exponents?

a^(1/n) is the n-th root of a. Enter fractions as decimals (0.5 for square root).

Q: How do I solve for the base or exponent?

Choose Solve for Base a or Exponent n. Share URLs use solve_for=a or solve_for=n. Even integer n with y > 0 returns two real bases ±. 1ⁿ = 1 and a⁰ = 1 (a ≠ 0) are infinitely many; 1ⁿ = 2 has no real solution. Log remains the dedicated logarithm engine.

Calculate aⁿ for a real base and exponent. Fast local calculation with shareable, machine-readable results.

Instant result

Result

—

Enter values to calculate.

Inputs—

Mode—

Formula—

Trust summary CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance

Input interpretation: Enter values to calculate.
Result: —
Assurance: Core
Declared partition coverage: PASS · 5/5 declared partitions (forward, solve-base, solve-exp, invalid-domain, xcal) · Matrix
Numerical scope: ≤2 ULP vs O3 applies to the 6 published tabulated vectors ((2,10), (10,2), (5,0), (9,0.5), (2,−3), (e,1)). It is not a guarantee over all real bases and exponents.
Known limitations: Real forward power; inverse via solve_for
Core CVP does not include live graph, viewport, or pointer interaction.
Model: The real power equation y = aⁿ. solve_for selects the unknown: y (default) | a | n.
Scope: Real arithmetic only. Complex values are not returned.
Verification: Engine tested · Source checked · v1.0.4 · CVP VERIFIED · CVP protocol 1.0.0-proposed · Core assurance· View Manifest · CVP overview · Specification
Versions: Calculation 1.0.4 · CVP protocol 1.0.0-proposed · Evidence 2026-09-08.xcal
Verification revision: 2026-09-08.xcal · 2/2 property · digest e5bdc1674386
Legacy regression: 38/38 tests · Production surface contract 3/3
Reference: O1 model · O3 expected_values · O3 numerical_behavior · O2 expected_values · O2 numerical_behavior
Interfaces: PASS · UI (SSR) / REST / MCP / URL→result→graph — Success 1/1. Integration: URL → SSR result → Live graph current point (4/4). Hydration/slider/history are URL-canonical contracts, not a live browser session.
Supplemental domain review: Not performed
Named expert review: Not performed
CVP suite: 3/3 golden · 22/22 CVP boundary · 21/21 invalid · 2/2 property · 2/2 metamorphic · 3/3 round-trip · 6/6 O3 · 1/1 cross-interface · 11/11 cross-calculator · 4/4 URL→result→graph · 1/1 CVP contract · Manifest
Sources: NIST Digital Library of Mathematical Functions, Chapter 4 — Logarithm, Exponential, Powers
NIST DLMF §4.2 — Logarithm and the exponential as inverse operations
CalculatorX mathematical conventions — 0^0 undefined; negative base only with integer exponent
Sources
Evidence: 16 legacy golden · 22 legacy boundary · legacy regression suite · 3/3 oracle-backed golden · 21/21 invalid · Artifact integrity PASS
Semantic contract: PASS

Full verification

Manifest identity, reference classes, interfaces, suite, and production records.

Formulas

Core equations used by this calculator.

Positive integer exponentaⁿ = a × a × … × a (n ∈ ℤ>0)

General real exponent, a > 0aⁿ = exp(n ln a)

Negative integer exponenta⁻ⁿ = 1 / aⁿ

Solve exponent (a > 0, a ≠ 1, y > 0)n = log(y) / log(a)

Solve base, odd integer na = ⁿ√y (unique real)

Solve base, even integer n and y > 0a = ± ⁿ√y

isolve_for selects the unknown: y (default) returns the scalar aⁿ; a and n return a structured result. 0⁰ and 0^(negative) are undefined. Negative bases require an integer exponent for a real forward value. Inverse base with even integer n and y > 0 has two real solutions. Use decimal form for fractional exponents (e.g. 0.5 for ½).

How to use

Choose Solve for

Power y computes y = aⁿ (published forward engine). Base a and Exponent n solve aⁿ = y with explicit domain and multiplicity. Share URLs include solve_for.

Optional: use e

Click “Use e as base” for natural powers eⁿ (share URL uses a=e).

Read the result

Small positive integer exponents also show the expanded product. Even roots report both real signs. Share the result URL or call the REST API.

Example calculations

Common configurations with formula and result.

Repeated multiply

2⁵

2×2×2×2×2

Negative exponent

5⁻²

1/25

0.04

Fractional exponent

9⁰·⁵

√9

Find exponent

2ⁿ = 1024

n = log₂(1024) (a > 0, a ≠ 1, y > 0)

Find base (two reals)

a² = 4

a = ±2

±2

Exponent calculator specification

Version 1.0.4 · Engine tested

Calculation status

Engine tested 38/38 tests · Production surface contract 3/3
Named expert review Not performed
Calculation version 1.0.4

Review policy · Evidence

Definition: Exponentiation aⁿ is the real power of base a and exponent n. The published engine solves y = aⁿ, or the inverse equation aⁿ = y for a or n when solve_for is set. Positive integer n is repeated multiplication; the general real case with a > 0 is aⁿ = exp(n ln a).
What it calculates: The real power equation y = aⁿ. solve_for selects the unknown: y (default) | a | n.
Inputs: solve_for: y (default) | a | n. If omitted and a,n are present, the engine computes y.
Base a (required for y and n). Token e is Euler’s number.
Exponent n (required for y and a)
Power y (required for a and n)
Outputs: solve_for=y: scalar y = aⁿ
solve_for=a or n: object { solve_for, value, a, n, y, optional solutions[], optional warnings[] }
Formula: y = aⁿ; for a > 0 also aⁿ = exp(n ln a)
Assumptions: Real arithmetic only. Complex values are not returned.
0⁰ is undefined. 0 raised to a negative power is undefined.
Negative bases are allowed only with an integer exponent. Non-integer exponents of a negative base are NOT_REAL (this engine does not special-case odd roots).
Token e as base uses Math.exp(n), not (Math.E)**n.
Solve exponent uses n = log(y)/log(a) only when a > 0, a ≠ 1, y > 0. 1ⁿ = 1 is INFINITELY_MANY; 1ⁿ = 2 is NO_REAL_SOLUTION; 0ⁿ = 0 (n > 0) is INFINITELY_MANY.
Solve base: odd integer n → unique real a = sign(y)·|y|^(1/n). Even integer n and y > 0 → two reals ± with warning TWO_REAL_SOLUTIONS (principal value is non-negative). Even n and y < 0 → NOT_REAL. n = 0 and y = 1 → INFINITELY_MANY.
Units: Dimensionless numeric result. In physical applications, apply consistent units under the relevant power law.
Boundary conditions: Missing required inputs for the selected solve_for returns MISSING_REQUIRED_INPUT. Invalid solve_for returns INVALID_SOLVE_FOR.
Non-numeric, object, array, boolean, NaN, or Infinity inputs return INVALID_NUMBER.
0⁰ and 0^(n<0) return UNDEFINED_POWER.
Negative a with non-integer n returns NOT_REAL.
IEEE-754 overflow returns RESULT_OVERFLOW, not Infinity. Underflow to 0 for nonzero a returns RESULT_UNDERFLOW.
Identity cases 1ⁿ = 1 and a⁰ = 1 (a ≠ 0) return INFINITELY_MANY. Impossible identities return NO_REAL_SOLUTION.
Numerical precision: Forward y uses IEEE-754 binary64 (JavaScript Number): y = a ** n, except a = e which uses y = Math.exp(n).
REST and SSR return that engine number for solve_for=y. Inverse modes return a structured object; the page may round for display (up to 12 significant digits; scientific notation when |y| ≥ 1e12 or 0 < |y| < 1e-6).
Integer powers that are exact in binary64 (for example 2¹⁰ = 1024 and 7⁰ = 1) display exactly.
JavaScript 0 ** 0 is 1; this engine rejects 0⁰ before that evaluation.
Interactive evaluation runs in the browser. Shared URLs and REST use the same engine. Default share URL is /calc/math/exponent?solve_for=y&a=2&n=10.
The Result Card includes an engine-linked Live graph of y = a^x using the same Overview / Focus template as Log (canonical window −2 ≤ x ≤ 2). (0, 1) is a Reference point, not the current input. Negative bases are not drawn as a continuous real curve.
Example: 2¹⁰ = 1024; a² = 4 → a = ±2; 2ⁿ = 1024 → n = 10
Validation cases: 20 published on this page · 38/38 tests · Production surface contract 3/3 · View evidence
a=2, n=10 → 1024
a=5, n=-2 → 0.04
a=9, n=0.5 → 3
a=7, n=0 → 1
a=-2, n=3 → -8
a=e, n=1 → e ≈ 2.71828182846
a=0, n=5 → 0
a=0.5, n=2 → 0.25
a=0, n=0 → error UNDEFINED_POWER
a=0, n=-1 → error UNDEFINED_POWER
a=-2, n=0.5 → error NOT_REAL
a=10, n=400 → error RESULT_OVERFLOW
a=10, n=-400 → error RESULT_UNDERFLOW
empty a → error MISSING_REQUIRED_INPUT
solve_for=a, n=2, y=4 → principal 2, solutions ±2, warning TWO_REAL_SOLUTIONS
solve_for=a, n=3, y=-8 → -2
solve_for=n, a=2, y=1024 → 10
solve_for=n, a=1, y=1 → error INFINITELY_MANY
solve_for=n, a=1, y=2 → error NO_REAL_SOLUTION
solve_for=a, n=0, y=1 → error INFINITELY_MANY
Sources: NIST Digital Library of Mathematical Functions, Chapter 4 — Logarithm, Exponential, Powers
Supports: Real powers a^n, including negative exponents as reciprocals and fractional exponents as roots when the result is real
NIST DLMF §4.2 — Logarithm and the exponential as inverse operations
Supports: a^n = exp(n ln a) for a > 0; this engine uses that identity via IEEE-754 a**n / Math.exp, not a table
CalculatorX mathematical conventions — 0^0 undefined; negative base only with integer exponent
Supports: Matches the on-page real-arithmetic contract. solve_for=y is the scalar forward engine; a and n are published inverses of aⁿ = y with explicit multiplicity.
Calculation version: 1.0.4

Background

Interpretation and common distinctions.

What an exponent is

Exponentiation is written a^n with base a and exponent n. When n is a positive integer:

a^n = underbracea × a × ⋯ × a(n times), n ∈ ℤ(>0)

Example: 2^5 = 2×2×2×2×2 = 32.

For a positive base the real definition is

a^n = exp(n ln a), a > 0.

This calculator accepts negative bases for integer exponents, negative exponents, and fractional exponents in decimal form (for example 0.5 for ½). It does not return imaginary numbers.

Basic exponent laws

Rule	Law	Example
Product (same base)	a^n · a^m = a^(n+m)	2² · 2^4 = 2^6 = 64
Quotient (same base)	a^m / a^n = a^(m−n)	2² / 2^4 = 2⁻² = 1/4
Power of a power	(a^m)^n = a^(mn)	(2²)^4 = 2^8 = 256
Product to a power	(ab)^n = a^n b^n	(2·4)² = 2²·4² = 64
Quotient to a power	(a/b)^n = a^n / b^n	(2/5)² = 4/25
Negative exponent	a⁻ⁿ = 1/a^n	2⁻³ = 1/8
Zero exponent	a^0 = 1 (a ≠ 0)	7^0 = 1
One as exponent	a^1 = a	9^1 = 9
Root as fraction	a^(1/n) = ⁿ√(a)	9^(0.5) = 3

Argument for a^0 = 1: from a^n · a^0 = aⁿ⁺⁰ = a^n, the only consistent multiplier is 1.

Common pitfalls

Order of operations: exponents before multiply/divide.
(−3)² ≠ −3²: use parentheses for a negative base.
0^0 is undefined here (some contexts define it as 1 for convenience).
Negative base + non-integer exponent may be complex — this tool reports NOT_REAL instead of a fake real.

Graph sketch (base 2)

Plotting this calculator’s exponent n against result y for default base a = 2:

y = 2^n

As n → −∞, y → 0⁺
As n → +∞, y grows exponentially
At n = 0, y = 1 (shown on the Live graph as Reference (0, 1), not the current input)

The same qualitative shape holds for any base a > 1. For 0 < a < 1, a^n decays as n increases. Negative bases are omitted from this sketch (integer exponents only; the graph is not a continuous real curve).

CVP (Calculator Verification Protocol)

Math graph pilot under CVP 1.0 Proposed. Profile: core (unitless exponentiation, not an engineering model).

Evidence Manifest: /evidence/math.exponent/1.0.4.cvp.json
Reproduce: /evidence/math.exponent/reproduce — tabulated O3 inputs, expected values, generator, and re-run commands
Independent reference: O1 (NIST DLMF model) + O3 mpmath/MPFR expected values and numerical behavior + O2 live identities
Numerical policy: IEEE-754 binary64; ≤2 ULP vs O3 applies to the 6 published tabulated vectors ((2,10), (10,2), (5,0), (9,0.5), (2,−3), (e,1)). It is not a guarantee over all real bases and exponents..5), (2,−3), (e,1)); not a guarantee over all real bases and exponents; declared_before_evaluation=true
Cross-calculator (CVP-XCAL-01): ⁿ√(aⁿ) = a vs published Root for positive integer n; log₁₀(10ⁿ) = n vs Log; 10ⁿ = antilog(n, 10) vs Antilog; 9^{1/2} = √9 and √(2²) = 2 vs Square root.
Coverage: forward a^n, solve base a, solve exponent n, invalid domain, cross-calculator
Interfaces: UI (SSR), REST, and MCP must agree. A separate integration check covers URL → result → Live graph. ui-ssr is not a live browser session.
Versions stay distinct: calculation 1.0.4 · CVP Proposed 1.0 · evidence revision 2026-09-08.xcal. Adding verification does not by itself change the exponentiation algorithm.
Expert review is optional and is not required for CVP Verified.

Other calculators in this family: Antilog Calculator, Exponential Growth Calculator, Log Calculator, Natural Log (ln) Calculator, Root Calculator, Square Root Calculator . Explore all Powers, Roots & Logarithms.

}

Frequently asked questions

Key distinctions behind the calculation.

What is an exponent?