Re: unboxed structure fields (or class slots)

I don’t see a path to feedback training of Perceptron networks, with any layer depth. Training is by back propagation of training answers versus training inputs, and requires gobs of iterations, since the training weight of any one iteration remains very small.

I have always seen Perceptron NNs as very weak solvers/classifiers. Each Perceptron becomes gradually trained to see a hyperplane partitioning its space into two subspaces. Overlapping (conjuntive / disjunctive ) combinations of these subspaces gradually isolate useful regions of information.

But this iterative training is very inefficient and would essentially ignore any single correction fed back into the system.  So combining a reasoning engine with a NN leaves you at the mercy of the initial training of the NN. The NN itself cannot learn from the output of the combined system.




> On Jan 14, 2026, at 10:28, wojciech.pasieka (as wojciech dot pasieka at ai dot pressiton dot com) (Adrian W. Pasieka) <[email protected]> wrote:
> 
> 
> Here are some ideas for how LispWorks could generate revenue and grow the Lisp community.
> 
> Whoever cracks ARC-AGI-1 through ARC-AGI-3 will upend a trillion-dollar industry.
> Lisp is best placed to do it, thanks to “code is data, data is code.”
> 
> 
> 1) INTRO — another REPL to merge LLMs with symbolic reasoning.
> =============================================================
> https://x.com/SergioPaniego/status/2011099577600950549
> @SergioPaniego New REPL environment in OpenEnv is live!
> 
> Built on the env from the Recursive Language Models paper.
> Inference and post-training ready, it devours long contexts:
> 
>    Run Python in a sandbox
>    Recurse into LMs
>    Probe data in code
>    Return the answer
> =====================
> 
> 
> 2) To achieve true success, Inductive Logic Programming (ILP) is essential. 
> That needs a Lisp REPL, whose Condition System talks to the LLMs.
> 
> ILP history:
> https://www.researchgate.net/publication/239059541_The_Synthesis_of_LISP_Programs_from_Examples_A_Survey
> 
> Excerpts:
> Summers   1977 – THESYS learns recursive Lisp from traces
> Biermann  1978 – infers regular Lisp programs from examples
> Kodratoff 1979 – learns Lisp programs from examples
> 
> 
> When asking LLMs for the ILP source code:
> 'Source code is not available. Most of these systems were written in early dialects of LISP (like
> Maclisp, Interlisp, or Lisp 1.5) and resided on mainframe tapes at specific universities (like MIT,
> Stanford, or the University of Paris-Sud).'
> 
> 
> 3) The key question is why LLMs currently fail to solve more complex ILP problems:
> a) Are Neural Networks fundamentally incapable of solving them?
> b) Is there not enough training material (code) available?
> 
> 
> 4)  Bridging Classic Papers with Modern Tools
> ‘SISP = an interactive system that synthesizes functions from examples.’
> https://www.ijcai.org/Proceedings/77-1/Papers/071a.pdf
> 
> Input-Output from the paper:
> '(A B C D E) -> '(E D C B A)
> '(A B C D E) -> '(A X B X C X D X E X)
> '(A B C D E) -> '(A A B B C C D D E E)
> 
> Claude solves it, with some human support.
> 
> 
> 5) Claude gets a final request = the simplest ARC-AGI challenge.
> 
> REQUEST: 'Synthesize a program for these three input-output rules.'
> 
> (DEFPARAMETER input-1  '((((2 2 C) (2 3 C) (2 4 C) (3 2 C) (3 4 C) ....
> (DEFPARAMETER output-1 '((((2 0 C) (2 1 C) (2 2 C) (0 0 F) (0 1 F) ....
> 
> (DEFPARAMETER input-2 ..... etc.
> 
> 
> CLAUDE:
> 'The system will test every candidate and pick the transform-main that nails all three cases!'
> 
> HUMAN REPL CHECK:
> Attempting synthesis from 3 examples…
> ✗ FAILED: No solution found
> 
> 
> NEXT:
> Claude is asked to refine its code and try again.
> 
> 
> CLAUDE:
> 'Multi-label groups must be split into single-label groups first. Let me know if that works!'
> 
> HUMAN REPL CHECK:
> Attempting synthesis from 3 examples…
> ✗ FAILED: No solution found
> 
> 
> SUMMARY:
> a) LLMs are currently "Pseudo-REPLs."
> They simulate logic without a grounded execution environment.
> 
> b) The solution lies in integrating a Lisp REPL and an LLM into a true feedback loop.
> The LispREPL+LLM should iterate autonomously until it finds the correct program synthesis.
> 
> c) Moving from theory to practice:
> LLMs require more training data from "lost" historical codebases.
> This training data must be unified according to Common Lisp standards.
> A unified "symbolic repository" should be curated and hosted on GitHub.
> 
> 
> This is the most viable path to determine, if LLMs can truly reason in ARC-AGI terms.
> If a LispREPL+LLM helps to solve ARC-AGI, it will drive R&D funding back to the Lisp ecosystem.
> 
> 
> Piece of cake.... : )
> 
> https://anokas.substack.com/p/o3-and-arc-agi-the-unsolved-tasks
> 
> 
> -- 
> Kind Regards,
> Adrian W. Pasieka
> 
> 
> 
> From: "Bradford Miller \(as bradford dot w dot miller at gmail dot com\)" <[email protected]>
> Subject: Re: unboxed structure fields (or class slots)
> Date: January 13, 2026 at 11:31:58 MST
> To: David McClain <[email protected]>
> Cc: Yuri Davidovsky <[email protected]>, [email protected]
> Reply-To: Bradford Miller <[email protected]>
> 
> 
> 
> 
>> On Jan 13, 2026, at 12:48 PM, David McClain (as dbm at refined-audiometrics dot com) <[email protected]> wrote:
>> 
>> As I recall, from first encounters with Harlequin Common Lisp, the early AI used “reasoning systems” - forward chaining and backward chaining. HCL offered their add-on Prolog system as well as a forward chaining system. Perceptrons didn’t participate in that realm.
> 
> Yes, I believe the current LispWorks “KnowledgeWorks” product is exactly that. I’ve used it a bit for some projects (given it’s a lot better implemented and supported than my old university code :-), and it’s not a bad system, though I don’t have an enterprise license to use it anymore. Back in the day, there were several commercial expert systems as well and there was a PROLOG for the LispMs too. In fact the Japanese 5th Generation project was centered around building a “PROLOG Machine” though that was a failure as unification introduced too many synchronization points to allow anything but single-thread backtracking.
> 
> I wrote a few reasoning systems myself during my university days, all forward and backward chaining with, e.g., type inference, though these were applied to NLU, not expert systems, but could be considered PROLOG variants (basically, take PROLOG, add a bunch of features to make semantic parsing and pragmatics easier). We also used the system for doing plan recognition, some degree of commonsense reasoning, etc. Early plan recognition was intractable trying to solve with logic, but we later started using other techniques using semantic nets and Dempster-Shafer type approaches to the math. These were all pointed toward expressiveness, not efficiency so wouldn’t be of much interest today. (Higher order logic, why sure! :-)
> 
> Nothing specifically numeric. SNEPS out of SUNY Buffalo had some interesting quantifier support to deal with things like “at least three” IIRC but we didn’t go that route. 
> 
>> 
>> We used Perceptrons starting in the early 90’s for building classifiers and recognizers. And then Kolmogorov showed that a simple feedback PN could be used to model chaotic attractor basins of dimensions equal to the number of input legs. Atmospheric turbulence has a fractal dimension around 7 and that led us to train a multilayer PN’s one long weekend on speckle images, using a DG Eagle, to train a “rubber mirror” for removal of atmospheric scintillation of star images.
> 
> We used to distinguish between “adaptation” and “learning” the latter required inducing actual rules (which could be inspected and hand modified if needed), while the former was mostly to deal with sensor systems and classification. I’m pretty sure our students that were doing that were using basic NNs not Perceptrons though (Perceptrons have no hidden layers).
> 
>> 
>> We also used Probabilistic Neural Networks to build target trackers for search and destroy missions - LIDAR underwater mine detection systems, and EKV Kinetic Kill Vehicles for taking out incoming nuclear warheads.
> 
> I did some work with HRL a dozen or so years back to use first-order logic functions to represent probabilities (e.g. confidence), so you could do probabilistic (adversarial) planning without actually having to deal with the math, after giving up on using MDPs. More qualitative than quantitative. The more interesting part of the research dealt with autoepistemic logic, so the system could reason about what it didn’t know and then create plans to find out to reduce uncertainty.
> 
>> 
>> Early Kohonen (highly interconnected mesh) networks were used for storing knowledge domains. 
>> 
>> LLMs would be another 20-30 years later…
>> 
> 
> 
> _______________________________________________
> Lisp Hug - the mailing list for LispWorks users
> [email protected]
> http://www.lispworks.com/support/lisp-hug.html
> 
>