Machine learning & surrogates

Condition a Gaussian process on three observations and compute the predictive mean and variance at a new input by hand.

Classify with Bayes' rule under a strong independence assumption, worked on a small spam-style example.

The nonlinear function applied at each neuron that lets networks represent nonlinear relationships.

Activation functions inject the nonlinearity that gives deep networks their expressive power, and their shape controls how gradients flow.

Active learning lets a model choose which unlabeled examples to have labeled, spending scarce annotation where it helps most.

Kronos targets its expensive offline solves where the surrogates are weakest, and retrains them as the design evolves and, later, as the plant reveals new data.

Active learning turns model uncertainty into experiment proposals, so scarce machine time is spent where new data most improves the models that run the machines.

Active learning chooses which expensive simulations or discharges to run next, extracting the most information per costly evaluation.

Spending a limited simulation budget on the points that most improve a model or answer a question.

Active learning chooses which unlabeled examples to annotate next so a model reaches target accuracy with far fewer labels.

Active learning chooses where to run an expensive simulation next, so a surrogate improves fastest with the fewest costly evaluations.

Letting a model choose its own next training example so it learns the most from the fewest expensive runs.

Actor-critic methods pair a policy that acts with a value estimator that critiques, combining low-variance updates with direct policy optimization.

Adadelta extends Adagrad with a decaying gradient average and a matching decaying average of updates, removing the need to choose a global learning rate.

Adapt a per-parameter learning rate by dividing by the accumulated history of squared gradients, favoring rarely updated directions.

Adagrad gives each parameter its own learning rate, shrinking it in proportion to the accumulated size of that parameter's past gradients.

Combine momentum and per-parameter adaptive scaling with bias correction: the default optimizer for training deep neural networks.

Adam with decoupled weight decay: apply regularization directly to the parameters instead of folding it into the adaptive gradient.

AdamW fixes how Adam applies weight decay, decoupling it from the adaptive gradient scaling to make regularization behave as intended.

Adaptive sampling adds training points sequentially where a surrogate is weakest, balancing exploration of unseen regions against refinement of complex ones.

Active learning chooses the next expensive evaluation where it most improves the surrogate, building accurate models from few runs.

Additive forecasters model a series as an interpretable sum of trend, seasonal, and holiday components with uncertainty.

Learned components are hardened against crafted inputs, and physics-based sanity bounds ensure a fooled model still cannot request an unsafe action.

Every copilot action is a typed, bounded tool call — read, simulate, or propose — with no tool that writes directly to the plant.

The fabric's output is a pristine, structured, quality-tagged feature set — the clean interface every L3 model and copilot is built on.

Aleatoric uncertainty is inherent randomness you cannot reduce; epistemic uncertainty is ignorance you can reduce with more data or better models.

ALS fits matrix-factorization models by alternately solving closed-form least-squares problems for each factor.

Anomaly detection flags rare, unexpected observations, usually with few or no labeled examples of the anomalies.

Continuous monitoring learns the plant's normal network and process behavior so deviations - a new flow, an odd command pattern - are flagged for response.

High-authority actions require multiple qualified approvers; policy defines who counts, how many, and what happens on timeout.

Concise definitions of the terms used across the AI-native architecture — layers, colors, lines, mechanisms, and machine physics.

ARIMA forecasts a series by combining autoregression, differencing for trend, and a moving average of past errors.

Using visual, auditory, and spatial cues in a disciplined budget so the machine can grab an operator's attention exactly when — and only when — it should.

Augmenting a neural ODE with extra state dimensions removes a fundamental expressiveness limit caused by trajectories that cannot cross.

A neural network trained to reconstruct its input through a compressed bottleneck, learning efficient representations.

Autoencoders learn compact representations by training a network to reconstruct its own input through a narrow bottleneck.

AutoML automates the pipeline of feature processing, model selection, and tuning to build models with less manual effort.

Autoregressive co-kriging couples Gaussian processes across fidelity levels so a few accurate runs correct many cheap ones.

Autoregressive models factor the probability of a sequence into a product of conditional next-token probabilities, the foundation of generative text models.

Simulating component failures and repairs to produce the honest 0.86-0.995 availability envelope against the 0.99982 Tier III target.

The algorithm that computes a neural network's loss gradients efficiently by applying the chain rule backward through layers.

Compute the forward pass and every gradient of a two-layer network on one example, entirely by hand.

Derive and code the gradients of a small neural network by applying the chain rule backward from the loss.

BPTT trains recurrent networks by unrolling the loop over time and applying the chain rule across every step.

Copies of data and a plan to restore service are the last line of defense against loss from failure, disaster, or ransomware.

Bagging trains models on bootstrap resamples and averages them, cutting variance without raising bias.

Bandit optimization chooses actions to minimize loss when only the chosen action's outcome is observed, forcing a trade-off between exploration and exploitation.

Batch normalization standardizes layer activations across a mini-batch, stabilizing and accelerating the training of deep networks.

The scheduled L0 loop that re-grounds every twin surrogate against fresh pulse histories so the real-time shadow does not drift.

Baum-Welch learns HMM transition and emission parameters from unlabeled sequences by expectation-maximization.

Choosing which experiment or simulation to run next so that its result is expected to reduce uncertainty the most.

Bayesian filtering is the common framework behind Kalman, ensemble, and particle methods: recursively updating a belief with each observation.

Bayesian inference treats unknown parameters as random and updates a prior into a posterior using observed data.

Bayes' rule is how the stack turns diagnostics and priors into calibrated posteriors, the basis of every uncertainty estimate the twin reports.

Bayesian calibration infers uncertain model parameters from data, yielding posterior distributions rather than single best-fit values.

Bayesian neural networks treat weights as distributions rather than fixed values, yielding predictions with principled uncertainty.

Plan the fewest, most-informative pulses to validate — accelerate commissioning.

BERT pretrains a bidirectional transformer encoder by predicting masked words, producing representations that read context from both directions.

BERT is a bidirectional transformer encoder pretrained by predicting randomly masked tokens, producing context-rich representations for classification and extraction tasks.

The tension between a model too simple to fit the pattern and one so flexible it fits the noise.

Boosting turns weak learners into a strong one by training them in sequence, each focusing on the previous errors.

Bootstrap-current models predict the self-generated plasma current that arises from the pressure gradient, a key term in current-profile and scenario codes.

The braking radiation emitted when electrons are deflected by ions, an unavoidable energy loss from any plasma.

Calibration tunes a model's fixed parameters so its predictions match data, turning a generic model into a twin of one specific unit.

A model is calibrated when its stated probabilities match observed frequencies; miscalibration makes uncertainty estimates untrustworthy.

Making predicted probabilities and uncertainties mean what they say, so decisions can rely on them.

A well-calibrated model's stated probabilities match observed frequencies, so a ninety percent interval really contains the truth ninety percent of the time.

Capsule networks represent entities as vectors whose length encodes presence and whose orientation encodes properties, aiming to preserve part-whole spatial relationships.

Predict interventions correctly, not just correlations.

The right surrogate depends on dimensionality, data budget, smoothness, output type, and whether you need calibrated uncertainty.

How documents are split and embedded so retrieval returns coherent, citable units without fragmenting equations, tables, or procedure steps.

Model changes flow through automated pipelines that build, test, validate, and stage artifacts — the same rigor as software delivery, adapted to models and machines.

Some quantum machine learning methods can be matched by classical algorithms, so a proposed advantage only holds if no efficient classical method exists.

Classification predicts a discrete label for each input, from spam-or-not to many mutually exclusive categories.

CLIP trains an image encoder and a text encoder together so that matching image-caption pairs land nearby in a shared embedding space.

Clustering groups unlabeled points by similarity; the method and distance you pick define what a cluster even means.

Grouping discharges or time slices into regimes without labels, to organize data and reveal structure.

The covariance matrix adaptation evolution strategy samples candidates from a Gaussian and reshapes that Gaussian toward better regions, needing no gradients.

Co-kriging fuses a primary variable with correlated secondary data or a lower-fidelity model to sharpen predictions and their uncertainty.

Where a PINN enforces its physics residual determines its accuracy; Kronos samples collocation points adaptively around steep gradients like the plasma edge.

Viewing Hyperion and the burner side by side shows how differently two fusion machines can be built for different jobs.

Every component carries measurements and design parameters drawn from the frozen canon, readable directly in the model.

How L0 packs Monte Carlo, coupled solves, and GPU training onto a shared pool without starving the reproducible core.

