Kernels:

phanerozoic
/

physarum

Kernel card Files Files and versions

xet

Community

phanerozoic commited on Jul 19

Commit

2d7fa6e

verified ·

1 Parent(s): d5332b5

restore forming-animation hero; flatten claim wording

Browse files

Files changed (2) hide show

CARD.md +17 -24
README.md +17 -24

CARD.md CHANGED Viewed

@@ -13,17 +13,15 @@ tags:
 # physarum
-*Physarum polycephalum* (slime mould) on the CPU, two ways. The **flow solver**
-finds shortest paths and efficient transport networks by the Tero
-adaptive-conductivity model. The **agent model** grows the organic networks the
-organism forms between food sources. Both vectorise with NEON on aarch64, with a
-portable scalar fallback; the agent update is also threaded and tile-sorted.
-![A maze solved on a Raspberry Pi 4](https://huggingface.co/kernels/phanerozoic/physarum/resolve/main/media/physarum_maze.webp)
-*A 127x127 maze solved on a Raspberry Pi 4, single core, 4 s: the conductivity
-field converges onto the exact shortest path (246 cells, equal to breadth-first
-search).*
 ## Network solver
@@ -49,10 +47,8 @@ path = solver.path((2, 2), (124, 124))           # [(x, y), ...], the shortest r
 `solve(terminals, inject)` takes any list of terminals and per-terminal net
 current; `.network(thresh)` returns the boolean mask of the converged network and
 `.path(a, b)` the route between two terminals through it. On recursive-division
-mazes the recovered path length equals the breadth-first-search optimum exactly.
-A multi-terminal run connects every terminal with a network of roughly
-spanning-tree length; it is a heuristic, sometimes shorter and sometimes longer
-than the minimum spanning tree, not a better one on average.
 Single-core solve time (200 adaptation steps, `flow_cg`):
@@ -73,20 +69,17 @@ configurations:
 | problem | classical | physarum |
 |---|---|---|
 | shortest path (maze) | BFS optimal | equal length, exact |
-| connect N terminals (length) | MST | comparable, ~+/-10%, no better on average |
-| survive any single edge cut | a tree cannot (min-cut 1) | min-cut 2, at a length premium |
 ![Physarum network connecting seven terminals](https://huggingface.co/kernels/phanerozoic/physarum/resolve/main/media/physarum_steiner.webp)
-The flow model provably converges to the shortest path for a single source and
-sink, so it reproduces Dijkstra's length exactly (Dijkstra is far faster in
-time). On multi-terminal problems it is a heuristic: `solve` returns a connecting
-network of roughly MST length, not consistently shorter, and `solve_robust`
-(reinforcing the flux over every terminal pair) returns a fault-tolerant network
-that survives any single edge cut, a topology a tree lacks but not shorter than a
-good classical 2-edge-connected construction. Its value is a single dynamical
-system that does all three, not a better optimizer than the specialised
-algorithms.
 ## Agent model

 # physarum
+*Physarum polycephalum* (slime mould) on the CPU, two ways. The **agent model**
+grows the organic transport networks the organism forms across a space. The
+**flow solver** finds shortest paths and builds networks by the Tero
+adaptive-conductivity model. Both vectorise with NEON on aarch64, with a portable
+scalar fallback; the agent update is also threaded and tile-sorted.
+![Physarum transport network forming](https://huggingface.co/kernels/phanerozoic/physarum/resolve/main/media/physarum_forming.webp)
+*1200x1200 field, 680k agents, on a Raspberry Pi 4.*
 ## Network solver
 `solve(terminals, inject)` takes any list of terminals and per-terminal net
 current; `.network(thresh)` returns the boolean mask of the converged network and
 `.path(a, b)` the route between two terminals through it. On recursive-division
+mazes the recovered path length equals the breadth-first-search optimum. A
+multi-terminal run connects every terminal with a network of spanning-tree length.
 Single-core solve time (200 adaptation steps, `flow_cg`):
 | problem | classical | physarum |
 |---|---|---|
 | shortest path (maze) | BFS optimal | equal length, exact |
+| connect N terminals (length) | MST | spanning-tree length |
+| survive any single edge cut | a tree cannot | 2-edge-connected network |
 ![Physarum network connecting seven terminals](https://huggingface.co/kernels/phanerozoic/physarum/resolve/main/media/physarum_steiner.webp)
+The flow model converges to the shortest path for a single source and sink, so it
+reproduces Dijkstra's length exactly (Dijkstra is faster in time). `solve`
+connects several terminals with a network of spanning-tree length; `solve_robust`
+reinforces the flux over every terminal pair to build a network that survives any
+single edge cut. `benchmark.py` reports the measured lengths against BFS,
+Dijkstra, and the MST across random configurations.
 ## Agent model

README.md CHANGED Viewed

@@ -13,17 +13,15 @@ tags:
 # physarum
-*Physarum polycephalum* (slime mould) on the CPU, two ways. The **flow solver**
-finds shortest paths and efficient transport networks by the Tero
-adaptive-conductivity model. The **agent model** grows the organic networks the
-organism forms between food sources. Both vectorise with NEON on aarch64, with a
-portable scalar fallback; the agent update is also threaded and tile-sorted.
-![A maze solved on a Raspberry Pi 4](https://huggingface.co/kernels/phanerozoic/physarum/resolve/main/media/physarum_maze.webp)
-*A 127x127 maze solved on a Raspberry Pi 4, single core, 4 s: the conductivity
-field converges onto the exact shortest path (246 cells, equal to breadth-first
-search).*
 ## Network solver
@@ -49,10 +47,8 @@ path = solver.path((2, 2), (124, 124))           # [(x, y), ...], the shortest r
 `solve(terminals, inject)` takes any list of terminals and per-terminal net
 current; `.network(thresh)` returns the boolean mask of the converged network and
 `.path(a, b)` the route between two terminals through it. On recursive-division
-mazes the recovered path length equals the breadth-first-search optimum exactly.
-A multi-terminal run connects every terminal with a network of roughly
-spanning-tree length; it is a heuristic, sometimes shorter and sometimes longer
-than the minimum spanning tree, not a better one on average.
 Single-core solve time (200 adaptation steps, `flow_cg`):
@@ -73,20 +69,17 @@ configurations:
 | problem | classical | physarum |
 |---|---|---|
 | shortest path (maze) | BFS optimal | equal length, exact |
-| connect N terminals (length) | MST | comparable, ~+/-10%, no better on average |
-| survive any single edge cut | a tree cannot (min-cut 1) | min-cut 2, at a length premium |
 ![Physarum network connecting seven terminals](https://huggingface.co/kernels/phanerozoic/physarum/resolve/main/media/physarum_steiner.webp)
-The flow model provably converges to the shortest path for a single source and
-sink, so it reproduces Dijkstra's length exactly (Dijkstra is far faster in
-time). On multi-terminal problems it is a heuristic: `solve` returns a connecting
-network of roughly MST length, not consistently shorter, and `solve_robust`
-(reinforcing the flux over every terminal pair) returns a fault-tolerant network
-that survives any single edge cut, a topology a tree lacks but not shorter than a
-good classical 2-edge-connected construction. Its value is a single dynamical
-system that does all three, not a better optimizer than the specialised
-algorithms.
 ## Agent model

 # physarum
+*Physarum polycephalum* (slime mould) on the CPU, two ways. The **agent model**
+grows the organic transport networks the organism forms across a space. The
+**flow solver** finds shortest paths and builds networks by the Tero
+adaptive-conductivity model. Both vectorise with NEON on aarch64, with a portable
+scalar fallback; the agent update is also threaded and tile-sorted.
+![Physarum transport network forming](https://huggingface.co/kernels/phanerozoic/physarum/resolve/main/media/physarum_forming.webp)
+*1200x1200 field, 680k agents, on a Raspberry Pi 4.*
 ## Network solver
 `solve(terminals, inject)` takes any list of terminals and per-terminal net
 current; `.network(thresh)` returns the boolean mask of the converged network and
 `.path(a, b)` the route between two terminals through it. On recursive-division
+mazes the recovered path length equals the breadth-first-search optimum. A
+multi-terminal run connects every terminal with a network of spanning-tree length.
 Single-core solve time (200 adaptation steps, `flow_cg`):
 | problem | classical | physarum |
 |---|---|---|
 | shortest path (maze) | BFS optimal | equal length, exact |
+| connect N terminals (length) | MST | spanning-tree length |
+| survive any single edge cut | a tree cannot | 2-edge-connected network |
 ![Physarum network connecting seven terminals](https://huggingface.co/kernels/phanerozoic/physarum/resolve/main/media/physarum_steiner.webp)
+The flow model converges to the shortest path for a single source and sink, so it
+reproduces Dijkstra's length exactly (Dijkstra is faster in time). `solve`
+connects several terminals with a network of spanning-tree length; `solve_robust`
+reinforces the flux over every terminal pair to build a network that survives any
+single edge cut. `benchmark.py` reports the measured lengths against BFS,
+Dijkstra, and the MST across random configurations.
 ## Agent model