Bad Math Jokes

[jack action]

 

[pinball1970]

This one took me way too long to figure out...

View attachment 342448

I need a translation please

 

[Ibix]

I need a translation please

O$\pi$nion

 

[renormalize]

I need a translation please

o(pi)nion

 

[Baluncore]

He who laughs last, laughs longest.

 

[pinball1970]

He who laughs last, laughs longest.

He who laughs last on this thread needs to study more mathematics!

I must have stuck that damn pi in the onion every which way before getting an opinion.

 

[Baluncore]

The soviet onion made me cry.

 

[WWGD]

This reminds me of Prof X's former student , who wrote a paper, where , in his dedication, he thanked Prof X, who " Taught him everything he knows about Mathematics. "

The paper was full of errors.

 

[DrClaude]

 

[jack action]

$$\sqrt{2^{6^{2^{1^{4^{4}}}}}} = 262144$$

Spoiler: What? No it doesn't.

$$\sqrt{2^{\left(6^{\left(2^{\left(1^{\left(4^{4}\right)}\right)}\right)}\right)}} = 262144$$

 

[collinsmark]

 

[DaveC426913]

 

[Ibix]

View attachment 351988

And another - four equal sides and contains four right angles:

 

[Halc]

View attachment 351988

Lego actually makes these:

A square part used to make a spiral staircase

I had used similar wording to make a square circle, but it was a 'figure with four equal straight sides and four equal angles'. Just draw it with chalk on a parking lot. If it isn't circular, you didn't draw it large enough.

 

[berkeman]

 

[berkeman]

LOL

 

[Baluncore]

 

[dwarde]

 

[jack action]

 

[Borg]

View attachment 352558

I think that there's been an orgy since I saw it last.

 

[jack action]

 

[Ibix]

Inspired by the above and the old chemist / plumber / unionised joke:

How do you tell the difference between a mathematician and an anesthesiologist? Ask them to pronounce "number".

 

[pines-demon]

– The Mandelbrot set is named after Benoit B. Mandelbrot
– What does the B. stand for?
– B. stands for Benoit B. Mandelbrot

 

[Ibix]

– The Mandelbrot set is named after Benoit B. Mandelbrot
– What does the B. stand for?
– B. stands for Benoit B. Mandelbrot

In a similar vein, Kernighan and Ritchie's classic text "The C Programming Language" has an index entry for "recursion", which includes its own page number.

 

[martinbn]

An anagram of Banach Tarski is Banach Tarski Banach Tarski.

 

[WWGD]

There's a YT channel for Measure Theory, run by 'Shirly'; almost Shirley.

 

[BillTre]

Surely you jest!

 

[WWGD]

Surely you jest!

Almost surely/Shirley.

 

[berkeman]

 

[Bandersnatch]

...or a divorce.

 

[martinbn]

...or a divorce.

May be that's what he meant by happiness.

 

[collinsmark]

