Month: November 2021

In the world at large (and even, it would appear, sometimes within the biological sciences) there can be a certain amount of trepidation surrounding the idea of a 'genetic tendency'. For example, if we posit a 'genetic tendency' towards aggression in human males, it seems as if we are saying something terrible. It seems even worse to posit a gene or genes 'for' aggression, even though, as Dawkins explains in The Extended Phenotype, this is exactly the same thing. A genetic basis for, a gene for, a genetic tendency towards, genetically influenced - however we phrase it, we are saying the same thing - that genes in some way contribute in the causal path.

The bogeyman of genetic tendency is at root a fear that if we have a 'gene for' X, that means that we will ineluctably do X. It can also go under the name of 'genetic determinism'. It is the idea that genes in some way control us, despite what we would like, and we (or other people) are doomed to carry out certain actions contrary to our best interests or contrary to morality or contrary to some other important social goal depending on what 'X' is.

The fear has a certain superficial credibility. After all, we all have 'genes for' hands, and we all (or almost all) end up with hands. Similarly for feet, hearts, livers, eyes, stomachs and so on. If men have a 'gene for' aggression, then surely all men end up violent?

This tempting line of reasoning contains a critical flaw. While genes for hands build hands, genes for aggression do not build violence, whatever that could mean, rather they build an aggression mechanism. Any time we have genes 'for' a behaviour, that necessarily means that the genes build a mechanism for producing that behaviour. Possessing a mechanism for a behaviour does not tell us much about how much if at all we should expect to see that behaviour. Let's consider why.

Let's suppose that we have a subroutine for punching people. I'm going to go ahead and write some pseudo-code:

function punch(thePersonToPunch){
    executePunchOn(thePersonToPunch);
}

Wow! How deterministic! If you call function 'punch' with an input of who to punch, it just punches them!

But while a mechanism for aggression must call something like the 'punch' function, that can't be the whole of the aggression mechanism. There's nothing in this code to say when it runs. It surely can't run constantly, or the poor human would just spend all its time and energy punching people and we know that doesn't happen. So the mechanism might look a bit more like this:

function aggressionMechanism(context){
    if (context.containsThreat()){
        punch(context.getThreat());
    }
}

This makes a bit more sense. We can run the aggressionMechanism constantly, and it will only output a punch if it detects that its environment contains a threat. We can say that the aggression mechanism outputs violence conditionally, in other words only under certain conditions.

Of course we can make the mechanism a bit more sensitive:

function aggressionMechanism(context){
    threatLevel = context.getThreatLevel();
    if (threatLevel < 10){
        doNothing();
    } 
    else if (threatLevel < 20){
        giveHardStare();
    }
    else if (threatLevel < 30){
        puffChest();
    }
    else {
        punch(context.getThreat());
    }
}

Now our mechanism is somewhat sensitive to the level of the threat. If it's only a mild threat, it ignores it. Slightly bigger threats gain a hard stare or a puffing of the chest. Finally, it is only very large threats that get a punch.

Hopefully we're already starting to feel somewhat safer. An 'aggression mechanism' does not need to mean constant mayhem and indeed no gene that generated constant mayhem would be likely to make it into the next generation.

But a 'gene for' a mechanism does not necessarily mean that the code of the mechanism is completely determined by the genes. We can imagine an aggression mechanism that is sensitive to the way that other people have historically treated the person who possesses the mechanism. Let's say that after a year of being treated nicely, the owner of the above mechanism now has a mechanism that looks like:

function aggressionMechanism(context){
    threatLevel = context.getThreatLevel();
    /* NOTE THE NEW THRESHOLDS! */
    if (threatLevel < 20){ // Was 10 before
        doNothing();
    } 
    else if (threatLevel < 40){ // Was 20 before
        giveHardStare();
    }
    else if (threatLevel < 60){ // Was 30 before
        puffChest();
    }
    else {
        punch(context.getThreat());
    }
}

For this hypothetical example, the structure of the mechanism has stayed the same, but the thresholds have changed. It takes a lot more for this individual to get riled up now. There's no reason a neural mechanism should not change like this. Just because something is a 'mechanism' does not mean it is completely unchangeable. Much encoding of mechanisms in the brain is done with synapse strengths and those are highly flexible.

