math-exercises 3.0.202 → 3.0.203

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

@@ -0,0 +1,236 @@
+import { tryToAddWrongProp, addValidProp, } 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 { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { splitAndKeep } from "../../../../utils/strings/splitAndKeep.js";
+import { getHydratedProofByInductionSituation, getRandomProofByInductionSituationParams, } from "./proofByInductionSituations.js";
+const getHydrated = (identifiers) => {
+    const { situationParams, isValid, indexForNodeProperty } = identifiers;
+    const situation = getHydratedProofByInductionSituation(situationParams);
+    const { n0 } = situation;
+    switch (situation.id) {
+        case "generalFormulaOfArithmeticoGeometricSequence": {
+            const nodeProperty = (isValid ? situation.arrNodeValid : situation.arrNodeInvalid)[indexForNodeProperty];
+            const nodeVarN = new VariableNode("n");
+            const nodePropertySubstituted = nodeBySubstitutingVar(nodeBySubstitutingVar(nodeProperty, n0.toTree(), nodeVarN), new VariableNode(`u_{${n0}}`), new VariableNode("u_{n}"));
+            return {
+                situation,
+                isValid,
+                nodeProperty,
+                nodePropertySubstituted,
+            };
+        }
+        case "multipleFromPolynomial": {
+            const { nbMod } = situation.params;
+            const nodeProperty = (isValid ? situation.arrNodeValid : situation.arrNodeInvalid)[indexForNodeProperty];
+            const nodeVarN = new VariableNode("n");
+            const nodePropertySubstituted = nodeBySubstitutingVar(nodeProperty, n0.toTree(), nodeVarN);
+            return {
+                situation,
+                isValid,
+                nodeProperty,
+                nodePropertySubstituted,
+                nbMod,
+            };
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getInstruction = (identifiers) => {
+    const { situation, nodeProperty, nbMod } = getHydrated(identifiers);
+    const { n0 } = situation;
+    switch (situation.id) {
+        case "generalFormulaOfArithmeticoGeometricSequence": {
+            return `${situation.strContext}
+
+Pour $n \\geq ${n0}$, on note $\\mathcal{P}(n)$ la propriété : 
+
+$$
+\\mathcal{P}(n) :\\ \\ ${nodeProperty.toTex()}  
+$$
+
+La propriété $\\mathcal{P}(${n0})$ est-elle vraie ?`;
+        }
+        case "multipleFromPolynomial": {
+            return `${situation.strContext}
+
+Pour $n \\geq ${n0}$, on note $\\mathcal{P}(n)$ la propriété : 
+
+$$
+\\mathcal{P}(n) :\\ \\ f(n) \\text{ est un multiple de } ${nbMod} 
+$$
+
+La propriété $\\mathcal{P}(${n0})$ est-elle vraie ?`;
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getAnswer = (identifiers) => {
+    const { isValid } = identifiers;
+    return isValid ? "Oui" : "Non";
+};
+const getHint = (identifiers) => {
+    const { situation } = getHydrated(identifiers);
+    const { n0 } = situation;
+    return `Remplace $n$ par $${n0}$ dans la formule proposée et compare la valeur obtenue avec la valeur de $u_{${n0}}$ fournie dans l'énoncé.`;
+};
+const getCorrection = (identifiers) => {
+    const { isValid } = identifiers;
+    const { situation, nodePropertySubstituted } = getHydrated(identifiers);
+    const { n0 } = situation;
+    switch (situation.id) {
+        case "generalFormulaOfArithmeticoGeometricSequence": {
+            return `On calcule la valeur de $u_{${n0}}$ d'après $\\mathcal{P}(${n0})$ : 
+  
+${alignTex([
+                splitAndKeep(nodePropertySubstituted.toTex(), "="),
+                splitAndKeep(nodePropertySubstituted.simplify().toTex(), "="),
+            ])}
+
+${(() => {
+                if (isValid) {
+                    return `La propriété $\\mathcal{P}(${n0})$ est donc vraie.`;
+                }
+                else {
+                    return `La propriété $\\mathcal{P}(${n0})$ est donc fausse.`;
+                }
+            })()}
+
+`;
+        }
+        case "multipleFromPolynomial": {
+            return `On calcule la valeur de $f(${n0})$ : 
+  
+${alignTex([
+                [`f(${n0})`, "=", nodePropertySubstituted.toTex()],
+                ["", "=", nodePropertySubstituted.simplify().toTex()],
+            ])}
+
+${(() => {
+                if (isValid) {
+                    return `La propriété $\\mathcal{P}(${n0})$ est donc vraie.`;
+                }
+                else {
+                    return `La propriété $\\mathcal{P}(${n0})$ est donc fausse.`;
+                }
+            })()}
+
+`;
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getPropositions = (_n, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non", "On ne peut pas savoir"].forEach((str) => {
+        if (str === answer) {
+            addValidProp(propositions, answer, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return propositions;
+};
+const createRandomIdentifiers = () => {
+    const situationParams = getRandomProofByInductionSituationParams();
+    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];
+            }
+            case "multipleFromPolynomial": {
+                const isValid = situation.arrNodeValid.length > 0;
+                const indexForNodeProperty = 0;
+                return [isValid, indexForNodeProperty];
+            }
+            default:
+                throw new Error("Unsupported situation.id: " + situation.id);
+        }
+    })();
+    const identifiers = {
+        situationParams,
+        isValid,
+        indexForNodeProperty,
+    };
+    return identifiers;
+};
+// const isIdentifiersQCPassed = (identifiers: Identifiers) => {
+//   const isExploding = (identifiers: Identifiers) => {
+//     let isExploding = false;
+//     try {
+//       getHydrated(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 identifiersDefault: Identifiers = (() => {
+//       return {
+//         situationParams,
+//         isValid: true,
+//         indexForNodeProperty: 0,
+//       };
+//     })();
+//     identifiers = identifiersDefault;
+//   }
+//   return identifiers!;
+// };
+const getProofByInductionCheckInitializationQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const proofByInductionCheckInitialization = {
+    id: "proofByInductionCheckInitialization",
+    connector: "=",
+    label: "Vérifier si une propriété $\\mathcal{P}(n)$ est vraie pour un rang $n_{0}$ donné",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getProofByInductionCheckInitializationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/sequences/proofByInduction/proofByInductionReorderProof.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 proofByInductionReorderProof: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=proofByInductionReorderProof.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proofByInductionReorderProof.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/proofByInduction/proofByInductionReorderProof.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAGL,+BAA+B,EAChC,MAAM,iCAAiC,CAAC;AAQzC,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;AA0WF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAiB9D,CAAC"}

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

@@ -0,0 +1,244 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { EqualNode } 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 { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { getArrProofByInductionSituationParams, getHydratedProofByInductionSituation, } from "./proofByInductionSituations.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isFractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { uuid } from "uuidv4";
+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 { nodeA, nodeB, n0, nodeInitial } = 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, nodePropertyInduction, nodePropertyInductionPlus1,] = [
+                nodeVarStepDefinition,
+                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 arrNodeBaseCaseSteps = [
+                new EqualNode(new EqualNode(nodeBySubstitutingVar(nodePropertyWithN.rightChild, n0.toTree(), new VariableNode("n")), nodeInitial), new VariableNode(`u_{${n0}}`)),
+            ];
+            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,
+                nodePropertyInductionPlus1,
+                arrNodeBaseCaseSteps,
+                arrNodeInductionSteps,
+            };
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getInstruction = (identifiers) => {
+    const { situation, nodePropertyDefinition, nodeVarStepDefinition } = 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()}  
+$$
+
+On veut démontrer que, pour tout $${nodeVarStepDefinition.toTex()} \\geq ${n0}$, $\\mathcal{P}(${nodeVarStepDefinition.toTex()})$ est vraie.
+
+Reconstruire la démonstration par récurrence en réordonnant les éléments.`;
+        }
+        default:
+            throw new Error("Unsupported situation.id: " + situation.id);
+    }
+};
+const getHint = (identifiers) => {
+    const { nodeIdsVarStepInduction } = identifiers;
+    const [nodeVarStepInduction] = [nodeIdsVarStepInduction].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Une démonstration par récurrence d'une propriété $\\mathcal{P}$ s'écrit en $3$ étapes :
+- l'initialisation, où l'on s'assure que $\\mathcal{P}$ est vraie au rang initial
+- l'hérédité, où l'on s'assure que, 
+pour un rang $${nodeVarStepInduction.toTex()}$ supérieur ou égal au rang initial, 
+si $\\mathcal{P}(${nodeVarStepInduction.toTex()})$ est vraie 
+alors $\\mathcal(${add(nodeVarStepInduction, 1).toTex()})$ est vraie
+- la conclusion, où l'on déduit de l'initialisation et de l'hérédité que $\\mathcal{P}$ est vraie à partir du rang initial (jusqu'à l'infini)`;
+};
+const getCorrection = (identifiers) => {
+    const orderedItemsSorted = getOrderedItems(-1, {
+        answer: "",
+        ...identifiers,
+    }).sort((item1, item2) => item1.rightIndex - item2.rightIndex);
+    return `Voici le raisonnement par récurrence qu'il fallait reconstruire : 
+
+  
+${orderedItemsSorted.map((item) => item.statement).join(`
+
+`)}`;
+};
+const getOrderedItems = (_n, { answer, ...identifiers }) => {
+    const { situationParams } = identifiers;
+    const orderedItems = (() => {
+        switch (situationParams.id) {
+            case "generalFormulaOfArithmeticoGeometricSequence": {
+                const { situation, nodeVarStepDefinition, nodeVarStepInduction, arrNodeBaseCaseSteps, arrNodeInductionSteps, } = getHydrated(identifiers);
+                const { n0 } = situation;
+                return [
+                    "Initialisation :",
+                    ...arrNodeBaseCaseSteps.map((node) => `$${node.toTex()}$`),
+                    `donc $\\mathcal{P}(${n0})$ est vraie`,
+                    "Hérédité :",
+                    `Soit $${nodeVarStepInduction.toTex()}$ un entier tel que $${nodeVarStepInduction.toTex()} \\geq ${n0}$.`,
+                    `On suppose la propriété $\\mathcal{P}(${nodeVarStepInduction.toTex()})$ vraie.`,
+                    ...arrNodeInductionSteps.map((node) => `$${node.toTex()}$`),
+                    `donc $\\mathcal{P}(${add(nodeVarStepInduction, 1).toTex()})$ est vraie`,
+                    `donc $\\mathcal{P}$ est héréditaire`,
+                    "Conclusion :",
+                    `Pour tout $${nodeVarStepDefinition.toTex()} \\geq ${n0}$, $\\mathcal{P}(${nodeVarStepDefinition.toTex()})$ est vraie.`,
+                ].map((statement, i) => ({
+                    id: uuid(),
+                    statement: statement,
+                    rightIndex: i,
+                    format: "raw",
+                }));
+            }
+            default:
+                throw new Error("Unsupported situationParams.id: " + situationParams.id);
+        }
+    })();
+    return shuffle(orderedItems);
+};
+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 getProofByInductionReorderProofQuestion = () => {
+    const identifiers = createQCPassedIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        keys: [],
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const proofByInductionReorderProof = {
+    id: "proofByInductionReorderProof",
+    connector: "=",
+    label: "Reconstruire une démonstration par récurrence",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getProofByInductionReorderProofQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    answerType: "reorder",
+    getOrderedItems,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,98 @@
+import { AlgebraicNode } from "../../../../tree/nodes/algebraicNode.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+import { KeyId } from "../../../../types/keyIds.js";
+import { KeyProps } from "../../../../types/keyProps.js";
+export type ProofByInductionSituationParams = (GeneralFormulaOfArithmeticoGeometricSequenceParams & {
+    id: "generalFormulaOfArithmeticoGeometricSequence";
+}) | (MultipleFromPolynomialParams & {
+    id: "multipleFromPolynomial";
+});
+export type ProofByInductionSituation = {
+    id: string;
+    strContext: string;
+    n0: number;
+    baseCase: string;
+    inductionHypothesis: string;
+    inductionStep: string;
+    conclusion: string;
+    keys: (KeyId | KeyProps)[];
+    params: ProofByInductionSituationParams;
+    arrNodeValid: AlgebraicNode[];
+    arrNodeInvalid: AlgebraicNode[];
+};
+type GeneralFormulaOfArithmeticoGeometricSequenceParams = {
+    n0: number;
+    nodeIdsInitial: NodeIdentifiers;
+    nodeIdsA: NodeIdentifiers;
+    nodeIdsB: NodeIdentifiers;
+};
+export declare const getGeneralFormulaOfArithmeticoGeometricSequenceSituation: (params: ProofByInductionSituationParams) => {
+    id: string;
+    strContext: string;
+    n0: number;
+    baseCase: string;
+    inductionHypothesis: string;
+    inductionStep: string;
+    conclusion: string;
+    keys: never[];
+    params: ProofByInductionSituationParams;
+    arrNodeValid: EqualNode[];
+    arrNodeInvalid: EqualNode[];
+    nodeA: AlgebraicNode;
+    nodeB: AlgebraicNode;
+    nodeR: AlgebraicNode;
+    nodeInitial: AlgebraicNode;
+};
+type MultipleFromPolynomialParams = {
+    n0: number;
+    isValid: boolean;
+    nbMod: number;
+    arrValueRoot: number[];
+};
+export declare const getMultipleFromPolynomialSituation: (params: ProofByInductionSituationParams) => {
+    id: string;
+    strContext: string;
+    n0: number;
+    baseCase: string;
+    inductionHypothesis: string;
+    inductionStep: string;
+    conclusion: string;
+    keys: never[];
+    params: ProofByInductionSituationParams;
+    arrNodeValid: AlgebraicNode[];
+    arrNodeInvalid: AlgebraicNode[];
+};
+export declare const getHydratedProofByInductionSituation: (params: ProofByInductionSituationParams) => {
+    id: string;
+    strContext: string;
+    n0: number;
+    baseCase: string;
+    inductionHypothesis: string;
+    inductionStep: string;
+    conclusion: string;
+    keys: never[];
+    params: ProofByInductionSituationParams;
+    arrNodeValid: EqualNode[];
+    arrNodeInvalid: EqualNode[];
+    nodeA: AlgebraicNode;
+    nodeB: AlgebraicNode;
+    nodeR: AlgebraicNode;
+    nodeInitial: AlgebraicNode;
+} | {
+    id: string;
+    strContext: string;
+    n0: number;
+    baseCase: string;
+    inductionHypothesis: string;
+    inductionStep: string;
+    conclusion: string;
+    keys: never[];
+    params: ProofByInductionSituationParams;
+    arrNodeValid: AlgebraicNode[];
+    arrNodeInvalid: AlgebraicNode[];
+};
+export declare const getRandomProofByInductionSituationParams: () => ProofByInductionSituationParams;
+export declare const getArrProofByInductionSituationParams: (arrId: string[]) => ProofByInductionSituationParams[];
+export {};
+//# sourceMappingURL=proofByInductionSituations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proofByInductionSituations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/proofByInduction/proofByInductionSituations.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAWnD,MAAM,MAAM,+BAA+B,GACvC,CAAC,kDAAkD,GAAG;IACpD,EAAE,EAAE,8CAA8C,CAAC;CACpD,CAAC,GAEF,CAAC,4BAA4B,GAAG;IAAE,EAAE,EAAE,wBAAwB,CAAA;CAAE,CAAC,CAAC;AAEtE,MAAM,MAAM,yBAAyB,GAAG;IACtC,EAAE,EAAE,MAAM,CAAC;IAEX,UAAU,EAAE,MAAM,CAAC;IAEnB,EAAE,EAAE,MAAM,CAAC;IAEX,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IAEnB,IAAI,EAAE,CAAC,KAAK,GAAG,QAAQ,CAAC,EAAE,CAAC;IAC3B,MAAM,EAAE,+BAA+B,CAAC;IAGxC,YAAY,EAAE,aAAa,EAAE,CAAC;IAC9B,cAAc,EAAE,aAAa,EAAE,CAAC;CACjC,CAAC;AAWF,KAAK,kDAAkD,GAAG;IACxD,EAAE,EAAE,MAAM,CAAC;IAEX,cAAc,EAAE,eAAe,CAAC;IAChC,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAoBF,eAAO,MAAM,wDAAwD,GACnE,QAAQ,+BAA+B;;;;;;;;;;;;;;;;CAmKxC,CAAC;AAuKF,KAAK,4BAA4B,GAAG;IAClC,EAAE,EAAE,MAAM,CAAC;IAEX,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAmBF,eAAO,MAAM,kCAAkC,GAC7C,QAAQ,+BAA+B;;;;;;;;;;;;CA8CxC,CAAC;AAEF,eAAO,MAAM,oCAAoC,GAC/C,QAAQ,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAQxC,CAAC;AAEF,eAAO,MAAM,wCAAwC,QAC/C,+BAYH,CAAC;AAEJ,eAAO,MAAM,qCAAqC,GAChD,OAAO,MAAM,EAAE,KACd,+BAA+B,EAYjC,CAAC"}