. @christianp has turned into a one-man plug for the holes in Wolfram Alpha. I’m genuinely impressed.

— Colin Beveridge (@icecolbeveridge) February 28, 2015

For a while, I’ve been following this cool Twitter account that tweets questions Wolfram|Alpha can’t answer. The genius of it is that the questions all look like things that you could half-imagine the solution algorithm for at a glance, and many of them look like the kinds of questions Wolfram like to give as examples when they’re showing off how clever their system is.

Questions like this:

number of words between "landslide" and "Beelzebub" in Bohemian Rhapsody

— Wolfram|Alpha Can't (@wacnt) January 22, 2015

The answer to that is 278. How do I know that? I know that because I went on a little problem-solving binge answering the questions that Wolfram|Alpha can’t.

Ever since I discovered the @wacnt account, a little voice had been telling me that I should work out the answers to some of the questions. While there are a few that require a good chocolate doughnut or two’s worth of brain power, the majority boil down to simple “look up some facts and put them together” tasks of the sort that Wolfram|Alpha is supposed to be good at.

So, while my fiancée and I were watching some improving broadcasts, I worked my way through @wacnt’s tweets, picking out questions to answer.

Here’s what I came up with. For comparison, I’ve found a query that Wolfram|Alpha *can* answer from their examples page, to go with each question it couldn’t.

smallest positive integer radius of a sphere whose volume is within 0.0001 of an integer

— Wolfram|Alpha Can't (@wacnt) February 28, 2015

This one’s straightforwardly mathematical: compute $\frac{4}{3} \pi r^3$ until you get close enough to an integer. Here’s the code I put in IPython:

from itertools import count from mpmath import pi,floor,ceil,mp mp.dps = 50 for r in count(1): v = pi*mp.mpf(r)**3 * 4/3 d = min(v-floor(v), ceil(v)-v) if d<0.00001: print(r) break

It turned out I had to use the arbitrary-precision mpmath library once $r$ was big enough. Anyway, it turns out the answer is $12352$, because $\frac{4}{3} \pi \times 12352^3 = 7894060641354.0000039427674483175607644657112582764….$.

**But Wolfram|Alpha can answer: **maximize e^x sin y on x^2+y^2=1

last time the world population was a repunit

— Wolfram|Alpha Can't (@wacnt) February 27, 2015

This is going to involve modelling the world’s population. I thought it’d be something like an exponential function, but it turns out the rate the world’s population is increasing has been… decreasing. Or at least fairly steady. Wikipedia has a page on word population milestones, which includes this table:

Population (in billions) | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | |||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|

Year | 1804 | 1927 | 1959 | 1974 | 1987 | 1999 | 2012 | 2026 | 2042 | |||||||||

Years elapsed | –– | 123 | 32 | 15 | 13 | 12 | 13 | 14 | 16 |

The world’s population is currently more than 7 billion but less than 7,777,777,777, so the last time the world’s population was a repunit was when it was 6,666,666,666. I could probably have looked up more accurate statistics than the table above, but I couldn’t be bothered. So, all things considered, I decided a cubic spline wouldn’t be a terrible model for population. I set up a cubic interpolation in scipy and used it to find the date corresponding to 6,666,666,666.

```
from scipy import interpolate
# data from http://en.wikipedia.org/wiki/World_population_milestones
years = [1804,1927,1959,1974,1987,1999,2011,2026,2042]
pops = [x*10**9 for x in [1,2,3,4,5,6,7,8,9]]
# cubic interpolation between milestones
tck = interpolate.splrep(pops,years,s=0)
# time when population was 6666666666, according to the interpolation
t=interpolate.splev([6666666666],tck)[0]
y = floor(t)
days = 365*(t-y)
print(t,y,days)
> (2006.7698638728784, 2006, 281.00031360062758)
```

So, 281 days into 2006.

```
months = [31,28,31,30,31,30,31,31,30,31,30,31]
[sum(months[:i]) for i in range(len(months))]
[0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]
```

… which is a little bit into October. I suppose I could’ve just divided by 30 to get that level of precision. Meh.

**But Wolfram|Alpha can answer: **France pop 2000 – France pop 1980

number of white pixels in an image of a Norwegian flag 1000 pixels tall

— Wolfram|Alpha Can't (@wacnt) February 18, 2015

Easy! Get a picture of the flag of Norway; scale it to 1000 pixels; count the white ones. Once again, Wikipedia has all I need.

```
from PIL import Image
f=Image.open(r"2000px-flag_of_Norway.svg.png")
white = 0
scale = f.size[1]/1000.0
for r,g,b,a in f.getdata():
if (r,g,b)==(255,255,255):
white += 1
white/(scale*scale)
> 247337.65543628437
```