Using sensor data and models to forecast when a component will need service, so maintenance is scheduled by condition rather than by calendar.

Activated components must be maintained without direct human access, so remote handling relies on simulation, planning, and precise models.

Decompose the variance of a model output among its inputs to rank which parameters actually drive uncertainty.

Concept-drift monitors detect when the relationship a model learned between inputs and outputs stops holding, even if the inputs themselves look familiar.

The condition number, the ratio of largest to smallest curvature, predicts how slowly gradient methods converge and why preconditioning helps.

CRFs are discriminative models for structured prediction that score whole label sequences given the full input.

For any estimate an operator can see how sure the model is, which model produced it, on what data, and which live diagnostics currently constrain it.

Distribution-free, finite-sample coverage guarantees on every model prediction.

Conformal prediction wraps any model in prediction intervals with a guaranteed coverage rate, without assuming a data distribution.

A table of predicted versus actual classes that breaks down a classifier's correct and incorrect calls.

Solve a symmetric positive-definite linear system with conjugate gradient and watch it converge in at most n steps.

A conjugate prior keeps the posterior in the same family as the prior, making Bayesian updates a closed-form calculation.

These networks are built so their predictions satisfy conservation laws exactly, rather than only approximately through a penalty.

Contour lines connect points of equal value, showing a 2D scalar field's levels, gradients, and structure with precision.

Contrastive learning trains representations by pulling similar examples together and pushing dissimilar ones apart, often without labels.

Metric learning trains embeddings so that distance reflects semantic similarity, using contrastive objectives that attract similar items and repel dissimilar ones.

Building models simple and fast enough for control yet faithful to the dynamics that matter - a different craft from physics modeling.

Convolutional neural networks analyze camera and imaging-diagnostic data to detect events, track structures, and infer plasma conditions.

A neural network that shares small learnable filters across an input to detect local patterns efficiently.

CNNs exploit the spatial structure of images by sharing small filters across a grid, learning local patterns that compose into global understanding.

How the toroidal frame of the breeder and the axial frame of the burner are set up so measurements are unambiguous.

Core-edge coupling joins a core transport model to a separate edge and scrape-off-layer model so the boundary condition on the core is computed, not guessed.

In quantum machine learning the loss is built from expectation values of observables, and its structure decides both what is learned and whether training is possible.

A plant twin is a federation of coupled physics models that must exchange boundary information consistently without instability.

Cross-attention lets one sequence attend to another, the bridge that connects an encoder's representation to a decoder's generation.

Because the GNN is permutation-equivariant and topology-driven, embeddings pretrained on legacy device data transfer to both Kronos machines.

Why models trained on one tokamak degrade on another, and how transfer learning helps.

Cross-validation reuses scarce data by rotating holdout folds, estimating a surrogate's out-of-sample error without new expensive runs.

The cryogenic system keeps the REBCO magnets cold enough to stay superconducting despite nuclear and ambient heat loads.

Intrinsic rewards drive exploration when the environment's own reward is sparse or absent.

Curriculum learning orders training examples from easy to hard, mirroring how humans learn structured material.

Radiation emitted by electrons gyrating in the magnetic field, a loss that grows with field and temperature.

DAgger fixes behavior cloning's drift by querying the expert on the states the learner itself visits.

Data augmentation expands a training set by applying label-preserving transformations, improving generalization and robustness.

Labeling data by sensitivity so that protection, access, and handling rules match the value and risk of each kind of information.

Compression shrinks data by removing redundancy, split into lossless and lossy families.

Data labeling attaches ground-truth annotations to raw examples so supervised models have targets to learn from and to be evaluated against.

Data are records of what happened; models are compressed theories of why; neither replaces the other and confusing them causes error.

First-principles models start from physical law; data-driven models start from observations. The best systems combine both.

Every sample and feature carries a quality score summarizing noise, validation, imputation, and drift, so downstream models weight it correctly.

A model that predicts by following a sequence of feature-based yes/no splits from a root to a leaf.

DDPG is an off-policy actor-critic method for continuous control, learning a deterministic policy alongside a Q-function critic.

Deep ensembles quantify uncertainty by training several networks independently and measuring how much their predictions disagree.

Training several neural networks from different random initializations and combining their predictions gives a simple, strong estimate of model uncertainty.

Deep kernel learning composes a neural feature extractor with a Gaussian-process kernel, giving calibrated uncertainty on top of learned representations -- powerful, but with real

Machine learning with many-layered neural networks that learn hierarchical features directly from raw data.

DQN scales Q-learning to high-dimensional inputs using a neural network, experience replay, and a slowly updated target network.

Neural networks learn complex, high-dimensional input-output maps from simulation data, serving as fast surrogates where classical methods struggle.

DeepONet learns an operator by combining a branch network that encodes the input function with a trunk network that encodes the query point.

DenseNet connects each layer to every earlier layer by concatenation, maximizing feature reuse and gradient flow with few parameters.

DenseNet connects every layer to all later layers by concatenation, maximizing feature reuse and gradient flow with few parameters.

Derivative-based global sensitivity measures average squared gradients over the input distribution, cheaply bounding Sobol total effects.

Descriptor systems mix differential and algebraic equations, capturing constraints and interconnections that ordinary state-space models cannot.

Design of experiments chooses where to sample an expensive model so a surrogate learns the most from the fewest runs.

A validation experiment is built to test a model, which means measuring the inputs the model needs as carefully as the outputs.

Degradation — a slow decline in a deployed model's accuracy or calibration — is caught by tracking performance against delayed ground truth and independent references.

Kronos separates the provably-timed control plane from the data-driven models above it, so intelligence can improve without ever endangering the deadline.

When control spans multiple nodes, the network must deliver messages with bounded latency and jitter, which ordinary best-effort networking cannot guarantee.

DDPG learns a deterministic continuous-control policy off-policy, using a critic's action gradient to improve the actor.

How Kronos manages random-number seeds so stochastic Monte Carlo and training runs remain exactly reproducible.

Embedding shots and diagnostic windows into vectors lets the fabric find physically similar situations by nearest-neighbor search.

Differentiable physics embeds known physical laws as differentiable program components so learning and simulation share one gradient path.

A differentiable simulator computes gradients of its outputs with respect to its inputs, enabling gradient-based design, control, and learning.

A generative model that learns to reverse a gradual noising process, turning noise into realistic samples.

Diffusion models generate data by learning to reverse a gradual noising process, denoising random noise step by step into a sample.

A continuously updated virtual model of a physical system, used for analysis, monitoring, and prediction.

A living computational model of a specific machine, kept in step with its real counterpart to predict, diagnose, and plan.

One twin is not enough; a family of models at different fidelities lets each task use the cheapest model that is accurate enough.

Reducing inputs or outputs to their essential few directions makes high-dimensional surrogate modeling tractable and more accurate.

Direct energy conversion (DEC) extracts electricity straight from the kinetic energy of charged fusion products, with no thermal cycle -- the power-extraction path modeled in the b

Coordinating many networked computers, each with its own memory, to work on a common task.

How Kronos splits large model training across many GPUs with data, tensor, and pipeline parallelism without losing reproducibility.

In distributed-memory systems each process owns private memory, and processes cooperate by exchanging explicit messages over a network.

Divertor modeling predicts the concentrated heat and particle loads on exhaust targets and the mitigation needed to keep them within material limits.

Randomizing simulator parameters during training forces policies robust enough to treat reality as one more variation.

The max in Q-learning systematically overestimates values; double Q-learning corrects it by decoupling action selection from evaluation.

Covariate-shift monitors watch the input distributions feeding every deployed model and raise a retraining flag when the live data drifts away from the training set.

Dropout randomly disables neurons during training, forcing the network to build redundant, robust features and reducing overfitting.

When the environment model is known, dynamic programming solves an MDP exactly by iterating the Bellman equations over all states.

A learned mapping of discrete items into a continuous vector space where geometry encodes meaning.

Storing embeddings well means choosing how to persist dense vectors, keep them synchronized with their source records, and rebuild indexes as data changes.

An embedding maps discrete items into a continuous vector space where geometric closeness reflects semantic similarity.

Simulation models how a system behaves from its inner mechanisms; emulation reproduces the input-output behavior without the mechanism.

Interpreting subsystem telemetry against design limits, physics models, and history to answer 'is this subsystem healthy and why'.

Combining multiple models so their collective prediction beats any single one.

Ensembles combine many models so their errors cancel, usually beating any single model through bagging, boosting, or stacking.

