9
$\begingroup$

I asked this question on MSE here.

Given a non-regular pentagon $A_1B_1C_1D_1E_1$ with no two adjacent angle having a sum of 360 degrees, from the pentagon $A_nB_nC_nD_nE_n$ construct the pentagon $A_{n+1}B_{n+1}C_{n+1}D_{n+1}E_{n+1}$ as follows:

  • $A_{n+1}$ is the intersection between the angle bisectors of $\angle C_n $ and $\angle D_n$.
  • $B_{n+1}$ is the intersection between the angle bisectors of $\angle D_n$ and $\angle E_n$.
  • $C_{n+1}$ is the intersection between the angle bisectors of $\angle E_n$ and $\angle A_n$.
  • $D_{n+1}$ is the intersection between the angle bisectors of $\angle A_n$ and $\angle B_n$.
  • $E_{n+1}$ is the intersection between the angle bisectors of $\angle B_n$ and $\angle C_n$.

(the two opposite angles) I am allowing self-intersecting polygons in this constructions.

The reason why I chose this construction is that the point $A_{n+1}$ is the only point that doesn't depend on $A_n$.

My question is if this process is repeated indefinitely would the sequences ${A_n}$ , ${B_n}$ , ${C_n}$ , $D_n $ and $E_n$ converge ? and if they converge what is the limit? if they din't always converge what are the necessary conditions that the pentagon $A_1B_1C_1D_1E_1$ should satisfy so the five sequences converge ?

There are only four possible scenarios:

  1. The points will converge.
  2. The points will eventually trapped on a loop.
  3. The points will diverge completely.
  4. Two or more points coincide, or two adjacent angle have a sum of 360 degrees ending the sequence.

I tried to draw the first few pentagons to see if the point will converge or not.

enter image description here enter image description here

Here is the first 50 pentagons in a zoom-in animation: enter image description here

I conjecture that the sequences converge to a single point for all non-regular pentagons. If convergence occurs, how can we determine the limit point based on the initial pentagon? If the limit point exist what interesting properties does it have for the pentagon?

Here is a Geogebra file that have the first 50 pentagons.

This is a python code than can calculate $A_n, B_n , C_n ,D_n ,E_n$

import math


print("Number of pentagons")
n=int(input() )
m=max(n,50)
m= min(m, 200)
from decimal import Decimal
import decimal

decimal.getcontext().prec = m
Decimal(10)**(-m)


# enter your coordinates here
A=[Decimal(0),Decimal(0)]
B=[Decimal(0),Decimal(0)]
C=[Decimal(0),Decimal(0)]
D=[Decimal(0),Decimal(0)]
E=[Decimal(0),Decimal(0)]

print("Enter the coordinates of A_1")
A[0]=Decimal(float (input() ))
A[1]=Decimal(float (input() ))
print("Enter the coordinates of B_1")
B[0]=Decimal(float (input() ))
B[1]=Decimal(float (input() ))
print("Enter the coordinates of C_1")
C[0]=Decimal(float (input() ))
C[1]=Decimal(float (input() ))
print("Enter the coordinates of D_1")
D[0]=Decimal(float (input() ))
D[1]=Decimal(float (input() ))
print("Enter the coordinates of E_1")
E[0]=Decimal(float (input() ))
E[1]=Decimal(float (input() ))
X=[Decimal(0),Decimal(0)]
Y=[Decimal(0),Decimal(0)]
Z=[Decimal(0),Decimal(0)]
W=[Decimal(0),Decimal(0)]
T=[Decimal(0),Decimal(0)]

#defining some useful functions--------------------------------------------
def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]
    return result 
def crs(a, b):
    result = [-Decimal(0.5)*((Decimal(a[0]*b[1])-Decimal(a[1]*b[0])))]
    return result
def dis(a,b):
    result =[Decimal(math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2))]
    return result 




for i in range (2,n+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n--------------------------------------------
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n--------------------------------------------
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n--------------------------------------------
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n--------------------------------------------
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n--------------------------------------------
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)



    A=X
    B=Y
    C=Z
    D=W
    E=T
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")
    print("\n")

