Blog

Showing old posts. Show newest posts.

Tube map stellated rhombicuboctahedron

2015-03-24

This is the fourth post in a series of posts about tube map folding.

Previous post in series ~ View all posts in series ~ Next post in series

A while ago, I made this (a stellated rhombicuboctahedron):

Here are some hastily typed instructions for Matt Parker, who is making one at this month's Maths Jam. Other people are welcome to follow these instructions too.

You will need

48 tube maps
glue

Making a module

First, take a tube map and fold the cover over. This will ensure that your shape will have tube (map and not index) on the outside and you will have pages to tuck your tabs between later.

Now fold one corner diagonally across to another corner. It does not matter which diagonal you chose for the first piece but after this all following pieces must be the same as the first.

Now fold the overlapping bit back over the top.

Turn it over and fold this overlap over too.

You have made one module.

You will need 48 of these and some glue.

Putting it together

By slotting three or four of these modules together, you can make a pyramid with a triangle or square as its base.

A stellated rhombicuboctahedron is a rhombicuboctahedron with a pyramid, or stellation on each face. In other words, you now need to build a rhombicuboctahedron with the bases of pyramids like these. A rhombicuboctahedron looks like this:

en.wiki User Cyp, CC BY-SA 3.0

More usefully, its net looks like this:

Robert Webb

To build a stellated rhombicuboctahedron, make this net, but with each shape as the base of a pyramid. This is what it will look like 6/48 tube maps in:

If you make on of these, please tweet me a photo so I can see it!

Edit: Proof that these instructions can be followed:

Previous post in series

Tube map Platonic solids, pt. 3

This is the fourth post in a series of posts about tube map folding.

View all posts in series

Next post in series

Tube map kaleidocycles

Tags: folding paper, folding tube maps, london underground, rhombicuboctahedron, london, matt parker

×2

(Click on one of these icons to react to this blog post)

You might also enjoy...

Tube map Platonic solids, pt. 2

Tube map kaleidocycles

Tube map Platonic solids, pt. 3

Electromagnetic Field talk

Comments

Comments in green were written by me. Comments in blue were not written by me.

⭐ top comment (2017-10-14) ⭐

I wish you'd make the final stellation of the rhombicuboctahedron! And show us! I know the shapes of the faces but have been stuck two years on the assembly!

Roberts, David

×2

Add a Comment

Logic bot, pt. 2

2015-03-15

A few months ago, I set @mathslogicbot (and @logicbot@mathstodon.xyz and @logicbot.bsky.social) going on the long task of tweeting all the tautologies (containing 140 characters or less) in propositional calculus with the symbols $\neg$ (not), $\rightarrow$ (implies), $\leftrightarrow$ (if and only if), $\wedge$ (and) and $\vee$ (or). My first post on logic bot contains a full explanation of propositional calculus, formulae and tautologies.

An alternative method

Since writing the original post, I have written an alternative script to generate all the tautologies. In this new method, I run through all possible strings of length 1 made with character in the logical language, then strings of length 2, 3 and so on. The script then checks if they are valid formulae and, if so, if they are tautologies.

In the new script, only formulae where the first appearances of variables are in alphabetical order are considered. This means that duplicate tautologies are removed. For example, $(b\rightarrow(b\wedge a))$ will now be counted as it is the same as $(a\rightarrow(a\wedge b))$.

You can view or download this alternative code on github. All the terms of the sequence that I have calculated so far can be viewed here and the tautologies for these terms are here.

Sequence

One advantage of this method is that it generates the tautologies sorted by the number of symbols they contain, meaning we can generate the sequence whose $n$^th term is the number of tautologies of length $n$.

The first ten terms of this sequence are

$$0, 0, 0, 0, 2, 2, 12, 6, 57, 88$$

as there are no tautologies of length less than 5; and, for example two tautologies of length 6 ($(\neg a\vee a)$ and $(a\vee \neg a)$).

This sequence is listed as A256120 on OEIS.

Properties

There are a few properties of this sequence that can easily be shown. Throughout this section I will use $a_n$ to represent the $n$^th term of the sequence.

