Alphabeta Math
Pipeline-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.

✓ 3 results · all verified · 3 also independently AI-judged
Every result on this page is machine-checked by a proof checker and read in full and owner-audited; the judge is an additional, independent cross-model AI review of the proofs; all 3 also cleared it.

Parallel in time parareal and mgrit

1 · Prerequisites

2 · Summary

Summary

Parareal corrects a serial coarse trajectory with parallel fine propagations. The canonical ODE instantiation uses explicit Runge–Kutta microsteps for the fine map and a selected successful backward Euler endpoint for the coarse map. Its exact-arithmetic recurrence reproduces the first k fine nodes after k sweeps. Under common-set Lipschitz bounds it has a binomial error estimate; any inexact propagation or correction contributes an explicit update defect. The target is the sequential fine-method trajectory. A separate fine-method estimate is required to compare that trajectory with an exact ODE solution.

MGRIT writes a linear time recurrence as an all-at-once bidiagonal system, eliminates F-points to identify the exact coarse Schur operator, and defines a practical two-level coarse correction with F or FCF relaxation. A two-grid cycle contracts only when its actual error matrix has norm below one in the declared block norm; residual/error comparison also assumes finite induced norms for the fine operator and its inverse. The local scalar heat calculation is not a general rate, and the two-grid theorem does not establish multilevel convergence. Work and span depend on propagator costs, processor count, communication, cycle count, and all visited levels.

3 · Logical flowchart

4 · Definitions, theorems and proofs

DefinitionDefinition: Literature-sourcedProof: Not applicableOpen item page →

Fine and coarse propagators on a common macro grid

Definition

Let d,N≥1, let X=Rd, and fix macro times t0<t1<⋯<tN. A fine/coarse propagator pair is a pair of deterministic maps Fn:DnF→X and Gn:DnG→X, for each 0≤n<N, where DnF,DnG⊆X are their admitted input sets. Both maps advance a state across the same interval [tn,tn+1]. The labels fine and coarse identify the two roles chosen by the user; they assert no accuracy, stability, cost, or convergence property.

For an initial state x0∈X, whenever every call succeeds, the sequential fine trajectory is the finite sequence xn+1=Fn(xn), and the sequential coarse trajectory is defined by replacing each Fn with Gn. A partially defined map is unavailable outside its admitted set; a failed stage evaluation or an unavailable implicit branch is a propagation failure, not a numerical value.

A canonical ODE instantiation uses the explicit Runge–Kutta stage map of Explicit Runge–Kutta tableaus, stage maps, and failure status for r≥1 fine substeps of size (tn+1−tn)/r, composed in order to form Fn. A coarse backward Euler value is an endpoint z satisfying the equation in Backward Euler step equation and algebraic residual over the full macro interval. Its branch selector is part of the input and must select exactly one admissible root for each admitted start state; if no such selected root exists, the coarse map is unavailable. The backward Euler definition alone asserts neither root existence nor uniqueness.

This definition distinguishes the sequential fine trajectory from samples of an exact ODE solution. Any estimate of the fine method's error relative to that exact solution is a separate obligation.

AlgorithmAlgorithm: AI-adaptedProof: Not applicablejudge pass (gpt-6-luna)Open item page →

Finite-budget Parareal correction sweeps

Definition

Input: an admissible propagator pair from Fine and coarse propagators on a common macro grid, initial state x0, number of macro intervals N, integer sweep budget K≥0, and optionally a wall-clock budget τ≥0 and certificate data (C,c,Q,V). Here c∈C is a supplied certificate, Q is a declared predicate on completed rows, and V(W,c) is a supplied deterministic verifier that terminates with a Boolean for every completed row W and satisfies V(W,c)=true⇒Q(W). Without certificate data, take V to return false. Every map call is required to terminate with a state or declared failure. Each map call either returns one state or a declared failure status. The output contains every fully completed row of the table Unk for 0≤k≤K, the last completed endpoint when one exists, and a status. If initialization never completes, return an empty completed-row table and no endpoint.

Initialize U00=x0 and, in increasing order of n, set Un+10=Gn(Un0). Store the values Gn(Un0). For each k=0,…,K−1, set U0k+1=x0. Evaluate Fn(Unk) independently for all n; the stored Gn(Unk) values are reused from the preceding row. Then, in increasing order of n, compute Gn(Unk+1) and set Un+1k+1=Gn(Unk+1)+Fn(Unk)−Gn(Unk). The fine calls in a sweep can run in parallel, while the corrected row is computed sequentially.