Another thing that supports the convergence of the series that no matter how many times I used that random function in python with the sequence the result always converge (suggesting it always converge except some zero measure set )

import math

import random

print("Number of pentagons")
n=int(input() )
m=max(n,50)
m= min(m, 200)
from decimal import Decimal
import decimal

decimal.getcontext().prec = m
Decimal(10)**(-m)


# enter your coordinates here
A=[Decimal(0),Decimal(0)]
B=[Decimal(0),Decimal(0)]
C=[Decimal(0),Decimal(0)]
D=[Decimal(0),Decimal(0)]
E=[Decimal(0),Decimal(0)]


A[0]=Decimal(random.random() )
A[1]=Decimal(random.random())

B[0]=Decimal(random.random())
B[1]=Decimal(random.random())

C[0]=Decimal(random.random())
C[1]=Decimal(random.random())

D[0]=Decimal(random.random())
D[1]=Decimal(random.random())

E[0]=Decimal(random.random())
E[1]=Decimal(random.random())
X=[Decimal(0),Decimal(0)]
Y=[Decimal(0),Decimal(0)]
Z=[Decimal(0),Decimal(0)]
W=[Decimal(0),Decimal(0)]
T=[Decimal(0),Decimal(0)]

#defining some useful functions--------------------------------------------
def v(a,b):
    result= [b[0]-a[0], b[1]-a[1]]
    return result 
def crs(a, b):
    result = [-Decimal(0.5)*((Decimal(a[0]*b[1])-Decimal(a[1]*b[0])))]
    return result
def dis(a,b):
    result =[Decimal(math.sqrt((a[0]-b[0])**2+(a[1]-b[1])**2))]
    return result 




for i in range (2,n+1):
    AB= dis(A,B)[0]
    BC= dis(B,C)[0]
    CD= dis(C,D)[0]
    DE= dis(D,E)[0]
    EA= dis(E,A)[0]



    #Here to calculate A_n--------------------------------------------
    x=   CD*crs(v(D,C),v(D,E))[0]
    y=  -CD*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(C,B),v(C,D))[0]
    z=  -CD*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(D,C),v(D,E))[0]
    t=   CD*crs(v(C,B),v(C,D))[0]
    X[0]=(x *B[0]+y*C[0]+z*D[0]+t*E[0])/(x+y+z+t)
    X[1]=(x *B[1]+y*C[1]+z*D[1]+t*E[1])/(x+y+z+t)



    #Here to calculate B_n--------------------------------------------
    x=   DE*crs(v(E,D),v(E,A))[0]
    y=  -DE*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(D,C),v(D,E))[0]
    z=  -DE*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(E,D),v(E,A))[0]
    t=   DE*crs(v(D,C),v(D,E))[0]
    Y[0]=(x *C[0]+y*D[0]+z*E[0]+t*A[0])/(x+y+z+t)
    Y[1]=(x *C[1]+y*D[1]+z*E[1]+t*A[1])/(x+y+z+t)



    #Here to calculate C_n--------------------------------------------
    x=   EA*crs(v(A,E),v(A,B))[0]
    y=  -EA*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(E,D),v(E,A))[0]
    z=  -EA*crs(v(E,D),v(E,B))[0]+  2*DE*crs(v(A,E),v(A,B))[0]
    t=   EA*crs(v(E,D),v(E,A))[0]
    Z[0]=(x *D[0]+y*E[0]+z*A[0]+t*B[0])/(x+y+z+t)
    Z[1]=(x *D[1]+y*E[1]+z*A[1]+t*B[1])/(x+y+z+t)



    #Here to calculate D_n--------------------------------------------
    x=   AB*crs(v(B,A),v(B,C))[0]
    y=  -AB*crs(v(C,B),v(C,E))[0]+  2*BC*crs(v(A,E),v(A,B))[0]
    z=  -AB*crs(v(A,E),v(A,C))[0]+  2*EA*crs(v(B,A),v(B,C))[0]
    t=   AB*crs(v(A,E),v(A,B))[0]
    W[0]=(x *E[0]+y*A[0]+z*B[0]+t*C[0])/(x+y+z+t)
    W[1]=(x *E[1]+y*A[1]+z*B[1]+t*C[1])/(x+y+z+t)



    #Here to calculate E_n--------------------------------------------
    x=   BC*crs(v(C,B),v(C,D))[0]
    y=  -BC*crs(v(D,C),v(D,A))[0]+  2*CD*crs(v(B,A),v(B,C))[0]
    z=  -BC*crs(v(B,A),v(B,D))[0]+  2*AB*crs(v(C,B),v(C,D))[0]
    t=   BC*crs(v(B,A),v(B,C))[0]
    T[0]=(x *A[0]+y*B[0]+z*C[0]+t*D[0])/(x+y+z+t)
    T[1]=(x *A[1]+y*B[1]+z*C[1]+t*D[1])/(x+y+z+t)



    A=X
    B=Y
    C=Z
    D=W
    E=T
    print(f"A_{i}= {A}")
    print(f"B_{i}= {B}")
    print(f"C_{i}= {C}")
    print(f"D_{i}= {D}")
    print(f"E_{i}= {E}")
    print("\n")
Improve this question
$\endgroup$
4
  • $\begingroup$ This is an interesting question, but please wait a few days at least after posting something on Mathstackexchange before also posting here. $\endgroup$
    – JoshuaZ
    Commented Jun 26 at 11:49
  • 2
    $\begingroup$ amazing graphics!!! $\endgroup$
    – mathworker21
    Commented Jun 26 at 12:08
  • 3
    $\begingroup$ Are you confident that by the 50th iteration you aren't just drawing roundoff error? $\endgroup$
    – Gerry Myerson
    Commented Jun 27 at 0:56
  • 1
    $\begingroup$ @GerryMyerson It's certainly possible that the apparent convergence in the animation after 50 iterations could be due to roundoff error accumulating over the calculations. Including 50 pentagons was mainly to provide a visual illustration of the sequence's behavior. It's difficult to definitively determine convergence from a finite number of iterations, especially with potential for numerical errors. I $\endgroup$
    – pie
    Commented Jun 27 at 10:05

1 Answer 1

Reset to default
7
+50
$\begingroup$

This is a great question for the theory of dynamics of polygon iterations. The best-known map of this kind is undoubtedly the pentagram map. The pentagram map sends a pentagon to the pentagon formed by the five diagonals; Wikipedia explains it best. Richard Schwartz proved that there is a limit point of the kind you describe if the starting pentagon is strictly convex. Amazingly, Max Glick proved the coordinates of that limit point are algebraic functions (using at worst cube roots) of the original pentagon's coordinates. Further studies were made by Aboud-Izosimov that give a kind of theoretical explanation for why that limit point exists.

Questions like this can be difficult and are very sensitive to the particular operations you use. For instance, unlike the pentagram map, your map does not preserve convexity. Neither is it a rational map – the coordinates of the image introduce square roots in general. All this makes geometric intuition difficult to apply. All this is to say, to my eye this is a worthwhile research problem that shouldn't have an out-of-the-box answer from general theory. Here are two questions to get you thinking:

  1. Why not start with quadrilaterals, or even triangles?

  2. If you draw the "exterior" angle bisector, that is, the perpendicular to the angle bisector, it looks like you get a convexity-preserving map. Do these tend to regular polygons up to resizing?

References:

Glick, Max, The limit point of the pentagram map, Int. Math. Res. Not. 2020, No. 9, 2818-2831 (2020). ZBL1484.37075.

Aboud, Quinton; Izosimov, Anton, The limit point of the pentagram map and infinitesimal monodromy, Int. Math. Res. Not. 2022, No. 7, 5383-5397 (2022). ZBL1486.52001.

Schwartz, Richard, The pentagram map, Exp. Math. 1, No. 1, 71-81 (1992). ZBL0765.52004.

Improve this answer
$\endgroup$
1
  • 1
    $\begingroup$ "Why not start with quadrilaterals, or even triangles?" I have a similar question about triangles here $\endgroup$
    – pie
    Commented Jun 29 at 9:00

Not the answer you're looking for? Browse other questions tagged or ask your own question.