Full Almost-Code Runtime Manual
Official anchor first. For Cambridge, IGCSE Mathematics 0580 is currently published as a syllabus for examinations in 2025, 2026 and 2027, and Cambridge treats 0580 and 0980 as separate mathematics qualifications. Cambridge 0580 uses Core and Extended routes, with two papers per route and an explicit split between non-calculator and calculator papers. (Cambridge International)
For Pearson, International GCSE Mathematics A (4MA1) is a separate qualification with a different structure: the main linear specification is two examinations at Foundation or Higher, both taken in the same series, and Pearson’s current 2025/26 information manual also lists regional paper variants and modular entry options for international centres. (Pearson Qualifications)
Everything from EDUKATESG.RUNTIME downward is an interpretive tutorial system, not official board wording. It is built on top of the official structures above so the teaching runtime stays aligned to the exam reality. (Cambridge International)
0. Meta Lock
DOC.NAME = “Technical Documentation of IGCSE Mathematics Tutorial by eduKateSG v3.0”
DOC.CLASS = “Tutorial runtime manual”
DOC.MODE = “Almost Code”
DOC.DEFAULT_BINDING = “Cambridge IGCSE Mathematics 0580”
DOC.COMPATIBILITY = [“Cambridge 0980”, “Pearson Edexcel International GCSE Mathematics A 4MA1”]
DOC.BOUNDARY = “Official syllabus layer must remain distinct from eduKateSG runtime compression.”
DOC.PURPOSE = “Turn syllabus object into diagnosable student-routing system.”
1. Official Binding Layer
CAMBRIDGE_0580.OFFICIAL = {
subject: “Cambridge IGCSE Mathematics”,
code: “0580”,
window: “Exams in 2025, 2026, 2027”,
tiers: [“Core”, “Extended”],
core_papers: [“Paper 1”, “Paper 3”],
extended_papers: [“Paper 2”, “Paper 4”],
calculator_split: {
Paper1: “No”,
Paper2: “No”,
Paper3: “Yes”,
Paper4: “Yes”
},
topic_areas: [
”Number”,
”Algebra and graphs”,
”Coordinate geometry”,
”Geometry”,
”Mensuration”,
”Trigonometry”,
”Transformations and vectors”,
”Probability”,
”Statistics”
],
assessment_objectives: [“AO1”, “AO2”]
}
Cambridge 0580 officially sets Paper 1 and Paper 3 for Core, and Paper 2 and Paper 4 for Extended. Paper 1 and Paper 3 are each 1 hour 30 minutes and 80 marks; Paper 2 and Paper 4 are each 2 hours and 100 marks. Cambridge also states that the content is arranged by topic rather than teaching order. (Cambridge International)
CAMBRIDGE_0980.OFFICIAL = {
subject: “Cambridge IGCSE (9–1) Mathematics”,
code: “0980”,
status: “Separate qualification object”,
warning: “Do not merge with 0580”
}
Cambridge publishes 0980 separately from 0580, and its site identifies it as Cambridge IGCSE (9–1) Mathematics 0980 rather than the same syllabus under a different label. (Cambridge International)
PEARSON_4MA1.OFFICIAL = {
subject: “Pearson Edexcel International GCSE Mathematics A”,
code: “4MA1”,
structure: “Linear”,
tiers: [“Foundation”, “Higher”],
papers_per_tier: 2,
paper_duration: “2 hours each”,
paper_marks: 100,
formula_sheets: true,
same_series_rule: true
}
Pearson’s specification states that 4MA1 is a linear qualification, with two examinations at Foundation or Higher, both taken in the same series. The spec also includes separate Foundation Tier and Higher Tier formula sheets. Pearson’s 2025/26 manual lists active entry options for 4MA1 F, 4MA1 H, and regional variants 4MA1 FR and 4MA1 HR, as well as modular Specification A entries for international centres. (Pearson Qualifications)
2. eduKateSG Tutorial Runtime Thesis
EDUKATESG.RUNTIME.THESIS = “IGCSE Mathematics tutorial is not chapter-help only. It is board-bound execution repair across number, symbol, graph, space, data, time pressure, and mark-capture conditions.”
EDUKATESG.RUNTIME.PRIMARY_OBJECTIVE = “Move student from unstable topic familiarity to reliable paper performance.”
EDUKATESG.RUNTIME.SUCCESS_CONDITION = {
board_alignment: true,
tier_fit: true,
topic_floor_stable: true,
paper_mode_stable: true,
mark_capture_visible: true
}
3. System Object
IGCSE_TUTORIAL_SYSTEM = {
INPUT: [
student_history,
board_identity,
target_tier,
diagnostic_paper,
error_log,
speed_profile,
confidence_profile
],
ENGINE: [
diagnosis,
retiering_logic,
packet_assignment,
lesson_runtime,
paper_simulation,
review_loop
],
OUTPUT: [
topic_stability,
paper_stability,
mark_gain,
confidence_gain,
route_viability
]
}
4. Runtime Levels
RUNTIME_LEVELS = {
L0: “Board-binding level”,
L1: “Tier-routing level”,
L2: “Topic-engine level”,
L3: “Question-execution level”,
L4: “Paper-conditioning level”,
L5: “Progression and retiering level”
}
RUNTIME_RULE = “Failure at a lower level contaminates all higher levels.”
5. Student State Model
STUDENT.STATE = {
board: null,
tier: null,
phase: null,
paper_mode: null,
number_floor: 0,
algebra_floor: 0,
graph_floor: 0,
geometry_floor: 0,
data_floor: 0,
mark_capture_floor: 0,
fatigue_profile: 0,
confidence_profile: 0,
drift_risk: 0
}
STATE_SCALE = {
0: “Absent”,
1: “Very weak”,
2: “Weak”,
3: “Usable”,
4: “Stable”,
5: “Strong”,
6: “Fast and stable”
}
6. Phase Route
PHASE_ROUTE = {
P0: “Student cannot reliably execute basic syllabus actions”,
P1: “Student recognises familiar questions but breaks often”,
P2: “Student can execute single-topic tasks with supervision”,
P3: “Student can execute mixed exam tasks with moderate stability”,
P4: “Student can self-correct, pace, and preserve marks under pressure”
}
TARGET_BY_ROUTE = {
Cambridge_Core: “P2.5 to P3”,
Cambridge_Extended: “P3 to P4”,
Pearson_Foundation: “P2.5 to P3”,
Pearson_Higher: “P3 to P4”
}
7. Topic Engine Stack
TOPIC_ENGINES = {
E1_NUMBER = {
subsystems: [integers, fractions, decimals, percentages, ratio, proportion, indices, standard_form, bounds],
ledger: “quantity correctness”,
core_failure: “arithmetic leakage contaminates downstream work”
},
E2_ALGEBRA = {
subsystems: [simplification, expansion, factorisation, rearrangement, equations, inequalities, sequences],
ledger: “symbol legality”,
core_failure: “sign drift and structure corruption”
},
E3_GRAPHS = {
subsystems: [coordinates, straight_line, gradient, intercepts, curve_behaviour, transformations],
ledger: “representation translation”,
core_failure: “graph blindness”
},
E4_GEOMETRY = {
subsystems: [angles, polygons, circles, congruence, similarity, constructions],
ledger: “shape-property validity”,
core_failure: “diagram panic and property misread”
},
E5_MENSURATION = {
subsystems: [perimeter, area, surface_area, volume, units, compound_measures],
ledger: “formula-shape-unit binding”,
core_failure: “formula mismatch or unit loss”
},
E6_TRIGONOMETRY = {
subsystems: [SOHCAHTOA, sine_rule, cosine_rule, bearings, elevation_depression],
ledger: “angle-ratio selection”,
core_failure: “wrong relation chosen from incomplete diagram”
},
E7_TRANSFORMATIONS_VECTORS = {
subsystems: [translation, rotation, reflection, enlargement, vector_movement],
ledger: “spatial operation control”,
core_failure: “movement rule confusion”
},
E8_PROBABILITY = {
subsystems: [basic_probability, tree_diagrams, combined_events],
ledger: “uncertainty reasoning”,
core_failure: “event structure misread”
},
E9_STATISTICS = {
subsystems: [averages, charts, cumulative_frequency, histograms, scatter, interpretation],
ledger: “data representation and inference”,
core_failure: “reads picture but misses inference”
}
}
This topic-engine stack mirrors Cambridge’s official nine-topic structure for 0580. (Cambridge International)
8. Assessment Objective Mapping Layer
AO_MAP.CAMBRIDGE_0580 = {
AO1: [knowledge_recall, routine_procedure, notation, calculation, estimation, measurement, instrument_use, spatial_relationship],
AO2: [analyse, interpret, select_strategy, connect_topics, infer, conclude, communicate_mathematically]
}
AO_MAP.PEARSON_4MA1 = {
AO1: “Number and algebra”,
AO2: “Shape, space and measures”,
AO3: “Handling data”
}
Cambridge officially uses AO1 and AO2. Pearson officially organises the specification by AO1 Number and algebra, AO2 Shape, space and measures, and AO3 Handling data. (Cambridge International)
9. Paper Mode Engine
PAPER_MODE = {
NON_CALCULATOR = {
required_for: [“Cambridge Paper 1”, “Cambridge Paper 2”],
demands: [mental_accuracy, fraction_control, exactness, neat_working, delayed_rounding],
common_breaks: [panic, sloppy arithmetic, abandoned steps]
},
CALCULATOR = {
required_for: [“Cambridge Paper 3”, “Cambridge Paper 4”, “Pearson written papers”],
demands: [correct_setup, correct_mode, sensible_rounding, sanity_checking],
common_breaks:
}
}
For Cambridge 0580, the calculator split is explicit by paper. For Pearson 4MA1, the specification includes formula sheets and does not impose the same Cambridge-style non-calculator paper split in the main linear model. (Cambridge International)
10. Tutorial Actor Model
ACTORS = {
Tutor = {
role: “Operator and diagnostician”,
must_do: [read_state, select_packet, sequence_load, surface_errors, preserve_morale, escalate_when_needed]
},
Student = {
role: “Load-bearer and executor”,
must_do: [show_working, attempt_independently, keep_error_log, rehearse_retrieval, reflect_on_breaks]
},
Parent = {
role: “Support environment”,
must_do: [protect_routine, stabilise_schedule, reduce noise, respect tier reality]
}
}
ACTOR_RULE = “Tutor directs load; student bears load.”
11. Diagnostic Intake Protocol
DIAGNOSTIC_INTAKE = {
Step_1: “Confirm board”,
Step_2: “Confirm tier or likely tier”,
Step_3: “Run baseline test”,
Step_4: “Tag errors by engine”,
Step_5: “Tag errors by failure type”,
Step_6: “Measure speed profile”,
Step_7: “Measure working visibility”,
Step_8: “Assign packet family”,
Step_9: “Set first 4-week route”
}
INTAKE.MINIMUM_DATA = {
board_identity: required,
tier_identity: required,
recent_paper: preferred,
school_marks: useful_but_not_sufficient,
student_self_report: required,
tutor_observation: required
}
12. Diagnostic Sensors
SENSORS = {
S1: “Fraction stability”,
S2: “Sign discipline”,
S3: “Rearrangement correctness”,
S4: “Formula retrieval”,
S5: “Graph translation”,
S6: “Diagram interpretation”,
S7: “Method choice speed”,
S8: “Non-calc resilience”,
S9: “Calculator discipline”,
S10: “Working visibility”,
S11: “Time endurance”,
S12: “Error recovery after drift”
}
SENSOR_READ = {
0: “No control”,
1: “Breaks constantly”,
2: “Can do with heavy prompting”,
3: “Usable”,
4: “Stable”,
5: “Reliable under pressure”
}
13. Error Taxonomy
ERRORS = {
ER01 = “Arithmetic contamination”,
ER02 = “Sign inversion”,
ER03 = “Bracket corruption”,
ER04 = “Formula hallucination”,
ER05 = “Unit neglect”,
ER06 = “Graph misread”,
ER07 = “Diagram misread”,
ER08 = “Wrong method despite correct topic recognition”,
ER09 = “Correct method but poor execution”,
ER10 = “Correct execution but wrong final form”,
ER11 = “Premature rounding”,
ER12 = “No visible working”,
ER13 = “Time collapse”,
ER14 = “Confidence collapse after one error”
}
ERROR_RULE = “Most students do not fail because they know nothing. They fail because a small number of repeated errors keep reopening across many topics.”
14. Packet Family Registry
PACKETS = {
PKT_A0_ENTRY_SCAN = {
purpose: “Find board, tier, and floor”,
contains: [baseline_mix, timing_probe, confidence_probe, script_review]
},
PKT_A1_NUMBER_REPAIR = {
purpose: “Repair arithmetic floor”,
contains: [fractions, decimals, percentages, ratio, noncalc_drills]
},
PKT_A2_ALGEBRA_REPAIR = {
purpose: “Repair sign and symbol engine”,
contains: [expansion, factorisation, rearrangement, equations, inequalities]
},
PKT_A3_GRAPH_REPAIR = {
purpose: “Repair graph translation”,
contains: [coordinate_tasks, gradient, intercept, sketch_reading, equation_to_graph]
},
PKT_A4_GEOMETRY_REPAIR = {
purpose: “Repair visual reasoning”,
contains: [angle_chains, shape_properties, circle_rules, diagram_annotation]
},
PKT_A5_MEASURE_TRIG_REPAIR = {
purpose: “Bind formula to shape”,
contains: [area_volume, units, trigonometry, bearings, mixed_shape_tasks]
},
PKT_A6_DATA_REPAIR = {
purpose: “Repair probability and statistics interpretation”,
contains: [averages, tables, charts, cumulative_frequency, tree_diagrams]
},
PKT_B1_CORE_STABILITY = {
purpose: “Single-topic to mixed-topic stability”,
contains: [standard_items, mini_mixed_sets, worked_example_pairs]
},
PKT_B2_TRANSFER_BUILDER = {
purpose: “Train topic transfer”,
contains: [algebra_plus_graphs, geometry_plus_ratio, mensuration_plus_units, statistics_plus_inference]
},
PKT_C1_NONCALC_MODE = {
purpose: “Train deliberate non-calculator execution”,
contains: [mental_arithmetic, exact_form, clean_working, arithmetic_endurance]
},
PKT_C2_CALC_MODE = {
purpose: “Train calculator setup discipline”,
contains: [mode_checks, bracket_input, rounding_checks, estimate_compare]
},
PKT_D1_MARK_CAPTURE = {
purpose: “Make methods visible”,
contains: [line_layout, statement_answer_pairing, unit_checks, final_form_checks]
},
PKT_E1_MOCK_CONDITIONING = {
purpose: “Paper readiness”,
contains: [timed_sections, fatigue_probe, recovery_protocol, postmortem]
}
}
15. Packet Assignment Logic
PACKET_ROUTER = {
if S1 <= 2 -> assign(PKT_A1_NUMBER_REPAIR),
if S2 <= 2 or S3 <= 2 -> assign(PKT_A2_ALGEBRA_REPAIR),
if S5 <= 2 -> assign(PKT_A3_GRAPH_REPAIR),
if S6 <= 2 -> assign(PKT_A4_GEOMETRY_REPAIR),
if engine_measure_or_trig_breaks -> assign(PKT_A5_MEASURE_TRIG_REPAIR),
if data_questions_break -> assign(PKT_A6_DATA_REPAIR),
if single_topic_ok_but_mixed_not_ok -> assign(PKT_B2_TRANSFER_BUILDER),
if Cambridge_noncalc_route and S8 <= 3 -> assign(PKT_C1_NONCALC_MODE),
if calc_errors_visible -> assign(PKT_C2_CALC_MODE),
if method_marks_lost -> assign(PKT_D1_MARK_CAPTURE),
if mock_performance_collapses -> assign(PKT_E1_MOCK_CONDITIONING)
}
16. Weekly Operator Runtime
WEEKLY_RUNTIME = {
WEEK_OPEN = {
Block1: “Recall and warm-up”,
Block2: “Packet repair”,
Block3: “Guided examples”,
Block4: “Independent attempt”,
Block5: “Error log closure”
},
MIDWEEK = {
Block1: “Short recall”,
Block2: “Mixed transfer set”,
Block3: “Paper-mode set”,
Block4: “Mark-capture check”
},
WEEK_CLOSE = {
Block1: “Timed probe”,
Block2: “Review and reteach”,
Block3: “State update”,
Block4: “Next packet decision”
}
}
WEEKLY_PRINCIPLE = “Every week must contain recall, repair, independent execution, mixed transfer, and measurement.”
17. Lesson Runtime
LESSON_RUNTIME = {
00_Entry: “2-minute retrieval sweep”,
01_State_Read: “Tutor spots active error cluster”,
02_Micro_Teach: “Teach only what this route needs”,
03_Guided_Run: “Tutor and student co-execute”,
04_Solo_Run: “Student executes independently”,
05_Paper_Embed: “Convert to exam-style question”,
06_Review: “Tag errors, not just answers”,
07_Assign: “Homework packet tied to sensor weakness”
}
LESSON_STOP_RULE = “Do not keep teaching new content when the same structural error is still active.”
18. Homework Architecture
HOMEWORK = {
HW1: “Recall strip”,
HW2: “Repair strip”,
HW3: “Mixed transfer strip”,
HW4: “Paper-mode strip”,
HW5: “Error reflection strip”
}
HOMEWORK_RATIO = {
repair: 40,
stability: 25,
transfer: 20,
paper_mode: 10,
reflection: 5
}
19. Mock and Review Engine
MOCK_ENGINE = {
pre_mock: [topic_heatmap, weak_packet_revision, timing_reminder],
during_mock: [time_checkpoints, working_visibility, calm_recovery],
post_mock: [error_coding, loss_bucket_analysis, retier_review_if_needed]
}
LOSS_BUCKETS = {
LB1: “Did not know”,
LB2: “Knew but forgot”,
LB3: “Chose wrong method”,
LB4: “Method right, execution wrong”,
LB5: “Answer right path but poor final form”,
LB6: “Ran out of time”,
LB7: “Panic response”
}
20. Route-Type Profiles
ROUTE_TYPES = {
RT1_Fragile_Foundation = {
signature: “Many small arithmetic leaks”,
first_priority: PKT_A1_NUMBER_REPAIR
},
RT2_Symbol_Drifter = {
signature: “Algebra errors reopen everywhere”,
first_priority: PKT_A2_ALGEBRA_REPAIR
},
RT3_Visual_Collapser = {
signature: “Geometry and trig trigger shutdown”,
first_priority: PKT_A4_GEOMETRY_REPAIR
},
RT4_False_Safe = {
signature: “Textbook okay, paper not okay”,
first_priority: PKT_B2_TRANSFER_BUILDER
},
RT5_Calc_Dependent = {
signature: “Breaks badly in non-calculator tasks”,
first_priority: PKT_C1_NONCALC_MODE
},
RT6_Time_Collapser = {
signature: “Late-paper decay”,
first_priority: PKT_E1_MOCK_CONDITIONING
},
RT7_Mark_Leaker = {
signature: “Knows enough but presentation costs marks”,
first_priority: PKT_D1_MARK_CAPTURE
}
}
21. Tier Review Logic
TIER_REVIEW = {
Cambridge_0580 = {
input: [recent_papers, mock_pattern, topic_stability, panic_profile],
review_questions: [
”Is Core too easy and capping progress?”,
”Is Extended too unstable and causing repeated trauma?”,
”Can the student survive both paper modes?”
]
},
Pearson_4MA1 = {
input: [recent_papers, higher_topic_readiness, pacing_profile],
review_questions: [
”Is Foundation safely below ceiling?”,
”Is Higher ambition supported by stable algebra and problem solving?”
]
}
}
Cambridge’s official assessment overview separates Core from Extended and links them to different paper combinations and grade ranges. Pearson’s specification similarly separates Foundation and Higher, though with a different grading architecture and paper model. (Cambridge International)
22. Mark-Capture Protocol
MARK_CAPTURE_PROTOCOL = {
M1: “Write enough to be credited”,
M2: “Keep one algebra action per line when unstable”,
M3: “Carry units deliberately”,
M4: “Read whether exact form is required”,
M5: “Delay rounding when later work depends on current value”,
M6: “Circle or clearly state final answer”
}
Cambridge explicitly states conventions for accuracy, including normal use of 3 significant figures for non-exact answers and 1 decimal place for angles in degrees unless the question says otherwise, so output discipline is not cosmetic; it is part of mark capture. (Cambridge International)
23. Formula Policy Protocol
FORMULA_PROTOCOL = {
Cambridge_0580 = {
exam_formula_list: true,
all_needed_formulas_provided: false,
tutorial_implication: “Build memory and selective formula retrieval”
},
Pearson_4MA1 = {
formula_sheet_present: true,
tutorial_implication: “Train live use of formula sheet”
}
}
Cambridge states that a formula list is provided in the paper but not all required formulae are given. Pearson includes separate Foundation and Higher formula sheets in the specification appendices. (Cambridge International)
24. Data Schema for Tutor Notes
TUTOR_NOTE_SCHEMA = {
student_id: “”,
board: “”,
tier: “”,
date: “”,
phase: “”,
active_engines: [],
active_errors: [],
sensor_scores: {},
packets_assigned: [],
homework_set: [],
time_profile: “”,
confidence_profile: “”,
next_action: “”
}
SESSION_LOG_SCHEMA = {
lesson_goal: “”,
questions_attempted: 0,
questions_completed: 0,
questions_correct: 0,
dominant_error: “”,
secondary_error: “”,
mark_capture_loss: “”,
paper_mode_today: “”,
state_shift: “”
}
25. KPI Layer
KPI = {
K1: “Fraction error rate falling”,
K2: “Algebra line legality rising”,
K3: “Graph questions attempted without avoidance”,
K4: “Diagram tasks no longer trigger freeze”,
K5: “Timed set completion improving”,
K6: “Method marks preserved”,
K7: “Late-paper drop shrinking”,
K8: “Student self-correction frequency rising”
}
SUCCESS_NOTATION = {
green: “Stable”,
amber: “Usable but fragile”,
red: “Immediate repair needed”
}
26. Control Tower
CONTROL_TOWER = {
INPUT: [diagnostics, classwork, homework, timed_sets, mocks],
READ: [board_fit, tier_fit, engine_heat, paper_mode_risk, fatigue_risk],
DECIDE: [repair, repeat, extend, simulate, retier_review],
ACT: [assign_packet, alter_load, run_mock, isolate_error, build_transfer],
OUTPUT: [greater_stability, greater_visibility, higher_mark_capture, stronger_route]
}
CONTROL_TOWER.CORE_RULE = “Do not confuse topic coverage with route stability.”
27. Full Operational Doctrine
OPERATIONAL_DOCTRINE = {
D1: “Board first”,
D2: “Tier reality before ambition”,
D3: “Repair floor before acceleration”,
D4: “Mixed transfer before false confidence”,
D5: “Paper mode matters”,
D6: “Working is part of mathematics performance”,
D7: “Error logs belong inside the tutorial system”,
D8: “Retiering is a structural decision, not an ego decision”
}
28. Canonical Lock
CANONICAL_LOCK = {
CL1: “IGCSE Mathematics tutorial must bind to the correct board object before lesson design begins.”,
CL2: “Cambridge 0580, Cambridge 0980, and Pearson 4MA1 are related but not identical systems.”,
CL3: “Cambridge 0580 requires real preparation for separate non-calculator and calculator papers.”,
CL4: “Pearson 4MA1 uses a different assessment and grading architecture and should be routed separately.”,
CL5: “A tutorial system succeeds when it repairs execution leakage, not merely when it finishes worksheets.”
}
