math-exercises 3.0.176 → 3.0.177

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductOrthoInSquare.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductOrthoInSquare.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductOrthoInSquare.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAwMF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAmB5D,CAAC"}
+{"version":3,"file":"scalarProductOrthoInSquare.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/scalarProduct/scalarProductOrthoInSquare.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAkOF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAmB5D,CAAC"}

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

@@ -1,5 +1,7 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile,
 // GetHint,
+// GetCorrection,
+// GetHint,
 // GetCorrection,
  } from "../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
@@ -155,14 +157,37 @@ const getScalarProductOrthoInSquareQuestion = () => {
 // `;
 // };
 // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   const {areSameDirection,vec1Name,vec2Name} = identifiers
-//   if(areSameDirection){
-//     const vec1 =
+//   const { areSameDirection, vec1Name, vec2Name, c } = identifiers;
+//   const vecs = [
+//     ["AB", "DC"],
+//     ["AC"],
+//     ["AD", "IK", "BC"],
+//     ["AJ", "LC"],
+//     ["AO", "LK", "OC", "IJ"],
+//     ["AK", "IC"],
+//     ["AI", "IB", "LO", "OJ", "DK", "KC"],
+//     ["AL", "LD", "IO", "OK", "BJ", "JC"],
+//   ];
+//   const index1 = vecs.findIndex(
+//     (e) =>
+//       e.includes(vec1Name) || e.includes(vec1Name.split("").reverse().join("")),
+//   );
+//   const firstIsReversed = !vecs[index1].includes(vec1Name);
+//   const index2 = vecs.findIndex(
+//     (e) =>
+//       e.includes(vec2Name) || e.includes(vec2Name.split("").reverse().join("")),
+//   );
+//   const secondIsReversed = !vecs[index2].includes(vec2Name);
+//   if (vec1Name[0] === vec2Name[0]) return `immédiat`;
+//   for (let i = 0; i < vecs[index1].length; i++) {
+//     const rep = vecs[index1][i];
+//     const origin1 = rep[0];
+//     const sameOrigin = vecs[index2].find((e) => e[0] === origin1);
+//     if (sameOrigin)
+//       return `on prend $${rep}$ et $${sameOrigin}$. ${sameOrigin[1]} à projeter sur ${rep}`;
 //   }
 //   return `On a :
-// ${alignTex([
-//   []
-// ])}
+// ${alignTex([[]])}
 // `;
 // };
 const getQuestionFromIdentifiers = (identifiers) => {

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

@@ -1,4 +1,2 @@
-export { probabilityTree, probabilityTreeIntersection, probabilityTreeTotalProbability, probabilityTreeReadProbability, probabilityTreeInversionProbability, } from "./probabilityTree.js";
-export * from "./fillProbaTreeWithComplementaryProbabilities.js";
-export * from "./buildTreeFromSituation.js";
+export { probabilityTree, } from "./probabilityTree.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EACf,2BAA2B,EAC3B,+BAA+B,EAC/B,8BAA8B,EAC9B,mCAAmC,GACpC,MAAM,sBAAsB,CAAC;AAC9B,cAAc,kDAAkD,CAAC;AACjE,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,GAKhB,MAAM,sBAAsB,CAAC"}

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

@@ -1,5 +1,10 @@
 // export * from "./treeInInstruction.js";
 // export * from "./treeInAnswer.js";
-export { probabilityTree, probabilityTreeIntersection, probabilityTreeTotalProbability, probabilityTreeReadProbability, probabilityTreeInversionProbability, } from "./probabilityTree.js";
-export * from "./fillProbaTreeWithComplementaryProbabilities.js";
-export * from "./buildTreeFromSituation.js";
+export { probabilityTree,
+// probabilityTreeIntersection,
+// probabilityTreeTotalProbability,
+// probabilityTreeReadProbability,
+// probabilityTreeInversionProbability,
+ } from "./probabilityTree.js";
+// export * from "./fillProbaTreeWithComplementaryProbabilities.js";
+// export * from "./buildTreeFromSituation.js";

package/lib/exercises/math/probaStat/trees/probabilityTree.d.ts

@@ -8,18 +8,12 @@ type Identifiers = {
     BC: NodeIdentifiers;
     BD: NodeIdentifiers;
     probaName: string;
-    useContraryNames?: boolean;
 };
 type Options = {
-    allowApproximate?: string;
-    eventTypes?: string[];
-    probaType?: string;
-    eventsNames?: string;
+    allowApproximate: string;
+    eventTypes: string[];
+    probaType: string;
 };
 export declare const probabilityTree: Exercise<Identifiers, Options>;
-export declare const probabilityTreeIntersection: Exercise<Identifiers, Options>;
-export declare const probabilityTreeTotalProbability: Exercise<Identifiers, Options>;
-export declare const probabilityTreeReadProbability: Exercise<Identifiers, Options>;
-export declare const probabilityTreeInversionProbability: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=probabilityTree.d.ts.map

package/lib/exercises/math/probaStat/trees/probabilityTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probabilityTree.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/probabilityTree.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,OAAO,EACL,QAAQ,EAkBT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IAIjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAuhBF,KAAK,OAAO,GAAG;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAwDF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe1D,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwBtE,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwB1E,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA2BzE,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CACxD,WAAW,EACX,OAAO,CA0BR,CAAC"}
+{"version":3,"file":"probabilityTree.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/probabilityTree.ts"],"names":[],"mappings":"AAOA,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,OAAO,EACL,QAAQ,EAiBT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IAIjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,EAAE,EAAE,eAAe,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkNF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA2CF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe1D,CAAC"}

