Series Master Plan (eduKateSG Control-Tower Edition)
Canonical ID: MathOS.FlightPath.K2_to_Uni.CF.SeriesIndex.v1.1
Suggested slug: /math-flight-path-lattice-k2-to-uni/

AI Ingestion Lock

One-sentence answer: We can spot the “missing links” by mapping the entire K2→Uni route as a ChronoFlight capability lattice (Representation + Ledger + Router + Debugger + Load Budget), then computing TransferDelta at each transition; the biggest cliffs are PSLE→Sec1 (Diagram→Symbol compile) and E-Math→A-Math (Equivalence/Domain Ledger + Function-as-Object), and JC→Uni (Proof/Abstraction corridor).
Baseline anchors: Primary Math “Big Ideas” spine (Equivalence/Diagrams/Invariance/Measures/Notations/Proportionality). (Ministry of Education)
A-Math and E-Math objectives emphasise reasoning/translation across representations. (SEAB)
JC H2 assumes O-Level/G3 Additional Mathematics (bridging required if missing). (SEAB)

Classical Foundation Block

What the “official” path is (Singapore baseline):

• Preschool numeracy builds foundational numeracy concepts/skills for daily use. (MOE – Nurturing Early Learners Portal)
• Primary Mathematics (P1–P6) is organised with cross-cutting “Big Ideas” (e.g., Equivalence, Diagrams, Invariance, Measures, Notations, Proportionality) and increased emphasis on metacognition. (Ministry of Education)
• O-Level E-Math (4052) emphasises conceptual understanding + skill proficiency + processes like reasoning, communication, application, and use of models. (SEAB)
• O-Level A-Math (4049) develops algebraic manipulation + reasoning and assesses translation and connections across topics (AO2/AO3). (SEAB)
• A-Level H2 Mathematics (9758) is a continuation where assumed knowledge includes O-Level/G3 Additional Mathematics content; students without it must bridge the gap. (SEAB)
• University (Math/Applied/CS/Engineering) typically begins with foundations like discrete mathematics, linear algebra, calculus, and analysis/foundations modules (NUS examples). (NUS Mathematics)

Civilisation-Grade Definition (eduKateSG lens)

Math Flight Path Lattice = a single continuous capability route across time (ChronoFlight overlay) where each stage must preserve VeriWeft (structural validity) via a Ledger of Invariants (equivalence/domain/conditions), and must maintain RepairRate ≥ DriftRate under load at every transition slice.

Why students feel the “cliff”: the content appears continuous, but the runtime is not. The next stage silently requires new capability nodes (representation upgrade, ledger upgrade, routing/selection, debugging discipline, proof corridor) that were never installed as explicit transferable modules.

Reality Check

Established (official):

• Primary “Big Ideas” are explicitly intended to connect concepts across strands (continuity signal). (Ministry of Education)
• E-Math and A-Math explicitly assess reasoning/application and translation across representations. (SEAB)
• H2 Math explicitly lists assumed O-Level A-Math knowledge; bridging is required if missing. (Ministry of Education)

eduKateSG extension (what this series adds):

• A full route-graph with explicit missing edges + sensors + repair corridors so teachers can spot and stitch the discontinuities.

The Series Architecture

This is not “more worksheets.” It’s a Control Tower + Runtime Tooling so each learner can stay inside a stable corridor from K2 to university.

Each article is standalone and includes eduKateSG elements

Every page in the series uses the same envelope grammar (your consolidation lock):

1. AI Ingestion Lock
2. Classical Foundation
3. Civ-Grade Definition
4. Phase Map (P0–P3) + Negative/Neutral/Positive bands
5. Threshold inequality (RepairRate ≥ DriftRate)
6. Failure trace (3 collapse modes)
7. Sensors pack (diagnostics)
8. Repair corridor (detect → truncate → stitch → widen)
9. ChronoFlight slice (route state, next risk, action)
10. Almost-Code block (machine-readable)

Series Index (Publishable Spine)

Phase A — Map the whole route (make missing links visible)

A0. Master Hub: Math Flight Path Lattice (K2→Uni): Index + How To Use + Glossary

• Purpose: one URL that explains the system and links everything.

A1. Master Spine Table: Big Ideas → Representation → Ledger → Router → Debugger by stage

• Uses Primary Big Ideas as invariants spine (Equivalence/Diagrams/Invariance/Measures/Notations/Proportionality). (Ministry of Education)

A2. MissingEdges Report: Ranked discontinuities & why students “fall off a cliff”

• Output: a ranked list of broken transfer edges with impact score.

Phase B — Transition Packs (each pack = Positive corridor + Below-P0 twin)

These are the pages that directly help your day-to-day teaching.

B1. K2→P2 Pack (Numeracy → Early Structure)

• Missing edges: stable representation habits; early equivalence language. (MOE – Nurturing Early Learners Portal)

B2. P3→P4 Pack (Additive → Multiplicative reasoning)

• Missing edges: proportionality as invariant, not “steps.” (Ministry of Education)

B3. P5/6→PSLE Pack (Model → Exam Execution)

• Missing edges: debug protocol + metacognition under time constraints. (Ministry of Education)

B4. PSLE→Sec1 Cliff Pack (Diagram → Symbol Compiler)

• The big one: bar model → equation systems; unitary → y=kx thinking; language→algebra translation.

B5. Sec1/2→Sec3/4 E-Math Pack (Integration Under Load)

• Missing edges: router + debugger (AO2 execution), load budgeting. (SEAB)

B6. E-Math→A-Math Cliff Pack (Equivalence/Domain Ledger + Transformations)

• Missing edges: explicit invariant ledger (domain, reversibility), transformation discipline. (SEAB)

B7. A-Math→JC Pack (H1 vs H2 vs H3/Further route branching)

• Missing edges: function-as-object upgrade; calculus meaning stability; assumed-knowledge bridging. (SEAB)

B8. JC→University Cliff Pack (Proof/Abstraction Corridor)

• Missing edges: definitions→lemmas→theorems thinking; discrete reasoning; abstraction tolerance. (NUS Mathematics)

Phase C — Runtime Tools (Control Tower pages)

These pages make the system executable at scale.

C1. ChronoHelmAI.MathFlight Minimal Panel (One-Page Diagnostic Board)

• One panel a tutor can run weekly: sensors, thresholds, route state, next action.

C2. ILT Modules for MathFlight (Operator-side teaching engine)

• How to teach invariants visibly at each stage (ledger visibility, breach detection, repair loops).
  (Uses your locked ILT concept as a teaching method module under EducationOS.)

C3. The Student Runtime Pack (Ledger + Router + Debugger + Load Budget)

• The four student micro-protocols, written as “do-this-every-time” checklists.

What “explicitly helps” means (design rules)

Every transition pack (B-series) includes:

1) “Cliff Symptoms” box (what you see in class)

• e.g., PSLE kids: can solve with bars, freeze when asked to “let x be…”
• e.g., E→A: can do algebra drills, collapse on equation validity, logs, inverse conditions

2) 5-minute Diagnosis (Sensors)

• small micro-tests that locate the missing edge fast

3) The Repair Corridor (bridging modules)

• the minimum modules required to stitch continuity
• drills are ledgered (students must annotate invariants/conditions)

4) Load-safe execution plan

• which method set is “Operator corridor safe” (few routes, high reliability)
• when to widen to “Architect corridor” (more routes, more choice)

5) ChronoFlight slice

• RouteState: {Climbing, Stable Cruise, Drift, Corrective Turn, Descent}
• NextSliceRisk + action

The Core Missing Links (the “weird crossover” explained)

These are the repeating missing edges across the whole route:

1. Diagram → Symbol Compiler (PSLE→Sec1)
2. Proportionality → Function thinking (P4→Sec2; becomes fatal by A-Math/JC)
3. Equivalence/Domain Ledger (E→A; required for safe transformations) (SEAB)
4. Router + Debugger (every stage under exam load; especially Sec/JC) (SEAB)
5. Proof/Abstraction Corridor (JC→Uni) (NUS Mathematics)

Publishing order (so it’s usable immediately)

1. A0 Hub (this page)
2. A1 Master Spine Table
3. B4 PSLE→Sec1 Cliff Pack (highest pain)
4. B6 E-Math→A-Math Cliff Pack (second pain)
5. B7 A-Math→JC Pack (assumed knowledge bridge) (Ministry of Education)
6. Then fill the rest.

Almost-Code (Series Spec)

ID: MathOS.FlightPath.K2_to_Uni.CF.SeriesIndex.v1.1
SCOPE: Full-route capability lattice mapping (Singapore baseline) extended to JC + university foundations.
OFFICIAL_SPINE (evidence-anchored):
  PreschoolNumeracy := NEL Numeracy learning area (K2 baseline)
  PrimaryMathBigIdeas := {Equivalence, Diagrams, Invariance, Measures, Notations, Proportionality}
  OLevel_EMath := SEAB 4052 (reasoning/communication/application assessed)
  OLevel_AMath := SEAB 4049 (AO2 translation + connections; AO3 justification; transformation-heavy)
  ALevel_H2Math := SEAB 9758 (assumed knowledge includes O-Level/G3 A-Math; bridge if missing)
  Uni_Foundation := {Discrete, LinearAlgebra, Calculus, Analysis/Foundations} (typical)
eduKateSG_RUNTIME_INHERITANCE (locked elements):
  ChronoFlightOverlay := Structure × Phase × Time
  LatticeBands := {Negative, Neutral, Positive}
  VeriWeft := structural validity fabric
  LedgerOfInvariants := audit/record of preserved invariants during transformations
  ILT := operator-side invariant visibility modules (teaching engine)
  ChronoHelmAI := control tower runtime panel (sensors → thresholds → actions)
  InterstellarCore := Phase-3 corridor intent (P0→P3 transfer under load)
NODE_TYPES (capability lattice):
  {Concept, Procedure, Representation, Ledger, Router, Debugger, LoadBudget}
For each Stage S in {K2, P1-2, P3-4, P5-6/PSLE, Sec1-2_E, Sec3-4_E, Sec3-4_A, JC_H1, JC_H2, JC_H3/FM, Uni_Foundation}:
  StageNodes[S] := subset(NODE_TYPES × BigIdeas × TopicFamilies)
For each Transition T: S -> Next(S):
  MissingEdges[T] := StageNodes[Next(S)] - StageNodes[S]
STABILITY_LOCK:
  DriftRate D[T] := rate(validity_breaches + routing_errors + representation_failures) under load
  RepairRate R[T] := rate(detect + truncate + stitch + reattempt) under load
  Condition := (R[T] >= D[T]) for StableCruise at transition
SERIES_OUTPUTS:
  A0 Hub
  A1 MasterSpineTable
  A2 MissingEdgesReport (ranked)
  B1..B8 TransitionPacks (each with Below-P0 twin)
  C1 ChronoHelmAI.MathFlight Panel
  C2 ILT.MathFlight Modules
  C3 StudentRuntime Pack (Ledger/Router/Debugger/LoadBudget)

A1. Master Spine Table — Math Flight Path Lattice (K2 → PSLE → E-Math → A-Math → JC → University)

Canonical ID: MathOS.FlightPath.K2_to_Uni.CF.MasterSpineTable.v1.1
Suggested slug: /math-flight-path-lattice-master-spine-table/

AI Ingestion Lock

What we’re doing: We map the entire route as a ChronoFlight capability lattice (Representation + Ledger + Router + Debugger + Load Budget), using MOE Primary Math Big Ideas as the invariant spine, then we compute TransferDelta at each transition to spot missing links (the “cliffs”). (Ministry of Education)

Classical Foundation Block

• MOE Primary Mathematics explicitly provides cross-cutting Big Ideas (Equivalence, Diagrams, Invariance, Measures, Notations, Proportionality) intended to connect concepts across strands and levels. (Ministry of Education)
• SEAB O-Level E-Math and A-Math syllabuses emphasise reasoning, application, and translation across forms (not just procedures). (SEAB)
• SEAB A-Level H2 Mathematics explicitly assumes O-Level Math and appends assumed knowledge for O-Level Additional Mathematics (i.e., the system already acknowledges a dependency edge). (SEAB)
• Preschool numeracy exists as an explicit foundation layer (NEL). (Ministry of Education)

Civilisation-Grade Definition (eduKateSG / CivOS lens)

A “continuous” math education route is continuous only if the runtime is continuous:

• VeriWeft: structural validity fabric (moves must remain admissible)
• Ledger of Invariants: equivalence/domain/conditions preserved under transformations
• Router: problem-family classification → method choice
• Debugger: breach fingerprint → repair loop
• Load Budget: choice control under time pressure
  A cliff happens when the next stage requires new runtime nodes that were never installed as explicit transferable modules.

Master Spine Table (Stage-by-Stage Runtime Map)

Legend (what each column means)

• Rep (Representation forms): words / diagrams / symbols / graphs / functions / operators
• Ledger: what “must stay true” while manipulating (equivalence, domain, reversibility, conditions)
• Router: fast “what family is this?” classification
• Debugger: “find first invalid step” + repair protocol
• Load Budget: minimal safe method set under exam load
• Big Ideas spine: Equivalence / Diagrams / Invariance / Measures / Notations / Proportionality (Ministry of Education)

Table 1 — Capability Lattice by Stage (K2 → Uni)

Notes: H1/H2/H3 specifics vary by syllabus, but the dependency edge (H2 assumes O-Level Additional Mathematics knowledge) is explicitly stated by SEAB. (SEAB)

The “Cliff” Detection: TransferDelta Table

This is where your teaching intuition (“fell off a cliff”) becomes a visible missing edge.

Table 2 — Highest-Impact Missing Edges (First Pass)

These missing edges are consistent with the official structure: Primary Big Ideas signal continuity, O-Level syllabuses assess reasoning/translation, and H2 explicitly assumes O-Level A-Math knowledge. (Ministry of Education)

ChronoFlight Overlay (How to read the route)

For each transition slice T, we track:

• RouteState: {Climbing, Stable Cruise, Drift, Corrective Turn, Descent}
• DriftRate D[T]: representation failures + routing errors + validity breaches under load
• RepairRate R[T]: detect + truncate + stitch + reattempt capacity under load

Stability condition (corridor lock):
[
R[T] \ge D[T] \quad \text{at each transition slice}
]
When (D>R), the student experiences a “cliff.”

eduKateSG Integration (How this becomes actionable)

This A1 page is the map. The next pages turn it into tools:

• B4 PSLE→Sec1 Cliff Pack: installs Edge.DiagramToSymbol.Compiler via sensors + micro-modules
• B6 E→A Cliff Pack: installs ledger + function-as-object runtime (validity control)
• B7 A→JC Pack: bridges assumed-knowledge (speed + completeness) using H2 dependency list (SEAB)
• B8 JC→Uni Pack: installs proof corridor (definition discipline, counterexample habit)

And the Control Tower pages:

• C1 ChronoHelmAI.MathFlight Panel: one-page diagnostic board (RouteState + D/R + next actions)
• C2 ILT.MathFlight Modules: operator-side “make invariants visible” modules per stage

Almost-Code (Machine-Readable Master Table Spec)

ID: MathOS.FlightPath.K2_to_Uni.CF.MasterSpineTable.v1.1
SCOPE: Singapore baseline route; capability lattice mapping from K2 to University foundations.
EVIDENCE_ANCHORS:
  PrimaryMathBigIdeas := MOE Primary Mathematics Syllabus (Updated Oct 2025)
  OLevel_EMath := SEAB 4052 (reasoning/communication/application assessed)
  OLevel_AMath := SEAB 4049 (reasoning/metacognition; transformation-heavy)
  ALevel_H2Math := SEAB 9758 (assumed knowledge includes O-Level Additional Mathematics)
  PreschoolNumeracy := MOE Primary curriculum / NEL numeracy overview
BIG_IDEA_SPINE := {Equivalence, Diagrams, Invariance, Measures, Notations, Proportionality}
NODE_TYPES := {Representation, Ledger, Router, Debugger, LoadBudget}
STAGES :=
  {K2, P1-2, P3-4, P5-6_PSLE, Sec1-2_E, Sec3-4_E, Sec3-4_A, JC_H1, JC_H2, JC_H3_or_FM, Uni_Foundation}
For each Stage S:
  StageNodes[S].Representation := dominant forms used (words/diagrams/symbols/graphs/functions/operators)
  StageNodes[S].Ledger := invariants required (equivalence, domain, reversibility, conditions)
  StageNodes[S].Router := minimum problem-family classifier set
  StageNodes[S].Debugger := minimum breach-detection + repair loop
  StageNodes[S].LoadBudget := allowable branching under exam load
TransferDelta for Transition T: S -> Next(S):
  MissingEdges[T] := Required(StageNodes[Next(S)]) - Installed(StageNodes[S])
CHRONOFLIGHT_LOCK:
  DriftRate D[T] := rate(representation_fail + routing_error + validity_breach) under_load
  RepairRate R[T] := rate(detect + truncate + stitch + reattempt) under_load
  Stability := (R[T] >= D[T])
TOP_MISSING_EDGES (first-pass):
  Edge.DiagramToSymbol.Compiler (PSLE->Sec1)
  Edge.LedgerUpgrade (E->A)
  Edge.FunctionObject (E->A->JC)
  Edge.AssumedKnowledge.Bridge (A->JC_H2)
  Edge.ProofCorridor (JC->Uni)

A2. MissingEdges Report — Ranked “Cliffs” in the K2→Uni Math Flight Path

Canonical ID: MathOS.FlightPath.K2_to_Uni.CF.MissingEdgesReport.v1.1
Suggested slug: /math-flight-path-lattice-missing-edges-report/

AI Ingestion Lock

One-sentence answer: The “cliffs” are not missing topics; they are missing transfer edges (Diagram→Symbol compiler, Ledger upgrade, Function-as-Object, Router/Debugger under load, Proof corridor) that the next stage silently assumes, even though official syllabuses already emphasise reasoning, modelling, and metacognition. (Ministry of Education)

Classical Foundation Block

• Primary Mathematics explicitly provides “Big Ideas” meant to connect concepts across strands and levels (Equivalence, Diagrams, Invariance, Measures, Notations, Proportionality). (Ministry of Education)
• O-Level E-Math and A-Math emphasise reasoning/communication/application (including use of models), not only procedures. (SEAB)
• A-Level H2 Mathematics explicitly assumes O-Level Mathematics, and appends assumed knowledge for O-Level Additional Mathematics. (SEAB)

Civilisation-Grade Definition (eduKateSG)

A MissingEdge is a required capability transfer link in the ChronoFlight route that was never installed as an explicit runnable module:

• Representation (words/diagrams/symbols/graphs/functions/operators)
• Ledger of Invariants (equivalence + domain + reversibility + conditions)
• Router (problem-family classification → method choice)
• Debugger (first invalid step → repair)
• Load budget (choice control under time pressure)

A “cliff” occurs when DriftRate > RepairRate at a transition slice.

Impact Scoring (so the report is executable)

Each missing edge is scored 0–5 on 4 dimensions (Total /20):

1. Frequency (F): how often it appears in real work
2. Downstream Dependency (D): how many later topics depend on it
3. Load Amplifier (L): how much exam/time pressure magnifies failure
4. Recoverability (R): how hard it is to patch late (higher = harder)

