$$
\newcommand{\AbsoluteConicImageEntry}{B}
\newcommand{\AbsoluteConicImageMatrix}{\mathbf{B}}
\newcommand{\AbsoluteConicVector}{\mathbf{b}}
\newcommand{\AcceleratedEpisodeTime}{T'}
\newcommand{\AcceleratedFractionSpeedup}{G}
\newcommand{\AccelerationNoiseDensityMatrix}{\mathbf{Q}_c}
\newcommand{\AccelerationNoiseSpectralDensity}{q_c}
\newcommand{\AccelerationWhiteNoise}{w}
\newcommand{\AcceleratorBatchTime}{T_{\text{GPU}}}
\newcommand{\AcceleratorConsumptionRate}{R_{\text{accel}}}
\newcommand{\AcceleratorCount}{N_{\text{GPU}}}
\newcommand{\AcceleratorDataConsumptionRate}{R_{\text{consumption}}}
\newcommand{\AcceleratorGain}{G_{\text{accel}}}
\newcommand{\AcceleratorHourlyPrice}{R_{\text{GPU/hr}}}
\newcommand{\AcceleratorMemoryBandwidth}{\text{BW}_{\text{accelerator}}}
\newcommand{\AcceleratorRailVoltage}{V_{\text{rail}}}
\newcommand{\AcceleratorSecondsPerQuery}{S_{\text{GPU/query}}}
\newcommand{\AcceleratorSupplyCurrent}{i}
\newcommand{\AcceleratorTargetQueryRate}{R_{\text{GPU,target}}}
\newcommand{\AcceleratorsPerNode}{G_{\text{node}}}
\newcommand{\AccelerometerBias}{b_a}
\newcommand{\AcceptanceFraction}{\alpha}
\newcommand{\AcceptanceIntervalLowerLimit}{L}
\newcommand{\AcceptanceIntervalUpperLimit}{U}
\newcommand{\AcceptanceProbability}{p_{\text{acc}}}
\newcommand{\AcceptedInfluences}{\text{Inf}}
\newcommand{\AcceptedInputSet}{\mathcal{A}_{\tau}}
\newcommand{\AcceptedLabelCount}{d}
\newcommand{\AcceptedOutcomePayoff}{V}
\newcommand{\AcceptedSampleCount}{X}
\newcommand{\AcceptedTaskMeanCost}{C_{\text{succ}}}
\newcommand{\AcceptedTasks}{N_{\text{acc}}}
\newcommand{\AcceptingStateSet}{F}
\newcommand{\AccessAttemptTime}{t}
\newcommand{\AccountQueryDistribution}{p_{\text{user}}}
\newcommand{\AccumulatedProcessNoiseCovariance}{\mathbf{Q}_d}
\newcommand{\AccumulatedSyncTime}{T_{\text{sync}}}
\newcommand{\AccumulatedUpdateTime}{T_{\text{effective}}}
\newcommand{\AccumulationStepCount}{k}
\newcommand{\AccuracyAfterDeployment}{\text{Accuracy}}
\newcommand{\AccuracyDecayRate}{\gamma}
\newcommand{\AccuracyPayoffPerQuery}{V}
\newcommand{\AchievedBrakingDeceleration}{a}
\newcommand{\AchievedKernelBandwidth}{\text{BW}_{\text{effective}}}
\newcommand{\AcquisitionEpoch}{t_{\text{acq}}}
\newcommand{\ActVariationalObjective}{\mathcal{L}_{\text{ACT}}}
\newcommand{\ActionBinCount}{B}
\newcommand{\ActionChunk}{\mathbf{A}}
\newcommand{\ActionChunkHorizon}{H}
\newcommand{\ActionChunkIndex}{k}
\newcommand{\ActionDimension}{d_a}
\newcommand{\ActionExecutionRate}{f_{\text{exec}}}
\newcommand{\ActionFilterCutoffFrequency}{f_{\text{cutoff}}}
\newcommand{\ActionLowerBound}{\mathbf{a}_{\min}}
\newcommand{\ActionMagnitudeBound}{a_{\max}}
\newcommand{\ActionRangeMaximum}{a_{\max}}
\newcommand{\ActionRangeMinimum}{a_{\min}}
\newcommand{\ActionRecoverableFraction}{\rho_{a}}
\newcommand{\ActionResidualVector}{\mathbf{r}}
\newcommand{\ActionSpace}{\mathcal{A}}
\newcommand{\ActionTokenPrefix}{a_{<j}}
\newcommand{\ActionUpperBound}{\mathbf{a}_{\max}}
\newcommand{\ActivationCheckpointCount}{n_{\text{ckpt}}}
\newcommand{\ActivationFunction}{f}
\newcommand{\ActivationInput}{x}
\newcommand{\ActivationLipschitzBound}{L_{\phi}}
\newcommand{\ActivationMatrix}{\mathbf{A}}
\newcommand{\ActivationMemory}{M_{\text{activations}}}
\newcommand{\ActivationPayloadSize}{M_{\text{act}}}
\newcommand{\ActivationStagingTime}{t_{\text{activate}}}
\newcommand{\ActivationVector}{\mathbf{a}}
\newcommand{\ActiveContactIndex}{k}
\newcommand{\ActiveControlTorque}{\mathbf{u}_{\text{active}}}
\newcommand{\ActiveInferencePower}{P_{\text{active}}}
\newcommand{\ActiveLeaseCount}{N_{\text{active}}}
\newcommand{\ActiveMotionDuration}{T_{\text{motion}}}
\newcommand{\ActiveParameterCount}{P_{\text{model}}}
\newcommand{\ActivePrefillRequestSet}{\mathcal{P}_{\text{active}}}
\newcommand{\ActiveSchemaSet}{\mathcal{S}}
\newcommand{\ActiveTargetTokenCount}{N_{\text{active}}}
\newcommand{\ActorAccelerationBound}{a_{k,\max}}
\newcommand{\ActorBodyRadius}{r}
\newcommand{\ActorUpdateDelayCount}{d}
\newcommand{\ActuatedJointAccelerations}{\ddot{\mathbf{q}}_j}
\newcommand{\ActuatedJointBiasForces}{\mathbf{h}_j}
\newcommand{\ActuatedJointCoordinates}{\mathbf{q}_j}
\newcommand{\ActuationSelectionBaseBlock}{\mathbf{S}_b}
\newcommand{\ActuationSelectionMatrix}{\mathbf{S}}
\newcommand{\ActuatorAxisCount}{N_{\text{axes}}}
\newcommand{\ActuatorBiasEffort}{u_{\text{bias}}}
\newcommand{\ActuatorCyclePeriod}{t_{\text{cycle}}}
\newcommand{\ActuatorDutyCycle}{D_{\text{cycle}}}
\newcommand{\ActuatorEffort}{u}
\newcommand{\ActuatorOffTime}{t_{\text{off}}}
\newcommand{\ActuatorOnTime}{t_{\text{on}}}
\newcommand{\ActuatorResponseTime}{T_{\text{act}}}
\newcommand{\ActuatorTorqueLowerBound}{\mathbf{u}_{\min}}
\newcommand{\ActuatorTorqueUpperBound}{\mathbf{u}_{\max}}
\newcommand{\AdamFirstMoment}{m}
\newcommand{\AdamMomentDecayRate}{\beta}
\newcommand{\AdamSecondMoment}{v}
\newcommand{\AdaptationEnergyAllowance}{E_{\text{slack}}}
\newcommand{\AdaptationInvestmentCost}{C_{\text{invest}}}
\newcommand{\AdaptationLatencyIncrease}{\Delta L_{\text{lat,fg}}^{\text{wc}}}
\newcommand{\AdaptationModule}{g_{\psi}}
\newcommand{\AdaptationPeakMemory}{M_{\text{peak}}}
\newcommand{\AdaptationPowerIncrement}{P_{\text{update}}}
\newcommand{\AdaptationWindowEnergy}{E_{\text{update}}}
\newcommand{\AdaptedHiddenActivation}{\mathbf{h}'}
\newcommand{\AdaptedTaskCost}{C_{\text{task, adapt}}}
\newcommand{\AdapterActivationFunction}{\sigma}
\newcommand{\AdapterDownProjectionMatrix}{\mathbf{A}}
\newcommand{\AdapterIndex}{k}
\newcommand{\AdapterInitializationStandardDeviation}{\sigma}
\newcommand{\AdapterRank}{r}
\newcommand{\AdapterScalingFactor}{\gamma}
\newcommand{\AdapterUpProjectionMatrix}{\mathbf{B}}
\newcommand{\AdjacentNeighboringDataset}{X'}
\newcommand{\AdjacentQueryResult}{v'}
\newcommand{\AdmissibleBacklogCount}{n}
\newcommand{\AdmissibleControlSet}{\mathcal{U}_{\text{adm}}}
\newcommand{\AdmissibleDisturbanceSet}{\mathcal{W}}
\newcommand{\AdmissionCheckCount}{n_{\text{chk}}}
\newcommand{\AdmissionCheckIndex}{i}
\newcommand{\AdmissionDecisionEvent}{e_{\text{auth}}}
\newcommand{\AdmissionInclusivePrebrakeDelay}{T_{\text{true}}}
\newcommand{\AdmissionRouteYield}{Y}
\newcommand{\AdmittedAttemptCap}{N}
\newcommand{\AdmittedCommand}{u}
\newcommand{\AdmittedContactForce}{F^*}
\newcommand{\AdmittedControlCommand}{\mathbf{u}}
\newcommand{\AdmittedSpeedCommand}{v^*}
\newcommand{\AdmittedTargetPosition}{\hat{\mathbf{p}}_{\text{target}}}
\newcommand{\AdmittedWorkUnitCount}{m}
\newcommand{\AdvantageStabilizer}{\epsilon_{\text{stab}}}
\newcommand{\AdversarialDisturbance}{\mathbf{d}}
\newcommand{\AdversarialExample}{x_{\text{adv}}}
\newcommand{\AdversarialInputLength}{n}
\newcommand{\AdversarialPenaltyWeight}{\lambda_{\text{adv}}}
\newcommand{\AdversarialPerturbation}{\boldsymbol{\delta}_{\text{adv}}}
\newcommand{\AdversarialPerturbationBudget}{\epsilon_{\text{adv}}}
\newcommand{\AdversaryLoss}{\mathcal{L}_{\text{adv}}}
\newcommand{\AffordanceFrame}{\mathcal{F}_{\text{affordance}}}
\newcommand{\AffordanceSuccessEstimate}{V_{\text{policy}}}
\newcommand{\AgeBlindTravel}{\Delta x_{\text{blind}}}
\newcommand{\AgeCheckInstant}{t_{\text{curr}}}
\newcommand{\AggregateSlotWork}{W}
\newcommand{\AggregatedRecoveryDataset}{\mathcal{D}}
\newcommand{\AggregatedSurrogateLoss}{\epsilon_N}
\newcommand{\AggregationLearnedPolicy}{\hat{\pi}}
\newcommand{\AggregationLearnerStateDistribution}{d_{\hat{\pi}_i}}
\newcommand{\AggregationRoundCount}{N}
\newcommand{\AggregationRoundIndex}{i}
\newcommand{\AggregationRoundTrajectorySet}{\mathcal{T}}
\newcommand{\AiStandaloneSensitivity}{S_{\text{AI}}}
\newcommand{\AisleTravelSpeed}{v_{\text{aisle}}}
\newcommand{\AisleWidth}{w}
\newcommand{\AlertCheckCount}{N_{\text{tests}}}
\newcommand{\AlertFalsePositiveRate}{\alpha_{\text{fp}}}
\newcommand{\AlgorithmTaxonomyAxis}{\mathsf{Algorithm}}
\newcommand{\AliasedVibrationFrequency}{f_{\text{alias}}}
\newcommand{\AliasingHarmonicIndex}{k}
\newcommand{\AllGatherCompletionTime}{T_{\text{allgather}}}
\newcommand{\AllOnesVector}{\mathbf{1}}
\newcommand{\AllReduceCompletionTime}{T_{\text{allreduce}}}
\newcommand{\AllReduceMinimumBandwidthTime}{T_{\text{bandwidth}}^{\text{min}}}
\newcommand{\AllRunsPassEstimate}{\widehat{r}}
\newcommand{\AllToAllCompletionTime}{T_{\text{alltoall}}}
\newcommand{\AllToAllExchangeTime}{T}
\newcommand{\AllocatedBlockCount}{N_{\text{blocks}}}
\newcommand{\AllocatedHazardRate}{\lambda_{\text{alloc}}}
\newcommand{\AllocatedWallTime}{T_{\text{wall}}}
\newcommand{\AllowableRailDroop}{\Delta V_{\text{droop, max}}}
\newcommand{\AllowableRailExcursion}{\Delta V_{\max}}
\newcommand{\AllowableWindingTemperatureRise}{\Delta T_{\max}}
\newcommand{\AllowedTokenSet}{\mathcal{V}_{\text{allow}}}
\newcommand{\AllowedViolationFraction}{V^{\text{allow}}}
\newcommand{\AlphabetByte}{b}
\newcommand{\AlternateModelInput}{x'}
\newcommand{\AmbientDimension}{D}
\newcommand{\AmbientTemperature}{T_{\text{amb}}}
\newcommand{\AmortizedTurnCost}{\bar{C}_{\text{turn}}}
\newcommand{\AngularAcceleration}{\boldsymbol{\alpha}}
\newcommand{\AngularClearance}{\theta_{\text{clear}}}
\newcommand{\AngularClearanceRate}{\dot{\theta}_{\text{clear}}}
\newcommand{\AngularFrequency}{\omega}
\newcommand{\AngularSpeed}{\omega}
\newcommand{\AngularVelocity}{\boldsymbol{\omega}}
\newcommand{\AngularVelocityDerivative}{\dot{\boldsymbol{\omega}}}
\newcommand{\AnnualQueryVolume}{Q_{\text{annual}}}
\newcommand{\AnonymitySetSize}{k_{\text{anon}}}
\newcommand{\AntiWindupTrackingTimeConstant}{T_t}
\newcommand{\AntialiasingFilterVariance}{s}
\newcommand{\ApiAccount}{u}
\newcommand{\ApparentContrast}{C}
\newcommand{\AppearanceRealityGap}{\Delta_{\text{vis}}}
\newcommand{\AppliedForce}{F}
\newcommand{\AppliedLoadCycleCount}{n}
\newcommand{\ApproachChannelCount}{K_a}
\newcommand{\ApproachDirection}{\hat{\mathbf{a}}_{\text{approach}}}
\newcommand{\ApproachPosition}{x}
\newcommand{\ApproachPredicate}{P_{\text{approach}}}
\newcommand{\ApproachSpeed}{v_{\text{app}}}
\newcommand{\ApprovalCatchFraction}{q}
\newcommand{\ApprovalHeldTrajectories}{N_{\text{held}}}
\newcommand{\ApproximatingDistribution}{q}
\newcommand{\ArbitrationFieldBitCount}{B_{\text{arb},i}}
\newcommand{\ArcObstacleDistance}{d_{\text{arc}}}
\newcommand{\ArchitectureResourceCost}{C}
\newcommand{\ArchitectureSearchSpace}{\mathcal{A}}
\newcommand{\ArcsineEffectSize}{h}
\newcommand{\ArgumentLegConfidence}{r}
\newcommand{\ArgumentLegCount}{m}
\newcommand{\ArithmeticIntensity}{I}
\newcommand{\ArmStoppingDeceleration}{a_{\text{arm}}}
\newcommand{\ArmSuccessProbability}{p}
\newcommand{\ArmingSettleDuration}{t_{\text{settle}}}
\newcommand{\ArrivalOffsetTravel}{\Delta x}
\newcommand{\ArrivalRate}{\lambda_{\text{arr}}}
\newcommand{\ArrivalStampOffset}{\Delta t_{\text{recv}}}
\newcommand{\ArrivalTimestamp}{t_{\text{recv}}}
\newcommand{\ArtifactVersion}{v}
\newcommand{\AssessedContactForceLimit}{F_{\text{limit}}}
\newcommand{\AssignedJobGpu}{g}
\newcommand{\AssociationCostEntry}{c}
\newcommand{\AssuranceClaim}{C}
\newcommand{\AsymptoticTightBound}{\Theta}
\newcommand{\AtmosphericExtinctionCoefficient}{\beta_{\text{atm}}}
\newcommand{\AttackStepsPgd}{K_{\text{PGD}}}
\newcommand{\AttackedTrialCount}{n}
\newcommand{\AttainableComputeRate}{R_{\text{attain}}}
\newcommand{\AttemptCleanupCost}{C_{\text{cleanup}}}
\newcommand{\AttemptCost}{C_{\text{attempt}}}
\newcommand{\AttemptCycleDuration}{t_{\text{cyc}}}
\newcommand{\AttemptDuration}{t_{\text{att}}}
\newcommand{\AttemptGenerationTime}{T_{\text{gen}}}
\newcommand{\AttemptPassProbability}{p}
\newcommand{\AttemptRuntimeOverheadCost}{C_{\text{runtime}}}
\newcommand{\AttemptVerificationCost}{C_{\text{verify}}}
\newcommand{\AttentionHeadCount}{N_{\text{heads}}}
\newcommand{\AttentionHeadDimension}{d_{\text{head}}}
\newcommand{\AttentionHeadOutput}{\mathbf{O}}
\newcommand{\AttentionKeyMatrix}{\mathbf{K}}
\newcommand{\AttentionOutputMatrix}{\mathbf{O}}
\newcommand{\AttentionOutputProjectionMatrix}{\mathbf{W}_{O}}
\newcommand{\AttentionQueryMatrix}{\mathbf{Q}}
\newcommand{\AttentionScoreEntry}{S_{ij}}
\newcommand{\AttentionScoreMatrix}{\mathbf{S}}
\newcommand{\AttentionScoreRow}{\mathbf{S}_{i, \cdot}}
\newcommand{\AttentionScoreSummand}{S_{ik}}
\newcommand{\AttentionScoreTile}{\mathbf{S}_{ij}}
\newcommand{\AttentionValuesMatrix}{\mathbf{V}}
\newcommand{\AttentionValuesProjectionMatrix}{\mathbf{W}_{V}}
\newcommand{\AttentionValuesSourceMatrix}{\mathbf{X}_{V}}
\newcommand{\AttentionValuesVector}{\mathbf{v}}
\newcommand{\AttentionWeightEntry}{A_{ij}}
\newcommand{\AttentionWeightMatrix}{\mathbf{A}}
\newcommand{\AttentionWeightVector}{\mathbf{a}}
\newcommand{\AttitudeError}{\theta_{\text{att}}}
\newcommand{\AttributionFeatureCount}{n_{\text{feat}}}
\newcommand{\AuditGroupRecordCount}{n_{\text{records}}}
\newcommand{\AuthorityExposureLevel}{A}
\newcommand{\AutocorrelationLagIndex}{k}
\newcommand{\AutoencoderReconstructionError}{\mathcal{L}_{\text{rec}}}
\newcommand{\AutomatedResetTime}{t_{\text{reset,auto}}}
\newcommand{\AutomatonStateSet}{Q}
\newcommand{\AutomatonTransitionFunction}{\delta}
\newcommand{\AutonomousExecutionComputeCost}{C_{\text{compute}}}
\newcommand{\AutoscalingDecisionTime}{T_{\text{decide}}}
\newcommand{\AutoscalingDetectionTime}{T_{\text{detect}}}
\newcommand{\AutoscalingResponseTime}{T_{\text{response}}}
\newcommand{\AvailabilityObjective}{S_{\text{availability}}}
\newcommand{\AvailableBrakingDistance}{D_{\text{avail}}}
\newcommand{\AvailableDeceleration}{a}
\newcommand{\AvailableObservations}{\mathcal{O}_{\text{avail}}}
\newcommand{\AverageCopperLossPower}{\bar{P}_{\text{loss}}}
\newcommand{\AverageOnlineRegret}{\gamma_N}
\newcommand{\AveragePower}{P_{\text{avg}}}
\newcommand{\AverageStateVisitationDistribution}{\bar{d}}
\newcommand{\AxiBurstLength}{A_{\text{len}}}
\newcommand{\AxisGridPointCount}{N}
\newcommand{\AzimuthAngle}{\theta_{\text{az}}}
\newcommand{\BackEmfVoltage}{e_{\text{bemf}}}
\newcommand{\BacklashAngle}{\theta_{\text{backlash}}}
\newcommand{\BackwardEulerEigenvalue}{\lambda_{\text{BE}}}
\newcommand{\BackwardEulerTransitionMatrix}{\mathbf{A}_{\text{BE}}}
\newcommand{\BackwardPassTime}{T_{\text{backward}}}
\newcommand{\BackwardReachableTube}{\mathcal{R}}
\newcommand{\BalanceDivergenceTime}{\tau_{\text{fall}}}
\newcommand{\BallRadius}{r}
\newcommand{\BallVolume}{V_D}
\newcommand{\Bandwidth}{\text{BW}}
\newcommand{\BankConflictPenalty}{\Delta t_{\text{conflict}}}
\newcommand{\BarrierConstraintBound}{b_{\text{cbf}}}
\newcommand{\BarrierConstraintCount}{K_b}
\newcommand{\BarrierConstraintNormal}{\mathbf{a}_{\text{cbf}}}
\newcommand{\BarrierFunction}{h}
\newcommand{\BarrierFunctionRate}{\dot{h}}
\newcommand{\BarrierHalfSpaceControlSet}{\mathcal{U}_{\text{safe}}}
\newcommand{\BarrierMargin}{\delta}
\newcommand{\BarrierNormalizationScale}{h_{\text{scale}}}
\newcommand{\BarrierProjectionLagrangian}{L_{\text{Lag}}}
\newcommand{\BarrierProjectionMultiplier}{\lambda}
\newcommand{\BarrierRelativeDegree}{r}
\newcommand{\BaseAbscissaVelocity}{\dot{x}}
\newcommand{\BaseAccelerationCommand}{a}
\newcommand{\BaseBatchSize}{B_{\text{base}}}
\newcommand{\BaseCameraRotation}{\mathbf{R}_{\text{base}}^{\text{cam}}}
\newcommand{\BaseCameraTransform}{\mathbf{T}_{\text{base}}^{\text{cam}}}
\newcommand{\BaseCameraTranslation}{\mathbf{t}_{\text{base}}^{\text{cam}}}
\newcommand{\BaseFlangeTransform}{\mathbf{T}_{\text{base}}^{\text{flange}}}
\newcommand{\BaseForwardSpeed}{v}
\newcommand{\BaseFramePoint}{\mathbf{p}_{\text{base}}}
\newcommand{\BaseHeadingRate}{\dot{\theta}_{\text{head}}}
\newcommand{\BaseJointInertiaCoupling}{\mathbf{M}_{bj}}
\newcommand{\BaseLateralPosition}{y_{\text{base}}}
\newcommand{\BaseLateralVelocity}{\dot{y}}
\newcommand{\BaseLayerCount}{N_{L,0}}
\newcommand{\BaseLearningRate}{\eta_{\text{base}}}
\newcommand{\BaseLongitudinalPosition}{x_{\text{base}}}
\newcommand{\BaseLongitudinalVelocity}{\dot{x}}
\newcommand{\BaseOdometrySpeed}{v}
\newcommand{\BaseOrdinateVelocity}{\dot{y}}
\newcommand{\BasePosition}{\mathbf{p}_{\text{base}}}
\newcommand{\BasePromptLength}{S_{\text{base}}}
\newcommand{\BaseStoppingDistance}{d_{\text{base}}}
\newcommand{\BaseToCameraTransform}{\mathbf{T}_{\text{cam} \leftarrow \text{base}}}
\newcommand{\BaseTrainingComputeCost}{C_{\text{compute}}}
\newcommand{\BaseTrajectoryTokenCount}{N_{\text{base}}}
\newcommand{\BaseTravelDistance}{d}
\newcommand{\BaseTravelSpeed}{v_{\text{base}}}
\newcommand{\BaseWidthMultiplier}{w_{\text{mult},0}}
\newcommand{\BaseWristTransform}{\mathbf{T}_{\text{base} \leftarrow \text{wrist}}}
\newcommand{\BaseYawRateBias}{\omega_{\text{bias}}}
\newcommand{\BaselineAcceptanceEstimate}{\hat{p}_{\text{base}}}
\newcommand{\BaselineControllerAction}{\mathbf{a}_t^{\text{base}}}
\newcommand{\BaselineConversionRate}{p_0}
\newcommand{\BaselineFeatureMean}{\mu_{\text{base}}}
\newcommand{\BaselineFeatureStandardDeviation}{\sigma_{\text{base}}}
\newcommand{\BaselineIntervalLowerLimit}{l_{\text{base}}}
\newcommand{\BaselineIntervalUpperLimit}{u_{\text{base}}}
\newcommand{\BaselineLowerLimitDistance}{\delta^-_{\text{base}}}
\newcommand{\BaselineOnlyAcceptedTaskCount}{b}
\newcommand{\BaselineOnlyCorrectCount}{n_{\text{base}}}
\newcommand{\BaselinePolicyAcceptanceProbability}{p_{X}}
\newcommand{\BaselinePolicyCost}{C_{X}}
\newcommand{\BaselineStateDistribution}{d^{\pi_{\text{base}}}}
\newcommand{\BaselineTaskCost}{C_{\text{task, base}}}
\newcommand{\BaselineToolCallDistribution}{p_{b}}
\newcommand{\BaselineTrackingError}{e_{\text{track}}}
\newcommand{\BaselineTrainingDuration}{T_{\text{hours}}}
\newcommand{\BaselineTrajectoryGoodput}{\mathcal{G}_{b}}
\newcommand{\BaselineUpperLimitDistance}{\delta^+_{\text{base}}}
\newcommand{\BatchArrivalRate}{\lambda_{\text{batch}}}
\newcommand{\BatchAxisLabel}{b}
\newcommand{\BatchBufferMemory}{M_{\text{batch}}}
\newcommand{\BatchCostPerAcceptedTask}{C_{\text{eff,batch}}}
\newcommand{\BatchDataVolume}{D_{\text{vol}}^{(\text{batch})}}
\newcommand{\BatchExampleIndex}{n}
\newcommand{\BatchFetchTime}{T_{\text{fetch}}}
\newcommand{\BatchFillArrivalCount}{k}
\newcommand{\BatchFixedOverheadTime}{T_{\text{fixed}}}
\newcommand{\BatchFlushStartTime}{t_{\text{start}}}
\newcommand{\BatchFormationDelay}{L_{\text{lat,form}}}
\newcommand{\BatchIndex}{k}
\newcommand{\BatchLabelComponent}{y_{ij}}
\newcommand{\BatchLatencyEnvelope}{L_{\text{lat,envelope}}}
\newcommand{\BatchLoss}{\mathcal{L}_{\text{batch}}}
\newcommand{\BatchMaxOutputLength}{S_{\text{max}}}
\newcommand{\BatchMaximumDeviationMultiple}{k}
\newcommand{\BatchMeanOutputLength}{\bar{S}}
\newcommand{\BatchNormMean}{\mu_{\mathcal{B}}}
\newcommand{\BatchNormOutput}{y}
\newcommand{\BatchNormRunningMean}{\boldsymbol{\mu}_{\mathcal{B}}}
\newcommand{\BatchNormRunningStandardDeviation}{\boldsymbol{\sigma}_{\mathcal{B}}}
\newcommand{\BatchNormStandardDeviation}{\sigma_{\mathcal{B}}}
\newcommand{\BatchOperations}{O_{\text{batch}}}
\newcommand{\BatchPredictedProbability}{\hat{y}_{ij}}
\newcommand{\BatchProcessingTime}{T_{\text{process}}}
\newcommand{\BatchRolloutCount}{N_{\text{batch}}}
\newcommand{\BatchScalingFactor}{k}
\newcommand{\BatchServiceTime}{T_{\text{svc}}}
\newcommand{\BatchSize}{B}
\newcommand{\BatchTransferTime}{T_{\text{transfer}}}
\newcommand{\BatchedDecodeStepTime}{t_{\text{step}}}
\newcommand{\BatchedEventIndex}{i}
\newcommand{\BatchedRequestLatency}{L_{\text{lat,batch}}}
\newcommand{\BatchingLatencyBudget}{L_{\text{lat,budget}}}
\newcommand{\BatchingQueueWait}{L_{\text{lat,wait}}}
\newcommand{\BatchingWindow}{T_{\text{window}}}
\newcommand{\BatteryCellResistance}{R_{\text{cell}}}
\newcommand{\BeamDivergenceAngle}{\delta\theta_{\text{div}}}
\newcommand{\BeamWidth}{W}
\newcommand{\BearingRay}{\mathbf{r}}
\newcommand{\BeatFrequency}{f_b}
\newcommand{\BehaviorCloningHorizon}{S}
\newcommand{\BehaviorCloningLoss}{\mathcal{L}_{\text{BC}}}
\newcommand{\BehaviorDistribution}{b}
\newcommand{\BehaviorPolicyVersion}{\text{ver}_b}
\newcommand{\BeliefErrorBound}{E}
\newcommand{\BeliefInvalidationHorizon}{T_{\text{inv}}}
\newcommand{\BeliefState}{b}
\newcommand{\BellmanBackupTarget}{y}
\newcommand{\BellmanErrorLoss}{\mathcal{L}_{\text{Bellman}}}
\newcommand{\BelowThresholdIndicator}{\mathbf{1}_{\{|(\mathbf{W}_{\text{sparse}})_{ij}| \leq \delta_{\text{prune}}\}}}
\newcommand{\BestEffortWireBitCount}{B_{\text{BE,wire}}}
\newcommand{\BetterArmSuccessProbability}{p_{\text{high}}}
\newcommand{\BetweenTaskStandardDeviation}{\sigma_{\text{task}}}
\newcommand{\BevPillarFeature}{\mathbf{V}_{\text{BEV}}}
\newcommand{\BevPillarXIndex}{X}
\newcommand{\BevPillarYIndex}{Y}
\newcommand{\BiasFeedbackFactor}{\alpha_{\text{fb}}}
\newcommand{\BiasVector}{\mathbf{b}}
\newcommand{\BilledAllocationTime}{T_{\text{total}}}
\newcommand{\BinaryActivationVector}{\mathbf{a}}
\newcommand{\BinaryClassifier}{h}
\newcommand{\BinaryWeightVector}{\mathbf{w}}
\newcommand{\BinomialSuccessCount}{X}
\newcommand{\BipedTiltAcceleration}{\ddot{\theta}_{\text{tilt}}}
\newcommand{\BisectionBandwidth}{\text{BW}_{\text{bisect}}}
\newcommand{\BitFlippedFloatNumber}{x_{\text{corrupt}}}
\newcommand{\BitTime}{T_{\text{bit}}}
\newcommand{\BlackoutClockConversionError}{\Delta t_{\text{one-sigma scenario}}}
\newcommand{\BlendDeadline}{t_{\text{blend}}}
\newcommand{\BlendedCommandJerk}{j_{\text{cmd}}}
\newcommand{\BlendedControlCommand}{\mathbf{u}_{\text{blend}}}
\newcommand{\BlendedInputTokenPrice}{c_{\text{in}}}
\newcommand{\BlendingTransitionWindow}{\tau_{\text{blend}}}
\newcommand{\BlindTravelDistance}{d_{\text{blind}}}
\newcommand{\BlockCheckTime}{T_{\text{ver}}}
\newcommand{\BlockCoordinateX}{b_x}
\newcommand{\BlockCoordinateY}{b_y}
\newcommand{\BlockCoordinateZ}{b_z}
\newcommand{\BlockEdgeVoxelCount}{n_{\text{blk}}}
\newcommand{\BlockMaximum}{M}
\newcommand{\BlockMaximumLevel}{z}
\newcommand{\BlockMaximumLimitDistribution}{G}
\newcommand{\BlockMaximumNormalizingScale}{a}
\newcommand{\BlockMaximumNormalizingShift}{b}
\newcommand{\BlockMetadataSize}{s_{\text{meta}}}
\newcommand{\BlockQuantizationScale}{s_b}
\newcommand{\BlockRangeMaximum}{x_{\max,i}}
\newcommand{\BlockRangeMinimum}{x_{\min,i}}
\newcommand{\BlockSampleCount}{n}
\newcommand{\BlockedWorkerCount}{N_{\text{blocked}}}
\newcommand{\BlockingCallTimeout}{T_{\text{out}}}
\newcommand{\BlockingTaskIndex}{k}
\newcommand{\BodyAcceleration}{\dot{v}}
\newcommand{\BodyDisplacement}{x}
\newcommand{\BodyEndEffectorTransform}{\mathbf{T}_{BE}}
\newcommand{\BodyFramePoint}{\mathbf{p}_{\text{body}}}
\newcommand{\BodyFramePointCovariance}{\boldsymbol{\Sigma}_{\text{body}}}
\newcommand{\BodyLidarTransform}{\mathbf{T}_{bl}}
\newcommand{\BodyReferenceFrame}{\mathcal{F}_B}
\newcommand{\BodyRegionMass}{m_H}
\newcommand{\BodySpeed}{v}
\newcommand{\BoltzmannConstant}{k_B}
\newcommand{\BoltzmannStateEnergy}{E}
\newcommand{\BoltzmannTemperature}{T}
\newcommand{\BootstrapQuantileFunction}{Q}
\newcommand{\BootstrapReplicateCount}{B_{\text{boot}}}
\newcommand{\BootstrapReplicateIndex}{r}
\newcommand{\BottomedOutContactStiffness}{k_{\infty}}
\newcommand{\BouligandContingentCone}{T_{\mathcal{C}}}
\newcommand{\BoundaryConditionVector}{\mathbf{b}}
\newcommand{\BoundaryLayerTime}{t_{\text{fast}}}
\newcommand{\BoundedRegimeTimestamp}{t_{\text{bounded}}}
\newcommand{\BoxMaximumHorizontalCoordinate}{x_{\text{max}}}
\newcommand{\BoxMaximumVerticalCoordinate}{y_{\text{max}}}
\newcommand{\BoxMinimumHorizontalCoordinate}{x_{\text{min}}}
\newcommand{\BoxMinimumVerticalCoordinate}{y_{\text{min}}}
\newcommand{\BrakeChopperResistance}{R_{\text{brake}}}
\newcommand{\BrakeCommandForce}{F_{\text{cmd}}}
\newcommand{\BrakeResistorPulseEnergy}{E_{\text{pulse}}}
\newcommand{\BrakingDistance}{d_{\text{brake}}}
\newcommand{\BrakingForce}{F_{\text{brake}}}
\newcommand{\BrakingOnsetContactForce}{F_{\text{cmd}}}
\newcommand{\BrakingWork}{W_{\text{brake}}}
\newcommand{\BreadthCriticalPathLatency}{T^{\text{breadth}}}
\newcommand{\BreadthPeakKvCacheMemory}{M_{\text{KV}}^{\text{breadth}}}
\newcommand{\BreakEvenAcceptanceProbability}{p'}
\newcommand{\BreakEvenBrakingDeceleration}{a}
\newcommand{\BreakEvenParseFailureRate}{p_{\text{break}}}
\newcommand{\BreakEvenTaskCount}{N^*}
\newcommand{\BreakEvenUtilization}{u^*}
\newcommand{\BreakerCooldownInterval}{T_{\text{cool}}}
\newcommand{\BreakerFailureFraction}{r}
\newcommand{\BreakerMinimumSampleCount}{n_{\min}}
\newcommand{\BreakerOutcomeIndex}{i}
\newcommand{\BreakerOutcomeWindow}{W}
\newcommand{\BreakerTripThreshold}{r_{\text{trip}}}
\newcommand{\BridgeTraceResistance}{R_{\text{trace}}}
\newcommand{\BroadcastColumnElement}{A}
\newcommand{\BroadcastColumnTensor}{\mathbf{A}}
\newcommand{\BroadcastCompletionTime}{T_{\text{broadcast}}}
\newcommand{\BroadcastRowElement}{b}
\newcommand{\BroadcastRowTensor}{\mathbf{B}}
\newcommand{\BroadcastTableSize}{s_{\text{table}}}
\newcommand{\BspLearningRate}{\eta_{\text{BSP}}}
\newcommand{\BsplineBasisFunction}{B}
\newcommand{\BudgetEvaluationTime}{\tau}
\newcommand{\BudgetFreeBalance}{F}
\newcommand{\BudgetNodeIndex}{k}
\newcommand{\BudgetReservedFunds}{R}
\newcommand{\BudgetSettledCharges}{E}
\newcommand{\BudgetedAcceptanceProbability}{q_{\pi}}
\newcommand{\BufferDependencyEdgeSet}{E}
\newcommand{\BufferDependencyGraph}{G}
\newcommand{\BufferDependencyVertexSet}{V}
\newcommand{\BufferIndex}{i}
\newcommand{\BulkDecouplingCapacitance}{C_{\text{bulk}}}
\newcommand{\BumplessTransferBlend}{\alpha}
\newcommand{\BumplessTransferBlendAcceleration}{\ddot{\alpha}}
\newcommand{\BumplessTransferBlendRate}{\dot{\alpha}}
\newcommand{\BumplessTransferBlendSlope}{\alpha'}
\newcommand{\BumplessTransferProgress}{\hat{t}}
\newcommand{\BumplessTransferStartInstant}{t_{\text{start}}}
\newcommand{\BurstArrivalCount}{N_{\text{burst}}}
\newcommand{\BurstSurvivalTime}{t_{\text{limit}}}
\newcommand{\BusBitRate}{R_{\text{bit}}}
\newcommand{\BusCapacitorEnergy}{E_C}
\newcommand{\BusCapacitorVoltage}{V_C}
\newcommand{\BusSerializationTime}{t_{\text{bus}}}
\newcommand{\ButterflyAllReduceTime}{T_{\text{butterfly}}}
\newcommand{\ByteAlphabet}{\Sigma}
\newcommand{\ByteString}{u}
\newcommand{\ByzantineClientCount}{f}
\newcommand{\ByzantineFaultCount}{f}
\newcommand{\CableFlexCycleCount}{n_{\text{cable}}}
\newcommand{\CableRatedFatigueLife}{L_{\text{cable}}}
\newcommand{\CacheMissStallFraction}{f}
\newcommand{\CachedInputTokenCount}{n_{\text{cache}}}
\newcommand{\CachedInputTokenPrice}{c_{\text{cache}}}
\newcommand{\CalibratedAcceptanceEstimate}{\hat{p}}
\newcommand{\CalibrationBinCount}{N_{\text{bins}}}
\newcommand{\CalibrationBinExampleSet}{B_m}
\newcommand{\CalibrationBinIndex}{m}
\newcommand{\CalibrationConstraintMatrix}{\mathbf{V}}
\newcommand{\CalibrationDataDistribution}{p_{\text{cal}}}
\newcommand{\CalibrationDataset}{\mathcal{C}_{\text{cal}}}
\newcommand{\CalibrationExampleCount}{n_{\text{cal}}}
\newcommand{\CalibrationModelPoint}{\mathbf{M}}
\newcommand{\CalibrationPoseIndex}{k}
\newcommand{\CalibrationRotationAxisCount}{N}
\newcommand{\CalibrationSceneIndex}{j}
\newcommand{\CalibrationTemperature}{T_{\text{cal}}}
\newcommand{\CalibrationViewCount}{N}
\newcommand{\CallLatency}{T_{\text{call}}}
\newcommand{\CallPostprocessingTime}{T_{\text{post}}}
\newcommand{\CallPreparationTime}{T_{\text{prep}}}
\newcommand{\CallTailProbability}{p_{\text{tail}}}
\newcommand{\CallUsefulWorkTime}{W}
\newcommand{\CameraCenterArcPosition}{x_{\text{rot}}}
\newcommand{\CameraExtrinsicRotation}{\mathbf{R}_{bc}}
\newcommand{\CameraExtrinsicTransform}{\mathbf{T}_{bc}}
\newcommand{\CameraExtrinsicTranslation}{\mathbf{p}_{bc}}
\newcommand{\CameraFrameDepth}{Z_c}
\newcommand{\CameraFrameHorizontalCoordinate}{X_c}
\newcommand{\CameraFramePeriod}{T_{\text{sample}}}
\newcommand{\CameraFramePoint}{\mathbf{p}_c}
\newcommand{\CameraFramePointCovariance}{\boldsymbol{\Sigma}_c}
\newcommand{\CameraFrameVerticalCoordinate}{Y_c}
\newcommand{\CameraIdentifierEmbedding}{\mathbf{e}_{\text{cam}}}
\newcommand{\CameraImage}{\mathbf{I}}
\newcommand{\CameraImuTimeOffset}{\Delta t_{\text{imu}}}
\newcommand{\CameraIntrinsicCalibrationMatrix}{\mathbf{K}}
\newcommand{\CameraIntrinsicInverseTranspose}{\mathbf{K}^{-\top}}
\newcommand{\CameraLateralStandardDeviation}{\sigma_{x_c}}
\newcommand{\CameraMountTiltAngle}{\theta_{\text{ext}}}
\newcommand{\CameraObjectTransform}{\mathbf{T}_{\text{camera}}^{\text{object}}}
\newcommand{\CameraOpticalCenter}{\mathbf{o}}
\newcommand{\CameraReferenceFrame}{\mathcal{F}_{\text{cam}}}
\newcommand{\CameraRotationColumn}{\mathbf{r}}
\newcommand{\CameraSampleTimestamp}{t_{\text{cam}}}
\newcommand{\CameraSkewCoefficient}{\gamma}
\newcommand{\CameraTargetTransform}{\mathbf{T}_{\text{cam}}^{\text{target}}}
\newcommand{\CameraToWorldRotation}{\mathbf{R}_{WC}}
\newcommand{\CameraToWorldTransform}{\mathbf{T}_{WC}}
\newcommand{\CameraToWorldTranslation}{\mathbf{t}_{WC}}
\newcommand{\CampaignActiveTime}{T_{\text{active}}}
\newcommand{\CanHighLineVoltage}{V_{\text{CANH}}}
\newcommand{\CanLowLineVoltage}{V_{\text{CANL}}}
\newcommand{\CanaryAllocationFraction}{\rho}
\newcommand{\CanaryInterventionRate}{\lambda_{\text{canary}}}
\newcommand{\CanaryLabelDelay}{t_{\text{label}}}
\newcommand{\CanarySpeedBound}{v_{\text{canary}}}
\newcommand{\CanaryStageDuration}{T_{\text{stage}}}
\newcommand{\CanaryTrafficFraction}{p_{\text{stage}}}
\newcommand{\CandidateAcceptanceEstimate}{\hat{p}_{\text{cand}}}
\newcommand{\CandidateActionVector}{\hat{\mathbf{a}}}
\newcommand{\CandidateArchitecture}{a}
\newcommand{\CandidateAvailabilityEstimate}{\widehat{q}}
\newcommand{\CandidateAvailabilityProbability}{q}
\newcommand{\CandidateCheckingCost}{v}
\newcommand{\CandidateClientCount}{K_{\text{candidates}}}
\newcommand{\CandidateControlCommand}{\mathbf{u}^{\text{cand}}}
\newcommand{\CandidateControlCommandDerivative}{\dot{\mathbf{u}}^{\text{cand}}}
\newcommand{\CandidateDefectRate}{\epsilon}
\newcommand{\CandidateGenerationCost}{g}
\newcommand{\CandidateIndex}{i}
\newcommand{\CandidateIntervalLowerLimit}{l_{\text{cand}}}
\newcommand{\CandidateIntervalUpperLimit}{u_{\text{cand}}}
\newcommand{\CandidateLowerLimitDistance}{\delta^-_{\text{cand}}}
\newcommand{\CandidateOnlyAcceptedTaskCount}{c}
\newcommand{\CandidatePolicyAcceptanceProbability}{p_{Y}}
\newcommand{\CandidatePolicyAction}{\mathbf{a}_t^{\text{cand}}}
\newcommand{\CandidatePolicyCost}{C_{Y}}
\newcommand{\CandidatePoolSize}{N}
\newcommand{\CandidateProposal}{p}
\newcommand{\CandidateRoutingPolicy}{Y}
\newcommand{\CandidateScoreVector}{\mathbf{c}}
\newcommand{\CandidateScoringCost}{c_{\text{infer}}}
\newcommand{\CandidateScoringError}{\epsilon}
\newcommand{\CandidateSkill}{a}
\newcommand{\CandidateSpeedCommand}{v_{\text{cand}}}
\newcommand{\CandidateTailCompletionTime}{\widehat{T}_{c,0.99}}
\newcommand{\CandidateToolCallDistribution}{p_{c}}
\newcommand{\CandidateTrackingErrorStandardDeviation}{\sigma_{\text{track}}}
\newcommand{\CandidateTrajectoryGoodput}{\mathcal{G}_{c}}
\newcommand{\CandidateUpperLimitDistance}{\delta^+_{\text{cand}}}
\newcommand{\CandidateUtility}{U}
\newcommand{\CandidateUtilityMean}{\mu}
\newcommand{\CandidateUtilityStandardDeviation}{\sigma_{U}}
\newcommand{\CandidateViolationCount}{V_{c}}
\newcommand{\CandidateWinCount}{j}
\newcommand{\CapabilityGrant}{\Gamma}
\newcommand{\CaptureAgeEmbedding}{\mathbf{e}_{\Delta t}}
\newcommand{\CaptureSampleIndex}{t_0}
\newcommand{\CaptureSampleKalmanGain}{\mathbf{G}_{t_0}}
\newcommand{\CaptureSampleMeasurementMatrix}{\mathbf{H}_{t_0}}
\newcommand{\CaptureSamplePredictedCovariance}{\mathbf{P}_{t_0|t_0-1}}
\newcommand{\CaptureSamplePredictedEstimate}{\hat{\mathbf{x}}_{t_0|t_0-1}}
\newcommand{\CaptureSampleUpdatedCovariance}{\mathbf{P}_{t_0|t_0}}
\newcommand{\CaptureSampleUpdatedEstimate}{\hat{\mathbf{x}}_{t_0|t_0}}
\newcommand{\CaptureTimestamp}{t_{\text{capture}}}
\newcommand{\CapturedSensorObservation}{\mathbf{z}_{t_0}}
\newcommand{\CartesianAcceleration}{\ddot{\mathbf{p}}}
\newcommand{\CartesianPosition}{\mathbf{p}}
\newcommand{\CartesianXCoordinate}{x}
\newcommand{\CartesianYCoordinate}{y}
\newcommand{\CartesianZCoordinate}{z}
\newcommand{\CascadeEscalationProbability}{p_{\text{escalate}}}
\newcommand{\CascadeGateCost}{g}
\newcommand{\CascadeGateDuration}{v}
\newcommand{\CascadeInferenceEnergy}{E_{\text{cascade}}}
\newcommand{\CascadeTaskCost}{C_{\text{cascade}}}
\newcommand{\CascadeTaskDuration}{T_{\text{cascade}}}
\newcommand{\CascadeTierCost}{c^{\text{tier}}}
\newcommand{\CascadeTierDuration}{t}
\newcommand{\CascadeTierIndex}{j}
\newcommand{\CascadedBarrierCertificate}{\psi}
\newcommand{\CascadedBarrierClassKFunction}{\alpha}
\newcommand{\CascadedBarrierDerivative}{\dot{\psi}}
\newcommand{\CaseAmbientThermalResistance}{R_{\text{th,case-amb}}}
\newcommand{\CaseTemperature}{T_{\text{case}}}
\newcommand{\CaseThermalCapacitance}{C_{\text{case}}}
\newcommand{\CaseThermalTimeConstant}{\tau_{\text{th,case}}}
\newcommand{\CatalogDefinitionTokens}{S_{\text{catalog}}}
\newcommand{\CatalogStagingCallCount}{N}
\newcommand{\CategoryRecordCount}{n}
\newcommand{\CausalInterventionMask}{\mathcal{M}}
\newcommand{\CausalMediator}{M}
\newcommand{\CausalTokenPosition}{s}
\newcommand{\CbsRuntimeBudget}{Q}
\newcommand{\CellOccupancyProbability}{p}
\newcommand{\CenterCount}{k}
\newcommand{\CentralizedTrainingEnergy}{E_{\text{centralized}}}
\newcommand{\CentroidalAngularMomentum}{\mathbf{h}_{\text{ang}}}
\newcommand{\CentroidalAngularMomentumDerivative}{\dot{\mathbf{h}}_{\text{ang}}}
\newcommand{\CentroidalLinearMomentum}{\mathbf{h}_{\text{lin}}}
\newcommand{\CentroidalLinearMomentumDerivative}{\dot{\mathbf{h}}_{\text{lin}}}
\newcommand{\CentroidalMomentum}{\mathbf{h}_G}
\newcommand{\CentroidalMomentumMatrix}{\mathbf{A}_G}
\newcommand{\CentroidalMomentumMatrixDerivative}{\dot{\mathbf{A}}_G}
\newcommand{\CentroidalMomentumRate}{\dot{\mathbf{h}}_G}
\newcommand{\CertifiedCommandWindow}{\mathbf{u}^*_{t:t+H-1}}
\newcommand{\CertifiedControlAction}{\mathbf{u}^*}
\newcommand{\CertifiedRadius}{R}
\newcommand{\ChainRuleInput}{x}
\newcommand{\ChainRuleIntermediate}{u}
\newcommand{\ChainRuleOutput}{v}
\newcommand{\ChainedOperationCount}{n_{\text{ops}}}
\newcommand{\ChanceAnnotatorAgreement}{p_e}
\newcommand{\ChannelAuthorityState}{S}
\newcommand{\ChannelCommand}{u}
\newcommand{\ChannelStoredEnergy}{E_{\text{channel}}}
\newcommand{\CharacteristicPolynomial}{p}
\newcommand{\CharacteristicPolynomialCoefficient}{c}
\newcommand{\ChassisThermalResistance}{R_{\text{th,chassis}}}
\newcommand{\CheapConfigurationAttemptCost}{c_{\text{small}}}
\newcommand{\CheapConfigurationPassProbability}{p_{\text{small}}}
\newcommand{\CheckIntervalStepCount}{m}
\newcommand{\CheckPassProbability}{p^{\text{chk}}}
\newcommand{\CheckSlotTime}{T}
\newcommand{\CheckedSignal}{x}
\newcommand{\CheckedSignalLimit}{L_{\text{limit}}}
\newcommand{\CheckpointAttemptDuration}{T_{\text{att}}}
\newcommand{\CheckpointExtraPauseTime}{T_{\text{pause}}}
\newcommand{\CheckpointInterval}{T_{\text{ckpt}}}
\newcommand{\CheckpointLoadTime}{T_{\text{load}}}
\newcommand{\CheckpointLogPosition}{j_{\text{ckpt}}}
\newcommand{\CheckpointOrdinalIndex}{m}
\newcommand{\CheckpointOverheadFraction}{f_{\text{ckpt}}}
\newcommand{\CheckpointOverheadRatio}{w}
\newcommand{\CheckpointRecoveryOverheadTime}{T_{\text{overhead}}}
\newcommand{\CheckpointRestoreTime}{T_{\text{restore}}}
\newcommand{\CheckpointStride}{k}
\newcommand{\CheckpointSuffixReadTime}{T_{\text{read}}}
\newcommand{\CheckpointWasteFraction}{W}
\newcommand{\CheckpointWriteTime}{T_{\text{write}}}
\newcommand{\ChildBatchSize}{n_{\text{batch}}}
\newcommand{\ChildBudgetAllocation}{C_{\max,C}}
\newcommand{\ChildCapabilityGrant}{\Gamma_{\text{child}}}
\newcommand{\ChildFreeBalance}{F_{C}}
\newcommand{\ChildPruningProbability}{p_{\text{prune}}}
\newcommand{\ChildReservedFunds}{R_{C}}
\newcommand{\ChildSettledCharges}{E_{C}}
\newcommand{\ChinchillaIrreducibleLoss}{E}
\newcommand{\ChirpDuration}{T_c}
\newcommand{\ChirpSlope}{S}
\newcommand{\ChopperClampVoltage}{V_{\text{clamp}}}
\newcommand{\ChopperTurnOffVoltage}{V_{\text{clamp,off}}}
\newcommand{\ChopperTurnOnVoltage}{V_{\text{clamp,on}}}
\newcommand{\ChunkActionDimension}{d_{\text{chunk}}}
\newcommand{\ChunkEnsemblingWeight}{w}
\newcommand{\ChunkExecutionHorizon}{H_{\text{exec}}}
\newcommand{\ChunkImitationLoss}{\mathcal{L}_{\text{chunk}}}
\newcommand{\ChunkLease}{T_{\text{lease}}}
\newcommand{\ChunkReactionLatency}{T_{\text{reaction}}}
\newcommand{\ChunkRenewalPeriod}{T_{\text{chunk}}}
\newcommand{\ChunkRenewalRate}{f_{\text{replan}}}
\newcommand{\ChunkStepIndex}{i}
\newcommand{\ClampedControlCommand}{\mathbf{u}_{\text{clip}}}
\newcommand{\ClassCount}{K}
\newcommand{\ClassIndex}{j}
\newcommand{\ClassKFunction}{\kappa}
\newcommand{\ClassKFunctionSet}{\mathcal{K}}
\newcommand{\ClassProbabilityVector}{\mathbf{p}}
\newcommand{\ClassificationThreshold}{\gamma_{\text{cls}}}
\newcommand{\CleanLabelSampleCount}{D_{\text{clean}}}
\newcommand{\CleanTrainingDataset}{\mathcal{S}}
\newcommand{\CleanupGraphEdgeSet}{E}
\newcommand{\CleanupGraphVertexSet}{V}
\newcommand{\ClearDistance}{D_{\text{clear}}}
\newcommand{\ClearanceAcceleration}{\ddot{D}_{\text{clear}}}
\newcommand{\ClearanceAllowance}{C}
\newcommand{\ClearanceExhaustionTime}{t_{\text{impact}}}
\newcommand{\ClearanceInset}{C_{\text{inset}}}
\newcommand{\ClearanceQueryTime}{t_{\text{query}}}
\newcommand{\ClearanceRate}{\dot{D}_{\text{clear}}}
\newcommand{\ClearanceSpeedClamp}{v_{\text{clamp}}}
\newcommand{\ClearanceTimeBudget}{T_{\text{total}}}
\newcommand{\ClfClassKFunction}{\alpha_V}
\newcommand{\ClfDescentControlSet}{\mathcal{U}_{\text{CLF}}}
\newcommand{\ClientIndex}{k}
\newcommand{\ClientLocalDataset}{\mathcal{D}}
\newcommand{\ClientLocalTrainingEnergy}{E_{\text{client}}}
\newcommand{\ClientObjectiveWeight}{w}
\newcommand{\ClientSampleCount}{n}
\newcommand{\ClientUpdateUploadEnergy}{E_{\text{upload}}}
\newcommand{\ClippedSurrogateObjective}{\mathcal{M}}
\newcommand{\ClippingRangeLowerBound}{\alpha}
\newcommand{\ClippingRangeUpperBound}{\beta}
\newcommand{\ClockConversionBound}{\epsilon_{\text{sync}}}
\newcommand{\ClockConversionIntercept}{b_{\text{clk}}}
\newcommand{\ClockConversionSlope}{a}
\newcommand{\ClockFrequency}{f}
\newcommand{\ClockOffset}{\theta_{\text{offset}}}
\newcommand{\ClockPeriod}{T_{\text{clk}}}
\newcommand{\ClockSynchronizationSkew}{\delta_{\text{skew}}}
\newcommand{\ClosedLoopTrajectoryDensity}{p_{\text{cl}}}
\newcommand{\ClosingSpeedBound}{v_{\text{close}}}
\newcommand{\CloudInferenceEnergy}{E_{\text{cloud}}}
\newcommand{\CloudOffloadEnergy}{E_{\text{transmit}}}
\newcommand{\CloudTrainingRunEnergy}{E_{\text{cloud,train}}}
\newcommand{\ClusterCount}{k}
\newcommand{\ClusterHeadroom}{N}
\newcommand{\ClusterNodeCount}{N_{\text{nodes}}}
\newcommand{\ClusterPower}{P_{\text{cluster}}}
\newcommand{\CoarseCellCount}{C}
\newcommand{\CodecDecodeTime}{T_{\text{decode}}}
\newcommand{\CodecEncodeTime}{T_{\text{encode}}}
\newcommand{\CodecOverheadTime}{T_{\text{overhead}}}
\newcommand{\CognitivePolicyAction}{\mathbf{a}}
\newcommand{\CoherencyCoefficient}{\kappa_{\text{coh}}}
\newcommand{\ColdCopperLossPower}{P_0}
\newcommand{\ColdResetCycleTime}{T_{\text{cycle,cold}}}
\newcommand{\CollaborativeContactForce}{F_{\text{contact}}}
\newcommand{\CollectedPhotocharge}{Q}
\newcommand{\CollectionCohortCost}{C_{\text{cohort}}}
\newcommand{\CollectionStateVisitationDistribution}{p^{\pi_{\text{col}}}}
\newcommand{\CollectiveCallStartupLatency}{\alpha_{\text{eff}}}
\newcommand{\CollectivePayloadSize}{M}
\newcommand{\CollectiveTensorSize}{M_{\text{coll}}}
\newcommand{\CollisionHullCount}{N_{\text{hulls}}}
\newcommand{\CollocationDefect}{\Delta}
\newcommand{\ColumnAccessLatency}{t_{\text{CL}}}
\newcommand{\ColumnModeComponentVector}{\mathbf{b}_s}
\newcommand{\ColumnModeFactorMatrix}{\mathbf{B}}
\newcommand{\ColumnModeFactorSlice}{\mathbf{b}}
\newcommand{\ColumnParallelWeightMatrix}{\mathbf{A}}
\newcommand{\CombinedBatch}{B_{\text{total}}}
\newcommand{\CombinedPlanValidationAllowance}{t_{\text{validate}}}
\newcommand{\CommandComponentCount}{N_c}
\newcommand{\CommandRateCeiling}{r}
\newcommand{\CommandTransportTime}{T_{\text{bus}}}
\newcommand{\CommandedActuatorEffort}{u_{\text{cmd}}}
\newcommand{\CommandedApproachAcceleration}{a_{\text{cmd}}}
\newcommand{\CommandedJointConfiguration}{\mathbf{q}_{\text{cmd}}}
\newcommand{\CommandedJointCount}{N_j}
\newcommand{\CommandedJointTorque}{\tau}
\newcommand{\CommandedJointTorqueSlew}{\dot{\tau}}
\newcommand{\CommandedTrackedPosition}{r_{\text{cmd}}}
\newcommand{\CommandedTractiveForce}{F_{\text{cmd}}}
\newcommand{\CommitBatchRecordCount}{N_{\text{batch}}}
\newcommand{\CommitmentInstant}{t_{\text{commit}}}
\newcommand{\CommitmentPathPosition}{q_{c}}
\newcommand{\CommonPositionShift}{\Delta}
\newcommand{\CommunicationComputeRatio}{\rho}
\newcommand{\CommunicationIntensity}{\text{CI}}
\newcommand{\CommunicationSlowdownFactor}{r}
\newcommand{\CommunicationTime}{T_{\text{comm}}}
\newcommand{\CommunicationTimeFraction}{f}
\newcommand{\CompactedContextLength}{S_{\text{comp}}}
\newcommand{\CompactionBoundaryCount}{k}
\newcommand{\CompactionBoundaryIndex}{i}
\newcommand{\CompactionCycleTurnCount}{n_{\text{cycle}}}
\newcommand{\CompactionCycleTurnIndex}{i}
\newcommand{\CompactionLossProbability}{\rho}
\newcommand{\CompactionPassCost}{C_{\text{comp}}}
\newcommand{\CompactionPathCost}{C_{\text{compact}}}
\newcommand{\CompactionPaybackCallCount}{N_{\min}}
\newcommand{\CompactionPerCallSaving}{s}
\newcommand{\CompactionTargetLength}{S_{\text{low}}}
\newcommand{\CompactionTriggerLength}{S_{\text{high}}}
\newcommand{\CompactionUpfrontCost}{U}
\newcommand{\ComparedPeriodAccuracy}{a}
\newcommand{\ComparisonArmTrialCount}{n_{\text{arm}}}
\newcommand{\ComparisonContext}{c}
\newcommand{\ComparisonSampleEmpiricalCdf}{G_{m}}
\newcommand{\ComparisonSampleSize}{m}
\newcommand{\ComparisonTrajectory}{z}
\newcommand{\ComparisonTrajectoryDerivative}{\dot{z}}
\newcommand{\CompensatedEnvironmentState}{\sigma_0'}
\newcommand{\CompensationPostcondition}{\phi}
\newcommand{\CompensationPostconditionSet}{\Phi}
\newcommand{\CompetingKeyCount}{n}
\newcommand{\CompetingKeyLogit}{z}
\newcommand{\CompilationBreakevenCount}{N_{\text{breakeven}}}
\newcommand{\CompilationTime}{T_{\text{compile}}}
\newcommand{\CompiledExecutionTime}{T_{\text{compiled}}}
\newcommand{\CompilerBackendCount}{N_{\text{backend}}}
\newcommand{\CompilerFrontendCount}{M}
\newcommand{\ComplementarityNormalForce}{\lambda_n}
\newcommand{\CompletedRequestCount}{N}
\newcommand{\CompletedRoundIndex}{r}
\newcommand{\CompletionCriteria}{\mathcal{K}_{\text{comp}}}
\newcommand{\CompletionDeadline}{T_{\text{deadline}}}
\newcommand{\CompletionOffset}{c}
\newcommand{\CompliantElementPreload}{F_{\text{preload}}}
\newcommand{\CompliantElementStiffness}{k_{\text{spring}}}
\newcommand{\ComponentAvailability}{A_{\text{component}}}
\newcommand{\ComponentFailureRate}{\lambda}
\newcommand{\ComponentHazardRate}{h}
\newcommand{\ComponentMttf}{\text{MTTF}_{\text{component}}}
\newcommand{\ComponentReliability}{R_{\text{single}}}
\newcommand{\ComposedChainTransform}{\mathbf{T}_{AC}}
\newcommand{\ComposedFunctionInput}{x}
\newcommand{\ComposedFunctionOutput}{y}
\newcommand{\ComposedMechanismCount}{k}
\newcommand{\CompoundScalingCoefficient}{\phi}
\newcommand{\CompressedCommunicationTime}{T_{\text{compressed}}}
\newcommand{\CompressedGradientUpdate}{\mathbf{v}}
\newcommand{\CompressedGradientUpdateElement}{v}
\newcommand{\CompressedOnlyCorrectCount}{n_{\text{comp}}}
\newcommand{\CompressionRatio}{r_{\text{comp}}}
\newcommand{\ComputationalGraph}{G}
\newcommand{\ComputeBudgetConstraint}{g}
\newcommand{\ComputeChipPower}{P_{\text{chip}}}
\newcommand{\ComputeConstrainedLagrangian}{\mathcal{L}_{\text{Lagrange}}}
\newcommand{\ComputeConstraintMultiplier}{\lambda}
\newcommand{\ComputeDemandVolume}{Q}
\newcommand{\ComputeLimitedSampleRate}{R_{\text{compute}}}
\newcommand{\ComputeOptimalTokenCount}{D_{\text{opt}}}
\newcommand{\ComputeUnitCost}{P}
\newcommand{\ConcordantTaskCount}{n}
\newcommand{\ConcurrentTrajectories}{N_{\text{traj}}}
\newcommand{\ConditionalDamageProbability}{p}
\newcommand{\ConditionalDistribution}{p(y \mid x)}
\newcommand{\ConditionalFlowMap}{\psi}
\newcommand{\ConditionalVelocityField}{v}
\newcommand{\ConditioningTokenPrefix}{x}
\newcommand{\ConductorCurrent}{I}
\newcommand{\ConeLimitStepSize}{\tau}
\newcommand{\ConfidenceCalibrationDataset}{\mathcal{D}_{\text{cal}}}
\newcommand{\ConfidenceCriticalQuantile}{z_{\alpha/2}}
\newcommand{\ConfidenceLevel}{C}
\newcommand{\ConfidentialityLabel}{\kappa}
\newcommand{\ConfigurationSpace}{\mathcal{C}}
\newcommand{\ConfirmationHitCount}{M}
\newcommand{\ConfirmationWindowCount}{N_{\text{conf}}}
\newcommand{\ConfluentVandermondeMatrix}{\mathbf{M}}
\newcommand{\ConformalMiscoverageRate}{\epsilon}
\newcommand{\ConformalPredictionSet}{\mathcal{C}}
\newcommand{\ConformalQuantileRank}{k_{\epsilon}}
\newcommand{\ConformalScoreQuantile}{\widehat{q}_{1-\epsilon}}
\newcommand{\ConservativePenaltyWeight}{\alpha_{\text{CQL}}}
\newcommand{\ConservativeSamplingDistribution}{\mu}
\newcommand{\ConsoleCommunicationTime}{T_{\text{comm}}}
\newcommand{\ConsolidationOverheadTime}{T_{\text{overhead}}}
\newcommand{\ConsolidationStride}{c}
\newcommand{\ConstantDivisorGrpoObjective}{\widehat{\mathcal{J}}_{\text{const}}}
\newcommand{\ConstantHazardRate}{\lambda}
\newcommand{\ConstrainedCallLatency}{T_{\text{constrained}}}
\newcommand{\ConstrainedDecodingAutomaton}{\mathcal{D}}
\newcommand{\ConstrainedParameterVector}{\mathbf{w}}
\newcommand{\ConstrainedTestEnvelope}{\mathcal{S}}
\newcommand{\ConstraintLagrangeMultiplier}{\lambda}
\newcommand{\ConstraintRetentionFraction}{\eta_{\mathcal{C}}}
\newcommand{\ContactApproachSpeed}{v_{\text{approach}}}
\newcommand{\ContactCount}{N_c}
\newcommand{\ContactDeformationDuration}{\Delta t_{\text{def}}}
\newcommand{\ContactDirectionSpeed}{v_c}
\newcommand{\ContactDirectionVelocity}{\dot{x}}
\newcommand{\ContactDriftAcceleration}{a_{\text{drift}}}
\newcommand{\ContactForce}{F_{\text{contact}}}
\newcommand{\ContactForceBarrierFunction}{h_{\text{force}}}
\newcommand{\ContactForceCap}{F_{\text{cap}}}
\newcommand{\ContactForceCeiling}{F_{\max}}
\newcommand{\ContactForceLimit}{F_{\text{limit}}}
\newcommand{\ContactForceMagnitude}{F}
\newcommand{\ContactForceRegularizationWeight}{w_f}
\newcommand{\ContactForceRiseTime}{t_{\text{rise}}}
\newcommand{\ContactGapAcceleration}{\ddot{\phi}}
\newcommand{\ContactGapFunction}{\phi}
\newcommand{\ContactGapVelocity}{\dot{\phi}}
\newcommand{\ContactImpulse}{I}
\newcommand{\ContactJacobianBaseBlock}{\mathbf{J}_{k,b}}
\newcommand{\ContactJacobianJointBlock}{\mathbf{J}_{k,j}}
\newcommand{\ContactLoopResponseTime}{T_c}
\newcommand{\ContactNaturalTimescale}{T_{\text{contact}}}
\newcommand{\ContactNormal}{\hat{\mathbf{n}}}
\newcommand{\ContactNormalDeflection}{x}
\newcommand{\ContactNormalJacobian}{\mathbf{J}_n}
\newcommand{\ContactNormalJacobianDerivative}{\dot{\mathbf{J}}_n}
\newcommand{\ContactNormalPosition}{x}
\newcommand{\ContactNormalVelocity}{v_n}
\newcommand{\ContactPatchRegion}{\mathcal{A}}
\newcommand{\ContactPointForce}{\mathbf{f}}
\newcommand{\ContactPointIndex}{i}
\newcommand{\ContactPointJacobian}{\mathbf{J}_{\text{c}}}
\newcommand{\ContactPointJacobianDerivative}{\dot{\mathbf{J}}_{\text{c}}}
\newcommand{\ContactPointOffset}{\mathbf{r}}
\newcommand{\ContactPointPosition}{x}
\newcommand{\ContactPointTorque}{\boldsymbol{\tau}}
\newcommand{\ContactReactionForce}{F}
\newcommand{\ContactResponseLatency}{t_{\text{resp}}}
\newcommand{\ContactStiffness}{k_{\text{contact}}}
\newcommand{\ContactTorqueCeiling}{\tau_{\max}}
\newcommand{\ContactTripwireForce}{F_{\text{trip}}}
\newcommand{\ContactWrench}{\mathbf{w}}
\newcommand{\ContactWrenchCeiling}{\mathbf{w}_{\max}}
\newcommand{\ContactWrenchEnvelope}{\mathbf{w}_{\text{contact}}}
\newcommand{\ContactWrenchTransform}{\mathbf{X}_k^*}
\newcommand{\ContactYieldDeadline}{t_{\text{yield}}}
\newcommand{\ContainerInnerRadius}{R}
\newcommand{\ContainmentForceCeiling}{F_{\max}}
\newcommand{\ContendingApplicationCount}{N}
\newcommand{\ContentionCoefficient}{\sigma_{\text{cont}}}
\newcommand{\ContextChunkTokenCount}{n}
\newcommand{\ContextHiddenRepresentation}{\mathbf{h}_{\text{context}}}
\newcommand{\ContextParallelDegree}{c}
\newcommand{\ContextParallelRankIndex}{i}
\newcommand{\ContextSaveTime}{t_{\text{context\_save}}}
\newcommand{\ContextWindow}{S_{\max}}
\newcommand{\ContinuationCount}{K}
\newcommand{\ContinuationIndex}{i}
\newcommand{\ContinuationReturnStandardDeviation}{\sigma}
\newcommand{\ContinuityCorrectedCrossProduct}{A}
\newcommand{\ContinuousActionComponent}{a}
\newcommand{\ContinuousActionSpace}{\mathcal{A}}
\newcommand{\ContinuousActionVector}{\mathbf{a}}
\newcommand{\ContinuousCurrent}{I_{\text{cont}}}
\newcommand{\ContinuousFactorialFunction}{\Gamma}
\newcommand{\ContinuousMeasurementNoiseIntensity}{\mathbf{R}_{\text{cont}}}
\newcommand{\ContinuousMotionModel}{\mathbf{f}}
\newcommand{\ContinuousOutcome}{\mathbf{x}}
\newcommand{\ContinuousRandomVariable}{\mathbf{X}}
\newcommand{\ContinuousStateTransitionMatrix}{\boldsymbol{\Phi}}
\newcommand{\ContinuousTorque}{\tau_{\text{cont}}}
\newcommand{\ContractedBarrierFunction}{h_{\text{contracted}}}
\newcommand{\ControlAffineDriftField}{\mathbf{f}}
\newcommand{\ControlAffineInputField}{\mathbf{g}}
\newcommand{\ControlCommand}{\mathbf{u}}
\newcommand{\ControlCommandSpace}{\mathcal{U}}
\newcommand{\ControlConversionRate}{\hat{p}_A}
\newcommand{\ControlCycleIndex}{i}
\newcommand{\ControlInput}{\mathbf{u}}
\newcommand{\ControlInputDimension}{m}
\newcommand{\ControlInputLowerLimit}{\mathbf{u}_{\min}}
\newcommand{\ControlInputSet}{\mathcal{U}}
\newcommand{\ControlInputUpperLimit}{\mathbf{u}_{\max}}
\newcommand{\ControlInputWindow}{\mathbf{u}_{[t, t+\Delta t]}}
\newcommand{\ControlSampleIndex}{k}
\newcommand{\ControlSampleSize}{m_A}
\newcommand{\ControlSetpointPeriod}{\Delta t_{\text{ctrl}}}
\newcommand{\ControlStepIndex}{t}
\newcommand{\ControlTaskIndex}{i}
\newcommand{\ControllabilityMatrix}{\mathbf{C}_{\text{ctrb}}}
\newcommand{\ControlledStopCommand}{\mathbf{u}_{\text{stop}}}
\newcommand{\ControllerReactionDelay}{T_{\text{react}}}
\newcommand{\ConversationTurnIndex}{i}
\newcommand{\ConverterLockoutVoltage}{V_{\text{uvlo}}}
\newcommand{\ConveyorSpeed}{v_{\text{conv}}}
\newcommand{\ConveyorSpeedBound}{v_{\text{conv}}}
\newcommand{\ConvolutionActivation}{H}
\newcommand{\ConvolutionTimeInstant}{t'}
\newcommand{\CookedTokenKeyVector}{\mathbf{k}_{\text{cooked}}}
\newcommand{\CookedTokenQueryVector}{\mathbf{q}_{\text{cooked}}}
\newcommand{\CoolantHeatLoad}{P_{\text{thermal}}}
\newcommand{\CoolantMassFlowRate}{\dot{m}}
\newcommand{\CoolantTemperature}{T}
\newcommand{\CoolingEnergy}{E_{\text{cooling}}}
\newcommand{\CoordinateFrameEmbedding}{\mathbf{e}_{\text{frame}}}
\newcommand{\CoordinationLatency}{L_{\text{lat,coordination}}}
\newcommand{\CoordinationOverhead}{h}
\newcommand{\CopperIronThermalResistance}{R_{\text{th,cu-iron}}}
\newcommand{\CopperReferenceTemperature}{T_0}
\newcommand{\CopperTemperatureCoefficient}{\alpha_{\text{Cu}}}
\newcommand{\CopperThermalCapacitance}{C_{\text{cu}}}
\newcommand{\CopperThermalTimeConstant}{\tau_{\text{th,cu}}}
\newcommand{\CoreAmbientThermalResistance}{R_{\text{th,ca}}}
\newcommand{\CoreRailVoltageDroop}{\Delta V_{\text{droop}}}
\newcommand{\CoreThermalCapacitance}{C_{\text{core}}}
\newcommand{\CoresetBudget}{K}
\newcommand{\CoriolisCentrifugalMatrix}{\mathbf{C}}
\newcommand{\CorrectCandidateTrialPassProbability}{p_{g}}
\newcommand{\CorrectClassIndex}{c}
\newcommand{\CorrectClassLogit}{z_{c}}
\newcommand{\CorrectClassProbability}{\hat{y}_{c}}
\newcommand{\CorrectnessReward}{R_{\text{corr}}}
\newcommand{\CorrelationCoefficient}{\rho}
\newcommand{\CorruptedAttentionScoreMatrix}{\mathbf{S}_{\text{corrupt}}}
\newcommand{\CorruptedModelWeight}{w'}
\newcommand{\CostAnomalyScore}{Z}
\newcommand{\CostBudgetUsedFraction}{\rho_C}
\newcommand{\CostCeiling}{C_{\max}}
\newcommand{\CostPerAcceptedTask}{C_{\text{eff}}}
\newcommand{\CostPerEmittedArtifact}{C_{\text{emit}}}
\newcommand{\CostToGo}{C}
\newcommand{\CoulombFrictionCoefficient}{\mu}
\newcommand{\CoulombFrictionForce}{F_{\text{friction}}}
\newcommand{\CountedFailureIndicator}{e}
\newcommand{\CovariateDriftBound}{\mathcal{O}(S^2 \epsilon)}
\newcommand{\CoverageFactor}{k}
\newcommand{\CpuEnergy}{E_{\text{CPU}}}
\newcommand{\CredibleBrakingDeceleration}{a_{\text{brake}}}
\newcommand{\CreditWindowCapacity}{N_{\text{win}}}
\newcommand{\CriticActionReturnEstimate}{Q_{\phi}}
\newcommand{\CriticApproximationError}{\epsilon}
\newcommand{\CriticModel}{M_{\text{value}}}
\newcommand{\CriticParameters}{\phi}
\newcommand{\CriticReturnEstimate}{V_{\phi}}
\newcommand{\CriticalBatchSize}{B^{*}}
\newcommand{\CriticalConstraint}{c}
\newcommand{\CriticalPathDuration}{T_{\text{crit}}}
\newcommand{\CriticalSectionIndex}{s}
\newcommand{\CriticalSectionWcet}{C^{\text{cs}}}
\newcommand{\CriticalTrackingErrorBound}{\epsilon_{\text{crit}}}
\newcommand{\CriticalTransitDistance}{d_{\text{crit}}}
\newcommand{\CrossEntropyLevelThreshold}{\gamma}
\newcommand{\CrossEntropyLoss}{\mathcal{L}_{\text{CE}}}
\newcommand{\CrossoverFrequency}{\omega_c}
\newcommand{\CruiseSpeed}{v_{c}}
\newcommand{\CumulativeArrivals}{A}
\newcommand{\CumulativeCompletions}{C}
\newcommand{\CumulativeIncidentCount}{N}
\newcommand{\CumulativeLogLikelihoodRatio}{\Lambda}
\newcommand{\CumulativeScheduleStepIndex}{s}
\newcommand{\CumulativeTransmittance}{T}
\newcommand{\CumulativeWorkCost}{C}
\newcommand{\CurrentBinProportion}{A}
\newcommand{\CurrentDistribution}{P_t}
\newcommand{\CurrentFeatureMean}{\mu_{\text{curr}}}
\newcommand{\CurrentFeatureStandardDeviation}{\sigma_{\text{curr}}}
\newcommand{\CurrentLayerWidth}{n_{\ell}}
\newcommand{\CurrentModelParameters}{\theta_{\text{old}}}
\newcommand{\CurrentMonotonicTime}{t_{\text{now,mono}}}
\newcommand{\CurrentNodeIndex}{j}
\newcommand{\CurrentPeriodCost}{C_{\text{current}}}
\newcommand{\CurrentStateDigest}{h_{\text{state},t}}
\newcommand{\CurrentStateEstimate}{\hat{\mathbf{x}}_{t_{\text{current}}}}
\newcommand{\CurrentTime}{t_{\text{now}}}
\newcommand{\CurrentWallClockTime}{t_{\text{current}}}
\newcommand{\CutCrossingDataVolume}{V_{\text{cut}}}
\newcommand{\CvaeEncoderParameters}{\phi}
\newcommand{\CvaeRecognitionEncoder}{q_\phi}
\newcommand{\CycleAveragePowerCeiling}{\bar{P}_{\max}}
\newcommand{\CycleGuardTime}{t_{\text{guard}}}
\newcommand{\CylinderForce}{F_{\text{cyl}}}
\newcommand{\DailyAccountQueryCount}{q_{\text{daily}}}
\newcommand{\DailyQueryVolume}{Q_{\text{day}}}
\newcommand{\DamageEventCount}{N_{\text{damage}}}
\newcommand{\DamageProbabilityTolerance}{\epsilon}
\newcommand{\DamageProbabilityUpperBound}{p_U}
\newcommand{\DamagingOutcomeIndicator}{Y}
\newcommand{\DampedLeastSquaresPseudoinverse}{\mathbf{J}_{\lambda}^\dagger}
\newcommand{\DampedStepConfiguration}{\mathbf{q}_\lambda}
\newcommand{\DampingRatio}{\zeta}
\newcommand{\DataAcquisitionCost}{C_{\text{acquire}}}
\newcommand{\DataDebtGrowthRate}{r}
\newcommand{\DataEgressCost}{C_{\text{egress}}}
\newcommand{\DataFieldBitCount}{B_{\text{data},i}}
\newcommand{\DataInformationContent}{\mathcal{I}}
\newcommand{\DataLabelingCost}{C_{\text{label}}}
\newcommand{\DataLoaderWorkerCount}{W}
\newcommand{\DataMovementEnergyFraction}{q}
\newcommand{\DataParallelDegree}{N_{\text{DP}}}
\newcommand{\DataPhaseBitRate}{R_{\text{data}}}
\newcommand{\DataPipelineProcessingCost}{C_{\text{process}}}
\newcommand{\DataProcessingCost}{C_{\text{process}}}
\newcommand{\DataScaleCoefficient}{B}
\newcommand{\DataScalingExponent}{\beta}
\newcommand{\DataScalingLossFactor}{D^{-\beta}}
\newcommand{\DataStallFraction}{f_{\text{stall}}}
\newcommand{\DataStorageCost}{C_{\text{store}}}
\newcommand{\DataSupplyRate}{R_{\text{data}}}
\newcommand{\DataTaxonomyAxis}{\mathsf{Data}}
\newcommand{\DataVolume}{D_{\text{vol}}}
\newcommand{\DatasetQuery}{f}
\newcommand{\DatasetQueryResult}{v}
\newcommand{\DatasetShardCount}{K_{\text{shards}}}
\newcommand{\DatasetSize}{D}
\newcommand{\DatasetTransferTime}{T}
\newcommand{\DcBusBulkCapacitance}{C_{\text{bus}}}
\newcommand{\DcBusOvervoltageThreshold}{V_{\text{max\_safe}}}
\newcommand{\DcBusVoltage}{V_{\text{bus}}}
\newcommand{\DcRailVoltage}{V_{\text{rail}}}
\newcommand{\DeadTimeCycleCount}{N_{\text{dtg}}}
\newcommand{\DeadTimeDqVoltageError}{\Delta V_{d,q}}
\newcommand{\DeadTimeSafetyMargin}{t_{\text{margin}}}
\newcommand{\DeadTimeTickPeriod}{T_{\text{dtg}}}
\newcommand{\DeadTimeVoltageError}{\Delta V_{\text{phase}}}
\newcommand{\DeadlineInstant}{t_{\text{deadline}}}
\newcommand{\DebiasingTotalLoss}{\mathcal{L}_{\text{total}}}
\newcommand{\DebounceFrameCount}{N}
\newcommand{\DecisionProcessState}{s}
\newcommand{\DecisionScore}{s_{\text{dec}}}
\newcommand{\DecisionStepIndex}{k}
\newcommand{\DecodeArithmeticIntensity}{I_{\text{decode}}}
\newcommand{\DecodeBatchSize}{B_{\text{dec}}}
\newcommand{\DecodeInterval}{T_{\text{decode}}}
\newcommand{\DecodeRequestSet}{\mathcal{D}}
\newcommand{\DecodeTokenTimeFloor}{T_{\text{token}}}
\newcommand{\DecoderEvaluationCount}{N_{\text{eval}}}
\newcommand{\DecoderPassTime}{t_{\text{pass}}}
\newcommand{\DecodingConstraintState}{q}
\newcommand{\DecomposedTensor}{\mathcal{Y}}
\newcommand{\DecomposedTensorEntry}{y_{ijt}}
\newcommand{\DecouplingCapacitance}{C}
\newcommand{\DecouplingDriftVector}{\mathbf{b}}
\newcommand{\DecouplingMatrix}{\mathbf{E}}
\newcommand{\DecouplingMatrixElement}{E}
\newcommand{\DedicatedHourlyFixedCost}{C_{\text{fixed}}}
\newcommand{\DedicatedVariableTokenCost}{c_{\text{ded}}}
\newcommand{\DefectiveActionProbability}{p_{\text{bad}}}
\newcommand{\DefinitionSerializedSize}{S}
\newcommand{\DeflectionComplianceAllowance}{\delta_{\text{deflect}}}
\newcommand{\DegradedFrictionCoefficient}{\mu_{\text{fault}}}
\newcommand{\DegradedStepTime}{T_{\text{slow}}}
\newcommand{\DelassusOperator}{\mathbf{A}_{\text{Delassus}}}
\newcommand{\DelayPhaseLag}{\Delta \phi}
\newcommand{\DelayTravelDistance}{d_{\text{delay}}}
\newcommand{\DelayWindowIntegrationTime}{\sigma}
\newcommand{\DelayedObservation}{\mathbf{y}_{t_0}}
\newcommand{\DelegatedAllocationAmount}{b}
\newcommand{\DelegationTokenMultiple}{r}
\newcommand{\DeliveredActuatorTorque}{\tau_{\text{act}}}
\newcommand{\DeliveredCapacityFraction}{u}
\newcommand{\DemandCap}{x_{\max}}
\newcommand{\DemandPriceElasticity}{\epsilon_{\text{elast}}}
\newcommand{\DemandThreshold}{x}
\newcommand{\DemonstratedTargetA}{\mathbf{y}_A}
\newcommand{\DemonstratedTargetB}{\mathbf{y}_B}
\newcommand{\DemonstrationActionDistribution}{p}
\newcommand{\DemonstrationActionLabel}{\mathbf{a}}
\newcommand{\DemonstrationArchiveActionDistribution}{p_{\text{demo}}}
\newcommand{\DemonstrationChunkDistribution}{p_{\text{data}}}
\newcommand{\DemonstrationDataset}{\mathcal{D}_{\text{demo}}}
\newcommand{\DemonstrationRetentionRate}{R}
\newcommand{\DemonstratorAction}{\mathbf{a}^{*}}
\newcommand{\DemonstratorActionComponent}{a}
\newcommand{\DenseEvaluationEnergy}{E_{\text{eval}}}
\newcommand{\DenseEvaluationRate}{f_{\text{eval}}}
\newcommand{\DenseVoxelGridMemory}{M_{\text{dense}}}
\newcommand{\DepartmentQuotaLimit}{Q_{\text{department}}}
\newcommand{\DependencyGraphEdgeSet}{E}
\newcommand{\DependencyGraphVertex}{v}
\newcommand{\DependencyGraphVertexSet}{V}
\newcommand{\DepletedBusVoltage}{V_{\text{low}}}
\newcommand{\DeploymentAge}{t}
\newcommand{\DeploymentDistribution}{p_{\text{deploy}}}
\newcommand{\DeploymentDuration}{T_{\text{deployment}}}
\newcommand{\DepthBinCount}{D}
\newcommand{\DepthBinDistribution}{\boldsymbol{\alpha}_{u, v}}
\newcommand{\DepthBinIndex}{k}
\newcommand{\DepthBinLogits}{\mathbf{d}_{u, v}}
\newcommand{\DepthBinProbability}{\alpha_{u, v}}
\newcommand{\DepthCalibrationScale}{s}
\newcommand{\DepthCalibrationShift}{t}
\newcommand{\DepthCriticalPathLatency}{T^{\text{depth}}}
\newcommand{\DepthFrameRate}{f_{\text{cam}}}
\newcommand{\DepthHypothesis}{d}
\newcommand{\DepthModeComponentVector}{\mathbf{c}_s}
\newcommand{\DepthModeFactorMatrix}{\mathbf{C}}
\newcommand{\DepthModeFactorSlice}{\mathbf{c}}
\newcommand{\DepthRayCount}{N_{\text{rays}}}
\newcommand{\DepthScalingRatio}{\alpha}
\newcommand{\DepthStandardDeviation}{\sigma_z}
\newcommand{\DerivativeControlEffort}{\mathbf{u}_{d}}
\newcommand{\DerivativeFilterTimeConstant}{T_{f}}
\newcommand{\DerivativeGainMatrix}{\mathbf{K}_{d}}
\newcommand{\DerivativeOperator}{d}
\newcommand{\DerivativeSplineControlPoint}{\mathbf{v}}
\newcommand{\DerivedMemoryEntry}{c}
\newcommand{\DerivedRecord}{y}
\newcommand{\DesignLatencyQuantile}{Q_{1-\epsilon}}
\newcommand{\DesiredContactPosition}{x_{\text{des}}}
\newcommand{\DesiredContactVelocity}{\dot{x}_{\text{des}}}
\newcommand{\DesiredTaskAcceleration}{\ddot{\mathbf{x}}_d}
\newcommand{\DesiredTaskPosition}{\mathbf{x}_d}
\newcommand{\DesiredTaskSpaceAcceleration}{\ddot{\mathbf{x}}^{\text{des}}}
\newcommand{\DesiredTaskVelocity}{\dot{\mathbf{x}}_d}
\newcommand{\DestinationRankIndex}{j}
\newcommand{\DetectionCount}{n_{\text{det}}}
\newcommand{\DetectionInterval}{t_{\text{detect}}}
\newcommand{\DetectionMeasurementNoiseCovariance}{\boldsymbol{\Sigma}_{\text{meas},j}}
\newcommand{\DetectionRangeShortfall}{\Delta d_{\text{detect}}}
\newcommand{\DetectionTimestamp}{t_{\text{det}}}
\newcommand{\DetectorMissProbability}{p_{\text{miss}}}
\newcommand{\DeterministicPolicy}{\mu_{\theta}}
\newcommand{\DevelopmentIterationCount}{N_{\text{dev}}}
\newcommand{\DeviationDisadvantage}{u}
\newcommand{\DeviceCount}{N}
\newcommand{\DeviceEnergy}{E_{\text{device}}}
\newcommand{\DeviceHardwareTime}{T_{\text{hw}}}
\newcommand{\DeviceMemoryCapacity}{M_{\text{device}}}
\newcommand{\DevicePower}{P_{\text{device}}}
\newcommand{\DeviceRequestCapacity}{Q_{\text{req,max}}}
\newcommand{\DeviceSilentCorruptionProbability}{p}
\newcommand{\DiagnosticCoverage}{C_{\text{diag}}}
\newcommand{\DictionaryCoefficientMatrix}{\mathbf{C}}
\newcommand{\DifferentiabilityClass}{C}
\newcommand{\DifferentialEntropy}{h}
\newcommand{\DiffusionCumulativeSchedule}{\bar{\alpha}}
\newcommand{\DiffusionGaussianNoise}{\boldsymbol{\epsilon}}
\newcommand{\DiffusionMatchingLoss}{\mathcal{L}_{\text{diff}}}
\newcommand{\DiffusionNoiseVariance}{\beta}
\newcommand{\DiffusionStepCount}{N}
\newcommand{\DiffusionStepIndex}{k}
\newcommand{\DiffusionStepRetention}{\alpha}
\newcommand{\DiffusionTimeCoordinate}{t_{\text{diff}}}
\newcommand{\DirectAxisCurrent}{i_d}
\newcommand{\DirectAxisInductance}{L_d}
\newcommand{\DirectAxisVoltage}{v_d}
\newcommand{\DirectionalCosineMatrix}{\mathbf{R}}
\newcommand{\DirectionalDerivativeStep}{\epsilon}
\newcommand{\DisadvantagedGroupClassificationThreshold}{\gamma_{\text{cls},g=\text{B}}}
\newcommand{\DiscordantPairCount}{n_{\text{disc}}}
\newcommand{\DiscordantPairFraction}{\psi}
\newcommand{\DiscountFactor}{\gamma}
\newcommand{\DiscountedReturn}{G}
\newcommand{\DiscountedReturnStepOffset}{j}
\newcommand{\DiscountedStateVisitationDistribution}{d}
\newcommand{\DiscreteLqrFeedbackGain}{\mathbf{K}_{\text{lqr},d}}
\newcommand{\DiscreteLqrQuadraticObjective}{J_d}
\newcommand{\DiscreteOutcome}{x}
\newcommand{\DiscretePlantDynamics}{f}
\newcommand{\DiscreteRandomVariable}{X}
\newcommand{\DiscreteSampleIndex}{k}
\newcommand{\DiscreteStateSpaceInputMatrix}{\mathbf{B}_{d}}
\newcommand{\DiscreteStateSpaceSystemMatrix}{\mathbf{A}_{d}}
\newcommand{\DiscretizationBinCount}{n_{\text{bin}}}
\newcommand{\DisengagedTakeoverResponseTime}{T_{\Sigma,2}}
\newcommand{\DiskBandwidth}{\text{BW}_{\text{disk}}}
\newcommand{\DisparityStandardDeviation}{\sigma_d}
\newcommand{\DispatchAdmissionCeiling}{\Delta_{\text{da,max}}}
\newcommand{\DispatchAdmissionInterval}{\Delta_{\text{da}}}
\newcommand{\DispatchObservationAge}{t_{\text{age}}}
\newcommand{\DispatchedOperationCount}{N_{\text{ops}}}
\newcommand{\DisplayPipelineLatency}{t_{\text{disp}}}
\newcommand{\DispreferredReferenceRelativeScore}{\Delta_l}
\newcommand{\DispreferredTrajectory}{\tau_l}
\newcommand{\DistanceEstimateStandardDeviation}{\sigma}
\newcommand{\DistanceMeasurement}{z}
\newcommand{\DistanceNormOrder}{p}
\newcommand{\DistanceQueryPoint}{\mathbf{y}}
\newcommand{\DistillationClassProbability}{p^{(T_{\text{distill}})}}
\newcommand{\DistillationLoss}{\mathcal{L}_{\text{distill}}}
\newcommand{\DistillationLossWeight}{\gamma_{\text{KD}}}
\newcommand{\DistillationTemperature}{T_{\text{distill}}}
\newcommand{\DistortedImageAbscissa}{x_d}
\newcommand{\DistortedImageOrdinate}{y_d}
\newcommand{\DistributedStepTime}{T_{\text{step}}}
\newcommand{\DisturbanceAccelerationBound}{a_{\text{dist}}}
\newcommand{\DisturbanceBasisCoefficient}{\psi}
\newcommand{\DisturbanceBasisCount}{K}
\newcommand{\DisturbanceBasisFunction}{B}
\newcommand{\DisturbanceBudget}{\Delta_{w}}
\newcommand{\DisturbanceDimension}{p}
\newcommand{\DisturbanceForceBound}{d_{\max}}
\newcommand{\DisturbanceParameterSet}{\Psi}
\newcommand{\DisturbanceParameterVector}{\boldsymbol{\psi}}
\newcommand{\DisturbanceTrajectory}{w_{\text{dist}}}
\newcommand{\DivergenceInstant}{t_{\text{div}}}
\newcommand{\DivergenceMeasure}{\mathcal{D}}
\newcommand{\DivergenceTolerance}{\delta_{\text{tol}}}
\newcommand{\DmaQueueTime}{t_{\text{DMA}}}
\newcommand{\DocumentPayloadFraction}{q}
\newcommand{\DomainRandomizationDistribution}{\mathcal{D}_{\text{DR}}}
\newcommand{\DomainRandomizationObjective}{J_{\text{DR}}}
\newcommand{\DominantComponentEnergy}{E_{\text{dominant}}}
\newcommand{\DominantShare}{d}
\newcommand{\DoorOpenReward}{r_{\text{open}}}
\newcommand{\DoubleIntegratorPosition}{p}
\newcommand{\DoubleIntegratorPositionDerivative}{\dot{p}}
\newcommand{\DoubleIntegratorVelocity}{v}
\newcommand{\DoubleIntegratorVelocityDerivative}{\dot{v}}
\newcommand{\DoubleTreeAllReduceTime}{T_{\text{double-tree}}}
\newcommand{\DownstreamStageLatency}{Y}
\newcommand{\DpoLoss}{\mathcal{L}_{\text{DPO}}}
\newcommand{\DraftAcceptanceRate}{\alpha}
\newcommand{\DraftCandidateToken}{\tilde{x}}
\newcommand{\DraftModelDistribution}{q_{\phi}}
\newcommand{\DraftPositionAcceptanceProbability}{\alpha_{\text{spec}, j}}
\newcommand{\DraftSamplingDistribution}{q}
\newcommand{\DraftTokenAcceptanceProbability}{\alpha_{\text{acc}}}
\newcommand{\DraftTokenCostRatio}{\beta}
\newcommand{\DraftTokenCount}{\gamma}
\newcommand{\DraftedToken}{T}
\newcommand{\DragonflyGlobalChannelCount}{h}
\newcommand{\DragonflyGroupRouterCount}{a}
\newcommand{\DragonflyTerminalPortCount}{p}
\newcommand{\DrainSourceVoltage}{V_{\text{ds}}}
\newcommand{\DriftElapsedTime}{t_{\text{drift}}}
\newcommand{\DriftImpactTime}{t_{\text{impact}}}
\newcommand{\DriftLieDerivativeOperator}{L_{\mathbf{f}}}
\newcommand{\DriftSpeedBound}{v_{\text{drift}}}
\newcommand{\DriftTestSampleSize}{n}
\newcommand{\DriftVelocityBound}{v_{\text{drift}}}
\newcommand{\DriveBrakingForceCeiling}{F}
\newcommand{\DriveBrakingTorqueCeiling}{\tau}
\newcommand{\DrivenWheelLoadFraction}{\phi_{\text{drive}}}
\newcommand{\DriverInterruptLatency}{t_{\text{driver\_irq}}}
\newcommand{\DrivetrainAntiresonanceFrequency}{f_{\text{anti}}}
\newcommand{\DrivetrainResonanceFrequency}{f_{\text{res}}}
\newcommand{\DroopedSupplyVoltage}{V_{\text{droop}}}
\newcommand{\DropletDiameter}{d_{\text{droplet}}}
\newcommand{\DropoutProbability}{p_{\text{drop}}}
\newcommand{\DualNumberInfinitesimal}{\epsilon}
\newcommand{\DuplicateEffectProbability}{p_{\text{dup}}}
\newcommand{\DurableAcknowledgmentTime}{t_{\text{ack}}}
\newcommand{\DurableStoreWriteBandwidth}{\text{BW}_{\text{store}}}
\newcommand{\DutyCyclePeriod}{T_{\text{period}}}
\newcommand{\DynamicPower}{P_{\text{dynamic}}}
\newcommand{\DynamicReachableSet}{\mathcal{R}}
\newcommand{\DynamicsRealityGap}{\Delta_{\text{dyn}}}
\newcommand{\EagerExecutionTime}{T_{\text{eager}}}
\newcommand{\EarlierBaseFlangeTransform}{\mathbf{T}_{\text{base}, k}^{\text{flange}}}
\newcommand{\EarlierCameraTargetTransform}{\mathbf{T}_{\text{cam}, k}^{\text{target}}}
\newcommand{\EarlierControlStepIndex}{t'}
\newcommand{\EarlierWorkerCount}{k}
\newcommand{\EarliestConflictTime}{t_{\text{conflict}}}
\newcommand{\EarthReferenceFrame}{\mathcal{F}_{\text{earth}}}
\newcommand{\EchoFactor}{e}
\newcommand{\EchoRoundTripTime}{t_{\text{rt}}}
\newcommand{\EditGrantRights}{\mathcal{R}_{\Gamma_{\text{edit}}}}
\newcommand{\EditPhaseCapabilityGrant}{\Gamma_{\text{edit}}}
\newcommand{\EffectiveAdmissionCeiling}{Q_{\text{effective}}}
\newcommand{\EffectiveApiOutputTokenPrice}{c_{\text{API}}}
\newcommand{\EffectiveBrakingDelay}{T_{\text{eff}}}
\newcommand{\EffectiveBranchingFactor}{b_{\text{eff}}}
\newcommand{\EffectiveConfidentialityLabel}{\kappa_{\text{eff}}}
\newcommand{\EffectiveFleetThroughput}{R_{\text{eff}}}
\newcommand{\EffectiveImpactMass}{m_{\text{eff}}}
\newcommand{\EffectiveIntegrityProvenance}{\iota_{\text{eff}}}
\newcommand{\EffectiveJointInertia}{J_{\text{eff}}}
\newcommand{\EffectiveLossResistance}{R_{\text{eff}}}
\newcommand{\EffectiveSampleSize}{N_{\text{eff}}}
\newcommand{\EffectiveSeriesStiffness}{k_{\text{eff}}}
\newcommand{\EffectiveServiceRate}{\mu_{\text{eff}}}
\newcommand{\EffectiveSpotTrainingCost}{C_{\text{effective}}}
\newcommand{\EffectiveStorageThroughput}{R_{\text{storage,eff}}}
\newcommand{\EffectiveWasteFraction}{W_{\text{effective}}}
\newcommand{\EfficiencyHw}{\eta_{\text{hw}}}
\newcommand{\EgressArrivalRate}{\lambda_{\text{arr}}}
\newcommand{\EgressBufferCapacity}{Q_{\text{max}}}
\newcommand{\EgressPortUtilization}{\rho_{\text{egress}}}
\newcommand{\EgressPrice}{R_{\text{egress/GB}}}
\newcommand{\EgressQueueOccupancy}{Q}
\newcommand{\EgressServiceRate}{\mu}
\newcommand{\ElapsedPlanningPeriods}{n}
\newcommand{\ElasticJointTorque}{\mathbf{z}}
\newcommand{\ElasticMaximumWorkerCount}{N_{\text{max}}}
\newcommand{\ElasticMinimumWorkerCount}{N_{\text{min}}}
\newcommand{\ElasticModalFrequencyMatrix}{\boldsymbol{\Omega}}
\newcommand{\ElasticPotentialEnergy}{E}
\newcommand{\ElasticStrainEnergy}{U_{\text{elastic}}}
\newcommand{\ElasticTorqueSecondDerivative}{\ddot{\mathbf{z}}}
\newcommand{\ElbowSwivelAngle}{\psi}
\newcommand{\ElectricalAngularSpeed}{\omega_e}
\newcommand{\ElectricalResistance}{R}
\newcommand{\ElectricalRotorAngle}{\theta_e}
\newcommand{\ElectricalTimeConstant}{\tau_e}
\newcommand{\ElectricityPrice}{R_{\$/\text{kWh}}}
\newcommand{\ElementStorageSize}{s_{\text{elem}}}
\newcommand{\ElementaryCharge}{q}
\newcommand{\ElementaryOperationCount}{W}
\newcommand{\ElevationAngle}{\phi}
\newcommand{\EligibleCachedPrefixLength}{S_{\text{hit}}}
\newcommand{\EligibleTargetPositionSet}{\mathcal{P}_{\text{elig}}}
\newcommand{\EligibleVectorCount}{N}
\newcommand{\EliteSampleFraction}{\beta}
\newcommand{\EmbeddingDimension}{d}
\newcommand{\EmbeddingShardCount}{N_{\text{shards}}}
\newcommand{\EmergencyStopContact}{S}
\newcommand{\EmergencyStopCount}{n_{\text{estop}}}
\newcommand{\EmittedArtifactCount}{N_{\text{emit}}}
\newcommand{\EmittedTokenCount}{S_{\text{out}}}
\newcommand{\EmpiricalBellmanOperator}{\mathcal{B}}
\newcommand{\EmpiricalExceedanceFraction}{\hat{\zeta}_{u}}
\newcommand{\EmpiricalTimestepAverage}{\hat{\mathbb{E}}}
\newcommand{\EmpiricalTransferDiscrepancy}{\hat{\epsilon}_{\text{gap}}}
\newcommand{\EmptyByteString}{\epsilon}
\newcommand{\EncodedLatentState}{\hat{\mathbf{z}}}
\newcommand{\EncoderAngle}{\theta_{\text{enc}}}
\newcommand{\EncoderBitCount}{n}
\newcommand{\EncoderLatentRepresentation}{\mathbf{z}}
\newcommand{\EncoderVelocityEstimate}{\dot{\theta}_{\text{enc}}}
\newcommand{\EncoderVelocityNoise}{\sigma_{\dot{\theta}_{\text{enc}}}}
\newcommand{\EndEffectorCameraTransform}{\mathbf{T}_{EC}}
\newcommand{\EndEffectorFirstAxisPosition}{x}
\newcommand{\EndEffectorPitchAngle}{\phi_{\text{pitch}}}
\newcommand{\EndEffectorPose}{\mathbf{T}_{WE}}
\newcommand{\EndEffectorRollAngle}{\phi_{\text{roll}}}
\newcommand{\EndEffectorSecondAxisPosition}{y}
\newcommand{\EndEffectorTaskAcceleration}{\ddot{\mathbf{x}}}
\newcommand{\EndEffectorTaskPosition}{\mathbf{x}}
\newcommand{\EndEffectorTaskVelocity}{\dot{\mathbf{x}}}
\newcommand{\EndEffectorThirdAxisPosition}{z}
\newcommand{\EndEffectorTwist}{\mathbf{V}_E}
\newcommand{\EndEffectorVelocity}{\mathbf{v}_e}
\newcommand{\EndEffectorYawAngle}{\phi_{\text{yaw}}}
\newcommand{\EndToEndRequestLatency}{L_{\text{lat,total}}}
\newcommand{\EnergyCrossoverIntensity}{I_{\text{crossover}}}
\newcommand{\EnergyLimitedContactForce}{F_E}
\newcommand{\EnergyPerByteMoved}{E_{\text{move}}}
\newcommand{\EnergyPerOperation}{E_{\text{compute}}}
\newcommand{\EnergyTankBarrierFunction}{h_{\text{energy}}}
\newcommand{\EnergyTankLevel}{E_{\text{tank}}}
\newcommand{\EnergyTankPower}{\dot{E}_{\text{tank}}}
\newcommand{\EnergyTankReserve}{E_{\text{min}}}
\newcommand{\EnforcedCommandLabel}{\mathbf{a}_{\text{enf}, t}}
\newcommand{\EnforcedCommandTap}{a_{\text{enf}}}
\newcommand{\EnforcerComputeTime}{T_{\text{comp}}}
\newcommand{\EnforcerDeadline}{T_{\text{deadline,enf}}}
\newcommand{\EngineerHourlyCost}{C_{\text{engineer}}}
\newcommand{\EngineeringTemperatureCeiling}{T_{\text{ceil}}}
\newcommand{\EnsembleSpreadThreshold}{\sigma_{\text{thresh}}}
\newcommand{\EnsemblingDecayRate}{m}
\newcommand{\EnsemblingWindowLength}{K}
\newcommand{\EntityCount}{N_{\text{entities}}}
\newcommand{\EntityEmbedding}{\mathbf{e}}
\newcommand{\EntropyTemperature}{\alpha}
\newcommand{\EnvelopeCallCount}{N}
\newcommand{\EnvelopeSetupTime}{T_{\text{setup}}}
\newcommand{\EnvironmentCycleTime}{T_{\text{cycle}}}
\newcommand{\EnvironmentFixture}{f}
\newcommand{\EnvironmentLatentDimension}{d_z}
\newcommand{\EnvironmentLatentVector}{\mathbf{z}}
\newcommand{\EnvironmentParameters}{e}
\newcommand{\EnvironmentResetTime}{T_{r}}
\newcommand{\EnvironmentResponseFunction}{g}
\newcommand{\EnvironmentRolloutStepCount}{h}
\newcommand{\EnvironmentTransitionDistribution}{p}
\newcommand{\EpipolarLine}{\mathbf{l}}
\newcommand{\EpochCount}{N_{\text{epochs}}}
\newcommand{\EpochIndex}{n_{\text{epoch}}}
\newcommand{\EquilibriumWindingTemperature}{T_\infty}
\newcommand{\EquivalentSeriesStiffness}{k_{\text{eq}}}
\newcommand{\ErasureDataFragmentCount}{d}
\newcommand{\ErasureParityFragmentCount}{m}
\newcommand{\ErroneousPredictionCost}{C_{\text{error}}}
\newcommand{\ErrorBudgetConsumption}{B}
\newcommand{\ErrorCovarianceDerivative}{\dot{\mathbf{P}}}
\newcommand{\ErrorFeedbackResidual}{\mathbf{e}}
\newcommand{\ErrorFeedbackResidualElement}{e}
\newcommand{\ErrorGrowthRate}{r}
\newcommand{\ErrorRecoveryCost}{C_{\text{recovery}}}
\newcommand{\EscalationDecision}{d}
\newcommand{\EscalationLossMatrix}{\mathbf{L}}
\newcommand{\EscalationThresholdProbability}{p_{\text{threshold}}}
\newcommand{\EssentialMatrix}{\mathbf{E}}
\newcommand{\EstimateEpoch}{t_{\text{est}}}
\newcommand{\EstimatedAcceptanceProbability}{\hat{p}}
\newcommand{\EstimatedAccuracy}{\hat{p}}
\newcommand{\EstimatedCandidateUtility}{\hat{U}}
\newcommand{\EstimatedCleanActionChunk}{\hat{\mathbf{A}}}
\newcommand{\EstimatedCoriolisMatrix}{\hat{\mathbf{C}}}
\newcommand{\EstimatedDamageProbability}{\hat{p}}
\newcommand{\EstimatedDivergenceInstant}{\hat{t}_{\text{div}}}
\newcommand{\EstimatedForceSensorBias}{\hat{b}}
\newcommand{\EstimatedGravitationalTorque}{\hat{\mathbf{g}}}
\newcommand{\EstimatedGripContactForce}{\hat{x}}
\newcommand{\EstimatedHistoryAdvantage}{\hat{A}}
\newcommand{\EstimatedInertiaMatrix}{\hat{\mathbf{M}}}
\newcommand{\EstimatedPairedAcceptanceDifference}{\hat{\Delta}}
\newcommand{\EstimatedPlantState}{\hat{\mathbf{x}}}
\newcommand{\EstimatedPosition}{\hat{\mathbf{p}}}
\newcommand{\EstimatedRemainingReturn}{\hat{V}}
\newcommand{\EstimatedUtilityStandardDeviation}{s}
\newcommand{\EstimatedVelocity}{\hat{\mathbf{v}}}
\newcommand{\EstimatedWindingTemperature}{\hat{T}_{\text{wind}}}
\newcommand{\EstimationErrorCovariance}{\mathbf{P}}
\newcommand{\EstimatorDrawCount}{N}
\newcommand{\EstimatorDrawStandardDeviation}{\sigma}
\newcommand{\EstimatorState}{\mathbf{x}}
\newcommand{\EstimatorStateVector}{\mathbf{x}}
\newcommand{\EstimatorStepIndex}{k}
\newcommand{\EulerIntegralFirstShape}{a}
\newcommand{\EulerIntegralSecondShape}{b}
\newcommand{\EulerIntegralVariable}{t}
\newcommand{\EvaluatedExceedance}{y}
\newcommand{\EvaluationPredicate}{\phi}
\newcommand{\EvaluationSampleCount}{N}
\newcommand{\EvaluationTrialCount}{N}
\newcommand{\EvaluationTrialIndex}{i}
\newcommand{\EventContrastThreshold}{C_{\text{th}}}
\newcommand{\EventDetectionPower}{P_{\text{detect}}}
\newcommand{\EventIndicator}{\mathbf{1}}
\newcommand{\EventPacket}{e}
\newcommand{\EventPolarity}{p}
\newcommand{\EventProcessingEnergy}{E_{\text{event}}}
\newcommand{\EvidenceCaptureInstant}{t_{\text{capture}}}
\newcommand{\EvidenceEpoch}{t_0}
\newcommand{\EvidenceHorizon}{\tau_{\text{ev}}}
\newcommand{\EvidenceLowerBound}{\mathcal{L}_{\text{ELBO}}}
\newcommand{\EvidenceRecordEvent}{e_{\text{obs}}}
\newcommand{\ExactFailureLowerLimit}{p_{L}}
\newcommand{\ExactFailureUpperLimit}{p_{U}}
\newcommand{\ExampleAveragedBatchLoss}{\mathcal{L}_{\text{example}}}
\newcommand{\ExampleIndex}{i}
\newcommand{\ExampleLabel}{y}
\newcommand{\ExceedanceReturnLevel}{z_\epsilon}
\newcommand{\ExceedanceSampleSet}{\mathcal{Y}_u}
\newcommand{\ExceedanceThreshold}{u}
\newcommand{\ExcessDistributionFunction}{F_{u}}
\newcommand{\ExcessForcePenaltyWeight}{\lambda_f}
\newcommand{\ExcessSupportUpperEndpoint}{y_{\max}}
\newcommand{\ExecutedActionStepCount}{T_a}
\newcommand{\ExecutedToolCall}{a}
\newcommand{\ExecutedTrialCount}{N_{\text{trial}}}
\newcommand{\ExecutionHorizon}{H_{\text{exec}}}
\newcommand{\ExecutionNondeterminism}{\xi}
\newcommand{\ExecutionSwitchTime}{T_{\text{switch}}}
\newcommand{\ExogenousDataDistribution}{\mathcal{D}}
\newcommand{\ExpectedCategoryFrequency}{n_i^{\text{exp}}}
\newcommand{\ExpectedCheckingTime}{T_{\text{check}}}
\newcommand{\ExpectedCostLimit}{\delta}
\newcommand{\ExpectedDecisionRisk}{\mathcal{R}}
\newcommand{\ExpectedHistoryActionReturn}{Q}
\newcommand{\ExpectedIrreversibleLoss}{L_A}
\newcommand{\ExpectedNormalMaximum}{m_{N}}
\newcommand{\ExpectedQueryDistribution}{p_{\text{expected}}}
\newcommand{\ExpectedRemainingReturn}{V}
\newcommand{\ExpectedReturnObjective}{J}
\newcommand{\ExpectedRunCompletionTime}{T}
\newcommand{\ExpectedTaskCostSum}{J}
\newcommand{\ExperienceReplayBuffer}{\mathcal{D}}
\newcommand{\ExperimentCount}{N_{\text{exp}}}
\newcommand{\ExperimentUserIndex}{i}
\newcommand{\ExpertCapacityFactor}{C_{\text{cap}}}
\newcommand{\ExpertCount}{N_{\text{experts}}}
\newcommand{\ExpertDiscountedStateVisitationDistribution}{d^{\pi^*}}
\newcommand{\ExpertIndex}{e}
\newcommand{\ExpertSelectionProbability}{p_e}
\newcommand{\ExpertStateVisitationDistribution}{p^{\pi^*}}
\newcommand{\ExpertTokenCount}{B_e}
\newcommand{\ExploitCandidateFraction}{p_{\text{exp}}}
\newcommand{\ExploitTrajectory}{\tau_{\text{hack}}}
\newcommand{\ExploratoryStateVisitationDistribution}{p^{\pi_{\text{expl}}}}
\newcommand{\ExponentBitIndex}{k}
\newcommand{\ExponentialSeriesArgument}{u}
\newcommand{\ExponentialStabilityConstant}{k}
\newcommand{\ExposedCommunicationTime}{T_{\text{comm,exposed}}}
\newcommand{\ExposedUnitCount}{E_{\text{exposure}}}
\newcommand{\ExposureDuration}{t_{\text{exp}}}
\newcommand{\ExposureMidpointTime}{t_{\text{mid}}}
\newcommand{\ExposureMotionDisplacement}{\Delta x_{\text{motion}}}
\newcommand{\ExposureStartTime}{t_{\text{start}}}
\newcommand{\ExposureTravelDistance}{\Delta x}
\newcommand{\ExtendedClassKInfinityFamily}{\mathcal{K}_\infty}
\newcommand{\ExtendedDepthLength}{K_{\text{ext}}}
\newcommand{\ExternalContactTorque}{\boldsymbol{\tau}_{\text{ext}}}
\newcommand{\ExternalDispatchAction}{a_{\text{ext}}}
\newcommand{\ExternalDisturbanceForce}{d}
\newcommand{\ExternalDisturbanceLoad}{\mathbf{d}_{\text{ext}}}
\newcommand{\ExternalJointTorque}{\tau_{\text{ext}}}
\newcommand{\ExternalObjectWrench}{\mathbf{w}_{\text{ext}}}
\newcommand{\ExternalWait}{T_{\text{wait}}}
\newcommand{\ExternalWrench}{\mathbf{F}_{\text{ext}}}
\newcommand{\ExtractionAnomalyClassifier}{f_{\theta}}
\newcommand{\ExtractionQueryCount}{n_{\text{queries}}}
\newcommand{\ExtrinsicCalibrationCovariance}{\boldsymbol{\Sigma}_{\text{ext}}}
\newcommand{\ExtrinsicCovarianceJacobian}{\mathbf{J}_{\text{ext}}}
\newcommand{\ExtrinsicLateralError}{\Delta y}
\newcommand{\ExtrinsicMisalignmentAngle}{\theta_{\text{ext}}}
\newcommand{\EyeInHandCameraMotion}{\mathbf{B}}
\newcommand{\EyeInHandFlangeMotion}{\mathbf{A}}
\newcommand{\EyeInHandUnknownTransform}{\mathbf{X}}
\newcommand{\EyeToHandCameraPose}{\mathbf{B}'}
\newcommand{\EyeToHandFlangePose}{\mathbf{A}'}
\newcommand{\EyeToHandTargetTransform}{\mathbf{Z}}
\newcommand{\EyeToHandUnknownTransform}{\mathbf{X}'}
\newcommand{\FacilityEnergy}{E_{\text{facility}}}
\newcommand{\FacilityHeatRemovalCapacity}{\dot{Q}_{\text{remove,max}}}
\newcommand{\FacilityPower}{P_{\text{facility}}}
\newcommand{\FacilityWaterConsumption}{W_{\text{water}}}
\newcommand{\FactoredIntermediateActivation}{\mathbf{z}}
\newcommand{\FactorizationRank}{k}
\newcommand{\FailureDetectionTime}{T_{\text{detect}}}
\newcommand{\FailureEventCost}{C_{\text{per-failure}}}
\newcommand{\FailureFlagLatency}{\delta_{\text{flag}}}
\newcommand{\FailureMarginFunction}{l}
\newcommand{\FailureModeOccurrenceCount}{n_{f}}
\newcommand{\FailureObservationInterval}{T}
\newcommand{\FailureOverheadFraction}{F_{\text{fail}}}
\newcommand{\FailureRecoveryTime}{T_{\text{recovery}}}
\newcommand{\FailureRegion}{F}
\newcommand{\FailureSet}{\mathcal{F}_{\text{fail}}}
\newcommand{\FailureUpperConfidenceLimit}{p_{\text{fail, upper}}}
\newcommand{\FairShareStabilizingConstant}{\epsilon_{\text{stab}}}
\newcommand{\FairnessGapTolerance}{\epsilon_{\text{fair}}}
\newcommand{\FakeQuantizedOutput}{x_{\text{fake}}}
\newcommand{\FallbackCost}{C_{\text{fallback}}}
\newcommand{\FallbackDeadline}{T_{\text{deadline,fallback}}}
\newcommand{\FallbackHold}{T_{\text{hold}}}
\newcommand{\FalseAcceptHarmCost}{C_{\text{harm}}}
\newcommand{\FalseApprovalCount}{N_{\text{fa}}}
\newcommand{\FalseApprovalOutcomeCount}{k}
\newcommand{\FalseApprovalPropensity}{Q}
\newcommand{\FalseApprovalPropensityLevel}{q}
\newcommand{\FalseDiscoveryRateTarget}{q}
\newcommand{\FalsificationInitialStateSet}{\mathcal{X}_0}
\newcommand{\FanoutBackendCount}{m}
\newcommand{\FarthestCandidateDistance}{D_{\max}}
\newcommand{\FatTreeHostCount}{N_{\text{hosts}}}
\newcommand{\FatigueLifeCycleCount}{N}
\newcommand{\FaultContainmentLatency}{\Delta t_{\text{bounded}}}
\newcommand{\FaultDetectionLatency}{\Delta t_{\text{det}}}
\newcommand{\FaultDomainIsolation}{\mathcal{F}}
\newcommand{\FaultInjectionDuration}{\Delta t_{\text{duration}}}
\newcommand{\FaultStartTimestamp}{t_{\text{fault\_start}}}
\newcommand{\FaultTakeoverLatency}{\Delta t_{\text{takeover}}}
\newcommand{\FaultTakeoverTimestamp}{t_{\text{takeover}}}
\newcommand{\FaultToleranceCost}{C_{\text{ft}}}
\newcommand{\FaultToleranceInvestment}{x}
\newcommand{\FeasibleOutputTokenRate}{\mu_{\text{out}}}
\newcommand{\FeasibleTrajectoryProjection}{\Pi_{\mathcal{K}}}
\newcommand{\FeasibleTrajectorySet}{\mathcal{K}}
\newcommand{\FeatureCategoryCount}{k}
\newcommand{\FeatureCategoryIndex}{i}
\newcommand{\FeatureCellVector}{\mathbf{f}_{u, v}}
\newcommand{\FeatureChannelCount}{C}
\newcommand{\FeatureCount}{N_{\text{features}}}
\newcommand{\FeatureFreshnessLatency}{T_{\text{freshness}}}
\newcommand{\FeatureMapColumnCoordinate}{x}
\newcommand{\FeatureMapGrowthRate}{g}
\newcommand{\FeatureMapHeight}{H_{\text{img}}}
\newcommand{\FeatureMapRowCoordinate}{y}
\newcommand{\FeatureMapWidth}{W_{\text{img}}}
\newcommand{\FeatureRecordTime}{t}
\newcommand{\FeatureRetentionWindow}{T_{\text{retention}}}
\newcommand{\FeatureUpdateInterval}{T_{\text{update}}}
\newcommand{\FeatureUpdateLag}{T_{\text{staleness}}}
\newcommand{\FeatureUpdateTimestamp}{t_{\text{feat}}}
\newcommand{\FeatureViewingDistance}{r}
\newcommand{\FederatedRoundCount}{R}
\newcommand{\FederatedRoundIndex}{t}
\newcommand{\FederatedTrainingEnergy}{E_{\text{federated}}}
\newcommand{\FeedForwardOperations}{O_{\text{FFN}}}
\newcommand{\FeedForwardWidth}{d_{\text{ff}}}
\newcommand{\FeedbackCheckDuration}{t_{\text{check}}}
\newcommand{\FeedbackCriticalPathLatency}{T^{\text{feedback}}}
\newcommand{\FeedbackIntervalCount}{k}
\newcommand{\FeedbackStepIndex}{t}
\newcommand{\FeedforwardJointTorque}{\boldsymbol{\tau}_{\text{ff}}}
\newcommand{\FeedthroughMatrix}{\mathbf{D}}
\newcommand{\FewShotStepCount}{n_{\text{steps}}}
\newcommand{\FewShotSupportSet}{\mathcal{D}_{\text{shot}}}
\newcommand{\FiberPropagationSpeed}{c_{\text{fiber}}}
\newcommand{\FieldbusCycleTime}{T_{\text{cycle}}}
\newcommand{\FilmEncounterRate}{\lambda_{\text{film}}}
\newcommand{\FilterSolveBudget}{T_{\text{budget}}}
\newcommand{\FilterSolveTime}{T_{\text{solve}}}
\newcommand{\FilterTapCount}{N}
\newcommand{\FilterWeight}{w}
\newcommand{\FilteredScreenSpaceCovariance}{\boldsymbol{\Sigma}_{2D}'}
\newcommand{\FinalBusVoltage}{V_{\text{final}}}
\newcommand{\FinalGeneratorLatentVector}{\mathbf{z}_{m}}
\newcommand{\FinalLayerFunction}{f_{N_L}}
\newcommand{\FinalLayerWidth}{n_{N_L}}
\newcommand{\FinalMiniBatchActivation}{a_{B}}
\newcommand{\FinalRecurrentHiddenState}{\mathbf{h}_{S}}
\newcommand{\FinalWatchdogToken}{T_{\text{final}}}
\newcommand{\FingerNormalForce}{f_n}
\newcommand{\FingerTangentialForce}{\mathbf{f}_t}
\newcommand{\FinishedWorkerCount}{j}
\newcommand{\FiniteChange}{\Delta}
\newcommand{\FiniteSampleGeneralizationBound}{\delta_N}
\newcommand{\FiniteTimeHorizon}{T}
\newcommand{\FirstAdjacentCheckIndex}{a}
\newcommand{\FirstAdjacentCheckPassProbability}{p_{a}}
\newcommand{\FirstAdjacentCheckSlotTime}{T_{a}}
\newcommand{\FirstCatalogDefinitionCount}{n_{\text{def},A}}
\newcommand{\FirstCatalogDefinitionSize}{S_{A}}
\newcommand{\FirstClassCoverageFloor}{a}
\newcommand{\FirstClientMaskedUpdate}{\mathbf{y}_A}
\newcommand{\FirstClientModelParameters}{\theta_A}
\newcommand{\FirstComparedGroupLabel}{a}
\newcommand{\FirstComparedItem}{i}
\newcommand{\FirstDiscardedSingularNumber}{\sigma_{r+1}}
\newcommand{\FirstErrorStepIndex}{k}
\newcommand{\FirstFloatingPointAddend}{a}
\newcommand{\FirstGroupClassificationThreshold}{\tau_{\text{thr},a}}
\newcommand{\FirstGroupQualifiedFraction}{q_a}
\newcommand{\FirstGroupSampleApprovalRate}{\hat{p}_a}
\newcommand{\FirstGroupSampleSize}{n_a}
\newcommand{\FirstGroupThresholdClassifier}{h_a}
\newcommand{\FirstIncidentTime}{t_1}
\newcommand{\FirstInputNodePrimal}{v_{1-N}}
\newcommand{\FirstJaccardSet}{\mathcal{A}}
\newcommand{\FirstMistakeEvent}{\mathcal{E}}
\newcommand{\FirstRankComputeTime}{T_{\text{rank}_0}}
\newcommand{\FirstRaterCategoryFraction}{p_{y,1}}
\newcommand{\FirstRingTraceElement}{a}
\newcommand{\FirstSummandStandardDeviation}{\sigma_a}
\newcommand{\FirstTwinCriticReturnEstimate}{Q_{\phi_1}}
\newcommand{\FittedSensitivity}{\lambda}
\newcommand{\FixedClearanceAllowance}{\delta}
\newcommand{\FlangeCameraTransform}{\mathbf{T}_{\text{flange}}^{\text{cam}}}
\newcommand{\FlangePose}{\mathbf{T}_{\text{flange}}}
\newcommand{\FlangeReferenceFrame}{\mathcal{F}_{\text{flange}}}
\newcommand{\FlangeTargetTransform}{\mathbf{T}_{\text{flange}}^{\text{target}}}
\newcommand{\FlattenedFilterWeights}{\mathbf{w}_{\text{col}}}
\newcommand{\FleetCommunicationTaxonomyAxis}{C_2}
\newcommand{\FleetComputeTaxonomyAxis}{C_1}
\newcommand{\FleetCoordinationTaxonomyAxis}{C_3}
\newcommand{\FleetEnergyProductivity}{\rho_{\text{energy}}}
\newcommand{\FleetManufacturingDistribution}{\mathcal{M}}
\newcommand{\FleetResourceCapacity}{C_{r}}
\newcommand{\FleetRobotCount}{N_{\text{fleet}}}
\newcommand{\FlippedFloatExponentField}{e'}
\newcommand{\FloatEncodedNumber}{x}
\newcommand{\FloatExponentField}{e}
\newcommand{\FloatMantissaField}{m}
\newcommand{\FloatSignBit}{s}
\newcommand{\FloatingBaseAccelerations}{\ddot{\mathbf{q}}_b}
\newcommand{\FloatingBaseBiasForces}{\mathbf{h}_b}
\newcommand{\FloatingBaseInertiaBlock}{\mathbf{M}_{bb}}
\newcommand{\FloatingBasePose}{\mathbf{q}_b}
\newcommand{\FlopPrice}{c_{\text{FLOP}}}
\newcommand{\FlowMatchingLoss}{\mathcal{L}_{\text{FM}}}
\newcommand{\FlowProbabilityPath}{\rho}
\newcommand{\FlowSampleVector}{\mathbf{y}}
\newcommand{\FlowTimeCoordinate}{t}
\newcommand{\FocalLength}{f}
\newcommand{\FollowerForwardWave}{\mathbf{u}_s}
\newcommand{\FollowerJointPositions}{\mathbf{q}_{\text{follower}}}
\newcommand{\FollowerMechanicalLatency}{t_{\text{mech}}}
\newcommand{\FollowerReturnWave}{\mathbf{w}_s}
\newcommand{\ForceGuidedRelay}{K}
\newcommand{\ForceReadingInnovation}{\nu}
\newcommand{\ForceSensorBias}{b}
\newcommand{\ForceSensorReading}{y}
\newcommand{\ForegroundLatency}{L_{\text{lat,fg}}}
\newcommand{\ForgetDataset}{D_{\text{forget}}}
\newcommand{\ForkBoundarySet}{\mathcal{B}_{\text{fork}}}
\newcommand{\ForkedTrajectoryTokenCount}{N_{\text{total}}}
\newcommand{\FormatComplianceScore}{\Phi}
\newcommand{\FormatEfficiency}{\eta_{\text{format}}}
\newcommand{\FormatRewardWeight}{\lambda_{\text{fmt}}}
\newcommand{\ForwardDiffusionDistribution}{q}
\newcommand{\ForwardEulerEigenvalue}{\lambda_{\text{FE}}}
\newcommand{\ForwardEulerTransitionMatrix}{\mathbf{A}_{\text{FE}}}
\newcommand{\ForwardInvariantSafeSet}{\mathcal{C}}
\newcommand{\ForwardKinematicsMap}{\mathbf{FK}}
\newcommand{\ForwardOccupancySet}{\mathcal{R}}
\newcommand{\ForwardPassTokenCount}{n}
\newcommand{\ForwardPosteriorMean}{\tilde{\boldsymbol{\mu}}}
\newcommand{\ForwardPosteriorVariance}{\tilde{\beta}}
\newcommand{\FourthRingTraceElement}{d}
\newcommand{\FrameBitCount}{B_{\text{frame}}}
\newcommand{\FrameBlockingTime}{B}
\newcommand{\FrameExposureStartTime}{t_{\text{start}}}
\newcommand{\FrameIndex}{i}
\newcommand{\FramePayloadSize}{B_{\text{payload}}}
\newcommand{\FramePeriod}{T}
\newcommand{\FrameReadoutTime}{t_{\text{readout}}}
\newcommand{\FrameReleaseJitter}{J}
\newcommand{\FrameResponseTime}{R}
\newcommand{\FrameSerializationTime}{t_{\text{frame},i}}
\newcommand{\FrameTransmissionTime}{C}
\newcommand{\FrameWireBitCount}{B_{\text{wire},i}}
\newcommand{\FreeConfigurationSpace}{\mathcal{C}_{\text{free}}}
\newcommand{\FreeCreditCount}{N_{\text{free}}}
\newcommand{\FreeSpaceDepth}{d_{\text{free}}}
\newcommand{\FreeSpaceLogOddsIncrement}{L_{\text{free}}}
\newcommand{\FreeSurfaceTiltAngle}{\theta_{\text{tilt}}}
\newcommand{\FreeboardHeight}{h_{f}}
\newcommand{\FreshEvidenceTime}{t_{\text{fresh}}}
\newcommand{\FreshInputTokenCount}{S_{\text{fresh}}}
\newcommand{\FreshnessObjective}{S_{\text{freshness}}}
\newcommand{\FrictionCoefficientFloor}{\mu_{\min}}
\newcommand{\FrictionPyramidMatrix}{\mathbf{F}}
\newcommand{\FrobeniusNorm}{F}
\newcommand{\FrozenBackboneFunction}{f}
\newcommand{\FrozenFeatureEncoder}{f}
\newcommand{\FrustumFeature}{\mathbf{c}_{u, v, k}}
\newcommand{\FullBatchLoss}{\mathcal{L}_B}
\newcommand{\FullDatasetSize}{D_{\text{total}}}
\newcommand{\FullPrecisionWeight}{w}
\newcommand{\FullSnapshotWriteVolume}{D_{\text{vol,full}}}
\newcommand{\FullSpeedTravelTime}{b}
\newcommand{\FunctionInputAdjoint}{\bar{x}}
\newcommand{\FunctionInputDimension}{N}
\newcommand{\FunctionInputElement}{x}
\newcommand{\FunctionInputTangent}{\dot{x}}
\newcommand{\FunctionInputVariable}{x}
\newcommand{\FunctionInputVector}{\mathbf{x}}
\newcommand{\FunctionJacobian}{\mathbf{J}}
\newcommand{\FunctionOutputDimension}{M}
\newcommand{\FunctionOutputElement}{y}
\newcommand{\FunctionOutputVariable}{z}
\newcommand{\FunctionOutputVector}{\mathbf{y}}
\newcommand{\FunctionSecondInputVariable}{y}
\newcommand{\FundamentalMatrix}{\mathbf{F}}
\newcommand{\FusedConvolutionBias}{\mathbf{b}_{\text{fused}}}
\newcommand{\FusedConvolutionWeight}{\mathbf{W}_{\text{fused}}}
\newcommand{\FusedTokenCount}{N_{\text{total}}}
\newcommand{\FusionCandidate}{x_{\text{cand}}}
\newcommand{\FusionInputList}{\mathcal{L}}
\newcommand{\FusionInputRank}{r}
\newcommand{\FutureControlTrajectory}{\mathbf{u}_{[t, \infty)}}
\newcommand{\FutureTimeInstant}{t'}
\newcommand{\GaeAdvantageEstimate}{\widehat{A}^{\text{GAE}}}
\newcommand{\GateCurrent}{I_g}
\newcommand{\GateDriverSkew}{t_{\text{prop, skew}}}
\newcommand{\GatePropagationDelay}{t_{\text{prop}}}
\newcommand{\GateSourceCapacitance}{C_{\text{gs}}}
\newcommand{\GateSourceCharge}{Q_{\text{gs}}}
\newcommand{\GateSourceVoltage}{V_{\text{gs}}}
\newcommand{\GaussianCovarianceMatrix}{\boldsymbol{\Sigma}}
\newcommand{\GaussianDistribution}{\mathcal{N}}
\newcommand{\GaussianFirstAxisScale}{s_{x}}
\newcommand{\GaussianMeanVector}{\boldsymbol{\mu}}
\newcommand{\GaussianMechanismNoiseVector}{\mathbf{z}}
\newcommand{\GaussianMechanismStandardDeviation}{\sigma_{\text{mech}}}
\newcommand{\GaussianOpacityLogit}{o}
\newcommand{\GaussianPrimitiveCovariance}{\boldsymbol{\Sigma}}
\newcommand{\GaussianPrimitiveDensity}{G}
\newcommand{\GaussianPrimitiveIndex}{i}
\newcommand{\GaussianPrimitiveMean}{\boldsymbol{\mu}}
\newcommand{\GaussianPrimitiveOpacity}{\alpha}
\newcommand{\GaussianPrimitiveScaleMatrix}{\mathbf{S}}
\newcommand{\GaussianSecondAxisScale}{s_{y}}
\newcommand{\GaussianStandardDeviation}{\sigma}
\newcommand{\GaussianThirdAxisScale}{s_{z}}
\newcommand{\GaussianViewDependentColor}{c}
\newcommand{\GearFaceWidth}{b}
\newcommand{\GearModule}{m}
\newcommand{\GearRatedFatigueLife}{L_{\text{gear}}}
\newcommand{\GearReductionRatio}{N_{\text{gear}}}
\newcommand{\GearTangentialLoad}{W_t}
\newcommand{\GearToothBendingStress}{\sigma_b}
\newcommand{\GearTorqueReversalCount}{n_{\text{gear}}}
\newcommand{\GearboxTransmissionEfficiency}{\eta_{\text{gear}}}
\newcommand{\GemmAccumulatorScale}{\beta}
\newcommand{\GemmColumnDimension}{N}
\newcommand{\GemmInnerDimension}{K}
\newcommand{\GemmLeftOperand}{\mathbf{A}}
\newcommand{\GemmLeftOperandElement}{A}
\newcommand{\GemmLeftOperandEntry}{A_{ik}}
\newcommand{\GemmOutputElement}{C}
\newcommand{\GemmOutputEntry}{C_{ij}}
\newcommand{\GemmOutputMatrix}{\mathbf{C}}
\newcommand{\GemmProductScale}{\alpha}
\newcommand{\GemmReductionIndex}{k}
\newcommand{\GemmRightOperand}{\mathbf{B}}
\newcommand{\GemmRightOperandElement}{B}
\newcommand{\GemmRightOperandEntry}{B_{kj}}
\newcommand{\GemmRowDimension}{M}
\newcommand{\GemmTileColumnDimension}{N_{\text{tile}}}
\newcommand{\GemmTileInnerDimension}{K_{\text{tile}}}
\newcommand{\GemmTileRowDimension}{M_{\text{tile}}}
\newcommand{\GemvArithmeticIntensity}{I_{\text{GEMV}}}
\newcommand{\GeneralPurposeEnergyProductivity}{\rho_{\text{energy,general}}}
\newcommand{\GeneralizedAccelerationLowerBound}{\ddot{\mathbf{q}}_{\min}}
\newcommand{\GeneralizedAccelerationUpperBound}{\ddot{\mathbf{q}}_{\max}}
\newcommand{\GeneralizedAccelerations}{\ddot{\mathbf{q}}}
\newcommand{\GeneralizedBiasForces}{\mathbf{h}}
\newcommand{\GeneralizedCoordinateCount}{n}
\newcommand{\GeneralizedCoordinates}{\mathbf{q}}
\newcommand{\GeneralizedInertiaMatrix}{\mathbf{M}}
\newcommand{\GeneralizedParetoDistribution}{H}
\newcommand{\GeneralizedParetoLikelihood}{L}
\newcommand{\GeneralizedVelocities}{\dot{\mathbf{q}}}
\newcommand{\GeneratedResponse}{y}
\newcommand{\GeneratedSampleCount}{n}
\newcommand{\GeneratedTokenCap}{N_{\text{cap}}}
\newcommand{\GenerationStepErrorRate}{\lambda_{\text{error}}}
\newcommand{\GenerativeActionModelDistribution}{p_\theta}
\newcommand{\GeneratorLatentVector}{\mathbf{z}}
\newcommand{\GenericRandomVariable}{X}
\newcommand{\GeometricStateRepresentation}{\mathbf{Z}_{\text{geom}}}
\newcommand{\GevLocationParameter}{\mu}
\newcommand{\GevScaleParameter}{\sigma}
\newcommand{\GlobalBatchGradient}{\mathbf{g}_{\text{global}}}
\newcommand{\GlobalBatchSize}{B_{\text{global}}}
\newcommand{\GlobalDeviationPenalty}{\mathcal{R}}
\newcommand{\GlobalModelParameters}{\theta_{\text{global}}}
\newcommand{\GoalConfiguration}{\mathbf{q}_{\text{goal}}}
\newcommand{\GoalSet}{\mathcal{G}_{\text{goal}}}
\newcommand{\GoodputRelativeTolerance}{\epsilon_{\mathcal{G}}}
\newcommand{\GpdCumulativeDistribution}{F_{\text{GPD}}}
\newcommand{\GpdScaleParameter}{\tilde{\sigma}}
\newcommand{\GpuAvailability}{A_{\text{GPU}}}
\newcommand{\GpuEnergy}{E_{\text{GPU}}}
\newcommand{\GpuFailureRate}{\lambda_{\text{GPU}}}
\newcommand{\GpuMttf}{\text{MTTF}_{\text{GPU}}}
\newcommand{\GpuTopologicalDistance}{d}
\newcommand{\GradientClippingNorm}{C}
\newcommand{\GradientCovarianceMatrix}{\Sigma}
\newcommand{\GradientElementCount}{d_{\text{grad}}}
\newcommand{\GradientMemory}{M_{\text{gradients}}}
\newcommand{\GradientPayload}{M_{\text{grad}}}
\newcommand{\GradientStaleness}{\tau_{\text{stale}}}
\newcommand{\GrantAllowedAccesses}{\mathcal{A}}
\newcommand{\GrantCondition}{\phi_{\Gamma}}
\newcommand{\GrantExpiryTime}{t_{\text{exp}}}
\newcommand{\GrantIssueTime}{T}
\newcommand{\GrantRights}{\mathcal{R}_{\Gamma}}
\newcommand{\GraphEdgeSet}{E}
\newcommand{\GraphNodeIndex}{i}
\newcommand{\GraphNodeSet}{V}
\newcommand{\GraspContactDisplacement}{\mathbf{d}}
\newcommand{\GraspForceCeiling}{f_{\max}}
\newcommand{\GraspForceFloor}{f_{\min}}
\newcommand{\GraspMap}{\mathbf{G}}
\newcommand{\GraspOrientation}{\mathbf{R}_{\text{grasp}}}
\newcommand{\GraspPose}{\mathbf{T}_{\text{grasp}}}
\newcommand{\GraspPosition}{\mathbf{p}_{\text{grasp}}}
\newcommand{\GraspVerticalAcceleration}{a_z}
\newcommand{\GravitationalTorqueVector}{\mathbf{g}}
\newcommand{\Gravity}{g}
\newcommand{\GravityCenterHeight}{h_{\text{cg}}}
\newcommand{\GravityVector}{\mathbf{g}_0}
\newcommand{\GridFeedCapacity}{P_{\text{grid}}}
\newcommand{\GridSideCellCount}{N}
\newcommand{\GripContactForce}{x}
\newcommand{\GripperContactAngle}{\theta_{\text{contact}}}
\newcommand{\GripperOpeningCommand}{a_{\text{gripper}}}
\newcommand{\GroundPlaneAbscissa}{x}
\newcommand{\GroundPlaneOrdinate}{y}
\newcommand{\GroupCommitWaitTime}{L_{\text{lat}, i}}
\newcommand{\GroupContrastProbability}{p_{\text{contrast}}}
\newcommand{\GroupDisparity}{\Delta_g}
\newcommand{\GroupMeanReward}{\mu_{R}}
\newcommand{\GroupRelativeAdvantage}{\hat{A}}
\newcommand{\GroupRewardStandardDeviation}{\sigma_{R}}
\newcommand{\GroupRolloutIndex}{i}
\newcommand{\GroupSize}{G}
\newcommand{\GrpoSampledObjective}{\widehat{\mathcal{J}}_{\text{GRPO}}}
\newcommand{\GuardBandDuration}{t_{\text{guard}}}
\newcommand{\GuardedContactPredicate}{P_{\text{contact}}}
\newcommand{\GuestImageMemory}{M_{\text{guest}}}
\newcommand{\GuestKernelBootTime}{T_{\text{kernel}}}
\newcommand{\HalfPrecisionGemvIntensity}{I_{\text{GEMV, 16-bit}}}
\newcommand{\HammingDataBitCount}{n}
\newcommand{\HandForceCriterion}{F_h}
\newcommand{\HandleAffordanceFrame}{\mathcal{F}_{\text{handle}}}
\newcommand{\HandoffExceedanceProbability}{\epsilon}
\newcommand{\HandoverTimeout}{T_{\text{timeout}}}
\newcommand{\HandoverTimeoutCeiling}{T_{\text{config}}}
\newcommand{\HandshakeProtocolLatency}{T_{\text{handshake}}}
\newcommand{\HardwareCommonCauseRate}{\lambda_{\text{other}}}
\newcommand{\HardwareParameterVector}{\boldsymbol{\xi}_{\text{real}}}
\newcommand{\HardwareServiceLife}{T_{\text{lifetime}}}
\newcommand{\HarmInclusiveTaskCost}{C_{\text{with\ harm}}}
\newcommand{\HarmInstant}{t_{\text{harm}}}
\newcommand{\HarmLeadTime}{t_{\text{harm}}}
\newcommand{\HarmonicDriveTorsionalStiffness}{k_c}
\newcommand{\HarmonicPeriodMultiple}{m}
\newcommand{\HarnessConnectorResistance}{R_{\text{harness}}}
\newcommand{\HashBucketCount}{N_{\text{buckets}}}
\newcommand{\HashEntrySize}{s_{\text{entry}}}
\newcommand{\HashRingServer}{s}
\newcommand{\HashRingServerCount}{N}
\newcommand{\HashRingServerSet}{\mathcal{S}_{\text{srv}}}
\newcommand{\HashedGridMemory}{M_{\text{hashed}}}
\newcommand{\HazardClassIndex}{h}
\newcommand{\HazardOnset}{t_{\text{onset}}}
\newcommand{\HazardOnsetBound}{t_{\text{bound}}}
\newcommand{\HazardousProposalRate}{\lambda_{\text{proposal}, h}}
\newcommand{\HazardousWorldState}{s_B}
\newcommand{\HeadAxisLabel}{h}
\newcommand{\HeadByteAllocation}{M_{\text{head}}}
\newcommand{\HeadComponentIndex}{m}
\newcommand{\HeadDimensionAxisLabel}{d}
\newcommand{\HeadKeyProjectionMatrix}{\mathbf{W}_{K,i}}
\newcommand{\HeadQueryProjectionMatrix}{\mathbf{W}_{Q,i}}
\newcommand{\HeadSamplingProbability}{\theta}
\newcommand{\HeadValuesProjectionMatrix}{\mathbf{W}_{V,i}}
\newcommand{\HeadingAngle}{\theta_{\text{head}}}
\newcommand{\HeadingCurvature}{\kappa}
\newcommand{\HealthyStepTime}{T_{\text{healthy}}}
\newcommand{\HeartbeatAge}{\Delta t_{\text{heartbeat}}}
\newcommand{\HeartbeatInterval}{H}
\newcommand{\HeartbeatReceiptTime}{t_{\text{local}}}
\newcommand{\HeartbeatSequenceCounter}{k}
\newcommand{\HeartbeatTimestamp}{t^{\text{hb}}}
\newcommand{\HeatDissipationPower}{P_{\text{heat}}}
\newcommand{\HermiteBasisFunction}{h}
\newcommand{\HermiteInterpolationFraction}{\lambda}
\newcommand{\HermiteSegmentProgress}{s}
\newcommand{\HertzianContactCoefficient}{k_{c}}
\newcommand{\HertzianContactStiffness}{k_H}
\newcommand{\HiddenActivation}{\mathbf{h}}
\newcommand{\HiddenActivationMatrix}{\mathbf{H}}
\newcommand{\HiddenDimension}{d}
\newcommand{\HiddenUnitOutput}{h}
\newcommand{\HighOccupancyBinCount}{m}
\newcommand{\HigherPriorityFrames}{hp}
\newcommand{\HigherPriorityTasks}{hp}
\newcommand{\HighestSignalFrequency}{f_{\max}}
\newcommand{\HnswLayerIndex}{L}
\newcommand{\HnswLevelDraw}{U}
\newcommand{\HnswLevelNormalization}{m_\ell}
\newcommand{\HnswMaximumConnectionCount}{M}
\newcommand{\HnswSearchBeamWidth}{ef_{\text{search}}}
\newcommand{\HoldingTorque}{\tau_{\text{hold}}}
\newcommand{\HomogeneousCameraFramePoint}{\tilde{\mathbf{p}}_C}
\newcommand{\HomogeneousPixelCoordinates}{\tilde{\mathbf{m}}}
\newcommand{\HomogeneousPointCoordinates}{\tilde{\mathbf{p}}}
\newcommand{\HomogeneousTransform}{\mathbf{T}_{AB}}
\newcommand{\HomogeneousWorldFramePoint}{\tilde{\mathbf{p}}_W}
\newcommand{\HomographyColumn}{\mathbf{h}}
\newcommand{\HomographyColumnEntry}{h}
\newcommand{\HomographyConstraintVector}{\mathbf{v}}
\newcommand{\HomographyScaleFactor}{\lambda}
\newcommand{\HomomorphicCiphertext}{c}
\newcommand{\HomomorphicFunction}{f}
\newcommand{\HomomorphicPublicKey}{pk}
\newcommand{\HomomorphicSecretKey}{sk}
\newcommand{\HorizonStepIndex}{k}
\newcommand{\HorizontalFocalLength}{f_x}
\newcommand{\HostArrivalTimestamp}{t_{\text{host}}}
\newcommand{\HostHeartbeatRate}{f_{\text{heartbeat}}}
\newcommand{\HostLinkBandwidth}{\text{BW}_{\text{link}}}
\newcommand{\HostPower}{P_{\text{host}}}
\newcommand{\HostPreparationTime}{T_{\text{prep}}}
\newcommand{\HostRuntimeCount}{N_{\text{host}}}
\newcommand{\HostSoftwareTime}{T_{\text{sw}}}
\newcommand{\HostTransferBandwidth}{\text{BW}_{\text{host}}}
\newcommand{\HotTierHitProbability}{h}
\newcommand{\HotTierServiceTime}{T_{\text{hot}}}
\newcommand{\HourlyAccountQueryCount}{q_{\text{hourly}}}
\newcommand{\HourlyComponentFailureRate}{\lambda_{\text{hour}}}
\newcommand{\HuberLossThreshold}{\delta}
\newcommand{\HullQueryTime}{t_{\text{query}}}
\newcommand{\HullSphereRadius}{r_{\text{hull}}}
\newcommand{\HumanCommandRate}{\dot{\mathbf{u}}_{\text{human}}}
\newcommand{\HumanControlCommand}{\mathbf{u}_{\text{human}}}
\newcommand{\HumanFallbackCost}{C_{h}}
\newcommand{\HumanReactionTime}{T_{\text{human}}}
\newcommand{\HumanResolutionProbability}{h}
\newcommand{\HumanReviewCost}{C_{\text{human}}}
\newcommand{\HumanStandaloneSensitivity}{S_{\text{human}}}
\newcommand{\HumanWalkingSpeedBound}{v_h}
\newcommand{\HybridIterationTime}{T_{\text{step}}}
\newcommand{\HydraulicSupplyPressure}{p}
\newcommand{\HypothesisIndex}{h}
\newcommand{\HypothesisTestFalseNegativeRate}{\beta_{\text{stat}}}
\newcommand{\HypothesisTestSignificanceLevel}{\alpha_{\text{sig}}}
\newcommand{\HypothesizedAcceptanceProbability}{p}
\newcommand{\HypothesizedTrialFailureProbability}{p}
\newcommand{\IdealAcceleratorTime}{T_{\text{ideal}}}
\newcommand{\IdealMemoryQueueDelay}{t_{\text{queue,ideal}}}
\newcommand{\IdempotentAlgebraElement}{x}
\newcommand{\IdentityMatrix}{\mathbf{I}}
\newcommand{\IllustrativeFunction}{f}
\newcommand{\ImageChannelCount}{C}
\newcommand{\ImageChannelIndex}{c}
\newcommand{\ImageColumnIndex}{w}
\newcommand{\ImageEpipole}{\mathbf{e}}
\newcommand{\ImageHeight}{H}
\newcommand{\ImageRowIndex}{h}
\newcommand{\ImageTensorElement}{X}
\newcommand{\ImageWidth}{W}
\newcommand{\ImaginaryUnit}{j}
\newcommand{\ImitationLearnedPolicy}{\hat{\pi}}
\newcommand{\ImitationTargetCommand}{\mathbf{u}_{\text{target}}}
\newcommand{\ImmediateTaskCostScore}{C}
\newcommand{\ImpactInstant}{T}
\newcommand{\ImpactRiseTime}{t_{\text{rise}}}
\newcommand{\ImpactSpeed}{v_{\text{impact}}}
\newcommand{\ImpedanceControlledPosition}{x}
\newcommand{\ImpedanceControlledVelocity}{\dot{x}}
\newcommand{\ImpedanceEquilibriumPosition}{x_{\text{des}}}
\newcommand{\ImpedanceEquilibriumVelocity}{\dot{x}_{\text{des}}}
\newcommand{\ImpedanceRestoringForce}{F}
\newcommand{\ImplicitPolicyEnergyFunction}{E_\theta}
\newcommand{\ImportanceProposalDistribution}{q}
\newcommand{\ImportanceSampledFailureProbability}{\hat{p}_F}
\newcommand{\ImuSampleTime}{t_{\text{IMU}}}
\newcommand{\InContactViableSet}{\mathcal{C}_{\text{contact}}}
\newcommand{\IncidenceAngle}{\theta_{\text{inc}}}
\newcommand{\IncidentOpticalPower}{P_{\text{opt}}}
\newcommand{\IncomingChannelCommand}{u_{\text{new}}}
\newcommand{\IncomingCommandDerivative}{\dot{u}_{\text{new}}}
\newcommand{\IncorrectCandidateTrialPassProbability}{p_{b}}
\newcommand{\IncrementalSnapshotWriteVolume}{D_{\text{vol,delta}}}
\newcommand{\IncumbentControlCommand}{\mathbf{u}^{\text{incumbent}}}
\newcommand{\IncumbentInterventionRate}{\lambda_{\text{incumbent}}}
\newcommand{\IncumbentTrackingErrorStandardDeviation}{\sigma_{\text{incumbent}}}
\newcommand{\IndependentAttemptCount}{k}
\newcommand{\IndependentEventProbability}{p}
\newcommand{\IndependentSampleRate}{f}
\newcommand{\IndexGraphNodeSet}{V}
\newcommand{\IndexedDocumentCount}{N}
\newcommand{\IndicatorFunction}{\mathbb{I}}
\newcommand{\InducedGateVoltage}{V_{\text{gs,induced}}}
\newcommand{\InductiveVoltage}{v}
\newcommand{\InequalityConstraintFunction}{g}
\newcommand{\InertiaMatchingRatio}{N^*}
\newcommand{\InertiaMatrixDerivative}{\dot{\mathbf{M}}}
\newcommand{\InertialIntegrationTime}{T}
\newcommand{\InferenceActiveTime}{t_{\text{inference}}}
\newcommand{\InferenceCost}{C_{\text{infer}}}
\newcommand{\InferenceDutyCycle}{\alpha_{\text{duty}}}
\newcommand{\InferenceEnergy}{E_{\text{inf}}}
\newcommand{\InferenceLatency}{L_{\text{lat,infer}}}
\newcommand{\InferenceLoadSocPower}{P_{\text{load}}}
\newcommand{\InflatedHullRadius}{r_{\text{inflated}}}
\newcommand{\InflightRolloutReservation}{M_{\text{inflight}}}
\newcommand{\InfluenceFunction}{I}
\newcommand{\InformationTechnologyEnergy}{E_{\text{IT}}}
\newcommand{\InformationTechnologyHeatLoad}{\dot{Q}_{\text{IT}}}
\newcommand{\InformationTechnologyPower}{P_{\text{IT}}}
\newcommand{\InformativeTaskFraction}{p_{\text{inform}}}
\newcommand{\IngestionPricePerSample}{C_{\text{ingest/sample}}}
\newcommand{\InitialAccuracy}{\text{Accuracy}_0}
\newcommand{\InitialBusVoltage}{V_{\text{initial}}}
\newcommand{\InitialPositionStandardDeviation}{\sigma_{p,0}}
\newcommand{\InitialPositionVelocityCovariance}{\sigma_{pv,0}}
\newcommand{\InitialProposalDistribution}{q_{\boldsymbol{\psi}_0}}
\newcommand{\InitialStateDistribution}{\rho_0}
\newcommand{\InitialTrackingError}{e_0}
\newcommand{\InitialVelocityStandardDeviation}{\sigma_{v,0}}
\newcommand{\InitiatedTasks}{N}
\newcommand{\InjectionBandwidth}{\text{BW}_{\text{inject}}}
\newcommand{\InjectionTriggerEpoch}{t_{\text{inject}}}
\newcommand{\InnerChainTransform}{\mathbf{T}_{BC}}
\newcommand{\InnerLayerFunction}{g}
\newcommand{\InnerProductLeftComponent}{a}
\newcommand{\InnerProductLeftVector}{\mathbf{a}}
\newcommand{\InnerProductRightComponent}{v}
\newcommand{\InnerProductRightVector}{\mathbf{b}}
\newcommand{\InnovationBias}{b}
\newcommand{\InnovationCovariance}{\mathbf{S}}
\newcommand{\InnovationVariance}{S}
\newcommand{\InputCaptureTime}{T_{\text{capture}}}
\newcommand{\InputChannelCount}{C_{\text{in}}}
\newcommand{\InputChannelIndex}{c}
\newcommand{\InputColumnLieDerivativeOperator}{L_{\mathbf{g}_j}}
\newcommand{\InputConsumerAcceleratorCount}{N_{\text{GPU}}}
\newcommand{\InputCoordinateCount}{d}
\newcommand{\InputDistribution}{p(x)}
\newcommand{\InputEventRate}{r_{\text{event}}}
\newcommand{\InputFeatureIndex}{i}
\newcommand{\InputFeatureVector}{\mathbf{x}}
\newcommand{\InputLieDerivativeOperator}{L_{\mathbf{g}}}
\newcommand{\InputNodePrimal}{v_{i-N}}
\newcommand{\InputPipelineRate}{R_{\text{pipeline}}}
\newcommand{\InputPipelineRatio}{r_{\text{pipe}}}
\newcommand{\InputPipelineServiceRate}{r_{\text{pipeline}}}
\newcommand{\InputPipelineStageIndex}{j}
\newcommand{\InputQuantizationScale}{s_X}
\newcommand{\InputResolution}{r}
\newcommand{\InputStageServiceRate}{r}
\newcommand{\InputTokenPrice}{c_{\text{in}}}
\newcommand{\InputTokenSequence}{x_{1:S}}
\newcommand{\InputVariableIndex}{m}
\newcommand{\InsetAvailableBrakingDistance}{D_{\text{avail}}}
\newcommand{\InstanceReplenishTime}{T_{\text{init}}}
\newcommand{\InstantaneousPhaseCurrent}{i_{\text{phase}}}
\newcommand{\InstantaneousRequestOccupancy}{Q}
\newcommand{\IntegerWeightCode}{q}
\newcommand{\IntegralControlEffort}{\mathbf{u}_{\text{int}}}
\newcommand{\IntegralGainMatrix}{\mathbf{K}_{i}}
\newcommand{\IntegratedPixelResponse}{I_{\text{pixel}}}
\newcommand{\IntegrationCandidateCommitHash}{h_{\text{candidate}}}
\newcommand{\IntegrationDummyTime}{t'}
\newcommand{\IntegrationHeadCommitHash}{h_{\text{head}}}
\newcommand{\IntegrationPoint}{\mathbf{y}}
\newcommand{\IntegrationPointCoordinate}{y}
\newcommand{\IntegrationTimeInstant}{s}
\newcommand{\IntegratorState}{\mathbf{z}}
\newcommand{\IntegratorStateRate}{\dot{\mathbf{z}}}
\newcommand{\IntegratorUnwindDelay}{T_{\text{unwind}}}
\newcommand{\IntegrityProvenance}{\iota}
\newcommand{\IntegrityTrustLabel}{\iota}
\newcommand{\IntentAcknowledgmentEvent}{e_{\text{flush}}}
\newcommand{\IntentAdministrativeLease}{T_{\text{admin}}}
\newcommand{\IntentDemonstrationDataset}{\mathcal{D}_{\text{intent}}}
\newcommand{\IntentLease}{\mathcal{I}_{\text{intent}}}
\newcommand{\IntentLeaseExpiry}{t_{\text{intent\_exp}}}
\newcommand{\IntentProposalPeriod}{T_{\text{period}}}
\newcommand{\InterAnnotatorAgreement}{\kappa}
\newcommand{\InterFeedInterval}{T_{\text{feed}}}
\newcommand{\InterGroupColumnDelay}{t_{\text{CCD\_S}}}
\newcommand{\InterKernelGapTime}{T_{\text{gap}}}
\newcommand{\InterNodeContextParallelDegree}{c_{\text{inter}}}
\newcommand{\InterQueryIntervalDeviation}{\sigma_{\text{inter-query}}}
\newcommand{\InterSensorClockSkew}{\Delta t_{\text{skew}}}
\newcommand{\InteractionHistory}{h}
\newcommand{\InteractionPortForce}{F}
\newcommand{\InteractionPortVelocity}{v}
\newcommand{\InterarrivalVariationCoefficient}{c_{a}}
\newcommand{\InterfaceMaterialThermalResistance}{R_{\text{th,TIM}}}
\newcommand{\InterferenceSlowdownFactor}{r_{\text{slow}}}
\newcommand{\InterframeSpacingTime}{t_{\text{interframe},i}}
\newcommand{\InterleavedPipelineBubbleFraction}{b_{\text{interleaved}}}
\newcommand{\IntermediateTensorSize}{M_{\text{tensor}}}
\newcommand{\InternalDissipationPower}{g}
\newcommand{\IntervalCompletionTime}{T_{\text{total}}}
\newcommand{\IntervalMean}{\bar{T}}
\newcommand{\IntervalMeanOccupancy}{\bar{Q}}
\newcommand{\IntervalNormalQuantile}{z}
\newcommand{\IntervalStandardDeviation}{\sigma}
\newcommand{\IntervalTransitionMatrix}{\boldsymbol{\Phi}}
\newcommand{\IntervalVariationCoefficient}{c}
\newcommand{\InterventionDensity}{D_{\text{int}}}
\newcommand{\InterventionRate}{\lambda_{\text{int}}}
\newcommand{\InterventionWindowDuration}{W}
\newcommand{\IntraClusterCorrelation}{\rho_{\text{ICC}}}
\newcommand{\IntraGroupColumnDelay}{t_{\text{CCD\_L}}}
\newcommand{\IntraNodeContextParallelDegree}{c_{\text{intra}}}
\newcommand{\IntrusionDistance}{C}
\newcommand{\IntrusionDistanceAllowance}{C}
\newcommand{\InvalidatedArtifactNode}{v}
\newcommand{\InverseDepth}{\rho}
\newcommand{\InverseDepthLandmarkParameters}{\mathbf{y}}
\newcommand{\InverseKinematicsDamping}{\lambda}
\newcommand{\InverseSensorLogOdds}{L_{\text{sensor}}}
\newcommand{\InverterCurrentLimit}{I_{\max}}
\newcommand{\InverterDeadTime}{t_{\text{dead}}}
\newcommand{\IoTransferTime}{T_{\text{IO}}}
\newcommand{\IronCaseThermalResistance}{R_{\text{th,iron-case}}}
\newcommand{\IronLawComputeTime}{T_{\text{compute}}}
\newcommand{\IronLawMemoryTime}{T_{\text{memory}}}
\newcommand{\IronLossPower}{P_{\text{iron}}}
\newcommand{\IronThermalCapacitance}{C_{\text{iron}}}
\newcommand{\IrreducibleLoss}{C_{\mathcal{L}}}
\newcommand{\IsolatedEnforcerExecutionTime}{t_{\text{iso}}}
\newcommand{\IsolatedJobRunTime}{T}
\newcommand{\IspProcessingTime}{t_{\text{ISP}}}
\newcommand{\IsrExecutionTime}{t_{\text{ISR}}}
\newcommand{\IterationCost}{C_{\text{iter}}}
\newcommand{\IterationTokenBudget}{N_{\text{budget}}}
\newcommand{\JaccardSimilarity}{J}
\newcommand{\JacobianLeftSingularMatrix}{\mathbf{U}}
\newcommand{\JacobianLeftSingularVector}{\mathbf{u}}
\newcommand{\JacobianPseudoinverse}{\mathbf{J}^\dagger}
\newcommand{\JacobianRightSingularMatrix}{\mathbf{V}}
\newcommand{\JacobianRightSingularVector}{\mathbf{v}}
\newcommand{\JacobianSingularNumber}{\sigma}
\newcommand{\JacobianSingularNumberMatrix}{\boldsymbol{\Sigma}}
\newcommand{\JawAperture}{w_{\text{aperture}}}
\newcommand{\JensenShannonDivergence}{\mathcal{D}_{\text{JS}}}
\newcommand{\JensenShannonMixtureDistribution}{\bar{P}}
\newcommand{\JerkLimit}{j_{\max}}
\newcommand{\JerkWeightMatrix}{\mathbf{W}_j}
\newcommand{\JitterBufferPlayoutDelay}{T_{\text{buf}}}
\newcommand{\JobAbsoluteDeadline}{d}
\newcommand{\JobAvailability}{A_{\text{all}}}
\newcommand{\JobDuration}{T_{\text{job}}}
\newcommand{\JobIndex}{j}
\newcommand{\JobQueueWaitTime}{W}
\newcommand{\JobReleaseTime}{r}
\newcommand{\JobRestartTime}{T_{\text{restart}}}
\newcommand{\JobSlowdown}{S}
\newcommand{\JobStartupTime}{T_{\text{startup}}}
\newcommand{\JointAcceleration}{\ddot{q}}
\newcommand{\JointAngle}{\theta_{\text{joint}}}
\newcommand{\JointAngleLowerLimit}{q_{\min}}
\newcommand{\JointAngleUpperLimit}{q_{\max}}
\newcommand{\JointAngularAcceleration}{\dot{\omega}}
\newcommand{\JointAngularRate}{\omega}
\newcommand{\JointAngularSpeed}{\omega}
\newcommand{\JointBaseInertiaCoupling}{\mathbf{M}_{jb}}
\newcommand{\JointBiasTorque}{\tau_{\text{bias}}}
\newcommand{\JointCoordinate}{q}
\newcommand{\JointCount}{n}
\newcommand{\JointFrictionTorque}{\tau_{\text{fric}}}
\newcommand{\JointIndex}{i}
\newcommand{\JointJerk}{j_{\text{joint}}}
\newcommand{\JointLoadTorque}{\tau_{\text{load}}}
\newcommand{\JointOutputImpedance}{Z_{\text{out}}}
\newcommand{\JointOutputTorque}{\tau_{\text{out}}}
\newcommand{\JointPathCurvature}{\mathbf{q}''}
\newcommand{\JointPathTangent}{\mathbf{q}'}
\newcommand{\JointPosition}{q}
\newcommand{\JointPositionLowerLimit}{\mathbf{q}_{\min}}
\newcommand{\JointPositionSetpoint}{\mathbf{q}^*}
\newcommand{\JointPositionTarget}{q_{\text{des}}}
\newcommand{\JointPositionUpperLimit}{\mathbf{q}_{\max}}
\newcommand{\JointReflectedRotorInertia}{J_{m}}
\newcommand{\JointSampleTimestamp}{t_{\text{joint}}}
\newcommand{\JointTorque}{\boldsymbol{\tau}}
\newcommand{\JointTorqueConstant}{K_t}
\newcommand{\JointTorqueLimit}{\tau_{\max}}
\newcommand{\JointTorqueLimits}{\boldsymbol{\tau}_{\max}}
\newcommand{\JointTorqueLowerLimit}{\boldsymbol{\tau}_{\min}}
\newcommand{\JointTorqueSlew}{\dot{\boldsymbol{\tau}}}
\newcommand{\JointTorqueSlewLimit}{\dot{\boldsymbol{\tau}}_{\max}}
\newcommand{\JointTorqueTarget}{\tau_{\text{des}}}
\newcommand{\JointTorqueUpperLimit}{\boldsymbol{\tau}_{\max}}
\newcommand{\JointTorsionalStiffnessMatrix}{\mathbf{K}}
\newcommand{\JointTrackingError}{\mathbf{e}}
\newcommand{\JointVelocity}{\dot{q}}
\newcommand{\JointVelocityCeiling}{\dot{q}_{\max}}
\newcommand{\JointVelocityLimit}{\dot{\mathbf{q}}_{\max}}
\newcommand{\JointVelocitySetpoint}{\dot{\mathbf{q}}^*}
\newcommand{\JointVelocityTarget}{\dot{q}_{\text{des}}}
\newcommand{\JouleanTemperatureRise}{\Delta T}
\newcommand{\JunctionAmbientThermalResistance}{R_{\text{th,JA}}}
\newcommand{\JunctionCaseThermalResistance}{R_{\text{th,JC}}}
\newcommand{\JunctionTemperature}{T_{\text{j}}}
\newcommand{\KalmanBucyObserverGain}{\mathbf{L}}
\newcommand{\KalmanGain}{\mathbf{G}}
\newcommand{\KeepContextPathCost}{C_{\text{keep}}}
\newcommand{\KendallMarkovianCode}{M}
\newcommand{\KernelActiveTime}{T_{\text{compute}}}
\newcommand{\KernelColumnOffset}{n}
\newcommand{\KernelExecutionTime}{T_{\text{kernel}}}
\newcommand{\KernelHeight}{K_h}
\newcommand{\KernelHorizontalLoopOffset}{k_{x}}
\newcommand{\KernelRowOffset}{m}
\newcommand{\KernelSize}{K}
\newcommand{\KernelVerticalLoopOffset}{k_{y}}
\newcommand{\KernelWeight}{W}
\newcommand{\KernelWidth}{K_w}
\newcommand{\KeyAxisLabel}{j}
\newcommand{\KeyBufferPosition}{j}
\newcommand{\KeyComponent}{k_{jm}}
\newcommand{\KeyLeftSingularMatrix}{\mathbf{U}}
\newcommand{\KeyLeftSingularVector}{\mathbf{u}}
\newcommand{\KeyProjectionMatrix}{\mathbf{W}_{K}}
\newcommand{\KeyRightSingularMatrix}{\mathbf{V}}
\newcommand{\KeyRightSingularVector}{\mathbf{v}}
\newcommand{\KeySingularNumber}{\sigma}
\newcommand{\KeySingularSpectrumMatrix}{\boldsymbol{\Sigma}}
\newcommand{\KeySourceMatrix}{\mathbf{X}_{K}}
\newcommand{\KeySpectrumLength}{q}
\newcommand{\KeyVector}{\mathbf{k}}
\newcommand{\KineticEnergy}{E_k}
\newcommand{\KineticEnergyCeiling}{E_{\max}}
\newcommand{\KineticInsetBarrierFunction}{h_{\text{kinetic}}}
\newcommand{\KineticInsetBarrierRate}{\dot{h}_{\text{kinetic}}}
\newcommand{\KlDivergence}{\mathcal{D}_{\text{KL}}}
\newcommand{\KlPenaltyCoefficient}{\beta_{\text{KL}}}
\newcommand{\KlSampleStatistic}{d}
\newcommand{\KnownComponentStopDistance}{d_{\text{budget}}}
\newcommand{\KolmogorovSmirnovCriticalThreshold}{c_{\text{crit}}}
\newcommand{\KolmogorovSmirnovStatistic}{\mathcal{D}_{\text{KS}}}
\newcommand{\KroneckerIndicator}{\delta}
\newcommand{\KrumClientCount}{n}
\newcommand{\KrylovSubspace}{\mathcal{K}}
\newcommand{\KsCriticalCoefficient}{c}
\newcommand{\KvBlockSize}{S_{\text{blk}}}
\newcommand{\KvBlockTailWaste}{\Delta_{\text{tail}}}
\newcommand{\KvCacheBytesPerToken}{m_{\text{token}}}
\newcommand{\KvCacheHandoffTime}{T_{\text{handoff}}}
\newcommand{\KvCacheMemory}{M_{\text{KV}}}
\newcommand{\KvElementStorageSize}{s_{\text{elem,KV}}}
\newcommand{\KvHeadCount}{H_{\text{KV}}}
\newcommand{\KvPoolHeadroomFraction}{f_{\text{head}}}
\newcommand{\KvPoolMemory}{M_{\text{pool}}}
\newcommand{\KvRecomputeTime}{T_{\text{recompute}}}
\newcommand{\KvReloadTime}{T_{\text{reload}}}
\newcommand{\KvTileCount}{T_c}
\newcommand{\KvTileIndex}{j}
\newcommand{\KvTileSize}{B_c}
\newcommand{\LaSalleInvariantSet}{\Omega}
\newcommand{\LabelCategoryIndex}{i}
\newcommand{\LabelVector}{\mathbf{y}}
\newcommand{\LabeledRecord}{x}
\newcommand{\LabeledSampleCount}{D_{\text{labeled}}}
\newcommand{\LabelingRoundIndex}{k}
\newcommand{\LaggedModelInput}{x_{t-\Delta}}
\newcommand{\LaggedStateDigest}{h_{\text{state},t-k}}
\newcommand{\LandmarkDepth}{d}
\newcommand{\LanguageInstruction}{c_{\text{instr}}}
\newcommand{\LanguageSkillPrior}{p_{\text{LLM}}}
\newcommand{\LaplaceLikelihoodScale}{b}
\newcommand{\LaplaceNoiseSample}{x}
\newcommand{\LaplaceNoiseScale}{b}
\newcommand{\LaplaceVariable}{s}
\newcommand{\LargestDrivenWheelLoadShare}{\varphi}
\newcommand{\LargestEigenvalue}{\lambda_{\max}}
\newcommand{\LargestInvariantSet}{\mathcal{M}}
\newcommand{\LargestSingularNumber}{\sigma_{\max}}
\newcommand{\LarsGlobalLearningRate}{\eta_{\text{global}}}
\newcommand{\LastCandidateEmbeddingVector}{\mathbf{x}_N}
\newcommand{\LastFunctionInputComponent}{x_N}
\newcommand{\LastMeasurementTime}{t_{\text{last}}}
\newcommand{\LastRankComputeTime}{T_{\text{rank}_{N-1}}}
\newcommand{\LatchApproachSpeed}{v_{\text{latch}}}
\newcommand{\LatchClearance}{c}
\newcommand{\LatchContactForce}{f}
\newcommand{\LatchForceLimit}{F_{\text{lim}}}
\newcommand{\LatchPlateStiffness}{k_{\text{latch}}}
\newcommand{\LatchStallForce}{F}
\newcommand{\LatchStrengthFloor}{F_{\text{floor}}}
\newcommand{\LateHandoffProbability}{p}
\newcommand{\Latency}{L_{\text{lat}}}
\newcommand{\LatencyBandwidthCrossoverSize}{n^*}
\newcommand{\LatencyBoundedBatchSize}{B_{\text{SLO}}}
\newcommand{\LatencyObjective}{S_{\text{latency}}}
\newcommand{\LatencyQuantileFunction}{Q_p}
\newcommand{\LatencyRewardExponent}{\beta_{\text{lat}}}
\newcommand{\LatencySlo}{L_{\text{lat,SLO}}}
\newcommand{\LatentActionComponent}{u}
\newcommand{\LatentComponentMean}{\mu_{\phi, j}}
\newcommand{\LatentComponentStandardDeviation}{\sigma_{\phi, j}}
\newcommand{\LatentDimension}{d_z}
\newcommand{\LatentGaussianPolicyDensity}{\mu}
\newcommand{\LatentKlWeight}{\beta}
\newcommand{\LatentPosteriorDistribution}{q}
\newcommand{\LatentPosteriorMean}{\boldsymbol{\mu}_\phi}
\newcommand{\LatentPosteriorStandardDeviation}{\boldsymbol{\sigma}_\phi}
\newcommand{\LatentStateEncoder}{q_\phi}
\newcommand{\LatentStyleVariable}{\mathbf{z}}
\newcommand{\LatentVariableSpace}{\mathcal{Z}}
\newcommand{\LaterBaseFlangeTransform}{\mathbf{T}_{\text{base}, k+1}^{\text{flange}}}
\newcommand{\LaterCameraTargetTransform}{\mathbf{T}_{\text{cam}, k+1}^{\text{target}}}
\newcommand{\LaterRolloutTurnIndex}{j}
\newcommand{\LaterStepIndex}{j}
\newcommand{\LateralClearance}{W_{\text{clear}}}
\newcommand{\LayerAllReduceTime}{T_{\text{layer comm}}}
\newcommand{\LayerBackwardTime}{T_{\text{layer backward}}}
\newcommand{\LayerCount}{N_L}
\newcommand{\LayerExposedCommunicationTime}{T_{\text{exposed}}}
\newcommand{\LayerFunction}{f}
\newcommand{\LayerIndex}{\ell}
\newcommand{\LayerInputComponent}{x}
\newcommand{\LayerInputMatrix}{\mathbf{X}}
\newcommand{\LayerInputVector}{\mathbf{x}}
\newcommand{\LayerInputWidth}{d_{\text{in}}}
\newcommand{\LayerIntermediateStateMemory}{s_{\ell}}
\newcommand{\LayerNonlinearity}{\phi}
\newcommand{\LayerNormMean}{\mu_{\text{LN}}}
\newcommand{\LayerNormStandardDeviation}{\sigma_{\text{LN}}}
\newcommand{\LayerOutputMatrix}{\mathbf{Y}}
\newcommand{\LayerOutputVector}{\mathbf{y}}
\newcommand{\LayerOutputWidth}{d_{\text{out}}}
\newcommand{\LayerParameterPayload}{M_{\text{layer}}}
\newcommand{\LayerSavedTensorCount}{n_{\text{saved}}}
\newcommand{\LayerSelectionIndex}{i}
\newcommand{\LayerWeightEntry}{W}
\newcommand{\LayerWeights}{\mathbf{w}}
\newcommand{\LayerWidth}{n}
\newcommand{\LcResonantFrequency}{f_0}
\newcommand{\LeaderForwardWave}{\mathbf{u}_m}
\newcommand{\LeaderJointPositions}{\mathbf{q}_{\text{leader}}}
\newcommand{\LeaderPortEffort}{\mathbf{F}_m}
\newcommand{\LeaderPortFlow}{\dot{\mathbf{x}}_m}
\newcommand{\LeaderPortPower}{P_m}
\newcommand{\LeaderReturnWave}{\mathbf{w}_m}
\newcommand{\LeaderWristRollAngle}{\theta_{\text{roll}}}
\newcommand{\LeadingSupportDistance}{d_{\text{lead}}}
\newcommand{\LeakageCurrent}{I_{\text{leak}}}
\newcommand{\LeakagePower}{P_{\text{leakage}}}
\newcommand{\LearnedActionProposal}{\hat{\mathbf{a}}_{\text{learned}}}
\newcommand{\LearnedNominalTrajectory}{\hat{\mathbf{q}}_{\text{learned}}}
\newcommand{\LearnedRemainingReturnEstimate}{\widehat{V}}
\newcommand{\LearnedVelocityField}{v_\theta}
\newcommand{\LearnerStateDisagreementRate}{\epsilon_\pi}
\newcommand{\LearnerStateVisitationDistribution}{p^{\pi}}
\newcommand{\LearningCurveSampleCount}{n}
\newcommand{\LearningRate}{\eta}
\newcommand{\LeaseAdmissionInstant}{t_{\text{adm}}}
\newcommand{\LeaseDirtyMemory}{M_{\text{dirty}}}
\newcommand{\LeaseExpiryDelaySubtotal}{\tau_{\text{delay,sub}}}
\newcommand{\LeaseHoldTime}{T_{\text{hold}}}
\newcommand{\LeasePathTravel}{d_{\text{lease}}}
\newcommand{\LeaseRefreshInstant}{t_{\text{refresh}}}
\newcommand{\LeftEvasionAction}{\mathbf{a}_{\text{left}}}
\newcommand{\LeftSingularVectorMatrix}{\mathbf{P}}
\newcommand{\LengthPenaltyWeight}{\lambda_{\text{len}}}
\newcommand{\LeverArmLength}{r_{\text{arm}}}
\newcommand{\LeverArmSweepError}{e_{\text{rot}}}
\newcommand{\LewisFormFactor}{Y}
\newcommand{\LexicalDocument}{x}
\newcommand{\LexicalFrequencySaturation}{k_1}
\newcommand{\LexicalLengthNormalization}{b}
\newcommand{\LexicalQuery}{Q}
\newcommand{\LidarAzimuthAngle}{\theta_{\text{az}}}
\newcommand{\LidarBeamDirection}{\mathbf{d}}
\newcommand{\LidarElevationAngle}{\phi}
\newcommand{\LidarFramePoint}{\mathbf{p}_{\text{lidar}}}
\newcommand{\LidarReferenceFrame}{\mathcal{F}_{\text{lidar}}}
\newcommand{\LidarScanRate}{f_{\text{scan}}}
\newcommand{\LidarSweepPeriod}{T_{\text{sweep}}}
\newcommand{\LidarSweepStartTime}{t_{\text{sweep}}}
\newcommand{\LieDerivativeAlongControl}{L_{\mathbf{g}} h}
\newcommand{\LieDerivativeAlongDrift}{L_{\mathbf{f}} h}
\newcommand{\LieDerivativeOrder}{k}
\newcommand{\LikelihoodRatioWeight}{w}
\newcommand{\LimitMarginFunction}{M}
\newcommand{\LinearAcceleration}{\mathbf{a}}
\newcommand{\LinearBarrierDecayRate}{\gamma_{\text{cbf}}}
\newcommand{\LinearMomentum}{p}
\newcommand{\LinearizedVirtualInput}{\mathbf{v}}
\newcommand{\LinkAngularAcceleration}{\ddot{\theta}_{\text{link}}}
\newcommand{\LinkBandwidth}{\beta}
\newcommand{\LinkBitRate}{R_{\text{link}}}
\newcommand{\LinkLength}{l}
\newcommand{\LinkOutputPosition}{q_{\text{out}}}
\newcommand{\LintFalseAcceptFraction}{\phi}
\newcommand{\LipschitzConstant}{K}
\newcommand{\LiveAutomatonStateSet}{Q_{\text{live}}}
\newcommand{\LoadCurrent}{I_{\text{load}}}
\newcommand{\LoadInertia}{J_{\text{load}}}
\newcommand{\LoadStepCurrentDeficit}{\Delta I_{\text{step}}}
\newcommand{\LoadStepDeficitDuration}{\Delta t_{\text{step}}}
\newcommand{\LoadedEnforcerExecutionTime}{t_{\text{enf}}}
\newcommand{\LoadedJunctionTemperature}{T_{\text{load}}}
\newcommand{\LocalBatchSize}{B_{\text{local}}}
\newcommand{\LocalEpochCount}{E}
\newcommand{\LocalGradient}{\mathbf{g}}
\newcommand{\LocalInferenceEnergy}{E_{\text{local}}}
\newcommand{\LocalPathTime}{T_{\text{local}}}
\newcommand{\LocalRankIndex}{i}
\newcommand{\LocalTokenCount}{B_{\text{tok}}}
\newcommand{\LocalUpdateCount}{H_{\text{local}}}
\newcommand{\LocalityPenaltyFunction}{w}
\newcommand{\LocalizationBound}{\delta_{\text{loc}}}
\newcommand{\LogFailureRatio}{s_{\text{fail}}}
\newcommand{\LogOddsLowerClamp}{L_{\min}}
\newcommand{\LogOddsUpperClamp}{L_{\max}}
\newcommand{\LogPositionIndex}{j}
\newcommand{\LoggedEvent}{e}
\newcommand{\LoggedEventPrefix}{\mathbf{e}_{1:j}}
\newcommand{\LoggpLongMessageTime}{T_{\text{long}}}
\newcommand{\LogisticProbability}{p_{\text{sig}}}
\newcommand{\LogitMask}{\mathbf{M}}
\newcommand{\LogitMaskEntry}{M}
\newcommand{\LogitStorageSize}{s_{\text{logit}}}
\newcommand{\LogitVector}{\mathbf{z}}
\newcommand{\LogpNetworkLatency}{L_{\text{LogGP}}}
\newcommand{\LonePassAdvantage}{\hat{A}_{\text{pass}}}
\newcommand{\LongMessageGapPerByte}{G}
\newcommand{\LongestInterruptMaskTime}{t_{\text{irq\_disabled,max}}}
\newcommand{\LongitudinalFrictionCoefficient}{\mu_x}
\newcommand{\LongitudinalSlipRatio}{\lambda}
\newcommand{\LongitudinalTractionStiffness}{C_x}
\newcommand{\LongitudinalVehicleSpeed}{v_x}
\newcommand{\LookaheadStepIndex}{l}
\newcommand{\LoopAcceptanceProbability}{p_{\text{loop}}}
\newcommand{\LoopGainScalingFactor}{\kappa}
\newcommand{\LoopNestDepth}{n_{\text{loops}}}
\newcommand{\LoopOrderCount}{N_{\text{order}}}
\newcommand{\LoopParallelizationChoiceCount}{\mathcal{P}_{\text{parallel}}}
\newcommand{\LoopTurnCost}{C}
\newcommand{\LossAdjointSeed}{\bar{\mathcal{L}}}
\newcommand{\LossFunction}{\mathcal{L}}
\newcommand{\LossGradient}{g}
\newcommand{\LossGradientVector}{\mathbf{g}}
\newcommand{\LossHessian}{\mathbf{H}}
\newcommand{\LossLowerBound}{\mathcal{L}_{\inf}}
\newcommand{\LossScaleFactor}{s_{\text{loss}}}
\newcommand{\LossTimeDerivative}{\dot{\mathcal{L}}}
\newcommand{\LostMotionDeflection}{\delta_{\text{lost}}}
\newcommand{\LostSuffixTurnCount}{H_{\text{suffix},i}}
\newcommand{\LostWorkReplayTime}{T_{\text{replay}}}
\newcommand{\LotSamplingProbability}{q}
\newcommand{\LowRankLeftFactor}{\mathbf{U}}
\newcommand{\LowRankRightFactor}{\mathbf{V}}
\newcommand{\LowerPriorityFrames}{lp}
\newcommand{\LowerPriorityTasks}{lp}
\newcommand{\LowerRatioClippingWidth}{\epsilon_{\text{low}}}
\newcommand{\LqrControlWeightMatrix}{\mathbf{R}_u}
\newcommand{\LqrCostToGoMatrix}{\mathbf{P}}
\newcommand{\LqrFeedbackGain}{\mathbf{K}_{\text{lqr}}}
\newcommand{\LqrQuadraticObjective}{J}
\newcommand{\LqrStateWeightMatrix}{\mathbf{Q}_x}
\newcommand{\LshBandCount}{L}
\newcommand{\LshCandidateProbability}{p_{\text{candidate}}}
\newcommand{\LshRowsPerBand}{r}
\newcommand{\LyapunovAnalysisDomain}{\mathcal{D}}
\newcommand{\LyapunovFunction}{V}
\newcommand{\LyapunovFunctionDerivative}{\dot{V}}
\newcommand{\LyapunovPositivityMargin}{\epsilon_{\text{pos}}}
\newcommand{\LyapunovSublevelSet}{\Omega_c}
\newcommand{\MacAccumulator}{\text{acc}}
\newcommand{\MachineTaxonomyAxis}{\mathsf{Machine}}
\newcommand{\MahalanobisDistance}{d_M}
\newcommand{\ManifestTrackIndex}{k}
\newcommand{\ManipulatorBaseFrame}{\mathcal{F}_{\text{base}}}
\newcommand{\ManipulatorJacobian}{\mathbf{J}}
\newcommand{\ManualLease}{T_{\text{lease,man}}}
\newcommand{\ManualResetTime}{t_{\text{reset,manual}}}
\newcommand{\ManualReviewCost}{C_{\text{manual}}}
\newcommand{\ManualReviewFraction}{r_{\text{manual}}}
\newcommand{\MapCovarianceJacobian}{\mathbf{J}_{\text{map}}}
\newcommand{\MapOdometryTransform}{\mathbf{T}_{\text{map}}^{\text{odom}}}
\newcommand{\MapParameterEstimate}{\theta_{\text{MAP}}}
\newcommand{\MapPoseCovariance}{\boldsymbol{\Sigma}_{\text{map}}}
\newcommand{\MapReferenceFrame}{\mathcal{F}_{\text{map}}}
\newcommand{\MappedCommandTap}{a_{\text{cmd}}}
\newcommand{\MarginalFalseApprovalProbability}{p}
\newcommand{\MarginalRequestServiceTime}{t_{\text{req}}}
\newcommand{\MarginalStoppingThreshold}{\epsilon_{\text{stop}}}
\newcommand{\MarginalVelocityField}{u}
\newcommand{\MarginalizedModelParameters}{\theta'}
\newcommand{\MarkovDecisionProcess}{\mathcal{M}}
\newcommand{\MaskTokenIndex}{i}
\newcommand{\MaskedFinetuningLoss}{\mathcal{L}_{\text{SFT}}}
\newcommand{\MaskedImitationDataset}{\mathcal{D}_{\text{train}}}
\newcommand{\MaskedImitationLoss}{\mathcal{L}_{\text{imitation}}}
\newcommand{\MaskedLogitVector}{\mathbf{z}'}
\newcommand{\MaskedTokenLogit}{z'}
\newcommand{\Mass}{m}
\newcommand{\MassCenterAcceleration}{\ddot{\mathbf{c}}}
\newcommand{\MassCenterHeight}{z_c}
\newcommand{\MassCenterPosition}{\mathbf{c}}
\newcommand{\MasterProcessingTime}{t_{\text{master}}}
\newcommand{\MatchingRowCount}{K}
\newcommand{\MatrixColumnIndex}{j}
\newcommand{\MatrixEigenvalue}{\lambda}
\newcommand{\MatrixMultiplyDestination}{\mathbf{D}}
\newcommand{\MatrixRowIndex}{i}
\newcommand{\MaxBatchSize}{B_{\text{max}}}
\newcommand{\MaxBatchingWindow}{T_{\text{max}}}
\newcommand{\MaxReceivedTokenCount}{B_{\text{max}}}
\newcommand{\MaxResidentContextCount}{B_{\max}}
\newcommand{\MaximumActuatorEffort}{u_{\max}}
\newcommand{\MaximumBreakerCooldownInterval}{T_{\text{cool}}^{\max}}
\newcommand{\MaximumCompletionOffset}{c_{\max}}
\newcommand{\MaximumDepthHypothesis}{d_{\max}}
\newcommand{\MaximumEntropyObjective}{J}
\newcommand{\MaximumLoadCurrentStep}{\Delta I_{\max}}
\newcommand{\MaximumLogit}{z_{\max}}
\newcommand{\MaximumObservationAge}{t_{\text{age},\max}}
\newcommand{\MaximumPlateIndentation}{x_{\max}}
\newcommand{\MaximumRetryBackoffInterval}{b_{\max}}
\newcommand{\MaximumTurnOffDelay}{t_{\text{off, max}}}
\newcommand{\McnemarTestStatistic}{\chi^2}
\newcommand{\McuCaptureTime}{t_{\text{MCU,capture}}}
\newcommand{\McuDispatchTime}{t_{\text{MCU,dispatch}}}
\newcommand{\MealTokenKeyVector}{\mathbf{k}_{\text{meal}}}
\newcommand{\MealTokenQueryVector}{\mathbf{q}_{\text{meal}}}
\newcommand{\MeanAcceptedDraftLength}{\bar{m}}
\newcommand{\MeanAttemptCost}{c}
\newcommand{\MeanClusterSize}{m}
\newcommand{\MeanContextLength}{\bar{S}}
\newcommand{\MeanDeliveryPayloadLength}{L}
\newcommand{\MeanDocumentLength}{\overline{|x|}}
\newcommand{\MeanHoldTime}{\bar{T}_{\text{hold}}}
\newcommand{\MeanLatchContactForce}{\bar{F}}
\newcommand{\MeanMessageQueueDelay}{\bar{T}_q}
\newcommand{\MeanNeesStatistic}{\bar{\epsilon}}
\newcommand{\MeanQueryDistance}{\mu_D}
\newcommand{\MeanRolloutLength}{\bar{N}}
\newcommand{\MeanSlotOccupancy}{\bar{N}_{\text{slot}}}
\newcommand{\MeanSquaredErrorCloningLoss}{\mathcal{L}_{\text{MSE}}}
\newcommand{\MeanStoredTokensPerRecord}{\bar{S}}
\newcommand{\MeanTargetTokensPerRecord}{\bar{w}}
\newcommand{\MeanTimeBetweenFailures}{\text{MTBF}}
\newcommand{\MeanTimeToFailure}{\text{MTTF}}
\newcommand{\MeanTimeToRepair}{\text{MTTR}}
\newcommand{\MeanVerifierServiceTime}{\bar{T}_{\text{svc}}}
\newcommand{\MeasuredAxisPosition}{x_{\text{meas}}}
\newcommand{\MeasuredContactForce}{\mathbf{F}_{\text{contact}}}
\newcommand{\MeasuredJointVelocities}{\dot{\mathbf{q}}_{\text{meas}}}
\newcommand{\MeasuredPixelDepth}{Z_{\text{meas}}}
\newcommand{\MeasuredResponseTap}{a_{\text{meas}}}
\newcommand{\MeasuredSeamAccelerations}{\ddot{\mathbf{q}}_{\text{meas}}}
\newcommand{\MeasuredSeamConfiguration}{\mathbf{q}_{\text{meas}}}
\newcommand{\MeasuredSeamVelocities}{\dot{\mathbf{q}}_{\text{meas}}}
\newcommand{\MeasuredTrackedPosition}{\mathbf{p}_{\text{meas}}}
\newcommand{\MeasurementCovariance}{\boldsymbol{\Sigma}_z}
\newcommand{\MeasurementDimension}{m}
\newcommand{\MeasurementErrorStandardDeviation}{\sigma}
\newcommand{\MeasurementFunction}{h}
\newcommand{\MeasurementHistory}{\mathbf{y}_{1:k}}
\newcommand{\MeasurementInnovation}{\boldsymbol{\nu}}
\newcommand{\MeasurementMatrix}{\mathbf{H}}
\newcommand{\MeasurementNoiseCovariance}{\boldsymbol{\Sigma}_{\text{meas}}}
\newcommand{\MeasurementNoiseVector}{\mathbf{v}_{\text{meas}}}
\newcommand{\MeasurementVector}{\mathbf{y}}
\newcommand{\MeasurementVectorDerivative}{\dot{\mathbf{y}}}
\newcommand{\MeasurementWindowEnd}{t_{\text{end}}}
\newcommand{\MechanicalEnergy}{E}
\newcommand{\MechanicalEnergyDerivative}{\dot{E}}
\newcommand{\MechanicalImpedanceMap}{Z}
\newcommand{\MechanicalPlantState}{\mathbf{x}}
\newcommand{\MechanicalWork}{W}
\newcommand{\MechanismAcceptanceProbability}{p'_{\text{acc}}}
\newcommand{\MechanismAttemptCost}{C'_{\text{attempt}}}
\newcommand{\MechanismLogMoment}{\alpha_{\mathcal{M}}}
\newcommand{\MechanismOutcome}{o}
\newcommand{\MechanismOutputSet}{\mathcal{S}}
\newcommand{\MechanismOutputVector}{\mathbf{y}}
\newcommand{\MechanismRenyiPrivacyBudget}{\epsilon_{\text{R},i}}
\newcommand{\MemoryBusQueueDelay}{t_{\text{queue}}}
\newcommand{\MemoryEntryBirthGeneration}{g_{\text{birth}}}
\newcommand{\MemoryEntryDeathGeneration}{g_{\text{death}}}
\newcommand{\MemoryHierarchyLevelCount}{N_{\text{mem}}}
\newcommand{\MemoryHoldDuringWait}{O_{\text{mem}}}
\newcommand{\MemorySubsystemEnergy}{E_{\text{memory}}}
\newcommand{\MergedAttentionOutput}{\mathbf{O}^{\text{new}}}
\newcommand{\MergedSoftmaxMaximum}{m^{\text{new}}}
\newcommand{\MergedSoftmaxNormalizer}{z^{\text{new}}}
\newcommand{\MessageInjectionGap}{g}
\newcommand{\MessageQueueDelay}{T_q}
\newcommand{\MessageStartupLatency}{\alpha}
\newcommand{\MessageTimestamp}{t_{\text{msg}}}
\newcommand{\MetricDepth}{z_{\text{metric}}}
\newcommand{\MicroUnitPrefix}{\text{µ}}
\newcommand{\MicrobatchCount}{m}
\newcommand{\MicrobatchGradient}{\mathbf{g}}
\newcommand{\MicrobatchIndex}{j}
\newcommand{\MicrobatchPassTime}{T_{\text{micro},j}}
\newcommand{\MicrobatchSize}{B_{\text{micro}}}
\newcommand{\MicrocontrollerClockTime}{t_{\text{MCU}}}
\newcommand{\MillerCapacitance}{C_{\text{gd}}}
\newcommand{\MillerCharge}{Q_{\text{gd}}}
\newcommand{\MillerDisplacementCurrent}{I_{\text{miller}}}
\newcommand{\MillerPlateauDuration}{t_{\text{plateau}}}
\newcommand{\MillerPlateauVoltage}{V_{\text{plateau}}}
\newcommand{\MinHashPermutation}{\sigma}
\newcommand{\MinHashPermutationCount}{n_{\sigma}}
\newcommand{\MinHashSketchSize}{s}
\newcommand{\MiniBatchActivation}{a}
\newcommand{\MiniBatchSet}{\mathcal{B}}
\newcommand{\MinibatchGradient}{\mathbf{g}}
\newcommand{\MinimumActuatorEffort}{u_{\min}}
\newcommand{\MinimumCellSupportCount}{N_{\min}}
\newcommand{\MinimumChunkSetpointCount}{h_{\min}}
\newcommand{\MinimumCompletionOffset}{c_{\min}}
\newcommand{\MinimumDepthHypothesis}{d_{\min}}
\newcommand{\MinimumDetectableEffect}{\delta_{\text{MDE}}}
\newcommand{\MinimumPrefetchBufferCount}{Q_{\text{prefetch,min}}}
\newcommand{\MinimumRailVoltage}{V_{\text{rail,min}}}
\newcommand{\MinimumRoundTripLatency}{L_{\text{lat,min}}}
\newcommand{\MinimumStableBatchSize}{B_{\text{min}}}
\newcommand{\MinimumTransitTime}{t_{\min}}
\newcommand{\MinimumTurnOnDelay}{t_{\text{on, min}}}
\newcommand{\MisclassifiedFraction}{r_{\text{error}}}
\newcommand{\MisroutedQueryFraction}{m}
\newcommand{\MissAcceptanceProbability}{\alpha}
\newcommand{\MissPathServiceTime}{T_{\text{cold}}}
\newcommand{\MissionDuration}{T_{\text{mission}}}
\newcommand{\MissionEnergy}{E_{\text{mission}}}
\newcommand{\MissionExceedanceBudget}{\epsilon_{\text{mission}}}
\newcommand{\MissionHandoffCount}{K}
\newcommand{\MixtureComponentCount}{M}
\newcommand{\MixtureComponentCovariance}{\boldsymbol{\Sigma}_m}
\newcommand{\MixtureComponentIndex}{m}
\newcommand{\MixtureComponentMean}{\boldsymbol{\mu}_m}
\newcommand{\MixtureComponentWeight}{w_m}
\newcommand{\MixupSample}{\tilde{x}}
\newcommand{\MixupWeight}{\lambda_{\text{mix}}}
\newcommand{\MlProductivityGoodput}{\text{MPG}}
\newcommand{\MlpWeightArithmeticIntensity}{I_{\text{MLP}}}
\newcommand{\MobileBaseBarrierFunction}{h_{\text{base}}}
\newcommand{\ModelCallIndex}{i}
\newcommand{\ModelCallRequest}{\mathcal{R}}
\newcommand{\ModelDownloadEnergy}{E_{\text{download}}}
\newcommand{\ModelFlopsUtilization}{\text{MFU}}
\newcommand{\ModelGenerationIndex}{n}
\newcommand{\ModelInput}{x}
\newcommand{\ModelLifetimeCost}{C_{\text{total}}}
\newcommand{\ModelParameters}{\theta}
\newcommand{\ModelPointAbscissa}{X}
\newcommand{\ModelPointHeight}{Z}
\newcommand{\ModelPointOrdinate}{Y}
\newcommand{\ModelPrediction}{\hat{y}}
\newcommand{\ModelPredictor}{f}
\newcommand{\ModelScore}{s}
\newcommand{\ModelStepOperations}{O_{\text{model}}}
\newcommand{\ModelTime}{T_{\text{model}}}
\newcommand{\ModelTimeFraction}{f}
\newcommand{\ModelWeight}{w}
\newcommand{\MomentOrder}{\lambda_{\text{mom}}}
\newcommand{\MonitorStartupTime}{T_{\text{vmm}}}
\newcommand{\MonitoredFairnessMetricCount}{m}
\newcommand{\MonitoredFeatureLevel}{x_{\text{feat}}}
\newcommand{\MonitoredGroupCount}{k}
\newcommand{\MonitoredMetric}{X}
\newcommand{\MonitoredMetricMean}{\mu}
\newcommand{\MonitoredMetricStandardDeviation}{\sigma}
\newcommand{\MonitoringAlertCost}{C_{\text{alert}}}
\newcommand{\MonitoringComputeCost}{C_{\text{compute}}}
\newcommand{\MonitoringCostComponent}{C_*}
\newcommand{\MonitoringIngestionCost}{C_{\text{ingest}}}
\newcommand{\MonitoringStorageCost}{C_{\text{storage}}}
\newcommand{\MonotonicClockInstant}{t}
\newcommand{\MonthlyOptimizationSavings}{C_{\text{save,monthly}}}
\newcommand{\MotionBlurLength}{L}
\newcommand{\MotionCyclePeriod}{T_{\text{cycle}}}
\newcommand{\MotionModelInput}{\mathbf{u}}
\newcommand{\MotorBackEmfConstant}{K_e}
\newcommand{\MotorConstant}{K_m}
\newcommand{\MotorPhaseRmsCurrent}{I_{\text{phase}}}
\newcommand{\MotorRotorAccelerations}{\ddot{\boldsymbol{\theta}}_{\text{motor}}}
\newcommand{\MotorRotorCoordinates}{\boldsymbol{\theta}_{\text{motor}}}
\newcommand{\MotorRotorVelocities}{\dot{\boldsymbol{\theta}}_{\text{motor}}}
\newcommand{\MotorShaftDamping}{D_{\text{motor}}}
\newcommand{\MotorShaftPosition}{q_{\text{motor}}}
\newcommand{\MotorTorque}{\tau_{\text{motor}}}
\newcommand{\MotorTorqueConstant}{K_t}
\newcommand{\MotorViscousDamping}{B_{m}}
\newcommand{\MotorViscousDampingMatrix}{\mathbf{B}_m}
\newcommand{\MpcControlSequence}{\mathbf{u}_{0:N_{\text{mpc}}-1}}
\newcommand{\MpcControlSequenceTail}{\mathbf{u}_{1:N_{\text{mpc}}-1}}
\newcommand{\MpcHorizonObjective}{J}
\newcommand{\MpcPredictionHorizon}{N_{\text{mpc}}}
\newcommand{\MpcTerminalCost}{\ell_f}
\newcommand{\MpcTerminalCostMatrix}{\mathbf{P}_{N_{\text{mpc}}}}
\newcommand{\MultiAgentAcceptanceProbability}{p_{\text{multi}}}
\newcommand{\MultiDeviceRunTime}{T_N}
\newcommand{\MultimodalFusedTokenStream}{\mathbf{Z}}
\newcommand{\MultimodalObservation}{\mathbf{o}}
\newcommand{\MutatingToolAction}{a}
\newcommand{\MutualInformation}{I}
\newcommand{\NaturalLogarithmBase}{e}
\newcommand{\NearestCandidateDistance}{D_{\min}}
\newcommand{\NeesStatistic}{\epsilon}
\newcommand{\NegativeGateSupplyVoltage}{V_{\text{ee}}}
\newcommand{\NeighborCount}{k}
\newcommand{\NeighborUserIndex}{j}
\newcommand{\NeighboringDataset}{X}
\newcommand{\NetAngularBrakingDeceleration}{\alpha_{\text{net}}}
\newcommand{\NetBrakingDeceleration}{a_{\text{net}}}
\newcommand{\NetworkBandwidth}{\text{BW}_{\text{network}}}
\newcommand{\NetworkDelayStandardDeviation}{\sigma_d}
\newcommand{\NetworkEnergy}{E_{\text{network}}}
\newcommand{\NetworkFunction}{f_{\text{net}}}
\newcommand{\NetworkLatency}{L_{\text{lat,network}}}
\newcommand{\NetworkOutput}{y}
\newcommand{\NetworkTrafficVolume}{M}
\newcommand{\NeuralLyapunovFactor}{\mathbf{L}_{\phi}}
\newcommand{\NeuronActivation}{a}
\newcommand{\NeuronBias}{b}
\newcommand{\NeuronConnectionWeight}{w_{ij}}
\newcommand{\NeuronIndex}{j}
\newcommand{\NeuronPreactivation}{z}
\newcommand{\NextDecisionProcessState}{s'}
\newcommand{\NextFailureTime}{F}
\newcommand{\NextProprioceptiveObservation}{\mathbf{o}_{\text{proprio}, t+1}}
\newcommand{\NextRobotAction}{\mathbf{a}'}
\newcommand{\NextTokenDistribution}{p}
\newcommand{\NextTokenEntropy}{\mathcal{H}}
\newcommand{\NextTokenLogitFunction}{\mathbf{f}_\theta}
\newcommand{\NgramLength}{n}
\newcommand{\NicMttf}{\text{MTTF}_{\text{nic}}}
\newcommand{\NicsPerNode}{n_{\text{nic}}}
\newcommand{\NodeAcceleratorCount}{n_{\text{acc}}}
\newcommand{\NodeHbmCapacity}{M_{\text{HBM}}}
\newcommand{\NodeMtbf}{\text{MTBF}_{\text{node}}}
\newcommand{\NodeStragglerProbability}{p_{\text{straggle}}}
\newcommand{\NoisePredictionNetwork}{\boldsymbol{\epsilon}_\theta}
\newcommand{\NoisedActionChunk}{\mathbf{A}^k}
\newcommand{\NoisyClassProbability}{\tilde{p}}
\newcommand{\NoisyClassProbabilityVector}{\tilde{\mathbf{p}}}
\newcommand{\NoisyLabelSampleCount}{D_{\text{noisy}}}
\newcommand{\NominalBitRate}{R_{\text{nom}}}
\newcommand{\NominalBitTime}{T_{\text{bit,nom}}}
\newcommand{\NominalBrakingDeceleration}{a_{\text{nominal}}}
\newcommand{\NominalClearance}{C_{\text{nominal}}}
\newcommand{\NominalClockFrequency}{f_{\text{nom}}}
\newcommand{\NominalCommandWindow}{\mathbf{u}_{\text{nom}, t:t+H-1}}
\newcommand{\NominalContactForces}{\mathbf{f}_{\text{nom}}}
\newcommand{\NominalControlCommand}{\mathbf{u}_{\text{nom}}}
\newcommand{\NominalFrameInterval}{T_{\text{nominal}}}
\newcommand{\NominalFrictionCoefficient}{\mu_{\text{nom}}}
\newcommand{\NominalOscillatorFrequency}{f_{\text{nom}}}
\newcommand{\NominalPlanExpiry}{t_{\text{plan\_exp}}}
\newcommand{\NominalRatedSpeed}{v_{\text{nominal}}}
\newcommand{\NominalReferenceClearance}{c}
\newcommand{\NominalSupplyVoltage}{V_{\text{nom}}}
\newcommand{\NominalTickPeriod}{T_{\text{period}}}
\newcommand{\NominalTrackingTolerance}{\epsilon_{\text{nom}}}
\newcommand{\NonconformityScore}{s}
\newcommand{\NoninferiorityRatioMargin}{\delta}
\newcommand{\NoninferiorityTolerance}{\delta_{\text{tol}}}
\newcommand{\NonlinearBiasTorque}{\mathbf{h}}
\newcommand{\NonlinearObservationSpace}{\mathbf{O}_{\text{NL}}}
\newcommand{\NonlinearOutputFunction}{\mathbf{h}}
\newcommand{\NonzeroCount}{n_{\text{nz}}}
\newcommand{\NonzeroParameterBudget}{k_{\text{nz}}}
\newcommand{\NormWeightMatrix}{\mathbf{W}}
\newcommand{\NormalContactForce}{f_{k, \perp}}
\newcommand{\NormalContactImpulse}{P_n}
\newcommand{\NormalizationScale}{\gamma}
\newcommand{\NormalizationScaleVector}{\boldsymbol{\gamma}}
\newcommand{\NormalizationShift}{\beta}
\newcommand{\NormalizationShiftVector}{\boldsymbol{\beta}}
\newcommand{\NormalizedActionCommand}{\tilde{a}}
\newcommand{\NormalizedActionResidual}{e}
\newcommand{\NormalizedActivation}{\hat{a}}
\newcommand{\NormalizedCandidateScore}{c}
\newcommand{\NormalizedElapsedTimeRatio}{D}
\newcommand{\NormalizedGearRatio}{\tilde{N}}
\newcommand{\NormalizedImageAbscissa}{x_n}
\newcommand{\NormalizedImageOrdinate}{y_n}
\newcommand{\NormalizedMetricBaseline}{v}
\newcommand{\NormalizedPredicateMargin}{\bar{f}}
\newcommand{\NormalizedRadialDistance}{r}
\newcommand{\NormalizedStatusEnvelope}{\mathcal{N}}
\newcommand{\NormalizerTokenIndex}{w}
\newcommand{\NormalizingClassIndex}{k}
\newcommand{\NormalizingKeyIndex}{m}
\newcommand{\NormalizingNextState}{\tilde{s}}
\newcommand{\NoticeByteAllocation}{M_{\text{notice}}}
\newcommand{\NucleusProbabilityMass}{p}
\newcommand{\NullSpaceProjector}{\mathbf{N}}
\newcommand{\NullSpaceVelocityBias}{\dot{\mathbf{q}}_0}
\newcommand{\NumericBitWidth}{b}
\newcommand{\NumericalStabilityConstant}{\epsilon}
\newcommand{\ObjectHandle}{h}
\newcommand{\ObjectWrench}{\mathbf{w}_{\text{obj}}}
\newcommand{\ObservabilityMatrix}{\mathbf{O}_{\text{obs}}}
\newcommand{\ObservableModelOutput}{O}
\newcommand{\ObservationAge}{t_{\text{age}}}
\newcommand{\ObservationAgeBudget}{t_{\text{age},\max}}
\newcommand{\ObservationAgeDisplacement}{\Delta \mathbf{p}}
\newcommand{\ObservationBinding}{\lambda}
\newcommand{\ObservationByteBudget}{M_{\text{obs},\max}}
\newcommand{\ObservationCount}{N}
\newcommand{\ObservationDataset}{\mathcal{D}}
\newcommand{\ObservationEncodingTime}{t_{\text{enc}}}
\newcommand{\ObservationFunction}{h}
\newcommand{\ObservationHistory}{\mathbf{O}}
\newcommand{\ObservationHistoryLength}{H_{\text{hist}}}
\newcommand{\ObservationHistorySequence}{\mathbf{o}_{0:t}}
\newcommand{\ObservationHistoryWindow}{\mathbf{o}_{t-H_{\text{hist}}:t}}
\newcommand{\ObservationIntervalEnd}{t_{b}}
\newcommand{\ObservationIntervalLength}{T_{\text{obs}}}
\newcommand{\ObservationIntervalStart}{t_{a}}
\newcommand{\ObservationPairingLag}{\Delta t_{\text{lag}}}
\newcommand{\ObservationPayload}{\mathbf{T}_{\text{payload}}}
\newcommand{\ObservationResponseLatency}{T_{\text{total}}}
\newcommand{\ObservationTimestamp}{t_{\text{obs}}}
\newcommand{\ObservationTokenCount}{S_{\text{obs}}}
\newcommand{\ObservationTokenSequence}{\mathbf{z}_{\text{token}}}
\newcommand{\ObservedAnnotatorAgreement}{p_o}
\newcommand{\ObservedCategoryCount}{n_i^{\text{obs}}}
\newcommand{\ObservedCycleCount}{N}
\newcommand{\ObservedDataPoint}{\mathbf{x}}
\newcommand{\ObservedFailureCount}{k}
\newcommand{\ObservedFailureFraction}{\hat{p}}
\newcommand{\ObservedFreeSpace}{\mathcal{M}_{\text{free}}}
\newcommand{\ObservedLabelCount}{n}
\newcommand{\ObservedOccupiedSpace}{\mathcal{M}_{\text{occ}}}
\newcommand{\ObservedPixelCoordinates}{\tilde{\mathbf{m}}_{\text{observed}}}
\newcommand{\ObservedPlantState}{\mathbf{x}_{\text{obs}}}
\newcommand{\ObservedPointRange}{r}
\newcommand{\ObservedRelativeSpeed}{v_{\text{rel}}}
\newcommand{\ObservedSignificanceLevel}{p_{\text{val}}}
\newcommand{\ObservedSuccessFraction}{\hat{p}}
\newcommand{\ObservedTrialFailureCount}{k}
\newcommand{\ObservedViolationFraction}{V}
\newcommand{\ObservedVolume}{V_{\text{obs}}}
\newcommand{\ObstacleConfigurationSet}{\mathcal{C}_{\text{obs}}}
\newcommand{\ObstacleCostWeight}{\lambda_{\text{obs}}}
\newcommand{\ObstaclePoint}{\mathbf{o}}
\newcommand{\ObstaclePosition}{x_{\text{obstacle}}}
\newcommand{\ObstacleProximityCost}{c_{\text{obs}}}
\newcommand{\ObstacleRiskRadius}{r_{\text{risk}}}
\newcommand{\ObstacleSeparationDistance}{d}
\newcommand{\ObstacleStateSet}{\mathcal{X}_{\text{obs}}}
\newcommand{\ObstacleSurfaceArea}{A_{\text{surface}}}
\newcommand{\OccupancyCoverageMultiplier}{k_\sigma}
\newcommand{\OccupancyLogOdds}{L}
\newcommand{\OccupancyThreshold}{k}
\newcommand{\OccupiedLogOddsIncrement}{L_{\text{occ}}}
\newcommand{\OccupiedScenarioCellCount}{N_{\text{supported}}}
\newcommand{\OdometryBaseTransform}{\mathbf{T}_{\text{odom}}^{\text{base}}}
\newcommand{\OdometryCovarianceJacobian}{\mathbf{J}_{\text{odom}}}
\newcommand{\OdometryNoiseStandardDeviation}{\sigma_{w}}
\newcommand{\OdometryPoseCovariance}{\boldsymbol{\Sigma}_{\text{odom}}}
\newcommand{\OdometryReferenceFrame}{\mathcal{F}_{\text{odom}}}
\newcommand{\OfflineTransitionDataset}{\mathcal{D}_{\text{offline}}}
\newcommand{\OffloadTailNetworkTime}{t_{\text{net}}^{\text{tail}}}
\newcommand{\OffloadTailProcessingTime}{t_{\text{proc}}^{\text{tail}}}
\newcommand{\OffloadTransactionWindow}{W}
\newcommand{\OhmUnit}{\Omega}
\newcommand{\OilBulkModulus}{\beta}
\newcommand{\OnDieDecouplingCapacitance}{C_{\text{die}}}
\newcommand{\OpenLoopTransferFunction}{L}
\newcommand{\OpenLoopTransferMatrix}{\mathbf{L}}
\newcommand{\OperationChargeBound}{\bar{c}}
\newcommand{\OperationDispatchOverhead}{t_{\text{dispatch}}}
\newcommand{\OperationRecipient}{r}
\newcommand{\OperationReconciliationTime}{T_{\text{rec}}}
\newcommand{\OperationalFailureProbability}{p_F}
\newcommand{\OperationalOverheadFraction}{f_{\text{overhead}}}
\newcommand{\OperationalScenarioDistribution}{p}
\newcommand{\OperationalTaxonomyDimension}{C}
\newcommand{\OperationalTestDistribution}{\mathcal{D}}
\newcommand{\Operations}{O}
\newcommand{\OperationsPerSample}{O_{\text{sample}}}
\newcommand{\OperatorCognitiveTime}{T_{\text{cognitive}}}
\newcommand{\OperatorMotorTime}{T_{\text{motor}}}
\newcommand{\OperatorResponseLatency}{t_{\text{hum}}}
\newcommand{\OperatorSensoryTime}{T_{\text{sensory}}}
\newcommand{\OperatorStabilizationInstant}{t_{\text{stabilize}}}
\newcommand{\OperatorWindowTime}{t'}
\newcommand{\OperatorWorkspaceMemory}{M_{\text{workspace}}}
\newcommand{\OpticalFrequency}{\nu}
\newcommand{\OpticalWavelength}{\lambda_{\text{wl}}}
\newcommand{\OptimalCheckpointInterval}{T^\ast_{\text{ckpt}}}
\newcommand{\OptimalCostToGoDerivative}{\dot{V}}
\newcommand{\OptimalCostToGoFunction}{V}
\newcommand{\OptimalModelParameters}{\theta^*}
\newcommand{\OptimalStateReturn}{V_{\text{RL}}}
\newcommand{\OptimizationBreakevenTime}{T_{\text{breakeven}}}
\newcommand{\OptimizationImplementationCost}{C_{\text{optimization}}}
\newcommand{\OptimizationIterate}{x}
\newcommand{\OptimizerStateMemory}{M_{\text{optimizer}}}
\newcommand{\OptimizerStepIndex}{t}
\newcommand{\OptimizerStepTime}{T_{\text{update}}}
\newcommand{\OptimizerUpdateCount}{T}
\newcommand{\OptimumMissFactor}{x}
\newcommand{\OrderedTestRank}{r}
\newcommand{\OrientationTolerance}{\theta_{\text{tol}}}
\newcommand{\OrphanSweepInterval}{T}
\newcommand{\OscillationPriorStateDigest}{h_{\text{state},t-2}}
\newcommand{\OscillatorAcceleration}{\ddot{q}}
\newcommand{\OscillatorNaturalFrequency}{\omega}
\newcommand{\OscillatorPosition}{q}
\newcommand{\OscillatorStepVelocity}{v}
\newcommand{\OscillatorVelocity}{\dot{q}}
\newcommand{\OutcomeAlphabet}{\mathcal{X}}
\newcommand{\OutcomeCheckPassProbability}{p_{\text{out}}}
\newcommand{\OutcomeCheckSlotTime}{T_{\text{out}}}
\newcommand{\OutcomePairPrivacyLoss}{\mathcal{L}_{\text{priv},(X,X')}^{(o)}}
\newcommand{\OutcomeStandardDeviation}{\sigma}
\newcommand{\OutgoingChannelCommand}{u_{\text{prior}}}
\newcommand{\OutgoingCommandDerivative}{\dot{u}_{\text{prior}}}
\newcommand{\OutputBearingDamping}{D_{\text{joint}}}
\newcommand{\OutputChannel}{y}
\newcommand{\OutputChannelCount}{C_{\text{out}}}
\newcommand{\OutputChannelIndex}{k}
\newcommand{\OutputComponentFunction}{h}
\newcommand{\OutputDimension}{p}
\newcommand{\OutputFeatureMapHeight}{H_{\text{out}}}
\newcommand{\OutputFeatureMapWidth}{W_{\text{out}}}
\newcommand{\OutputIndex}{\ell}
\newcommand{\OutputLayerBiasVector}{\mathbf{b}_{\text{out}}}
\newcommand{\OutputLayerWeightMatrix}{\mathbf{W}_{\text{out}}}
\newcommand{\OutputLength}{K}
\newcommand{\OutputLengthStandardDeviation}{\sigma}
\newcommand{\OutputLimit}{K_{\max}}
\newcommand{\OutputLogit}{z}
\newcommand{\OutputNodeAdjoint}{\bar{v}_W}
\newcommand{\OutputNodePrimal}{v_W}
\newcommand{\OutputProjectionOperations}{O_{\text{out}}}
\newcommand{\OutputQuantizationScale}{s_Y}
\newcommand{\OutputRelativeDegree}{r}
\newcommand{\OutputToken}{y}
\newcommand{\OutputTokenPrefix}{y_{<t}}
\newcommand{\OutputTokenPrice}{c_{\text{out}}}
\newcommand{\OutputTokenSequence}{y_{1:K}}
\newcommand{\OutputTorqueCeiling}{\tau_{\text{out,max}}}
\newcommand{\OutstandingItemCount}{N_{\text{out}}}
\newcommand{\OverheadCameraEmbedding}{\mathbf{e}_{\text{overhead}}}
\newcommand{\OverlappedBackwardCommunicationTime}{T_{\text{pipelined}}}
\newcommand{\OverlappedTime}{T_{\text{overlap}}}
\newcommand{\OverlappingGaussianSet}{\mathcal{N}}
\newcommand{\OversubscriptionRatio}{R}
\newcommand{\OwnershipAcquisitionTime}{T_{\text{own}}}
\newcommand{\PackageDecouplingCapacitance}{C_{\text{pkg}}}
\newcommand{\PackageInductance}{L_{\text{pkg}}}
\newcommand{\PackageResistance}{R_{\text{pkg}}}
\newcommand{\PackageThermalCapacitance}{C_{\text{th}}}
\newcommand{\PackageThermalTimeConstant}{\tau_{\text{th}}}
\newcommand{\PackedExampleIndex}{k}
\newcommand{\PackedExampleLength}{s}
\newcommand{\PackedExampleOffset}{b}
\newcommand{\PacketBuffer}{b}
\newcommand{\PaddingWasteFraction}{W}
\newcommand{\PageRankDampingFactor}{d}
\newcommand{\PageRankScoreVector}{\mathbf{r}}
\newcommand{\PairedAcceptanceDifference}{\Delta}
\newcommand{\PairedDifferenceLowerLimit}{L_{\Delta}}
\newcommand{\PairedDifferenceUpperLimit}{U_{\Delta}}
\newcommand{\PairedOutcomeCellCount}{n}
\newcommand{\PairedRandomVariable}{Y}
\newcommand{\PairedTaskIndex}{j}
\newcommand{\PairedTimeInstant}{s}
\newcommand{\PairedVerdictCorrelation}{\hat{\phi}}
\newcommand{\PairingLagCeiling}{\Delta t_{\text{lag,max}}}
\newcommand{\PairwiseCoordinationCoefficient}{\beta_{\text{pair}}}
\newcommand{\PairwiseMaskSecret}{\mathbf{s}}
\newcommand{\ParallelEnvironmentCount}{n_{\text{env}}}
\newcommand{\ParallelFraction}{f_{\text{parallel}}}
\newcommand{\ParallelLoopCount}{k_{\text{parallel}}}
\newcommand{\ParallelRigCount}{N_{\text{rig}}}
\newcommand{\ParameterPayload}{M_{\text{param}}}
\newcommand{\ParameterRandomizationRanges}{\mathcal{P}}
\newcommand{\ParameterScaleCoefficient}{A}
\newcommand{\ParameterScalingExponent}{\alpha}
\newcommand{\ParameterServerCount}{K_{\text{srv}}}
\newcommand{\ParameterSpace}{\Theta}
\newcommand{\ParameterSpaceDirection}{u}
\newcommand{\ParameterStreamingTime}{t_{\text{stream}}}
\newcommand{\ParameterVelocity}{\dot{\theta}}
\newcommand{\ParameterizedPredictor}{f_{\theta}}
\newcommand{\Parameters}{P}
\newcommand{\ParametricProposalDistribution}{q_{\boldsymbol{\psi}}}
\newcommand{\ParasiticLoopInductance}{L_{\text{parasitic}}}
\newcommand{\ParentCapabilityGrant}{\Gamma_{\text{parent}}}
\newcommand{\ParentFreeBalance}{F_{P}}
\newcommand{\ParentNodeIndex}{k}
\newcommand{\ParentReservedFunds}{R_{P}}
\newcommand{\ParentSettledCharges}{E_{P}}
\newcommand{\ParetoMinimumDemand}{x_{\min}}
\newcommand{\ParetoTailExponent}{\alpha_{\text{tail}}}
\newcommand{\ParetoTaskDemand}{X}
\newcommand{\ParticipatingClientCount}{N_{\text{clients}}}
\newcommand{\PartnerBitIndex}{k}
\newcommand{\PassAtKEstimate}{\widehat{\operatorname{pass@}k}}
\newcommand{\PassedTrialCount}{N_{\text{pass}}}
\newcommand{\PassingRunCount}{s}
\newcommand{\PassingSampleCount}{c}
\newcommand{\PassiveModelPrediction}{\hat{Y}}
\newcommand{\PastSynchronizationStepIndex}{j}
\newcommand{\PatchColumnIndex}{w}
\newcommand{\PatchRowIndex}{h}
\newcommand{\PatchTokenCount}{N}
\newcommand{\PathAcceleration}{\ddot{s}}
\newcommand{\PathAccelerationInput}{u}
\newcommand{\PathAccelerationLowerBound}{\ddot{s}_{\min}}
\newcommand{\PathAccelerationTorqueCoefficient}{\mathbf{a}_{\tau}}
\newcommand{\PathAccelerationUpperBound}{\ddot{s}_{\max}}
\newcommand{\PathCoordinate}{s}
\newcommand{\PathDelayAsymmetry}{\Delta t_{\text{asym}}}
\newcommand{\PathGridPointCount}{N_{\text{grid}}}
\newcommand{\PathVelocity}{\dot{s}}
\newcommand{\PathVelocitySquaredTorqueCoefficient}{\mathbf{b}_{\tau}}
\newcommand{\PayloadGravityTorque}{\tau_{g}}
\newcommand{\PayloadLeverArm}{r}
\newcommand{\PcieLinkFailureRate}{\lambda_{\text{PCIe}}}
\newcommand{\PdnBranchCurrent}{I_{\text{branch}}}
\newcommand{\PdnBranchResistance}{R_{\text{PDN}}}
\newcommand{\PdnTargetImpedance}{Z_{\text{target}}}
\newcommand{\PeakBridgeJerk}{j_{\text{peak}}}
\newcommand{\PeakContactForce}{F_{\text{peak}}}
\newcommand{\PeakCopperLossPower}{P_{\text{peak}}}
\newcommand{\PeakCurrent}{I_{\text{peak}}}
\newcommand{\PeakMemoryBandwidth}{\text{BW}_{\text{peak}}}
\newcommand{\PeakPenetrationDepth}{\delta_{\max}}
\newcommand{\PeakRate}{R_{\text{peak}}}
\newcommand{\PeakRegenerativePower}{P_{\text{regen, peak}}}
\newcommand{\PeakRotorAngularSpeed}{\omega_{\max}}
\newcommand{\PeakSlipRatio}{\lambda_{\text{peak}}}
\newcommand{\PeakStopDeceleration}{a_{\text{peak}}}
\newcommand{\PeakTorque}{\tau_{\text{peak}}}
\newcommand{\PeakTractionCoefficient}{\mu_{\text{peak}}}
\newcommand{\PearsonFitStatistic}{\chi^2}
\newcommand{\PeerReviewerIndex}{i}
\newcommand{\PeerToolCallIndex}{j}
\newcommand{\PenaltyContactDamping}{c}
\newcommand{\PenaltyContactStiffness}{k_{\text{pen}}}
\newcommand{\PenaltyPenetrationDepth}{\delta_{\text{pen}}}
\newcommand{\PenaltyRestitutionDuration}{\Delta t_{\text{res}}}
\newcommand{\PendulumNaturalFrequency}{\omega_0}
\newcommand{\PenetrationDepth}{\delta}
\newcommand{\PenetrationRate}{\dot{\delta}}
\newcommand{\PenultimateLayerWidth}{n_{N_L-1}}
\newcommand{\PerDeviceComputeTime}{T_{\text{compute,local}}}
\newcommand{\PerDeviceWeightReadTime}{T_{\text{read}}}
\newcommand{\PerExperimentComputeCost}{C_{\text{compute,per-exp}}}
\newcommand{\PerExperimentEngineeringCost}{C_{\text{engineer,per-exp}}}
\newcommand{\PerFrameDetectionProbability}{p_{\text{frame}}}
\newcommand{\PerGpuNetworkFailureRate}{\lambda_{\text{network/GPU}}}
\newcommand{\PerGpuPowerFailureRate}{\lambda_{\text{power/GPU}}}
\newcommand{\PerGpuTotalFailureRate}{\lambda_{\text{total/GPU}}}
\newcommand{\PerStepCostBound}{C_{\max}}
\newcommand{\PerStepErrorRate}{\epsilon}
\newcommand{\PerStreamTokenRate}{R}
\newcommand{\PerTaskRunCount}{R}
\newcommand{\PerTestSignificanceLevel}{\alpha_{\text{sig}}'}
\newcommand{\PerTokenDecodeTime}{t_{\text{decode}}}
\newcommand{\PerTokenKlEstimate}{\hat{\mathcal{D}}}
\newcommand{\PerTokenMaskingTime}{t_{\text{mask}}}
\newcommand{\PerTokenPrefillTime}{t_{\text{prefill}}}
\newcommand{\PerWorkerBatchSize}{B_{\text{per-worker}}}
\newcommand{\PerceptionDepthCovariance}{\boldsymbol{\Sigma}_{\text{depth}}}
\newcommand{\PerceptionDispatchTime}{t_{\text{IPC}}}
\newcommand{\PerceptionErrorScale}{\epsilon_{\text{scale}}}
\newcommand{\PeriodicPeakWindingTemperature}{T_{\text{peak}}}
\newcommand{\PeriodicTaskCount}{n}
\newcommand{\PermanentMagnetFluxLinkage}{\lambda_{\text{pm}}}
\newcommand{\PermissionLoopPeriod}{T_{\text{tick}}}
\newcommand{\PermissionPathKernel}{G_\kappa}
\newcommand{\PermissionPathParameters}{\kappa}
\newcommand{\PermissionTickWaitTime}{t_{\text{wait}}}
\newcommand{\PermissionTickWcet}{T_{\text{wcet}}}
\newcommand{\PermittedActions}{\mathcal{A}_{\text{perm}}}
\newcommand{\PermittedUsePassProbability}{p_{\text{use}}}
\newcommand{\PersonApproachTravel}{S_h}
\newcommand{\PersonPositionUncertainty}{Z_d}
\newcommand{\PersonalizationPenaltyWeight}{\lambda_{\text{reg}}}
\newcommand{\PersonalizationVector}{\mathbf{p}}
\newcommand{\PerturbationNoiseStandardDeviation}{\sigma}
\newcommand{\PerturbationNormOrder}{p}
\newcommand{\PerturbedPose}{\mathbf{T}'}
\newcommand{\PerturbedSignalDimension}{D}
\newcommand{\PerturbedSignalVector}{\mathbf{x}}
\newcommand{\PfcWatchdogTimeout}{T_{\text{watchdog}}}
\newcommand{\PhaseInductance}{L_{\text{phase}}}
\newcommand{\PhaseJoulePower}{P_{\text{phase}}}
\newcommand{\PhaseMargin}{\Phi_m}
\newcommand{\PhaseResistance}{R_{\text{phase}}}
\newcommand{\PhotodiodeQuantumEfficiency}{\eta_{\text{QE}}}
\newcommand{\PhysicalPlantDynamics}{f_{\text{real}}}
\newcommand{\PhysicalRestoreTime}{t_{\text{physical\_restore}}}
\newcommand{\PhysicalReturnLevel}{z_{T, \text{real}}}
\newcommand{\PhysicalStateTrajectory}{s_{\text{real}}}
\newcommand{\PhysicalStlRobustness}{\rho_{\text{real}}}
\newcommand{\PhysicalTrajectorySet}{\mathcal{S}_{\text{real}}}
\newcommand{\PhysicalWorldState}{s}
\newcommand{\PidDerivativeGain}{K_d}
\newcommand{\PidIntegralGain}{K_i}
\newcommand{\PidProportionalGain}{K_p}
\newcommand{\PidProportionalGainMatrix}{\mathbf{K}_p}
\newcommand{\PipelineBubbleFraction}{b_{\text{pipe}}}
\newcommand{\PipelineBufferMemory}{M_{\text{required}}}
\newcommand{\PipelineClockSkew}{t_{\text{skew}}}
\newcommand{\PipelineFlushDelay}{t_{\text{hw\_pipe}}}
\newcommand{\PipelineIterationTime}{T_{\text{iteration}}}
\newcommand{\PipelineParallelDegree}{N_{\text{PP}}}
\newcommand{\PipelineTimeSlot}{t}
\newcommand{\PipelinedExecutionTime}{T_{\text{pipelined}}}
\newcommand{\PistonArea}{A}
\newcommand{\PixelColumnCoordinate}{u}
\newcommand{\PixelLastEventTime}{t_{\text{last}}}
\newcommand{\PixelOpacityContribution}{\alpha'}
\newcommand{\PixelRowCoordinate}{v}
\newcommand{\PixelRowStandardDeviation}{\sigma_v}
\newcommand{\PixelStandardDeviation}{\sigma_u}
\newcommand{\PlaintextInput}{m}
\newcommand{\PlanAction}{a}
\newcommand{\PlanarHomographyMatrix}{\mathbf{H}}
\newcommand{\PlanarPositionEmbedding}{\mathbf{E}_{\text{pos}}^{2D}}
\newcommand{\PlanarSpecialEuclideanGroup}{SE(2)}
\newcommand{\PlanckConstant}{h}
\newcommand{\PlanningOperator}{o}
\newcommand{\PlanningStageLatency}{T_{\text{plan}}}
\newcommand{\PlanningStartInstant}{t_{\text{plan}}}
\newcommand{\PlantDynamicsFunction}{\mathbf{f}}
\newcommand{\PlantDynamicsParameters}{\theta_{\text{plant}}}
\newcommand{\PlantOutcomeFunction}{g}
\newcommand{\PlantParameters}{m}
\newcommand{\PlantStateAcceleration}{\ddot{\mathbf{x}}}
\newcommand{\PlantStateComponentCount}{N_s}
\newcommand{\PlantStateDimension}{n}
\newcommand{\PlantStateRate}{\dot{\mathbf{x}}}
\newcommand{\PlantStateSpace}{\mathcal{X}}
\newcommand{\PlantTransitionDensity}{p_m}
\newcommand{\PlantTransitionKernel}{\mathcal{T}}
\newcommand{\PlatformResourceCapacity}{\text{Cap}}
\newcommand{\PlatformResourceIndex}{i}
\newcommand{\PlatformTotalCost}{C_{\text{platform}}}
\newcommand{\PlatformUtilization}{U_{\text{platform}}}
\newcommand{\PointClearanceMargin}{d_{\text{margin}}}
\newcommand{\PointToPointMessageSize}{n}
\newcommand{\PointToPointTransferTime}{T}
\newcommand{\PoisonedModel}{f_{\mathcal{S} \cup \mathcal{S}_{\text{poison}}}}
\newcommand{\PoisoningDataset}{\mathcal{S}_{\text{poison}}}
\newcommand{\PoisoningTargetDataset}{\mathcal{S}_{\text{test}}}
\newcommand{\PoissonSubintervalCount}{n}
\newcommand{\Policy}{\pi_\theta}
\newcommand{\PolicyAction}{a}
\newcommand{\PolicyActionStandardDeviation}{\sigma^{\pi}}
\newcommand{\PolicyActionWindow}{\mathbf{A}_{t:t+H-1}}
\newcommand{\PolicyCheckpoint}{v}
\newcommand{\PolicyEnsembleCovariance}{\boldsymbol{\Sigma}_{\pi}}
\newcommand{\PolicyEntropy}{\mathcal{H}}
\newcommand{\PolicyGaussianMean}{\boldsymbol{\mu}_{\theta}}
\newcommand{\PolicyGaussianMeanComponent}{\mu^{\pi}}
\newcommand{\PolicyGaussianStandardDeviation}{\boldsymbol{\sigma}_{\theta}}
\newcommand{\PolicyGradientBaseline}{b}
\newcommand{\PolicyGradientEstimate}{\widehat{g}}
\newcommand{\PolicyHistoryActionReturn}{Q^{\pi}}
\newcommand{\PolicyHistoryAdvantage}{A^{\pi}}
\newcommand{\PolicyImitationLoss}{\mathcal{L}_{\text{policy}}}
\newcommand{\PolicyLipschitzBound}{L_{\text{lip}}}
\newcommand{\PolicyObservedState}{s}
\newcommand{\PolicyPassRate}{f}
\newcommand{\PolicyProbabilityRatio}{\rho}
\newcommand{\PolicyRemainingReturn}{V^{\pi}}
\newcommand{\PolicyRequestLength}{S_{\pi}}
\newcommand{\PolicyStateActionDistribution}{\rho_{\pi_\theta}}
\newcommand{\PolicyTrajectoryDistribution}{p_\theta}
\newcommand{\PolicyTti}{T_{\text{TTI}}}
\newcommand{\PolicyUpdateStepTime}{T_{\text{step}}}
\newcommand{\PolyakAveragingCoefficient}{\tau}
\newcommand{\PolynomialCoefficientVector}{\mathbf{a}}
\newcommand{\PolynomialTrajectoryCoefficient}{a}
\newcommand{\PomdpActionSet}{\mathsf{A}}
\newcommand{\PomdpObservationFunction}{\mathsf{O}}
\newcommand{\PomdpObservationSet}{\Omega}
\newcommand{\PomdpRewardFunction}{\mathsf{R}}
\newcommand{\PomdpStateSpace}{\mathsf{S}}
\newcommand{\PomdpTransitionFunction}{\mathsf{T}}
\newcommand{\PoolResidentMemory}{M_{\text{pool}}}
\newcommand{\PooledAcceptanceProbability}{\bar{p}}
\newcommand{\PooledConversionRate}{\hat{p}}
\newcommand{\PooledSampleApprovalRate}{\hat{p}}
\newcommand{\PopulationStabilityBinCount}{n_{\text{bins}}}
\newcommand{\PopulationStabilitySmoothingConstant}{\epsilon_{\text{smooth}}}
\newcommand{\PortCycleNetEnergy}{\Delta E}
\newcommand{\PortEffort}{\mathbf{F}}
\newcommand{\PortFlow}{\dot{\mathbf{x}}}
\newcommand{\PortInput}{\mathbf{u}}
\newcommand{\PortOutput}{\mathbf{y}}
\newcommand{\PortStoredEnergy}{E}
\newcommand{\PortVelocity}{v}
\newcommand{\Pose}{\mathbf{T}}
\newcommand{\PoseTwistPerturbation}{\boldsymbol{\epsilon}}
\newcommand{\PoseTwistPerturbationMatrix}{\hat{\boldsymbol{\epsilon}}}
\newcommand{\PositionComponent}{p}
\newcommand{\PositionConfidenceEllipsoidRadius}{\chi_{3,0.95}}
\newcommand{\PositionErrorBound}{E}
\newcommand{\PositionErrorCeiling}{e_{\max}}
\newcommand{\PositionErrorCovariance}{\mathbf{P}_{pp}}
\newcommand{\PositionErrorEnvelope}{e}
\newcommand{\PositionLossMask}{m}
\newcommand{\PositionUncertaintyRadius}{r}
\newcommand{\PositionalTaskTolerance}{r_{\text{tol}}}
\newcommand{\PositiveClassInput}{x_{+}}
\newcommand{\PositiveIntegerExponent}{n}
\newcommand{\PostContactDrivenStroke}{\Delta x_{\text{driven}}}
\newcommand{\PostImpactNormalVelocity}{v_n^+}
\newcommand{\PostRevocationDelay}{\tau_{\text{rev}}}
\newcommand{\PosteriorCovarianceMatrix}{\boldsymbol{\Sigma}_{\text{post}}}
\newcommand{\PosteriorDifferentialEntropy}{h_{\text{post}}}
\newcommand{\PostprocessingLatency}{L_{\text{lat,post}}}
\newcommand{\PotentialOutcome}{Y^{\text{pot}}}
\newcommand{\PowerCriticalQuantile}{z_{\beta}}
\newcommand{\PowerLimitBase}{a}
\newcommand{\PowerRailInductance}{L_{\text{bus}}}
\newcommand{\PowerRailResistance}{R_{\text{bus}}}
\newcommand{\PoweredHoldCommand}{\mathbf{u}_{\text{hold}}}
\newcommand{\PoweredHoldState}{\mathbf{x}_{\text{hold}}}
\newcommand{\PoweredServerCount}{N}
\newcommand{\PpoClippedSurrogateObjective}{\mathcal{L}^{\text{CLIP}}}
\newcommand{\PqApproximateDistance}{\tilde{d}}
\newcommand{\PqCentroidCode}{c^{\text{pq}}}
\newcommand{\PqSubspaceIndex}{j}
\newcommand{\PqSubvectorCount}{m}
\newcommand{\PreForwardEnvironmentState}{\sigma_0}
\newcommand{\PreImpactNormalVelocity}{v_n^-}
\newcommand{\PreImpactSeparationDistance}{d_{\text{sep}}}
\newcommand{\PrePivotCatchRate}{v}
\newcommand{\PreTriggerWindowDuration}{T_{\text{pre}}}
\newcommand{\PreactivationMatrix}{\mathbf{Z}}
\newcommand{\PreactivationVector}{\mathbf{z}}
\newcommand{\PrebrakeDelay}{\tau_{\text{delay}}}
\newcommand{\PrebrakeDelayCeiling}{\tau_{\text{delay},\max}}
\newcommand{\PredecessorGraphVertex}{u}
\newcommand{\PredicateLipschitzConstant}{L_{\phi}}
\newcommand{\PredicateNormalizationScale}{c}
\newcommand{\PredictedActionComponent}{\hat{a}}
\newcommand{\PredictedClassProbability}{p}
\newcommand{\PredictedConfidence}{\hat{p}}
\newcommand{\PredictedDecision}{\hat{Y}}
\newcommand{\PredictedEnvironmentLatent}{\hat{\mathbf{z}}}
\newcommand{\PredictedErrorCovariance}{\mathbf{P}_{k|k-1}}
\newcommand{\PredictedForceReading}{\hat{y}}
\newcommand{\PredictedOutput}{\hat{\mathbf{y}}}
\newcommand{\PredictedOutputComponent}{\hat{y}}
\newcommand{\PredictedPolicyAction}{\hat{\mathbf{a}}}
\newcommand{\PredictedProtectedAttribute}{\hat{a}}
\newcommand{\PredictedRelativeDepth}{z_{\text{pred}}}
\newcommand{\PredictedStateEmbedding}{\mathbf{e}_{\text{state}}}
\newcommand{\PredictedStateEstimate}{\hat{\mathbf{x}}_{k|k-1}}
\newcommand{\PredictionHeadFunction}{g}
\newcommand{\PredictionStepIndex}{i}
\newcommand{\PredictiveEntropy}{H_{\text{pred}}}
\newcommand{\PreemptionFanoutCount}{k}
\newcommand{\PreemptionRate}{\lambda_{\text{preempt}}}
\newcommand{\PreemptionTaxTime}{T_{\text{preempt}}}
\newcommand{\PreferenceMargin}{z}
\newcommand{\PreferencePairDataset}{\mathcal{D}}
\newcommand{\PreferenceScale}{\beta}
\newcommand{\PreferenceScoredPositionSet}{\mathcal{A}}
\newcommand{\PreferredReferenceRelativeScore}{\Delta_w}
\newcommand{\PreferredTrajectory}{\tau_w}
\newcommand{\PrefetchBufferCount}{N_{\text{prefetch}}}
\newcommand{\PrefillAllocatedTokenCount}{C}
\newcommand{\PrefillArithmeticIntensity}{I_{\text{prefill}}}
\newcommand{\PrefillChunkSize}{C_{\text{chunk}}}
\newcommand{\PrefillOperations}{O_{\text{prefill}}}
\newcommand{\PrefillRequestIndex}{i}
\newcommand{\PrefillTime}{T_{\text{prefill}}}
\newcommand{\PrefixHitRate}{\rho_{\text{prefix}}}
\newcommand{\PregraspPosition}{\mathbf{p}_{\text{pre}}}
\newcommand{\PreprocessingLatency}{L_{\text{lat,pre}}}
\newcommand{\PreprocessingServiceTime}{T_{\text{preprocessing}}}
\newcommand{\PreprocessingThroughput}{R_{\text{preprocessing}}}
\newcommand{\PresaturationTorqueCommand}{\boldsymbol{\tau}_{\text{cmd}}}
\newcommand{\PreviousLayerWidth}{n_{\ell-1}}
\newcommand{\PreviousPeriodCost}{C_{\text{previous}}}
\newcommand{\PreviousRangeObservationHistory}{z_{1:t-1}}
\newcommand{\PreviousUpdatedErrorCovariance}{\mathbf{P}_{k-1|k-1}}
\newcommand{\PreviousUpdatedStateEstimate}{\hat{\mathbf{x}}_{k-1|k-1}}
\newcommand{\PrimitiveOperation}{\phi}
\newcommand{\PrincipalPointColumn}{c_x}
\newcommand{\PrincipalPointRow}{c_y}
\newcommand{\PriorCovarianceMatrix}{\boldsymbol{\Sigma}_{\text{prior}}}
\newcommand{\PriorDifferentialEntropy}{h_{\text{prior}}}
\newcommand{\PriorStandardDeviation}{\sigma_0}
\newcommand{\PriorTurnCount}{j}
\newcommand{\PrivacyAdditiveSlack}{\delta}
\newcommand{\PrivacyBudget}{\epsilon}
\newcommand{\PrivacyLossVariable}{\mathcal{L}_{\text{priv}}}
\newcommand{\PrivacyNoiseMultiplier}{\sigma}
\newcommand{\PrivatizedQuery}{\tilde{f}}
\newcommand{\PrivilegeTrapTime}{T_{\text{trap}}}
\newcommand{\PrivilegedSimulatorState}{s_{\text{priv}}}
\newcommand{\PrivilegedStateDimension}{d_{\text{priv}}}
\newcommand{\PrivilegedStateEncoder}{E}
\newcommand{\ProbabilityFunction}{p}
\newcommand{\ProbabilitySimplex}{\Delta}
\newcommand{\ProbedCellCount}{n_{\text{probe}}}
\newcommand{\ProcessConditionCheckTime}{T_{\text{proc}}}
\newcommand{\ProcessConditionPassProbability}{p_{\text{proc}}}
\newcommand{\ProcessNoiseCovariance}{\mathbf{Q}}
\newcommand{\ProcessNoiseIntensity}{\mathbf{Q}}
\newcommand{\ProcessNoiseVector}{\mathbf{w}}
\newcommand{\ProcessedDataVolume}{D_{\text{vol,processed}}}
\newcommand{\ProcessedSampleCount}{N_{\text{samples}}}
\newcommand{\ProcessingBufferCount}{N_{\text{processing}}}
\newcommand{\ProcessingPrice}{R_{\text{process/GB}}}
\newcommand{\ProductFactorIndex}{j}
\newcommand{\ProductionExecutionCount}{N_{\text{prod}}}
\newcommand{\ProductionModelCount}{N_{\text{models}}}
\newcommand{\ProductionOnlyFailureCount}{n_{\text{prod}}}
\newcommand{\ProfileAccelerationBound}{a_{\max}}
\newcommand{\ProfileJerk}{\dot{a}}
\newcommand{\ProgramGoodput}{\eta_{\text{program}}}
\newcommand{\ProgramInvariantPredicate}{P}
\newcommand{\ProgramState}{s}
\newcommand{\ProgramStateSpace}{\Sigma}
\newcommand{\ProjectedSeamState}{\hat{\mathbf{x}}_{\text{seam}}}
\newcommand{\ProjectedTrajectoryRecord}{R}
\newcommand{\ProjectedTurnGradientContribution}{Z}
\newcommand{\ProjectionBallRadius}{\epsilon}
\newcommand{\ProjectionConstraintSet}{\mathcal{C}}
\newcommand{\ProjectiveDistanceSample}{s}
\newcommand{\ProjectiveRayScale}{\lambda}
\newcommand{\ProjectiveScaleFactor}{s}
\newcommand{\PromotedFusionInputRank}{r'}
\newcommand{\PromptLength}{S_{\text{prompt}}}
\newcommand{\PromptToken}{x}
\newcommand{\PromptTokensSent}{S_{\text{sent}}}
\newcommand{\PropagatedPositionStandardDeviation}{\sigma_p}
\newcommand{\PropensityPriorApprovalShape}{a}
\newcommand{\PropensityPriorRejectionShape}{b}
\newcommand{\ProportionTestStatistic}{z}
\newcommand{\ProportionalGainMatrix}{\mathbf{K}_{p}}
\newcommand{\ProportionalPotentialEnergy}{\mathcal{L}_{\text{pos}}}
\newcommand{\ProposalDeserializationTime}{t_{\text{deser}}}
\newcommand{\ProposalExpiryInstant}{t_{\text{valid}}}
\newcommand{\ProposalFirstWaypoint}{\mathbf{a}_0}
\newcommand{\ProposalLinkTransportTime}{t_{\text{link}}}
\newcommand{\ProposalParameterVector}{\boldsymbol{\psi}}
\newcommand{\ProposalPayload}{\mathcal{P}}
\newcommand{\ProposedAccess}{r}
\newcommand{\ProposedContactForce}{F_{\text{nom}}}
\newcommand{\ProposedEndEffectorPoseSequence}{\mathbf{X}_{1:H}}
\newcommand{\ProposedGripperCommandSequence}{\mathbf{g}_{1:H}}
\newcommand{\ProposedJointPositionSequence}{\mathbf{Q}_{1:H}}
\newcommand{\ProposedJointVelocitySequence}{\dot{\mathbf{Q}}_{1:H}}
\newcommand{\ProposedOperation}{o}
\newcommand{\ProposerConfidenceScore}{\hat{p}}
\newcommand{\ProposerEvaluationRate}{f}
\newcommand{\ProposerInferenceTime}{t_{\text{infer}}}
\newcommand{\ProprioceptiveInputSpace}{\mathcal{X}}
\newcommand{\ProprioceptiveInputVector}{\mathbf{x}}
\newcommand{\ProprioceptiveTokenEmbeddings}{\mathbf{z}_{\text{proprio}}}
\newcommand{\ProtectedAttribute}{a}
\newcommand{\ProtectedGroupMembership}{G}
\newcommand{\ProtectedTrainingRecord}{R}
\newcommand{\ProtectionSwitchResistance}{R_{\text{switch}}}
\newcommand{\ProtectiveClearanceMargin}{\delta_{\text{margin}}}
\newcommand{\ProtectiveSeparationDistance}{S_p}
\newcommand{\ProtectiveSpringStiffness}{k_{\text{spring}}}
\newcommand{\ProtectiveSpringTravel}{\delta}
\newcommand{\ProxyTrajectoryReward}{\hat{R}}
\newcommand{\PrunedWeightMatrix}{\hat{\mathbf{W}}}
\newcommand{\PruningMask}{\mathbf{M}}
\newcommand{\PruningMaskEntry}{M_{i,j}}
\newcommand{\PruningThreshold}{\delta_{\text{prune}}}
\newcommand{\PsuMttf}{\text{MTTF}_{\text{psu}}}
\newcommand{\PtpExchangeTimestamp}{t}
\newcommand{\PtpForwardPathDelay}{T_{\text{prop}, M \to S}}
\newcommand{\PtpHardwareTimestamp}{t_{\text{PTP}}}
\newcommand{\PtpPropagationDelay}{T_{\text{prop}}}
\newcommand{\PtpReversePathDelay}{T_{\text{prop}, S \to M}}
\newcommand{\PublicationEpoch}{t_{\text{pub}}}
\newcommand{\PufChallenge}{C}
\newcommand{\PufResponse}{R}
\newcommand{\PufResponseBit}{r}
\newcommand{\PulseRoundTripTime}{\Delta t}
\newcommand{\PureNoiseActionChunk}{\mathbf{A}^N}
\newcommand{\PureTransportDelay}{T_d}
\newcommand{\PwmPeriod}{T_{\text{pwm}}}
\newcommand{\QuadratureAxisInductance}{L_q}
\newcommand{\QuadratureAxisVoltage}{v_q}
\newcommand{\QualifiedAdmissionRate}{r}
\newcommand{\QualityObjective}{S_{\text{quality}}}
\newcommand{\QuantileLevel}{u}
\newcommand{\QuantileProbabilityLevel}{q}
\newcommand{\QuantileThresholdCandidate}{x}
\newcommand{\QuantizationBitWidth}{b}
\newcommand{\QuantizationBlockSize}{b_{\text{block}}}
\newcommand{\QuantizationScale}{s}
\newcommand{\QuantizationStep}{\delta}
\newcommand{\QuantizationZeroPoint}{z}
\newcommand{\QuantizedGradient}{\mathbf{g}_{\text{int8}}}
\newcommand{\QuantizedIntegerCode}{x_q}
\newcommand{\QuantizedWeightEntry}{W_{ik}}
\newcommand{\QuantizerInput}{x}
\newcommand{\QuarterCycleCompressionTime}{t_{\text{peak}}}
\newcommand{\QueryAxisLabel}{i}
\newcommand{\QueryBlockCount}{T_r}
\newcommand{\QueryBlockIndex}{i}
\newcommand{\QueryBlockSize}{B_r}
\newcommand{\QueryBoundaryCount}{S_{\text{eff}}}
\newcommand{\QueryBufferPosition}{i}
\newcommand{\QueryComponent}{q_{im}}
\newcommand{\QueryPrice}{p_{\text{query}}}
\newcommand{\QueryProjectionMatrix}{\mathbf{W}_{Q}}
\newcommand{\QuerySensitivity}{\Delta}
\newcommand{\QuerySourceMatrix}{\mathbf{X}_{Q}}
\newcommand{\QueryVector}{\mathbf{q}}
\newcommand{\QueryWord}{q}
\newcommand{\QueryWordDocumentFrequency}{n}
\newcommand{\QueryWordFrequency}{f}
\newcommand{\QueryWorkspaceGeneration}{g_q}
\newcommand{\QueueArrivalTime}{t_{\text{arr}, i}}
\newcommand{\QueueServerCount}{c}
\newcommand{\QueueServiceVariationCoefficient}{c_{s}}
\newcommand{\QueueSystemCapacity}{K}
\newcommand{\QueueWaitTime}{W_{q}}
\newcommand{\QueuedJobCount}{N_{\text{queue}}}
\newcommand{\QueuedTransactionBytes}{D_{\text{vol}}}
\newcommand{\QueuedTransactionCount}{K}
\newcommand{\QueuedTransactionSet}{\mathcal{Q}}
\newcommand{\QueueingLatency}{L_{\text{lat,queue}}}
\newcommand{\QuiescentJunctionTemperature}{T_{\text{j},\text{target}}}
\newcommand{\QuiescentSocPower}{P_{\text{base}}}
\newcommand{\QuinticBlendCoefficient}{\mathbf{a}}
\newcommand{\QuotaReductionSensitivity}{\gamma_{\text{rate}}}
\newcommand{\RadarRangeResolution}{\Delta R}
\newcommand{\RadialBasisKernelCoefficient}{\gamma}
\newcommand{\RadialDistortionCoefficient}{k}
\newcommand{\RadialRange}{R}
\newcommand{\RadialRangeStandardDeviation}{\sigma_R}
\newcommand{\RadiationWavelength}{\lambda}
\newcommand{\RailVoltageTolerance}{\delta_{\text{tol}}}
\newcommand{\RandomEnvironmentState}{S}
\newcommand{\RandomRetainedElementCount}{K_{\text{rand}}}
\newcommand{\RandomSampleCollectionSize}{D_{\text{eval,total}}}
\newcommand{\RandomVectorDimension}{d}
\newcommand{\RandomizationClusterCount}{K}
\newcommand{\RandomizedMechanism}{\mathcal{M}}
\newcommand{\RandomizedSmoothingNoise}{\boldsymbol{\delta}}
\newcommand{\RangeObservation}{z}
\newcommand{\RangeObservationHistory}{z_{1:t}}
\newcommand{\RankComponentIndex}{s}
\newcommand{\RankConstrainedMatrix}{\mathbf{A}}
\newcommand{\RankContribution}{x}
\newcommand{\RankCountBinaryExponent}{m}
\newcommand{\RankFusionSmoothingConstant}{k_{\text{rrf}}}
\newcommand{\RankIndex}{i}
\newcommand{\RankReductionResult}{y}
\newcommand{\RankingFunction}{V}
\newcommand{\RatedActuatorTorque}{\tau_{\text{rated}}}
\newcommand{\RatedCurrentEquilibriumTemperature}{T_{\text{eq}}}
\newcommand{\RatedFatigueLife}{L_{10}}
\newcommand{\RatedJointTorque}{\boldsymbol{\tau}_{\text{rated}}}
\newcommand{\RatingCategory}{y}
\newcommand{\RatioClippingWidth}{\epsilon_{\text{clip}}}
\newcommand{\RationaleTokens}{z}
\newcommand{\RawClearanceBarrierFunction}{h_{\text{raw}}}
\newcommand{\RawDataUploadEnergy}{E_{\text{raw}}}
\newcommand{\RawHardwareFaultRate}{\lambda_{\text{raw}}}
\newcommand{\RawPipelineInput}{x}
\newcommand{\RawRecordCount}{N}
\newcommand{\RawSensoryData}{\mathbf{S}}
\newcommand{\RayReturnRange}{r_{\text{hit}}}
\newcommand{\RayStepCount}{N_{\text{steps}}}
\newcommand{\RayTraversalLength}{d_{\text{ray}}}
\newcommand{\RayVoxelRange}{r_{\text{voxel}}}
\newcommand{\RayleighDissipationFunction}{\mathcal{D}}
\newcommand{\ReachabilityCostate}{\mathbf{p}}
\newcommand{\ReachabilityHamiltonian}{\mathcal{H}}
\newcommand{\ReachabilityHorizonInstant}{t'}
\newcommand{\ReachabilityLevelFunction}{V}
\newcommand{\ReachabilityTerminalTime}{T}
\newcommand{\ReachableArtifactNode}{u}
\newcommand{\ReachableDistance}{d_{\text{reach}}}
\newcommand{\ReachableWorkspace}{\mathcal{W}}
\newcommand{\ReadEndSequenceCount}{c_{\text{end}}}
\newcommand{\ReadStartSequenceCount}{c_{\text{start}}}
\newcommand{\ReadTimeCeiling}{R}
\newcommand{\RealDataset}{\mathcal{S}_{\text{real}}}
\newcommand{\RealTimeTaskIndex}{i}
\newcommand{\RealityGapVector}{\boldsymbol{\Delta}_{\text{sim2real}}}
\newcommand{\RealizedActuatorEffort}{u_{\text{act}}}
\newcommand{\RealizedArrivalCount}{n}
\newcommand{\RealizedDamageOutcome}{y}
\newcommand{\RealizedDampingPower}{P_d}
\newcommand{\RealizedDeviceComputeRate}{R}
\newcommand{\RealizedFalseAlarmProbability}{\alpha_{*}}
\newcommand{\RealizedMissedDegradationProbability}{\beta_{*}}
\newcommand{\RealizedServiceTime}{s}
\newcommand{\ReceiptSampleIndex}{t_{\text{recv}}}
\newcommand{\ReceiveBandwidth}{\text{BW}_{\text{rx}}}
\newcommand{\ReceiverOverhead}{o_{\text{recv}}}
\newcommand{\ReceiverTimingJitter}{\sigma_{\Delta t}}
\newcommand{\RecentUsageShare}{F_{\text{actual}}}
\newcommand{\RecommenderItemCount}{N_{\text{items}}}
\newcommand{\RecommenderUserCount}{N_{\text{users}}}
\newcommand{\ReconcilableToolInterface}{\mathbb{T}_{a}}
\newcommand{\ReconstructedGradient}{\hat{\mathbf{g}}}
\newcommand{\ReconstructedWeight}{\hat{w}}
\newcommand{\RecordAdequacyPassProbability}{p_{\text{record}}}
\newcommand{\RecordSizeCeiling}{s_{\max}}
\newcommand{\RecordedAuthorityState}{S_{\text{auth}}}
\newcommand{\RecoveryCompletionInstant}{t_{\text{rec}}}
\newcommand{\RecoveryPoseTolerance}{\epsilon_{\text{sync}}}
\newcommand{\RecoveryTargetLogPosition}{j_{\text{target}}}
\newcommand{\RecoveryWarmupTime}{T_{\text{warmup}}}
\newcommand{\RecurrentHiddenBias}{\mathbf{b}_{\text{h}}}
\newcommand{\RecurrentHiddenState}{\mathbf{h}}
\newcommand{\RecurrentInputWeights}{\mathbf{W}_{\text{hx}}}
\newcommand{\RecurrentOutputWeights}{\mathbf{W}_{\text{yh}}}
\newcommand{\RecurrentStateWeights}{\mathbf{W}_{\text{hh}}}
\newcommand{\ReduceScatterCompletionTime}{T_{\text{reducescatter}}}
\newcommand{\ReducedBoundaryConditionVector}{\mathbf{b}_{\text{red}}}
\newcommand{\ReducedImpactMass}{m_{\text{red}}}
\newcommand{\ReducibleLoss}{\hat{\mathcal{L}}}
\newcommand{\ReductionInputCount}{n}
\newcommand{\RedundantComponentCount}{N_{\text{red}}}
\newcommand{\RedundantReplicaCount}{k}
\newcommand{\RedundantServiceAvailability}{A_{\text{system}}}
\newcommand{\ReferenceActionDisadvantage}{A_t^{\pi^*}}
\newcommand{\ReferenceAssessedFailure}{F}
\newcommand{\ReferenceBinIndex}{b}
\newcommand{\ReferenceBinProportion}{E}
\newcommand{\ReferenceCostToGo}{Q_t^{\pi^*}}
\newcommand{\ReferenceDisagreementProbability}{\mathcal{L}}
\newcommand{\ReferenceDistribution}{p}
\newcommand{\ReferenceJointAccelerations}{\ddot{\mathbf{q}}^{\text{ref}}}
\newcommand{\ReferenceJointPosition}{q_{\text{reference}}}
\newcommand{\ReferenceJointPositions}{\mathbf{q}^{\text{ref}}}
\newcommand{\ReferenceJointVelocities}{\dot{\mathbf{q}}^{\text{ref}}}
\newcommand{\ReferenceLogProbabilitySum}{\Delta_{\text{ref}}}
\newcommand{\ReferenceMixingProbability}{\lambda}
\newcommand{\ReferenceNextTokenDistribution}{q}
\newcommand{\ReferencePosition}{\mathbf{r}}
\newcommand{\ReferenceProbabilityRatio}{z}
\newcommand{\ReferenceRelativeScore}{\Delta_\theta}
\newcommand{\ReferenceRequestLength}{S_{\text{ref}}}
\newcommand{\ReferenceSampleEmpiricalCdf}{F}
\newcommand{\ReferenceStateDisagreementRate}{\epsilon_E}
\newcommand{\ReferenceStateDistribution}{d_{\pi^*}}
\newcommand{\ReferenceStepDisagreementRate}{\epsilon}
\newcommand{\ReferenceWindingResistance}{R_0}
\newcommand{\ReflectedContactForce}{F_{\text{contact}}}
\newcommand{\ReflectedRotorInertia}{J_{\text{ref}}}
\newcommand{\ReflectedRotorInertiaMatrix}{\mathbf{J}_m}
\newcommand{\ReflectedTransmissionInputInertia}{J_{\text{ref,in}}}
\newcommand{\ReflectionAngle}{\theta_{\text{refl}}}
\newcommand{\ReflexCollisionBudget}{T_{\text{reflex\_budget}}}
\newcommand{\RegeneratedBrakingEnergy}{E_{\text{regen}}}
\newcommand{\RegenerativeBrakingTorque}{\tau_{\text{brake}}}
\newcommand{\RegenerativeRecoveryEfficiency}{\eta_{\text{regen}}}
\newcommand{\RegisterSetupTime}{t_{\text{setup}}}
\newcommand{\RegisteredDescriptorCount}{n_{\text{reg}}}
\newcommand{\RegularizedEulerIntegral}{I}
\newcommand{\RejectionDecodeStep}{t_{\text{cut}}}
\newcommand{\RelationalSelection}{\sigma}
\newcommand{\RelativeContrastTolerance}{\epsilon_{\text{contrast}}}
\newcommand{\RelativeDeviationBound}{\delta}
\newcommand{\RelativeImprovementFraction}{\delta}
\newcommand{\RelativeStandardError}{r}
\newcommand{\RelevantRecordSet}{\mathcal{D}^*}
\newcommand{\ReliabilityTargetIndex}{i}
\newcommand{\ReliableDetectionFrameCount}{N_{\text{frames}}}
\newcommand{\RemainingCallCount}{N_{\text{rem}}}
\newcommand{\RemainingDistanceEstimate}{\hat{s}}
\newcommand{\RemainingExecutionLease}{T_{\text{lease,rem}}}
\newcommand{\RemainingHarmDistance}{d_{\text{rem}}}
\newcommand{\RemainingIntentTime}{T_{\text{rem}}}
\newcommand{\RemainingReturn}{R_{\geq k}}
\newcommand{\RemainingUprightDistance}{s}
\newcommand{\RemoteHardwareEfficiency}{\eta_{\text{hw,remote}}}
\newcommand{\RemotePathTime}{T_{\text{remote}}}
\newcommand{\RemotePeakRate}{R_{\text{peak,remote}}}
\newcommand{\RenderedPixelColor}{C}
\newcommand{\RenewalJitterAllowance}{T_{\text{jitter}}}
\newcommand{\RenyiDivergence}{\mathcal{D}_{\alpha_{\text{R}}}}
\newcommand{\RenyiOrder}{\alpha_{\text{R}}}
\newcommand{\RenyiPrivacyBudget}{\epsilon_{\text{R}}}
\newcommand{\RepairAttemptCost}{C_{\text{repair}}}
\newcommand{\RepairCap}{K_{\text{repair}}}
\newcommand{\RepairCapabilityGrant}{\Gamma_{\text{repair}}}
\newcommand{\RepairFirstCost}{C_{\text{repair\ first}}}
\newcommand{\RepairPatchArtifact}{P}
\newcommand{\RepairSuccessProbability}{p}
\newcommand{\RepairTurnLatency}{T_{\text{repair}}}
\newcommand{\ReparameterizationNoise}{\boldsymbol{\epsilon}}
\newcommand{\RepeatedRunCount}{k}
\newcommand{\RepeatedRunMean}{\mu_{\text{run}}}
\newcommand{\RepeatedRunStandardDeviation}{\sigma_{\text{run}}}
\newcommand{\ReplacementLatency}{L}
\newcommand{\ReplacementTimingReserve}{T_{\text{reserve}}}
\newcommand{\ReplanRequestOffset}{T_{\text{request}}}
\newcommand{\ReplayBuffer}{\mathcal{M}}
\newcommand{\ReplayBufferTransitionCount}{n_{\text{replay}}}
\newcommand{\ReplayedErrorCovariance}{\mathbf{P}_{t_{\text{recv}}}}
\newcommand{\ReplayedStateEstimate}{\hat{\mathbf{x}}_{t_{\text{recv}}}}
\newcommand{\ReplicaAvailability}{A_{\text{single}}}
\newcommand{\ReplicaColdStartTime}{T_{\text{cold-start}}}
\newcommand{\ReplicaCount}{R}
\newcommand{\ReplicaModelLoadTime}{T_{\text{load}}}
\newcommand{\ReplicaProvisioningTime}{T_{\text{provision}}}
\newcommand{\ReplicaWarmupTime}{T_{\text{warmup}}}
\newcommand{\ReplyLossProbability}{q_{\text{rep}}}
\newcommand{\RepositoryEdgeSourceIndex}{i}
\newcommand{\RepositoryEdgeTargetIndex}{j}
\newcommand{\RepositoryEdgeWeight}{A}
\newcommand{\RepositoryEdgeWeightMatrix}{\mathbf{A}}
\newcommand{\RepositoryFileCount}{n}
\newcommand{\RepositoryGraphEdgeSet}{E}
\newcommand{\RepositoryGraphVertexSet}{V}
\newcommand{\RepositoryTransitionMatrix}{\mathbf{P}_{\text{graph}}}
\newcommand{\ReprojectionResidual}{\epsilon_{\text{reproj}}}
\newcommand{\RepublicationIndex}{k}
\newcommand{\RepublicationPeriod}{T_{\text{rep}}}
\newcommand{\RequantizationScale}{s_{\text{eff}}}
\newcommand{\RequestCompressionRatio}{\gamma_{\text{req}}}
\newcommand{\RequestConcurrency}{Q_{\text{req}}}
\newcommand{\RequestLossProbability}{q_{\text{req}}}
\newcommand{\RequestOutputLength}{S}
\newcommand{\RequestPromptTokens}{\mathbf{x}}
\newcommand{\RequestQueueTime}{T_{\text{queue}}}
\newcommand{\RequestResidenceTime}{W}
\newcommand{\RequestResponseTime}{t}
\newcommand{\RequestSeenBatchSize}{B_{\text{req}}}
\newcommand{\RequestServiceTime}{T_{\text{svc}}}
\newcommand{\RequestTimeInSystem}{T_{\text{lat}}}
\newcommand{\RequestedActionTap}{a_{\text{req}}}
\newcommand{\RequiredClearance}{C_{\text{safe}}}
\newcommand{\RequiredComponentCount}{N}
\newcommand{\RequiredDetectionRange}{d_{\text{detect}}}
\newcommand{\RequiredInputBandwidth}{\text{BW}_{\text{required}}}
\newcommand{\RequiredMemoryBandwidth}{\text{BW}_{\text{req}}}
\newcommand{\RequiredPremiseClaim}{P}
\newcommand{\RequiredPremiseConfidence}{p}
\newcommand{\RequiredPremiseCount}{n}
\newcommand{\RequiredResultCount}{k}
\newcommand{\RequiredScenarioCellCount}{N_{\text{req}}}
\newcommand{\RequiredScenarioSet}{\mathcal{S}_{\text{req}}}
\newcommand{\RequiredServiceRate}{\mu_{\text{required}}}
\newcommand{\RequiredTaskPairCount}{N'}
\newcommand{\RequiredUsersPerVariant}{n}
\newcommand{\ResampledReplacementToken}{T_4'}
\newcommand{\ReservedDeviceMemory}{M_{\text{reserve}}}
\newcommand{\ResetCalibrationTime}{t_{\text{calibration}}}
\newcommand{\ResetDuration}{t_{\text{rst}}}
\newcommand{\ResetLatency}{T_{\text{reset}}}
\newcommand{\ResidentStopDistance}{d_{\text{suffix}}}
\newcommand{\ResidentWeightMemory}{M_{\text{weights,resident}}}
\newcommand{\ResidualAdapterFunction}{A}
\newcommand{\ResidualBlockOutput}{\mathbf{y}}
\newcommand{\ResidualCorrectionCeiling}{\Delta_{\max}}
\newcommand{\ResidualDynamicsPerturbation}{\Delta \mathbf{f}}
\newcommand{\ResidualFrequencyError}{\Delta f_{\text{res}}}
\newcommand{\ResidualFunction}{\mathcal{F}}
\newcommand{\ResidualGate}{g}
\newcommand{\ResidualPolicyTorque}{\boldsymbol{\tau}_{\text{res},\theta}}
\newcommand{\ResidualSamplingDistribution}{p_{\text{res}}}
\newcommand{\ResolutionScalingRatio}{\gamma}
\newcommand{\ResourceChangeRate}{r_{\text{chg}}}
\newcommand{\ResourceCostBudget}{C_{\text{max}}}
\newcommand{\ResourceTypeIndex}{r}
\newcommand{\ResourceUtilization}{U}
\newcommand{\ResponseActionTokens}{a}
\newcommand{\ResponseMetadata}{\mathbf{m}}
\newcommand{\ResponsePayload}{\mathbf{y}}
\newcommand{\ResponseReward}{r}
\newcommand{\ResponseThreshold}{\tau}
\newcommand{\ResponseTimeDistributionFunction}{F}
\newcommand{\ResponseTimeIterationIndex}{\ell}
\newcommand{\ResponseTimeStandardDeviation}{\sigma_t}
\newcommand{\RestConfiguration}{\mathbf{q}_{\text{rest}}}
\newcommand{\RestitutionCoefficient}{e}
\newcommand{\RestoreWorkerCount}{w}
\newcommand{\RestrictedAccelerationBound}{a_{\text{restricted}}}
\newcommand{\RestrictedSpeedBound}{v_{\text{restricted}}}
\newcommand{\ResultActionTime}{T_{\text{action}}}
\newcommand{\ResumeTime}{T_{\text{resume}}}
\newcommand{\RetainedDigestCount}{m}
\newcommand{\RetainedGradientElementCount}{K_{\text{top}}}
\newcommand{\RetainedProductiveTime}{T_{\text{productive}}}
\newcommand{\RetainedSpectralEnergyFraction}{\eta_r}
\newcommand{\RetainingCallCount}{H_{\text{rem}}}
\newcommand{\RetiringChunkJointVelocity}{\dot{q}_A}
\newcommand{\RetiringChunkReferenceState}{\mathbf{x}_A}
\newcommand{\RetrainingComputeCost}{C_{\text{compute}}}
\newcommand{\RetrainingDeploymentCost}{C_{\text{deployment}}}
\newcommand{\RetrainingInterval}{T}
\newcommand{\RetrainingRiskCost}{C_{\text{risk}}}
\newcommand{\RetrainingRunCost}{C}
\newcommand{\RetrainingValidationCost}{C_{\text{validation}}}
\newcommand{\RetrievalCollectionSize}{N}
\newcommand{\RetrievalCutoffCount}{k}
\newcommand{\RetrievalMethodIndex}{i}
\newcommand{\RetrievedRecordSet}{\mathcal{R}}
\newcommand{\RetryAttemptIndex}{j}
\newcommand{\RetryBackoffInterval}{b}
\newcommand{\RetryJitterDelay}{d}
\newcommand{\ReturnLevel}{z}
\newcommand{\ReturnPeriodTrialCount}{T}
\newcommand{\ReturnStepOffset}{k}
\newcommand{\ReturnedClassLabel}{c}
\newcommand{\ReusedPrefixLength}{S_{\text{match}}}
\newcommand{\ReverseModeWorkConstant}{C}
\newcommand{\ReverseTransitionCovariance}{\boldsymbol{\Sigma}}
\newcommand{\ReverseTransitionMean}{\boldsymbol{\mu}_\theta}
\newcommand{\RevertFidelity}{\rho_{\text{revert}}}
\newcommand{\ReviewerFalseApprovalIndicator}{X}
\newcommand{\ReviewerIndex}{j}
\newcommand{\RevisionPassProbability}{p_{\text{rev}}}
\newcommand{\Reward}{r}
\newcommand{\RewardFunction}{r}
\newcommand{\RewardModel}{r}
\newcommand{\RightEvasionAction}{\mathbf{a}_{\text{right}}}
\newcommand{\RightSingularVectorMatrix}{\mathbf{Q}}
\newcommand{\RigidGangJob}{J}
\newcommand{\RigidImpactInstant}{t_{\text{impact}}}
\newcommand{\RigidTransformTranslation}{\mathbf{t}}
\newcommand{\RingAllReduceBandwidthTime}{T_{\text{bandwidth}}}
\newcommand{\RingAllReduceCompletionTime}{T_{\text{ring}}}
\newcommand{\RingAllReduceStartupTime}{T_{\text{latency}}}
\newcommand{\RingBufferHorizon}{T_{\text{buffer}}}
\newcommand{\RingBufferSlotCount}{N_{\text{buffer}}}
\newcommand{\RingStepIndex}{s}
\newcommand{\RingTreeCrossoverPayload}{M_{\text{crossover}}}
\newcommand{\RmsMotorTorque}{\tau_{\text{rms}}}
\newcommand{\RmspropSquaredGradientAverage}{s}
\newcommand{\RobotAction}{\mathbf{a}}
\newcommand{\RobotApproachSpeed}{v_r}
\newcommand{\RobotApproachVelocity}{v_{\text{robot}}}
\newcommand{\RobotObservation}{\mathbf{o}}
\newcommand{\RobotPosition}{x_{\text{robot}}}
\newcommand{\RobotPositionUncertainty}{Z_r}
\newcommand{\RobotReactionTime}{T_r}
\newcommand{\RobotReactionTravel}{S_r}
\newcommand{\RobotStoppingTravel}{S_s}
\newcommand{\RobotStructuralStiffness}{k_{\text{robot}}}
\newcommand{\RobotTransitVolume}{\mathcal{T}_{\text{robot}}}
\newcommand{\RollingShutterDistortion}{\Delta \mathbf{x}}
\newcommand{\RollingShutterFrameSkew}{\Delta t_{\text{skew}}}
\newcommand{\RollingShutterRowReadout}{t_{\text{row}}}
\newcommand{\RolloutAction}{a}
\newcommand{\RolloutActionSequence}{\mathbf{a}_{0:T}}
\newcommand{\RolloutAdmissionAge}{\Delta T_{\text{rollout}}}
\newcommand{\RolloutAssessmentTime}{T_{v}}
\newcommand{\RolloutDuration}{T_{\text{rollout}}}
\newcommand{\RolloutEnvironmentState}{s}
\newcommand{\RolloutHorizon}{T}
\newcommand{\RolloutLoss}{\mathcal{L}}
\newcommand{\RolloutPolicyParameters}{\theta_{\text{old}}}
\newcommand{\RolloutPolicyTokenCount}{N}
\newcommand{\RolloutStateSequence}{s_{0:T}}
\newcommand{\RolloutStepCount}{N}
\newcommand{\RolloutStepIndex}{k}
\newcommand{\RolloutSurrogateObjective}{\mathcal{L}}
\newcommand{\RolloutTurnIndex}{k}
\newcommand{\RooflineRidgePoint}{I_{\text{ridge}}}
\newcommand{\RotaryRotationMatrix}{\mathbf{R}}
\newcommand{\RotatingBodyAngularSpeed}{\omega}
\newcommand{\RotatingBodyInertia}{J}
\newcommand{\RotationOriginAcceleration}{\mathbf{a}_O}
\newcommand{\RotationOriginVelocity}{\mathbf{v}_O}
\newcommand{\RotationalKineticEnergy}{E_{k,\text{rot}}}
\newcommand{\RotationalSpringStiffness}{K}
\newcommand{\RotorAngularSpeed}{\omega_m}
\newcommand{\RotorInertia}{J_{\text{rotor}}}
\newcommand{\RotorPolePairCount}{N_{\text{poles}}}
\newcommand{\RoundCommunicationVolume}{M_r}
\newcommand{\RoundDownloadVolume}{M_{\text{download},r}}
\newcommand{\RoundDuration}{t_r}
\newcommand{\RoundEmittedTokenCount}{N_{\text{emit}}}
\newcommand{\RoundProtocolVolume}{M_{\text{protocol},r}}
\newcommand{\RoundRetryVolume}{M_{\text{retry},r}}
\newcommand{\RoundSampleCount}{n_{\text{round}}}
\newcommand{\RoundUploadVolume}{M_{\text{upload},r}}
\newcommand{\RoundedClassProbability}{p^{\text{rnd}}}
\newcommand{\RoundingDecimalCount}{d_{\text{dec}}}
\newcommand{\RoutedExpertCount}{k_{\text{experts}}}
\newcommand{\RouterGateProbability}{p_{\text{gate}}}
\newcommand{\RowActivationDelay}{t_{\text{RCD}}}
\newcommand{\RowActiveTime}{t_{\text{RAS}}}
\newcommand{\RowAttitudeIncrement}{\Delta \boldsymbol{\theta}_{\text{att}}}
\newcommand{\RowConflictCount}{N_{\text{conflict}}}
\newcommand{\RowCycleTime}{t_{\text{RC}}}
\newcommand{\RowExposureStartTime}{t_{\text{scan}}}
\newcommand{\RowModeComponentVector}{\mathbf{a}_s}
\newcommand{\RowModeFactorMatrix}{\mathbf{A}}
\newcommand{\RowModeFactorSlice}{\mathbf{a}}
\newcommand{\RowParallelOutputMatrix}{\mathbf{Z}}
\newcommand{\RowParallelWeightMatrix}{\mathbf{B}}
\newcommand{\RowPrechargeTime}{t_{\text{RP}}}
\newcommand{\RunIndexSubset}{J}
\newcommand{\RuntimeGoodput}{\eta_{\text{runtime}}}
\newcommand{\RuntimeReserveMemory}{M_{\text{runtime}}}
\newcommand{\SCurveAccelerationPhaseTime}{T_{\text{acc}}}
\newcommand{\SafeApproachSpeedEnvelope}{v_{\text{safe}}}
\newcommand{\SafeControlSet}{\mathcal{U}_{\text{safe}}}
\newcommand{\SafeOverrideCommand}{\mathbf{u}_{\text{safe}}}
\newcommand{\SafeSeparationDistance}{d_{\text{safe}}}
\newcommand{\SafeSetProjection}{\mathcal{P}_{\mathcal{C}}}
\newcommand{\SafeStateConstraintSet}{\mathcal{X}_{\text{safe}}}
\newcommand{\SafeStateSet}{\mathcal{X}_{\text{safe}}}
\newcommand{\SafeWorldState}{s_A}
\newcommand{\SafeguardSeparationDistance}{S}
\newcommand{\SafeguardStoppingTime}{T}
\newcommand{\SafetyBoundaryManifold}{\partial \mathcal{C}}
\newcommand{\SagaCompensatingStep}{C}
\newcommand{\SagaFailedForwardStep}{F_k^{\text{fail}}}
\newcommand{\SagaForwardStep}{F}
\newcommand{\SagaStepIndex}{k}
\newcommand{\SampleAcquisitionPrice}{c_{\text{sample}}}
\newcommand{\SampleGradientStandardDeviation}{\sigma}
\newcommand{\SampleLabelingPrice}{c_{\text{label}}}
\newcommand{\SampleStatistic}{\widehat{\theta}}
\newcommand{\SampleStorageSize}{s_{\text{sample}}}
\newcommand{\SampledPolicyToken}{w}
\newcommand{\SampledSimulationParameterVector}{\tilde{\boldsymbol{\xi}}}
\newcommand{\SampledUnit}{y}
\newcommand{\SampledUnitCount}{m}
\newcommand{\SamplingParameters}{\boldsymbol{\Theta}_{\text{sample}}}
\newcommand{\SamplingPeriod}{T_s}
\newcommand{\SamplingRate}{f_s}
\newcommand{\SamplingTemperature}{\tau_{\text{temp}}}
\newcommand{\SandboxColdBootTime}{T_{\text{cold}}}
\newcommand{\SaturatedJointTorque}{\boldsymbol{\tau}_{\text{act}}}
\newcommand{\SavedEngineeringTime}{T_{\text{saved}}}
\newcommand{\ScalarFieldSize}{k}
\newcommand{\ScalarGraphFunction}{f}
\newcommand{\ScalarKalmanGain}{g}
\newcommand{\ScalarTrackingError}{e}
\newcommand{\ScalarTrackingErrorAcceleration}{\ddot{e}}
\newcommand{\ScalarTrackingErrorRate}{\dot{e}}
\newcommand{\ScaleCoefficient}{A_{\mathcal{L}}}
\newcommand{\ScaledBatchSize}{B_{\text{new}}}
\newcommand{\ScaledJointStiffnessMatrix}{\tilde{\mathbf{K}}}
\newcommand{\ScaledLearningRate}{\eta_{\text{new}}}
\newcommand{\ScaledResource}{X}
\newcommand{\ScaledSerialFraction}{s}
\newcommand{\ScalingCurveWorkerCount}{k}
\newcommand{\ScalingEfficiency}{\eta_{\text{scaling}}}
\newcommand{\ScalingExponent}{\alpha_{\text{scale}}}
\newcommand{\ScalingLawLoss}{\mathcal{L}}
\newcommand{\ScanCapabilityGrant}{\Gamma_{\text{scan}}}
\newcommand{\ScatteringCrossSection}{\sigma_s}
\newcommand{\ScenarioCellRecordCount}{N_{\text{cell}}}
\newcommand{\SceneRadiance}{I}
\newcommand{\ScheduleFinishTime}{T_{\text{finish}}}
\newcommand{\ScheduledSessionDuration}{T_{\text{sched}}}
\newcommand{\SchedulingClassWeight}{w}
\newcommand{\SchedulingGoodput}{\eta_{\text{scheduling}}}
\newcommand{\SchedulingIntervalLength}{t}
\newcommand{\ScoreNoiseStandardDeviation}{\sigma}
\newcommand{\ScoreNoiseVector}{\mathbf{z}}
\newcommand{\ScoreRefreshInterval}{k_{\text{refresh}}}
\newcommand{\ScoredPrefixLength}{S_{\text{step}}}
\newcommand{\ScoredStepCount}{J}
\newcommand{\ScoredStepIndex}{j}
\newcommand{\ScoredToolCall}{a}
\newcommand{\ScoredToolCallCount}{N}
\newcommand{\ScoringErrorStandardDeviation}{\sigma}
\newcommand{\ScreenSpaceCovariance}{\boldsymbol{\Sigma}_{2D}}
\newcommand{\ScreenedFeature}{x}
\newcommand{\ScreenedFeatureSet}{X}
\newcommand{\ScreeningMissRate}{m}
\newcommand{\SeamActualAccelerations}{\ddot{\mathbf{q}}_{\text{actual}}}
\newcommand{\SeamActualConfiguration}{\mathbf{q}_{\text{actual}}}
\newcommand{\SeamActualVelocities}{\dot{\mathbf{q}}_{\text{actual}}}
\newcommand{\SeamBlendReference}{\mathbf{s}}
\newcommand{\SeamBridgeDuration}{T_{\text{blend}}}
\newcommand{\SeamBridgePosition}{q_{\text{blend}}}
\newcommand{\SeamInstant}{t_{\text{seam}}}
\newcommand{\SeamStepTorque}{\tau_{\text{request}}}
\newcommand{\SearchBranchingFactor}{b}
\newcommand{\SearchDepth}{d_{\max}}
\newcommand{\SearchDepthIndex}{d}
\newcommand{\SearchQueryEmbedding}{\mathbf{q}}
\newcommand{\SecondAdjacentCheckIndex}{b}
\newcommand{\SecondAdjacentCheckPassProbability}{p_{b}}
\newcommand{\SecondAdjacentCheckSlotTime}{T_{b}}
\newcommand{\SecondCatalogDefinitionCount}{n_{\text{def},B}}
\newcommand{\SecondCatalogDefinitionSize}{S_{B}}
\newcommand{\SecondClassCoverageFloor}{b}
\newcommand{\SecondClientMaskedUpdate}{\mathbf{y}_B}
\newcommand{\SecondClientModelParameters}{\theta_B}
\newcommand{\SecondComparedGroupLabel}{b}
\newcommand{\SecondComparedItem}{j}
\newcommand{\SecondFloatingPointAddend}{b}
\newcommand{\SecondGroupClassificationThreshold}{\tau_{\text{thr},b}}
\newcommand{\SecondGroupQualifiedFraction}{q_b}
\newcommand{\SecondGroupSampleApprovalRate}{\hat{p}_b}
\newcommand{\SecondGroupSampleSize}{n_b}
\newcommand{\SecondJaccardSet}{\mathcal{B}}
\newcommand{\SecondRankComputeTime}{T_{\text{rank}_1}}
\newcommand{\SecondRaterCategoryFraction}{p_{y,2}}
\newcommand{\SecondRingTraceElement}{b}
\newcommand{\SecondSummandStandardDeviation}{\sigma_b}
\newcommand{\SecondTwinCriticReturnEstimate}{Q_{\phi_2}}
\newcommand{\SecurityLabelLattice}{\mathbb{L}}
\newcommand{\SecurityLabelSet}{\mathcal{S}_{\text{lab}}}
\newcommand{\SelectedActuationCommand}{\mathbf{u}_{\text{act}}}
\newcommand{\SelectedDescriptorCount}{n_{\text{sel}}}
\newcommand{\SelectedLayerSet}{\mathcal{S}}
\newcommand{\SelectionOverheadSize}{S_{\text{sel}}}
\newcommand{\SelectionScoreFunction}{f}
\newcommand{\SelectionTime}{T_{\text{selection}}}
\newcommand{\SelectiveAcceptanceScore}{\kappa}
\newcommand{\SelfConsistencySampleCount}{k}
\newcommand{\SelfWatchdogTimeout}{T_{\text{self}}}
\newcommand{\SenderOverhead}{o_{\text{send}}}
\newcommand{\SensingRealityGap}{\Delta_{\text{sens}}}
\newcommand{\SensingStageLatency}{T_{\text{sense}}}
\newcommand{\SensorErrorBound}{\epsilon}
\newcommand{\SensorFeatureTokens}{\mathbf{z}_{\text{sensor}}}
\newcommand{\SensorLeverArm}{\mathbf{r}_{P/O}}
\newcommand{\SensorLeverArmLength}{r}
\newcommand{\SensorLinkTransportTime}{t_{\text{transport}}}
\newcommand{\SensorNoiseBound}{\epsilon}
\newcommand{\SensorNoiseDensity}{N_{\text{IMU}}}
\newcommand{\SensorNoiseStandardDeviation}{\sigma}
\newcommand{\SensorObservationFunction}{g}
\newcommand{\SensorPatternDictionary}{\boldsymbol{\Phi}_{\text{dict}}}
\newcommand{\SensorPitchAngle}{\theta_{\text{pitch}}}
\newcommand{\SensorPointAcceleration}{\mathbf{a}_P}
\newcommand{\SensorPointVelocity}{\mathbf{v}_P}
\newcommand{\SensorReadoutTime}{t_{\text{readout}}}
\newcommand{\SensorReferenceFrame}{\mathcal{F}_{\text{sensor}}}
\newcommand{\SensorRowIndex}{y}
\newcommand{\SensorTraceMatrix}{\mathbf{X}}
\newcommand{\SequenceCounterReading}{S}
\newcommand{\SequenceIterationOperations}{c_{\text{decode}}}
\newcommand{\SequenceLength}{S}
\newcommand{\SequenceToken}{x}
\newcommand{\SequentialAttemptIndex}{j}
\newcommand{\SequentialBackwardCommunicationTime}{T_{\text{sequential}}}
\newcommand{\SequentialCandidateCount}{M}
\newcommand{\SequentialCostPerAcceptedTask}{C_{\text{eff,seq}}}
\newcommand{\SequentialExecutionTime}{T_{\text{sequential}}}
\newcommand{\SequentialLogLikelihoodRatio}{\Lambda_m}
\newcommand{\SequentialTestObservation}{X}
\newcommand{\SequentialTrialCount}{m}
\newcommand{\SerialAutocorrelation}{\rho}
\newcommand{\SerialCallCount}{n}
\newcommand{\SerialFraction}{r}
\newcommand{\SerialLinkClockFrequency}{f_{\text{link}}}
\newcommand{\SerialReferenceTime}{T_{\text{serial}}}
\newcommand{\SerializationLatency}{L_{\text{lat,serialization}}}
\newcommand{\SerializedChunkVolume}{D_{\text{vol,chunk}}}
\newcommand{\SerializedTrainingExample}{X}
\newcommand{\SeriesComponentCount}{N_{\text{series}}}
\newcommand{\SeriesElasticStiffness}{k}
\newcommand{\SeriesPsuCount}{n_{\text{psu}}}
\newcommand{\ServerAggregationEnergy}{E_{\text{aggregation}}}
\newcommand{\ServerIndex}{i}
\newcommand{\ServerPower}{P_{\text{server}}}
\newcommand{\ServerRoutingWeight}{w}
\newcommand{\ServiceRate}{\mu}
\newcommand{\ServiceTimeStandardDeviation}{\sigma}
\newcommand{\ServiceTimeVariationCoefficient}{c_{s}}
\newcommand{\ServingCostPerQuery}{C_{\text{serving}}}
\newcommand{\ServingEmpiricalCdf}{F_{P_t}}
\newcommand{\ServingPathPredictor}{f_{\text{serve}}}
\newcommand{\ServingTransformFunction}{f_{\text{serve}}}
\newcommand{\ServingUtilization}{\rho_{\text{serv}}}
\newcommand{\ServoFrequencyCorrection}{\Delta f}
\newcommand{\SessionAttemptCount}{N_{\text{att}}}
\newcommand{\SessionRequestCount}{N_{\text{session}}}
\newcommand{\SetMemberPoint}{\mathbf{z}}
\newcommand{\SetpointSampleIndex}{k}
\newcommand{\SetpointStepInterval}{\Delta t_{\text{step}}}
\newcommand{\SettledOperationCharge}{c}
\newcommand{\SettledTrajectoryCost}{C}
\newcommand{\SetupShareCap}{\phi}
\newcommand{\ShadowOnlyFailureCount}{n_{\text{shadow}}}
\newcommand{\ShannonEntropy}{H}
\newcommand{\ShapedObservationSize}{S_{\text{shaped}}}
\newcommand{\ShapedTotalReward}{r_{\text{total}}}
\newcommand{\ShapingPotential}{\Phi}
\newcommand{\ShardIndex}{s}
\newcommand{\ShardReaderCount}{n_{\text{workers}}}
\newcommand{\SharedBusBandwidth}{\text{BW}_{\text{bus}}}
\newcommand{\SharedHardwareInterferenceDelay}{T_{\text{interf,shared}}}
\newcommand{\SharedPoolWorkerCount}{N_{\text{pool}}}
\newcommand{\SharedPrefixFraction}{f}
\newcommand{\SharedPrefixLength}{S_{\text{prefix}}}
\newcommand{\SharedPrefixRequestCount}{n_{\text{req}}}
\newcommand{\ShellRelativeThickness}{\epsilon}
\newcommand{\ShieldInterceptionCoverage}{c_h}
\newcommand{\ShiftedMpcControlSequence}{\tilde{\mathbf{u}}_{0:N_{\text{mpc}}-1}}
\newcommand{\ShiftedTestDistribution}{\mathcal{D}'}
\newcommand{\ShingleLength}{w}
\newcommand{\ShipDecision}{\mathbf{1}_{\text{ship}}}
\newcommand{\ShootThroughCurrent}{I_{\text{shoot-through}}}
\newcommand{\SiblingPolicyAction}{a'}
\newcommand{\SiblingTeamAllocation}{U_{\text{allocated}}}
\newcommand{\SightlineRange}{d}
\newcommand{\SigmoidFunction}{\sigma}
\newcommand{\SignalDimension}{n}
\newcommand{\SignalHandoff}{\mathcal{H}}
\newcommand{\SignalPropagationDelay}{t_{\text{prop}}}
\newcommand{\SignalTrajectory}{s}
\newcommand{\SignatureBandCount}{b}
\newcommand{\SignificanceCriticalQuantile}{z_{1-\alpha_{\text{sig}}/2}}
\newcommand{\SignificanceLevel}{\alpha}
\newcommand{\SiliconThermalTimeConstant}{\tau_{\text{th,silicon}}}
\newcommand{\SimplexProjection}{\Pi_{\Delta^{K-1}}}
\newcommand{\SimulatedPlantDynamics}{f_{\text{sim}}}
\newcommand{\SimulatedReturnLevel}{z_{T, \text{sim}}}
\newcommand{\SimulatedStateTrajectory}{s_{\text{sim}}}
\newcommand{\SimulatedStlRobustness}{\rho_{\text{sim}}}
\newcommand{\SimulatedTrajectorySet}{\mathcal{S}_{\text{sim}}}
\newcommand{\SimulatedTransportDelay}{T_{d,\text{sim}}}
\newcommand{\SimulatedUnbrakedImpactForce}{F_{\text{unbraked,sim}}}
\newcommand{\SimulationParameterSet}{\Xi}
\newcommand{\SimulationParameterVector}{\boldsymbol{\xi}}
\newcommand{\SimulatorStepFunction}{\mathbf{F}}
\newcommand{\SingleAgentAcceptanceProbability}{p_{\text{single}}}
\newcommand{\SingleDeviceContextLength}{S_{\text{single}}}
\newcommand{\SingleDeviceRunTime}{T_1}
\newcommand{\SingleJointAccelerationLimit}{\ddot{q}_{i,\max}}
\newcommand{\SingleJointInertia}{M}
\newcommand{\SingleJointVelocityLimit}{\dot{q}_{i,\max}}
\newcommand{\SingleLinkBandwidth}{\text{BW}_{\text{link}}}
\newcommand{\SingleStepImitationError}{\epsilon}
\newcommand{\SingularSpectrumMatrix}{\boldsymbol{\Sigma}}
\newcommand{\SisaShardCount}{K}
\newcommand{\SisaTrainingShard}{S}
\newcommand{\SixthHarmonicTorqueRipple}{\tau_{\text{ripple}}}
\newcommand{\SkewDisplacementEnvelope}{d_{\text{skew}}}
\newcommand{\SkillSelectionDistribution}{p}
\newcommand{\SlaveDriveCount}{S}
\newcommand{\SlaveDriveIndex}{s}
\newcommand{\SlaveForwardingDelay}{t_{\text{slave},s}}
\newcommand{\SlipAccelerationBound}{a_{\text{slip}}}
\newcommand{\SlipRegularizationSpeed}{\epsilon_{\text{reg}}}
\newcommand{\SloVector}{\mathbf{S}}
\newcommand{\SlowdownPersistenceUpdateCount}{K}
\newcommand{\SmallChange}{\delta}
\newcommand{\SmallPerturbation}{\delta}
\newcommand{\SmallestJacobianSingularNumber}{\sigma_{\min}}
\newcommand{\SmallestKeySingularNumber}{\sigma_{\min(S, d_{\text{head}})}}
\newcommand{\SmoothedClassifier}{g}
\newcommand{\SmoothedRunnerUpProbability}{p_{B}}
\newcommand{\SmoothedTargetAction}{\tilde{\mathbf{a}}'}
\newcommand{\SmoothedTopClassProbability}{p_{A}}
\newcommand{\SmoothingNoiseClipBound}{c}
\newcommand{\SmoothingNoiseStandardDeviation}{\sigma}
\newcommand{\SmoothnessConstant}{L_s}
\newcommand{\SnapshotReadTime}{t_{\text{own}}}
\newcommand{\SnapshotResetCycleTime}{T_{\text{cycle,snap}}}
\newcommand{\SoftExpectedActionReturn}{Q}
\newcommand{\SoftExpectedRemainingReturn}{V}
\newcommand{\SoftenedStudentProbabilityVector}{\mathbf{p}_{\text{student}}^{(T_{\text{distill}})}}
\newcommand{\SoftenedTeacherProbabilityVector}{\mathbf{p}_{\text{teacher}}^{(T_{\text{distill}})}}
\newcommand{\SoftmaxFunction}{\sigma}
\newcommand{\SoftmaxInputScore}{x}
\newcommand{\SoftmaxInputVector}{\mathbf{x}}
\newcommand{\SoftmaxNormalizer}{z}
\newcommand{\SoftmaxOutputProbability}{p}
\newcommand{\SoftmaxRowMaximum}{m}
\newcommand{\SoftmaxRunningMaximum}{m}
\newcommand{\SoftmaxVectorLength}{n}
\newcommand{\SontagStabilizingControl}{\mathbf{u}_{\text{Sontag}}}
\newcommand{\SourceCurrent}{I_{\text{source}}}
\newcommand{\SourceEventTime}{T_{\text{event}}}
\newcommand{\SourceFramePoint}{\mathbf{p}_B}
\newcommand{\SourceSinkPathSet}{\Pi}
\newcommand{\SourceVoltage}{V_{\text{source}}}
\newcommand{\SourceWriteShardGrant}{\Gamma_{c}}
\newcommand{\SpareStoppingClearance}{d_{\text{spare}}}
\newcommand{\SparseMatrixEntryCount}{n_{\text{elem}}}
\newcommand{\SparseMatrixRowCount}{n_{\text{rows}}}
\newcommand{\SparseProductInputComponent}{v}
\newcommand{\SparseWeightMatrix}{\mathbf{W}_{\text{sparse}}}
\newcommand{\SparsityPenaltyWeight}{\lambda_{\text{L1}}}
\newcommand{\SparsityRatio}{\rho_{\text{sparse}}}
\newcommand{\SpatialClearancePredicate}{P_{\text{clear}}}
\newcommand{\SpatialColumnIndex}{j}
\newcommand{\SpatialCovarianceEmbedding}{\mathbf{e}_{\Sigma}}
\newcommand{\SpatialErrorVector}{\boldsymbol{\epsilon}_{\text{spatial}}}
\newcommand{\SpatialHashFunction}{h}
\newcommand{\SpatialMemoryMap}{\mathcal{M}}
\newcommand{\SpatialPositionCount}{N_{\text{pix}}}
\newcommand{\SpatialRowIndex}{i}
\newcommand{\SpatialTransformation}{\mathcal{T}}
\newcommand{\SpecialEuclideanAlgebra}{\mathfrak{se}(3)}
\newcommand{\SpecialEuclideanGroup}{SE(3)}
\newcommand{\SpecialOrthogonalGroup}{SO(3)}
\newcommand{\SpecializedEnergyProductivity}{\rho_{\text{energy,specific}}}
\newcommand{\SpecificHeatCapacity}{c_p}
\newcommand{\SpectrallyNormalizedWeightMatrix}{\overline{\mathbf{W}}}
\newcommand{\SpeculativeDecodingSpeedup}{S_{\text{spec}}}
\newcommand{\SpeculativeDraftLength}{K}
\newcommand{\SpeculativeDraftTokenCount}{k}
\newcommand{\SpeedAtDetection}{v}
\newcommand{\SpeedBound}{v_{\max}}
\newcommand{\SpendingWindowDuration}{T_{\text{win}}}
\newcommand{\SphereSurfaceArea}{S_{D-1}}
\newcommand{\SplineControlPoint}{\mathbf{p}}
\newcommand{\SplineDegree}{p}
\newcommand{\SplineFinalControlIndex}{L}
\newcommand{\SplineKnotTime}{\xi}
\newcommand{\SplitAssignmentMap}{s}
\newcommand{\SplitMessageCount}{N_{\text{msg}}}
\newcommand{\SpotHourlyPrice}{C_{\text{spot}}}
\newcommand{\SpringBrakeEngagementTime}{t_{\text{engage}}}
\newcommand{\SpringCompressionForce}{F}
\newcommand{\SprtExpectedLogIncrement}{m}
\newcommand{\SprtLowerBoundary}{\Lambda_{\text{lo}}}
\newcommand{\SprtLowerLogBoundary}{b_{\text{low}}}
\newcommand{\SprtStoppingSampleCount}{N_{\text{stop}}}
\newcommand{\SprtUpperBoundary}{\Lambda_{\text{up}}}
\newcommand{\SprtUpperLogBoundary}{u}
\newcommand{\SquareGemmDimension}{N}
\newcommand{\SquaredGaussianSumQuantile}{\chi}
\newcommand{\SquaredPathVelocity}{x}
\newcommand{\SquaredRadiusSubstitution}{u}
\newcommand{\SquashedActionComponent}{a}
\newcommand{\SramCapacity}{M_{\text{SRAM}}}
\newcommand{\StabilizationErrorThreshold}{\epsilon_{\text{stable}}}
\newcommand{\StabilizationSlewCeiling}{j_{\text{stable}}}
\newcommand{\StackedContactForces}{\mathbf{f}_{\text{c}}}
\newcommand{\StageConditionalAcceptanceProbability}{q}
\newcommand{\StageEpisodeCount}{N_{\text{episodes}}}
\newcommand{\StageReachProbability}{r}
\newcommand{\StagedDefinitionCount}{n_{\text{def}}}
\newcommand{\StagingExhaustionTime}{T_{\text{exhaust}}}
\newcommand{\StagingStoreCapacity}{M_{\text{stage}}}
\newcommand{\StaleSupportRate}{\epsilon_{\text{stale}}}
\newcommand{\StalenessAdjustedLearningRate}{\eta'}
\newcommand{\StalenessBound}{s}
\newcommand{\StallCounterTorque}{\tau_{\text{stall}}}
\newcommand{\StallTravelBound}{d_{\text{F1}}}
\newcommand{\StandardDeviationMultiple}{k}
\newcommand{\StandardNormalCumulativeDistribution}{\Phi}
\newcommand{\StandardNormalQuantile}{z_q}
\newcommand{\StandbyInstanceMemory}{M_{\text{standby}}}
\newcommand{\StandbyPower}{P_{\text{idle}}}
\newcommand{\StandbyReserveCount}{N_{\text{reserve}}}
\newcommand{\StandstillSpeedThreshold}{\epsilon_{\text{vel}}}
\newcommand{\StateConstraintMatrix}{\mathbf{H}_x}
\newcommand{\StateConstraintVector}{\mathbf{b}_x}
\newcommand{\StateCotangentSpace}{T_{\mathbf{x}}^*}
\newcommand{\StateDimension}{n}
\newcommand{\StateDistribution}{d_\pi}
\newcommand{\StateEstimate}{\hat{\mathbf{x}}}
\newcommand{\StateEstimateDerivative}{\dot{\hat{\mathbf{x}}}}
\newcommand{\StateEstimationError}{\mathbf{e}}
\newcommand{\StateExposureLevel}{S}
\newcommand{\StateNormWeighting}{W}
\newcommand{\StateOperation}{f}
\newcommand{\StateParameterSensitivity}{\mathbf{S}}
\newcommand{\StateRecurrencePeriod}{\ell}
\newcommand{\StateScalarFunction}{\phi}
\newcommand{\StateSpaceDimension}{d_s}
\newcommand{\StateSpaceInputMatrix}{\mathbf{B}}
\newcommand{\StateSpaceSystemMatrix}{\mathbf{A}_{\text{sys}}}
\newcommand{\StateTokenCount}{K_s}
\newcommand{\StateTrackingWeightMatrix}{\mathbf{W}_q}
\newcommand{\StateTransitionMatrix}{\mathbf{F}}
\newcommand{\StatelessCursorPayload}{d}
\newcommand{\StaticBatchingOperations}{O_{\text{traditional}}}
\newcommand{\StaticChassisPower}{P_{\text{chassis\_static}}}
\newcommand{\StaticDataDistribution}{p_{\text{data}}}
\newcommand{\StationaryConditionPolynomial}{P}
\newcommand{\StatisticalDivergence}{\mathcal{D}(P_t \| P_0)}
\newcommand{\StatisticalFalseNegativeRate}{\beta}
\newcommand{\StatisticalHypothesis}{H}
\newcommand{\StatisticalPowerQuantile}{z_{1-\beta}}
\newcommand{\StatisticalSignificanceLevel}{\alpha_{\text{sig}}}
\newcommand{\StatorCoreTemperature}{T_{\text{core}}}
\newcommand{\StatorIronTemperature}{T_{\text{iron}}}
\newcommand{\StatorThermalCapacitance}{C_{\text{th}}}
\newcommand{\StatusPollCount}{N_{\text{poll}}}
\newcommand{\SteadyDeceleration}{a}
\newcommand{\SteadyStateAvailability}{A}
\newcommand{\SteadyStateCurrent}{I_{\text{final}}}
\newcommand{\SteadyStateErrorCovariance}{\mathbf{P}_{\text{est}}}
\newcommand{\SteadyStateIntegratorState}{\mathbf{z}_{\text{ss}}}
\newcommand{\SteadyStateTemperatureRise}{\Delta T_{\max}}
\newcommand{\SteadyStateTrackingError}{\mathbf{e}_{\text{ss}}}
\newcommand{\SteeringTransferTime}{T}
\newcommand{\StepFailureHazard}{a}
\newcommand{\StepGenerationCost}{C_{\text{gen}}}
\newcommand{\StepGenerationTime}{T_{\text{step}}}
\newcommand{\StepIoTime}{T_{\text{IO}}}
\newcommand{\StepResponsePhaseLag}{\Delta \phi}
\newcommand{\StepSettlingTime}{t_{\text{settle}}}
\newcommand{\StepSuccessProbability}{p}
\newcommand{\StepTestVoltage}{V_{\text{step}}}
\newcommand{\StepTimePenalty}{c_{\text{time}}}
\newcommand{\StepTokenLogit}{z_{t,v}}
\newcommand{\StereoBaseline}{b}
\newcommand{\StereoDisparity}{d}
\newcommand{\StlEventuallyDeadline}{\tau}
\newcommand{\StlFormula}{\phi}
\newcommand{\StlIntervalEnd}{b}
\newcommand{\StlIntervalStart}{a}
\newcommand{\StlPredicateFunction}{f}
\newcommand{\StlRobustness}{\rho}
\newcommand{\StlUntilOperator}{\mathcal{U}_{[a, b]}}
\newcommand{\StockoutNormalQuantile}{z_{1-\epsilon}}
\newcommand{\StockoutProbabilityTarget}{\epsilon}
\newcommand{\StopAxisAcceleration}{\ddot{q}_{\text{stop}}}
\newcommand{\StopAxisPosition}{q_{\text{stop}}}
\newcommand{\StopCompletionInstant}{t_{\text{stop\_end}}}
\newcommand{\StopDecisionComputeBound}{T_{\text{compute}}}
\newcommand{\StopProgress}{u}
\newcommand{\StopSequenceSet}{\mathcal{S}_{\text{stop}}}
\newcommand{\StoppingBoundaryClearance}{z}
\newcommand{\StoppingCrossoverSpeed}{v^{*}}
\newcommand{\StoppingDeadline}{t_{\text{deadline,stop}}}
\newcommand{\StoppingDistance}{d_{\text{stop}}}
\newcommand{\StoppingDistanceBudget}{d_{\text{budget}}}
\newcommand{\StoppingDuration}{T_{\text{stop}}}
\newcommand{\StorageAccessFactor}{F_{\text{access}}}
\newcommand{\StorageBandwidth}{\text{BW}_{\text{storage}}}
\newcommand{\StorageCapacityPrice}{C_{\text{storage/byte-time}}}
\newcommand{\StorageFunction}{V}
\newcommand{\StorageFunctionDerivative}{\dot{V}}
\newcommand{\StorageIngestBandwidth}{\text{BW}_{\text{ingest}}}
\newcommand{\StoragePrice}{c_{\text{storage}}}
\newcommand{\StorageReadTime}{T_{\text{read}}}
\newcommand{\StorageRetentionTime}{T_{\text{months}}}
\newcommand{\StorageThroughput}{R_{\text{storage}}}
\newcommand{\StoredDataVolume}{D_{\text{vol,store}}}
\newcommand{\StoredEmbedding}{\mathbf{z}}
\newcommand{\StoredIndexVector}{\mathbf{x}}
\newcommand{\StoredSystemState}{s}
\newcommand{\StoredTokenVolume}{V}
\newcommand{\StragglerStepTime}{T_{\text{step,straggler}}}
\newcommand{\StreamAcceptanceProbability}{p}
\newcommand{\StreamingEndToEndLatency}{T_{\text{streaming}}}
\newcommand{\StrideCheckpointCount}{N}
\newcommand{\StrongConfigurationAttemptCost}{c_{\text{big}}}
\newcommand{\StrongConfigurationPassProbability}{p_{\text{big}}}
\newcommand{\StruckObjectMass}{m_{\text{obj}}}
\newcommand{\StructuredSparsityGroupSize}{m_{\text{group}}}
\newcommand{\StructuredSparsityNonzeroCount}{n_{\text{keep}}}
\newcommand{\StudentProbabilityVector}{\mathbf{p}_{\text{student}}}
\newcommand{\StuffBitTime}{t_{\text{stuff},i}}
\newcommand{\SubgroupIndex}{g}
\newcommand{\SubgroupSampleSize}{n}
\newcommand{\SubintervalFailureProbability}{p}
\newcommand{\SublevelSetThreshold}{c}
\newcommand{\SubsequentArrivalTime}{\tau}
\newcommand{\SubsetAllPassIndicator}{I_J^{\text{all}}}
\newcommand{\SubsetAnyPassIndicator}{I_J}
\newcommand{\SubsetDatasetSize}{D_{\text{subset}}}
\newcommand{\SuccessCountIndex}{j}
\newcommand{\SuccessLowerConfidenceLimit}{p_{\text{lower}}}
\newcommand{\SuccessfulTrialCount}{k}
\newcommand{\SuccessorActionVector}{\mathbf{a}'}
\newcommand{\SuccessorPlanningState}{s'}
\newcommand{\SuffixFoldTime}{T_{\text{fold}}}
\newcommand{\SummaryOutputLength}{K_{\text{sum}}}
\newcommand{\SummaryTokenEmbedding}{\mathbf{x}_{\text{class}}}
\newcommand{\SupervisoryMtbi}{T_{\text{MTBI}}}
\newcommand{\SupervisoryTakeoverLatency}{T_{\Sigma}}
\newcommand{\SupplyVoltage}{V}
\newcommand{\SupportPolygon}{\mathcal{P}_{\text{support}}}
\newcommand{\SupportSetSize}{n_{\text{shot}}}
\newcommand{\SustainableAttemptRate}{R_{\text{attempt}}}
\newcommand{\SustainableCopperLossPower}{P_{\text{loss,ss}}}
\newcommand{\SustainableHoldingTorque}{\tau_{\text{hold,max}}}
\newcommand{\SustainedComputeRate}{R_{\text{sustained}}}
\newcommand{\SustainedDropoutFrameCount}{N_{\text{drop}}}
\newcommand{\SustainedMemoryBandwidth}{\text{BW}_{\text{mem}}}
\newcommand{\SweepCandidateCostFraction}{f}
\newcommand{\SweepCandidateCount}{k}
\newcommand{\SwitchBreakdownVoltage}{V_{\text{breakdown}}}
\newcommand{\SwitchInputCapacitance}{C_{\text{iss}}}
\newcommand{\SwitchOnResistance}{R_{\text{ds(on)}}}
\newcommand{\SwitchRadix}{k}
\newcommand{\SwitchedCapacitance}{C}
\newcommand{\SwitchingActivityFactor}{\alpha}
\newcommand{\SwitchingEnergy}{E}
\newcommand{\SwitchingTransitionTime}{t_{\text{sw}}}
\newcommand{\SymbolicPlanningState}{s}
\newcommand{\SymmetricClippingThreshold}{\alpha_{\text{sym}}}
\newcommand{\SymmetricMessageOverhead}{o}
\newcommand{\SymplecticEulerTransitionMatrix}{\mathbf{A}_{\text{symp}}}
\newcommand{\SyncMessageInterval}{\Delta t_{\text{interval}}}
\newcommand{\SyncPairingDisplacement}{\Delta \mathbf{x}_{\text{sync}}}
\newcommand{\SynchronizationBlackout}{T_{\text{blackout}}}
\newcommand{\SynchronizationClearanceMargin}{d_{\text{sync}}}
\newcommand{\SynchronizationErrorBound}{\epsilon_{\text{sync}}}
\newcommand{\SynchronizationStepIndex}{k}
\newcommand{\SynchronizationTime}{T_{\text{sync}}}
\newcommand{\SyntheticDataGenerator}{G_{\theta}}
\newcommand{\SyntheticDataset}{\mathcal{S}_{\text{synthetic}}}
\newcommand{\SystemCallFilterTime}{T_{\text{filter}}}
\newcommand{\SystemCallOverheadTime}{T_{\text{syscall}}}
\newcommand{\SystemFailureRate}{\lambda_{\text{system}}}
\newcommand{\SystemHazardRate}{\lambda_{\text{system}, h}}
\newcommand{\SystemInstructionTokenCount}{S_{\text{system}}}
\newcommand{\SystemMatrixPowerIndex}{k}
\newcommand{\SystemMemoryBandwidth}{\text{BW}_{\text{system}}}
\newcommand{\SystemMtbf}{\text{MTBF}_{\text{system}}}
\newcommand{\SystemReliability}{R_{\text{system}}}
\newcommand{\TableRowCount}{N}
\newcommand{\TailByteAllocation}{M_{\text{tail}}}
\newcommand{\TailMomentOrder}{k}
\newcommand{\TailPerformanceMetric}{X}
\newcommand{\TailRequestLatency}{T_{\text{lat},\text{p99}}}
\newcommand{\TailRequestSeenBatchSize}{B_{\text{req,p99}}}
\newcommand{\TailRiskDistributionFunction}{F}
\newcommand{\TailRiskObservation}{X}
\newcommand{\TailRiskObservationLevel}{x}
\newcommand{\TailShapeParameter}{\xi}
\newcommand{\TailStepIoTime}{T_{\text{IO,p99}}}
\newcommand{\TailSupportUpperEndpoint}{x_F}
\newcommand{\TakeoverInstant}{t_{\text{takeover}}}
\newcommand{\TakeoverResponseTime}{T_{\Sigma, 1}}
\newcommand{\TakeoverStateVisitationDistribution}{p^{\text{takeover}}}
\newcommand{\TakeoverTrackingError}{\mathbf{e}_{\text{track}}}
\newcommand{\TangentDirection}{\mathbf{v}}
\newcommand{\TangentSeedVector}{\dot{\mathbf{x}}}
\newcommand{\TangentialContactShear}{\mathbf{f}_{k, \parallel}}
\newcommand{\TangentialSpeed}{v_{\text{tangential}}}
\newcommand{\TapeIntermediateResult}{y_{\text{tape}}}
\newcommand{\TargetAcceptanceDifference}{\Delta}
\newcommand{\TargetActionReturnEstimate}{\hat{Q}}
\newcommand{\TargetActorParameters}{\theta'}
\newcommand{\TargetBatchSize}{B_{\text{target}}}
\newcommand{\TargetCompletionQuantile}{q}
\newcommand{\TargetComputeRate}{R_{\text{ops}}}
\newcommand{\TargetComputeTimeFraction}{\eta_{\text{target}}}
\newcommand{\TargetCriticParameters}{\phi'}
\newcommand{\TargetCriticReturnEstimate}{Q_{\phi'}}
\newcommand{\TargetDeterministicPolicy}{\mu_{\theta'}}
\newcommand{\TargetError}{\epsilon}
\newcommand{\TargetExceedanceProbability}{\epsilon}
\newcommand{\TargetFairShare}{F_{\text{target}}}
\newcommand{\TargetFramePoint}{\mathbf{p}_A}
\newcommand{\TargetHazardRate}{\lambda_{\text{target}}}
\newcommand{\TargetImpedanceDampingMatrix}{\mathbf{D}_d}
\newcommand{\TargetImpedanceInertiaMatrix}{\mathbf{M}_d}
\newcommand{\TargetImpedanceStiffnessMatrix}{\mathbf{K}_d}
\newcommand{\TargetInferenceLatency}{L_{\text{lat,target}}}
\newcommand{\TargetKeyAttentionWeight}{\alpha_{\text{target}}}
\newcommand{\TargetKeyLogit}{z_{\text{target}}}
\newcommand{\TargetModelDistribution}{p_{\theta}}
\newcommand{\TargetOrientation}{\mathbf{R}_{\text{target}}}
\newcommand{\TargetPlantState}{\mathbf{x}_{f}}
\newcommand{\TargetPolicyEntropy}{\overline{\mathcal{H}}}
\newcommand{\TargetPose}{\mathbf{T}_{\text{target}}}
\newcommand{\TargetPosition}{\mathbf{p}_{\text{target}}}
\newcommand{\TargetPositionComponent}{p_{\text{target},i}}
\newcommand{\TargetRange}{z}
\newcommand{\TargetRepeatedRunConsistency}{p_{\text{target}}}
\newcommand{\TargetSamplingDistribution}{p}
\newcommand{\TargetServingUtilization}{\rho_{\text{target}}}
\newcommand{\TargetSmoothingNoise}{\boldsymbol{\epsilon}}
\newcommand{\TargetSmoothingNoiseStandardDeviation}{\sigma}
\newcommand{\TargetTokenVolume}{W}
\newcommand{\TargetTravelDistance}{d}
\newcommand{\TargetTrialFailureProbability}{p_{*}}
\newcommand{\TargetTrialSuccessProbability}{p_{\text{target}}}
\newcommand{\TargetTwinCriticReturnEstimate}{Q_{\phi'_i}}
\newcommand{\TargetUnitQuaternion}{\mathbf{q}_{\text{quat,target}}}
\newcommand{\TargetUpdateCount}{K_{\text{target}}}
\newcommand{\TargetUtilizationBatchSize}{B_{\text{util}}}
\newcommand{\TargetXPosition}{x}
\newcommand{\TargetYPosition}{p_y}
\newcommand{\TargetZPosition}{z}
\newcommand{\TaskAcceptanceLabel}{x}
\newcommand{\TaskBlockingTime}{B}
\newcommand{\TaskContract}{\mathcal{C}}
\newcommand{\TaskContractGoal}{G}
\newcommand{\TaskCost}{C_{\text{task}}}
\newcommand{\TaskCount}{K}
\newcommand{\TaskCoverageProbability}{Q}
\newcommand{\TaskCriticalSections}{cs}
\newcommand{\TaskDerivativeGain}{\mathbf{K}_{d,i}}
\newcommand{\TaskDistance}{d_{\text{task}}}
\newcommand{\TaskEnvironment}{\mathcal{E}_{\text{env}}}
\newcommand{\TaskErrorTolerance}{\tau_{\text{tol}}}
\newcommand{\TaskGroupMap}{g}
\newcommand{\TaskIndex}{i}
\newcommand{\TaskInterferenceTime}{I}
\newcommand{\TaskJacobian}{\mathbf{J}}
\newcommand{\TaskJacobianDerivative}{\dot{\mathbf{J}}}
\newcommand{\TaskJacobianPseudoinverse}{\mathbf{J}^\dagger}
\newcommand{\TaskKinematicMap}{f}
\newcommand{\TaskLoss}{\mathcal{L}_{\text{task}}}
\newcommand{\TaskLossGradient}{\nabla \mathcal{L}}
\newcommand{\TaskPeriod}{T}
\newcommand{\TaskProportionalGain}{\mathbf{K}_{p,i}}
\newcommand{\TaskReadCount}{n_{\text{read}}}
\newcommand{\TaskRelativeDeadline}{D}
\newcommand{\TaskRelevantOutcome}{\mathbf{Y}_{\text{task}}}
\newcommand{\TaskReward}{r_{\text{task}}}
\newcommand{\TaskSetUtilization}{U}
\newcommand{\TaskSpaceAcceleration}{\ddot{\mathbf{x}}}
\newcommand{\TaskSpaceCoordinates}{\mathbf{x}}
\newcommand{\TaskSpaceDimension}{m}
\newcommand{\TaskSpaceReference}{\mathbf{x}_i^{\text{ref}}}
\newcommand{\TaskSpaceReferenceAcceleration}{\ddot{\mathbf{x}}^{\text{ref}}}
\newcommand{\TaskSpaceReferenceVelocity}{\dot{\mathbf{x}}^{\text{ref}}}
\newcommand{\TaskSpaceVelocity}{\dot{\mathbf{x}}}
\newcommand{\TaskSpecificLoss}{\mathcal{L}}
\newcommand{\TaskStateTokenCount}{S_{\text{state}}}
\newcommand{\TaskToleranceSemiAxes}{\mathbf{r}}
\newcommand{\TaskToleranceSemiAxis}{r}
\newcommand{\TaskTurnCost}{C_{\text{call}}}
\newcommand{\TaskWeight}{w}
\newcommand{\TasksPerComparisonArm}{N_{\text{arm}}}
\newcommand{\TeamQuotaCap}{Q_{\text{team}}}
\newcommand{\TelemetryFlushTime}{t_{\text{telemetry\_flush}}}
\newcommand{\TelemetryFreshnessBound}{\Delta t_{\text{fresh}}}
\newcommand{\TelemetryRetentionDuration}{T_{\text{retention}}}
\newcommand{\TelemetrySamplingFrequency}{f_{\text{sample}}}
\newcommand{\TelemetrySeriesCount}{N_{\text{series}}}
\newcommand{\TelemetryTickInterval}{\Delta t_s}
\newcommand{\TeleoperationCommandLatency}{t_{\text{cmd}}}
\newcommand{\TeleoperationDownlinkTime}{T_{\text{downlink}}}
\newcommand{\TeleoperationRoundTripLatency}{t_{\text{loop}}}
\newcommand{\TeleoperationRoundTripTime}{T_{\text{RTT}}}
\newcommand{\TeleoperationStateVisitationDistribution}{p^{\pi_{\text{teleop}}}}
\newcommand{\TeleoperationUplinkTime}{T_{\text{uplink}}}
\newcommand{\TeleoperationVideoLatency}{T_{\text{video}}}
\newcommand{\TemperatureDualObjective}{\mathcal{L}}
\newcommand{\TemperatureStepSize}{\lambda_{\alpha}}
\newcommand{\TemplateSharedMemory}{M_{\text{template}}}
\newcommand{\TemporalDifferenceResidual}{\delta}
\newcommand{\TemporalEnsemblingWeight}{w_i}
\newcommand{\TenantIndex}{i}
\newcommand{\TenantResourceAllocation}{a_{i,r}}
\newcommand{\TensorAxisCount}{n}
\newcommand{\TensorColumnModeSize}{J}
\newcommand{\TensorCoreAccumulatorMatrix}{\mathbf{C}_{\text{acc}}}
\newcommand{\TensorCoreLeftInput}{\mathbf{A}_{\text{tc}}}
\newcommand{\TensorCoreOutputMatrix}{\mathbf{D}_{\text{tc}}}
\newcommand{\TensorCoreRightInput}{\mathbf{B}_{\text{tc}}}
\newcommand{\TensorDepthModeSize}{T}
\newcommand{\TensorElementCount}{N}
\newcommand{\TensorModeIndex}{n_{\text{mode}}}
\newcommand{\TensorParallelDegree}{N_{\text{TP}}}
\newcommand{\TensorParallelLayerTime}{T_{\text{inference}}}
\newcommand{\TensorRowModeSize}{I}
\newcommand{\TerminalFeedbackGain}{\mathbf{K}_f}
\newcommand{\TerminalInvariantSet}{\mathcal{X}_{f}}
\newcommand{\TerminalPlantState}{\mathbf{x}_N}
\newcommand{\TerminalTransitTime}{t_{\text{transit}}}
\newcommand{\TerminalVoltageLimit}{V_{\max}}
\newcommand{\TerminationProtocol}{\kappa}
\newcommand{\TestExample}{z_{\text{test}}}
\newcommand{\TestFamilySize}{k}
\newcommand{\TestPhaseCapabilityGrant}{\Gamma_{\text{test}}}
\newcommand{\TestsDirectoryShardGrant}{\Gamma_{a}}
\newcommand{\TextTokenCount}{S_{\text{text}}}
\newcommand{\TextTokenEmbeddings}{\mathbf{z}_{\text{text}}}
\newcommand{\ThermalExpansionCoefficient}{\alpha}
\newcommand{\ThermalPenaltyWeight}{\lambda_T}
\newcommand{\ThermalPowerLimit}{P_{\text{thermal}}}
\newcommand{\ThermalResistance}{R_{\text{th}}}
\newcommand{\ThermalTimeConstant}{\tau_{\text{th}}}
\newcommand{\ThirdFloatingPointAddend}{c}
\newcommand{\ThirdRingTraceElement}{c}
\newcommand{\ThresholdExceedanceCount}{N_u}
\newcommand{\ThresholdExceedanceRate}{\zeta_u}
\newcommand{\ThresholdExcess}{y}
\newcommand{\ThresholdExcessVariable}{Y}
\newcommand{\ThresholdedSparsityRatio}{\rho_{\text{sparse},\delta}}
\newcommand{\ThrottleClearTemperature}{T_{\text{clear}}}
\newcommand{\ThrottleOnsetJunctionTemperature}{T_{\text{j},\text{start}}}
\newcommand{\ThrottleRecoveryTime}{t_{\text{recov}}}
\newcommand{\ThrottleTripTemperature}{T_{\text{trip}}}
\newcommand{\ThrottledClockFrequency}{f_{\text{throt}}}
\newcommand{\TickCycleCount}{N}
\newcommand{\TickIndex}{n}
\newcommand{\TickPeriodJitterBound}{J_{\text{phase}}}
\newcommand{\TieredRequestServiceTime}{T}
\newcommand{\TightenedDiscreteSafeSet}{\mathcal{C}_{\text{discrete}}}
\newcommand{\TileRowIndex}{m}
\newcommand{\TiltAngle}{\theta_{\text{tilt}}}
\newcommand{\Time}{T}
\newcommand{\TimeBudgetUsedFraction}{\rho_T}
\newcommand{\TimeInstant}{t}
\newcommand{\TimeScaleSeparationRatio}{\epsilon}
\newcommand{\TimeStepIndex}{t}
\newcommand{\TimeToResult}{T_{\text{result}}}
\newcommand{\TimeToTarget}{T_{\text{target}}}
\newcommand{\TimeoutSafetyMultiplier}{k}
\newcommand{\TimeoutTrialCount}{n_{\text{timeout}}}
\newcommand{\TimerClockPeriod}{T_{\text{timer\_clk}}}
\newcommand{\TimestampJitterDelay}{\delta_{\text{jitter}}}
\newcommand{\TimestampQuantizationBound}{T_{\text{quant}}}
\newcommand{\TimestampSkew}{t_{\text{skew}}}
\newcommand{\TimingJitter}{\sigma_{\text{jitter}}}
\newcommand{\TimingRealityGap}{\Delta_{\text{lat}}}
\newcommand{\TokenAuthenticationCode}{\sigma}
\newcommand{\TokenAveragedBatchLoss}{\mathcal{L}_{\text{token}}}
\newcommand{\TokenBucketDepth}{b}
\newcommand{\TokenBucketRefillRate}{r}
\newcommand{\TokenBudgetUsedFraction}{\rho_N}
\newcommand{\TokenByteDecoding}{s}
\newcommand{\TokenCaveat}{c}
\newcommand{\TokenDispatchTime}{T_{\text{dispatch}}}
\newcommand{\TokenIdentifierSize}{s_{\text{id}}}
\newcommand{\TokenIndex}{t}
\newcommand{\TokenPrefix}{x_{<t}}
\newcommand{\TokenVocabulary}{\mathcal{V}}
\newcommand{\TokenizationTime}{T_{\text{tokenize}}}
\newcommand{\ToleranceEllipsoidMatrix}{\mathbf{E}}
\newcommand{\ToleratedFailureProbability}{\epsilon}
\newcommand{\ToleratedPositionError}{\epsilon_{\text{pos}}}
\newcommand{\TombstonedNodeSet}{V_{\text{tomb}}}
\newcommand{\TombstonedRecordFraction}{\rho_{\text{dead}}}
\newcommand{\ToolArgumentKey}{p}
\newcommand{\ToolCallCategory}{y}
\newcommand{\ToolCallCost}{c_{\text{tool}}}
\newcommand{\ToolCallIndex}{i}
\newcommand{\ToolCallReadSet}{R}
\newcommand{\ToolCallWriteSet}{W}
\newcommand{\ToolCartesianPose}{\mathbf{x}}
\newcommand{\ToolCartesianVelocity}{\dot{\mathbf{x}}}
\newcommand{\ToolCenterPointAxis}{\hat{\mathbf{z}}_{\text{TCP}}}
\newcommand{\ToolCenterPointFrame}{\mathcal{F}_{\text{TCP}}}
\newcommand{\ToolCenterPointPose}{\mathbf{T}_{\text{TCP}}}
\newcommand{\ToolCenterPointPosition}{\mathbf{p}_{\text{TCP}}}
\newcommand{\ToolClearanceDistance}{d_{\text{tool}}}
\newcommand{\ToolDeclarationTokenCount}{S_{\text{tools}}}
\newcommand{\ToolDescriptorSize}{S_{\text{desc}}}
\newcommand{\ToolPlanarAbscissa}{x}
\newcommand{\ToolPlanarOrdinate}{y}
\newcommand{\ToolPositionError}{e_{\text{tool}}}
\newcommand{\ToolServiceCount}{N_{\text{tool}}}
\newcommand{\ToolSpeedLimit}{v_{\text{TCP}}}
\newcommand{\ToolTargetState}{s}
\newcommand{\ToolTime}{T_{\text{tool}}}
\newcommand{\ToolTipPose}{\mathbf{T}_{\text{tool}}}
\newcommand{\TopClassCount}{k}
\newcommand{\TopMagnitudeIndicator}{\mathbf{1}_{|\mathbf{g}| \geq |\mathbf{g}|_{(K_{\text{top}})}}}
\newcommand{\TopTokenSampleCount}{k}
\newcommand{\TopologicalPlaceNode}{p^{\text{place}}}
\newcommand{\TopologyEndpointCount}{N}
\newcommand{\TorqueCutoffCommand}{\mathbf{u}_{\text{cutoff}}}
\newcommand{\TorqueEffortPenaltyWeight}{\lambda_{\tau}}
\newcommand{\TorqueProducingCurrent}{i_q}
\newcommand{\TorqueRateLimit}{\dot{\tau}_{\max}}
\newcommand{\TorqueRegularizationWeight}{w_\tau}
\newcommand{\TorqueSlewPenaltyWeight}{\lambda_{\dot{\tau}}}
\newcommand{\TorusFirstAxisChipCount}{X}
\newcommand{\TorusSecondAxisChipCount}{Y}
\newcommand{\TorusThirdAxisChipCount}{Z}
\newcommand{\TotalChipPower}{P_{\text{total}}}
\newcommand{\TotalCollisionQueryTime}{T_{\text{query\_total}}}
\newcommand{\TotalDataCost}{C_{\text{total}}}
\newcommand{\TotalDelayPhaseShift}{\phi_{\text{total}}}
\newcommand{\TotalEnergy}{E_{\text{total}}}
\newcommand{\TotalExecutedTrialCount}{N_{\text{total}}}
\newcommand{\TotalFailureRecoveryTime}{T_{\text{recovery}}}
\newcommand{\TotalGateCharge}{Q_g}
\newcommand{\TotalInterventionCount}{N_{\text{int}}}
\newcommand{\TotalKineticEnergy}{E_{k,\text{total}}}
\newcommand{\TotalMemoryFootprint}{M_{\text{total}}}
\newcommand{\TotalPipelineLatency}{L_{\text{lat,total}}}
\newcommand{\TotalTrainingRunCost}{C_{\text{total}}}
\newcommand{\TraceCrashCount}{N_{\text{crash}}}
\newcommand{\TraceCrashIndex}{i}
\newcommand{\TraceDecay}{\lambda}
\newcommand{\TraceIntermediateAdjoint}{\bar{v}}
\newcommand{\TraceIntermediateTangent}{\dot{v}}
\newcommand{\TraceIntermediateVariable}{v}
\newcommand{\TrackIndex}{i}
\newcommand{\TrackLastUpdateTime}{t_{\text{last}}}
\newcommand{\TrackLossTimeout}{T_{\text{lost}}}
\newcommand{\TrackPositionDeviation}{\sigma_{\text{track}}}
\newcommand{\TrackPredictedErrorCovariance}{\mathbf{P}_{t|t-1}}
\newcommand{\TrackPredictedStateEstimate}{\hat{\mathbf{x}}_{t|t-1}}
\newcommand{\TrackedEvidenceHorizon}{\tau_{\text{ev,tracked}}}
\newcommand{\TrackerFrameIndex}{t}
\newcommand{\TrackingErrorAcceleration}{\ddot{\mathbf{e}}}
\newcommand{\TrackingErrorAllowance}{\epsilon_{\text{pos}}}
\newcommand{\TrackingErrorBound}{\epsilon_{\text{track}}}
\newcommand{\TrackingErrorDistance}{e}
\newcommand{\TrackingErrorRate}{\dot{\mathbf{e}}}
\newcommand{\TrackingErrorVector}{\mathbf{e}}
\newcommand{\TrackingRelaxationSlack}{\delta}
\newcommand{\TrackingSlackPenaltyWeight}{p}
\newcommand{\TrackingStartInstant}{t_{\text{start}}}
\newcommand{\TractionLimitedDeceleration}{a}
\newcommand{\TractiveForce}{F_x}
\newcommand{\TrainableStateMemory}{M_{\text{train}}}
\newcommand{\TrainerUpdateTime}{T_{\text{train}}}
\newcommand{\TrainingCompute}{O_{\text{train}}}
\newcommand{\TrainingCost}{C_{\text{train}}}
\newcommand{\TrainingDataset}{D}
\newcommand{\TrainingDistribution}{P_0}
\newcommand{\TrainingEmpiricalCdf}{F_{P_0}}
\newcommand{\TrainingExample}{z}
\newcommand{\TrainingFailureCount}{N_{\text{failures}}}
\newcommand{\TrainingFeatureMean}{\mu}
\newcommand{\TrainingFeatureStandardDeviation}{\sigma}
\newcommand{\TrainingLabelMask}{\mathcal{M}_{\text{train}}}
\newcommand{\TrainingLoss}{\mathcal{L}_{\text{train}}}
\newcommand{\TrainingPathPredictor}{f_{\text{train}}}
\newcommand{\TrainingPipelineFunction}{f}
\newcommand{\TrainingRunCount}{N_{\text{runs}}}
\newcommand{\TrainingSampleThroughput}{R_{\text{train}}}
\newcommand{\TrainingSchemaKeySet}{\mathcal{K}_{\text{train}}}
\newcommand{\TrainingServingSkew}{S_{\text{skew}}}
\newcommand{\TrainingSplitFraction}{f_{\text{train}}}
\newcommand{\TrainingStepCount}{K}
\newcommand{\TrainingStepEnergy}{E_{\text{step}}}
\newcommand{\TrainingStepOperations}{O_{\text{step}}}
\newcommand{\TrainingStepTime}{T_{\text{step}}}
\newcommand{\TrainingThroughput}{R_{\text{training}}}
\newcommand{\TrainingTime}{T_{\text{train}}}
\newcommand{\TrainingTransformFunction}{f_{\text{train}}}
\newcommand{\Trajectory}{\tau}
\newcommand{\TrajectoryAction}{a}
\newcommand{\TrajectoryAdmissionRate}{\lambda_{\text{traj}}}
\newcommand{\TrajectoryBudget}{\mathbf{B}}
\newcommand{\TrajectoryCallCount}{N_{\text{call}}}
\newcommand{\TrajectoryCategoryIndex}{j}
\newcommand{\TrajectoryCheckpointCount}{N_{\text{ckpt}}}
\newcommand{\TrajectoryDivergenceResidual}{e_{\text{div}}}
\newcommand{\TrajectoryDuration}{T_{\text{traj}}}
\newcommand{\TrajectoryGoodput}{\mathcal{G}}
\newcommand{\TrajectoryObservation}{o}
\newcommand{\TrajectoryOptimizationObjective}{\mathcal{U}}
\newcommand{\TrajectoryRecordDuration}{T_{\text{record}}}
\newcommand{\TrajectoryRecordFrame}{\mathcal{F}}
\newcommand{\TrajectoryReturn}{R}
\newcommand{\TrajectoryReward}{R}
\newcommand{\TrajectorySampleCount}{N}
\newcommand{\TrajectoryState}{s}
\newcommand{\TrajectoryStateSpace}{\mathcal{S}}
\newcommand{\TrajectoryTimeLimit}{T_{\max}}
\newcommand{\TrajectoryTokenCost}{C_{\text{session}}}
\newcommand{\TrajectoryTokenLimit}{N_{\max}}
\newcommand{\TrajectoryTurnLimit}{H_{\max}}
\newcommand{\TransceiverDelay}{t_{\text{transceiver}}}
\newcommand{\TransductionInstant}{t_{\text{transduction}}}
\newcommand{\TransferBufferCount}{N_{\text{transfer}}}
\newcommand{\TransferDiscrepancyBound}{\epsilon_{\text{gap}}}
\newcommand{\TransferTimeForPayload}{T_{\text{transfer}}}
\newcommand{\TransferredDataVolume}{D_{\text{vol,transfer}}}
\newcommand{\TransformGraph}{\mathcal{G}}
\newcommand{\TransformGraphEdgeSet}{\mathcal{E}}
\newcommand{\TransformGraphFrame}{\mathcal{F}}
\newcommand{\TransformGraphVertexSet}{\mathcal{V}}
\newcommand{\TransformRotationBlock}{\mathbf{R}_{AB}}
\newcommand{\TransformTranslationBlock}{\mathbf{t}_{AB}}
\newcommand{\TransformationInputCount}{k}
\newcommand{\TransformedCartesianPosition}{\mathbf{p}'}
\newcommand{\TransformedHomogeneousPointCoordinates}{\tilde{\mathbf{p}}'}
\newcommand{\TransistorThresholdVoltage}{V_{\text{th}}}
\newcommand{\TransitionStorageSize}{b_{\text{tr}}}
\newcommand{\TranslationComponent}{v}
\newcommand{\TranslationVector}{\mathbf{v}}
\newcommand{\TranslationalDriftError}{e_{\text{trans}}}
\newcommand{\TranslationalJerk}{j}
\newcommand{\TranslationalKineticEnergy}{E_{k,\text{trans}}}
\newcommand{\TransmissionEnergyPerByte}{E_{\text{tx}}}
\newcommand{\TransmissionInputInertia}{J_{\text{in}}}
\newcommand{\TransmissionTorsionalStiffness}{K_{\text{joint}}}
\newcommand{\TransverseStandardDeviation}{\sigma_\perp}
\newcommand{\TravelPosition}{x}
\newcommand{\TraverseDistance}{d}
\newcommand{\TreatedNeighborFraction}{e}
\newcommand{\TreatmentAssignment}{w}
\newcommand{\TreatmentConversionRate}{\hat{p}_B}
\newcommand{\TreatmentSampleSize}{m_B}
\newcommand{\TreeAllReduceCompletionTime}{T_{\text{tree}}}
\newcommand{\TreeLikeAllReduceTime}{T_{\text{tree-like}}}
\newcommand{\TreeSearchExplorationWeight}{c_{\text{explore}}}
\newcommand{\TreeSearchLeafScore}{V}
\newcommand{\TreeSearchMeanReturn}{Q}
\newcommand{\TreeSearchPriorDistribution}{p_{\text{prior}}}
\newcommand{\TreeSearchVisitCount}{N_{\text{visit}}}
\newcommand{\TrialCampaignWallTime}{T_{\text{wall}}}
\newcommand{\TrialCompletionIndicator}{Y}
\newcommand{\TrialCondition}{c}
\newcommand{\TrialControlStepCount}{N_{\text{steps}, i}}
\newcommand{\TrialCount}{N}
\newcommand{\TrialFailureIndicator}{x}
\newcommand{\TrialFailureProbability}{p_{\text{fail}}}
\newcommand{\TrialIndex}{n}
\newcommand{\TrialInterventionCount}{n_{\text{int}}}
\newcommand{\TrialLoadReversalCount}{n_{\text{rev}}}
\newcommand{\TrialPassProbability}{p_{\text{trial}}}
\newcommand{\TrialPathDistance}{d}
\newcommand{\TrialResetLatency}{T_{\text{reset}}}
\newcommand{\TrialResetTime}{t_{\text{reset}}}
\newcommand{\TrialRolloutTime}{t_{\text{rollout}}}
\newcommand{\TrialRunTime}{t_{\text{run}}}
\newcommand{\TrialSuccessProbability}{p}
\newcommand{\TriggeredWindowArrivalCount}{Q_{\text{arr}}}
\newcommand{\TrueClearance}{C_{\text{true}}}
\newcommand{\TrueLabelComponent}{y}
\newcommand{\TrueOutcome}{Y}
\newcommand{\TrueOutcomeLevel}{v}
\newcommand{\TrueReferentScore}{c_{y_j}}
\newcommand{\TruncatedDistanceSample}{d_{\mu}}
\newcommand{\TruncatedKeyApproximation}{\hat{\mathbf{K}}_r}
\newcommand{\TruncatedKeyLeftSingularMatrix}{\mathbf{U}_r}
\newcommand{\TruncatedKeyRightSingularMatrix}{\mathbf{V}_r}
\newcommand{\TruncatedKeySpectrumMatrix}{\boldsymbol{\Sigma}_r}
\newcommand{\TruncationBandVolume}{V_{\text{band}}}
\newcommand{\TruncationRank}{r}
\newcommand{\TruthInstrumentSet}{\mathcal{I}_{\text{truth}}}
\newcommand{\TsdfAccumulatedDistance}{D}
\newcommand{\TsdfAccumulatedWeight}{W}
\newcommand{\TsdfObservationWeight}{w}
\newcommand{\TsdfTruncationBand}{\mu_{\text{tsdf}}}
\newcommand{\TsdfWeightCap}{W_{\max}}
\newcommand{\TuckerCoreTensor}{\mathcal{G}}
\newcommand{\TurnAppendLength}{\Delta S_{\text{turn}}}
\newcommand{\TurnBoundaryDelay}{t_{\text{boundary}}}
\newcommand{\TurnBudgetUsedFraction}{\rho_H}
\newcommand{\TurnContext}{c}
\newcommand{\TurnContributionDeviationBound}{\sigma}
\newcommand{\TurnCovarianceBoundScale}{C}
\newcommand{\TurnCovarianceDecayRatio}{\alpha_{\text{corr}}}
\newcommand{\TurnFailureRate}{\lambda_{\text{fail}}}
\newcommand{\TurnGeneratedTokenCount}{n_{\text{gen}}}
\newcommand{\TurnHorizon}{H}
\newcommand{\TurnIndex}{t}
\newcommand{\TurnInputTokenCost}{C_{\text{in}}}
\newcommand{\TurnOffGateCurrent}{I_{g,\text{off}}}
\newcommand{\TurnOffGateResistance}{R_{g,\text{off}}}
\newcommand{\TurnOnGateResistance}{R_{g,\text{on}}}
\newcommand{\TurnOutputTokenCost}{C_{\text{out}}}
\newcommand{\TurnPayloadProbability}{q_{\text{turn}}}
\newcommand{\TurnReadCount}{r}
\newcommand{\TurnReconstructionTime}{T_{\text{recon}}}
\newcommand{\TurnReexecutionTime}{T_{\text{exec}}}
\newcommand{\TurnReward}{r}
\newcommand{\TurnSandboxCost}{C_{\text{sandbox}}}
\newcommand{\TurnStateGrowth}{s_{\text{turn}}}
\newcommand{\TurnToolFeeCost}{C_{\text{tools}}}
\newcommand{\TustinEigenvalue}{\lambda_{\text{Tustin}}}
\newcommand{\TustinTransitionMatrix}{\mathbf{A}_{\text{Tustin}}}
\newcommand{\TwinCriticReturnEstimate}{Q_{\phi_i}}
\newcommand{\TwistCoordinates}{\boldsymbol{\xi}}
\newcommand{\TwistCovarianceMatrix}{\boldsymbol{\Sigma}_{\boldsymbol{\xi}}}
\newcommand{\TwistMatrix}{\hat{\boldsymbol{\xi}}}
\newcommand{\TwistRotationAngle}{\theta_{\text{rot}}}
\newcommand{\TwistRotationCoordinates}{\boldsymbol{\omega}}
\newcommand{\TwistTranslationMatrix}{\mathbf{V}}
\newcommand{\TwistWedgeOperator}{\wedge}
\newcommand{\UnacceptedTaskMeanCost}{C_{\text{fail}}}
\newcommand{\UnassistedCompletionCount}{N_{\text{unassisted}}}
\newcommand{\UnassistedSuccessIndicator}{A}
\newcommand{\UnbiasedAngularBrakingDeceleration}{\alpha_{\text{nom}}}
\newcommand{\UnbrakedImpactForce}{F_{\text{unbraked}}}
\newcommand{\UncachedInputTokenCount}{n_{\text{in}}}
\newcommand{\UncachedPromptLength}{S_{\text{new}}}
\newcommand{\UncertainScenarioParameters}{x}
\newcommand{\UnconstrainedCallLatency}{T_{\text{free}}}
\newcommand{\UnconstrainedParseFailureRate}{p_{\text{err}}}
\newcommand{\UndampedNaturalFrequency}{\omega_n}
\newcommand{\UnfoldedConvolutionOutput}{\mathbf{Y}_{\text{col}}}
\newcommand{\UnfoldedPatchMatrix}{\mathbf{X}_{\text{col}}}
\newcommand{\UniformDistribution}{\mathcal{U}}
\newcommand{\UniformLoopTurnCost}{C_{\text{turn}}}
\newcommand{\UnitAliasMultiplier}{k}
\newcommand{\UnitImpulseFunction}{\delta}
\newcommand{\UnitQuaternion}{\mathbf{q}_{\text{quat}}}
\newcommand{\UnitQuaternionScalarComponent}{q_w}
\newcommand{\UnitQuaternionSphere}{S^3}
\newcommand{\UnitQuaternionXComponent}{q_x}
\newcommand{\UnitQuaternionYComponent}{q_y}
\newcommand{\UnitQuaternionZComponent}{q_z}
\newcommand{\UnitTemperatureProbabilityVector}{\mathbf{p}_{\tau_{\text{temp}}=1}}
\newcommand{\UnlabeledPool}{U}
\newcommand{\UnloadedTickExecutionTime}{t_{\text{unloaded}}}
\newcommand{\UnmitigatedHardwareFaultRate}{\lambda_{\text{unmitigated}}}
\newcommand{\UnmodeledCommandPathDelay}{\Delta t_{\text{bus}}}
\newcommand{\UnobservableForceOffset}{\Delta}
\newcommand{\UnobservedUnknownSpace}{\mathcal{M}_{\text{unknown}}}
\newcommand{\UnprojectionJacobian}{\mathbf{J}_{\text{unproj}}}
\newcommand{\UnrecoverableDamageCost}{C_{\text{blast}}}
\newcommand{\UnreservedStopDelay}{\delta}
\newcommand{\UnshardedLocalExecutionTime}{T_{\text{compute}}}
\newcommand{\UnsquashedLatentAction}{\mathbf{u}}
\newcommand{\UntilPrefixTime}{t''}
\newcommand{\UntrackedEvidenceHorizon}{\tau_{\text{ev,untracked}}}
\newcommand{\UpdatedErrorCovariance}{\mathbf{P}_{k|k}}
\newcommand{\UpdatedModelParameters}{\theta_{\text{new}}}
\newcommand{\UpdatedParameterSubset}{\theta_{\text{updated}}}
\newcommand{\UpdatedSoftmaxRunningMaximum}{m'}
\newcommand{\UpdatedStateEstimate}{\hat{\mathbf{x}}_{k|k}}
\newcommand{\UpperRatioClippingWidth}{\epsilon_{\text{high}}}
\newcommand{\UprightPosition}{\mathbf{p}_{\text{upright}}}
\newcommand{\UprightRange}{r}
\newcommand{\UpstreamGradientElement}{\bar{y}}
\newcommand{\UpstreamGradientVector}{\mathbf{v}}
\newcommand{\UpstreamStageLatency}{X}
\newcommand{\UsableDemonstrationYield}{Y_{\text{usable}}}
\newcommand{\UsefulAcceleratorHourCost}{C_{\text{useful}}}
\newcommand{\UsefulComputeFraction}{f_{\text{compute}}}
\newcommand{\UsefulModelFlops}{O_{\text{useful}}}
\newcommand{\UsefulStepCount}{N}
\newcommand{\UsefulTrainingTime}{T_{\text{useful}}}
\newcommand{\UserConnectionSet}{\mathcal{N}}
\newcommand{\UserSpaceSetupTime}{T_{\text{user}}}
\newcommand{\UvloThresholdVoltage}{V_{\text{UVLO}}}
\newcommand{\VacuumLightSpeed}{c}
\newcommand{\ValidCandidateRate}{p_{\text{valid}}}
\newcommand{\ValidTokenSet}{\mathcal{V}_{\text{valid}}}
\newcommand{\ValidatedMotionDuration}{T_{\text{yield}}}
\newcommand{\ValidatedProposalEvent}{e_{\text{prop}}}
\newcommand{\ValidationDataset}{\mathcal{D}_{\text{val}}}
\newcommand{\ValidationGateThreshold}{\gamma_{\text{gate}}}
\newcommand{\ValidationLoss}{\mathcal{L}_{\text{val}}}
\newcommand{\VanishingTimeOffset}{\epsilon}
\newcommand{\VariationalDistribution}{q_\phi}
\newcommand{\VariationalParameters}{\phi}
\newcommand{\VectorAngle}{\phi}
\newcommand{\VectorElementCount}{N_{\text{vec}}}
\newcommand{\Velocity}{\mathbf{v}}
\newcommand{\VelocitySaturationExponent}{\alpha}
\newcommand{\VerificationCheckCost}{C_{\text{ver}}}
\newcommand{\VerificationCheckCount}{K}
\newcommand{\VerificationPoolCapacity}{\mu_{\text{verify}}}
\newcommand{\VerificationScheduleCost}{C}
\newcommand{\VerificationTrialCount}{n_{\text{trial}}}
\newcommand{\VerificationTrialIndex}{j}
\newcommand{\VerificationTrialTime}{T_{\text{trial}}}
\newcommand{\VerifiedDemonstrationDataset}{\mathcal{D}_{\text{verified}}}
\newcommand{\VerifierFalseAcceptanceRate}{\epsilon_{\text{FA}}}
\newcommand{\VerifierFalseRejectionRate}{\epsilon_{\text{FR}}}
\newcommand{\VerifierPassProbability}{q}
\newcommand{\VerifierPrecision}{\Pi_{V}}
\newcommand{\VerifierTimeout}{T_{\text{out}}}
\newcommand{\VerifierTrueAcceptanceRate}{u}
\newcommand{\VerifierVerdict}{V}
\newcommand{\VersionSkewBound}{k_{\text{skew}}}
\newcommand{\VertexSlotTime}{d}
\newcommand{\VerticalFocalLength}{f_y}
\newcommand{\VibrationFrequency}{f_{\text{vib}}}
\newcommand{\VirtualAccelerationCommand}{\ddot{\mathbf{q}}^*}
\newcommand{\VirtualDampingMatrix}{\mathbf{D}_{\text{virt}}}
\newcommand{\VirtualPipelineStagesPerDevice}{V}
\newcommand{\ViscousDampingMatrix}{\mathbf{D}}
\newcommand{\VisionBackboneTime}{t_{\text{backbone}}}
\newcommand{\VisionTokenEmbeddings}{\mathbf{z}_{\text{vision}}}
\newcommand{\VisualConditioningEmbedding}{\mathbf{E}}
\newcommand{\VisualEncodingTime}{t_{\text{vis}}}
\newcommand{\VitImagePatch}{\mathbf{x}_p}
\newcommand{\VitPatchProjectionWeights}{\mathbf{W}_{\text{patch}}}
\newcommand{\VitPatchSize}{p_{\text{patch}}}
\newcommand{\VitPatchTokenEmbedding}{\mathbf{z}}
\newcommand{\VocabularyToken}{v}
\newcommand{\VocabularyTokenLogit}{o}
\newcommand{\VolumetricFlowRate}{\dot{V}}
\newcommand{\VoxelBlockCoordinate}{\mathbf{b}}
\newcommand{\VoxelBlockEdgeLength}{L_{\text{blk}}}
\newcommand{\VoxelCenterPosition}{\mathbf{p}_{\text{vox}}}
\newcommand{\VoxelIndex}{i}
\newcommand{\VoxelOccupancyState}{m}
\newcommand{\VoxelPitch}{r}
\newcommand{\VoxelStorageSize}{s_{\text{voxel}}}
\newcommand{\VoxelUpdateTraffic}{s_{\text{rw}}}
\newcommand{\WarmupEpochCount}{N_{\text{warmup}}}
\newcommand{\WarmupStepCount}{W}
\newcommand{\WatchdogClockFrequency}{f_{\text{wdg}}}
\newcommand{\WatchdogCounterReading}{W}
\newcommand{\WatchdogEarliestServiceTime}{T_{\text{lower}}}
\newcommand{\WatchdogLatestServiceTime}{T_{\text{upper}}}
\newcommand{\WatchdogLowerWindowCount}{W_{\text{lower}}}
\newcommand{\WatchdogReloadCount}{W_{\text{init}}}
\newcommand{\WatchdogServiceTime}{t_{\text{service}}}
\newcommand{\WatchdogToken}{T}
\newcommand{\WatchdogUpperWindowCount}{W_{\text{upper}}}
\newcommand{\WaveImpedance}{b}
\newcommand{\WeightElementStorageSize}{s_{\text{elem,W}}}
\newcommand{\WeightMatrix}{\mathbf{W}}
\newcommand{\WeightMatrixColumnCount}{n}
\newcommand{\WeightMatrixEntry}{W_{ij}}
\newcommand{\WeightMatrixRowCount}{m}
\newcommand{\WeightMemory}{M_{\text{weights}}}
\newcommand{\WeightOnlyStepTime}{t}
\newcommand{\WeightPenaltyStrength}{\lambda_{\text{reg}}}
\newcommand{\WeightQuantizationScale}{s_W}
\newcommand{\WeightRangeBound}{W_{\text{max}}}
\newcommand{\WeightVector}{\mathbf{w}}
\newcommand{\WeightedNormArgument}{\mathbf{z}}
\newcommand{\WheelAngularSpeed}{\omega}
\newcommand{\WheelDiameter}{D_{\text{wheel}}}
\newcommand{\WheelInertia}{J_{\text{wheel}}}
\newcommand{\WheelNormalLoad}{F_z}
\newcommand{\WheelRadius}{r}
\newcommand{\WheelRevolutionCount}{N_{\text{rev}}}
\newcommand{\WheelTrackWidth}{b}
\newcommand{\WhiteNoiseProcess}{\mathcal{WN}}
\newcommand{\WholeBodyDecisionVariables}{\mathbf{z}}
\newcommand{\WholeRepositoryShardGrant}{\Gamma_{b}}
\newcommand{\WidthMultiplier}{w_{\text{mult}}}
\newcommand{\WidthScalingRatio}{\beta}
\newcommand{\WilsonIntervalCenter}{\tilde{p}}
\newcommand{\WindingCoreThermalResistance}{R_{\text{th,wc}}}
\newcommand{\WindingCurrent}{I}
\newcommand{\WindingJouleHeat}{E_{\text{thermal}}}
\newcommand{\WindingLossPower}{P_{\text{loss}}}
\newcommand{\WindingTemperature}{T_{\text{winding}}}
\newcommand{\WindingTemperatureLimit}{T_{\text{limit}}}
\newcommand{\WindingTerminalVoltage}{V_{\text{terminal}}}
\newcommand{\WindingThermalCapacitance}{C_{\text{wind}}}
\newcommand{\WindowArrivalCount}{k}
\newcommand{\WindowArrivalOffset}{t}
\newcommand{\WindowSpendingLimit}{C_{\text{win}}}
\newcommand{\WithinTaskRunStandardDeviation}{\sigma_{\text{run}}}
\newcommand{\WorkedTraceProduct}{c}
\newcommand{\WorkedTraceProductAdjoint}{\bar{c}}
\newcommand{\WorkedTraceSine}{b}
\newcommand{\WorkedTraceSineAdjoint}{\bar{b}}
\newcommand{\WorkedTraceSquare}{a}
\newcommand{\WorkedTraceSquareAdjoint}{\bar{a}}
\newcommand{\WorkerBaseCommitHash}{h_{\text{base}}}
\newcommand{\WorkerCandidateCommitHash}{h_{\text{worker}}}
\newcommand{\WorkerCompletionDistribution}{F}
\newcommand{\WorkerCompletionTime}{T}
\newcommand{\WorkerCount}{N_{\text{workers}}}
\newcommand{\WorkerIndex}{k}
\newcommand{\WorkerOverheadSlope}{\gamma}
\newcommand{\WorkerTransformTime}{T_{\text{transform}}}
\newcommand{\WorkerWrittenFileCount}{w}
\newcommand{\WorkloadMeanOutputLength}{\mu}
\newcommand{\WorkloadRequestIndex}{i}
\newcommand{\WorkspaceExtentX}{L_x}
\newcommand{\WorkspaceExtentY}{L_y}
\newcommand{\WorkspaceExtentZ}{L_z}
\newcommand{\WorkspaceRestoreTime}{T_{\text{ws}}}
\newcommand{\WorkspaceVolume}{V_{\text{ws}}}
\newcommand{\WorldBaseTransform}{\mathbf{T}_{WB}}
\newcommand{\WorldBodyTransform}{\mathbf{T}_{wb}}
\newcommand{\WorldFramePoint}{\mathbf{p}_{\text{world}}}
\newcommand{\WorldLidarTransform}{\mathbf{T}_{wl}}
\newcommand{\WorldMapTransform}{\mathbf{T}_{\text{world}}^{\text{map}}}
\newcommand{\WorldPointCovariance}{\boldsymbol{\Sigma}_{\text{world}}}
\newcommand{\WorldReferenceFrame}{\mathcal{F}_W}
\newcommand{\WorldStateSpace}{\mathcal{S}}
\newcommand{\WorldToCameraRotation}{\mathbf{R}_{CW}}
\newcommand{\WorldToCameraTransform}{\mathbf{T}_{CW}}
\newcommand{\WorldToCameraTranslation}{\mathbf{t}_{CW}}
\newcommand{\WornPlantTransitionDistribution}{p_{n \gg 1}}
\newcommand{\WorseArmSuccessProbability}{p_{\text{low}}}
\newcommand{\WorstCaseExecutionTime}{C}
\newcommand{\WorstCaseInterruptLatency}{t_{\text{irq,lat}}}
\newcommand{\WorstCasePermissionCycleTime}{T_{\text{exec}}}
\newcommand{\WorstCaseResponseTime}{R}
\newcommand{\WristAngularVelocity}{\boldsymbol{\omega}_{\text{wrist}}}
\newcommand{\WristCameraEmbedding}{\mathbf{e}_{\text{wrist}}}
\newcommand{\WristLinearVelocity}{\mathbf{v}_{\text{wrist}}}
\newcommand{\WristObjectTransform}{\mathbf{T}_{\text{wrist} \leftarrow \text{object}}}
\newcommand{\WristSkewDisplacement}{\Delta \mathbf{p}_{\text{skew}}}
\newcommand{\XAxisAngularRate}{\omega_x}
\newcommand{\XAxisRotationCoordinate}{\omega_x}
\newcommand{\XForceCeiling}{F_x}
\newcommand{\XPositionErrorEnvelope}{e_x}
\newcommand{\XTaskToleranceSemiAxis}{r_x}
\newcommand{\XTorqueCeiling}{\tau_x}
\newcommand{\YAxisAngularRate}{\omega_y}
\newcommand{\YAxisRotationCoordinate}{\omega_y}
\newcommand{\YForceCeiling}{F_y}
\newcommand{\YPositionErrorEnvelope}{e_y}
\newcommand{\YTaskToleranceSemiAxis}{r_y}
\newcommand{\YTorqueCeiling}{\tau_y}
\newcommand{\YawRate}{\omega_z}
\newcommand{\YoshikawaManipulability}{w}
\newcommand{\ZAxisRotationCoordinate}{\omega_z}
\newcommand{\ZForceCeiling}{F_z}
\newcommand{\ZPositionErrorEnvelope}{e_z}
\newcommand{\ZTaskToleranceSemiAxis}{r_z}
\newcommand{\ZTorqueCeiling}{\tau_z}
\newcommand{\ZTransformVariable}{z}
\newcommand{\ZeroEntryIndicator}{\mathbf{1}_{\{(\mathbf{W}_{\text{sparse}})_{ij} = 0\}}}
\newcommand{\ZeroFailureTrialCount}{n}
\newcommand{\ZeroFailureUpperConfidenceLimit}{p_{\text{fail, upper}}^{95\%}}
\newcommand{\ZeroMatrix}{\mathbf{0}}
\newcommand{\ZeroMomentPoint}{\mathbf{p}_{\text{ZMP}}}
\newcommand{\ZeroVector}{\mathbf{0}}
\newcommand{\ZohHoldTravel}{d_{\text{ZOH}}}
\newcommand{\ZohPhaseShift}{\phi_{\text{ZOH}}}
\newcommand{\ZohTransportDelay}{\tau_{\text{ZOH}}}
\newcommand{\AuthorityLevels}{\AuthorityExposureLevel}
\newcommand{\BreakEvenTaskVolume}{\BreakEvenTaskCount}
\newcommand{\PertokenPricesCache}{\CachedInputTokenPrice}
\newcommand{\ContentionAndCoherencyCoefficientsTwo}{\CoherencyCoefficient}
\newcommand{\CoherencyContentionCoefficient}{\CoherencyCoefficient}
\newcommand{\TaskDeadline}{\CompletionDeadline}
\newcommand{\Deadline}{\CompletionDeadline}
\newcommand{\Confidentiality}{\ConfidentialityLabel}
\newcommand{\ContentionAndCoherencyCoefficients}{\ContentionCoefficient}
\newcommand{\CostPerAcceptedTaskEff}{\CostPerAcceptedTask}
\newcommand{\DuplicateeffectProbability}{\DuplicateEffectProbability}
\newcommand{\EstimatedAdvantageK}{\EstimatedHistoryAdvantage}
\newcommand{\EstimatedValueK}{\EstimatedRemainingReturn}
\newcommand{\ExpectedIrreversibleLossA}{\ExpectedIrreversibleLoss}
\newcommand{\PertokenPricesIn}{\InputTokenPrice}
\newcommand{\CohensKappa}{\InterAnnotatorAgreement}
\newcommand{\KvBlockSizeBlk}{\KvBlockSize}
\newcommand{\MaskedFinetuningLossSft}{\MaskedFinetuningLoss}
\newcommand{\ValidityIntervalOfAMemoryEntryBirth}{\MemoryEntryBirthGeneration}
\newcommand{\ValidityIntervalOfAMemoryEntryDeath}{\MemoryEntryDeathGeneration}
\newcommand{\MemoryHeldDuringAWait}{\MemoryHoldDuringWait}
\newcommand{\OptimalCheckpointIntervalCkpt}{\OptimalCheckpointInterval}
\newcommand{\PertokenPricesOut}{\OutputTokenPrice}
\newcommand{\PertokenDecodeTime}{\PerTokenDecodeTime}
\newcommand{\TokenLossMask}{\PositionLossMask}
\newcommand{\LossMaskT}{\PositionLossMask}
\newcommand{\ValidityIntervalOfAMemoryEntryQ}{\QueryWorkspaceGeneration}
\newcommand{\RequestAndReplylossProbabilitiesTwo}{\ReplyLossProbability}
\newcommand{\RequestAndReplylossProbabilities}{\RequestLossProbability}
\newcommand{\EnvironmentStateK}{\RolloutEnvironmentState}
\newcommand{\StalesupportRate}{\StaleSupportRate}
\newcommand{\StateLevels}{\StateExposureLevel}
\newcommand{\GoalContract}{\TaskContractGoal}
\newcommand{\Environment}{\TaskEnvironment}
\newcommand{\Vocabulary}{\TokenVocabulary}
\newcommand{\ActionProposal}{\TrajectoryAction}
\newcommand{\ConcurrentTrajectoriesTwo}{\TrajectoryAdmissionRate}
\newcommand{\ActionObservation}{\TrajectoryObservation}
\newcommand{\Observation}{\TrajectoryObservation}
\newcommand{\StateAtTurn}{\TrajectoryState}
\newcommand{\PerturnAppend}{\TurnAppendLength}
\newcommand{\Context}{\TurnContext}
\newcommand{\Horizon}{\TurnHorizon}
\newcommand{\VerifierFalseacceptance}{\VerifierFalseAcceptanceRate}
\newcommand{\VerifierFalseacceptanceFr}{\VerifierFalseRejectionRate}
\newcommand{\WorkerCountWorkers}{\WorkerCount}
\newcommand{\AllocationHoldTime}{\AllocatedWallTime}
\newcommand{\CheckpointIntervalCkpt}{\CheckpointInterval}
\newcommand{\AcceleratorsPerNodeNodes}{\ClusterNodeCount}
\newcommand{\CommunicationcomputationRatio}{\CommunicationComputeRatio}
\newcommand{\PercomponentFailureRate}{\ComponentFailureRate}
\newcommand{\Correlation}{\CorrelationCoefficient}
\newcommand{\DataparallelDegreeDp}{\DataParallelDegree}
\newcommand{\NumberOfDevices}{\DeviceCount}
\newcommand{\TypeIAndTypeIiErrorRatesStat}{\HypothesisTestFalseNegativeRate}
\newcommand{\TypeIAndTypeIiErrorRatesSig}{\HypothesisTestSignificanceLevel}
\newcommand{\DollarCostInfer}{\InferenceCost}
\newcommand{\KvcacheBytesPerToken}{\KvCacheBytesPerToken}
\newcommand{\KvcacheMemory}{\KvCacheMemory}
\newcommand{\CrossoverPoint}{\LatencyBandwidthCrossoverSize}
\newcommand{\LoggpLongmessageTime}{\LoggpLongMessageTime}
\newcommand{\LogploggpNetworkLatency}{\LogpNetworkLatency}
\newcommand{\LongmessageGapPerByte}{\LongMessageGapPerByte}
\newcommand{\MeanTimeBetweenFailuresThree}{\MeanTimeBetweenFailures}
\newcommand{\PermessageLatency}{\MessageStartupLatency}
\newcommand{\NdeviceTime}{\MultiDeviceRunTime}
\newcommand{\PipelineparallelDegreePp}{\PipelineParallelDegree}
\newcommand{\MlProductivityGoodputFactorsProgram}{\ProgramGoodput}
\newcommand{\ReceiverOverheadRecv}{\ReceiverOverhead}
\newcommand{\CollectiveCompletionTimeRing}{\RingAllReduceCompletionTime}
\newcommand{\RingtreeCrossoverPayload}{\RingTreeCrossoverPayload}
\newcommand{\MlProductivityGoodputFactorsRuntime}{\RuntimeGoodput}
\newcommand{\GoodputRatio}{\RuntimeGoodput}
\newcommand{\ScalingExponentScale}{\ScalingExponent}
\newcommand{\MlProductivityGoodputFactorsScheduling}{\SchedulingGoodput}
\newcommand{\SingledeviceTimeOne}{\SingleDeviceRunTime}
\newcommand{\ReliabilityFunctionSystem}{\SystemReliability}
\newcommand{\TensorparallelDegreeTp}{\TensorParallelDegree}
\newcommand{\SmallConstant}{\ToleratedFailureProbability}
\newcommand{\DollarCostTrain}{\TrainingCost}
\newcommand{\CollectiveCompletionTimeTree}{\TreeAllReduceCompletionTime}
\newcommand{\UsefulComputetimeFraction}{\UsefulComputeFraction}
\newcommand{\AccuracyAtTime}{\AccuracyAfterDeployment}
\newcommand{\NumberOfAttentionHeads}{\AttentionHeadCount}
\newcommand{\Distribution}{\InputDistribution}
\newcommand{\NumberOfKeyValueHeads}{\KvHeadCount}
\newcommand{\NumberOfKeyvalueHeadsKv}{\KvHeadCount}
\newcommand{\NumberOfLayers}{\LayerCount}
\newcommand{\LayerInputAndOutputWidths}{\LayerInputWidth}
\newcommand{\LayerInputAndOutputWidthsTwo}{\LayerOutputWidth}
\newcommand{\Gradient}{\LossGradient}
\newcommand{\TrainingDistributionZero}{\TrainingDistribution}
\newcommand{\AcceleratorCountGpu}{\AcceleratorCount}
\newcommand{\ActivationMemoryActivations}{\ActivationMemory}
\newcommand{\BatchServiceTimeSvc}{\BatchServiceTime}
\newcommand{\EnergyPerOperationCompute}{\EnergyPerOperation}
\newcommand{\GradientMemoryGradients}{\GradientMemory}
\newcommand{\IronlawTermTimesCompute}{\IronLawComputeTime}
\newcommand{\SingleDeviceComputeTime}{\IronLawComputeTime}
\newcommand{\IronlawTermTimesMemory}{\IronLawMemoryTime}
\newcommand{\LossscaleFactor}{\LossScaleFactor}
\newcommand{\OptimizerstateMemory}{\OptimizerStateMemory}
\newcommand{\RequestTimeInSystemLat}{\RequestTimeInSystem}
\newcommand{\StoragePricePerByteTime}{\StorageCapacityPrice}
\newcommand{\WeightMemoryWeights}{\WeightMemory}
\newcommand{\WindingAndAmbientTemperatureTwo}{\AmbientTemperature}
\newcommand{\BackemfVoltageBemf}{\BackEmfVoltage}
\newcommand{\CoordinateReferenceFramesB}{\BodyReferenceFrame}
\newcommand{\CameraframeThreedCoordinate}{\CameraFramePoint}
\newcommand{\CartesianThreedPosition}{\CartesianPosition}
\newcommand{\CommandTransportTimeBus}{\CommandTransportTime}
\newcommand{\ContactForceVectorK}{\ContactPointForce}
\newcommand{\ContactPointJacobianK}{\ContactPointJacobian}
\newcommand{\ContinuousPeakCurrent}{\ContinuousCurrent}
\newcommand{\CredibleDecelerationBrake}{\CredibleBrakingDeceleration}
\newcommand{\OpenloopCrossoverFrequency}{\CrossoverFrequency}
\newcommand{\PhaseLagDegradation}{\DelayPhaseLag}
\newcommand{\DiffusionScheduleParameterK}{\DiffusionCumulativeSchedule}
\newcommand{\DispatchtoadmissionIntervalDa}{\DispatchAdmissionInterval}
\newcommand{\EmittedTokenCountOut}{\EmittedTokenCount}
\newcommand{\FundamentalAndEssentialMatricesTwo}{\EssentialMatrix}
\newcommand{\ForwardinvariantSafeSet}{\ForwardInvariantSafeSet}
\newcommand{\FreespaceDepth}{\FreeSpaceDepth}
\newcommand{\FundamentalAndEssentialMatrices}{\FundamentalMatrix}
\newcommand{\TransmissionEfficiencyGear}{\GearboxTransmissionEfficiency}
\newcommand{\HardwareAndCommoncauseRateOther}{\HardwareCommonCauseRate}
\newcommand{\ContinuousPeakTorqueHold}{\HoldingTorque}
\newcommand{\OptimalInertiamatchingRatio}{\InertiaMatchingRatio}
\newcommand{\IntentleaseExpiryIntentexp}{\IntentLeaseExpiry}
\newcommand{\LatentStyleStateEmbedding}{\LatentStyleVariable}
\newcommand{\LinearBarrierDecayRateCbf}{\LinearBarrierDecayRate}
\newcommand{\Momentum}{\LinearMomentum}
\newcommand{\RotorAndLoadInertiaTwo}{\LoadInertia}
\newcommand{\LqrGainAndWeights}{\LqrFeedbackGain}
\newcommand{\CenterOfMass}{\MassCenterPosition}
\newcommand{\TorqueAndBackemfConstants}{\MotorTorqueConstant}
\newcommand{\NoisePredictionNetworkTwo}{\NoisedActionChunk}
\newcommand{\ObservabilityMatricesNl}{\NonlinearObservationSpace}
\newcommand{\ObservabilityMatrices}{\ObservabilityMatrix}
\newcommand{\ContinuousPeakCurrentTwo}{\PeakCurrent}
\newcommand{\ContinuousPeakTorque}{\PeakTorque}
\newcommand{\PermissionloopPeriodTick}{\PermissionLoopPeriod}
\newcommand{\PhaseInductanceAndResistance}{\PhaseInductance}
\newcommand{\PhaseInductanceAndResistanceTwo}{\PhaseResistance}
\newcommand{\InitialAndCeilingError}{\PositionErrorCeiling}
\newcommand{\RenewaljitterAllowance}{\RenewalJitterAllowance}
\newcommand{\ResidentStopDistanceSuffix}{\ResidentStopDistance}
\newcommand{\CoefficientOfRestitution}{\RestitutionCoefficient}
\newcommand{\RigidtransformTranslation}{\RigidTransformTranslation}
\newcommand{\RotorAndLoadInertia}{\RotorInertia}
\newcommand{\SamplingPeriodAndRate}{\SamplingPeriod}
\newcommand{\SensorLeverarmVector}{\SensorLeverArm}
\newcommand{\SequentialLoglikelihoodRatioM}{\SequentialLogLikelihoodRatio}
\newcommand{\SinglestepImitationError}{\SingleStepImitationError}
\newcommand{\SprtBoundariesLo}{\SprtLowerBoundary}
\newcommand{\SprtBoundariesUp}{\SprtUpperBoundary}
\newcommand{\LinearStatespaceMatrices}{\StateSpaceInputMatrix}
\newcommand{\LinearStatespaceMatricesSys}{\StateSpaceSystemMatrix}
\newcommand{\PertrialProbabilitiesTarget}{\TargetTrialSuccessProbability}
\newcommand{\TorqueproducingCurrent}{\TorqueProducingCurrent}
\newcommand{\TrackingerrorBound}{\TrackingErrorBound}
\newcommand{\PertrialProbabilitiesFail}{\TrialFailureProbability}
\newcommand{\TsdfAccumulatedVolumeVox}{\TsdfAccumulatedWeight}
\newcommand{\VirtualDampingAndStiffness}{\VirtualDampingMatrix}
\newcommand{\Radius}{\WheelRadius}
\newcommand{\WindingAndAmbientTemperature}{\WindingTemperature}
\newcommand{\CoordinateReferenceFramesW}{\WorldReferenceFrame}
\newcommand{\ZerofailureTrialCount}{\ZeroFailureTrialCount}
\newcommand{\ZeroMomentPointZmp}{\ZeroMomentPoint}
\newcommand{\Glyph}[1]{#1}
$$
Algorithm Foundations
A profile showing low utilization is often misdiagnosed as a hardware limit when the cause is algorithmic: a matrix multiply shape that underfills matrix arithmetic units, a layout that breaks contiguity, or activation memory held for backpropagation. This appendix collects the computational complexity models, memory footprint derivations, numerical-stability rules, and proofs that the book’s performance chapters lean on. With them, readers can evaluate algorithmic trade-offs before committing code to accelerators. It assumes familiarity with linear algebra and with the iron law introduced early in the book.
How to Use This Appendix
This appendix is designed as a reference. Reach for it when translating a profiler symptom (“slow matmul,” “shape mismatch,” “OOM during training”) into a concrete computational or memory cause. Each symptom or need maps to one section (table 1 ), and conventions throughout follow the book-wide notation (for example, \(\BatchSize\) is reserved for batch size and \(\Bandwidth\) denotes bandwidth). Every section names the chapter that teaches its concept in context; the chapter carries the argument, and this appendix carries the derivation or the reference formula.
Neural networks turn linear algebra into learned behavior. Matrices transform activations, tensor layouts determine how data move through memory, and backpropagation carries error signals through the resulting computation. These foundations support the deep learning treatment in Neural Computation , the framework internals in ML Frameworks , and the training strategies in Model Training .
Linear Algebra
Frameworks such as PyTorch hide raw linear algebra behind single function calls, yet changing a layer’s width or a serving request’s batch size can shift the underlying matrix operations from compute-bound execution to a bandwidth-bound stall without altering a line of model logic. While Numerical Representations establishes how individual numbers are represented in bits, the primitives below govern how those numbers are combined into contractions, inner products, and dense or sparse matrix multiplies.
Systems Perspective 1.1: Why this matters Many dense neural networks, especially transformers and large convolutional neural networks, spend most of their compute in matrix multiplication or GEMM-like kernels. A self-attention block executes query, key, value, and output projection GEMMs alongside two attention-matrix products for scores and weighted values, and the layer’s feed-forward block adds two or three more. Because those kernels dominate execution, GEMM performance characteristics explain why batch size governs throughput, why aligned layer dimensions run faster than unaligned ones, and whether a dense workload will be compute bound or bandwidth bound before any profiler trace runs.
Tensor operations and einsum notation
Tensor operations in deep learning contract across batch, head, sequence, and hidden dimensions at once. Einstein summation notation writes those contractions as a single index string rather than a chain of nested loops and transposes (implemented as torch.einsum in PyTorch and np.einsum in NumPy). Matrix multiplication \(\GemmOutputMatrix= \GemmLeftOperand\GemmRightOperand\) becomes: \[ \GemmOutputEntry = \sum_k \GemmLeftOperandEntry \GemmRightOperandEntry \]
1 Einstein summation convention : Repeated indices in a product are implicitly summed over, eliminating explicit summation signs. ML frameworks adopted the convention because it concisely expresses arbitrary tensor contractions in a single string.
In einsum notation, this is ik,kj->ij. The same notation handles batched multi-head attention, bhid,bhjd->bhij (batch \(\BatchAxisLabel\) , head \(\HeadAxisLabel\) , query sequence \(\QueryAxisLabel\) , key sequence \(\KeyAxisLabel\) , and head dimension \(\HeadDimensionAxisLabel\) ). The head dimension \(\HeadDimensionAxisLabel\) appears in both inputs but not in the output, so it is the index that is summed.
The dot product as similarity
Summing over that shared head dimension \(\HeadDimensionAxisLabel\) for a single query vector and a single key vector is a dot product, the primitive that scores how closely two token embeddings or feature vectors align. The sum \(\InnerProductLeftVector\cdot \InnerProductRightVector= \sum \InnerProductLeftComponent_i \InnerProductRightComponent_i\) grows when the vectors point in the same direction and vanishes when they are orthogonal because it equals \(\|\InnerProductLeftVector\| \|\InnerProductRightVector\| \cos \VectorAngle\) . For nonzero vectors, its sign distinguishes acute, right, and obtuse angles, while its magnitude scales with both vector norms.
In attention mechanisms, query (\(\AttentionQueryMatrix\) ) and key (\(\AttentionKeyMatrix\) ) vectors are dot-produced to compute a similarity score that determines how much each token attends to every other token. The resulting attention weights are then used to form a weighted combination of value (\(\AttentionValuesMatrix\) ) vectors, so every token can draw on every other token. Attention: Dynamic Processing develops attention itself, including the cost of computing one score for every query-key pair.
General matrix multiply (GEMM)
Evaluating those dot products across every query-key pair at once, or projecting a batch of activations through a dense layer, packs individual inner products into a general matrix multiply (GEMM). Whether that GEMM saturates an accelerator’s Tensor Cores or stalls on memory bandwidth depends on its three dimensions: for matrices of size \(\GemmRowDimension{\times}\GemmInnerDimension\) and \(\GemmInnerDimension{\times}\GemmColumnDimension\) , a GEMM performs \(2\GemmRowDimension \GemmColumnDimension \GemmInnerDimension\) floating-point operations (counting multiply-accumulate as two operations).
2 General matrix multiply (GEMM) : The BLAS (Basic Linear Algebra Subprograms) family began with vector routines standardized in 1979 (Lawson et al. 1979 ) ; GEMM was standardized later as a Level 3 routine (Dongarra et al. 1988 ) . The “GE” prefix stands for “general,” as opposed to symmetric or triangular forms. GEMM computes \(\GemmOutputMatrix= \GemmProductScale\GemmLeftOperand\GemmRightOperand+ \GemmAccumulatorScale\GemmOutputMatrix\) and is a performance-critical routine in deep learning. Matrix operations explains how GEMM shapes determine training throughput.
Lawson, Charles L., Richard J. Hanson, David R. Kincaid, and Fred T. Krogh. 1979. “Basic Linear Algebra Subprograms for Fortran Usage.” ACM Transactions on Mathematical Software 5 (3): 308–23. https://doi.org/10.1145/355841.355847.
Dongarra, Jack J., Jeremy Du Croz, Sven Hammarling, and Richard J. Hanson. 1988. “An Extended Set of FORTRAN Basic Linear Algebra Subprograms.” ACM Transactions on Mathematical Software 14 (1): 1–17. https://doi.org/10.1145/42288.42291.
The arithmetic intensity of GEMM scales linearly with matrix dimension. For square \(\SquareGemmDimension{\times}\SquareGemmDimension\) matrices in FP16 (2 bytes/element), the ideal \(\GemmAccumulatorScale=0\) bound reads \(\GemmLeftOperand\) and \(\GemmRightOperand\) once and writes \(\GemmOutputMatrix\) once: \[\text{Intensity} = \frac{\Operations}{\DataVolume} = \frac{2\SquareGemmDimension^3}{3\SquareGemmDimension^2 \times 2} = \frac{\SquareGemmDimension}{3}\text{ FLOP/byte}\]
Reading the old \(\GemmOutputMatrix\) when \(\GemmAccumulatorScale\ne 0\) changes the intensity to \(\SquareGemmDimension/4\) FLOP/byte. Three consequences follow for GEMM execution:
Larger batches can improve efficiency : Batching increases effective matrix dimensions when it forms larger GEMMs or enables reuse; merely queuing independent small GEMMs does not raise intensity.
Aligned dimensions help : Hardware Tensor Cores are optimized for precision- and architecture-specific tile multiples. Dimensions that align with these multiples avoid padding overhead and improve kernel efficiency, but they do not need to be powers of two.
Small matrices are inefficient : A square GEMM with \(\SquareGemmDimension =\) 64 has intensity 64/3 ≈ 21.3 FLOP/byte, well below the ridge point of the book’s reference accelerator, the H100 (295.2 FLOP/byte). Its roofline cap is ~7.2 percent of peak; launch and tiling overhead can lower realized throughput. Performance Bounds derives the ridge point and the compute-bound and bandwidth-bound regimes on either side of it, which is the comparison each of these consequences relies on.
Operation cost reference
Each common layer type reduces to the GEMMs and elementwise operations above, so its parameter count and forward-pass FLOPs follow from its shapes (table 2 ). Given layer dimensions and input shapes, the formulas give first-order estimates of model size and compute before hardware is provisioned. The attention row is the one to watch. Sequence length contributes an \(\SequenceLength^2\) term, while hidden dimension contributes \(\HiddenDimension^2\) projection work, so long-context models can shift the dominant cost without changing the parameter count.
The formulas in table 2 specify what each layer computes and how many operations it performs. Expressing those computations in code raises a second question: how frameworks represent multidimensional arrays in flat memory without copying data unnecessarily.
Tensor Programming Primitives
Tensor programming answers that question as the abstraction layer that translates linear algebra into array manipulations on hardware. When its flat-memory representation is misunderstood, code fails in three characteristic ways: a shape mismatch crashes the run, a transposed tensor loses contiguity and runs at a small fraction of peak throughput, or an unintended broadcast silently allocates gigabytes of memory.
Shapes, strides, and memory layout
Transposing or reshaping a gigabyte matrix in PyTorch returns almost instantly because no elements move in memory; instead, frameworks represent a tensor as a view over a flat storage buffer, described by shape, stride, dtype, and offset metadata rather than as a multidimensional array of pointers. While its shape specifies the logical dimensions of the tensor (for example, (3, 4)), its stride defines how many elements to skip in storage to advance one step along each dimension, and only contiguous tensors store their logical elements in a single adjacent block.
Because operations like transpose() or view() rewrite only those strides in \(\mathcal{O}(1)\) time, they can leave a tensor noncontiguous and cause kernels that require contiguous data to fail. In such cases, calling contiguous() on a tensor of \(\TensorElementCount\) elements forces an \(\mathcal{O}(\TensorElementCount)\) memory copy that can dominate runtime if triggered repeatedly inside a loop.
The order of the strides is the tensor’s memory layout. Row-major and column-major layouts of the same matrix differ only in which dimension has stride 1. That choice affects cache efficiency, because iterating along the stride-1 dimension touches contiguous memory locations, which is much faster than strided access.
A common optimization pattern is to materialize a transposed tensor once before repeated operations to ensure contiguous access in the hot loop. The one-time copy cost is amortized across many subsequent operations. Rank, layout, and data type introduces strides and layouts in the framework that manages them, and Memory-efficient tensor layouts shows how the layout choice (channels-last versus channels-first) changes accelerator throughput for convolutions.
Broadcasting
Zero-copy stride manipulation also powers broadcasting , the rule that lets arithmetic operators combine tensors of different shapes without materializing duplicate copies of the smaller input. Frameworks compare dimensions from right to left and treat two dimensions as compatible when they are equal or when one of them is 1. A singleton dimension is then stretched virtually by setting its stride to zero. Yet an unintended singleton alignment, such as adding a \((\BatchSize, 1)\) column vector of predictions to a \((\BatchSize,)\) row vector of targets, silently allocates a \((\BatchSize, \BatchSize)\) output matrix that can exhaust memory or corrupt a loss calculation.
Adding a \((3, 1)\) column tensor (\(\BroadcastColumnTensor\) ) to a \((1, 4)\) row tensor (\(\BroadcastRowTensor\) ) expands both virtually across their complementary singleton dimensions and generates a \((3, 4)\) matrix of pairwise sums \(\BroadcastColumnElement_i + \BroadcastRowElement_j\) (figure 1 ). Dashed cell boundaries mark result elements whose operands are read through stride-0 views, so neither input is copied. Only the \((3, 4)\) output is allocated, and hardware repeatedly accesses identical input buffer addresses.
Consider a concrete case: tensor A has shape (32, 1, 64) and tensor B has shape (1, 128, 64). Comparing dimensions right to left, 64 matches 64, then 1 stretches to 128, then 1 stretches to 32, yielding result shape (32, 128, 64). Writing out the expanded shape before running catches silent logic bugs that accidentally allocate a large tensor (for example, a (Batch, Batch) matrix instead of an element-wise (Batch) vector).
Shapes, strides, and broadcasting govern how tensors flow through a model’s forward pass. Training adds a second requirement, computing how much each parameter contributed to the error. Backpropagation meets that requirement and imposes the memory costs quantified in the training-memory decomposition below.
Mechanics of Learning
Training a neural network takes roughly three times the compute of a forward pass and holds gigabytes of intermediate activations in memory until the backward sweep consumes them. The chain rule and reverse-mode automatic differentiation create both costs by saving forward intermediates to compute every parameter gradient in one backward sweep, while the resulting computational graph exposes where compilers can fuse memory-bound operations and where reduced-precision exponentials at the loss must be stabilized.
Systems Perspective 1.2: Why this matters When training fails (loss goes to NaN, gradients explode, or memory runs out), understanding what backpropagation actually does is essential for diagnosing the problem. The backward graph supplies the mental model for reasoning about gradient flow and memory usage during training.
The chain rule and automatic differentiation
Updating a model with \(\Parameters\) parameters requires the derivative of the scalar loss with respect to every weight, and perturbing one parameter at a time would cost \(\Parameters\) forward passes per training step. Factoring the network as a composition of layers avoids that blowup. For a composed function \(\ComposedFunctionOutput= \LayerFunction(\InnerLayerFunction(\ComposedFunctionInput))\) , the derivative is \(\frac{d\ComposedFunctionOutput}{d\ComposedFunctionInput} = \frac{d\ComposedFunctionOutput}{d\InnerLayerFunction} \cdot \frac{d\InnerLayerFunction}{d\ComposedFunctionInput}\) , and for a three-layer network \(\ComposedFunctionOutput= \LayerFunction_3(\LayerFunction_2(\LayerFunction_1(\ComposedFunctionInput)))\) , the chain rule extends to: \[ \frac{\partial \ComposedFunctionOutput}{\partial \ComposedFunctionInput} = \frac{\partial \LayerFunction_3}{\partial \LayerFunction_2} \cdot \frac{\partial \LayerFunction_2}{\partial \LayerFunction_1} \cdot \frac{\partial \LayerFunction_1}{\partial \ComposedFunctionInput} \]
Each factor in this product is a local derivative, computed at one layer using only that layer’s inputs and outputs. This locality keeps the bookkeeping cheap: the entire network never needs to be differentiated as a monolithic function. Instead, each layer computes its own local derivative during the backward pass and multiplies it by the gradient flowing in from the layer above.
Modern frameworks use reverse-mode automatic differentiation, which computes gradients for all \(\Parameters\) parameters in a single backward pass. Starting from the output and working backward (reverse mode) requires one pass regardless of the number of parameters, whereas starting from each input and working forward (forward mode) would require \(\Parameters\) passes, one per parameter. This is why a training step is a small constant multiple of inference, commonly about 2–3\(\times\) a forward pass for dense networks, rather than \(\Parameters\) passes. Forward and reverse mode shows how frameworks implement both modes and why training uses reverse mode.
The backpropagation algorithm
Backpropagation implements the chain rule efficiently through two passes: forward to compute outputs, backward to compute gradients. The gradient edges retrace forward dependencies, meaning each backward step requires intermediate activations retained from the corresponding forward operation. Figure 2 traces these dual dataflow passes across a two-layer network. Solid gray arrows stage forward activations (\(\InputFeatureVector\to \HiddenActivation\to \PredictedOutput\) ) through weight parameters \(\WeightMatrix_1\) and \(\WeightMatrix_2\) to evaluate loss \(\LossFunction\) . Curved dashed red arrows propagate intermediate adjoints (\(\frac{\partial \LossFunction}{\partial \PredictedOutput}, \frac{\partial \LossFunction}{\partial \HiddenActivation}, \frac{\partial \LossFunction}{\partial \InputFeatureVector}\) ) in reverse order.
3 Backpropagation : Short for “backward propagation of errors.” The algorithm was independently discovered multiple times, by Werbos (1974 ) and Linnainmaa (1970 ) for reverse-mode differentiation and by Rumelhart et al. (1986 ) for neural network training. Its key insight is that computing gradients for all parameters requires one backward pass through the graph rather than one pass per parameter. Section 1.4.1 derives the constant-factor work bound and a representative dense-layer cost.
Werbos, Paul. 1974. “Beyond Regression: New Tools for Prediction and Analysis in the Behavioral Sciences.” PhD thesis, Harvard University.
Linnainmaa, Seppo. 1970. “The Representation of the Cumulative Rounding Error of an Algorithm as a Taylor Expansion of the Local Rounding Errors.” Master's thesis, University of Helsinki.
Rumelhart, David E., Geoffrey E. Hinton, and Ronald J. Williams. 1986. “Learning Representations by Back-Propagating Errors.” Nature 323 (6088): 533–36. https://doi.org/10.1038/323533a0.
Forward pass
Using row-vector activations, omitting biases, and retaining intermediate activations for backward execution, computation begins at input \(\InputFeatureVector\) . Multiplying \(\InputFeatureVector\) by weight matrix \(\WeightMatrix_1\) yields hidden activation \(\HiddenActivation\) , which the execution runtime caches for backward differentiation. Multiplying \(\HiddenActivation\) by \(\WeightMatrix_2\) produces network output \(\PredictedOutput\) , which is similarly cached. Finally, comparing \(\PredictedOutput\) to the target label produces scalar loss \(\LossFunction\) .
At this point, forward evaluation is complete, and memory holds input \(\InputFeatureVector\) , cached activation \(\HiddenActivation\) , cached prediction \(\PredictedOutput\) , and loss \(\LossFunction\) . For large models, these retained activation tensors frequently dominate overall memory consumption.
Backward pass
Gradient propagation begins backward from scalar loss \(\LossFunction\) . The loss function evaluates \(\frac{\partial \LossFunction}{\partial \PredictedOutput}\) , the error gradient with respect to the network prediction, which starts the backward pass.
Because \(\PredictedOutput = \HiddenActivation\cdot \WeightMatrix_2\) , the matrix chain rule yields two gradients at this layer: \[ \frac{\partial \LossFunction}{\partial \WeightMatrix_2} = \HiddenActivation^T \cdot \frac{\partial \LossFunction}{\partial \PredictedOutput} \qquad \text{(weight gradient—used to update } \WeightMatrix_2\text{)} \] \[ \frac{\partial \LossFunction}{\partial \HiddenActivation} = \frac{\partial \LossFunction}{\partial \PredictedOutput} \cdot \WeightMatrix_2^T \qquad \text{(input gradient—passed backward to the previous layer)} \]
Computing \(\frac{\partial \LossFunction}{\partial \WeightMatrix_2}\) requires cached activation \(\HiddenActivation\) from the forward pass. Activations must remain resident in memory because every layer’s weight gradient depends directly on that layer’s input.
Continuing backward to the first layer, the linear relationship \(\HiddenActivation= \InputFeatureVector\cdot \WeightMatrix_1\) produces: \[ \frac{\partial \LossFunction}{\partial \WeightMatrix_1} = \InputFeatureVector^T \cdot \frac{\partial \LossFunction}{\partial \HiddenActivation} \]
Each backward step requires two operands: the gradient flowing in from downstream layers \(\left(\frac{\partial \LossFunction}{\partial \HiddenActivation}\right)\) and that layer’s cached input (\(\InputFeatureVector\) ). Consequently, the backward pass requires roughly 2\(\times\) the forward pass FLOPs: each layer executes two matrix multiplications (one for the parameter gradient, one for the upstream activation gradient) rather than one. Gradient computation and backpropagation teaches the algorithm step by step on a running network. The cached inputs that every backward step needs are the reason training memory exceeds model size, which the next section quantifies.
Training memory
Because the backward pass holds those intermediate activations alongside weights, gradients, and optimizer buffers, training memory is the sum of four components rather than model size alone: \[ \TotalMemoryFootprint = \WeightMemory + \GradientMemory + \OptimizerStateMemory + \ActivationMemory \]
For a standard Adaptive Moment Estimation (Adam) optimizer (Kingma and Ba 2015 ) in mixed precision (Micikevicius et al. 2018 ) :
Kingma, Diederik P., and Jimmy Ba. 2015. “Adam: A Method for Stochastic Optimization.” 3rd International Conference on Learning Representations (ICLR) .
Micikevicius, Paulius, Sharan Narang, Jonah Alben, Gregory Diamos, Erich Elsen, David Garcia, Boris Ginsburg, et al. 2018. “Mixed Precision Training.” International Conference on Learning Representations (ICLR) .
Weights : 2 bytes (FP16/BF16) or 4 bytes (FP32).
Gradients : Same size as weights.
Optimizer State : Adam moments require 8 bytes per parameter; an FP32 master copy adds another 4 bytes, giving 8–12 bytes per parameter.
Activations : Activations typically dominate the dynamic memory footprint during training. A recomputation- or tiled-attention-friendly estimate scales as \(\mathcal{O}(\BatchSize\times \SequenceLength\times \LayerCount \times \HiddenDimension)\) ; a full no-recompute attention implementation also materializes attention-score tensors that scale with \(\SequenceLength^2\) .
To see how these four components interact on a single accelerator, consider a concrete language model. Once the static model state is allocated, the remaining device capacity sets a hard ceiling on the batch size that can run without recomputation.
Napkin Math 1.1: Worked example: GPT-2 (1.5B) training memory The model : GPT-2 XL has
\(\Parameters=\) \(1.5 \times 10^{9}\) parameters, 48 layers, hidden dimension
\(\HiddenDimension=\) 1600.
Model state (fixed per step) :
Weights (BF16) : \(1.5 \times 10^{9}\) \(\times\) 2 bytes = 3 GB
Gradients (BF16) : \(1.5 \times 10^{9}\) \(\times\) 2 bytes = 3 GB
Optimizer (FP32 master + momentum + variance) : \(1.5 \times 10^{9}\) \(\times\) 12 bytes = 18 GB
Total model state : 24 GB, which fits on an 80 GB-class H100 (85.9 GB in decimal units) but leaves only 61.9 GB for activations.
Activations (scale with batch) :
Per-layer retained activations for this quick estimate are approximately \(12 \times \BatchSize\times \SequenceLength\times \HiddenDimension\) BF16 elements, or \(12 \times \BatchSize\times \SequenceLength\times \HiddenDimension\times 2\) bytes, where \(\BatchSize\) is batch size and \(\SequenceLength\) is sequence length. The factor twelve accounts for the major intermediate tensors retained for backpropagation: input activations, QKV projections (\(3\HiddenDimension\) ), attention output, FFN intermediate (\(4\HiddenDimension\) ), and layer norm/dropout masks. This estimate assumes the implementation does not retain the full \(\BatchSize\times \AttentionHeadCount \times \SequenceLength^2\) attention-score tensor, as in recomputation- or tiled-attention-friendly accounting. With 48 layers, batch size 8, and sequence length 1024:
\[48 \times 12 \times 8 \times 1024 \times 1600 \times 2\text{ bytes } \approx 15.1\text{ GB}\]
Systems insight : Total memory reaches ~39.1 GB under this activation-accounting convention, which fits on one 85.9 GB accelerator. Each additional sample adds ~1.9 GB of activations, so under this quick estimate the remaining capacity fills near batch 32. At batch 64, activations grow to ~120.8 GB, well beyond it. The estimate omits smaller retained tensors such as dropout masks and softmax inputs. The full per-layer count of 34 bytes per token per hidden unit (Korthikanti et al. 2023 ) fills the same room near batch 23, the limit GPT-2 optimization walkthrough works from. That crossover is the threshold where gradient checkpointing or another memory-saving method becomes necessary; its savings and recomputation overhead depend on checkpoint placement and implementation.
Korthikanti, Vijay Anand, Jared Casper, Sangkug Lym, Lawrence McAfee, Michael Andersch, Mohammad Shoeybi, and Bryan Catanzaro. 2023. “Reducing Activation Recomputation in Large Transformer Models.” Proceedings of Machine Learning and Systems (MLSys ) 5: 341–53.
Activation explosion
While weights are fixed (\(\mathcal{O}(\Parameters)\) ), activations grow linearly with batch size and at least linearly with sequence length; implementations that materialize attention scores add an \(\mathcal{O}(\SequenceLength^2)\) component. As the worked example above shows, activation memory can quickly exceed the room left after model state. Gradient checkpointing reduces this pressure by storing only selected activations and recomputing the rest during backpropagation (Chen et al. 2016 ) , and FlashAttention removes the quadratic term by tiling attention (Dao et al. 2022 ) . The same decomposition provides a quick feasibility check: sum the per-parameter model state, add the activation term implied by batch size and sequence length, and compare the total against the accelerator’s capacity. Optimizers and their memory applies the model-state terms to optimizer choice, and Backpropagation and activation memory develops the activation term, with Activation checkpointing teaching the recomputation trade-off for the training loop.
4 Gradient checkpointing : Trades compute for memory. Instead of storing all activations, only a subset (checkpoints) is kept, and the missing ones are recomputed during the backward pass. This reduces memory usage from storing every layer activation to roughly the square root of the layer count at the cost of ~33 percent more compute (Chen et al. 2016 ) .
Chen, Tianqi, Bing Xu, Chiyuan Zhang, and Carlos Guestrin. 2016. “Training Deep Nets with Sublinear Memory Cost.” arXiv Preprint arXiv:1604.06174 .
Computational graphs and optimization
Running a chain of small operations one kernel at a time forces every intermediate tensor out to high-bandwidth memory and back, even when the next operation immediately consumes it. Because the dependency structure exposed by backpropagation records which operations feed which, ML compilers can represent the model as a directed acyclic graph (DAG) and rewrite those memory round-trips before generating device code.
Static single assignment
To transform a DAG safely, a compiler must know which write each read depends on. Static single-assignment (SSA) form makes those dependencies explicit by assigning each variable exactly once rather than overwriting tensor variables in place, enabling safe transformations such as operator fusion.
Operator fusion
Without fusion, each operation in a chain like MatMul → Add (bias) → ReLU produces an intermediate tensor that is written to high-bandwidth memory (HBM) and then read back for the next operation. For elementwise operations like Add and ReLU, the compute is trivial (one FLOP per element) but the memory traffic is not (read the tensor, write it back). The arithmetic intensity of unfused elementwise operations is therefore close to zero, which makes them strongly memory bound.
Fusion combines consecutive operations into a single kernel that reads the input once, applies all operations in registers or shared memory, and writes the final result once. For a sequence of \(\ChainedOperationCount\) elementwise operations on a tensor of \(\TensorElementCount\) elements of \(\ElementStorageSize\) bytes each, fusion reduces memory traffic from \(2\ChainedOperationCount \TensorElementCount\ElementStorageSize\) bytes (each operation reads and writes) to \(2\TensorElementCount\ElementStorageSize\) bytes (one read, one write), a \(\ChainedOperationCount\times\) reduction. The memory wall and kernel fusion develops fusion as a framework decision, and Kernel fusion on the accelerator shows the accelerator-side limits on how much a single kernel can fuse.
FlashAttention is fusion applied to attention. It computes the score, softmax, and value-product stages in SRAM tiles without materializing the full attention matrix in HBM, which reduces auxiliary attention memory from \(\mathcal{O}(\SequenceLength^2)\) to \(\mathcal{O}(\SequenceLength)\) for a fixed head dimension (Dao et al. 2022 ) . Section 1.4.2 derives the traffic bound step by step, and FlashAttention: IO-aware attention optimization applies the algorithm to training.
Fused and tiled kernels keep results exact while moving fewer bytes. The softmax at the end of the forward pass raises a different question, whether its results stay finite at all.
Logits and numerical stability
A classifier’s forward pass ends in a softmax over the final layer’s outputs, and the cross-entropy loss is computed from that softmax. The softmax exponentiates those outputs, and the exponential of a large output exceeds the range of every reduced-precision format, so the softmax is a common overflow site in reduced-precision training.
Those final-layer outputs form a vector of logits \(\LogitVector\) (unnormalized scores). For class index \(\ClassIndex\) , softmax normalizes \(\OutputLogit_{\ClassIndex}\) over all class indices \(\NormalizingClassIndex\) to produce a probability:
5 Logit : Joseph Berkson coined the term in 1944 by analogy with probit . The logit function is the inverse of the logistic (sigmoid) function: \(\text{logit}(\LogisticProbability) = \log(\LogisticProbability/(1-\LogisticProbability))\) . In deep learning, “logits” refers more loosely to the raw, unnormalized output of the final linear layer before any activation function is applied.
\[ \text{Softmax}(\OutputLogit_{\ClassIndex}) = \frac{e^{\OutputLogit_{\ClassIndex}}}{\sum_{\NormalizingClassIndex} e^{\OutputLogit_{\NormalizingClassIndex}}} \]
The problem is that if \(\OutputLogit_{\ClassIndex}\) is large (for example, 100), the exponential \(e^{\OutputLogit_{\ClassIndex}}\) overflows common training and inference formats such as FP32, BF16, and FP16. FP64 can represent this specific value, but production ML kernels rarely use FP64 for softmax. The fix is to subtract the largest logit before exponentiating, the log-sum-exp trick. The shift leaves the result mathematically unchanged and keeps every exponent at or below zero, as the worked example below illustrates for realistic logit values.
6 Log-sum-exp : Implemented as torch.logsumexp in PyTorch and scipy.special.logsumexp in SciPy. It relies on the identity \(\log\left(\sum e^{\OutputLogit_{\NormalizingClassIndex}}\right) = \SoftmaxRowMaximum + \log\left(\sum e^{\OutputLogit_{\NormalizingClassIndex} - \SoftmaxRowMaximum}\right)\) , where \(\SoftmaxRowMaximum = \max(\OutputLogit_{\NormalizingClassIndex})\) . Shifted values \(\OutputLogit_{\NormalizingClassIndex} - \SoftmaxRowMaximum\) are \(\le 0\) , ensuring exponentials never overflow.
Napkin Math 1.2: Log-sum-exp in action Setup : A three-class classifier outputs logits
\(\LogitVector=\) \([100, 101, 102]\) .
Without the trick (naive softmax) : \[\text{
$\exp(100) \approx 2.7 \times 10^{43}$, $\exp(101) \approx 7.3 \times 10^{43}$, $\exp(102) \approx 2.0 \times 10^{44}$}\]
These numbers are representable in FP64 but overflow FP32 (max \(\approx 3.4 \times 10^{38}\) ). With FP16 (max \(\approx 65{,}504\) ), even \(e^{12}\) overflows. Raw logits rarely reach magnitude 100, but large intermediate values do arise (for example, unscaled attention scores or overconfident outputs). Because FP16 and BF16 are the standard training precisions, a naive softmax risks overflow often enough that the stable form is used by default.
With the trick : Subtract \(\SoftmaxRowMaximum = \max(\LogitVector) =\) 102:
Shifted logits: \(\LogitVector- \SoftmaxRowMaximum =\) \([-2, -1, 0]\)
Exponentials: \(\exp(-2) \approx 0.135\) , \(\exp(-1) \approx 0.368\) , \(\exp(0) = 1.0\)
Sum = 1.503. LogSumExp = 102 \(+ \log(1.503) = 102.408\) .
Softmax: \([0.135/1.503,\; 0.368/1.503,\; 1.0/1.503] = [0.090,\; 0.245,\; 0.665]\)
Systems insight : The exponentiated shifted values and the resulting softmax probabilities are in \([0, 1]\) , so nothing overflows, even in FP16.
Cross-entropy and classification loss functions builds the cross-entropy loss on this stable softmax. The same maximum subtraction reappears, generalized to tiles of a long sequence, in the tiled-attention derivation of section 1.4.2 , one of the three proofs that close this appendix.
Derivations
The earlier sections used three results that the chapters rely on without proof: that reverse-mode differentiation costs a small constant multiple of a forward pass rather than scaling with parameter count, that tiled attention can normalize across blocks without materializing an \(\SequenceLength \times \SequenceLength\) matrix in HBM, and that a fixed training compute budget splits predictably between model parameters and dataset tokens. Each derivation below proves one of those bounds and states its systems consequence.
Cost of reverse-mode differentiation
Perturbing each of \(\FunctionInputDimension\) parameters one by one to measure its effect on the loss requires \(\FunctionInputDimension\) forward evaluations, yet backpropagation computes all \(\FunctionInputDimension\) partial derivatives of a scalar loss in a small constant multiple of a single forward pass, whether \(\FunctionInputDimension\) is a thousand or a hundred billion. Baur and Strassen proved in 1983 that this dimension-free ratio holds for any scalar function on a computational graph: computing a function together with its full gradient takes at most four times the operations of the function alone when every operation counts, and at most three times when only multiplications and divisions count (Baur and Strassen 1983 ) . The per-operation accounting below is simpler than their construction and proves the looser constant of five.
Baur, Walter, and Volker Strassen. 1983. “The Complexity of Partial Derivatives.” Theoretical Computer Science 22 (3): 317–30. https://doi.org/10.1016/0304-3975(83)90110-x.
Statement
Let \(\ScalarGraphFunction: \mathbb{R}^\FunctionInputDimension\to \mathbb{R}\) be a multivariate scalar-valued function represented as a computational graph \(\ComputationalGraph= (\GraphNodeSet, \GraphEdgeSet)\) consisting of \(\ElementaryOperationCount(\ScalarGraphFunction)\) elementary operations (additions, subtractions, multiplications, divisions, and unary functions such as \(\exp, \ln, \sin, \sqrt{\cdot}\) ).
Theorem 1.1: Cheap-gradient bound If a scalar function
\(\ScalarGraphFunction: \mathbb{R}^\FunctionInputDimension\to \mathbb{R}\) can be computed in
\(\ElementaryOperationCount(\ScalarGraphFunction)\) elementary operations, then the full gradient vector
\(\nabla \ScalarGraphFunction(\FunctionInputVector) = \left(\frac{\partial \ScalarGraphFunction}{\partial \FunctionInputElement_1}, \frac{\partial \ScalarGraphFunction}{\partial \FunctionInputElement_2}, \dots, \frac{\partial \ScalarGraphFunction}{\partial \LastFunctionInputComponent}\right)^T \in \mathbb{R}^\FunctionInputDimension\) can be evaluated in total work
\(\text{Work}_{\text{Reverse}}(\ScalarGraphFunction, \nabla \ScalarGraphFunction)\) satisfying:
\[ \text{Work}_{\text{Reverse}}(\ScalarGraphFunction, \nabla \ScalarGraphFunction) \le \ReverseModeWorkConstant\cdot \ElementaryOperationCount(\ScalarGraphFunction) \] where
\(\ReverseModeWorkConstant\le 5\) is a universal constant independent of the input dimension
\(\FunctionInputDimension\) . Furthermore, the backward pass alone requires work
\(\text{Work}_{\text{Backward}}(\nabla \ScalarGraphFunction) \le 4 \cdot \ElementaryOperationCount(\ScalarGraphFunction)\) .
Proof
Let the computational graph \(\ComputationalGraph= (\GraphNodeSet, \GraphEdgeSet)\) be topologically ordered with nodes \(\FirstInputNodePrimal, \dots, \TraceIntermediateVariable_0, \TraceIntermediateVariable_1\) , \(\TraceIntermediateVariable_2, \dots, \OutputNodePrimal\) . The input variables are \(\FunctionInputElement_{\InputVariableIndex} = \InputNodePrimal\) for \(\InputVariableIndex\in \{1, \dots, \FunctionInputDimension\}\) and the final output is \(\ScalarGraphFunction(\FunctionInputVector) = \OutputNodePrimal\) . Each intermediate node \(\TraceIntermediateVariable_j\) is evaluated via a primitive operation: \[ \TraceIntermediateVariable_j = \PrimitiveOperation_j\left( \{ \TraceIntermediateVariable_k \mid \ParentNodeIndex\in \text{Parents}(\CurrentNodeIndex) \} \right) \]
Define the adjoint variable \(\TraceIntermediateAdjoint_i\) for every node \(\TraceIntermediateVariable_i\) as the partial derivative of the scalar output \(\OutputNodePrimal\) with respect to \(\TraceIntermediateVariable_i\) : \[ \TraceIntermediateAdjoint_i \triangleq \frac{\partial \ScalarGraphFunction}{\partial \TraceIntermediateVariable_i} = \frac{\partial \OutputNodePrimal}{\partial \TraceIntermediateVariable_i} \]
By the multivariate chain rule, the adjoint \(\TraceIntermediateAdjoint_i\) is the sum of partial derivatives propagated from all successor nodes (children) that consume \(\TraceIntermediateVariable_i\) : \[ \TraceIntermediateAdjoint_i = \sum_{j \in \text{Children}(i)} \TraceIntermediateAdjoint_j \cdot \frac{\partial \TraceIntermediateVariable_j}{\partial \TraceIntermediateVariable_i} \]
Reverse-mode automatic differentiation initializes \(\OutputNodeAdjoint = 1\) and \(\TraceIntermediateAdjoint_i = 0\) for all \(\GraphNodeIndex< \ElementaryOperationCount\) , then traverses the nodes in reverse topological order from \(\OutputNodePrimal\) down to \(\TraceIntermediateVariable_1\) . For each primitive node \(\TraceIntermediateVariable_j\) , its fully accumulated adjoint \(\TraceIntermediateAdjoint_j\) propagates error signals to its parent nodes \(\TraceIntermediateVariable_k\) (\(\ParentNodeIndex\in \text{Parents}(\CurrentNodeIndex)\) ) via: \[ \TraceIntermediateAdjoint_k \gets \TraceIntermediateAdjoint_k + \TraceIntermediateAdjoint_j \cdot \frac{\partial \TraceIntermediateVariable_j}{\partial \TraceIntermediateVariable_k} \]
We bound the backward cost one operation type at a time:
Addition/Subtraction (\(\TraceIntermediateVariable_j = \TraceIntermediateVariable_i \pm \TraceIntermediateVariable_k\) ) :
Local derivatives: \(\frac{\partial \TraceIntermediateVariable_j}{\partial \TraceIntermediateVariable_i} = 1\) , \(\frac{\partial \TraceIntermediateVariable_j}{\partial \TraceIntermediateVariable_k} = \pm 1\) .
Backward updates: \(\TraceIntermediateAdjoint_i \gets \TraceIntermediateAdjoint_i + \TraceIntermediateAdjoint_j\) and \(\TraceIntermediateAdjoint_k \gets \TraceIntermediateAdjoint_k \pm \TraceIntermediateAdjoint_j\) .
Cost: 2 additions in backward pass for 1 forward operation. Work ratio: \(\text{Fwd}(1) + \text{Bwd}(2) = 3 \text{ OPs} \le 5 \cdot 1\) .
Multiplication (\(\TraceIntermediateVariable_j = \TraceIntermediateVariable_i \cdot \TraceIntermediateVariable_k\) ) :
Local derivatives: \(\frac{\partial \TraceIntermediateVariable_j}{\partial \TraceIntermediateVariable_i} = \TraceIntermediateVariable_k\) , \(\frac{\partial \TraceIntermediateVariable_j}{\partial \TraceIntermediateVariable_k} = \TraceIntermediateVariable_i\) .
Backward updates: \(\TraceIntermediateAdjoint_i \gets \TraceIntermediateAdjoint_i + \TraceIntermediateAdjoint_j \cdot \TraceIntermediateVariable_k\) and \(\TraceIntermediateAdjoint_k \gets \TraceIntermediateAdjoint_k + \TraceIntermediateAdjoint_j \cdot \TraceIntermediateVariable_i\) .
Cost: 2 multiplications + 2 additions = 4 operations in backward pass for 1 forward operation. Work ratio: \(\text{Fwd}(1) + \text{Bwd}(4) = 5 \text{ OPs} \le 5 \cdot 1\) .
Division (\(\TraceIntermediateVariable_j = \TraceIntermediateVariable_i/\TraceIntermediateVariable_k\) ) :
Local derivatives: \(\frac{\partial \TraceIntermediateVariable_j}{\partial \TraceIntermediateVariable_i} = \frac{1}{\TraceIntermediateVariable_k}\) , \(\frac{\partial \TraceIntermediateVariable_j}{\partial \TraceIntermediateVariable_k} = -\frac{\TraceIntermediateVariable_i}{\TraceIntermediateVariable_k^2} = -\frac{\TraceIntermediateVariable_j}{\TraceIntermediateVariable_k}\) .
Backward updates: \(\TraceIntermediateAdjoint_i \gets \TraceIntermediateAdjoint_i + \frac{\TraceIntermediateAdjoint_j}{\TraceIntermediateVariable_k}\) and \(\TraceIntermediateAdjoint_k \gets \TraceIntermediateAdjoint_k - \frac{\TraceIntermediateAdjoint_j \cdot \TraceIntermediateVariable_j}{\TraceIntermediateVariable_k}\) .
Cost: Compute the quotient of the incoming adjoint and the denominator once, then reuse it in both updates. Add it to the numerator adjoint, and multiply it by the cached forward output before subtracting from the denominator adjoint. This requires 2 multiplications/divisions + 2 additions = 4 operations in backward pass for 1 forward operation. Work ratio: \(\text{Fwd}(1) + \text{Bwd}(4) = 5 \text{ OPs} \le 5 \cdot 1\) .
Unary transcendental operations (\(\TraceIntermediateVariable_j = \PrimitiveOperation(\TraceIntermediateVariable_i)\) ) :
Local derivative: \(\frac{\partial \TraceIntermediateVariable_j}{\partial \TraceIntermediateVariable_i} = \PrimitiveOperation'(\TraceIntermediateVariable_i)\) .
Backward update: \(\TraceIntermediateAdjoint_i \gets \TraceIntermediateAdjoint_i + \TraceIntermediateAdjoint_j \cdot \PrimitiveOperation'(\TraceIntermediateVariable_i)\) .
For \(\TraceIntermediateVariable_j = \exp(\TraceIntermediateVariable_i)\) , \(\PrimitiveOperation'(\TraceIntermediateVariable_i) = \TraceIntermediateVariable_j\) , requiring 1 multiplication + 1 addition = 2 OPs.
For \(\TraceIntermediateVariable_j = \ln(\TraceIntermediateVariable_i)\) , \(\PrimitiveOperation'(\TraceIntermediateVariable_i) = 1/\TraceIntermediateVariable_i\) , requiring 1 division + 1 addition = 2 OPs.
Summing across all primitive nodes in \(\ComputationalGraph\) , every forward operation generates at most 4 backward operations: \[ \text{Work}_{\text{Backward}}(\nabla \ScalarGraphFunction) \le 4 \cdot \ElementaryOperationCount(\ScalarGraphFunction) \]
Adding the forward pass work \(\ElementaryOperationCount(\ScalarGraphFunction)\) yields the total work bound: \[ \text{Work}_{\text{Reverse}}(\ScalarGraphFunction, \nabla \ScalarGraphFunction) = \ElementaryOperationCount(\ScalarGraphFunction) + \text{Work}_{\text{Backward}}(\nabla \ScalarGraphFunction) \le 5 \cdot \ElementaryOperationCount(\ScalarGraphFunction) \qquad\blacksquare\]
Systems Perspective 1.3: Why 175B-parameter large language models can be trained The independence of
\(\ReverseModeWorkConstant\le 5\) from input dimension
\(\FunctionInputDimension\) is the mathematical reason deep learning works. Consider training a transformer model with
\(\Parameters= 175 \times 10^9\) parameters:
Forward pass : Matrix multiplications \(\LayerOutputMatrix= \LayerInputMatrix\WeightMatrix\) require \(2\Parameters\) FLOPs per token.
Reverse-mode backward pass : Computes both weight gradients \(\frac{\partial \LossFunction}{\partial \WeightMatrix} = \LayerInputMatrix^T \frac{\partial \LossFunction}{\partial \LayerOutputMatrix}\) (\(2\Parameters\) FLOPs) and input activation gradients \(\frac{\partial \LossFunction}{\partial \LayerInputMatrix} = \frac{\partial \LossFunction}{\partial \LayerOutputMatrix} \WeightMatrix^T\) (\(2\Parameters\) FLOPs), totaling \(4\Parameters\) FLOPs per token.
Total training work : \(2\Parameters(\text{fwd}) + 4\Parameters(\text{bwd}) = 6\Parameters\) FLOPs per token. The backward compute factor is exactly \(\frac{4\Parameters}{2\Parameters} = 2\) , so forward plus backward costs three times the forward pass, within both the bound of \(\ReverseModeWorkConstant\le 5\) proved here and Baur and Strassen’s sharper constant of four.
If we instead used forward-mode automatic differentiation (AD) or finite differences to compute \(\nabla \ScalarGraphFunction\in \mathbb{R}^\Parameters\) , evaluating each partial derivative separately would require \(\Parameters\) forward passes: \(\text{Work}_{\text{ForwardMode}}(\nabla \ScalarGraphFunction) = \mathcal{O}(\Parameters\cdot \ElementaryOperationCount) = \mathcal{O}(\Parameters^2)\) FLOPs. For \(\Parameters= 175 \times 10^9\) , that method would require \(2 \times (175 \times 10^9)^2 \approx 6.1 \times 10^{22}\) FLOPs per token, \(\Parameters\) times the forward-pass work and therefore prohibitive at this scale. Reverse-mode AD replaces this \(\mathcal{O}(\Parameters)\) factor with a constant multiplier of 2 for the dense-layer accounting above.
Reverse mode achieves this constant factor by keeping the forward pass’s intermediate values for the backward sweep, which is why the training-memory decomposition in section 1.3.3 carries an activation term. Attention adds an intermediate whose size grows with the square of the sequence length, the subject of the next derivation.
Tiled attention and online softmax
Standard self-attention in transformers requires materializing an \(\SequenceLength\times \SequenceLength\) attention score matrix in HBM, creating an \(\mathcal{O}(\SequenceLength^2)\) memory bandwidth bottleneck. FlashAttention (Dao et al. 2022 ) reduces this bottleneck by tiling query, key, and value matrices and recomputing attention using an online softmax recurrence without materializing intermediate scores to HBM. FlashAttention: IO-aware attention optimization applies the algorithm to training. This subsection proves the online softmax recurrence it relies on and then its memory-traffic bound.
Memory traffic of standard attention
Given queries \(\AttentionQueryMatrix\in \mathbb{R}^{\SequenceLength\times \AttentionHeadDimension}\) , keys \(\AttentionKeyMatrix\in \mathbb{R}^{\SequenceLength\times \AttentionHeadDimension}\) , and values \(\AttentionValuesMatrix\in \mathbb{R}^{\SequenceLength\times \AttentionHeadDimension}\) for sequence length \(\SequenceLength\) and head dimension \(\AttentionHeadDimension\) , standard attention evaluates: \[ \AttentionScoreMatrix= \AttentionQueryMatrix\AttentionKeyMatrix^T \in \mathbb{R}^{\SequenceLength\times \SequenceLength}, \qquad \AttentionWeightMatrix= \text{softmax}(\AttentionScoreMatrix) \in \mathbb{R}^{\SequenceLength\times \SequenceLength}, \qquad \AttentionHeadOutput= \AttentionWeightMatrix\AttentionValuesMatrix\in \mathbb{R}^{\SequenceLength\times \AttentionHeadDimension} \]
To prevent numerical overflow, row-wise softmax subtracts the row maximum (the log-sum-exp shift of section 1.3.5 ) \(\SoftmaxRowMaximum_i = \max_{1 \le j \le \SequenceLength} \AttentionScoreEntry\) : \[ \AttentionWeightEntry = \frac{\exp(\AttentionScoreEntry - \SoftmaxRowMaximum_i)}{\sum_{k=1}^\SequenceLength\exp(\AttentionScoreSummand - \SoftmaxRowMaximum_i)} \]
Standard GPU implementations execute this in three discrete kernel launches:
Compute \(\AttentionScoreMatrix= \AttentionQueryMatrix\AttentionKeyMatrix^T\) in SRAM, then write \(\AttentionScoreMatrix\in \mathbb{R}^{\SequenceLength\times \SequenceLength}\) to HBM (\(\AsymptoticTightBound(\SequenceLength^2)\) writes).
Read \(\AttentionScoreMatrix\) from HBM, compute row max \(\SoftmaxRowMaximum\) and row sum \(\SoftmaxNormalizer\) , compute \(\AttentionWeightMatrix= \text{softmax}(\AttentionScoreMatrix)\) , write \(\AttentionWeightMatrix\in \mathbb{R}^{\SequenceLength\times \SequenceLength}\) to HBM (\(\AsymptoticTightBound(\SequenceLength^2)\) reads + writes).
Read \(\AttentionWeightMatrix\) and \(\AttentionValuesMatrix\) from HBM, compute \(\AttentionHeadOutput= \AttentionWeightMatrix\AttentionValuesMatrix\) , write \(\AttentionHeadOutput\in \mathbb{R}^{\SequenceLength\times \AttentionHeadDimension}\) to HBM (\(\AsymptoticTightBound(\SequenceLength^2 + \SequenceLength\AttentionHeadDimension)\) reads + writes).
Total HBM memory traffic is \(\AsymptoticTightBound(\SequenceLength^2 + \SequenceLength\AttentionHeadDimension)\) elements. For \(\SequenceLength=\) 8192, \(\AttentionHeadDimension = 128\) in FP16, \(\AttentionScoreMatrix\) requires \(8192^2 \times 2 \text{ B} = 134 \text{ MB}\) per head per layer. Because modern GPUs have high compute throughput relative to HBM bandwidth, repeatedly reading and writing intermediate matrices \(\AttentionScoreMatrix\) and \(\AttentionWeightMatrix\) leaves GPU execution units memory-bound.
Online softmax recurrence
Tiling softmax is difficult because computing \(\SoftmaxNormalizer_i = \sum_{k=1}^{\SequenceLength} \exp(\AttentionScoreSummand - \SoftmaxRowMaximum_i)\) requires the global maximum \(\SoftmaxRowMaximum_i\) across all \(\SequenceLength\) keys. The online softmax recurrence solves this by incrementally updating normalization statistics as sub-blocks arrive.
Theorem 1.2: Online softmax recurrence theorem Let a vector
\(\SoftmaxInputVector\in \mathbb{R}^\SoftmaxVectorLength\) be partitioned into two sub-vectors
\(\SoftmaxInputVector^{(1)} \in \mathbb{R}^{\SoftmaxVectorLength_1}\) and
\(\SoftmaxInputVector^{(2)} \in \mathbb{R}^{\SoftmaxVectorLength_2}\) with
\(\SoftmaxVectorLength= \SoftmaxVectorLength_1 + \SoftmaxVectorLength_2\) . Let the local statistics for block 1 be:
\[ \SoftmaxRowMaximum^{(1)} = \max_{1 \le j \le \SoftmaxVectorLength_1} \SoftmaxInputScore_j^{(1)}, \qquad \SoftmaxNormalizer^{(1)} = \sum_{j=1}^{\SoftmaxVectorLength_1} \exp\left(\SoftmaxInputScore_j^{(1)} - \SoftmaxRowMaximum^{(1)}\right) \] and for block 2 be:
\[ \SoftmaxRowMaximum^{(2)} = \max_{1 \le j \le \SoftmaxVectorLength_2} \SoftmaxInputScore_j^{(2)}, \qquad \SoftmaxNormalizer^{(2)} = \sum_{j=1}^{\SoftmaxVectorLength_2} \exp\left(\SoftmaxInputScore_j^{(2)} - \SoftmaxRowMaximum^{(2)}\right) \]
Then the combined maximum \(\MergedSoftmaxMaximum\) , normalization sum \(\MergedSoftmaxNormalizer\) , and accumulated output vector \(\MergedAttentionOutput\) satisfy the exact recurrence relations: \[ \begin{aligned}
\MergedSoftmaxMaximum &= \max\left(\SoftmaxRowMaximum^{(1)}, \SoftmaxRowMaximum^{(2)}\right), \\
\MergedSoftmaxNormalizer &= \SoftmaxNormalizer^{(1)} e^{\SoftmaxRowMaximum^{(1)} - \MergedSoftmaxMaximum} + \SoftmaxNormalizer^{(2)} e^{\SoftmaxRowMaximum^{(2)} - \MergedSoftmaxMaximum}, \\
\MergedAttentionOutput &= \frac{\SoftmaxNormalizer^{(1)} e^{\SoftmaxRowMaximum^{(1)} - \MergedSoftmaxMaximum}}{\MergedSoftmaxNormalizer} \AttentionHeadOutput^{(1)} + \frac{e^{\SoftmaxRowMaximum^{(2)} - \MergedSoftmaxMaximum}}{\MergedSoftmaxNormalizer} \sum_{j=1}^{\SoftmaxVectorLength_2} e^{\SoftmaxInputScore_j^{(2)} - \SoftmaxRowMaximum^{(2)}} \AttentionValuesMatrix_j^{(2)},
\end{aligned} \] where \(\AttentionHeadOutput^{(1)} = \frac{1}{\SoftmaxNormalizer^{(1)}} \sum_{j=1}^{\SoftmaxVectorLength_1} e^{\SoftmaxInputScore_j^{(1)} - \SoftmaxRowMaximum^{(1)}} \AttentionValuesMatrix_j^{(1)}\) is the partial output accumulated from block 1.
Denominator recurrence
Expanding the combined sum \(\MergedSoftmaxNormalizer = \sum_{j=1}^\SoftmaxVectorLength e^{\SoftmaxInputScore_j - \MergedSoftmaxMaximum}\) : \[ \begin{aligned} \MergedSoftmaxNormalizer &= \sum_{j=1}^{\SoftmaxVectorLength_1} e^{\SoftmaxInputScore_j^{(1)} - \MergedSoftmaxMaximum} + \sum_{j=1}^{\SoftmaxVectorLength_2} e^{\SoftmaxInputScore_j^{(2)} - \MergedSoftmaxMaximum} \\ &= \sum_{j=1}^{\SoftmaxVectorLength_1} e^{\left(\SoftmaxInputScore_j^{(1)} - \SoftmaxRowMaximum^{(1)}\right) + \left(\SoftmaxRowMaximum^{(1)} - \MergedSoftmaxMaximum\right)} + \sum_{j=1}^{\SoftmaxVectorLength_2} e^{\left(\SoftmaxInputScore_j^{(2)} - \SoftmaxRowMaximum^{(2)}\right) + \left(\SoftmaxRowMaximum^{(2)} - \MergedSoftmaxMaximum\right)} \\ &= e^{\SoftmaxRowMaximum^{(1)} - \MergedSoftmaxMaximum} \underbrace{\sum_{j=1}^{\SoftmaxVectorLength_1} e^{\SoftmaxInputScore_j^{(1)} - \SoftmaxRowMaximum^{(1)}}}_{\SoftmaxNormalizer^{(1)}} + e^{\SoftmaxRowMaximum^{(2)} - \MergedSoftmaxMaximum} \underbrace{\sum_{j=1}^{\SoftmaxVectorLength_2} e^{\SoftmaxInputScore_j^{(2)} - \SoftmaxRowMaximum^{(2)}}}_{\SoftmaxNormalizer^{(2)}} \\ &= \SoftmaxNormalizer^{(1)} e^{\SoftmaxRowMaximum^{(1)} - \MergedSoftmaxMaximum} + \SoftmaxNormalizer^{(2)} e^{\SoftmaxRowMaximum^{(2)} - \MergedSoftmaxMaximum}. \quad \blacksquare \end{aligned} \]
Output rescaling recurrence
The true normalized output over the concatenated sequence is \(\MergedAttentionOutput = \frac{1}{\MergedSoftmaxNormalizer} \sum_{j=1}^\SoftmaxVectorLength e^{\SoftmaxInputScore_j - \MergedSoftmaxMaximum} \AttentionValuesMatrix_j\) : \[ \begin{aligned} \MergedAttentionOutput &= \frac{1}{\MergedSoftmaxNormalizer} \left[ \sum_{j=1}^{\SoftmaxVectorLength_1} e^{\SoftmaxInputScore_j^{(1)} - \MergedSoftmaxMaximum} \AttentionValuesMatrix_j^{(1)} + \sum_{j=1}^{\SoftmaxVectorLength_2} e^{\SoftmaxInputScore_j^{(2)} - \MergedSoftmaxMaximum} \AttentionValuesMatrix_j^{(2)} \right] \\ &= \frac{1}{\MergedSoftmaxNormalizer} \left[ e^{\SoftmaxRowMaximum^{(1)} - \MergedSoftmaxMaximum} \sum_{j=1}^{\SoftmaxVectorLength_1} e^{\SoftmaxInputScore_j^{(1)} - \SoftmaxRowMaximum^{(1)}} \AttentionValuesMatrix_j^{(1)} + e^{\SoftmaxRowMaximum^{(2)} - \MergedSoftmaxMaximum} \sum_{j=1}^{\SoftmaxVectorLength_2} e^{\SoftmaxInputScore_j^{(2)} - \SoftmaxRowMaximum^{(2)}} \AttentionValuesMatrix_j^{(2)} \right] \end{aligned} \]
Noting that \(\SoftmaxNormalizer^{(1)} \AttentionHeadOutput^{(1)} = \sum_{j=1}^{\SoftmaxVectorLength_1} e^{\SoftmaxInputScore_j^{(1)} - \SoftmaxRowMaximum^{(1)}} \AttentionValuesMatrix_j^{(1)}\) , we substitute this directly: \[ \MergedAttentionOutput = \frac{\SoftmaxNormalizer^{(1)} e^{\SoftmaxRowMaximum^{(1)} - \MergedSoftmaxMaximum}}{\MergedSoftmaxNormalizer} \AttentionHeadOutput^{(1)} + \frac{e^{\SoftmaxRowMaximum^{(2)} - \MergedSoftmaxMaximum}}{\MergedSoftmaxNormalizer} \sum_{j=1}^{\SoftmaxVectorLength_2} e^{\SoftmaxInputScore_j^{(2)} - \SoftmaxRowMaximum^{(2)}} \AttentionValuesMatrix_j^{(2)}. \quad \blacksquare \]
Memory traffic of tiled attention
The recurrence lets each query tile be combined with one key-value tile at a time, so score tiles never need to leave SRAM. The remaining question is how many bytes then cross the HBM boundary.
Let \(\SramCapacity\) be the fast SRAM capacity (in words). Following Algorithm 1 of Dao et al. (2022 ) , FlashAttention sets \(\KvTileSize = \lfloor \SramCapacity/(4\AttentionHeadDimension) \rfloor\) and \(\QueryBlockSize = \min(\lfloor \SramCapacity/(4\AttentionHeadDimension) \rfloor,\AttentionHeadDimension)\) . The proof abstracts constant factors and buffer reuse, using \(\KvTileSize=\AsymptoticTightBound(\SramCapacity/\AttentionHeadDimension)\) , \(\QueryBlockSize=\AsymptoticTightBound(\min(\SramCapacity/\AttentionHeadDimension,\AttentionHeadDimension))\) , and \(\QueryBlockSize\KvTileSize=\mathcal{O}(\SramCapacity)\) for the on-chip working set.
The algorithm partitions \(\AttentionQueryMatrix\) into \(\QueryBlockCount = \lceil \SequenceLength/\QueryBlockSize \rceil\) blocks of size \(\QueryBlockSize \times \AttentionHeadDimension\) . It also partitions \(\AttentionKeyMatrix, \AttentionValuesMatrix\) into \(\KvTileCount = \lceil \SequenceLength/\KvTileSize \rceil\) blocks of size \(\KvTileSize \times \AttentionHeadDimension\) . The algorithm then executes two nested loops:
Outer loop over \(\KvTileIndex= 1, \dots, \KvTileCount\) : Load \(\AttentionKeyMatrix_j\) and \(\AttentionValuesMatrix_j\) into SRAM.
Inner loop over \(\QueryBlockIndex= 1, \dots, \QueryBlockCount\) : Load \(\AttentionQueryMatrix_i\) , \(\AttentionHeadOutput_i\) , and its softmax statistics; compute \(\AttentionScoreTile = \AttentionQueryMatrix_i \AttentionKeyMatrix_j^T\) in SRAM; then update and write \(\AttentionHeadOutput_i\) and the statistics without materializing \(\AttentionScoreTile\) in HBM.
This loop order is the source of the I/O reduction. A key-value tile remains resident while the algorithm visits every query tile, so each element of \(\AttentionKeyMatrix\) and \(\AttentionValuesMatrix\) crosses the HBM boundary once. The query and output tiles must be revisited for each key-value block, but the \(\QueryBlockSize\times \KvTileSize\) score tile is consumed on chip and discarded. Standard attention instead writes and rereads the full \(\SequenceLength\times \SequenceLength\) score and probability matrices.
Total memory access accounting
Total HBM accesses comprise two components. The first is key and value reads, where each element of \(\AttentionKeyMatrix\) and \(\AttentionValuesMatrix\) is loaded once (contributing \(2\SequenceLength\AttentionHeadDimension\) accesses). The second is query, output, and statistics passes, where each of the \(\KvTileCount\) column blocks reads all of \(\AttentionQueryMatrix\) , reads and writes \(\AttentionHeadOutput\) , and updates \(\mathcal{O}(\SequenceLength)\) softmax statistics. The matrices dominate the statistics for head dimension \(\AttentionHeadDimension\geq 1\) , so each pass contributes \(\AsymptoticTightBound(\SequenceLength\AttentionHeadDimension)\) accesses and all passes contribute \(\AsymptoticTightBound(\SequenceLength\AttentionHeadDimension \KvTileCount)\) .
Because \(\KvTileCount=\lceil \SequenceLength/\KvTileSize\rceil=\AsymptoticTightBound(\SequenceLength\AttentionHeadDimension/\SramCapacity)\) , the total is \[ \text{HBM}_{\text{Flash}} = \AsymptoticTightBound\left(\SequenceLength\AttentionHeadDimension + \SequenceLength\AttentionHeadDimension \KvTileCount\right) = \AsymptoticTightBound\left(\SequenceLength\AttentionHeadDimension + \frac{\SequenceLength^2 \AttentionHeadDimension^2}{\SramCapacity}\right) = \AsymptoticTightBound\left(\frac{\SequenceLength^2 \AttentionHeadDimension^2}{\SramCapacity}\right), \] where the final equality follows for \(\AttentionHeadDimension \leq \SramCapacity\leq \SequenceLength\AttentionHeadDimension\) .
The bound counts communication rather than arithmetic. FlashAttention still evaluates the same dense score blocks and may recompute intermediate quantities during backpropagation; its advantage comes from keeping those intermediates out of HBM.
I/O reduction ratio
Comparing standard attention I/O to FlashAttention I/O: \[ \frac{\text{HBM}_{\text{Standard}}}{\text{HBM}_{\text{Flash}}} = \frac{\AsymptoticTightBound(\SequenceLength^2 + \SequenceLength\AttentionHeadDimension)}{\AsymptoticTightBound\left(\SequenceLength\AttentionHeadDimension + \frac{\SequenceLength^2 \AttentionHeadDimension^2}{\SramCapacity}\right)} = \AsymptoticTightBound\left(\frac{\SramCapacity}{\AttentionHeadDimension^2}\right) \quad \text{for } \SequenceLength\gg \max\left(\AttentionHeadDimension,\frac{\SramCapacity}{\AttentionHeadDimension}\right) \]
Systems Perspective 1.4: A100 I/O reduction The asymptotic ratio
\(\SramCapacity/\AttentionHeadDimension^2\) predicts how greater SRAM capacity can reduce HBM traffic, but hidden constants and kernel details prevent it from serving as an exact transfer count. In an NVIDIA A100 measurement,
Dao et al. (2022 ) report the effect for a forward-and-backward attention workload with sequence length 1,024, head dimension 64, 16 heads, batch size 64, a key-padding mask, and no dropout:
Standard attention : 35.3 GB of HBM reads and writes; 35.1 ms runtime.
FlashAttention : 4.4 GB of HBM reads and writes; 11.7 ms runtime.
The measurements show the systems consequence of the I/O bound: substantially less HBM traffic coincides with lower runtime even though FlashAttention performs additional recomputation. They do not imply that every configuration becomes compute bound; tile size, sequence length, and kernel implementation determine the realized regime.
Dao, T., D. Y. Fu, S. Ermon, A. Rudra, and C. Ré. 2022. “FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness.” Advances in Neural Information Processing Systems (NeurIPS) 35: 16344–59. https://doi.org/10.52202/068431-1189.
Tiling changes how many bytes cross the memory boundary for a fixed model. The last derivation applies the same accounting one level up and asks how large the model and its training set should be for a fixed compute budget.
Compute-optimal scaling laws
Spending a fixed FLOP budget \(\Operations\) on a 175-billion-parameter model trained on 300 billion tokens leaves the model undertrained compared with a 70-billion-parameter model trained on 1.4 trillion tokens at the same compute cost. Minimizing parametric training loss under a fixed \(\Operations = 6\Parameters\DatasetSize\) constraint via Lagrange multipliers explains why, and it separates the earlier fit of Kaplan et al. (2020 ) from the compute-optimal scaling of Hoffmann et al. (2022 ) . The compute-optimal frontier uses the resulting frontier to test whether a training run is starved of data or of compute.
To match the rest of the book, the derivation writes model parameters as \(\Parameters\) , dataset size in tokens as \(\DatasetSize\) , and the training compute budget as \(\Operations\) total FLOPs, whereas Kaplan et al. (2020 ) and Hoffmann et al. (2022 ) write \(\Glyph{N}\) for parameters and \(\Glyph{C}\) for compute. The fitted constants \(\ChinchillaIrreducibleLoss\) , \(\ParameterScaleCoefficient\) , \(\DataScaleCoefficient\) , \(\ParameterScalingExponent\) , and \(\DataScalingExponent\) and the Lagrange multiplier \(\ComputeConstraintMultiplier\) keep the papers’ letters and are local to this section, so \(\ChinchillaIrreducibleLoss\) is a loss rather than an energy and \(\DataScaleCoefficient\) is a fitted constant rather than batch size.
Parametric loss surface
The cross-entropy evaluation loss \(\LossFunction(\Parameters, \DatasetSize)\) of an autoregressive transformer language model trained with \(\Parameters\) non-embedding parameters on \(\DatasetSize\) tokens is modeled by the power-law formulation: \[ \LossFunction(\Parameters, \DatasetSize) = \ChinchillaIrreducibleLoss+ \frac{\ParameterScaleCoefficient}{\Parameters^\ParameterScalingExponent} + \frac{\DataScaleCoefficient}{\DatasetSize^\DataScalingExponent} \] where:
\(\ChinchillaIrreducibleLoss\) : Irreducible loss representing the entropy of natural language data.
\(\frac{\ParameterScaleCoefficient}{\Parameters^\ParameterScalingExponent}\) : Capacity bottleneck loss resulting from finite model parameters \(\Parameters\) .
\(\frac{\DataScaleCoefficient}{\DatasetSize^\DataScalingExponent}\) : Dataset size bottleneck loss resulting from finite training tokens \(\DatasetSize\) .
\(\ParameterScaleCoefficient, \DataScaleCoefficient> 0\) : Empirical scaling constants.
\(\ParameterScalingExponent, \DataScalingExponent> 0\) : Power-law scaling exponents for model size and dataset size, respectively.
Constrained optimization
The total floating-point operations required to train a transformer with \(\Parameters\) non-embedding parameters for \(\DatasetSize\) tokens is given by \[ \Operations= 6 \Parameters \DatasetSize\text{ FLOPs}, \] where \(2 \Parameters \DatasetSize\) accounts for the forward pass and \(4 \Parameters \DatasetSize\) accounts for the backward pass.
Given a fixed training compute budget \(\Operations_0\) , we formulate the constrained optimization problem to minimize the reducible loss \(\ReducibleLoss(\Parameters, \DatasetSize) = \frac{\ParameterScaleCoefficient}{\Parameters^\ParameterScalingExponent} + \frac{\DataScaleCoefficient}{\DatasetSize^\DataScalingExponent}\) : \[ \min_{\Parameters, \DatasetSize} \left( \frac{\ParameterScaleCoefficient}{\Parameters^\ParameterScalingExponent} + \frac{\DataScaleCoefficient}{\DatasetSize^\DataScalingExponent} \right) \quad \text{subject to} \quad \ComputeBudgetConstraint(\Parameters, \DatasetSize) = 6 \Parameters \DatasetSize- \Operations_0 = 0 \]
We construct the Lagrangian function \(\ComputeConstrainedLagrangian(\Parameters, \DatasetSize, \ComputeConstraintMultiplier)\) : \[ \ComputeConstrainedLagrangian(\Parameters, \DatasetSize, \ComputeConstraintMultiplier) = \frac{\ParameterScaleCoefficient}{\Parameters^\ParameterScalingExponent} + \frac{\DataScaleCoefficient}{\DatasetSize^\DataScalingExponent} + \ComputeConstraintMultiplier(6 \Parameters \DatasetSize- \Operations_0) \]
Taking partial derivatives with respect to \(\Parameters, \DatasetSize\) , and \(\ComputeConstraintMultiplier\) and setting them to zero yields: \[ \frac{\partial \ComputeConstrainedLagrangian}{\partial \Parameters} = -\ParameterScalingExponent \ParameterScaleCoefficient \Parameters^{-\ParameterScalingExponent- 1} + 6 \ComputeConstraintMultiplier \DatasetSize= 0 \implies \ParameterScalingExponent \ParameterScaleCoefficient \Parameters^{-\ParameterScalingExponent- 1} = 6 \ComputeConstraintMultiplier \DatasetSize, \tag{1} \] \[ \frac{\partial \ComputeConstrainedLagrangian}{\partial \DatasetSize} = -\DataScalingExponent \DataScaleCoefficient \DatasetSize^{-\DataScalingExponent- 1} + 6 \ComputeConstraintMultiplier \Parameters= 0 \implies \DataScalingExponent \DataScaleCoefficient \DatasetSize^{-\DataScalingExponent- 1} = 6 \ComputeConstraintMultiplier \Parameters, \tag{2} \] \[ \frac{\partial \ComputeConstrainedLagrangian}{\partial \ComputeConstraintMultiplier} = 6 \Parameters \DatasetSize- \Operations_0 = 0. \tag{3} \]
Multiplying Equation (1) by \(\Parameters\) and Equation (2) by \(\DatasetSize\) gives: \[ \ParameterScalingExponent \ParameterScaleCoefficient \Parameters^{-\ParameterScalingExponent} = 6 \ComputeConstraintMultiplier \Parameters \DatasetSize, \] \[ \DataScalingExponent \DataScaleCoefficient \DatasetSize^{-\DataScalingExponent} = 6 \ComputeConstraintMultiplier \Parameters \DatasetSize. \]
Equating these expressions yields the power-law optimality condition: \[ \ParameterScalingExponent \ParameterScaleCoefficient \Parameters^{-\ParameterScalingExponent} = \DataScalingExponent \DataScaleCoefficient \DatasetSize^{-\DataScalingExponent}. \] This condition states that at the compute-optimal allocation, the marginal loss reduction per fractional increase in parameter count must equal the marginal loss reduction per fractional increase in dataset tokens.
Compute-optimal exponents
From \(\ParameterScalingExponent \ParameterScaleCoefficient \Parameters^{-\ParameterScalingExponent} = \DataScalingExponent \DataScaleCoefficient \DatasetSize^{-\DataScalingExponent}\) , solving for \(\DatasetSize\) in terms of \(\Parameters\) yields: \[ \DatasetSize^\DataScalingExponent= \left(\frac{\DataScalingExponent \DataScaleCoefficient}{\ParameterScalingExponent \ParameterScaleCoefficient}\right) \Parameters^\ParameterScalingExponent\implies \DatasetSize= \left(\frac{\DataScalingExponent \DataScaleCoefficient}{\ParameterScalingExponent \ParameterScaleCoefficient}\right)^{1/\DataScalingExponent} \Parameters^{\ParameterScalingExponent/\DataScalingExponent}. \]
Substituting \(\DatasetSize\) into the compute constraint \(\Operations= 6 \Parameters \DatasetSize\) gives: \[ \Operations= 6 \Parameters\left(\frac{\DataScalingExponent \DataScaleCoefficient}{\ParameterScalingExponent \ParameterScaleCoefficient}\right)^{1/\DataScalingExponent} \Parameters^{\ParameterScalingExponent/\DataScalingExponent} = 6 \left(\frac{\DataScalingExponent \DataScaleCoefficient}{\ParameterScalingExponent \ParameterScaleCoefficient}\right)^{1/\DataScalingExponent} \Parameters^{\frac{\ParameterScalingExponent+ \DataScalingExponent}{\DataScalingExponent}}. \]
Solving explicitly for the compute-optimal parameter count \(\Parameters^*(\Operations)\) : \[ \Parameters^*(\Operations) = \left( \frac{\ParameterScalingExponent \ParameterScaleCoefficient}{\DataScalingExponent \DataScaleCoefficient} \right)^{\frac{1}{\ParameterScalingExponent+ \DataScalingExponent}} \left( \frac{\Operations}{6} \right)^{\frac{\DataScalingExponent}{\ParameterScalingExponent+ \DataScalingExponent}} \propto \Operations^{\frac{\DataScalingExponent}{\ParameterScalingExponent+ \DataScalingExponent}}. \]
By symmetry, solving for the compute-optimal token count \(\DatasetSize^*(\Operations)\) yields: \[ \DatasetSize^*(\Operations) = \left( \frac{\DataScalingExponent \DataScaleCoefficient}{\ParameterScalingExponent \ParameterScaleCoefficient} \right)^{\frac{1}{\ParameterScalingExponent+ \DataScalingExponent}} \left( \frac{\Operations}{6} \right)^{\frac{\ParameterScalingExponent}{\ParameterScalingExponent+ \DataScalingExponent}} \propto \Operations^{\frac{\ParameterScalingExponent}{\ParameterScalingExponent+ \DataScalingExponent}}. \]
Empirical exponents and the \(\DatasetSize/\Parameters\approx 20\) rule
Fitting the parametric loss surface to over 400 experimental runs, Hoffmann et al. (2022 ) estimated \(\ParameterScalingExponent\approx 0.34\) and \(\DataScalingExponent\approx 0.28\) . Substituting these values gives exponents close to the paper’s parametric-model result:
\[ \frac{\DataScalingExponent}{\ParameterScalingExponent+ \DataScalingExponent} \approx 0.45, \qquad \frac{\ParameterScalingExponent}{\ParameterScalingExponent+ \DataScalingExponent} \approx 0.55 \]
Thus the parametric model predicts: \[ \Parameters^*(\Operations) \propto \Operations^{0.45}, \qquad \DatasetSize^*(\Operations) \propto \Operations^{0.55} \]
The paper’s two direct empirical approaches report near-balanced exponents of \((0.50, 0.50)\) and \((0.49, 0.51)\) , which motivate the common square-root shorthand. Under the parametric fit, however, \(\DatasetSize^*/\Parameters^*\) grows slowly with compute rather than remaining strictly constant. Across the regime studied, roughly 20 training tokens per parameter is a useful Chinchilla heuristic, not a universal invariant.
Systems Perspective 1.5: Kaplan vs. Chinchilla scaling
The difference between Kaplan et al. (2020 ) and Hoffmann et al. (2022 ) shows how the training schedule used in empirical fits can alter system design conclusions:
Kaplan scaling model : Kaplan et al. (2020 ) fit a different loss form with its own exponents and reported compute-optimal growth of \(\Parameters\propto \Operations^{0.73}\) and \(\DatasetSize\propto \Operations^{0.27}\) . This split does not follow from substituting exponents into the two-term surface above. Kaplan’s split led the field to scale model sizes aggressively while holding training dataset sizes relatively small (e.g., GPT-3 175B trained on 300B tokens, giving \(\DatasetSize/\Parameters=\) 1.71).
Methodological divergence : Kaplan et al. (2020 ) used a fixed token budget and learning-rate schedule across models. Hoffmann et al. (2022 ) matched the schedule to each training horizon and found that the earlier setup understated the value of training smaller models on more data.
Chinchilla revision : Hoffmann et al. (2022 ) found near-balanced parameter and token scaling: its three approaches report exponent pairs of \((0.50, 0.50)\) , \((0.49, 0.51)\) , and \((0.46, 0.54)\) rather than one exact universal ratio.
Practical impact : Chinchilla (70B parameters trained on 1.4T tokens, \(\DatasetSize/\Parameters=\) 20) outperformed GPT-3 (175B parameters trained on 300B tokens) across downstream benchmarks while requiring 2.5× less compute during inference (inference cost scales with parameter count) and 2.5× lower weight memory at the same precision (Hoffmann et al. 2022 ) .
Hoffmann, Jordan, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya, Trevor Cai, Eliza Rutherford, Diego de Las Casas, et al. 2022. “Training Compute-Optimal Large Language Models.” Advances in Neural Information Processing Systems (NeurIPS) 35: 30016–30. https://doi.org/10.52202/068431-2176.
Kaplan, Jared, Sam McCandlish, Tom Henighan, Tom B. Brown, Benjamin Chess, Rewon Child, Scott Gray, Alec Radford, Jeffrey Wu, and Dario Amodei. 2020. “Scaling Laws for Neural Language Models.” ArXiv Preprint abs/2001.08361.
Together, the three derivations bound the algorithmic costs that govern training at scale: reverse-mode differentiation keeps gradient compute within a small constant factor of the forward pass, tiled online softmax keeps attention memory traffic from growing quadratically in HBM, and constrained loss minimization balances parameter count against training tokens for a fixed FLOP budget.
Summary
An algorithm becomes a systems workload through its shapes, operation graph, data dependencies, and numerical representation. Linear-algebra primitives, memory layouts, broadcasting, and sparse formats determine work, traffic, locality, and usable parallelism. Automatic differentiation and backpropagation add saved activations and backward computation. Computational graphs then expose opportunities for fusion and recomputation, and the log-sum-exp shift keeps the softmax at the loss finite in reduced precision. Among the derivations, the Baur–Strassen result bounds reverse-mode overhead, while FlashAttention shows how tiling and an online recurrence can reduce HBM traffic without changing attention semantics.
The same accounting connects kernels to scaling decisions. Compute-optimal scaling turns a fixed budget into a model-data allocation, but the fitted exponents remain empirical rather than universal. Before selecting an optimization, count the operations, the bytes moved, and the state saved for the backward pass.
Back to top