I asked this question on MSE [here][1].
-----
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][2]][2]
[![enter image description here][3]][3]
Here is the first 50 pentagons in a zoom-in animation:
[![enter image description here][4]][4]
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][5] 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$
```python
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 )
```python
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")
```
[1]: https://math.stackexchange.com/questions/4937560/does-the-sequence-formed-by-intersecting-angle-bisector-in-a-pentagon-converges
[2]: https://i.sstatic.net/8M3RUVFT.png
[3]: https://i.sstatic.net/2fbkfWiM.png
[4]: https://i.sstatic.net/Ddnk9Px4.gif
[5]: https://www.geogebra.org/classic/tywbvnyg