eyeling 1.14.9 → 1.14.11

package/examples/e-computable-real.n3

@@ -0,0 +1,201 @@
+# =========================================================================================
+# e as “integers-only” engineering: a computable real via factorial-series bounds
+#
+# Philosophy (Kronecker-friendly):
+#   We do not assume a completed continuum of real numbers. Instead, a “real number” is
+#   represented by a *procedure* that can deliver arbitrarily tight rational information
+#   on demand (finite request in, finite certificate out).
+#
+# What this file encodes:
+#   We represent e = exp(1) using the classical series:
+#       e = Σ_{k=0..∞} 1/k!
+#   For each requested precision n (0..maxN) we compute an index m = n + offset and produce
+#   a rational interval [L_n, U_n] where:
+#     L_n = Σ_{k=0..m} 1/k!                    (partial sum; lower bound)
+#     U_n = L_n + R_m                          (upper bound using a remainder estimate)
+#
+# Guarantees produced (machine-checkable inequalities):
+#   (1) width(n) = U_n - L_n = R_m
+#   (2) width(n) <= 2^-n                         (precision guarantee)
+#   (3) optional sanity: intervals are nested as n increases
+#
+# Finite arithmetic only:
+#   All computations are performed with finite numeric literals; rationals appear only as
+#   quotients produced by math:quotient (no “actual” infinite real object is required).
+#
+# Output discipline (Gödel-ish):
+#   The rules derive a closure; log:query is used to project only the intended results
+#   (bounds, widths, epsilons, midpoints), separating “truth definition” from “reporting”.
+# =========================================================================================
+
+@prefix :      <http://example.org/kronecker-e#>.
+@prefix math:  <http://www.w3.org/2000/10/swap/math#>.
+@prefix log:   <http://www.w3.org/2000/10/swap/log#>.
+
+# ----------
+# Parameters
+# ----------
+
+:e a :ComputableReal;
+  :computedBy :seriesE.
+
+:seriesE a :IntervalProcedure;
+  :maxN 12;
+  :offset 6;
+  :maxK 18.     # must be >= maxN + offset
+
+# ------------------------------------
+# 1) Generate factorials: fact(k) = k!
+# ------------------------------------
+
+:seriesE :fact (0 1.0).
+
+{
+  :seriesE :fact (?k ?f).
+  :seriesE :maxK ?maxK.
+  ?k math:lessThan ?maxK.
+
+  ( ?k 1 ) math:sum ?k1.
+  ( ?f ?k1 ) math:product ?f1.
+}
+=>
+{
+  :seriesE :fact (?k1 ?f1).
+}.
+
+# --------------------------------------------------
+# 2) Generate partial sums: sum(k) = Σ_{i=0..k} 1/i!
+# --------------------------------------------------
+
+:seriesE :sum (0 1.0).
+
+{
+  :seriesE :sum (?k ?s).
+  :seriesE :maxK ?maxK.
+  ?k math:lessThan ?maxK.
+
+  ( ?k 1 ) math:sum ?k1.
+  :seriesE :fact (?k1 ?f1).
+
+  ( 1.0 ?f1 ) math:quotient ?term.
+  ( ?s ?term ) math:sum ?s1.
+}
+=>
+{
+  :seriesE :sum (?k1 ?s1).
+}.
+
+# ------------------------------------------
+# 3) Generate precision requests n = 0..maxN
+# ------------------------------------------
+
+:seriesE :n 0.
+
+{
+  :seriesE :n ?n.
+  :seriesE :maxN ?maxN.
+  ?n math:lessThan ?maxN.
+  ( ?n 1 ) math:sum ?n1.
+}
+=>
+{
+  :seriesE :n ?n1.
+}.
+
+# ------------------------------------------------------------------
+# 4) For each n, choose m = n + offset and compute bounds [L_n, U_n]
+#    Remainder estimate used here:
+#        R_m = 1 / (m * m!)
+#    (a standard upper bound for the tail of Σ 1/k! for m >= 1)
+# ------------------------------------------------------------------
+
+{
+  :seriesE :n ?n.
+  :seriesE :offset ?off.
+  ( ?n ?off ) math:sum ?m.
+
+  :seriesE :sum  (?m ?L).
+  :seriesE :fact (?m ?mf).
+
+  ( ?m ?mf ) math:product ?den.        # den = m * m!
+  ( 1.0 ?den ) math:quotient ?R.       # R = 1 / (m*m!)
+  ( ?L ?R ) math:sum ?U.               # U = L + R
+}
+=>
+{
+  :e :bounds (?n ?m ?L ?U).
+  :e :width  (?n ?R).
+}.
+
+# ---------------------------------------------------------------
+# 5) eps(n) = 2^-n and the precision guarantee width(n) <= eps(n)
+# ---------------------------------------------------------------
+
+{
+  :seriesE :n ?n.
+  ( 2 ?n ) math:exponentiation ?pow2.
+  ( 1.0 ?pow2 ) math:quotient ?eps.
+}
+=>
+{
+  :e :epsilon (?n ?eps).
+}.
+
+{
+  :e :width (?n ?W).
+  :e :epsilon (?n ?eps).
+  ?W math:notGreaterThan ?eps.
+}
+=>
+{
+  :e :guaranteeWidthLe2PowNegN (?n true).
+}.
+
+# ----------------------------------------------------------
+# 6) Optional sanity: nestedness of intervals as n increases
+# ----------------------------------------------------------
+
+{
+  :e :bounds (?n ?m ?L ?U).
+  ( ?n 1 ) math:sum ?n1.
+  :e :bounds (?n1 ?m1 ?L1 ?U1).
+
+  ?L1 math:notLessThan ?L.
+  ?U1 math:notGreaterThan ?U.
+}
+=>
+{
+  :e :nested (?n1 true).
+}.
+
+# -------------------------------
+# 7) Output selection (log:query)
+# -------------------------------
+
+{
+  :e :bounds (?n ?m ?L ?U).
+  :e :width  (?n ?W).
+  :e :epsilon (?n ?eps).
+  :e :guaranteeWidthLe2PowNegN (?n true).
+
+  ( ?L ?U ) math:sum ?s.
+  ( ?s 2 ) math:quotient ?M.
+  ( ?W 2 ) math:quotient ?errBound.
+}
+log:query
+{
+  :result :requestN  ?n.
+  :result :chosenM   ?m.
+  :result :interval  (?n ?L ?U).
+  :result :width     (?n ?W).
+  :result :eps       (?n ?eps).
+  :result :midpoint  (?n ?M ?errBound).
+}.
+
+{
+  :e :nested (?n true).
+}
+log:query
+{
+  :result :nestedAt (?n true).
+}.

