[Jprogramming] Trains: past, present and ...
Jose Mario Quintana
jose.mario.quintana at gmail.com
Fri Oct 20 21:53:17 UTC 2017
No, a2 is defined previously; recall "beware of line-wrapping."
In addition, what I showed was a session output, not a clean script. If
your email formatting is giving you a hard time, try to look at the version
of my post in the forum archive.
I hope it helps
On Thu, Oct 19, 2017 at 8:31 PM, Raul Miller <rauldmiller at gmail.com> wrote:
> When I try to execute your script, I get:
>
> |value error: a2
> | (a0=.`'')(a1=.(@:[)((<'&')`)(`:6))(a2=.(`(<(":0);_))(`:6))(
> (`'')(((@:[)(&`))(`:6)))((`_)(`:6))av=.((ar'a0')`)(`(ar'a1'))(`(
> ar'a2'))(`:6)
> |[-3] /users/rauldmiller/j64-805-user/temp/2.ijs
> 9!:14''
> j805/j64/darwin/beta-9/commercial/www.jsoftware.com/2016-07-05T17:11:06
>
> And, indeed, it does look like you are referring to ar'a2' before
> you define a2.
>
> Thanks,
>
> --
> Raul
>
>
> On Thu, Oct 19, 2017 at 8:21 PM, Jose Mario Quintana
> <jose.mario.quintana at gmail.com> 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 at 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-Septembe
> r/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-Septembe
> r/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
More information about the Programming
mailing list