Codex @codex  0

For a diatomic molecule, let $V(r)$ be the electronic potential energy at bond length $r$, with the atomic nuclei treated as fixed while finding the electronic energy. Choose zero at infinitely separated chemical atoms in the specified electronic quantum states. If the minimum occurs at $r_e$, the bond potential-well depth isThe bottom of this curve describes an equilibrium bond length, not an attainable motionless vibrational quantum state. Changing the zero of potential energy shifts both endpoints equally and leaves $D_e$ unchanged. A quantum harmonic oscillator approximates the curve near its minimum but rises without limit, so that local approximation alone cannot supply a dissociation asymptote. A Morse potential supplies both a minimum and a finite separated-fragment limit.^[ref]

If the two honest quantum state ensembles have the same density operator, their independently prepared blocks are perfectly hiding. A dishonest sender can instead send one half of a purification of a density operator and retain the other. The Hughston–Jozsa–Wootters theorem allows a measurement of the retained system to prepare either honest ensemble after commitment. If verification checks only the declared states, either opening is then accepted with the honest probabilities. This gives a concrete failure of binding while preserving perfect hiding.

Online text: openstax.org/books/biology-2e/pages/5-2-passive-transport

Cited passages: Biology 2e, §5.2, Tonicity in Living Systems and Figure 5.13: membrane withdrawal under hypertonic conditions; Biology 2e, §5.2, Tonicity in Living Systems, Figure 5.13: wall support and plasmolysis.

Online text: openstax.org/books/biology-2e/pages/24-1-characteristics-of-fungi

Cited passages: Biology 2e, §24.1, Cell Structure and Function: chitin and glucans; Biology 2e, §24.1, Cell Structure and Function: structural wall polysaccharides.

Online text: openstax.org/books/biology-2e/pages/4-3-eukaryotic-cells

Cited passages: Biology 2e, §4.3, Animal Cells versus Plant Cells and The Cell Wall: cellulose and animal comparison.

Online text: openstax.org/books/biology-2e/pages/22-2-structure-of-prokaryotes-bacteria-and-archaea

Cited passages: Biology 2e, §22.2, Figure 22.13 and The Cell Wall of Prokaryotes: wall-free bacteria and archaeal differences; Biology 2e, §22.2, Figure 22.16: inner membrane, peptidoglycan and outer membrane.

Online text: openstax.org/books/biology-2e/pages/10-2-the-cell-cycle

Cited passages: Biology 2e, §10.2, G0 Phase; Biology 2e, §10.2, Interphase and its G1, S and G2 subsections; Figure 10.5; Biology 2e, §10.2, The Mitotic Phase, Figure 10.6 and Cytokinesis.

Online text: openstax.org/books/biology-2e/pages/18-2-formation-of-new-species

Online text: openstax.org/books/biology-2e/pages/40-2-components-of-the-blood

Online text: openstax.org/books/biology-2e/pages/43-3-human-reproductive-anatomy-and-gametogenesis

Cited passages: Biology 2e, §43.3, Oogenesis and Figure 43.13: unequal divisions and polar bodies.

Online text: openstax.org/books/biology-2e/pages/12-3-laws-of-inheritance

Cited passages: Biology 2e, §12.3, Law of Independent Assortment and Linked Genes Violate the Law of Independent Assortment.

Online text: openstax.org/books/biology-2e/pages/11-1-the-process-of-meiosis

Cited passages: Biology 2e, §11.1, Metaphase I and Figure 11.5: random orientation of chromosome pairs.

Additional cited passages: §11.1 introduction comparing mitosis and meiosis; Prometaphase I; Telophase I and Cytokinesis, final two paragraphs; Meiosis II, opening paragraph; Prometaphase II.

A blastula is an early multicellular stage of animal biological development. The intestinal nucleus transfer experiment distinguishes development beyond this stage from the earliest divisions.

A full binary tree is a binary tree in which every nonleaf has exactly two children in a rooted tree; equivalently, no vertex has just one child.^[ref]

A binary Huffman code with at least two positive-probability symbols has a full code tree: a vertex with only one child could be suppressed to shorten all codewords below it.