Firstly, $a_{n+2}\geq a_n$. This can be explained as follows: let $A$ be a tautology of length $n$. $\neg\neg A$ will be of length $n+2$ and is logically equivalent to $A$.

Another property is $a_{n+4}\geq 2a_n$: given a tautology $A$ of length $n$, both $(a\vee A)$ and $(A\vee a)$ will be tautologies of length $n+4$. Similar properties could be shown for $\rightarrow$, $\leftrightarrow$ and $\wedge$.

Given properties like this, one might predict that the sequence will be increasing ($a_{n+1}\geq a_n$). However this is not true as $a_7$ is 12 and $a_8$ is only 6. It would be interesting to know at how many points in the sequence there is a term that is less than the previous one. Given the properties above it is reasonable to conjecture that this is the only one.

Edit: The sequence has been published on OEIS!

Edit: Added Mastodon and Bluesky links

Tags: python, logic, propositional calculus, oeis, programming, mathslogicbot, bots

×5

×3

(Click on one of these icons to react to this blog post)

You might also enjoy...

Logical contradictions

Logic bot

Interesting tautologies

How OEISbot works

Comments

Comments in green were written by me. Comments in blue were not written by me.

2026-01-25

You should do a logic bot for logical graphs ...

• https://oeis.org/wiki/Logical_Graphs
• https://inquiryintoinquiry.com/2024/08...
• https://inquiryintoinquiry.com/2024/09...
• https://inquiryintoinquiry.com/2025/05...

it would be great !!!

Jon Awbrey

⭐ top comment (2023-02-09) ⭐

Great project! Would be interesting to have a version of this for the sheffer stroke.

×3

×1

×3

Add a Comment

Design your own flexagon

2015-03-03

This post explains how to make a trihexaflexagon with and images you like on the three faces.

Making the template

To make a flexagon template with your images on, visit mscroggs.co.uk/flexagons. On this page, you will be able to choose three images (png, jp(e)g or gif) which will appear on the faces of your flexagon. Once you have created the template, save and print the image it gives you.

The template may fail to load if your images are too large; so if your template doesn't appear, resize your images and try again.

Making the flexagon

First, cut out your printed tempate. For this example, I used plain blue, green and purple images.

Then fold and glue your template in half lengthways.

Next, fold diagonally across the blue diamond, being careful to line the fold up with the purple diamond. This will bring two parts of the purple picture together.

Do the same again with the blue diamond which has just been folded into view.

Fold the green triangle under the purple.

And finally tuck the white triangle under the purple triangle it is covering. This will bring the two white triangles into contact. Glue these white triangles together and you have made a flexagon.

Flexing the flexagon

Before flexing the flexagon, fold it in half through each pair of corners. This will get it ready to flex in the right places.

Now fold your flexagon into the following position.

Then open it out from the centre to reveal a different face.

This video shows how to flex a flexagon in more detail.

Tags: folding paper, flexagons

×2

×1

×2

(Click on one of these icons to react to this blog post)

You might also enjoy...

MENACE

Electromagnetic Field talk

Assorted christmaths

Christmas card 2024

Comments

Comments in green were written by me. Comments in blue were not written by me.

Add a Comment

Tube map Platonic solids, pt. 3

2015-01-31

This is the third post in a series of posts about tube map folding.

Previous post in series ~ View all posts in series ~ Next post in series

In 2012, I folded all the Platonic solids from tube maps. The dodecahedron I made was a little dissapointing:

After my talk at Electromegnetic Field 2014, I was shown the following better method to fold a dodecahedron.

Making the modules

First, take a tube map, cut apart all the pages and cut each page in half.

Next, take one of the parts and fold it into four

then lay it flat.

Next, fold the bottom left corner upwards

and the top right corner downwards.

Finally, fold along the line shown below.

You have now made a module which will make up one edge of the dodecahedron. You will need 30 of these to make the full solid.

Putting it together

Once many modules have been made, then can be put together. To do this, tuck one of the corners you folded over into the final fold of another module.

Three of the modules attached like this will make a vertex of the dodecahedron.

