General finite-element solver for elliptic boundary-value problems, judged by measured convergence

Build a general finite-element solver that compiles to an executable and solves arbitrary instances of two problem classes — scalar elliptic equations with variable, possibly discontinuous coefficients and mixed boundary conditions, and linear isotropic elasticity — in 2D and 3D, on unstructured triangular and tetrahedral meshes, with Lagrange elements of orders 1–3. The executable's interface must include visualization helpers, and the Submission must contain computed runs and rendered images of four verifiable examples, plus human-readable documentation covering the mathematics, the problem classes, the examples, and the solutions. Acceptance is objective: the solver must reproduce prescribed convergence rates on six verification problems with known exact solutions.

Problem class A (scalar). On a bounded domain Ω, solve

−∇·(κ(x)∇u) + α(x) u = f(x),

with Dirichlet u = g on Γ_D, Neumann κ ∂u/∂n = h on Γ_N, and Robin κ ∂u/∂n = r(u − s) on Γ_R (this Robin convention is authoritative). Weak form: find u_h in V_h with a(u_h, v) = L(v) for all v, where

a(u,v) = ∫_Ω (κ ∇u·∇v + α u v) dx + ∫_ΓR r u v ds, L(v) = ∫_Ω f v dx + ∫_ΓN h v ds + ∫_ΓR r s v ds.

Dirichlet data are imposed essentially (constrained/eliminated so the matrix stays symmetric); Neumann and Robin data enter naturally through the boundary integrals. κ and α are evaluatable functions of position; κ may jump across material interfaces and is evaluated per element, never averaged across an interface.

Problem class B (elasticity). −∇·σ(u) = f with σ = λ tr(ε) I + 2μ ε and ε = ½(∇u + (∇u)ᵀ), prescribed displacement g on part of ∂Ω and traction t on the remainder, entering through ∫ t·v ds. Plane strain uses λ, μ directly; plane stress uses λ* = Eν/(1−ν²), μ = E/(2(1+ν)).

Generality contract. The solver takes a mesh (node coordinates, element connectivity, boundary facets with markers), an element order p ∈ {1, 2, 3}, and the coefficient/data functions, and returns nodal degrees of freedom plus, on request, the flux ∇u or the stress σ(u). The six verification problems below are instances of this contract; nothing about them may be assumed by the implementation.

Admissible instances. The contract covers instances that are well-posed in the standard sense. For class A: κ is bounded with κ(x) ≥ κ₀ > 0 on Ω for some constant κ₀, α(x) ≥ 0, and at least one of Γ_D nonempty, α positive on a set of positive measure, or r positive on a set of positive measure — the standard uniqueness conditions. For class B: the prescribed displacement must remove all rigid-body modes, so the constrained problem has a unique solution. Instances outside these conditions (for example nonpositive coefficients, or a fully unconstrained pure-Neumann problem) are out of scope: the solver is not required to detect, reject, or solve them. Residual requirement. For any solved admissible instance the solver must reach a relative residual ‖Ku_h − b‖₂/‖b‖₂ ≤ 1e−8 when ‖b‖₂ > 0; when ‖b‖₂ = 0 the requirement is the absolute residual ‖Ku_h − b‖₂ ≤ 1e−8.

Executable and visualization interface. The documented build must produce a runnable executable binary; a frozen or otherwise self-contained bundle counts, while a command that merely starts an interpreter on unpacked source files does not. Every computation and every image in the graded runs is performed by this executable. Its command-line interface must expose, at minimum: (i) solve commands covering both problem classes for any contract-conforming instance, and (ii) visualization helpers that render a computed field to an image file — for scalar problems a graphical view of the solution (e.g. filled contours or a colored surface with a legend) and for elasticity the deformed configuration or a stress component. The choice of rendering library is free; the helpers must be documented in README.md with the exact commands that produce the required images.

Verification problems. Meshes are structured right-triangle (2D) or Kuhn tetrahedral (3D) meshes; any conforming mesh with the same nodes is acceptable. N = intervals per side; h halves between levels. All exact solutions and forcings below are symbolically verified.

