Prüfungsvorleistungen

Vergleichbar zu Modulen aus dem Bachelor-Studium, gibt es in Diskrete Strukturen ein normales Praktikum mit mehreren Terminen und Aufgaben. Die Besonderheit liegt jedoch darin, dass es nur drei Praktika gibt, die zu einem beliebigen Zeitpunkt vor der Prüfung abgegeben werden können. Aufgrund der vielen Hausarbeiten und Präsentationen in diesem Semester hat sich diese Freiheit als äußerst nützlich erwiesen. Die Aufgaben haben einen starken Bezug zur Vorlesung und helfen durch die Bearbeitung beim weiterführenden Verständnis. Im Rahmen des Praktikums werden die Ergebnisse als Präsentation vorgestellt und mit dem Dozenten diskutiert.

Prüfung

In der Klausur werden alle Themengebiete des Skripts angeschnitten. Die Aufgaben beziehen sich auf (Unter-)Gruppen, Gruppenoperationen, k-Teilmengen, Permutationen, Graphen sowie Transversale und Bahnen. Viele Aufgaben sind bereits im Skript aufgeführt oder in der Beispielklausur vorhanden. Es ist auf jeden Fall sinnvoll sich das Skript, den Fragenkatalog und die Beispielklausur im Detail anzusehen und zu bearbeiten, um eine gute Basis für die eigentliche Klausur zu haben. Die Durchfallquote belegt dies ebenfalls. Trotz guter Vorbereitung ist der Schwierigkeitsgrad der Klausur relativ anspruchsvoll. Vermutlich liegt dies auch daran, dass es sich um ein Theoriefach handelt.

Gesamtfazit

Professor Braun gibt sich alle Mühe mit diesem Fach und der Vermittlung der teilweise sehr abstrakten Inhalte. Er verzichtet auf einen Foliensatz und schreibt alle Inhalte an die Tafel, was sich größtenteils mit dem Skript deckt. Bei seinen Rückfragen gibt es oftmals nur sehr zögerliches Feedback, da die Studierenden noch am Grübeln und Nachvollziehen sind, wenn er mal wieder einen komplexen Beweis einfach aus dem Kopf an die Tafel geschrieben hat. Die regelmäßigen Wiederholungen zu Unterrichtsbeginn, die vertiefenden Praktika und die Tatsache, dass man einige Wochen vor der letzten Vorlesungen mit dem Stoff bereits durch ist, helfen jedoch massiv und sorgen dafür, dass dieses Theoriefach zu bewältigen ist. Rückblickend hat es mir viel Spaß gemacht über die Sachverhalte zu Knobeln und ist auch mit einer dem Aufwand gerechten Note honoriert worden.

Der Beitrag Diskrete Strukturen (Abschlussbericht) erschien zuerst auf Maximilian Krieg.

Klausur

Wie sind die organisatorischen Rahmenbedingungen?

• Es wird 5 Aufgaben mit jeweils 10 Punkten geben, davon müssen 50% zum Bestehen erreicht werden
• Es sind keinerlei Notizen und Hilfsmittel erlaubt
• Da Multiple Choice-Aufgaben in den vorherigen Klausuren aufgrund von zahlreichen Falschantworten keine Punkte erbracht haben, wird es keine mehr geben

Der Beitrag Diskrete Strukturen (Klausurvorbereitung) erschien zuerst auf Maximilian Krieg.

Erzeugung von Bahnen und Transversale

Schreiben Sie ein Programm, welches bei Eingabe einer Permutationsgruppe (über die Erzeuger) \(G=\left \langle \gamma_0,\cdots ,\gamma_{l-1} \right \rangle \leq S_n\) die Bahnen G\\X auf der Menge X der k-Teilmengen der n elementigen Menge {0, … , n – 1} berechnet. Das Programm soll für jede Bahn einen Repräsentanten angeben.

Includes und Deklarationen

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <math.h>
#include <assert.h>
#include <algorithm>
using namespace std;
 
void multiply_subset_permutation(vector<unsigned int>& vSubset, vector<unsigned int>& vPermutation, vector<unsigned int>& vResult);
bool inResult(vector<unsigned int>& v1, vector<unsigned int>& v2);
int binkoeff(int n, int k);
int kSubsetRevDoorRank(vector<unsigned int>& vVec, int k);
vector<unsigned int> kSubsetRevDoorUnrank(int r, int k, int n);
void generate_orbits_new(vector<vector<unsigned int> >& vErzeuger, int n, int k);
vector<unsigned int> bit_to_list(vector<unsigned int>& vBitlist);
string output_list(vector<unsigned int>& vVector, int iOffset);

Main()

int main() {

     // Set 1
     vector<vector<unsigned int> > vErzeuger;
     static const int arr1[] = { 0, 3, 4, 1, 2, 5 };
     static const int arr2[] = { 3, 4, 0, 5, 1, 2 };
     vector<unsigned int> vTmp1(arr1, arr1 + sizeof(arr1) / sizeof(arr1[0]));
     vector<unsigned int> vTmp2(arr2, arr2 + sizeof(arr2) / sizeof(arr2[0]));
     vErzeuger.push_back(vTmp1);
     vErzeuger.push_back(vTmp2);
     generate_orbits_new(vErzeuger, 6, 3);

     // Set 2
     vector<vector<unsigned int> > vErzeuger;
     static const int arr1[] = { 5, 4, 3, 2, 1, 0, 7, 6 };
     static const int arr2[] = { 1, 0, 7, 6, 5, 4, 3, 2 };
     vector<unsigned int> vTmp1(arr1, arr1 + sizeof(arr1) / sizeof(arr1[0]));
     vector<unsigned int> vTmp2(arr2, arr2 + sizeof(arr2) / sizeof(arr2[0]));
     vErzeuger.push_back(vTmp1);
     vErzeuger.push_back(vTmp2);
     generate_orbits_new(vErzeuger, 8, 4); 
 
     // Set 3
     vector<vector<unsigned int> > vErzeuger;
     static const int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0 };
     static const int arr2[] = { 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
     vector<unsigned int> vTmp1(arr1, arr1 + sizeof(arr1) / sizeof(arr1[0]));
     vector<unsigned int> vTmp2(arr2, arr2 + sizeof(arr2) / sizeof(arr2[0]));
     vErzeuger.push_back(vTmp1);
     vErzeuger.push_back(vTmp2);
     generate_orbits_new(vErzeuger, 14, 5);

    // Set 4
    vector<vector<unsigned int> > vErzeuger;
    static const int arr1[] = { 19, 0, 20, 1, 21, 2, 22, 3, 15, 4, 16, 5, 17, 6, 18, 7, 27, 8, 28, 9, 29, 10, 30, 11, 23, 12, 24, 13, 25, 14, 26, 31 };
    static const int arr2[] = { 21, 9, 27, 0, 22, 10, 28, 3, 17, 13, 23, 4, 18, 14, 24, 15, 5, 25, 11, 16, 6, 26, 12, 19, 1, 29, 7, 20, 2, 30, 8, 31 };
    vector<unsigned int> vTmp1(arr1, arr1 + sizeof(arr1) / sizeof(arr1[0]));
    vector<unsigned int> vTmp2(arr2, arr2 + sizeof(arr2) / sizeof(arr2[0]));
    vErzeuger.push_back(vTmp1);
    vErzeuger.push_back(vTmp2);
    generate_orbits_new(vErzeuger, 31, 5);
   
    return 0;
}

Bahnerzeugung

void generate_orbits_new(vector<vector<unsigned int> >& vErzeuger, int n, int k) {
    vector<vector<vector<unsigned int> > > vOrbits;
 
    // Erzeugung der Menge
    cout << "n: " << n << endl;
    cout << "k: " << k << endl;
    cout << "Subset size: " << binkoeff(n, k) << endl;
 
    // Erzeugung des Vergleichsarrays
    int iElements = binkoeff(n, k);
    vector<bool> isUsed(iElements, false);
 
    for (int i = 0; i < iElements; i++) {
        // Ist die Teilmenge bereits genutzt?
        if (isUsed.at(i) == true)
            continue;
 
        // Noch nicht genutzt
        isUsed.at(i) == true;
 
        // Neue Bahn anlegen
        vector<vector<unsigned int> > vResult;
        vOrbits.push_back(vResult);
 
        // Schlange erzeugen
        vector<vector<unsigned int> > vSchlange;
        vector<unsigned int> vNoName = kSubsetRevDoorUnrank(i, n, k);
        vNoName = bit_to_list(vNoName);
        vSchlange.push_back(vNoName);

        // Laufe solange noch Elemente in der Schlange sind
        while (vSchlange.size() > 0) {
 
            // Durchlaufe alle Erzeuger
            for (unsigned int j = 0; j < vErzeuger.size(); j++) {
 
                // Temporärer Vektor
                vector<unsigned int> vTmp;
 
                multiply_subset_permutation(vSchlange.at(0), vErzeuger.at(j), vTmp);
                sort(vTmp.begin(), vTmp.end());
 
                // Neues Element?
                bool bNew = true;
 
                // Element schon in irgendeiner Bahn?
                for (unsigned int l = 0;
                        l < vOrbits.at(vOrbits.size() - 1).size(); l++) {
                    if (inResult(vTmp, vOrbits.at(vOrbits.size() - 1).at(l))) { // Bereits bekannte Permutation?
                        bNew = false;
                        break;
                    }
                }
 
                if (bNew == true) { 
                    // Nicht bekannt -> Hinzufuegen
                    vSchlange.push_back(vTmp);
                    vOrbits.at(vOrbits.size() - 1).push_back(vTmp);
                    
                    // "Benutzt" setzen --> rank holen
                    int iPos = kSubsetRevDoorRank(vTmp, k);
                    isUsed.at(iPos) = true;
                }
 
            } // for
            vSchlange.erase(vSchlange.begin());
        } // while
    } // for
    
    // Ausgabe
    for (unsigned int m = 0; m < vOrbits.size(); m++) {
        cout << "Bahn " << m + 1 << ": " << vOrbits.at(m).size() 
                << " Elemente, Repraesentant: "
                << output_list(vOrbits.at(m).at(0), 0) << endl;
    }
}

int kSubsetRevDoorRank(vector<unsigned int>& vVec, int k) {
    int i, r, s;
    r = 0;
    if ((k % 2) == 1)
        r = r - 1;
    s = 1;
    for (i = k; i >= 1; i = i - 1) {
        //cout << "i= " << i << endl;
        r = r +binkoeff(vVec.at(i - 1) + 1, i) * s;
        s = -s;
    }
    return (r);
}
 
vector<unsigned int> kSubsetRevDoorUnrank(int r, int n, int k)
{
    vector<unsigned int> vResult(n);
    //cout << "Size: " << vResult.size() << endl;
    int x, i, y;
    x = n;
    for (i = k; i >= 1; i = i - 1) {
        y = binkoeff(x, i);
        while (y > r) {
            x = x - 1;
            y = binkoeff(x, i);
        }
        vResult.at(x) = 1;
        r = binkoeff(x + 1, i) - r - 1;
    }
    return vResult;
}

Hilfsfunktionen

int binkoeff(int n, int r) {
    int i, b;
    if ((r < 0) || (n < r))
        return (0);
    if ((2 * r) > n)
        r = n - r;
    b = 1;
    if (r > 0)
        for (i = 0; i <= (r - 1); i = i + 1)
            b = (b * (n - i)) / (i + 1);
    return (b);
}
 
bool inResult(vector<unsigned int>& v1, vector<unsigned int>& v2) {
    if (v1.size() != v2.size())
        return false;
 
    for (unsigned int i = 0; i < v1.size(); i++) {
        if (v1.at(i) != v2.at(i))
            return false;
    }
    return true;
}

vector<unsigned int> bit_to_list(vector<unsigned int>& vBitlist) {
    vector<unsigned int> vList;
    for (unsigned int i = 0; i < vBitlist.size(); i++) {
        if (vBitlist.at(i) == 1) {
            vList.push_back(i);
        }
    }
 
    return vList;
}
 
void multiply_subset_permutation(vector<unsigned int>& vSubset,
        vector<unsigned int>& vPermutation, vector<unsigned int>& vResult) {
    for (unsigned int i = 0; i < vSubset.size(); i++) {
        vResult.push_back(vPermutation[vSubset[i]]);
    }
}

bool isId(vector<unsigned int>& vTmp) {
    for (unsigned int i = 0; i < vTmp.size(); i++) {
        if (i != vTmp[i]) {
            return false;
        }
    }
    return true;
}
 
