Actually, now that I think about it... if they have a dog and you send a lot of ultrasonic noise their way, IF they have a dog,  the dog will make all the disruptive noise you need :-)

That said, as that you are having trouble with your neighbors... I guess talking to them is out of the question??

mp

It's been a while since I was last here, but I do love a good challenge...

Since you are offering fractional bitcoins for hints, here is my suggestion:

Use ultrasound interference.  Ultrasound is sound at frequencies above human hearing, so technically, it can be as loud as it needs to be blasted through a transducer... but because it is in the range above human hearing, no matter how loud it is, it shouldn't be heard at least not at the source.  Then using the principle of sound from ultrasound which involves interference patterns modulated appropriately, it is possible to direct the sound such that it is basically heard only at the destination.  There are companies that have developed the technology described in the wikipedia page:

https://en.wikipedia.org/wiki/Sound_from_ultrasound

You can also Google the details of how sound from ultrasound works and there is also a few discussions on instructables if you want to investigated the DIY route:

http://www.instructables.com/answers/Is-there-a-way-to-make-an-ultrasound-to-sound-quo/

mp

shovelsandpickaxes.com is online in limited production/beta.

Sign up to post your USED mining equipment there for FREE.  

Basically, I'm just a guy that recently started exploring cryptocoin mining as a hobby.  I started with the ASIC Erupter Blade V2.  The problem as I saw it, was that there was a lot of price gouging going on that contributed to a high cost of entry which made it difficult to mine a decent return on the money invested to purchase crypto mining equipment.  Nowhere was this more evident than the graphics cards that now often sell for more than $100 over their MSRP.  In some ways it reminded me of those late night commercials where for a nontrivial initial investment, you get the money-making "kit" that will lead you to your future financial freedom.

Anyway, I've been involved with computers for a long time... As a hobby, long enough to often subsidize many of my new hardware purchases with the proceeds from "cleaning house" on occasion.  I figured that to the extent that I could encourage a similar ecosystem for this new mining hobby, we might _all_ benefit.

Like many of you, I first looked to Ebay to find my initial equipment.  Let's face it; Ebay has everything... but sometimes when it comes to sticking people up for their hard earned cash, Ebay is more a part of the problem than the solution.  It's long since moved away from the individual seller looking to clear out his/her basement to favor storefront/business based sellers... and with that shift in focus, many of the "deals" that many of us remember fondly from Ebay's early days have migrated to places like Craigslist.

The next place I went was Amazon which possibly has more stuff than Ebay.  They also had crypto mining equipment, more straightforward purchasing and delivery, and slightly lower prices (about $80 when I bought my first Erupter blades). I ended up buying there from Jones Gear and was pretty pleased with my purchase but although lower than Ebay, this still wasn't the lower cost alternative I was looking for especially since in both cases, I was dealing with new equipment.

So I decided that I needed to do something to encourage people to sell their used equipment at a discount with a slight twist:

If you sell anything through Ebay, Ebay takes a cut, and if you use Paypal (owned by Ebay) to collect payment, Paypal takes a cut.  A friend who sometimes sells on Ebay told me that this can be as much as 15%.  If you sell through Amazon, Amazon gets a cut that I think is comparable...  

My solution is simply to let you post your used equipment for free, and then depending upon how altruistic you feel, reflect some or all of the money that you are _not_ paying to Amazon or Ebay in your posted prices.  Because such altruism can lead to lower prices, my hope is that it creates negative price pressure to counterbalance the gouging I was complaining about.  People buying cheaper used equipment sap demand for higher priced new equipment, which hopefully leads to lower prices for new equipment and more people getting into crypto mining at a more affordable entry level.

That's the theory anyway, so to get this experiment started, I created shovelsandpickaxes.com.  I am aware that greed can be such that individuals may choose to sell on the website at the same prices as Ebay and Amazon, but that is ok too because my hope is more people selling on the site will lead to more competition, if not with the other sellers of used equipment, with the sellers of new equipment willing to lower their prices to compete better with the used equipment sellers.

Is it a perfect plan? Nope.

Is it a perfect website? Nope.  Not even close.

I'm a system admin, I'm not an economist, and I'm not a web designer but I hope that with your help, I'll be able to improve the website over time. I just figured that there needed to be somewhere else besides Ebay, Amazon, and here to facilitate the buying and selling of used crypto mining hardware, which in turn for users could potentially lower the price of and/or subsidize the buying and selling of new crypto mining hardware.

So if you want to be a part of the vision and help out you can:

1) List your used equipment on shovelsandpickaxes.com for free
2) You can offer your suggestions for improvement and desired features here
3) You can (eventually) buy premium ads on the website for any of the available categories
4) You can tell others about shovelsandpickaxes.com and what I'm trying to accomplish
5) You can donate however much or little BTC you feel like donating to offset my time and expenses
6) You can volunteer your own time and expertise in some way (lots to be done)
7) You can start your own classifieds website (because more competition is better) to do the same thing

How will I benefit from all of this?

1) Did I mention that this hobby is an expensive one? :-)
2) I'd like to enjoy lower prices for both new and used mining equipment just like you
3) It could subsidize my other projects such as my ASIC ethernet management tools which require me to purchase more and different kinds of Ethernet based miners.  (Currently they only support the ASIC Erupter Blade V2)
4) There are worse things you can get a reputation for :-)

How will YOU benefit from all of this?

1) You get a free place to liquidate your used equipment either for profit or to subsidize your own crypto mining activities
2) As a buyer or seller, you get to strike back at all of the businesses engaging in the price gouging ecosystem from the gougers to the payment systems and other middle men taking their cut of the gouging.
3) You (hopefully) get a place to find less expensive crypto mining equipment.

Because of the site's mission, posting _used_ equipment will always be FREE.  (Actually while in limited production, until I get the paid features of the site tested and running, I'd actually prefer for you to use just the free features)  Other than that, I will continue to run the site for as long and as well as my limited resources allow.  All suggestions welcome here.  Also, because I am not much of a web designer or graphic artist, depending upon its reception, I'll probably offer bounties at some point to add beauty and/or functionality to the site.

In the meantime, let the experiment begin...

MP

Site donation btc:
1PZtJwHZdhMzegddJVcddgipp1wu8HX1F8

No need to be insulting, I would wager that most here have studied "basic" math.  The fact remains that compression is used and works everyday.  Math is a tool, this is a challenge.  We don't have to compress every number in existence, we only need to find the best way to compress 4.  If they happen to be 4 identical numbers, then the problem is trivial.  The only thing that is ultimately required is to either find or create an exploitable relationship between the numbers.

Perhaps your time would be better spent studying basic history, because history is just as "full" of things that _got_ done as it is of people who made proclamations about what couldn't be done.  Even if *I* can't do it, it still doesn't mean that it can't be done.

Btw, in my first attempt, I already using a modified huffman encoding scheme figured out how to consistently represent 128 bits in about 85.

0, 11, 100, 101

MP

I understand the point about the folly of trying to use 2^32 things to represent 2^64 things.  I get that, however the point I come to is that we're not looking for a way to express 2^64 things using 2^32 things.  We are looking for a way to express 4 out of 2^64 things.  If you had a data stream that consisted of 2^64 unique symbols, I agree that there is no way to express that stream using less than 2^64 symbols...

BUT

We have a box of 2^64 symbols, and we are looking for a way to describe 4 of them as independently of the box they came from as we can.  If we can do that, then we ultimately only need 4 symbols.

0 1 2 3 4 5 6 7 8 9 A B C D E F

16 is the size of our box, we select 1, 5, 9 and D.  If we predetermine between the encoder and the decoder that 4x+1 is the magic incantation, then we can "compress" a 4 bit code into a 3 bit code  It doesn't matter that the box holds 16 symbols in total.  What matters is the relationship that is "understood" between encoder and decoder.

Yes, EK has given us numbers that can range from 0 to 2^32-1, but we only have to "store" 4 of them and if he gives us a different 4, we can identify a different relationship.  So I'm not disputing anyone's proof, I just currently remain unconvinced that the proofs presented necessarily describe and apply to *this* problem.

Mind you, that doesn't mean that I have an answer for this challenge... but it does mean that I'll probably have to programmatically explore some ideas before I convince myself that it can't be done.

MP