I’ll call that 247338. I reckon Wolfram would’ve done about as well as that. I suppose I could’ve looked up the rules for the construction of the Norwegian flag and work it out precisely, but again I went with “quick but roughly right”, which Wolfram often does.

**But Wolfram|Alpha can answer: **nearest paper sizes for a 5″x7″ photo

longest English word formed only with letters m through z

— Wolfram|Alpha Can't (@wacnt) February 17, 2015

I have a few word lists saved on my PC because I like to do stupid things with words, so this was easy.

import re words = open('words.txt').read().split('\n')[:-1] # regex recognising words which only use the letters m to z r = re.compile('^[m-z]*$') # filter words matching the pattern mwords = [w for w in words if r.match(w)] # sort in descending order of length mwords.sort(key=len,reverse=True) # print the longest word print(mwords[0]) > 'nonsynonymous' # actually, is there more than one word that long? print([w for w in mwords if len(w)==len(mwords[0])]) > ['nonsynonymous'] # that's a rubbish word. What are the top 10? print(mwords[:10]) > ['nonsynonymous', 'unmonotonous', 'unsynonymous', 'monosporous', 'monostomous', 'myxosporous', 'myzostomous', 'nonsupports', 'nontortuous', 'nontumorous']

It looks like the longest word is ‘nonsynonymous’, at 15 letters, but I didn’t like the fact it uses a prefix, so I reckoned ‘monosporous’, at 11 letters, was the first “proper” word.

**But Wolfram|Alpha can answer: **words with qsp

ratio of dots to dashes in Gulliver's Travels in International Morse Code

— Wolfram|Alpha Can't (@wacnt) February 15, 2015

I liked this one! First of all I had to get a copy of Gulliver’s Travels, then a list of the Morse Code equivalents of each letter, and mash those two together. Of course Project Gutenberg has a plain text copy of Gulliver’s Travels which worked perfectly after I removed the metadata and legalese, and my good friend Wikipedia has a chart of Morse Code letters and numerals. Once I had those, I could put them in Python:

gulliver = open(r'gulliver.txt',encoding='utf-8').read() letters = 'abcdefghijklmnopqrstuvwxyz1234567890' morse = '.- -... -.-. -.. . ..-. --. .... .. .--- -.- .-.. -- -. --- .--. --.- .-. ... - ..- ...- .-- -..- -.-- --.. .---- ..--- ...-- ....- ..... -.... --... ---.. ----. -----'.split(' ') # count the number of dashes in each letter dashes = {letter:code.count('-') for letter,code in zip(letters,morse)} # count the number of dots in each letter dots = {letter:code.count('.') for letter,code in zip(letters,morse)} # for every letter in Gulliver's travels, add up the dashes ndashes = sum(dashes.get(l,0) for l in gulliver.lower()) # and do the same with dots ndots = sum(dots.get(l,0) for l in gulliver.lower()) # ratio of dots to dashes print(ndots/float(ndashes)) > 1.5240217474538633 # the raw totals print(ndots,ndashes) > 696577 457065

About 50% more dots than dashes! I wonder if that’s anything to do with the fact that the most common letters in the English language, E, T, and H, are encoded as ., -, and ….: a clear win for dots.

**But Wolfram|Alpha can answer: **most frequent two-word phrases in The Raven

total segment toggles as a 7-segment display counts up from 1234 to 6789

— Wolfram|Alpha Can't (@wacnt) February 13, 2015

This is the kind of thing a Project Euler question might ask you to calculate. I quickly came up with an outline of an algorithm:

- encode the patteron of lit segments for each digit
- for each pair of digits, count the number of differing segments
- run through the numbers 1234 to 6789, comparing digits with the same place value and adding up the number of differing segments.

```
"""
Layout:
0
1 2
3
4 5
6
"""
from itertools import product
segments = ['1110111','0010010','1011101','1011011','0111010','1101011','0101111','1010010','1111111','1111010']
toggles = {}
for a,b in product(range(10),repeat=2):
t = 0
for da,db in zip(segments[a],segments[b]):
if da!=db:
t += 1
toggles[(str(a),str(b))] = t
total = 0
for old,new in zip(range(1234,6789),range(1235,6790)):
for dold,dnew in zip(str(old),str(new)):
total += toggles[(dold,dnew)]
print(total)
> 20976
```

I did the layout in my head – I might have made a mistake! Anyway, the total I got says that on average $20976/(6789-1234) \approx 3.77$ segments change at each tick, which doesn’t seem unrealistic.

**But Wolfram|Alpha can answer: **nothing? I couldn’t find anything similar to this – use common knowledge about a system; track some property of it as it evolves – in the examples page.

the pair of neighboring countries whose ratio of birth rates is the greatest

— Wolfram|Alpha Can't (@wacnt) February 10, 2015

