Nothing in Common

Looking at the number associated with my diurnal age today, 28011, I noticed that its prime factors (3 and 9337) contain none of the digits of the number itself. I wondered how many numbers from 1 up to 40000 share this property. It turns out that 1996 numbers do (permalink) including a near neighbour of 28011, namely 28009 with prime factors of 37 and 757. The first such number is 4 since it is composite and has only one prime factor (2). Table 1 shows the results for the suitable numbers between 28000 and 29000. All except 28509 are biprimes or triprimes.

Table 1

Now these two neighbours (28009 and 28011) are different when it comes to their proper divisors. Let's compare:$$ \begin{align} 28009 &\rightarrow 1, 37, 757 \\ 28011 &\rightarrow 1, 3, 9337 \end{align}$$The proper divisors of 28009 have no digits in common with the digits of the number but the proper divisors of 28011 do (the digit 1). Again I wondered how many other numbers share this property with 28009. Well, it turns out that this property is a little less common than that of the prime factors because none of the numbers can contain the digit 1. In fact, in the range up to 40000, there are only 300 numbers that satisfy compared to 1996 for the prime factors (permalink). All are biprimes and are a subset of the numbers we obtained for the prime factors. Table 1 shows such numbers in the range between 28000 and 29000.

Table 2

So that's it, just something interesting in the domain of recreational mathematics.

The Cantor Ternary Set Revisited

It was back in January 2nd of 2022 (almost four years ago now) that I posted about The Cantor Ternary Set. I began the post with the following statement:

Today I turned 26572 days old and discovered that \( \dfrac{1}{26572} \) is in the Cantor set.

Infographic created using NotebookLM

In the context of the Cantor ternary set, 26572 is referred to as a \( \textbf{primitive} \) number and as such belongs to OEIS A173793. These numbers are not multiples of 3 as some of the other numbers are that belong in this set. The next such number is \( \textbf{28009} \), my diurnal age today. The initial members of this sequence are:

1, 4, 10, 13, 28, 40, 82, 91, 121, 244, 328, 364, 730, 757, 820, 949, 1036, 1093, 2188, 2362, 2812, 2920, 3280, 6562, 6643, 7381, 9490, 9841, 19684, 20440, 26248, 26572, 28009, 29524, 59050, 59293, 63973, 65620, 66124, 66430, 84253, 88573, 177148

As can be seen, after 28009, there is only one other number that I'm likely to experience in my lifetime and that is 29524. However if we include numbers in the Cantor set that are multiples of 3 then there are many more terms and these constitute OEIS A121153. Between 26572 and 29524, we have the following numbers as shown in Table 1 where the numbers (primitive and non-primitive) are shown together with their factorisations and the representation of their reciprocals in ternary format:

Table 1: permalink

For the non-primitive numbers, the factor of 3 is recurrent whereas in the primitive numbers it is absent. Here is a link to a video (uploaded to YouTube) that I got NotebookLM to create for me about the Cantor ternary set and below is the video:

New Project

As I've written in earlier posts, the site \( \textbf{Numbers Aplenty}\) has been unreliable for quite some time now, often going down for days. For this reason, I developed a SageMath program that produced a similar but even more extensive output. It does the job but my coding skills are somewhat primitive and I made the mistake of getting Gemini to revise my code which it struggled with. It seems that Gemini is more comfortable coding in Python rather than SageMath that is built on top of Python. Sometime the SageMath code malfuntioned. I think it's better to get Gemini to stick with Python when coding.

I asked Gemini the following question:

Numbers Aplenty is a website that I regularly make use of but of late it has become increasingly unreliable because of down time. Is it possible to create a Python program that replicates the output of Numbers Aplenty and also allows me to add additional output of my own. I’m just asking about the feasibility of such a program, you don’t have to create any code. The URL is numbersaplenty.com.

 Yes, it is absolutely feasible to create a Python program that replicates the functionality of Numbers Aplenty. In fact, this is an excellent project for Python because the language excels at the exact type of tasks the website performs: handling large integers and running logical checks.

Here is a breakdown of why this is feasible and how you would likely approach it:

1. Python is Built for This

