Running Rubi in LISP (with Richard Fateman's MockMMA)

[stblake]

I was wondering if a subset of the Rubi rules that do not rely heavily on the internal details of PossibleZeroQ, N, Simplify, etc will run in LISP with MockMMA?

I could never get MockMMA to run in SBCL (although this was many years ago).

[rfateman]

MockMMA was written and tested in Allegro Common Lisp, circa 1992. It seems to have been used some here and there; I see at least
2 projects on Github. There are really 2 parts to Sam's question. Here are my answers:

1. I recall reading Rubi files (algebraic stuff) in to MockMMA without problems. I did not try to run them, but I expect that some of them would run just fine, given that they consist of pattern --> replacement. Additional ones should work if PossibleZeroQ were defined. Some would not work because they rely on more elaborate predicates or transformations.
2. What about SBCL? Incompatibilities between "Common Lisp Standard" implementations crop up sometimes. One is treatment of UPPER and lower case. The CL standards committee, for historical reasons and incidentally against my advice, decided to map all cases to one. Thus Plus became PLUS. To retain cases, and more recently to expand the character set far beyond ASCII, one must go outside the standard. Allegro and SBCL took different turns. I know of one other possible glitch, a program called ucons, which is defined in one file within the standard, but more efficiently in Allegro outside the standard. It involves hashtable optimization. What ucons does is a "unique" cons. [ for non-Lispers, (cons a b) in Lisp constructs a new list x where head of x is a, and rest of x is b...] Ucons differs from regular cons in that it will, if possible, return a pre-existing list structure y equal to x, saving space and possibly future computation time.

If there are specific questions about MockMMA I'll try to answer them; I may try to run this code (23 years old?) in an SBCL, myself.

[rfateman]

One additional comment -- the parser for the "Wolfram Language" (WL) which I wrote in Lisp, can be written easily in WL, which of course already knows how to parse WL. All that is needed is a program that prints it out in Lisp. Mathematica fans will probably be aware that there is a WL program called FullForm which prints A+B as Plus[A,B]. A program I wrote, called LForm for Lisp Form prints A+B as (Plus A B). That's Lisp.
Here is what LForm looks like..

ToStringS[u_]:=ToString[u]<>" "  (* convert u to a string, but add a space on the right *)
LForm[m_Rational] := ToString[Numerator[m]]<> "/"<> ToStringS[Denominator[m]]  (* 3 special edge cases *)
LForm[m_Complex]:=LForm[Re[m]+"I"*Im[m]]
LForm[n_Real]:= LForm[ToString[FortranForm[n]]]
LForm[a_?AtomQ]:=ToStringS[a]
LForm[r_[args___]]:= StringJoin@@{"(",ToStringS[r] , LForm/@ {args},")"} 

(* to read and write whole files of Rubi rules, converting them from WL to Lisp, we do this *)

(* we need inertify to keep SetDelayed from evaluating and then returning Null. courtesy Dan L *)

inertify[expr_Hold] := With[{i1 = inertify1[expr]}, i1 /. Hold -> Identity]

inertify1[expr_Hold] := Module[{xx},
  xx[Release[expr /. (f_Symbol /; f =!= Hold && f =!= HoldAll) :> ToString[f]]] /. xx -> Hold]

   (* How it works: we would iterate through all the files. example of one file *)
			       
( infile =OpenRead["d:/rubi1222.m"]  (*some rubi.m file*);
 outfile=  OpenWrite["d:/lisp/rubi1222.lisp"] (*that file in Lisp *);
(WriteString[outfile,LForm[inertify/@ ReadList[infile,Hold[Expression]]]];
       Close[infile]; Close[outfile])

Sample input...

first line of the .m file
Int[x_(a_ + b_.x_^2 + c_.x_^4)^p_., x_Symbol] := 1/2Subst[Int[(a + bx + cx^2)^p, x], x, x^2] /; FreeQ[{a, b, c, p}, x]

first line of the .lisp file [omitting a "(List" at the top of the file, and reformatting for indentation...]

(SetDelayed
  (Int (Times (Pattern x (Blank ))
	      (Power (Plus (Pattern a (Blank ))
			   (Times (Optional (Pattern b (Blank )))
				  (Power (Pattern x (Blank ))2 ))
			   (Times (Optional (Pattern c (Blank )))
				  (Power (Pattern x (Blank ))4 )))
		     (Optional (Pattern p (Blank )))))
       (Pattern x (Blank Symbol )))
  (Condition (Times (Times 1 (Power 2 -1 ))
		    (Subst
		     (Int (Power (Plus a (Times b x )
				       (Times c (Power x 2 )))p )
			  x )
		     x
		     (Power x 2 )))
	     (FreeQ (List a b c p )x )))