Previously, I’ve been talk­ing in broad terms about very gen­eral con­cepts in profi­ci­ol­ogy. This will be the first time I nar­row my focus into a spe­cific domain. A domain is a restricted set­ting with only a small num­ber of rel­e­vant events / senses / agents – basi­cally a toy prob­lem, or a sim­pli­fied model envi­ron­ment. The hope is that we can use impor­tant ideas from these domains as fun­da­men­tal build­ing blocks that will help us ana­lyze more com­plex setups. In other words, we should be able to build more inter­est­ing / real­is­tic gener­ics by mix­ing & match­ing sim­ple com­po­nents from mul­ti­ple domains, as if we were build­ing a com­plex mol­e­cule atom-by-atom.

In this post we will talk about the Rivalry domain, which focuses on events where one generic ben­e­fits at another generic’s loss. I will sup­ple­ment my expla­na­tion with for­mal nota­tion loosely based on func­tional pro­gram­ming lan­guages. I am not requir­ing (or expect­ing) read­ers to have a back­ground in com­puter sci­ence – it’s just that this kind of nota­tion is very use­ful for describ­ing non­triv­ial generic behav­iors through the com­po­si­tion of sim­pler con­structs. In any case, I will be explain­ing this func­tional nota­tion as I go.

The Basic Senses: Pain and Gain

Central to the Rivalry domain are a pair of senses that I will call Pain and Gain. Here, a sense is like a trig­ger that is acti­vated upon encoun­ter­ing cer­tain sequences of events. We will use the word scene to mean “a sequence of events”, and more for­mally describe a sense as a func­tion which takes in a scene and pro­duces a boolean value (either true or false). In func­tional nota­tion, we say that a sense has the type [scene -> boolean] – the arrow denotes that a sense is a func­tion, where the input is a scene and the out­put is a boolean.

We will assume that there are sequences of events that are inher­ently con­sid­ered pleas­ant, and sequences of events that are inher­ently con­sid­ered unpleas­ant. Let’s sup­pose we had a scene called [obtaining candy]¹, which is an inher­ently pleas­ant one. By def­i­n­i­tion, we say that [Gain(obtaining candy) = true] – this is a for­mal way of say­ing that the act of obtain­ing candy trig­gers the Gain sense. On the other hand, if we had a scene called [having my candy taken away] that is inher­ently unpleas­ant, then by def­i­n­i­tion we say that [Pain(having my candy taken away) = true] – this is a for­mal way of say­ing that los­ing some candy trig­gers the Pain sense. For com­ple­tion, I should note that some scenes don’t trig­ger either sense. Perhaps we have a scene called [nothing interesting is happening], where [Gain(nothing interesting is happening) = false] and [Pain(nothing interesting is happening) = false].

Helper Functions: Mirroring

We also need to have a func­tion called Mirror which is used to view a scene from some­one else’s per­spec­tive². Suppose we started with a scene called [I took candy from someone] where a generic takes candy away from another generic. We can use the Mirror func­tion to view the scene from the per­spec­tive of the vic­tim – per­haps we can call the result [someone took candy from me]. Let’s put this into func­tional nota­tion. We can say that the Mirror func­tion takes in a scene and a generic as inputs. If the inputs are well-formed then the func­tion out­puts a new scene. But if the inputs are non­sen­si­cal then the func­tion out­puts an error called Failure. We can say that Mirror has type [(scene, generic) -> scene?], and in our exam­ple we have:

Mirror(I took candy from someone, the bolded "someone") =
  Success(someone took candy from me)

Mirror(I took candy from someone, an unrelated person) = Failure

Lastly, we need to have a func­tion GetGenerics which takes in a scene and out­puts a list of all the gener­ics that par­tic­i­pate in that scene. This will help us find the gener­ics that we can use as inputs to the Mirror function.

More Advanced Senses: Selfishness and Selflessness

In the Rivalry domain, the Pain and Gain senses are sim­ply given to us and we don’t care too much about how they work. But we will use them (as well as Mirror and GetGenerics) as build­ing blocks to cre­ate two more senses. The first one is called Rivalry-selfish, and is trig­gered when­ever some­thing good hap­pens to the generic at the expense of some­thing bad hap­pen­ing to another generic. To be spe­cific, we will use the fol­low­ing definition:

define Rivalry-selfish(scene): (scene -> boolean) as
  let generics = GetGenerics(scene),
  if there is some generic in generics where
    Gain(scene) = true, and
    Mirror(scene, generic) = Success(mirrored_scene), and
    Pain(mirrored_scene) = true
  then true
  otherwise false

