Number Theory and Combinatorics in SKS

Use the article as a practical guide to attacking unfamiliar olympiad problems with a more systematic SKS reasoning framework.

Number theory and combinatorics often appear to ask different kinds of questions.

Number theory studies objects such as:

digits, bases, divisibility, residues, prime factors, and arithmetic relations.

Combinatorics studies:

arrangements, classes, grids, configurations, and counting.

Yet many olympiad problems become easier only when the Navigator stops respecting that boundary.

An arithmetic condition may collapse into a combinatorial classification. A large collection of exact integers may be replaced by a few residue classes. A numerical equality may turn into a simple question about whether a digit appears.

The strategic pattern is:

Arithmetic Object → Structural Projection → Combinatorial State-Space → Resolution

This article studies two AIME problems in which that transformation becomes especially visible:

2026 AIME II Problem 4 — a problem about interpreting decimal numerals in another base collapses into counting numbers containing the digit 9.

2023 AIME II Problem 10 — twelve integers collapse into three residue classes, then into three column vectors whose orientations propagate deterministically across a grid.

The progression is:

Exact Arithmetic → Categorical Structure → Combinatorial Counting

The central SKS principle is:

The mathematical domain in which a problem is stated does not have to be the domain in which its Resolution Structure becomes visible.

---

1. Two Mathematical Domains, One Strategic State-Space

Suppose a problem is initially represented in an arithmetic state-space:

𝒮NT

containing numbers, digits, bases, congruences, products, or divisibility relations.

The Navigator may construct another representation:

Πcomb(𝒮NT)

whose coordinates are instead:

• classes,
• positions,
• colors,
• arrangements,
• vectors,
• occupancy states.

The underlying mathematical problem has not changed.

What changes is the representation available to the Navigator.

We therefore work with the coupled system:

*𝒮 = 𝒮P × 𝒮N**

where:

𝒮P = objective problem state-space,

and:

𝒮N = Navigator representation of that state-space.

A mathematical breakthrough may occur even though the objective problem remains unchanged:

Pₜ₊₁ = Pₜ

while:

ΠNₜ₊₁(𝒮P) ≠ ΠNₜ(𝒮P)

The Navigator has not changed the problem.

The Navigator has changed what counts as a relevant coordinate.

---

2. Cross-Domain Reasoning as Projection Change

A useful question in olympiad mathematics is not only:

What topic is this problem from?

A strategically stronger question is:

What representation makes the decisive constraint easiest to see?

For example, the condition:

x − y is not divisible by 3

can be read arithmetically.

But it can also be compressed into:

x mod 3 ≠ y mod 3

and then into:

adjacent cells must have different colors.

Likewise, comparing the value of the same numeral in bases b and 10 initially appears to demand explicit calculation.

But the real structure may be only:

b < 10 or b = 10?

The domain shift itself becomes a Strategic Trigger.

---

3. The Main SKS Pattern

Both problems in this article follow the same high-level architecture:

Surface Read

↓

Find the information actually used by the condition

↓

Discard irrelevant numerical detail

↓

Construct a lower-dimensional state-space

↓

Count states in the compressed representation

The two problems differ in where the decisive compression occurs.

In the first:

Exact Numeral → Base Regime → Digit-Presence Condition

In the second:

Exact Integers → Residues → Column Types → Forced Orientation Chain

---

4. Case Study 1 — 2026 AIME II Problem 4

For every positive integer n, define f(n) by taking the ordinary decimal numeral for n and interpreting those same digits as a base-b numeral, where b is the smallest integer greater than every digit appearing in n.

For example, for n = 72, the largest digit is 7, so b = 8, and:

f(72) = 7·8 + 2 = 58.

The problem asks for the number of positive integers n < 1000 satisfying:

f(n) = n.

The official answer is 279. (LIVE)

At first sight, the problem seems to require studying hundreds of numerals and many possible bases.

That is the Surface Read.

---

5. Surface Read: Evaluate the Base

Suppose:

n = dₖ₋₁…d₁d₀

in decimal notation.

Its ordinary value is:

