Foundations: math, probability & algorithms

Deciding satisfiability of boolean formulas with two literals per clause in linear time via implication graphs.

Run Lloyd's algorithm on six points with two clusters, alternating assignment and mean update until the centers stop moving.

A* finds a shortest path to a goal by guiding Dijkstra's search with an admissible heuristic that estimates the remaining distance.

The decision rule of Bayesian optimization: score candidate points by expected usefulness to balance exploration and exploitation.

A finite, unambiguous procedure that transforms inputs into outputs to solve a problem.

Complexity describes how an algorithm’s time and memory grow with problem size, which decides what is feasible at scale.

Apply one Adam update with worked numbers, tracking the bias-corrected first and second moment estimates.

Estimate a rare-event probability far more efficiently by sampling from a shifted distribution and reweighting.

A convex hull algorithm that sorts points by coordinate and builds the lower and upper hulls in one linear pass each.

ANN algorithms find vectors close to a query far faster than exhaustive comparison by accepting a small, tunable loss in recall.

An approximation algorithm runs in polynomial time and returns a solution provably close to optimal for a hard optimization problem.

An AVL tree is a binary search tree that keeps every node's subtrees within one level of each other, guaranteeing O(log n) operations.

Three simple rules due to Kolmogorov make probability a consistent measure and generate every other identity.

A B-tree is a balanced search tree with many keys per node, tuned to minimise disk reads for databases and file systems.

A basis is a minimal set of vectors that spans a space; coordinates express every vector uniquely in that set.

Bayes theorem inverts conditional probability, turning a likelihood and a prior into an updated posterior belief.

Update probability distributions over uncertain parameters using data, yielding calibrated parameters that carry their own uncertainty.

Bayesian methods combine diagnostics and priors into a probability distribution over the plasma state, giving best estimates with calibrated uncertainty.

Bayesian optimization efficiently optimizes expensive black-box functions by modeling them and choosing where to sample next.

Choosing the next expensive experiment or simulation to run so that few evaluations find a good setting.

Choosing operating points and profiles is expensive to evaluate; Bayesian optimization finds good scenarios in few costly simulations by balancing exploration and exploitation.

Bayesian optimization finds good designs with few expensive evaluations by modeling the objective and choosing each next point to learn the most.

Bayesian optimization tunes operating scenarios and design parameters by balancing exploration and exploitation over an expensive objective.

The Bernoulli distribution models a single yes/no trial and is the atom from which many discrete distributions are built.

A notation describing how an algorithm's resource use grows with input size, ignoring constants.

Big-O notation describes how an algorithm's running time or space grows with input size, ignoring constants and lower-order terms.

A binary heap is a complete binary tree stored in an array that keeps the smallest or largest element at the root for O(log n) updates.

Binary search halves a sorted array each step to find a target in O(log n), the classic payoff for keeping data ordered.

A binary search tree keeps keys ordered so search, insertion, and deletion cost O(h) where h is the height, ideally O(log n).

A binary tree gives each node at most two children, forming the structural basis for search trees, heaps, and expression trees.

The binomial distribution counts successes in a fixed number of independent yes/no trials.

The bootstrap estimates the uncertainty of a statistic by resampling the observed data with replacement.

A restricted photonic model whose output distribution is classically hard to sample, offering evidence for quantum computational advantage.

A pattern-matching algorithm that scans right to left and skips large sections of text using two shift heuristics.

Branch and bound solves hard discrete problems by recursively splitting the search space and pruning branches that cannot beat the best solution found.

Breadth-first search explores a graph level by level from a source, finding shortest paths in unweighted graphs in O(V + E).

Bubble sort repeatedly swaps adjacent out-of-order pairs; simple to understand but O(n^2) and rarely used in practice.

The chi-squared distribution describes sums of squared standard normals and underpins variance and goodness-of-fit tests.

Pick the feature and threshold that most reduce label impurity, the greedy step that grows a decision tree.

Measurement is always relative to a basis; the same state yields different statistics in different bases, and basis choice is a design lever.

Circuit complexity measures the size and depth of Boolean circuits needed to compute a function, offering a hardware-based view of difficulty.

Libraries implement each collective with several internal algorithms and switch between them by message size, process count, and topology.

Communication-avoiding algorithms are redesigned to move less data, accepting extra arithmetic because communication, not computation, is the true cost.

Factor a small matrix into rotation, scaling, and rotation, and read off rank, range, and the best low-rank approximation.

The Fibonacci sequence illustrates the leap from exponential naive recursion to linear dynamic programming and logarithmic matrix methods.

Building and quantifying logical trees that trace an undesired event back to the combinations of failures that could cause it.

Planning the flow of specialized materials and components through fabrication so schedules stay feasible under real constraints.

Conditional entropy measures the uncertainty remaining in one variable once another is known.

Conditional probability updates the chance of an event once you learn that another event has occurred.

Two distinct ideas that together explain when a computed answer can be trusted: sensitivity of the problem and quality of the algorithm.

Conditioning measures how sensitive a problem is to input perturbations; stability measures how faithfully an algorithm solves the problem it was given.

Minimize an objective while respecting equality and inequality constraints, the setting for most real engineering design.

Content-addressable storage names each object by the hash of its bytes, giving automatic deduplication, integrity checking, and immutable references.

When the objective and feasible set are convex, every local minimum is global and efficient solvers guarantee the optimum.

The geometric and analytic building blocks of convex optimization: sets closed under line segments and functions that curve upward.

Optimize one variable at a time while holding the rest fixed, effective when single-coordinate updates are cheap and closed-form.

Coordinate descent optimizes one variable at a time, holding the rest fixed, and cycles or samples through the coordinates until convergence.

Counting sort tallies how many of each key value occur, then places elements directly, sorting in linear time for a small key range.

Cross-entropy benchmarking scores how well a device's random-circuit outputs match ideal probabilities, the basis of early quantum-advantage claims.

The cross-entropy method adaptively learns a good importance-sampling distribution for rare events by iteratively fitting to the best samples.

No algorithm is hard-coded; every key, certificate, and protocol carries an algorithm identifier so schemes can be rotated without redesigning the plant.

The cumulative distribution function gives the probability that a random variable falls at or below a value, unifying discrete and continuous cases.

Cutting-plane methods build an outer polyhedral approximation of a convex problem, adding one linear inequality at a time to trim the search region.

Scheduling a directed acyclic graph means choosing a valid task order and deciding when and how often the whole graph executes.

A problem is decidable if some algorithm always halts with the correct yes-or-no answer for every input.

A decision tree splits data on feature thresholds into a flowchart of rules, readable and nonlinear but prone to overfitting.

Complexity theory is framed around yes-or-no decision problems, but most practical tasks are optimization problems closely tied to them.

The density operator generalizes the state vector to describe statistical mixtures, subsystems, and open-system dynamics.

Depth-first search plunges as deep as possible before backtracking, revealing graph structure in O(V + E) time.

Derivative-free optimization minimizes functions using only their values, essential when gradients are unavailable, unreliable, noisy, or expensive.

Rewriting a matrix in a basis of its eigenvectors, where it acts as simple coordinate-wise scaling.

A population-based method that mutates candidates using scaled differences between other population members, effective for continuous global search.

Using asymmetric cryptography to prove that a message came from a specific signer and was not altered, without sharing a secret.

A graph algorithm that finds shortest paths from one node to all others with non-negative edge weights.

Dijkstra's algorithm finds shortest paths from a source in a graph with non-negative edge weights using a priority queue.

A layered max-flow algorithm that augments blocking flows per phase, reaching strong worst-case bounds.

Instead of predicting the mean return, distributional RL models the full distribution of possible returns, improving stability and risk awareness.

Distributional RL learns the full distribution of returns, not just its mean, capturing risk and multi-modality.

Distributionally robust optimization hedges against uncertainty in the probability distribution itself, optimizing the worst case over a set of plausible distributions.

Dynamic programming solves problems with overlapping subproblems by computing each subproblem once and reusing the stored result.

Dynamic programming solves sequential decision problems by working backward from the goal, building optimal policies from optimal subproblems.

Entropy measures disorder in a set of labels; information gain, the drop in entropy from a split, guides decision trees.

All refrigeration is entropy management, and the third law of thermodynamics forbids reaching absolute zero in any finite sequence of steps.

Throw random darts at a square, count how many land in the inscribed circle, and read off pi - with a 1/sqrt(N) error.

