Available question types¶

Each type has one section here, in alphabetical order, holding everything there is to say about it: the shapes it can ask, the sources a line must give it, what steps has it show, the options it reads on top of the common ones, and whatever else is worth knowing. The three sections below come first because they belong to no type in particular — the options every type reads, steps, and the wording variant the operation types share.

Options every type reads¶

Written on the line, behind its -- separator (see Question specs). Every type reads these five; what a type adds to them is listed in its own section, and an option no type reads at all is refused by check qspec as well as at render time.

The steps option¶

Every question type reads steps the same way: a level from 0 — the answer alone, and the default everywhere — up to the highest one the type knows how to show. steps=true and steps=false are accepted too, and mean 1 and 0. Above 0 the answer spells the calculation out.

The option shapes the sheet. A correction slide always answers at level 0, whatever the line asked for: a slide is read from the back of the room, in the seconds before the next one, so it shows the result and leaves the detail to the help button.

Types that show steps, all at level 1:

A level above what a type can show is capped, not refused: asking for more detail than a type has is asking for all of it. So steps=3 on expand_simple means steps=1, and multi_direct 2-9×2-9 -- steps=1 asks for nothing at all — 6 × 7 has nothing to explain that its answer does not already say. That is what lets a mixed block carry the option for the types that use it, without the others turning it down. Only what is not a level at all is refused — a negative, a word — by check qspec as well as at render time.

Two of those rows depend on the line rather than on the type alone: scale gives multi_direct zeros to explain, and variant=wording gives the four operation types the operation their sentence names. The same steps=1 that asks for nothing on a plain product then has something to spell out. square_of and cube_of are the exception among the worded types: their step belongs to the type, and is there on the plain form too.

Leaving steps at 0¶

Leave it at 0 on a mental-calculation sheet. On the live page (render html --interactive) the answer key then carries a small ⓘ button next to each such answer, opening the whole calculation in a modal: the printed sheet keeps the bare result the exercise asks for, and the reasoning is one click away for whoever wants it. Raising steps puts those very lines in the answer itself, and the button disappears — there is nothing left to show. The button never prints, and the static page has none.

A slideshow does the same, from its own controls: a correction slide whose type has steps carries a discreet Steps button at the bottom right, opening the same chain in a panel (see slideshows). A slide answers at level 0 whatever steps asked for — it is read from the back of the room, in the seconds before the next one — so the button is there on every correction of a type that has steps.

The wording variant¶

The four operation types can ask their question as a sentence rather than as an expression, with -- variant=wording:

Same operation, same numbers, same answer — only the way the question is put changes. That is what distinguishes it from multi_vocab and divi_vocab, where the word replaces an operand (double 7, a third of 21) and the source has to supply the 2, 3 or 4 the word stands for. square_of and cube_of offer the same variant — What is the square of 8? — and follow everything below; what is specific to them is described under square_of.

subtr_direct words the same subtraction two further ways, as the complement it computes: variant=to_reach — What number must be added to 37 to make 100? — and variant=complement — What is the hundreds complement of 37? Both are sentences like the rest and follow everything below, except that they imply result=positive; what is specific to them is described under subtr_direct.

addi_direct tells its addition a further way, as a mini-problem: variant=story — Our neighbours have 47 sheep. We have 28 more sheep than they do. How many sheep do we have? It is described under addi_direct.

A line can mix the two forms: multi_direct 2-9×2-9 -- variant={default|wording} draws the form of each of its questions independently.

What the variant changes¶

The answer goes underneath. A sentence has no ? for the answer to take the place of, so answer_layout defaults to below instead of inline. An explicit answer_layout=inline on the line still wins.

The question is given more time, since a sentence is read through before it is computed:

An explicit transduration= still wins, and an option that already asked for more time is not added to — multi_direct 2-9×2-9 -- variant=wording scale=1-3 stays at 24 s, the longer of what the zeros and the sentence are worth.

The question gains a step. A worded question can show the operation its sentence names, which is the whole of what it was testing:

Produit de 7 par 8 ?     →  answer: 56
                            ⓘ        7 × 8 = 56

At steps=0 — the default — the answer key shows 56 alone and keeps the line above behind its ⓘ button, a correction slide behind its Steps button. steps=1 puts it in the answer itself. The plain form has no such step: its wording already is the operation.

Where the answer is drawn rather than written — the fraction of divi_direct fractions — the step draws it the same way: Quotient de 3 par 4 ? opens on 3 ÷ 4 = 3/4 (ou 0,75). square_of and cube_of go one level further, and have their step on the plain form too — see square_of.

A worded multi_direct carrying scale keeps the longer chain of the zeros, which already opens on the multiplication.

Everything else is untouched: the sources, carry, result, min_result, max_result, shuffle and scale behave as they do without the variant. So subtr_direct still orients its pair at random, and the sentence names the two terms in that order — Difference between 52 and 37? is 52 − 37. Where negative differences are not wanted, say so with result=positive or min_result=, exactly as for the plain form.

A misspelt variant is refused by check qspec and at render time: it would otherwise fall back silently on the default form, and the mistake would only show on the printed sheet.

Three terms and more: the preposition comes back¶

Past two terms, the sentence repeats the preposition of the operation before each of them rather than listing them behind a single one:

Somme de 4, de 5 et de 9 ?          not:  Somme de 4, 5 et 9 ?
Produit de 4 par 5 et par 9 ?       not:  Produit de 4, 5 et 9 ?

The reason is the decimal comma. Somme de 4, 5 et 9 ? is read by a pupil as the sum of 4,5 and 9, and answered 13,5 — a right answer to the wrong question. The repeated de / par makes the reading impossible.

Two terms keep the shorter sentence — Somme de 14 et 18 ?, Produit de 6 par 7 ? — since with nothing between the numbers but the conjunction there is no list to read wrong, and a shorter question is a question read faster.

Which word comes back is part of the translation, not of the code: the two templates a list is folded with are translated strings, so a language whose decimals need no such precaution can join its terms plainly.

addi_direct¶

Addition.

Sources — one source per term, or a product range giving several at once — 10-99 10-99, 2-9 2-9 2-9, 10-99×10-99; or one time range per term — 8h-17h30[5min] 10min-2h[5min]; or clocktimes alone, a departure and a duration drawn in a frame.

Steps — none on the plain form; one level under variant=wording, on the operation the sentence names.

Options — these, on top of the ones every type reads:

What follows holds for subtr_direct as well: the two types read their sources, frame their result and count their carries the same way, and are described here together.

Both read their numbers from the sources in the order they are written, one source giving as many terms as its width:

An addition adds up between two and six terms — six is a hexagon's perimeter, past which the sides are equal and the sum is a product. A subtraction takes exactly two numbers, and check qspec says so when the sources give anything else.

Two independent sources are usually the better choice: each term gets its own range, and no pair is ever spent — a product range never draws the same pair twice, which is a constraint a sum does not need. What a product range brings instead is the anti-repeat tracking of the pairs table, shared with the neighbouring multi_direct questions. Two singleton ranges share the singletons table the same way.

With a single pair range, the two values are oriented at random, and by the constraints when there are any: a pair range holds (38, 47) and never (47, 38), so a subtraction reading it as it comes would forever take the larger from the smaller.

carry — with or without a carry¶

carry=false draws an operation no column carries, carry=true one where at least one column does. For a subtraction, that carry is the borrow.

(6) addi_direct 10-99 10-99 -- carry=false
    →  42 + 37 = ?
(6) addi_direct 10-99 10-99 -- carry=true
    →  46 + 29 = ?
(6) subtr_direct 10-99 10-99 -- result=positive carry=true
    →  95 − 76 = ?

The columns are read on the digits, as they are written by hand, and decimals are aligned on the finest precision among the terms first: 0.1-9.9 0.1-9.9 -- carry=false draws 8,2 + 1,3 and never 7,7 + 2,5, whose tenths carry. The option works the same across three terms or six: a column carries when its digits sum above nine.

Left out, the option constrains nothing and both kinds come up.

result, min_result and max_result — framing the answer¶

result=positive and result=negative say what they say in order_of_2ops, and result=positive is exactly min_result=0 — a null difference is a legitimate subtraction. Nothing constrains the result by default, so subtr_direct 10-99 10-99 draws 33 − 91 as readily as 56 − 16; for the grades where negative numbers are not taught yet, say so:

(10) subtr_direct 10-99 10-99 -- result=positive

min_result and max_result frame it more closely, and both work on the addition too:

(6) addi_direct 10-99 10-99 -- max_result=100      stay under a hundred
(6) subtr_direct 10-99 10-99 -- min_result=10      a two-digit answer

carry=false and result=negative are refused together: taking a number from a smaller one always borrows somewhere.

result — naming the answers outright¶

Written as a numrange rather than as a sign, result names the results allowed and no others. That is how a target which varies from question to question is said, the complement to a round hundred above all:

(10) addi_direct 10-990[10][^100] 10-990[10][^100] -- result=300-1000[100]
     →  140 + 660 = ?      530 + 170 = ?      320 + 680 = ?

Each question lands on one of the eight round hundreds from 300 to 1000, and the [^100] keeps a term from being one of them — 300 + 400 is not the exercise. A single value is the short way to pin it: result=1000 says min_result=1000 max_result=1000.

The numrange must draw single numbers, one result being what an operation comes out at, and it may list at most a hundred of them. Past that it is an interval, which min_result and max_result state exactly:

addi_direct 10-99 10-99 -- result=1-500
→  result=1-500 lists 500 results; past 100 it is an interval, which
   min_result= and max_result= state exactly.

A bound written beside the set narrows it rather than overriding it, and one that leaves nothing is refused like any other contradiction.

What the constraints do to the draw¶

They bear on the combination, not on any single number, so they cannot be pushed down into a source. Each draw is instead narrowed to the values the remaining sources can still complete: nothing is ever produced outside a declared range, and a first term never corners the draw — addi_direct 2-9 2-9 2-9 -- carry=false will not open on a 9, which no two terms above 2 could follow.

A constraint no combination satisfies is an error, and automath check qspec reports it before anything is rendered:

subtr_direct 2-9 2-9 -- min_result=10
→  no combination of '2-9', '2-9' satisfies min_result=10.
   Widen a source, or relax the constraint.

One that leaves very little is a warning instead — the sheet would keep asking the same few questions. Beyond a hundred thousand combinations the spec is reported without a feasibility verdict, and an impossible one then raises while rendering, with the same message.

A source that is not a numrange — a content table, an alternator — cannot be narrowed, so the constraints refuse it. Without them it draws as usual.

Times — durations and times of day¶

Sources written with units are time ranges, and the two types then add and subtract times instead of numbers:

A time of day and a duration are not told apart: they add and subtract alike, so nothing in the line has to say which is which. Every source of the line must be a time range — one mixing times and numbers is refused.

Values are written as a clock writes them: every unit after the first on two digits, and the units holding nothing left out at both ends — 8 h 05 min, 45 min, 2 h.

The answer is typed one unit at a time, in a box per unit: … h … min. The boxes run from the largest unit the sources write down to the finest one their values need, and every one of them is drawn, the hours included where the answer has none — leaving a box out would give the answer away, and a box per unit is what makes the pupil answer in the units asked for. A box left empty counts as zero; a number of minutes or seconds past 59 is refused, the unit above being there to hold it. units names another span — h_min, min_s, h_min_s, or a single unit:

(6) addi_direct 30min-50min[5min] 30min-50min[5min]                → … min
(6) addi_direct 30min-50min[5min] 30min-50min[5min] -- units=h_min → … h … min

A span may start higher or lower than the sources; it may not stop above the finest unit a value needs, which could then not be answered in it.

The options read the same way, in time:

• carry=true asks for sixty minutes to be made into an hour — or, for a subtraction, an hour to be borrowed as sixty minutes; sixty seconds and a minute likewise. A span starting at the minutes has no hour to carry into: 40 min + 35 min is then a plain 75 min.
• min_result, max_result and result are written as times — max_result=12h, result=1h-3h[15min] — and result=negative is refused: no time is.
• No result crosses midnight: a time stays under 24 h unless max_result lets it go further, so 22 h 40 min + 3 h 20 min is never drawn by default. A difference is never negative.

clocktimes — times drawn in a frame¶

clocktimes, written alone where the sources go, frames the draw for you: it draws a departure and an arrival that belong together, and the addition asks the departure plus the duration, the subtraction the arrival less the departure.

(5) addi_direct clocktimes      →  14 h 35 min + 1 h 50 min = ?
(5) subtr_direct clocktimes     →  11 h 15 min − 8 h 40 min = ?

The departure is never on the hour, and the arrival never has the minutes of the departure — the duration would be a whole number of hours. And the operation carries by default: the minutes of the arrival are drawn below those of the departure, so that the addition makes sixty minutes into an hour and the subtraction borrows one. carry=false asks the other way round.

The times are drawn in a broad frame of the day — a departure from 5 h to 22 h 30 min, a duration from 9 min to 8 h 30 min, an arrival before 23 h 59 min — every step minutes: 5 by default, which keeps the calculation within reach of mental work, and 1 for any minute. The step must divide the hour: 1, 2, 3, 4, 5, 6, 10, 12, 15, 20 or 30. The same times told as a story — a film, a bus journey, a cake in the oven — are mini_pb_time.

The frame is what bounds the draw, so result, min_result, max_result and units are refused beside clocktimes — the answer is in hours and minutes — and so is any other source: write time ranges to frame the draw yourself.

Shuffling, and the rest¶

addi_direct shuffles its terms, so addi_direct 100-999 2-9 asks 7 + 342 as well as 342 + 7; -- shuffle=false keeps the order of the sources. On a line of times the order of the sources is kept by default — the time of day first, the duration added to it after — and -- shuffle=true shuffles them. subtr_direct has no such option, its order being what the question means.

Neither type has steps to show, both answer inline, and both default to 20 s per question — 30 s on a line of times, sum or difference alike — see The wording variant for what variant=wording changes to the last two.

variant=story — the addition told as a mini-problem¶

addi_direct can also tell its addition as a short story, with -- variant=story:

(4) addi_direct 11-99 11-99 -- variant=story
    →  Nos voisins ont 47 moutons. Nous avons 28 moutons de plus qu'eux.
       Combien de moutons avons-nous ?
    →  Jules a lu 23 pages de son livre ce matin, et 35 de plus cet
       après-midi. Combien de pages a-t-il lues aujourd'hui ?

The operation is still an addition of two numbers drawn from the sources, and the answer is still their sum: the story only dresses it up. Finding which operation a story calls for is another exercise, the one mini_pb_time sets with times.

Each story has its own bounds. Eggs laid in a day are counted in tens, a gardener's lettuces in tens too, a number of marbles may run into the hundreds. The story is taken first, among those the ranges of the line can tell, and the two numbers are then drawn inside both the ranges and the story's bounds. So addi_direct 2-99 2-99 -- variant=story tells the gardener planting 12 and 7 lettuces as well as the neighbours' 85 sheep, but never 85 lettuces. The ranges keep deciding how hard the addition is, the story keeps it plausible.

Lines that tell well. Any pair of numranges will do as long as some story fits them, but a few lines suit mental arithmetic and leave the sheet many stories to choose from:

[^1] keeps whole numbers out of a decimal range: without it, 1.1-9.9 also draws 4 or 7, and the sheet mixes counts in among the measures. By halves, [0.5], an elephant drinks 39,5 L, not 39,6 L: precise enough to practise, and plausible. Better not mix sizes in one range: 11-1000[5] draws two numbers under 100 often enough to make many of the sums too easy — write two lines instead.

The stories come in turn, a theme at a time. They are grouped in broad themes — animals, cooking, everyday life, family and friends, fantasy, harvest, leisure, space, sports — and a sheet goes through the themes before coming back to one, then through the stories of each theme: a wizard is not followed by a dragon, nor two stories of a theme told one after the other, and a story just told keeps clear of the next eight questions — as long as the line can tell enough others. Some stories are told in several versions, the one told last time never coming again at once: the baker bakes croissants, baguettes, loaves or brioches, it rains on two days of the week that follow each other, the squirrel hid hazelnuts, walnuts or acorns.

Two numbers, from numranges. A story tells exactly two numbers, and its bounds can only be compared with numranges: three sources, a content table, or time ranges are refused — a story about times is mini_pb_time. A story about a measure has its answer typed with the unit printed beside the box. Only some of them are told with decimals, and with no more decimal places than they make sense with: a hike of 12,5 km, a bag of 3,8 kg, a height of 1,39 m — but no ride of 47,3 km, a precision nobody tells. Most of these are told with whole numbers too, a height in metres only with decimals — 1.00-1.70 0.01-0.12 is the line it needs. A story about money writes its prices to the cent — 3,60 €, never 3,6 € — and a whole price without any: une tarte à 12 €; 12 + 3,60 = 15,60 mixes both, as a shop does. A pupil who types 15,6 has the right answer all the same. A price finer than the cent (8,208 €) is rounded with a warning, or otherwise as the prices.finer_than_cent setting says (see the configuration). A story about a count never gets a decimal number, and says what it counts in small grey words under the box — (billes), (œufs), (glands) — the word following the version told. A slide, which has no box, writes the word after the number: 75 billes.

Some stories only take multiples of a number, as they are in real life: a cake's flour, sugar and butter are weighed by fives of grams. Whatever the line starts at, the numbers are then multiples of five — addi_direct 11-99 11-99 -- variant=story mixes 15, 20 or 85 g of flour, never 11, 16 or 99.

The other options still apply, on top of the story: carry=true, max_result=100 and the rest constrain the draw as they do without it. By default either source can give either number of the story; shuffle=false gives the first source to the first number the story tells.

When no story fits the line, automath check qspec says so before anything is rendered. When only one or two fit, it warns that the sheet will keep telling them:

addi_direct 2000-3000 2-9 -- variant=story
→  no story can be told with the numbers of '2000-3000', '2-9'. Choose other
   ranges, e.g. "addi_direct 2-20 2-20 -- variant=story".

Like the wording variant, a story writes its answer underneath. It gets 30 s on a slide, and one step: steps=1 (or the ⓘ button) writes out the addition, 47 + 28 = 75. The first names it uses follow the language of the render, and in French a story elides before the names that call for it: plus qu'Emma, le chat d'Hugo, but plus que Léa. A story never leaves its question mark alone at the start of a line (French sets a narrow no-break space before it), nor a number apart from its unit — 23 mL stays on one line.

addi_hole¶

Addition with a missing term.

Sources — one source per term, or a product range giving several at once — 10-99 10-99, 2-9 2-9 2-9, 10-99×10-99; the sum is worked out from them.

Steps — one level: steps=1 writes out the subtraction the missing term is recovered by.

Options — these, on top of the ones every type reads:

step is refused here: a hole is not asked on times: its sources are numbers.

units is refused here: a hole is not asked on times: its sources are numbers.

What follows holds for subtr_hole as well: the two types draw their numbers, place their hole and frame their result the same way, and are described here together.

What the sources give, and what is worked out¶

The sources give the terms of the operation, exactly as they do for addi_direct and subtr_direct — same notation, same number of them, same anti-repeat tracking. What the question shows after the = is then worked out from them, and the hole takes the place of one of the terms:

The consequence worth keeping in mind: the hidden number is always one of the numbers a source drew, never the one that was worked out. addi_hole 10-99 10-99 asks for a two-digit number and nothing else, and the kind of numbers in play — whole, decimal, multiples of 5 — is settled by the sources alone: addi_hole 0.1-9.9 0.1-9.9 asks ? + 7,9 = 13,6.

hidden — which number the hole falls on¶

Left out, the hole is drawn afresh for each question. Given, it is fixed: addi_hole counts the terms from 0 in the order they are displayed (after the shuffle), subtr_hole names them.

(6) addi_hole 27 48 -- shuffle=false hidden=0
    →  ? + 48 = 75
(6) subtr_hole 100-999 10-99 -- hidden=minuend
    →  ? − 63 = 495
(6) subtr_hole 100-999 10-99 -- hidden=subtrahend
    →  558 − ? = 495

For subtr_hole the choice is not cosmetic: a missing minuend is found by an addition, a missing subtrahend by a subtraction. Leaving hidden out mixes the two, which is usually what a mental-calculation sheet wants.

What the constraints frame¶

carry, result, min_result and max_result say exactly what they say on addi_direct and subtr_direct, and they bear on the operation between the drawn terms — so min_result and max_result frame the number the question shows after the =, not the answer expected. The answer needs no framing: it is drawn, so its own source already frames it.

carry is the report of that same operation, which is also what the pupil runs into: 27 + 48 carries in the units exactly where 75 − 48 borrows, so carry=false gives a sheet nothing is carried on, hole or no hole.

(10) addi_hole 10-99 10-99 -- carry=false max_result=100

Every number of the line positive¶

Since the hidden number is a drawn one, the only number that can come out negative is the difference subtr_hole shows — 29 − ? = −26 is what 10-99 10-99 draws when the subtrahend outgrows the minuend. result=positive is therefore all it takes for every number of the line to be positive, whichever term the hole falls on:

(10) subtr_hole 10-99 10-99 -- result=positive
     →  77 − ? = 41,  ? − 23 = 41

addi_hole needs nothing of the sort: a sum of positive terms is positive, and so is each of its terms.

Written out, negative numbers keep the reading a hand would give them: a number taken away carries its own sign into brackets, 37 − (−15) = 52.

steps — the operation that fills the hole¶

steps=1 writes the calculation the missing number comes out of, which is the whole of what these questions test:

addi_hole 27 48 -- hidden=0        →  75 − 48 = 27
addi_hole 2 3 4 -- hidden=1        →  9 − 2 − 4 = 3
subtr_hole 52 37 -- hidden=minuend →  15 + 37 = 52
subtr_hole 52 37 -- hidden=subtrahend  →  52 − 15 = 37

Left at 0 — what mental calculation asks for — the answer key shows the number alone and keeps that calculation one click away, behind its ⓘ button.

The rest¶

Both answer inline, in place of the ?, and both take 20 s on a slide. addi_hole shuffles its terms like addi_direct, and -- shuffle=false keeps the order of the sources; subtr_hole has no such option, the order of a subtraction being what the question means. Neither type has a variant: variant=wording belongs to the direct forms.

area_rectangle¶

Area of a rectangle, its length and its width written on the figure.

Sources — one product range of two unequal values — 2-9×2-9; the bigger of them is the length.

Steps — one level, the product written out with its units.

Options — these, on top of the ones every type reads:

area_rectangle asks for the area of a rectangle whose two dimensions are written on the figure:

(8) area_rectangle 2-9×2-9
     →  [a 7 cm × 4 cm rectangle]  Aire de ce rectangle ?      answer: 28 cm²

The wording is the figure: a rectangle drawn with rect{}, its four right angles coded, its length written above it and its width to its right. Where the sentence goes is the one thing the two documents disagree on — beside the figure in a worksheet grid, where a line of height is a line the eleven other questions lose, above it on a slide, where the figure has the screen to itself.

The source gives the two dimensions¶

One source, a product range — the same kind multi_direct multiplies:

(8) area_rectangle 2-9×2-9                   from the times tables
(8) area_rectangle 2-12×2-12 -- unit=m
(8) area_rectangle 10-90[10]×2-9 -- unit=cm  a round dimension and a small one

The bigger of the two values drawn is the length, so the side that looks longer is the one carrying the bigger number. The figure is not drawn to scale — how big it is drawn is a matter of layout, see Polygons — but it is not to be read against either.

Pairs of equal values are left out of the draw: a square is a rectangle, yet the figure cannot say so, since a grid figure is drawn lying down whatever it is labelled — 6 cm × 6 cm on a shape twice as wide as it is tall would be read as a mistake. A source holding nothing else (5×5) is refused by check qspec.

unit — the same length for both dimensions¶

unit is the unit both dimensions are given in, cm by default. Any unit of the metric length ladder is accepted (mm … km), and the group notation draws one per question:

(8) area_rectangle 2-9×2-9 -- unit=m
(8) area_rectangle 2-9×2-9 -- unit={cm|m|mm}

The area is then asked for in the square of that unit — no trap: a rectangle measured in cm has its area asked in cm².

carry, scale and decimals — which multiplication it is¶

Under the figure there is a multiplication, and the three options that say which multiplication on multi_direct say it here too, read exactly as they are read there — on the two values the source draws.

carry narrows the draw to the dimensions whose product carries, or to those whose product does not:

(8) area_rectangle 11×11-99 -- carry=false unit=mm
     →  [11 mm × 27 mm]      →  [11 mm × 45 mm]

scale and decimals lay powers of ten on the dimensions — the zeros of the one, the ranks of the other — so that a table fact becomes a rectangle of another size, measured in the same unit:

(8) area_rectangle 2-9×2-9 -- scale=1        →  [40 cm × 6 cm]     answer: 240 cm²
(8) area_rectangle 2-9×2-9 -- decimals=1     →  [0,4 cm × 6 cm]    answer: 2,4 cm²
(8) area_rectangle 2-9×2-9 -- decimals=1×1   →  [0,4 cm × 0,6 cm]  answer: 0,24 cm²
(8) area_rectangle 2-9×2-9 -- unit=m scale=1 decimals=1
                                             →  [40 m × 0,6 m]     answer: 24 m²

Everything the two options accept elsewhere they accept here — a count, a span (scale=1-3), a split spelled out (scale=1×1) — and everything they refuse they refuse here: a rectangle has two sides, so a split spelled over three of them, or budgets asking for a power of ten on more sides than there are, is refused by check qspec. A side takes zeros or ranks, never both.

One thing is the figure's own. A shift may land so as to make the two dimensions equal — 4 and 40 under scale=1, as soon as the zero goes on the 4 — and a square is what this figure cannot carry. The two powers of ten are then swapped rather than the draw refused: giving each dimension the other's power always separates them again, and the line keeps drawing.

The unit is untouched by all this: scale and decimals change how long the sides are, not what they are measured in — 40 cm × 6 cm, never 40 cm × 6 mm. A conversion is another exercise, and units_conversion is where it is asked.

The unit of the answer is written beside the box¶

The answer is the number alone: the unit the area is expected in is printed inside the answer box, against its right edge, on the question sheet as on a mail-merge template. It is part of the question — an area asked in cm² is not the same question as one asked in m² — and it locks the answer down: no number is right in two units at once.

On the answer key the same unit follows the result, which is why the key reads 28 cm² while the pupil only ever types 28. On a slide, where there is no box, the unit is written into the answer itself.

Any question type can do the same by returning its unit from answer_unit(); snapshots carry it in the answer_unit field of a grid entry (see atmxs).

steps — the product, units included¶

steps=0 is the default: the area alone. steps=1 writes the product out, units and all, because multiplying them is what makes the result an area:

7 cm × 4 cm = 28 cm²

That is the one level, whatever scale and decimals say: unlike multi_direct, whose step sets the power of ten aside from the table fact, the product written here is the one the figure shows — 40 cm × 6 cm = 240 cm² — because the numbers a step would set aside are lengths, and a length divided out of a product is no longer a side of anything.

Whatever steps says, the info button of the answer key — and the Steps button of a slideshow — opens on that product and on the same rectangle with its area written at its centre. The two drawings of the figure are seeded from the question itself, so the shape shown behind the button is the shape of the wording, down to the pixel.

On a slide¶

The centre of the rectangle carries the Q{} the correction fills in green: the area is written where it is measured, inside the figure, rather than on a line below it.

The sentence stands above the figure, written smaller than the rest of the slide: what the pupil reads is the rectangle, the sentence only says what to do with it, and the height it gives up is height the figure gains. The slide also lifts its content block a little (raise, see atmxs), since a wording standing above a figure would otherwise leave the whole of it low on the screen.

compare_signed¶

Comparing two signed numbers, one at least of them negative.

Sources — one or two plain ranges of positive numbers, the distances to zero — 1-20, 25-500[25] 1.0-9.9; with one range both numbers are drawn from it, with two one from each.

Steps — none: the comparison is the whole answer; the rule it applies is said behind the info button.

Options — these, on top of the ones every type reads:

Two signed numbers are compared, one at least of them negative: the cases worth asking are the ones where the signs and the distances to zero pull apart.

(10) compare_signed 1-20
(10) compare_signed 1-20 -- variant=compare

The sources are distances to zero¶

The sources give positive numbers; the signs are the question's to give. With one range both numbers are drawn from it; with two, one from each — which is how a whole number is compared with a decimal:

compare_signed 1-20                →  −7 and −12, −15 and 4, −3 and 10…
compare_signed 25-500[25] 1.0-9.9  →  −300 and 3,7, −1,9 and −125…
compare_signed 0-10                →  0 may come out, and is then compared
                                      with a negative: −4 < 0

A 0 drawn stays unsigned — there is no −0 — and the other number is then the negative. Two numbers equal in every way are never compared: there would be nothing to find.

The three cases¶

They come round in packs of ten — five comparisons between two negatives, three and two of the others — so that any ten questions in a row hold them in that proportion, not merely on average. cases keeps some of them only, the proportions between those left standing:

compare_signed 1-20 -- cases=two_negatives
compare_signed 1-20 -- cases=negative_further,negative_closer

A source that cannot give one of the cases asked is refused when the line is checked: compare_signed 5 has no two different negatives to compare.

Tricks¶

With the probability tricks — 0.5 by default — the second number is not drawn but built from the first, to bait the usual mistakes:

• a number close to it, a tenth to nine tenths or a quarter away: −6 and −6,5;
• its digits the other way round, the point left in place: −8,9 and −9,8;
• in the cases mixing the signs, its opposite: −6 and 6.

Built from a number close to the first, a case mixing the signs gives nearly opposites, −6 and 5,75, where comparing the distances to zero gives the wrong answer. A line with two sources leaves the second aside for those questions. tricks=0 draws every number; tricks=1 builds every second one.

The two variants¶

true_false (the default) writes the comparison and asks whether it holds. It is written one of four ways — the smaller number on the left or on the right, with the sign that holds or the other one — −150 < 4, 4 > −150, −150 > 4, 4 < −150; these too come round in packs, so that a sheet asks as many true as false. The pupil answers with the word or its initial, case and spaces aside: vrai, V, Faux, f in French. The syntax help of the page — the ⓘ button — says so, in the words of its locale.

compare asks for the sign: on a sheet the box stands between the two numbers, on a slide the sign takes the place of the ?. The pupil types < or >; the answer key writes the whole comparison, −4 < 150.

The answer key's info button gives the comparison that holds, and the rule it applies, in one sentence.

cube_of¶

Cube of a number.

Sources — one singleton range, or a triplet range narrowed to its equal triplets — 2-10, 4-9×4-9×4-9.

Steps — one level, the power written out and its first two factors multiplied — 3³ = 3 × 3 × 3 = 9 × 3 = 27.

Options — the ones every type reads only.

The cube takes its sources, its variant=wording and its step the way the square does, and the two are described together under square_of: why a product range is usually the better source — a triplet range here, narrowed to its equal triplets — and what steps writes out.

Two things are its own. Its chain pauses once more, on the product of the first two factors: 3³ = 3 × 3 × 3 = 9 × 3 = 27, since three factors are not multiplied in one go. And it is given 30 s throughout, where a square starts at 20 s.

digitplace_count¶

Whole number of a given place a decimal number holds.

Sources — one digit place: the digitplaces, digitplaces_big or digitplaces_small alternator, or a single place written as a power of ten — 0.001.

Steps — none: the answer is the whole of it, so the answer key draws no ⓘ button.

Options — these, on top of the ones every type reads:

The place is drawn, and the number built around it, exactly as for digitplace_digit — same sources, same width, same rule of digits without repetition. What follows is what this type alone asks of that number.

Counting whole places¶

digitplace_count asks the same number one step further: not the digit at the place, but every digit from that place upwards, read as one number. 43.571 holds 435 whole tenths — and 4357 whole hundredths, and 43 whole units.

digitplace_count digitplaces      →  Whole number of tenths in 43.571?        435
digitplace_count digitplaces_big  →  Whole number of millions in 725,910,000?  725

Nothing is rounded: what sits below the place is dropped, which is what whole says — 43.571 holds 435 whole tenths, not 436. The digit asked for by digitplace_digit is the last digit of that count, which is the tie between the two questions and the reason they share a source.

Where the place drawn happens to be the leftmost digit of the numeral, the count is that digit — whole number of tenths in 0.357 is 3. That is not a degenerate case to avoid but the easiest way in, and a width of 2 or 3 is how a first sheet stays there:

digitplace_count digitplaces_small -- width=2

The answer is a number, so it is compared as one: the page writes it with the locale's thousands separator (43 571), and a pupil typing 43571 is right.

Transduration¶

30 s: the time to read several digits as one number and, on paper, to write it down.

digitplace_digit¶

Digit sitting at a given place of a decimal number.

Sources — one digit place: the digitplaces, digitplaces_big or digitplaces_small alternator, or a single place written as a power of ten — 0.001.

Steps — none: the answer is the whole of it, so the answer key draws no ⓘ button.

Options — these, on top of the ones every type reads:

The same knowledge, asked three ways: what digit sits at a given place, at which place a given digit sits, and how many whole units of a place the number holds.

(4) digitplace_digit digitplaces
    →  Digit of hundredths in 43.571?          answer:  7

(4) digitplace_name digitplaces
    →  Position of the digit 7 in 43.571?      answer:  hundredths

(4) digitplace_count digitplaces
    →  Whole number of hundredths in 43.571?   answer:  4357

What follows holds for the three of them: they draw their place from the same sources and build the same numeral around it. digitplace_name and digitplace_count then add what is theirs alone.

The source draws the place¶

The source of these questions is not the number — it is the place the question is about. Three alternators are registered for it:

Being alternators, they run through their places once per cycle and never twice in a row, so a sheet spreads over all of them instead of asking the hundredths three times.

The split into keys is what doses the large places. They belong to the syllabus, but naming the hundreds of millions is not what a mental-calculation belt should hinge on, so a sheet asks for them only as often as it says:

(9) digitplace_name digitplaces
(1) digitplace_name digitplaces_big

A single place can also be asked for directly, by writing it as a power of ten — useful for a sheet drilling one place:

(6) digitplace_digit 0.001      →  always the thousandths

Anything else is refused by check qspec: a source drawing 7, or 0.5, is not drawing a digit place.

The number is built around the place¶

The number is not drawn — it is built so that the question can be asked at all. Its digits are taken from 1 to 9 without repetition, filling consecutive places around the one drawn. So:

• the place asked about always carries a digit, never an implicit zero;
• the digit shown by digitplace_name appears once and only once, which is what makes position of the digit 7 a question with one answer.

Where the number may extend depends on the place drawn. A place from the thousands down to the thousandths keeps the number under ten thousand; a large place gives a whole number, the way large places are read at school. So digitplaces never produces a number in the millions, and digitplaces_big never produces a decimal part.

width sets how many digits the number carries — a number, or a range from which one is drawn per question (the default is 3-5):

digitplace_digit digitplaces -- width=2      →  Digit of hundredths in 0.72?
digitplace_digit digitplaces -- width=3-5    →  three to five digits

It may not go below 1 nor past 9 (there are only nine non-zero digits to choose from), and a width wider than the places available is narrowed to them rather than refused.

min_place and max_place — where the number may reach¶

width counts the digits; it says nothing about how high they sit. A five-digit number built around the tens of thousands may come out as 64 519 or as 3 692 800 000, both carrying five significant digits. min_place and max_place say where the numeral is allowed to run, each written the way a source writes a place — as a power of ten:

(10) digitplace_digit 1,10,100,1000,10000,100000,1000000
     -- width=5-8 min_place=1 max_place=10000000
     →  Digit of hundreds in 982 167?      Digit of millions in 45 962 000?

That is a sheet on the places of a big whole number: min_place=1 keeps the units the lowest place written, so nothing below the decimal point; and max_place=10000000 caps the numeral at eight digits. Either may stand alone — the other end then stays where the catalogue ends.

Which is what the default span cannot give: the hundreds are a core place, so without min_place they come with a decimal part — Digit of hundreds in 8 597.42? — and the large places come without any ceiling.

The two are the span itself, so the source has to draw inside them. A place they leave out is refused rather than skipped:

digitplace_digit 0.001 -- min_place=1
→  the number is confined to the places from 1 to 1000000000, which
   leaves out the place 0.001 a source draws.

With an alternator the same refusal comes at render time, its places being unknown until one is drawn: pair a narrowed span with the places you mean — 1,10,100,1000 rather than digitplaces, whose thousandths it excludes.

Transduration¶

digitplace_digit defaults to 20 s — reading off a digit is quick once the places are known. Its two siblings, which have a word or a number to write, are given 30 s.

digitplace_name¶

Place a given digit sits at in a decimal number.

Sources — one digit place: the digitplaces, digitplaces_big or digitplaces_small alternator, or a single place written as a power of ten — 0.001.

Steps — none: the answer is the whole of it, so the answer key draws no ⓘ button.

Options — these, on top of the ones every type reads:

The place is drawn, and the number built around it, exactly as for digitplace_digit — same sources, same width, same rule of digits without repetition, which is what makes the digit shown appear once and only once. What follows is what this type alone asks of that number.

Answering with a word¶

digitplace_name is answered in words — hundredths, tens. Both the plural and the singular are accepted, and the comparison ignores spaces, case and accents: for the French dixièmes, a pupil typing Dixième or dixiemes is right.

Transduration¶

30 s: the time to name a place and, on paper, to write the word.

divi_direct¶

Division.

Sources — one product range of exactly two factors, or the fractions table — 2-9×2-9, fractions.

Steps — none on the plain form; one level under variant=wording, on the operation the sentence names.

Options — these, on top of the ones every type reads:

Drawing from the fractions table¶

divi_direct fractions -- variant=wording asks Quotient of 3 by 4?, whose answer is the fraction 3/4 — with its decimal form beside it, 3/4 (or 0.75), whenever the quotient falls in three decimals or fewer. Both spellings are accepted from the pupil. 7/3 and 5/11 get no such hint: their decimal form does not end.

The fractions drawn are irreducible¶

The table holds every n/d with n and d from 1 to 12, 6/9 and 12/12 included. divi_direct filters it to the irreducible rows by default: the question asks whether the pupil sees that a quotient can be written as a fraction at all, not whether they can simplify one. Drawn 6/9, a pupil writes 2/3 and loses the point on something the question was not about.

The line lifts the filter when it wants to:

any exists because a column filter has no absent state once a type gives it a default — true and false each keep half the table, and neither means either. Any other value is refused by check qspec and at render time, rather than reaching the database as a filter nothing matches.

This is a default of divi_direct alone. multi_hole fractions is untouched and still draws from the whole table unless the line filters it.

hidden — which of the two is asked¶

hidden=fraction hides the fraction and shows 3 ÷ 4; hidden=integer hides the denominator and shows 3 ÷ 3/4 — a division by a fraction. Left to itself the plain form draws either, so a line meant for a grade where dividing by a fraction is not taught yet has to say so:

(10) divi_direct fractions -- hidden=fraction
(10) divi_direct fractions -- variant=wording

The worded form settles it on its own, having no sentence for a division by a fraction: it always hides the fraction, and hidden=integer written alongside it is refused.

divi_euclidean¶

Euclidean division.

Sources — one product range of exactly two factors — 2-9×2-9; the remainder is drawn on top of their product.

Steps — none: the answer is the whole of it, so the answer key draws no ⓘ button.

Options — these, on top of the ones every type reads:

divi_vocab¶

Half, third or quarter of a natural number.

Sources — one product range of exactly two values, one of which is 2, 3 or 4 — the word names it — 2-4×2-9.

Steps — none: the answer is the whole of it, so the answer key draws no ⓘ button.

Options — these, on top of the ones every type reads:

expand_simple¶

Expand and reduce a factor times a binomial.

Sources — one product range, drawn twice as a linked pair sharing the distributed factor — 3-9×3-9.

Steps — one level, the distribution written before the reduced form.

Options — the ones every type reads only.

expand_simple asks to expand and reduce a factor times a binomial:

(6) expand_simple 3-9×3-9
    →  Expand and reduce: 4x(6x − 9) = ?      answer:  24x² − 36x

On a sheet the instruction is part of every question, read once per line in passing. A slide shows one question at a time, so it leads with the expression and drops the instruction underneath (see On a slide). The factor is on the left unless variant says otherwise (see below).

One source, two linked products¶

Expanding 4x(6x − 9) needs two products, 4 × 6 and 4 × 9, sharing the distributed factor. They come from one product range, drawn as a linked pair: the first product is drawn as usual, then the second is drawn among those carrying one of its factors.

(6) expand_simple 3-9×3-9      one source, two products drawn from it

