A test cross crosses an individual with a homozygote for recessive alleles, allowing suitable offspring phenotypes to reveal transmitted gamete combinations.

Independent assortment means that transmission at different genetic loci has conditional independence given the parental genotype. With fair Mendelian segregation, a parent heterozygous at two genetic loci, $AaBb$, produces $AB,Ab,aB,ab$ gametes with probability $1/4$ each. For example,Here $AB$ labels an allele combination; it does not assert that the two genetic loci lie on the same chromosome.

The physical model is stochastic orientation of different homologous chromosome pairs toward the two poles of the spindle apparatus in meiosis I. One pair's orientation does not determine another's. For two pairs, one division can send $A,B$ together and $a,b$ together; another can send $A,b$ together and $a,B$ together. See The Process of Meiosis (§11.1, Metaphase I and Figure 11.5: random orientation of chromosome pairs).

With $k$ distinguishable homologous chromosome pairs, there are $2^k$ choices of parental homologous chromosome origin for a product at a specified pole, each with probability $2^{-k}$ under this model. For $k=3$, enumerate $MMM,MMP,MPM,MPP,PMM,PMP,PPM,PPP$, where M and P mark parental origins. Whole-pole reversal pairs complementary choices, leaving $2^{k-1}$ unordered partitions for $k\ge 1$. For $k=2$ there are four choices for a specified pole but only the two relative orientations drawn. This counts possible products across meioses, not eight different products of one division when $k=3$. Identical alleles at scored genetic loci can also make different parental-origin choices observationally indistinguishable.

Independent assortment of different chromosome pairs does not imply independence of every pair of genes. Nearby genetic loci on the same chromosome can show genetic linkage. Chromosomal crossover can create new haplotypes, but does not automatically erase genetic linkage. See Laws of Inheritance (§12.3, Law of Independent Assortment and Linked Genes Violate the Law of Independent Assortment). In the ordinary fair two-locus model with parental haplotypes $AB/ab$ and recombination fraction $r$,Thus $r=0$ gives only the two parental haplotypes, while $r=1/2$ gives four equal probabilities. A recombination fraction of $1/2$ alone does not establish that the genetic loci lie on different chromosomes.

A motivating experiment appears in Experiments in Plant Hybridization by Gregor Mendel (§9, “The Reproductive Cells of the Hybrids”). In peas, hybrids for round versus wrinkled seeds and yellow versus green seeds were crossed reciprocally with constant wrinkled-green plants. The readout was visible seed shape and color: hybrid seed parents gave 31 round-yellow, 26 round-green, 27 wrinkled-yellow and 26 wrinkled-green; the reciprocal cross gave 24, 25, 22 and 27.

The apparatus was controlled pollination: opening immature flowers, removing stamens with forceps, and applying selected pollen to the stigma. Two-year trials established constant parental characters; greenhouse pots checked interference from insects in outdoor beds. Reciprocal crosses tested both transmission directions. These procedures are described in Experiments in Plant Hybridization by Gregor Mendel (§§2–3).

With complete dominance at both genetic loci, this test cross makes each phenotype report one hybrid gamete combination. The ideal expected values are $110/4=27.5$ and $98/4=24.5$ per class. The observations support four transmitted combinations, approximately equally frequent. They do not directly image chromosome orientation or prove independence for all genes; failed development and seed germination also limit the inference, as §9 notes.

An ordered sequence of memory references, recording repetitions as well as addresses. The example under memory cache records twelve reads in decimal physical addresses; the trace itself does not determine cache hits until cache line size, capacity, initial contents, placement and replacement are specified.

For a terminating pure function, a reusable entry must record its correct completed result, and equal memoization keys must imply equal results throughout the entry's memoization cache lifetime. Reusing that result must also preserve the behavior callers require. These conditions separate correctness from speed: a complete key can be correct even if it rarely repeats.

A procedure using deterministic computation can still have a required side effect. If a procedure returns $n^2$ and appends an audit record on every call, serving the second call from a table preserves the numerical answer but skips the second record. Likewise, if each call promises a fresh mutable list, returning the same stored mutable list changes observable sharing and allows a caller to damage later answers. Plain result reuse is unsuitable for those contracts.^[ref]

Completion matters for recursion. Suppose computing key $A$ needs key $B$, and computing $B$ needs $A$. A table containing only completed answers has no answer to return for the second $A$; remembering completed values does not make this directed cycle terminate. Marking a key ACTIVE before descending detects re-entry, as in spreadsheet dependency evaluation, but detection is not a solution of the circular equations. If computation fails, clear its active mark and do not publish an unfinished value. The example using Fibonacci numbers avoids this issue through a strictly decreasing argument.

