ControlTower.Sec1MathTuition v1.0

Type: Runtime / Diagnostic Board / Control Loop Spec
Domain: EducationOS × MathOS (Sec 1)
Scale: Human (Z0–Z2) + Centre Ops (Z2)
Phase: Student P0–P3 routing (with cohort overlay)
ChronoFlight Lens: Structure × Phase × Time (weekly slices; exam nodes)

0) Canonical Framing Box

Purpose: Run Secondary 1 Math tuition as a Phase-3 corridor: detect drift early, prevent cliff-falls, repair fast, widen mastery corridor, preserve continuity into Sec 2 / E-Math / A-Math readiness.

Runtime Inheritance (Compiled Layer):
Lattice Bands (+/0/−) → VeriWeft (structural admissibility) → Invariant Ledger (what must remain true) → ChronoFlight (time axis) → Corridor Stack (repair routing) → FENCE/ERCO (control discipline) → ILT (teaching engine)

1) Classical Foundation

Mathematics (baseline): a system of valid transformations governed by invariants (e.g., equivalence, conservation under operations, unit consistency).
Tuition (baseline): a local repair and transfer engine: it converts hidden misconceptions into visible breaches, repairs them, and restores transfer under load.

2) Civilisation-Grade Definition (Local Form)

Control Tower (Sec 1 Math Tuition):
A bounded operational system that:

Senses student state + misconception breaches,
Classifies into lattice bands (+ / 0 / −),
Routes repairs via a small set of interventions,
Verifies repair under load,
Logs outcomes into a ledger to prevent recurrence.

3) Unified Envelope Grammar

3.1 Entities

S = Student
C = Cohort/Class
T = Tutor (Operator)
A = Architect (curriculum / sequencing)
R = Registry (topics, skills, error taxonomy, interventions)

3.2 Student State (time-sliced)

X_S(k) = { P, M, L, B, TC, Ret, Tr, Err, ConfGap, τ_node }

Where:

P = phase {P0, P1, P2, P3}
M = mastery vector per topic
L = load (task difficulty × speed pressure)
B = buffer (sleep/attention/confidence bandwidth proxy)
TC = truth clarity (signal/noise of understanding)
Ret = retention (days later)
Tr = transfer (new question types)
Err = error signature distribution
ConfGap = confidence − accuracy
τ_node = time-to-next assessment node (compression indicator)

4) Lattice Band Classification (per student, per topic)

4.1 Core inequalities

Define thresholds: θ_TC, θ_Ret, θ_Tr, θ_A, θ_Speed

+Latt (Stable / P3 corridor) if:

TC ≥ θ_TC AND Ret ≥ θ_Ret AND Tr ≥ θ_Tr
errors are rare + non-systematic
can solve under moderate load without collapse

0Latt (Boundary / P1–P2) if:

understands with prompts, or works only in familiar templates
retention/transfer unstable, speed collapses under load

−Latt (Below corridor / P0–P1) if any:

repeated invariant breaches (same misconception)
Tr < θ_Tr OR Ret < θ_Ret
load causes rapid breakdown (time, panic, random algebra)

4.2 Phase mapping (simple)

P0: cannot reliably preserve invariants; frequent structural breaks
P1: can do fragments; inconsistent; depends on tutor scaffolding
P2: stable on trained forms; fragile under novelty/load
P3: stable under novelty; self-repair improves; corridor widened

5) One-Page Diagnostic Board (Minimum Panels)

Panel A — Student Flight Status (top row)

For each student:

P (phase), +0− band per current unit
τ_node (days to next test)
RiskFlag = {Green, Amber, Red}

Panel B — Invariant Ledger Breach Map (the core)

Track breaches as named invariants (not “careless”):

Inv-ALG-01: equivalence preservation (doing same to both sides)
Inv-NUM-01: place value / integer sign consistency
Inv-FRA-01: fraction meaning (part–whole / operator)
Inv-UNI-01: unit/quantity consistency in word problems
Inv-RAT-01: ratio as multiplicative structure (not additive)

Each breach logs:
{InvariantID, TriggerQuestionID, ErrorType, FixProtocolID, VerifyDate}

Panel C — Error Taxonomy Distribution (fast triage)

E1: Misread / language parse
E2: Wrong operation choice (model error)
E3: Algebraic manipulation break
E4: Arithmetic fluency load collapse
E5: Diagram/visualization missing
E6: Memory/recall hole (forgot rule, not concept)

Panel D — Repair Queue (Top 5 per student)

Each item:
{BreachID → FixProtocol → DrillSet → TransferTest → RetentionCheck}

Panel E — Cohort Correlated Failure (centre ops)

Top 3 invariant breaches across class
Which topic nodes are “shearing” (many students at 0/−)

6) Sensor Pack (Sec 1)

S1 Accuracy: % correct by difficulty band
S2 Latency: time-to-first-correct (proxy for fluency/buffer)
S3 Hint Dependence: prompts needed / question
S4 Transfer: performance on unseen structures
S5 Retention: same skill after 7–14 days
S6 Load Collapse: accuracy drop when timed
S7 ConfGap: confidence vs accuracy mismatch
S8 Misconception Recurrence: same invariant breach repeats

7) Three Collapse Modes Only (per consolidation discipline)

Mode 1 — Drift (silent decay)

Looks “okay” on homework, fails on mixed/novel tests
Sensor signature: Ret↓, Tr↓, ConfGap↑

Mode 2 — Shear (topic mixing breaks structure)

When algebra meets arithmetic/ratio/word problems, structure tears
Signature: Err shifts from E6 to E2/E3, TC↓ under mix

Mode 3 — Rupture (node compression crash)

Near test nodes, time pressure collapses buffer
Signature: τ_node→0, Latency↑, LoadCollapse↑, panic errors

8) Repair Corridor (Standard Loop)

Detect → Name breach (InvariantID) → Truncate noise → Stitch core → Verify under load → Log

Repair protocols (library style)

Each protocol must define:

FixProtocolID
Target Invariant
Minimal Explanation
Worked Examples (2)
Anti-Examples (2)
Drill Set (10)
Transfer Test (3)
Retention Check (7–14 days)

9) ILT Integration (Operator-side)

ILT modules used inside Sec 1 Math:

Invariant Spotlight: “what must remain true” per transformation
Ledger Replay: show breach → correction → re-verify
Reconciliation Prompt: student explains invariant in 1 sentence
Breach Alarm: same invariant fails twice → forced repair block

10) Operating Cadence (Weekly Runtime)

Week Cycle

PreCheck (10 min) — mini diagnostic (transfer + timed micro)
Classify — update band (+/0/−) + phase estimate
Teach (ILT) — invariants made visible during new content
Repair Block (20–30 min) — top 1–2 breach protocols
Verify — timed + novel question
Log — ledger update + next-week routing

11) Minimal Registry Set (so it’s runnable)

You only need these 5 registries to start:

Student Registry: {StudentID, baseline, goals, phase}
Topic Registry: {TopicID, prerequisites, invariants}
Invariant Registry: {InvariantID, definition, breach signatures}
Question Registry: {QID, topic tags, invariant tags, difficulty}
Fix Protocol Registry: {FixProtocolID, steps, verify tests}

12) Output Artifacts (what the Control Tower produces)

StudentFlightLog (weekly)
InvariantLedger (living)
RepairQueue (next actions)
Parent Report (2-layer)
Layer 1: phase + band + next risks
Layer 2: top breaches + what you’re fixing + proof of repair

13) Quickstart (to deploy in a tuition centre fast)

Start with just 1 class + 1 spreadsheet:

Sheet 1: Students + Phase + Band
Sheet 2: Invariant Breaches log
Sheet 3: Fix Protocol library (links)
Sheet 4: Weekly diagnostic results (Accuracy/Latency/Transfer)

Then scale into dashboards later.

			
# ControlTower.OnePanel.Sec1Math v1.0
META:
  UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
  Domain: EducationOS × MathOS
  Scope: Secondary 1 Mathematics Tuition
  Scale: Human(Z0–Z2) + CentreOps(Z2)
  Phase: P0–P3
  ChronoFlight: Structure × Phase × Time (weekly slices; test-nodes)
  OutputType: Printable Operator Board + Spreadsheet Schema
CONTRACT:
  Goal:
    Run Sec 1 Math as a Phase-3 corridor by (1) sensing drift, (2) naming invariant breaches,
    (3) routing repairs, (4) verifying under load, (5) logging to prevent recurrence.
  NonGoals:
    Not a syllabus rewrite. Not a “more practice” engine. Not a motivation essay.
  SuccessCondition:
    Retention + transfer stable under timed/mixed load; misconception recurrence trends to zero.
DEFINITIONS:
  Band ∈ {+Latt, 0Latt, -Latt}
  Phase P ∈ {P0, P1, P2, P3}
  τ_node = days to next node (quiz/test/exam)
  TC = TruthClarity ≈ Signal/(Signal+Noise) for understanding
  LoadCollapse = accuracy drop when time pressure increases
  ConfGap = confidence − accuracy (risk if high)
ONE_PANEL (per student, per week):
  HEADER:
    StudentID:
    WeekNo:
    CurrentUnit/Topic:
    τ_node(days):
    TutorID:
  FLIGHT_STATUS:
    Phase(P):
    Band(+/0/−):
    RiskFlag(Green/Amber/Red):
    Notes(1 line):
  SENSOR_SNAPSHOT (5-minute view):
    S1_Accuracy(%):            # mixed set
    S2_Latency(sec/q):         # median time per question
    S3_HintDependence(0-3):
    S4_Transfer(%):            # unseen structures
    S5_Retention(%):           # last-week skill recheck
    S6_LoadCollapse(%drop):
    S7_ConfGap(+/-):
    S8_Recurrence(count):      # repeated same invariant breach
  INVARIANT_LEDGER_TOP3 (name breaches, not “careless”):
    - Breach1: {InvariantID, Signature, TriggerQID, ErrorType(E1–E6)}
    - Breach2: {InvariantID, Signature, TriggerQID, ErrorType(E1–E6)}
    - Breach3: {InvariantID, Signature, TriggerQID, ErrorType(E1–E6)}
  REPAIR_QUEUE (next actions, max 2 for the week):
    RepairA:
      FixProtocolID:
      MicroLesson(≤5 min):
      DrillSetID(10 items):
      TransferTestID(3 items):
      RetentionCheckDate(+7d):
    RepairB:
      FixProtocolID:
      MicroLesson(≤5 min):
      DrillSetID(10 items):
      TransferTestID(3 items):
      RetentionCheckDate(+7d):
  VERIFY_UNDER_LOAD (must pass to “close” breach):
    TimedMixedSet(%):
    NovelQuestionPass(yes/no):
    Explanation1Sentence(pass/fail):  # states invariant in words
  LEDGER_UPDATE:
    AppendLog:
      - {Date, InvariantID, FixProtocolID, VerifyResult, NextRisk}
  PARENT_OUTPUT (auto-summary):
    Line1: "Current Phase/Band + next node risk"
    Line2: "Top breach + what we fixed + proof (verify result)"
    Line3: "Next week focus"
RISK_FLAG RULE (simple, executable):
  Red if:
    (Band == -Latt) OR (S6_LoadCollapse > 25%) OR (S8_Recurrence ≥ 2) OR (τ_node ≤ 7 AND S1_Accuracy < 55%)
  Amber if:
    (Band == 0Latt) OR (S4_Transfer < 60%) OR (S5_Retention < 65%) OR (ConfGap large)
  Green otherwise
SPREADSHEET_SCHEMA (minimum columns):
  Students:
    StudentID | Name | Level | Target | Phase | Band | RiskFlag | τ_node | CurrentUnit | Notes
  WeeklySensors:
    Date | StudentID | S1 | S2 | S3 | S4 | S5 | S6 | S7 | S8
  BreachLog (Invariant Ledger):
    Date | StudentID | InvariantID | TriggerQID | ErrorType | Signature | FixProtocolID | VerifyDate | VerifyResult
  RepairPlan:
    WeekNo | StudentID | FixProtocolID_A | FixProtocolID_B | DrillSetID_A | DrillSetID_B | TransferTestID_A | TransferTestID_B
  Verify:
    WeekNo | StudentID | TimedMixed% | NovelPass | Explain1Sentence | CloseBreach?(Y/N)
CLOSE_BREACH RULE:
  Close breach if:
    TimedMixed% ≥ 70% AND NovelPass == Yes AND Explain1Sentence == Pass
  Else:
    keep open + reroute repair (do not “move on” silently)

		

			
# InvariantRegistry.Sec1Math (Starter Pack) v1.0
META:
  UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
  RegistryType: Invariant Registry
  Use: Name → detect → repair → verify → log
  ErrorType:
    E1 Misread/Parse | E2 Wrong Model/Operation | E3 Manipulation Break | E4 Fluency Load Collapse | E5 Missing Diagram | E6 Recall Hole
FORMAT:
  InvariantID:
    Name:
    MustRemainTrue(1 line):
    BreachSignature(what it looks like):
    CommonTriggers:
    TypicalErrorType:
    FixProtocolID:
    VerifyTest(what proves repair):
CORE ALGEBRA / EQUIVALENCE:
  CT-S1M-INV-01:
    Name: Equality Preservation
    MustRemainTrue: Transformations must preserve equivalence on both sides.
    BreachSignature: does different operations to each side; “moves term” without invariant.
    CommonTriggers: solve linear equations; transposition.
    TypicalErrorType: E3
    FixProtocolID: CT-S1M-FIX-01
    VerifyTest: solves 5 equations incl. negatives + explains “same-to-both-sides”.
  CT-S1M-INV-02:
    Name: Inverse Operations Pairing
    MustRemainTrue: Operation and its inverse undo each other in correct order.
    BreachSignature: cancels incorrectly; divides before distributing; wrong undo sequence.
    CommonTriggers: 3x+5=20; fractional coefficients.
    TypicalErrorType: E3/E6
    FixProtocolID: CT-S1M-FIX-02
    VerifyTest: “undo chain” on 3 equations + timed.
  CT-S1M-INV-03:
    Name: Distributive Property Integrity
    MustRemainTrue: a(b+c)=ab+ac.
    BreachSignature: a(b+c)=ab+c; or missing one term.
    CommonTriggers: expand brackets; simplify expressions.
    TypicalErrorType: E3
    FixProtocolID: CT-S1M-FIX-03
    VerifyTest: expands + factor-check via substitution.
  CT-S1M-INV-04:
    Name: Like-Term Combination Only
    MustRemainTrue: Only like terms combine (same variable power/structure).
    BreachSignature: 3x + 5 = 8x; x + x^2 = 2x^2.
    CommonTriggers: simplify algebraic expressions.
    TypicalErrorType: E3/E6
    FixProtocolID: CT-S1M-FIX-04
    VerifyTest: simplifies mixed expressions + explains “same structure”.
  CT-S1M-INV-05:
    Name: Substitution Validity
    MustRemainTrue: Replacing a variable with a value preserves structure everywhere.
    BreachSignature: substitutes only part; forgets brackets; sign errors.
    CommonTriggers: evaluate expressions; checking solutions.
    TypicalErrorType: E3/E4
    FixProtocolID: CT-S1M-FIX-05
    VerifyTest: evaluates 5 expressions with negatives + bracketed terms.
NUMBER / SIGN / ORDER:
  CT-S1M-INV-06:
    Name: Integer Sign Consistency
    MustRemainTrue: Negative signs distribute correctly; subtraction is adding a negative.
    BreachSignature: -(a+b)= -a+b; -3×-2=-6; 5-(-2)=3.
    CommonTriggers: integer arithmetic; algebra with negatives.
    TypicalErrorType: E4/E3
    FixProtocolID: CT-S1M-FIX-06
    VerifyTest: integer drill + mixed algebra check.
  CT-S1M-INV-07:
    Name: Order of Operations (Structure First)
    MustRemainTrue: Brackets → powers → multiply/divide → add/subtract.
    BreachSignature: adds before multiply; ignores brackets.
    CommonTriggers: evaluate expressions; word problems with formulas.
    TypicalErrorType: E6/E4
    FixProtocolID: CT-S1M-FIX-07
    VerifyTest: 10 mixed expressions timed.
  CT-S1M-INV-08:
    Name: Operation Closure Awareness
    MustRemainTrue: Some operations change the number set (e.g., division may not stay integer).
    BreachSignature: forces integer answers; rejects fractions; random rounding.
    CommonTriggers: division; ratio; algebra.
    TypicalErrorType: E2/E6
    FixProtocolID: CT-S1M-FIX-08
    VerifyTest: chooses correct form (fraction/decimal) + explains why.
FRACTIONS / RATIONAL STRUCTURE:
  CT-S1M-INV-09:
    Name: Fraction Meaning (Operator)
    MustRemainTrue: a/b means “a ÷ b” and scales quantities.
    BreachSignature: treats as two separate numbers; adds tops and bottoms.
    CommonTriggers: fraction operations; word problems.
    TypicalErrorType: E2/E6
    FixProtocolID: CT-S1M-FIX-09
    VerifyTest: fraction of a quantity + explain in words.
  CT-S1M-INV-10:
    Name: Equivalent Fractions
    MustRemainTrue: Multiply/divide top & bottom by same nonzero number preserves value.
    BreachSignature: changes only numerator; wrong simplification.
    CommonTriggers: simplify; compare; ratio to fraction.
    TypicalErrorType: E6/E3
    FixProtocolID: CT-S1M-FIX-10
    VerifyTest: simplify + generate 3 equivalents.
  CT-S1M-INV-11:
    Name: Common Denominator Principle
    MustRemainTrue: Addition/subtraction needs same unit (denominator).
    BreachSignature: adds denominators; “cross-add” wrong.
    CommonTriggers: fraction add/subtract.
    TypicalErrorType: E6/E3
    FixProtocolID: CT-S1M-FIX-11
    VerifyTest: 6 fraction sums incl. mixed numbers.
  CT-S1M-INV-12:
    Name: Multiplication/Division of Fractions Integrity
    MustRemainTrue: Multiply across; divide = multiply by reciprocal.
    BreachSignature: adds instead; wrong reciprocal; cancels incorrectly.
    CommonTriggers: fraction ×/÷ fraction.
    TypicalErrorType: E6/E3
    FixProtocolID: CT-S1M-FIX-12
    VerifyTest: 8 mixed ×/÷ problems timed.
RATIO / RATE / PERCENT (MULTIPLICATIVE CORE):
  CT-S1M-INV-13:
    Name: Ratio as Multiplicative Relationship
    MustRemainTrue: Ratio scaling multiplies both parts by same factor.
    BreachSignature: adds same number to both parts; treats as difference.
    CommonTriggers: simplify ratio; equivalent ratios.
    TypicalErrorType: E2/E6
    FixProtocolID: CT-S1M-FIX-13
    VerifyTest: scale ratios + explain factor.
  CT-S1M-INV-14:
    Name: Unitary Method Consistency
    MustRemainTrue: Find “per 1” then scale; keep units consistent.
    BreachSignature: scales wrong direction; loses units.
    CommonTriggers: rates; price per item; speed.
    TypicalErrorType: E2/E1
    FixProtocolID: CT-S1M-FIX-14
    VerifyTest: 3 unitary problems + units stated.
  CT-S1M-INV-15:
    Name: Percent = /100 Identity
    MustRemainTrue: p% = p/100 = decimal form.
    BreachSignature: treats 15% as 15; divides by 10.
    CommonTriggers: percentage of a quantity; increase/decrease.
    TypicalErrorType: E6/E2
    FixProtocolID: CT-S1M-FIX-15
    VerifyTest: convert between forms + compute % of number.
  CT-S1M-INV-16:
    Name: Multiplicative Change (Increase/Decrease)
    MustRemainTrue: new = original × (1 ± rate).
    BreachSignature: adds percent directly; uses wrong base.
    CommonTriggers: discount; growth; GST-style problems.
    TypicalErrorType: E2
    FixProtocolID: CT-S1M-FIX-16
    VerifyTest: 4 change problems incl. reverse.
WORD PROBLEMS / MODELLING (STRUCTURE & UNITS):
  CT-S1M-INV-17:
    Name: Unit Consistency Ledger
    MustRemainTrue: Operations must respect units; cannot add unlike units.
    BreachSignature: adds dollars + items; mixes cm with m.
    CommonTriggers: measurement; money; speed.
    TypicalErrorType: E2/E1
    FixProtocolID: CT-S1M-FIX-17
    VerifyTest: annotate units per step + correct conversion.
  CT-S1M-INV-18:
    Name: Known/Unknown Separation
    MustRemainTrue: Define variables for unknowns; do not mix with given values.
    BreachSignature: random operations on given numbers; no variable model.
    CommonTriggers: algebra word problems.
    TypicalErrorType: E2
    FixProtocolID: CT-S1M-FIX-18
    VerifyTest: writes equation from 3 statements.
  CT-S1M-INV-19:
    Name: Direction-of-Scaling Sanity Check
    MustRemainTrue: If quantity increases, answer should reflect direction.
    BreachSignature: “more” gives smaller; “per” inverted.
    CommonTriggers: ratio, rate, unitary.
    TypicalErrorType: E2
    FixProtocolID: CT-S1M-FIX-19
    VerifyTest: estimation check + correct computation.
