math-exercises 3.0.215 → 3.0.216

package/lib/exercises/math/matrices/matrixComputePower.js

@@ -0,0 +1,230 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Matrix, MatrixConstructor, } from "../../../math/matrices/matrix.js";
+import { parseMatrix } from "../../../math/matrices/parseMatrix.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../tree/nodes/operators/powerNode.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { matIdsA, exponent } = identifiers;
+    const [matA] = [matIdsA].map((matIds) => MatrixConstructor.fromIdentifiers(matIds));
+    const nodeExprInstruction = power("A".toTree(), exponent);
+    return {
+        matA,
+        nodeExprInstruction,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { matA, nodeExprInstruction } = getHydrated(identifiers);
+    return `Soit :
+
+$$
+A = ${matA.toTex()}
+$$
+
+Calculer $${nodeExprInstruction.toTex()}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { exponent } = identifiers;
+    const { matA } = getHydrated(identifiers);
+    const matProduct = matA.power(exponent);
+    const matProductSimplified = matProduct.simplify({ towardsDistribute: true });
+    return matProductSimplified.toTex();
+};
+const getHint = () => {
+    const matA = new Matrix([
+        ["a".toTree(), "b".toTree()],
+        ["c".toTree(), "d".toTree()],
+    ]);
+    const matASpaced = new Matrix([
+        ["\\ \\ \\ a".toTree(), "\\ \\ \\ \\ \\ b \\ \\ \\ ".toTree()],
+        ["\\ \\ \\ c".toTree(), "\\ \\ \\ \\ \\ d \\ \\ \\ ".toTree()],
+    ]);
+    return `Soient $A$ une matrice à $2$ lignes et $2$ colonnes à coefficients réels.
+  
+$$
+A = ${matA.toTex()}
+$$
+
+Pour calculer $A^2=AA$,
+tu peux disposer les matrices de cette façon pour ne pas te tromper :
+
+$$
+\\begin{matrix} {\\begin{matrix} \\  & \\  \\\\ \\  & \\  \\end{matrix}} & {${matASpaced.toTex()}} \\\\ {${matA.toTex()}} & {\\begin{pmatrix} {...} & {ab+bd}  \\\\ {...}  & {...}  \\end{pmatrix}} \\end{matrix}
+$$
+
+Ce qui donne :
+
+$$
+A^2 = AA = ${matA.matrixProduct(matA).toTex()}
+$$
+
+Continue ainsi pour les autres puissances de $A$ :
+
+$$
+A^3 = AAA = A^2 A
+$$
+
+etc.
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { exponent } = identifiers;
+    const { matA } = getHydrated(identifiers);
+    const matA2 = matA.matrixProduct(matA);
+    const matA2Simplified = matA2.simplify({ towardsDistribute: true });
+    const matA3 = matA2Simplified.matrixProduct(matA);
+    const matA3Simplified = matA3.simplify({ towardsDistribute: true });
+    switch (exponent) {
+        case 2:
+            return `${alignTex([
+                ["", "A^2"],
+                ["=", `${matA.toTex()} ${matA.toTex()}`],
+                ["=", matA2.toTex()],
+                ["=", matA2Simplified.toTex()],
+            ])}`;
+        case 3:
+            return `
+      
+${alignTex([
+                ["", "A^2"],
+                ["=", `${matA.toTex()} ${matA.toTex()}`],
+                ["=", matA2.toTex()],
+                ["=", matA2Simplified.toTex()],
+            ])}
+      
+${alignTex([
+                ["", "A^3"],
+                ["=", "A^2 A"],
+                ["=", `${matA2Simplified.toTex()} ${matA.toTex()}`],
+                ["=", matA3.toTex()],
+                ["=", matA3Simplified.toTex()],
+            ])}
+      
+`;
+        default:
+            throw new Error("Unsupported exponent: " + exponent);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { exponent } = identifiers;
+    const { matA } = getHydrated(identifiers);
+    function createPowerFuncWrong(funcAB) {
+        const func = (matA, exponent) => [...Array(exponent).keys()].reduce((acc, i) => {
+            if (i === 0) {
+                return matA;
+            }
+            else {
+                return funcAB(acc, matA);
+            }
+        }, matA);
+        return func;
+    }
+    //student: AB = A+B
+    {
+        const powerFuncWrong = createPowerFuncWrong((matA, matB) => matA.add(matB));
+        const matWrong = powerFuncWrong(matA, exponent);
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //student: AB = (a_{ij}b_{ij})
+    {
+        function matrixProductWrong(mat1, mat2) {
+            const arrElementSumWrong = mat1.elements.map((row, i) => row.map((elt1, j) => {
+                const elt2 = mat2.elements[i][j];
+                return multiply(elt1, elt2);
+            }));
+            return new Matrix(arrElementSumWrong);
+        }
+        const powerFuncWrong = createPowerFuncWrong(matrixProductWrong);
+        const matWrong = powerFuncWrong(matA, exponent);
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //student: AB = (sum(a_{ik}b_{jk}))
+    {
+        const powerFuncWrong = createPowerFuncWrong((matA, matB) => matA.matrixProduct(matB.transposed()));
+        const matWrong = powerFuncWrong(matA, exponent);
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //filler
+    {
+        propWhile(propositions, n, () => {
+            const identifiersWrong = createRandomIdentifiers(opts);
+            tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["mat-2-2"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const matAns = parseMatrix(ans);
+        const matAnswer = parseMatrix(answer);
+        return matAns.equals(matAnswer);
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const matA = MatrixConstructor.random(2, 2);
+    const exponent = parseInt(opts.exponent);
+    const identifiers = {
+        matIdsA: matA.toIdentifiers(),
+        exponent,
+    };
+    return identifiers;
+};
+const getMatrixComputePowerQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, optsIn) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: optsIn,
+    };
+    return question;
+};
+const optsDefault = {
+    exponent: "2",
+};
+const options = [
+    {
+        id: "exponent",
+        label: "Valeur de l'exposant",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["2", "3"],
+        defaultValue: optsDefault.exponent,
+    },
+];
+export const matrixComputePower = {
+    id: "matrixComputePower",
+    connector: "=",
+    label: "Calculer une puissance d'une matrice",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMatrixComputePowerQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/matrices/matrixComputeProduct.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { MatrixIdentifiers } from "../../../math/matrices/matrix.js";
+type Identifiers = {
+    matIdsA: MatrixIdentifiers;
+    matIdsB: MatrixIdentifiers;
+};
+export declare const matrixComputeProduct: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=matrixComputeProduct.d.ts.map

package/lib/exercises/math/matrices/matrixComputeProduct.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrixComputeProduct.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/matrixComputeProduct.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAOvC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,iBAAiB,CAAC;IAC3B,OAAO,EAAE,iBAAiB,CAAC;CAC5B,CAAC;AA0MF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/math/matrices/matrixComputeProduct.js

@@ -0,0 +1,178 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Matrix, MatrixConstructor, } from "../../../math/matrices/matrix.js";
+import { parseMatrix } from "../../../math/matrices/parseMatrix.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { matIdsA, matIdsB } = identifiers;
+    const [matA, matB] = [matIdsA, matIdsB].map((matIds) => MatrixConstructor.fromIdentifiers(matIds));
+    const nodeExprInstruction = multiply("A".toTree(), "B".toTree()).simplify();
+    return {
+        matA,
+        matB,
+        nodeExprInstruction,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { matA, matB, nodeExprInstruction } = getHydrated(identifiers);
+    return `Soient :
+
+$$
+A = ${matA.toTex()}
+$$
+
+$$
+B = ${matB.toTex()}
+$$
+
+Calculer $${nodeExprInstruction.toTex()}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { matA, matB } = getHydrated(identifiers);
+    const matProduct = matA.matrixProduct(matB);
+    const matProductSimplified = matProduct.simplify({ towardsDistribute: true });
+    return matProductSimplified.toTex();
+};
+const getHint = () => {
+    const matA = new Matrix([
+        ["a".toTree(), "b".toTree()],
+        ["c".toTree(), "d".toTree()],
+    ]);
+    const matB = new Matrix([
+        ["r".toTree(), "s".toTree()],
+        ["t".toTree(), "u".toTree()],
+    ]);
+    const matBSpaced = new Matrix([
+        ["\\ \\ \\ r".toTree(), "\\ \\ \\ \\ \\ s \\ \\ \\ ".toTree()],
+        ["\\ \\ \\ t".toTree(), "\\ \\ \\ \\ \\ u \\ \\ \\ ".toTree()],
+    ]);
+    return `Soient $A$ et $B$ deux matrices à $2$ lignes et $2$ colonnes à coefficients réels.
+  
+$$
+A = ${matA.toTex()}
+$$
+
+$$
+B = ${matB.toTex()}
+$$
+
+Pour calculer le produit matriciel $AB$,
+tu peux disposer les matrices $A$ et $B$ de cette façon pour ne pas te tromper :
+
+$$
+\\begin{matrix} {\\begin{matrix} \\  & \\  \\\\ \\  & \\  \\end{matrix}} & {${matBSpaced.toTex()}} \\\\ {${matA.toTex()}} & {\\begin{pmatrix} {...} & {as+bu}  \\\\ {...}  & {...}  \\end{pmatrix}} \\end{matrix}
+$$
+
+Ce qui donne :
+
+$$
+AB = ${matA.matrixProduct(matB).toTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { matA, matB, nodeExprInstruction } = getHydrated(identifiers);
+    const matProduct = matA.matrixProduct(matB);
+    const matProductSimplified = matProduct.simplify({ towardsDistribute: true });
+    return `${alignTex([
+        ["", nodeExprInstruction.toTex()],
+        ["=", `${matA.toTex()} ${matB.toTex()}`],
+        ["=", matProduct.toTex()],
+        ["=", matProductSimplified.toTex()],
+    ])}`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { matA, matB } = getHydrated(identifiers);
+    //student: AB = A+B
+    {
+        const matWrong = matA.add(matB);
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //student: AB = (a_{ij}b_{ij})
+    {
+        function matrixProductWrong(mat1, mat2) {
+            const arrElementSumWrong = mat1.elements.map((row, i) => row.map((elt1, j) => {
+                const elt2 = mat2.elements[i][j];
+                return multiply(elt1, elt2);
+            }));
+            return new Matrix(arrElementSumWrong);
+        }
+        const matWrong = matrixProductWrong(matA, matB);
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //student: AB = (sum(a_{ik}b_{jk}))
+    {
+        const matWrong = matA.matrixProduct(matB.transposed());
+        tryToAddWrongProp(propositions, matWrong.simplify({ towardsDistribute: true }).toTex());
+    }
+    //filler
+    {
+        propWhile(propositions, n, () => {
+            const identifiersWrong = createRandomIdentifiers();
+            tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["mat-2-2"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const matAns = parseMatrix(ans);
+        const matAnswer = parseMatrix(answer);
+        return matAns.equals(matAnswer);
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const createRandomIdentifiers = () => {
+    const nodeKA = (1).toTree();
+    const nodeKB = (2).toTree();
+    const matA = MatrixConstructor.random(2, 2);
+    const matB = MatrixConstructor.random(2, 2);
+    const identifiers = {
+        matIdsA: matA.toIdentifiers(),
+        matIdsB: matB.toIdentifiers(),
+        nodeIdsKA: nodeKA.toIdentifiers(),
+        nodeIdsKB: nodeKB.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getMatrixComputeProductQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const matrixComputeProduct = {
+    id: "matrixComputeProduct",
+    connector: "=",
+    label: "Calculer le produit de deux matrices",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getMatrixComputeProductQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/matrices/writeMatrixAssociatedToSystem.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { GeneralSystemIdentifiers } from "../../../math/systems/generalSystem.js";
+type Identifiers = {
+    systemIds: GeneralSystemIdentifiers;
+};
+export declare const writeMatrixAssociatedToSystem: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=writeMatrixAssociatedToSystem.d.ts.map

package/lib/exercises/math/matrices/writeMatrixAssociatedToSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeMatrixAssociatedToSystem.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/matrices/writeMatrixAssociatedToSystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,wBAAwB,EACzB,MAAM,qCAAqC,CAAC;AAG7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,wBAAwB,CAAC;CACrC,CAAC;AA6FF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAqB/D,CAAC"}

package/lib/exercises/math/matrices/writeMatrixAssociatedToSystem.js

@@ -0,0 +1,105 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { Matrix, MatrixConstructor } from "../../../math/matrices/matrix.js";
+import { parseMatrix } from "../../../math/matrices/parseMatrix.js";
+import { GeneralSystemConstructor, } from "../../../math/systems/generalSystem.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, MatrixConstructor.random(2, 2).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { systemIds } = identifiers;
+    const system = GeneralSystemConstructor.fromIdentifiers(systemIds);
+    const matrix = system.getMatrix();
+    return matrix.toTex();
+};
+const getInstruction = (identifiers) => {
+    const { systemIds } = identifiers;
+    const system = GeneralSystemConstructor.fromIdentifiers(systemIds);
+    return `On considère le système $(S)$ suivant :
+
+$$
+${system.toTex()}
+$$
+
+On cherche à écrire ce système sous forme matricielle : 
+
+$$
+AX = B
+$$
+
+avec $X = \\begin{pmatrix}x\\\\ y\\end{pmatrix}$ et $B = \\begin{pmatrix}${system.coeffs[0][2].toTex()}\\\\ ${system.coeffs[1][2].toTex()}\\end{pmatrix}$.
+
+
+Écrire $A$.`;
+};
+const getHint = () => {
+    return `En faisant le produit de $A$ par $X$, on doit obtenir la partie gauche du système.`;
+};
+const getCorrection = (identifiers) => {
+    const { systemIds } = identifiers;
+    const system = GeneralSystemConstructor.fromIdentifiers(systemIds);
+    const coeffs = system.coeffs.map((row) => row.slice(0, 2));
+    const matrix = new Matrix(coeffs).toTex();
+    return `En posant $X = \\begin{pmatrix}x\\\\ y\\end{pmatrix}$, $B = \\begin{pmatrix}${system.coeffs[0][2].toTex()}\\\\ ${system.coeffs[1][2].toTex()}\\end{pmatrix}$ et :
+  
+$$
+A = ${matrix}
+$$
+
+on obtient bien $(S)\\iff AX=B$.`;
+};
+const getKeys = () => {
+    return ["mat-2-2"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const matAns = parseMatrix(ans);
+        const matAnswer = parseMatrix(answer);
+        return matAns.equals(matAnswer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getWriteMatrixAssociatedToSystemQuestion = () => {
+    const sys = GeneralSystemConstructor.random();
+    const identifiers = {
+        systemIds: sys.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const writeMatrixAssociatedToSystem = {
+    id: "writeMatrixAssociatedToSystem",
+    connector: "=",
+    label: "Écrire la matrice associée à un système d'équations linéaires",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getWriteMatrixAssociatedToSystemQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/vea/matrixVEA.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=matrixVEA.d.ts.map

package/lib/exercises/vea/matrixVEA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrixVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/matrixVEA.ts"],"names":[],"mappings":""}

package/lib/exercises/vea/matrixVEA.js

@@ -0,0 +1 @@
+export {};

package/lib/index.d.ts

@@ -1042,19 +1042,6 @@ declare const mathExercises: (Exercise<{
     minutes: number;
 }, {
     amPmType: string;
-}> | Exercise<{
-    dateTimeStart: {
-        day: number;
-        hours: number;
-        minutes: number;
-    };
-    dateTimeDuration: {
-        day: number;
-        hours: number;
-        minutes: number;
-    };
-}, {
-    hoursMinutesType: string;
 }> | Exercise<{
     point: import("./math/geometry/point.js").PointIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -3283,6 +3270,41 @@ declare const mathExercises: (Exercise<{
     BjCoeff: number;
     i: number;
     j: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    matIdsA: import("./math/matrices/matrix.js").MatrixIdentifiers;
+    matIdsB: import("./math/matrices/matrix.js").MatrixIdentifiers;
+    nodeIdsKA: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsKB: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    typeLinComb: string;
+}> | Exercise<{
+    matIdsA: import("./math/matrices/matrix.js").MatrixIdentifiers;
+    matIdsB: import("./math/matrices/matrix.js").MatrixIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    matIdsA: import("./math/matrices/matrix.js").MatrixIdentifiers;
+    exponent: number;
+}, {
+    exponent: string;
+}> | Exercise<{
+    matIdsA: import("./math/matrices/matrix.js").MatrixIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    matIdsA: import("./math/matrices/matrix.js").MatrixIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    matIdsA: import("./math/matrices/matrix.js").MatrixIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    matIdsA: import("./math/matrices/matrix.js").MatrixIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./math/matrices/matrix.js").MatrixIdentifiers;
+    bIds: import("./math/matrices/matrix.js").MatrixIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    systemIds: import("./math/systems/generalSystem.js").GeneralSystemIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    systemIds: import("./math/systems/generalSystem.js").GeneralSystemIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    matrixIds: import("./math/matrices/matrix.js").MatrixIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./math/matrices/matrix.js").MatrixIdentifiers;
+    bIds: import("./math/matrices/matrix.js").MatrixIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     isPercentToDecimal: boolean;
     nb: number;
@@ -5895,6 +5917,57 @@ declare const mathExercises: (Exercise<{
     nodeIdsInterval: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     nodeIdsDistanceMax: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     keyIncomplete: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    graphIds: import("./math/graphs/graph.js").GraphIdentifiers;
+    graphNodes: import("./math/utils/graphs/graphRenderer.js").GraphNode[];
+    graphEdges: import("./math/utils/graphs/graphRenderer.js").GraphEdge[];
+}, {
+    graphType: string;
+}> | Exercise<{
+    graphIds: import("./math/graphs/graph.js").GraphIdentifiers;
+    indexAsked: number;
+    graphNodes: import("./math/utils/graphs/graphRenderer.js").GraphNode[];
+    graphEdges: import("./math/utils/graphs/graphRenderer.js").GraphEdge[];
+}, {
+    graphType: string;
+}> | Exercise<{
+    graphIds: import("./math/graphs/graph.js").GraphIdentifiers;
+    nameVertex1: string;
+    nameVertex2: string;
+    graphNodes: import("./math/utils/graphs/graphRenderer.js").GraphNode[];
+    graphEdges: import("./math/utils/graphs/graphRenderer.js").GraphEdge[];
+}, {
+    graphType: string;
+}> | Exercise<{
+    graphIds1: import("./math/graphs/graph.js").GraphIdentifiers;
+    graphIds2: import("./math/graphs/graph.js").GraphIdentifiers;
+    graphNodes1: import("./math/utils/graphs/graphRenderer.js").GraphNode[];
+    graphEdges1: import("./math/utils/graphs/graphRenderer.js").GraphEdge[];
+    scale1: number;
+    graphNodes2: import("./math/utils/graphs/graphRenderer.js").GraphNode[];
+    graphEdges2: import("./math/utils/graphs/graphRenderer.js").GraphEdge[];
+    scale2: number;
+}, {
+    graphType: string;
+}> | Exercise<{
+    graphIds: import("./math/graphs/graph.js").GraphIdentifiers;
+    graphNodes: import("./math/utils/graphs/graphRenderer.js").GraphNode[];
+    graphEdges: import("./math/utils/graphs/graphRenderer.js").GraphEdge[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    graphIds: import("./math/graphs/graph.js").GraphIdentifiers;
+    lengthAsked: number;
+    graphNodes: import("./math/utils/graphs/graphRenderer.js").GraphNode[];
+    graphEdges: import("./math/utils/graphs/graphRenderer.js").GraphEdge[];
+}, {
+    graphType: string;
+}> | Exercise<{
+    degrees: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    matrixIds: import("./math/matrices/matrix.js").MatrixIdentifiers;
+    startIndex: number;
+    endIndex: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    matrixIds: import("./math/matrices/matrix.js").MatrixIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     mod: number;