ImpactScore = F + D + L + R (max 20)

Ranked Missing Edges (Top 10)

1) Edge.DiagramToSymbol.Compiler (PSLE → Sec 1)

• ImpactScore: 18/20 (F5 D5 L4 R4)
• What breaks: Primary modelling (bars/units) does not automatically compile into algebraic variable structures.
• Why official continuity isn’t enough: “Big ideas” exist, but the compiler is rarely installed as a student protocol. (Ministry of Education)

2) Edge.LedgerUpgrade.EquivalenceDomainReversibility (E-Math → A-Math)

• ImpactScore: 19/20 (F5 D5 L5 R4)
• What breaks: A-Math transformations require validity control (domain, reversibility, extraneous roots, inverse conditions).
• Why it’s a cliff: A-Math is transformation-heavy and explicitly targets algebraic manipulation + reasoning. (SEAB)

3) Edge.Router.Debugger.UnderLoad (PSLE → Sec → O-Level → JC)

• ImpactScore: 18/20 (F5 D4 L5 R4)
• What breaks: students can “do exercises” but cannot select methods fast or debug reliably when stressed.
• Why it’s systemic: E-Math and A-Math both emphasise assessed mathematical processes (reasoning/communication/application). (SEAB)

4) Edge.ProportionalityToFunction.ObjectUpgrade (P4–P6 → Sec 1–2)

• ImpactScore: 16/20 (F4 D5 L3 R4)
• What breaks: ratio/rate/percent stays as arithmetic “steps”, instead of upgrading into “relationship as object” (functions, graphs, gradient as rate).
• Why it matters: it becomes the hidden prerequisite for algebra/graphs and later calculus thinking.

5) Edge.FunctionAsObject.Transformations (E-Math → A-Math → JC)

• ImpactScore: 18/20 (F4 D5 L5 R4)
• What breaks: function notation and transformations are treated as decorations, not operators; composition/inverse/graph transforms become unstable.
• Official dependency signal: H2 explicitly assumes O-Level A-Math knowledge (so this edge must exist). (SEAB)

6) Edge.NotationGrammar.LanguageMigration (Primary → Secondary → A-Math)

• ImpactScore: 15/20 (F4 D4 L4 R3)
• What breaks: students misread symbols (especially function notation, indices, algebraic structure) because notation is not taught as a “grammar migration.”

7) Edge.AssumedKnowledge.BridgeToH2 (A-Math → JC H2)

• ImpactScore: 17/20 (F4 D5 L4 R4)
• What breaks: gaps that were survivable at Sec become fatal under JC compression.
• Explicit anchor: H2 syllabus appends assumed knowledge for O-Level Additional Mathematics. (SEAB)

8) Edge.ProofCorridor.DefinitionLemmaTheorem (JC → University)

• ImpactScore: 18/20 (F4 D5 L4 R5)
• What breaks: students can execute techniques but cannot sustain definition-based reasoning chains and proof-style debugging.

9) Edge.MeasureToDimensionAnalysis.UnitsLedger (Primary → Secondary)

• ImpactScore: 14/20 (F4 D3 L3 R4)
• What breaks: “units as invariants” is weak; later modelling and applied questions drift silently.

10) Edge.ModelToEquationSystem.MultiVariable (Upper Primary → Sec 1–2)

• ImpactScore: 16/20 (F4 D4 L4 R4)
• What breaks: multi-step comparison problems require systematic variable definitions + equation systems; students keep trying to “bar model everything” even when algebra is the intended corridor.

Failure Trace (3 collapse modes only)

1. Amplitude collapse: unfamiliar form → router fails → choice explosion → errors cascade
2. Slow attrition: micro-breaches accumulate undetected → confidence + speed collapse
3. Fast attrition: early wrong step → no debugger → whole question/paper sinks
   (These modes are consistent with syllabuses assessing reasoning and application, not merely answers.) (SEAB)

Sensors Pack (Minimum viable, transition-agnostic)

Use these at every transition slice:

• Rep-Switch Sensor: convert words ⇄ diagram ⇄ algebra ⇄ graph (single prompt, 3 minutes)
• Ledger Sensor: identify one hidden assumption (domain / reversibility / “what could be zero?”)
• Router Sensor: name the problem family + first method in 10 seconds
• Debugger Sensor: find first invalid line in a wrong solution in ≤45 seconds
• Load Sensor: count method switches per question (target trending ↓)

Almost-Code (A2 Report Spec)

ID: MathOS.FlightPath.K2_to_Uni.CF.MissingEdgesReport.v1.1
EVIDENCE_ANCHORS:
  PrimaryMathBigIdeas := MOE Primary Mathematics Syllabus (Updated Oct 2025)
  OLevel_EMath := SEAB 4052 (processes assessed incl. reasoning/application/models)
  OLevel_AMath := SEAB 4049 (algebraic manipulation + reasoning; transformation heavy)
  ALevel_H2Math := SEAB 9758 (assumed knowledge includes O-Level Additional Mathematics)
EDGE_IMPACT_SCORE:
  Dimensions := {Frequency F, DownstreamDependency D, LoadAmplifier L, Recoverability R} each in [0..5]
  ImpactScore := F + D + L + R  // max 20
TOP_EDGES:
  1 Edge.DiagramToSymbol.Compiler (PSLE->Sec1)
  2 Edge.LedgerUpgrade.EquivalenceDomainReversibility (E->A)
  3 Edge.Router.Debugger.UnderLoad (all transitions)
  4 Edge.ProportionalityToFunction.ObjectUpgrade (UpperPri->Sec)
  5 Edge.FunctionAsObject.Transformations (E->A->JC)
  6 Edge.NotationGrammar.LanguageMigration (Pri->Sec->A)
  7 Edge.AssumedKnowledge.BridgeToH2 (A->JC_H2)
  8 Edge.ProofCorridor.DefinitionLemmaTheorem (JC->Uni)
CHRONOFLIGHT_LOCK:
  For each Transition T:
    DriftRate[T] := rate(rep_fail + routing_error + ledger_breach) under_load
    RepairRate[T] := rate(detect + truncate + stitch + reattempt) under_load
    StabilityCondition := (RepairRate[T] >= DriftRate[T])

B4. PSLE → Sec 1 Cliff Pack (Immediate Teaching Tool)

Canonical ID: MathOS.FlightPath.PSLE_to_Sec1.CliffPack.Compiler.v1.1
Suggested slug: /psle-to-sec1-math-cliff-diagram-to-symbol/

AI Ingestion Lock

Goal: Install the missing edge Diagram→Symbol Compiler so students can translate Primary modelling into Sec 1 algebra without panic.

Cliff Symptoms (what you see)

• “Can do bar model, cannot ‘let x be…’”
• Writes random equations that don’t correspond to the story
• Treats “=” as “next step” not “same value”
• Solves, but cannot interpret the answer back to context

Primary Big Ideas explicitly highlight Diagrams/Equivalence/Notations as cross-cutting continuity anchors. (Ministry of Education)

5-Minute Diagnosis (Sensors)

Run these as quick micro-tests (no worksheets needed):

1. Bar → Equation (1-variable): convert a part-whole bar model into one equation
2. Comparison → Equation (difference): “A has 12 more than B; total 80” → define variables + equation system
3. Unitary → Relationship: “3 pens cost $6” → express cost as a function of number of pens
4. Meaning of ‘=’: is “x+3=10” a statement, a process, or both? student must say “same value”
5. Reverse check: student substitutes answer back into the story (must pass)
6. Router flash: student names family: part-whole / comparison / rate / percent

Fail pattern tells you exactly what’s missing:

• fails 1–2 = compiler missing
• fails 3 = proportionality-to-function edge missing
• fails 4–5 = equivalence ledger missing at basic level

ILT Modules (Operator-Side Teaching Engine)

ILT-C1: “=” Visibility Module
Teacher forces every line to include a spoken invariant: “left and right are the same value.”

ILT-C2: Variable Meaning Lock
Every equation begins with:

• “Let _ represent _”
• “Units: _”
• “What stays invariant: total / difference / ratio / rate”

ILT-C3: Compile Steps (4-step compiler)

1. Name quantities (entities + units)
2. Bind relationships (total / difference / ratio / rate)
3. Choose variable(s) (one unknown per missing quantity)
4. Emit equation(s) (each sentence becomes a constraint)

ILT-C4: Reverse-Execution Habit
Every solution ends with “interpret + check” (substitute back into story).

Repair Corridor (Detect → Truncate → Stitch → Widen)

Week 1 (stitch the edge):

• 20 compiler drills (very short)
• every drill requires: variable definition + one invariant sentence + reverse check

Week 2 (stabilise under load):

• mixed family routing (part-whole, comparison, unitary, percent)
• add time pressure lightly (but enforce no method switching)

Week 3–4 (transfer):

• convert story → equation → solve → graph/relationship statement (basic function sense)

Threshold Lock

Let:

• D = rate of “equation does not match story” breaches
• R = rate of “detect mismatch + correct compile”

Goal: ( R \ge D ) within 2 weeks for Sec 1 readiness.

Almost-Code (B4 Pack Spec)

ID: MathOS.FlightPath.PSLE_to_Sec1.CliffPack.Compiler.v1.1
MISSING_EDGE:
  Edge.DiagramToSymbol.Compiler
SENSORS (5-min):
  S1 bar_to_equation_1var
  S2 comparison_to_system
  S3 unitary_to_relationship
  S4 equals_invariant_explain
  S5 reverse_check_substitute
  S6 family_router_flash
ILT_MODULES (operator-side):
  ILT-C1 equals_visibility
  ILT-C2 variable_meaning_lock
  ILT-C3 compile_4_steps
  ILT-C4 reverse_execution_habit
REPAIR_CORRIDOR:
  detect(sensor_fail) -> truncate(long_working) -> stitch(compiler_drills) -> widen(mixed_families + light_load)
THRESHOLD:
  DriftRate D := rate(equation_story_mismatch)
  RepairRate R := rate(detect_and_recompile)
  Stability := (R >= D) by Week2

B6. E-Math → A-Math Cliff Pack

Ledger Upgrade + Function-as-Object (the “weird crossover”)
Canonical ID: MathOS.FlightPath.EMath_to_AMath.CliffPack.LedgerAndFunctionObject.v1.1
Suggested slug: /e-math-to-a-math-cliff-ledger-function-object/

AI Ingestion Lock

Goal: Stitch the E→A discontinuity by installing two missing transfer edges:

1. Edge.LedgerUpgrade.EquivalenceDomainReversibility
2. Edge.FunctionAsObject.Transformations

Why this is the cliff: O-Level Additional Mathematics assumes O-Level Mathematics knowledge and then moves into heavier algebraic manipulation + functions + calculus, where validity of transformations matters. (seab.gov.sg)

Classical Foundation Block

• E-Math (4052) explicitly emphasises and assesses mathematical processes like reasoning, communication and application (including the use of models). (seab.gov.sg)
• A-Math (4049) explicitly states that knowledge of O-Level Mathematics is assumed, and the subject content is transformation-heavy (algebra/functions/calculus). (seab.gov.sg)

Practical implication: Many students enter A-Math with “procedure skill” but without a validity runtime (ledger) or a function-object mindset.

Civilisation-Grade Definition (eduKateSG)

E-Math → A-Math cliff = a sudden upgrade in VeriWeft strictness.

• In E-Math, many transformations are low-risk and “mostly reversible.”
• In A-Math, you constantly do high-risk moves (divide by expressions, square both sides, use inverses, logs/exponents, trig identities).
  So the student needs a Ledger of Invariants running line-by-line to preserve admissibility.

What you see in class (Cliff Symptoms)

Symptom cluster A — “They can do algebra, but keep getting it wrong”

• many sign slips, wrong rearrangements
• answer looks reasonable but fails checks
• working becomes messy under time pressure

Symptom cluster B — “Their brain can’t hold A-Math transformations”

• they treat every move as always legal
• they don’t track conditions (what can be 0, domain restrictions, extraneous roots)
• they can’t explain why a step is valid

Symptom cluster C — “Functions don’t feel like objects”

• f(x) treated like decoration
• graph transformations memorised without meaning
• weak in inverse/composition/“what does this do to x?”

Missing Edge 1: Ledger Upgrade (Validity Control)

What the Ledger must cover (minimum viable)

Ledger items students must be able to state + apply:

1. Equivalence: “Did I preserve the same solution set?”
2. Domain: “What values are allowed at this step?”
3. Reversibility: “Is this move reversible? If not, what extra checks?”
4. Extraneous roots: “Did I introduce solutions by squaring / multiplying by expressions?”
5. Zero-division hazard: “Did I divide by something that could be 0?”
6. Inverse conditions: “Is inverse valid here (one-to-one / restricted domain)?”

Interpretation: A-Math is not “harder algebra.” It is algebra with legality.

Missing Edge 2: Function-as-Object Upgrade

What changes from E-Math to A-Math

E-Math often treats functions as:

• equations to solve
• graphs to read

A-Math/JC treats functions as:

• objects you transform (shift/scale/compose/invert)
• inputs → outputs machines
• operators (differentiate/integrate as actions on a function)

This matters because H2 Math explicitly assumes O-Level Additional Mathematics knowledge, i.e., the function-object corridor is a dependency edge into JC. (seab.gov.sg)

5-Minute Diagnosis (Sensors)

Run these micro-tests. They pinpoint which edge is missing.

Sensor set L (Ledger)

L1 — Zero-division check (30s):
“Is it always valid to divide both sides by (x−3)?” Student must answer: “only if x≠3,” and state what to do.

L2 — Squaring check (45s):
Given a line where squaring was used, student must say: “may introduce extraneous roots → must substitute back.”

L3 — Domain check (45s):
Log/√ expression: student must state domain before solving.

L4 — Equivalence check (45s):
Give a wrong worked solution; student must identify the first invalid step.

Sensor set F (Function-object)

F1 — Meaning of f(x+a) (30s):
Student explains “input shift” and predicts graph shift direction.

F2 — Inverse validity (60s):
Given a non one-to-one graph, student says: “inverse not a function unless restrict domain.”

F3 — Composition sense (60s):
Explain what (f∘g)(x) means in words (machine-chaining).

Sensor set LD (Load discipline)

LD1 — Method switching count:
Student solves one A-Math question; count method switches. Target: ≤1 switch.

How to read the results

• Fail L1/L2/L3/L4 ⇒ Ledger missing
• Fail F1/F2/F3 ⇒ Function-object missing
• Pass both but still collapses in tests ⇒ Load budget + router/debugger under load missing

ILT Modules (Operator-Side Teaching Engine)

These are teaching modules (not “learner traits”). Install them explicitly.

ILT-L1: Ledger Speech Protocol (make invariants visible)

Every line must be either:

• E-move: equivalence-preserving and reversible
• C-move: conditional / non-reversible → requires a check

Student says (out loud at first):

• “This move is conditional because …”
• “So I must check …”

ILT-L2: The 3-Checkpoint Working Style (truncate drift early)

Checkpoints every 3–5 lines:

1. Domain checkpoint (what cannot be 0 / allowed inputs)
2. Equivalence checkpoint (same solution set?)
3. Substitution checkpoint (verify candidate roots)

ILT-F1: Function Machine Protocol

Force every function step into:

• input → transform → output
• describe transformation in words
• then write algebra

ILT-LD1: Operator Corridor Method Set

Pick a small safe set per family (example):

• quadratic: factorise / complete square (but ledgered)
• trig equation: standard identities + restriction checks
• logs: domain first, then isolate log, then exponentiate
  No “free exploration” until stability is proven.

Repair Corridor (Detect → Truncate → Stitch → Widen)

Week 0 (baseline)

Run sensors L1–L4 + F1–F3 + LD1 and record:

• Ledger breach rate (IBR-L)
• Function misread rate (FMR)
• Method switch count (MSC)

Phase 1 (Weeks 1–2): Install Ledger

• daily 10–15 min “Ledger drills” (micro-items)
• every solution must include domain line + validity note + final check

Success condition: student can spot first invalid step within 45s on common breach types.

Phase 2 (Weeks 3–4): Install Function-as-Object

• function transformation drills in words → graph sketch → algebra
• inverse/composition explained as machines

Success condition: student can predict transformation direction/shape before doing algebra.

Phase 3 (Weeks 5–6): Stabilise under load (Operator corridor)

• mixed A-Math families with strict method set
• enforce checkpoints, ban method switching unless justified by router

Success condition: MSC trending ↓ and accuracy trending ↑ under timed sets.

Threshold Inequality Lock

Define:

• DriftRate D: rate of ledger breaches + function misreads + wrong routing under timed work
• RepairRate R: rate of detecting + correcting + re-stitching within the same question

A-Math stability condition:
[
R \ge D \quad \text{under test load}
]

When (D>R), the student experiences the “cliff” (panic + cascading errors).

Failure Trace (3 modes only)

1. Amplitude collapse: one conditional move breaks (divide/square/log) → wrong branch → whole question sinks
2. Slow attrition: many small breaches accumulate; student becomes slow and unsure
3. Fast attrition: early wrong step + no debugger → builds on wrong state → paper failure

ChronoFlight Slice (E→A transition)

• RouteState (typical): Drift → Descent (if ledger absent), Corrective Turn (once ledger installed)
• Primary Drift: legality blindness (invalid moves not detected)
• Primary Repair: checkpoint ledger + conditional move checks
• Buffer status: low (working memory consumed by choice + uncertainty)
• Next-slice risk: A→JC assumed knowledge dependency becomes fatal if this slice is not repaired (seab.gov.sg)
• Action: install Ledger first, then Function-object, then load stabilisation

Almost-Code (Machine-Readable)

ID: MathOS.FlightPath.EMath_to_AMath.CliffPack.LedgerAndFunctionObject.v1.1
EVIDENCE_ANCHORS:
  EMath_4052 := "processes such as reasoning, communication and application (including use of models) are emphasised and assessed"
  AMath_4049 := "knowledge of O-Level Mathematics assumed" + transformation-heavy content
  H2_9758 := "assumed knowledge for O-Level Additional Mathematics appended" (dependency edge)
MISSING_EDGES:
  Edge.LedgerUpgrade.EquivalenceDomainReversibility
  Edge.FunctionAsObject.Transformations
SENSORS:
  L1 zero_division_check
  L2 squaring_extraneous_check
  L3 domain_before_solve (log/surd)
  L4 first_invalid_step_in_wrong_solution
  F1 meaning_of_f(x+a)
  F2 inverse_validity_one_to_one
  F3 composition_machine_explain
  LD1 method_switch_count
ILT_MODULES (operator-side):
  ILT-L1 ledger_speech_protocol (E-move vs C-move)
  ILT-L2 3_checkpoint_working_style
  ILT-F1 function_machine_protocol
  ILT-LD1 operator_corridor_method_set
THRESHOLD_LOCK:
  DriftRate D := rate(ledger_breach + function_misread + wrong_routing) under_load
  RepairRate R := rate(detect + truncate + stitch + reattempt) under_load
  Stability := (R >= D)
