Primender Sequence: Numbers that are prime or end in a prime number (of any length)

Primender Sequence

The Primender Sequence is a novel mathematical construct that includes numbers which are prime, or which end with a prime number (of any length). In simpler terms, a number qualifies as a Primender if it:

• Is a prime number itself, or
• Has at least one suffix (ending segment) that is a prime number.

For example:

• 2, 3, 5, 7 → Prime numbers → ✅
• 12 → Ends in 2 (a prime) → ✅
• 12345699 → Ends with suffix 45699 (a prime) → ✅

Properties

• The sequence is infinite.
• It is densely populated, with the maximum delta (difference) between consecutive terms never exceeding 5.
• All prime numbers are included in the Primender sequence.
• The rule-based structure offers a symbolic and computational framework to analyze prime distribution, modular arithmetic, and AI inference patterns.

Applications

This sequence opens avenues for:

• Symbolic reasoning tasks
• Cryptographic keyspace exploration
• Pseudo-random number generation
• Benchmarking interpretable AI systems and LLM inference consistency

Sample Python Implementation

from sympy import isprime

def is_primender(n):
    s = str(n)
    return any(isprime(int(s[i:])) for i in range(len(s)))

# Generate first 1000 Primender numbers
primender_numbers = []
n = 1

while len(primender_numbers) < 1000:
    if is_primender(n):
        primender_numbers.append(n)
    n += 1

print("First 1000 Primender numbers:", primender_numbers)

Sample Set:

The Primender sequence includes numbers that ends with a prime number. In other words, numbers which are primes or have at least one prime suffix. The sequence is infinite, densely populated, and maintains a maximum delta of 5 between consecutive terms. Since all primes are part of this sequence, it offers a novel lens for prime number analysis. 

Some examples:

2, 3, 5, 7, 11, 12, 13, 15, 17, 19, 22, 23, 25, 27, 29, 31, 32, 33, 35, 37, 41, 42, 43, 45, 47, 52, 53, 55, 57, 59, 61, 62, 63, 65, 67, 71, 72, 73, 75, 77, 79, 82, 83.

    A beautiful observation:

   The Primender sequence exhibits a dense numerical structure, with most terms appearing in close proximity. This is largely due to the rule favoring numbers that either are prime or end in digits like 2, 3, 5, or 7—leading to frequent inclusion of nearby integers. The combination of traditional primes and numbers with prime-ending digits (evaluated over the last 2 or 3 digits) creates a consistently growing, non-terminating sequence. As a result, the Primender series is infinite by design. Notably, there are no observed instances where the gap between consecutive terms reaches 6 or more. This absence indicates that the selection mechanism inherently favors closely spaced numbers, and that a difference of 6 exceeds the permissible range defined by the sequence’s construction rules.

The reason no delta (difference between consecutive numbers) exceeds 5 in your sequence of selected numbers is due to the density and overlap of the selection rules. Here's a breakdown of why this happens:

🔁 1. High Frequency of Qualifying Numbers

The selection rules are generous and overlapping:

• Primes are already fairly common, especially in lower ranges.
• Last digit in {2, 3, 5, 7} occurs 4 out of every 10 numbers.
• Last two or three digits being prime adds even more candidates.

This means that within any small window of 5–6 numbers, at least one number is almost always selected.

🔍 2. Overlapping Criteria

Many numbers satisfy multiple rules. For example:

• A number like 113 is a prime, ends in 3, and its last two digits (13) are also prime.
• This overlap increases the density of qualifying numbers.

📏 3. Mathematical Implication

If you imagine scanning every group of 6 consecutive numbers:

• The chance that none of them satisfy any of the rules is extremely low.
• Hence, the maximum gap (delta) between two selected numbers is capped at 5.

📈 4. Empirical Confirmation

In the analysis of:

• 1,000 numbers ✅
• 10,000 numbers ✅
• 1,000,000 numbers ✅

There were no deltas greater than 5, confirming this pattern holds even at large scales.

Mathematical Proof:

To mathematically prove that a delta (gap) of 6 or more cannot occur in your sequence, we can use a proof by contradiction based on the density of the selection rules. Here's a structured theoretical argument:

🧠 Assumption (for contradiction)

Assume there exists a gap of 6 or more between two consecutive selected numbers. That means there is a block of 5 consecutive numbers (say, $n+1,n+2,n+3,n+4,n+5$n+1,n+2,n+3,n+4,n+5) that do not satisfy any of the selection rules.