I was really pleased with this one – it looked like a really hard problem, involving staring at a world atlas and writing out lists of adjacencies, but Wikipedia’s countless fact-hoarders have made it really easy. There’s a page with a table of countries and their land or maritime neighbours (I wasn’t sure whether to include neighbours separated by a sea but, as you’ll see, it didn’t matter in the end) and a page with birth rate figures for each country.

It turned out a couple of places have national birth rates but aren’t really countries – for example, the West Bank – but apart from that it all worked flawlessly.

```
best = None
top = None
for c1, borders in bordering.items():
if c1 in birth_rates:
for c2 in borders:
# pairs.append((c1,c2))
if c2 in birth_rates:
r = birth_rates[c1]/birth_rates[c2]
if best is None or r>best:
best = r
top = (c1,c2)
print("{} and {}: {} ({} against {})".format(top[0],top[1],best, birth_rates[top[0]],birth_rates[top[1]]))
> Afghanistan and China: 3.7899159663865545 (45.1 against 11.9)
```

Wow, Afghanistan has a high birth rate! I was half-expecting somewhere absolutely tiny like Monaco or Vanuatu would have a surprisingly high birth rate, but the answer I got made sense.

**But Wolfram|Alpha can answer: **unemployment rate of country with largest population

number of different time zones in places where Portuguese is an official language

— Wolfram|Alpha Can't (@wacnt) March 1, 2015

A couple of things to consider with this one: how hard will it be to find the countries with Portuguese as an official language? What is a time zone – do I count places which are currently on the same offset from UTC but have different daylight savings rules as the same time zone, or different?

I found a very helpful page listing the countries which speak a variety of world languages, Portuguese included. It lists 10 “Portuguese Speaking Countries”, of which Macau is one. Macau isn’t a part of China, not really a sovereign nation, which caused me some consternation, but that was helpfully solved when I noticed the list of countries where Portuguese is an official language, just underneath.

After that, I just googled “<place> time zone”, and jotted down the names of the time zones belonging to each country; Google helpfully showed a little card with just the information I needed. Brazil is the only Lusophone country with more than one timezone – 3 in total – and two pairs of countries sit in the same time zone, so it turns out that there are 9 time zones containing countries where Portuguese is an official language.

Country | Time zone(s) |
---|---|

Portugal | Western European (UTC+0) |

Cape Verde | Cape Verde (UTC-1) |

Guinea-Bissau | GMT (UTC+0) |

Timor Leste | Timor Leste (UTC+9) |

Angola | West Africa (UTC+1) |

Equatorial Guinea | West Africa (UTC+1) |

Brazil | Amazon (UTC-4), Brasilia (UTC-3), Fernando de Noronha (UTC-2) |

Mozambique | Central Africa (UTC+2) |

Sao Tome and Principe | GMT (UTC+0) |

**But Wolfram|Alpha can answer: **time in Tokyo

2 cities outside Egypt, the great circle path between which separates Alexandria from Cairo

— Wolfram|Alpha Can't (@wacnt) February 3, 2015

This one’s unsatisfactory. Ideally I’d give a list of all possible pairs of cities that work, but there are probably millions of those, so I just looked for one. Cairo is south-east of Alexandria, so you’d expect one of the 2 cities outside Egypt to be to the south-west. The problem is, there’s a big huge expanse of nothingness that way.

After much scrolling, I finally found Agadez, in Niger. Next I had to find a city to the north-east of Egypt so that the great circle path between the two goes between Alexandria and Cairo. You can’t do this just by drawing lines out of Agadez – the shortest path between two points on the globe isn’t a straight line on a map projection – so I searched for a tool that would draw great circles for me. I found a tool called Great Circle Mapper, which performed admirably. Great circles are vital for planning air routes, so the tool only takes airport names. Fortunately, Agadez has an airport! After a few false starts, I found that the path between Agadez and Tel Aviv separates Alexandria and Cairo:

If I’d been really obtuse, I would’ve found a city south-west of Agadez so that the long route between them separates the two Egyptian cities, but I’m fairly happy with the answer I got.

**But Wolfram|Alpha can answer: **23.5S 46.4W to 56.8N 60.6E

average speed of an aircraft leaving New York at 3pm EST and arriving in Los Angeles at 6pm PST

— Wolfram|Alpha Can't (@wacnt) January 26, 2015

Wolfram|Alpha really should be able to do this one. You just need to find the distance between New York and Los Angeles airports, and divide by the difference in time betwen 6pm PST and 3pm EST.

The Great Circle Mapper tool quickly told me that JFK-LAX is 2475 miles, and since PST is three hours behind EST, the flight took 6 hours. That means the aircraft’s average speed was $2475 \div 6 = 412.5$mph.

**But Wolfram|Alpha can answer: **convert greenwich mean time to eastern time

