Perform CSP event $a$, then behave as CSP process $P$.

In communicating sequential processes, CSP choice combines possible process behaviours. With external choice $P\square Q$, an offered CSP event selected by the environment can determine which branch proceeds. Internal choice $P\sqcap Q$ leaves the branch selection nondeterministic from the environment's viewpoint. For example, choosing externally between receiving left and receiving right offers both alternatives; internally choosing a branch can remove one offer before the environment acts. Sets of execution traces alone can hide this distinction, so CSP failures semantics also records CSP refusal sets of CSP events that may be declined.

Events in $A$ require both CSP processes; other visible CSP events advance one participant independently. CSP internal actions do not synchronize.

Relabel visible CSP events according to a function or relation, preserving CSP internal actions. An injective relabelling preserves event identity; a non-injective one can merge distinct actions. In relational renaming, an original event with no image is disabled. Thus partial relational renaming can also restrict an interface.

Turn CSP events in $A$ into CSP internal actions. Infinite hidden activity can create CSP divergence.

Allow $P$ to proceed while $Q$ is ready to interrupt. The first visible CSP event of $Q$ discards $P$ and leaves the derivative of $Q$. A CSP internal action of $Q$ alone does not discard $P$.

Behave as $P$ until it performs a visible CSP event in $A$, then switch to $Q$. The triggering event is included in the visible CSP trace.

An algebraic expansion listing the initially possible CSP events and their continuations. It translates operational transition cases into CSP external choice expressions.

Expose a cloning operation through a common object interface and create new objects by asking a configured prototype for a copy. Concrete prototypes implement the copy operation; the client need not name their concrete software classes. This is useful when creation depends on runtime configuration or expensive reusable initial state. The contract must specify whether nested mutable data requires a deep copy; copying only outer fields can preserve unintended reference aliasing.

Provide a shared unique instance of a service or state holder. A Scala object supplies one instance of that object definition; a top-level object can therefore centralize shared state such as a registry of current scores. A singleton does not by itself implement thread safety, remove stale entries, or define the lifetime of registered objects. Those remain separate design responsibilities.

Declare a creation operation returning an abstract product interface and let concrete creators specialize how products are built. Clients call the creator interface rather than hard-coding construction of each concrete product. For example two regional manufacturers can implement build(carType): Car to select a concrete car and apply regional settings; optional wrappers can then be composed independently using the decorator pattern.

Provide an interface for creating a family of related products while hiding their concrete software classes. Unlike a single factory method pattern operation returning one product abstraction, an abstract factory typically exposes several related product-creation operations whose implementations coordinate a consistent family.

For the quantum harmonic oscillator with $a_{-}=P-im\omega X$, $a_{+}=a_{-}^{\ast }$ and $\gamma =2m\hslash \omega$, factorization gives $a_{+}{a}_{-}=2m(H-E_0)$, where $E_0=\hslash \omega /2$. For an energy eigenstate $\psi$ at $E_n=E_0+n\hslash \omega$,The first identity shows that lowering to the ground state is injective on the $E_n$ eigenspace; the second shows how to invert it by raising. If the ground eigenspace is one-dimensional, $(a_{-}{)}^n\psi =c{\psi }_0$ and therefore $\psi =c(a_{+}{)}^n{\psi }_0/({\gamma }^{n}n!)$. Thus every level is also nondegenerate. This proof explicitly rules out a second independent energy eigenstate at an excited level rather than merely constructing one ladder of states.

Suppose a mutable collection of narrow-type values could be viewed as a mutable collection of a wider type. Inserting a wider-only value through that alias would make a subsequent narrow-type read invalid. For example, hypothetical covariance would let one insert a string through an Any-typed alias of an integer multiset. Generic type invariance prevents that substitution; making a parameter covariant does not authorize an unsound consuming method.

Tasks transfer control at explicit suspension points. A FIFO queue of runnable continuations implements round-robin scheduling; a task that never transfers control can prevent others from running.

An integrable kernel is uniquely determined by its convolution operator on $L^2$. Convolve it with a smooth compactly supported approximate identity ${\eta }_{\epsilon }$, whose members also lie in $L^2$. A zero operator makes $h\ast {\eta }_{\epsilon }=0$, while translation continuity in Lp gives $h\ast {\eta }_{\epsilon }\to h$ in $L^1$, proving the assertion. Since the adjoint operator of convolution by $f$ is convolution by $f^{♯}(s)=\overline{f(-s)}$, this also proves the exact self-adjointness criterion $f=f^{♯}$ almost everywhere, including necessity at the level of kernels.

For finite complex measures on the additive circle group, convolution is the pushforward measure of their product under addition modulo $2\pi$. EquivalentlyBounded tests are integrable against the product variation measure, so Fubini's theorem applies. Testing the factorization $e^{-in(x+y)}=e^{-inx}{e}^{-iny}$ proves the displayed Fourier coefficient of a measure on the circle identity. The convolution of two probability measures is again a probability measure. On these measures convolution preserves simultaneous convergence in the weak-star topology: multiply the converging coefficients and use their common unit variation bound and dense trigonometric tests.

Tonelli's theorem gives the product integral of $|g(x-y)h(y)|$ as $\Vert g{\Vert }_1\Vert h{\Vert }_1$. Fubini's theorem then defines the convolution almost everywhere and gives an integrable result with norm at most that product. Multiplication by a complex exponential of modulus one preserves absolute integrability and permits the usual Fourier transform convolution identity.

Every set of at least $d+2$ points in ${\mathbb{R}}^d$ can be partitioned into two nonempty parts with intersecting convex hulls. To see this, take a nonzero affine dependence on $d+2$ of its points. Its positive and negative coefficient sums have the same magnitude $L>0$. Dividing by $L$ expresses one point as a convex combination of the positive-coefficient points and also as a convex combination of the negative-coefficient points. Distribute zero-coefficient and remaining points arbitrarily between the parts. This theorem obstructs arbitrary labels for affine linear classifiers.

Start from a nondegenerate tetrahedron and insert remaining points one at a time. Discard a point inside the current convex polyhedron; otherwise replace faces visible from it by the cone from that point to the horizon of a convex polyhedron. Scanning every current face gives $O(n^2)$ worst-case time complexity and $O(n)$ current-hull storage in three dimensions. Coplanar input requires a separate degeneracy policy.