The Dividing Line
The 0.999… = 1.000… Debate
I came across a math forum debate where a portion of users had stated that 0.999 = 1.000.
I looked at 1/3 and the differences between the graphical representation and the decimal equivalent of fractions. Fractions in my mind are nothing more than graphical shorthand denoting the need for further calculations that give rise to the actual decimal answers.
Whereas 1/3 + 1/3 + 1/3 = 1/1 = 1.0 and 0.333 + 0.333 + 0.333 = 0.999 /= 1.000. Fractions are clearly a concept and not a defined value of themselves.
Simply put, there is no way to split an even amount amongst odd numbers. We effectively divide odd numbers by forcing an even split. Lazily fractions accomplish this through shorthand. As fractions step away from even division the number of digits to compute increases to infinity. To save time we truncate or round these values up to something more manageable. 1/3 * 3 is an ideal that is easier to look at and compute than;
0.33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333… (to infinity) * 3
Just as I tired of holding down the 3 key, any human would tire of computing infinity so we use shorthand, symbology, to quickly show complex ideals. However, when gaining ease you lose what makes things complex. Today we see 1/3 * 3 = 1 when doing the math will lead to 0.999… . One view recognizes 1/3 is an ideal where you split 1 item 3 ways equally. The other view looks at the math of a fraction and sees not the intent but the actual quantity of 3 parts out of 10. One is an ideal of ease, the other a computation of record. In my mind, the placement of a decimal should not break an equivalency; 3 parts of 1.0 should yield the same answers as 3 parts of 10. Do we argue that 10/3 = 3 with a remainder of 1? Why argue that 1.0/3 has no remainder?
Adding the decimal results of the fractions shows that we have lost a thin line of .0001. At an infinite amount of precision this loss is equal to the smallest possible number / the smallest increment of change; 0.0001. I also call this number the trigger number as I imagine an infinite number of 9s passing the 1 upwards and leaving behind a trail of infinite zeros.
In this exploration I happened upon a curiosity. I focused on the squares of numbers as 1^2 = 1 and 0.9^2 = 0.81. Given that this is just 2 digits of accuracy I began to wonder exactly how unequal 0.999^2 and 1.000^2 are. I began to square higher digits of
A few Caveats;
Where N = 0, undefined as the request is 0 digits of accuracy.
Where N = 1, and the resultant subscript is = 0, this denotes the absence of the proceeding digit.
Where N = approaches infinity, At this point several ( to infinite ) digits began to be pushed out side of the realms of our defined infinity. Truncating the value at our defined infinity will allow for 0.9999.
A tool; (XN-N)2
I use the following to denote this math; (XN-N)2
X = 9 (XN-N)2
; N = # of digits of
precision (subscript) {See Chunk
Compression}
N = 0 to Infinity -N=
# of decimal places (superscript)
Where N = 4, (94-4)2 = (0.9999) 2 = 9N-180N-11-2N =94-1804-11-2*4 = 938031-8 = 0.99980001
Where N = Infinity the error rate becomes 0.0001, At infinity + 1 the error rate is 0.0000 as the one slips out of our defined infinity ( as does the request of infinity + 1 digits of accuracy ).
I came to express the smallest possible number at all levels of decimal accuracy to be: Z = 1-X-Nwhere X = 0.9 and -N= the number decimal precision from 0 to infinity. Whereas @ infinity Z = 0.0001 (0.9999 + 0.0001 = 1.0000). I shorthand this to TDL-2N so that 0.9 N2 + Err N2 + + TDL-2N= 1.0000. (-2N) Denotes the decimals placement where N = the supplied decimal precision.
So now that we know every answer for the squares of decimal 9 we can begin to show the error in calculations between 1.0N2 and 0.9N2 (Where N = Number of decimal precision). The inverse of 9N-180N-11-2N is 0N-119N-18-2N, I shorthand this to Err so that 0.9 N2 + Err N2 = 0.9-2N. ( -2N ) Denotes the decimals placement where N = the supplied decimal precision.
Thinking outside the box (or infinity)
I enjoy infinities and have long thought of infinities as the same as any other number set or collection. I can easily have an infinite series of numbers in my mind, I’ll make them yellow. Now I can add another distinguishable set of infinite numbers that are blue. Next, I can put an infinite set of numbers on a plate. I can do each of these colors and objects an infinite number of variations. After I have done all that I can Imagine I would have an infinite amount of infinite permutations of an infinite amount collections. Then we could add the next person’s concept of infinity until we have an infinite number of people defining an infinite number of
I began to focus on dividing numbers utilizing odd numbers.
I noticed other opportunities for the use of Chunk Compression, for example the
fraction 1/7. This number is a repeating decimal equal to
0. 142857142857142857142857 which is more tidily
displayed as 0.1428574. Also, Note that 0.142857 * 7 = 0.999999,
this too is missing TDL to fully reach 1.0000….
In my mind, it is very clear and demonstrable as to why 0.999 /= 1.000. It seems that the majority of dissenters proclaim that there is no possible number between 0.9999 and 1.0000 and this tangency is the key to their claims. I reason that 0.9999 is a far different to 1.0000 as is 0.9999 from 0.9998. To suggest that mere tangency is the same as equivalency collapses all numbers to equate the same. (ie; If 0.9999 is tangent and equal to 1.0000, then the 2 equal numbers can be expressed as a number set X {x=1.0000 & 0.9999} so now we can add the two new tangent and equal numbers and our number set X grows to include {0.9998, 0.9999, 1.0000, 1.0001}, this exposes two new tangent and equal numbers. It makes no sense to me to say tangency is synonymous with equivalency.
Other Formula;
All
solutions to 0.9 * 7.9 at all decimal precisions.
(AKA why tangent is never synonymous to equal)
subscript N = # of repeating digits.
X = 1.0 | 0.9N ( XN*YN )
= Y-1 + [(Y+1)N-110N-11]-2N
Y = 8.0 | 7.9N ( 0.9N*7.9N ) = 8-1 + [(8+1)N-110N-11]-2N
N = 0 to Infinity
@ N = 1 (0.9*7.9)
= 7 + [11]-2
= 7 + .11
@ N = 2 (0.99*7.99) = 7 + [9101]-4 = 7 + .9101
@ N = 3 (0.999*7.999) = 7 + [991001]-6 = 7 + .991001
Inverse = 0.0N-1899N-1
A few Caveats;
Where N = 0, undefined as the request
is 0 digits of accuracy.
Where N = 1, and the resultant subscript is = 0,
This denotes the absence of the proceeding digit.
Where N = Infinity, the answer will be 7.9991.
The missing piece is the Inverse = 0.0N-1899N-1
This is due to 8 inputs missing 0.0N-11 parts.
Chunk Compression
Utilizing Chunk Compression, the below number can be expressed more efficiently. 0.33318544444444444472121212121212121212121212633333333333377217217217217217217218
Using CC on the above leaves 24 digits used to display the original 80 digits, 70% compression.
0.331854127211226312772178.
Simply underlining the digits to repeat will allow for increased efficiency.
Some numbers such as PI would find little to no benefit to chunk compression, however, as the efficiency is directly correlated to the number of repetitive digits in a string of digits.
I soon began to look at multiplication as interference patterns from modifying mathematical patterns by the process set forth by symbology. The next pattern I stumbled upon caused me to think of the mechanics of algorithmic growth when processing even number squares of N precision.
Tri- Patterns (3s)
You can see below that a few numbers have easy solutions. Note that there is no similar solution for X = 1.
Where X = 1.5, (XN-N)2 = 0N-127N-125-2N
Where X = 3, (XN-N)2 = 1N-108N-19-2N
Where X = 6, (XN-N)2 = 4N-135N-16-2N
Where X = 9, (XN-N)2 = 9N-180N-11-2N
Where X = 12, (XN-N)2 = 1.7N-142N-14-2N
Where X = 15, (XN-N)2 = 2.7N-122N-15-2N
Where X = 18, (XN-N)2 = 3.9N-120N-14-2N
Where X = 21, (XN-N)2
= 5.4N-1335N-161-2N
Only
valid for N > 1
Where X = 24, (XN-N)2
= 7.1N-109688N-196-2N
Only
valid for N > 2
Where X = 27, (XN-N)2
= 8.9N-1820N-109-2N
Only
valid for N > 1
Where X = 33, (XN-N)2
= 13.4N-1175N-169-2N
Only
valid for N > 1
The special case of multiple digit inputs.
Looking at 2 or more digits for the value of X presents an interesting case as the usual single digit values produce squares from a string of 1 unique digit. (ie 0.5, 0.55, 0.555) whereas multiple digits produce an patterned expansion (ie 1.8, 1.98, 1.998, 1.9998).
Squares Where X = 1, (XN-N)2
The squares of 1 show a similar growth pattern as do the squares of even numbers. These patterns have algorithmic growth. Let’s look at the mechanics observed at the growth between N = 9 & N = 10
- @ N = 1 => 0.01
- @ N = 2 => 0.0121
- @ N = 3 => 0.012321
- @ N = 4 => 0.01234321
- @ N = 5 => 0.0123454321
- @ N = 9 => 0.012345678987654321
- @ N = 10 => 0.01234567900987654321
- @ N = 11 => 0.0123456790120987654321
We can see an early pattern emerge in the first 5 iterations. 01, 0121, 012321, etc. There appears to be a shifted symmetry as there is no accountable trailing 0 to complete the symmetry. The interesting portion lies within the mechanics of growth where the next number to be added to this growing sequence is 10. For clarity, we will add the trailing 0 and split the digits along the line of symmetry.
@ N = 7 => 0.0123456 7 6543210.0
@ N = 8 => 0.01234567 8 76543210.0
@ N = 9 => 0.012345678 9 876543210.0
@ N = 10 => 0.0123456790 0 9876543210.0
@ N = 11 => 0.01234567901 2 09876543210.0
@ N = 12 => 0.012345679012 3 209876543210.0
@ N = 13 => 0.0123456790123 4 3209876543210.0
At N = 9 the central digit is 9. The next iteration will have us add 1 to the proceeding central digit creating the number 10, a two digit number.
This will require the left symmetry to be modified to accept the 1 in the tens place that overlaps the left symmetry’s ones place thus breaking the overall symmetry of the expansion pattern.
At N = 10 the rightmost digit of the left symmetry is expected to be 9 however as it accepts the 1 from the central digit, the digit also becomes 10 and again passes the 1 in the tens location to the next left digit. This leaves 790 instead of the expected 789.
At N = 11 the central digit is 2 where I initially expected a 1. I guess that this is an artifact of an attempt to maintain symmetry and there are an extra +1 where the 2 is located.
Also of note is that the proceeding iteration’s central digit is the digit to be added to the current iteration’s innermost digits. This pattern also is interrupted by the advent of the 2 digits in the central number. It appears at first glance that the central number has a range of 1 to 11. At the second 3 in the central number (N =
We can now begin to see the overall patterns emerging. The leftmost pattern is 012345679, the central pattern is 098765432, the rightmost pattern is 0987654321. As the digits of accuracy increases, the two leftmost patterns will continue to reproduce themselves while the rightmost pattern completes only one time. I refer to these patterns as “Chains” that I can also use “Chunk Compression” on to help reduce the length of the displayed digits and also as a method of navigating the length of the numbers.
N(29) = 0.012345679301 2 098765432209876543211
N(30) = 0.0123456793012 3 2098765432209876543211
N(31) = 0.01234567930123 4 32098765432209876543211
N(32) = 0.012345679301234 5 432098765432209876543211
N(33) = 0.0123456793012345 6 5432098765432209876543211
N(100) = 0.01234567911 0 0987654321009876543211
N(101) = 0.0123456791101 2 0987654321009876543211
N(102) = 0.01234567911012 3 20987654321009876543211
The Central Number & Summation
The central number seems to be predictable by the summation of the digits of N. @ N = 30 the central number = 3 which correlates to 30 => 3+0 = 3 and @ N = 29 the central number = 2 which correlates to 29 => 2+9 = 11 => 1+1 = 2. Since 11 is a 2 digit number I utilized multiple iterations of summation to produce a single digit. Please note that a summation of 10 is automatically equated to 0 as is the case @ N = 10, N = 28, N = 37, N = 46, N = 64, N = 118, etc.
The central number also seems to correlate with the number of digits to the left that are not a part of a completed chain. The right digit count will always be the central number – 2.
The Symmetries
The symmetries will always have an equal # of subscripts when comparing the left symmetry and the right symmetries.
Please keep in mind for the symmetry to work an additional 0.0 is appended to the value giving the right side 2 extra digits thus keeping the central number at the number’s core.
N(36) = 0.0123456793012345678 9 8765432098765432209876543211
N(37) = 0.0123456794 0 098765432309876543211
N(38) = 0.012345679401 2 098765432309876543211
N(39) = 0.0123456794012 3 2098765432309876543211
Navigating within the numbers
Using the information above we can now begin to create a system of navigation. For example, @ N 39 we know; (0.111111111111111111111111111111111111111)2
- There are 39*2 digits, a 78 digit answer.
- The first chain (Chain A) and thus first 36 digits and the pattern.
- The middle chain (Chain B) has 1 less iteration than Chain A and thus we know 27 additional digits and their pattern.
- The last ten digits will always be the same 10 digits and the same pattern (Chain C).
- The central number @ N = 39 equals 3+9=> 12 ==> 1+2 => 3
- The left number is 3 digits long and the right number is 3 – 2 = 1 digit long
- The left number is the first 3 digits of Chain A = 012
- The right number is the last 1 digit of Chain B = 2
Utilizing this information it is easy to say N39.37 = 0 as this is the 37th digit @ N = 39