Cell Division and Meiosis

Genetics and Heredity Fundamentals

Course 1 · Chapter 4 · Cell Division and Meiosis

Genetics and Heredity Fundamentals 3 followed a gene to its protein. This chapter asks a different question: how does DNA get from one cell to the next, and from parent to child? The answer is two kinds of cell division. One makes exact copies; the other shuffles and halves the DNA to make sex cells. The shuffling is the reason Genetics and Heredity Fundamentals 1 could talk about chance at all, and it is why brothers and sisters are alike but not identical. All the programs here are Python 3.

What was run, and what was not

Every program in this chapter was run and the output shown is what it printed. The biology is written from general knowledge; items marked (check) are the ones to verify first. Where a program uses random numbers it fixes the seed, so the same output appears each time.

Copying DNA First

Before a cell divides it copies its DNA. The pairing rules from Genetics and Heredity Fundamentals 2 make this easy: if the two strands of the double helix are pulled apart, each one can serve as a template for building a new partner. The result is two double helices, each made of one old strand and one newly built strand. This is called semi-conservative copying (check). In code, the new strand is just the complement of the old one.

PAIR = {"A": "T", "T": "A", "C": "G", "G": "C"}

def replicate(strand):
    return "".join(PAIR[b] for b in strand)

old = ("ATGCCGTA", "TACGGCAT")
new1 = (old[0], replicate(old[0]))
new2 = (replicate(old[1]), old[1])
print(new1)
print(new2)
print(new1 == old, new2 == old)
    

('ATGCCGTA', 'TACGGCAT')
('ATGCCGTA', 'TACGGCAT')
True True
    

Each new double helix matches the original exactly. (Real copying makes rare mistakes, and cells have proofreading and repair that catch most of them; check. Those rare mistakes are the source of the mutations in Genetics and Heredity Fundamentals 3.) After copying, each chromosome consists of two identical halves joined together, called sister chromatids (check).

Mitosis: Two Identical Cells

Mitosis is the division used for growth and repair. One cell copies its DNA and then splits into two daughter cells, each receiving a full set of chromosomes. Each daughter cell has the same chromosome number as the parent cell and the same DNA. A human body cell has 46 chromosomes in 23 pairs, one of each pair from each parent (check), and after mitosis both daughters have 46.

A cell with two sets of chromosomes is called diploid, written 2n. A cell with one set is haploid, written n. For humans n = 23 and 2n = 46 (check). We can model a cell as a list of chromosome pairs, with m marking the one from the mother and p the one from the father.

Meiosis: Halving the Set

Meiosis makes the sex cells, or gametes: sperm and egg cells in animals. If gametes carried the full 2n set, a child would get 2n from each parent, 4n in all, and the number would double every generation. Instead meiosis cuts the number in half, so a gamete is haploid, and fertilisation joins two gametes to restore 2n.

The process has two rounds of division after a single copying of the DNA (check). In the first round the homologous pairs (the maternal and paternal copy of each chromosome) line up together and are separated, so each daughter gets one chromosome of each pair. In the second round the sister chromatids are separated. One starting cell ends up as four gametes (in humans, check that the egg-making version divides unequally and gives one working egg rather than four). The important point for us is the first round: for each pair, which of the two chromosomes goes into a given gamete is a matter of chance.

	Mitosis	Meiosis
Purpose	growth, repair	making gametes
DNA copying rounds	one	one
Divisions	one	two
Cells produced	two	four
Chromosome number	stays 2n (46)	halves to n (23)
Daughter cells	identical to the parent	different from the parent and from each other

import random

def mitosis(cell):
    return [list(cell), list(cell)]

def meiosis(cell, rng):
    return [[rng.choice(pair) for pair in cell] for _ in range(2)]

cell = [("m1", "p1"), ("m2", "p2"), ("m3", "p3")]
rng = random.Random(4)
a, b = mitosis(cell)
print(len(cell), len(a), len(b), a == b == cell)
for gamete in meiosis(cell, rng):
    print(gamete, len(gamete))
    

3 3 3 True
['m1', 'p2', 'm3'] 3
['p1', 'p2', 'm3'] 3
    

Mitosis returns two copies equal to the parent (the pairs are kept; the lists hold three entries each). Meiosis returns gametes of length 3, one chromosome per pair, and the two gametes differ: here they disagree on the first pair. This is a simplified model: it makes only two gametes where real meiosis makes four, and it ignores crossing over, which comes next.

Counting the Possible Gametes

Because each pair is sorted independently, the number of different gametes doubles with every extra pair. With 3 pairs there are 2 x 2 x 2 = 8 possible gametes; with the human 23 pairs there are 2²³. This shuffling of whole chromosomes is called independent assortment, and Genetics and Heredity Fundamentals 5 returns to it for two genes at once.

from itertools import product

pairs = [("m1", "p1"), ("m2", "p2"), ("m3", "p3")]
combos = list(product(*pairs))
print(len(combos), combos[0], combos[-1])
print(2 ** 3, 2 ** 23, (2 ** 23) ** 2)
    

('m1', 'm2', 'm3') ('p1', 'p2', 'p3')
8388608 70368744177664
    