GEOMETRY / MEASUREMENT (SEC 1 CORE):
  CT-S1M-INV-20:
    Name: Perimeter vs Area Distinction
    MustRemainTrue: Perimeter is 1D boundary; area is 2D coverage.
    BreachSignature: uses area formula for perimeter; adds length×breadth.
    CommonTriggers: rectangles; composite shapes.
    TypicalErrorType: E6/E2
    FixProtocolID: CT-S1M-FIX-20
    VerifyTest: 4 mixed perimeter/area tasks.
  CT-S1M-INV-21:
    Name: Area Unit Squaring
    MustRemainTrue: Area units are squared; conversion squares the factor.
    BreachSignature: 1 m² = 100 cm² (wrong; should be 10,000).
    CommonTriggers: unit conversion in area.
    TypicalErrorType: E6
    FixProtocolID: CT-S1M-FIX-21
    VerifyTest: convert area units + explain “square factor”.
  CT-S1M-INV-22:
    Name: Angle Facts Consistency
    MustRemainTrue: Straight line 180°, full turn 360°, around point 360°.
    BreachSignature: random subtraction; forgets base facts.
    CommonTriggers: angle chase basics.
    TypicalErrorType: E6/E5
    FixProtocolID: CT-S1M-FIX-22
    VerifyTest: 5 angle questions with diagrams.
DATA / AVERAGES (COMMON SEC 1 TOPIC):
  CT-S1M-INV-23:
    Name: Mean as Conservation of Total
    MustRemainTrue: total = mean × number of items.
    BreachSignature: averages by adding/dividing wrong count; loses total.
    CommonTriggers: mean problems; missing value.
    TypicalErrorType: E6/E2
    FixProtocolID: CT-S1M-FIX-23
    VerifyTest: finds missing value using total conservation.
  CT-S1M-INV-24:
    Name: Median/Mode Definition Integrity
    MustRemainTrue: median is middle (ordered); mode is most frequent.
    BreachSignature: uses mean formula; doesn’t order data.
    CommonTriggers: statistics basics.
    TypicalErrorType: E6
    FixProtocolID: CT-S1M-FIX-24
    VerifyTest: compute mean/median/mode correctly for 3 sets.
LOAD / EXECUTION INVARIANTS (CONTROL LAYER, not topic):
  CT-S1M-INV-25:
    Name: Working Memory Budget
    MustRemainTrue: Steps must be chunked; too many live items causes collapse.
    BreachSignature: can do untimed but fails timed; loses steps mid-solution.
    CommonTriggers: multi-step algebra; word problems.
    TypicalErrorType: E4
    FixProtocolID: CT-S1M-FIX-25
    VerifyTest: same task timed + structured working shown.
  CT-S1M-INV-26:
    Name: Double-Check via Substitution / Estimation
    MustRemainTrue: Answers must pass quick sanity check.
    BreachSignature: accepts impossible results; no verification habit.
    CommonTriggers: all mixed tests.
    TypicalErrorType: E2/E4
    FixProtocolID: CT-S1M-FIX-26
    VerifyTest: performs check step on 5 questions consistently.
NOTES:
  - This is a starter pack. Add more invariants only if they repeat as dominant breach drivers.
  - Rule: “Name the invariant” before “give more practice”.

		

			
# FixProtocolIndex.Sec1Math (Starter Mapping) v1.0
META:
  UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
  Purpose: Each FixProtocol is a reusable repair module (ILT-compatible)
FIX_PROTOCOL_TEMPLATE:
  FixProtocolID:
    TargetInvariantID:
    MinimalExplanation(≤3 lines):
    WorkedExamples(2):
    AntiExamples(2):
    DrillSet(10):
    TransferTest(3):
    RetentionCheck(+7d):
    CloseRule: TimedMixed≥70% AND NovelPass=Yes AND Explain1Sentence=Pass
INDEX (IDs only; fill content as you build library):
  CT-S1M-FIX-01: targets CT-S1M-INV-01 (Equality Preservation)
  CT-S1M-FIX-02: targets CT-S1M-INV-02 (Inverse Operations Pairing)
  CT-S1M-FIX-03: targets CT-S1M-INV-03 (Distributive Integrity)
  CT-S1M-FIX-04: targets CT-S1M-INV-04 (Like-Terms Only)
  CT-S1M-FIX-05: targets CT-S1M-INV-05 (Substitution Validity)
  CT-S1M-FIX-06: targets CT-S1M-INV-06 (Integer Sign Consistency)
  CT-S1M-FIX-07: targets CT-S1M-INV-07 (Order of Operations)
  CT-S1M-FIX-08: targets CT-S1M-INV-08 (Closure Awareness)
  CT-S1M-FIX-09: targets CT-S1M-INV-09 (Fraction Meaning)
  CT-S1M-FIX-10: targets CT-S1M-INV-10 (Equivalent Fractions)
  CT-S1M-FIX-11: targets CT-S1M-INV-11 (Common Denominator)
  CT-S1M-FIX-12: targets CT-S1M-INV-12 (Frac ×/÷ Integrity)
  CT-S1M-FIX-13: targets CT-S1M-INV-13 (Ratio Multiplicative Core)
  CT-S1M-FIX-14: targets CT-S1M-INV-14 (Unitary Method)
  CT-S1M-FIX-15: targets CT-S1M-INV-15 (Percent Identity)
  CT-S1M-FIX-16: targets CT-S1M-INV-16 (Multiplicative Change)
  CT-S1M-FIX-17: targets CT-S1M-INV-17 (Unit Consistency)
  CT-S1M-FIX-18: targets CT-S1M-INV-18 (Known/Unknown Separation)
  CT-S1M-FIX-19: targets CT-S1M-INV-19 (Scaling Sanity Check)
  CT-S1M-FIX-20: targets CT-S1M-INV-20 (Perimeter vs Area)
  CT-S1M-FIX-21: targets CT-S1M-INV-21 (Area Unit Squaring)
  CT-S1M-FIX-22: targets CT-S1M-INV-22 (Angle Facts)
  CT-S1M-FIX-23: targets CT-S1M-INV-23 (Mean Total Conservation)
  CT-S1M-FIX-24: targets CT-S1M-INV-24 (Median/Mode Integrity)
  CT-S1M-FIX-25: targets CT-S1M-INV-25 (Working Memory Budget)
  CT-S1M-FIX-26: targets CT-S1M-INV-26 (Verification Habit)

		

			
# FixProtocolLibrary.Sec1Math (CT-S1M-FIX-01 → CT-S1M-FIX-06) v1.0
META:
  UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
  Domain: EducationOS × MathOS (Sec 1)
  ModuleType: Repair Protocol Library (ILT-compatible)
  CloseRule(Global):
    Close breach if TimedMixed≥70% AND NovelPass=Yes AND Explain1Sentence=Pass
  OperatingRule:
    Name invariant first → show breach → teach minimal mechanism → drill → transfer → verify → log → retention check.
# -------------------------------------------------------------------
# CT-S1M-FIX-01
# -------------------------------------------------------------------
FixProtocolID: CT-S1M-FIX-01
TargetInvariantID: CT-S1M-INV-01
Name: Equality Preservation Repair (Same-to-Both-Sides)
MinimalExplanation(≤3 lines):
  Equality means both sides are the same value.
  Any change must be applied to BOTH sides in the same way to keep it true.
  “Moving a term” is shorthand for doing an operation to both sides.
ILT_Module:
  InvariantSpotlight:
    OneSentence: "Whatever you do to one side of an equation, you must do to the other side."
  LedgerReplay:
    Show: wrong step → invariant broken → corrected step → invariant preserved.
  ReconciliationPrompt:
    Student says: "I keep it equal by _______ to both sides."
WorkedExamples(2):
  Ex1:
    Problem: 3x + 5 = 20
    Steps:
      - Subtract 5 from both sides: 3x = 15
      - Divide both sides by 3: x = 5
    Check:
      - Substitute x=5: 3(5)+5=20 ✓
  Ex2:
    Problem: 2x - 7 = 11
    Steps:
      - Add 7 to both sides: 2x = 18
      - Divide both sides by 2: x = 9
    Check:
      - Substitute x=9: 18-7=11 ✓
AntiExamples(2):
  Anti1:
    Wrong: 3x+5=20 → 3x=20 (subtracted 5 on one side only)
    Breach: equality not preserved.
  Anti2:
    Wrong: 2x-7=11 → x-7=11 (divided left side only)
    Breach: equality not preserved.
DrillSet(10):
  - 4x + 3 = 19
  - 5x - 6 = 24
  - 2x + 9 = 7
  - 3x - 10 = -1
  - 7x + 5 = 54
  - 9x - 4 = 14
  - 6x + 11 = 5
  - 8x - 9 = -41
  - 12 + x = 30
  - 15 - x = 2
TransferTest(3):
  T1:
    Problem: 3(x+2)=21
    Expect: divide both sides by 3 first; then subtract 2.
  T2:
    Problem: (x/4) + 3 = 9
    Expect: subtract 3 both sides; multiply both sides by 4.
  T3:
    Problem: 2x + 5 = x + 17
    Expect: subtract x both sides; then subtract 5.
RetentionCheck(+7d):
  QuickCheck(5):
    - 4x - 1 = 11
    - 2x + 8 = 0
    - x/3 - 2 = 5
    - 5(x-1)=20
    - 7 + x = 19
  PassRule:
    4/5 correct + student states invariant in 1 sentence.
VerifyUnderLoad:
  TimedMixedSet(6 questions, 6 minutes):
    include 2 with negatives, 2 with fractions, 2 with variable both sides.
  Explain1Sentence:
    "I kept the equation true by doing the same operation to both sides."
# -------------------------------------------------------------------
# CT-S1M-FIX-02
# -------------------------------------------------------------------
FixProtocolID: CT-S1M-FIX-02
TargetInvariantID: CT-S1M-INV-02
Name: Inverse Operations Pairing Repair (Undo Chain)
MinimalExplanation(≤3 lines):
  Solving is undoing operations in reverse order.
  Each operation has an inverse: + ↔ −, × ↔ ÷.
  Keep the “undo chain” clean: one inverse step at a time.
ILT_Module:
  InvariantSpotlight:
    OneSentence: "To isolate x, undo the operations in the reverse order they were applied."
  LedgerReplay:
    Show: wrong undo order → extra complexity → corrected undo order → clean isolation.
  ReconciliationPrompt:
    Student says: "The last thing done to x was ___, so I undo it by ___."
WorkedExamples(2):
  Ex1:
    Problem: 5x + 6 = 31
    UndoChain:
      - Undo +6 by −6: 5x = 25
      - Undo ×5 by ÷5: x = 5
  Ex2:
    Problem: 4(x - 3) = 20
    UndoChain:
      - Undo ×4 by ÷4: x - 3 = 5
      - Undo −3 by +3: x = 8
AntiExamples(2):
  Anti1:
    Wrong: 4(x-3)=20 → x-3=20-3 (subtracting 3 before dividing)
    Breach: undo order; creates nonsense steps.
  Anti2:
    Wrong: 5x+6=31 → x=31-6÷5 (mixing operations without preserving structure)
    Breach: breaks clean inverse pairing.
DrillSet(10):
  - 6x + 8 = 44
  - 9x - 5 = 58
  - 3(x+4)=27
  - 5(x-2)=15
  - (x/7)+6=10
  - (x/5)-3=9
  - 2x + 11 = x + 20
  - 7x - 9 = 5x + 3
  - 12 - 3x = 0
  - 4x + 1 = -11
TransferTest(3):
  T1: 2(3x - 1) = 16
  T2: (x - 5)/3 = 4
  T3: 5 - (x/2) = 1
RetentionCheck(+7d):
  QuickCheck(5):
    - 7x + 2 = 30
    - 3(x-1)=18
    - (x/4)+1=6
    - 2x+9=x+1
    - 10-2x=4
  PassRule:
    4/5 correct + student verbalizes the undo chain.
VerifyUnderLoad:
  TimedMixedSet:
    6 questions, 6 minutes; include brackets and fractions.
  Explain1Sentence:
    "I isolated x by undoing the operations in reverse order."
# -------------------------------------------------------------------
# CT-S1M-FIX-03
# -------------------------------------------------------------------
FixProtocolID: CT-S1M-FIX-03
TargetInvariantID: CT-S1M-INV-03
Name: Distributive Property Repair (Bracket Expansion Integrity)
MinimalExplanation(≤3 lines):
  A factor outside a bracket multiplies EVERY term inside.
  Treat it like “spreading” the multiplier across the bracket.
  Check by substitution: pick x=1 to verify equality.
ILT_Module:
  InvariantSpotlight:
    OneSentence: "The multiplier must hit every term in the bracket."
  LedgerReplay:
    Show: missed term → value mismatch → correct spread → match restored.
  ReconciliationPrompt:
    Student says: "I multiplied ___ by each term: ___ and ___."
WorkedExamples(2):
  Ex1:
    Problem: 3(x + 4)
    Expand: 3x + 12
    Check: let x=1 → LHS 3(5)=15, RHS 3+12=15 ✓
  Ex2:
    Problem: -2(2x - 5)
    Expand: -4x + 10
    Check: x=1 → LHS -2( -3)=6, RHS -4+10=6 ✓
AntiExamples(2):
  Anti1:
    Wrong: 3(x+4)=3x+4
    Breach: multiplier didn’t hit 4.
  Anti2:
    Wrong: -2(2x-5)=-4x-10
    Breach: sign distribution wrong (−2 × −5 = +10).
DrillSet(10):
  - 2(x+7)
  - 5(x-3)
  - -3(x+2)
  - 4(2x+1)
  - 6(3x-4)
  - -2(5x-6)
  - 7(2x-1)
  - 3(4x+5)
  - -5(3x+2)
  - 2(5x-7)
TransferTest(3):
  T1: 3(2x - 5) + 4(x + 1)
  T2: -2(3x - 4) - (x - 6)
  T3: 5(x - 2) = 3(x + 4)  (expand both sides then solve)
RetentionCheck(+7d):
  QuickCheck(5):
    - 4(x-3)
    - -2(x+5)
    - 3(3x-1)
    - -5(2x-7)
    - 2(4x+9)
  PassRule:
    4/5 correct + 1 substitution check performed.
VerifyUnderLoad:
  TimedMixedSet:
    8 expansions in 6 minutes, includes negatives.
  Explain1Sentence:
    "I expanded by multiplying the outside factor into every term inside the bracket."
# -------------------------------------------------------------------
# CT-S1M-FIX-04
# -------------------------------------------------------------------
FixProtocolID: CT-S1M-FIX-04
TargetInvariantID: CT-S1M-INV-04
Name: Like-Terms Only Repair (Structure Matching)
MinimalExplanation(≤3 lines):
  Terms combine only if they have the same variable part (same “shape”).
  3x and 5x combine; 3x and 5 do not.
  Use “shape tags”: x, x², xy are different shapes.
ILT_Module:
  InvariantSpotlight:
    OneSentence: "Only same-shape terms can be added/subtracted."
  LedgerReplay:
    Show: wrong merge → changes value under substitution → correct grouping → value preserved.
  ReconciliationPrompt:
    Student says: "These are like terms because they both have ___."
WorkedExamples(2):
  Ex1:
    Problem: 3x + 5x - 2x
    Combine: (3+5-2)x = 6x
  Ex2:
    Problem: 4a + 3 - 2a + 7
    Combine: (4a-2a) + (3+7) = 2a + 10
AntiExamples(2):
  Anti1:
    Wrong: 3x + 5 = 8x
    Breach: different shapes (x vs constant).
  Anti2:
    Wrong: x + x^2 = 2x^2
    Breach: different shapes (x vs x²).
DrillSet(10):
  - 2x + 7x
  - 9a - 4a + a
  - 3y + 5 - 2y + 1
  - 6m - 2 + 3m + 9
  - 4p + 2q + 7p
  - 8x - 3x + 2
  - 5a + 3b - 2a - b
  - 10t + 4 - 6t - 1
  - 7k + 2k - 5
  - 3x + 2y + x - y
TransferTest(3):
  T1: 3(x+2) + 4(x-1)  (expand then combine)
  T2: 5a - 2(2a - 3)   (distribute then combine)
  T3: 2x + 3y = 11; simplify LHS and interpret (structure awareness)
RetentionCheck(+7d):
  QuickCheck(5):
    - 7x+2x-4x
    - 3a+8-5a+1
    - 2p+q+6p-3q
    - 4m-2+9-3m
    - 5x+3y-2x+y
  PassRule:
    4/5 correct + student explains “same shape” once.
VerifyUnderLoad:
  TimedMixedSet:
    10 simplify tasks in 6 minutes (mixed with bracket expansion).
  Explain1Sentence:
    "I only combined terms that had the same variable structure."
# -------------------------------------------------------------------
# CT-S1M-FIX-05
# -------------------------------------------------------------------
FixProtocolID: CT-S1M-FIX-05
TargetInvariantID: CT-S1M-INV-05
Name: Substitution Repair (Bracket + Sign Discipline)
MinimalExplanation(≤3 lines):
  When substituting, replace the variable everywhere with the value.
  If the value is negative, bracket it first.
  Then follow order of operations.
ILT_Module:
  InvariantSpotlight:
    OneSentence: "Substitution must replace the variable everywhere without changing structure."
  LedgerReplay:
    Show: missing bracket → sign flip → correct bracket → correct value.
  ReconciliationPrompt:
    Student says: "I bracketed ___ because it’s negative."
WorkedExamples(2):
  Ex1:
    Problem: Evaluate 2x + 3 when x = 4
    Steps: 2(4)+3 = 11
  Ex2:
    Problem: Evaluate x^2 - 3x when x = -2
    Steps: (-2)^2 - 3(-2) = 4 + 6 = 10
AntiExamples(2):
  Anti1:
    Wrong: x^2 when x=-2 → -2^2 = -4
    Breach: missing brackets; should be (+4).
  Anti2:
    Wrong: 3x+5 when x=4 → 3+4+5=12
    Breach: didn’t multiply; structure changed.
DrillSet(10):
  - Evaluate 3x-1 when x=5
  - Evaluate 4x+7 when x=0
  - Evaluate 2x^2 when x=3
  - Evaluate x^2+2x when x=-1
  - Evaluate 5-2x when x=4
  - Evaluate 3(x+2) when x=-2
  - Evaluate 2x-3 when x=-5
  - Evaluate x^2-4 when x=2
  - Evaluate (x/2)+6 when x=8
  - Evaluate 7x-3x when x=-3
TransferTest(3):
  T1: Evaluate 2(x-3)+5 when x=-1
  T2: Check if x=3 is a solution of 4x-2=10
  T3: Evaluate (x^2 - 1)/(x+1) when x=2
RetentionCheck(+7d):
  QuickCheck(5):
    - 2x+1 at x=-4
    - x^2-3x at x=3
    - 3(x-2) at x=-2
    - 5-2x at x=-1
    - (x/3)+2 at x=9
  PassRule:
    4/5 correct + correct bracketing for negatives.
VerifyUnderLoad:
  TimedMixedSet:
    8 substitution tasks in 6 minutes; includes negatives + brackets.
  Explain1Sentence:
    "I kept structure by replacing x everywhere, bracketing negatives, then following operations order."
# -------------------------------------------------------------------
# CT-S1M-FIX-06
# -------------------------------------------------------------------
FixProtocolID: CT-S1M-FIX-06
TargetInvariantID: CT-S1M-INV-06
Name: Integer Sign Repair (Negatives as Objects)
MinimalExplanation(≤3 lines):
  Treat negative numbers as real objects on a number line.
  Subtraction is adding a negative: a − b = a + (−b).
  Two negatives multiply to a positive; one negative gives negative.
ILT_Module:
  InvariantSpotlight:
    OneSentence: "Subtraction is adding a negative; signs follow consistent rules."
  LedgerReplay:
    Show: sign flip error → number line contradiction → corrected rule.
  ReconciliationPrompt:
    Student says: "I rewrote subtraction as addition of a negative: ___."
WorkedExamples(2):
  Ex1:
    Problem: 5 - (-3)
    Rewrite: 5 + 3 = 8
  Ex2:
    Problem: (-4)(-6)
    Rule: negative × negative = positive → 24
AntiExamples(2):
  Anti1:
    Wrong: 5 - (-3) = 2
    Breach: failed subtraction-as-add-negative rule.
  Anti2:
    Wrong: (-4)(-6) = -24
    Breach: sign multiplication rule.
DrillSet(10):
  - 7 - (-2)
  - -5 - 3
  - -8 + 11
  - 12 + (-15)
  - -6 - (-9)
  - (-3)(5)
  - (-7)(-2)
  - 24 ÷ (-3)
  - (-18) ÷ (-6)
  - -4 + (-9)
TransferTest(3):
  T1: Simplify: x - (-5) when x = -2 (evaluate)
  T2: Solve: x - 7 = -3
  T3: Simplify: -2(3x - 5) (distribute with sign)
