majority-judgment-for-streamers

Let's discuss delegations.

Flow


graph TD
	DirectVote["Direct Grade"]
	DelegatedVote["Delegated Grade"]
	ToReject["Default Grade: To Reject"]
    UserHasJudged{"User has judged"}
	UserHasDelegates{"User has Delegate(s)"}
    
    UserHasJudged --> | yes | DirectVote
    UserHasJudged --> | no | UserHasDelegates
    UserHasDelegates --> | yes | DelegatedVote
    UserHasDelegates --> | no | ToReject

Delegation Graphs

Legend

In the graphs below, we're using this legend:

graph TD
	DirectGrade>"Direct Grade"]
	DelegatedGrade>"Delegated Grade"]
    
	DirectUser("User")
	DelegativeUser("User")
    Delegator("Delegator User")
    Delegate("Delegate User")
    
    DirectUser --- DirectGrade
    DelegativeUser -.- DelegatedGrade
    Delegator --> Delegate

Acyclic

Let's consider a simple delegation graph, like so:

graph TD
	Poor>"Poor"]
	Good>"Good"]
    
	Adele("Adèle")
	Benjamin("Benjamin")
    Eugenie("Eugénie")
        
    Adele --> Benjamin
    Adele --> Eugenie
    
    Benjamin --- Good
    Eugenie --- Poor

    AdeleGrade>"Poor ⁽¹⁾"]
    Adele -.- AdeleGrade

(1) Adèle's delegated judgment is Poor because it is the median judgment of her two delegates. Majority Judgment uses the lower median grade when there is an even number of grades.

This complies with the observation that humans appear to feel stronger about contestation than adhesion. See the works of Daniel Kahneman for examples. (If you have a paper on-point, please share!)

Precedence

Direct judgments always take precedence over delegations. That is, if Eugénie delegates to Benjamin, like so:


graph TD
	Poor>"Poor"]
	Good>"Good"]
    
	Adele("Adèle")
	Benjamin("Benjamin")
    Eugenie("Eugénie")
        
    Adele --> Benjamin
    Adele --> Eugenie
    Eugenie --> Benjamin

    Benjamin --- Good
    Eugenie --- Poor

    AdeleGrade>"Poor"]
    Adele -.- AdeleGrade

The results are unchanged because the delegation is ignored, since Eugénie has also expressed a judgment.

Inheritance

The delegated grade of a user is the median grade of their delegates.

See Algorithm C: Expanding Social Circles below.

Cyclic

Things get interesting when a wild cycle appears in the tall grass, like so:

graph TD
	Adele("Adèle")
	Benjamin("Benjamin")
	Clemence("Clémence")
    
    Adele --> Benjamin
    Benjamin --> Clemence
    Clemence --> Adele

In that case, the default grade TO REJECT is applied:

graph TD
	ToReject>"To Reject ('default)"]
    Adele("Adèle")
	Benjamin("Benjamin")
	Clemence("Clémence")
    
    Adele --> Benjamin
    Benjamin --> Clemence
    Clemence --> Adele
    
    Adele -.- ToReject
    Benjamin -.- ToReject
    Clemence -.- ToReject

It only takes one member of a delegation cycle to break the status quo (aka. mexican standoff).

If Clemence for example has also delegated to Didier, and Didier has expressed a judgment, the normal delegation graph resolution can occur:

graph TD
	Passable>"Passable"]
    Adele("Adèle")
	Benjamin("Benjamin")
	Clemence("Clémence")
	Didier("Didier")
    
    Adele --> Benjamin
    Benjamin --> Clemence
    Clemence --> Adele
    Clemence --> Didier
    
    Adele -.- Passable
    Benjamin -.- Passable
    Clemence -.- Passable
    Didier --- Passable

Head-scratcher N°01

What should the delegated grade of Benjamin be here?

graph TD
	Good>"Good"]
    Adele("Adèle")
	Benjamin("Benjamin")
	Clemence("Clémence")
	Didier("Didier")
    GradeAdele>"Passable ⁽¹⁾"]
    GradeBenjamin>"???"]
	Passable>"Passable"]
    
    Benjamin --> Adele
    Adele --> Benjamin
    Benjamin --> Clemence
    Adele --> Didier
    
    Adele -.- GradeAdele
    Benjamin -.- GradeBenjamin
    Clemence --- Good
    Didier --- Passable

(1) Whatever algorithm gets chosen, Adele's grade will be Passable because Majority Judgment uses the lower median grade when there is an even number of grades.

In more complex situations we might not be able to ascertain Adèle's delegated judgment so easily, so you should pretend we don't know it in advance.

Algorithm A : Cancel cyclic delegations

If none of the participants of a delegation cycle have expressed a direct judgment, all the delegations within the cycle from participants having other delegations ouside of the cycle are broken.

What if those other delegations happen to be part of another cycle?

This would set the delegated grade of Benjamin to Good.

Algorithm B : Leaf-Most

Median of all the leaves in the delegation graph.

This would set the delegated grade of Benjamin to Passable.

My judgment is, by order of precedence:

My direct judgment
The median of the direct judgments of my 1st degree delegates
The median of the direct judgments of my 2nd degree delegates
The median of the direct judgments of my ... degree delegates
To Reject (closed cyclic graph)

This would set the delegated grade of Benjamin to Good.

This is the author's favorite algorithm. ★★★

Algorithm D : Something Else

Request access to the repository (make an account and submit an issue, there's no button yet on Gitea) to be able to write into this wiki.

Blackboard (random snippets without meaning)


graph TD
	CollectDelegationGraph["Collect the Delegation Graph"]
    CollectDelegationGraph --> | cyclic | Void

Tooling for graphs

graph TD
	ToReject["To Reject"]
	Poor["Poor"]
	Passable["Passable"]
	Good["Good"]
	VeryGood["Very Good"]
	Excellent["Excellent"]

	Adele("Adèle")
	Benjamin("Benjamin")
	Clemence("Clémence")
	Didier("Didier")
	Eugenie("Eugénie")
    Francois("François")
    Germaine("Germaine")
    Henri("Henri")