(Source: https://xkcd.com/3015/)

 

[collinsmark]

View attachment 353830

(Source: https://xkcd.com/3015/)

I was curious to how meticulous Randall Monroe in his probability calculations. Did he just throw some dice figures in there hoping nobody would check, or was he actually pretty close?

Here's a repost of comic, in case it's not showing up in the quote above.

Well, I wrote a computer program to calculate the probabilities of summing up different types of dice rolling, to find out how close he was.

First let's analyze the drawing of arrows. This is easy. 5 out the the 10 arrows are cursed, so there's a 50% chance that the first arrow picked is not cursed. Now there are only 4 uncursed arrows out of 9. So the chance of the second draw, also being uncursed (given the first arrow was uncursed) is 4/9. So the probability of both arrows are uncursed is

P[uncursed] = $\left( \frac{1}{2}\right) \left( \frac{4}{9} \right) = \frac{2}{9}$ = 0.22222222...

So the probability of at least one of the arrows cursed is the probability inverse of that,
$\left( 1 - \frac{2}{9} \right) = \frac{7}{9}$= 0.7777777...

We'll come back to that. Now let's analyze the dice.

In order to calculate the sum of multiple dice, we perform a linear convolution of the probability density function (PDF) of each of the dice, for all the dice thrown.

According to the comic, he must roll three 6-sided dice, plus one 4-sided die and add the results together.

To calculate the probabilities of all of that, we convolve the PDF of a six-sided dice with itself and then again (3 PDFs convolved total so far), and then convolve that with a four-sided die.

Using the computer program, the PDF of the whole operation was:

4    0.0011574074074074073
5    0.004629629629629629
6    0.011574074074074073
7    0.023148148148148147
8    0.03935185185185185
9    0.06018518518518519
10    0.08217592592592593
11    0.10185185185185186
12    0.11574074074074076
13    0.12037037037037036
14    0.11574074074074074
15    0.10185185185185186
16    0.08217592592592593
17    0.06018518518518519
18    0.03935185185185185
19    0.023148148148148147
20    0.011574074074074073
21    0.004629629629629629
22    0.0011574074074074073

And the cumulative probability distribution:

4    0.0011574074074074073
5    0.005787037037037037
6    0.017361111111111112
7    0.04050925925925926
8    0.0798611111111111
9    0.14004629629629628
10    0.2222222222222222
11    0.32407407407407407
12    0.4398148148148148
13    0.5601851851851852
14    0.6759259259259259
15    0.7777777777777778
16    0.8599537037037037
17    0.920138888888889
18    0.9594907407407408
19    0.982638888888889
20    0.994212962962963
21    0.9988425925925927
22    1

According to the program, rolling a 15 or below is exactly the same probability of drawing at least one of the cursed arrows. So one would need to roll a 16 or greater to avoid the cursed arrows.

So Randall Monroe was not just close, he was exactly on the mark. Kudos to his attention to detail.

Spoiler: Source code

Here's the C# class that does most of the work:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Text;
using System.Threading.Tasks;
using System.Xml;

namespace DiceConvolution
{
    internal class IntegerDistribution
    {
        // public properties
        public int startingIndex { get; private set; } // typically the first nonzero index. The first index of importance. For a standard die, this is 1.
        public double[] probabilityDensityArray { get; private set; } // The zero based array of probabilities (shifted to start at array index 0).

        // constructor
        public IntegerDistribution(int startingIndex, double[] probabilityDensityArray)
        {
            this.startingIndex = startingIndex;
            this.probabilityDensityArray = probabilityDensityArray;
        }

        // methods
        public IntegerDistribution convolve (IntegerDistribution a)
        {
            // create a reversed version of the input a
            double[] aReversed = new double[a.probabilityDensityArray.Length];
            Array.Copy(a.probabilityDensityArray, aReversed, a.probabilityDensityArray.Length);
            Array.Reverse(aReversed);

            double[] output = new double[aReversed.Length + probabilityDensityArray.Length - 1];

            // Convolution
            for (int i = 0; i < output.Length; i++)
            {
                output[i] = 0;

                for(int j = 0; j < aReversed.Length; j++)
                {
                    // Only integrate legal portions of the arrays
                    if(i - j >= 0 && i - j < probabilityDensityArray.Length)
                    {
                        output[i] += probabilityDensityArray[i - j] * aReversed[j];
                    }
                }
            }
            return new IntegerDistribution(startingIndex + a.startingIndex, output);
        }

        public IntegerDistribution clone()
        {
            double[] array = new double[probabilityDensityArray.Length];
            Array.Copy(probabilityDensityArray, array, probabilityDensityArray.Length);
            return new IntegerDistribution(startingIndex, array);
        }

        public static IntegerDistribution operator+ (IntegerDistribution a, IntegerDistribution b)
        {
            return a.convolve(b);
        }

        public double[] cumulative()
        {
            double total = 0;
            double[] output = new double[probabilityDensityArray.Length];
            for (int i = 0;i < output.Length;i++)
            {
                total += probabilityDensityArray[i];
                output[i] = total;
            }
            return output;
        }

        public static IntegerDistribution operator* (int a, IntegerDistribution b)
        {
            IntegerDistribution output = b.clone();

            for (int i = 2; i <= a; i++) output += b;
            return output;
        }
    }
}

And the main program to run it:

// Main program
using DiceConvolution;

Console.WriteLine("Hello, World!");

IntegerDistribution D6 = new IntegerDistribution(1, new double[] { 1 / 6.0, 1 / 6.0, 1 / 6.0, 1 / 6.0, 1 / 6.0, 1 / 6.0 });
IntegerDistribution D4 = new IntegerDistribution(1, new double[] { 1 / 4.0, 1 / 4.0, 1 / 4.0, 1 / 4.0 });

IntegerDistribution c = (3 * D6) + D4;

for (int i = 0; i < c.probabilityDensityArray.Length; i++)
{
    Console.WriteLine(c.startingIndex + i + "    " + c.probabilityDensityArray[i]);
}

Console.WriteLine(Environment.NewLine + Environment.NewLine);

double[] cumulative = c.cumulative();

for (int i = 0; i < c.probabilityDensityArray.Length; i++)
{
    Console.WriteLine(c.startingIndex + i + "    " + cumulative[i]);
}

 

[DaveC426913]

I was curious to how meticulous Randall Monroe in his probability calculations. Did he just throw some dice figures in there hoping nobody would check, or was he actually pretty close?
...According to the program, rolling a 15 or below is exactly the same probability of drawing at least one of the cursed arrows. So one would need to roll a 16 or greater to avoid the cursed arrows.

So Randall Monroe was not just close, he was exactly on the mark. Kudos to his attention to detail.

I would have been astonished if he wasn't accurate. It's what he does.

That aside, kudos to you for verifying by code. That's the kind of next-level compulsion I pay my internet bill for.

 

[jack action]