The call counts above assume sequential execution and no eviction. Concurrent requests for an absent key can both begin evaluation before either publishes its result; keeping a table coherent alone does not ensure one body execution per key.^[ref]

Under constant-cost lookup and integer addition, Memoized Fibonacci evaluation has time complexity $O(n)$ in Big O notation, retaining $O(n)$ values. A hash table needs its own lookup-cost assumptions; an array indexed by $0,\dots ,n$ avoids hash collisions in this example. Memoization removes repeated bodies, but also pays for keys, lookups and retained answers. A workload without reuse can pay those costs without saving evaluations.

The call stack remains. Left-first recursion descends through arguments $n,n-1,\dots ,1$ before returning, giving $n$ simultaneously active frames for $n\ge 2$. Therefore the auxiliary space complexity includes $O(n)$ frames as well as $O(n)$ table entries in the constant-size-value model. An iterative bottom-up dynamic programming calculation removes these recursive frames; retaining only the two previous Fibonacci numbers suffices when only the final value is wanted, but discards the table useful for later requests.

Exact Fibonacci numbers do not remain constant-size values. For $k\ge 2$, the recurrence relation gives $2^{(k-2)/2}\le F_k\le 2^{k-1}$, so the representation of $F_k$ as a binary number has order $k$ bits. With ordinary addition costing order $k$ bit operations on such operands, the $n-1$ additions cost order $n^2$ bit operations in total. Retaining all values also requires order $n^2$ bits of value storage, before keys and frame overhead. The linear bound counts additions under its stated cost model; it is not a linear bound on exact integer arithmetic in bits.^[ref]

The Fibonacci numbers give an exact example. For a nonnegative integer $n$, their recurrence relation isTo obtain $F_5=5$ by direct recursion, evaluate $F_4$ and $F_3$ separately; computing $F_4$ also evaluates $F_3$. The full call tree has 15 occurrences but just six distinct arguments, $0,1,2,3,4,5$. Shared dependencies form a directed acyclic graph because every directed edge goes to a strictly smaller argument. Memoization evaluates a distinct argument on first demand; filling values in increasing argument order is the corresponding bottom-up dynamic programming calculation.^[ref]

Use an initially empty hash table memo, shared by every recursive call. Count even the first evaluations of the two base cases, store only completed results, evaluate the left term first, and retain all entries. The following original procedure assumes a nonnegative integer argument:

def cached_fib(n, memo):
    if n in memo:
        return memo[n]
    if n < 2:
        value = n
    else:
        value = cached_fib(n - 1, memo) + cached_fib(n - 2, memo)
    memo[n] = value
    return value

Every self-call must pass through the memoization lookup. Wrapping only the outer call while leaving inner calls uncached retains the repeated work. Test membership rather than whether the stored value is nonzero: $F_0=0$ is a valid completed result.

For cold $F_5$, the lookup arguments are $5,4,3,2,1,0,1,2,3$. The first six are absent; the last three reuse completed answers. Results are stored on return in argument order $1,0,2,3,4,5$, with values $1,0,1,2,3,5$. Thus there are nine wrapper calls, six body evaluations and four additions. Repeating $F_5$ with the same table takes one wrapper call and no body evaluation. Requesting $F_6$ next evaluates only its body, reuses $F_5$ and $F_4$, and stores $F_6=8$: three wrapper calls, one body evaluation and two hits.

The direct-call count satisfies $C_0=C_1=1$ and $C_n=1+C_{n-1}+C_{n-2}$. Its exact solution is $C_n=2F_{n+1}-1$, as substitution into this recurrence relation verifies. With the specified memoization procedure, a cold call at $n\ge 2$ evaluates $n+1$ distinct bodies, makes $n-1$ additions and makes $2n-1$ wrapper calls. There are $n-2$ hits: each of the $n-1$ nonbase bodies issues two recursive calls, in addition to the initial call. The difference is between the number of occurrences and the number of distinct subproblems.

Overlapping subproblems occur when several parts of a calculation request the same smaller problem. Memoization can share its answer if the memoization key identifies that problem completely. For the Fibonacci numbers, both $F_5$ and $F_4$ require $F_3$. In dynamic programming, the dynamic programming state plays the corresponding role of identifying a reusable continuation. Overlap explains potential savings; the recurrence relation and its base cases still need to be correct.