package/examples/euler-identity.n3

@@ -0,0 +1,113 @@
+# =========================================================================================
+# Euler identity (exact, certificate-friendly):
+#   exp(i*pi) + 1 = 0
+#
+# Philosophy:
+# Unlike the T-gate example, this phase needs no approximation.  exp(i*pi) lands exactly at
+# (-1,0) = cos(pi) + i sin(pi), so the identity can be certified using integer arithmetic
+# alone.
+#
+# Method:
+# 1) Construct -1 as 0 - 1.
+# 2) Represent exp(i*pi) exactly as (-1, 0).
+# 3) Add 1 componentwise to obtain (0, 0).
+# 4) Sanity-check the phase modulus: |-1 + 0i|^2 = 1.
+# 5) Project only the intended certificates via log:query.
+# =========================================================================================
+
+@prefix :     <http://example.org/euler-identity#>.
+@prefix log:  <http://www.w3.org/2000/10/swap/log#>.
+@prefix math: <http://www.w3.org/2000/10/swap/math#>.
+
+# ----------
+# Parameters
+# ----------
+
+:EulerIdentity a :ExactComplexEquation;
+  :name "Euler identity";
+  :formula "exp(i*pi) + 1 = 0";
+  :usesPhase :phasePi.
+
+:one a :ComplexNumber;
+  :exact (1 0).
+
+:zero a :ComplexNumber;
+  :exact (0 0).
+
+:phasePi a :ComplexPhase;
+  :definedAs "cos(pi) + i sin(pi)".
+
+# -----------------------------------------
+# 1) Construct exp(i*pi) exactly as (-1, 0)
+# -----------------------------------------
+
+{
+  (0 1) math:difference ?minusOne.
+} => {
+  :phasePi :exact (?minusOne 0).
+}.
+
+# -----------------------------------------------------
+# 2) Add 1 componentwise: (-1 + 0i) + (1 + 0i) = 0 + 0i
+# -----------------------------------------------------
+
+{
+  :phasePi :exact (?re ?im).
+  :one :exact (?oneRe ?oneIm).
+  (?re ?oneRe) math:sum ?sumRe.
+  (?im ?oneIm) math:sum ?sumIm.
+} => {
+  :EulerIdentity :lhsExact (?sumRe ?sumIm).
+  :EulerIdentity :rhsExact (0 0).
+}.
+
+# --------------------------------------------------
+# 3) Certify that the left-hand side is exactly zero
+# --------------------------------------------------
+
+{
+  :EulerIdentity :lhsExact (?sumRe ?sumIm).
+  :zero :exact (?sumRe ?sumIm).
+} => {
+  :EulerIdentity :holds true.
+}.
+
+# -------------------------------------------------
+# 4) Sanity check: |exp(i*pi)|^2 = (-1)^2 + 0^2 = 1
+# -------------------------------------------------
+
+{
+  :phasePi :exact (?re ?im).
+  (?re ?re) math:product ?re2.
+  (?im ?im) math:product ?im2.
+  (?re2 ?im2) math:sum ?modSq.
+} => {
+  :phasePi :modSq ?modSq.
+}.
+
+{
+  :phasePi :modSq ?modSq.
+  ?modSq math:equalTo 1.
+} => {
+  :phasePi :modSqIsOne true.
+}.
+
+# -------------------------------
+# 5) Output selection (log:query)
+# -------------------------------
+
+{
+  :phasePi :exact (?re ?im).
+  :EulerIdentity :lhsExact (?sumRe ?sumIm).
+  :EulerIdentity :rhsExact (?rhsRe ?rhsIm).
+  :phasePi :modSq ?modSq.
+  :phasePi :modSqIsOne ?modOk.
+  :EulerIdentity :holds ?ok.
+} log:query {
+  :result :phasePi (?re ?im).
+  :result :lhsPlusOne (?sumRe ?sumIm).
+  :result :rhsZero (?rhsRe ?rhsIm).
+  :result :phaseModSq ?modSq.
+  :result :phaseModSqIsOne ?modOk.
+  :result :identityHolds ?ok.
+}.

