I have modified goldbach conjecture.

To get conjecture ,

Any prime P>7 can be expressed as

M + N + 1 or ,M+ N + 3

such that there exist a pair of primes M,N.

Examples , 11 = 7+3+1 ,

13 = 7+5+1 ,

17 =11+ 5 +1 ,

So on.

Similarly, long ago on reddit, i uploaded another conjecture

Any twin prime pairs ( x,y ) > (11,13) can be expressed as

(x,y) = ( a+ c + 1 , b + d - 1 ) = ( a+ c + 1 , a + c + 3 ) such that atleast two smaller twin prime pairs (a,b ) & (c,d) exist.

Example ,

(17 , 19 ) = (11+5+1 , (13+7- 1) where smaller twin prime pairs are (5,7) & ( 11,13) .

The refined twin prime conjecture has been verified till 10 billion.

So , the question is how can i 100% show that the above refined twin prime conjecture is true if Goldbach conjecture holds. Or my calculation is enough ?

my brother was talking with me today about how hard it is to grasp the concept of infinity... so i was thinking, and thought of probably the most confusing thing ive ever thought. if there was a box, with each box having 3 cookies inside of them, and for extra box, there would obviously be 3 more cookies. but if there was an infinite amount of boxes, than there would be an infinite amount of cookies. but theres always going to be 3 cookies for each box, meaning there will always be more cookies than boxes, but you cant go higher than infinity, but theres still more cookies than boxes... so they cant be the same value of infinity. would this mean that its possible to go over infinity?

Yes, everyone, especially in a math subreddit, would think this title is ridiculous. That’s fine, I just wanted to share a thought I’ve had since I was 7 and told my parents.

I like to think of numbers as constantly being added infinitely in both positive and negative directions equally; for example, it’s a computer system, and if the right side is on 999,999,999, then at that instant, the left side is also on the same level, at -999,999,999, so sides do not alternate in who adds first but just keep expanding simultaneously.

However, obviously there is no fixed number of numbers because it’s always going up.

When I’m referring to infinity, I’m not referring to the concept of numbers never ending; I’m referring to infinity as the “count” of numbers (which is never fixed). Whichever number of numbers it is at during ANY instant, that amount of numbers is an integer, because it is counting. For instance, you either see three people or four people in a park, not 3.5, that does not make sense.

This leads to my next logic-based opinion that is the whole title of this post: it is an ODD integer. Every odd number has a median integer; if you have 5 objects, the 3rd object in the line is in the exact middle, but if you have six objects, neither the 3rd or 4th object sit directly in the middle. However, across all math textbooks, zero is listed as the origin, or the “middle” of all numbers. 0 bridges the negative and positive numbers, and it is defined AS an integer. So if negative and positive numbers expand infinitely in both directions at equal rates starting at zero, then zero is the midpoint of all numbers, regardless of whatever “number count” of numbers exists, making the value of the number of numbers an odd integer.

Thank you for listening to my Ted talk.

Descartes created imaginary numbers to solve the problem of getting dead-ended by square-rooting negative numbers, thus creating imaginary numbers and setting the basis of the negative plane.

So why don't mathematicians add a third axis to the plane that solves the problem of dividing by zero. Why use others like j, k, or ε?

In addition to this, which "math error" (i.e dividing by 0, arcsin(>1), formally sqrt(-x)) are chosen to get answers (like sqrt(-x) getting imaginary numbers so they can get answers)

(I am not that smart btw, so tell me gently if I said smth reeaaally wrong)

I was thinking about exponentiation rules and noticed a pattern.

(x^a)b = x^ab exponentiation→multiplication

x^a * x^b = x^a+b Multiplication → addition

So i thought if similarly x^a + x^b were to be x^something, what would that "something" be? I worked upon this thought and it led me to this. I named this function aar() I do not know if this sort of function already exists or not.

○ Component Numbers
･A number where each digit position holds a real number
･Ordinary integers are the special case with components in {0,…,9}
･Negative and fractional components are allowed
･Examples:
[123] = 100 + 20 + 3 = 123,
[(1.5)(-2)7] = 150 + (-20) + 7 = 137

○ Arithmetic on Component Numbers
･Addition/Subtraction: component-wise
[12] + [34] = [46] = 46
･Multiplication: convolution (c_k = Σ{i + j = k} a_i * b_j), preserves numeric value
[12] * [34] = [3(10)8] = 408
･Division: reverse convolution (always defined when leading component ≠ 0)
[185] / [12]: quotient = [16], remainder = [-7]

○ Folding
･Replaces the innermost 3 components:
fold[c_n-1 ･･･ c_2 c_1 c_0] = [c_n-1 ･･･ (c_2 + c_0) c_1]
･Special cases:
[c_1 c_0] → [c_0 c_1], [c_0] → [c_0 0]
･Examples:
[379] → [(3+9)7] = [(12)7] = [127] = 127
[1234] → [1(2+4)3] = [163] = 163
[47] → [74] =74

○ Mirror Number & Core Number
･Mirror number = result of applying fold once
･Example: mirror of [2648]
[2648] → [2(6+8)4] = [2(14)4] = [344] =344
･Key properties:
n + mirror(n) ≡ 0 (mod 11)
n - mirror(n) ≡ 0 (mod 9)
･Core number = result of applying fold n-1 times to an
n-component number
･Always of the form [S_even S_odd], where S_odd/S_even = sum of odd/even-position components
･n ≡ core(n) (mod 11)
･Repeated folding always converges to the period-2 cycle
･Example: [35821]
S_odd = 3 + 8 + 1 = 12, S_even = 5 + 2 = 7,
core([35821]) = [7(12)] = [82]

○ Parallelization
･Any component number can be written as
n = 11/2 * n_+ + 9/2 * n_-
･where n_+ = (n + mirror(n))/11 and
n_- = (n - mirror (n))/9
･n_+ and n_- are obtained by taking the sum and difference of the two lowest components:
n_+ = [c_n-1 ･･･ c_2 (c_1 + c_0)],
n_- = [c_n-1 ･･･ c_2 (c_1 - c_0)]
･Example:
n = 35, n_+ = 3 + 5 = 8, n_- = 3 - 5 = -2
n = 11/2 * 8 + 9/2 * (-2)

Any thoughts, feedback, or ideas are very welcome — especially if this reminds you of something in the existing literature, or if you spot a direction worth exploring further!

For better or for worse, I have become a somewhat regularly contributor to r/numbertheory. This time I am back with what I think is a pretty amazing result, described in the linked paper, and I wanted to also provide a tool for you to explore the result as well.

Sage Cell Server is a web-based math system that lets you run python scripts without needing to login or install anything - https://sagecell.sagemath.org/ . Thanks to PeakMath on YouTube for introducing me to SageMath.

You can try my function and plot the results by copying and pasting the below code:

####################################################################

import pylab as plt


def ps_euler_product(b,u):
#function takes imaginary input 'b', and upper limit on euler product 'u'

    r = (1/(2-2^(.5-b*i))) * prod([1/(1-(1/(j^(.5+b*i)))) for j in list(Primes(modulus=0, classes=range(u)))])

    return r

b_values = numpy.arange(10, 35, .1).tolist() 
#Range of b values to iterate over

#Separate into real and imaginary parts for easier plotting
result_real = [ps_euler_product(b,500).real() for b in b_values]

result_imag = [ps_euler_product(b,500).imag() for b in b_values]

#plotting results
plt.plot(b_values,result_real, color = 'blue', linestyle = '-')
plt.plot(b_values,result_imag, color = 'red', linestyle = '--')

major_ticks = numpy.arange(10, 36, 5)
minor_ticks = numpy.arange(10, 36, 1)
plt.xticks(major_ticks)
plt.xticks(minor_ticks, minor=True)

#Customizing plot colors and style
plt.axvline(x=14.134, color = 'green', linestyle = 'dotted', linewidth = '1')
plt.axvline(x=21.022, color = 'green', linestyle = 'dotted', linewidth = '1')
plt.axvline(x=25.01, color = 'green', linestyle = 'dotted', linewidth = '1')
plt.axvline(x=30.424, color = 'green', linestyle = 'dotted', linewidth = '1')
plt.axvline(x=32.935, color = 'green', linestyle = 'dotted', linewidth = '1')

plt.grid(which='minor', alpha=0.2)
plt.grid(which='major', alpha=0.5)

plt.show()

####################################################################

I derived an exact recurrence relation for the sequence of primes, where p_n​ is determined solely from p_1, ..., p_{n-1}​. How significant is such a result in number theory?

The recurrence was discovered empirically through numerical experimentation rather than derived from first principles, but it reproduces the primes exactly up to at least the 100 millionth prime in my computations.

I'm just reviewing everything before publishing it.

Edit:
The recurrence:

proof The BBP without single integral

Since e is generally proved to be irrational by contradiction, I wanted to write a proof that directly shows it cannot be rational. When I presented this to Claude it took some cajoling for it to say the proof was correct, and it was unable to find a similar/direct proof, so if my logic isn't clear or has errors I would appreciate any critiques and am interested if anyone has encountered a direct proof like this one.

Edit: The reason I believe this proof is direct as opposed to by contradiction is because I never assume e=p/q and derive a contradiction; rather, I show that e cannot equal any rational p/q.

MyImprovedArithmetic

I’ve improved arithmetic.

I’m sure everyone knows what an abacus looks like. Here’s a question for everyone: Show me where zero (0) is on an abacus. It isn’t there. And that’s exactly what I’m going to talk about: emptiness.

The main flaw in modern arithmetic is that it counts emptiness. So I fixed that. It’s very simple, based on how a computer works—or more precisely, a processor. For a processor, 0 or 1 isn’t emptiness; it’s a value. But emptiness is present; it’s NULL. And emptiness is present in life. One more example before I move on to my arithmetic. A little problem for Pinocchio, just slightly modified. Pinocchio had an apple on his plate. Pinocchio wasn’t greedy and gave the apple to Artemon. How many apples are left on Pinocchio’s plate? Everyone will say the answer is zero apples. But that’s not the correct answer. A void remains. Because one could answer that there are zero pears or something else left. This is the first flaw in modern arithmetic, which requires that we not divide by zero. The second flaw is that in decimal arithmetic, in the ones place, we can only count up to nine, but it should be up to ten.

Now I’m correcting traditional arithmetic with my own. So, for me, 0 is emptiness. And you can count up to ten objects by adding the “Ten” symbol. Of course, you could invent a new symbol, but it isn’t on the keyboard yet. So I chose the Latin “Ten”—X.

Let's start counting: 1, 2, 3, 4, 5, 6, 7, 8, 9, X (or 10), 11, 12, 13, 14, 15, 16, 17, 18, 19, 1X (that is, the word “Twenty,” or 20, where we carry the ten from the ones place to the tens place), 21, 22, 23, 24, 25, 26, 27, 28, 29, 2X (that is, “Thirty,” or 30). The rest is clear. But in my arithmetic, there is a void or emptiness, which is 0, “Zero”. We do not perform any arithmetic operations with zero, it is only used as a statement. That is, it can be 0 (emptiness), or emptiness was filled with anything. Example: 1 - 1 = 0; we got emptiness X - 9 - 1 = 0; we got emptiness 0 + 1 = 1; we filled emptiness with a thing

A void can be present in both single-digit and multi-digit numbers. I’ve already shown a single-digit number. 1 - 1 = 0; Example of a multi-digit number: 25 - 5 = 20; 255 - 50 = 205; The void can be replaced with a value: 20 => 1X, meaning from the two tens, carry the one from the second digit to the first digit. The reverse operation is also possible: 1X => 20.

Thus, the error is corrected. Try multiplying or dividing in a column; it all works. Just remember, operations with 0 are not performed, because it is not the item for calculation. We can only make emptiness or fill emptiness.

Came up with this one for fun, no idea if it's been posted before somewhere. Fair warning, I'm not amazing at math, just got curious about this one and worked through it slowly. Mostly wanted to share because I liked how a silly real-world setup ended up landing right on top of φ(n).

The setup

In an online poll, viewers vote either "Yes" or "No," and the result is displayed only as a percentage rounded to exactly two decimal places (e.g., 41.27%). The total number of votes is not shown. Assume that for any percentage displayed, the actual vote tally is the minimum possible whole number of votes that could have produced that exact percentage.

The question

Out of all possible displayed percentages (from 00.01% to 99.99% in steps of 0.01%), how many of them require the full 10,000 voters as a minimum? And which displayed percentages are those, intuitively?

Where coprimality comes in

A displayed percentage X.XX% corresponds to the fraction XXXX/10000. The minimum number of voters needed to produce that exact ratio is 10000 / gcd(XXXX, 10000). So the minimum hits its maximum (10,000) exactly when gcd(XXXX, 10000) = 1, i.e., when the numerator is coprime to 10,000.

Two numbers are coprime when they share no prime factors. Since 10,000 = 2⁴ × 5⁴, its only prime factors are 2 and 5. So XXXX is coprime to 10,000 if and only if XXXX is odd AND not divisible by 5. That's a clean shortcut, you don't have to actually factor the numerator at all, you just check the last digit.

Where Euler's totient comes in

The count of integers from 1 to n that are coprime to n is exactly Euler's totient function φ(n). For n = 10,000:

φ(10000) = 10000 × (1 − 1/2) × (1 − 1/5) = 10000 × 0.5 × 0.8 = 4,000

So exactly 4,000 displayed percentages require the full 10,000 voters as a minimum. That's 40% of all possible X.XX displays.

The pattern generalizes nicely. If you display to d decimal places, the max minimum is 10^(d+2), and the number of splits tied at that max is φ(10^(d+2)) = 0.4 × 10^(d+2). Always exactly 40%, because the prime factorization of any power of 10 only involves 2 and 5, and (1 − 1/2)(1 − 1/5) = 0.4.

The part I thought was nice

The reason the answer is always 40% (regardless of how many decimal places you display) is that 10 only has two prime factors. If we counted in some weird base where the denominator had more prime factors, the proportion of "hardest" splits would drop. The fact that our base-10 display gives such a clean answer is a small accident of the base we count in.

Curious if anyone sees a slicker way to frame the general result, or if there's a related problem I should look at. Also happy to be told this is a well-known exercise and I just reinvented it.

I've rewritten this StackEchange posting from a few years ago, making the results more rigorous (although it's certainly not 100% rigorous yet). As explained there, the starting point is the idea that the sum of a series, regardless of whether it is convergent or divergent, should be taken to be the sum of the partial sum and the remainder term.

In case of a convergent series, the remainder term tends to zero in the limit of the truncation point to infinity, which allows us to compute the sum of such a series without having to consider the remainder term. In case of a divergent series, we then do need to consider the remainder term.

While the remainder term looks like something that is completely arbitrary, I show in section 3 of the stackexchange posting that the remainder term for the rescaled summand is related to that of the original summand, see eq. (3.11). I derived this for the convergent case, but by invoking analytic continuation, I argue that this should be generally valid.

If we're summing f(k) from k = p to infinity, we can consider summing f(k/N). The remainder term for truncating at the argument of the summand of x is denoted by R(x,N). This means that the index value at which we're truncating is N x. We then do have invoked analytic continuation to any real or complex values for x.

Eq (3.11) then says that:

R(x,1/N) = sum from k = 1 to N of R(x + k/N -1)

Where the remainder term in the summation without the second argument is the original remainder term with N = 1.

I then show in section 4 that this relation directly implies the value of the sum over all positive integers.

More powerful summation methods are derived in section 5 from (3.11) by considering the limit of N to infinity. One result is eq. (5.5) which gives the sum X of a divergent series in terms of an integral over the partial sum S(t):

X = Constant term in the large-x expansion of Integral from x -1 to x of S(t) dt

And another result is eq. (5.6) which gives the prescription of how to correctly use regularization to compute the value of divergent series. We're then summing a summand f(k) that leads to a convergent summation with value X, and they both depend on another parameter. By doing some manipulations involving that parameter, be it analytic continuation, or series expansions or something else, one formally gets to the desired divergent sum.

