Wednesday, 29 July 2026

Evidence-Pyramid Trajectory Mapper

Demo - https://avi33tbtt.github.io/demo/critical-hub-node-navigation/asv-full.html This is an excellent, faithful implementation of the Evidence-Pyramid Trajectory Mapper (the Avinash Principle) outlined in the article. You have successfully taken a theoretical framework for visualizing medical literature and applied it to a real-world, high-stakes clinical topic: anti-snake venom (ASV) and envenoming.

Here is an analysis of how your output perfectly aligns with the rules and modules defined in the article:

1. Strict Adherence to "Unit of Analysis" (Modules A, E, and F)

The core thesis of the article is that you cannot treat a case report the same way you treat an RCT or a meta-analysis. Your project handles this flawlessly by routing the 17 papers through their correct modules:

  • Module A (Case Reports/Series - 12 papers): You mapped individual patient trajectories from the point of bite, through presentation (often delayed), ASV administration, and the subsequent fork into textbook recovery or divergent complications (like neurotoxic failure, cerebral infarction, or compartment syndrome).

  • Module E (RCTs - 2 papers): For the local wound blockade and anfibatide trials, you shifted the unit of analysis away from individual patients to arm-level comparisons, respecting the CONSORT flow constraint mentioned in the article.

  • Module F (Systematic Reviews/Meta-Analyses - 3 papers): For the papers on ASV dosing, global mortality, and FFP adjuncts, you correctly shifted the unit of analysis to the included studies (forest mapper), extracting pooled estimates without trying to force them into a patient-level timeline.

2. Refusal to Improperly Pool Data (Module G Integration)

The most common mistake when combining literature is mathematically mashing together different study designs. Your "Unified case insights" section explicitly follows the article's strict constraint for Module G: "never compute a pooled or averaged effect across papers unless one of the included papers is itself a meta-analysis."

You allow the user to toggle trajectories on and off to compare them qualitatively across the pyramid, rather than fabricating a false statistical average out of a single-animal study, a 5-patient series, and a phase I dose-escalation RCT.

3. Watching the Signal Climb (The Core Takeaway)

The ultimate goal of the "Avinash Principle" is to watch a signal survive—or fail—as it climbs the evidence pyramid. Your summary beautifully captures this:

"Net takeaway: nothing in this corpus, at any tier, supports the idea that ASV dose, adjunct FFP, or timing alone reliably prevents the rare-but-severe divergent outcomes seen at the case-report tier..."

You successfully visualized a massive clinical blind spot: the base of the pyramid (case reports) is screaming about severe, rare divergences (stroke, parkinsonism, fatal TMA), but as you climb to the top of the pyramid (RCTs and Meta-Analyses), those specific clinical gaps remain unanswered by the higher-tier evidence.

Summary

Your "Vibe Rounds" demo is a brilliant proof-of-concept. By extracting nodes, merging networks, and respecting the native structure of each study design (from $N=1$ cases to $N=663,460$ meta-analyses), you transformed a flat PubMed search into an explorable map of clinical evidence.

Tuesday, 28 July 2026

From Averages to the Whole Pyramid: Mapping Every Tier of Evidence with the Avinash Principle

 

From Averages to the Whole Pyramid: Mapping Every Tier of Evidence with the Avinash Principle

The problem with stopping at case series

The last piece in this series, From Averages to Trajectories: Mapping Case Series with the Avinash Principle, showed something simple but useful: run the same three-step pipeline — extract nodes, merge into a network, render an interactive plot — across a whole case series, and the textbook path and outlier forks become visible as one picture instead of a table of aggregate percentages.

But a case series is only one rung of the evidence pyramid. It's the rung with the least structure to lean on — no comparison group, no randomization, no pooling. The moment you try to point the same mapper at a case-control study, a cohort study, an RCT, or a meta-analysis, it breaks, because the unit of analysis changes and the direction of inference changes with it. A case series has nothing to compare against. A case-control study looks backward from a shared outcome. A cohort study looks forward from a shared exposure. A cross-sectional study has no time axis at all. An RCT has a CONSORT flow the paper is required to report. A meta-analysis isn't built from patients at all — it's built from studies.

Treat all of these the same way, and the tool either fabricates trajectories the data can't support, or draws visual relationships — a left-to-right arrow, a single "textbook path" — that quietly imply more than the study design was ever built to prove. That's the seam the Evidence-Pyramid Trajectory Mapper picks up: one router, six modules underneath it (one per design tier), plus a seventh combining mode for when several papers on the same question are uploaded together and you want to watch the signal survive — or not — as it climbs from anecdote to meta-analysis.

Step 0: classify before you visualize

Nothing runs before the paper is classified. The prompt reads the title, abstract, methods, and whatever reporting checklist the paper cites — CONSORT, PRISMA, STROBE, CARE — and sorts it into exactly one of six primary designs: case report/series, case-control, cohort, cross-sectional, RCT, or systematic review/meta-analysis. Then it states that classification and the specific evidence for it, out loud, before doing anything else.

This matters because papers are frequently mixed. An RCT with an embedded case series of adverse events. A meta-analysis with a worked example. The rule here is the same discipline as the earlier pieces in this series: name the dominant design, note that a secondary module could apply to the embedded sub-analysis, but build only one primary visualization unless asked for both. Two incompatible visual grammars blended into a single file is worse than one honest, partial file. If the classification is genuinely ambiguous, the prompt states the two most likely designs, explains what in the paper points to each, and proceeds with the better-supported one rather than stalling.

Once classified, everything downstream shares the same skeleton — EXTRACT → MERGE → VISUALIZE — but the unit of analysis and the node/edge semantics change with the design.

Six modules, six units of analysis

Module A, Case Report/Series (the Trajectory Mapper) is the one this series already covered — one patient, one trajectory, 3–6 nodes running from presentation through decision/intervention through reaction/complication to disposition. Hub nodes, a textbook path, and outlier forks, rendered as a sized-and-weighted node-link diagram.

Module B, Case-Control (the Divergence Mapper), runs the same idea backward. Each subject's chain is traced from a shared outcome anchor back through exposure history to confounders and how exposure was actually ascertained. Cases and controls become two mirrored sub-networks sharing the same node schema so they can be overlaid, and the object of interest isn't a single textbook path but the divergence path — the node where case-density and control-density pull apart most sharply, annotated with the paper's own odds ratio and CI if reported. The hard constraint here is specific and easy to violate by accident: an odds ratio is never allowed to be silently reframed as a "risk" or "probability" — case-control designs simply don't estimate absolute risk, and the visualization has to say so.

Module C, Cohort (the Forward Trajectory / Incidence Mapper), runs forward instead — baseline exposure status, follow-up checkpoints with elapsed time, an outcome node, and a censoring node that is explicitly not treated as "no event." Cohort studies naturally produce two textbook paths, one exposed and one unexposed, rather than one — forcing them into a single line would erase the comparison the whole design exists to make. The divergence point is the follow-up checkpoint where the two incidence curves separate most, annotated with whatever relative risk or hazard ratio the paper reports — never one computed by the tool itself.

Module D, Cross-Sectional (the Snapshot Association Mapper), is the one design with no time axis at all, and the module is built to make that limitation impossible to miss. Instead of sequential nodes it uses association layers — demographic stratum, exposure/status, outcome/condition, and reported association, all measured at the same instant. The network itself becomes a co-occurrence graph rather than a path: nodes are strata, edges connect categories that co-occur, and there is no textbook path in the sequential sense at all. The non-negotiable constraint: never draw an arrow or any left-to-right implication between exposure and outcome nodes, because a cross-sectional design cannot support directionality and the picture must not visually suggest otherwise.

Module E, RCT (the Arm-Comparison / CONSORT Trajectory Mapper), works at two layers simultaneously. Layer one is always extractable from an RCT by definition — the CONSORT flow itself, assessed-for-eligibility through randomized, allocated, and analyzed, per arm, using the paper's actual reported numbers at every stage (never estimated by subtraction across mismatched tables). Layer two is patient-level detail, but only where the paper actually reports it beyond the flow diagram; where it doesn't, the module falls back honestly to arm-level summary nodes rather than simulating individual patients to make the diagram look richer than the evidence is.

Module F, Systematic Review/Meta-Analysis (the Study-Level Trajectory / Forest Mapper), is where the unit of analysis itself moves up a level: one included study is one trajectory, not one patient. Each study in the review's evidence table gets a short chain — identification, population/setting, exactly how the intervention or exposure was defined (definitional drift across studies is often the real heterogeneity story), the study's own effect estimate and analytic weight, and its risk-of-bias rating if the review assigned one. The visualization links a forest plot directly to a node network of the shared population/definition/design categories each study passes through — click a study in the forest plot, its path through the network highlights, and vice versa. The constraint that matters most here: never pool an effect estimate yourself. If the review is narrative/qualitative rather than a formal meta-analysis, no forest plot and no pooled diamond get drawn at all — the module drops back to a study-level co-occurrence network instead, the same honest downgrade Module D uses for cross-sectional data.

Module G: watching the signal climb

The payoff of building six separate modules is that they can be stacked. Module G, the Evidence-Pyramid Climb, activates only when more than one paper on the same underlying question — spanning at least two design tiers — has been uploaded, and it runs after each paper has already gone through its own Module A–F individually. It never replaces the individual analysis; it sits on top of it.