If a map call fails, return the last fully completed row and status propagation-failure; a prefix of the failed row may be reported separately but is not a completed iterate. If the time budget expires at a call boundary, return the last fully completed row and status budget-exhausted. When initialization and all K requested sweeps finish, call V on the final row and c (or use false when no certificate was supplied). Return status converged if this returns true, certifying the declared predicate Q; otherwise return status budget-exhausted. Completion of the finite budget alone is not a convergence certificate.

For the exact-arithmetic recurrence, an update computed with inexact fine/coarse values or an inexact correction solve can be written as the displayed right-hand side plus a combined defect ηnk+1. A residual tolerance alone does not bound that defect in forward error.

DefinitionDefinition: Literature-sourcedProof: Not applicableOpen item page →

The all-at-once bidiagonal time operator and C/F points

Definition

Let d,N≥1, let Φi∈Rd×d for 1≤i≤N, and let u0∈Rd be fixed. The linear part of a fine propagator in Fine and coarse propagators on a common macro grid is represented by Φi. For forcing vectors gi∈Rd, write the fine recurrence as ui=Φiui−1+gi. On the unknown vector v=(v1,…,vN)∈(Rd)N, define At by (Atv)1=v1 and (Atv)i=vi−Φivi−1 for 2≤i≤N. With b1=Φ1u0+g1 and bi=gi for i≥2, the recurrence is exactly Atv=b.

For a coarsening factor m≥2 dividing N, the coarse indices are 0,m,2m,…,N. Among unknowns, let C={m,2m,…,N} and F={1,…,N}∖C. Reordering the unknown vector as (vF,vC) gives At=(AFFAFCACFACC). A practical coarse propagator Ψj on each interval is the linear subcase of the coarse maps Gn in Fine and coarse propagators on a common macro grid; the exact coarse operator is determined by eliminating F-points and is not generally the same as this practical choice. This definition asserts no stability or convergence property.

LemmaStatement: Literature-sourcedProof: AI-generatedjudge pass (gpt-6-luna)Open item page →

Parareal reproduces the first k fine-grid nodes after k sweeps

Statement

For the exact-arithmetic recurrence in Finite-budget Parareal correction sweeps, let x0 be the initial state and xn+1=Fn(xn) its sequential fine trajectory. For every completed sweep k and every 0≤n≤min⁡{k,N}, Unk=xn. Consequently, if the requested sweep budget K≥N is fully completed, the returned table contains the complete sequential fine trajectory in row K.

Facts & Assumptions

Given: The exact-arithmetic recurrence is defined on the rows considered; each row called completed is formed from successful evaluations.

[F1]

Fine and coarse propagators on a common macro grid: the sequential fine trajectory is xn+1=Fn(xn) from x0.

[F2]

Finite-budget Parareal correction sweeps: U0k=x0 for every sweep, the initial row is coarse-propagated, and each correction is Un+1k+1=Gn(Unk+1)+Fn(Unk)−Gn(Unk). The algorithm returns every fully completed row and may stop early after a propagation failure or time-budget expiry.

Proof

1.1givenF1F2algebra

At sweep k=0, the only claimed node is n=0, and U00=x0=x0 by initialization and the definition of the fine trajectory [F1].

1.2givenF1F2inductionalgebra

Suppose the claim holds at sweep k. At sweep k+1, U0k+1=x0 by [F2]. Induct on n from 0 to min⁡{k,N−1}; if Unk+1=xn, then n≤k also gives Unk=xn, so [F2] yields Un+1k+1=Gn(xn)+Fn(xn)−Gn(xn)=Fn(xn)=xn+1 by [F1]. Thus the claim holds through node min⁡{k+1,N}.

2.1F2step 1.2inductionalgebra∎

Induction on k proves the first assertion. If the requested rows 0,…,K all complete and K≥N, applying it at k=K gives UnK=xn for every 0≤n≤N; by [F2], row K is in the returned table.

TheoremStatement: AI-adaptedProof: AI-generatedjudge pass (gpt-6-luna)Open item page →

A conditional binomial error bound for Parareal

Statement

Let xn+1=Fn(xn) be the sequential fine trajectory and let Unk be the exact-arithmetic table from Finite-budget Parareal correction sweeps. Let D⊆X contain every xn and every iterate used in the requested sweeps. Suppose constants a,b,M≥0 satisfy, for every 0≤n<N and u,v∈D, ∥Gn(u)−Gn(v)∥≤a∥u−v∥,∥(Fn−Gn)(u)−(Fn−Gn)(v)∥≤b∥u−v∥, and ∥Un0−xn∥≤M for all 0≤n≤N. Use (nk) for the number of k-element subsets of an n-element set, set it to 0 for k>n, and put A=max⁡{1,a}. Then for every node 0≤n≤N and completed sweep k≥0, ∥Unk−xn∥≤M(nk)Anbk, with b0=1. The hypotheses include all comparison points; invariance of D under Fn,Gn alone does not ensure that corrected iterates stay in D.