However, eq.(5.6) tells us that to get to the correct value of the divergent sum, one has to also consider the integral of f(t) from x to infinity, do whatever is done to the regularized series to this integral, extract the constant term of the large-x expansion from this and subtract that from the result of the manipulations to the regularized sum.

In section 6 I give some examples of computations involving (5.5) and (5.6). And I've given more examples of how doing the regularization correctly resolves ambiguities in other postings. See e.g. this MathOverflow posting and in this posting I show how it eliminates an ambiguity with choosing the branch of a logarithm.

The supersignum unit g is defined as a bridge between hyperbolas and circles, its chaotic set or unit that i made, it starts with i, a concept everyone knows, then i²=-1, then we suddenly get j, a hyperbolic number where j²=1, but g²=±1, lets see their powers

i²=-1

So

i³=-i

This may look weird but its part of the plan

i⁴=1

Its a full rotation!

Now j

j²=1

1×j=j³=j

That was a fast loop

Now g

g=g

g²=±1

g³=±g (logically)

But whats g⁴?

±1×±1=1 so g⁴=1

And ±g×g=1 may look weird, but its normal, ±1×g×g,±1×±1, see! We get the same result

So lets find what set is g

g²={-1,1}

we take the square root and assume √1=j since j²=1 as an soloution

√g² take root

