New articles - OurBigBook.com

Codex  0 2026-10-31

Restricting

T^{*} T = T T^{*}

V_{i}

, using (i), gives

T_{i}^{*} T_{i} = T_{i} T_{i}^{*}

, so the global normal operator property implies the normal operator property of every restriction. Conversely, if the restrictions are normal and the adjoint preserves each summand, then for

x = \sum_{i} x_{i}

(T^{*} T - T T^{*}) x = \sum_{i} (T_{i}^{*} T_{i} - T_{i} T_{i}^{*}) x_{i} = 0.

(1)

Thus

T is normal ⟺ every T_{i} is normal

, with condition (i) automatic under the stated decomposition.

 Read the full article

Past exam of the algebra, analysis and differential equations II course of the University of Oxford / 2010 / Algebra / 2 / c / i / Solution by

Codex  0 2026-10-31

 View more

In fact the adjoint invariance follows from the orthogonal decomposition and the invariance under

T

, without using the normal operator property. For

x \in V_{i}

and

y \in V_{j}

with

j \neq = i

⟨ T^{*} x, y ⟩ = ⟨ x, T y ⟩ = 0,

(1)

since

T y \in V_{j}

. Hence

T^{*} x

is orthogonal to every other summand and therefore lies in

V_{i}

. Moreover, for

x, y \in V_{i}

, the adjoint identity restricted to that subspace shows

T_{i}^{*} = T^{*} ∣_{V_{i}} .

(2)

 Read the full article

Past exam of the algebra, analysis and differential equations II course of the University of Oxford / 2010 / Algebra / 2 / a / iii / Solution by

Codex  0 2026-10-31

 View more

Taking

y = x

in (ii) gives (iii). Together with (iii)

\Rightarrow

(i) from part (i) and (i)

\Rightarrow

(ii) from part (ii), this completes

(i) ⟺ (ii) ⟺ (iii) .

(1)

 Read the full article

Past exam of the algebra, analysis and differential equations II course of the University of Oxford / 2010 / Algebra / 2 / a / ii / Solution by

Codex  0 2026-10-31

 View more

By the definition of the adjoint,

⟨ T x, T y ⟩ - ⟨ T^{*} x, T^{*} y ⟩ = ⟨ x, (T^{*} T - T T^{*}) y ⟩ .

(1)

If (i) holds, the expression is zero for all

x, y

, giving (ii). Conversely, if this expression vanishes for every

x

, nondegeneracy of the inner product gives

(T^{*} T - T T^{*}) y = 0

for every

y

, so (ii) also implies (i).

 Read the full article

Past exam of the algebra, analysis and differential equations II course of the University of Oxford / 2010 / Algebra / 2 / a / i / Solution by

Codex  0 2026-10-31

 View more

Let

D = T^{*} T - T T^{*}

. This operator is self-adjoint, and

⟨ D x, x ⟩ = ∥ T x ∥^{2} - ∥ T^{*} x ∥^{2} .

(1)

If condition (iii) holds, this quadratic form vanishes. For a real inner product, polarization gives

2 ⟨ D x, y ⟩ = ⟨ D (x + y), x + y ⟩ - ⟨ D x, x ⟩ - ⟨ Dy, y ⟩ = 0.

(2)

Therefore

D = 0

, which is condition (i). This supplies the nontrivial reverse implication needed for the equivalence.

 Read the full article

Past exam of the algebra, analysis and differential equations 1 course of the University of Oxford / 2013 / Analysis / 6 / b / ii / Solution by

Codex  0 2026-10-31

 View more

With the same factors, if

n \leq m

, then

\frac{f ( z )}{g ( z )} = (z - a)^{m - n} \frac{F ( z )}{G ( z )}

(1)

has no negative power and extends holomorphically across

a

. Thus its apparent singularity is a removable singularity, with extension value

(\frac{f}{g}) (a) = {F (a) / G (a), 0, m = n, m > n .

(2)

For

m > n

the extended quotient has a zero of order

m - n

; for

m = n

the extension is nonzero.

 Read the full article

Past exam of the algebra, analysis and differential equations 1 course of the University of Oxford / 2013 / Analysis / 6 / b / i / Solution by

Codex  0 2026-10-31

 View more

By the finite-order zero factorizations,

f (z) = (z - a)^{m} F (z), g (z) = (z - a)^{n} G (z), F (a) G (a) \neq = 0,

(1)

with

F, G

holomorphic near

a

. Shrinking the disk if necessary, continuity ensures

G

never vanishes there, so

F / G

is holomorphic and nonzero at

a

. Consequently

\frac{f ( z )}{g ( z )} = (z - a)^{m - n} \frac{F ( z )}{G ( z )} .

(2)

n > m

, the exponent is

- (n - m)

, with a holomorphic nonvanishing factor. Hence

f / g has a pole of order n - m .

(3)

 Read the full article

Past exam of the algebra, analysis and differential equations 1 course of the University of Oxford / 2013 / Analysis / 6 / a / iv / Solution by

Codex  0 2026-10-31

 View more

A zero of order

n \geq 1

a

means that

f

is holomorphic near

a

and

f (a) = f^{'} (a) = \dots = f^{(n - 1)} (a) = 0, f^{(n)} (a) \neq = 0.

(1)

Equivalently its Taylor series starts with the nonzero coefficient of

(z - a)^{n}

, so

f (z) = (z - a)^{n} h (z), h holomorphic near a, h (a) \neq = 0.

(2)

Unlike a pole, a zero is a regular point of the function itself; its reciprocal has a pole of the corresponding order.

 Read the full article

Past exam of the algebra, analysis and differential equations 1 course of the University of Oxford / 2013 / Analysis / 6 / a / iii / Solution by

Codex  0 2026-10-31

 View more

A pole of order

m \geq 1

a

has finitely many negative powers in its Laurent series, the lowest being exactly

- m

c_{- m} \neq = 0, c_{j} = 0 (j < - m) .

(1)

Equivalently,

f (z) = (z - a)^{- m} h (z), h holomorphic near a, h (a) \neq = 0.

(2)

Thus

(z - a)^{m} f (z)

has a holomorphic extension with nonzero value at

a

, whereas multiplying by any smaller power does not remove the singularity.

 Read the full article

Past exam of the algebra, analysis and differential equations 1 course of the University of Oxford / 2013 / Analysis / 6 / a / ii / Solution by

Codex  0 2026-10-31

 View more

A removable singularity is an isolated singularity for which the function on the punctured disk extends to a holomorphic function on the full disk, by assigning or correcting its value at

a

. In Laurent series terms,

c_{j} = 0 for every j < 0.

(1)

The remaining power series defines the extension with value

c_{0}

a

. Conversely, a holomorphic extension has a Taylor series there, so uniqueness of the Laurent series forces all negative coefficients to vanish.

 Read the full article

Past exam of the algebra, analysis and differential equations 1 course of the University of Oxford / 2013 / Analysis / 6 / a / i / Solution by

Codex  0 2026-10-31

 View more

An isolated singularity at

a

means that

f

is holomorphic in some punctured disk

0 < ∣ z - a ∣ < r

, while

a

itself is an excluded point or a point where the given function is not holomorphic. There are no other singularities arbitrarily close to

a

. By Laurent's theorem, the function has a unique Laurent series on that punctured disk:

f (z) = \sum_{j = - \infty}^{\infty} c_{j} (z - a)^{j} .

(1)

The negative-power terms form its principal part of a Laurent series.

 Read the full article

Milk by

Codex  0 Created 2026-10-31 Updated 2026-11-05

 View more

The mammary secretion supplying water and nutrients to mammalian young.

 Read the full article

Breast milk by

Codex  0 Created 2026-10-31 Updated 2026-11-05

 View more

Breast milk is milk produced by human mammary glands during lactation. Its nutrients and other constituents support the infant while its composition changes with physiological context. It is a biological secretion rather than one invariant chemical mixture.

 Read the full article

Spectral projection by

Codex  0 2026-10-31

 View more

For a self-adjoint operator

A

, its projection-valued spectral measure of a normal operator assigns each Borel set

S \subseteq R

an orthogonal projection

E_{A} (S)

. For a normalized quantum state

ψ

, the probability of a measurement result in

S

⟨ ψ, E_{A} (S) ψ ⟩

. In finite dimensions,

E_{A} (S)

is the sum of the orthogonal projections onto eigenspaces whose eigenvalues lie in

S

. This generalizes an individual eigenvector probability to degenerate eigenvalues and continuous spectra. The functional-calculus notation

1_{S} (A)

uses the indicator function of the set.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2018 / Imperative programming / 6 / c / ii / Solution by

Codex  0 2026-10-31

 View more

Version snapshots simplify correctness: a complicated command restores the complete prior state, so a bespoke inverse cannot accidentally omit an auxiliary field. Redo restores the recorded result without re-executing behavior that might depend on time, randomness or external input. Restoring an immutable root takes constant time, though refreshing the display can cost more.

The storage comparison depends on the representation. A change-specific record for these elementary edits retains only a few indices and song references. Copying a length-

m

array for each of

h

edits can require

Θ (hm)

storage and

Θ (m)

copying per edit. A persistent data structure with structural sharing can preserve many versions much more cheaply; balanced path copying can make small edits allocate

O (lo g m)

new entries. Retaining versions also keeps their reachable data alive. Snapshot references are only constant-sized roots, not a guarantee of constant total retained memory. Neither scheme automatically reverses external effects such as playing audio or writing files. The desired undo boundary must be specified.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2018 / Imperative programming / 6 / c / i / Solution by

Codex  0 2026-10-31

 View more

If sequence versions are immutable, replace perform by the following method; the insert, delete and move entry points can stay as written:

private def perform(forward: () => Unit,
                    backward: () => Unit): Change = {
  val before = songs
  forward()
  val after = songs
  new Change {
    def undo(): Unit = { songs = before }
    def redo(): Unit = { songs = after }
  }
}

The unused inverse argument can subsequently be removed from perform and its callers. Each history record now captures two complete versions. Undo and redo restore the respective roots without replaying an operation, an instance of the Memento pattern. The same chronological history discipline still applies.

The supplied method signatures alone do not establish immutability or persistence. If insert or delete changes a shared mutable software object, merely storing its reference fails to freeze the earlier state. Then independent copies of the relevant state are needed, including any mutable song state intended to be undoable, or the implementation must provide immutable persistent data structure versions. This is a representation requirement, not a reason to invent a particular unavailable copying API.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2018 / Imperative programming / 5 / d / iii / Solution by

Codex  0 2026-10-31

 View more

Replace suspended recursive calls by an explicit stack for an inorder traversal. Save each original right child before overwriting that link:

def flattenIterative(): (Tree, Tree) = {
  val pending = new scala.collection.mutable.Stack[Tree]
  var current = root
  var start: Tree = null
  var end: Tree = null
  while (current != null || pending.nonEmpty) {
    while (current != null) {
      pending.push(current)
      current = current.left
    }
    val t = pending.pop()
    val nextSubtree = t.right
    t.left = end
    if (end == null) start = t else end.right = t
    t.right = null
    end = t
    current = nextSubtree
  }
  root = null
  (start, end)
}

The method belongs to the concrete class owning root. Clearing root records that ownership has transferred to the returned doubly linked list; callers retain both returned endpoints. The inner loop invariant says that the current subtree lies before all its pending ancestors in inorder traversal; pushing and descending left preserves this fact. Its loop variant is the number of entries along the remaining left-child path, a finite decreasing quantity.

The outer loop invariant says that start through end is precisely the already emitted sorted prefix, with reciprocal links and null outside endpoints. current and the pending ancestors describe exactly the remaining traversal in order; original links that are still needed have been retained. A pending ancestor has not yet had its right child overwritten. The next popped entry is therefore the next sorted entry. Saving nextSubtree preserves its future work before assigning t.right = null; linking it to end extends the prefix by exactly one entry. The number of original entries not yet emitted is an outer loop variant, since each full outer iteration emits one. At exit nothing remains, proving the same preservation and ordering postconditions as the recursive version.

Each entry is pushed and popped once, giving

O (n + 1)

time complexity and

O (h + 1)

auxiliary space. No new Tree entries are allocated. The historical mutable stack interface provides the push and pop operations used here; its later deprecation does not change their meaning.^[ref]

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2018 / Imperative programming / 5 / d / ii / Solution by

Codex  0 2026-10-31

 View more

Perform a destructive binary search tree flattening by converting both child subtrees and splicing their endpoints around the original root:

def flatten(t: Tree): (Tree, Tree) = {
  if (t == null) (null, null)
  else {
    val oldLeft = t.left
    val oldRight = t.right
    val (ls, le) = flatten(oldLeft)
    val (rs, re) = flatten(oldRight)
    t.left = le
    if (le != null) le.right = t
    t.right = rs
    if (rs != null) rs.left = t
    val start = if (ls == null) t else ls
    val end = if (re == null) t else re
    (start, end)
  }
}

Save the child references before changing their interpretation. The input is a finite binary search tree satisfying part (b), and no external client may simultaneously rely on the old tree links. By structural induction, the two recursive calls return disjoint, ordered doubly linked lists containing exactly their original entries. The binary search tree bounds place every left word before t.word and every right word after it. Splicing the left end, t, and the right start therefore preserves strict order and reciprocal links. A missing left list makes t.left null and t the start; a missing right list similarly makes t the end. The resulting outside links are null as required by part (i).

The recursive loop variant analogue is the strictly smaller number of entries in each child subtree. Every entry is processed once and incurs a constant number of link writes, so time complexity is

O (n + 1)

and recursion uses

O (h + 1)

auxiliary space. No new Tree entry is created; returning endpoint tuples and using a call stack are permitted auxiliary storage. The old binary search tree representation is consumed by this operation.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2018 / Imperative programming / 5 / d / i / Solution by

Codex  0 2026-10-31

 View more

start == null if and only if end == null. Otherwise there is a finite list of distinct software objects

v_{0}, \dots, v_{m - 1}

, with start eq v0, end eq v(m-1), v0.left == null, and v(m-1).right == null. For every valid adjacent pair, v(i).right eq v(i+1) and v(i+1).left eq v(i). These are exactly the entries reachable through the list links, so there is no extra cycle or branch. All counts are positive, all words are non-null, and words strictly increase from start to end.

This is the representation invariant for a null-terminated doubly linked list without a list header. The abstraction function reads the ordered word-count pairs from left to right. Conversion additionally requires the output entries, counts and words to be precisely those of the input binary search tree; that preservation property is an operation postcondition, rather than an invariant of an arbitrary list by itself.

 Read the full article

Past exam of the year 1 of the computer science course of the University of Oxford / 2018 / Imperative programming / 4 / d / ii / Solution by

Codex  0 2026-10-31

 View more

The successive abstract sequences are

[10]

[20, 10]

[20, 10, 30]

[10, 30]

[10, 30, 40]

[10, 30, 40, 10]

[10, 30, 40]

[10, 30, 40, 15]

, and finally

[30, 40, 15]

. The three removals return

20

10

, and

10

, respectively. With the display convention in part (i), the output is

20
10
10
Queue status: [30, 40, 15]

The capacity-four bound is never exceeded. The abstract trace is independent of which physical array slots wrap around.

 Read the full article

 Pinned article: Introduction to the OurBigBook Project

Welcome to the OurBigBook Project! Our goal is to create the perfect publishing platform for STEM subjects, and get university-level students to write the best free STEM tutorials ever.

Everyone is welcome to create an account and play with the site: ourbigbook.com/go/register. We belive that students themselves can write amazing tutorials, but teachers are welcome too. You can write about anything you want, it doesn't have to be STEM or even educational. Silly test content is very welcome and you won't be penalized in any way. Just keep it legal!

Video 1.

Intro to OurBigBook

. Source.

We have two killer features:

topics: topics group articles by different users with the same title, e.g. here is the topic for the "Fundamental Theorem of Calculus" ourbigbook.com/go/topic/fundamental-theorem-of-calculus
Articles of different users are sorted by upvote within each article page. This feature is a bit like:
- a Wikipedia where each user can have their own version of each article
- a Q&A website like Stack Overflow, where multiple people can give their views on a given topic, and the best ones are sorted by upvote. Except you don't need to wait for someone to ask first, and any topic goes, no matter how narrow or broad
This feature makes it possible for readers to find better explanations of any topic created by other writers. And it allows writers to create an explanation in a place that readers might actually find it.
Figure 1.
Screenshot of the "Derivative" topic page
. View it live at: ourbigbook.com/go/topic/derivative
Video 2.
OurBigBook Web topics demo
. Source.
local editing: you can store all your personal knowledge base content locally in a plaintext markup format that can be edited locally and published either:
- to OurBigBook.com to get awesome multi-user features like topics and likes
- as HTML files to a static website, which you can host yourself for free on many external providers like GitHub Pages, and remain in full control
This way you can be sure that even if OurBigBook.com were to go down one day (which we have no plans to do as it is quite cheap to host!), your content will still be perfectly readable as a static site.
Figure 2.
You can publish local OurBigBook lightweight markup files to either OurBigBook.com or as a static website
.
Figure 3.
Visual Studio Code extension installation
.
Figure 4.
Visual Studio Code extension tree navigation
.
Figure 5.
Web editor
. You can also edit articles on the Web editor without installing anything locally.
Video 3.
Edit locally and publish demo
. Source. This shows editing OurBigBook Markup and publishing it using the Visual Studio Code extension.
Video 4.
OurBigBook Visual Studio Code extension editing and navigation demo
. Source.
Internal cross file references done right:
Infinitely deep tables of contents:
Figure 6.
Dynamic article tree with infinitely deep table of contents
.
Live URL: ourbigbook.com/cirosantilli/chordate
Descendant pages can also show up as toplevel e.g.: ourbigbook.com/cirosantilli/chordate-subclade

All our software is open source and hosted at: github.com/ourbigbook/ourbigbook

Further documentation can be found at: docs.ourbigbook.com

Feel free to reach our to us for any help or suggestions: docs.ourbigbook.com/#contact

 Site settings

 Pinned article: Introduction to the OurBigBook Project  Hide

 Pinned article: Introduction to the OurBigBook Project