<jupyter_start><jupyter_text>Materialien zu aglaAutor: <NAME> - <EMAIL> Hyperbolische Geometrie   Isometrien<jupyter_code>%run agla/start<jupyter_output><empty_output><jupyter_text>Isometrien im *D*-Modell Isometrische Abbildungen haben die Form (im Komplexen) $\;\;\;  f(z) = \frac {a z+\bar{b}} {b z+\bar{a}},  \;\;\; g(z) = \frac {a\bar{z}+\bar{b}} {b \bar{z}+\bar{a}} \;\;\; $ mit $\;\;\; \left|\begin{matrix}a & \bar{b}\\ b & \bar{a}\end{matrix}\right| \gt 0$ Sie sind aus einfacheren Abbildungen zusammengesetzt, die Inversionen an hyperboli-schen Geraden darstellen. Aus geometrischen Überlegungen ist ableitbar: Für die Inversion (Spiegelung) an einem Durchmesser des Einheitskreises ist$ f(z) = \frac{c \bar{z}} {\bar{c}} ,  \;\;\;\quad n = -c\, i \;$  entspricht dem Normalenvektor der euklidischen Geraden, die den Durchmesser enthältFür die Inversion an einem Kreisbogen ist$ f(z) = \frac{c \bar{z} + i} {-i \bar{z} + \bar{c}} ,  \;\;\;\quad m = c\, i \;\;$  entspricht dem Mittelpunkt des Kreises, der den Bogen  enthält; sein Radius ist $ \sqrt{\vert m \vert ^2-1} \;\\$ ($m\;$ muss außerhalb des Einheitskreises liegen)  Einige nützliche Funktionen<jupyter_code>def c2v(z):   # komplexe Zahl --> Vektor
    return v(re(z), im(z))  

def c2p(z):   # komplexe Zahl --> hyperbolischer Punkt
    return hPunkt(re(z), im(z))   

def v2c(v):   # Vektor --> komplexe Zahl
    return v.x + v.y*I            
# Hyperbolische Punkte

A = hPunkt(-0.2, 0.5); B = hPunkt(0.4, 0.1); OH = hPunkt(0, 0)
A.e, B.e, OH.e<jupyter_output><empty_output><jupyter_text>Inversion an an einem Durchmesser<jupyter_code>d = hGerade(OH, A)
d.träger
P = hPunkt(-0.6, 0.3)   # der zu spiegelnde hyperbolische Punkt
Q = d.inv(P)            # das Bild bei der Spiegelung (hyperbolischer Punkt)
Q.e.dez                 # der zugehörige euklidische Punkt mit dezimalen 
                        # Koorinaten
sicht_box(-1.1, 1.1)
zeichne(EinhKreis2, d, OH, A, [P, grün], [Q, rot, 2], hGerade(P, Q), achsen=nein)<jupyter_output><empty_output><jupyter_text>Inversion an an einem Kreisbogen<jupyter_code>k = hGerade(A, B)
k.träger
Q1 = k.inv(P)              
Q1.e.dez 
zeichne(EinhKreis2, k, A, B, [P, grün,], [Q1, rot, 2], hStrecke(P, Q1), achsen=nein)<jupyter_output><empty_output><jupyter_text>Illustration, dass es sich um eine Spiegelung handelt(Zweimaliges Spiegeln hintereinander ergibt die Identität)<jupyter_code>P = hPunkt(0.56067, -0.341294)   # Urbild
Q = k.inv(P)                     # Spiegelbild          
P1 = k.inv(Q)                    # Bild des Spiegelbildes               
P1.e.dez , P.e.dez               # ist das Urbild<jupyter_output><empty_output><jupyter_text>Eine Isometrie zur Verschiebung des Ursprungs $P(r, s) \; $  sei ein beliebiger Punkt innerhalb des Einheitskreises, dann überführt diefolgende Isometrie $f$ den Ursprung in diesen Punkt<jupyter_code>r, s = Symbol('r', real=True), Symbol('s', real=True)
a = (r-s)/(r^2+s^2) + (r+s)/(r^2+s^2)*I
b = 1+I

def f(z):
    return (a*conjugate(z)+conjugate(b)) / (b*conjugate(z)+conjugate(a))

