Actually the intermediate Operation abstract does clean it up some more. Basics of that refactor are...

```
public class Operation : Expression 
{
    private Expression _lhs;
    private Expression _rhs;
    
    public Operation(Expression lhs, Expression rhs)
    {
        _lhs = lhs;
        _rhs = rhs;
    }
    
    protected abstract float CalculateResult(float lhs, float rhs);

    public override float Run() => CalculateResult(_lhs.Run(), _rhs.Run());
}

public class Subtract : Operation
{
    public Subtract(Expression lhs, Expression rhs)
        : base(lhs, rhs) {}
    
    protected override float CalculateResult(float lhs, float rhs) 
        => lhs + rhs;
}

public class Multiply : Operation
{
    public Multiply(Expression lhs, Expression rhs)
        : base(lhs, rhs) {}
    
    protected override float CalculateResult(float lhs, float rhs) 
        => lhs * rhs;
}

...
```