Running 10 nodes locally for my own pool I am getting about 10% reject rate as blocks come in just before shares are submitted.   Factor in internet latency and other issues from normal pools and I would expect it to be much higher.

i can make an UI design for the wallet ..

I would love the concept, but pretty graphics and non-standard UI elements make the cost of GUI development grow very quickly on desktop apps.    If you stick to common UI elements without a lot of fancy style then I would welcome the effort, but cannot pay for that.   Consider it an investment in your protoshares

I am keeping that info private, people may not want their keyhotee ID tied to their real ID.

bytemaster, hope you saw my response. I think you underestimated the issue:

https://bitcointalk.org/index.php?topic=325261.msg3523201#msg3523201

Integrated Graphics can saturate its memory bus (60 GB/Sec on latest hardware) using the same techniques as hyper-threading to perform parallel execution.  GPUs can get 5x faster memory performance, though I think in this particular use case moving more than 64 bytes (cache line size) per cycle doesn't help due to the random access nature.   In fact, it may hurt the GPU by being forced to consume its memory bandwidth in larger than necessary chunks when it is randomly accessed.

I think it is fair to say that performance of the memory-based approach is limited by memory bandwidth and that 'in theory' a GPU could have 260 Gbs while high end desktops can get 60 Gbs and low end systems get 10 Gbs.  So there is a 26x difference between average CPU based systems and high end graphics cards.

By the way, I am very much considering paying the bounty based upon information provided thus far.  I just need to understand the degree to which Momentum has been harmed by the algorithms mentioned. 

1) What is the performance of SCRYPT on CPU vs GPU? 
2) Does momentum have a lower performance ratio than SCRYPT?
3) When it comes to making an ASIC, which would be harder SCRYPT or Momentum?

As far as how to divided the bounty among the various contributors I am thinking that AnonyMint and gigawatt have both provided some reasonable contributions.   I will wait to see gigawatt's proof-of-concept implementation to be sure there is a cycle and that the computational time is not larger than available parallelism before making the final decision about relative payout.   Gigawatts proof-of-concept shows more time and energy invested and is also more compelling than theoretical estimations of performance gains provided by AnonyMint.  Clearly writing code is of greater value than writing forum posts and also more definitive.

Summary of Algorithms Presented
Bloom Filter to Reduce Memory  -  comes at performance cost, may be able to perform in parallel with R&D which leads to GPUs...
Memory Bandwidth of GPU arch vs CPU arch - gives a potential 4 to 24x advantage to GPU based upon specs alone, must be discounted by overhead of accessing memory in larger chunks than necessary and/or bloom filter and/or different time complexity sort/search algorithms
Constant-Memory Cycle Search Algorithms - trade CPU for Memory in a manner that might make parallelism free from memory bus constraints.  Must prove we have cycles and that calculation time does not exceed  level of parallelism. 

Good work everyone, it is a pleasure debating this with you all.  I hope you recognize that I am in this to find the best algorithm and NOT to defend my ego and put my head in the sand.   This bounty and ProtoShares has brought out great minds and we sharpen one another. 



 

Wow great work guys!   I am taking some time to digest it all and really wish the bounty would have been taken more seriously prior to launch.

If the input is given as a subroutine for calculating ƒ, the cycle detection problem may be trivially solved using only λ+μ function applications, simply by computing the sequence of values xi and using a data structure such as a hash table to store these values and test whether each subsequent value has already been stored. However, the space complexity of this algorithm is λ+μ, unnecessarily large. Additionally, to implement this method as a pointer algorithm would require applying the equality test to each pair of values, resulting in quadratic time overall. Thus, research in this area has concentrated on two goals: using less space than this naive algorithm, and finding pointer algorithms that use fewer equality tests.

So assuming an ASIC can implement f(x) very quickly... then this algorithm can be reduced to 2 memory locations using something like the tortoise and hare algorithm. 

There is one thing it seems to require and that is mapping an input space to itself.   In the case of momentum the input space does not fit this criteria.   Nonces are 20 bit, birthdays are 50 bits.   But a birthday is not just a SHA512(nonce), but SHA512( nonce + header ) and this generates 8+ birthdays which would not have the property of mapping back to itself in a cycle.

Let me look into some of the other techniques and their requirements.

You have to create it because by default it is empty.

I will email instructions once the beta of Keyhotee is out with details on how to redeem your ID.