the sentence in Othello whose word count increases by the most when translated into French

— Wolfram|Alpha Can't (@wacnt) January 27, 2015

I had a really good go at this, but failed. I got English and French versions of Othello from Project Gutenberg, which were luckily in very similar formats, did some Vim magic to make them line up even better, and set Python on it. My plan was to compare each line of dialogue, hoping that the number of sentences would almost always be the same in each translation, and do word counts.

Unfortunately, some very slight differences meant that the lines failed to line up somewhere in Act II, and I decided life was too short to set about trying to fix it. This one’s just about possible if you interpret the query a certain way (and Wolfram|Alpha certainly doesn’t mind doing that), but I don’t blame Wolfram|Alpha for not being able to do it.

**But Wolfram|Alpha can answer: **On the Origin of Species most frequent capitalized words

number of words between "landslide" and "Beelzebub" in Bohemian Rhapsody

— Wolfram|Alpha Can't (@wacnt) January 22, 2015

This is, I think, the quintessence of a Wolfram|Alpha show-off question: completely pointless, a bit amusing, but well-defined and generalisable. Solving it is really simple: find the lyrics to Bohemian Rhapsody, find the word “landslide”, find the word “Beelzebub”, and count the words in between.

I got the lyrics very easily, and then wrote some Python to split it up into words and find my answer:

```
import re
bohemian_rhapsody = re.sub(r'[?!.,]','',bohemian_rhapsody)
words = re.split(r'\s+',bohemian_rhapsody)
print(words.index("Beelzebub")-words.index("landslide"))
> 279
```

I’ve just realised that the question asked for the number of words *between* ‘landslide’ and ‘Beelzebub’, so the answer is actually 278. This bug will be fixed in CP version 2.0.

**But Wolfram|Alpha can answer: **word cloud for Bohemian Rhapsody

missing digit in ISBN 0201896?34

— Wolfram|Alpha Can't (@wacnt) January 23, 2015

This is the last question I answered. Wolfram|Alpha really *really* should be able to do this. An ISBN code is 9 arbitrary digits, followed by a check digit. You find the check digit by multiplying each of the preceding numbers by $10 \dots 2$, respectively, and taking the result modulo $11$. The eighth digit is missing, so it would be multiplied by $3$ in the check digit calculation.

Some very simple Python found the answer:

```
isbn = '0201896?34'
t = 0
for d,i in zip(isbn[:-1],range(10,1,-1)):
if d!='?':
t += int(d)*i
m = t%11
target = int(isbn[-1])
missing_index = isbn.index('?')
missing_mult = 10-missing_index
for a in range(11):
if (missing_mult*a+t)%11==target:
print(a)
> 7
```

**But Wolfram|Alpha can answer: **ISBN 1-5795-5008-8

So, what did I learn in my evening as a human computational knowledge engine? Each of the questions took about 20 minutes to answer, on average. The solution almost always involved finding a little bit of machine-readable information on the internet and plugging it into a very simple algorithm. Apart from the Othello question, I don’t think I answered a single question that Wolfram|Alpha couldn’t be taught to, if someone could be bothered.

That’s the problem with Wolfram|Alpha – most of the types of question it can answer have to be programmed in individually. I’m not at all convinced that it will eventually reach a point of sufficient complexity that it can devise the solutions to these kinds of questions itself. It’s very useful anyway, and I’d definitely miss it if it wasn’t there. I suppose it’s a bit like the UNIX of recreational maths – common tasks have been abstracted and automated, so nobody needs to reinvent the wheel while getting on with whatever new thing they’re trying to do.

For myself, I had a lot of fun answering these questions. Compared with Project Euler, the more popular geek brainstretcher, it was both a lot easier and a lot more interesting. If you want a good challenge of your lateral thinking and programming skills, I heartily recommend taking on Wolfram|Alpha at its own game!

]]>As discussed at the MathsJam conference in 2012, the set of 55 cards feature a collection of 57 symbols: 8 of them are printed on each card, but in such a way that any two cards share exactly one symbol in common. Martin Whitworth’s slides from the 2012 conference (PDF) discuss the fact that this is possible using an interesting mathematical structure, based on a finite projective plane – but that Dobble could in fact have as many as 57 cards and still retain this property. He even gives the layout of the two missing cards.

Despite this clearly non-trivial imperfection, the game is still huge fun to play, and includes several variants in which you’re trying to build your own stack of cards, get rid of your cards, give your cards to others, make pairs and so on.

The phone-based version, available on Android for £2.13 and iOS for £1.99, has many other variants including different symbols, different numbers of symbols on each card, and allows up to four players on one device (a device which, presumably, you’re ok with people jabbing with their fingers pretty hard onto when they’re excited about having found a match). Download at your own risk.