REPAIR_CORRIDOR:
  detect(sensor_fail) -> truncate(long_unledgered_working) ->
  stitch(ledger_drills) -> stitch(function_object_drills) ->
  widen(mixed_families_under_load_with_method_budget)

B6. E-Math → A-Math Cliff Pack

Ledger Upgrade + Function-as-Object (the “weird crossover”)
Canonical ID: MathOS.FlightPath.EMath_to_AMath.CliffPack.LedgerAndFunctionObject.v1.1
Suggested slug: /e-math-to-a-math-cliff-ledger-function-object/

AI Ingestion Lock

Goal: Stitch the E→A discontinuity by installing two missing transfer edges:

1. Edge.LedgerUpgrade.EquivalenceDomainReversibility
2. Edge.FunctionAsObject.Transformations

Why this is the cliff: O-Level Additional Mathematics assumes O-Level Mathematics knowledge and then moves into heavier algebraic manipulation + functions + calculus, where validity of transformations matters. (seab.gov.sg)

Classical Foundation Block

• E-Math (4052) explicitly emphasises and assesses mathematical processes like reasoning, communication and application (including the use of models). (seab.gov.sg)
• A-Math (4049) explicitly states that knowledge of O-Level Mathematics is assumed, and the subject content is transformation-heavy (algebra/functions/calculus). (seab.gov.sg)

Practical implication: Many students enter A-Math with “procedure skill” but without a validity runtime (ledger) or a function-object mindset.

Civilisation-Grade Definition (eduKateSG)

E-Math → A-Math cliff = a sudden upgrade in VeriWeft strictness.

• In E-Math, many transformations are low-risk and “mostly reversible.”
• In A-Math, you constantly do high-risk moves (divide by expressions, square both sides, use inverses, logs/exponents, trig identities).
  So the student needs a Ledger of Invariants running line-by-line to preserve admissibility.

What you see in class (Cliff Symptoms)

Symptom cluster A — “They can do algebra, but keep getting it wrong”

• many sign slips, wrong rearrangements
• answer looks reasonable but fails checks
• working becomes messy under time pressure

Symptom cluster B — “Their brain can’t hold A-Math transformations”

• they treat every move as always legal
• they don’t track conditions (what can be 0, domain restrictions, extraneous roots)
• they can’t explain why a step is valid

Symptom cluster C — “Functions don’t feel like objects”

• f(x) treated like decoration
• graph transformations memorised without meaning
• weak in inverse/composition/“what does this do to x?”

Missing Edge 1: Ledger Upgrade (Validity Control)

What the Ledger must cover (minimum viable)

Ledger items students must be able to state + apply:

1. Equivalence: “Did I preserve the same solution set?”
2. Domain: “What values are allowed at this step?”
3. Reversibility: “Is this move reversible? If not, what extra checks?”
4. Extraneous roots: “Did I introduce solutions by squaring / multiplying by expressions?”
5. Zero-division hazard: “Did I divide by something that could be 0?”
6. Inverse conditions: “Is inverse valid here (one-to-one / restricted domain)?”

Interpretation: A-Math is not “harder algebra.” It is algebra with legality.

Missing Edge 2: Function-as-Object Upgrade

What changes from E-Math to A-Math

E-Math often treats functions as:

• equations to solve
• graphs to read

A-Math/JC treats functions as:

• objects you transform (shift/scale/compose/invert)
• inputs → outputs machines
• operators (differentiate/integrate as actions on a function)

This matters because H2 Math explicitly assumes O-Level Additional Mathematics knowledge, i.e., the function-object corridor is a dependency edge into JC. (seab.gov.sg)

5-Minute Diagnosis (Sensors)

Run these micro-tests. They pinpoint which edge is missing.

Sensor set L (Ledger)

L1 — Zero-division check (30s):
“Is it always valid to divide both sides by (x−3)?” Student must answer: “only if x≠3,” and state what to do.

L2 — Squaring check (45s):
Given a line where squaring was used, student must say: “may introduce extraneous roots → must substitute back.”

L3 — Domain check (45s):
Log/√ expression: student must state domain before solving.

L4 — Equivalence check (45s):
Give a wrong worked solution; student must identify the first invalid step.

Sensor set F (Function-object)

F1 — Meaning of f(x+a) (30s):
Student explains “input shift” and predicts graph shift direction.

F2 — Inverse validity (60s):
Given a non one-to-one graph, student says: “inverse not a function unless restrict domain.”

F3 — Composition sense (60s):
Explain what (f∘g)(x) means in words (machine-chaining).

Sensor set LD (Load discipline)

LD1 — Method switching count:
Student solves one A-Math question; count method switches. Target: ≤1 switch.

How to read the results

• Fail L1/L2/L3/L4 ⇒ Ledger missing
• Fail F1/F2/F3 ⇒ Function-object missing
• Pass both but still collapses in tests ⇒ Load budget + router/debugger under load missing

ILT Modules (Operator-Side Teaching Engine)

These are teaching modules (not “learner traits”). Install them explicitly.

ILT-L1: Ledger Speech Protocol (make invariants visible)

Every line must be either:

• E-move: equivalence-preserving and reversible
• C-move: conditional / non-reversible → requires a check

Student says (out loud at first):

• “This move is conditional because …”
• “So I must check …”

ILT-L2: The 3-Checkpoint Working Style (truncate drift early)

Checkpoints every 3–5 lines:

1. Domain checkpoint (what cannot be 0 / allowed inputs)
2. Equivalence checkpoint (same solution set?)
3. Substitution checkpoint (verify candidate roots)

ILT-F1: Function Machine Protocol

Force every function step into:

• input → transform → output
• describe transformation in words
• then write algebra

ILT-LD1: Operator Corridor Method Set

Pick a small safe set per family (example):

• quadratic: factorise / complete square (but ledgered)
• trig equation: standard identities + restriction checks
• logs: domain first, then isolate log, then exponentiate
  No “free exploration” until stability is proven.

Repair Corridor (Detect → Truncate → Stitch → Widen)

Week 0 (baseline)

Run sensors L1–L4 + F1–F3 + LD1 and record:

• Ledger breach rate (IBR-L)
• Function misread rate (FMR)
• Method switch count (MSC)

Phase 1 (Weeks 1–2): Install Ledger

• daily 10–15 min “Ledger drills” (micro-items)
• every solution must include domain line + validity note + final check

Success condition: student can spot first invalid step within 45s on common breach types.

Phase 2 (Weeks 3–4): Install Function-as-Object

• function transformation drills in words → graph sketch → algebra
• inverse/composition explained as machines

Success condition: student can predict transformation direction/shape before doing algebra.

Phase 3 (Weeks 5–6): Stabilise under load (Operator corridor)

• mixed A-Math families with strict method set
• enforce checkpoints, ban method switching unless justified by router

Success condition: MSC trending ↓ and accuracy trending ↑ under timed sets.

Threshold Inequality Lock

Define:

• DriftRate D: rate of ledger breaches + function misreads + wrong routing under timed work
• RepairRate R: rate of detecting + correcting + re-stitching within the same question

A-Math stability condition:
[
R \ge D \quad \text{under test load}
]

When (D>R), the student experiences the “cliff” (panic + cascading errors).

Failure Trace (3 modes only)

1. Amplitude collapse: one conditional move breaks (divide/square/log) → wrong branch → whole question sinks
2. Slow attrition: many small breaches accumulate; student becomes slow and unsure
3. Fast attrition: early wrong step + no debugger → builds on wrong state → paper failure

ChronoFlight Slice (E→A transition)

• RouteState (typical): Drift → Descent (if ledger absent), Corrective Turn (once ledger installed)
• Primary Drift: legality blindness (invalid moves not detected)
• Primary Repair: checkpoint ledger + conditional move checks
• Buffer status: low (working memory consumed by choice + uncertainty)
• Next-slice risk: A→JC assumed knowledge dependency becomes fatal if this slice is not repaired (seab.gov.sg)
• Action: install Ledger first, then Function-object, then load stabilisation

Almost-Code (Machine-Readable)

ID: MathOS.FlightPath.EMath_to_AMath.CliffPack.LedgerAndFunctionObject.v1.1
EVIDENCE_ANCHORS:
  EMath_4052 := "processes such as reasoning, communication and application (including use of models) are emphasised and assessed"
  AMath_4049 := "knowledge of O-Level Mathematics assumed" + transformation-heavy content
  H2_9758 := "assumed knowledge for O-Level Additional Mathematics appended" (dependency edge)
MISSING_EDGES:
  Edge.LedgerUpgrade.EquivalenceDomainReversibility
  Edge.FunctionAsObject.Transformations
SENSORS:
  L1 zero_division_check
  L2 squaring_extraneous_check
  L3 domain_before_solve (log/surd)
  L4 first_invalid_step_in_wrong_solution
  F1 meaning_of_f(x+a)
  F2 inverse_validity_one_to_one
  F3 composition_machine_explain
  LD1 method_switch_count
ILT_MODULES (operator-side):
  ILT-L1 ledger_speech_protocol (E-move vs C-move)
  ILT-L2 3_checkpoint_working_style
  ILT-F1 function_machine_protocol
  ILT-LD1 operator_corridor_method_set
THRESHOLD_LOCK:
  DriftRate D := rate(ledger_breach + function_misread + wrong_routing) under_load
  RepairRate R := rate(detect + truncate + stitch + reattempt) under_load
  Stability := (R >= D)
REPAIR_CORRIDOR:
  detect(sensor_fail) -> truncate(long_unledgered_working) ->
  stitch(ledger_drills) -> stitch(function_object_drills) ->
  widen(mixed_families_under_load_with_method_budget)

B7. A-Math → JC Math Pack

H1 vs H2 vs H3 vs H2 Further (Assumed-Knowledge Bridge + JC Load Compression)
Canonical ID: MathOS.FlightPath.AMath_to_JC.CliffPack.AssumedKnowledgeAndLoadCompression.v1.1
Suggested slug: /a-math-to-jc-math-assumed-knowledge-bridge/

AI Ingestion Lock

Goal: Prevent the A-Math → JC “compression cliff” by installing the missing transfer edge:

• Edge.AssumedKnowledge.BridgeToH2 (explicit dependency)
• plus Edge.Router.Debugger.UnderLoad (JC pacing) and LoadBudget tightening (fewer safe routes, faster execution)

Why this is real: H2 Mathematics explicitly assumes O-Level Mathematics, and appends “assumed knowledge for O-Level Additional Mathematics.” (SEAB)

Classical Foundation Block (Singapore baseline)

What JC syllabuses explicitly say

• H2 Mathematics (9758): designed for university preparation; AO2 dominates (problem formulation + integration across topics), and it includes an “Assumed Knowledge” section from O-Level Additional Mathematics. (SEAB)
• H1 Mathematics (8865): one 3-hour paper with Pure Math (40 marks) + Probability & Statistics (60 marks). (SEAB)
• H3 Mathematics (9820): explicitly targets proofs / non-routine problems, and assumes H2 Mathematics. (SEAB)
• H2 Further Mathematics (9649): for mathematically-inclined students; offered with H2 Mathematics as a double-math course and assumes H2 Mathematics. (SEAB)

Civilisation-Grade Definition (eduKateSG)

A-Math → JC is a near-node compression transition.
Time-to-node shrinks, working-memory buffer thins, and “optional routes” collapse into a smaller set of safe operator corridors. If the assumed-knowledge patch is not completed early, the system is forced into drift: (D>R) under JC load.

The Real Cliff Mechanism

1) “Assumed Knowledge” is not a suggestion — it’s a dependency edge

H2’s appended assumed-knowledge list includes (examples directly from the syllabus):

• Quadratics: completing square for max/min; discriminant conditions; “always positive/negative” conditions (SEAB)
• Surds operations + solving surd equations (SEAB)
• Polynomials + partial fractions (with specified denominator types) (SEAB)
• Exponential/log functions: laws, graphs, change of base, basic solving (SEAB)
• Trig identities/equations and forms like (a\cos\theta+b\sin\theta\to R\sin(\theta\pm\alpha)) (SEAB)
• Calculus: derivative as gradient/rate, chain rule, product/quotient, stationary points, integration as reverse diff + standard integrals (SEAB)

If these are weak, JC isn’t “harder”—it becomes non-runnable.

2) JC load demands faster routing + faster debugging

H2 AOs explicitly include selecting strategies, translating between equivalent forms, integrating concepts, and justifying choices—i.e., routing + reasoning, not just technique. (SEAB)

3) Calculator doesn’t remove the need for a runtime

H2 expects graphing calculator access but still requires supported working when asked; GC has limitations. (SEAB)

Route Router (H1 / H2 / H3 / Further) — eduKateSG “Choice Budget”

This is a capability router, not “which JC you like”.

Track A — H1 corridor

• Build stable Pure-Math basics + Stats execution under one-paper load. (SEAB)
• Still needs Router/Debugger, but assumed A-Math dependency is not stated as strongly as H2’s appended A-Math assumed-knowledge section (H2 explicitly appends it). (SEAB)

Track B — H2 corridor

• Mandatory: Assumed-Knowledge Bridge (from O-Level A-Math list). (SEAB)
• Must handle AO2-heavy integration and application contexts. (SEAB)

Track C — H2 + Further / H3 corridor

• H3: proof + non-routine + mathematical text response; assumes H2. (SEAB)
• Further Math: double-math with H2; assumes H2; aimed at deeper math toolsets. (SEAB)

10-Minute Diagnosis (Sensors)

Run these in Week 0 of JC to locate the missing edge fast.

AK Sensors (from H2 “Assumed Knowledge” list)

1. Quadratic max/min via completing square (not differentiation) (SEAB)
2. Discriminant conditions (two real / equal / no real roots) (SEAB)
3. Surds: rationalise + solve a surd equation (SEAB)
4. Partial fractions on a permitted denominator type (SEAB)
5. Logs: change of base + solve a simple log equation (domain stated first) (SEAB)
6. Trig identity/equation + (a\cos\theta+b\sin\theta) rewrite (SEAB)
7. Chain rule + product/quotient rule execution (SEAB)
8. Stationary point classification + second derivative test usage (SEAB)
9. Basic integration set (poly/exp/trig) + “reverse diff” meaning (SEAB)

Load Sensors (JC compression)

10. First-wrong-line debugger (≤45s) on a wrong worked solution
11. Method-switch count per question (target ≤1 switch)
12. Router flash (10s): name family + first method

Interpretation

• AK fails ⇒ Edge.AssumedKnowledge.BridgeToH2 missing
• Debug slow ⇒ Edge.Router.Debugger.UnderLoad missing
• Too many method switches ⇒ LoadBudget missing

ILT Modules (Operator-Side Teaching Engine)

ILT-AK1: Assumed-Knowledge Patchboard (visible checklist)

Make the H2 assumed-knowledge list a student-visible patchboard (AK-A1…AK-C7). (SEAB)
Student tracks: known / shaky / broken.

ILT-AK2: Ledgered Refresh (validity rules attached)

Every AK item is taught with a ledger note:

• domain restrictions (logs/surds)
• reversible vs conditional moves (squaring/dividing)
• extraneous root checks

ILT-JC1: Mixed-Topic Router Drills (AO2 discipline)

H2 AO2 includes selecting strategy, translating equivalent forms, integrating concepts. (SEAB)
So train 2-minute “route selection” drills: family → method → checkpoint plan.

ILT-GC1: GC Verification Discipline

GC access is assumed, but unsupported answers may be restricted; GC has limitations. (SEAB)
Install a protocol: GC = verify + sketch + sanity check, not “replace working”.

Repair Corridor (Detect → Truncate → Stitch → Widen)

Week 0: Baseline scan

Run Sensors 1–12. Produce:

• AK-Gap Index (which AK items are broken)
• Debug Latency
• Method Switch Count

Phase 1 (Weeks 1–2): AK Bridge Sprint

• Daily: 20–30 min AK patch drills (ledgered, checked)
• Goal: close the top 3 AK holes first (usually logs/trig/calculus basics)

Phase 2 (Weeks 3–4): JC Router + Debugger under load

• 3× per week: mixed-topic sets with forced “router flash + checkpoint plan”
• Debugger drill: find first invalid step ≤45s

Phase 3 (Weeks 5–6): AO2 integration + application question readiness

H2 includes integrated questions and application contexts. (SEAB)
Train “integrate topics” tasks (functions + calculus + stats reasoning) with minimal switching.

Threshold Inequality Lock (JC stability)

Let:

• D = DriftRate (AK gaps + routing errors + validity breaches) under timed work
• R = RepairRate (detect + correct + re-stitch) under timed work

JC corridor stability condition:
[
R \ge D \quad \text{under JC load}
]

Failure Trace (3 collapse modes only)

1. Amplitude collapse: one AK hole (e.g., logs/trig/calculus rule) → cannot proceed → panic spiral
2. Slow attrition: many small AK + ledger breaches → constant remediation → time debt accumulates
3. Fast attrition: early wrong step + slow debug → whole question set collapses

ChronoFlight Slice (A-Math → JC)

• RouteState: Drift risk is highest in JC1 Term 1 (compression begins immediately)
• Primary hazard: assumed knowledge mismatch + reduced buffer
• Primary repair: AK bridge sprint + router/debugger instrumentation
• Next node: H2/H3/Further become “single corridor” only if the earlier gate is passed (H3/Further explicitly assume H2). (SEAB)

Almost-Code (Machine-Readable)

ID: MathOS.FlightPath.AMath_to_JC.CliffPack.AssumedKnowledgeAndLoadCompression.v1.1
EVIDENCE_ANCHORS:
  H2_9758 := "Assumed knowledge for O-Level Additional Mathematics appended" + AO2-heavy + GC expected
  H1_8865 := "One 3-hour paper; Pure 40 + Stats 60"
  H3_9820 := "Assumes H2; proof + non-routine + math text"
  FM_9649 := "Double-math with H2; assumes H2"
MISSING_EDGES:
  Edge.AssumedKnowledge.BridgeToH2
  Edge.Router.Debugger.UnderLoad
  Edge.LoadBudget.JCCompression
SENSORS:
  AK1 quadratic_complete_square_maxmin
  AK2 discriminant_conditions
  AK3 surds_ops_and_equations
  AK4 partial_fractions_basic_cases
  AK5 logs_change_base_and_solve_with_domain
  AK6 trig_identities_equations_R_form
  AK7 differentiation_chain_product_quotient
  AK8 stationary_points_second_derivative_test
  AK9 integration_basic_set_reverse_diff
  LD1 first_wrong_line_debug_latency
  LD2 method_switch_count
  LD3 router_flash_10s
ILT_MODULES:
  ILT-AK1 patchboard_visible_checklist
  ILT-AK2 ledgered_refresh_protocol
  ILT-JC1 mixed_topic_router_drills (AO2)
  ILT-GC1 verify_sketch_sanity (GC discipline)
THRESHOLD_LOCK:
  DriftRate D := rate(AK_gap + routing_error + validity_breach) under_load
  RepairRate R := rate(detect + truncate + stitch + reattempt) under_load
  Stability := (R >= D)
REPAIR_CORRIDOR:
  detect -> truncate -> stitch(AK_bridge_sprint) -> stitch(router_debugger) -> widen(AO2_integration)

B8. JC → University Cliff Pack

