Personal Stories

Stories about how you have used Maple, MapleSim and Math in your life or work.

Math powers the world. From tracking the spread of an epidemic to designing a new rocket engine, mathematical equations allow us to understand a challenge and formulate an approach to solving it. Everywhere around us, math is ubiquitous; an equation determines how your thermostat controls your home furnace; a mathematical algorithm is used to encode the signal from your cell phone. More than ever, we rely on mathematics to make our lives better. And continually, our mathematical techniques get more refined as we solve more and more complex problems.

Greetings to all.

I am writing to alert MaplePrimes users to a Maple package that makes an remarkable contribution to combinatorics and really ought to be part of your discrete math / symbolic combinatorics class if you teach one. The combstruct package was developed at INRIA in Paris, France, by the algorithmics research team of P. Flajolet during the mid 1990s. This software package features a parser for grammars involving combinatorial operators such as sequence, set or multiset and it can derive functional equations from the grammar as well as exponential and ordinary generating functions for labeled and unlabeled enumeration. Coefficients of these generating functions can be computed. All of it easy to use and very powerful. If you are doing research on some type of combinatorial structure definitely check with combstruct first.

My purpose in this message is to advise you of the existence of this package and encourage you to use it in your teaching and research. With this in mind I present five applications of the combstruct package. These are very basic efforts that admit improvement that can perhaps serve as an incentive to deploy combstruct nonetheless. Here they are:

I hope you enjoy reading these and perhaps you might want to feature combstruct as well, which presented the first complete implementation in a computer algebra system of the symbolic method, sometimes called the folklore theorem of combinatorial enumeration, when it initially appeared.

Best regards,

Marko Riedel.


Partial rectification for the Physics:-Simplify and Physics:-Library:-SortProducts procedures dealing with Fermi annihilation/creation operators

This post will be useful for physicists dealing with Fermi annihilation/creation operators. Physics Package provides plenty of powerful tools for quantum operators handling, however some of them often fail to render correct result.  In particular incorrect behaviour with respect to Fermi annihilation/creation operators is observed for routines Simplify and SortProducts.  In this post I present my procedures S*implifyFermionicOperators and SortProductsFermi which partially solve these issues.

Problems with Physics Package routines

   

Short explanation of custom routines SimplifyFermionicOperators and SortProductsFermi

   

"Details for SimplifyFermionicOperators(z,prefix)"

   

"Details for SortProductsFermi(x,L,prefix)"

   

Weak points

   

Final notes

   


Download FermiCreationAnnihilation.mw

I would like to announce a new unofficial record computation of the MRB constant that was finished on Sun 21 Sep 2014 18:35:06.

I really would like to see someone beat it with Maple!

It took 1 month 27 days 2 hours 45 minutes 15 seconds. I computed 3,014,991 digits of the MRB constant, (confirming my previous 2,00,000 or more digit computation was actually accurate to 2,009,993 digits), with Mathematica 10.0. I Used my version of Richard Crandall's code:

 

____________________________________________________________________________