Combining several models to improve accuracy and, importantly, to estimate uncertainty.

Aleatoric uncertainty is irreducible randomness in the system; epistemic uncertainty is reducible ignorance about the model, and the two demand different responses.

The three units that describe how much data a training run has processed.

Equation discovery infers the governing laws of a system directly from data, aiming for compact, physically meaningful models.

Symmetry is a modeling asset; building permutation, and where relevant geometric, symmetry into GNNs cuts data needs and enables breeder-to-burner transfer.

Equivariant networks are built so that transforming the input, by rotation or reflection, transforms the output the same way, encoding symmetry.

A prediction without an error bar hides how much to trust it; sound surrogates report calibrated uncertainty alongside every value.

Every prompt, model, retrieval, or tool change runs the full evaluation suite; a safety regression on any case blocks the release.

An expectation suite is a versioned, executable collection of assertions about a dataset that produces a readable pass or fail report each run.

EM iteratively fits models with latent variables by alternating a soft-assignment step with a maximum-likelihood update.

Every training run, sweep, and evaluation is logged with its config, metrics, and artifacts, so the history of how a model came to be is fully queryable.

The decisive test of a model is comparison to measurement, with quantified uncertainty on both the simulation and the experiment.

Being able to say why a model produced an output is what lets humans check it, debug it, and decide whether to act on it.

Beyond random actions, deep RL uses intrinsic curiosity, count bonuses, and posterior sampling to explore hard, sparse-reward tasks.

An agent must balance exploiting what it knows to gain reward now against exploring the unknown to find something better.

Fusion dynamics are nonlinear; the EKF linearizes the model while the UKF propagates sample points, giving the twin nonlinear state estimation.

Fairness in ML studies how models can encode or amplify social bias, and the trade-offs among competing fairness definitions.

Transforming raw data into informative inputs that make a learning problem easier to solve.

Feature scaling puts numeric features on a comparable range so distance- and gradient-based models are not skewed by units.

A shared feature store guarantees that the features a model saw in training are the exact features it sees in production, eliminating training-serving skew.

A feature store is a shared registry that computes, stores, and serves the engineered inputs a model consumes during training and inference.

Each unit learns from the whole fleet without centralizing raw data.

Federated learning trains a shared model across many devices or sites without moving their raw data to a central server.

How pink feedback closes the learning loop: anomalies and drift trigger batch retraining at L0, and validated models return to the twin.

Reordering orbitals with fermionic swap gates so that all interaction terms become local, taming Jordan-Wigner string overhead on limited-connectivity hardware.

Continuing training of a pretrained model on a smaller, task-specific dataset to specialize it.

Fine-tuning adapts a pretrained encoder to a specific task by attaching a small head and continuing training with a low learning rate on labeled data.

A model of computation with a finite set of states and rules for transitioning between them on inputs.

Firewalls enforce which network traffic may cross a boundary, the workhorse control for segmentation and perimeter defense.

Interpolate noisy data with a Gaussian process that returns not just predictions but calibrated uncertainty.

Flash attention computes exact attention faster by tiling the calculation to keep intermediate results in fast on-chip memory, never materializing the full score matrix.

How multiple units and shared learning lift facility-level availability toward - though not to single-unit Tier III - the honest target.

When several units share a model backbone, experience on one improves the models for all, so later units start smarter than earlier ones.

Validated models learned on one unit propagate to others under governance, so each new breeder or burner starts from the accumulated experience of the fleet.

As breeder units progress FOAK to NOAK to BOAK, models and lessons propagate across the fleet through the registry, with per-unit validation before any shared model acts.

Remaining-useful-life models trained across the whole fleet predict component degradation earlier and more sharply than any single unit's history allows.

Flux limiters blend high- and low-order schemes locally to keep sharp gradients monotone without spurious oscillations.

The foundational augmenting-path scheme for computing maximum flow in a capacitated network.

Foundation models are large networks pretrained on broad data that adapt to many downstream tasks, a shift from task-specific to general-purpose AI.

Large models pretrained on broad plasma data aim to transfer across tasks and devices with limited task-specific labels.

As fixed-frequency qubits multiply, their transition frequencies crowd together, causing addressing errors and constraining chip design.

A 3D model shows what a Kronos machine looks like; the digital twin adds the physics that makes it behave, turning geometry into a predictive model.

GAIL imitates an expert by matching state-action distributions through an adversarial game, skipping explicit reward recovery.

The systematic row-reduction procedure that solves linear systems and reveals rank and invertibility.

A Gaussian mixture models data as a weighted sum of several Gaussian components, giving soft, probabilistic clustering.

The kernel of a Gaussian process encodes assumptions about smoothness, scale, and structure, and choosing it is the main modeling decision.

A Gaussian process places a distribution over functions, giving predictions with calibrated uncertainty that grows away from the data.

Gaussian processes are surrogates that return both a prediction and a calibrated uncertainty, ideal where data is scarce and honesty matters.

A Gaussian process is a distribution over functions; it gives the stack calibrated surrogates with built-in error bars, ideal for scarce fusion data.

A flexible regression method that reports calibrated uncertainty, well suited to small, expensive datasets.

The kernel encodes every assumption a Gaussian process makes about smoothness, scale, and structure, and choosing it well is the modeling task.

Gaussian processes fit smooth plasma profiles from scattered measurements while returning principled uncertainty and gradient estimates.

Smooth, self-gated activations that behave like ReLU for large inputs but curve gently near zero, now standard in transformers and modern vision models.

Nearly every RL algorithm is a case of two processes — value estimation and policy improvement — pushing toward mutual consistency.

Two networks trained against each other: a generator that fakes data and a discriminator that detects fakes.

GANs pit a generator against a discriminator in a game, training the generator to produce data realistic enough to fool its critic.

Models that learn to produce new plasma-like data, for scenario design, augmentation, and exploration.

Genetic programming evolves a population of expression trees through selection, crossover, and mutation to discover fitting formulas.

Seek the best solution over an entire landscape of many local minima, where gradient methods alone are not enough.

Training graph neural networks over the diagnostic constellation so the twin can impute dropped signals and detect anomalies.

A single goal-conditioned policy learns to reach any goal, turning many tasks into one parameterized problem.

Decoder-only transformers predict the next token given all previous ones, a simple objective that scales into general-purpose language models.

An ensemble method that builds trees sequentially, each correcting the residual errors of the ensemble so far.

An optimization method that iteratively steps parameters in the direction that most reduces a loss.

Minimize a simple quadratic to build intuition for step size, convergence rate, and why conditioning matters.

When gradients are available, gradient-enhanced kriging uses them as extra training data to build accurate surrogates from fewer function evaluations.

Graph attention networks weight each neighbor by a learned relevance score, letting a node listen more to some neighbors than others.

GNNs extend deep learning to graph-structured data by learning node representations from the pattern of connections around each node.

The diagnostic constellation and the coupled subsystems are graphs; message passing is the mathematics that lets a network reason over their topology.

Every supervised result rests on labels assumed to be true; when that assumption is shaky, so is everything built on it.

Group normalization splits channels into groups and normalizes within each group per sample, giving batch-independent normalization for vision models.

The slow, systematic motions of a gyrating particle's center caused by fields, gradients, and curvature.

Class imbalance arises when one class dominates; naive training then ignores the rare class that usually matters most.

The precursor that the anomaly ensemble raises must become an action the MPC agent takes; Kronos defines that handoff precisely and safely.

Kronos bakes boundary conditions into the network architecture so they hold exactly, improving conditioning over soft-penalty PINNs.

When observation noise varies across input space, the surrogate must model an input-dependent noise level rather than a single constant.

A model of sequences generated by hidden states that transition over time and emit observable outputs.

An HMM models a sequence of observations generated by a hidden state that evolves as a Markov chain.

Hierarchical models calibrate across multiple experiments or units by sharing information through population-level priors.

Hierarchical RL decomposes long tasks into reusable sub-behaviors, letting a high-level policy select among temporally extended options.

Options are temporally extended actions that let an agent plan over skills rather than primitive steps.

Highway networks use learned gates to control how much of each layer's input passes through unchanged versus transformed, an early route to training very deep networks.

HER turns failures into learning by relabeling trajectories with the goals that were actually achieved.

Kronos combines the graph network's diagnostic reasoning with the physics network's equation-solving so measurement and physics constrain one solution.

Hybrid models combine a trusted physical model with a learned component that corrects its errors or supplies its missing pieces.

The central solenoid sits on the machine axis and drives plasma current inductively, acting as the primary of a transformer.