f(z)
einfach(f(z))
det(v(a, b), v(conjugate(b), conjugate(a)))<jupyter_output><empty_output><jupyter_text>die Determinante ist positiv, da $\; r^2+s^2<1 \;$ ist<jupyter_code>z = f(0)               # Bild des Ursprungs (komplexe Zahl)
c2v(f(0)).einfach      # zugehöriger Punkt<jupyter_output><empty_output><jupyter_text>Die inverse Isometrie $F$ wird in folgender Form gewonnen<jupyter_code>d = Symbol('d')

F = lambda z: (c*z+conjugate(d))/(d*z+conjugate(c))
F(z), einfach(F(z))<jupyter_output><empty_output><jupyter_text>wobei $\; c,\; \bar{c}, \; d\; $ und $ \; \bar{d} \;$ die Elemente der Umkehrmatrix$\; \left(\begin{matrix}c & \bar{d}\\ d & \bar{c}\end{matrix}\right) \;$ der zur Abbildung $f$ gehörigen Matrix$\; \left(\begin{matrix}a & \bar{b}\\ b & \bar{a}\end{matrix}\right) \;$ sind<jupyter_code>M = v(a, b) | v(conjugate(b), conjugate(a))
M
MI = M^-1
MI
(M * MI).einfach   # Kontrolle
c, d = MI[0, 0], MI[1, 0]
c, d
def F(z): 
    return (c*z+conjugate(d)) / (d*z+conjugate(c))<jupyter_output><empty_output><jupyter_text>Diese Abbildung überführt die Zahl $\;r+i s \;$ nach 0<jupyter_code>einfach(F(r+s*I))<jupyter_output><empty_output><jupyter_text>Isometrisches Bild eines Dreiecks<jupyter_code># Eine Abbildung wird gewählt

a, b = 2-5*I, -3+2*I

det(v(a, b), v(conjugate(b), conjugate(a)))
def f(z): 
    return (a*conjugate(z)+conjugate(b))/(b*conjugate(z)+conjugate(a))

f(z)
# Das Dreieck

A = hPunkt(0.7, 0.1); B = hPunkt(-0.3, 0.5); C = hPunkt(0.6, 0.3)
dd = hDreieck(A, B, C)
# Das Bild des Dreiecks

zA, zB, zC = f(v2c(A.e)), f(v2c(B.e)), f(v2c(C.e))

AA, BB, CC = c2p(zA), c2p(zB), c2p(zC)

db = hDreieck(AA, BB, CC)
sicht_box(-1.1, 1.1)
zeichne(EinhKreis2, dd, [db, rot], achsen=nein)
# Die Dreiecke sind kongruent

dd.laengen
db.laengen
dd.winkel
db.winkel
dd.fläche, db.fläche<jupyter_output><empty_output><jupyter_text>Isometrien im *H*-Modell Isometrische Abbildungen im $H$-Modell sind Parallelverschiebungen entlang der $x$- bzw. $y$-Achse um eine Größe $d$ und Drehungen um die z-Achse um einen Winkel $\phi$ mit den Matrizen<jupyter_code>def M1(d):
    return Matrix(v(cosh(d), 0, sinh(d)), v(0, 1, 0), v(sinh(d), 0, cosh(d)))

def M2(d):
    return Matrix(v(1, 0, 0), v(0, cosh(d), sinh(d)), v(0, sinh(d), cosh(d)))
    
def M3(phi):    
    return Matrix(v(cos(phi), sin(phi), 0), v(-sin(phi), cos(phi), 0), v(0, 0, 1))
M1(d), M2(d), M3(phi)<jupyter_output><empty_output><jupyter_text>Diese Abbildungen lassen die quadratische Form  $\sigma$  invariant und erhalten somit die Metrik<jupyter_code>x1, x2, y1, y2, z1, z2 = symbols('x_1, x_2, y_1 y_2, z_1, z_2')
P1 = v(x1, y1, z1); P2 = v(x2, y2, z2)   # 2 Punkte
P1, P2
def sigma(P, Q):             # die quadratische Form
    return -P.x*Q.x - P.y*Q.y + P.z*Q.z