package/lib/exercises/math/probaStat/trees/probabilityTree.js

@@ -1,11 +1,11 @@
 import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
 import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { random } from "../../../../utils/alea/random.js";
@@ -18,26 +18,12 @@ const optionValues = [
     "Probabilité totale $P(C)$",
     "Probabilité conditionnelle $P_B(A)$",
     "Probabilité 'simple' $P(A)$",
-    "Probabilité d'inversion de causalité $P_B(A)$",
 ];
 const defaultOptionValues = [
     "Probabilité d'intersection $P(A\\cap C)$",
     "Probabilité totale $P(C)$",
     "Probabilité conditionnelle $P_B(A)$",
-    "Probabilité 'simple' $P(A)$",
 ];
-const getProbaType = (identifiers) => {
-    const { probaName } = identifiers;
-    return probaName.includes("\\cap")
-        ? "inter"
-        : ["P(C)", "P(D)"].includes(probaName)
-            ? "totale"
-            : ["P(A)", "P(B)"].includes(probaName)
-                ? "simple"
-                : ["P_A(C)", "P_A(D)", "P_B(C)", "P_B(D)"].includes(probaName)
-                    ? "conditionnelle"
-                    : "inversion";
-};
 const buildAll = (identifiers) => {
     return {
         pA: NodeConstructor.fromIdentifiers(identifiers.A),
@@ -76,82 +62,16 @@ const getAnswerNode = (identifiers) => {
         case "P(D)":
         default:
             return add(multiply(probas.pA, probas.pAD), multiply(probas.pB, probas.pBD)).simplify();
-        case "P_C(A)": {
-            //anc / c
-            const pc = add(multiply(probas.pA, probas.pAC), multiply(probas.pB, probas.pBC)).simplify();
-            return frac(multiply(probas.pA, probas.pAC), pc).simplify();
-        }
-        case "P_C(B)": {
-            //cnb / c
-            const pc = add(multiply(probas.pA, probas.pAC), multiply(probas.pB, probas.pBC)).simplify();
-            return frac(multiply(probas.pB, probas.pBC), pc).simplify();
-        }
-        case "P_D(A)": {
-            //and / d
-            const pd = add(multiply(probas.pA, probas.pAD), multiply(probas.pB, probas.pBD)).simplify();
-            return frac(multiply(probas.pA, probas.pAD), pd).simplify();
-        }
-        case "P_D(B)": {
-            //cnb / c
-            const pd = add(multiply(probas.pA, probas.pAD), multiply(probas.pB, probas.pBD)).simplify();
-            return frac(multiply(probas.pB, probas.pBD), pd).simplify();
-        }
     }
 };
 const getAnswer = (identifiers) => {
     return getAnswerNode(identifiers).toTex();
 };
-const getTrueProbaName = (identifiers) => {
-    const { probaName, useContraryNames } = identifiers;
-    if (!useContraryNames)
-        return probaName;
-    return probaName
-        .replaceAll("_B", "_{\\overline{A}}")
-        .replaceAll("B", "\\overline{A}")
-        .replaceAll("_D", "_{\\overline{B}}")
-        .replaceAll("C", "B")
-        .replaceAll("D", "\\overline{B}");
-};
 const getInstruction = (identifiers, options) => {
-    const probas = buildAll(identifiers);
-    const type = getProbaType(identifiers);
-    const { useContraryNames } = identifiers;
-    const trueProbaName = getTrueProbaName(identifiers);
-    const tree = [
-        [
-            [
-                [`£${probas.pA.toTex()}£`, "£A£"],
-                [
-                    `£${probas.pB.toTex()}£`,
-                    useContraryNames ? "£\\overline{A}£" : "£B£",
-                ],
-            ],
-        ],
-        [
-            [
-                [`£${probas.pAC.toTex()}£`, useContraryNames ? "£B£" : "£C£"],
-                [
-                    `£${probas.pAD.toTex()}£`,
-                    useContraryNames ? "£\\overline{B}£" : "£D£",
-                ],
-            ],
-            [
-                [`£${probas.pBC.toTex()}£`, useContraryNames ? "£B£" : "£C£"],
-                [
-                    `£${probas.pBD.toTex()}£`,
-                    useContraryNames ? "£\\overline{B}£" : "£D£",
-                ],
-            ],
-        ],
-    ];
-    let instr = `On considère l'arbre de probabilités ci-dessous :
-  
-<svg id="treeDiagram">${JSON.stringify(tree)}</svg>
-  
-${type === "conditionnelle" || type === "simple" ? "Déterminer :" : "Calculer :"} 
+    let instr = `On considère l'arbre de probabilités ci-dessous. Calculer : 
   
 $$
-${trueProbaName}
+${identifiers.probaName}
 $$`;
     if (options?.allowApproximate) {
         instr += `
@@ -171,7 +91,7 @@ const getProbaAndOpposite = (decimal = false) => {
     }
 };
 const getStartStatement = (identifiers) => {
-    return getTrueProbaName(identifiers);
+    return identifiers.probaName;
 };
 const getProbabilityTree = (opts) => {
     const isDecimal = opts?.probaType === "Décimales";
@@ -202,9 +122,6 @@ const getProbabilityTree = (opts) => {
         case 3: //simple
             probaName = random(["P(A)", "P(B)"]);
             break;
-        case 4: //inversion
-            probaName = random(["P_C(A)", "P_D(A)", "P_C(B)", "P_D(B)"]);
-            break;
     }
     const identifiers = {
         A: pA.toIdentifiers(),
@@ -214,254 +131,58 @@ const getProbabilityTree = (opts) => {
         BC: pCSachantB.toIdentifiers(),
         BD: pDSachantB.toIdentifiers(),
         probaName,
-        useContraryNames: opts?.eventsNames === "Événements et leur contraire",
     };
     return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getHint = (identifiers) => {
-    const { probaName, useContraryNames } = identifiers;
-    const type = getProbaType(identifiers);
-    const trueProbaName = getTrueProbaName(identifiers);
-    switch (type) {
-        case "conditionnelle": {
-            const splitted = probaName
-                .replaceAll("(", "")
-                .replaceAll(")", "")
-                .split("_")[1];
-            const under = splitted[0];
-            const trueUnder = useContraryNames && under === "B" ? "\\overline{A}" : under;
-            const over = splitted[1];
-            const trueOver = useContraryNames
-                ? over === "C"
-                    ? "B"
-                    : "\\overline{B}"
-                : over;
-            return `La probabilité $${trueProbaName}$ est la probabilité de $${trueOver}$ sachant $${trueUnder}$.
-
-Dans l'arbre, elle se lit sur la branche partant de $${trueUnder}$ et allant jusqu'à $${trueOver}$.`;
-        }
-        case "inter": {
-            const [first, second] = probaName
-                .replaceAll("P(", "")
-                .replaceAll(")", "")
-                .split("\\cap ");
-            const trueFirst = useContraryNames && first === "B" ? "\\overline{A}" : first;
-            const trueSecond = useContraryNames
-                ? second === "C"
-                    ? "B"
-                    : "\\overline{B}"
-                : second;
-            return `La probabilité $${trueProbaName}$ est la probabilité d'une intersection. 
-      
-Pour la calculer, il faut multiplier les probabilités présentes sur les branches suivant le chemin $${trueFirst}$ puis $${trueSecond}$.
-`;
-        }
-        case "totale": {
-            const evenement = probaName[2];
-            const trueEvenement = useContraryNames
-                ? evenement === "C"
-                    ? "B"
-                    : "\\overline{B}"
-                : evenement;
-            return `Il y a plusieurs chemins qui mènent à l'événement $${trueEvenement}$. Sa probabilité est la somme des probabilités de chacun de ces chemins. Pour obtenir la probabilité d'un chemin, il faut multiplier les probabilités présentes sur les branches de ce chemin.`;
-        }
-        case "simple": {
-            const trueEvent = useContraryNames && probaName[2] === "B"
-                ? "\\overline{A}"
-                : probaName[2];
-            return `La probabilité $${trueProbaName}$ se lit sur la branche menant à l'événement $${trueEvent}$.`;
-        }
-        case "inversion": {
-            const splitted = probaName
-                .replaceAll("(", "")
-                .replaceAll(")", "")
-                .split("_")[1];
-            const under = splitted[0];
-            const trueUnder = useContraryNames
-                ? under === "C"
-                    ? "B"
-                    : "\\overline{B}"
-                : under;
-            const over = splitted[1];
-            const trueOver = useContraryNames && over === "B" ? "\\overline{A}" : over;
-            return `La probabilité $${trueProbaName}$ est la probabilité de $${trueOver}$ sachant $${trueUnder}$.
-
-Pour la déterminer, tu peux revenir à la définition d'une probabilité conditionnelle : pour deux évenements $M$ et $N$, on a : 
-
-$$
-P_M(N) = \\frac{P(M \\cap N)}{P(M)}
-$$
-`;
-        }
-    }
-};
-const getCorrection = (identifiers) => {
-    const { probaName } = identifiers;
-    const probas = buildAll(identifiers);
-    const type = getProbaType(identifiers);
-    const trueProbaName = getTrueProbaName(identifiers);
-    const { useContraryNames } = identifiers;
-    switch (type) {
-        case "conditionnelle": {
-            const splitted = probaName
-                .replaceAll("(", "")
-                .replaceAll(")", "")
-                .split("_")[1];
-            const under = splitted[0];
-            const trueUnder = useContraryNames && under === "B" ? "\\overline{A}" : under;
-            const over = splitted[1];
-            const trueOver = useContraryNames
-                ? over === "C"
-                    ? "B"
-                    : "\\overline{B}"
-                : over;
-            return `La probabilité $${trueProbaName}$ est la probabilité de $${trueOver}$ sachant $${trueUnder}$.
-
-Dans l'arbre, elle se lit sur la branche partant de $${trueUnder}$ et allant jusqu'à $${trueOver}$.
-
-On a donc : 
-
-$$
-${trueProbaName} = ${getAnswer(identifiers)}
-$$`;
-        }
-        case "inter": {
-            const [first, second] = probaName
-                .replaceAll("P(", "")
-                .replaceAll(")", "")
-                .split("\\cap ");
-            const firstProba = first === "A" ? probas.pA : probas.pB;
-            const secondProba = second === "C"
-                ? first === "A"
-                    ? probas.pAC
-                    : probas.pBC
-                : first === "A"
-                    ? probas.pAD
-                    : probas.pBD;
-            const trueFirst = useContraryNames && first === "B" ? "\\overline{A}" : first;
-            const secondFirst = useContraryNames
-                ? second === "C"
-                    ? "B"
-                    : "\\overline{B}"
-                : second;
-            return `La probabilité $${trueProbaName}$ est la probabilité d'une intersection. 
-      
-Pour la calculer, il faut multiplier les probabilités présentes sur les branches suivant le chemin $${trueFirst}$ puis $${secondFirst}$. 
-
-On a donc : 
-
-$$
-${trueProbaName} = ${multiply(firstProba, secondProba).toSimplificationTex()}
-$$
-`;
-        }
-        case "totale": {
-            const evenement = probaName[2];
-            const trueEvenement = useContraryNames
-                ? evenement === "C"
-                    ? "B"
-                    : "\\overline{B}"
-                : evenement;
-            const first = evenement === "C" ? probas.pAC : probas.pAD;
-            const second = evenement === "C" ? probas.pBC : probas.pBD;
-            const firstWay = multiply(probas.pA, first);
-            const secondWay = multiply(probas.pB, second);
-            return `Il y a plusieurs chemins qui mènent à l'événement $${trueEvenement}$ : le chemin de l'intersection $A\\cap ${trueEvenement}$ et celui de l'intersection $${useContraryNames ? "\\overline{A}" : "B"}\\cap ${trueEvenement}$. La probabilité $${trueProbaName}$ est la somme des probabilités de ces chemins.
-
-On a : 
-
-$$
-P(A\\cap ${trueEvenement}) = ${firstWay.toSimplificationTex()}
-$$
-
-et
-
-$$
-P(${useContraryNames ? "\\overline{A}" : "B"}\\cap ${trueEvenement}) = ${secondWay.toSimplificationTex()}
-$$
-
-Donc : 
-
-$$
-${trueProbaName} = ${add(firstWay.simplify(), secondWay.simplify()).toSimplificationTex()}
-$$      
-`;
-        }
-        case "simple": {
-            const trueEvent = useContraryNames && probaName[2] === "B"
-                ? "\\overline{A}"
-                : probaName[2];
-            return `La probabilité $${trueProbaName}$ se lit sur la branche menant à l'événement $${trueEvent}$.
-      
-On a donc : 
-
-$$
-${trueProbaName} = ${getAnswer(identifiers)}
-$$`;
-        }
-        case "inversion": {
-            const splitted = probaName
-                .replaceAll("(", "")
-                .replaceAll(")", "")
-                .split("_")[1];
-            const under = splitted[0];
-            const trueUnder = useContraryNames
-                ? under === "C"
-                    ? "B"
-                    : "\\overline{B}"
-                : under;
-            const over = splitted[1];
-            const trueOver = useContraryNames && over === "B" ? "\\overline{A}" : over;
-            const total = add(multiply(probas.pA, under === "C" ? probas.pAC : probas.pAD), multiply(probas.pB, under === "C" ? probas.pBC : probas.pBD));
-            const inter = multiply(over === "A" ? probas.pA : probas.pB, under === "C"
-                ? over === "A"
-                    ? probas.pAC
-                    : probas.pBC
-                : over === "A"
-                    ? probas.pAD
-                    : probas.pBD);
-            return `La probabilité $${trueProbaName}$ est la probabilité de $${trueOver}$ sachant $${trueUnder}$.
-
-Pour la déterminer, on revient à la définition d'une probabilité conditionnelle : 
-
-$$
-${trueProbaName} = \\frac{P(${trueOver} \\cap ${trueUnder})}{P(${trueUnder})}
-$$
-
-On calcule donc d'abord $P(${trueOver} \\cap ${trueUnder})$ :
-
-$$
-P(${trueOver} \\cap ${trueUnder}) = ${inter.toSimplificationTex()}
-$$
-
-Puis on calcule la probabilité totale $P(${trueUnder})$ :
-
-$$
-P(${trueUnder})=${total.toSimplificationTex()}
-$$
-
-On a donc : 
-
-$$
-${trueProbaName} = ${frac(inter.simplify(), total.simplify()).toSimplificationTex()}
-$$
-`;
-        }
-    }
-};
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         instruction: getInstruction(identifiers, opts),
         startStatement: getStartStatement(identifiers, opts),
-        answer: getAnswer(identifiers, opts),
+        answer: getAnswer(identifiers),
         keys: [],
+        ggbOptions: getGGBOptions(identifiers, opts),
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers, opts),
-        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
+const getGGBOptions = (identifiers) => {
+    const probas = buildAll(identifiers);
+    const commands = [
+        "A = Point({2,2})",
+        "B = Point({2,-2})",
+        "AC = Point({5,3})",
+        "AD = Point({5,1})",
+        "BC = Point({5,-1})",
+        "BD = Point({5,-3})",
+        "Segment(Point({0,0}),A)",
+        "Segment(A,AC)",
+        "Segment(A,AD)",
+        "Segment(Point({0,0}),B)",
+        "Segment(B,BC)",
+        "Segment(B,BD)",
+        `Text("\\scriptsize ${probas.pA.toTex()}", (0.1, 2.2), true, true)`,
+        `Text("\\scriptsize ${probas.pAC.toTex()}", (2.8, 4), true, true)`,
+        `Text("\\scriptsize ${probas.pAD.toTex()}", (2.8, 1.6), true, true)`,
+        `Text("\\scriptsize ${probas.pB.toTex()}", (0.1, -0.8), true, true)`,
+        `Text("\\scriptsize ${probas.pBC.toTex()}", (2.8, -0.6), true, true)`,
+        `Text("\\scriptsize ${probas.pBD.toTex()}", (2.8, -2.5), true, true)`,
+        'Text("A", (1.85 , 2.5))',
+        'Text("B", (1.85 , -2.8))',
+        'Text("C", (5.5 , 2.85))',
+        'Text("D", (5.5 , 0.85))',
+        'Text("C", (5.5 , -1.1))',
+        'Text("D", (5.5 , -3.1))',
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: [-2, 8, -5, 5],
+    });
+};
 const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -512,114 +233,19 @@ const options = [
         defaultValue: "Fractions",
         values: ["Fractions", "Décimales"],
     },
-    {
-        id: "eventsNames",
-        label: "Noms des événements",
-        target: GeneratorOptionTarget.generation,
-        type: GeneratorOptionType.select,
-        defaultValue: "Événements et leur contraire",
-        values: [
-            "Événements et leur contraire",
-            "Noms d'événements tous différents",
-        ],
-    },
 ];
