PocketLearn

Symbolic cognitive architecture: XML + XSLT + ILP + ASP + FORTH. Zero Python.

Learn = build a visible theory.

Neural net: learn = adjust W -= lr * grad. Knowledge disappears into numbers you can't read.

This: learn = build a visible theory.

---

What it does

sample_corpus.txt
      |
      v
corpus_tokens.xml          (tokenizer — 69 tokens, 52 vocab)
      |
      v
ontology.xml               (seed concepts: stack_op, compiler_word, meta_word...)
      |
      +--[XSLT]----------> background.pl          (Prolog co-occurrence facts)
      |
      +--[XSLT]----------> ontology_induction_generated.pl   (ILP engine, GENERATED by XSLT)
                                    |
                                    v
                             swipl learns rules:
                             Induced: is_a(W, stack_op) :- cooccur(W, 'drop'). F1=0.60
                             Propose: include should be is_a(stack_op) cnt=1
                                    |
                                    v
                           ontology_induced.xml    (updated ontology with induced members)
                                    |
                     +------[XSLT]-+------[XSLT]--+
                     |                            |
                     v                            v
             ASP validation               generated_corpus_induced.fth
             clingo rejects               gforth runs the learned dictionary
             contradictions
             (dup = stack_op AND
              compiler_word -> UNSAT)

The meta-trick: ontology_to_induction.xslt generates the Prolog ILP engine from ontology.xml. So the whole system is self-describing — XSLT generates Prolog that learns rules from XML co-occurrence stats.

---

Run

# Install (Mac)
brew install libxslt swi-prolog clingo gforth

# Install (Linux)
sudo apt install -y xsltproc swi-prolog gringo gforth

# Build — full pipeline
make

# Run the FORTH (pre-built, no deps needed)
make demo-prebuilt

---

What you get

make
# [3/7] ILP engine via XSLT
# [4/7] ILP Induction
# Induced: is_a(W, stack_op)       :- cooccur(W, 'drop').       F1=0.60
# Induced: is_a(W, compiler_word)  :- cooccur(W, 'semicolon').  F1=0.75
# Induced: is_a(W, learning_word)  :- cooccur(W, 'statistical'). F1=0.80
# Proposing: include  should be is_a(stack_op)      (cooccurs with 'drop')
# Proposing: defined  should be is_a(compiler_word) (cooccurs with 'semicolon')
# Proposing: similarity should be is_a(learning_word)
# [5/7] ASP: SATISFIABLE
# [6/7] FORTH written

make demo
# PocketLearn FORTH — seed + ILP-induced vocab
# vocab size: 18
# Induced: include (by drop), defined (by semicolon), similarity (by statistical)

---

Files

File	Role
sample_corpus.txt	Input text
corpus_tokens.xml	Tokenized corpus (XML)
ontology.xml	Seed concepts with members + co-occurrence strengths
ontology_induced.xml	Output ontology with ILP-induced members
corpus_to_background.xslt	XML → Prolog co-occurrence facts
ontology_to_induction.xslt	Generates the Prolog ILP engine from ontology.xml
ontology_to_asp.xslt	XML → ASP validation facts
corpus_to_forth.xslt	XML → FORTH dictionary
ontology_induction_generated.pl	ILP engine (XSLT output) — run with swipl
generated_corpus_induced.fth	Final FORTH (seed + induced) — run with gforth
ontology.asp	ASP contradiction rules
Makefile	Full pipeline

---

Why this instead of a transformer

	Transformer	PocketLearn
Inspectable	No — weights are numbers	Yes — open ontology_induced.xml
Reproducible	No — depends on random seed	Yes — same XML = same FORTH, bit-for-bit
Debuggable	No	Yes — stack blow → trace to corpus_tokens.xml line → XSLT template
Hallucinates	Yes — dup = delete possible	No — ASP kills contradictions
Learns deep semantics	Yes	No

It won't discover deep semantics. It will never hallucinate dup = delete because ASP kills it.

---

Ahmad Ali Parr · Bel Esprit D'Accord Irrevocable Trust · EIN 42-697643

Omega = TRUST AND CODE