Mathematics

Math-aware maps, the Board, an interactive graph you can drive, and the Answer Guard.

When the conversation turns quantitative, Logos stops drawing a mind-map about the problem and starts drawing a map of the work: each state of the expression is a node, each operation an edge with the move written on it — −6 both sides, factor — so the solution reads as a chain. Math is written in real LaTeX everywhere it appears: the chat, the map, the Board, the node panels, the drafts.

A map of the work#

Eleven node types exist for this — givens, unknowns, equations, definitions, transformations, theorems, steps, inferences, verifications, results, and errors — with proofs chaining on implies and a theorem attaching to the step it licenses via justifies.

Four kinds of math moment#

The map also reads why the math is happening, because the right behavior differs:

Learning

You are working a problem to understand it. The Answer Guard engages — guidance toward the next step, never the full worked solution.

Verification

You did the work and want it checked. Logos finds the first step where it diverged, names exactly what went wrong there, and helps you repair that step — it never silently rewrites.

Utility

A quick calculation where teaching would be friction — “what’s 18% of 340”. It just computes it, plainly. No Socratic detour.

Exploration

Understanding a concept rather than solving an assigned problem. It explains, and describes functions so they can be seen.

The goal is never to withhold an answer artificially — only to avoid replacing reasoning you are trying to build. When in doubt between learning and utility, Logos assumes learning if a specific problem is being worked.

The Board#

The Board renders the same map as a worked-through notebook page: equations in a serif math face, operations and asides in a handwritten one, givens tagged given and unknowns tagged find across the top, the chain flowing down the page with hand-drawn arrows, theorems as margin notes beside the step they justify. Mistakes are struck through in rust with the fix written beneath — never erased — the result gets a hand-drawn box, and verified steps a handwritten check.

Every wobble and tilt is seeded from the node’s own id, so the board looks hand-made but never jitters between renders. Watch it work the demo problem — the sign slip goes down, stays down, and the fix arrives beside it:

The function plot#

When the map holds something graphable, the Plot lens draws it — up to four curves with a KaTeX legend. What counts as graphable is deliberately narrow: a single-variable expression with an actual operation in it (a bare x or 42 is not a curve), never an error node (a wrong line does not get drawn), and implicit multiplication like 2x or x sin(x) is understood.

The interactive graph#

A drawn curve tells you what a function looks like. It does not tell you what a derivative is. So when the work is about an idea rather than a picture, the Plot lens builds a scene: the same plot, plus one parameter you can move and watch the mathematics respond.

Below is the definition of the derivative, live in this page. Drag h toward zero, or press play. Two points on a curve, the straight line through them, and the moment that line stops being an average and becomes the slope at a point:

Nothing about that is a video. The readings under the plot are computed from the expression as you move the handle, the words to the right change as the picture does, and the whole thing is drawn with the same sandboxed evaluator described above — no plotting library, no eval().

The kinds of scene#

The renderer knows nothing about mathematics. It draws objects and runs a clock over one swept parameter; each kind decides what those objects are. That split is why the list grows without the drawing code changing.

function

A curve, with as many expressions on it as you care to add.

limit

Two readings closing in from either side, and whether they meet.

derivative

A secant becoming a tangent as the gap closes.

riemann

Rectangles narrowing under a curve toward the integral.

taylor

A polynomial gaining a degree at a time until it hugs the function.

sequence

Terms as stems, with the running total beside them.

vectors

Arrows, and everything a combination of them can reach.

matrix

A plane being transformed, with its eigenvectors held still.

distribution

A density, and the area under whatever interval you choose.

ode

A slope field, with a solution threaded through it.

Three more, live — a limit, a Taylor series, and an area:

Notice what the limit scene does not show. When both sides arrive at the same value, the one-sided limits are left out: three lines reading “2”, “2” and “2” make one point, and the two sample readings closing on each other are the visible evidence for it. Give it a jump discontinuity and the one-sided limits come back, because there they are the whole reason the two-sided limit does not exist.

And the same instrument, well outside calculus:

Anything else you can draw#

