If Putnam was really a genius I think he would have been able to communicate precisely some of this insight to mere mortals. It seems that he taught the same course during 10 years and that seems time enough to mature a good introduction to his ideas. Being ineffable don't entitle you to being a genius.

What seems clear is that he was in the right moment and with the right people to produce a great theory of the mind, he was thinking about defining the mind as a creator of heuristic for generating inductive rules, that is a very interesting idea, also that seems related to cellular automata and homeostasis, fixed point theory, error recovery and many other ideas that we, with our ability to look back in time, can see are located in their neighborhood. Recently we are using LLMs to produce heuristic or rules to generate python programs to explore proofs or new models, so the gems is still alive.

The field he was interested in it is full of little diamonds waiting for someone to find them, but perhaps he just put his foot in the door without entering (or creating) the field he was trying to envision. It could be that his paper could reveal some intuition that could guide us in a new search for meaning but from this post there is no any hint about that beyond such a desire.

Thank you, this is a nice point to consider. Don't know if using the weights could be considered equivalent or implying accepting the terms of services from weights creators.

Contracts require agreement (a “meeting of the minds”)… if X makes a contract with Google, that contract between Google and X can’t create a contract between Google and Y without Y’s agreement. Of course, Google’s lawyers will do all they can possibly can to make the contract “transitive”, but the problem is contracts fundamentally don’t have the property of transitivity.

Now, if you are aware of a contract between two parties, and you actively and knowingly cooperate with one of them in violating it, you may have some legal liability for that contractual violation even though you weren’t formally party to the contract, but there are limits - if I know you have signed an NDA, and I personally encourage you to send me documents covered by the NDA in violation of it, I may indeed be exposed to legal liability for your NDA violation. But, if we are complete strangers, and you upload NDA-protected documents to a file sharing website, where I stumble upon them and download them - then the legal liability for the NDA violation is all on you, none on me. The owner of the information could still sue me for downloading it under copyright law, but they have no legal recourse against me under contract law (the NDA), because I never had anything to do with the contract, neither directly nor indirectly

If you download a model from the vendor’s website, they can argue you agreed to the contract as a condition of being allowed to make the download. But if you download it from elsewhere, what is the consideration (the thing they are giving you) necessary to make a binding contract? If the content of the download is copyrighted, they can argue the consideration is giving you permission to use their copyrighted work; but if it is an AI model and models are uncopyrightable, they have nothing to give when you download it from somewhere else and hence no basis to claim a contractual relationship

What they’ll sometimes do, is put words in the contract saying that you have to impose the contract on anyone else you redistribute the covered work to. And if you redistribute it in full compliance with those terms, your recipients may find themselves bound by the contract just as you are. But if you fail to impose the contract when redistributing, the recipients escape being bound for it, and the legal liability for that failure is all yours, not theirs

Thanks for such a clear and logical explanation, it is a pleasure to read explanations like this. Anyway, I am always skeptical about how law is applied, sometimes the spirit of the law is bended by the weight of the powerful organizations, perhaps there are some books which explains how the spirit of the law is not applied when powerful organizations are able to tame it.

This is another comment of the author about maxima in the browser from four months ago: I'm experimenting with WASI and the GC extension for WASM, but that's months from today if we speak about complete port (given my time capacity at the moment). Don't know if the gc extension is used in this example.

I was going to ask if maxima (a symbolic computation system) can be implemented in the browser, but it was answered four months ago [1]

[1] https://news.ycombinator.com/item?id=42853528

Do you use maxima? Would you say it's still worth using and learning?

It depends of what you need, but for example for calculus is a nice program. There is also sympy and Wolfram Mathematica. For symbolic computation I think that Mathematica is the strongest then maxima and then sympy, but sympy is based on python and I think it will get stronger. If you need numerical computation then there is octave or matlab or julia.

For symbolic computation there is also Maple (*shudders at the thought*).

Yes, I think it is worth learning. GNU units is worth learning, too. You know these math riddles? You can solve it using GNU units alone. :D

Qalc from libqalculate it's a mini-maxima.