My point is that unless the data stream consists of the entire sample space/list of all possible values, (which in this case, it doesn't) you will never need to be able to store all of those infinite points digitally.  If given 4 numbers, you can identify or create a relationship between those numbers, then you can potentially transmit the relationship as opposed to the data.  In some cases this may be far less data to store or transmit.

For instance, if both sides or rather the encoder and decoder "understood" that the data consisted only of powers of 2, then you could send the data element 256 as 8, a reduction from 9 bits to just 4 (8 bits handles values 0-$FF, $100 is 9 bits, likewise 3 bits handles values 0-$7, 4 bits is required to express the number 8  ). To E-K's point concerning compression, I would propose that this is exactly a compression problem because although your numbers can be in the range of 0-2^32-1, you're only using 4 numbers from that set.  If perfect knowledge existed between encoder and decoder (which of course it doesn't), then you could ultimately express each number using 2 bits: 00, 01, 10, 11

Anyway, I got the spiral idea contemplating nature, spirals, and fractals.  I understand your point about analog vs digital addressing but this problem doesn't have to be solved in terms of ones and zeros.  We can use analogs such as any positive value is 1 and any negative value is 0, or any value greater than or equal to 0.5 is 1 and any value less than 0.5 is 0.  The attribute about the spiral that I like is that the further way from the center you get, the greater the distance between targets which means that you can be "closer" to a target with less resolution in your coordinate system.

I'm not willing to say that this will work, I'm just wondering if we can get around some of the well established limitations by looking at the problem differently and checking to see whether the limitations involved MUST apply to our case.

MP

Yes, I get your point but you are correct in that compression does "feel" right.  We're ultimately talking storage.  One might say that 11111111 as characters occupies more storage than 255 stored as characters, which is more than FF when stored as characters, yet when stored as bits it occupies less space than all of these.

The function 3x+2y= 14, describes an infinite number of points.  So I don't think it's necessarily about finding ways to represent 4 numbers using 2, but finding for *each* of the 4 numbers a way to represent them using 2 numbers that can be reversed.  When first contemplating the problem I imagined a spiral

R= a+b*theta

Imagine all of the possible integers in question evenly spaced along the spiral as it wraps around.

Every number along the spiral could be reached using just two numbers: a radius and theta.

Perhaps in the end there wouldn't be much savings because of the resolution you'd need to express tiny angles,  but as a thought exercise, it seemed reasonable.

MP

Hi all,

While I agree that it _probably_ can't be done, part of me entertains that it possibly can be done.  To me this seems like a basic compression problem.  At first blush, I contemplated using variable length codes organized according to a frequency distribution of the data taken to bits at a time.  This would basically have been huffman encoding where upon evaluating the bit patterns 00,01,10,11 the variable length codes would have looked like 0, 11, 100, 101.  Thus the most frequent bit pattern would be coded as 0, the next most frequent bit pattern 11, and the least frequent bit patterns either 100, or 101.

Unfortunately, this had a best case scenario of 50% compression+the overhead of the frequency table required to map the 2 bit tokens to their variable length equivalents.

The most promising approach in my opinion is dictionary based compression which I believe is the basis of Lempel-Ziv compression.  There however the compression is ultimately limited by the size of the dictionary.

All case however revolve around identifying patterns that allow you to shrink the communicated sample space such that you are counting patterns of data as opposed to individual data items.

MP

Payment has been received and I have left you positive feedback. Thanks.

MP

Thank you Evil-Knievel,

You can pay me at this bitcoin address:

1KUhB2S8Xwp2eE3Tsn9NRtd9HWNxvp3Dx2

As I contemplate your response, I think that you might be able to get somewhere using fuzzy logic.  If one substitute (-1) for (0), ie: {-1, 1} as opposed to {0, 1}, a single XOR can be expressed as:

(-1)^((a+b)^2/4)

It is difficult to escape the modulo math because without it, it's difficult to isolate individual bits. Using negative vs positive numbers (as opposed to individual numbers) might work, but that is just the first thought off the top of my head.

MP

Hi,

I'm obviously new here.  While I know what escrow is, how does escrow work here?  How do you identify services that you can trust?  Is there a thread that covers this?

MP
(still unpaid)

Evil-Knievel:

Could we get an update?

MP

Sorry guys. 

Many years after writing my first computer program in BASIC, I still enjoy programming.  In RL, my programming is more mundane... stuff like managing email aliases, creating accounts, monitoring log files, etc.  This was the most interesting challenge I've considered in a little while, and really the only one where the "how it was done" was more interesting than the "what was done."

The OP, kinda presented the challenge like he might have some interest in how it was done.  Others answered the call, no one seemed to have the answer.  I thought it might be interesting to share the answer and how I came up with it because the principles involved actually have value for bitcoin/altcoin mining... Why? Because if you can describe logical operations mathematically, you can investigate SHA256 and sCrypt mathematically.  Who knows where that leads?  If you could simplify the mathematical expression of sCrypt for instance (and look at it), you might be able to derive an algorithm that can hash sCrypt hashes even faster by saving your compute platform redundant/superfluous processing cycles. You never know.

I didn't mean to bore anyone; my intentions were good... and then of course, there was the $200 :-)

The ironic thing? I got into computers because I wasn't particularly good at math...

MP

PS.: I'll be putting my ASIC Erupter Blade V2 configuration/monitoring tools out in source code form and GPL'd for FREE soon. I have a few mining boards, like them a lot, but realized that I would like them more if I could apportion/manage/restart/reconfigure them automatically under program control. When ready (probably I'll start with a 0.5 release), look on the forums for where to get them if you have and like the Erupter Blade hardware....

[ This is the Mathematica compatible version that I sent to EK via PM]

I have figured out what you were doing wrong.  Since you are using Mathematica, the modulus (mod) operator is not '%' as it is in Perl and in Python.  I have since rewritten the formula to be Mathematica compatible.  The following version was tested to run under Mathematica 7:

((1+((-1)^(((1-(-1)^(Mod[a*2^(32-0),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-0),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-0),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-0),(2^32-1)]))/2))))/(-2))/2)*2^0+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-1),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-1),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-1),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-1),(2^32-1)]))/2))))/(-2))/2)*2^1+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-2),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-2),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-2),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-2),(2^32-1)]))/2))))/(-2))/2)*2^2+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-3),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-3),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-3),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-3),(2^32-1)]))/2))))/(-2))/2)*2^3+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-4),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-4),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-4),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-4),(2^32-1)]))/2))))/(-2))/2)*2^4+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-5),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-5),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-5),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-5),(2^32-1)]))/2))))/(-2))/2)*2^5+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-6),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-6),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-6),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-6),(2^32-1)]))/2))))/(-2))/2)*2^6+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-7),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-7),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-7),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-7),(2^32-1)]))/2))))/(-2))/2)*2^7+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-8),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-8),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-8),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-8),(2^32-1)]))/2))))/(-2))/2)*2^8+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-9),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-9),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-9),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-9),(2^32-1)]))/2))))/(-2))/2)*2^9+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-10),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-10),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-10),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-10),(2^32-1)]))/2))))/(-2))/2)*2^10+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-11),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-11),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-11),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-11),(2^32-1)]))/2))))/(-2))/2)*2^11+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-12),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-12),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-12),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-12),(2^32-1)]))/2))))/(-2))/2)*2^12+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-13),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-13),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-13),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-13),(2^32-1)]))/2))))/(-2))/2)*2^13+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-14),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-14),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-14),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-14),(2^32-1)]))/2))))/(-2))/2)*2^14+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-15),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-15),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-15),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-15),(2^32-1)]))/2))))/(-2))/2)*2^15+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-16),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-16),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-16),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-16),(2^32-1)]))/2))))/(-2))/2)*2^16+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-17),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-17),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-17),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-17),(2^32-1)]))/2))))/(-2))/2)*2^17+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-18),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-18),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-18),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-18),(2^32-1)]))/2))))/(-2))/2)*2^18+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-19),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-19),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-19),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-19),(2^32-1)]))/2))))/(-2))/2)*2^19+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-20),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-20),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-20),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-20),(2^32-1)]))/2))))/(-2))/2)*2^20+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-21),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-21),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-21),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-21),(2^32-1)]))/2))))/(-2))/2)*2^21+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-22),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-22),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-22),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-22),(2^32-1)]))/2))))/(-2))/2)*2^22+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-23),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-23),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-23),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-23),(2^32-1)]))/2))))/(-2))/2)*2^23+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-24),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-24),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-24),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-24),(2^32-1)]))/2))))/(-2))/2)*2^24+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-25),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-25),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-25),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-25),(2^32-1)]))/2))))/(-2))/2)*2^25+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-26),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-26),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-26),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-26),(2^32-1)]))/2))))/(-2))/2)*2^26+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-27),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-27),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-27),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-27),(2^32-1)]))/2))))/(-2))/2)*2^27+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-28),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-28),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-28),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-28),(2^32-1)]))/2))))/(-2))/2)*2^28+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-29),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-29),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-29),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-29),(2^32-1)]))/2))))/(-2))/2)*2^29+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-30),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-30),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-30),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-30),(2^32-1)]))/2))))/(-2))/2)*2^30+
((1+((-1)^(((1-(-1)^(Mod[a*2^(32-31),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-31),(2^32-1)]))/2))+(-1)^(2-(((1-(-1)^(Mod[a*2^(32-31),(2^32-1)]))/2)+((1-(-1)^(Mod[b*2^(32-31),(2^32-1)]))/2))))/(-2))/2)*2^31

