[HN Gopher] 987654321 / 123456789
___________________________________________________________________
987654321 / 123456789
Author : ColinWright
Score : 464 points
Date : 2025-10-26 15:22 UTC (4 days ago)
(HTM) web link (www.johndcook.com)
(TXT) w3m dump (www.johndcook.com)
| trotro wrote:
| Feels like a Temu version of Ramanujan's constant [0].
|
| [0] https://mathworld.wolfram.com/RamanujanConstant.html
| MontyCarloHall wrote:
| In a similar vein, e^pi - pi = 19.9990999792, as referenced in
| this XKCD: https://xkcd.com/217/
| madcaptenor wrote:
| Not really in a similar vein, because there's actually a good
| reason for this to be very close to an integer whereas there is
| no such reason for e^pi - pi.
| tempfile wrote:
| No _known_ reason :-)
| zkmon wrote:
| Also, (-1)^(-i) - pi = 19.999... ;)
| alyxya wrote:
| I like to think of 0.987654... and 0.123456... as infinite series
| which simplify to 80/81 and 10/81, hence the ~8 ratio.
| Stolpe wrote:
| Care to elaborate? Why does 0.987654 simplify to 80/81 and
| 0.123456 to 10/81?
| alyxya wrote:
| If you set x = 0.123456..., then multiplying it by (10 - 1)
| gives 9x = 1.111111..., and multiplying it by (10 - 1) again
| gives 81x = 10, or x = 10/81. I'm not writing things formally
| here but that's the rough idea, and you can do the same
| procedure with 0.987654... to get 80/81.
| madcaptenor wrote:
| .123456... = x + 2 x^2 + 3 x^3 + ... with x = 1/10.
|
| Then you have (x + 2 x^2 + 3 x^3 + ...) = (x + x^2 + x^3 +
| x^4 + ...) + (x^2 + x^3 + x^4 + x^5 + ...) + (x^3 + x^4 + x^5
| + x^6 + ...) (count the number of occurrences of each power
| of x^n on the right-hand side)
|
| and from the sum of a geometric series the RHS is x/(1-x) +
| x^2/(1-x) + x^3/(1-x) + ..., which _itself_ is a geometric
| series and works out to x /(1-x)^2. Then put in x = 1/10 to
| get 10/81.
|
| Now 0.987654... = 1 - 0.012345... = 1 - (1/10) (10/81) = 1 -
| 1/81 = 80/81.
| gus_massa wrote:
| I don't know who downvoted this, but it's correct.
|
| The use of series is a little "sloppy", but x + 2 x^2 + 3
| x^3 + ... has absolute uniform convergence when |x|<r<1,
| even more importantly that it's true even for complex
| numbers |z|<r<1.
|
| The super nice property of complex analysis is that you can
| be almost ridiculously "sloppy" inside that open circle and
| the Conway book will tell you everything is ok.
|
| [I'll post a similar proof, but mine use -1/10 and
| rounding, so mine is probably worse.]
| gowld wrote:
| Don't need the clutter of infinite series and polynomials:
| 1/9 = 0.1111... 1/81 = 1/9 * 1/9 = 0.111... *
| 0.111... = Sum of: 0.0111...
| 0.00111... 0.000111... ...
| = 0.012345...
| madcaptenor wrote:
| This is better than my answer, at least if you can get
| your brain to interpret it in base b. In that case the
| first two lines would become 1/(b-1) =
| 0.1111... 1/((b-1)^2) = 1/b * 1/b = 0.111... *
| 0.111... =
| GuB-42 wrote:
| Isn't it essentially the same thing, but less formal
|
| 0.1111... is just a notation for (x + x^2 + x^3 + x^4 +
| ...) with x = 1/10
|
| 1/9 = 0.1111... is a direct application of the x/(1-x)
| formula
|
| The sum of 0.0111... + 0.00111... ... = 0.012345... part
| is the same as the "(x + 2 x^2 + 3 x^3 + ...) = (x + x^2
| + x^3 + x^4 + ...) + (x^2 + x^3 + x^4 + x^5 + ...)" part
| (but divided by 10)
|
| And 1/81 = 1/9 * 1/9 ... part is the x/(1-x)^2 result
| oersted wrote:
| I didn't get where this comes from until I saw the second
| answer from the StackOverflow question another commenter
| shared.
|
| https://math.stackexchange.com/a/2268896
|
| Apparently 1/9^2 is well known to be 0.12345679(012345679)...
|
| EDIT: Yes it's missing the 8 (I wrote it wrong intially):
| https://math.stackexchange.com/questions/994203/why-do-we-mi...
|
| Interesting how it works out but I don't think it is anywhere
| close to as intuitive as the parent comment implies. The way
| its phrased made me feel a bit dumb because I didn't get it
| right away, but in retrospect I don't think anyone would
| reasonably get it without context.
| iso1631 wrote:
| 9^2 is 81
|
| 1/81 is 0.012345679012345679....
|
| no 8 in sight
| madcaptenor wrote:
| The 8 is there but then it's followed by a 9 and a 10, and
| the carry from the 10 ends up bumping it up.
| zkmon wrote:
| Shouldn't wee see two zeros then?
| oersted wrote:
| This illustrates it nicely:
| https://math.stackexchange.com/a/994214
| madcaptenor wrote:
| The reason you don't see two zeroes is as follows: you
| have .123456789
|
| then add 10 on the end, as the tenth digit after the
| decimal point, to get .123456789(10)
|
| where the parentheses denote a "digit" that's 10 or
| larger, which we'll have to deal with by carrying to get
| a well-formed decimal. Then carry twice to get
| .12345678(10)0 .1234567900
|
| So for a moment we have two zeroes, but now we need to
| add 11 to the 11th digit after the decimal point to get
| .1234567900(11)
|
| or after carrying .12345679011
|
| and now there is only one zero.
| zkmon wrote:
| Ah, that's cool. Thanks!
| alyxya wrote:
| It actually skips the 8 in its repeating decimal. It's better
| to think of 1/9^2 as the infinite sum of k * 10^-k for all
| positive integers k. The 8 gets skipped because you have
| something like ...789(10)(11)... where the 1 from the "10"
| and "11" digits carry over, increment the 9 digit causing
| another carry, so the 8 becomes a 9.
| dpacmittal wrote:
| Also 12345679*x*9 = xxxxxxxxx
|
| Eg 12345679*6*9 = 666666666
| madcaptenor wrote:
| I think your formatting is off.
| ozb wrote:
| More general analytic proof:
| https://math.stackexchange.com/questions/2268833/why-is-frac...
| ukuina wrote:
| That question was asked 8 years ago. Coincidence? I think not!
| yohbho wrote:
| For smaller bases, does this converge to base - 1 ?
|
| Base 3: 21/12 = 7/5(dec.)
|
| Base 2: 1/1 = 1
|
| Base 1: |/| = 1 (thinking |||| = 4 etc.)
| Joker_vD wrote:
| Somewhat interesting, 123456789 * 8 is 987654312 (the last two
| digits are swapped). This holds for other bases as well:
| 0x123456789ABCDEF * 14 is 0xFEDCBA987654312.
|
| Also, adding 123456789 to itself eight times on an abacus is a
| nice exercise, and it's easy to visually control the end result.
| andyjansson wrote:
| Another interesting thing is that these seem to work:
|
| base 16: 123456789ABCDEF~16 * (16-2) + 16 - 1 =
| FEDCBA987654321~16
|
| base 10: 123456789~10 * (10-2) + 10 - 1 = 987654321~10
|
| base 9: 12345678~9 * (9-2) + 9 - 1 = 87654321~9
|
| base 8: 1234567~8 * (8-2) + 8 - 1 = 7654321~8
|
| base 7: 123456~7 * (7-2) + 7 - 1 = 654321~7
|
| base 6: 12345~6 * (6-2) + 6 - 1 = 54321~6
|
| and so on..
|
| or more generally:
|
| base n: sequence * (n - 2) + n - 1
| madcaptenor wrote:
| This is in the original post, in the form
| num(b)/denom(b) = b - 2 + (b-1)/denom(b)
|
| so you just need to clear the denominator.
| monkpit wrote:
| > the last 2 digits are swapped
|
| They are also +9 away from being in order.
|
| And then 12345678 * 8 is 98765424 which is +9 away from also
| being in order.
| ok123456 wrote:
| For the even bases, the "error" appears to be
| https://oeis.org/A051848.
|
| pp = lambda x : denom(x)/ (num(x) - denom(x)*(x - 2))
|
| [pp(2),pp(4),pp(6),pp(8)]
|
| [1.0, 9.0, 373.0, 48913.0]
| madcaptenor wrote:
| And if you see the description there it traces back to
| https://oeis.org/A023811, which is more obviously relevant
| throw0101c wrote:
| See perhaps various "What every programmer / CSist should know
| about floating-point arithmetic" papers and articles:
|
| * David Goldberg, 1991:
| https://dl.acm.org/doi/10.1145/103162.103163
|
| * 2014, "Floating Point Demystified, Part 1":
| https://blog.reverberate.org/2014/09/what-every-computer-pro... ;
| https://news.ycombinator.com/item?id=8321940
|
| * 2015:
| https://www.phys.uconn.edu/~rozman/Courses/P2200_15F/downloa...
| MrOrelliOReilly wrote:
| As someone who has recently been fighting bugs from
| representing very simple math with floats... thank you!
| msuvakov wrote:
| Why the b > 2 condition? In the b=2 case, all three formulas also
| work perfectly, providing a ratio of 1. And this is interesting
| case where the error term is integer and the only case where that
| error term (1) is dominant (b-2=0), while the b-2 part dominates
| for larger bases.
| listeria wrote:
| in the b=2 case, you get: 1 / 1 = 1 = b - 1
| 1 % 1 = 0 = b - 2
|
| they are the other way around, see for example the b=3 case:
| 21 (base 3) = 7 12 (base 3) = 5 7 / 5 = 1 = b - 2
| 7 % 5 = 2 = b - 1
| tetris11 wrote:
| I like calculator quirks like this. I remember as a kid playing
| with the number pad and noticing a geometric center of mass in
| number sequences +---+---+---+ | 7 | 8
| | 9 | +---+---+---+ | 4 | 5 | 6 |
| +---+---+---+ | 1 | 2 | 3 | +---+---+---+
| | 0 | . | | +---+---+---+
|
| I remember seeing that (14787 + 36989) / 2 would produce 25888,
| in that the mean of geometric shape traced by the two sequences
| would average out in the middle like that
| nashashmi wrote:
| 14789 + 36987 / 2 would do the same thing. Why trace back?
| dfee wrote:
| So would 147 and 369. As it's just an average, per digit, I'm
| not sure this is very interesting.
| gowld wrote:
| Being curious is delightful.
| tetris11 wrote:
| Just to show that you could - 14861 and 36843 gives 25852
| nasvay_factory wrote:
| i remember the 1110 thing on a calc as well.
|
| 741 + 369 & 963 + 147 | 123 + 987 & 321 + 789 (left right | up
| down)
|
| 159 + 951 & 753 + 357 | 258 + 852 & 456 + 654 (diagonally |
| center lines)
|
| the design of a keypad... it unintentionally contains these
| elegant mathematical relationships.
|
| i call this phenomena: outcomes of human creations can be
| "funny and odd", and everybody understand that eventually there
| will be always something unpredictable.
| sim7c00 wrote:
| ita intuited knowledge, which is only later understood.
| (itzhak bentov, stalking the wild pendulum)
| nonethewiser wrote:
| The even simpler example is more striking imo.
|
| (147 + 369) / 2 = 258
|
| and
|
| (741 + 963) / 2 = 852
| tempodox wrote:
| The decimal digits clearly have a conspiracy going on.
| deepsun wrote:
| That would work in any base, I even think we would find way
| more interesting coincidences in base 12 (as Sumerians
| preferred), because it's divisible by 2,3,4,6.
|
| It's unfortunate that we have 5 fingers.
| anvuong wrote:
| But this is obvious?
|
| (741 + 963)/2 = (700+900)/2 + (40+60)/2 + (1+3)/2, it's just
| average in each decimal place.
| jvanderbot wrote:
| Obvious _now_ and really cool in hindsight.
| bitwize wrote:
| Great, now I'm getting Carrot Top flashbacks. "Dial right down
| the center of the phone!"
|
| For non-Americans and/or those too young to remember when
| landline service was still dominant, in the 90s and early 2000s
| AT&T ran a collect-call service accessible through the number
| 1-800-CALL-ATT (1-800-225-5288) and promoted it with ads
| featuring comedian Carrot Top. And if you don't know who Carrot
| Top is, maybe that's for the best.
| wkat4242 wrote:
| I thought this was a user ID and password lol
| danielbarla wrote:
| I also spent hours messing around with calculators as a kid. I
| recall noticing that:
|
| 11 * 11 = 121
|
| 111 * 111 = 12321
|
| 1111 * 1111 = 1234321
|
| and so on, where the largest digit in the answer is the number of
| digits in the multiplicands.
| brutuscat wrote:
| Gemini thinks in a similar fashion:
|
| https://gemini.google.com/share/1e59f734b43c
|
| This is a fantastic observation, and yes, this pattern not only
| continues for larger bases, but the approximation to an integer
| becomes dramatically better.
|
| The general pattern you've found is that for a number base $b$,
| the ratio of the number formed by digits $(b-1)...321$ to the
| number formed by digits $123...(b-1)$ is extremely close to
| $b-2$.
|
| ### The General Formula
|
| Let's call your ascending number $N_{asc}(b)$ and your descending
| number $N_{desc}(b)$.
|
| The exact ratio $R(b) = N_{desc}(b) / N_{asc}(b)$ can be shown to
| be:
|
| $$R(b) = (b-2) + \frac{(b-1)^3}{b^b - b^2 + b - 1}$$
|
| The "error" or the fractional part is that second term. As you
| can see, the numerator $(b-1)^3$ is roughly $b^3$, while the
| denominator $b^b$ grows _much_ faster.
|
| ### Testing Your Examples
|
| Let's check your two examples with this formula:
|
| * *Base 10 (b=10):* * $R(10) = (10-2) + \frac{(10-1)^3}{10^{10} -
| 10^2 + 10 - 1}$ * $R(10) = 8 + \frac{9^3}{10,000,000,000 - 91}$ *
| $R(10) = 8 + \frac{729}{9,999,999,909} \approx 8 +
| 0.0000000729...$ * This matches your $8.0000000729$ perfectly.
|
| * *Base 6 (b=6):* * $R(6) = (6-2) + \frac{(6-1)^3}{6^6 - 6^2 + 6
| - 1}$ * $R(6) = 4 + \frac{5^3}{46,656 - 31}$ * $R(6) = 4 +
| \frac{125}{46,625} \approx 4 + 0.00268...$ * This also matches
| your $4.00268$.
|
| ### Answering Your Question: A Larger Base
|
| So, what about a larger base? Let's use *Base 16* (hexadecimal),
| which uses digits $1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F$.
| Here, $b=16$.
|
| * $N_{asc} = 123456789ABCDEF_{16}$ * $N_{desc} =
| FEDCBA987654321_{16}$
|
| According to the pattern, the ratio should be extremely close to
| $b-2 = 16-2 = 14$.
|
| Let's use the formula to see _how_ close:
|
| * $R(16) = (16-2) + \frac{(16-1)^3}{16^{16} - 16^2 + 16 - 1}$ *
| $R(16) = 14 + \frac{15^3}{16^{16} - 241}$ * $R(16) = 14 +
| \frac{3,375}{1.844... \times 10^{19} - 241}$ * $R(16) \approx 14
| + (1.829... \times 10^{-16})$
|
| So, the ratio in base 16 is approximately:
| *$14.0000000000000001829...$*
|
| As you predicted, the "error" for a larger base is astronomically
| smaller than it was for base 10.
| OldGreenYodaGPT wrote:
| Definitions: denom(b) = (b^b - b^2 + b - 1) / (b - 1)^2 num(b) =
| (b^b _(b - 2) + 1) / (b - 1)^2
|
| Exact relation: num(b) - (b - 2)_denom(b) = b - 1
|
| Therefore: num(b) / denom(b) = (b - 2) + (b - 1)^3 / (b^b - b^2 +
| b - 1) [exact]
|
| Geometric expansion: Let a = b^2 - b + 1. 1 / (b^b - b^2 + b - 1)
| = (1 / b^b) * 1 / (1 - a / b^b) = (1 / b^b) * sum_{k>=0} (a /
| b^b)^k
|
| So: num(b) / denom(b) = (b - 2) * (b - 1)^3 / b^b * (b - 1)^3 * a
| / b^{2b} * (b - 1)^3 * a^2 / b^{3b} * ...
|
| Practical approximation: num(b) / denom(b) [?] (b - 2) + (b -
| 1)^3 / b^b
|
| Exact error: Let T_exact = (b - 1)^3 / (b^b - b^2 + b - 1) Let
| T_approx = (b - 1)^3 / b^b
|
| Absolute error: T_exact - T_approx = (b - 1)^3 * (b^2 - b + 1) /
| [ b^b * (b^b - b^2 + b - 1) ]
|
| Relative error: (T_exact - T_approx) / T_exact = (b^2 - b + 1) /
| b^b
|
| Sign: The approximation with denominator b^b underestimates the
| exact value.
|
| Digit picture in base b: (b - 1)^3 has base-b digits (b - 3), 2,
| (b - 1). Dividing by b^b places those three digits starting b
| places after the radix point.
|
| Examples: base 10: 8 + 9^3 / 10^10 = 8.0000000729 base 9: 7 + 8^3
| / 9^9 = 7.000000628 in base 9 base 8: 6 + 7^3 / 8^8 = 6.00000527
| in base 8
|
| num(b) / denom(b) equals (b - 2) + (b - 1)^3 / (b^b - b^2 + b -
| 1) exactly. Replacing the denominator by b^b gives a simple
| approximation with relative error exactly (b^2 - b + 1) / b^b.
| jedberg wrote:
| This was by far the most interesting part to me. I've never
| considered that code and proofs can be so complementary. It would
| be great if someone did this for all math proofs!
|
| "Why include a script rather than a proof? One reason is that the
| proof is straight-forward but tedious and the script is compact.
|
| A more general reason that I give computational demonstrations of
| theorems is that programs are complementary to proofs. Programs
| and proofs are both subject to bugs, but they're not likely to
| have the _same_ bugs. And because programs made details explicit
| by necessity, a program might fill in gaps that aren't
| sufficiently spelled out in a proof. "
| layer8 wrote:
| This is misleading in that the (Curry-Howard) correspondence is
| between proofs and the static typing of programs. A bug in a
| proof therefore corresponds to a bug in the static typing of a
| program (or to the type system of the programming language
| being unsound), not to any other program bug.
|
| (Also: complementary != complimentary.)
| nh23423fefe wrote:
| i think this is wrong. code is proofs, types are propositions
| layer8 wrote:
| The types are the propositions proved by the proof. The
| proof is correct <=> the program is soundly typed.
| CamperBob2 wrote:
| Code is proof that the operation embodied by the _code_
| works. I don 't understand how it proves anything more
| generally than that, apart from code using exotic languages
| or techniques intended for just that purpose.
| sigbottle wrote:
| Well, in theory (and I guess more generally philosophy)
| land, sure, you can't really "prove absoluteness" outside
| of your axioms and assumptions. You need to have a notion
| of true and false, and then implications, for example, to
| do logic, then whatever the leap from there it takes to
| do set theory, then go up from there etc. it's turtles
| all the way down.
|
| In practice land (real theorem provers), I guess the idea
| is that, it theoretically should be a perfect logic
| engine. Two issues:
|
| 1. What if there's a compiler bug?
|
| 2. How do I "know" that I actually compiled "what I
| meant" to this logic engine?
|
| (which are re-statements of what I said in theory land).
| You are given, that supposedly, within _your_ internal
| logic engine, you have a proof, and you want to translate
| it to a "universal" one.
|
| I guess the idea is, in practice, you just hope that
| slight perturbations to either your mental model, the
| translation, or even the compiler itself, just "hard
| fail". Just hope it's a very not-continuous space and
| violating boundaries fail the self-consistency check.
|
| (As opposed to, for example, physical engineering, which
| generally doesn't allow _hard_ failure and has a bunch of
| controls and guards in mind, and it 's very much a
| continuuum).
|
| A trivial example is how easy it is to just typo a
| constant or a variable name in a normal programming
| language, and the program still compiles fine (this is
| why we have tests!). The idea is, that, down from trivial
| errors like that, all the way up to fundamental
| misconceptions and such, you can catch preturbations to
| the ideal, I guess, be they small or large. I think what
| makes one of these theorem provers minimally good, is
| that you can't easily, accidentally encode a concept
| wrong (from high level model A to low level theorem
| proving model B), for a variety of reasons. Then of
| course, runtime efficiency, ergonomics etc. come later.
|
| Of course, this brings into notion just how "powerful"
| certain models bring - my friend is doing a research
| project with these, something as simple as "proving a dfs
| works to solve a problem" is apparently horrible.
| jedberg wrote:
| > Also: complementary != complimentary
|
| I'm gonna blame autocorrect for that one, but appreciate you
| catching it. Fixed! :)
| Sharlin wrote:
| I don't think the author is referring to the C-H
| correspondence. Just the fact that
|
| a) it can be actually helpful to check that some property
| holds up to one zillion, even though it's not a proof that it
| holds for all numbers; and
|
| b) if a proof has a bug, a program checking the relevant
| property up to one zillion is not unlikely to produce a
| counterexample.
| TheTon wrote:
| As a kid, I was marginally decent at competitive math. Not good
| like you think of kids who dominate those type of competitions
| at a high level, but like I could qualify for the state
| competition type good.
|
| What I was actually good, or at least fast at, was TI-Basic,
| which was allowed in a lot of cases (though not all). Usually
| the problems were set up so you couldn't find the solution
| using just the calculator, but if you had a couple of ideas and
| needed to choose between them you could sometimes cross off the
| wrong ones with a program.
|
| The script the author gives isn't a proof itself, unless the
| proposition is false, in which case a counter example always
| makes a great proof :p
| bobbylarrybobby wrote:
| Let's prove it.
|
| In general, sum(x^k, k=1...n) = x(1-x^n)/(1-x).
|
| Then sum(kx^(k-1), k=1...n) = d/dx sum(x^k, k=1...n) = d/dx
| (x(1-x^n))/(1-x) = (nx^(n+1) - (n+1)x^n + 1)/(1-x)^2
|
| With x=b, n=b-1, the numerator as defined in TFA is n =
| sum(kb^(k-1), k=1...b-1) = ((b-2)b^b + 1)/(1-b)^2 = ((b-2)b^b +
| 1)/(1-b)^2.
|
| And the denominator is:
|
| d = sum((b-k)b^(k-1), k=1..b-1) = sum(b^k, k=1..b-1) -
| sum(kb^(k-1), k=1..b-1) = (b-b^b)/(1-b) - n = (b^b - b^2 + b -
| 1)/(1-b)^2.
|
| Then, n-(b-1) = (b^(b+1) - 2b^b - b^3 + 3b^2 - 3b +2)/(1-b)^2.
|
| And d(b-2) = the same thing.
|
| So n = d(b-2) + b - 1, whence n/d = b-2 + (b-1)/d.
|
| We also see that the dominant term in d will be b^b/(1-b)^2 which
| grows like b^(b-2), which is why the fractional part of n/d is 1
| over that.
|
| I disagree with the author that a script works as well as a
| proof. Scripts are neither constructive nor exhaustive.
| jph00 wrote:
| The author does not say a script works as well as a proof.
| vatsachakrvthy wrote:
| If you want to be lazier, after finding the generating
| functions one can plug into sympy to skip the algebra.
| veganjay wrote:
| Reminds me of an old calculator trick:
|
| Pick an integer between 1 and 9. Multiple it by 9. Take that
| number and multiply it by 12345679. (Skip the 8)
|
| >>> 3 * 9
|
| 27
|
| >>> 12345679 * 27
|
| 333333333
|
| This all works because:
|
| >>> 111111111 / 9
|
| 12345679.0
| _def wrote:
| > The exact ratio is not 14, but it's as close to 14 as a
| standard floating point number can be.
|
| How do you get around limitations like that in science?
| gus_massa wrote:
| You can use Mathematica or Sage that can use any number of
| digits
| https://www.wolframalpha.com/input?i=FEDCBA987654321_16+%2F+...
|
| You can use special libraries for floating point that uses more
| mantisa.
|
| In most sciences, numbers are never integers anyway, so you
| have errors intervals in the numerator and denumerator and you
| get an error interval for the result.
| necovek wrote:
| You can do symbolic calculations carrying precisely defined
| numbers (eg. PI, 3/7...), you can use tools which allow
| arbitrary precision (it's only slower by several orders of
| magnitude so not too bad if you don't need millions of
| calculations: this includes Python if you use Decimal objects),
| or you can use error calculus to decide if the final error is
| acceptable.
| sltkr wrote:
| For rational numbers, Python has a Fraction class in the
| standard library that performs exact integer arithmetic:
| >>> from fractions import Fraction >>> f =
| Fraction(0xFEDCBA987654321, 0x123456789ABCDEF) >>> f%1
| Fraction(1, 5465701947765793) >>> f - f%1
| Fraction(14, 1)
|
| That shows that 0xFEDCBA987654321 / 0x123456789ABCDEF = 14 +
| 1/5465701947765793 exactly. >>>
| math.log(5465701947765793, 2) 52.279328213174445
|
| Shows that the denominator requires 52 bits which is slightly
| more than the number of mantissa bits in a 64-bit floating
| point number, so the result gets rounded to 14.0 due to limited
| precision.
| lutusp wrote:
| > I recently saw someone post [1] that 987654321/123456789 is
| very nearly 8, specifically 8.0000000729.
|
| Okay. Try this (in a Python terminal session):
|
| >>> 111111111 ** 2
|
| 12345678987654321
|
| (typo corrected)
| gus_massa wrote:
| The other replies are good, but let's add another one anyway.
|
| 0.987654321/0.123456789 = (1.11111111-x)/x = 1.11111111/x - 1
| where x = 0.123456789
|
| You can aproximate 1.11111111 by 10/9 and aproximate x =
| 0.123456789 using y = 0.123456789ABCD... =
| 0.123456789(10)(11)(12)(13)... that is a number in base 10 that
| is not written correctly and has digits that are greater than 9.
| I.E. y = sum_i>0 i/10^i
|
| Now you can consider the function f(t) = t + 2 t^2 + 3 t^3 + 4
| t^4 + ... = sum_i>0 i*t^i and y is just y=f(0.1).
|
| And also consider an auxiliary function g(t) = t + t^2 + t^3 +
| t^4 + ... = sum_i>0 1*t^i . A nice property is that g(t)= 1/(1-t)
| when -1<t<1.
|
| The problem with g is that it lacks the coefficients, but that
| can be solved taking the derivative. g'(t) = 1 + 2 t + 3 t^2 + 4
| t^3 + ... Now the coefficients are shifted but it can be solved
| multiplying by t. So f(t)=t*g'(t).
|
| So f(t) = t * (1/(1-t))' = t * (1/(1-t)^2) = t/(1-t)^2
|
| and y = f(0.1) = .1/.9^2 = 10/81
|
| then 0.987654321/0.123456789 ~= (10/9-y)/y = 10/(9y)-1 = 9 - 1 =
| 8
|
| Now add some error bounds using the Taylor method to get the
| difference between x and y, and also a bound for the difference
| between 1.11111111 an 10/9. It shoud take like 15 minutes to get
| all the details right, but I'm too lazy.
|
| (As I said in another comment, all these series have a good
| convergence for |z|<1, so by standards methods of complex
| analysis all the series tricks are correct.)
| jamesmaniscalco wrote:
| This is fun! but not so surprising to me:
|
| 987,654,321 + 123,456,789 = 1,111,111,110
|
| 1,111,111,110 + 123,456,789 = 1,234,567,899 \approx 1,234,567,890
|
| So 987,654,321 + 2 x 123,456,789 \approx 10 x 123,456,789
|
| Thus 987,654,321 / 123,456,789 \approx 8.
|
| If you squint you can see how it would work similarly in other
| bases. Add the 123... equivalent once to get the base-independent
| series of 1's, add a second time to get the base-independent
| 123...0.
| uticus wrote:
| this reminds me of the online encyclopedia of integer sequences
| (https://oeis.org/). anything similar for things like 987654321 /
| 123456789 ?
| uticus wrote:
| ...followup after looking through comments on OP, indeed
| someone else already had the idea to tie in OEIS sequences in
| the comment at
| https://www.johndcook.com/blog/2025/10/26/987654321/#comment...
|
| but i still wonder if there is something like OEIS for
| observations / analysis like this
| madcaptenor wrote:
| That was me. The best I know is to find a related sequence
| and look it up in the OEIS.
| nomilk wrote:
| TIL 0x denotes hexadecimal E.g.
|
| > 0xFEDCBA987654321 / 0x123456789ABCDEF
|
| (somehow I'd seen the denotation for years yet never actually
| known what it was).
| notorandit wrote:
| May I Say 355/113 ?
| kazinator wrote:
| It gets closer when you add digits after the decimal, reflected:
| > 987654321 / 123456789 8.0000000729 >
| 987654321.123456 / 123456789.98765 8.00000000990027
|
| Spooky, just in time for Halloween. (Remember your OCT(31) ==
| DEC(25)).
|
| I still see it getting smaller toward 8 with more digits, but by
| a very small amount: > 987654321.12345678 /
| 123456789.9876543 8.0000000099000026 >
| 987654321.123456789 / 123456789.98765432 8.0000000099000008
|
| Here is a correction which m akes it exactly 8.0:
| > 987654320 / 123456790 8.0
|
| We decrement the top by one, and increment the bottom by one.
|
| In other words ( 987654321 - 1 )
| ----------------- = 8 ( 123456789 + 1 )
| jojobas wrote:
| 12345679 (oh no, we forgot the 8!) - let's multiply by 8 =
| 98765432.
___________________________________________________________________
(page generated 2025-10-30 23:00 UTC)