When executing (time (loop for i below (expt 10 8) count t)) it takes a long time, sbcl takes less than a second on this. So not useful when speed is required. More: (time (loop for i below 1000000 count t) takes 7 seconds on my computer, so counting to (exp 10 8) would take 700 seconds, and sbcl do that in 0.1 seconds, so in this example the ratio is 7000 times slower than sbcl.

In SLip: https://lisperator.net/s/slip/

    SL-USER> (time (loop for i below (expt 10 8) count t))
    Evaluation time: 19376ms
    100000000

    SL-USER> (time (loop for i below 1000000 count t))
    Evaluation time: 272ms
    1000000

    SL-USER> (defun fib (n) (if (< n 2) n (+ (fib (- n 1)) (fib (- n 2)))))
    #'FIB
    SL-USER> (time (fib 32))
    Evaluation time: 1601ms
    2178309

These timings are in Firefox; Chromium is almost 2x faster. Also, it doesn't completely freeze the browser in the mean time (we have green threads).

I used to think it's quite slow, but somehow it's much faster than any other posted here. The only Lisp in browser I know to beat SLip (by a large margin) is JSCL, which compiles to JS.

Both slip and jscl takes the same time in my computer: 63 seconds to run the loop.

I can see what happens there in JSCL.. I took a look at

    (disassemble (lambda () (loop for i below (expt 10 8) count t)))

Seems TAGBODY is compiled into a while(true) which sets an exception handler on each iteration. (and then, LOOP macroexpands into a TAGBODY). I don't think there's a better way to do it, BTW — JS is simply not a friendly compilation target. But `try` on each iteration is quite costly, that's most probably the bottleneck here.

Hm, you're right, JSCL seems abnormally slow on this loop (27.5 sec here). SLip consistently takes 19.3 sec. My CPU is rather beefy (Ryzen 9 HX 370). What's your hardware and browser?

But JSCL is much faster on the fib example, that's why I thought it should be generally faster. After all, it compiles to JS.

Bytecodes compiler used in this build from repl is one-pass with very little optimizations, so it is not surprising. Natively compiled code is much faster.

Should it be possible to implement an optimization compiler? so that compiling the code in the web page produces results similar to ECL or sbcl?

With enough code - yes. But not right now. You may precompile to native though.

Solving Queens using J and brute force all permutations.

   randomboard =: 3 : '? (y,y) $ y'
   testsolution =: 4 : 0          NB. solution is a list of columns.
   m =. x
   n =. #x
   solution =. y A. i. n
   regions =.  ({&m) <"1 (i. n) ,. solution
   distinctregions =. n -: # ~. regions
   adjacentregions =. 1 e. |2-/\solution
   distinctregions *  -. adjacentregions
   )
   findsolution =:3 : 0
   board =: y
   ns =. 1 i.~ (board & testsolution)"0 i. !#y
   if. (ns = !#y) do. 'No solution found' 
   else.
 echo 'Solution index is ', ": ns
 ns A. i. #y end.
   )
   
   regions =: 4 : 0
   ({&x) <"1 (i. #x) ,. y
   )
   number2solution =: 4 : 0
   y A. i. #x
   )

   writesolution =: 4 : 0
   board =. x
   sol =.y
   m1 =. m
   n1 =. #x
   count =. 0
   for_a. sol do.
     m1 =. n1 (< count , a) } m1
     count =. count + 1
   end.
   m1
   )
   
   writewithsolution=: 4 : 0
   m1 =: x writesolution y
   (":"1 x) ,. '|' ,. ":"1 m1
   )
   
   m =: randomboard 9
   echo m writewithsolution findsolution m

Solving Queens in J from a novice J programmer:

   randomboard =: 3 : '? (y,y) $ y'
   testsolution =: 4 : 0
   m =. x
   n =. #x
   n -: # ~. ({&m) <"1 (i. n) ,. y A. (i. n)
   )
   findsolution =:3 : 0
   board =: y
   ns =. 1 i.~ (board & testsolution)"0 i. !#y
   if. (ns = !#y) do. 'No solution found' else. ns A. i. #y end.
   )
     
   writesolution =: 4 : 0
   board =. x
   sol =.y
   m1 =. m
   n1 =. #x
   count =. 0
   for_a. sol do.
     m1 =. n1 (< count , a) } m1
     count =. count + 1
   end.
   m1
   )
   
   writewithsolution=: 4 : 0
   m1 =: x writesolution y
   (":"1 x) ,. '|' ,. ":"1 m1
   )
   
   m =: randomboard 9
   echo m writewithsolution findsolution m

      load 'queens.ijs'
   5 2 8 0 3 3 0 5 2|9 2 8 0 3 3 0 5 2
   8 2 3 6 7 7 4 5 1|8 9 3 6 7 7 4 5 1
   6 1 5 8 3 5 8 7 6|6 1 5 9 3 5 8 7 6
   8 4 8 8 7 5 1 1 1|8 4 8 8 9 5 1 1 1
   2 6 7 6 5 4 7 3 1|2 6 7 6 5 4 7 9 1
   6 8 1 4 1 4 3 2 7|6 8 1 4 1 9 3 2 7
   6 0 5 6 5 5 8 5 0|6 0 5 6 5 5 8 5 9
   1 7 5 5 8 1 1 0 1|1 7 5 5 8 1 9 0 1
   8 4 6 2 2 4 6 4 1|8 4 9 2 2 4 6 4 1

Solution in J (a few lines of code from a novice J programmer).

   board =: 3 : '? (y,y) $ y'
   test =: 4 : 0
   m =. x
   n =. #x
   n -: # ~. ({&m) <"1 (i. n) ,. 0 A. (i. n)
   )
   findsol =:3 : 0
   ns =. 1 i.~ (y & test)"0 i. !#y
   if. (ns = !#y) do. 'No solution found'
   else.
   ns A. i. #y
   end.
   )
  
   m =: board 5
   m
   4 4 0 1 1
   3 2 0 1 1
   2 4 1 1 0
   3 2 1 3 4
   2 0 2 2 0
   0 1 2 3 4
   findsol m
   0 1 2 3 4

  echo 'So the solution found is putting the queens   in the diagonal'

I am thinking about developing in Common Lisp a version of J. And this could be a useful library to use with that program.