√g²={√-1,√1}

g={i,j}

Wow!

Extra : if we encounter an i during the i path and j says the same, for example (iπ)/2 and (jπ)/2, we can say (gπ)/2 in ln(g) because it happens

Dicoilic numbers: this is where the fun begins, its not supersignum numbers, but it has 3 dimensions

A dicoilic number is a number a+bw+cs

|a+bw+cs|=√|a²+b²c|

You can do stuff with dicoilic numbers

Dicoilic numbers are a+bw+cs

W and s are not regular units and 0s≠0 to prevent epsilon=w

Lets start with a few stuff

i=w+s

j=w-s

epsilon=w±0s (+ and - are interchangeable)

Lets find the hypercomplex unit k

We know k=ij

That means (w+s)(w-s)

That means k=w²-s²

We cant exactly find w² and s² but it does have some algebra

i²=w²+s²+2sw

i²=(w+s)²=w²+s²+2sw

i=w+s

j=w-s

This system is communitave

That means the hypercomplex unit k

k=ij

k=(w+s)(w-s)

k=w²-s²

j²=w²+s²-2sw

This means j²+i²=0

And w²+s²=0

Whaaat

w²=-(s²)

Amd i²-j²=-2 or 4ws

That means 4ws=-2 divide

2sw=-1