package/examples/gd-step-certified.n3

@@ -0,0 +1,283 @@
+# =========================================================================================
+# A simple gradient descent step with certified rational bounds (integers-first style)
+#
+# Philosophy (Kronecker-friendly):
+#   We do not assume “true” real numbers as primitives. Instead, we represent quantities by
+#   finite rational/decimal literals and *certified interval bounds* derived by arithmetic.
+#
+# Objective (1D toy problem):
+#   f(x) = (x - a)^2      (convex quadratic with minimizer at x = a)
+#   ∇f(x) = 2 (x - a)
+#
+# Gradient descent update:
+#   x_{k+1} = x_k - η ∇f(x_k) = x_k - η * 2 (x_k - a)
+#
+# What is certified here:
+#   Given an interval x_k ∈ [L_k, U_k] and a step size η ≥ 0, we derive an interval
+#   x_{k+1} ∈ [L_{k+1}, U_{k+1}] by sound interval arithmetic:
+#     g ∈ [2(L_k-a), 2(U_k-a)]
+#     p = η g ∈ [η g_L, η g_U]
+#     x_{k+1} = x_k - p ∈ [L_k - p_U, U_k - p_L]
+#
+# Additionally (when η ≤ 1/2):
+#   the update map is monotone increasing (1 - 2η ≥ 0), and the interval width contracts:
+#     width_{k+1} ≤ width_k
+#
+# Output discipline (Gödel-ish):
+#   log:query projects only the intended results (bounds, midpoints, certificates).
+# =========================================================================================
+
+@prefix :      <http://example.org/kronecker-gd#>.
+@prefix math:  <http://www.w3.org/2000/10/swap/math#>.
+@prefix log:   <http://www.w3.org/2000/10/swap/log#>.
+
+# ----------
+# Parameters
+# ----------
+
+:gd a :GradientDescentProcedure ;
+  :maxK 10 ;
+  :a 1.0 .
+
+# Step size η = 1/5
+{ ( 1.0 5 ) math:quotient ?eta. } => { :gd :eta ?eta. }.
+
+# Initial uncertainty: x0 ∈ [0, 2]
+:gd :xBounds (0 0.0 2.0).
+
+# ----------------------------
+# Generate indices k = 0..maxK
+# ----------------------------
+
+:gd :k 0.
+
+{
+  :gd :k ?k.
+  :gd :maxK ?maxK.
+  ?k math:lessThan ?maxK.
+  ( ?k 1 ) math:sum ?k1.
+}
+=>
+{
+  :gd :k ?k1.
+}.
+
+# ---------------------------------------
+# A) Gradient bounds g ∈ [2(L-a), 2(U-a)]
+# ---------------------------------------
+
+{
+  :gd :a ?a.
+  :gd :xBounds (?k ?L ?U).
+
+  ( ?L ?a ) math:difference ?dL.
+  ( ?U ?a ) math:difference ?dU.
+
+  ( 2 ?dL ) math:product ?gL.
+  ( 2 ?dU ) math:product ?gU.
+}
+=>
+{
+  :gd :gBounds (?k ?gL ?gU).
+}.
+
+# -----------------------------------------
+# B) Step interval p = η g  (η ≥ 0 assumed)
+# -----------------------------------------
+
+{
+  :gd :eta ?eta.
+  :gd :gBounds (?k ?gL ?gU).
+
+  ( ?eta ?gL ) math:product ?pL.
+  ( ?eta ?gU ) math:product ?pU.
+}
+=>
+{
+  :gd :pBounds (?k ?pL ?pU).
+}.
+
+# --------------------------------------------
+# C) Update bounds: x_{k+1} ∈ [L - pU, U - pL]
+# --------------------------------------------
+
+{
+  :gd :xBounds (?k ?L ?U).
+  :gd :pBounds (?k ?pL ?pU).
+  :gd :maxK ?maxK.
+  ?k math:lessThan ?maxK.
+
+  ( ?k 1 ) math:sum ?k1.
+
+  ( ?L ?pU ) math:difference ?L1.
+  ( ?U ?pL ) math:difference ?U1.
+}
+=>
+{
+  :gd :xBounds (?k1 ?L1 ?U1).
+}.
+
+# -----------------------------
+# D) Width + midpoint summaries
+# -----------------------------
+
+{
+  :gd :xBounds (?k ?L ?U).
+
+  ( ?U ?L ) math:difference ?W.
+  ( ?W 2 ) math:quotient ?halfW.
+
+  ( ?L ?U ) math:sum ?s.
+  ( ?s 2 ) math:quotient ?M.
+}
+=>
+{
+  :gd :width    (?k ?W).
+  :gd :midpoint (?k ?M ?halfW).
+}.
+
+# --------------------------------
+# E) Optional certificate: η ≤ 1/2
+# --------------------------------
+
+{
+  :gd :eta ?eta.
+  ( 1.0 2 ) math:quotient ?half.
+  ?eta math:notGreaterThan ?half.
+}
+=>
+{
+  :gd :etaLeHalf true.
+}.
+
+# width_{k+1} ≤ width_k when η ≤ 1/2 (checked from derived intervals)
+{
+  :gd :etaLeHalf true.
+  :gd :width (?k ?W).
+  ( ?k 1 ) math:sum ?k1.
+  :gd :width (?k1 ?W1).
+  ?W1 math:notGreaterThan ?W.
+}
+=>
+{
+  :gd :widthContractsAt (?k1 true).
+}.
+
+# ----------------------------------------------------------------
+# F) Certified bounds on objective value f(x) = (x-a)^2 over [L,U]
+# ----------------------------------------------------------------
+
+# compute endpoint squares (L-a)^2 and (U-a)^2
+{
+  :gd :a ?a.
+  :gd :xBounds (?k ?L ?U).
+
+  ( ?L ?a ) math:difference ?dL.
+  ( ?U ?a ) math:difference ?dU.
+
+  ( ?dL ?dL ) math:product ?sL.
+  ( ?dU ?dU ) math:product ?sU.
+}
+=>
+{
+  :gd :endSquares (?k ?sL ?sU).
+}.
+
+# upper bound fU = max(sL,sU)
+{
+  :gd :endSquares (?k ?sL ?sU).
+  ( ?sL ?sU ) :max ?fU.
+}
+=>
+{
+  :gd :fUpper (?k ?fU).
+}.
+
+# lower bound:
+# if a ∈ [L,U] then fLower = 0
+{
+  :gd :a ?a.
+  :gd :xBounds (?k ?L ?U).
+  ?L math:notGreaterThan ?a.
+  ?a math:notGreaterThan ?U.
+}
+=>
+{
+  :gd :fLower (?k 0.0).
+}.
+
+# else if interval is entirely left of a (U < a): fLower = min(sL,sU)
+{
+  :gd :a ?a.
+  :gd :xBounds (?k ?L ?U).
+  ?U math:lessThan ?a.
+  :gd :endSquares (?k ?sL ?sU).
+  ( ?sL ?sU ) :min ?fL.
+}
+=>
+{
+  :gd :fLower (?k ?fL).
+}.
+
+# else if interval is entirely right of a (a < L): fLower = min(sL,sU)
+{
+  :gd :a ?a.
+  :gd :xBounds (?k ?L ?U).
+  ?a math:lessThan ?L.
+  :gd :endSquares (?k ?sL ?sU).
+  ( ?sL ?sU ) :min ?fL.
+}
+=>
+{
+  :gd :fLower (?k ?fL).
+}.
+
+# -------------------------------------------------------------------
+# User-defined max/min
+#
+# These are written as backward rules (<=), so they behave like
+# “user-defined built-ins” when you use (a b) :max ?m in a rule body.
+# -------------------------------------------------------------------
+
+{ ( ?a ?b ) :max ?a. } <= { ?a math:notLessThan ?b. }.  # a >= b
+{ ( ?a ?b ) :max ?b. } <= { ?a math:lessThan ?b. }.     # a <  b
+
+{ ( ?a ?b ) :min ?a. } <= { ?a math:notGreaterThan ?b. }. # a <= b
+{ ( ?a ?b ) :min ?b. } <= { ?a math:greaterThan ?b. }.    # a >  b
+
+# ----------------------------
+# Output selection (log:query)
+# ----------------------------
+
+{
+  :gd :k ?k.
+  :gd :xBounds (?k ?L ?U).
+  :gd :width   (?k ?W).
+  :gd :midpoint (?k ?M ?halfW).
+  :gd :gBounds (?k ?gL ?gU).
+  :gd :pBounds (?k ?pL ?pU).
+  :gd :fLower (?k ?fL).
+  :gd :fUpper (?k ?fU).
+}
+log:query
+{
+  :result :k ?k.
+  :result :xBounds (?k ?L ?U).
+  :result :midpoint (?k ?M ?halfW).
+  :result :width (?k ?W).
+  :result :gBounds (?k ?gL ?gU).
+  :result :pBounds (?k ?pL ?pU).
+  :result :fBounds (?k ?fL ?fU).
+}.
+
+{ :gd :eta ?eta. }
+log:query
+{ :result :eta ?eta. }.
+
+{ :gd :etaLeHalf true. }
+log:query
+{ :result :etaLeHalf true. }.
+
+{ :gd :widthContractsAt (?k true). }
+log:query
+{ :result :widthContractsAt (?k true). }.