Here’s an expla­na­tion of this nota­tion. We first rec­og­nize who is par­tic­i­pat­ing in the scene with [let generics = GetGenerics(scene)]. Then for each generic, we check whether the scene sat­is­fies three criteria:

1. The scene is good from our per­spec­tive – [Gain(scene) = true]
2. It makes sense to mir­ror the scene – [Mirror(scene, generic) = Success(mirrored_scene)]
3. The scene is bad from the other generic’s per­spec­tive – [Pain(mirrored_scene) = true]

If we are able to sat­isfy these cri­te­ria, then the Rivalry-selfish sense is triggered.

Similarly, we can define the Rivalry-selfless sense, which is trig­gered when some­thing bad hap­pens to the generic in a way that is ben­e­fi­cial to another generic.

define Rivalry-selfless(scene): (scene -> boolean) as
  let generics = GetGenerics(scene),
  if there is some generic in generics where
    Pain(scene) = true, and
    Mirror(scene, generic) = Success(mirrored_scene), and
    Gain(mirrored_scene) = true
  then true
  otherwise false

Keep in mind that Rivalry-selfish and Rivalry-selfless are senses, not per­son­al­ity traits as the words “self­ish” and “self­less” may sug­gest. They relate to the per­cep­tion of whether a scene has a “self­ish nature” or a “self­less nature”, just as Pain and Gain refer to the per­cep­tion of whether a scene is “good” or “bad”.

Dynamics of the Rivalry Domain

We are now ready to talk about how these senses relate to generic behav­ior. Suppose that we had a generic soci­ety where all gener­ics have the Rivalry-selfish and Rivalry-selfless senses, and many actions trig­ger these Rivalry senses. For instance, per­haps resources are lim­ited in this soci­ety and gener­ics fre­quently com­pete over such resources³. In this case, in claim­ing these resources a generic may very well incon­ve­nience oth­ers around them.

Naturally, the lenses of the gener­ics in this soci­ety will fre­quently pro­duce eval­u­a­tions related to the Rivalry senses. In turn, that means each generic will likely house agents that are ener­gized by such eval­u­a­tions, and hence mem­bers of this soci­ety are con­stantly moti­vated to per­form actions that trig­ger the Rivalry senses.

Let’s try to cre­ate a very self­ish generic. His lens will have two eval­u­a­tions that directly mir­ror the Rivalry senses, and he will have an agent which tries to max­i­mize Rivalry-selfish. For a more exag­ger­ated effect, let’s say that both Rivalry-selfish and Rivalry-selfless ener­gize this agent. Through the will of this agent, our generic will always try to do things that ben­e­fit him­self while hurt­ing oth­ers. If he hap­pens to lose to another per­son (thereby trig­ger­ing the Rivalry-selfless sense), then he will get mad and become even more moti­vated to win. Funnily enough, we don’t even need to give him an agent that sim­ply attempts to max­i­mize Gain. It’s pos­si­ble that he doesn’t have any strong feel­ings about a “free ben­e­fit” (a scene which trig­gers Gain with­out Rivalry-selfish), and is sat­is­fied only if the ben­e­fit comes at some­one else’s disadvantage.

Of course, if we swap the two senses then we can just as eas­ily cre­ate a highly altru­is­tic generic who will gladly give back dou­ble for every favor he receives. Let’s try mak­ing the eval­u­a­tions a lit­tle more com­pli­cated though. Suppose we had a generic who likes to clas­sify his neigh­bors into two groups – the ingroup and the out­group. We give him two evaluations:

• ingroup selflessness: pro­duced when Rivalry-selfless appears in the pos­te­rior infor­ma­tion and the vic­tim is in the ingroup.
• outgroup selfishness: pro­duced when Rivalry-selfish appears in the pos­te­rior infor­ma­tion and the vic­tim is in the outgroup.

Now, we give him an agent called HelpMyFriends which uses ingroup selflessness as its source / sink eval­u­a­tions, and an agent called HurtMyEnemies which uses outgroup selfishness as its source / sink eval­u­a­tions. The result is that the generic will be happy to

1. spend his time / effort doing things that help mem­bers of the ingroup, and
2. gain ben­e­fits in a way that hurts mem­bers of the outgroup.

In other words, this generic has a group iden­tity and is moti­vated to fight for the ben­e­fit of the ingroup. If other mem­bers of the ingroup also had agents sim­i­lar to HelpMyFriends and HurtMyEnemies, then they would form a tightly knit tribe of gener­ics who are all hos­tile toward those out­side their group.