Two independent sources would not work: nothing would make the second range share a factor with what the first one drew.

The range must therefore hold two products sharing a factor other than 0 or 1 — 1×2-9 does not, and check qspec says so before anything is rendered. Both products are recorded in the pairs table, like multi_direct, so an expansion and a multiplication on the same sheet cannot ask the same fact twice.

A shared factor of 1 (or 0) is never chosen — 1(6x − 9) expands to itself — but a range holding 1 stays perfectly usable: the 1 simply ends up inside the binomial, as in 6x(6x + 1).

On a slide¶

A slide gives the instruction the same height as the expression, which pushes the expression off-centre and buries the = ? the correction is about to fill. So on a slide the question leads with the expression and the instruction becomes the note underneath:

sheet:                              slide:

Expand and reduce: 4x(6x − 9) = ?       4x(6x − 9) = ?
                                       (to expand and reduce)

The correction slide is the same slide with the red ? replaced by the answer in green — the expression and the note do not move.

That holds whatever steps says: like every type, expand_simple answers a slide at level 0 — the reduced form — and leaves the distribution to the sheet and to the help button. See The steps option.

variant — where the factor sits, and whether it carries the unknown¶

Four shapes, selectable by name, by number, by alias (monomial, number, left, right, all) or by ^ exclusion:

(4) expand_simple 3-9×3-9                         4x(6x − 9),  4(6x − 9)
(4) expand_simple 3-9×3-9 -- variant=all          the four shapes
(4) expand_simple 3-9×3-9 -- variant=monomial     4x(6x − 9),  (6x − 9)×4x
(4) expand_simple 3-9×3-9 -- variant=number       4(6x − 9),   (6x − 9)×4
(4) expand_simple 3-9×3-9 -- variant=right        (6x − 9)×4x, (6x − 9)×4

A factor written after the binomial keeps its × — (6x − 9)×4x, where 4x(6x − 9) needs none.

Without a variant, only the two shapes holding the factor on the left are drawn — the way an expansion is first written and read. The mirrored forms, useful once the rule is acquired, come with variant=all, variant=right, or by naming them.

The sign inside the binomial is drawn at random and is not part of the variant.

steps — showing the distribution¶

The reduced form is the answer, not a step: steps=0 (the default) gives it alone, and steps=1 shows the distribution first.

steps=0:   4x(6x − 9) = ?   →  24x² − 36x
steps=1:   4x(6x − 9) = ?   →  4x×6x − 4x×9 = 24x² − 36x

steps=true and steps=false are accepted too, and mean 1 and 0. At steps=0, the distribution is still one click away on the live page — see The steps option.

As everywhere, the option shapes the sheet: a slide answers with the reduced form either way (see On a slide).

Typing the answer¶

In an interactive page the pupil types the reduced form. Neither ² nor ^ is within easy reach of every keyboard, so a bare 2 behind the unknown is read as the square, and both orders of the two terms are accepted, each keeping its own sign:

24x²-36x    24x^2-36x    24x2-36x    -36x+24x²    -36x+24x^2    -36x+24x2

(the sign typed is the keyboard hyphen, not the typographic minus the page displays)

Spaces are ignored, wherever they are — as they are in every question of an interactive page, along with case and accents.

expr_eval¶

Replace the letter by its value, and compute.

Sources — a range for the values of the letters and a second for the numbers of the expression — 2-9 2-12, one range serving for both where only one is written — and, to draw the products and the quotients as multi_direct and divi_direct draw theirs, a product range: 2-9×2-9 2-12.

Steps — one level, the expression with its letters replaced, then each stage of the reduction.

Options — these, on top of the ones every type reads:

The pupil replaces the letter by its value and computes:

Calculer la valeur de l'expression A = 5x − 1, où x = 4.     →  19
Calculer la valeur de l'expression E = 6 + ab, où a = 3 et b = 4.   →  18
Calculer la valeur de l'expression P = 24 − t², où t = 3.    →  15

The name of the expression — the A, the E, the P — is drawn from an alphabet of its own and set in the text font, where the unknown inside is set in the math one. That is how the two are told apart on the page, and it is the usual typography: a capital naming the whole expression stands upright, a letter standing for a number leans.

The sources¶

Up to three, bound by position, and in this order:

expr_eval  <product range>  <letters>  <numbers>
              ↑                ↑          ↑
   the products and     what a letter   the numbers
   quotients, as a       may be worth    written in
   pair, or `auto`                      the expression
   (optional)

(5) expr_eval 2-9 2-12 -- result=positive          letters 2-9, numbers 2-12
(5) expr_eval 2-9×2-9 2-9 2-99 -- result=positive  all three
(5) expr_eval 2-9×2-9 2-20 -- result=positive      one range for both

Position is all there is to tell a product range from a plain one, and the two plain ones from each other — 2-9×2-9 carries its ×, so it is recognised wherever it stands, but 2-9 2-12 says which is which by order alone. The last may be left out, and one plain range then serves for both: write both whenever you want them to differ, which with a product range in front is easy to forget.

Neither is ever drawn from freely (see Landing right below), but neither is ever stepped outside either: whatever comes out of a draw is a value the range declared.

Drawing the product, and the quotient, as their own questions draw them¶

Wherever the expression holds a product or a quotient joining a number and a letter — ax, xy, x/a, a/x — that operation is exactly what multi_direct and divi_direct draw. So it can be drawn the same way, from a product range, written alongside the others:

(4) expr_eval 2-9×2-9 2-12 -- variant=ax-b result=positive
       →  7x − 5, where x = 8        the pair is 7 × 8
(2) expr_eval 2.5×4-20[2] 2-12 -- variant=ax-b result=positive
       →  4x − 7, where x = 2,5      or 2,5x − 7, where x = 4
(2) expr_eval 11×11-99 2-99 -- variant=ax+b result=positive
       →  11x + 20, where x = 63
(4) expr_eval 2-9×2-9 2-20 -- family=quotient result=positive
       →  x/7 + 5, where x = 63

Two things follow, and the first matters more than it looks:

• the tracking is shared. Deduplication happens per table, and a product range feeds the same one multi_direct draws from. A sheet carrying both will therefore not ask 7 × 8 and then 7x for x = 8 — which two ranges drawn apart cannot prevent, since neither knows what the other drew;
• a quotient comes out exact by construction. The pair gives the divisor and the dividend is their product, as in divi_direct, so x/7 for x = 63 needs nothing sifted for it. The quotients, which two plain ranges leave the most cramped of all the families, are the ones a product range serves best.

Which of the pair is the letter is drawn: 2.5×4-20[2] asks 4x − 7 for x = 2,5 as readily as 2,5x − 7 for x = 4, and a sheet gains by mixing the two.

auto — the multiplications a pupil has already met¶

A range is a set of values. What an author wants is rarely a set of values: it is a kind of calculation. auto is the union of the kinds a pupil starting on literal expressions has already worked through, written in the product range's place:

(10) expr_eval auto 2-12 2-99 -- result=positive

Written alone, auto draws its letters from 2-12 and its numbers from 2-30 — the ranges nearly every line wrote out anyway. auto speaks of the products and the quotients and of nothing else, so the letter of x − b and the term of x² + b would otherwise have nothing to come from; a shape that knows better about one of its slots already says so itself (see A shape may draw a slot itself below). Write one range beside auto and it serves for both, as it always did:

(10) expr_eval auto -- result=positive            letters 2-12, numbers 2-30
(10) expr_eval auto 2-9 -- result=positive        letters and numbers 2-9

x + b, x − b and b − x take two-figure numbers instead, 11-99 both: between 2-12 and 2-30 the whole question would be 5 − 4, and between two-figure numbers carry decides whether a column carries or borrows (see below).

The shares are declared, and they add up to a hundred so that each reads as the percentage it is. They have to be declared: read off how many questions each recipe offers instead, and the mix is nobody's choice — every recipe wide enough to reach the search's ceiling counts the same, which had 1,5 × and 2,5 × taking nearly half the products of ax + b. A recipe no plan can people drops out, and the rest share its place.

Dividing by 15 or by 25 stops at 6 where multiplying goes to 8: 90 ÷ 15 is a question worth asking, 120 ÷ 15 is one a good many pupils give up on. Splitting a range in two is how a recipe says that one end of it is not the other.

Every one is a line multi_direct already poses at that grade, and auto draws them into the same tracking table, so a sheet holding both does not put the same product twice.

They are recipes for multiplying, and each says whether it may also fill a quotient — because the two do not follow one another. Knowing 12 × 12 is knowing 144 ÷ 12; knowing 11 × 80 is not knowing 880 ÷ 11, which is nobody's lesson. The tables of 15 and of 25 divide too, 120 ÷ 15 being harder and still a question; 2,5 × 6 read backwards is 15 ÷ 6 = 2,5, which is not.

A recipe that does not divide is simply not offered to a shape that does — refusing its quotients one at a time would leave 880 ÷ 11 standing, whose divisor and quotient are both small enough to pass the tables rule.

The whole numbers start at 3. Multiplying by 2 is not a question at that grade, and a recipe is read backwards as well as forwards: 2 × 5 posed as a quotient is 10 ÷ 2. Weighing a small end down is not enough where nearly half of what it holds is of that size, so 2 is left out once, for products and quotients alike. It survives where it means something else — 1,5 × 2 is a recipe about 1,5.

Notice that each recipe carries the options that make it what it is — a two-figure number by 11 is a mental calculation only as long as nothing carries. That is why auto is not a wider range: no range can say that.

Which recipe a question draws from is settled once the shape is known, since 1,5 × 18 peoples ax + b and no quotient at all. The recipes that fit then share the draw by their declared shares, renormalised over themselves — so before a shape that divides, where 11 × 63 and the two decimal recipes drop out, the tables take seven draws in ten rather than four.

A shape holding two products lets one of them lead, and keeps it company. Three operations asked at once are three operations asked with nothing written down — the pupil has replaced the letters themselves, so 7 × 8 + 6 × 9 is held entirely in their head. That is not a harder question; it is a question most of a class does not attempt. And a recipe built round a fixed factor fills every product it is asked for with that same factor, so ax − by came out 26m − 11a, one multiplication by 11 twice over.

So whichever recipe was drawn fills one group, and one of two plain ranges fills the rest — the tables of 2 to 5 three times out of four, and 2×10,15,25 the fourth, which is still nothing to work out with a little more to look at:

expr_eval auto 2-12 2-30 -- variant=ax+by,ax-by result=positive
    →  2k + 54y,  where k = 10 and y = 11   54 × 11 beside 2 × 10
    →  25n − 4t,  where n = 6 and t = 4     25 × 6  beside 4 × 4
    →  3k + 9u,   where k = 4 and u = 6      9 × 6  beside 3 × 4
    →  11v − 2y,  where v = 34 and y = 15   11 × 34 beside 2 × 15

The 2 the recipes left out comes back in that company, and may: what made it a poor recipe was 2 × 5 read backwards as 10 ÷ 2, and neither companion range divides.

A quotient keeps company of its own, for that very reason: 3-5×3-5, either member dividing — 12 ÷ 3, 20 ÷ 5, 16 ÷ 4 — which is as plain as a division gets without becoming a halving. So ax + y/b and x/a + by may lead with either operation, and x/a + y/b with either quotient:

expr_eval auto 2-12 2-30 -- variant=ax+y/b,x/a+by,x/a+y/b result=positive
    →  10v + q/5,   where v = 8 and q = 15     10 × 8  beside 15 ÷ 5
    →  2p + t/12,   where p = 3 and t = 144    144 ÷ 12 beside 2 × 3
    →  n/15 + d/5,  where n = 90 and d = 25    90 ÷ 15 beside 25 ÷ 5

The leading recipe's share is split over the positions it may take and over the company it may keep, so arranging changes where a recipe lands and never how often it is drawn. And what a recipe fixes, it fixes for its own group: 40 × 11 carries in no column because that is what makes it that recipe, while the 3 × 3 beside it answers for itself. Only a power of ten is settled for the question as a whole, since it moves the whole expression.

A shape may ask for a different mix. a(x + b) has the pair fill the factor and the sum, so under the tables x + b never passes 10 — and an unknown being 2 at the very least, b is cramped between 2 and 8, which writes 4(q + 2) over and over. The recipes with a big fixed factor put a real number inside the parentheses, so that shape asks for fewer tables and gets 11(p + 30), 8(c + 16), 2,5(b + 18). Nothing is excluded; the mix is weighed, shape by shape.

scale and decimals apply where they mean something. A power of ten lands on the tables recipe and on no other: laying a rank on 1,5 × 18 would ask for 0,15 × 18, and laying one on 15 × 3 only writes 1,5 × 3, which is a recipe of its own. So the options are honoured where they were meant and ignored where they were not, rather than refused:

expr_eval auto 2-12 2-99 -- variant=ax+b,ax-b result=positive decimals=1
    →  0,7y + 82, where y = 6      the tables, with a rank laid on
    →  0,4q + 81, where q = 2      the same
    →  19p − 6, where p = 1,5      a recipe of its own, left alone
    →  25k − 91, where k = 7       likewise

carry follows the same rule: a recipe that fixes the columns keeps its own answer, and a line's carry reaches the ones that do not.

One auto to a line — it is a union, and two would mean nothing. It fills a product or a quotient, so a line whose shapes hold neither is told that nothing comes of it. The letters and the numbers keep their own ranges: write 2-12 for the letters and the squares land on 2 to 12, which is the same list the recipes hold.

A product range is also how a recipe is written — a kind of calculation you want a whole line of, rather than a range you want values from. Pinning one member and letting the other run is what says it:

(10) expr_eval 10×0.1-9.9 2-12 2-99 -- variant=b-ax result=positive
       →  99 − 10y, where y = 8,5        →  44 − 3,8b, where b = 10
       →  40 − 10q, where q = 0,6        →  36 − 0,9y, where y = 10

Ten questions that are all the same calculation — a tenth multiplied by ten, taken from a number that is larger — which is what a line of a worksheet usually wants. Name the shape with variant and the recipe is exact; leave it out and the range serves whatever shape is drawn.

A product range fills a product or a quotient and nothing else, so a line holding one alone leaves whatever sits outside it — the term of ax + b, the letter of x + b — with nothing to come from. Write the range it needs beside it; check qspec says which is missing, and for which shape.

A computed member is drawn from the pair too. Where the operation joins a slot and something the expression works out — a(x + b), a/(x + b), (x + b)/a — one member of the pair fills the slot and the other is what the computed side has to come out at:

(4) expr_eval 2-9×2-9 2-99 -- variant=a(x-b),a/(x-b) result=positive
       →  7(m − 9), where m = 17     the pair is 7 × 8
       →  72/(t − 83), where t = 91  the pair is 8 × 9: 8 divides, 72 is 8 × 9

This is where a pair earns the most. Looked for at random, an exact division in the tables is rare — a/(x + b) over 2-99 has 551 combinations that suit out of 941 192 — so a plain range leaves those three shapes a handful and check qspec says so. Drawn from a pair they come out right every time.

A square is the exception, and stays drawn from plain ranges: it takes square values and no others, so a pair has next to nothing to offer it — with 2-9×2-9, ax² would be left the two bases 2 and 3. The tables rule above holds its base small, which is the whole of what a square needs.

carry, scale and decimals — the product's own options¶

A product inside an expression is the same product multi_direct poses, so it answers to the same three options, read by the same code and spelt the same way:

expr_eval 2-9×2-9 2-12 -- variant=ax-b carry=false     →  2x − 7, where x = 4
expr_eval 2-9×2-9 0.1-9.9 -- variant=ax-b decimals=1   →  0,8a − 0,1, where a = 3
                                                       →  8u + 9, where u = 0,7
expr_eval 2-9×2-9 2-99 -- variant=ax+b scale=1         →  7p + 86, where p = 20

decimals and scale move the whole expression, and say how far, not which number takes the zeros: the same calculation at another size, which is a lesson of its own.

drawn:  4 × 6 + 15
  scale=1     →  4x + 150,     where x = 60     390
  decimals=1  →  4x + 1,5,     where x = 0,6    3,9
  decimals=2  →  0,4x + 0,15,  where x = 0,6    0,39

The value keeps its digits and only the point moves. Which slot carries the zeros is the shape's affair, and the thriftiest move is the one made: 4000x + 150 for x = 0,06 lands one rank up as surely and is nobody's question.

Some shapes cannot move at all — x² + x would have its two halves move at different speeds, the square going twice as fast as the letter beside it — and a square moves in twos, so x² + b takes scale=2 and ignores scale=1. A shape that cannot make the move asked for simply does not make it. scale=1-2 draws one rank or two; decimals=1×1 spends one rank on each of two factors, which is two ranks down in all.

carry needs nothing: 8x for x = 7 carries wherever its numbers came from, so it reads on the values whatever drew them, product range or not. It reads on a sum or a difference too, where the expression is nothing else — x + b, x − b, b − x — the way addi_direct and subtr_direct read them: carry=true asks for a column that carries, or for one that borrows. A sum with a computed member, the + of ax + b, adds the pupil's own product, and carry says nothing of it.

expr_eval auto -- variant=x+b,x-b,b-x result=positive carry=true
    →  b + 86,  where b = 42
    →  62 − x,  where x = 47

They need a product range: a shift transforms a drawn pair, where a range drawn one value at a time is simply the range you wrote (0.2-1.2 rather than 2-12 shifted). With auto, only the recipes that have digits to spare carry one — laying a rank on 1,5 × 18 would ask for 0,15 × 18.

The powers of ten are laid before the expression is sifted, never after, so what was tested for landing right is what the page shows. An option a drawn shape has no use for is harmless — check qspec remarks on it and renders all the same.

Choosing the expression — one selector and three filters¶

variant picks shapes the way it does everywhere else: by name (ax+b), by number, by range, by ^ exclusion — see Selecting variants.

Beside it, three filters, which intersect where the terms of a variant unite:

(carry, scale and decimals are options of the product, not filters: see above.)

expr_eval 2-9 2-12 -- family=quotient ops=2      # the quotients of two operations
expr_eval 2-9 2-12 -- ops=1                      # the first rung: x + 7, 3x, t²
expr_eval 2-12 2-12 -- letters=2                 # 6 + ab, 3a + 2b

That intersection is the reason they are options of their own rather than aliases of variant: variant=quotient,plain would be a union, and "quotient and one operation" could not be written at all.

ops is not the grade level — it counts the operations the expression asks for, the square counting for one: x + 7 and x/4 ask one, 3x + 7 and t² − 5 ask two, x² + 3x asks three. It is read off the expression itself, so it can never disagree with it.

A line that names variant explicitly drops the three defaults: asking for variant=80 is asking for it, and a default filter silently emptying the selection would be a trap rather than a convenience. Filters written next to a variant still apply.

A shape may name its own ranges where the line wrote auto, in place of the recipes. x² + ax does: its product keeps the square company rather than doubling the work — the same thing two products of one expression do for each other — so it draws from 2-5×2-12, 1.5×2-12 and 2.5×2-12, six draws in ten for the first. The 2 the recipes left out comes back in that company, as it does in any: what made it a poor recipe was 2 × 5 read backwards as 10 ÷ 2, and a product keeping company is never read backwards.

expr_eval auto 2-12 2-30 -- variant=x²+ax result=positive
    →  b² + 2b,   b = 12      →  u² + 5u,   u = 12
    →  x² + 2x,   x = 11      →  t² + 2,5t, t = 9

A line that writes its product range out is left alone: what the author wrote is what they meant, and the shape's ceiling on the coefficient (5, above) is enough there.

Three shapes carry a table of their own instead of being weighed by the tables rule: ax², x²/a and a/x². The rule asks of every operation whether a pupil can carry it out, and answers by the size of the operands — nothing beyond twelve, its zeros and its point set aside. That answer is right almost everywhere and wrong wherever a square is an operand, because a square is not free to be small: 2 × 144 is a question a 5e pupil answers and 64 ÷ 32 is another, while 64 ÷ 16 is not, and no rule about size tells the three apart. A table does. Keyed by the value of the unknown, it gives what the number beside it may be, and the shape then vouches for the operation the way a product range vouches for what it drew:

expr_eval auto 2-12 2-30 -- variant=ax²,x²/a,a/x² result=positive
    →  2y², y = 12        2 × 144       →  q²/18, q = 6     36 ÷ 18
    →  8x², x = 4         8 × 16        →  x²/4,  x = 8     64 ÷ 4
    →  12p², p = 10      12 × 100       →  n²/64, n = 8     64 ÷ 64 = 1
    →  1000/q², q = 10    1000 ÷ 100    →  63/b², b = 3     63 ÷ 9