n = Σ dᵢ10ⁱ

while its value under the new interpretation is:

f(n) = Σ dᵢbⁱ

where:

b = 1 + max(dᵢ).

One possible approach is to analyze different maximum digits:

max digit = 1, 2, 3, …, 9

and solve the corresponding equations.

That is mathematically possible.

But it preserves far more information than the resolution requires.

The strategic question is not:

What is the exact value of b?

It is:

Can b be smaller than 10 while f(n) still equals n?

That change in question produces the Structural Unlock.

---

6. Hidden Axis: Compare Place-Value Systems

Because every decimal digit is at most 9:

b ≤ 10.

There are therefore only two strategically different regimes:

b < 10

and:

b = 10.

Consider a numeral containing at least two digits.

If b < 10, then for every positive place i:

bⁱ < 10ⁱ.

The leading digit is positive, so at least one positive-place contribution is strictly smaller in base b than in base 10.

Therefore:

Σ dᵢbⁱ < Σ dᵢ10ⁱ

and hence:

f(n) < n.

This immediately rules out every multi-digit numeral with:

b < 10

A potentially complicated equation has become an ordering relation.

---

7. Strategic Invariant: Positional Dominance

The crucial structure is not any particular digit.

It is the dominance relation:

b < 10 ⇒ bⁱ < 10ⁱ for i ≥ 1.

Once the same digit string is evaluated in the two place-value systems, the base-10 numeral is strictly larger whenever the smaller base affects a non-units position.

This gives a stable resolution condition:

multi-digit equality requires b = 10.

That is the Active Strategic Invariant of the first phase.

The problem has compressed from:

f(n) = n

to:

b = 10?

---

8. Structural Unlock: Base 10 Means Digit 9

By definition:

b = 1 + greatest digit of n.

Therefore:

b = 10

if and only if:

the greatest digit is 9,

which is equivalent to:

n contains at least one digit 9.

So for every multi-digit n:

f(n) = n ⇔ n contains a 9.

This is the decisive domain transformation:

Equation in positional notation

↓

Comparison of bases

↓

Presence/absence of a digit

The arithmetic problem has turned into elementary combinatorial counting.

---

9. The One-Digit Regime

There is one important boundary case.

For a one-digit number:

n = d

there are no higher place values.

Regardless of the chosen base:

f(n) = d = n.

Therefore all:

1,2,…,9

work.

That contributes:

9 solutions.

This exception also illustrates an important DCE principle.

The argument:

b < 10 ⇒ f(n) < n

depends on the existence of a positive power of the base.

For one-digit numerals there is only the coefficient of b⁰ = 1.

The Navigator must verify the boundary regime rather than mechanically extending the general pattern.

---

Да. Здесь лучше показать не просто «удобный способ подсчета», а смену проекции Navigator: условие «есть хотя бы одна 9» создает пересекающиеся случаи, тогда как дополнение «ни одной 9» распадается на независимые локальные ограничения по разрядам.

Я бы переписал разделы так:

10. Counting the Two-Digit Solutions: From Overlapping Cases to a Factorized State-Space

There are:

90

two-digit integers, from 10 through 99.

We need to count those containing at least one digit 9.

A direct approach is possible. The Navigator may first separate the numbers according to the position of the digit 9:

• tens digit is 9;
• units digit is 9.

But these two classes overlap at:

99.

So even in this small case, the direct representation introduces an extra bookkeeping problem. One has to remember which cases overlap and correct for double counting.

For example:

• 90 through 99 give 10 numbers;
• numbers ending in 9 give 9 numbers;
• but 99 belongs to both groups.

Therefore:

10 + 9 − 1 = 18.

The calculation is easy here, but the important strategic issue is already visible.

The property:

contains at least one 9

is an existential condition across digit positions.

For a two-digit numeral with digits d₁d₀, we are asking whether:

d₁ = 9 OR d₀ = 9.

The corresponding state classes overlap.

From an SKS perspective, this creates unnecessary Strategic Friction: the Navigator is working in a representation where the target set is defined as a union of interacting cases.