Flattening a tree into an array by recording entry and exit times, turning subtree and path problems into range problems.

Evolve continuous solutions by sampling from a distribution and adapting its mean and covariance toward better regions.

The expectation of a random variable is its probability-weighted average, the long-run mean of repeated draws.

Fusion design is a high-dimensional search; computing lets a small team examine tens of thousands of candidate machines instead of a handful.

The exponential distribution models the waiting time until the next event in a memoryless, constant-rate process.

Computing the greatest common divisor of two integers together with the coefficients of Bezout's identity.

Sorting data too large for memory by merging sorted runs read from and written to external storage.

A compact array structure that maintains prefix aggregates with logarithmic update and query using the low-bit trick.

FORM estimates a failure probability by finding the most probable failure point and linearizing the limit state there.

Forward UQ pushes known input distributions through a model to compute the resulting distribution, moments, and failure probabilities of the output.

Forward-backward computes exact state posteriors in a hidden Markov model by two passes of dynamic programming.

Gate-set tomography reconstructs a full, self-consistent description of a set of gates, state preparation, and measurement without assuming any of them is perfect.

A photonic sampling model using squeezed light instead of single photons, easier to scale and tied to matrix hafnians.

Evolve a population of candidate solutions through selection, crossover, and mutation, guided by a fitness function.

The geometric distribution counts how many independent trials you need until the first success.

Optimize when gradients are unavailable, unreliable, or expensive, using only objective values to guide the search.

An angular-sort sweep that computes the convex hull of a planar point set in O(n log n) time.

Algorithms that operate on graphs of nodes and edges to answer questions about connectivity and paths.

Graph convolutional networks generalize convolution to graphs by averaging each node's features with its neighbors' using a normalized adjacency matrix.

A graph can be stored as an adjacency matrix or an adjacency list; the choice trades memory against the cost of listing a vertex's neighbours.

An algorithm that builds a solution step by step, always taking the locally best choice.

A greedy algorithm makes the locally best choice at each step, which yields a global optimum only when the problem has the right structure.

The HHL algorithm prepares a quantum state proportional to the solution of a linear system, with runtime polylogarithmic in dimension under strong assumptions.

When two keys hash to the same bucket, a collision-resolution scheme keeps operations correct and fast; chaining and open addressing are the two families.

A data structure that maps keys to values with near-constant-time lookup using a hash function.

A hash table maps keys to slots through a hash function, delivering expected constant-time insertion, lookup, and deletion.

A hash function maps arbitrary data to a fixed-size integer; good hashing spreads inputs uniformly and underlies tables, caches, and fingerprints.

Cryptographic hash functions condense data into a fixed fingerprint, letting anyone detect if even a single bit has changed.

Heapsort builds a max-heap and repeatedly extracts the largest element, giving guaranteed O(n log n) sorting in place.

A heatmap maps a value at each cell of a grid to color, giving an immediate picture of a two-dimensional field or matrix.

Hierarchical clustering builds a tree of nested groups, letting you read clusters at any granularity from a dendrogram.

L1 assembles a coherent plasma or plug state vector every control cycle from dozens of diagnostics, validated and time-aligned in fabric.

The fastest classical algorithm for maximum matching in bipartite graphs, augmenting many shortest paths per phase.

A combinatorial method that finds a minimum-cost perfect matching in a weighted bipartite graph in polynomial time.

HPO and architecture search run as governed L0 campaigns whose winning configuration is a versioned, reproducible artifact — never an unrecorded manual tweak.

Importance sampling estimates expectations by drawing from a cleverly chosen distribution and reweighting, cutting variance for rare-event and tail problems.

Insertion sort builds a sorted prefix one element at a time; O(n^2) overall but fast on small or nearly sorted arrays.

Integer programming optimizes a linear objective over linear constraints where some or all variables must take whole-number values.

Solve linear and convex programs by following a smooth central path through the interior of the feasible region.

These classic stationary iterations split the matrix and sweep repeatedly; Gauss-Seidel reuses updated values and usually converges faster than Jacobi.

A joint distribution describes several random variables together, capturing how they co-vary as well as their individual behavior.

Joint entropy measures the combined uncertainty of two random variables considered together.

A binary space-partitioning tree that organizes points in k dimensions for nearest-neighbor and range search.

A randomized contraction algorithm that finds a global minimum cut of an undirected graph with high probability.

Kernel methods compute inner products in a high-dimensional space implicitly, letting linear algorithms learn nonlinear patterns.

Cryptography is only as strong as the handling of its keys, so generating, storing, rotating, and retiring them safely is the hard part.

The Knuth-Morris-Pratt algorithm finds a pattern in text in linear time by never re-examining characters, using a failure function.

Fill the 0/1 knapsack table for four items and a small capacity, then backtrack to recover which items the optimum selects.

Representing components, requirements, analyses, and their relationships as a graph so complex questions can be answered by traversal.

A linear-time single-pattern string search that never re-examines text characters, using a precomputed prefix-failure table.

Kolmogorov complexity measures a string's information as the length of the shortest program that outputs it.

A two-pass depth-first method for strongly connected components using the graph and its transpose.

Kruskal's algorithm builds a minimum spanning tree by adding edges in weight order, skipping any that would form a cycle.

A family of iterative solvers that build solutions from powers of a matrix applied to a vector, using only matrix-vector products.

The Kullback-Leibler divergence measures how much one probability distribution differs from a reference distribution.

Limited-memory BFGS stores only a handful of recent vectors, scaling quasi-Newton optimization to millions of variables.

Convert an equality-constrained optimization into stationarity of a single Lagrangian, with multipliers measuring constraint sensitivity.

The lambda calculus is a minimal formal system of functions that is equivalent in power to the Turing machine.

The probability of an event equals the weighted average of its conditional probabilities across a partition of the sample space.

Line search chooses how far to move along a descent direction each iteration, turning a direction into a concrete, safely sized step.

Given a descent direction, choose a step length that sufficiently decreases the objective, guaranteeing global convergence.

A set of vectors is independent when none can be built from the others; this fixes the true dimension of a space.

LMIs recast many control problems as convex feasibility or optimization over positive-definite matrices, solvable reliably by interior-point methods.

Optimize a linear objective subject to linear equality and inequality constraints: the most widely used class of optimization.

Linear search scans a collection element by element until it finds the target, costing O(n) but requiring no ordering or preprocessing.

Maps between vector spaces that respect addition and scaling; every one is represented by a matrix.

A fixed-capacity cache that evicts the least-recently-used entry, giving O(1) get and put with a hash map and linked list.

Factoring a matrix into lower and upper triangular pieces, the standard way to solve dense linear systems.

Factor a small matrix into permuted lower- and upper-triangular factors, then solve a system by forward and back substitution.

Factor a matrix into lower and upper triangular pieces so many linear systems can be solved with cheap back-substitution.

From a joint distribution you extract marginals by summing out variables and conditionals by fixing them.

MCMC samples from complex distributions by building a Markov chain whose stationary distribution is the target.

A Markov chain is a random process whose next state depends only on the current state, not the full history.

A Markov decision process formalizes sequential decision making as states, actions, transition probabilities, rewards, and a discount factor.

Raising a transition matrix to a large power by repeated squaring to evaluate linear recurrences in logarithmic time.

Matrix factorization embeds users and items in a shared latent space so their dot product predicts preference.

Measures of a matrix's size, from element-wise sums to the largest amount it can stretch a vector.

Matrix-free methods provide the action of an operator on a vector without assembling or storing the operator as an explicit matrix.

A technique that halves the exponent of brute force by splitting the search, solving both halves, and combining results.

Merge sort splits the array in half, sorts each recursively, and merges the two sorted halves, guaranteeing O(n log n) and stability.

Draw samples from a target distribution using a random-walk proposal and the accept-reject rule, then check the sample statistics.

A minimum spanning tree connects all vertices of a weighted graph with the least total edge weight and no cycles.

Answering many offline range queries efficiently by reordering them to minimize the movement of two pointers.

Moments summarize a distribution's shape, and generating functions package all of them into a single transform.

Monte Carlo dropout estimates uncertainty by keeping dropout active at prediction time and sampling many stochastic forward passes.

Keeping dropout active at prediction time and averaging many stochastic forward passes gives a cheap approximation to Bayesian uncertainty.

Estimate pi by sampling points in a square, count the fraction inside the inscribed circle, and quantify the error scaling.

