eyeling 1.32.1 → 1.33.1

package/examples/eyelang/socket-age.pl

@@ -0,0 +1,39 @@
+% socket-age.pl
+%
+% 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.pl
+
+% 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/eyelang/socket-family.pl

@@ -0,0 +1,28 @@
+% socket-family.pl
+%
+% 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.pl
+
+% 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/eyelang/socrates.n3

@@ -0,0 +1,11 @@
+# Adapted from eyereasoner/eyeling examples/socrates.n3.
+# Demonstrates a small RDFS-style subclass rule in the RDF/N3 reader.
+PREFIX : <http://example.org/socrates#>
+PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+
+:Socrates a :Human .
+:Human rdfs:subClassOf :Mortal .
+
+{ ?S a ?A . ?A rdfs:subClassOf ?B . }
+=>
+{ ?S a ?B . } .

package/examples/eyelang/socrates.pl

@@ -0,0 +1,19 @@
+% Socrates is mortal, adapted from Eyelet's input/socrates.pl.
+%
+% 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/eyelang/statistics-summary.pl

@@ -0,0 +1,54 @@
+% 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).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+sample(scores, [2.0, 4.0, 4.0, 4.0, 5.0, 5.0, 7.0, 9.0]).
+
+sum([], 0.0).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+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/eyelang/sudoku.pl

@@ -0,0 +1,20 @@
+% Generic 9x9 Sudoku example using the compiled sudoku/2 builtin.
+%
+% Puzzles are 81-character strings read row-major. Digits 1..9 are givens;
+% 0, dot, or underscore marks a blank. The builtin also accepts a 9x9 list
+% of integers in the same representation.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(solution, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+puzzle(classic,
+  "100007090030129008009600500005300900010080002600794000350408219240005867897201304").
+
+puzzle(third,
+  "078200000005000400100400092000035070007000500050810000720004008009000300000006910").
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+solution(Name, Rows) :-
+  puzzle(Name, Grid),
+  sudoku(Grid, Rows).

package/examples/eyelang/superdense-coding.pl

@@ -0,0 +1,84 @@
+% Superdense coding using discrete quantum computing, adapted from
+% Eyelet's input/superdense-coding.pl.
+%
+% 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)).

package/examples/eyelang/traveling-salesman.pl

