friction
stress orientation
threshold

loading…

The slip magnitudes are large and are not a prediction. Median slip is 12–16 m across the sweep and the maximum reaches 98 m, because the load sits at λ/σc = 3.0 — a differential stress well above any crustal state — and a static solution has no healing, no viscous relaxation and no prior slip history to have relieved it. The load was chosen to give a large enough active set to measure, which it does. Which elements slip, and how moment distributes across them, are the results; how far they slip is what the equations give at that load and should be read as such.

What λ is

The regional stress is a full tensor growing along a fixed path, σ(λ) = σc I + λ(D + k I). D is a fixed unit tensor giving the shape of the tectonic stress — its orientation and its faulting style — σc is the confining pressure, here 150 MPa, and k is the loading path. Only the magnitude grows during a run; the shape never changes, which is what lets a single number stand for the whole history.

D's eigenvalues are (+1, 0, −1), so its maximum shear stress is exactly 1 and therefore λ is the maximum shear stress of the tectonic field, in GPa — equivalently half the differential stress, (σ1 − σ3)/2. The run starts at λ = 0.1175, a tectonic field whose maximum shear stress is 118 MPa, which is where the first element in this network reaches its failure criterion, and ends at 0.4525.

λ is not time. It carries units of stress, nothing in the problem has a rate, and every frame is a static equilibrium. And λ alone means nothing: the problem is invariant under scaling λ and σc together, so the physical parameter is the ratio of the two, never either by itself.

The problem, written out

Let δi be the slip on element i, along its own slip direction. The shear traction it carries is the regional field plus everything every other element's slip transfers to it:

K is the elastostatic stress-transfer operator — the one mhs assembles — and di is how fast the regional field drives element i per unit of load. Its strength is Coulomb, gi = μ σ'n,i, so the yield function is

Friction is then three statements, not one. Slip is non-negative, because it runs one way along the driving direction. Traction never exceeds strength. And an element slips only while it is exactly at yield:

That last line is the whole of it. Each element is either locked (δi = 0 and Fi < 0) or slipping (δi > 0 and Fi = 0), and never anything else.

In standard form

Write w = −F for the margin to failure, A = −K, and q = g − λd. The three conditions become

which is the Linear Complementarity Problem LCP(q, A) exactly as it is posed in contact mechanics. The sign flip is not cosmetic: A's diagonal is Aii = −Kii > 0, because an element's own slip relieves its own shear, and that positive diagonal is what everything below rests on.

Why there is exactly one answer

LCP(q, A) has a unique solution for every q if and only if A is a P-matrix — all principal minors positive (Cottle, Pang & Stone, Thm 3.3.7). A sufficient condition, and the one actually checkable on an assembled operator, is positive definiteness:

No symmetry is required, which matters here because collocation makes A markedly non-symmetric. What is required is that smallest eigenvalue of the symmetric part, and it is measured per run rather than assumed: 2.4 on this network, against a matrix whose entries are tens of GPa per km of slip.

How it is solved

Projected Gauss-Seidel — one sweep over the elements, each solved for its own slip holding the others fixed, then clipped at zero:

The clip is what makes it a complementarity solve rather than a linear one: an element whose update would send it negative is simply locked. The convergence test is the natural residual maxi |min(δi, wi)|, which is zero at the solution and nowhere else — a step-size test would report success on a solver that had merely slowed down. ~141 sweeps cold on 2,056 elements; a handful warm.

The screening, in the same notation

Critically-stressed fracture analysis is this problem with K = 0. The coupling vanishes, every element decouples, and the solve collapses to one inequality per element:

No matrix, no iteration. That is the null this study measures against, and the comparison is between that set and {i : δi > 0} from the full solve.

What is unique and what is not

The solution δ, and therefore the active set, is unique at every λ and every μ. On a fixed active set 𝒜 the problem is linear, A𝒜𝒜δ𝒜 = −q𝒜, and q is affine in both parameters — so δ is piecewise linear, with kinks exactly where the active set changes. That is why the counts below move in lumps rather than smoothly.

What is not unique is the decomposition of slip into events. That requires a strength drop, and a cascade has no unique end state — which is the division this page is organised around.

