Bitcoin Forum
December 04, 2016, 12:02:04 AM *
News: Latest stable version of Bitcoin Core: 0.13.1  [Torrent].
 
   Home   Help Search Donate Login Register  
Pages: [1] 2 3 »  All
  Print  
Author Topic: MerkleWeb - statistical Godel-like secure-but-not-perfect global Turing Machine  (Read 6810 times)
BenRayfield
Sr. Member
****
Offline Offline

Activity: 262



View Profile WWW
November 27, 2011, 11:21:51 PM
 #1

When I build a prototype of this public domain open specification, it will be at http://sourceforge.net/projects/merkleweb

MerkleWeb is based on a variation of the Bitcoin security model.


MerkleWeb - a statistical Godel-like secure-but-not-perfect proof system for a global realtime peer to peer Turing Machine

Start with a 256 bit address space where each address points at a specific one of 2^256 virtual bits, not a byte or int like many hardwares take shortcuts in the consistency of their designs.

Add a 64 bit address space for time, so any past, present, or future state.

Use that as a combined 320 bit address space, where each address points at a specific one of 2^320 virtual bits.

Add 1 bit to the 320 bit addresses, so a 321 bit address points at a Godel-like statement which means "This specific one of 2^320 virtual bits is a 0 bit" or at "This specific one of 2^320 virtual bits is a 1 bit".

In 321 address space, there are 2 bits mapping to each bit in 320 address space.

If those bits, aligned at even bit indexes, are 10, it means "This specific one of 2^320 virtual bits is a 0 bit".

If 01, it means "This specific one of 2^320 virtual bits is a 1 bit".

If 00, it means "This Godel-like statement does not know if the specific one of 2^320 virtual bits is a 0 bit or a 1 bit".

If 11, that is a contradiction and must be backtracked until a state of the system is found that, as proven to exponential certainty but not Godel-like certainty, is a consistent state of the system.

Put constants near the end of time in 64 bit address space so they do not interfere with the Turing Machine running in the lower half for up to 2^63 cycles.

Name constants by their SHA256 secure-hash, so it is exponentially certain their name will never overlap any other constant in the whole system. The 320 address of any constant bit string is the 256 address from its SHA256 hash and the 64 time address of 2^64 minus its bit length, which can be calculated in twos-complement integer math as -bigLength, so if you're using Java's long number type for example, the constant bit string starts at a 320 address, and you increment the long until it rolls over to 0, each time observing 1 bit in the constant bit string that is named by that 320 bit address.

A Merkle Tree is a tree of secure-hash names of other Merkle Tree nodes, ending at any leaf data. Bitcoin uses Merkle Trees to keep its peer to peer network secure as the whole network globally agrees on who has how much money and who has sent and received how much money from who else. MerkleWeb (this software I'm planning) will use MerkleTrees similar to how Bitcoin uses them, but to refer to states of a peer to peer globally decentralized Turing Machine instead of money.

Each MerkleTree recursively refers to specific values for each of 2^321 bits, which is approximately 1 googolbit.

As parts of the system flow through the Internet and learn about other parts of the system, new MerkleTrees are created that have more "10" and "01" (adjacent bits, aligned at even index, in 321 address space) than "00" (which means don't know if its 0 or 1 in 320 address space). Each of those "parts of the system" is a MerkleTree that combines other MerkleTrees in usually different combinations than other MerkleTrees combine them.

Every 2 MerkleTrees that have equal childs are the same MerkleTree and have the same 320 address, since its made of the SHA256 hash of the bits of that MerkleTree (shallow view, only including the 320 address of each child in the hash) and 2^64 minus its bit length which is 320*childs. Therefore if 2 computers on 2 sides of Earth happen to calculate the same MerkleTree as a combination of the same childs and continue calculations based on it, when that information travels across Earth and they learn of eachother's calculations, it fits together since they both calculated the same 320 bit addresses.

In this MerkleWeb system, each MerkleTree, which can be as small as 640 bits, refers to a possibility of the entire state of MerkleWeb and the entire history of MerkleWeb, including all other MerkleTrees which represent other possibilities, an acyclic network of possibilities each referring to many other possibilities.

2 MerkleTrees can only be combined if they do not contradict eachother on even 1 bit. Each MerkleTree represents exact values for each of 2^321 virtual bits, approximately 1 googolbit, so that is not easy to do, but here's the rule that makes it practical for realtime speeds: Since we only store MerkleTrees that, proven to exponential certainty, have no contradictions between their child MerkleTrees recursively, we only need to keep track of which child MerkleTrees are compatible with which other MerkleTrees, and search any MerkleTrees we receive from the peer to peer network recursively comparing their childs to the childs we already have, and use only the parts of them we can prove, to exponential certainty, do not contradict eachother. Each cycle of the network, which I call a "global heartbeat" since these cycles and network hops are time aligned in the whole MerkleWeb, each computer creates a MerkleTree node that recursively refers to the largest set of consistent bits in the 321 bit address space (a possibility, a view of all past and present states of the whole MerkleWeb), and transmits that to peers.

Computers in MerkleWeb ask eachother for specific MerkleTrees, named by a 320 address. When its received, they SHA256 hash it to verify as an absolute proof that it has that 320 address, but there is a exponentially small chance some other computer in the network has a different MerkleTree that has the same SHA256 hash (which has never happened for the SHA256 algorithm), and there is a superexponentially small chance such a contradiction would survive in MerkleWeb as I'll explain as continuous "snapshot-of-the-whole-Internet" below.

The network routing behaviors can be built on top of the Turing Complete layer that MerkleWeb defines as bits. Start with some bit representation of NAND and 320 bit addresses for it to be a CONSTRAINT between, which all other logical operations can be derived from, build it up like a hardware system, build whatever software components you need to make the peer to peer network work, and to exponential accuracy it is accurate to call MerkleWeb and the entire Internet (or whichever parts choose to implement the MerkleWeb open standard) a quine.

NAND is a constraint between 2 bits in the past and 1 bit in the future, not an action. A more flexible definition of NAND would be to let it operate on 3 320 bit addresses, to NAND 2 of their targets and put the resulting bit in the other address. MerkleWeb is flexible and secure enough to work either way or both.

Technically the "acyclic network" is a closed loop allowing self-reference or other forms of cycles and we would get into all kinds of contradictions as Godel proved, but this system will prove to exponential certainty, backed by the security of SHA256 or whatever secure-hash algorithm you think is more secure, exponential certainty that the system is consistent on each computer and in the peer to peer network where local events change things and such information flows here a short time later, we also have a proof to exponential certainty that all these MerkleTrees will quickly fit together into a consistent snapshot of the whole decentralized MerkleWeb, so we can take continuous snapshots of the Internet (whichever parts choose to implement the MerkleWeb open standard) and have a new root MerkleTree snapshot-of-the-whole-Internet thats only a few seconds old, updating it continuously.

We could version and branch the whole Internet, states of its memory and computing states, as a peer to peer based Turing Complete cloud infrastructure, to use the whole Internet as 1 Turing Machine.

The backtracking and recalculating, from the NAND level up (with optional paravirtual optimization if the implementation of MerkleWeb supports it, but that doesn't change behaviors, just do combinations of NANDs faster), is proven to converge at exponential speed in the global peer to peer network because each virtual bit string of exactly 2^321 bits (which a MerkleTree refers to recursively) is a Bloom Filter. A bloom filter is a 1 dimensional array of bits, where all bits start at 0, and the only allowed operation is to change a 0 bit to a 1 bit, but no 1 bit ever becomes a 0 bit.

Bloom filters can be combined if no 2 adjacent bits, the first having even index, are both 1 or become 1. To combine them, OR their bits, verify the "2 adjacent bits" constraint is satisfied, and there is 1 more constraint: The state of the system must be the result of a past state of the system as the NAND logic, implemented in the past bit state of the system, defines.

Proven to exponential certainty, no bloom filter in MerkleWeb will have 2 adjacent bits, an even index and the odd index that goes with it, both being 1, because that would mean the specific bit in 320 bit address space (that those 2 bits in 321 bit address space refer to possibilities of) would simultaneously be 0 and 1. Many computers in the peer to peer network will have MerkleTrees (which each refer to virtual 2^321 bit bloom filters) that disagree with eachother and can not be combined (while some of their childs to some recursive depth can be combined with some of the local childs), but it will all converge as past states of the system and the NAND level definition of how the system must proceed from one state to the next are used for the peer to peer network to agree on how the Turing Machine states proceed in the global MerkleWeb.

MerkleWeb could work for other implementations of Turing Machines, but I chose a 256+64 bit address space because most computers work with address spaces, so existing technology could be mapped into this global address space bit for bit, like VMWare runs Windows with paravirtual optimizations for example, while some parts of the network would have to run at different speeds since network hops are slow and cpu cycles are fast, maybe some combination of darknets and global broadcasts. MerkleWeb is a general way to implement any kind of Turing Machine in a global peer to peer network and converge toward a consistent state continuously.

As I've defined it but not yet built it, MerkleWeb is a secure-but-not-perfect closure on Godel Numbering into 320 bits per Godel Number, a quine, and a peer to peer decentralized realtime practical global Turing Machine, where each Merkle Tree refers to specific values for each of 2^321 virtual bits which are used and combined as bloom filters to prove the system will converge exponentially fast toward consistent states except for the most recent few time cycles.

All my writing, here or anywhere else, permission granted to copy.
1480809724
Hero Member
*
Offline Offline

Posts: 1480809724

View Profile Personal Message (Offline)

Ignore
1480809724
Reply with quote  #2

1480809724
Report to moderator
Advertised sites are not endorsed by the Bitcoin Forum. They may be unsafe, untrustworthy, or illegal in your jurisdiction. Advertise here.
1480809724
Hero Member
*
Offline Offline

Posts: 1480809724

View Profile Personal Message (Offline)

Ignore
1480809724
Reply with quote  #2

1480809724
Report to moderator
1480809724
Hero Member
*
Offline Offline

Posts: 1480809724

View Profile Personal Message (Offline)

Ignore
1480809724
Reply with quote  #2

1480809724
Report to moderator
ElectricMucus
Legendary
*
Offline Offline

Activity: 1540


Drama Junkie


View Profile
November 28, 2011, 02:23:16 AM
 #2

Oh wow  Shocked

That is like the most awesome bitcoin sidekick project I've seen. Except that it is proposed to be written in java (which I don't like  Embarrassed)

First they ignore you, then they laugh at you, then they keep laughing, then they start choking on their laughter, and then they go and catch their breath. Then they start laughing even more.
BenRayfield
Sr. Member
****
Offline Offline

Activity: 262



View Profile WWW
November 28, 2011, 04:13:13 AM
 #3

Its not a Java system. I also gave VMWare and Windows as examples, but its not those systems either. I'm simply planning to implement a small prototype in Java since Java has a consistent specification document that its implementations obey, unlike C++ for example, and because most of my open source software http://sourceforge.net/users/benrayfield is converging toward a shared Java network infrastructure.

The best system for an implementation of MerkleWeb would be in a peer to peer network of a new kind of Turing Complete wireless network router, like the "mesh networks" that people are building to overcome censoring of their Internet and their rights to communicate (in words or in bits or any form of communication they choose).

A more advanced form of this network router would include a small machine that prints NAND gates onto silicon and automatically integrates them as permanent parts of its own circuits and maps them into the 320 bit global address space as a paravirtualization hook defined by the SHA256 hash of the NAND logic it implements. As that new 320 address is broadcast to everyone who it tends to be useful for, they will have the ability to take it apart, put it back together in more useful ways, and print it as it is or print their modified versions into their own hardware as NAND gates.

Its simple for MerkleWeb to calculate which NAND gates to print since its based on NAND logic from the start. Its a simple matter of counting which combinations of NAND occur in the public part of the Internet most often.

MerkleWeb is much more like Scheme than Java. The MerkleTrees are Continuations of the whole MerkleWeb or large parts of it, a more advanced kind of Continuation since its used statistically and in combination with many other Continuations flowing through MerkleWeb, a self-referencing harmony of mathematical precision.

EDIT: I've updated the http://sourceforge.net/projects/merkleweb description to:
Absolute minimalist open spec of whats needed to obsolete and rebuild entire Earth infrastructure, as global peer to peer 320 bit (256 space, 64 time) address quine Turing Machine, military-strength Bitcoin-like security on every bit and NAND calculation, from NAND gates, software NAND logic, recursive paravirtual hooks (run Windows, Mac, and Linux on global cloud through VMWare or other emulators) at paravirtual optimized realtime speed. Runs slowly on existing Internet. Best system would be wireless mesh network of new kind of Turing Complete routers. No system has an address. They're redundant computing power and storage for the 1 global Turing Machine. End to end branch prediction, global rollbacks, snapshots and SVN-like branching whole network, recalculation if 1 bit is found through NAND-level quine Godel-like error checking codes in Merkle Trees. Supports evolvable hardware as paravirtual hook into global address space of SHA256 hash of NAND definition of new hardware. Freedom.

"I wish I had a shilling for every senseless killing. I'd buy a government. America's for sale, and you can get a good deal on it, and make a healthy profit. Or maybe, tear it apart. Start with assumption, that a million people are smart, smarter than one." --NOFX, The Decline

With a global secure peer to peer Turing Machine and digital-signatures, we can trivially implement a global democracy. Counting votes becomes as simple as writing the code to loop over them and sum. Every bit and NAND calculation in MerkleWeb has military-strength security. The only errors, proven to exponential certainty using the Bitcoin security model at the bit and NAND level, are the errors we command the Turing Machine to create. We can command MerkleWeb to print "2=3", but that is our error, not the Turing Machine's error. In a world where "national security" is higher than Earth Security, we need an unbiased shared computing platform everyone can trust.

All my writing, here or anywhere else, permission granted to copy.
fivebells
Sr. Member
****
Offline Offline

Activity: 462


View Profile
November 28, 2011, 01:26:07 PM
 #4

I've read your original post a couple of times now, with great care.  It does not make sense to me.  I would like to understand it, though.  Here are a couple of questions:

1) What will the incentive to run this computation be, at a personal level?

2) How does the bloom filter, the Goedel framework, and the SHA256 hashing relate to arbitrary computation?

Your exposition would be a lot clearer if you presented a simple concrete example of a MerkleWeb in operation, showing step by step how it would perform some useful computation.  At this stage I simply have no idea how it would work or what merit it would have.
BenRayfield
Sr. Member
****
Offline Offline

Activity: 262



View Profile WWW
November 30, 2011, 04:30:32 AM
 #5

Quote
1) What will the incentive to run this computation be, at a personal level?

It would be the first unbiased secure global computer. There are many cloud and grid systems, but they are designed for specific hardware and/or specific tasks, and they're highly biased toward the advantage of whoever owns them. MerkleWeb would be everyone's shared computing platform. Since we all own it, the only cost of using the network (except for business systems that we may choose to access) is owning a computer or other device to hook into it. There would be no Internet Service Providers blocking our path to the Internet and charging us for access on the condition we agree to their legal terms. There would be no legal terms. Since we would all own it, there's nobody to ask for permission. That's if we do it as a wireless mesh network. We would start in an emulated version running on the existing Internet and later the existing Internet would be emulated on our shared global wireless grid.