Dividing the square by itself is in the table deliberately: it is simple, and it is exactly where a class hesitates. It is the one place the engine's own refusal of a division that divides nothing steps aside, and it does so only because a table said which of the two it meant.

The base of the square is weighed all the same — that is the one thing a rule about size had right about squares — and the line's range for the letters still applies, so a table is a ceiling and never a floor: expr_eval auto 2-9 never reaches the rows for 10, 11 and 12. The draw takes the unknown first, so the base comes out evenly across the table's keys and the number is chosen from the row it opened.

A table may weigh a base, or a value inside a row. An even draw puts a row holding one question on the page as often as a row holding eight, and puts a value sitting in every row on a third of the lines:

• a/x² weighs its row for 4 down — 32 ÷ 16 is all that row holds, and five bases drawn evenly put it on one line in five;
• x²/a weighs the division of the square by itself down to a share, which takes it from 38 % of the line to 8 %;
• ax² gives 10 and 100 two fifths of a share each, because multiplying by ten and by a hundred is one and the same asking and both sit in every row — between them they took a third of the line, and now a fifth. The 2 then takes four fifths, the short rows holding little else once the zeros have given up their place.

A share is a draw-time weight like a recipe's: it changes how often a question comes up and never whether it may, so check qspec --report, which counts what a line can pose, reads the same either way.

A shape may also draw a slot itself, where the line's range describes something else. A line's ranges say what a pupil is given, and most slots are given: the x of ax + b is a value chosen for them, and 2-12 says what it may be. A few are not. The b of b − x² is not a free term — under result=positive it is a square plus the answer — so a range stopping at 30 stops the base at 5 and the shape poses 66 questions out of a possible 1265. The x of (x − b)/a is not a free value either: it is the dividend plus b, and the dividend is a product of the tables, so a range stopping at 12 leaves it four questions. Nor is the x of x − ay, which has to be worth more than the product it loses: it reaches as far as the b of b − x².

expr_eval auto 2-12 2-30 -- variant=(x-b)/a result=positive
    →  (b − 5)/7,  b = 68      63 ÷ 7
    →  (a − 24)/3, a = 69      45 ÷ 3
    →  (c − 21)/15, c = 81     60 ÷ 15

expr_eval auto 2-12 2-30 -- variant=b-x² result=1-30
    →  76 − x², x = 8          76 − 64
    →  32 − k², k = 2          32 − 4

This is what the dividend of a/x has always done — it is the pair's product, and no range of the line's ever held it — said for a slot the shape names instead of for one a group fills. The draw still takes the slots in turn, so the base of b − x² comes out evenly across 2 to 12 rather than piling up where the term left room; and result is where to say how big the answer may get.

A shape may hold one of its slots down to a size of its own, whatever range the line gives it: the term of x² + b stops at 20, and the a of x² + ax at 5, so the product keeps the square company rather than doubling the work. A ceiling is read on the value as it was drawn, before any power of ten, so a line moving the whole expression never runs into one. It is declared and not read off the tree, because it is not in the tree to read: x² + b is a perfectly good expression for any b, and that a term of 26 beside a square is more to carry than one of 12 is a teacher's judgement.

A shape may write itself either way round where writing it both ways is not a second question: a(x+b) comes out 7(t + 3) or 7(3 + t), at random, because the sum inside the parentheses commutes and the exercise is the same one — and so do (x+b)/a and a/(x+b). That is not so of ax+b and b+ax, which are two shapes of the catalogue: there the coefficient changes side, and a pupil reads the expression differently. Nor of x²+x and x+x²: the second is where a pupil adds before squaring. Everything a shape derives — its groups, its slots, what may carry the zeros — is read off the one writing; only the drawn tree is mirrored.

In the tables¶

82 ÷ 41 is exact. 28 × 17 is whole. 69² is positive. Not one of the three is a question a 5e pupil is asked to answer without writing anything down — and arithmetic alone cannot say so, which is why there is a second rule beside Landing right below:

• a product wants both its factors in the tables;
• a quotient wants its divisor and its quotient in the tables — the table read backwards, so the dividend is free to be 81;
• a square wants a base a pupil knows.

"In the tables" is read on the digits, zeros and point set aside: 40, 0,4 and 12 000 are all as simple as 4, which is exactly what scale is for. The ceiling is 12 — 11 × 11 and 12 × 12 are learnt with the rest. A square is held to the plain reading instead: scaling a product costs one count of zeros, scaling a square costs it twice, and 8 100 is not the mental calculation 8 × 100 is.

82/(t + 25), t = 16      ✗  82 ÷ 41
81/(t + 5),  t = 4       →  81 ÷ 9, and a question
28(m − 20),  m = 37      ✗  28 × 17
7(m − 9),    m = 17      →  7 × 8
a² − a,      a = 69      ✗  and exact, and positive
8r + 53,     r = 6       →  a sum is not weighed: nothing about the sizes a
                            range offers makes a sum something other than a sum

A product range is the author's own judgement, not the sift's — about what a line will multiply. A multiplication drawn from one is exempt: writing 11×11-99 is asking for 11 × 63, and 9×1.5 is asking for 9 × 1,5. That is also why a coefficient written as 2,5 reaches the page through a product range and not through a plain one.

A division built out of the same pair is exempt from nothing, and that is the whole of the difference. 11 × 71 read backwards is 781 ÷ 11, which nobody described and no pupil recognises; 2,5 × 6 backwards is 15 ÷ 6 = 2,5. A pair says what a line will multiply; what it may divide the rule decides, which is why 2-9×2-9 divides freely — every quotient it can make is a table — and 1.5×2-20 does not divide at all.

One consequence worth knowing when writing a line: a slot that is itself a factor or a divisor is narrowed where it stands, before any combination is tried. On 2-99 that leaves a coefficient 19 values — 2 to 12, then 20, 30, … 90 — where the term beside it keeps all 98. It is the same rule read one slot at a time, and it is what keeps the search from hunting a handful of survivors through a hundred thousand combinations.

Landing right¶

An expression that passes through a negative number is not a 5e question, and a division that does not fall right is not a question at all. Both are settled the same way: every combination the sources allow is tried on the expression, reduced the way a pupil reduces it, and only those that come out clean are offered to the draw.

• a division must stop within the precision the line works at — the digits of the most precise value its ranges offer. With whole ranges that is exact integer division; with 0.1-9.9 on the line, a quotient may need a tenth;
• a division that divides nothing is refused: 9 ÷ (9 − 8), 12 ÷ 12 — and so is a product that multiplies nothing, 70(93 − b) for b = 92;
• a coefficient is never 1 (1x is not written), an unknown is never 0 or 1, and two letters are never given the same value.

Nothing else needs a rule, and that is worth knowing when writing a line: a sum, a difference, a product and a square never need more digits than their operands bring. So the answer is whole exactly when the sources are, with no option to set — and a range holding a decimal makes a decimal answer natural rather than forbidden:

expr_eval 9×1.5 2-12 -- variant=ax+b     →  9x + 2, where x = 1,5   → 15,5
expr_eval 2.5×4-20[2] 2-12 -- variant=ax-b result=positive
                                         →  4x − 7, where x = 2,5   → 3

With result=positive — what a 5e line writes nearly always, negative numbers being taught late in the year at the earliest — no negative number appears anywhere in the reduction, not merely in the result:

expr_eval 2-9 2-12 -- variant=b-ax result=positive
    →  12 − 2x, where x = 4        12 − 8 = 4
    ✗  5 − 2x, where x = 4         a pupil meets 5 − 8 on the way

result=negative asks for the opposite result. Left out, neither applies and an expression is free to pass through a negative number.

Asking for a question of a certain size¶

result also takes bounds, and they carry the positive reading with them — a result between 11 and 30 is a positive result, negative numbers staying out of the steps just the same:

(6) expr_eval 2-9×2-9 2-9 2-99 -- variant=ax+b,b+ax,ax-b result=20-60
       →  9m − 35, where m = 8      → 37
       →  34 + 3t, where t = 3      → 43
(4) expr_eval 2-9×2-9 2-12 2-99 -- family=square ops=2 result=20-99
       →  n²/5, where n = 10        → 20
       →  47 + t², where t = 5      → 72

This is what an author reaches for when they want a question of a certain size and find themselves narrowing a source instead — which does not work, because the size of a term is not the size of a question: 8r + b wants a small b where b − x² wants a large one, and both are terms of the same kind. The result is the thing actually being asked about, so it is the thing to bound.

A bound is a filter and never a source: the values still come from the ranges the line declared, and none is invented to reach one. So bounds can empty a shape the way any constraint can, and check qspec says which. result=12 bounds the result to exactly 12.

What to give it¶

A product range, wherever the expression divides. Drawn from two plain ranges, the quotient family is the demanding one: x/a needs the value of the letter to be a multiple of the number, and a/(x + b) needs a division that is exact and in the tables, with nothing to aim at. A pair settles both by construction. Failing that, room:

(4) expr_eval 2-9×2-9 2-20 -- family=quotient result=positive
(4) expr_eval 2-20 2-12 -- family=quotient result=positive

A line of plain ranges spanning the whole catalogue will draw a warning or two on a/(x + b) and a/x² however wide it is. That is the warning doing its job: give those a product range, or exclude them with variant=^141.

automath check qspec says so before anything is rendered — it refuses a shape no combination can people, naming every such shape of the line at once rather than the first of them, and warns about one left with 25 questions or fewer where a wider range would help. x² holds eleven questions and cannot hold more, its base being capped at 12 by the tables rule, so nothing is said about it: a remark an author cannot act on is noise. See Validating specs.

Seeing what a line will give¶

Ranges and a catalogue of shapes do not add up to something an author can foresee, and the questions worth knowing about are the ones at the edge. So ask:

automath check qspec --report "expr_eval 11×11-99 2-9 2-99 -- variant=ax+b result=positive"

expr_eval: shapes selected: 1. Questions they can draw: 4000.
expr_eval: the result falls between 125 and 1 185.
expr_eval: it multiplies within the tables, the most it asks being 12 × 11,
in 12x + 88, x = 11.
expr_eval: it multiplies beyond the tables, the most it asks being 11 × 99,
in 11x + 21, x = 99.

Every question the line can draw is weighed, not a sample of five: the sift has already enumerated them, so the extremes are the real ones. Difficulty is read as a demand rather than a size — 1000 × 7 is a shift, 79 × 3 is not — and the bands are listed lowest first, so the most trivial question a line can ask shows as plainly as the hardest. A recipe reports as one band:

expr_eval 10×0.1-9.9 2-12 2-99 -- variant=b-ax result=positive
    expr_eval: it multiplies by a power of ten, the most it asks being
    10 × 9,8, in 99 − 10x, x = 9,8.

expr_vocab¶

A worded expression to write in letters.

Sources — the lexicon the word is drawn from — expr_operations, expr_multiples, expr_powers, expr_opposite or expr_words — and, for the words taking two operands, a range for the number: expr_operations 2-9.

Steps — none: the answer is the whole of it, so the answer key draws no ⓘ button.

Options — these, on top of the ones every type reads:

expr_vocab words an expression and asks for it in letters:

(8) expr_vocab expr_words 2-9
    →  Sum of x and 3?        answer:  x + 3
    →  Square of t?           answer:  t²
    →  Quotient of 12 by n?   answer:  12/n

It is the vocabulary the other question types ask the value of — the four operations of the variant=wording forms, the double and the third of multi_vocab and divi_vocab, the square and the cube of square_of and cube_of — asked here of a letter, so that nothing is left to compute and the reading of the word is the whole of the question.

The lexicon is the source, and it is how a sheet avoids repeating itself¶

The word comes from the source, and the source names one of five lexicons:

That is what keeps a worksheet from asking the same word twice. A sheet already carrying a multi_direct 2-9×2-9 -- variant=wording — which has no choice but to say product — asks for its expression elsewhere:

(4) multi_direct 2-9×2-9 -- variant=wording      Product of 7 by 8?
(4) expr_vocab expr_powers                       Square of t?

Nothing does this automatically, and deliberately so: a question drawn before another cannot know what that other will ask, and every word of this vocabulary is already in use by some other type. The author, who sees the whole sheet, is the one who can choose — and a lexicon named on the line is a choice that renders the same way every time.

expr_opposite stands alone rather than inside expr_words because the opposite of y says nothing before the relative numbers are taught: a sheet gets it by naming it, and never stumbles on it.

One source or two¶

The words of expr_operations take a second operand; the others bear on the letter alone. So a lexicon holding any of the four needs a range to draw that number from, and the others take no range at all:

(4) expr_vocab expr_operations 2-9     Sum of x and 3?
(4) expr_vocab expr_powers             Square of t?
(4) expr_vocab expr_words 2-9          either, and the range waits its turn

A range that could draw 0 or 1 is remarked on by check qspec: the sum of x and 0 is a question with nothing left to write.

letters=2 writes the second operand with a second letter instead, and then no range is needed:

(4) expr_vocab expr_operations -- letters=2      Sum of x and y?

A range stated where a given question does not need it is not an error — it is simply never drawn from. That is what lets a line mix the two:

(8) expr_vocab expr_words 2-19 -- letters={1|2}

Each alternative is validated on its own, and the one writing two letters leaves the range alone, as does every question that happens to draw a square. The only thing refused is the reverse — a word that needs a number to be written, with nothing to draw it from:

(8) expr_vocab expr_words -- letters=1      refused: no range for the number

Which operand comes first is drawn¶

Quotient of x by 3? and Quotient of 12 by x? are both asked, and answered x/3 and 12/x respectively. It matters: neither the difference nor the quotient is commutative, and reading the order off the sentence is half of what the question teaches. Difference between x and 3 is x − 3, the same reading subtr_direct gives it in words.

Every writing of the answer is accepted¶

An expression has no single spelling, so the answer is not compared as a string: what is checked is whether what the pupil typed is the expected expression, however written.

Spaces, case and the various signs are folded: × and * are the same multiplication, ÷, : and / the same division, the comma and the point the same decimal separator. The letter x is never read as a multiplication sign — it is a letter.

Two conventions are worth knowing, both positional:

• a number before a letter is a coefficient, 4x being 4 × x;
• a number after a letter is its exponent, x2 being x² — the reading expand_simple already gives 24x2.

A pupil is never forced to reach for ²: the syntax help of the page — the ⓘ button, beside the writing of a multiplication and of a fraction — says that x² may be written x2 or x^2. It is said there and not under the question: a note reading x² may also be written x*x beneath Square of x? would hand the answer over.

An expression that merely happens to be equal is accepted too — 4x² − 4x² + 2x is the double of x, and refusing it would mean drawing a line no rule can draw. What is not accepted is an expression defined elsewhere than the expected one: 2x²/x is 2x everywhere except at 0, which makes it another expression, not another writing of the same one.

frac_decimal¶

A fraction and its decimal writing, one asked from the other.

Sources — one decimal place — digitplaces_small, or a power of ten from 0.1 to 0.001 — or the usual_fractions table, whose fractions are drawn whole.

Steps — none: the answer is the whole of it, so the answer key draws no ⓘ button.

Options — these, on top of the ones every type reads:

A decimal fraction is a fraction over ten, a hundred or a thousand, and it is the same number as its decimal writing. frac_decimal asks for one writing given the other, either way round:

(10) frac_decimal digitplaces_small
     →  78/100 = ?      answer:  0,78     (as a decimal number)
     →  1,3 = ?         answer:  13/10    (as a decimal fraction)

The source draws the place, hence the denominator¶

As for digitplace_*, the source is not the number: it is the place the number goes down to — which is the denominator said the other way round. A number whose last digit sits at the hundredths is a number of hundredths, i.e. a fraction over 100.

digitplaces_small is an alternator: it runs through the three places once per cycle and never twice in a row, so a sheet spreads over the three denominators instead of camping on one. A numrange pins the places a line wants instead — which is how a first sheet stays on the tenths:

(10) frac_decimal 0.1              →  always tenths, always /10
(10) frac_decimal 0.010,0.001      →  hundredths and thousandths

Note the padding in the last one: a numrange takes its step from the precision of its bounds, so the places of a list must be written with the same number of decimals — 0.1,0.01 is refused, 0.100,0.010 is not. For a mix of all three, digitplaces_small says it better anyway.

Anything else is refused by check qspec: 10 is a digit place, but not one a decimal fraction is written on.

The number is drawn from the place upwards¶

width is how many digits the numerator has — a number, or a range from which one is drawn per question (the default is 1-3):

frac_decimal 0.01                   →  0,09   ·   0,47   ·   2,47
frac_decimal 0.001 -- width=1-2     →  0,003  ·  0,043
frac_decimal 0.1 -- width=4         →  473,9

The digits grow leftwards from the place drawn, and the last of them is never a zero. That single rule is what the whole type rests on:

• the number has exactly as many decimals as the place asks for, so 0,70 never comes up where 70/100 was meant;
• it is therefore never a whole number, in either direction;
• and its decimal fraction is unique, which is what makes 1,3 as a decimal fraction a question with one shortest answer.

A width the places cannot hold is narrowed rather than refused: the number and its numerator stay inside the thousandths-to-thousands window, so width=7 on the tenths gives a five-digit numerator, not a number in the millions.

The usual fractions, in two series¶

A content table source draws the fraction whole instead of building a number over a place: usual_fractions holds the ones whose decimal writing is learnt by heart, in the two series a class meets one after the other.

(6) frac_decimal usual_fractions -- series=basic     →  0,25 = ?   ·  1/10 = ?
(6) frac_decimal usual_fractions -- series=extended  →  2,5 = ?    ·  4/5 = ?
(6) frac_decimal usual_fractions                     →  either list

series is a row filter on the table's own column, so it belongs to a table source alone: written on a line drawing over a place, it is refused rather than ignored — as width is over a table. Being an option group like any other, series={basic|extended} draws one of the two lists per question, which balances a block the way to=alternate balances the directions.

What changes for the pupil, over a table, is the fraction asked back: the one the list holds and no other. 0,5 is 1/2, not 5/10 — so the note says (as a simplified fraction), and the rule accepting any equal decimal fraction (below) is deliberately not applied here. The extended series also brings in fractions above 1, whose decimal writing has a whole part: 3/2 is 1,5.

to — which writing is asked for¶

alternate is the default because the two directions are the same knowledge and a sheet should ask both. Being an alternator, it never asks the same way twice running — within a block, questions are shuffled afterwards, so what it guarantees is the balance, not the printed order. random gives up that balance; decimal and fraction pin the direction for a sheet drilling one of them.

The note says which writing is expected¶

1,3 = ? alone would take either writing, and the ? of 78/100 = ? could be filled with 39/50 by a pupil who reduces. So each question carries a note — (as a decimal fraction), (as a decimal number) — which is the instruction a printed sheet would put in its title, moved into the question so that both directions can sit in the same block.

Any equal decimal fraction is accepted¶

13/10, 130/100, 1400/10000 are all correct for 1,3, and there is no end to them. So where a fraction is asked for, the interactive page does not compare against a list: it brings whatever was typed back to the shortest writing and compares that. What passes:

A decimal answer is compared as it is written, 0,78: a decimal writing is unique, and there is nothing to bring back to anything.

No steps, and 25 s¶

The type shows no steps, and offers no info button on the answer key: writing a number the other way round is what the pupil is expected to do at sight, and spelling it out step by step would only restate the question. A line carrying steps=1 for the other types of a mixed block is not turned down — the level simply comes back down to 0, as it does everywhere a type has no step.

The default transduration is 25 s, the time to read the number, count its decimals and write it the other way round.

frac_equal¶

Equality of two fractions with one of its four terms missing.

Sources — two sources, bound by arity and not by position: a product range for the base fraction and a singleton range for the multiplier — 2-9×2-9 2-9.

Steps — one level, what was done to both terms of the complete fraction.

Options — these, on top of the ones every type reads:

frac_equal asks an equality of two fractions with one of its four terms missing:

(6) frac_equal 2-9×2-9 2-9
    →  ?/24 = 2/3      answer:  16

The two fractions are equal because one is the other with both terms multiplied by the same whole number: 16/24 is 2/3 with 8 everywhere. The pupil goes from the complete fraction to the other one by multiplying or by dividing — whichever way the hole faces — or, later on, by a cross product.

Two sources, bound by arity¶

