eyelang 1.7.16 → 2.0.0

package/examples/competitive-enzyme-kinetics.pl

@@ -0,0 +1,78 @@
+% Science example: competitive enzyme inhibition.
+%
+% Michaelis-Menten kinetics with a competitive inhibitor:
+%   Km_effective = Km * (1 + Inhibitor / Ki)
+%   rate = Vmax * Substrate / (Km_effective + Substrate)
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(effectiveKm_uM, 2).
+materialize(uninhibitedRate_uM_s, 2).
+materialize(inhibitedRate_uM_s, 2).
+materialize(inhibitionFraction, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+assay(assay1, vmax_uM_s, 120.0).
+assay(assay1, substrate_uM, 50.0).
+assay(assay1, km_uM, 30.0).
+assay(assay1, inhibitor_uM, 10.0).
+assay(assay1, ki_uM, 5.0).
+threshold(assay1, significant_inhibition_fraction, 0.25).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+competitive_multiplier(Assay, Multiplier) :-
+  assay(Assay, inhibitor_uM, Inhibitor),
+  assay(Assay, ki_uM, Ki),
+  div(Inhibitor, Ki, Ratio),
+  add(1.0, Ratio, Multiplier).
+
+effective_km(Assay, Effectivekm) :-
+  assay(Assay, km_uM, Km),
+  competitive_multiplier(Assay, Multiplier),
+  mul(Km, Multiplier, Effectivekm).
+
+uninhibited_rate(Assay, Rate) :-
+  assay(Assay, vmax_uM_s, Vmax),
+  assay(Assay, substrate_uM, Substrate),
+  assay(Assay, km_uM, Km),
+  mul(Vmax, Substrate, Numerator),
+  add(Km, Substrate, Denominator),
+  div(Numerator, Denominator, Rate).
+
+inhibited_rate(Assay, Rate) :-
+  assay(Assay, vmax_uM_s, Vmax),
+  assay(Assay, substrate_uM, Substrate),
+  effective_km(Assay, Effectivekm),
+  mul(Vmax, Substrate, Numerator),
+  add(Effectivekm, Substrate, Denominator),
+  div(Numerator, Denominator, Rate).
+
+inhibition_fraction(Assay, Fraction) :-
+  uninhibited_rate(Assay, Uninhibited),
+  inhibited_rate(Assay, Inhibited),
+  sub(Uninhibited, Inhibited, Delta),
+  div(Delta, Uninhibited, Fraction).
+
+significant_inhibition(Assay) :-
+  inhibition_fraction(Assay, Fraction),
+  threshold(Assay, significant_inhibition_fraction, Limit),
+  gt(Fraction, Limit).
+
+effectiveKm_uM(Assay, Effectivekm) :-
+  effective_km(Assay, Effectivekm).
+
+uninhibitedRate_uM_s(Assay, Rate) :-
+  uninhibited_rate(Assay, Rate).
+
+inhibitedRate_uM_s(Assay, Rate) :-
+  inhibited_rate(Assay, Rate).
+
+inhibitionFraction(Assay, Fraction) :-
+  inhibition_fraction(Assay, Fraction).
+
+status(Assay, significant_inhibition) :-
+  significant_inhibition(Assay).
+
+reason(Assay, "competitive inhibitor raises effective Km and lowers reaction rate") :-
+  significant_inhibition(Assay).

package/examples/complex.pl

@@ -0,0 +1,133 @@
+% Complex numbers, adapted from Eyeling complex.n3.
+%
+% Complex values are represented as two-item lists [Real, Imaginary], matching
+% the pair-shaped pair lists used by the Eyeling source.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+%
+% The example derives arithmetic identities, polar conversions, powers, roots,
+% exponential/trigonometric functions, and distance/normalization results from
+% a small complex-number toolkit.
+materialize(complex_power, 4).
+materialize(complex_function, 4).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+pi(3.141592653589793).
+e(2.718281828459045).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+% z^w is evaluated through polar/log form, exposing useful intermediate proof steps.
+complex_exponentiation([A, B], [C, D], [E, F]) :-
+  complex_polar([A, B], [R, T]),
+  pow(R, C, Z1),
+  neg(D, Z2),
+  mul(Z2, T, Z3),
+  e(Euler),
+  pow(Euler, Z3, Z4),
+  log(R, Z5),
+  mul(D, Z5, Z6),
+  mul(C, T, Z7),
+  add(Z6, Z7, Z8),
+  cos(Z8, Z9),
+  mul(Z1, Z4, Z1z4),
+  mul(Z1z4, Z9, E),
+  sin(Z8, Z10),
+  mul(Z1z4, Z10, F).
+
+complex_asin([A, B], [C, D]) :-
+  add(1, A, Z1),
+  pow(Z1, 2, Z2),
+  pow(B, 2, Z3),
+  add(Z2, Z3, Z4),
+  pow(Z4, 0.5, Z5),
+  sub(1, A, Z6),
+  pow(Z6, 2, Z7),
+  add(Z7, Z3, Z8),
+  pow(Z8, 0.5, Z9),
+  sub(Z5, Z9, Z10),
+  div(Z10, 2, E),
+  add(Z5, Z9, Z11),
+  div(Z11, 2, F),
+  asin(E, C),
+  pow(F, 2, Z12),
+  sub(Z12, 1, Z13),
+  pow(Z13, 0.5, Z14),
+  add(F, Z14, Z15),
+  log(Z15, D).
+
+complex_acos([A, B], [C, D]) :-
+  add(1, A, Z1),
+  pow(Z1, 2, Z2),
+  pow(B, 2, Z3),
+  add(Z2, Z3, Z4),
+  pow(Z4, 0.5, Z5),
+  sub(1, A, Z6),
+  pow(Z6, 2, Z7),
+  add(Z7, Z3, Z8),
+  pow(Z8, 0.5, Z9),
+  sub(Z5, Z9, Z10),
+  div(Z10, 2, E),
+  add(Z5, Z9, Z11),
+  div(Z11, 2, F),
+  acos(E, C),
+  pow(F, 2, Z12),
+  sub(Z12, 1, Z13),
+  pow(Z13, 0.5, Z14),
+  add(F, Z14, Z15),
+  log(Z15, U),
+  neg(U, D).
+
+complex_polar([X, Y], [R, Tp]) :-
+  pow(X, 2, Z1),
+  pow(Y, 2, Z2),
+  add(Z1, Z2, Z3),
+  pow(Z3, 0.5, R),
+  abs(X, Z4),
+  div(Z4, R, Z5),
+  acos(Z5, T),
+  complex_dial(X, Y, T, Tp).
+
+complex_dial(X, Y, T, Tp) :-
+  ge(X, 0),
+  ge(Y, 0),
+  add(0, T, Tp).
+
+complex_dial(X, Y, T, Tp) :-
+  lt(X, 0),
+  ge(Y, 0),
+  pi(Pi),
+  sub(Pi, T, Tp).
+
+complex_dial(X, Y, T, Tp) :-
+  lt(X, 0),
+  lt(Y, 0),
+  pi(Pi),
+  add(Pi, T, Tp).
+
+complex_dial(X, Y, T, Tp) :-
+  ge(X, 0),
+  lt(Y, 0),
+  pi(Pi),
+  mul(Pi, 2, Z1),
+  sub(Z1, T, Tp).
+
+% Named result rows keep the example output readable.  Each row records the
+% operation name, the input value(s), and the computed complex result rather
+% than packing all assertions into one large nested term.
+complex_power(sqrt_minus_one, [-1, 0], [0.5, 0], Result) :-
+  complex_exponentiation([-1, 0], [0.5, 0], Result).
+
+complex_power(e_to_i_pi, [2.718281828459045, 0], [0, 3.141592653589793], Result) :-
+  complex_exponentiation([2.718281828459045, 0], [0, 3.141592653589793], Result).
+
+complex_power(i_to_i, [0, 1], [0, 1], Result) :-
+  complex_exponentiation([0, 1], [0, 1], Result).
+
+complex_power(e_to_minus_pi_over_two, [2.718281828459045, 0], [-1.57079632679, 0], Result) :-
+  complex_exponentiation([2.718281828459045, 0], [-1.57079632679, 0], Result).
+
+complex_function(asin, two, [2, 0], Result) :-
+  complex_asin([2, 0], Result).
+
+complex_function(acos, two, [2, 0], Result) :-
+  complex_acos([2, 0], Result).

package/examples/composition-of-injective-functions-is-injective.pl

@@ -0,0 +1,50 @@
+% Composition of injective functions is injective, adapted from Eyeling's
+% examples/composition-of-injective-functions-is-injective.n3.
+%
+% The output mirrors the Eyeling golden result shape:
+% sameInputByCompositeInjectivity(h, a, b) and the symmetric counterpart.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(sameInputByCompositeInjectivity, 3).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+inX(a).
+inX(b).
+inY(c).
+inY(d).
+inZ(e).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+sameTerm(X, X) :- inX(X).
+sameTerm(X, X) :- inY(X).
+sameTerm(X, X) :- inZ(X).
+sameTerm(Y, X) :- sameTerm(X, Y).
+
+app(f, a, c).
+app(f, b, d).
+app(g, c, e).
+app(g, d, e).
+
+injective(f).
+injective(g).
+compositeOf(h, g, f).
+
+app(H, X, Z) :-
+  compositeOf(H, G, F),
+  app(F, X, Y),
+  app(G, Y, Z).
+
+sameTerm(X, Y) :-
+  injective(F),
+  app(F, X, U),
+  app(F, Y, V),
+  sameTerm(U, V).
+
+sameInputByCompositeInjectivity(H, X, Y) :-
+  compositeOf(H, G, F),
+  injective(G),
+  injective(F),
+  app(H, X, Z),
+  app(H, Y, Z),
+  sameTerm(X, Y),
+  neq(X, Y).

package/examples/context-association.pl

@@ -0,0 +1,53 @@
+% Context association adapted from Eyeling context-association.n3.
+%
+% This version keeps the original shape: each context is named with log_nameOf
+% and its contents remain quoted formula data.  Nothing inside the three formulae
+% is asserted globally unless a rule explicitly projects it.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(log_nameOf, 2).
+materialize(dataGraph, 2).
+materialize(signatureGraph, 2).
+materialize(metadataGraph, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+log_nameOf(skolem_g0, foaf_name(bob, "Bob")).
+
+log_nameOf(skolem_g1, (
+  sec_proof(skolem_g0, dataSignature),
+  type(signature1, sec_DataIntegrityProof),
+  sec_cryptosuite(signature1, "ecdsa-proof-2019"),
+  sec_created(signature1, "2021-11-13T18:19:39Z"),
+  sec_verificationMethod(signature1, "https://university.example/issuers/14#key-1"),
+  sec_proofPurpose(signature1, "assertionMethod"),
+  sec_proofValue(signature1, "z58DAdFfa9SkqZMVPxAQp...jQCrfFPP2oumHKtz"),
+  sec_issuer(signature1, university),
+  sec_validFrom(signature1, "2024-04-03T00:00:00.000Z"),
+  sec_validUntil(signature1, "2025-04-03T00:00:00.000Z")
+)).
+
+log_nameOf(g3, (
+  sec_proof(skolem_g1, signature2),
+  type(signature2, sec_DataIntegrityProof),
+  sec_cryptosuite(signature2, "ecdsa-proof-2019"),
+  sec_created(signature2, "2021-11-13T18:19:39Z"),
+  sec_verificationMethod(signature2, "https://university.example/issuers/14#key-1"),
+  sec_proofPurpose(signature2, "assertionMethod"),
+  sec_proofValue(signature2, "adad123efv434r5200...dqed2t44v43das")
+)).
+
+% A tiny projection shows how a program can inspect a quoted context without
+% making the entire context globally true.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+context_statement(Contextname, Subject, Predicate, Object) :-
+  log_nameOf(Contextname, Context),
+  holds(Context, Predicate, [Subject, Object]).
+
+dataGraph(association, skolem_g0) :-
+  context_statement(skolem_g0, bob, foaf_name, "Bob").
+
+signatureGraph(association, skolem_g1) :-
+  context_statement(skolem_g1, skolem_g0, sec_proof, dataSignature).
+
+metadataGraph(association, g3) :-
+  context_statement(g3, skolem_g1, sec_proof, signature2).

package/examples/context-schema-audit.pl

@@ -0,0 +1,46 @@
+% Context schema audit.
+%
+% This example needs holds/3 rather than holds/2 because the audit rule does
+% not know the predicate names or arities in advance.  It inspects a whole
+% context as data, extracts each member as Name + Args, computes the arity, and
+% checks that shape against an allowed schema.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(context_shape, 3).
+materialize(schema_violation, 3).
+
+% Program structure: each message carries heterogeneous context data.  The
+% members deliberately use different arities: heartbeat/0, source/1,
+% temperature/2, gps/3, and signature/4.
+message_context(msg_ok, (
+  heartbeat,
+  source(sensor17),
+  temperature(sensor17, 38),
+  gps(sensor17, 51, 4),
+  signature(sensor17, sha256, "9f86d081", "2026-06-18T09:30:00Z")
+)).
+
+message_context(msg_bad, (
+  heartbeat,
+  source(sensor18),
+  temperature(sensor18, 99),
+  gps(sensor18, 51),
+  tampered(sensor18)
+)).
+
+allowed_shape(heartbeat, 0).
+allowed_shape(source, 1).
+allowed_shape(temperature, 2).
+allowed_shape(gps, 3).
+allowed_shape(signature, 4).
+
+% Derivation rules: holds/3 exposes arbitrary context members as predicate name
+% plus argument list, so one generic rule can audit mixed-arity data.
+context_shape(Message, Name, Arity) :-
+  message_context(Message, Context),
+  holds(Context, Name, Args),
+  length(Args, Arity).
+
+schema_violation(Message, Name, Arity) :-
+  context_shape(Message, Name, Arity),
+  not(allowed_shape(Name, Arity)).

package/examples/continued-fraction-sqrt2.pl

@@ -0,0 +1,36 @@
+% Convergents of sqrt(2) by tabled recurrence.
+%
+% conv(N, P, Q) gives the Nth numerator/denominator pair for [1; 2, 2, ...].
+% Because each convergent depends on the previous two, memoization avoids the
+% exponential recomputation that the direct Horn-clause recurrence would have.
+% pell_error/2 connects the approximation sequence with P^2 - 2Q^2 = +/-1.
+materialize(convergent_answer, 2).
+
+table(conv, 3).
+
+% Base convergents are 1/1 and 3/2.
+conv(0, 1, 1).
+conv(1, 3, 2).
+conv(N, P, Q) :-
+  gt(N, 1),
+  sub(N, 1, N1),
+  sub(N, 2, N2),
+  conv(N1, P1, Q1),
+  conv(N2, P2, Q2),
+  mul(2, P1, Twicep1),
+  add(Twicep1, P2, P),
+  mul(2, Q1, Twiceq1),
+  add(Twiceq1, Q2, Q).
+
+% The signed error alternates between +1 and -1 for these convergents.
+pell_error(N, Error) :-
+  conv(N, P, Q),
+  mul(P, P, P2),
+  mul(Q, Q, Q2),
+  mul(2, Q2, Twiceq2),
+  sub(P2, Twiceq2, Error).
+
+convergent_answer(convergent_10, fraction(P, Q)) :- conv(10, P, Q).
+convergent_answer(convergent_15, fraction(P, Q)) :- conv(15, P, Q).
+convergent_answer(pell_error_15, Error) :- pell_error(15, Error).
+convergent_answer(numerator_sum_0_to_10, Sum) :- sumall(P, (between(0, 10, N), conv(N, P, _q)), Sum).

package/examples/control-system.pl

@@ -0,0 +1,76 @@
+% Control Systems example, adapted from Eyelet's input/control-system.pl.
+%
+% The example combines measurements, observations, targets, logarithmic
+% feedforward compensation, square-root normalization, and nonlinear feedback.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+%
+% Each derived quantity is represented as its own predicate rather than a single
+% formula blob, making the proof trace useful for debugging a failed actuator
+% normalization or control-signal calculation.
+materialize(controlSignal, 2).
+materialize(status, 2).
+materialize(normalizedMeasurement, 2).
+materialize(log10, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+measurement(input1, [6, 11]).
+measurement(disturbance2, [45, 39]).
+measurement(input2, true).
+measurement(input3, 56967).
+measurement(disturbance1, 35766).
+measurement(output2, 24).
+
+observation(state1, 80).
+observation(state2, false).
+observation(state3, 22).
+
+target(output2, 29).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+measurement_normalized(I, M) :-
+  measurement(I, [M1, M2]),
+  lt(M1, M2),
+  sub(M2, M1, Delta),
+  pow(Delta, 0.5, M).
+
+measurement_normalized(I, M1) :-
+  measurement(I, [M1, M2]),
+  ge(M1, M2).
+
+log10(Value, Result) :-
+  log(Value, Naturallog),
+  log(10, Naturallog10),
+  div(Naturallog, Naturallog10, Result).
+
+control(actuator1, C) :-
+  measurement_normalized(input1, M1),
+  measurement(input2, true),
+  measurement(disturbance1, D1),
+  mul(M1, 19.6, Proportional),
+  log10(D1, Compensation),
+  sub(Proportional, Compensation, C).
+
+control(actuator2, C) :-
+  observation(state3, P3),
+  measurement(output2, M4),
+  target(output2, T2),
+  sub(T2, M4, Error),
+  sub(P3, M4, Differentialerror),
+  mul(5.8, Error, Proportional),
+  div(7.3, Error, Nonlinearfactor),
+  mul(Nonlinearfactor, Differentialerror, Differential),
+  add(Proportional, Differential, C).
+
+controlSignal(Actuator, C) :-
+  control(Actuator, C).
+
+status(Actuator, active) :-
+  control(Actuator, _c).
+
+normalizedMeasurement(input1, M) :-
+  measurement_normalized(input1, M).
+
+log10(disturbance1, C) :-
+  measurement(disturbance1, D),
+  log10(D, C).

package/examples/critical-path-schedule.pl

@@ -0,0 +1,82 @@
+% Critical-path scheduling for a small project network.
+%
+% earliest_start/2 is the maximum finish time over all predecessors; finish_time/2
+% adds task duration.  Critical tasks are reconstructed by following predecessors
+% that attain those maxima.  Memoization lets the schedule, finish date, and path
+% queries share the same project-network subproblems.
+materialize(critical_path_answer, 2).
+
+table(earliest_start, 2).
+table(finish_time, 2).
+
+% Durations are in arbitrary project time units.
+task(requirements, 2).
+task(architecture, 3).
+task(api_design, 2).
+task(database, 4).
+task(backend, 6).
+task(frontend, 5).
+task(auth, 3).
+task(integration, 4).
+task(security_review, 3).
+task(load_test, 2).
+task(launch, 1).
+
+depends(architecture, requirements).
+depends(api_design, requirements).
+depends(database, architecture).
+depends(backend, api_design).
+depends(backend, database).
+depends(frontend, api_design).
+depends(auth, architecture).
+depends(integration, backend).
+depends(integration, frontend).
+depends(integration, auth).
+depends(security_review, integration).
+depends(load_test, integration).
+depends(launch, security_review).
+depends(launch, load_test).
+
+earliest_start(Task, 0) :-
+  task(Task, _duration),
+  not(depends(Task, _pred)).
+earliest_start(Task, Start) :-
+  depends(Task, _pred),
+  aggregate_max(Finish, Pred,
+    (depends(Task, Pred), finish_time(Pred, Finish)),
+    Start, _criticalpred).
+
+finish_time(Task, Finish) :-
+  task(Task, Duration),
+  earliest_start(Task, Start),
+  add(Start, Duration, Finish).
+
+% For each task, choose a predecessor that determines its earliest start.
+critical_predecessor(Task, Pred) :-
+  depends(Task, _anypred),
+  aggregate_max(Finish, P,
+    (depends(Task, P), finish_time(P, Finish)),
+    _bestfinish, Pred).
+
+project_finish(Finish) :-
+  aggregate_max(Finishtime, Task, finish_time(Task, Finishtime), Finish, _lasttask).
+
+final_task(Task) :-
+  project_finish(Finish),
+  finish_time(Task, Finish).
+
+critical_chain(Task, Task).
+critical_chain(Task, Pred) :-
+  critical_predecessor(Task, Parent),
+  critical_chain(Parent, Pred).
+
+critical_task(Task) :-
+  final_task(Final),
+  critical_chain(Final, Task).
+
+critical_path_answer(project_finish, Finish) :- project_finish(Finish).
+critical_path_answer(critical_task, Task) :- critical_task(Task).
+critical_path_answer(schedule, task(Task, Start, Finish)) :-
+  task(Task, _duration),
+  earliest_start(Task, Start),
+  finish_time(Task, Finish).

package/examples/cyclic-path.pl

@@ -0,0 +1,18 @@
+% Cyclic transitive closure.
+%
+% The graph deliberately contains the directed cycle a -> b -> c -> d -> a.  The
+% recursive path/2 rule therefore has to deal with cycles while still deriving
+% the reachable pairs used by the golden output.
+%
+% This is a compact regression-style example for active-goal handling in recursive
+% graph search.
+
+materialize(path, 2).
+
+arc(a, b).
+arc(b, c).
+arc(c, d).
+arc(d, a).
+
+path(X, Y) :- arc(X, Y).
+path(X, Z) :- arc(X, Y), path(Y, Z).

package/examples/d3-group.pl

@@ -0,0 +1,99 @@
+% Eyelet-inspired D3 group example using findall/3 and sort/2.
+% The six facts are the symmetries of an equilateral triangle, with compose/3 as
+% the Cayley table and inverse/2 as the inverse relation.  Candidate subsets are
+% generated as subsequences, then filtered for subgroup closure.
+
+materialize(subgroups, 2).
+materialize(subgroupCount, 2).
+materialize(reason, 2).
+
+% Six symmetries of an equilateral triangle: identity, rotations, reflections.
+symmetry(identity).
+symmetry(rotation_120).
+symmetry(rotation_240).
+symmetry(reflection_a).
+symmetry(reflection_b).
+symmetry(reflection_c).
+
+% Cayley table for D3 composition.
+compose(identity, identity, identity).
+compose(identity, rotation_120, rotation_120).
+compose(identity, rotation_240, rotation_240).
+compose(identity, reflection_a, reflection_a).
+compose(identity, reflection_b, reflection_b).
+compose(identity, reflection_c, reflection_c).
+compose(rotation_120, identity, rotation_120).
+compose(rotation_120, rotation_120, rotation_240).
+compose(rotation_120, rotation_240, identity).
+compose(rotation_120, reflection_a, reflection_b).
+compose(rotation_120, reflection_b, reflection_c).
+compose(rotation_120, reflection_c, reflection_a).
+compose(rotation_240, identity, rotation_240).
+compose(rotation_240, rotation_120, identity).
+compose(rotation_240, rotation_240, rotation_120).
+compose(rotation_240, reflection_a, reflection_c).
+compose(rotation_240, reflection_b, reflection_a).
+compose(rotation_240, reflection_c, reflection_b).
+compose(reflection_a, identity, reflection_a).
+compose(reflection_a, rotation_120, reflection_c).
+compose(reflection_a, rotation_240, reflection_b).
+compose(reflection_a, reflection_a, identity).
+compose(reflection_a, reflection_b, rotation_240).
+compose(reflection_a, reflection_c, rotation_120).
+compose(reflection_b, identity, reflection_b).
+compose(reflection_b, rotation_120, reflection_a).
+compose(reflection_b, rotation_240, reflection_c).
+compose(reflection_b, reflection_a, rotation_120).
+compose(reflection_b, reflection_b, identity).
+compose(reflection_b, reflection_c, rotation_240).
+compose(reflection_c, identity, reflection_c).
+compose(reflection_c, rotation_120, reflection_b).
+compose(reflection_c, rotation_240, reflection_a).
+compose(reflection_c, reflection_a, rotation_240).
+compose(reflection_c, reflection_b, rotation_120).
+compose(reflection_c, reflection_c, identity).
+% Each candidate subgroup must also contain inverses.
+inverse(identity, identity).
+inverse(rotation_120, rotation_240).
+inverse(rotation_240, rotation_120).
+inverse(reflection_a, reflection_a).
+inverse(reflection_b, reflection_b).
+inverse(reflection_c, reflection_c).
+
+% Candidate subsets are generated as subsequences of the sorted symmetry list.
+subsequence([], []).
+subsequence([Head | Tail], [Head | Rest]) :-
+  subsequence(Tail, Rest).
+subsequence([_head | Tail], Rest) :-
+  subsequence(Tail, Rest).
+
+all_symmetries(Symmetries) :-
+  findall(X, symmetry(X), Raw),
+  sort(Raw, Symmetries).
+
+% A valid subgroup is closed under both composition and inverse.
+closed_under_composition(Group) :-
+  not((member(X, Group), member(Y, Group), compose(X, Y, Z), not(member(Z, Group)))).
+
+closed_under_inverse(Group) :-
+  not((member(X, Group), inverse(X, Y), not(member(Y, Group)))).
+
+valid_group(Group) :-
+  all_symmetries(All),
+  subsequence(All, Group),
+  member(identity, Group),
+  closed_under_composition(Group),
+  closed_under_inverse(Group).
+
+all_subgroups(Groups) :-
+  findall(G, valid_group(G), Raw),
+  sort(Raw, Groups).
+
+subgroups(d3_group, Groups) :-
+  all_subgroups(Groups).
+
+subgroupCount(d3_group, Count) :-
+  all_subgroups(Groups),
+  length(Groups, Count).
+
+reason(d3_group, "findall enumerates candidate subgroups and sort gives canonical subgroup order").