The static solution, which is unique

At one load the quasi-static Coulomb problem is a Linear Complementarity Problem. Every element is either locked and below strength or slipping and exactly at strength, and nothing else is admissible: with w the margin to failure, w = Aδ + q, δ ≥ 0, w ≥ 0, δ·w = 0, with A = −P. When A has positive definite symmetric part it is a P-matrix, and an LCP with a P-matrix has exactly one solution for every q (Cottle, Pang & Stone, Thm 3.3.7).

So which faults slip under this stress field has one answer, and it depends on no loading path, no update rule and no frictional weakening whatsoever. The strength drop above is needed for the separate question of how slip arrives — in what sized jumps — because the stiffness criterion forbids a finite jump without it. Measured here, the two static solutions bracket the entire loading history exactly:

A(μs) 10,822  ⊆  A(history) 10,977  ⊆  A(μd) 11,299

with zero violations in either direction. The brackets are 477 elements apart, 2.3 % of the network, so the strength drop does not decide the active set — it only chooses where inside that band the history lands. A static solve is also two to three orders of magnitude cheaper: ~141 projected Gauss-Seidel sweeps against 165,659 events.

Mollification is what makes this well posed, not merely convenient. The uniqueness theorem needs a finite, correctly signed Pii. For a classical dislocation element that number does not exist — the traction kernel is hypersingular on its own surface, giving a Hadamard finite part, a collocation-dependent value, or a divergence. Mollification smears slip over a width ε and the self-interaction becomes a convergent integral, with ε physical rather than arbitrary: a fault is a gouge zone of finite thickness, so Pii is the self-stiffness of a slip patch of that width. Without it the theorem has no matrix to act on.

Two things are measured rather than guaranteed. The continuum hypersingular operator is coercive for a single crack, but a collocation discretization on a network of arbitrary orientations and near-contacts does not inherit that — ours did not, the first time, with one negative eigenvalue out of 2,826 traceable to a single nearly perpendicular pair. And P is strongly non-symmetric, |P − PT|max/|P|max = 0.72, as collocation is where Galerkin would not be. Uniqueness survives, needing definiteness and not symmetry, but this is a genuine LCP and not a convex QP, so the solver's convergence is an empirical fact here and is reported per run.

What interaction adds to screening everyone already does

Resolving Coulomb on each fracture independently against the regional stress — critically-stressed fracture analysis, after Barton, Zoback & Moos (1995) — is routine in reservoir geomechanics and costs nothing. It is also exactly this study's no-interaction null. So the central measurement is the difference between that screening and the static solve, and the two halves of it disagree:

That orientation dependence was invisible from a single orientation, and an earlier version of this page reported only the single-orientation figure of "well under 3 %". The worst disagreement is at SHmax 105° (Jaccard 0.872, an eighth of the network), the best at SHmax 0° and 165° (under 0.1 %). So whether the standard screening is adequate is not a property of the network alone — it is a property of the network and the tectonic regime acting on it, which is precisely what the second slider exists to show.

Because the solve is cheap, the network can also be grown fault by fault and re-solved, which a loading history could not afford. Leaving one fault out of the full network and warm-starting from its solution gives the clean perturbation, and both signs occur: removing one 780-element fault switched 224 elements off and 12 on — it was mostly promoting its neighbours — while removing a 600-element fault switched 64 on and 8 off, having mostly been shadowing them. Removing an inactive fault, however large, changes nothing at all: a fault that does not slip transfers nothing, so the 1,444-element fault that dominates the locked set is mechanically invisible to the rest of the network.

Not every fault can ever slip

The measurements in this section come from a different configuration than the one displayed above — 538 power-law faults swept in FRICTION rather than a subparallel cloud swept in LOAD. They are kept because the mechanics they describe is the same and the numbers were earned, but they are not statements about the cloud in the viewer, whose own event statistics are reported further up: median one patch, largest five, 7.9 % multi-element.

The load clamps as well as shears, so a plane's strength grows with λ too. Failure needs λ|τ| ≥ μ(σc + λσn), so an element with |τ| ≤ μσn per unit load never fails at any load whatsoever. On the path shipped here that is 28.3 % of elements, so the active set has a ceiling of 71.7 % rather than 100 %. The gate checks this the blunt way: a locked element's yield function is still negative at λ = 108. Elastic interaction is almost powerless against it — on the purely deviatoric path it pushed exactly two of 2,116 locked elements over.

Measured rather than argued. At k = 1, where the load has no ceiling and λ → ∞ is a legitimate question, a run of 1,021,035 events out to 20× the first failure reaches 47.5 % active against a predicted ceiling of 50.5 % — 94 % of the way there, with the remainder arriving logarithmically. The active set overlaps the no-interaction prediction by 99.3 %. So the ceiling is real, interaction does not lift it, and the answer to whether everything eventually slips is no by roughly half.

The active set is almost nested in μ, and the exceptions are real. Raising friction can only shrink the screened set, by construction. With interaction it need not: LCP monotonicity requires A to be a Z-matrix — every off-diagonal coupling promoting — and the dislocation kernel has shadowing lobes too, with only 44 % of pairs satisfying the condition here. So an element held locked at low μ by a neighbour's stress shadow can be freed at high μ when that neighbour stops slipping.

An earlier version of this page said that escape is never taken. That was measured at one stress orientation and stated as though it held everywhere. Across twelve orientations it is taken at three of them — 1 element at SHmax 120°, 142 at 105°, 6 at 165°, and none at the other nine. The elements involved slip 2.5–11.6 m, so this is mechanics and not solver tolerance, whose floor is around 10−8 m. The prediction that non-monotonicity is permitted was right; the claim that it never happens came from a sample of one.

Nothing downstream depends on it either way. The viewer reads membership from the per-frame slip array, which is exact whether or not the set nests; "critical friction" is reported as the largest μ at which an element slips, not as a guarantee that every lower one does.

19.1 % of the cloud slips — 392 patches of 2,056 — by 2.3 times the load at which the first one fails. Almost nothing is permanently locked (0.05 %), so that fraction is not a ceiling; it is how far the load was taken. Events are small: the median is a single patch, the largest is five, and 7.9 % involve more than one. The triggering budget is 0.63 — what one patch sheds onto others, as a fraction of what it sheds in total — so cascades die out, which is what subcritical means and why no event runs away.

What the interaction adds is small, and the page shows exactly how small. The honest comparison is not against nothing; it is against the set that would fail with the elastic coupling switched off, chosen by orientation and load alone. That null gets 98 % of the same patches. Colour by what interaction changed and almost the whole cloud is grey: the loading does nearly all of the choosing, and the handful of patches interaction adds or removes is the entire mechanical contribution. Coherence — how nearly the slipping patches deform as one — moves from 0.785 to 0.800, about two per cent.

What the active set does have is shape. Its clusters are strongly linear (0.91) and barely planar (0.03), against 0.87 and 0.07 for the no-interaction null. Subparallel planes scattered through a volume pick out lineaments rather than sheets when they slip together — which is the kinematically connected subset this configuration was built to look for, in a form that was not the one anticipated. Colour by cluster planarity to see it, and note how few patches are in a cluster larger than a handful: the largest holds eight.

Why the load is a full tensor and not a deviatoric one

An earlier version of this page was loaded past the bound below, and 16.6 % of its active set was failing for no mechanical reason. The run shown now is compressive at every element in every frame, and the payload builder refuses to publish one that is not.

A deviatoric D is traceless, so it raises the mean stress not at all: the tension-favoured planes shed normal stress exactly as fast as they gain shear. Past λ ≈ σc their effective normal stress goes negative. Coulomb friction does not describe that — the fault opens — and worse, a negative σeff makes the strength μσeff negative, so the element satisfies the yield criterion however little shear it carries and joins the active set for no mechanical reason.

Purely deviatoric, the first element here opens at only 1.95× the first failure. Lowering σc does not help, because first failure and opening scale with it identically — a lithostatic profile gives 2.15×. What helps is a loading path that also raises the mean stress, through the k I term:

kthe pathusable range lockedceiling on active
0σH up and σh down equally; mean fixed 1.95×10.2 %89.8 %
2/3only σH grows — shipped here3.89× 28.3 %71.7 %
1minimum principal stress never falls unbounded49.5 %50.5 %