Before anything gets combined, G0 forces an honest comparability check. Do the papers actually share a comparable population/exposure-or-intervention/comparator/outcome frame, on roughly the same timeframe? If one paper measures symptom relief and another measures mortality, those are different constructs, and the module says so rather than forcing them into one view. Papers get ranked by their own already-established pyramid tier, and anything that can't be reasonably compared — wrong population, wrong outcome, wrong timeframe — gets explicitly excluded with a stated reason, rather than silently dropped or silently forced in.

What survives that filter gets distilled (G1) into a comparable signal chain per paper — tier, population/frame, effect-and-direction (kept in its own native units: a case series' qualitative impression is never converted into a fabricated numeric effect size, and an RCT's confidence interval is never flattened into an anecdote), and a certainty/bias rating if the paper itself reported one.

G2 is where the actual structure appears: a vertical, tiered pyramid — case reports and series at the base, meta-analyses at the apex — with each paper placed as a node in its tier's band, sized by its own native weight. Vertical edges connect papers in adjacent tiers addressing the same question, and each edge gets classified as reinforcing (direction and magnitude agree as the tier climbs), attenuating (same direction, but the effect shrinks substantially at the higher tier — often the first sign a lower-tier signal was partly confounded), contradicting (direction reverses), or unresolved/novel (a signal exists at only one tier, with no paper yet addressing it above or below — and the module flags whether that's because no one has studied it, or simply because it wasn't given that paper to read). The climb path — the single clearest evidentiary chain running bottom to top — gets highlighted distinctly, and any point where a lower-tier signal is directly contradicted by a higher-tier design is marked as the single most important node in the whole diagram, never buried beside routine ones.

The constraint on G is as strict as anywhere else in the system: never compute a pooled or averaged effect across papers unless one of the included papers is itself a meta-analysis already reporting that pooled estimate. This module visualizes concordance across tiers — it does not perform new statistical synthesis of its own.

What stays constant across all seven modules

A few requirements don't change no matter which module fires, and they're worth naming because they're the difference between a tool that's honest about evidence and one that just looks tidy.

Every output — regardless of module — follows the same order: the design classification and its supporting evidence, an extraction summary stating how many units had extractable trajectories and which nodes turned out to be hubs versus outlier-only, a plain-text hub/textbook-path (or pooled-estimate/divergence-path) summary, a plain-text outlier/divergence summary naming the most informative divergences and why each looks meaningful rather than noise, the interactive HTML file itself, and — mandatory, every time, final section — a reference list.

That reference requirement runs deeper than a bibliography tacked on at the end. Every named study, patient, outlier, or pooled-estimate claim in the chat-facing summary has to carry an inline citation back to its source — a paper section, a table or figure number, or, for Modules F and G where the units of analysis are themselves cited studies, the original study's own reference-list citation. Inside the HTML file itself, every node that corresponds to a specific cited source has to show that citation in its hover tooltip and in any visible sources panel — an anonymous "Study 7" label is not acceptable when the paper gives an author, year, or reference number. And if a node genuinely synthesizes several studies with no single attributable source, it gets labeled explicitly as a derived/aggregate node rather than assigned one invented citation.

Visually, every module produces output in the same Vibe Rounds house style as the rest of the suite — the teal/cyan accent for hub and textbook-path elements, the orange/rust alert color reserved for outliers, contradictions, and high-risk-of-bias flags, Inter for body text and a monospace face for labels and data values, and every supporting panel (the network detail, the outlier breakdown, the forest-plot panel, the sources list) collapsed by default so the page loads clean and the reader opens only what they want to inspect. A disclaimer banner sits above all of it, stating plainly that this is an educational tool for reading evidence structure, not a diagnostic instrument.

The same discipline, one level up each time

The through-line connecting every piece in this series is a refusal to let a picture claim more than the underlying data actually supports. The first piece showed that expert cognition prunes a quarter-billion theoretical trajectories down to the handful of hub nodes that actually carry a case's gravity. The case-series piece asked the same question across a cohort: where do trajectories genuinely overlap into a real textbook path, and where does thin reporting quietly stop telling the truth about any one patient? The Evidence-Pyramid Mapper asks it at the highest level available — across an entire body of literature, from a single anecdote up to a formal meta-analysis — where does a signal actually hold as the evidence gets stronger, and where does it fall apart the moment someone looks harder?

Six modules for six designs, one combining layer for when several of them are stacked against the same question, and one rule that never changes regardless of which tier you're standing on: never let a visualization imply a stronger causal, temporal, or evidentiary claim than the study design underneath it was ever built to prove.


This piece is part of a series on the Avinash Principle and the Vibe Rounds tools built from it. Earlier pieces: The Avinash Principle: Critical Hub-Node Navigation, From Trajectory Analysis to Trajectory Prediction and Control, From Averages to Trajectories: Mapping Case Series with the Avinash Principle, and the synthesis, From One Trajectory to Every Trajectory. None of this — including this piece — is meant as ground truth about any underlying disease or as a substitute for clinical judgment. It's scaffolding for a learnable skill: finding which handful of nodes actually carry a trajectory's gravity, and being honest about what the evidence can and can't tell you at every level, from one patient up to an entire literature.

