A (firsthand) background note here, that Ken & Eugene were flying together to APL88 in Sydney (with their wives, so it was Ken & Jean and Eugene & Jeanne).
They switched their seats and sat together and chatted and ended up having little sleep for the 16 hours trans pacific flight. Their discussions led to the epiphany (Ken’s word to me on landing) of verb trains. I met him at the airport and he was (surprisingly) quite excited and alert and excitedly started to describe how the verb trains for function composition and showed me some paper of the simplicity of their concept. I recall they had just focused on trains of length 2 (a hook) and 3 (a fork) but had not yet reached agreement on the implementation of longer trains. Ken said they would save that for their return flight, and they did. …/Regards Rob > On 20 Oct 2017, at 11:21 am, Jose Mario Quintana > <[email protected]> wrote: > > There were many adverb and conjunction producing trains during a period > which Henry has referred as the Golden Age. Some were available as early > as 1993 [0] and several more afterward [1]. A few of those adverb > producing trains (all of them bidents) survived [2] (using nv to denote > noun or verb), > > " > x (a1 a2) is x a1 a2 > x (c nv) is x c nv > x (nv c) is nv c x > " > > but none of the conjunction producing trains did. Nevertheless, I learned > to appreciate very much two of them (a trident and a bident), together with > the survivors, many years after they were decommissioned, > > " > x (a1 c2 a3) y is (x a1) c2 (y a3) > ... > x (c a) y is (x c y) a > " > > I hope mentioning old versions of J does not provoke a wild-goose chase ;) > > Remarkably, the adverb producing train survivors are sufficient to allow > for complete adverbial programming in the following sense: if the desired > entity (a noun, verb, adverb or conjunction), to be produced, can be > computed from the adverb's argument then there is a (pure) tacit adverb > able to do so (even compliantly; that is, the hard way, without using any > black magic). > > How come? There are several ways to show how this can be done; the J > sentences further down define a (Curried) adverb hg which can define an > arbitrary adverb t as follows, > > t=. v hg > > hg acts on a (presumably pure tacit) workhorse verb v and produces the > required adverb (t). The workhorse verb acts on the atomic representation > of t's argument and should produce the atomic representation (or similar) > of the desired entity; finally, hg evokes (`:6) it. Since (at least, in > principle) one can go back and forth between the atomic representations and > the entities they represent, tacit adverbial programming is reduced to > tacit verbal programming and the latter is Turing complete [3, 4]. > > The adverb hg can be defined as follows (no agendas are used, which some > members might find too cryptic), beware of line-wrapping, > > 9!:14'' > j805/j64/windows/release/commercial/www.jsoftware.com/2016-12-11T08:02:16 > > o=. @: > ar=. 5!:1@:< > > (a0=. `'') (a1=. (@:[) ((<'&')`) (`:6)) (a2=. (`(<(":0);_)) (`:6)) > ((`'')(((@:[)(&`))(`:6)))((`_)(`:6)) > av=. ((ar'a0')`) (`(ar'a1')) (`(ar'a2') ) (`:6) > NB. Adverbing a monadic verb (adv) > assert 1 4 9 -: 1 2 3 *: av > > aw=. < o ((0;1;0)&{::) NB. Fetching the atomic representation > a3=. (@: (aw f.)) ('av'f.) > a4=. "_ > a5=. `:6 > a6=. ((( ar'a4') ; ] ; ( ar'a3')"_) ('av'f.)) (`:6) > > hg=. `((ar'a6')`(ar'a5')) (`:6) > assert 1 4 9 -: 1 2 3 ((<'*:') ; ]) hg > > erase'a0 a1 a2 a3 a4 a5 a6 ar av aw' > 1 1 1 1 1 1 1 1 1 1 > > The adverb hg is tacit and it is fixed. Once it is defined one does not > have to know or remember how it works to use it (that was the main point > for defining it in the first place). > > The verb an is convenient to use together with hg for development (because > it neutralizes the hg ending adverb evoke (`:6)) > > an=. <@:((,'0') (,&<) ]) NB. Atomizing words (monadic verb) > > For example, assume one wants an adverb t to act on a gerund, representing > two verbs (say, u and v) u`v, and produce the verb v@u; thus one needs a > workhorse verb to produce, > > v@:u an hg > ┌──────────┐ > │┌──┬─────┐│ > ││@:│┌─┬─┐││ > ││ ││v│u│││ > ││ │└─┴─┘││ > │└──┴─────┘│ > └──────────┘ > > acting on, > > (u`v) an hg > ┌─────────┐ > │┌─┬─────┐│ > ││0│┌─┬─┐││ > ││ ││u│v│││ > ││ │└─┴─┘││ > │└─┴─────┘│ > └─────────┘ > > Therefore, given that, > > (u`v) an o (< o ((('@:') ; < o |.)) o (('';1)&{::)) hg > ┌──────────┐ > │┌──┬─────┐│ > ││@:│┌─┬─┐││ > ││ ││v│u│││ > ││ │└─┴─┘││ > │└──┴─────┘│ > └──────────┘ > > the adverb t can be defined as, > > t=. < o ((('@:') ; < o |.)) o (('';1)&{::) hg > > (u`v)t > v@:u > > Let us entertain a more general version of t taking a gerund representing a > (variable) number of verbs, the atomic representation of a sample argument > u0`u1`u2`u3`u4 (extra parentheses used again for clarity) is, > > (u0`u1`u2`u3`u4) an hg > ┌────────────────────┐ > │┌─┬────────────────┐│ > ││0│┌──┬──┬──┬──┬──┐││ > ││ ││u0│u1│u2│u3│u4│││ > ││ │└──┴──┴──┴──┴──┘││ > │└─┴────────────────┘│ > └────────────────────┘ > > and the atomic representation of the product u0@:u1@:u2@:u3@:u4 is, > > (u0@:u1@:u2@:u3@:u4) an hg > ┌──────────────────────────────────────────┐ > │┌──┬─────────────────────────────────────┐│ > ││@:│┌────────────────────────────────┬──┐││ > ││ ││┌──┬───────────────────────────┐│u4│││ > ││ │││@:│┌──────────────────────┬──┐││ │││ > ││ │││ ││┌──┬─────────────────┐│u3│││ │││ > ││ │││ │││@:│┌────────────┬──┐││ │││ │││ > ││ │││ │││ ││┌──┬───────┐│u2│││ │││ │││ > ││ │││ │││ │││@:│┌──┬──┐││ │││ │││ │││ > ││ │││ │││ │││ ││u0│u1│││ │││ │││ │││ > ││ │││ │││ │││ │└──┴──┘││ │││ │││ │││ > ││ │││ │││ ││└──┴───────┘│ │││ │││ │││ > ││ │││ │││ │└────────────┴──┘││ │││ │││ > ││ │││ ││└──┴─────────────────┘│ │││ │││ > ││ │││ │└──────────────────────┴──┘││ │││ > ││ ││└──┴───────────────────────────┘│ │││ > ││ │└────────────────────────────────┴──┘││ > │└──┴─────────────────────────────────────┘│ > └──────────────────────────────────────────┘ > > Now, that seems to be messy but it does not have to be (hint: producing the > atomic representation is not necessary, as long as the entity can be evoked > correctly). A solution of this type is shown near the end of this post. > > While currently, tacit adverbial programming is complete, tacit > conjunctional programming is, alas, virtually zip. Nevertheless, let us > have a thought experiment: what would happen if the two conjunction > producing trains I mentioned above had survived? Would conjunctional > programming be complete in the same sense in which tacit adverbial > programming is? The answer is yes. > > How come? Because then tacit conjunctional programming could be reduced to > tacit adverbial programming. Assume, for example, that a conjunction acts > on a noun and a verb, say 1 2 3 4 and +/, then > > 1 2 3 4 ((an f.hg) (` (an o ((('';1)&{::))hg))(an f.hg)) (+/) > ┌───────────┬───────┐ > │┌─┬───────┐│┌─┬───┐│ > ││0│1 2 3 4│││/│┌─┐││ > │└─┴───────┘││ ││+│││ > │ ││ │└─┘││ > │ │└─┴───┘│ > └───────────┴───────┘ > > Therefore, one can replace the verb an by a workhorse verb v acting on the > above gerund to produce whatever is desired, for example, if one wants the > right-hand verb argument to act on the left-hand side argument we could > simply define the conjunction as follows, > > t=. ((an f.hg) (` (|. o ((('';1)&{::))hg)) (an f.hg)) > > 1 2 3 4 t (+/) > 10 > > 'boxed' t < > ┌─────┐ > │boxed│ > └─────┘ > > type't' > ┌───────────┐ > │conjunction│ > └───────────┘ > > In general, an arbitrary conjunction could be defined as, > > > t=. (an f.hg) (` (v o ((('';1)&{::))hg)) (an f.hg) > > where v is the workhorse verb. For the common case where the two arguments > are verbs, > > t=. ` (v o ((('';1)&{::))hg) > > would be sufficient. > > The 1993 version J is unable to successfully define hg because, although > evoke (`:6) supported gerunds representing lists of verbs, it did not have > the extended functionality for hg to be able to work; that was added > later. I am not sure if the late versions of the interpreters of the > Golden Age can reproduce all the above. > > However, the above is not quite a pure thought experiment. It reflects a > Jx session (Jx is a fork of J that provides some extensions [5]). (Jx does > not require the conjunction producing trains to make tacit conjunctional > programming complete because it provides an alternative way to produce > arbitrary conjunctions; there are there because they are useful and I > personally consider any tiny performance penalty, due to restoring a > trident entry in the parse table, as a well-deserved tribute to them.) > > Could they find their way back to official interpreters? I do not think > so. Yet, complete conjunctional tacit programming could be provided without > having to restore any trident (apart from the fork trident which is > special). How come? I could give an outline on how this could be > implemented but this post is already way too long and I wonder how many > members could still be reading it at this point. > > However, before I forget, just in case someone wants to see it... > > The more general adverb t can be obtained easily: since, > > (u0`u1`u2`u3`u4) an o (([ , (<'@:') , ])/o |. o (('';1)&{::))hg > ┌──┬──┬──┬──┬──┬──┬──┬──┬──┐ > │u4│@:│u3│@:│u2│@:│u1│@:│u0│ > └──┴──┴──┴──┴──┴──┴──┴──┴──┘ > > then t can be defined as, > > t=. ([ , (<'@:') , ])/o |. o (('';1)&{::)hg > > u0`u1`u2`u3`u4`u5`u6 t > u6@:u5@:u4@:u3@:u2@:u1@:u0 > > *:`(+/)`-`j.`(^ %:)t 1 2 3 > 2.40034j16.7123 > > PS. My plans for sending a version of this post during the weekend were > crushed because I was too busy (oversleeping, watching dance performances, > eating out, swimming, watching boxing, football, etc. :) > > > References > > [0] [Jprogramming] Tacit Expressions with Explicit J Syntax roger stokes > > http://www.jsoftware.com/pipermail/programming/2017-September/048917.html > > [1] [Jprogramming] Jx 1.1 Release neitzel > http://www.jsoftware.com/pipermail/programming/2017-October/049177.html > > [2] [Jprogramming] Jx 1.1 Release neitzel > http://www.jsoftware.com/pipermail/programming/2017-October/049179.html > > [3] Universal Turing machine (J) > https://rosettacode.org/wiki/Universal_Turing_machine#J > > [4] Jforum: A Tacit Implementation of a Turing Machine > http://www.jsoftware.com/pipermail/general/1999-December/002736.html > > [5] [Jprogramming] Jx 1.1 Release Jose Mario Quintana > > http://www.jsoftware.com/pipermail/programming/2017-September/048957.html > ---------------------------------------------------------------------- > For information about J forums see http://www.jsoftware.com/forums.htm ---------------------------------------------------------------------- For information about J forums see http://www.jsoftware.com/forums.htm
