Gender ratio in a three gender system

Question

I'm creating a human race that has 3 sexes: male, female & hermaphrodite.

Is there any biological rules that limits what should be the ratio between sexes or I could just pick whatever works best for my story?

---

I've added hermaphrodites for storytelling purposes. I don't plant to explain how they've evolved.

My gender determination system works like this:

• FF chromosome -> Female
• MF or FM chromosome -> Hermaphrodite
• MM chromosome -> Male

All the fallowing couples produce viable offspring: Sire Dam

• Male Female
• Male Hermaphrodite
• Hermaphrodite Female
• Hermaphrodite Hermaphrodite

The children of any couple could be of any of the three genders, depending what kind of chromosomes will they receive from their parents. Both sperm and eggs are haploid carrying either M or F chromosome.

Testosterone levels, height and muscles vary by individual but in general:

• Males -highest testosterone level, tallest, most muscular (John Cena, Dwayne Johnson, Vin Diesel)
• Hermaphrodites - medium testosterone level, medium height, muscles like elite female fighters due to natural doping (Ronda Rousey, Kyra Gracie, Cristiane 'Cyborg' Justino)
• Woman -lowest testosterone, shortest, least amount of muscles, looks like any normal women that doesn't like to go to gym

Answer 1

Arbitrary system

I came up with a system for handling genders. In this system, a female is FF, a male is MM, and a hermaphrodite is FM. So if a female and a male breed, they have only hermaphroditic offspring. If a hermaphrodite breeds with either other sex, there's a 50% chance of a hermaphrodite and a 50% chance that the child is the same gender as the other partner. If two hermaphrodites breed, they have a 50% chance of a hermaphrodite and 25% each for the other genders.

+---+----+----+   +---+----+----+   +---+----+----+   +---+----+----+
|   |  F |  F |   |   |  F |  F |   |   |  F |  M |   |   |  F |  M |
+---+----+----+   +---+----+----+   +---+----+----+   +---+----+----+
| M | FM | FM |   | F | FF | FF |   | M | FM | MM |   | F | FF | FM |
+---+----+----+   +---+----+----+   +---+----+----+   +---+----+----+
| M | FM | FM |   | M | FM | FM |   | M | FM | MM |   | M | FM | MM |
+---+----+----+   +---+----+----+   +---+----+----+   +---+----+----+

I ran some simulations (code and assumptions at the bottom). I found a slight preference for hermaphroditic offspring overall but a stable one. So perhaps 56-57% hermaphrodite and evenly distributed between the other two. Note that it is possible to favor males over females or vice versa. For example, a rule that hermaphrodites and females only breed with males (possibly allowing males with multiple spouses) would eliminate females and keep females eliminated so long as it was followed.

This was based purely on those rules. If you have different rules, then you're going to get different results. It might be better to approach the problem from the other direction. How would you like to split the genders and why? Some splits may not have an easy explanation.

Alternatives

I read a book a while ago where gender was determined by the gender ratio around the child. So all children were neuters. The move to adulthood occurred when the child would develop a gender. A child surrounded by females would become male. A child surrounded by males would become female. You could extend that to include hermaphrodites (surrounded by equal numbers of males and females). And you could provide arbitrary rules for the development of children surrounded by hermaphrodites. That society could choose its gender ratio if it wanted.

We often act like males and females are perfectly evenly divided in humans. But actually Y sperm are more likely to form. This is partially offset as Y sperm are less likely to succeed to fertilization. But overall, there are more boy babies than girl babies. Boys/men are also more fragile, dying in accidents more often. With modern medicine, women seldom die due to pregnancy. So by retirement age, there are more women than men.

Anyway, you can use similar mechanisms to alter ratios in your humanoids. Perhaps there is some birth defect that is common in one gender or another that leads to miscarriage. Perhaps hermaphrodites produce less sperm. Perhaps the genetics is more complicated.

Simulation code

GenderSimulator.java

import java.security.SecureRandom;
import java.util.EnumMap;
import java.util.Map;
import java.util.Random;

public class GenderSimulator {

    public enum Gender {
        FEMALE, HERMAPHRODITE, MALE;

        public Gender opposite() {
            switch (this) {
            case FEMALE:
                return MALE;
            case MALE:
                return FEMALE;
            default:
                return null;
            }
        }
    }

    public static class Generation {

        Map<Gender, Integer> genderCounts = new EnumMap<Gender, Integer>(Gender.class);

        public Generation() {
            this(0, 0, 0);
        }

        public Generation(int femaleCount, int hermaphroditeCount, int maleCount) {
            genderCounts.put(Gender.FEMALE, femaleCount);
            genderCounts.put(Gender.HERMAPHRODITE, hermaphroditeCount);
            genderCounts.put(Gender.MALE, maleCount);
        }