One product range for the two terms of the base fraction, one singleton range for the number they are multiplied by:

(6) frac_equal 2-9×2-9 2-9      the pair 2-9×2-9, the multiplier 2-9
(6) frac_equal 2-9 2-9×2-9      exactly the same thing

Position is ignored: the sources are told apart by their width, as in order_of_2ops. The base fraction is recorded in the pairs table and the multiplier in singletons, so neither comes back before the others have been used.

What the ranges decide¶

Everything. The question type imposes no bound of its own — only that the multiplier be a whole number of 2 or more (1 would write the same fraction twice) and that the base fraction not be 1 (3/3 = 12/12 asks nothing):

(6) frac_equal 2-9×2-9 2-9                    ?/24 = 2/3
(6) frac_equal 20-90[10]×20-90[10] 2-9        20/30 = ?/240
(6) frac_equal 2-9×2-9 2-12                   past the tables, for the drill

The base fraction is not required to be irreducible: 4/6 = 12/18 is a sound question, since what the pupil does is go from one fraction to the other, not simplify either of them. What the model does guarantee is that this step is always a whole number — 20/16 = 15/12 is a true equality, but its step is ¾, and no draw here can produce it.

The terms of a fraction being whole numbers, a range of decimals is refused outright, and check qspec says so before anything is rendered — as it does for a range holding no usable pair (5×5) or no multiplier (1).

Where the hole falls¶

The four terms are numbered by fraction, numerator first:

    0        2                    ?/24 = 2/3   →   0: the ? , 1: 24
   ───  =   ───                                    2: 2     , 3: 3
    1        3

Left to itself the hole moves from question to question, covering the four terms once each before any comes back — so a sheet asks as many multiplications as divisions instead of repeating the same shape. hidden pins it:

(6) frac_equal 2-9×2-9 2-9 -- hidden=0     always the first numerator

A line that pins its hole draws nothing from that rotation, and so leaves the lines around it where they were.

Which fraction is written first¶

order decides which side the base fraction — the smaller one — is written on:

steps — showing what was done to both terms¶

steps=0 is the default, as everywhere in mental calculation: the answer is the missing number alone, and the reasoning stays behind the info button of the answer key. steps=1 writes it out, from the complete fraction to the one missing a term — multiplying or dividing, depending on where the hole fell:

steps=0:   ?/24 = 2/3   →  16
steps=1:   ?/24 = 2/3   →  2/3 = (2 × 8)/(3 × 8) = 16/24
           16/24 = ?/3  →  16/24 = (16 ÷ 8)/(24 ÷ 8) = 2/3

In the middle member the operation is written in red on both terms, its sign included — what that member is there to show is that one and the same thing was done above and below the bar.

Only the missing number is ever accepted as an answer, with or without steps.

frac_of_quantity¶

Calculate a fraction of a quantity given with its unit.

Sources — one product range, its fractions drawn in turn, then two of its products sharing a factor — 2-10×2-10.

Steps — one level, the quantity divided by the denominator then multiplied by the numerator.

Options — these, on top of the ones every type reads:

frac_of_quantity asks for a fraction of a quantity given with its unit:

(8) frac_of_quantity 2-10×2-10
     →  Combien valent 4/5 de 20 L ?      answer: 16 L

The fraction is always irreducible: simplifying a fraction is another exercise, and is not mixed into this one. It is proper unless proper says otherwise (see below). The quantity is always a multiple of the denominator, so both the division and the multiplication fall right, inside the tables.

One source: a fraction, then two products¶

The three numbers come from one product range, as two products sharing a factor, a × b and a × c. The fraction is b/c, the quantity a × c and the answer a × b:

4 × 4 and 4 × 5   →   4/5 of 20    answer: 16
3 × 5 and 3 × 8   →   5/8 of 24    answer: 15

They are drawn in two steps, each with its own tracking:

1. The fraction first, among those the range allows: two coprime values of the range, with some factor of the range — other than 0 or 1 — making a product with each. 2-10×2-10 allows 22 fractions, from 2/3 to 9/10. They are recorded in a tracking table of their own, so a sheet goes through all of them before asking one again — a range allows only a few dozen fractions, and chance alone would ask the same one several times in a row, whatever the quantity.
2. Then the two products a × b and a × c, drawn around the fraction. They are recorded in the pairs table, like multi_direct, so a fraction of a quantity and a multiplication on the same sheet do not ask the same fact twice: no 7/9 of 72 right after 7 × 8.

The range decides which fractions can come up. 2-10×2-10 keeps the denominators at 10 and leaves out the fractions of numerator 1; 1-10×1-10 brings 1/2 … 1/10 in. A shared factor of 1 is never chosen — 1 × 4 and 1 × 5 would ask for 4/5 of 5, which is the numerator itself — but a range holding 1 stays usable: the 1 ends up in the fraction, as in 1/3 of 21 g.

The range must hold at least one such fraction — 1×2-9 does not, nor does 3×2-8[2], all of whose fractions are fractions of two even numbers. check qspec says so before anything is rendered.

proper — proper or improper fractions¶

An improper fraction is a proper one turned over, so proper=false draws from the same fractions of the range, the ones of numerator 1 aside — turned over, 1/7 would be 7/1, a whole number. With proper=any they stay proper.

unit — the unit of the quantity¶

Without unit, the quantity is given in any unit of the length, mass and capacity ladders, drawn per question: km … mm, kg … mg, hL … mL. All of them, the rarer ones included, so that the pupils meet them too — but for the kilolitre, which nothing is measured in.

unit narrows that choice, to one unit or to the units of one quantity:

(8) frac_of_quantity 2-10×2-10 -- unit=mass        kg … mg
(8) frac_of_quantity 2-10×2-10 -- unit=cL          always cL
(8) frac_of_quantity 2-10×2-10 -- unit={kg|g}      one of the two per question

The answer is counted in the unit of the quantity. That unit is printed inside the answer box, against its right edge, and the pupil types the number alone. On a slide, which has no box, the correction writes it after the number.

steps — divide, then multiply¶

steps=0 (the default) gives the result alone; steps=1 writes the calculation out — the quantity divided by the denominator, then multiplied by the numerator:

steps=0   16
steps=1   20 L ÷ 5 × 4 = 4 L × 4 = 16 L

At steps=0, the calculation is still one click away on the live page — see The steps option.

The wording agrees with the numerator¶

In French the verb agrees with the fraction — Combien vaut ⅕ de 20 L ?, Combien valent ⅘ de 20 L ? — so the question is written with one of two sentences, depending on whether the numerator is 1. Each is translated as a whole.

frac_simplify¶

A fraction to simplify, whose terms share a whole divisor by design.

Sources — two sources, bound by arity and not by position: a product range for the base fraction and a singleton range for the number both its terms are multiplied by — 2-9×2-9 2-9.

Steps — one level, both terms divided by their common divisor.

Options — these, on top of the ones every type reads:

frac_simplify shows one fraction and asks for it simplified:

(6) frac_simplify 2-9×2-9 2-9
    →  Simplify 18/24      answer:  3/4

The fraction is the one frac_equal writes on its multiplied side: a base fraction with both terms multiplied by the same whole number. The multiplier being 2 or more, the fraction shown always comes down — the pupil never meets one that is already irreducible.

The base fraction is drawn irreducible, so that what brings the fraction all the way down is the multiplier and nothing else: the range that draws the multiplier is what a sheet's difficulty rests on, and 2-9 keeps it within what is done in the head. The irreducible option, below, says otherwise where a harder fraction is the point.

Two sources, bound by arity¶

One product range for the two terms of the base fraction, one singleton range for the number they are multiplied by — the sources of frac_equal, read the same way:

(6) frac_simplify 2-9×2-9 2-9      the pair 2-9×2-9, the multiplier 2-9
(6) frac_simplify 2-9 2-9×2-9      exactly the same thing

Position is ignored: the sources are told apart by their width, as in order_of_2ops. The base fraction is recorded in the pairs table and the multiplier in singletons, so neither comes back before the others have been used.

What the ranges decide¶

How big the terms grow, and how far the fraction has to come down:

(6) frac_simplify 2-9×2-9 2-9                    Simplify 18/24
(6) frac_simplify 2-9×2-9 2-4                    one small divisor to find
(6) frac_simplify 2-9×2-9 6,8,9                  the divisor is never small

The terms of a fraction being whole numbers, a range of decimals is refused outright, and check qspec says so before anything is rendered — as it does for a range holding no usable pair (5×5), no multiplier (1) or no pair on the side irreducible asks for (2-8[2]×2-8[2], two even numbers every time).

irreducible — how far the fraction has to come down¶

The three values of the fractions table column of the same name, read the same way — divi_direct reads them too:

A reducible base compounds: 4/6 multiplied by 9 gives 36/54, which comes down by 18 — past what a 5e does in his head, though the multiplier drawn was a perfectly reasonable 9. irreducible=true rules that out, and pins the divisor of the fraction shown to the multiplier itself:

(6) frac_simplify 2-9×2-9 3                              always ÷3
(6) frac_simplify 2-9×2-9 3 -- irreducible=false         ÷6, ÷9, ÷12…

irreducible=any is also what a range with no irreducible pair to offer asks for — a range of round numbers, typically:

(6) frac_simplify 20-90[10]×20-90[10] 2-9 -- irreducible=any    Simplify 240/360

Every simplification is accepted¶

The answer key gives the irreducible fraction, and an interactive page accepts it — but it also accepts the fraction stopped on the way down:

Simplify 18/24   →   3/4, and 6/8 and 9/12 too

which is the 5e reading of the instruction: simplify, not make irreducible. What is refused is a fraction merely equal to the one shown: 36/48 is 18/24 multiplied, not simplified, and answers nothing.

A sheet marked by hand is a different matter — the answer key shows the irreducible fraction alone, and what a half-simplified answer is worth is for whoever marks it to decide.

steps — showing the division¶

steps=0 is the default, as everywhere in mental calculation: the answer is the simplified fraction alone, and the reasoning stays behind the info button of the answer key. steps=1 writes the division out:

steps=0:   Simplify 18/24   →  3/4
steps=1:   Simplify 18/24   →  18/24 = (18 ÷ 6)/(24 ÷ 6) = 3/4

The division is written in red on both terms, its sign included — what that middle member is there to show is that one and the same thing was done above and below the bar.

Where the divisor is not prime, the info button offers the other way beside it: dividing one prime factor at a time, each member carrying its own division —

(18 ÷ 2)/(24 ÷ 2) = (9 ÷ 3)/(12 ÷ 3) = 3/4
(24 ÷ 2)/(72 ÷ 2) = (12 ÷ 2)/(36 ÷ 2) = (6 ÷ 2)/(18 ÷ 2) = (3 ÷ 3)/(9 ÷ 3) = 1/3

which is how a pupil who does not see the 6 at once gets there, and which passes through the answers he may stop on. The division being in red on the black fraction it bears on, the fraction it lands on is the next member: only the last one, the result, carries no division.

fraction_of_a_rectangle¶

Which fraction of a ruled rectangle is coloured.

Sources — a product range for the fraction, with an optional singleton range for the number of rows — 1-10×1-10 2-4 — or two product ranges, the grid and its coloured part — 2-5×2-5 2-5×2-5.

Steps — one level, the fraction simplified where it can be; the number of cells counted is behind the info button.

Options — the ones every type reads only.

fraction_of_a_rectangle draws a ruled rectangle with some of its cells coloured, and asks which fraction of the figure they are:

(4) fraction_of_a_rectangle 1-10×1-10 2-4
    →  [a 3×5 grid, two columns greyed]  Which fraction of the figure is greyed?
       answer:  6/15

The figure is a rectgrid{}, drawn beside the sentence on a worksheet and under it on a slide, its coloured cells starting from a corner drawn at random.

Greyed or coloured¶

The colour of the cells depends on the kind of page, as the configuration sets it for every grid (rendering.rectgrids.fill_color and its fill_color_grid, fill_color_page, fill_color_slide variants): grey on a worksheet, since an assessment is printed in black and white, and a colour drawn at random from fill_palette on a slide.

The sentence follows the colour actually drawn. A grey figure asks Which fraction of the figure is greyed? — "coloured", on a grey figure printed in black and white, leaves many pupils asking which part is meant to be coloured — and any other asks about its coloured part. The explanation behind the info button says it the same way. The colour is written into the question, so a snapshot keeps both the colour and the word that goes with it.

Two ways of drawing the figure¶

The sources are told apart by their width, never by their position, as for frac_equal:

(4) fraction_of_a_rectangle 1-10×1-10           a fraction, over one row
(4) fraction_of_a_rectangle 1-10×1-10 2-4       a fraction, over 2 to 4 rows
(4) fraction_of_a_rectangle 2-5×2-5 2-5×2-5     two rectangles

A fraction. The product range is the fraction itself, the smaller value over the bigger one: 3/7 is a strip of seven cells, three of them coloured. The singleton range, when there is one, is the number of rows it is spread over, which multiplies both of its terms: 2/5 over three rows is a 3×5 grid with two full columns coloured — 6/15 counted cell by cell, 2/5 read column by column. Without a singleton range, one row.

The fraction is drawn irreducible, and proper: a pair of equal values, a 0, or two values sharing a divisor (2×4) is left out of the draw. Enlarging the fraction is what the rows are for.

Two rectangles. One is the grid, the other the coloured area — the bigger of the two is the grid, and they are never drawn with the same area. The coloured area is a number of cells, which the figure arranges into whatever fits (see What the fill descriptor says): ten cells coloured in a 3×4 grid are the grid coloured whole but for a white 1×2 in a corner. Those figures cannot be read by columns: the cells have to be counted.

These reproduce the four sources mathmaker used for this question:

check qspec refuses a range of decimals (a grid is made of whole cells), a product range holding no usable fraction, a singleton range holding no number of rows, and two product ranges that can only give one area.

The answer¶

The answer key gives the fraction the cells count — coloured cells over all of them — followed, when it can be simplified, by its biggest simpler writing, an ellipsis saying when there are more:

3/7
6/15 (or 2/5)
18/30 (or 9/15…)

— so that whoever corrects a printed sheet does not take 9/15 for a mistake. Every fraction equal to it is accepted: 2/5, 4/10, 6/10…

steps=1 simplifies it instead, dividing both terms by their greatest common divisor, written in red on both:

steps=1:   6/15 = (6 ÷ 3)/(15 ÷ 3) = 2/5

Behind the info button, that simplification comes after a sentence saying what was counted — 18 cells out of 30 are greyed. — and, where the fraction has more than one simpler writing, beside a second chain listing them all, from the biggest down (Or else: 18/30 = 9/15 = 6/10 = 3/5): each of them is a right answer.

Size of the figure¶

Each cell has the side the configuration sets for the kind of page (rendering.rectgrids.cell_size_ratio and its cell_size_ratio_grid, cell_size_ratio_page, cell_size_ratio_slide variants), so a grid of more columns is a wider figure. It is only drawn with smaller cells when it would outgrow its room: at most about 6 em by 3 em on a worksheet, beside its sentence, so a 6×6 grid does not stretch its row of the sheet to twice the height of the others; 9 em by 5 em on a plain page; 15 em by 9 em on a slide, where the grid is alone and its cells are counted from the back of the room.

On a slide the answer is written beside the figure (answer_layout=side), not under it, which would take its height from the cells; answer_layout=below on the line puts it back underneath.

The time a slide gives the question grows with the number of cells to count: 20 s up to 25 cells, 25 s up to 40, 30 s beyond.

mini_pb_time¶

Time mini-problem.

Sources — clocktimes alone: a departure and an arrival drawn in the frame of the context.

Steps — one level, the operation the story calls for.

Options — these, on top of the ones every type reads:

A story gives two of three times — the start, the duration, the end — and asks for the third. The operation is not written: finding which one the story calls for is half of the exercise.

ask=alternate, the default, takes the three in turn, so that a sheet never asks the same thing twice running; ask=random draws one each time.

The times are drawn by the clocktimes source — the only one this type reads — and carry by default whatever is asked: the minutes are drawn so that the addition makes sixty minutes into an hour and both subtractions borrow one. carry=false asks the other way round.

context — the story, and how closely its times are told¶

context names the story, which sets both the frame of the times and how closely they are told: a timetable gives them to the minute, a film showing to five minutes, and nobody sets out on a hike at 8 h 37 min. context=any, the default, takes the contexts in turn.

The start leaves room for the shortest duration, and the end stays within reach of the start and inside its own bounds. The contexts told to five or ten minutes come first in a progression; the timetables, to the minute, are harder.

step, in minutes, can only make the times rounder: context=train step=10 draws a timetable to ten minutes, while context=hike step=1 still draws its times to ten. Where the step and the precision do not divide each other, the times move by both: context=hike step=4 draws them every twenty minutes.

Answer and steps¶

The answer is typed in hours and minutes, … h … min, the hours drawn even where there are none. steps=1 writes out the operation the story called for — 20 h 30 min + 1 h 40 min = 22 h 10 min — and the ⓘ button of the answer key shows it otherwise. A story is given 40 s.

multi_direct¶

Multiplication.

Sources — one product range, of two factors or more — 2-9×2-9.

Steps — none on a plain product, which its answer says whole; one level under scale or decimals — the fact, the power of ten, the result — or under variant=wording.

Options — these, on top of the ones every type reads:

multi_direct 2-9×2-9 asks the times table as it is learnt. Three options change what it draws: scale puts zeros on the factors, decimals moves their point left, and carry says whether the multiplication may carry.

scale — the same table, followed by zeros¶

scale asks the same table followed by zeros:

(10) multi_direct 2-9×2-9 -- scale=1-3
     →  40 × 600 = ?      answer:  24 000
     →  4 × 6000 = ?      answer:  24 000
     →  7 × 80 = ?        answer:  560

The value is the number of zeros the result gains — one to three above, scale=2 for exactly two — which is how the calculation is done: the fact, then the zeros. Where they land is drawn for each question, every split being as likely as the others, so one factor carrying them all comes up as readily as a balanced pair. Writing the split out instead — scale=2×1, one number per factor — pins the form, as decimals does below.

Left out, the option changes nothing: multi_direct 2-9×2-9 stays the plain table. scale=false says the same thing explicitly, which is what a line of a mixed block writes to stay out of it; and -- scale={default|1-3} mixes plain and scaled questions on one line, each question drawing its own.

decimals — the same table, with the point moved¶

decimals is scale the other way round: instead of zeros the result gains, it counts the ranks its point moves left.

(10) multi_direct 2-9×2-9 -- decimals=1
     →  0,4 × 6 = ?       answer:  2,4
     →  8 × 0,7 = ?       answer:  5,6
(10) multi_direct 2-9×2-9 -- decimals=2
     →  0,7 × 0,3 = ?     answer:  0,21
     →  4 × 0,06 = ?      answer:  0,24

Everything scale promises holds here, the direction aside: the numbers still come from the table the line names, decimals=false opts a line out, -- decimals={default|1} mixes whole and decimal questions, and steps=1 shows the calculation as it is done — the digits multiplied, then the point placed.

What the option promises is exactly that the point moves that many ranks, not that the result shows that many decimals: 0,5 × 4 is 2, and 0,2 × 0,5 is 0,1. A fact whose product ends in a zero loses it on the way, which is arithmetic rather than a miscount — and 0,5 × 4 = 2 is worth asking.

The split spelled out¶

Written as a single number, decimals=2 lets the draw choose which factor takes the ranks: 0,7 × 0,3 and 4 × 0,06 both come up. Those are two different exercises, and a progression usually wants them one belt apart. So the value may spell the split instead, one number per factor:

(10) multi_direct 2-9×2-9 -- decimals=1×1     →  0,7 × 0,3     (one rank each)
(10) multi_direct 2-9×2-9 -- decimals=2×0     →  4 × 0,06      (both on one)
(10) multi_direct 2-9×2-9×2-9 -- decimals=1×1×0

The × echoes the shape of the source — one member per factor, zeros included — and * is accepted for it as the numranges accept it. The split is read as a set: the factors are shuffled, so 2×0 and 0×2 name the same line, and which factor ends up with the ranks is drawn.

A belt meeting the two first forms and nothing else writes them as alternatives, each question drawing its own:

(10) multi_direct 2-9×2-9 -- decimals={1|1×1}

scale reads the same spelling: scale=2×1 is 400 × 60, where scale=3 would also have given 4 × 6000.

scale and decimals together — 40 × 0,6¶