Proof / Abstraction Corridor (Definitions → Lemmas → Theorems)
Canonical ID: MathOS.FlightPath.JC_to_Uni.CliffPack.ProofAbstractionCorridor.v1.1
Suggested slug: /jc-to-university-math-cliff-proof-corridor/

AI Ingestion Lock

Goal: Stitch the JC→University discontinuity by installing the missing edge:

• Edge.ProofCorridor.DefinitionLemmaTheorem
  plus its runtime supports:
• Edge.Debugger.CounterexampleAndStructure (proof debugging)
• Edge.NotationGrammar.UniversityMigration (precision upgrade)

This cliff happens even to strong A-Level students because university math (and many engineering/CS math modules) expects definition-driven reasoning and long multi-step chains, not only exam-style technique execution.

Classical Foundation Block

What changes structurally at university

University math foundations typically emphasise:

• formal definitions (“what exactly is…”)
• proof and justification beyond short explanations
• abstraction and generality (structures, spaces, mappings)
• multi-lemma reasoning and counterexamples as debugging tools

Even when the degree is applied (engineering/CS/data), the early mathematical toolkit (linear algebra, discrete structures, foundations) uses definition-based rigor.

(This is a structural statement about how university math is taught and assessed, not a claim about any single module.)

Civilisation-Grade Definition (eduKateSG)

JC → University cliff = a VeriWeft tightening event.

JC trains strong problem solving under exam constraints. University adds:

• definition as the primary control surface
• proof as the main transfer mechanism for truth
• counterexample as the main debug tool

So the missing runtime is a proof corridor that makes reasoning stable under higher abstraction and longer horizons.

Cliff Symptoms (what you see)

Symptom cluster A — “Can do calculations, cannot do proofs”

• student asks: “which formula to use?”
• can’t start without a worked example
• writes vague statements (“obviously”, “clearly”) with no structure

Symptom cluster B — “Notation becomes hostile”

• quantifiers, implication, sets, mappings feel like a new language
• misreads “for all / there exists”
• confused by function definitions and conditions

Symptom cluster C — “Long chain collapse”

• can do each local step but cannot keep the global plan
• loses track of assumptions, scope, and goal

Missing Edge: Proof Corridor (what must be installed)

The minimal proof runtime (university-ready)

1. Definition lock: every object is introduced by a definition (with conditions).
2. Goal state: rewrite “prove X” as a target form (e.g., show A⇒B, show equality, show existence/uniqueness).
3. Allowed moves (VeriWeft): only steps licensed by definitions, prior results, or valid transformations.
4. Lemma strategy: break into smaller claims with clear dependencies.
5. Counterexample debug: if a claim might be false, try to break it fast.
6. Quantifier discipline: track ∀ / ∃, domains, and scope.

In short: university math is “A-Math ledger” upgraded into definition-driven validity.

10-Minute Diagnosis (Sensors)

Run these with any JC student to locate the proof-corridor gap.

Proof sensors (P)

P1 — Rewrite the goal (60s):
Given “Prove: If n is even then n² is even.” Student must rewrite as: “Assume n=2k; show n²=2m.”

P2 — Quantifier reading (60s):
Interpret: “For all real x, there exists real y such that …” Student explains what changes and what is fixed.

P3 — Counterexample instinct (60s):
Given a claim like “If a·b=0 then a=0 and b=0”, student must find counterexample quickly.

P4 — Structure proof outline (2 min):
Outline steps (not full proof) for a simple set/inequality statement.

Notation sensors (N)

N1 — Function definition reading (60s):
Given f: ℝ→ℝ, f(x)=…, student states domain, codomain, and what “well-defined” means informally.

N2 — Implication / converse (60s):
Distinguish A⇒B vs B⇒A with example.

Chain sensors (C)

C1 — Lemma chain planning (2 min):
Given a multi-step statement, student proposes 2–3 lemmas.

Interpretation

• Fail P1/P4 ⇒ “start engine” missing (goal rewrite + outline)
• Fail P2/N2 ⇒ language/logic grammar missing
• Fail P3 ⇒ debugger missing (counterexample tool)
• Fail C1 ⇒ chain-planning missing (lemma corridor)

ILT Modules (Operator-Side Teaching Engine)

ILT-P1: Proof Template Kit (3 canonical templates)

1. Direct proof: assume premises → transform → reach conclusion
2. Contrapositive: prove ¬B⇒¬A when easier
3. Contradiction: assume ¬(claim) → derive impossibility

ILT-P2: Definition First Protocol

Every new object triggers:

• definition
• domain/codomain/scope
• one example + one non-example (counterexample training)

ILT-D1: Counterexample Debugger

Teach counterexample as the default “unit test”:

• try n=0,1,2,−1
• try boundary cases
• try simple structured cases (a=0, b≠0)

ILT-C1: Lemma Ladder

Train students to split proofs into:

• Lemma 1: reduce to known form
• Lemma 2: apply known theorem/definition
• Lemma 3: conclude

Repair Corridor (Detect → Truncate → Stitch → Widen)

Phase 0 (baseline)

Run sensors P/N/C to produce:

• Proof Start Rate (PSR): can they start correctly?
• Counterexample Rate (CER): can they break false claims?
• Quantifier Accuracy (QA): correct reading of ∀/∃

Phase 1 (Weeks 1–2): Proof start engine

• daily: 10–15 min goal-rewrite drills (P1)
• outline-only practice (P4) before full proofs

Success condition: PSR ≥ 80% on simple statements.

Phase 2 (Weeks 3–4): Definition discipline + counterexample debugger

• every definition: example + non-example
• every “maybe true” claim: attempt counterexample first

Success condition: CER ≥ 70% for common false patterns.

Phase 3 (Weeks 5–6): Lemma chains + longer horizon

• write 2–3 lemma plans (C1), then fill in proofs
• increase length gradually

Success condition: can sustain a 10–15 line proof without losing scope.

Threshold Inequality Lock (University stability)

Define:

• D = DriftRate (scope slips + invalid steps + quantifier errors + “handwave gaps”) per proof
• R = RepairRate (detect gap + patch with definition/lemma/counterexample) per proof

University proof corridor condition:
[
R \ge D \quad \text{for multi-step reasoning}
]

Failure Trace (3 collapse modes only)

1. Amplitude collapse: cannot start proof → panic → no progress
2. Slow attrition: repeated scope/logic slips → constant correction → avoidance
3. Fast attrition: one wrong assumption early → everything built on wrong base

ChronoFlight Slice (JC → Uni)

• RouteState: often “Stable cruise” in calculations, but “Drift” in proof corridor
• Primary drift: lack of definition-driven control + no counterexample debugger
• Primary repair: proof templates + definition-first + lemma ladder
• Next-slice risk: higher-level modules (analysis/LA/discrete) become non-runnable without proof corridor

Almost-Code (Machine-Readable)

ID: MathOS.FlightPath.JC_to_Uni.CliffPack.ProofAbstractionCorridor.v1.1
MISSING_EDGES:
  Edge.ProofCorridor.DefinitionLemmaTheorem
  Edge.Debugger.CounterexampleAndStructure
  Edge.NotationGrammar.UniversityMigration
SENSORS:
  P1 goal_rewrite_even_square
  P2 quantifier_reading_forall_exists
  P3 counterexample_instinct_zero_product
  P4 proof_outline_simple_statement
  N1 function_definition_domain_codomain
  N2 implication_vs_converse
  C1 lemma_chain_planning
ILT_MODULES:
  ILT-P1 proof_template_kit (direct/contra/contradiction)
  ILT-P2 definition_first_protocol (example + nonexample)
  ILT-D1 counterexample_debugger (unit tests + boundary cases)
  ILT-C1 lemma_ladder (2-3 lemma plan)
THRESHOLD_LOCK:
  DriftRate D := rate(scope_slip + invalid_move + quantifier_error + handwave_gap)
  RepairRate R := rate(detect_gap + patch_with_definition_or_lemma_or_counterexample)
  Stability := (R >= D) for multi-step reasoning
REPAIR_CORRIDOR:
  detect(sensor_fail) -> truncate(handwave) -> stitch(proof_start_engine) ->
  stitch(definition+counterexample) -> widen(lemma_chains_longer_proofs)

C1. ChronoHelmAI.MathFlight — Minimal Panel (One-Page Diagnostic Board)

Canonical ID: ChronoHelmAI.MathFlight.MinimalPanel.v1.1
Suggested slug: /chronohelmai-mathflight-minimal-panel/

AI Ingestion Lock

What this is: A single page a tutor (or parent/student) can run weekly to keep a learner inside a stable K2→Uni math flight corridor by measuring the 5 runtime sensors and enforcing the stability law:

[
\textbf{RepairRate} ; R ;\ge; \textbf{DriftRate} ; D \quad \text{under load}
]

If (D>R), the learner enters Drift/Descent; the panel outputs the next repair actions (truncate → stitch → widen).

Classical Foundation Block (baseline anchors)

• Primary Math “Big Ideas” provide continuity spine across levels. (moe.gov.sg)
• O-Level E-Math and A-Math emphasise assessed mathematical processes beyond technique (reasoning/application/communication, translation across forms). (seab.gov.sg)
• H2 assumes O-Level Additional Mathematics knowledge (dependency edge). (seab.gov.sg)

Civilisation-Grade Definition (eduKateSG)

This panel is a Control Tower: it does not teach topics directly. It controls corridor width by monitoring:

• Representation stability
• Ledger validity control
• Router method selection
• Debugger repair speed
• Load budget (choice control)

The Minimal Panel (fill weekly)

0) Metadata (Canonical Framing Box)

• Learner: __
• Stage (one): K2 / P1–2 / P3–4 / P5–6 / Sec1–2 / Sec3–4 E / Sec3–4 A / JC H1 / JC H2 / JC H3-FM / Uni
• Time Slice (week): __
• Primary Goal: Maintain Stable Cruise; widen corridor only after stability holds.

1) Route State (ChronoFlight)

Choose one:

• Climbing (skills rising, buffers healthy)
• Stable Cruise (consistent, low drift)
• Drift (errors rising, confidence dropping)
• Corrective Turn (repair working)
• Descent (collapse under load)

Quick rule: If two or more core sensors breach thresholds → Drift/Descent.

2) Core Sensors (5 numbers)

S1 — Representation Switch Score (RepSwitch)

Test (3 min): same problem represented in:

• words → diagram/model → algebra → (graph/relationship statement if relevant)

Score 0–3:

• 0 = cannot convert
• 1 = converts with major mismatch
• 2 = mostly correct
• 3 = clean + can explain meaning

S2 — Invariant Breach Rate (IBR)

Test (timed set): count breaches per question:

• illegal divide / domain ignored / extraneous roots not checked / wrong equivalence step

Metric:

• IBR = breaches / question

S3 — Router Accuracy (RA)

Test (10 flash prompts): “What family is this + first method?”

• RA = correct / 10

S4 — Debug Latency (DL)

Test (2 wrong solutions): find the first invalid line.

• DL = average seconds (target ≤45s by Sec3/4; ≤30s by JC)

S5 — Choice Explosion Index (CEI)

Test (timed): method switches per question.

• CEI = switches / question (target trending ↓; ideal ≤1)

3) Thresholds (by stage band)

Use banded targets (do not overfit early stages).

Band A — Primary (P1–P6)

• RepSwitch ≥ 2
• IBR ≤ 0.6
• RA ≥ 6/10
• DL ≤ 90s
• CEI ≤ 2

Band B — Secondary E-Math

• RepSwitch ≥ 2
• IBR ≤ 0.4
• RA ≥ 7/10
• DL ≤ 60s
• CEI ≤ 1.5

Band C — Secondary A-Math / JC

• RepSwitch ≥ 2 (incl. function meaning)
• IBR ≤ 0.25 (ledger discipline tight)
• RA ≥ 8/10
• DL ≤ 45s (JC ≤ 30–40s)
• CEI ≤ 1

Band D — University (foundation)

• RepSwitch ≥ 2 (definitions included)
• IBR ≤ 0.25
• RA ≥ 8/10
• DL ≤ 45s (proof gaps count)
• CEI ≤ 1 (plan before execute)

4) DriftRate vs RepairRate (the stability law)

Compute DriftRate D (simple)

[
D = w_1(1-\text{RepSwitch}/3)+w_2(\text{IBR})+w_3(1-\text{RA}/10)+w_4(\text{DL}/T)+w_5(\text{CEI}/C)
]
Use defaults:

• (T=90) seconds, (C=2) switches
• weights (w_i = 1) (equal) unless you specialise later

Compute RepairRate R (simple)

R is operational, not emotional:

• R = (how quickly the student detects + corrects within the same question)

Practical proxy:

• R = 1 / (DL + 30×CEI) (lower DL + fewer switches = higher R)

Decision rule

• If D rising AND R falling → Drift/Descent
• If D falling AND R rising → Corrective Turn / Climbing

5) Edge Diagnosis (auto-map to MissingEdges)

If thresholds fail, identify which edge is broken:

• RepSwitch low → Edge.DiagramToSymbol.Compiler or Edge.NotationGrammar.LanguageMigration
• IBR high → Edge.LedgerUpgrade.EquivalenceDomainReversibility
• RA low → Edge.Router.Debugger.UnderLoad (router half)
• DL high → Edge.Router.Debugger.UnderLoad (debugger half)
• CEI high → Edge.LoadBudget (choice control failure)

6) Action Output (Repair Corridor)

Pick ONE primary repair corridor per week.

Action A — Truncate (stop drift)

• enforce checkpoints every 3–5 lines
• ban method switching unless router says so
• require “domain/condition line” in A-Math+

Action B — Stitch (install missing edge)

Choose the matching cliff pack:

• PSLE→Sec1: B4 Diagram→Symbol Compiler
• E→A: B6 Ledger + Function-as-Object
• A→JC: B7 Assumed-Knowledge bridge + load compression
• JC→Uni: B8 Proof corridor

Action C — Widen (only if stable)

• add alternative methods
• add mixed-topic integration
• add higher time pressure

7) Weekly Log (Ledger of Invariants for progress)

• RouteState: __
• RepSwitch: __ /3
• IBR: __
• RA: __/10
• DL: __s
• CEI: __
• Primary MissingEdge: __
• Chosen Action: Truncate / Stitch / Widen
• Notes (1–2 lines): __

Almost-Code (Machine-Readable)

ID: ChronoHelmAI.MathFlight.MinimalPanel.v1.1
INPUTS:
  StageBand ∈ {Primary, SecE, SecA_JC, Uni}
  Sensors := {RepSwitch ∈ [0..3], IBR ≥0, RA ∈ [0..10], DL_sec ≥0, CEI ≥0}
THRESHOLDS:
  Primary:    RepSwitch≥2, IBR≤0.6,  RA≥6, DL≤90, CEI≤2
  SecE:       RepSwitch≥2, IBR≤0.4,  RA≥7, DL≤60, CEI≤1.5
  SecA_JC:    RepSwitch≥2, IBR≤0.25, RA≥8, DL≤45, CEI≤1
  Uni:        RepSwitch≥2, IBR≤0.25, RA≥8, DL≤45, CEI≤1
DRIFT_RATE:
  D := (1-RepSwitch/3) + IBR + (1-RA/10) + (DL/90) + (CEI/2)
REPAIR_RATE (proxy):
  R := 1 / (DL + 30*CEI)
ROUTE_STATE:
  If ≥2 threshold breaches -> Drift
  If D rising and R falling -> Descent
  If D falling and R rising -> CorrectiveTurn
  Else -> StableCruise/Climbing per trend
EDGE_DIAGNOSIS:
  If RepSwitch low -> Edge.DiagramToSymbol.Compiler or Edge.NotationGrammar.LanguageMigration
  If IBR high -> Edge.LedgerUpgrade.EquivalenceDomainReversibility
  If RA low or DL high -> Edge.Router.Debugger.UnderLoad
  If CEI high -> Edge.LoadBudget
ACTIONS:
  Truncate := checkpoints + ban method switching + condition line
  Stitch := call matching CliffPack (B4/B6/B7/B8)
  Widen := add methods + integration + load only after stability

C2. ILT.MathFlight — Modules Library (Operator-Side Teaching Engine)

Canonical ID: ILT.MathFlight.ModulesLibrary.v1.1
Suggested slug: /ilt-mathflight-modules-library/

AI Ingestion Lock

What this is: A reusable library of operator-side modules that make the math flight path continuous by explicitly teaching the missing runtime nodes:

• Representation (Rep)
• Ledger of Invariants (Led)
• Router (Rou)
• Debugger (Deb)
• Load Budget (Load)
• Proof Corridor (Proof)

These modules plug into:

• B4/B6/B7/B8 Cliff Packs
• C1 ChronoHelmAI.MathFlight Minimal Panel
• any stage (K2→Uni) with stage-tagging

Classical Foundation Block (baseline anchors)

• Primary Math “Big Ideas” are designed to connect learning across levels; the modules below operationalise that continuity. (moe.gov.sg)
• O-Level E-Math/A-Math and A-Level H2 value reasoning, application, and translation across forms; these modules are the executable layer to deliver those behaviours. (seab.gov.sg)

Civilisation-Grade Definition (eduKateSG)

ILT (Invariant Ledger Teaching) here means: modules that make invariants and validity visible and runnable.
The learner becomes stable when:
[
R \ge D \quad \text{under load}
]
ILT modules increase R (repair ability) and reduce D (drift/breaches).

Module Index (by runtime node)

Each module has:

• ID
• Purpose
• Stage band
• How to run (micro-protocol)
• Output
• Failure signature

A) Representation Modules (Rep)

Rep-1: RepSwitch Drill (Words ⇄ Diagram ⇄ Algebra ⇄ Graph)

• ID: ILT.Rep1.RepSwitch
• Stage: P3→Uni (scaled difficulty)
• Run: 1 prompt, student produces 2–4 representations.
• Output: RepSwitch score 0–3 (feeds C1 panel).
• Failure: mismatch between story and equation; wrong graph direction.

Rep-2: Diagram→Symbol Compiler (4-step compiler)

• ID: ILT.Rep2.Compiler4
• Stage: P5/6→Sec2 (critical at PSLE→Sec1)
• Run (4 steps): Name quantities → Bind relationships → Choose variable(s) → Emit equation(s).
• Output: story-consistent equations (compiler installed).
• Failure: “random equations”, wrong variable meaning.

Rep-3: Unit/Dimension Annotation

• ID: ILT.Rep3.UnitsAnnotate
• Stage: P3→Uni
• Run: every variable/expression must carry a unit tag at least once per question.
• Output: fewer silent modelling errors.
• Failure: inconsistent units; impossible magnitudes.

B) Ledger of Invariants Modules (Led)

Led-1: “=” Visibility Protocol

• ID: ILT.Led1.EqualsVisibility
• Stage: P1→Sec
• Run: student must say “left and right are the same value” and keep it true.
• Output: reduces equivalence drift.
• Failure: treats “=” as “next step.”

Led-2: Conditional Move Tagging (E-move vs C-move)