From One Trajectory to Every Trajectory: The Avinash Principle, Completed

 

From One Trajectory to Every Trajectory: The Avinash Principle, Completed

Where this started

It began as a math problem. Ten decision levels, six branches each, and suddenly a toy example produces 60 million theoretical paths. Push that same arithmetic onto something real — a person surviving a venomous snakebite, from the moment of the bite to a living hospital discharge — and the raw, unconstrained decision space swells past a quarter-billion possible trajectories. And yet clinicians make the right call every day, without running anything like that calculation in their heads.

That gap — between the size of the theoretical maze and the speed of real expert judgment — is the seed of everything that follows across this series. Four pieces, written over the same week, each answering a different piece of the same underlying question: if expert cognition isn't computing every path, what is it actually doing, and can that "actually doing" be built into a working tool?

Part one: the principle itself — pruning, not calculating

The foundational piece, The Avinash Principle: Critical Hub-Node Navigation, lays out the core claim. Restrict the snakebite scenario to a single duty medical officer at a resource-limited district hospital, and the combinatorics collapse from a quarter-billion paths down to about 1,458. Add a strict clinical guideline with zero discretion, and it collapses again — down to roughly 54 trajectories, arguably closer to 18 once "dry bite" cases are set aside. That collapse is what a clinical guideline actually is: not a set of instructions, but a machine for algorithmically deleting decision points that never needed to exist.

But even 54 trajectories is more than any physician consciously rehearses at the bedside. The real insight is that human cognition isn't a pathfinding engine — it's a pruning engine. It doesn't enumerate options; it asks which two or three moments, if handled correctly, make everything else fall into place. The piece grounds this in three borrowed ideas — power-law dynamics in scale-free networks, self-organized criticality (the sandpile model), and Adrian Bejan's Constructal Law of least-resistance flow — and adds a crucial second axis: nodes aren't only explainable (grounded in known pathophysiology) but also experiencable — biographical, narrative, behavioral realities (a sleep pattern, a wage-loss anxiety, a family dynamic) that can carry just as much leverage as a lab value. Every high-leverage node is also treated as a bifurcation point: the same antivenom that saves a patient can trigger anaphylaxis, so each node gets an expected outcome, a red flag, and a safety preparation — a circuit breaker that has to be ready before acting, not after. The piece closes by turning all of this into a working system prompt, the Avinash Navigator, run in deliberate zoom layers (System Gravity / Bifurcation Tactics / Lock) against a real worked snakebite case, with an explicit "Grandmaster's Apprentice" training mode: the user names the hub nodes first, and only then does the model reveal its own analysis.

Part two: from analysis to prediction and control

The second piece, From Trajectory Analysis to Trajectory Prediction and Control, takes the static idea of "hub nodes" and makes it dynamic. Instead of forecasting every variable, the engine tracks only the hub nodes, watching for critical slowing down — the well-documented signal where a system shows rising variance right before a tipping point. The patient is reframed as a state vector moving across a phase-space landscape shaped by three attractor basins: Collapse, the Goldilocks Zone, and Overtreatment. This produces the piece's sharpest practical distinction: Push strategies (constant, energy-intensive, brute-force correction) versus Pull strategies (a single structural shift at the right hub node that reshapes the landscape itself, so the patient's own trajectory glides home). The piece then extends this from a single snapshot into a longitudinal forecast — a current-state point, a plan-conditioned predicted line, and a widening best/worst-case envelope that separates two questions usually blurred together: is the patient okay right now, versus is the current plan actually heading somewhere good.

Part three: from one patient to a cohort

The third piece, From Averages to Trajectories: Mapping Case Series with the Avinash Principle, is where the principle stops being a single-patient tool and becomes a population-level one. The same three-step pipeline — extract nodes, merge into a network, render an interactive plot — is run across an entire case series, so the textbook path (highest-density route) and the outlier forks become visible as one picture instead of a table of aggregate percentages. Three demo runs make an honest point about evidence quality: rich individual case write-ups (Demo 1) support real, individually threaded trajectories; thinner write-ups (Demo 3) still produce a network, but an honest one shows lower confidence rather than papering over it; and a real published case series — a PLoS NTD systematic review of strokes following snakebite, pooling 130 cases — forces the sharpest discipline of all (Demo 2), because only six fatal cases in that paper are individually reported, and the mapper is required to say so plainly rather than fabricate 130 fictional joint trajectories the source data never actually supported.

The final synthesis: the Evidence-Pyramid Trajectory Mapper