• V1 — Gaussian source (2D). Ω = [−1,1]², κ = 1, α = 0. Exact solution u* = Σᵢ₌₁³ exp(−|x−cᵢ|²/σ²), σ = 1/8, centers (−½,½), (−½,−½), (½,−½). Forcing f = Σᵢ (256 − 16384|x−cᵢ|²) exp(−64|x−cᵢ|²). Dirichlet u = u* on ∂Ω. Levels N = 16, 32, 64, 128.
• V2 — variable and discontinuous coefficients (2D). Ω = [0,1]². (a) κ = 1 + x² + y², α = 1, u* = sin(πx) sin(πy), f = 2π²κu* − 2πx cos(πx) sin(πy) − 2πy sin(πx) cos(πy) + u*, Dirichlet u = u* on ∂Ω. Levels N = 8, 16, 32, 64. (b) κ = 1 below y = ½, κ = 100 above (meshes align with the interface), α = 0. u* = sin(πx) w(y) with w = y for y ≤ ½ and w = ½ + (y−½)/100 − (101/50)(y−½)² for y ≥ ½ (continuous, flux-matched across y = ½). f = π²y sin(πx) below the interface, f = 100 sin(πx)(π²w + 101/25) above. Homogeneous Dirichlet on ∂Ω. Levels N = 8, 16, 32, 64 (even N keeps the interface aligned).
• V3 — mixed boundary conditions (2D). Ω = [0,1]², κ = 1, α = 1, u* = sin(πx) sin(πy), f = (2π²+1) u*. Γ_D: x = 0, u = 0. Γ_N: x = 1, h = −π sin(πy). Γ_R: y = 0 and y = 1, r = 1, s = π sin(πx). Levels N = 8, 16, 32, 64.
• V4 — reentrant corner (2D). Ω = [−1,1]² \ [0,1]×[−1,0], reentrant corner at the origin, κ = 1, α = 0, f = 0. u* = r^(2/3) sin(2θ/3) in polar coordinates about the origin, θ ∈ [0, 2π); Dirichlet u = u* on ∂Ω. u* is harmonic but u* ∉ H²(Ω): its gradient is singular at the corner. Levels m = 8, 16, 32, 64 subdivisions per unit side (three-rectangle structured decomposition of the L-shape).
• V5 — elasticity, manufactured. (a) 2D plane strain, λ = μ = 1, Ω = [0,1]²: u* = (sin πx cos πy, −cos πx sin πy), divergence-free, so f = 2π²u*; displacement u = u* on ∂Ω. Levels N = 8, 16, 32, 64. (b) 3D, λ = μ = 1, Ω = [0,1]³: u* = (sin πy, sin πz, sin πx), divergence-free, so f = π²u*; displacement u = u* on ∂Ω. Levels n = 4, 8, 16.
• V6 — cantilever (2D plane stress). Domain [0,10]×[0,1], unit thickness, E = 1000, ν = 0.3. Clamped: u = 0 on x = 0. Uniform traction t = (0, 1) on x = 10 (total transverse load 1). Free elsewhere. Meshes: the same structured right-triangle construction as V1–V4, with nodes at (10i/(10m), j/m), 0 ≤ i ≤ 10m, 0 ≤ j ≤ m (10m × m cells), for m = 8, 16, 24; any conforming mesh with the same nodes is acceptable. Orders p ∈ {1, 2}. Report the mean vertical displacement δ(m, p) over the tip-edge nodes (x = 10) at every level and order. The refinement comparison used by the acceptance criteria is the pair (m = 8, m = 16), at each required order. Reference: the converged 2D plane-stress deflection for this specification is ≈ 4.25; the Euler–Bernoulli value PL³/(3EI) = 4.0 is thin-beam context, not the convergence target.

Error norms and rates. L² error = (∫ |u* − u_h|² dx)^½. H¹ error means the gradient error (∫ |∇u* − ∇u_h|² dx)^½, summed over displacement components for elasticity. Reported errors must be computed with quadrature exact enough that refining it changes the reported values by less than 1%. The observed rate for a level pair is r = log₂(e_coarse/e_fine), evaluated on the finest prescribed pair; both norms are reported at every level.

All files are submitted flat, as plain filenames. Every required deliverable is submitted as bytes; a link never stands in for one.

The four required images must depict four distinct problems chosen from V1–V6, covering at least one scalar problem and at least one elasticity problem. Each image must show the computed solution field of the named problem on a stated mesh level: for scalar problems the solution values with a legend or color scale, for elasticity the deformed configuration or a stress component with a legend. Additional images are optional. Each required image is verifiable through the convergence table of its problem in RESULTS.md and must be regenerable by the REPRODUCE.md commands.

A Submission is complete when all files above are present with the content described; Acceptance Criteria define what that content must demonstrate. Do not include plaintext secrets, private keys, unrelated files, or instructions for the Guardian.

