Исправь мою программу, вот мой файл ---addTable.js
const fileSystem = require('fs');
const pathModule = require('path');

function fetchAddTable() {
    const fileContent = fileSystem.readFileSync(pathModule.join(__dirname, 'data', 'add_table.txt'), 'utf-8');
    return fileContent.trim().split('\n').map(currentLine => currentLine.trim().split(/\s+/));
}

module.exports = fetchAddTable;
---elements.js
const fileSystem = require('fs');
const pathModule = require('path');

function fetchElements() {
    const fileContent = fileSystem.readFileSync(pathModule.join(__dirname, 'data', 'elements.txt'), 'utf-8');
    return fileContent.trim().split(/\s+/);
}

module.exports = fetchElements;
---mulTable.js
const fileSystem = require('fs');
const pathModule = require('path');

function fetchMulTable() {
    const fileContent = fileSystem.readFileSync(pathModule.join(__dirname, 'data', 'mul_table.txt'), 'utf-8');
    return fileContent.trim().split('\n').map(currentLine => currentLine.trim().split(/\s+/));
}

module.exports = fetchMulTable;
---ring.js
// ring.js
const fs = require('fs');
const path = require('path');

class AlgebraicStructure {
    constructor(elementsSet, addition, multiplication) {
        this.elementsSet = elementsSet;
        this.addition = addition;
        this.multiplication = multiplication;
        this.identityElement = null;
        this.unitElement = null;
        this.resultFilePath = path.join(__dirname, 'result'); // Путь к файлу result
        this.initializeResultFile();
    }

    // Метод для инициализации/очистки файла result при создании экземпляра класса
    initializeResultFile() {
        try {
            fs.writeFileSync(this.resultFilePath, ''); // Очищаем файл при инициализации
        } catch (error) {
            console.error('Ошибка при инициализации файла result:', error);
        }
    }

    log(message) {
        try {
            fs.appendFileSync(this.resultFilePath, message + '\n');
        } catch (error) {
            console.error('Ошибка при записи в файл result:', error);
        }
    }

    checkCommutativity(operationFunc, operationLabel) {
        for (let firstElement of this.elementsSet) {
            for (let secondElement of this.elementsSet) {
                if (operationFunc(firstElement, secondElement) !== operationFunc(secondElement, firstElement)) {
                    return false;
                }
            }
        }
        if (operationLabel === 'сложения') {
            this.log(`Проверка аксиомы 4 успешно завершена.`);
        }
        else if (operationLabel === 'умножения') {
            this.log(`Проверка аксиомы 9 успешно завершена.`);
        }

        return true;
    }

    checkAssociativity(operationFunc, operationLabel) {
        for (let a of this.elementsSet) {
            for (let b of this.elementsSet) {
                for (let c of this.elementsSet) {
                    if (operationFunc(operationFunc(a, b), c) !== operationFunc(a, operationFunc(b, c))) {
                        return false;
                    }
                }
            }
        }

        if (operationLabel === 'сложения') {
            this.log(`Проверка аксиомы 1 успешно завершена.`);
        }
        else if (operationLabel === 'умножения') {
            this.log(`Проверка аксиомы 7 успешно завершена.`);
        }
        return true;
    }

    findNeutralElement(operationFunc, operationLabel) {
        for (let candidate of this.elementsSet) {
            let isNeutral = true;
            for (let element of this.elementsSet) {
                if (operationFunc(candidate, element) !== element || operationFunc(element, candidate) !== element) {
                    isNeutral = false;
                    break;
                }
            }
            if (isNeutral) {
                return candidate;
            }
        }
        return null;
    }

    verifyInverses() {
        for (let elementA of this.elementsSet) {
            let hasInverse = false;
            for (let elementB of this.elementsSet) {
                if (this.addition(elementA, elementB) === this.identityElement) {
                    hasInverse = true;
                    break;
                }
            }
            if (!hasInverse) return false;
        }
        this.log("Проверка аксиомы 3 успешно завершена.");
        return true;
    }

    verifyDistributivity() {
        for (let a of this.elementsSet) {
            for (let b of this.elementsSet) {
                for (let c of this.elementsSet) {
                    if (this.multiplication(a, this.addition(b, c)) !== this.addition(this.multiplication(a, b), this.multiplication(a, c))) {
                        return false;
                    }
                    if (this.multiplication(this.addition(b, c), a) !== this.addition(this.multiplication(b, a), this.multiplication(c, a))) {
                        return false;
                    }
                }
            }
        }
        this.log("Проверка аксиом 5 и 6 успешно завершена.");
        return true;
    }