Monte Carlo estimates output statistics by random sampling of inputs, a robust dimension-independent workhorse of uncertainty propagation.

Estimating integrals by random sampling, with error that shrinks independently of dimension.

A family of methods that estimate quantities by averaging over many random samples.

Monte Carlo methods estimate quantities by random sampling, converting hard integrals and expectations into averages.

Monte Carlo methods learn values from complete episodes by averaging the actual returns that follow each state.

Monte Carlo neutral codes launch and follow statistical sample particles through collision physics to tally plasma sources in realistic geometry.

MCTS builds an asymmetric search tree by repeated simulation, focusing effort on the most promising moves.

Monte Carlo tree search plans by selectively growing a search tree, balancing promising moves against unexplored ones through sampled rollouts.

Sample the uncertain inputs many times, run the code on each, and build the output distribution directly; general but expensive.

Weight windows, importance biasing, and splitting that let Kronos resolve deep-shield and rare-channel quantities without brute force.

Multi-fidelity Monte Carlo estimates statistics by combining a few high-fidelity samples with many cheap low-fidelity ones as control variates.

Optimize several conflicting objectives at once, seeking the set of trade-off solutions rather than a single best point.

Multilevel Monte Carlo estimates statistics by combining many cheap coarse-grid samples with a few expensive fine-grid corrections.

Nonconvex objectives have multiple minima, saddles, and plateaus, so no method guarantees a global optimum, yet local methods often work well in practice.

The normal, or Gaussian, distribution is the bell curve that arises whenever many small independent effects add up.

Batch, layer, instance, and group normalization differ only in which axes they compute statistics over, and that choice determines where each works best.

Vector and matrix norms measure size and error, and the matrix condition number bounds how much a linear solve can amplify input errors.

A class of problems believed to have no efficient exact algorithm, all reducible to one another.

A fast elitist genetic algorithm that finds a diverse approximation of the whole Pareto front in a single run.

Among explanations that fit equally well, prefer the simpler; added complexity must earn its place by explaining more.

Representing a categorical value as a binary vector with a single active element.

Online convex optimization makes a sequence of decisions against an adversary revealing convex losses one at a time, judged by regret against the best fixed choice.

Optimization finds the inputs that best satisfy an objective under constraints, which is the mathematical core of engineering design.

A fusion design must be optimized subject to hard limits; the interesting solutions almost always sit on the constraint boundaries.

Vectors are orthogonal when their dot product is zero, a condition that simplifies geometry, projection, and computation.

A basis of mutually perpendicular unit vectors, in which coordinates are just dot products and geometry is preserved.

Monte Carlo methods estimate answers by random sampling; their independence makes them scale almost perfectly, with a catch in random numbers.

A swarm of candidate solutions moves through the search space, each pulled toward its own best and the swarm's best position.

Physics-constrained optimization searches for the best design while requiring that governing equations and physical limits are respected.

The Poisson distribution models the count of independent events in a fixed interval when they occur at a steady average rate.

Represent the output as a polynomial series in the uncertain inputs, capturing the distribution with far fewer runs than sampling.

When the agent cannot observe the full state, it must act on a belief, a probability distribution over states.

Powell's method minimizes a function by successive line searches along a set of directions that it updates to become mutually conjugate, without derivatives.

Prim's algorithm grows a minimum spanning tree from a start vertex, always adding the cheapest edge that reaches a new vertex.

Find the directions of maximum variance by taking the eigenvectors of the covariance matrix, and project to fewer dimensions.

A probability density function describes a continuous random variable through probability per unit length, not probability at a point.

A probability mass function gives the probability that a discrete random variable equals each of its possible values.

The closest point in a subspace to a given vector, found by dropping a perpendicular.

Forward uncertainty propagation pushes distributions over uncertain inputs through a model to characterize the distribution of its outputs.

Any mixed state can be viewed as part of a larger pure state, a construction that underlies channels, entropy, and open-system reasoning.

Purity and linear entropy are simple quadratic measures of how far a state is from pure, useful when logarithms are inconvenient.

Factoring a matrix into an orthonormal part and an upper triangular part, the stable workhorse for least squares.

Orthonormalize the columns of a small matrix with Gram-Schmidt to produce Q and R, and check orthogonality.

Minimize a quadratic objective subject to linear constraints: convex when the quadratic term is positive semidefinite.

Estimating the number of solutions to a search problem quadratically faster than classical sampling, without finding them.

Estimating expectation values and integrals with a quadratic reduction in sample complexity using amplitude estimation.

Process tomography reconstructs the full channel a device implements by probing it with known states and measuring the outputs.

Process tomography fully reconstructs what an operation does to every input state, giving a complete but expensive picture of a gate.

State tomography reconstructs an unknown density matrix from measurements on many identically prepared copies.

Quasi-Monte Carlo replaces random samples with low-discrepancy sequences that fill space more evenly, converging faster than plain Monte Carlo.

Quicksort partitions around a pivot and recurses on each side; O(n log n) on average with excellent constants, though O(n^2) in the worst case.

Rabin-Karp searches for a pattern by comparing rolling hashes of text windows, enabling efficient multi-pattern search.

Radix sort orders integers digit by digit using a stable counting sort per digit, achieving linear time when the key width is bounded.

An ensemble of decorrelated decision trees whose averaged predictions are more accurate and stable than any single tree.

Randomized algorithms use random choices during execution to gain speed or simplicity, at the cost of some uncertainty.

The number of independent directions a matrix can reach, equal to the dimension of its column space.

Recursive algorithms solve a problem by solving smaller versions of it, and their cost is captured by recurrence relations.

A red-black tree is a self-balancing binary search tree that uses node colours and five rules to keep height within a factor of two of optimal.

The reduced density matrix describes a subsystem alone, obtained by partial-tracing out the rest; it reveals entanglement as local mixedness.

A result you cannot regenerate from its inputs is a claim, not a finding; reproducibility is what makes computational science checkable.

Robust optimization guards against uncertain data by optimizing for the worst case within a defined uncertainty set, requiring no probability distribution.

Scheduling decides which task runs when; in real-time systems the algorithm must be analyzable so deadlines can be guaranteed in advance.

Saddle points are critical points that are minima in some directions and maxima in others; they dominate high-dimensional nonconvex landscapes.

How much interaction an algorithm needs to learn is often the deciding factor when environment steps are slow or costly.

A sampling distribution is the distribution of a statistic across repeated samples, and it is what makes inference possible.

Draw samples from a distribution you can only evaluate up to a constant, using a random walk with an accept-reject rule.

Optimization codes search the design or operating space for points that maximize an objective subject to physics and engineering constraints.

SDP relaxation replaces a hard nonconvex problem with a tractable semidefinite program by lifting variables into a matrix and dropping a rank constraint.

Second-order cone programming optimizes a linear objective subject to constraints that a norm is bounded by an affine function, generalizing quadratic programs.

A balanced binary tree over an array that answers range queries and point or range updates in logarithmic time.

Selection sort repeatedly picks the smallest remaining element and places it next; O(n^2) but with the fewest possible writes.

Semidefinite programming optimizes a linear objective over symmetric matrices constrained to be positive semidefinite, generalizing linear programming.

Shannon entropy measures the average uncertainty, in bits, of a random source's outcomes.

A randomized ordered structure of layered linked lists giving expected logarithmic search, insert, and delete.

A function that turns a vector of scores into a probability distribution over classes.

Solve Ax = b without factoring the matrix by repeatedly updating each unknown from the previous sweep's values.

The central problem of linear algebra: finding the vector x that a matrix A maps to a given vector b.

A procedure for arranging elements in order, a foundational and well-studied computing task.

Space complexity measures how much working memory an algorithm needs as a function of input size.

The span of a set of vectors is every point you can reach by scaling and adding them.

Sparse matrices store and operate on only their nonzero entries, making it possible to solve systems with millions of unknowns.

A self-adjusting binary search tree that moves each accessed node to the root, giving strong amortized guarantees.

Stationarity means a series statistics do not change over time; autocorrelation measures how a series relates to its own lags.

A stationary distribution is a state distribution that a Markov chain leaves unchanged, and often the limit it converges to.

Statistical entropy measures the average uncertainty in a random variable, in bits or nats, and grounds information theory.

Stochastic programming optimizes decisions when some data is random, using probability distributions to model uncertainty and expected outcomes.

Vector fields are shown by tracing paths that follow the field, by placing oriented glyphs, or by texture-based methods that fill space.