RetentionCheck(+7d):
  QuickCheck(5):
    - 9 - (-4)
    - -6 - (-2)
    - (-5)(-3)
    - 20 ÷ (-4)
    - -7 + (-8)
  PassRule:
    4/5 correct + student explains one rule using number line.
VerifyUnderLoad:
  TimedMixedSet:
    12 integer operations in 5 minutes (mix +,−,×,÷).
  Explain1Sentence:
    "I handled signs by rewriting subtraction as adding a negative and applying consistent sign rules."
LOGGING (for all FixProtocols):
  Append to BreachLog:
    {Date, StudentID, InvariantID, FixProtocolID, TimedMixed%, NovelPass, Explain1Sentence, Close(Y/N), NextRisk, RetentionDate}

		

			
# DrillSetRegistry.Sec1Math (IDs used above) v1.0
META:
  UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
  Note: In practice, each DrillSetID maps to a stored worksheet / question bank link.
DrillSetID Mapping (starter):
  CT-S1M-DRILL-01: Equality Preservation (10)
  CT-S1M-DRILL-02: Inverse Undo Chain (10)
  CT-S1M-DRILL-03: Distributive Expansion (10)
  CT-S1M-DRILL-04: Like-Terms Only (10)
  CT-S1M-DRILL-05: Substitution + Negatives (10)
  CT-S1M-DRILL-06: Integer Signs Mixed (10)

		

			
# TransferTestRegistry.Sec1Math (IDs used above) v1.0
META:
  UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
TransferTestID Mapping (starter):
  CT-S1M-TRAN-01: Brackets + Equations (3)
  CT-S1M-TRAN-02: Fractions + Equations (3)
  CT-S1M-TRAN-03: Mixed Expand→Simplify→Solve (3)
  CT-S1M-TRAN-04: Substitute→Check Solution (3)
  CT-S1M-TRAN-05: Signs + Algebra Mix (3)

		

“`md id=”xk2m4n”

FixProtocolLibrary.Sec1Math (CT-S1M-FIX-07 → CT-S1M-FIX-12) v1.0

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
Domain: EducationOS × MathOS (Sec 1)
ModuleType: Repair Protocol Library (ILT-compatible)
CloseRule(Global):
Close breach if TimedMixed≥70% AND NovelPass=Yes AND Explain1Sentence=Pass

——————————————————————-

CT-S1M-FIX-07

——————————————————————-

FixProtocolID: CT-S1M-FIX-07
TargetInvariantID: CT-S1M-INV-07
Name: Order of Operations Repair (Structure First)
MinimalExplanation(≤3 lines):
Expressions have structure; follow the hierarchy: Brackets → Powers → ×/÷ → +/−.
Work left-to-right within the same rank (×/÷) and (+/−).
When substituting negatives, bracket first, then apply the order.

ILT_Module:
InvariantSpotlight:
OneSentence: “I keep the expression’s structure by doing brackets/powers first, then ×/÷, then +/−.”
LedgerReplay:
Show: wrong order → different value → correct order → value preserved.
ReconciliationPrompt:
Student says: “I did _ first because it has higher priority than _.”

WorkedExamples(2):
Ex1:
Problem: 6 + 2(5 – 3)
Steps:
– Brackets: (5-3)=2
– Multiply: 2×2=4
– Add: 6+4=10
Ex2:
Problem: 18 ÷ 3 × 2
Steps:
– Same rank (÷ and ×): left to right
– 18 ÷ 3 = 6
– 6 × 2 = 12

AntiExamples(2):
Anti1:
Wrong: 6 + 2(5-3) → 6+2×5-3 = 13
Breach: removed brackets incorrectly; violated structure.
Anti2:
Wrong: 18 ÷ 3 × 2 → 18 ÷ 6 = 3
Breach: didn’t go left-to-right within same rank.

DrillSet(10):

8 + 3(4 – 2)
12 – 2(7 – 5)
5 + 6 ÷ 2
24 ÷ 3 × 4
18 – 6 ÷ 3
3(2 + 5) – 4
20 ÷ (5 – 1)
7 + 2^3
2^4 – 3×5
9 – 3(6 ÷ 2)

TransferTest(3):
T1: Evaluate 2(x-3)+5 when x=-1 (order + negative brackets)
T2: Evaluate 3 + 12 ÷ 3 × 2
T3: Simplify 2(3x-1)+4(x+2) (structure then expansion)

RetentionCheck(+7d):
QuickCheck(5):
– 10 – 2(6-4)
– 16 ÷ 2 × 3
– 5 + 2^4
– 18 – 3(4-1)
– 24 ÷ (8-2)
PassRule:
4/5 correct + student states the hierarchy once.

VerifyUnderLoad:
TimedMixedSet:
10 expressions in 6 minutes (include brackets + powers + ×/÷ chain).
Explain1Sentence:
“I followed the hierarchy to preserve the expression’s structure.”

——————————————————————-

CT-S1M-FIX-08

——————————————————————-

FixProtocolID: CT-S1M-FIX-08
TargetInvariantID: CT-S1M-INV-08
Name: Number-Set / Closure Awareness Repair (Fractions Are Valid)
MinimalExplanation(≤3 lines):
Division doesn’t always stay inside integers; fractions are valid exact answers.
Don’t round unless asked; keep exact form to preserve invariants.
Choose representation based on context: exact (fraction) vs approximate (decimal).

ILT_Module:
InvariantSpotlight:
OneSentence: “I preserve exact value by keeping fractions when division doesn’t give an integer.”
LedgerReplay:
Show: forced rounding → wrong check → keep fraction → checks correctly.
ReconciliationPrompt:
Student says: “I kept it as a fraction because _.”

WorkedExamples(2):
Ex1:
Problem: 7 ÷ 2
Answer: 7/2 (or 3.5) # exact vs decimal
Note: exact form is 7/2.
Ex2:
Problem: Solve 3x = 5
Answer: x = 5/3
Check: 3(5/3)=5 ✓

AntiExamples(2):
Anti1:
Wrong: 7 ÷ 2 = 3
Breach: destroyed value (rounding without permission).
Anti2:
Wrong: 3x=5 → x=1
Breach: forced integer; fails check.

DrillSet(10):

5 ÷ 2 (write exact)
9 ÷ 4 (write exact)
Solve: 2x = 7
Solve: 5x = 3
Solve: x/3 = 5
Solve: x/4 = 7
Simplify: 12/18
Simplify: 15/25
Convert to decimal: 3/8
Convert to fraction: 0.6

TransferTest(3):
T1: Solve: 4x + 1 = 0
T2: Word: $7 shared equally among 2 people. Exact share?
T3: Solve: (x/5) – 2 = 0

RetentionCheck(+7d):
QuickCheck(5):
– Solve: 6x = 5
– Solve: x/2 = 9
– 11 ÷ 4 (exact)
– 0.75 to fraction
– 9/12 simplify
PassRule:
4/5 correct + student explains “exact vs approximate”.

VerifyUnderLoad:
TimedMixedSet:
8 items in 6 minutes mixing “exact fraction required” and “decimal requested”.
Explain1Sentence:
“I kept the value exact by using a fraction unless approximation was required.”

——————————————————————-

CT-S1M-FIX-09

——————————————————————-

FixProtocolID: CT-S1M-FIX-09
TargetInvariantID: CT-S1M-INV-09
Name: Fraction Meaning Repair (Fraction as Division/Operator)
MinimalExplanation(≤3 lines):
a/b means a ÷ b (division) and also an operator: “take a parts out of b equal parts”.
Fractions scale quantities; they are not two separate numbers.
Use “of” = multiply, and unit reasoning to keep meaning.

ILT_Module:
InvariantSpotlight:
OneSentence: “A fraction is a division and an operator that scales a quantity.”
LedgerReplay:
Show: add-top-bottom mistake → absurd check → operator model → correct.
ReconciliationPrompt:
Student says: “/ means _ divided by _.”

WorkedExamples(2):
Ex1:
Problem: Find 3/4 of 20
Steps: (3/4)×20 = 3×(20/4)=3×5=15
Ex2:
Problem: What does 5/2 mean?
Meaning: 5 ÷ 2 = 2.5 (two and a half); as operator it scales by 2.5.

AntiExamples(2):
Anti1:
Wrong: 3/4 of 20 = 3/4 + 20
Breach: fraction is not “add-on”.
Anti2:
Wrong: 5/2 means 5 and 2 (two numbers)
Breach: lost division meaning.

DrillSet(10):

2/3 of 18
5/6 of 24
3/5 of 40
7/4 as a mixed number
9/2 as a mixed number
Interpret: 4/7 in words
1/8 of 64
3/2 of 14
5/3 of 12
Explain: why 6/3 = 2

TransferTest(3):
T1: A recipe uses 3/4 cup sugar. Double the recipe. How much sugar?
T2: A tank is 2/5 full. If capacity is 50L, how many liters?
T3: Explain why 3/4 of 20 equals 15 using “divide then multiply”.

RetentionCheck(+7d):
QuickCheck(5):
– 4/5 of 35
– 3/2 of 10
– Convert 11/4 to mixed
– Explain 7/3 in words
– 2/7 of 21
PassRule:
4/5 correct + one verbal meaning statement.

VerifyUnderLoad:
TimedMixedSet:
10 items in 7 minutes (mix “of”, interpretation, conversion).
Explain1Sentence:
“A fraction means division and acts as a multiplier on a quantity.”

——————————————————————-

CT-S1M-FIX-10

——————————————————————-

FixProtocolID: CT-S1M-FIX-10
TargetInvariantID: CT-S1M-INV-10
Name: Equivalent Fractions Repair (Same Multiplier Top & Bottom)
MinimalExplanation(≤3 lines):
Multiplying (or dividing) numerator and denominator by the same nonzero number keeps value.
This is the “same-to-both-sides” idea applied inside a fraction.
Simplify by dividing by the greatest common factor (GCF).

ILT_Module:
InvariantSpotlight:
OneSentence: “A fraction’s value stays the same if top and bottom are scaled by the same factor.”
LedgerReplay:
Show: changed only top → value changes → scale both → value preserved.
ReconciliationPrompt:
Student says: “I multiplied/divided BOTH by _.”

WorkedExamples(2):
Ex1:
Problem: Simplify 12/18
Steps: divide both by 6 → 2/3
Ex2:
Problem: Make an equivalent fraction to 3/5 with denominator 20
Steps: ×4 top and bottom → 12/20

AntiExamples(2):
Anti1:
Wrong: 3/5 = 6/5
Breach: changed numerator only → changed value.
Anti2:
Wrong: 12/18 → 6/9 → 3/3
Breach: inconsistent scaling; ended at 1 incorrectly.

DrillSet(10):

Simplify 8/12
Simplify 15/35
Simplify 21/28
Simplify 18/24
Make denominator 30: 2/3
Make denominator 50: 3/10
Make denominator 12: 5/6
Make numerator 12: 3/8
Find 3 equivalent fractions for 4/7
Decide: are 6/9 and 2/3 equivalent?

TransferTest(3):
T1: Compare 7/12 and 5/8 (use equivalence/common denominator)
T2: A ratio 3:5 written as a fraction. Make denominator 40.
T3: Solve: x/20 = 3/5

RetentionCheck(+7d):
QuickCheck(5):
– Simplify 16/20
– Make denominator 24: 5/6
– Are 9/15 and 3/5 equivalent?
– Solve: x/18 = 2/3
– Simplify 27/36
PassRule:
4/5 correct + student states “same factor both”.

VerifyUnderLoad:
TimedMixedSet:
10 items in 6 minutes: simplify + generate equivalence + quick compare.
Explain1Sentence:
“I preserved value by scaling numerator and denominator by the same factor.”

——————————————————————-

CT-S1M-FIX-11

——————————————————————-

FixProtocolID: CT-S1M-FIX-11
TargetInvariantID: CT-S1M-INV-11
Name: Common Denominator Repair (Same Unit Before Add/Subtract)
MinimalExplanation(≤3 lines):
Denominator tells the unit size; you can only add/subtract like units.
Convert to a common denominator first, then add/subtract numerators.
Simplify at the end.

ILT_Module:
InvariantSpotlight:
OneSentence: “I make the unit the same (common denominator) before adding/subtracting.”
LedgerReplay:
Show: add denominators mistake → nonsense check → common denom → correct.
ReconciliationPrompt:
Student says: “I changed both fractions to ___ths.”

WorkedExamples(2):
Ex1:
Problem: 1/3 + 1/6
Steps:
– Common denom 6: 1/3=2/6
– 2/6 + 1/6 = 3/6 = 1/2
Ex2:
Problem: 5/8 – 1/4
Steps:
– 1/4=2/8
– 5/8 – 2/8 = 3/8

AntiExamples(2):
Anti1:
Wrong: 1/3 + 1/6 = 2/9
Breach: added denominators; changed unit.
Anti2:
Wrong: 5/8 – 1/4 = 4/4
Breach: treated denominators as same without converting.

DrillSet(10):

1/2 + 1/3
3/4 + 1/8
5/6 – 1/3
7/10 – 1/5
2/9 + 4/9
3/5 + 2/15
11/12 – 1/6
5/8 + 3/16
7/9 – 2/3
2/7 + 3/14

TransferTest(3):
T1: 2 1/3 + 1 1/6 (mixed numbers)
T2: A tank is 3/4 full, then 1/8 is used. Fraction remaining?
T3: 1/ (x) + 1/6 = 1/2 (solve for x by common denom reasoning)

RetentionCheck(+7d):
QuickCheck(5):
– 1/4 + 1/6
– 5/12 – 1/3
– 2/5 + 3/10
– 7/8 – 1/16
– 1 1/2 + 2 1/4
PassRule:
4/5 correct + student states “same unit first”.

VerifyUnderLoad:
TimedMixedSet:
10 add/subtract in 7 minutes (include mixed numbers).
Explain1Sentence:
“I can only add/subtract fractions after making the denominator (unit) the same.”

——————————————————————-

CT-S1M-FIX-12

——————————————————————-

FixProtocolID: CT-S1M-FIX-12
TargetInvariantID: CT-S1M-INV-12
Name: Fraction ×/÷ Repair (Multiply Across; Divide = Reciprocal)
MinimalExplanation(≤3 lines):
To multiply fractions: multiply numerators and denominators.
To divide by a fraction: multiply by its reciprocal.
Simplify by cross-canceling before multiplying to reduce load.

ILT_Module:
InvariantSpotlight:
OneSentence: “Division by a fraction is multiplication by its reciprocal.”
LedgerReplay:
Show: dividing tops and bottoms separately → wrong → reciprocal rule → correct.
ReconciliationPrompt:
Student says: “I changed ÷ to × by flipping the second fraction.”

WorkedExamples(2):
Ex1:
Problem: (3/4) × (8/9)
Steps:
– Cancel 8 with 4: 8/4=2/1
– (3×2)/(1×9)=6/9=2/3
Ex2:
Problem: (5/6) ÷ (2/3)
Steps:
– Reciprocal: (5/6) × (3/2)
– Cancel: 3 with 6 → 1 with 2
– (5×1)/(2×2)=5/4

AntiExamples(2):
Anti1:
Wrong: (5/6) ÷ (2/3) = (5÷2)/(6÷3)= (2.5)/(2)=1.25
Breach: invented rule; not invariant-preserving.
Anti2:
Wrong: (3/4)×(8/9) = 24/36 = 1/2 (ok simplification could be wrong if arithmetic off)
Breach: fluency + failure to reduce/cancel properly (load collapse risk).

DrillSet(10):

(2/3) × (3/5)
(4/7) × (14/3)
(5/8) × (4/15)
(3/10) × (5/6)
(7/9) ÷ (1/3)
(2/5) ÷ (4/15)
(3/4) ÷ (9/8)
(11/12) × (6/11)
(5/6) ÷ (5/12)
(9/10) × (20/27)

TransferTest(3):
T1: A recipe uses 3/4 cup. If you make 2/3 of the recipe, how much?
T2: A distance is 5/6 km. You travel it in 2/3 hour. Speed (fraction km/h)?
T3: Solve: (x/12) × (3/5) = 1/10

RetentionCheck(+7d):
QuickCheck(5):
– (3/5)×(10/9)
– (7/8)÷(7/16)
– (2/3)×(9/4)
– (5/12)÷(1/6)
– (4/9)×(27/8)
PassRule:
4/5 correct + student states “flip then multiply”.

VerifyUnderLoad:
TimedMixedSet:
12 items in 7 minutes; must show at least 3 cross-cancel steps.
Explain1Sentence:
“I solved fraction division by flipping the second fraction and multiplying, simplifying before multiplying.”

LOGGING (for all FixProtocols):
Append to BreachLog:
{Date, StudentID, InvariantID, FixProtocolID, TimedMixed%, NovelPass, Explain1Sentence, Close(Y/N), NextRisk, RetentionDate}

md id=”q9k7u2″

RegistryUpdate.Sec1Math v1.0

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
WhatChanged:
Added FixProtocols 07–12 and aligned Drill/Transfer IDs.

AddTo_FixProtocolIndex:
CT-S1M-FIX-07: targets CT-S1M-INV-07 (Order of Operations)
CT-S1M-FIX-08: targets CT-S1M-INV-08 (Closure Awareness)
CT-S1M-FIX-09: targets CT-S1M-INV-09 (Fraction Meaning)
CT-S1M-FIX-10: targets CT-S1M-INV-10 (Equivalent Fractions)
CT-S1M-FIX-11: targets CT-S1M-INV-11 (Common Denominator)
CT-S1M-FIX-12: targets CT-S1M-INV-12 (Fraction ×/÷)
“`