There is 1 "killer app" that can only run on MerkleWeb: a global voting system through digital-signatures, everyone having their own private-key(s) like in Bitcoin, certified identities through certificate-authorities or "network of trust" decentralized algorithms, or anonymous like Bitcoin doesn't associate names with public-keys. Since the global computer would have military-strength Bitcoin-like security on every bit and NAND calculation, and this is all visible for peer-review, people could trust that their votes are counted correctly by a simple code to loop over them and sum for each thing voted on. Anyone could start a vote, which of course has military-strength security and hooks into shared public-key systems that we can build on top of the Turing Machine, not just to vote in people, but a vote on who we want to impeach or what we want to change. We could vote for or against legalizing marijuana, for example, and when we prove in a country or globally (or wherever the vote is) that a majority of people is for or against it, our "elected" leaders will have a very hard time justifying going against the will of the people, and if they continue to ignore majority agreement, they risk things like a much bigger Wall Street Protests that spreads globally in a much bigger way. They control us by telling us what we're allowed to vote on. We the people choose what to vote on. Democracy tells government what to do. Is freedom and democracy enough reason for people to help create and use MerkleWeb?

Eventually MerkleWeb would run video games and other software incredibly fast. We would set the "global heartbeat" interval to the clock rate of graphics cards, synchronize every billion cycles or whatever rate, backtrack and recalculate (only affected parts of the system) more often as a result, run grids of programmable GPUs 24 hours per day, and whoever is using MerkleWeb at the time gets some of that bandwidth.

We can do that because we don't have to verify every bit to prove to exponential certainty what those bits are. We just make sure enough bits at the end of a long sequence of GPU calculations match what everyone else expects, and if even 1 bit is unexplained in the whole MerkleWeb, it automatically backtracks only affected parts of the system (from the SVN-like versioning of the whole network based on continuous diffs, which is the normal way it works not the exception) and as much of the network as needed quickly recalculates, going down to the emulated NAND level if necessary to replace a calculation from a hardware that broke in the middle of a calculation.

Whats the personal incentive? Use huge grids of GPUs, like Bitcoin has for mining, as general purpose CPUs, to run all programs on MerkleWeb.

Quote
2) How does the bloom filter, the Goedel framework, and the SHA256 hashing relate to arbitrary computation?

That's just a way to synchronize the bit state of the system, of all 2^320 virtual bits. I didn't define which combinations of bits map to which NAND calculations because there are many ways to do it that work. Motherboards have address busses, access to specific parts of a memory stick, DMA memory mapping, cache levels, and many other systems. Its all NAND logic or calculations that can be derived from NAND. We first need to create a prototype address bus and CPU registers, but in more decentralized way that combines the ideas of CPU and memory and address bus into one kind of thing. After that is defined, then we get to use 256+64 bit numbers as addresses in the system of things to NAND, and using that ability we write the definition of the "CPU and memory and address bus into one kind of thing" that we used to build the "CPU and memory and address bus into one kind of thing", a quine. It has to be a Universal Turing Machine, a Turing Machine that comes with a data format of how to specify other Turing Machines for it to emulate, and we tell it how GPUs and other hardware works, SHA256 hash the NAND level description of the GPUs into a 256+64 bit address, and use that address as the name of that GPU logic, to be called from anywhere in the network like any other function in the system. We should start with a single function (that we first have to derive in a quine way, as I already explained about the whole system being a quine) that does a single NAND calculation. There are still lots of details to work out, but I've logically bounded the task enough to know it will run at practical speeds if we build the right hardware.

Quote
Your exposition would be a lot clearer if you presented a simple concrete example of a MerkleWeb in operation, showing step by step how it would perform some useful computation.  At this stage I simply have no idea how it would work or what merit it would have.

If we build it as a grid of GPUs and wireless mesh network, it would do everything the existing Internet does but better, in a unified address space. There would be no HTTP. There would be a 320 bit address you read and write like its in the same computer. VMWare Fusion, in unity mode, lets you run Windows and Macintosh programs side by side and copy/paste between them. Think of MerkleWeb as "unity mode" for the whole Internet.

All my writing, here or anywhere else, permission granted to copy.
jtimon
Legendary
*
Offline Offline

Activity: 1246


View Profile WWW
November 30, 2011, 07:45:49 AM
 #6

There is 1 "killer app" that can only run on MerkleWeb: a global voting system through digital-signatures, everyone having their own private-key(s) like in Bitcoin, certified identities through certificate-authorities or "network of trust" decentralized algorithms, or anonymous like Bitcoin doesn't associate names with public-keys.

I've been thinking about this lately, but I don't know how to do it without associating people to keypairs and making public everyone's vote.

Another service I understand merkleweb could perform is cloud and "trusted" computing. I mean I can run my program in google's app engine but I cannot tell for sure if google is really running my algorithm or a modification of it. Google could also do whatever he wants with the data of my application. After thinking a little about it, I came to the conclusion that what I wanted was impossible but maybe this merkleweb can do it.
I'm still skeptical but I haven't really understood how it works yet. I have to re-read the thread more carefully.

2 different forms of free-money: Freicoin (free of basic interest because it's perishable), Mutual credit (no interest because it's abundant)
markm
Legendary
*
Offline Offline

Activity: 1778



View Profile WWW
November 30, 2011, 07:58:39 AM
 #7

If you allow proxy voting as in "just count me down as voting the same way that guy there votes" then you could issue one babyvote per birth certificate issued and one per verified baby-who-turned-18 or whatnot, and simply not care who they (or their parents in the xcase of babyvotes maybe) end up passing along their proxy to. Hmm might lead to oligarchy though if you can't figure out which votecoin corresponds to which actual living person in order to cancel theirs when they die. SO might want to jsut put a time limit on it. Maybe issue decadeofvoting tokens that expire in a decade.

The main point being, blind them so you don't know nor care whether the entity it was issued to chose a republic style (voting for representatives intead of directly on issues, implemented in this simply by giving your vote to your "representative" to cast on your behalf as they please) or a democratic style (hold it yourself, cast it yourself, instead of giving it to a rep or trading it for a bowl of porridge or whatever).

Open Transactions planned voting system could maybe handle that kind of approach.

-MarkM-

Browser-launched Crossfire client now online (select CrossCiv server for Galactic  Milieu)
Free website hosting with PHP, MySQL etc: http://hosting.knotwork.com/
BenRayfield
Sr. Member
****
Offline Offline

Activity: 262



View Profile WWW
November 30, 2011, 09:43:53 AM
 #8

Instead of debating the details of which kinds of voting systems and ways to pair public-keys with people, and other parts of how a democracy could be built, and the balance between encrypted privacy (encryption is made of NANDs like all other software) and optimizations based on shared data structures, lets focus on how to give everyone the ability to experiment with many combinations of those things, and new kinds of interactions between people we've never thought of, and see which works best. Instead of focusing on who has how much power and who gets to control who else, lets work together globally to create a consistent model of how we all think the world works, how global power flows, why laws get created as a reaction to what other things, the game-theory and global strategy of it all, how science and psychology and all other paradigms fit together, into one model of how the world works that a majority of 7 billion people agree is close enough to how the world works. Then we decide what possible futures we the people prefer, and use the simulation/model of how the world works to find probable paths from where we are now to our preferred futures. Lets proceed scientifically instead of fighting through different ways to do politics. Life is a positive sum game. You don't have to lose for me to win. Lets find ways to increase the number of positive sum games in how the world works, like I did when I chose not to patent and sell this new kind of system design. Its public domain, an open specification for the world to work together.