MP

Did you try the latest version of the program that uses -1 as a base instead of 0?  Also, I have access to Mathematica, so perhaps I can see what you are up against...

MP

That is almost the *exact* configuration I started out with when I experienced problems. It took about a week for me to figure out that I needed to isolate the boards on their own network.  At the high point, I had 10 blades on a 16 port switch.  Now I have 3 (sold the rest), but like I said... I no longer have any problems.

As best as I can illustrate, my configuration looks like:

INTERNET<--->modem<--->(eth0)[computer-running-bfgminer]
                                                         (eth1)<--->netgear-ethernet-switch
                                                                                ^              ^
                                                                                 |               |
                                                                                 v              v
                                                                              blade0  ...  bladeN

I originally went down this path to try to isolate my network issues in the event that something
was either broadcasting or interfering with the other hosts on its subnet.  Basically, all of the
blades are on a 192.168.2.x subnet along with eth1.  The computer running bfgminer is on my
internal internet connected network 192.168.1.x.  This means that bfgminer running in proxy mode can get out to communicate with whichever pool you've assigned it to.  The blades themselves don't need to access the internet directly, they only need to talk to the host running bfgminer.

Since switching to this configuration, the remaining boards have been running without incident. They've even been stable enough that I have developed tools to monitor, configure, and reconfigure them automatically. (I'll probably be releasing the tools for free to the public under a GPL license within the next couple of weeks).

