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. Train Config
75. 50. Basic Training Loop
76. 51. Batching and Data Loading
77. 52. Loss Functions
78. 53. Validation and Testing
79. 54. Checkpointing
80. 55. Early Stopping
82. Model I/O
83. 56. Overview
84. 57. Save Models
85. 58. Load Models
86. 59. Model Metadata
87. 60. Supported Formats
88. 1. 60.1. JSON Format
    2. 60.2. YAML Format
    3. 60.3. GGUF Format
90. Command-Line Interface
91. 61. CLI Reference
93. Declarative Training
94. 62. Overview
95. 63. YAML Configuration
96. 64. train_from_yaml Function
97. 65. Configuration Schema
98. 66. Optimizer Builders
99. 67. Model Builders
101. API Reference
102. 68. Tensor API
103. 69. Autograd Operations
104. 70. Optimizer API
105. 71. LoRA API
106. 72. QLoRA API
107. 73. Configuration System
108. 74. Error Handling
110. Examples
111. 75. Linear Regression with Autograd
112. 76. Training a Simple MLP
113. 77. Fine-Tuning with LoRA
114. 78. Memory-Efficient QLoRA
115. 79. Custom Loss Functions
116. 80. Learning Rate Scheduling
117. 81. Gradient Clipping
118. 82. Adapter Sharing
120. Development Guide
121. 83. Contributing
122. 84. EXTREME TDD Methodology
123. 85. Testing Strategy
124. 1. 85.1. Unit Tests
     2. 85.2. Property-Based Tests
     3. 85.3. Gradient Checking Tests
     4. 85.4. Mutation Testing
125. 86. Quality Gates
126. 1. 86.1. Pre-Commit Hooks
     2. 86.2. Continuous Integration
     3. 86.3. Code Coverage
     4. 86.4. Clippy Linting
127. 87. Benchmarking
128. 88. PMAT Toyota Workflow
130. Best Practices
131. 89. Optimizer Selection
132. 90. Learning Rate Tuning
133. 91. LoRA Configuration
134. 92. Memory Optimization
135. 93. Gradient Stability
136. 94. Debugging Training Issues
137. 95. Performance Profiling
139. Advanced Topics
140. 96. Custom Backward Passes
141. 97. Implementing New Optimizers
142. 98. Custom LoRA Variants
143. 99. Advanced Quantization
144. 100. Distributed Training
145. 101. Model Parallelism
147. Specifications
148. 102. Autograd Specification
149. 103. Optimizer Specification
150. 104. LoRA Specification
151. 105. Quantization Specification
152. 106. Academic Foundations
154. Appendix
155. 107. Glossary
156. 108. Mathematical Notation
157. 109. References
158. 110. FAQ
159. 111. Changelog
160. 112. Migration Guide
161. 113. Benchmarking Results