Polynomial rolling hashes turn strings into integers that can be compared and updated in constant time, powering fast substring algorithms.

The Student-t distribution accounts for the extra uncertainty of estimating a standard deviation from a small sample.

Rules for computing subdifferentials of sums, maxima, and compositions let algorithms find a valid descent direction even at nondifferentiable points.

A sorted array of all suffix starting positions of a string, giving compact full-text indexing and fast substring search.

A suffix tree indexes all suffixes of a string in a compressed trie, answering many substring queries in time independent of the text length.

An SVM finds the boundary with the widest margin between classes, using kernels to draw nonlinear separators.

Compute the singular value decomposition of a small matrix from its symmetric products and verify the reconstruction.

A single-pass depth-first algorithm that finds all strongly connected components of a directed graph in linear time.

Tensor cores are specialized units that compute small matrix multiply-accumulate operations in one step, at much higher throughput than general cores.

Tensor fields carry directional information richer than a vector; visualizing them means showing magnitude and orientation in several directions at once.

Multidimensional generalizations of scalars, vectors, and matrices, indexed by any number of dimensions.

The Born rule states that the probability of a measurement outcome equals the squared magnitude of its amplitude.

MPC never optimizes freely; it optimizes inside a certified envelope of states and actuator moves proven safe, which is the constraint set X_safe.

P is the class of decision problems solvable by a deterministic algorithm in time polynomial in the input size.

A product of two vectors in three dimensions that yields a third vector perpendicular to both.

Deutsch-Jozsa decides constant-vs-balanced in one query - the textbook first step whose interference trick powers the fusion-relevant algorithms Kronos uses.

Multiply matching components and add; the result measures length, angle, and alignment between two vectors.

An exception matrix maps detected off-normal conditions to defined responses, making fault handling explicit, reviewable, and testable.

Frank-Wolfe minimizes a smooth function over a convex set using only linear subproblems, never projecting back onto the set.

The energy-dependent probability that two colliding nuclei fuse, the microscopic input to all reaction rates.

A procedure that turns any independent set of vectors into an orthonormal set spanning the same space.

No algorithm can decide, for every program and input, whether that program eventually halts or runs forever.

The Hessian matrix of second derivatives describes an objective's local curvature, classifying critical points and governing how fast optimizers converge.

The HHL algorithm solves linear systems on a quantum computer in time logarithmic in the matrix size, under conditions that sharply limit its practical reach.

The square matrix with ones on the diagonal and zeros elsewhere acts as the multiplicative identity for matrices.

The kernel trick lets linear algorithms operate in a high-dimensional feature space using only inner products, never computing the explicit coordinates.

The 0/1 knapsack problem picks a subset of items with maximum value under a weight limit, solved by dynamic programming.

A state is Markov when it captures all history relevant to the future, so the past adds nothing once the present is known.

Extending the exponential function to matrices, the key to solving systems of linear differential equations.

The inverse undoes a matrix's action, but it exists only for square, full-rank matrices and is rarely computed explicitly.

The workhorse algorithm that solves the Vlasov-Maxwell system by following sampled particles on a field grid.

The simplest eigenvalue algorithm: repeatedly apply a matrix to a vector to converge onto the dominant eigenvector.

A generalized inverse that gives the least-squares, minimum-norm solution for any matrix, invertible or not.

The QR algorithm computes all eigenvalues of a matrix by repeated QR factorization, accelerated by Hessenberg reduction and shifts.

A factorization that reveals the fundamental geometry of any matrix and underlies least squares, rank, and low-rank approximation.

Softmax turns a vector of scores into a probability distribution, the standard output layer for multi-class classification and attention weights.

Any sort that orders by comparing keys must make at least on the order of n log n comparisons in the worst case.

The matrix exponential propagates a linear system's state forward in time and forms the core of its solution.

The Thomas algorithm solves tridiagonal systems in linear time, the specialized elimination behind splines and one-dimensional implicit schemes.

Reflecting a matrix across its main diagonal turns rows into columns and reverses the order of products.

The upper-confidence-bound algorithm handles the explore-exploit trade-off by playing the arm with the highest optimistic estimate of its reward.

The collisionless kinetic equation that evolves a particle distribution function in six-dimensional phase space.

The Wolfe conditions are two inequalities a line-search step must satisfy to guarantee both sufficient decrease and enough curvature progress.

A measure of how an algorithm's running time scales with the size of its input.

Time complexity measures how the number of basic operations an algorithm performs grows with input size.

A topological sort orders the vertices of a directed acyclic graph so every edge points forward, respecting all dependencies.

Follow Dijkstra's shortest-path algorithm node by node on a five-vertex weighted graph, watching the tentative distances settle.

A randomized balanced BST that couples binary-search-tree keys with heap-ordered random priorities for expected logarithmic height.

Tree traversals visit every node in a defined order: pre-order, in-order, and post-order for depth, and level-order for breadth.

A tree keyed on shared prefixes that stores a set of strings for fast prefix search, autocomplete, and dictionary lookup.

A trie stores strings by their characters along tree paths, giving lookup time proportional to key length rather than the number of keys.

Every simulation output is a distribution, not a number; good engineering decisions weigh the spread, not just the central value.

The uniform distribution spreads probability evenly, and its continuous form is the root of most random number generation.

A vector database stores high-dimensional embeddings and retrieves the nearest ones to a query vector, powering semantic search and retrieval-augmented generation.

Different ways to measure the length of a vector, each suited to a different notion of size or distance.

The abstract setting where addition and scalar multiplication obey a short list of axioms, unifying vectors, functions, and more.

Viterbi finds the single most probable hidden state sequence in an HMM using dynamic programming over paths.

When threads in a warp take different branches, the hardware runs each path serially, wasting throughput on the inactive threads.

GPUs execute threads in lockstep groups called warps; keeping enough warps resident and avoiding divergence within them drives performance.

Weak duality always bounds the primal by the dual; strong duality closes the gap under convexity and a constraint qualification.

A linear-time method that computes, for each position, the length of the longest substring starting there that matches a prefix.

A small gridworld makes the abstractions of MDPs, value functions, and value iteration concrete and inspectable.

Hiding detail behind clean boundaries lets large systems be understood, built, and changed one piece at a time.

Computing compresses the loop from idea to evaluated design from months to days, so more ideas get tested and better ones survive.

Deciding in advance how much error or discrepancy is acceptable turns V&V evidence into a defensible pass-or-fail decision.

Active subspaces find the few input directions along which a function changes most, collapsing high-dimensional problems onto a low-dimensional ridge.

A combinational circuit that adds binary numbers, the arithmetic core of a processor.

Reaching a hard-to-prepare ground state by starting easy and deforming slowly, guided by the adiabatic theorem.

Adjoint methods compute the sensitivity of an output to all inputs at a cost independent of the number of inputs, powering efficient local UQ.

Some uncertainty is genuine randomness that cannot be reduced; some is ignorance that more information removes. The distinction changes what to do.

ADMM splits a large problem into smaller pieces coupled by a linear constraint, then coordinates their solutions through a dual variable.

The self-regulating diffusion in which electrons and ions leave together at a common rate set by a self-consistent field.

Amdahl's law bounds speedup when a serial fraction is fixed; Gustafson's law shows scaling improves when the problem grows with the processors.

Amortized analysis measures the average cost per operation over a sequence, showing that occasional expensive operations are cheap on average.

Exact closed-form solutions of simplified problems provide ground truth for verification without needing a manufactured source.

Anomaly detection flags behavior that departs from the learned normal, catching problems that no one wrote an explicit rule for.

An array stores a fixed number of equal-size elements in one contiguous block, giving constant-time access by index.

Asymptotic analysis studies how resource use grows as input size heads toward infinity, ignoring machine-specific constants.

Combine a quadratic penalty with explicit multiplier estimates to reach feasibility without driving the penalty weight to infinity.

Turning raw simulation outputs into consistent, verifiable, human-readable reports without manual copy-paste.

Automated checks re-run analyses and compare outputs to expected values, so a claim and its evidence never silently drift apart.

Automation executes a fixed procedure a human specified; autonomy chooses its own actions toward a goal, and the gap is where risk lives.

Backtracking builds candidate solutions incrementally and abandons a partial candidate as soon as it cannot be completed.

A barrel shifter moves a word left or right by any number of positions in one pass, using layered stages of multiplexers.

Keep iterates strictly inside the feasible region by adding a barrier that grows to infinity at the boundary of inequality constraints.

