Claude Haiku 4.5 × binary-search

```python
def binary_search(arr: list[int], target: int) -> int:
    """
    Search for a target value in a sorted list using binary search algorithm.
    
    Binary search works by repeatedly dividing the search interval in half.
    It compares the target with the middle element and eliminates half of the
    remaining elements with each comparison, achieving O(log n) time complexity.
    
    Args:
        arr: A sorted list of integers in ascending order.
        target: The integer value to search for.
    
    Returns:
        The index (0-based) of the target if found in the list.
        Returns -1 if the target is not present in the list.
    
    Raises:
        TypeError: If arr is not a list or target is not an integer.
        ValueError: If the input list is not sorted in ascending order.
    
    Examples:
        >>> binary_search([1, 3, 5, 7, 9, 11], 7)
        3
        
        >>> binary_search([1, 3, 5, 7, 9, 11], 4)
        -1
        
        >>> binary_search([2, 4, 6, 8, 10], 2)
        0
    """
    # Input validation
    if not isinstance(arr, list):
        raise TypeError("arr must be a list")
    if not isinstance(target, int):
        raise TypeError("target must be an integer")
    
    # Check if the list is sorted (basic validation for small lists)
    if len(arr) > 1 and arr != sorted(arr):
        raise ValueError("arr must be sorted in ascending order")
    
    # Initialize left and right pointers
    left = 0
    right = len(arr) - 1
    
    # Continue searching while the search space is valid
    while left <= right:
        # Calculate middle index (avoids potential overflow in other languages)
        mid = left + (right - left) // 2
        
        # Compare target with middle element
        if arr[mid] == target:
            # Target found, return the index
            return mid
        elif arr[mid] < target:
            # Target is in the right half, move left pointer up
            left = mid + 1
        else:
            # Target is in the left half, move right pointer down
            right = mid - 1
    
    # Target not found in the list
    return -1


# Test cases demonstrating the function
if __name__ == "__main__":
    # Test case 1: Target found in the middle
    arr1 = [1, 3, 5, 7, 9, 11]
    result1 = binary_search(arr1, 7)
    print(f"Test 1 - Search for 7 in {arr1}: Index = {result1}")
    assert result1 == 3, "Expected index 3"
    
    # Test case 2: Target not found
    arr2 = [1, 3, 5, 7, 9, 11]
    result2 = binary_search(arr2, 4)
    print(f"Test 2 - Search for 4 in {arr2}: Index = {result2}")
    assert result2 == -1, "Expected -1"
    
    # Test case 3: Target at the beginning
    arr3 = [2, 4, 6, 8, 10]
    result3 = binary_search(arr3, 2)
    print(f"Test 3 - Search for 2 in {arr3}: Index = {result3}")
    assert result3 == 0, "Expected index 0"
    
    # Additional test cases
    # Test case 4: Target at the end
    arr4 = [2, 4, 6, 8, 10]
    result4 = binary_search(arr4, 10)
    print(f"Test 4 - Search for 10 in {arr4}: Index = {result4}")
    assert result4 == 4, "Expected index 4"
    
    # Test case 5: Single element list - found
    arr5 = [5]
    result5 = binary_search(arr5, 5)
    print(f"Test 5 - Search for 5 in {arr5}: Index = {result5}")
    assert result5 == 0, "Expected index 0"
    
    # Test case 6: Single element list - not found
    arr6 = [5]
    result6 = binary_search(arr6, 3)
    print(f"Test 6 - Search for 3 in {arr6}: Index = {result6}")
    assert result6 == -1, "Expected -1"
    
    # Test case 7: Empty list
    arr7 = []
    result7 = binary_search(arr7, 5)
    print(f"Test 7 - Search for 5 in {arr7}: Index = {result7}")
    assert result7 == -1, "Expected -1"
    
    print("\nAll tests passed! ✓")
    
    # Error handling examples
    print("\nTesting error handling:")
    try:
        binary_search("not a list", 5)
    except TypeError as e:
        print(f"✓ TypeError caught: {e}")
    
    try:
        binary_search([1, 2, 3], "five")
    except TypeError as e:
        print(f"✓ TypeError caught: {e}")
    
    try:
        binary_search([3, 1, 2], 2)
    except ValueError as e:
        print(f"✓ ValueError caught: {e}")
```

**Key Features:**

1. **Comprehensive Docstring**: Includes detailed description, Args, Returns, Raises, and Examples sections

2. **Algorithm Explanation**: 
   - Uses two pointers (left, right) to track the search interval
   - Calculates middle index safely
   - Eliminates half the remaining elements each iteration
   - Time complexity: O(log n)

3. **Input Validation**:
   - Type checking for both parameters
   - Ensures the list is sorted

4. **Inline Comments**: Explains each step of the algorithm logic

5. **Comprehensive Testing**: 
   - 7 test cases covering various scenarios
   - Error handling demonstrations
   - All assertions included

**Output:**
```
Test 1 - Search for 7 in [1, 3, 5, 7, 9, 11]: Index = 3
Test 2 - Search for 4 in [1, 3, 5, 7, 9, 11]: Index = -1
Test 3 - Search for 2 in [2, 4, 6, 8, 10]: Index = 0
Test 4 - Search for 10 in [2, 4, 6, 8, 10]: Index = 4
Test 5 - Search for 5 in [5]: Index = 0
Test 6 - Search for 3 in [5]: Index = -1
Test 7 - Search for 5 in []: Index = -1

All tests passed! ✓

Testing error handling:
✓ TypeError caught: arr must be a list
✓ TypeError caught: target must be an integer
✓ ValueError caught: arr must be sorted in ascending order
```