So a 'genetically determined' aggression mechanism can nevertheless be highly conditional, firing rarely if at all, and it can be highly sensitive to environmental input, meaning that it can be configured by external input.

But we can go further. When you're considering a complex system (like a human brain), it's always a mistake to consider one component in isolation. It's important to consider the interactions between all components if we're going to understand the behaviour of the whole.

Let's make a crude model of human behavioural output. At any given moment we can decide to do any of a great number of behaviours - singing, dancing, talking, walking, running, jumping and so on. We can imagine some kind of central authority that decides which of the many possible available actions to execute. We could suppose something like:

function centralExecutive(){
    options = new List;
    options.add(getSingingMechanismRecommendation());
    options.add(getDancingMechanismRecommendation());
    options.add(getTalkingMechanismRecommendation());
    options.add(getWalkingMechanismRecommendation());
    options.add(getRunningMechanismRecommendation());
    options.add(getJumpingMechanismRecommendation());
    /* And our aggression mechanism */
    options.add(getAggressionMechanismRecommendation());

    actionToExecute = getHighestScoring(options);
    execute(actionToExecute);
}

In this toy central executive, lots of different mechanisms are polled, each one 'recommending' an action. I imagine you've experienced something similar. In the mid-afternoon, you might ask yourself, "What do I feel like doing this evening?", and you might be aware of several different options, that we can suppose come from different parts of your brain. One part says "I quite fancy some Indian food." Another part says "I should really go to the gym". Another part says "I'm tired, I just want to go home." Maybe another part says, "I'd like to meet up with some friends."

We can suppose that we have something roughly like the central executive function running all day every day. At every moment, our brain is trying to figure out what is the best thing to be doing right now, and then executing its choice.

We can also suppose that the different parts of the brain must make their recommendations in some kind of common currency, otherwise how is the executive to choose between them? We experience this subjectively as how much we 'feel like' or 'want to' do something. Generally the thing we 'want to do' the most wins. But these feelings of wanting must somehow be in the same currency or we could not compare them.

So let's suppose that there is a threat in the environment. It's a threat at level 70, so even our most recent, milder aggression mechanism is triggered. But to incorporate this new element of the central executive, we need to change our aggression mechanism slightly.

function aggressionMechanism(context){
    threatLevel = context.getThreatLevel();
    if (threatLevel < 20){
        recommendDoNothing();
    } 
    else if (threatLevel < 40){
        recommendHardStare();
    }
    else if (threatLevel < 60){
        recommendPuffChest();
    }
    else {
        recommendPunch(context.getThreat());
    }
}

The difference to the previous mechanism is that now, the mechanism only recommends courses of action to the central executive, rather than taking those actions itself.

So even though the threat level is now at 70, the aggression mechanism just says to the central mechanism "Hey, I'm strongly recommending that we punch this threat."

But crucially, the central executive has a chance to evaluate this course of action before executing it. Perhaps it runs it by the 'future simulator' function, asking it "Hey future simulator, what would happen if I punch the threat?" The future simulator might calculate the likely results and say, "Well, I think you would damage the threat but it's likely you'd end up in jail and that would be very bad."

So the central executive weighs up the pros and cons and decides against the violence, despite the aggression mechanism strongly recommending it.

Hopefully now we're feeling a lot safer.

The fact is that we can have a 'gene for' a behaviour, and that gene can 100% reliably (or close to it) build a mechanism for producing that behaviour, just as genes build hands, and yet that behaviour only be produced under very rare or specific circumstances if at all.

The existence of a mechanism does not mean it's going to produce the product it was designed to produce. I've lived in my flat for 5 years and I've never once used the central heating mechanism.

Of course we know that people aren't aggressive all the time or even most of the time, and we know that it only happens under tightly circumscribed circumstances. The point of this article is to illustrate how this is perfectly compatible with a genetic tendency towards or even genes for (it's the same thing!) aggression. The same goes for genes for any other behaviour we may care to consider.