Computer vision once had to scan every position at every zoom level to find a face, because a face's size in pixels was unknown. When a depth sensor reports how far away each pixel is, the expected face size can be computed directly, and the search over zoom levels disappears. Simulating where a brittle solid will crack has the same problem. Flaws, pores and notches span many sizes, and high-fidelity fracture simulators resolve all of them at the finest scale, so each run takes hours. This proposal argues that brittle materials carry their own version of the depth sensor. Experiments on marble show that a stress concentrator smaller than a material-specific length, about 0.27 mm in that case, does not weaken the specimen at all. Failure is governed by stress averaged over that length, not by the peak stress at the flaw edge.
We propose to use this intrinsic length as a hard prior on the scale of a coarse-to-fine search for fracture initiation. A cheap elastic solve, run at a resolution set by the material length, is averaged over that length. That average screens out harmless concentrators, much as a detector cascade rejects background windows early. Expensive fracture physics is then run only in the few windows that survive. If this works, simulation cost would grow with the number of flaws that can actually matter, not with the domain volume divided by the size of the smallest flaw. It would also give a physically interpretable alternative to black-box fracture surrogates.
Core Claim
In Rupture of Perfectly Brittle Materials under Concentrated Stress, Satô and Sakurai drilled holes of increasing diameter into marble cylinders loaded in torsion. Rupture occurs when the mean stress over a surface layer of thickness $\delta$ reaches the tensile strength $\sigma_b$:
$$\bar{\sigma} = \frac{1}{\delta}\int_0^{\delta}\sigma(x)\,dx = \sigma_b .$$
Holes smaller than $\delta$ produced no notch weakening (Regime I). Two consequences follow for computation. First, no feature finer than roughly $\delta$ needs to be resolved to decide whether initiation can happen, which sets the finest level of the scale pyramid. Second, $\bar{\sigma}/\sigma_b$ is a cheap, physically calibrated score for rejecting regions early.
Our claim is that a cascade built on these two facts locates fracture initiation sites and predicts failure loads as well as full high-fidelity simulation. Its cost would scale roughly as
$$C \approx c_0\,(L/\delta)^d + N_{\mathrm{active}}\,c_{\mathrm{fine}},$$
where $L$ is specimen size, $d$ the spatial dimension, $c_0$ the per-cell cost of the coarse elastic solve, $N_{\mathrm{active}}$ the number of windows that survive screening, and $c_{\mathrm{fine}}$ the cost of one local high-fidelity fracture solve. The first term is a fixed-resolution elastic solve. The second depends on how many flaws exceed $\delta$, not on the total flaw population. The claim fails if a standard refinement indicator, which knows nothing about the material, achieves the same savings.
How This Sits Against Prior Work
The material-scaling literature motivates the idea by showing that brittle failure has intrinsic lengths at several levels. Molecular dynamics of calcium–silicate–hydrate, the binding phase of cement (Fracture toughness of calcium–silicate–hydrate from molecular dynamics simulations), finds a plastic zone of about 13.7 Å and $K_{Ic} = 0.369$ MPa·m$^{1/2}$, matching macroscopic cement paste. Simulations of sodium silicate glass (Nanoductility in silicate glasses is driven by topological heterogeneity) confine plastic events to underconstrained pockets of about 1.5 nm. These nanometre lengths are far below any continuum mesh, and that is the point: what matters at engineering scale is the microstructural length $\delta$ that emerges above them. We do not try to upscale atomistic plasticity, which the file identifies as unsolved.
Compression tests on glass and ceramic spheres (Experimental research on the strength distribution of brittle spheres under compression) supply the statistical side of the story. Crushing force scales as $d^2$ and follows a lognormal distribution ($R^2 > 0.95$). We use this as a validation target for the size effect our cascade should reproduce when run over random flaw populations.
Three surrogate papers are the closest existing work, and all three avoid explicit search rather than structuring it. Accelerating high-strain continuum-scale brittle fracture simulations with machine learning compresses the microcrack field to the longest crack and peak tensile stress, emulates their evolution with a recurrent network, and reports about 10⁴× speedup on a beryllium flyer-plate problem. StressNet predicts stress from given crack images at a single fixed resolution. A Foundation Model for Material Fracture Prediction runs a transformer over a fixed grid or mesh across many materials. None of them uses a material length to decide where or at what scale to compute. The foundation-model authors also do not connect learned representations to physical length thresholds.
From vision we reuse two techniques. The first is the logic of computing scale from known geometry instead of searching over it, as in depth-based head detection (Fully Convolutional Network for Head Detection with Depth Images). The second is the attentional cascade (An Analysis of the Viola-Jones Face Detection Algorithm), with rejection thresholds set asymmetrically following Group Cost-Sensitive Boosting for Multi-Resolution Pedestrian Detection. That paper showed that uniform costs make cascades drop small targets. In fracture, missing the one critical flaw is the catastrophic error, so stage thresholds should be tuned for near-zero misses.
Research Program
The cascade has three stages.
Stage one: coarse screening. We solve linear elasticity on a uniform mesh of size about $\delta/4$. This is fine enough to evaluate the averaging integral, and is usually far coarser than the smallest flaw. Flaws below this size enter only through their contribution to effective stiffness. The solver then computes $\bar{\sigma}$ along the boundaries of resolved concentrators and rejects every window whose ratio $\bar{\sigma}/\sigma_b$ falls below a threshold $\tau$. $\tau$ is calibrated on held-out simulations so that recall of true initiation sites stays at or above 0.99.
Stage two: learned verifier. A small convolutional verifier, analogous to the secondary verifier in Object specific deep feature and its application to face detection, re-scores surviving windows. It takes as input the local coarse stress field and the flaw geometry. It is trained with a cost-sensitive loss that penalizes missed initiation far more than false alarms, which handles flaw interactions that the plain averaging rule cannot see.
Stage three: local high-fidelity solves. Phase-field fracture is run only inside the surviving windows. Boundary conditions come from the coarse solve, in the style of global–local submodeling. When a local crack grows past its window, the coarse field is updated. Phase-field models carry their own regularization length. We will set it to be consistent with $\delta$ and check that the full fine-mesh reference reproduces Regime I and Regime II before trusting it as ground truth.
Estimating $\delta$ is part of the program. For simulated materials we run the Satô–Sakurai hole-diameter sweep inside the fine reference model and read off the knee in rupture stress. We then test how errors in $\delta$ of ±50% degrade both cost and recall. This sensitivity matters because a real material's $\delta$ is measured, not known.
Baselines
The naive reference is the full fine-mesh phase-field simulation. It resolves every flaw at its own scale, uses no screening, and defines ground truth for initiation sites, crack paths and failure load. All other methods are scored against it on identical geometries and flaw populations, so its errors are zero by construction and its wall-clock time sets the cost scale. The closest published analogue of its cost is StressNet's report that a 2D finite-discrete element run with 20 cracks takes about 4 hours.
The strongest competitor on cost is adaptive mesh refinement driven by a standard stress-gradient or energy-error indicator. It is what a computational mechanician would reach for first. It also starts from a coarse solve and refines locally, so it isolates exactly whether material-aware screening adds anything. We run it with the same coarse starting mesh, the same phase-field solver, the same finest element size, and an equal tuning budget over its refinement threshold. Beating it means equal or better initiation recall and failure-load error at substantially lower refined area. The gap should be largest in specimens dense with sub-$\delta$ flaws, which an error indicator refines because they look singular. No reported result was found on Lacuna for adaptive refinement on these fracture benchmarks.
The strongest competitors on speed are global neural surrogates. StressNet reports 2% mean absolute percentage error on stress at a 720× speedup on its 61-run, 20-crack dataset. The fracture foundation model reports $R^2 = 0.9522$ for failure time at millisecond latency. We fine-tune the foundation model, or retrain StressNet where the foundation model is unavailable, on the same training simulations used to fit the cascade verifier. Both are evaluated on failure load, initiation location and failure time. The cascade does not need to beat them on speed. It beats them if it matches their accuracy in distribution and is clearly more accurate when the flaw-size distribution or specimen size shifts outside the training range, because its screening rule is physical rather than learned.
Two ablations isolate the key ingredient. The first replaces the δ-averaged score with peak elastic stress, which is the classical stress-concentration criterion Satô and Sakurai showed fails for small holes. The second uses uniform false-negative costs in stage two instead of the asymmetric costs. If neither ablation hurts, the material length is not doing the work we claim.
Why not just…?
Why not just use adaptive mesh refinement? This is the most serious threat. Refinement indicators measure where the numerical error is large, not where the material will fail. A sharp sub-$\delta$ hole has large error and draws refinement even though Satô and Sakurai found such holes to be mechanically inert. The decisive experiment sweeps the fraction of the flaw population below $\delta$ from 0 to 90%. If refinement matches the cascade's cost across that sweep, the proposal's central claim is wrong and we will report that.
Why not just apply the critical-distance criterion to a coarse elastic solve and stop there? For the initiation load of a single dominant flaw under quasi-static load, this may well suffice. If it does, that is a useful finding. It cannot follow crack growth, coalescence of interacting flaws, or the multi-crack evolution that Fernández-Godino et al. found continuum damage models miss, such as the spall pull-back signal. We report a stage-one-only predictor as its own row. The fine stages are justified only where their accuracy gain on crack path and failure load is measurable.
Why not just run the fracture foundation model everywhere? It is already fast, so the case for the cascade is not speed but reliability under shift. The foundation model is trained on fixed grids and 2D tensile loading, and its authors do not tie its representations to physical length thresholds. We test both methods on specimens two to four times larger than training and on flaw-size distributions centred on the other side of $\delta$. If the foundation model's error does not grow there, the main remaining advantage of the cascade is interpretability.
Why not just give a surrogate multi-scale context, for example factorized dilated convolutions as in FarSee-Net? That approach cuts the cost of each forward pass, reported at about 8.8× for its context module, but still evaluates the whole domain at every scale. It also does not encode which scales are physically irrelevant. We include a multi-scale convolutional surrogate as a variant of the neural baseline rather than as a separate method.
Proposed Experiments
The primary benchmark is a newly generated set of 2D phase-field simulations. Plates contain random populations of circular and elliptical flaws whose sizes are drawn lognormally across $\delta$. They are loaded in uniaxial and biaxial tension and in shear, the last to probe beyond the tensile-only regime of the surrogate papers. Reference simulations are run on the full fine mesh.
We also reproduce two published settings. The first is the Satô–Sakurai hollow-cylinder geometry, where the cascade must recover rupture-stress ratios of 1.0 for $2a \le \delta$ and the averaged-stress curve beyond. The second is the 20-crack tensile setting used by StressNet, regenerated if the original runs are unavailable. For size effects, we run cascades over populations of virtual spheres from 10 to 50 mm under compression. We check whether the median crushing force scales as $d^2$ and whether strengths follow a lognormal distribution, as in the sphere experiments.
Metrics are recall and precision of initiation sites against the reference, relative error in failure load, error in failure time, the fraction of domain area refined, and wall-clock time.
Three checks decide the proposal. First, the cascade must hold recall at or above 0.99 while refining a much smaller area than error-driven refinement, with the gap widening as the share of sub-$\delta$ flaws grows. Second, replacing the δ-averaged score with peak stress must sharply increase refined area or false alarms. Third, under shifts in specimen size and flaw distribution, the cascade's failure-load error must grow more slowly than that of the fine-tuned neural surrogates.
References
- Rupture of Perfectly Brittle Materials under Concentrated Stress
- Fracture toughness of calcium–silicate–hydrate from molecular dynamics simulations
- Nanoductility in silicate glasses is driven by topological heterogeneity
- Experimental research on the strength distribution of brittle spheres under compression
- Accelerating high-strain continuum-scale brittle fracture simulations with machine learning
- StressNet: Deep Learning to Predict Stress With Fracture Propagation in Brittle Materials
- A Foundation Model for Material Fracture Prediction
- Fully Convolutional Network for Head Detection with Depth Images
- An Analysis of the Viola-Jones Face Detection Algorithm
- Group Cost-Sensitive Boosting for Multi-Resolution Pedestrian Detection
- Object specific deep feature and its application to face detection
- FarSee-Net: Real-Time Semantic Segmentation by Efficient Multi-scale Context Aggregation and Feature Space Super-resolution