The Carnival rounds up maths blog posts from all over the internet, including some from our own Aperiodical. See our Carnival of Mathematics page for more information.

]]>Puzzlebomb is a monthly puzzle compendium. Issue 55 of Puzzlebomb, for July 2016, can be found here:

Puzzlebomb – Issue 55 – July 2016 (printer-friendly version)

There’s also an online electronic version of the puzzle in this issue.

The solutions to Issue 55 will be posted at the same time as Issue 56.

Previous issues of Puzzlebomb, and their solutions, can be found at Puzzlebomb.co.uk.

]]>Year 1, Semester 1: I had three two-hour exams. One was 9am on Monday, the second was 9am on Tuesday and the third was 4.30pm on the same Tuesday.

Year 1, Semester 2: I don’t have this exam timetable, for some reason. (The real question is why I still have five out of six, not why I’m missing one!)

Year 2, Semester 1: six two-hour exams over two weeks. Week 1 started fairly well, with exams on Monday 9am, Wednesday 4.30pm and Friday 4.30pm, then the fourth was Saturday 9am, so I finished at 6.30pm on Friday and took another at 9am the following morning. The remaining two were on the following Tuesday, at 9am and 4.30pm.

Year 2, Semester 2: another six two-hour exams over two weeks. The first week was Tuesday at 4.30pm, Wednesday at 9am, Wednesday at 4.30pm and Thursday at 4.30pm. Notice I am given a whole 22 hours off between the 3rd and 4th, a comparative luxury! Then the last two were Tuesday and Wednesday the following week, both at 9am.

Year 3, Semester 1: much more relaxed this time, five exams mostly 2.5 hours on Monday at 1.30pm, Wednesday at 9am and Thursday at 9am one week and Monday 9am and Wednesday 9am the following week.

Year 3, Semester 2: three 2.5 hour exams, two on Friday, 9am and 4.30pm and the other on the following Monday at 9am.

So it seems I was expected to either do minimal revision before each exam or to do revision in advance of the exam period and simply retain a good level of knowledge and practice for, say, six hours of exams on three different subjects in a 34-hour period (Y1, S1) or eight hours of exams on four different subjects in a 50-hour period (Y2, S2).

This doesn’t change my sympathy with students who feel their exams could be more spread out. This is important so that they have plenty of time for revision and can fairly represent themselves, refreshed and at their best. It strikes me that with the sort of exam schedules I had, and with the weightings given to exams, if a student woke with a cold that lasted a few days, that could seriously damage half a semester’s work.

I’m trying to tweak what I’ve written above so it doesn’t sound whiny – that isn’t my intention, I’m aware that others have it worse. I’m reminded of the bit from my George Green talk (listen here), where when Green sat the Cambridge Tripos in 1837, this was a five-day examination, 9-11.30 and 1-4pm on Wednesday-Saturday and Monday, that determined the order of merit for the Bachelor’s degree!

Another memory confirmed by these papers is that the Monday 9am exam at the end of year 3 served as both the end point of my degree and also my 21st birthday. One thing I am genuinely surprised by is that I didn’t take a 3 hour exam on any of these timetables – I’ve definitely claimed in recent years during a conversation on exam lengths to have regularly taken three hour exams. Funny thing, memory.

]]>`1`

) and no glitter (`0`

) to encode binary messages in your nail varnish. We also posted an accompanying puzzle, stated as:
**Suppose I want to paint my nails on one hand differently every day for a month – so I need to use all 31 combinations involving glitter. Assuming that a nail painted with plain varnish can have glitter added, but a nail with glitter needs to be nail-varnish-removed before it can become a plain nail again, what order do I apply the different combinations so that you minimise the amount of nail varnish remover I’ll need to use?**

Here’s our take on the solution.

First of all, there’s a slightly subtle point to note – there’s a similar question you can ask, to which there is an easy and well-known answer. If instead we were asking how to minimise **the number of times I need to change a nail**, either from glitter to no glitter or back again, that’s the same as asking how to minimise the number of flips from 0 to 1 or from 1 to 0. The answer to this is to use a *Gray code*.

A Gray code – sometimes known as reflected binary code, and named after its creator Frank Gray – is an ordering of numbers such that each successive pair of numbers differ in only one bit (binary digit). Patented in 1947, it was originally designed to minimise errors in mechanical switching systems – if more than one switch has to flip to change between two numbers, they might not flip at exactly the same time, so the output might temporarily read or print out a number unintentionally. In the conventional order, binary numbers sometimes involve flipping multiple bits – such as going from 3 (`011`

) to 4 (`100`

), in which all three bits flip; the Gray code is an alternative ordering that can be worked out for any set of numbers $0 \ldots 2^n-1$ to ensure each switch is only one digit – for example, the numbers 0 to 7 can be written in the following order with only single bit-flips:

0 | `000` |

1 | `001` |

3 | `011` |

2 | `010` |

6 | `110` |

7 | `111` |

5 | `101` |

4 | `101` |

In fact, the binary combinations above are referred to as the *Gray code* for the numbers 0 to 7, in that order, so Gray code for 2 is 011 (even though that’s 3 in binary).

A Gray code for an $n$-bit sequence can be constructed from the $(n-1)$-bit Gray code, in quite a pleasing way. To go from 2-bit to 3-bit, take the sequence for 2-bit:

`00`

, `01`

, `11`

, `10`

Add a reflected version of this same string to the end:

`00`

, `01`

, `11`

, `10`

, `10`

, `11`

, `01`

, `00`

Then prefix the first half with `0`

s and the second half with `1`

s:

`000, `

`001`

, `011`

, `010`

, `110`

, `111`

, `101`

, `100`

This process can be repeated to generate the 4-bit sequence, and so on.

Since its creation, the Gray Code has been used in error correction and digital logic, and it can also be used to solve the Towers of Hanoi puzzle. As far as I know, the present work is the first application to personal grooming.

So, if I were to use the Gray Code ordering for my nails, I’d get the following sequence:

Order | Gray Code | Decimal equivalent | Order | Gray Code | Decimal equivalent | Order | Gray Code | Decimal equivalent |
---|---|---|---|---|---|---|---|---|

0 | `00000` |
0 | 11 | `01110` |
14 | 22 | `11101` |
29 |

1 | `00001` |
1 | 12 | `01010` |
10 | 23 | `11100` |
28 |

2 | `00011` |
3 | 13 | `01011` |
11 | 24 | `10100` |
20 |

3 | `00010` |
2 | 14 | `01001` |
9 | 25 | `10101` |
21 |

4 | `00110` |
6 | 15 | `01000` |
8 | 26 | `10111` |
23 |

5 | `00111` |
7 | 16 | `11000` |
24 | 27 | `10110` |
22 |

6 | `00101` |
5 | 17 | `11001` |
25 | 28 | `10010` |
18 |

7 | `00100` |
4 | 18 | `11011` |
27 | 29 | `10011` |
19 |

8 | `01100` |
12 | 19 | `11010` |
26 | 30 | `10001` |
17 |

9 | `01101` |
13 | 20 | `11110` |
30 | 31 | `10000` |
16 |

10 | `01111` |
15 | 21 | `11111` |
31 |

Each time I change from one nail to the next, I’m changing exactly one nail – either adding glitter, or removing it, and this is undeniably the most efficient way. But the question we asked in our puzzle was slightly different – since it’s much more effort to remove nail glitter than to add it, can we minimise the number of glitter removals, i.e. changes from 1 to 0?

If you’d like to try and work it out for yourself, go and do that now.

The first question you might ask is, is Gray Code the answer here too? In the list given above, there are 15 instances of switching from a 1 to a 0. But it can be done in fewer!

Our first breakthrough here was to find a solution more efficient than the Gray Code ordering, and we did find an ordering which takes 14 removes (for the record, it was 0, 2, 3, 1, 5, 4, 6, 7, 11, 10, 8, 9, 13, 12, 14, 15, 23, 22, 20, 21, 17, 19, 18, 16, 24, 26, 27, 25, 29, 28, 30, 31). But can we do any better?

It’s actually possible to prove that the lower bound on this — the fewest removals any valid solution can have — is 13. Let’s assume that each move consists of removing or adding exactly one nail’s glitter, and note that there are 31 ‘steps’ to achieve all 32 positions. If you start with no nails glittered and finish with all five glittered, the difference between the number of moves adding and removing glitter must be at most five, and therefore the minimal solution in terms of removals must have 18 adds and 13 removes making up the 31 steps.

All we need now is to actually find a way of doing it with only 13 removals. Ooh, here’s one:

Order | Binary | Decimal Equivalent | Order | Binary | Decimal Equivalent | Order | Binary | Decimal Equivalent |
---|---|---|---|---|---|---|---|---|

0 | `00000` |
0 | 11 | `01000` |
8 | 22 | `10010` |
20 |

1 | `00001` |
1 | 12 | `01010` |
10 | 23 | `10011` |
22 |

2 | `00011` |
3 | 13 | `01011` |
11 | 24 | `10111` |
23 |

3 | `00010` |
2 | 14 | `01111` |
15 | 25 | `10101` |
21 |

4 | `00110` |
6 | 15 | `01110` |
14 | 26 | `10001` |
17 |

5 | `00111` |
7 | 16 | `11110` |
30 | 27 | `10011` |
19 |

6 | `00101` |
5 | 17 | `11100` |
28 | 28 | `11011` |
27 |

7 | `00100` |
4 | 18 | `11000` |
24 | 29 | `11001` |
25 |

8 | `01100` |
12 | 19 | `11010` |
26 | 30 | `11101` |
29 |

9 | `01101` |
13 | 20 | `10010` |
18 | 31 | `11111` |
31 |

10 | `01001` |
9 | 21 | `10000` |
16 |

One obvious way to find the most efficient solution is to crunch it all through a computer: generate all the possible orderings, and count how many removals you need in each case. Of course, this would take a huge amount of computer time – the number of possible orderings is 32!, which is 263130836933693530167218012160000000, and as you can see below in the results of a simulation of 126,000 randomly-chosen orderings in R, only a tiny proportion achieve fewer than thirty removals, let alone thirteen.

So instead of relying on luck, we used a bit of *maths thinking*. The standard Gray Code that will solve you the Tower of Hanoi looks like this

\[1213121412131215121312141213121\]

where each digit represents the nail you change at each step (or which disk you move to a new peg). The problem with the standard solution for our purposes is that, starting with five unglittered nails, it doesn’t end with all fingers glittered — it ends with only digit 5 glittered. Fortunately, it’s easy to modify the sequence to change this.

Consider the simpler case of a three-fingered mathematician. They can imagine their nail-painting journey as a trip round the edges of a cube visiting every corner, with forwards and backwards movemement in each of the three dimensions correpsonding to glittering and unglittering each of the three nails. The picture below shows how the standard Gray Code solution can be modified to create a minimal-removals, no-glitter to all-glitter, solution, which on the cube corresponds to a path starting and ending at opposite corners.

Switching 1s for 2s and vice versa in the second 121 subection has done the trick here, but for the five-nails case it’s a bit more complex. It’s hard to visualise a trip round a five-dimensional hypercube, so let’s return to the digit sequence. Starting and ending at opposite corners happens if and only if each digit appears in the sequence an odd number of times (an even number of changes puts you back where you started). In the longer five-digit sequence we can still switch 1s and 2s in a 121 subsequence, but we can also switch around the 1s, 2s and 3s in a larger 1213121 subsequence, or even the 1s, 2s, 3s and 4s in one of the two big 121312141213121 chunks. A brief bit of faffing around before too long delivered this sequence:

\[1213121413121315232423212324232\]

where we’ve switched 2s with 3s in the second 1213121 chunk, and changed the 1s to 2s, 2s to 3s, 3s to 4s and the 4 to a 1 in the second 121312141213121 chunk. This sequence of digit-changes contains each digit an odd number of times, and gives the full sequence of nails tabulated above.

Having found this one solution, any equivalent solution made by permuting the five columns of binary digits will also only involve 13 removals; plus there are other tweaks you can make to the ordering using the method above. So, this solution generates hundreds of potential other 13-remove solutions. We’ve not ascertained whether all solutions that take exactly 13 can be found in this way from this one, or whether there are multiple classes out there, but this is pretty satisfying.

As always, CL-P has done his usual trick and built an interactive version of this problem, so you can play around with it for yourself and see if you can find a different solution with 13 removals:

The base of the development is a tool to “semantically enrich” mathematical expressions, inferring information about the meanings of individual elements. This is not an easy job, and has required the development of thousands of pattern-matching rules to identify different notational conventions.

This semantic enrichment is passed directly onto a tool which works with a screen reader to read mathematical expressions aloud; the exploration tool lets you work through an expression piece-by-piece, using the keyboard to navigate.

The auto-collapse extension also makes MathJax behave better in responsive designs where the available width for rendered expressions can change, by intelligently picking break points and collapsing sub-expressions so they fit on smaller screens.

We’ve enabled the accessibility extensions on our site – right-click on the expression below and play with the “collapsible expressions” and “explorer” menus.

\[ c_p\rho \int_{x-\Delta x}^{x+\Delta x} [u(\xi,t+\Delta t)-u(\xi,t-\Delta t)]\, d\xi = c_p\rho\int_{t-\Delta t}^{t+\Delta t}\int_{x-\Delta x}^{x+\Delta x} \frac{\partial u}{\partial\tau}\,d\xi \, d\tau \]

In the future, the accessibility extensions will be included in the standard MathJax configuration, but for now you need to manually load them.

To load the accessibility extensions on your own site, you just need to add a line to your MathJax config script. Here’s a basic configuration:

<script type="text/x-mathjax-config"> MathJax.Ajax.config.path["Contrib"] = "https://cdn.mathjax.org/mathjax/contrib"; MathJax.Hub.Config({ extensions: ["[Contrib]/a11y/accessibility-menu.js"], tex2jax: { inlineMath: [ ['$','$'], ["\\(","\\)"] ], processEscapes: true } }); </script> <script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS_HTML"></script>

When you’re reading a site that has loaded MathJax without the accessibility extensions, you can use this bookmarklet (drag the link to your bookmarks) to add in the extensions.

**More information**, including detailed instructions on how to use the extensions and demos of the new features, is at the MathJax blog.

Puzzlebomb is a monthly puzzle compendium. Issue 54 of Puzzlebomb, for June 2016, can be found here:

Puzzlebomb – Issue 54 – June 2016

The solutions to Issue 54 can be found here:

Puzzlebomb – Issue 54 – June 2016 – Solutions (printer-friendly version)

Previous issues of Puzzlebomb, and their solutions, can be found at Puzzlebomb.co.uk.

]]>The Carnival rounds up maths blog posts from all over the internet, including some from our own Aperiodical. See our Carnival of Mathematics page for more information.

]]>- Prof. Alice Rogers, Emeritus Professor of Mathematics, King’s College, London, appointed OBE for services to Mathematics Education and Higher Education.
- John Sidwell, volunteer, HMP Hewell appointed MBE for services to Prisoners through One to One Maths.
- Danielle George, vice-dean for teaching and learning, Faculty of Engineering and Physical Sciences, University of Manchester, appointed MBE for services to engineering through public engagement.
- Anthony Finkelstein, professor of software systems engineering, University College London and the Alan Turing Institute, for services to computer science and engineering.
- Economist Angus Deaton, professor, Princeton University, Nobel laureate, for services to research in economics and international affairs.
- Prof. Alan Thorpe, lately Director-General of the European Centre for Medium Range Weather Forecasts, appointed OBE for services to environmental science and research (thanks to Philip Browne on Twitter).
- Prof. Nalini Joshi was made an Officer of the Order of Australia (AO); the citation is more involved than the UK ones and reads “for distinguished service to mathematical science and tertiary education as an academic, author and researcher, to professional societies, and as a role model and mentor of young mathematicians” (added in an update 16/06/16).

It’s also worth mentioning the new batch of Regius professorships, 12 posts created at universities around the UK to celebrate the Queen’s 90th birthday: Oxford University has been given a professorship in maths, but no appointment has been made yet.

Are there any others we’ve missed? Please add any of interest in the comments below. A full list may be obtained from the Cabinet Office website.

]]>“Principia Mathematica”, published in three volumes in 1910, 1912 and 1913, was a major work by mathematician and philosopher Bertrand Russell, with help from Alfred North Whitehead. The book contains a proof, starting from very basic axioms, that 1+1=2 – which takes over **360 pages**! It might seem excessive, but they work from only the most basic assumptions, and have to define firstly what they mean by ‘1’, ‘2’, ‘plus’, and ‘equals’. It’s all done in formal logic, and must surely be one of the longest proofs relative to the length and complexity of the statement it’s proving.

**PROOF SIZE: 0.1148 tennis courts**

- Principia Mathematica, on Wikipedia
- Russell and Whitehead, on The Story of Mathematics
- Restatement of the proof in more modern notation, at MetaMath Proof Explorer
- The proof starts on page 362 of Principia Mathematica Vol. 1

Famously one of the first proofs that required so many fiddly cases to check that its authors resorted to a computer, the Four Colour Theorem simply states that any diagram (or equivalently, any graph) drawn on a flat piece of paper can be coloured using at most four colours, so that any two adjacent parts are different colours. The original problem was stated in 1852, and while purported proofs were published in the 1880s, they were later found to be incorrect.

The first real proof, given by Appel and Haken in 1977, roughly consisted of finding a set of 1,936 minimal reducible structures that any diagram/graph that might not be four-colourable could be made up from, then checking each one by computer. Checking the maps one by one took over **1000 computer hours**, and accompanied a hand-checked component of the proof on **400 pages of microfiche**.

A shorter proof, involving a mere 633 reducible structures, was produced in 1996, and that proof was formalised in 2005 using the COQ computer proof assistant, which means it’s less reliant on cases checked by computer.

**PROOF SIZE: 1.8 times the area of an olympic swimming pool plus 370.4 watches of the film Avatar**

- Four Colour Theorem, on Wikipedia
- The Four Colour Theorem, at NRICH
- Formal Proof – The Four-Color Theorem, an article explaining the shorter COQ proof by Georges Gonthier in the Notices of the AMS (PDF)

‘The Enormous Theorem’ is always given as an alternative name for the classification of finite simple groups, but of course nobody actually ever calls it this in their work.

The classification of the finite simple groups — otherwise known as ‘CFSG’ or simply **The Enormous Theorem** — is a bit different to the other massive proofs listed here. It’s not a single work from one person or team, but rather a joint effort among dozens of mathematicians through the (nineteen-) eighties and nineties, a patchwork of results published in separate articles which together constitute the overall theorem.

A *group* is roughly speaking the set of interlocking symmetries of some concrete or abstract object, and the simple ones are those that are not ‘made by’ mashing two smaller symmetry groups together. The CFSG states that any finite simple group must be either a member of one of a set of precisely-defined infinite families of groups, or one of 26 specific outliers: the sporadic simple groups.

Wikipedia reckons that the aggregated length of the papers contributing to the proof is around **10,000 pages**. Work on a consolidated ‘second-generation’ proof, led by Daniel Gorenstein, is ongoing and is expected to result in an eleven-volume proof a mere 5,000 pages long. In fairness to the competition, it should be pointed out that these page counts are for the full articles/books, including all exposition as well as the bare proofs.

**PROOF SIZE: 1.4 basketball courts**

- Classification of finite simple groups, on Wikipedia
- An enormous theorem: the classification of finite simple groups, by Richard Elwes at Plus Magazine
- Rewriting the enormous theorem, by Rachel Thomas at Plus Magazine
- The Status of the Classification of the Finite Simple Groups, by Michael Aschbacher (PDF)

Kepler Conjecture/FLYSPECK

The Kepler Conjecture, originally posited in the 17th century by Johannes Kepler, relates to the density of spheres packed in 3D space. Kepler conjectured that the ‘cubic close packing’ (the one where you put a hexagonal grid of spheres on a flat surface and then stack another one on top, but offset so the balls are over the gaps) is the most efficient way to pack spheres in 3D space – the one with the least empty space left in between.

While it was long suspected to be true, nobody managed to formally prove it until Thomas Hales in 1998. Hales’ proof involved around **300 pages of notes** and **3 gigabytes of computer programs, data and results**. It was a ‘proof by exhaustion’ which involved checking many individual cases. Referees on the proof said they were ‘99% certain’ the proof was correct, and hence that this was the most efficient 3D packing.

But that wasn’t enough for Thomas Hales – as we covered here when it was completed, the FLYSPECK project (named as it is a Formal Proof of the Kepler conjecture, and ‘flyspeck’ is a word that contains all of those letters in that order, but it’s not as good as the word ‘flapjack’) was a further project undertaken to formalise and check the previous proof. It took from its start in 2003 until September 2014 to complete, and used proof assistants Isabelle and HOL Light.

**PROOF SIZE: 1.43 downloads of the film Titanic in HD, plus about 0.94 Harry Potter and the Prisoner of Azkabans**

- The Flyspeck project is complete: we know how to stack balls!
- Git Repo for FLYSPECK
- The Kepler Conjecture, on Wikipedia

Another recent bit of maths that’s made headlines by having a massive proof was the Erdős Discrepancy problem – back in February 2014, a proof using an SAT solver by Boris Konev and Alexei Lisitsa of the University of Liverpool hit the headlines because it was ‘the size of Wikipedia’ (around 13 gigabytes).

The problem asks whether it’s possible to come up with an infinite sequence of +1s and -1s and a ‘target’ number in such a way that you can never get past the target by adding together regularly-spaced terms from the sequence. (Going lower than minus-the-target-number also counts, in case you thought you had trumped the proof with your clever sequence of just -1s.) James Grime has explained the problem in a video with snakes and a cliff. The proof showed that in fact you can’t always make the required sequence.

Luckily, Terence Tao came to the rescue in September 2015, with a smaller hand-crafted proof developed in collaboration with the Polymath project.

**PROOF SIZE: around 3,250 holiday snaps taken on a 10 megapixel camera**

- A SAT Attack on the Erdős Discrepancy Conjecture by Boris Konev and Alexei Lisitsa
- Erdős’s discrepancy problem now less of a problem
- New Wikipedia sized proof explained with a puzzle – James Grime on YouTube
- Terence Tao has solved the Erdős discrepancy problem!

Claiming to be the ‘largest proof ever’, the Boolean Pythagorean Triples theorem relates to the question of whether it’s possible to split all numbers into two groups, neither of which contains a complete Pythagorean triple. For example, 3, 4 and 5 form a triple, and to find a valid split they would have to not all be in the same half – but then 5 couldn’t also be in the same half as 12 and 13, and so on.

It’s much better explained by Evelyn Lamb in her post in Nature, but a team of researchers have shown that not only is it not possible to do this, it’s not even possible to split the numbers 1 to 8000 in this way without getting stuck. It might not sound like ground-breaking mathematical knowledge we need right now, but it ties in to Ramsey Theory and other combinatorial questions. Proving it took 2 days for a computer running 800 parallel processors, and generated **200 terabytes of data**.

**PROOF SIZE: Amount of data generated by CERN every 2.92 days**

- Solving and Verifying the boolean Pythagorean Triples problem via Cube-and-Conquer by Marijn J. H. Heule, Oliver Kullmann and Victor W. Marek
- Two-hundred Terabyte maths proof is largest ever, by Evelyn Lamb at Nature
- Boolean Pythagorean Triples theorem on Wikipedia

More information at Wired.

*via math-fun.*