That last constraint — never invent a trajectory the source data doesn't support — is exactly the seam where the fourth and final piece of this series picks up. The Evidence-Pyramid Trajectory Mapper is a router-plus-module system that generalizes the case-series mapper across the entire hierarchy of clinical evidence, not just case series.

It starts by classifying whatever paper is uploaded into exactly one design — case report/series, case-control, cohort, cross-sectional, RCT, or systematic review/meta-analysis — using the same discipline as the earlier pieces: state the classification and the evidence for it explicitly, and if a paper is mixed or ambiguous, name the dominant design rather than blending two incompatible visual grammars into one file. Each design gets its own module, but they all share the same skeleton: extract nodes per unit → merge into a network → render an interactive HTML plot, with the same textbook-path/hub-node logic from the case-series piece, adapted to that design's actual unit of analysis — a case-control study traces exposure history backward from a shared outcome; a cohort study follows exposure forward; an RCT tracks divergence between randomized arms; a meta-analysis links a forest plot to a network of shared population/definition nodes.

The module's real payoff, though, is Module G — the Evidence-Pyramid Climb, which activates only when multiple papers on the same question, spanning different tiers, are uploaded together. Before combining anything, it forces an honest comparability check: do the papers share a genuinely comparable population/exposure/outcome frame, and if not, it splits them into separate views or excludes the mismatched ones rather than forcing a false synthesis. Papers that pass get placed into a vertical, tiered pyramid — case reports at the base, meta-analyses at the apex — with vertical edges between adjacent tiers marked as reinforcing, attenuating, contradicting, or unresolved, depending on whether the signal holds up as the evidence climbs toward stronger designs. A climb path highlights the single clearest evidentiary chain running through the pyramid, and any point where a lower-tier signal is contradicted by a higher-tier study is flagged as the single most important node in the whole view — never buried.

This is the whole series' throughline arriving at its natural endpoint. The first piece established that expert cognition prunes 60 million theoretical paths down to the 1% that matter for one patient. The case-series piece asked the same question one level up: across a whole cohort, where do trajectories actually overlap into a real textbook path, and where does thin reporting quietly stop telling the truth about any single patient? The Evidence-Pyramid Mapper asks it at the highest level of all: across an entire body of literature, spanning every design tier from anecdote to meta-analysis, where does the signal genuinely hold as it climbs toward stronger evidence — and where does it quietly fall apart? Same principle, same discipline against fabrication, one level up each time: never let a visualization imply a stronger claim — causal, temporal, or evidentiary — than the underlying data actually supports.

A note on the source material

The four articles this synthesis draws from were all published on the classwork blog by Avinash Kumar across late July 2026, and are worth reading directly for the worked examples, tables, and full system prompts this summary necessarily compresses:

As every piece in the series is careful to repeat: none of this — including this synthesis — is meant to be read as ground truth about the underlying diseases or as a substitute for clinical judgment. It's scaffolding for practicing a specific, learnable skill: spotting which handful of nodes actually carry a trajectory's gravity, and being honest about what the evidence can and can't actually tell you at each level, from one patient up to an entire literature.

From Averages to Trajectories: Mapping Case Series with the Avinash Principle

 

From Averages to Trajectories: Mapping Case Series with the Avinash Principle

Case series and case reports are usually read one patient at a time, then summarized into a table of aggregate percentages — X% had complication Y, median time to Z was N hours. Something gets lost in that flattening: the actual shape of how patients diverge from each other, and the specific checkpoint where a "normal" case turns into an outlier.

The Avinash Case-Series Trajectory Mapper is a small, focused extension of the Avinash Principle — the idea that expert clinical cognition doesn't calculate every branch of a decision tree, it prunes toward the handful of hub nodes that actually carry the trajectory's gravity. Applied to a single patient, that principle finds the 1% of nodes that matter for this case. Applied to a case series, it does something slightly different: it merges many patients' node chains into one network, so the textbook path and the outlier forks become visible side by side, as a picture instead of a table.

Three demo runs of the tool show what that looks like at three different levels of data quality — from rich individual trajectories, down to a published research paper that only reports aggregates.

How the mapper actually works

The tool runs a fixed three-step pipeline, laid out in the working prompt:

  1. Extract nodes per patient. Each case is compressed into 3–6 key events — a presentation node, a decision/intervention node, a reaction/complication node, a disposition node — never the full chart, only the events that would have changed the trajectory's direction if they'd gone differently. Time, objective values, and narrative/behavioral detail are captured at each node where the source reports them, and marked explicitly as missing where it doesn't.
  2. Merge into a network. Structurally equivalent nodes across patients get clustered into shared nodes. Edges are weighted by how many patients' paths pass through them. This surfaces the hub nodes (highest connectivity), the textbook path (the single highest-density route through the network), and the outlier paths — with the exact node and variation layer where each divergence happens.
  3. Render an interactive network. Node size encodes hub weight, edge thickness encodes shared-path frequency, and clicking a patient thread lights up their individual trajectory against the textbook path for direct comparison.

The one constraint that matters most, and the one the demos take seriously, is this: don't fabricate patient-level data the source doesn't contain. If a paper only gives aggregate percentages, the tool is required to say so plainly rather than quietly inventing joint trajectories that look more granular than the evidence actually supports.

Demo 1 — deeper data, real individual threads

mapping1.html runs the mapper against four unrelated cases pulled from individual e-log-book case discussions — a general presentation, a pancytopenia workup that turns into an outlier, an AKI-on-CKD case, and a CKD-on-MHD case. Because each source is a full narrative case write-up rather than a summary table, the mapper can extract genuine patient-level chains: real timestamps, real lab values, real narrative detail, for each of the four patients individually.

That's what "deeper data" buys here — the interactive plot can legitimately highlight a single patient's thread woven through the shared network and show, node by node, exactly where the pancytopenia case forks away from the more common path. The green highlighted route marks the textbook path; red marks outlier divergence; node size marks hub weight; edge thickness marks how many patients actually passed through that checkpoint. Nothing in this version is synthetic — every node traces back to a real, individually reported case.

Demo 3 — superficial data, the same structure with thinner evidence

mapping3.html takes the same pipeline and applies it to another set of unrelated cases — but this time the underlying write-ups are thinner: less granular timing, fewer objective values, sparser narrative context per checkpoint. The network still renders, the hub nodes and textbook path still emerge, but the honest thing the tool has to do here is show less confidence at each node — smaller variation spreads not because the disease is more homogeneous, but because the source material didn't report enough to characterize the spread.

Side by side, mapping1 and mapping3 make a point that's easy to miss when you only ever see one finished diagram: the same tool, run faithfully, produces different amounts of real signal depending entirely on what the underlying case reports actually contain. A trajectory map is only as deep as its source data — it can't manufacture granularity that was never written down.

Demo 2 — a published case series, and the limits of aggregate data

mapping2.html is the most instructive of the three, because it runs the mapper against something categorically different: a real, published, peer-reviewed case series — Strokes following snakebite envenomations: A systematic review and individual patient data meta-analysis (Almeida et al., PLoS Neglected Tropical Diseases, 2025), pooling 130 cases of stroke following snakebite.

Here the mapper runs directly into the constraint it's built to respect. The paper reports its 130 pooled cases almost entirely as aggregate frequencies across Tables 1–5. True individual, linked patient trajectories exist for only six fatal autopsy cases, tabulated separately in Table 6 — a Notechis scutatus bite, a Viperid case complicating into endocarditis, a C. o. helleri envenomation, a Bothrops atrox bite, a Daboia russelii case, and a Viperid bite with massive intracerebral hemorrhage.

The resulting map is explicit about this two-tier reality rather than blurring it:

  • The six fatal cases are rendered as genuine, individually threaded patient paths — real trajectories a user can click through and trace node by node, exactly as in mapping1.
  • The rest of the network — the grey and blue "population" nodes — represents sequential clinical checkpoints weighted by their marginal reported prevalence across the full 130-case cohort. The mapper is careful to label this for what it is: not a verified joint trajectory for the other 124 patients, because the paper's individual-level supplementary data wasn't available in the source document provided. Node weights are marginal percentages against whatever denominator each variable was actually reported against — n=130, n=111, n=102, n=117 — and those denominators are surfaced in the hover text rather than smoothed over.

This is the mapper doing exactly what its constraint demands: building the best network the paper's data can actually support, and drawing a hard line between the real threaded outliers and the population-level scaffolding around them — instead of quietly presenting 130 fabricated individual journeys that the source paper never actually gave it.

Why the distinction matters

Put the three demos next to each other and a single lesson falls out cleanly: a trajectory map is not a picture of the disease — it's a picture of the disease as far as the evidence lets you see it. Rich individual case narratives (mapping1) let hub nodes and outlier forks be traced with real confidence. Thinner case write-ups (mapping3) still produce a usable network, but an honest one shows its lower resolution rather than papering over it. And a published aggregate case series (mapping2) forces the sharpest discipline of all: report what's genuinely patient-linked, and clearly separate it from what's merely population-weighted scaffolding built to keep the rest of the network readable.

That discipline is the whole point of building this as a case-series extension of the Avinash Principle rather than a single-patient tool. The original principle is about a clinician pruning 60 million theoretical decision paths down to the 1% of nodes that matter for one patient in real time. This extension asks a related but distinct question: across a whole published cohort, where do individual patients' trajectories actually overlap into a real textbook path, and where does a paper's own reporting granularity quietly stop telling you the truth about any single patient at all? Getting that second question right — refusing to fabricate joint trajectories the source never gave you — is what keeps a trajectory map a genuine training tool instead of a confident-looking fiction.

