future.lisp

;;; ==================================================================
;;;  ILAN · FUTURE — unfold of an UNrecorded moment
;;;  Layer above the core (time axis).
;;;
;;;  Past (`to-past`) — real snapshots that WERE, recorded.
;;;  Future — the same anamorphism over T(X)=Moment×Maybe(X), but forward
;;;  and by an EXPECTATION rule. Future moments aren't recorded — it's an
;;;  unfold of the POSSIBLE, not fact. The time axis symmetry closes.
;;; ==================================================================

(load "algebras.lisp")   ; core (time axis) + meaning-algebras

;;; ── rule preds (swappable, like an algebra): to unfold the future you
;;;    need an EXPECTATION rule — "what happens per tick". As algebra
;;;    folds meaning, rule unfolds the next moment. Here: "leaf keeps filling".
(defun rule-fill () (invoke (branch 'Leaf) 'fill))

;;; ── to-future — anamorphism FORWARD (dual of `to-past`) ──────────
;;;  Unfold of the future over the time functor T(X)=Moment×Maybe(X).
;;;  [rigorous] — the unfold mechanism; present is NOT touched (we work on
;;;               a frozen snapshot, restore after). Proven by count.
;;;  [informal] — this is expected-by-a-rule, not fact; each moment is
;;;               marked :prediction, so it's not confused with the real past.
;;;  Run: (demo-future) — 3 predicted ticks + present intact.
;;; ──────────────────────────────────────────────────────────────────
(defun to-future (rule d)
  (let ((snapshot (let ((*print-readably* nil) (*print-length* nil)
                      (*print-level* nil))
                  (prin1-to-string (fold))))    ; freeze the PRESENT
        (preds nil))
    (dotimes (i d)
      (funcall rule)                             ; expected step forward
      (push (list :tick (+ *clock* i 1) :status :prediction
                  :life (meaning-life))
            preds))
    (sprout (let ((*read-eval* nil))              ; RESTORE the present
                (read-from-string snapshot)))         ; future didn't corrupt reality
    (nreverse preds)))

;;; ── DEMO: past recorded, future unfolded, present intact ──
(defun demo-future ()
  (setf *timeline* nil *clock* 0)
  (grow-tree)
  (dotimes (i 2) (invoke (branch 'Leaf) 'fill) (imprint)) ; 2 real moments
  (format t "~&═══ TIME AXIS · PAST ↔ FUTURE ═══~%~%")
  (let ((life-before (meaning-life)))
    (format t "PAST (recorded, real): moments ~a~%"
            (to-past (car *timeline*) 10))
    (format t "PRESENT: life=~a~%~%" life-before)
    (format t "FUTURE (unfolded by rule, [informal] — expectation, not fact):~%")
    (dolist (p (to-future #'rule-fill 3))
      (format t "  tick ~a: life=~a  ~a~%"
              (getf p :tick) (getf p :life) (getf p :status)))
    (let ((life-after (meaning-life)))
      (format t "~%PRESENT after unfolding the future: life=~a~%" life-after)
      (format t "reality intact: ~:[✗ CORRUPTED~;✔ present untouched~] (~a=~a)~%"
              (= life-before life-after) life-before life-after)))
  (format t "~%Past — what WAS (snapshots). Future — what CAN be~%")
  (format t "(unfold of a rule). One axis, two directions, honestly separated.~%"))

(demo-future)