To solve Bob's problem, we first need to formulate a symbolic representation of the optimization problem. Let's denote:

- $x_1$ as the number of trucks used
- $x_2$ as the number of vans used

The objective function is to maximize the total number of potatoes transported. Given that each truck can transport 150 potatoes and each van can transport 80 potatoes, the objective function can be represented algebraically as:

Maximize: $150x_1 + 80x_2$

The constraints are:
1. The cost constraint: Each truck costs $20 per trip, and each van costs $12 per trip. Bob wants to spend at most $250 on transporting his potatoes.
   - Algebraic representation: $20x_1 + 12x_2 \leq 250$
2. The traffic law constraint: The number of trucks must be less than the number of vans.
   - Algebraic representation: $x_1 < x_2$

Since we are dealing with whole vehicles, both $x_1$ and $x_2$ should be integers. However, for simplicity in finding a solution that maximizes the potatoes transported without immediately jumping into integer programming (which is not strictly necessary given our initial formulation focuses on linear programming), let's consider the problem as initially presented.

The symbolic representation of the problem in JSON format is:
```json
{
  'sym_variables': [('x1', 'number of trucks'), ('x2', 'number of vans')],
  'objective_function': 'Maximize: 150*x1 + 80*x2',
  'constraints': ['20*x1 + 12*x2 <= 250', 'x1 < x2', 'x1 >= 0', 'x2 >= 0']
}
```

To solve this problem using Gurobi in Python, we will formulate it as a linear programming problem. Note that since `x1` must be less than `x2`, and both are non-negative integers, we can start by checking feasible integer solutions within our constraints.

```python
from gurobipy import *

# Create a model
m = Model("Potato_Transport")

# Define variables
x1 = m.addVar(vtype=GRB.INTEGER, name="trucks")
x2 = m.addVar(vtype=GRB.INTEGER, name="vans")

# Objective function: Maximize the total potatoes transported
m.setObjective(150*x1 + 80*x2, GRB.MAXIMIZE)

# Constraints
m.addConstr(20*x1 + 12*x2 <= 250)  # Cost constraint
m.addConstr(x1 < x2)  # Traffic law constraint
m.addConstr(x1 >= 0)  # Non-negativity constraint for trucks
m.addConstr(x2 >= 0)  # Non-negativity constraint for vans

# Solve the model
m.optimize()

# Print solution
if m.status == GRB.OPTIMAL:
    print(f"Optimal solution: {m.objVal} potatoes transported")
    print(f"Trucks used: {x1.x}")
    print(f"Vans used: {x2.x}")
else:
    print("No optimal solution found")

```