Sounds a little bit similar to this one idea I read about, but am having trouble finding right now (fakeedit before submit: it was
https://github.com/neyer/respect ), which was meant to be a system for determining respect and reputation in large groups.
The idea was that each person would select some number of people to state that they trust/respect (fakeedit: this should say respect most of the times I say trust, but I don't feel like replacing all of them atm. mentally substitute the word 'trust' with 'respect') them to some degree (between 0 and 1, or between -1 and 1, but the negative ones were counted as zero until the last step). These would together form a (square) matrix of how much each person has granted 'initial' trust to who. Also each person's statement of who they trust is a vector, and it is normalized to have magnitude 1 (before being used as part of the matrix. This is to defend against attacks from people making extra identities that all trust each other, or things like that)
The idea would then be that people tend to trust people that people they trust, trust, so it would be useful to determine what trust levels there are when including 'indirect' trust. To do this, one adds the matrix to the matrix raised to the second power, plus the matrix raised to the third power, for some number of levels (I think they recommended 3 levels). For each of these, on the last level, one can include the negative values in order to include /distrust/. (But one does not want to include it in earlier levels, otherwise one would end up trusting people that people you distrust, distrust, which probably isn't what you want).
Then to find someone's indirect trust vector you look at the appropriate, uh, I think row, of the resulting matrix.
In addition, there is a measure of how much your 'initial' trust vector aligns with your 'indirect' trust vector, by taking the dot product of the two, (and I think also dividing by the magnitudes of the two vectors). This is sort of a measure of how similar your trust is to that of the people you trust.
....
oh, I think I originally saw it as a blog post, but it looks like it was by neyer and is at https://github.com/neyer/respect
...
So, a roughly analogue thing for using upvotes as the input would I guess be, uh...
To determine the ranking that a given person would see, consider the list of all of a person's upvotes/downvotes (or all in the last 6 months or w/e?) as a vector, and for each person who upvoted or downvoted anything in the thread one is looking at, take the dot product of their voting record vector with one's own voting record, and weigh their votes in the given thread based on that dot product (perhaps adjusted for the magnitude of the voting record vectors in question).
So, if someone is someone who you vote similarly to, their upvotes increase the score you see of posts, and if you tend to vote the opposite way from them, their upvotes would decrease the score you see on posts (the opposite would be the case with downvotes).
However, this seems like it might be computationally expensive? For each thread one looks at, getting each person who voted a single time in that thread, and then get every time they voted in the last time ( or at least all the times that they voted, where you also voted), and compare all of your (recent) votes with theirs.
Another concern that I think people would have would be that it might produce some echo-chamber-ish effects, but I don't know if that would really be a problem.
It might be that if one votes for what makes good arguments for their position, and not just the opinions that one agrees with, then one will vote similarly to other people who do that, and that one will as a result see the posts that people who do that upvoted. But if there is a group who does not do that, and is large, and many of them vote for a post which the people who vote for good reasoning, that they might have an unfortunate influence on how the people who are voting for careful arguments see.
However, it seems like this would be solved by simply downvoting the arguments that do not contribute.
So, depending on how one defines "echo chamber", it seems like the system might only give one an "echo chamber" if one votes in a way that would align with that.
However, for another seemingly reasonable definition of "echo chamber" , I guess it would lead to one (with that being essentially the purpose), but the fact that it does so might not be all that bad (with the people who are "open minded" ending up in an "echo chamber" of other "open minded" people).
It also seems like it could be combined with github:neyer/respect in potentially nice ways.
for example, the dot products of similarity of voting seem to be possibly of the same "type" as the respect value in github:neyer/respect , and it seems like maybe they could be added together.
So, one could maybe do something like add the indirect respect value to the similarity of voting value, when weighing how much to consider the different votes, or perhaps one could use the dot products of the voting records as contributing to the initial trust vectors. (In either case, this could be potentially weighted to make one have more weight than the other).
This might make it so that one has more people in the vector of who one initially has respect information about, which could be useful. But I don't know if similarity in voting record is a good thing for that.
And there's still the problem of whether it is too computationally expensive to do for every thread view for every person. Maybe if there was some caching, and some of the stuff didn't get updated all the time? But that seems like it would require a lot of memory.
_____
another potential problem is, if it is to be decentralized, it would I think be difficult to use the above system without making lists of who upvoted/downvoted who entirely public (unless one used something like the recent MIT Enigma thing, but that would make this all even more computationally and memory expensive. /Mayyyybe/ not prohibitively so though? I'm not sure. Practicality isn't my strong suit.)
_____
It is a very interesting problem!