sigma(P1, P2)
PP, QQ = M1(d) * P1, M1(d) * P2; einfach(sigma(PP, QQ))   # Nachweis ...
PP, QQ = M2(d) * P1, M2(d) * P2; einfach(sigma(PP, QQ))   # der ...
PP, QQ = M3(phi) * P1, M3(phi) * P2; einfach(sigma(PP, QQ))   # Invarianz<jupyter_output><empty_output><jupyter_text>Isometrische Dreiecke<jupyter_code>A = hPunkt(0.2, -1, 'h')
B = hPunkt(0.5, 0.3,'h')
C = hPunkt(-2, 0.5, 'h')
A.e, B.e, C.e
d = hDreieck(A, B, C)   # das Ausgangsdreieck
M1 = M1(1.7)   # Verschiebung entlang der x-Achse um 1.7

A1 = hPunkt(M1*A.e)
B1 = hPunkt(M1*B.e)
C1 = hPunkt(M1*C.e)

d1 = hDreieck(A1, B1, C1)

A1.e, B1.e, C1.e

# mit M2 kann analog verfahren werden

M3 = M3(180)     # Drehung um die z-Achse um 180°

A3 = hPunkt(M3*A.e)
B3 = hPunkt(M3*B.e)
C3 = hPunkt(M3*C.e)

d3 = hDreieck(A3, B3, C3)

A3.e, B3.e, C3.e
sicht_box(5)
zeichne([HypSchale, gelb], [d, 2], [d3, 2, rot])<jupyter_output><empty_output><jupyter_text>Die drei Dreiecke sind in der Tat kongruent, ihre Seitenlängen und Innenwinkel stimmen überein<jupyter_code>d.längen
d1.längen
d3.längen
d.winkel
d1.winkel
d3.winkel<jupyter_output><empty_output><jupyter_text>Parkettierung mit Fünfecken im *D*-Modell siehe [Rosebrock]Die Konstruktion ist gegenwärtig **SEHR** zeitaufwändig; es werden bei jedem Schritt nur ein bis zwei Fünfecke hinzugefügt<jupyter_code># Das Fundamentaldreieck   [Rosebrock S150]

wia = pi/2; wib = pi/5; wic = pi/4

# Die Seitenlängen

# Die Berechnung erfolgt auf der Grundlage des Halbseitensatzes der 
# sphärischen Geometrie; R wird durch I ersetzt

s = 1/2 * (wia + wib + wic)

c = (N(abs(2*R*arctan(sqrt(-cos(s)*cos(s-wic)/cos(s-wia)/cos(s-wib)))))).subs(R, I)

a = (N(abs(2*R*arctan(sqrt(-cos(s)*cos(s-wia)/cos(s-wib)/cos(s-wic)))))).subs(R, I)

b = (N(abs(2*R*arctan(sqrt(-cos(s)*cos(s-wib)/cos(s-wia)/cos(s-wic)))))).subs(R, I)

a, b, c
# Die Eckpunkte

B = hPunkt(0, 0)

h = Symbol('h')
A = hPunkt(0, h); h = nsolve(A.abstand(B)-c, -0.5)
A = hPunkt(0, N(h))

t = Symbol('t')
g = Gerade(v(0, 0), v(1, tan(3/10*pi)))
C = hPunkt(g.pkt(t)); t = nsolve(C.abstand(B)-a, -0.5)
C = hPunkt(g.pkt(N(t)))

d = hDreieck(A, B, C)

A.e.dez, B.e, C.e.dez
sicht_box(1.1)
zeichne(EinhKreis2, [A, rot, 2], [B, gruen, 2], [C, blau, 2], d, achsen=nein)<jupyter_output><empty_output><jupyter_text>Aus diesem Dreieck kann durch Spiegelungen an den auf Durchmessern liegenden Seiten das Ausgangs-5-Eck erzeugt werdenHier wird es durch euklidische Drehungen des Eckpunktes $C$ erzeugt<jupyter_code># Das Ausgangs-5-Eck

ecken = [hPunkt(C.e.bild(drehung(O2, i*360/5), exakt=False)) for i in range(5)]
ecken += [ecken[0]]
seiten = [hStrecke(ecken[i], ecken[i+1]) for i in range(5)]
# Das Fünfeck ist regulär

[ecken[i].abstand(ecken[i+1]) for i in range(5)]
sicht_box(-1.1, 1.1)
zeichne(EinhKreis2, *[[seiten[i], rot] for i in range(5)], achsen=nein)
# Durch Inversion des Fünfecks an seinen Seiten wird die nächste  
# Generation von Fünfecken erzeugt