k = 2/3 is not fitted to anything: holding σh and σv while σH grows raises the mean stress at Δ/3 while the maximum shear rises at Δ/2. An isotropic tensor resolves the same normal stress onto every plane and no shear onto any, so k enters the arithmetic in exactly one place and every downstream formula is untouched — checked to machine precision rather than assumed.

The more realistic the loading path, the fewer faults can ever slip. That is the uncomfortable half of the table: going from a deviatoric load to one that never opens a fault cuts the ceiling from 89.8 % to 50.5 %. The deviatoric case was flattering itself by driving a tenth of the network toward tension.

None of the conclusions below depend on which of the three was used. At k = 0 to 1.9× (the last compressive load), at k = 2/3 to 3.85× (shipped) and at k = 1, the overlap with the no-interaction null is 97.1 %, 97.9 % and 99.0 %; the participation ratio differs from that null by −0.0003, +0.0012 and +0.0035; and the mean event size is 5.86, 5.83 and 5.90 against a largest of 845, 840 and 836. What moves is the active fraction — 51.9 %, 52.8 %, 42.5 % — and nothing else.

What is and is not being claimed

The machinery works and the numbers above are measured: 165,659 events over the load range shown, 52.8 % of elements eventually slipping, a cumulative moment of 3.1×1021 N m, and a largest single cascade of 840 elements. Every event reached equilibrium; none ran away, which is not automatic — the branching ratio averages 0.786 and its 90th percentile is 0.969, so this network sits just below criticality rather than comfortably away from it.

Interaction does not choose which elements slip. It chooses how much each one slips. That is the result, and it is not what we expected to find. The active set overlaps the no-interaction null — the set that would fail if elements could not talk to each other, selected by orientation and the regional load alone — by 97.9 %. Hold the weighting fixed and every geometric statistic of the two sets agrees: coherence differs by +0.0005, the participation ratio by +0.0012, the orientation fabric's leading eigenvalue by +0.0009, cluster planarity and linearity to three decimals. The faults that fail are the well-oriented ones, and elasticity barely moves that list.

What elasticity does move is the distribution of slip across that list. Weighted by moment rather than by membership, the active set's participation ratio falls from 0.378 to 0.172 — moment is about 2.2 times more concentrated than the footprint carrying it — and its coherence rises from 0.731 to 0.780. So slip piles onto a mutually better-aligned subset of the elements that were always going to fail. The network manufactures asperities out of slip amplitude, not out of which patches participate.

Two of those numbers were wrong here first, in the same way. The build originally weighted the active set by real slip while weighting every null by unit slip, then printed the difference in one column. That read as interaction concentrating the active set by a factor of two and sharpening its coherence by +0.057. Both effects were the weighting. Each statistic is now computed at matched weighting across every row, and the moment-weighted comparison is made against the same set's own unit-weighted value rather than across rows — which is how a factor of 2.2 in moment survived as real while the +0.057 became −0.003.

The dimension question cannot be asked in this domain at all. The box-counting window is bounded below by the largest fault, not the element size, because until a box exceeds a fault that fault reads locally two-dimensional. With a 37.9 km fault in a 100 km box the window spans zero decades, and the code refuses to report a slope rather than fitting one. Measuring Dactive against Dgeom needs either a domain of order 1,400 km or a network whose largest fault is a small fraction of the box; the multiplicative-cascade configuration exists for exactly that and keeps its largest fault at 1.6 % of the domain against 38 % here.

Two standing limits on what a dimension could ever say. The estimator is biased low by about 0.11 and that bias is invisible to R2 — every calibration fit reaches R2 ≥ 0.999, including one wrong by 0.14 — so only differences in a matched window are quoted. And a subset's dimension falls simply because it has fewer members: on a sheet that is exactly two-dimensional, a 5 % random subset reads 0.36 lower and a 1 % subset loses a full dimension. So “the active set is lower-dimensional” is nearly free, and the matched-cardinality null is the entire result rather than a formality.

Avalanches