The Structural Unlock is to reverse the projection.

Instead of asking:

Where can a 9 appear?

ask:

How many numbers contain no 9 at all?

Now the constraint becomes local and independent at each position.

To avoid 9:

• the tens digit can be any of 1,2,…,8: 8 choices;
• the units digit can be any of 0,1,…,8: 9 choices.

Therefore the number of two-digit integers containing no 9 is:

8·9 = 72.

Hence the number containing at least one 9 is:

90 − 72 = 18.

The answer is the same, but the reasoning architecture is different:

Overlapping Positive Cases

↓

Complement Projection

↓

Independent Digit Constraints

↓

Product Count

This is a small but important SKS move.

The Navigator replaces:

“at least one position satisfies the condition”

with:

“every position avoids the condition.”

The first representation produces overlap.

The second factorizes.

---

11. Counting the Three-Digit Solutions: Complement as Strategic Compression

There are:

900

three-digit integers from 100 through 999.

Again, we need those containing at least one digit 9.

At this point, counting “in the obvious way” begins to create noticeably more friction.

The Navigator could split the problem according to where 9 appears:

• hundreds digit;
• tens digit;
• units digit.

But now the cases overlap in several ways.

A number may contain:

• a 9 only in the hundreds position;
• a 9 only in the tens position;
• a 9 only in the units position;
• 9s in two positions;
• or 9s in all three positions.

For example:

912

belongs to the “hundreds digit is 9” class,

while:

919

belongs simultaneously to both the “hundreds” and “units” classes,

and:

999

belongs to all three.

A direct count therefore pushes the Navigator toward inclusion-exclusion or a growing case tree.

Nothing is mathematically wrong with that approach.

But its reasoning cost is increasing faster than the underlying structure warrants.

This is a classic SKS signal:

The calculation is becoming complicated because the representation is complicated, not because the problem itself is complicated.

The condition:

“contains at least one 9”

is again producing a union of overlapping subspaces.

So we apply the same projection change as in the two-digit case:

Count those that do not contain 9.

This changes the logical form of the condition.

Instead of:

Hundreds = 9 OR Tens = 9 OR Units = 9

we use:

Hundreds ≠ 9 AND Tens ≠ 9 AND Units ≠ 9.

That transformation is strategically important.

The OR structure creates overlaps.

The AND structure creates independent coordinate restrictions.

The state-space now factorizes by digit position.

For a three-digit number containing no 9:

• the hundreds digit can be 1,…,8: 8 choices;
• the tens digit can be 0,…,8: 9 choices;
• the units digit can be 0,…,8: 9 choices.

Therefore:

8·9·9 = 648

three-digit integers contain no 9.

Hence:

900 − 648 = 252

three-digit integers contain at least one 9.

So the number of three-digit solutions is:

252.

The important SKS transition is:

Existential Target Condition

↓

Complement

↓

Universal Avoidance Condition

↓

Independent Coordinates

↓

Multiplicative State-Space

In other words:

“At least one 9”

is awkward because it couples the positions through overlapping cases.

But:

“No 9 anywhere”

decouples the positions.

This is more than a standard counting trick.

It is a change in the Navigator’s representation of the same solution set.

The objective problem has not changed:

Pₜ₊₁ = Pₜ.

But the projection has:

Π₁: presence of 9 → overlapping positional cases

becomes:

Π₂: absence of 9 → independent digit coordinates.

The second projection has lower Strategic Friction.

It also scales immediately.

For a k-digit number, counting numerals containing at least one 9 directly becomes increasingly cumbersome, while the complement remains structurally simple:

8·9^(k−1)

k-digit numerals contain no 9.

This suggests a general combinatorial principle:

When the desired states are defined by an overlapping “at least one” condition, inspect the complement. The forbidden region may have a simpler topology than the target region.

In SKS terms:

Count the easier side of the state-space boundary.

And for this problem, that change of projection is exactly what converts a potentially branching case analysis into a one-line product count.

Finally, we combine the three digit-length regimes already analyzed: all 9 one-digit numbers work, there are 18 valid two-digit numbers, and 252 valid three-digit numbers. Therefore the total number of positive integers less than 1000 satisfying f(n)=n is:

9 + 18 + 252 = 279.

So the answer is:

279.

---

12. SKS Reading of Case 1

The most important step was not complementary counting.

That part is elementary once the state-space has been compressed.

The difficult conceptual move is earlier:

Do not solve f(n) = n digit by digit. Compare the two positional systems globally.

The sequence of projections is:

Exact Digits + Variable Base

↓

Base Comparison

↓

{b < 10, b = 10}

↓

{digit 9 absent, digit 9 present}

↓

Combinatorial Counting

This is strong cognitive compression.

A potentially large family of arithmetic equations becomes a binary structural classification.

The Hidden Axis is:

Base Equality with the Original Representation

and the Strategic Trigger is:

compare place weights rather than individual numerals.

---

13. Case Study 2 — 2023 AIME II Problem 10

Let N be the number of ways to place the integers 1 through 12 in a 2 × 6 grid so that any two cells sharing a side contain numbers whose difference is not divisible by 3.

The problem asks for the number of positive divisors of N. The answer is 144.

The visible state-space is enormous:

12!

possible arrangements before constraints are imposed.

But the condition does not actually care about exact differences.

It cares only about one quotient structure.

---

14. Strategic Compression: Integers Become Residues

Two integers differ by a multiple of 3 exactly when they have the same residue modulo 3.

Therefore the original condition becomes:

Cells sharing a side must contain different residues modulo 3.

Among 1,…,12, each residue occurs exactly four times:

0 mod 3: 3,6,9,12

1 mod 3: 1,4,7,10

2 mod 3: 2,5,8,11

The first projection is therefore:

{1,…,12} → {0,1,2}.

Instead of arranging twelve distinct numerical values, first solve a much smaller problem:

Fill the 2 × 6 grid with four 0s, four 1s, and four 2s so that adjacent cells are different.

Only afterward will we restore the actual integers.

This factorization gives:

N = K·(4!)³

where K is the number of valid residue grids. (LIVE)

---

15. The Hidden Combinatorial Object: Three Column Vectors

Every column has two vertically adjacent cells.

They cannot carry equal residues.

So each column must contain one of the three unordered residue pairs.

For clarity, define three canonical column vectors:

a = (0,1)

b = (0,2)

c = (1,2)

At this stage, a, b, and c represent column types, not yet fixed top-bottom orientations.

For example, type a may appear as either:

(0,1)

or:

(1,0).

Similarly for b and c.

Let the numbers of columns of each type be:

xₐ, xᵦ, x𝚌.

Residue 0 appears in types a and b, and must occur four times:

xₐ + xᵦ = 4.

Residue 1 appears in a and c:

xₐ + x𝚌 = 4.

Residue 2 appears in b and c:

xᵦ + x𝚌 = 4.

Subtracting these equations gives:

xₐ = xᵦ = x𝚌.

Since there are six columns:

xₐ + xᵦ + x𝚌 = 6.

Therefore:

xₐ = xᵦ = x𝚌 = 2.

Every valid residue grid must contain exactly:

two a-columns, two b-columns, and two c-columns.

The 12-cell grid has now become a six-symbol sequence:

aabbcc

in some order.

---

16. Column Ordering and Forced Orientation

This step contains two different combinatorial questions:

A. In which order can the six column types appear?

B. Once that order is chosen, how many top-bottom orientations are possible?

Keeping these two questions separate makes the structure much clearer.

16.1 Counting the Type Sequences

We need all six-position sequences containing exactly:

2 copies of a

2 copies of b

2 copies of c.

Examples include:

aabbcc

abcabc

abccba

cbabac

and so on.

If all six symbols were distinct, there would be:

6!

orders.

But the two a’s are indistinguishable, so exchanging them does not create a new sequence. The same is true for the two b’s and the two c’s.

Therefore every actual sequence has been counted:

2!·2!·2!

times in 6!.

Hence the number of distinct type sequences is:

6! / (2!·2!·2!)

which equals:

720 / 8 = 90.

