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
<[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
