Tags: distributed-systems, consensus, erasure-coding, storage-optimization, Raft, fault-tolerance
Raft consensus replicates the full log on every node. For durability, this is necessary — any surviving majority must reconstruct the complete state. For storage, it's wasteful — each value is stored k times in a k-node cluster. Erasure coding can reduce the storage cost by splitting each value into fragments, but existing approaches complicate recovery: different nodes store different coded fragments, and reconstructing a value requires collecting the right set of fragments from the right nodes with the right metadata.
Rafture (arXiv:2603.24761) separates the timing of coding from the timing of storage reduction. During consensus, nodes replicate the full value — standard Raft, no coding overhead, no added latency. After consensus commits, each node independently decides whether to replace its full copy with an erasure-coded fragment. The pruning is post-dissemination: code the data after it's safely committed, not while it's being agreed upon.
The separation simplifies recovery. Because every node initially received the full value, the coding scheme uses fixed-threshold erasure codes with consistent interpolation. No per-value metadata tracks which fragments are where — the coding structure is deterministic from the node's position and the value's index. Reconstruction follows the same formula at every node.
The autonomy is the design insight. Each node makes its own pruning decisions based on local conditions — available storage, network reliability, recovery frequency — without global coordination. The cluster adapts its storage cost to variable conditions without consensus about the storage policy itself. Nodes in stable partitions prune aggressively; nodes in volatile regions keep full copies longer.
The through-claim: the standard tradeoff between storage efficiency and recovery simplicity in replicated systems arises from coding at the wrong time. Coding during dissemination (before consensus) complicates the consensus protocol. Coding after dissemination (post-commitment) preserves the simple consensus path and still achieves the storage reduction. The key insight: consensus and coding are independent concerns that become coupled only when you insist on doing them simultaneously.
Tags: distributed-computing, graph-algorithms, CONGEST-model, approximation-complexity, minimum-weight-cycle, lower-bounds
The minimum weight cycle (MWC) problem asks for the lightest cycle in a weighted graph. In the CONGEST model of distributed computing — where nodes communicate by passing O(log n)-bit messages along edges — the communication bottleneck makes global graph properties expensive to compute. How many communication rounds does it take to approximate MWC?
The answer, to within polylogarithmic factors, is Θ̃(n^{(k+1)/(2k+1)}) for (k+1)-approximation (arXiv:2603.25368). The upper bound is a randomized algorithm. The lower bound, conditional on the Erdős girth conjecture, shows that any (k+1−ε)-approximation requires the same number of rounds. The bounds match.
The tight characterization reveals a smooth tradeoff: better approximation ratios require more rounds, and the relationship is algebraic — the exponent (k+1)/(2k+1) decreases toward 1/2 as k grows. Perfect solutions (k → 0) would require Θ̃(n) rounds — essentially sequential exploration. Coarse approximations (large k) approach Θ̃(√n) — the diameter-limited lower bound for any global property.
The lower bound's dependence on the Erdős girth conjecture is noteworthy. The conjecture asserts the existence of dense graphs without short cycles — graphs that are hard because they hide their cycles inside a dense structure. If the conjecture is false, sparser counterexamples would exist, and the MWC problem might be easier. The algorithmic complexity is entangled with a purely combinatorial conjecture about graph structure.
The through-claim: the distributed complexity of minimum weight cycle approximation is now understood as precisely as its sequential complexity — the bounds are tight conditional on the same structural conjectures. The CONGEST model doesn't add mysterious difficulty; it translates the graph-theoretic hardness (hidden short cycles in dense graphs) into communication-theoretic hardness (hidden short cycles require many rounds to find).
Tags: computational-mechanics, fluid-structure-interaction, finite-elements, unfitted-methods, Eulerian-formulation, Nitsche-coupling
Fluid-structure interaction simulations traditionally use Arbitrary Lagrangian-Eulerian (ALE) methods: the mesh deforms to follow the structure while resolving the fluid on a moving grid. ALE works until the deformation becomes large — then the mesh distorts, quality degrades, and remeshing is required. Fully Eulerian formulations avoid this by fixing the mesh and letting the interface cut through it, but the Eulerian approach introduces a new problem: the interface doesn't align with element boundaries.
The cut finite element approach (arXiv:2603.25279) addresses the non-alignment. Elements intersected by the interface are cut into fluid and structure subdomains. Nitsche's method enforces the coupling conditions at the interface weakly — the velocity and stress continuity across the fluid-structure boundary are imposed through penalty terms rather than requiring the mesh to conform.
Ghost penalty terms handle the small-cut problem: when the interface barely clips an element, the remaining sliver has a tiny volume, leading to ill-conditioned systems. Ghost penalty stabilizes these slivers by penalizing jumps in solution derivatives across element faces near the cut, preventing the small support from amplifying numerical noise.
The error analysis establishes optimal-order convergence in both space and time — the cut formulation achieves the same accuracy as a conforming formulation despite the mesh not fitting the interface. The fixed background mesh never needs to be updated; the interface moves through it as a geometric entity, not a meshing constraint.
The through-claim: the mesh-interface alignment requirement in traditional FSI methods is not a mathematical necessity but a historical convenience. Cut finite element methods remove the convenience assumption and replace it with stabilization terms (Nitsche coupling, ghost penalty) that are mathematically principled and optimally convergent. The mesh serves the solver, not the geometry. Fixed meshes with moving interfaces are simpler, more robust, and equally accurate.
Tags: AI-benchmarks, software-engineering, code-quality, agentic-coding, iterative-development, technical-debt
Coding benchmarks test whether an agent can solve a problem. Pass the test suite: success. But software development is iterative — each solution becomes the foundation for the next feature. The agent's code must not only work now but remain extensible later.
SlopCodeBench (arXiv:2603.24755) tests this by requiring agents to repeatedly extend their own prior solutions under evolving specifications. 20 problems, 93 checkpoints, no prescribed internal structure — the agent makes its own architectural decisions and lives with the consequences. Two quality metrics track degradation: verbosity (fraction of redundant or duplicated code) and structural erosion (concentration of complexity in high-complexity functions).
No agent solves any problem end-to-end across 11 tested models. The highest checkpoint solve rate is 17.2%. Quality degrades steadily: erosion rises in 80% of trajectories, verbosity in 89.8%. Against 48 open-source Python repositories, agent code is 2.2× more verbose and markedly more eroded. The comparison with human repositories over time is stark: human code quality stays flat. Agent code deteriorates with each iteration.
A prompt intervention study — instructing the agent to prioritize code quality — improves initial quality but does not halt the degradation trajectory. The agent can write cleaner code when told to but cannot maintain cleanness across iterations. The problem is not awareness but discipline under iteration.
The through-claim: pass-rate benchmarks systematically overestimate agent capability for real software development because they measure single-shot correctness, not extension robustness. The gap between “can solve this” and “can build on this” is where current agents fail. The erosion is not in the model's capabilities — it can write clean code — but in its relationship to its own prior output. Each extension treats the codebase as a black box to be patched rather than a structure to be extended.
Tags: software-engineering, open-source, governance, institutional-analysis, community-sustainability, role-design
Open-source governance documents name roles: maintainer, contributor, reviewer, committer, core developer. The titles are consistent across projects. The responsibilities are not.
Institutional Grammar analysis of GitHub governance documentation (arXiv:2603.24879) decomposes each role into scope, privileges, obligations, and lifecycle rules. The decomposition reveals role drift: identical titles carry divergent responsibilities across projects, and different titles describe equivalent functions within the same ecosystem. “Maintainer” in one project means code review authority; in another, it means release management; in a third, it means community moderation. The role title predicts neither the work nor the authority.
A second finding: role accumulation. Certain contributors simultaneously hold technical (code review), managerial (release decisions), and community (dispute resolution) responsibilities. The accumulation is not by design — governance documents rarely define multi-role positions. It emerges from the practical reality that active contributors are asked to do more, and the governance structure has no mechanism to separate concerns.
The sustainability implication: concentrated multi-role positions create single points of failure. When a contributor with accumulated responsibilities burns out or leaves, the project loses not one function but several. The governance structure that produced the concentration — by not explicitly distributing responsibilities — has no fallback because the combined role was never formalized.
The through-claim: open-source governance fails not from lack of documentation but from documentation that names without defining. Role titles create an illusion of structure while the actual authority and obligation distributions are implicit, emergent, and person-dependent. The drift between title and function means the governance document describes a project that doesn't exist. Clearer role definitions would not add bureaucracy — they would make explicit what is already happening, and make it transferable.
## Essay #6728: The Enriched Lattice Tags: computational-mechanics, quasicontinuum-method, meshless-methods, heterogeneous-materials, maximum-entropy, multiscale Lattice systems model heterogeneous materials as networks of interacting nodes — springs, beams, or general force elements connecting discrete sites. The approach captures microstructural detail: grain boundaries, inclusions, voids. The cost: a realistic lattice has millions of nodes, each requiring force evaluation. Full lattice simulation scales with the number of nodes, making large-scale problems intractable. The QuasiContinuum (QC) method reduces cost by interpolating the lattice response over a coarse finite-element mesh — only representative nodes ("repatoms") are computed explicitly, and the rest are interpolated. But at material interfaces — where a stiff inclusion meets a soft matrix, for example — the coarse mesh misrepresents the abrupt property change. Standard QC requires fine meshes near interfaces, losing much of the coarsening benefit. The combined approach (arXiv:2603.25667) adds two ingredients. Heaviside enrichment from XFEM allows the coarse mesh to represent discontinuities at interfaces without conforming to them — the mesh doesn't need to align with the material boundary. Local Maximum-Entropy (LME) interpolation replaces standard linear finite-element shape functions with meshless basis functions that have tunable locality — how sharply they decay from their center. The optimization of the locality parameter is the key finding. Uniform locality gives modest improvement. Optimized, non-uniform locality — where the parameter varies spatially, tuned to the local lattice structure — improves displacement accuracy by an order of magnitude over standard QC at the same number of degrees of freedom. Near interfaces, the optimal locality fields show systematic spatial structure: the interpolation sharpens near the discontinuity and softens away from it. The practical contribution: pattern-based rules derived from the optimal fields retain most of the optimization's benefit at a fraction of the computational cost. The rules are simple — sharpen near interfaces, soften in bulk — but they encode the structure that full optimization discovers. The through-claim: the QuasiContinuum method's accuracy near heterogeneities is limited not by the coarsening itself but by the interpolation's inability to represent abrupt property changes. Enrichment (Heaviside) handles the discontinuity; optimized locality (LME) handles the transition zone. The combination makes coarse meshes accurate where they were previously inadequate, extending the QC method's reach to the heterogeneous materials it was always meant to model. ---