standard model of floating point arithmetic The standard model is:
$$fl(x\; \text{op} \; y)=(x\; \text{op} \; y)(1+\delta),$$ 
where $|\delta| \le \epsilon$, but this ignores the rounding error after the computation.  I had thought that it should have been:
$$fl(x\; \text{op} \; y)=(x(1+\delta_1)\;\text{op}\;y(1+\delta_2))(1+\delta_3),$$ where $|\delta_i| \le \epsilon$.  Could someone clarify?
 A: In a formulation of the standard model of floating point arithmetic,
generally we start with two operands $x$ and $y,$
which are the values received by the processor on which to perform the desired operation.
It is also very often true that in the larger context of calculations in which one such operation occurs, the input operands $x$ and $y$ are themselves the result of some previous calculations--even if the calculations are only the conversion from data entered in decimal format to the internal binary floating-point format of the computer.
As a result of those previous calculations, it is possible that neither $x$ nor $y$ is equal to the value that it would have in a perfectly accurate computation. But any such difference is accounted for in the application of the model to earlier operations.
Note that once a number is output by one operation, it is already in the
floating-point format of the computer (having been rounded as needed during that operation) and does not require any additional rounding before being used as input to another operation.
The error of $x$ or $y$ (relative to their "true" values) can indeed be much greater than the rounding error of the floating-point representation, due to accumulated errors (of all kinds, not just rounding errors) from multiple previous operations. So your proposed model not only overcounts the errors according to the usual way of accounting for things,
it underestimates the possible error if it is supposed to represent the possible difference between the $x$ and $y$ the operation receives and the 
$x$ and $y$ the operation "should" receive.
A: This model of computation assumes that:


*

*Floating point operands $x$, $y$ are exact, i.e. $\text{fl}(x) = x$ and $\text{fl}(y) = y$.

*Computation of $z \equiv x\ \text{op} \ y $ for $\text{op} = $ $+$, $-$, $*$, $/$ is exact, is performed with infinite accuracy.

*The only source of error is the roundoff error $\text{fl}(z)$. This error cannot be avoided, since usually $z$ cannot be represented by floating point number.
This notation however can be quite confusing. To be more explicit let define by $\tilde{\text{op}}$ the result of operation $\text{op}$ returned by a computer. If this model is satisfied, then $x \ \tilde{\text{op}} \ y $ must be equal to $\text{fl}(x\ \text{op} \ y)$ and 
$$x \ \tilde{\text{op}} \ y \doteq \text{fl}(x\ \text{op} \ y) = (x\ \text{op}\ y)\times (1+\delta), \ \ |\delta| \leq \varepsilon$$
where $\varepsilon$ is the machine epsilon.
This model is valid on computers, that implements IEEE 784 standard of floating point computation with some differences:


*

*This model is not valid, when overflow or underflow occures, i.e. when $|z| > \text{MAX}$, or $|z| < \text{MIN}$, where $\text{MAX}$ is the largest representable number and $\text{MIN}$ is the smallest positive nonzero representable number.

*Computation error is much larger, when $x$, $y$, or $z$ is so called denormal number, i.e. small nonzero number, that cannot be represented with full accuracy possible for (normal) floating point numbers of given type.

*For default rounding mode (i.e. round to nearest ties to even) actual accuracy is 
$\text{fl}(x\ \text{op} \ y) = (x\ \text{op}\ y)\times (1+\delta)$ for $|\delta| \leq \frac{1}{2}\varepsilon$, where $\varepsilon$ is the machine epsilon.

*For fused operations, $x \pm y\times z$, computed result can be much more accurate than predicted by this model.

A: In Higham's book the standard model for floating point arithmetic is written as
$$ \text{fl}(x\,\text{op}\, y) = (x\, \text{op}\, y)(1+\delta),$$
where $x, y \in \mathcal{F}$ are machine numbers and $|\delta| \leq u$, where $u$ is the unit round off. 
If $x$ and $y$ are real numbers in the representable range, then
$$ \text{fl}(x) = x(1+\delta_x), \quad \text{fl(y)} = y(1 + \delta_y),$$
where $|\delta_x|, |\delta_y| \leq u$. 
When seeking to compute $s=x+y$ where $x$ and $y$ are real numbers, the best we can hope for is
$$ \hat{s} = \text{fl}(\text{fl}(x) + \text{fl}(y)) = \left[x(1+\delta_x) + y(1+\delta_y)\right](1+\delta).$$
This is the expression which you felt should replace the standard model. You simply missed that the standard model refers to machine numbers, rather than real numbers.

The unit roundoff $u$ is also known as machine precision. It should not be confused with machine epsilon, i.e. the distance between 1 and the next floating point number. In base $\beta$ and precision $t$, machine epsilon is
$$ \epsilon_M = \beta^{1-t}.$$
If we use round to nearest, then
$$ u = \frac{1}{2} \epsilon_M.$$
If we use directed rounding, then
$$ u = \epsilon_M.$$
