Сделай так, чтобы результат выполнения каждой аксиомы выводился в файл result
Вывод резульатата каждой аксиомы нужно делать 1 раз в формате "Проверка аксиомы N успешно завершена". Вывод должен быть от 1 до 9.
Остальные выводы трогать не нужно (ниже перечислил):
Начало проверки структуры на соответствие кольцу. 
Множество является ассоциативным кольцом с единицей.
Начинаем поиск обратимых элементов.
1^(-1) = 1
3^(-1) = 3
5^(-1) = 5
7^(-1) = 7
Начинаем проверку на мультипликативную группу.
Проверка аксиомы 7 успешно завершена.
Проверка замкнутости по умножению успешно завершена.
Ответ: Обратимые элементы {1, 3, 5, 7} образуют мультипликативную группу относительно умножения.


Программа:// 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("Начало проверки структуры на соответствие кольцу.");
        this.identityElement = this.findNeutralElement(this.addition, 'сложения'); // 2 аксиома
        this.unitElement = this.findNeutralElement(this.multiplication, 'умножения'); // 8 аксиома
        const isValid = (
            this.checkAssociativity(this.addition, 'сложения') && // 1 аксиома
            this.identityElement !== null && // 2 аксиома
            this.unitElement !== null && // 8 аксиома
            this.checkCommutativity(this.addition, 'сложения') && // 4 аксиома
            this.checkCommutativity(this.multiplication, 'умножения') && // 9 аксиома
            this.checkAssociativity(this.multiplication, 'умножения') && // 7 аксиома
            this.verifyInverses() && // 3 аксиома
            this.verifyDistributivity() // 5 и 6 аксиома
        );
        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("Начинаем проверку на мультипликативную группу.");
        this.unitElement = this.findNeutralElement(this.multiplication, 'умножения');
        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;