Ongoing learning program
AI Algorithms Learning Laboratory
- Started
- 2026-07
- Last revised
A structured learning program that moves from mathematical derivation to implementation, tiny verification cases, and visual explanation while preparing for the 2026 Vietnamese Student AI Olympiad.
- Python
- TypeScript
- NumPy
- Dynamic programming
- Linear algebra
Research question
Which small implementations and visual tests reveal the assumptions of an AI algorithm more clearly than using a high-level library alone?
From input to inspectable output
System architecture
- 01Deriveobjective + recurrence↗
- 02Implementclear reference code↗
- 03Interrogatevisible intermediate state↗
- 04Verifytiny cases + invariants
- 01
Derive
Write the objective, state variables, recurrence, and complexity bounds.
- in
- algorithm
- out
- mathematical note
- 02
Implement
Translate the derivation into a minimal dependency-light reference implementation.
- in
- equations
- out
- executable code
- 03
Interrogate
Expose intermediate tables, vectors, or decisions through a focused visual explanation.
- in
- execution trace
- out
- inspectable states
- 04
Verify
Use tiny hand-computable cases, invariants, and comparisons with trusted implementations.
- in
- reference output
- out
- test ledger
What the design must respect
Operating constraints
- 01
The scope must stay narrow enough for each algorithm to be derived and tested from first principles.
- 02
Reference implementations should favor clarity before vectorized performance.
- 03
Visual explanations must correspond to actual intermediate states, not decorative animations.
Evaluation ledger
Current results
Values will be added only with the evaluation set, protocol, ontology version, and relevant runtime conditions.
- R01Modules completed
- Not reportedPlaceholder
The public log will count only modules with derivation, implementation, and verification.
- R02Verification coverage
- Not reportedPlaceholder
A rubric is being defined before reporting a percentage.
Negative evidence
Failed or insufficient approaches
Collecting disconnected notebooks
Code accumulates, but assumptions and failure cases are hard to recover later.
Require the same derive–implement–interrogate–verify structure for every module.
Starting with optimized vectorized code
Compact implementations can conceal the state transitions being learned.
Keep a slow reference version beside any optimized variant.
What changed in the model of the problem
Lessons
- A hand-computable example is often the fastest way to find an indexing error.
- Visualization is most useful when it exposes the exact state used by the implementation.
- Complexity analysis belongs before optimization.
Queue, not promises
Next experiments
- 01Complete the Viterbi module with brute-force agreement tests.
- 02Add stable softmax, log-sum-exp, and numerical gradient-checking notes.
- 03Build a small retrieval module comparing sparse and dense similarity.