1. Introduction
3. Getting Started
4. 1. Installation
5. 2. Quick Start
6. 3. First Training Loop
7. 4. Core Concepts
9. Architecture
10. 5. Overview
11. 6. Design Philosophy
12. 7. Module Organization
13. 8. Type System
14. 9. Memory Management
16. Autograd Engine
17. 10. What is Automatic Differentiation?
18. 11. Tape-Based Computation Graphs
19. 12. Tensor Operations
20. 1. 12.1. Matrix Multiplication
    2. 12.2. Activations (ReLU, GELU, Swish)
    3. 12.3. Layer Normalization
    4. 12.4. Attention Mechanism
21. 13. Backward Pass
22. 14. Gradient Computation
23. 15. Finite Difference Validation
25. Optimizers
26. 16. Overview
27. 17. Stochastic Gradient Descent (SGD)
28. 18. Adam Optimizer
29. 19. AdamW (Decoupled Weight Decay)
30. 20. Learning Rate Schedulers
31. 1. 20.1. Cosine Annealing
    2. 20.2. Step Decay
    3. 20.3. Exponential Decay
32. 21. Gradient Clipping
33. 22. SIMD-Accelerated Updates
34. 23. Optimizer Theory
36. LoRA (Low-Rank Adaptation)
37. 24. What is LoRA?
38. 25. Parameter-Efficient Fine-Tuning
39. 26. LoRA Layer Architecture
40. 1. 26.1. Low-Rank Matrices A and B
    2. 26.2. Scaling Factor (alpha/rank)
    3. 26.3. Merge and Unmerge
41. 27. Target Module Selection
42. 28. Gradient Flow Isolation
43. 29. Adapter Persistence
44. 1. 29.1. Saving Adapters
    2. 29.2. Loading Adapters
    3. 29.3. Sharing Adapters
46. QLoRA (Quantized LoRA)
47. 30. Memory-Efficient Fine-Tuning
48. 31. 4-bit Quantization
49. 1. 31.1. Block-Wise Quantization
    2. 31.2. Scale Factors
    3. 31.3. Quantization/Dequantization
50. 32. QLoRA Layer
51. 33. On-the-Fly Dequantization
52. 34. Memory Benchmarks
53. 1. 34.1. LoRA vs QLoRA Comparison
    2. 34.2. Transformer Model Benchmarks
    3. 34.3. Compression Ratios
54. 35. Trade-offs and Best Practices
56. Model Merging
57. 36. Overview
58. 37. TIES Algorithm
59. 38. DARE Algorithm
60. 39. SLERP Algorithm
61. 40. Multi-Model Ensembles
62. 41. Merge Best Practices
64. Knowledge Distillation
65. 42. What is Distillation?
66. 43. Temperature-Scaled KL Divergence
67. 44. Multi-Teacher Ensemble
68. 45. Progressive Layer-Wise
69. 46. Distillation Loss Functions
70. 47. Student-Teacher Architecture
72. Training Loops
73. 48. Trainer API
74. 49. Callback System
75. 50. Train Config
76. 51. Basic Training Loop
77. 52. Batching and Data Loading
78. 53. Loss Functions
79. 54. Validation and Testing
80. 55. Checkpointing
81. 56. Early Stopping
82. 57. Curriculum Learning
83. 58. Explainability
85. Real-Time Monitoring
86. 59. Overview
87. 60. Experiment Tracking
88. 61. Quality Gates (Jidoka)
89. 62. Metrics Collection
90. 63. Terminal Dashboard
91. 64. Drift Detection
92. 65. Andon Alerting (Jidoka)
93. 66. Model Lineage
94. 67. Export Formats
95. 68. Hansei Reports
97. Dashboard
98. 69. Overview
99. 70. DashboardSource Trait
100. 71. WASM Bindings
102. Ecosystem Integration
103. 72. Overview
104. 73. Batuta Integration
105. 74. Realizar GGUF Export
106. 75. Ruchy Session Bridge
108. Model I/O
109. 76. Overview
110. 77. Save Models
111. 78. Load Models
112. 79. Model Metadata
113. 80. Supported Formats
114. 1. 80.1. SafeTensors Format
     2. 80.2. JSON Format
     3. 80.3. YAML Format
     4. 80.4. GGUF Format
116. Command-Line Interface
117. 81. CLI Overview
118. 82. Research Commands
119. 83. Benchmark Commands
121. Declarative Training
122. 84. Overview
123. 85. YAML Mode Training (v1.0)
124. 86. YAML Examples Catalog
125. 87. Toyota Way QA Process
126. 88. YAML Configuration
127. 89. train_from_yaml Function
128. 90. Configuration Schema
129. 91. Optimizer Builders
130. 92. Model Builders
132. API Reference
133. 93. Tensor API
134. 94. Autograd Operations
135. 95. Optimizer API
136. 96. LoRA API
137. 97. QLoRA API
138. 98. Configuration System
139. 99. Error Handling
141. Examples
142. 100. Linear Regression with Autograd
143. 101. Training a Simple MLP
144. 102. Fine-Tuning with LoRA
145. 103. Memory-Efficient QLoRA
146. 104. Custom Loss Functions
147. 105. Learning Rate Scheduling
148. 106. Gradient Clipping
149. 107. Adapter Sharing
151. Development Guide
152. 108. Contributing
153. 109. EXTREME TDD Methodology
154. 110. Testing Strategy
155. 1. 110.1. Unit Tests
     2. 110.2. Property-Based Tests
     3. 110.3. Gradient Checking Tests
     4. 110.4. Mutation Testing
156. 111. Quality Gates
157. 1. 111.1. Pre-Commit Hooks
     2. 111.2. Continuous Integration
     3. 111.3. Code Coverage
     4. 111.4. Clippy Linting
158. 112. Benchmarking
159. 113. PMAT Toyota Workflow
161. Best Practices
162. 114. Optimizer Selection
163. 115. Learning Rate Tuning
164. 116. LoRA Configuration
165. 117. Memory Optimization
166. 118. Gradient Stability
167. 119. Debugging Training Issues
168. 120. Performance Profiling
170. Advanced Topics
171. 121. Custom Backward Passes
172. 122. Implementing New Optimizers
173. 123. Custom LoRA Variants
174. 124. Advanced Quantization
175. 125. Distributed Training
176. 126. Model Parallelism
177. 127. Compiler-in-the-Loop (CITL)
179. Sovereign Deployment
180. 128. Overview
182. Academic Research
183. 129. Overview
185. Specifications
186. 130. Autograd Specification
187. 131. Optimizer Specification
188. 132. LoRA Specification
189. 133. Quantization Specification
190. 134. Academic Foundations
192. Appendix
193. 135. Glossary
194. 136. Mathematical Notation
195. 137. References
196. 138. FAQ
197. 139. Changelog
198. 140. Migration Guide
199. 141. Benchmarking Results