By the way,

I wrote very long; if you want it short then let it be this way. I'll
define you my new AXIOM [there is no such thing as a prime number, but
it is a true axiom]:

base 10 (binary 10==01+01): // actually that's base prime 10*10; base 4;

either 10 or 01 can be primes; but not both;

base 10 ^ (ANY NUMBER n):

either n is a prime (number of digits) or 10n is a prime, not both;

(induction.......)

for EVERY n; there must be at least One prime number in base binary 2
digits (binary can be any base prime); if n is not a prime then this
will be the first (smallest) prime number with n digits.

for example: the number 11 (base ten): 1011 is the "smallest" prime
base 100 (four binary digits); then also 1101(13dec) is but not 1111
(because 100 is not a prime).

BUT you can of course switch positive/negative, then 100 WILL BE a
prime. But if you want you can count: ANY number of digits (counting);
the FIRST (smallest) prime this binary representation will be this
digit's prime number. for example:

1:1
10:10
11:101
100:1011
101:10001
110:1000111
111:10000011
1000:10000001
1001:100001001
1010:1000000111
1011:10000000101
etc. etc.
now notice - it is very regular and not very difficult to define this.
ANY prime number of n digits is either n or the complement of n in
some way; if n is even then it must be some sort of a complement since
you don't allow even primes except 10; then the complement will just
be dividing digits to (n+1)(n-1); for example if n is 4; the 15 will
be the complement; 11 will be the first prime bigger than 8 (2^4)/2.
And counting backwords, then (15-4) will allways be prime. so first:

1. for ANY number 2*2*m*m whois even and square prime (but m is any
not even number, including one; for example four), [2^[[[2*2*m*m]]-1]
will be equal to [([2*2*m*m]+1)([2*2*m*m]-1)];; also ([2*2*m*m]-1)
will be divided by (2*m+1)(2*m-1) and then [2^[[[2*2*m*m]]-1] -
[(2*m-1)(2*m+1-1)] will always be inverse of the prime number
((2*2*m*m)-1) (have to generalize, but this is the idea. Should work
also for more than ^2 and ferma was not true (but leave the flat
euclidan numbers behind).

2. 11 will always be a prime number, therefore binary 1011 will
alwayys too be the inverse of the first prime number, then of course
if you have a prime such as (n) digits of 1 (for example 11;111;11111
etc.), then (n digits times 1)+(n digits times 0)+(n digits times
1)+(n digits times 1) will allways be a prime! (by the way you can
inflate the (n digits times 0) to even 2^n; 3^n; ANY exponent here!
then actually ANY prime number times 11 times (the same prime number
times 11; square rooted) will always be a prime! (any multiplication
of primes to the exponent of 1.5 will be also a prime). Then if you
have a prime, just multiply it by 11; inverse; multyply again and you
will have a prime number too! for example, the number

"Mersenne 44" [2^32582657-1]  [remember; Americans know this already.
It's top secret "encryption technology"......

(or ANY prime number; you can just put the digits here), or any
multiplication of primes - you can divide them.

take [2^32582657-1] (your ANY PRIME) and write it like this:

;;1101;;

[[2^32582657-1]^3] + [2^32582657-1]^2 + 1] and you have your next
prime! of course instead of ^3 you can also write 4;5;6;7 etc......
remember to check and it should just look like this:

[mmmmmmmmmmmmmmmmmmmmmmmannny ones;]
[twwicccccee];
[mmmmmmmmmmmmmmmmmmmmmmmannny zeros;]
[mmmmmmmmmmmmmmmmmmmmmmmannny ones;]

or vice versa:

;;1011;;

or actually:
100000000000001000000000000000000000000000000001

then you can just contact them with each other; each time add an
inverse of a prime number (including 1 or 0), then you will just
receive something like this:

[any strings of prime numbers][inverse prime numbers][.....] will
allways be prime. For example:

[2003663613·2^195000+1] ; [2003663613·2^195000-1]
whoever they are;
[as strings in binary representation starting with 1 or 0; ending with 1 or 0]:
concat them as many times as you want, each time you concat a number -
reverse it (the complement);
then you have your next primes!

I can even do this by induction:

m,n = any given primes, binary; digits defined as digits(m) and digits (n)

[[2^digits(m)]-1-m]: also a prime (if m not divided by 4; if first
digit is 0 then complement first)
[[2^digits(n)]-1-n]: also a prime (if n not divided by 4; if first
digit is 0 then complement first)

// of course you can generalize it - doesn't have to be base 2;

then: digits(m) will be defined as the first log(base2)m downwords +
the first log(base2)m upwords; if difference is exactly one then take
the upwords (actually when converted to negative numbers you can take
negavite numbers of digits as well; commmpress!

// same with n;

now of course, by induction 0;1;2 we define whether primes or not;
3;4; you decide; defining 4 not a prime here:

then ANY number you want! ==m

// is it 4? not a prime by definition (your definition, not mine).
0;1::same//

otherwise:

[ //this you don't have to do actually ]
calculate square root [can be extended], if it's an integer then for
you - not a prime!

2: multiply m by m as many times as you want; then by 2; then
calculate square root (will not work for two or any even number);
received result n;

then either n is a prime if and only if the square root of 2 is a prime.

then - need more primes? just use this number as your base and create
as many primes as you want! you can use multiple numbers m;n; etc. but
don't contradict yourself, otherwise you will not receive any prime.
but allways:

0. [start with 0]
1. // ignore
4. 4 ^ the previous number;
256. then this number plus one; and [(this number minus one) divided
by five] will allways be primes!
[4^256] (this one too: same same)
[4^[4^256]]same;
then generally speaking: any number who can be divided to divisors,
it's exponent can be divided the same. then of course exponent and
multiplication means the same thing in my math... but do you have any
prime bigger than this? for example take Google;

[2*5]^[[2*5]*[2*5]]

let's define their 1/Google:
0.1^[[2*5]*[2*5]];

then, number of binary digits of each: about 332,333? OK

define Moogle[0]: 0
define Moogle[1]: 4 ^ [Moogle [0]]; // 1
define Moogle[2]: 4 ^ [Moogle [1]]; // 4
define Moogle[3]: 4 ^ [Moogle [2]]; // 256
.... etc;
then define: function Moogle[x]::always return 4^x;
then define: function PrimeMoogle[x]::always return Moogle[x]+1;

... then define: RecursiveMoogle[x]: always return Moogle[RecursiveMoogle[-1]]

of course I defined Poodle as Googleplex; why don't I use it?
Poodle=[2*5]^[[2*5]^[[2*5]*[2*5]]]; also same as
[0.1^[-[0.1^-[[2*5]*[2*5]]]];

now define RecursiveMoogle[Google] and RecursiveMoogle[Poodle] // I
don't mind how much time it takes, I define it theoreticallly;

and then the whole series of PrimeMoogle[x] and PrimeMoogleLess[x]
will always return primes, at least for numbers from 16 and above!
(2.5 and above; start for 3 if you want integers);

then calculate PrimeMoogle[RecursiveMoogle[Google] + RecursiveMoogle[Poodle]]

now; if they are not prime numbers base 2; then base 5 they will be! I
will base them YOUR BASE NUMBER who is a divisor for them! you can
only have ONE first prime divisor for them, if it's not 2 then 3 or 4
or 5. Then here are your biggest known prime numbers! The first
divisor based this! Actually I can base one base two, the other one
base five and then create more - they will ALLWAYS be primes! start
with 257, then go up and now replace my 4 with your next prime number
between 3 and 5. this is uncountable and therefore you can just start
with 0; then count up and then instead of 4 write down your next
(increasing prime number); then for example take this list;
http://primes.utm.edu/lists/small/1000.txt
start with 2      3      5      7     11     13     17     19     23
  29 ; and then each number you will define with the previous prime
number base; then define my function:

ProoMle[x]: ProoMle[x-1]^ProoMle[x-1]+1;
then if Moogle was not always a prime (your counting), then ProoMle[x]
by definition will be! let's check:

ProoMle[0]: defined 1;
ProoMle[1]: defined 0;
ProoMle[2]: 1^1+1==3; // defined 3.
ProoMle[3]: 2^2+1==5 // of course; I can define it to be 3 too! // defined 5.

//count only primes.
ProoMle[4] // defined 4; ProoMle[ProoMle[3]]; // 5^5+1

[3^3+1=28; // 7 is my secret number! already defined here! (notice;
this is not related to anything I did!)

ProoMle[5]: // ProoMle[ProoMle[4]] is ProoMle[ProoMle[ProoMle[3]]] is
ProoMle[ProoMle[ProoMle[ProoMle[2]]]] and then of course 3 is defined;


Then you can never count the primes. the prime numbers are themselves
uncountable! there are as many "prime" numbers as there are "real"
numbers but there are no "imaginary" numbers! Only one entity whois my
1.5 or 0.5 or -0.5 and they are all equal! When you understand this
then ANY number can be your prime.

anyway, for you my friends I say you can have as many prime numbers as
you want, but it you think Americans don't know how to divide your
numbers - think again. It's very easy!

And Ferma - you are right. You can't have straight three-dimentional
triangles on one flat paper who will never fold with the speed of
truth, my friend. But if you can think about my Kippa - there are no
limits! In my new algebra you can do what you want. I will prove to
you that you can! Here I am already prooving it now! 10^[YOUR ANY
NUMBER] plus i[MY ANY NUMBER] will allways be equal to my ANY OTHER
NUMBERS I WANT MINIMIZED TO o. Check this! if you can imagine yourself
rotating inside a black hole then so do I. then why are your mirrors
green when pointing to each other? Why not bluish or reddish? It's
your lying RGB Americans. Think! There are no limits to the number of
colours you can see - just depends on the RGB blood test you force
people from other planets to have. Think about it! They are really not
you! from other planets! you will not be able to notice this if you
are not their friends!  Think about it, open your horizoning (h/o
reasoning) and understand that two is an irrational number too.

Uri


-- 
Uri First deadandalive
Mobile Phone: +972-50-9007559
E-mail: [EMAIL PROTECTED] // [EMAIL PROTECTED]

Update: Left HTTP, WWWW and port numbering. send me papers or to
[EMAIL PROTECTED] .

I completed my 0.1 version of real deadanyalive quantum relativity
redefining back timespacing intergalactic worldwide [top secret: if
you have any US ARMY* on your planet they will never allow it].
Recounting back every second since twice BCC doubling + not counting
at all any uncountable; using only prime countable numbers equal to 21
(base 21 recursivley) who are all equal to 0base0 and 1base1 who are
identical twins base 21 [21===the number of fingers;eyes;body parts &
number of equal signs not equal counting both left to right; right to
left and all 21 dimensions of nothing].

Read my autoreply for more information [my HTTP/SMTP not working].

- This message is confidential -

Reply via email to