“`md id=”c3g9q1″

FixProtocolLibrary.Sec1Math (CT-S1M-FIX-13 → CT-S1M-FIX-18) v1.0

——————————————————————-

CT-S1M-FIX-13

——————————————————————-

FixProtocolID: CT-S1M-FIX-13
TargetInvariantID: CT-S1M-INV-13
Name: Ratio Multiplicative Core Repair (Scale Both Parts)
MinimalExplanation(≤3 lines):
A ratio compares quantities by a multiplicative factor.
Equivalent ratios come from multiplying/dividing BOTH parts by the same factor.
“Add the same number” is NOT a valid ratio move.

ILT_Module:
InvariantSpotlight:
OneSentence: “To keep the ratio the same, multiply/divide both parts by the same factor.”
LedgerReplay:
Show: additive move → ratio changes → multiplicative scale → ratio preserved.
ReconciliationPrompt:
Student says: “I scaled both parts by _, so the ratio stays equivalent.”

WorkedExamples(2):
Ex1:
Problem: Simplify 12:18
Steps:
– Divide both by 6 → 2:3
Check:
– 12/18 = 2/3 ✓ (ratio preserved)
Ex2:
Problem: Find an equivalent ratio to 3:5 where the first term is 12
Steps:
– 3 → 12 is ×4
– 5 ×4 = 20
– Answer: 12:20

AntiExamples(2):
Anti1:
Wrong: 3:5 → 4:6 (added 1 to both)
Breach: 3/5 ≠ 4/6; ratio changed.
Anti2:
Wrong: 6:10 → 3:10 (scaled only one side)
Breach: not equivalent.

DrillSet(10):

Simplify 8:12
Simplify 15:25
Simplify 21:28
Write 3 equivalent ratios for 2:7
Find x: 4:9 = x:27
Find x: 5:x = 20:36
Convert ratio to fraction: 3:8 (as 3/8)
Are 6:10 and 9:15 equivalent? (Yes/No)
If 7:14 simplifies to _
Scale 5:6 by factor 3

TransferTest(3):
T1:
Problem: The ratio of boys to girls is 3:5. There are 24 boys. How many girls?
Expect: scale factor ×8 → girls=40.
T2:
Problem: A recipe uses flour:sugar = 4:1. If sugar is 150g, flour is?
Expect: flour = 600g (×4).
T3:
Problem: Ratio A:B = 2:3 and B:C = 4:5. Find A:C.
Expect: align B (LCM) then combine.

RetentionCheck(+7d):
QuickCheck(5):
– Simplify 18:24
– 3:7 = 12:x
– Are 10:15 and 2:3 equivalent?
– If A:B=5:8 and A=20, find B
– Write 9:12 in simplest form
PassRule:
4/5 correct + student states the “scale both parts” invariant.

VerifyUnderLoad:
TimedMixedSet:
10 ratio items in 7 minutes (mix simplify, equivalent, find missing term, word ratio).
Explain1Sentence:
“Ratios stay equivalent only when I multiply/divide both parts by the same factor.”

LOGGING:
Append to BreachLog:
{Date, StudentID, InvariantID=CT-S1M-INV-13, FixProtocolID=CT-S1M-FIX-13, TimedMixed%, NovelPass, Explain1Sentence, Close(Y/N), RetentionDate}

——————————————————————-

CT-S1M-FIX-14

——————————————————————-

FixProtocolID: CT-S1M-FIX-14
TargetInvariantID: CT-S1M-INV-14
Name: Unitary Method Repair (Per-1 then Scale, with Units)
MinimalExplanation(≤3 lines):
Unitary method means: find value for 1 unit, then multiply to target.
Keep units attached at every step (dollars per item, km per hour, etc.).
Direction check: if you multiply the quantity, you must multiply the value.

ILT_Module:
InvariantSpotlight:
OneSentence: “Find per-1 with units, then scale up/down consistently.”
LedgerReplay:
Show: wrong direction scaling → sanity fails → per-1 route → correct.
ReconciliationPrompt:
Student says: “I found _ per 1 , then multiplied by .”

WorkedExamples(2):
Ex1:
Problem: 5 notebooks cost $12. How much is 1 notebook?
Steps:
– $12 ÷ 5 = $2.40 per notebook
– For 8 notebooks: $2.40 × 8 = $19.20
Ex2:
Problem: A car travels 180 km in 3 hours. Speed?
Steps:
– 180 ÷ 3 = 60 km per hour
– Speed = 60 km/h

AntiExamples(2):
Anti1:
Wrong: 5 notebooks cost $12 → 1 notebook costs $12×5
Breach: inverted operation; unitary must divide first.
Anti2:
Wrong: 180 km in 3 hours → 180-3 = 177 km/h
Breach: wrong operation/model.

DrillSet(10):

6 pens cost $9. Find cost of 1 pen.
6 pens cost $9. Find cost of 14 pens.
12 apples weigh 3 kg. Weight of 1 apple (kg)?
12 apples weigh 3 kg. Weight of 20 apples?
8 m of ribbon costs $20. Cost of 1 m?
8 m of ribbon costs $20. Cost of 2.5 m?
240 km in 4 h. Speed?
72 pages in 6 min. Pages per minute?
15 L fills 5 bottles equally. Liters per bottle?
1 bottle holds 3/4 L. How many bottles from 6 L?

TransferTest(3):
T1:
Problem: 3 kg of rice costs $7.50. What is the cost of 2.4 kg?
Expect: per-kg then multiply (unit handling).
T2:
Problem: 5 workers build 2 walls in 4 days. How many walls in 10 days (same rate)?
Expect: build “walls per worker per day” then scale.
T3:
Problem: A printer prints 180 pages in 12 minutes. How long for 75 pages?
Expect: per-minute rate then reverse scaling.

RetentionCheck(+7d):
QuickCheck(5):
– 7 items cost $21. Cost per item?
– Cost of 9 items?
– 150 km in 2.5 h. Speed?
– 18 L shared equally among 6 containers. Liters each?
– 4 m costs $6. Cost of 10 m?
PassRule:
4/5 correct + units stated in at least 3 answers.

VerifyUnderLoad:
TimedMixedSet:
8 unitary items in 8 minutes (mix direct + reverse “how long/how many”).
Explain1Sentence:
“I found the value per 1 with units, then scaled to the target amount.”

LOGGING:
Append to BreachLog:
{Date, StudentID, InvariantID=CT-S1M-INV-14, FixProtocolID=CT-S1M-FIX-14, TimedMixed%, NovelPass, Explain1Sentence, Close(Y/N), RetentionDate}

——————————————————————-

CT-S1M-FIX-15

——————————————————————-

FixProtocolID: CT-S1M-FIX-15
TargetInvariantID: CT-S1M-INV-15
Name: Percent Identity Repair (Percent ↔ Fraction ↔ Decimal)
MinimalExplanation(≤3 lines):
p% means p/100 (exact identity).
Convert using: percent → ÷100; decimal → ×100%.
“Percent of” means multiply: p% of N = (p/100)×N.

ILT_Module:
InvariantSpotlight:
OneSentence: “Percent is a fraction out of 100: p% = p/100.”
LedgerReplay:
Show: treating % as whole number → absurd result → p/100 model → correct.
ReconciliationPrompt:
Student says: “I rewrote % as /100 before calculating.”

WorkedExamples(2):
Ex1:
Problem: 15% of 80
Steps: (15/100)×80 = 0.15×80 = 12
Ex2:
Problem: Convert 0.36 to percent
Steps: 0.36×100% = 36%

AntiExamples(2):
Anti1:
Wrong: 15% of 80 = 15×80
Breach: forgot /100 scaling.
Anti2:
Wrong: 0.36 = 0.36%
Breach: missed ×100 conversion.

DrillSet(10):

Convert 25% to fraction and decimal
Convert 3/5 to percent
Convert 0.08 to percent
Find 12% of 50
Find 40% of 120
Find 7.5% of 200
Write 150% as a fraction and simplify
Which is larger: 35% or 3/8?
Find x: x% of 60 = 18
Find x: 20% of x = 14

TransferTest(3):
T1:
Problem: A test has 80 marks. You scored 62 marks. What percent is that? (nearest 0.5% ok)
T2:
Problem: A shirt is $48 after a 20% discount. What was the original price?
Expect: reverse using multiplicative change identity (ties into FIX-16).
T3:
Problem: 3/8 of a class are girls. What percent are girls?
Expect: fraction→decimal→percent.

RetentionCheck(+7d):
QuickCheck(5):
– 18% of 200
– 0.125 to percent
– 45% as fraction simplified
– x% of 40 = 10, find x
– 3/20 as percent
PassRule:
4/5 correct + student states “p% = p/100”.

VerifyUnderLoad:
TimedMixedSet:
10 items in 7 minutes (mix conversions + % of + find missing).
Explain1Sentence:
“Percent is out of 100, so I convert p% to p/100 before calculating.”

LOGGING:
Append to BreachLog:
{Date, StudentID, InvariantID=CT-S1M-INV-15, FixProtocolID=CT-S1M-FIX-15, TimedMixed%, NovelPass, Explain1Sentence, Close(Y/N), RetentionDate}

——————————————————————-

CT-S1M-FIX-16

——————————————————————-

FixProtocolID: CT-S1M-FIX-16
TargetInvariantID: CT-S1M-INV-16
Name: Multiplicative Change Repair (New = Old × (1 ± r))
MinimalExplanation(≤3 lines):
Percent change is multiplicative: new = old × (1 ± r).
Reverse change uses division: old = new ÷ (1 ± r).
Base matters: the percent is always “of the original/base”.

ILT_Module:
InvariantSpotlight:
OneSentence: “After a r% change, I multiply by (1±r) using r as a decimal.”
LedgerReplay:
Show: adding percent as a number → wrong base → multiplier method → correct.
ReconciliationPrompt:
Student says: “I used multiplier _ because it is a _% (increase/decrease).”

WorkedExamples(2):
Ex1:
Problem: $50 discounted by 20%
Steps:
– Multiplier = 1 – 0.20 = 0.80
– New price = 50×0.80 = $40
Ex2:
Problem: A value increases from 120 by 15%
Steps:
– Multiplier = 1 + 0.15 = 1.15
– New = 120×1.15 = 138

AntiExamples(2):
Anti1:
Wrong: 20% discount on $50 → $50 – 20 = $30
Breach: percent treated as absolute number; base ignored.
Anti2:
Wrong reverse: final $40 after 20% discount → original = 40×0.8
Breach: reverse should divide, not multiply.

DrillSet(10):

$80 with 25% discount (find new)
$60 with 10% increase (find new)
200 decreased by 15%
150 increased by 8%
After 30% discount, price is $35. Find original.
After 12% increase, salary is $2800. Find original.
A population 5000 grows 6%. New population?
A mass 2.4 kg decreases 5%. New mass?
Original 90, new 99. Percent increase?
Original 120, new 102. Percent decrease?

TransferTest(3):
T1:
Problem: Two successive changes: $100 increased by 10% then decreased by 10%. Final?
Expect: 100×1.1×0.9.
T2:
Problem: GST-style: add 9% to $72. (use multiplier 1.09)
T3:
Problem: A number after 20% increase is 96. Find the original.
Expect: divide by 1.2.

RetentionCheck(+7d):
QuickCheck(5):
– 240 decreased by 25%
– $48 after 20% discount → original?
– 120 increased by 15%
– After 5% increase, value is 210 → original?
– Original 80 → new 68 → % change?
PassRule:
4/5 correct + student states multiplier idea.

VerifyUnderLoad:
TimedMixedSet:
8 items in 8 minutes (mix forward + reverse + % change).
Explain1Sentence:
“Percent change is multiplicative, so I use a multiplier (1±r) and divide to reverse.”

LOGGING:
Append to BreachLog:
{Date, StudentID, InvariantID=CT-S1M-INV-16, FixProtocolID=CT-S1M-FIX-16, TimedMixed%, NovelPass, Explain1Sentence, Close(Y/N), RetentionDate}

——————————————————————-

CT-S1M-FIX-17

——————————————————————-

FixProtocolID: CT-S1M-FIX-17
TargetInvariantID: CT-S1M-INV-17
Name: Unit Consistency Ledger Repair (Tag Units Every Step)
MinimalExplanation(≤3 lines):
Units are part of the value; write them like a ledger tag.
You cannot add/subtract different units; convert first.
Multiplying/dividing changes units in predictable ways (km/h, $/item, cm²).

ILT_Module:
InvariantSpotlight:
OneSentence: “Every number carries a unit tag; I only combine like units after conversion.”
LedgerReplay:
Show: mixing units → impossible ledger → convert → ledger reconciles.
ReconciliationPrompt:
Student says: “I converted _ to _ so the units match.”

WorkedExamples(2):
Ex1:
Problem: 2 m + 30 cm
Steps:
– Convert 2 m = 200 cm
– 200 cm + 30 cm = 230 cm (or 2.3 m)
Ex2:
Problem: 60 km in 2 h
Steps:
– Speed = 60 km ÷ 2 h = 30 km/h
Unit ledger:
– (km)/(h) → km/h

AntiExamples(2):
Anti1:
Wrong: 2 m + 30 cm = 32 m
Breach: treated cm as meters; units not reconciled.
Anti2:
Wrong: speed = 60 + 2 = 62 km/h
Breach: added unlike units (km + h).

DrillSet(10):

3 m 20 cm = _ cm
450 cm = _ m
1.5 m + 75 cm = _ m
2 km 300 m = _ m
3500 g = _ kg
2.4 kg + 600 g = _ kg
90 min = _ h
Speed: 120 km in 3 h = _ km/h
Cost rate: $18 for 6 items = _ $/item
Area conversion: 2 m² = _ cm² (squared factor)

TransferTest(3):
T1:
Problem: A runner runs 400 m in 50 s. Speed in m/s.
T2:
Problem: A rectangle is 1.2 m by 80 cm. Find area in m².
Expect: convert first; units squared.
T3:
Problem: $36 buys 1.5 kg of fruit. Find $/kg, then cost for 2.2 kg.

RetentionCheck(+7d):
QuickCheck(5):
– 2.5 m = _ cm – 1800 g = kg
– 1 h 45 min = min – 2 km + 350 m = m
– 3 m² = __ cm²
PassRule:
4/5 correct + student states “convert before combine”.

VerifyUnderLoad:
TimedMixedSet:
10 items in 8 minutes (mix length/mass/time/speed/area).
Explain1Sentence:
“I kept unit tags consistent and converted first so only like units are combined.”

LOGGING:
Append to BreachLog:
{Date, StudentID, InvariantID=CT-S1M-INV-17, FixProtocolID=CT-S1M-FIX-17, TimedMixed%, NovelPass, Explain1Sentence, Close(Y/N), RetentionDate}

——————————————————————-

CT-S1M-FIX-18

——————————————————————-

FixProtocolID: CT-S1M-FIX-18
TargetInvariantID: CT-S1M-INV-18
Name: Known/Unknown Separation Repair (Variable First, Then Equation)
MinimalExplanation(≤3 lines):
Define the unknown clearly (let x be …).
Translate statements into an equation without mixing “given” and “unknown”.
Solve, then check back in the original sentence.

ILT_Module:
InvariantSpotlight:
OneSentence: “I define the unknown, translate to an equation, solve, then check meaning.”
LedgerReplay:
Show: random operations on given numbers → no model → variable model → coherent solve.
ReconciliationPrompt:
Student says: “Let x be . The sentence becomes equation: .”

WorkedExamples(2):
Ex1:
Problem: The sum of a number and 7 is 20. Find the number.
Model:
– Let x be the number.
– x + 7 = 20
– x = 13
Check:
– 13+7=20 ✓
Ex2:
Problem: A number is 5 less than twice another number. If the other number is 9, find the number.
Model:
– Let y be the other number (given 9).
– x = 2y – 5
– x = 2(9) – 5 = 13

AntiExamples(2):
Anti1:
Wrong: “sum of a number and 7 is 20” → 20-7= (stops, no variable/no meaning)
Breach: bypassed unknown definition; cannot generalize; fragile transfer.
Anti2:
Wrong: “5 less than twice” → 5 – 2x
Breach: order reversed; language-to-equation mapping failed.

DrillSet(10):

The sum of x and 12 is 30. Find x.
x decreased by 9 gives 14. Find x.
Three times a number is 27. Find the number.
Half of a number is 11. Find the number.
The difference between a number and 8 is 5. Find the number.
A number increased by 15 is 42. Find the number.
Twice a number minus 3 is 19. Find the number.
A number divided by 4 gives 6. Find the number.
The sum of two consecutive integers is 25. Find them.
A number is 7 more than another. Their sum is 41. Find both.

TransferTest(3):
T1:
Problem: A rectangle’s length is 3 cm more than its width. Perimeter is 26 cm. Find width and length.
Expect: let w, l=w+3, 2(w+l)=26.
T2:
Problem: After spending $18, Ali has $47 left. How much did he have at first?
Expect: let x initial, x-18=47.
T3:
Problem: A taxi charges $4 plus $0.50 per km. The fare is $11. How many km?
Expect: let k, 4+0.5k=11.

RetentionCheck(+7d):
QuickCheck(5):
– “x plus 9 equals 26”
– “5 less than a number is 12”
– “a number divided by 3 is 7”
– “twice a number plus 1 is 17”
– “sum of two numbers is 40; one is 6 more than the other”
PassRule:
4/5 correct + student writes “Let x be …” each time.

VerifyUnderLoad:
TimedMixedSet:
6 word-to-equation items in 10 minutes (must include 2-step models).
Explain1Sentence:
“I separated knowns from unknowns by defining a variable, forming an equation, then checking meaning.”

LOGGING:
Append to BreachLog:
{Date, StudentID, InvariantID=CT-S1M-INV-18, FixProtocolID=CT-S1M-FIX-18, TimedMixed%, NovelPass, Explain1Sentence, Close(Y/N), RetentionDate}

md id=”s8p1wz”

RegistryUpdate.Sec1Math v1.0 (FixProtocols 13–18)

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1

AddTo_FixProtocolIndex:
CT-S1M-FIX-13: targets CT-S1M-INV-13 (Ratio Multiplicative Core)
CT-S1M-FIX-14: targets CT-S1M-INV-14 (Unitary Method)
CT-S1M-FIX-15: targets CT-S1M-INV-15 (Percent Identity)
CT-S1M-FIX-16: targets CT-S1M-INV-16 (Multiplicative Change)
CT-S1M-FIX-17: targets CT-S1M-INV-17 (Unit Consistency Ledger)
CT-S1M-FIX-18: targets CT-S1M-INV-18 (Known/Unknown Separation)
“`