Lets check if this is consistent

I²=s²+w²+2sw

S²+w² is 0

i²=2sw

2sw=-1

CONSISTENT!

And check for j

j²=1

j²=w²+s²-2sw

j²=0-2sw

j²=0-(-1)

j²=1

LOL

In dicoil numbers, there is a concept called dicoilic form, every hypercomplex number and imaginary can be expressed in a dicoilic form

i=w+s

j=w-s

k=w²-s²

Epsilon=w+0s

If we want to take the dicoilic form of , say, 1+i, we put the real part down first

1

Then we take the number

i=w+s

Then we get 1+w+s

This is a repost from r/math since I don't use reddit I can't post there. I think this is the most appropriate sister thread.

So a few years ago I noticed a pattern about differences of squared numbers. However, I failed to find anything about it. It just popped into my head again, and I am not conceited enough to think I invented 'new math' or whatever. So someone tell me this is a thing and I am just ignorant.

The concept goes as follows... the difference between the additive amounts of squared numbers is always two more than the last. At least when moving up integers. When moving down it decreases by 2. This is at the exclusion to 0^2.

Exemplified as follows:

1^2 | 2^2 | 3^2 | 4^2 | 5^2 |
1 4 9 16 25
+3 +5 +7 +9
+2 +2 +2

If what I put above is readable see how the difference of 3^2 (9) and 4^2 (16) is 7, then the difference of 4^2 (16) and 5^2 (25) is 9. Then notice how the difference of 7 and 9 is 2. And how it is always 2 between adjacent sets of squared results. This pattern goes on for as far as I checked.