        public Generation generateNext() {
            Generation generation = new Generation();

            generateRandomCouples(generation);
            generateFemaleMaleCouples(generation);
            generateCouples(generation, Gender.FEMALE);
            generateCouples(generation, Gender.MALE);
            generateFromHermaphrodites(generation);

            return generation;
        }

        public int size() {
            int sum = 0;

            for (int count : genderCounts.values()) {
                sum += count;
            }

            return sum;
        }

        public int count(Gender gender) {
            Integer count = genderCounts.get(gender);

            return (count == null) ? 0 : count;
        }

        private void add(Gender gender, int amount) {
            int count = count(gender);
            genderCounts.put(gender, count + amount);
        }

        private Gender chooseGenderChildOfHermaphrodites() {
            int choice = RANDOM.nextInt(4);
            if (choice == 0) {
                return Gender.FEMALE;
            } else if (choice == 3) {
                return Gender.MALE;
            } else {
                return Gender.HERMAPHRODITE;
            }
        }

        private Gender chooseGenderChild(Gender gender) {
            return RANDOM.nextBoolean() ? Gender.HERMAPHRODITE : gender;
        }

        private Gender chooseGenderParent() {
            int choice = RANDOM.nextInt(count(Gender.HERMAPHRODITE) + count(Gender.MALE) + count(Gender.FEMALE));
            if (choice < count(Gender.HERMAPHRODITE)) {
                return Gender.HERMAPHRODITE;
            } else if (choice < count(Gender.HERMAPHRODITE) + count(Gender.MALE)) {
                return Gender.MALE;
            }

            return Gender.FEMALE;
        }

        private boolean hasHermaphroditeParent(Gender gender) {
            return RANDOM.nextInt(count(Gender.HERMAPHRODITE) + count(gender)) < count(Gender.HERMAPHRODITE);
        }

        private void breedWith(Generation generation, Gender gender) {
            add(gender, -1);
            if (hasHermaphroditeParent(gender.opposite())) {
                add(Gender.HERMAPHRODITE, -1);
                generation.add(chooseGenderChild(gender), 1);
                generation.add(chooseGenderChild(gender), 1);
            } else {
                add(gender.opposite(), -1);
                generation.add(Gender.HERMAPHRODITE, 2);
            }
        }

        private void generateFemaleMaleCouples(Generation generation) {
            int maleCount = count(Gender.MALE);
            int femaleCount = count(Gender.FEMALE);

            int count = Math.min(maleCount, femaleCount);

            genderCounts.put(Gender.MALE, maleCount - count);
            genderCounts.put(Gender.FEMALE, femaleCount - count);

            generation.add(Gender.HERMAPHRODITE, 2 * count);
        }

        private void generateRandomCouples(Generation generation) {
            while (count(Gender.HERMAPHRODITE) - 1 > Math.abs(count(Gender.MALE) - count(Gender.FEMALE))
                    && count(Gender.FEMALE) > 0 && count(Gender.MALE) > 0) {
                Gender parent = chooseGenderParent();
                if (parent == Gender.HERMAPHRODITE) {
                    add(Gender.HERMAPHRODITE, -1);
                    Gender other = chooseGenderParent();
                    if (other == Gender.HERMAPHRODITE) {
                        add(Gender.HERMAPHRODITE, -1);
                        generation.add(generation.chooseGenderChildOfHermaphrodites(), 1);
                        generation.add(generation.chooseGenderChildOfHermaphrodites(), 1);
                    } else {
                        add(other, -1);
                        generation.add(chooseGenderChild(other), 1);
                        generation.add(chooseGenderChild(other), 1);
                    }
                } else {
                    breedWith(generation, parent);
                }
            }
        }

        private void generateCouples(Generation generation, Gender gender) {
            while (count(gender) > 0 && count(Gender.HERMAPHRODITE) > 0) {
                add(gender, -1);
                add(Gender.HERMAPHRODITE, -1);
                generation.add(chooseGenderChild(gender), 1);
                generation.add(chooseGenderChild(gender), 1);
            }
        }

        private void generateFromHermaphrodites(Generation generation) {
            while (count(Gender.HERMAPHRODITE) > 1) {
                add(Gender.HERMAPHRODITE, -2);
                generation.add(generation.chooseGenderChildOfHermaphrodites(), 1);
                generation.add(generation.chooseGenderChildOfHermaphrodites(), 1);
            }
        }

        public String toString() {
            return toString("-");
        }

        public String toString(String delimiter) {
            StringBuilder builder = new StringBuilder();

            builder.append(genderCounts.get(Gender.FEMALE));
            builder.append(delimiter);
            builder.append(genderCounts.get(Gender.HERMAPHRODITE));
            builder.append(delimiter);
            builder.append(genderCounts.get(Gender.MALE));

            return builder.toString();
        }

    }

    public final static Random RANDOM = new SecureRandom();

    public static void main(String[] args) {
        Generation generation = new Generation(2150, 5700, 2150);
        System.out.println(generation);
        int size = generation.size();
        while (true) {
            generation = generation.generateNext();
            System.out.println(generation);
            if (size != generation.size()) {
                break;
            }
            size = generation.size();
        }
    }

}

Assumptions:

• Breeding is monogamous (if you breed with someone, all your children are with that someone);
• Any compatible and available partner is equally likely (hermaphrodites are neither preferred nor avoided as partners relative to the other genders);
• No male/male or female/female relationships, as those wouldn't produce offspring;
• Every couple has two children (stable population);
• Everyone breeds with someone (also needed for a stable population).

Note that this code is not particularly flexible. You can't swap breeding strategies in and out. That's hard coded. Changing the first generation involves modifying code. This is mainly designed to test my initial hypothesis that hermaphrodites would make up 50% of the population. That does not seem to be true. The hermaphrodite population stabilizes around 56-57% when everything is random.

The other genders are less stable, fluctuating in a much wider band.

I used interior classes because it was easier for me to do this in just one file. I used SecureRandom because I didn't seem to need more efficiency, and I wanted to be sure that my results weren't being tainted by too much pseudo in my random. I didn't notice any difference between the two, so you could switch back if you wanted.

Answer 2

Sex ratios are controlled more by mating strategy than anything else, even species with the same sex chromosomes can have vastly different sex ratios. So really it is controlled by how many partners each sex has at a time. if your species is monogamous, or serial monogamous like humans, then you actually can have a wide range becasue the normal 1:1 gets thrown for a loop when you have both sexes at the same time as an option. I suspect you will quickly see the hermaphrodite begin to dominate the gene pool since they can switch hit depending on circumstances.

Males are high risk but potentially high reward, like a lottery, less likely to find a mate but also capable of hitting the Genghis Khan jackpot. Females are a conservative but safer bet, they are almost guaranteed to reproduce but have an upper limit on on the number of offspring they can have. So if their ratio gets unbalanced the opposite sex has a big advantage so the people will have more of that sex until they reach equilibrium again. Too many males and males have even less of chance to find a mate so females get favored, if females dominate males have a much better chance of finding multiple partners so males get favored.

Hermaphrodite have both a sure thing and the chance of the jackpot. The only thing preventing hermaphrodite domination is if males or females (or both) are less willing to mate with hermaphrodites than the opposite sex.

So really it's entirely dependent on how hermaphrodites are viewed as possible mates. If they are just as desirable as the opposite sex soon all you have is hermaphrodites. basically the less males and females are willing to mate with hermaphrodites the closer to male/female domination you will see and the more willing they are the closer to hermaphrodite domination you will get.

Answer 3

Well, that's the same three sexes that our human race has.

If you're going for reality then, make the ratios the same. It's approximately equal split between men and women (101 men to 100 women) and about 1 in 2,000 for hermaphrodites.

Answer 4

If there are three genders, are all three required to breed? In that case, equal numbers of each at the age of adolescence will be the end state of evolutionary pressure. (In humans now, for example, more male infants are born than female, about 105-100, but they are more fragile and more of them die in childhood, so the numbers are just about equal at puberty.)

If they are based on humans, then you could have a triplex gender chromosome - XXX is female, YYY is male, and XXY or XYY is hermaphrodite. (In truth, we get these variations naturally, and they are not really hermaphrodites - look them up if you are interested.)

It could also be a different kind of genetic mechanism. For example, Sigourney Weaver is genetically XY, but her testosterone receptors don't work, so her body is the default (female) shape, but without all the curves estrogen would create.

Your hermaphrodites might be a variation like this, hormonal-based, rather than chromosomal. Many of the naturally-occurring variations like this are infertile, though. And those that are fertile, are only fertile in either the male or the female structure, not both.

You could go with two types of hermaphrodite that look similar externally, but are only fertile in one of the structures.

Or give up trying to be scientific, wave your hands, and carry on with the story!

Answer 5

Figure out your genetics. Here are your pairings:

• M+F
• M+H
• H+H
• H+F

H has more breeding options, so it's the better fitness function. If H is a dominant trait, it will dominate over time. If H is a recessive trait, it'll drop towards 25%. If any pairing can result in any gender, they'll balance out. This is assuming there is no cultural pressure to bias prospective mates away or toward one of the genders.