This is the standard multinomial count.

There is also a more constructive way to see the same result.

First choose the two positions occupied by a:

C(6,2) = 15.

Four positions remain.

Choose two of those for b:

C(4,2) = 6.

The remaining two positions are automatically occupied by c.

Therefore:

C(6,2)·C(4,2) = 15·6 = 90.

So:

90

different type chains are possible before orientation is considered.

This second derivation is particularly useful from the SKS point of view because it interprets the result as sequential state-space reduction:

6 free positions

↓

choose 2 for a

↓

4 free positions

↓

choose 2 for b

↓

c is forced.

---

16.2 Why Orientation Looks Difficult

Now comes the more subtle step.

Each column type seems to have two orientations.

For example:

a = (0,1) or (1,0).

A first Surface Read might therefore suggest:

2⁶

possible orientation choices for every type sequence.

This is exactly where significant Navigator friction can occur.

The columns look locally independent.

They are not.

Horizontal adjacency couples them.

The correct strategic question is:

Once one column is oriented, how much freedom actually remains in the next column?

The answer is:

none.

---

16.3 The Shared Residue as a Constraint Carrier

Take any two consecutive column types from:

a = {0,1}

b = {0,2}

c = {1,2}.

Any two different types share exactly one residue.

For example:

a and b share 0.

a and c share 1.

b and c share 2.

If two consecutive columns have the same type, they share both residues.

Now remember the horizontal condition:

cells in the same row in adjacent columns must have different residues.

Suppose the shared residue appears in the top cell of the current column.

Then it cannot appear in the top cell of the next column.

Therefore it must appear in the bottom cell.

Once that position is fixed, the other residue automatically occupies the remaining cell.

So:

the orientation of the current column uniquely determines the orientation of the next column.

This is local constraint propagation.

---

16.4 Example: The Sequence abcabc

Suppose the six column types are:

a b c a b c

and choose the first orientation:

a = (0,1)

where the first coordinate is the top cell and the second is the bottom cell.

The first two columns are a and b.

Type b contains residues 0 and 2.

In the first column, residue 0 is on top.

Therefore residue 0 cannot remain on top in the second column.

So b is forced to be:

(2,0).

Now compare b and c.

They share residue 2.

In column 2, residue 2 is on top.

Therefore it must move to the bottom in column 3.

Thus c is forced to be:

(1,2).

Now c and a share residue 1.

Residue 1 is on top in column 3, so in column 4 it must be on the bottom.

Therefore:

a = (0,1).

Continuing gives:

(0,1), (2,0), (1,2), (0,1), (2,0), (1,2).

There was no new choice after column 1.

---

16.5 Example: The Sequence aabbcc

The same principle works when equal types are adjacent.

Start with:

a = (0,1).

The second column is also type a.

Since both residues are shared, both must switch rows.

Therefore column 2 is forced to be:

(1,0).

The third column is b.

Types a and b share residue 0.

In column 2, 0 is on the bottom, so in column 3 it must be on the top:

b = (0,2).

The fourth column is another b, so it must reverse:

b = (2,0).

Then c shares residue 2 with b.

Since 2 is on top in column 4, it must be on the bottom in column 5:

c = (1,2).

Finally the second c must reverse:

c = (2,1).

Thus:

(0,1), (1,0), (0,2), (2,0), (1,2), (2,1).

Again, everything after the first orientation is forced.

---

16.6 Why the First Vector Determines the Whole Chain

We can now formulate the general rule.

For every ordered pair of consecutive column types:

• if the types differ, they share exactly one residue;
• that shared residue must change rows;
• therefore the next orientation is uniquely determined;
• if the types are equal, both residues must change rows, so the column is simply reversed.

Thus for any of the 90 type sequences:

orientation of column 1 → orientation of column 2 → … → orientation of column 6

is deterministic.

The first column has exactly two possible orientations.

Therefore each type sequence produces exactly:

2

valid residue grids.

Hence:

K = 90·2 = 180.

---

16.7 The SKS Meaning of the Guess

This is an important reasoning moment.