“`md id=”5v9q2e”

FixProtocolLibrary.Sec1Math (CT-S1M-FIX-19 → CT-S1M-FIX-26) v1.0

——————————————————————-

CT-S1M-FIX-19

——————————————————————-

FixProtocolID: CT-S1M-FIX-19
TargetInvariantID: CT-S1M-INV-19
Name: Direction-of-Scaling Sanity Check Repair (Estimate Before Compute)
MinimalExplanation(≤3 lines):
Before calculating, predict direction: bigger/smaller, faster/slower, more/less.
After computing, check if answer matches direction and rough magnitude.
If not, model/operation likely wrong (invert, add vs multiply, wrong base).

ILT_Module:
InvariantSpotlight:
OneSentence: “I estimate direction and size first, then verify the answer matches.”
LedgerReplay:
Show: wrong direction answer accepted → add sanity check → detect → fix.
ReconciliationPrompt:
Student says: “It should be _ because , so my answer must be around .”

WorkedExamples(2):
Ex1:
Problem: 3 items cost $12. How much for 6 items?
Estimate: double items → about double cost → about $24.
Compute: 12÷3=4 per item; 4×6=24 ✓
Ex2:
Problem: A tank is 3/4 full. 1/8 is used. Remaining?
Direction: using some → remaining less than 3/4.
Compute: 3/4 – 1/8 = 6/8 – 1/8 = 5/8 ✓

AntiExamples(2):
Anti1:
Wrong: 3 items $12 → 6 items $6
Breach: direction wrong (more items cannot cost less).
Anti2:
Wrong: 3/4 – 1/8 = 2/12
Breach: magnitude wrong; should be near 0.625.

DrillSet(10):
For each, write (Direction + Rough Estimate) then compute:

5 pens cost $10. Cost of 15 pens.
40% of 200
200 increased by 10%
18 ÷ (3 × 2)
1/2 + 1/3
7/8 – 1/16
12 km in 0.5 h (speed)
3/5 of 50
Ratio 2:3 scaled to 10:?
Rectangle 10 cm by 5 cm: area

TransferTest(3):
T1: Reverse % change: after 20% discount price is $80. Original?
T2: Unitary reverse: printer 120 pages in 6 min. Time for 30 pages?
T3: Ratio word: If A:B=3:4 and A increases, what happens to ratio? (conceptual sanity)

RetentionCheck(+7d):
QuickCheck(5):
Each requires: direction statement + computed answer.
PassRule:
4/5 correct + all 5 have direction written.

VerifyUnderLoad:
TimedMixedSet:
8 mixed word problems in 10 minutes; must write a 1-line sanity check each.
Explain1Sentence:
“I estimated direction and magnitude first, then checked my computed answer matches.”

——————————————————————-

CT-S1M-FIX-20

——————————————————————-

FixProtocolID: CT-S1M-FIX-20
TargetInvariantID: CT-S1M-INV-20
Name: Perimeter vs Area Repair (Boundary vs Coverage)
MinimalExplanation(≤3 lines):
Perimeter measures the boundary length (1D).
Area measures surface coverage (2D).
The formulas differ because the units differ (cm vs cm²).

ILT_Module:
InvariantSpotlight:
OneSentence: “Perimeter is around the edge; area is inside the shape.”
LedgerReplay:
Show: used area formula for perimeter → unit mismatch → correct.
ReconciliationPrompt:
Student says: “Perimeter uses _ units; area uses _ units.”

WorkedExamples(2):
Ex1:
Problem: Rectangle 8 cm by 3 cm. Find perimeter.
Perimeter: 2(8+3)=22 cm
Ex2:
Problem: Same rectangle. Find area.
Area: 8×3=24 cm²

AntiExamples(2):
Anti1:
Wrong: Perimeter = 8×3 = 24 cm
Breach: used area formula; units conflict.
Anti2:
Wrong: Area = 2(8+3)=22 cm²
Breach: used perimeter formula; units conflict.

DrillSet(10):
Identify whether to find P or A, then compute:

Rectangle 10 cm by 6 cm: perimeter
Rectangle 10 cm by 6 cm: area
Square side 7 cm: perimeter
Square side 7 cm: area
Rectangle 12 m by 5 m: perimeter
Rectangle 12 m by 5 m: area
Composite: two rectangles joined (given diagram): perimeter
Composite: same diagram: area
Given perimeter 30 cm and length 8 cm: find width
Given area 48 cm² and width 6 cm: find length

TransferTest(3):
T1: A fence goes around a garden (perimeter). How much fencing for 12 m by 9 m?
T2: Tiles cover a floor (area). How many m² for 6 m by 4.5 m?
T3: Same area, different shapes: does perimeter have to be the same? (concept)

RetentionCheck(+7d):
QuickCheck(5):
Mix P/A; student must write unit correctly.
PassRule:
4/5 correct + correct unit labels.

VerifyUnderLoad:
TimedMixedSet:
10 items in 8 minutes (mix P/A, include 2 reverse problems).
Explain1Sentence:
“Perimeter is boundary length (cm), area is coverage (cm²), so I choose formula by units.”

——————————————————————-

CT-S1M-FIX-21

——————————————————————-

FixProtocolID: CT-S1M-FIX-21
TargetInvariantID: CT-S1M-INV-21
Name: Area Unit Squaring Repair (Squared Conversion Factor)
MinimalExplanation(≤3 lines):
Area units are squared, so conversion factors must be squared too.
Since 1 m = 100 cm, then 1 m² = (100 cm)² = 10,000 cm².
Convert lengths first if unsure, then compute area.

ILT_Module:
InvariantSpotlight:
OneSentence: “Area conversion squares the length conversion factor.”
LedgerReplay:
Show: used ×100 instead of ×10,000 → mismatch → square factor fix.
ReconciliationPrompt:
Student says: “I squared the factor because it’s area (2D).”

WorkedExamples(2):
Ex1:
Convert 2 m² to cm²:
1 m² = 10,000 cm² → 2 m² = 20,000 cm²
Ex2:
Convert 3000 cm² to m²:
3000 ÷ 10,000 = 0.3 m²

AntiExamples(2):
Anti1:
Wrong: 1 m² = 100 cm²
Breach: did not square factor.
Anti2:
Wrong: 5000 cm² = 50 m²
Breach: inverted and mis-scaled.

DrillSet(10):

1 m² = _ cm²
0.5 m² = _ cm²
3 m² = _ cm²
12,000 cm² = _ m²
2500 cm² = _ m²
2.4 m² = _ cm²
75,000 cm² = _ m²
A rectangle 1.2 m by 80 cm: area in m²
Same rectangle: area in cm²
Square side 150 cm: area in m²

TransferTest(3):
T1: A floor is 4 m by 3.5 m. Express area in cm².
T2: A painting covers 18,000 cm². Express in m².
T3: Why is the factor 10,000 not 100? (explain)

RetentionCheck(+7d):
QuickCheck(5):
– 2 m² to cm²
– 30,000 cm² to m²
– 0.08 m² to cm²
– 12,500 cm² to m²
– 1.5 m² to cm²
PassRule:
4/5 correct + explanation sentence.

VerifyUnderLoad:
TimedMixedSet:
8 conversion items in 7 minutes (include mixed cm²↔m² and shape area).
Explain1Sentence:
“Because area is 2D, I square the length conversion factor.”

——————————————————————-

CT-S1M-FIX-22

——————————————————————-

FixProtocolID: CT-S1M-FIX-22
TargetInvariantID: CT-S1M-INV-22
Name: Angle Facts Repair (Anchor Facts + Diagram Discipline)
MinimalExplanation(≤3 lines):
Anchor facts: straight line 180°, around point 360°, triangle 180°.
Mark known angles on the diagram before calculating.
Use “what remains” logic: remaining = total – known.

ILT_Module:
InvariantSpotlight:
OneSentence: “Angle problems conserve total degrees (180/360/triangle 180).”
LedgerReplay:
Show: random subtraction → mismatch → anchor fact ledger → correct.
ReconciliationPrompt:
Student says: “Total is °, known is °, so remaining is _°.”

WorkedExamples(2):
Ex1:
On a straight line, angles are (3x) and (2x). Find x.
Steps:
– 3x + 2x = 180
– 5x = 180 → x = 36
Ex2:
Around a point: angles 120°, 80°, and x.
Steps:
– x = 360 – 120 – 80 = 160°

AntiExamples(2):
Anti1:
Wrong: 3x+2x=360 on a straight line
Breach: used wrong anchor total.
Anti2:
Wrong: x = 360 – 120 + 80
Breach: ledger arithmetic wrong; does not represent “remaining”.

DrillSet(10):

Straight line: x + 70 = 180
Straight line: 2x + 40 = 180
Straight line: 3x + 2x = 180
Around point: x + 110 + 90 = 360
Around point: 2x + x + 60 = 360
Triangle: x + 50 + 60 = 180
Triangle: 2x + 3x + 30 = 180
Isosceles triangle: base angles 40° each, find vertex
Adjacent angles on line: 4x and (x+30)
Around point: 120, 80, 60, x

TransferTest(3):
T1: Find missing angle in a diagram with a straight line + vertical opposite angles.
T2: Triangle with one exterior angle given (use 180 rule).
T3: Multi-step: around point + triangle combined (two anchor totals).

RetentionCheck(+7d):
QuickCheck(5):
Mix straight/point/triangle; must label totals.
PassRule:
4/5 correct + totals written.

VerifyUnderLoad:
TimedMixedSet:
10 items in 8 minutes; must show “total – known” line.
Explain1Sentence:
“Angle totals are conserved (180/360/triangle 180), so I subtract known from total.”

——————————————————————-

CT-S1M-FIX-23

——————————————————————-

FixProtocolID: CT-S1M-FIX-23
TargetInvariantID: CT-S1M-INV-23
Name: Mean as Total Conservation Repair (Total = Mean × Count)
MinimalExplanation(≤3 lines):
Mean is a summary of a conserved total.
Total = mean × number of items.
Missing value problems: build total ledger, then solve.

ILT_Module:
InvariantSpotlight:
OneSentence: “Mean problems conserve total: total = mean × count.”
LedgerReplay:
Show: averaging wrong count → mismatch → total ledger route → correct.
ReconciliationPrompt:
Student says: “Total is _ because mean×count.”

WorkedExamples(2):
Ex1:
Problem: Mean of 5 numbers is 12. What is their total?
Total = 12×5 = 60
Ex2:
Problem: Mean of 4 numbers is 10. Three numbers are 8, 11, 9. Find the fourth.
Total = 10×4=40; known sum=28; missing=12

AntiExamples(2):
Anti1:
Wrong: total = mean + count = 17
Breach: wrong operation.
Anti2:
Wrong: mean of 4 numbers is 10 → total 10
Breach: forgot multiplication by count.

DrillSet(10):

Mean of 6 numbers is 7. Total?
Mean of 8 numbers is 15. Total?
Mean of 5 numbers is 9. Four numbers sum to 30. Find fifth.
Mean of 4 numbers is 12. Numbers: 10, 15, 13, x. Find x.
Mean of 3 numbers is 18. Two numbers are 20 and 16. Find third.
Total of 7 numbers is 84. Mean?
Mean is 14 for 5 numbers. If one number is 22, others total?
Mean of 10 numbers is 6. One number removed leaves mean 5 for 9 numbers. Removed number?
Mean of 4 tests is 65. Scores: 60, 70, 68, x. Find x.
Total of 12 items is 96. Mean?

TransferTest(3):
T1: Weighted situation: mean of boys and girls; totals combined (simple).
T2: Add one new number changes mean (use total ledger).
T3: Two groups merge: mean of group A and B given with sizes, find combined mean.

RetentionCheck(+7d):
QuickCheck(5):
– Mean 9 of 6 numbers → total?
– Mean 20 of 3 numbers; two are 18 and 25 → third?
– Total 55 of 5 numbers → mean?
– Mean 12 of 5 numbers; known sum 44 → missing?
– Remove a number changes mean (short)
PassRule:
4/5 correct + total ledger line shown.

VerifyUnderLoad:
TimedMixedSet:
8 mean/missing-value items in 10 minutes.
Explain1Sentence:
“Mean conserves total, so I use total = mean × count and solve with a ledger.”

——————————————————————-

CT-S1M-FIX-24

——————————————————————-

FixProtocolID: CT-S1M-FIX-24
TargetInvariantID: CT-S1M-INV-24
Name: Median/Mode Repair (Order + Frequency Integrity)
MinimalExplanation(≤3 lines):
Median is the middle value AFTER ordering.
For even count: median is mean of the two middle values.
Mode is the most frequent value.

ILT_Module:
InvariantSpotlight:
OneSentence: “Median needs ordering; mode needs counting frequency.”
LedgerReplay:
Show: took median without ordering → wrong → order + pick middle.
ReconciliationPrompt:
Student says: “I ordered the data, then the middle is _.”

WorkedExamples(2):
Ex1:
Data: 7, 2, 9, 2, 5
Ordered: 2,2,5,7,9
Median=5, Mode=2
Ex2:
Data: 3, 8, 10, 6
Ordered: 3,6,8,10
Median=(6+8)/2=7, Mode=none

AntiExamples(2):
Anti1:
Wrong: median of 7,2,9,2,5 is 9 (picked random)
Breach: not ordered; wrong definition.
Anti2:
Wrong: mode is the biggest number
Breach: mode is frequency, not magnitude.

DrillSet(10):
Find median and mode:

4, 1, 6, 1, 9
10, 12, 10, 8, 7
3, 3, 3, 5, 6
2, 4, 6, 8
9, 9, 7, 5, 3, 1
11, 14, 11, 15, 16
6, 2, 6, 2, 6, 9
5, 5, 5, 5
1, 2, 3, 4, 5, 6
8, 3, 8, 7, 7, 7

TransferTest(3):
T1: Find median after adding one new value (how median shifts).
T2: A set has median 6; construct one possible data set of 5 numbers.
T3: Choose whether mean/median/mode best represents “typical” for an outlier set (concept).

RetentionCheck(+7d):
QuickCheck(5):
Mix odd/even counts; must show ordered list.
PassRule:
4/5 correct + ordering shown each time.

VerifyUnderLoad:
TimedMixedSet:
10 sets in 8 minutes (small sets); must order quickly.
Explain1Sentence:
“Median is the middle after ordering; mode is the most frequent.”

——————————————————————-

CT-S1M-FIX-25

——————————————————————-

FixProtocolID: CT-S1M-FIX-25
TargetInvariantID: CT-S1M-INV-25
Name: Working Memory Budget Repair (Chunking + Step Ledger)
MinimalExplanation(≤3 lines):
Many failures are load failures, not concept failures.
Reduce live load by chunking steps and writing a visible step ledger.
Always keep only one transformation per line.

ILT_Module:
InvariantSpotlight:
OneSentence: “I prevent load collapse by chunking and writing a step ledger.”
LedgerReplay:
Show: mental multi-step → drop sign/term → step ledger → stable.
ReconciliationPrompt:
Student says: “I wrote one step per line to avoid losing information.”

WorkedExamples(2):
Ex1:
Problem: 3(x-2)+2(x+5)
StepLedger:
– = 3x-6 + 2x+10
– = 5x+4
Ex2:
Problem: 2x + 5 = x – 7
StepLedger:
– 2x – x = -7 – 5
– x = -12

AntiExamples(2):
Anti1:
Wrong: 3(x-2)+2(x+5) = 3x-2+2x+5
Breach: dropped structure; memory collapse.
Anti2:
Wrong: 2x+5=x-7 → x= -7-5-2
Breach: compressed too many steps; lost invariant.

DrillSet(10):
Instruction: show step ledger with one transformation per line.

4(x+3)+2(x-1)
5(2x-3)- (x+4)
3x + 7 = 2x – 9
6x – 5 = 2x + 15
(x/3) + 4 = 10
2(x-5)=3(x+1)
7 – 2x = 1
3(x+2)+4 = 2(x+8)
5x – (2x – 3) = 18
2(3x-1) + (x+4)

TransferTest(3):
T1: Multi-step word equation (short) requiring 3+ steps; must use step ledger.
T2: Mixed fractions equation: (x/4)+2=5
T3: Expand both sides then solve: 2(x+3)=3(x-1)

RetentionCheck(+7d):
QuickCheck(5):
Must show step ledger and circle each transformation type (expand/simplify/solve).
PassRule:
4/5 correct + step ledger used in all 5.

VerifyUnderLoad:
TimedMixedSet:
6 multi-step items in 12 minutes; grading includes “ledger quality”.
Explain1Sentence:
“I prevented load collapse by writing a step ledger and doing one transformation per line.”

——————————————————————-

CT-S1M-FIX-26

——————————————————————-

FixProtocolID: CT-S1M-FIX-26
TargetInvariantID: CT-S1M-INV-26
Name: Verification Habit Repair (Substitute / Estimate / Units)
MinimalExplanation(≤3 lines):
Every answer must pass at least one verification method:
(1) substitution check, (2) estimation/direction check, (3) unit check.
Verification is not optional; it is how invariants are enforced.

ILT_Module:
InvariantSpotlight:
OneSentence: “I verify because correct answers preserve invariants under check.”
LedgerReplay:
Show: wrong answer accepted → check fails → repair → check passes.
ReconciliationPrompt:
Student says: “I checked by , and it passed because .”

WorkedExamples(2):
Ex1:
Problem: Solve 3x+5=20 → x=5
Verify:
– Substitute: 3(5)+5=20 ✓
Ex2:
Problem: 20% discount on $50 → $40
Verify:
– Direction: discount must reduce
– Estimate: 10% is $5, 20% is $10, so $50-$10=$40 ✓

AntiExamples(2):
Anti1:
Wrong: 3x+5=20 → x=6 (no check)
Check: 3(6)+5=23 ≠ 20
Anti2:
Wrong: 2 m + 30 cm = 32 m
Unit check fails (cm ≠ m without conversion)

DrillSet(10):
Instruction: solve then choose at least one verification method.

Solve: 4x-3=13
Solve: 2(x+5)=18
15% of 80
After 25% discount, price is $90. Original?
1/3 + 1/6
7/8 – 1/16
Speed: 150 km in 3 h
Convert: 2.4 m² to cm²
Ratio: 3:5 with 18 on first term
Mean: mean 12 for 5 numbers → total?

TransferTest(3):
T1: Given an answer, identify which verification check would catch an error fastest.
T2: Two-step word problem: solve then verify with estimate + units.
T3: Algebra solution: solve then verify by substitution.

RetentionCheck(+7d):
QuickCheck(5):
Must show check type used.
PassRule:
4/5 correct + verification shown in all 5.

VerifyUnderLoad:
TimedMixedSet:
8 items in 10 minutes; marking requires 1 check per item.
Explain1Sentence:
“I verified using substitution/estimation/units to confirm invariants are preserved.”

LOGGING (all FixProtocols):
Append to BreachLog:
{Date, StudentID, InvariantID, FixProtocolID, TimedMixed%, NovelPass, Explain1Sentence, Close(Y/N), NextRisk, RetentionDate}

md id=”3kq0c1″

CompletionNote.Sec1Math.ControlTower v1.0

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1

Status:

FixProtocolLibrary complete: CT-S1M-FIX-01 → CT-S1M-FIX-26
InvariantRegistry starter complete: CT-S1M-INV-01 → CT-S1M-INV-26
OnePanel operator board complete: ControlTower.OnePanel.Sec1Math v1.0

MinimumRunnableSystem:
Requires:
– Student Registry (IDs + Phase/Band)
– Weekly Sensors sheet (S1–S8)
– BreachLog (Invariant ledger)
– RepairPlan (choose up to 2 FixProtocols/week/student)
– Verify sheet (TimedMixed + NovelPass + Explain1Sentence)
Output:
– Parent summary (3 lines)
– Tutor repair queue
– Cohort correlated breach list
“`

“`md id=”m8q1s3″

ControlTower.Cohort.Sec1Math v1.0

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
Domain: EducationOS × MathOS × CentreOps
Scope: Multi-class Secondary 1 Mathematics Tuition (centre runtime)
Scale: Human(Z0–Z2) + CentreOps(Z2) + NetworkOps(Z3 optional)
Phase: Student P0–P3 with Cohort overlay
ChronoFlight: Structure × Phase × Time (weekly slices; node compression)
OutputType: Cohort dashboard + operating cadence + staffing + escalation rules

CONTRACT:
Goal:
Run Sec 1 Math across multiple classes as a stable Phase-3 corridor:
detect correlated failure early, prevent topic shearing, allocate repairs efficiently,
and keep performance stable as τ_node compresses.
NonGoals:
Not a marketing doc. Not a syllabus war. Not a “one-method fits all”.
SuccessConditions:
– Cohort: ≥80% students in +/0 band; – band shrinking week-on-week.
– Recurrence: cohort-level repeated invariant breaches trend to near zero.
– Node weeks: no mass rupture (no sudden cohort collapse under timed mixed sets).

——————————————————————-

1) Cohort State Model

——————————————————————-

DEFINITIONS:
ClassID: group of students taught together
CohortState X_C(k):
{ DistP, DistBand, TopBreaches, ShearNodes, LoadCollapseRate, ConfGapRate, τ_node, InterventionsActive }

DistP: distribution of phases {P0,P1,P2,P3}
DistBand: distribution of bands {+,0,−}
TopBreaches: ranked list of (InvariantID, frequency, recurrence)
ShearNodes: topic intersections causing structure breaks
LoadCollapseRate: % students with S6_LoadCollapse > threshold
ConfGapRate: % students with high ConfGap
τ_node: days to next assessment node for the cohort

BAND_HEALTH_METRICS:
H1: pct_plus = %(+Latt)
H2: pct_zero = %(0Latt)
H3: pct_minus = %(-Latt)
H4: drift_index = % with (Retention<θ or Transfer<θ) H5: rupture_risk = % with (τ_node≤7 AND Accuracy<55) OR (LoadCollapse>25) OR (Recurrence≥2)

——————————————————————-

2) Cohort Dashboard (One-Page)

——————————————————————-

COHORT_DASHBOARD:
A) Flight Overview (per class):
Columns:
ClassID | TutorID | τ_node | pct_plus | pct_zero | pct_minus | rupture_risk | Top3Breaches | Notes
B) Correlated Failure Map (centre-wide):
Rank TopBreaches across all classes:
– {InvariantID, CountStudentsAffected, RecurrenceRate, ClassesAffected}
C) Shear Node Map (topic intersections):
Identify “shear pairs” where breach spikes occur:
– {TopicA, TopicB, InvariantID, SpikeWeek, Evidence}
Common Sec1 shear examples:
– Algebra × Negatives
– Fractions × Word Problems (units)
– Ratio × Percent × Unitary
– Brackets × Simplification × Equation solving
D) Load Collapse Radar:
– % students failing timed mixed sets
– median latency shift week-on-week
– % students with working-memory budget breach (INV-25)
E) Intervention Queue (centre actions):
– “What to fix first” list:
{InvariantID → FixProtocolID → ClassIDs → ResponsibleTutor/Architect → Deadline}

——————————————————————-

3) Control Loop (Weekly Cadence)

——————————————————————-

WEEKLY_COHORT_LOOP:
Step1_Sense:
Collect per-student:
{Band, Phase, S1–S8 sensors, Top3 breaches, Verify results}
Step2_Classify:
Compute per-class:
pct_plus/pct_zero/pct_minus, rupture_risk, TopBreaches
Step3_Detect_CorrelatedFailure:
If same InvariantID appears in ≥30% of students in a class OR ≥3 classes centre-wide:
mark as CorrelatedFailure
Step4_Route_Interventions:
Choose intervention type:
– MicroRepair (student-level) using FixProtocol
– ClassRepair (whole class ILT spotlight + guided practice)
– ArchitectRepair (sequencing, prerequisite patch, drill redesign)
Step5_Verify:
Require VerifyUnderLoad on the targeted invariants:
TimedMixed + NovelPass + Explain1Sentence
Step6_Log:
Update CentreLedger:
{Week, ClassID, TopBreaches, InterventionUsed, VerifyOutcomes, NextRisk}

——————————————————————-

4) AVOO Staffing Layer (Centre Ops)

——————————————————————-

ROLES:
Operator (Tutor):
Executes FixProtocols, runs ILT, closes breaches, keeps class stable under load.
Architect (Curriculum/Sequencing Lead):
Detects shear nodes, patches missing prerequisites, designs drill sets and progression,
reduces choice overload for Operators.
Oracle (Diagnostics/Assessment Lead):
Designs diagnostic sets, maintains question registry tagging, validates sensors/thresholds.
Visionary (Programme Lead):
Sets corridor targets, defines standards for P3 readiness, manages centre-level strategy.

ROLE_ALLOCATION_RULES:
If CorrelatedFailure detected:
– Operator runs immediate class repair
– Architect investigates sequencing/prereq gaps
– Oracle validates sensor thresholds & question tagging
If τ_node ≤ 7 (node compression):
– Operator dominance (execution)
– Architect restricted to “minimal safe patching” (no new complexity)
– Oracle focuses on high-signal diagnostics only

——————————————————————-

5) Node Compression Playbook (τ_node → 0)

——————————————————————-

NODE_COMPRESSION_STATES:
StableCruise:
τ_node > 14
Actions:
– widen corridor (transfer + retention)
– allow deeper conceptual repairs
Drift:
7 < τ_node ≤ 14
Actions:
– lock to top 2 breach repairs/student
– mixed practice begins
– increase Verify frequency
CorrectiveTurn:
3 < τ_node ≤ 7
Actions:
– no new topics unless prerequisite patch
– timed mixed sets daily/alternate
– strict CloseRule enforcement
– focus: INV-25 (load) + INV-26 (verification) + top 3 topic breaches
DescentRisk:
τ_node ≤ 3
Actions:
– “stabilize and land” mode
– only high-yield repairs; remove choice overload
– operator scripts; reduce cognitive load
– confidence stabilization + error pattern control

NODE_WEEK_PRIORITIES (default):
Priority1: Stop rupture
– Fix INV-25 (working memory budget)
– Fix INV-26 (verification habit)
– Fix dominant breach (Top1 Invariant)
Priority2: Transfer stabilization
– 3-question transfer test daily
Priority3: Retention lock
– recheck last week’s closed breaches

——————————————————————-

6) Correlated Failure Escalation Rules

——————————————————————-

ESCALATION:
Level0 (Normal):
– correlated failure < 20% per class
Level1 (Amber):
Trigger:
– correlated failure ≥ 30% in any class OR
– same breach appears in ≥3 classes
Action:
– mandatory ILT spotlight lesson for that invariant
– shared drill set across classes
– verify within 7 days
Level2 (Red):
Trigger:
– correlated failure ≥ 45% in any class OR
– rupture_risk ≥ 25% in any class OR
– recurrence ≥ 2 for the same invariant for many students
Action:
– Architect-led patch (sequencing + prerequisite repair)
– Oracle audit: question tags + threshold calibration
– freeze new content for 1 week; repair sprint
Level3 (Critical):
Trigger:
– cohort collapse in a node week (mass timed failure)
Action:
– post-mortem ledger + rebuild corridor plan
– redesign diagnostics + drill architecture
– retrain operator scripts for next node

——————————————————————-

7) Centre Ledger (Invariant Ledger at Centre Scale)

——————————————————————-

LEDGER_INVARIANTS (Centre):
CT-CENTRE-INV-01: “No silent recurrence” (breach repeats → must reroute, never ignore)
CT-CENTRE-INV-02: “CloseRule enforced” (no ‘move on’ without verification)
CT-CENTRE-INV-03: “Node weeks reduce choice” (operators need narrow corridor)
CT-CENTRE-INV-04: “Architect patches reduce operator load” (sequencing removes chaos)
CT-CENTRE-INV-05: “Diagnostics must be high-signal” (avoid noisy tests under compression)

——————————————————————-

8) Minimal Implementation (Runnable Without Fancy Tools)

——————————————————————-

MINIMUM_RUNBOOK:
Tools:
– One Google Sheet (tabs: Students, WeeklySensors, BreachLog, RepairPlan, Verify, CentreLedger)
– A printed OnePanel per student (optional)
Weekly Meeting (30 minutes):
Agenda:
1) Show cohort dashboard
2) Pick Top2 correlated breaches centre-wide
3) Assign class repair + architect patch
4) Confirm Verify plan for next week
5) Log centre decisions (CentreLedger)

OUTPUTS:
Tutor:
– class TopBreaches + scripts + assigned FixProtocols
Parent:
– 3-line summary per student
Centre:
– CentreLedger + correlated failure trend lines (week-to-week)

md id=”2p1a7k”

CohortScripts.Sec1Math (Operator Short Scripts) v1.0

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
Use: Node-week low-choice scripts to stabilize corridor

SCRIPT_TEMPLATE:
ScriptID:
TargetInvariantID:
30sec_Explain:
1min_Demo:
3min_GuidedPractice:
2min_Verify:
ExitCriteria:

SCRIPTS (starter):
CT-SCRIPT-INV-03:
TargetInvariantID: CT-S1M-INV-03 (Distributive Integrity)
30sec_Explain: “Outside number multiplies every term inside; missing one term breaks equality.”
1min_Demo: Expand 3(x+4) and -2(2x-5), then substitution check with x=1.
3min_GuidedPractice: Students expand 2(x+7), 5(x-3), -3(x+2) with teacher call-and-response.
2min_Verify: 4 quick expansions timed + one substitution check.
ExitCriteria: ≥80% class correct + students say “every term” rule.

CT-SCRIPT-INV-11:
TargetInvariantID: CT-S1M-INV-11 (Common Denominator)
30sec_Explain: “You can’t add different-sized pieces. Make same denominator (same unit) first.”
1min_Demo: 1/3+1/6 via 6ths.
3min_GuidedPractice: 1/2+1/3, 3/4+1/8, 5/6-1/3 (together).
2min_Verify: 4 fraction add/sub tasks.
ExitCriteria: ≥80% correct + students state “same unit first”.

CT-SCRIPT-INV-25:
TargetInvariantID: CT-S1M-INV-25 (Working Memory Budget)
30sec_Explain: “One step per line prevents sign loss and dropped terms.”
1min_Demo: Solve 2x+5=x-7 with step ledger.
3min_GuidedPractice: Students solve 3x+7=2x-9 using one-step-per-line.
2min_Verify: 2 timed multi-step items; check ledger quality.
ExitCriteria: ≥80% correct + visible step ledger used.

“`