The two options are not rivals: they are two budgets of powers of ten, and a factor takes at most one of them. Asked together, they land on distinct factors — one gains zeros, the other loses ranks:

(10) multi_direct 2-9×2-9 -- scale=1 decimals=1
     →  40 × 0,6 = ?     answer:  24
     →  0,8 × 70 = ?     answer:  56

Their displacements compensate, so the result is the table fact itself — which is the whole point of those products, and what steps=1 shows:

(5) multi_direct 2-9×2-9 -- scale=1 decimals=1 steps=1
    →  40 × 0,6 = ?
       answer:  4 × 6 = 24

Nothing forces them to compensate: scale=2 decimals=1 moves the result one rank up, and the chain then reads 4 × 6 × 10 = 24 × 10 = 240.

Both budgets need a factor of their own, so a pair of factors carries at most one of each. Ask for more than the drawn factors can hold — two ranks on separate factors and a zero besides, on a product of two — and the line is refused, by check qspec where the source says how many factors it draws, and by the draw otherwise.

Why not a range of multiples of ten, or of decimals¶

Because 20-90[10]×20-90[10] and 0.2-0.9×0.2-0.9 would be a different exercise. The numbers a shifted question shows are still drawn from the range the line names, and the powers of ten are laid on afterwards: the pupil recognises 4 × 6 under 40 × 600 and under 0,4 × 0,6, and the anti-repeat tracking of the pairs table sees the same thing — the fact is spent for the sheet, whatever coat it came in. Draw the shifted numbers directly and the same table fact can come back three times, because 4 × 6, 40 × 60 and 0,4 × 0,6 are three unrelated pairs.

How far the powers of ten go¶

scale=1-3 is what a mental-calculation sheet usually wants: three zeros on top of 9 × 9 still reads as 81 000. Nothing caps it, though — scale=1-5 is a legitimate exercise for a class that has just met the millions. check qspec only warns past six zeros, where counting them starts being the exercise instead of the multiplication, and the line renders all the same.

decimals is warned about sooner, past three ranks: a decimal part is read digit by digit, and past the thousandths it is no longer held in the head. decimals=1-2 is the usual ask.

Both are counted from 1: scale=0 and decimals=0 are refused rather than read as a plain product, which the option's absence already says. A split laying nothing anywhere — decimals=0×0 — is refused for the same reason.

Steps, and the pace it sets¶

A power of ten is what gives multi_direct something to explain, so scale and decimals open level 1 of steps:

(5) multi_direct 2-9×2-9 -- scale=3 steps=1
    →  40 × 600 = ?
       answer:  4 × 6 × 1 000 = 24 × 1 000 = 24 000

(5) multi_direct 2-9×2-9 -- decimals=1×1 steps=1
    →  0,4 × 0,6 = ?
       answer:  4 × 6 ÷ 100 = 24 ÷ 100 = 0,24

The chain is the calculation as it is done: the digits multiplied as a table fact, then the point placed — to the right for the zeros of scale, to the left for the ranks of decimals. Where the two compensate it stops at the fact, 40 × 0,6 = 4 × 6 = 24, a third member repeating the second.

Wherever a factor is written with a point, the ⓘ button also carries the rule in words, under the chain, reaching the result without any power of ten:

0,4 × 6      →  In other words: work out 4 × 6 = 24, then put one digit
                after the point: 2,4.
400 × 0,6    →  In other words: work out 400 × 6 = 2 400, then put one digit
                after the point: 240,0, that is 240.

It is read on the factors as they are shown — what the pupil multiplies in 400 × 0,6 is 400 by 6 — where the chain reads the table fact behind them. The two are the same reasoning, and a pupil reads one or the other; the sentence is therefore still offered at steps=1, where the chain is already on the page. A product drawn decimal by its source, with neither option on, gets it too.

At steps=0 — the default — the answer key shows the result alone and keeps that chain behind its ⓘ button, and a correction slide behind its Steps button.

A shifted question is also given longer: 24 s instead of the 20 s a plain table fact gets, the fact being recalled and pointed. It stays a default — -- transduration=20 on the line wins.

A factor that is a power of ten — the rule that names the displacement¶

multi_direct 0.001-10.000×10,100,1000 is not a table fact under a coat of zeros: the × 1 000 is the exercise, and it is done by the rule that names the displacement rather than by multiplying and pointing afterwards. So where one of the two factors drawn is a power of ten, that is the sentence the ⓘ button carries instead of the one above:

5,265 × 1000   →  In other words: multiplying by 1 000 moves the point three
                  ranks to the right: 5,265 → 5 265.
2,5 × 1000     →  In other words: multiplying by 1 000 moves the point three
                  ranks to the right, the empty ranks filled with zeros:
                  2,5 → 2 500.
0,1 × 52,65    →  In other words: multiplying by 0,1 moves the point one rank
                  to the left: 52,65 → 5,265.

The general rule holds there too — 5,265 × 1 000 is 5 265 × 1 000 pointed three ranks in — but it reaches the result the long way round, and reads 5 265,000, that is 5 265 at the end of it. A sheet asking for the thousandfold is asking for the displacement, so the displacement is what the sentence says.

Nothing on the line asks for this: the draw decides, and the same line may show one rule or the other from one question to the next. The condition is that the displacement be the whole of the calculation:

• two factors, one of them a power of ten. Past that, 0,5 × 3 × 100 is not something one rule finishes, and the general sentence comes back. Both of them being one — 0,1 × 100, which a range of decimals may well draw against a 100 — the whole one is the multiplier the pupil reads.
• a point somewhere: under × 0,1 the power of ten carries it itself. Without it the question is a whole-number table fact, and 10 × 7 is left with no sentence at all — the rule has nothing to say there that the answer does not, and a times-table sheet is not improved by an ⓘ button on every one of its answers.

Where the point runs past the last digit written — 2,5 × 1000, 7 × 0,01 — the sentence says the zeros that fill the ranks it leaves behind, that being exactly where the pupil stops.

The rule is read on the factors as they are shown, like the general one: scale and decimals lay their powers of ten on the factors of a table fact, never as a factor, so a line carrying them keeps the general sentence — 400 × 0,6 is 400 multiplied by 6 and pointed, not a displacement. multi_vocab is left out of it altogether: its word stands for the multiplication, so the triple of 0,1 is three tenths and not a point moved one rank left by a factor the question never shows.

The types that read them too¶

multi_vocab and multi_expand derive from multi_direct, and take both options in the way their own question allows:

(6) multi_vocab 2-4×2-9 -- scale=1-3
    →  How much is double 400?      →  How much is triple 8000?

(6) multi_vocab 2-4×2-9 -- decimals=1
    →  How much is double 0,4?      →  How much is triple 0,9?

(6) multi_expand 2-9×2-9 -- scale=1-2
    →  230 × 5 = ?      answer, at steps=1:  200 × 5 + 30 × 5 = 1000 + 150 = 1150

(6) multi_expand 2-9×2-9 -- decimals=1
    →  2,3 × 5 = ?      answer, at steps=1:  2 × 5 + 0,3 × 5 = 10 + 1,5 = 11,5

For multi_vocab the power of ten always goes on the operand: the word names the other factor, and there is no double of 20, nor of 0,2. When both drawn factors could name the word — a 3 and a 4 — the one it spares is the one the word takes. It gains the same steps=1 chain as multi_direct, on the multiplication behind the word: 8000 × 3 = 8 × 3 × 1000 = 24 × 1000 = 24 000. Only one factor being within reach, a line asking for two — a split decimals=1×1, or scale and decimals at once — is refused.

For multi_expand they land on the number, on the lone factor, or one on each, and the expansion follows: 230 is split into 200 + 30, and 2,3 into 2 + 0,3, exactly as 23 is split into 20 + 3. The type already shows its calculation at steps=1, so neither option adds a level there; and it keeps its 30 s, a shifted expansion being no quicker than a plain one.

area_rectangle reads them too, without deriving from multi_direct: its two dimensions are a product, and the options lay their powers of ten on them — 40 cm × 6 cm, 0,4 cm × 0,6 cm. Two dimensions is all it has to spend them on, and a shift that would make them equal has them swapped rather than drawing a square.

carry — a multiplication that carries nowhere¶

carry=false draws a multiplication no column carries, carry=true one where at least one does — the same word, and the same promise, as on addi_direct and subtr_direct.

What it is mostly there for is the eleven-times table, whose trick only works while the two digits stay under ten — 27 × 11 is 2, then 2 + 7, then 7:

(10) multi_direct 11×11-99 -- carry=false
     →  11 × 27 = ?      →  45 × 11 = ?      →  11 × 71 = ?
(10) multi_direct 11×11-99 -- carry=true
     →  11 × 39 = ?      →  88 × 11 = ?      →  11 × 57 = ?

The columns are read the way the multiplication is written by hand: each digit of one factor against the whole of the other, the partial products then added up. A column of that sum holds the digit products that land in it, so one reading covers both stages — a partial product that carries puts its column above nine too. It follows that the option is symmetric (11 × 27 and 27 × 11 carry alike), that the point of a decimal is set aside (0.4 × 0.2 carries no more than 4 × 2), and that on the plain times table carry=false is exactly a product under ten: 2-9×2-9 -- carry=false leaves four products, which check qspec warns about.

scale and decimals are no obstacle: a power of ten only shifts the columns, so 40 × 600 and 0,4 × 0,6 carry exactly where 4 × 6 does, and the option judges the factors as the source drew them. multi_vocab and area_rectangle read carry the same way. multi_expand refuses it rather than ignore it: its two products are drawn as a linked pair — one sharing a factor with the other — which no constraint narrows.

The draw is narrowed exactly as the operation types' constraints are, and an impossible or a tight spec is reported the same way — see What the constraints do to the draw.

multi_expand¶

Multiplication of a two-digit number, to be expanded to be done.

Sources — one product range, drawn twice as a linked pair sharing the factor — 2-9×2-9.

Steps — one level, and there is no other: the expansion, the two products it yields, then the result.

Options — these, on top of the ones every type reads:

carry is refused here: its two products are drawn as a linked pair, which no constraint narrows.

multi_expand asks a plain multiplication — but one that has to be expanded to be done in one's head:

(6) multi_expand 2-9×2-9
    →  23 × 5 = ?      answer:  115

Nothing on the page says how to proceed: finding the decomposition is the exercise. To multiply 23 by 5 the pupil splits 23 into 20 + 3 and adds the two products, 5 × 20 and 5 × 3 — the first step towards the literal expansion expand_simple asks for later on.

One source, two linked products¶

The two products the pupil performs are exactly the two the question draws, as a linked pair sharing the factor: 5 × 2 and 5 × 3 for 23 × 5. They come from one product range, the ordinary multiplication-table one:

(6) multi_expand 2-9×2-9      one source, two products drawn from it

The two factors that are not the shared one are the digits of the number: 2 and 3 make 23. Both products are recorded in the pairs table, like multi_direct, so a sheet asking 23 × 5 cannot ask 5 × 3 on its own a few questions later.

The range therefore decides which multiplications the expansion calls for:

(6) multi_expand 2-9×2-9      digits and factor within the tables
(6) multi_expand 1-9×1-9      the ×1 cases too — 91 × 7, done as 7 × 90 + 7 × 1
(6) multi_expand 3-9×3-9      nothing below 3 anywhere

A shared factor of 0 or 1 is never chosen — 1 × 23 leaves nothing to expand — but a range holding 1 stays perfectly usable: the 1 becomes a digit, as above. A product carrying a 0 never reaches the draw either, so the number is never a multiple of ten: 30 × 6 needs no expanding.

Repeated digits¶

22 × 5 and 44 × 7 are worth asking, and they are drawn: the question then holds a single product, 5 × 2 done twice over, so a single pair is drawn and recorded. It happens exactly as often as any other companion — one time in k + 1, where k counts the other products carrying the shared factor, which is one time in eight for 2-9×2-9.

steps — showing the whole calculation¶

Mental calculation asks for the result and nothing else, so steps=0 is the default — and on the live page the whole calculation stays one click away, see The steps option. On a written sheet, half an explanation explains nothing: steps=1 shows the expansion, the two products it yields, and the result, and there is no level above it.

steps=0:   5 × 23 = ?   →  115
steps=1:   5 × 23 = ?   →  5 × 20 + 5 × 3 = 100 + 15 = 115

The expansion keeps the factor on the side the question shows it, so the step reads as the calculation asked and not as its mirror:

5 × 23 = ?   →  5 × 20 + 5 × 3 = 100 + 15 = 115
23 × 5 = ?   →  20 × 5 + 3 × 5 = 100 + 15 = 115

Whichever comes first is drawn at random, as in multi_direct; shuffle=false keeps the factor in front. Only the result is ever accepted as an answer, with or without steps.

What the source may hold¶

The digits are digits: a range of decimals is refused outright, and a range reaching past 9 is only warned about — 3 and 12 still give 42 = 30 + 12, and the answer stays right, but that is no longer the decomposition the digits of 42 show. As for expand_simple, a range holding no two products sharing a factor other than 1 cannot work at all, and check qspec says so before anything is rendered.

multi_hole¶

Missing factor in a product.

Sources — one product range, of two factors or more, or the fractions table — 2-9×2-9, fractions.

Steps — none: the answer is the whole of it, so the answer key draws no ⓘ button.

Options — these, on top of the ones every type reads:

multi_reversed¶

Product equal to a provided number.

Sources — one product range of exactly two factors — 2-9×2-9; their product is what the question shows.

Steps — none: the answer is the whole of it, so the answer key draws no ⓘ button.

Options — the ones every type reads only.

multi_vocab¶

Double, triple or quadruple of a natural number.

Sources — one product range of exactly two values, one of which is 2, 3 or 4 — the word names it — 2-4×2-9.

Steps — none by itself; one level under scale or decimals, on the multiplication the word stands for.

Options — these, on top of the ones every type reads:

order_of_2ops¶

Order of operations, two operations.

Sources — a product range for the ×/÷ block and a singleton range for the standalone term, bound by arity and not by position — 7-19 4-9×4-9; the split family (9-16) needs the product range alone.

Steps — one level, the intermediate expression written before the result.

Options — these, on top of the ones every type reads:

The 24 shapes above form three families of eight, ordered by teaching sequence:

Within each family the order is the same: the four additive shapes, then the four subtractive ones; in each half, the block on the right then on the left, × before ÷. So n and n + 16 are the same shape, with and without its redundant parentheses.

Family 9-16 is built differently from the other two. It does not draw three independent numbers: it starts from a multiplication or division fact — exactly what multi_direct and divi_direct draw — and rewrites one of its operands as a sum or a difference. So it needs the product source only, and a line selecting nothing else takes a single source:

(6) order_of_2ops 4-9×4-9 -- variant=split
    →  (3 + 4) × 6 = ?      (the fact is 7 × 6; 7 is decomposed)
    →  81 ÷ (13 − 4) = ?    (the fact is 81 ÷ 9; the divisor is decomposed)

A selection spanning several families still needs both sources; check qspec says so when one is missing, and warns when one goes unused.

See Selecting variants for the variant selector syntax.

result — keeping numbers positive¶

By default no sign constraint applies, so 31 − 4 × 6 and 16 − 5 × 9 are both drawable. result=positive (for grades where negative numbers are not taught yet) and result=negative constrain the outcome.

The constraint is met in one of two ways, never by inventing a number outside a declared range:

• The standalone term must dominate the block (a − b × c, a − b ÷ c, numbers 5, 6, 21, 22). It is then built as block + result, which means the singleton range describes the result, not the first operand. With 7-19 4-9×4-9 you get 31 − 4 × 6 = 7 or 56 − 6 × 7 = 14: the displayed minuend leaves the range on purpose, the result never does.
• The standalone term is dominated by the block (a × b − c, a ÷ b − c, numbers 7, 8, 23, 24). It stays a displayed operand and both draws are narrowed to the values that fit.

The second case can get tight: in a ÷ b − c the whole expression is worth at most the quotient, so with 4-9×4-9 it never exceeds 9 and a singleton range of 7-19 leaves only two usable values. automath check qspec reports this before you render anything — see Validating specs.

tricks may set this convention aside; see below.

The split family (9-16) needs none of this: it decomposes a fact that is already positive, so its parenthesis and its result always are too. For the same reason result=negative is impossible there and is rejected.

decimals — one digit after the decimal point¶

For families 1-8 and 17-24, decimals=1 divides the standalone term and one operand of the block by 10, so both additive terms are scaled alike. Accepted values run from 0 to 4. Three consequences worth knowing:

• the sign of the expression is unchanged, so a result=positive combination stays valid after scaling;
• for a quotient block it is the dividend that is scaled, so the divisor stays a whole number — a division by a decimal is never introduced;
• the draw itself still works on whole-number pairs, which keeps the benefit of the anti-repeat tracking: drawing 6 × 8 here still prevents the same pair coming up again in a neighbouring multi_direct question.

(6) order_of_2ops 7-19 4-9×4-9 -- variant=17 decimals=1
    →  1,1 + 0,7 × 9 = ?

For the split family (9-16), decimals is instead the step of the decomposition — the promise to the user is the same, the mechanism differs because there is a single fact to decompose rather than two terms to scale:

(6) order_of_2ops 4-9×4-9 -- variant=9 decimals=1
    →  (2,2 + 4,8) × 5 = ?

There, the additive splits are the interesting ones. A subtractive split of a whole target can never carry a borrow: x − y = n with n whole forces frac(x) = frac(y), so (11,8 − 5,8) × 4 is a whole-number subtraction in disguise. This is arithmetic, not a shortcoming of the generator — the cure is a decimal target, which comes from the source:

(6) order_of_2ops 0.1-9.9×10,100 -- variant=13,15
    →  10 × (5,3 − 1,9) = ?        (the fact is 3,4 × 10)

The round factor is never the one decomposed: it is what makes the final multiplication easy.

tricks — baiting the precedence error¶

A pupil who gets the precedence wrong computes first the operation next to the standalone term. Whether that mistake is cheap or expensive is entirely in the generator's hands, and it changes the exercise:

22 − 4 × 3 = ?     the error leads to 18 × 3 — a long detour for nothing
14 − 4 × 3 = ?     the error leads to 10 × 3 — instant, and therefore tempting

tricks is the probability of deliberately setting that bait, where one is reachable. It defaults to 0.5; tricks=1 baits whenever possible, tricks=0 never does so deliberately — some baits still occur by chance, there is no way to forbid them without distorting the draw.

One rule covers the eight shapes: the wrong first step must land on a value that makes the second step cheap — a multiple of ten before a ×, an exact division before a ÷.

The choice is made before the pair is drawn, so the fact itself is steered towards one that admits a bait, and the display order of a product is settled the same way — which factor faces the standalone term decides whether the bait exists at all.

Two nuances worth knowing:

• when the bait is out of reach, a second tier applies: a wrong path that is merely cheap rather than outright easy. This is what carries variant 23, where b − c cannot be a positive multiple of ten as long as the pair source only yields single-digit factors — with 4-9×4-9 you get 7 × 9 − 7, so the error costs 7 × 2 and no more;
• variant 22 is the one shape whose wrong path can divide exactly while being negative (12 − 16 ÷ 4). That is deliberately kept: a pupil who has not met negative numbers loses no time there either — they see at once that the path is closed, which is exactly what baiting is for.

tricks=1 narrows the draw to the combinations that bait, so variety drops: on 4-9×4-9 with 6-19, variant 21 goes from 57 distinct questions per 60 draws down to 41. The default 0.5 keeps both. Variant 24 is narrow to begin with — automath check qspec says so.

The range as a derogation¶

One shape cannot bait inside its own range at all: in a − b ÷ c the dividend usually dwarfs the standalone term, so a − b can only dead-end on a negative number. With ... − 32 ÷ 8 and a range of 6-19, no value sits above 32.

When baiting, the range is therefore also read as a distance above the block operand facing the standalone term: the offsets 8 and 16 give 40 − 32 ÷ 8 and 48 − 32 ÷ 8, whose wrong path is 8 ÷ 8 and 16 ÷ 8. The declared range still governs — it describes the offset instead of the value.

Only a minuend derogates, that is a shape written a − …. A subtrahend (… − c, variants 7, 8, 23, 24) never does: it only ever needs to be smaller than the block, which its own range already allows, so shrinking it below what was asked would be taking a liberty rather than lifting an obstacle.

Both readings compete at equal bait quality, and the winner is drawn in proportion to how many values it offers, so the handful of in-range combinations cannot shut out the far larger derogated set.