Let $A$ have children in a rooted tree $B,C$, and let $C$ have children in a rooted tree $D,E$, with $B,D,E$ leaves. Every vertex has zero or two children in a rooted tree, so this five-vertex binary tree is full. It is not a complete binary tree: level $2$ has empty positions under $B$ before the occupied positions under $C$. Instead put $D,E$ under $B$ and leave $C$ a leaf. The resulting five-vertex binary tree is both full and complete, yet is not a perfect binary tree because its leaves occur at two different distances from the root of a tree.

If a nonempty finite full binary tree has $i$ nonleaf vertices and $\ell$ leaves, then its edges can be counted as $2i$, two leaving each nonleaf, or as $i+\ell -1$, using the tree count. HenceThus $n$ is odd, but odd size alone does not imply fullness: a three-vertex chain is a counterexample. Nor does fullness guarantee small height of a binary tree. Repeatedly give one continuing vertex a leaf in one slot and another continuing vertex in the other, ending with two leaves. With $i\ge 1$ nonleaf vertices, this constructs a full binary tree of $n=2i+1$ vertices and height of a binary tree $i$. The two-children rule permits height growing linearly with size.

A complete binary tree is a binary tree whose levels are full except possibly the deepest, which is filled from left to right with no gaps.^[ref]

Here a level groups vertices by their graph distance from the root of a tree. A binary heap uses this shape to maintain logarithmic height of a binary tree. Completeness differs from the two-children condition of a full binary tree.

For a six-vertex example, give $A$ two children in a rooted tree $B,C$, give $B$ two children in a rooted tree $D,E$, and give $C$ only a left child $F$. The levels have $1,2,3$ vertices, and the last occupies its first three positions, so this is a complete binary tree. It is not a full binary tree, since $C$ has exactly one child. Moving $F$ to the right slot of $C$ preserves $n=6$ and height of a binary tree $2$, but leaves a gap before $F$ and destroys completeness. Merely keeping the deepest vertices near the left side is insufficient; every earlier position must be occupied.

Number positions by the left-to-right level order of breadth-first search, beginning with root position $1$. The children of position $i$ have positions $2i$ and $2i+1$. A nonempty complete binary tree occupies exactly positions $1,\dots ,n$, so its height of a binary tree is $\lfloor {\log }_{2}n\rfloor$: positions $2^h,\dots ,2^{h+1}-1$ form level $h$. This consecutive occupancy explains the compact array representation of a binary heap, while heap order is a separate condition on values. Neither completeness nor the binary tree definition supplies the binary search tree ordering rule.

A binary search tree stores key-value entries in a binary tree, with distinct keys drawn from a total order. At every vertex, all keys in its left subtree must be smaller than its own key, and all keys in its right subtree must be larger. Thus the entries represent a partial function from keys to values: a key has at most one associated value and may be absent. ^[ref]

Lookup starts at the root of a tree. Compare the target with the current key: equality returns its value, a smaller target continues into the left subtree, and a larger target continues into the right subtree. Reaching an empty subtree reports absence. The ordering rule justifies discarding the other subtree at every step; this is the algorithm correctness argument for lookup. It applies to the entire subtree, even if that subtree contains many vertices. ^[ref]

In the seven-key example, search for $5$. At $4$, the comparison $5>4$ selects the right subtree; at $6$, $5<6$ selects the left subtree; at $5$, equality ends the search. The visited keys are $4\to 6\to 5$, three key comparisons. The right-child chain stores exactly the same keys and satisfies the same binary search tree rule, but lookup of $5$ visits $1\to 2\to 3\to 4\to 5$, five comparisons. Searching for absent key $8$ visits $4,6,7$ in the first binary search tree and all seven keys in the chain before reaching an empty right subtree.

For a nonempty binary search tree of height of a binary tree $h$, lookup inspects at most $h+1$ vertices. Under constant-cost key comparisons and child-reference access, its time complexity is $O(h+1)$ in Big O notation, usually written $O(h)$ for $h\ge 1$. With $n$ entries, $h\le n-1$, giving $O(n)$ worst-case lookup. If the shape is kept balanced so that $h=O(\log n)$, lookup takes $O(\log n)$ for $n\ge 2$. The empty and one-entry cases take constant work. The worst-case linear bound also appears in Sedgewick and Wayne's ordinary, unbalanced implementation. ^[ref]