seiten0 = [seiten[0].gerade.inv(s) for s in seiten]   # Inversion an 
                                            # der 0. (unteren) Seite
seiten1 = [seiten[1].gerade.inv(s) for s in seiten]   # Inversion an 
                                       # der 1. (angrenzenden) Seite
sicht_box(-1.1, 1.1)
zeichne(EinhKreis2, 
        [seiten0[1], blau],  [seiten0[2], blau],  [seiten0[3], blau],  [seiten0[4], blau],
        [seiten1[0], blau],  [seiten1[2], blau],  [seiten1[3], blau],  [seiten1[4], blau],
        *[[seiten[i], rot] for i in range(5)], achsen=nein)

g0 = [hGerade(ecken[i], ecken[i+1]) for i in range(5)]   # 0. Geraden-
                                                         # Generation
zeichne(EinhKreis2, [seiten0[2], blau, 2], [seiten0[3], rot, 2],
        *[g0[i] for i in range(5)], achsen=nein)
# 1. Geraden-Generation 

g10 = seiten0[3].gerade
g11 = seiten0[2].gerade

dr = drehung(O2, 360/5)
P0, Q0 = g10.e.pkt(30), g10.e.pkt(45)               # Punkte innerhalb 
PP0, QQ0 = hPunkt(P0.bild(dr)), hPunkt(Q0.bild(dr))
g12 = hGerade(PP0, QQ0)
P1, Q1 = g11.e.pkt(90), g11.e.pkt(120)              # des Einheitskreises
PP1, QQ1 = hPunkt(P1.bild(dr)), hPunkt(Q1.bild(dr)) 
g13 = hGerade(PP1, QQ1)
sicht_box(-1.1, 1.1)
zeichne(EinhKreis2, [seiten0[2], blau, 2], [seiten0[3], rot, 2],
        g10, g11, g12, g13,
        *[g0[i] for i in range(5)], achsen=nein)
# Zur Berechnung der 2. Geraden-Generation wird wieder invertiert

seiten_rot = [seiten0[3].gerade.inv(seiten0[i]) for i in range(5)]
seiten_blau = [seiten0[2].gerade.inv(seiten0[i]) for i in range(5)]
zeichne(EinhKreis2, [seiten0[2], blau, 2], [seiten0[3], rot, 2],
        g10, g11, 
        [seiten_rot[0], rot, 2], [seiten_rot[1], blau, 2], seiten_rot[2], seiten_rot[4],
        [seiten_blau[0], blau, 2], seiten_blau[1], seiten_blau[2], seiten_blau[3],  [seiten_blau[4], rot, 2],
        *[g0[i] for i in range(5)], achsen=nein)
g20 = seiten_rot[0].gerade
g21 = seiten_rot[1].gerade
g22 = seiten_blau[4].gerade
g23 = seiten_blau[0].gerade
zeichne(EinhKreis2, 
        g10, g11,
        g20, g21, g22, g23,
        *[g0[i] for i in range(5)], achsen=nein)
# Überprüfung, dass die Spiegelung an einer "Seitenkante" ebenfalls zu einem 
# kongruenten Fünfeck führt

seiten2 = [seiten0[1].gerade.inv(seiten0[i]) for i in range(5)]
zeichne(EinhKreis2, 
        g10, g11,
        *[[seiten0[i], blau, 3] for i in range(5)], 
        *[[seiten2[i], grün, 3] for i in (0, 2, 3, 4)], 
        *[g0[i] for i in range(5)], achsen=nein)<jupyter_output><empty_output><jupyter_text>AnmerkungDie verwendete Literatur ist mit der Hilfe-Funktion einsehbar<jupyter_code>#Hilfe(h=23)    # entfernen<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.177935630974305, 'fraction_numerical': 0.03998947645356485, 'mean_word_length': 3.909169177787344, 'pattern_counts': {'":': 0, '<': 76, '<?xml version=': 0, '>': 78, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 7, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '18', 'dir': 'jupyter-structured-clean-dedup', 'id': '483319', 'license': 'Apache-2.0', 'n_tokens_mistral': 5489, 'n_tokens_neox': 5379, 'n_words': 1141, 'path': 'agla/mat/hyp_geometrie_Isometrien.ipynb', 'repo_name': 'HBOMAT/AglaUndZufall', 'size': '11421'}