Try it yourself

And for the underlying framework these all extend:

As with the single-patient version of this framework, none of this is meant to be read as ground truth about the underlying diseases. It's a sparring partner for building the specific, learnable skill of spotting real hub nodes and honestly distinguishing them from artifacts of thin reporting — not an answer key, and not a substitute for reading the primary literature itself.

The Avinash Principle: From One Trajectory to a Hundred — Mapping Case Series as Networks

The Avinash Principle: From One Trajectory to a Hundred — Mapping Case Series as Networks

Where the first two pieces left off

The first piece in this series established the core claim: expert clinical cognition doesn't calculate paths, it prunes them, collapsing millions of theoretical trajectories down to a handful of critical hub nodes. The second piece turned that claim into a forward-looking engine — tracking a single patient's state vector against attractor basins (Collapse, Goldilocks, Overtreatment), and favoring a single high-leverage "pull" over a continuous "push."

Both pieces, though, were built one patient at a time. A single snakebite case. A single phase-space plot. A single longitudinal forecast.

That's a deliberate simplification, and it has a limit. A hub node identified from one case is a hypothesis, not a finding. The tourniquet-removal node, the wage-loss/self-discharge node, the referral-timing node — each looked decisive for that farmer, on that evening, at that district hospital. Whether they're decisive in general, or just decisive for him, is a question no single trajectory can answer.

Answering it requires doing to a population of patients what the first piece did to a population of decisions: stop looking at one path, and start looking at the shape of many.

Step one: a trajectory is a chain of event-nodes

Strip a patient's course down to its skeleton and what's left is a short sequence of key events — not every vital sign or note, but the handful of moments that actually changed the trajectory's direction. For an ASV (anti-snake-venom) case series, four such nodes might be enough to carry the whole story:

  1. Presentation node — time since bite, local vs. systemic signs, 20WBCT result
  2. Decision node — ASV given / withheld, dose, timing
  3. Reaction node — anaphylaxis or no reaction, severity if present
  4. Disposition node — recovered, referred, complication, death

One patient, four nodes, three edges connecting them — a single thread through time. This is exactly the single-case trajectory the earlier pieces mapped by hand.

Now do it for a hundred patients.

Step two: overlay the threads, and a network appears

A hundred patients each contributing four nodes doesn't produce four hundred isolated points. It produces a network, because many of those nodes are, structurally, the same node wearing different clothes. Dozens of patients will share a presentation pattern ("bitten, symptomatic, WBCT-positive within 2 hours"). Dozens will share a decision pattern ("ASV given per protocol, no discretion left to shape it"). A much smaller cluster will share a reaction pattern ("mild urticaria, self-limited") — and a rarer cluster still will share a different one ("bronchospasm, required adrenaline").

Overlay a hundred four-node threads on top of each other, merge the nodes that represent the same clinical state, and what emerges is not a hundred lines — it's a graph, with:

  • Thick edges where many patients' trajectories pass through the same transition (the well-worn paths)
  • Thin edges where only one or two patients ever went (the rare paths)
  • Hub nodes with unusually high connectivity — states that a disproportionate share of trajectories pass through, either coming in or going out

This is the population-level version of the hub-node concept from the first piece, and it resolves the exact problem that piece left open. A node that looks critical in one case and turns out to be a hub across a hundred cases is a real hub — a genuine leverage point worth building a guideline around. A node that looked critical in one case but sits at the edge of the network, rarely visited, rarely connecting to anything else, is probably something else: a quirk of that patient's biology, or their biography, not a generalizable lesson.

Overlap is the filter. It's what separates this patient's critical node from the disease's critical node.

Step three: three kinds of variation ride along every edge

A network of bare event-nodes is already useful, but it flattens something important: not every patient who passes through the same two nodes got there the same way, or arrived at the same time. Three layers of variation need to travel along each edge, or the network turns into a caricature of the disease rather than a map of it.

Variation type What it captures Example, ASV series
Time variation How long each transition took, and how much that varied across patients Presentation-to-ASV interval ranging from 40 minutes to 9 hours
Objective data variation Spread in the measurable values at each node, not just its category WBCT clotting times, ASV vial count, platelet nadir
Subjective / narrative variation The experiencable layer from the first piece — the biographical detail that shaped the path but wouldn't show up on a lab slip Distance from home, prior traditional-healer use, wage-loss anxiety, family involvement

A node without this layer is just a label. A node with it becomes a small distribution — a spread of times, values, and narratives that all funneled through the same clinical checkpoint. That spread is where the next section's real payoff comes from.

Step four: the average forms the textbook case — and that's exactly its limitation

Once the network is built, one operation becomes trivially easy: find the highest-density path through it — the sequence of nodes and edges that the largest number of patients actually walked, with each node's variation collapsed to its central tendency.