MP

Nope, at least not yet-- But I would like to mention that I *do* accept bitcoin :-)

I think we can all agree that it was an interesting challenge, so much so that even in spite of the novel I've written here, I'm writing a blog entry about the problem and its solution.

MP

Hi,

Do you have your board connected to a wireless router?  For some reason, the boards don't seem to play well with them.  (That's my experience at least) At one point, I had 10 boards hashing away but I had to isolate them on their own backend network.

I don't know your setup, but I would recommend putting all of your boards (or even just the one) on an ethernet switch and then possibly connect to your proxy server via a second ethernet card in the server.  In other words, my configuration was a dual homed proxy server running bfg miner with one ethernet adapter connected to my internet service and the other adapter connected to the ethernet switch that the boards were connected to.

Once I isolated the boards on their own backend network, I never had any more problems.

MP

Ok, to deal with the last concern about 0^0 being undefined in some implementations, this program uses the same principles but uses a mapping of {-1,1} in place of {0, 1}.  Basically, everything else applies only to go from the former to the latter you must add 1 (+1) then divide by 2.  This works because (-1+1)/2 = 0, and (1+1)/2 = 1.

Using this we must remap our xor and alternate modulus functions such that:

xor($a,$b)= ((1+((-1)**($a+$b)+(-1)**(2-($a+$b)))/(-2))/2)

and our alternate modulo 2 function looks like:

((1-(-1)**$n)/2) = $n % 2

why?

because when $n is odd we get (1-(-1))=2/2= 1,
      and when $n is even we get (1-1)=0/2= 0.

Literally everything else (including the rotations to rotate the bits of interest to the 1s digit) is the same.

THE LASTEST (and hopefully last) PROGRAM:
#!/usr/bin/perl

my $buf=<STDIN>;
my ($a, $b)= split /\s/, $buf;

my $result=
((1+((-1)**(((1-(-1)**($a*2**(32-0)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-0)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-0)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-0)%(2**32-1)))/2))))/(-2))/2)*2**0+
((1+((-1)**(((1-(-1)**($a*2**(32-1)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-1)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-1)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-1)%(2**32-1)))/2))))/(-2))/2)*2**1+
((1+((-1)**(((1-(-1)**($a*2**(32-2)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-2)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-2)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-2)%(2**32-1)))/2))))/(-2))/2)*2**2+
((1+((-1)**(((1-(-1)**($a*2**(32-3)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-3)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-3)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-3)%(2**32-1)))/2))))/(-2))/2)*2**3+
((1+((-1)**(((1-(-1)**($a*2**(32-4)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-4)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-4)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-4)%(2**32-1)))/2))))/(-2))/2)*2**4+
((1+((-1)**(((1-(-1)**($a*2**(32-5)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-5)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-5)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-5)%(2**32-1)))/2))))/(-2))/2)*2**5+
((1+((-1)**(((1-(-1)**($a*2**(32-6)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-6)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-6)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-6)%(2**32-1)))/2))))/(-2))/2)*2**6+
((1+((-1)**(((1-(-1)**($a*2**(32-7)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-7)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-7)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-7)%(2**32-1)))/2))))/(-2))/2)*2**7+
((1+((-1)**(((1-(-1)**($a*2**(32-8)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-8)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-8)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-8)%(2**32-1)))/2))))/(-2))/2)*2**8+
((1+((-1)**(((1-(-1)**($a*2**(32-9)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-9)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-9)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-9)%(2**32-1)))/2))))/(-2))/2)*2**9+
((1+((-1)**(((1-(-1)**($a*2**(32-10)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-10)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-10)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-10)%(2**32-1)))/2))))/(-2))/2)*2**10+
((1+((-1)**(((1-(-1)**($a*2**(32-11)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-11)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-11)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-11)%(2**32-1)))/2))))/(-2))/2)*2**11+
((1+((-1)**(((1-(-1)**($a*2**(32-12)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-12)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-12)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-12)%(2**32-1)))/2))))/(-2))/2)*2**12+
((1+((-1)**(((1-(-1)**($a*2**(32-13)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-13)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-13)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-13)%(2**32-1)))/2))))/(-2))/2)*2**13+
((1+((-1)**(((1-(-1)**($a*2**(32-14)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-14)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-14)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-14)%(2**32-1)))/2))))/(-2))/2)*2**14+
((1+((-1)**(((1-(-1)**($a*2**(32-15)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-15)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-15)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-15)%(2**32-1)))/2))))/(-2))/2)*2**15+
((1+((-1)**(((1-(-1)**($a*2**(32-16)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-16)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-16)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-16)%(2**32-1)))/2))))/(-2))/2)*2**16+
((1+((-1)**(((1-(-1)**($a*2**(32-17)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-17)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-17)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-17)%(2**32-1)))/2))))/(-2))/2)*2**17+
((1+((-1)**(((1-(-1)**($a*2**(32-18)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-18)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-18)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-18)%(2**32-1)))/2))))/(-2))/2)*2**18+
((1+((-1)**(((1-(-1)**($a*2**(32-19)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-19)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-19)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-19)%(2**32-1)))/2))))/(-2))/2)*2**19+
((1+((-1)**(((1-(-1)**($a*2**(32-20)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-20)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-20)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-20)%(2**32-1)))/2))))/(-2))/2)*2**20+
((1+((-1)**(((1-(-1)**($a*2**(32-21)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-21)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-21)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-21)%(2**32-1)))/2))))/(-2))/2)*2**21+
((1+((-1)**(((1-(-1)**($a*2**(32-22)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-22)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-22)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-22)%(2**32-1)))/2))))/(-2))/2)*2**22+
((1+((-1)**(((1-(-1)**($a*2**(32-23)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-23)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-23)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-23)%(2**32-1)))/2))))/(-2))/2)*2**23+
((1+((-1)**(((1-(-1)**($a*2**(32-24)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-24)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-24)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-24)%(2**32-1)))/2))))/(-2))/2)*2**24+
((1+((-1)**(((1-(-1)**($a*2**(32-25)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-25)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-25)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-25)%(2**32-1)))/2))))/(-2))/2)*2**25+
((1+((-1)**(((1-(-1)**($a*2**(32-26)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-26)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-26)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-26)%(2**32-1)))/2))))/(-2))/2)*2**26+
((1+((-1)**(((1-(-1)**($a*2**(32-27)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-27)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-27)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-27)%(2**32-1)))/2))))/(-2))/2)*2**27+
((1+((-1)**(((1-(-1)**($a*2**(32-28)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-28)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-28)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-28)%(2**32-1)))/2))))/(-2))/2)*2**28+
((1+((-1)**(((1-(-1)**($a*2**(32-29)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-29)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-29)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-29)%(2**32-1)))/2))))/(-2))/2)*2**29+
((1+((-1)**(((1-(-1)**($a*2**(32-30)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-30)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-30)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-30)%(2**32-1)))/2))))/(-2))/2)*2**30+
((1+((-1)**(((1-(-1)**($a*2**(32-31)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-31)%(2**32-1)))/2))+(-1)**(2-(((1-(-1)**($a*2**(32-31)%(2**32-1)))/2)+((1-(-1)**($b*2**(32-31)%(2**32-1)))/2))))/(-2))/2)*2**31;

print "$result\n";

At this point, the bottom line is that BOTH the last 2 programs should satisfy the requirements and work.  This program avoids the 0^0 convention by substituting -1 for 0 and adjusting our alternate modulo 2 and xor functions accordingly.

(Thanks nickjer)

MP