The measurements in this section come from a different configuration than the one displayed above — 538 power-law faults swept in FRICTION rather than a subparallel cloud swept in LOAD. They are kept because the mechanics they describe is the same and the numbers were earned, but they are not statements about the cloud in the viewer, whose own event statistics are reported further up: median one patch, largest five, 7.9 % multi-element.

An event here is one relaxation to equilibrium after a single element is pushed past its static strength — a cascade through the network, not a dynamic rupture, and nothing in it propagates in time. Sizes are broad: 58.5 % involve more than one element, the 99th percentile is 71 elements and the largest is 840, against a median of 2.

No exponent is quoted. A power law needs a defended lower cutoff, and these sizes are bounded above by the elements per fault — 38.6 on average here — so a fitted slope would be reporting the discretisation as much as the network. The survival function is given instead: P(≥2) = 58.5 %, P(≥5) = 23.9 %, P(≥10) = 12.3 %, P(≥50) = 1.9 %, P(≥100) = 0.5 %. An earlier configuration with small faults made this point the hard way: its event size was invariant to a 16× density change and a 25× change in the strength drop, because it was set by the discretisation within a fault rather than by the network — which is Rice's discreteness critique arriving uninvited.

The stress isosurface, and why this cloud has none yet

The viewer can raymarch a translucent isosurface of the elastic maximum shear stress — an invariant, (σ1 − σ3)/2, so it does not depend on a reference plane the way a Coulomb stress change would — with a threshold slider moving the shell. The control is absent above because this network's volume has not been evaluated. The page renders whatever the payload carries and omits the toggle when there is no volume, rather than offering a control that fails on click.

The reason is cost, and the cost was first estimated wrong by a factor of six. Evaluating the field costs one kernel pair per grid point per element, and a stress readout parallelises at only 1.45× here — it is the assembly of an interaction matrix that parallelises at 8.5×, a distinction worth keeping straight, because reading the wrong row is what produced the original estimate. Measured end to end at 54.1 µs/pair, a 243 grid against all 2,056 elements is about 4.3 hours. The previous configuration's volume took two.

A twenty-times-cheaper route was tried and rejected on measurement. Replacing each fault by its own rectangle carrying the same total moment — geometry exact, moment exact, only the slip distribution within a fault averaged — agrees with the exact field to a median of 0.00 % on a coarse grid, correlation 0.9997. But resolved against distance from the nearest fault it is wrong by a median 3.8 % and a worst 38 % within one fault length, falling below 0.1 % only beyond about eight. An isosurface at a high threshold selects precisely the near-fault points, so the approximation is worst exactly where the picture is most interesting. Any volume published here is therefore exact over every element, and a coarse grid is the price: at 4.2 km cells against 2–38 km faults it would show the network's aggregate stress structure, not a concentration at a fault tip.

Why there is a strength drop

With a single friction coefficient this experiment has no mechanism, because friction that does not weaken cannot go unstable. A patch unloads itself elastically at a stiffness k = |Kii|, and instability requires the strength to fall with slip faster than that — the classical criterion k < |dτ/dδ|. Non-weakening Coulomb friction has dτ/dδ = 0, so the inequality can never be satisfied at any patch size, stress or stiffness.