@@ -0,0 +1,64 @@
+% Traveling salesman problem, adapted from Eyelet input/traveling-salesman.pl.
+% The optimal tour matches Eyelet output-swipl/traveling-salesman.pl.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(optimalTour, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% The target list fixes the city set; weighted_hamiltonian_path/4 searches tours.
+target_cities([aaa, bbb, ccc, ddd, eee, fff, ggg]).
+
+distance(aaa, bbb, 10).
+distance(aaa, ccc, 15).
+distance(aaa, ddd, 20).
+distance(aaa, eee, 25).
+distance(aaa, fff, 30).
+distance(bbb, ccc, 35).
+distance(bbb, ddd, 40).
+distance(bbb, eee, 20).
+distance(bbb, fff, 25).
+distance(ccc, ddd, 30).
+distance(ccc, eee, 15).
+distance(ccc, fff, 10).
+distance(ddd, eee, 10).
+distance(ddd, fff, 35).
+distance(ddd, ggg, 5).
+distance(eee, fff, 20).
+
+% Distances are stored once; distance2/3 makes the graph undirected.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+distance2(A, B, D) :-
+  distance(A, B, D).
+distance2(A, B, D) :-
+  distance(B, A, D).
+
+permutation([], []).
+permutation(List, [X|Perm]) :-
+  select(X, List, Rest),
+  permutation(Rest, Perm).
+
+total_distance([_Last], 0).
+total_distance([X, Y|Tail], D) :-
+  distance2(X, Y, D1),
+  total_distance([Y|Tail], D2),
+  add(D1, D2, D).
+
+tsp(Cities, Tour, Distance) :-
+  weighted_hamiltonian_path(distance, Cities, Tour, Distance).
+
+% Materialized output keeps only the minimum-distance candidate.
+optimalTour(Cities, Optimal) :-
+  target_cities(Cities),
+  findall([T, D], tsp(Cities, T, D), Solutions),
+  min_distance(Solutions, Optimal).
+
+min_distance([Sol|Sols], Optimal) :-
+  min_distance_acc(Sols, Sol, Optimal).
+
+min_distance_acc([], Best, Best).
+min_distance_acc([[_T, D]|Rest], [_BestTour, BestDistance], Optimal) :-
+  lt(D, BestDistance),
+  min_distance_acc(Rest, [_T, D], Optimal).
+min_distance_acc([[_T, D]|Rest], [BestTour, BestDistance], Optimal) :-
+  ge(D, BestDistance),
+  min_distance_acc(Rest, [BestTour, BestDistance], Optimal).

package/examples/eyelang/triple-term.n3

@@ -0,0 +1,9 @@
+# RDF 1.2 triple term example for the eyelang compatibility layer.
+PREFIX : <http://example.org/triple-term#>
+
+:alice :says <<( :bob :knows :carol )>> .
+
+{ ?Reporter :says <<( ?Knower :knows ?Known )>> . }
+=>
+{ ?Reporter :reportedKnower ?Knower .
+  ?Reporter :reportedKnown ?Known . } .

package/examples/eyelang/turing.pl

@@ -0,0 +1,67 @@
+% Universal Turing machine example adapted from Eyelet's input/turing.pl.
+%
+% The machine below adds 1 to a binary number represented as a list of bits.
+% The blank tape symbol is #.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(input, 2).
+materialize(output, 2).
+materialize(addsOne, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+compute([], OutTape) :-
+  start(_Machine, I),
+  find(I, [], #, [], OutTape).
+
+compute([Head|Tail], OutTape) :-
+  start(_Machine, I),
+  find(I, [], Head, Tail, OutTape).
+
+find(State, Left, Cell, Right, OutTape) :-
+  t([State, Cell, Write, Move], Next),
+  move(Move, Left, Write, Right, A, B, C),
+  continue(Next, A, B, C, OutTape).
+
+continue(halt, Left, Cell, Right, OutTape) :-
+  rever(Left, R),
+  append(R, [Cell|Right], OutTape).
+
+continue(State, Left, Cell, Right, OutTape) :-
+  find(State, Left, Cell, Right, OutTape).
+
+move(l, [], Cell, Right, [], #, [Cell|Right]).
+move(l, [Head|Tail], Cell, Right, Tail, Head, [Cell|Right]).
+move(s, Left, Cell, Right, Left, Cell, Right).
+move(r, Left, Cell, [], [Cell|Left], #, []).
+move(r, Left, Cell, [Head|Tail], [Cell|Left], Head, Tail).
+
+rever([], []).
+rever([A|B], C) :-
+  rever(B, D),
+  append(D, [A], C).
+
+% A Turing machine to add 1 to a binary number.
+start(add1, 0).
+t([0, 0, 0, r], 0).
+t([0, 1, 1, r], 0).
+t([0, #, #, l], 1).
+t([1, 0, 1, s], halt).
+t([1, 1, 0, l], 1).
+t([1, #, 1, s], halt).
+
+case(case1, [1, 0, 1, 0, 0, 1]).
+case(case2, [1, 0, 1, 1, 1, 1]).
+case(case3, [1, 1, 1, 1, 1, 1]).
+case(case4, []).
+
+input(Case, InTape) :-
+  case(Case, InTape).
+
+output(Case, OutTape) :-
+  case(Case, InTape),
+  compute(InTape, OutTape).
+
+addsOne(Case, true) :-
+  case(Case, InTape),
+  compute(InTape, _OutTape).

package/examples/eyelang/vector-similarity.pl

@@ -0,0 +1,56 @@
+% Vector dot product, Euclidean norm, and cosine similarity.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(dotProduct, 2).
+materialize(normA, 2).
+materialize(normB, 2).
+materialize(cosineSimilarity, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Two named vectors form the single cosine-similarity case.
+vector(pair1, a, [1.0, 2.0, 3.0]).
+vector(pair1, b, [4.0, -5.0, 6.0]).
+
+% Recursive list folds compute dot products and sums of squares.
+dot([], [], 0.0).
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+dot([A|As], [B|Bs], Dot) :-
+  mul(A, B, Product),
+  dot(As, Bs, Rest),
+  add(Product, Rest, Dot).
+
+sum_squares([], 0.0).
+sum_squares([X|Xs], Total) :-
+  pow(X, 2.0, Squared),
+  sum_squares(Xs, Rest),
+  add(Squared, Rest, Total).
+
+norm(Vector, Norm) :-
+  sum_squares(Vector, SumSquares),
+  pow(SumSquares, 0.5, Norm).
+
+% cosine = dot(A,B) / (norm(A) * norm(B)).
+cosine_similarity(Case, Similarity) :-
+  vector(Case, a, A),
+  vector(Case, b, B),
+  dot(A, B, Dot),
+  norm(A, NormA),
+  norm(B, NormB),
+  mul(NormA, NormB, Denominator),
+  div(Dot, Denominator, Similarity).
+
+dotProduct(Case, Dot) :-
+  vector(Case, a, A),
+  vector(Case, b, B),
+  dot(A, B, Dot).
+
+normA(Case, NormA) :-
+  vector(Case, a, A),
+  norm(A, NormA).
+
+normB(Case, NormB) :-
+  vector(Case, b, B),
+  norm(B, NormB).
+
+cosineSimilarity(Case, Similarity) :-
+  cosine_similarity(Case, Similarity).

package/examples/eyelang/witch.pl

@@ -0,0 +1,38 @@
+% Burn the witch, adapted from Eyeling's examples/witch.n3.
+%
+% This is the classic N3/Semantic Web rule chain in eyelang form: a duck
+% floats; something with the same weight as something that floats also floats;
+% things that float are made of wood; things made of wood burn; and a woman
+% who burns is a witch.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(floats, 1).
+materialize(madeOfWood, 1).
+materialize(burns, 1).
+materialize(witch, 1).
+materialize(is, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+witch(X) :-
+  burns(X),
+  woman(X).
+
+woman(girl).
+
+burns(X) :-
+  madeOfWood(X).
+
+madeOfWood(X) :-
+  floats(X).
+
+floats(duck).
+
+floats(Y) :-
+  sameWeight(X, Y),
+  floats(X).
+
+sameWeight(duck, girl).
+
+is(witchExample, true) :-
+  witch(girl).

package/examples/eyelang/wolf-goat-cabbage.pl

@@ -0,0 +1,56 @@
+% Wolf, goat and cabbage puzzle, adapted from Eyelet's
+% input/wolf-goat-cabbage.pl.
+%
+% A configuration is [man, wolf, goat, cabbage], where each item is on the west
+% bank w or east bank e.  The recursive search keeps a visited list so eyelang
+% explores the finite state space without looping.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(solution, 2).
+materialize(solved, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+memoize(solve, 4).
+
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+solution(Moves) :-
+  solve([w, w, w, w], [e, e, e, e], [[w, w, w, w]], Moves),
+  length(Moves, 7).
+
+solve(Config, Config, _Visited, []).
+
+solve(Config, Goal, Visited, [Move|Rest]) :-
+  move(Config, Move, NextConfig),
+  safe(NextConfig),
+  not_member(NextConfig, Visited),
+  solve(NextConfig, Goal, [NextConfig|Visited], Rest).
+
+% Each move transforms one configuration into another.
+move([X, X, Goat, Cabbage], wolf, [Y, Y, Goat, Cabbage]) :-
+  change(X, Y).
+
+move([X, Wolf, X, Cabbage], goat, [Y, Wolf, Y, Cabbage]) :-
+  change(X, Y).
+
+move([X, Wolf, Goat, X], cabbage, [Y, Wolf, Goat, Y]) :-
+  change(X, Y).
+
+move([X, Wolf, Goat, Cabbage], nothing, [Y, Wolf, Goat, Cabbage]) :-
+  change(X, Y).
+
+change(e, w).
+change(w, e).
+
+% Safe if the goat is not left alone with the wolf or cabbage without the man.
+safe([Man, Wolf, Goat, Cabbage]) :-
+  one_eq(Man, Goat, Wolf),
+  one_eq(Man, Goat, Cabbage).
+
+one_eq(X, X, _).
+one_eq(X, _, X).
+
+solution(puzzle, Moves) :-
+  solution(Moves).
+
+solved(puzzle, true) :-
+  solution(_Moves).

package/examples/eyelang/zebra.pl

@@ -0,0 +1,44 @@
+% Zebra puzzle, adapted from Eyelet's input/zebra.pl.
+%
+% Five houses are represented as house(Color, Nationality, Pet, Beverage,
+% Cigarette).  The answer is the classic one: the Norwegian drinks water and the
+% Japanese owns the zebra.
+
+% Output declarations: materialize/2 selects the relations written to this example's golden output.
+materialize(waterDrinker, 2).
+materialize(zebraOwner, 2).
+materialize(solved, 2).
+
+% Program structure: facts set up the scenario, and rules derive the materialized conclusions.
+% Derivation rules: each rule below contributes one logical step toward the displayed results.
+zebra(WaterDrinker, ZebraOwner) :-
+  eq(Houses, [_, _, _, _, _]),
+  first(Houses, house(_, norwegian, _, _, _)),
+  third(Houses, house(_, _, _, milk, _)),
+  adjacent(house(_, norwegian, _, _, _), house(blue, _, _, _, _), Houses),
+  next_to(house(ivory, _, _, _, _), house(green, _, _, _, _), Houses),
+  member(house(red, english, _, _, _), Houses),
+  member(house(green, _, _, coffee, _), Houses),
+  member(house(yellow, _, _, _, kools), Houses),
+  member(house(_, spanish, dog, _, _), Houses),
+  member(house(_, ukrainian, _, tea, _), Houses),
+  member(house(_, _, snail, _, old_gold), Houses),
+  adjacent(house(_, _, _, _, chesterfields), house(_, _, fox, _, _), Houses),
+  adjacent(house(_, _, _, _, kools), house(_, _, horse, _, _), Houses),
+  member(house(_, _, _, orange_juice, lucky_strike), Houses),
+  member(house(_, japanese, _, _, parliaments), Houses),
+  member(house(_, WaterDrinker, _, water, _), Houses),
+  member(house(_, ZebraOwner, zebra, _, _), Houses).
+
+first([X|_], X).
+third([_, _, X|_], X).
+
+adjacent(A, B, List) :- next_to(A, B, List).
+adjacent(A, B, List) :- next_to(B, A, List).
+
+next_to(X, Y, [X, Y|_]).
+next_to(X, Y, [_|Zs]) :- next_to(X, Y, Zs).
+
+waterDrinker(zebraPuzzle, WaterDrinker) :- zebra(WaterDrinker, _ZebraOwner).
+zebraOwner(zebraPuzzle, ZebraOwner) :- zebra(_WaterDrinker, ZebraOwner).
+solved(zebraPuzzle, true) :- zebra(norwegian, japanese).

package/eyelang.d.ts

@@ -0,0 +1,92 @@
+export interface EyelangStats {
+  [key: string]: number;
+}
+
+export interface EyelangRunOptions {
+  proof?: boolean;
+  why?: boolean;
+  explain?: boolean;
+  inputFormat?: 'auto' | 'eyelang' | 'rdf' | 'rdf12' | 'turtle' | 'ttl' | 'nt' | 'n3' | string;
+  [key: string]: unknown;
+}
+
+export interface EyelangRunResult {
+  stdout: string;
+  stats: EyelangStats;
+}
+
+export interface EyelangSourcePart {
+  text?: string;
+  source?: string;
+  filename?: string;
+}
+
+export class Program {
+  constructor(clauses?: unknown[], options?: EyelangRunOptions);
+  static parse(source: string, options?: EyelangRunOptions): Program;
+  static parseSources(sources?: Array<string | EyelangSourcePart>, options?: EyelangRunOptions): Program;
+  materializationGoals(): unknown[];
+  sourceFactLines(predicateKeys?: Set<string> | null): Set<string>;
+}
+
+export function makeProgram(clauses?: unknown[], options?: EyelangRunOptions): Program;
+export function parseClauses(source: string, options?: EyelangRunOptions): unknown[];
+export function parseProgramText(source: string, options?: EyelangRunOptions): unknown[];
+export function parseRdfClauses(source: string, options?: EyelangRunOptions): unknown[];
+export function rdfToEyelang(source: string, options?: EyelangRunOptions): string;
+export function clausesToEyelang(clauses: unknown[]): string;
+export function rdfIri(value: string): unknown;
+export function rdfBlank(value: string): unknown;
+export function rdfLiteral(value: string, datatype?: string, language?: string): unknown;
+export function rdfTripleTerm(subject: unknown, predicate: unknown, object: unknown): unknown;
+export function rdfGoal(subject: unknown, predicate: unknown, object: unknown): unknown;
+
+export class Env {
+  constructor(parent?: Env | null);
+}
+
+export class Solver {
+  constructor(program: Program, options?: EyelangRunOptions);
+  stats: EyelangStats;
+  solve(goals: unknown[], env?: Env, depth?: number): Iterable<Env>;
+}
+
+export class BuiltinRegistry {
+  constructor();
+}
+
+export function createDefaultRegistry(): BuiltinRegistry;
+export function getDefaultRegistry(): BuiltinRegistry;
+
+export function run(source: string | Program, options?: EyelangRunOptions): EyelangRunResult;
+
+export function whyProof(program: Program, goal: unknown, options?: EyelangRunOptions): { ok: boolean; text: string };
+export function whyNoProof(goal: unknown): string;
+
+export const ATOM: 'atom';
+export const VARIABLE: 'variable';
+export const COMPOUND: 'compound';
+export const NUMBER: 'number';
+export const STRING: 'string';
+export function atom(name: string): unknown;
+export function variable(name: string): unknown;
+export function compound(name: string, args?: unknown[]): unknown;
+export function termToString(term: unknown, env?: Env, quoted?: boolean): string;
+
+declare const eyelang: {
+  run: typeof run;
+  Program: typeof Program;
+  makeProgram: typeof makeProgram;
+  parseClauses: typeof parseClauses;
+  parseProgramText: typeof parseProgramText;
+  parseRdfClauses: typeof parseRdfClauses;
+  rdfToEyelang: typeof rdfToEyelang;
+  clausesToEyelang: typeof clausesToEyelang;
+  Solver: typeof Solver;
+  Env: typeof Env;
+  BuiltinRegistry: typeof BuiltinRegistry;
+  createDefaultRegistry: typeof createDefaultRegistry;
+  getDefaultRegistry: typeof getDefaultRegistry;
+};
+
+export default eyelang;