As we know from stock markets, accuracy of prediction is a kind of money. If we can globally majority-agree on a simulation/model of how the world works, which repeatedly makes very accurate predictions of what happens next globally, we create a stock market of predictions of how the world will change. Money runs the world, in corporations and governments. If many buy stock in the prediction that a certain country will try to shut down their Internet, for example, that's something that wasn't allowed in the existing stock markets. They are limited to the fluctuating money values of businesses. I'm not saying it has to be a stock market of money. We can trade the value of predictions directly for the value of other predictions, or for Bitcoins or dollars or whatever other forms of value. With a global unbiased Universal Turing Machine for us all to experiment and communicate and design new ways of interaction and ways of organizing groups of people, the data-structures called "business" and "government" are going to have to justify their continued usefulness before we emulate in software all the useful things they do and they become consumers of our more accurate predictions of the world, unable to contribute anything within the constraints of their obsolete system, their effective power draining away like Bitcoin moved 100 million of value from dollars into bitcoins without putting in any money to get it. That is what a unified unbiased global system can do, and we haven't even got into what a grid of people wearing Emotiv Epoc mind reading game controllers, or other brain related technology, could do together.

The requirement for the cpu registers, address bus, memory, and other emulated hardware components, all combined into one kind of NAND based bit space instead of many separate components as computers are built today... the requirement for that to be a quine made of NANDs that generate their own definition in a loop, is very important. As a quine, it can rebuild itself if parts of it get broken or computers disagree on what kind of logic or state of the bits are in the system at any one 320 address (256 space and 64 time). When such disagreements occur ("11" bits in virtual 321 address space, at the leafs of some of the Merkle Trees in the constants section), the quines evolve and branch and merge like DNA duplicating itself, but as combinations of NANDs instead of A, C, T, and G molecules.

MerkleWeb, as I defined it, would be a http://en.wikipedia.org/wiki/Friendly_artificial_intelligence because of that quine and DNA-like evolution of the NAND logic which evolves toward global consistency of the whole system. It evolves toward exponential certainty of acting exactly as a Turing Machine, a normal computer. Its not even an AI in the normal definition of the word. In the SVN-like versioning and branching of the states (including computing states) of the whole Internet, disagreements between the computers of what the 1 global computer is doing must be solved somehow. I'm simply calling that process the AI, the blind no-intelligence backtracking to previous states of the system and emulating whats missing so the whole system can proceed. Bio evolution is blind and lacking intelligence too, but it evolved Human brains. It is a http://en.wikipedia.org/wiki/Friendly_artificial_intelligence because it has no goals of its own, no desire toward any specific outcome, except to be a Turing Machine and do whatever calculations we give it, and because it has exponential selection-pressure toward a globally consistent state of the system.


MerkleWeb has alot of potential, its power coming from simplicity of only supporting NAND and forming its cpu, address bus, memory, and/or a decentralized unification of those ideas from a quine of self-referencing NANDs. For example, since no system in the MerkleWeb network has an address (no HTTP, no IP address, nothing), it is theoretically possible as nanotechnology advances to run a "wireless mesh network" of computronium dust (as some science fiction has called nanotech wireless mesh networks), each particle of dust broadcasting a small part of the calculations to the near particles of dust, all solar powered to power their millimeter range wireless transmissions. I don't know how to build such hardware, but MerkleWeb would work on a planet tiled with such dust particles as well as bigger network routers and grids of GPUs. The algorithm, as I've logically bounded it to prove certain behaviors as it scales (while lacking some details within those bounds like what kind of address bus, if any)... the algorithm is nonlocal, exponentially error tolerant, and scale-free.

All my writing, here or anywhere else, permission granted to copy.
Mike Hearn
Legendary
*
Offline Offline

Activity: 1526


View Profile
November 30, 2011, 08:59:00 PM
 #9

I described the voting system referred to by markm some years ago, you can read it in this doc. It explains how to implement it:

https://docs.google.com/document/d/1jidmNJHWAtsPLCUD7EPPm8jOEV93kSXbZOMycqCWOyA/edit?authkey=CN7BnLUG

You could theoretically broadcast the votes and incorporate them into a block chain, but in practice I think nobody would accept a voting system that could be overridden or DoSd by a sufficiently powerful attacker. More likely, you would submit votes to several independent voting authorities who would then publish the votes they received publically. You could check your own vote appeared correctly. Problems would soon become apparent.
BenRayfield
Sr. Member
****
Offline Offline

Activity: 262



View Profile WWW
December 01, 2011, 02:22:57 AM
 #10

Ok lets compare voting systems (which is one thing you could build in MerkleWeb, since it will be a general computer)...

MerkleWeb, as I've technically defined it within certain logical bounds, can be trusted by average people because of 1 simple fact: There will never be 1 bit in the entire MerkleWeb, for the entire history and future of running MerkleWeb, calculated incorrectly unless it is the result of a weak secure-hash or digital-signature algorithm or a whole network running only incorrect implementations of MerkleWeb (all made by Hacker Joe's half-ass voting Incorporated) that someone claims to be a MerkleWeb but did not implement the specification to the letter. If 99% of a MerkleWeb is taken over by hackers, the remaining 1% will know this (since the use of their data causes at least 1 bit to calculate wrong in combination with local data that has been proven correct to exponential accuracy) and reject their offers of further data until they start obeying the MerkleWeb specification. If you trust SHA256 and your public-key and whoever created your specific MerkleWeb-compatible system to be secure, and you trust the state of the system you're starting from (which may have been loaded from a USB stick, for example), then MerkleWeb does not reduce that security. If your implementation of MerkleWeb correctly takes the time to verify enough of the past calculations, you don't have to trust the USB stick. If your implementation of MerkleWeb takes the time to create Merkle Trees of enough of the bits in the constants section (not just the Turing Complete area), then you don't have to trust SHA256 since its hashed bits are Merkle Treed from many angles at once. You may run Windows on a much later version of MerkleWeb and Windows gets hacked into, the same as it gets hacked into on a normal computer, but that is the exact correct behavior of Windows that MerkleWeb will emulate, exactly as the NAND/bit level description of Windows and the hardware Windows runs on says to do. If you don't want your computer to be hacked, run completely in MerkleWeb and use only programs built using correct math inside MerkleWeb. If you command MerkleWeb to let your section of the data be hacked into by anyone, MerkleWeb will do exactly that, down to the last bit of accuracy. If you command MerkleWeb, through the correct use of math and logic, to count 7 billion votes, it will give you the exact integer, and people can trust that integer as the number of global votes for a certain subject. This is all proven in the core logical design of MerkleWeb, as explained in my posts above in this thread.

The security of MerkleWeb is also enforced by the fact that MerkleWeb does not offer bailouts if you predict wrong. All affected calculations must be rolled back and recalculated, at the bit/NAND level if necessary, and recalculate everything after that that changes as a result, and so on. This risk of extreme cost of recalculating if something goes unnoticed for a long time is the necessary motivation for many computers in the network to redundantly and to exponential certainty verify that has not happened and keep looking over a few bits here and there in past calculations, to avoid an even bigger cost later from such a rollback and recalculation. When a rollback is done, nothing is lost. Both versions are kept, like you can have as many branches as you want in SVN, but the one thats rolled back becomes the more popular branch since its the correct calculation. The global economy crashed primarily because people think they'll get bailed out if they screw up too bad. MerkleWeb will let everyone pay the full price of their mistakes, so they're motivated to prove to exponential certainty such mistakes are found and fixed quickly and don't expand into bigger problems. For example, in USA the income tax was not voted in by enough states to pass, but through military force it was done anyways, and later the income tax was voted in, under threat, by the other states. If that was a calculation instead of politics, in MerkleWeb, rollback and recalculate from the "no income tax" state of the system, since it was not done by the rules of the system. No bailouts, like the government continuing to collect such income tax because its been going on for a long time. This is why MerkleWeb can be trusted to converge toward every bit being calculated correctly, because it doesn't just let things go if they're too hard to fix.

