Weather forecasting estimates future meteorological conditions from observations and physical models. Numerical models use an approximate initial condition and equations of fluid mechanics to simulate future conditions; forecasters also compare model outputs and apply experience and research.^[ref] The forecast horizon describes how far ahead a prediction remains useful at a specified accuracy; sensitive dependence on initial conditions can limit detailed predictions under deterministic evolution.

Colonization of empty habitat at rate $c$ and extinction of occupied habitat at rate $m$ give the displayed patch-occupancy equation. The positive equilibrium is $1-m/c$ when $c>m$. Competition can be incorporated through replacement fluxes between patches occupied by different species.

This model couples deterministic underdominant allele-frequency dynamics in equal-sized habitats by global migration. Starting with $m$ pure habitats of one allele and $N-m$ of the other preserves two within-class frequencies $x,y$, reducing the system to $\dot{x}=f(x)-\sigma (1-q)(x-y)$, $\dot{y}=f(y)+\sigma q(x-y)$ with $q=m/N$. Migration is conservative in the mean, but selection need not conserve global allele frequency.

A G protein-coupled receptor is a cell-surface receptor that relays activation through a G protein on the intracellular side of the cell membrane. The activated G protein can regulate an enzyme or ion channel, so a GPCR supplies a concrete metabotropic receptor example: ligand recognition and the eventual response are connected through distinct components. Different G proteins couple to different targets. See Alberts et al., Molecular Biology of the Cell, 4th edition: signaling through G-protein-linked cell-surface receptors.

Combine a secret randomly selected almost strongly universal hash family member with a fresh secret output mask. An observed message authentication code tag leaves the hash-selection key hidden, and the conditional hash bound controls substitution forgery probability. The message itself need not be encrypted. Mask reuse can reveal hash differences; repeated-use guarantees require fresh masks and an appropriate analysis of verification information. A one-use polynomial construction needs only two secret field elements, even for a much longer message.

A meson with total angular momentum one and negative parity. In the ordinary quark model, a quark-antiquark pair with orbital angular momentum zero and total spin one has these quantum numbers; its neutral self-conjugate states have charge conjugation $C=-1$. The light-flavour tensor product gives an octet and a singlet, forming a vector nonet, just as spin-zero negative-parity pairs form a pseudoscalar meson nonet. Nonzero orbital excitations can also produce vector states.

The rho meson is an isospin-one vector meson. Its neutral member has charge conjugation value minus one, so all three charge states have G parity plus one. The two-pion decay is allowed by G parity, whereas a purely strong isospin-conserving three-pion decay is excluded.

The omega meson is an isospin-zero vector meson with charge conjugation value minus one and consequently G parity minus one. Three-pion decay is compatible with the isospin-symmetric strong interaction, whereas two-pion decay violates its G-parity rule.

For an ordinary quark-antiquark meson, opposite intrinsic parities and orbital parity give $P=(-1{)}^{L+1}$. For a self-conjugate flavor state, charge conjugation exchanges the two constituents. Reversal of their relative momentum gives $(-1{)}^L$, spin exchange gives $(-1{)}^{S+1}$, and reordering the two fermionic creation operators gives one extra minus sign. Their product is $C=(-1{)}^{L+S}$. Electrical neutrality alone does not imply that a state is an eigenstate of charge conjugation; charged mesons have no individual C eigenvalue.

An isospin-zero quark $h$ paired with $\overline{u}$ or $\overline{d}$ gives a meson isospin doublet of charges $q_h-2/3,q_h+1/3$. Spin addition at zero orbital angular momentum gives both pseudoscalar mesons and vector mesons. Pairing the new antiquark with $u,d$ gives the charge-conjugate doublets. For strange or charm flavour these are the kaon or D-meson families and their vector partners.

There are two distinct questions: whether another operating-system process can observe shared contents, and whether those contents survive a crash. In the timeline, persistent storage deliberately remains $(7,8)$ while the shared page cache contains $(11,12)$. No background page writeback occurs in this toy interval. Real page writeback may persist some contents earlier; shared visibility alone cannot tell the reader which contents are durable.

For the covered shared range, msync(base, length, MS_SYNC) requests page writeback and waits for completion; check its return value. MS_ASYNC is not a durable completion acknowledgment, and on modern Linux kernel versions it is a no-op because dirty contents are already tracked. The address must be aligned, so synchronizing our changed second page uses base + 4096, length 4096, rather than base + 4133. Unmapping alone is not a guarantee of completed writeback.^[ref]

For persistence of the file and associated file metadata, fsync on an open file descriptor is a broader interface; a new directory entry needs separate synchronization of its file-system directory. Retain a suitable file descriptor if the persistence protocol needs it after mapping. Successful storage completion still relies on the file system and device honoring their persistence contracts.^[ref]

Neither fsync nor msync supplies mutual exclusion, an atomic storage write for several memory pages, or an application-wide file-system transaction. Stop or coordinate writers before deciding which update a completion acknowledges. A crash during page writeback can leave a mixture of old and new contents unless a separate recovery protocol provides file-system crash consistency. The last timeline row assumes successful synchronous completion, honored storage flush semantics and no subsequent writer; it illustrates a persistence boundary, not a promise about arbitrary hardware failures.

With MAP_PRIVATE, copy-on-write initially reuses backing page cache contents. In our model, a private store raises a protection page fault, copies the affected memory page to a private page frame, installs a writable page table entry and retries. The other memory page can remain shared. This page fault needs no storage read.

In B's private file mapping, storing $x=99$ copies relative page 1, including its neighbor $y=8$. Next, A stores $x=11,y=12$ through its shared file mapping. After coordination outside the mapped data, B's shared reads give $(11,12)$, while its detached private page gives $(99,8)$. The untouched first memory page remains backed by the file; this is not a frozen snapshot of the whole file. Neither page writeback of shared contents nor msync publishes B's private 99. To save those private contents, the application needs a separate explicit file update.

With MAP_SHARED, updates are visible to other operating-system processes mapping the same region and are carried through to the backing file. With MAP_PRIVATE, updates instead stay private, and later backing file changes have unspecified visibility in that mapping.^[ref]

In the toy model, both shared file mappings initially read backing bytes $x=7,y=8$ at file offsets 8229 and 8230. Both memory pages have been accessed, so their translations are installed. A shared store changes the common page cache contents and creates a dirty memory page eligible for page writeback. That change can be observed before it reaches persistent storage. Cooperating readers need synchronization to know when an update is ready; MAP_SHARED alone supplies no mutual exclusion or indivisible multi-field update.

Let $P$ be the memory page size, $O$ the aligned starting file offset, $L$ the mapping length and $B$ its base virtual address. A valid displacement $r=v-B$ with $0\le r<L$ corresponds to file offsetHere $j$ is the relative memory page index, the floor function selects its integer part, and Euclidean division gives the within-page displacement $d$. The backing page begins at $O+jP$. This identifies file contents; the page table separately selects a resident page frame and enforces permissions.

Take $P=4096$, $O=4096$ and $L=8192$ bytes in a file of at least 12288 bytes. A has a shared file mapping at $B_A=0x10000000$. B has a shared file mapping at $B_B=0x20000000$ and a private file mapping at $B_C=0x30000000$. These bases are illustrative chosen results, not requested fixed addresses. All three mappings cover the same two backing pages: file offsets 4096–8191 and 8192–12287. Displacement $r=4133=4096+37$ selects relative page 1, within-page displacement 37 and file offset $o=8229=0x2025$. Thus A's 0x10001025, B's shared 0x20001025 and B's private 0x30001025 initially identify the same byte. The adjacent displacement 4134 identifies file offset 8230. Different virtual addresses can reach the same backing contents.

To access a requested file offset $q$ that is not aligned, choose $O=P\lfloor q/P\rfloor$ and displacement $q-O$. Mapping enough bytes to cover that displacement plus the requested length makes the desired data start inside the aligned mapping. Do not pass the unaligned $q$ directly as the Linux kernel mmap offset. For example, $q=8229$ uses $O=8192$ and displacement 37; that one-page start differs from our two-page mapping's $O=4096$.

