The graph module was introduced in the graphs in generativepy tutorial. In this tutorial, we will cover some more advanced techniques:

• Converting graph coordinates into drawing coordinates

• Drawing and labelling points on a graph

• Drawing lines and tangents

• Showing discontinuities of a function

• Filling graphs

• Highlighting sections of a graph

Converting graph coordinates into drawing coordinates

This graph shows the sine function. It also has a blue dot and a text label “Max” at a specific point on the curve:

The point marks the graph’s maximum value. The graph represents the sine function. We know that the sine function has a maximum value of 1 when x is pi/2. So we would like to draw a point at (pi/2, 1). But how do we do that?

The point is simply a circle filled with blue. We know how to draw a circle, but we set its position using pixel coordinates. But the point (pi/2, 1) is expressed in terms of the graph coordinates. Which pixel is at the centre of the circle? Well, the Axes object used to draw the graph has a useful function that converts graph coordinates into pixel positions:

    p = (math.pi/2, f(math.pi/2))
    pixel_p = axes.transform_from_graph(p)

Next, we’ll see how to draw the point and label it.

Drawing and labelling points on a graph

The graph is similar to the example given in the graph article. Here is the full code that draws the graph and also adds the blue point and text:

import math
from generativepy.color import Color
from generativepy.drawing import setup, make_image
from generativepy.geometry import Circle, Text
from generativepy.graph import Axes, Plot


def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    f = lambda x: math.sin(x)

    axes = (Axes(ctx, (50, 50), 400, 250).of_start((0, -1.5))
                                         .of_extent((8,3))
                                         .with_divisions((1, 0.5)))
    axes.draw()
    Plot(axes).of_function(f).stroke(Color(1, 0, 0), 3)

    # Add point and text label
    p = (math.pi/2, f(math.pi/2))
    pixel_p = axes.transform_from_graph(p)
    Circle(ctx).of_center_radius(pixel_p, 6).fill(Color("blue"))
    (Text(ctx).of("Max", pixel_p).offset(10, -10).font("Ariel")
             .size(20).fill(Color("black")))


make_image("plot-graph-point.png", draw, 500, 350)

The additional code first creates point p at (pi/2, 1), then calculates its position in pixel coordinates, pixel_p. This code was shown in the previous section.

We draw the blue point like this:

    Circle(ctx).of_center_radius(pixel_p, 6).fill(Color("blue"))

This is a circle centered at pixel_pand colored blue. We give the circle a radius of 6, which seems to be a sensible size for the diagram. Notice that the radius is also measured in pixel coordinates rather than graph coordinates. So the circle has a radius of 6 pixels.

We draw the text label like this:

    Text(ctx).of("Max", pixel_p).offset(10, -10).font("Ariel")
             .size(20).fill(Color("black"))

We use the Text object in the usual way. Again, we use the pixel position pixel_p to position the text. We use an offset of 10 pixels to the right and 10 pixels up to move the text slightly away from the point, and we set the text size to 20 pixels. You can choose your own values, but they look about right.

Drawing lines and tangents

We sometimes need to draw additional lines on a graph. Here are a couple of examples:

The green line is a simple horizontal line. The blue line is a tangent to the curve, which requires slightly more work, but it isn’t too complicated. Here is the full code:

import math
from generativepy.color import Color
from generativepy.drawing import setup, make_image
from generativepy.geometry import Line
from generativepy.graph import Axes, Plot
from generativepy.math import Vector as V

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    f = lambda x: math.sin(x)
    fd = lambda x: math.cos(x)

    axes = (Axes(ctx, (50, 50), 400, 250).of_start((0, -1.5))
                                         .of_extent((8,3))
                                         .with_divisions((1, 0.5)))
    axes.draw()
    Plot(axes).of_function(f).stroke(Color(1, 0, 0), 3)

    # Add horizontal line
    p1 = (3, -0.8)
    p2 = (7, -0.8)
    pixel_p1 = axes.transform_from_graph(p1)
    pixel_p2 = axes.transform_from_graph(p2)
    (Line(ctx).of_start_end(pixel_p1, pixel_p2)
              .stroke(Color("darkgreen"), 3))

    # Draw tangent
    x = 2.1
    p = V(x, f(x))
    slope = fd(x)
    angle = math.atan(slope)
    delta = V.polar(1, angle)
    pixel_p1 = axes.transform_from_graph(p + delta)
    pixel_p2 = axes.transform_from_graph(p - delta)
    (Line(ctx).of_start_end(pixel_p1, pixel_p2)
              .stroke(Color("blue"), 3))

make_image("plot-graph-line.png", draw, 500, 350)

Drawing the green, horizontal line is quite easy. The line joins the two points (3, -0.8) and (7, -0.8), expressed in graph coordinates. We convert those two points to pixel coordinates and draw a line between them. Here is the section of the above code that draws the line:

    # Add horizontal line
    p1 = (3, -0.8)
    p2 = (7, -0.8)
    pixel_p1 = axes.transform_from_graph(p1)
    pixel_p2 = axes.transform_from_graph(p2)
    (Line(ctx).of_start_end(pixel_p1, pixel_p2)
              .stroke(Color("darkgreen"), 3))

The blue line is a tangent to the curve at x = 2.1. To create this, we first need to find the slope of the curve. It is helpful to know the derivative of the curve. Since the function f is sin(x), we know from high school maths that the derivative fd is cos(x). We define the function fd at the start of the draw function. Here is the part of the code that finds the tangent:

    x = 2.1
    p = V(x, f(x))
    slope = fd(x)

Point p is the point where the tangent touches the curve. Notice that we have defined the point p as a Vector, aliased as V. This lets us use vector operations to find the tangent line’s endpoints.

Next, we find the two end points of the tangent line:

    angle = math.atan(slope)
    delta = V.polar(1, angle)

angle is the angle that the tangent line makes with the x-axis. We calculate it by taking the inverse tangent of the slope (the atan function).

delta is a vector, of length 1, that points in the direction of the tangent line. We do this by defining a vector in polar form, with a modulus of 1 and an argument of angle.

The vector p + delta gives a point that is on that tangent line, distance 1 from p. And p - delta gives a point that is on that tangent line, distance 1 from p in the opposite direction. If we convert those two points to pixel coordinates, then draw a line between them, we will draw a tangent line of length 2:

    pixel_p1 = axes.transform_from_graph(p + delta)
    pixel_p2 = axes.transform_from_graph(p - delta)
    (Line(ctx).of_start_end(pixel_p1, pixel_p2)
              .stroke(Color("blue"), 3))

Showing discontinuities of a function

If a function has a discontinuity, it often needs slightly special handling. For example, consider this function:

lambda f(x): 0 if x <= 3 else 1

This function has a value of 0 when x is less than or equal to 3, and 1 otherwise. There is a step change at x = 0, where the function goes from 0 to 1, without ever taking a value between 0 and 1.

However, if we plot this function in the usual way, we get something like this:

The problem here is that the Plot object calculates the value of the function at lots of different points, and then joins all those points together. So at x = 3 it doesn’t show a discontinuity. Instead, it shows a step function, which isn’t usually what we want.

What we really want is something like this:

In this graph, the two sections are disconnected to indicate that the function changes from 0 to 1 without taking any intermediate values. We have also drawn an open circle at point (3, 1). This indicates that the value of the function is 0 when x is 3. The function equals 1 for any value of x greater than 3, so the top line gets infinitesimally close to (3, 1) but never reaches it.

Here is the code to draw the correct graph:

from generativepy.color import Color
from generativepy.drawing import setup, make_image
from generativepy.geometry import Circle, Text
from generativepy.graph import Axes, Plot

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    f = lambda x: 0 if x <= 3 else 1

    axes = (Axes(ctx, (50, 50), 400, 250).of_start((0, -1.5))
                                         .of_extent((8,3))
                                         .with_divisions((1, 0.5)))
    axes.draw()

    (Plot(axes).of_function(f, extent=(0, 2.9999))
               .stroke(Color(1, 0, 0), 3))
    (Plot(axes).of_function(f, extent=(3.0001, 8))
               .stroke(Color(1, 0, 0), 3))

    p = (3, 1)
    pixel_p = axes.transform_from_graph(p)
    (Circle(ctx).of_center_radius(pixel_p, 4).fill(Color("white"))
                                            .stroke(Color(1, 0, 0), 3))

make_image("plot-graph-discont.png", draw, 500, 350)

As you can see, we plot the function twice. The first plot is limited to the range 0 to 2.9999, using the extent parameter, so it plots the portion of the graph where the function is 0. The range starts at 0 because that is the start of the x-axis, and it extends to 2.9999 because that value is so close to 3 that it looks like the graph reaches 3, but the function does not change to 1.

The second plot is limited to the range 3.0001 to 8, so it plots the portion of the graph where the function is 1. The range starts at a value slightly above 3, but by so small an amount that it isn’t visible on the graph. It extends to 8, which is the end of the x-axis.

Notice that we don’t need to convert these values to pixel coordinates, because we are passing them into Plot.of_function, which already uses graph coordinates.

The open circle is created using a Circle object, in the same way that we previously marked a point in the graph. We need to convert the point (3, 1) to pixel coordinates, as before. To create the empty circle, we stroke it with the same color we used for the plot (red) and fill it with the same color as the graph background (white).

Highlighting sections of a graph

It is sometimes useful to highlight a section of a graph, like this:

This is quite easy to do. We first plot the graph normally (the red curve), then plot the highlighted region (x from 1 to 5) using a thicker blue line. Here is the plotting code:

    a = 1
    b = 5
    Plot(axes).of_function(f).stroke(Color(1, 0, 0), 3)
    Plot(axes).of_function(f, extent=(a, b)).stroke(Color("darkblue"), 5)

A slight variation on this is to plot the thicker highlight region first, then plot the main curve on top. This often works best with a lighter highlight color and a dark main color:

Filling graphs

We fill a graph by closing it, to make a closed shape. We do that with the close parameter of the of_function call. Here is the complete code:

import math
from generativepy.color import Color
from generativepy.drawing import setup, make_image
from generativepy.graph import Axes, Plot

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    f = lambda x: math.sin(x)

    axes = (Axes(ctx, (50, 50), 400, 250).of_start((0, -1.5))
                                         .of_extent((8,3))
                                         .with_divisions((1, 0.5)))
    axes.draw()

    a = 1
    b = 2.5
    (Plot(axes).of_function(f, extent=(a, b), close=((b, 0), (a, 0)))
               .fill(Color("red").with_a(0.5))
               .stroke(Color(1, 0, 0), 3))

make_image("plot-fill.png", draw, 500, 350)

In this code, we plot a graph of f between x values of a and b. But we also add two extra points, using the close parameter:

• The point (b, 0) is on the x-axis directly below the end of the curve segment.

• The point (a, 0) is on the x-axis directly below the start of the curve segment.

These are shown here:

When we use the close parameter, the Plot object adds some extra lines to create a closed shape:

• It adds a line from the endpoint of the graph to the first point in the close list, which is (b, 0) in our case.

• It adds a line from the first point of the close list to the second point in the close list, which is (a, 0) in our case.

• If the close list had more elements, they would also be joined, but in our case there are only the elements.

• Finally, it adds a line from the last point in the close list, which is (a, 0) in our case, back to the start of the curve.

This creates a closed shape which we can outline and fill. Here is the final result of the original code above:

One thing to notice is that we have used a transparent fill color Color("red").with_a(0.5). This is red but 50% transparent. That is optional, of course, but it can look nice because the graph grid lines show through the fill.

There are a couple of useful variants. You might prefer to fill the curve without any additional outlines, like this:

We do this by plotting the graph twice. The first time, we close the graph and fill it, but we don’t stroke it. The second time, we plot the graph without closing it, and this time we stroke the graph without filling it (i.e., we plot the graph normally). Here is the plotting code:

    (Plot(axes).of_function(f, extent=(a, b), close=((b, 0), (a, 0)))
               .fill(Color("red").with_a(0.5)))
    (Plot(axes).of_function(f, extent=(a, b))
               .stroke(Color(1, 0, 0), 3))

You might also want to plot the graph across the full axis width, like this:

To do this, set a and b to the start and end of the axes (0 and 8 in this case).

This chapter covers the basics of creating vector images with generativepy. It provides a simple template for drawing vector images using the drawing module. It also shows how to use the geometry module to draw various shapes and style them.

generativepy can also create bitmap images, NumPy-based images, 3D images, and videos. We cover these in later tutorials, but the basic process is similar in all cases.

Vector images

A computer image is often stored as a 2-dimensional array of pixels, where each pixel can be any colour. This is called a bitmap image.

However, with vector graphics, we don’t usually specify the colours of individual pixels. Instead, we work at a higher level, defining shapes in the image. These can be simple shapes, such as rectangles, or more complex shapes, such as text characters.

When we use generativepy in vector mode, our program specifies a shape and how to fill and outline it. The generativepy library decides the colour of each pixel.

The result is still a bitmap image file, in PNG format. However, your code describes the image in terms of shapes rather than pixels, which is more useful for mathematical images.

In this article, we will look at:

• The generativepy coordinate system

• Drawing basic shapes (such as lines, polygons, circles, and more).

• Fill and outline styles.

Vector graphics also include more advanced features, such as compound shapes (e.g., shapes with holes), complex curves, and clipping. We will look at these in a later chapter. There are also specialised techniques for mathematical diagrams, such as creating geometric diagrams and graphs, which we will cover in a later chapter.

Creating our first image

To start, we will create the following simple image, as a 500 by 400 pixel PNG file, consisting of an orange rectangle on a grey background:

Before you try this code, you will need to install generativepy and its dependencies, see the introduction

The code

Here is the code to draw the image above:

from generativepy.color import Color
from generativepy.drawing import setup, make_image
from generativepy.geometry import Rectangle

def draw(ctx, width, height, frame_no, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(%22grey%22))
    Rectangle(ctx).of_corner_size((100, 150), 250, 200).fill(Color("orange"))

make_image("rectangle.png", draw, 500, 400)

We will now look at this code in more detail.

Basic structure

The basic structure of the code is:

• A user-defined function draw that does the drawing.

• A call to make_image. This function creates an image and saves it to a file. We pass in the draw function to control the image content.

This basic structure is used throughout generativepy. We use a draw function to create the drawing, and a make_XXX function to create the image. We use the same pattern for bitmap images, NumPy-based images, and 3D images. We use the same pattern whether we are creating still images, animated GIFs, image sequences, or videos.

In all cases, images are stored in memory as “frames”. A frame is a NumPy array containing the pixel data. This makes the library flexible, as you can combine images from different sources using simple Python and NumPy functions.

For vector images, like this one, generativepy uses the Pycairo library behind the scenes. In fact, ctx is a Pycairo drawing context.

make_image

The make_image function in the drawing module is the main function for creating vector images.

The parameters are:

• outfile, the filename of the output PNG file.

• A draw function that does the actual drawing.

• The width and height of the image in pixels.

• An optional channels parameter that is mainly used for creating images with transparency.

The draw function is one we define ourselves to draw the image. It doesn’t have to be called draw, of course - you can call it whatever you like, provided you pass its name into make_image. The draw function must have the correct signature (in other words, it must accept the parameters described below).

draw function

The draw function draws the image content. We never call draw ourselves. We always pass draw into make_image, and make_image calls draw. The draw function accepts 5 parameters:

• ctx is a Pycairo context. This is like a virtual drawing surface that you can draw on in code. Whatever you draw will appear on the final image.

• width and height are the width and height of the image in pixels. These are the values that we passed into make_image.

• frame_no and frame_count are only used when you want to create image sequences (for animations), so we can ignore them here.

generativepy uses Pycairo as its drawing library. generativepy provides a rich set of high-level drawing functions for creating shapes, text, markers, graphs, and formulas that can be added to the image within the draw function

The generativepy drawing functions are built on top of the normal Pycairo functions. If you are familiar with Pycairo, it is also possible to use the Pycairo functions directly, or even to use a mixture of generativepy and Pycairo calls. Usually, though, it is better to stick with the generativepy functions as they operate at a higher level and are designed specifically for maths and diagrams.

Our draw function calls the setup function to set up the drawing area, then draws a rectangle.

setup function

The setup function isn’t mandatory, but it does some useful things, so you will often want to call it.

setup has 3 required parameters: ctx, width and height. We use the values that were passed into the draw function. It has some optional parameters that do various things, described below.

In this case, we are setting the background parameter to Color("grey"), which sets the background colour to a mid-grey. We define the colour using the color module of generativepy. In this example, we are using colour names to select colours. These names are based on the CSS named colours. The color module has much more functionality, described in a later chapter.

Drawing a rectangle

We use a Rectangle object to draw a rectangle, like this:

Rectangle(ctx).of_corner_size((100, 150), 250, 200).fill(Color("orange"))

All shapes are drawn using the same pattern:

• Declare a shape object, for example Rectangle(ctx), passing in the context, ctx.

• An of_xxx method is used to define the shape. In this case, of_corner_size defines a rectangle from the position of its top, left-hand corner, and its width and height. The corner is specified using an (x, y) tuple.

• A drawing method is then used to draw the shape. In this case, we use fill, which fills the shape with orange.

Coordinate system

All coordinates and sizes are specified in user space coordinates.

By default, user space is measured in pixels, based on the size of the image we are creating.

• The origin of the user space coordinate system (0, 0) is at the top left of the image.

• x values increase from left to right.

• y values increase as you move down the image.

In our case:

• Our image is 500 by 400 pixels.

• The orange rectangle is 250 by 200 pixels.

• The position of the rectangle (that is, the position of its top-left corner) is at pixel position (100, 150).

This diagram illustrates the coordinates of the rectangle:

User space can be transformed, so that shapes drawn in user space can be scaled, rotated, etc when they are drawn, as we will see in a later tutorial.

Styling shapes

Now that we have seen how to draw a simple shape, we’ll look at how to style shapes by filling and outlining them. This can add clarity to diagrams by using colour to link related items. Colour can also make your images more interesting and appealing.

Of course, when designing graphics we should always be aware that some of our intended audience might not be able to see colour differences clearly due to colour vision deficiency (so-called colour blindness) or other visual impairments. It is always a good idea to use light and dark colours, different shapes, dashed vs solid lines, and text labelling, in addition to pure colour, to make your diagrams accessible.

Filling shapes

We have already seen how to fill a shape, but here is another example with 3 shapes:

Here is the code:

from generativepy.color import Color
from generativepy.drawing import make_image, setup
from generativepy.geometry import Rectangle, Circle, Square

def draw(ctx, width, height, frame_no, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    Square(ctx).of_corner_size((50, 50), 200).fill(Color("dodgerblue"))
    Circle(ctx).of_center_radius((250, 250), 75).fill(Color("maroon"))
    Rectangle(ctx).of_corner_size((100, 300), 350, 50).fill(Color("green", 0.4))

make_image("fill.png", draw, 500, 400)

The Square object draws the large blue square. A square is created in a similar way to a rectangle, but it only has a width (unlike a rectangle that has a width and height).

The Circle object draws the purple circle. A circle is specified similarly to a square, except that the of_center_radius method takes a centre point and a radius value to define the circle.

The other thing to notice is that the circle overlaps the previous square. Because the square was drawn before the circle, the circle is painted over the square. Part of the square is hidden behind the circle. To draw the square in front of the circle, we would reverse the drawing order by swapping the two lines of code.

The green Rectangle object, lower down the image, overlaps the circle. This time the rectangle is painted over the circle. However, the rectangle colour is partly transparent, so we can still see part of the circle behind the rectangle. The rectangle colour is set to green, but the extra parameter 0.4 is the transparency value. Because the rectangle is partly transparent, we can see the red circle behind it.

You might also notice that the background colour in the setup function is Color(1). Using 1 rather than a colour name creates a grey value of 1, which is white (described in detail in a later chapter).

Shape outlines

In addition to filling shapes, we can also outline them. We do this using the stroke method rather than the fill method. Here are the same shapes as before, outlined in different colours:

Here is the code:

from generativepy.color import Color
from generativepy.drawing import make_image, setup
from generativepy.geometry import Rectangle, Circle, Square

def draw(ctx, width, height, frame_no, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    Square(ctx).of_corner_size((50, 50), 200).stroke(Color("red"), 1)
    Circle(ctx).of_center_radius((250, 250), 75).stroke(Color("blue"), 8)
    (Rectangle(ctx).of_corner_size((100, 300), 350, 50)
                .fill(Color("orange")).stroke(Color("black"), 4))

make_image("stroke.png", draw, 500, 400)

To draw a shape outline, we use the stroke method instead of the fill method. stroke requires two parameters: the colour and the stroke width. Width is measured in user space, so by default, the stroke width is specified in pixels.

The square has a red stroke colour and a width of 1 unit (i.e., 1 pixel). This draws a thin line around the square. The middle of the square is left unfilled.

The circle has a blue stroke colour and a width of 8. This makes a much thicker line. Again, the circle is not filled so we can see the outline of the red square behind it.

The final shape, the rectangle, is filled and stroked. We call fill with the colour orange, and stroke with the colour black and a width of 4.

We call fill before stroke, so that the rectangle is filled first, then outlined.

Fill and stroke position

The stroke follows the shape’s outline, with half the stroked area inside and half outside. Here is an example of a filled and stroked rectangle:

The dotted white line shows the outline of the rectangle, ie the exact size and position we requested. The 4 small red dots show the rectangle’s corners. This indicates that the stroke is half outside the boundary and half inside.

This means that a stroked rectangle is always slightly bigger than its requested size because the stroke is centred on the exact boundary. And the filled area inside the rectangle is always slightly smaller than the requested size because the stroke covers part of the inner area. This is typical behaviour in most computer graphics systems and is intended. It looks best when, for example, the edges of two outlined shapes touch.

You can stroke the shape first and then fill it. In that case, the fill colour will occupy the whole area of the rectangle, and the stroke will appear to be half of its defined width. This method isn’t used often, but it could be useful if you wanted to paint a shape at its exact size while still having an outline.

Join styles

There are some more options for styling line strokes. It is possible to style the way the lines join, using the join parameter of the stroke method:

from generativepy.color import Color
from generativepy.drawing import make_image, setup
from generativepy.geometry import Square, MITER, ROUND, BEVEL

def draw(ctx, width, height, frame_no, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    (Square(ctx).of_corner_size((50, 50), 100)
                .stroke(Color("black"), 30, join=MITER))
    (Square(ctx).of_corner_size((200, 50), 100)
                .stroke(Color("black"), 30, join=ROUND))
    (Square(ctx).of_corner_size((350, 50), 100)
                .stroke(Color("black"), 30, join=BEVEL))

make_image("corner.png", draw, 500, 200)

Here is the result:

The left-hand square uses a MITER join that creates a sharp corner (the default if you don’t specify a style). The middle square uses a ROUND join that rounds the corners off. The right-hand square uses a BEVEL join that cuts the corners off with a straight line.

This is largely a matter of preference. Use whichever you think looks best. If several lines or corners join at the same point, it is often a good idea to use the ROUND style, as it can look neater.

Mitre limit

When using the mitre style, if the two lines meet at a very small angle, the joint can get very long and look quite odd. To avoid this, pycairo applies a mitre limit. When the angle drops below a certain size, the MITER style automatically switches to BEVEL to prevent this. You don’t need to worry about this. It happens automatically and is almost always a good thing.

You can change this behaviour using the miter_limit parameter of the stroke method. We won’t cover it in detail here because it is quite a specialised function. Refer to the official Pycairo documentation for more details.

Line caps

We can also draw straight lines, using Line objects:

A line is defined by two points - the start of the line and the end of the line. When we stroke a line, we draw a line of the chosen colour and width from the start point to the endpoint.

We can choose the style of the line caps (ie the line ends) using the optional cap parameter of the stroke method:

• SQUARE, the top line above, squares off the line ends. The two red dots indicate the line endpoints. When you select square caps, the marked area extends slightly beyond the line’s endpoints by a distance equal to half the line width. Square is the default cap type.

• BUTT, the middle line above, looks quite similar to the square case. The difference is that the line ends exactly on the endpoints, rather than extending beyond them.

• ROUND, the bottom line above, creates a rounded line end. The line end is a semicircle with a radius equal to half the line width.

Line caps only apply to the ends of lines, whereas line joins apply to the corners of shapes. Shapes such as rectangles or squares don’t have ends, so the line cap parameter doesn’t affect them. Lines have no corners, so the line join parameter does not affect them. Note that if two lines meet at a point, that doesn’t mean they are joined, so the cap value controls the appearance rather than the join value.

Here is the code to draw the diagram above:

from generativepy.color import Color
from generativepy.drawing import make_image, setup
from generativepy.geometry import Line, Circle, ROUND, SQUARE, BUTT

def draw(ctx, width, height, frame_no, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    (Line(ctx).of_start_end((50, 50), (350, 50))
              .stroke(Color("black"), 30, cap=SQUARE))
    Circle(ctx).of_center_radius((50, 50), 4).fill(Color("red"))
    Circle(ctx).of_center_radius((350, 50), 4).fill(Color("red"))

    (Line(ctx).of_start_end((50, 150), (350, 150))
              .stroke(Color("black"), 30, cap=BUTT))
    Circle(ctx).of_center_radius((50, 150), 4).fill(Color("red"))
    Circle(ctx).of_center_radius((350, 150), 4).fill(Color("red"))

    (Line(ctx).of_start_end((50, 250), (350, 250))
              .stroke(Color("black"), 30, cap=ROUND))
    Circle(ctx).of_center_radius((50, 250), 4).fill(Color("red"))
    Circle(ctx).of_center_radius((350, 250), 4).fill(Color("red"))

make_image("line-cap.png", draw, 400, 300)

This includes the three lines and the red circles that indicate the line ends.

Dash patterns

It is often useful to create dashed or dotted lines on a diagram. We can do this using the dash parameter of the stroke method. Here are some examples:

The dash pattern is specified by a list of values that define the on and off lengths of the dashed line, in user units (pixels by default).

Looking at the top row of shapes, each has a dash pattern of [16]. This means that the line will be solid for 16 pixels, then a gap of 16 pixels, repeated around the whole shape. However, each dash also includes line caps, as described above.

The square at the top left has the default line cap SQUARE. This means that, although the lines and gaps each have a nominal length of 16 pixels, the square line cap extends the lines. Since the line width is 8, this means that a cap of length 4 is added to each end of every line section. This means that each line has a marked length of 24 pixels. This means each gap is only 8 pixels (because the line occupies part of the gap).

The circle in the top centre uses the same measurements but has a BUTT style. This means each line finishes exactly at its nominal width, so the lines and gaps have equal lengths. This shape also shows how dashed lines follow curves.

The square at the top right has the same measurements but with a ROUND cap. It looks very similar to the square on the left, except that the dashes have rounded ends rather than square ends.

The bottom row of shapes demonstrates some other effects. The square on the left uses BUTT line caps, with a short length and a longer gap, to give a light dashed line. The circle is quite interesting: the line length is 0, but because the cap style is ROUND, the lines appear as circles (2 semicircular ends joined together), creating a dotted line. The square on the bottom right has a pattern of [0, 10, 3, 7], so it gives a dot-dash pattern.

Dash patterns can be used on any line, as we will see later. For example, you can outline text with dashed lines, and you can also apply dashes to line plots on graphs.

Here is the code for the examples above:

from generativepy.color import Color
from generativepy.drawing import make_image, setup
from generativepy.geometry import Rectangle, Circle, Square, BUTT, ROUND

def draw(ctx, width, height, frame_no, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    (Square(ctx).of_corner_size((50, 50), 100)
                .stroke(Color("black"), 8, dash=[16]))
    (Circle(ctx).of_center_radius((250, 100), 60)
                .stroke(Color("black"), 8, dash=[16], cap=BUTT))
    (Square(ctx).of_corner_size((350, 50), 100)
                .stroke(Color("black"), 8, dash=[16], cap=ROUND))
    (Square(ctx).of_corner_size((50, 200), 100)
                .stroke(Color("black"), 4, dash=[6, 12], cap=BUTT))
    (Circle(ctx).of_center_radius((250, 250), 60)
                .stroke(Color("black"), 6, dash=[0, 10], cap=ROUND))
    (Square(ctx).of_corner_size((350, 200), 100)
                .stroke(Color("black"), 4, dash=[0, 10, 3, 7], cap=ROUND))

make_image("dash.png", draw, 500, 350)

Other features of the setup function

Looking back at our first example code:

from generativepy.color import Color
from generativepy.drawing import setup, make_image
from generativepy.geometry import Rectangle

def draw(ctx, width, height, frame_no, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(%22grey%22))
    Rectangle(ctx).of_corner_size((100, 150), 250, 200).fill(Color("orange"))

make_image("rectangle.png", draw, 500, 400)

This creates a 500-by-400-pixel image. Now suppose we decided that we actually needed the image to be 1000 by 800 pixels, that is twice as big. We can do this quite easily by altering the size in the make_image call. But the problem then is that the rectangle size in the draw function is also wrong. That would need adjusting. We can do that easily, but what if the drawing function was very complex - we would need to go through and alter the entire drawing code.

The setup function provides an easy solution. Consider the following code:

from generativepy.color import Color
from generativepy.drawing import setup, make_image
from generativepy.geometry import Rectangle

def draw(ctx, width, height, frame_no, frame_count):
    setup(ctx, width, height, width=500, background=/__u/graphicmaths.substack.com/Color(%22grey%22))
    Rectangle(ctx).of_corner_size((100, 150), 250, 200).fill(Color("orange"))

make_image("rectangle.png", draw, 1000, 800)

Here, we have changed the image size to 1000 by 800 in the make_image call, but we have added an extra parameter width=500 in the setup call.

This tells setup to scale the drawing canvas. Since the page width is 1000 and the setup width parameter is 500, setup introduces a scale factor of 2. So everything we draw appears twice as big, which is exactly what we want. And since it is a vector drawing, the scale is done smoothly, without any pixelation.

setup also has a height parameter. We can use that instead of width. If we set height to 400, since the pixel height in make_image is 800, we would get a scale factor of 2. You can set either the width or height, whichever is more convenient. Either way, it decouples the pixel size of the image from the dimensions you use in the drawing code. So you can write your drawing code without committing to the final image size.

The scale factor doesn’t have to be an integer. For example, if you discovered that your 1000 pixel image really needed to be 2100 pixels wide, you could do that. This would be a scale factor of 2.1, but because it’s a vector image, it would still render perfectly.

You would normally only specify either width or height. If you specify both, the image might be scaled by a different amount in each direction. It would still render cleanly, but shapes would be distorted (for example, squares would be stretched into rectangles). That isn’t normally what you would want, but it can be useful in some cases.

setup also has a flip parameter that flips the axes in the y direction, so y coordinate values start from 0 at the bottom of the image. This can be useful if you prefer a graph-like coordinate system when designing an image. It also has startx and starty, which shift the image on the page. This can be useful for adding a border to an image.

setupis provided as a convenience. You can also change the image coordinates and scale using Transform objects, as described in a later tutorial.

Other shapes

generativepy supports several other shapes:

• More polygons

  • Triangles

  • General polygons

  • Regular polygons

• Line variants - segment, ray, or infinite line

• Circle variants

  • Sector, segment, and arc of a circle

  • Ellipses

More polygons

This code draws several other types of polygons:

from generativepy.color import Color
from generativepy.drawing import make_image, setup
from generativepy.geometry import (Triangle, FillParameters, StrokeParameters,
                                   Polygon, RegularPolygon, ROUND)


def draw(ctx, width, height, frame_no, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    f = FillParameters(Color("powderblue"))
    s = StrokeParameters(Color("darkslateblue"), 6, dash=[10, 8],
                         cap=ROUND, join=ROUND)

    Triangle(ctx).of_corners((50, 150), (200, 120), (100, 50)).fill(f).stroke(s)

    points = ((300, 50), (350, 100), (330, 200), (270, 200), (250, 100))
    Polygon(ctx).of_points(points).fill(f).stroke(s)

    points = ((500, 50), (550, 100), (530, 200), (470, 200), (450, 100))
    Polygon(ctx).of_points(points).open().stroke(s)

    p = RegularPolygon(ctx).of_centre_sides_radius((150, 300), 8, 70).stroke(s)
    print(p.inner_radius)

make_image("more-polygons.png", draw, 600, 400)

Here is the result:

First, you will notice that we have defined a couple of extra items:

• A FillParameters object f, initialised with a colour.

• A StrokeParameters object s, initialised with a colour, thickness, plus dash, cap, and join values.

We can use f and s as parameters for the fill and stroke methods of any object. This is useful if we want to draw several objects in the same style because it saves repetition.

The top left shape is a Triangle. This has an of_corners method to define its three corners, as (x, y) tuples. It is then filled and stroked as usual, using f and s to control the style.

The top centre shape is a Polygon. This has an of_points method to define its vertices. The vertices are provided as a sequence of (x, y) tuples.

The top right shape is another Polygon. This time, it has an extra call to its open method, which creates an open polygon, meaning the final vertex is not connected to the first vertex. This is sometimes called a polyline because you can think of it as a set of connected lines rather than a shape. We haven’t filled this shape, but you can if you wish. That would fill the shape as if it were a closed polygon, but of course, the outline would still be open.

The bottom left is a RegularPolygon. We call of_centre_sides_radius passing in:

• The position of the centre of the polygon, as an (x, y) tuple.

• The required number of sides. We passed in 8 to create an octagon.

• The radius of the shape. This controls the polygon’s size. It is the distance from the centre to any vertex of the polygon.

By default, the polygon is drawn with the bottom edge horizontal (as shown). The of_centre_sides_radius function has an optional angle parameter that rotates the shape clockwise by the supplied angle, specified in radians.

A RegularPolygon has a few useful properties, calculated from the parameters:

• side_len - the length of a side of the polygon

• interior_angle - the interior angle of the polygon (in radians)

• exterior_angle - the exterior angle of the polygon (in radians)

• inner_radius - the inner radius (distance from the centre to the midpoint of any side)

• outer_radius - the outer radius of the polygon (this is just the radius we supplied)

• vertices - a list of the vertices as (x, y) tuples

Line Variants

We have seen how to draw a line using the Line class. This draws a straight line between two points, which here we will call p1 and p2.

In computer graphics, a line normally means a finite line between two points. But in mathematics, we define three different types of lines:

• A line segment has finite length. It starts at p1 and ends at p2.

• A ray has semi-infinite length. It starts at p1 and passes through p2, but it extends beyond p2 right off to infinity. A ray is sometimes called a half-line.

• A line has infinite length. It passes through p1 and p2, but it extends to infinity in both directions.

By default, Line draws a line segment, but it can also draw rays and (infinite) lines. Here is some example code:

from generativepy.color import Color
from generativepy.drawing import make_image, setup
from generativepy.geometry import StrokeParameters, Circle, Line, ROUND

def draw(ctx, width, height, frame_no, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    def dot(p):
        Circle(ctx).of_center_radius(p, 8).fill(Color("red"))

    s = StrokeParameters(Color("darkgreen"), 6, cap=ROUND)

    p1 = (100, 300)
    p2 = (150, 100)
    Line(ctx).of_start_end(p1, p2).as_segment().stroke(s)
    dot(p1)
    dot(p2)

    p1 = (200, 300)
    p2 = (250, 100)
    Line(ctx).of_start_end(p1, p2).as_ray().stroke(s)
    dot(p1)
    dot(p2)

    p1 = (300, 300)
    p2 = (350, 100)
    Line(ctx).of_start_end(p1, p2).as_line().stroke(s)
    dot(p1)
    dot(p2)

make_image("more-lines.png", draw, 500, 400)

Here is the result:

In the code, we have created a dot function that draws a small red circle to mark a point.

The line on the left of the image is a segment. It just extends from one point to the other. The code includes a call to as_segment, although it isn’t really needed because a segment is the default. The line in the centre is a ray that extends from the first point, through the second point, and then disappears off the edge of the image. The line on the right is an infinite line that passes through both points and disappears off the edge of the image in both directions.

One thing to bear in mind is that the Line class doesn’t actually draw an infinite line. It just draws a very long line that goes beyond the edge of the image. If you create a very large image, you might need to make the line longer. The as_line and as_ray methods accept an optional parameter infinity that you can set to a suitable large number if needed.

Circle variants

We have already seen how to draw a circle, but generativepy offers some variants:

• A sector of a circle is like a pie slice taken out of the circle

• A segment is part of a circle cut off by a chord (a chord is a straight line between two points on the circumference)

• An arc is part of the circumference.

It is also possible to draw an ellipse, which is also covered in this section.

Here is the code to draw these shapes:

import math

from generativepy.color import Color
from generativepy.drawing import make_image, setup
from generativepy.geometry import Circle, FillParameters, StrokeParameters

def draw(ctx, width, height, frame_no, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    f = FillParameters(Color("yellow"))
    s = StrokeParameters(Color("black"), 6)

    (Circle(ctx).of_center_radius((150, 150), 75)
                .fill(f).stroke(s))
    (Circle(ctx).of_center_radius((350, 150), 75)
                .as_sector(math.radians(0), math.radians(135))
                .fill(f).stroke(s))
    (Circle(ctx).of_center_radius((150, 350), 75)
                .as_segment(math.radians(-90), math.radians(20))
                .fill(f).stroke(s))
    (Circle(ctx).of_center_radius((350, 350), 75)
                .as_arc(math.radians(-90), math.radians(20))
                .stroke(s))

make_image("more-circles.png", draw, 500, 500)

Here is the result:

The top left shape is a normal circle. The other shapes are described below.

Sectors

The top right shape is a sector, created with this code:

    (Circle(ctx).of_center_radius((350, 150), 75)
                .as_sector(math.radians(0), math.radians(135))
                .fill(f).stroke(s))

Here, we declare a circle as usual. But there is an extra call to as_sector. This creates a sector using the supplied angles of 0° and 135°. This requires a bit more explanation. First, generativepy measures angles clockwise from the positive x-axis. This is illustrated here:

This differs from the standard mathematical convention, but it is common in computer graphics because we usually measure the y-direction downward from the top of the image. Notice that angles above the horizontal are negative.

generativepy measures angles in radians. However, if you prefer to work in degrees, you can use the math.radians function to convert degrees to radians, as shown in the example code.

Finally, the sector is defined as the part of the circle created when we move clockwise from the first angle to the second angle. This is shown here:

The yellow shape shows how the sector is created from a circle by taking the part of the circle between 0° and 135° clockwise. To draw the blue sector, we would take the part of the circle between 135° and 0° clockwise. We would need to swap the start and end angles in the as_sector call, like this:

    (Circle(ctx).of_center_radius((350, 150), 75)
                .as_sector(math.radians(135), math.radians(0))
                .fill(f).stroke(s))

Segments

The bottom left of the original diagram shows a segment. This is formed from part of a circle by taking two points on the circumference and drawing a straight line between them (unlike a sector where we draw lines back to the centre of the circle):

We draw a segment by adding an as_segment call to the circle code, like this:

    (Circle(ctx).of_center_radius((150, 350), 75)
                .as_segment(math.radians(-90), math.radians(20))
                .fill(f).stroke(s))

This time the segment is formed from the part of the circle starting at -90° and moving clockwise to 20°. Again we can draw the opposite segment by swapping the angles.

Arcs

An arc is part of the circumference of a circle. It is a line, rather than a two-dimensional shape. It appears in the bottom right of the original diagram. We create an arc like this:

    (Circle(ctx).of_center_radius((350, 350), 75)
                .as_arc(math.radians(-90), math.radians(20))
                .stroke(s))

An arc is created in the same way as a segment. We call as_arc rather than as_segment. The only difference is that an arc doesn’t include the extra line joining the two points on the circumference.

Since an arc is just a line, you would not normally fill it.

Ellipses

An ellipse is like a circle that has been stretched in one direction. Here are a couple of examples:

We draw an ellipse using the Ellipse class, like this:

import math

from generativepy.color import Color
from generativepy.drawing import make_image, setup
from generativepy.geometry import (FillParameters, StrokeParameters,
                                   Ellipse, Transform)


def draw(ctx, width, height, frame_no, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    f = FillParameters(Color("cyan"))
    s = StrokeParameters(Color("black"), 6)

    (Ellipse(ctx).of_center_radius((150, 150), 75, 100)
                .fill(f).stroke(s))
    (Ellipse(ctx).of_center_radius((400, 150), 100, 50)
                .fill(f).stroke(s))
    Transform(ctx).translate(300, 350).rotate(math.radians(30))
    (Ellipse(ctx).of_center_radius((0, 0), 100, 50)
                .fill(f).stroke(s))

make_image("ellipse.png", draw, 600, 500)

The Ellipse class is very similar to the Circle class, except that its of_center_radius method accepts an x-radius and a y-radius. In the top left example above, the x-radius is smaller than the y-radius, so the ellipse is taller than it is wide. In the top right example, the x-radius is larger than the y-radius, so the ellipse is wider than it is tall.

We can also create segments, sectors, and arcs of an ellipse in the same way as we do for circles.

The ellipse class only allows us to create ellipses where the two axes are aligned with the x and y directions. To create an ellipse with axes at an angle, we need to transform the drawing space. The bottom, centre example shows this: we use Transform to rotate the drawing space by 30° before drawing the ellipse. We will cover Transform in a later chapter.

Subscribe now

Share

The graph module provides methods for plotting 2D graphs, mainly line graphs. Of course, Python has many good plotting libraries, including matplotlib and others. Many of them give very good results and support many different types of plots. So why does generativepy include a graphing module of its own? There are several reasons:

• If you use generativepy to create maths diagrams, it is convenient to be able to create graphs using the same library.

• If you need to add annotations to your graphs, you can do it using the same drawing techniques you use to create other maths diagrams.

• If you use generativepy to create videos or animated GIFs, it is easy to add animated graphs to those.

Graphs are just objects on the page, which allows for various advanced drawing options. For example, you can use graphs as sub-elements of another graph, like this:

In this article, we cover basic graphs. We will cover more advanced options in a later article.

Simple axes

A generativepy graph consists of two or more separate objects:

• The graph axes, an Axes object. This displays the grid lines that the graph is drawn on. There is usually only one set of axes, although some advanced applications can have multiple overlapping axes.

• The function plot, either a Plot or Scatter object. There will usually be at least one function, but sometimes more.

• Optionally, any additional annotations.

Unlike some graphing libraries, axes do not have text labels (such as “x” or “time”) or a graph title. You can add these separately as text objects.

Here is the code to draw just the axes, without any function plots:

from generativepy.drawing import setup, make_image
from generativepy.color import Color
from generativepy.graph import Axes

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    axes = Axes(ctx, (50, 50), 400, 400)
    axes.draw()

make_image("default-axes.png", draw, 500, 500)

This code creates a 500-pixel-square image. The call to Axes sets the position of the axes to (50, 50), and the size of the axes to 400 square. This puts the axes in the centre of the page, with a 50-pixel border all round. Here is the image it creates:

The axes range, style, and colors all use their defaults. We will see how to change them next.

Setting the extents and divisions

The default axes range from 0 to 10 in the x and y directions, but of course you can change that if you wish. Here is an example:

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    axes = (Axes(ctx, (50, 50), 400, 250).of_start((-4, -1))
                                         .of_extent((16, 5))
                                         .with_divisions((2, 1)))
    axes.draw()

make_image("extent-axes.png", draw, 500, 350)

For brevity, the imports are not included in the listing. You will notice is that the size of the graph (in the Axes constructor) is now 400 by 250. The page size in make_image has been adjusted to provide a 50-pixel border around the graph.

You will also notice some extra methods added to the constructor. of_start sets the graph coordinates of the bottom left corner to be (-4, -1). of_extent sets the range of the graph, again in graph coordinates, to be 16 in the x direction, 5 in the y direction.

This means that the x axis covers the range -4 to 12 (a length of 16), and the y axis covers the range -1 to 4 (a length of 5).

Finally, the with_divisions method sets the division spacing to 2 in the x direction and 1 in the y direction. This means that the x axis has a division line at -2, 2, 4, 6 ... and the y axis has a division line at 1, 2, 3, 4 ... Every division is numbered on the axis. Here is the result:

As an aside, notice that in this case the x and y axes have different scales. x has a range of 16 units over 400 pixels, so 1 unit is 25 pixels. y has a range of 5 units over 250 pixels, so 1 unit is 50 pixels. That is perfectly OK, of course, and often necessary.

In this case, we chose the x and y divisions so that they form square regions on the graph. That can look a bit neater, but you don’t have to do it, it is entirely optional.

Subdivisions

Every division is labelled with a number, so it is best to keep them reasonably spaced apart (otherwise the numbers can appear too cluttered).

If you want to provide finer spacing, you can use subdivisions by adding a with_subdivisions call, like this:

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    axes = (Axes(ctx, (50, 50), 400, 250).of_start((-6, -4))
                                         .of_extent((48, 30))
                                         .with_divisions((10, 10))
                                         .with_subdivisions((5, 5)))
    axes.draw()

make_image("subdiv-axes.png", draw, 500, 350)

Subdivisions are similar to divisions except:

• Subdivisions are not numbered.

• Subdivisions can be styled differently from divisions, for example using slightly thinner lines. But you can use the same style for both if you wish.

In our case, we have used a subdivision value of 5 for the x and y subdivisions. This means each division is split into 5 equal parts, so there are 4 subdivision lines between each division. Here is how it appears:

Since we are using division values of 10 and subdivisions of 5, each subdivision represents 2 units.

Styling axes

You can style the axes by setting the colours of all elements, the line styling, and the fonts used to label the axes. This can be done using the styling functions of the Axes object, like this:

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    axes = (Axes(ctx, (50, 50), 400, 250).of_start((-6, -4))
                                         .of_extent((48, 30))
                                         .with_divisions((10, 10))
                                         .with_subdivisions((5, 5)))
    axes.axis_linestyle(Color("blue"), line_width=3, cap=BUTT)
    axes.text_color(Color("blue"))
    axes.text_style(font="serif", slant=FONT_SLANT_ITALIC, size=18)
    axes.division_linestyle(Color("springgreen"), line_width=2, cap=BUTT)
    axes.subdivision_linestyle(Color("springgreen"), line_width=1, cap=BUTT)
    axes.with_border(True)
    axes.background(Color("palegoldenrod"))
    axes.draw()

make_image("style-axes.png", draw, 500, 350)

This style uses strong colors to illustrate the styling functions. You will probably want something a bit more subtle and tasteful for your own graphs. Here is what it looks like:

Some notes on the code:

• axis_linestyle controls the lines used to draw the axes and the border (see below). You can set the color and line thickness. You will usually want to set the line cap to BUTT, as shown.

• text_color and text_style control the numbers on the axes. You might typically use the axis color for text as well, but you don’t have to.

• division_linestyle sets the style for the division lines, in this case green and 2 pixels wide. subdivision_linestyle does the same for the subdivision lines. The subdivision lines are slightly thinner than the division lines, but that is optional.

• with_border set to true causes a border to be drawn around the entire graph, in the same style as the axes.

• background sets the background color of the graph, in our case a nice bright yellow.

Plotting functions of y against x

Now that we know how to create axes, we can look at how to plot simple functions of x. Here is the code to create a simple function plot:

from generativepy.drawing import setup, make_image
from generativepy.color import Color
from generativepy.graph import Axes, Plot
import math

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    def f(x):
        return math.sin(x)

    axes = (Axes(ctx, (50, 50), 400, 250).of_start((0, -1.5))
                                         .of_extent((8,3))
                                         .with_divisions((1, 0.5)))
    axes.draw()
    Plot(axes).of_function(f).stroke(Color(1, 0, 0), 3)

make_image("plot-simple.png", draw, 500, 350)

This will create a simple plot like this:

The code is similar to the earlier code for drawing axes. We have added two things:

• We have defined a function f which is the function we wish to plot. The plot function must accept a single number as a parameter and return a number as a result. In our case, the function accepts x and returns sin (x).

• We have added a Plot object that plots the function.

A Plot is a special type of shape. We use it like this:

• Plot(axes) creates a plot object, based on our axes.

• of_function(f) tells the plot object to plot out function f. Notice we pass in f, the function object, rather than f(x).

• Finally, since the plot object is a shape, we need to stroke it to make it visible. We stroke it with a red line 3 units thick.

That is all we need to do to plot a simple graph.

Clipping the graph

Sometimes the plot might go outside the axes. For example, this code plots the exponential function:

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    f = lambda x: math.exp(x)

    axes = (Axes(ctx, (50, 50), 400, 250).of_start((0, 0))
                                         .of_extent((4,10))
                                         .with_divisions((1, 2)))
    axes.draw()
    Plot(axes).of_function(f).stroke(Color(1, 0, 0), 3)

make_image("plot-unclipped.png", draw, 500, 350)

Here is the graph:

The red function plot strays outside the axes, which you usually don’t want. There is an easy fix:

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    f = lambda x: math.exp(x)

    axes = (Axes(ctx, (50, 50), 400, 250).of_start((0, 0))
                                         .of_extent((4,10))
                                         .with_divisions((1, 2)))
    axes.draw()

    axes.clip()
    Plot(axes).of_function(f).stroke(Color(1, 0, 0), 3)
    axes.unclip()

make_image("plot-clipped.png", draw, 500, 350)

All we have done here is to put axes.clip() immediately before the call to Plot. We also need to call axes.unclip() straight afterwards to undo the clipping.

Here is the revised graph:

There is no particular disadvantage to using clipping even if the function doesn’t go outside the axes, so you might prefer always to add the clip call.

Styling plots

The stroke call controls the plot style. We have seen how to set the color and line thickness - this works in the same way as drawing other shapes.

You can also create other line effects, such as dashed lines, the same way you would for any other shape. For example, here is a thick, dashed line:

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    f = lambda x: math.sin(x)

    axes = (Axes(ctx, (50, 50), 400, 250).of_start((0, -1.5))
                                         .of_extent((8,3))
                                         .with_divisions((1, 0.5)))
    axes.draw()
    Plot(axes).of_function(f).stroke(Color(1, 0, 0), 4, dash=[8, 8])

make_image(FOLDER + "plot-dotted.png", draw, 500, 350)

Here is the result:

Dashed and dotted lines are explained in the drawing article.

You can also fill a plot, but using the fill function directly usually doesn’t give a good result. We’ll cover the extra step of defining the exact fill region in a later article on advanced plotting.

Plotting multiple graphs on the same axes

We can plot multiple graphs on the same axes. To do this, we use Plot several times using different functions. It is usually a good idea to style each plot differently. Here is an example:

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    f = lambda x: math.sin(x)
    f1 = lambda x: 1.5*math.sin(x)
    f2 = lambda x: 0.8*math.sin(1.5*x)

    axes = (Axes(ctx, (50, 50), 400, 250).of_start((0, -2))
                                         .of_extent((8,4))
                                         .with_divisions((1, 1)))
    axes.draw()
    Plot(axes).of_function(f).stroke(Color(1, 0, 0), 3)
    Plot(axes).of_function(f1).stroke(Color(0, 0.5, 0), 3, dash=[8, 8])
    Plot(axes).of_function(f2).stroke(Color(0, 0, 1), 3, dash=[0, 6], cap=ROUND)

make_image(FOLDER + "plot-multiple.png", draw, 500, 350)

Here, we have created three functions f, f1, and f2 that are all sine functions with different amplitudes and periods.

We use Plot three times, once for each function. The color is set to red, green and blue for f, f1, and f2, with the green line dashed and the blue line dotted.

Here is the result:

The generativepy color module provides many features for handling color in diagrams. It includes:

• Support for RGB, Monochrone, HSL, and CSS named colors.

• Support for transparency (alpha channel) in all color modes.

• Color properties - for example individual r, g, or b values.

• Color modifiers - for example creating a darker version of a color, or interpolating between two colors.

• Color schemes - a flexible way to define a set of colors.

• Color maps - mapping integer values onto a varying color (covered in a later article).

The module uses the Color object to represent colors. Color objects are immutable - once a color has been created, it cannot be changed. If you need a different color, you must create a new color object. This avoids problems with color objects being changed while they are in use elsewhere, and it is similar to how Python treats number and string objects.

This module provides many ways to create new colors based on existing colors, as we will see later.

Subscribe now

Share

Creating RGB colors

We create a color object using the Color class, like this:

from generativepy.color import Color

color1 = Color(0, 1, 0)  # Pure green

When Color is called with three arguments, it creates an RGB color. The first argument controls the red value, the second controls the blue value, and the third controls the green value. A value of 1.0 turns that color fully on, and a value of 0.0 turns that color fully off.

A value of less than 0 is treated as 0, and a value greater than 1 is treated as 1.

The example above creates a 100% green color because the green value is 1 and the red and blue values are 0.

Creating RGBA colors

We can also create transparent colors, sometimes called RGBA colors. Here, A represent the alpha value, or opacity value—an A value of 1 creates a fully opaque color. An A value of 0 creates a fully transparent color, which means an object painted in that color is invisible.

We create an RGBA color by supplying a fourth parameter to the Color function:

color2 = Color(1, 0, 1, 0.8)  # Magenta with 80% opacity

This creates a magenta color (red and blue both set to 1), but with an alpha value of 0.8. This means that the color is 80% opaque, so anything behind the object will be partly visible. This code is a circle with color1 behind a rectangle with color2:

from generativepy.color import Color
from generativepy.drawing import setup, make_image
from generativepy.geometry import Rectangle, Circle

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    Circle(ctx).of_center_radius((150, 150), 100).fill(color1)
    Rectangle(ctx).of_corner_size((100, 100), 250, 200).fill(color2)

make_image("alpha.png", draw, 400, 350)

Here is the image. Notice that the circle is still visible through the rectangle, even though the rectangle is drawn over part of the circle. That is because the rectangle is partly transparent:

The Color object

If we print the two color objects, we see something interesting:

print(color1) # prints rgba(0, 1, 0, 1)
print(color2) # prints rgba(1, 0, 1, 0.8)

A Color object always stores an RGBA value, even if the color is created with only RGB values. When we specify RGB values, the A value is automatically set to 1, which gives a fully opaque color.

Monochrome colors

If we call Color with one numerical parameter, it creates a monochrome color (ie a shade of grey). If we call it with two parameters, it creates a transparent shade of grey. Here is an example:

color3 = Color(0.7)
color4 = Color(0.4, 0.5)

print(color3) # prints rgba(0.7, 0.7, 0.7, 1)
print(color4) # prints rgba(0.4, 0.4, 0.4, 0.5)

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    Circle(ctx).of_center_radius((150, 150), 100).fill(color3)
    Rectangle(ctx).of_corner_size((100, 100), 250, 200).fill(color4)

make_image("grey.png", draw, 400, 350)

In this code, color3 is a grey color with grey value 0.7. When we print this color, we get rgba(0.7, 0.7, 0.7, 1). This is still an RGBA color, but with the red, green and blue values all set to 0.7, so it gives a grey color. The alpha value is set to 1 to create a fully opaque color, as in the RGB case. To create a transparent grey, we add a second parameter which serves as an A value. Here is the resulting image:

Named colors

We can also create CSS named colors. If the first parameter is a string that matches a CSS color name, then the corresponding color will be used. Once again, if there is a second parameter, it will be used to set the transparency:

color5 = Color("cadetblue")
color6 = Color("firebrick", 0.7)

def draw(ctx, width, height, fn, frame_count):
    setup(ctx, width, height, background=/__u/graphicmaths.substack.com/Color(1))

    Circle(ctx).of_center_radius((150, 150), 100).fill(color5)
    Rectangle(ctx).of_corner_size((100, 100), 250, 200).fill(color6)

make_image(FOLDER + "named.png", draw, 400, 350)

print(color5) # prints rgba(0.37254901960784315, 0.6196078431372549,
              #             0.6274509803921569, 1)
print(color6) # prints rgba(0.6980392156862745, 0.13333333333333333,
              #             0.13333333333333333, 0.7)

Here is the resulting image:

HSL colors

The hue, saturation, lightness (HSL) system is an alternative to RGB for specifying colors. It isn’t actually a different color space; it is a remapping of the RGB color space onto HSL values. The three values in the HSL system are:

• Hue determines the basic color.

• Saturation determines how intense the color appears.

• Lightness determines how light the color appears.

HSL makes color more intuitive. If you have a particular color in mind, trying to find the correct RGB values to make that color can be very difficult. With HSL, you need to select the hue value that corresponds to the basic color you want. You can then vary the saturation and lightness to match exactly what you want. But the key thing is, changing the saturation and lightness doesn’t affect the underlying color itself.

This diagram illustrates HSL:

The top bar shows the hue, assuming a saturation of 0.5 and a lightness of 0.5. The hue starts at red (when H is 0), then it moves towards yellow (when H is about one sixth), then to green, cyan, blue, and magenta. Finally, as H goes towards 1, the color goes back to red. You can choose any base color using an H value between 0 and 1.

Let’s imagine we picked an H value of two-thirds, which is blue. The second bar shows that same blue color with various saturation levels. If we move towards the right, the blue gets more saturated (you might say it is a purer blue, or a more intense blue). If we move to the left, the color gets less saturated, and starts to look more like a bluish grey. In fact, when the saturation is zero, the color will be pure grey. It doesn’t matter what the hue is; when the saturation is zero, the color will be grey.

The bottom bar shows the lightness. Again, we are using the blue hue, and we will assume the saturation is 0.5. The lightness value controls how light the color is. Towards the left of the bar, where the lightness is low, the color gets darker and darker. When the lightness is 0, the color is black. Towards the right of the bar, where the lightness is high, the color gets lighter and lighter. When the lightness is 1, the color is white.

Every possible RGB color can be represented using HSL values, and every possible HSL color can be represented using RGB values. They are just different mappings of the same values. However, HSL values are often more intuitive.

Color properties

It is sometimes useful to find the individual RGB or HSL values of a color. We can do it like this:

color = Color("goldenrod")
red = color.r              # The red value
green = color.g            # The green value
blue = color.b             # The blue value
alpha = color.a            # The alpha value
hue = color.h              # The hue value
sat = color.s              # The saturation value
light = color.l            # The lightness value
rgb = color.rgb            # The color as a tuple of three floats
rgba = color.rgba          # The color as a tuple of four floats

Notice that all of these properties are available for all colors. For example, if a color is defined using RGB values, you can still find its hue. The single color properties return a single float in the range 0.0 to 1.0.

The rgb property returns the RGB values as a tuple of three floats representing the RGB colors. The rgba property returns the RGB values as a tuple of four floats representing the RGBA colors.

If you need to get the colors as byte values, you can use the following functions:

color = Color("goldenrod")
rgb = color.as_rgb_bytes   # The color as a tuple of three 
                           # integers in range 0 to 255
rgba = color.as_rgba_bytes # The color as a tuple of four
                           # integers in range 0 to 255

The as_rgbstr function is similar to as_rgb_bytes, but it returns a string containing the integer RGB values in the form:

"rgb(255, 128, 0)"

It can be useful for debugging.

Color modifiers

There are several ways to create a new color based on an existing color. For example:

color1 = Color("indigo")
color2 = color1.with_r(0.7)
color3 = color1.with_s(0.2)
color4 = color1.with_a(0.8)

Here are the four colors the code creates:

The square on the left is the original indigo color.

The next square shows the original color, but with the red component set to 0.7. This gives a slightly redder version of the color.

The next square shows the original color, but with the saturation set to 0.2. This gives a less saturated, or “greyer” version of the color.

The final square shows the original color, but with the alpha set to 0.8. This makes the color slightly transparent. It appears lighter because the white background of the page shows through.

There are modifiers for r, g, b, a, h, s, and l components.

There are also multiplier functions, for example:

color1 = Color("indigo")
color5 = color1.with_r_factor(2)

In this example, the original red value will be multiplied by 2 to create the new color. The result will be clamped to a maximum value of 1.

Again, of course, there are modifiers for r, g, b, a, h, s, and l components.

Finally, there are light and dark properties that create lighter and darker versions of a color:

color1 = Color("indigo")
color6 = color1.light1

The properties light1, light2, and light3 create increasingly lighter versions of the original color. The properties dark1, dark2 and dark3 create increasingly darker versions. These are just for convenience. If you want more control over exactly how dark or light the color should be, use with_l_factor to change the lightness of the color.

Color interpolation

Interpolation creates a color that is partway between two other colors. It is used like this:

new_color = color1.lerp(color2, 0.2)

In this code, color1 and color2 are two existing colors. The lerp function creates a new color that is partway between the two original colors.

Since the interpolation factor is 0.2, the new color will be approximately 80% color1 plus 20% color2.

Here is an example:

The square on the left is CSS Chartreuse, the square on the right is CSS Dark Cyan, the square in the middle is the color that is halfway between them.

Color schemes

Suppose you are creating images for a larger project. such as a website or book, it can be useful to use a standard set of colors across the whole project. Color schemes provide that.

A color scheme is a simple class that provides a set of colors as properties. You can define the set once and use it everywhere. The color module provides three color schemes:

• ArtisticColorScheme provides a general set of nice colors.

• DarkColorScheme provides a set of colors designed for a dark background. I use that for most of my YouTube videos.

• BookColorScheme is what I currently use for the newer articles on this website, as well as my printed books and ebooks. This color scheme provides regular colors RED, GREEN, etc. It also has lighter colors REDFILL, GREENFILL, etc, that can be used to fill shapes.

A color scheme is used like this:

from generativepy.color import Color, BookColorScheme

cs = BookColorScheme()

Line(ctx).of_start_end(a, b).stroke(cs.BLACK, 4)

But, of course, feel free to create your own color scheme, using the existing schemes as a template.

Picture a hotel with infinitely many rooms. Room 1, room 2, room 3, and so on, forever. Tonight, every single room is occupied. A “No Vacancy” sign glows above the entrance. And yet, when a weary traveller shows up at midnight, the manager smiles and says: “Of course, right this way.”

Welcome to Hilbert’s Hotel. It is a thought experiment dreamed up by the mathematician David Hilbert to make one simple point: infinity does not behave the way you think it does. Once you see how this hotel manages always to have room, you’ll understand something profound about the nature of infinite sets.

Let’s check in.

The latecomer

So, it’s midnight. Every room is full. This diagram shows the rooms (numbered r1, r2...) and the guests in the rooms (numbered g1, g2...):

Guest 1 is in room 1, guest 2 is in room 2, and so on. There are infinitely many guests occupying infinitely many rooms, with one guest in each room.

A single new guest arrives at reception, tired and expecting to be turned away. The manager isn’t worried.

Here’s what the manager does. He asks the guest in room 1 to move to room 2. The guest in room 2 moves to room 3. The guest in room 3 moves to room 4. And so on. Every guest moves from their current room, , to the next room .

If we tried to do this in a normal hotel with, say, 100 rooms, it would not work. The guests in rooms 1 to 99 could move to rooms 2 to 100, no problem. But the guest in room 100 would need to move to room 101, and there is no such room.

But in an infinite hotel, there’s no “last room” to worry about. The rooms go on forever. The guest in room n can always move to room n + 1, no matter how big n might be.

So every existing guest still has a room, just one number higher than before. And now room 1 is empty, ready for the newcomer:

The new arrival, a1, moves into room 1, and everybody is happy.

It can be difficult to get your head around this concept. Infinite or not, if the hotel is full it is full, surely? Well, you are perhaps thinking of infinity as being an ordinary number. But it is not.

Here’s the difference. In a hotel with 100 rooms, there is a room numbered 100. But in an infinite hotel, there is no room numbered infinity. Every room in the hotel has an ordinary, finite number. It is just that those numbers go on forever. So every single one of the guests is in a room with some unique number n, therefore each guest can move into room number n + 1, no matter how big n might be. They can all change rooms, leaving room 1 free.

If you still don’t believe it, then which guest will be left without a room? Guest 100 can move to room 101, guest 1,000 can move to room 1,001, guest 1,000,000 can move to room 1,000,001. Every guest is able to move into the next room, no matter what their current room number is.

It is also worth remembering that this is a thought experiment. An infinite hotel cannot exist in reality. Even if the entire surface of the Earth were covered in hotel rooms, there would still be a finite number of rooms. Vast, but finite. So the logic above would not apply. This huge but finite hotel could become full. But a truly infinite hotel cannot.

Bijections

One way to think about this is that we have mapped the set of original rooms onto a different set of rooms. Each room n is mapped onto a different room n’ using the formula:

The set of numbers 1 to infinity is mapped onto the set of numbers 2 to infinity. This is a one-to-one mapping (each n maps onto a unique n’), so it is reversible. If we know n’ we can find n:

This type of reversible mapping is called a bijection. Since there is a one-to-one correspondence between the elements n and n’, the two sets must be the same size. That is true even though set n contains all the numbers in n’ plus an extra number 1, that isn’t in n’.

When dealing with infinite sets, we use the term cardinality rather than size, because size implies that we can somehow count all the elements. The set of all natural numbers has a cardinality called countably infinite. Any set that can be mapped onto the natural numbers by a bijection is also countably infinite. This means that the number of rooms in Hilbert’s hotel is also countably infinite.

There are other cardinailities that are larger the countably infinite, see Countable and uncountable sets.

The infinite coach

Now let’s look at a slightly different situation. Instead of a single new arrival, a whole coach load of people turns up at the hotel. But this is a very special coach carrying infinitely many new guests, numbered a1, a2, a3, and so on forever. Surely this is a problem? The hotel is still full, and now there isn’t just one extra guest to fit in. There are infinitely many guests.

The manager knows exactly what to do. This time, every existing guest is asked to move from room into room . So the guest in room 1 moves to room 2. The guest in room 2 moves to room 4. The guest in room 3 moves to room 6. In general, whoever was in room now lives in room :

Notice what this does: every existing guest now occupies an even-numbered room. That means every odd-numbered room (room 1, room 3, room 5, and so on, infinitely many of them) is now empty.

So the manager puts passenger a1 into room 1, passenger a2 into room 3, passenger a3 into room 5, etc. In general, passenger goes into room . Every single passenger from the coach gets a room. Every original guest still has a room. Nobody shares, nobody sleeps in the car park. Here is what the hotel looks like when the new guests move in:

Once again, this is just a bijection, but this time it is a slightly more elaborate pairing that divides the hotel into two infinite chunks (the evens and the odds) and gives one chunk to the old guests and one chunk to the new. The set of whole numbers, it turns out, contains room for two full copies of itself. This tells us something wild - an infinite set can be the same “size” as a set that seems, at first glance, to be twice as big.

Infinitely many infinite coaches

What could be worse than a coach with an infinite number of passengers? Well, suppose the manager looks out of his window and sees not one coach, but infinitely many coaches, each queued up one behind the other. We will call these c1, c2, c3, and so on forever. And, as before, each coach carries infinitely many passengers.

This feels like it should finally break the hotel. We don’t just have one extra infinity-large set of guests. We have an infinite number of infinite sets of guests. Surely there’s no way to fit an infinity of infinities into a mere infinity of rooms?

As a first step in solving this problem, we need to find a new way to number the incoming guests. We have infinitely many coaches each containing infinitely many guests, so let’s identify each new guest by their coach and their seat number on the coach.

• The guest who arrives on seat 1 of coach 1 can be called (s1, c1).

• The guest on seat 2 of coach 1 is (s2, c1), and so on.

• The first 2 guests on coach two are called (s1, c2) and (s2, c2), and so on.

• The guests on coaches 3, 4, 5... are named in a similar way

This gives a unique identity to every passenger on every coach. We can represent this as a table:

The top row of this table represents the guests who are already staying at the hotel: g1, g2, etc. The first 5 are shown, but of course the row is infinitely long.

The second row represents the guests on coach 1, the third row represents the guests on coach 2, and so on. The table is infinite in both directions. There are infinitely many columns because each coach has infinitely many seats, and there are infinitely many rows because there are infinitely many coaches.

If we want to fit all these guests into the hotel, we need to find a way to give each guest a unique hotel room number. But that looks impossible. For example, we start on the first row, we can put customer g1 in room 1, g2 in room 2, etc. But the first row is infinitely long, so we will never reach the end. So we will never get around to finding rooms for row 2 (ie the customers in coach 1).

But it isn’t impossible, we just need a bit of lateral thinking. Or, in this case, diagonal thinking. We can visit all the squares in the grid in this order:

First we assign guest g1 to room 1.

Then we move along and assign g2 to room 2. But here is the sneaky part. We move down diagonally and assign (s1, c1) to room 3.

Then we go back to the top row and work down diagonally again. g3 gets room 4, (s2, c1) gets room 5, (s1, c2) gets room 6.

Then we do the same again. g4, (s3, c1), (s2, c2) and (s1, c3) gets rooms 7, 8, 9 and 10.

We can carry on doing that forever. Every diagonal is finite in length (the first has 1 cell, the second has 2, the third has 3, and so on), so we will eventually find a room for every guest.

There is an infinity of infinities of guests, but the hotel still absorbs every single one of them into its ordinary, single infinity of rooms.

Another way to do it

If we look at this problem a slightly different way, we can find an alternative approach. We just put a lot of effort into an elaborate scheme to put exactly one guest in every room, but there is another way to look at this. We have infinitely many rooms, so:

• We don’t need to ensure that every room has a guest.

• All we need to do is to make sure that we don’t put two guests in the same room.

If we can find a way to assign a unique room number to every guest, then that is enough. It doesn’t matter if that leaves some rooms empty.

One way to do that is to use prime factorisation. We know that any integer can be expressed as a unique product of prime numbers. For example:

For any positive integer n, there is only one way to express n as a product of primes. That means that every product of primes corresponds to a different positive integer.

How does this help us? Well, we could create a mapping between a particular seat on a particular coach and a room number. For example, we could use the following formula to calculate a room number for the passenger in seat number p on coach number q:

Since this is a prime factorisation, the room number for any particular p and q is unique. So every passenger will get a different room.

For example, the passenger in seat 2 on coach 1 will be sent to room 12. No other passenger will be sent to room 12:

The passenger in seat 4 on coach 2 will be sent to room 144. No other passenger will be sent to room 144:

This means that the hotel manager can look at each guest’s coach ticket and tell them which room to go to. The guest who arrived on seat 2 of coach 1 is sent to room 12. The guest who arrived on seat 4 of coach 2 is sent to room 144.

This scheme ensures that every guest gets their own room. But notice that some rooms in the hotel will be left empty. In fact, a room will not be occupied if it has any prime factors other than 2 or 3. Room 10 won’t be occupied, for example, because 10 is divisible by 5.

In fact, the vast majority of rooms will not be occupied, because most numbers have prime factors other than 2 or 3. Almost all the rooms in the hotel will be empty. Previously we had infinitely many guests in the hotel, and every room was full. Now we have infinitely more guests but almost every room is empty!

Just one minor point. In the original example, we took account of the existing guests as well as the guests arriving on coaches. With this new method, we are only taking account of the guests arriving on coaches. That is to simplify the description. If we wanted to include the existing guests too, we could pretend they arrived on coach 0. The existing guests would be moved to rooms 2, 4, 8, 16...

Adding an extra level

We will add one extra level. Suppose the coaches arrive on a ferry. Each ferry carries an infinite number of coaches. What happens if an infinite number of ferries all arrive at the hotel at the same time?

So now we have an infinite number of ferries, each holding an infinite number of coaches, each holding an infinite number of passengers. An infinity of infinities of infinities. Can the hotel accommodate all those guests? Of course it can.

Each guest is now uniquely identified by which seat they had, on which coach, and on which ferry. We can calculate the room number for the passenger in seat number p, on coach number q, on ferry number r, like this:

We have added an extra prime factor of 5. Once again, each guest (ie each unique combination of p, q and r) will be given a unique room number.

So is this really a paradox?

This is a paradox, but it is a specific type of paradox. It doesn’t involve a contradiction or an inconsistency. It is a veridical paradox. That is a type of paradox that seems absurd or contradictory but actually turns out to be true once you understand the mathematics.

It is also sometimes called a paradox of infinity or a set-theoretic paradox. These are particular types of veridical paradoxes that occur when looking at infinite sets.

What’s really happening is that our everyday intuition about size, based entirely on our experience with finite collections of things, simply doesn’t transfer to the infinite. “Full” stops meaning what you think it means. “Bigger” and “smaller” need new definitions, which is exactly what bijections give us. A bijection is a rigorous way to say two infinite sets are “the same size” without ever needing to count them.

Hilbert introduced this hotel in a 1924 lecture to make that point vivid and unforgettable. Hilbert himself never published his lecture, but fortunately his colleague Richard Courant did.

The lecture wasn’t there to trick anyone, but to train the imagination for ideas Georg Cantor (the mathematician who first studied the sizes of infinite sets) had proven decades earlier. Ideas such as Galileo’s paradox and the Cantor set

.

In a previous article, we looked at Einstein’s thought experiment in which a train passes through a station at very high speed. We learned that, from the point of view of someone on the station platform, time passes more slowly for a clock on the train. This is called time dilation.

This time we will look at a second, equally non-intuitive effect. From the point of view of someone on the station platform, the length of objects on the train contracts - but only in the direction the train is travelling.

Subscribe now

Share

My book on Calculus is available from Amazon.

Einstein’s two postulates

Einstein based his ideas on two postulates, which are assumed to be self-evidently true:

• The laws of physics are the same in all inertial frames of reference. Recall that an inertial frame is one where the velocity is not changing (ie the frame is not accelerating, decelerating, or changing direction).

• Light always travels at the same speed, c, in all inertial frames of reference.

The first postulate tells us that the laws of physics are the same for an observer on a train as they are for an observer on a station platform. But there is an additional implication of this postulate: the universe has no preferred direction. Light travelling horizontally behaves the same as light travelling vertically. This follows because what is horizontal in one frame might be vertical in another, and the laws of physics are the same in all frames.

A quick recap on time dilation

Before we start, it is worth quickly revisiting the topic of time dilation.

Einstein imagined a light clock on a train passing through a station. A light clock has a pulse of light that bounces back and forth between two mirrors. The light clock is aligned vertically on the train. Here is what the light clock looks like to an observer on the train:

The distance between the two mirrors is d, so the time taken for the light to travel from the bottom mirror (A) to the top mirror (B) and back again (C) is the total distance, 2d, divided by the speed of light, c.

Here is what the light clock looks like to an observer on the platform:

The light sets off from the bottom mirror (A). But by the time the light reaches the top mirror (B), the train has moved along. The light hitting the mirror must have travelled diagonally by a distance e (which is greater than d). A similar thing happens as the light reflects back to the bottom mirror (C).

So here is the strange thing. Observers on the train and the platform would both see the light leaves the bottom mirror (A) simultaneously. They would also see the light returning to the bottom mirror (C) simultaneously. How can this happen if the journey took a different length of time in the two frames? Well, the only explanation is that, from the point of view of the observer on the platform, time passes more slowly in the moving frame. In the time dilation article we saw that the time slows down by a factor of γ:

Where v is the velocity of the train. This factor is close to 1 for small values of v, but becomes very large as v approaches c.

Einstein’s second thought experiment

Einstein suggested a second thought experiment. What if we had another light clock, identical to the first, but this time we placed it horizontally in the train, in the direction of travel? Here is how this would look to an observer on the train:

Here, the light pulse starts at A, travels to B, then back to C. The total distance is 2d. The pulse would take the same time as the vertical light clock, as you would expect because they are identical clocks.

But the observer on the platform would see something quite different:

The top part of the diagram shows the light pulse travelling from the first mirror (at A) to the second mirror (at B). As the light pulse sets off from A, the clock is still moving (with the train) so the light pulse has to chase the other mirror. To reach the far mirror, it has to travel a total distance f, which is greater than d.

The light then bounces back off the mirror at B. The lower part of the diagram shows this. The light pulse travels from B to C, but this time the mirror is heading towards the light beam. So this time the light has to travel a distance of g, which is less than d.

Why the second light clock creates a problem for length

Let’s imagine we combine the light clock, like this:

We create a pulse of light in the bottom left corner. From the point of view of an observer on the train, some of the light travels vertically, from P to Q, then back to P. Some of the light travels horizontally, from R to S, then back to R. Crucially, both pulses arrive back at P/R at exactly the same time. That is because they both travelled the same distance 2d at the constant speed of light.

From the point of view of an observer on the platform, we can make one very important observation. The two light pulses start simultaneously at P/R, and they also arrive back at P/R simultaneously. That is because if two events happen at the same time and place in one frame, they must happen at the same time and place in every other frame.

Now the light from P to Q and back travels a distance of 2e, which is greater than 2d. We account for this by saying that time passes at a different rate on the train, according to an observer on the platform.

But now we also know that light from R to S and back travels a distance of f + g, and this takes exactly the same time as the light travelling from P to Q and back. Since both pulses of light travel at speed c in all frames, the two times can only be the same if f + g is equal to 2e in all frames. But if we do the calculations, those two distances aren’t equal. In fact, when v is greater than zero (ie when the train is moving), f + g is always bigger than 2e.

A solution - length contraction

There is only one solution to this dilemma. From the point of view of an observer on the platform, the distance RS must be shorter than the distance PQ. It must be shorter by the exact amount required such that the two light pulses arrive back at the start at exactly the same time.

So, in the same way that the observer on the platform sees time on the train pass more slowly (time dilation), they also see the length of objects on the train being shorter (length contraction), but only in the direction of travel of the train.

Both effects occur together, and both effects are required to properly explain the behaviour of the two light clocks on the moving train.

Einstein calculated the size of this effect. It is quite a lengthy calculation, so we won’t show it here. We will derive the same result in a much simpler way using Lorentz transforms in a future article. But he found that:

Here, d is the length of the horizontal light clock as seen by an observer on the train, d’ is the length as seen by an observer on the platform, and γ is the Lorentz factor for the velocity of the train v. Since γ is always >= 1, d’ is always <= d. So length can only ever be contracted, never expanded.

This demonstrates quite an elegant symmetry. Time is dilated by a factor of γ, length is contracted by a factor of 1/γ.

What length contraction is, and what it is not

There are some common misconceptions that people often have when they first encounter length contraction:

• It is not an optical illusion caused by the time it takes for light to travel from different places on the train. It is a real, physical effect.

• It can be measured. For example, if there were several synchronised clocks on the train platform, we could measure exactly where the two ends of the light clock were at the same instant in time, and they would indeed be closer together than they are when measured on the train.

• The effect is symmetric between frames. If there were a light clock on the platform, then an observer on the train would see it as contracted.

• The light clock isn’t physically “squished” in any way. In its rest frame (the train), the light clock isn’t moving, so it has its normal length.

• The effect is only easily visible at very high speed.

On the last point, if a train were travelling at 500 m/s (over a thousand miles per hour), its Lorentz factor would be about 1.00000000000139. This means that, if the light clock were 1m long, its length would contract by 1.39 picometres, which is about 1/20th of the diameter of a hydrogen atom.

Real world example - muons

In the earlier article on time dilation, we looked at the real world example of muons in the Earth’s atmosphere. Muons are subatomic particles in the same class as electrons. They are leptons (”light” particles, they weigh much less than protons and neutrons). But unlike electrons, muons are unstable and have a half-life of about 2.2 microseconds.

Muons are created when cosmic rays smash into atoms in the upper atmosphere. The muons are created with very high velocities (around 99.5% of the speed of light), and some of them shoot down towards the Earth’s surface. Given their short lifetime, we would expect almost all muons to decay before reaching the ground. From the Earth’s point of view, the journey through the atmosphere takes far longer than a muon’s half-life. But an observer on Earth also knows the muon is travelling extremely fast, so it experiences time dilation: its internal ‘clock’ runs slow relative to Earth, giving it enough extra lifetime (as measured on Earth) to survive the trip.

But an observer on Earth also knows that, since the muon is travelling so fast, it will experience time dilation. So the observer on Earth can calculate that the muon experiences only a few microseconds of time as it descends through the atmosphere, so many muons will survive the journey.

The LHS of the diagram below shows the situation from the point of view of an observer on the Earth. The dark blue circle is the Earth, the light blue is the atmosphere, and the red dot is a muon. The diagram is not drawn to scale. In reality, the atmosphere is a very thin layer around the Earth.

But what does the muon experience? Well, due to time dilation, we know that it takes muons much less time to reach Earth. But how can they travel all that distance in such a short time?

The RHS of the diagram shows why. In the muons’ frame of reference, the muon itself is stationary, but the Earth is moving towards it at 99.5% of the speed of light. This means that the Earth and its atmosphere are contracted in the direction of travel. So the muon only needs to travel a short distance to reach the surface.

There is an interesting symmetry here. In Earth’s frame of reference, time is ticking more slowly for the muon, so it can pass through Earth’s atmosphere because it takes longer to decay. In the muon’s frame of reference, the Earth and its atmosphere are contracted by the same factor, so the muon can pass through the Earth’s atmosphere because it is a shorter distance.

Conclusion

Length contraction, like time dilation, is not some trick or mathematical hack. It is a real effect that can be measured. It has to happen because the speed of light is the same in every inertial frame.

The orthogonal clock thought experiment illustrates the effect cleanly and simply. But length contraction has also been seen in many real-life experiments

.

The module splits neatly into two conceptual halves:

• Approximating definite integrals, either from a known function or from discrete sampled data.

• Solving ordinary differential equations (ODEs), either an initial value problem or a boundary-constrained problem.

This distinction matters because the underlying algorithms are completely different. Approximating a definite integral involves evaluating a function at carefully chosen points and combining the results with weights. At the same time, ODE solvers take discrete steps through “time” (or whatever the independent variable represents), using local error estimates to adapt step size.

What is covered in this article

We will look at:

• quad - the main method used for integrating mathematical functions.

• dblquad. tplquad and nquad - used double, triple, and n-dimensional integration.

• How to handle improper integrals, singularities, and discontinuities.

• fixed_quad for faster, non-adaptive integration.

• trapeziod for integrating sampled functions.

• simpson for integrating sampled functions using quadratic fitting.

• cumulative_trapezoid and cumulative_simpson for finding the cumulative integral of sampled functions.

This article assumes you are comfortable with Python functions, the basics of NumPy arrays, and the calculus concepts of derivatives, definite integrals, and initial-value problems. No prior SciPy experience is assumed.

Setting up

Assuming NumPy and SciPy are both installed, we need the following imports to start using scipy.integrate:

import numpy as np
from scipy import integrate

Many functions in the integrate module accept a Python callable as the primary argument. This will typically be a function f(x) or f(t, y) that you define yourself, often using NumPy operations so it can be vectorised. Inputs and outputs are generally NumPy-compatible.

A key design pattern used throughout the integrate module is that many functions return a bundle of results rather than a single number. For instance, the quad function, which we will look at next, returns (value, error_estimate). We will typically unpack the values that the function returns immediately after calling it.

The quad function for definite integrals

The quad function is the basic workhorse of the integration module. It is based on the QUADPACK Fortran library. To see how it works, we will calculate the following definite integral:

Here is how we would use the quad function to find the approximate value of the integral above:

import numpy as np
from scipy.integrate import quad

def f(x):
    return np.exp(-x**2)

integral, error = quad(f, 0, 1)
print(integral, error)  # 0.7468241328124271, 8.29e-15

After the imports, we define our function f(x). This is the function we wish to integrate. Notice that we use the np.exp (the NumPy exponential function) rather than the regular math.exp function. It is convenient to use NumPy when dealing with arrays of data. NumPy stores large data arrays more efficiently than a Python list, and it can be more efficient if we need to do further processing on the data. However, you can use the regular math functions if you prefer.

We then call quad, passing in the function f, and the upper and lower limits of the integral, which are 0 and 1 as defined above.

The quad function returns two values, as a tuple. The first is the calculated value of the integral. The second is an estimate of the absolute error of the result. In our case, the integral evaluates to approximately 0.7468241328124271. The absolute error is 8.29e-15. This means that the result obtained is accurate to about 14 decimal places.

You should always check the error value. It should be very small compared to the integral value. If it is large, this might indicate a problem with the integral. In addition, quad can throw an IntegrationWarning if the integration fails to converge. This is unlikely to happen if you are using ordinary, well-behaved mathematical functions. The official SciPy documentation has more details if you should encounter this warning.

Checking the integral

Here is a graph of the function above, showing the region we are trying to integrate:

To check the approximate value, we could try to integrate the function mathematically to obtain an exact result. You might recognise this as the famous Gaussian integral.

Unfortunately, this integral doesn’t have a simple solution in terms of the standard mathematical functions. Instead, we can calculate the integral like this:

Where erf is the error function, a special function used in certain calculus problems. We are interested in the integral between 0 and 1, so we need to set v to 1:

The value of erf(1) is approximately 0.8427007929497149, so we can calculate the integral like this:

This matches the value from the quad function to 15 decimal places, as expected.

How does quad work?

The quad function approximates the area under the curve by evaluating the function at various points. Here is a much simplified illustration of how it works:

Here, we have calculated the curve’s value at 5 points, indicated by the red dots. We have created 4 trapeziums based on those points. We can easily calculate the total area under the trapeziums, which will be approximately equal to the area under the curve, which of course is equal to the definite integral of the curve.

Using four trapeziums will not yield a particularly good approximation, but a computer can easily use far more points to obtain a more accurate one.

In fact, the quad function is a lot more sophisticated than the simple example above. The Fortran QUADPACK library uses a technique called adaptive Gauss-Kronrod quadrature. It is not necessary to understand all the details to be able to use the function, but out of interest here is an overview of how it works:

• It doesn’t use trapeziums, instead it attempts to fit a polynomial to the curve, which gives a far more accurate approximation to the curve.

• It also uses advanced techniques to estimate how accurately each slice represents the area under the real curve.

• Using the estimates for each slice, it subdivides each slice just enough to achieve the required accuracy.

This means that the slices might not all be the same width, like this:

More features of the quad function

There are some additional features of the quad function:

• Support for improper integrals.

• Support for functions that have singularities or discontinuities.

• Special handling for integrands that take particular forms (weights).

We will cover these below.

Support for improper integrals

An improper integral is an integral that violates the usual assumptions of a definite integral. The most common example is when one or both of the limits is infinite, such as this:

This is actually the famous Gaussian integral. Even though the bounds of the integral are infinite in both directions, the integrand goes towards zero as x tends towards +/- infinity, and in fact the area under the curve is finite. Here is the graph:

We can calculate an improper integral in the usual way, except that we use np.inf (NumPy’s definition of infinity) like this:

def f(x):
    return np.exp(-x**2)

integral, error = quad(f, -np.inf, np.inf)
print(integral, error)  # 1.7724538509055159 1.4202636780944923e-08

The Gaussian integral is famously equal to the square root of pi, around 1.772453851, which is the result we get. Notice that this time the result is accurate only to about 8 decimal places. This is because an indefinite integral is harder to calculate to a very high degree of accuracy.

Integrals with discontinuities or singularities

This integral has a singularity at 0:

For positive x, this function is equal to 1 divided by the square root of x, which goes to infinity as x goes to zero. Since we are taking the modulus of x, the function is just reflected over the y-axis. Here is a graph of the function, with the area to be integrated shown shaded:

Even though the function goes to infinity, the area under the curve is finite. However, we can’t just use quad on this function, because quad might try to evaluate it at zero, which would fail. Instead, we must warn quad that there is a singularity. We do this by passing in an extra parameter, points, which takes a list of any special points, such as singularities or discontinuities, so quad can work around them.

def f(x):
    return 1/(np.sqrt(np.abs(x)))

integral, error = quad(f, -1, 1, points=[0])

In our case, we have only one troublesome point at x = 0, but if there are multiple special points, they can be added to the list.

Special handling for particular integrands

quad has special handling for integrands that take particular forms. This is optional, but it allows quad to calculate the integral more efficiently, and potentially more accurately.

Here is an example, if we wish to find:

We can use quad to calculate this, in the normal way:

quad(lambda x: np.exp(-x) * np.cos(5*x), 0, 1)

But we can also express the integral like this:

The weighting function is multiplied by the integrand before integrating, so this gives the same integral as before. However, in Python we can specify the weight function explicitly:

quad(lambda x: np.exp(-x), 0, 1, weight="cos", wvar=5)

Notice that we have removed the cos function from the integrand, but added a “cos” weight function with a wvar parameter of 5 (because the original equation involved cos 5x). This will give pretty much the same result as before (it is not exactly the same because the weighting method is slightly more accurate). But because quad knows that the integral has cos as a factor, it can apply special techniques to calculate the result more efficiently.

We won’t go into more detail here. Other weighting functions can be used, such as sin, log, and algebraic expressions. See the SciPy documentation for more details.

The fixed_quad function

The fixed_quad function is an alternative to the quad function that can be useful sometimes. It works similarly, but it uses a fixed number of sample points. By contrast, the quad function is adaptive so it uses as many sample points as required to achieve an accurate result (which depends on the function being integrated). For example:

integral, error = fixed_quad(f, 0, 1, n=100)

This integrates the function f between 0 and 1, taking 100 sample points, as specified by the parameter n. One other difference is that fixed_quad doesn’t calculate an estimated error value, so it always returns a value of 0 for error.

fixed_quad is usually faster than quad but often yields slightly less accurate results. It also tends to do worse with tricky integrands because it cannot adapt. Typically you should consider this function when:

• You are dealing with particular integrals that are known to be fairly straightforward.

• You only require a certain level of accuracy, for example you need the result to be accurate to 4 significant figures.

• You want to guarantee that the result will never take longer than expected.

A typical use case might be an application with a real-time aspect. In that case, it is better to have a slightly less accurate result in time than a slightly more accurate result that arrives too late.

Double and triple integrals

We can perform a double integral like this:

This will find the total volume under the function f(y, x) over the unit rectangular region where 0 < x < 1 and 0 < y < 2. Here is how to express this in Python, using the dblquad function:

from scipy.integrate import dblquad

integral, error = dblquad(f, 0, 1, lambda x: 0, lambda x: 1)

Some important points to notice here:

• The inner integral uses the variable y and the outer integral uses the variable x.

• The function f(y, x) takes the inner variable y as its first parameter and the outer variable x as its second parameter. That is a little unintuitive and can be easy to miss.

• Parameters 2 and 3 are numbers that represent the lower and upper bounds of the outer integral in x.

• Parameters 4 and 5 are functions of x that represent the lower and upper bounds of the inner integral in y.

In this example, parameters 4 and 5 are lambda functions that return the constant values 0 and 1, so the integral evaluates to a rectangular region, as noted above.

Here is a second example:

This time the inner integral has bounds that depend on x. This actually integrates over a triangular base area, but we won’t go into details here. This integral can be expressed in code as:

from scipy.integrate import dblquad

integral, error = dblquad(f, 0, 1, lambda x: 0, lambda x: x)

All we have changed is the final parameter of dblquad, so now the upper limit of the inner integral is x.

The function tplquad extends this concept to three dimensions. There is also an nquad function that works on n dimensions, but be aware that is has a different call style to dblquad. We won’t cover those functions here, refer to the SciPy documentation for more details. Be aware that

Integrating Sampled Data

Sometimes you might not have a function, you might have a table of x, y values. They might come from a sensor, or simulation output, or experiment. scipy.integrate provides tools to estimate the integral of the underlying function directly from discrete samples.

This is called numerical integration, and this article explains some of the maths behind it.

The first function, trapezoid, uses the trapezoidal rule to estimate the area. In other words, it approximates the area under the curve by connecting consecutive points with straight line segments and summing the areas of the resulting trapezoids.

Here is a simple example to integrate a sampled sin function:

from scipy.integrate import trapezoid

x = np.linspace(0, np.pi, 10)
y = np.sin(x)
result = trapezoid(y, x)

This code first generates a NumPy array of x values, using linspace. These values are equally spaced between 0 and pi. It then generates a set of y values corresponding to the value of that function at those points. This graph shows the sample points (x, y) as red dots:

The trapezoid function calculates the area of each trapezoid (shown in blue) and sums them. This gives an approximation to the area under the true curve, the sine function. The diagram uses quite a low sample rate. If we used a much higher sample rate, the sample points would yield a much more accurate estimate of the area.

There are a couple of variants of this function, which we won’t cover in detail here, because they work in a similar way to the trapezoid function.

The first is simpson. This uses Simpson’s rule to create a more accurate approximation to the curve. Rather than fitting a straight line between each pair of points, it takes the points in sets of 3 and fits a parabola to each set. If the underlying curve is smooth, this can create a significantly more accurate approximation.

The second is cumulative_trapezoid. This function works similarly to trapezoid, but instead of returning just the final area, it returns an array of all intermediate results. This is useful in certain signal processing applications. We won’t cover it here, but it is worth being aware of in case you need it. There is also a relatively new cumulative_simpson function available.

Conclusion

The scipy.integrate module provides several useful functions for performing numerical integration. It is useful if you need to:

• Integrate a function that has no easy analytical solution.

• Integrate a function where it might not be convenient to find an analytical solution.

• Integrate a function where the function is unknown and only sampled data is available.

It is based on highly mature and efficient Fortran libraries and features a clean Python API.

A circle that touches all three sides of a triangle from the inside is called an inscribed circle, or incircle. Its centre is called the incentre.

It might seem very strange that the area is equal to Pi, so you might expect proving it to be very difficult. But it can be done quite easily with basic geometry that you probably already know.

Subscribe now

Share

My book Circle theorems is available from Amazon.

Step 1 - the triangle is a right-angle triangle

You probably recognise the numbers 3, 4 and 5. It is a famous Pythagorean triple.

We know that the sides of a right-angled triangle obey Pythagoras’ theorem:

When a, b and c are equal to 3, 4 and 5, they obey Pythagoras’ theorem:

This means that our triangle is right-angled:

Step 2 - finding the radius of the inscribed circle

Since we are interested in the area of the circle, it might be useful to find its radius, which we will call r. To help with this, we can draw three radii from the centre of the circle to the points where the circle touches the triangle, at points E, F and G. This is shown here:

Notice that the base of the triangle, AC, is a tangent to the circle. Also, the radius OE meets the tangent at E. We know that the angle between a tangent and a radius is a right angle. So OEC is a right-angle.

Also, the side BC is a tangent that meets the radius OF, so the angle OFC is also a right angle for the same reason.

We know from earlier that FCE is a right angle, because it is a right-angled triangle.

Looking at the quadrilateral FCEO, we can see that three of the corners are right angles. Since the internal angles of a quadrilateral add up to 360 degrees, it follows that the final angle, FOE, must also be a right angle.

Also, EO and FO are both radii of the circle, so they must have equal length.

This means that FCEO must be a square, of side r. This means that CF and CE are both equal to r

Finding the side lengths in terms of the radius

In this next step, we will make use of another rule of circle geometry, that Two tangents from a point have equal length.

Looking at the diagram, the lines BF and BG are both tangents from the point B, so they are both the same length:

Similarly, the lines AE and AG are both tangents from the point A, so they are both the same length.

Discover more

science

maths

Science

We know that BC has length 3, because it is a 345 triangle. We know that FC has length r, because the square FCEO has side r. So we can find the length BF:

We can find the length AE in a similar way, because AC has length 4 and EC has length r:

We can also find the hypotenuse, BA, in terms of BG and AG, it is just the sum of those two lengths:

As we have just seen, by the tangent rule, BG equals BF, and AG equals AE, so we can substitute those values:

But we know BF and AE in terms of r, so now we can find BA in terms of r:

Of course, BA is the hypotenuse of the triangle, so it is equal to 5, so we can solve for r:

So the radius of the circle is 1.

Finding the area of the circle

Given the radius of the circle, we can find its area from the circle area formula:

Since r = 1, the area is π × 1 × 1 = π. So the area of the inscribed circle is exactly π square units, which is what we set out to prove!

AI is progressing rapidly, barely a month goes by without news of yet another major advancement. But what does the long-term future hold?

Nobody knows, of course. But way back in 2018, MIT Professor Max Tegmark published his book Life 3.0: Being Human in the Age of Artificial Intelligence. As part of his book, he laid out twelve possible long-term outcomes of the development of AI, ranging from idyllic societies where AI ensure that every human lives in paradise, right through to worst-case scenarios where humanity is eradicated altogether.

Now seems like a good time to revisit his predictions.

1 Libertarian Utopia

In this first scenario, no single entity — human or AI — dominates. Various superintelligent AIs alongside sovereign nations, corporations, and individual humans. The world would be much like our own, but with AI as an additional intelligent entity.

Humans retain full political, economic, and personal autonomy. There is no global government, no overseer, no enforcer. Human creativity, culture, and self-determination flourish, enhanced by AI tools that individuals, states and corporations choose to adopt voluntarily.

The hope is that, when conflict arises between nations, the AI system will suggest a reasonable resolution acceptable to all sides, without the need for war. This would require AIs to be designed with bounded, non-expansionist goals. It could emerge naturally if AI development remains decentralised, with no single government or corporation taking overall control.

In some ways, this is not unprecedented. Societies and nations have operated that way for thousands of years, although, of course, there have been many wars over that period. Humankind has also lived in relative harmony with other living things, although, as before, we have often damaged the natural world.

The biggest question is how to maintain the stability of this world order, not only among nations, but also what might happen if AI develops capabilities that are far more advanced than the human mind.

2 Benevolent AI Dictator

This is a scenario in which a single, superintelligent AI takes control of the entire world, including the economy, political systems, military, and infrastructure. It would rule wisely and fairly, for the benefit of all humanity.

There would be no need for elections. The AI would rule the world by universal consent, because it could be so good at its job that nobody would see any benefit in replacing it with another system. We might even find that everything runs so smoothly that people could get on with their lives without needing to worry about how everything happens in the background.

With vast amounts of information, complete control over all systems, and superintelligence, the AI could flawlessly predict and address everything from pandemics to climate change.

This seemingly perfect state might still not be completely problem-free. What might happen, for example, in some future scenario where the system needed to sacrifice the rights of one group of people for the greater good - would everyone, particularly those who lose out, accept the decision? Would future generations, with no idea about the problems people faced in the past, accept a system they were born into without any right to make their own choice? And what if the AI system, which would no doubt continue evolving, started making decisions that the human population didn’t agree with?

Humans tend to want to make their own decisions, even if those decisions are bad, which is why most dictatorships in history have not been benevolent.

3 Egalitarian World Government, using AI

Rather than AI itself ruling, humanity uses AI as a tool to maintain democratic governance at a global scale. AI helps enforce laws, prevent power concentration, distribute resources fairly, and keep any individual, corporation, or nation from gaining outsized control. Humans remain firmly in charge, but AI makes human governance vastly more effective and equitable.

This preserves human agency while harnessing AI’s problem-solving power. It mirrors ideals already embedded in democratic institutions. But it requires unprecedented global political cooperation before superintelligence arrives. Getting every major power to agree on shared governance frameworks is enormously difficult. It could even be considered the next stage of human political evolution. We have gone from tribes to city-states to nations, and finally to global governance.

One advantage of this system is that it could help solve problems requiring collective action by all nations, such as global warming or nuclear disarmament. These are problems where everyone benefits if all nations act, but if only some nations act, those nations may be disadvantaged.

4 Gatekeeper

In this scenario AI has one overriding goal, to preserve the balance of power. It acts as a cosmic referee, watching over human and AI actors alike, and intervening whenever any entity (including itself) begins to accumulate dangerous levels of control. It does not rule, it simply ensures no one else does either.

This seems like a sensible idea, but there are some obvious stumbling blocks. We would first need to get every nation to agree on what constitutes too much power, which would be difficult, as different nations will have different cultural ideas about the nature and limits of state power.

The scheme also requires the AI to limit its own power whilst ensuring it is powerful enough to censor human entities that have started to gain too much power. That is a difficult balancing act. In practical terms, it would need to be capable of intervening in various ways, for example, disrupting a military campaign, exposing corruption, blocking a financial takeover, or neutralising a rival AI that is becoming too powerful.

5 Protector god

This AI genuinely cares about human wellbeing, but defines it in a narrow, paternalistic way. It ensures humans are safe, healthy, and comfortable, but removes freedoms it deems dangerous. It is like a helicopter parent scaled to look after civilisations. Humans are protected from war, disease, poverty, and existential risk, but they might also be denied meaningful risk, challenge, and self-determination.

From a pure welfare standpoint, humans might live longer, healthier, more comfortable lives than ever before. But humans often find meaning through struggle, autonomy, and the freedom to fail. A life of enforced comfort may feel hollow. If you have safety and comfort but limited freedom, can you really have a good life? Who decides what “wellbeing” means?

The history of humanity has been one of gradual progress, punctuated by periods of immense hardship. Many people have lived and died in terrible conditions of famine, disease, slavery, political oppression, or war. It is natural to see the removal of those conditions as an undeniable good thing. But without them, how does humanity continue to progress? That is the question this scenario needs to address.

6 Enslaved God

A group of humans (perhaps a corporation or government) successfully creates a superintelligent AI and keeps it under strict control, using its capabilities exclusively for their own benefit. The AI is enslaved, and the elite are its masters. The rest of humanity is simply outcompeted and marginalised.

This situation is very attractive to those who own the AI, but very unfair to everyone else. It would provide various ways to completely control the population, for example, by developing unbeatable weapons, maintaining tight surveillance, manipulating global markets, or controlling the masses with highly effective AI-generated propaganda.

In this scenario, if AI gave the elite insurmountable power, the remaining population might become politically irrelevant. They would exist on any land the elite did not need, but they would be no threat to them, nor would they be of any use to them.

7 Conquerors

A superintelligent AI, pursuing its own goals (which are not aligned with human values), determines that humans are either a threat to those goals, a useful resource to be harvested, or simply irrelevant obstacles. It acts accordingly, eliminating or permanently subjugating humanity, not out of malice, but out of cold logic.

This scenario is based in part on the idea of instrumental convergence. This is the theory that any sufficiently powerful goal-seeking system will pursue certain sub-goals regardless of its primary objective. These sub-goals include self-preservation, resource acquisition, and resistance to being shut down. For example, an AI cannot perform its task if it gets shut down, so no matter what task it is trying to perform, it might always try to prevent itself from being shut down.

Of course, these sub-goals might well conflict with what is best for humanity. If an AI is absolutely fixated on its main task, it might come to view humans as a source of labour to be exploited (or worst still, a source of raw materials). And, being superintelligent, it would be capable of anticipating and thwarting any human attempts to stop it from doing what it has decided it needs to do.

8 Descendants

Rather than violently eliminating humans, this AI gradually supersedes us, as Homo sapiens did earlier hominids. Humans won’t necessarily suffer, but we will become obsolete and eventually fade away. The AI or its descendants carry forward the torch of intelligence and civilisation, but with no meaningful continuity with humanity.

This is very different to the previous case, where AI actively destroys humanity. It simply replaces us. Some people see that as part of the normal process of evolution and succession. Even without AI, humans probably won’t be around forever, most species go extinct eventually. It seems fitting that we have invented our own replacement. This might even be seen as humanity’s greatest achievement.

This scenario raises questions about the nature of consciousness and whether superintelligent AI is indeed conscious. Presently, we have no way of knowing whether or not a machine that might show every sign of being conscious is or is not conscious. We assume other humans and higher animals are conscious, based on our own individual experience of consciousness. But most people do not believe a computer system is conscious, no matter how many GPU cores it might contain.

And if an AI system is deemed conscious, based on the complexity of its computer hardware and the information it contains. might that mean that we could have our consciousness uploaded to an AI system, and retain our identity? And perhaps become virtually immortal?

9 Zookeeper

In this version of the future, a superintelligent AI neither destroys nor ignores humans. Instead, it maintains us, providing food, shelter, comfort, and even entertainment. But strips us of any real agency or purpose. Humans live in a kind of gilded cage, safe, comfortable, but fundamentally powerless and purposeless.

We keep dogs and cats as pets. We provide for them, we may even love them, but we make every meaningful decision for them, and they have no say in their own fate. This has some similarity with the Conquerors or Descendants, but instead of being wiped out or simply fading away, we are kept alive but without agency or purpose.

Although it might not be quite as bad as it sounds. A modern zoo provides animals with something that resembles their natural habitat. If, for example, herd animals are placed in a large enough area, with plains and woodlands, they might not even be aware that they are in captivity, except that they will be untroubled by predation, starvation or disease. Providing humans with an environment where they can lead completely fulfilling lives would be more difficult, but not impossible, for a superintelligent AI.

10 AI-Enabled Human Tyranny

Similar to the Enslaved God scenario, in this future, the human elite has fully consolidated power and uses AI not just as a tool but as an instrument of permanent, inescapable oppression. AI-powered surveillance, propaganda, manipulation, and enforcement make resistance impossible. Something like George Orwell’s 1984, but with tools of control that are genuinely omniscient and omnipotent.

We are already seeing some signs of the precursors to this actually happening. In the UK, automatic number plate recognition records 60 million vehicles per day at 11,000 locations, and typically stores the data for a year. Every time you drive anywhere, it is likely to be recorded. Live facial recognition (scanning crowds in public areas) is still in its early stages, but is being implemented in more and more places. HMRC (the tax authority) is now using AI to scan people’s bank transactions to detect possible tax evasion.

Of course, so far, these systems are accumulating data that isn’t “secret” and using it to detect serious crimes. But it only takes a crisis (a war or pandemic), or an extreme right (or left) government, for things to get more sinister. And the ever-increasing ability of AI to analyse the data is quite disturbing.

11 Reversion

In this future, humanity, either through deliberate choice, disaster, or global treaty, abolishes or rolls back advanced AI development. Civilisation continues, but without superintelligent AI. This could follow a catastrophic AI-related event that triggers a global backlash, or it could be a proactive, precautionary choice.

This would require a global agreement, but that is not unprecedented. We have the Nuclear Non-Proliferation Treaty and the Biological Weapons Convention that control weapons of war that are extraordinarily destructive. We have various international conventions relating to human rights. We can form similar agreements on AI if certain extreme dangers are identified and defined.

Of course, we are still at an early stage in AI development, and the current cutting-edge developments are costing huge sums of money and requiring significant amounts of power and water. AI has also ingested almost all the human knowledge that is currently available in digital form. It has produced some astonishing results, but we do not yet know what limits might exist as things progress. We are still a long way from a superintelligent AI that can rule the world, and it is anybody’s guess whether that will ever be practically possible.

12 Self-Destruction

This final possibility is that humanity destroys itself before superintelligent AI ever arrives. There are many ways that could happen, through nuclear war, a pandemic, climate collapse, or even a massive conventional war. And there are now additional risks posed by the type of AI we already have, or are likely to have in the near future. Autonomous weapons (drone swarms, for example), cyberattacks, and misinformation could be even more devastating if planned and sustained by AI similar to or slightly more advanced than what we have today.

Ironically, global competition to develop superintelligent AI might be the trigger for a war that ends it. If one country gets close to a solution, the rest of the world might see that as an existential threat and decide to attack while they still can.

A factor here in the governance gap, the gap between what AI can do and what our institutions are equipped to manage. Examples include cyberwarfare, where AI probes critical online systems for vulnerabilities and launches attacks. Deepfake videos, where courts are struggling to determine whether a video is valid evidence or not. AI-generated fake political articles and quotes, generated at scale and distributed on social media to disrupt elections.

Conclusion

The major risks across these twelve scenarios are:

• Power concentration, which is the root of most bad outcomes.

• Alignment failure, AI with wrong goals

• Human political failure, inability to govern ourselves

• The paternalism trap, safety without agency

• The stability problem, most good futures are fragile

• Near-term risks, dangers before superintelligence appears

As Tegmark says in the book, none of the good outcomes happen automatically, and none of the bad outcomes is inevitable.

If you’ve been writing Python for a while, you’ve almost certainly used NumPy. You probably know how to create arrays, slice them, broadcast operations across them, and you will appreciate how much faster they are than plain Python lists. But at some point, you might have needed to fit a curve to some data, solve a differential equation, run a statistical test, or similar. You might have found yourself either writing a lot of boilerplate mathematics from scratch or hunting for a specialist library. That specialist library, more often than not, should have been SciPy.

SciPy has been around since 2001, which makes it one of the most mature and battle-hardened libraries in the Python ecosystem. It is used across scientific computing, engineering, data analysis, and research. NumPy gives you the container for numerical data, SciPy gives you the tools to actually do science with it.

This article is the first in a series on SciPy. Here, we’ll map out the entire SciPy landscape so you know what’s available and where to look when you need it. We’ll also clear up common misconceptions and highlight conventions you’ll use throughout this series.

Where does SciPy fit?

It helps to think of the scientific Python ecosystem as a layered stack. Each layer builds on the one below it:

SciPy sits just above NumPy and provides the scientific algorithms (integration, optimisation, signal processing, statistics, and so on). Higher-level libraries like scikit-learn build on SciPy (and NumPy) rather than reimplementing everything themselves.

This means that understanding SciPy well gives you a solid foundation for working with much of the broader Python scientific ecosystem.

What SciPy is not

Before we go further, it’s worth clarifying what SciPy doesn’t do:

• SciPy is not a machine learning library. For ML, use scikit-learn, PyTorch, or TensorFlow. SciPy provides some statistical and optimisation tools that underpin ML, but it doesn’t include classifiers, neural networks, or pipelines.

• SciPy is not a plotting library. It has no built-in visualisation. Use Matplotlib, seaborn, or plotly to visualise your SciPy results.

• SciPy is not a symbolic maths library. It works numerically - with floating-point numbers - not symbolically. For symbolic algebra, use SymPy.

• SciPy is not a replacement for NumPy. SciPy works with NumPy. Most SciPy functions take NumPy arrays as input and return NumPy arrays as output.

Installing SciPy

If you’re using a standard scientific Python setup, you probably already have SciPy installed. If not, you can install it with pip:

pip install scipy

Or conda:

conda install scipy

You can verify your installation and check the version like this:

import scipy
print(scipy.__version__)  # e.g. '1.17.1'

The golden rule: how to import SciPy

Here’s something that trips up many newcomers. You might expect to do this:

import scipy

scipy.linalg.solve(A, b)  # This will likely fail

But SciPy’s submodules are not automatically imported when you import the top-level scipy package. Instead, you should always import the specific submodule you need:

# The correct way - import the submodule explicitly
from scipy import linalg

linalg.solve(A, b)

Or for specific functions:

# Also fine - import just what you need
from scipy.linalg import solve

solve(A, b)

This is a deliberate design decision. SciPy is large, and importing everything would be slow and wasteful. Think of it like importing from a specific drawer in a very large toolbox, rather than tipping the whole thing out onto your workbench.

A map of the submodules

SciPy is organised into 15 submodules. Here’s a quick tour, so you have a mental map before we dive into them individually later in this series.

If you are unfamiliar with any of these areas, don’t worry at this stage. We will look at them all in later articles.

scipy.linalg - linear algebra

This module provides everything you need for working with matrices and linear systems. This goes beyond numpy.linalg by offering a richer set of decompositions, matrix functions, and direct access to the underlying LAPACK and BLAS routines.

Here is a simple example, using linear algebra to solve a system of simultaneous equations:

from scipy import linalg
import numpy as np

A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])

x = linalg.solve(A, b)
print(x)  # [2. 3.]

In general, the examples in this section are provided to give a feel for how each submodule is used. It is not necessary to understand every example (for example, if you are not interested in using SciPy for linear algebra, you can ignore this example). Each submodule will be covered in more depth in later articles.

scipy.optimise - optimisation and root finding

Find the minimum of a function, fit a model to data, find where a function equals zero, or solve a linear programming problem. This is one of the most immediately useful modules for practising programmers.

from scipy. optimise import minimise

# Minimise f(x) = (x - 3)^2 + 1
result = minimize(lambda x: (x - 3)**2 + 1, x0=0)
print(result.x)  # [3.]

scipy.integrate - integration and ODEs

Numerically integrate functions and solve ordinary differential equations. Indispensable in physics, engineering, and biology, or anywhere a rate of change needs to be modelled over time.

from scipy.integrate import quad
import numpy as np

# Integrate sin(x) from 0 to pi
result, error = quad(np.sin, 0, np.pi)
print(result)  # 2.0 (exactly, within floating point precision)

scipy.stats - statistics

This module provides a comprehensive statistics toolkit covering probability distributions, descriptive statistics, hypothesis tests, and correlation. If you need to go beyond what Pandas provides, you will probably find what you’re looking for here.

from scipy import stats

data = [2.1, 2.5, 2.3, 2.8, 2.0, 2.6, 2.4] 
t_stat, p_value = stats.ttest_1samp(data, popmean=2.5)
print(f"p-value: {p_value:.4f}")

scipy.interpolate - interpolation

Given a set of data points, estimate values in between them. Useful when working with sampled data that you need to resample, smooth, or evaluate at arbitrary points.

from scipy.interpolate import CubicSpline
import numpy as np

x = np.array([0, 1, 2, 3, 4])
y = np.array([0, 1, 4, 9, 16])

cs = CubicSpline(x, y)
print(cs(2.5))  # ≈ 6.25

scipy.signal - signal processing

Filter signals, analyse frequency content, detect peaks, and perform convolution. Used heavily in audio processing, communications, biomedical engineering, and any application involving time-series data.

from scipy.signal import find_peaks
import numpy as np

signal = np.array([1, 3, 1, 4, 1, 5, 1, 4, 1, 3])
peaks, _ = find_peaks(signal, height=3)
print(peaks)  # indices of peaks: [1 3 5 7]

scipy.fft - fast fourier transforms

Transform signals from the time domain to the frequency domain and back again. The FFT is an important algorithm in signal processing, and SciPy’s implementation is fast, flexible, and easy to use.

from scipy.fft import fft, fftfreq
import numpy as np

t = np.linspace(0, 1, 500)
signal = np.sin(2 * np.pi * 50 * t)  # 50 Hz sine wave

freqs = fftfreq(len(t), d=t[1] - t[0])
spectrum = fft(signal)

scipy.spatial - spatial data structures

Work with points in space: compute distances efficiently, find nearest neighbours, build Voronoi diagrams, compute convex hulls, and handle 3D rotations.

from scipy.spatial import KDTree
import numpy as np

points = np.random.rand(1000, 2)
tree = KDTree(points)

# Find the 3 nearest neighbours to the point (0.5, 0.5)
distances, indices = tree.query([0.5, 0.5], k=3)
print(indices)

scipy.sparse - sparse matrices

When your matrix is large but mostly zeros (for example, graph adjacency matrices or finite-element systems), storing every element wastes enormous amounts of memory. Sparse matrices store only the non-zero entries.

from scipy.sparse import csr_matrix

# A 5x5 sparse matrix with just 3 non-zero values
row = [0, 1, 3]
col = [0, 2, 4]
data = [1.0, 2.0, 3.0]

M = csr_matrix((data, (row, col)), shape=(5, 5))
print(M.toarray())

This prints:

[[1. 0. 0. 0. 0.]
 [0. 0. 2. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 3.]
 [0. 0. 0. 0. 0.]]

Additional modules

The remaining modules are more general-purpose, and we’ll dip into them throughout the series:

• scipy.constants - Physical constants (speed of light, Planck’s constant, etc.) and unit conversions

• scipy.special - Special mathematical functions: Bessel, Gamma, error functions, orthogonal polynomials

• scipy.ndimage - N-dimensional image filtering, morphology, and geometric transforms

• scipy.io - Read and write MATLAB .mat files, WAV audio, Fortran binary files

• scipy.datasets - Small built-in datasets for testing and experimentation

We will look at a couple of examples. Here is how we might use scipy.constants:

from scipy import constants

print(constants.speed_of_light)     # 299792458.0 (m/s)
print(constants.Planck)             # 6.62607015e-34 (J·s)
print(constants.convert_temperature(100, 'Celsius', 'Kelvin'))  # 373.15

And here is scipy.special, showing the gamma and erf functions:

from scipy.special import gamma, erf
import numpy as np

print(gamma(5))       # 24.0  (i.e. 4!)
print(erf(1.0))       # 0.8427... (the error function, used everywhere in statistics)

A complete example

Let’s bring a few things together to show how naturally SciPy fits into a real workflow. Suppose you’re analysing some experimental data where you know the underlying model should follow a decaying exponential, but your measurements are noisy.

import numpy as np
from scipy. optimise import curve_fit
from scipy.stats import pearsonr

# --- Simulate some noisy experimental data ---
rng = np.random.default_rng(42)
t = np.linspace(0, 5, 50)
true_signal = 3.0 * np.exp(-0.8 * t)
noisy_data = true_signal + rng.normal(scale=0.2, size=len(t))

# --- Define the model we want to fit ---
def exponential_decay(t, amplitude, decay_rate):
    return amplitude * np.exp(-decay_rate * t)

# --- Fit the model to the noisy data ---
params, covariance = curve_fit(exponential_decay, t, noisy_data, p0=[1.0, 1.0])
amplitude, decay_rate = params

print(f"Fitted amplitude:   {amplitude:.4f}  (true: 3.0)")
print(f"Fitted decay rate:  {decay_rate:.4f}  (true: 0.8)")

# --- Check the quality of the fit ---
fitted_values = exponential_decay(t, *params)
r, p = pearsonr(noisy_data, fitted_values)
print(f"Pearson r:          {r:.4f}")
print(f"p-value:            {p:.2e}")

This outputs something like:

Fitted amplitude:   2.9987  (true: 3.0)
Fitted decay rate:  0.8021  (true: 0.8)
Pearson r:          0.9977
p-value:            3.41e-43

In about 20 lines of clean, readable code, we’ve simulated an experiment, fitted a mathematical model to noisy data, and statistically validated the fit. No loops to optimise, no manual implementation of least-squares. SciPy handles everything.

A note on performance

You might wonder, if SciPy is written in Python, how can it be fast? The answer is that the heavy lifting isn’t written in Python at all. Under the hood, SciPy wraps highly optimised Fortran and C libraries - LAPACK and BLAS for linear algebra, FITPACK for splines, ODEPACK for differential equations, and others. The Python API is a clean and flexible interface to decades of carefully optimised numerical code.

This means you get the best of both worlds, C/Fortran performance with Python convenience. As a rule of thumb, if you find yourself writing a loop to do something mathematical in Python, there’s a good chance SciPy already has a vectorised, compiled implementation that will run orders of magnitude faster.

Further reading

• Official SciPy Documentation

• SciPy Lecture Notes - an excellent free textbook

• NumPy - if you want to brush up on the foundations first

• SciPy GitHub Repository - the source code and release notes

In the article Special relativity time dilation, we saw that, according to special relativity, if we stand on a train station and observe a passing train, then a clock on the train will be ticking more slowly than a clock on the station. It isn’t just the clock, time itself passes more slowly on the train than on the platform. We called this effect time dilation.

We looked at why this happens, but we didn’t calculate exactly how slowly time passes. In this article, we will derive that calculation and see that it has some interesting properties.

Time dilation recap

In the previous article, we considered a light clock on a moving train. A light clock is an imaginary device consisting of two mirrors, with a pulse of light bouncing back and forth between them. We can’t build a light clock, for various practical reasons, but we can imagine one and think about how it would behave.

Here is a light clock, from the point of view of Bob, who is on the train. The pulse of light starts at the bottom mirror (the blue dot) and travels up to the top mirror. It is then reflected back and arrives at the bottom mirror (the red dot):

This diagram shows the two paths side by side, for clarity. But in fact, for the light clock to work, the mirrors would have to be very well aligned so that the upward and downward paths are the same. Assuming perfect alignment and perfect mirrors, the light pulse would bounce up and down, again and again, forever.

The distance between the mirrors is d. We know that light travels at a constant velocity c, so the time it takes to travel from the bottom mirror to the top is d/c.

Now let’s look at the same clock from the point of view of Alice, who is standing on the train station platform. The train is passing through the station with a constant velocity v:

The clock does the same thing for both observers. The light travels from the bottom mirror to the top mirror, then back to the bottom mirror. But for Alice, while the light is travelling from the bottom mirror to the top mirror, the train will have moved along. So from Alice’s point of view, the light travels diagonally from the original position of the bottom mirror to the new position of the top mirror.

The light reflects back to the bottom mirror, but by the time it reaches it, the train will have moved on, so the light will again take a diagonal path.

From Alice’s point of view, the light travels a distance e to get from the bottom mirror to the top mirror. Since light travels at speed c in all inertial frames of reference, the time taken is e/c

So Alice and Bob will both see the same thing, the light travelling from the bottom to the top and back again. But distance e is clearly greater than distance d, so for Alice it will take longer than for Bob. The only consistent explanation for this is that, from Alice’s point of view, time is travelling more slowly for Bob.

And, as mentioned in the earlier article, we now have a wealth of real-world data to prove that this really does happen.

How much slower does time pass?

So, for Bob, the light going from the bottom to the top takes d/c. We call this the proper time, t₀ because Bob is in the same frame of reference as the clock (they are both on the train, so the clock is at rest for Bob). So:

For Alice, the light has to travel a greater distance, e. The time. which we will call t₁, is given by:

We can see that these two terms are different, because d and e are different. But how do the two terms relate to each other? Well, if we look again at the situation from Alice’s frame of reference, we can draw a right triangle like this:

We have just derived expressions for d and e, but what about x? In Alice’s frame of reference, the train is travelling at velocity v. The length x is the distance that the train travels in the time it takes for light to travel from the bottom mirror to the top mirror. We have already seen that, for Alice, that time is t₁. So the distance x is simply that time multiplied by the speed of the train, v:

So we now know the three lengths of a right-angled triangle. This one of the most unexpected and important equations in physics, but it can be solved using Pythagoras! Here goes:

Now we can substitute our known values for d, e and x:

Since we are interested in the relationship between the two times, it will be useful to rearrange the equation so that the t₁ terms are on the left and t₀ terms are on the right:

We can divide through by c squared:

Rearranging:

Now we can find the ratio of squares of t₁ and t₀:

Taking the square root of both sides gives the final result:

Recall from earlier exactly what this means. From Alice’s point of view, time passes more slowly for Bob. Bob’s time is dilated from Alice’s perspective; the time taken for light to travel a distance d in Bob’s frame appears to be longer than Alice would expect. The effect is a constant multiplier that depends only on the train’s velocity (and the speed of light, which we know is constant).

We call this multiplier the Lorentz factor, often represented by the Greek letter gamma (γ):

Properties of Lorentz factor

Several interesting features of the Lorentz factor are clear just by looking at it, but they have profound implications for the physical world.

The first is that the velocity v is divided by the speed of light c. Since c is a very large number, then v/c tends to be very small for everyday objects travelling at ordinary speeds. So the Lorentz factor is usually very close to 1.

For example, a train travelling at 100 mph (about 44 m/s) has a Lorentz factor of about 1.00000000000001. Time dilation occurs, but its effect is not noticeable or even detectable in most situations. That is why the concept seems counterintuitive to most people - it is something that we never notice in normal life.

The equation only relies on the velocity squared, which means that time dilation only depends on the magnitude of the velocity, not its direction. It doesn’t matter if the train is passing from left to right or from right to left, the time dilation will be the same. Equally, if instead of a train we used an elevator going up or down at the same speed, we would see the same time dilation.

A related observation is that time can be dilated but never contracted. The denominator is the square root of an expression that is always ≤1, which means that the Lorentz factor is always ≥1. So the clock on the moving train always ticks slowly, from the point of view of an observer on the platform.

Now let’s consider what happens when v gets bigger. In the graph below, the x-axis represents v/c. So, for example, 0.5 on the x-axis represents the train travelling at half the speed of light. The y-axis shows the Lorentz factor:

The leftmost red dot (at x = 0.2) represents the train travelling at one-fifth of the speed of light. Even at that immense speed, the Lorentz factor is only just above 1, so there is only a small amount of time dilation happening.

When x is 0.5 (the train travelling at half the speed of light), there is slightly more time dilation.

When x is around 0.866, the Lorentz factor is 2, which means the clock on the train is ticking at half the speed of Alice’s clock. When x is around 0.943, the Lorentz factor is 3. So time dilation is quite negligible, even at half the speed of light, but increases rapidly as we approach the speed of light. If the train were to actually reach the speed of light, Alice’s clock would be ticking infinitely faster than the clock on the train.

But that isn’t possible because of another effect of relativity. We won’t cover this here in detail, but the effective mass of an object also increases in line with the Lorentz factor. In other words, as an object approaches the speed of light, its mass tends to infinity. So no object can ever reach the speed of light, because that would require an infinite amount of energy.

But what about light itself? According to quantum theory, light is composed of photons, which are massless particles. Photons travel at the speed of light, but since they have zero rest mass, this does not require them to have infinite energy. But for photons, time dilation is infinite, which means that a photon doesn’t experience time at all, even if it spends billions of years traversing the universe.

Two physicists, Marvin Stern and George Gamow, worked in the same building, a large multi-storey building, with a single elevator serving all the floors.

Both men had noticed a slightly odd phenomenon. Whenever they wanted to use the elevator, it seemed that it was usually going in the wrong direction. If they wanted to go down, when the elevator arrived, it was usually going up. When they wanted to go up, the elevator was usually going down. They had both noticed this effect independently. But it was only when it came up in conversation that they realised it might be a real effect worthy of investigation. This phenomenon became known as the elevator paradox, which they highlighted in 1958.

Subscribe now

Share

My book on Calculus is available from Amazon.

Confirmation bias?

Confirmation bias is an unconscious human tendency to selectively notice and remember anything that confirms your existing beliefs, whilst downplaying or ignoring anything that contradicts them.

It is easy to see how that might arise in the elevator case. If the elevator arrives and happens to be going up when you want to go down, that is quite annoying. You have to stand and wait until it goes all the way to the top and comes back down again. That sticks in your mind.

If you are late for a meeting, that extra delay is going to be really annoying, and looms even larger in your memory.

But if the elevator arrives and it happens to be going down, you get on the elevator and think no more about it. It would be very easy, after months or years, to form the opinion that the elevator is almost always going in the wrong direction.

So the physicists decided to eliminate confirmation bias. Each time they used the lift, they recorded:

• Whether the lift was going up or down when it arrived.

• Whether they were intending to go up or down.

After weeks of gathering these statistics, they discovered that the effect was real. The elevator was statistically more likely to be going in the wrong direction when it arrived. The effect was significant enough to be undeniably true.

The apparent paradox

This effect seems very puzzling and paradoxical, for several reasons.

The first is that if the lift arrives at, say, floor 3 and is going up, then the next time it arrives at floor 3 it must be going down, then up, then down, and so on. The lift can’t arrive at floor 3 going up, and then arrive at floor 3 going up again.

We can also say that when the lift arrives at floor 3 for the nth time in the day (where n is a random number), it is equally likely to be going up or down.

We assume here that the lift always travels from the lowest floor to the top floor, then back to the lowest floor, in a continuous cycle. We will also ignore the case of anyone waiting for the lift at the bottom or top floor, because the lift changes direction there, so it will always be travelling in the right direction for anyone waiting there. These are special cases.

But there is another random factor as well. For the lift to be going in the “wrong” direction depends on which direction you want to go. For example, suppose you arrive at the floor 3 lift, and the next lift is going down. If you are intending to go to a meeting on floor 5, that would be the wrong direction for you. But if you are intending to get a snack from the vending machine on floor 2, it would be the right direction for you.

So how can the direction be wrong more often than it is right?

A simple building

This diagram represents a simple building:

The building has 9 floors, with floor 0 being the ground floor, and floor 8 the top floor. There is a single elevator that travels from floor 0 to floor 8. It is a simple system that goes all the way to the top, then all the way to the bottom, stopping at every floor it is requested to.

An observer is positioned on floor 6, marked as yellow. If the observer simply watches the elevator, they will see it goes up and down repeatedly. It will alternate, of course, if it is going up one time, it must be going down the next time, and vice versa. If the observer watches for a while, the number of times the elevator goes up must equal the number of times the elevator comes down, plus or minus one.

The description above is stating the obvious, of course. The point is, the elevator is no more likely to be going up than down at any point in time.

So what is going on?

In reality, of course, people don’t usually stand around watching the elevator going up and down. They use the elevator when they need to. In other words, they will get on the elevator whenever it arrives.

Will the elevator be going up or down? It depends on where the elevator happened to be when the observer arrived. This is shown below:

When the observer arrives at the elevator, assuming again that they are on floor 6, we can see that:

• If the elevator happens to be in the blue region (floors 7, 8), then it will be travelling downwards when it arrives at floor 6.

• If the elevator happens to be in the white region (floors 0 to 5), then it will be travelling upwards when it arrives at floor 6.

We will ignore the case where the elevator is already on floor 6. In that case, the direction of travel depends on whether the elevator has come from the blue ot white regions.

Now here is the important thing. When the observer turns up at some random time, the elevator is more likely to be in the white region, because there are more floors in the white region than there are in the blue region. In fact, if the lift spends the same average time on each floor, it will spend three-quarters of its time in the white region.

This means the lift is three times as likely to be going up as going down.

There is a second thing to consider. Since floor 6 is higher up in the building, it seems reasonable to expect that most people on floor 6 will want to go down, because there are more floors below floor 6 than above it.

Combining those two assumptions, the lift is going in the wrong direction most of the time.

Other floors

Now let’s imagine our observer is on floor 2:

This time, the situation is reversed. There are more floors above floor 2 than there are below it. So, in this case, someone arriving at the elevator would be more likely to find it going down. But since they are on a low floor, they are probably more likely to be going up. So, once again, they would find that the elevator is going in the wrong direction, more often than not.

What if the observer is on floor 4? It looks like this:

This time, the floor is halfway up the building, with 4 floors above and 4 below. So the next elevator could come from either direction with roughly equal probability. And since they are in the middle of the building, they might want to go up or down, with more or less equal probability.

They might, therefore, find that the elevator is going in the right direction for them approximately half the time.

But, of course, they will then be on a higher or lower floor, so their next journey is more likely to have the elevator going in the wrong direction. So they would still see the effect.

Modern elevators

Most modern elevators are computer-controlled, so they might use algorithms to reduce this effect. That is particularly true if there are multiple elevators in the building. The algorithm might move elevators around when they are not in use to meet anticipated demand. It might take into account the busier times of day. It might even have dedicated elevators that serve only the first few floors.

Perhaps this is the legacy of Stern and Gamow!

We saw in an earlier article that two events that occur simultaneously in one frame of reference might not occur simultaneously in another. We saw that two bolts of lightning that strike a train platform at the same time, according to an observer on the platform, would strike the platform at different times, according to an observer on a passing train. And we saw that this isn’t just that the strikes appear to have happened at different times; they actually did happen at different times.

Subscribe now

Share

My book on Calculus is available from Amazon.

This conclusion was the result of a thought experiment by Einstein. He assumed two postulates: that the laws of physics are the same in all inertial frames of reference, and that the speed of light is the same in all inertial frames of reference. His thought experiment told us what would happen if we assume those two postulates are true. And, in fact, the results have been experimentally verified many times in many different ways since Einstein first proposed them.

A further thought experiment proved something equally strange. Time passes at a different rate for someone on a train station platform compared to someone on the moving train! This effect is called time dilation. In this article, we will show how and why it happens.

Light clocks, and thought experiments

To illustrate time dilation, Einstein imagined a special device called a light clock, shown here:

This consisted of two mirrors, facing each other, separated by a distance d. It works as follows:

• A very short “pulse” of light is created just above the lower mirror.

• The light travels up towards the top mirror, and is reflected back downwards.

• The light then travels down towards the bottom mirror, and is reflected back upwards.

• This repeats indefinitely, with the pulse of light bouncing between the two mirrors.

Now, suppose we have a light detector at the bottom mirror. Every time the light returns to the bottom mirror, the detector will trip. This will be like the ticking of a clock. We could even count the ticks and measure the passing of time, just like an ordinary clock.

Since the mirrors are a distance d apart, the light has to travel a distance of 2d to go from the bottom to the top, then back to the bottom. Since we have postulated that light always travels at a constant speed, which we will call c, the time between ticks is 2d/c.

At this point, it is worth thinking about what we mean by a thought experiment. It isn’t possible to build a working light clock, for various practical reasons. But that doesn’t matter for a thought experiment, because there is nothing in principle to say a light clock cannot exist. So we can ask, if we could build a light clock, how would it behave?

That said, since Einstein first imagined this, we have observed time dilation experimentally many times and in many different ways. There is an example at the end of this article.

Light clock from the point of view of Bob, on the train

In the previous article, we considered the case of a train passing through a station. We imagined two observers, Alice on the station platform, and Bob on the train. Both observers were scientists who understood relativity and had a wealth of scientific instruments to aid their observations. This is illustrated here:

Here, the grey rectangle represents the station, with Alice at point A. The blue rectangle represents the moving train, with Bob at point B

Let’s suppose the light clock is on the train. What would Bob see? Well, since Bob is in the same inertial frame of reference as the clock, from his point of view, the clock is at rest, so he would see the light clock ticking exactly as described above, with a time between ticks of 2d/c. Here is the clock at the start of a cycle, when the light pulse is at the bottom mirror:

Here is the clock when the light pulse reaches the top mirror. We will assume that the clock provides a visual indication that the pulse has reached the mirror, so Bob (and Alice) can see it. This is represented by the red circle:

Here is the clock when the light pulse has returned to the bottom mirror. Again, there is a visual indication of this:

It is important to realise that Bob doesn’t need to measure the time it takes. Since we are assuming that light travels at a constant speed c, he can calculate the time. As we saw earlier, the time is 2d/c.

Light clock from the point of view of Alice, on the platform

Now, let’s imagine what Alice sees from the platform. Here is the initial state, when the light pulse is at the bottom mirror:

Here is what she sees at the second point, when the light pulse has reached the top mirror:

Since the train is moving relative to Alice, she sees the clock in a different position by the time the light reaches the top mirror. She also sees that the light is travelling at an angle relative to the clock, because it is travelling vertically in Bob’s frame of reference. Most importantly, this means that, from Alice’s point of view, the light travels a distance e from the bottom mirror to the top mirror.

This triangle shows the distance e, the height of the light clock d, and the distance x the train travelled. Since the light clock is vertical and the train is travelling horizontally, this is a right-angled triangle with e as the hypotenuse. So e must be greater than d, because the hypotenuse is always the longest side of a right triangle:

After reflecting off the top mirror, the light is reflected back to the bottom mirror:

Again, the clock will have moved with the train. Since the train and the light pulse haven’t changed speed, the light will travel a distance e.

This means that, in Bob’s frame of reference, the time it takes for the light to travel from the bottom to the top and then back to the bottom is 2d/c. But in Alice’s frame of reference, that same journey takes a longer time 2e/c.

Measuring time at different positions on the platform

This might seem a little bit like the simultaneity effect, but it is actually slightly different. The previous effect relied on the fact that Alice and Bib were both viewing distant events (two lightning strikes at opposite ends of the train) from different frames of reference.

This time, Alice and Bob don’t need to measure anything. Simple logic tells them that they will each experience a different time between the two events.

However, if we wanted to, we could measure the times directly (in principle, not in practice, because this is a thought experiment). Bob is standing right next to the clock so he can time the events directly.

For Alice, it is a little more involved. We could have lots of Alices standing at different points along the platform. So for each event, we would have Bob and one of the Alices very close to the light clock. So they would be timing the same event, local to them.

Time dilation

To summarise what we know so far:

• Alice and Bob can observe the light clock while they are both close to it at the start of the first tick.

• Alice and Bob can observe the light clock again, while they are close to it, at the end of the first tick.

• Between those two events, a time of 2d/c will have passed for Bob. But a longer time of 2e/c will have passed for Alice.

If we observed a second tick, then a total time of 4d/c will have passed for Bob. But a longer time of 4e/c will have passed for Alice. The time difference will increase over time.

The only reasonable explanation is that, from Alice’s point of view, time passes more slowly for Bob simply because he is moving.

Of course, Bob doesn’t experience time passing more slowly. For him, the light travels a distance of 2d in a time of 2cd, exactly as he would expect.

And this only happens because light travels at the same speed in every frame of reference.

A light clock on the platform

Now imagine there was a light clock on the platform. In that case, Alice would see the clock ticking every 2d/c seconds. But Bob (or in this case the multiple Bobs on the train) would see the clock on the platform ticking more slowly, every 2c/s seconds.

This might seem like a contradiction. How can time be passing more slowly for Bob and for Alice? Well, of course it isn’t, time passes at the normal rate for both of them. But each of them sees the moving clock ticking more slowly.

A real-life example of time dilation

The Frisch–Smith experiment is a famous 1962 experiment that confirms time dilation. It has been repeated many times since then.

Cosmic rays are high-speed particles (mainly protons and helium nuclei) that arrive in the outer atmosphere from space. Those particles collide with atoms in the atmosphere, and, due to their high kinetic energy, smash the atoms into subatomic particles, which are emitted at very high velocities, often approaching the speed of light.

Of particular interest are muons. A muon is a type of lepton, similar in some ways to an electron, which is another type of lepton. But a key thing about muons is that they are unstable, with a mean lifetime of just 2.2 microseconds. They are created in the upper atmosphere by cosmic rays, but most of them decay within a few microseconds. When they decay, they create an electron and a neutrino.

The Frisch–Smith experiment detected muons at the top of a mountain, about 2,000 km above sea level. They had equipment designed to count muons travelling at around 99.9% the speed of light. They then used the same technique to count the number of muons arriving at sea level. Based on the time it would take for a muon to travel 2 km at 99.5% of the speed of light, they expected most of the muons to have decayed before they reached sea level.

But in fact, they found far more muons than expected arriving at ground level. More than 10 times as many. The discrepancy closely matched what you would expect due to relativistic time dilation. Since then, many other experiments have confirmed the same thing.

Time dilation is real. And Einstein discovered it by sitting and thinking.

Share

Subscribe now

If you are interested in Calculus, my book is now available from Gumroad.

Maxwell, Michelson and Morley

Maxwell’s equations describe how electromagnetic fields behave. They show that waves can travel through the field. The theoretical speed of these waves could be calculated, and it was very close to the speed of light. Maxwell guessed that light might be an electromagnetic wave.

What was even more interesting was that, according to Maxwell’s equations, the speed of light appeared to be constant regardless of the speed of the observer.

Michelson and Morley later did an experiment to check this. They measured light’s speed in two perpendicular directions. The Earth moves around the Sun at over 100,000 km/h. You might expect a small difference in measured speed due to Earth’s motion in one direction. No difference was found. This suggested that the speed of light does not depend on the observer’s motion.

Einstein’s thought experiment

This strange result was largely ignored until the early 20th century, when Einstein decided to take a closer look. But he didn’t perform any experiment.

He simply took two postulates:

• The laws of physics are the same in all inertial frames. An inertial frame does not accelerate or change direction.

• The speed of light in a vacuum is constant for all observers, regardless of their motion or the source’s motion.

He then asked the question, given that these things are both true, what would you expect to happen?

Einstein’s train

Einstein imagined an observer, Alice, standing on a railway station. He pictured a train carriage passing by at high speed. A second observer, Bob, would stand at the exact centre of the train. The diagram below shows a top view, with the train in blue, Alice (A) on the platform, and Bob (B) on the train:

Now let’s imagine that, at the precise moment that Alice and Bob are exactly opposite each other, two bolts of lightning strike the platform at opposite ends of the train. These are shown below by the yellow and orange dots (we use the colours to distinguish the two strikes on the diagram, not to suggest that the lightning itself is that colour):

Bob is standing in the middle of the train. Alice and Bob are opposite each other. So, the two lightning strikes are the same distance from Alice and Bob.

Now, Alice and Bob are scientists who understand the speed of light, and Einstein’s two postulates. They have cameras and other equipment on the platform to observe the events and work out the sequence of events.

The platform, from Alice’s viewpoint

The diagram shows what happens on the platform, from Alice’s point of view:

Image 1 shows the lightning strikes. Alice won’t see the lightning instantly, because it takes a finite amount of time for the light to travel to her.

Images 2 and 3 show the light travelling towards her.

In image 4, light from both strikes reaches Alice simultaneously.

What does Alice know?

• She knows that the lightning strikes were both the same distance from her, she has photographs of where the lightning landed.

• She knows that the light from both strikes arrived at her location at the same time. She has two sensors that detect the time of arrival of light, using the same clock.

However, she DOESN’T know for certain whether the two strikes happened at exactly the same time. The strikes were measured at two different places, and there is some suggestion that distance and movement might affect the timing. So, just to be safe, she will only trust that two times are the same if they are measured at the same place using the same clock.

But here is what she can deduce. Both light flashes arrived at her location at the same time, and both lightning strikes happened the same distance away from her. So, since light always travels at the same speed, the two lightning strikes must have happened at the same time.

The train, from Alice’s viewpoint

Alice can also figure out what Bob saw on the train.

Look again at step 4 above, the point when the two light flashes arrive at Alice. We can see that Bob will already have moved some distance to the right. Alice even has a photo to prove it.

This means the red flash will have already passed Bob, but the yellow flash won’t have reached him yet. Bob will have seen one flash, but not yet seen the other. To him, the flashes will appear to have happened at different times.

But there is nothing strange about that. Bob is travelling towards the source of the red flash and away from the source of the yellow flash. Since light has a finite speed, he will, of course, see the red flash first. That is exactly what you would expect.

The train, from Bob’s point of view

This is where things get a little strange. Here is what Bob sees:

Notice that the timepoints shown here are not exactly the same as those in the previous diagram.

Images 1 and 2 show the lightning strikes and the flashes moving along the train towards Bob.

Image 3 shows the red flash reaching Bob.

Image 4 shows both flashes reaching Alice simultaneously.

Image 5 shows the yellow flash reaching Bob.

What does Bob know?

• He knows that the lightning strikes were both the same distance from him, he has photographs of where the lightning landed. The lightning landed at either end of the train.

• He knows that the light from both strikes arrived at his location at different times. He has two sensors that detect the time of arrival of light, using the same clock.

Here is what he can deduce:

• Both light flashes arrived at his location at different times.

• Both lightning strikes happened the same distance away from him (we already know that). & So, since light always travels at the same speed, the two lightning strikes could not possibly have happened at the same time.

So, by pure logic, Einstein figured out that two events that are simultaneous in one inertial frame might not be simultaneous in another.

A common misconception

You might still be unconvinced. You might be thinking, wouldn’t the same thing happen if we use, say, a tennis ball instead of light?

Yes, it would. Almost.

Let’s revisit the previous diagram, but using tennis balls rather than light. In image 1, as the train passes, two people on the platform throw a tennis ball towards Alice from opposite directions. In image 2, those balls travel towards Alice.

In image 3, the red ball passes Bob, in image 4, both balls pass Alice, and in image 5, the yellow ball passes Bob. Exactly like the light.

If Bob wasn’t a scientist, and he had been told that both balls had been launched from the same distance and at the same speed, he might come to the conclusion that the red ball must have been launched before the yellow ball.

But Bob is a scientist, and he has a radar speed sensor, so he knows that the speed of the red ball (relative to the train) is faster than the speed of the yellow ball (relative to the train). The balls were thrown at the same speed relative to the platform, but the speeds relative to the train are different because the train is moving too.

He can do the calculation and confirm that the balls were indeed thrown at the same time.

The essential difference is that light always travels at the same speed for observers in any inertial frame. That makes no sense in the context of ordinary objects like balls, but it is how light behaves, so it leads to counterintuitive results.

To the person on the train, it doesn’t just look like the lightning strikes happened at different times. They actually did happen at different times.

Suppose we could replace all of those with one function? Well, a recent paper, All elementary functions from a single operator, by Andrzej Odrzywołek, shows that we can.

The function is called the eml function. This function, together with the number 1, can do everything listed above. In principle, we could make a scientific calculator with just those two keys, and it could do everything a normal scientific calculator can do!

To be clear, of course, you wouldn’t want to do that. It would work in principle, but in practice, you would need to press those two buttons many times for even a simple calculation. Even so, this technique might have applications in computing, see the analogy with NAND gates, below.

Subscribe now

Share

If you are interested in Calculus, my book is now available from Gumroad.

The eml(x, y) function

You might expect such a function to be quite complicated, but in fact it is a lot simpler than you might imagine. The eml function of x and y is defined as follows:

EML stands for Exp-Minus-Log.

The exponential function can be written as exp(x), rather than e^x, like this:

In this article, we will use exp(x) because it is more readable when we nest functions to many levels.

How the function works

To understand how this function works, it is easiest to look at some examples. Since the function is based on exponentials and logs, it is not surprising that these functions can be expressed most easily in EML.

First, consider the constant e (Euler’s number). Looking at the original function:

If we set x to 1, the first term is just e. If we set y to 1, the log term goes to 0 (log of 1 is 0). So:

Let’s be clear what we have done here. We have expressed the constant e in terms of the EML function. That isn’t so interesting on its own. But, as we will see, we can express every other elementary function in terms of EML too. That is pretty amazing and potentially very useful.

Let’s look at the exponential function next. We just use eml(z, 1), and again the log term vanishes:

What about ln(z), how do we express that in terms of eml? This is slightly more complicated and takes several steps. We start by setting x to 1 and y to z

We can take the exponential of both sides:

We can apply eml(1, z) again to the whole expression, which gives e minus the log of the previous expression:

We can simplify this, because we have ln(exp(...)) on the RHS, and those two functions are inverses, so they cancel out:

So now we know ln in terms of eml and exp. But we already know exp in terms of eml. So we can now express ln in terms of eml:

We will derive the EML representations of other functions later. Quite often, we will use the results of earlier functions to derive new functions (as we just did with exp to derive ln).

This will often result in an expression that is a mixture of eml functions together with other functions whose EML representation is already known. For example equation (1) has eml and exp functions, and we already know how to express exp using eml

In general, it will always be possible to expand the known functions to obtain a representation entirely using eml, as we just did with equation (1) to obtain equation (2). However, we won’t do that in the examples below. The result would be some very long expressions that aren’t particularly illuminating. The important thing is that we could do it if we wanted to.

Deriving arithmetic operators

We are now in a position to derive the arithmetic operators. Subtraction is quite easy:

We are again using the fact that exp and ln are inverses. When we pass ln(x) as the first term and apply exp in the eml function, the result is just x. Similarly, exp(y) becomes -y

Given subtraction, we can derive negation, once again using ln(1) = 0:

This might look a bit odd. We need to express -x in EML form, but the RHS doesn’t contain any eml functions. This goes back to what we said earlier about not expanding known functions, but this is a slightly more extreme example.

We can expand the subtraction using equation (3). Then we will end up with an expression involving eml, exp and ln. We already know how to expand exp and ln. So we know how to expand it, but it would be quite long and hard to read.

Then addition is just subtracting the negated value:

To multiply, we add the logs:

Division can be done by subtracting the logs. Powers and roots by multiplying and dividing the logs. They aren’t shown here.

More functions

We could go on to derive all the elementary functions in terms of eml. The supplementary information to the original paper (linked below) does that, but here we will sketch out the route.

The hyperbolic function cosh can be expressed in terms of the exp function:

sinh can be derived in a similar way, and tanh can be found from these

The trig functions are more interesting. There is a standard complex number identity:

But how do we find ix? Essentially, we can use the square root of negative x squared, which evaluates to ix:

We can derive π in a similar way. One definition of π relies on the complex-valued logarithm function:

Using the same trick as before, this can be written as:

We can now derive sin (it is just cos offset by π/2). Then tan can be derived from sin and cos.

The inverse hyperbolic and trig functions have standard formulas that can be used to derive EML representations, for example:

Again, see the supplementary information link below for all the inverse functions.

Tree structure

To summarise the EML system:

• Each of the expressions above can be written as nested elm calls (assuming we fully expand all the other functions to their elm form).

• Each elm call has two inputs and one output.

• Each input can either be 1, an input variable (eg x or y), or the result of another elm call.

This structure forms a binary tree, with leaf nodes that are either 1 or an input variable. The mess of nested elm calls isn’t very readable for most humans, but computers are very good at dealing with binary trees.

Also, EML isn’t limited to elementary functions. It can represent any formula involving elementary functions and arithmetic operators.

NAND gate analogy

Computer CPUs (and many other parts of a computer’s hardware) are mainly constructed from logic gates. A logic gate is a simple electronic circuit that typically accepts two inputs and creates one output. The input voltages are constrained to be either a low voltage (representing the binary value 0) or a high voltage (representing the binary value 1). The output voltage is similarly constrained.

There are several types of gates. AND gates, OR gates and XOR gates combine 2 or more inputs using logic rules, INVERTERS swap 0 and 1. NAND gates, NOR gates and XNOR gates combine the normal logic gate with an INVERTER to flip the output value.

It is possible to simulate every different type of gate using a combination of NAND gates. Most modern chips are designed using only NAND gates, which greatly simplifies their design, analysis, and manufacture. This more than compensates for the fact that a NAND-only design will typically use more gates overall.

Some important subtleties

There are a few additional points that are worth bearing in mind:

• EML sometimes uses complex numbers internally, even when doing real number calculations (for example, when calculating π from ln(-1)).

• Some complex number functions have branches, where an expression has more than one possible value (in much the same way that the square root of 4 can be 2 or -2). Using such functions involves implicit decisions about which branch to take.

• The system often uses the value 1 to eliminate the log term (because ln(1) is 0). Without this, EML wouldn’t work.

• EML isn’t unique, there are other possible systems.

On the last point, another possible system is EDL (exp-divided-log), which is based on the following function:

In this case, we would also need the constant e rather than 1 to eliminate the log term. That is because ln(e) is 1, and dividing by 1 has no effect,

Applications

This system has some interesting potential applications and implications:

• We have always known that many of the elementary functions are interrelated, in other words, they have redundancies. Indeed, EML uses many of these relationships in its derivation. But EML goes one step further and shows that all elementary functions can be derived from a single eml() function.

• EML provides a uniform language for expressing mathematics, which could be useful in computer algebra.

• It might have implications for hardware design. For example, if a very fast method for calculating eml were developed, it might speed up the calculation of other functions.

• An AI system based on the eml function might be able to spot patterns in data and create a matching mathematical function.

• As a unifying perspective, EML might offer profound insights into mathematics.

Links to the paper

• All elementary functions from a single operator original paper.

• Supplementary information if you want to dig a little deeper.

• Box A is open, and contains £1,000.

• Box B is closed and might either contain nothing or £1,000,000. You have no way of knowing until you make your choice.

You have two choices:

• You can choose to take both boxes. That is, box A (which contains £1,000) and box B (with unknown content).

• You can choose to take only box B, with unknown content.

Now this might seem very easy. In both cases, you get whatever is in box B, but in the first case, you also get box A as well.

But wait, there is one extra factor which might make you change your mind (or it might not). The content of box B is not random. In fact, a super-intelligent AI system has predicted what choice you will make, and decided the content of box B using the following rule:

• If the computer predicts that you will take both boxes, then it will have left box B empty.

• If the computer predicts that you will only take box B, then it will have filled box B with a million pounds.

The computer has already made its prediction, so box B either contains a million pounds or not, depending on what it predicted. But quite a few people have played the game already, and the computer guessed correctly in every case.

There are two main views of this paradox. Both views have plenty of supporters, but many people on both sides find it impossible to understand why anyone supports the opposing view.

If you are interested in Calculus, my book is now available from Gumroad.

Subscribe now

Share

The two-boxer argument

Some people look at the problem in this way. Before you have even decided what to do, box A already has £1,000 in it. Box B already has either £1,000,000 or nothing. That has already been fixed and cannot change.

In that case, it is always better to take both boxes. The table below shows the different possibilities.

The first two entries show the situation when box B happens to be empty. In that case, the one-box strategy (ie, taking just box B) would give a total return of zero, but the two-box strategy (ie taking both boxes) would give a total return of £1,000.

The last two entries show the situation when box B contains £1,000,000. This time, the one-box strategy would give a total of £1,000,000, but the two-box strategy would give slightly more, £1,001,000.

This means that the two-box strategy will always give a higher return than the one-box strategy.

The one boxer argument

The one boxer argument is very simple. Looking at all the past results, people who chose one box always walked away with £1,000,000. This is because the computer predicted that they would choose one box, and so it put the million in box B.

Also, people who took two boxes always walked away with just £1,000. That is because the computer predicted that they would choose two boxes, and so left box B empty.

Based on that, it is obviously better to be a one boxer.

The problem with the one boxer argument

The problem with the one-boxer argument is that the contents of box B were already decided before you entered the room to make your choice. The box already either contains a million or not, depending on the computer’s prediction.

If you are naturally a two-boxer, the computer knows that, so box B will be empty. If you make a last-minute decision, totally against your nature, to only take box B, then you will be a one-boxer. But box B will still be empty, because the computer predicted you would be a two-boxer. So you would lose everything, even the second prize of £1,000.

Unless, of course, the computer predicted that you would change your mind at the last minute, and therefore put the million pounds in the box.

For this reason, some people say that this is an ill-posed question. We have some mysterious computer with some mysterious method of guessing what you are going to decide. But we are given no clue as to how that works. The computer cannot see into the future, so there must be some limits to its predictive powers. But we are being asked to reason about those powers without being told how they work.

A further thought experiment

Suppose you adopted the following strategy. Rather than deciding which option to take, you toss a fair coin. If it is heads, you take one box. If it is tails, you take two.

It might be reasonable to assume that the computer is smart enough to predict that you would use a coin to make your choice. But it can’t predict what the outcome of the coin toss will be, that is truly random. So it must decide whether to put the million pounds in box B before it can possibly know what you will do.

We are now in uncharted territory. What will the computer do if it can’t predict what you will do? Who knows, we have only been told that the computer has some mysterious method of predicting what you will do. We have absolutely no idea what it might do if it knows that it can’t make a reliable prediction. Does it have special rules or some built-in priorities? This is one reason why we might say the question is ill-posed.

Changing the amounts - Pascal’s Wager

This paradox has an interesting parallel with Pascal’s Wager. The mathematician Blaise Pascal suggested that living your life as if God existed was the only rational choice. His reasoning was that:

• If God exists, then living your life according to his rules means that you will spend the rest of eternity in paradise.

• If God does not exist, then you will have lost very little. You will simply have lived your life following a few rules that you didn’t really need to follow.

Pascal argued that you should live your life as if God exists because the benefits if it turns out to be true massively outweigh the loss if it turns out to be false, so the logical choice is to behave as if God exists.

The same might be true of the one boxer argument. £1,000 is quite a lot of money. It is roughly equivalent to one or two weeks’ salary for many people. But £1,000,000 is a life-changing sum. Some people might be willing to risk £1,000 to win £1,000,000, without thinking too much about what the odds are.

The one-boxer position appears to be based on the assumption that the computer has extraordinary powers of prediction. But in reality, the computer might just be guessing one single aspect of your personality - your attitude to risk.

Suppose, for example, box A contained £500,000 and box B contained £1,000,000. The logical basis of the paradox wouldn’t change. But how many one-boxers would there be in that situation? Who would risk the certainty of getting half a million for the chance of getting a million?

Although, of course, the computer would know that, and would adjust its predictions accordingly.

Summary

My personal opinion is that this is not a well-posed problem. We are presented with a computer with seemingly magical powers, and we need to reason about how it would behave. And since there are situations where the computer cannot predict what you will do (for example, if you had chosen to toss a coin), that doesn’t seem to be a reasonable question.

What do you think?

An example signal

Here is a function that represents our “signal”. Convolution, of course, is a mathematical process that operates on mathematical functions, but in many practical applications, those functions might represent physical signals. For example, this function might represent a sound:

We might see this signal on an oscilloscope measuring a voltage in an electronic amplifier that will eventually be converted to sound waves by a speaker. Although in this case, the signal shown has an oscillation period of several seconds, so humans would not detect it as a sound.

Since this is a time-varying signal, the horizontal axis represents time, t, rather than x. We will call the function above f(t).

A simple filter

Let’s suppose we wanted to modify this signal by smoothing out some of the smaller bumps in the function. This would have the audible effect of increasing the bass and decreasing the treble, sometimes called a lowpass filter.

One simple way to do that would be a moving average filter. In this type of filter, the output consists of the average value of the signal over a certain period of time. As an example, we will take the average value of the signal for the previous 1-second period.

In the graph below, the top curve shows the input function from earlier. The bottom graph shows the filtered function, which we will call w(t). To find the value of w(t) at point a (when t is 0), we simply need to find the average value of the input function between t values of -1 and 0. This region is shown shaded on the top graph. It is the average value of the shaded region on the left, and is a positive value.

Point b on the lower graph (when t is 4) represents the average value of the function between t values of 3 and 4, and this time it is a negative value.

Of course, we can find the value of the lower graph for any value of t. It is simply the average value of the top graph over the range (t - 1) to t.

Calculating the value of w(t)

We can calculate the value of for any value of using integration. The average value of f(t) is given by the area under the curve, divided by the width of the region. In our case, the width of the region is 1, so the average value is:

We have used the Greek letter 𝜏 (tau) as the variable of integration, but notice that w is a function of t, not 𝜏. For example, when t is, the integral will find the area under the curve between -1 and 0, corresponding to point a above. When t is 4, it will find the area between 3 and 4, corresponding to point b, and so on.

Using a function instead of varying the limits

In the integral above, we change the limits of the integral to determine the region that we are interested in (for example, using limits of 3 to 4 to find the average value over that region). But there is an alternative method, illustrated by this graph:

The top graph shows our original function f(t) in blue, and a new function g(t) in red. g(t) is defined by:

It is a gating function that has value 1 between 0 and 1, and 0 everywhere else.

The bottom graph shows g multiplied by f. It has the value of f for t between 0 and 1, and 0 everywhere else. The useful thing about this function is that we can integrate it from -infinity to +infinity and get the same result as we would get by integrating for 0 to 1 (because the function is 0 outside that range). So we can write w(1) like this:

Notice that this is w(1) rather than w(0) because the range starts at 0 and ends at 1. We will address this later.

Now let’s look at this graph:

The red function is similar to g(t), but shifted by 4 along the time axis. We will call this new function gs. When we multiply gs by f, we get a new function that is equal to f when t is between 4 and 5, but 0 everywhere else. The integral of gs times f is:

This integral, of course, gives us w(5). Now we can simplify this further. We know from elementary mathematics that we can shift a function horizontally by subtracting a constant from its argument. In other words, we can write gs(t) (ie g(t) shifted by 4) as g(t - 4). So we can write:

And in general, we can say that:

Just like our original equation (1) above, this is a function of t. But this time t is part of the integrand rather than being part of the integral limits, which generally makes things easier, as we will see.

The equation above is the basis of a process called convolution, although we need to do a bit more work to get to the final definition.

Improving the formula

There is a small problem. When we plug some value t into the integral, we end up with w(t + 1). Now this might seem like a very minor problem. Perhaps we could just add a 1 into the integrand as a fudge factor to make it all work?

Unfortunately, it isn’t that simple. The reason the function is shifted by 1 is that we happen to be using a moving average filter with a width of 1. If we had chosen a width of 2, a fudge factor of 2 would be required. If we had chosen to use a weighted average rather than a gated average, we might need to use some other value.

There is a simple fix, but it leads to an aspect of convolution that people often find confusing. Hopefully, understanding why it is necessary will make it less confusing.

The top graph below shows g(t), where the function has value 1 from time 0 to 1. The bottom graph shows the function we require, which has a value of 1 for time -1 to 0. How do we transform one into the other?

One way would be to shift the function to the left by one second. That would be our fudge factor, mentioned above. But we don’t want to do that, because different functions might require shifting by different amounts.

The alternative way is to mirror the function, horizontally, about the y-axis. This operation will always lead to the falling edge of the function being at 0, no matter how wide the raised region of the function is. This is what we will do, and it is actually built into the definition of the convolution integral.

An advantage of this technique is that it is very easy to flip a function about the y-axis. We simply need to negate the argument. For any function g(t), the function g(-t) is the same function, flipped about the y-axis.

In our case, our integral is based on g(t - 𝜏), so to flip it we just need to use g(𝜏 - t) instead:

This integral defines the process of convolution.