My dad is going away on a golfing holiday with seven of his friends and, since I know a little bit about mathematics, he’s asked me to help him work out the best way to arrange the teams for the week. I’ve tried to work out a solution, but can’t seem to find one that fits.

They’ll be playing 5 games during the week, on 5 different days, and they’d like to split the group of 8 people into two teams of four each day. The problem is, they’d each like to play with each of their friends roughly the same amount – so each golfer should be on the same team as each other golfer at least twice, but no more than three times.

Can you help me figure it out?

Sam Coates, Manchester

Dear Sam

Thanks for getting in touch! This is actually quite a constrained problem, and it’s no wonder you’ve struggled to find an answer. I’ve looked into it, and here’s what I’ve found:

- Each day, we need to split the 8 golfers into two teams of four. There are $8 \choose 4$ different ways to do this – we’d choose four of the eight, and call that ‘team A’, and the other four would make ‘team B’. This gives 70 options, which we can divide by two (since if we chose players 1,2,3,4 that would give an equivalent team split as if we chose players 5,6,7,8, so we’ve counted each split twice) – giving 35 options.

- Next, we need to choose five of these splits to make the five consecutive days. It’s probably safe to assume that you’d like a different one for each day, so the number of possible ways to do this is $35 \choose 5$; if we choose (without loss of generality) to make the set on the first day 1234 vs 5678, we can reduce this to $34 \choose 4$ $ = 46,376$ different ways to arrange people for the week.

Surely this is loads of possibilities, and we’ll definitely be able to find one that fits the bill?

If we look at the constraints you’ve set, it turns out we don’t actually have a lot of options for this to work; if we have 8 players, playing for 5 days, that means our plan of the week will look like this:

Day | Team A | Team B |
---|---|---|

Monday | 1 2 3 4 | 5 6 7 8 |

Tuesday | 1 ? ? ? | ? ? ? ? |

Wednesday | 1 ? ? ? | ? ? ? ? |

Thursday | 1 ? ? ? | ? ? ? ? |

Friday | 1 ? ? ? | ? ? ? ? |

Here, I’ve arranged it so that (without loss of generality) the first day is 1234 vs 5678, and then for each of the other days, the team which contains player 1 is Team A.

What we want is for each player to play with every other player two or three times. Looking at the grid, we can see that e.g. Player 1 plays with fifteen instances of a person; that is, the first three are 234, but the other 12 aren’t fixed yet. Each player similarly plays on a team with 15 other instances of a player. Of those 15, given there are 7 other players, we must have 6 lots of ‘the same player twice’ and one lot of ‘the same player three times’.

\[ 15 = (2 \times 6) + (1 \times 3) \]

That’s not a lot of choices – any combination where someone plays with two different people three times can immediately be rejected. Also, since ‘Player 1 plays on a team with Player 2 three times’ immediately implies ‘Player 2 plays with Player 1 three times’, the players have to pair off into four pairs of ‘triple buddies’, and every other pairing must happen exactly twice.

It’s quite possible to work out setups where e.g. Player 1’s requirements are satisfied; if we fill in the left hand half using two of each number between 2 and 7, we might get a setup like this:

Day | Team A | Team B |
---|---|---|

Monday | 1 2 3 4 | 5 6 7 8 |

Tuesday | 1 2 5 7 | 3 4 6 8 |

Wednesday | 1 3 6 8 | 2 4 5 7 |

Thursday | 1 4 5 7 | 2 3 6 8 |

Friday | 1 6 8 ? | ? ? ? ? |

Checking the number of times 2 pairs with each number quickly reveals that if we make our missing final entry on the left be a 2 (giving 3 4 5 7 on the right), then 2 pairs with everything except 1 twice, and 1 pair with everything except 2 twice, and then 1 and 2 are a pair of ‘triple buddies’.

However, this solution falls down as soon as you check 3, which only occurs once with 5. In fact, I’ve tried this several times with different starting points, and it never seems to get past satisfying 1 and 2, no matter how much I fiddle with it.

This was when I started to suspect this is an impossible task; the problem is so constrained that no set of combinations will satisfy it. In order to check, and since this is a nice finite question, we can write a computer program. In this case, I used group theory software called MAGMA, which is very used to handling sets of objects, and sets of sets of objects, and has lots of nice functions designed for this kind of problem.

Roughly, the steps the program took were:

- Generate the list of 35 possible left-hand sides
- From this, generate the list of 46,376 possible weeks of golf
- Take the set of pairs of numbers from the set $\{1,\ldots,8\}$
- For each possible golf week, determine how many times each pair occurs
- As you go through the list, if any set of days has pairs occurring only in multiples of 2 or 3, print it on the screen.

The program took a few seconds to run, since this kind of number-crunching is pretty easy if you’re a computer. When it had finished, the screen was sadly blank. (I didn’t write an extra line into the program to output a sad face if there were no matches, but we should have).