A hypernetwork is a network that generates the weights of another network, letting one model produce parameters adapted to a context or task.

A configuration value set before training that governs how a model learns, not learned from the data itself.

Parallel search over model architectures and training settings that tunes Kronos PINNs, GNNs, and surrogates at scale.

Hyperparameters set before training, learning rate, depth, regularization, are searched to find the best model configuration.

When one class is rare, standard training and accuracy fail; resampling, reweighting, and better metrics restore balance.

Imitation learning trains a policy to mimic expert demonstrations, bypassing reward design when good examples are available.

Behavior cloning turns imitation into supervised learning: predict the expert's action from the state.

Every anomaly becomes a labeled learning example: the postmortem produces corrected labels and a retraining mandate, so the fleet gets safer after each event.

The design assumes a privileged insider may turn malicious or be coerced, and limits what any single trusted person can do without a second party detecting or blocking it.

Systems that watch network traffic and host activity for signs of attack, so a breach is noticed rather than discovered months later.

Infer unknown model inputs from observed outputs, a task that is often ill-posed and sensitive to noise.

Inverse problems infer hidden parameters or fields from indirect measurements, and machine learning provides fast, regularized estimators.

Inverse RL recovers the reward function that best explains observed expert behavior, then optimizes it.

Inverse RL infers the reward function that best explains observed expert behavior, rather than optimizing a given reward.

Paul traps confine ions with oscillating fields; scaling them means shuttling ions between zones or networking many small traps.

k-NN classifies or predicts a point by looking at its k closest training examples, storing all data and computing at query time.

Kelley's method minimizes a convex function by building a lower model from its supporting linear pieces and minimizing that model each round.

The Kennedy-O'Hagan framework calibrates a computer model while explicitly modeling the systematic discrepancy between the model and reality.

Distillation trains a small student model to mimic a large teacher, transferring its behavior into a cheaper package.

Kriging is Gaussian process interpolation developed in geostatistics, predicting a spatial field with a best linear unbiased estimator.

How Kronos applies AI, machine learning, and quantum computing to fusion — an 8-layer architecture (L0 Foundation → L7 Ecosystem) wired into both machines: the breeder (Hyperion) a

Cloud HPC, bare metal, and supercomputing — the offline multi-physics and batch-training substrate.

Layer 3 is where Kronos turns validated telemetry into predictive physics: GNNs, PINNs, anomaly ensembles, MPC agents, and the KRONOS-CTRL digital twin.

GNNs, PINNs, anomaly ensembles, and MPC agents running over the KRONOS-CTRL digital twin and its 50-100 ms predictive shadow.

Agentic Plasma, Engineering, and Operations copilots.

Labels are versioned artifacts with recorded source and confidence, because a mislabeled disruption or off-normal event teaches a safety model exactly the wrong lesson.

Lagrangian neural networks learn a system's Lagrangian, deriving physically consistent dynamics even in arbitrary or constrained coordinates.

LAMB rescales each layer's update to match the norm of its weights, enabling stable training at very large batch sizes.

The Laplace approximation fits a Gaussian to the posterior around a trained network's weights using the loss curvature, adding uncertainty after the fact.

A transformer trained on vast text to predict the next token, gaining broad language and reasoning ability.

Lasso regression adds an L1 penalty to least squares, driving weights to zero so it selects features while it fits.

Latent-space dynamics models evolve a compressed representation forward in time, giving fast surrogates for high-dimensional simulations.

Layer normalization standardizes across features within a single example, making it independent of batch size and ideal for transformers.

Learning curves plot error against training-set size or training progress, diagnosing whether more data or a better model helps.

Gaussian process hyperparameters are set by maximizing the marginal likelihood, which balances data fit against model complexity automatically.

A learning-rate schedule changes the step size over training, typically warming up then decaying, to balance fast early progress against stable final convergence.

Learning-rate-free methods aim to match a well-tuned step size automatically, removing the most fragile hyperparameter of gradient-based optimization.

Least squares chooses model parameters that minimize the total squared gap between predictions and observations.

Leave-one-out cross-validation estimates a surrogate's predictive error by testing on each training point held out in turn.

LIME explains one prediction by fitting a simple, interpretable model to the black box behavior nearby.

A candid summary of what machine learning can and cannot do for fusion, and the standards that keep it useful.

Linear attention replaces the softmax with a kernel feature map, reordering the computation so cost grows linearly rather than quadratically with sequence length.

Linear regression fits a straight-line relationship between predictors and a response by minimizing squared error.

Fit a line to data by solving a small linear system, and understand why the QR route is numerically safer.

Every component in the model connects to an explanatory page here, so geometry and explanation form one reference.

Lion updates each weight by the sign of a momentum-smoothed gradient, using less memory than Adam while remaining competitive on large models.

Logistic regression models the probability of a binary outcome as a smooth function of predictors.

Fit a logistic classifier to a small separable dataset with batch gradient descent and read the learned decision boundary.

LSTM cells add a gated memory pathway that lets recurrent networks carry information across hundreds of steps without vanishing gradients.

The scalar objective a model minimizes, quantifying how far predictions are from targets.

A loss function scores how wrong a prediction is; minimizing it over the data is what training actually optimizes.

The geometry of a model's loss surface, its valleys, barriers, and flatness, shapes how training proceeds and how well the result generalizes.

Compression shrinks the archive without discarding physics, using lossless coding where forensics demand it and bounded-loss only where theory permits.

Lossless compression restores data exactly; lossy compression trades fidelity for much smaller size.

Lossy compression achieves large size reductions by discarding information judged unimportant, trading exactness for compactness.

A family of methods that fit models to data so they generalize to unseen inputs, rather than following hand-written rules.

Machine learning fits models to data so they can make predictions on inputs they have not seen, guided by measured error.

How data-driven models complement physics simulation across control, prediction, reconstruction, and design in magnetic-confinement fusion.

Data-driven models predict how neutron irradiation and thermal cycling degrade fusion materials, guiding material choice and component lifetime estimates.

Models predict steady-state or evolving temperature, density, and current profiles from engineering settings, accelerating scenario studies.

Learned surrogates approximate particle- and radiation-transport codes, speeding shielding design and dose estimation across many configurations.

Mamba makes state-space model parameters depend on the input, giving content-aware selectivity with linear-time sequence processing and no attention matrix.

Each component is tagged with its material class, so the model shows not just where a part is but what it must be made of.

Every AI layer running Hyperion and Aegis/MetroVolt rests on a small set of equations: equilibrium PDEs, MHD eigenproblems, Bayesian inference, and constrained optimization.

The duality result stating that the maximum s-t flow equals the minimum-capacity s-t cut in any network.

Maximum likelihood picks the parameter values that make the observed data most probable under the model.

Point-to-point, radial, and layer-thickness measurement tools let you read true dimensions directly off the geometry.

A memory consistency model defines the order in which one core's memory operations become visible to others in a shared-memory system.

Memory-augmented networks pair a controller with an external, addressable memory it can read from and write to, separating computation from storage.

Message passing is the unifying recipe of graph neural networks: gather from neighbors, aggregate symmetrically, then update each node.

The message-passing framework describes most graph neural networks as three steps: compute messages on edges, aggregate them at nodes, and update node states.

Meta-RL learns how to learn, producing agents that adapt to a new task within a handful of episodes.

Metric learning trains an embedding where distance reflects semantic similarity, enabling retrieval and verification.

The middle ground between full-batch and single-sample updates: average gradients over a small batch for stable, hardware-friendly steps.

Mixed-integer programming combines continuous and integer variables, letting a single model capture both discrete decisions and continuous quantities.

Mixture-of-experts models route each input to a few specialized subnetworks, growing total capacity while keeping per-input computation low.

A mixture of experts routes each input to a few specialized subnetworks out of many, growing total capacity while keeping per-input computation low.

Classifiers label the plasma regime in real time, distinguishing confinement modes and operational phases to inform control decisions.

Models that inform control are treated as security-critical artifacts: their training data, weights, and lineage are protected against poisoning and silent substitution.

Machine learning shortens the loop between running an experiment, understanding it, and choosing the next one.

Neural models infer electron temperature and density from Thomson scattering spectra faster and more robustly than fitting each spectrum by hand.

Using machine learning to rank candidate materials against many coupled requirements before slow, costly testing.

Offline retraining, twin refinement, drift detection, and reinforcement learning from human feedback.

Tuning uncertain model parameters to match data, a legitimate step that becomes self-deception when confused with validation.

Calibration tunes a model's uncertain parameters so its predictions match observations, without overfitting to noise.

A short structured record of what a model is for, how it was built, and where it fails makes responsible use possible.

The discrepancy function represents the systematic gap between a calibrated model and reality, distinct from random noise and parameter error.

The model shows what is designed and computed, states clearly that the machines are unbuilt, and flags the gates that remain.

Interpretability methods explain why a model made a prediction, supporting trust, debugging, and accountability.

Pruning removes redundant weights or structures from a trained network to make it smaller and faster.

A model registry is the system of record for trained models, tracking versions, stages, and metadata so deployment is controlled and auditable.

The registry is the single source of truth for every model: its version, lineage, validation status, and a promotion state that governs whether it may act on a machine.

No single algorithm wins everywhere; model selection compares candidates fairly to find the best fit for a given problem.

Choosing among candidate models means balancing fit against complexity and, above all, estimating how each will perform on unseen cases.

Each model release is a versioned snapshot tied to a frozen design state, so any component can be cited unambiguously.

Model-based RL learns a model of the environment's dynamics and uses it to plan or generate simulated experience.

Dyna blends real experience with simulated experience from a learned model to accelerate value learning.

The uncertainty from the model itself being an approximation, often the largest and hardest-to-quantify error source.

MPC plans a short action sequence with a model, executes one step, then replans, and pairs naturally with learned models.

Model-predictive control repeatedly plans a short future using a model, applies the first step, then re-plans as new data arrives.

The burner captures charged-particle energy directly instead of only as heat; modeling that conversion is central to its design.

Accumulate a velocity vector from past gradients to accelerate along consistent directions and damp oscillations across valleys.

The tandem-mirror burner is confined by its end plugs; Kronos's MPC agent regulates plug density to hold the ambipolar potential that traps the central cell.

The reliability and repair statistics that feed every availability model, and how spares provisioning cuts effective repair time.

Consensus protocols drive a network of agents to agree on a common value using only communication with neighbors.

The Plasma, Engineering, and Operations copilots collaborate through L4 with clear ownership, shared grounding, and a single human authority.

When many learning agents share an environment, each faces a moving target: the others are learning too.

When several learning agents share an environment, each faces a moving target as the others adapt, reshaping the learning problem.

The bandit is RL stripped to one decision: choose among actions with unknown payoffs to maximize total reward.

Bandit algorithms balance exploring uncertain options against exploiting the best-known one to maximize cumulative reward.

The multi-armed bandit is the simplest reinforcement learning problem, isolating exploration versus exploitation with no state transitions.

Multi-fidelity methods combine many cheap approximate runs with a few expensive accurate ones to build an accurate model efficiently.

Combine cheap and expensive simulations for calibrated, affordable accuracy.

Multi-fidelity methods combine many cheap approximate runs with few expensive accurate ones to build a surrogate at high-fidelity accuracy for less effort.

Multi-fidelity methods fuse many cheap, approximate model evaluations with a few expensive, accurate ones to build a surrogate that is both fast and trustworthy.

Running several attention operations in parallel lets a model attend to different kinds of relationships at once, then combine them.

Multi-query attention shares a single set of keys and values across all attention heads, shrinking the memory needed to cache them during generation.

Multi-task learning trains one model on several related tasks so shared structure improves all of them.

Multiclass classification assigns one of several mutually exclusive labels, using softmax or by decomposing into binary problems.

Stacking layers of neurons with nonlinear activations turns a linear classifier into a universal function approximator.

Multimodal models combine signals from different modalities at different depths, trading simplicity against the richness of cross-modal interaction.

Phenomena spanning atoms to devices cannot be captured at one resolution; multiscale modeling links models across scales that no single method reaches.

MuZero plans with a learned model of dynamics in a latent space, so it needs no access to the true game rules.

A fast probabilistic classifier that assumes features are conditionally independent given the class.

The natural gradient rescales the ordinary gradient by the Fisher information matrix, following the steepest descent direction in distribution space.

A momentum variant that evaluates the gradient at a look-ahead point, achieving the optimal first-order convergence rate for smooth convex problems.

Dividing a network into isolated zones limits how far an intruder can move, and an air gap is the strongest form of that isolation.

Topology is the arrangement of links between nodes; it determines message hop counts, bisection bandwidth, and how a cluster scales.

Networked control systems close feedback loops over shared communication networks, contending with delay, packet loss, jitter, and limited bandwidth.

Neural architecture search automates designing network structures, searching over layers and connections for the best design.

Neural closures learn the unresolved subgrid terms of a coarse simulation, letting a cheap grid approximate expensive high-resolution physics.

A model of layered, weighted connections between simple units that together approximate complex functions.

Choosing recurrent, convolutional, attention, or graph models to match plasma data structure.

The building blocks of the models used across fusion ML, from layers to training.

Neural networks approximate expensive physics across large, high-dimensional datasets, trading interpretability for speed and scale.

Neural networks compose many simple weighted units into flexible function approximators trained by gradient descent.

Neural operators learn mappings between function spaces, so one trained model can solve a whole family of PDEs at any resolution.

Neural operators learn mappings between function spaces, so one trained model solves a family of PDEs at any resolution.

Fast PDE surrogates across the whole parameter space, more general than a single PINN.

Neural operators learn the mapping from parameters to entire physical fields, giving Kronos fast, resolution-flexible surrogates for transport and thermal solves.

Neural operators learn mappings between function spaces, so one trained model returns a whole equilibrium or field for a new profile, not a single point solution.

Neural ODEs treat a network's depth as continuous time, defining the transformation as the solution of a differential equation parameterized by a neural network.

A Neural Turing Machine couples a neural controller to a differentiable memory using content and location-based addressing, learning simple algorithms end to end.

Neural networks learn to solve the Grad-Shafranov equation orders of magnitude faster than iterative solvers, enabling near-instant magnetohydrodynamic equilibrium estimates.

When the relationship between fidelity levels is nonlinear, a deep-structured Gaussian process learns the mapping instead of assuming a constant scaling.

Normalizing flows build generative models from invertible transformations, giving exact likelihoods where VAEs and GANs give only approximations.

The high-throughput, high-latency connections that move petabytes to the compute substrate for multi-physics runs and model retraining.

Offline RL learns policies entirely from a fixed dataset of logged experience, without any further interaction with the environment.

L0 is where every model is retrained: a slow, expansive, reproducible compute substrate that regenerates ground truth before any artifact is compiled toward the machine.

CQL learns from a fixed dataset by pushing down Q-values on unseen actions, preventing overestimation of out-of-distribution behavior.

IQL learns entirely within the dataset by never evaluating actions it has not seen, using expectile regression on the value function.

A power delivery network distributes stable supply voltage across a chip despite rapidly changing current demand from switching logic.

On-policy methods learn about the policy they follow; off-policy methods learn about one policy from data generated by another.

Fit a shallow tree to the residuals of a constant predictor and watch a single boosting round shrink the loss.

A feature must compute identically live and from the archive; the fabric enforces this parity so models behave the same in training and operation.

Recognizing when a model is being asked about inputs unlike anything it was trained on.

When a model fits the training data's noise and fails to generalize to new data.

A model that memorizes its training data fails on new data; the goal is to capture the signal without fitting the noise.

Why models memorize small fusion datasets, and the techniques that make them generalize.

When the agent cannot observe the full state, it must act on incomplete information and maintain beliefs about what it cannot see.

Patch embedding turns a 2D image into a token sequence with one strided convolution, and position embeddings restore the spatial layout the transformer would otherwise ignore.

Center a small dataset, compute its covariance eigenvectors, and project onto the leading principal component.

Permutation importance ranks features by how much a model performance drops when a feature values are shuffled.

The complete, replayable archive of every pulse and simulation campaign that grounds retraining, refinement, and audit.

PETS captures model uncertainty with an ensemble of probabilistic networks and plans with sampling-based model-predictive control.

A twin can be first-principles physics, machine-learned surrogates, or a hybrid - and Kronos uses fast learned models inside a physics-consistent frame.

Embedding conservation laws and known limits into transport models keeps predictions physically valid and improves extrapolation beyond the training data.

Physics-informed neural networks solve the Grad-Shafranov equilibrium equation by minimizing the PDE residual directly, needing few or no labeled solutions.

A neural network trained to satisfy governing physical equations, not just fit data.

Neural networks trained to respect governing equations, improving data efficiency and extrapolation.

A PINN trains a neural network to satisfy a differential equation by penalizing the equation's residual at sampled points inside the domain.

A PINN represents a field as a neural network and trains it to satisfy a PDE via automatic differentiation, turning solving into optimization.

Tuning sets the three PID gains to balance speed, overshoot, and disturbance rejection, by rule, by model, or by iterative adjustment.

Pink blocks close the loop — anomaly alerts, drift detection, and the retraining signals that keep the twin honest as the machines evolve.

PINNs fail in characteristic ways - spectral bias and unbalanced gradients; the neural-tangent-kernel view explains why and guides fixes.

The PINN objective is a weighted sum of residual, boundary, initial, and data losses evaluated at sampled collocation points.

A PINN's loss sums PDE residual, boundary, and data terms; how those terms are weighted decides whether training converges to the physical solution.

Physics-informed networks fail in characteristic ways: stiff gradients, spectral bias, and imbalanced loss terms that stall optimization.

Training physics-informed neural networks that solve Grad-Shafranov and MHD residuals natively for fast twin evaluation.

The tandem-mirror burner is confined by an electrostatic potential; Kronos solves that ambipolar potential with a physics-informed network.

Pointer networks use attention as the output itself, selecting positions in the input sequence rather than tokens from a fixed vocabulary.

A policy is the agent's behavior: a rule, deterministic or stochastic, that maps states to actions.

A reinforcement learning approach that optimizes a parameterized policy directly by gradient ascent on expected reward.

Policy iteration alternates full policy evaluation with greedy improvement, converging to an optimal policy in a finite number of steps.

Because attention ignores order, transformers add positional encodings so the model knows where each token sits in the sequence.

Two complementary metrics capturing how accurate a classifier's positive calls are and how many positives it finds.

A twin forecasts when components will need attention by tracking their real accumulated stress, replacing fixed schedules with condition-based action.

Skew — any difference between how a feature or model behaves in training versus production — is treated as a defect and caught by contract tests before deployment.

PCA finds orthogonal directions of maximum variance, giving a linear projection that compresses data with minimal loss.

Replay transitions in proportion to how surprising they are, so the agent learns fastest from its biggest errors.

A calibrated model outputs probabilities that match observed frequencies, so a 0.7 prediction is right about 70 percent of the time.

Take a gradient step, then project back onto the feasible set, a simple and effective method for constrained problems with easy projections.

POD extracts an optimal low-dimensional basis from simulation snapshots, enabling reduced-order models that run far faster than the full system.

Proximal gradient descent minimizes a smooth term plus a nonsmooth term by taking a gradient step, then a proximal step.

Split a smooth loss from a nonsmooth regularizer: gradient-step the smooth part, then apply the proximal operator of the rest.

PPO improves policies with a clipped objective that permits several update steps per batch while preventing destructively large policy changes.

The model shows a full public teaser with real geometry and physics, and reveals deeper internal detail to signed-in users.

The plant network is layered into Purdue levels 0 to 5 with a hardened level 3.5 DMZ, so a breach at one level cannot traverse directly to the physics.

A model-free reinforcement learning method that learns the value of actions to derive an optimal policy.

Q-learning is an off-policy temporal-difference method that learns the optimal action-value function regardless of how the agent explores.

Neural networks trained on quasilinear gyrokinetic flux databases predict turbulent transport in milliseconds, replacing runtime calls to slow physics codes.

QR-DQN represents the return distribution by learned quantile locations, removing C51's fixed value grid.

Quantile regression predicts conditional quantiles directly, capturing the shape of the output distribution without assuming it is Gaussian.

Quantum neural networks are parameterized quantum circuits trained like neural networks, borrowing the layered structure and gradient-based optimization of deep learning.

Approximate the Hessian from successive gradients, capturing curvature without ever computing second derivatives.

Radial basis function interpolants build a surrogate from weighted bumps centered on training points, giving smooth fits with simple linear algebra.

Evaluate a classifier honestly with counts of the four outcome types and the threshold-sweep ROC curve.

A twin must revise not only its state but its own parameters as the real machine drifts, wears, and reveals mismodeled physics.

Hardware never matches the drawing exactly; measuring the real machine and updating the models keeps the digital twin honest.

Recurrent neural networks model the temporal dynamics of plasma signals for forecasting, event detection, and control.

A neural network with feedback connections that maintains state to process sequences of varying length.

RNNs process sequences one step at a time, carrying a hidden state that acts as memory of everything seen so far.

Reduced-order models compress a high-fidelity simulation into a much smaller one that keeps the behavior that matters.

Reduced-order models compress a high-dimensional simulation into a few coordinates whose dynamics are cheap to evolve.

Regime monitors detect when the machine crosses into a plasma operating regime outside a model's validated envelope and gate that model accordingly.

Statistical modeling of the relationship between a dependent variable and one or more predictors.

Fitting continuous relationships from data, from linear models to flexible learners, with fusion examples.

Regression metrics such as MSE, MAE, and R-squared quantify how far continuous predictions fall from the truth.

Automated tests that catch when a change silently breaks something that used to work, the immune system of a long-lived code.

Regret measures how much worse a sequence of decisions did than the best fixed choice in hindsight; minimizing it is the goal of online learning.

Techniques that constrain a model's complexity to improve generalization and reduce overfitting.

REINFORCE is the simplest policy-gradient algorithm, updating policy parameters using Monte Carlo returns as the action weight.

Learning a policy that maximizes cumulative reward by interacting with an environment through trial and error.

RLHF trains a reward model from human preference comparisons, then optimizes a policy against it.

The core concepts of learning to act, framed for readers who will meet RL in plasma control.

Recorded machine inputs are replayed against new procedure, twin, or policy versions to test changes safely before they touch hardware.

The discipline that lets any Kronos simulation or training result be re-derived exactly, because the machines are still numerical.

A reproducible dataset can be regenerated exactly from its recorded inputs, code, and environment, or independently verified against a stated tolerance.

Every training run is deterministic and re-executable: pin the data, seed, code, and container, and two runs produce the same model — reproducibility is a hard gate.

A residual connection adds a layer's input to its output, letting networks learn refinements to the identity and making very deep stacks trainable.

How the Kronos AI stack keeps the breeder (Hyperion) and burner (Aegis / MetroVolt) running safely when components, sensors, or models fail.

Residual connections let a layer learn a correction to its input rather than a full transformation, making very deep networks trainable.

Retrieval-augmented generation fetches relevant documents from an external store and conditions a generative model on them, grounding outputs in retrievable knowledge.

The return is the cumulative reward an agent seeks to maximize; the discount factor sets how much future reward counts against the present.

Agents optimize the reward you write, not the goal you meant; the gap between them is reward hacking.

A reward model is a learned proxy for what we want, standing in for a true objective that is hard to specify.

The reward model that RLHF optimizes against is itself a versioned, validated artifact — miscalibrated reward is a hazard, so it passes its own gates.

Reward shaping adds guidance signals to speed learning, but only potential-based shaping is guaranteed to be safe.

Reward shaping adds guidance signals to sparse rewards to speed learning, but poorly designed shaping can change what the agent learns.

Ridge regression adds an L2 penalty to least squares, shrinking weights to reduce variance and tame correlated features.

RLHF learns a reward model from human preference judgments, then optimizes a policy against it to align behavior with human intent.

Fix AdaGrad's vanishing step size by scaling gradients with an exponentially decaying average of their recent magnitudes.

RMSprop adapts per-parameter learning rates using an exponentially decaying average of squared gradients, curing Adagrad's vanishing step size.

RMSprop scales each parameter's step by a running average of its squared gradients, adapting the learning rate per parameter to handle varying gradient magnitudes.

The path from today's three-dimensional model to an operational twin at first-of-a-kind runs through simulation, hardware-in-the-loop, and commissioning.

A curve and a summary number describing a classifier's performance across all decision thresholds.

Every deployed model has a certified predecessor and a physics-based safe state it can fall to within a bounded time, so a bad model is always reversible.

Rotary position embeddings encode position by rotating query and key vectors, so attention depends on the relative distance between tokens.

In high-dimensional nonconvex problems, saddle points, not local minima, are the main obstacle to gradient-based training.

Safe RL maximizes reward subject to constraints, so the agent respects safety limits during and after learning.

Safe RL seeks policies that respect constraints and avoid harmful behavior during both learning and deployment.

Saliency maps highlight which parts of an input a neural network relied on, usually via gradients of the output.

SARSA is an on-policy temporal-difference control method that learns the value of the policy it actually follows, including its exploration.

