eyeling 1.22.15 → 1.22.16

package/HANDBOOK.md

@@ -35,6 +35,7 @@
 - [Appendix H — Applied Constructor-Theory and the N3 ARC examples](#app-h)
 - [Appendix I — The Eyeling Playground](#app-i)
 - [Appendix J — Formalism Is Fine](#app-j)
+- [Appendix K — Whitehead-inspired becoming examples](#app-k)
 
 ---
 
@@ -3680,3 +3681,23 @@ Herbrand semantics is fine because it gives symbolic reasoning a concrete semant
 Gödel incompleteness is fine because the limits of formal systems are not a refutation of formal reasoning. They are part of its shape. Once a system becomes expressive enough, one should expect structural limits on what it can prove about itself. That does not make formal methods less serious. It shows that their boundaries are principled rather than accidental. For a handbook like this one, that is the right lesson: formal systems are valuable not because they say everything, but because they say some things clearly, explicitly, and in a form that can be checked.
 
 Taken together, these positions support a straightforward attitude toward Eyeling. Horn logic is fine. Notation3 is fine. Executable specification is fine. Herbrand semantics is fine. Gödel incompleteness is fine. None of these commitments make the reasoner narrower in a harmful sense. They make it clearer, easier to inspect, and easier to trust. For this project, that is enough.
+
+<a id="app-k"></a>
+
+## Appendix K — Whitehead-inspired becoming examples
+
+A small family of examples in the repository explores a common idea: that logic can describe not only what **is** the case, but what a thing, system, lineage, or device can **become**. The inspiration is Whiteheadian in a broad sense. The examples do not attempt to formalize Whitehead’s metaphysics as scholarship. Instead, they borrow one guiding intuition from it: reality is often better understood as a structured passage from one state to another than as a mere inventory of static objects.
+
+In N3 terms, this means the examples are written so that rules describe **state-transition potential**. Earlier examples in the handbook often use predicates such as `:can`, `:cannot`, `:supports`, or `:requires`. The becoming family shifts the emphasis toward predicates such as `:canBecome` and `:cannotBecome`, along with intermediate states such as protected dormancy, germination, negative differential response, or adaptive persistence. This is still ordinary Horn-style reasoning. The novelty is not in the engine, but in the modeling style.
+
+The seven current becoming examples span several domains. One is a pure Whiteheadian toy model, where actual occasions prehend a past, respond to a lure of possibility, and become objectively available for future occasions. Others translate the same pattern into engineering revision, developmental genetics, control-systems design, constructor-theoretic task transition, barley-seed lineage renewal, and tunnel-junction wake switching. The common thread is always the same: an entity inherits a prior condition, encounters some enabling or disabling structure, and either reaches a new stabilized state or fails to do so.
+
+That common pattern makes the examples useful pedagogically. They show that Eyeling is not limited to taxonomies, datatype checks, or one-step deductions. It can also express **process descriptions** in a compact symbolic form. A design revision can become a new approved baseline. A cell state can become a differentiated lineage state. A controller can become a validated closed-loop design. A substrate can become a new attribute-state under a possible task. A seed lineage can become a self-renewing cycle. A tunnel junction can become a low-bias wake-serving device.
+
+These examples are also helpful because they keep different levels of abstraction visible. Some of them are deliberately metaphysical, some quasi-biological, some engineering-oriented, and some constructor-theoretic. But they all run through the same reasoner, using the same underlying machinery: terms, triples, forward rules, and closure. That is a quiet but important point. Eyeling does not care whether the domain is philosophy, control theory, genetics, or device physics. What matters is whether the modeled transitions can be stated clearly enough as explicit conditions and consequences.
+
+The becoming examples should therefore be read as **executable schemata** rather than as complete scientific models. They intentionally simplify their domains. The engineering example does not replace design verification. The genetics example does not replace systems biology. The constructor-theory example does not replace the theory itself. And the Whitehead example is not a substitute for reading Whitehead. What the examples do show is that N3 can serve as a clean medium for expressing relational process in a way that remains inspectable, runnable, and easy to vary.
+
+For the handbook, these examples matter for two reasons. First, they provide a concrete demonstration that Eyeling can handle a style of reasoning that feels closer to **becoming, development, and transformation** than to static classification. Second, they show how expressive gains can come from modeling choices rather than from adding new machinery to the engine. The same forward-chaining core that proves `:Socrates a :Mortal` can also prove that a lineage becomes evolvable, that a controller becomes approved, or that a wake switch becomes serviceable under a low-bias regime.
+
+That is why this appendix belongs after Appendix J. “Formalism is fine” not only because it supports rigor, but because it can remain flexible enough to describe worlds in motion. The becoming examples are small demonstrations of that claim. They show that a compact N3 reasoner can host process-oriented models without ceasing to be simple, readable, and executable.

package/examples/barley-seed-becoming.n3

@@ -0,0 +1,497 @@
+# ==========================================================================
+# This example reframes the barley-seed example as a logic of becoming.
+# A lineage is treated not as a static object but as a repeatable passage:
+# dormant seed -> germination -> adult plant -> next protected seed.
+#
+# The viable lineage:
+#   mainLine
+#
+# The contrast lineages:
+#   analogLine   - hereditary information is not digitally instantiated
+#   fragileLine  - there is no repair support
+#   coatlessLine - there is no protected dormant stage
+#   staticLine   - there is no heritable variation
+#
+# The point is to show both:
+#   - what a viable barley lineage can become
+#   - what a contrast lineage cannot become when key ingredients are missing
+# ==========================================================================
+
+@prefix : <http://example.org/barley-seed-becoming/> .
+@prefix arc: <https://example.org/arc#> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+:case a arc:Case ;
+  arc:question "Can a barley seed lineage become a self-renewing and adaptively persistent cycle under no-design laws — and what blocks that becoming when digital heredity, repair, protected dormancy, or variation are missing?" .
+
+# ------------------------
+# Shared world assumptions
+# ------------------------
+
+:world :obeys :NoDesignLaws .
+:zygote a :DevelopmentalBottleneck .
+
+:dnaRegister a :DigitalInformationMedium .
+:analogRegister a :NonDigitalInformationMedium .
+
+:greenhouse a :GrowthEnvironment ;
+  :condition :WarmthAvailable ;
+  :condition :MoistureAvailable ;
+  :condition :LightAvailable .
+
+:nutrientBed a :RawMaterialSupply .
+:pollinationLoop a :ReproductionSupport .
+:salineBench a :SelectionEnvironment ;
+  :favours :SaltTolerant .
+
+# ---------------------
+# 1. The viable lineage
+# ---------------------
+
+:mainGenome a :Replicator ;
+  :accuracy :High ;
+  :storedIn :dnaRegister ;
+  :variant :SaltTolerant .
+
+:mainRepair a :RepairVehicle .
+
+:mainEmbryoVehicle a :Vehicle ;
+  :function :Metabolism ;
+  :function :Development ;
+  :function :CopyingSupport ;
+  :function :CompartmentControl ;
+  :usesRepair :mainRepair .
+
+:mainAdultVehicle a :Vehicle ;
+  :function :Metabolism ;
+  :function :Development ;
+  :function :GameteProduction ;
+  :function :SeedConstruction .
+
+:mainSeedCoat a :Compartment ;
+  :function :DormancyProtection .
+
+:mainSeed a :Organism ;
+  :lifeStage :DormantSeed ;
+  :hasReplicator :mainGenome ;
+  :hasVehicle :mainEmbryoVehicle ;
+  :hasCompartment :mainSeedCoat .
+
+:mainAdult a :Organism ;
+  :lifeStage :AdultPlant ;
+  :hasReplicator :mainGenome ;
+  :hasVehicle :mainAdultVehicle .
+
+:mainLine a :Lineage ;
+  :seedStage :mainSeed ;
+  :adultStage :mainAdult ;
+  :replicator :mainGenome ;
+  :variant :SaltTolerant ;
+  :variationStatus :Present .
+
+# ----------------------------------------------
+# 2. Contrast lineages used for blocked becoming
+# ----------------------------------------------
+
+:analogGenome a :Replicator ;
+  :accuracy :High ;
+  :storedIn :analogRegister ;
+  :variant :SaltTolerant .
+
+:analogRepair a :RepairVehicle .
+
+:analogEmbryoVehicle a :Vehicle ;
+  :function :Metabolism ;
+  :function :Development ;
+  :function :CopyingSupport ;
+  :usesRepair :analogRepair .
+
+:analogAdultVehicle a :Vehicle ;
+  :function :Metabolism ;
+  :function :Development ;
+  :function :GameteProduction ;
+  :function :SeedConstruction .
+
+:analogSeedCoat a :Compartment ;
+  :function :DormancyProtection .
+
+:analogSeed a :Organism ;
+  :lifeStage :DormantSeed ;
+  :hasReplicator :analogGenome ;
+  :hasVehicle :analogEmbryoVehicle ;
+  :hasCompartment :analogSeedCoat .
+
+:analogAdult a :Organism ;
+  :lifeStage :AdultPlant ;
+  :hasReplicator :analogGenome ;
+  :hasVehicle :analogAdultVehicle .
+
+:analogLine a :Lineage ;
+  :seedStage :analogSeed ;
+  :adultStage :analogAdult ;
+  :replicator :analogGenome ;
+  :variant :SaltTolerant ;
+  :variationStatus :Present .
+
+:fragileGenome a :Replicator ;
+  :accuracy :High ;
+  :storedIn :dnaRegister ;
+  :variant :SaltTolerant .
+
+:fragileEmbryoVehicle a :Vehicle ;
+  :function :Metabolism ;
+  :function :Development ;
+  :function :CopyingSupport .
+
+:fragileAdultVehicle a :Vehicle ;
+  :function :Metabolism ;
+  :function :Development ;
+  :function :GameteProduction ;
+  :function :SeedConstruction .
+
+:fragileSeedCoat a :Compartment ;
+  :function :DormancyProtection .
+
+:fragileSeed a :Organism ;
+  :lifeStage :DormantSeed ;
+  :hasReplicator :fragileGenome ;
+  :hasVehicle :fragileEmbryoVehicle ;
+  :hasCompartment :fragileSeedCoat .
+
+:fragileAdult a :Organism ;
+  :lifeStage :AdultPlant ;
+  :hasReplicator :fragileGenome ;
+  :hasVehicle :fragileAdultVehicle .
+
+:fragileLine a :Lineage ;
+  :seedStage :fragileSeed ;
+  :adultStage :fragileAdult ;
+  :replicator :fragileGenome ;
+  :variant :SaltTolerant ;
+  :variationStatus :Present ;
+  :lacksRepair true .
+
+:coatlessGenome a :Replicator ;
+  :accuracy :High ;
+  :storedIn :dnaRegister ;
+  :variant :SaltTolerant .
+
+:coatlessRepair a :RepairVehicle .
+
+:coatlessEmbryoVehicle a :Vehicle ;
+  :function :Metabolism ;
+  :function :Development ;
+  :function :CopyingSupport ;
+  :usesRepair :coatlessRepair .
+
+:coatlessAdultVehicle a :Vehicle ;
+  :function :Metabolism ;
+  :function :Development ;
+  :function :GameteProduction ;
+  :function :SeedConstruction .
+
+:coatlessSeed a :Organism ;
+  :lifeStage :DormantSeed ;
+  :hasReplicator :coatlessGenome ;
+  :hasVehicle :coatlessEmbryoVehicle .
+
+:coatlessAdult a :Organism ;
+  :lifeStage :AdultPlant ;
+  :hasReplicator :coatlessGenome ;
+  :hasVehicle :coatlessAdultVehicle .
+
+:coatlessLine a :Lineage ;
+  :seedStage :coatlessSeed ;
+  :adultStage :coatlessAdult ;
+  :replicator :coatlessGenome ;
+  :variant :SaltTolerant ;
+  :variationStatus :Present ;
+  :lacksDormancyProtection true .
+
+:staticGenome a :Replicator ;
+  :accuracy :High ;
+  :storedIn :dnaRegister ;
+  :variant :SaltTolerant .
+
+:staticRepair a :RepairVehicle .
+
+:staticEmbryoVehicle a :Vehicle ;
+  :function :Metabolism ;
+  :function :Development ;
+  :function :CopyingSupport ;
+  :usesRepair :staticRepair .
+
+:staticAdultVehicle a :Vehicle ;
+  :function :Metabolism ;
+  :function :Development ;
+  :function :GameteProduction ;
+  :function :SeedConstruction .
+
+:staticSeedCoat a :Compartment ;
+  :function :DormancyProtection .
+
+:staticSeed a :Organism ;
+  :lifeStage :DormantSeed ;
+  :hasReplicator :staticGenome ;
+  :hasVehicle :staticEmbryoVehicle ;
+  :hasCompartment :staticSeedCoat .
+
+:staticAdult a :Organism ;
+  :lifeStage :AdultPlant ;
+  :hasReplicator :staticGenome ;
+  :hasVehicle :staticAdultVehicle .
+
+:staticLine a :Lineage ;
+  :seedStage :staticSeed ;
+  :adultStage :staticAdult ;
+  :replicator :staticGenome ;
+  :variant :SaltTolerant ;
+  :variationStatus :None .
+
+# --------------------------------------------
+# 3. CAN-BECOME rules — viable transformations
+# --------------------------------------------
+
+# Under no-design laws, digital hereditary information can be copied accurately.
+{ :world :obeys :NoDesignLaws .
+  ?Genome a :Replicator ;
+          :storedIn ?Medium .
+  ?Medium a :DigitalInformationMedium . }
+=>
+{ ?Genome :canBecome :AccuratelyCopiedGenome . } .
+
+# A protected seed can remain a protected dormant stage.
+{ ?Seed a :Organism ;
+        :lifeStage :DormantSeed ;
+        :hasCompartment ?Compartment .
+  ?Compartment :function :DormancyProtection . }
+=>
+{ ?Seed :canBecome :ProtectedDormantPhase . } .
+
+# A dormant seed can become a germinating stage when conditions are present.
+{ ?Seed a :Organism ;
+        :lifeStage :DormantSeed .
+  :greenhouse :condition :WarmthAvailable .
+  :greenhouse :condition :MoistureAvailable .
+  :nutrientBed a :RawMaterialSupply . }
+=>
+{ ?Seed :canBecome :GerminatingStage . } .
+
+# An adult plant can become a next protected seed stage when reproductive
+# vehicle functions and supports are present.
+{ ?Adult a :Organism ;
+         :lifeStage :AdultPlant ;
+         :hasVehicle ?Vehicle .
+  ?Vehicle :function :GameteProduction .
+  ?Vehicle :function :SeedConstruction .
+  :pollinationLoop a :ReproductionSupport .
+  :greenhouse :condition :LightAvailable . }
+=>
+{ ?Adult :canBecome :NextDormantSeedStage . } .
+
+# Accurate lineage renewal requires accurate copying, repair, and a bottleneck.
+{ ?Line a :Lineage ;
+        :seedStage ?Seed ;
+        :replicator ?Genome .
+  ?Genome :canBecome :AccuratelyCopiedGenome .
+  ?Seed :hasVehicle ?Vehicle .
+  ?Vehicle :usesRepair ?Repair .
+  ?Repair a :RepairVehicle .
+  :zygote a :DevelopmentalBottleneck . }
+=>
+{ ?Line :canBecome :AccuratelyReproducedNextGeneration . } .
+
+# A lineage closes as a becoming when it can pass through protected dormancy,
+# germination, and return to a next seed stage.
+{ ?Line a :Lineage ;
+        :seedStage ?Seed ;
+        :adultStage ?Adult .
+  ?Seed :canBecome :ProtectedDormantPhase .
+  ?Seed :canBecome :GerminatingStage .
+  ?Adult :canBecome :NextDormantSeedStage . }
+=>
+{ ?Line :canBecome :LifeCycleClosure . } .
+
+# Heritable variation enables becoming otherwise.
+{ ?Line a :Lineage ;
+        :variationStatus :Present . }
+=>
+{ ?Line :canBecome :NovelVariantLineage . } .
+
+# Adaptive persistence is a becoming that joins renewal, variation, and selection.
+{ ?Line a :Lineage ;
+        :variant ?Variant .
+  ?Line :canBecome :AccuratelyReproducedNextGeneration .
+  ?Line :canBecome :NovelVariantLineage .
+  :salineBench :favours ?Variant . }
+=>
+{ ?Line :canBecome :AdaptivelyPersistentLineage . } .
+
+# A lineage is an evolvable becoming when it can close and persist adaptively.
+{ ?Line :canBecome :LifeCycleClosure .
+  ?Line :canBecome :AdaptivelyPersistentLineage . }
+=>
+{ ?Line a :EvolvableBecoming . } .
+
+# ------------------------------------------------
+# 4. CANNOT-BECOME rules — blocked transformations
+# ------------------------------------------------
+
+# Non-digital heredity cannot become accurate copying under no-design laws.
+{ :world :obeys :NoDesignLaws .
+  ?Genome a :Replicator ;
+          :storedIn ?Medium .
+  ?Medium a :NonDigitalInformationMedium . }
+=>
+{ ?Genome :cannotBecome :AccuratelyCopiedGenome . } .
+
+# If the genome cannot become accurately copied, the lineage cannot become an
+# accurately reproduced next generation.
+{ ?Line :replicator ?Genome .
+  ?Genome :cannotBecome :AccuratelyCopiedGenome . }
+=>
+{ ?Line :cannotBecome :AccuratelyReproducedNextGeneration . } .
+
+# No repair blocks reliable correction.
+{ ?Line a :Lineage ;
+        :lacksRepair true . }
+=>
+{ ?Line :cannotBecome :ReliablyCorrectedLineage . } .
+
+# Without reliable correction, accurate renewal is blocked.
+{ ?Line :cannotBecome :ReliablyCorrectedLineage . }
+=>
+{ ?Line :cannotBecome :AccuratelyReproducedNextGeneration . } .
+
+# No protective compartment blocks protected dormancy.
+{ ?Line a :Lineage ;
+        :lacksDormancyProtection true . }
+=>
+{ ?Line :cannotBecome :ProtectedDormantPhase . } .
+
+# If protected dormancy is blocked, life-cycle closure is blocked.
+{ ?Line :cannotBecome :ProtectedDormantPhase . }
+=>
+{ ?Line :cannotBecome :LifeCycleClosure . } .
+
+# No heritable variation blocks adaptive becoming.
+{ ?Line a :Lineage ;
+        :variationStatus :None . }
+=>
+{ ?Line :cannotBecome :AdaptiveLineage . } .
+
+# If adaptive becoming is blocked, adaptive persistence is blocked.
+{ ?Line :cannotBecome :AdaptiveLineage . }
+=>
+{ ?Line :cannotBecome :AdaptivelyPersistentLineage . } .
+
+# If any major becoming is blocked, the lineage is not an evolvable becoming.
+{ ?Line :cannotBecome :AccuratelyReproducedNextGeneration . }
+=>
+{ ?Line :cannotBecome :EvolvableBecoming . } .
+
+{ ?Line :cannotBecome :AdaptivelyPersistentLineage . }
+=>
+{ ?Line :cannotBecome :EvolvableBecoming . } .
+
+{ ?Line :cannotBecome :LifeCycleClosure . }
+=>
+{ ?Line :cannotBecome :EvolvableBecoming . } .
+
+# ---------
+# 5. Checks
+# ---------
+
+{ :world :obeys :NoDesignLaws . }
+=> { :case :checkB1 :Passed . } .
+
+{ :mainGenome :canBecome :AccuratelyCopiedGenome . }
+=> { :case :checkB2 :Passed . } .
+
+{ :mainSeed :canBecome :ProtectedDormantPhase . }
+=> { :case :checkB3 :Passed . } .
+
+{ :mainSeed :canBecome :GerminatingStage . }
+=> { :case :checkB4 :Passed . } .
+
+{ :mainAdult :canBecome :NextDormantSeedStage . }
+=> { :case :checkB5 :Passed . } .
+
+{ :mainLine :canBecome :AccuratelyReproducedNextGeneration . }
+=> { :case :checkB6 :Passed . } .
+
+{ :mainLine :canBecome :LifeCycleClosure . }
+=> { :case :checkB7 :Passed . } .
+
+{ :mainLine :canBecome :NovelVariantLineage . }
+=> { :case :checkB8 :Passed . } .
+
+{ :mainLine :canBecome :AdaptivelyPersistentLineage . }
+=> { :case :checkB9 :Passed . } .
+
+{ :mainLine a :EvolvableBecoming . }
+=> { :case :checkB10 :Passed . } .
+
+{ :analogLine :cannotBecome :AccuratelyReproducedNextGeneration . }
+=> { :case :checkB11 :Passed . } .
+
+{ :fragileLine :cannotBecome :AccuratelyReproducedNextGeneration . }
+=> { :case :checkB12 :Passed . } .
+
+{ :coatlessLine :cannotBecome :LifeCycleClosure . }
+=> { :case :checkB13 :Passed . } .
+
+{ :staticLine :cannotBecome :AdaptiveLineage . }
+=> { :case :checkB14 :Passed . } .
+
+{ :staticLine :cannotBecome :EvolvableBecoming . }
+=> { :case :checkB15 :Passed . } .
+
+# -------------------
+# 6. ARC-style output
+# -------------------
+
+{ :case :checkB1 :Passed .
+  :case :checkB2 :Passed .
+  :case :checkB3 :Passed .
+  :case :checkB4 :Passed .
+  :case :checkB5 :Passed .
+  :case :checkB6 :Passed .
+  :case :checkB7 :Passed .
+  :case :checkB8 :Passed .
+  :case :checkB9 :Passed .
+  :case :checkB10 :Passed .
+  :case :checkB11 :Passed .
+  :case :checkB12 :Passed .
+  :case :checkB13 :Passed .
+  :case :checkB14 :Passed .
+  :case :checkB15 :Passed . }
+=>
+{
+  :out log:outputString """Barley seed lineage — becoming
+
+Answer
+YES for the viable barley lineage.
+NO for the contrast lineages when digital heredity, repair, protected dormancy, or heritable variation are missing.
+
+Reason Why
+The main lineage can be read as a becoming: a protected dormant seed can germinate, an adult plant can become a next seed stage, and the lineage can therefore become a self-renewing cycle. Because its hereditary information is digitally instantiated and repair is available, it can also become an accurately reproduced next generation under no-design laws. And because heritable variation is present under a matching selection environment, it can become an adaptively persistent lineage. The contrast lineages mark blocked becomings: non-digital heredity blocks accurate copying, lack of repair blocks reliable renewal, lack of dormancy protection blocks closure through the seed phase, and lack of heritable variation blocks adaptive becoming.
+
+Check
+B1  OK - no-design laws are assumed
+B2  OK - the viable genome can become accurately copied
+B3  OK - the viable seed can become a protected dormant phase
+B4  OK - the viable seed can become a germinating stage
+B5  OK - the viable adult can become a next dormant seed stage
+B6  OK - the viable lineage can become an accurately reproduced next generation
+B7  OK - the viable lineage can become a closed life cycle
+B8  OK - the viable lineage can become a novel variant lineage
+B9  OK - the viable lineage can become adaptively persistent
+B10 OK - the viable lineage is an evolvable becoming
+B11 OK - the non-digital lineage cannot become an accurately reproduced next generation
+B12 OK - the repair-deficient lineage cannot become an accurately reproduced next generation
+B13 OK - the coatless lineage cannot become a closed life cycle
+B14 OK - the static lineage cannot become an adaptive lineage
+B15 OK - the static lineage cannot become an evolvable becoming
+""" .
+} .

package/examples/constructor-theory-becoming.n3

@@ -0,0 +1,177 @@
+# ================================================================
+# This small Notation3 program models becoming in a
+# constructor-theoretic idiom. A substrate is described by an
+# attribute. A task specifies a transformation from one attribute
+# to another. A constructor is something that can bring about that
+# task while retaining the capacity to do so again. The program
+# below distinguishes possible from impossible tasks and shows how
+# a sequence of possible tasks yields a new substrate state.
+# ================================================================
+
+@prefix : <http://example.org/constructor#>.
+
+# ----------
+# CATEGORIES
+# ----------
+
+:SubstrateVersion a :Category.
+:Attribute        a :Category.
+:Task             a :Category.
+:Constructor      a :Category.
+:Principle        a :Category.
+
+# ----------
+# ATTRIBUTES
+# ----------
+
+:blankMemory      a :Attribute.
+:encodedMemory    a :Attribute.
+:stabilizedMemory a :Attribute.
+:damagedMemory    a :Attribute.
+:pristineMemory   a :Attribute.
+
+# -----
+# TASKS
+# -----
+
+:writeTask a :Task;
+    :input  :blankMemory;
+    :output :encodedMemory.
+
+:stabilizeTask a :Task;
+    :input  :encodedMemory;
+    :output :stabilizedMemory.
+
+:perfectRestoreTask a :Task;
+    :input  :damagedMemory;
+    :output :pristineMemory;
+    :forbiddenBy :noMiraclePrinciple.
+
+# ------------
+# CONSTRUCTORS
+# ------------
+
+:writer a :Constructor;
+    :canPerform :writeTask.
+
+:stabilizer a :Constructor;
+    :canPerform :stabilizeTask.
+
+# ----------
+# PRINCIPLES
+# ----------
+
+:noMiraclePrinciple a :Principle.
+
+# ---------------
+# INITIAL HISTORY
+# ---------------
+
+:v1 a :SubstrateVersion;
+    :time 1;
+    :hasAttribute :blankMemory.
+
+:v2 a :SubstrateVersion;
+    :time 2;
+    :derivesFrom :v1;
+    :intendsTask :writeTask.
+
+:v3 a :SubstrateVersion;
+    :time 3;
+    :derivesFrom :v2;
+    :intendsTask :stabilizeTask.
+
+:damaged1 a :SubstrateVersion;
+    :time 4;
+    :hasAttribute :damagedMemory.
+
+:vBad a :SubstrateVersion;
+    :time 5;
+    :derivesFrom :damaged1;
+    :intendsTask :perfectRestoreTask.
+
+# ---------------------------------------------
+# RULE 1
+# A TASK FORBIDDEN BY A PRINCIPLE IS IMPOSSIBLE
+# ---------------------------------------------
+
+{
+  ?task :forbiddenBy ?principle.
+}
+=>
+{
+  ?task :status :impossibleTask.
+}.
+
+# --------------------------------------------
+# RULE 2
+# A TASK WITH A CONSTRUCTOR IS A POSSIBLE TASK
+# --------------------------------------------
+
+{
+  ?constructor :canPerform ?task.
+}
+=>
+{
+  ?task :status :possibleTask.
+  ?constructor :retainsCapacityFor ?task.
+}.
+
+# ---------------------------------------------------------------
+# RULE 3
+# A POSSIBLE TASK CAN BE APPLIED WHEN THE INPUT ATTRIBUTE MATCHES
+# ---------------------------------------------------------------
+
+{
+  ?next :derivesFrom ?prev.
+  ?next :intendsTask ?task.
+  ?task :status :possibleTask.
+  ?task :input ?in.
+  ?prev :hasAttribute ?in.
+}
+=>
+{
+  ?next :canUndergo ?task;
+        :becomesFrom ?prev.
+}.
+
+# ---------------------------------------------------------
+# RULE 4
+# WHEN A TASK IS UNDERGONE, THE OUTPUT ATTRIBUTE IS REACHED
+# ---------------------------------------------------------
+
+{
+  ?next :canUndergo ?task.
+  ?task :output ?out.
+}
+=>
+{
+  ?next :hasAttribute ?out.
+}.
+
+# -------------------------------------
+# RULE 5
+# IMPOSSIBLE TASKS BLOCK THE TRANSITION
+# -------------------------------------
+
+{
+  ?next :intendsTask ?task.
+  ?task :status :impossibleTask.
+}
+=>
+{
+  ?next :status :blockedTransition.
+}.
+
+# ---------------------------------------------------------------
+# RULE 6
+# A SUCCESSFUL TRANSFORMATION BECOMES AVAILABLE FOR FURTHER TASKS
+# ---------------------------------------------------------------
+
+{
+  ?next :hasAttribute ?attr.
+}
+=>
+{
+  ?next :availableForFurtherTask :yes.
+}.

package/examples/output/barley-seed-becoming.txt

@@ -0,0 +1,25 @@
+Barley seed lineage — becoming
+
+Answer
+YES for the viable barley lineage.
+NO for the contrast lineages when digital heredity, repair, protected dormancy, or heritable variation are missing.
+
+Reason Why
+The main lineage can be read as a becoming: a protected dormant seed can germinate, an adult plant can become a next seed stage, and the lineage can therefore become a self-renewing cycle. Because its hereditary information is digitally instantiated and repair is available, it can also become an accurately reproduced next generation under no-design laws. And because heritable variation is present under a matching selection environment, it can become an adaptively persistent lineage. The contrast lineages mark blocked becomings: non-digital heredity blocks accurate copying, lack of repair blocks reliable renewal, lack of dormancy protection blocks closure through the seed phase, and lack of heritable variation blocks adaptive becoming.
+
+Check
+B1  OK - no-design laws are assumed
+B2  OK - the viable genome can become accurately copied
+B3  OK - the viable seed can become a protected dormant phase
+B4  OK - the viable seed can become a germinating stage
+B5  OK - the viable adult can become a next dormant seed stage
+B6  OK - the viable lineage can become an accurately reproduced next generation
+B7  OK - the viable lineage can become a closed life cycle
+B8  OK - the viable lineage can become a novel variant lineage
+B9  OK - the viable lineage can become adaptively persistent
+B10 OK - the viable lineage is an evolvable becoming
+B11 OK - the non-digital lineage cannot become an accurately reproduced next generation
+B12 OK - the repair-deficient lineage cannot become an accurately reproduced next generation
+B13 OK - the coatless lineage cannot become a closed life cycle
+B14 OK - the static lineage cannot become an adaptive lineage
+B15 OK - the static lineage cannot become an evolvable becoming

package/examples/output/constructor-theory-becoming.n3

@@ -0,0 +1,18 @@
+@prefix : <http://example.org/constructor#> .
+
+:perfectRestoreTask :status :impossibleTask .
+:writeTask :status :possibleTask .
+:writer :retainsCapacityFor :writeTask .
+:stabilizeTask :status :possibleTask .
+:stabilizer :retainsCapacityFor :stabilizeTask .
+:v1 :availableForFurtherTask :yes .
+:damaged1 :availableForFurtherTask :yes .
+:v2 :canUndergo :writeTask .
+:v2 :becomesFrom :v1 .
+:v2 :hasAttribute :encodedMemory .
+:vBad :status :blockedTransition .
+:v2 :availableForFurtherTask :yes .
+:v3 :canUndergo :stabilizeTask .
+:v3 :becomesFrom :v2 .
+:v3 :hasAttribute :stabilizedMemory .
+:v3 :availableForFurtherTask :yes .

package/examples/output/tunnel-junction-wake-switch-becoming.txt

@@ -0,0 +1,21 @@
+tunnel-junction wake switch — becoming
+
+Answer
+YES for the tunnel junction.
+NO for the conventional low-bias PN junction in the same wake-switch regime.
+
+Reason Why
+The tunnel junction can be read as a becoming under low forward bias. Because it is modeled as a heavily doped narrow PN junction with overlapping states, it can become a quantum-transfer state. In that regime it can become a sub-threshold current state, and under peak-to-valley scanning it can also become a negative differential response state. As a wake-switch device, that lets it become an ultra-low-bias switching state and finally a leak-alarm wake-serving state. By contrast, the conventional junction lacks the structural conditions needed for the same transition into quantum transfer, so the later wake-serving becoming is blocked as well.
+
+Check
+B1  OK - the tunnel junction can become a quantum-transfer state
+B2  OK - the tunnel junction is classified as tunneling-dominant
+B3  OK - the tunnel junction can become a sub-threshold current state
+B4  OK - the tunnel junction can become a negative differential response state
+B5  OK - the tunnel junction can become an ultra-low-bias switching state
+B6  OK - the tunnel junction can become a leak-alarm wake-serving state
+B7  OK - the conventional junction cannot become a quantum-transfer state
+B8  OK - the conventional junction cannot become a sub-threshold current state
+B9  OK - the conventional junction cannot become the tunnel-style negative differential state
+B10 OK - the conventional junction cannot become an ultra-low-bias switching state here
+B11 OK - the conventional junction cannot become a leak-alarm wake-serving state in this case

package/examples/tunnel-junction-wake-switch-becoming.n3

@@ -0,0 +1,216 @@
+# =================================================================================
+# tunnel-junction wake switch — becoming
+#
+# This example reframes the wake-switch case as a becoming example.
+# The device is not treated as a static component with capabilities, but as a
+# system that can or cannot pass into a low-bias wake-triggering state.
+#
+# We compare two devices:
+#   - tunnelJunction   : a heavily doped narrow PN junction with overlapping states
+#   - ordinaryJunction : a conventional PN junction without that overlap
+#
+# The point is to show:
+#   - what the tunnel junction can become under the low-bias requirement
+#   - what the conventional junction cannot become under the same requirement
+# =================================================================================
+
+@prefix : <http://example.org/tunnel-junction-wake-switch-becoming/> .
+@prefix arc: <https://example.org/arc#> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+:case a arc:Case ;
+  arc:question "Can a tunnel-junction wake switch become a low-bias wake-triggering state in a regime where a conventional PN junction cannot?" .
+
+# -------------------
+# Application context
+# -------------------
+
+:leakAlarmNode a :EdgeSensor ;
+  :needs :MicrowattWakeSwitching ;
+  :application :PipeLeakAlarm .
+
+# ----------------------------------
+# Device A: tunnel-style PN junction
+# ----------------------------------
+
+:tunnelJunction a :PNJunction ;
+  :junctionKind :TunnelDiode ;
+  :doping :Heavy ;
+  :depletionWidth :Narrow ;
+  :stateAlignment :Overlap ;
+  :biasRegime :LowForwardBias ;
+  :scanProfile :PeakToValley ;
+  :deviceRole :WakeSwitch .
+
+# ----------------------------------
+# Device B: conventional PN junction
+# ----------------------------------
+
+:ordinaryJunction a :PNJunction ;
+  :junctionKind :ConventionalDiode ;
+  :doping :Standard ;
+  :depletionWidth :Wide ;
+  :stateAlignment :NoOverlap ;
+  :biasRegime :LowForwardBias ;
+  :scanProfile :MonotoneForward ;
+  :deviceRole :WakeSwitch .
+
+# -------------------------------------------
+# CAN-BECOME rules — viable state transitions
+# -------------------------------------------
+
+# A heavily doped, narrow junction with overlapping states can become a
+# quantum-transfer-supporting junction.
+{ ?J a :PNJunction ;
+     :doping :Heavy ;
+     :depletionWidth :Narrow ;
+     :stateAlignment :Overlap . }
+=>
+{ ?J :canBecome :QuantumTransferState ;
+     :transportMode :TunnelingDominant . } .
+
+# In the low-forward-bias regime, a junction in the quantum-transfer state can
+# become a sub-threshold current state.
+{ ?J :canBecome :QuantumTransferState ;
+     :biasRegime :LowForwardBias . }
+=>
+{ ?J :canBecome :SubThresholdCurrentState . } .
+
+# If the junction is scanned across the peak-to-valley window, it can become a
+# negative differential response state.
+{ ?J :canBecome :QuantumTransferState ;
+     :scanProfile :PeakToValley . }
+=>
+{ ?J :canBecome :NegativeDifferentialResponseState . } .
+
+# A wake-switch device that can become a sub-threshold current state can become
+# an ultra-low-bias switching state.
+{ ?J :canBecome :SubThresholdCurrentState ;
+     :deviceRole :WakeSwitch . }
+=>
+{ ?J :canBecome :UltraLowBiasSwitchingState . } .
+
+# If the device can become an ultra-low-bias switching state and the node needs
+# microwatt wake switching, it can become a wake-serving device.
+{ ?J :canBecome :UltraLowBiasSwitchingState .
+  :leakAlarmNode :needs :MicrowattWakeSwitching . }
+=>
+{ ?J :canBecome :LeakAlarmWakeServingState . } .
+
+# -----------------------------------------------
+# CANNOT-BECOME rules — blocked state transitions
+# -----------------------------------------------
+
+# A conventional wide-depletion low-bias junction without state overlap cannot
+# become a quantum-transfer-supporting junction.
+{ ?J a :PNJunction ;
+     :doping :Standard ;
+     :depletionWidth :Wide ;
+     :stateAlignment :NoOverlap . }
+=>
+{ ?J :cannotBecome :QuantumTransferState . } .
+
+# Without that quantum-transfer state, the junction cannot become a
+# sub-threshold current state in the same low-bias regime.
+{ ?J :cannotBecome :QuantumTransferState ;
+     :biasRegime :LowForwardBias . }
+=>
+{ ?J :cannotBecome :SubThresholdCurrentState . } .
+
+# Without quantum transfer, the tunnel-style negative differential state is
+# blocked as well.
+{ ?J :cannotBecome :QuantumTransferState . }
+=>
+{ ?J :cannotBecome :NegativeDifferentialResponseState . } .
+
+# Without sub-threshold current, the device cannot become an ultra-low-bias
+# switching state.
+{ ?J :cannotBecome :SubThresholdCurrentState ;
+     :deviceRole :WakeSwitch . }
+=>
+{ ?J :cannotBecome :UltraLowBiasSwitchingState . } .
+
+# Without ultra-low-bias switching, the device cannot become a wake-serving
+# device for the leak-alarm node.
+{ ?J :cannotBecome :UltraLowBiasSwitchingState .
+  :leakAlarmNode :needs :MicrowattWakeSwitching . }
+=>
+{ ?J :cannotBecome :LeakAlarmWakeServingState . } .
+
+# ------
+# Checks
+# ------
+
+{ :tunnelJunction :canBecome :QuantumTransferState . }
+=> { :case :checkB1 :Passed . } .
+
+{ :tunnelJunction :transportMode :TunnelingDominant . }
+=> { :case :checkB2 :Passed . } .
+
+{ :tunnelJunction :canBecome :SubThresholdCurrentState . }
+=> { :case :checkB3 :Passed . } .
+
+{ :tunnelJunction :canBecome :NegativeDifferentialResponseState . }
+=> { :case :checkB4 :Passed . } .
+
+{ :tunnelJunction :canBecome :UltraLowBiasSwitchingState . }
+=> { :case :checkB5 :Passed . } .
+
+{ :tunnelJunction :canBecome :LeakAlarmWakeServingState . }
+=> { :case :checkB6 :Passed . } .
+
+{ :ordinaryJunction :cannotBecome :QuantumTransferState . }
+=> { :case :checkB7 :Passed . } .
+
+{ :ordinaryJunction :cannotBecome :SubThresholdCurrentState . }
+=> { :case :checkB8 :Passed . } .
+
+{ :ordinaryJunction :cannotBecome :NegativeDifferentialResponseState . }
+=> { :case :checkB9 :Passed . } .
+
+{ :ordinaryJunction :cannotBecome :UltraLowBiasSwitchingState . }
+=> { :case :checkB10 :Passed . } .
+
+{ :ordinaryJunction :cannotBecome :LeakAlarmWakeServingState . }
+=> { :case :checkB11 :Passed . } .
+
+# ----------------
+# ARC-style output
+# ----------------
+
+{ :case :checkB1 :Passed .
+  :case :checkB2 :Passed .
+  :case :checkB3 :Passed .
+  :case :checkB4 :Passed .
+  :case :checkB5 :Passed .
+  :case :checkB6 :Passed .
+  :case :checkB7 :Passed .
+  :case :checkB8 :Passed .
+  :case :checkB9 :Passed .
+  :case :checkB10 :Passed .
+  :case :checkB11 :Passed . }
+=>
+{
+  :out log:outputString """tunnel-junction wake switch — becoming
+
+Answer
+YES for the tunnel junction.
+NO for the conventional low-bias PN junction in the same wake-switch regime.
+
+Reason Why
+The tunnel junction can be read as a becoming under low forward bias. Because it is modeled as a heavily doped narrow PN junction with overlapping states, it can become a quantum-transfer state. In that regime it can become a sub-threshold current state, and under peak-to-valley scanning it can also become a negative differential response state. As a wake-switch device, that lets it become an ultra-low-bias switching state and finally a leak-alarm wake-serving state. By contrast, the conventional junction lacks the structural conditions needed for the same transition into quantum transfer, so the later wake-serving becoming is blocked as well.
+
+Check
+B1  OK - the tunnel junction can become a quantum-transfer state
+B2  OK - the tunnel junction is classified as tunneling-dominant
+B3  OK - the tunnel junction can become a sub-threshold current state
+B4  OK - the tunnel junction can become a negative differential response state
+B5  OK - the tunnel junction can become an ultra-low-bias switching state
+B6  OK - the tunnel junction can become a leak-alarm wake-serving state
+B7  OK - the conventional junction cannot become a quantum-transfer state
+B8  OK - the conventional junction cannot become a sub-threshold current state
+B9  OK - the conventional junction cannot become the tunnel-style negative differential state
+B10 OK - the conventional junction cannot become an ultra-low-bias switching state here
+B11 OK - the conventional junction cannot become a leak-alarm wake-serving state in this case
+""" .
+} .

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.22.15",
+  "version": "1.22.16",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [