Jean Louis <b...@static.rcdrun.com> writes:

> * Van Ly via Emacs news and miscellaneous discussions outside the scope of 
> other Emacs mailing lists <emacs-tangents@gnu.org> [2025-04-04 16:17]:
>> > Though maybe you think of consciousness in some other definition.
>> 
>> Natural philosophy science of the mind in 8-bit atari graphic resolution 
>> simulcrom.
>
> You missed a verb! But you are good at generating random words, almost like 
> SmolLM2-135M-Instruct.
>

I was surfacing a thought and those words spilled out without a verb.  To my 
mind that works for picture captions.  Lately, I have been thinking of 
ultraweak biophotons at industrial scale of Gigaphoton.  What's on your mind 
when you engage in this thread?  Cheeky monkey?

>> So, the Starliner had 28 thrusters and 4 failed leaving no failover coverage 
>> remaining.
>
> (defun check-coherence (sentence)
>   "Check if the given SENTENCE is coherent."
>   (let* ((words (split-string sentence "\\s-+"))
>          (has-subject (catch 'found
>                         (dolist (word words)
>                           (when (string-match-p "\\b[[:alpha:]]+\\b" word)
>                             (throw 'found t)))))
>          (has-verb (catch 'found
>                      (dolist (word words)
>                        (when (string-match-p 
> "\\b\\(had\\|failed\\|leaving\\)\\b" word)
>                          (throw 'found t)))))
>          (has-object (catch 'found
>                       (dolist (word words)
>                         (when (string-match-p "\\b[0-9]+\\b" word)
>                           (throw 'found t))))))
>     (if (and has-subject has-verb has-object)
>         "The sentence is coherent."
>       "The sentence is not coherent.")))
>
> ;; Example usage
> (check-coherence "The Starliner had 28 thrusters and 4 failed leaving no 
> failover coverage remaining.")
>
> Happy now?
>

*shrug*  Is it possible to see the compacted lisp syntax in circuit diagram and 
explode out the details where wanted?  At bottom would be nor logic gates?

>> Maybe, 8✕1 serial and 8✕4 parallel p‑nodes are needed for Starship ITS AI 
>> and the Tenstorrent RISC-V hardware will do for modernizing the Cray-1 
>> general purpose open free architecture.
>
> Well, let's verify it:
>
> (defun check-coherence (sentence)
>   "Check if the given SENTENCE is coherent."
>   (let* ((words (split-string sentence "\\s-+"))
>          (has-subject (catch 'found
>                         (dolist (word words)
>                           (when (string-match-p "\\b[[:alpha:]]+\\b" word)
>                             (throw 'found t)))))
>          (has-verb (catch 'found
>                      (dolist (word words)
>                        (when (string-match-p 
> "\\b\\(are\\|needed\\|will\\|do\\)\\b" word)
>                          (throw 'found t)))))
>          (has-object (catch 'found
>                       (dolist (word words)
>                         (when (string-match-p "\\b[0-9]+\\b" word)
>                           (throw 'found t)))))
>          (has-technical-terms (catch 'found
>                                 (dolist (word words)
>                                   (when (string-match-p 
> "\\b\\(p-nodes\\|Tenstorrent\\|RISC-V\\|Cray-1\\)\\b" word)
>                                     (throw 'found t)))))
>          (logical-coherence (string-match-p "\\bfor\\b" sentence)))
>     (if (and has-subject has-verb has-object has-technical-terms 
> logical-coherence)
>         (if (string-match-p 
> "\\b\\(Starship\\|ITS\\|AI\\|modernizing\\|general\\-purpose\\|open\\|free\\|architecture\\)\\b"
>  sentence)
>             "The sentence is not coherent. It lacks logical sense and 
> functionality."
>           "The sentence is not coherent. It lacks logical sense and 
> functionality.")
>       "The sentence is not coherent. It lacks logical sense and 
> functionality.")))
>
> ;; Example usage
> (check-coherence "Maybe, 8✕1 serial and 8✕4 parallel p-nodes are needed for 
> Starship ITS AI and the Tenstorrent RISC-V hardware will do for modernizing 
> the Cray-1 general purpose open free architecture.")
>

*shrug*  So, an ideal architecture would combine cpu, gpu, qpu.  SoTA is 100 
error corrected logical qubits and to be useful 1 million are imagined needed.

>> Do Linuxheads make jokes at the expense of Plan 9?  Why is that?
>
> Seems more effort to solve that one...
>
> (defun check-gnu-jokes (sentence)
>   "Check if the given SENTENCE is coherent and determine if GNU Users make 
> jokes on Linuxheads and Plan 9."
>   (let* ((words (split-string sentence "\\s-+"))
>          (has-gnu (catch 'found
>                     (dolist (word words)
>                       (when (string-match-p "\\bGNU\\b" word)
>                         (throw 'found t)))))
>          (has-linuxheads (catch 'found
>                            (dolist (word words)
>                              (when (string-match-p "\\bLinuxheads\\b" word)
>                                (throw 'found t)))))
>          (has-plan9 (catch 'found
>                       (dolist (word words)
>                         (when (string-match-p "\\bPlan\\s-?9\\b" word)
>                           (throw 'found t)))))
>          (has-jokes (catch 'found
>                       (dolist (word words)
>                         (when (string-match-p "\\bjokes\\b" word)
>                           (throw 'found t)))))
>          (has-together (catch 'found
>                          (dolist (word words)
>                            (when (string-match-p "\\btogether\\b" word)
>                              (throw 'found t)))))
>          (logical-coherence (and has-gnu has-linuxheads has-plan9 has-jokes 
> has-together)))
>     (if logical-coherence
>         "GNU Users make jokes on Linuxheads and Plan 9 together."
>       "The sentence is not coherent. It does not indicate that GNU Users make 
> jokes on Linuxheads and Plan 9 together.")))
>
> ;; Example usage
> (check-gnu-jokes "GNU Users make jokes on Linuxheads and Plan 9 together.")
>

*shrug*  Meta cognition and reasoning may have been available the last 50 
thousand years and written language the last 5 thousand years.

> --- --- --- --- --- --- --- --- --- --- --- --- --- --- --- 
>
>> Can your code snippet be represented in a 512-bit vectorframe?  To what 
>> extent are the number of bits needed for context?
>
> Let me turn against myself:
>
> (defun mock-user (code-snippet)
>   "Mock the user by indicating that the CODE-SNIPPET cannot be represented in 
> a 512-bit vector frame."
>   (let* ((code-length (length code-snippet))
>          (bits-needed (* code-length 8))) ; Assuming 8 bits per character
>     (if (> bits-needed 512)
>         (format "Ha! Your code snippet is %d bits long, way more than 512 
> bits! Clearly, you need a much larger vector frame. And don't even get me 
> started on the context..." bits-needed)
>       (format "Well, your code snippet is only %d bits long, which is less 
> than 512 bits. But who needs context anyway? Ha!" bits-needed))))
>
> ;; Example usage
> (mock-user "(defun check-gnu-jokes (sentence)
>   \"Check if the given SENTENCE is coherent and determine if GNU Users make 
> jokes on Linuxheads and Plan 9.\"
>   (let* ((words (split-string sentence \"\\s-+\"))
>          (has-gnu (catch 'found
>                     (dolist (word words)
>                       (when (string-match-p \"\\bGNU\\b\" word)
>                         (throw 'found t)))))
>          (has-linuxheads (catch 'found
>                            (dolist (word words)
>                              (when (string-match-p \"\\bLinuxheads\\b\" word)
>                                (throw 'found t)))))
>          (has-plan9 (catch 'found
>                       (dolist (word words)
>                         (when (string-match-p \"\\bPlan\\s-?9\\b\" word)
>                           (throw 'found t)))))
>          (has-jokes (catch 'found
>                       (dolist (word words)
>                         (when (string-match-p \"\\bjokes\\b\" word)
>                           (throw 'found t)))))
>          (has-together (catch 'found
>                          (dolist (word words)
>                            (when (string-match-p \"\\btogether\\b\" word)
>                              (throw 'found t)))))
>          (logical-coherence (and has-gnu has-linuxheads has-plan9 has-jokes 
> has-together)))
>     (if logical-coherence
>         \"GNU Users make jokes on Linuxheads and Plan 9 together.\"
>       \"The sentence is not coherent. It does not indicate that GNU Users 
> make jokes on Linuxheads and Plan 9 together.\")))") ➜ "Ha! Your code snippet 
> is 11760 bits long, way more than 512 bits! Clearly, you need a much larger 
> vector frame. And don't even get me started on the context..."
>

*shrug*  So, I am thinking this.  Can the Rubik's cube puzzle be encoded and 
solved by bit representations confined to the microchip registers and cache 
lines.  The state vector and transform rule set would all be on microchip.

Grok3 tells me at bottom 1 bit is sustained by 6 transistors.  Do you think 
there is anything to be gained by having transistors directly modeling 
pyramidal neurons?  One estimate suggests the microtubule may have capacity for 
1gb memory and that is without biophotons.

>> You are trying to be funny or macabre, or both.  But you are not.
>
> I now how to counter that one:
>
> (defun sarcastic-response (comment)
>   "Respond sarcastically to the given COMMENT."
>   (let ((response ""))
>     (cond
>      ((string-match-p "\\bfunny\\b" comment)
>       (setq response "Ah, I see. So you think humor is not my forte. Well, 
> let's try again: Why was the math book sad? Because it had too many problems. 
> Ha ha!"))
>      ((string-match-p "\\bmacabre\\b" comment)
>       (setq response "Oh, you prefer macabre, do you? Well, let's see: Why 
> did the scarecrow win an award? Because he was outstanding in his field. 
> Spooky, right?"))
>      ((string-match-p "\\both\\b" comment)
>       (setq response "Both, you say? Interesting. How about this: Why did the 
> tomato turn red? Because it saw the salad dressing. Both funny and macabre, I 
> guess."))
>      (t
>       (setq response "Well, if you don't like my attempts at humor or 
> macabre, perhaps you'd prefer a technical explanation of the universe. But 
> that's a bit dry, isn't it?")))
>     response))
>
> ;; Example usage
> (sarcastic-response "You are trying to be funny or macabre, or both. But you 
> are not.")
>

*shrug*  Happy days.  Starship goes to Mars 2026Q4.  What will passengers on a 
9 month journey write on their Emacs with AI?



-- 
vl

---
via emacs-tangents mailing list 
(https://lists.gnu.org/mailman/listinfo/emacs-tangents)
  • ... Van Ly via Emacs news and miscellaneous discussions outside the scope of other Emacs mailing lists
  • ... Jean Louis
  • ... Van Ly via Emacs news and miscellaneous discussions outside the scope of other Emacs mailing lists
  • ... Jean Louis
  • ... Van Ly via Emacs news and miscellaneous discussions outside the scope of other Emacs mailing lists
  • ... Jean Louis
  • ... Van Ly via Emacs news and miscellaneous discussions outside the scope of other Emacs mailing lists
  • ... Jean Louis
  • ... Van Ly via Emacs news and miscellaneous discussions outside the scope of other Emacs mailing lists
  • ... Jean Louis
  • ... Van Ly via Emacs news and miscellaneous discussions outside the scope of other Emacs mailing lists
  • ... Jean Louis
  • ... Jean Louis

Reply via email to