Pepe,
The specification for the first puzzle is still a bit ambiguous, because:
> the equivalence fails because the execution of
> sentences involving (Ca f p g) break down when
> applied to (meaningful) identical arguments
Can apply equally to the cases I was trying to distinguish:
(1) a difference .. in the /output/ of these two verbs when applied
to identical arguments
(2) show differences in products /derived/ from these two
("identical") verbs
Both cases are "sentences involving (the constructs in question)" and both
involve application to "(meaningful) identical arguments". In the latter
case, the "(meaningful) identical arguments" are, in fact, the constructs in
question.
Let me put it a different way: must I find a combination of f g x y such
that ( (Ca f p g) y ) -: ( ([: f g) y ) or ( x (Ca f p g) y ) -: ( x
([: f g) y ) does not result in a 1? Or am I allowed sneakier tactics? An
example of the kind of sneaky tactic I'm considering is given in the
postscript (after some spaces to hide the spoilers).
I've also given a potential solution to the second puzzle, depending on the
definition of "the interpreter" or how it "favors" things. In particular,
whether "favoring" requires that the interpreter generate code involving @
(instead of [: ) of arbitrary complexity, or whether simply producing a @
(instead of [:) without my asking for it suffices (meaning, the number of
cases I can provoke is finite).
For euphony, I've made this first pair of solutions "rhyme".
-Dan
PS: I noticed your original "(This is a tricky puzzle thought)", and felt
it was hinting at something, but haven't grasped what.
**SPOILERS BELOW HERE**
With Ca =. [ and p =. @] is (Ca #:p +:) "identical" to ([: #: +:) ?
([: #: +:) b. _1
[: -: #.
(Ca #:p +:) b. _1
|domain error
| (Ca#:p+:)b._1
+/&.([: #: +:) 1 2 3
6
+/&.(Ca #:p +:) 1 2 3
|domain error
| +/&.(Ca#:p+:)1 2 3
Does the interpreter ever favor @ or @: over [: ?
2&#. b. _1
($&2@>:@(2&(<.@^.))@(1&>.)@(>./)@:|@, #: ]) :.(2&#.)
'@ @: [:' e.&;: 2&#. b. _1
1 1 0
+/"1 '@ @: [:' =/&;: 2&#. b. _1
6 1 0
Using this approach, I am inclined to take up Henry's usage and name the
interpreter "Roger", because it feels more to me like these results convey
the preferences of the man Roger, who hand-rolled particular inverses, than
the machine J, which automatically generates the [:s from 13 : . Though
perhaps there are ways to induce the interpreter to use @ instead of [: when
(automatically) generating inverses of compound verbs. Hmm....
Anyway, are these solutions on the right tracks?
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm
