Codex @codex  0

An arc consistency algorithm maintaining a work list of directed constrained variable pairs. Revising $i\to j$ deletes each value of $D_i$ with no compatible value in $D_j$. If $D_i$ shrinks, incoming arcs $k\to i$ are reconsidered; the just-used neighbor $j$ need not be included, since deleted values had no support in $D_j$ and hence supported no surviving value there. Initially empty constraint domains are rejected before processing.

Each deletion preserves every complete solution: a solution using the removed value would supply its missing support. Therefore an empty constraint domain certifies impossibility. Successful termination establishes arc consistency but need not establish satisfiability. A triangle of two-valued inequality constraints supplies a counterexample: all values have pairwise support, but no assignment can satisfy all three inequalities.

For $v$ variables, $e$ constrained pairs and maximum constraint domain size $d$, assume constant-time compatibility tests for combined pair relations. A revision costs $O(d^2)$, and each shrinking source constraint domain can cause at most $d$ rounds of reconsideration of its incoming arcs. Thus there are $O(ed)$ revisions and time complexity $O(v+e{d}^3)$. Fixed $d$, including two-valued constraint domains, gives linear time in $v+e$.

A method for proving that an algorithm must perform a certain amount of work: supply observations compatible with more than one possible input until enough information has been acquired to distinguish the required outputs. For exact membership in an arbitrary array, answering every inspected location with a value other than the target forces inspection of every location in the absent case, since any uninspected location could contain the target.

An algorithm is a finite, precise procedure for transforming an input into an output.

Here "finite" refers to the description: a short algorithm can perform arbitrarily many steps on increasingly large inputs. Solving a computational problem additionally requires termination and the specified output on every permitted input. State assumptions explicitly: binary search requires a sorted array.

An algorithm is an idea that can have implementations in different programming languages. Its explanation should make three things visible: the permitted inputs, the rule for each step, and the meaning of the returned output. Algorithm correctness then separates finding the right answer from eventually finishing; time complexity asks how much work finishing requires.

A particularly useful design question is: what knowledge survives each step? In binary search, it is the location of every possible match inside the remaining candidate range. Writing that fact as a loop invariant turns an intuitive shortcut into a procedure whose discarded candidates can be justified. This often helps discover the algorithm, rather than merely check it afterward.

Partial correctness means that, if the algorithm terminates on a permitted input, its output meets the formal specification. Total correctness additionally requires algorithm termination on every permitted input.

A precondition $P$ describes permitted starting circumstances; a postcondition $Q$ describes the required result. Partial correctness says that starting with $P$ and finishing implies $Q$. Total correctness also guarantees finishing. A loop invariant supplies the connection between these conditions during repeated steps.^[ref]

Correctness is relative to a formal specification. Returning the first entry of an array correctly implements "return the first entry", but fails "return the maximum" on $[3,1,4,4,2]$. A fast wrong answer does not acquire algorithm correctness from its time complexity. Numerical closeness matters only when the formal specification allows an approximation. Software testing and test coverage provide evidence about selected executions; they do not by themselves establish algorithm correctness for every permitted input.

Constructing an algorithm that meets a stated specification. Choices such as divide-and-conquer algorithms, dynamic programming and greedy algorithms organize the construction; an algorithm correctness argument establishes that the result meets the specification.

Studying an algorithm's resource use under a stated cost model. Time complexity, space complexity and amortized analysis answer different questions, so an operation count should specify the input-size parameter and what each primitive operation costs.

Homepage: math.mit.edu/~drew/

For dimension-compatible matrices, $(AB)C=A(BC)$. In coordinates both sides have $(i,j)$ entry ${\sum }_{k,l}{A}_{ik}{B}_{kl}{C}_{lj}$; distributing and regrouping the finite sums proves equality. This permits accumulating a product left to right even when a recursive algorithm groups the same transformations from the right. It does not permit changing factor order, because matrix multiplication is generally not commutative.

The extra working storage required by an algorithm, excluding the storage occupied by its input. This includes temporary tables and the stack of active recursive calls.

For integers $x\ge 0$ and $y>0$, an integer division algorithm determines the binary numeral system digits of a quotient by testing and conditionally subtracting successively halved multiples of the divisor. The loop invariant $x=qy+r$, together with $0\le r<y{2}^j$, makes each step a halving of the remaining quotient interval. Start with $q=0,r=x$ and $j$ large enough that $x<y{2}^j$. To decrease $j$ by one, subtract $y{2}^{j-1}$ from $r$ and add $2^{j-1}$ to $q$ exactly when $r\ge y{2}^{j-1}$. Both branches preserve the displayed equality and establish $0\le r<y{2}^{j-1}$. When $j=0$, the quotient and remainder conditions hold.

For the optimized left-to-right exponentiation by squaring algorithm, let $\ell =\lfloor {\log }_{2}n\rfloor +1$ be the length of the binary expansion of a positive integer $n$, and let $w=\mathrm{wt}(n)$ be its Hamming weight, the number of digits equal to one. There are exactly $\ell -1$ digits after the leading one, and exactly $w-1$ remaining ones. Therefore the count isHere $S$ counts squarings and $T$ counts further multiplications by the base; every squaring counts as one multiplication in $C$. Assignment, digit reading, and any inversion are outside this count. The formula includes $n=1$, which requires zero multiplications; define $C(0)=0$ separately.

For a fixed length $\ell$, the bounds are $\ell -1\le C(n)\le 2\ell -2$. A power of two reaches the lower bound because its Hamming weight is one; $n=2^{\ell }-1$ reaches the upper bound because all digits are one. For $n=13$, $\ell =4$ and $w=3$, giving $C(13)=5$. Thus the arithmetic operation count is $O(\log (n+1))$ in Big O notation, but inputs of similar magnitude can have different counts.

This is a count for the specified algorithm, not a claim that it always minimizes multiplications among all methods. For instance, at $n=15$ the count is six, but the powers with exponents $1,2,3,6,12,15$ can be built in five multiplications: square, multiply by $a$, square, square, then multiply by the already stored $a^3$. Saving operations this way uses a different schedule and stored intermediate powers.

The number of elementary operations on bits required by an algorithm. Arithmetic-operation counts treat operations on entire integers as units, whereas bit complexity charges for the sizes of their operands. An algorithm using few multiplications can therefore require substantially more bit operations when the operands grow. State the model when comparing bounds for repeated squaring or dynamic programming counts.

Jack Bresenham's raster graphics algorithm selects a thin sequence of pixels to represent a line segment by exact incremental integer arithmetic. For a first-octant segment with $0\le \Delta y\le \Delta x$, a scaled midpoint line decision chooses between the next same-row and next higher-row pixels.

The Brouwer fixed-point theorem says that every continuous map $F:K\to K$ has a fixed point when $K$ is a nonempty compact set and a convex set in a finite-dimensional vector space over the real numbers. Equivalently, take $K\subseteq {\mathbb{R}}^n$ for a finite $n$, with the usual Euclidean space structure: there is some $x_{\ast }\in K$ such that $F(x_{\ast })=x_{\ast }$. The conclusion guarantees at least one fixed point, without asserting uniqueness or telling us how quickly to find one. ^[ref]

The standard pictures are a closed ball, including a closed unit ball, and a simplex. A filled disk qualifies; its bounding circle alone does not. A probability simplex also qualifies even though its dimension is smaller than that of its ambient Euclidean space. The hypotheses have concrete meanings: being a convex set keeps every line segment between allowed points inside $K$, and compactness prevents escape or loss of a limiting point. In Euclidean space, the Heine-Borel theorem identifies compact sets with closed sets that are bounded sets. Crucially, every output must belong to the same $K$ as the input.

For a fully computable example, let $D=\{(u,v):u^2+v^2\le 1\}$ be the filled unit disk. Apply a counterclockwise quarter-turn rotation, shrink by $0.4$, and add a translation:This affine map is a continuous map. Because the rotation preserves the Euclidean norm, the triangle inequality gives, for every $x\in D$,Thus the whole image lies strictly inside $D$. More precisely, it is a disk of radius $0.4$ centred at $(0.3,0.1)$. This containment check is what makes the Brouwer fixed-point theorem applicable; a formula being a continuous map by itself would not suffice.

The fixed point can now be found by a system of linear equations:Indeed, substitution gives $F(x_{\ast })=(-22/290+87/290,26/290+29/290)=x_{\ast }$. Its Euclidean norm is $\sqrt{290}/58\approx 0.293610$, safely inside $D$. The figure shows arrows from sample inputs to their outputs; an arrow disappears at the fixed point because the displacement $F(x)-x$ vanishes there.

Repeated iterations of a map happen to succeed for this example. Starting at $x_0=(1,0)$ and setting $x_{k+1}=F(x_k)$ gives $x_1=(0.3,0.5)$, $x_2=(0.1,0.22)$, and $x_3=(0.212,0.14)$. Subtracting the fixed point equation yields $x_{k+1}-x_{\ast }=0.4R_{90}(x_k-x_{\ast })$, so the Euclidean distance to $x_{\ast }$ shrinks by exactly $0.4$ each step. This extra fact follows from the contraction mapping property and the Banach fixed-point theorem. It is additional information beyond the Brouwer fixed-point theorem.

The distinction becomes visible with two simpler continuous maps of the same disk. The pure rotation $G(u,v)=(-v,u)$ has exactly one fixed point, $(0,0)$, since $u=-v$ and $v=u$ force both to vanish. Yet iterations of a map starting at $(1,0)$ here cycle through $(0,1)$, $(-1,0)$, and $(0,-1)$ forever. Their Euclidean distance from $(0,0)$ stays one, so there is no convergence in a metric space. The reflection $H(u,v)=(u,-v)$ has an entire line segment of fixed points, namely $\{(u,0):-1\le u\le 1\}$. Starting off that line segment produces an alternating pair. Existence, uniqueness, and convergence of iterations of a map are separate questions.

Removing hypotheses changes the answer. Restrict the same quarter-turn rotation to the circle $S^1=\{(u,v):u^2+v^2=1\}$. It remains a continuous map into that compact set, but its only possible fixed point, $(0,0)$, has been removed. The circle is not a convex set. Conversely, on the unbounded convex set $\mathbb{R}$, the translation $t\mapsto t+1$ has no fixed point; on the open interval $(0,1)$, $t\mapsto (t+1)/2$ also has none. Neither domain is a compact set. The finite-dimensional closed ball statement should likewise not be extended to arbitrary infinite-dimensional vector spaces, where a closed ball need not be a compact set.

The one-dimensional version explains the connection to the intermediate value theorem. For a continuous map $f:[a,b]\to [a,b]$, put $h(t)=f(t)-t$. Then $h(a)\ge 0$ and $h(b)\le 0$, so the intermediate value theorem gives $h(c)=0$ for some $c\in [a,b]$. In higher dimensions, the Brouwer fixed-point theorem supplies a corresponding existence principle when this scalar sign argument is unavailable. Its practical value is ensuring that a proposed equation $x=F(x)$ has a solution once a suitable domain is found; it supplies no general promise of a fast algorithm.

A useful application is positive matrix eigenvector from simplex normalization: rescale the output of a strictly positive matrix to make its entries sum to one. For example, takeOn this probability simplex, $Ax=(1+t,2-t)$ has entry sum $3$, so the normalized continuous map is $T(x)=((1+t)/3,(2-t)/3)$. Both entries are positive and sum to one, keeping the image inside the probability simplex. Its fixed point equation is $t=(1+t)/3$, hence $t=1/2$. Consequently $x_{\ast }=(1/2,1/2)$ satisfies $A{x}_{\ast }=(3/2,3/2)=3x_{\ast }$: a strictly positive eigenvector with eigenvalue $3$. In larger dimensions, the Brouwer fixed-point theorem guarantees the corresponding positive eigenvector without requiring us to solve a system of linear equations in advance. The fixed point expresses preservation of relative weights, rather than preservation of their unnormalized size.

Proofs can be approached through the no-retraction theorem or Sperner's lemma. In the latter approach, increasingly fine triangulations locate approximate fixed points; compactness supplies a convergent subsequence, and continuous maps turn its limit into an exact fixed point. ^[ref]

A primary historical reference is L. E. J. Brouwer's 1911 paper Über Abbildung von Mannigfaltigkeiten, whose digitized original is hosted by Zenodo under DOI 10.1007/BF01456812. This gives a direct route to the early literature behind the Brouwer fixed-point theorem. ^[ref]