https://community.wolfram.com RSS Feed for Wolfram Community showing any discussions tagged with Symbolic Computations sorted by most viewed. https://community.wolfram.com/groups/-/m/t/1106375 Greetings, I am working on a very complicated equation that needs to be solved. To simplify the function I use a limit in which x is much less than D or ( x<<D). I cannot find much less/greater condition in Mathematica. I need to solve that equation symbolically and I know that I should get four solutions. By taking a limit manually I got something like A*x^4-B*x^2+C=0. Then using solve I was able to get four solution, but with coefficients that were very long. (In manual calculations, I was able to get shorter coefficients) How do I solve equation with much less condition? Just for the sake of example let say I want to solve f(x)= sqrt( D^2 - ( x - z )^2 ) + x * cos(a) + x + z after limit f(x)= sqrt( D^2 - ( z )^2 ) + x * cos(a) + x + z Is there a command in Mathematica to selectively simplify/factor/expand some terms instead all terms in equations? Adam Szewczyk 2017-05-25T01:56:46Z https://community.wolfram.com/groups/-/m/t/1296252 Hi people, I have a problem where I get four solutions to an equation system. Two imaginary, one negative and one positive. Can I somehow automatically tell Mathematica to only keep the real and positive answer? Sort of: Solve[equation1==equation2, x]//Real//Positive Thanks! //Freddy, Sweden Fredrik Erling 2018-03-05T15:24:25Z https://community.wolfram.com/groups/-/m/t/1063480 &[Wolfram Notebook][1] [1]: https://www.wolframcloud.com/obj/373ccb1d-e97f-40ec-aa0a-0d3001c4728d Mariusz Iwaniuk 2017-04-16T22:38:51Z https://community.wolfram.com/groups/-/m/t/1241479 I need to solve this apparently simple system of equations in Mathematica, but it gives me an error message, that Equations may not give solutions for all "solve" variables. The command is sol = Solve[{x1 == x A1/(x A1 + y A3), x2 == x A2/(x A2 + y A4), x3 == y A3/(x A1 + y A3), x4 == y A4/(x A2 + y A4), x1 + x2 + x3 + x4 == 2, x + y == 1}, {x1, x2, x3, x4, x, y}] Any help is appreciated. Alex Token 2017-12-08T08:28:45Z https://community.wolfram.com/groups/-/m/t/1008112 I am trying to obtain the scalar product of two vectors whose components are complex valued. I can do the maths (as I understand it) by hand for my first simple examples but struggle with Mathematica 11. The simplest task which is to establish the Norm of these vectors works fine, but when I then try to get the Dot product, I get an error from Mathematica. I am sure that I have the syntax wrong somewhere or that I need to use the INNER function rather than Dot but I cannot get that to work either based on my reading of the Mathematica Help. I have attached a very simple Notebook to illustrate my problem. Any help will be gratefully received. Thanks David David Mackay 2017-02-04T17:36:50Z https://community.wolfram.com/groups/-/m/t/546818 [Crossposting][1] here to get a wider opinion. So, given some data, *Mathematica* 10.2 can now attempt to figure out what probability distribution might have produced it. Cool! But suppose that, instead of having data, we have something that is in some ways better -- a formula. Let's call it $f$. We suspect -- perhaps because $f$ is non-negative over some domain and because the integral of $f$ over that domain is 1 -- that $f$ is actually the PDF of some distribution (Normal, Lognormal, Gamma, Weibull, etc.) or some relatively simple transform of that distribution. Is there any way that *Mathematica* can help figure out the distribution (or simple transform) whose PDF is the same as $f$? Example: Consider the following formula: 1/(2*E^((-m + Log[5])^2/8)*Sqrt[2*Pi]) $$\frac{e^{-\frac{1}{8} (\log (5)-m)^2}}{2 \sqrt{2 \pi }}$$ As it happens -- and as I discovered with some research and guesswork -- this formula is the PDF of `NormalDistribution[Log[5], 2]` evaluated at $m$. But is there a better way than staring or guessing to discover this fact? That is, help me write `FindExactDistribution[f_, params_]`. Notes --- - The motivation for the problem comes from thinking about Conjugate Prior distributions but I suspect it might have a more general application. - One could start with mapping PDF evaluated at $m$ over a variety of continuous distributions. And if I did this I would at some point get to what I will call $g$, which is the PDF or the `NormalDistribution` with parameters $a$ and $b$ evaluated at $m$. 1/(b*E^((-a + m)^2/(2*b^2))*Sqrt[2*Pi]) $$\frac{e^{-\frac{(m-a)^2}{2 b^2}}}{\sqrt{2 \pi } b}$$ But unless I knew that if I replaced $a$ by `Log[5]` and $b$ by $2$ that I would get $f$, this fact would not mean a lot to me. I suppose I could look at the `TreeForm` of $f$ and $g$ and I would notice certain similarities, and that might be a hint, but I am not sure how to make much progress beyond that observation. Ultimately, the problem looks to be about finding substitutions in parts of a tree ($g$) which, after evaluation, yield a tree that matches a target $f$. I have the suspicion that this is a difficult problem with an NKS flavor but one for which *Mathematica* and its ability to transform expressions might be well suited. [1]: http://mathematica.stackexchange.com/q/91408/13 Seth Chandler 2015-08-12T18:27:19Z https://community.wolfram.com/groups/-/m/t/1032663 Teaching programing and assessing learning progress is often a very custom task. I wanted to create a completely automated "practically" infinite stream of random puzzles that guide a leaner towards improving programing skills. I think the major problem is content creation. To test whether the learner knows a programming concept, an exercise needs to be wisely designed. And it is better to have a randomized set of such exercises to definitely test the knowledge and exclude guesses and cheating and so on. Often creating such educational materials is very tedious, time consuming, and manual. Exactly like creating good documentation. I will explain one simple idea of using docs to make an educational game. This is just a barebone prototype to clearly follow the inner workings (try it out & share: https://wolfr.am/bughunter ). Please comment with feedback on how we can develop this idea further. [![enter image description here][1]][3] # Introduction: efficient use of resources The docs are the finest wealth and depth of information and should be explored beyond their regular usage. Manual painstaking time consuming effort of creating good programing documentation should be used to its fullest potential. An automated game play would be a novel take on docs. We can use existing code examples in docs to randomly pull pieces of code and make programing exercises automatically. Being able to read code and find bugs is, in my experience, one of the most enlightening practices. The goal of the linked above game is to find a defect of the input code (bug) and fix it. Hence, the "bug hunter". There are just 2 possible outcomes of a single game cycle, --- and after each you can "try again": ![enter image description here][4] # Core game code: making puzzles Wolfram Language (WL) documentation is one of the best I've seen. It has pages and pages of examples starting from simple ones and going though the all details of the usage. Moreover the docs are written in WL itself and furthermore, WL can access docs and even has internal self-knowledge of its structure via WolframLanguageData. For instance, this is how you can show a relationship community graph for symbols related to `GatherBy`: WolframLanguageData["GatherBy", "RelationshipCommunityGraph"] ![enter image description here][5] We can use `WolframLanguageData` to access docs examples and then drop some parts of the code. The puzzle is then for the learner to find what is missing. For the sake of clarity designing a small working prototype lets limit test WL functions and corresponding docs' pages to some small number. So out of ~5000 (and we [just released a new addition][6]): WolframLanguageData[] // Length `4838` built in symbols I just take 30 functions = {"Append", "Apply", "Array", "Cases", "Delete", "DeleteCases", "Drop", "Except", "Flatten", "FlattenAt", "Fold", "Inner", "Insert", "Join", "ListConvolve", "Map", "MapThread", "Nest", "Outer", "Partition", "Prepend", "ReplacePart", "Reverse", "RotateLeft", "RotateRight", "Select", "Sort", "Split", "Thread", "Transpose"}; functions // Length 30 that are listed on a [very old but neat animated page][7] of some essential core-language collection. I will also add some "sugar syntax" to potential removable parts of code: sugar = {"@@", "@", "/@", "@@@", "#", "^", "&"}; So, for instance, out of the following [example in docs][8] we could remove a small part to make a puzzle: ![enter image description here][9] Here is an example of "sugar syntax" removal, which for novice programmers would be harder to solve: ![enter image description here][10] Next step is to define a function that can check if a string is a built-in symbol (function, all 5000) or if it is some of sugar syntax we defined above: ClearAll[ExampleHeads]; ExampleHeads[e_]:= Select[ Cases[e,_String, Infinity], (NameQ["System`"<>#]||MemberQ[sugar,#])&&#=!="Input"& ] Next function essentially makes a single quiz question. First it randomly picks a function from list of 30 symbols we defined. Then it goes to the doc page of that symbol to the section called "Basic Examples". It finds a random example and removes a random part out of it: ranquiz[]:=Module[ {ranfun=RandomChoice[functions],ranexa,ranhead}, ranexa=RandomChoice[WolframLanguageData[ranfun,"DocumentationBasicExamples"]][[-2;;-1]]; ranhead=RandomChoice[ExampleHeads[ranexa[[1]]]]; { ReplacePart[#,Position[#,ranhead]->""]&@ranexa[[1]], ranexa[[2]], ranhead, ranfun } ] Now we will define a few simple variables and tools. # Image variables I keep marveling how convenient it is that Mathematica front end can make images to be part of code. This makes notebooks a great IDE: ![enter image description here][11] # Databin for tracking stats It is important to have statistics of your learning game: to understand how to improve it where the education process should go. [Wolfram Datadrop][12] is an amazing tool for these purposes. [![enter image description here][13]][14] We define the databin as bin = CreateDatabin[<|"Name" -> "BugHunter"|>] # Deploy game to the web To make an actual application usable by everyone with internet access I will use [Wolfram Development Platform][15] and [Wolfram Cloud][16]. First I define a function that will build the "result of the game" web page. It will check is answer is wrong or right and give differently designed pages accordingly. quiz[answer_String,check_String,fun_String]:= ( DatabinAdd[Databin["kd3hO19q"],{answer,check,fun}]; Grid[{ {If[answer===check, Grid[{{Style["Right! You got the bug!",40,Darker@Red,FontFamily->"Chalkduster"]},{First[imgs]}}], Grid[{{Style["Wrong! The bug got you!",40,Darker@Red,FontFamily->"Chalkduster"]},{Last[imgs]}}] ]}, {Row[ {Hyperlink["Try again","https://www.wolframcloud.com/objects/user-3c5d3268-040e-45d5-8ac1-25476e7870da/bughunter"], "|", hyperlink["Documentation","http://reference.wolfram.com/language/ref/"<>fun<>".html"], "|", hyperlink["Fun hint","http://reference.wolfram.com/legacy/flash/animations/"<>fun<>".html"]}, Spacer[10] ]}, {Style["===================================================="]}, {hyperlink["An Elementary Introduction to the Wolfram Language","https://www.wolfram.com/language/elementary-introduction"]}, {hyperlink["Fast introduction for programmers","http://www.wolfram.com/language/fast-introduction-for-programmers/en"]}, {logo} }] ) This function is used inside `CloudDeploy[...FormFunction[...]...]` construct to actually deploy the application. `FormFunction` builds a query form, a web user interface to formulate a question and to get user's answer. Note for random variables to function properly `Delayed` is used as a wrapper for `FormFunction`. CloudDeploy[Delayed[ quizloc=ranquiz[]; FormFunction[ {{"code",None} -> "String", {"x",None}-><| "Input"->StringRiffle[quizloc[[3;;4]],","], "Interpreter"->DelimitedSequence["String"], "Control"->Function[Annotation[InputField[##],{"class"->"sr-only"},"HTMLAttrs"]]|>}, quiz[#code,#x[[1]],#x[[2]]]&, AppearanceRules-> <| "Title" -> Grid[{{title}},Alignment->Center], "MetaTitle"->"BUG HUNTER", "Description"-> Grid[{ {Style["Type the missing part of input code",15, Darker@Red,FontFamily->"Ayuthaya"]}, {Rasterize@Grid[{ {"In[1]:=",quizloc[[1]]}, {"Out[1]=",quizloc[[2]]}},Alignment->Left]} }] |>]], "bughunter", Permissions->"Public" ] The result of the deployment is a cloud object at a URL: CloudObject[https://www.wolframcloud.com/objects/user-3c5d3268-040e-45d5-8ac1-25476e7870da/bughunter] with the short version: URLShorten["https://www.wolframcloud.com/objects/user-3c5d3268-040e-45d5-8ac1-25476e7870da/bughunter", "bughunter"] https://wolfr.am/bughunter And we are done! You can go at the above URL and play. # Further thoughts Here are some key points and further thoughts. ## Advantages: - Automation of content: NO new manual resource development, use existing code bases. - Automation of testing: NO manual labor of grading. - Quality of testing: NO multiple choice, NO guessing. - Quality of grading: almost 100% exact detection of mistakes and correct solutions. - Fight cheating: clear to identify question type "find missing code part" helps to ban help from friendly forums (such as this one). - Almost infinite variability of examples if whole docs system is engaged. - High range from very easy to very hard examples (exclusion of multiple functions and syntax can make this really hard). ## Improvements: - Flexible scoring system based on function usage frequencies. - Optional placeholder as hint where the code is missing. - Using network of related functions (see above) to move smoothly through the topical domains. - Using functions frequency to feed easier or harder exercises based on test progress. ***Please comment with your own thoughts and games and code!*** [1]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-03-17at10.37.46AM.png&userId=11733 [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-03-16at6.49.58PM.png&userId=11733 [3]: https://www.wolframcloud.com/objects/user-3c5d3268-040e-45d5-8ac1-25476e7870da/bughunter [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-03-16at6.58.45PM.png&userId=11733 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=sgfq354ythwrgsf.png&userId=11733 [6]: http://blog.wolfram.com/2017/03/16/the-rd-pipeline-continues-launching-version-11-1/ [7]: http://reference.wolfram.com/legacy/flash/ [8]: http://reference.wolfram.com/language/ref/Except.html [9]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-03-16at7.21.05PM.png&userId=11733 [10]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-03-16at7.25.52PM.png&userId=11733 [11]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-03-16at7.34.59PM.png&userId=11733 [12]: https://datadrop.wolframcloud.com/ [13]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ScreenShot2017-03-16at7.41.35PM.png&userId=11733 [14]: https://datadrop.wolframcloud.com/ [15]: https://www.wolfram.com/development-platform/ [16]: http://www.wolfram.com/cloud/ Vitaliy Kaurov 2017-03-17T01:13:24Z https://community.wolfram.com/groups/-/m/t/823320 Hi; It doesn't seem that the Norm[ ] command is applying the trig identity Sin^2 + Cos^2 = 1 to give the correct answer - please see attached. Thanks, Mitch Sandlin Mitchell Sandlin 2016-03-14T18:29:27Z https://community.wolfram.com/groups/-/m/t/415820 Very nice palindromic binary year for everybody! IntegerDigits[2015, 2] `{1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1}` Jose Martin-Garcia 2015-01-02T23:57:16Z https://community.wolfram.com/groups/-/m/t/1056910 There is a simple matrix operation that other scientific computing systems typically have and Mathematica sorely lacks: **Replace the diagonal of a matrix with all zeros.** Or more generally, replace the diagonal with some given values. I am not sure why this is missing from Mathematica. Perhaps it is considered trivial to implement. To show that it isn't, I challenge the readers of this forum to post an implementation which is: - As efficient as possible—it should be fast and not use too much memory - As general as possible—it should work with all sorts of matrices that can be used in Mathematica Think through your submission before you post it. I expect that I will be able to point out problems in the first few submissions. If not, and I am proven wrong, then I will be happy to learn new methods of doing this. *If you agree that this functionality needs to be added to the next version of Mathematica, upvote this post!* Szabolcs Horvát 2017-04-08T12:12:41Z https://community.wolfram.com/groups/-/m/t/1057642 One of the advertised features of Wolfram Alpha Pro is that it gives access to step-by-step solutions. I've just started using Pro, and I can't seem to get them to show up consistently. For instance, it pops up as an option for this query Integrate[(5x+1)^2,x] http://www.wolframalpha.com/input/?i=integrate%5B(5x%2B1)%5E2,x%5D but not for Sum[(-1)^m/((2m-1)^2-1),{m,2,infty}] https://www.wolframalpha.com/input/?i=Sum%5B(-1)%5Em%2F((2m-1)%5E2-1),%7Bm,2,infty%7D%5D I guess my question boils down to: - When can/does wolfram know how to do step-by-step solutions? - When it is possible, how can one get access to them? Thanks in advance. Grant Larsen 2017-04-10T00:57:33Z https://community.wolfram.com/groups/-/m/t/1024712 A blanagram is an anagram for another word except for the substitution of one letter. Think of Scrabble with a blank square (blank + anagram = blanagram). For example, *phyla* is a blanagram of *glyph*; replace the "g" with an "a" and find anagrams (see [blog on Anagrams][1]). We will prototype with a simple word, glyph. We'll start by getting a list of the individual characters in glyph. In[1]:= Characters["glyph"] Out[1]= {"g", "l", "y", "p", "h"} Start by replacing the first letter in glyph with an a and then finding all anagrams. The third argument to StringReplacePart is a list of beginning and ending positions for the replacement. In[2]:= StringReplacePart["glyph", "a", {1, 1}] Out[2]= "alyph" In[3]:= Anagrams[%] Out[3]= {"phyla", "haply"} Now do the same for each character position in the word. In[4]:= Map[StringReplacePart["glyph", "a", {#, #}] &, Range[StringLength["glyph"]]] Out[4]= {"alyph", "gayph", "glaph", "glyah", "glypa"} In[5]:= Flatten[Map[Anagrams, %]] Out[5]= {"phyla", "haply"} Having done this for the letter a, we now repeat for all other single characters. In[6]:= CharacterRange["a", "z"] Out[6]= {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"} In[7]:= blana = Table[ Map[StringReplacePart["glyph", ch, {#, #}] &, Range[StringLength["glyph"]]], {ch, CharacterRange["a", "z"]}] Out[7]= {{"alyph", "gayph", "glaph", "glyah", "glypa"}, {"blyph", "gbyph", "glbph", "glybh", "glypb"}, {"clyph", "gcyph", "glcph", "glych", "glypc"}, {"dlyph", "gdyph", "gldph", "glydh", "glypd"}, {"elyph", "geyph", "gleph", "glyeh", "glype"}, {"flyph", "gfyph", "glfph", "glyfh", "glypf"}, {"glyph", "ggyph", "glgph", "glygh", "glypg"}, {"hlyph", "ghyph", "glhph", "glyhh", "glyph"}, {"ilyph", "giyph", "gliph", "glyih", "glypi"}, {"jlyph", "gjyph", "gljph", "glyjh", "glypj"}, {"klyph", "gkyph", "glkph", "glykh", "glypk"}, {"llyph", "glyph", "gllph", "glylh", "glypl"}, {"mlyph", "gmyph", "glmph", "glymh", "glypm"}, {"nlyph", "gnyph", "glnph", "glynh", "glypn"}, {"olyph", "goyph", "gloph", "glyoh", "glypo"},{"plyph", "gpyph", "glpph", "glyph", "glypp"}, {"qlyph", "gqyph", "glqph", "glyqh", "glypq"}, {"rlyph", "gryph", "glrph", "glyrh", "glypr"}, {"slyph", "gsyph", "glsph", "glysh", "glyps"}, {"tlyph", "gtyph", "gltph", "glyth", "glypt"}, {"ulyph", "guyph", "gluph", "glyuh", "glypu"}, {"vlyph", "gvyph", "glvph", "glyvh", "glypv"}, {"wlyph", "gwyph", "glwph", "glywh", "glypw"}, {"xlyph", "gxyph", "glxph", "glyxh", "glypx"}, {"ylyph", "gyyph", "glyph", "glyyh", "glypy"}, {"zlyph", "gzyph", "glzph", "glyzh", "glypz"}} Because of the extra nesting of the output ( `Table[Map[...]]` ) we need to flatten the output at a deeper level. And delete duplicates. In[8]:= Flatten[Map[Anagrams, blana, {2}]] // DeleteDuplicates Out[8]= {"phyla", "haply", "glyph", "lymph", "sylph"} Finally, put all the pieces together to create a reusable function, `Blanagrams`. In[9]:= Blanagrams[word_String] := Module[{blana}, blana = Table[ Map[StringReplacePart[word, ch, {#, #}] &, Range[StringLength[word]]], {ch, CharacterRange["a", "z"]}]; DeleteDuplicates[Flatten[Map[Anagrams, blana, {2}]]] ] This turns out to be fairly quick for small words, but it bogs down for larger words. In[10]:= Blanagrams["glyph"] //Timing Out[10]= {1.25209, {"phyla", "haply", "glyph", "lymph", "sylph"}} In[11]:= Blanagrams["string"] //Timing Out[11]= {8.85717, {"taring", "rating", "gratin", "arsing", "grains", "sating", "giants", "grants", "gratis", "strain", "trains", "brings", "grinds", "sering", "singer", "signer", "resign", "reigns", "ingres", "signet", "tinges", "ingest", "tigers", "insert", "inters", "inerts", "string", "things", "nights", "rights", "girths", "tiring", "siring", "rising", "siting", "tigris", "glints", "roting", "soring", "signor", "groins", "ingots", "strong", "intros", "spring", "sprint", "prints", "stings", "turing", "truing", "strung", "grunts", "wrings", "trying", "stying", "stingy"}} Because we are doing similar computations for each of the letters of the alphabet, this is a good candidate for parallelizing. But which parts do we parallelize? One way to help determine where the computational bottlenecks are is to profile the code. Integrated development environments such as Wolfram Workbench have built-in profilers, but here we will create a simple set of profiling steps to determine where our bottlenecks are. Here is a small auxiliary function that wraps [AbsoluteTiming][2] around an expression and adds a tag to make it easy to identify the various parts of what is reported. In[12]:= timing[expr_, tag_] := Print[{NumberForm[First@AbsoluteTiming[expr], 10], tag}] In[13]:= SetAttributes[timing, HoldAll]; In[14]:= word = "string"; timing[ tmp = Table[Map[StringReplacePart[word, ch, {#, #}] &, Range[StringLength[word]]],{ch, CharacterRange["a", "z"]}];, "table" ]; timing[ Flatten[tmp2 = Map[Anagrams, tmp, {2}]];, "map Anagrams" ]; timing[ DeleteDuplicates[Flatten[tmp2]];, "flatten and delete duplicates" ] Out[15]= {0.000794,table} Out[16]= {8.986847,map Anagrams} Out[17]= {0.000050,flatten and delete duplicates} Not surprisingly, creating the many possible letter combinations is very quick. The greatest part of this computation is spent with mapping Anagrams across the many word combinations. So we can simply try to parallelize that using [ParallelMap][3]. In[17]:= BlanagramsParallel[word_String]:= Module[{blana}, blana = Table[Map[StringReplacePart[word,ch{#,#}]&, Range[StringLength[word]]],{ch,CharacterRange["a","z"]}]; DeleteDuplicates@Flatten[ParallelMap[Anagrams,blana,{2}]] ] Launch kernels on our current machine and compute. In[18]:= LaunchKernels[] Out[18]= {KernelObject[1,local],KernelObject[2,local]} In[19]:= DistributeDefinitions[Anagrams] Out[19]= {Anagrams,word} In[20]:= BlanagramsParallel["strings"]//AbsoluteTiming Out[20]= {37.792462, {ratings,gratins,staring,strains,resting,stinger,singers,signers, resigns,ingress,signets,ingests,tigress,inserts,strings,tirings,risings, sitings,sorting,storing,signors,tossing,springs,sprints,rusting,tryings,stringy}} For comparison, here is the computation done serially on one kernel. In[21]:= Blanagrams["strings"]//AbsoluteTiming Out[21]= {47.756149, {ratings,gratins,staring,strains,resting,stinger,singers,signers,resigns, ingress,signets,ingests,tigress,inserts,strings,tirings,risings,sitings,sorting, storing,signors,tossing,springs,sprints,rusting,tryings,stringy}} With the 2-kernel machine this was run on, we are getting a slight speedup. This particular computation parallelizes well and so on an 8-kernel machine, we would see substantially faster compute times. In[22]:= First[%]/First[%%] Out[22]= 1.2636422 ---------- *NOTE: This article was [originally posted][4] on Paul Wellin's blog PROGRAMMING WITH MATHEMATICA.* [1]: http://programmingwithmathematica.blogspot.com/2011/12/anagrams.html [2]: http://reference.wolfram.com/language/ref/AbsoluteTiming.html [3]: http://reference.wolfram.com/language/ref/ParallelMap.html [4]: http://programmingwithmathematica.blogspot.com/2011/12/blanagrams.html Paul Wellin 2017-03-03T11:10:07Z https://community.wolfram.com/groups/-/m/t/911604 Inspiration and Idea ================ The prospect of internalizing some notion of pure mathematics into the Wolfram Language has been talked about at various points in the past, such as in [this post][1]. My background is in proof assistants and type theories, and I've spent several years programming in languages like Agda and Coq. These dependently typed languages have the best track record for expressing formal mathematics, but the Wolfram Language can't be easily modified to replicate the behaviour of such languages. The issue, as I've come to understand it now, is that the rule-replacement computational model that the Wolfram Language uses is, at it's core, incompatible with a system-wide type theory. That is to say, such a system cannot have every term be typable while maintaining usability. So, what are the alternatives? As far as I can tell, there are two major branches of dependently typed languages (and several minor ones), the "formal" type theories, such as Agda, Coq, Lean, Idris, etc., and the "semantic" type theories, being NuPRL and the more recent RedPRL. I started learning about that second branch a few months ago. Unfortunately, all current PRL implementations are largely unusable for an ordinary user, but the ideas underlying their approach to type theory was enamoring to me. The approach is as follows; 1. Start with an untyped computational model (any will do). 2. Use a programming logic to declare some forms from the model to be "canonical types". 3. Declare other forms from the model to be "canonical terms" of the already declared type. 4. Declare equations which define computational behaviors for those symbols intended to interact with the type under consideration. As an example, it's typical to start with an untyped lambda calculus + constants as a computational model. If we want to define the booleans, we first must choose a symbol and declare it to be a canonical type. We would use an already existing term, in this case we can use the constant "bool", and state something like; DeclareType bool Which adds a rule to our environment allowing us to prove that bool is a type. Similarly, we would declare the two terms in the boolean type; DeclareTerm True bool DeclareTerm False bool As before, the forms "True" and "False" existed in the language already, we are simply adding user-defined rules which allow us to reason about them as terms of a type. The last step is to declare the defining computational behaviour for the type. This basically involves declaring the constant ABT "if(a. A, b, T, F)" to follow particular sequent rules, being; ![The basic typing rule for the dependent if function][2] Actual programming syntax can vary on this, but with the Wolfram Language's Notation Package, I can make the declarations within the system I'll describe in this post match fairly closely to the sequent calculus syntax. PRL languages expand on this idea by saying that one must define a series of partial equivalence relations (PERs) for each type. I take this approach in the third part of this post. After studying this kind of system for a few weeks, Mathematica 11 hit, and I had an epiphany. This approach is 100% compatible with the Wolfram Language, and I decided to try implementing something like this. After about 2 weeks, I feel that I've had quite a bit of success, and I figured my project could benefit from some input from others. A Very Basic Proof Assistant ====================== Rules for Reasoning -------------------------- To start out, I want to implement the sequent calculus in such a way that it's user friendly to prove basic statements. This first example will be a simple implementation of a proof assistant for (Hilbert-style) propositional logic. Starting out, I can declare the encoding I want to use to have special notations using the Notation package. ![Declaring various notations][3] Using this, I can express rules like modus ponens as; SequentRule[ Turnstile[Judgement[], Judgement[true[Implies[A, B]]]], Turnstile[Judgement[], Judgement[true[A]]], Turnstile[Judgement[], Judgement[true[B]]]] And have it display as; ![modus ponens, as it apears after notations are declared][4] Thus mimicking a sequent. I'll expand on this when I get to implementing an actual type system The idea I have is to first state a goal, then treat this sort of rule as a pattern. You start with a pattern like; B true And then apply modus ponens to get the goals A => B true A true If the original goal is a theorem in our logic, then applying existing rules in the correct order will discharge all goals. Before such a system can be made, we need to process our rules into replacement rules that can actually be applied. This involves sugaring the hypotheses with context variables and turning the appropriate variables into patterns. If we were to declare modus ponens as; ![the modus ponens used in my developement][5] We want to get a rule out (which will be stored as ReversePattern[ModusPonens]) which we can apply to a goal. At the end of the processing our rule looks like; ![the pattern replacement rule generated for modus ponens][6] The $ExtraArgument part is added to avoid problems with variable capture during user interaction (maybe it would be a good idea to do this to the context variable as well, but for now it's fine). Notice that the phi is not turned into a pattern or altered in any way. The processing algorithm notices that phi appears in the antecedent goals, but not the conclusion. This means the user has to tell the system what phi is supposed to be since there's no other way to get it. All the variables required by the user are stored in the list ExtraArguments[ModusPonens]. The newly declared rule is then added to a list of known rules. After implementing this, we can declare all the rules we want; ![declaring axioms for classical logic][7] Notice the DeclareSymbol command at the top. This just adds the symbols to a list called DeclaredSymbols which by default contains symbols such as true, Judgement, SequentRule, Turnstile, etc. By adding symbols to this list, they won't be turned into patterns by the processor. Additionally, we want to verify the behaviour of algorithms which may try to evaluate when we don't want them to during proof construction. Since I'm using the built-in Implies and Not, they will try to evaluate on certain arguments. For example "A => A" evaluates to "True", but I want to prove that as a theorem from the axioms. To prevent this, symbols with computational behaviour have to be rendered [Inactive][8]. I'll talk about reactivating them near the end of this section. You may also notice the ImplicationFormer and NegationFormer rules. In a proper formalization of classical (and many other) logics, the axiom rules should have extra hypotheses which require one to prove that a particular variable is a well-formed formula/proposition. I decided not to use them for this post, but they should be used in a serious development. User Interaction -------------------- I designed a simple interface for picking and applying declared rules. I'll probably put it into a window at some point, but for now it looks like this; ![the user interface for interactive theorem proving][9] The top two components are a drop-down menu showing all available rules, and an input field for filtering the drop-down menu. The second two are a preview of what the declared rule looks like, and an auto-generated list of input fields for arguments required for completely applying a rule. The apply rule button applies the selected rule, and I'll explain the other two buttons in a bit. At the bottom is the current goal (in this case, I want to prove that A implies A), and below that is a (currently blank) string of text for storing error messages. Here's a gif of me proving the goal; ![a demo showing 'A implies A' being proved][10] At the end we can get the proof we made and the rule which we proved. After the fact, we can check that this proof is correct by issuing it to CheckProof[provedRule, proof], which will return True if the proof is valid. It works by applying the rules in the proof in the same way they were applied when the proof was originally constructed, then checking if all goals have been discharged. Additionally, we can add proven rules to the environment via an AddTheorem command that adds a rule the same way that DeclareSequentRule does, but only if the proof correctly checks. ![Several Proved Theorems][11] You'll notice that all the theorems with non-empty antecedents have "LogHypothesis" in their proofs. This is added when the "Log Hypothesis" button is pressed in the UI. By deriving the hypothesis from the target and logging it, it will remove the hypothesis from the goal and add it to the rule being proved. Calling The System ------------------------ You may be asking yourself, "hey, can't we already use Simplify to test when a proposition is true? If I were proving things in a more sophisticated logic that relies on classical propositional logic (Say, ZFC) it would be useful to actually utilize the built in capabilities of the Wolfram Language. We can manually add a rule that makes a call to the simplifier; ![A rule for calling the simplifier][12] Using this we may have a complicated goal like; ![enter image description here][13] and issue a system call to immediately get; ![enter image description here][14] Which is trivially provable. Later in this post, I make use of similar rules to interface a type system with the already existing language. Tactics -------- I've not invested very much time thinking about tactics, but the system as it stands can be extended with them. I added one called "BranchSearchTactic" which does a breadth-first search over all rules that don't require user interaction. If it finds a proof, it will add it to the currently building proof and discharge the goal. Here is a usage example; ![enter image description here][15] This is a useful tactic for proving that some term is well-formed. I use this frequently when constructing proofs in the type system. Future work should include an expanded library of tactics. Implementing Types and Formally Verifying Programs ======================================= Rules for a Simple Dependent Type Theory ---------------------------------------- The rules for an actual type theory are similar to what you'd see for any logic, but they are far more complicated than propositional logic. I will take the approach of implementing type theory using PERs for defining type behaviors. Before this can be done, I first add rules for manipulating equations; ![enter image description here][16] ![enter image description here][17] Several of those rules are redundant or maybe undesirable, but I include them here as examples. The most typical type for a dependently typed language is the pi-type, who's typing rules can be declared in the style that you'd see in a technical paper on type theory. ![enter image description here][18] The vertical tildes mark variable bindings, representing those bindings created by the abstract binding tree we're defining. The Wolfram Language doesn't properly handle variable binding (you can't test for alpha-equivalence, for example), but we don't need it to for the examples I make in this post. Notice the presence of substitutions in the inference rules. We now are working with rules who's form may be determined by an intra-rule substitution. A straightforward pattern and replace application would fail to correctly apply the given rules. As a result, we must get the pre-substitution information from the user. After that, these arguments are substituted into the pattern, then the in-pattern substitutions must be performed. This will get us a working replacement rule. Other rules, such as the typing rule for if, also have a substitution in the antecedents. This must also be performed in order to get the correct post-application goal to the user. Using the declared rules we can formally verify some basic programs, such as the S combinator; ![enter image description here][19] ![enter image description here][20] You'll notice that we had to do this by hand. Type checking has to be done by hand since it isn't decidable. This is because an arbitrary term does not have a unique type. In the future, it will probably be worth adding a tactic which can type-check a significant subset of the logic, even if it's technically impossible to check everything. Sigma, Bool, and Coproduct Types -------------------------------------------- At this stage we can add in any of the standard types we want. For example, we can add sigma types, booleans, and coproducts like so; ![Sigma Types][21] ![Booleans][22] ![Coproducts][23] This is sufficient for specifying more interesting theorems. For example, we can prove that all booleans are either True or False; ![A proof that all booleans are either True or False][24] The Natural Numbers and Formal Verification --------------------------------------------------------- As a final example, we can define the type of natural numbers, along with it's dependent eliminator which represents mathematical induction. ![enter image description here][25] I had to do a bit of extra work to make it interface well with the built in representation of numbers. Also note that I declared Plus and Times in the type system. While both could have been defined in terms of induction, I would like to get the various built-in Wolfram Language functions to have their own typing rules so that the already existing system can interface with proofs. This way, we can make calls to the system using some custom rules; ![enter image description here][26] These simply call Simplify on one or both arguments of an equation, but they can easily be modified to call other rule should we want to. As a usage example, I want to prove that all numbers are either even or odd, that, for all natural numbers n, there exists a number z such that n = 2 * z or n = 1 + 2 * z. This is a simple proof by mathematical induction + a bit of algebra. Our initial goal looks like. ![enter image description here][27] The term makes various references to "sys", which basically says "justify the equation in any way", which will be some calls to simplify in this case. For example, at some point in the proof we have the goal; ![enter image description here][28] which asks us to prove Succ[n3] = Succ[2 * fst[f]] given a proof that n3 = 2 * fst[f]. One way we can approach this is to call SysCallEQ, simplifying both sides algebraically, which will reduce the equation to; ![enter image description here][29] which is just our assumption. Later on in the same proof we encounter a different goal; ![enter image description here][30] We may consider making the same system call as before. If we do this, we get to; ![enter image description here][31] Which, unlike last time, is not one of our assumptions. We can then use transitivity to get us; ![enter image description here][32] The first of those goals is trivially provable as our assumption. That second goal can be approached by calling Simplify on the left-hand side, getting us; ![enter image description here][33] Which is easy to justify. While these are simple use cases, they suggest a greater potential for interfacing proofs with the already existing system. In the end, the verification of the proof that all numbers are even or odd is around 500 steps. The point is to formally verify an algorithm, one which, given a number n, finds a z such that z is half of n (in the case of "inl") or z is half of n-1 (in the case of "inr"). Can this algorithm actually be run? ![enter image description here][34] Yes, yes it can. Future Work ========== Potential Generalizations ------------------------------- One system I implemented during testing was [MU][35]. ![enter image description here][36] You'll notice that I had to put in the rules manually since the kind of pattern matching they use is incompatible with the processing done by DeclareSequentRule. It was this exercise which made me realize that the user interface was largely a way to systematically apply Replace on specific rules. The main thing preventing this from being strictly true is the handling of intra-rule substitutions. This suggests to me a potential generalization and even simplification of the system I've set out here. Early on, I noticed that my development was somewhat similar to [Metamath][37], a small theorem prover. It may be prudent to borrow some of its methodology when modifying this system in the future. Program Extraction ------------------------ In theory, it should be possible to start with the type without any term as a goal, and interact with the user to build up a term which witnesses the type. I've had some small success in making a system which works like this, though it isn't nice enough to talk about in detail. This sort of feature is what makes dependently typed languages useful and usable in the first place. For now, my system can only verify a program, but building up a program from a specification will have to be a future project. Libraries ----------- I mentioned that I wanted to add typing rules (and theorems) for a large number of the Wolfram Languages' built in functions. There are many existing mature libraries for fields like graph and group theory for languages such as Coq and Agda. Making a similar library with compatibility with the already existing faculties for calculation and manipulation would be nice. Extensions -------------- There are many cutting-edge logics and type theories which are difficult to implement inside modern proof assistants. I think a system like the one I laid out here could be helpful for quickly setting up all the rules required to play with more speculative type theories, such as [Adjoint Logic][38], [Cubical Realizability][39], and [Directed HoTT][40]. In the future, I plan on trying to implement some of those myself. [1]: http://blog.stephenwolfram.com/2014/08/computational-knowledge-and-the-future-of-pure-mathematics/ [2]: http://community.wolfram.com//c/portal/getImageAttachment?filename=9683ifTypingLatex.png&userId=137675 [3]: http://community.wolfram.com//c/portal/getImageAttachment?filename=NotationExam.png&userId=137675 [4]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ModusPonens.png&userId=137675 [5]: http://community.wolfram.com//c/portal/getImageAttachment?filename=ModusPonens2.png&userId=137675 [6]: http://community.wolfram.com//c/portal/getImageAttachment?filename=MPPattern.png&userId=137675 [7]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Declarations.png&userId=137675 [8]: https://reference.wolfram.com/language/ref/Inactive.html [9]: http://community.wolfram.com//c/portal/getImageAttachment?filename=UserInterface.png&userId=137675 [10]: http://community.wolfram.com//c/portal/getImageAttachment?filename=UIDemo.gif&userId=137675 [11]: http://community.wolfram.com//c/portal/getImageAttachment?filename=DeclaredTheorems.png&userId=137675 [12]: http://community.wolfram.com//c/portal/getImageAttachment?filename=SystemCallRule.png&userId=137675 [13]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Meredith.png&userId=137675 [14]: http://community.wolfram.com//c/portal/getImageAttachment?filename=Trivial.png&userId=137675 [15]: http://community.wolfram.com//c/portal/getImageAttachment?filename=TacticDemo.gif&userId=137675 [16]: http://community.wolfram.com//c/portal/getImageAttachment?filename=IDManipulations.png&userId=137675 [17]: http://community.wolfram.com//c/portal/getImageAttachment?filename=MoreIdentityManipulations.png&userId=137675 [18]: http://community.wolfram.com//c/portal/getImageAttachment?filename=8741PiTypes.png&userId=137675 [19]: http://community.wolfram.com//c/portal/getImageAttachment?filename=1097SGoal.png&userId=137675 [20]: http://community.wolfram.com//c/portal/getImageAttachment?filename=SComb.gif&userId=137675 [21]: http://community.wolfram.com//c/portal/getImageAttachment?filename=SigmaTypes.png&userId=137675 [22]: http://community.wolfram.com//c/portal/getImageAttachment?filename=BoolType.png&userId=137675 [23]: http://community.wolfram.com//c/portal/getImageAttachment?filename=CoProuctType.png&userId=137675 [24]: http://community.wolfram.com//c/portal/getImageAttachment?filename=TrueFalseBool.png&userId=137675 [25]: http://community.wolfram.com//c/portal/getImageAttachment?filename=NaturalNums.png&userId=137675 [26]: http://community.wolfram.com//c/portal/getImageAttachment?filename=SysCalls.png&userId=137675 [27]: http://community.wolfram.com//c/portal/getImageAttachment?filename=EvenOddGoal.png&userId=137675 [28]: http://community.wolfram.com//c/portal/getImageAttachment?filename=SysCalGoal.png&userId=137675 [29]: http://community.wolfram.com//c/portal/getImageAttachment?filename=10090SysCalGoal.png&userId=137675 [30]: http://community.wolfram.com//c/portal/getImageAttachment?filename=6302SysCalGoal.png&userId=137675 [31]: http://community.wolfram.com//c/portal/getImageAttachment?filename=9736SysCalGoal.png&userId=137675 [32]: http://community.wolfram.com//c/portal/getImageAttachment?filename=2873SysCalGoal.png&userId=137675 [33]: http://community.wolfram.com//c/portal/getImageAttachment?filename=2413SysCalGoal.png&userId=137675 [34]: http://community.wolfram.com//c/portal/getImageAttachment?filename=EvenOddClassifier.png&userId=137675 [35]: https://en.wikipedia.org/wiki/MU_puzzle [36]: http://community.wolfram.com//c/portal/getImageAttachment?filename=MIU.png&userId=137675 [37]: http://us.metamath.org/index.html [38]: http://dlicata.web.wesleyan.edu/pubs/ls15adjoint/ls15adjoint.pdf [39]: http://www.cs.cmu.edu/~rwh/papers/chitt/draft.pdf [40]: https://people.cs.kuleuven.be/~dominique.devriese/ThesisAndreasNuyts.pdf Anthony Hart 2016-08-23T11:31:46Z https://community.wolfram.com/groups/-/m/t/855400 Hi guys, do you know how could I solve an indefinite integral with step-by-step solution and specifying the variable of integration? For example: WolframAlpha["cos(tw+f)cos(t*w)", IncludePods -> {"Indefinite Integral"}, PodStates -> {"Step-by-step solution", "Show all steps"}] in this case Mathematica chooses as variable of integrazion w, but I would variable of integration is t. I tried to lunch: WolframAlpha["[cos(tw+f)cos(t*w),{t}]", IncludePods -> {"Indefinite Integral"}, PodStates -> {"Step-by-step solution", "Show all steps"}] but doesn't work. Thank you for your help. Gennaro Arguzzi 2016-05-12T16:05:30Z https://community.wolfram.com/groups/-/m/t/826533 Hi. I have this number: (e + I y - 3 (f + I z) + 3 (e + I y)^2 (f + I z) - (e + I y) (f + I z)^2 + Sqrt[5] Sqrt[(e + I (1 + y))^2 (e - f + I (y - z))^2 (f + I (1 + z))^2] + I (e + f + I (y + z))^2 + (4 (-1 + 3 I e - I f + (e + I y)^2 - 3 y + (e + I y) (f + I z) - (f + I z)^2 + z)^2)/(e + I y - 3 (f + I z) + 3 (e + I y)^2 (f + I z) - (e + I y) (f + I z)^2 + Sqrt[5] Sqrt[(e + I (1 + y))^2 (e - f + I (y - z))^2 (f + I (1 + z))^2] + I (e + f + I (y + z))^2))/(2 (-1 + 3 I e - I f + (e + I y)^2 - 3 y + (e + I y) (f + I z) - (f + I z)^2 + z)) I know it is real (I proved that), but using Simplify or FullSimplify there are still imaginary units. Using ComplexExpand, too. What is commend which I should use to reduct imaginary units? I am not well-experienced, so I don't know how do this. *e, f, y, z are real numbers Jan Redwi?ski 2016-03-20T18:59:27Z https://community.wolfram.com/groups/-/m/t/1863194 There is a way to convert Python to Lisp. Peter Norvig talked about it. https://norvig.com/lispy2.html ismail ali 2020-01-20T17:47:09Z https://community.wolfram.com/groups/-/m/t/1395518 I have three PDE's and I want to solve it analytically. But I could not find any method to solve it. Can anyone suggest me which method is suitable for these type of PDE's. Details are given in the attached file. Anyone can help me it would be highly appreciated. Mirza Farrukh Baig 2018-08-01T13:10:47Z https://community.wolfram.com/groups/-/m/t/1164210 I am writing a paper "Simple Random Walk Models of Entanglement Effects on the Elasticity and Viscoelasticity of Polymer Networks." which i will be presenting at the Polymer Networks meeting in Prague. Of course, i'm writing it in a Mathematica notebook but it will have a bunch of equations and my physical disability makes it difficult for me to enter them (also, i am not very familiar with the use of the mathematical templates in WL / Mathematica). I have PDFs of my published articles from which i am creating this 'tutorial' article . these PDFs have all the equations i will be using in the article. What i need is someone to enter each equation into its own cell in a Mathematica notebook. I can then take that notebook and can create a notebook containing both the text which i will be composing and the equations which i will 'copy and paste' from the 'notebook of equations'. I can email the PDFs to the person who, after creating the notebook of equations, can email it to me. So this is is a simple straightforward job that will earn some income for someone (the pricing is negotiable, based on the time involved, the difficulty of the work, etc.) . Richard Gaylord 2017-08-13T09:34:53Z https://community.wolfram.com/groups/-/m/t/1575783 # Introduction Implementation of CSS Selectors 3 for Wolfram Language SymbolicXML expressions. This work is motivated by the Stack Exchange post [css-selectors-for-symbolic-xml](https://mathematica.stackexchange.com/questions/49052/css-selectors-for-symbolic-xml). The full package with the examples shown below can be download from [the github repo here](https://github.com/KMDaily/CSS_Selectors3_WolframLanguage). The standalone package is attached to this community post but may not remain as up to date as the repo. The [CSS Selectors 3 specification](https://www.w3.org/TR/selectors-3/) is followed as far as possible, but I make no claims to be absolutely conformant. For example, being that WL SymbolicXML is a static expression, any HTML/XML elements such as dynamic pseudo classes (e.g. active/hover/focus) and pseudo elements (e.g. before/after) are not found. ## Load Package ``` In[] := Needs["Selectors3`"] ``` ## Testing on HTML source Being a little meta, let's test this against the [WC3 page for Selectors Level 3](https://www.w3.org/TR/selectors-3/). ``` In[] := document = Import["https://www.w3.org/TR/selectors-3/", "XMLObject"]; ``` ### Look for elements that belong to classes that contain the letter 'h'. ``` In[] := Position[document, Selector["[class*=h]"]] Out[] = {{2, 3, 2, 3, 2}, {2, 3, 2, 3, 484}, {2, 3, 2, 3, 488}, {2, 3, 2, 3, 2, 3, 11}} In[] := Extract[document, %][[All, 1 ;; 2]] // Column Out[] = { {XMLElement["div", {"class" -> "head"}]}, {XMLElement["dl", {"class" -> "bibliography"}]}, {XMLElement["dl", {"class" -> "bibliography"}]}, {XMLElement["p", {"class" -> "copyright"}]} } ``` ### Look for elements of class '.no-num' ``` In[] := Extract[document, Position[document, Selector[".no-num"]]] // Column Out[] = { {XMLElement["h2", {"class" -> "no-num no-toc", "id" -> "abstract"}, {"Abstract"}]}, {XMLElement["h2", {"class" -> "no-num no-toc", "id" -> "status"}, {"Status of this document"}]}, {XMLElement["h2", {"class" -> "no-num no-toc", "id" -> "contents"}, {"Table of contents"}]}, {XMLElement["h2", {"class" -> "no-num no-toc"}, {"W3C Recommendation 06 November 2018"}]} } ``` ### Check specificity of the selector ``` In[] := Selector[document, "[class~=a] b > *:link"]["Specificity"] Out[] = {0, 2, 1} In[] := Selector[document, "[class~=a] b > :not(p)"]["Specificity"] Out[] = {0, 1, 2} In[] := Selector[document, "#welcome"]["Specificity"] Out[] = {1, 0, 0} ``` ## Testing on XML source ``` In[] := str = "<html xml:lang='zh'><head><title>Test</title></head><body \ xmlns='http://www.w3.org/1999/xhtml'><p lang='en' class='red' \ myid='unique'>Here is some math.</p><p><m:math \ xmlns:m='http://www.w3.org/1998/Math/MathML'><m:mi \ m:title='cat'>x</m:mi><m:mo>+</m:mo><m:mn>1</m:mn></m:math></p></body>\ \n</html>"; In[] := obj = ImportString[str, "XML"]; ``` ### Namespace If the selector does not specify a namespace, then the namespace is ignored: ``` In[] := Selector[str, "mo"] Out[] = <|"Specificity" -> {0, 0, 1}, "Elements" -> {{2, 3, 2, 3, 2, 3, 1, 3, 2}}|> ``` If a namespace is given in the selector, then you need to provide the prefix's expansion rule. Otherwise the selector won't match any element. ``` In[] := Selector[str, "m|mo"] Out[] = <|"Specificity" -> {0, 0, 1}, "Elements" -> {}|> In[] := Selector[str, "m|mo", "Namespaces" -> {"m" -> "http://www.w3.org/1998/Math/MathML"}] Out[] = <|"Specificity" -> {0, 0, 1}, "Elements" -> {{2, 3, 2, 3, 2, 3, 1, 3, 2}}|> ``` ### ID XML can define its own unique ID tags. Use the "ID" option to indicate what tag name is in use. This is equivalent to using the attribute selector but with higher specificity. ``` In[] := Selector[str, "#unique", "ID" -> "myid"] Out[] = <|"Specificity" -> {1, 0, 0}, "Elements" -> {{2, 3, 2, 3, 1}}|> In[] := Selector[str, "[myid=unique]"] Out[] = <|"Specificity" -> {0, 1, 0}, "Elements" -> {{2, 3, 2, 3, 1}}|> ``` ### Case sensitivity XML is case-sensitive, but the Selectors3 package is not by default. Use the "CaseInsensitive" option to enforce case sensitivity. ``` In[] := Selector[str, "[myID=unique]", "CaseInsensitive" -> True] Out[] = <|"Specificity" -> {0, 1, 0}, "Elements" -> {{2, 3, 2, 3, 1}}|> In[] := Selector[str, "[myID=unique]", "CaseInsensitive" -> False] Out[] = <|"Specificity" -> {0, 1, 0}, "Elements" -> {}|> ``` You can specify the case-sensitivity separately for attribute name and value. ``` In[] := Selector[str, "[myID=Unique]", "CaseInsensitive" -> {"AttributeName" -> True, "AttributeValue" -> False}] Out[] = <|"Specificity" -> {0, 1, 0}, "Elements" -> {}|> In[] := Selector[str, "[myID=Unique]", "CaseInsensitive" -> {"AttributeName" -> False, "AttributeValue" -> True}] Out[] = <|"Specificity" -> {0, 1, 0}, "Elements" -> {}|> In[] := Selector[str, "[myID=Unique]", "CaseInsensitive" -> {"AttributeName" -> True, "AttributeValue" -> True}] Out[] = <|"Specificity" -> {0, 1, 0}, "Elements" -> {{2, 3, 2, 3, 1}}|> ``` You can specify the case-sensitivity separately for type. ``` In[] := Selector[str, "P", "CaseInsensitive" -> {"Type" -> True}] Out[] = <|"Specificity" -> {0, 0, 1}, "Elements" -> {{2, 3, 2, 3, 1}, {2, 3, 2, 3, 2}}|> In[] := Selector[str, "P", "CaseInsensitive" -> {"Type" -> False}] Out[] = <|"Specificity" -> {0, 0, 1}, "Elements" -> {}|> ``` Kevin Daily 2018-12-20T20:53:34Z https://community.wolfram.com/groups/-/m/t/1664846 [GeometricScene][1] and [FindGeometricConjectures][2] are two of my favorite new functions in Wolfram Language V12. V12 provides innovative automated capabilities to draw and reason about abstractly described scenes in the plane. I also remember that I'd proved famous theorems of geometry over many days when I was a junior high school student. I will show nine theorems, including those in the Documentation Center and [WOLFRAM blog][3]. ## Thaless Theorem ## If A, B, and C are distinct points on a circle where the line AC is a diameter, then the angle \[Angle]ABC is a right angle. gs = GeometricScene[{"A", "B", "C", "O"}, {Triangle[{"A", "B", "C"}], CircleThrough[{"A", "B", "C"}, "O"], "O" == Midpoint[{"A", "C"}], Style[Line[{"A", "B"}], Orange], Style[Line[{"B", "C"}], Orange] } ]; RandomInstance[gs] FindGeometricConjectures[gs]["Conclusions"] ![enter image description here][4] ![enter image description here][5] ## Napoleons Theorem ## If regular triangles are constructed on the sides of any triangle, either all outward or all inward, the lines connecting the centres of those regular triangles themselves form an regular triangle. gs = GeometricScene[{"C", "B", "A", "C'", "B'", "A'", "Oc", "Ob", "Oa"}, {Triangle[{"C", "B", "A"}], TC == Triangle[{"A", "B", "C'"}], TB == Triangle[{"C", "A", "B'"}], TA == Triangle[{"B", "C", "A'"}], GeometricAssertion[{TC, TB, TA}, "Regular"], "Oc" == TriangleCenter[TC, "Centroid"], "Ob" == TriangleCenter[TB, "Centroid"], "Oa" == TriangleCenter[TA, "Centroid"], Style[Triangle[{"Oc", "Ob", "Oa"}], Orange]} ]; RandomInstance[gs] FindGeometricConjectures[gs]["Conclusions"] ![enter image description here][6] ![enter image description here][7] ## Finsler-Hadwiger Theorem ## ABCD and A BB CC DD are two squares with common vertex A. Let Q and S be the midpoints of BB D and DD B respectively, and let R and T be the centers of the two squares. Then the quadrilateral QRST is a square as well. gs = GeometricScene[{"A", "B", "C", "D", "BB", "CC", "DD", "Q", "R", "S", "T"}, {GeometricAssertion[{Polygon[{"A", "B", "C", "D"}], Polygon[{"A", "BB", "CC", "DD"}]}, "Regular", "Counterclockwise"], "Q" == Midpoint[{"BB", "D"}], "R" == Midpoint[{"A", "C"}], "S" == Midpoint[{"B", "DD"}], "T" == Midpoint[{"A", "CC"}], Style[Polygon[{"Q", "R", "S", "T"}], Orange]}]; RandomInstance[gs] FindGeometricConjectures[gs]["Conclusions"] ![enter image description here][8] ![enter image description here][9] ## Echols Theorem ## The midpoints of AD, BE, and CF in two equilateral triangles ABC and DEF form a regular triangle. gs = GeometricScene[{"A", "B", "C", "D", "E", "F", "L", "M", "N"}, {T1 == Triangle[{"A", "B", "C"}], T2 == Triangle[{"D", "E", "F"}], GeometricAssertion[{T1, T2}, "Regular"], "L" == Midpoint[{"A", "D"}], "M" == Midpoint[{"B", "E"}], "N" == Midpoint[{"C", "F"}], Style[Triangle[{"L", "M", "N"}], Orange] } ]; RandomInstance[gs] FindGeometricConjectures[gs]["Conclusions"] ![enter image description here][10] ![enter image description here][11] ## Simson Theorem & Steiner Theorem ## Simson's Theorem states that ABC and a point P on its circumcircle, the three closest points to P on lines AB, AC, and BC are collinear. Steiner's Theorem states that if the vertical center of triangle ABC is H, the Simson line passes through the midpoint of PH. gs = GeometricScene[{"A", "B", "C", "P", "L", "M", "N", "H", "S"}, {CircleThrough[{"P", "A", "B", "C"}], "L" \[Element] InfiniteLine[{"B", "C"}], "M" \[Element] InfiniteLine[{"C", "A"}], "N" \[Element] InfiniteLine[{"A", "B"}], PlanarAngle[{"P", "L", "B"}] == 90 \[Degree], PlanarAngle[{"P", "M", "C"}] == 90 \[Degree], PlanarAngle[{"P", "N", "A"}] == 90 \[Degree], Style[InfiniteLine[{"L", "M"}], Orange], GeometricAssertion[{InfiniteLine[{"A", "H"}], Line[{"B", "C"}]}, "Perpendicular"], GeometricAssertion[{InfiniteLine[{"B", "H"}], Line[{"A", "C"}]}, "Perpendicular"], Style[Line[{"P", "H"}], Orange], Line[{"P", "S", "H"}], Line[{"L", "S", "M"}] } ]; RandomInstance[gs] FindGeometricConjectures[gs]["Conclusions"] ![enter image description here][12] ![enter image description here][13] ## Aubel Theorem ## Starting with a given quadrilateral (a polygon having four sides), construct a square on each side.The two line segments between the centers of opposite squares are of equal lengths and are at right angles to one another. gs = GeometricScene[{"A", "B", "C", "D", "A'", "A''", "B'", "B''", "C'", "C''", "D'", "D''", "Oa", "Ob", "Oc", "Od"}, {GeometricAssertion[Polygon[{"A", "B", "C", "D"}], "Convex"], GeometricAssertion[{pa = Polygon[{"A", "B", "A'", "A''"}], pb = Polygon[{"B", "C", "B'", "B''"}], pc = Polygon[{"C", "D", "C'", "C''"}], pd = Polygon[{"D", "A", "D'", "D''"}]}, "Regular", "Counterclockwise"], "Oa" == Midpoint[{"A", "A'"}], "Ob" == Midpoint[{"B", "B'"}], "Oc" == Midpoint[{"C", "C'"}], "Od" == Midpoint[{"D", "D'"}], Style[Line[{"Oa", "Oc"}], Orange], Style[Line[{"Ob", "Od"}], Orange]} ]; RandomInstance[gs] FindGeometricConjectures[gs]["Conclusions"] ![enter image description here][14] ![enter image description here][15] ## Brahmagupta Theorem ## If a cyclic quadrilateral has perpendicular diagonals, then the perpendicular to a side from the point of intersection of the diagonals always bisects the opposite side. gs = GeometricScene[{"A", "B", "C", "D", "E", "M"}, {Polygon[{"A", "B", "C", "D"}], CircleThrough[{"A", "B", "C", "D"}], GeometricAssertion[{Line[{"A", "C"}], Line[{"B", "D"}]}, "Perpendicular"], Line[{"A", "E", "C"}], Line[{"B", "E", "D"}], "M" == Midpoint[{"A", "B"}], Style[InfiniteLine[{"M", "E"}], Orange], Style[Line[{"C", "D"}], Orange] } ]; RandomInstance[gs] FindGeometricConjectures[gs]["Conclusions"] ![enter image description here][16] ![enter image description here][17] ## Morley Theorem ## In any triangle, the three points of intersection of the adjacent angle trisectors form a regular triangle. gs = GeometricScene[{"A", "B", "C", "D", "E", "F"}, {Triangle[{"A", "B", "C"}], PlanarAngle[{"A", "B", "F"}] == PlanarAngle[{"A", "B", "C"}]/3, PlanarAngle[{"F", "A", "B"}] == PlanarAngle[{"C", "A", "B"}]/3, PlanarAngle[{"C", "B", "D"}] == PlanarAngle[{"C", "B", "A"}]/3, PlanarAngle[{"B", "C", "D"}] == PlanarAngle[{"B", "C", "A"}]/3, PlanarAngle[{"A", "C", "E"}] == PlanarAngle[{"A", "C", "B"}]/3, PlanarAngle[{"C", "A", "E"}] == PlanarAngle[{"C", "A", "B"}]/3, "D" \[Element] Triangle[{"A", "B", "C"}], "E" \[Element] Triangle[{"A", "B", "C"}], "F" \[Element] Triangle[{"A", "B", "C"}], Style[Triangle[{"D", "E", "F"}], Orange] } ]; RandomInstance[gs] FindGeometricConjectures[gs]["Conclusions"] ![enter image description here][18] ![enter image description here][19] [1]: https://reference.wolfram.com/language/ref/GeometricScene.html [2]: https://reference.wolfram.com/language/ref/FindGeometricConjectures.html [3]: https://blog.wolfram.com/2019/04/16/version-12-launches-today-big-jump-for-wolfram-language-and-mathematica/ [4]: https://community.wolfram.com//c/portal/getImageAttachment?filename=122401.jpg&userId=1013863 [5]: https://community.wolfram.com//c/portal/getImageAttachment?filename=801502.jpg&userId=1013863 [6]: https://community.wolfram.com//c/portal/getImageAttachment?filename=508803.jpg&userId=1013863 [7]: https://community.wolfram.com//c/portal/getImageAttachment?filename=222204.jpg&userId=1013863 [8]: https://community.wolfram.com//c/portal/getImageAttachment?filename=289105.jpg&userId=1013863 [9]: https://community.wolfram.com//c/portal/getImageAttachment?filename=932006.jpg&userId=1013863 [10]: https://community.wolfram.com//c/portal/getImageAttachment?filename=876507.jpg&userId=1013863 [11]: https://community.wolfram.com//c/portal/getImageAttachment?filename=184108.jpg&userId=1013863 [12]: https://community.wolfram.com//c/portal/getImageAttachment?filename=350909.jpg&userId=1013863 [13]: https://community.wolfram.com//c/portal/getImageAttachment?filename=500710.jpg&userId=1013863 [14]: https://community.wolfram.com//c/portal/getImageAttachment?filename=318711.jpg&userId=1013863 [15]: https://community.wolfram.com//c/portal/getImageAttachment?filename=254812.jpg&userId=1013863 [16]: https://community.wolfram.com//c/portal/getImageAttachment?filename=308813.jpg&userId=1013863 [17]: https://community.wolfram.com//c/portal/getImageAttachment?filename=934714.jpg&userId=1013863 [18]: https://community.wolfram.com//c/portal/getImageAttachment?filename=367015.jpg&userId=1013863 [19]: https://community.wolfram.com//c/portal/getImageAttachment?filename=16.jpg&userId=1013863 Kotaro Okazaki 2019-04-20T14:42:58Z