Update documentation for final preference system implementation

Comprehensive documentation updates reflecting all changes since last update:

## Autotune Tutorial Updates
- Updated show_algorithm_choices() documentation with comprehensive output
- Added example showing algorithm choices across all element types
- Enhanced preference integration examples
- Documented improved tabular analysis format

## Internal API Documentation Updates
- Updated function reference: reset_defaults! → make_preferences_dynamic!
- Added comprehensive preference system architecture documentation
- Documented src/preferences.jl file organization and structure
- Added testing mode operation explanation with eval-based approach
- Documented LU-only algorithm support scope

## Algorithm Selection Basics Updates
- Enhanced show_algorithm_choices() documentation with full feature set
- Added example output showing all element types side-by-side
- Updated preference system benefits with latest capabilities
- Documented comprehensive analysis and display features

## Key Documentation Features

### **File Organization**
- All preference functionality consolidated in src/preferences.jl
- Compile-time constants for production performance
- Runtime testing infrastructure for verification
- Analysis and display functions integrated

### **Testing Architecture**
- make_preferences_dynamic!() enables runtime preference checking
- Eval-based function redefinition maintains type stability
- No performance impact on production code
- Comprehensive preference verification capabilities

### **Enhanced Analysis**
- Algorithm choices for all element types across all sizes
- Clear tabular format showing preference effects
- System information and extension availability
- Preference display for all configured categories

The documentation now fully reflects the clean, efficient, and comprehensive
dual preference system implementation.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: ChrisRackauckas

docs/src/advanced/internal_api.md

@@ -36,25 +36,71 @@ LinearSolve.show_algorithm_choices
 LinearSolve.make_preferences_dynamic!
 ```
 
-### Preference System Internals
+### Preference System Architecture
 
-The dual preference system provides intelligent algorithm selection with fallbacks:
+The dual preference system provides intelligent algorithm selection with comprehensive fallbacks:
 
+#### **Core Functions**
 - **`get_tuned_algorithm`**: Retrieves tuned algorithm preferences based on matrix size and element type
-- **`is_algorithm_available`**: Checks if a specific algorithm is currently available (extensions loaded)
-- **`show_algorithm_choices`**: Analysis function to display current algorithm choices and preferences
+- **`is_algorithm_available`**: Checks if a specific algorithm is currently available (extensions loaded)  
+- **`show_algorithm_choices`**: Analysis function displaying algorithm choices for all element types
+- **`make_preferences_dynamic!`**: Testing function that enables runtime preference checking
 
-The system categorizes matrix sizes as:
-- **tiny**: ≤20 elements
+#### **Size Categorization**
+The system categorizes matrix sizes to match LinearSolveAutotune benchmarking:
+- **tiny**: ≤20 elements (matrices ≤10 always override to GenericLU)
 - **small**: 21-100 elements  
 - **medium**: 101-300 elements
 - **large**: 301-1000 elements
 - **big**: >1000 elements
 
-For each category and element type, preferences store both:
-- `best_algorithm_{type}_{size}`: Overall fastest algorithm
+#### **Dual Preference Structure**
+For each category and element type (Float32, Float64, ComplexF32, ComplexF64):
+- `best_algorithm_{type}_{size}`: Overall fastest algorithm from autotune
 - `best_always_loaded_{type}_{size}`: Fastest always-available algorithm (fallback)
 
+#### **Preference File Organization**
+All preference-related functionality is consolidated in `src/preferences.jl`:
+
+**Compile-Time Constants**:
+- `AUTOTUNE_PREFS`: Preference structure loaded at package import
+- `AUTOTUNE_PREFS_SET`: Fast path check for whether any preferences are set
+- `_string_to_algorithm_choice`: Mapping from preference strings to algorithm enums
+
+**Runtime Functions**:
+- `_get_tuned_algorithm_runtime`: Dynamic preference checking for testing
+- `_choose_available_algorithm`: Algorithm availability and fallback logic
+- `show_algorithm_choices`: Comprehensive analysis and display function
+
+**Testing Infrastructure**:
+- `make_preferences_dynamic!`: Eval-based function redefinition for testing
+- Enables runtime preference verification without affecting production performance
+
+#### **Testing Mode Operation**
+The testing system uses an elegant eval-based approach:
+```julia
+# Production: Uses compile-time constants (maximum performance)
+get_tuned_algorithm(Float64, Float64, 200)  # → Uses AUTOTUNE_PREFS constants
+
+# Testing: Redefines function to use runtime checking
+make_preferences_dynamic!()
+get_tuned_algorithm(Float64, Float64, 200)  # → Uses runtime preference loading
+```
+
+This approach maintains type stability and inference while enabling comprehensive testing.
+
+#### **Algorithm Support Scope**
+The preference system focuses exclusively on LU algorithms for dense matrices:
+
+**Supported LU Algorithms**:
+- `LUFactorization`, `GenericLUFactorization`, `RFLUFactorization`
+- `MKLLUFactorization`, `AppleAccelerateLUFactorization`
+- `SimpleLUFactorization`, `FastLUFactorization` (both map to LU)
+- GPU LU variants (CUDA, Metal, AMDGPU - all map to LU)
+
+**Non-LU algorithms** (QR, Cholesky, SVD, etc.) are not included in the preference system
+as they serve different use cases and are not typically the focus of dense matrix autotune optimization.
+
 ## Trait Functions
 
 These trait functions help determine algorithm capabilities and requirements:

docs/src/basics/algorithm_selection.md

@@ -191,11 +191,22 @@ using LinearSolve
 show_algorithm_choices()
 ```
 
-This shows:
-- Current autotune preferences (if set)
-- Algorithm choices for each size category
-- System information (available extensions)
-- Element type behavior
+This shows a comprehensive analysis:
+- Current autotune preferences for all element types (if set)
+- Algorithm choices for all element types across all size categories
+- Side-by-side comparison showing Float32, Float64, ComplexF32, ComplexF64 behavior
+- System information (available extensions: MKL, Apple Accelerate, RecursiveFactorization)
+
+Example output:
+```
+📊 Default Algorithm Choices:
+Size       Category    Float32            Float64            ComplexF32         ComplexF64
+8×8        tiny        GenericLUFactorization GenericLUFactorization GenericLUFactorization GenericLUFactorization
+50×50      small       MKLLUFactorization MKLLUFactorization MKLLUFactorization MKLLUFactorization
+200×200    medium      MKLLUFactorization GenericLUFactorization MKLLUFactorization MKLLUFactorization
+```
+
+When preferences are set, you can see exactly how they affect algorithm choice across different element types.
 
 ### Preference System Benefits
 

docs/src/tutorials/autotune.md

@@ -429,11 +429,19 @@ show_algorithm_choices()
 ```
 
 This displays:
-- Current autotune preferences (if any are set)
-- Algorithm choices for representative sizes in each category  
-- Element type behavior
+- Current autotune preferences for all element types (if any are set)
+- Algorithm choices for all element types across representative sizes in each category  
+- Comprehensive element type behavior (Float32, Float64, ComplexF32, ComplexF64)
 - System information (MKL, Apple Accelerate, RecursiveFactorization status)
 
+The output shows a clear table format:
+```
+📊 Default Algorithm Choices:
+Size       Category    Float32            Float64            ComplexF32         ComplexF64
+8×8        tiny        GenericLUFactorization GenericLUFactorization GenericLUFactorization GenericLUFactorization
+200×200    medium      MKLLUFactorization MKLLUFactorization MKLLUFactorization MKLLUFactorization
+```
+
 ## Preferences Integration
 
 The autotuner sets preferences that LinearSolve.jl uses for automatic algorithm selection: