## Nice polynomials, nice polynomials …

For my math class, I was attempting to create a curve sketching question by writing the second derivative as a factorable quadratic, and working backwards to an order-4 polynomial. Along the way, I would fill in the missing constant terms by using synthetic division on an arbitrary binomial factor, and striking upon a satisfactory polynomial by trial and error. What I was aiming for was for the original f(x) polynomial, its first derivative and its second derivative to all have rational roots. After about 6-8 hours of lackluster results (the only ones that worked by this method had triple roots), I tried the internet. It was then it became clear what an ambitious project this in fact was. I had downloaded graduate-level publications which try to tackle it. This has certainly helped me in generalizing the problem, but it appears to be something bordering on unwieldy given my time constraints.

First of all, such polynomials which are differentiable and have rational roots in their first and second derivatives are called “Nice” polynomials. The impression I am getting is that these are fairly rare and difficult to find. Ones without double or triple roots have so far been next to impossible with my method, which I thought was airtight.

Here was my plan:

1)      I make a second derivative as a quadratic, which has rational factors. This gives me my points of inflection for when I obtain f(x).

2)      Working backwards, the first derivative is found by the indefinite integral.  The result will be a polynomial with an unknown constant term. That can be found by choosing an arbitrary binomial factor and synthetic division.

1. Once that is done, you need to check to see if the whole of f ‘(x) can be factored. Of course, your arbitrary factor will always work, but you might find that the quadratic which remains will not factor further.
2. If you have no luck factoring the quadratic, your polynomial isn’t “nice”. Either use a different arbitrary factor or start over altogether.

3)      Working backwards once more, I found my quartic by finding f(x) through the indefinite integral of f ‘(x). I add the constant term once again by synthetic division using an arbitrary factor.

1. Whether the rest of it can factor is a separate question, so I must factor the remaining cubic to see if I get 3 rational roots.
2. If it fails, the polynomial is not “nice”. Either pick a different arbitrary factor or start over.

You might want to make a compromise and tell yourself that you’re willing to live with a situation that when using synthetic division, you wind up with quadratics that have real roots, but everything else works out OK. Then, your students have to use the quadratic formula, which isn’t necessarily a bad thing. It’s just that I don’t think such roots should occur too early. Getting them in f(x) is fine, but not really OK for its derivatives.

## How to spend an idle afternoon

Yesterday, I told another fellow computer geek an ’80s DOS joke about being prompted to “Enter any 11-digit prime number and press ENTER to continue.” She then suggested that a number with 11 1’s might be prime.  Having encountered this before in programs I’ve written, I warned her that you can’t assume all sequences of 1’s are prime, having previously tried this on numbers like 11; 111  1,111; 11,111; 111,111 and so on. 1 itself is neither prime nor composite, so it doesn’t count.

But of course, was 11,111,111,111 prime? There was no direct way of knowing that, and even an attempt to write a C program ran me into trouble, since said number is one digit beyond double precision, and I can’t get the “%” operator to work with floating point anyway. Long int will cause an overflow; casting long double as any kind of int will result in undefined behaviour. And admittedly, I didn’t want to spend hours at this. The only thing that came out of this is that I needed to brush up on my C coding.

The prime detectors I saw on the web also choked on 11 digit numbers. There were exceptions, however. The prime number calculator at math.com could do it. 21,649 was a factor of 11,111,111,111.

(Late edit) I tried using Maple to find primes consisting of ones, and the lowest number I can find besides 11 was the number: 1,111,111,111,111,111,111, or 1 quintillion and change (maybe 1 million billion if you are old-school).

## HP 35s Calculator Annoyances III

I keep saying how much of a fan I am of the RPN mode, and have used it on and off since high school. But times have changed, and HP needs to find a way to manipluate the logic of repeated calculations to make RPN still come out on top, but I feel discouraged, and feel there is no turning back.

I’ll tell you why. For one thing, you can’t enter any calculation in a mode involving stacks and operators, which is at the heart of RPN logic, and expect it to repeat without some way of remembering each operator and number you pressed. And the only way to do that is to really learn how to program this calculator, then preferably bind the program to a key. So, this is really not a calculator for sissies. At least, not unless you stay in algebra mode.

There was one more thing that I don’t think I’ve mentioned: viewing numbers in scientific notation sometimes requires you to use the scroll feature. This is because it will show you as many as 12 digits, pushing the power of 10 exponent off the immediate display.You need the left arrow to see what you missed.

## HP Calculator Annoyances II

I am as much of a fan of the RPN mode as anyone. But the implementation of RPN in the HP calculators have to keep up with new developments in technology.

For one thing, I had trouble in RPN mode, to make a list of random numbers. Suppose you wanted to make a list of numbers with a certain variability such as:

`150 + 25*RAND`

I would do this to generate a list of random numbers with a minimum of 150, and a maximum of 175. RAND is the random function which generates a number between 0 and 1. In RPN, I would need to enter 150 and 25 in a stack, then my RAND, then * and then +.  That generates one such random number. To generate more numbers, such as a list of 25 numbers, you need to go through the whole thing again, 24 more times. It may have been necessary 20 years ago to actually repeat the same keypresses over and over like this, but dual displays have been around for slightly longer than 20 years, making these operations a lot less error prone, and way more efficient.

You may do this calculation better in algebra mode, using the left arrow key to go back to the statement you typed in, then press ENTER to get the new number. This will cause fans of RPN to vascillate back and forth between algebra and RPN modes whenever they need to take advantage of certain features. It is likely that the official HP claim that RPN is more efficient with respect to key presses is becoming less and less true as technology improves, unless HP can figure out how to repeat a stack of numbers and operators.

More on this next Wednesday.

## More on the HP 35s Calculator

I have kept some notes as I was performing an stats operation on a list of numbers. Most of the time the interface on most calculators is intuitive enough that you don’t really need the manual to do things like stats or common operations on the scientific calculator. The Sharp calculator has data entry for stats refined to the point where you can return to any list member and correct the entry.

Stats on the HP35s is of the “old school” variety, with an important change: the calculator is always in single variable stats mode. Hitting the “Sigma+” key on the bottom of the keypad is enough to begin your entry, and this means you can interrupt your data entry at any point and to any other calculation that you need to do. This is true in both RPN and Algebra mode.

One annoying feature I found is that if you have a syntax error, there is no “clear error” or “clear” button that will instantly remedy it. All attempts to clear the display have to be done through a “clear” button that is made as a second function to the backspace key (the backspace key is the other way to clear your error, one character at a time, using the arrow keys to help you). To clear everything (“clear/all”) requires you to go through 2 layers of menus.

## What is old is new: RPN on the HP 35s Scientific Calculator part 1

When I comment on technology, I like to discuss the good and the bad about it. I don’t sell calculators, and I don’t get freebies to review. That gives me the freedom to freely comment.

One has to admit that for HP to sell a \$90 RPN calculator in this age of \$20 textbook display calculators takes guts, especially if said \$90 calculator does not have graphical capabilites. HP has been making RPN calculators since the 1970s. In the 80s, they had their heyday when their top-of-the line calculators not only had programmability, but even came with complex functions stored on cards on which was mounted a piece of magnetic tape on the small plastic card which one would swipe through a reader inside the calculator. Every key including the number key seemed to have at least 3 functions, and usually 4.  It was a great technology, but the calculators were quite pricey, but loved by statisticians, university professors and math nerds everywhere.  The common theme in all of these calculators was that their input was required to be in reverse Polish notation, or RPN.

In RPN, you enter your two operands, and press the button for the operator last. This requires an “Enter” key; and since the calculation is over once you press the operator, there is no need for an equal sign. In fact, the keypads are noted for their lack of an equal sign.

On a normal calculator, entering “2 + 2” is a matter of entering the operands and opereator in the order you would write them down. For RPN, you enter “2 2 +”, hitting an “Enter” button after each “2”. The advantage of RPN, to those who have the patience to give themselves such a habit of thought for this, is that the overall effect is that you can do a reasonably complex calculation with fewer keystrokes, than on a conventional calculator. And while it promised efficiency, it was never a calculator for button monkeys. To take advantage of  RPN’s efficiency you always needed to think carefully about the calculation. But I must state that HP is ready for today’s generation: they do in fact, provide an “algebraic” mode where it uses the common algebraic syntax you would expect on most other calculators, but on my calculator, it was RPN that was the default.

## Zero

Once upon a time, around the year 525 during the reign of Pope John I, a monk named Dionysius invented the idea of Anno Domini by producing a calendar which marked the time since the birth of Christ. The numbering of the years was adopted for the Julian Calendar, a calendar created 600 years previous under the reign of Julius Caesar. The Julian Calendar allows for 12 months, 365 days per year, and 366 on leap year, once every 4 years. The numbering of the years would change with Anno Domini.

The calendar lost 11 minutes per solar year, then over time, 3 entire days out of every 400 years, so that by 1582 under Pope Gregory, a new calendar was issued that made that correction. Now, under what is known as the Gregorian Calendar, a leap year will happen every 4 years, and on years divisible by 400; but not on years divisible by 100. 1900 was not a leap year, but 2000 was.

But there was a bigger problem in the concept of Anno Domini. There was no year zero. A kid born on 1 BC would be 3 years old by 3 AD. But if you subtract, you get the wrong answer: 3 − (-1) = 4, and this is because there is no year zero in the calendar. For the Dionysian calendar, the counting is: -1, 1, 2, 3, rather than -1, 0, 1, 2, 3. The blame cannot be laid at the feet of Dionysius alone, however. Dionysius did not know of the number zero, because the number had not been known to the Romans, nor the Greeks, and not even the Church, for hundreds of years.

Well, it kind of did. The Arab world had known and used the number in their counting system since at least the days of the Greeks, and possibly before. Aristotle stated that there was no such a thing as a vacuum, and thus the very idea of zero, or of “nothing” as being countable, was anathema to Greek philosophy. Greek geometry, with all of its laws and proofs,  had to proceed without it. They were aware that zero was being used by the Babylonians, but the Greeks had a good thing going with their pursuit of philosophy and didn’t want it being messed up by the introduction of zero.

This meant that the Romans, who did not pursue philosophy so much, had no zero in their rather cumbersome number system. And the Catholic church, who embraced Aristotle, had no zero for hundreds of years, and didn’t even question Aristotle’s idea of a vacuum until the 13th century. While the Catholics liked a rational God, and pursued philosophy and mathematics in their monasteries during the so-called “Dark Ages”, and even started the university system some time after the 10th century, did not see until much later how zero could actually fit in with their theology regarding “the void” and “the infinite”.

In the meantime, a calendar had been produced that had no year zero. This meant that centuries do not begin at multiples of 100, they have to begin at 100 + 1. While everyone was euphoric over the year 1999 becoming the year 2000, really the 21st century didn’t begin until 2001.

## Magic Squares: Errata

There were some mistakes with the construction of the prime-ordered magic squares. These mistakes ought to give us hope in finding squares that, if n is a prime 5 or greater, you will indeed get (n!)2 magic squares with a random method. I had always maintained that, and until now I never had a reason to question it. And once again, the only reason I questioned it is because there was a mistake in how I remembered the algorithm.

After completing a program written on an Excel 2007 spreadsheet using Visual Basic for Applications, and reading my copy of Reichmann a little more closely, I now see that some corrections need to be made to the articles I have previously written. Corrections are forthcoming, and those articles will be updated.

## Recreational Math I: Magic Squares: the “really good” kind – Part 6

Welcome to part 6, where the magic squares are 7×7. 7 was the number of known planets in medieval times, as well as the number of known elements, and the number of days in the week. The rest is all alchemy.

The algorithm for a 7×7 matrix is the same as for 5×5. In fact, it should work for any odd prime-ordered matrix. Do the first based on a random sequence of the numbers between 1 and 7:

 1 6 2 3 4 7 5 7 5 1 6 2 3 4 3 4 7 5 1 6 2 6 2 3 4 7 5 1 5 1 6 2 3 4 7 4 7 5 1 6 2 3 2 3 4 7 5 1 6

Now, do the second matrix using 0 and every seventh number after it up to 42:

 7 42 0 21 14 35 28 0 21 14 35 28 7 42 14 35 28 7 42 0 21 28 7 42 0 21 14 35 42 0 21 14 35 28 7 21 14 35 28 7 42 0 35 28 7 42 0 21 14

The resulting matrix is magic, but not “hyper-magic” like the 5x5s were:

 8 48 2 24 18 42 33 7 26 15 41 30 10 46 17 39 35 12 43 6 23 34 9 45 4 28 19 36 47 1 27 16 38 32 14 25 21 40 29 13 44 3 37 31 11 49 5 22 20

The matrix above was done using Excel, and checked using VBA, where I checked it for “magic”. The loss of hypermagic is unfortunate, but I suppose inevitable when you scale up. There are (7!)2 = 25,401,660 magic squares possible by this algorithm. The VBA proved handy later when I used dynamic programming to produce any odd-ordered magic square of any size, and investigated the results.

What if I made a mistake and got the shifting wrong, such as shifting from the second number from the left instead of the right? The result is variable; full magic can only be restored if the rightward diagonal is all 4/s:

 7 3 6 2 5 1 4 3 6 2 5 1 4 7 6 2 5 1 4 7 3 2 5 1 4 7 3 6 5 1 4 7 3 6 2 1 4 7 3 6 2 5 4 7 3 6 2 5 1

Why does this work? This is because the sum of the numbers 1 to 7 in any order is 28. Notice that whatever number is in the opposite diagonal is repeated 7 times. There is only one number, when multiplied by 7, equals 28, and that is 4. All other numbers will result in a loss of magic. This appears to be a way to maintain magic in all odd-ordered magic squares past order 7. This can possibly generalize for squares of prime order n by taking the middle number (n+1)/2 and making it the main diagonal.

When added to the second preliminary square, both diagonals became magic, as well as the columns and rows. But because the opposite diagonal consists of all 4’s, we lose variety with this restriction, but not by much: 7!6! = 3,628,800. Still enough to occupy you on a rainy day.

9×9 magic squares won’t work so well, because the second square is shifted by 3, which is a number that divides 9. This will result in certain rows repeating in one of the pre-squares; and the result generally is that one of the diagonals won’t total the magic number (369 in this case).

 13 66 78 59 27 8 34 38 46 74 55 22 3 33 41 54 17 70 26 7 29 37 49 12 69 77 63 32 45 53 16 65 73 58 21 6 48 15 68 81 62 25 2 28 40 64 76 57 24 5 36 44 52 11 61 20 1 31 39 51 14 72 80 9 35 43 47 10 67 75 60 23 42 50 18 71 79 56 19 4 30

This is a consequence of 9 not being a prime number. The algorithm that works so well for 5×5 and 7×7 magic squares breaks down when the odd number is composite. Thus, the algorithm is known to work for 11×11, 13×13, 17×17, and has been tried all the way to 101×101 and beyond on my Excel spreadsheet.

The magic number can be known in advance of any magic square because an order-n magic square obeys the formula (n × (n2 + 1))/2. The best bet is to look for odd-ordered n × n squares where n is prime. In my VBA program, I made double sure by sticking to magic squares where the order is prime. Here is an 11 × 11 square, where the magic number is 671:

 112 20 60 87 3 41 92 33 105 51 67 62 78 2 42 93 32 102 52 70 121 17 11 39 95 23 101 53 71 120 14 63 81 96 26 110 50 73 111 13 64 82 10 36 109 47 74 114 22 61 84 1 35 97 27 75 115 21 58 85 4 44 94 29 100 46 12 57 86 5 43 91 30 103 55 72 117 83 7 34 90 31 104 54 69 118 15 66 37 99 28 106 45 68 119 16 65 80 8 25 107 48 77 116 18 56 79 9 38 98 49 76 113 19 59 88 6 40 89 24 108

Finally, to stretch things out to the boldly absurd, what about an order-23 square whose magic number is 6095?

 92 369 279 275 108 466 226 403 125 327 360 316 55 457 485 14 192 182 234 425 36 145 524 283 271 115 461 210 413 131 328 364 311 56 442 498 17 193 181 232 428 31 159 510 80 381 103 473 214 409 138 323 348 321 62 443 502 12 194 166 245 431 32 158 508 83 376 297 257 228 395 126 335 352 317 69 438 486 22 200 167 249 426 33 143 521 86 377 296 255 106 468 129 330 366 303 57 450 490 18 207 162 233 436 39 144 525 81 378 281 268 109 469 227 393 365 301 60 445 504 4 195 174 237 432 46 139 509 91 384 282 272 104 470 212 406 132 331 63 446 503 2 198 169 251 418 34 151 513 87 391 277 256 114 476 213 410 127 332 350 314 488 15 201 170 250 416 37 146 527 73 379 289 260 110 483 208 394 137 338 351 318 58 447 196 171 235 429 40 147 526 71 382 284 274 96 471 220 398 133 345 346 302 68 453 489 19 236 433 35 148 511 84 385 285 273 94 474 215 412 119 333 358 306 64 460 484 3 206 177 45 154 512 88 380 286 258 107 477 216 411 117 336 353 320 50 448 496 7 202 184 231 417 507 72 390 292 259 111 472 217 396 130 339 354 319 48 451 491 21 188 172 243 421 41 161 386 299 254 95 482 223 397 134 334 355 304 61 454 492 20 186 175 238 435 27 149 519 76 266 99 478 230 392 118 344 361 305 65 449 493 5 199 178 239 434 25 152 514 90 372 287 464 218 404 122 340 368 300 49 459 499 6 203 173 240 419 38 155 515 89 370 290 261 113 399 136 326 356 312 53 455 506 1 187 183 246 420 42 150 516 74 383 293 262 112 462 221 324 359 307 67 441 494 13 191 179 253 415 26 160 522 75 387 288 263 97 475 224 400 135 308 66 439 497 8 205 165 241 427 30 156 529 70 371 298 269 98 479 219 401 120 337 362 452 500 9 204 163 244 422 44 142 517 82 375 294 276 93 463 229 407 121 341 357 309 51 10 189 176 247 423 43 140 520 77 389 280 264 105 467 225 414 116 325 367 315 52 456 495 180 242 424 28 153 523 78 388 278 267 100 481 211 402 128 329 363 322 47 440 505 16 190 430 29 157 518 79 373 291 270 101 480 209 405 123 343 349 310 59 444 501 23 185 164 252 141 528 85 374 295 265 102 465 222 408 124 342 347 313 54 458 487 11 197 168 248 437 24

That probably ran into the neighbouring columns, but it’s just for illustration. The code, which I have used to generate magic squares of as high an order as 113 (magic number 721,505) is fewer than 170 lines in VBA for Excel 2007. And yes, even the above square, and the order 113 square are magic.

## Recreational Math I: Magic Squares: the “really good” kind – Part 5

I have met with some disappointment as to how a methodology for creating a 4×4 square should pan out, and instead I have come up with many different algorithms, each resulting in its own small sets of magic squares, but had stumbled upon a set of squares with similar “hyper-magical” properties which I called the Durer Series.

I had met with some disappointment at this, and am still in the middle of writing my own 4×4 square program in Visual Basic .NET (it’s going to use a “brute force” algorithm … sorry!). With that, I had to learn about how .NET does objects. To those of you out of the loop on the recent .NET versions of VB, this language actually allows you to create your own novel objects, thus saving processing time if the right kind of objects are created. It’s a work in progress.

For now, I wanted to centre on the pièce de résistance of this series: that of the odd-ordered magic squares, those of order 5 and beyond. But it can’t just be any odd number. For the algorithm to work, the order of the square has to be a prime number greater than 5. As I hinted at the beginning of this series, these are special and unique in that an algorithm can be made for an order-n magic square (where n is an odd prime) which can generate (n!)2 squares, all magic (even after weeding out duplicates, the numbers of unique squares will still be in the thousands).

This seems to be a hard-to-find algorithm, except from a book called The Fascination of Numbers, written on the year of The Queen’s coronation in 1957 by W. J. Reichmann while he was still a headmaster at a Grammar School located in Spalding, Lincolnshire, England (according to my signed copy of the book, purchased from an English vendor through Amazon used books). I read it for the first time at a university library, and it is likely to be found in a similar univeristy or college collection near you.

What I like about this algorithm is that while I have used it to write computer programs for magic squares, it really requires no more than pencil and paper, and a bit of skill at addition.

First of all, write down the numbers from 1 to 5, in any order at all:

`3, 2, 1, 5, 4`

A 5×5 square matrix is constructed in a pattern by starting from the fourth number in the sequence, then proceeding with the 5th number, then the first, second and finally the third:

```4 2 1 5 3
5 3 4 2 1
2 1 5 3 4
3 4 2 1 5
1 5 3 4 2
```

Next, scramble the first 5 multiples of 5 (counting 0):

`20, 0, 5, 15, 10`

Create a 5×5 matrix by shifting the order of these numbers by 2 to the left as follows:

```20  0  5 15 10
5 15 10 20  0
10 20  0  5 15
0  5 15 10 20
15 10 20  0  5
```

Now add them together, adding together numbers located in the same columns and rows in both squares, as in matrix addition:

 24 2 6 20 13 10 18 14 22 1 12 21 5 8 19 3 9 17 11 25 16 15 23 4 7

The result is a magic square which has many more ways of obtaining  the magic number 65 than just adding the rows, columns, and diagonals. Taking any 3×3 sub-square on the corners or left/right sides of this square and adding its corner numbers to the middle number will obtain 65. This seems to be true of all magic squares made by this method. Since both squares can be scrambled independently, there will be (5!)2 = 14,400 possible squares before duplicates are weeded out. I have written programs in many languages regarding this 5×5 square, and can attest to the robustness of this algorithm in producing a nearly endless series of 5×5 magic squares, all sharing very similar “magical” properties.

Reichmann also reminds us that the scrambled 5×5 squares we created initially are also magic.

I suspect there may be more than 14,400 magic squares. Are there any squares that cannot be produced by this algorithm? This must be checked against a “brute-force” (read: computational) method for generating all possible magic squares to see if this is really the definitive number. It is certainly a couple of orders of magnitude greater than what Danny Dawson did with his 4×4 squares (around 920 squares or so, with some duplicates). It would also be interesting to know what squares could not have originiated from Reichmann’s algorithm (proven by working backwards to show, supposedly, that duplicate numbers appear in some rows of the first or second matrix, which disappears in the resultant matrix.

It also seems that 4×4 and 5×5 squares can have such “compound” magical properties; it is harder to find for 7×7 matrices, although they are additive to the magic number in just enough ways so as to say they are magic. We’ll leave that for the next journal entry.

## Recreational Math I: 4×4 squares: Some sequences work better than others

I was experimenting with Danny Dawson’s 4×4 magic square script, and began to consider writing my own script. But I just thought I would do a few runs for my own research. I wanted to thank Mr. Dawson for his fine work which I am obviously gaining knowledge from, but his comments page thought I was a spam bot, and rejected my comments. Oh well ….

The central topic of discussion here centers on building an algorithm for a computer program that can search for and find all or most squares, centering on initial construction. But the discussion on pairings work for magic squares generally.

Some number pairings work better on the 4×4 square than others. What I mean by number pairings are two sequential numbers being placed next to each other along a column or row of the magic square. Dawson’s script allows me to place any numbers on the magic square, and it would output all of the magic squares that fit the arrangement of numbers I suggested by filling in the rest. I only worked with two numbers, and it would suggest to me complete squares which work with that placement of a pair of numbers. Some number pairs resulted in more than one magic square, while other pairs gave no squares.

It would tell me that in a computer algorithm for such squares, if an “unsuccessful” pair of numbers show up next to each other in a magic square made by a brute force algorithm such as Dawson’s, the smart thing to do is to detect this situation and abandon the square’s construction, thus saving computer procesing time, an amount of time Dawson attested to as being potentially long, on the order of hours at best, to decades at worst.

My research was far from thorough, but I think I took into account most situations where the pairings would show up, barring left-right reflections, rotations, or up-down reflections of the same square.  It is possible I may have missed some, due to clues that seemed to be left behind by some of the successful combinations. And I only considered pairings of sequential numbers, not just any pairings of numbers, of which there are (16 × 15)/2 = 120 combinations.

First, the combinations of sequential numbers that were NOT successful: “3  4”, “7  8”, “9  10”, “11  12” and “13  14”. Finding these pairs next to each other resulted in nothing output in all of the ways they might show up that I’ve tried. This is likely not the true situation, since when I tried “5  6”, only one unique square was found (and no others); while an attempt to try the famous Durer pun “1514” on two adjacent squares resulted in nothing until I moved the “15  14” to the centre columns of the top row. No other unique solutions were found for the Durer pun. None at all.

If a programmer were serious to find such “rare” solutions, then he or she would not consider ignoring these sequential pairs. On the other hand, if missing a half dozen or so squares is not important, then one is wise to look for these sequences in a row or column and abandon all such squares to save time, rather than making a square that is destined to fail.

In fact, it would be worth considering to check for these pairings before checking for “magic”, although both the pairings and magic can be done on-the-fly, during construction as a way of bailing out early and moving on.

All other successful pairings:

• 1 2, and 2 3 both gave generous numbers of squares
• 4 5: gave patterns reminiscent of the Durer square
• 5 6: only 1 square was found in my trials
• 6 7, 8 9, 10 11, 12 13: all gave generous numbers of squares
• 14 15: only worked if these numbers appeared in the middle columns of the top row (means that the bottom row and both left and right sides should work also; in addition, the “15 14” combination should work in the same way) (11 solutions)
• 15 16: Gave a few solutions, but only in the first and second cells of the first row, as far as I can tell.

Obviously, the five “failed” pairings given above are not the whole picture. Of the 120 possible pairs of numbers between 1 and 16 that can exist, there are obviously more pairs that would result in no square being formed, thus saving more time.

## Recreational Math I: Magic Squares: the “really good” kind – Part 4

How to Make a Random Square

I have noticed that it has been difficult to elucidate a method for systematically creating even-ordered magic squares of any but the most basic kind. I don’t know why this is, since the art has been alive in Europe for at least 600 years, and probably longer in other cultures. There are a few methodologies out there, but they are perfunctory. Such as, this method offered by Reichmann (1957), which tells us little more than to write the numbers down from 1 to 16 and reverse the order of the diagonals:

``` 1  2  3  4        16  2  3 13
5  6  7  8  ====>  5 11 10  8
9 10 11 12         9  6  7 12
13 14 15 16         4 14 15  1
```

Well, only a limited number of magic squares are possible that way. You can reverse the order of the numbers, or write the numbers in order down the columns instead of the rows, followed by a similar reversal of the diagonals (these would not be considered to be unique solutions, since these methods amount to mirroring or rotating the square).

After some playing around with known 4×4 magic squares (thanks to the thorough resource offered here), and using some simple rules, I think I may have come upon a method on my own. I would suppose that it could not generate all magic squares possible, but I don’t intend to offer a complete solution. I estimate that I would be able to generate maybe another 10 or so magic squares with this method. The intent here is to allow the reader to create a 4×4 magic square sitting down at a table with little more than pencil and paper. I am sure this methodology is published elsewhere, but I wasn’t able to come up with anything.

I just have a few simple rules in coming up with the method. First of all, all of the 16 numbers are the result of a sum of two smaller numbers a and b, where a is a number from 1 to 4 such that a = {1, 2, 3, 4}, and b is a multiple of 4: b = {0, 4, 8, 12}. All 16 unique numbers generated will be the result of adding a number from set a to a number in set b.

The numbers 1, 2, 3 and 4 are the result of adding set a to 0 in set b.

The numbers 5, 6, 7, 8 come from adding set a to 4 in set b.

The numbers 9, 10, 11, 12 come from adding set a to 8 in set b.

And the numbers 13, 14, 15, 16 come from adding set a to 12 in set b.

My solution is inspired by Reichmann’s (1957) work on odd-ordered matrices. This solution on even-ordered matrices is quite different than for odd-ordered matrices, but the idea of adding two matrices and getting a magic square appealed to me, so I went with that basic idea.

The first matrix uses numbers from set a, in the following pattern:

```4  3  2  1
1  2  3  4
1  2  3  4
4  3  2  1
```

These numbers may be randomized, but I’ll just stick to numeric order for now. The second matrix is composed of the numbers of set b arranged in a pattern reminiscent of the Durer square:

```12  0  0 12
4  8  8  4
8  4  4  8
0 12 12  0
```

The sum of the two matrices has all the magic of the Durer square, and consist of the unique numbers 1 to 16:

```16  3  2 13
5 10 11  8
9  6  7 12
4 15 14  1
```

In fact, it is the Durer square itself. Now that we know it works, what about mixing things up? Take note of the patterns. Let the first matrix represent numbers {a, b, c, and d} belonging to set a; and {e, f, g, and h} belonging to set b. whatever randomization is chosen, the numbers must fit the following scheme:

```a  b  c  d      e  h  h  e
d  c  b  a      f  g  g  f
d  c  b  a   +  g  f  f  g
a  b  c  d      h  e  e  h
```

a, b, c, and d may be any permutation of the numbers 1 to 4, without apparent limitation. The second and third rows on teh first matrix are the reversals of the first and fourth. The second matrix, however is much more restricted. Considering e and f to be one pair; g and h to be another pair: 12 can only be paired on the same row with 0; and 4 only be paired with 8. Otherwise, no joy.

So, on with a randomized square: let a = {3, 1, 4, 2} and b = {8, 0, 12, 4}

```3  1  4  2     8  4  4  8     11  5  8 10
2  4  1  3     0 12 12  0      2 16 13  3
2  4  1  3  + 12  0  0 12  =  14  4  1 15
3  1  4  2     4  8  8  4      7  9 12  6
```

What about a = {2, 4, 1, 3}, and b = {4, 12, 0, 8}

```2  4  1  3      8  4  4  8     10  8  5 11
3  1  4  2     12  0  0 12     15  1  4 14
3  1  4  2  +   0 12 12  0  =   3 13 16  2
2  4  1  3      4  8  8  4      6 12  9  7
```

You may also treat sets a and b oppositely, while randomizing. This time the restriction is on matrix a — 4 pairs with 1, and 2 pairs with 3:

```3  2  2  3     8 12  0  4     11 14  2  7
4  1  1  4     4  0 12  8      8  1 13 12
1  4  4  1  +  4  0 12  8  =   5  4 16  9
2  3  3  2     8 12  0  4     10 15  3  6
```

The reason I say these squares are limited to about 10 or so, is because as you can see, the individual rows or columns end up being about the same — at best, a shuffling or reversal the same rows found in the Durer square. There are at best 24 such squares, not subtracting tilted (squares the same when laid on its side) or reflected squares (where the squares are mirror images of each other). All that might be said, is that we may have discovered all the ways a magic square may be constructed with the same “hyper-magic” as the Durer square, which may be a pretty cool thing to say actually. It’s just that my goal was more ambitious at the start. I will refer to the set of 4×4 hypermagic squares built on the same rules as “the Durer series.”

Any known magic square, however, is the result of a unique combination of the basic squares built on sets a and b. Respectively, I will call the matrices A and B.  This allows us to work backwards from a 4×4 square we know is magic, and discern any patterns. The above squares were done that way. What patterns can be observed for the following square, which this website offers as #379 out of 900 or so others?

```                Matrix "A"      Matrix "B"
13 12  6  3     1  4  2  3     12  8  4  0
10  5 11  8     2  1  3  4      8  4  8  4
7 16  2  9  =  3  4  2  1  +   4 12  0  8
4  1 15 14     4  1  3  2      0  0 12 12```

One may discern a pattern here, but it is not all that obvious, especially for the square built on set b. It doesn’t seem to resolve itself into simple rules and patterns the way the Durer series of squares did. Also, you might have noticed that this square is not quite as “magic” as the Durer series, though all rows, columns, and both diagonals give you 34.

But I do notice that in matrix A the last column is a reversal of pairs of the first column. Also, the third column is built on the middle numbers of the first column, and the second column are built on the middle numbers of the last column.

What of Matrix B? The first and last columns are reversals (of all 4 numbers, not of pairs), the second and third both start with the middle two numbers, then first, then last from their adjacent end columns: “e f g h” becomes: “f g e h”.

When I tried to build on these rules, I got duplicate numbers in my squares (and with that, some missing numbers). It would appear that the observable number patterns in such squares are limited to getting you maybe 4 to 8 unique squares, then you have to make a new set of rules each time. With over 900 squares discovered (give or take a duplicate or two), that’s a lot of rules. The total number of 4×4 squares, both magic and not, are equal to 16! = 21 trillion possible squares. Finding all possible magic squares, weeding out any duplicates, reflections, and sideways duplicates would seem a tad non-trivial. Even at the website I referred to for these squares, it has been shown that the number “924” claimed as the number of possible 4×4 magic squares, might be too high, due to some duplicates found. Their scripts took just under 25 seconds to generate and check these squares — but just to check them for magic, less so for duplication, which sounds like it would take more computer time.

## Recreational Math I: Magic Squares: the “really good” kind – Part 3

Notice that to show the rules for making these kind of magic squares, I used only odd-ordered square matrices as examples. What about matrices of even numbers of rows and columns? The rules for these vary.

The famous Durer magic square, with the year of the engraving cleverly made a part of a magic square, has a certain organization in its construction, as well as a certain symmetry. The numbers are constructed, in sequence:

```_   3   2   _        _   3   2   _
_   _   _   _        5   _   _   8
_   _   _   _  ====> _   6   7   _
4   _   _   1        4   _   _   1

_   3   2   _       16   3   2  13
5  10  11   8        5  10  11   8
9   6   7  12  ====> 9   6   7  12
4   _   _   1        4  15  14   1```

So, you start from the bottom right and proceed in a horseshoe to the top then the bottom left. The next diagram places the numbers 5-8 in a pattern that is left-to-right u-shape. Then the same u-shape for the numbers 9-12 from left to right, except this time it’s upside-down. Finally ending as we started, the same horseshoe shape (except right side up) from right to left.

Durer’s square has many things about it, apart from its magic number (34) which works on all the attendant diagonals, rows and columns. The middle 4 squares add up to 34 (10 + 11 + 6 + 7 = 34); the four corners add to 34 (16 + 13 + 4 + 1 = 34), and all corner foursomes add to 34: (16 + 3 + 5 + 10); (2 + 13 + 11 + 8); (9 + 6 + 4 + 15); and (7 + 12 + 14 + 1).

The numbers at the ends of the two middle rows add to 34:

```16   3   2  13
5  10  11   8
9   6   7  12
4  15  14   1
```

and the numbers at the tops and bottoms of the two middle columns add to 34:

```16   3   2  13
5  10  11   8
9   6   7  12
4  15  14   1
```

If we take another symmetrical combination: a rightward-slanting rectangle whose corners are 2, 8, 9, and 15, these also add to 34:

```16   3   2  13
5  10  11   8
9   6   7  12
4  15  14   1
```

The leftward-slanting rectangle, whose corners are 5, 3, 12, and 14 also add to 34:

```16   3   2  13
5  10  11   8
9   6   7  12
4  15  14   1```

Starting from 2 and proceeding in an “L”-shape to the left to the number 5, and continuing counter-clockwise in the same manner gets us the corners of a tilted square whose numbers 2, 5, 15, and 12, add to 34:

```16   3   2  13
5  10  11   8
9   6   7  12
4  15  14   1```

Starting from “3” and doing likewise yields the numbers 3, 9, 14, and 8, also adding to 34:

```16   3   2  13
5  10  11   8
9   6   7  12
4  15  14   1```

And what about this talk about “symmetry”? By this, we mean that we may take pairs of numbers at the start and end of any row, and they add up to the same number in a symmetrical place elsewhere. 16 + 3 = 4 + 15, taking the top and bottom of the first and second column. Likewise can be done for the last two columns: 2 + 13 = 14 + 1. The middle two rows have the same property: 5 + 10 = 9 + 6; and 11 + 8 = 7 + 12. On a larger scale, the sums of the middle two rows of columns 1 and 2 are the same as the tops and bottoms of columns 3 and 4: 11 + 8 = 7 + 12 = 16 + 3 = 4 + 15. Likewise, the sums of the middle two rows of columns 3 and 4 are the same as the tops and bottoms of columns 1 and 2: 2 + 13 = 14 + 1 = 5 + 10 = 9 + 6. These two groups of symmetrical numbers are illustrated below in red and green:

```16   3   2  13
5  10  11   8
9   6   7  12
4  15  14   1```

The sums of 15 (green) and 18 (red) across each row form this pattern

```16   3   2  13
5  10  11   8
9   6   7  12
4  15  14   1```

The downward symmetry is also interesting. Here, the sum of 25 is in gold and the sum of 9 is in blue. In the process, we can discern the patterns that we used to construct the square in the first place:

```16   3   2  13
5  10  11   8
9   6   7  12
4  15  14   1```

This is an incredible amount of magic, but if you follow the order of filling (horseshoes are right-to-left, u-shapes are left-to-right, along with the peculiar pattern of filling u’s and horseshoes), there really are four possible patterns that have these “hyper-magic” qualities, but you lose the “1514” idea in two of them:

``` 8  11  10   5      12   7   6   9       4  15  14   1
13   2   3  16       1  14  15   4      12   6   7   9
1  14  15   4      13   2   3  16       5  11  10   8
12   7   6   9       8  11  10   5      16   3   2  13
```

Of course, you could reverse all of the numbers in the rows of the first two squares to get your “1514” back.

Every time I look at that darned Durer square, I keep seeing more patterns. I think there comes a point where one has to leave the remaining observations up to the reader.

There is yet another 4×4 square, and with it we can increase the magic, if that can even be conceivable after all I have said. But there is a square with even more magic than the Durer square. R. J. Reichmann mentioned it in his book “The Fascination of Numbers”, first published in 1957. The square could be constructed like this:

```-  -  3  -        -  -  3  6        - 10  3  6        15 10  3  6
4  -  -  - ====>  4  5  -  - ====>  4  5  -  9  ====>  4  5 16  9
-  -  2  -        -  -  2  7        - 11  2  7        14 11  2  7
1  -  -  -        1  8  -  -        1  8  - 12         1  8 13 12
```

This square has all the magic of the Durer square and then some. One thing this new square has over the Durer square is that any four numbers in square formation will add to 34, from anywhere in the square. These include the foursomes:

```10  3     16   9     11   2       4   5
5  16      2   7      8  13      14  11
```

## Recreational Math I: Magic Squares: the “really good” kind – Part 2

Last time I introduced the idea of magic squares. I promised I would show you how to make one. In this post, I will begin by discussing “trivial” squares, or squares made by simple rules of following diagonals and wrapping.

When I say a square is “magic”, I mean that all rows, columns, and diagonals add up to the same number. While other sources, such as Wolfram’s Mathematica, say that only the main diagonal of the matrix need be magic, I will take the more strict requirement that both leftward and rightward diagonals have to be magic.

There are trivial magic squares that begins by following a rule where you start with “1” in the top middle square, then move up and to the right one square, and place a “2” there.

```_  1  _
_  _  _
_  _  _
```

But you may have noticed that if you start at the top, how can you move “up and to the right”? You get around this by “wrapping” to the bottom, treating the bottom of the rightward column as though it is above.

```_  1  _
_  _  _
_  _  2```

OK, you say, but now there’s no “right” after the last column. Now what? Now you can wrap so that the leftmost column is treated as “right of” the rightmost column:

```_  1  _
3  _  _
_  _  2```

Now another problem: up and to the right of “3”, there is a “1” in the way. If this happens, you are allowed to place the fourth number below the “3”:

```_  1  _
3  _  _
4  _  2```

Now, following these rules and exceptions, we can keep going:

```8  1  6
3  5  7
4  9  2```

The result is a magic square whose rows, columns and diagonals add up to 15.

I found that if I moved the 1 elsewhere and followed these rules in the same manner, some or all of the “magic” is lost. There seems to be only one magic square that can be made using these rules, at least one that adds up to 15 in all of its rows, columns and diagonals. The following 3×3 magic squares were the closest I could come to any credible “magic” by placing the “1” in a different position:

```6  8  1                4  9  2
7  3  5 and similarly: 8  1  6
2  4  9                3  5  7
```

But notice in both cases, neither of the diagonals add up to 15. In the next post, I will discuss a way to break this limitation, making it possible to construct up to 36 3×3 magic squares.

Meanwhile, let’s expand the idea to 5×5, using the same, identical rules. This one seems easier in a way, since there aren’t as many blockages early on:

```17  24   1   8  15
23   5   7  14  16
4   6  13  20  22
10  12  19  21   3
11  18  25   2   9```

I particularly like 5×5 squares. But my experience with placing the “1” elsewhere than the exact middle position of the top row has resulted in a loss of “magic”. However, I was lucky on my first attempt with moving the “1” around. The following magic square has a “Mathematica” level of magic:

```11  18  25   2   9
17  24   1   8  15
23   5   7  14  16
4   6  13  20  22
10  12  19  21   3
```

Later in this series, we can break this limitation, too. But next, we shall discuss some 4×4 magic squares, including one that made history.

## Recreational Math I: Magic Squares: the “really good” kind

Introduction

ONE OF THE few things you see on the web these days is how to do a really good magic square. There are many websites that tell you about how spiralling arrangements of sequential numbers on a square matrix is magic, but for me, that’s dull. You are limited to doing seemingly less than a dozen such magic squares, so I don’t find them too interesting.

Recall that magic squares are numbers arranged in a square matrix such that each of its rows and columns, and normally both diagonals add up to the same number. Usually, a square of n numbers to a side which has numbers total, will be populated with the entire set of numbers from 1 to n inclusive, in some quasi-random order. These numbers would be arranged in such a manner that the total of each of its rows, columns, and both diagonals equal the same “magic number”, which is different depending on the dimensions of the square. By using random methods suggested in this article, the number of magic squares possible, when n is odd, is equal to (n!)2.

For the 5×5 square, you apparently have to start by moving from the current position to the “top right” square (wrapping to the opposite edge if necessary), and if that square is occupied, move down by 1 square. This non-random, deterministic method apparently works for all squares greater than 5×5 (with odd dimensions).

I read from an old book on recreational math (The Fascination of Numbers, by W. J. Reichmann (1958)), that

1. Squares of even dimensions (4×4, 6×6) have to be arranged by a different algorithm than squares of odd prime dimension (5×5, 7×7, 11×11, …).
2. A randomly-generated 5×5 magic square can be made which uses the sum of two matrices.

The number of possible permutations of 5×5 matrices is equal to (5!)2.

Reichmann’s book was the only place where I could find such an algorithm. This seems to be a rare algorithm, even on an internet search. But it is the only method that leads to “magic” results in a variety of ways. These squares seem to be the most robust in terms of the number of ways their “magic” qualities can be determined. They have inspired my writing computer programs that generate such squares as a way of practicing programming several years ago. I have written magic square programs following Reichmann’s algorithm (not sure if he originated it) in VB5, Visual Basic .NET, VB for applications (in Excel), and in Microsoft Quick Basic 4.5. The 16-bit QB 4.5 version does not run on my 64-bit machine, and for similar reasons, neither does the VB5 version, whose runtime DLL is no longer supported by MS Windows 7.

In the next instalments, starting this coming Saturday, I will begin to discuss the making of 3×3 and 5×5 squares, and discuss their magic properties.

## Getting f(x) notation to work in Maple

Maple is a robust math environment which can graph, solve equations, and solve for the unknown with the aid of its computer algebra solver (CAS), which is capable of computing exact roots of cubic functions, for example.

I wanted to demonstrate for myself that Maple could do various function transformations, such as: `f(x), f(x + 1), f(x) + 1, 2*f(x)`, and the like. I discovered after much reading and browsing the web that I could coax f(x) to do whatever is needed using an inline call:

```f := proc (x :: float) option inline; x4 + 5x3 + 5x2 - 5*x - 6 end proc: ```

The function takes a floating point number `x` as a parameter. This means that `f(-10.0)` would yield

`5544.0000`

as output. I noticed that Maple practices fairly strong typing, so if you declare floating point using `float`, you can only pass floats to the function. That is, `f(-10)` would have gotten an error, at least in my copy of Maple 12. Once you execute this proc declaration, you can do a plot function like:

`plot ({f(x), f(x + 1), f(x + 2)}, x = -5..5, numpoints=1000);`

and superimpose three curves on the same set of axes to make a comparison. You can even do:

`plot ({f(x), 0.5 * f(2*(x + 1)) - 5}, x = -10..10``, numpoints=1000``);`

to illustrate combinations of transformations of a function. Even a transformation of a sine wave can look like this:

``` h := proc (x::float) option inline; sin(x) end proc; plot(1.5h(2(x+Pi/4)), x = -2Pi .. 2Pi, numpoints = 5000, tickmarks = [spacing((1/4)*Pi), default]);```

and you are rewarded with:

There is an even better function called animate which is great for transformations of functions. I will discuss that in a later post.

## The TI-NSpire Programming Language

A couple of changes to the TI-NSpire programming language, including the addition of a host of commands and libraries, and the `Request "x",y`  command, have made the programming experience more pleasant on the Nspire. Finally, something that comes a giant step closer to behaving like a normal programming language. The language appears to be undocumented as of 2010.

The assignment command using “`STO>`” doesn’t work the way it used to, but I wasn’t aware that the Nspire had a Pascal-style “`:=`” for variable assignment.

The spreadsheet could be populated once, but re-running the program to populate the spreadsheet with different data lead to the Nspire becoming confused, and garbage data winding up on the spreadsheet. Deleting the spreadsheet, and re-inserting the array names once more on the tops of the columns resulted in the new array values updating themselves automatically on the spreadsheet.

There needs to be a way to declare and name a spreadsheet programmatically, and I don’t see a way yet. There also needs to be a way of disposing of the spreadsheet or clearing a spreadsheet, inside of the program. Again, I don’t know of a way to do that yet.

Once I get the code perfected a little more, I’ll post it.

## Version 2 of the TI Nspire operating system

My main complaint about the Nspire and Nspire CAS, the need to have some kind of input statement in its programmnig language, looks like it is closer to reality. I just have to fiddle with it some more to see if it can really place data in tables (or now, spreadsheets), and see if I can really do I/O in a running program as was the case for the TI-84 family. To be clear, I am not using the new “touchpad” version of the CAS, I am using the slightly older version, which had the original keyboard.

When I did a test statement

`Request "---> ", j`
and ran it, the calculator came back with a screen using “–>” as a prompt, and a blank for me to input something. I entered “36”, then the input window disappeared, then the string

` --> 36`
was output. The input window seems cumbersome.  That could be because I like command line input, and think it has less memory overhead on a device where every byte of RAM is precious.

At any rate, the value is stored in `j`, and this was proven by doing the multiplication

`4j`
and I got `144`. This was on a calculator whose memory was cleared due to the OS upgrade. The cursor is much more sensitive, and there is a noticeable speed impovement over prior OS versions.

I tried to make a simple program, and got nowhere with the Request statement, when I placed it inside a FOR/END FOR loop in a named program.

## My Geo-Trig Poem

“Geo-Trig Poem”

You take tan b and ×
sin(cos(q+y))
and just to make it more complex
÷ cot(Δx)
And so then by csc(Θ)
× angles π, ρ, η
and show that they continue on
by proof with δ – ε.

Once tidied-up you then inspect
and find the answer incorrect
So then you do the question over
Once it’s right you then discover
You were to do the even ones
and not the odds, which you had done.

You give it up and say you’re leaving
Geo-Trig for basket weaving.

— something I wrote back in Grade 12.