A barrier blocks every process until all processes in the communicator have reached it, giving a common synchronization point.

Converting a number between bases uses repeated division for the integer part and repeated multiplication for the fraction.

Collections of benchmarks and public rankings drive progress and distort it in equal measure; the ranking is not the goal.

Between shots, automated analysis turns the last discharge into corrections for the next, tightening the loop over an operating day.

Bounded-input bounded-output stability holds exactly when the impulse response is absolutely integrable, equivalent to left-half-plane poles.

Big-Omega notation gives a lower bound on a function's growth, stating the cost is at least a certain rate.

Big-Theta notation gives a tight bound: the function grows at exactly the stated rate, up to constants.

Base-2 representation using only 0 and 1, the native language of digital hardware.

Binary represents every number with just two digits, 0 and 1, matching the two states of a switch.

A binary subtractor computes A minus B, most often by adding A to the two's complement of B using an ordinary adder.

Block coordinate descent updates a group of correlated variables jointly at each step, restoring efficiency when single-coordinate updates stall.

Matrices partitioned into submatrices, letting large structured problems be manipulated in coarse pieces.

SAT asks whether a Boolean formula can be made true by some assignment of true and false to its variables.

The burner runs as a long steady-state supervisory loop rather than pulsed shots, so orchestration emphasizes continuous supervision over sequencing.

The burner (Aegis / MetroVolt) aims at steady export, so its operating story is about holding a regime, not chaining shots - under four honest gates.

The end tanks terminate each end of the machine, housing the converter, handling exhaust, and maintaining the axial vacuum.

When multiple cores cache the same memory, a coherence protocol like MESI keeps their private copies consistent.

Every channel carries a live calibration; the fabric watches for slow drift and corrects or flags it before it biases a feature.

How the user moves and points the camera determines whether a 3D visualization is explorable or disorienting.

A sweep orchestrator generates comparable shot plans across a parameter grid, submits them by priority, and adapts the grid from results.

The central limit theorem explains why sums and averages of many independent variables become normally distributed.

Translating coordinates and matrices from one basis to another, revealing that many matrices describe the same map.

Channel capacity is the maximum rate at which information can be sent reliably over a noisy channel.

Checkpointing periodically saves a computation's state so a long run can resume after a failure instead of starting over.

The efficient square-root factorization reserved for symmetric positive-definite matrices.

A system that proposes, runs, analyzes, and re-plans experiments in a loop with limited human intervention.

When the threads of a warp read contiguous addresses, the hardware serves them in one wide memory transaction instead of many.

Solving differential equations by requiring the approximate solution to satisfy the equation exactly at a chosen set of points.

Columnar formats store each column contiguously, giving analytical queries far less I/O and far better compression than row-oriented storage.

Columnar formats store tables by column rather than by row, making analytical scans and compression far more efficient.

Commands are imperative requests that may be rejected; events are immutable facts that already happened. The stack keeps them strictly separate.

A way of framing problems so a machine can solve them: decompose, find patterns, abstract away detail, and specify a procedure.

Computation carries a fusion machine from first design sketch through simulation, construction, commissioning, and daily operation.

Simulating how coolant carries heat away from the components that intercept fusion power, keeping temperatures within limits.

Predicting how repeated thermal and mechanical cycling accumulates damage in components until cracks initiate and grow.

A measure of how sensitive a problem's output is to small changes in its input.

A confidence interval is a range that would capture the true parameter in a stated fraction of repeated experiments.

Physical invariants like conserved mass, energy, and symmetry must hold in the discrete solution; a violation is a bug.

A layered harness that grades copilot answers, reasoning traces, and proposals against grounded, machine-specific truth before any change ships.

A measure of how strongly two variables move together, and a caution against inferring causation.

The correlation coefficient rescales covariance to a dimensionless number between -1 and 1, measuring linear association.

That two things move together does not mean one drives the other; mistaking association for cause is the most common inferential error.

The rate at which cumulative small-angle Coulomb encounters deflect a charged particle by a large angle.

Covariance measures whether two random variables tend to move together, in the same direction or opposite ones.

Step a 1D heat equation with the unconditionally stable Crank-Nicolson scheme by solving a tridiagonal system each step.

Trade an explicit stability limit for an unconditionally stable, second-order-in-time implicit scheme that solves a tridiagonal system each step.

When a design decision rests on a simulation, credibility is the evidence chain: verification, validation, uncertainty, and honest scope.

A cryostat is the nested-shield vacuum enclosure that stages temperature from room ambient down to millikelvin while blocking radiation and conduction.

Cubic splines join cubic pieces with matched first and second derivatives, giving smooth interpolation that avoids high-degree oscillation.

How the top-level operating dashboards are composed and which indicators define a good shot for the breeder and steady operation for the burner.

De Morgan's laws convert between AND and OR through inversion, letting any gate be rebuilt from its dual.

An event that repeatedly fails processing is quarantined to a dead-letter topic so it cannot stall a partition or block the machine.

The fast feedback loop that keeps the burner's collector grids matched to a shifting ion spectrum, executed deterministically for stable direct conversion.

A demultiplexer routes a single input to one of several outputs chosen by select lines, the reverse of a multiplexer.

A double-ended queue supports constant-time insertion and removal at both ends, generalising both the stack and the queue.

The describing function approximates a nonlinearity by its gain to a sinusoid, letting frequency methods predict limit cycles.

Callouts present a component's key parameters with their conditions, so a number is never shown without the context it needs.

Analog telemetry crosses the vacuum and cryogenic boundary through rated feedthroughs into a fabric front end that samples at sub-microsecond intervals.

Any shot or campaign can be re-executed against the recorded event stream to reproduce exactly what orchestration saw and decided.

Decide whether a black-box function is constant or balanced with a single evaluation instead of exponentially many.

A comparator compares two binary numbers and reports whether one is equal to, greater than, or less than the other.

A digital comparator tests two binary numbers and reports whether one is greater than, equal to, or less than the other.

Dilated causal convolutions insert gaps between kernel taps to widen the receptive field exponentially while keeping outputs strictly dependent on the past.

Dilated (atrous) convolutions insert gaps between kernel elements to expand the receptive field without adding parameters or losing resolution.

High-dimensional uncertainty problems become tractable only after reducing inputs or outputs to the directions that actually matter.

Dimensionality reduction compresses many features into a few, aiding visualization, speed, and defeating sparsity.

How charged fusion products can be decelerated against an electric field to produce electricity without a thermal cycle.

The two families differ in whether outcomes are countable, and that difference decides whether you sum or integrate.

Divide and conquer splits a problem into independent subproblems, solves them recursively, and combines their answers.

A dynamic array grows automatically by reallocating to a larger block, giving amortized constant-time append on top of a fixed array.

Dynamic routing iteratively assigns lower-level capsule outputs to the higher-level capsules whose predictions they most agree with.

EDF always runs the task with the nearest deadline; it achieves full processor utilization but at the cost of dynamic priorities and harder overload behavior.

Edit distance counts the fewest single-character insertions, deletions, and substitutions needed to turn one string into another.

Elastic net blends L1 and L2 penalties, gaining lasso's sparsity and ridge's stability with correlated features.

Endianness is the order in which the bytes of a multi-byte value are stored in memory.

As power, not transistor count, limits large systems, efficiency is measured in useful work per joule and pursued across hardware and software.

Some uncertainty comes from what we do not yet know and shrinks with study; some is inherent randomness that no amount of study removes.

An itemized accounting of every error source in a prediction, added up so the total uncertainty is defensible rather than guessed.

Automated checks that every factual claim in an answer is supported by a cited source that actually entails it — catching both missing and misleading citations.

Ordering is guaranteed only within a partition, so partition keys are chosen to keep causally-related machine events on one ordered stream.

Event sourcing records every change as an immutable event in an append-only log, so current state is derived by replaying history.

Event streaming platforms store ordered, replayable logs of events partitioned for scale, letting many independent consumers read the same history.

An append-only, partitioned event log is the single source of truth carrying every measurement, prediction, proposal, and command through the stack.

Where Kronos workloads actually scale toward exascale, where they do not, and why bandwidth and reproducibility bound the frontier.

Experience replay stores past transitions and reuses them in random minibatches, breaking correlations and improving sample efficiency.

UCB explores by acting optimistically under uncertainty: prefer actions whose value might still be high.

Exponential smoothing forecasts by averaging past values with weights that decay geometrically into the past.

EXPTIME is the class of problems solvable in exponential time, and it provably contains problems that P cannot.

A claim earns scientific standing by risking refutation; a theory that forbids nothing explains nothing.

Fan-in is how many inputs a gate accepts; fan-out is how many inputs one output can reliably drive.

A priority queue with O(1) amortized insert and decrease-key, improving the theoretical bound of Dijkstra and Prim.

A finite state machine has a fixed number of states and no external memory, making it weaker but far easier to analyze than a Turing machine.

March a vibrating string forward with a leapfrog scheme and meet the Courant condition that keeps it stable.

Rewriting f(x)=0 as x=g(x) and iterating x_{n+1}=g(x_n) converges to a fixed point whenever g is a contraction near the root.

Across many burner units, L7 solves a constrained scheduling problem that meets firm-power obligations while respecting maintenance, ramp, and physics limits.

Prove the closed loop can never reach an unsafe state — over the whole reachable set, not just per step.

When states are too many to tabulate, value functions and policies are represented by parameterized functions that generalize across states.

Stability margins measure how much extra gain or phase lag a stable loop can tolerate before it begins to oscillate.

Gain and phase margins quantify how much loop gain or phase lag a stable feedback system can absorb before it becomes unstable.

Turning a mathematically specified unitary into an explicit, resource-minimal sequence of executable gates.

Solve a small diagonally dominant system by sweeping updates in place, using each new value immediately.

Local sensitivity is a derivative at one point; global sensitivity explores the whole input space and captures interactions.

Green blocks run the plant as an operating asset — dispatch, scheduling, maintenance, and supply chain — described purely by operational role.

When a request is unsafe, out of scope, or under-supported, the copilot refuses or escalates rather than guessing — a designed behavior, not a failure.

Gustafson's law reframes scaling for growing problems, showing that large machines stay useful when the workload scales with processor count.

The Hamming distance between two equal-length strings is the number of positions where they differ.

Verilog and VHDL describe digital hardware as text, letting engineers specify behavior and structure that tools turn into circuits.

A hardware prefetcher predicts which memory a program will need next and fetches it into cache before the request arrives.

Heterogeneous systems combine CPUs with accelerators, assigning each part of a workload to the processor that runs it best.

A heuristic is a practical strategy that finds good solutions quickly without any guarantee of optimality or worst-case quality.

The fine print behind the HHL speedup: condition number, state preparation, readout, and when the exponential advantage survives.

Telemetry is stored as fully time-resolved series, not downsampled summaries, so the fast physics survives into the archive intact.

Symmetric and recursively constructed product formulas that cancel low-order error terms for far better accuracy per step.

Keeping a person in the decision path pairs machine speed with human judgment, but only if the human is positioned to actually intervene.

The center stack is the slender central column that carries the toroidal-field return, the solenoid, and the inboard shielding.

Implicit feedback infers preference from behavior like clicks and plays, where non-interaction is ambiguous.

Two events are independent when knowing one occurred gives no information about the other.

Interrupts and exceptions divert the processor from its current work to handle an event, then restore it precisely afterward.

An inverse problem infers hidden causes from observed effects, such as reconstructing internal state from external measurements.

Isolate a single part or hide obscuring shells to inspect any component of either machine without clutter.

Isolation forest detects anomalies by how quickly random partitioning isolates a point from the rest.

Recovering accuracy lost to rounding by computing a residual, solving for the correction, and adding it back.

A deadline met on average is a deadline missed under load; the reflex tier is engineered for bounded worst-case jitter, not good typical behavior.

Expanding a real gas through a restriction cools it below its inversion temperature, a principle used in the final liquefaction stages of cryogenic systems.

A grid method for simplifying Boolean expressions by grouping adjacent terms visually.

A Karnaugh map is a grid arrangement of a truth table that makes Boolean simplification a matter of grouping adjacent 1s.

The Karush-Kuhn-Tucker conditions generalize Lagrange multipliers to inequality constraints, characterizing constrained optima.

The Power Systems module tracks direct-energy-conversion voltages, extraction efficiency, and grid synchronization for the burner.

Fold constraints into the objective with multipliers, minimize over the primal variables, and obtain a dual problem of lower bounds.

The law of large numbers says the sample average converges to the true mean as the number of observations grows.

Lead compensators add phase for speed and stability; lag compensators add low-frequency gain for accuracy; together they shape the loop.

The best-fit solution to an overdetermined system, minimizing the sum of squared residuals.

Finding the best approximate solution to an overdetermined system by minimizing the sum of squared residuals.

A cache that evicts the least-frequently-used entry, favoring items accessed often over items accessed merely recently.

A paradigm that solves geometric problems by moving an imaginary line across the plane and processing events in order.

A linked list chains elements through pointers so insertion and deletion cost constant time, at the price of losing random access.

Load balancing distributes work evenly across processors so none sits idle waiting for an overloaded peer; imbalance caps scaling.

Distributing work evenly across processors or machines so none sits idle while others are overloaded.

Load imbalance is uneven work across processes; at each synchronization point everyone waits for the slowest, wasting the difference.

The local outlier factor scores anomalies by comparing a point density to the density of its neighbors.

Local sensitivity measures the response to a small nudge at one point; global sensitivity averages influence over the whole uncertain input space.

Procedures that run for minutes to hours checkpoint their state so a restart resumes exactly, without re-energizing from scratch.

The longest common subsequence finds the longest ordering of characters shared by two strings, solved with a two-dimensional DP table.

Every linear program has a dual whose optimum equals the primal optimum, providing bounds, certificates, and shadow prices.

The LP relaxation drops integrality from an integer program, yielding a tractable linear program whose optimum bounds the true integer optimum.

Lyapunov theory judges stability from an energy-like function, applying to nonlinear systems without solving their equations.

Machine epsilon is the gap between 1.0 and the next representable float, bounding relative rounding error.

A simplified Toffoli that flips the target correctly but allows one extra sign, cheaper to build and safe when uncomputed.

In a Mealy machine the outputs depend on both the current state and the current inputs, reacting faster but risking glitches.

Memoization caches the results of function calls so repeated calls with the same arguments return instantly instead of recomputing.

The memory hierarchy stacks storage from small and fast to large and slow, using locality to give the illusion of both.

A message queue decouples producers from consumers by buffering messages, absorbing load spikes and letting components fail and recover independently.

A message broker decouples producers from consumers by durably buffering and routing records, absorbing bursts and surviving failures.

Minterms and maxterms are the canonical product and sum terms that pin a Boolean function to individual truth-table rows.

Computing a base raised to a large power modulo m in logarithmic time by repeated squaring.

A cheap global method that separates influential inputs from negligible ones before spending a full sensitivity budget.

Hard operating limits enter MPC as inequality constraints; the Karush-Kuhn-Tucker conditions define the optimum and expose which limits are active.

The burner's direct energy conversion produces electrical output that must track collector potentials and synchronize to the grid; Kronos governs this with MPC.

When several goals conflict, multi-objective RL seeks the Pareto front of policies rather than a single optimum.

Real components obey several physics at once; multiphysics coupling solves them together so their interactions are captured.

A circuit that selects one of several inputs to pass to its single output, steered by select lines.

The NAND gate outputs 0 only when all inputs are 1; it is an AND followed by inversion and is functionally complete.

Condensing long technical documents into faithful summaries, with the source always one click away for verification.

A nondeterministic machine may branch into many possible next steps at once and accepts if any branch leads to acceptance.

The NOR gate outputs 1 only when all inputs are 0; it is an OR followed by inversion and is functionally complete.

NP-complete problems are the hardest in NP: every NP problem reduces to them, so a fast solution to one would solve all of NP.

An NP-hard problem is at least as hard as every problem in NP, but need not itself be in NP.

The Nyquist plot traces the loop gain in the complex plane as frequency varies, encoding closed-loop stability in its encirclements.

OLTP systems run many small transactions on current records; OLAP systems run few large scans that aggregate history. Their designs pull in opposite directions.

One-sided communication lets a process read or write a remote process's memory directly, without the remote process issuing a matching call.

Summarizing machine state, open items, and outstanding risks between crews with citations, so context is not lost across a handoff.

The order of convergence quantifies how fast an iterative method's error shrinks, distinguishing linear, superlinear, and quadratic methods.

Square matrices whose columns are orthonormal; they rotate and reflect without changing lengths or angles.

When something goes wrong, the priority order is safe physical state first, then containment, then recovery - never the reverse.

