Using Math Tools

A detailed look at how to write calculations, read results, and get the most out of a Math Tools notebook. See Math Tools Help for how to open a notebook in the first place.

Writing a calculation

Structured input

Each cell accepts input in a structured computational notation — the same general style used by widely available symbolic-math and computer-algebra software, so if you've used one before, this will feel familiar. A few defining habits of the style:

Built-in function names are capitalized: Integrate, Solve, Simplify, Plot, D (for differentiation), and so on.
Arguments go in square brackets, not parentheses: Sin[x], not Sin(x).
Multiplication can be written with a space: Sin[x] Cos[x] means "Sin[x] times Cos[x]".
Lists/ranges use curly braces: {x, 0, 2 Pi} means "the variable x, ranging from 0 to 2π".

A few worked examples:

What you want	What you type
Integrate sin(x)cos(x) with respect to x	`Integrate[Sin[x] Cos[x], x]`
Differentiate x³ with respect to x	`D[x^3, x]`
Solve x² − 4 = 0 for x	`Solve[x^2 - 4 == 0, x]`
Simplify an expression	`Simplify[(x^2 - 1)/(x - 1)]`
Plot sin(x) from 0 to 2π	`Plot[Sin[x], {x, 0, 2 Pi}]`
Define a variable, then reuse it in a later cell	`myVar = 42` in one cell, then `myVar + 1` in the next

You don't need to memorize this notation up front — start with natural language (below) and use the structured form once you're comfortable, or as a way to fine-tune a result you got from a natural-language query.

If you already know a symbolic math package

If you've used a computer-algebra system before, this notation is intentionally close to the most widely used one in that space — most of what you already know will transfer directly.

Natural-language input

Instead of learning the structured notation, you can type a plain-English request into a cell, such as:

"integrate sin(x) times cos(x)"
"solve x squared minus 4 equals 0"
"plot sine of x from 0 to 2 pi"
"derivative of x cubed"

The notebook interprets your request in one of two ways:

Direct interpretation — the notebook's own built-in natural-language understanding parses your request locally and converts it to the equivalent structured form, shown to you as an "Interpreted as: ..." strip before running it. This happens without sending your query to any external AI or cloud service — it's handled entirely by the same local computation engine that runs your cells.
"Retry with AI" fallback — if direct interpretation doesn't understand your query (this can happen more often with longer or more ambiguous phrasing), a Retry with AI option appears. This uses an AI language model to translate your natural-language request into the structured notation above. The translated code is placed into the cell for you to review — it is never run automatically. Look it over, edit it if needed, and run it yourself when you're satisfied it says what you meant.

Always review AI-translated input before running it

Like any AI translation, the "Retry with AI" fallback can occasionally produce code that doesn't quite match your intent, especially for ambiguous or multi-part requests. That's exactly why it lands in the cell for you to check first, rather than running immediately — treat it the same way you'd treat any AI-generated answer: useful, but worth a second look before you trust it.

Direct interpretation can occasionally fail outright on a query it would normally understand (an inherent quirk of natural-language interpretation, not a bug) — if that happens you'll see a clear "couldn't interpret this" message rather than a confusing error, and the "Retry with AI" option is always available as a fallback.

Reading your results

Results appear directly below the cell you ran. A few things worth knowing:

Plain results display as-is, exactly as computed — a number, a simplified expression, a solved equation, etc.
Plots and graphics (Plot[...], Plot3D[...], Graphics[...], and similar) render as real images inline in the notebook. Click any image to open a full-size view.
Some exact results look unusual on purpose. Certain calculations (e.g. the roots of a polynomial with no simple closed-form solution) have a genuinely complex exact form — the notebook shows this exactly as computed rather than approximating it, since an approximation would be a different, less precise answer. If you'd prefer a decimal approximation, ask for one explicitly (e.g. wrap your expression to request a numeric result).
Animated/interactive controls are not supported — a calculation that would normally produce an interactive, adjustable plot instead renders as a single static image (a snapshot at default settings). This is a known, accepted limitation of running through a lightweight notebook interface rather than a full desktop application, not something currently being worked around.

Session continuity

Cells within the same notebook share state — a variable or function you define in one cell remains available in every cell you run afterward in that notebook. This lets you break a calculation into logical steps instead of writing one giant expression. Opening a different notebook starts a fresh, independent session — it does not see variables from any other notebook.

Common issues

Symptom	What's likely going on
A result comes back blank or looks like an error with no real content	The computation engine occasionally needs a moment after being idle for a while — wait a few seconds and re-run the cell. Persistent blank results are worth reporting to support.
A polynomial/root result looks like a complicated symbolic expression instead of a clean number	Expected behavior for exact roots with no simple closed form — see "Reading your results" above.
Natural-language input misunderstands a clearly-worded query	Occasional natural-language interpretation quirks are expected — try rephrasing more simply, or use "Retry with AI".
A plot doesn't animate/respond to controls	Interactive plots aren't supported — you'll get a static snapshot image instead. This is expected, not a bug.

Still stuck? See Math Tools Help for access-related issues, or email support@examcatalyst.ai with the cell content that didn't behave as expected.