math-exercises 3.0.200 → 3.0.201

package/lib/exercises/math/probaStat/tchebychev/mean/tchebychevMinorizeProbaOfMeanInCenteredInterval.js

@@ -0,0 +1,245 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { abs } from "../../../../../tree/nodes/functions/absNode.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsE, nodeIdsV, nodeIdsA, nodeIdsN } = identifiers;
+    const [nodeE, nodeV, nodeA, nodeN] = [
+        nodeIdsE,
+        nodeIdsV,
+        nodeIdsA,
+        nodeIdsN,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeVM = frac(nodeV, nodeN);
+    const nodeVarMn = new VariableNode(`M_{${nodeN.toTex()}}`);
+    const nodeBoundLow = substract(nodeE, nodeA).simplify();
+    const nodeBoundHigh = add(nodeE, nodeA).simplify();
+    const texPWithinBounds = `P( ${nodeBoundLow.toTex()} < ${nodeVarMn.toTex()} < ${nodeBoundHigh.toTex()} )`;
+    const nodeLhs = abs(substract(nodeVarMn, nodeE).simplify());
+    const texPAbsGeq = `P( ${nodeLhs.toTex()} \\geq ${nodeA.toTex()} )`;
+    const texPInside = `P( ${nodeLhs.toTex()} < ${nodeA.toTex()} )`;
+    const nodeErrorMax = frac(nodeV, multiply(nodeN, square(nodeA)));
+    const nodeErrorMin = substract(1, nodeErrorMax);
+    const nodeErrorMinSimplified = substract(1, nodeErrorMax.simplify());
+    return {
+        nodeE,
+        nodeV,
+        nodeA,
+        nodeN,
+        texPWithinBounds,
+        texPAbsGeq,
+        texPInside,
+        nodeVM,
+        nodeErrorMax,
+        nodeErrorMin,
+        nodeErrorMinSimplified,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeE, nodeV, texPWithinBounds, nodeN } = getHydrated(identifiers);
+    return `Soit $(X_{${nodeN.toTex()}})$ un échantillon d'une variable aléatoire $X$ d'espérance $${nodeE.toTex()}$ et de variance $${nodeV.toTex()}$. On note :
+
+$$
+M_{${nodeN.toTex()}} = \\frac{1}{${nodeN.toTex()}} \\displaystyle \\sum_{i=1}^{${nodeN.toTex()}} X_{i}
+$$
+
+À l'aide du théorème de Bienaymé-Tchebychev, donner une minoration de $${texPWithinBounds}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeErrorMinSimplified } = getHydrated(identifiers);
+    return nodeErrorMinSimplified.toTex();
+};
+const getHint = () => {
+    const nodeA = new VariableNode("a");
+    return `Soit $n$ un entier strictement positif. Soit $(Y_{n})$ un échantillon d'une variable aléatoire $Y$.
+
+On note :
+
+$$
+M_{n} = \\frac{1}{n} \\displaystyle \\sum_{i=1}^{n} Y_{i}
+$$
+  
+On a :
+
+$$
+E(M_{n}) = E(Y)
+$$
+
+et 
+
+$$
+V(M_{n}) = \\frac{V(Y)}{n}
+$$
+  
+  
+et d'après le théorème de Bienaymé-Tchebychev appliqué à la variable aléatoire $M_{n}$ :
+
+$$
+P( \\lvert M_{n} - E(M_{n}) \\rvert \\geq ${nodeA.toTex()}) \\leq \\frac{V(M_{n})}{${square(nodeA).toTex()}}
+$$
+
+$$
+1 - P( \\lvert M_{n} - E(M_{n}) \\rvert \\geq ${nodeA.toTex()}) \\geq 1 - \\frac{V(M_{n})}{${square(nodeA).toTex()}}
+$$
+
+$$
+P( \\lvert M_{n} - E(M_{n}) \\rvert < ${nodeA.toTex()}) \\geq 1 - \\frac{V(M_{n})}{${square(nodeA).toTex()}}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeE, nodeVM, nodeA, nodeN, texPAbsGeq, texPInside, nodeErrorMax, texPWithinBounds, nodeErrorMin, nodeErrorMinSimplified, } = getHydrated(identifiers);
+    return `On a :
+
+${alignTex([
+        [`E(M_{${nodeN.toTex()}})`, "=", "E(X)"],
+        ["", "=", nodeE.toTex()],
+    ])}
+
+${alignTex([
+        [`V(M_{${nodeN.toTex()}})`, "=", `\\frac{V(X)}{${nodeN.toTex()}}`],
+        ["", "=", nodeVM.toTex()],
+    ])}
+  
+et d'après le théorème de Bienaymé-Tchebychev appliqué à la variable aléatoire $M_{${nodeN.toTex()}}$ :
+
+${alignTex([
+        [
+            `P( \\lvert M_{${nodeN.toTex()}} - E(M_{${nodeN.toTex()}}) \\rvert \\geq ${nodeA.toTex()})`,
+            "\\leq",
+            `\\frac{V(M_{${nodeN.toTex()}})}{${square(nodeA).toTex()}}`,
+        ],
+        [
+            texPAbsGeq,
+            "\\leq",
+            nodeErrorMax.toTex({
+                forceTimesSign: true,
+            }),
+        ],
+        [`1 - ${texPAbsGeq}`, "\\geq", nodeErrorMin.toTex({})],
+        [texPInside, "\\geq", nodeErrorMin.toTex({})],
+        [texPWithinBounds, "\\geq", nodeErrorMinSimplified.toTex({})],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeV, nodeA, nodeN } = getHydrated(identifiers);
+    //student: M_{n} -> X
+    {
+        const nodeErrorMinWrong = substract(1, frac(nodeV, square(nodeA)).simplify());
+        tryToAddWrongProp(propositions, nodeErrorMinWrong.toTex());
+    }
+    //student: 1 - P -> P
+    {
+        const nodeErrorMax = frac(nodeV, multiply(nodeN, square(nodeA))).simplify();
+        tryToAddWrongProp(propositions, nodeErrorMax.toTex());
+    }
+    //student: v/na^2 -> v/(na)^2
+    {
+        const nodeErrorMinWrong = substract(1, frac(nodeV, square(multiply(nodeN, nodeA))).simplify());
+        tryToAddWrongProp(propositions, nodeErrorMinWrong.toTex());
+    }
+    //student: v/na^2 -> nv/a^2
+    {
+        const nodeErrorMinWrong = substract(1, multiply(nodeN, frac(nodeV, square(nodeA))).simplify());
+        tryToAddWrongProp(propositions, nodeErrorMinWrong.toTex());
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers(opts);
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const nodeE = randfloat(-10, 10, 2).toTree();
+    const nodeV = randfloat(1, 10, 2).toTree();
+    const nodeA = randint(2, Math.ceil(3 * nodeV.evaluate())).toTree();
+    const nodeN = opts.typeN === "nombre"
+        ? (randint(1, 11) * 10).toTree()
+        : new VariableNode("n");
+    const identifiers = {
+        nodeIdsE: nodeE.toIdentifiers(),
+        nodeIdsV: nodeV.toIdentifiers(),
+        nodeIdsA: nodeA.toIdentifiers(),
+        nodeIdsN: nodeN.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getTchebychevMinorizeProbaOfMeanInCenteredIntervalQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+const optsDefault = {
+    typeN: "nombre",
+};
+const options = [
+    {
+        id: "typeLinearCombination",
+        label: "Type de la taille $n$ de l'échantillon",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["nombre", "lettre"],
+        defaultValue: optsDefault.typeN,
+    },
+];
+export const tchebychevMinorizeProbaOfMeanInCenteredInterval = {
+    id: "tchebychevMinorizeProbaOfMeanInCenteredInterval",
+    label: "Sur une moyenne, utiliser le théorème de Bienaymé Tchebychev pour donner une minoration de la probabilité de tomber dans un intervalle centré sur l'espérance",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTchebychevMinorizeProbaOfMeanInCenteredIntervalQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/tchebychev/tchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredInterval.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsE: NodeIdentifiers;
+    nodeIdsV: NodeIdentifiers;
+    nodeIdsPMax: NodeIdentifiers;
+};
+export declare const tchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredInterval: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=tchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredInterval.d.ts.map

package/lib/exercises/math/probaStat/tchebychev/tchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/tchebychev/tchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,WAAW,EAAE,eAAe,CAAC;CAC9B,CAAC;AA8LF,eAAO,MAAM,2DAA2D,EAAE,QAAQ,CAAC,WAAW,CAyB3F,CAAC"}

package/lib/exercises/math/probaStat/tchebychev/tchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredInterval.js

@@ -0,0 +1,191 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsE, nodeIdsV, nodeIdsPMax } = identifiers;
+    const [nodeE, nodeV, nodePMax] = [nodeIdsE, nodeIdsV, nodeIdsPMax].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeVarX = new VariableNode("X");
+    const nodeLhs = abs(substract(nodeVarX, nodeE).simplify());
+    const texPr = `P( ${nodeLhs.toTex()} \\geq r )`;
+    const texPR = `P( ${nodeLhs.toTex()} \\geq R )`;
+    //Err = V / a²
+    //<=>
+    //a = sqrt(V/Err)
+    const nodeA = sqrt(frac(nodeV, nodePMax));
+    const n = Math.ceil(nodeA.evaluate());
+    return {
+        nodeE,
+        nodeV,
+        nodePMax,
+        texPR,
+        texPr,
+        nodeA,
+        n,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeE, nodeV, texPR, nodePMax } = getHydrated(identifiers);
+    return `Soit $X$ une variable aléatoire d'espérance $${nodeE.toTex()}$ et de variance $${nodeV.toTex()}$. 
+Déterminer le plus petit entier $R$ pour lequel le théorème de Bienaymé-Tchebychev permet d'affirmer que :
+
+$$
+${texPR} < ${nodePMax.toTex()}
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { n } = getHydrated(identifiers);
+    return n.frenchify();
+};
+const getHint = () => {
+    const nodeVarY = new VariableNode("Y");
+    const nodeE = new VariableNode("E(Y)");
+    const nodeV = new VariableNode("V(Y)");
+    const nodeA = new VariableNode("r");
+    const nodeLhs = abs(substract(nodeVarY, nodeE).simplify());
+    const texPr = `P( ${nodeLhs.toTex()} \\geq ${nodeA.toTex()} )`;
+    const nodeErrorMax = frac(nodeV, square(nodeA));
+    return `Soit $Y$ une variable aléatoire. Soit $r$ un réel strictement positif. 
+  
+D'après le théorème de Bienaymé-Tchebychev :
+
+$$
+${texPr} \\leq ${nodeErrorMax.toTex()}
+$$
+
+Soit $P_{\\text{max}}$ un réel compris entre $0$ et $1$, si on veut garantir :
+
+$$
+${texPr} \\leq P_{\\text{max}}
+$$
+
+alors, il faut choisir $r$ tel que :  
+
+$$
+${texPr} \\leq ${nodeErrorMax.toTex()} \\leq P_{\\text{max}}
+$$
+
+Il faut donc résoudre l'inéquation :
+
+$$
+${nodeErrorMax.toTex()} \\leq P_{\\text{max}}
+$$
+
+Résous l'inéquation et détermine ensuite le plus petit entier $R$ supérieur ou égal à $r$.
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeV, texPr, nodePMax, nodeA, n } = getHydrated(identifiers);
+    return `Soit $r$ un réel strictement positif. D'après le théorème de Bienaymé-Tchebychev :
+
+$$
+P( \\lvert X - E(X) \\rvert \\geq r) \\leq \\frac{V(X)}{r^2}
+$$
+
+Si on veut garantir :
+
+$$
+${texPr} \\leq ${nodePMax.toTex()}
+$$
+
+alors, il faut choisir $r$ tel que :  
+
+$$
+${texPr} \\leq \\frac{${nodeV.toTex()}}{r^2} \\leq ${nodePMax.toTex()}
+$$
+
+Il faut donc résoudre l'inéquation :
+
+$$
+\\frac{${nodeV.toTex()}}{r^2} \\leq ${nodePMax.toTex()}
+$$
+
+On trouve : 
+
+$$
+${round(nodeA.evaluate(), 2).frenchify()} \\approx ${nodeA.toTex()} \\leq r
+$$
+
+L'entier recherché est le plus petit entier $R$ supérieur à $${nodeA.toTex()}$. 
+C'est $${n.frenchify()}$.`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const nodeE = randfloat(-10, 10, 2).toTree();
+    const nodeV = randfloat(1, 10, 2).toTree();
+    const nodePMax = random([0.1, 0.01, 0.001]).toTree();
+    const identifiers = {
+        nodeIdsE: nodeE.toIdentifiers(),
+        nodeIdsV: nodeV.toIdentifiers(),
+        nodeIdsPMax: nodePMax.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getTchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredIntervalQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+export const tchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredInterval = {
+    id: "tchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredInterval",
+    label: "Utiliser le théorème de Bienaymé-Tchebychev pour déterminer le rayon minimal de l'intervalle pour satisfaire une condition avec majoration de l'erreur",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredIntervalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/tchebychev/tchebychevMajorizeProbaOfXOutOfCenteredInterval.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsE: NodeIdentifiers;
+    nodeIdsV: NodeIdentifiers;
+    nodeIdsA: NodeIdentifiers;
+};
+export declare const tchebychevMajorizeProbaOfXOutOfCenteredInterval: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=tchebychevMajorizeProbaOfXOutOfCenteredInterval.d.ts.map

package/lib/exercises/math/probaStat/tchebychev/tchebychevMajorizeProbaOfXOutOfCenteredInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tchebychevMajorizeProbaOfXOutOfCenteredInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/tchebychev/tchebychevMajorizeProbaOfXOutOfCenteredInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAyIF,eAAO,MAAM,+CAA+C,EAAE,QAAQ,CAAC,WAAW,CAsB/E,CAAC"}

package/lib/exercises/math/probaStat/tchebychev/tchebychevMajorizeProbaOfXOutOfCenteredInterval.js

@@ -0,0 +1,135 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsE, nodeIdsV, nodeIdsA } = identifiers;
+    const [nodeE, nodeV, nodeA] = [nodeIdsE, nodeIdsV, nodeIdsA].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeVarX = new VariableNode("X");
+    const nodeLhs = abs(substract(nodeVarX, nodeE).simplify());
+    const texP = `P( ${nodeLhs.toTex()} \\geq ${nodeA.toTex()} )`;
+    const nodeErrorMax = frac(nodeV, square(nodeA));
+    return {
+        nodeE,
+        nodeV,
+        nodeA,
+        texP,
+        nodeErrorMax,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeE, nodeV, texP } = getHydrated(identifiers);
+    return `Soit $X$ une variable aléatoire d'espérance $${nodeE.toTex()}$ et de variance $${nodeV.toTex()}$. 
+À l'aide du théorème de Bienaymé-Tchebychev, Donner une majoration de $${texP}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeErrorMax } = getHydrated(identifiers);
+    return nodeErrorMax.simplify().toTex();
+};
+const getHint = () => {
+    const nodeVarY = new VariableNode("Y");
+    const nodeE = new VariableNode("E(Y)");
+    const nodeV = new VariableNode("V(Y)");
+    const nodeA = new VariableNode("a");
+    const nodeLhs = abs(substract(nodeVarY, nodeE).simplify());
+    const texP = `P( ${nodeLhs.toTex()} \\geq ${nodeA.toTex()} )`;
+    const nodeErrorMax = frac(nodeV, square(nodeA));
+    return `Soit $Y$ une variable aléatoire. Soit $a$ un réel strictement positif. 
+  
+D'après le théorème de Bienaymé-Tchebychev :
+
+$$
+${texP} <= ${nodeErrorMax.toTex()}
+$$
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeA, texP, nodeErrorMax } = getHydrated(identifiers);
+    return `D'après le théorème de Bienaymé-Tchebychev :
+
+$$
+P( \\lvert X - E(X) \\rvert \\geq ${nodeA.toTex()}) \\leq \\frac{V(X)}{${square(nodeA).toTex()}}
+$$
+
+$$
+${texP} \\leq ${nodeErrorMax.toTex()} = ${nodeErrorMax.simplify().toTex()}
+$$
+
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const nodeE = randfloat(-10, 10, 2).toTree();
+    const nodeV = randfloat(1, 10, 2).toTree();
+    const nodeA = randint(2, Math.ceil(3 * nodeV.evaluate())).toTree();
+    const identifiers = {
+        nodeIdsE: nodeE.toIdentifiers(),
+        nodeIdsV: nodeV.toIdentifiers(),
+        nodeIdsA: nodeA.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getTchebychevMajorizeProbaOfXOutOfCenteredIntervalQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+export const tchebychevMajorizeProbaOfXOutOfCenteredInterval = {
+    id: "tchebychevMajorizeProbaOfXOutOfCenteredInterval",
+    label: "Utiliser directement le théorème de Bienaymé-Tchebychev pour donner une majoration de la probabilité de tomber hors d'un intervalle centré sur l'espérance",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTchebychevMajorizeProbaOfXOutOfCenteredIntervalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/tchebychev/tchebychevMinorizeProbaOfXInCenteredInterval.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsE: NodeIdentifiers;
+    nodeIdsV: NodeIdentifiers;
+    nodeIdsA: NodeIdentifiers;
+};
+export declare const tchebychevMinorizeProbaOfXInCenteredInterval: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=tchebychevMinorizeProbaOfXInCenteredInterval.d.ts.map

package/lib/exercises/math/probaStat/tchebychev/tchebychevMinorizeProbaOfXInCenteredInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tchebychevMinorizeProbaOfXInCenteredInterval.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/tchebychev/tchebychevMinorizeProbaOfXInCenteredInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AA8JF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAsB5E,CAAC"}