Your turn. Explain why we should trust that voting system or any other.

http://en.wikipedia.org/wiki/Sun_tzu
Quote
One of the more well-known stories about Sun Tzu, taken from the Shiji, illustrates Sun Tzu's temperament as follows: Before hiring Sun Tzu, the King of Wu tested Sun Tzu's skills by commanding him to train a harem of 180 concubines into soldiers. Sun Tzu divided them into two companies, appointing the two concubines most favored by the king as the company commanders. When Sun Tzu first ordered the concubines to face right, they giggled. In response, Sun Tzu said that the general, in this case himself, was responsible for ensuring that soldiers understood the commands given to them. Then, he reiterated the command, and again the concubines giggled. Sun Tzu then ordered the execution of the king's two favored concubines, to the king's protests. He explained that if the general's soldiers understood their commands but did not obey, it was the fault of the officers. Sun Tzu also said that once a general was appointed, it was their duty to carry out their mission, even if the king protested. After both concubines were killed, new officers were chosen to replace them. Afterwards, both companies performed their maneuvers flawlessly.

I'm not advocating violence. I work in very abstract indirect ways, looking for the causes of the causes... which is what led me to understand to the need for MerkleWeb. If Sun Tzu was alive today, I doubt he would use any violence, since there are so many other tools available to change the world. The same general strategy as in that quote, is MerkleWeb's strategy for causing programmers not to write bugs and junk software, and that way MerkleWeb, a later version running on huge grids of GPUs and wireless mesh networks at incredible speeds, will have so few rollbacks/recalculates that we can make effective and simultaneously secure use of the advanced technology we waste today.

