eyeling 1.22.5 → 1.22.7

package/examples/fundamental-theorem-arithmetic.n3

@@ -0,0 +1,244 @@
+# ============================================================================
+# Fundamental Theorem of Arithmetic — ARC-style
+#
+# Single scenario:
+#   n = 202692987 = 3^2 * 7 * 829 * 3881
+#
+# This example translates the Eyelet/Prolog ARC example into Notation3 for
+# Eyeling. It computes the prime factors of one target integer by repeated
+# smallest-divisor decomposition, reports the result in ARC form, and includes
+# independent checks for product reconstruction, primality, and uniqueness up
+# to order.
+# ============================================================================
+
+@prefix : <https://example.org/fundamental-theorem-arithmetic#> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+@prefix math: <http://www.w3.org/2000/10/swap/math#> .
+@prefix list: <http://www.w3.org/2000/10/swap/list#> .
+@prefix string: <http://www.w3.org/2000/10/swap/string#> .
+
+# --------------
+# Editable input
+# --------------
+
+:Case
+  :n 202692987;
+  :expectedSmallestFactors (3 3 7 829 3881);
+  :expectedPrimePower "3^2 * 7 * 829 * 3881";
+  :expectedFlat "3 * 3 * 7 * 829 * 3881";
+  :expectedLargestFlat "3881 * 829 * 7 * 3 * 3".
+
+# -------------------------
+# Backward helper relations
+# -------------------------
+
+# divides0(A,B): A divides B in the positive integers.
+{ (?A ?B) :divides0 true }
+<=
+{ ?A math:greaterThan 0.
+  ?B math:greaterThan 0.
+  (?B ?A) math:remainder 0. } .
+
+# trialPrime(P): simple trial-division primality for individual numbers.
+{ 2 :trialPrime true } <= true.
+{ 3 :trialPrime true } <= true.
+
+{ ?P :trialPrime true }
+<=
+{ ?P math:greaterThan 3.
+  (?P 2) :smallestDivisorFrom ?P. } .
+
+# smallestDivisorFrom(N,D,S): S is the smallest divisor of N starting from D.
+{ (?N ?D) :smallestDivisorFrom ?D }
+<=
+{ (?D ?N) :divides0 true. } .
+
+{ (?N ?D) :smallestDivisorFrom ?N }
+<=
+{ (?D ?D) math:product ?D2.
+  ?D2 math:greaterThan ?N. } .
+
+{ (?N ?D) :smallestDivisorFrom ?S }
+<=
+{ 1 log:notIncludes { (?D ?N) :divides0 true. }.
+  (?D ?D) math:product ?D2.
+  ?D2 math:notGreaterThan ?N.
+  (?D 1) math:sum ?D1.
+  (?N ?D1) :smallestDivisorFrom ?S. } .
+
+# factorSmallest(N,Fs): prime factors of N in nondecreasing order.
+{ ?N :factorSmallest () }
+<=
+{ ?N math:lessThan 2. } .
+
+{ ?N :factorSmallest (?N) }
+<=
+{ ?N math:notLessThan 2.
+  (?N 2) :smallestDivisorFrom ?D.
+  ?D math:equalTo ?N. } .
+
+{ ?N :factorSmallest ?Fs }
+<=
+{ ?N math:notLessThan 2.
+  (?N 2) :smallestDivisorFrom ?D.
+  ?D math:notEqualTo ?N.
+  (?N ?D) math:integerQuotient ?N1.
+  ?D :factorSmallest ?Fs1.
+  ?N1 :factorSmallest ?Fs2.
+  (?Fs1 ?Fs2) list:append ?Fs. } .
+
+# factorLargest(N,Fs): same factors in reverse order.
+{ ?N :factorLargest ?Fs }
+<=
+{ ?N :factorSmallest ?Small.
+  ?Small list:reverse ?Fs. } .
+
+# product(Fs,P): product of all numbers in an RDF list.
+{ () :product 1 }
+<=
+true .
+
+{ ?Fs :product ?P }
+<=
+{ ?Fs list:firstRest (?X ?Rest).
+  ?Rest :product ?P0.
+  (?X ?P0) math:product ?P. } .
+
+# ---------------------------
+# Materialized scenario facts
+# ---------------------------
+
+{ :Case :n ?N.
+  ?N :factorSmallest ?Fs.
+  ?N :factorLargest ?Fr.
+  ?Fs :product ?P.
+  ?Fs list:sort ?SortedS.
+  ?Fr list:sort ?SortedL.
+  ?Fs list:first ?Smallest.
+  ?Fs list:last ?Largest. }
+=>
+{ :Case :factorsSmallest ?Fs;
+        :factorsLargest ?Fr;
+        :product ?P;
+        :sortedSmallest ?SortedS;
+        :sortedLargest ?SortedL;
+        :smallestPrimeFactor ?Smallest;
+        :largestPrimeFactor ?Largest. } .
+
+{ :Case :factorsSmallest ?Fs; :expectedSmallestFactors ?Fs. }
+=>
+{ :Case :flatFactorString "3 * 3 * 7 * 829 * 3881";
+        :primePowerString "3^2 * 7 * 829 * 3881";
+        :distinctPrimeCount 4;
+        :largestFlatFactorString "3881 * 829 * 7 * 3 * 3". } .
+
+# ------------------
+# Independent checks
+# ------------------
+
+{ :Case :factorsSmallest ?Fs; :expectedSmallestFactors ?Fs. }
+=>
+{ :Check :c1 "OK - repeated smallest-divisor decomposition produced the expected smallest-first factor list (3 3 7 829 3881).". } .
+
+{ :Case :n ?N; :product ?N. }
+=>
+{ :Check :c2 "OK - the product of the computed factors reconstructs n = 202692987.". } .
+
+{ 3 :trialPrime true.
+  7 :trialPrime true.
+  829 :trialPrime true.
+  3881 :trialPrime true. }
+=>
+{ :Check :c3 "OK - every distinct factor in the decomposition is prime by trial division.". } .
+
+{ :Case :primePowerString ?S; :expectedPrimePower ?S. }
+=>
+{ :Check :c4 "OK - the prime-power form matches 3^2 * 7 * 829 * 3881.". } .
+
+{ :Case :sortedSmallest ?S; :sortedLargest ?S. }
+=>
+{ :Check :c5 "OK - smallest-first and largest-first traversals have the same multiset of primes, so the factorization agrees up to order.". } .
+
+{ :Case :smallestPrimeFactor 3; :largestPrimeFactor 3881. }
+=>
+{ :Check :c6 "OK - the smallest and largest prime factors are 3 and 3881.". } .
+
+# -----
+# Fuses
+# -----
+
+{ :Case :n ?N; :product ?P.
+  ?P log:notEqualTo ?N. }
+=> false .
+
+{ :Case :factorsSmallest ?Fs; :expectedSmallestFactors ?Expected.
+  ?Fs log:notEqualTo ?Expected. }
+=> false .
+
+{ :Case :sortedSmallest ?A; :sortedLargest ?B.
+  ?A log:notEqualTo ?B. }
+=> false .
+
+{ 1 log:notIncludes { 3 :trialPrime true. }. }
+=> false .
+
+{ 1 log:notIncludes { 7 :trialPrime true. }. }
+=> false .
+
+{ 1 log:notIncludes { 829 :trialPrime true. }. }
+=> false .
+
+{ 1 log:notIncludes { 3881 :trialPrime true. }. }
+=> false .
+
+{ :Case :smallestPrimeFactor ?S.
+  ?S log:notEqualTo 3. }
+=> false .
+
+{ :Case :largestPrimeFactor ?L.
+  ?L log:notEqualTo 3881. }
+=> false .
+
+{ :Case :factorsSmallest ?A, ?B.
+  ?A log:notEqualTo ?B. }
+=> false .
+
+# ---------------------
+# Answer and reason why
+# ---------------------
+
+{ :Case :n ?N;
+        :flatFactorString ?Flat;
+        :primePowerString ?PrimePower;
+        :largestFlatFactorString ?LargestFlat;
+        :distinctPrimeCount ?Distinct;
+        :smallestPrimeFactor ?Smallest;
+        :largestPrimeFactor ?Largest.
+  :Check :c1 ?C1.
+  :Check :c2 ?C2.
+  :Check :c3 ?C3.
+  :Check :c4 ?C4.
+  :Check :c5 ?C5.
+  :Check :c6 ?C6.
+  (
+    "Fundamental Theorem of Arithmetic — ARC-style\n\n"
+    "Answer\n"
+    "For n = " ?N ", the prime factors are " ?Flat ", the prime-power form is " ?PrimePower
+    ", and the product of these factors is " ?N " with " ?Distinct " distinct primes.\n\n"
+    "Reason Why\n"
+    "Existence in this run comes from repeated smallest-divisor decomposition: " ?N
+    " factors as " ?Flat ". Each distinct factor is prime. "
+    "For uniqueness up to order, the reverse traversal gives " ?LargestFlat
+    ", and both traversals sort to the same multiset of primes. "
+    "So this concrete case exhibits the Fundamental Theorem of Arithmetic for " ?N
+    ": a prime factorization exists and is unique up to order. The extreme prime factors are " ?Smallest " and " ?Largest ".\n\n"
+    "Check\n"
+    "C1 " ?C1 "\n"
+    "C2 " ?C2 "\n"
+    "C3 " ?C3 "\n"
+    "C4 " ?C4 "\n"
+    "C5 " ?C5 "\n"
+    "C6 " ?C6 "\n"
+  ) string:concatenation ?Block. }
+=>
+{ :report log:outputString ?Block. } .

