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.

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 keeps it — multi_direct 2-9×2-9 -- variant=wording scale=1-3 stays at the 24 s the zeros 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.

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.

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.

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. 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 — see The wording variant for what variant=wording changes to the last two.

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:

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².

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²

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.

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 16 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¶

20 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.

Transduration¶

digitplace_digit defaults to 12 s — reading off a digit is immediate once the places are known. Its two siblings, which have a word or a number to write, are given 20 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¶

20 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.

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.

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.

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 16 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 two 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.

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 reads 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 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.

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 16 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.

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.

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:

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.