Education by Demonstration

Finally, let’s see what hap­pens to a new generic join­ing into this Rivalry-cen­tered soci­ety⁴. Let’s say that his mind already has the Rivalry senses, but they are not being used in any eval­u­a­tions (which also means his pre-exist­ing agents are unaware of this sense).

Initially, he does not under­stand the behav­iors of his neigh­bors. Given the prior infor­ma­tion for an event, he can­not find a good eval­u­a­tion that he can use to pre­dict the out­come through value pre­dic­tion. Maybe after repeat­edly wit­ness­ing a spe­cific event sev­eral times, he can pro­duce a causal esti­mate for the event:

If one per­son has candy and finds another per­son with­out candy, we might see the for­mer give his candy to the lat­ter. I’ve seen this hap­pen sev­eral times, after all.

However, this knowl­edge doesn’t gen­er­al­ize to events which super­fi­cially appear very dif­fer­ent, but still demon­strate sim­i­lar kinds of Rivalry dynamics:

If one per­son finds another per­son acci­den­tally walk­ing into a dan­ger­ous place, what’s going to hap­pen? I have never seen any­thing like this before, so I have no idea.
(Turns out, the for­mer per­son delib­er­ately put him­self at risk to pull the lat­ter back to safety.)

Recall that the lens inher­ently seeks to improve pre­dic­tive accu­racy. If it dis­cov­ers that it can use a new eval­u­a­tion based on the exist­ing Rivalry senses to explain these events (though value pre­dic­tion), then it will spawn this new eval­u­a­tion in no time. After that, our generic may cre­ate a new agent that is ener­gized by this new eval­u­a­tion, and voila – he now behaves like a true mem­ber of the Rivalry-cen­tered generic society.

An inter­est­ing thought is that the Mirror func­tion may play a big role in this learn­ing process. We know that the Rivalry senses can only be trig­gered if either Pain or Gain is trig­gered. Simply watch­ing some­one else gain / lose some­thing will not trig­ger the Rivalry senses, since the observer is not directly affected. But if a generic uses the Mirror func­tion, they can view a scene from a dif­fer­ent per­spec­tive and con­clude that some­one else may be expe­ri­enc­ing the Rivalry senses⁵. By being able to study events even when they are not being per­son­ally expe­ri­enced, a generic can give more train­ing data to his lens and learn about the Rivalry dynam­ics more quickly than otherwise.

1. I will some­times make analo­gies to sit­u­a­tions encoun­tered by babies / tod­dlers, because I think humans learn about the con­cept of Rivalry from a very young age (and build more advanced abstrac­tions on top of it soon after).
2. I named the func­tion after the mir­ror neu­ron, which is a neu­ron that fires either when a per­son per­forms a spe­cific action, or when they sim­ply watch some­one else do that same action. The con­cept is sim­ple, but this is actu­ally a pretty advanced piece of func­tion­al­ity. This is painfully obvi­ous to any­one work­ing in robot­ics, as there is no inher­ent con­nec­tion between a robot’s cam­eras / sen­sors and its motors / actu­a­tors. Despite the com­plex­ity, it prob­a­bly was evo­lu­tion­ar­ily advan­ta­geous for ani­mals to develop mir­ror neu­rons, since most ani­mals fre­quently inter­act with oth­ers of the same species. The world just becomes that much more pre­dictable once you real­ize that other mem­bers of your species can only do pre­cisely what you can do yourself.
3. Obviously, resources are indeed lim­ited in the real world and many ben­e­fits do have to come at some­one else’s loss. But this may not be the most press­ing con­cern in most people’s minds, espe­cially as over­all stan­dards of liv­ing improve. In the Rivalry domain, com­pe­ti­tion is in essence the only press­ing con­cern in a generic’s mind.
4. This also includes “join­ing” the soci­ety by being born into this envi­ron­ment, by the way.
5. Whether this is actu­ally true or not is a sep­a­rate issue. In the gen­eral case, two gener­ics do not share the same senses, and it may be wrong to claim that another generic is expe­ri­enc­ing Rivalry senses even though you would expe­ri­ence such senses if the same scene hap­pened to you. Frequently using the Mirror func­tion incor­rectly like this can rein­force the per­cep­tion that other peo­ple are fol­low­ing Rivalry dynam­ics, even if the true rea­son for their behav­ior is much more varied.