## Problem Description and Formulation

The problem is a linear programming optimization problem where the goal is to maximize the score from throwing small and large balls at a target. The scoring system awards 5 points for each small ball and 2 points for each large ball.

### Decision Variables

- \(x_s\): The number of small balls to throw.
- \(x_l\): The number of large balls to throw.

### Objective Function

The objective is to maximize the total score: \(5x_s + 2x_l\).

### Constraints

1. **Total Balls Constraint**: The total number of balls thrown cannot exceed 20. So, \(x_s + x_l \leq 20\).
2. **Minimum Small Balls Constraint**: At least 6 small balls must be thrown. So, \(x_s \geq 6\).
3. **Minimum Large Balls Constraint**: At least 5 large balls must be thrown. So, \(x_l \geq 5\).
4. **Maximum Balls Constraint**: No more than 12 of either type can be thrown. So, \(x_s \leq 12\) and \(x_l \leq 12\).
5. **Non-Negativity Constraint**: The number of balls cannot be negative. So, \(x_s \geq 0\) and \(x_l \geq 0\). However, this is partially covered by the minimum constraints.

## Gurobi Code Formulation

Given the problem formulation, we can now translate it into Gurobi code in Python:

```python
import gurobi

def maximize_score():
    # Create a new model
    model = gurobi.Model()

    # Define the decision variables
    x_s = model.addVar(lb=6, ub=12, name="small_balls")  # At least 6, no more than 12
    x_l = model.addVar(lb=5, ub=12, name="large_balls")  # At least 5, no more than 12

    # Objective function: Maximize 5x_s + 2x_l
    model.setObjective(5 * x_s + 2 * x_l, gurobi.GRB.MAXIMIZE)

    # Total balls constraint: x_s + x_l <= 20
    model.addConstr(x_s + x_l <= 20, name="total_balls")

    # Solve the model
    model.optimize()

    # Get the optimized values
    if model.status == gurobi.GRB.OPTIMAL:
        small_balls = x_s.varValue
        large_balls = x_l.varValue
        max_score = 5 * small_balls + 2 * large_balls
        print(f"Optimal Strategy: Throw {small_balls} small balls and {large_balls} large balls.")
        print(f"Maximum Score: {max_score}")
    else:
        print("The model is infeasible.")

maximize_score()
```

This code sets up the optimization problem with Gurobi, solves it, and prints out the optimal strategy and the maximum achievable score. If the problem is infeasible (i.e., no solution satisfies all constraints), it indicates that as well.