Scientific machine learning fuses data-driven models with the governing equations, symmetries, and constraints of physical systems.

Decomposition splits a time series into trend, seasonal, and remainder parts to reveal and model each separately.

Self-attention lets every position in a sequence attend to every other, building context-aware representations in a single parallel operation.

In self-play an agent improves by competing against copies of itself, generating an ever-stronger curriculum.

Self-supervised learning creates its own labels from unlabeled data by hiding part of the input and predicting it.

Semi-supervised learning combines a small labeled set with a large unlabeled one to train better than labels alone allow.

Which inputs actually move the answer? Sensitivity analysis ranks them, focusing measurement and modeling effort where it matters.

A structured, replayable handover so an incoming crew inherits the machine's full state, open issues, and recent history without loss.

Siamese networks run two inputs through identical weight-sharing towers and compare their embeddings to judge similarity.

The classic S-shaped activations squash inputs into bounded ranges; still useful at outputs and gates, but prone to vanishing gradients in deep hidden layers.

Why a policy or model trained in simulation may fail on hardware, and how to narrow the gap.

Policies trained in simulation must bridge the reality gap to work on physical systems, using randomization and robust training.

When a model can simulate data but not write down a likelihood, simulation-based inference recovers the parameters that explain observations.

SAC maximizes reward plus policy entropy, giving a stable, sample-efficient, exploration-friendly control algorithm.

SAC is an off-policy actor-critic that maximizes reward plus policy entropy, yielding robust exploration and strong continuous control.

Shannon's source coding theorem sets entropy as the hard floor on lossless compression.

Sparse attention restricts each token to attend to a chosen subset of positions, cutting the quadratic cost of full attention while preserving important connections.

Sparse Gaussian processes summarize a large dataset with a small set of inducing points, cutting the cubic cost of exact inference.

SINDy discovers governing equations by selecting a few active terms from a large library of candidate functions using sparse regression.

Spiking neural networks communicate with discrete timed events rather than continuous values, modeling neurons that integrate inputs and fire when a threshold is crossed.

Dimensional modeling organizes analytical data into fact tables of measurements surrounded by dimension tables of descriptive context.

An observer reconstructs unmeasured states by running a model of the plant corrected by the difference between predicted and actual outputs.

State-space models describe a system by first-order equations in a state vector, handling multivariable and nonlinear dynamics naturally.

The three raw ingredients of any reinforcement learning problem: what the agent sees, what it can do, and how it is scored.

Find the root or minimizer of a function observed only through noisy measurements, the theoretical basis of stochastic gradient methods.

Stochastic collocation propagates uncertainty by running the model at a structured set of sample points and interpolating the response.

A scalable form of gradient descent that updates parameters from small random batches of data.

The parallel storage systems that hold petabyte pulse histories and feed high-bandwidth reads to Monte Carlo and training jobs.

A disciplined topic taxonomy separates measurements, state, proposals, commands, and audit so each gets the right retention and access policy.

Structured state-space models represent a sequence layer as a linear dynamical system, computed as a long convolution to capture very long-range dependencies efficiently.

Subgradient methods minimize nondifferentiable convex functions by stepping along any subgradient, using a diminishing step size for convergence.

Optimize nondifferentiable convex functions by stepping along any subgradient, trading speed for the ability to handle kinks.

Successor representations factor value into expected future state occupancy times reward, enabling fast transfer.

Learning a function from input-output pairs so it predicts correct outputs for new inputs.

A classifier that finds the boundary with the widest margin between classes, extended to nonlinear cases with kernels.

Surrogate gradients let spiking networks train with backpropagation by replacing the non-differentiable spike function's derivative with a smooth stand-in.

A fast approximation trained to mimic an expensive simulation or experiment.

A surrogate is a fast approximation of an expensive simulation, trained on solver outputs to enable many-query design and analysis.

A surrogate model is a fast approximation of a slow simulation, trained to reproduce its outputs across a design space.

A fast approximation trained on a slow model lets you explore vast design spaces, as long as you respect where it was trained.

Surrogate models approximate expensive physics codes with fast learned functions, enabling real-time control, large scans, and optimization at reduced fidelity.

Fast approximations of slow simulations that let engineers explore, optimize, and quantify uncertainty at scale.

Learned stand-ins for turbulent transport calculations that make integrated modeling and control feasible.

Emulating gyrokinetic turbulence results, the most expensive step in transport modeling, with learned models.

Surrogates are fast approximations of expensive physics codes, letting a twin run inside real-time and assimilation loops.

A fast approximation trained on a few expensive runs stands in for the real code, making thousands of UQ evaluations feasible.

Surrogate models approximate expensive physics codes with fast statistical or machine-learned functions, enabling scans that would otherwise be infeasible.

MPC needs to roll the plant model forward many times per cycle, so Kronos uses fast differentiable surrogates as the prediction model.

Fast approximations that stand in for expensive simulations, and the rules for using them without fooling yourself.

Twin surrogates are retrained on a governed cadence — scheduled, drift-triggered, and regime-triggered — so acceleration never comes at the cost of stale physics.

Surrogate acceleration blends fast approximations with occasional full-physics runs, keeping a twin both quick and trustworthy.

When each objective evaluation is expensive, a surrogate guides the search, spending real evaluations only where they most improve the design.

Replace an expensive objective with a cheap approximate model, optimize on the surrogate, and validate with occasional true evaluations.

Replacing an expensive limit-state function with an adaptively refined surrogate makes rare-failure probability estimation affordable.

A surrogate is a fast learned stand-in for a slow simulation, making optimization and uncertainty analysis affordable at scale.

Fusion design leans on expensive multiphysics codes; surrogates make the scans, optimization, and uncertainty studies those designs require affordable.

Symbolic regression searches the space of mathematical expressions for a compact formula that fits data and can be read and interpreted.

System identification builds mathematical models of dynamic systems from measured input-output data rather than first principles.

TD(lambda) blends one-step temporal-difference learning and Monte Carlo returns using eligibility traces to assign credit over multiple steps.

Temperature scaling recalibrates a neural network confidence with a single learned parameter, without changing predictions.

Temporal convolutional networks model sequences with stacked dilated causal convolutions, offering a parallel alternative to recurrent networks for time-series tasks.

Temporal-difference learning updates value estimates from one step of experience by bootstrapping off its own next estimate.

Tensor cores are hardware units that multiply small matrices in one operation, delivering most of an accelerator's throughput on deep learning.

Tensor-network methods are the classical benchmark quantum simulation must beat; they already solve many correlated-electron problems Kronos cares about.

Tensor-network decoders approximate the true maximum-likelihood correction by contracting a network that sums over all error configurations.

The adjoint method computes the gradient of an objective with respect to many parameters at a cost independent of the number of parameters.

A technique to compute the gradient of a scalar objective with respect to many parameters at a cost independent of the parameter count.

The advantage function measures how much better an action is than the policy's average, sharpening the learning signal for policy gradients.

Every reinforcement learning problem is a cycle: observe a state, act, receive reward and next state, repeat.

Attention lets a model dynamically weight different parts of its input, focusing on what is relevant to each step of its output.

The honest availability finding: modelled ~0.86-0.995 against a Tier III target of 0.99982 - a 30-100x downtime shortfall stated as a physics-and-operations fact.

A self-generated toroidal current driven by the plasma pressure gradient through trapped-particle dynamics.

Seven colors classify every block in the blueprint by role — so a glance tells you whether you are looking at governance, infrastructure, or a thermal path.

A consistent naming and tagging scheme lets every part in both machines be selected, cited, and cross-referenced.

Solve a symmetric positive-definite system in at most n steps by searching along mutually conjugate directions.

The conjugate gradient method solves symmetric positive-definite systems efficiently using short recurrences and conjugate search directions.

Kronos closes a data-to-model loop that continually re-grounds every predictive object against new pulse evidence without ever letting the machine learn online.

When reward arrives long after the actions that earned it, the agent must figure out which decisions deserve credit or blame.

As input dimensions grow, volume explodes and samples spread thin, defeating grid methods and straining every surrogate and UQ technique.

Dephasing destroys phase coherence while preserving populations, the loss mechanism behind T2 and the classical limit.

The depolarizing channel replaces a state with the maximally mixed state at some rate, a symmetric and widely used noise model.

A parabolic partial differential equation describing how a conserved quantity spreads down its own gradient over time.

Every learning agent must balance taking known-good actions against gathering information about uncertain ones.

The HJB equation is the dynamic-programming condition for optimal control, defining the value function whose gradient yields the optimal feedback law.

