Alphabeta Math
ExampleConstruction: Literature-sourcedVerification: AI-adaptedPipeline-generated
How statement and proof provenance work

The first chip identifies the source of the statement or construction; the second identifies the source of its local proof or verification.

  • Literature-sourced: the exact statement appears in a cited source; only wording and notation differ.
  • AI-adapted: a semantically identical restatement of literature-sourced material, modulo indexing, notation, and boundary cases adopted by the library.
  • AI-generated: a genuinely novel statement formulated by AI, with no source for the claim itself.

These labels describe origin, not correctness: citations and verification chips remain separate evidence.

SVRG and SAGA gradient-work and storage ledger

Statement

Let a finite sum have n,d≥1 components and dimension, and let an SVRG epoch and SAGA block each have m≥1 inner updates. Count component-gradient evaluations separately from scalar coordinate arithmetic, and do not cache SVRG snapshot gradients. SVRG uses n+2m component-gradient evaluations per epoch, O(nd) arithmetic to assemble its full gradient, O(d) arithmetic per inner update, and O(d) working storage. SAGA uses n+m component-gradient evaluations during its initialized block and m new evaluations in each later equally long block; initializing its mean takes O(nd) arithmetic, each later update takes O(d) arithmetic, and its table plus auxiliary vectors use O(nd) storage. The cost of evaluating a component gradient is not bounded here. For n=1000, d=20, and m=2n=2000, the gradient counts are 5000 SVRG evaluations per epoch, 3000 SAGA evaluations in the initial block, and 2000 in a later block; the SAGA table has 20,000 scalar coordinates.

Facts & Assumptions

Given: The component count, dimension, horizon, and algorithms in the Statement.

[F1]

Finite-sum SVRG: the procedure computes the full finite-sum gradient, evaluates both displayed component gradients at every inner update without caching snapshot values, and uses a fixed number of vector additions, scalings, and temporaries per update.

[F2]

Finite-sum SAGA: initialization evaluates one component gradient for each table entry and forms their running mean; each later update evaluates one sampled component gradient once and reuses it for the estimator and replacement, with a fixed number of vector operations and temporary d-vectors.

[F3]

Finite sums and finite products, by recursion: the finite objective contains exactly n component functions.

Proof

Given: n,d≥1, an epoch and blocks of length m≥1, and the displayed finite-sum algorithms. The numerical instance is n=1000, d=20, and m=2n=2000.

1.1F1F2F3givenalgebra

By [F1] and [F3], one full gradient evaluates each of the n component gradients once, and each of the m inner updates evaluates two component gradients, so SVRG uses n+2m evaluations. By [F2], SAGA initializes all n table entries and evaluates one sampled component per update, so its initialized block uses n+m evaluations and a later block uses m. Substitution of n=1000 and m=2000 gives 5000, 3000, and 2000, respectively.

1.2F1F2F3givenalgebra

A full gradient sums and scales n vectors with d coordinates, using O(nd) coordinate operations; each update in [F1] has a fixed number of vector operations and therefore costs O(d). SAGA's initialization forms the table mean from n vectors for O(nd) coordinate operations, and each update in [F2] uses a fixed number of vector operations for O(d).

2.1F1F2givenalgebra∎

For SVRG, sample the independent uniform output index J before the epoch and save xJ when that index is reached, including x0 if J=0. The inner updates do not use J, so independence gives the same joint law of J and the trajectory, and hence the same returned-snapshot law as sampling J after the updates. This implementation needs one saved d-vector in addition to the fixed update buffers in [F1], uses no extra gradient evaluations, and therefore has O(d) working storage. By [F2], SAGA stores n table vectors and a constant number of additional d-vectors, giving nd+O(d)=O(nd) scalars because n≥1. At the numerical instance the table itself contains 1000⋅20=20,000 coordinates. The accounting excludes arithmetic within each component-gradient evaluation and makes no total-runtime claim.

Depends on

Used by

Nothing in the library uses this result yet.

Dependency tree · two levels

19 results within two dependency steps of this one, each drawn at its shortest distance from it. An arrow runs from a result to what uses it, so the chart reads left to right and ends at this result, which carries a heavier outline. Every node is a link to that result. Click elsewhere on the chart to enlarge it.

Sources