The consequence is that the quasi-static solution is continuous in the load. Beyond failure, equilibrium pins the traction to the strength, so slip follows δ(λ) = (λ τ' − τp)/|Kii| — it grows from zero slip at a finite rate τ'/|Kii|. Nothing jumps, so no event has a finite size and there is nothing to count. The first version of the solver demonstrated exactly that, advancing the load to the first failure and then relaxing zero slip indefinitely.

So an element has a static strength τp = μsσ'n it must reach to fail and a residual strength τr = μdσ'n it relaxes down to. The drop Δτ = τp − τr forces a finite slip Δδ = Δτ/|Kii| the instant an element fails, and that slip is what loads its neighbours and can trigger them in turn. This is slip-weakening in the limit of zero weakening distance, so the nucleation length collapses to zero and every element is unstable at any size — the price of not resolving a breakdown zone. Here μs = 0.6 and μd = 0.54 against 150 MPa give 90 → 81 MPa, a 9 MPa stress drop, which sits inside the 1–10 MPa range observed for real earthquakes. At a ratio of 1.0 there are no cascades by construction, and the code refuses that value rather than returning a null result that would look like a finding.

It does not follow that the drop sets the avalanche statistics, and measurement says it does not. A failing element slips Δτ/|Kii| and delivers KjiΔτ/|Kii| to its neighbour, while the gap that neighbour must re-close after relocking is itself proportional to Δτ — so the drop cancels from the triggering ratio, which is pure geometry. Measured: a 25× change in the drop moved mean avalanche size by under 2 %, with events × drop constant to 9 %. What the drop does set is whether events exist at all, the moment carried by each, and how many there are — not how large they are in elements, which is most of what this page measures.

What the solver choice costs

A cascade has no unique end state — a triggered element lands anywhere between its dynamic and static strength depending on the order elements are visited — so there is no exact answer to validate against. What can be done is to vary the update rule and measure the spread. Measured on the smaller cascade configuration rather than on this network: between Gauss-Seidel and Jacobi, event counts move by 6.9 % and mean event size by 4.3 %; between element orderings, under 1 %. But total slip is invariant to 0.1 %, and the active set came out bit identical under every rule tried — symmetric difference zero. So the set every claim above is made on carries no solver dependence, while an avalanche exponent would carry that 7 % as part of its uncertainty — one of several reasons none is quoted. The same sweep has not been repeated at 2,056 elements, where each relaxation is a hundred times more expensive.

Does any of this need a mollified kernel?

It is worth asking directly, because on this cloud the answer is no. Elastic interaction supplies between 1.6 and 8.3 % of an element’s strength here, which is the product of two small numbers: the stress drop as a fraction of strength, about 0.10, and the geometric transfer between elements, about 0.17. Driving the network from zero background stress makes the size of that budget explicit — a seeded patch recruits zero neighbours at any stress drop, the peak transfer is exactly 0.830× the drop (linear to four figures over a ninefold sweep), and reaching the failure threshold on interaction alone would need about 630 elements, 31 % of the network, to slip at once. Weakening cannot rescue it either: the 0.830 ceiling holds even at total strength loss. So a critically-stressed screening with no kernel at all reproduces most of this answer, and that is a fact about the geometry — scattered, separated faults — not about the kernel.

A rough contiguous crack is the opposite geometry, and the honest result there has two halves. For assembling the interaction matrix, a classical triangular dislocation element does as well as the mollified kernel at every roughness tested, and recovers the Eshelby solution marginally better: collocation only asks for traction at an element’s own centroid, where the classical finite part exists. For reading back a stress field, it does not, because a field asks for stress off the collocation points too — and where two adjacent elements slip by different amounts, the classical kernel leaves a residual dislocation on their shared edge whose stress goes as a clean 1/d. This mesh has 770 km of such spurious singular line against 49 km of physical rim. That is the case for a declared regularisation length, and it is narrower than “mollification is necessary”.

One simplification worth naming

Effective normal stress is uniform with depth here, and that is a deliberate choice rather than an oversight. The real gradient is about 0.0167 GPa/km once hydrostatic pore pressure is removed, which across a 40 km box is a factor of twenty in strength: the shallow elements would fail first, the active set would be a horizontal slab, and its measured dimension would be reporting the depth gradient rather than any mechanical localisation. Removing it leaves orientation and elastic interaction as the only things that can select which faults slip, which is the question. The depth-dependent case runs, and is important future work — it needs its own null, the same network with the gradient and the elastic interaction switched off, or depth and localisation stay confounded.

Slip is stored quantised: log10 into one byte per element per frame, 254 levels, zero reserved for “has never slipped” and drawn grey rather than at the bottom of the ramp, because a locked element is categorically different from one that slipped a little. The whole 120 × 2,056 array is encoded in one pass, so the colour scale is global across frames — a per-frame scale would normalise away the growth being animated. The quantisation error is bounded by arithmetic rather than asserted, and the build measures what it wrote against that bound: 1.239 % against a bound of 1.239 %, a ratio of 1.000. The payload is 0.55 MiB for 2,056 elements across 120 equilibria, plus two single-frame arrays that describe the final state rather than its history.