Delegations

Let's discuss delegations.

## Flow

``````
graph TD
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

DirectUser("User")
DelegativeUser("User")
Delegator("Delegator User")
Delegate("Delegate User")

Delegator --> Delegate
``````

### Acyclic

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

``````graph TD
Poor>"Poor"]
Good>"Good"]

Benjamin("Benjamin")
Eugenie("Eugénie")

Benjamin --- Good
Eugenie --- Poor

``````

(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"]

Benjamin("Benjamin")
Eugenie("Eugénie")

Eugenie --> Benjamin

Benjamin --- Good
Eugenie --- Poor

``````

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.

### Cyclic

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

``````graph TD
Benjamin("Benjamin")
Clemence("Clémence")

Benjamin --> Clemence
``````

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

``````graph TD
ToReject>"To Reject ('default)"]
Benjamin("Benjamin")
Clemence("Clémence")

Benjamin --> Clemence

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"]
Benjamin("Benjamin")
Clemence("Clémence")
Didier("Didier")

Benjamin --> Clemence
Clemence --> Didier

Benjamin -.- Passable
Clemence -.- Passable
Didier --- Passable
``````

What should the delegated grade of Benjamin be here?

``````graph TD
Good>"Good"]
Benjamin("Benjamin")
Clemence("Clémence")
Didier("Didier")
Passable>"Passable"]

Benjamin --> Clemence

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`.

#### Algorithm C : Expanding Social Circles

My judgment is, by order of precedence:

1. My direct judgment
2. The median of the direct judgments of my 1st degree delegates
3. The median of the direct judgments of my 2nd degree delegates
4. The median of the direct judgments of my ... degree delegates
5. 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"]