G2 Mathematics K210 problem solving is often easier when the target is treated as the end of a chain rather than a mysterious unknown. If the final quantity is known or tightly constrained, ask what must have been true immediately before it.
This one-hundred-and-second Learner’s Guide develops work-backward reconstruction. It complements Vol 0070 Dependency Graphs and Vol 0098 Case Splitting.
The backward protocol
Write the target, identify the last operation that produced it, undo that operation, then repeat until you reach known information. At the end, run the chain forward once. Backward reasoning proposes the route; forward verification confirms it.
1. final price to original
Given target state: sale price and discount are known.
Backward move: divide by remaining percentage factor to recover original. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
2. final after increase to original
Given target state: final is 120% of original.
Backward move: divide by 1.2 rather than subtracting 20% of final. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
3. final after decrease to original
Given target state: final is 80% of original.
Backward move: divide by 0.8. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
4. profit to revenue/cost
Given target state: profit relation is known.
Backward move: rearrange profit = revenue – cost. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
5. margin to profit
Given target state: margin and revenue known.
Backward move: recover profit from fraction of revenue. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
6. markup to profit
Given target state: markup and cost known.
Backward move: recover profit from fraction of cost. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
7. distance to speed
Given target state: distance and time known.
Backward move: work backward through d=st. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
8. distance to time
Given target state: distance and speed known.
Backward move: recover time by division. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
9. total cost to quantity
Given target state: fixed/unit costs known.
Backward move: remove fixed part then divide by unit rate. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
10. total cost to unit price
Given target state: quantity known.
Backward move: remove fixed component before dividing. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
11. mean to total
Given target state: mean and count known.
Backward move: multiply to reconstruct total. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
12. missing value from mean
Given target state: mean, count and other values known.
Backward move: reconstruct total then subtract known sum. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
13. weighted mean to missing value
Given target state: weights and mean known.
Backward move: reconstruct weighted total and isolate unknown contribution. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
14. range to endpoint
Given target state: range and one extreme known.
Backward move: use max-min relation. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
15. probability to favourable count
Given target state: probability and total outcomes known.
Backward move: multiply share by total when count interpretation valid. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
16. relative frequency to count
Given target state: rate and total observations known.
Backward move: recover category count. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
17. percentage to part
Given target state: percentage and whole known.
Backward move: multiply whole by percentage fraction. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
18. percentage to whole
Given target state: part and percentage known.
Backward move: divide part by percentage fraction. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
19. ratio and total
Given target state: parts ratio and total known.
Backward move: recover one ratio unit then each part. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
20. ratio and one part
Given target state: one part known.
Backward move: recover common ratio unit then other parts. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
21. scale drawing to actual
Given target state: scale factor known.
Backward move: reverse multiplication/division in correct direction. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
22. actual to drawing
Given target state: scale known.
Backward move: apply reciprocal direction appropriately. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
23. area scale factor to length factor
Given target state: area factor known.
Backward move: take square root for positive scale. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
24. volume factor to length factor
Given target state: volume factor known.
Backward move: take cube root. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
25. circle circumference to radius
Given target state: circumference known.
Backward move: divide by 2π. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
26. circle area to radius
Given target state: area known.
Backward move: divide by π then square root. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
27. rectangle area to side
Given target state: area and one side known.
Backward move: divide by known side. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
28. perimeter to missing side
Given target state: perimeter relation known.
Backward move: remove known sides and account for multiplicity. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
29. Pythagoras hypotenuse to leg
Given target state: hypotenuse and one leg known.
Backward move: subtract squares then square root. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
30. coordinate midpoint to endpoint
Given target state: midpoint and one endpoint known.
Backward move: double midpoint then subtract known coordinate. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
31. gradient to coordinate difference
Given target state: gradient and run/rise known.
Backward move: use rise = gradient × run or inverse. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
32. line equation to intercept
Given target state: point/slope known.
Backward move: substitute and solve for intercept. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
33. line equation to unknown coordinate
Given target state: equation and one coordinate known.
Backward move: substitute and solve. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
34. direct proportion output to constant
Given target state: x and y known.
Backward move: recover k=y/x. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
35. inverse proportion output to constant
Given target state: x and y known.
Backward move: recover k=xy. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
36. direct proportion target input
Given target state: k and output known.
Backward move: divide by k. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
37. inverse proportion target input
Given target state: k and output known.
Backward move: divide k by output. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
38. arithmetic sequence term to difference
Given target state: two terms/positions known.
Backward move: use total change over number of steps. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
39. arithmetic sequence term to first term
Given target state: later term and difference known.
Backward move: reverse repeated addition. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
40. geometric sequence term to ratio
Given target state: terms known.
Backward move: use quotient with position gap as appropriate. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
41. geometric sequence term to first
Given target state: later term and ratio known.
Backward move: divide by accumulated ratio power. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
42. compound growth final to principal
Given target state: final, rate and periods known.
Backward move: divide by growth factor power. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
43. depreciation final to original
Given target state: final, rate and periods known.
Backward move: divide by retention factor power. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
44. simple interest total to principal
Given target state: amount, rate, time known.
Backward move: solve amount relation backward. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
45. currency final to source
Given target state: converted amount and rate known.
Backward move: apply reciprocal of forward conversion. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
46. density to mass
Given target state: density and volume known.
Backward move: multiply. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
47. density to volume
Given target state: mass and density known.
Backward move: divide. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
48. population density to population
Given target state: density and area known.
Backward move: multiply. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
49. population density to area
Given target state: population and density known.
Backward move: divide. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
50. speed-time graph area to time
Given target state: distance and speed region known.
Backward move: recover width/time where shape relation permits. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
51. rate to duration
Given target state: total change and rate known.
Backward move: divide total by rate. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
52. work rate to workers
Given target state: target work/time and per-worker rate known.
Backward move: recover required worker count. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
53. runway to cash
Given target state: runway and burn known.
Backward move: multiply. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
54. runway to burn
Given target state: cash and runway known.
Backward move: divide. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
55. flow time to volume
Given target state: flow rate and time known.
Backward move: multiply. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
56. flow time to rate
Given target state: volume and time known.
Backward move: divide. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
57. data transfer time to size
Given target state: rate and time known.
Backward move: multiply. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
58. data transfer time to rate
Given target state: size and time known.
Backward move: divide. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
59. capacity utilisation to used amount
Given target state: utilisation and capacity known.
Backward move: multiply. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
60. capacity utilisation to capacity
Given target state: used amount and utilisation known.
Backward move: divide. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
61. occupancy to occupied count
Given target state: rate and capacity known.
Backward move: multiply. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
62. success rate to successes
Given target state: rate and attempts known.
Backward move: multiply. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
63. error rate to errors
Given target state: rate and attempts known.
Backward move: multiply. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
64. survey response rate to responses
Given target state: rate and invitations known.
Backward move: multiply. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
65. percentage-point final to initial
Given target state: final percentage and change known.
Backward move: subtract point change. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
66. index to current value
Given target state: index and base known.
Backward move: reverse index formula. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
67. normalised value to raw
Given target state: normalised ratio and base known.
Backward move: multiply by base. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
68. upper/lower bound to displayed rounded value
Given target state: interval known.
Backward move: identify rounding unit and compatible display. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
69. rounded value to true interval
Given target state: displayed value known.
Backward move: work backward to half-unit bounds. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
70. constraint from answer choices
Given target state: candidate outputs given.
Backward move: work backward to test which input/model could produce each. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
71. MCQ reverse substitution
Given target state: options are easier to test than derive.
Backward move: substitute choices into original condition. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
72. equation target known
Given target state: final x candidate known.
Backward move: reverse operations to test original equation. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
73. function output known
Given target state: y and function known.
Backward move: solve f(x)=y for valid x. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
74. graph target y known
Given target state: horizontal line meets graph.
Backward move: read possible x values. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
75. graph target x known
Given target state: vertical line meets graph.
Backward move: read y. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
76. probability complement known
Given target state: P(not A) known.
Backward move: recover P(A)=1-complement. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
77. union/intersection known
Given target state: probability relation known.
Backward move: rearrange inclusion-exclusion. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
78. tree final path known
Given target state: path product and one branch known.
Backward move: divide to recover missing branch probability. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
79. mixture final concentration known
Given target state: final total and concentration known.
Backward move: recover solute amount before reconstructing input. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
80. average speed target
Given target state: total distance and target average known.
Backward move: recover total time then missing segment time. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
81. journey arrival target
Given target state: arrival time and duration known.
Backward move: work backward to departure time. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
82. age relation future
Given target state: future age relation known.
Backward move: reverse time shift to present. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
83. age relation past
Given target state: past relation known.
Backward move: advance back to present. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
84. geometry target angle
Given target state: final angle relation known.
Backward move: reverse through angle sums/parallel relations. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
85. similarity target side
Given target state: corresponding scale known.
Backward move: reverse from image to original. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
86. algebraic expression target
Given target state: output known.
Backward move: undo operations in reverse order. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
87. formula target variable
Given target state: formula and result known.
Backward move: rearrange symbolically before numbers. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
88. dependency chain target
Given target state: final quantity known.
Backward move: walk backward through intermediate relations. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
89. reverse-engineering final rule
Given target state: start from what must be true immediately before the target.
Backward move: undo one justified operation at a time and verify forward. For practice, draw arrows from known input to target, then reverse the arrows and label the inverse operation on each edge.
Watch for operations that are not one-to-one: squaring can create ± roots, rounding creates intervals, absolute value creates cases, and contextual constraints may reject algebraic candidates. Backward reconstruction must preserve these branches rather than pretending every operation has one inverse.
Backward is not guessing from the answer
The method is legitimate when every reverse step follows a defined relation. It becomes guessing when the learner changes numbers until an option works without understanding why. Use the original model, not the answer choice, as the authority.
Links
Use the Mathematics Hub, Vol 0086 Bounding Checks, Vol 0072 Verification Asymmetry, the Examination Craft hub and the PSLE Learner’s Guide.
Official-source discipline
For the current 2027 SEC G2 school-candidate framework, use the official SEAB G2 syllabus directory and linked K210 Mathematics syllabus. Work-backward reconstruction is an eduKateSengkang reasoning framework, not an additional SEAB syllabus topic.
Final rule
Start from the target and ask what must have been true one step earlier. Undo only justified operations, preserve branches where inverses are not unique, then run the reconstructed chain forward to verify it.
