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. Metrics Collection
88. 61. Terminal Dashboard
89. 62. Drift Detection
90. 63. Andon Alerting (Jidoka)
91. 64. Model Lineage
92. 65. Export Formats
93. 66. Hansei Reports
95. Model I/O
96. 67. Overview
97. 68. Save Models
98. 69. Load Models
99. 70. Model Metadata
100. 71. Supported Formats
101. 1. 71.1. SafeTensors Format
     2. 71.2. JSON Format
     3. 71.3. YAML Format
     4. 71.4. GGUF Format
103. Command-Line Interface
104. 72. CLI Reference
106. Declarative Training
107. 73. Overview
108. 74. YAML Configuration
109. 75. train_from_yaml Function
110. 76. Configuration Schema
111. 77. Optimizer Builders
112. 78. Model Builders
114. API Reference
115. 79. Tensor API
116. 80. Autograd Operations
117. 81. Optimizer API
118. 82. LoRA API
119. 83. QLoRA API
120. 84. Configuration System
121. 85. Error Handling
123. Examples
124. 86. Linear Regression with Autograd
125. 87. Training a Simple MLP
126. 88. Fine-Tuning with LoRA
127. 89. Memory-Efficient QLoRA
128. 90. Custom Loss Functions
129. 91. Learning Rate Scheduling
130. 92. Gradient Clipping
131. 93. Adapter Sharing
133. Development Guide
134. 94. Contributing
135. 95. EXTREME TDD Methodology
136. 96. Testing Strategy
137. 1. 96.1. Unit Tests
     2. 96.2. Property-Based Tests
     3. 96.3. Gradient Checking Tests
     4. 96.4. Mutation Testing
138. 97. Quality Gates
139. 1. 97.1. Pre-Commit Hooks
     2. 97.2. Continuous Integration
     3. 97.3. Code Coverage
     4. 97.4. Clippy Linting
140. 98. Benchmarking
141. 99. PMAT Toyota Workflow
143. Best Practices
144. 100. Optimizer Selection
145. 101. Learning Rate Tuning
146. 102. LoRA Configuration
147. 103. Memory Optimization
148. 104. Gradient Stability
149. 105. Debugging Training Issues
150. 106. Performance Profiling
152. Advanced Topics
153. 107. Custom Backward Passes
154. 108. Implementing New Optimizers
155. 109. Custom LoRA Variants
156. 110. Advanced Quantization
157. 111. Distributed Training
158. 112. Model Parallelism
159. 113. Compiler-in-the-Loop (CITL)
161. Specifications
162. 114. Autograd Specification
163. 115. Optimizer Specification
164. 116. LoRA Specification
165. 117. Quantization Specification
166. 118. Academic Foundations
168. Appendix
169. 119. Glossary
170. 120. Mathematical Notation
171. 121. References
172. 122. FAQ
173. 123. Changelog
174. 124. Migration Guide
175. 125. Benchmarking Results