math-exercises 3.0.201 → 3.0.203

package/lib/exercises/math/primitive/exponentialPrimitive.js

@@ -28,6 +28,20 @@ export const getExponentialPrimitive = () => {
     const identifiers = { a };
     return getExponentialPrimitiveQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    const { a } = identifiers;
+    const integratedFuction = new MultiplyNode(new NumberNode(a), new ExpNode(new VariableNode("x")));
+    return `Quelles sont les fonctions qui ont pour dérivée $x\\mapsto ${integratedFuction.toTex()}$ ?`;
+};
+const getCorrection = (identifiers) => {
+    return `La forme générale des primitives de la fonction $f$ est : 
+  
+$$
+F(x) = ${getAnswer(identifiers)}
+$$
+
+où $C$ est un réel. En effet, en dérivant $F(x)$, on obtient bien $F'(x) = f(x)$.`;
+};
 export const getExponentialPrimitiveQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -36,6 +50,8 @@ export const getExponentialPrimitiveQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "C", "epower", "exp"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -80,4 +96,5 @@ export const exponentialPrimitive = {
     subject: "Mathématiques",
     pdfOptions: { shouldSpreadPropositions: true },
     getQuestionFromIdentifiers: getExponentialPrimitiveQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/primitive/polynomialPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiBF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAKjE,CAAC;AAEF,eAAO,MAAM,6CAA6C,EAAE,0BAA0B,CACpF,WAAW,CAYZ,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CA8B7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAYrD,CAAC"}
+{"version":3,"file":"polynomialPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/polynomialPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAKR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiCF,eAAO,MAAM,sBAAsB,EAAE,iBAAiB,CAAC,WAAW,CAKjE,CAAC;AAEF,eAAO,MAAM,6CAA6C,EAAE,0BAA0B,CACpF,WAAW,CAcZ,CAAC;AAEF,eAAO,MAAM,kCAAkC,EAAE,YAAY,CAAC,WAAW,CAexE,CAAC;AAEF,eAAO,MAAM,gCAAgC,EAAE,GAAG,CAAC,WAAW,CA8B7D,CAAC;AAEF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}

package/lib/exercises/math/primitive/polynomialPrimitive.js

@@ -6,13 +6,26 @@ import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers) => {
-    const polynomial = new Polynomial(identifiers.coeffs);
+    const polynomial = new Polynomial(identifiers.coeffs).toTree();
     return `Déterminer la forme générale des primitives de la fonction polynomiale $f$ définie par : 
 
 $$
 f(x) = ${polynomial.toTex()}
 $$`;
 };
+const getHint = (identifiers) => {
+    const polynomial = new Polynomial(identifiers.coeffs).toTree();
+    return `Quelles sont les fonctions qui ont pour dérivée $x\\mapsto ${polynomial.toTex()}$ ?`;
+};
+const getCorrection = (identifiers) => {
+    return `La forme générale des primitives de la fonction $f$ est : 
+  
+$$
+F(x) = ${getAnswer(identifiers)}
+$$
+
+où $C$ est un réel. En effet, en dérivant $F(x)$, on obtient bien $F'(x) = f(x)$.`;
+};
 const getAnswer = (identifiers) => {
     const polynomial = new Polynomial(identifiers.coeffs);
     const integralPolynomial = polynomial.integrateToNode();
@@ -33,6 +46,8 @@ export const getPolynomialPrimitiveQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "C"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -85,4 +100,5 @@ export const polynomialPrimitive = {
     isAnswerValid: isPolynomialPrimitiveAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers: getPolynomialPrimitiveQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/primitive/sinCosPrimitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sinCosPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/sinCosPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAGR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAwBF,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,CAAC,WAAW,CAM7D,CAAC;AAEF,eAAO,MAAM,yCAAyC,EAAE,0BAA0B,CAChF,WAAW,CAYZ,CAAC;AACF,eAAO,MAAM,8BAA8B,EAAE,YAAY,CAAC,WAAW,CA4BpE,CAAC;AACF,eAAO,MAAM,4BAA4B,EAAE,GAAG,CAAC,WAAW,CAYzD,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}
+{"version":3,"file":"sinCosPrimitive.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/sinCosPrimitive.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAKR,0BAA0B,EAE1B,YAAY,EAEZ,iBAAiB,EACjB,GAAG,EAIJ,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAwBF,eAAO,MAAM,kBAAkB,EAAE,iBAAiB,CAAC,WAAW,CAM7D,CAAC;AAoBF,eAAO,MAAM,yCAAyC,EAAE,0BAA0B,CAChF,WAAW,CAcZ,CAAC;AACF,eAAO,MAAM,8BAA8B,EAAE,YAAY,CAAC,WAAW,CA4BpE,CAAC;AACF,eAAO,MAAM,4BAA4B,EAAE,GAAG,CAAC,WAAW,CAYzD,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

package/lib/exercises/math/primitive/sinCosPrimitive.js

@@ -34,6 +34,22 @@ export const getSinCosPrimitive = () => {
     const identifiers = { a, isCos };
     return getSinCosPrimitiveQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    const { a, isCos } = identifiers;
+    const selectedFunction = isCos
+        ? new MultiplyNode(new NumberNode(a), new CosNode(new VariableNode("x")))
+        : new MultiplyNode(new NumberNode(a), new SinNode(new VariableNode("x")));
+    return `Quelles sont les fonctions qui ont pour dérivée $x\\mapsto ${selectedFunction.toTex()}$ ?`;
+};
+const getCorrection = (identifiers) => {
+    return `La forme générale des primitives de la fonction $f$ est : 
+  
+$$
+F(x) = ${getAnswer(identifiers)}
+$$
+
+où $C$ est un réel. En effet, en dérivant $F(x)$, on obtient bien $F'(x) = f(x)$.`;
+};
 export const getSinCosPrimitiveQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -42,6 +58,8 @@ export const getSinCosPrimitiveQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "C", "sin", "cos"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -74,7 +92,7 @@ export const isSinCosPrimitiveAnswerValid = (ans, { isCos, a }) => {
 export const sinCosPrimitive = {
     id: "sinCosPrimitive",
     connector: "=",
-    label: "Primitive de sin et cos",
+    label: "Primitive de $\\sin$ et $\\cos$",
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getSinCosPrimitive, nb),
     qcmTimer: 60,
@@ -83,4 +101,5 @@ export const sinCosPrimitive = {
     isAnswerValid: isSinCosPrimitiveAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers: getSinCosPrimitiveQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/primitive/usualPrimitives.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usualPrimitives.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/usualPrimitives.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAOT,MAAM,6BAA6B,CAAC;AA4BrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AA+HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"usualPrimitives.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/primitive/usualPrimitives.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAOT,MAAM,6BAA6B,CAAC;AA4BrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AA+HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

package/lib/exercises/math/primitive/usualPrimitives.js

@@ -131,4 +131,5 @@ export const usualPrimitives = {
     subject: "Mathématiques",
     pdfOptions: { shouldSpreadPropositions: true },
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/index.d.ts

@@ -9,4 +9,5 @@ export * from "./notation/index.js";
 export * from "./seqArithmGeom/index.js";
 export * from "./limits/index.js";
 export * from "./variations/index.js";
+export * from "./proofByInduction/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/sequences/index.js

@@ -9,3 +9,4 @@ export * from "./notation/index.js";
 export * from "./seqArithmGeom/index.js";
 export * from "./limits/index.js";
 export * from "./variations/index.js";
+export * from "./proofByInduction/index.js";

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

@@ -0,0 +1,5 @@
+export * from "./proofByInductionCheckInitialization.js";
+export * from "./proofByInductionWritePropAtRankKPlus1.js";
+export * from "./proofByInductionWriteMissingStep.js";
+export * from "./proofByInductionReorderProof.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/proofByInduction/index.ts"],"names":[],"mappings":"AAAA,cAAc,0CAA0C,CAAC;AACzD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,uCAAuC,CAAC;AACtD,cAAc,mCAAmC,CAAC"}

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

@@ -0,0 +1,4 @@
+export * from "./proofByInductionCheckInitialization.js";
+export * from "./proofByInductionWritePropAtRankKPlus1.js";
+export * from "./proofByInductionWriteMissingStep.js";
+export * from "./proofByInductionReorderProof.js";

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { ProofByInductionSituationParams } from "./proofByInductionSituations.js";
+type Identifiers = {
+    situationParams: ProofByInductionSituationParams;
+    isValid: boolean;
+    indexForNodeProperty: number;
+};
+export declare const proofByInductionCheckInitialization: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=proofByInductionCheckInitialization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proofByInductionCheckInitialization.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/proofByInduction/proofByInductionCheckInitialization.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAGL,+BAA+B,EAChC,MAAM,iCAAiC,CAAC;AAEzC,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,+BAA+B,CAAC;IACjD,OAAO,EAAE,OAAO,CAAC;IACjB,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AA8PF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAkBrE,CAAC"}

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"}