To solve the optimization problem described, we first need to convert the natural language description into a symbolic representation. This involves defining variables and formulating the objective function and constraints algebraically.

Let's define:
- $x_1$ as the number of freight train trips.
- $x_2$ as the number of cargo ship trips.

The objective is to maximize the total number of fish transported. Given that each freight train can take 2000 fish per trip and each cargo ship can take 7000 fish per trip, the objective function can be represented as:
\[ \text{Maximize: } 2000x_1 + 7000x_2 \]

The constraints are as follows:
1. The budget constraint: The total cost for freight trains ($100 per trip) and cargo ships ($180 per trip) must not exceed $1500.
\[ 100x_1 + 180x_2 \leq 1500 \]
2. The constraint on the number of trips: The number of freight train trips must be less than the number of cargo ship trips.
\[ x_1 < x_2 \]
3. Non-negativity constraints: Both $x_1$ and $x_2$ must be non-negative since they represent numbers of trips.
\[ x_1 \geq 0, x_2 \geq 0 \]

However, since we're dealing with a linear programming formulation and the number of trips must be an integer, we should technically consider this as a mixed-integer linear program (MILP) if we were strictly adhering to the requirement that $x_1$ and $x_2$ are integers. For simplicity in solving with Gurobi, which can handle both LP and MILP formulations, we'll initially approach it as an LP problem but keep in mind the actual application requires integer solutions.

In symbolic representation:
```json
{
  'sym_variables': [('x1', 'number of freight train trips'), ('x2', 'number of cargo ship trips')],
  'objective_function': '2000*x1 + 7000*x2',
  'constraints': ['100*x1 + 180*x2 <= 1500', 'x1 < x2', 'x1 >= 0', 'x2 >= 0']
}
```

Now, let's implement this in Gurobi using Python. Note that to handle the strict inequality $x_1 < x_2$ directly is not straightforward in linear programming formulations as most solvers, including Gurobi, do not natively support strict inequalities. Instead, we can introduce a small positive value $\epsilon$ to convert it into a non-strict inequality ($x_1 \leq x_2 - \epsilon$) for practical purposes, but since our primary constraints and objective are linear and the problem does not explicitly require handling of strict inequalities in this context (given that in practice, $x_1$ and $x_2$ would be integers), we proceed with the understanding that finding an optimal integer solution will satisfy these conditions implicitly.

```python
from gurobipy import *

# Create a new model
m = Model("Fish_Transport")

# Add variables
x1 = m.addVar(vtype=GRB.INTEGER, name="freight_train_trips")
x2 = m.addVar(vtype=GRB.INTEGER, name="cargo_ship_trips")

# Set the objective function
m.setObjective(2000*x1 + 7000*x2, GRB.MAXIMIZE)

# Add constraints
m.addConstr(100*x1 + 180*x2 <= 1500, "budget")
m.addConstr(x1 <= x2 - 1, "trip_constraint") # Adjusted to ensure x1 < x2 by making it x1 <= x2 - 1 for integer solutions

# Optimize the model
m.optimize()

# Print the solution
if m.status == GRB.OPTIMAL:
    print("Optimal solution found:")
    print(f"Freight Train Trips: {x1.x}")
    print(f"Cargo Ship Trips: {x2.x}")
    print(f"Total Fish Transported: {2000*x1.x + 7000*x2.x}")
else:
    print("No optimal solution found")
```