Topic: [XPM] [ANN] Primecoin Release - First Scientific Computing Cryptocurrency - page 32. (Read 688812 times)

can somebody look at this article:
http://www.wired.com/wiredscience/2013/11/prime/all/

it means that there is no large gap between large prime numbers ? and the prime numbers go to infinity? so this is very good news for primecoin? the PoW could be more safe then SHA256, right?

Ok you're right about the 130,001 I didnt really think that through.

Sadly I will not indulge government coin-destruction scenarios / conspiracy theories, they're best left to the Newbies subforum.

Just nitpicking, but... to perform a 51% attack against an existing network of 130,000 CPUs you'll have to buy at least 130,001 CPUs.

Oh, and I think this is absolutely realistic for a determined attacker, like some government that wants to destroy cryptocoins.

today i mined my first block of primecoin (solo mining)
awsome feeling - I've mined it for last 3weeks

Does anyone have a precompiled copy of either Xolominer, Primeminer (or some other miner) for Mac OS X? Its a nightmare to get it up and running and i would love to get my hackintosh up and mining XPM

Big Rise in Price today! Like the Terminator haha!

See the video: http://www.youtube.com/watch?v=xNErA7yQwds

xolokram of beeeeer.org claimed that he had found a botnet and refused to payout to the address http://www.peercointalk.org/index.php?topic=485.msg5740#msg5740

Good news, Primecoin price reached 1 USD.

I disagree. I have previously (a few months back) calculated from data on mikaelh's stats webpage that at that time the primecoin network was equivalent to ~130,000 intel Q9550 CPUs (at that time, that was my fastest CPU, and used for comparison).

Now I don't believe that hiring VPS or buying 130,000 x 0.51 = 66300 quad core CPUs is either "cheap" or "realistic" for that matter.

The other thing you might suggest is botnets, except:

i) There is no real evidence that there are even any XPM botnets in the wild
ii) This scenario assumes the botnet operator could collectively control the infected machines to collaboratively work together to perform a 51% attack on the network, when in reality this is unlikely since the goal of a botnet would be to make money as quickly as possible, not to attack and deteriorate a coin

There are probably only a few hundred academics and engineers on the planet who have a complete grasp of the quantum computers / processors currently built. Let alone to comment on the implementation of them for finding primes, let alone primecoin specifically.

Just like any other newly developed high-cost scientific instrument, quantum computers (read D-Wave) will only ever run for academic, military, and government purposes and simulations until their cost falls by orders of magnitude.

There is never going to be a underground group who makes a quantum computer in their basement and starts cracking away at primecoin. Even if that was possible, I can think of a LONG list of things that would make them more wealth before primecoin ever would.

Keep in mind that with any cryptocoin, if there was suddenly an exponential rise in the difficulty from an unknown and unexpected source, then the miners, traders, and investors in that coin would lose confidence over night, it would crash and die in days, and finally be abandoned completely*. This discussion used to come up almost every day here a long time go - before ASIC were around to secure bitcoin - when people were claiming it was a genuine concern that 'some organization / government' would buy datacenters full of GPU just to end bitcoin: there is next to no logic behind it.

Note*: A notable exception / alternative scenario is where some kind of attack takes place but no one cashes out the coins. A good example specifically is the hundreds of thousands or millions of terracoins that were obtained with months of exploitation of the network that have not yet been cashed out. When/if that does happen the coin will most likely die.

It seems that quantum computers would be good at finding prime numbers too, though:  http://www.newscientist.com/article/dn23289-quantum-computer-could-solve-prime-number-mystery.html

2 very important questions and anserw by Sunny:

questions:
1. from wikipedia http://en.wikipedia.org/wiki/Primecoin "To meet this requirement, the size of the prime numbers in the system cannot be too large". What could happen when we cross 10 or 100 mln block and the prime numbers start to be large?
2. "If the coin is successful and prime number theorists can use the results to find an equation to predict prime #s, it would essentially break the coin's PoW." -> is it possible?

answers:
1) Prime size would stay same. The prime chains aren't going to be exhausted. There are countless prime numbers, basically as abundant as numbers themselves. Remember there is a prime every couple of hundred numbers at the scale primecoin miners work. So for a 256 bit number there are more than 2^248 primes, so that's not far from 2^256 which is the total numbers at 256 bit.
2) Prime number theory is an extreme hard discipline, with hundreds of years of history. So it's not very likely to happen overnight. I'd say even if you throw trillions dollars at such research it's not going to produce that type of results on demand. Also, even if you find a super efficient mining algorithm doesn't mean you 'break' the proof-of-work system, it just means you have an advantage over the public before you publish the findings. The difficulty can scale enormously in primecoin's design.
--------

its quite optimistic. those 2 questions were my major doubts about prime. now i think that this model of PoW could be more safe then SHA256, which could have some problem when quantum computer appear on the market.

Just curious... was this a valid private key? I imported it successfully but its balance is zero

can you send them to me?  ~ i believe in /\XPM !!!

It's the same guy spamming the btc-e trollbox all day with the "benefits" of XPM.

A message to bagholders : be patient, also rome was not built in a day, also XPM is so young.

This guy says the coin is going to die, lets just pack our bags now and go home guys. It's all over.

Here have my coins

65HaqogaC8w8RRoL5iYnTjHpajLFK5LPKE9cRjKbkaHgrKB3bWo

Yes, that was to be expected. Forcing the hash to be a prime number makes the proof-of-work reusability infeasible. Also, searching for a block header hash that is divisible by a large primorial no longer applies. However, this does not prevent someone who is mathematically gifted to go after double SHA-256 and look for a divisibility weakness against existing prime chain origins. That is what I would do if I were interested in the financial gains from mining.

For the (Nvidia GPU, sm_20 and above) modular exponentiation, I am using the square-and-multiply (binary exponentiation) method. You cannot eliminate branching but it can be drastically reduced. The penalty for branching in this case is a 2x reduction in performance, but you can fix the exponent to reduce the overall effects of warp divergence. You can see from the partial code below (Montgomery Reduction for multiplying two 320-bit numbers) that it is almost branch free. And a vast amount of work went into memory management instead.

So how do I fix the exponent, it is easy to do on a chain-by-chain basis, for example:
We have the following chain, 19, 37, 73
Take the largest exponent which is (73-1) = 72
2^72 modulo 19 = 1
2^72 modulo 37 = 1
2^72 modulo 73 = 1

I also have another trick that I run on the CPU from left-to-right on my virtual array to deal with the partial remainders, because the exponent is fixed for the entire array, is has to do with the modular square roots of prime numbers. It is much more complicated but is runs very fast on the CPU and almost always returns the correct result for prime numbers, but not for composite numbers.

Even with all of this work, the Nvidia GTX 580 is still only 6.86x faster than the AMD Phenom II X6 1100T because of the added overhead to reduce warp divergence. Plus I am also working in the Montgomery domain from end-to-end.