• ID: ILT.Led2.ECMoveTag
• Stage: Sec2→Uni (critical at E→A)
• Run: each transformation is tagged:
• E-move: equivalence-preserving & reversible
• C-move: conditional/non-reversible → requires a check
• Output: legality awareness.
• Failure: divides/squares/logs with no conditions.

Led-3: Domain Line First

• ID: ILT.Led3.DomainFirst
• Stage: Sec3A→Uni
• Run: before solving logs/surds/inverses, write domain constraints.
• Output: reduces invalid solutions.
• Failure: extraneous roots; invalid log arguments.

Led-4: 3-Checkpoint Working Style

• ID: ILT.Led4.Checkpoints3
• Stage: Sec→Uni
• Run: every 3–5 lines:

1. domain checkpoint
2. equivalence checkpoint
3. substitution checkpoint

• Output: truncates drift early.
• Failure: long uncontrolled working, late discovery.

C) Router Modules (Rou)

Rou-1: Family Flash (10 seconds)

• ID: ILT.Rou1.FamilyFlash10s
• Stage: P5/6→Uni
• Run: show question; student says family + first method in 10s.
• Output: RA/10 score for panel.
• Failure: freezes; method chosen doesn’t match structure.

Rou-2: Method Budget Map (Operator corridor)

• ID: ILT.Rou2.MethodBudget
• Stage: Sec3→JC
• Run: per topic family, pick 1–2 safe routes; forbid others until stable.
• Output: fewer method switches; higher reliability.
• Failure: random method switching, “try everything.”

Rou-3: Mixed-Topic Router (AO2 discipline)

• ID: ILT.Rou3.MixedTopicAO2
• Stage: Sec4→JC (critical at A→JC)
• Run: 2-minute plan: family → method → checkpoints → expected form of answer.
• Output: integration readiness.
• Failure: starts calculating without a route plan.

D) Debugger Modules (Deb)

Deb-1: First Wrong Line (≤45s)

• ID: ILT.Deb1.FirstWrongLine45
• Stage: Sec→Uni (JC target ≤30–40s)
• Run: provide wrong solution; student identifies first invalid line and labels breach type.
• Output: DL (debug latency).
• Failure: points to final answer only; cannot localise breach.

Deb-2: Breach Class Repair Loops

• ID: ILT.Deb2.RepairLoops
• Stage: Sec→JC
• Run: map breach classes → micro-drills:
• sign slip → 10-line sign drill
• domain breach → domain-first drill
• wrong identity → identity recall + verify
• Output: RepairRate increases.
• Failure: repeats same error pattern weekly.

Deb-3: Substitution Verification Habit

• ID: ILT.Deb3.SubstituteBack
• Stage: P5/6→Uni
• Run: all candidate solutions must be substituted back (especially after C-moves).
• Output: catches extraneous roots.
• Failure: accepts solutions without verification.

Deb-4: Counterexample Unit Tests (Proof Debugger)

• ID: ILT.Deb4.CounterexampleUnitTests
• Stage: JC→Uni (critical)
• Run: before proving, attempt to break claim (n=0,1,−1; boundary cases).
• Output: proof debugging installed.
• Failure: believes false statements; cannot find non-example.

E) Load Budget Modules (Load)

Load-1: Method Switch Cap

• ID: ILT.Load1.SwitchCap
• Stage: Sec→Uni
• Run: cap method switches at ≤1 per question unless router justifies.
• Output: CEI trending down.
• Failure: spirals under stress.

Load-2: Checkpoint Timer

• ID: ILT.Load2.CheckpointTimer
• Stage: Sec3→JC
• Run: must reach a checkpoint by 2–3 minutes; else truncate and restart with simpler route.
• Output: prevents time debt.
• Failure: spends 10 minutes on wrong branch.

Load-3: Two-Speed Mode (Learn vs Test)

• ID: ILT.Load3.TwoSpeed
• Stage: All
• Run: explicitly separate:
• Learn mode: explore, widen
• Test mode: operator corridor only
• Output: prevents exploration from leaking into exams.
• Failure: exploration habits appear during timed tests.

F) Function-as-Object Modules (Func)

Func-1: Function Machine (Input→Output)

• ID: ILT.Func1.MachineIO
• Stage: Sec1→JC
• Run: every f(x) task must be described in words first.
• Output: fewer f(x+a)/f(ax) errors.
• Failure: “memorise shift rules” without meaning.

Func-2: Transformation Prediction First

• ID: ILT.Func2.PredictThenCompute
• Stage: Sec3A→JC
• Run: predict graph change before algebra; then verify.
• Output: stable intuition + verification loop.
• Failure: blind manipulation.

Func-3: Inverse Validity Protocol

• ID: ILT.Func3.InverseValidity
• Stage: Sec3A→JC
• Run: one-to-one check; domain restriction if needed.
• Output: prevents invalid inverses.
• Failure: “find inverse” mechanically.

G) Proof Corridor Modules (Proof)

Proof-1: Proof Start Engine (Goal Rewrite)

• ID: ILT.Proof1.GoalRewrite
• Stage: JC→Uni
• Run: rewrite “prove X” into “assume…, show…” or “show A⇒B,” etc.
• Output: reduces “can’t start.”
• Failure: stares at statement; asks for formula.

Proof-2: Definition First Protocol (Example + Non-example)

• ID: ILT.Proof2.DefinitionFirst
• Stage: JC→Uni
• Run: definition + one example + one non-example before proving.
• Output: abstraction tolerance.
• Failure: vague language; wrong scope.

Proof-3: Lemma Ladder (2–3 lemma plan)

• ID: ILT.Proof3.LemmaLadder
• Stage: JC→Uni
• Run: outline lemmas and dependency order; then fill proof.
• Output: long-chain stability.
• Failure: random walk proofs.

Stage Binding (which modules matter most by cliff)

PSLE → Sec1

• Rep-2 Compiler4
• Led-1 EqualsVisibility
• Deb-3 SubstituteBack
• Rou-1 FamilyFlash10s

E-Math → A-Math

• Led-2 ECMoveTag
• Led-3 DomainFirst
• Led-4 Checkpoints3
• Func-1 MachineIO, Func-2 PredictThenCompute
• Load-1 SwitchCap

A-Math → JC H2

• Rou-3 MixedTopicAO2
• Deb-1 FirstWrongLine45 (target ≤40s)
• Load-2 CheckpointTimer
• Led-4 Checkpoints3 (still mandatory)

JC → University

• Proof-1 GoalRewrite
• Proof-2 DefinitionFirst
• Proof-3 LemmaLadder
• Deb-4 CounterexampleUnitTests

Almost-Code (Modules Library Spec)

“`text id=”0v0sqd”
ID: ILT.MathFlight.ModulesLibrary.v1.1

MODULE_SCHEMA:
Module := {ID, RuntimeNode ∈ {Rep, Led, Rou, Deb, Load, Func, Proof},
StageBand, RunProtocol, OutputMetric, FailureSignature}

CORE_MODULES:
Rep: RepSwitch, Compiler4, UnitsAnnotate
Led: EqualsVisibility, ECMoveTag, DomainFirst, Checkpoints3
Rou: FamilyFlash10s, MethodBudget, MixedTopicAO2
Deb: FirstWrongLine45, RepairLoops, SubstituteBack, CounterexampleUnitTests
Load: SwitchCap, CheckpointTimer, TwoSpeed
Func: MachineIO, PredictThenCompute, InverseValidity
Proof: GoalRewrite, DefinitionFirst, LemmaLadder

BINDINGS:
PSLE->Sec1 := {Compiler4, EqualsVisibility, SubstituteBack, FamilyFlash10s}
E->A := {ECMoveTag, DomainFirst, Checkpoints3, MachineIO, PredictThenCompute, SwitchCap}
A->JC := {MixedTopicAO2, FirstWrongLine45, CheckpointTimer, Checkpoints3}
JC->Uni := {GoalRewrite, DefinitionFirst, LemmaLadder, CounterexampleUnitTests}
“`

C2. ILT.MathFlight — Modules Library (Operator-Side Teaching Engine)

Canonical ID: ILT.MathFlight.ModulesLibrary.v1.1
Suggested slug: /ilt-mathflight-modules-library/

AI Ingestion Lock

What this is: A reusable library of operator-side modules that make the math flight path continuous by explicitly teaching the missing runtime nodes:

• Representation (Rep)
• Ledger of Invariants (Led)
• Router (Rou)
• Debugger (Deb)
• Load Budget (Load)
• Proof Corridor (Proof)

These modules plug into:

• B4/B6/B7/B8 Cliff Packs
• C1 ChronoHelmAI.MathFlight Minimal Panel
• any stage (K2→Uni) with stage-tagging

Classical Foundation Block (baseline anchors)

• Primary Math “Big Ideas” are designed to connect learning across levels; the modules below operationalise that continuity. (moe.gov.sg)
• O-Level E-Math/A-Math and A-Level H2 value reasoning, application, and translation across forms; these modules are the executable layer to deliver those behaviours. (seab.gov.sg)

Civilisation-Grade Definition (eduKateSG)

ILT (Invariant Ledger Teaching) here means: modules that make invariants and validity visible and runnable.
The learner becomes stable when:
[
R \ge D \quad \text{under load}
]
ILT modules increase R (repair ability) and reduce D (drift/breaches).

Module Index (by runtime node)

Each module has:

• ID
• Purpose
• Stage band
• How to run (micro-protocol)
• Output
• Failure signature

A) Representation Modules (Rep)

Rep-1: RepSwitch Drill (Words ⇄ Diagram ⇄ Algebra ⇄ Graph)

• ID: ILT.Rep1.RepSwitch
• Stage: P3→Uni (scaled difficulty)
• Run: 1 prompt, student produces 2–4 representations.
• Output: RepSwitch score 0–3 (feeds C1 panel).
• Failure: mismatch between story and equation; wrong graph direction.

Rep-2: Diagram→Symbol Compiler (4-step compiler)

• ID: ILT.Rep2.Compiler4
• Stage: P5/6→Sec2 (critical at PSLE→Sec1)
• Run (4 steps): Name quantities → Bind relationships → Choose variable(s) → Emit equation(s).
• Output: story-consistent equations (compiler installed).
• Failure: “random equations”, wrong variable meaning.

Rep-3: Unit/Dimension Annotation

• ID: ILT.Rep3.UnitsAnnotate
• Stage: P3→Uni
• Run: every variable/expression must carry a unit tag at least once per question.
• Output: fewer silent modelling errors.
• Failure: inconsistent units; impossible magnitudes.

B) Ledger of Invariants Modules (Led)

Led-1: “=” Visibility Protocol

• ID: ILT.Led1.EqualsVisibility
• Stage: P1→Sec
• Run: student must say “left and right are the same value” and keep it true.
• Output: reduces equivalence drift.
• Failure: treats “=” as “next step.”

Led-2: Conditional Move Tagging (E-move vs C-move)

• ID: ILT.Led2.ECMoveTag
• Stage: Sec2→Uni (critical at E→A)
• Run: each transformation is tagged:
• E-move: equivalence-preserving & reversible
• C-move: conditional/non-reversible → requires a check
• Output: legality awareness.
• Failure: divides/squares/logs with no conditions.

Led-3: Domain Line First

• ID: ILT.Led3.DomainFirst
• Stage: Sec3A→Uni
• Run: before solving logs/surds/inverses, write domain constraints.
• Output: reduces invalid solutions.
• Failure: extraneous roots; invalid log arguments.

Led-4: 3-Checkpoint Working Style

• ID: ILT.Led4.Checkpoints3
• Stage: Sec→Uni
• Run: every 3–5 lines:

1. domain checkpoint
2. equivalence checkpoint
3. substitution checkpoint

• Output: truncates drift early.
• Failure: long uncontrolled working, late discovery.

C) Router Modules (Rou)

Rou-1: Family Flash (10 seconds)

• ID: ILT.Rou1.FamilyFlash10s
• Stage: P5/6→Uni
• Run: show question; student says family + first method in 10s.
• Output: RA/10 score for panel.
• Failure: freezes; method chosen doesn’t match structure.

Rou-2: Method Budget Map (Operator corridor)

• ID: ILT.Rou2.MethodBudget
• Stage: Sec3→JC
• Run: per topic family, pick 1–2 safe routes; forbid others until stable.
• Output: fewer method switches; higher reliability.
• Failure: random method switching, “try everything.”

Rou-3: Mixed-Topic Router (AO2 discipline)

• ID: ILT.Rou3.MixedTopicAO2
• Stage: Sec4→JC (critical at A→JC)
• Run: 2-minute plan: family → method → checkpoints → expected form of answer.
• Output: integration readiness.
• Failure: starts calculating without a route plan.

D) Debugger Modules (Deb)

Deb-1: First Wrong Line (≤45s)

• ID: ILT.Deb1.FirstWrongLine45
• Stage: Sec→Uni (JC target ≤30–40s)
• Run: provide wrong solution; student identifies first invalid line and labels breach type.
• Output: DL (debug latency).
• Failure: points to final answer only; cannot localise breach.

Deb-2: Breach Class Repair Loops

• ID: ILT.Deb2.RepairLoops
• Stage: Sec→JC
• Run: map breach classes → micro-drills:
• sign slip → 10-line sign drill
• domain breach → domain-first drill
• wrong identity → identity recall + verify
• Output: RepairRate increases.
• Failure: repeats same error pattern weekly.

Deb-3: Substitution Verification Habit

• ID: ILT.Deb3.SubstituteBack
• Stage: P5/6→Uni
• Run: all candidate solutions must be substituted back (especially after C-moves).
• Output: catches extraneous roots.
• Failure: accepts solutions without verification.

Deb-4: Counterexample Unit Tests (Proof Debugger)

• ID: ILT.Deb4.CounterexampleUnitTests
• Stage: JC→Uni (critical)
• Run: before proving, attempt to break claim (n=0,1,−1; boundary cases).
• Output: proof debugging installed.
• Failure: believes false statements; cannot find non-example.

E) Load Budget Modules (Load)

Load-1: Method Switch Cap

• ID: ILT.Load1.SwitchCap
• Stage: Sec→Uni
• Run: cap method switches at ≤1 per question unless router justifies.
• Output: CEI trending down.
• Failure: spirals under stress.

Load-2: Checkpoint Timer

• ID: ILT.Load2.CheckpointTimer
• Stage: Sec3→JC
• Run: must reach a checkpoint by 2–3 minutes; else truncate and restart with simpler route.
• Output: prevents time debt.
• Failure: spends 10 minutes on wrong branch.

Load-3: Two-Speed Mode (Learn vs Test)

• ID: ILT.Load3.TwoSpeed
• Stage: All
• Run: explicitly separate:
• Learn mode: explore, widen
• Test mode: operator corridor only
• Output: prevents exploration from leaking into exams.
• Failure: exploration habits appear during timed tests.

F) Function-as-Object Modules (Func)

Func-1: Function Machine (Input→Output)

• ID: ILT.Func1.MachineIO
• Stage: Sec1→JC
• Run: every f(x) task must be described in words first.
• Output: fewer f(x+a)/f(ax) errors.
• Failure: “memorise shift rules” without meaning.

Func-2: Transformation Prediction First

• ID: ILT.Func2.PredictThenCompute
• Stage: Sec3A→JC
• Run: predict graph change before algebra; then verify.
• Output: stable intuition + verification loop.
• Failure: blind manipulation.

Func-3: Inverse Validity Protocol

• ID: ILT.Func3.InverseValidity
• Stage: Sec3A→JC
• Run: one-to-one check; domain restriction if needed.
• Output: prevents invalid inverses.
• Failure: “find inverse” mechanically.

G) Proof Corridor Modules (Proof)

Proof-1: Proof Start Engine (Goal Rewrite)

• ID: ILT.Proof1.GoalRewrite
• Stage: JC→Uni
• Run: rewrite “prove X” into “assume…, show…” or “show A⇒B,” etc.
• Output: reduces “can’t start.”
• Failure: stares at statement; asks for formula.

Proof-2: Definition First Protocol (Example + Non-example)

• ID: ILT.Proof2.DefinitionFirst
• Stage: JC→Uni
• Run: definition + one example + one non-example before proving.
• Output: abstraction tolerance.
• Failure: vague language; wrong scope.

Proof-3: Lemma Ladder (2–3 lemma plan)

• ID: ILT.Proof3.LemmaLadder
• Stage: JC→Uni
• Run: outline lemmas and dependency order; then fill proof.
• Output: long-chain stability.
• Failure: random walk proofs.

Stage Binding (which modules matter most by cliff)

PSLE → Sec1

• Rep-2 Compiler4
• Led-1 EqualsVisibility
• Deb-3 SubstituteBack
• Rou-1 FamilyFlash10s

E-Math → A-Math

• Led-2 ECMoveTag
• Led-3 DomainFirst
• Led-4 Checkpoints3
• Func-1 MachineIO, Func-2 PredictThenCompute
• Load-1 SwitchCap

A-Math → JC H2

• Rou-3 MixedTopicAO2
• Deb-1 FirstWrongLine45 (target ≤40s)
• Load-2 CheckpointTimer
• Led-4 Checkpoints3 (still mandatory)

JC → University

• Proof-1 GoalRewrite
• Proof-2 DefinitionFirst
• Proof-3 LemmaLadder
• Deb-4 CounterexampleUnitTests

Almost-Code (Modules Library Spec)

“`text id=”0v0sqd”
ID: ILT.MathFlight.ModulesLibrary.v1.1

MODULE_SCHEMA:
Module := {ID, RuntimeNode ∈ {Rep, Led, Rou, Deb, Load, Func, Proof},
StageBand, RunProtocol, OutputMetric, FailureSignature}

CORE_MODULES:
Rep: RepSwitch, Compiler4, UnitsAnnotate
Led: EqualsVisibility, ECMoveTag, DomainFirst, Checkpoints3
Rou: FamilyFlash10s, MethodBudget, MixedTopicAO2
Deb: FirstWrongLine45, RepairLoops, SubstituteBack, CounterexampleUnitTests
Load: SwitchCap, CheckpointTimer, TwoSpeed
Func: MachineIO, PredictThenCompute, InverseValidity
Proof: GoalRewrite, DefinitionFirst, LemmaLadder

BINDINGS:
PSLE->Sec1 := {Compiler4, EqualsVisibility, SubstituteBack, FamilyFlash10s}
E->A := {ECMoveTag, DomainFirst, Checkpoints3, MachineIO, PredictThenCompute, SwitchCap}
A->JC := {MixedTopicAO2, FirstWrongLine45, CheckpointTimer, Checkpoints3}
JC->Uni := {GoalRewrite, DefinitionFirst, LemmaLadder, CounterexampleUnitTests}
“`

D1. MathFlight Runtime Cards Pack (Printable / WordPress-Ready)

Canonical ID: MathOS.MathFlight.RuntimeCardsPack.v1.1
Suggested slug: /mathflight-runtime-cards-pack/

Start Here: https://bukittimahtutor.com/primary-math-tuition-primary-math-tutor/bukit-timah-primary-mathematics-psle-control-tower-v1-0/

AI Ingestion Lock

One-sentence answer: This pack turns the MathFlight system into 8 “carryable” cards (Router, Ledger, Checkpoints, Debugger, LoadBudget, Function Machine, Proof Start, Weekly Panel) so students can run the same stable runtime from PSLE→Sec→A-Math→JC→Uni.