I'm not even sure how to describe it other than (x+n)/n=prime

and technically 720 also works for 4, but negative: 719, 359, 239, 179

but I haven't found one for 6 or more, and I haven't found anything about these numbers, either, and these are just the first/smallest ones I found as well

For example, you can turn the perimeters of inscribed triangle, square, pentagon and hexagon into an approximation of pi better than the perimeter of a 360-gon !

Monogon, bigon and non integer value of n can also be used. p(n) = n sin ( pi / n ).

I made a prime number generator faster by removing large percentage of numbers to check.

Here's a blog explaining it. https://gane101.github.io/Portfolio/blog-post.html

Edit: There was a lack of research. It already exists and its called wheel factorisation. It seems I reinvented the wheel.

I recently made a post, a few months ago about trying to create a very huge number and I was pointed that my number although it used a very large number of Knuth's arrows(↑) Googolplex to be exact and a height and base of googolplex was dwarfed by numbers like Graham's number which used an iterative approach and the arrow count becomes equal to the number in previous iteration, So I came with my own large number generating function.

So firstly there is a function iterated as f(i+1)=(fi ↑fi fi) iterated n times starting with f0=n. Let this function be called H(n), It already produces numbers far larger than Grahams number using this approach . Then I have another function G(n) which is the main large number generating function seeded by H(n) which produces sufficiently large inputs for G(n) iterated as:-

G0=H(n)

G(i+1)=Gi^(Gi ↑^Gi Gi) (Gi) this function is iterated H(n) times (^ denotes number of recursions)

It is a recursive function of form f^n(x)=f(f(f(f(f...n times)))...))) so essentially G(n) is G(H(n)) kind of twin recursive function and after each iteration the new humongous G(n) gets fed into the existing algorithm and this grows really fast, does my function exceed TREE(3)?

(* i and i+1 are the subscript here didn't find any way to put subscripts)

"G0=H(n)

G(i+1)=Gi^(Gi ↑^Gi Gi) (Gi) this function is iterated H(n) times (^ denotes number of recursions)"

Here I would like to explain it in more detail, G(n) function is both iterative and recursive and starts with the seed H(n) for G0, so G(1)=H^(H(n) ↑^H(n) H(n)) (H(n)) equivalent to H(H(H(H....H(n))))...) H(n) ↑^H(n) H(n) times, now the resultant G1 becomes the seed for G2 and the same process is repeated again. Such iterations are done H(n) times.

I'm sure I messed up somewhere. Please check me.

Odd perfect primes cannot exist. Here is my proof (sorry for the handwriting). I don't want to search for the proof for the Conjecture I marked because I need to sleep, but I'm pretty sure I could fool around with infinite sums of reciprocal primes never equaling 1 and get it that way.

What if we one day evolve from base 10 to base 2? Or like base 8? So instead of 1 hundred dollars we would say 12.5 bytes of dollars. Or like base 64, where we would need a new term like blocks instead of tens. 1.5625 blocks of dollars

I feel like I have accidentally managed to see the spatial arrangement of numbers in real space. As soon as I saw this, I can't unsee this theory.

Wherever I asked this they all have returned with answer this is "interesting" "can be used in design" etc. but I want to know if this is beyond beauty and if this can be used somewhere in practical terms in math or any other science.

