math-exercises 3.0.202 → 3.0.204

package/lib/exercises/math/sequences/proofByInduction/proofByInductionWriteMissingStep.js

@@ -0,0 +1,317 @@
+import { tryToAddWrongProp, addValidProp, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode, isEqualNode, } from "../../../../tree/nodes/equations/equalNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { getArrProofByInductionSituationParams, getHydratedProofByInductionSituation, } from "./proofByInductionSituations.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { splitAndKeep } from "../../../../utils/strings/splitAndKeep.js";
+import { isFractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+const getHydrated = (identifiers) => {
+    const { situationParams, isValid, indexForNodeProperty, nodeIdsVarStepDefinition, nodeIdsVarStepInduction, } = identifiers;
+    const situation = getHydratedProofByInductionSituation(situationParams);
+    const [nodeVarStepDefinition, nodeVarStepInduction] = [
+        nodeIdsVarStepDefinition,
+        nodeIdsVarStepInduction,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    switch (situation.id) {
+        case "generalFormulaOfArithmeticoGeometricSequence": {
+            const { nodeA, nodeB } = situation;
+            function createNodeBySubstitutingVar(nodeCarrier, nodeInjected, variableNodeOfCarrier) {
+                return nodeBySubstitutingVar(nodeBySubstitutingVar(nodeBySubstitutingVar(nodeCarrier, nodeInjected, variableNodeOfCarrier), new VariableNode(`u_{${add(nodeInjected, 1).toTex()}}`), new VariableNode(`u_{${add(variableNodeOfCarrier, 1).toTex()}}`)), new VariableNode(`u_{${nodeInjected.toTex()}}`), new VariableNode(`u_{${variableNodeOfCarrier.toTex()}}`));
+            }
+            const nodePropertyWithN = (isValid ? situation.arrNodeValid : situation.arrNodeInvalid)[indexForNodeProperty];
+            const [nodePropertyDefinition, nodePropertyDefinitionPlus1, nodePropertyInduction, nodePropertyInductionPlus1,] = [
+                nodeVarStepDefinition,
+                add(nodeVarStepDefinition, 1),
+                nodeVarStepInduction,
+                add(nodeVarStepInduction, 1),
+            ].map((node) => createNodeBySubstitutingVar(nodePropertyWithN, node, new VariableNode("n")));
+            const nodeSequenceDefinition = new EqualNode(new VariableNode(`u_{${add(nodeVarStepDefinition, 1).toTex()}}`), add(multiply(nodeA, new VariableNode(`u_{${nodeVarStepDefinition.toTex()}}`)), nodeB));
+            const nodeSequenceDefinitionMinus1 = new EqualNode(new VariableNode(`u_{${nodeVarStepDefinition.toTex()}}`), add(multiply(nodeA, new VariableNode(`u_{${substract(nodeVarStepDefinition, 1).toTex()}}`)), nodeB));
+            const arrNodeInductionSteps = [
+                //by def:
+                createNodeBySubstitutingVar(nodeSequenceDefinition, nodeVarStepInduction, nodeVarStepDefinition),
+                //subst by using induction property
+                nodeBySubstitutingVar(nodeBySubstitutingVar(nodeSequenceDefinition, nodePropertyInduction.rightChild, new VariableNode(`u_{${nodeVarStepDefinition.toTex()}}`)), new VariableNode(`u_{${add(nodeVarStepInduction, 1).toTex()}}`), new VariableNode(`u_{${add(nodeVarStepDefinition, 1).toTex()}}`)),
+                //rewrite to exhibit induction + 1
+                nodePropertyInductionPlus1,
+            ];
+            return {
+                situation,
+                nodeVarStepDefinition,
+                nodeSequenceDefinition,
+                nodeVarStepInduction,
+                nodePropertyInduction,
+                nodePropertyDefinition,
+                nodePropertyDefinitionPlus1,
+                nodePropertyInductionPlus1,
+                arrNodeInductionSteps,
+                nodeSequenceDefinitionMinus1,
+            };
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getInstruction = (identifiers) => {
+    const { situation, nodePropertyDefinition, nodeVarStepDefinition, nodeVarStepInduction, arrNodeInductionSteps, } = getHydrated(identifiers);
+    const { n0 } = situation;
+    switch (situation.id) {
+        case "generalFormulaOfArithmeticoGeometricSequence": {
+            return `${situation.strContext}
+
+Pour $${nodeVarStepDefinition.toTex()} \\geq ${n0}$, on note $\\mathcal{P}(${nodeVarStepDefinition.toTex()})$ la propriété : 
+
+$$
+\\mathcal{P}(${nodeVarStepDefinition.toTex()}) :\\ \\ ${nodePropertyDefinition.toTex()}  
+$$
+
+Donner l'étape manquante de la démonstration de l'hérédité de $\\mathcal{P}$ : 
+
+Soit $${nodeVarStepInduction.toTex()}$ un entier tel que $${nodeVarStepInduction.toTex()} \\geq ${n0}$.
+On suppose la propriété $\\mathcal{P}(${nodeVarStepInduction.toTex()})$ vraie.
+
+${alignTex([
+                arrNodeInductionSteps[0],
+                new VariableNode("..."),
+                arrNodeInductionSteps[2],
+            ].map((node) => splitAndKeep(node.toTex(), "=")))}
+
+`;
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getAnswerNode = (identifiers) => {
+    const { arrNodeInductionSteps } = getHydrated(identifiers);
+    return arrNodeInductionSteps[1];
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsVarStepInduction } = identifiers;
+    const [nodeVarStepInduction] = [nodeIdsVarStepInduction].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Utilise $\\mathcal{P}(${nodeVarStepInduction.toTex()})$ pour substituer $u_{${nodeVarStepInduction.toTex()}}$ dans l'égalité juste avant l'étape manquante.`;
+};
+const getCorrection = (identifiers) => {
+    const { situation, nodeVarStepInduction, arrNodeInductionSteps } = getHydrated(identifiers);
+    const { n0 } = situation;
+    switch (situation.id) {
+        case "generalFormulaOfArithmeticoGeometricSequence": {
+            return `Voici la rédaction complète de la démonstration de l'hérédité de $\\mathcal{P}$ :
+      
+Soit $${nodeVarStepInduction.toTex()}$ un entier tel que $${nodeVarStepInduction.toTex()} \\geq ${n0}$.
+On suppose la propriété $\\mathcal{P}(${nodeVarStepInduction.toTex()})$ vraie.
+
+Par définition : 
+
+$$
+${arrNodeInductionSteps[0].toTex()}
+$$
+
+On utilise $\\mathcal{P}(${nodeVarStepInduction.toTex()})$ : 
+
+$$
+${arrNodeInductionSteps[1].toTex()}
+$$
+
+On réécrit l'égalité pour faire apparaître $\\mathcal{P}(${add(nodeVarStepInduction, 1).toTex()})$ :
+
+$$
+${arrNodeInductionSteps[2].toTex()}
+$$
+
+On vient de montrer que si $\\mathcal{P}(${nodeVarStepInduction.toTex()})$ est vraie alors $\\mathcal{P}(${add(nodeVarStepInduction, 1).toTex()})$ est vraie, 
+autrement dit que $\\mathcal{P}$ est héréditaire.
+
+`;
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeSequenceDefinition, nodePropertyDefinition, nodeSequenceDefinitionMinus1, nodeVarStepDefinition, nodeVarStepInduction, arrNodeInductionSteps, } = getHydrated(identifiers);
+    //student: uses def prop again
+    {
+        const equalNodeWrong = nodeBySubstitutingVar(nodeBySubstitutingVar(nodeSequenceDefinition, nodeSequenceDefinitionMinus1.rightChild, new VariableNode(`u_{${nodeVarStepDefinition.toTex()}}`)), new VariableNode(`u_{${add(nodeVarStepInduction, 1).toTex()}}`), new VariableNode(`u_{${add(nodeVarStepDefinition, 1).toTex()}}`));
+        tryToAddWrongProp(propositions, equalNodeWrong.toTex());
+    }
+    //student: wrong variable
+    {
+        const equalNodeWrong = nodeBySubstitutingVar(nodeBySubstitutingVar(nodeSequenceDefinition, nodePropertyDefinition.rightChild, new VariableNode(`u_{${nodeVarStepDefinition.toTex()}}`)), new VariableNode(`u_{${add(nodeVarStepInduction, 1).toTex()}}`), new VariableNode(`u_{${add(nodeVarStepDefinition, 1).toTex()}}`));
+        tryToAddWrongProp(propositions, equalNodeWrong.toTex());
+    }
+    //student: forgets to add b
+    {
+        const equalNodeValid = arrNodeInductionSteps[1];
+        const equalNodeWrong = new EqualNode(equalNodeValid.leftChild, equalNodeValid.rightChild.leftChild);
+        tryToAddWrongProp(propositions, equalNodeWrong.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { nodeIdsVarStepDefinition, nodeIdsVarStepInduction } = identifiers;
+    const [nodeVarStepDefinition, nodeVarStepInduction] = [
+        nodeIdsVarStepDefinition,
+        nodeIdsVarStepInduction,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrLetter = [nodeVarStepDefinition, nodeVarStepInduction].map((nodeVar) => nodeVar.name);
+    return ["u", ...arrLetter, "underscore", "equal"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        //TODO faire fonctionner parseAlgebraic("u_n=3+2n") (token _ not implemented)
+        const nodeAnswer = getAnswerNode(identifiers);
+        if (!ans.includes("=")) {
+            // return false;
+            ans = nodeAnswer.leftChild.toTex() + "=" + ans;
+        }
+        // const nodeAns = parseAlgebraic(ans);
+        const nodeAns = (() => {
+            const [lhs, rhs] = ans.split("=");
+            const nodeLhs = lhs.toTree();
+            const nodeRhs = parseAlgebraic(rhs);
+            return new EqualNode(nodeLhs, nodeRhs);
+        })();
+        if (!isEqualNode(nodeAns)) {
+            return false;
+        }
+        const isValidLhs = () => nodeAns.leftChild.toTex() === nodeAnswer.leftChild.toTex();
+        const isValidRhs = () => {
+            const nodeAnsRhs = nodeAns.rightChild;
+            const nodeAnswerRhs = nodeAnswer.rightChild;
+            const { nodeIdsVarStepInduction } = identifiers;
+            const [nodeVarStepInduction] = [nodeIdsVarStepInduction].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            return NodeComparator.isEqualViaRandomEvaluations(nodeAnsRhs, nodeAnswerRhs, 3, 6, nodeVarStepInduction, () => randint(0, 20));
+        };
+        return isValidLhs() && isValidRhs();
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const createRandomIdentifiers = () => {
+    const [situationParams] = getArrProofByInductionSituationParams([
+        "generalFormulaOfArithmeticoGeometricSequence",
+    ]);
+    const [isValid, indexForNodeProperty] = [true, 0];
+    const [nodeVarStepDefinition, nodeVarStepInduction] = randomMany(["n", "k", "p", "m"], 2).map((letter) => new VariableNode(letter));
+    const identifiers = {
+        situationParams,
+        isValid,
+        indexForNodeProperty,
+        nodeIdsVarStepDefinition: nodeVarStepDefinition.toIdentifiers(),
+        nodeIdsVarStepInduction: nodeVarStepInduction.toIdentifiers(),
+    };
+    return identifiers;
+};
+const isIdentifiersQCPassed = (identifiers) => {
+    const isExploding = (identifiers) => {
+        let isExploding = false;
+        try {
+            //ensure r is an integer
+            {
+                const { situationParams } = identifiers;
+                const situation = getHydratedProofByInductionSituation(situationParams);
+                switch (situation.id) {
+                    case "generalFormulaOfArithmeticoGeometricSequence":
+                        {
+                            const { nodeR, nodeInitial } = situation;
+                            if (isFractionNode(nodeR) ||
+                                isFractionNode(opposite(nodeR).simplify())) {
+                                isExploding = true;
+                            }
+                            if (NodeComparator.isEqualViaSub(nodeInitial, nodeR)) {
+                                isExploding = true;
+                            }
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported situation.id: " + situation.id);
+                }
+            }
+            getAnswer(identifiers);
+        }
+        catch (_) {
+            isExploding = true;
+        }
+        return isExploding;
+    };
+    return !isExploding(identifiers);
+};
+const createQCPassedIdentifiers = () => {
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiers();
+        isValid = isIdentifiersQCPassed(identifiersCandidate);
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        const [situationParams] = getArrProofByInductionSituationParams([
+            "generalFormulaOfArithmeticoGeometricSequence",
+        ]);
+        const [nodeVarStepDefinition, nodeVarStepInduction] = randomMany(["n", "k", "p", "m"], 2).map((letter) => new VariableNode(letter));
+        const identifiersDefault = (() => {
+            return {
+                situationParams,
+                isValid: true,
+                indexForNodeProperty: 0,
+                nodeIdsVarStepDefinition: nodeVarStepDefinition.toIdentifiers(),
+                nodeIdsVarStepInduction: nodeVarStepInduction.toIdentifiers(),
+            };
+        })();
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getProofByInductionWriteMissingStepQuestion = () => {
+    const identifiers = createQCPassedIdentifiers();
+    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 proofByInductionWriteMissingStep = {
+    id: "proofByInductionWriteMissingStep",
+    connector: "=",
+    label: "Hérédité : Compléter une étape manquante",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getProofByInductionWriteMissingStepQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/proofByInduction/proofByInductionWritePropAtRankKPlus1.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+import { ProofByInductionSituationParams } from "./proofByInductionSituations.js";
+type Identifiers = {
+    situationParams: ProofByInductionSituationParams;
+    isValid: boolean;
+    indexForNodeProperty: number;
+    nodeIdsVarStepDefinition: NodeIdentifiers;
+    nodeIdsVarStepInduction: NodeIdentifiers;
+};
+export declare const proofByInductionWritePropAtRankKPlus1: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=proofByInductionWritePropAtRankKPlus1.d.ts.map

package/lib/exercises/math/sequences/proofByInduction/proofByInductionWritePropAtRankKPlus1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proofByInductionWritePropAtRankKPlus1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/proofByInduction/proofByInductionWritePropAtRankKPlus1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,OAAO,EAGL,+BAA+B,EAChC,MAAM,iCAAiC,CAAC;AAMzC,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,+BAA+B,CAAC;IACjD,OAAO,EAAE,OAAO,CAAC;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,wBAAwB,EAAE,eAAe,CAAC;IAC1C,uBAAuB,EAAE,eAAe,CAAC;CAC1C,CAAC;AAwWF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAiBvE,CAAC"}

package/lib/exercises/math/sequences/proofByInduction/proofByInductionWritePropAtRankKPlus1.js

@@ -0,0 +1,265 @@
+import { tryToAddWrongProp, addValidProp, shuffleProps, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode, isEqualNode, } from "../../../../tree/nodes/equations/equalNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { getArrProofByInductionSituationParams, getHydratedProofByInductionSituation, } from "./proofByInductionSituations.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getHydrated = (identifiers) => {
+    const { situationParams, isValid, indexForNodeProperty, nodeIdsVarStepDefinition, nodeIdsVarStepInduction, } = identifiers;
+    const situation = getHydratedProofByInductionSituation(situationParams);
+    const [nodeVarStepDefinition, nodeVarStepInduction] = [
+        nodeIdsVarStepDefinition,
+        nodeIdsVarStepInduction,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    switch (situation.id) {
+        case "generalFormulaOfArithmeticoGeometricSequence": {
+            const nodePropertyWithN = (isValid ? situation.arrNodeValid : situation.arrNodeInvalid)[indexForNodeProperty];
+            function createNodePropertySubstituted(nodeInjected) {
+                return nodeBySubstitutingVar(nodeBySubstitutingVar(nodePropertyWithN, nodeInjected, new VariableNode("n")), new VariableNode(`u_{${nodeInjected.toTex()}}`), new VariableNode("u_{n}"));
+            }
+            const [nodePropertyDefinition, nodePropertyDefinitionPlus1, nodePropertyInduction, nodePropertyInductionPlus1,] = [
+                nodeVarStepDefinition,
+                add(nodeVarStepDefinition, 1),
+                nodeVarStepInduction,
+                add(nodeVarStepInduction, 1),
+            ].map((node) => createNodePropertySubstituted(node));
+            return {
+                situation,
+                isValid,
+                nodeVarStepDefinition,
+                nodePropertyDefinition,
+                nodePropertyDefinitionPlus1,
+                nodeVarStepInduction,
+                nodePropertyInduction,
+                nodePropertyInductionPlus1,
+            };
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getInstruction = (identifiers) => {
+    const { situation, nodePropertyDefinition, nodeVarStepDefinition, nodeVarStepInduction, } = getHydrated(identifiers);
+    const { n0 } = situation;
+    switch (situation.id) {
+        case "generalFormulaOfArithmeticoGeometricSequence": {
+            return `${situation.strContext}
+
+Pour $${nodeVarStepDefinition.toTex()} \\geq ${n0}$, on note $\\mathcal{P}(${nodeVarStepDefinition.toTex()})$ la propriété : 
+
+$$
+\\mathcal{P}(${nodeVarStepDefinition.toTex()}) :\\ \\ ${nodePropertyDefinition.toTex()}  
+$$
+
+Soit $${nodeVarStepInduction.toTex()}$ un entier tel que $${nodeVarStepInduction.toTex()} \\geq ${n0}$.
+On suppose la propriété $\\mathcal{P}(${nodeVarStepInduction.toTex()})$ vraie.
+
+Quelle est l'égalité qui correspond à la propriété $\\mathcal{P}(${add(nodeVarStepInduction, 1).toTex()})$ ?
+`;
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getAnswer = (identifiers) => {
+    const { nodePropertyInductionPlus1 } = getHydrated(identifiers);
+    return nodePropertyInductionPlus1.toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeIdsVarStepInduction } = identifiers;
+    const [nodeVarStepInduction] = [nodeIdsVarStepInduction].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Substitue $${nodeVarStepInduction.toTex()}$ par $${add(nodeVarStepInduction, 1).toTex()}$ dans l'égalité proposée.`;
+};
+const getCorrection = (identifiers) => {
+    const { situation, nodePropertyInductionPlus1, nodeVarStepInduction } = getHydrated(identifiers);
+    switch (situation.id) {
+        case "generalFormulaOfArithmeticoGeometricSequence": {
+            return `Pour vérifier que la propriété est héréditaire, 
+il faut démontrer que si on suppose $\\mathcal{P}(${nodeVarStepInduction.toTex()})$ vraie alors $\\mathcal{P}(${add(nodeVarStepInduction, 1).toTex()})$ est vraie.
+
+On s'intéresse donc à $\\mathcal{P}(${add(nodeVarStepInduction, 1).toTex()})$,
+autrement dit à l'égalité : 
+
+$$
+${nodePropertyInductionPlus1.toTex()}
+$$
+
+`;
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodePropertyDefinition, nodePropertyDefinitionPlus1, nodePropertyInduction, nodePropertyInductionPlus1, } = getHydrated(identifiers);
+    tryToAddWrongProp(propositions, nodePropertyDefinitionPlus1.toTex());
+    const [arrLhs, arrRhs] = [0, 1].map((i) => [
+        nodePropertyDefinition,
+        nodePropertyInduction,
+        nodePropertyInductionPlus1,
+        nodePropertyDefinitionPlus1,
+    ].map((equalNode) => i === 0 ? equalNode.leftChild : equalNode.rightChild));
+    const arrEqualNode = shuffle(getCartesiansProducts([arrLhs, arrRhs]).map(([nodeLhs, nodeRhs]) => new EqualNode(nodeLhs, nodeRhs)));
+    propWhile(propositions, n, () => {
+        const equalNodeWrong = arrEqualNode.pop();
+        tryToAddWrongProp(propositions, equalNodeWrong.toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { nodeIdsVarStepDefinition, nodeIdsVarStepInduction } = identifiers;
+    const [nodeVarStepDefinition, nodeVarStepInduction] = [
+        nodeIdsVarStepDefinition,
+        nodeIdsVarStepInduction,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrLetter = [nodeVarStepDefinition, nodeVarStepInduction].map((nodeVar) => nodeVar.name);
+    return ["u", ...arrLetter, "underscore", "equal"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        //TODO faire fonctionner parseAlgebraic("u_n=3+2n") (token _ not implemented)
+        const nodeAnswer = getHydrated(identifiers)
+            .nodePropertyInductionPlus1;
+        if (!ans.includes("=")) {
+            // return false;
+            ans = nodeAnswer.leftChild.toTex() + "=" + ans;
+        }
+        // const nodeAns = parseAlgebraic(ans);
+        const nodeAns = (() => {
+            const [lhs, rhs] = ans.split("=");
+            const nodeLhs = lhs.toTree();
+            const nodeRhs = parseAlgebraic(rhs);
+            return new EqualNode(nodeLhs, nodeRhs);
+        })();
+        if (!isEqualNode(nodeAns)) {
+            return false;
+        }
+        const isValidLhs = () => nodeAns.leftChild.toTex() === nodeAnswer.leftChild.toTex();
+        const isValidRhs = () => {
+            const nodeAnsRhs = nodeAns.rightChild;
+            const nodeAnswerRhs = nodeAnswer.rightChild;
+            const { nodeIdsVarStepInduction } = identifiers;
+            const [nodeVarStepInduction] = [nodeIdsVarStepInduction].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            return NodeComparator.isEqualViaRandomEvaluations(nodeAnsRhs, nodeAnswerRhs, 3, 6, nodeVarStepInduction, () => randint(0, 20));
+        };
+        return isValidLhs() && isValidRhs();
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const createRandomIdentifiers = () => {
+    const [situationParams] = getArrProofByInductionSituationParams([
+        "generalFormulaOfArithmeticoGeometricSequence",
+    ]);
+    const situation = getHydratedProofByInductionSituation(situationParams);
+    const [isValid, indexForNodeProperty] = (() => {
+        switch (situation.id) {
+            case "generalFormulaOfArithmeticoGeometricSequence": {
+                const isValid = coinFlip();
+                const indexForNodeProperty = randint(0, isValid
+                    ? situation.arrNodeValid.length
+                    : situation.arrNodeInvalid.length);
+                return [isValid, indexForNodeProperty];
+            }
+            default:
+                throw new Error("Unsupported situation.id: " + situation.id);
+        }
+    })();
+    const [nodeVarStepDefinition, nodeVarStepInduction] = randomMany(["n", "k", "p", "m"], 2).map((letter) => new VariableNode(letter));
+    const identifiers = {
+        situationParams,
+        isValid,
+        indexForNodeProperty,
+        nodeIdsVarStepDefinition: nodeVarStepDefinition.toIdentifiers(),
+        nodeIdsVarStepInduction: nodeVarStepInduction.toIdentifiers(),
+    };
+    return identifiers;
+};
+// const isIdentifiersQCPassed = (identifiers: Identifiers) => {
+//   const isExploding = (identifiers: Identifiers) => {
+//     let isExploding = false;
+//     try {
+//       getAnswer(identifiers);
+//     } catch (_) {
+//       isExploding = true;
+//     }
+//     return isExploding;
+//   };
+//   return !isExploding(identifiers);
+// };
+// const createQCPassedIdentifiers = () => {
+//   let identifiers: Identifiers;
+//   let counter = -1;
+//   let isValid = false;
+//   while (!isValid && counter < 100) {
+//     counter++;
+//     const identifiersCandidate = createRandomIdentifiers();
+//     isValid = isIdentifiersQCPassed(identifiersCandidate);
+//     if (isValid) {
+//       identifiers = identifiersCandidate;
+//     }
+//   }
+//   if (!isValid) {
+//     const [situationParams] = getArrProofByInductionSituationParams([
+//       "generalFormulaOfArithmeticoGeometricSequence",
+//     ]);
+//     const [nodeVarStepDefinition, nodeVarStepInduction] = randomMany(
+//       ["n", "k", "p", "m"],
+//       2,
+//     ).map((letter) => new VariableNode(letter));
+//     const identifiersDefault: Identifiers = (() => {
+//       return {
+//         situationParams,
+//         isValid: true,
+//         indexForNodeProperty: 0,
+//         nodeIdsVarStepDefinition: nodeVarStepDefinition.toIdentifiers(),
+//         nodeIdsVarStepInduction: nodeVarStepInduction.toIdentifiers(),
+//       };
+//     })();
+//     identifiers = identifiersDefault;
+//   }
+//   return identifiers!;
+// };
+const getProofByInductionWritePropAtRankKPlus1Question = () => {
+    const identifiers = createRandomIdentifiers();
+    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 proofByInductionWritePropAtRankKPlus1 = {
+    id: "proofByInductionWritePropAtRankKPlus1",
+    connector: "=",
+    label: "Hérédité : Écrire au rang $k+1$ une propriété donnée au rang $k$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getProofByInductionWritePropAtRankKPlus1Question(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1 +1 @@
-{"version":3,"file":"polynomialVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/polynomialVEA.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,QAAQ,MAAM,YAmBxD,CAAC"}
+{"version":3,"file":"polynomialVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/polynomialVEA.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,QAAQ,MAAM,YAuBxD,CAAC"}

package/lib/exercises/vea/polynomialVEA.js

@@ -1,11 +1,15 @@
 import { getArrNodeCoeffOfPolynomialNode } from "../../math/utils/polynomial/polynomialUtils.js";
 import { substract } from "../../tree/nodes/operators/substractNode.js";
+import { isIDontKnowNode } from "../../tree/nodes/student/iDontKnowNode.js";
 import { parseAlgebraic } from "../../tree/parsers/latexParser.js";
 import { zip } from "../../utils/arrays/arrayZip.js";
 import { handleVEAError } from "../../utils/errors/handleVEAError.js";
 export const polynomialVEA = (ans, answer) => {
     try {
         const nodeAns = parseAlgebraic(ans);
+        if (isIDontKnowNode(nodeAns)) {
+            return false;
+        }
         const nodeAnswer = parseAlgebraic(answer);
         const [arrNodeCoeffAns, arrNodeCoeffAnswer] = [nodeAns, nodeAnswer].map((node) => getArrNodeCoeffOfPolynomialNode(node));
         return (arrNodeCoeffAns.length === arrNodeCoeffAnswer.length &&