Every kind above is a named picture with code behind it that knows its subject. Most of what people want to see is not on that list and never will be — a titration curve, a free-body diagram, a cooling curve, a budget line, a project timeline, a dose–response curve.

So there is one more kind, and it is open. Ask for a picture of something drawable and Logos composes it out of the same pieces every other scene is made of: curves, points, segments, arrows, shaded regions, rules and labels, in whatever units the subject uses.

Two things make that cover most of a syllabus rather than a corner of one. A path is traced by a parameter rather than being a height above x, so a shape may close or double back — a Carnot cycle on a PV diagram, a hysteresis loop, a phase portrait, an ellipse. And max and min give you piecewise shapes without a conditional: a payoff floored at zero is max(0, x), a line that hits capacity is min(2x, 6), and a phase plateau is a sum of them.

It is deliberately not a fallback for mathematics: if what you are doing is a limit, you get the limit scene. And Logos will decline to draw rather than force something onto two axes that does not belong there — a subject with no shape gets a map of the thinking instead, which is the honest answer.

The window is yours#

Logos proposes the picture. What you do with it afterwards is not the model’s business, so the window and the scene are both yours to change:

• Scroll to zoom, drag to move. On a touch screen, pinch. The window is never written back into the scene — panning is a way of looking, not a change to the mathematics.
• From the keyboard. Tab to the plot and the arrow keys pan, + and − zoom, 0 fits. Double-click fits too.
• Edit what is shown. Change the expression, change the kind of scene, or add your own curves alongside Socria’s — they are drawn in their own colours so it stays obvious which marks are yours.
• Ask what a symbol means. Any reading with an explanation behind it is a button; pressing it says what the quantity is, never what it equals. That distinction is what makes it safe to answer while the guard is up.

Calculus, statistics, and beyond#

The quadratic above is deliberately small — but nothing about the machinery is tied to school algebra. The map’s mathematical vocabulary is domain-agnostic: the same eleven node types and the same chain edges carry college work unchanged.

• Calculus — a derivative or an integral is a chain like any other, each state becoming the next with the move written on the edge: pick u and dv, apply the rule, differentiate to check. The rule you invoked — by parts, the chain rule, a known limit — attaches to the step it licenses as a theorem in the margin, and the Plot lens graphs whatever function the work holds.
• Statistics — a hypothesis test maps its sample and its H₀ as givens, the question as the unknown, the t-statistic as the theorem justifying the standardizing step, and the verdict as the result. Confidence intervals and regressions take the same shape.
• Proofs and logic — proof steps chain on implies rather than transforms_to, with inference nodes for the deductions.
• Linear algebra and the rest — row operations, substitutions, unit conversions: anywhere the work is a sequence of justified moves, the map is a map of the work.

Two of those, on the real Board — including calculus’s most classic mistake, kept and repaired in place:

Everything on this page applies at every level: the intents read the same way (a problem set being checked is verification; a concept being explored is exploration), and the Answer Guard arms for learning-intent work whether the problem is a quadratic or an integral.

The Answer Guard#

The guard arms on one condition: the work is math and the intent is learning. Verification, utility and exploration are never guarded — those answers are what you asked for.

While armed, it is one shared state across every surface, so the chat cannot withhold an answer that the map, the Board, or a node panel quietly reveals. The chat behaves like an excellent lab instructor, climbing a six-rung ladder one rung at a time — observe, nudge, concept hint, specific hint, one minimal partial step, and only then the full solution. Pushed with “just tell me”, it gives the next-smallest hint and mentions the reveal button; it does not lecture, and it does not cave. On the map and the Board, the result and any verification of it are masked as = ? — the working stays visible, because the working is yours. The plot still draws your curve faithfully — and it never annotates roots, intercepts or extrema with their values, so it can never become the surface that hands over what the chat is withholding.

The bar under the chat says what is happening — “Guiding, not solving — you’re working this one out” — with two buttons: Another hint, and Show solution, which lifts the guard for that conversation and regenerates every surface with the results unmasked. The reveal is per-conversation, remembered, and never priced.