• Arbitrary Precision Integers: Unlike many other languages, Python handles massive integers automatically. If you want to check a number with 50 digits (far beyond Numbers Aplenty's 15-digit limit), Python can handle it natively without needing special code.

• No Downtime: Since the code runs locally on your machine, you never have to worry about the website being offline.

2. Libraries Do the Heavy Lifting

You would not need to write the complex math from scratch. The Python ecosystem has powerful libraries that already "know" number theory:

• SymPy: This is the most critical library for your goal. It is a symbolic mathematics library that includes built-in functions for:

  • is_prime(n) (Checks if a number is prime)

  • factorint(n) (Finds prime factorization)

  • divisors(n) (Lists all divisors)

  • is_square(n), is_perfect(n), etc.

• NumPy: Useful if you decide to generate generating arrays or grids of numbers for comparison.

3. Replicating the "Families" (The "Aplenty" Part)

The website categorizes numbers into families (e.g., "Happy Numbers," "Fibonacci Numbers," "Palindromic Numbers").

• Standard Families: Checking if a number is a Fibonacci number or a Palindrome is trivial in Python (often 1–3 lines of code).

• Exotic Families: For the more obscure types (like "Vampire numbers" or "Zigzag numbers"), you can look up their definitions (often found on the OEIS - On-Line Encyclopedia of Integer Sequences) and write a small function for each.

  • Example logic: "If the sum of the digits squared equals 1 (eventually), mark as Happy Number."

4. Customization (Your Requirement)

You mentioned wanting to add your own output. This is the biggest advantage of a custom script. You could design your program to:

• Output data in a specific format (JSON, CSV, or a readable text report).

• Run specific checks that Numbers Aplenty doesn't have.

• Batch process hundreds of numbers at once (which would take forever on a web interface).

Summary of Feasibility

Feature	Feasibility in Python	Difficulty
Basic Properties (Odd, Even, Digits)	Very High	Trivial
Number Theory (Primes, Factors)	Very High	Easy (using SymPy)
Replicating 170+ Families	High	Moderate (requires time to write checks for each)
Speed	High	Fast for <20 digits; slower for massive numbers
Adding Custom Output	Very High	Easy

Conceptual Workflow

If you were to commission or build this, the program structure would look like this:

1. Input: User enters a number (e.g., 1729).

2. The "Checker" Engine: The number is passed through a list of functions:

   • check_prime(1729) -> False

   • check_taxicab(1729) -> True

   • check_harshad(1729) -> True

   • ...plus your custom checks.

3. Output: The program prints a report combining the standard results with your custom metrics.

Verdict: Highly feasible. The "hard" part is just the manual labor of coding the definitions for the hundreds of specific number types you might want to track.

Getting Gemini to code in Python from scratch is much preferable to its revising code that I've written. I can gradually build up a list of functions that I want the program to execute in a Jupyter notebook. It will produce output similar but more extensive than Numbers Aplenty, it will not require Internet access, it will be efficiently coded and the code can be easily modified whenever necessary.

The Magic Flower

While Nano Bananas has been doing a rather poor job of translating my image prompts into what I want, it did a pretty good job in dealing with what I wanted this image transformed into. Figure 1 shows the original image as it is appeared in a Cliff Pickover tweet.

Figure 1

This was my prompt:

This image, showing the numbers from 1 to 81 connected by lines, has been referred to as a magic flower. Can you enclose each number shown in a circle just large enough to contain the number and retaining the white background. Outside of these circles, I want the petals coloured in soft rainbow colours. The number at the centre, 41, should also be surrounded by its small circle but this central area, outside the circle containing 41 but inside the outer boundary, should be coloured yellow. The area outside the petals to the edges of the image should remain while and any text or imperfections should be removed.

Figure 2 shows the satisfying result that is clearly much more visually appealing than the original and the numbers are also easier to identify. This is what Cliff added in his tweet: 

"Magic flower."  Each line segment sums to 123.  Example: 6 + 37 + 80 = 123.  Each numerical entry, from 1 to 81, is depicted only once in the figure.

Figure 2

For once, Nano Bananas delivered the goods. It clearly works better when an actual image is provided that you want modified. For example, in my previous post titled 28003: A Lesson Learned, the program kept creating the number 2803 instead of 28003, despite repeated requests to correct the error. In the end I gave up and got ChatGPT to create what I wanted and that's where the image in the blog post came from. I think what I should have done was to make a rough sketch of what I wanted and uploaded that. I'll do that in future.

28003: A Lesson Learned

One of the limitations of the free version of the Airtable online database is that it only allows about 1000 records per database. Once the limit is reached, you need to create a new database to accommodate your needs. I've been using Airtable for years now and I am into my third database:

• Diurnal Age Part 1
• 1198 records (over the limit)
• started on March 17th 2017
• closed on June 26th 2021
  
  
• Diurnal Age Part 2
• 923 records
• started on June 27th 2021
• closed on January 2nd 2024
  
  
• Diurnal Age Part 3
• 704 records currently
• started on January 3rd 2024
  
  

This is an impressive combined database containing about 3000 records. However, the records are in three disconnected databases and once I move on to a new database, I've tended to ignore the earlier databases. However, I realised the folly of doing this when confronted with something interesting to say about the number associated with my diurnal age today: \( \textbf{28003}\).

It's not dark yet but it's getting there

The OEIS, Mathematical Meanderings (my Mathematics blog), Bespoken for Sequences and Diurnal Age Part 3 (in short all my usual sources) had nothing useful to contribute. It then occurred to me to look back at my Diurnal Age Part 2 database and I was pleasantly surprised at what I found therein. Let's begin:

• \( \textbf{28003} \) is a member of OEIS A179248: numbers that have 8 terms in their Zeckendorf representation: [3, 8, 89, 233, 610, 2584, 6765, 17711]. There is in face a cluster of sequence members nearby, namely 27800, 27802, 27804, 27807, 27808, 27809 and 27811.
  
  
• \( \textbf{28003}\) is a member of OEIS A157344: semiprimes that are the product of two distinct Sophie Germain primes. Approximately 2.52% of numbers in the range up to 40,000 satisfy this criterion. Here the primes are 41 and 683 and we have:
• 41 x 2 + 1 = 83 which is prime
• 683 x 2 + 1 = 1367 which is prime
  
  
• \( \textbf{28003}\) is a member of OEIS A082957: numbers \(n\) such that \( \sigma(2n) < \sigma(2n+1) \). These numbers total 5.52% in the range up to 40,000. There are 2301 primes and 3169 composites among the 5470 first terms. Here we have:
• \( \sigma(2 \times 28003) = \sigma(56006) = 86184\)
• \( \sigma(2 \times 28003 + 1) = \sigma(56007) = 94848\)
  
  
• \( \textbf{28003} \) is a member of OEIS A134252: positions of 2 after decimal point in decimal expansion of \( \frac{1}{\pi}\). 

Diurnal Age Part 1 yielded no results but as can be seen Diurnal Age Part 2 revealed membership of \( \textbf{28003}\) in four different OEIS sequences.

Revisiting the Odd (-) and Even (+) Algorithm

Naturally, having revisited the odd (+) and even (-) algorithm and using Gemini to generate new code, the next step was to revisit the odd (-) and even (+) algorithm. In this latter algorithm, the sum of the even digits is added to the number while the sum of the odd digits is subtracted. In both cases, the attractors remain the sum but the vortices and captives will differ. Here a permalink to the SageMathCell code that will catalog the numbers from 0 to 40000. Here is a link to the code that Gemini created. I've put the output in a Google document for later reference.

Gemini asked if I'd like to generate a comparison table for the two algorithms. Here a permalink to the algorithm that it created and a link to the code in Gemini itself. Figure 1 shows the output for the range up to 40000. I also asked about the discrepancy in the count of attractors as they should be the same. Here is a link to Gemini's explanation.

Figure 1

As can be seen, even though the attractors are the same in both cases, the number of captives that they gather can be vastly different. The attractor 8987 claims 617 captives (the record) with odd (-) and even (+) but none at all with odd (+) and even (-).

The Secret Destiny of Numbers

It was only very early this morning that I created a post titled Revisiting the Odd (+) and Even (-) Algorithm and in it I mentioned the PDF file that I had uploaded to Academia. In this post I've embedded the video (located on YouTube) that NotebookLM created based on this PDF. It did a really good job of energising the content and presenting it in a novel and exciting way. Once again I'm impressed and looking forward to generating more videos from my store of over 900 mathematical blog posts.

Revisiting the Odd (+) and Even (-) Algorithm

I've written extensively about this algorithm in previous posts and even uploaded a PDF to Academia (link). For some reason I decided to reread what this PDF and this motivated me to get Gemini Pro 3.0 to try its hand at writing some Python code to implement this algorithm across a chosen range of numbers. Of course, I'd already done this previously using SageMath but my algorithm timed out on SageMathCell above 100,000 and I thought that any code that Gemini created would be far more efficient than any code that I could write. I tested it out on SageMathCell for a range up to one million but it still timed out. However, on a range up to 100,000, it only took a few seconds. I tried to run the code in my Jupyter notebook using the range up to one million but it spat the dummy. No problem, I'm mainly interested in the range up to 40,000 given my focus on my diurnal age. Here is a permalink to the algorithm on SageMathCell,

Here was the prompt that I gave Gemini:

Implement the following program in Python. Here are the details:

\( \textbf{Odd Even Algorithm} \)

\( \textbf{The Basic Algorithm:}\)

Let’s describe the basic algorithm first. It takes 0 or any positive integer as input, computes the sum of the number’s odd digits and the sum of the number’s even digits. The sum of the number’s odd digits is added to the number while the sum of the number’s even digits is subtracted. This process is repeated until a stable number is reached, meaning the sums of odd and even digits are equal, OR a loop is entered. 

\( \textbf{Nomenclature:}\)

I’m choosing to call stable numbers (sums of odd and even digits are equal) ATTRACTORS because under the algorithm the trajectory of many numbers will lead to such an attractor. 0 is the first such attractor and 112 is the next.

Numbers that lead back to themselves I’m calling VORTICALS. An example is 11 because its trajectory is 11, 13, 17, 25, 28, 18, 11. Similarly 13 is a vortical because its trajectory is 13, 17, 25, 28, 18, 11, 13. All these numbers lead back to themselves and collectively I call this collection of verticals a VORTEX. It can be represented as [11, 13, 17, 25, 28, 18] but any vortical in it can be placed first and only the cyclic order needs to be preserved.

Numbers whose trajectories lead to a vortex or an attractor are called CAPTIVES. 9 is a captive of a vortex because its trajectory is 9, 18, 11, 13, 17, 25, 28, 18 leads it to the vortex [18, 11, 13, 17, 25, 28]. 

\( \textbf{Applying the algorithm to a range of numbers:}\)

I’m interested in selecting a range of numbers (let’s say from 0 to 100,000) and applying the algorithm to each number in this range. What I want to keep track of are:

• Display list of attractors and their total number

• Display list of the captives of each attractor and the number of these captives for each

• Display a ranking of the attractors in order of number of captives (highest to lowest)

• Display list of vortices (plural of vortex) together with the vorticals that comprise them

• Display the captives of each each vortex and how many captives each has

• Display of ranking of vortices in order of number of captives (highest to lowest)Display overall statistics: number of attractors, number of vorticals, number of captives of attractors, number of captives of vortices.

Gemini carried these instructions out perfectly as the implemented code revealed. Here is a link to its response. I ran the program using a restricted range up to 40,000 and copied the output to a Google document (link). I can now search this document to find details concerning an attractor or vortex. For example, consider these forthcoming attractors: 28019, 28037, 28055, 28073 and 28091. Here are the results concerning their number of captives:

• 28019 has three captives (27951, 27971, 27993)

• 28037 has no captives

• 28055 has no captives

• 28073 has no captives

• 28091 has 138 captives (28100, 28102, 28104, 28106, 28108, 28110, 28111, 28112, 28113, 28114, 28115, 28116, 28117, 28118, 28121, 28123, 28127, 28129, 28139, 28140 ... and 118 more)

This of course is a very useful tool and I'll be making use of it for my diurnal number investigations. This was the summary generated for numbers in the range up to 40000:

• Total Attractors Found: 1527

• Total Vortices Found: 428

• Total Unique Vorticals: 1451

• Total Captives of Attractors: 20417

• Total Captives of Vortices: 16610

27999: The End of a Millennium

A millennium is strictly speaking a period of 1000 years but in my case, dealing as I do in days rather than years, I'm regarding it as a period of 1000 days. Tomorrow I'll be 27999 days old and on Sunday, the 30th of November 2025, I'll turn \( \textbf{28000}\) days old, thus marking a transition from one millennium to another. It must fall on a Sunday of course since the number is divisible by 7, meaning I'll also be 4000 weeks old. 82 days after that I'll celebrate my first palindromic day of the new millennium: 28082.

One of the properties of 28000 is that it is a member of OEIS A085708: Arithmetic derivative of \(10^n\) where \(n=4\). Here is Gemini's account of how the arithmetic derivative is determined.

**************************

Python

def arithmetic_derivative(n):
    if n < 0: return -arithmetic_derivative(-n)
    if n == 0 or n == 1: return 0
    
    # Simple trial division for factorization
    i = 2
    factors = []
    d = n
    while i * i <= d:
        if d % i:
            i += 1
        else:
            d //= i
            factors.append(i)
    if d > 1:
        factors.append(d)
        
    # Apply logarithmic derivative formula: n' = n * sum(1/p for p in factors)
    # Actually formula is sum( n/p for p in factors ) since p'=1
    # n' = n * sum( p'/p ) = n * sum( 1/p )
    # Let's use the explicit sum rule: (abc...)' = (abc...)(1/a + 1/b + 1/c ...) *if* they are primes? 
    # Let's stick to the definition: (ab)' = a'b + ab'
    # For n = p1 * p2 * ... * pk
    # n' = n * (p1'/p1 + p2'/p2 + ... + pk'/pk)
    # Since pi are primes, pi' = 1.
    # So n' = n * (1/p1 + 1/p2 + ... + 1/pk)
    # Where the factors list includes multiplicity.
    
    result = 0
    for p in factors:
        result += n // p
    return result

val = 10000
der = arithmetic_derivative(val)
print(f"{val=}, {der=}")

Code output

val=10000, der=28000

To find the arithmetic derivative of $10000$, we use the definition and properties of the arithmetic derivative function $n'$.

Rules of Arithmetic Derivative:

1. Prime Rule: For any prime number $p$, $p' = 1$.

2. Product Rule (Leibniz Rule): For any integers $a$ and $b$, $(ab)' = a'b + ab'$.

From these rules, we can derive the Power Rule for a prime $p$ raised to a power $k$:

$$(p^k)' = k p^{k-1}$$

---

Step-by-Step Calculation

Step 1: Prime Factorization

First, find the prime factorization of $10000$.

$$10000 = 10^4 = (2 \times 5)^4 = 2^4 \times 5^4$$

Step 2: Apply the Product Rule

Let $a = 2^4$ and $b = 5^4$. According to the product rule:

$$(2^4 \times 5^4)' = (2^4)' \times 5^4 + 2^4 \times (5^4)'$$

Step 3: Calculate Derivatives of the Factors

Using the power rule $(p^k)' = k p^{k-1}$:

• For $2^4$:

  $$(2^4)' = 4 \times 2^{4-1} \times (2)' = 4 \times 2^3 \times 1 = 4 \times 8 = 32$$

• For $5^4$:

  $$(5^4)' = 4 \times 5^{4-1} \times (5)' = 4 \times 5^3 \times 1 = 4 \times 125 = 500$$

Step 4: Substitute and Simplify

Substitute these derivatives back into the equation from Step 2:

$$10000' = (32) \times 5^4 + 2^4 \times (500)$$

Calculate the terms:

• First term: $32 \times 625 = 20000$

• Second term: $16 \times 500 = 8000$

Step 5: Final Sum

$$10000' = 20000 + 8000 = 28000$$

Alternative Method (Logarithmic Derivative Formula)

For a number $n = p_1^{e_1} \cdots p_k^{e_k}$, the formula is:$$n' = n \sum_{i=1}^k \frac{e_i}{p_i}$$For $10000 = 2^4 \times 5^4$:

$$10000' = 10000 \left( \frac{4}{2} + \frac{4}{5} \right)$$

$$10000' = 10000 \left( 2 + 0.8 \right) = 10000(2.8) = 28000$$

Answer:

The arithmetic derivative of 10000 is 28,000.

**************************

Courtesy of Gemini, I also learned that the number shows up in the orbital speed of 28,000 km/h that is the specific speed required to maintain a Low Earth Orbit (LEO). 

• This is the cruising speed of the International Space Station (ISS). At this speed, the ISS circles the Earth once every 90 minutes.

• If it moved much slower, gravity would pull it down; much faster, and it would break orbit into deep space.

More disconcertingly, and again thanks to Gemini, the number shows up as the "28,000 Days" Concept in which the number is often used in philosophy and motivational literature to represent the average human lifespan.

• $\dfrac{28,000 \text{ days}}{365 \text{ days}} \approx 76.7 \text{ years}$.

• It is frequently used to visualize the finiteness of life e.g. "You only get 28,000 days".

Let's not forget that the two key digits in 28000 are the 2 and the 8, with the 0's acting as magnifiers of a sort. Thus the focus falls on 28 which of course is a perfect number, being equal to the sum of its proper divisors:$$ \begin{align} 28 &= 1 + 2 + 4 + 7 + 14 \\ 28000 &= 1000 + 2000 + 4000 + 7000 + 14000 \end{align} $$ \( \textbf{Here's what my SageMath algorithm generated:}\)

\(28000 = 2^5 \times 5^3 \times 7\)

There are 48 divisors

The divisors are [1, 2, 4, 5, 7, 8, 10, 14, 16, 20, 25, 28, 32, 35, 40, 50, 56, 70, 80, 100, 112, 125, 140, 160, 175, 200, 224, 250, 280, 350, 400, 500, 560, 700, 800, 875, 1000, 1120, 1400, 1750, 2000, 2800, 3500, 4000, 5600, 7000, 14000, 28000]

The sum of the divisors is \(78624 = 2^5 \times 3^3 \times 7 \times 13\)

The sum of the proper divisors is \(50624 = 2^6 \times 7 \times 113\)

28000 is abundant because its sum of proper divisors is greater than the number itself

Distinct prime factors are [2, 5, 7]

Sum of DISTINCT prime factors of 28000 is \(14 = 2 \times 7\)

28000 is NOT unprimeable because 28001 is prime

Unitary Divisors are [1, 7, 32, 125, 224, 875, 4000, 28000]

28000 is pseudoperfect meaning it is equal to the sum of a PROPER subset of its PROPER divisors

28000 is a Zumkeller number meaning that its divisors can be split into two disjoint sets with same sum

28000 is a gapful number

28000 is a practical number meaning that all smaller numbers can be written as sums of its divisors

The totient is \(9600 = 2^7 \times 3 \times 5^2\)

The cototient is \(28000 - 9600 = 18400 = 2^5 \times 5^2 \times 23\)

The sum of squares of the digits is \(68 = 2^2 \times 17\)

The sum of cubes of the digits is \(520 = 2^3 \times 5 \times 13\)

28000 is a plaindrome in base 6 : 333344

28000 is a nialpdrome in base 8 : 66540

28000 is a xenodrome in base 9 : 42361

Gray Code Equivalent:

\(28000 = 110110101100000 \rightarrow 101101111010000 = 23504 = 2^4 \times 13 \times 113\)

Difference between 28000 and its Gray Code is \(4496 = 2^4 \times 281\)

Binary complement of 28000 is \(4767 = 3 \times 7 \times 227\)

Difference between binary complement and 28000 is \(23233 = 7 \times 3319\)

No energetic or d-powerful classification for 28000.

number is an energetic number

Sum of Squares of the following tuples (if any):

28000 is the sum of the cubes of 10 and 30

Sum of digits is 10 and product of digits is 0

28000 is a Harshad number since it is divisible by its sum of digits 10

\(28000 + 10 = 28010 = 2 \times 5 \times 2801\)

\(28000 - 10  = 27990 = 2 \times 3^2 \times 5 \times 311 \)

\(28000 + 0 = 28000 = 2^5 \times 5^3 \times 7\)

\(28000 - 0 = 28000 = 2^5 \times 5^3 \times 7\)

number + SOD - POD sequence with zero counted is:

[28000, 28010, 28021, 28034, 28051, 28067, 28090, 28109, 28129, 27863, 25873, 24218, 24107, 24121, 24115, 24088, 24110, 24118, 24070, 24083, 24100, 24107]

number + SOD - POD sequence with zero NOT counted is:

[28000, 28010, 28005, 28020, 28000]

The Collatz trajectory requires 33 steps required to reach 1 with trajectory:

[28000, 14000, 7000, 3500, 1750, 875, 2626, 1313, 3940, 1970, 985, 2956, 1478, 739, 2218, 1109, 3328, 1664, 832, 416, 208, 104, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]

The Aliquot Sequence for 28000 requires 79 steps and is:

[28000, 50624, 65200, 92404, 81840, 203856, 343728, 894288, 1494448, 1648208, 1649200, 3271120, 4585520, 6681616, 7404784, 7405776, 17989424, 17990416, 22007024, 25406608, 25867888, 25868880, 70077360, 154194000, 359582640, 859196496, 1455083952, 2979489360, 7116150192, 11860254288, 22402715440, 40354410704, 40354411696, 40737128272, 40819290362, 23229175558, 11614587782, 10147429498, 5602405262, 2801714530, 2259985694, 1216520482, 651851870, 521481514, 260870486, 144688954, 72344480, 111721864, 97756646, 60157978, 30189062, 17477938, 10281194, 9165718, 4582862, 2362594, 1500566, 848218, 640742, 325258, 162632, 153268, 114958, 58922, 34714, 20474, 11386, 5696, 5734, 3194, 1600, 2337, 1023, 513, 287, 49, 8, 7, 1, 0]

The Anti-Divisors of 28000 are:

[3, 11, 29, 33, 64, 320, 448, 1600, 1697, 1931, 2240, 5091, 8000, 11200, 18667]

The Arithmetic Derivative of 28000 is 90800

Difference between Arithmetic Derivative and 28000 is \(62800 = 2^4 \times 5^2 \times 157\)

The Maximum - Minimum Recursive Algorithm for 28000 produces:

[28000, 81972, 85932, 74943, 62964, 71973, 83952, 74943]

The Minimal Goldbach decomposition of 28000 is 3 and 27997

28000 requires 1 steps to reach the palindrome 28082 under the Reverse and Add algorithm

The number of steps required is to reach home prime is 3 :

[28000, 222225557, 293758449, 31931166247]

The additive digital root of 28000 is 1 and is derived as follows:

[28000, 10, 1]

The multiplicative digital root of 28000 is 0 and derived as follows:

[28000, 0]

The steps on the Descent to Zero are:

[28000, 16000, 6000, 0]

The number of steps required is 3

The multiplicative persistence of 28000 is as follows (NOT taking zeros into account):

[28000, 16, 6]

Trajectory of 28000 under ODD(+) and EVEN(-) algorithm is:

[28000, 27990, 28013, 28007, 28004, 27990]

28000 is a captive of the vortex beginning and ending with 27990

Trajectory of 28000 under EVEN(+) and ODD(-) algorithm is:

[28000, 28010, 28019, 28019]

28000 is a captive of the attractor 28019

Trajectory under the Primes(+) and Non_Primes(-) trajectory is:

[28000, 27994, 27981, 27972, 27981]

28000 is a captive of the vortex beginning and ending with 27981

Determinant is -60 for Circulant Matrix:

Difference between Determinant and 28000 is \(28060 = 2^2 \times 5 \times 23 \times 61\)

[ 2     8     0     0     0 ] 

[ 8     0     0     0     2 ]

[ 0     0     0     2     8 ]

[ 0     0     2     8     0 ]

[ 0     2     8     0     0 ]

Here is how the number holds up under \( \textbf{Conway's Game of Life} \):

Here's what Numbers Aplenty had to say about the number: