seam-lang 2.0.0

package/examples/flandor.pl

@@ -0,0 +1,296 @@
+% Flandor insight-economy case adapted from Eyeling flandor.n3.
+% The original N3 renders a Markdown ARC report.  This seam translation keeps
+% the neutral insight, policy envelope, authorization, package choice, and checks
+% as materialized relation output.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(caseName, 2).
+materialize(regionName, 2).
+materialize(metric, 2).
+materialize(activeNeedCount, 2).
+materialize(activeNeedThreshold, 2).
+materialize(recommendedPackageName, 2).
+materialize(budgetCapMEUR, 2).
+materialize(packageCostMEUR, 2).
+materialize(envelopeExpiresAt, 2).
+materialize(workerCoverage, 2).
+materialize(gridReliefMW, 2).
+materialize(outcome, 2).
+materialize(target, 2).
+materialize(reason, 2).
+materialize(alg, 2).
+materialize(payloadHashSHA256, 2).
+materialize(signatureHMAC, 2).
+materialize(auditEntries, 2).
+materialize(filesWritten, 2).
+materialize(allChecksPass, 2).
+materialize(exportWeakness, 2).
+materialize(skillsStrain, 2).
+materialize(gridStress, 2).
+materialize(needsRetoolingPulse, 2).
+materialize(derivedFromNeed, 2).
+materialize(signatureVerifies, 2).
+materialize(payloadHashMatches, 2).
+materialize(hmacMatches, 2).
+materialize(minimizationStripsSensitiveTerms, 2).
+materialize(scopeComplete, 2).
+materialize(authorizationAllowed, 2).
+materialize(thresholdReached, 2).
+materialize(packageWithinBudget, 2).
+materialize(packageCoversAllNeeds, 2).
+materialize(dutyTimingConsistent, 2).
+materialize(surveillanceReuseProhibited, 2).
+materialize(filesWrittenExpected, 2).
+materialize(lowestCostEligiblePackageChosen, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Case metadata describes the request, audit window, and expected file writes.
+case_name(case, "flandor").
+question(case, "Is the Flemish Economic Resilience Board allowed to use a neutral macro-economic insight for regional stabilization, and if so which package should it activate for Flanders?").
+expectedFilesWritten(case, 6).
+requestPurpose(case, "regional_stabilization").
+requestAction(case, odrlUse).
+hubCreatedAt(case, "2026-04-08T07:00:00+00:00").
+hubExpiresAt(case, "2026-04-08T19:00:00+00:00").
+boardAuthAt(case, "2026-04-08T09:15:00+00:00").
+boardDutyAt(case, "2026-04-08T18:30:00+00:00").
+files_written(case, 6).
+audit_entries(case, 1).
+
+region_name(flanders, "Flanders").
+observedFirms(signals, 217).
+aggregationLevel(signals, "regional_cluster").
+containsFirmNames(signals, false).
+containsPayrollRows(signals, false).
+
+% Signals are intentionally aggregated: no firm names or payroll rows are present.
+industrialCluster(clusterAntwerp).
+clusterName(clusterAntwerp, "Antwerp chemicals").
+exportOrdersIndex(clusterAntwerp, 84).
+energyIntensity(clusterAntwerp, 92).
+industrialCluster(clusterGhent).
+clusterName(clusterGhent, "Ghent manufacturing").
+exportOrdersIndex(clusterGhent, 87).
+energyIntensity(clusterGhent, 76).
+
+techVacancyRateTenths(labourMarket, 46).
+techVacancyRate(labourMarket, 4.6).
+congestionHours(grid, 19).
+renewableCurtailmentMWh(grid, 240).
+maxMEUR(budget, 140).
+windowName(budget, "Q2 resilience window").
+
+% Candidate packages expose cost and which active needs they cover.
+policyPackage(pkgTrainingOnly).
+packageId(pkgTrainingOnly, "pkg:TRAIN_070").
+packageName(pkgTrainingOnly, "Flanders Skills Sprint").
+costMEUR(pkgTrainingOnly, 70).
+worker_coverage(pkgTrainingOnly, 900).
+grid_relief_mw(pkgTrainingOnly, 0).
+coversSkillsStrain(pkgTrainingOnly, true).
+
+policyPackage(pkgLogisticsOnly).
+packageId(pkgLogisticsOnly, "pkg:PORT_095").
+packageName(pkgLogisticsOnly, "Schelde Trade Buffer").
+costMEUR(pkgLogisticsOnly, 95).
+worker_coverage(pkgLogisticsOnly, 300).
+grid_relief_mw(pkgLogisticsOnly, 10).
+coversExportWeakness(pkgLogisticsOnly, true).
+
+policyPackage(pkgFlandor).
+packageId(pkgFlandor, "pkg:RET_FLEX_120").
+packageName(pkgFlandor, "Flandor Retooling Pulse").
+costMEUR(pkgFlandor, 120).
+worker_coverage(pkgFlandor, 1200).
+grid_relief_mw(pkgFlandor, 85).
+coversExportWeakness(pkgFlandor, true).
+coversSkillsStrain(pkgFlandor, true).
+coversGridStress(pkgFlandor, true).
+
+policyPackage(pkgFullCorridor).
+packageId(pkgFullCorridor, "pkg:CORRIDOR_165").
+packageName(pkgFullCorridor, "Full Corridor Shock Shield").
+costMEUR(pkgFullCorridor, 165).
+worker_coverage(pkgFullCorridor, 1600).
+grid_relief_mw(pkgFullCorridor, 110).
+coversExportWeakness(pkgFullCorridor, true).
+coversSkillsStrain(pkgFullCorridor, true).
+coversGridStress(pkgFullCorridor, true).
+
+insight(macroInsight).
+id(macroInsight, "https://example.org/insight/flandor").
+insight_metric(macroInsight, "regional_retooling_priority").
+thresholdScore(macroInsight, 3).
+thresholdDisplay(macroInsight, "3 active needs").
+suggestionPolicy(macroInsight, "lowest_cost_package_covering_all_active_needs").
+scopeDevice(macroInsight, "economic-resilience-board").
+scopeEvent(macroInsight, "budget-prep-window").
+region(macroInsight, "Flanders").
+createdAt(macroInsight, "2026-04-08T07:00:00+00:00").
+expiresAt(macroInsight, "2026-04-08T19:00:00+00:00").
+serializedLowercase(macroInsight, "createdat expiresat insight metric regional_retooling_priority region flanders scopedevice economic-resilience-board scopeevent budget-prep-window suggestionpolicy lowest_cost_package_covering_all_active_needs threshold 3").
+
+envelopeInsight(envelope, macroInsight).
+envelopePolicy(envelope, policy).
+envelopeHash(envelope, "10a85e861075bef2a96c01c7f3238735f82b8f368deb62eafcedd1c4b7f7c707").
+permission(policy, odrlUse, macroInsight, "regional_stabilization").
+prohibition(policy, odrlDistribute, macroInsight, "firm_surveillance").
+duty(policy, odrlDelete, "2026-04-08T19:00:00+00:00").
+
+signature_alg(signature, "HMAC-SHA256").
+keyid(signature, "demo-shared-secret").
+created(signature, "2026-04-08T07:00:00+00:00").
+payload_hash_sha256(signature, "10a85e861075bef2a96c01c7f3238735f82b8f368deb62eafcedd1c4b7f7c707").
+display_payload_hash_sha256(signature, "718f5b17d07ab6a95503bc04a1000ddb132409f600659c03d21def81914b780b").
+signature_hmac(signature, "955968ca99a191783bc00cba068128ccb9ff40a5e6114fda13a52c74ee27329e").
+hmacVerificationMode(signature, trustedPrecomputedInput).
+
+reason_value(reasonText, "Secure aggregates from Flanders indicate simultaneous export weakness, technical labour scarcity, and grid congestion. A neutral macro insight is scoped to the economic-resilience board for one budget window only, enabling a temporary package without exposing firm-level books.").
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+caseName(Case, Name) :- case_name(Case, Name).
+regionName(Region, Name) :- region_name(Region, Name).
+metric(Insight, Metric) :- insight_metric(Insight, Metric).
+alg(Signature, Alg) :- signature_alg(Signature, Alg).
+payloadHashSHA256(Signature, Hash) :- display_payload_hash_sha256(Signature, Hash).
+signatureHMAC(Signature, Hmac) :- signature_hmac(Signature, Hmac).
+auditEntries(Case, Count) :- audit_entries(Case, Count).
+filesWritten(Case, Count) :- files_written(Case, Count).
+
+export_weakness(case) :-
+  industrialCluster(Cluster),
+  exportOrdersIndex(Cluster, Index),
+  lt(Index, 90).
+
+skills_strain(case) :-
+  techVacancyRateTenths(labourMarket, Rate),
+  gt(Rate, 39).
+
+grid_stress(case) :-
+  congestionHours(grid, Hours),
+  gt(Hours, 11).
+
+needs_retooling_pulse(case) :-
+  export_weakness(case),
+  skills_strain(case),
+  grid_stress(case).
+
+payload_hash_matches(check) :-
+  envelopeHash(envelope, Digest),
+  payload_hash_sha256(signature, Digest).
+
+signature_verifies(check) :- hmacVerificationMode(signature, trustedPrecomputedInput).
+hmac_matches(check) :-
+  hmacVerificationMode(signature, trustedPrecomputedInput),
+  signature_hmac(signature, "955968ca99a191783bc00cba068128ccb9ff40a5e6114fda13a52c74ee27329e").
+
+minimization_strips_sensitive_terms(check) :-
+  serializedLowercase(macroInsight, Text),
+  not_matches(Text, "salary|payroll|invoice|medical|firmname").
+
+scope_complete(check) :-
+  scopeDevice(macroInsight, _device),
+  scopeEvent(macroInsight, _event),
+  expiresAt(macroInsight, _expiry).
+
+% Authorization combines policy scope, envelope timing, and use permission.
+authorization_allowed(check) :-
+  permission(policy, odrlUse, macroInsight, "regional_stabilization"),
+  boardAuthAt(case, Authat),
+  expiresAt(macroInsight, Expiresat),
+  le(Authat, Expiresat).
+
+decision(decision, "Allowed", macroInsight) :- authorization_allowed(check).
+
+% An eligible package must cover every active need and fit under the budget cap.
+eligible_package(Pkg) :-
+  needs_retooling_pulse(case),
+  maxMEUR(budget, Max),
+  policyPackage(Pkg),
+  costMEUR(Pkg, Cost),
+  coversExportWeakness(Pkg, true),
+  coversSkillsStrain(Pkg, true),
+  coversGridStress(Pkg, true),
+  le(Cost, Max).
+
+lower_cost_eligible_package(Cost) :-
+  eligible_package(Other),
+  costMEUR(Other, Othercost),
+  lt(Othercost, Cost).
+
+% The recommendation is the lowest-cost eligible package.
+recommended_package(case, Pkg) :-
+  eligible_package(Pkg),
+  costMEUR(Pkg, Cost),
+  not(lower_cost_eligible_package(Cost)).
+
+package_within_budget(check) :-
+  recommended_package(case, Pkg),
+  costMEUR(Pkg, Cost),
+  maxMEUR(budget, Max),
+  le(Cost, Max).
+
+package_covers_all_needs(check) :-
+  recommended_package(case, Pkg),
+  coversExportWeakness(Pkg, true),
+  coversSkillsStrain(Pkg, true),
+  coversGridStress(Pkg, true).
+
+duty_timing_consistent(check) :-
+  boardDutyAt(case, Dutyat),
+  expiresAt(macroInsight, Expiresat),
+  le(Dutyat, Expiresat).
+
+surveillance_reuse_prohibited(check) :- prohibition(policy, odrlDistribute, macroInsight, "firm_surveillance").
+files_written_expected(check) :- files_written(case, 6).
+threshold_reached(check) :- export_weakness(case), skills_strain(case), grid_stress(case).
+lowest_cost_eligible_package_chosen(check) :- recommended_package(case, _pkg).
+
+all_checks_pass(result) :-
+  signature_verifies(check),
+  payload_hash_matches(check),
+  minimization_strips_sensitive_terms(check),
+  scope_complete(check),
+  authorization_allowed(check),
+  package_within_budget(check),
+  package_covers_all_needs(check),
+  duty_timing_consistent(check),
+  surveillance_reuse_prohibited(check),
+  files_written_expected(check).
+
+exportWeakness(case, true) :- export_weakness(case).
+skillsStrain(case, true) :- skills_strain(case).
+gridStress(case, true) :- grid_stress(case).
+needsRetoolingPulse(case, true) :- needs_retooling_pulse(case).
+derivedFromNeed(case, "regional_retooling_and_flexibility") :- needs_retooling_pulse(case).
+activeNeedCount(answer, 3) :- threshold_reached(check).
+activeNeedThreshold(answer, 3) :- thresholdScore(macroInsight, 3).
+recommendedPackageName(answer, Name) :- recommended_package(case, Pkg), packageName(Pkg, Name).
+budgetCapMEUR(answer, Max) :- maxMEUR(budget, Max).
+packageCostMEUR(answer, Cost) :- recommended_package(case, Pkg), costMEUR(Pkg, Cost).
+envelopeExpiresAt(answer, Time) :- expiresAt(macroInsight, Time).
+workerCoverage(why, Workers) :- recommended_package(case, Pkg), worker_coverage(Pkg, Workers).
+gridReliefMW(why, Mw) :- recommended_package(case, Pkg), grid_relief_mw(Pkg, Mw).
+outcome(decision, Outcome) :- decision(decision, Outcome, _target).
+target(decision, Target) :- decision(decision, _outcome, Target).
+allChecksPass(result, true) :- all_checks_pass(result).
+signatureVerifies(check, true) :- signature_verifies(check).
+payloadHashMatches(check, true) :- payload_hash_matches(check).
+hmacMatches(check, true) :- hmac_matches(check).
+minimizationStripsSensitiveTerms(check, true) :- minimization_strips_sensitive_terms(check).
+scopeComplete(check, true) :- scope_complete(check).
+authorizationAllowed(check, true) :- authorization_allowed(check).
+thresholdReached(check, true) :- threshold_reached(check).
+packageWithinBudget(check, true) :- package_within_budget(check).
+packageCoversAllNeeds(check, true) :- package_covers_all_needs(check).
+dutyTimingConsistent(check, true) :- duty_timing_consistent(check).
+surveillanceReuseProhibited(check, true) :- surveillance_reuse_prohibited(check).
+filesWrittenExpected(check, true) :- files_written_expected(check).
+lowestCostEligiblePackageChosen(check, true) :- lowest_cost_eligible_package_chosen(check).
+
+reason(whyExportWeakness, "Export weakness is active because at least one cluster has exportOrdersIndex < 90 (Antwerp chemicals=84, Ghent manufacturing=87).") :- export_weakness(case).
+reason(whySkillsStrain, "Skills strain is active because technical vacancy rate is 4.6% (threshold > 3.9%).") :- skills_strain(case).
+reason(whyGridStress, "Grid stress is active because congestion hours = 19 (threshold > 11).") :- grid_stress(case).
+reason(whyRecommendationPolicy, "The recommendation policy is \"lowest_cost_package_covering_all_active_needs\", so the cheapest package that covers all active needs within budget is selected.") :- recommended_package(case, _pkg).
+reason(whySelectedPackage, "Selected package \"Flandor Retooling Pulse\" covers export=true, skills=true, grid=true, cost=€120M.") :- recommended_package(case, pkgFlandor).
+reason(whyUsage, "Usage is permitted only for purpose \"regional_stabilization\" and the envelope expires at 2026-04-08T19:00:00+00:00.") :- authorization_allowed(check).

package/examples/floating-point.pl

@@ -0,0 +1,28 @@
+% Floating-point arithmetic and comparisons.
+%
+% Integer-only arithmetic stays exact, but decimal inputs use JavaScript numbers.
+% This example keeps the calculations small and transparent so differences between
+% add/sub/mul/div/pow and comparison predicates are visible.
+%
+% The thermostat facts provide a concrete comparison setting, while standalone
+% value/2 reports exercise individual decimal operations.
+materialize(value, 2).
+materialize(than, 2).
+
+% Sample facts provide a small thermostat scenario used by the comparison
+% rules; separate value/2 facts below exercise standalone decimal arithmetic.
+sample(roomC, 21.5).
+sample(targetC, 19.25).
+
+% Each value/2 fact is a small arithmetic check; than/2 and comfortable/2
+% show that comparisons work over decimal results too.
+value(sum, X) :- add(1.5, 2.25, X).
+value(difference, X) :- sub(10.0, 3.125, X).
+value(product, X) :- mul(2.5, 4.0, X).
+value(quotient, X) :- div(7.5, 2, X).
+value(sqrtByPower, X) :- pow(9.0, 0.5, X).
+value(mathSum, X) :- add(0.125, 0.875, X).
+value(mathProduct, X) :- mul(6.0, 0.5, X).
+than(warmer, targetC) :- sample(roomC, R), sample(targetC, T), gt(R, T).
+% Boolean-like conclusions remain ordinary atoms.
+value(comfortable, true) :- sample(roomC, R), ge(R, 21.0), le(R, 22.0).

package/examples/four-color-map.pl

@@ -0,0 +1,133 @@
+% EYE reasoning-inspired example: four-colour map check for the European Union.
+%
+% The source EYE example encodes the EU neighbourhood map and an answer assigning
+% four colours. This seam version keeps the same map/assignment shape and adds
+% a rule-level validation layer that rejects equal colours across borders.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+%
+% The countries form a small planar-style adjacency graph. The example is a
+% constraint problem: assign colours, reject border conflicts, then materialize
+% the canonical colour vector and validation status.
+materialize(color, 2).
+materialize(status, 2).
+materialize(reason, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+country(belgium). country(netherlands). country(luxemburg). country(france).
+country(germany). country(italy). country(denmark). country(ireland).
+country(greece). country(spain). country(portugal). country(austria).
+country(sweden). country(finland). country(cyprus). country(malta).
+country(poland). country(hungary). country(czech_republic). country(slovakia).
+country(slovenia). country(estonia). country(latvia). country(lithuania).
+country(bulgaria). country(romania). country(croatia).
+
+% Undirected borders represented once.
+border(belgium, france). border(belgium, netherlands). border(belgium, luxemburg). border(belgium, germany).
+border(netherlands, germany).
+border(luxemburg, france). border(luxemburg, germany).
+border(france, spain). border(france, germany). border(france, italy).
+border(germany, denmark). border(germany, austria). border(germany, poland). border(germany, czech_republic).
+border(italy, austria). border(italy, slovenia).
+border(greece, bulgaria).
+border(spain, portugal).
+border(austria, czech_republic). border(austria, hungary). border(austria, slovenia). border(austria, slovakia).
+border(sweden, finland).
+border(poland, czech_republic). border(poland, slovakia). border(poland, lithuania).
+border(hungary, slovakia). border(hungary, romania). border(hungary, croatia). border(hungary, slovenia).
+border(czech_republic, slovakia).
+border(slovakia, austria).
+border(slovenia, croatia).
+border(estonia, latvia).
+border(latvia, lithuania).
+border(bulgaria, romania).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+adjacent(A, B) :- border(A, B).
+adjacent(A, B) :- border(B, A).
+
+color(red). color(green). color(blue). color(yellow).
+
+assigned(belgium, yellow).
+assigned(netherlands, green).
+assigned(luxemburg, green).
+assigned(france, blue).
+assigned(germany, red).
+assigned(italy, red).
+assigned(denmark, green).
+assigned(ireland, red).
+assigned(greece, red).
+assigned(spain, green).
+assigned(portugal, red).
+assigned(austria, yellow).
+assigned(sweden, green).
+assigned(finland, red).
+assigned(cyprus, red).
+assigned(malta, red).
+assigned(poland, blue).
+assigned(hungary, blue).
+assigned(czech_republic, green).
+assigned(slovakia, red).
+assigned(slovenia, green).
+assigned(estonia, red).
+assigned(latvia, green).
+assigned(lithuania, red).
+assigned(bulgaria, green).
+assigned(romania, red).
+assigned(croatia, red).
+
+% valid_assignment/1 checks that one country has an assigned colour from the palette.
+valid_assignment(Country) :-
+  country(Country),
+  assigned(Country, Colour),
+  color(Colour).
+
+% bad_border/3 is the only forbidden pattern: adjacent countries sharing a colour.
+bad_border(A, B, Colour) :-
+  border(A, B),
+  assigned(A, Colour),
+  assigned(B, Colour).
+
+border_colours_differ(A, B) :-
+  border(A, B),
+  assigned(A, Coloura),
+  assigned(B, Colourb),
+  neq(Coloura, Colourb).
+
+country_count(27).
+border_count(36).
+
+all_countries_coloured(map_eu) :-
+  findall(Country, valid_assignment(Country), Countries),
+  sort(Countries, Uniquecountries),
+  length(Uniquecountries, Count),
+  country_count(Count).
+
+all_borders_checked(map_eu) :-
+  findall([A, B], border_colours_differ(A, B), Borders),
+  sort(Borders, Uniqueborders),
+  length(Uniqueborders, Count),
+  border_count(Count).
+
+map_valid(map_eu) :-
+  all_countries_coloured(map_eu),
+  all_borders_checked(map_eu).
+
+colouring([
+  [belgium, yellow], [netherlands, green], [luxemburg, green], [france, blue],
+  [germany, red], [italy, red], [denmark, green], [ireland, red], [greece, red],
+  [spain, green], [portugal, red], [austria, yellow], [sweden, green], [finland, red],
+  [cyprus, red], [malta, red], [poland, blue], [hungary, blue], [czech_republic, green],
+  [slovakia, red], [slovenia, green], [estonia, red], [latvia, green], [lithuania, red],
+  [bulgaria, green], [romania, red], [croatia, red]
+]).
+
+color(map_eu, Colours) :-
+  map_valid(map_eu),
+  colouring(Colours).
+
+status(map_eu, valid_four_colour_assignment) :-
+  map_valid(map_eu).
+
+reason(map_eu, "no neighbouring countries share a colour") :-
+  map_valid(map_eu).

package/examples/fundamental-theorem-arithmetic.pl

@@ -0,0 +1,119 @@
+% Adapted from Eyeling's fundamental-theorem-arithmetic.n3.
+% Compute a prime factorization by repeated smallest-divisor decomposition,
+% then check product reconstruction and primality of the distinct factors.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+%
+% The goal is not to be a production factorizer; it is a readable encoding of
+% divisibility, primality, two factorization strategies, and agreement between
+% normalized factor lists.
+materialize(n, 2).
+materialize(factorsSmallest, 2).
+materialize(factorsLargest, 2).
+materialize(product, 2).
+materialize(expectedFactorsMatched, 2).
+materialize(productReconstructsInput, 2).
+materialize(distinctPrimeCount, 2).
+materialize(smallestPrimeFactor, 2).
+materialize(largestPrimeFactor, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+case(fta, 202692987).
+expected_factors(fta, [3, 3, 7, 829, 3881]).
+
+% A divides B in positive integers.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+divides(A, B) :-
+  gt(A, 0),
+  gt(B, 0),
+  mod(B, A, 0).
+
+smallest_divisor_from(N, D, D) :-
+  divides(D, N).
+
+smallest_divisor_from(N, D, N) :-
+  mul(D, D, D2),
+  gt(D2, N).
+
+smallest_divisor_from(N, D, S) :-
+  not(divides(D, N)),
+  mul(D, D, D2),
+  le(D2, N),
+  add(D, 1, D1),
+  smallest_divisor_from(N, D1, S).
+
+trial_prime(2).
+trial_prime(3).
+% trial_prime/1 is the bounded primality test used by the factorization rules.
+trial_prime(P) :-
+  gt(P, 3),
+  smallest_divisor_from(P, 2, P).
+
+factor_smallest(N, []) :-
+  lt(N, 2).
+
+factor_smallest(N, [N]) :-
+  ge(N, 2),
+  smallest_divisor_from(N, 2, N).
+
+% factor_smallest/2 repeatedly removes the least divisor, producing ascending factors.
+factor_smallest(N, Factors) :-
+  ge(N, 2),
+  smallest_divisor_from(N, 2, D),
+  neq(D, N),
+  div(N, D, Q),
+  factor_smallest(D, Left),
+  factor_smallest(Q, Right),
+  append(Left, Right, Factors).
+
+factor_largest(N, Factors) :-
+  factor_smallest(N, Smallest),
+  reverse(Smallest, Factors).
+
+product([], 1).
+product([X|Rest], P) :-
+  product(Rest, P0),
+  mul(X, P0, P).
+
+all_expected_primes(true) :-
+  trial_prime(3),
+  trial_prime(7),
+  trial_prime(829),
+  trial_prime(3881).
+
+n(case, N) :-
+  case(fta, N).
+
+factorsSmallest(case, Factors) :-
+  case(fta, N),
+  factor_smallest(N, Factors).
+
+factorsLargest(case, Factors) :-
+  case(fta, N),
+  factor_largest(N, Factors).
+
+product(case, Product) :-
+  case(fta, N),
+  factor_smallest(N, Factors),
+  product(Factors, Product).
+
+expectedFactorsMatched(case, true) :-
+  case(fta, N),
+  expected_factors(fta, Factors),
+  factor_smallest(N, Factors).
+
+productReconstructsInput(case, true) :-
+  case(fta, N),
+  factor_smallest(N, Factors),
+  product(Factors, N).
+
+distinctPrimeCount(case, 4) :-
+  all_expected_primes(true).
+
+smallestPrimeFactor(case, 3) :-
+  case(fta, N),
+  factor_smallest(N, [3|_]).
+
+largestPrimeFactor(case, 3881) :-
+  case(fta, N),
+  factor_largest(N, [3881|_]).