math-exercises 3.0.157 → 3.0.159

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductViaCos.js

@@ -3,13 +3,47 @@ import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinct
 import { mainTrigoValues, remarkableTrigoValues, } from "../../../../../math/trigonometry/remarkableValues.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
-import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { multiply, MultiplyNode, } from "../../../../../tree/nodes/operators/multiplyNode.js";
 import { randomLetter } from "../../../../../utils/strings/randomLetter.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
 import { random } from "../../../../../utils/alea/random.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { cos } from "../../../../../tree/nodes/functions/cosNode.js";
 //|u| |v| cos(u,v)
+const getHint = () => {
+    return `Utilise la formule du produit scalaire suivante : 
+  
+$$
+\\overrightarrow{u}\\cdot \\overrightarrow{v} = ||\\overrightarrow{u}|| \\times ||\\overrightarrow{v}||\\times \\cos(\\widehat{\\overrightarrow{u}, \\overrightarrow{v}})
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { AB, AC, trigoPoint, letters } = identifiers;
+    const trigo = mainTrigoValues.find((v) => v.point === trigoPoint);
+    const [letterA, letterB, letterC] = letters;
+    const u = letterA + letterB;
+    const v = letterA + letterC;
+    return `Utilise la formule du produit scalaire suivante : 
+  
+$$
+\\overrightarrow{u}\\cdot \\overrightarrow{v} = ||\\overrightarrow{u}|| \\times ||\\overrightarrow{v}||\\times \\cos(\\widehat{\\overrightarrow{u}, \\overrightarrow{v}})
+$$
+
+Ici, on a donc : 
+
+${alignTex([
+        [
+            `\\overrightarrow{${u}}\\cdot \\overrightarrow{${v}}`,
+            "=",
+            `${u}\\times ${v}\\times \\cos\\left(${letterB}${letterA}${letterC}\\right)`,
+        ],
+        ["", "=", multiply(multiply(AB, AC), cos(trigo.angle)).toTex()],
+        ["", "=", multiply(multiply(AB, AC), trigo.cos).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
 const getInstruction = (identifiers) => {
     const { AB, AC, trigoPoint, letters } = identifiers;
     const [letterA, letterB, letterC] = letters;
@@ -45,6 +79,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["pi"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -83,4 +119,5 @@ export const scalarProductViaCos = {
     getInstruction,
     getAnswer,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

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

@@ -0,0 +1,118 @@
+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 { substract } from "../../../../tree/nodes/operators/substractNode.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, multiply(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 substract(add(pA, pB), 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\\cup 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)$.
+  
+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 { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    const pAB = multiply(pA, pB);
+    const pABSimp = pAB.simplify();
+    return `Puisque $A$ et $B$ sont indépendants, alors on a :
+  
+${alignTex([
+        ["P(A\\cap B)", "=", "P(A)\\times P(B)"],
+        ["", "=", pAB.toTex()],
+        ["", "=", pABSimp.toTex()],
+    ])}
+
+On utilise ensuite la formule de l'union : 
+
+${alignTex([
+        ["P(A \\cup B)", "=", "P(A) + P(B) - P(A \\cap B)"],
+        ["", "=", substract(add(pA, pB), pABSimp).toTex()],
+        ["", "=", substract(add(pA, pB), pABSimp).simplify().toTex()],
+    ])}
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIndependancyFindCupQuestion = () => {
+    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 independancyFindCup = {
+    id: "independancyFindCup",
+    connector: "=",
+    label: "Calculer l'union de deux événements indépendants",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIndependancyFindCupQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,5 @@
+export * from "./independancy.js";
+export * from "./isIndependantFromDefinition.js";
+export * from "./independancyFindCap.js";
+export * from "./independancyFindCup.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC"}

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

@@ -0,0 +1,4 @@
+export * from "./independancy.js";
+export * from "./isIndependantFromDefinition.js";
+export * from "./independancyFindCap.js";
+export * from "./independancyFindCup.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"isIndependantFromDefinition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/isIndependantFromDefinition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AA8FF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAqB7D,CAAC"}