string output_list(vector<unsigned int>& vVector, int iOffset) {
    stringstream ss;
 
    if (isId(vVector) == true) {
        ss << "id" << vVector.size();
    } else {
        ss << "[";
        for (unsigned int i = 0; i < vVector.size(); i++) {
            ss << vVector[i] + iOffset;
            if (i < vVector.size() - 1) {
                ss << ",";
            }
        }
        ss << "]";
    }
    return ss.str();
}

Eingabe von Testparametern

Testen Sie das Programm für folgende Parameter.

Set 1

n=6

k=3

γ₀ = (1, 3)(2, 4)

γ₁ = (0, 3, 5, 2)(1, 4)

n: 6 
k: 3 
Subset size: 20  
Bahn 1: 4 Elemente, Repraesentant: [0,3,4] 
Bahn 2: 12 Elemente, Repraesentant: [0,1,4]  
Bahn 3: 4 Elemente, Repraesentant: [0,1,3]

Set 2

n=8

k=4

γ₀ = (0, 5)(1, 4)(2, 3)(7, 6)

γ₁ = (0, 1)(2, 7)(3, 6)(4, 5)

n: 8  
k: 4  
Subset size: 70 
Bahn 1: 4 Elemente, Repraesentant: [2,3,4,5]  
Bahn 2: 4 Elemente, Repraesentant: [1,2,4,5]  
Bahn 3: 2 Elemente, Repraesentant: [1,2,3,4]  
Bahn 4: 4 Elemente, Repraesentant: [1,2,3,5]  
Bahn 5: 4 Elemente, Repraesentant: [1,3,4,5]  
Bahn 6: 1 Elemente, Repraesentant: [0,1,4,5]  
Bahn 7: 4 Elemente, Repraesentant: [0,1,3,5]  
Bahn 8: 4 Elemente, Repraesentant: [0,1,2,5]  
Bahn 9: 2 Elemente, Repraesentant: [0,2,3,5]  
Bahn 10: 2 Elemente, Repraesentant: [0,3,4,7] 
Bahn 11: 4 Elemente, Repraesentant: [0,3,5,7] 
Bahn 12: 4 Elemente, Repraesentant: [0,2,3,7] 
Bahn 13: 4 Elemente, Repraesentant: [0,2,4,7] 
Bahn 14: 4 Elemente, Repraesentant: [0,2,5,7] 
Bahn 15: 2 Elemente, Repraesentant: [0,1,2,7] 
Bahn 16: 4 Elemente, Repraesentant: [0,1,3,7] 
Bahn 17: 2 Elemente, Repraesentant: [1,3,5,7] 
Bahn 18: 4 Elemente, Repraesentant: [1,2,3,7] 
Bahn 19: 2 Elemente, Repraesentant: [2,4,5,7] 
Bahn 20: 4 Elemente, Repraesentant: [2,3,4,7] 
Bahn 21: 4 Elemente, Repraesentant: [2,3,5,7]
Bahn 22: 1 Elemente, Repraesentant: [2,3,6,7]

Set 3

n=14

k=5

γ₀ = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)

γ₁ = (0, 13)(1, 12)(2, 11)(3, 10)(4, 9)(5, 8)(6, 7)