“`md id=”v2d4q8″

ShearAtlas.Sec1Math.PSLE→SecTransition v1.0

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
Domain: MathOS × EducationOS
Purpose: Identify the PSLE→Sec 1 “cliff points” as shear nodes (structure breaks),
then route repairs using named invariants + FixProtocols.
Scale: Human(Z1–Z2) + CohortOps(Z2)
Phase: P0–P3
ChronoFlight: Structure × Phase × Time (transition band; node compression weeks)
OutputType: Shear Node Map + Breach Signatures + Repair Routing

CONTRACT:
Goal:
Make the PSLE→Sec 1 transition continuous by detecting where structure breaks,
naming the invariant that failed, and stitching the corridor with a minimal repair.
NonGoals:
Not “more practice”. Not “harder papers”. Not “just be careful”.
SuccessCondition:
Students hold invariants under mixed, timed, novel questions (P3 corridor).

——————————————————————-

0) What is a Shear Node?

——————————————————————-

DEFINITIONS:
ShearNode:
A topic intersection where students can do each topic in isolation,
but fail when the topics combine under load (structure tears).
ShearSignature:
Error pattern flips from E6 (recall) to E2/E3 (model/manipulation) under mixing.
RepairPrinciple:
Patch prerequisites + reduce choice + name invariant + verify under load.

——————————————————————-

1) PSLE→Sec 1 Transition: Top Shear Nodes (Ranked)

——————————————————————-

SHEAR_NODE_LIST (most common first):
SN-01: Arithmetic Fluency × Negatives × Algebra (sign shear)
SN-02: Brackets × Expansion × Simplification (structure shear)
SN-03: Fractions × Word Problems × Units (meaning shear)
SN-04: Ratio × Proportion × Unitary Method (direction shear)
SN-05: Percent × Multiplicative Change × Reverse Problems (base shear)
SN-06: “Model” Thinking × Equation Translation (language-to-math shear)
SN-07: Order of Operations × Substitution (structure+load shear)
SN-08: Geometry Units × Area/Perimeter × Conversion (unit ledger shear)
SN-09: Data Handling × Mean/Median/Mode (definition shear)
SN-10: Load × Time Pressure × Mixed Paper (execution rupture)

——————————————————————-

2) Shear Node Cards (Each = Detect → Name → Repair Route)

——————————————————————-

————————-

SN-01

————————-

ShearNodeID: SN-01
Name: Sign Shear (Negatives enter Algebra)
TypicalTrigger:

solving equations with negative constants/coefficients
expanding brackets with negative multipliers
simplifying expressions with subtraction
BreachSignature:
-(a+b) becomes -a+b
5-(-2)=3
distributes negative wrongly, flips sign randomly
DominantInvariants:
CT-S1M-INV-06 (Integer Sign Consistency)
CT-S1M-INV-01 (Equality Preservation)
CT-S1M-INV-03 (Distributive Integrity)
ErrorTypes:
E4 (fluency load collapse) + E3 (manipulation break)
RepairRoute:
Step1: CT-S1M-FIX-06 (Integer Signs)
Step2: CT-S1M-FIX-03 (Distributive Integrity)
Step3: CT-S1M-FIX-01 (Equality Preservation)
Verify:
TimedMixed includes: negatives + brackets + solve (6 items/6 min)
Explain: “subtraction is adding a negative” + “negative distributes to every term”

————————-

SN-02

————————-

ShearNodeID: SN-02
Name: Bracket Structure Shear (Expansion + Like Terms)
TypicalTrigger:

simplifying after expansion
two brackets or bracket + constants
BreachSignature:
misses a term: 3(x+4)=3x+4
combines unlike terms: 3x+5=8x
DominantInvariants:
CT-S1M-INV-03 (Distributive Integrity)
CT-S1M-INV-04 (Like-Term Combination Only)
ErrorTypes:
E3 (manipulation break)
RepairRoute:
Step1: CT-S1M-FIX-03 (Distributive Integrity)
Step2: CT-S1M-FIX-04 (Like Terms Only)
Step3: CT-S1M-FIX-25 (Step Ledger / Working Memory Budget) if collapse persists
Verify:
8 expansions + 6 simplify tasks timed
substitution check on 1 item to prove equivalence

————————-

SN-03

————————-

ShearNodeID: SN-03
Name: Fraction Meaning Shear (Operator + Units)
TypicalTrigger:

“fraction of”, sharing, rates, mixed contexts
fraction add/sub mixed with word problems
BreachSignature:
adds tops & bottoms; treats fraction as two numbers
wrong unit handling: adds unlike denominators
DominantInvariants:
CT-S1M-INV-09 (Fraction Meaning)
CT-S1M-INV-11 (Common Denominator)
CT-S1M-INV-17 (Unit Consistency Ledger)
ErrorTypes:
E2 (wrong model) + E6 (recall hole)
RepairRoute:
Step1: CT-S1M-FIX-09 (Fraction Meaning)
Step2: CT-S1M-FIX-11 (Common Denominator)
Step3: CT-S1M-FIX-17 (Unit Consistency) if word problems still fail
Verify:
3 “of” questions + 4 add/sub + 3 word items under time
student explains: “denominator is unit size”

————————-

SN-04

————————-

ShearNodeID: SN-04
Name: Ratio/Unitary Direction Shear (Scaling)
TypicalTrigger:

ratio word problems
finding missing term in proportion
rates “per 1” with reverse scaling
BreachSignature:
adds same number to ratio parts
inverts scaling (more items → cheaper cost)
DominantInvariants:
CT-S1M-INV-13 (Ratio Multiplicative Core)
CT-S1M-INV-14 (Unitary Method)
CT-S1M-INV-19 (Scaling Sanity Check)
ErrorTypes:
E2 (wrong operation/model)
RepairRoute:
Step1: CT-S1M-FIX-13 (Ratio Core)
Step2: CT-S1M-FIX-14 (Unitary)
Step3: CT-S1M-FIX-19 (Sanity Check) to prevent inversions
Verify:
2 ratio scale + 2 missing term + 2 unitary reverse + 1 sanity check explanation

————————-

SN-05

————————-

ShearNodeID: SN-05
Name: Percent Base Shear (Change + Reverse)
TypicalTrigger:

discounts, GST-style, increase/decrease, original price
BreachSignature:
subtracts “20” from price instead of 20%
reverse uses multiply instead of divide
DominantInvariants:
CT-S1M-INV-15 (Percent Identity)
CT-S1M-INV-16 (Multiplicative Change)
CT-S1M-INV-19 (Sanity Check)
ErrorTypes:
E2 (wrong base/model)
RepairRoute:
Step1: CT-S1M-FIX-15 (Percent Identity)
Step2: CT-S1M-FIX-16 (Multiplier + Reverse)
Step3: CT-S1M-FIX-19 (Sanity Check) as guard rail
Verify:
2 conversions + 3 forward change + 3 reverse change timed

————————-

SN-06

————————-

ShearNodeID: SN-06
Name: Language-to-Equation Shear (Model Translation)
TypicalTrigger:

“sum”, “difference”, “twice”, “5 less than”
multi-step word equations
BreachSignature:
random operations on numbers
reverses phrasing: “5 less than twice x” → 5-2x
DominantInvariants:
CT-S1M-INV-18 (Known/Unknown Separation)
CT-S1M-INV-17 (Units)
CT-S1M-INV-01 (Equality Preservation) (after model)
ErrorTypes:
E1 (misread/parse) + E2 (wrong model)
RepairRoute:
Step1: CT-S1M-FIX-18 (Let x be…)
Step2: CT-S1M-FIX-17 (Units ledger tags) if context quantities present
Step3: CT-S1M-FIX-01 (Solve with equality preservation)
Verify:
6 translate-to-equation tasks + solve 3, timed

————————-

SN-07

————————-

ShearNodeID: SN-07
Name: Structure Shear Under Substitution (Order + Brackets)
TypicalTrigger:

evaluate expressions with negatives/brackets/powers
BreachSignature:
-2^2 confusion
ignores order: adds before multiply
DominantInvariants:
CT-S1M-INV-05 (Substitution Validity)
CT-S1M-INV-07 (Order of Operations)
ErrorTypes:
E3/E4 (structure + load)
RepairRoute:
Step1: CT-S1M-FIX-05 (Substitution discipline)
Step2: CT-S1M-FIX-07 (Order of operations)
Verify:
8 evaluate tasks incl negatives, timed; must show brackets

————————-

SN-08

————————-

ShearNodeID: SN-08
Name: Unit Ledger Shear in Geometry (P vs A vs Conversion)
TypicalTrigger:

perimeter vs area confusion
cm² ↔ m² conversion
BreachSignature:
uses wrong formula; wrong unit labels
1 m² = 100 cm²
DominantInvariants:
CT-S1M-INV-20 (Perimeter vs Area)
CT-S1M-INV-21 (Area unit squaring)
CT-S1M-INV-17 (Units)
ErrorTypes:
E6 (definition) + E2 (unit conversion model)
RepairRoute:
Step1: CT-S1M-FIX-20 (P vs A)
Step2: CT-S1M-FIX-21 (square factor)
Step3: CT-S1M-FIX-17 (unit ledger discipline)
Verify:
4 P/A + 4 conversions + 2 shape-area tasks timed

————————-

SN-09

————————-

ShearNodeID: SN-09
Name: Data Definition Shear (Mean vs Median vs Mode)
TypicalTrigger:

missing value mean problems
median without ordering
BreachSignature:
median chosen without sorting
total not conserved in mean
DominantInvariants:
CT-S1M-INV-23 (Mean total conservation)
CT-S1M-INV-24 (Median/mode integrity)
ErrorTypes:
E6 (definition)
RepairRoute:
Step1: CT-S1M-FIX-23 (mean ledger)
Step2: CT-S1M-FIX-24 (median/mode)
Verify:
4 mean items (incl missing) + 4 median/mode timed

————————-

SN-10

————————-

ShearNodeID: SN-10
Name: Mixed-Paper Rupture (Load + Time + Switching)
TypicalTrigger:

test weeks; mixed-topic timed sets
BreachSignature:
correct when untimed; collapses timed
sign errors increase, steps dropped, random guessing
DominantInvariants:
CT-S1M-INV-25 (Working memory budget)
CT-S1M-INV-26 (Verification habit)
CT-S1M-INV-19 (Sanity check)
ErrorTypes:
E4 (load collapse)
RepairRoute:
Step1: CT-S1M-FIX-25 (step ledger + chunking)
Step2: CT-S1M-FIX-26 (verification habit)
Step3: CT-S1M-FIX-19 (sanity check) as guard rail
Verify:
8 mixed timed items with mandatory 1 check per item
track S6_LoadCollapse week-on-week

——————————————————————-

3) ShearNode Detection Rules (Cohort Ops)

——————————————————————-

DETECT_SHEAR_NODE:
For each class and week:
If (Transfer < θ_Tr OR Retention < θ_Ret) AND (TopicMix present) AND (ErrorType shifts to E2/E3/E4):
Flag ShearNode
If same ShearNode flagged 2 weeks in a row:
Escalate to ArchitectRepair (sequencing/prereq patch)

SHEAR_NODE_EVIDENCE_REQUIREMENT:
Must log at least:
– 2 TriggerQIDs
– 1 dominant InvariantID
– Verify outcome after intervention

——————————————————————-

4) Repair Routing Table (ShearNode → FixProtocol)

——————————————————————-

ROUTING_TABLE:
SN-01 -> FIX-06 + FIX-03 + FIX-01
SN-02 -> FIX-03 + FIX-04 (+ FIX-25 if load)
SN-03 -> FIX-09 + FIX-11 (+ FIX-17)
SN-04 -> FIX-13 + FIX-14 + FIX-19
SN-05 -> FIX-15 + FIX-16 + FIX-19
SN-06 -> FIX-18 (+ FIX-17) + FIX-01
SN-07 -> FIX-05 + FIX-07
SN-08 -> FIX-20 + FIX-21 (+ FIX-17)
SN-09 -> FIX-23 + FIX-24
SN-10 -> FIX-25 + FIX-26 + FIX-19

——————————————————————-

5) Implementation Note (How to Use in Tuition)

——————————————————————-

USAGE:
Per student:
Identify which ShearNode they’re in (SN-01..SN-10).
Pull the routing table → assign 1–2 FixProtocols for the week.
Per class:
Rank top 2 ShearNodes by frequency.
Run one class-wide ILT spotlight for the #1 shear node.
Per centre:
If same ShearNode appears in ≥3 classes:
issue a shared “Shear Patch Pack” (same scripts + drill sets + verify plan).

OUTPUT:

A “ShearNode Report” (weekly) for tutors and centre lead:
{ClassID, τ_node, TopShearNodes, TopInvariants, AssignedFixProtocols, VerifyPassRate}

“`

