math-exercises 3.0.200 → 3.0.201

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

@@ -0,0 +1,273 @@
+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 { 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 { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsE, nodeIdsV, nodeIdsA, nodeIdsPMin } = identifiers;
+    const [nodeE, nodeV, nodeA, nodePMin] = [
+        nodeIdsE,
+        nodeIdsV,
+        nodeIdsA,
+        nodeIdsPMin,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeN = new VariableNode("n");
+    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 nodeNTowards = frac(nodeV, multiply(substract(1, nodePMin), square(nodeA)));
+    const nodeNResult = Math.ceil(nodeNTowards.evaluate()).toTree();
+    return {
+        nodeE,
+        nodeV,
+        nodeA,
+        nodePMin,
+        nodeN,
+        texPWithinBounds,
+        texPAbsGeq,
+        texPInside,
+        nodeVM,
+        nodeErrorMax,
+        nodeErrorMin,
+        nodeNTowards,
+        nodeNResult,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeE, nodeV, texPWithinBounds, nodeN, nodePMin } = getHydrated(identifiers);
+    return `Pour $n$ entier strictement positif, 
+on note $(X_{${nodeN.toTex()}})$ un échantillon d'une variable aléatoire $X$ d'espérance $${nodeE.toTex()}$ et de variance $${nodeV.toTex()}$. 
+
+$$
+M_{${nodeN.toTex()}} = \\frac{1}{${nodeN.toTex()}} \\displaystyle \\sum_{i=1}^{${nodeN.toTex()}} X_{i}
+$$
+
+Déterminer le plus petit entier $n$ pour lequel le théorème de Bienaymé-Tchebychev permet d'affirmer que :
+
+$$
+${texPWithinBounds} > ${nodePMin.toTex()}
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeNResult } = getHydrated(identifiers);
+    return nodeNResult.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 nodeN = new VariableNode("n");
+    const nodeLhs = abs(substract(nodeVarY, nodeE).simplify());
+    const texPr = `P( ${nodeLhs.toTex()} \\geq ${nodeA.toTex()} )`;
+    const nodeErrorMax = frac(nodeV, multiply(nodeN, square(nodeA)));
+    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()}}
+$$
+
+Si on veut garantir :
+
+$$
+${texPr} \\geq P_{\\text{min}}
+$$
+
+alors, il faut choisir $n$ tel que : 
+
+$$
+${texPr} \\geq 1 - ${nodeErrorMax.toTex()} \\geq P_{\\text{min}}
+$$
+
+Il faut donc résoudre l'inéquation :
+
+$$
+1 - ${nodeErrorMax.toTex()} \\geq P_{\\text{min}}
+$$
+
+et déterminer le plus petit entier qui satisfaisant l'équation.
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeE, nodeVM, nodeA, nodeN, nodePMin, texPAbsGeq, texPInside, nodeErrorMax, texPWithinBounds, nodeErrorMin, nodeNTowards, nodeNResult, } = 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()],
+    ])}
+
+L'intervalle considéré autour de $M_{n}$ a pour rayon $${nodeA.toTex()}$.
+  
+Or, 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", nodeErrorMin.toTex({})],
+    ])}
+
+Par conséquent, si on veut garantir :
+
+$$
+${texPWithinBounds} \\geq ${nodePMin.toTex()}
+$$
+
+alors, il faut choisir $n$ tel que : 
+
+$$
+${texPWithinBounds} \\geq 1 - ${nodeErrorMax.toTex()} \\geq ${nodePMin.toTex()}
+$$
+
+Il faut donc résoudre l'inéquation :
+
+$$
+1 - ${nodeErrorMax.toTex()} \\geq ${nodePMin.toTex()}
+$$
+
+On trouve : 
+
+$$
+n \\geq ${nodeNTowards.toTex()} \\approx ${round(nodeNTowards.evaluate(), 2).frenchify()}
+$$
+
+L'entier recherché est donc $${nodeNResult.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(2, 10, 2).toTree();
+    const nodeA = random([0.1, 0.2, 0.5, 1]).toTree();
+    const nodePMin = random([0.5, 0.75, 0.9, 0.95, 0.99]).toTree();
+    const identifiers = {
+        nodeIdsE: nodeE.toIdentifiers(),
+        nodeIdsV: nodeV.toIdentifiers(),
+        nodeIdsA: nodeA.toIdentifiers(),
+        nodeIdsPMin: nodePMin.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getTchebychevFindRadiusToMinorizeProbaOfMeanInCenteredIntervalQuestion = () => {
+    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 tchebychevFindRadiusToMinorizeProbaOfMeanInCenteredInterval = {
+    id: "tchebychevFindRadiusToMinorizeProbaOfMeanInCenteredInterval",
+    label: "Sur une moyenne, utiliser le théorème de Bienaymé-Tchebychev pour déterminer la taille minimale de l'échantillon pour satisfaire une condition avec minoration de l'erreur",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTchebychevFindRadiusToMinorizeProbaOfMeanInCenteredIntervalQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/tchebychev/mean/tchebychevMajorizeProbaOfMeanOutOfCenteredInterval.d.ts

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

package/lib/exercises/math/probaStat/tchebychev/mean/tchebychevMajorizeProbaOfMeanOutOfCenteredInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tchebychevMajorizeProbaOfMeanOutOfCenteredInterval.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/tchebychev/mean/tchebychevMajorizeProbaOfMeanOutOfCenteredInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,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;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAwNF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgBF,eAAO,MAAM,qDAAqD,EAAE,QAAQ,CAC1E,WAAW,EACX,OAAO,CAwBR,CAAC"}

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

@@ -0,0 +1,219 @@
+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 { 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 nodeVarMn = new VariableNode(`M_{${nodeN.toTex()}}`);
+    const nodeLhs = abs(substract(nodeVarMn, nodeE).simplify());
+    const nodeVM = frac(nodeV, nodeN);
+    const texPMean = `P( ${nodeLhs.toTex()} \\geq ${nodeA.toTex()} )`;
+    const nodeErrorMax = frac(nodeV, multiply(nodeN, square(nodeA)));
+    return {
+        nodeE,
+        nodeV,
+        nodeA,
+        nodeN,
+        nodeVM,
+        texPMean,
+        nodeErrorMax,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeE, nodeV, texPMean, 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 majoration de $${texPMean}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeErrorMax } = getHydrated(identifiers);
+    return nodeErrorMax.simplify().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()}}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeE, nodeVM, nodeA, nodeN, texPMean, nodeErrorMax } = 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()}}`,
+        ],
+        [
+            texPMean,
+            "\\leq",
+            nodeErrorMax.toTex({
+                forceTimesSign: true,
+            }),
+        ],
+        [texPMean, "\\leq", nodeErrorMax.simplify().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 nodeErrorMax = frac(nodeV, square(nodeA));
+        tryToAddWrongProp(propositions, nodeErrorMax.simplify().toTex());
+    }
+    //student: v/na^2 -> v/(na)^2
+    {
+        const nodeErrorMax = frac(nodeV, square(multiply(nodeN, nodeA)));
+        tryToAddWrongProp(propositions, nodeErrorMax.simplify().toTex());
+    }
+    //student: v/na^2 -> nv/a^2
+    {
+        const nodeErrorMax = multiply(nodeN, frac(nodeV, square(nodeA)));
+        tryToAddWrongProp(propositions, nodeErrorMax.simplify().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 getTchebychevOnMeanMajorizeProbaOfXOutOfCenteredIntervalQuestion = (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 tchebychevOnMeanMajorizeProbaOfXOutOfCenteredInterval = {
+    id: "tchebychevOnMeanMajorizeProbaOfXOutOfCenteredInterval",
+    label: "Sur une moyenne, utiliser 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(() => getTchebychevOnMeanMajorizeProbaOfXOutOfCenteredIntervalQuestion(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/mean/tchebychevMinorizeProbaOfMeanInCenteredInterval.d.ts

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

package/lib/exercises/math/probaStat/tchebychev/mean/tchebychevMinorizeProbaOfMeanInCenteredInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tchebychevMinorizeProbaOfMeanInCenteredInterval.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/tchebychev/mean/tchebychevMinorizeProbaOfMeanInCenteredInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AA0QF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgBF,eAAO,MAAM,+CAA+C,EAAE,QAAQ,CACpE,WAAW,EACX,OAAO,CAuBR,CAAC"}