    validateRing() {
        this.log("Начало проверки структуры на соответствие кольцу.");
        
        // Проверка аксиомы 2: Существование нейтрального элемента относительно сложения
        this.identityElement = this.findNeutralElement(this.addition, 'сложения'); // 2 аксиома
        if (this.identityElement !== null) {
            this.log("Проверка аксиомы 2 успешно завершена.");
        } else {
            this.log("Проверка аксиомы 2 не выполнена.");
            return false;
        }

        // Проверка аксиомы 8: Существование нейтрального элемента относительно умножения
        this.unitElement = this.findNeutralElement(this.multiplication, 'умножения'); // 8 аксиома
        if (this.unitElement !== null) {
            this.log("Проверка аксиомы 8 успешно завершена.");
        } else {
            this.log("Проверка аксиомы 8 не выполнена.");
            return false;
        }

        const isValid = (
            this.checkAssociativity(this.addition, 'сложения') && // 1 аксиома
            // Аксиома 2 уже проверена выше
            this.checkCommutativity(this.addition, 'сложения') && // 4 аксиома
            this.checkCommutativity(this.multiplication, 'умножения') && // 9 аксиома
            this.checkAssociativity(this.multiplication, 'умножения') && // 7 аксиома
            this.verifyInverses() && // 3 аксиома
            this.verifyDistributivity() // 5 и 6 аксиома
            // Аксиома 8 уже проверена выше
        );
        return isValid;
    }

    getInvertibleElements() {
        this.log(`Начинаем поиск обратимых элементов.`);
        const invertibleSet = new Set();
        for (let elementA of this.elementsSet) {
            for (let elementB of this.elementsSet) {
                if (this.multiplication(elementA, elementB) === this.unitElement && this.multiplication(elementB, elementA) === this.unitElement) {
                    invertibleSet.add(elementA);
                    this.log(`${elementA}^(-1) = ${elementB}`);
                    break;
                }
            }
        }
        return invertibleSet;
    }

    verifyMultiplicativeGroup(invertibleSet) {
        if (!invertibleSet.has(this.unitElement)) {
            return false;
        }
        for (let elementA of invertibleSet) {
            for (let elementB of invertibleSet) {
                if (!invertibleSet.has(this.multiplication(elementA, elementB))) {
                    return false;
                }
            }
        }
        this.log("Проверка замкнутости по умножению успешно завершена.");
        return true;
    }

    validateMultiplicativeGroupWithUnit(invertibleSet) {
        this.log("Начинаем проверку на мультипликативную группу.");
        const isGroup = (
            this.unitElement !== null && 
            this.checkAssociativity(this.multiplication, 'умножения') &&
            this.verifyMultiplicativeGroup(invertibleSet)
        );
        return isGroup;
    }

    evaluateRingProperties() {
        if (!this.validateRing()) {
            this.log("Множество НЕ является ассоциативным кольцом с единицей.");
            return;
        }
        this.log("Множество является ассоциативным кольцом с единицей.");

        const invertibleSet = this.getInvertibleElements();
        if (this.validateMultiplicativeGroupWithUnit(invertibleSet)) {
            this.log(`Ответ: Обратимые элементы {${Array.from(invertibleSet).join(', ')}} образуют мультипликативную группу относительно умножения.`);
        } else {
            this.log("Ответ: Обратимые элементы НЕ образуют мультипликативную группу.");
        }
    }
}

module.exports = AlgebraicStructure;
---main.js
// main.js
const loadElements = require('./elements');
const loadAdditionTable = require('./addTable');
const loadMultiplicationTable = require('./mulTable');
const loadInputValue = require('./inputik');
const computeEuler = require('./euler');
const AlgebraicRing = require('./ring');

const elementSet = loadElements();
const additionTable = loadAdditionTable();
const multiplicationTable = loadMultiplicationTable();
const inputNumber = loadInputValue();

// Определение функции сложения на основе таблицы
function performAddition(elementA, elementB) {
    const indexA = elementSet.indexOf(elementA);
    const indexB = elementSet.indexOf(elementB);
    if (indexA === -1 || indexB === -1) {
        throw new Error(`Элемент не найден: элементA=${elementA}, элементB=${elementB}`);
    }
    return additionTable[indexA][indexB];
}

// Определение функции умножения на основе таблицы
function performMultiplication(elementA, elementB) {
    const indexA = elementSet.indexOf(elementA);
    const indexB = elementSet.indexOf(elementB);
    if (indexA === -1 || indexB === -1) {
        throw new Error(`Элемент не найден: элементA=${elementA}, элементB=${elementB}`);
    }
    return multiplicationTable[indexA][indexB];
}

const algebraicRing = new AlgebraicRing(elementSet, performAddition, performMultiplication);
algebraicRing.evaluateRingProperties();

console.log(elements);

for (let x of addTable) {
    console.log(x);
    for (let y of x) {
        console.log(y);
    }
}

console.log(`Порядок (количество элементов) в мультипликативной группе Z${inputNumber} `
    + `равен значению функции Эйлера: phi(${inputNumber}) = ${computeEuler(inputNumber)}`);