Classical Foundation Block

Your syllabuses already emphasise reasoning, modelling, and metacognition; students still “fall off a cliff” when the runtime isn’t installed as an explicit habit. This pack is the student-operational layer.

How to Use (Tutor / Parent / Student)

• Print these cards or paste them as WordPress “Callout” blocks.
• Students memorise Card 1–4 first (Router/Ledger/Checkpoints/Debugger).
• Add Card 5 (LoadBudget) for tests.
• Add Card 6–7 (Function/Proof) only when needed.
• Run Card 8 weekly (the panel) to decide what to repair next.

CARD 1 — Router (10 seconds)

Title: CARD.Router10s
Purpose: Choose the correct first move; don’t calculate blindly.

Do this every time

1. Family: What type? (linear/quadratic/trig/log/calc/stats/proof)
2. Target form: What should the answer look like?
3. First method: What is the safest first move? (one only)
4. Checkpoint: Where will I check after 3–5 lines?

Rule: If you can’t name family + first method, you’re not allowed to start.

CARD 2 — Ledger (Validity Control)

Title: CARD.Ledger
Purpose: Keep steps legal.

Tag every move

• E-move: safe equivalence move
• C-move: conditional / non-reversible → must add a check

C-move examples

• divide by an expression
• square both sides
• log / exponentiate
• square roots
• inverses

C-move checklist

1. Condition line: “Require _”
2. Check: substitute answer back
3. Scope: did I widen the solution set?

Rule: No condition line = illegal step.

CARD 3 — 3 Checkpoints (Anti-Drift)

Title: CARD.Checkpoints3
Purpose: Don’t discover you’re wrong after 12 lines.

Every 3–5 lines, write:

1. Domain checkpoint (what values forbidden/required?)
2. Equivalence checkpoint (same problem?)
3. Sanity checkpoint (sign/magnitude/units/graph direction?)

Rule: If you can’t checkpoint, stop and restart from last checkpoint.

CARD 4 — Debugger (First Wrong Line)

Title: CARD.Debugger
Purpose: Fix the earliest break, not the final answer.

≤45 seconds target (≤30–40s by JC)

1. Find first wrong line
2. Tag breach type:

• algebra slip
• ledger breach (domain/0-division/extraneous)
• router error (wrong method)
• representation error (read/graph/notation)

1. Repair that line only
2. Re-run from last checkpoint

Rule: Never continue building on broken working.

CARD 5 — Load Budget (Test Mode)

Title: CARD.LoadBudget
Purpose: Stop spirals under time pressure.

Rules

• Method switch cap: ≤1 per question unless Router justifies
• Time-to-checkpoint: reach a checkpoint by 2–3 minutes
• Two-speed mode:
• Learn mode: explore
• Test mode: operator corridor only

Emergency stop
Truncate → checkpoint → restart with simpler route.

CARD 6 — Function Machine (A-Math / JC)

Title: CARD.FunctionMachine
Purpose: Treat functions as objects, not decorations.

Checklist

1. Input: what is x?
2. Action: what does f do to x?
3. Output: what comes out?
4. Transformations: describe in words before algebra
5. Inverse: check one-to-one / restrict domain

Rule: If you can’t say it in words, you don’t own it.

CARD 7 — Proof Start Engine (JC → Uni)

Title: CARD.ProofStart
Purpose: Start proofs reliably.

Checklist

1. Rewrite goal: “Assume…, show…” / “Show A⇒B”
2. Write definitions + conditions
3. Plan 2–3 lemmas
4. Counterexample unit test (try to break claim)

Rule: Proof = legal chain from definitions to conclusion.

CARD 8 — Weekly Panel (2 minutes)

Title: CARD.WeeklyPanel
Purpose: Decide what to repair next (not what to “cover”).

Record:

• RepSwitch (0–3)
• IBR (breaches/question)
• RA (out of 10)
• DL (seconds)
• CEI (switches/question)

Decision

• ≥2 threshold breaches → Drift
• Choose one action: Truncate / Stitch / Widen
• Stitch chooses the correct Cliff Pack:
• PSLE→Sec1: Diagram→Symbol Compiler
• E→A: Ledger + Function-Object
• A→JC: Assumed-Knowledge bridge
• JC→Uni: Proof corridor

Almost-Code (Pack Manifest)

ID: MathOS.MathFlight.RuntimeCardsPack.v1.1
CARDS:
  CARD.Router10s
  CARD.Ledger
  CARD.Checkpoints3
  CARD.Debugger
  CARD.LoadBudget
  CARD.FunctionMachine
  CARD.ProofStart
  CARD.WeeklyPanel
BINDINGS:
  PSLE->Sec1 := {Router10s, Ledger(basic "="), Checkpoints3, Debugger, WeeklyPanel}
  E->A := {Router10s, Ledger(C-moves), Checkpoints3, Debugger, LoadBudget, FunctionMachine, WeeklyPanel}
  A->JC := {Router10s, Ledger, Checkpoints3, Debugger(speed), LoadBudget, WeeklyPanel}
  JC->Uni := {Router10s, Ledger(definition-based), Debugger(counterexample), ProofStart, WeeklyPanel}
STABILITY_LAW:
  Under_load: RepairRate R >= DriftRate D

D2. Tutor Weekly SOP — MathFlight Control Tower Operating Procedure

Canonical ID: ControlTower.MathFlight.WeeklySOP.v1.1
Suggested slug: /mathflight-weekly-tutor-sop/

AI Ingestion Lock

One-sentence answer: Run the same weekly loop: measure 5 sensors → determine RouteState (Climb/Cruise/Drift/Turn/Descent) → identify the broken MissingEdge → prescribe one repair corridor (truncate/stitch/widen) using the ILT modules → retest → log.
Stability law: RepairRate ≥ DriftRate under load.

Classical Foundation Block (baseline anchors)

Across levels, the intended outcomes include reasoning, application, representation translation, and metacognition; this SOP is the execution layer that installs these as stable student behaviours. (moe.gov.sg)

0) Inputs (every week)

• Student: __
• Stage band: Primary / Sec E / Sec A+JC / Uni
• Time slice: Week __
• Target: Stable Cruise (then widen corridor)

Tools used:

• C1 Minimal Panel
• C2 ILT Modules Library
• C3 Student Runtime Pack
• relevant Cliff Pack (B4/B6/B7/B8)

1) Weekly Schedule (30–60 min format)

Option A (30 min)

• 5 min: Panel sensors
• 15 min: Stitch drill set (one module)
• 8 min: Timed mini-set (2 questions)
• 2 min: Retest 1 sensor + log

Option B (60 min)

• 10 min: Panel sensors + edge diagnosis
• 25 min: Stitch drill set + coached correction
• 20 min: Mixed set under load
• 5 min: Retest + flight log + homework prescription

2) Step-by-step SOP (what the tutor does)

Step 1 — Run the 5 sensors (C1)

Record:

• RepSwitch (0–3)
• IBR (breaches/question)
• RA (correct family+first method /10)
• DL (sec to first wrong line)
• CEI (method switches/question)

Step 2 — Determine RouteState (ChronoFlight)

• Stable Cruise: ≤1 threshold breach
• Drift: ≥2 threshold breaches
• Descent: D rising AND R falling week-over-week
• Corrective Turn: D falling AND R rising

(Use the band thresholds from C1.)

Step 3 — Identify the primary MissingEdge (choose ONE)

Use this mapping:

If RepSwitch low → Representation edge

• Primary/Sec1: Edge.DiagramToSymbol.Compiler
• Sec+: Edge.NotationGrammar.LanguageMigration

If IBR high → Ledger edge

• Edge.LedgerUpgrade.EquivalenceDomainReversibility

If RA low or DL high → Router/Debugger edge

• Edge.Router.Debugger.UnderLoad

If CEI high → Load edge

• Edge.LoadBudget (choice control failure)

If JC→Uni proof issues → Proof edge

• Edge.ProofCorridor.DefinitionLemmaTheorem

Rule: Do not fix more than one edge per week.

3) Prescribe one repair corridor (truncate / stitch / widen)

A) Truncate (if Drift/Descent)

Use when: student is spiralling, working is long, CEI high.

• enforce Checkpoints3 every 3–5 lines (ILT.Led4.Checkpoints3)
• apply SwitchCap (ILT.Load1.SwitchCap)
• force Router10s before every question (ILT.Rou1.FamilyFlash10s)
• stop after 2–3 minutes if no checkpoint (restart)

B) Stitch (install the missing edge)

Choose the matching module pack:

Stitch-PSLE→Sec1

• ILT.Rep2.Compiler4 + ILT.Led1.EqualsVisibility
• mini-set: 6 compiler drills + 2 algebra starters

Stitch-E→A

• ILT.Led2.ECMoveTag + ILT.Led3.DomainFirst
• plus ILT.Func1.MachineIO if function meaning fails

Stitch-A→JC

• ILT.Rou3.MixedTopicAO2 + ILT.Deb1.FirstWrongLine45
• plus assumed-knowledge patchboard (from B7)

Stitch-JC→Uni

• ILT.Proof1.GoalRewrite + ILT.Proof2.DefinitionFirst
• plus ILT.Deb4.CounterexampleUnitTests

C) Widen (only if Stable Cruise ≥2 weeks)

• add alternative methods (Architect corridor)
• add mixed-topic integration
• add higher load (timed sets)

4) Drill formats (so it’s runnable)

Drill Format 1 — Micro-drills (10 minutes)

• 8 items, 1 minute each
• immediate correction
• ledger annotation required on every C-move

Drill Format 2 — Two-question mini-set (10 minutes)

• timed
• target: CEI ≤ 1, DL ≤ band target
• review only the first wrong line

Drill Format 3 — Mixed-topic (20 minutes)

• 4 short questions from different families
• router flash for each
• checkpoint enforced

5) Retest (must do)

Pick the one sensor linked to this week’s missing edge and retest after stitching:

• compiler work → retest RepSwitch
• ledger work → retest IBR
• router work → retest RA
• debugger work → retest DL
• load work → retest CEI
• proof work → retest “goal rewrite” success rate

6) Homework prescription (tiny but targeted)

Homework is not “more questions.”
It is:

• 10 micro-drills that install the missing edge
• 2 mixed questions to test transfer
• 1 reflection line: “Which ledger rule did I use today?”

7) Logging (the control tower record)

Weekly log row:

• Week, StageBand, RouteState
• RepSwitch, IBR, RA, DL, CEI
• MissingEdge chosen
• Modules used
• Retest result
• Next action (truncate/stitch/widen)

Almost-Code (Weekly SOP Spec)

“`text id=”j2f1m9″
ID: ControlTower.MathFlight.WeeklySOP.v1.1

INPUTS:
Student, StageBand, Week
Sensors := {RepSwitch, IBR, RA, DL, CEI}

ROUTE_STATE:
StableCruise if breaches<=1 Drift if breaches>=2
Descent if D rising and R falling
CorrectiveTurn if D falling and R rising

EDGE_DIAGNOSIS (choose ONE):
If RepSwitch low -> Edge.DiagramToSymbol.Compiler or Edge.NotationGrammar.LanguageMigration
If IBR high -> Edge.LedgerUpgrade.EquivalenceDomainReversibility
If RA low or DL high -> Edge.Router.Debugger.UnderLoad
If CEI high -> Edge.LoadBudget
If proof fail -> Edge.ProofCorridor.DefinitionLemmaTheorem

ACTIONS:
Truncate := {Checkpoints3, SwitchCap, Router10s, RestartRule}
Stitch := select modules by edge (Compiler4 / ECMoveTag / MixedTopicAO2 / GoalRewrite etc)
Widen := only if StableCruise>=2 weeks

RETEST:
Retest sensor corresponding to chosen edge; log delta

OUTPUT:
WeeklyPlan := {PrimaryEdge, Modules, Drills, Retest, Homework, LogRow}
“`

D3. Missing Bits Catalogue — MathFlight Edge Registry (K2 → University)

Canonical ID: MathOS.FlightPath.K2_to_Uni.CF.MissingBitsCatalogue.v1.1
Suggested slug: /mathflight-missing-bits-catalogue/

AI Ingestion Lock

One-sentence answer: This registry lists every “missing bit” (MissingEdge) that causes students to fall off the math flight path, with symptoms → sensors → repair modules → transition binding, so gaps can be diagnosed and stitched systematically instead of guessed.

Classical Foundation Block

Primary Math Big Ideas are designed to connect concepts across levels; secondary and pre-university syllabuses assess reasoning and representation translation. This catalogue is the operational layer that makes the continuity executable. (moe.gov.sg)

How to Read This Catalogue

Each MissingEdge has:

• Edge ID (stable, canonical)
• Transition(s) where it breaks
• Definition (what capability is missing)
• Symptoms (what you observe)
• Sensors (quick diagnostics)
• Repair modules (ILT module IDs)
• Repair corridor (truncate → stitch → widen)

Registry Index (Top Edge Set)

1. Edge.DiagramToSymbol.Compiler
2. Edge.LedgerUpgrade.EquivalenceDomainReversibility
3. Edge.Router.Debugger.UnderLoad
4. Edge.ProportionalityToFunction.ObjectUpgrade
5. Edge.FunctionAsObject.Transformations
6. Edge.NotationGrammar.LanguageMigration
7. Edge.AssumedKnowledge.BridgeToH2
8. Edge.ProofCorridor.DefinitionLemmaTheorem
9. Edge.MeasureToDimensionAnalysis.UnitsLedger
10. Edge.ModelToEquationSystem.MultiVariable

1) Edge.DiagramToSymbol.Compiler

Transition(s): P6/PSLE → Sec1 (highest pain)

Definition: Ability to compile model/diagram reasoning into variables + equations that preserve story invariants.

Symptoms

• can bar-model but freezes on “let x be…”
• equations don’t match the story
• cannot interpret answer back to context

Sensors

• Bar→Equation (1 variable)
• Comparison→System (2 variables)
• Reverse check by substitution

Repair Modules

• ILT.Rep2.Compiler4
• ILT.Led1.EqualsVisibility
• ILT.Deb3.SubstituteBack

Repair Corridor
Truncate long working → stitch compiler drills → widen mixed families.

2) Edge.LedgerUpgrade.EquivalenceDomainReversibility

Transition(s): Sec2 E → Sec3 A (and persists into JC)

Definition: Line-by-line legality control for conditional/non-reversible transformations (domain, divide-by-0, squaring, inverses, logs).

Symptoms

• “steps look right” but answers wrong
• ignores domain; extraneous roots appear
• cannot explain validity of steps

Sensors

• Zero-division check
• Squaring extraneous check
• Log/surd domain-first check
• First invalid step in wrong solution

Repair Modules

• ILT.Led2.ECMoveTag
• ILT.Led3.DomainFirst
• ILT.Led4.Checkpoints3

Repair Corridor
Detect breach → enforce condition lines + checkpoints → widen.

3) Edge.Router.Debugger.UnderLoad

Transition(s): all, amplified at Sec3/4 and JC

Definition: Fast problem-family classification + quick breach localisation and repair under timed conditions.

Symptoms

• tries many methods; spirals
• slow, loses time, panics
• “I don’t know what to do” on unfamiliar form

Sensors

• Router flash (10s) RA/10
• Debug latency (first wrong line)
• Method switch count

Repair Modules

• ILT.Rou1.FamilyFlash10s
• ILT.Deb1.FirstWrongLine45
• ILT.Deb2.RepairLoops
• ILT.Load1.SwitchCap

Repair Corridor
Truncate switching → stitch router+debug drills → widen mixed-topic sets.

4) Edge.ProportionalityToFunction.ObjectUpgrade

Transition(s): P4–P6 → Sec1–2 (hidden cause)

Definition: Upgrade ratio/rate/percent from “steps” into stable relationship thinking (y=kx, gradient as rate, scale as mapping).

Symptoms

• can do unitary method but can’t express relationship as equation
• weak graph sense; gradient meaning unclear
• struggles later with variation and calculus intuition

Sensors

• Unitary → y=kx translation
• Rate interpretation from graph
• “What stays constant?” invariant question

Repair Modules

• ILT.Rep1.RepSwitch
• ILT.Rep2.Compiler4 (relationship emission)
• ILT.Func1.MachineIO (later)

5) Edge.FunctionAsObject.Transformations

Transition(s): Sec3 A → JC (and earlier for A-Math)

Definition: Treat functions as objects you transform (shift/scale/compose/invert) with meaning.

Symptoms

• memorises graph shifts without understanding
• misreads f(x+a), f(ax)
• inverse/composition confusion

Sensors

• Explain f(x+a) in words
• Inverse validity (one-to-one / restrict domain)
• Composition “machine chaining” explanation

Repair Modules

• ILT.Func1.MachineIO
• ILT.Func2.PredictThenCompute
• ILT.Func3.InverseValidity

6) Edge.NotationGrammar.LanguageMigration

Transition(s): Primary → Secondary → A-Math

Definition: Treat symbols as a language with grammar (scope, structure, precedence, meaning).

Symptoms

• “symbol blindness”
• wrong interpretation of expressions
• errors due to misreading, not concept gaps

Sensors

• parse expression aloud
• identify “what is the object?” vs “what is the operation?”

Repair Modules

• ILT.Rep1.RepSwitch
• ILT.Led1.EqualsVisibility
• (plus short notation drills embedded in every set)

7) Edge.AssumedKnowledge.BridgeToH2

Transition(s): A-Math → JC H2

Definition: Completion + speed of O-Level A-Math assumed-knowledge set under JC compression.

Symptoms

• JC topics feel impossible because prerequisites are shaky
• slow manipulation causes time debt
• constant remediation needed

Sensors

• assumed-knowledge patch scan (quadratics, logs, trig, calculus basics)
• debug latency under load

Repair Modules

• ILT.Rou3.MixedTopicAO2
• ILT.Deb1.FirstWrongLine45
• ILT.Load2.CheckpointTimer
• plus B7 patchboard SOP

8) Edge.ProofCorridor.DefinitionLemmaTheorem

Transition(s): JC → University

Definition: Definition-driven reasoning + proof start engine + lemma planning + counterexample debugging.

Symptoms

• can calculate but can’t prove
• can’t start without worked examples
• long chain collapse

Sensors

• goal rewrite (assume/show)
• quantifier reading
• counterexample instinct
• lemma planning

Repair Modules

• ILT.Proof1.GoalRewrite
• ILT.Proof2.DefinitionFirst
• ILT.Proof3.LemmaLadder
• ILT.Deb4.CounterexampleUnitTests

9) Edge.MeasureToDimensionAnalysis.UnitsLedger

Transition(s): Primary → Secondary (and modelling later)

Definition: Treat units/dimensions as invariants that must reconcile; prevents silent modelling drift.

Symptoms

• wrong magnitude answers
• confusion between speed/time/distance units
• formula misuse not detected

Sensors

• annotate units for every variable
• estimate magnitude sanity check

Repair Modules

• ILT.Rep3.UnitsAnnotate
• ILT.Led4.Checkpoints3

10) Edge.ModelToEquationSystem.MultiVariable

Transition(s): Upper Primary → Sec1–2