The frontier of non-dominated solutions in objective space, showing the best achievable trade-offs among competing goals.

Partial differential equations relate how quantities change across space and time, and they describe nearly all continuum physics.

Principal component analysis compresses correlated inputs or outputs into a few uncorrelated components, simplifying uncertainty propagation.

Independent expert critique before and after publication is how a field decides which claims to provisionally trust.

Convert constraints into a penalty term added to the objective, then solve a sequence of unconstrained problems with growing penalty.

A persistent identifier is a stable, resolvable name for a digital object that keeps pointing to it even as locations change.

Phase-plane analysis studies second-order nonlinear systems by plotting trajectories in the plane of the two states, revealing global behavior at a glance.

The burner's 1D axial potential and density profiles are solved by a PINN that carries quasineutrality and ambipolarity as constraints, with extrapolation honesty built in.

The explicit plant-wide states and the guarded transitions between them - the backbone that makes every other resiliency behavior legible.

Verification asks whether a proposed answer can be checked quickly, which is the defining feature of the class NP.

Pooling downsamples feature maps by summarizing local regions, shrinking resolution while building a degree of invariance to small shifts.

Symmetric matrices whose quadratic form is always positive; they behave like positive numbers among matrices.

A confidence interval bounds an estimated parameter; a prediction interval bounds a future observation and is always wider.

Every user, process, and component should have only the access strictly necessary for its task, and no more.

Priority inversion is when a high-priority task waits on a resource held by a low-priority one; inheritance protocols bound how long that wait can last.

A priority queue serves elements by priority rather than arrival order, usually implemented with a binary heap.

Standing administrative power is minimized; elevated access is granted just-in-time, scoped, time-boxed, and fully recorded, then automatically revoked.

Risk assessment asks what can go wrong, how likely it is, and how bad it would be, expressed as probabilities rather than worst-case assertions.

The family of splitting methods that approximate e^(-iHt) as ordered products of simple exponentials, from Trotter to randomized variants.

Product-of-sums expresses a function as an AND of OR terms, read from the truth-table rows that output 0.

PSPACE is the class of problems solvable using a polynomial amount of memory, regardless of how much time they take.

A queue is a first-in-first-out container with constant-time enqueue and dequeue, the natural structure for fair, in-order processing.

Rainbow combines six independent improvements to DQN and shows they are largely complementary.

Computers produce reproducible pseudo-random sequences from a seed, which makes stochastic methods both random enough and repeatable.

A random variable is a function that assigns a number to each outcome, turning events into arithmetic.

Randomized benchmarking estimates average gate error from how quickly random gate sequences decay, cleanly separating gate error from readout error.

Rate-monotonic scheduling assigns higher priority to faster tasks; it is optimal among fixed-priority policies and comes with a simple sufficiency test.

Two ways to make an image: shoot rays from the eye into the scene, or project geometry onto the screen and fill it in.

A section along the burner's long axis shows the confine-then-convert chain from central cell to direct converter.

A practical guide to reading any Master Blueprint diagram: check the layer, the color, the line, and the termination — in that order.

REBCO conductor is a thin layered tape: a superconducting film on a metal substrate, protected by silver and copper.

A finite-horizon planner can be unstable unless a terminal cost and terminal set are chosen correctly; this is what makes MPC provably safe to run in a loop.

A technique where a function solves a problem by calling itself on smaller instances.

Recursion solves a problem by having a function call itself on smaller instances until it reaches a base case.

Completeness identifies the hardest problems in a class as those to which every member reduces, capturing the essence of the class.

A reduction transforms one problem into another so that solving the second solves the first, transferring difficulty between them.

How multiple channels combine into one trustworthy decision, and why more channels is not always safer.

Estimating how long a component will keep working, with honest uncertainty, so maintenance lands before failure not after.

A runbook records exactly how to reproduce a result, from environment to inputs to commands, so anyone can regenerate it later.

Pinning the exact software environment lets a computation be rerun elsewhere and later with the same result.

Resilience is the ability to keep operating through failures and attacks; redundancy, done well, is one way to achieve it.

The plant is designed to recover to a known-good state from signed artifacts and verified backups, so an incident ends in restoration rather than uncertainty.

Rice's theorem shows that every non-trivial question about what a program computes is undecidable.

A ripple-carry adder chains full adders so each carry-out feeds the next stage, giving simple hardware but delay that grows with word width.

RMSNorm normalizes activations by their root-mean-square alone, dropping the mean-centering of layer normalization for a cheaper, equally effective operation.

The root locus traces how closed-loop poles move through the s-plane as a single gain is varied from zero to infinity.

A deterministic rules engine enforces hard operational bounds independently of the ML stack; it can only ever forbid, never command.

Run-length encoding compresses runs of a repeated value into a single value and a count.

A family of methods for accurately integrating ordinary differential equations step by step.

The classic fourth-order Runge-Kutta method combines four slope evaluations per step for high accuracy without needing derivatives of f.

A parametric ZX-interaction gate, the ideal operation realized by the cross-resonance drive and a flexible pulse-efficient primitive.

Long machine procedures cannot hold a single lock; sagas break them into steps each paired with a compensating action that undoes it safely.

A sample space lists every possible outcome of an experiment; an event is any subset of those outcomes.

Reduce a multi-objective problem to a single objective by combining goals, then vary the combination to trace the Pareto front.

Verifying each stage of startup against a trusted anchor ensures a device runs only genuine, unaltered software from the moment it powers on.

Semi-Lagrangian methods advect quantities by tracing characteristics backward from fixed grid points, avoiding the explicit CFL time-step limit.

Sensitivity analysis ranks which inputs actually move the outcome, so effort and measurement go where they change the answer.

SHAP attributes a prediction to its features using Shapley values, a fair-division rule from cooperative game theory.

Shock-capturing schemes compute discontinuous solutions of conservation laws automatically, without tracking discontinuity locations explicitly.

The breeder shot lifecycle is a strict state machine where each phase has entry guards, exit conditions, and its own safe-abort path.

An ancient method that finds all primes up to n by iteratively marking multiples of each prime as composite.

Signed integers represent both positive and negative whole numbers, most often using two's complement.

Solve linear programs by walking from vertex to adjacent vertex of the feasible polyhedron, improving the objective at each pivot.

Simulation and experiment are complementary sources of truth; each checks and extends the reach of the other.

Variance-based measures that apportion the output variance among the inputs and their interactions, the standard global sensitivity tool.

Scientific software that drives real decisions must be built with the rigor of any other load-bearing engineering.

An SBOM is a complete inventory of the components in a piece of software, the prerequisite for knowing whether you are exposed to a given flaw.

Guarantees that any discrete universal gate set fills the unitary group efficiently, with only polylogarithmic overhead.

L7 links predicted degradation to spare inventory and long-lead manufacturing so the right component is staged before a unit needs it, fleet-wide.

Matrices dominated by zeros, stored and solved with methods that touch only the nonzeros.

A precomputed table that answers idempotent range queries such as minimum in constant time on a static array.

A system is stable if bounded inputs produce bounded outputs; for LTI systems this reduces to all poles lying in the left half-plane.

Two ordered collections defined by their access discipline: last-in-first-out and first-in-first-out.

A stack is a last-in-first-out container with constant-time push and pop, the natural structure for nested and reversible work.

Standardizing to a z-score puts any normal variable on a common scale with mean zero and unit variance.

A representation of a dynamic system by a set of state variables evolving through first-order equations.

Steady-state error is the residual tracking error after transients settle, set by the number of integrators in the open loop.

A stochastic process is a collection of random variables indexed by time, describing how randomness evolves.

A strongly connected component is a maximal set of vertices where every vertex can reach every other; they are found in linear time.

Subset simulation estimates rare failure probabilities as a product of larger conditional probabilities reached through intermediate thresholds.

Subsets closed under addition and scaling; the natural stage for column spaces, null spaces, and projections.

SOR accelerates Gauss-Seidel by over-correcting each update with a relaxation factor, dramatically speeding convergence when the factor is tuned well.

The smallest deterministic automaton recognizing every substring of a string, built online in linear time.

Sum-of-products expresses a function as an OR of AND terms, read directly from the rows of a truth table that output 1.

Learned super-resolution reconstructs fine-scale simulation detail from a coarse field, mimicking a high-resolution run at lower cost.

Rather than attacking a target directly, adversaries compromise a trusted supplier whose product the target already installs and trusts.