For a fixed horizon T=NH, suppose a≤1+CaH, b≤CbHq+1 for constants Ca,Cb≥0 and integer q≥1, and one M works uniformly as N varies. Then, for each fixed k≤N, ∥UNk−xN∥≤M(CbT)kexp⁡(CaT)Hqk. Thus the exact-solve error is O(Hqk) at each fixed iteration k under these uniform assumptions. Neither estimate includes finite-solver error; that effect requires a separate update-defect analysis.

Facts & Assumptions

Given: The exact Parareal recurrence, its sequential fine trajectory, a common comparison set, and the stated Lipschitz and initial-error bounds.

[F1]

Fine and coarse propagators on a common macro grid: the sequential fine trajectory is xn+1=Fn(xn) from x0.

[F2]

Finite-budget Parareal correction sweeps: U0k=x0 and Un+1k+1=Gn(Unk+1)+Fn(Unk)−Gn(Unk).

[F3]

A norm on a real vector space, the induced metric, and the dictionary with the metric axioms: the norm satisfies ∥u+v∥≤∥u∥+∥v∥.

[F5]

The exponential addition formula exp⁡(x+y)=exp⁡(x)exp⁡(y): exp⁡(u+v)=exp⁡(u)exp⁡(v) for real u,v.

[F6]

The real exponential function and the number e by a power series: for every real x, exp⁡(x) is defined by the convergent series ∑n=0∞xn/n!.

[A1]

All fine and coarse evaluations are exact and defined, all comparison points lie in D, the two Lipschitz inequalities hold on D, and the coarse initial-row errors are at most M.

[A2]

In the fixed-horizon branch, H=T/N, T>0, a≤1+CaH, b≤CbHq+1, q≥1, and the envelope M is independent of N.

Proof

1.1givenF1F2F3A1algebra

Put enk=Unk−xn. Subtract xn+1=Fn(xn) from the recurrence in [F2] and add and subtract Gn(xn); this gives en+1k+1=Gn(Unk+1)−Gn(xn)+(Fn−Gn)(Unk)−(Fn−Gn)(xn). By [A1] and the triangle inequality in [F3], En+1k+1≤aEnk+1+bEnk, where Enk=∥enk∥.

1.2F2A1induction

At node 0, E0k=0 for every k by [F2]. At sweep k=0, [A1] gives En0≤M≤MAn. These are the initial cases for induction on the node, simultaneously over all completed sweeps.

2.1step 1.1step 1.2A1inductionalgebra

Assume the bound holds at node n. For the level-zero row at node n+1, [A1] gives En+10≤M≤MAn+1. For each k≥0, [step 1.1] gives En+1k+1≤MAnbk+1(a(nk+1)+(nk))≤MAn+1bk+1((nk+1)+(nk)). The last inequality uses a≤A and 1≤A. Partitioning the (k+1)-element subsets of an (n+1)-element set according to whether they contain its final element gives (nk+1)+(nk)=(n+1k+1), including the zero convention. Thus the bound holds at node n+1, and induction proves the first estimate.

3.1A2F4F5F6step 2.1constructalgebra∎

In the fixed-horizon branch, A≤1+CaH≤exp⁡(CaH) by [A2], [F4], and the definition of exp⁡ in [F6]. Repeated use of [F5] gives AN≤exp⁡(CaNH)=exp⁡(CaT). Each k-element subset of an N-element set has a unique increasing k-tuple, so (Nk)≤Nk. Substituting these bounds and b≤CbHq+1 into the first estimate gives ∥UNk−xN∥≤MNkexp⁡(CaT)(CbHq+1)k=M(CbT)kexp⁡(CaT)Hqk. For fixed T,k and uniform M, this is O(Hqk).

LemmaStatement: Literature-sourcedProof: AI-generatedjudge pass (gpt-6-luna)Open item page →

Eliminating F-points gives the exact coarse time operator

Statement