Definition: Move from single-unknown arithmetic modelling to multi-variable algebraic systems.

Symptoms

• persists with bar model when algebra intended
• cannot define variables cleanly
• inconsistent equations

Sensors

• define variables with units
• emit 2 constraints from 2 sentences
• solve and interpret

Repair Modules

• ILT.Rep2.Compiler4
• ILT.Led1.EqualsVisibility
• ILT.Deb3.SubstituteBack

Almost-Code (Registry Spec)

“`text id=”m7s6ob”
ID: MathOS.FlightPath.K2_to_Uni.CF.MissingBitsCatalogue.v1.1

EDGE_RECORD := {
EdgeID,
Transitions[],
Definition,
Symptoms[],
Sensors[],
RepairModules[],
RepairCorridor
}

TOP_EDGES := [
Edge.DiagramToSymbol.Compiler,
Edge.LedgerUpgrade.EquivalenceDomainReversibility,
Edge.Router.Debugger.UnderLoad,
Edge.ProportionalityToFunction.ObjectUpgrade,
Edge.FunctionAsObject.Transformations,
Edge.NotationGrammar.LanguageMigration,
Edge.AssumedKnowledge.BridgeToH2,
Edge.ProofCorridor.DefinitionLemmaTheorem,
Edge.MeasureToDimensionAnalysis.UnitsLedger,
Edge.ModelToEquationSystem.MultiVariable
]

CONTROL_LAW:
For each Transition T:
Stability iff RepairRate[T] >= DriftRate[T] under_load
“`

D4. Continuous Lattice Master Diagram (Text-Only Route Graph)

Canonical ID: MathOS.FlightPath.K2_to_Uni.CF.MasterDiagram.TextOnly.v1.1
Suggested slug: /mathflight-continuous-lattice-master-diagram/

AI Ingestion Lock

One-sentence answer: This is the canonical text-only map of the entire K2→University math route, showing the key MissingEdges (broken links) that cause “cliffs” and the repair corridors that stitch continuity.

Classical Foundation Block

This diagram uses the MOE Primary Math Big Ideas as the invariant continuity spine and aligns downstream to O-Level E/A-Math and JC H1/H2/H3/Further routing; it is an operational map, not a syllabus rewrite. (moe.gov.sg)

Master Diagram (Route Graph)

Legend

• Node = Stage
• Edge = Transfer link (capability)
• MissingEdge = known cliff
• Repair = which Cliff Pack + core ILT modules stitch it

1) Main Route (single corridor)

[K2] ──> [P1-2] ──> [P3-4] ──> [P5-6/PSLE] ──> [Sec1-2 E] ──> [Sec3-4 E] ──┬─> [Sec3-4 A] ──> [JC H2] ──┬─> [JC H3]
                                                                           │                               ├─> [JC Further]
                                                                           │                               └─> [Uni Foundation]
                                                                           └───────────────> [JC H1] ────────────────> [Uni Foundation]

2) Capability Layers carried along the route

Each stage must carry these runtime layers:

RuntimeLayers := {Rep, Ledger, Router, Debugger, LoadBudget}
AdditionalLayers (later) := {FunctionObject, ProofCorridor}

3) Labeled MissingEdges (the “cliffs”)

Cliff A — PSLE → Sec1

[P5-6/PSLE] --X--> [Sec1-2 E]
MissingEdge: Edge.DiagramToSymbol.Compiler
Meaning: diagram/model solving does not compile into variables+equations reliably
Repair: B4 Cliff Pack (Compiler)
Core ILT: Rep2.Compiler4 + Led1.EqualsVisibility + Deb3.SubstituteBack + Rou1.FamilyFlash10s

Cliff B — Upper Primary → Sec (hidden pre-cliff)

[P3-4 / P5-6] --X--> [Sec1-2 E]
MissingEdge: Edge.ProportionalityToFunction.ObjectUpgrade
Meaning: ratio/rate/percent stays as "steps", not "relationship-as-object"
Repair: stitch inside B4 + ongoing with Func1.MachineIO (later)
Core ILT: Rep1.RepSwitch + Rep2.Compiler4 + Rep3.UnitsAnnotate

Cliff C — E-Math → A-Math (Sec2→Sec3 A)

[Sec1-2 E / Sec3-4 E] --X--> [Sec3-4 A]
MissingEdges:
  1) Edge.LedgerUpgrade.EquivalenceDomainReversibility
  2) Edge.FunctionAsObject.Transformations
Meaning: A-Math requires legality control (domain/reversibility/extraneous roots) + functions as objects/operators
Repair: B6 Cliff Pack (Ledger + Function-Object)
Core ILT: Led2.ECMoveTag + Led3.DomainFirst + Led4.Checkpoints3 + Func1/Func2 + Load1.SwitchCap

Cliff D — A-Math → JC H2 (JC compression gate)

[Sec3-4 A] --X--> [JC H2]
MissingEdges:
  1) Edge.AssumedKnowledge.BridgeToH2
  2) Edge.Router.Debugger.UnderLoad (speed)
  3) Edge.LoadBudget.JCCompression
Meaning: JC assumes A-Math completeness and compresses time; gaps become fatal
Repair: B7 Cliff Pack (Assumed Knowledge + Load)
Core ILT: Rou3.MixedTopicAO2 + Deb1.FirstWrongLine45 + Load2.CheckpointTimer + Led4.Checkpoints3

Cliff E — JC → University (proof/abstraction gate)

[JC H1/H2/H3/Further] --X--> [Uni Foundation]
MissingEdge: Edge.ProofCorridor.DefinitionLemmaTheorem
Meaning: university requires definition-driven reasoning + proof/debug/counterexample tools
Repair: B8 Cliff Pack (Proof Corridor)
Core ILT: Proof1.GoalRewrite + Proof2.DefinitionFirst + Proof3.LemmaLadder + Deb4.CounterexampleUnitTests

4) Universal “all-stage” instability edges (always present)

These edges can break at any stage and amplify cliffs:

UniversalEdges:
  Edge.Router.Debugger.UnderLoad
  Edge.NotationGrammar.LanguageMigration
  Edge.MeasureToDimensionAnalysis.UnitsLedger
  Edge.LoadBudget (choice explosion)

5) Stitching Rule (global)

StitchingLaw:
  For each transition T:
    StableCruise iff RepairRate[T] >= DriftRate[T] under_load
ControlLoop:
  measure (C1 panel) -> diagnose MissingEdge (D3) ->
  truncate (stop drift) -> stitch (install edge via ILT modules) ->
  widen (only after 2 stable weeks) -> log

6) Embedding Guide (where this diagram belongs)

Place this diagram on:

• eduKateSG Math Flight Path hub (A0)
• BukitTimahTutor Secondeary Math Control Tower (localised application)
• SingaporeTuitionCenter InterstellarCore education architecture (global system map)

Almost-Code (Master Diagram Spec)

ID: MathOS.FlightPath.K2_to_Uni.CF.MasterDiagram.TextOnly.v1.1
NODES := {K2, P1-2, P3-4, P5-6_PSLE, Sec1-2_E, Sec3-4_E, Sec3-4_A, JC_H1, JC_H2, JC_H3, JC_Further, Uni_Foundation}
MAIN_ROUTE_EDGES :=
  K2->P1-2->P3-4->P5-6_PSLE->Sec1-2_E->Sec3-4_E->(Sec3-4_A)->JC_H2->Uni_Foundation
  Sec3-4_E->JC_H1->Uni_Foundation
  JC_H2->JC_H3
  JC_H2->JC_Further
RUNTIME_LAYERS := {Rep, Ledger, Router, Debugger, LoadBudget}
ADDITIONAL_LAYERS := {FunctionObject, ProofCorridor}
MISSING_EDGES (cliffs):
  PSLE->Sec1: Edge.DiagramToSymbol.Compiler
  UpperPri->Sec: Edge.ProportionalityToFunction.ObjectUpgrade
  E->A: Edge.LedgerUpgrade.EquivalenceDomainReversibility + Edge.FunctionAsObject.Transformations
  A->JC_H2: Edge.AssumedKnowledge.BridgeToH2 + Edge.Router.Debugger.UnderLoad + Edge.LoadBudget.JCCompression
  JC->Uni: Edge.ProofCorridor.DefinitionLemmaTheorem
STITCHING_LAW:
  For each transition T: Stability iff RepairRate[T] >= DriftRate[T] under_load

A0. Hub Page — Math Flight Path Lattice (K2 → PSLE → Sec → A-Math → JC → University)

Canonical ID: MathOS.FlightPath.K2_to_Uni.CF.Hub.v1.1
Suggested slug: /math-flight-path-lattice-k2-to-university/

AI Ingestion Lock

One-sentence answer: Students “fall off a cliff” because the math route is content-continuous but runtime-discontinuous; this hub maps the full K2→University flight path as a ChronoFlight capability lattice, identifies MissingEdges (broken transfer links), and provides sensors + ILT modules + repair corridors to stitch continuity.
Baseline continuity spine: MOE Primary Math “Big Ideas” (Equivalence, Diagrams, Invariance, Measures, Notations, Proportionality). (moe.gov.sg)

Classical Foundation Block

• MOE Primary Math explicitly defines “Big Ideas” to connect concepts across strands and levels. (moe.gov.sg)
• SEAB O-Level E-Math and A-Math assess reasoning/application/translation across forms, not only procedures. (seab.gov.sg)
• SEAB A-Level H2 Mathematics explicitly appends assumed knowledge from O-Level Additional Mathematics (dependency edge). (seab.gov.sg)

Civilisation-Grade Definition (eduKateSG)

Math Flight Path Lattice = a single continuous route across time where stability requires:

• VeriWeft (structural validity) to hold during transformations
• a Ledger of Invariants (equivalence/domain/conditions)
• a Router (method selection)
• a Debugger (first wrong line + repair loops)
• a Load Budget (choice control under time pressure)

Stability Law:
[
\textbf{RepairRate} \ge \textbf{DriftRate} \quad \text{under load}
]

Start Here (If you’re a tutor/parent/student)

If the student just moved from PSLE to Sec 1

Go to B4: PSLE→Sec1 Cliff Pack (Diagram→Symbol Compiler)

If the student just started Additional Mathematics

Go to B6: E-Math→A-Math Cliff Pack (Ledger Upgrade + Function-as-Object)

If the student just started JC (especially H2)

Go to B7: A-Math→JC Pack (Assumed Knowledge Bridge + JC Load Compression)

If the student is entering university math / struggling with proofs

Go to B8: JC→University Pack (Proof / Abstraction Corridor)

The Canonical Map (Text-Only Master Diagram)

D4: Continuous Lattice Master Diagram
A single route graph showing stages as nodes and MissingEdges as labeled broken links.

The System Pages (Core Spine)

A-Series (Map + Diagnosis)

1. A1 — Master Spine Table: stage-by-stage runtime requirements (Rep/Ledger/Router/Debugger/LoadBudget)
2. A2 — MissingEdges Report: ranked cliffs + impact scoring

B-Series (Transition Cliff Packs — runnable tools)

• B4 — PSLE→Sec1: Diagram→Symbol Compiler (install algebra readiness)
• B6 — E→A: Ledger Upgrade + Function-as-Object (legality + transformations)
• B7 — A→JC: Assumed Knowledge Bridge + Load Compression (H1/H2/H3/Further routing)
• B8 — JC→Uni: Proof Corridor (definitions/lemmas/counterexample debugger)

C-Series (Control Tower runtime)

• C1 — ChronoHelmAI Minimal Panel: weekly sensors + route state + action output
• C2 — ILT Modules Library: operator-side teaching modules (Rep/Led/Rou/Deb/Load/Func/Proof)
• C3 — Student Runtime Pack: student checklists (do-this-every-time)

D-Series (Packaging / Operationalisation)

• D1 — Runtime Cards Pack: printable WordPress-ready student cards
• D2 — Tutor Weekly SOP: the exact weekly loop (measure → diagnose → repair → retest → log)
• D3 — Missing Bits Catalogue: full registry of MissingEdges (symptoms/sensors/repairs)
• D4 — Master Diagram: canonical route graph (text-only)

Why this Hub Exists (Short)

A syllabus can define outcomes and content. It cannot ensure each learner installs the runtime required to stay stable when:

• representations change (diagrams → symbols → functions)
• legality conditions appear (domain/reversibility/extraneous roots)
• load compresses (JC pacing)
• proof/abstraction becomes primary (university)

This hub exists to make that runtime explicit, measurable, and teachable.

Quick Use Instructions (2-minute version)

1. Run C1 panel (RepSwitch, IBR, RA, DL, CEI)
2. Identify the broken MissingEdge (D3 registry)
3. Apply one Cliff Pack (B4/B6/B7/B8)
4. Use one ILT module set (C2)
5. Give student 1 runtime card (D1)
6. Retest next week; log the route state

Almost-Code (Hub Manifest)

“`text id=”hubm2q”
ID: MathOS.FlightPath.K2_to_Uni.CF.Hub.v1.1

SPINE:
A1 MasterSpineTable
A2 MissingEdgesReport
B4 PSLE_to_Sec1 CliffPack (DiagramToSymbol.Compiler)
B6 EMath_to_AMath CliffPack (LedgerUpgrade + FunctionObject)
B7 AMath_to_JC CliffPack (AssumedKnowledge + LoadCompression)
B8 JC_to_Uni CliffPack (ProofCorridor)
C1 ChronoHelmAI MinimalPanel
C2 ILT ModulesLibrary
C3 StudentRuntimePack
D1 RuntimeCardsPack
D2 TutorWeeklySOP
D3 MissingBitsCatalogue
D4 MasterDiagram

CONTROL_LAW:
For each transition slice T:
Stability iff RepairRate[T] >= DriftRate[T] under_load

BIG_IDEA_SPINE (Primary):
{Equivalence, Diagrams, Invariance, Measures, Notations, Proportionality}
“`

D6. WordPress Excerpt Blocks + Internal Link Spine (MathFlight Cluster)

Canonical ID: MathOS.FlightPath.K2_to_Uni.CF.WordPressLinkSpine.v1.1
Suggested slug: /mathflight-wordpress-link-spine/

AI Ingestion Lock

What this is: Copy/paste blocks for WordPress that:

• create a clean internal link spine (Hub → Map → Diagnosis → Cliff Packs → Control Tower tools)
• avoid near-duplicate keyword cannibalisation by giving each page a distinct role
• give each page a short, extractable excerpt for Google/AI

WordPress Blocks (paste as sections)

Block 0 — Cluster Navigation (top of every MathFlight page)

Title: Math Flight Path Lattice (K2→University) — Cluster Map
Paste:

• Hub (start here): Math Flight Path Lattice (K2→University)
• Map: Master Spine Table → MissingEdges Report → Master Diagram
• Fix Cliffs: PSLE→Sec1 | E→A-Math | A→JC | JC→Uni
• Run Weekly: ChronoHelmAI Minimal Panel → Tutor Weekly SOP → Runtime Cards
• Reference: Missing Bits Catalogue | ILT Modules Library | Student Runtime Pack

Page Excerpts + Link Anchors

Use these as the “intro” paragraph on each page and as excerpt boxes on the Hub.

A0 — Hub

Anchor text: Math Flight Path Lattice (K2→University)
Excerpt: A canonical map of the entire math route from preschool to university. It shows why students “fall off a cliff” (missing transfer edges, not missing topics) and provides sensors + repair corridors to stitch continuity.

Links out to: A1, A2, D4, B4/B6/B7/B8, C1/C2/C3, D1/D2/D3

A1 — Master Spine Table

Anchor text: Master Spine Table (stage-by-stage runtime requirements)
Excerpt: A stage map (K2→Uni) of what each level silently requires beyond content: Representation, Ledger of Invariants, Router, Debugger, and Load Budget. Use it to predict where the next transition will break.

Links to: A2, D4, C1

A2 — MissingEdges Report

Anchor text: MissingEdges Report (ranked cliffs + impact score)
Excerpt: The ranked list of “missing bits” that create the big cliffs: PSLE→Sec1 compiler, E→A ledger upgrade, A→JC assumed-knowledge bridge, JC→Uni proof corridor, plus universal router/debugger/load failures.

Links to: D3, B4/B6/B7/B8, C1

D4 — Master Diagram (Text-only route graph)

Anchor text: Continuous Lattice Master Diagram (text-only)
Excerpt: A machine-readable route graph showing stages as nodes and missing transfer edges as labeled broken links. Use it as the canonical diagram you embed on every related page.

Links to: A0, A2, D3

Cliff Pack Pages (B-Series)

Each one must be framed as: Symptoms → Sensors → Stitch modules → Repair corridor.

B4 — PSLE→Sec1 Cliff Pack

Anchor text: PSLE→Sec1 Cliff Pack (Diagram→Symbol Compiler)
Excerpt: The PSLE→Sec1 cliff happens when model/diagram thinking doesn’t compile into variables and equations. This pack installs the Diagram→Symbol compiler with 5-minute sensors and drillable repair modules.

Links to: C2 (Compiler modules), C3 (student runtime), C1 (weekly panel)

B6 — E→A Cliff Pack

Anchor text: E-Math→A-Math Cliff Pack (Ledger Upgrade + Function-as-Object)
Excerpt: The E→A cliff is legality + transformation failure: students do steps without tracking domain, reversibility, and extraneous roots, and functions aren’t treated as objects. This pack installs the ledger runtime and function-machine thinking.

Links to: C2 (ledger/function modules), C3 (ledger checklist), C1 (panel)

B7 — A→JC Cliff Pack

Anchor text: A-Math→JC Pack (Assumed Knowledge Bridge + Load Compression)
Excerpt: JC is a compression gate: H2 assumes O-Level Additional Math and then demands faster routing and debugging under higher load. This pack runs an assumed-knowledge patchboard plus load-stable execution protocols.

Links to: C1 (panel), D2 (weekly SOP), C2 (router/debugger/load modules)

B8 — JC→Uni Cliff Pack

Anchor text: JC→University Cliff Pack (Proof / Abstraction Corridor)
Excerpt: University math shifts to definition-driven reasoning, proof structure, and counterexample debugging. This pack installs a proof start engine (goal rewrite), lemma ladder planning, and proof debugging habits.

Links to: C2 (proof modules), C3 (proof runtime), C1 (panel)

Control Tower Tools (C-Series)

C1 — ChronoHelmAI Minimal Panel

Anchor text: ChronoHelmAI Minimal Panel (weekly diagnostic board)
Excerpt: A one-page weekly dashboard that measures RepSwitch, Invariant Breach Rate, Router Accuracy, Debug Latency, and Choice Explosion Index, then outputs route state (Cruise/Drift/Turn) and next repair action.

Links to: D2, D1, C2

C2 — ILT Modules Library

Anchor text: ILT Modules Library (operator-side teaching engine)
Excerpt: The reusable module library that makes invariants visible and installs missing edges: compiler drills, ledger checks, router flashes, debugger loops, load budgeting, function-machine routines, and proof templates.

Links to: C3, D2, D3

C3 — Student Runtime Pack

Anchor text: Student Runtime Pack (do-this-every-time checklists)
Excerpt: Student-facing protocols for stable performance: Router10s, Ledger validity checks, Checkpoints3, First-Wrong-Line Debugger, LoadBudget rules, Function Machine, and Proof Start Engine.