Synchronization coordinates concurrent execution through locks, atomics, and barriers, trading some serialization for correctness.

The theory that lets Kronos trust MPC over a finite horizon to keep the machine safe indefinitely: a terminal safe set and a terminal cost.

A structured record of independent analyses, each reproducible from inputs to result, forms the evidence base behind the Kronos design.

One architecture, eight layers, wired end-to-end into two fusion machines — the breeder (Hyperion) and the burner (Aegis / MetroVolt).

Bracket a root between a sign change and halve the interval until it is pinned down - slow but guaranteed.

Bisection halves a sign-changing interval at every step, giving guaranteed but linear convergence to a root of a continuous function.

Bracket a root, halve the interval repeatedly, and converge to a solution with guaranteed but linear reliability.

The Church-Turing thesis claims that any function computable by any effective procedure is computable by a Turing machine.

Convolution slides a learnable kernel over an input, computing dot products that measure how strongly a local pattern is present at each position.

The Cook-Levin theorem proves that Boolean satisfiability is NP-complete, giving the first natural NP-complete problem.

Bringing a dilution refrigerator from room temperature to base takes a day or more, proceeding through precooling, condensing, and circulation phases.

A reason-act-observe loop with an explicit step budget and replanning, driving bounded tool calls toward a grounded, cited answer.

Crank-Nicolson averages explicit and implicit evaluations to reach second-order accuracy in time with unconditional linear stability.

A single number that measures how a linear map scales volume and whether it is invertible.

Simulation produces knowledge only under conditions; understanding those conditions is what separates a result from a rendered picture.

Finite differences approximate derivatives by ratios of function values on a grid, turning differential equations into algebraic systems.

Finite elements represent the solution as a sum of local basis functions and enforce the equation in a weighted-average (weak) sense.

Galerkin methods choose test functions from the same space as the trial functions, making the residual orthogonal to that space.

The electron momentum balance that connects electric field, current, and the two-fluid and Hall terms.

A declarative boundary that lets Kronos workloads target profiles, not machines, so the same job reproduces on cloud or bare-metal.

The architecture states plainly what is designed, what is simulated, and what is not yet proven — no capability is claimed ahead of the physics or the schedule.

LQR is the unconstrained closed-form limit of MPC; its Riccati solution is the baseline gain and the terminal cost that makes MPC provably stable.

The 8-layer stack, the color grammar and line semantics, and how one architecture runs both machines.

The master theorem gives the running time of many divide-and-conquer recurrences by comparing the recursion's work to its combine step.

The Morris method screens many inputs with few runs, flagging which are negligible, which are linear, and which are nonlinear or interacting.

The square symmetric system A^T A x = A^T b that characterizes the least-squares solution.

Closed-loop stability follows from counting how many times the open-loop Nyquist curve encircles the critical point minus one.

P versus NP asks whether every problem whose solution can be checked quickly can also be solved quickly.

The partial trace discards a subsystem to yield the correct local description of the part you keep.

Particle-in-cell methods track sample particles moving through continuous fields defined on a grid, coupling kinetic motion to field solves.

A petabyte-scale archive retains raw and reduced telemetry at high fidelity, so any shot on either machine can be re-examined byte-for-byte.

The X basis {|+>, |->} is the diagonal basis conjugate to the computational basis, essential for reading out phase information.

V&V is organized around the specific output a decision depends on; error and uncertainty are measured for that quantity, not in general.

Many published computational results cannot be reproduced; understanding why points to the practices that prevent it.

Shared reference problems let different methods be compared on equal terms, but only for the narrow thing the benchmark measures.

Routh-Hurwitz decides stability from the characteristic polynomial's coefficients alone, without computing any roots.

The Rx(theta) gate is a continuous X-axis rotation - the tunable knob a drive pulse physically implements in the circuits Kronos runs.

A widely used analytic fit for the neoclassical bootstrap current valid across collisionality regimes.

Turn a two-point boundary-value problem into a root-finding problem on the unknown initial slope.

The small-gain theorem guarantees closed-loop stability when the product of the gains of two interconnected systems is less than one.

The structured singular value mu measures exactly how much structured uncertainty a system can tolerate before losing stability.

The cylindrical local stability condition against pressure-driven interchange in a screw pinch.

The trapezoidal rule approximates an integral by straight-line segments between samples, with error that falls as the square of the panel width.

Estimate an integral by summing trapezoids under the curve, and understand its second-order error and one surprising strength.

A Turing machine is an abstract device with an infinite tape and a finite rulebook that defines the mathematical limit of what is computable.

Complex systems are validated bottom-up: unit-physics, then subsystems, then the full system, because the whole is rarely testable directly.

The z-transform maps discrete-time sequences to functions of a complex variable, turning difference equations into algebra.

Designing a cryostat means tallying every heat source at every stage and ensuring each stays within the cooling power available there.

Laser Thomson scattering gives the fabric local electron temperature and density along a line of sight, the backbone of the core pressure map.

Threads share one address space within a process; processes have separate memory. The distinction shapes communication, isolation, and cost.

Pure time delays add frequency-dependent phase lag that limits achievable bandwidth and can destabilize otherwise sound loops.

High-resolution schemes that guarantee no new oscillations by ensuring the solution's total variation never increases.

TVD schemes guarantee that the total variation of the solution does not increase, preventing the growth of spurious oscillations.

State changes and their emitted events are committed in one local transaction, so a crash never leaves the two inconsistent.

A transfer function maps scalar values to color and opacity; it decides what becomes visible inside a volume and what fades away.

Rise time, overshoot, and settling time quantify how a system responds to a step, translating design goals into measurable targets.

A translation lookaside buffer caches recent virtual-to-physical address translations so the processor avoids walking page tables on every access.

A tri-state buffer passes its input when enabled and presents a high-impedance open circuit when disabled, letting many drivers share one wire.

Where product-formula error comes from, how it depends on commutators, and how to bound it rigorously.

A truth table lists every possible input combination and the output the circuit produces, defining a Boolean function exactly.

The standard way to represent signed integers in binary so that addition works uniformly.

Two's complement is the standard way to store signed integers, giving one zero and uniform arithmetic.

Two's complement lets one adder handle signed and unsigned numbers, which is why nearly all digital hardware represents signed integers this way.

A single-parameter diagonal gate that phases the one-state, implementable as a zero-cost virtual frame change.

The union-find structure tracks a partition into disjoint sets, answering connectivity queries in near-constant amortized time.

A near-constant-time structure that maintains a partition of elements into disjoint sets, supporting merge and same-set queries.

A universal gate can build any Boolean function on its own; NAND and NOR each have this property.

A quantitative measure of the discrepancy between simulation and experiment, accounting for uncertainty on both sides.

Variance measures how far a random variable spreads around its mean; the standard deviation restores the original units.

Sobol indices decompose output variance into contributions from each input and their interactions, giving a rigorous global sensitivity ranking.

A result you cannot reproduce is a rumor; verification and reproducibility turn computation into evidence.

Formal standards codify V&V terminology and procedures so that credibility claims mean the same thing across organizations.

Verification asks whether the equations are solved correctly; validation asks whether the right equations were chosen for reality.

Verification asks whether the equations are solved right, validation whether the right equations were solved, and UQ bounds the remaining confidence.

The continuous cycle of finding, assessing, prioritizing, and remediating weaknesses before attackers exploit them.

The liveness layer that detects a silent, hung, or dead component and forces a safe action before the plant notices.

Consumers reason about event time, not arrival time, and use watermarks to know when a time window is safe to close.

Strong scaling fixes the problem size and adds processors; weak scaling grows the problem with the processors, and each answers a different question.

High-order finite-difference schemes for hyperbolic conservation laws that capture shocks sharply without spurious oscillations.

Computation is the mechanical transformation of input symbols into output symbols by following a fixed, finite set of rules.

A single view of how computation runs through every phase of the Kronos program, from first design sweep to plant operation.

Shot and experiment procedures run as durable, resumable state machines that survive process restarts without losing their place.

L1 certifies every critical path by its provable worst-case execution time, computed from fabric structure rather than measured averages.

Every reflex-path stage carries a statically provable upper bound on execution time; the loop is only certified when their sum fits the deadline with margin.

The XNOR gate outputs 1 when its inputs are equal; it is the complement of XOR and acts as an equality detector.

The Ziegler-Nichols rules give quick starting PID gains from a single closed-loop or open-loop experiment on the plant.