Poincare Disk “Raise Perpendicular” Construction

Use the checkboxes to view the steps in the construction

δ

Given: Two points A and B in the Poincare Disk.
Construct: the Poincare line through B that is perpendicular to the 
                Poincare line k thatpasses through A and B.

(Show/Hide) 1. Viewing Poincare line k as the arc of a circle,  
                       let O be the center of k.
(Show/Hide) 2. Construct radius OB, then construct the  
                       Euclidean line m through B that is perpendicular  
                       to OB.
(Show/Hide) 3. Using a previously described construction, let  
                       B' be the inverse point of B, relative to Poincare
                       disk defining circle γ.
(Show/Hide) 4. Construct the Euclidean perpendicular bisector n  
                       of Euclidean segment BB'.
(Show/Hide) 5. Let P be the intersection of m and n, and let δ be
                       the circle centered at P that passes through B.  
(Show/Hide) 6. Let t be the part of δ that lies inside circle γ.

Arc t is the Poincare line through B that is perpendicular to the 
Poincare line through A and B.

A = (-0.8161226770593875, -0.10642407476747019)
B = (-0.0694116799996921, -0.5940720728472707)
k, C, D = PDiskLine(A, B)
O = Center(k)
a = Segment(O, B)
m = OrthogonalLine(B, a)
B' = PDiskInversePoint(B)
c = Segment(B, B')
n = LineBisector(c)
E = Midpoint(c)
P = Intersect(m, n)
α = Angle(O, B, P)
β = Angle(P, B, O)
δ_1 = Angle(O, E, B')
ε = Angle(B', E, O)
δ = Circle(P, B)
G = Point(δ)
t = PDiskRaisePerpendicular(A, B)
H, I = Intersect(δ, γ)
b = false
d = false
e = false
f = false
g = false
h = false

Tool: PDisk Inverse Point (command PDiskInversePoint)
Input: A
Output: A'

a = Ray(Center[Circle[(0, 0), (1, 0)]], A)
b = OrthogonalLine(A, a)
B, C = Intersect(Circle[(0, 0), (1, 0)], b)
c = Segment(Center[Circle[(0, 0), (1, 0)]], B)
d = OrthogonalLine(B, c)
A' = Intersect(a, d)

Tool: PDisk Ray (command PDiskRay)
Input: B, A
Output: e, G

A' = PDiskInversePoint(A)
d = CircumcircleArc(B, A, A')
E, F = Intersect(d, Circle[(0, 0), (1, 0)])
G = If(E ≟ E, E, F)
e = CircumcircleArc(B, A, G)

Tool: PDisk Line (command PDiskLine)
Input: A, B
Output: g, G, H

A' = PDiskInversePoint(A)
d = CircumcircleArc(B, A, A')
E, F = Intersect(d, Circle[(0, 0), (1, 0)])
G = If(E ≟ E, E, F)
f, H = PDiskRay(A, B)
g = CircumcircleArc(G, A, H)

Tool: PDisk Segment (command PDiskSegment)
Input: A, B
Output: h

a = Ray(Center[Circle[(0, 0), (1, 0)]], A)
b = OrthogonalLine(A, a)
C, D = Intersect(Circle[(0, 0), (1, 0)], b)
c = Segment(Center[Circle[(0, 0), (1, 0)]], C)
d = OrthogonalLine(C, c)
E = Intersect(d, a)
e = Circle(E, A, B)
F = Center(e)
f = Segment(A, B)
G = Midpoint(f)
g = Ray(F, G)
H = Intersect(e, g)
h = CircumcircleArc(A, H, B)

Tool: PDisk Distance (command PDiskDistance)
Input: A, B
Output: f, text1

a = Ray(Center[Circle[(0, 0), (1, 0)]], A)
b = OrthogonalLine(A, a)
C, D = Intersect(Circle[(0, 0), (1, 0)], b)
c = Segment(Center[Circle[(0, 0), (1, 0)]], C)
d = OrthogonalLine(C, c)
E = Intersect(d, a)
e = Circle(E, A, B)
F, G = Intersect(e, Circle[(0, 0), (1, 0)])
f: abs(log(Distance[A, F] / Distance[A, G] / (Distance[B, F] / Distance[B, G])))
H = Center(e)
I = Midpoint(A, B)
g = Ray(H, I)
J = Intersect(e, g)
text1: Name[A] + (Name[B]) + "=" + f

Tool: PDisk Angle Measure (command PDiskAngleMeasure)
Input: A, C, B
Output: text1, β

c, D = PDiskRay(C, A)
d, E = PDiskRay(C, B)
F = Center(c)
G = Center(d)
a = Segment(F, C)
b = Segment(G, C)
e = OrthogonalLine(C, a)
f = OrthogonalLine(C, b)
g = OrthogonalLine(A, e)
h = OrthogonalLine(B, f)
A' = Intersect(e, g)
B' = Intersect(f, h)
α = Angle(A', C, B')
β = Angle(Min[α, 360° - α])
text1: "∡" + (Name[A]) + (Name[C]) + (Name[B]) + "=" + β
k = Circle(C, (0.5 * Distance[A, C]))
i = AngularBisector(A', C, B')
j = OrthogonalLine(A', i)
H = Intersect(i, j)
l = Ray(C, H)
I = Intersect(k, l)

Tool: PDisk Raise Perpendicular (command PDiskRaisePerpendicular)
Input: A, B
Output: f

c, C, D = PDiskLine(A, B)
E = Center(c)
a = Segment(E, B)
b = OrthogonalLine(B, a)
F = PDiskInversePoint(B)
d = LineBisector(B, F)
G = Intersect(b, d)
e = Circle(G, B)
H, I = Intersect(e, Circle[(0, 0), (1, 0)])
f = CircumcircleArc(H, B, I)

Tool: PDisk Drop Perpendicular (command PDiskDropPerpendicular)
Input: A, B, C
Output: e, H

A' = Mirror(A, Circle[(0, 0), (1, 0)])
c = Circle(A', A, B)
C' = Mirror(C, Circle[(0, 0), (1, 0)])
C'_1 = Mirror(C, c)
d = Circle(C'_1, C, C')
D, E = Intersect(d, Circle[(0, 0), (1, 0)])
F, G = Intersect(d, c)
g = Segment(Center[Circle[(0, 0), (1, 0)]], G)
G' = Intersect(Circle[(0, 0), (1, 0)], g)
H = If(G' ≟ G', F, G)
e = CircumcircleArc(D, C, E)

Tool: PDisk Angle Bisector (command PDiskAngleBisector)
Input: A, B, C
Output: r

c, D = PDiskRay(B, A)
d, E = PDiskRay(B, C)
F = Center(c)
G = Center(d)
a = Segment(F, B)
b = Segment(G, B)
e = OrthogonalLine(B, a)
f = OrthogonalLine(B, b)
g = OrthogonalLine(A, e)
h = OrthogonalLine(C, f)
A' = Intersect(e, g)
C' = Intersect(f, h)
i = AngularBisector(A', B, C')
j = OrthogonalLine(B, i)
k = Ray(Center[Circle[(0, 0), (1, 0)]], B)
l = OrthogonalLine(B, k)
H, I = Intersect(Circle[(0, 0), (1, 0)], l)
m = Segment(Center[Circle[(0, 0), (1, 0)]], H)
n = OrthogonalLine(H, m)
B' = Intersect(n, k)
p = LineBisector(B', B)
J = Intersect(j, p)
q = Circle(J, B)
K, L = Intersect(q, Circle[(0, 0), (1, 0)])
r = CircumcircleArc(L, B, K)

Tool: PDisk Midpoint (command PDiskMidpoint)
Input: A, B
Output: M

c = PDiskRaisePerpendicular(A, B)
d = PDiskRaisePerpendicular(B, A)
A' = Mirror(A, c)
B' = Mirror(B, d)
a = Ray(Center[Circle[(0, 0), (1, 0)]], A)
b = LineBisector(B', B)
C_1 = Intersect(b, a)
e = Ray(Center[Circle[(0, 0), (1, 0)]], B)
f = LineBisector(A, A')
C_2 = Intersect(f, e)
g = Circle(C_1, B')
h = Circle(C_2, A)
C, D = Intersect(g, h)
k, E, F = PDiskLine(C, D)
p, G, H = PDiskLine(A, B)
K = Center(k)
L = Center(p)
q = Circle(K, D)
r = Circle(L, B)
I, J = Intersect(q, r)
M = If(abs(I)  <  1, I, J)

Tool: PDisk Perpendicular Bisector (command PDiskPerpendicularBisector)
Input: A, B
Output: k, M

c = PDiskRaisePerpendicular(A, B)
d = PDiskRaisePerpendicular(B, A)
A' = Mirror(A, c)
B' = Mirror(B, d)
a = Ray(Center[Circle[(0, 0), (1, 0)]], A)
b = LineBisector(B', B)
C_1 = Intersect(b, a)
e = Ray(Center[Circle[(0, 0), (1, 0)]], B)
f = LineBisector(A, A')
C_2 = Intersect(f, e)
g = Circle(C_1, B')
h = Circle(C_2, A)
C, D = Intersect(g, h)
k, E, F = PDiskLine(C, D)
p, G, H = PDiskLine(A, B)
K = Center(k)
L = Center(p)
q = Circle(K, D)
r = Circle(L, B)
I, J = Intersect(q, r)
M = If(abs(I)  <  1, I, J)

Tool: PDisk Point Reflection (command PDiskPointReflection)
Input: A, M
Output: A'

d = PDiskRaisePerpendicular(A, M)
A' = Mirror(A, d)

Tool: PDisk Circle Center And Point (command PDiskCircleCenterAndPoint)
Input: O, P
Output: c

P' = PDiskPointReflection(P, O)
a = LineBisector(P', P)
b = Ray(Center[Circle[(0, 0), (1, 0)]], O)
A = Intersect(b, a)
c = Circle(A, P)

Tool: PDisk Circle Center And Radius (command PDiskCircleCenterAndRadius)
Input: O, A, B
Output: e

l, C = PDiskPerpendicularBisector(O, A)
D = Center(l)
a = Line(D, B)
c = Circle(D, C)
E, F = Intersect(c, a)
G = If(abs(F)  <  1, F, E)
d, M = PDiskDropPerpendicular(G, C, B)
H = PDiskPointReflection(B, M)
e = PDiskCircleCenterAndPoint(O, H)