By continuing to attach modules, you will get the shell of a dodecahedron.

To make the dodecahedron look more complete, fold some more almost-squares of tube map to be just larger than the holes and tuck them into the modules.

Previous post in series

Tube map Platonic solids, pt. 2

This is the third post in a series of posts about tube map folding.

View all posts in series

Next post in series

Tube map stellated rhombicuboctahedron

Tags: folding paper, folding tube maps, london underground, platonic solids, london, electromagnetic field

×2

×3

(Click on one of these icons to react to this blog post)

You might also enjoy...

Tube map kaleidocycles

Electromagnetic Field talk

Tube map Platonic solids, pt. 2

Tube map Platonic solids

Comments

Comments in green were written by me. Comments in blue were not written by me.

Add a Comment

Logic bot

2014-11-26

Last week, @mathslogicbot (also now on Mastodon (@logicbot@mathstodon.xyz) and Bluesky (@logicbot.bsky.social)) started the long task of tweeting every tautology in propositional calculus. This post explains what this means and how I did it.

What is propositional calculus?

Propositional calculus is a form of mathematical logic, in which the formulae (the logical 'sentences') are made up of the following symbols:

Variables (a to z and $\alpha$ to $\lambda$) (Variables are usually written as $p_1$, $p_2$, etc. but as Twitter cannot display subscripts, I chose to use letters instead.)
Not ($\neg$)
Implies ($\rightarrow$)
If and only if ($\leftrightarrow$)
And ($\wedge$)
Or ($\vee$)
Brackets ($()$)

Formulae

Formulae are defined recursively using the following rules:

Every variable is a formula.
If $A$ is a formula, then $\neg A$ is a formula.
If $A$ and $B$ are formulae then $(A\rightarrow B)$, $(A\leftrightarrow B)$, $(A\wedge B)$ and $(A\vee B)$ are all formulae.

For example, $(a\vee b)$, $\neg f$ and $((a\vee b)\rightarrow\neg f)$ are formulae.

Each of the variables is assigned a value of either "true" or "false", which leads to each formula being either true or false:

$\neg a$ is true if $a$ is false (and false otherwise).
$(a\wedge b)$ is true if $a$ and $b$ are both true (and false otherwise).
$(a\vee b)$ is true if $a$ or $b$ is true (or both are true) (and false otherwise).
$(a\leftrightarrow b)$ is true if $a$ and $b$ are either both true or both false (and false otherwise).
($a \rightarrow\ b)$ is true if $a$ and $b$ are both true or $a$ is false (and false otherwise).

Tautologies

A tautology is a formula that is true for any assigment of truth values to the variables. For example:

$(a\vee \neg a)$ is a tautology because: if $a$ is true then $a$ or $\neg a$ is true; and if $a$ is false, then $\neg a$ is true, so $a$ or $\neg a$ is true.

$(a\leftrightarrow a)$ is a tautology because: if $a$ is true then $a$ and $a$ are both true; and if $a$ is false then $a$ and $a$ are both false.

$(a\wedge b)$ is not a tautology because if $a$ is true and $b$ is false, then it is false.

The following are a few more tautologies. Can you explain why they are always true?

$(a\leftrightarrow a)$
$((a\vee\neg a)\vee a)$
$\neg(a\wedge\neg a)$
$(a\vee(a\rightarrow b))$

Python

If you want to play with the Logic Bot code, you can download it here.

In order to find all tautologies less than 140 characters long, one method is to first generate all formulae less than 140 characters then check to see if they are tautologies. (This is almost certainly not the fastest way to do this, but as long as it generates tautolgies faster than I want to tweet them, it doesn't matter how fast it runs.) I am doing this on a Raspberry Pi using Python in the following way.

All formulae

The following code is writing all the formulae that are less than 140 characters to a file called formulae.

python

from os.path import join
path = "/home/pi/logic"

First import any modules needed and set the path where the file will be saved.

python

def candidate(formula):
    global formulae

    if len(formula) <= 140 and formula not in formulae:
        formulae.append(formula)
        print formula
        f = open(join(path,"formulae"),"a")
        f.write(formula + "\n")
        f.close()

This function checks that a formula is not already in my list of formulae and shorter than 140 characters, then adds it to the list and writes it into the file.

python

variables = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
             "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
             "u", "v", "w", "x", "y", "z", "@", "#", "2", "3",
             "4", "5", "6", "7", "8", "9"]

This line says which characters are going to be used as variables. It is impossible to write a formula in less that 140 characters with more than 36 different variables so these will be sufficient. I haven't used 0 and 1 as these are used to represent false and true later.

python

f = open(join(path,"formulae"))
formulae = f.readlines()
for i in range(0,len(formulae)):
formulae[i] = formulae[i].strip("\n")
f.close()

These lines load the formulae already found from the file. This is needed if I have to stop the code then want to continue.

python

oldlen = 0
newlen = 26

while oldlen != newlen:
    for f in formulae + variables:
        candidate("-" + f)
    for f in formulae + variables:
        for g in formulae:
            for star in ["I", "F", "N", "U"]:
                candidate("(" + f + star + g + ")")
    oldlen = newlen
    newlen = len(formulae)

The code inside the while loop goes through every formula already found and puts "-" in front of it, then takes every pair of formulae already found and puts "I", "F", "N" or "U" between them. These characters are used instead of the logical symbols as using the unicode characters leads to numerous python errors. The candidate function as defined above then adds them to the list (if they are suitable). This continues until the loop does not make the list of formulae longer as this will occur when all formulae are found.

python

f = open(join(path,"formulae"),"a")
f.write("#FINISHED#")
f.close()

Once the loop has finished this will add the string "#FINISHED#" to the file. This will tell the truth-checking code when the it has checked all the formulae (opposed to having checked all those generated so far).

Tautologies

Now that the above code is finding all formulae, I need to test which of these are tautologies. This can be done by checking whether every assignment of truth values to the variables will lead to the statement being true.

python

from os.path import join
path = "/home/pi/logic"

First import any modules needed and set the path where the file will be saved.

python

def next(ar,i=0):
    global cont
    if i < len(ar):
        if ar[i] == "0":
            ar[i] = "1"
        else:
            ar[i] = "0"
            ar = next(ar, i + 1)
    else:
        cont = False
    return ar

Given an assignment of truth values, this function will return the next assignment, setting cont to False if all the assignments have been tried.

python

def solve(lo):
    lo = lo.replace("-0", "1")
    lo = lo.replace("-1", "0")

    lo = lo.replace("(0I0)", "1")
    lo = lo.replace("(0I1)", "1")
    lo = lo.replace("(1I0)", "0")
    lo = lo.replace("(1I1)", "1")

    lo = lo.replace("(0F0)", "1")
    lo = lo.replace("(0F1)", "0")
    lo = lo.replace("(1F0)", "0")
    lo = lo.replace("(1F1)", "1")

    lo = lo.replace("(0N0)", "0")
    lo = lo.replace("(0N1)", "0")
    lo = lo.replace("(1N0)", "0")
    lo = lo.replace("(1N1)", "1")

    lo = lo.replace("(0U0)", "0")
    lo = lo.replace("(0U1)", "1")
    lo = lo.replace("(1U0)", "1")
    lo = lo.replace("(1U1)", "1")

    return lo

This function will replace all instances of "NOT TRUE" with "FALSE" and so on. It will be called repeatedly until a formula is reduced to true or false.

python

f = open(join(path,"formulae"))
formulae = f.readlines()
f.close()

f = open(join(path,"donet"))
i = int(f.read())
f.close()

variables = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
             "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
             "u", "v", "w", "x", "y", "z", "@", "#", "2", "3",
             "4", "5", "6", "7", "8", "9"]

These lines read the formulae from the file they are saved in and load how many have been checked if this script has been restarted. The the variables are set.

python

while formulae[-1] != "#FINISHED#" or i < len(formulae) - 1:
if i < len(formulae):
formula = formulae[i].strip("\n")

These lines will loop through all formulae until "#FINISHED#" is reached.

