Some Trust Systems

TODO figure out which metrics/criteria/properties these have.(might want to give each a code for brevity) Also put equations in and prove it.

Note; all reputations here are subjective, i.e. every node has its reputation for other nodes. There is no global reputation.

'Heat' inspired

Basically vouching for someone adds a one-way heat conduction. toward person k is defined as the limit of t→∞ for

  T_self ≡ 1,   and   ∂_tT_k=∑_iα_i-k(T_i - T_k) - β_kT_k

At equilibrium that is (β_k + ∑_iα)T_k = ∑_iαT_i making a large linear equation.

From which it looks like the relaxation method can solve it. TODO does it always converge?

Tube capacity

Basically each edge is a tube with one-way valve, with just a capacity, and the total capacity between two points is the reputation.(multiple paths can be used together) Basically, this means it comes down to the chokepoint. Calculating this reputation takes some kind of path-finding-like algorithm.

Could decrease the capacity by an additional factor based on distance, otherwise the approach might carry reputation too far.

TrustDavis

pdf, youtube, slides. Something like the maximum pay between two points could be taken as the reputation.

Edit: below is crappy.

An issue for many concepts: Loops

Lets say you have some function for assigning reputation to a node, based on edges from already-reputed nodes. Then you have the issue of loops, as you dont know where to start to give reputations.

Delooping:distance one approach is to use distance, all edges may one go more distance from the originating node. This node is excessively crude, because it doesnt care about the strength of edges.

Delooping:keep adding current most reputable, much less complex. (note: calculation is similar to Dijkstra's pathfinding without final path.)

Basically you have a set of already calculated reputations, I(t), I(0)=origin and the rest is the excluded set E(t)=All ¬ I(t). Based on the edges from I(t), you calculate the reputations, the one with the highest reputation is added; add(origin, t) such that ∀y∈E(t): f_I(t)(origin, add(t))>f_I(t)(origin, y), and I(t+1)=I(t) ∪ {add(origin, t)}

Note that in principle, f(origin, add(origin, t+1))>f(origin, add(origin, t+1)) is a-priory possible. Likely would be caused by edges add(origin, t)→add(origin, t+1) potentially, this is a self-depreciation issue. Can be fixed after-the-fact, computational cost?

Weighted Averages (EDIT: i stupidly forgot about loops)

Basicaly each node has edges and treats them as weights, when reporting a value, it just takes the averages of given values and its own estimate;

  E_k=(w_ke_k + ∑_it_kiE_i) / (w_k + ∑_it_ki)

Of course, it can give any weight to itself, i.e. it can ignore its own friends. (not really defeating, it is just very non-self-depreciative)

This approach allows for directly making estimates, as opposed to just having numerical reputations that need interpretation afterward. Note that if there are partisan players they'll go over/below their actual estimate. One big disadvantage is that there is no decrease in estimation 'ability' over a long chain of links, if no-one else votes. For this a variant that keeps track of the actual fraction of weight might be in order.

TODO This could be taken as a reputation by...