“`md id=”z7k2p9″

ShearPatchPack.Sec1Math.SN-01 v1.0

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
PackType: Print-ready Micro-Intervention
ShearNode: SN-01 (Sign Shear: Negatives enter Algebra)
Duration: 15 minutes (class) + 10 minutes (home)
Targets:
– CT-S1M-INV-06 (Integer Sign Consistency)
– CT-S1M-INV-03 (Distributive Integrity)
– CT-S1M-INV-01 (Equality Preservation)
FixProtocols:
– CT-S1M-FIX-06 → CT-S1M-FIX-03 → CT-S1M-FIX-01
SuccessProof:
TimedMixed + NovelPass + Explain1Sentence

CONTRACT:
Goal:
Stop sign chaos by making negatives “objects” with stable rules,
then applying them inside brackets and equations.
NonGoal:
Not speed training alone; must stabilize meaning + operations.

A) 15-MIN CLASS SCRIPT (Operator, low-choice)
Minute0-1 (Invariant Spotlight):
Say:
1) “Subtraction is adding a negative.”
2) “A negative outside brackets hits EVERY term.”
3) “Equation stays true only if we do the same to both sides.”
Minute1-3 (Demo 1: Subtraction as add-negative):
Board:
– 5 – (-3) = 5 + 3 = 8
– 7 – 4 = 7 + (-4) = 3
Micro-check:
Students rewrite 9 – (-2) as 9 + 2.
Minute3-6 (Demo 2: Negative distributes):
Board:
– -(x+4) = -x – 4
– -2(2x-5) = -4x + 10
Substitution check (x=1):
LHS = -2( -3 )=6; RHS = -4+10=6 ✓
Minute6-10 (Guided Practice: Call-and-response):
Q1: -(x-3) = _ Q2: -3(x+2) =
Q3: 2 – (-x) = Q4: – (2x – 7) = _
Rule reminder after each: “Every term. Every time.”
Minute10-13 (Equation Repair):
Solve with clean steps:
– x – 7 = -3 → x = 4
– 2x + 5 = x – 7 → x = -12
Emphasize:
“Do the same to both sides; don’t ‘teleport’ signs.”
Minute13-15 (Verify-under-load mini):
4 items, 3 minutes, timed:
1) 6 – (-5)
2) -2(x+3) expand
3) Solve: x + 8 = -4
4) Simplify: -(2x-9)

B) DRILL SET (HOME, 10 minutes)
Instruction:
Show one step per line. Circle sign changes.
Drill(12):
1) 8 – (-7)
2) -9 + (-4)
3) -6 – 3
4) -5 – (-2)
5) (-3)(7)
6) (-4)(-6)
7) 24 ÷ (-3)
8) (-18) ÷ (-6)
9) -(x+5) expand
10) -3(2x-1) expand
11) Solve: x – 9 = -2
12) Solve: 3x + 2 = -7

C) TRANSFER TEST (3 items)
T1: Simplify: -2(3x – 4) – (x – 6)
T2: Solve: 5 – x = -3
T3: Evaluate: x^2 – 3x when x = -2 (must bracket)

D) VERIFY CHECKLIST (Close Rule)
TimedMixed (6 items / 6 min):
include:
– 2 integer ops
– 2 bracket expansions with negatives
– 2 linear equations with negative constants
NovelPass:
at least 1 unfamiliar mixed item correct (from Transfer Test)
Explain1Sentence:
Student must say:
“Subtraction is adding a negative, and a negative outside brackets hits every term.”

E) LOG ENTRY (Ledger)
Append:
{Date, StudentID/ClassID, ShearNode=SN-01, InvariantIDs=[INV-06,INV-03,INV-01],
FixProtocols=[FIX-06,FIX-03,FIX-01], VerifyResult, NextRisk, RetentionDate(+7d)}

RETENTION CHECK (+7 days)
Quick(5):
– 7 – (-4)
– -(x-2) expand
– -2(2x+1) expand
– Solve: x+3=-8
– Solve: 2x-5=-13

md id=”n4t6k1″

ShearPatchPack.Sec1Math.SN-02 v1.0

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
PackType: Print-ready Micro-Intervention
ShearNode: SN-02 (Bracket Structure Shear)
Duration: 15 minutes (class) + 10 minutes (home)
Targets:
– CT-S1M-INV-03 (Distributive Integrity)
– CT-S1M-INV-04 (Like-Terms Only)
– CT-S1M-INV-25 (Working Memory Budget) [guard]
FixProtocols:
– CT-S1M-FIX-03 → CT-S1M-FIX-04 (+ CT-S1M-FIX-25 if load)
SuccessProof:
Expansion + simplify stable under time + substitution check passes.

A) 15-MIN CLASS SCRIPT
Minute0-1 (Invariant Spotlight):
Say:
1) “Outside number hits EVERY term inside.”
2) “Only same-shape terms combine.”
3) “One step per line prevents missing terms.”
Minute1-4 (Demo: ‘Every Term’):
Board:
3(x+4)=3x+12
-2(2x-5)=-4x+10
Substitution check x=1:
Show LHS=RHS.
Minute4-7 (Guided Practice: Expansion):
Students do:
1) 2(x+7)
2) 5(x-3)
3) -3(x+2)
Tutor call:
“Every term. Every time.”
Minute7-10 (Demo: Like Terms / Same Shape):
Board:
3x + 5x – 2x = 6x
4a + 3 – 2a + 7 = 2a + 10
Say:
“x-shape combines with x-shape; constants with constants.”
Minute10-13 (Guided Practice: Expand then Simplify):
1) 3(x+2)+2(x-1)
2) -2(2x-3)+x
Minute13-15 (Timed verify mini):
4 items / 3 minutes:
– Expand 4(x-3)
– Expand -5(2x+1)
– Simplify 2x+7x-3
– Expand+Simplify 3(x+1)+2(x+4)

B) DRILL SET (HOME, 10 minutes)
Instruction:
One step per line; box each expansion line.
Drill(12):
1) 4(x+5)
2) 6(x-2)
3) -2(x+7)
4) -5(x-3)
5) 3(2x+1)
6) -4(3x-2)
7) 2(x+4)+3(x+1)
8) 5(x-2)-2(x+3)
9) 3(x+7)-x
10) -2(2x-1)+5x
11) 4(x-3)+2(3x+1)
12) -3(x+2)-2(x-5)

C) TRANSFER TEST (3 items)
T1: 3(2x – 5) + 4(x + 1) simplify fully
T2: -2(3x – 4) – (x – 6) simplify fully
T3: Solve: 5(x – 2) = 3(x + 4)

D) VERIFY CHECKLIST
TimedMixed (8 items / 6 min):
– 4 expansions (incl negative multipliers)
– 4 expand→simplify items
NovelPass:
1 unseen “two brackets” style item correct
Explain1Sentence:
Student must say:
“The outside factor multiplies every term, then I only combine like terms.”

E) LOAD GUARD (if collapse persists)
Trigger:
missed-term rate > 20% OR signs dropped under time
Action:
apply CT-S1M-FIX-25 for 1 week (step ledger discipline)

RETENTION CHECK (+7 days)
Quick(5):
– Expand -2(x-6)
– Expand 3(2x+5)
– Simplify 6x-2x+3
– Expand+Simplify 2(x+7)+3(x-1)
– Solve 2(x+3)=3(x-1)

md id=”p1f0z6″

ShearPatchPack.Sec1Math.SN-03 v1.0

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
PackType: Print-ready Micro-Intervention
ShearNode: SN-03 (Fraction Meaning Shear)
Duration: 15 minutes (class) + 10 minutes (home)
Targets:
– CT-S1M-INV-09 (Fraction Meaning as Operator/Division)
– CT-S1M-INV-11 (Common Denominator = same unit)
– CT-S1M-INV-17 (Unit Consistency) [when word problems involved]
FixProtocols:
– CT-S1M-FIX-09 → CT-S1M-FIX-11 (+ CT-S1M-FIX-17 when units appear)
SuccessProof:
Fraction “of” + add/sub + word context stable under time.

A) 15-MIN CLASS SCRIPT
Minute0-1 (Invariant Spotlight):
Say:
1) “A fraction means division.”
2) “Denominator tells unit size.”
3) “Add/sub only after same unit (same denominator).”
Minute1-4 (Demo: Fraction as operator):
Board:
3/4 of 20 = (3/4)×20 = 15
Verbal:
“Divide by 4, then take 3 parts.”
Minute4-7 (Guided Practice: ‘of’ problems):
Students do:
1) 2/3 of 18
2) 5/6 of 24
3) 3/5 of 40
Tutor call:
“Divide by denominator first.”
Minute7-10 (Demo: Common denominator):
Board:
1/3 + 1/6 = 2/6 + 1/6 = 1/2
Unit talk:
“thirds and sixths are different piece sizes.”
Minute10-13 (Guided Practice: add/sub):
1) 1/2 + 1/3
2) 5/6 – 1/3
3) 3/4 + 1/8
Minute13-15 (Timed verify mini):
4 items / 3 minutes:
– 3/4 of 12
– 1/4 + 1/6
– 7/8 – 1/16
– A tank is 3/5 full of 50 L. How many liters?

B) DRILL SET (HOME, 10 minutes)
Drill(12):
Operator meaning (“of”):
1) 4/5 of 35
2) 3/2 of 10
3) 1/8 of 64
4) 5/3 of 12
Add/Sub (common denom):
5) 1/3 + 1/4
6) 2/5 + 3/10
7) 5/12 – 1/3
8) 7/8 – 1/16
Mixed word:
9) 2/3 of a class of 30 students. How many students?
10) 3/4 of 48 minutes. How many minutes?
11) A rope is 5/6 m. 1/3 m is cut off. Length left?
12) A jug has 2/5 of 25 L. How many liters?

C) TRANSFER TEST (3 items)
T1: 2 1/3 + 1 1/6
T2: A recipe uses 3/4 cup sugar. If you make 2/3 of the recipe, how much sugar?
T3: 1/(x) + 1/6 = 1/2 (solve for x using “same unit” thinking)

D) VERIFY CHECKLIST
TimedMixed (10 items / 7 min):
– 3 “of” items
– 4 add/sub items
– 3 short word items with units
NovelPass:
1 unfamiliar mixed-number fraction item correct
Explain1Sentence:
Student must say:
“Denominator is unit size, so I make denominators the same before adding/subtracting.”

E) UNIT LEDGER ADD-ON (if word context fails)
Trigger:
student mixes liters and fractions incorrectly OR misreads “of”
Action:
apply CT-S1M-FIX-17 for 1 week:
write unit tags each step (L, $, minutes)

RETENTION CHECK (+7 days)
Quick(5):
– 3/5 of 50
– 1/4 + 1/6
– 5/6 – 1/3
– 3/4 of 48 minutes
– 2/7 of 21

“`

“`md id=”b1r8k0″

BridgePlan.PSLE→Sec1Math.Corridor v1.0

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
SiteContext: BukitTimahTutor.com
Domain: EducationOS × MathOS
Scope: PSLE Mathematics → Secondary 1 Mathematics Transition (Bridge Corridor)
Scale: Human(Z1→Z2) + CentreOps(Z2)
PhaseTarget: move students toward stable P2→P3 corridor by Week 6–8
ChronoFlight: Transition Band (Structure × Phase × Time), weekly slices
RuntimeDependencies:
– ControlTower.OnePanel.Sec1Math v1.0
– InvariantRegistry.Sec1Math v1.0 (INV-01..26)
– FixProtocolLibrary.Sec1Math v1.0 (FIX-01..26)
– ShearAtlas.Sec1Math.PSLE→SecTransition v1.0
– ShearPatchPack SN-01, SN-02, SN-03 v1.0

CONTRACT:
Goal:
Prevent the “Sec 1 cliff” by pre-emptively patching the highest-frequency shear nodes,
enforcing CloseRule verification, and stabilizing transfer under timed mixed load.
NonGoals:
Not a full Sec 1 syllabus replacement.
Not endless practice.
Not speed-first without invariants.
SuccessConditions (by Week 6–8):
– Majority students in +/0 bands; – band shrinking
– Recurrence of top breaches → near zero
– Timed mixed sets pass rate ≥70% with verification habit visible

——————————————————————-

0) Operating Cadence (per lesson)

——————————————————————-

LESSON_LOOP (60–90 min):
1) PreCheck(10m):
– 6-question micro diagnostic (2 transfer + 2 timed + 2 last-week retention)
2) Teach(20–25m):
– ILT spotlight: name 1 invariant; show 1 breach; show 1 correct ledgered move
3) Repair(20–30m):
– assign 1–2 FixProtocols max (low-choice corridor)
4) Verify(10–15m):
– TimedMixed + NovelPass + Explain1Sentence
5) Log(5m):
– BreachLog + Close(Y/N) + RetentionDate(+7d)

CLOSE_RULE:
Close breach only if:
TimedMixed≥70% AND NovelPass=Yes AND Explain1Sentence=Pass

——————————————————————-

1) Intake & Baseline (Week 0 / First Session)

——————————————————————-

WEEK0_INTAKE:
Purpose:
Build initial flight state + ledger: no guessing.
Diagnostics (20–30m):
D1: Signs + integer ops (INV-06)
D2: Brackets expansion (INV-03)
D3: Like terms (INV-04)
D4: Fraction meaning + add/sub (INV-09, INV-11)
D5: Ratio/Unitary direction (INV-13, INV-14, INV-19)
D6: Percent identity (INV-15)
D7: Word-to-equation (INV-18)
Outputs:
– Each student gets:
Phase estimate P0–P3
Band (+/0/−) for each cluster
Top3 invariant breaches
Initial RepairQueue (2 FixProtocols for Week 1)
ParentLine (3 lines):
– Phase/Band + main cliff risk
– Top breach + repair plan
– Verification proof policy (CloseRule)

——————————————————————-

2) 8-Week Bridge Corridor (Default)

——————————————————————-

PLAN_8W:
Week1:
Theme: SN-01 Sign Shear (negatives enter algebra)
Pack: ShearPatchPack.SN-01
CoreInvariants: INV-06, INV-03, INV-01
FixProtocols: FIX-06 → FIX-03 → FIX-01
VerifyGate:
– 6 items/6 min mixed (negatives + brackets + solve)
– Explain1Sentence required

Week2:
Theme: SN-02 Bracket Structure Shear (expand + simplify)
Pack: ShearPatchPack.SN-02
CoreInvariants: INV-03, INV-04 (+ INV-25 guard)
FixProtocols: FIX-03 → FIX-04 (+ FIX-25 if load)
VerifyGate:
– 8 expansions + 6 simplify timed
– 1 substitution check to prove equivalence

Week3:
Theme: SN-03 Fraction Meaning Shear (operator + common denominator)
Pack: ShearPatchPack.SN-03
CoreInvariants: INV-09, INV-11 (+ INV-17 units when word context)
FixProtocols: FIX-09 → FIX-11 (+ FIX-17 as needed)
VerifyGate:
– 10 items/7 min (of + add/sub + 3 word items)

Week4:
Theme: Ratio / Unitary Direction Shear (scaling without inversion)
CoreInvariants: INV-13, INV-14, INV-19
FixProtocols: FIX-13 → FIX-14 → FIX-19
VerifyGate:
– 10 ratio/unitary items/8 min incl reverse scaling
– direction statement required on 4 items

Week5:
Theme: Percent + Multiplicative Change (forward + reverse)
CoreInvariants: INV-15, INV-16, INV-19
FixProtocols: FIX-15 → FIX-16 → FIX-19
VerifyGate:
– 8 items/8 min incl reverse original price
– sanity check line mandatory

Week6:
Theme: Language-to-Equation (model translation stability)
CoreInvariants: INV-18 (+ INV-17 when units present) + INV-01
FixProtocols: FIX-18 (+ FIX-17) → FIX-01
VerifyGate:
– 6 translate-to-equation + solve 3 (timed 12 min)
– “Let x be …” must appear in all solutions

Week7:
Theme: Geometry Unit Ledger (P vs A + squared conversions) + Angle anchors
CoreInvariants: INV-20, INV-21, INV-17, INV-22
FixProtocols: FIX-20 → FIX-21 (+ FIX-17) + FIX-22
VerifyGate:
– 10 items/10 min mix P/A + area conversion + angle totals
– correct units required (cm vs cm²)

Week8:
Theme: Mixed-Paper Stabilization (load + verification = anti-rupture)
CoreInvariants: INV-25, INV-26, INV-19
FixProtocols: FIX-25 → FIX-26 → FIX-19
VerifyGate:
– 12 mixed items/15 min
– mandatory 1 verification step per item
– track S6_LoadCollapse improvement week-on-week

——————————————————————-

3) 6-Week Compressed Bridge (Late Joiners)

——————————————————————-

PLAN_6W (compress, preserve order of cliffs):
Week1: SN-01 (sign shear) + SN-02 (mini) [FIX-06 + FIX-03 + FIX-04]
Week2: SN-03 (fraction meaning) [FIX-09 + FIX-11]
Week3: Ratio/Unitary [FIX-13 + FIX-14 + FIX-19]
Week4: Percent/Change [FIX-15 + FIX-16 + FIX-19]
Week5: Word-to-Equation [FIX-18 + FIX-01]
Week6: Mixed-Paper Stabilization [FIX-25 + FIX-26 + FIX-19]
Rule:
Do not add new content if CloseRule is failing; patch corridor first.

——————————————————————-

4) Shear Node Routing (Per Student)

——————————————————————-

PER_STUDENT_ROUTING:
Each week:
– Identify TopShearNode SN-01..SN-10
– Assign max 2 FixProtocols (low-choice corridor)
– Verify → Close or keep open
Default mapping:
SN-01 -> FIX-06 + FIX-03 (+ FIX-01)
SN-02 -> FIX-03 + FIX-04 (+ FIX-25)
SN-03 -> FIX-09 + FIX-11 (+ FIX-17)
SN-04 -> FIX-13 + FIX-14 (+ FIX-19)
SN-05 -> FIX-15 + FIX-16 (+ FIX-19)
SN-06 -> FIX-18 (+ FIX-17) + FIX-01
SN-10 -> FIX-25 + FIX-26 (+ FIX-19)

——————————————————————-

5) Node Compression Handling (School Test Weeks)

——————————————————————-

NODE_COMPRESSION (τ_node ≤ 7):
Mode: “Stabilize and Land”
Rules:
– freeze new content unless prerequisite patch
– focus on top 1 breach + INV-25 + INV-26
– daily 6-question mixed timed set
– mandatory verification step on each item
Output:
– weekly “Node Week Flight Log” for parents:
{Band, TopBreach, VerifyPassRate, NextRisk}

——————————————————————-

6) Evidence Pack (What Proves It Worked)

——————————————————————-

EVIDENCE_PACK:
For each student:
– Week0 baseline diagnostic snapshot
– BreachLog with closed breaches + verify proof
– Retention checks (+7d) for closed items
– Week6/8 mixed-paper stability result (TimedMixed + Verification Habit)
For cohort:
– TopBreaches trend line (week-on-week)
– LoadCollapseRate trend line
– pct_minus shrinking indicator

——————————————————————-

7) Minimal Artefacts to Publish/Run

——————————————————————-

MINIMUM_ARTEFACTS:

ControlTower.OnePanel.Sec1Math (printable)
FixProtocolLibrary (01–26)
ShearAtlas + ShearPatchPacks (SN-01..03)
BridgePlan (this)
Parent Report Template (3-line output)

PARENT_REPORT_TEMPLATE (auto):
Line1: “Phase/Band now + τ_node risk status”
Line2: “Top invariant breach + FixProtocol used”
Line3: “Proof: TimedMixed% + NovelPass + Explain1Sentence + next retention date”

“`

			
# BukitTimahTutor Article (Parent-Facing) — Preventing the Sec 1 Math “Cliff” v1.0
META:
  UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
  Brand: BukitTimahTutor.com
  Domain: Secondary 1 Mathematics Tuition
  CoordinateStandard: BukitTimah Lattice (Lane×Zoom×Role)
  Lane: MathOS.Sec1
  Zoom: Z2 (Secondary)
  Roles: Parent | Student | Tutor(Operator) | ProgrammeLead(Architect)
  Phase: P0–P3 (learning corridor states)
  OutputType: Parent Article (Google-friendly, mechanism-first)
## 1) What is the “Secondary 1 Math Cliff”?
DEFINITION:
  The Sec 1 Math “cliff” is not just “harder questions”.
  It is a STRUCTURE CHANGE: more symbols, more mixing of topics, and more time pressure.
  Many students can do skills separately, but their thinking breaks when those skills combine.
MECHANISM (what actually breaks):
  - Negatives enter algebra → sign mistakes multiply
  - Brackets + simplification combine → missing terms / wrong merges
  - Fractions meet word problems → meaning collapses (units + denominators)
  - Ratio + percent + unitary method mix → scaling direction flips
  - Timed mixed papers → working memory collapses even if concept is present
WHY THIS MATTERS:
  If the “break point” is not repaired early, students build new topics on broken foundations.
  That creates recurring errors, low confidence, and a cycle of “I practiced but still fail”.
## 2) Our Approach: A Sec 1 Math Control Tower (Proof > Promises)
DEFINITION:
  A “Control Tower” is a simple operating system for tuition:
  Detect → Name the real break → Repair the exact break → Verify under load → Log it so it doesn’t return.
WHAT WE DO (in parent language):
  Step 1 — Diagnose (not guess):
    We run a short diagnostic to identify the TOP 1–3 structural breaks (not “careless mistakes”).
  Step 2 — Repair (small and targeted):
    We fix the exact misunderstanding using a short repair protocol (10–20 minutes).
  Step 3 — Verify (proof under pressure):
    We retest with a timed + mixed + slightly new question.
  Step 4 — Retention (make it stick):
    We recheck 7–14 days later to prevent silent relapse.
PROMISE WE DON’T MAKE:
  We don’t say “do more practice”.
  If the underlying rule is broken, more practice can automate the wrong thing.
## 3) What We Measure (Simple, Practical Signals)
SENSORS (what we track):
  - Accuracy: can they get it correct?
  - Speed/Latency: do they freeze because the steps overload them?
  - Transfer: can they solve a NEW version of the problem (not just memorised templates)?
  - Retention: can they still do it after 7–14 days?
  - Load collapse: do they fail only when timed/mixed?
  - Recurrence: does the same error keep coming back?
INTERPRETATION:
  - If accuracy is okay but transfer/retention is weak → the understanding is fragile.
  - If untimed is fine but timed collapses → it’s a load/structure problem, not “laziness”.
## 4) What Parents Will Receive (Weekly Proof Summary)
PARENT OUTPUT (3 lines, every week):
  Line 1: Current Phase/Band + next test risk (stable / drifting / compressed)
  Line 2: Top structural break we fixed (named) + what we used to fix it
  Line 3: Proof: timed score + a “new-style” pass + next retention check date
WHY THIS HELPS:
  You can see whether your child is improving in the way that matters:
  not only “today can do”, but “next month still can do”, under real test conditions.
## 5) The Bridge Plan (PSLE → Sec 1) in 8 Weeks
CORE IDEA:
  We patch the biggest “cliff points” first, in the order they usually break.
8-WEEK MAP (summary):
  Week 1: Negatives + signs in algebra (stop sign chaos)
  Week 2: Brackets → expand → simplify (stop missing-term errors)
  Week 3: Fraction meaning + denominators (stop fraction collapse)
  Week 4: Ratio + unitary scaling (stop direction inversion)
  Week 5: Percent + change + reverse problems (stop wrong base)
  Week 6: Word problems → equation translation (stop random operations)
  Week 7: Geometry units (perimeter vs area + unit conversion)
  Week 8: Mixed-paper stability (time pressure + verification habit)
RULE:
  If a foundation is broken, we do not “move on” silently.
  We repair → verify → then continue.
## 6) What This Looks Like in a Lesson
LESSON FLOW:
  - 10 min: quick check (mix + transfer + retention)
  - 20 min: teach with one key rule made visible
  - 20–30 min: repair the top 1–2 break points
  - 10 min: verify under time + new-style question
  - 5 min: log + plan the retention check
## 7) Who Benefits Most
BEST FIT:
  - Students who did “fine” in PSLE but now feel Sec 1 is confusing
  - Students who practice a lot but still repeat the same mistakes
  - Students who freeze in tests even when they understand at home
  - Students aiming to keep doors open for strong Sec 2 / Sec 3 pathways
## 8) The Bottom Line
SUMMARY:
  Secondary 1 Math becomes manageable when the hidden structural breaks are repaired early.
  Our method is: diagnose precisely → repair narrowly → verify under load → lock retention.
CALL TO ACTION (soft):
  If you want, start with a Week-0 diagnostic.
  It immediately tells us the exact “cliff points” to patch for your child.

		

			
v# DiagnosticBlueprint.Week0.Sec1Math.ControlTower v1.0
META:
  UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
  Purpose: Week-0 intake diagnostic for PSLE→Sec1 transition
  TotalQuestions: 30
  SuggestedTime: 45 minutes (plus 5 minutes buffer)
  Marking: 1 mark each (Total 30)
  Output: QID-tagged results → Invariant Breach Log → Repair Queue (max 2 FixProtocols)
CONTRACT:
  Goal:
    Identify the top 1–3 structural breaks (invariants) that cause the Sec 1 “cliff”.
  NonGoals:
    Not a full exam paper. Not a speed contest. Not a trick test.
  CloseRule:
    A breach is “closed” only later after VerifyUnderLoad, not on this diagnostic.