__device__ void
nvidia_gfn_multiply(nvidia_word_t *rop, const int rop_interleaved,
               const nvidia_word_t *op1, const int op1_interleaved,
               const nvidia_word_t *op2, const int op2_interleaved,
               nvidia_word_t nvidia_gfn_n)
{
   nvidia_gfn_t r;
   nvidia_word_t q;
   nvidia_word_t c0=0, c1;
   nvidia_word_t tasm=0;
      
   r[0]=0;
   r[1]=0;
   r[2]=0;
   r[3]=0;
   r[4]=0;
   r[5]=0;
   r[6]=0;
   r[7]=0;
   r[8]=0;
   r[9]=0;

   tasm=0;
   asm( "add.cc.u32 %0, %0, %1;" : "+r"(r[0]) : "r"(tasm));
   asm( "madc.hi.u32 %0, %1, %2, 0;" : "=r"(tasm) : "r"(op1[0*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "mad.lo.cc.u32 %0, %1, %2, %0;" : "+r"(r[0]) : "r"(op1[0*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "addc.u32 %0, %0, 0;" : "+r"(tasm));
   asm( "add.cc.u32 %0, %0, %1;" : "+r"(r[1]) : "r"(tasm));
   asm( "madc.hi.u32 %0, %1, %2, 0;" : "=r"(tasm) : "r"(op1[1*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "mad.lo.cc.u32 %0, %1, %2, %0;" : "+r"(r[1]) : "r"(op1[1*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "addc.u32 %0, %0, 0;" : "+r"(tasm));
   asm( "add.cc.u32 %0, %0, %1;" : "+r"(r[2]) : "r"(tasm));
   asm( "madc.hi.u32 %0, %1, %2, 0;" : "=r"(tasm) : "r"(op1[2*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "mad.lo.cc.u32 %0, %1, %2, %0;" : "+r"(r[2]) : "r"(op1[2*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "addc.u32 %0, %0, 0;" : "+r"(tasm));
   asm( "add.cc.u32 %0, %0, %1;" : "+r"(r[3]) : "r"(tasm));
   asm( "madc.hi.u32 %0, %1, %2, 0;" : "=r"(tasm) : "r"(op1[3*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "mad.lo.cc.u32 %0, %1, %2, %0;" : "+r"(r[3]) : "r"(op1[3*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "addc.u32 %0, %0, 0;" : "+r"(tasm));
   asm( "add.cc.u32 %0, %0, %1;" : "+r"(r[4]) : "r"(tasm));
   asm( "madc.hi.u32 %0, %1, %2, 0;" : "=r"(tasm) : "r"(op1[4*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "mad.lo.cc.u32 %0, %1, %2, %0;" : "+r"(r[4]) : "r"(op1[4*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "addc.u32 %0, %0, 0;" : "+r"(tasm));
   asm( "add.cc.u32 %0, %0, %1;" : "+r"(r[5]) : "r"(tasm));
   asm( "madc.hi.u32 %0, %1, %2, 0;" : "=r"(tasm) : "r"(op1[5*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "mad.lo.cc.u32 %0, %1, %2, %0;" : "+r"(r[5]) : "r"(op1[5*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "addc.u32 %0, %0, 0;" : "+r"(tasm));
   asm( "add.cc.u32 %0, %0, %1;" : "+r"(r[6]) : "r"(tasm));
   asm( "madc.hi.u32 %0, %1, %2, 0;" : "=r"(tasm) : "r"(op1[6*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "mad.lo.cc.u32 %0, %1, %2, %0;" : "+r"(r[6]) : "r"(op1[6*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "addc.u32 %0, %0, 0;" : "+r"(tasm));
   asm( "add.cc.u32 %0, %0, %1;" : "+r"(r[7]) : "r"(tasm));
   asm( "madc.hi.u32 %0, %1, %2, 0;" : "=r"(tasm) : "r"(op1[7*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "mad.lo.cc.u32 %0, %1, %2, %0;" : "+r"(r[7]) : "r"(op1[7*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "addc.u32 %0, %0, 0;" : "+r"(tasm));
   asm( "add.cc.u32 %0, %0, %1;" : "+r"(r[8]) : "r"(tasm));
   asm( "madc.hi.u32 %0, %1, %2, 0;" : "=r"(tasm) : "r"(op1[8*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "mad.lo.cc.u32 %0, %1, %2, %0;" : "+r"(r[8]) : "r"(op1[8*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "addc.u32 %0, %0, 0;" : "+r"(tasm));
   asm( "add.cc.u32 %0, %0, %1;" : "+r"(r[9]) : "r"(tasm));
   asm( "madc.hi.u32 %0, %1, %2, 0;" : "=r"(tasm) : "r"(op1[9*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "mad.lo.cc.u32 %0, %1, %2, %0;" : "+r"(r[9]) : "r"(op1[9*op1_interleaved]), "r"(op2[0*op2_interleaved]));
   asm( "addc.u32 %0, %0, 0;" : "+r"(tasm));
   asm( "add.cc.u32 %0, %0, %1;" : "+r"(c0) : "r"(tasm) );
   asm( "addc.u32 %0, 0, 0;" : "=r"(c1));

             ...

nvidia_word_t overflow;
   asm ( "sub.cc.u32 %0, %0, %1;" : "+r"(r[0]) : "r"(nvidia_gfn_n[0]) );
   asm ( "subc.cc.u32 %0, %0, %1;" : "+r"(r[1]) : "r"(nvidia_gfn_n[1]) );
   asm ( "subc.cc.u32 %0, %0, %1;" : "+r"(r[2]) : "r"(nvidia_gfn_n[2]) );
   asm ( "subc.cc.u32 %0, %0, %1;" : "+r"(r[3]) : "r"(nvidia_gfn_n[3]) );
   asm ( "subc.cc.u32 %0, %0, %1;" : "+r"(r[4]) : "r"(nvidia_gfn_n[4]) );
   asm ( "subc.cc.u32 %0, %0, %1;" : "+r"(r[5]) : "r"(nvidia_gfn_n[5]) );
   asm ( "subc.cc.u32 %0, %0, %1;" : "+r"(r[6]) : "r"(nvidia_gfn_n[6]) );
   asm ( "subc.cc.u32 %0, %0, %1;" : "+r"(r[7]) : "r"(nvidia_gfn_n[7]) );
   asm ( "subc.cc.u32 %0, %0, %1;" : "+r"(r[8]) : "r"(nvidia_gfn_n[8]) );
   asm ( "subc.cc.u32 %0, %0, %1;" : "+r"(r[9]) : "r"(nvidia_gfn_n[9]) );
   asm ( "subc.u32 %0, %1, 0;" : "=r"(overflow) : "r"(c0) );
   
   if (overflow!=0)
   {      
      asm ( "add.cc.u32 %0, %0, %1;" : "+r"(r[0]) : "r"(nvidia_gfn_n[0]) );
      asm ( "addc.cc.u32 %0, %0, %1;" : "+r"(r[1]) : "r"(nvidia_gfn_n[1]) );
      asm ( "addc.cc.u32 %0, %0, %1;" : "+r"(r[2]) : "r"(nvidia_gfn_n[2]) );
      asm ( "addc.cc.u32 %0, %0, %1;" : "+r"(r[3]) : "r"(nvidia_gfn_n[3]) );
      asm ( "addc.cc.u32 %0, %0, %1;" : "+r"(r[4]) : "r"(nvidia_gfn_n[4]) );
      asm ( "addc.cc.u32 %0, %0, %1;" : "+r"(r[5]) : "r"(nvidia_gfn_n[5]) );
      asm ( "addc.cc.u32 %0, %0, %1;" : "+r"(r[6]) : "r"(nvidia_gfn_n[6]) );
      asm ( "addc.cc.u32 %0, %0, %1;" : "+r"(r[7]) : "r"(nvidia_gfn_n[7]) );
      asm ( "addc.cc.u32 %0, %0, %1;" : "+r"(r[8]) : "r"(nvidia_gfn_n[8]) );
      asm ( "addc.u32 %0, %0, %1;" : "+r"(r[9]) : "r"(nvidia_gfn_n[9]));
   }
   rop[0*rop_interleaved]=r[0];
   rop[1*rop_interleaved]=r[1];
   rop[2*rop_interleaved]=r[2];
   rop[3*rop_interleaved]=r[3];
   rop[4*rop_interleaved]=r[4];
   rop[5*rop_interleaved]=r[5];
   rop[6*rop_interleaved]=r[6];
   rop[7*rop_interleaved]=r[7];
   rop[8*rop_interleaved]=r[8];
   rop[9*rop_interleaved]=r[9];
}

becouse of coins supply

Why? I think having a coin which is immune to disruptive mining methods, is a good thing. More certainty, better investment.

if nobody invent fast GPU miner / ASIC XPM miner - this coin will be probably dead.