eyeling 1.14.13 → 1.15.0

package/examples/check/input/deep-taxonomy-100000.c

@@ -0,0 +1,20 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void) {
+    if (printf("@prefix : <http://eulersharp.sourceforge.net/2009/12dtb/test#> .\n\n") < 0) {
+        return EXIT_FAILURE;
+    }
+
+    for (int i = 1; i <= 100000; i++) {
+        if (printf(":ind a :N%d .\n:ind a :I%d .\n:ind a :J%d .\n", i, i, i) < 0) {
+            return EXIT_FAILURE;
+        }
+    }
+
+    if (printf(":ind a :A2 .\n:test :is true .\n") < 0) {
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_SUCCESS;
+}

package/examples/check/input/gps.c

@@ -0,0 +1,127 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct {
+    const char *from;
+    const char *to;
+    const char *action;
+    double duration;
+    double cost;
+    double belief;
+    double comfort;
+} Edge;
+
+typedef struct {
+    const char *actions[8];
+    int action_count;
+    double duration;
+    double cost;
+    double belief;
+    double comfort;
+} Path;
+
+static const Edge EDGES[] = {
+    {"Gent", "Brugge",   ":drive_gent_brugge",    1500.0, 0.006, 0.96, 0.99},
+    {"Gent", "Kortrijk", ":drive_gent_kortrijk",  1600.0, 0.007, 0.96, 0.99},
+    {"Kortrijk", "Brugge", ":drive_kortrijk_brugge", 1600.0, 0.007, 0.96, 0.99},
+    {"Brugge", "Oostende", ":drive_brugge_oostende", 900.0, 0.004, 0.98, 1.0}
+};
+
+static void print_decimal(double value) {
+    char buf[64];
+    snprintf(buf, sizeof(buf), "%.15f", value);
+    char *p = buf + strlen(buf) - 1;
+    while (p > buf && *p == '0') {
+        *p-- = '\0';
+    }
+    if (p > buf && *p == '.') {
+        *p = '\0';
+    }
+    printf("\"%s\"^^xsd:decimal", buf);
+}
+
+static int contains_city(const char *visited[], int visited_count, const char *city) {
+    for (int i = 0; i < visited_count; ++i) {
+        if (strcmp(visited[i], city) == 0) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static void emit_path(const Path *path) {
+    printf(":i1 gps:path ((");
+    for (int i = 0; i < path->action_count; ++i) {
+        if (i > 0) {
+            putchar(' ');
+        }
+        fputs(path->actions[i], stdout);
+    }
+    printf(") ");
+    print_decimal(path->duration);
+    printf(" ");
+    print_decimal(path->cost);
+    printf(" ");
+    print_decimal(path->belief);
+    printf(" ");
+    print_decimal(path->comfort);
+    printf(") .\n");
+}
+
+static void dfs(const char *current,
+                const char *goal,
+                const char *visited[],
+                int visited_count,
+                Path *path) {
+    if (strcmp(current, goal) == 0) {
+        emit_path(path);
+        return;
+    }
+
+    for (size_t i = 0; i < sizeof(EDGES) / sizeof(EDGES[0]); ++i) {
+        const Edge *e = &EDGES[i];
+        if (strcmp(e->from, current) != 0) {
+            continue;
+        }
+        if (contains_city(visited, visited_count, e->to)) {
+            continue;
+        }
+
+        path->actions[path->action_count++] = e->action;
+        path->duration += e->duration;
+        path->cost += e->cost;
+        path->belief *= e->belief;
+        path->comfort *= e->comfort;
+
+        const char *next_visited[16];
+        for (int j = 0; j < visited_count; ++j) {
+            next_visited[j] = visited[j];
+        }
+        next_visited[visited_count] = e->to;
+
+        dfs(e->to, goal, next_visited, visited_count + 1, path);
+
+        path->action_count--;
+        path->duration -= e->duration;
+        path->cost -= e->cost;
+        path->belief /= e->belief;
+        path->comfort /= e->comfort;
+    }
+}
+
+int main(void) {
+    puts("@prefix : <https://eyereasoner.github.io/eye/reasoning#> .");
+    puts("@prefix gps: <https://eyereasoner.github.io/eye/reasoning/gps/gps-schema#> .");
+    puts("@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .");
+    putchar('\n');
+
+    Path path;
+    memset(&path, 0, sizeof(path));
+    path.belief = 1.0;
+    path.comfort = 1.0;
+
+    const char *visited[] = {"Gent"};
+    dfs("Gent", "Oostende", visited, 1, &path);
+    return 0;
+}

package/examples/check/input/high-trust-rdf-bloom-envelope.c

@@ -0,0 +1,148 @@
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+typedef struct {
+    const char *name;
+    int canonicalTripleCount;
+    int spoIndexTripleCount;
+    int bloomBits;
+    int hashFunctions;
+    int negativeLookupsPerBatch;
+    double fpRateBudget;
+    double extraExactLookupsBudget;
+    const char *exactTranscendentalSymbol;
+    double certifiedLambda;
+    double expMinusLambdaLower;
+    double expMinusLambdaUpper;
+    const char *maybePositivePolicy;
+    const char *definiteNegativePolicy;
+} Artifact;
+
+typedef struct {
+    bool parameterSanity;
+    bool indexAgreement;
+    double lambda;
+    bool expIntervalCertificate;
+    double fpRateLower;
+    double fpRateUpper;
+    bool withinFpRateBudget;
+    double expectedExtraExactLookupsUpper;
+    bool withinExactLookupBudget;
+    bool accepted;
+} Evaluation;
+
+static bool same_policy(const char *lhs, const char *rhs) {
+    return strcmp(lhs, rhs) == 0;
+}
+
+static Evaluation evaluate_artifact(const Artifact *a) {
+    Evaluation ev;
+    memset(&ev, 0, sizeof(ev));
+
+    ev.parameterSanity =
+        a->canonicalTripleCount > 0 &&
+        a->spoIndexTripleCount > 0 &&
+        a->bloomBits > 0 &&
+        a->hashFunctions > 0 &&
+        a->negativeLookupsPerBatch > 0 &&
+        a->fpRateBudget > 0.0 &&
+        a->extraExactLookupsBudget > 0.0;
+
+    ev.indexAgreement = (a->canonicalTripleCount == a->spoIndexTripleCount);
+
+    if (ev.parameterSanity) {
+        ev.lambda = ((double)a->hashFunctions * (double)a->canonicalTripleCount) /
+                    (double)a->bloomBits;
+    }
+
+    ev.expIntervalCertificate =
+        ev.lambda > 0.0 &&
+        a->certifiedLambda == ev.lambda &&
+        a->expMinusLambdaLower < a->expMinusLambdaUpper &&
+        a->expMinusLambdaLower > 0.0 &&
+        a->expMinusLambdaUpper < 1.0;
+
+    if (ev.expIntervalCertificate) {
+        const double oneMinusLo = 1.0 - a->expMinusLambdaUpper;
+        const double oneMinusHi = 1.0 - a->expMinusLambdaLower;
+        ev.fpRateLower = pow(oneMinusLo, a->hashFunctions);
+        ev.fpRateUpper = pow(oneMinusHi, a->hashFunctions);
+    }
+
+    ev.withinFpRateBudget =
+        ev.fpRateUpper > 0.0 &&
+        ev.fpRateUpper < a->fpRateBudget;
+
+    ev.expectedExtraExactLookupsUpper =
+        (double)a->negativeLookupsPerBatch * ev.fpRateUpper;
+
+    ev.withinExactLookupBudget =
+        ev.expectedExtraExactLookupsUpper > 0.0 &&
+        ev.expectedExtraExactLookupsUpper < a->extraExactLookupsBudget;
+
+    ev.accepted =
+        ev.parameterSanity &&
+        ev.indexAgreement &&
+        ev.expIntervalCertificate &&
+        ev.withinFpRateBudget &&
+        ev.withinExactLookupBudget &&
+        same_policy(a->maybePositivePolicy, ":ConfirmAgainstCanonicalGraph") &&
+        same_policy(a->definiteNegativePolicy, ":ReturnAbsent");
+
+    return ev;
+}
+
+int main(void) {
+    const Artifact artifact = {
+        .name = ":artifact",
+        .canonicalTripleCount = 1200,
+        .spoIndexTripleCount = 1200,
+        .bloomBits = 16384,
+        .hashFunctions = 7,
+        .negativeLookupsPerBatch = 50000,
+        .fpRateBudget = 0.002,
+        .extraExactLookupsBudget = 100.0,
+        .exactTranscendentalSymbol = "exp(-k*n/m)",
+        .certifiedLambda = 0.5126953125,
+        .expMinusLambdaLower = 0.5988792348,
+        .expMinusLambdaUpper = 0.5988792349,
+        .maybePositivePolicy = ":ConfirmAgainstCanonicalGraph",
+        .definiteNegativePolicy = ":ReturnAbsent"
+    };
+
+    const Evaluation ev = evaluate_artifact(&artifact);
+
+    printf("@prefix : <http://example.org/high-trust-rdf#> .\n");
+    printf("@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .\n\n");
+
+    if (ev.expIntervalCertificate) {
+        printf(":result :expIntervalCertificate :CertifiedDecimalInterval .\n");
+    }
+
+    if (ev.accepted) {
+        printf(":result :summary (\"parameter-sanity\" true ");
+        printf("\"index-agreement\" true ");
+        printf("\"transcendental\" \"%s\" ", artifact.exactTranscendentalSymbol);
+        printf("\"lambda\" \"%.10f\"^^xsd:decimal ", ev.lambda);
+        printf("\"certified-lambda\" %.10f ", artifact.certifiedLambda);
+        printf("\"exp-lower\" %.10f ", artifact.expMinusLambdaLower);
+        printf("\"exp-upper\" %.10f ", artifact.expMinusLambdaUpper);
+        printf("\"fp-lower\" \"%.19f\"^^xsd:decimal ", ev.fpRateLower);
+        printf("\"fp-upper\" \"%.19f\"^^xsd:decimal ", ev.fpRateUpper);
+        printf("\"expected-extra-exact-lookups-upper\" \"%.14f\"^^xsd:decimal ",
+               ev.expectedExtraExactLookupsUpper);
+        printf("\"decision\" :AcceptForHighTrustUse) .\n");
+    }
+
+    if (ev.withinExactLookupBudget) {
+        printf(":result :withinExactLookupBudget true .\n");
+    }
+
+    if (ev.withinFpRateBudget) {
+        printf(":result :withinFpRateBudget true .\n");
+    }
+
+    return 0;
+}

package/examples/check/input/high-trust-rdf-bloom-tamper-contrast.c

@@ -0,0 +1,247 @@
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define ARRAY_LEN(x) (sizeof(x) / sizeof((x)[0]))
+
+typedef struct {
+    const char *name;
+    int canonicalTripleCount;
+    int spoIndexTripleCount;
+    int bloomBits;
+    int hashFunctions;
+    int negativeLookupsPerBatch;
+    double fpRateBudget;
+    double extraExactLookupsBudget;
+    const char *exactTranscendentalSymbol;
+    double certifiedLambda;
+    double expMinusLambdaLower;
+    double expMinusLambdaUpper;
+    const char *maybePositivePolicy;
+    const char *definiteNegativePolicy;
+} Artifact;
+
+typedef enum {
+    REJECT_NON_POSITIVE_BLOOM_BITS,
+    REJECT_CERTIFIED_LAMBDA_MISMATCH,
+    REJECT_MALFORMED_INTERVAL_ORDERING,
+    REJECT_NON_POSITIVE_INTERVAL_LOWER_BOUND,
+    REJECT_INTERVAL_UPPER_BOUND_NOT_BELOW_ONE
+} RejectReason;
+
+typedef struct {
+    double lambda;
+    double weakFpUpper;
+    double weakExtraUpper;
+    bool indexAgreement;
+    bool weakWithinFpRateBudget;
+    bool weakWithinExactLookupBudget;
+    bool weakAccepted;
+    bool parameterSanity;
+    bool expIntervalCertificate;
+    bool withinFpRateBudget;
+    bool withinExactLookupBudget;
+    bool hardenedAccepted;
+    RejectReason rejectReasons[8];
+    size_t rejectReasonCount;
+} Evaluation;
+
+static bool same_policy(const char *lhs, const char *rhs) {
+    return strcmp(lhs, rhs) == 0;
+}
+
+static double compute_lambda(const Artifact *a) {
+    double kn = (double)a->hashFunctions * (double)a->canonicalTripleCount;
+    return kn / (double)a->bloomBits;
+}
+
+static double compute_weak_fp_upper(const Artifact *a) {
+    double oneMinusHi = 1.0 - a->expMinusLambdaLower;
+    return pow(oneMinusHi, a->hashFunctions);
+}
+
+static void add_reject_reason(Evaluation *ev, RejectReason reason) {
+    ev->rejectReasons[ev->rejectReasonCount++] = reason;
+}
+
+static const char *reject_reason_name(RejectReason reason) {
+    switch (reason) {
+        case REJECT_NON_POSITIVE_BLOOM_BITS:
+            return ":NonPositiveBloomBits";
+        case REJECT_CERTIFIED_LAMBDA_MISMATCH:
+            return ":CertifiedLambdaMismatch";
+        case REJECT_MALFORMED_INTERVAL_ORDERING:
+            return ":MalformedIntervalOrdering";
+        case REJECT_NON_POSITIVE_INTERVAL_LOWER_BOUND:
+            return ":NonPositiveIntervalLowerBound";
+        case REJECT_INTERVAL_UPPER_BOUND_NOT_BELOW_ONE:
+            return ":IntervalUpperBoundNotBelowOne";
+    }
+    return ":UnknownRejectReason";
+}
+
+static Evaluation evaluate_artifact(const Artifact *a) {
+    Evaluation ev;
+    memset(&ev, 0, sizeof(ev));
+
+    ev.lambda = compute_lambda(a);
+    ev.indexAgreement = (a->canonicalTripleCount == a->spoIndexTripleCount);
+
+    ev.weakFpUpper = compute_weak_fp_upper(a);
+    ev.weakWithinFpRateBudget = (ev.weakFpUpper < a->fpRateBudget);
+    ev.weakExtraUpper = (double)a->negativeLookupsPerBatch * ev.weakFpUpper;
+    ev.weakWithinExactLookupBudget = (ev.weakExtraUpper < a->extraExactLookupsBudget);
+    ev.weakAccepted = ev.indexAgreement &&
+                      ev.weakWithinFpRateBudget &&
+                      ev.weakWithinExactLookupBudget &&
+                      same_policy(a->maybePositivePolicy, ":ConfirmAgainstCanonicalGraph") &&
+                      same_policy(a->definiteNegativePolicy, ":ReturnAbsent");
+
+    ev.parameterSanity =
+        a->canonicalTripleCount > 0 &&
+        a->spoIndexTripleCount > 0 &&
+        a->bloomBits > 0 &&
+        a->hashFunctions > 0 &&
+        a->negativeLookupsPerBatch > 0 &&
+        a->fpRateBudget > 0.0 &&
+        a->extraExactLookupsBudget > 0.0;
+
+    ev.expIntervalCertificate =
+        ev.lambda > 0.0 &&
+        a->certifiedLambda == ev.lambda &&
+        a->expMinusLambdaLower < a->expMinusLambdaUpper &&
+        a->expMinusLambdaLower > 0.0 &&
+        a->expMinusLambdaUpper < 1.0;
+
+    ev.withinFpRateBudget = ev.expIntervalCertificate &&
+                            ev.weakFpUpper > 0.0 &&
+                            ev.weakFpUpper < a->fpRateBudget;
+
+    ev.withinExactLookupBudget = ev.expIntervalCertificate &&
+                                 ev.weakExtraUpper > 0.0 &&
+                                 ev.weakExtraUpper < a->extraExactLookupsBudget;
+
+    ev.hardenedAccepted = ev.parameterSanity &&
+                          ev.indexAgreement &&
+                          ev.expIntervalCertificate &&
+                          ev.withinFpRateBudget &&
+                          ev.withinExactLookupBudget &&
+                          same_policy(a->maybePositivePolicy, ":ConfirmAgainstCanonicalGraph") &&
+                          same_policy(a->definiteNegativePolicy, ":ReturnAbsent");
+
+    if (a->bloomBits <= 0) {
+        add_reject_reason(&ev, REJECT_NON_POSITIVE_BLOOM_BITS);
+    }
+    if (a->certifiedLambda != ev.lambda) {
+        add_reject_reason(&ev, REJECT_CERTIFIED_LAMBDA_MISMATCH);
+    }
+    if (!(a->expMinusLambdaUpper > a->expMinusLambdaLower)) {
+        add_reject_reason(&ev, REJECT_MALFORMED_INTERVAL_ORDERING);
+    }
+    if (!(a->expMinusLambdaLower > 0.0)) {
+        add_reject_reason(&ev, REJECT_NON_POSITIVE_INTERVAL_LOWER_BOUND);
+    }
+    if (!(a->expMinusLambdaUpper < 1.0)) {
+        add_reject_reason(&ev, REJECT_INTERVAL_UPPER_BOUND_NOT_BELOW_ONE);
+    }
+
+    return ev;
+}
+
+static void print_decision(const Artifact *a, const Evaluation *ev) {
+    printf(":result :decision [\n");
+    printf("  :artifact %s ;\n", a->name);
+    printf("  :hardened %s ;\n",
+           ev->hardenedAccepted ? ":AcceptForHighTrustUse" : ":RejectForHighTrustUse");
+    printf("  :weak %s\n",
+           ev->weakAccepted ? ":AcceptUnderWeakBudgetOnlyRules" : ":RejectUnderWeakBudgetOnlyRules");
+    printf("] .\n");
+}
+
+static void print_reject_reasons(const Artifact *a, const Evaluation *ev) {
+    for (size_t i = 0; i < ev->rejectReasonCount; ++i) {
+        printf(":result :rejectReason [\n");
+        printf("  :artifact %s ;\n", a->name);
+        printf("  :why %s\n", reject_reason_name(ev->rejectReasons[i]));
+        printf("] .\n");
+    }
+}
+
+static void print_summary_tampered(const Artifact *a, const Evaluation *ev) {
+    long long weakFpUpperInt = (long long)llround(ev->weakFpUpper);
+    long long weakExtraUpperInt = (long long)llround(ev->weakExtraUpper);
+
+    printf(":result :summary (%s \"lambda\" %.0f \"certified-lambda\" %.10f ",
+           a->name,
+           ev->lambda,
+           a->certifiedLambda);
+    printf("\"weak-fp-upper\" \"%lld\"^^xsd:decimal ", weakFpUpperInt);
+    printf("\"weak-extra-exact-upper\" \"%lld\"^^xsd:decimal ", weakExtraUpperInt);
+    printf("\"weak-decision\" %s \"hardened-decision\" %s) .\n",
+           ev->weakAccepted ? ":AcceptUnderWeakBudgetOnlyRules" : ":RejectUnderWeakBudgetOnlyRules",
+           ev->hardenedAccepted ? ":AcceptForHighTrustUse" : ":RejectForHighTrustUse");
+}
+
+static void print_summary_trusted(const Artifact *a, const Evaluation *ev) {
+    printf(":result :summary (%s \"lambda\" \"%.10f\"^^xsd:decimal \"certified-lambda\" %.10f ",
+           a->name,
+           ev->lambda,
+           a->certifiedLambda);
+    printf("\"weak-fp-upper\" \"%.19f\"^^xsd:decimal ", ev->weakFpUpper);
+    printf("\"weak-extra-exact-upper\" \"%.14f\"^^xsd:decimal ", ev->weakExtraUpper);
+    printf("\"weak-decision\" %s \"hardened-decision\" %s) .\n",
+           ev->weakAccepted ? ":AcceptUnderWeakBudgetOnlyRules" : ":RejectUnderWeakBudgetOnlyRules",
+           ev->hardenedAccepted ? ":AcceptForHighTrustUse" : ":RejectForHighTrustUse");
+}
+
+int main(void) {
+    const Artifact trusted = {
+        .name = ":trustedArtifact",
+        .canonicalTripleCount = 1200,
+        .spoIndexTripleCount = 1200,
+        .bloomBits = 16384,
+        .hashFunctions = 7,
+        .negativeLookupsPerBatch = 50000,
+        .fpRateBudget = 0.002,
+        .extraExactLookupsBudget = 100.0,
+        .exactTranscendentalSymbol = "exp(-k*n/m)",
+        .certifiedLambda = 0.5126953125,
+        .expMinusLambdaLower = 0.5988792348,
+        .expMinusLambdaUpper = 0.5988792349,
+        .maybePositivePolicy = ":ConfirmAgainstCanonicalGraph",
+        .definiteNegativePolicy = ":ReturnAbsent"
+    };
+
+    const Artifact tampered = {
+        .name = ":tamperedArtifact",
+        .canonicalTripleCount = 1200,
+        .spoIndexTripleCount = 1200,
+        .bloomBits = -12,
+        .hashFunctions = 7,
+        .negativeLookupsPerBatch = 1,
+        .fpRateBudget = 0.1,
+        .extraExactLookupsBudget = 100.0,
+        .exactTranscendentalSymbol = "whatever an attacker writes here",
+        .certifiedLambda = 0.5126953125,
+        .expMinusLambdaLower = 42.0,
+        .expMinusLambdaUpper = -42.0,
+        .maybePositivePolicy = ":ConfirmAgainstCanonicalGraph",
+        .definiteNegativePolicy = ":ReturnAbsent"
+    };
+
+    const Evaluation trustedEval = evaluate_artifact(&trusted);
+    const Evaluation tamperedEval = evaluate_artifact(&tampered);
+
+    printf("@prefix : <http://example.org/high-trust-rdf#> .\n");
+    printf("@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .\n\n");
+
+    print_decision(&trusted, &trustedEval);
+    print_decision(&tampered, &tamperedEval);
+    print_reject_reasons(&tampered, &tamperedEval);
+    print_summary_tampered(&tampered, &tamperedEval);
+    print_summary_trusted(&trusted, &trustedEval);
+
+    return 0;
+}