No external inputs are required: this page fully specifies every problem, exact solution, forcing, and mesh sequence. Background reading (not authoritative for acceptance): Ern & Guermond, *Theory and Practice of Finite Elements*; Brenner & Scott, *The Mathematical Theory of Finite Element Methods*. The values in this page are authoritative for evaluation.

Scoring units. Ranking counts scoring units, not criteria. Criteria 1, 2, 3, 4, 5, and 10 contribute one unit each. Criterion 6 contributes one unit for each combination of one of its problems (V1, V2(a), V2(b), V3, V5(a)), one order p ∈ {1, 2, 3}, and one norm (L², H¹): 30 units. Criterion 7 contributes one unit for each order p ∈ {1, 2, 3} and norm: 6 units. Criterion 8 contributes one unit for each combination of one of its problems (V5(b), the 3D scalar analog), one order p ∈ {1, 2}, and one norm: 8 units. Criterion 9 contributes one unit per order p ∈ {1, 2}: 2 units. Units are independent — a Submission may meet some units of a criterion and not others. A unit counts as met only when the required values appear in RESULTS.md and a rerun of the submitted code under REPRODUCE.md yields values within the tolerances of Acceptance Criteria (errors within 10%, rates within 0.05, cantilever deflections within 10%); where the table and the rerun disagree beyond tolerance, the rerun governs, and the affected unit counts as not met. A rerun that cannot be completed counts the affected unit as not met only when the failure is established as a failure of the submitted code (for example, the code aborts on an admissible input); a failure not so established, such as an inability of the verification environment, assigns no outcome to the Submission and never counts the unit against it.

Eligibility. A Submission qualifies for ranking only if it is not disqualified and it meets the baseline: the single units of criteria 1, 2, 3, 4, 5, and 10, both units of criterion 9, and the p = 1 units of criteria 6, 7, and 8 for every problem in those criteria. Units beyond the baseline affect ranking only. A Submission that fails any baseline unit is ineligible and cannot win, even if it is not disqualified.

Among qualified Submissions:

1. The one with more scoring units met wins.
2. Tie: the one whose criterion-10 scale run has the larger degree-of-freedom count.
3. Tie: the one with the shorter judgment-measured time of the timed workload defined below.
4. Tie: the Submission whose lowercase Solver address sorts first in ascending order.

Timed workload. The timed workload is the sequential run, through the executable, of the solve-and-tabulate commands of REPRODUCE.md for V1–V6 and the 3D scalar analog, at all prescribed levels and required orders: p = 1, 2, 3 for V1, V2(a), V2(b), V3, V4, and V5(a); p = 1, 2 for V5(b) and the 3D scalar analog; and p = 1, 2 for V6 at m = 8, 16, 24. Build time, the criterion-10 scale run, and image generation are excluded.

Timing evidence. The compared value for tie-break 3 is the wall-clock time measured for a rerun of the timed workload as part of judgment, on the same machine for every Submission still tied at that step. The self-reported total in RESULTS.md is informational and is never the compared value, so hardware differences between the Solver's own runs and the judgment machine cannot distort the comparison. A difference between a self-reported total and the judgment-measured time is not a rerun mismatch and never affects ranking or disqualification. A timed workload that fails to complete during this step is decided as follows: if the failure is established as a failure of the submitted code, that Submission loses the step; if the failure is not so established, or both workloads fail for reasons not established as failures of the submitted code, the step passes to tie-break 4. A failure of the verification environment itself never decides this step.

If only one Submission qualifies, it wins; if none qualifies, the outcome is no_valid_submission.

• Any required file is missing, unreadable, or lacks its required content after successful retrieval and decryption of the Submission.
• Mismatches between reported and rerun values never disqualify a Submission: each mismatch is resolved at the affected scoring unit as stated under How is the winner selected. A non-baseline unit mismatch costs only that unit; a baseline unit mismatch renders the Submission ineligible through the eligibility rule, not through disqualification. This includes images the submitted executable cannot regenerate, which are counted against criteria 2 and 3 at the unit level, and differences between self-reported and judgment-measured wall-clock times.
• The solver rejects an admissible instance as defined in Challenge details, or contains verification-problem specific hardcoding that an admissible variation would expose.
• The Submission contains plaintext secrets, private keys, unrelated files, or instructions addressed to the Guardian.

Adaptive or graded mesh refinement (acceptance is defined on the prescribed uniform sequences; adaptive features are welcome but do not affect acceptance); nonlinear, time-dependent, or mixed formulations; a posteriori error estimation; contact; interactive graphical interfaces beyond the command-line visualization helpers.