Skip to content
Cohesion Dynamics (CD)

Petri Net Lens Demo (K-LENS-PN)

This interactive demo illustrates how the Petri Net Lens (K-LENS-PN) faithfully represents Simple Core Cohesion Dynamics concepts:

  • Domain members participate autonomously
  • Obligations impose participation constraints
  • Resolutions are atomic (no partial resolution)
  • Multiple resolution pathways may be admissible in principle
  • Only one resolution actualizes in realized history

Interactive Demo

Understanding the Demo

Scenario: One Obligation, Two Admissible Resolvers

This demo presents the simplest non-trivial case in Simple Core CD:

  • One obligation is outstanding (represented as a token in the “Obligation” place)
  • Two domain members (A and B) can in principle participate in resolving it
  • Two resolution pathways are admissible (transitions “Resolution A” and “Resolution B”)
  • Exactly one resolution can occur (atomicity constraint)

Petri Net Elements

Places (circles):

  • Represent obligation contexts
  • The single place labeled “Obligation” holds the outstanding obligation token

Tokens (small dots):

  • Represent outstanding obligation instances
  • Initially, one token is present in the Obligation place

Transitions (rectangles):

  • Represent admissible resolutions (participation events)
  • Labeled with the domain member who participates (Member A or Member B)
  • Green transitions are enabled (can fire)
  • Gray transitions are disabled (cannot fire)

Arcs (arrows):

  • Show flow relationships
  • Arrows from place to transitions indicate that the obligation must be present for resolution to be possible

How to Use the Demo

Manual Mode:

  • Click an enabled (green) transition to fire it manually
  • This represents that specific domain member actualizing their participation

Auto Mode:

  • Click “Run Once” to randomly select one enabled transition and fire it
  • Optional: Use the seed input for reproducible runs

Reset:

  • “Reset” restores the initial state (one obligation, both resolutions enabled)

Replay:

  • “Replay” resets and immediately runs once (for quick experimentation)

What Happens When a Transition Fires

  1. The obligation token is consumed (removed from the place)
  2. One resolution is actualized (recorded in the state panel)
  3. The other resolution pathway becomes disabled (turns gray)
  4. The event log records the sequence of events

This demonstrates:

  • Atomic resolution: The obligation state changes completely in one event
  • Single actualization: Only one resolution occurs, not both
  • Non-singular admissibility: Both pathways were enabled, but only one actualized

Conceptual Framing

This Is a Lens-Level View

K-LENS-PN is a representational lens, not an ontological claim. The Petri net structure provides a faithful way to visualize Simple Core dynamics, but:

  • ❌ Petri nets are not the fundamental substrate
  • ❌ This is not a physical simulator
  • ✅ This is a valid representation of K-KERN grammar under appropriate assumptions
  • ✅ This does capture the essential Simple Core semantics

Domain Members as Transition Labels

Important representational choice:

  • Domain members are represented as labels on transitions (e.g., “Member A”)
  • Domain members are not represented as tokens
  • Tokens represent obligation instances, not participants

This aligns with Simple Core ontology: domain members are autonomous participants whose actions resolve obligations, not resources to be consumed.

Non-Singular Admissibility vs. Single Actualization

This demo makes concrete the distinction between:

  • Admissible: Multiple transitions may be enabled (both A and B can fire)
  • Actual: Only one transition fires (either A or B, not both)

The enabled transitions represent pathways that are possible in principle. Firing one transition represents what actually occurs. This is not ontological branching or “many worlds”—it’s simply the difference between what could happen and what does happen.

Conflict = Exclusive Resolution

In Petri net terminology, enabled transitions with a shared input place are in conflict. In K-LENS-PN, this conflict enforces the Simple Core semantics:

  • Multiple resolutions may be admissible
  • But firing one resolution consumes the shared obligation
  • Which disables the incompatible alternatives
  • Exactly one resolution actualizes

What This Demo Does NOT Represent

Following the issue requirements, this demo explicitly avoids:

  • ❌ Probability amplitudes or stochastic rates (beyond simple random choice)
  • ❌ Spacetime, locality, metrics, or clocks
  • ❌ Physical dynamics or forces
  • ❌ Wavefunction ontology or quantum superposition
  • ❌ Branching histories or parallel worlds

This is a conceptual demonstration of Simple Core representational capacity, not a physics simulation.

Relation to K-LENS-PN Paper

This demo illustrates concepts from the K-LENS-PN paper:

  • Configuration-place correspondence: The obligation state maps to the place marking
  • Resolution-transition correspondence: Each resolution pathway maps to a transition
  • Admissibility-enabling correspondence: Enabled transitions = admissible resolutions
  • Conflict = irreconcilability: Shared input place enforces exclusive resolution
  • Single-history semantics: Only one transition fires, not multiple

For the full theoretical treatment, see the paper.

Extensions and Limitations

Current Scope

  • Single obligation
  • Two resolution pathways
  • No sequential dependencies
  • No resource production (transitions only consume)

Possible Extensions (Not Implemented)

  • Multiple obligations in sequence
  • Complex dependency structures
  • Obligation generation (tokens produced by transitions)
  • Hierarchical composition

The current scope is deliberately minimal to clearly demonstrate the core concepts without additional complexity.

Terminology Alignment

This demo uses Simple Core Cohesion Dynamics terminology:

  • Obligation: Outstanding constraint requiring resolution
  • Domain member: Autonomous participant (represented as transition label)
  • Resolution: Participatory event that resolves an obligation (transition firing)
  • Admissibility: Whether a resolution pathway is enabled in principle
  • Actualization: Which resolution pathway fires in realized history
  • Atomicity: Resolution is all-or-nothing, no partial states

Summary

This demo shows how Petri nets can faithfully represent Simple Core CD semantics:

✅ Autonomous participation (no central coordinator)
✅ Obligation-driven dynamics (tokens as constraints)
✅ Non-singular admissibility (multiple enabled transitions)
✅ Single actualization (exactly one fires)
✅ Atomic resolution (complete state change)
✅ Consistent participation (no contradictory outcomes)

The Petri Net Lens (K-LENS-PN) provides a clean, visual, and executable representation of these foundational concepts.