Skip to main content

history - Why did the Mathematica Language choose term rewriting instead of the Lambda Calculus as its basis?


Now we can see that Church was associated with the Simply Typed Lambda Calculus. Indeed, it seems he explained the Simply Typed Lambda Calculus in order to reduce misunderstanding about the Lambda Calculus.



Now when John McCarthy created Lisp - he based it on the Lambda Calculus. This is by his own admission when he published "Recursive functions of symbolic expressions and their computation by machine, Part I". You can read it here.


Now we know that at the core of Mathematica is a Lisp-like system, but instead of being based purely on the Lambda Calculus, it is based on a term-rewriting system.


Here the author states state:



Mathematica is fundamentally a term rewriting system... a more general concept than the Lambda Calculus behind Lisp.



My question is: Why did the Mathematica Language choose term rewriting instead of the Lambda Calculus as its basis?



Answer



The short answer is that the Mathematica Language did not choose anything. It was Stephen Wolfram back in 1979 when he started working on his own system after he reached the boundaries of Maxima which was his program of choice then.


There is a very interesting talk about this which is called How Mathematica, Wolfram|Alpha & the Wolfram Language Came to Be. In this talk, he described some of the reasons why he designed it the way he did. You might want to watch it from minute 24 when he talks about Algy - the algebraic manipulator which later became SMP and finally Mathematica.



Here is the probably most related part, freely transcribed by myself:



I knew most of the general-purpose Algol-like languages and as well as languages like Lisp and APL and so on at the time, but somehow they didn't seem to capture sort of the things that I wanted my system to do. So I guess what I did was what I learned to do in physics which was I tried to sort of drill down to find kind of the atoms; the primitives of what was going on in all these computations that I wanted to do.


I knew a certain amount about mathematical logic and the history of attempts to formulate things using logic and so on, even if my mother's textbook about philosophical logic didn't exist yet, but the history of all the effort of formalization I was quite aware of through Leibnitz, Hilbert, [...]


Back in 1979, I was sort of thinking about this kind of thing and that led me to design the design that I came up with that was based on the idea of symbolic expressions and doing transformations on symbolic expressions.



This all does not sound to me as it was an active decision to create a term rewriting system but rather, Wolfram wrote down the specifications of how he thought an expression manipulator should be designed. When we look at it now, it seems clear that it is of course a term-rewriting system, but maybe it wasn't so clear back then.


Comments

Popular posts from this blog

How to thread a list

I have data in format data = {{a1, a2}, {b1, b2}, {c1, c2}, {d1, d2}} Tableform: I want to thread it to : tdata = {{{a1, b1}, {a2, b2}}, {{a1, c1}, {a2, c2}}, {{a1, d1}, {a2, d2}}} Tableform: And I would like to do better then pseudofunction[n_] := Transpose[{data2[[1]], data2[[n]]}]; SetAttributes[pseudofunction, Listable]; Range[2, 4] // pseudofunction Here is my benchmark data, where data3 is normal sample of real data. data3 = Drop[ExcelWorkBook[[Column1 ;; Column4]], None, 1]; data2 = {a #, b #, c #, d #} & /@ Range[1, 10^5]; data = RandomReal[{0, 1}, {10^6, 4}]; Here is my benchmark code kptnw[list_] := Transpose[{Table[First@#, {Length@# - 1}], Rest@#}, {3, 1, 2}] &@list kptnw2[list_] := Transpose[{ConstantArray[First@#, Length@# - 1], Rest@#}, {3, 1, 2}] &@list OleksandrR[list_] := Flatten[Outer[List, List@First[list], Rest[list], 1], {{2}, {1, 4}}] paradox2[list_] := Partition[Riffle[list[[1]], #], 2] & /@ Drop[list, 1] RM[list_] := FoldList[Transpose[{First@li...

front end - keyboard shortcut to invoke Insert new matrix

I frequently need to type in some matrices, and the menu command Insert > Table/Matrix > New... allows matrices with lines drawn between columns and rows, which is very helpful. I would like to make a keyboard shortcut for it, but cannot find the relevant frontend token command (4209405) for it. Since the FullForm[] and InputForm[] of matrices with lines drawn between rows and columns is the same as those without lines, it's hard to do this via 3rd party system-wide text expanders (e.g. autohotkey or atext on mac). How does one assign a keyboard shortcut for the menu item Insert > Table/Matrix > New... , preferably using only mathematica? Thanks! Answer In the MenuSetup.tr (for linux located in the $InstallationDirectory/SystemFiles/FrontEnd/TextResources/X/ directory), I changed the line MenuItem["&New...", "CreateGridBoxDialog"] to read MenuItem["&New...", "CreateGridBoxDialog", MenuKey["m", Modifiers-...

functions - Get leading series expansion term?

Given a function f[x] , I would like to have a function leadingSeries that returns just the leading term in the series around x=0 . For example: leadingSeries[(1/x + 2)/(4 + 1/x^2 + x)] x and leadingSeries[(1/x + 2 + (1 - 1/x^3)/4)/(4 + x)] -(1/(16 x^3)) Is there such a function in Mathematica? Or maybe one can implement it efficiently? EDIT I finally went with the following implementation, based on Carl Woll 's answer: lds[ex_,x_]:=( (ex/.x->(x+O[x]^2))/.SeriesData[U_,Z_,L_List,Mi_,Ma_,De_]:>SeriesData[U,Z,{L[[1]]},Mi,Mi+1,De]//Quiet//Normal) The advantage is, that this one also properly works with functions whose leading term is a constant: lds[Exp[x],x] 1 Answer Update 1 Updated to eliminate SeriesData and to not return additional terms Perhaps you could use: leadingSeries[expr_, x_] := Normal[expr /. x->(x+O[x]^2) /. a_List :> Take[a, 1]] Then for your examples: leadingSeries[(1/x + 2)/(4 + 1/x^2 + x), x] leadingSeries[Exp[x], x] leadingSeries[(1/x + 2 + (1 - 1/x...