The POSIX mapping interface. Ordinary Linux kernel file mappings require a positive length and an aligned file offset. A null address lets the operating-system kernel choose an aligned base; length need not be aligned. Check for MAP_FAILED. After success the file descriptor may be closed without invalidating the mapping; munmap or process termination removes it.^[ref]

Mapping does not extend the backing file. Under POSIX, for an initially partial last memory page, the tail beyond the file's end is zero-filled and is not written back as file data; accesses to whole mapped memory pages beyond the end raise SIGBUS. POSIX leaves access to portions added or removed by later resizing unspecified. Establish the required file size first and coordinate resizing with readers; a mapping's length is not proof that those bytes exist in the file.^[ref]

The Linux kernel documents a tail-cache exception: modified beyond-end bytes can survive in the page cache and appear in later mappings, although never written to the file. Do not use that tail as reliable storage.^[ref]

The file supplying a memory-mapped file's initial contents. Its logical file offsets identify data independently of the virtual addresses chosen by different operating-system processes. Modified private file mapping contents have private storage; they are not updates waiting to be written to the backing file.

The arithmetic mean of memory access latencies. Suppose each read completes before the next begins, every cache hit costs $t_h$, and every cache miss costs $t_h+p$, with the same additional cache miss penalty $p$. If $h$ is cache hit rate and $m=1-h$ is cache miss rate, the weighted arithmetic mean isThe common lookup cost is paid on both outcomes. This additive assumption matches the simple model in Beyond Physical Memory: Policies (§22.1, equation 22.1, pp. 1–2), where main computer memory acts as a memory cache for memory pages backed by disk; here the same accounting is applied to a toy data memory cache.

Assign synthetic values $t_h=2\mathrm{ns}$ and $p=30\mathrm{ns}$. The twelve-read, two-slot fully associative cache example has five cache hits and seven cache misses, givingWith four cache slots, its four compulsory misses instead give $\mathrm{AMAT}=12\mathrm{ns}$. This comparison holds the timing costs fixed as capacity changes, which is a model assumption rather than a hardware promise.

If a problem supplies a total miss time $t_m$, use $h{t}_h+m{t}_m$; adding $t_h$ to $t_m$ again would count lookup twice. Variable cache miss penalties, multiple consulted levels, or overlapping requests require a richer timing model. Real CPU work can overlap a pending read, so this arithmetic mean cannot by itself predict program speed or stall time. ^[ref]

A memoization cache lifetime is the interval over which retained entries are available and valid. One table per top-level request shares recursive subproblems within that request; keeping a table between requests also allows the warm $F_5$ and incremental $F_6$ examples. Clearing it loses those savings. Evicting a correct answer can preserve correctness for a terminating pure function, while forcing recomputation; changing an input without invalidating an obsolete answer can break correctness.

Specify who owns the table, when context changes invalidate it, and how long keys and results occupy computer memory. In a concrete implementation, retained references can keep arguments and answers alive until removal or clearing.^[ref] The memoization promise is conditional reuse of valid completed answers, not an automatic guarantee of freshness, termination or bounded computer memory.

// Target: computer-science.bigb

A memoization key identifies all information that determines a reusable answer. Write $x$ for explicit arguments and $c$ for relevant context. For a function $f$ and key function $K$, the necessary value condition isThis implication need hold only for contexts in which the entry can be reused. The condition concerns key equality, not merely equality of hash function outputs: a hash table must resolve hash collisions by comparing complete keys. Include the identity or version of the procedure if one table stores results for several procedures or changing implementations.

For an original toy example, let $g(n,a)=an$. Caching only by $n$ after $g(3,2)=6$ incorrectly returns $6$ for $g(3,4)$, whose answer is $12$. The pair $(n,a)$ is complete for this function. If $a$ is hidden in mutable configuration, either freeze that configuration for the memoization cache lifetime, include a reliable version in the key, or invalidate affected entries before reuse. A version is sufficient only if every relevant change updates it. Object identity alone is likewise insufficient for a mutable list whose contents determine the answer.

Endocytosis takes material into a biological cell by inward budding and separation of part of its cell membrane. At a chemical synapse, it helps recover membrane and proteins after synaptic vesicle exocytosis. This recovery is distinct from uptake of individual neurotransmitter molecules through membrane transport proteins.