_xs_: collection
Evaluate to a product of all the elements in `collection`.
If all the elements are numbers, the result is a number. Otherwise it is a `["Multiply"]` expression.
```json example
["Product", ["List", 5, 7, 11]]
// ➔ 385
["Product", ["List", 5, "x", 11]]
// ➔ ["Multiply", 55, "x"]
```
Note this is equivalent to:
```json example
["Reduce", ["List", 5, 7, 11], "Multiply"]
```
_f_: function, _bounds_:tuple
Return the product of `body` for each value in `bounds`.
```json example
["Product", ["Add", "x", 1], ["Tuple", "x", 1, 10]]
// ➔ 39916800
```
_body_: function, ..._bounds_: Element
Evaluate to the product of `body` for each value in an Element-based indexing set.
This form uses `["Element", index, collection]` to specify that the index variable
iterates over a finite collection (Set, List, or Range).
```json example
["Product", "k", ["Element", "k", ["Set", 1, 2, 3, 4]]]
// ➔ 24 (4!)
["Product", ["Power", "k", 2], ["Element", "k", ["Set", 1, 2, 3]]]
// ➔ 36 (1² × 2² × 3² = 1 × 4 × 9)
```
See the `Sum` documentation above for details on supported collection types.
#### Simplification
When `simplify()` is called on a `Product` expression with symbolic bounds, the following closed-form formulas are applied when applicable:
| Pattern | Simplifies to | Name |
| :------ | :------------ | :--- |
| $$\prod_{n=1}^{b} c$$ | $$c^b$$ | Constant body |
| $$\prod_{n=1}^{b} n$$ | $$b!$$ | Factorial |
| $$\prod_{n=1}^{b} (n+c)$$ | $$\frac{(b+c)!}{c!}$$ | Shifted factorial |
| $$\prod_{n=1}^{b} (2n-1)$$ | $$(2b-1)!!$$ | Odd double factorial |
| $$\prod_{n=1}^{b} 2n$$ | $$2^b \cdot b!$$ | Even double factorial |
| $$\prod_{k=0}^{n-1} (x+k)$$ | $$(x)_n$$ | Rising factorial (Pochhammer) |
| $$\prod_{k=0}^{n-1} (x-k)$$ | $$\frac{x!}{(x-n)!}$$ | Falling factorial |
| $$\prod_{k=1}^{n} \frac{k+1}{k}$$ | $$n+1$$ | Telescoping product |
| $$\prod_{k=2}^{n} (1 - \frac{1}{k^2})$$ | $$\frac{n+1}{2n}$$ | Wallis-like product |
| $$\prod_{n=1}^{b} c \cdot f(n)$$ | $$c^b \cdot \prod_{n=1}^{b} f(n)$$ | Factor out constant |
Edge cases:
- Empty range (upper < lower): returns `1`
- Single iteration (upper = lower): substitutes the bound value and returns the body
#### Infinite Products
A `Product` over an **infinite** upper bound is evaluated exactly for these
known convergent families (staying symbolic otherwise):
| Product | Value | Name |
| :------ | :---- | :--- |
| $$\prod_{k=a}^{\infty} \left(1 - \frac{1}{k^2}\right), \; a \ge 2$$ | $$\frac{a-1}{a}$$ | Telescoping |
| $$\prod_{k=1}^{\infty} \left(1 - \frac{1}{(2k)^2}\right)$$ | $$\frac{2}{\pi}$$ | Wallis product |
| $$\prod_{k=1}^{\infty} \left(1 - \frac{1}{(2k+1)^2}\right)$$ | $$\frac{\pi}{4}$$ | Odd Wallis analog |
| $$\prod_{k=1}^{\infty} \left(1 + \frac{1}{k^2}\right)$$ | $$\frac{\sinh \pi}{\pi}$$ | From the $\sin$ product formula |
### Interpreting Elliptical Notation
_expr_
Give formal meaning to an **elliptical** sum or product — one written with an
ellipsis, such as $1 + 2 + \dots + n$ — by turning it into a `Sum` or
`Product`. A sum or product containing an ellipsis is otherwise an inert
notational object (see [Elliptical Notation](/compute-engine/guides/latex-syntax/#elliptical-notation)),
returned unchanged by `evaluate()`.
Interpretation is an explicit **opt-in**: a plain `evaluate()` never guesses.
The recognizer handles arithmetic progressions, polynomial general terms (via
finite differences), geometric patterns, and linear recurrences (via
Berlekamp–Massey and `RSolve`). The gate is strict by design — an ambiguous or
unproven pattern is returned unchanged rather than interpreted incorrectly.
```json example
["Interpret", ["Add", 1, 2, "ContinuationPlaceholder", "n"]]
// ➔ ["Sum", "k", ["Limits", "k", 1, "n"]]
["Interpret", ["Add", 1, 2, "ContinuationPlaceholder", 100]]
// ➔ a Sum that evaluates to 5050
["Interpret", ["Multiply", 2, 4, "ContinuationPlaceholder", ["Multiply", 2, "n"]]]
// ➔ ["Product", ["Multiply", 2, "k"], ["Limits", "k", 1, "n"]]
["Interpret", ["Add", 1, 1, 2, 3, 5, 8, "ContinuationPlaceholder", 55]]
// ➔ ["Sum", ["Fibonacci", "k"], ["Limits", "k", 1, 10]] (evaluates to 143)
```
Read more about **interpreting elliptical notation** and the recognizer families
### Transcendental Functions
| Function | Notation | |
| :----------- | :---------------------- | :------------------------------------------------------------------------------------------------------------------------- |
| `Exp` | $$\exponentialE^{x}$$ | [Exponential function](https://www.wikidata.org/wiki/Q168698). Applied to a matrix, broadcasts element-wise — it is **not** the matrix exponential $e^M$ |
| `Ln` | $$\ln(x)$$ | [Logarithm function](https://www.wikidata.org/wiki/Q11197), the natural logarithm, the inverse of `Exp` |
| `Log` | $$\log_b(x)$$ | `["Log", , ]`
Logarithm of base _b_, default 10 |
| `Lb` | $$\log_2(x)$$ | [Binary logarithm function](https://www.wikidata.org/wiki/Q581168), the base-2 logarithm |
| `Lg` | $$\log_{10}(x)$$ | [Common logarithm](https://www.wikidata.org/wiki/Q966582), the base-10 logarithm |
| `LogOnePlus` | $$\ln(x+1)$$ | |
See also **Trigonometry** for trigonometric functions
See also **Complex** for complex functions
See also **Statistics** for statistics functions and functions on lists
### Rounding
| Function | Notation | |
| :------- | :----------- | :---------------------------------------------------------------------------------------------------------------- |
| `Abs` | $$\|x\| $$ | Absolute value, [magnitude](https://www.wikidata.org/wiki/Q3317982) |
| `Ceil` | $$\lceil x \rceil $$ | Rounds a number up to the next largest integer |
| `Floor` | $$\lfloor x \rfloor$$ | Round a number to the greatest integer less than the input value |
| `Chop` | | Replace real numbers that are very close to 0 (less than $$10^{-10}$$) with 0 |
| `Round` | | |
### Other Relational Operators
_a_, _b_, _modulus_
Evaluate to `True` if `a` is congruent to `b` modulo `modulus`.
```json example
["Congruent", 26, 11, 5]
// ➔ True
```
### Other Functions
_value_
_value_, _lower_, _upper_
- If `value` is less than `lower`, evaluate to `lower`
- If `value` is greater than `upper`, evaluate to `upper`
- Otherwise, evaluate to `value`
If `lower`and `upper`are not provided, they take the default values of -1 and
+1.
```json example
["Clamp", 0.42]
// ➔ 1
["Clamp", 4.2]
// ➔ 1
["Clamp", -5, 0, "+Infinity"]
// ➔ 0
["Clamp", 100, 0, 11]
// ➔ 11
```
_x1_, _x2_, ...
_list_
If all the arguments are real numbers, excluding `NaN`, evaluate to the largest
of the arguments.
Otherwise, simplify the expression by removing values that are smaller than or
equal to the largest real number.
```json example
["Max", 5, 2, -1]
// ➔ 5
["Max", 0, 7.1, "NaN", "x", 3]
// ➔ ["Max", 7.1, "NaN", "x"]
```
_x1_, _x2_, ...
_list_
If all the arguments are real numbers, excluding `NaN`, evaluate to the smallest
of the arguments.
Otherwise, simplify the expression by removing values that are greater than or
equal to the smallest real number.
```json example
["Min", 5, 2, -1]
// ➔ -1
["Min", 0, 7.1, "x", 3]
// ➔ ["Min", 0, "x"]
```
_a_, _b_
Evaluate to the Euclidian division (modulus) of `a` by `b`.
When `a` and `b` are positive integers, this is equivalent to the `%` operator in
JavaScript, and returns the remainder of the division of `a` by `b`.
However, when `a` and `b` are not positive integers, the result is different.
The result is always the same sign as `b`, or 0.
```json example
["Mod", 7, 5]
// ➔ 2
["Mod", -7, 5]
// ➔ 3
["Mod", 7, -5]
// ➔ -3
["Mod", -7, -5]
// ➔ -2
```
_n_
Evaluate to a rational approximating the value of the number `n`.
```json example
["Rational", 0.42]
// ➔ ["Rational", 21, 50]
```
_numerator_, _denominator_
Represent a rational number equal to `numerator`over `denominator`.
_expr_
Return the numerator of `expr`.
Note that `expr` may be a non-canonical form.
```json example
["Numerator", ["Rational", 4, 5]]
// ➔ 4
```
_expr_
Return the denominator of `expr`.
Note that `expr` may be a non-canonical form.
```json example
["Denominator", ["Rational", 4, 5]]
// ➔ 5
```
_expr_
Return the numerator and denominator of `expr` as a sequence.
Note that `expr` may be a non-canonical form.
```json example
["NumeratorDenominator", ["Rational", 4, 5]]
// ➔ ["Sequence", 4, 5]
```
The sequence can be used with another function, for example GCD to
check if the fraction is in its canonical form:
```json example
["GCD", ["NumeratorDenominator", ["Rational", 4, 5]]]
// ➔ 1
["GCD", ["NumeratorDenominator", ["Rational", 8, 10]]]
// ➔ 2
```
### Random Numbers
The random operators take a **domain** to draw from, never a seed. Seeding is
done by wrapping the work in a `WithRandomSeed` block, which makes every draw
inside it reproducible.
| Function | Result |
| :----------------- | :----------------------------------------- |
| `WithRandomSeed` | evaluate an expression with a seeded block |
| `Random` | one draw |
| `RandomChoice` | `k` draws, with replacement |
| `RandomSample` | `k` elements, without replacement |
| `RandomShuffle` | a permutation |
**One draw, or `k` draws:**
| | one draw | `k` draws |
| :------------------- | :------------- | :------------------------ |
| with replacement | `Random(xs)` | `RandomChoice(xs, k)` |
| without replacement | `Random(xs)` | `RandomSample(xs, k)` |
| all of them | — | `RandomShuffle(xs)` |
`Random(xs)` and `RandomChoice(xs, 1)` have the same distribution: with a single
draw, "with" and "without" replacement coincide. The wrapper is the only
difference — `RandomChoice` returns a list.
_seed_: finite\_real | string, _body_: any
Evaluate _body_ with a random seed frame installed. Every draw inside the frame
is deterministic, and the whole block replays identically on re-evaluation,
while repeated draws **within** the frame still differ.
```json example
["WithRandomSeed", 42, ["Random"]]
// ➔ 0.7367300395263549 — the same value on every evaluation
["WithRandomSeed", 42, ["Delimiter", ["Sequence", ["Random"], ["Random"]]]]
// ➔ (0.7367300395263549, 0.4498528692283148) — two different draws,
// and the same pair every time
```
Outside a frame, draws are **live**: `["Random"]` on its own is
non-deterministic, which is what an animation or a ticker needs.
Frames nest and the innermost wins. Counters are per frame, so a nested frame
never disturbs its parent's later draws:
```json example
["WithRandomSeed", 1,
["Delimiter", ["Sequence",
["Random"],
["WithRandomSeed", 2, ["Random"]],
["Random"]]]]
// ➔ the first and third draws are the frame-1 stream's 1st and 2nd values;
// the inner frame does not shift them
```
Scoping is **dynamic**: the frame is active through calls to user-defined
functions, not just lexically inside _body_. The seed is evaluated once on entry
to the frame, not once per draw, and it may be a string
(`["WithRandomSeed", "'cell-a7'", …]`).
Seed a **row or cell**, not a whole document: with one document-wide frame,
inserting a draw near the top shifts every later value below it.
**A frame around a lazy collection does not make it replayable.** Only
evaluation consumes draw indices, and a lazy view is not evaluated until its
elements are read — by which time the frame has exited, so the draws escape it.
The expression *looks* framed and the failure is silent:
```json example
["WithRandomSeed", 12345,
["Comprehension", ["Random"], ["Element", "k", ["Range", 1, 6]]]]
// the elements draw LIVE (outside the frame), not the seeded stream:
// this instance: [0.9120…, 0.1273…, 0.4710…, …] ✗ NOT the framed values
// re-created (a fresh parse or evaluation): different values again
```
Reading the elements of the **same instance** twice does give the same values
— a lazy collection's elements are cached per instance, so one instance is
one draw set (two readers of the same list agree). But that is read
coherence, not replay: the values are live draws, and a re-created instance
draws fresh ones.
Materialize inside the frame, and it replays. `ListFrom` is the general form —
it works over any finite collection body — and indexing or a reducer will do it
too:
```json example
["WithRandomSeed", 12345,
["ListFrom",
["Comprehension", ["Random"], ["Element", "k", ["Range", 1, 6]]]]]
// ➔ the same six values on every evaluation ✓
// (identical to ["RandomChoice", ["Interval", 0, 1], 6] in the same frame)
```
Note that `["Repeat", ["Random"], n]` is eager and replayable but draws
**once**, yielding n copies of a single value — it is not a uniform batch.
The generator, the seed folding, the interpreted/compiled/GPU parity contract,
and how many draws each operator consumes are specified in the
**Randomness Model** note
_domain_: collection
`Random` is **not** a pure function: it carries the `random` effect and
evaluates to a different value on each evaluation. Wrapping it in
`WithRandomSeed` discharges that effect — the block as a whole is pure and
replays identically.
- `["Random"]` evaluates to a real number in the interval $[0, 1)$.
- `["Random", ["Interval", a, b]]` evaluates to a real number in $[a, b)$.
Open/closed endpoint markers are ignored: a floating-point draw cannot respect
an open endpoint.
- `["Random", ["Range", …]]` evaluates to an element of the range, which is
**inclusive** at both ends and normalizes reversed bounds
(`["Range", 7, 2]` descends).
- `["Random", xs]` evaluates to an element of the finite collection `xs`.
```json example
["Random"]
// ➔ 0.6233… (for example)
["Random", ["Range", 1, 6]]
// ➔ 4 (for example) — a die roll
["Random", ["Interval", -1, 1]]
// ➔ -0.318… (for example)
["Random", ["List", 5, 2, 10, 18]]
// ➔ 10 (for example)
```
The domain is never materialized: `["Random", ["Range", 1, 1000000]]` indexes
the range, it does not build it.
`Random` draws along the **first axis** of a non-flat domain, so
`["Random", ["List", ["List", 1, 2], ["List", 3, 4]]]` returns a *row*.
A `Tuple` is treated as an ordinary finite indexed collection and yields one of
its elements — deliberately unlike `Join`, where a tuple operand is a single
atomic element.
An unbounded or empty `Interval`, an infinite `Range` or collection, and an
empty collection are all errors.
_domain_: collection, _k_: number
Evaluate to a list of `k` independent draws from _domain_, **with
replacement**. Because each draw is independent, `k` may exceed the size of the
domain — that is what replacement means.
```json example
["RandomChoice", ["Range", 1, 6], 3]
// ➔ [4, 1, 4] (for example) — repeats are expected
["WithRandomSeed", 7, ["RandomChoice", ["Interval", 0, 1], 4]]
// ➔ a reproducible list of 4 reals in [0, 1)
```
`k` is typed `number`, not `integer`, so a computed count does not have to be
rounded by the caller; it is rounded on evaluation (half toward $+\infty$:
`2.5` → `3`, `-2.5` → `-2`). A negative or out-of-range count is an error, and
`k = 0` evaluates to the empty list.
Only the `k` drawn elements are materialized — the source domain is not, so
`["RandomChoice", ["Range", 1, 1000000000], 5]` is cheap.
_xs_: indexed\_collection, _k_: number
Evaluate to a list of `k` elements drawn from _xs_ **without replacement**.
"Without replacement" is over **positions**, not values. On a multiset, repeated
values are expected: `["RandomSample", ["List", 1, 1, 2], 2]` returns `[1, 1]`
in about a quarter of trials. It does not return distinct *values*.
Unlike `RandomChoice`, `k` may not exceed the size of `xs` — there are only that
many positions to draw. `k` equal to the size returns a permutation.
See **Statistics** for the full description of `RandomSample`
_xs_: indexed\_collection
Evaluate to a random permutation of the elements of _xs_.
See **Collections** for the full description of `RandomShuffle`
#### Migrating from the previous random operators
`RandomInteger`, `RandomList`, `RandomSeed`, `Sample` and `Shuffle` have been
removed, along with the `ce.randomSeed` property and every per-operator `seed`
argument. Each removed head throws an `operator-removed` error naming its
replacement for one release, so a stored document fails loudly rather than
silently stopping to randomize.
| Was | Now |
| :------------------------- | :-------------------------------------------------- |
| `Random(seed)` | `WithRandomSeed(seed, Random())` |
| `Random(n)`, $n > 0$ | `Random(Range(0, n-1))` |
| `Random(m, n)`, $m < n$ | `Random(Range(m, n-1))` |
| `RandomInteger(a, b)` | `Random(Range(a, b))` |
| `RandomList(n)` | `RandomChoice(Interval(0, 1), n)` |
| `RandomList(n, seed)` | `WithRandomSeed(seed, RandomChoice(Interval(0,1), n))` |
| `RandomSeed(s)` | `WithRandomSeed(s, …)` around the work |
| `Sample(xs, k)` | `RandomSample(xs, k)` |
| `Shuffle(xs)` | `RandomShuffle(xs)` |
| `Shuffle(xs, seed)` | `WithRandomSeed(seed, RandomShuffle(xs))` |
| `ce.randomSeed = s` | `WithRandomSeed(s, …)` |
Note the `-1` on the `Random(n)` and `Random(m, n)` rows: the old bounds were
upper-**exclusive** and `Range` is inclusive. The formulas hold only in the
ranges stated — degenerate old calls ($n \leq 0$, $m \geq n$) need rewriting by
hand, because `Range` normalizes reversed bounds into a descending range instead
of producing an empty one.
## Relational Operators
| Function | Notation | |
| :------------- | :--------------- | :------------------------------------------------------------------------------ |
| `Equal` | $$ x = y $$ | Mathematical relationship asserting that two quantities have the same value. Stays unevaluated when the answer is not known |
| `NotEqual` | $$ x \ne y $$ | |
| `Greater` | $$ x \gt y $$ | |
| `GreaterEqual` | $$ x \geq y $$ | |
| `Less` | $$ x \lt y $$ | |
| `LessEqual` | $$ x \leq y $$ | |
| `IdenticallyEqual` | $$ x \equiv y $$ | Assert an identity: the two expressions have the same value for **every** value of their free variables |
See below for additonal relational operators: `Congruent`, etc...
The three tiers of equality — `Same` (syntactic), `Equal` (same value) and
`IdenticallyEqual` (same value for every value of the free variables) — are
compared in
[Comparing Expressions](/compute-engine/guides/symbolic-computing/#comparing-expressions).
## Polynomial Arithmetic
These functions operate on polynomial expressions.
| Function | Description |
| :--------------------- | :--------------------------------------------------------------- |
| `Expand` | Expand products and positive integer powers |
| `ExpandAll` | Recursively expand products and positive integer powers |
| `Factor` | Factor an expression into irreducible factors |
| `Together` | Combine rational expressions into a single fraction |
| `Distribute` | Distribute multiplication over addition |
| `PolynomialDegree` | Return the degree of a polynomial |
| `CoefficientList` | Return the list of coefficients of a polynomial |
| `Polynomial` | Construct a polynomial from a coefficient list |
| `PolynomialQuotient` | Return the quotient of polynomial division |
| `PolynomialRemainder` | Return the remainder of polynomial division |
| `GCD` | Greatest common divisor of integers or polynomials |
| `PolynomialGCD` | Return the greatest common divisor of two polynomials |
| `Cancel` | Cancel common polynomial factors in a rational expression |
| `PartialFraction` | Decompose a rational expression into partial fractions |
| `Apart` | Alias for `PartialFraction` |
| `PolynomialRoots` | Return the roots of a polynomial |
| `Discriminant` | Return the discriminant of a polynomial |
_expr_
Expand out products and positive integer powers in `expr`.
```json example
["Expand", ["Power", ["Add", "x", 1], 2]]
// ➔ ["Add", ["Power", "x", 2], ["Multiply", 2, "x"], 1]
```
_expr_
Recursively expand out products and positive integer powers in `expr` and all subexpressions.
_expr_
_expr_, _var_
Factor a polynomial expression into a product of irreducible factors.
Supports:
- **Perfect square trinomials**: $ a^2 \pm 2ab + b^2 \to (a \pm b)^2 $
- **Difference of squares**: $ a^2 - b^2 \to (a-b)(a+b) $
- **Quadratic factoring**: $ ax^2 + bx + c $ (when roots are rational)
- **Rational root factoring**: Degree 3+ polynomials with rational roots (via Rational Root Theorem)
- **Content extraction**: $ 6x^2 + 12x + 6 \to 6(x+1)^2 $ (extracts GCD of integer coefficients first)
- **Common factor extraction**: $ 2x + 4 \to 2(x+2) $
The optional `var` parameter specifies which variable to factor over.
**Perfect square trinomial:**
```json example
["Factor", ["Add", ["Power", "x", 2], ["Multiply", 2, "x"], 1]]
// ➔ ["Power", ["Add", "x", 1], 2] // (x+1)²
```
**Quadratic with rational roots:**
```json example
["Factor", ["Add", ["Power", "x", 2], ["Multiply", 5, "x"], 6]]
// ➔ ["Multiply", ["Add", "x", 2], ["Add", "x", 3]] // (x+2)(x+3)
```
**Difference of squares:**
```json example
["Factor", ["Add", ["Power", "x", 2], -4]]
// ➔ ["Multiply", ["Add", "x", -2], ["Add", "x", 2]] // (x-2)(x+2)
```
A difference of squares is factored recursively, so a higher-degree input such
as $$ x^6 - 1 $$ is reduced all the way to its irreducible (cyclotomic) factors
rather than stopping at the first split:
```json example
["Factor", ["Subtract", ["Power", "x", 6], 1]]
// ➔ (x-1)(x+1)(x²+x+1)(x²-x+1)
```
The factors are always polynomials: `Factor` never introduces `Sqrt` or `Abs`
(e.g. $$ x^3 - 1 \to (x-1)(x^2+x+1) $$, not the branch-dependent
$$ (x\sqrt{x}-1)(x\sqrt{x}+1) $$).
**With coefficients:**
```json example
["Factor", ["Add", ["Multiply", 4, ["Power", "x", 2]], ["Multiply", 12, "x"], 9]]
// ➔ ["Power", ["Add", ["Multiply", 2, "x"], 3], 2] // (2x+3)²
```
**Cubic with rational roots:**
```json example
["Factor", ["Add", ["Power", "x", 3], ["Negate", ["Multiply", 6, ["Power", "x", 2]]], ["Multiply", 11, "x"], -6]]
// ➔ ["Multiply", ["Add", "x", -1], ["Add", "x", -2], ["Add", "x", -3]] // (x-1)(x-2)(x-3)
```
**Automatic use in sqrt simplification:**
```json example
["Sqrt", ["Add", ["Power", "x", 2], ["Multiply", 2, "x"], 1]]
// ➔ ["Abs", ["Add", "x", 1]] // |x+1| (auto-factors before applying sqrt rule)
```
_expr_
Combine rational expressions into a single fraction with a common denominator.
```json example
["Together", ["Add", ["Divide", 1, "x"], ["Divide", 1, "y"]]]
// ➔ ["Divide", ["Add", "x", "y"], ["Multiply", "x", "y"]]
```
_expr_
Distribute multiplication over addition in `expr`.
```json example
["Distribute", ["Multiply", "a", ["Add", "b", "c"]]]
// ➔ ["Add", ["Multiply", "a", "b"], ["Multiply", "a", "c"]]
```
_poly_
_poly_, _var_
Return the degree of the polynomial `poly` with respect to the variable `var`.
When `var` is omitted, it defaults to the single free variable of `poly`, or
to `x` when there are several free variables and one of them is `x`.
```json example
["PolynomialDegree", ["Add", ["Power", "x", 3], ["Multiply", 2, "x"], 1], "x"]
// ➔ 3
```
_poly_
_poly_, _var_
Return the list of coefficients of the polynomial `poly` with respect to the variable `var`, ordered from highest to lowest degree.
When `var` is omitted, it defaults to the single free variable of `poly`, or
to `x` when there are several free variables and one of them is `x`.
```json example
["CoefficientList", ["Add", ["Power", "x", 3], ["Multiply", 2, "x"], 1], "x"]
// ➔ ["List", 1, 0, 2, 1]
```
The result represents the polynomial $$ 1 \cdot x^3 + 0 \cdot x^2 + 2 \cdot x + 1 $$. The first element is the leading coefficient, and the last element is the constant term.
This function is also available as a method on expressions:
```javascript
const coeffs = ce.parse('x^3 + 2x + 1').polynomialCoefficients('x');
// ➔ [1, 0, 2, 1] (as BoxedExpression[])
```
When the variable is omitted, it is auto-detected if the expression has exactly one unknown:
```javascript
ce.parse('x^2 + 5').polynomialCoefficients();
// ➔ [1, 0, 5]
```
Returns `undefined` if the expression is not a polynomial in the given variable. This subsumes an `isPolynomial` check and degree computation:
```javascript
const isPolynomial = expr.polynomialCoefficients('x') !== undefined;
const degree = expr.polynomialCoefficients('x')?.length - 1;
```
**Multivariate validation:** Pass an array of variables to validate that the expression is polynomial in all of them. The coefficients are decomposed by the first variable:
```javascript
ce.parse('x^2*y + 3x + y^2').polynomialCoefficients(['x', 'y']);
// ➔ [y, 3, y²] (polynomial in both x and y, decomposed by x)
ce.parse('sin(x)*y + 1').polynomialCoefficients(['x', 'y']);
// ➔ undefined (not polynomial in x)
```
### `polynomialRoots()`
The `polynomialRoots()` method returns the roots of a polynomial expression:
```javascript
ce.parse('x^2 - 5x + 6').polynomialRoots('x');
// ➔ [2, 3]
ce.parse('x^3 - 6x^2 + 11x - 6').polynomialRoots('x');
// ➔ [1, 2, 3]
ce.parse('x^2 + 1').polynomialRoots('x');
// ➔ [] (no real roots)
ce.parse('sin(x)').polynomialRoots('x');
// ➔ undefined (not a polynomial)
```
Returns `undefined` if the expression is not a polynomial. Returns an empty array if no roots can be found (e.g., irreducible over the rationals). Supports auto-detection of the variable when omitted.
_coefficients_, _var_
Construct a polynomial expression from a list of coefficients (highest degree first) and a variable. This is the inverse of `CoefficientList`.
```json example
["Polynomial", ["List", 1, 0, 2, 1], "x"]
// ➔ ["Add", ["Power", "x", 3], ["Multiply", 2, "x"], 1]
```
This constructs the polynomial $$ x^3 + 2x + 1 $$ from the coefficient list $$[1, 0, 2, 1]$$.
**Round-trip with CoefficientList:**
$$\operatorname{Polynomial}(\operatorname{CoefficientList}(p, x), x) = p$$
_dividend_, _divisor_
_dividend_, _divisor_, _var_
Return the quotient of the polynomial division of `dividend` by `divisor` with respect to the variable `var`.
When `var` is omitted, it defaults to the single free variable of the
operands, or to `x` when there are several free variables and one of them is
`x`.
```json example
["PolynomialQuotient", ["Subtract", ["Power", "x", 3], 1], ["Subtract", "x", 1], "x"]
// ➔ ["Add", ["Power", "x", 2], "x", 1]
```
This represents $$ \frac{x^3 - 1}{x - 1} = x^2 + x + 1 $$.
_dividend_, _divisor_
_dividend_, _divisor_, _var_
Return the remainder of the polynomial division of `dividend` by `divisor` with respect to the variable `var`.
When `var` is omitted, it defaults to the single free variable of the
operands, or to `x` when there are several free variables and one of them is
`x`.
```json example
["PolynomialRemainder", ["Add", ["Power", "x", 3], ["Multiply", 2, "x"], 1], ["Add", "x", 1], "x"]
// ➔ -2
```
_x-1_, _x-2_, ...
Return the greatest common divisor of the arguments.
With integer arguments, `GCD` returns their integer greatest common divisor:
```json example
["GCD", 60, 12, 18]
// ➔ 6
```
`GCD` also computes the greatest common divisor of **polynomials**. When the
arguments are univariate polynomials in the same variable that share a
non-trivial common factor, the variable is inferred and a (monic) polynomial
GCD is returned:
```json example
["GCD",
["Add", ["Power", "x", 2], ["Multiply", 3, "x"], 2],
["Add", ["Power", "x", 2], ["Multiply", 4, "x"], 3]]
// ➔ ["Add", "x", 1]
```
This represents $$ \gcd(x^2 + 3x + 2, x^2 + 4x + 3) = x + 1 $$.
When the polynomial GCD would be a constant, the expression is left
unevaluated, so that a bare symbol keeps its integer-GCD reading — for example
`["GCD", "x", 6]` (where `x` may stand for an unknown integer) stays symbolic.
Use `PolynomialGCD` with an explicit variable when you want the coprime
→ `1` result, or to control which variable the GCD is taken over.
_a_, _b_
_a_, _b_, _var_
Return the greatest common divisor of two polynomials `a` and `b` with respect to the variable `var`.
When `var` is omitted, it defaults to the single free variable of the
operands, or to `x` when there are several free variables and one of them is
`x`.
```json example
["PolynomialGCD", ["Subtract", ["Power", "x", 2], 1], ["Subtract", "x", 1], "x"]
// ➔ ["Subtract", "x", 1]
```
This represents $$ \gcd(x^2 - 1, x - 1) = x - 1 $$.
_expr_
_expr_, _var_
Cancel common polynomial factors in the numerator and denominator of the rational expression `expr` with respect to the variable `var`.
When `var` is omitted, it defaults to the single free variable of `expr`, or
to `x` when there are several free variables and one of them is `x`.
```json example
["Cancel", ["Divide", ["Subtract", ["Power", "x", 2], 1], ["Subtract", "x", 1]], "x"]
// ➔ ["Add", "x", 1]
```
This represents $$ \frac{x^2 - 1}{x - 1} = x + 1 $$ after canceling the common factor $$(x - 1)$$.
_expr_
_expr_, _var_
Decompose a rational expression into a sum of simpler fractions (partial fractions) with respect to the variable `var`.
When `var` is omitted, it defaults to the single free variable of `expr`, or
to `x` when there are several free variables and one of them is `x` — so a
pipeline such as `expr |> Apart` works without naming the variable.
Supports:
- **Distinct linear factors**: $ \frac{1}{(x+1)(x+2)} \to \frac{1}{x+1} - \frac{1}{x+2} $
- **Repeated linear factors**: $ \frac{3x+5}{(x+1)^2} \to \frac{3}{x+1} + \frac{2}{(x+1)^2} $
- **Irreducible quadratic factors**: $ \frac{1}{(x+1)(x^2+1)} \to \frac{1}{2(x+1)} + \frac{-x+1}{2(x^2+1)} $
- **Improper fractions**: Performs polynomial division first, then decomposes the proper remainder.
Returns the expression unchanged if it is not a rational expression in `var`, or if the denominator cannot be factored.
```json example
["PartialFraction", ["Divide", 1, ["Multiply", ["Add", "x", 1], ["Add", "x", 2]]], "x"]
// ➔ ["Add", ["Divide", 1, ["Add", "x", 1]], ["Divide", -1, ["Add", "x", 2]]]
```
_expr_
_expr_, _var_
Alias for `PartialFraction`. Decompose a rational expression into partial fractions.
_poly_
_poly_, _var_
Return the roots of the polynomial `poly` with respect to the variable `var` as a set.
When `var` is omitted, it defaults to the single free variable of `poly`, or
to `x` when there are several free variables and one of them is `x`.
Returns `undefined` if the expression is not a polynomial or no roots can be found. Supports polynomials up to degree 4 with rational roots, and degree 2 with irrational roots.
```json example
["PolynomialRoots", ["Add", ["Power", "x", 2], ["Multiply", -5, "x"], 6], "x"]
// ➔ ["Set", 2, 3]
```
_poly_
_poly_, _var_
Return the discriminant of the polynomial `poly` with respect to the variable `var`. Supports degree 2, 3, and 4 polynomials. Works with symbolic coefficients.
- **Degree 2** ($$ax^2 + bx + c$$): returns $$b^2 - 4ac$$
- **Degree 3** ($$ax^3 + bx^2 + cx + d$$): returns $$b^2c^2 - 4ac^3 - 4b^3d + 18abcd - 27a^2d^2$$
- **Degree 4**: returns the full 16-term discriminant formula
```json example
["Discriminant", ["Add", ["Power", "x", 2], ["Multiply", -5, "x"], 6], "x"]
// ➔ 1
```
A discriminant of 0 indicates repeated roots. For quadratics, a negative discriminant indicates no real roots.