A suggestion for factordb.
 

I would suggest that factordb can detect the number of digits of a number , like PFGW can it with the len-command.

Other suggestions:

Operator "" for [URL="https://en.wikipedia.org/wiki/Division_(mathematics)#Of_integers"]integer division[/URL] (i.e. a\b = floor(a/b)) (FactorDB already has "%" for the [URL="https://en.wikipedia.org/wiki/Modulo_(mathematics)"]modulo operator[/URL])
Operator "n!!" for double factorial of n
Operator "n!!!" for triple factorial of n
Operator "An" for n! - (n-1)! + (n-2)! - ... 1! ([URL="https://oeis.org/A005165"]A005165[/URL](n))
Operator "Kn" for 1! + 2! + 3! + ... + n!
Operator "Bn" for [URL="https://oeis.org/A000110"]Bell[/URL](n)
Operator "En" for [URL="https://oeis.org/A000111"]Euler[/URL](n)
Operator "Cn" for [URL="https://oeis.org/A000108"]Catalan[/URL](n)
Operator "W(m,n)" (Wolstenholme numbers) for the numerator of 1 + 1/(2^m) + 1/(3^m) + ... + 1/(n^m)
Operator "I(m,n)" for the n-th m-Fibonacci number ([URL="https://oeis.org/A000045"]1[/URL], [URL="https://oeis.org/A000129"]2[/URL], [URL="https://oeis.org/A006190"]3[/URL], [URL="https://oeis.org/A001076"]4[/URL], [URL="https://oeis.org/A052918"]5[/URL], [URL="https://oeis.org/A005668"]6[/URL], ...)
Operator "J(m,n)" for the n-th m-step Fibonacci number ([URL="https://oeis.org/A000045"]2[/URL], [URL="https://oeis.org/A000073"]3[/URL], [URL="https://oeis.org/A000078"]4[/URL], [URL="https://oeis.org/A001591"]5[/URL], [URL="https://oeis.org/A001592"]6[/URL], ...)
Operator "P(n)" for the n-th [URL="https://oeis.org/A001608"]Perrin number[/URL]
Operator "Phi(m,n)" for the m-th [URL="http://en.wikipedia.org/wiki/Cyclotomic_polynomial"]cyclotomic polynomial[/URL] at n
Operator "R(m,n)" for the repunit in base m with length n
Operator "S(m,n)" for the [URL="https://oeis.org/A007908"]concatenate the first n integers[/URL] in base m

Also for the first n digits of (pi, e, sqrt(2), golden ratio, ln(2), gamma, ...) in base m

The guy was either trolling or brain farting (FDB displays the length of the number always, as a small index after the number, unless the number is too small).

But some of your suggestions are good (some other are futile, or step over the existent notations).

That would save a lot of typing:

(10^911)\(3^911) is shorter than (10^911-((10^911)%(3^911)))/3^911.
64!! would probably end up as 126886932185884164103433389335161480802865516174545192198801894375214704230400000000000000!, a number that's way too large for the DB. This is due to how the DB parses expressions. A better way of representing it would be n!2 for n!!, n!3 for n!!!, etc.
A109 is much shorter than 109!-108!+107!-...-24+6-2+1.
K109 is much shorter than 109!+108!+107!+...+24+6+2+1.
The Bell, Euler, Catalan, etc. functions would make it easier to add those numbers, if anyone wanted to do so.
Phi(1001,2) is much shorter than M1001/M143*M13/M91*M7*M11/M77.
R(314159,919) would definitely be easier to type than (314159^919-1)/314158
S(36,35) is definitely shorter than (6^72-1261)/1225 (See [URL]http://www.factordb.com/index.php?showid=1100000000518685782&base=36[/URL] for proof of concatenation).

[QUOTE=Stargate38;567141]That would save a lot of typing:

(10^911)\(3^911) is shorter than (10^911-((10^911)%(3^911)))/3^911.
64!! would probably end up as 126886932185884164103433389335161480802865516174545192198801894375214704230400000000000000!, a number that's way too large for the DB. This is due to how the DB parses expressions. A better way of representing it would be n!2 for n!!, n!3 for n!!!, etc.
A109 is much shorter than 109!-108!+107!-...-24+6-2+1.
K109 is much shorter than 109!+108!+107!+...+24+6+2+1.
The Bell, Euler, Catalan, etc. functions would make it easier to add those numbers, if anyone wanted to do so.
Phi(1001,2) is much shorter than M1001/M143*M13/M91*M7*M11/M77.
R(314159,919) would definitely be easier to type than (314159^919-1)/314158
S(36,35) is definitely shorter than (6^72-1261)/1225 (See [URL]http://www.factordb.com/index.php?showid=1100000000518685782&base=36[/URL] for proof of concatenation).[/QUOTE]

I wanted to compute the list of factorization of Phi(n,2) for all 1<=n<=3000 in 5 years ago (the [URL="https://homes.cerias.purdue.edu/~ssw/cun/pmain1020.txt"]Cunningham list[/URL] only lists n<=1300, only [URL="https://stdkmd.net/nrr/repunit/Phin10.txt"]Phi(n,10)[/URL] has such big list), but FactorDB does not support the Phi (cyclotomic polynomial) function

There are also [URL="http://www.asahi-net.or.jp/~KC2H-MSM/mathland/matha1/index.htm"]many types of numbers to factorize[/URL], which cannot be simply typed in factorDB, unlike the formula (a*b^n+c)/d (near-repdigit numbers and quasi-repdigit numbers in base b)

I think that we can use Q(n) for [URL="https://oeis.org/A000041"]part[/URL](n) (since P(n) is already used for Perrin numbers), and use D(n) for [URL="https://oeis.org/A000009"]distinctpart[/URL](n)

Also, currently factorDB only supports Fibonacci numbers I(n) and Lucas numbers L(n), but not support the Fibonacci polynomial (we may use I(m,n) for the n-th Fibonacci polynomial evaluated at m, which is the same as the n-th m-Fibonacci number, e.g. for m=2, this is the n-th Pell number, and for m=3, this is [URL="https://oeis.org/A006190"]A006190[/URL](n)) (I think that we can even use U(P,Q,n) and V(P,Q,n) for the n-th number in [URL="https://en.wikipedia.org/wiki/Lucas_sequence"]Lucas sequences[/URL]), factorDB also not supports tribonacci numbers, tetracci numbers, etc.

[QUOTE=Stargate38;567141]64!! would probably end up as 126886932185884164103433389335161480802865516174545192198801894375214704230400000000000000!, a number that's way too large for the DB.[/QUOTE]
You are very confused about what "double factorial" means. Google it.

64!! = 1130138339199322632554990773529330319360000000
You can get it in pari with "prod(x=1,32,2*x)".

[QUOTE=LaurV;568460][QUOTE=Stargate38;567141]64!! would probably end up as 126886932185884164103433389335161480802865516174545192198801894375214704230400000000000000!, a number that's way too large for the DB.[/QUOTE]You are very confused about what "double factorial" means. Google it.

64!! = 1130138339199322632554990773529330319360000000
You can get it in pari with "prod(x=1,32,2*x)".[/QUOTE]Hmm, I must have forgotten the "double factorial" notation. I know they've been discussed on the Forum, a "multifactorial" generalization also.

For iterated factorials, use parentheses. The factorial of 64! is (64!)!. It's too big for me to want to calculate exactly. I'll content myself with its natural logarithm. Even for the logarithm, I have to bump up the real precision from its default of 38.

[code]? n=64!
%1 = 126886932185884164103433389335161480802865516174545192198801894375214704230400000000000000

? default(realprecision,150)
%2 = 150

? lngamma(n+1)
%3 = 25906276482267964036342506230950052158110911566157592844228132441739611236380625962625795073.4807460213107849024090809743801213248377167429072675193492[/code]

The workers in factordb can only:

* Factoring numbers <70 digits
* Proving probable primes <300 digits
* Checking the smallest number with status unknown <20000 digits

For the number factoring, it can also factor numbers <100 digits but not immediately (I do not know about it, maybe somebody factored these numbers, like that maybe somebody assign the first numbers >=20000 digits to worker to test their (probable)-primality)

However, in 2010, they can prove probable primes <1000 digits (see [URL="https://web.archive.org/web/20100921050309/http://factordb.com/status.php"]https://web.archive.org/web/20100921050309/http://factordb.com/status.php[/URL])

I hope that factordb can:

* Factoring numbers <100 digits
* Proving probable primes <2500 digits
* Checking the smallest number with status unknown <50000 digits

Is this possible?

Go ahead and do it- you know it's users doing those factoring jobs and proving those prps, right?

Become that user. Download composites, factor them, upload the factors. Or run Primo proofs for any prps you wish were proven.

Yes, really. You.

[QUOTE=sweety439;568479]
I hope that factordb can:

* Factoring numbers <100 digits
* Proving probable primes <2500 digits
* Checking the smallest number with status unknown <50000 digits

Is this possible?[/QUOTE]




:clap:

Suggest lower case letters for variables, upper case letters for these functions: (remove: "!!" = double factorial and "##" = product of first n primes)

[CODE]
A n! - (n-1)! + (n-2)! - ... 1! [URL="https://oeis.org/A005165"]A005165[/URL]
B Bell numbers [URL="https://oeis.org/A000110"]A000110[/URL]
C Catalan numbers [URL="https://oeis.org/A000108"]A000108[/URL]
D Distinct partition numbers [URL="https://oeis.org/A000009"]A000009[/URL]
E Euler zigzag numbers [URL="https://oeis.org/A000111"]A000111[/URL]
F Fermat numbers [URL="https://oeis.org/A000215"]A000215[/URL]
G Fubini numbers [URL="https://oeis.org/A000670"]A000670[/URL]
H H(m,n) = n-th m-Fibonacci numbers [URL="https://oeis.org/A000045"]A000045[/URL] [URL="https://oeis.org/A000129"]A000129[/URL] [URL="https://oeis.org/A006190"]A006190[/URL] [URL="https://oeis.org/A001076"]A001076[/URL] ...
I I(m,n) = n-th m-step Fibonacci numbers [URL="https://oeis.org/A000045"]A000045[/URL] [URL="https://oeis.org/A000073"]A000073[/URL] [URL="https://oeis.org/A000078"]A000078[/URL] [URL="https://oeis.org/A001591"]A001591[/URL] ...
J Coefficients of modular function j as power series in q = e^(2 Pi i t) [URL="https://oeis.org/A000521"]A000521[/URL]
K 1! + 2! + 3! + ... + n! [URL="https://oeis.org/A007489"]A007489[/URL]
L L(m,n) = n-th m-Lucas numbers [URL="https://oeis.org/A000032"]A000032[/URL] [URL="https://oeis.org/A002203"]A002203[/URL] [URL="https://oeis.org/A006497"]A006497[/URL] [URL="https://oeis.org/A014448"]A014448[/URL] ...
M Mersenne numbers [URL="https://oeis.org/A000225"]A000225[/URL]
N N(m,n) = n!_(m) = m-factorial of n
O O(m,n) = m-th cyclotomic polynomial evaluated at n
P Partition numbers [URL="https://oeis.org/A000041"]A000041[/URL]
Q Perrin numbers [URL="https://oeis.org/A001608"]A001608[/URL]
R R(m,n) = repunit in base m with length n
S S(m,n) = (Smarandache numbers) the concatenate the first n integers in base m
T Ramanujan's tau function [URL="https://oeis.org/A000594"]A000594[/URL]
U U(n,p,q) = Lucas sequence U_n(p,q)
V V(n,p,q) = Lucas sequence V_n(p,q)
W W(m,n) = (Wolstenholme numbers) numerator of 1 + 1/(2^m) + 1/(3^m) + ... + 1/(n^m)
X X(m,n) = (Smarandache-Wellin numbers) the concatenate the first n primes in base m
Y Y(m,n) = n-th m-step Lucas numbers [URL="https://oeis.org/A000032"]A000032[/URL] [URL="https://oeis.org/A001644"]A001644[/URL] [URL="https://oeis.org/A073817"]A073817[/URL] [URL="https://oeis.org/A074048"]A074048[/URL] ...
Z Motzkin numbers [URL="https://oeis.org/A001006"]A001006[/URL]
! [URL="https://en.wikipedia.org/wiki/Factorial"]Factorial[/URL]
# [URL="https://en.wikipedia.org/wiki/Primorial"]Primorial[/URL]
% [URL="https://en.wikipedia.org/wiki/Modulo_(mathematics)"]Modulo operator[/URL]
\ [URL="https://en.wikipedia.org/wiki/Division_(mathematics)#Of_integers"]Integer division[/URL]
@ n@ = n-th prime
& Narayana's cows sequence [URL="https://oeis.org/A000930"]A000930[/URL]
$ Padovan sequence [URL="https://oeis.org/A000931"]A000931[/URL]
: :(m,n,r,s,...) = LCM(m,n,r,s,...) (least common multiple)
; ;(m,n,r,s,...) = GCD(m,n,r,s,...) (greatest common divisor)
~ ~(abc(de)^(fg)hij,n) = string "abcdedede...dededehij" (with fg de's, this fg is written in base 10) in base n (n must be >=2 and <=36) (the letters in the m of ~(m,n) must be upper case, and the m does not support any functions include +-*/, and if there are any variable in m, the variable is read in base n (except when the variable is in fg, in this case, the variable is still read in base 10))
[/CODE]

Also let factordb can support expressions with negative numbers or noninteger rational numbers as middle result, but the final result is nonnegative integer (e.g. "3-5+7" and "5/10*12"), and then we can type expressions such as (142/999)*(10^(3*n+1)-10)+1, also we can type "3.4*5" to get the result 17, if so, then I also suggest use "|n" for absolute value of n and "?n" for numerator of n and "_n" for floor(n) and "`n" for ceiling(n) and 'n for gaussian_rounding(n) (also: "-n" for addition inverse of n and "/n" for multiplicative inverse of n), if the final result is negative number or noninteger rational number, then factordb return "Error: Negative" or "Error: Not divisible" (Note: For expression m^n, n can be negative number, but n cannot be noninteger number, since the result of m^n will be transcendental number)

the [URL="http://factordb.com/sequences.php"]sequence[/URL] in factordb can add the problem in [URL="https://oeis.org/A195264"]https://oeis.org/A195264[/URL] and [URL="https://oeis.org/A316941"]https://oeis.org/A316941[/URL] (like the home prime problem [URL="https://oeis.org/A037274"]https://oeis.org/A037274[/URL]), also the sequences in [URL="http://www.aliquotes.com/autres_processus_iteratifs.html"]http://www.aliquotes.com/autres_processus_iteratifs.html[/URL] (n --> sigma(n)-n+k for fixed constant k>=-1) (the original Aliquot sequence is n --> sigma(n)-n, i.e. k=0) (the k=-1 case can be called "quasi-Aliquot sequence", like "quasiperfect number" is n=sigma(n)-n-1 and "quasi-amicable pair" is betrothed pair, such as 48 and 75; also the k=1 case can be called "almost Aliquot sequence", like "almost perfect number" is n=sigma(n)-n+1)

Also, the home prime problem and inverse home prime problem can include all bases 2<=b<=36

Also I think that the sequence "Greatest prime factor ^2+1" is silly, as the sequences never terminate at a prime unless the start number is power of 2, also "Greatest prime factor ^2-1", "Greatest prime factor ^3+1", etc.

I use those "Greatest Prime Factor" sequences (mostly GPF^3+1 and GPF^3-1, but I've also run the q^2-1 sequences of all factored RSA numbers) to see if they ever end in a cycle, so we can't get rid of those.

Silvester/Euclid sequence in factordb is repeatedly x^2-x+1 until reaching a prime, I think the polynomial "x^2-x+1" can be generalized to any irreducible polynomial with positive leading coefficient (can be added to factordb, users may enter the polynomial and the start number), e.g. 2*x+1, to get the [URL="https://oeis.org/A050412"]Riesel problem[/URL], or 2*x-1, to get the Sierpinski problem, etc.

Silvester/Euclid sequence (and the sequences which I suggest in the previous post) should not stop when the number is not fully factored (e.g. [URL="http://factordb.com/sequences.php?se=28&aq=20&action=last20&fr=0&to=100"]n=20[/URL]), and I think the sequence in factordb can add the generalization of [URL="https://oeis.org/A000945"]A000945[/URL] and [URL="https://oeis.org/A000946"]A000946[/URL] starting with given number n, e.g. A000945 starting with 12 is 12, 13, 157, 7, 5, 857221, 734826985621, 67, 36178036819339404422591341, 619, 196501174273319, ..., and A000946 starting with 12 is 12, 13, 157, 3499, 85697509, 1025850392947, 4054085938915939, 229936221387049265462828227782402791669, ..., A000945 should stop only when the number has no known prime factor, but A000946 should stop when the number is not fully factored.

Also [URL="https://oeis.org/A005265"]A005265[/URL] and [URL="https://oeis.org/A005266"]A005266[/URL]