Polygons & Metallic Means

We show that associating metallic means with polygons, beyond the golden and silver means, requires looking beyond the side to diagonal relationship.

Table of contents

Introduction
Logic
Example
Program
Metallic mean selection
Visualization tool
Results
References
Links

Introduction

From Polygons, Diagonals, and the Bronze Mean by Antonia R. Buitrago

The Metallic Means Family (MMF) was introduced in 1998 by Vera W. de Spinadel [1998; 1999]. Its members are the positive solutions of the quadratic equation , where the parameters and are positive integer numbers. The more relevant of them are the Golden Mean and the Silver Mean, the first members of the subfamily which is obtained by considering . The members , of this subfamily share properties which are the generalization of the Golden Mean properties. For instance, they all may be obtained by the limit of consecutive terms of certain "generalized secondary Fibonacci sequences" (GSFS) and they are the only numbers which yield geometric sequences:

with additive properties

Figure 1

In Polygons, Diagonals, and the Bronze Mean, Antonia Redondo Buitrago demonstrates that the bronze mean does not appear as a side to diagonal relationship in a regular polygon. Yet there still remains the question of whether or not metallic means appear as a ratio between line segments like in the pentagon, Figure 1.

Logic

Figure 2

Figure 3

Let there be a regular polygon with sides and vertices and a circumradius of 1. Connect each vertex pair with a diagonal and let be a set of intersection points between and each other diagonal:

where is the total number of intersection points for a given diagonal .

Let be the set of lengths between pairs of points in :

For a regular polygon, only a single vertex and its diagonals are needed due to rotational symmetry.

For a vertex, the number of diagonals required to encompass all possible lengths of a regular polygon is due to reflectional symmetry. Reflectional symmetry reduces the number of diagonals by half because diagonals opposite each other across a line of symmetry have the same set of line segments; even-sided polygons also include the diagonal that is the circumdiameter.

Taking figure 2 as an example,

And for figure 3,

Then, the complete set of lengths for a regular polygon with -sides is

Then to test if a metallic mean exists as a ratio of lengths in , we find the intersection between and :

If the intersection is not empty then the metallic mean exists as a ratio of lengths.

Example

Let's take a look at a simple example, the pentagon, which has an established relationship with the first metallic mean, the golden mean . The pentagon has the characteristic that any diagonal is representative of all diagonals so we'll use the blue diagonal from figure 1.

Let be the complete set of line segments for a pentagon

and the lengths are

So to test for the first metallic mean, we multiply by , where ,

and we find that all but one is a member of :

Additionally we can test for the fourth metallic mean by multiplying by (), where ,

and we find that only one is a member of :

Program

Download zip | GitHub repo

install required packages: pip3 install -r requirements.txt

usage: main.py [-h] [--dps DPS] [--buffer BUFFER] [-s] n mean_id

positional arguments:
  n                   # of sides for regular polygon
  mean_id             metallic mean to test for

optional arguments:
  -h, --help          show this help message and exit
  --dps DPS           decimal precision [default: 50]
  --buffer BUFFER     decimal precision buffer [default: 5]
  -s, --show_matches  show matches

examples: 
python3 main.py 5 1
python3 main.py 8 2
python3 main.py 13 3

The program is written in Python3.7 using mpmath for arbitrary-precision. mpmath is required because double-precision has an insufficient number of significant digits to account for the very tiny variations in lengths which result in false positives.

mpmath is set to 55 decimal-places, an arbitrarily sufficient number, with 5 decimal-places as a buffer to account for minor cumulative computational errors. Then the computed mpmath values are converted to decimal string literals with 50 significant digits allowing for string comparisons of relatively precise decimal values.

lib/utils.py

import mpmath as mp

# nstr() is a mpmath function that converts an mpf or mpc
# to a decimal string literal with n significant digits.
def getkey(val): return mp.nstr(val, SIG_DIGITS)

# return metallic mean for specified n
def mmf(n): return (n+mp.sqrt(n*n+4))/2

lib/vector2.py

import mpmath as mp
from .utils import getkey

class Vector2(object):
    def __init__(self, x=0, y=0):
        if mp.almosteq(x, 0): x = 0.0
        if mp.almosteq(y, 0): y = 0.0

        self.x = mp.mpf(x)
        self.y = mp.mpf(y)

    def __add__(self, other):
        return Vector2(self.x+other.x, self.y+other.y)

    def __sub__(self, other):
        return Vector2(self.x-other.x, self.y-other.y)

    def __mul__(self, other):
        if isinstance(other, Vector2):
            return Vector2(self.x*other.x, self.y*other.y)
        else:
            return Vector2(self.x*other, self.y*other)

    def __str__(self):
        return '<Vector2 x=%s y=%s>'%(str(self.x)[:10], str(self.y)[:10])

    def __repr__(self):
        return self.__str__()

    def __hash__(self):
        return hash((getkey(self.x), getkey(self.y)))

    def __eq__(self, other):
        return mp.almosteq(self.x, other.x) and mp.almosteq(self.y, other.y)

    def cross(self, other):
        return self.x*other.y - self.y*other.x

    def dist(self, other):
        return (self-other).len()

    def dot(self, other):
        return self.x*other.x + self.y*other.y

    def len(self):
        return mp.sqrt(self.dot(self))

