Update documentation for dual preference system and show_algorithm_choices

Updated documentation to reflect the new dual preference system and analysis function:

## Autotune Tutorial Updates
- Removed "in progress" warning about automatic preference setting
- Added mention of show_algorithm_choices() function
- Updated preference integration section to reflect working system
- Added example of viewing algorithm choices after autotune

## Algorithm Selection Basics Updates
- Added "Tuned Algorithm Selection" section explaining preference system
- Added show_algorithm_choices() usage examples
- Documented dual preference system benefits
- Explained size categories and preference structure

## Internal API Documentation Updates
- Added new internal functions: get_tuned_algorithm, is_algorithm_available, show_algorithm_choices
- Added preference system internals documentation
- Explained size categorization and dual preference structure
- Documented fallback mechanism architecture

These updates reflect that the dual preference system is now fully functional
and provide users with clear guidance on how to use the new capabilities.

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

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

Author: ChrisRackauckas

docs/src/advanced/internal_api.md

@@ -30,8 +30,30 @@ The automatic algorithm selection is one of LinearSolve.jl's key features:
 
 ```@docs
 LinearSolve.defaultalg
+LinearSolve.get_tuned_algorithm
+LinearSolve.is_algorithm_available
+LinearSolve.show_algorithm_choices
 ```
 
+### Preference System Internals
+
+The dual preference system provides intelligent algorithm selection with fallbacks:
+
+- **`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
+
+The system categorizes matrix sizes as:
+- **tiny**: ≤20 elements
+- **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
+- `best_always_loaded_{type}_{size}`: Fastest always-available algorithm (fallback)
+
 ## Trait Functions
 
 These trait functions help determine algorithm capabilities and requirements:

docs/src/basics/algorithm_selection.md

@@ -160,4 +160,46 @@ end
 sol = solve(prob, LinearSolveFunction(my_custom_solver))
 ```
 
-See the [Custom Linear Solvers](@ref custom) section for more details.
+See the [Custom Linear Solvers](@ref custom) section for more details.
+
+## Tuned Algorithm Selection
+
+LinearSolve.jl includes a sophisticated preference system that can be tuned using LinearSolveAutotune for optimal performance on your specific hardware:
+
+```julia
+using LinearSolve
+using LinearSolveAutotune
+
+# Run autotune to benchmark algorithms and set preferences
+results = autotune_setup(set_preferences = true)
+
+# View what algorithms are now being chosen
+show_algorithm_choices()
+```
+
+The system automatically sets preferences for:
+- **Different matrix sizes**: tiny (≤20), small (21-100), medium (101-300), large (301-1000), big (>1000)
+- **Different element types**: Float32, Float64, ComplexF32, ComplexF64
+- **Dual preferences**: Best overall algorithm + best always-available fallback
+
+### Viewing Algorithm Choices
+
+Use `show_algorithm_choices()` to see what algorithms are currently being selected:
+
+```julia
+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
+
+### Preference System Benefits
+
+- **Automatic optimization**: Uses the fastest algorithms found by benchmarking
+- **Intelligent fallbacks**: Falls back to always-available algorithms when extensions aren't loaded
+- **Size-specific tuning**: Different algorithms optimized for different matrix sizes
+- **Type-specific tuning**: Optimized algorithm selection for different numeric types

docs/src/tutorials/autotune.md

@@ -2,8 +2,7 @@
 
 LinearSolve.jl includes an automatic tuning system that benchmarks all available linear algebra algorithms on your specific hardware and automatically selects optimal algorithms for different problem sizes and data types. This tutorial will show you how to use the `LinearSolveAutotune` sublibrary to optimize your linear solve performance.
 
-!!! warn
-    The autotuning system is under active development. While benchmarking and result sharing are fully functional, automatic preference setting for algorithm selection is still being refined.
+The autotuning system provides comprehensive benchmarking and automatic algorithm selection optimization for your specific hardware.
 
 ## Quick Start
 
@@ -418,33 +417,46 @@ for config in configs
 end
 ```
 
-## Preferences Integration
+## Algorithm Selection Analysis
+
+You can analyze what algorithms are currently being chosen for different matrix sizes:
+
+```julia
+using LinearSolve
 
-!!! warn
-    Automatic preference setting is still under development and may not affect algorithm selection in the current version.
+# Show current algorithm choices and preferences
+show_algorithm_choices()
+```
+
+This displays:
+- Current autotune preferences (if any are set)
+- Algorithm choices for representative sizes in each category  
+- Element type behavior
+- System information (MKL, Apple Accelerate, RecursiveFactorization status)
+
+## Preferences Integration
 
-The autotuner can set preferences that LinearSolve.jl will use for automatic algorithm selection:
+The autotuner sets preferences that LinearSolve.jl uses for automatic algorithm selection:
 
 ```julia
 using LinearSolveAutotune
 
-# View current preferences (if any)
-LinearSolveAutotune.show_current_preferences()
-
 # Run autotune and set preferences
 results = autotune_setup(set_preferences = true)
 
-# Clear all autotune preferences
-LinearSolveAutotune.clear_algorithm_preferences()
+# View what algorithms are now being chosen
+using LinearSolve
+show_algorithm_choices()
 
-# Manually set custom preferences
-custom_categories = Dict(
-    "Float64_0-128" => "RFLUFactorization",
-    "Float64_128-256" => "LUFactorization"
-)
-LinearSolveAutotune.set_algorithm_preferences(custom_categories)
+# View current preferences
+LinearSolveAutotune.show_current_preferences()
+
+# Clear all autotune preferences if needed
+LinearSolveAutotune.clear_algorithm_preferences()
 ```
 
+After running autotune with `set_preferences = true`, LinearSolve.jl will automatically use the fastest algorithms found for each matrix size and element type, with intelligent fallbacks when extensions are not available.
+
 ## Troubleshooting
 
 ### Common Issues