0) Alignment to the Project’s Ends → Ways → Means
The claim is: a “global WBS view” is a global section; incompatibility is a non-vanishing obstruction (or a flagged residual).
The two approaches differ mainly in whether you want hard certificates (A) or soft localisation and learned diagnostics (B).
Ends (global, continuous, metric-ready)
- Global view patched from local data = compute H⁰ (global sections) and show the section explicitly.
- Continuity = local agreement on overlaps (interfaces) implies a unique glued plan; discontinuities are “where restrictions disagree”.
- Metric-ready = evaluate a functional on the global section (expected risk, staff-hours, schedule slack), and/or a spectral invariant on the sheaf Laplacian.
Ways (sheaf/cohomology pipeline over WBS graph)
- Model WBS as a category (objects = work packages; arrows = dependencies/interfaces).
- Attach local data to stalks (risk sets, resource functions, interface specs).
- Restriction maps encode interface conditions (handover, precedence, tolerances).
- Then: glue if possible; else compute obstruction / residual and localise.
Means (interactive HTML + LLM-friendly analytics)
The MVP is an explorable WBS graph, editable local data, and a “Glue” button that either returns a global section
or highlights the minimal conflicting overlap(s). Everything else is second-order polish.
What changes in practice
Old world: "Does the plan work?" → meetings, gut feel, spreadsheet juggling. Sheaf world: "Does a global section exist?" → a yes/no + explicit witness. If no: "Where is the obstruction supported?" → highlight overlaps/edges + remediation hints.
1) Prototype A — PySheaf notebooks: exact global-section consistency
Use a cellular sheaf backend for crisp certificates: compute global sections (and, if desired, cohomology) on a WBS dependency complex.
What it is
- Model your WBS/dependency graph as a cell complex (or poset).
- Attach stalks: sets (discrete risk scenarios) or vector spaces (parameterised interface/resource quantities).
- Attach restriction maps: “handover projections”, inequality constraints, interface consistency maps.
- Compute: Γ / H⁰ (global sections), optionally H¹ for obstruction localisation.
Why it helps your ends
- Auditability: a global plan is an explicit section (data assignment per work package) with a proof of compatibility.
- Minimal blame: if no section exists, the obstruction lives on overlaps; you can name the failing interfaces, not just wave at “complexity”.
- Metric pipeline: once a section exists, compute project-level functionals (risk expectation, cost integrals, constraint slack).
Concrete deliverable
Notebook pack: 01_build_wbs_complex.ipynb 02_define_sheaves_risk_resource.ipynb 03_global_sections_and_H0.ipynb 04_inject_conflict_show_obstruction.ipynb Export: - JSON witness of global section - List of conflicting edges (if none) - Optional: eigenpairs of sheaf Laplacian for diagnostics
Preferred role in the full stack
PySheaf is your “ground truth engine”: a crisp solver/checker used for small-to-mid models, CI tests, and generating labelled examples.
It also supplies training/evaluation data for the learned spectral layer in Prototype B.
2) Prototype B — Neural Sheaf Diffusion: learned propagation & spectral diagnostics
Treat constraints as a diffusion operator on a sheaf; push signals around heterophilous interfaces; learn restriction maps; use persistent sheaf Laplacians for multi-scale alarms.
What it is
- Neural Sheaf Diffusion implements sheaf-Laplacian-style propagation on graphs where “neighbours differ” (heterophily), common in multi-discipline projects.
- Instead of only asking “global section exists?”, you get where tensions accumulate via residuals / diffusion dynamics / spectrum.
- Recent persistent sheaf Laplacian work suggests a multi-scale spectral signature: small eigenvalues emerging at certain filtrations can flag structural inconsistency onset.
Why it helps your ends
- Localisation: diffusion highlights which interfaces “carry” inconsistency even before it blocks a global section.
- Learning: you can infer restriction maps/topology from observed project telemetry (rates, costs, defects) rather than hand-coding everything.
- Scalability: once learned, the operator can run fast over large WBS graphs for near-real-time “health fields”.
How it complements Prototype A
A (PySheaf): "Is there a global section?" → certificate / counterexample. B (NSD + persistent spectra): "Where is the project stiff / inconsistent / heterophilous?" → heatmap & early warning. Together: A gives ground-truth labels; B gives scalable detection + localisation.
3) Unifying Model: one WBS, many sheaves, one patchable “global project”
The unification move is to treat scope, interfaces, schedule, resources, and risk as separate (possibly coupled) sheaves over the same base category,
then define a project-level fitness functional over their global sections (or over the obstruction landscape if no section exists).
Base category
- Objects: work packages (or interfaces / documents) in the WBS graph.
- Morphisms: precedence, information dependency, interface relation, or overlap inclusion (depending on the view).
- You can run multiple topologies: a cover by disciplines, by phases, by physical zones (useful for a tunnel example).
Example sheaves (stalks → restrictions)
- Risk sheaf: discrete scenarios per task; restriction maps enforce dependency constraints and propagate feasible scenarios.
- Resource sheaf: functions over time/space per phase; restrictions are interval restrictions on overlaps; gluing yields a global resourcing function.
- Interface/spec sheaf: parameter vectors per interface; restrictions are projection/aggregation maps; global section = consistent interface book.
Coupling
- Form products: F = Risk × Resources × Interface × ….
- Or define natural transformations between sheaves to encode “risk depends on resources” etc.
- Then compute sections jointly (or solve sequentially with constraints).
The key promise
Global WBS is no longer a monolithic artefact. It is: "the space of global sections" (possibly empty, possibly many). Project governance becomes: pick a section; track drift; detect obstruction early.
4) Interactive Mini-Demo: Glue / Obstruction on a “Solway Firth Tunnel” WBS
This demo is deliberately tiny, but it’s shaped like the artefact we’d ship: editable local stalks + restriction maps + solver + explanation.
editable local data
consistent
obstruction
warning / residual
Ready.
Select a node to inspect/edit local data, then press “Glue”.
Inspector
Click a node in the graph to view/edit its local stalks.
Result
—
How to read this
- Risk stalks are discrete values per work package.
- Restriction maps here are simple inequalities per dependency edge.
- “Glue” tries to find an assignment to all tasks that satisfies all edge constraints; if none exists it highlights the failing edge(s).
5) Metrics & “Continuity”: from global section to project fitness functional
Once you have a section (or an obstruction landscape), you can treat project “health” as a function on that space—either scalar or field-valued.
Scalar metrics (cheap and useful)
- Expected risk = Σ (risk(t) · weight(t)) computed from the global risk section.
- Total staff-hours = ∫ f_global(t) dt from the global resource function section.
- Schedule slack = derived from feasible start/finish windows in a schedule sheaf section.
Field metrics (continuous-ish)
- Residual field on edges: how badly restrictions disagree (when no exact section exists).
- Spectral diagnostics: eigenvectors of sheaf Laplacian as “stress modes” localising tension.
- Persistence: track spectral features across filtrations (“add constraints gradually”) to see when inconsistency appears.
How this realises your “continuous project metric” idea
Pick a topology (cover) on your WBS category that corresponds to how the project is observed: - by discipline - by contract package - by physical zone (e.g., launch shaft / bore / reception shaft) - by time windows Then define a functional J on sections: J(s) = ∫ cost_density(s, x) dx (continuous) or J(s) = Σ penalty_edge(s|overlap) (discrete) Continuity is then: small local changes cause small changes in J (especially when using vector-space stalks + Laplacians).
6) Roadmap & Risks: what we ship, how we validate
The audit recommendation is to go straight to a React/HTML canvas MVP: graph + glue + obstruction + exportable witness.
Phase 1 — MVP (1–2 iterations)
- Interactive HTML (like the demo) driven by a JSON schema: tasks, edges, stalks, restrictions.
- Exact solver: find section or return a minimal inconsistent edge-set (certificate).
- Export: global section JSON + “obstruction report” + simple metric.
Phase 2 — PySheaf back-end
- Implement the same schema in a notebook; compute H⁰ (and optionally H¹).
- Use it as “truth oracle” + regression tests.
- Start building a library of WBS cases (including tunnel packages).
Phase 3 — Neural/spectral layer
- Run Neural Sheaf Diffusion to generate tension heatmaps over large graphs.
- Try persistent sheaf Laplacian spectra as multi-scale diagnostics.
- Optionally learn restriction maps from telemetry to reduce hand-modelling burden.
Risks & mitigations
- Overpromising “continuity”: mitigate by explicitly defining topology/cover and metric functional.
- Scaling exact solvers: mitigate by using exact for small graphs + learned/spectral for large graphs.
- Data elicitation: mitigate by defining a minimal schema that maps cleanly onto existing PM tools (IDs, dates, resources, risk registers).
7) References
Links are included so the proposal is runnable as a standalone document. (You can later replace with your own permalinks / repo paths.)
- PySheaf:
https://github.com/kb1dds/pysheafand docshttps://kb1dds.github.io/pysheaf/ - Neural Sheaf Diffusion (official code):
https://github.com/twitter-research/neural-sheaf-diffusion - NeurIPS 2022 paper page:
https://proceedings.neurips.cc/paper_files/paper/2022/(Neural Sheaf Diffusion) - Persistent sheaf Laplacians:
https://www.aimsciences.org/article/doi/10.3934/fods.2024033 - Learning restriction maps (2025):
https://arxiv.org/abs/2501.19207
Note on “less popular but useful” lens
A good contrarian spine here is: treat planning as sheafification. Instead of: "We have a plan, now validate it." Prefer: "We have a presheaf of partial commitments; planning is the left adjoint that forces gluing." This aligns with the “creative preservation” literature on sheafification as a design technique, and it makes your global plan literally the associated sheaf (not a spreadsheet artifact).