ArcGD Optimiser: Phase-Aware Gradient Descent

• ArcGD Optimiser is an optimization algorithm based on arc-length principles with phase-aware, user-controlled dynamics to prevent overshooting and stalling in non-convex landscapes.
• Its three-phase update mechanism—exploration, transition, and vanishing phases—ensures bounded updates, smooth acceleration, and minimum progress in low-gradient zones.
• Empirical results across benchmarks show ArcGD achieves faster convergence, reduced overfitting, and enhanced generalization compared to Adam and other traditional optimizers.

Arc Gradient Descent (ArcGD) is an optimization algorithm derived from a mathematical reformulation of classical gradient descent. Employing an arc-length principle and phase-aware, user-controlled step dynamics, ArcGD constrains parameter updates within tunable bounds to address issues of overshooting in high-gradient regions and stalling near critical points. The method was formally derived, implemented, and empirically evaluated across highly non-convex optimization landscapes and standard deep-learning benchmarks. Notably, ArcGD embodies a spectrum of behaviors interpolating between classical gradient descent and sign-based optimizers, and connects to the Lion optimizer in special cases (Verma et al., 7 Dec 2025).

1. Mathematical Formulation

The core of ArcGD is a mathematically grounded step size schedule based on the arc length of the loss function. For a one-dimensional differentiable function $f(x)$, the arc length is