This means there’s no way to arrange eight people into five games of golf so everyone plays with each other 2 or 3 times. But, since this is one of those ‘real world problems’, I figured rather than come back to you with the answer “NO”, I’d come back with something your dad might find useful. I scanned the list again, this time looking for entries where everyone plays each other at least ONCE, but no more than three times.

There were plenty of results, although some of them had 6 or more pairs which only got one game together. I did find what I think is the most pleasing of all the possible solutions, which only has four ‘one-game pairs’, and if the 8 players were, for instance, four couples, or four pairs of friends, you could arrange it so they only play each other once. Here’s the solution:

Day | Team A | Team B |
---|---|---|

Monday | 1 2 3 4 | 5 6 7 8 |

Tuesday | 1 4 5 7 | 2 3 6 8 |

Wednesday | 1 3 6 7 | 2 4 5 8 |

Thursday | 1 3 5 8 | 2 4 6 7 |

Friday | 1 4 5 8 | 2 3 6 7 |

The four ‘one-game pairs’ are $(12)$, $(34)$, $(56)$ and $(78)$, and the only time they get to play together is on day one (provided that’s the order you choose to put the days in). If you look at the left-hand column, this has a pleasing symmetry to it. The 3s and 4s in their column follow an ABBA pattern; the 5s and 6s go ABAB, and the 7s and 8s go AABB. I couldn’t have designed a more logical system myself, if it hadn’t been spat out at me by a simple computer program.

What would be nice is if we could find a more elegant proof that this isn’t possible (obviously, your dad won’t care, but we will feel better about it). There’s a branch of mathematics called Combinatorial Design Theory, which deals with ways to construct different sets of subsets of a set, given constraints like these. For example, a **balanced** **block design** is a way of picking a number of blocks, i.e. smaller sets, from a set of objects, so that each pair of objects occurs in the same number of blocks.

While I’m sure a design exists that’s able to answer this particular question, I don’t know enough about design theory to say for sure. Maybe one of our readers knows, and can comment below?

I hope this helps to answer your question, and I wish your dad a great golf week, with lots of small numbers in it!

Katie

]]>The conjecture says that any continuous map of a simplex of dimension $(r−1)(d+1)$ to $\mathbb{R}^d$ maps points from $r$ disjoint faces of the simplex to the same point in $\mathbb{R}^d$. In certain cases the conjecture has been proven true, but there have been found counterexamples in the case where $r$ is not a prime power, for sufficiently large values of $d$: the smallest counterexample found is for a map of the 100-dimensional simplex to $\mathbb{R}^{19}$, with $r=6$.

The result was recently unveiled at the Oberwolfach Maths Research Institute, which is situated in the Black Forest in Germany and regularly hosts bands of fiercely clever mathematicians. The disproof, by Florian Frick, is found in the paper Counterexamples to the Topological Tverberg Conjecture.

From Oberwolfach: The Topological Tverberg Conjecture is False, at Gil Kalai’s blog

Counterexamples to the Topological Tverberg Conjecture, by Florian Frick on the ArXiv

Florian Frick’s TU Berlin homepage

* via Gil Kalai on Google+*

Honeybees scout for nesting sites in tree cavities and other nooks and crannies, and need to know whether a chamber is large enough to contain all the honey necessary to feed their colony throughout the winter. A volume of less than 10 litres would mean starvation for the whole colony, whereas 45 litres gives a high chance of survival. How are tiny honeybees able to estimate the capacity of these large enclosed spaces, which can be very irregular and have multiple chambers?

In the paper “How might individual bees measure massive volumes?” social entomologists Nigel Franks and Anna Dornhaus suggest that honeybees might make intuitive use of the *mean free path length* formula.

Imagine a billiard table of any shape, with a ball (represented by a point mass, as per usual) rolling around frictionlessly and bouncing off the irregular sides. How far, on average, will the ball travel between bounces? This average is the mean free path length, which I’ll write as $\mathbb{E}(L)$.

The mean free path length is, surprisingly, independent of the shape of the billiard table: it is exactly $\mathbb{E}(L)=\pi \frac{\text{Area}}{\text{Perimeter}}$.

In a three-dimensional space, you can play the same game again (so long as you have access to a zero-gravity billiard room), which leads to the solution $\mathbb{E}(L)=4 \frac{\text{Volume}}{\text{Surface area}}$.

If you’re wondering about the constants $\pi$ and $4$ in the equations above, they are both of the form \[C_D = \frac{\text{Surface area of a }D\text{-dimensional sphere}}{\text{Volume of a }(D-1)\text{-dimensional sphere}}\] and so are unitless. A one-dimensional sphere is a line between points $-r$ and $+r$ and its ‘volume’ is its length, $2r$. Likewise, a two-dimensional sphere is a circle, whose ‘volume’ is its area, and ‘surface area’ is its perimeter. So $C_2=\frac{2\pi r}{2 r}=\pi$ and $C_3 = \frac{4 \pi r^2}{\pi r^2}=4$. These formulas are typically used by acoustic engineers and some particle physicists.

