eyelang 1.2.2 → 1.3.1

package/examples/security-incident-correlation.eye

@@ -0,0 +1,69 @@
+% Representative example: security incident correlation.
+%
+% The rules correlate endpoint, identity, vulnerability, and threat-intelligence
+% signals into an escalation decision with concise reason relations.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(type, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+incident(inc42).
+incident(inc43).
+
+asset(endpoint23, criticality, high).
+asset(endpoint77, criticality, low).
+
+assigned_user(endpoint23, user_alice).
+assigned_user(endpoint77, user_bob).
+
+privileged_user(user_alice).
+
+alert(inc42, endpoint, endpoint23).
+alert(inc42, suspicious_login, user_alice).
+alert(inc42, malware_hash, hash_redline).
+alert(inc42, outbound_ip, ip_203_0_113_17).
+
+alert(inc43, endpoint, endpoint77).
+alert(inc43, suspicious_login, user_bob).
+alert(inc43, outbound_ip, ip_198_51_100_42).
+
+vulnerability(endpoint23, cve_critical_rce).
+threat_intel(ip_203_0_113_17, command_and_control).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+critical_asset(?endpoint) :-
+  asset(?endpoint, criticality, high).
+
+credential_abuse(?incident) :-
+  alert(?incident, suspicious_login, ?user),
+  privileged_user(?user).
+
+malware_on_critical_asset(?incident) :-
+  alert(?incident, endpoint, ?endpoint),
+  alert(?incident, malware_hash, ?_hash),
+  critical_asset(?endpoint).
+
+c2_contact(?incident) :-
+  alert(?incident, outbound_ip, ?ip),
+  threat_intel(?ip, command_and_control).
+
+exploitable_endpoint(?incident) :-
+  alert(?incident, endpoint, ?endpoint),
+  vulnerability(?endpoint, cve_critical_rce).
+
+confirmed_compromise(?incident) :-
+  credential_abuse(?incident),
+  malware_on_critical_asset(?incident),
+  c2_contact(?incident),
+  exploitable_endpoint(?incident).
+
+type(?incident, confirmed_compromise) :-
+  confirmed_compromise(?incident).
+
+status(?incident, escalate_to_incident_response) :-
+  confirmed_compromise(?incident).
+
+reason(?incident, "privileged credential abuse, malware on a critical endpoint, C2 contact, and exploitable RCE are correlated") :-
+  confirmed_compromise(?incident).

package/examples/send-more-money.eye

@@ -0,0 +1,71 @@
+% Cryptarithm search for SEND + MORE = MONEY.
+%
+% The solver assigns distinct decimal digits to letters while enforcing the
+% column-by-column carries.  Rather than generate all digit assignments first,
+% each column constraint is applied as soon as its letters are chosen.
+materialize(cryptarithm_answer, 2).
+
+% The search domain is a shrinking digit list threaded through select/3 calls.
+all_digits([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]).
+
+send_more_money(solution(?s, ?e, ?n, ?d, ?m, ?o, ?r, ?y)) :-
+  all_digits(?digits),
+  eq(?m, 1),
+  eq(?o, 0),
+  select(?m, ?digits, ?d0),
+  select(?o, ?d0, ?d1),
+
+  select(?d, ?d1, ?d2),
+  select(?e, ?d2, ?d3),
+  add(?d, ?e, ?onessum),
+  mod(?onessum, 10, ?y),
+  div(?onessum, 10, ?carry1),
+  select(?y, ?d3, ?d4),
+
+  select(?n, ?d4, ?d5),
+  select(?r, ?d5, ?d6),
+  add(?n, ?r, ?tenspartial),
+  add(?tenspartial, ?carry1, ?tenssum),
+  mod(?tenssum, 10, ?e),
+  div(?tenssum, 10, ?carry2),
+
+  add(?e, ?o, ?hundredspartial),
+  add(?hundredspartial, ?carry2, ?hundredssum),
+  mod(?hundredssum, 10, ?n),
+  div(?hundredssum, 10, ?carry3),
+
+  select(?s, ?d6, ?_d7),
+  neq(?s, 0),
+  add(?s, ?m, ?thousandspartial),
+  add(?thousandspartial, ?carry3, ?thousandssum),
+  mod(?thousandssum, 10, ?o),
+  div(?thousandssum, 10, ?m).
+
+% Number constructors are used only for readable output after a solution is found.
+number4(?a, ?b, ?c, ?d, ?value) :-
+  mul(?a, 1000, ?apart),
+  mul(?b, 100, ?bpart),
+  mul(?c, 10, ?cpart),
+  add(?apart, ?bpart, ?ab),
+  add(?ab, ?cpart, ?abc),
+  add(?abc, ?d, ?value).
+
+number5(?a, ?b, ?c, ?d, ?e, ?value) :-
+  mul(?a, 10000, ?apart),
+  mul(?b, 1000, ?bpart),
+  mul(?c, 100, ?cpart),
+  mul(?d, 10, ?dpart),
+  add(?apart, ?bpart, ?ab),
+  add(?ab, ?cpart, ?abc),
+  add(?abc, ?dpart, ?abcd),
+  add(?abcd, ?e, ?value).
+
+cryptarithm_answer(assignments, solution(?s, ?e, ?n, ?d, ?m, ?o, ?r, ?y)) :-
+  send_more_money(solution(?s, ?e, ?n, ?d, ?m, ?o, ?r, ?y)).
+cryptarithm_answer(equation, equation(?send, ?more, ?money)) :-
+  send_more_money(solution(?s, ?e, ?n, ?d, ?m, ?o, ?r, ?y)),
+  number4(?s, ?e, ?n, ?d, ?send),
+  number4(?m, ?o, ?r, ?e, ?more),
+  number5(?m, ?o, ?n, ?e, ?y, ?money).
+cryptarithm_answer(solution_count, ?count) :-
+  countall(send_more_money(?_solution), ?count).

package/examples/service-impact.eye

@@ -0,0 +1,41 @@
+% Practical cyclic recursion: incident impact analysis for a service dependency graph.
+% The payment stack has a real-world feedback cycle: payment_service calls
+% fraud_service, fraud_service calls risk_rules, and risk_rules calls payment_service
+% for authorization data. A payment outage should still produce a finite impact set.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(impactedByFailureOf, 2).
+materialize(status, 2).
+materialize(businessFunctionAtRisk, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+depends_on(web_store, checkout_api).
+depends_on(mobile_app, checkout_api).
+depends_on(checkout_api, payment_service).
+depends_on(checkout_api, inventory_service).
+depends_on(payment_service, fraud_service).
+depends_on(fraud_service, risk_rules).
+depends_on(risk_rules, payment_service).
+depends_on(inventory_service, stock_db).
+depends_on(stock_db, inventory_service).
+
+business_function(place_order, web_store).
+business_function(mobile_checkout, mobile_app).
+business_function(collect_payment, payment_service).
+business_function(screen_fraud, fraud_service).
+business_function(show_stock, inventory_service).
+
+failed(payment_service).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+impacted(?service, ?failed) :- depends_on(?service, ?failed).
+impacted(?service, ?failed) :- depends_on(?service, ?dependency), impacted(?dependency, ?failed).
+
+affected(?service) :- failed(?failed), impacted(?service, ?failed).
+affected(?service) :- failed(?service).
+
+affected_function(?function) :- business_function(?function, ?service), affected(?service).
+
+impactedByFailureOf(?service, ?failed) :- failed(?failed), impacted(?service, ?failed).
+status(?service, failed) :- failed(?service).
+businessFunctionAtRisk(?function, true) :- affected_function(?function).

package/examples/sieve.eye

@@ -0,0 +1,20 @@
+% Prime enumeration inspired by Eyelet input/sieve.eye.
+% The 1000-limit answer matches Eyelet output-swipl/sieve.eye.
+%
+% eyelang uses the built-in smallest_divisor_from/3 relation to keep the
+% example fast while preserving the same generated prime list.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(primes, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+want_primes(1000).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+prime_under(?limit, ?p) :-
+  between(2, ?limit, ?p),
+  smallest_divisor_from(?p, 2, ?p).
+
+primes(?limit, ?ps) :-
+  want_primes(?limit),
+  findall(?p, prime_under(?limit, ?p), ?ps).

package/examples/skolem-functions.eye

@@ -0,0 +1,52 @@
+% Skolem functional terms in rule heads.
+%
+% A generated resource should be deterministic and collision-free. Use a
+% function symbol whose arguments contain the values that make the resource
+% unique, such as skolem_observation(Patient, Test).
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(type, 2).
+materialize(patient, 2).
+materialize(test, 2).
+materialize(value, 2).
+materialize(about, 2).
+materialize(sameInputsSameId, 2).
+materialize(noObservationClash, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+test_result(alice, glucose, 6.8).
+test_result(alice, cholesterol, 4.2).
+test_result(bob, glucose, 5.1).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+high_glucose(?patient) :-
+  test_result(?patient, glucose, ?value),
+  gt(?value, 6.0).
+
+observation_id(?patient, ?test, skolem_observation(?patient, ?test)) :-
+  test_result(?patient, ?test, ?_value).
+
+type(skolem_observation(?patient, ?test), observation) :-
+  test_result(?patient, ?test, ?_value).
+
+patient(skolem_observation(?patient, ?test), ?patient) :-
+  test_result(?patient, ?test, ?_value).
+
+test(skolem_observation(?patient, ?test), ?test) :-
+  test_result(?patient, ?test, ?_value).
+
+value(skolem_observation(?patient, ?test), ?value) :-
+  test_result(?patient, ?test, ?value).
+
+type(skolem_alert(?patient, glucose), highGlucoseAlert) :-
+  high_glucose(?patient).
+
+about(skolem_alert(?patient, glucose), skolem_observation(?patient, glucose)) :-
+  high_glucose(?patient).
+
+sameInputsSameId(skolemDemo, true) :-
+  eq(skolem_observation(alice, glucose), skolem_observation(alice, glucose)).
+
+noObservationClash(skolemDemo, true) :-
+  neq(skolem_observation(alice, glucose), skolem_observation(alice, cholesterol)),
+  neq(skolem_observation(alice, glucose), skolem_observation(bob, glucose)).

package/examples/socket-age.eye

@@ -0,0 +1,39 @@
+% socket-age.eye
+%
+% A small runnable eyelang Socket example for age reasoning.
+%
+% The socket facts are ordinary eyelang data. They document the semantic
+% openings that this rule module expects:
+%
+%   - a patient registry that provides birthDay/2
+%   - a policy source that provides duration/2
+%   - a clock source that provides today/1
+%
+% The plug facts say which concrete providers are connected.
+%
+% Run:
+%   eyelang socket-age.eye
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(ageAbove, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+socket(patient_registry, provides(birthDay_2)).
+socket(policy_source, provides(duration_2)).
+socket(clock_source, provides(today_1)).
+
+plug(test_patients, patient_registry).
+plug(test_policy, policy_source).
+plug(test_clock, clock_source).
+
+birthDay(patH, "1944-08-21").
+duration(check, "P80Y").
+today("2026-05-30").
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+ageAbove(?s, ?a) :-
+    birthDay(?s, ?b),
+    duration(check, ?a),
+    today(?d),
+    difference(?d, ?b, ?f),
+    gt(?f, ?a).

package/examples/socket-family.eye

@@ -0,0 +1,28 @@
+% socket-family.eye
+%
+% A small runnable eyelang Socket example.
+%
+% The socket facts below are ordinary eyelang data. They document the
+% semantic opening: this reasoning module expects a provider for parent/2.
+% The plug fact says which provider is connected.
+%
+% Run:
+%   eyelang socket-family.eye
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(ancestor, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+socket(family_source, provides(parent_2)).
+plug(family_file, family_source).
+
+parent(pat, jan).
+parent(jan, emma).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+ancestor(?x, ?y) :-
+    parent(?x, ?y).
+
+ancestor(?x, ?z) :-
+    parent(?x, ?y),
+    ancestor(?y, ?z).

package/examples/socrates.eye

@@ -0,0 +1,19 @@
+% Socrates is mortal, adapted from Eyelet's input/socrates.eye.
+%
+% Eyelet uses type('Socrates', 'Man') and a single rule deriving Mortal.
+% eyelang keeps the same reasoning shape and emits relation facts.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(type, 2).
+materialize(is, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+type(socrates, man).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+type(?x, mortal) :-
+  type(?x, man).
+
+
+is(test, true) :-
+  type(socrates, mortal).

package/examples/stable-marriage.eye

@@ -0,0 +1,92 @@
+% Stable-marriage search with explicit blocking-pair detection.
+%
+% matching/1 enumerates one-to-one pairings for four men and four women.  A
+% pairing is stable precisely when no blocking pair exists: two people who would
+% both prefer each other over their assigned partners.
+materialize(stable_marriage_answer, 2).
+
+man(adam).
+man(brian).
+man(cole).
+man(drew).
+
+woman(amy).
+woman(bea).
+woman(cora).
+woman(dana).
+
+rank_man(adam, bea, 1).
+rank_man(adam, amy, 2).
+rank_man(adam, dana, 3).
+rank_man(adam, cora, 4).
+rank_man(brian, amy, 1).
+rank_man(brian, cora, 2).
+rank_man(brian, bea, 3).
+rank_man(brian, dana, 4).
+rank_man(cole, amy, 1).
+rank_man(cole, bea, 2).
+rank_man(cole, dana, 3).
+rank_man(cole, cora, 4).
+rank_man(drew, cora, 1).
+rank_man(drew, dana, 2).
+rank_man(drew, bea, 3).
+rank_man(drew, amy, 4).
+
+rank_woman(amy, cole, 1).
+rank_woman(amy, adam, 2).
+rank_woman(amy, brian, 3).
+rank_woman(amy, drew, 4).
+rank_woman(bea, adam, 1).
+rank_woman(bea, cole, 2).
+rank_woman(bea, drew, 3).
+rank_woman(bea, brian, 4).
+rank_woman(cora, drew, 1).
+rank_woman(cora, brian, 2).
+rank_woman(cora, adam, 3).
+rank_woman(cora, cole, 4).
+rank_woman(dana, brian, 1).
+rank_woman(dana, drew, 2).
+rank_woman(dana, cole, 3).
+rank_woman(dana, adam, 4).
+
+% Permutations give every complete one-to-one matching over the four women.
+perm([], []).
+perm(?items, [?x|?rest]) :-
+  select(?x, ?items, ?remaining),
+  perm(?remaining, ?rest).
+
+matching([
+  pair(adam, ?w1),
+  pair(brian, ?w2),
+  pair(cole, ?w3),
+  pair(drew, ?w4)
+]) :-
+  perm([amy, bea, cora, dana], [?w1, ?w2, ?w3, ?w4]).
+
+assigned(?matching, ?man, ?woman) :- member(pair(?man, ?woman), ?matching).
+
+prefers_man(?man, ?candidate, ?current) :-
+  rank_man(?man, ?candidate, ?candidaterank),
+  rank_man(?man, ?current, ?currentrank),
+  lt(?candidaterank, ?currentrank).
+
+prefers_woman(?woman, ?candidate, ?current) :-
+  rank_woman(?woman, ?candidate, ?candidaterank),
+  rank_woman(?woman, ?current, ?currentrank),
+  lt(?candidaterank, ?currentrank).
+
+% A blocking pair witnesses instability of a candidate matching.
+blocking_pair(?matching, ?man, ?woman) :-
+  assigned(?matching, ?man, ?currentwoman),
+  woman(?woman),
+  neq(?woman, ?currentwoman),
+  prefers_man(?man, ?woman, ?currentwoman),
+  assigned(?matching, ?currentman, ?woman),
+  prefers_woman(?woman, ?man, ?currentman).
+
+stable_matching(?matching) :-
+  matching(?matching),
+  not(blocking_pair(?matching, ?_man, ?_woman)).
+
+stable_marriage_answer(first_stable_matching, ?matching) :- once(stable_matching(?matching)).
+stable_marriage_answer(stable_matching_count, ?count) :- countall(stable_matching(?_matching), ?count).

package/examples/statistics-summary.eye

@@ -0,0 +1,56 @@
+% Population statistics for a small numeric sample.
+%
+% The sample is the textbook data set [2,4,4,4,5,5,7,9], whose population
+% mean is 5, variance is 4, and standard deviation is 2.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(count, 2).
+materialize(mean, 2).
+materialize(populationVariance, 2).
+materialize(populationStddev, 2).
+
+% The sample is one list fact, which lets recursive list folds demonstrate
+% aggregation without introducing a separate row relation.
+sample(scores, [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0]).
+
+sum([], 0.0).
+% sum/2 and squared_error_sum/3 are recursive folds; the public relations then
+% derive count, mean, population variance, and standard deviation.
+sum([?x|?xs], ?total) :-
+  sum(?xs, ?rest),
+  add(?x, ?rest, ?total).
+
+mean(?name, ?mean) :-
+  sample(?name, ?values),
+  sum(?values, ?total),
+  length(?values, ?count),
+  div(?total, ?count, ?mean).
+
+squared_error_sum([], ?_mean, 0.0).
+squared_error_sum([?x|?xs], ?mean, ?total) :-
+  sub(?x, ?mean, ?delta),
+  pow(?delta, 2.0, ?squared),
+  squared_error_sum(?xs, ?mean, ?rest),
+  add(?squared, ?rest, ?total).
+
+population_variance(?name, ?variance) :-
+  sample(?name, ?values),
+  mean(?name, ?mean),
+  squared_error_sum(?values, ?mean, ?sumsquarederrors),
+  length(?values, ?count),
+  div(?sumsquarederrors, ?count, ?variance).
+
+population_stddev(?name, ?stddev) :-
+  population_variance(?name, ?variance),
+  pow(?variance, 0.5, ?stddev).
+
+count(?name, ?count) :-
+  sample(?name, ?values),
+  length(?values, ?count).
+
+
+populationVariance(?name, ?variance) :-
+  population_variance(?name, ?variance).
+
+populationStddev(?name, ?stddev) :-
+  population_stddev(?name, ?stddev).

package/examples/stirling-bell-numbers.eye

@@ -0,0 +1,32 @@
+% Stirling numbers of the second kind and Bell numbers.
+%
+% stirling2(N, K, Count) counts partitions of N labelled elements into K nonempty blocks.
+% The recurrence either places the newest labelled element into a new singleton block or into
+% one of the K existing blocks.  bell/2 then sums a whole row of Stirling numbers.
+% Memoization turns the overlapping recurrence into a small dynamic-programming table.
+materialize(stirling_bell_answer, 2).
+
+table(stirling2, 3).
+
+% Boundary cases define the empty partition and the impossible zero-block columns.
+stirling2(0, 0, 1).
+stirling2(?n, 0, 0) :- gt(?n, 0).
+stirling2(0, ?k, 0) :- gt(?k, 0).
+stirling2(?n, ?k, ?count) :-
+  gt(?n, 0),
+  gt(?k, 0),
+  sub(?n, 1, ?n1),
+  sub(?k, 1, ?k1),
+  stirling2(?n1, ?k1, ?newblock),
+  stirling2(?n1, ?k, ?existingblocks),
+  mul(?k, ?existingblocks, ?extended),
+  add(?newblock, ?extended, ?count).
+
+% Bell(N) is the row sum S(N,0)+...+S(N,N).
+bell(?n, ?count) :-
+  sumall(?s, (between(0, ?n, ?k), stirling2(?n, ?k, ?s)), ?count).
+
+stirling_bell_answer(stirling_10_4, ?count) :- stirling2(10, 4, ?count).
+stirling_bell_answer(stirling_12_5, ?count) :- stirling2(12, 5, ?count).
+stirling_bell_answer(bell_10, ?count) :- bell(10, ?count).
+stirling_bell_answer(bell_12, ?count) :- bell(12, ?count).

package/examples/sudoku-4x4.eye

@@ -0,0 +1,54 @@
+% Compact 4x4 Sudoku search with row permutations and column/box constraints.
+%
+% The givens are baked into row1/1 ... row4/1, so each candidate row is already
+% a permutation of 1..4.  sudoku_solution/1 then checks the remaining columns
+% and 2x2 boxes, which keeps the example clear and playground-friendly.
+materialize(sudoku_answer, 2).
+
+perm([], []).
+perm(?items, [?x|?rest]) :-
+  select(?x, ?items, ?remaining),
+  perm(?remaining, ?rest).
+
+% distinct/1 is the reusable all-different constraint.
+distinct([]).
+distinct([?x|?xs]) :-
+  not_member(?x, ?xs),
+  distinct(?xs).
+
+row1([1, ?b, ?c, 4]) :- perm([1, 2, 3, 4], [1, ?b, ?c, 4]).
+row2([?a, 4, 1, ?d]) :- perm([1, 2, 3, 4], [?a, 4, 1, ?d]).
+row3([?b, 1, 4, ?c]) :- perm([1, 2, 3, 4], [?b, 1, 4, ?c]).
+row4([4, ?c, ?b, 1]) :- perm([1, 2, 3, 4], [4, ?c, ?b, 1]).
+
+column([?r1, ?r2, ?r3, ?r4], ?index, [?a, ?b, ?c, ?d]) :-
+  nth0(?index, ?r1, ?a),
+  nth0(?index, ?r2, ?b),
+  nth0(?index, ?r3, ?c),
+  nth0(?index, ?r4, ?d).
+
+% The four boxes are extracted as lists, then passed through distinct/1.
+boxes([?r1, ?r2, ?r3, ?r4], [?box1, ?box2, ?box3, ?box4]) :-
+  nth0(0, ?r1, ?a), nth0(1, ?r1, ?b), nth0(0, ?r2, ?c), nth0(1, ?r2, ?d),
+  eq(?box1, [?a, ?b, ?c, ?d]),
+  nth0(2, ?r1, ?e), nth0(3, ?r1, ?f), nth0(2, ?r2, ?g), nth0(3, ?r2, ?h),
+  eq(?box2, [?e, ?f, ?g, ?h]),
+  nth0(0, ?r3, ?i), nth0(1, ?r3, ?j), nth0(0, ?r4, ?k), nth0(1, ?r4, ?l),
+  eq(?box3, [?i, ?j, ?k, ?l]),
+  nth0(2, ?r3, ?m), nth0(3, ?r3, ?n), nth0(2, ?r4, ?o), nth0(3, ?r4, ?p),
+  eq(?box4, [?m, ?n, ?o, ?p]).
+
+sudoku_solution([?r1, ?r2, ?r3, ?r4]) :-
+  row1(?r1),
+  row2(?r2),
+  row3(?r3),
+  row4(?r4),
+  column([?r1, ?r2, ?r3, ?r4], 0, ?c0), distinct(?c0),
+  column([?r1, ?r2, ?r3, ?r4], 1, ?c1), distinct(?c1),
+  column([?r1, ?r2, ?r3, ?r4], 2, ?c2), distinct(?c2),
+  column([?r1, ?r2, ?r3, ?r4], 3, ?c3), distinct(?c3),
+  boxes([?r1, ?r2, ?r3, ?r4], [?b1, ?b2, ?b3, ?b4]),
+  distinct(?b1), distinct(?b2), distinct(?b3), distinct(?b4).
+
+sudoku_answer(solution, ?grid) :- once(sudoku_solution(?grid)).
+sudoku_answer(solution_count, ?count) :- countall(sudoku_solution(?_grid), ?count).

package/examples/superdense-coding.eye

@@ -0,0 +1,84 @@
+% Superdense coding using discrete quantum computing, adapted from
+% Eyelet's input/superdense-coding.eye.
+%
+% The Eyelet program toggles dynamic sdcoding/2 facts so answers appearing an
+% even number of times cancel. eyelang expresses the same finite example
+% declaratively: for this protocol the surviving messages are exactly those
+% with a single support path after the interference choices are expanded.
+
+% |R) = |0, 0) + |1, 1)
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(decodesAs, 2).
+materialize(preservesMessage, 2).
+materialize(cancelsCrossTalk, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+r(false, false).
+r(true, true).
+
+% ID |0) = |0), ID |1) = |1)
+identity(false, false).
+identity(true, true).
+
+% G |0) = |1), G |1) = |0)
+g(false, true).
+g(true, false).
+
+% K |0) = |0), K |1) = |0) + |1)
+k(false, false).
+k(true, false).
+k(true, true).
+
+% KG and GK compositions.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+kg(?x, ?y) :-
+  g(?x, ?z),
+  k(?z, ?y).
+
+gk(?x, ?y) :-
+  k(?x, ?z),
+  g(?z, ?y).
+
+% Alice encodes two classical bits as one of four transformations.
+alice(0, ?x, ?y) :- identity(?x, ?y).
+alice(1, ?x, ?y) :- g(?x, ?y).
+alice(2, ?x, ?y) :- k(?x, ?y).
+alice(3, ?x, ?y) :- kg(?x, ?y).
+
+% Bob decodes with the Bell-style measurement basis.
+bob(?x, ?y, 0) :- gk(?x, ?y).
+bob(?x, ?y, 1) :- k(?x, ?y).
+bob(?x, ?y, 2) :- g(?x, ?y).
+bob(?x, ?y, 3) :- identity(?x, ?y).
+
+% One concrete support path through the entangled pair and the two transforms.
+sdc_path(?n, ?m, path(?x, ?y, ?b)) :-
+  r(?x, ?y),
+  alice(?n, ?x, ?b),
+  bob(?b, ?y, ?m).
+
+% If another different support path gives the same answer, this answer cancels
+% in pairs in the finite superdense-coding table.
+duplicate_sdc_path(?n, ?m, ?proof) :-
+  sdc_path(?n, ?m, ?proof),
+  sdc_path(?n, ?m, ?other),
+  neq(?proof, ?other).
+
+sdcoding(?n, ?m) :-
+  sdc_path(?n, ?m, ?proof),
+  not(duplicate_sdc_path(?n, ?m, ?proof)).
+
+decodesAs(message(?n), ?m) :-
+  sdcoding(?n, ?m).
+
+preservesMessage(protocol, true) :-
+  sdcoding(0, 0),
+  sdcoding(1, 1),
+  sdcoding(2, 2),
+  sdcoding(3, 3).
+
+cancelsCrossTalk(protocol, true) :-
+  not(sdcoding(0, 1)),
+  not(sdcoding(1, 0)),
+  not(sdcoding(2, 3)),
+  not(sdcoding(3, 2)).