n: 14 
k: 5  
Subset size: 2002 
Bahn 1: 14 Elemente, Repraesentant: [1,2,3,4,5] 
Bahn 2: 28 Elemente, Repraesentant: [1,2,3,5,6] 
Bahn 3: 28 Elemente, Repraesentant: [1,3,4,5,6] 
Bahn 4: 28 Elemente, Repraesentant: [1,2,3,6,7] 
Bahn 5: 28 Elemente, Repraesentant: [1,3,4,6,7] 
Bahn 6: 14 Elemente, Repraesentant: [1,2,4,6,7] 
Bahn 7: 28 Elemente, Repraesentant: [1,4,5,6,7] 
Bahn 8: 28 Elemente, Repraesentant: [1,3,5,6,7] 
Bahn 9: 14 Elemente, Repraesentant: [1,3,4,5,7] 
Bahn 10: 28 Elemente, Repraesentant: [1,2,3,7,8] 
Bahn 11: 28 Elemente, Repraesentant: [1,3,4,7,8]  
Bahn 12: 28 Elemente, Repraesentant: [1,2,4,7,8]  
Bahn 13: 28 Elemente, Repraesentant: [1,4,5,7,8]  
Bahn 14: 28 Elemente, Repraesentant: [1,3,5,7,8]  
Bahn 15: 28 Elemente, Repraesentant: [1,5,6,7,8]  
Bahn 16: 28 Elemente, Repraesentant: [1,4,6,7,8]  
Bahn 17: 28 Elemente, Repraesentant: [1,3,6,7,8]  
Bahn 18: 28 Elemente, Repraesentant: [1,3,4,6,8]  
Bahn 19: 28 Elemente, Repraesentant: [1,4,5,6,8]  
Bahn 20: 28 Elemente, Repraesentant: [1,2,3,8,9]  
Bahn 21: 28 Elemente, Repraesentant: [1,3,4,8,9]  
Bahn 22: 28 Elemente, Repraesentant: [1,2,4,8,9]  
Bahn 23: 28 Elemente, Repraesentant: [1,4,5,8,9]  
Bahn 24: 28 Elemente, Repraesentant: [1,3,5,8,9]  
Bahn 25: 14 Elemente, Repraesentant: [1,2,5,8,9] 
Bahn 26: 28 Elemente, Repraesentant: [1,5,6,8,9]  
Bahn 27: 28 Elemente, Repraesentant: [1,4,6,8,9]  
Bahn 28: 28 Elemente, Repraesentant: [1,3,6,8,9]  
Bahn 29: 28 Elemente, Repraesentant: [1,6,7,8,9]  
Bahn 30: 28 Elemente, Repraesentant: [1,5,7,8,9]  
Bahn 31: 28 Elemente, Repraesentant: [1,4,7,8,9]  
Bahn 32: 28 Elemente, Repraesentant: [1,3,7,8,9]  
Bahn 33: 28 Elemente, Repraesentant: [1,3,4,7,9]  
Bahn 34: 28 Elemente, Repraesentant: [1,4,5,7,9]  
Bahn 35: 14 Elemente, Repraesentant: [1,3,5,7,9]  
Bahn 36: 28 Elemente, Repraesentant: [1,5,6,7,9]  
Bahn 37: 28 Elemente, Repraesentant: [1,4,6,7,9]  
Bahn 38: 14 Elemente, Repraesentant: [1,4,5,6,9]  
Bahn 39: 28 Elemente, Repraesentant: [1,3,4,9,10] 
Bahn 40: 28 Elemente, Repraesentant: [1,4,5,9,10] 
Bahn 41: 28 Elemente, Repraesentant: [1,3,5,9,10] 
Bahn 42: 28 Elemente, Repraesentant: [1,2,5,9,10] 
Bahn 43: 28 Elemente, Repraesentant: [1,5,6,9,10] 
Bahn 44: 28 Elemente, Repraesentant: [1,4,6,9,10] 
Bahn 45: 28 Elemente, Repraesentant: [1,3,6,9,10] 
Bahn 46: 14 Elemente, Repraesentant: [1,6,7,9,10] 
Bahn 47: 28 Elemente, Repraesentant: [1,5,7,9,10] 
Bahn 48: 28 Elemente, Repraesentant: [1,4,7,9,10] 
Bahn 49: 28 Elemente, Repraesentant: [1,3,7,9,10] 
Bahn 50: 28 Elemente, Repraesentant: [1,6,8,9,10] 
Bahn 51: 28 Elemente, Repraesentant: [1,5,8,9,10] 
Bahn 52: 28 Elemente, Repraesentant: [1,4,8,9,10] 
Bahn 53: 14 Elemente, Repraesentant: [1,3,8,9,10] 
Bahn 54: 28 Elemente, Repraesentant: [1,3,4,8,10] 
Bahn 55: 28 Elemente, Repraesentant: [1,4,5,8,10] 
Bahn 56: 28 Elemente, Repraesentant: [1,3,5,8,10] 
Bahn 57: 28 Elemente, Repraesentant: [1,5,6,8,10] 
Bahn 58: 28 Elemente, Repraesentant: [1,4,6,8,10] 
Bahn 59: 28 Elemente, Repraesentant: [1,5,7,8,10] 
Bahn 60: 28 Elemente, Repraesentant: [1,4,7,8,10] 
Bahn 61: 28 Elemente, Repraesentant: [1,4,5,7,10] 
Bahn 62: 28 Elemente, Repraesentant: [1,5,6,7,10] 
Bahn 63: 14 Elemente, Repraesentant: [1,5,6,10,11]  
Bahn 64: 28 Elemente, Repraesentant: [1,4,6,10,11]  
Bahn 65: 28 Elemente, Repraesentant: [1,5,7,10,11]  
Bahn 66: 28 Elemente, Repraesentant: [1,4,7,10,11]  
Bahn 67: 28 Elemente, Repraesentant: [1,3,7,10,11]  
Bahn 68: 28 Elemente, Repraesentant: [1,5,8,10,11]  
Bahn 69: 28 Elemente, Repraesentant: [1,4,8,10,11]
Bahn 70: 14 Elemente, Repraesentant: [1,5,9,10,11]  
Bahn 71: 14 Elemente, Repraesentant: [1,3,5,9,11] 
Bahn 72: 28 Elemente, Repraesentant: [1,4,6,9,11] 
Bahn 73: 14 Elemente, Repraesentant: [1,3,6,9,11] 
Bahn 74: 14 Elemente, Repraesentant: [1,5,7,9,11] 
Bahn 75: 28 Elemente, Repraesentant: [1,4,7,9,11] 
Bahn 76: 28 Elemente, Repraesentant: [1,5,8,9,11] 
Bahn 77: 28 Elemente, Repraesentant: [1,4,5,8,11] 
Bahn 78: 14 Elemente, Repraesentant: [1,4,6,8,11] 
Bahn 79: 14 Elemente, Repraesentant: [1,4,7,10,12]  

Set 4

n=31

k=5

γ₀ = (0, 19, 9, 4, 21, 10, 16, 27, 13, 6, 22, 30, 26, 24, 23, 11, 5, 2, 20, 29, 14, 18, 28, 25, 12, 17, 8, 15, 7, 3, 1)

γ₁ = (0, 21, 26, 7, 3)(1, 9, 13, 14, 24)(2, 27, 20, 6, 28)(4, 22, 12, 18, 11)(5, 10, 23, 19, 16)(8, 17, 25, 29, 30)

n: 31
k: 5
Subset size: 169911  
Bahn 1: 155 Elemente, Repraesentant: [0,1,19,20,21]
Bahn 2: 155 Elemente, Repraesentant: [0,2,19,20,21]

...

Bahn 1098: 155 Elemente, Repraesentant: [1,4,7,8,20]
Bahn 1099: 155 Elemente, Repraesentant: [6,7,8,20,22]
Bahn 1100: 155 Elemente, Repraesentant: [2,6,8,20,22]
Bahn 1101: 31 Elemente, Repraesentant: [0,5,8,15,20] 

Der Beitrag Diskrete Strukturen (Praktikum 3) erschien zuerst auf Maximilian Krieg.

Rückblick

Teilmengen

• Konzept und Definition von minimal change-Sequenzen
• rank, unrank, successor und predecessor-Funktionen
• Darstellungen von n-Teilmengen (Bit-Arrays und charakteristischer Vektor)
• Darstellungen von k-Teilmengen einer n-Teilmenge
• Rekursive Erzeugung aller Teilmengen (Gray-Code)
• Anzahl der n-Teilmengen und k-Teilmengen bestimmen
• Binomialkoeffizient und Pascalsches Dreieck

Permutationen

• Definition einer Permutation auf n Punkten (kanonischer Start mit 0)
• Anzahl von Permutationen (n!)
• Darstellungen von Permutationen als Liste (einfacher zu speichern) und in Zykelnotation (lesbarer für Menschen)
• Definition der Identität id_n
• Multiplikation und Inversion von Permutationen (Aufwand O(n))
• Definitionen und Transformation von Zykeltyp und (Zahl-)Partitionen
• Anzahl von Permutationen mit gleichem Zykeltyp bestimmen: \(\frac{n!}{\prod_{k=1}^{n}(a_k!*k^{a_k})}\) 
• Erzeugung aller Permutationen auf n Punkten (Johnson-Trotter)

Gruppen

• Definitionen und Axiome (multiplikative und additive Gruppen)
• Beispiele von Gruppen, Inversen und neutralen Elementen
• Endliche Gruppen
• Ordnung einer Gruppe bestimmen (Anzahl der Elemente in einer Gruppe)
• Definition einer Untergruppe (Teilmenge einer endlichen Gruppe ist dann eine Gruppe, wenn sie Abgeschlossenheit erfüllt)
• Erzeugnis von Gruppenelementen
• Zyklische Gruppe (Gruppe wird von exakt einem Element erzeugt)
• Symmetrische Gruppe S_n
• Untergruppen von Drehgruppen und geometrischen Objekten
• Satz von Lagrange (Untergruppenordnung teilt Gruppenordnung)
• Definition von Nebenklassen
• Berechnung von Transversalen

Gruppenoperationen

• Definitionen von Gruppenoperationen, Bahn und Stabilisator
• Permutationsgruppen auf Graphen und k-Teilmengen anwenden
• Bahnenalgorithmus
• Berechnung des Stabilisators (nach Schreier)
• Anzahl von Fixpunktmengen, Bahnen sowie von nicht-isomorphen Graohen und Halsketten bestimmen

Der Beitrag Diskrete Strukturen (Klausurvorbereitung) erschien zuerst auf Maximilian Krieg.

Der Beitrag Diskrete Strukturen (Vorlesung 15) erschien zuerst auf Maximilian Krieg.

Der Beitrag Diskrete Strukturen (Vorlesung 14) erschien zuerst auf Maximilian Krieg.

Der Beitrag Diskrete Strukturen (Vorlesung 13) erschien zuerst auf Maximilian Krieg.

Der Beitrag Diskrete Strukturen (Vorlesung 12) erschien zuerst auf Maximilian Krieg.

Der Beitrag Diskrete Strukturen (Vorlesung 11) erschien zuerst auf Maximilian Krieg.

Operationen und Darstellungen von Permutationen

Implementieren Sie die Multiplikation und die Inversion von Permutationen in S_n. Verwenden Sie die Listennotation als Darstellung im Rechner und beachten Sie die Laufzeit von O(n) für beide Routinen. Implementieren Sie die Zyklennotation als Ausgabe von Permutationen. Beachten Sie dabei die drei Konventionen: Sortieren nach dem kleinsten Element innerhalb eines Zykels, Weglassen von Einerzyklen und die gesonderte Darstellung der Identität.

Konsolenausgabe des folgenden Quellcodes

Ausgaben Zykel (Offset 1):
vA [5,4,3,2,1] = (1,5)(2,4) 
vB [2,4,1,3,5] = (1,2,4,3) 
vC [2,5,4,3,1] = (1,2,5)(3,4) 
vD [3,2,6,9,5,7,1,8,4] = (1,3,6,7)(4,9) 
id [1,2,3,4,5] = id5

Multiplikation von: 
(1,5)(2,4) * (1,2,4,3) -> (1,4,3,5)

Inversion:
(1,2,5)(3,4) -> (1,5,2)(3,4)

Includes und Deklarationen

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <math.h>
#include <assert.h>
#include <algorithm>
using namespace std;
  
string list_to_cycle(vector<unsigned int>& vVector, int iOffset);
string output_list(vector<unsigned int>& vVector, int iOffset);
bool isId(vector<unsigned int>& vTmp);
vector<unsigned int> invertieren(vector<unsigned int>& vVector);
vector<unsigned int> multiplizieren(vector<unsigned int>& vLinks, vector<unsigned int>& vRechts);

Main()

int main() {
    int iTmp[] = {0,1,2,3,4};
    vector<unsigned int> vID(iTmp, iTmp + sizeof iTmp / sizeof iTmp[0]);
     
    int iTmp2[] = {4,3,2,1,0};
    vector<unsigned int> vA(iTmp2, iTmp2 + sizeof iTmp2 / sizeof iTmp2[0]);

    int iTmp3[] = {1,3,0,2,4};
    vector<unsigned int> vB(iTmp3, iTmp3 + sizeof iTmp3 / sizeof iTmp3[0]);
     
    int iTmp4[] = {1,4,3,2,0};
    vector<unsigned int> vC(iTmp4, iTmp4 + sizeof iTmp4 / sizeof iTmp4[0]);
     
    // 3,2,6,9,5,7,1,8,4 //  http://cims.nyu.edu/~kiryl/teaching/aa/les100103.pdf (1367)(49)
    int iTmp5[] = {2,1,5,8,4,6,0,7,3};
    vector<unsigned int> vD(iTmp5, iTmp5 + sizeof iTmp5 / sizeof iTmp5[0]);
     
    // Umwandlung in Zykelnotation (Offset 1)
    cout << "Ausgaben Zykel (Offset 1):\n";
    cout << "vA [5,4,3,2,1] = " << list_to_cycle(vA,1) << "\n";
    cout << "vB [2,4,1,3,5] = " << list_to_cycle(vB,1) << "\n";
    cout << "vC [2,5,4,3,1] = " << list_to_cycle(vC,1) << "\n";
    cout << "vD [3,2,6,9,5,7,1,8,4] = " << list_to_cycle(vD,1) << "\n";
    cout << "id [1,2,3,4,5] = " << list_to_cycle(vID,1)<< "\n\n";  
     
    //Multiplizieren (Offset 1)
    vector<unsigned int> vTmp=multiplizieren(vA,vB);
    cout    << "Multiplikation von: \n"
            << list_to_cycle(vA,1)
            << " * "
            << list_to_cycle(vB,1)
            << " -> "
            << list_to_cycle(vTmp,1)
            << "\n\n";
   
    // Invertieren (Offset 1)
    vTmp = invertieren(vC);
    cout << "Inversion: \n";
    cout << list_to_cycle(vC,1) << " -> " << list_to_cycle(vTmp,1);
    cout << "\n\n";
}

Multiplikation

vector<unsigned int> multiplizieren(vector<unsigned int>& vLinks, vector<unsigned int>& vRechts)
{   
    vector<unsigned int> tmp(vRechts.size(),0);
    for (unsigned int i=0;i<vRechts.size();i++)
    {
        tmp[i]=vLinks[vRechts[i]];
    }
    return tmp;
}

Inversion

vector<unsigned int> invertieren(vector<unsigned int>& vVector)
{
    vector<unsigned int> tmp(vVector.size(),0);
    for (unsigned int i=0;i<vVector.size();i++)
    {
        tmp[vVector[i]]=i;
    }
    return tmp;
}

Ausgabe in Zykelnotation

string list_to_cycle(vector<unsigned int>& vVector, int iOffset) {
    stringstream ss;
    if (isId(vVector)) {
        ss << "id" << vVector.size();
    } else {
        bool bAktiv[vVector.size()];
        for (unsigned int i = 0; i < vVector.size(); i++) {
            bAktiv[i] = true;
        }
 
        for (unsigned int i = 0; i < vVector.size(); i++) {
            if (bAktiv[i]) {
                if (i == vVector[i]) {
                    bAktiv[i] = false;
                    continue;
                } else {
                    ss << "(";
                    ss << i + iOffset;
                    bAktiv[i] = false;
                    int j = i;
 
                    while (bAktiv[vVector[j]]) {
                        j = vVector[j];
                        ss << "," << j + iOffset;
                        bAktiv[j] = false;
                    }
                    ss << ")";
                }
            }
        }
    }
    return ss.str();
}

Hilfsfunktionen

bool isId(vector<unsigned int>& vTmp) {
    for (unsigned int i = 0; i < vTmp.size(); i++) {
        if (i != vTmp[i]) {
            return false;
        }
    }
    return true;
}

string output_list(vector<unsigned int>& vVector, int iOffset)
{
    stringstream ss;
 
    if (isId(vVector)==true)
    {
        ss << "id" << vVector.size();
    }
    else
    {
        ss << "[";
        for (unsigned int i=0;i<vVector.size();i++)
        {
            ss << vVector[i]+ iOffset;
            if (i<vVector.size()-1)
            {
                ss << ",";
            }
        }
        ss << "]";
    }
    return ss.str();
}

Erzeugung von Gruppenelementen

Entwerfen und implementieren Sie einen Algorithmus, welche bei Eingabe einer Liste von Permutationen \(\pi_0, \cdots, \pi_{l-1} \in S_n\) alle Gruppenelemente der von diesen Permutationen erzeugten Gruppe \( G=\left \langle \pi_0 ,\cdots, \pi_{l-1} \right \rangle \) generiert. Dokumentieren und erläutern Sie alle Schritte nachvollziehbar.

Konsolenausgabe des folgenden Quellcodes

Aufgabe 2:

Erzeuger:
(0,1,2,3)
(0,1)(2,3)

Gruppenelemente:
[1,2,3,0] | (0,1,2,3)
[1,0,3,2] | (0,1)(2,3)
[2,3,0,1] | (0,2)(1,3)
[0,3,2,1] | (1,3)
[2,1,0,3] | (0,2)
id4 | id4
[3,0,1,2] | (0,3,2,1)
[3,2,1,0] | (0,3)(1,2)

Includes und Deklarationen

Für diese Aufgabe benötigen wir die Invertierung nicht mehr. Stattdessen deklarieren wir nun eine Funktion zur Überprüfung der Gleichheit von zwei Vektoren sowie die Funktion zur Erzeugung aller Gruppenelemente.

#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <math.h>
#include <assert.h>
#include <algorithm>
using namespace std;
  
string list_to_cycle(vector<unsigned int>& vVector, int iOffset);
string output_list(vector<unsigned int>& vVector, int iOffset);
bool isId(vector<unsigned int>& vTmp);
vector<unsigned int> multiplizieren(vector<unsigned int>& vLinks, vector<unsigned int>& vRechts);
void create_group(vector< vector<unsigned int> >& vErzeuger);
bool areEqual(vector<unsigned int>& vA, vector<unsigned int>& vB);

Main()

int main() {
    cout << "Aufgabe 2:\n\n";
    vector< vector<unsigned int> > vErzeuger;   
 
    vector<unsigned int> vErzeuger1;
    vErzeuger1.push_back(1);
    vErzeuger1.push_back(2);
    vErzeuger1.push_back(3);
    vErzeuger1.push_back(0);
 
    vector<unsigned int> vErzeuger2;
    vErzeuger2.push_back(1);
    vErzeuger2.push_back(0);
    vErzeuger2.push_back(3);
    vErzeuger2.push_back(2);    
    
    vErzeuger.push_back(vErzeuger1);
    vErzeuger.push_back(vErzeuger2);
    
    create_group(vErzeuger);
}

Erzeugung aller Gruppenelemente

void create_group(vector< vector<unsigned int> >& vErzeuger)
 {     
    vector< vector<unsigned int> > vSchlange;
    vector< vector<unsigned int> > vAblage;
    vector<unsigned int> tmp;
    
     cout << "Erzeuger:\n";
    for (unsigned int i=0;i<vErzeuger.size();i++)
    {
        vAblage.push_back(vErzeuger.at(i));
        vSchlange.push_back(vErzeuger.at(i));
       cout << list_to_cycle(vErzeuger.at(i),0) << "\n";
    }
    cout << "\n";
    
    // Läuft solange die Qu nicht leer ist
    while (vSchlange.size()>0)
    {
        // Laufe alle Erzeuger ab und wende sie auf das erste Element in Q an
        for (unsigned int j=0;j<vErzeuger.size();j++)
        {
            // Erzeuge Element
            vector<unsigned int> vT = multiplizieren(vErzeuger.at(j),vSchlange.at(0));
         
            bool unknown=true;
         
            // Prüfe ob Element bekannt ist
            for (unsigned int x=0;x<vAblage.size();x++)
            {
                tmp=vAblage.at(x);
             
                if (areEqual(vT, tmp)==true)
                {
                    unknown=false;
                    break;
                }
            }
         
            //wenn unbekannt, kommt es auf die Q
            if (unknown==true)
            {
                vSchlange.push_back(vT);
                vAblage.push_back(vT);
            }
        }
     
        // entferne erstes Element aus Q nachdem alle Erzeuger drόber sind
        tmp=vSchlange.at(0);
        vSchlange.erase(vSchlange.begin()); 
    }
 
    // Ausgabe der Ablage
    cout << "Gruppenelemente:\n";
    for (unsigned int i=0;i<vAblage.size();i++)
    {
        cout << output_list(vAblage.at(i),0) << " | " << list_to_cycle(vAblage.at(i),0) << "\n";
    }
}

Hilfsfunktionen

Hier ist die Vergleichsfunktion zweier Integer-Vektoren zu finden. Eine wesentlich effizientere Vergleichsmethode wäre es den Rang beider Vektoren zu bestimmen und diesen zu vergleichen. Für dieses Praktikum ist diese Lösung jedoch ausreichend.