So, back to bees. Rearranging the formula to \[\text{Volume} \propto \text{Surface area} \times \mathbb{E}(L)\] provides a way of calculating or comparing volumes, but would present our humble heroes with two new problems: estimating the mean free path length and the surface area.

It’s well known that bees are able to measure flight distances. Being collaborative social insects, when they return to their nests after finding a good site for nectar or nesting, they communicate the direction of travel to other bees via a waggle dance, tracing a figure of eight over and over again, with a zigzagging dance in the middle. Not only does the dance uniquely identify a direction, but the number of zigzags is roughly proportional to the distance away of the location of interest. Bee researchers understand the waggle dance so well that they can also read the instructions, and then run off and find the location that the bees are dancing about.

However, the mechanism by which bees measure distance is less certain. One conjecture is that they are aware of either how long they have flown for, or how much energy they have used. Another is that bees use visual clues: the amount of scenery change they see whilst flying. This ‘visual odometry’ conjecture has been backed up by some brilliant research where bees flew through tunnels with various patterns on the walls. Bees that flew through a 6m tunnel with extremely random Julesz patterns reported up to about 200m flown. In tests using tunnels with stripes parallel to the bees’ direction of travel (ie. no change in the pattern) bees reported lengths of about a quarter of those who flew through the same tunnel decorated with Julesz patterns.

This gives a few ideas about how bees might measure the mean free path length, $\mathbb{E}(L)$: they can simply fly randomly in a straight line between walls a few times to get some sense of how far they travel between landings (no actual bouncing is required). Bees do make such short hopping flights between the walls of potential nest sites, otherwise unexplained behaviour that is consistent with this explanation. But how about measuring the surface area?

By carefully choosing light levels and coating the inside of wooden nest boxes with slippery fluon, lifelong bee researcher Thomas Seeley has shown that, to evaluate a potential nest site, honeybees need either sufficient light to see or to be able to walk freely around it. Honeybees’ opinions of the real estate can be visually polled by watching how many followers they attract to the nest box within a fixed period of time. Honeybees convince each other to visit the locations by performing waggle dances: the better the location, the more excited the waggle dance, and so the more followers. By constructing a cylindrical nest box with a sort of treadmill, Seeley has been able to trick exploring honeybees by making their walks back to the entrance seem either shorter or longer by rotating with or against their walking direction. In the experiments, the honeybees recruited more followers to the nest boxes where their walks back to the entrance were made artificially longer.

The paper by Franks and Dornhaus mentioned at the start of this article describes a similar, simple experiment to test their elegant hypothesis that bees use the connection between volume, surface area and mean free path length. As far as I know it hasn’t been carried out^{1}. Three nest boxes are to be created. The first is the control, just a plain box. The second has a partition, so while the volume will be identical, the surface area is increased, and therefore the mean free path length is decreased. The third has the same partition as the second, but the partition is coated with slippery fluon, so it has the same lower walkable surface area as the control, but the lower mean free path length of the second.

If the hypothesis is correct, the bees should like the first two boxes equally, but shun the third, believing it to be smaller. It’s a wonderful experiment: it’ll be even more wonderful when someone actually performs it.

Thomas Seeley’s “Honeybee Democracy” describes his lifetime of scientific work investigating the collective decision-making process that honeybees use to decide on potential nesting sites (Princeton University Press have made preview of Chapter 1 available). It’s a well-written book with engaging and detailed descriptions of many fascinating honeybee experiments within an area I’d never considered, but which illustrates how an aspect of bees’ group intelligence is achieved. Chapter 3, in particular, is what inspired me to read around Franks and Dornhaus’ paper.

Most humans have $2^n$ ancestors $n$ generations above (at least for small $n$). There are exceptions: for instance, some of the great-grandsons of Queen Victoria only had six great-grandparents (Victoria and Albert were their great-grandparents in two ways).

While female honeybees also have two parents of each sex, the males only have one parent: the queen bee^{2}. How many ancestors does a male drone bee have $n$ generations above?^{3}.

**Apiological Part 1: **Honeycomb geometry

- I checked with one of the authors back in June 2012, and looked for works that cite the paper just before going to press
- This is because male bees only have half as many chromosomes as the females: meaning that female bee siblings share $3/4$ of their genes on average (instead of $1/2$ in humans), which is important for workers in a hive cooperating. This high proportion of shared inheritance means that it’s strongly in their and their genes’ evolutionary interests to help any new queens that their mother gives birth to.
- I.e. one parent, two grandparents, three great-grandparents,…

