How does the stamp eigenkarma system work?

6 min read

If someone posts something good on the Discord - something that shows insight, knowledge of AI Safety, etc. - give the message or answer a stamp of approval! Stampy keeps track of these, and uses them to decide how much he likes each user. You can ask Stampy (in a PM if you like), "How many stamps am I worth?", and he'll tell you.

If something is really very good, especially if it took a lot of work/effort, give it a gold stamp. These are worth 5 regular stamps!

Note that stamps aren't just 'likes', so please don't give stamps to say "me too" or "that's funny" etc. They're meant to represent knowledge, understanding, good judgement, and contributing to the discord. You can use 💯 or ✔️ for things you agree with, 😂 or 🤣 for funny things etc.

Your stamp points determine how much say you have if there are disagreements on Stampy content, which channels you have permission to post to, your voting power for approving YouTube replies, and whether you get to invite people.

Notes on stamps and stamp points

Stamps awarded by people with a lot of stamp points are worth more
Awarding people stamps does not reduce your stamp points
New users who have 0 stamp points can still award stamps, they just have no effect. But it's still worth doing because if you get stamp points later, all your previous votes are retroactively updated!
Yes, this was kind of tricky to implement! Stampy actually stores how many stamps each user has awarded to every other user, and uses that to build a system of linear scalar equations which is then solved with numpy.
Each user has stamp points, and also gives a score to every other user they give stamps to the scores sum to 1 so if I give user A a stamp, my score for them will be 1.0, if I then give user B a stamp, my score for A is 0.5 and B is 0.5, if I give another to B, my score for A goes to 0.3333 and B to 0.66666 and so on
Score is "what proportion of the stamps I've given have gone to this user"
Everyone's stamp points is the sum of (every other user's score for them, times that user's stamp points) so the way to get points is to get stamps from people who have points
Rob is the root of the tree, he got one point from Stampy
So the idea is the stamp power kind of flows through the network, giving people points for posting things that I thought were good, or posting things that "people who posted things I thought were good" thought were good, and so on ad infinitum so for posting YouTube comments, Stampy won't send the comment until it has enough stamps of approval. Which could be a small number of high-points users or a larger number of lower-points users
Stamps given to yourself or to Stampy do nothing

So yeah everyone ends up with a number that basically represents what Stampy thinks of them, and you can ask him "how many stamps am I worth?" to get that number

so if you have people a, b, and c, the points are calculated by: ```

a_points = (bs_score_for_a * b_points) + (cs_score_for_a * c_points) b_points = (as_score_for_b * a_points) + (cs_score_for_b * c_points) c_points = (as_score_for_c * a_points) + (bs_score_for_c * b_points)

``` which is tough because you need to know everyone else's score before you can calculate your own but actually the system will have a fixed point - there'll be a certain arrangement of values such that every node has as much flowing out as flowing in - a stable configuration so you can rearrange ```

(bs_score_for_a * b_points) + (cs_score_for_a * c_points) - a_points = 0 (as_score_for_b * a_points) + (cs_score_for_b * c_points) - b_points = 0 (as_score_for_c * a_points) + (bs_score_for_c * b_points) - c_points = 0

``` or, for neatness: ```

( -1 * a_points) + (bs_score_for_a * b_points) + (cs_score_for_a * c_points) = 0 (as_score_for_b * a_points) + ( -1 * b_points) + (cs_score_for_b * c_points) = 0 (as_score_for_c * a_points) + (bs_score_for_c * b_points) + ( -1 * c_points) = 0

```

and this is just a system of linear scalar equations that you can throw at numpy.linalg.solve(you add one more equation that says rob_points = 1, so there's some place to start from) there should be one possible distribution of points such that all of the equations hold at the same time, and numpy finds that by linear algebra magic beyond my very limited understanding

but as far as I can tell you can have all the cycles you want!

(I actually have the scores sum to slightly less than 1, to have the stamp power slightly fade out as it propagates, just to make sure it doesn't explode. But I don't think I actually need to do that)

and yes this means that any time anyone gives a stamp to anyone, ~everyone's points will change slightly

And yes this means I'm recalculating the matrix and re-solving it for every new stamp, but computers are fast and I'm sure there are cheaper approximations I could switch to later if necessary