Why might the Navigator fail to see it immediately?

Because the Surface Projection presents six columns, each apparently carrying an independent binary orientation.

That projection suggests:

2 × 2 × 2 × 2 × 2 × 2 = 64

orientation states.

But horizontal adjacency introduces a hidden coupling.

The actual strategic structure is:

1 initial binary choice + 5 forced transitions.

So the orientation state-space collapses from:

2⁶ = 64

apparent possibilities

to:

2

actual possibilities for each fixed type sequence.

The Hidden Axis is:

Shared Residue × Row Position

and the Strategic Trigger is:

Every adjacent pair of column types shares a residue, and that residue must switch rows.

In information terms, after the first column:

H(next orientation | current orientation, next type) = 0.

There is no remaining orientation uncertainty.

The first orientation acts as an initial condition for a deterministic transition system.

This is a particularly strong example of Strategic Friction caused by false independence.

The Navigator initially sees six local choices.

The actual system contains only one global choice.

---

17. Returning to the Exact Integers

The residue grid is now solved.

There are:

K = 180

valid residue patterns.

But the original grid contains distinct integers, not residue labels.

Each residue class contains four numbers.

Once the four cells carrying residue 0 are known, the four numbers:

3,6,9,12

can be permuted among them in:

4!

ways.

The same is true independently for the residue-1 and residue-2 classes.

Therefore:

N = 180·(4!)³.

Since:

180 = 2²·3²·5

and:

(4!)³ = 24³ = 2⁹·3³,

we obtain:

N = 2¹¹·3⁵·5.

Thus the number of positive divisors is:

(11+1)(5+1)(1+1)

= 12·6·2

= 144.

---

18. SKS Reading of Case 2

The decisive move was not counting 12! arrangements.

It was identifying which information the constraint actually observes.

The condition cannot distinguish:

1 from 4 from 7 from 10

because all have the same residue modulo 3.

Therefore exact value is initially irrelevant.

The first compression is:

12 distinct values → 3 residue classes.

The second is:

12 residue cells → 6 column types.

The third is:

6 seemingly independent orientations → 1 initial orientation + deterministic propagation.

Thus the full chain is:

Exact Integer Arrangement

↓

Residue Grid

↓

Column-Type Sequence

↓

Initial Orientation + Forced Transitions

↓

180 compressed patterns

↓

Restore exact integers

↓

Prime factorization

↓

144 divisors

---

19. The Domain Loop

Case 2 moves through several mathematical languages:

Arithmetic

→ congruence mod 3

→ Coloring

→ column types

→ Multiset Combinatorics

→ forced propagation

→ Permutation Counting

→ exact-number restoration

→ Number Theory

→ divisor function.

The problem therefore does not merely combine number theory and combinatorics.

It uses a sequence of strategically different projections.

The same objective state is repeatedly re-encoded.

---

20. The Two Cases as an Evolution

The first case performs an unexpectedly strong compression:

Numerical Equation → Binary Regime

The second goes further:

Exact Numbers → Equivalence Classes → Local Structures → Deterministic Transition Chain

Their strategic progression is:

Case 1: Detect the decisive class.

Case 2: Build a compressed state-space and discover hidden dependence inside it.

Or more compactly:

Classification → Quotienting → Constraint Propagation

---

21. Cognitive Compression

Both problems illustrate the same principle:

Preserve only information capable of changing the answer.

In Case 1, the exact maximum digit from 0 through 8 does not matter.

All those cases belong to one strategic regime:

b < 10.

The nine possible maximum digits compress to:

{9 present, 9 absent}.

In Case 2, the exact integer initially does not matter either.

Twelve numerical identities compress to three classes:

0,1,2 mod 3.

Then six orientation choices that appear independent compress to:

one binary initial state.

This is the SKS compression chain:

𝒮full → Πstrategic(𝒮full)

with the objective:

Maximum Safe Information Reduction + Preserved Resolution Structure

---

22. Projection Mismatch

Each case has a characteristic wrong projection.

For the 2026 AIME problem:

Wrong projection: solve f(n)=n for many individual digit patterns.