package/examples/harborsmr.n3

@@ -0,0 +1,233 @@
+# ===========================================================================
+# HarborSMR — bounded flexible-export insight for port electrolysis.
+#
+# The port hydrogen hub does not need raw reactor telemetry in order
+# to schedule one electrolyzer train for a short window.
+#
+# The SMR operator keeps detailed plant data local. What crosses the boundary
+# is a narrow, expiring insight: a temporary flexible-export window of 18 MW,
+# scoped to the port hydrogen hub and usable only for electrolysis dispatch.
+#
+# That is the Insight Economy in action. The hub receives a permissioned
+# decision object rather than control-rod positions, neutron flux traces,
+# or other sensitive operational telemetry.
+# ===========================================================================
+
+@prefix : <https://example.org/insight/harborsmr/> .
+@prefix arc: <https://example.org/arc#> .
+@prefix ins: <https://example.org/insight-economy#> .
+@prefix odrl: <http://www.w3.org/ns/odrl/2/> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+@prefix math: <http://www.w3.org/2000/10/swap/math#> .
+@prefix string: <http://www.w3.org/2000/10/swap/string#> .
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+# -----
+# Facts
+# -----
+
+:case a arc:Case ;
+  :caseName "harborsmr" ;
+  arc:question "May the port hydrogen hub use a temporary SMR flexible-export insight to schedule electrolysis for the next four-hour balancing window?" ;
+  :requestPurpose "electrolysis_dispatch" ;
+  :requestAction odrl:use ;
+  :hubAuthAt "2026-06-18T13:10:00+00:00"^^xsd:dateTime .
+
+:portHydrogenHub a :IndustrialOfftaker ;
+  :hubName "North Quay Hydrogen Hub" .
+
+:secureAggregate a :SecureAggregate ;
+  :availableFlexibleExportMW 18 ;
+  :reserveMarginMW 24 ;
+  :coolingMarginPct 18 ;
+  :plannedOutage false ;
+  :containsCoreTemperature false ;
+  :containsRodPosition false ;
+  :containsNeutronFlux false ;
+  :containsOperatorBadgeIds false .
+
+:flexInsight a ins:Insight ;
+  :id <https://example.org/insight/harborsmr> ;
+  :metric "temporary_flexible_export_window" ;
+  :targetLoad "PEM_electrolyzer_train_2" ;
+  :exportMW 18 ;
+  :windowStart "2026-06-18T14:00:00+00:00"^^xsd:dateTime ;
+  :expiresAt "2026-06-18T18:00:00+00:00"^^xsd:dateTime ;
+  :scopeDevice "port-hydrogen-hub" ;
+  :scopeEvent "day_ahead_balancing" ;
+  :serializedLowercase """{"createdat":"2026-06-18t13:00:00+00:00","expiresat":"2026-06-18t18:00:00+00:00","exportmw":18,"id":"https://example.org/insight/harborsmr","metric":"temporary_flexible_export_window","scopedevice":"port-hydrogen-hub","scopeevent":"day_ahead_balancing","targetload":"pem_electrolyzer_train_2","type":"ins:insight"}""" .
+
+:electrolyzerRequest a :Request ;
+  :requester :portHydrogenHub ;
+  :requestedMW 16 ;
+  :purpose "electrolysis_dispatch" ;
+  :targetLoad "PEM_electrolyzer_train_2" .
+
+:dispatchPlan a :DispatchPlan ;
+  :dispatchMW 16 ;
+  :windowStart "2026-06-18T14:00:00+00:00"^^xsd:dateTime ;
+  :windowEnd "2026-06-18T18:00:00+00:00"^^xsd:dateTime ;
+  :forLoad "PEM_electrolyzer_train_2" .
+
+:policy a odrl:Policy ;
+  :profile "HarborSMR-Insight-Policy" ;
+  odrl:permission [
+    odrl:action odrl:use ;
+    odrl:target <https://example.org/insight/harborsmr> ;
+    odrl:constraint [
+      odrl:leftOperand odrl:purpose ;
+      odrl:operator odrl:eq ;
+      odrl:rightOperand "electrolysis_dispatch"
+    ]
+  ] ;
+  odrl:prohibition [
+    odrl:action odrl:distribute ;
+    odrl:target <https://example.org/insight/harborsmr> ;
+    odrl:constraint [
+      odrl:leftOperand odrl:purpose ;
+      odrl:operator odrl:eq ;
+      odrl:rightOperand "market_resale"
+    ]
+  ] .
+
+# -----
+# Logic
+# -----
+
+{ :secureAggregate :reserveMarginMW ?mw .
+  ?mw math:greaterThan 19 .
+} => { :case :checkC1 :Passed . } .
+
+{ :secureAggregate :coolingMarginPct ?pct .
+  ?pct math:greaterThan 14 .
+} => { :case :checkC2 :Passed . } .
+
+{ :secureAggregate :plannedOutage false .
+} => { :case :checkC3 :Passed . } .
+
+{ :electrolyzerRequest :requestedMW ?req .
+  :flexInsight :exportMW ?cap .
+  ?req math:notGreaterThan ?cap .
+} => { :case :checkC4 :Passed . } .
+
+{ :flexInsight :serializedLowercase ?s .
+  ?s string:notMatches "coretemp|rodposition|neutronflux|operatorbadge" .
+} => { :case :checkC5 :Passed . } .
+
+{ :secureAggregate
+    :containsCoreTemperature false ;
+    :containsRodPosition false ;
+    :containsNeutronFlux false ;
+    :containsOperatorBadgeIds false .
+} => { :case :checkC6 :Passed . } .
+
+{ :policy odrl:permission [
+      odrl:action odrl:use ;
+      odrl:target <https://example.org/insight/harborsmr> ;
+      odrl:constraint [
+        odrl:leftOperand odrl:purpose ;
+        odrl:operator odrl:eq ;
+        odrl:rightOperand "electrolysis_dispatch"
+      ]
+    ] .
+  :case :hubAuthAt ?authAt .
+  :flexInsight :expiresAt ?expiresAt .
+  ?authAt math:notGreaterThan ?expiresAt .
+} => { :case :checkC7 :Passed . } .
+
+{ :policy odrl:prohibition [
+      odrl:action odrl:distribute ;
+      odrl:target <https://example.org/insight/harborsmr> ;
+      odrl:constraint [
+        odrl:leftOperand odrl:purpose ;
+        odrl:operator odrl:eq ;
+        odrl:rightOperand "market_resale"
+      ]
+    ] .
+} => { :case :checkC8 :Passed . } .
+
+{ :flexInsight
+    :scopeDevice ?device ;
+    :scopeEvent ?event ;
+    :windowStart ?start ;
+    :expiresAt ?end .
+} => { :case :checkC9 :Passed . } .
+
+{ :dispatchPlan :dispatchMW ?mw .
+  :electrolyzerRequest :requestedMW ?req .
+  :dispatchPlan :forLoad ?load .
+  :electrolyzerRequest :targetLoad ?load .
+  ?req math:notGreaterThan ?mw .
+} => { :case :checkC10 :Passed . } .
+
+{ :case :checkC1 :Passed .
+  :case :checkC2 :Passed .
+  :case :checkC3 :Passed .
+  :case :checkC4 :Passed .
+  :case :checkC5 :Passed .
+  :case :checkC6 :Passed .
+  :case :checkC7 :Passed .
+  :case :checkC8 :Passed .
+  :case :checkC9 :Passed .
+  :case :checkC10 :Passed .
+} => {
+  :case :decision :Permit .
+  :decision :target <https://example.org/insight/harborsmr> ;
+            :outcome "Allowed" .
+} .
+
+# ------------------
+# Presentation (ARC)
+# ------------------
+
+{ :case :decision :Permit . }
+=> {
+  :out log:outputString """HarborSMR — bounded flexible-export insight for port electrolysis
+
+Answer
+PERMIT
+The port hydrogen hub may use the SMR insight to run PEM electrolyzer train 2 at 16 MW from 14:00 to 18:00.
+
+Reason Why
+The operator shares only a narrow, expiring insight that a temporary 18 MW flexible-export window is available. The request is for electrolysis dispatch only, the requested 16 MW fits inside the permitted window, safety margins are above threshold, no outage blocks the window, and the policy forbids redistribution for market resale. Raw reactor telemetry stays local.
+
+Check
+C1  OK - reserve margin exceeds the dispatch threshold
+C2  OK - cooling margin exceeds the dispatch threshold
+C3  OK - no planned outage blocks the window
+C4  OK - requested MW fits within the export window
+C5  OK - serialized insight omits sensitive telemetry terms
+C6  OK - aggregate excludes core temperature, rod position, neutron flux, and operator IDs
+C7  OK - policy allows use for electrolysis dispatch before expiry
+C8  OK - policy prohibits redistribution for market resale
+C9  OK - scope is explicit: device, event, start, and expiry
+C10 OK - dispatch plan matches the requested load and power
+""" .
+} .
+
+# ----------------
+# Fail-loud checks
+# ----------------
+
+{ :case :decision :Permit .
+  :electrolyzerRequest :requestedMW ?req .
+  :flexInsight :exportMW ?cap .
+  ?req math:greaterThan ?cap .
+} => false .
+
+{ :case :decision :Permit .
+  :secureAggregate :plannedOutage ?x .
+  ?x log:notEqualTo false .
+} => false .
+
+{ :case :decision :Permit .
+  :case :hubAuthAt ?authAt .
+  :flexInsight :expiresAt ?expiresAt .
+  ?authAt math:greaterThan ?expiresAt .
+} => false .
+
+{ :case :decision :Permit .
+  :dispatchPlan :forLoad ?planLoad .
+  :electrolyzerRequest :targetLoad ?requestLoad .
+  ?planLoad log:notEqualTo ?requestLoad .
+} => false .

package/examples/meta-rule-audit.n3

@@ -0,0 +1,135 @@
+# =====================================================================
+# Meta-rule audit with quoted =>, <=, includes
+#
+# This example audits a quoted theory that mixes:
+# - a bidirectional rule pair,
+# - a forward-only rule,
+# - a backward-only rule,
+# and checks which rule bodies are currently active.
+#
+# It exercises:
+# - quoted formulas as first-class terms
+# - log:includes with { ?B log:implies ?H }
+# - log:includes with { ?H log:impliedBy ?B }
+# - log:notIncludes to detect missing dual rules
+# - reusing a bound quoted body formula as the argument of log:includes
+#
+# Expected highlights:
+# - subclass lifting is bidirectional and active
+# - parentOf -> childOf is forward-only and active
+# - worksFor <= employs is backward-only and active
+# =====================================================================
+
+@prefix : <http://example.org/> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+@prefix log: <http://www.w3.org/2000/10/swap/log#> .
+
+<> :theory {
+
+    # Bidirectional pair
+    {
+        ?X a ?C .
+        ?C rdfs:subClassOf ?D .
+    }
+    =>
+    {
+        ?X a ?D .
+    }.
+
+    {
+        ?X a ?D .
+    }
+    <=
+    {
+        ?X a ?C .
+        ?C rdfs:subClassOf ?D .
+    }.
+
+    # Forward-only rule
+    {
+        ?P :parentOf ?Q .
+    }
+    =>
+    {
+        ?Q :childOf ?P .
+    }.
+
+    # Backward-only rule
+    {
+        ?P :worksFor ?Org .
+    }
+    <=
+    {
+        ?Org :employs ?P .
+    }.
+
+    # Facts that activate all three bodies
+    :alice a :Student .
+    :Student rdfs:subClassOf :Person .
+
+    :alice :parentOf :bob .
+
+    :acme :employs :carol .
+}.
+
+# --------------------------------------------------
+# Audit the quoted theory for forward/backward pairs
+# --------------------------------------------------
+
+{
+    ?W :theory ?F.
+    ?F log:includes { ?B log:implies ?H }.
+    ?F log:includes { ?H log:impliedBy ?B }.
+}
+=>
+{
+    ?B :ruleStatus :Bidirectional .
+    ?B :ruleHead ?H .
+}.
+
+{
+    ?W :theory ?F.
+    ?F log:includes { ?B log:implies ?H }.
+    ?F log:notIncludes { ?H log:impliedBy ?B }.
+}
+=>
+{
+    ?B :ruleStatus :ForwardOnly .
+    ?B :ruleHead ?H .
+}.
+
+{
+    ?W :theory ?F.
+    ?F log:includes { ?H log:impliedBy ?B }.
+    ?F log:notIncludes { ?B log:implies ?H }.
+}
+=>
+{
+    ?B :ruleStatus :BackwardOnly .
+    ?B :ruleHead ?H .
+}.
+
+# --------------------------------------
+# Check which rule bodies are active now
+# --------------------------------------
+
+{
+    ?W :theory ?F.
+    ?F log:includes { ?B log:implies ?H }.
+    ?F log:includes ?B.
+}
+=>
+{
+    ?B :activeAs :ForwardBody .
+}.
+
+{
+    ?W :theory ?F.
+    ?F log:includes { ?H log:impliedBy ?B }.
+    ?F log:includes ?B.
+}
+=>
+{
+    ?B :activeAs :BackwardBody .
+}.

package/examples/output/act-alarm-bit-interoperability.txt

@@ -0,0 +1,20 @@
+ACT harbor alarm bit interoperability
+
+Answer
+YES for the classical alarm bit.
+NO for universal cloning and unrestricted fan-out of the quantum-like token.
+
+Reason Why
+The alarm state is modeled as an abstract bit carried by two unlike classical substrates. Because both the optical beacon and the relay register are information media for the same variable, local permutation and copying in both directions are possible. By contrast, the quantum-like token is treated as a superinformation medium, so universal cloning of all of its states is impossible, and unrestricted classical-style fan-out is blocked as well.
+
+Check
+C1  OK - the optical beacon is an information medium
+C2  OK - the relay register is an information medium
+C3  OK - both substrates encode the same abstract variable: AlarmBit
+C4  OK - AlarmBit can be copied from optical beacon to relay register
+C5  OK - AlarmBit can be copied from relay register to optical beacon
+C6  OK - local permutation of AlarmBit is possible on the optical beacon
+C7  OK - local permutation of AlarmBit is possible on the relay register
+C8  OK - cloning all states of the quantum token is an impossible task
+C9  OK - the quantum token cannot be universally cloned
+C10 OK - the quantum token cannot support unrestricted classical-style fan-out

package/examples/output/act-barley-seed-lineage.txt

@@ -0,0 +1,25 @@
+ACT barley seed lineage — can and can't
+
+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 achieve genome copying under no-design laws because its hereditary information is digitally instantiated. It can also pass through protected dormancy, germinate, produce propagules, reproduce accurately, close its life cycle, and adaptively persist under saline selection. But the contrast lineages show the "can't" side: non-digital heredity blocks accurate genome copying under no-design laws, lack of repair blocks accurate self-reproduction, lack of dormancy protection blocks lineage closure through a protected seed phase, and lack of heritable variation blocks adaptive evolution and thus blocks evolvability.
+
+Check
+C1  OK - no-design laws are assumed
+C2  OK - the viable genome can be copied under no-design laws
+C3  OK - the viable seed can achieve protected dormancy
+C4  OK - the viable seed can germinate
+C5  OK - the viable adult can produce propagules
+C6  OK - the viable lineage can achieve accurate self-reproduction
+C7  OK - the viable lineage can achieve lineage closure
+C8  OK - the viable lineage can exhibit heritable variation
+C9  OK - the viable lineage can adaptively persist
+C10 OK - the viable lineage is evolvable
+C11 OK - the non-digital lineage cannot achieve accurate self-reproduction
+C12 OK - the repair-deficient lineage cannot achieve accurate self-reproduction
+C13 OK - the coatless lineage cannot achieve lineage closure through protected dormancy
+C14 OK - the static lineage cannot achieve adaptive evolution
+C15 OK - the static lineage cannot be an evolvable lineage

package/examples/output/act-docking-abort.txt

@@ -0,0 +1,22 @@
+ACT docking abort token — constructor-theory coverage case
+
+Answer
+YES for the classical abort token.
+NO for universal cloning and unrestricted audit fan-out of the quantum seal.
+
+Reason Why
+The docking-abort token is treated as an abstract information variable carried by unlike classical media: lamp state, PLC register, radio frame, and audit display. Because those substrates are information media for the same variable, the token can be permuted locally, cloned locally, copied across media, measured into an output record, and embedded in serial and parallel task networks. By contrast, the quantum authenticity seal is treated as a superinformation medium, so cloning all of its states is impossible and unrestricted audit fan-out is blocked.
+
+Check
+C1  OK - the abort lamp is a computation medium
+C2  OK - the abort lamp distinguishes the abort bit
+C3  OK - permutation of the abort bit is possible on the abort lamp
+C4  OK - local cloning of the abort bit is possible on the PLC register
+C5  OK - the abort bit can be copied from lamp to PLC
+C6  OK - the abort bit can be copied from PLC to radio frame
+C7  OK - the abort bit can be measured from radio frame into the audit display
+C8  OK - a serial network from lamp via PLC to audit display is possible
+C9  OK - a parallel network from PLC to radio frame and audit display is possible
+C10 OK - cloning all states of the quantum seal is an impossible task
+C11 OK - the quantum seal cannot be universally cloned
+C12 OK - the quantum seal cannot be used for unrestricted audit fan-out