A single person can therefore make 8,388,608 different gametes by assortment alone. Two parents can combine any of one person's gametes with any of the other's: 8,388,608 squared is 70,368,744,177,664, about 70 trillion different children, before counting crossing over. (The number is an upper bound on what chance allows; it treats every chromosome as distinct and ignores real-world constraints. check)

Crossing Over

During the first round of meiosis, the maternal and paternal copies of a chromosome lie alongside each other and can swap matching stretches. This is called crossing over (or recombination). After a swap, a chromosome is a mosaic: part from the grandmother's line and part from the grandfather's. In human meiosis there are typically a few crossovers per chromosome pair (check), so the gametes' chromosomes are mixtures, not copies of either original.

We can model two chromosomes as strings and swap the tails at a chosen point. Here the mother's copy is all A and the father's all b, so you can see exactly what came from where.

def cross_over(mat, pat, point):
    return mat[:point] + pat[point:], pat[:point] + mat[point:]

mat, pat = "AAAAAAAAAA", "bbbbbbbbbb"
print(cross_over(mat, pat, 4))
print(cross_over(mat, pat, 0))
print(cross_over(mat, pat, 10))
    

('AAAAbbbbbb', 'bbbbAAAAAA')
('bbbbbbbbbb', 'AAAAAAAAAA')
('AAAAAAAAAA', 'bbbbbbbbbb')
    

A swap at position 4 gives two new chromosomes, each with the first four letters from one parent line and the last six from the other. Swapping at position 0 or 10 exchanges everything or nothing, which is the same as no crossing over at all (the two results are just the originals, possibly swapped). Crossing over does not change what is on a chromosome overall; it changes which pieces travel together. That is why two genes close together on one chromosome are usually inherited as a pair, and why genes far apart behave almost as if on different chromosomes (check). Genetics and Heredity Fundamentals 5 covers this under the name linkage.

Why Siblings Differ

Every child of the same two parents gets one gamete from each, and each gamete is one random draw from millions of possibilities. We can put numbers on this. Write a gamete as a string of 23 letters, m or p, saying which chromosome of each pair it contains, and count how many positions two gametes share. (This ignores crossing over, so the real figures are fuzzier than the model; check.)

def gamete(rng, n=23):
    return "".join(rng.choice("mp") for _ in range(n))

def shared(x, y):
    return sum(i == j for i, j in zip(x, y))

rng = random.Random(1)
g1, g2 = gamete(rng), gamete(rng)
print(g1)
print(g2)
print(shared(g1, g2))
trials = 20000
mean = sum(shared(gamete(rng), gamete(rng)) for _ in range(trials)) / trials
print(round(mean, 1), 23 / 2)
    

mmpmppppmmpmppmppmmpmmm
mpmpmmppmpmmppmpmmpmppm
11
11.5 11.5
    

Two gametes from the same parent share 11 of 23 positions in this example, and on average they share half, 11.5 of 23, as chance predicts. So two children of the same parents get, from each parent, a set of chromosomes that matches the sibling's about half the time at each chromosome. The chance that two gametes from one person are identical is 1 in 2²³, about one in 8.4 million, and for two children to match from both parents it is the square of that. So, apart from identical twins (who come from a single fertilised egg that splits; check), siblings are very unlikely to carry the same combination.

"Half" is an average, not a rule

Siblings are often said to share half their DNA. That is the average over many pairs of siblings; a particular pair can be above or below it, and crossing over spreads the figure further (check). Full siblings can also look much more alike or much less alike than the average suggests, because appearance depends on many genes and on environment as well.

Challenges

Exercise 1

For n = 1 to 5 pairs of chromosomes (named m1, p1, m2, p2 and so on), list every possible gamete with itertools.product, count the distinct ones, and check that the count equals 2ⁿ.

📄 View solution

Exercise 2

Write cross_over_many(mat, pat, points) that swaps tails at each point in the list, one after another, and returns the two resulting chromosomes. Run it on "AAAAAAAAAA" and "bbbbbbbbbb" with points [4], [3, 7], [2, 5, 8] and an empty list, and check at every position that the two results together still hold one A and one b.

📄 View solution

Exercise 3

Model parents who each have only 3 chromosome pairs. Each child gets one gamete from each parent. Simulate 100,000 pairs of children (use random.Random(11)) and find the fraction of pairs in which both children carry exactly the same chromosomes. Compare it with the exact chance, (1/2³)².

📄 View solution

Quick Reference

Mitosis: one cell becomes two identical cells; chromosome number stays 2n
Meiosis: two divisions after one copying; makes gametes with n chromosomes
Diploid / haploid: 2n (two sets, 46 in humans) / n (one set, 23)
Independent assortment: each pair is sorted separately, giving 2ⁿ gametes
Crossing over: matching stretches of paired chromosomes are swapped, creating mosaics
Check: the counts of chromosomes, the number of crossovers, the egg-making details, the statement about siblings sharing half

Coming next

Genetics and Heredity Fundamentals 5 follows two genes at once: when they are inherited independently, and when crossing over cannot separate them.