From 04bcd31ea3b589f32ad2ed66a6a682324e04a80a Mon Sep 17 00:00:00 2001 From: Vitalik Buterin Date: Thu, 27 Aug 2015 09:38:48 -0400 Subject: [PATCH] Made binary by-block consensus work --- casper/casper.py | 437 ++++++++++++++------------------------ casper/distributions.py | 9 +- casper/networksim.py | 6 +- casper/voting_strategy.py | 86 ++------ 4 files changed, 185 insertions(+), 353 deletions(-) diff --git a/casper/casper.py b/casper/casper.py index 4f04209..f89c054 100644 --- a/casper/casper.py +++ b/casper/casper.py @@ -2,9 +2,14 @@ import copy, random, hashlib from distributions import normal_distribution import networksim from voting_strategy import vote +import math NUM_VALIDATORS = 20 -BLKTIME = 100 +BLKTIME = 40 +BY_CHAIN = False +NETSPLITS = False + +GENESIS_STATE = 0 logging_level = 0 @@ -15,17 +20,16 @@ def log(s, lvl): class Signature(): - def __init__(self, signer, probs, height, last_finalized): + def __init__(self, signer, probs, finalized_state, sign_from): self.signer = signer # List of maps from block hash to probability self.probs = probs - # Top height of the signature - self.height = height - # The HashChainObj that represents the last finalized hash - # of this signature - self.last_finalized = last_finalized # Hash of the signature (for db storage purposes) - self.hash = random.randrange(10**14) + 10**14 * self.height + self.hash = random.randrange(10**14) + # Finalized state + self.finalized_state = finalized_state + # Finalized height + self.sign_from = sign_from class Block(): @@ -35,73 +39,27 @@ class Block(): # The height of the block self.height = height # Hash of the signature (for db storage purposes) - self.hash = random.randrange(10**20) + 10**20 * self.height + self.hash = random.randrange(10**20) + 10**21 + 10**23 * self.height -# An object containing the hash of a block and the hash of a previous -# hash chain object. These objects end up forming the actual "blockchain" -# in this scheme -class HashChainObj(): - def __init__(self, block, prev): - # Genesis hash chain object - if block is None: - self.hash = 0 - self.prev = None - self.blockhash = None - # All other hash chain objects - else: - self.hash = (prev.hash ** 7 + block.hash ** 3) ** 5 % 10**30 - self.prev = prev.hash - self.blockhash = block.hash - - -# A request for info from a node that needs to synchronize after a period -# of being offline from the network -class SyncRequest(): - def __init__(self, sender): - self.sender_id = sender.id - self.last_finalized_height = sender.max_finalized_height - self.hash = random.randrange(10**10) - - -# A response to a sync request -class SyncResponse(): - def __init__(self, blocks, signatures, finalized_chain, requester_mfh, responder_mfh, responder_hashchain): - self.blocks = blocks - self.signatures = signatures - self.finalized_chain = finalized_chain - self.requester_mfh = requester_mfh - self.responder_mfh = responder_mfh - self.responder_hashchain = responder_hashchain - self.hash = random.randrange(10**10) - - -# A request to get an object with a particular hash -class ObjRequest(): - def __init__(self, sender, ask_hash): - self.sender_id = sender.id - self.ask_hash = ask_hash - self.hash = random.randrange(10**10) - - -# A response to an object request -class ObjResponse(): - def __init__(self, obj): - self.obj = obj - self.hash = random.randrange(10**10) +def state_transition(state, block): + return state if block is None else (state ** 3 + block.hash ** 5) % 10**40 # A validator class Validator(): def __init__(self, pos, network): - # Map from height to { blocks: blocks, signatures: signatures } - self.heights = {0: {"blocks": {}, "signatures": {}}} + # Map from height to {node_id: latest_opinion} + self.received_signatures = [] + # List of received blocks + self.received_blocks = [] + # Own probability estimates + self.probs = [] # All objects that this validator has received; basically a database self.received_objects = {} + self.time_received = {} # The validator's ID, and its position in the queue self.pos = self.id = pos - # Heights that this validator has already signed - self.signed_heights = {} # This validator's offset from the clock self.time_offset = max(normal_distribution(200, 100)(), 0) # The highest height that this validator has seen @@ -109,142 +67,58 @@ class Validator(): self.head = None # The last time the validator made a block self.last_time_made_block = -999999999999 - # Block hashes of finalized blocks - self.finalized = [None] # The validator's hash chain - self.finalized_hashes = [HashChainObj(None, None)] + self.finalized_hashes = [] + # Finalized states + self.finalized_states = [] # The highest height that the validator has finalized - self.max_finalized_height = 0 + self.max_finalized_height = -1 # The network object self.network = network + # Last time signed + self.last_time_signed = 0 + # Next neight to mine + self.next_height = self.pos + + def get_time(self): + return self.network.time + self.time_offset def sign(self, block): - # Calculate this validator's (randomly offset) view of the current time - mytime = now[0] + self.time_offset - offset = (mytime - (block.maker * BLKTIME)) % (BLKTIME * NUM_VALIDATORS) - # Iniitalize the probability array, the core of the signature - probs = [] - # Compute the validator's opinion of the latest block, based on whether - # or not it arrived at the correct time - if offset < BLKTIME: - probs.append({block.hash: 0.67 + random.random() * 0.05}) - else: - probs.append({block.hash: 0.33 - random.random() * 0.05}) - # Compute the validator's current view of previous blocks up to the - # point of finalization - probs.extend(self.compute_view(block.height)) - if self.pos == 0: - for i, v in enumerate(probs): - log('Signatures for block %d: %r' % (block.height - i, v), lvl=1) - # Add the end of the node's finalized hash chain to the signature, and - # create the signature - pre_probs_h = block.height - len(probs) - o = Signature(self.pos, probs, block.height, self.finalized_hashes[pre_probs_h]) - # Sanity check - if o.last_finalized.blockhash is not None: - assert o.last_finalized.blockhash // 10**20 == block.height - len(probs) - # Append the signature to the node's list of signatures produced and return it - signatures.append(o) - return o - - def compute_view(self, from_height): - # Fetch the latest signature from each validator, along with its age - signatures = {} - for v in range(NUM_VALIDATORS): - for q in xrange(1, from_height): - if from_height - q in self.heights and v in self.heights[from_height - q]['signatures']: - signatures[v] = (q, self.heights[from_height - q]['signatures'][v]) - break - # If we have no signatures, then we have no opinion - if len(signatures) == 0: - return [] - # For every height between the node's current maximum seen height and - # its last known finalized height... - probs = [] - for i in xrange(1, from_height - self.max_finalized_height): - block_scores = {} - if from_height - i not in self.heights: - self.heights[from_height - i] = {"blocks": {}, "signatures": {}} - # For every signature... - for q, sig in signatures.values(): - assert sig.height == from_height - q - # If the signature is older than this height, then it has - # nothing to say about this height so its vote for every block - # is assumed to be zero - if i < q: - continue - # Otherwise, grab the signature's probability estimate for - # every block at the height - elif len(sig.probs) > i-q: - for blockhash, prob in sig.probs[i-q].items(): - assert blockhash // 10**20 == from_height - q - (i-q) - if blockhash not in block_scores: - block_scores[blockhash] = [] - block_scores[blockhash].append(prob) - # Every signature has a hash chain object at the end; this - # implicitly attests with probability 0.999999 that every block - # in that chain going back is final. Hence, we go back through - # the chain and add such an attestation to our list of votes - else: - h = sig.last_finalized - assert h.blockhash // 10**20 == from_height - q - len(sig.probs) - success = True - for _ in range(i-q - len(sig.probs)): - if h.prev not in self.received_objects: - success = False - break - h = self.received_objects[h.prev] - if success and h.blockhash is not None: - assert h.blockhash // 10**20 == from_height - i, (h.blockhash, from_height - i) - if h.blockhash not in block_scores: - block_scores[h.blockhash] = [] - block_scores[h.blockhash].append(0.999999) - if i-q-len(sig.probs) > 0: - log('Decoding hash succeeded', lvl=3) - else: - log('Decoding hash failed', lvl=3) - self.network.broadcast(self, SyncRequest(self)) - # Use the array of previous votes that we have collected, and - # compute from that our own vote for every block - probs.append(vote(block_scores, self.received_objects, NUM_VALIDATORS)) - for b in block_scores: - if b not in self.received_objects: - self.network.broadcast(self, ObjRequest(self, b)) - # Log a single node's viewpoint changing over time - if self.pos == 0: - log('%d %r' % (from_height - i, self.heights[from_height - i]["blocks"].keys()), lvl=2) - log(block_scores, lvl=2) - log(probs[-1], lvl=2) - # See if our vote corresponds to finality anywhere - for blockhash, p in probs[-1].items(): - assert blockhash // 10**20 == from_height - i - # 0.9999 = finality threshold - if p > 0.9999: - while len(self.finalized) <= from_height - i: - self.finalized.append(None) - self.finalized[from_height - i] = blockhash - # Add the hash to a global list of finalized blocks - finalized_blocks[blockhash] = True - # Add all other hashes at that height to a global list of - # discarded blocks - if from_height - i in self.heights: - for b in self.heights[from_height - i]['blocks']: - if b != blockhash: - discarded[b] = True - # Advance the max_finalized_height and re-calculate the - # hash chain - while self.max_finalized_height + 1 < len(self.finalized) and self.finalized[self.max_finalized_height + 1] is not None: - self.max_finalized_height += 1 - last_finalized_block = self.received_objects[self.finalized[self.max_finalized_height]] - new_state = HashChainObj(last_finalized_block, self.finalized_hashes[-1]) - self.received_objects[new_state.hash] = new_state - self.finalized_hashes.append(new_state) - # Sanity check - for j, p in enumerate(probs): - for h, sig in p.items(): - assert h // 10**20 == from_height - j - 1, (probs, from_height, block_scores) - log('Probabilities: %r' % probs, lvl=4) - return probs + # Initialize the probability array, the core of the signature + best_guesses = [None] * len(self.received_blocks) + sign_from = max(0, self.max_finalized_height - 30) + for i, b in list(enumerate(self.received_blocks))[sign_from:]: + if self.received_blocks[i] is None: + time_delta = self.get_time() - BLKTIME * i + my_opinion = 0.35 / (1 + max(0, time_delta) * 0.3 / BLKTIME) + 0.14 + else: + time_delta = self.time_received[b.hash] - BLKTIME * i + my_opinion = 0.7 / (1 + abs(time_delta) * 0.3 / BLKTIME) + 0.15 + if my_opinion == 0.5: + my_opinion = 0.5001 + votes = self.received_signatures[i].values() if i < len(self.received_signatures) else [] + votes += [my_opinion] * (NUM_VALIDATORS - len(votes)) + best_guesses[i] = min(vote(votes), 1 if self.received_blocks[i] is not None else my_opinion) + if best_guesses[i] > 0.9999: + while len(self.finalized_hashes) <= i: + self.finalized_hashes.append(None) + self.finalized_hashes[i] = self.received_blocks[i].hash + elif best_guesses[i] < 0.0001: + while len(self.finalized_hashes) <= i: + self.finalized_hashes.append(None) + self.finalized_hashes[i] = False + while self.max_finalized_height < len(self.finalized_hashes) - 1 \ + and self.finalized_hashes[self.max_finalized_height + 1] is not None: + self.max_finalized_height += 1 + last_state = self.finalized_states[-1] if len(self.finalized_states) else GENESIS_STATE + self.finalized_states.append(state_transition(last_state, self.received_blocks[self.max_finalized_height])) + + self.probs = self.probs[:sign_from] + best_guesses[sign_from:] + log('Making signature: %r' % self.probs[-10:], lvl=1) + sign_from_state = self.finalized_states[sign_from - 1] if sign_from > 0 else GENESIS_STATE + s = Signature(self.pos, self.probs[sign_from:], sign_from_state, sign_from) + all_signatures.append(s) + return s def on_receive(self, obj): # Ignore objects that we already know about @@ -253,67 +127,22 @@ class Validator(): # When receiving a block if isinstance(obj, Block): log('received block: %d %d' % (obj.height, obj.hash), lvl=2) - if obj.height > self.max_finalized_height + 40: - self.network.broadcast(self, SyncRequest(self)) + while len(self.received_blocks) <= obj.height: + self.received_blocks.append(None) + self.received_blocks[obj.height] = obj + self.time_received[obj.hash] = self.get_time() # If we have not yet produced a signature at this height, do so now - if obj.height not in self.signed_heights: - s = self.sign(obj) - self.signed_heights[obj.height] = True - self.on_receive(s) - self.network.broadcast(self, s) - if obj.height not in self.heights: - self.heights[obj.height] = {"blocks": {}, "signatures": {}} - self.heights[obj.height]["blocks"][obj.hash] = obj - if obj.height > self.max_height: - self.max_height = obj.height - self.head = obj + s = self.sign(obj) + self.network.broadcast(self, s) + self.on_receive(s) self.network.broadcast(self, obj) # When receiving a signature elif isinstance(obj, Signature): - if obj.height not in self.heights: - self.heights[obj.height] = {"blocks": {}, "signatures": {}} - self.heights[obj.height]["signatures"][obj.signer] = obj + while len(self.received_signatures) <= len(obj.probs) + obj.sign_from: + self.received_signatures.append({}) + for i, p in enumerate(obj.probs): + self.received_signatures[i + obj.sign_from][obj.signer] = p self.network.broadcast(self, obj) - self.received_objects[obj.last_finalized.hash] = obj.last_finalized - # Received a synchronization request from another node - elif isinstance(obj, SyncRequest): - blocks, signatures, hashchainobjs = [], [], [] - # Respond only if we have something to say - if self.max_finalized_height > obj.last_finalized_height: - # Add blocks and signatures at all requested and possible - # heights - for h in range(obj.last_finalized_height, self.max_height): - if h in self.heights: - for b in self.heights[h]["blocks"].values(): - blocks.append(b) - for s in self.heights[h]["signatures"].values(): - signatures.append(s) - # Add the finalized hash chain - for h in range(obj.last_finalized_height, self.max_finalized_height + 1): - hashchainobjs.append(self.finalized_hashes[h]) - log('Responding to request with height %d, my finalized height %d and my max height %d' % - (obj.last_finalized_height, self.max_finalized_height, self.max_height), lvl=2) - # Create and send a synchronization response object - self.network.direct_send(obj.sender_id, SyncResponse(blocks, signatures, hashchainobjs, - obj.last_finalized_height, self.max_finalized_height, self.finalized)) - # Received a synchronization response object from another node - elif isinstance(obj, SyncResponse): - # Process it only if the object has something to give us - if obj.responder_mfh > self.max_finalized_height: - log('Received response, my finalized height was %d and my height was %d, their MFH was %d' - % (self.max_finalized_height, self.max_height, obj.responder_mfh), lvl=2) - for s in obj.finalized_chain: - self.received_objects[s.hash] = s - for s in obj.signatures: - self.on_receive(s) - for b in obj.blocks: - if b.height not in self.heights: - self.heights[b.height] = {"signatures": {}, "blocks": {}} - self.heights[b.height]["blocks"][b.hash] = b - self.received_objects[b.hash] = b - self.compute_view(self.max_height) - log('And now they are %d and %d' % - (self.max_finalized_height, self.max_height), lvl=2) # Received an object request, respond if we have it elif isinstance(obj, ObjRequest): if obj.ask_hash in self.received_objects: @@ -323,50 +152,90 @@ class Validator(): elif isinstance(obj, ObjResponse): self.received_objects[obj.obj.hash] = obj.obj self.received_objects[obj.hash] = obj + self.time_received[obj.hash] = self.get_time() # Run every tick def tick(self): - mytime = self.network.time + self.time_offset - offset = (mytime - (self.pos * BLKTIME)) % (BLKTIME * NUM_VALIDATORS) - if offset < BLKTIME and self.last_time_made_block < mytime - (BLKTIME * NUM_VALIDATORS / 2): - self.last_time_made_block = mytime - o = Block(self.pos, self.max_height + 1) + mytime = self.get_time() + target_time = BLKTIME * self.next_height + if mytime >= target_time: + o = Block(self.pos, self.next_height) + self.next_height += NUM_VALIDATORS log('making block: %d %d' % (o.height, o.hash), lvl=1) - self.network.broadcast(self, o) + if random.random() < 0.9: + self.network.broadcast(self, o) + while len(self.received_blocks) <= o.height: + self.received_blocks.append(None) + self.received_blocks[o.height] = o self.received_objects[o.hash] = o + self.time_received[o.hash] = mytime return o validator_list = [] future = {} discarded = {} finalized_blocks = {} -signatures = [] +all_signatures = [] now = [0] + +def who_heard_of(h, n): + o = '' + for x in n.agents: + o += '1' if h in x.received_objects else '0' + return o + +def get_opinions(n): + o = [] + maxheight = 0 + for x in n.agents: + maxheight = max(maxheight, len(x.probs)) + for h in range(maxheight): + p = '' + q = '' + for x in n.agents: + if len(x.probs) <= h: + p += '_' + elif x.probs[h] < 0.5: + p += str(int(5 - math.log(x.probs[h]) / math.log(0.0001) * 4) if x.probs[h] > 0.0001 else 0) + elif x.probs[h] >= 0.5: + p += str(int(5 + math.log(1 - x.probs[h]) / math.log(0.0001) * 4) if x.probs[h] < 0.9999 else 9) + q += 'n' if len(x.received_blocks) <= h or x.received_blocks[h] is None else 'y' + o.append((h, p, q)) + return o + +def get_finalization_heights(n): + o = [] + for x in n.agents: + o.append(x.max_finalized_height) + return o + + # Check how often blocks that are assigned particular probabilities of # finalization by our algorithm are actually finalized -def calibrate(): +def calibrate(finalized_hashes): thresholds = [0, 0.25, 0.5, 0.75] + [1 - 0.5**k for k in range(10)] + [1] signed = [0] * (len(thresholds) - 1) _finalized = [0] * (len(thresholds) - 1) _discarded = [0] * (len(thresholds) - 1) - for s in signatures: - for probs in s.probs: - for blockhash, p in probs.items(): - index = 0 - while p > thresholds[index + 1]: - index += 1 - signed[index] += 1 - if blockhash in finalized_blocks: - _finalized[index] += 1 - assert blockhash not in discarded, blockhash - if blockhash in discarded: - _discarded[index] += 1 - assert blockhash not in finalized_blocks, blockhash + for s in all_signatures: + for i, prob in enumerate(s.probs): + if i + s.sign_from >= len(finalized_hashes): + continue + actual_result = 1 if finalized_hashes[i + s.sign_from] else 0 + index = 0 + while prob > thresholds[index + 1]: + index += 1 + signed[index] += 1 + if actual_result == 1: + _finalized[index] += 1 + elif actual_result == 0: + _discarded[index] += 1 for i in range(len(thresholds) - 1): if _finalized[i] + _discarded[i]: print 'Probability from %f to %f: %f' % (thresholds[i], thresholds[i+1], _finalized[i] * 1.0 / (_finalized[i] + _discarded[i])) + print 'Percentage of blocks nonempty: %f%%' % (len([x for x in finalized_hashes if x]) * 100.0 / len(finalized_hashes)) def run(steps=4000): @@ -374,8 +243,8 @@ def run(steps=4000): for i in range(NUM_VALIDATORS): n.agents.append(Validator(i, n)) n.generate_peers() - while len(signatures): - signatures.pop() + while len(all_signatures): + all_signatures.pop() for x in future.keys(): del future[x] for x in finalized_blocks.keys(): @@ -385,27 +254,31 @@ def run(steps=4000): for i in range(steps): n.tick() if i % 250 == 0: - finalized = [(v.max_finalized_height, v.finalized) for v in n.agents] - finalized = sorted(finalized, key=lambda x: len(x[1])) + print get_opinions(n)[-60:] + finalized0 = [(v.max_finalized_height, v.finalized_hashes) for v in n.agents] + finalized = sorted(finalized0, key=lambda x: len(x[1])) for j in range(len(n.agents) - 1): for k in range(len(finalized[j][1])): - assert finalized[j][1][k] is None or finalized[j+1][1][k] is \ - None or finalized[j][1][k] == finalized[j+1][1][k], (finalized, j) - print 'Finalized status: %r' % [x[1][x[0]] for x in finalized] - if i == 10000: + if finalized[j][1][k] is not None and finalized[j+1][1][k] is not None: + if finalized[j][1][k] != finalized[j+1][1][k]: + print finalized[j] + print finalized[j+1] + raise Exception("Finalization mismatch: %r %r" % (finalized[j][1][k], finalized[j+1][1][k])) + print 'Finalized status: %r' % [x[0] for x in finalized0] + if i == 10000 and NETSPLITS: print "###########################################################" print "Knocking off 20% of the network!!!!!" print "###########################################################" n.knock_offline_random(NUM_VALIDATORS // 5) - if i == 20000: + if i == 20000 and NETSPLITS: print "###########################################################" print "Simluating a netsplit!!!!!" print "###########################################################" n.generate_peers() n.partition() - if i == 30000: + if i == 30000 and NETSPLITS: print "###########################################################" print "Network health back to normal!" print "###########################################################" n.generate_peers() - calibrate() + calibrate(n.agents[0].finalized_hashes) diff --git a/casper/distributions.py b/casper/distributions.py index cdd3833..a37ce72 100644 --- a/casper/distributions.py +++ b/casper/distributions.py @@ -3,8 +3,9 @@ import random, sys def normal_distribution(mean, standev): def f(): - total = sum([random.choice([1, -1]) for i in range(529)]) - return int(total * (standev / 23.0) + mean) + return int(random.normalvariate(mean, standev)) + # total = sum([random.choice([2, 0, 0, -2]) for i in range(8)]) + # return int(total * (standev / 4.0) + mean) return f @@ -14,9 +15,9 @@ def exponential_distribution(mean): total = 0 while 1: total += 1 - if not random.randrange(500): + if not random.randrange(32): break - return int(total * 0.002 * mean) + return int(total * 0.03125 * mean) return f diff --git a/casper/networksim.py b/casper/networksim.py index 18398b2..301cd65 100644 --- a/casper/networksim.py +++ b/casper/networksim.py @@ -16,11 +16,13 @@ class NetworkSimulator(): self.peers = {} for a in self.agents: p = [] - while len(p) < num_peers: + while len(p) <= num_peers // 2: p.append(random.choice(self.agents)) if p[-1] == a: p.pop() - self.peers[a.id] = p + self.peers[a.id] = self.peers.get(a.id, []) + p + for peer in p: + self.peers[peer.id] = self.peers.get(peer.id, []) + [a] def tick(self): if self.time in self.objqueue: diff --git a/casper/voting_strategy.py b/casper/voting_strategy.py index 297969c..4c38def 100644 --- a/casper/voting_strategy.py +++ b/casper/voting_strategy.py @@ -1,68 +1,24 @@ -# The voting strategy. Validators see what every other validator's most -# recent vote for very particular block, in the format +import random + +# The voting strategy. Validators see what every other validator votes, +# and return their vote. # -# { -# blockhash1: [vote1, vote2, vote3...], -# blockhash2: [vote1, vote2, vote3...], -# ... -# } -# -# Where the votes are probabilities with 0 < p < 1 (see -# http://lesswrong.com/lw/mp/0_and_1_are_not_probabilities/ !), and the -# strategy should itself return an object of the format -# { -# blockhash1: vote, -# blockhash2: vote, -# ... -# } +# Votes are probabilities with 0 < p < 1 (see +# http://lesswrong.com/lw/mp/0_and_1_are_not_probabilities/ !) +def vote_transform(p): + return (abs(2 * p - 1) ** 0.333 * (1 if p > 0.5 else -1) + 1) / 2 + -def vote(probs, db, num_validators): - pass1 = {k: get_vote_from_scores(v, num_validators) - for k, v in probs.items() if k in db} - pass2 = normalize(pass1, num_validators) - return pass2 - - -# Get the list of scores from other users and come up with -# your own base score -def get_vote_from_scores(probs, num_validators): - if len(probs) <= num_validators * 2 / 3: - o1 = 0 - else: - o1 = sorted(probs)[::-1][num_validators * 2 / 3] - return 0.8 + 0.2 * o1 - - -# Given a set of independently computed block probabilities, "normalize" the -# probabilities (ie. make sure they sum to at most 1; less than 1 is fine -# because the difference reflects the probability that some as-yet-unknown -# block will ultimately be finalized) -def normalize(block_results, num_validators): - # Trivial base cases - if len(block_results) == 1: - return {k: v for k, v in block_results.items()} - elif len(block_results) == 0: - return {} - a = {k: v for k, v in block_results.items()} - for v in a.values(): - assert v <= 1, a - # Artificially privilege the maximum value at the expense of the - # others; this ensures more rapid convergence toward one equilibrium - maxkey, maxval = None, 0 - for v in a: - if a[v] > maxval: - maxkey, maxval = v, a[v] - for v in a: - if v == maxkey: - a[v] = a[v] * 0.8 + 0.2 - else: - a[v] *= 0.8 - # If probabilities sum to more than 1, keep reducing them via a - # transform that preserves proportional probability of non-inclusion - while 1: - for v in a.values(): - assert v <= 1, a - if sum(a.values()) < 1: - return a - a = {k: v * 1.05 - 0.050001 for k, v in a.items() if v > 0.050001} +def vote(probs): + if len(probs) == 0: + return 0.5 + probs = sorted(probs) + score = (probs[len(probs)/2] + probs[-len(probs)/2]) * 0.5 + if score > 0.9: + score2 = probs[len(probs)/3] + score = min(score, max(score2, 0.9)) + elif score < 0.1: + score2 = probs[len(probs)*2/3] + score = max(score, min(score2, 0.1)) + return vote_transform(score)