-const partialOptions = options.filter((p) => p.id !== "eventTypes");
 export const probabilityTree = {
     id: "probabilityTree",
     connector: "=",
-    label: "Calculer une probabilité dans un arbre pondéré (tous calculs)",
+    label: "Calculs de probabilités à l'aide d'un arbre pondéré",
     isSingleStep: false,
     generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
+    hasGeogebra: true,
     subject: "Mathématiques",
     options,
     getQuestionFromIdentifiers,
-    hasHintAndCorrection: true,
-};
-export const probabilityTreeIntersection = {
-    id: "probabilityTreeIntersection",
-    connector: "=",
-    label: "Calculer une intersection dans un arbre pondéré",
-    isSingleStep: false,
-    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree({
-        eventTypes: ["Probabilité d'intersection $P(A\\cap C)$"],
-        allowApproximate: opts?.allowApproximate,
-        probaType: opts?.probaType,
-        eventsNames: opts?.eventsNames,
-    }), nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-    isAnswerValid,
-    subject: "Mathématiques",
-    options: partialOptions,
-    getQuestionFromIdentifiers,
-    hasHintAndCorrection: true,
-};
-export const probabilityTreeTotalProbability = {
-    id: "probabilityTreeTotalProbability",
-    connector: "=",
-    label: "Calculer une probabilité totale dans un arbre pondéré",
-    isSingleStep: false,
-    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree({
-        eventTypes: ["Probabilité totale $P(C)$"],
-        allowApproximate: opts?.allowApproximate,
-        probaType: opts?.probaType,
-        eventsNames: opts?.eventsNames,
-    }), nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-    isAnswerValid,
-    subject: "Mathématiques",
-    options: partialOptions,
-    getQuestionFromIdentifiers,
-    hasHintAndCorrection: true,
-};
-export const probabilityTreeReadProbability = {
-    id: "probabilityTreeReadProbability",
-    connector: "=",
-    label: "Lire une probabilité dans un arbre pondéré",
-    isSingleStep: false,
-    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree({
-        eventTypes: [
-            "Probabilité conditionnelle $P_B(A)$",
-            "Probabilité 'simple' $P(A)$",
-        ],
-        allowApproximate: opts?.allowApproximate,
-        probaType: opts?.probaType,
-        eventsNames: opts?.eventsNames,
-    }), nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-    isAnswerValid,
-    subject: "Mathématiques",
-    options: partialOptions,
-    getQuestionFromIdentifiers,
-    hasHintAndCorrection: true,
-};
-export const probabilityTreeInversionProbability = {
-    id: "probabilityTreeInversionProbability",
-    connector: "=",
-    label: "Calculer une probabilité d'inversion de causalité du type $P_B(A)$ dans un arbre pondéré",
-    isSingleStep: false,
-    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree({
-        eventTypes: ["Probabilité d'inversion de causalité $P_B(A)$"],
-        allowApproximate: opts?.allowApproximate,
-        probaType: opts?.probaType,
-        eventsNames: opts?.eventsNames,
-    }), nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-    isAnswerValid,
-    subject: "Mathématiques",
-    options: partialOptions,
-    getQuestionFromIdentifiers,
-    hasHintAndCorrection: true,
 };