$s = \int \sqrt{1 + [f'(x)]^2}\, dx.$

Discretization over a small step $\Delta x$ yields

$\Delta s \approx \Delta x\, \sqrt{1 + [f'(x)]^2}.$

Enforcing an upper bound on the arc-length increment, $\Delta s \approx a |f'(x)|$, with a ceiling $a \ll 1$, gives the elementwise update rule

$\Delta x = -a\, \frac{g}{\sqrt{1 + g^2}}$

where $g \equiv f'(x)$. Generalizing to the multidimensional case, the algorithm applies this update per parameter dimension.

To address near-zero gradients and inertial regions, the update comprises three phases—each regulated by user-controlled parameters $(a,b,c)$ decomposing the total step ceiling:

$$\Delta x = -\left[a T + b T (1 - |T|) + c\, \text{sign}(T) (1 - |T|)\right],$$

where $s = \int \sqrt{1 + [f'(x)]^2}\, dx.$0. The terms represent:

• High-phase: $s = \int \sqrt{1 + [f'(x)]^2}\, dx.$1 for $s = \int \sqrt{1 + [f'(x)]^2}\, dx.$2 (bounded ceiling).
• Transition-phase: $s = \int \sqrt{1 + [f'(x)]^2}\, dx.$3 for moderate $s = \int \sqrt{1 + [f'(x)]^2}\, dx.$4, shaping mid-range step.
• Low-phase: $s = \int \sqrt{1 + [f'(x)]^2}\, dx.$5, enforcing a nonzero lower bound in vanishing-gradient regimes.

An adaptive floor variant is also provided to prevent divergence of the low-phase term:

$s = \int \sqrt{1 + [f'(x)]^2}\, dx.$6

and the update becomes

$s = \int \sqrt{1 + [f'(x)]^2}\, dx.$7

2. Algorithmic Procedure

ArcGD uses a simultaneous, component-wise update. The procedure is as follows:

• Inputs: Initial parameters $s = \int \sqrt{1 + [f'(x)]^2}\, dx.$8, hyperparameters $s = \int \sqrt{1 + [f'(x)]^2}\, dx.$9, $\Delta x$0, $\Delta x$1, and optionally $\Delta x$2 for moving-averaged gradients and $\Delta x$3 for adaptive $\Delta x$4.
• Iterative update: At each step, compute the gradient $\Delta x$5; if using the noisy-variant, replace $\Delta x$6 by an exponentially weighted moving average.
• For each parameter $\Delta x$7:
  • $\Delta x$8
  • Compute the phase-aware update $\Delta x$9 as per the full update rule
  • Optionally apply the adaptive floor for $\Delta s \approx \Delta x\, \sqrt{1 + [f'(x)]^2}.$0
• Update all parameters: $\Delta s \approx \Delta x\, \sqrt{1 + [f'(x)]^2}.$1

Pseudocode (verbatim, see (Verma et al., 7 Dec 2025)):

$g \equiv f'(x)$2

3. Phase-Aware Step Dynamics and User Control

ArcGD explicitly partitions the update regime into three dynamically weighted phases determined by the normalized gradient $\Delta s \approx \Delta x\, \sqrt{1 + [f'(x)]^2}.$2.

• Exploration (Saturation) Phase: $\Delta s \approx \Delta x\, \sqrt{1 + [f'(x)]^2}.$3. The update is capped by $\Delta s \approx \Delta x\, \sqrt{1 + [f'(x)]^2}.$4, implementing a hard ceiling.
• Transition Phase: For moderate gradients ($\Delta s \approx \Delta x\, \sqrt{1 + [f'(x)]^2}.$5), the $\Delta s \approx \Delta x\, \sqrt{1 + [f'(x)]^2}.$6-term facilitates smooth nonlinearity in update magnitude.
• Vanishing Phase: For $\Delta s \approx \Delta x\, \sqrt{1 + [f'(x)]^2}.$7, the $\Delta s \approx \Delta x\, \sqrt{1 + [f'(x)]^2}.$8-term enforces a nonzero floor, guaranteeing minimum progress when gradients are nearly vanishing.

User control is provided via the parameters:

• Increasing $\Delta s \approx \Delta x\, \sqrt{1 + [f'(x)]^2}.$9 raises the ceiling (maximum step).
• Adjusting $\Delta s \approx a |f'(x)|$0 modifies the nonlinearity and acceleration in transition.
• Setting $\Delta s \approx a |f'(x)|$1 or $\Delta s \approx a |f'(x)|$2 tunes stalling resistance at small gradients.

4. Hyperparameter Selection and Implementation Guidelines

Default values for general tasks are:

Parameter	Default Value	Role
$\Delta s \approx a |f'(x)|$3	$\Delta s \approx a |f'(x)|$4	Ceiling
$\Delta s \approx a |f'(x)|$5	$\Delta s \approx a |f'(x)|$6	Transition
$\Delta s \approx a |f'(x)|$7	$\Delta s \approx a |f'(x)|$8	Floor
$\Delta s \approx a |f'(x)|$9	$a \ll 1$0	Gradient moving average
$a \ll 1$1	$a \ll 1$2	Adaptive $a \ll 1$3 (optional)

• Ensure $a \ll 1$4 for stability: $a \ll 1$5.
• Set $a \ll 1$6 to prevent domination by the floor.
• For aggressive stalling prevention, $a \ll 1$7; for conservative, $a \ll 1$8.

Initialization uses standard neural network schemes (e.g. He-normal), with $a \ll 1$9 selected uniformly in an appropriate range.

5. Empirical Evaluation and Comparative Performance

5.1 Stochastic Rosenbrock Benchmark

ArcGD was benchmarked against Adam on a noisy, non-convex Rosenbrock function across dimensions $\Delta x = -a\, \frac{g}{\sqrt{1 + g^2}}$0. Two protocol configurations eliminated learning-rate bias: (A) matched effective learning rates; (B) both using Adam's default.

Dim	Adam conv.%	ArcGD conv.%	Avg iters (Adam/ArcGD)	Avg time (s) (Adam/ArcGD)
2	100%	100%	9,440 / 2,802	0.47 / 0.15
10	60%	80%	11,370 / 2,897	0.85 / 0.25
100	90%	90%	13,432 / 4,378	1.29 / 0.40
1,000	90%	100%	15,658 / 9,197	1.99 / 1.22
50,000	0%	100%	– / 22,993	– / 104.4

ArcGD demonstrated superior speed, reliability, and precision, especially as dimensionality increased. For smaller default rates (Config B), ArcGD produced more precise solutions at the cost of increased iterations in high dimension.

5.2 CIFAR-10 Neural Network Benchmark

Eight MLPs of 1–5 hidden layers (parameters: $\Delta x = -a\, \frac{g}{\sqrt{1 + g^2}}$1–$\Delta x = -a\, \frac{g}{\sqrt{1 + g^2}}$2) were trained on CIFAR-10, comparing ArcGD to Adam, AdamW, Lion, and SGD. Average test accuracy:

Optimiser	5,000 iters	20,000 iters
ArcGD	48.4	50.7
Adam	47.7	46.6
AdamW	47.6	46.8
Lion	42.7	43.3
SGD	44.1	49.6

Adam and AdamW showed early rapid convergence (5,000 iterations) but regressed at 20,000 due to overfitting. ArcGD continued improving throughout training ($\Delta x = -a\, \frac{g}{\sqrt{1 + g^2}}$3 on average), requiring no early stopping tuning, and delivered highest accuracy on six out of eight architectures at the late stage. This suggests greater resistance to overfitting and enhanced generalization without hyperparameter tuning for training duration.

6. Connections to the Lion Optimiser

A variant of ArcGD recovers the Lion optimizer's behavior. By omitting the transition-phase ($\Delta x = -a\, \frac{g}{\sqrt{1 + g^2}}$4) and setting $\Delta x = -a\, \frac{g}{\sqrt{1 + g^2}}$5,

$\Delta x = -a\, \frac{g}{\sqrt{1 + g^2}}$6

which, in the regime $\Delta x = -a\, \frac{g}{\sqrt{1 + g^2}}$7, yields

$\Delta x = -a\, \frac{g}{\sqrt{1 + g^2}}$8

matching the core Lion sign-momentum update when $\Delta x = -a\, \frac{g}{\sqrt{1 + g^2}}$9 is replaced by a momentum-accumulated gradient ($g \equiv f'(x)$0, $g \equiv f'(x)$1; see Chen et al. 2023). This unifies ArcGD's bounded ceiling/floor approach with Lion’s sign-based step rule, highlighting structural correspondence between the optimizers (Verma et al., 7 Dec 2025).