lib/linesegment.py

import mpmath as mp

class LineSegment(object):
    def __init__(self, start, end):
        self.start = start
        self.end = end
        self.vec = end-start

    def intersect(self, other):
        numerator = (other.start-self.start).cross(other.vec)
        denominator = self.vec.cross(other.vec)

        if (not numerator or mp.isnormal(numerator)) and mp.isnormal(denominator):
            ratio = numerator/denominator
            return self.vec*ratio + self.start

        return None

1. Generate the vertices of the polygons and connect each pair of vertices with a diagonal.

main.py

# n is polygon size
theta = 2*pi/n

# calculate vertices
vertices = []
for i in range(n):
    x = cos(theta*i)
    y = sin(theta*i)
    vertex = Vector2(x, y)
    vertices.append(vertex)

# generate diagonals
diagonals = []
for i in range(n):
    for j in range(i+1, n):
        v1 = vertices[i]
        v2 = vertices[j]
        diag = LineSegment(v1, v2)
        diagonals.append(diag)

2. For each diagonal calculate and collect intersection points between itself and other diagonals. Then within the same iteration calculate and collect distances (lengths) between pairs of points in a dictionary using a consistent key for the mpmath value.

main.py

# calculate line segments lengths
lengths = dict()
for i, diag in enumerate(diagonals[:n//2]):
    # find intersection points
    points = set()
    for other in diagonals[i+1:]:
        # find the intersection point between diagonals
        point = diag.intersect(other)

        # ensure point lies within unit circle
        if point and point not in points and abs(point) <= 1:
            points.add(point)

    # calculate lengths for pairs of points on the same diagonal
    if len(points):
        points = list(points)
        for j, point1 in enumerate(points):
            for point2 in points[j+1:]:
                dist = point2.dist(point1)
                key = getkey(dist)
                if key not in lengths:
                    lengths[key] = dist

3. Iterate over the set and multiply each length by a metallic mean and test to see if the resultant value is contained in the length set.

main.py

# test for specified metallic mean
count = 0
for k,l in lengths.items():
    key = getkey(mean*l)
    if key in lengths:
        count += 1

Metallic mean selection

We could test every polygon with every metallic mean but eventually the number of lengths grows too large to compute by hand or a modern desktop computer. So it is prudent to find a method for determining appropriate metallic means for polygons or conversely, a method for identifying prospective polygons for metallic means.

Now back to the definition of a metallic mean. They are the positive solutions of the characteristic equation when and is a positive integer. Then the quadratic equation is

and the quadratic formula to compute the means is

Selecting appropriate polygons to test for metallic means appears to be related either to the discriminant, , or the simplified form of the radical . metallic means that are a power of a lower mean appear alongside their lower counterpart.

In the case of , the golden mean , the discriminant is 5 and the simplified radical is , associating the metallic mean with the pentagon and polygons with a number of sides that is a multiple of 5. For , , the discriminant is 20 and the simplified radical is which is also associated with the pentagon and polygons with a number of sides that is a multiple of 5. For , , the discriminant is 125 and the simplified radical is but does not appear until is a multiple of 10 or 15. Similarily appears when is a multiple of 20 or 30 and appears when is a multiple of 30.

In the case of , the discriminant is and the radical is , associating to the tridecagon.

In the case of , the discriminant is and the simplified radical is . The associated polygon is a 40-gon.

In the case of , the discriminant is 68 but the associated regular polygon is a heptadecagon (), which relates to the simplified radical .

* As of writing this, I have been unable to determine values for when is 7,9 or 10 for .

Visualization tool

Metallic Means results review tool thumbnail

Tool to visualize the Metallic Mean matches.

Left & right arrow keys – pagination
Up & down arrow keys – list selection
Spacebar – Play/Pause

Results

	-gons	Trigonometric expression
1	5x
2	8x
3	13x	Simplified (Wikipedia) Original
4	5x
5	29x	Simplified (Wikipedia) Original
6	40x
7	53, ~~106~~
8	17x
9	85
10	52, ~~104~~
11	10+5x
12	74

If anyone happens to identify 7, 9 or 10 please let me know at tellerm<at>protonmail.com or on Twitter @tellerm. Thank you.

References

[1] Vera W. de Spinadel. (1999). The Family of metallic means. Visual Mathematics 1, 3. http://members.tripod.com/vismath1/spinadel/

[2] Antonia R. Buitrago. (2007). "Polygons, Diagonals and the Bronze Mean", Nexus Network Journal 9: 321.