python

        insofar = True
        inA = []
        fail = False
        for a in variables:
            if a not in formula:
                insofar = False
            elif not insofar:
                fail = True
                break
            else:
                inA.append(a)

Here, the code checks that if a variable is in the formula, then all the previous variables are in the formula. This will prevent the Twitter bot from repeating many tautologies that are the same except for the variable a being replaced by b (although there will still be some repeats like this. Can you work out what these will be?).

python

        if not fail:
            valA = ["0"]*len(inA)
            cont = True
            taut = True
            while cont and taut:
                feval = formula
                for j in range(0,len(inA)):
                    feval = feval.replace(inA[j],valA[j])
                while feval not in ["0", "1"]:
                    feval = solve(feval)
                if feval != "1":
                    taut = False
                valA = next(valA)
            if taut:
                f = open(join(path,"true"),"a")
                f.write(str(formula) + "\n")
                f.close()

        i += 1
        f = open(join(path,"donet"),"w")
        f.write(str(i))
        f.close()

Now, the formula is tested to see if it is true for every assignment of truth values. If it is, it is added to the file containing tautologies. Then the number of formulae that have been checked is written to a file (in case the script is stopped then resumed).

python

    else:
        f = open(join(path,"formulae"))
        formulae = f.readlines()
        f.close()

If the end of the formulae file is reached, then the file is re-loaded to include all the formulae found while this code was running.

Tweeting

Finally, I wrote a code that tweets the next item in the file full of tautologies every three hours (after replacing the characters with the correct unicode characters).

How long will it take?

Now that the bot is running, it is natural to ask how long it will take to tweet all the tautologies.

While it is possible to calculate the number of formulae with 140 characters or less, there is no way to predict how many of these will be tautologies without checking. However, the bot currently has over 13 years of tweets lines up. And all the tautologies so far are under 30 characters so there are a lot more to come...

Edit: Updated time left to tweet.

Edit: Added Mastodon and Bluesky links

Tags: python, logic, propositional calculus, raspberry pi, programming, mathslogicbot, inline code, bots

×4

×5

×4

(Click on one of these icons to react to this blog post)

You might also enjoy...

Logical contradictions

Logic bot, pt. 2

Interesting tautologies

How OEISbot works

Comments

Comments in green were written by me. Comments in blue were not written by me.

⭐ top comment (2017-07-05) ⭐

In part two you say a_{n+4} >= 2*a_n, and you have 13 years worth of tweets of length (say) 15-30. so there are 26 years worth length 19-34 characters, 13*2^n years worth of tweets of length between (15 + 4n) and (30 + 4n). In particular, setting n = 27, we have 13*2^{27} = 1744830464 years worth of tweets of length 123-138. I hope you have nice sturdy hardware!

Christian

×3

Add a Comment

End of page. Show older posts.

Blog

Tube map stellated rhombicuboctahedron

You will need

Making a module

Putting it together

You might also enjoy...

Comments

Logic bot, pt. 2

An alternative method

Sequence

Properties

You might also enjoy...

Comments

Design your own flexagon

Making the template

Making the flexagon

Flexing the flexagon

You might also enjoy...

Comments

Tube map Platonic solids, pt. 3

Making the modules

Putting it together

You might also enjoy...

Comments

Logic bot

What is propositional calculus?

Formulae

Tautologies

Python

All formulae

Tautologies

Tweeting

How long will it take?

You might also enjoy...

Comments

Archive

Feb 2026

Dec 2025

Nov 2025

Sep 2025

Aug 2025

Jun 2025

Mar 2025

Jan 2025

Dec 2024

Nov 2024

Feb 2024

Jan 2024

Dec 2023

Nov 2023

Sep 2023

May 2023

Apr 2023

Mar 2023

Feb 2023

Jan 2023

Dec 2022

Nov 2022

Oct 2022

Mar 2022

Feb 2022

Jan 2022

Dec 2021

Nov 2021

Sep 2021

May 2021

Jan 2021

Dec 2020

Nov 2020

Jul 2020

May 2020

Mar 2020

Feb 2020

Jan 2020

Dec 2019

Nov 2019

Sep 2019

Jul 2019

Jun 2019

Apr 2019