We will show that this is impossible.

📏 Selection Rules Recap

A number $x$x is selected if any of the following is true:

1. $x$x is prime.
2. $x\mathrm{m}\mathrm{o}\mathrm{d}10\in \{2,3,5,7\}$xmod10∈{2,3,5,7}.
3. $x\mathrm{m}\mathrm{o}\mathrm{d}100$xmod100 is prime.
4. $x\mathrm{m}\mathrm{o}\mathrm{d}1000$xmod1000 is prime.

🔍 Key Observations

1. Last Digit Rule (mod 10)

• In any 10 consecutive numbers, 4 will end in 2, 3, 5, or 7.
• So in any block of 6 numbers, at least 2 or 3 will likely satisfy this rule.

2. Primes Are Dense

• The prime number theorem tells us that the number of primes less than $n$n is approximately $\frac{n}{\ln n}$lnnn​.
• For small $n$n, primes are very frequent. For example, between 1 and 1000, there are 168 primes.
• So in any small interval (like 6 numbers), the chance of no primes is very low.

3. Modular Prime Rules (mod 100, mod 1000)

• These rules increase the density of qualifying numbers even more.
• For example, even if a number is not prime, if its last 2 or 3 digits form a prime, it qualifies.

🔄 Contradiction

If we assume a gap of 6, then none of the 5 numbers in between satisfy any of the rules. But:

• At least 2 of them will end in 2, 3, 5, or 7.
• At least 1 of them is likely to be prime.
• At least 1 of them will have last 2 or 3 digits that are prime.

So at least one of the 5 numbers must be selected, contradicting the assumption of a gap of 6.

✅ Conclusion

Therefore, by contradiction, no delta greater than 5 can occur in the sequence.

Would you like to visualize this with a simulation or plot showing how often each rule is triggered in a small window?

References:

• “Github repository for Primender,” GitHub, 2025. [Online]. Available: https://github.com/Anwar-Faiz/primender. [Accessed: Jun. 09, 2025].
• “Primender Checker,” [Online]. Available: https://tools.anwarjamal.com/Primender
• Mohd Anwar Jamal Faiz, Primender Sequence: A Novel Mathematical Construct for Testing Symbolic Inference and AI Reasoning, 2025

Python's F-String for String Interpolation and Formatting

Interpolating Values and Objects in F-Strings

In latest python, F-strings make the string interpolation process intuitive, quick, and concise. The syntax is similar to what you used with .format(), but it’s less verbose. You only need to start your string literal with a lowercase or uppercase f and then embed your values, objects, or expressions in curly brackets at specific places:

>>> name = "Jane"
>>> age = 25
>>> f"Hello, {name}! You're {age} years old."
'Hello, Jane! You're 25 years old.'

Earlier in Python 3.6 we had the Modulo Operator, % for thsi purpose

The modulo operator (%) was the first tool for string interpolation and formatting in Python and has been in the language since the beginning. Here’s what using this operator looks like in practice:

>>> name = "Jane"
>>> "Hello, %s!" % name
'Hello, Jane!'

Or, see the next example

>>> name = "Jane"
>>> age = 25

>>> "Hello, %s! You're %s years old." % (name, age)
'Hello, Jane! You're 25 years old.'
Or, see the next example for decimal point formatting
>>> "Balance: $%.2f" % 5425.9292
'Balance: $5425.93'

How to fix rearrangement of display screen/spaces on Mac?

Sometimes i get irritated when i see the arrangement of spaces or screen changes when i want to switch between screens on Mac. I always try to ask how do you prevent the macos from occasionally changing or resetting the display arrangement on its own upon waking up or a reboot?

The solution is simple:

Go to Apple > System Preferences > 

Mission Control > un-check "Automatically rearrange spaces" 

and "Displays have separate spaces" 

Cheers :)

If you also want to understand How to fix Mission Control Not working on MAC OS then you can refer my earlier post from 2021 - https://www.w3lc.com/2021/08/how-to-fix-mission-control-not-working.html

Resolving 'Failed to Fetch' Errors in JavaScript

The "TypeError: Failed to fetch" error is a common and often frustrating issue encountered when working with web applications. This error usually arises from problems with the Fetch API and can be caused by a variety of factors.

Common Reasons for "Failed to Fetch" Errors

1. Incorrect or Incomplete URL

   - The URL used in the `fetch()` method might be incorrect or incomplete.

   - Make sure the URL includes the correct protocol (https:// or http://) and that the path is accurate.

2. CORS (Cross-Origin Resource Sharing) Issues

   - The server might not be returning the correct CORS headers. If you're unfamiliar with CORS, you can refer to the MDN documentation.

   - Ensure the server is configured with the appropriate `Access-Control-Allow-*` headers.

3. Incorrect Fetch Configuration

   - There could be errors in the HTTP method or headers passed to the `fetch()` method.

   - Double-check that the configuration, including the URL, HTTP method, and headers, is correct.

4. Browser Extensions

Occasionally, browser extensions can trigger these errors by interfering with API calls or altering the responses.

Steps to Debug

1. Verify the URL

   - Ensure the URL in the `fetch()` method is correct and complete.

   - Check that the protocol, path, and HTTP method are accurate.

2. Inspect the Browser Console

   - The browser console can provide valuable insights into failed API calls.

   - Look for errors related to CORS or other network issues.

3. Check CORS Headers

   - Confirm that the server is sending the correct CORS headers.

   - Use the browser’s Network tab to review the headers of the failed requests.

4. Experiment with Different Configurations

   - Try different `fetch()` configurations to pinpoint the issue.

   - Adjust methods, headers, and URL formats as needed.

5. Consider Using a Proxy

   - If modifying server headers isn’t possible, consider using a proxy to bypass CORS restrictions.

   - Implement proxies with tools like Express or `cors-anywhere` in Node.js.

Enable CORS on a resource using the AWS API Gateway console

 Sometimes while hitting an API gateway you get error suggesting No 'Access-Control-Allow-Origin' header is present on the requested resource. If an opaque response serves your needs, set the request's mode to 'no-cors' to fetch the resource with CORS disabled.

In such a case, sometimes people suggest to set the request mode to 'no-cors' like so:

fetch(url, {

    mode: "no-cors",

    ...

})

But if you're getting CORS issues this is not the solution. If the API endpoint is something that you control, then you have to fix those CORS issue there. If the API endpoint is not something that you control, then you have to proxy your request through a server that does have CORS enabled.

You need to remove the mode: 'no-cors' setting from your request. Setting no-cors mode is exactly the cause of the problem you’re having. A no-cors request makes the response type opaque. The log snippet in the question shows that. Opaque means your frontend JavaScript code can’t see the response body or headers.

With no-cors — JavaScript may not access any properties of the resulting Response

So the effect of setting no-cors mode is essentially to tell browsers, “Don’t let frontend JavaScript code access the response body or headers under any circumstances.”

People sometimes try setting no-cors mode when a response doesn’t include the Access-Control-Allow-Origin response header or else because the request is one that triggers a CORS preflight, and so your browser does an OPTIONS preflight. But using no-cors mode isn’t a solution to those problems. The solution is either to:

1. configure the server to which you’re making the request such that it sends the Access-Control-Allow-Origin response header, and such that it handles OPTIONS requests
2. or set up a CORS proxy using code from https://github.com/Rob--W/cors-anywhere/ or such; see the How to use a CORS proxy to get around “No Access-Control-Allow-Origin header” problems section of the answer at No 'Access-Control-Allow-Origin' header is present on the requested resource—when trying to get data from a REST API 
3. Temporarily you can also use Chrome extension of Enabling CORS. But it is for debugging phase only.

However, it is evident that sometimes you clearly need to Enable CORS on a resource. You can do this using the API Gateway console.

To enable CORS support on a REST API resource

1. Sign in to the API Gateway console at https://console.aws.amazon.com/apigateway

2. Choose an API.

3. Choose a resource under Resources.

4. In the Resource details section, choose Enable CORS.

Next Steps/settings In the Enable CORS box:

• (Optional) If you created a custom gateway response and want to enable CORS support for a response, select a gateway response.
• Select each method to enable CORS support. The OPTION method must have CORS enabled.
• If you enable CORS support for an ANY method, CORS is enabled for all methods.
• In the Access-Control-Allow-Headers input field, enter a static string of a comma-separated list of headers that the client must submit in the actual request of the resource. Use the console-provided header list of 'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token' or specify your own headers.
• Use the console-provided value of '*' as the Access-Control-Allow-Origin header value to allow access requests from all origins, or specify origins to be permitted to access the resource.
• Choose Save.

After this, deploy the API again and see the fun in next call!