Round to Even Rule The standard practice for rounding numbers appears to include the "round to even" rule for cases where the digit to the right of the least significant digit is equal to 5. Here is an example from 
http://www.chemteam.info/SigFigs/Rounding.html 
Example #4 Round
24.8514 to three significant figures. Look at the fourth digit. It is a 5, so now you must also look at the third digit. It is 8, an even number, so you simply drop the 5 and the figures that follow it. The original number becomes 24.8. (rule #3 above)
They say that the intent of this rule it to ensure that in the long run we round up as often as we round down. If we are dealing with real numbers with infinite precision, this rule is of course unnecessary. But how about the case when we are working with floating point representations of real numbers that carry 16 or more digits of precision as would be stored internally in a computer. It seems to me that we could dispense with the round to even rule in this case with little risk of having an imbalance of round ups and round downs in the long run. Does this sound reasonable? If so, can someone offer a reference that discusses this subject and comes to the same conclusion that I did?
 A: There's more than one rounding rule. I doubt you'll find the reputable reference that comes to the same conclusion as you did.
There are many rounding rules. Particularly, in the floating point IEEE standard there are at least five different rules. Some programming languages such as Java support multiple rules. 
Also, note that there are different ways to represent floating points even with IEEE 754 standard, e.g. binary and decimals, which may have different default rounding modes. It's not always binary representation.
A: The core of the question was about floating point representation of numbers and rounding. Floating point numbers are hard to reason about but easy to experiment with.
Given a modern computer, based on floating point arithmetics, we can use a reasonable random number generator and produce continously distributed random data, e. g. normally distributed data, and round them. We can count how many times rounding is upwards or downwards an perform a binomial test to see, whether there is a tendency towards one of them.
The following R code does that with 10^8 random numbers
set.seed(42)
# huge number of random numbers normally distributed around 100:
sampled <- rnorm(1e+08, mean=100, sd=1)
# boolean count, whether a number was rounded upwards
rounded_up <- round(sampled)>sampled
# count those booleans
tabl <- table(rounded_up)
print(tabl)
# perform binomial test on results
binom.test(x=tabl)

My result here is p = .635 If you take a few minutes time, you can test it with n = 10^9. If there is a tendency towards rounding up or down that is not significant in n = 10^9, I don't think it will ever be relevant in any process that I am going to investigate in my life. 
Of course, if you round the values to say 3 digits and perform the above test, there will be a significant tendency towards rounding down:
set.seed(42)
# huge number of random numbers normally distributed around 100:
sampled <- round(rnorm(1e+08, mean=100, sd=1), digits=3)
# boolean count, whether a number was rounded upwards
rounded_up <- round(sampled)>sampled
# count those booleans
tabl <- table(rounded_up)
print(tabl)
# perform binomial test on results
binom.test(x=tabl)

will produce a p-value < 2.2e-16.
Of course, this is only simulation and not a theoretical approach, but it should still answer the question: The more digits you use, the higher an n is needed, to make a difference between standard rounding and rounding to even. Simulation is suitable to investigate, whether for a given n, the standard resolution of your software/computer (in this case R on Windows) is sufficient. If n gets larger than feasible for simulation, it's probably not possible to handle it with your statistics program anyways. So for all practical uses, simulation should be good enough.