We started off with a nice logic puzzle to warm up, which we gave to everyone to see who could get an answer the quickest:

MAN: We think Eric did it. pic.twitter.com/ki8Gf2p03U

— Maths Jam (@MathsJam) January 20, 2015

Lots of toys and games were present this month – we built a truncated icosahedral structure using the tiny magnetic balls (so dangerous they’re banned in three-ish countries), and played with some Japanese box opening puzzles, which someone had found in a second-hand shop.

Then we instigated a large game of Tetris Jenga, while discussing the shortcomings of the Tetris/Jenga crossover format (not all the pieces have four squares to them, not all Tetris pieces are represented, it’s really difficult to play) and despite all this we managed to keep the game going for a good while.

At this point, for complicated logistical reasons, we moved tables, after which the group split across two tables and various games were played. On one table, a game of No Thanks!, with its interesting game theoretic strategy – you have to try to collect the optimal hand, and each card can be directly picked up or offered round the table, which is often worth doing, as it results in winning more tokens (I didn’t play – I only had it explained to me – but I’d like to next time!). On the other table, a game of MathsJam staple SET took place, followed by what’s quickly becoming a staple – 6 Nimmt!, a German card game involving placing your cards without overfilling a stack, in which case you have to take the whole stack.

We also tried out someone’s new Christmas present – a dice game called Farkel. While it can be played using a regular set of dice, the Farkel dice that came with instructions had a different symbol (‘Farkel’, or ⌘) in place of the number 5 (but were otherwise just normal dice). This resulted in a group decision to replace the word ‘five’ with the word ‘farkel’ in conversation, and hilarity ensued (especially for the person scoring the game, who had to often say things like ‘you have farkel hundred and farkelty points’, written ⌘⌘0). We’re such wags.

The game involves trying to roll certain combinations to score points, and on each roll you choose which of your dice you want to score, and have the option of re-rolling the rest – although if none of them score anything, you lose all the points you’ve earned so far that turn. The game’s initial barrier of needing to score at least 500 points (⌘00 points) to be ‘in’, much like the mechanic in Rummikub, meant that it took us a while for all 7 players to be scoring points. Mostly, we just complained that all the scores were multiples of 10 (indeed, multiples of farkelty) so we could have divided the whole thing through, and instead of trying to score 10,000 points to finish, we’d only need 200, which would… be quicker?

We also had a crack at some of the puzzles posed by other MathsJams on Twitter, including a square-based teaser from Leeds – but it was mostly good to see everyone, and to have such a good turnout (with a few new faces too!). We’re all looking forward to February 201⌘!

]]>Pls RT: Just launched! The twitter feed of the Research Committee of @IMAmaths , we provide useful information for UK maths researchers.

— IMA Research (@IMA__research) February 12, 2015

Recently launched, @IMA_Research is the new Twitter account for the Research Committee of the IMA. The Committee works with funders and users of mathematics research, to promote the needs of mathematics and applied mathematics research, and the account promises to ‘provide useful information’ – they obviously don’t understand how Twitter works.

Maths! In Cosmopolitan magazine?! This might be the best achievement of my life so far: http://t.co/OUTqNpwlhH — Hannah Fry (@FryRsquared) February 11, 2015

Hannah Fry, YouTube star and UCL mathematics outreach bod, is also a superstar on Twitter, and tweets about interesting maths and videos of cute dogs.

number of consecutive times Jurassic Park could have played during the Jurassic period

— Wolfram|Alpha Can’t (@wacnt) January 3, 2015

Wolfram|Alpha, that fantastic source of mathematical insight (and doing your maths homework for you), has its limitations. This Twitter account posts examples of things which Wolfram|Alpha wasn’t able to parse and calculate instantaneously. This could be my new favourite thing.

]]>*Axis* is a retro-styled game a bit like *Missile Command* crossed with a graphing calcuator. Instead of pointing a turret and trying to estimate a parabolic trajectory ending at one of your enemies, your shot follows the path of any function $y=f(x)$ you can think of.

You’re only given a minute to write down your function, so breaking out pen and paper to calculate an interpolating polynomial is out – but using Wolfram|Alpha isn’t!

A little hint that isn’t completely obvious – the coordinate system for your shot is centred on the position you’re shooting from. Sometimes it’s a bit disappointing that your pieces can be placed such that there’s no clever way for your shot to get to the enemy, because its trajectory is strictly monotonic increasing in $x$. Maybe a version in polar coordinates would allow more clever trick shots.

Anyway, find a friend and give it a go. It runs in your browser, and you can set up a private game by sharing a link.

**Play Axis online: **axisthegame.com

*via /r/math*

Jeremy Paxman might never recover from having his mind so thoroughly blown.

]]>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.

]]>