Mathematical Numeric Reasoning Professional Playbook

Numeric reasoning should feel like replacing many raw cases with a smaller canonical property that preserves the answer.

modulo classes:

values by remainder mod 5:

class 0:  0   5   10   15
class 1:  1   6   11   16
class 2:  2   7   12   17
class 3:  3   8   13   18
class 4:  4   9   14   19

Equal prefix remainders imply the subarray difference is divisible by 5.

Euclid reduction:

gcd(48, 18)
    48 = 2 * 18 + 12
    18 = 1 * 12 + 6
    12 = 2 * 6  + 0

gcd is 6 because common divisors survive each remainder step.

normalized slope:

point A (x1, y1) ---- point B (x2, y2)

dy = y2 - y1
dx = x2 - x1
g  = gcd(abs(dy), abs(dx))

key = (dy / g, dx / g) with one fixed sign convention

No floating-point slope is needed.

fast exponentiation:

x^13

13 in binary = 1101

bit:      8     4     2     1
power:  x^8   x^4   x^2    x
use:     yes   yes   no    yes

answer = x^8 * x^4 * x

digit carry:

      9  9  8
  +      7  6
  -------------
      ?  ?  ?

process from right:
    digit_sum = a[i] + b[j] + carry
    output digit_sum % 10
    carry = digit_sum / 10

subarrays divisible by k:

prefix sums:       0   4   9   14   17
remainder mod 5:   0   4   4    4    2
                       ^        ^

Equal remainders mean the subarray between them sums to a multiple of k.
invariant: equal remainder classes preserve divisibility of differences

common divisibility:

24 factors: 2 * 2 * 2 * 3
18 factors: 2 * 3 * 3

common part: 2 * 3 = 6

gcd stores the shared divisibility structure.
invariant: gcd preserves exactly the common factors needed by the answer

primality repeated over range:

numbers: 2 3 4 5 6 7 8 9 10
mark 2:  P P x P x P x P  x
mark 3:  P P x P x P x x  x

Sieve marks composites once small primes explain them.
invariant: unmarked numbers after small-prime marking are prime candidates

combinations / permutations:

choose 3 of 5:

items:  A B C D E
slots:  _ _ _

Formula counts equivalent choices without listing every subset.
invariant: each valid choice is counted once by the formula

large power:

x^13 = x^(8 + 4 + 1)

binary exponent bits:
8  4  2  1
1  1  0  1

Multiply only selected squared powers.
invariant: selected bits multiply to the original exponent value

digit processing:

number string:  "507"

value scan:
0 --'5'--> 5 --'0'--> 50 --'7'--> 507

Each digit shifts previous value by base 10.
invariant: processed prefix has the numeric value represented so far

geometry:

A(x1,y1) -------- B(x2,y2)
     \              /
      \            /
       C(x3,y3)

Use integer relations:
    slope key
    distance squared
    cross product orientation
invariant: integer formulas preserve geometric equality/orientation exactly

If raw values are only needed through a property, carry the property. If raw values are needed for ordering or adjacency, another family may be primary.

Numeric code is often wrong because the representation is not canonical.

Use integer formulas when possible. Floating point should be avoided for slopes, collinearity, and equality unless the problem explicitly works in continuous precision.

The transformation must preserve exactly what the answer asks.

State the invariant before coding. If the invariant is vague, the formula is probably being applied by memory rather than by proof.

Trace 1: subarrays divisible by k.

k = 5
prefix sums:       0   4   9   14
remainders:        0   4   4    4
                       ^        ^

step:
    current remainder 4 has appeared before
    add previous count of remainder 4

invariant:
    equal remainders define subarrays whose sum is divisible by k

Trace 2: normalized slope.

points:
A(1,1), B(3,3)

dy = 2
dx = 2
g = 2
key = (1, 1)

invariant:
    all points on the same direction from A share the same normalized key

Use this family when arithmetic structure is the reason the problem becomes simple. Be careful when:

The clean test is: can you replace brute force with a named numeric property and prove the replacement preserves the answer?

Invariant:

gcd(a, b) == gcd(b, a % b)

def gcd(a, b):
    while b:
        a, b = b, a % b
    return abs(a)

Invariant:

answer * base^exp remains equal to the original target power.

def fast_pow(x, n):
    if n < 0:
        x = 1 / x
        n = -n

    ans = 1
    while n:
        if n & 1:
            ans *= x
        x *= x
        n >>= 1
    return ans

Invariant:

gcd(a, b) preserves the set of common divisors through gcd(b, a % b).

LCM should be computed as:

a // gcd(a, b) * b

This reduces overflow risk.

Invariant:

The formula counts each valid object exactly once.

Before using a formula, decide whether order matters:

combination: order does not matter
permutation: order matters
multiset: repeated items need division or DP

Invariant:

Integer formulas should preserve geometric relations without floating-point
rounding.

Prefer:

cross products
squared distances
reduced slopes
bounding-box overlap

Input:

x = 2
n = 13

Binary exponent:

13 = 1101b

Process:

ans *= 2       because low bit is 1
square base -> 4
skip multiply because next bit is 0
square base -> 16
ans *= 16
square base -> 256
ans *= 256

Answer:

8192

Anchor:

(0, 0)

Points:

(2, 2) -> dy=2, dx=2 -> reduced (1, 1)
(4, 4) -> dy=4, dx=4 -> reduced (1, 1)
(1, 2) -> dy=2, dx=1 -> reduced (2, 1)

The first two points share the same line through the anchor.