Each phase produces data that improves the models used in the next, so knowledge compounds from design through build to operation.

The intelligence layer is the software and models that turn raw plant data into predictions, decisions, and design insight.

Kronos's interactive 3D model lets anyone explore its machines in the browser - rotate the geometry, open cutaways, run the real physics - and it is the foundation the digital twin

To track or reject a signal with zero error, a feedback loop must contain a model of that signal's generating dynamics.

A drift-type microinstability driven by steep ion temperature gradients, a leading cause of core heat loss.

A thin insulating barrier between two superconductors carries a lossless supercurrent set by phase difference, giving superconducting qubits their nonlinearity.

The 3D model is a versioned design and simulation record of two unbuilt machines, not a depiction of existing hardware.

The multi-armed bandit is the simplest model of learning by trial and error: repeatedly pull one of several arms with unknown reward, aiming to maximize total reward.

An advisory agent that generates runbooks and procedures, supports shift handoff, and assembles campaign context from the twin and the data fabric.

The parameter-shift rule computes exact gradients of a quantum circuit by evaluating the same circuit at two shifted parameter values.

The perceptron is the simplest trainable neuron: a weighted sum passed through a threshold, and the historical seed of neural networks.

Geometry in the model is tied to the frozen design parameters, so fields, currents, and dimensions read off the parts themselves.

How Kronos composes the physics residual, boundary conditions, and sparse measurements into a single differentiable loss for equilibrium and stability PINNs.

The policy gradient theorem gives the gradient of expected return with respect to policy parameters without differentiating the environment.

A framework that rates how mature a simulation capability is across several axes, rather than declaring it credible or not.

A shareable, interactive 3D machine model is a visualization: it makes a design legible to a broad audience while protecting sensitive detail.

A reference architecture that layers an industrial network into levels, from field devices up to enterprise IT, to structure segmentation.

The roofline model plots achievable performance against arithmetic intensity, showing whether a kernel is limited by compute or by memory bandwidth.

The roofline model plots achievable performance against arithmetic intensity to show whether a kernel is limited by compute or by memory bandwidth.

Turn logits into class probabilities and derive why the combined gradient collapses to predicted-minus-target.

The transformer builds sequence models entirely from attention and feedforward layers, enabling the parallel training that produced modern foundation models.

The interactive 3D model holds both Kronos designs, the Hyperion breeder and the tandem-mirror burner, as fully explorable geometry.

A structured enumeration of who might attack a Kronos plant, what they want, and how they could try - the basis every control in this section is measured against.

A structured way to find what can go wrong in a system before an attacker does, by reasoning about assets, entry points, and adversaries.

Methods for labeling multichannel, non-stationary plasma signals in real time and offline.

Time-series compression exploits the regularity of timestamped measurements to store them in a small fraction of their raw size, often losslessly.

Splitting text into the discrete units a language model reads and predicts.

Tokenization splits text into the units a model processes; subword schemes balance vocabulary size against the ability to represent any word.

Splitting data into training, validation, and test sets keeps model selection honest and the final estimate unbiased.

A quantum model is trainable only if its gradients stay measurable as it scales; local cost functions and structured ansatze are the main ways to keep them so.

Build and train a compact convolutional network to separate two synthetic image classes, and read the convergence from the loss curve.

Turning raw petabyte pulse histories and simulation campaigns into clean, labeled, versioned datasets fit to train twin models.

Transfer learning reuses knowledge from a model trained on a large dataset to solve a related task with far less data.

Models trained on existing fusion devices give Kronos machines a head start, provided the transfer respects where the physics differs.

Reusing knowledge from large or related datasets to help models learn from scarce fusion data.

A sequence architecture built on attention that processes all positions in parallel and scales to very large models.

Attention-based transformers model long-range dependencies in multi-channel plasma signals for prediction and representation learning.

Work a single self-attention head through query-key scores, softmax weights, and value mixing on three short tokens with tiny vectors.

Triplet networks learn embeddings from an anchor, a positive, and a negative example, enforcing that the anchor sits closer to the positive than to the negative.

TRPO improves a policy while limiting how far it moves, using a constraint on policy change to guarantee monotonic improvement.

Build a local model, trust it only within a region, and expand or shrink that region based on how well the model predicted reality.

GP hyperparameters - length scales, variance, and noise - are learned by maximizing the marginal likelihood, which balances fit against simplicity.

A model describes behavior, a simulation runs it forward, and a twin keeps a simulation locked to a real asset with live data.

The two-stage model makes a here-and-now decision, observes the random outcome, then takes a recourse action to correct for it, minimizing total expected cost.

UMAP is a fast nonlinear embedding that preserves local and some global structure, useful for both visualization and features.

Knowing how much to trust a model's prediction, and communicating that alongside the number.

A prediction without an honest error bar is only half a result; UQ is the discipline of attaching credible uncertainty to model outputs.

A surrogate must know when it does not know; Kronos equips every twin surrogate with calibrated uncertainty so control stays cautious where the model is weak.

Turning point predictions into honest ranges by tracking how input uncertainty and model error propagate to outputs.

Uncertainty quantification separates noise in the data from ignorance in the model, so predictions come with honest, actionable error bars.

Uncertainty quantification turns a single model prediction into a distribution, tracing how input, model, and data uncertainties shape the answer.

The model uses SI units throughout, with a persistent scale reference so components never lose their true size.

Finding structure such as clusters or low-dimensional representations in data that has no labels.

A surrogate is only trustworthy after validation against data it never saw, on metrics that expose both accuracy and honest uncertainty.

No model gains any authority without clearing a fixed sequence of gates — accuracy, calibration, safety-envelope, parity, and uncertainty — each of which can hard-block promotion.

Validation metrics quantify agreement between a model's predicted distribution and experimental data, going beyond a single error number.

A value function estimates expected future return, giving the agent a way to compare states and actions without simulating the full future.

Value iteration solves an MDP by repeatedly applying the Bellman optimality update to every state until the value function stops changing.

In deep and recurrent networks, gradients can shrink to nothing or blow up as they propagate, stalling or destabilizing training.

The failure of gradients to propagate through deep or recurrent networks, stalling learning in early layers.

Variational assimilation fits the model to a whole window of observations at once by minimizing a mismatch cost, complementing sequential filters.

Variational inference approximates an intractable weight posterior with a simpler distribution by maximizing a lower bound on the evidence.

Variational inference turns posterior estimation into optimization, giving the twin approximate uncertainty fast enough for near-real-time use.

Two distinct checks: that a model is solved correctly, and that it represents reality.

Verification asks whether you built the model right; validation asks whether you built the right model. Both are required.

Mechanical vibration from pulse-tube coolers must be isolated from cold stages, because motion in magnetic gradients injects noise into sensitive quantum devices.

The Vision Transformer applies the pure transformer to images by cutting them into patches and treating each patch as a token.

The Vision Transformer treats an image as a sequence of patches and applies a standard transformer encoder, showing convolution is not required for strong image models.

Virtual private networks create an encrypted tunnel across untrusted networks, extending a protected network to remote users and sites.

Immersive and augmented displays place data in spatial context, useful for training, maintenance planning, and layout review.

WaveNet generates raw audio one sample at a time using a deep stack of dilated causal convolutions with gated activations, modeling waveforms directly.

How a network's weights are set before training determines whether signals and gradients stay at a usable scale through many layers.

A surrogate is a cheap approximation of an expensive simulation or experiment, trained on samples so it predicts outputs in milliseconds.

Reinforcement learning trains an agent to choose actions that maximize cumulative reward through trial-and-error interaction with an environment.

Surrogates fail silently more often than loudly; knowing the failure modes and how to detect them is as important as building the model.

Trust in a model is earned per question, per regime, and per required accuracy, never granted to the model as a whole.

Word embeddings learn vector representations of words from co-occurrence in text, placing words with similar meanings near one another.

A minimal, honest sketch of training and evaluating a disruption predictor, emphasizing correct practice.

A world model learns to predict how an environment evolves, letting an agent train and plan inside its own simulation.

XGBoost is a fast, regularized gradient-boosting library that dominates tabular benchmarks through engineering and second-order optimization.

Yellow blocks are where learning and optimization live — training pipelines, surrogates, MPC, and the loops that make the plant intelligent.

A security model that never grants trust by network location, verifying every request explicitly regardless of where it originates.

The Kronos plant treats every network, device, and request as untrusted by default; access is earned per-request through identity, attestation, and policy, never by location.