This is a genuine derogation, and it is the one case where the range is left: under result=positive, a − b ÷ c then puts its result outside the declared range (about half the time at tricks=0.5, nearly always at tricks=1; never at tricks=0). Everything else still holds — the sign constraint, and every displayed operand staying positive. a − b × c can bait inside its range and so never derogates in practice; nothing forces that, it falls out of the sign constraint, which rejects a minuend built from a factor rather than from the product.

Families 1-8 and 9-16 ignore the option: explicit parentheses leave no precedence to get wrong. Passing it alongside them is not an error — a selection spanning several families carries it for the shapes that use it.

steps — showing the intermediate expression¶

steps=1 (or steps=true) makes the correction show the stage a pupil is meant to write down, instead of the bare result. It forces the answer layout to below.

without steps:   7 + 4 × 6 = ?     →  31
with steps:      7 + 4 × 6 = ?     →  7 + 4 × 6 = 7 + 24 = 31

Without it, that stage is still one click away on the live page — see The steps option.

perimeter_polygon¶

Perimeter of a polygon, its sides given on the figure.

Sources — one length per batch of equal sides — one source drawn as many times as the figure asks (2-9), one source per batch (2-9 10-90[10]), or one product range holding them all (2-9×2-9×2-9).

Steps — two levels: 1 the calculation the perimeter comes from, 2 the step it goes through — the grouped form that shortens the addition, or the half-perimeter of a rectangle.

Options — these, on top of the ones every type reads:

perimeter_polygon asks for the perimeter of a polygon of three to six sides, whose lengths are written on the figure:

(8) perimeter_polygon 2-9 -- sides=aaabbc
     →  [a hexagon labelled 9 cm, 5 cm, 2 cm]  Périmètre de cet hexagone ?
        answer: 39 cm

The sentence names the family the figure is in — triangle, quadrilatère, pentagone, hexagone — and stops there. Whether the triangle is isosceles, whether the quadrilateral is a rhombus, is exactly what the codings are on the figure for the pupil to read. It goes further in one case only, the parallelogram, and only because there the figure carries no codings at all (see marks below).

It is an addition of three to six terms, dressed as a figure — and dressed is the word: what makes it more than addi_direct is that the terms have to be read off the drawing, tick marks included. Three sides marked alike say 9 cm three times while writing it once, so the pupil counts before adding.

sides — how many, and which of them are equal¶

One option describes the figure, in any of three notations, from the loosest to the tightest:

sides=6         six sides, nothing said about which are equal
sides=3_2_1     three equal, two equal, one on its own — any arrangement
sides=aaabbc    the same, in that order round the figure

What a line leaves open is drawn, so sides=6 keeps giving different hexagons without the script having to enumerate them; what it pins down is honoured exactly.

The letter form gives the number of sides away (one letter per side), so it never needs a count beside it — and it is the only one that can tell abab (opposite sides equal: a rectangle) from aabb (adjacent ones: a kite), which the partition 2_2 cannot.

Say nothing at all and the number of sides is drawn too — in turn, one family after another. Left to chance it would not be: six sides can be arranged 144 ways where three can be arranged one, so a pattern drawn uniformly from everything a bare perimeter_polygon 2-9 allows is a hexagon nineteen times out of twenty. The family is alternated instead, so a page of a dozen questions asks about all four. A line that pins the family down leaves that rotation where it was, for the lines around it.

The same skew sits one level down, and is levelled off the same way. Of the nine four-sided patterns, three are abcd and one is aaaa: drawn from the patterns, sides=4 would be scalene a third of the time and square once in nine — and a figure with no two sides equal is the figure with nothing to count, which is what the question is about. So the batching is drawn first — 4, 3+1, 2+2, 2+1+1, 1+1+1+1, evenly — and the arrangement among the ones that batching allows. Which is why sides=4 really is half squares, rectangles, rhombi, parallelograms, kites and trapezoids. At three sides there is nothing to level: one batching, one arrangement.

shape — the figures a pattern cannot tell apart¶

sides describes the sides; some figures differ from one another by their angles, and no pattern of equal sides separates them: aaaa is a square and a rhombus, abab is a rectangle and a parallelogram. That is what shape is for:

shape=rhombus         shape=parallelogram    shape=kite
shape=square          shape=rectangle        shape=right_kite
shape=isosceles_trapezoid                    shape=regular
shape=equilateral     shape=isosceles        shape=scalene
shape=right_triangle

A name implies its pattern, so sides is redundant beside it — and the two are checked against one another rather than one silently winning: shape=rhombus sides=abab is refused by check qspec.

And the corollary: a line that says nothing about the shape is asking for either of them, so it gets both, in turn.

So sides=4 really does cover the six quadrilaterals it names, and not the three inscribed ones alone. Every other pattern has a single figure — three sides settle a triangle, aaab settles what it settles — and there the rotation is left where it was.

shape=regular is the case worth knowing: every side equal makes the question a multiplication, and the answer key leads with it (5 cm × 6 = 30 cm) rather than with a six-term addition.

A name that promises a right angle — right_triangle, right_kite, rectangle, square — narrows the numbers as well as the shape: the lengths have to be close enough together to be drawn as they are. Squashed lengths (see below) bend the angles, and the figure then loses the very codings that say what it is. So a right kite is drawn from 9 cm and 4 cm and never from 9 cm and 2 cm, and it carries its two right angles on every draw.

The sources give one length per batch, not per side¶

The number of values a line has to draw is the number of batches of equal sides, since a batch writes its length once and its tick marks carry it to the others. Four spellings, all of them valid:

(8) perimeter_polygon 2-9 -- sides=aaabbc      one source, drawn three times
(8) perimeter_polygon 2-9 2-9 2-9 -- sides=6   one source per batch
(8) perimeter_polygon 2-9×2-9×2-9 -- sides=6   one product range holding all
(8) perimeter_polygon 2-9 -- shape=regular sides=5      one value, ×5

A single source of one value is the short form: it is drawn as many times as the figure asks. Anything else has to add up to exactly the number of batches, and check qspec says so when it does not:

perimeter_polygon: '2-9×2-9' gives 2 value(s), i.e. 2 batch(es) of equal
sides, which sides=aaabbc cannot be split into.

Two conditions narrow the draw, both on the numbers and not on the drawing:

• the lengths are pairwise different — two batches worth the same are one batch, and the figure would carry two codings for one length;
• they close: the longest side is shorter than all the others laid end to end, or there is no such polygon. A hexagon labelled 2, 2, 2, 2, 2, 20 is not a hexagon, whatever it is drawn like.

A third narrows it for readability: no figure is drawn with a corner sharper than 25°, which is what keeps 2, 8 and 9 — a triangle eleven degrees thick — off the page.

What the figure promises, and what it does not¶

The figure is built from its lengths, so what it says about them is true:

• sides labelled alike are drawn alike, and marked with the same tick — bar the one figure whose shape already says it (marks, below);
• the order of the lengths survives — the figure never contradicts its labels;
• right angles are detected, never imposed. A triangle labelled 3, 4, 5 comes out of the construction with its right angle already there and gets it coded; one labelled 3, 4, 6 does not, and is drawn without a coding rather than with a false one. This is also why shape=right_triangle needs sources that can give a Pythagorean triple.

It is not to scale, though. Lengths more than three times apart are squashed towards each other before being drawn, so that a side labelled 24 cm beside one labelled 3 cm still leaves room for both labels. The squashing is affine and increasing, which is what keeps the three promises above; below that ratio nothing happens at all and the figure is to scale. Where it has been at work, the drawing no longer answers for the angles of what it is labelled, so no right angle is coded.

unit — the same length for every side, and for the answer¶

A perimeter is a length, so it is asked in the unit the sides are given in. That unit is printed inside the answer box, against its right edge, and the pupil types the number alone.

Say nothing and it alternates: mm, cm, dm, m, each in its turn, so a sheet meets the millimetre and the metre rather than four centimetres running. Nothing else in the question changes with it, which is what makes it free.

unit=cm             pinned, wherever a level wants it pinned
unit=alternate      the default, said out loud
unit={cm|m|mm}      one of the three, drawn at random per question

The rotation behind it is length_units, its own and shared with any later question needing a length to state — deliberately not the one the conversions draw their unit pairs from. A line that pins its unit leaves that rotation where it was, for the lines around it.

marks — the codings a shape makes needless¶

Sides drawn equal are coded with tick marks, one batch one tick, which is how a batch says its length once. With one exception: the rectangle and the parallelogram are drawn without any. That their opposite sides are equal is what a pupil is expected to know about them — it is the figure, not something a tick has to say — and a rectangle bristling with codings is the rectangle of no textbook. So they carry two labels on two adjacent sides, and the other two sides are read off them.

That leaves the figure to be recognised some other way, and the two are not recognised alike:

• the rectangle names itself: its four right angles are coded, and the sentence stays at the family — Périmètre de ce quadrilatère ?
• the parallelogram has nothing — no ticks, no right angles — so the sentence names it: Périmètre de ce parallélogramme ? This is the one place a wording goes past the family, and it goes there because otherwise nothing on the page says which sides are equal.

perimeter_polygon 2-9 2-9 -- shape=parallelogram marks=true

marks=true writes the codings anyway — and the sentence goes back to quadrilatère, the figure having taken the saying back. Everywhere else the option is ignored, silently: three equal sides on a hexagon are not a property of any named figure — they are the question — so their codings are what says them, and they are written whatever the line asks.

One aside worth knowing: sides=abab drawn as the rectangle normally keeps its right angles, but a pair of lengths too far apart to be drawn to scale loses their codings along with the rest (see above) — and the sentence then says parallélogramme, which a rectangle is.

steps — the calculation, and the step it goes through¶

A perimeter is reached two ways here, both taught:

9 cm + 9 cm + 9 cm + 5 cm + 5 cm + 2 cm = 39 cm
9 cm × 3 + 5 cm × 2 + 2 cm = 39 cm

steps writes the first into the answer key: 0 (the default) the perimeter alone, 1 the calculation and its result, 2 the step it goes through in between — here the grouped form, which is what a pupil counting the tick marks writes down before adding.

steps=1   9 cm + 9 cm + 9 cm + 5 cm + 5 cm + 2 cm = 39 cm
steps=2   9 cm + 9 cm + 9 cm + 5 cm + 5 cm + 2 cm = 9 cm × 3 + 5 cm × 2 + 2 cm = 39 cm

Two figures have a perimeter with a formula of their own, and there the calculation is that formula rather than the addition:

The second row is the answer key perimeter_rectangle writes, to the character: the two types overlap whenever a line asks for that figure, and a pupil should not be able to tell which one set the question. Writing 5 cm + 9 cm + 5 cm + 9 cm there would be teaching the long way round a formula they have learnt.

Where every side is different there is only one: grouping 3 + 4 + 6 writes 3 + 4 + 6 again, a batch of one being written on its own rather than multiplied by one. The second form is then dropped altogether rather than shown twice — steps=2 reads exactly like steps=1, and the info button has nothing left to add.

Otherwise, whatever steps says, the info button of the answer key — and the Steps button of a slideshow — opens on both, set side by side and the second introduced by Ou bien :, since two chains stacked read as one calculation carried over two lines. Snapshots carry it in the steps_alt field (see atmxs).

On a slide¶

The polygon carries nothing at its centre: a perimeter is measured along the sides, and writing it in the middle of the figure would say it is what the surface holds. The correction writes it under the wording instead (answer_layout=below), with its unit, since a slide has no answer box.

The sentence stands above the figure and smaller than the rest of the slide, and the content block is lifted, exactly as for perimeter_rectangle.

Reviewing what the generator draws¶

Because the figures are computed rather than catalogued, what is worth looking at is the generator's whole output rather than one figure at a time. The polygon catalogue is exactly that: every side pattern of three to six sides and every named figure, drawn on one page, rebuilt with the documentation. Nothing a script can ask for is missing from it.

tools/polygons_contact_sheet.py is what writes it, and it takes --layout grid to see the figures at the size a worksheet gives them.

One line, more than one figure¶

How a figure is set down is the most visible thing about it: two polygons in the same pose read as the same polygon however different their lengths are. So the pose is alternated rather than drawn — each presentation comes up in its turn, where chance would show the diamond four times running and then not once in six questions.

A figure of no particular name is set down on one of its broad sides — those within reach of its longest, since a polygon stood on a short side is a tall figure, and a tall figure is a small one once fitted into a line — and turned over, or not. The named ones have poses of their own:

A kite has an axis of symmetry, so it has four positions no other quadrilateral has: the axis brought square to the page, pointing up, down, left or right. They come on top of the sides it can rest on, not instead of them — a pupil who only ever meets the upright kite comes to read the pose rather than the figure.

What stays random is the rest — how far a parallelogram leans, how wide a kite opens. Those vary a figure without naming a presentation anybody could meet twice.

perimeter_rectangle¶

Perimeter of a rectangle, its length and its width on the figure.

Sources — one product range of two unequal values, or two sources of one value each, the second drawn away from the first — 2-9×2-9, 2-20 2-20.

Steps — two levels: 1 the operation the perimeter comes from, 2 the half-perimeter it goes through.

Options — these, on top of the ones every type reads:

perimeter_rectangle asks for the perimeter of a rectangle whose two dimensions are written on the figure:

(8) perimeter_rectangle 2-9×2-9
     →  [a 7 cm × 4 cm rectangle]  Périmètre de ce rectangle ?   answer: 22 cm

It is the figure of area_rectangle, down to the seed that keeps the wording and the answer key drawing the same shape: a rectangle with its four right angles coded, its length above it, its width to its right, and the sentence beside it in a worksheet grid, above it on a slide. What changes is what is asked — and what the answer is counted in.

The sources give the two dimensions¶

Either one product range, as area_rectangle takes it, or two sources of one value each, which lets the two dimensions be drawn from ranges that have nothing to do with each other:

(8) perimeter_rectangle 2-9×2-9               from the times tables
(8) perimeter_rectangle 2-20 2-20 -- unit=m
(8) perimeter_rectangle 10-90[10] 2-9         a round length and a small width

The bigger of the two values drawn is the length, so the side that looks longer carries the bigger number.

Two equal dimensions would label a square, which the figure cannot show: it is drawn lying down whatever it is labelled (see area_rectangle). With one product range, the equal-valued pairs are simply left out of the draw; with two sources, the second one is drawn away from the value the first gave — 2-20 2-20 never labels a square, without the line having to say so. Only sources that can never differ (5 5) are refused, by check qspec.

unit — the same length for both dimensions, and for the answer¶

unit works as it does for an area (any unit of the metric length ladder, cm by default, {cm|m|mm} to draw one per question), with one difference: a perimeter is a length, so it is asked in that unit itself and not in its square. It is printed inside the answer box, against its right edge, and the pupil types the number alone.

steps — the calculation, and the step it goes through¶

A perimeter is reached two ways, both taught:

(7 cm + 4 cm) × 2 = 11 cm × 2 = 22 cm
7 cm × 2 + 4 cm × 2 = 14 cm + 8 cm = 22 cm

steps writes the first of them into the answer key, since one of the two has to be picked for a line that has room for one: 0 (the default) the perimeter alone, 1 the operation and its result, 2 the half-perimeter in between — the step a pupil doing it in their head stops at.

steps=1   (7 cm + 4 cm) × 2 = 22 cm
steps=2   (7 cm + 4 cm) × 2 = 11 cm × 2 = 22 cm

Whatever steps says, the info button of the answer key — and the Steps button of a slideshow — opens on both calculations, written out in full and set side by side (stacked when the panel is too narrow). Neither is the way: a pupil who has learnt one finds it there, and sees that the other lands on the same number. Snapshots carry the second one in the steps_alt field (see atmxs).

On a slide¶

The rectangle carries nothing at its centre: a perimeter is measured along the sides, and writing it in the middle of the figure would say it is what the surface holds. The correction writes it under the wording instead (answer_layout=below), with its unit, since a slide has no answer box.

The sentence stands above the figure and smaller than the rest of the slide, and the content block is lifted, exactly as for an area.

read_abscissa¶

The abscissa of a point marked on a graduated axis.

Sources — one source of denominators, i.e. of how many parts the unit is divided into — 2-10, 2,4,5,10.

Steps — none: an abscissa is read, not calculated, so the answer is the whole of it — what there is to say about it is behind the ⓘ button of the answer key, whatever steps asks for.

Options — these, on top of the ones every type reads:

The pupil reads a number off a graduated line. What makes it a question is the graduation: the unit is divided into as many parts as the denominator says, and the abscissa is the number of those parts — which is exactly what a fraction counts.

(6) read_abscissa 2-10

The source gives the denominators¶

Not the abscissa: the denominator, i.e. into how many parts the unit is divided. That is where the difficulty of the figure lies — halves are read at sight, sevenths are counted — while the numerator only says how far along the point sits, and is drawn here.

read_abscissa 2-10          →  an axis in halves, thirds, … tenths
read_abscissa 4            →  always quarters
read_abscissa 2,4,5,10     →  only abscissae that also have a decimal writing
read_abscissa 3,6,7,9      →  only abscissae that have none

The last two are worth knowing: whether the answer can be written as a decimal number is settled entirely by the denominator (a denominator built of twos and fives has a decimal writing, anything else has not), so no option is needed to force one or the other — the source says it.

A denominator of 1 is refused: every abscissa over it is a whole number already written under its graduation, which is nothing to ask. Past ten, check qspec warns rather than refuses — eleven graduations to a unit is a comb, and whoever writes it may know what they are after.

proper — either side of 1¶

An abscissa above 1 is never far above it — normally between 1 and 2, the point sitting in the second unit of the axis. A coarse graduation reaches further, and only because one unit leaves it too little to choose from: in halves there is a single improper abscissa below 2, and a line asking for six of them would ask for 3/2 six times. Never further than the width of the figure allows, though: counting thirty graduations is not a reading, it is an inventory.

origin — whether 0 is on the picture¶

This is the second difficulty, and it is independent of the first. With the origin shown, the pupil counts graduations from 0 and the count is the numerator. With it hidden, the axis slides: only whole numbers further along are written, and the reading starts from one of them.

Hiding the origin does not require an abscissa above 1. The window may stop just above the point, which then falls in the graduations drawn before the first written one:

read_abscissa 3 -- proper=true origin=hidden
     →  1 and 2 written, two graduations drawn before the 1,
        the point on the first of them:  M(2/3)

read backwards from 1, with 0 nowhere on the axis. The one abscissa this cannot be asked of is a unit fraction — 1/3, 1/10: an axis starting to the right of 0 cannot also start to the left of a point one graduation from it, so those are left out where the origin is hidden (and simply get a visible origin where the line leaves it open).

One unit of axis, and the question beside it¶

The written range is the unit the point sits in, and no more: what is needed to read an abscissa is that unit, divided — the graduations of a second one are graduations to skip over. With the origin shown the range starts at 0 all the same, so it counts the units up to the point: 0 to 1 for a proper fraction, 0 to 2 for one between 1 and 2.

That is what leaves room for the sentence. The figure and Abscisse de M ? share one line of the sheet, the axis being drawn no wider than the wording column can hold beside the question — a grid is used for an assessment, where what is asked has to be on the paper in words, and a question taking two lines costs every other question a line too.

The axis itself is drawn no longer than its graduations need — the configuration holds them between a minimum and a maximum spacing — so a unit in halves takes about half the width of one in tenths, and a page of these questions looks like a page of figures rather than one figure redrawn. A denominator past ten overruns the width all the same, which is one more thing the warning about combs is warning about.

The sentence is not the same width in every font, nor in every language. So the axis measures it when the page is drawn, in the font the page sets it in, and takes only what it leaves of the line (the beside option of axis{}): a wide font gets a shorter axis rather than a sentence pushed onto a second line. This only works for a font the rendering server has: a font asked for by name and missing on the computer displaying the page is replaced by another one, which nothing measured.

The box is framed by M( )¶

The answer box carries the notation an abscissa is written in — M( before it and ) after it — so the pupil types the number alone yet reads the notation each time, and the answer key spells the whole of it: M(7/4). On a printed sheet the two halves stand apart, the room between them being where the answer goes; on the answer key they close up around the result.

Any question type can do the same by returning its two halves from answer_frame(); snapshots carry them in the answer_frame field of a grid entry (see atmxs).

Every correct writing is accepted¶

The abscissa has one shortest writing, and the answer key shows it — but a pupil who does not simplify is not wrong, and neither is one who answers in decimals where the number has a decimal writing:

The English notation is refused on purpose: writing a decimal number the way the language writes it is part of what is being learnt.

No steps, and the ⓘ button all the same¶

An abscissa is read, not calculated, so the answer key writes the abscissa and nothing else whatever steps asks for. The reasoning is still one click away, behind the ⓘ button — and it reads forwards, the sentence first and the counting under it:

L'unité est partagée en 4 parts égales :
chaque graduation vaut 1/4.

        7 × 1/4 = 7/4

What each graduation is worth is not a remark on a calculation already read, it is the step the calculation starts from, and the step a pupil misses.

The counting under it starts wherever the reading does. From the origin, the count is the abscissa — 7 × 1/4 = 7/4, seven graduations of a quarter apiece. From a written graduation, it is added to that graduation or taken off it, and the step in the middle is the one worth showing: the whole number written as a fraction of the same denominator, which is what makes the addition possible.

1 + 7/10  =  10/10 + 7/10  =  17/10
2 − 1/7   =  14/7 − 1/7    =  13/7

The default transduration is 30 s: reading the figure, counting graduations and writing a fraction is one operation more than naming a digit place.

On a slide¶

A slide has no answer box to carry the notation, so the correction writes the abscissa named in full, M(7/4). The sentence goes above the figure rather than beside it, a slide being as wide as it needs and read from the back of the room.

read_coordinates¶

The coordinates of a point marked in a coordinate system.

Sources — one window, written as intervals — [-4;4] for both axes, [-6;6]×[-3;3] for the abscissas then the ordinates; the decimals of the bounds set the graduation, [-1.0;1.0] being divided in tenths.

Steps — none: coordinates are read, not calculated, so the answer is the whole of it.

Options — these, on top of the ones every type reads:

The pupil reads the coordinates of a point marked in a coordinate system, drawn on its grid. Nothing is calculated: what is kept alive is the reading itself, and the order the two numbers are written in — the abscissa, read on the horizontal axis, then the ordinate.

(6) read_coordinates [-4;4]

The source is the window¶

The source is the part of the coordinate system the figure shows, written as intervals — see Windows. The point is drawn among the nodes of its grid, and the figure shows that same window, one cell past each bound.

read_coordinates [-4;4]          →  whole coordinates from −4 to 4, on both axes
read_coordinates [-6;6]×[-3;3]   →  a wider figure than it is tall
read_coordinates [0;8]×[0;5]     →  the first quadrant only
read_coordinates [-1.0;1.0]      →  a grid of tenths

The decimals of the bounds set how finely each axis is graduated, which is where the difficulty of a figure lies. [-4;4] is the mental-calculation figure; a worksheet can afford finer grids, wider windows, larger numbers.

Points are tracked in the order they were drawn: (2; 3) and (3; 2) are two points, and one may follow the other on a sheet — which is exactly the confusion the question is there to catch.

notation — how the answer is typed¶

With written, the pupil has the notation to write as well as the numbers: the parentheses, and the separator between the coordinates. The name of the point stands before the box, so the question says plainly that it is not to be written; a pupil typing it all the same — W(4;-2) — is not marked wrong for it. Spaces do not count.

The separator is the one of the render locale: a semicolon where the comma is the decimal mark — (0,5 ; 2) could not be read otherwise — and a comma elsewhere, as English writes (0.5, 2), where a semicolon is accepted too. A coordinate is written in the notation of the locale, 0,5 in French, and the minus sign may be the hyphen a keyboard gives.

x_labels_step, y_labels_step — the values written along the axes¶

Handed to the figure as they are: how often a value is written along each axis, a whole number of graduations. Left out, the figure chooses — every graduation from −4 to 4, every 0.2 on a grid of tenths from −1 to 1 (see plot{}).

read_coordinates [-1.0;1.0] -- x_labels_step=0.5 y_labels_step=0.5

round_number¶

A number to round to a given place.

Sources — one digit place, the one to round to: the digitplaces, digitplaces_big or digitplaces_small alternator, or places written as powers of ten — 0.01, 1,10,100.

Steps — none: the answer is the whole of it, so the answer key draws no ⓘ button.

Options — these, on top of the ones every type reads:

The place is named — ten, unit, tenth… — and the pupil writes the rounded number:

(6) round_number digitplaces -- max_place=100
    →  Round 43.571 to the nearest tenth.       answer:  43.6
    →  Round 2,815 to the nearest hundred.      answer:  2,800

The source draws the place to round to¶

As with digitplace_digit, the source is not the number but the place: the same digitplaces, digitplaces_big and digitplaces_small alternators (see there for the places each runs through), or places written as powers of ten — 0.01, 1,10,100.

min_place and max_place narrow the places asked, each written as a power of ten. A place the source hands back outside them is passed over, the alternator's cycle going on, so the places kept still come round evenly. That is how a sheet rounds from the hundreds down to the thousandths while drawing from digitplaces, which also runs through the thousands:

round_number digitplaces -- max_place=100
round_number digitplaces -- min_place=1       →  no rounding past the unit

A source none of whose places the bounds let through is refused by check qspec — digitplaces_small -- min_place=1 has only decimal places to offer.

The number always reaches below the place¶

The number is built around the place drawn, like that of the digitplace_* questions, but it always runs at least one place below it: there would be nothing to round otherwise. So rounding to the thousandths gives a number with a digit at the ten-thousandths, the one place a number is ever written at without a question being able to ask about it.

Its first and last digits are never zero; the digits in between may be, and may repeat — 3.05 is as good a number to round as any. When the number stops one place under the place asked, that last digit is non-zero, so the number never comes already rounded.

Whether the number rounds up or down is left to the draw: a sheet where every number rounded down would be answered without looking. A 5 rounds up, as at school — 43.5 to the unit gives 44.

width sets how many digits the number carries, place asked included — a number, or a range from which one is drawn per question (the default is 3-5). It may not go below 2 — the place and one under it — nor past 9, and a width wider than the places available is narrowed to them. With the default width, a large place gives a whole number, and the hundreds may give one too — 3,045 as well as 927.94.

The answer, and what is accepted¶

The answer key writes the rounded number in its shortest form: 3.96 rounded to the tenth is 4, not 4.0. On an interactive page, any decimal writing equal to it is accepted — 4, 4.0, 4.000 — in the notation of the locale (4,0 in French), as everywhere else. A fraction is not: a rounding is asked for as a decimal number.

Transduration¶

25 s by default.

spreadsheet_formula¶

Enter a formula in a cell, and say what the cell will show.

Sources — the sources of expr_eval, read the same way: a range for the values of the cells and a second for the numbers of the formula — 2-9 2-12 — a product range for its products and quotients, or auto.

Steps — one level, the formula with its cells replaced by their values, then each stage of the reduction.

Options — these, on top of the ones every type reads:

spreadsheet_formula asks what a spreadsheet will show once a formula is entered:

(8) spreadsheet_formula auto -- result=positive
     →  En C2, on entre =5*A2-1.
        [A2 shows 4, C2 a red ?]
        Que va-t-il s'y afficher après avoir pressé Entrée ?      answer: 19

It is expr_eval asked the way a spreadsheet asks it. The expressions are the same ones, drawn the same way — the same catalogue of shapes, variant and its three filters, the same sources, auto included, result, carry, the tables rule, everything said in expr_eval's section. A line moves from one type to the other by its identifier alone:

(8) expr_eval auto -- result=positive letters=2
(8) spreadsheet_formula auto -- result=positive letters=2

Only the writing differs.

The letters are cells¶

Each unknown is a cell whose value is read in the figure rather than given in the sentence, and the formula is typed in another cell, which shows a red ?. The figure stands somewhere between A1 and H9, so that a pupil reads the references rather than meeting A1 and B1 every time, and the formula is typed onward from a value, to its right or below it, the way a sheet is filled. The cells the question does not fill are drawn empty.

Its shape depends on where the question is read:

• on a printed sheet, as flat as the cells allow, since height is what a page's questions share: a value and its formula side by side, and a square of two by two where two values and a formula need a third cell — with the question written beside the figure, on two lines, rather than under it;
• on a slide, a block of four contiguous cells — a square, a row of four or a column of four — the two values side by side or one above the other, and the question under it: the slide has the screen to itself.

The question is drawn once and written twice: the same expression and the same values, read on the cells each figure places them in.

On a slide the answer takes the place of the ? on the correction, as the area of a rectangle takes its centre: answer_layout=inline is the default.

The formula is written as it is typed¶

The expression is written the way it is entered in a cell — = first, every product written out with *, a division on the line with /, a square with ^2, no space — and set in the font of source code with code{}:

The parentheses a fraction bar made unnecessary come back, since a line of keys has no bar to hold its members together.

A square is typed with the power key unless the line says otherwise: square=product writes it as the product it is, the writing a class meets before the power key — and keeps it whole wherever it stands:

(6) spreadsheet_formula auto -- variant=x²+b,ax²,a/x² result=positive square=product
     →  =D2*D2+5     =11*F8*F8     =64/(B3*B3)

A decimal takes the locale's point, as a spreadsheet set in that language reads it, and no thousands separator, which nobody types.

square_of¶

Square of a number.

Sources — one singleton range, or a pair range narrowed to its equal pairs — 2-12, 4-9×4-9.

Steps — one level, the power written out as the multiplication it stands for — 8² = 8 × 8 = 64.

Options — the ones every type reads only.

What follows holds for cube_of as well: the two types raise a single drawn number, take the same shapes of source and show the same kind of step, and are described here together.

Both accept two shapes of source:

(4) square_of 4-9×4-9
    →  8² = ?

(3) cube_of 2-10 -- variant=wording
    →  What is the cube of 10?

Why a product range is usually the better source¶

A product range is narrowed to its equal tuples — the six (n, n) of 4-9×4-9 — so the question drawn is exactly the same. What changes is which table it is drawn from, and therefore what the anti-repeat tracking can see.

Most of a mental-calculation sheet comes from product ranges, and the tracking only prevents a repeat within one table. So:

(4) multi_direct 4-9×4-9
(2) square_of 4-9        →  6 × 6 = ? followed by 6² = ? is possible
(2) square_of 4-9×4-9    →  it is not: the pair (6,6) is already spent

With the product form, a 6 × 6 already asked by multi_direct cannot come back as 6² a few questions later, and vice versa. Nothing else changes — same wording, same answer.

A product range must be able to yield equal values: square_of 2×6-9 never does, and check qspec says so. It must also have the right width — a pair for a square, a triplet for a cube — which check qspec checks too.

The wording variant¶

variant=wording asks the same question as a sentence — What is the square of 8? — and follows the rules of The wording variant: the answer goes underneath, and answer_layout=inline overrides that. Unlike the four operation types, neither is given extra time by the variant: naming a square takes no longer to read than writing it.

Steps — writing the power out¶

Both types have one level, and it belongs to the type, not to the variant:

8² = ?                      →  answer: 64
                               ⓘ        8² = 8 × 8 = 64

Quel est le carré de 8 ?    →  answer: 64
                               ⓘ        8² = 8 × 8 = 64

At steps=0 — the default — the answer key shows 64 alone and keeps the chain behind its ⓘ button; steps=1 puts it in the answer itself.

The chain reads the same whichever way the question was asked, and it always opens on the power, even where the wording carries it already. Both halves earn their place: 8² = 8 × 8 is what a pupil reading a square as a doubling needs to see, and it is also what tells the one who was asked the square of 8 how that is written down.

A cube pauses once more, on the product of its first two factors — three of them are not multiplied in one go, and the chain stops where the pupil does:

3³ = ?      →  answer: 27
               ⓘ        3³ = 3 × 3 × 3 = 9 × 3 = 27

10³ = ?     →  answer: 1 000
               ⓘ        10³ = 10 × 10 × 10 = 100 × 10 = 1 000

Transduration¶

square_of defaults to 20 s, like multi_direct — a square up to 10² is a times-table fact. From 11² on it has to be worked out, so the default rises to 24 s on its own, per question. cube_of defaults to 30 s throughout. An explicit transduration= on the line always wins.

Decimal ranges work: square_of 0.1-0.9 draws 0,3² = ? for 0,09.

subtr_direct¶

Subtraction.

Sources — exactly two numbers: two sources, the minuend then the subtrahend, or one pair range oriented at random — 100-999 10-99, 10-99×10-99; or two time ranges, the minuend then the subtrahend — 13h-18h[5min] 8h-12h[5min]; or clocktimes alone, a departure and an arrival drawn in a frame.

Steps — none on the plain form; one level under variant=wording, on the operation the sentence names.

Options — these, on top of the ones every type reads:

The subtraction reads its sources, frames its difference and counts its borrows exactly as the addition does, and the two are described together under addi_direct: how many terms a source gives, how a single pair range is oriented, what carry promises, and what result, min_result and max_result frame.

Two things are its own. It takes exactly two numbers, the minuend then the subtrahend, and check qspec says so when the sources give anything else. And it has no shuffle: the order of a subtraction is what the question means.

to_reach and complement — the same subtraction, as a complement¶

A subtraction whose minuend is round is not read as a subtraction in class: it is read as the complement of the other number to it. Two variants word it that way, and both compute exactly what 100 − 37 computes:

to_reach puts the complement as the addition to make; complement names it. Where the target is 10, 100 or 1000, the sentence uses the name the lesson uses — the tens complement, the hundreds complement, the thousands complement. Any other target is numbered instead: What is the complement to 400 of 140?

Both are sentences, so they follow the wording variant in everything else: the answer goes underneath, the question is given the same 24 s, and the subtraction it stands for waits behind the ⓘ button.

The two start from the subtrahend — it is the number completed, the minuend being the target it is completed to — where wording names the minuend first. Which is why they imply result=positive: there is nothing to complete past the target, and a pair range oriented at random would otherwise ask half of its questions the wrong way round. The line above needs no result= of its own.

It only fills a silence. A result the line writes is honoured as written, min_result included, and one letting the difference go negative is reported rather than overruled:

subtr_direct 100×1-99 -- variant=complement result=negative
→  variant=complement asks what is missing to reach the first number,
   which result=negative contradicts — a complement is never negative.

On a line of times, both variants keep their meaning: to_reach asks how long must be added — How long must be added to 8 h 40 min to make 11 h 15 min? — and complement names its target as a time, What is the complement to 1 h of 35 min?

subtr_hole¶

Subtraction with a missing term.

Sources — exactly two numbers: two sources, the minuend then the subtrahend, or one pair range oriented at random — 100-999 10-99, 10-99×10-99; the difference is worked out from them.

Steps — one level: steps=1 writes out the operation the missing number is recovered by — an addition where the minuend is hidden, a subtraction where the subtrahend is.

Options — these, on top of the ones every type reads:

step is refused here: a hole is not asked on times: its sources are numbers.

units is refused here: a hole is not asked on times: its sources are numbers.

The subtraction with a hole draws its numbers, places its hole and frames its difference exactly as the addition with a hole does, and the two are described together under addi_hole: what the sources give and what is worked out, where hidden puts the hole, what the constraints frame, and what steps=1 writes out.

Two things are its own. The hole falls on the minuend or on the subtrahend — never on the difference, which is subtr_direct — and the two are not the same exercise: ? − 37 = 15 is answered by an addition, 52 − ? = 15 by a subtraction.

And result=positive is what keeps every number of the line positive: the hidden number is always one of the numbers a source drew, so the only one that can go negative is the difference the question shows.

units_conversion¶

Conversion between two units of the same quantity.

Sources — the unit_pairs table, one row per direction, narrowed by its columns — quantity, level, gap, direction, everyday, unit1, unit2, dimension.

Steps — one level, the operation the conversion comes down to.

Options — these, on top of the ones every type reads:

units_conversion asks for the same quantity read in another unit:

(10) units_conversion unit_pairs -- level=1
     →  9 dL = ? L      answer:  0,9

The wording carries both units, so the answer is the number alone. The pair of units is drawn from the unit_pairs content table; the number is drawn against it, by the question type.

The unit asked for is written beside the box too¶

The unit the wording ends on is also printed inside the answer box, against its right edge, on the question sheet as on a mail-merge template: the wording states the equality, the box states what the number about to be written in it is counted in — under the eye, where it is written. The pupil still types the number alone.

On the answer key the same unit follows the result, which is why the key reads 0,9 L while the pupil only ever types 0,9. On a slide, where there is no box, the answer takes the place of the ? and the wording supplies the unit (9 dL = 0,9 L). This is the answer_unit() mechanism area_rectangle uses as well; snapshots carry it in the answer_unit field of a grid entry (see atmxs).

The source is always unit_pairs¶

There is one source, and it is the table of pairs. Its columns are the filters a line narrows it with:

Each pair is stored once per direction, so dL → L and L → dL are two rows: asking for one direction only is a filter, and the anti-repeat tracking of the table counts them apart.

The ladders run from km, kg and hL down to mm, mg and mL. The kilolitre is deliberately left out — the symbol exists, and unit{3 kL} still draws it, but nothing is measured in kilolitres, so no question converts one.

(10) units_conversion unit_pairs                     anything, level 1 to 3
(10) units_conversion unit_pairs -- quantity=capacity gap=1
(10) units_conversion unit_pairs -- level={1|2}      a mix of both levels
(10) units_conversion unit_pairs -- everyday=true    the everyday ones only
(10) units_conversion unit_pairs -- direction=right  the ones that multiply

A filter that selects nothing (quantity=area) is refused by check qspec, which lists the values available; one that leaves a pair or two (unit1=dL unit2=L) is accepted, with a warning that every question of the block will ask the same conversion.

level — the power of ten, not the number of columns¶

The difficulty of a conversion is the power of ten between the two units:

with one deliberate exception: the conversions of everyday life are known rather than computed, so they count as level 1 whatever their gap —

m ↔ km      m ↔ cm      g ↔ kg      L ↔ mL      L ↔ cL

m → km is three columns apart, and stays a level-1 question. Use gap where what you want is the columns themselves, everyday=true where you want that handful of pairs, and level — the usual choice — where you want a difficulty.

width — the number drawn, and why it is always readable¶

width is how many digits are drawn, 1-3 by default, one width per question. They are the significant digits: two digits landing on the hundreds and the tens read 710.

Where the digits fall is not free. The number and its conversion both stay inside the places a pupil reads — the thousandths to the thousands — and every digit stays inside the ladder of the quantity, so that the conversion table below can always be drawn. A question therefore never asks for 3 mm in kilometres, and width=7 on a three-column pair is narrowed to what the pair can hold rather than refused.

A whole number may end in zeros (30 dL = 3 L is worth asking); a decimal one never does, since a trailing zero would simply not be printed.

steps — the operation the syllabus names¶

steps=0 is the default, as everywhere in mental calculation: the answer is the converted number alone. steps=1 writes the operation out, in the answer column of the answer key:

9 dL = 9 ÷ 10 L
     = 0,9 L

Multiplying when the unit asked for is the smaller one, dividing otherwise; the factor is the power of ten of the level — 10, 100 or 1000.

The info button shows both ways at once¶

Whatever steps says, the info button of the answer key — and the Steps button of a slideshow — opens on two presentations of the same conversion, side by side:

• the operation above, which is the form the syllabus states;
• the conversion table, the digits of the number laid out one per column.

Neither replaces the other: some pupils reason with the operation, others read the columns. The table is columns and nothing else — no frame, no rule between the units and the digits (borders=inner_cols), the separators themselves in grey, and the units in a smaller size than the digits: they label the columns, the digits are what is read.

9 dL = 0,9 L            0,56 kg = 560 g
                          │     │     │
   L  │ dL              kg│ hg  │ dag │ g
   0  │ 9,               0,│  5  │  6  │ 0

One comma is written, and always: the one of the number as it is given, on its units digit — 9, even when the number is whole, because the comma is how that column is found. That digit, its comma and the unit of that column are in red; the unit asked for is in green, the columns merely passed through in grey, and every other digit in green — they are what the answer is read on, and they do not move.

The table is only ever shown behind the button: an answer cell of a grid, and the answer of a correction slide, keep to the result alone.

Areas, volumes, and time¶

Not yet. An area column is two powers of ten and a volume column three, which the dimension filter is there to carry — it is 1 everywhere for now, and a line that says nothing about it gets one-dimensional pairs, so seeding areas and volumes later will not change what today's scripts ask.

Conversions between the two systems of volumes (1 dm³ = 1 L) are a family of their own, and time units — which are not decimal — will be a question type of their own.