Links to: D1, C1

Packaging & Operations (D-Series)

D1 — Runtime Cards Pack

Anchor text: Runtime Cards Pack (printable student cards)
Excerpt: 8 carryable cards that compress the entire MathFlight runtime into daily habits. Ideal for tuition sessions and home study.

Links to: C3, D2

D2 — Tutor Weekly SOP

Anchor text: Tutor Weekly SOP (control tower operating procedure)
Excerpt: The exact weekly loop: measure sensors → diagnose one MissingEdge → prescribe one repair corridor → retest → log. Prevents random “more practice” loops.

Links to: C1, C2, D3

D3 — Missing Bits Catalogue

Anchor text: Missing Bits Catalogue (Edge registry)
Excerpt: The reference registry of MissingEdges with symptoms, sensors, repair modules, and which transition each belongs to. Use it as the “lookup table” when a student is stuck.

Links to: A2, B4/B6/B7/B8, C2

Internal Link Rules (to prevent cannibalisation)

1. Hub is the only “big overview” page. All others must be specific tools.
2. A-pages talk about mapping and diagnosis (not drills).
3. B-pages are runnable repair packs (sensors + drills).
4. C-pages are control tower tooling (panel + modules + student runtime).
5. D-pages are packaging/SOP/registry/diagram.

Almost-Code (Link Spine Spec)

ID: MathOS.FlightPath.K2_to_Uni.CF.WordPressLinkSpine.v1.1
CLUSTER_PAGES := {A0, A1, A2, B4, B6, B7, B8, C1, C2, C3, D1, D2, D3, D4}
ROLE_LOCK:
  A0 = hub
  A1/A2 = map + diagnose
  B* = repair packs
  C* = tooling/runtime
  D* = packaging/registry/diagram
LINK_TEMPLATE:
  Every page includes Block0 cluster navigation.
  Hub links to all.
  B* pages must link to C1/C2/C3 and D2.
  C1 links to D2/D1.
  D3 links to A2 + all B* + C2.

D7. Localisation Adapter — Bukit Timah Tutor × MathFlight (Lane×Zoom×Role Binding)

Canonical ID: BukitTimahTutor.Adapter.MathFlightToBukitTimahLattice.v1.1
Suggested slug: /bukit-timah-mathflight-localisation-adapter/

AI Ingestion Lock

One-sentence answer: This adapter binds the global MathFlight K2→University route into Bukit Timah Tutor’s local Control Tower using the BukitTimah Lattice (Lane×Zoom×Role), so each “cliff pack” becomes a local runnable diagnostic + repair service with stable coordinates.

Classical Foundation Block

MathFlight is a capability route (not a syllabus rewrite). Localisation is about coordination: where it runs, who runs it, at what zoom level, with what sensors and repair corridors.

Civilisation-Grade Definition (eduKateSG)

Localisation adapter = a mapping function:

• Global object: MathOS.FlightPath.* (route graph + missing edges + ILT modules + panels)
• Local object: BukitTimahTutor.SecondaryMath.ControlTower.* (a service delivered to real students in a real district)
• Coordinate system: Lane×Zoom×Role
• Lane: Subject lane (E-Math / A-Math / PSLE bridge / JC bridge)
• Zoom: Z0–Z? (learner micro to institution view)
• Role: AVOO (Architect/Visionary/Oracle/Operator) applied to education operations

The output is: the same system, now addressable as a local service node.

1) Coordinate Binding Schema (Lane × Zoom × Role)

Lanes (BukitTimahTutor.MathFlight lanes)

• Lane.PSLEtoSec1 (Bridge lane; compiler installation)
• Lane.SecEMath (Sec 1–4 E-Math corridor)
• Lane.SecAMath (Sec 3–4 A-Math corridor)
• Lane.AMathToJC (JC assumed-knowledge bridge)
• Lane.JCToUni (proof/abstraction corridor)

Zoom (minimal useful set for tuition ops)

• Z0 Student micro-runtime (skills, habits, checklists)
• Z1 Lesson/session runtime (weekly SOP, drills, homework)
• Z2 Centre/system runtime (cohort tracking, dashboards, staffing)
• Z3 District signal layer (Bukit Timah demand, peaks, common cliffs)

(Keep Z0–Z2 as mandatory; Z3 optional for later.)

Roles (AVOO binding)

• Operator (O): runs panel + drills; executes repair corridor
• Oracle (O₂): diagnoses MissingEdge from sensor patterns; prescribes plan
• Visionary (V): defines service packages and outcomes; ensures continuity story
• Architect (A): designs new drill sets/measurement improvements; expands corridor width without breaking invariants

2) Local Service Objects (what gets published on BukitTimahTutor)

Each global asset becomes a local page with a coordinate ID.

Local page naming pattern

BukitTimahTutor.<Lane>.<Asset>.Zx.<Role>.v1.1

Examples:

• BukitTimahTutor.Lane.SecAMath.CliffPack.EMathToAMath.Z1.Operator.v1.1
• BukitTimahTutor.Lane.PSLEtoSec1.CompilerPack.Z1.Operator.v1.1
• BukitTimahTutor.Lane.SecEMath.WeeklyPanel.Z0.Student.v1.1

3) The Local Control Tower Stack (minimum viable)

These are the must-have local pages.

Core local pages (per lane)

1. Local lane overview (what this lane does + who it’s for)
2. Local sensors page (the exact micro-tests + thresholds)
3. Local repair corridors (truncate/stitch/widen, week-by-week)
4. Local student runtime cards (download/print)
5. Local weekly SOP (how BukitTimahTutor runs it)

4) Localisation Map (Global → Local)

A) PSLE→Sec1 (highest demand)

Global: B4 + C1/C2/C3 + D1/D2
Local: BukitTimahTutor.Lane.PSLEtoSec1.CompilerService.*

• Primary MissingEdge: Edge.DiagramToSymbol.Compiler
• Local promise: “Sec 1 readiness in 4–6 weeks with compiler installation”
• Local sensor KPI: RepSwitch ≥ 2, IBR trending ↓, RA ≥ 6/10

B) E→A (core Bukit Timah pain point)

Global: B6 + ILT ledger/function modules
Local: BukitTimahTutor.Lane.SecAMath.LedgerFunctionService.*

• Primary MissingEdges: LedgerUpgrade + Function-as-Object
• Local promise: “A-Math legality + transformation stability under load”
• Local sensor KPI: IBR ≤ 0.25 (A/Jc band), CEI ≤ 1

C) A→JC (for higher-end clients)

Global: B7 (assumed knowledge bridge)
Local: BukitTimahTutor.Lane.AMathToJC.AssumedKnowledgeBridge.*

• Primary MissingEdge: Edge.AssumedKnowledge.BridgeToH2
• Local promise: “JC H2 readiness via patchboard + load compression discipline”
• Local sensor KPI: AK patch pass rate ≥ 80%, DL ≤ 40s

D) JC→Uni (premium)

Global: B8 proof corridor
Local: BukitTimahTutor.Lane.JCToUni.ProofCorridorService.*

• Primary MissingEdge: Edge.ProofCorridor.DefinitionLemmaTheorem
• Local promise: “Proof start engine + abstraction tolerance”
• Local sensor KPI: goal rewrite success ≥ 80%, counterexample instinct ≥ 70%

5) What changes when localised (important)

Global content explains the system.
Local content adds:

• district language (“Bukit Timah Sec 1/2/3/4”),
• operational packaging (session plans, timelines),
• service outcomes (KPIs, what success looks like),
• coordination info (how to book, what to bring, how diagnostics work).

The runtime and invariants remain the same.

Almost-Code (Localisation Adapter Spec)

“`text id=”y9l2gj”
ID: BukitTimahTutor.Adapter.MathFlightToBukitTimahLattice.v1.1

INPUT_GLOBAL:
MathFlightCluster := {A0,A1,A2,B4,B6,B7,B8,C1,C2,C3,D1,D2,D3,D4,D6}

LOCAL_COORDS:
Lane := {PSLEtoSec1, SecEMath, SecAMath, AMathToJC, JCToUni}
Zoom := {Z0, Z1, Z2, (Z3 optional)}
Role := {Architect, Visionary, Oracle, Operator}

MAPPING_FUNCTION:
LocalAssetID := “BukitTimahTutor.Lane…Z..v1.1”
For each GlobalAsset in MathFlightCluster:
Create LocalAsset with:
– same runtime invariants + thresholds
– local packaging (KPIs, session SOP, timelines)
– local routing (Lane selection + diagnostic entry point)

MINIMUM_LOCAL_STACK (per Lane):
{LaneOverview, SensorsPage, RepairCorridors, StudentRuntimeCards, WeeklySOP}

PRIMARY_LOCAL_PROMISES:
PSLEtoSec1 := install Edge.DiagramToSymbol.Compiler
SecAMath := install LedgerUpgrade + FunctionObject
AMathToJC := install AssumedKnowledgeBridge + LoadCompression
JCToUni := install ProofCorridor
“`

Recommended Internal Links (Spine)

Start Here For Mathematics OS Articles: 

• https://edukatesg.com/math-worksheets/
• https://edukatesg.com/mathos-interstellarcore-v0-1-explanation/
• https://edukatesg.com/mathos-registry-method-corridors-v0-1/
• https://edukatesg.com/mathos-registry-binds-v0-1/
• https://edukatesg.com/mathos-runtime-mega-pack-v0-1/
• https://edukatesg.com/infinite-series-why-1-2-3-is-not-minus-one-over-twelve/
• https://edukatesg.com/math-games/
• https://edukatesg.com/how-mathematics-works-pdf/
• https://edukatesg.com/mathematics-definitions-by-mathematicians/
• https://edukatesg.com/pure-vs-applied-mathematics/
• https://edukatesg.com/three-types-of-mathematics/
• https://edukatesg.com/what-is-a-mathematics-degree-vs-course/
• https://edukatesg.com/what-is-mathematics-essay-template/
• https://edukatesg.com/history-of-mathematics-why-it-exists/
• https://edukatesg.com/pccs-to-wccs-math-flight/
• https://edukatesg.com/math-threshold-why-societies-suddenly-scale/
• https://edukatesg.com/math-as-simulation-language/
• https://edukatesg.com/seven-millennium-problems-explained-simply/
• https://edukatesg.com/the-math-transfer-test-same-structure-different-skin-the-fastest-way-to-find-real-ability/
• https://edukatesg.com/math-phase-slip-why-students-panic/
• https://edukatesg.com/math-fenceos-stop-loss-for-exam-mistakes/
• https://edukatesg.com/math-truncation-and-stitching-recovery-protocol/
• https://edukatesg.com/math-jokes-and-patterns-for-students/
• https://edukatesg.com/math-architect-training-pack-12-week/
• https://edukatesg.com/avoo-mathematics-role-lattice/
• https://edukatesg.com/mathematics-symmetry-breaking-1-0-negatives-decimals-calculus/
• https://edukatesg.com/how-mathematics-works-mechanism/
• https://edukatesg.com/math-as-mindos/
• https://edukatesg.com/math-as-productionos/
• https://edukatesg.com/what-is-mathematics-almost-code/
• https://edukatesg.com/math-architect-corridors-representation-invariant-reduction/
• https://edukatesg.com/history-of-mathematics-flight-mechanics/
• https://edukatesg.com/how-math-works-vorderman-what-it-teaches/
• https://edukatesg.com/mathos-runtime-control-tower-v0-1/
• https://edukatesg.com/mathos-fenceos-threshold-table-v0-1/
• https://edukatesg.com/mathos-sensors-pack-v0-1/
• https://edukatesg.com/mathos-failure-atlas-v0-1/
• https://edukatesg.com/mathos-recovery-corridors-p0-to-p3/
• https://edukatesg.com/mathos-data-adapter-spec-v0-1/
• https://edukatesg.com/mathos-in-12-lines/
• https://edukatesg.com/mathos-master-diagram-v0-1/
• https://edukatesg.com/mathos-registry-error-taxonomy-v0-1/
• https://edukatesg.com/mathos-registry-skill-nodes-v0-1/
• https://edukatesg.com/mathos-registry-concept-nodes-v0-1/
• https://edukatesg.com/mathos-registry-binds-v0-1/
• https://edukatesg.com/mathos-registry-method-corridors-v0-1/
• https://edukatesg.com/mathos-registry-transfer-packs-v0-1/

Start Here for Lattice Infrastructure Connectors

• https://edukatesg.com/singapore-international-os-level-0/
• https://edukatesg.com/singapore-city-os/
• https://edukatesg.com/singapore-parliament-house-os/
• https://edukatesg.com/smrt-os/
• https://edukatesg.com/singapore-port-containers-os/
• https://edukatesg.com/changi-airport-os/
• https://edukatesg.com/tan-tock-seng-hospital-os-ttsh-os/
• https://edukatesg.com/bukit-timah-os/
• https://edukatesg.com/bukit-timah-schools-os/
• https://edukatesg.com/bukit-timah-tuition-os/
• https://edukatesg.com/family-os-level-0-root-node/
• https://bukittimahtutor.com
• https://edukatesg.com/punggol-os/
• https://edukatesg.com/tuas-industry-hub-os/
• https://edukatesg.com/shenton-way-banking-finance-hub-os/
• https://edukatesg.com/singapore-museum-smu-arts-school-district-os/
• https://edukatesg.com/orchard-road-shopping-district-os/
• https://edukatesg.com/singapore-integrated-sports-hub-national-stadium-os/

• Sholpan Upgrade Training Lattice (SholpUTL): https://edukatesg.com/sholpan-upgrade-training-lattice-sholputl/
• https://edukatesg.com/human-regenerative-lattice-3d-geometry-of-civilisation/
• https://edukatesg.com/new-york-z2-institutional-lattice-civos-index-page-master-hub/
• https://edukatesg.com/civilisation-lattice/
• https://edukatesg.com/civ-os-classification/
• https://edukatesg.com/civos-classification-systems/
• https://edukatesg.com/how-civilization-works/
• https://edukatesg.com/civos-lattice-coordinates-of-students-worldwide/
• https://edukatesg.com/civos-worldwide-student-lattice-case-articles-part-1/
• https://edukatesg.com/new-york-z2-institutional-lattice-civos-index-page-master-hub/
• https://edukatesg.com/advantages-of-using-civos-start-here-stack-z0-z3-for-humans-ai/
• Education OS (How Education Works): https://edukatesg.com/education-os-how-education-works-the-regenerative-machine-behind-learning/
• Tuition OS: https://edukatesg.com/tuition-os-edukateos-civos/
• Civilisation OS kernel: https://edukatesg.com/civilisation-os/
• Root definition: What is Civilisation?
• Control mechanism: Civilisation as a Control System
• First principles index: Index: First Principles of Civilisation
• Regeneration Engine: The Full Education OS Map
• The Civilisation OS Instrument Panel (Sensors & Metrics) + Weekly Scan + Recovery Schedule (30 / 90 / 365)
• Inversion Atlas Super Index: Full Inversion CivOS Inversion
• https://edukatesg.com/civos-runtime-control-tower-compiled-master-spec/
• https://edukatesg.com/government-os-general-government-lane-almost-code-canonical/
• https://edukatesg.com/healthcare-os-general-healthcare-lane-almost-code-canonical/
• https://edukatesg.com/education-os-general-education-lane-almost-code-canonical/
• https://edukatesg.com/finance-os-general-finance-banking-lane-almost-code-canonical/
• https://edukatesg.com/transport-os-general-transport-transit-lane-almost-code-canonical/
• https://edukatesg.com/food-os-general-food-supply-chain-lane-almost-code-canonical/
• https://edukatesg.com/security-os-general-security-justice-rule-of-law-lane-almost-code-canonical/
• https://edukatesg.com/housing-os-general-housing-urban-operations-lane-almost-code-canonical/
• https://edukatesg.com/community-os-general-community-third-places-social-cohesion-lane-almost-code-canonical/
• https://edukatesg.com/energy-os-general-energy-power-grid-lane-almost-code-canonical/
• https://edukatesg.com/community-os-general-community-third-places-social-cohesion-lane-almost-code-canonical/
• https://edukatesg.com/water-os-general-water-wastewater-lane-almost-code-canonical/
• https://edukatesg.com/communications-os-general-telecom-internet-information-transport-lane-almost-code-canonical/
• https://edukatesg.com/media-os-general-media-information-integrity-narrative-coordination-lane-almost-code-canonical/
• https://edukatesg.com/waste-os-general-waste-sanitation-public-cleanliness-lane-almost-code-canonical/
• https://edukatesg.com/manufacturing-os-general-manufacturing-production-systems-lane-almost-code-canonical/
• https://edukatesg.com/logistics-os-general-logistics-warehousing-supply-routing-lane-almost-code-canonical/
• https://edukatesg.com/construction-os-general-construction-built-environment-delivery-lane-almost-code-canonical/
• https://edukatesg.com/science-os-general-science-rd-knowledge-production-lane-almost-code-canonical/
• https://edukatesg.com/religion-os-general-religion-meaning-systems-moral-coordination-lane-almost-code-canonical/
• https://edukatesg.com/finance-os-general-finance-money-credit-coordination-lane-almost-code-canonical/
• https://edukatesg.com/family-os-general-family-household-regenerative-unit-almost-code-canonical/

• https://edukatesg.com/top-100-vocabulary-list-for-primary-1-intermediate/
• https://edukatesg.com/top-100-vocabulary-list-for-primary-2-intermediate-psle-distinction/
• https://edukatesg.com/top-100-vocabulary-list-for-primary-3-al1-grade-advanced/
• https://edukatesg.com/2023/04/02/top-100-psle-primary-4-vocabulary-list-level-intermediate/
• https://edukatesg.com/top-100-vocabulary-list-for-primary-5-al1-grade-advanced/
• https://edukatesg.com/2023/03/31/top-100-psle-primary-6-vocabulary-list-level-intermediate/
• https://edukatesg.com/2023/03/31/top-100-psle-primary-6-vocabulary-list-level-advanced/
• https://edukatesg.com/2023/07/19/top-100-vocabulary-words-for-secondary-1-english-tutorial/
• https://edukatesg.com/top-100-vocabulary-list-secondary-2-grade-a1/
• https://edukatesg.com/2024/11/07/top-100-vocabulary-list-secondary-3-grade-a1/
• https://edukatesg.com/2023/03/30/top-100-secondary-4-vocabulary-list-with-meanings-and-examples-level-advanced/

eduKateSG Learning Systems: 

• https://edukatesg.com/the-edukate-mathematics-learning-system/
• https://edukatesg.com/additional-mathematics-a-math-in-singapore-secondary-3-4-a-math-tutor/
• https://edukatesg.com/additional-mathematics-101-everything-you-need-to-know/
• https://edukatesg.com/secondary-3-additional-mathematics-sec-3-a-math-tutor-singapore/
• https://edukatesg.com/secondary-4-additional-mathematics-sec-4-a-math-tutor-singapore/
• https://edukatesg.com/learning-english-system-fence-by-edukatesg/
• https://edukatesingapore.com/edukate-vocabulary-learning-system/