Use The all-at-once bidiagonal time operator and C/F points with N=Jm, m≥2, and its F/C partition. Both At and AFF are invertible. Eliminating the F unknowns from Atv=b gives the coarse system with Schur complement S=ACC−ACFAFF−1AFC. On coarse interval j, its recurrence is ujm−(ΦjmΦjm−1⋯Φ(j−1)m+1)u(j−1)m=gˉj, where gˉj=∑s=1m(ΦjmΦjm−1⋯Φ(j−1)m+s+1)g(j−1)m+s, with an empty product defined to be the identity. If Φi=Φ for every fine step, the exact coarse propagator is Φm.

Facts & Assumptions

Given: The finite fine recurrence, its all-at-once block matrix, and the C/F partition.

[F1]

The all-at-once bidiagonal time operator and C/F points: the fine equations are ui−Φiui−1=gi with identity diagonal blocks, and C={m,2m,…,N}.

Proof

1.1givenF1constructinduction

For any right-hand side, solve the fine equations in increasing index: the first unknown is determined by its identity diagonal block, and each later unknown is uniquely ui=ri+Φiui−1. This proves At is invertible. Holding all C-values fixed, the F-equations in each interval between consecutive C-points have the same forward-substitution form with identity diagonal blocks, so they uniquely determine the F-values; hence AFF is invertible.

2.1givenF1step 1.1algebra

In the reordered block system, the F rows give uF=AFF−1(bF−AFCuC). Substituting this expression in the C rows gives (ACC−ACFAFF−1AFC)uC=bC−ACFAFF−1bF. Conversely, any solution uC of this coarse system, together with the displayed formula for uF, satisfies both the F and C rows. Thus elimination preserves exactly the solution set.

3.1F1step 2.1inductionalgebra∎

Repeated substitution in ui=Φiui−1+gi, for i=(j−1)m+1,…,jm, gives ujm=(Φjm⋯Φ(j−1)m+1)u(j−1)m+∑s=1m(Φjm⋯Φ(j−1)m+s+1)g(j−1)m+s. For s=m the product is empty and equals I. This is exactly the coarse recurrence in the Statement; the coefficient product reduces to Φm when every Φi=Φ.

TheoremStatement: AI-adaptedProof: AI-generatedOpen item page →

An additive error ledger for inexact Parareal sweeps

Statement

Use the notation and Lipschitz hypotheses of A conditional binomial error bound for Parareal, with A=max⁡{1,a}. Let computed iterates Vnk∈D satisfy V0k=x0, ∥Vn0−xn∥≤M, and, for each requested correction, ∥Vn+1k+1−[Gn(Vnk+1)+(Fn−Gn)(Vnk)]∥≤η for a constant η≥0. Define Pnk=M(nk)Anbk and a nonnegative forcing array by R0k=0, Rn0=0, and Rn+1k+1=ARnk+1+bRnk+η. Then ∥Vnk−xn∥≤Pnk+Rnk for every completed node and sweep.

The base envelope M includes coarse-initialization error relative to the fine trajectory. The per-update defect η must bound the actual combined effect of fine/coarse evaluation errors and correction-solve error; a residual tolerance alone supplies no forward-error bound.

Facts & Assumptions

Given: The Parareal Lipschitz hypotheses, the stated computed recurrence defect, and the definitions of Pnk and Rnk.

[F1]

A conditional binomial error bound for Parareal: with A=max⁡{1,a}, the exact-arithmetic error is bounded by Pnk=M(nk)Anbk.

[A1]

Every computed comparison point lies in the common set on which the two Lipschitz bounds hold, and the combined update defect has norm at most η.

Proof

1.1givenA1algebra

Set enk=∥Vnk−xn∥. Subtracting xn+1=Fn(xn) from the computed recurrence, splitting off the update defect, and applying the two Lipschitz inequalities gives en+1k+1≤aenk+1+benk+η≤Aenk+1+benk+η.

1.2givenF1A1algebra

At node 0, e0k=0, P0k=0 for k>0, and R0k=0; at k=0, the base coarse-error assumption gives en0≤M≤Pn0+Rn0.

2.1F1A1step 1.1step 1.2inductionalgebra∎

Assume enk≤Pnk+Rnk at node n for every completed sweep. For k≥0, step 1.1 gives en+1k+1≤A(Pnk+1+Rnk+1)+b(Pnk+Rnk)+η. The P terms satisfy APnk+1+bPnk=MAnbk+1(A(nk+1)+(nk))≤MAn+1bk+1((nk+1)+(nk))=Pn+1k+1 because A≥1 and Pascal's identity holds. The remaining terms equal Rn+1k+1 by definition. Therefore the bound holds at node n+1; induction proves it for all nodes and sweeps.

AlgorithmAlgorithm: AI-adaptedProof: Not applicablejudge pass (gpt-6-luna)Open item page →

A declared two-level MGRIT coarse-correction cycle

Definition

Input: a linear fine-grid system Atu=b with N≥1 fine intervals as in The all-at-once bidiagonal time operator and C/F points, a coarsening factor m≥2 dividing N and its C/F partition as in Eliminating F-points gives the exact coarse time operator, practical coarse propagators Ψj∈Rd×d for 1≤j≤Nc:=N/m, an initial fine-grid iterate uin, pre- and post-relaxation choices from {F,FCF}, a real-valued norm on the fine-grid residual space as in A norm on a real vector space, the induced metric, and the dictionary with the metric axioms, a nonnegative integer cycle budget Jcyc, and a residual tolerance ε≥0. The symbol Jcyc is the number of permitted cycles; the coarse-interval count is Nc (the letter J in Eliminating F-points gives the exact coarse time operator denotes that lemma's coarse-interval count). The output is the last iterate, its residual norm, the number of completed cycles, and status converged or budget-exhausted.

In F/C ordering define ideal interpolation P and restriction R by P=[−AFF−1AFCIC],R=[−ACFAFF−1IC].

The exact coarse operator is the Schur complement RAtP=ACC−ACFAFF−1AFC from Eliminating F-points gives the exact coarse time operator. The practical correction matrix Ac has identity diagonal blocks and subdiagonal blocks −Ψj for 2≤j≤Nc; its first row corresponds to the fixed zero initial correction z0=0. For any right-hand side ρ, forward substitution uniquely solves Acz=ρ by setting z0=0 and, in increasing order for j=1,…,Nc, setting zj=ρj+Ψjzj−1. Thus Ac is invertible even when an individual Ψj is singular.

Define the relaxations on Atu=b as follows. An F-relaxation holds every C-value fixed and, for each coarse interval j=1,…,Nc, updates its F-indices i=(j−1)m+1,…,jm−1 in increasing order: set u1=b1 if i=1, and otherwise set ui=bi+Φiui−1. Different coarse intervals have independent F-updates and may be processed in parallel. A C-relaxation holds every F-value fixed and, for j=1,…,Nc in increasing order, sets ujm=bjm+Φjmujm−1; these C-updates are independent because m≥2 and each predecessor is an F-index. An FCF-relaxation applies F-relaxation, then C-relaxation, then F-relaxation. Each relaxation is a finite linear update; write Spre and Spost for the error maps of the selected pre- and post-relaxations.

For one cycle from a current iterate u, apply the selected pre-relaxation; form r=b−Atu and ρ=Rr; solve Acz=ρ by the forward substitution above; correct u←u+Pz; then apply the selected post-relaxation. The exact error-propagation matrix of this fixed cycle is E=Spost(I−PAc−1RAt)Spre.

Initialize u(0)=uin and compute ∥b−Atu(0)∥. If this is at most ε, return u(0), zero completed cycles, and status converged. Otherwise, for jcyc=1,…,Jcyc, perform one cycle, call the resulting iterate u(jcyc), and compute ∥b−Atu(jcyc)∥. If this norm is at most ε, return that iterate, jcyc completed cycles, and status converged; if not, continue. If all Jcyc cycles finish without this condition (including when Jcyc=0), return the last iterate, its residual norm, and status budget-exhausted. The matrix E describes exact arithmetic and exact coarse solves; inexact solves contribute an update defect that needs its own bound.

CorollaryStatement: AI-adaptedProof: AI-generatedOpen item page →

Separate Parareal iteration error from fine-method error

Statement

Let y:[0,T]→Rd solve a first-order initial-value problem as in First-order systems, initial value problems, and solutions on intervals, and let xn be the sequential fine trajectory from Fine and coarse propagators on a common macro grid on a grid 0=t0<⋯<tN=T. Suppose the inexact Parareal ledger gives ∥VnK−xn∥≤PnK+RnK, and suppose a separately established fine-method estimate gives ∥xn−y(tn)∥≤δF for some δF≥0 and every node. Then ∥VnK−y(tn)∥≤PnK+RnK+δF. The quantity δF must come from an independent analysis of the selected fine method and its hypotheses; this corollary does not prove a local defect, stability, or continuous-time error estimate.

Facts & Assumptions

Given: A continuous reference solution, the sequential fine trajectory, the Parareal update-defect ledger, and a separate uniform bound for the fine trajectory.

[F1]

First-order systems, initial value problems, and solutions on intervals: an ODE solution is defined on an interval, stays in its open time-state domain, and satisfies the differential equation there.

[F2]

Fine and coarse propagators on a common macro grid: the sequential fine trajectory is xn+1=Fn(xn) from x0.

[F3]

An additive error ledger for inexact Parareal sweeps: ∥VnK−xn∥≤PnK+RnK.

[A1]

The separate fine-method estimate is ∥xn−y(tn)∥≤δF for every grid node.

Proof

1.1F1F2A1F3algebra

By [F2], xn is the sequential fine node; since tn∈[0,T], [F1] gives the solution value y(tn). Insert and subtract xn and apply the norm triangle inequality: ∥VnK−y(tn)∥≤∥VnK−xn∥+∥xn−y(tn)∥.

2.1givenA1F3step 1.1algebra∎

Substitute the two given bounds from [A1] and [F3]. This gives the displayed conclusion, while leaving δF as a separate fine-method obligation.

TheoremStatement: AI-adaptedProof: AI-generatedjudge pass (gpt-6-luna)Open item page →

A verified MGRIT error-matrix contraction controls error and residual

Statement

Let Atu∗=b be the fine-grid system from The all-at-once bidiagonal time operator and C/F points. By Eliminating F-points gives the exact coarse time operator, At is invertible. Let E be the exact error matrix for one fixed two-level cycle in A declared two-level MGRIT coarse-correction cycle. Choose a real-valued norm ∥⋅∥ on (Rd)N and define its induced operator norm by ∥T∥=sup⁡v≠0∥Tv∥/∥v∥. Assume ∥At∥ and ∥At−1∥ are finite for this norm. If a direct calculation or other proof establishes ∥E∥≤q<1, then after r≥0 cycles the error satisfies ∥e(r)∥≤qr∥e(0)∥, with the convention q0=1. The residual s(r)=b−Atu(r)=Ate(r) obeys ∥s(r)∥≤∥At∥qr∥e(0)∥, and for every error/residual pair, ∥s∥≤∥At∥∥e∥,∥e∥≤∥At−1∥∥s∥.

The contraction hypothesis is a property to prove for the declared operators, norm, and cycle. The MGRIT name alone supplies no such bound, and this theorem makes no multilevel convergence claim.

Facts & Assumptions

Given: A finite linear time system, the declared exact two-level cycle and a chosen product-space norm.

[F1]

A declared two-level MGRIT coarse-correction cycle: one cycle has error matrix E=Spost(I−PAc−1RAt)Spre.

[F2]

Eliminating F-points gives the exact coarse time operator: the fine-grid operator At is invertible.

[F3]

A norm on a real vector space, the induced metric, and the dictionary with the metric axioms: the chosen vector norm separates zero: ∥v∥=0 if and only if v=0.

[A1]

The directly calculated or proved induced norm satisfies ∥E∥≤q<1.

[A2]

The induced norms ∥At∥ and ∥At−1∥ are finite for the chosen product-space norm.

Proof

1.1givenF1algebra

By [F1], one cycle sends the current error to e(r+1)=Ee(r).

2.1givenF3A1step 1.1inductionalgebra

At r=0 the claimed inequality is equality. If the bound holds at r and e(r)=0, [F3] gives Ee(r)=0 and the next bound follows. If e(r)≠0, the induced-norm definition in the Statement and [A1] give ∥e(r+1)∥=∥Ee(r)∥≤∥E∥ ∥e(r)∥≤qr+1∥e(0)∥. Induction proves the error bound for every r≥0.

3.1givenF2F3A2step 2.1algebra

Since Atu∗=b, subtraction gives s(r)=At(u∗−u(r))=Ate(r). If e(r)=0, [F3] gives s(r)=0. Otherwise the induced-norm definition in the Statement and [A2] give ∥s(r)∥≤∥At∥∥e(r)∥, and step 2.1 yields the displayed residual estimate.

4.1givenF2F3A2algebra∎

For any error/residual pair, s=Ate and [F2] gives e=At−1s. If e=0, then s=0 and [F3] gives both inequalities. If e≠0, invertibility forces s≠0, so the induced-norm definition in the Statement and [A2] give both ∥s∥≤∥At∥∥e∥ and ∥e∥≤∥At−1∥∥s∥.

AlgorithmAlgorithm: AI-adaptedProof: Not applicableOpen item page →

Recursive multilevel MGRIT cycles

Definition

Input: levels ℓ=0,…,L with L≥1; fine-grid systems Aℓuℓ=bℓ of the form in The all-at-once bidiagonal time operator and C/F points; coarsening factors mℓ≥2 dividing Nℓ with Nℓ+1=Nℓ/mℓ; transfers Pℓ,Rℓ from the F/C construction in A declared two-level MGRIT coarse-correction cycle; and pre/post-relaxations selected from its F- and FCF-relaxations. At each level ℓ<L, form the practical coarse matrix Aℓ+1 with identity diagonal blocks and subdiagonal blocks −Ψℓ,j as in A declared two-level MGRIT coarse-correction cycle. Each noncoarsest level has a positive integer recursive visit count νℓ. Also supply an initial fine-level iterate, a chosen norm on the fine-level residual space as in A norm on a real vector space, the induced metric, and the dictionary with the metric axioms, outer cycle budget Jout≥0, and residual tolerance ε≥0. The hierarchy must provide a nonsingular coarse system at every level and an exact solve on level L. V-cycles use νℓ=1 and W-cycles use νℓ=2. This algorithm gives no existence or convergence claim for a hierarchy that fails these input conditions.

For a recursive call at level ℓ, perform the following operations on an initial guess uℓ:

  1. If ℓ=L, solve ALuL=bL exactly by forward substitution and return.
  2. Apply the selected pre-relaxation to Aℓuℓ=bℓ; compute rℓ=bℓ−Aℓuℓ and restrict it to rℓ+1=Rℓrℓ.
  3. Set the coarse correction zℓ+1=0. Repeat νℓ times: form ρℓ+1=rℓ+1−Aℓ+1zℓ+1; recursively apply the level ℓ+1 cycle to Aℓ+1δℓ+1=ρℓ+1 from zero initial correction; then set zℓ+1←zℓ+1+δℓ+1.
  4. Correct uℓ←uℓ+Pℓzℓ+1 and apply the selected post-relaxation.

Return the updated fine-level vector when the call completes. At level 0, check the residual before the first outer cycle and after every completed cycle; return status converged only when the residual tolerance is met. After Jout cycles without a verified residual certificate, return the last iterate with status budget-exhausted. Inexact level solves contribute explicit update defects; no such defect is hidden in the exact-arithmetic cycle.

No two-grid contraction is transferred to this recursive cycle; convergence requires a bound for its actual full recursive error operator.

LemmaStatement: AI-adaptedProof: AI-generatedprecheck passjudge pass (gpt-6-luna)Open item page →

Work and idealized span of completed Parareal sweeps

Statement

Suppose initialization and all K≥0 sweeps of Finite-budget Parareal correction sweeps complete successfully. They make KN fine calls and (K+1)N coarse calls. In an accounting model with constant nonnegative call costs cF,cG, P processors for a positive integer P, fine calls scheduled without idle time in batches of P except possibly the last, serial coarse calls, and additive synchronization cost τsync≥0 per sweep, their modeled work and span are respectively W=KNcF+(K+1)NcG+Kτsync,S=NcG+K(⌈N/P⌉cF+NcG+τsync). This model excludes vector arithmetic, storage, certificate verification and any overhead other than the declared synchronization cost. It gives no measured speedup guarantee.

Facts & Assumptions

Given: Successful completion and the accounting model in the Statement; N≥1 and K≥0 are integers.

[F1]

Finite-budget Parareal correction sweeps initializes one serial coarse row, then evaluates all N fine calls and N new coarse calls per sweep, reusing the preceding row's stored coarse values.

Proof

1.1givenF1algebra

Initialization makes N coarse calls. Each of the K sweeps in [F1] makes N fine calls and N new coarse calls, so the totals are KN and (K+1)N. Multiplying by the stipulated costs and adding K synchronization charges gives W.

2.1givenF1step 1.1algebra∎

Each fine phase has N independent equal-cost calls. Filling each batch except possibly the last gives ⌈N/P⌉ batches, taking ⌈N/P⌉cF without idle time. Initialization takes NcG, and each sweep has this fine phase followed by N serial coarse calls and one synchronization charge. Adding these sequential phases gives S, including K=0 and zero call costs.

LemmaStatement: AI-adaptedProof: AI-generatedprecheck passjudge pass (gpt-6-luna)Open item page →

Propagator call counts for the two-level MGRIT cycle

Statement

For the literal operations of A declared two-level MGRIT coarse-correction cycle, put Nf=N and Nc=N/m. One F-relaxation uses Nf−Nc−1 fine-propagator calls; one C-relaxation uses Nc; and one FCF-relaxation uses 2(Nf−Nc−1)+Nc. The specified coarse forward substitution uses Nc practical coarse-propagator applications, including the evaluation at z0=0. These counts concern completed operations without eliminating calls at zero inputs.

In an additive accounting model with nonnegative call costs cΦ,cΨ, the modeled work is nΦcΦ+nΨcΨ+κ, where nΦ,nΨ count all executed calls and κ accounts for all remaining work. Residuals, restriction, interpolation and stopping checks must contribute their actual calls and overhead; cached values incur no new call. A parallel schedule must respect the serial order within each F-interval and in the coarse solve, and its communication and synchronization. No measured speedup is asserted.

Facts & Assumptions

Given: The declared literal implementation, m≥2 dividing N, completed operations and the additive accounting convention of the Statement.

[F1]

A declared two-level MGRIT coarse-correction cycle updates every F-index, using u1=b1 without a propagator; each other F-update and each C-update applies one fine propagator. FCF means F, then C, then F. The coarse solve computes zj=ρj+Ψjzj−1 for j=1,…,Nc.

Proof

1.1givenF1algebra

There are Nc C-indices among Nf unknowns, leaving Nf−Nc F-indices. Exactly the boundary assignment u1=b1 in [F1] omits a fine call, giving Nf−Nc−1 calls. Each of the Nc C-updates makes one call. Adding two F counts and one C count gives the stated FCF count, including N=m=2, where the F count is zero.

2.1givenF1step 1.1algebra∎

The coarse loop in [F1] has Nc iterations and executes one application per iteration, including Ψ1z0. Summing the stipulated charge for every executed call and remaining operation gives the work formula. Each F-index uses the preceding index in its interval, and the coarse loop uses zj−1; any execution schedule must preserve these dependencies and account for its other costs.

LemmaStatement: AI-adaptedProof: AI-generatedprecheck passjudge pass (gpt-6-luna)Open item page →

Finite recursion and work accounting for multilevel MGRIT

Statement

For one top-level call of Recursive multilevel MGRIT cycles on a finite admissible hierarchy with terminating primitive operations, the recursion terminates. Its visit counts satisfy v0=1 and vℓ+1=νℓvℓ for 0≤ℓ<L.

Suppose every visit to noncoarsest level ℓ has the same local call counts nΦ,ℓ,nΨ,ℓ, excluding its recursive children. In an additive accounting model with nonnegative call costs cΦ,ℓ,cΨ,ℓ, remaining local work κℓ, and work WL per coarsest solve, its modeled work is W=∑ℓ=0L−1vℓ(nΦ,ℓcΦ,ℓ+nΨ,ℓcΨ,ℓ+κℓ)+vLWL. Each local F-, C- or FCF-relaxation has the literal fine-call counts Nℓ−Nℓ+1−1, Nℓ+1 or 2(Nℓ−Nℓ+1−1)+Nℓ+1 respectively. Residual formation, repeated coarse residuals, restriction, interpolation and correction contribute all their actual calls and overhead; caching incurs no new call. If counts or costs vary by visit, replace each product by the sum of the corresponding visit charges. Outer stopping checks have additional costs.

Parallel execution must respect the order within each F-interval, between the successive recursive visits that update the same correction, and within each exact coarse forward solve, including communication and synchronization. The accounting model implies no measured speedup or multilevel contraction.

Facts & Assumptions

Given: A finite admissible hierarchy, finite positive integer visit counts, terminating primitives and the accounting model in the Statement.

[F1]

Recursive multilevel MGRIT cycles solves exactly on level L; on level ℓ<L it invokes the level ℓ+1 cycle exactly νℓ times in sequence, recomputing each residual from the updated correction.

[F2]

Propagator call counts for the two-level MGRIT cycle gives the literal F, C and FCF call counts for a grid whose initial state is absorbed into its first right-hand-side block.

Proof

1.1givenF1inductionalgebra

A call on level L terminates by the stipulated finite exact forward solve. If calls on level ℓ+1 terminate, [F1] makes a finite number νℓ of them and otherwise executes only finite local operations, so a level ℓ call terminates. Downward induction proves termination on level 0. There is one root call and every level ℓ visit has exactly νℓ children, giving the stated visit recurrence.

2.1givenF1F2step 1.1algebra∎

Each noncoarsest visit has its stated local work charge, and every coarsest visit costs WL. Partition all operations by their unique executing visit and sum the charges to obtain W. At level ℓ the inherited relaxation has Nf=Nℓ and Nc=Nℓ+1, so [F2] supplies its three call counts, including the boundary assignment without a call. The data dependencies in [F1] and in each relaxation/forward solve require the stated scheduling order. Summing actual visit charges also covers unequal costs, and outer checks are outside the recursive call.

5 · Examples, counterexamples and false statements

None yet.

Sources