bool areEqual(vector<unsigned int>& vA, vector<unsigned int>& vB)
{
    // Größe weicht ab / vermeidet Fehler
    if (vA.size()!=vB.size())
    {
        // Groessenabweichung
        return false;
    }
 
    // Vergleiche Stellenweise
    for (unsigned int i=0;i<vA.size();i++)
    {
        if (vA[i]!=vB[i])
        {
            // Stellenweise Abweichung
            return false;
        }
    }
    // Sie sind gleich
    return true;
}

Erzeuger von geometrischen Objekten

Definieren Sie für folgende Gruppen Erzeuger und generieren Sie alle Gruppenelemente mit der Routine aus Aufgabe 2. Wie sind die Gruppenordnungen?

Symmetriegruppe D₃ des regulären Dreiecks

Erzeuger:
(0,1,2)
(0,1)

Gruppenelemente:
[1,2,0] | (0,1,2)
[1,0,2] | (0,1)
[2,0,1] | (0,2,1)
[0,2,1] | (1,2)
[2,1,0] | (0,2)
id3 | id3

Die Ordnung der Gruppe beträgt 6.

Symmetriegruppe V₄ eines Rechtecks mit unterschiedlicher Seitenlänge

Erzeuger:
(0,1)(2,3)
(0,2)(1,3)

Gruppenelemente:
[1,0,3,2] | (0,1)(2,3)
[2,3,0,1] | (0,2)(1,3)
id4 | id4
[3,2,1,0] | (0,3)(1,2)

Die Ordnung der Gruppe beträgt 4.

Symmetriegruppe T des Tetraeders

Erzeuger:
(0,1,2)
(0,3)(1,2)

Gruppenelemente:
[1,2,0,3] | (0,1,2)
[3,2,1,0] | (0,3)(1,2)
[2,0,1,3] | (0,2,1)
[2,1,3,0] | (0,2,3)
[3,0,2,1] | (0,3,1)
id4 | id4
[1,3,2,0] | (0,1,3)
[0,2,3,1] | (1,2,3)
[3,1,0,2] | (0,3,2)
[0,3,1,2] | (1,3,2)
[2,3,0,1] | (0,2)(1,3)
[1,0,3,2] | (0,1)(2,3)

Die Gruppenordnung beträgt 12.

Symmetriegruppe Q des Würfels

Erzeuger:
(0,1,2,3)(4,5,6,7)
(0,3,7,4)(1,2,6,5)

Gruppenelemente:
[1,2,3,0,5,6,7,4] | (0,1,2,3)(4,5,6,7)
[3,2,6,7,0,1,5,4] | (0,3,7,4)(1,2,6,5)
[2,3,0,1,6,7,4,5] | (0,2)(1,3)(4,6)(5,7)
[2,6,7,3,1,5,4,0] | (0,2,7)(1,6,4)
[0,3,7,4,1,2,6,5] | (1,3,4)(2,7,5)
[7,6,5,4,3,2,1,0] | (0,7)(1,6)(2,5)(3,4)
[3,0,1,2,7,4,5,6] | (0,3,2,1)(4,7,6,5)
[6,7,3,2,5,4,0,1] | (0,6)(1,7)(2,3)(4,5)
[3,7,4,0,2,6,5,1] | (0,3)(1,7)(2,4)(5,6)
[6,5,4,7,2,1,0,3] | (0,6)(1,5)(2,4)(3,7)
[1,0,4,5,2,3,7,6] | (0,1)(2,4)(3,5)(6,7)
[4,7,6,5,0,3,2,1] | (0,4)(1,7)(2,6)(3,5)
[4,5,1,0,7,6,2,3] | (0,4,7,3)(1,5,6,2)
id8 | id8
[7,3,2,6,4,0,1,5] | (0,7,5)(1,3,6)
[7,4,0,3,6,5,1,2] | (0,7,2)(1,4,6)
[5,4,7,6,1,0,3,2] | (0,5)(1,4)(2,7)(3,6)
[0,4,5,1,3,7,6,2] | (1,4,3)(2,5,7)
[5,1,0,4,6,2,3,7] | (0,5,2)(3,4,6)
[2,1,5,6,3,0,4,7] | (0,2,5)(3,6,4)
[5,6,2,1,4,7,3,0] | (0,5,7)(1,6,3)
[4,0,3,7,5,1,2,6] | (0,4,5,1)(2,3,7,6)
[1,5,6,2,0,4,7,3] | (0,1,5,4)(2,6,7,3)
[6,2,1,5,7,3,0,4] | (0,6)(1,2)(3,5)(4,7)

Die Gruppenordnung beträgt 24.

Symmetriegruppe I des Ikosaeders

Erzeuger:
(1,2,3,4,5)(6,7,8,9,10)
(0,3,10,9,1)(4,6,11,8,5)

Gruppenelemente:
[0,2,3,4,5,1,7,8,9,10,6,11] | (1,2,3,4,5)(6,7,8,9,10)
[3,0,2,10,6,4,11,7,5,1,9,8] | (0,3,10,9,1)(4,6,11,8,5)
[0,3,4,5,1,2,8,9,10,6,7,11] | (1,3,5,2,4)(6,8,10,7,9)
[3,2,10,6,4,0,7,5,1,9,11,8] | (0,3,6,7,5)(1,2,10,11,8)
[4,0,3,6,7,5,11,8,1,2,10,9] | (0,4,7,8,1)(2,3,6,11,9)
[10,3,2,9,11,6,8,7,4,0,1,5] | (0,10,1,3,9)(4,11,5,6,8)
[0,4,5,1,2,3,9,10,6,7,8,11] | (1,4,2,5,3)(6,9,7,10,8)
[3,10,6,4,0,2,5,1,9,11,7,8] | (0,3,4)(1,10,7)(2,6,5)(8,9,11)
[4,3,6,7,5,0,8,1,2,10,11,9] | (0,4,5)(1,3,7)(2,6,8)(9,10,11)
[10,2,9,11,6,3,7,4,0,1,8,5] | (0,10,8)(1,2,9)(3,11,5)(4,6,7)
[5,0,4,7,8,1,11,9,2,3,6,10] | (0,5,1)(2,4,8)(3,7,9)(6,11,10)
[6,3,10,11,7,4,8,5,0,2,9,1] | (0,6,8)(1,3,11)(2,10,9)(4,7,5)
[6,4,3,10,11,7,9,8,5,0,2,1] | (0,6,9)(1,4,11)(2,3,10)(5,7,8)
[9,10,2,1,8,11,5,7,6,3,0,4] | (0,9,3,1,10)(4,8,6,5,11)
[0,5,1,2,3,4,10,6,7,8,9,11] | (1,5,4,3,2)(6,10,9,8,7)
[3,6,4,0,2,10,1,9,11,7,5,8] | (0,3)(1,6)(2,4)(5,10)(7,9)(8,11)
[4,6,7,5,0,3,1,2,10,11,8,9] | (0,4)(1,6)(2,7)(3,5)(8,10)(9,11)
[10,9,11,6,3,2,4,0,1,8,7,5] | (0,10,7)(1,9,8)(2,11,5)(3,6,4)
[5,4,7,8,1,0,9,2,3,6,11,10] | (0,5)(1,4)(2,7)(3,8)(6,9)(10,11)
[6,10,11,7,4,3,5,0,2,9,8,1] | (0,6,5,3,7)(1,10,8,2,11)
[9,2,1,8,11,10,7,6,3,0,5,4] | (0,9)(1,2)(3,8)(4,11)(5,10)(6,7)
[1,0,5,8,9,2,11,10,3,4,7,6] | (0,1)(2,5)(3,8)(4,9)(6,11)(7,10)
[7,4,6,11,8,5,9,1,0,3,10,2] | (0,7,1,4,8)(2,6,9,3,11)
[11,10,9,8,7,6,5,4,3,2,1,0] | (0,11)(1,10)(2,9)(3,8)(4,7)(5,6)
[7,5,4,6,11,8,10,9,1,0,3,2] | (0,7,9)(1,5,8)(2,4,11)(3,6,10)
[11,6,10,9,8,7,1,5,4,3,2,0] | (0,11)(1,6)(2,10)(3,9)(4,8)(5,7)
[10,6,3,2,9,11,1,8,7,4,0,5] | (0,10)(1,6)(2,3)(4,9)(5,11)(7,8)
[1,9,2,0,5,8,4,7,11,10,3,6] | (0,1,9,10,3)(4,5,8,11,6)
id12 | id12
[3,4,0,2,10,6,9,11,7,5,1,8] | (0,3,2)(1,4,10)(5,6,9)(7,11,8)
[4,7,5,0,3,6,2,10,11,8,1,9] | (0,4,3)(1,7,10)(2,5,6)(8,11,9)
[10,11,6,3,2,9,0,1,8,7,4,5] | (0,10,4,2,6)(1,11,5,9,7)
[5,7,8,1,0,4,2,3,6,11,9,10] | (0,5,4)(1,7,3)(2,8,6)(9,11,10)
[6,11,7,4,3,10,0,2,9,8,5,1] | (0,6)(1,11)(2,7)(3,4)(5,10)(8,9)
[9,1,8,11,10,2,6,3,0,5,7,4] | (0,9,5,2,8)(3,11,4,10,7)
[1,5,8,9,2,0,10,3,4,7,11,6] | (0,1,5)(2,8,4)(3,9,7)(6,10,11)
[7,6,11,8,5,4,1,0,3,10,9,2] | (0,7)(1,6)(2,11)(3,8)(4,5)(9,10)
[11,9,8,7,6,10,4,3,2,1,5,0] | (0,11)(1,9)(2,8)(3,7)(4,6)(5,10)
[1,2,0,5,8,9,7,11,10,3,4,6] | (0,1,2)(3,5,9)(4,8,10)(6,7,11)
[2,0,1,9,10,3,11,6,4,5,8,7] | (0,2,1)(3,9,5)(4,10,8)(6,11,7)
[8,5,7,11,9,1,10,2,0,4,6,3] | (0,8)(1,5)(2,7)(3,11)(4,9)(6,10)
[8,9,1,5,7,11,4,6,10,2,0,3] | (0,8,10)(1,9,2)(3,5,11)(4,7,6)
[8,1,5,7,11,9,6,10,2,0,4,3] | (0,8,2,5,9)(3,7,10,4,11)
[11,7,6,10,9,8,2,1,5,4,3,0] | (0,11)(1,7)(2,6)(3,10)(4,9)(5,8)
[8,11,9,1,5,7,0,4,6,10,2,3] | (0,8,6)(1,11,3)(2,9,10)(4,5,7)
[6,7,4,3,10,11,2,9,8,5,0,1] | (0,6,2,4,10)(1,7,9,5,11)
[9,11,10,2,1,8,0,5,7,6,3,4] | (0,9,6)(1,11,4)(2,10,3)(5,8,7)
[2,10,3,0,1,9,5,8,11,6,4,7] | (0,2,3)(1,10,4)(5,9,6)(7,8,11)
[4,5,0,3,6,7,10,11,8,1,2,9] | (0,4,6,10,2)(1,5,7,11,9)
[5,8,1,0,4,7,3,6,11,9,2,10] | (0,5,7,6,3)(1,8,11,10,2)
[9,8,11,10,2,1,3,0,5,7,6,4] | (0,9,7)(1,8,5)(2,11,4)(3,10,6)
[1,8,9,2,0,5,3,4,7,11,10,6] | (0,1,8,7,4)(2,9,11,6,3)
[7,11,8,5,4,6,0,3,10,9,1,2] | (0,7,3,5,6)(1,11,2,8,10)
[11,8,7,6,10,9,3,2,1,5,4,0] | (0,11)(1,8)(2,7)(3,6)(4,10)(5,9)
[2,1,9,10,3,0,6,4,5,8,11,7] | (0,2,9,8,5)(3,10,11,7,4)
[8,7,11,9,1,5,2,0,4,6,10,3] | (0,8,4,1,7)(2,11,3,9,6)
[2,3,0,1,9,10,8,11,6,4,5,7] | (0,2)(1,3)(4,9)(5,10)(6,8)(7,11)
[5,1,0,4,7,8,6,11,9,2,3,10] | (0,5,8,9,2)(3,4,7,11,10)
[7,8,5,4,6,11,3,10,9,1,0,2] | (0,7,10)(1,8,9)(2,5,11)(3,4,6)
[2,9,10,3,0,1,4,5,8,11,6,7] | (0,2,10,6,4)(1,9,11,7,5)

Die Gruppenordnung beträgt 60. Es gilt verallgemeinert: \(|\text{Gruppenelemente}|=|\text{Knoten}|*|\text{Kanten pro Knoten}|\).

Der Beitrag Diskrete Strukturen (Praktikum 2) erschien zuerst auf Maximilian Krieg.