Similarly, once MerkleWeb and many competing global voting systems (which people choose to use) are up and running, and we point the world's attention to whichever few specific politicians or corporations are majority-agreed to deserve such an investigation into their possible crimes, and after we continue that until finding a few who really are guilty of serious crimes and under public view they actually go to jail for it and don't get to buy their way out, then most of the other criminals in governments and corporations will start obeying the laws that we the people choose through democracy, not they choose through buying laws. One of the most useful things we can build on MerkleWeb is a system that, through directing public attention at what a majority of people agrees on (which we can trust as real democratic agreement since criminals can't hack into it like the existing Internet), makes everyone accountable. In a real democracy, people would celebrate the laws and ways government works, because it would be only what a majority of us prefers it to be.

So lets make it happen... This is what I could use help designing:

Quote
The requirement for the cpu registers, address bus, memory, and other emulated hardware components, all combined into one kind of NAND based bit space instead of many separate components as computers are built today... the requirement for that to be a quine made of NANDs that generate their own definition in a loop, is very important. As a quine, it can rebuild itself if parts of it get broken or computers disagree on what kind of logic or state of the bits are in the system


Like in Bitcoin, its very easy to verify the network is what you think it is if at least half the computers are honestly doing the Bitcoin protocol (and even if its less than half the majority attackers still can't change the Merkle Trees you already have and trust), but for MerkleWeb half isn't good enough. I need it to work even if all the other computers in the network are creating fake data to fool us (in that case, we would have to emulate all the data locally, very very slowly), data that overlaps local real data by design of them knowing that from our broadcasts, but with full access to the entire history of every bit in the network (stored part as literal bits and part as NAND definitions of the emulation that calculates between such partial snapshots, so emulation is used as a kind of compression in MerkleWeb, since you can always emulate a past state again), in the Turing Complete environment, its certain that there are many ways to ask a question that costs you little to ask and verify the answer but costs an attacker exponentially more time, or up to the size of the whole network in bits including its history (which is impractically large, and its a scale-free algorithm so its exponential cost), to answer since the attacker does not know which parts of the network you've been calculating from the various parts of the network you receive and continue calculations on, including combinations of them. If you have a Merkle Tree leading to a certain bit in the network, then you also have a way to trace that bit back, one NAND at a time, to the start of the whole network. There's also the ability to define arbitrary functions, do SVN-like branches of the network where such functions were run, and make Godel-like statements (see the 00, 01, 10, and 11 leaf codes about bits in the first post of this thread) about the return values of those functions, and we could also make Godel-like statements about other Godel-like statements since the constants section where they're located (in Merkle Trees) is addressable the same as everywhere else. Certainly we can get the proof of exponential certainty (but not Godel-like certainty, unless we locally compute the entire network from the start which is an option for small networks) that the network is what we think it is, but the question is how deep into abstraction and game-theory we have to go to prove it for each new MerkleTree (including its childs recursively how deep?) we accept as having an exponential proof that its accurate.

All my writing, here or anywhere else, permission granted to copy.
jtimon
Legendary
*
Offline Offline

Activity: 1246


View Profile WWW
December 02, 2011, 11:10:42 AM
 #11

I've been reading the proposal again but I still don't get it.
I know Godel, Turing and Merkle but I'm getting lost in your long explanations.
Can you post a summary without design details such as the size of the addresses?
Only to have a general idea about how this would work.

If this can really work, its implications are probably much bigger than bitcoin's.
A decentralized computer which its users can trust (unlike the cloud) to execute the algorithms they want but without making public its internal state at every step.

Maybe by just explaining how the voting application would work helps.
How do you prevent the authority that provides the certificates from knowing what each person have voted?

I want to believe, but I can't.

2 different forms of free-money: Freicoin (free of basic interest because it's perishable), Mutual credit (no interest because it's abundant)
markm
Legendary
*
Offline Offline

Activity: 1778



View Profile WWW
December 02, 2011, 01:54:22 PM
 #12

The novel "When H.A.R.L.I.E. was one" by David Gerrold seems very relevant to where this has been going.

18,000 stacked feet of printout for the board members to read in preparation for the upcoming board-meeting detailed the proposal for how "Human Analogue Robot Logic Induction Engine" could be useful (thus shouldn't have its plug pulled) by programming faster/better than human programmers predictive programs taking into account every verifiable fact ever verified, basically. (And of course proceeding on from that to every verifiable fact that ever will be verified, when it will be verified, who by, and what would that cause, etc etc the usual.)

Was there a "catch"? Read the novel and see... Wink

-MarkM-

Browser-launched Crossfire client now online (select CrossCiv server for Galactic  Milieu)
Free website hosting with PHP, MySQL etc: http://hosting.knotwork.com/
BenRayfield
Sr. Member
****
Offline Offline

Activity: 262



View Profile WWW
December 05, 2011, 01:00:22 AM
 #13

jtimon
Quote
I'm getting lost in your long explanations.
Can you post a summary without design details such as the size of the addresses?
Only to have a general idea about how this would work.

If you have a computer and software running on it that you trust both of (and you should never trust the existing infrastructure since getting hacked into now and then is accepted as an inevitable part of that system), then you could connect from that system into a MerkleWeb network by running a MerkleWeb server on that computer which you use as a proxy, through some local port, like through a web browser's proxy settings in the advanced options. You would put your private key(s) in that one MerkleWeb server, and it would digitally-sign everything you broadcast to MerkleWeb. It could also be done through a USB wireless network router we would design just for MerkleWeb, which would come with its own private-key/public-key pair built into the hardware and just work in any computer you trust which you plug it into. If there is a virus in that computer, it will have full control over what you do in MerkleWeb. MerkleWeb will not make existing technology more secure. Its a platform for building secure technology on top of which you may choose to access using less secure technology at your own risk, like Bitcoin is very secure but not if you run it on Windows and that virus designed just for stealing bitcoins gets onto your Windows. That virus can't infect the Bitcoin network, but it can infect your Windows and get to your bitcoins and nobody else's.

Quote
Maybe by just explaining how the voting application would work helps.
How do you prevent the authority that provides the certificates from knowing what each person have voted?

If you want PRIVACY in voting, a simple Bitcoin-like network could be setup inside MerkleWeb for that, or just use Bitcoin, to distribute voting credits (votecoins) to everyone who is allowed to vote on a specific question, and then spend their votecoins toward whatever they want to vote on. Its actually simpler than Bitcoin since you can only spend a votecoin once. Nobody needs to know the identity of who spent a votecoin to count the votecoins for each subject. The part of that Bitcoin will not do is distribute the votecoins to whoever they need to go to before the vote, and to set up various things to vote on. For tasks like that, and the other complexities that will come from the new society we're building in the Internet, a global secure peer to peer Turing Machine (general computer) is what we need.

MerkleWeb supports the NAND operation since all other logic can be derived from it. For PRIVACY, write an existing encryption algorithm (after making sure laws in your country allow that) as combinations of NANDs, and run part of MerkleWeb on top of that encryption layer, encrypted with your private key at the root of the encryption tree and form some complex network of encryption keys so while its all out in the open nobody except you can track down where all the encryption is coming from and going to... kind of like the Tor network, you could build depending on how much privacy you need. MerkleWeb doesn't care what software you run. Its only goal is to make sure its all globally consistent and the NAND calculations work. The calculations to hook in the public-key security (for digital-signatures) are also built on NAND calculations. All this can be optimized if hardware is available that does those exact NAND calculations, as we will find ways to align hardware and software after MerkleWeb is up and running and we can experiment with it. Its a Universal Turing Machine. It can calculate anything.

The whole MerkleWeb would be deterministic, and therefore highly optimizable, except for CHOICE BITS, which are where people connect into the system. Those bits can be 0 or 1, and can be proven only by the digital-signature associated with each group of choice bits. Choice bits slow the system down incredibly, so they should be compressed and used as little as possible.


markm, if you don't want to be predicted, go live by yourself deep in the woods. Getting to know someone means to predict them, and when they're gone you predict them but do not find the expected behavior, therfore you "miss" them, your prediction misses its target.

It will never get to the level of "every verifiable fact that ever will be verified, when it will be verified, who by, and what would that cause". Godel proved that's impossible.



Some technical stuff...

Since my design requirement is that MerkleWeb will still be secure even if 99% of the computers have been hacked into, I add the following to the MerkleWeb specification: All computers will lie in half of their broadcasts. Half will be what each computer honestly thinks is accurately part of the next state of MerkleWeb. The other half will be very close to that except it will have some bit, or multiple bits, set incorrectly, in a way that is very deceptive and hard to verify is wrong. That way, when a hacker gets into MerkleWeb, its no big deal, since all of MerkleWeb is already doing the same thing, has been expecting it and learned to overcome it.

Why would that work? Each contradiction added to a branch (like SVN has recursive branching) of MerkleWeb causes that branch to run anywhere between normal speed and half speed. On average, as the number of contradictions in a branch of MerkleWeb increases linearly, the speed of that branch will decrease exponentially.

So its simple to figure out which branches of MerkleWeb have contradictions... broadcast half of your communications honestly and the other half having some hard-to-detect error, and see which of your communications come back to you after they've flowed around the network for some time. Statistically more often, trust the communications that come back with your honest broadcasts, and distrust communications that come back with your dishonest broadcasts, because dishonesty will be exponentially time-dilated until it falls into a black-hole of contradictions that can't be calculated at any practical speed. In MerkleWeb, hackers fall into black-holes of time-dilation.

MerkleWeb can only practically verify calculations that have an effect on the future state of the system, so the security does not cover "quantum eraser" type of interactions. Because of the requirement to backtrack all observed contradictions, MerkleWeb will reproduce the behaviors of the "quantum eraser" and "delayed choice quantum eraser" experiments in quantum physics, but for Turing Machine calculations instead of quantum physics specificly, where calculations flow in waves, and have wave-interference with eachother, through hops in the network.

http://en.wikipedia.org/wiki/Double-slit_experiment#Delayed_choice_and_quantum_eraser_variations

Calculations that use pointers that access parts of the system farther away than the speed of network wires (which is limited by the speed of light) allows, risk backtracking to solve any resulting contradictions. As long as such calculations have been designed to keep the whole network consistent, there will be no resulting backtracking. But as CHOICE BITS move near the speed of internet wires (or the speed of light) their mass (total calculations needed to solve resulting contradictions) increases to infinity, they experience time dilation, and the whole network slows down to handle the increase in global contradictions, therefore MerkleWeb will put selection-pressure on the ideas of programmers to not slow the network down like that, to create consistent programs that do not move CHOICE BITS near the speed of internet wires. Relativistic speeds of CHOICE BITS are handled the same way as hackers. They time-dilate and fall into black holes, and faster branches of MerkleWeb continue without such inefficiency.

Network routing will be handled by statistical clustering of which parts of the program tend to affect which other parts of the program (whatever is running on the global Turing Machine), in a way thats kind of like holographic entropy-based gravity. As the NAND calculations and bit states of the system representing such NAND calculations propogate outward in circles (light cones) through network hops, and inward on those same circles, and back and forth in bell-curve patterns, any 2 parts of the program that are near but should become closer, will have their circles of influence overlap as they spread, so that information will come to the attention of other computers in the network at about the same time, first X then Y on the left side, and first Y then X on the right side, and as it reflects back toward the center, the holographic pressure will push them either toward eachother or apart, depending on their NAND relationships. I you sum 100 numbers which are each -1 or 1, then the standard deviation is 10, the square root of 100. Its the same thing how the circles of influence get bigger and smaller at the same time just by mostly random movements of the data transmitted. That's all I meant by holographic.

These behaviors, in this analogy between MerkleWeb and quantum and relativistic physics, are not extra parts of the system. They are what I expect from the simple NAND design as it applies to network hops in a peer to peer network as they try to synchronize the state of MerkleWeb globally. Its still the simplest nanokernel design, without 1 extra bit of complexity. Maybe physics also formed through very simple processes.

All my writing, here or anywhere else, permission granted to copy.
jtimon
Legendary
*
Offline Offline

Activity: 1246


View Profile WWW
December 05, 2011, 10:41:02 AM
 #14

Thank you. Not sure but I think I understand it better now.

For the decentralized voting, the anonymity is still a problem. Whoever distributes the votecoins can know exactly what each participant votes. I still don't see a way around it.

2 different forms of free-money: Freicoin (free of basic interest because it's perishable), Mutual credit (no interest because it's abundant)
markm
Legendary
*
Offline Offline

Activity: 1778



View Profile WWW
December 05, 2011, 03:51:12 PM
 #15

Nice exposition, thanks.

If you can find G. Spencer Brown's "Laws of Form" see if you can read it and make sense of it.

It is an excellent extremely minimalistic "form" that treats the empty page as "or" and "the mark" (the label, the distinction, that which makes distinguishable marks upon the page, that which is distinguishable from the emptiness that is take as "or") is taken as "not".

Thus if we use "being in parentheses" as "the mark", (a) (b) would represent (not a) or (not b).

He proves that all lemmas can be stated in forms not more than two deep, such as ((a)(b)).

It is a very useful notation because you can cancel things out very easily, and all that remains is the solution to the lemma.

It uses not and or instead of not and and so I guess would be using nor gates instead of nand gates, but any two such primitives suffices, its like whether to use one or zero as true or false, or whether to use NPN or PNP transistors maybe in a way. Anything that can be represented using one can also be represented using the other.

Its a pretty small book but very amazing contents, I expect you will find it quite interesting if it is not already part of the bread and butter that got your this far already.

-MarkM-

Browser-launched Crossfire client now online (select CrossCiv server for Galactic  Milieu)
Free website hosting with PHP, MySQL etc: http://hosting.knotwork.com/
PLATO
Sr. Member
****
Offline Offline

Activity: 277


Subversive


View Profile WWW
December 08, 2011, 01:50:16 AM
 #16

re: voting,

if a trusted third party is willing to sign your key to prove that you're a human being, you can participate in a particular vote. (i.e. the US govt (or my company) can have a known key. they sign your key. you authenticate to the voting server by decrypting a gpg-encrypted challenge string, proving ownership of your private key. if the government's key signature checks out, you're allowed to vote.
Gavin Andresen
Legendary
*
Offline Offline

Activity: 1652


Chief Scientist


View Profile WWW
December 08, 2011, 03:13:07 AM
 #17

Neat idea!

I don't get the economics of it, though-- how do I convince the network to run/check the calculations I want the MerkleWeb to run rather than somebody else's?  And does anything prevent me from asking the MerkleWeb to do some useless busy-work that is just designed to chew up computing resources? Who decides what gets run on the Turing machine, when?

How often do you get the chance to work on a potentially world-changing project?
jtimon
Legendary
*
Offline Offline

Activity: 1246


View Profile WWW
December 08, 2011, 10:57:13 AM
 #18

re: voting,

if a trusted third party is willing to sign your key to prove that you're a human being, you can participate in a particular vote. (i.e. the US govt (or my company) can have a known key. they sign your key. you authenticate to the voting server by decrypting a gpg-encrypted challenge string, proving ownership of your private key. if the government's key signature checks out, you're allowed to vote.

But the voting is still public and the third party knows who owns which keys.
So the third party knows what each individual has voted.

2 different forms of free-money: Freicoin (free of basic interest because it's perishable), Mutual credit (no interest because it's abundant)
markm
Legendary
*
Offline Offline

Activity: 1778



View Profile WWW
December 08, 2011, 12:44:11 PM
 #19

The vote tickets could be blinded cash, so the issuer can tick off that a ticket has been used to prevent its being re-used but cannot tell which issued ticket it was that just got ticked off.

Thinking about Laws of Form's representation where the default/empty space is take as or, compared to your NOT and AND system (NAND), I wonder if your representation would basically have space be taken as AND.

A possible advantage of OR over AND might be that if the nearby data for the OR is true, you don't care about the far away part, you can proceed in the knowledge that regardless of what the far away part says, the OR evaluates to TRUE, so you can go ahead without waiting to hear what the actual value of the far away part is.

With AND, if your nearby data input for it is FALSE you know the whole thing is FALSE, but unless your goal is to pursue falseness in preference to pursuing truth, that might not be as useful as being able to proceed on the basis of TRUTH.

That might end up with everyone having to pose all important questions to your universal machine in terms that make FALSE be the important result they are hoping for / pursuing.

Basically just a semantic thing but I think aesthetically a system designed to optimise the pursuit of truth might sound more appealing than a system that optimises the pursuit of falseness?

Hey, maybe run two universal turing machines, one built the Laws of Form way to pursue truth, another built your way to check the results / error-correct by pursuing falseness?

Maybe its all just semantic, afterall one could just reverse true and false any time one displays values/results to humans? Hmm...

Maybe space taken as OR and space taken as AND differ in "timelike versus spacelike" way(s)?

-MarkM-

Browser-launched Crossfire client now online (select CrossCiv server for Galactic  Milieu)
Free website hosting with PHP, MySQL etc: http://hosting.knotwork.com/
BenRayfield
Sr. Member
****
Offline Offline

Activity: 262



View Profile WWW
December 15, 2011, 06:10:29 AM
 #20

For the decentralized voting, the anonymity is still a problem. Whoever distributes the votecoins can know exactly what each participant votes. I still don't see a way around it.

Encryption is made of NAND calculations, like everything else. MerkleWeb will also support private-keys that are not stored in the system (for digital-signatures, like in Bitcoin). My intuition is that some recursive combination of those will be able to generate privacy algorithms, but we'll have to think about it.

MerkleWeb will support emulators inside emulators to unlimited depth, with paravirtual optimizations (like VMWare uses to speed up emulated Windows for example). Recursive emulation levels will be as easy and efficient as recursive function calls since its designed in from the start. This is an unprecedented level of emulation flexibility. I think we can figure out a way to have privacy with the bottom layer of bits and NANDs being visible to everyone.

Even if it turns out MerkleWeb can't support any kind of privacy, isn't it better to have a working unhackable peer to peer voting system where everyone can see your private-key's votes, than a private vote where we have to trust governments with our votes and to tell us what we're allowed to vote on?


If you can find G. Spencer Brown's "Laws of Form" see if you can read it and make sense of it.

It is an excellent extremely minimalistic "form" that treats the empty page as "or" and "the mark" (the label, the distinction, that which makes distinguishable marks upon the page, that which is distinguishable from the emptiness that is take as "or") is taken as "not".

Thus if we use "being in parentheses" as "the mark", (a) (b) would represent (not a) or (not b).

He proves that all lemmas can be stated in forms not more than two deep, such as ((a)(b)).

It is a very useful notation because you can cancel things out very easily, and all that remains is the solution to the lemma.

My intuition is http://en.wikipedia.org/wiki/Laws_of_Form is closely related to NAND and MerkleWeb's core design, but I'll wait until I read more about it before answering your posts.

In a zen way, I think the kolmogorov-complexity http://en.wikipedia.org/wiki/Kolmogorov_complexity of the universe is 0. That means the universe contains no information overall, but every smaller subset of it contains information. "All integers" has more integers and less information than "all integers except 42". Similarly, the universe overall can contain less information than its parts individually. "The kolmogorov complexity of the universe is 0" is the simplest way to say the universe is all possibilities you can write in math, so its equal to Max Tegmark's "Mathematical Universe Hypothesis" (also known as Ultimate Ensemble multiverse theory).

In the Laws Of Form, "The kolmogorov complexity of the universe is 0" is the "void", "unmarked state", and "nothing". I also call it "unity". Its simultaneously everything (all possibilities you can write in math) and nothing since "everything" and "nothing" are isomorphic except for the labels "everything" and "nothing", and labels don't change content, so they equal. This is the fundamental paradox of all reality. laws_of_form_cross(laws_of_form_void) means everything except laws_of_form_void, but since unity (kolmogorov complexity 0) is simultaneously everything and nothing, everything except laws_of_form_void equals laws_of_form_void.

That's why consciousness exists. Consciousness (or call it the experience of reality or quantum wavefunction) is laws_of_form_cross, and unity (kolmogorov complexity 0) is laws_of_form_void. Supporting that view is this quote from Wikipedia and the book:

Quote
The Cross can be seen as denoting the distinction between two states, one "considered as a symbol" and another not so considered. From this fact arises a curious resonance with some theories of consciousness and language. Paradoxically, the Form is at once Observer and Observed, and is also the creative act of making an observation. LoF (excluding back matter) closes with the words:

"...the first distinction, the Mark and the observer are not only interchangeable, but, in the form, identical."

These kind of thoughts are what led me to understand the need for MerkleWeb, but I think we should make it a little less abstract than that and stick with NAND calculations since that's what all digital technology is built on, or calculations that can be derived from NAND.

Using only NAND and local broadcasts of the many MerkleTrees representing the best known state of the system (from each local point of view, spreading out like "light cones"), it is flexible enough to represent Russel's Paradox http://en.wikipedia.org/wiki/Russel%27s_paradox which is basically "does [the set of all sets that do not contain themself] contain itself?" If it contains itself, then it must not contain itself, but if it does not contain itself, then it must contain itself. MerkleWeb could represent Russel's Paradox as a mobius shape of logic flowing through the network, which would kind of quantum-collapse and rollback to a consistent state of the system when the paradox is observed, flowing rollbacks back on mostly the same paths they proceeded so you get a "delayed choice quantum eraser" effect or something similar to it (wave-interference comes from disagreements on which bits are 0 and 1, especially from the way computers test eachother with fake bits sometimes), as a side-effect of the way NAND logic flows through the network and not as an extra part of the system. In terms of Feynman paths, all paths through the network are taken by all data, except when branches are pruned off the Merkle Trees or ignored because they're too deep, so MerkleWeb is most similar to the Copenhagen interpretation of quantum physics (which I don't like since in a zen way I think manyworlds multiverse theory is true instead, but Copenhagen could be an approximation of manyworlds). While it has some similarities to quantum physics, it does not give quantum-like computing speed advantages since all possibilities would have to be calculated (with some overlapping optimizations) up to the depth before wavefunction collapse (SVN-like branching of whole state of the network). In any case, its only NAND logic flowing in complex patterns through the Internet.


re: voting,

if a trusted third party is willing to sign your key to prove that you're a human being, you can participate in a particular vote. (i.e. the US govt (or my company) can have a known key. they sign your key. you authenticate to the voting server by decrypting a gpg-encrypted challenge string, proving ownership of your private key. if the government's key signature checks out, you're allowed to vote.

I don't see why we should involve governments in our elections. Democracy tells government what to do. Lets set up our own elections through the MerkleWeb secure global computer, figure out what people agree on in a way people can trust the free open source system, and then together we tell governments to do their jobs which is whatever democracy tells them to do.

MerkleWeb is not about any specific computing task or kind of elections, but you can build what you said if you like. MerkleWeb will be a general computer that runs on a network. Its about giving people an open source unbiased secure computing platform they can trust so we can experiment with many kinds of election systems and other ways of organizing the world.

For now, its more important to help design the low level details of the system than to speculate about what kind of voting systems people will build on top of it.


Neat idea!

I don't get the economics of it, though-- how do I convince the network to run/check the calculations I want the MerkleWeb to run rather than somebody else's?  And does anything prevent me from asking the MerkleWeb to do some useless busy-work that is just designed to chew up computing resources? Who decides what gets run on the Turing machine, when?

All calculations that run will be checked. Each MerkleWeb network will have the appearance of being single-threaded for the whole network while actually being massively multithreaded and using rollbacks of the relevant bits when predictions fail. Any contradictions cause recursive rollbacks to a state of the system where no contradictions exist. The calculations MerkleWeb will do will be well-defined.

The only way to convince MerkleWeb to calculate anything different is with "choice bits" (as I wrote above), which are kind of like network ports mapped into certain global 320-bit addresses. Each choice bit can only be written by a certain private-key. Each group of choice bits has a public-key that everyone can see to verify the digitally-signed bits from the private-key.

The ways we allocate computing power will have the flexibility of a Turing Machine. Each MerkleWeb network will need to have some kind of driver written to do such allocations, written on top of the NAND and bit level.

We could, for example, allocate global calculating power and memory through Bitcoin. Since MerkleWeb is based on a variation of the Bitcoin security model, we could map Bitcoin's existing history and user accounts into MerkleWeb's 320 bit global address space (in the constants section "Name constants by their SHA256 secure-hash" and 2^64 minus their bit length). It would be many small Bitcoin transactions, except running much faster than the existing Bitcoin network since no "proof of work" is needed. Instead, large amounts of actual work (NAND calculations and large functions made of NANDs) are verified by all computers sometimes throwing in some incorrect bits to see who catches their intentional mistake ("will have some bit, or multiple bits, set incorrectly, in a way that is very deceptive and hard to verify is wrong"). I said they will do that half the time, but that may be too much. We can tune it after its up and running and based on statistical proofs.

The simplest way to control MerkleWeb is a democracy of computing power can opt-out of any calculation they don't like by choosing not to continue that branch. MerkleWeb will be a SVN-like versioning and recursive branching system for all calculations and computing states and memory states of the whole network, at the bit and NAND granularity, storing snapshots of the bits sometimes but mostly using emulation as compression, since if you know a past state and the NAND definition of how calculations proceed, you can calculate the next states, and combine calculations between branches that have overlap or similarity through some translation function (It's Turing Complete), and get compression ratios so high they can only be expressed in scientific notation. This is possible because a Turing Machine compresses down to its state transition definitions and the data it starts with, regardless of how complex a program it becomes. Also, we must store the "choice bits" since they aren't necessarily deterministic.

The democratic opt-out ability through the SVN-like versioning and branching at the bit and NAND level is our protection for if anything goes wrong. We can always restore MerkleWeb to any previous state, unless we choose to not store (with unprecedented levels of compression as I explained above) all previous states.

The best way to keep the system consistent may be to create a simulation of the existing Internet infrastructure, not the whole thing but just the NAND behaviors of the routers and the distance and bandwidth of routers to other routers in a directed network, and to cap their bandwidth and delay others to keep everything running at the "global heartbeat" speed, because it has to be completely deterministic except for choice bits. By simulating the real bottlenecks, we can avoid allowing software to try to jump around faster than light through the real infrastructure, which would very much slow the system down as the real light speed limit is what happens and up to the rest of MerkleWeb (only the parts that affect or can be affected by the calculations that jump around too fast) gets time-dilated, but a least its 1 consistent system and we get the SVN-like versioning and branching and global security. As we create hardware designed specificly for MerkleWeb, we advance past those bottlenecks and don't need to simulate the bottlenecks anymore. We would instead simulate something more similar to light-cones representing the maximum speed light can move between routers in a wireless mesh network, more like a peer to peer liquid than a hierarchy with an Internet backbone. These are the physical constraints any software must obey.


To everyone...
MerkleWeb is a new idea and I'm figuring out the details as I go. Please help unify our technology and ways we organize the world by contributing your ideas to the MerkleWeb public-domain where everyone has the right to use them.

Theres lots of money to be made in creating "unity mode" for the whole Internet (VMWare got rich on single-computer operating systems, while MerkleWeb will be a seamless network nanokernel operating system), and like Bitcoin, MerkleWeb will be a mix of business and free open source (including GNU GPL software since it has an operating system exception) systems, but nobody will ever have to pay to join MerkleWeb since the core idea is open source.

If you want to help, the first steps are to implement integer math, 320 bit addresses, virtual CPU operations, address bus, virtual memory storage, peer to peer link layer transport strategies, and all through a quine of NAND logic that defines itself as a bit string in the constants section. The quine self-definition will be done the same way as "Supports evolvable hardware as paravirtual hook into global address space of SHA256 hash of NAND definition of new hardware." We have to keep it absolutely as simple as possible, or it won't work. NAND is already extremely complicated to do in a global network this way.

Anyone who has lots of money invested in Bitcoin should be selfishly interested, in a long-term way, to help the MerkleWeb project succeed, since its very similar to Bitcoin while much more flexible in what it can calculate (Turing Complete), so if MerkleWeb succeeds then Bitcoin will extremely increase in value and probably transform the global economy into mostly different kinds of cryptocurrencies, finally defeating the central banks' bottleneck on the Human species' progress.

If you want to improve the world and make lots of money in the process, MerkleWeb is a good long-term investment. I'm not taking a cut. Its public-domain. Will you help?


Also, in my meetup group http://meetup.com/Technology-Singularity-Detonator in Silicon Valley, I'm including debates and technical talks and hopefully later prototype development of MerkleWeb (and my AI research). Its only 21 people so far, and only a few have come, but its slowly expanding.

All my writing, here or anywhere else, permission granted to copy.
Pages: [1] 2 3 »  All
  Print  
 
Jump to:  

Sponsored by , a Bitcoin-accepting VPN.
Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!