Better projection: compare positional weights globally.

For the 2023 AIME problem:

Wrong projection: track twelve exact integers.

Better projection: track residues.

But there is a second mismatch inside the compressed representation:

Wrong projection: six column orientations are independent.

Better projection: adjacent vectors are coupled by their shared residue.

This second mismatch is especially important.

Compression alone does not guarantee that the Navigator has found the correct model.

One must also identify dependencies between the compressed coordinates.

---

23. DCE: Abstraction ↔ Verification

Both cases require movement between abstraction and exact verification.

In Case 1:

Abstraction: replace the equality problem by the regimes b<10 and b=10.

Verification: prove strict inequality f(n)<n for every multi-digit numeral when b<10, then separately check one-digit numbers.

In Case 2:

Abstraction: replace integers by residues and columns by types a,b,c.

Verification: prove:

xₐ = xᵦ = x𝚌 = 2,

then prove that every transition has exactly one valid next orientation.

This is the DCE loop:

Strategic Abstraction ↔ Universal Constraint Verification

Without abstraction, the state-space remains too large.

Without verification, the compressed model may be a structural hallucination.

---

24. Active Strategic Invariants

The two cases use different types of invariant.

For Case 1:

Positional Order Invariant

If b<10 and the numeral has multiple digits:

f(n)<n.

The only equality regime is therefore b=10.

For Case 2:

Residue Occupancy Invariant

There must always be exactly four occurrences of each residue.

This forces exactly two copies of each column type.

A second invariant then appears:

Shared residues must switch rows across adjacent columns.

That local invariant generates global orientation determinism.

The evolution is therefore:

Global Order Relation

→

Quotient Occupancy

→

Local Transition Invariant

---

25. USC Reading

[geo] Strategic Geometry

Both solutions are coordinate changes.

Case 1:

exact digits → base regime.

Case 2:

integer → residue → column vector → transition state.

The decisive geometry lies in representation space rather than physical geometry.

[mech] Strategic Mechanics

Case 1 uses a monotone comparison between two place-value systems.

Case 2 uses local transition mechanics:

current orientation + next type → unique next orientation.

The second problem is therefore especially close to a finite-state machine.

[thermo] Strategic Thermodynamics

Brute-force reasoning produces unnecessary reasoning heat.

Case 1 begins with 999 possible integers.

Case 2 begins with 12! raw arrangements.

The successful projections sharply reduce the amount of information that must be processed.

[field] Strategic Field Theory

Surface notation generates misleading attractors.

Base notation invites case-by-case base arithmetic.

A grid of twelve integers invites permutation counting.

In both cases, these visible objects are not the best Resolution coordinates.

[topo] Strategic Topology

Case 2 contains an important reachability structure.

Once the first orientation is selected, the remaining orientation states lie on one forced trajectory.

The Navigator is no longer exploring a branching tree.

The state-space has collapsed to two deterministic paths corresponding to the two initial orientations.

[info] Strategic Information Theory

This is the dominant USC perspective.

Case 1 discards exact digit values until only the presence of 9 matters.

Case 2 discards exact integer values, then discards independent orientation freedom.

The strongest reduction occurs when apparent entropy is discovered to be false:

2⁶ apparent orientation configurations → 2 actual trajectories.

[stoch] Strategic Stochastic Theory

Neither problem contains objective randomness.

The uncertainty is epistemic: the Navigator initially does not know which representation will expose the Resolution Structure.

Projection change converts search uncertainty into deterministic structure.

---

26. A General Taxonomy of Number Theory × Combinatorics Problems

Several reusable architectures emerge from these cases.

Arithmetic surface	Strategic projection	Combinatorial structure
Numeral in variable base	compare positional weights	classify digit patterns
Congruence	quotient by residue	coloring
Divisibility	compatibility relation	graph / pairing
Digit condition	presence / absence classes	complementary counting
Residue multiplicities	occupancy vector	multiset permutations
Local modular constraints	shared-coordinate transitions	finite-state propagation
Prime factorization	exponent vector	divisor counting

The common operation is:

Arithmetic Detail → Structural Equivalence Classes

---

27. Mathematics Navigator Protocol

When a number-theory problem contains strong combinatorial structure, the Navigator can ask:

1. 
   

   What information does the condition actually observe?
   
   Exact values, residues, parity, digits, or only an order relation?

   
   
2. 
   

   Can many numerical states be quotient into the same strategic class?

   
   
3. 
   

   Is an equation easier to replace by an inequality or regime classification?

   
   
4. 
   

   After compression, are the remaining coordinates really independent?

   
   
5. 
   

   Do local constraints propagate globally?

   
   
6. 
   

   Can a large arrangement problem be split into a structural pattern and a later restoration of exact labels?

   
   
7. 
   

   What information has been discarded, and can any of it still affect the answer?

   
   

The fourth question is especially important.

The 2023 AIME case shows that even after a successful projection, the Navigator may still overestimate state-space freedom.

---

28. Strategic Hallucinations

A number-theory/combinatorics problem encourages several recurring reasoning errors.

“The equation must be solved directly.”
Not necessarily. In Case 1, an inequality classifies every multi-digit candidate at once.

“Every integer must remain distinct throughout the solution.”
Not if the condition sees only residue classes.

“Each local binary choice contributes a factor of 2.”
Only when the choices are independent. In Case 2, adjacency destroys that independence.

“Once I compress the state-space, the hard part is finished.”
Not always. Hidden dependencies may remain inside the compressed system.

The more general warning is:

Do not count degrees of freedom before checking whether the constraints couple them.

---

29. FAQ

Why is the 2026 AIME problem relevant to combinatorics?

Because after the arithmetic comparison is solved, the remaining task is entirely combinatorial: count digit strings satisfying a presence condition.

The domain changes during the solution.

Why is digit 9 special?

Because the base b is defined as one more than the greatest digit. Since decimal digits never exceed 9:

b=10 exactly when a 9 occurs.

Why do one-digit numbers need separate treatment?

Because changing the base affects only positive powers of the base. A one-digit numeral contains only the units coefficient, so its value is independent of the base.

Why are there exactly two of each vector a, b, c?

Because every residue must appear four times. The three resulting occupancy equations force equal counts, and six total columns then force each count to be two.

Why are there 90 orders of a,a,b,b,c,c?

Because this is a permutation of a multiset:

6!/(2!2!2!) = 90.

Equivalently:

C(6,2)·C(4,2) = 90.

Why are there only two orientations for each type sequence?

Because after the first orientation is chosen, every adjacent column shares a residue with the previous one. That residue must change rows, uniquely fixing the next orientation.

What is the main SKS lesson of the second case?

A state-space can contain false degrees of freedom.

Six columns appear to have six independent orientation choices, but the constraint network reduces them to one initial binary choice followed by deterministic propagation.

---

30. Conclusion

Number theory and combinatorics are often presented as separate mathematical domains.

These two AIME problems show why that separation can become strategically misleading.

In the 2026 AIME problem, a variable-base equation initially appears to require detailed arithmetic analysis. The decisive move is instead to compare place-value systems. That collapses all multi-digit candidates into two regimes:

b<10

and:

b=10.

The second regime is equivalent to a simple combinatorial property:

the numeral contains a 9.

In the 2023 AIME grid problem, twelve exact integers collapse into three residue classes. Those classes collapse again into three column vectors:

a=(0,1), b=(0,2), c=(1,2).

The vectors form a multiset with 90 possible orders.

But an even deeper compression follows: once the first vector is oriented, the horizontal constraints propagate that orientation through the entire chain.

What appeared to be:

six binary choices

is actually:

one binary choice + five forced transitions.

The two cases therefore reveal two different forms of strategic compression:

Arithmetic Equation → Categorical State

and:

Local Choices → Coupled Deterministic System

Together they support a broader SKS principle:

The strongest representation is not the one that preserves the most information. It is the one that preserves exactly the information capable of changing the resolution.

Or, in compact form:

Exact Numbers → Strategic Classes → Hidden Dependencies → Resolution.