INVARIANT TAGS (used in this diagnostic):
  INV-01 Equality Preservation
  INV-03 Distributive Integrity
  INV-04 Like-Terms Only
  INV-05 Substitution Validity
  INV-06 Integer Sign Consistency
  INV-07 Order of Operations
  INV-09 Fraction Meaning
  INV-10 Equivalent Fractions
  INV-11 Common Denominator
  INV-13 Ratio Multiplicative Core
  INV-14 Unitary Method
  INV-15 Percent Identity
  INV-16 Multiplicative Change
  INV-17 Unit Consistency Ledger
  INV-18 Known/Unknown Separation
  INV-19 Scaling Sanity Check
  INV-20 Perimeter vs Area
  INV-21 Area Unit Squaring
  INV-22 Angle Facts
  INV-23 Mean Total Conservation
  INV-24 Median/Mode Integrity
SCORING → BAND (per cluster):
  ClusterScore = correct / questions_in_cluster
  +Latt: ≥ 0.75
  0Latt: 0.50–0.74
  -Latt: < 0.50
CLUSTERS (for reporting):
  C1 Signs+Algebra Basics: Q01–Q06
  C2 Brackets+Simplify:    Q07–Q10
  C3 Fractions Core:       Q11–Q16
  C4 Ratio/Percent/Change: Q17–Q22
  C5 Word-to-Equation:     Q23–Q25
  C6 Geometry+Units:       Q26–Q28
  C7 Data Handling:        Q29–Q30
# ------------------------------------------------------------
# PAPER (Questions)
# ------------------------------------------------------------
## C1: Signs + Algebra (Q01–Q06)
Q01 [INV-06]:
  Compute: 7 - (-4) = ______
Q02 [INV-06]:
  Compute: (-5) × (-3) = ______
Q03 [INV-06]:
  Compute: 20 ÷ (-4) = ______
Q04 [INV-01]:
  Solve: x - 9 = -2
Q05 [INV-01]:
  Solve: 3x + 5 = 20
Q06 [INV-01, INV-06]:
  Solve: 2x - 7 = -13
## C2: Brackets + Simplification (Q07–Q10)
Q07 [INV-03]:
  Expand: -2(2x - 5) = __________
Q08 [INV-03, INV-04]:
  Simplify: 3(x + 2) + 2(x - 1)
Q09 [INV-04]:
  Simplify: 4a + 3 - 2a + 7
Q10 [INV-03, INV-04, INV-01]:
  Solve: 3(x - 2) = 21
## C3: Fractions Core (Q11–Q16)
Q11 [INV-09]:
  Find 3/4 of 20.
Q12 [INV-11]:
  Compute: 1/3 + 1/6 = ______
Q13 [INV-11]:
  Compute: 5/8 - 1/4 = ______
Q14 [INV-10]:
  Simplify: 12/18 = ______
Q15 [INV-10]:
  Write an equivalent fraction to 3/5 with denominator 20: ______/20
Q16 [INV-12 (optional extension, still Sec1-friendly)]:
  Compute: (3/4) × (8/9) = ______
## C4: Ratio / Percent / Change (Q17–Q22)
Q17 [INV-13]:
  Simplify the ratio 12:18.
Q18 [INV-13]:
  The ratio A:B = 3:5. If A = 24, find B.
Q19 [INV-14, INV-17]:
  5 notebooks cost $12. How much does 1 notebook cost?
Q20 [INV-15]:
  Find 15% of 80.
Q21 [INV-16]:
  $50 is discounted by 20%. Find the new price.
Q22 [INV-16, INV-19]:
  After a 20% discount, an item costs $80. What was the original price?
## C5: Word → Equation (Q23–Q25)
Q23 [INV-18]:
  The sum of a number and 7 is 20. Find the number.
Q24 [INV-18]:
  Twice a number minus 3 is 19. Find the number.
Q25 [INV-18, INV-17]:
  A taxi charges $4 plus $0.50 per km. The fare is $11. How many km was the trip?
## C6: Geometry + Units (Q26–Q28)
Q26 [INV-20]:
  A rectangle is 8 cm by 3 cm. Find its perimeter.
Q27 [INV-20]:
  A rectangle is 8 cm by 3 cm. Find its area.
Q28 [INV-21]:
  Convert 2 m² to cm².
## C7: Data Handling (Q29–Q30)
Q29 [INV-23]:
  The mean of 4 numbers is 10. Three numbers are 8, 11, 9. Find the fourth number.
Q30 [INV-24]:
  Find the median and mode of: 7, 2, 9, 2, 5
# ------------------------------------------------------------
# ANSWER KEY
# ------------------------------------------------------------
ANSWERS:
  Q01: 11
  Q02: 15
  Q03: -5
  Q04: x = 7
  Q05: x = 5
  Q06: x = -3
  Q07: -4x + 10
  Q08: 5x + 4
  Q09: 2a + 10
  Q10: x = 9
  Q11: 15
  Q12: 1/2
  Q13: 3/8
  Q14: 2/3
  Q15: 12/20
  Q16: 2/3
  Q17: 2:3
  Q18: 40
  Q19: $2.40
  Q20: 12
  Q21: $40
  Q22: $100
  Q23: 13
  Q24: 11
  Q25: 14 km
  Q26: 22 cm
  Q27: 24 cm²
  Q28: 20,000 cm²
  Q29: 12
  Q30: median = 5, mode = 2
# ------------------------------------------------------------
# TAG TABLE (QID → Invariant → FixProtocol Routing)
# ------------------------------------------------------------
TAG_TABLE:
  Q01: INV-06 -> FIX-06
  Q02: INV-06 -> FIX-06
  Q03: INV-06 -> FIX-06
  Q04: INV-01 -> FIX-01 (+ FIX-06 if sign errors)
  Q05: INV-01 -> FIX-01
  Q06: INV-01+INV-06 -> FIX-01 + FIX-06
  Q07: INV-03 -> FIX-03 (+ FIX-06 if sign)
  Q08: INV-03+INV-04 -> FIX-03 + FIX-04 (+ FIX-25 if missing terms)
  Q09: INV-04 -> FIX-04
  Q10: INV-03+INV-01 -> FIX-03 + FIX-01
  Q11: INV-09 -> FIX-09
  Q12: INV-11 -> FIX-11
  Q13: INV-11 -> FIX-11
  Q14: INV-10 -> FIX-10
  Q15: INV-10 -> FIX-10
  Q16: (Frac ×) -> FIX-12
  Q17: INV-13 -> FIX-13
  Q18: INV-13 -> FIX-13 (+ FIX-14 if word scaling fails)
  Q19: INV-14+INV-17 -> FIX-14 + FIX-17
  Q20: INV-15 -> FIX-15
  Q21: INV-16 -> FIX-16
  Q22: INV-16+INV-19 -> FIX-16 + FIX-19
  Q23: INV-18 -> FIX-18
  Q24: INV-18 -> FIX-18 + FIX-01 (solve discipline)
  Q25: INV-18+INV-17 -> FIX-18 + FIX-17 + FIX-14 (rate meaning)
  Q26: INV-20 -> FIX-20
  Q27: INV-20 -> FIX-20
  Q28: INV-21 -> FIX-21 (+ FIX-17 unit tagging)
  Q29: INV-23 -> FIX-23
  Q30: INV-24 -> FIX-24
OUTPUTS AFTER MARKING:
  - Student: Cluster bands (C1..C7) + Top3 breach invariants
  - RepairQueue: pick max 2 FixProtocols/week (low-choice corridor)
  - Parent summary (3 lines): Phase/Band + Top breach + Proof plan

		

“`md id=”faqpack-sec1-01″

FAQPack.BukitTimahTutor.Sec1MathControlTower v1.0

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
Brand: BukitTimahTutor.com
Domain: Secondary 1 Mathematics Tuition
OutputType: Google-Snippet FAQ Pack (Parent-facing)
Method: Control Tower (Detect → Name Invariant → Repair → Verify → Retain)

FORMAT:
Q:
SnippetAnswer(≤30 words):
What’sReallyHappening (mechanism):
WhatWeDo (control loop):
WhatYouCanDo (parent actions):

FAQ-01:
Q: Why did my child suddenly “drop” in Math in Secondary 1?
SnippetAnswer(≤30 words): Sec 1 isn’t just harder—it mixes topics and symbols. Most “drops” are structural breaks (signs, brackets, fractions, ratio/percent) under higher load and time pressure.
What’sReallyHappening (mechanism):
– New algebra + negatives + faster mixing creates shear nodes
– Students can do skills separately but fail when combined
WhatWeDo (control loop):
– Diagnose top 1–3 invariant breaches → targeted repair → verify timed + mixed → retention check
WhatYouCanDo (parent actions):
– Ask for: (1) what invariant broke, (2) proof of repair under time, (3) retention plan

FAQ-02:
Q: Is it “careless mistakes” or real misunderstanding?
SnippetAnswer(≤30 words): If the same error repeats across different questions or appears under time pressure, it’s usually a broken rule/invariant—not “carelessness”.
What’sReallyHappening (mechanism):
– Recurrence + transfer failure = concept structure broken
– Timed collapse = working-memory budget exceeded
WhatWeDo (control loop):
– Name the invariant breach; do not label as “careless”
– Close only after VerifyUnderLoad
WhatYouCanDo (parent actions):
– Track recurrence count; demand “closed breach” proof, not “more practice”

FAQ-03:
Q: Why can my child do homework but fail tests?
SnippetAnswer(≤30 words): Homework is often single-topic and untimed. Tests are mixed-topic and timed. That exposes weak transfer, weak retention, and load-collapse.
What’sReallyHappening (mechanism):
– Template success ≠ transfer success
– Time pressure compresses decision space; errors spike
WhatWeDo (control loop):
– Mixed+timed verification every week
– Repair INV-25 (load) + INV-26 (verification habit)
WhatYouCanDo (parent actions):
– Ask for timed mixed scores and “novel question pass”

FAQ-04:
Q: What are the most common Sec 1 “cliff points”?
SnippetAnswer(≤30 words): Signs with negatives, brackets expansion, fractions meaning/denominators, ratio+unitary scaling, percent change, word-to-equation translation, and unit conversion in geometry.
What’sReallyHappening (mechanism):
– Shear nodes: topic intersections where structure tears
WhatWeDo (control loop):
– ShearAtlas routing: SN-01..SN-10 → FixProtocols
WhatYouCanDo (parent actions):
– Ensure your tutor can name the exact shear node and the repair protocol

FAQ-05:
Q: How do you diagnose the real problem quickly?
SnippetAnswer(≤30 words): We use a short Week-0 diagnostic tagged by “invariants” (the rules that must stay true). Wrong answers map directly to repair protocols.
What’sReallyHappening (mechanism):
– Each mistake has a signature: sign rule, distributive rule, unit ledger, etc.
WhatWeDo (control loop):
– Mark by InvariantID → build RepairQueue (max 2 per week)
WhatYouCanDo (parent actions):
– Ask to see: Top 3 InvariantIDs + next repair actions

FAQ-06:
Q: What is an “invariant” in Sec 1 Math?
SnippetAnswer(≤30 words): An invariant is a rule that must stay true during transformations—like keeping both sides of an equation equal, or keeping units consistent in word problems.
What’sReallyHappening (mechanism):
– Math is valid transformations + invariants that must not break
WhatWeDo (control loop):
– Teach by making invariants visible (ILT style)
WhatYouCanDo (parent actions):
– Replace “be careful” with “which invariant did you preserve?”

FAQ-07:
Q: Why are negatives so destructive in Sec 1?
SnippetAnswer(≤30 words): Negatives multiply errors because they affect signs inside brackets, equations, and substitution. One sign slip can break the entire solution chain.
What’sReallyHappening (mechanism):
– Sign shear: subtraction-as-add-negative; negative distributes to every term
WhatWeDo (control loop):
– SN-01 Sign Shear Pack: FIX-06 → FIX-03 → FIX-01 + timed verify
WhatYouCanDo (parent actions):
– Require your child to say: “subtraction is adding a negative” confidently

FAQ-08:
Q: Why do brackets cause “missing term” errors?
SnippetAnswer(≤30 words): Because students don’t treat brackets as structure. The outside factor must multiply every term. Missing one term breaks equivalence.
What’sReallyHappening (mechanism):
– Distributive integrity breach + load collapse
WhatWeDo (control loop):
– FIX-03 (distribute) + FIX-04 (like terms) + FIX-25 (step ledger)
WhatYouCanDo (parent actions):
– Ask for substitution check proof (x=1) to confirm expansion is correct

FAQ-09:
Q: Why do fractions suddenly become confusing again?
SnippetAnswer(≤30 words): Fractions in Sec 1 are often used as operators in word problems and mixed with units. If “denominator = unit size” isn’t stable, everything collapses.
What’sReallyHappening (mechanism):
– Fraction meaning shear + common denominator failure
WhatWeDo (control loop):
– SN-03 Fraction Pack: FIX-09 + FIX-11 (+ FIX-17 units)
WhatYouCanDo (parent actions):
– Ask your child: “What does the denominator mean?” and “Why must denominators match?”

FAQ-10:
Q: Why do ratio and percent problems flip direction?
SnippetAnswer(≤30 words): Because ratio/percent are multiplicative, but many students use additive thinking. They scale the wrong way or use the wrong base.
What’sReallyHappening (mechanism):
– Direction-of-scaling breach; wrong base for percent change
WhatWeDo (control loop):
– FIX-13 + FIX-14 + FIX-19; then FIX-15 + FIX-16 + FIX-19
WhatYouCanDo (parent actions):
– Require a “direction estimate” sentence before calculating

FAQ-11:
Q: Why do word problems feel impossible in Sec 1?
SnippetAnswer(≤30 words): Word problems require translation: define unknowns, preserve units, then build an equation. Without a model, students do random operations on numbers.
What’sReallyHappening (mechanism):
– Known/unknown separation fails; language-to-equation mapping breaks
WhatWeDo (control loop):
– FIX-18 (“Let x be…”) + FIX-17 (units ledger) + FIX-01 (solve)
WhatYouCanDo (parent actions):
– Make “Let x be …” mandatory in solutions

FAQ-12:
Q: What should I look for in a Sec 1 Math tutor?
SnippetAnswer(≤30 words): Look for a tutor who can diagnose error patterns, name the exact rule broken, run targeted repairs, and prove improvement under timed mixed questions—not just assign more practice.
What’sReallyHappening (mechanism):
– Many tutors teach content; fewer run a repair+verification system
WhatWeDo (control loop):
– Control Tower: sensors + invariant ledger + close rule
WhatYouCanDo (parent actions):
– Ask: “What will you measure weekly?” and “How do you prove a misconception is closed?”

FAQ-13:
Q: How do you prevent relapse after tuition?
SnippetAnswer(≤30 words): We schedule retention checks 7–14 days later. If the same invariant breaks again, it stays open and gets rerouted—never ignored.
What’sReallyHappening (mechanism):
– Without retention checks, “fixed today” becomes “forgot next week”
WhatWeDo (control loop):
– BreachLog + RetentionCheckDate + recurrence tracking
WhatYouCanDo (parent actions):
– Ask for the next retention date and the result

FAQ-14:
Q: How fast should improvement appear?
SnippetAnswer(≤30 words): The first goal is fewer repeated errors and stable performance under time. You should see reduced recurrence within 2–3 weeks if repairs are targeted and verified.
What’sReallyHappening (mechanism):
– Early wins are stability gains (less collapse), not just harder questions
WhatWeDo (control loop):
– Track recurrence trend + load-collapse trend
WhatYouCanDo (parent actions):
– Ask for the “recurrence count” trend, not only raw marks

FAQ-15:
Q: What does “Phase P0–P3” mean for a student?
SnippetAnswer(≤30 words): P0–P3 describes stability: P0 breaks often, P1 works with help, P2 works on familiar patterns, P3 holds under new questions and time pressure.
What’sReallyHappening (mechanism):
– Phase = corridor stability under load + transfer
WhatWeDo (control loop):
– Move student toward P3 by closing breaches with proof
WhatYouCanDo (parent actions):
– Ask: “What phase is my child in for this topic, and what is the next repair step?”

md id=”opws-sec1-01″

OperatorWorksheetTemplate.Sec1Math.ControlTower v1.0

META:
UnifiedVersion: eduKateSG.RuntimeLayer.v1.1
Brand: BukitTimahTutor.com
Use: Tutor-facing forms (printable + spreadsheet-friendly)
Components:
– Week0 Diagnostic Marking Sheet
– Weekly OnePanel Lesson Sheet
– Class/Cohort Quick Summary (optional)

————————————————————

A) WEEK 0 — DIAGNOSTIC MARKING SHEET (30Q)

————————————————————

FORM: Week0Diagnostic.Sec1Math
HEADER:
StudentID:
StudentName:
School:
Date:
TutorID:
TimeTaken(min):
Notes(1 line):

MARKING (tick / cross + error notes):
Q01 _ Q02 Q03 Q04 Q05 Q06
Q07 Q08 Q09 Q10
Q11 Q12 Q13 Q14 Q15 Q16
Q17 Q18 Q19 Q20 Q21 Q22
Q23 Q24 Q25 Q26 Q27 Q28
Q29 Q30
TotalScore: ___ / 30

CLUSTER SCORES (for banding):
C1 Signs+Algebra (Q01–Q06): _ / 6 Band(+/0/−):
C2 Brackets+Simplify (Q07–Q10): _ / 4 Band(+/0/−):
C3 Fractions Core (Q11–Q16): _ / 6 Band(+/0/−):
C4 Ratio/Percent/Change (Q17–Q22): _ / 6 Band(+/0/−):
C5 Word→Equation (Q23–Q25): _ / 3 Band(+/0/−):
C6 Geometry+Units (Q26–Q28): _ / 3 Band(+/0/−):
C7 Data (Q29–Q30): _ / 2 Band(+/0/−):

TOP BREACHES (choose max 3 by frequency + severity):
Breach#1: InvariantID: _ Evidence(QIDs): ErrorType(E1–E6): Breach#2: InvariantID: Evidence(QIDs): ErrorType(E1–E6): Breach#3: InvariantID: Evidence(QIDs): ErrorType(E1–E6): __

INITIAL PHASE ESTIMATE (overall):
P0 / P1 / P2 / P3: _ Reason(1 line): _____________________________

REPAIR QUEUE (Week 1, max 2 FixProtocols):
RepairA:
FixProtocolID: _ (e.g., CT-S1M-FIX-06) TargetInvariantID:
VerifyPlan: TimedMixed /6 + NovelPass + Explain1Sentence RepairB: FixProtocolID:
TargetInvariantID: _
VerifyPlan: TimedMixed /6 + NovelPass + Explain1Sentence

PARENT SUMMARY (3 lines):
Line1 (Phase/Band + main risk): ________________________
Line2 (Top breach + what we’ll fix): ____________________
Line3 (Proof plan + retention date): ____________________

————————————————————

B) WEEKLY — ONEPANEL LESSON SHEET

————————————————————

FORM: WeeklyOnePanel.Sec1Math
HEADER:
StudentID:
WeekNo:
Date:
CurrentUnit/Topic:
τ_node(days to next test):
TutorID:

FLIGHT STATUS:
Phase(P0–P3): _ Band(+/0/−) for current unit:
RiskFlag(Green/Amber/Red): Notes(1 line): _____________________________

SENSOR SNAPSHOT (today):
S1 Accuracy (%): _ S2 Latency (sec/q):
S3 HintDependence (0–3): S4 Transfer (%):
S5 Retention (%): S6 LoadCollapse (% drop):
S7 ConfGap (+/−): S8 Recurrence (count): _

INVARIANT LEDGER (top 3 today):
Breach1: InvariantID _ TriggerQID ErrorType(E1–E6) Signature(note) _
Breach2: InvariantID _ TriggerQID ErrorType(E1–E6) Signature(note) _
Breach3: InvariantID _ TriggerQID ErrorType(E1–E6) Signature(note) _

REPAIR EXECUTED (max 2):
RepairA:
FixProtocolID: _ MicroLessonDone(≤5m): Yes/No DrillDone(10): /10
TransferTestDone(3): /3 RepairB: FixProtocolID: _
MicroLessonDone(≤5m): Yes/No
DrillDone(10): /10 TransferTestDone(3): /3

VERIFY UNDER LOAD (must record):
TimedMixedSet: % (target ≥70%) NovelPass: Yes/No Explain1Sentence: Pass/Fail CloseBreach? (Y/N):
RetentionCheckDate(+7d): ___

LEDGER UPDATE (append line):
{Date, InvariantID, FixProtocolID, VerifyResult, Close(Y/N), NextRisk}

PARENT OUTPUT (3 lines):
Line1: ________________________
Line2: ________________________
Line3: ________________________

————————————————————

C) OPTIONAL — CLASS QUICK SUMMARY (for Cohort Ops)

————————————————————

FORM: ClassSummary.Sec1Math (Weekly)
ClassID:
WeekNo:
τ_node:
pct_plus:
pct_zero:
pct_minus:
rupture_risk(%):
Top3Breaches(InvariantIDs):
InterventionThisWeek (script/pack):
VerifyPassRate(%):
NextWeekPlan(1 line):
“`

Start Here: https://bukittimahtutor.com/bukit-timah-secondary-mathematics-control-tower-v1-0/