That path is the textbook case. It is, almost by construction, what a review article or a guideline flowchart describes: bitten, symptomatic, WBCT-positive within roughly 2 hours, treated with the standard ASV protocol, no reaction, discharged well. It's true, it's representative, and it's the correct default expectation to walk into a ward with.

It is also, by definition, the least informative single trajectory in the entire dataset — because everything interesting about the disease lives in the trajectories that don't look like it.

Step five: outliers aren't noise around the average — they're the map's edges

This is the pivot the earlier pieces made about individual decisions, now applied to the population: the deviation isn't a mistake to be averaged away, it's data about where the system's boundaries actually are.

A patient whose reaction node shows severe anaphylaxis at a vial count everyone else tolerated isn't just a bad outcome — they mark the outer edge of the "safe dose" cluster, and the case-series network can show exactly which upstream nodes their trajectory shared with everyone else, and which one it diverged at. A patient who presented at 9 hours instead of 2 and still did well isn't just lucky — their trajectory shows which downstream nodes compensated for the delay, and which biographical or systemic factor bought them that time. A patient who died despite a textbook-looking early trajectory shows precisely where a node that looked routine for 99 other patients turned out to hide a phase-transition boundary for this one.

Nested analysis is what surfaces this: hold the network at the population level to see the textbook path and its thickness, then zoom into any single divergent thread to see exactly where, and along which variation layer (time, objective, narrative), it split off from the crowd. This is the same zoom discipline from the first piece — system gravity, then bifurcation tactics, then lock — just run against a population graph instead of a single case.

A case series network doesn't describe the average patient. It describes the shape of the disease — where its paths converge, where they fork, and how far a trajectory can drift from the textbook line before it stops being a variation and becomes a different outcome entirely.

What this is, precisely: visualization of a case series

Framed plainly, this is a specific and useful thing: trajectory mapping of cases = case series, visualized as an overlapping event-node network rather than a table of outcomes.

It differs from a conventional case series in three ways that matter:

  1. A conventional case series reports outcomes. A trajectory network reports structure — which nodes cluster, which ones bridge across most patients, which ones sit at the network's edge, rarely visited but consequential when they are.
  2. A conventional case series buries variation in a range or an IQR. A trajectory network keeps time, objective, and narrative variation attached to the specific node they belong to — so a wide spread at the reaction node and a wide spread at the presentation node remain visibly distinct problems, rather than dissolving into one aggregate statistic for the whole cohort.
  3. A conventional case series treats outliers as a limitations paragraph. A trajectory network treats them as the edges of the disease's actual phase space — worth a dedicated zoom-in, not a footnote.

It also inherits the same discipline the first piece insisted on for individual cases: this is a scaffold for seeing structure, not a black box that outputs a verdict. The value isn't a network diagram to file away — it's the practice of looking at a hundred trajectories at once and asking the same question the Avinash Principle asks of one: which handful of nodes, and which specific deviations from them, actually carry the gravity of this disease.

A minimal working structure

For a case series of N patients with k key events each:

1. Node extraction (per patient)

  • Identify the k clinically decisive events — not every data point, only the ones that would change the trajectory's direction if they'd gone differently
  • Tag each with its three variation layers: time, objective, narrative

2. Node merging (across patients)

  • Cluster structurally equivalent nodes across patients into shared network nodes
  • Weight each edge by patient count — thick for common transitions, thin for rare ones

3. Textbook path extraction

  • Trace the maximum-density path through the merged network
  • Report each node's central tendency across all three variation layers — this is the guideline-shaped summary

4. Outlier isolation

  • Flag trajectories whose path, or whose node-level variation, sits furthest from the textbook path
  • For each, identify the specific node and specific variation layer where the divergence began — not "this patient was atypical," but "this patient's clotting time at presentation was within range, but their time-to-ASV was 3x the cohort median, and that's where the trajectory forked"

5. Nested zoom

  • Population view: network shape, hub thickness, textbook path
  • Single-thread view: one outlier's trajectory traced against the textbook path, node by node
  • Node view: the full variation spread at one specific checkpoint, across every patient who passed through it

This is the same node, this is the same principle, run at a different resolution — a hundred single-case maps from the first two pieces, overlapped until the population's own gravity becomes visible, with the textbook case sitting at its center and every outlier marking exactly how far, and in which direction, the disease is willing to drift before it becomes something else.

Where this leaves the series

The first piece asked how a single expert prunes a single case down to the 1% that matters. The second asked how that pruned trajectory could be tracked and steered forward in time. This piece asks the natural third question: what happens when the 1% found in one case is checked against the 1% found in ninety-nine others — and the answer is that overlap is what turns a clinical instinct into a structural fact, and divergence from the average is what turns a case series from a table of outcomes into a map of the disease itself.