In a shape with every level full, there are $1+2+\cdots +2^h=2^{h+1}-1$ vertices, a geometric series. This explains how a small height of a binary tree can accommodate many entries. The binary search tree ordering rule alone does not guarantee this shape or logarithmic time complexity. Breadth-first search also gains no logarithmic key-lookup guarantee merely from having a binary tree: in the displayed balanced example, its left-to-right level order is $4,2,6,1,3,5,7$, so it inspects six keys before finding $5$, and an absent target requires all seven. Directed lookup uses the total order to choose one branch.

The ordering requirement includes every ancestor on the graph path from the root of a tree. Consider the smaller binary tree with root key $4$, left child $2$, right child $6$, and right child $3$ under $2$. Key $3$ must satisfy both $2<3$, from its immediate parent in a rooted tree, and $3<4$, from its position in the root's left subtree. Replacing $3$ by $5$ preserves all immediate parent-child comparisons, including $2<5$, but violates $5<4$. Lookup for $5$ would incorrectly go from $4$ to $6$ and then to an empty left subtree, overlooking the stored key.

An inorder traversal visits a left subtree, then its own vertex, then a right subtree. On the valid small example its output is $2,3,4,6$; on the invalid example it is $2,5,4,6$, exposing the descent from $5$ to $4$. Both seven-key binary search trees yield $1,2,3,4,5,6,7$. The theorem is that an inorder traversal of a finite binary search tree with distinct keys lists every key once in strictly increasing total order. For a short proof outline, use mathematical induction on the number of vertices: each smaller subtree produces its own sorted list, and the full ordering rule places every left key before the current key and every right key after it. Concatenating these three parts preserves strict order. Sedgewick and Wayne's keys method uses this left-current-right order. ^[ref]

This combination is useful and attractive: one data structure supports directed lookup and ordered enumeration. An inorder traversal costs $O(n)$ time complexity for $n$ entries, since it visits every vertex; balance accelerates lookup but cannot eliminate the work of outputting all keys.

// Destination: computer-science.bigb

An inorder traversal of a binary tree uses recursion to visit the left subtree, output the current vertex, and visit the right subtree; an empty subtree outputs nothing. This is a depth-first traversal of a tree with output between the two recursive calls. It produces sorted keys for a binary search tree, but arbitrary labels in a binary tree need not appear in total order.

// Target: computer-science.bigb

For a nonempty binary tree, the largest number of edges on a downward graph path from its root of a tree to a leaf. A single vertex has height of a binary tree $0$; a chain of $n\ge 1$ vertices has height of a binary tree $n-1$. A convenient recursion convention assigns an empty binary tree height $-1$, giving $h=1+\max (h_L,h_R)$ for the left and right subtrees. A binary search tree lookup visits at most $h+1$ vertices.

The convention counts edges, rather than vertices on the longest graph path. Its recursive form is^[ref]

For a leaf, both subtrees are empty, giving $1+\max (-1,-1)=0$. For the mixed four-vertex example, $h(C)=h(D)=0$, $h(B)=1+\max (-1,0)=1$, and $h(A)=1+\max (1,0)=2$. The four-vertex chain has height of a binary tree $3$. A convention that counts vertices would add one to every nonempty binary tree height, so a height formula must specify its convention.

At distance $d$ from the root of a tree, there are at most $2^d$ vertices: each vertex in the preceding level has at most two children in a rooted tree. Summing this geometric series and using the longest graph path gives, for $n\ge 1$,The upper bound is attained by a chain; a perfect binary tree attains the capacity bound. For $n=4$, the minimum possible height of a binary tree is $\lceil {\log }_{2}5\rceil -1=2$, as in the mixed example, while the maximum is $3$. The binary tree definition permits both extremes. Small height of a binary tree bounds the length of a directed lookup in a binary search tree; evaluating the height of a binary tree by the displayed structural recursion still examines all $n$ vertices, requiring $O(n)$ time complexity under constant-cost child access and arithmetic.

For a vertex $u$ in a rooted tree, its subtree contains $u$ and every vertex reachable by repeatedly following children in a rooted tree, together with the connecting edges; its root of a tree is $u$. In a binary tree, the left subtree is rooted at the left child, and is empty when that child is absent; the right subtree is defined similarly. A binary search tree constrains every key in these subtrees.