math-exercises 3.0.156 → 3.0.158

package/lib/exercises/math/probaStat/basicProbas/pickEquiprobableSituations.js

@@ -1,14 +1,64 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { probaWheelGGBCommands } from "../../../../geogebra/probas/probaWheelGGBCommands.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { dichoFilter } from "../../../../utils/arrays/dichoFilter.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getDictEventsAndProba = (arrItem) => {
+    const outDict = {};
+    const indexesColorsUsed = [
+        ...new Set(arrItem.map((wheelItem) => wheelItem.indexColor)),
+    ];
+    //couleur
+    {
+        const dictColor = indexesColorsUsed.reduce((acc, i) => {
+            const nbIssues = arrItem.filter((itemX) => itemX.indexColor === i).length;
+            const nodeProba = frac(nbIssues, arrItem.length);
+            acc[i] = nodeProba;
+            return acc;
+        }, {});
+        outDict["couleur"] = dictColor;
+    }
+    const valuesUsed = [...new Set(arrItem.map((wheelItem) => wheelItem.value))];
+    //numéro
+    {
+        const dictValue = valuesUsed.reduce((acc, v) => {
+            const nbIssues = arrItem.filter((itemX) => itemX.value === v).length;
+            const nodeProba = frac(nbIssues, arrItem.length);
+            acc[v] = nodeProba;
+            return acc;
+        }, {});
+        outDict["numéro"] = dictValue;
+    }
+    //parité
+    {
+        const dictColor = [0, 1].reduce((acc, i) => {
+            const nbIssues = arrItem.filter((itemX) => itemX.value % 2 === i).length;
+            const nodeProba = frac(nbIssues, arrItem.length);
+            acc[i] = nodeProba;
+            return acc;
+        }, {});
+        outDict["parité"] = dictColor;
+    }
+    //geq5
+    {
+        const dictGeq5 = dichoFilter(arrItem.map((item) => item.value), (v) => v >= 5).reduce((acc, arrV, i) => {
+            const nodeProba = frac(arrV.length, arrItem.length);
+            acc[i] = nodeProba;
+            return acc;
+        }, {});
+        outDict["geq5"] = dictGeq5;
+    }
+    return outDict;
+};
 //on note le numéro du secteur obtenu
 //on note la couleur du secteur obtenu
 //on note la parité du numéro obtenu
-const getPropositions = (n, { answer, items }) => {
+//on note si le numéro est supérieur ou égal à 5
+const getPropositions = (_arg1, { answer: _arg2, items }) => {
     const propositions = [];
-    addValidProp(propositions, answer);
     const colors = [0, 0, 0, 0];
     const nums = [0, 0, 0, 0, 0, 0, 0, 0, 0];
     const pars = [0, 0];
@@ -32,7 +82,16 @@ const getPropositions = (n, { answer, items }) => {
         addValidProp(propositions, "On note la parité du secteur obtenu (pair ou impair)", "raw");
     else
         tryToAddWrongProp(propositions, "On note la parité du secteur obtenu (pair ou impair)", "raw");
-    return shuffleProps(propositions, n);
+    if ((() => {
+        const [arrGeq5, arrLt5] = dichoFilter(items.map((item) => item.value), (v) => v >= 5);
+        return arrLt5.length === arrGeq5.length;
+    })()) {
+        addValidProp(propositions, "On note si le numéro obtenu est supérieur ou égal à $5$", "raw");
+    }
+    else {
+        tryToAddWrongProp(propositions, "On note si le numéro obtenu est supérieur ou égal à $5$", "raw");
+    }
+    return propositions;
 };
 const getInstruction = (identifiers) => {
     const { items } = identifiers;
@@ -45,22 +104,51 @@ const getHint = () => {
 };
 const getCorrection = (identifiers) => {
     const { items } = identifiers;
-    const colors = [0, 0, 0, 0];
-    const nums = [0, 0, 0, 0, 0, 0, 0, 0, 0];
-    const pars = [0, 0];
-    for (let i = 0; i < items.length; i++) {
-        colors[items[i].indexColor]++;
-        nums[items[i].value]++;
-        if (items[i].value % 2 === 0)
-            pars[0]++;
-        else
-            pars[1]++;
-    }
+    const dictEventsAndProba = getDictEventsAndProba(items);
+    const arrAnswer = getPropositions(4, { answer: "", ...identifiers }).filter((proposition) => proposition.isRightAnswer);
     return `On détaille chaque situation : 
   
-- 
-- 
-- `;
+${mdTable([
+        ["", ""],
+        ["Numéro", ""],
+        ["Issue", "Probabilité"],
+        ...Object.entries(dictEventsAndProba["numéro"]).map(([s, nodeProba]) => [
+            `$${s}$`,
+            `$${nodeProba.toTex()}$`,
+        ]),
+        ["", ""],
+        ["Couleur", ""],
+        ["Issue", "Probabilité"],
+        ...Object.entries(dictEventsAndProba["couleur"]).map(([s, nodeProba]) => {
+            const indexEvent = +s;
+            return [
+                ["rouge", "bleu", "vert", "orange"][indexEvent],
+                `$${nodeProba.toTex()}$`,
+            ];
+        }),
+        ["", ""],
+        ["Parité", ""],
+        ["Issue", "Probabilité"],
+        ...Object.entries(dictEventsAndProba["parité"]).map(([s, nodeProba]) => {
+            const indexEvent = +s;
+            return [["pair", "impair"][indexEvent], `$${nodeProba.toTex()}$`];
+        }),
+        ["", ""],
+        ["Supérieur ou égal à $5$", ""],
+        ["Issue", "Probabilité"],
+        ...Object.entries(dictEventsAndProba["geq5"]).map(([s, nodeProba]) => {
+            const indexEvent = +s;
+            return [["oui", "non"][indexEvent], `$${nodeProba.toTex()}$`];
+        }),
+    ])}
+
+Les situations équiprobables sont celles où toutes les issues ont la même probabilité.
+${arrAnswer.length > 1 ? "Ce sont donc :" : `C'est donc :`}
+
+${arrAnswer.map((proposition) => `- ${proposition.statement}`).join(`
+`)}
+
+`;
 };
 const getGGBOptions = (identifiers) => {
     const { items } = identifiers;
@@ -89,13 +177,18 @@ const hasRightAnswer = (items) => {
     return (colors.filter((e) => !!e).every((i) => i === colors[0]) ||
         nums
             .filter((e) => !!e)
-            .every((i) => i === nums[0] || pars.every((i) => i === pars[0])));
+            .every((i) => i === nums[0] || pars.every((i) => i === pars[0])) ||
+        (() => {
+            const [arrGeq5, arrLt5] = dichoFilter(items.map((item) => item.value), (v) => v >= 5);
+            return arrLt5.length === arrGeq5.length;
+        })());
 };
 const getPickEquiprobableSituationsQuestion = () => {
+    const nbWheelItems = randint(8, 11);
     let items = [];
     do {
         items = [];
-        for (let i = 0; i < 9; i++) {
+        for (let i = 0; i < nbWheelItems; i++) {
             items.push({
                 value: randint(1, 10),
                 indexColor: randint(0, 4),
@@ -127,6 +220,7 @@ export const pickEquiprobableSituations = {
     subject: "Mathématiques",
     getHint,
     getCorrection,
+    hasHintAndCorrection: true,
     getInstruction,
     getGGBOptions,
     hasGeogebra: true,

package/lib/exercises/math/probaStat/basicProbas/pickEquiprobableTo.js

@@ -122,7 +122,7 @@ const getGGBOptions = (identifiers) => {
     });
 };
 const getHint = () => {
-    return `Compte le nombre d'issues réalisent chaque évènement et cherche lesquels sont égaux entre eux.`;
+    return `Compte le nombre d'issues qui réalisent chaque évènement et cherche lesquels sont égaux entre eux.`;
 };
 const getCorrection = (identifiers) => {
     const { arrItem, typeAsked } = identifiers;
@@ -280,7 +280,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 export const pickEquiprobableTo = {
     id: "pickEquiprobableTo",
     connector: "=",
-    label: "Déterminer les situations équiprobables à une situation donnée",
+    label: "Déterminer les évènements équiprobables",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getPickEquiprobableToQuestion(opts), nb),
     qcmTimer: 60,

package/lib/exercises/math/probaStat/conditionalProbability.d.ts

@@ -7,6 +7,9 @@ type Identifiers = {
     pA_B?: number;
     pB_A?: number;
 };
-export declare const conditionalProbability: Exercise<Identifiers>;
+type Options = {
+    probaType: string[];
+};
+export declare const conditionalProbability: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=conditionalProbability.d.ts.map

package/lib/exercises/math/probaStat/conditionalProbability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conditionalProbability.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/conditionalProbability.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,QAAQ,EAeT,MAAM,mBAAmB,CAAC;AAM3B,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AA8SF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"conditionalProbability.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/conditionalProbability.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,QAAQ,EAmBT,MAAM,mBAAmB,CAAC;AAO3B,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAoRF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAyDF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBjE,CAAC"}

package/lib/exercises/math/probaStat/conditionalProbability.js

@@ -1,12 +1,13 @@
 /* eslint-disable @typescript-eslint/naming-convention*/
 //? it makes sense here to use pA_B
 import { randint } from "../../../math/utils/random/randint.js";
-import { addValidProp, propWhile, tryToAddWrongProp, } from "../../exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
 import { round } from "../../../math/utils/round.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 import { alignTex } from "../../../utils/latex/alignTex.js";
 import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { random } from "../../../utils/alea/random.js";
 const getInstruction = (identifiers) => {
     const { flip, pA, pAB, pA_B, pB, pB_A } = identifiers;
     let instruction = `On considère deux événements $A$ et $B$ tels que `;
@@ -223,9 +224,18 @@ ${alignTex([
         }
     }
 };
-const getConditionalProbability = () => {
+const getConditionalProbability = (opts) => {
     let pA, pB, pAB, pA_B, pB_A;
-    const flip = randint(1, 7);
+    const types = opts?.probaType ?? ["$P(A)$", "$P(A\\cap B)$", "$P_A(B)$"];
+    const flipChoices = [];
+    if (types.includes("$P(A)$"))
+        flipChoices.push(5, 6);
+    if (types.includes("$P(A\\cap B)$"))
+        flipChoices.push(3, 4);
+    if (types.includes("$P_A(B)$"))
+        flipChoices.push(1, 2);
+    const flip = random(flipChoices);
+    //1,2 = P_AB, 3,4 = PANB, 5,6 = PA
     switch (flip) {
         case 1:
             pA = randint(2, 100);
@@ -259,6 +269,27 @@ const getConditionalProbability = () => {
     const identifiers = { flip, pA, pAB, pB, pA_B, pB_A };
     return getQuestionFromIdentifiers(identifiers);
 };
+const options = [
+    {
+        id: "probaType",
+        label: "Probabilité demandée",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["$P(A)$", "$P(A\\cap B)$", "$P_A(B)$"],
+        defaultValue: ["$P(A)$", "$P(A\\cap B)$", "$P_A(B)$"],
+    },
+];
+const validateOptions = (opts) => {
+    if (!opts?.probaType?.length)
+        return {
+            valid: false,
+            message: "Veuillez choisir au moins un type de probabilité demandée.",
+        };
+    return {
+        valid: true,
+        message: "",
+    };
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -286,9 +317,9 @@ const isAnswerValid = (ans, { answer }) => {
 export const conditionalProbability = {
     id: "conditionalProbability",
     connector: "=",
-    label: "Calcul de probabilité conditionnelle avec la formule de Bayes",
+    label: "Calcul de probabilité conditionnelle avec la formule de Bayes $P(A \\cap B) = P_A(B) \\times P(A)$",
     isSingleStep: false,
-    generator: (nb) => getDistinctQuestions(getConditionalProbability, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getConditionalProbability(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -296,4 +327,6 @@ export const conditionalProbability = {
     subject: "Mathématiques",
     hasHintAndCorrection: true,
     getQuestionFromIdentifiers,
+    options,
+    validateOptions,
 };

package/lib/exercises/math/probaStat/independancy/independancy.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    pA: number;
+    pB: number;
+    pUnion: number;
+};
+export declare const independancy: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=independancy.d.ts.map

package/lib/exercises/math/probaStat/independancy/independancy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"independancy.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/independancy.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAkHF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAc9C,CAAC"}

package/lib/exercises/math/probaStat/independancy/independancy.js

@@ -0,0 +1,114 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { DecimalConstructor } from "../../../../math/numbers/decimals/decimal.js";
+import { frenchify } from "../../../../math/utils/latex/frenchify.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { pA, pB, pUnion } = identifiers;
+    return `Soient deux événements $A$ et $B$ tels que $P(A) = ${frenchify(pA)}$, $P(B) = ${frenchify(pB)}$ et $P(A\\cup B) = ${frenchify(pUnion)}$. 
+  
+Les événements $A$ et $B$ sont-ils indépendants ?`;
+};
+const getHint = () => {
+    return `Deux évènements $M$ et $N$ sont indépendants si et seulement si : 
+  
+$$
+P(M\\cap N) = P(M)\\times P(N)
+$$
+
+D'autre part, on rappelle la formule de l'union : 
+
+$$
+P(A \\cup B) = P(A) + P(B) - P(A \\cap B)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { pA, pB, pUnion } = identifiers;
+    const isInde = getAnswer(identifiers) === "Oui";
+    return `On sait que : 
+  
+$$
+P(A \\cup B) = P(A) + P(B) - P(A \\cap B)
+$$
+
+On a donc : 
+
+$$
+P(A \\cap B) = P(A) + P(B) - P(A \\cup B) = ${round(pA + pB - pUnion, 5).frenchify()}
+$$
+
+D'autre part, 
+
+$$
+P(A)\\times P(B) = ${multiply(pA, pB).toTex()} = ${round(pA * pB, 5).frenchify()}
+$$
+
+${isInde
+        ? `Puisque $P(A\\cap B) = P(A)\\times P(B)$, les évènements $A$ et $B$ sont bien indépendants.`
+        : `Puisque $P(A\\cap B) \\neq P(A)\\times P(B)$, les évènements $A$ et $B$ ne sont pas indépendants.`}
+`;
+};
+const getAnswer = (identifiers) => {
+    const { pA, pB, pUnion } = identifiers;
+    return Math.abs(pA + pB - pA * pB - pUnion) < 0.0001 ? "Oui" : "Non";
+};
+const getIndependancyQuestion = () => {
+    const pA = DecimalConstructor.random(0, 1, randint(1, 3));
+    const pB = DecimalConstructor.random(0, 1, randint(1, 3));
+    const areIndependants = coinFlip();
+    let pUnion;
+    const unionValueIfIndependants = round(pA.value + pB.value - pA.value * pB.value, 5);
+    if (areIndependants)
+        pUnion = unionValueIfIndependants;
+    else {
+        let counter = 0;
+        do {
+            counter++;
+            if (counter > 1000)
+                throw new Error("Too many iterations in independancy");
+            pUnion = DecimalConstructor.random(0, 1, randint(1, 3)).value;
+        } while ((pUnion < pA.value && pUnion < pB.value) ||
+            pUnion === unionValueIfIndependants ||
+            pUnion > pA.value + pB.value);
+    }
+    const identifiers = { pA: pA.value, pB: pB.value, pUnion };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (_n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffle(propositions);
+};
+export const independancy = {
+    id: "independancy",
+    connector: "=",
+    label: "Déterminer l'indépendance de deux événements en connaissant $P(A)$, $P(B)$ et $P(A\\cup B)$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getIndependancyQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/independancy/independancyFindCap.d.ts

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

package/lib/exercises/math/probaStat/independancy/independancyFindCap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"independancyFindCap.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/independancyFindCap.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAuFF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}

package/lib/exercises/math/probaStat/independancy/independancyFindCap.js

@@ -0,0 +1,101 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, add(pA, pB).simplify().toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(0, 1, randint(1, 3)).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    return multiply(pA, pB).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    return `On considère deux événements indépendants $A$ et $B$, tels que $P(A) = ${pA.toTex()}$ et $P(B) = ${pB.toTex()}$.
+  
+Déterminer $P(A\\cap B)$.`;
+};
+const getHint = () => {
+    return `Deux événements $A$ et $B$ sont indépendants si et seulement si $P(A)\\times P(B) = P(A\\cap B)$.`;
+};
+const getCorrection = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    return `Puisque $A$ et $B$ sont indépendants, alors on a :
+  
+${alignTex([
+        ["P(A\\cap B)", "=", "P(A)\\times P(B)"],
+        ["", "=", multiply(pA, pB).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIndependancyFindCapQuestion = () => {
+    const pA = randfloat(0, 1, randint(1, 3));
+    const pB = randfloat(0, 1, randint(1, 3));
+    const identifiers = {
+        pAIds: pA.toTree().toIdentifiers(),
+        pBIds: pB.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const independancyFindCap = {
+    id: "independancyFindCap",
+    connector: "=",
+    label: "Calculer l'intersection de deux événements indépendants",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIndependancyFindCapQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/independancy/independancyFindCup.d.ts

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

package/lib/exercises/math/probaStat/independancy/independancyFindCup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"independancyFindCup.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/independancyFindCup.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAuGF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}