(*Fastest (at MRB's end) as of 25 Jul 2014.*)

DateString[]

prec = 3000000;(*Number of required decimals.*)ClearSystemCache[];

T0 = SessionTime[];

expM[pre_] := 

  Module[{a, d, s, k, bb, c, n, end, iprec, xvals, x, pc, cores = 12, 

    tsize = 2^7, chunksize, start = 1, ll, ctab, 

    pr = Floor[1.005 pre]}, chunksize = cores*tsize;

   n = Floor[1.32 pr];

   end = Ceiling[n/chunksize];

   Print["Iterations required: ", n];

   Print["end ", end];

   Print[end*chunksize]; d = ChebyshevT[n, 3];

   {b, c, s} = {SetPrecision[-1, 1.1*n], -d, 0};

   iprec = Ceiling[pr/27];

   Do[xvals = Flatten[ParallelTable[Table[ll = start + j*tsize + l;

        x = N[E^(Log[ll]/(ll)), iprec];

        pc = iprec;

        While[pc < pr, pc = Min[3 pc, pr];

         x = SetPrecision[x, pc];

         y = x^ll - ll;

         x = x (1 - 2 y/((ll + 1) y + 2 ll ll));];(*N[Exp[Log[ll]/ll],

        pr]*)x, {l, 0, tsize - 1}], {j, 0, cores - 1}, 

       Method -> "EvaluationsPerKernel" -> 4]];

    ctab = ParallelTable[Table[c = b - c;

       ll = start + l - 2;

       b *= 2 (ll + n) (ll - n)/((ll + 1) (2 ll + 1));

       c, {l, chunksize}], Method -> "EvaluationsPerKernel" -> 2];

    s += ctab.(xvals - 1);

    start += chunksize;

    Print["done iter ", k*chunksize, " ", SessionTime[] - T0];, {k, 0,

      end - 1}];

   N[-s/d, pr]];

t2 = Timing[MRBtest2 = expM[prec];]; DateString[]

Print[MRBtest2]

MRBtest2 - MRBtest2M

_________________________________________________________________________.

 

I used a six core Intel(R) Core(TM) i7-3930K CPU @ 3.20 GHz 3.20 GHz with 64 GB of RAM of which only 16 GB was used.

t2 From the computation was {1.961004112059*10^6, Null}.

 

 

 

Greetings to all.

As some of you may remember I have posted several announcements concerning Power Group Enumeration and the Polya Enumeration Theorem this past year, e.g. at this MaplePrimes link: Power Group Enumeration.

I have continued to work in this field and for those of you who have followed the earlier threads I would like to present some links to my more recent work using the Burnside lemma. Of course all of these are programmed in Maple and include the Maple code and it is with the demonstration of Maple's group theory capabilities in mind that I present them to you (math.stackexchange links).

The third and fourth to last link in particular include advanced Maple code.

The second entry is new as of October 30 2015.

With my best wishes for happy group theory computing with Maple,

Regards,

Marko Riedel

I see two recent items on the web about Mathematica and the rosettacode.org site. One was a Wolfram Inc. corporate blog post, and the other a post on Wolfram's relatively new community site.

There are many items on the page of tasks still without a submitted Maple implementation. It would be nice to see interesting implementations of some remaining tasks, as contributions from the Maple user base. The tasks remaining are of very mixed difficulty levels.

To date there are only 132 entries on the page for Maple implementations of that site's programming tasks. (Of these about 40 were submitted by one member while about 80 were submitted by another member.)

acer

I think we all know the routine. We walk to a large classroom, we sit down for a test, we receive a large stack of questions stapled together and then we fill in tiny bubbles on a separate sheet that is automatically graded by a scanning machine. We’ve all been there. I was thinking recently about how far the humble multiple choice question has come over the last few years with the advent of systems like Maple T.A., and so I did a little research.

Multiple choice questions were first widely-distributed during World War I to test the intelligence of recruits in the United States of America. The army desired a more efficient way of testing as using written and oral evaluations was very time consuming. Dr. Robert Yerkes, the psychologist who convinced the army to try a multiple choice test, wanted to convince people that psychiatry could be a scientific study and not just philosophical. A few years later, SATs began including multiple choice questions. Since then, educational institutions have adopted multiple choice questions as a permanent tool for many different types of assessments.

One of the biggest advances in the use of multiple choice questions was the birth of automatic grading through the use of machine-readable papers. These grew in popularity during the mid-70s as teachers and instructors saved time by not having to grade answer sheets manually.

Until recently, there has not been much advancement in this area.  It’s true, Maple T.A. can do so much more than just multiple choice questions, so this style of question is less important in large-scale testing than it used to be. But multiple choice questions still have their place in an automated testing system, where uses include leveraging older content, easily detecting patterns of misunderstanding, requiring students to choose from different images, and minimizing student interaction with the system. Luckily, Maple T.A. takes even the humble multiple choice questions to the next level. Now you might be thinking, how is that even possible given the basic structure of multiple choice questions? What could possibly be done to enhance them?

Well, for starters, in Maple T.A., you can permute the answers. This means you have the option to change the order of the choices for each student. This is also possible with machine-readable papers, but this does require multiple solution sets for a teacher or instructor to keep track of. With Maple T.A., everything is done for you. For example, if you have a multiple choice question in Maple T.A. with 5 answer choices, there are 120 different possible answer orders that students can be presented with. You don’t have to keep track of extra solution sets or note which test version each student is receiving. Maple T.A. takes care of it all.

Maple T.A. allows you to create Algorithmic questions - multiple choice questions in which you can vary different values in your question. And you aren’t limited to selecting values from a specific range, either. For example, you can select a random integer from a pre-defined list, a random number that satisfies a mathematical condition, such as ‘divisible by 3’ or ‘prime’, or even a random polynomial or matrix with specific characteristics. It allows an instructor to create a single question template, but have tens, hundreds, or even thousands of possible question outcomes based on the randomly selected values for the algorithmic variables. The algorithmic variables not only apply to the question being asked by a student, but also the choices they see in a multiple choice question.

You can even create a question where every student gets the same fixed list of choices, but the question varies to ensure that the correct response changes.  That’s going to confuse some students who are doing a little more “collaboration” than is appropriate!

Some of the other advantages of using Maple T.A. for multiple choice are also common to all Maple T.A. question types. For example, you can provide instant, customized feedback to your students. If a student gets a multiple choice question correct, you can provide feedback showing the solution (who is to say the student didn’t guess and get this question correct?) If a student gets a multiple choice question incorrect, you can provide targeted feedback that depends on which response they chose. This allows you to customize exactly what a student sees in regards to feedback without having to write it out by hand each time.

And of course, like in other Maple T.A. questions, multiple choice questions can include mathematical expressions, plots, images, audio clips, videos, and more – in the questions and in the responses.      

Finally, let’s not forget, in an online testing environment, there is no panic when you realized you accidently skipped line 2 while filling out your card, no risk of paper cuts, and no worrying about what kind of pencil to use!

References:

http://www.edutopia.org/blog/dark-history-of-multiple-choice-ainissa-ramirez

http://xkcd.com/499/

http://io9.com/5908833/the-birth-of-scantrons-the-bane-of-standardized-testing

Greetings to all.

I would like to share a brief observation concerning my experiences with the Euler-Maclaurin summation routine in Maple 17 (X86 64 LINUX). The following Math StackExchange Link shows how to compute a certain Euler-MacLaurin type asymptotic expansion using highly unorthodox divergent series summation techniques. The result that was obtained matches the output from eulermac which is definitely good to know. What follows is the output from said routine.

> eulermac(1/(1+k/n),k=0..n,18);
     1       929569        3202291        691                O(1)
O(- ---) - ----------- + ----------- - --------- + 1/1048576 ----
     19             15            17          11              19
    n      2097152 n     1048576 n     32768 n               n

                                           n
                                          /
        174611      5461        31       |      1           17        1
     - -------- + --------- + ------- +  |   ------- dk - ------- + ------
             19          13         9    |   1 + k/n            7        5
       6600 n     65536 n     4096 n    /                 4096 n    256 n
                                          0

         1       1
     - ------ + ---- + 3/4
            3   16 n
       128 n

While I realize that this is good enough for most purposes I have two minor issues.

  • One could certainly evaluate the integral without leaving it to the user to force evaluation with the AllSolutions option. One can and should make use of what is known about n and k. In particular one can check whether there are singularities on the integration path because we know the range of k/n.
  • Why are there two order terms for the order of the remainder term? There should be at most one and a coefficient times an O(1) term makes little sense as the coefficient would be absorbed.

You might want to fix these so that the output looks a bit more professional which does enter into play when potential future users decide on what CAS to commit to. Other than that it is a very useful routine even for certain harmonic sum computations where one can use Euler-Maclaurin to verify results.

Best regards,

Marko Riedel

Greetings to all.

It is a new year (for some time now) and I am writing to indicate that the mathematical adventures with cycle index computations and Maple continue!

Here are the previous installments:

My purpose this time is to alert readers who might be interested to a new cycle index computation that is neither an application of the classical form of the Polya Enumeration Theorem (PET) nor of Power Group Enumeration. The former counts objects being distributed into slots with a group acting on the slots and the latter objects going into slots with a second group which permutes the objects in addition to the slots being permuted. What I am about to present treats a third possible case: when the slot permutation group and the object permutation group are one and the same and act simultaneously (not exactly the same but induced by the action of a single group).

This requires quite radical proceedings in the etymological sense of the word, which is to go back to the roots of a problem. It seems that after working with the PET sooner or later one is confronted with enumeration problems that demand the original unmitigated power of Burnside's lemma, sometimes called the lemma that is not Burnside's. This is the case with the following problem. Suppose you have an N-by-N matrix whose entries are values from 1 to N, with all assignments allowed and the symmetric group on N elements acts on the row and column indices permuting rows and columns as well as the entries simultaneously. We ask how many such matrices there are taking these double symmetries into account. This also counts the number of closed binary operations on a set of N elemnents and there is a discussion as well as the Maple code (quite simple in my opinion and no more than a few lines) that solves this problem at the following Math Stackexchange link, which uses Lovasz Formula for the cycle index of the symmetric group which some readers may remember.

In continuing the saga of Polya and Burnside exploration I have often reflected on how best to encapsulate these techniques in a Maple package. With this latest installment it would appear that a command to do Burnside enumeration probably ought to be part of such a package.

Best regards,

Marko Riedel

Event?

January 2014: Pages of oldest Russian Maple Application Center have been opened 10000000 times.

http://webmath.exponenta.ru/

Greetings to all.

This past year I have on occasion shared mathematical adventures with cycle index computations and Maple, e.g. at these links:

Befitting the season I am sending another post to continue this series of cycle index computations. I present two Maple implementations of Power Group Enumeration as described by Harary and Palmer in their book "Graphical Enumeration" and by Fripertinger in his paper "Enumeration in Musical Theory." It was a real joy working with Maple to implement the computational aspects of their work, i.e. the Power Group Enumeration Theorem. Moreover the resulting software is easy to read, simple and powerful and has a straightforward interface, taking advantage of many different capabilities present in Maple.

The problem I am treating is readily described. Consider a cube in 3 space and its symmetries under rotation, i.e. rigid motions. We ask in how many different ways we may color the edges of the cube with at most N colors where all colors are completely interchangable, i.e. have the symmetric group acting on them in addition to the edge permutation group of the cube. At the following Math Stackexchange Link  I have posted the Maple code to implement the algorithms / formulas of Harary / Palmer / Fripertinger to solve this problem. The reader is invited to study and test these algorithms. It seems to me an excellent instance of computational combinatorics fun.

To conclude I would like to point out that these algorithms might be candidates for a Polya Enumeration Theorem (PET) package that I have been suggesting for a future Maple release at the above posts, the algorithms being of remarkable simplicity while at the same time providing surprisingly sophisticated combinatorics and enumeration methods.

Season's greetings!

Marko Riedel

Greetings to all.

As some of you may remember I made several personal story type posts concerning my progress in solving enumeration problems with the Polya Enumeration Theorem (PET). This theorem would seem to be among the most exciting in mathematics and it is of an amazing simplicity so that I never cease to suggest to mathematics teachers to present it to gifted students even before university. My previous efforts are documented at your site, namely at this MaplePrimes link I and this MaplePrimes link II.

I have been able to do another wonderful cycle index computation using Maple recently and I would like to share the Maple code for this problem, which is posted at Math StackExchange.com (this post includes the code) This time we are trying to compute the cycle index of the automorphism group of the 3-by-3-by-3 cube under rotations and reflections. I suggest you try this problem yourself before you look at my solution. Enjoy!

I mentioned in some of my other posts concerning PET that Maple really ought to come with a library of cycle indices and the functions to manipulate them. I hope progress has been made on this issue. I had positive feedback on this at the time here at your website. Do observe that you have an opportinuity here to do very attractive mathematics if you prepare a worksheet documenting cycle index facilities that you may eventually provide. This is good publicity owing to the fact that you can include images of the many geometric objects that appear which all look quite enticing and moreover potential readers get rewarded quickly as they discover that it takes little effort to master this theorem and proceed to work with symmetries themselves and investigate them. This sort of thing also makes nice slides.

With best wishes for happy combinatorics computing,

Marko Riedel

Greetings to all.

I have been using the numtheory package for quite some time now and it has helped me advance on a number of problems. Recently an issue came to my attention that I have known about for a long time but somehow never realized that it can be fixed. This is the fact that the numtheory package does not know about Dirichlet series, finite and infinite. Here are two links:

We’re conducting some market research, and we’re hoping some of you can help.  We’re interested in learning more about why people choose Maple over other systems, in particular Mathematica.  We know why we like Maple, but we’re interested in knowing why you do.

We’d love to hear from anyone who either compared both systems before choosing Maple or who used to be a Mathematica user and has now switched to Maple.  What led you to make your decision?

I made 3 years ago a SOKOBAN game using Maple for my Math/Programming class.

Here is a video of the application:

http://www.youtube.com/watch?v=l00l82_LK2Y

Have a nice day!

5 6 7 8 9 10 11 Last Page 7 of 21