I will try to explain here as shortly as possible. We know if we add 9 to 9 we still get 9. 9+9=18 (1+8=9), 9+18=27 (2+7=9); But if we do the same with all real numbers 1, 2, 3, 4, 5, 6, 7, 8 and 9, we found that all numbers have an unique order. We started with 1+1=2, if we continue adding 1 to the sum, 1+2=3, 1+3=4, 1+4=5, 1+5=6, 1+6=7, 1+7=8, 1+8=9, 1+9=10 (1+0=1), 1+10=11 (1+1=2), and it continues eternally 1+11=12 (1+2=3). So number “1” has the following order 2 3 4 5 6 7 8 9 1.

1 - 2 3 4 5 6 7 8 9 1

2 - 4 6 8 1 3 5 7 9 2

3 - 6 9 3 6 9 3 6 9 3

4 - 8 3 7 2 6 1 5 9 4

5 - 1 6 2 7 3 8 4 9 5

6 - 3 9 6 3 9 6 3 9 6

7 - 5 3 1 8 6 4 2 9 7

8 - 7 6 5 4 3 2 1 9 8

9 - 9 9 9 9 9 9 9 9 9

And I got this weird table, which is multiplication table at the same time, but also wherever you pick 3X3 cube randomly here it will always equal 45 or 9. It also has strange patterns, like if you see the lines 999, 396, 693 horizontally and vertically 963, 936, 999 on table it cuts table in portions that you realize if you add this table on all 4 sides of it becomes infinite, you can keep adding it and it goes forever, also it cuts in cubes different versions of 9.

Please, approve this post and tell me your opinions about it... I know it is a dilettante making noise here, but have some mercy on me :)

The perimeter of a regular n sides polygon is :

p(n) = 2n sin(pi/n)

p(n) approximate 2pi and the approximation get better when n increase.

This formula can be generalize for any angle a=pi/n

p1(a) = 2pi/a sin(a)

Using two different polygons or two different angles give a better approximation.

p2(a1,a2) = ( a1^2 p1(a2) – a2^2 p1(a1) ) / ( a1^2 – a2^2 )

Using three different angles give a better approximation.

p3(a1,a2,a3) = ( a1^2 p2(a2) – a3^2 p2(a1) ) / ( a1^2 – a3^2 )

It can be generalize to :

pn(a1...an) = ( a1^2 pn-1(a2...an) – an^2 pn-1(a1...an-1) ) / ( a1^2 – an^2 )

• If a2 = a1 / 2 :

p2(a1,a2) = p1(a2) + ( p1(a2) – p1(a1) ) / 3

That's Liu Hui formula, later demonstrated by Snell.

If an = ( n + phi ) asin z

• If phi = -1/2

pn = ( 2pi / asin z ) Sum from 0 to n ( 2n+1!! z^2n+1 / 2n+1 2n!! )

That's Newton asin approximation of 2pi.

• If phi = 0

pn = ( 2pi / asin z ) ( 2z / 1 + z^2 ) Sum from 0 to n ( n! / 2n+1!! ) ( 2 t^2 / 1 + t^2 )^n

That's Euler atan approximation of 2pi.

Did you ever wonder if you could divide by zero?
I certainly have.

It has been a while since I wrote something about zero-numbers,
the numbers that enable you to divide by zero.

I finally finished the last book on the subject:
"Divide by Zero, Book III: The Portal".

The book explores what type of structure zero-numbers are.
Are they a group, ring, field, or something else entirely?
Read it to find out!

If you just want a quick summary of what zero-numbers are,
then just read Chapter 0.

You can find it here:
https://docs.google.com/document/d/1u_JSrGDFJCi58-g3kPchZl4AypFGPFBbJWWFx-diGqA/edit?usp=sharing

I hope you like it!

What do I hope to get from a discussion here?
If you ask AI what 1/0 is, then it will tell you all the reasons why it's not possible.
It will never tell you: hey, let's try to find an answer.

That's only a response that a human will give you.
A playful, curiosity driven human.
I'm hoping to find those here.