// Numbas version: exam_results_page_options
{"name": "Logical Equivalence Proof", "extensions": ["propositionallogic"], "custom_part_types": [], "resources": [], "navigation": {"allowregen": true, "showfrontpage": false, "preventleave": false, "typeendtoleave": false}, "question_groups": [{"pickingStrategy": "all-ordered", "questions": [{"name": "Logical Equivalence Proof", "tags": [], "metadata": {"description": "<p>Asks students to apply laws of logical equivalence to prove the equivalence between two logical statements. The quiz should accept any correct answer (as long as each step is included, with one law per step), and provides detailed feedback on mistakes.</p>", "licence": "Creative Commons Attribution-ShareAlike 4.0 International"}, "statement": "<p>Show that {eqn}.</p>\n<h3>Instructions to fill the gaps</h3>\n<ul>\n<li>Apply <strong> one and only one </strong> law per step.</li>\n<li><strong>Start from the left hand side (already given)</strong>, and <strong>finish with the right hand side</strong>. Do not rewrite the Left hand side.<em> You will lose marks if you do not, as the system will conclude that you did not include all steps of the proof.</em></li>\n<li>You can add additional steps, and <strong>any blank step at the end will signal the end of your work </strong> (so don't skip a line).</li>\n<li>The system will automatically interpret your entry and display a formula. <em>If no formula appears, it means that the system cannot parse your entry. Check the syntax.</em> Note that the displayed formula does not show all brackets, because it applies bodmas, which can be confusing at first. Unfortunately this is hardcoded and cannot be changed.</li>\n<li>You can enter formulas using either the operations &not;,&and;,&or;, or English words not, and, or. So, the input \"p and (q or not p)\" is the same as \"p &and; (q &or; &not; p)\".</li>\n<li>The easiest way to enter a step is either type it with the plain words (\"not p or (not q and p)\") or to copy-paste the previous formula and modify it appropriately.</li>\n<li>At the bottom of this question you will find a table with the list of operations, and the keywords to use. You can copy/paste from there.</li>\n</ul>\n<h3>Entering your solution</h3>\n<div><strong>You are strongly encouraged to work out your proof on paper before entering it into the system.</strong> It will save you time, and give you an opportunity to review your work and take notes if you made a mistake.</div>\n<div>Please note that the system should accept any correct proof. You can only apply <strong>one law per step</strong>, not more (in particular you cannot apply the same law twice in one go - it has to be done in two steps: it is one law per step, not one type of law per step).</div>\n<div>The system checks your proof and returns whether it is correct.</div>", "advice": "", "rulesets": {}, "extensions": ["propositionallogic"], "builtin_constants": {"e": true, "pi,\u03c0": true, "i": true}, "constants": [], "variables": {"s_eqn": {"name": "s_eqn", "group": "DIsplay Variables", "definition": "s_lhs + \" \u2261 \" + s_rhs", "description": "<p>Unicode string translation of the problem to solve.</p>", "templateType": "anything", "can_override": false}, "lhs": {"name": "lhs", "group": "Left Hand Side", "definition": "generateExpression(nops,atoms)", "description": "<p>A randomly generated expression. The students will be asked to simplify this expression.</p>", "templateType": "anything", "can_override": true}, "atoms": {"name": "atoms", "group": "General Parameters", "definition": "[ \"p\", \"q\" ]", "description": "<p>The list of atoms to use in the boolean expression. For the moment, only two atoms are supported.</p>", "templateType": "list of strings", "can_override": false}, "nops": {"name": "nops", "group": "General Parameters", "definition": "5", "description": "<p>number of logical operations to use in the randomly generated expression.</p>", "templateType": "number", "can_override": true}, "rhs": {"name": "rhs", "group": "Right Hand Side", "definition": "simplifyProposition(lhs)", "description": "<p>The right hand side fo the equivalence is the simplified form of the expression lhs.</p>", "templateType": "anything", "can_override": false}, "s_lhs": {"name": "s_lhs", "group": "Left Hand Side", "definition": "stringify(lhs)", "description": "<p>The string containing the expression lhs, to simplify</p>", "templateType": "anything", "can_override": false}, "eqn": {"name": "eqn", "group": "DIsplay Variables", "definition": "\"$\" + latexify(lhs) + \"\\\\equiv \" + latexify(rhs) +\"$\"", "description": "<p>LaTeX translation of the problem to solve, used to display the question.</p>", "templateType": "anything", "can_override": false}, "banned": {"name": "banned", "group": "Right Hand Side", "definition": "[expression(\"p xor q\"),expression(\"not (p xor q)\")]", "description": "<p>A list of banned expressions: for example we want to avoid the operator `xor` because it doesn't have a nice latex/unicode version, which can confuse the students.</p>", "templateType": "anything", "can_override": false}, "qID": {"name": "qID", "group": "General Parameters", "definition": "random(10000 .. 99999#1)", "description": "<p>Random ID for the question. If we include multiple times this question in an exam, this ID is used to identify the html elements.</p>", "templateType": "randrange", "can_override": false}, "countID": {"name": "countID", "group": "General Parameters", "definition": "\"stepCount\"+string(qID)", "description": "<p>An id for the input for the number of steps. This is useful to identify this html element if we use that question more than once.</p>", "templateType": "anything", "can_override": false}, "countInput": {"name": "countInput", "group": "General Parameters", "definition": "\"<input type=\\\"number\\\" name=\\\"nsteps\\\" min=\\\"3\\\" max=\\\"20\\\" id=\\\"stepCount\" + string(qID)+\"\\\" value=\\\"3\\\" />\"", "description": "<p>The html element to ask the number of steps.</p>", "templateType": "anything", "can_override": false}, "expr1": {"name": "expr1", "group": "Marking Variables", "definition": "[lhs,s_lhs]", "description": "<p>This will be used to check the steps while marking. It will be replaced with the value at the previous step.</p>", "templateType": "anything", "can_override": false}, "expr2": {"name": "expr2", "group": "Marking Variables", "definition": "[lhs,s_lhs]", "description": "<p>This will be used to check the steps while marking. It will be replaced with the value at the current step.</p>", "templateType": "anything", "can_override": false}, "p_lhs": {"name": "p_lhs", "group": "Left Hand Side", "definition": "[lhs,s_lhs]", "description": "<p>A pair containing the left hand side, both in expression and string format. This will be useful for marking, because if the students get it wrong sometimes we can try to diagnose the problem from the string (eg, missing brackets).</p>", "templateType": "anything", "can_override": false}, "p_rhs": {"name": "p_rhs", "group": "Right Hand Side", "definition": "[rhs,s_rhs]", "description": "", "templateType": "anything", "can_override": false}, "s_rhs": {"name": "s_rhs", "group": "Right Hand Side", "definition": "stringify(rhs)", "description": "<p>A string representing the right hand side using unicode characters.</p>", "templateType": "anything", "can_override": false}, "laws": {"name": "laws", "group": "Ungrouped variables", "definition": "[\"Boolean Operation\", \"Definition of \u27f9\", \"Absorption Law\", \"Associative Law\", \"Commutative Law\", \"De Morgan's Law\", \"Distributive Law\", \"Domination Law\", \"Double Negation Law\", \"Identity Law\", \"Idempotent Law\", \"Negation Law\"]", "description": "<p>List of logical laws. This is a dummy list, which will be programatically populated by the system.</p>", "templateType": "anything", "can_override": false}, "texpr1": {"name": "texpr1", "group": "Ungrouped variables", "definition": "expression(tinput1)", "description": "", "templateType": "anything", "can_override": false}, "texpr2": {"name": "texpr2", "group": "Ungrouped variables", "definition": "expression(tinput2)", "description": "", "templateType": "anything", "can_override": false}, "ft": {"name": "ft", "group": "Ungrouped variables", "definition": "html(checkstep(texpr1,texpr2,[0,0,1])[1])", "description": "", "templateType": "anything", "can_override": false}, "tinput1": {"name": "tinput1", "group": "Ungrouped variables", "definition": "\"(p \u2228 q) \u2227 p\"", "description": "", "templateType": "anything", "can_override": false}, "tinput2": {"name": "tinput2", "group": "Ungrouped variables", "definition": "\"p \u2228 q\"", "description": "", "templateType": "anything", "can_override": false}}, "variablesTest": {"condition": "length(findvars(lhs)) = length(atoms) and not (rhs in banned)", "maxRuns": "1000"}, "ungrouped_variables": ["laws", "texpr1", "texpr2", "ft", "tinput1", "tinput2"], "variable_groups": [{"name": "Left Hand Side", "variables": ["lhs", "s_lhs", "p_lhs"]}, {"name": "General Parameters", "variables": ["atoms", "nops", "qID", "countID", "countInput"]}, {"name": "Right Hand Side", "variables": ["rhs", "banned", "s_rhs", "p_rhs"]}, {"name": "Marking Variables", "variables": ["expr1", "expr2"]}, {"name": "DIsplay Variables", "variables": ["eqn", "s_eqn"]}, {"name": "Unnamed group", "variables": []}], "functions": {"checkMyStep": {"parameters": [["lhs", "expression"], ["rhs", "expression"], ["option", "list"]], "type": "boolean", "language": "javascript", "definition": "val = Numbas.extensions.propositionallogic.getFeedbackLaw(lhs,rhs,option);\nreturn val"}, "countBrackets": {"parameters": [["s", "string"]], "type": "number", "language": "javascript", "definition": "/* Count the number of (opening) brackets in an string. */\nnb = s.split('(').length - 1\nreturn nb"}, "isMissingBrackets": {"parameters": [["s", "string"]], "type": "boolean", "language": "jme", "definition": "//Compare the number of brackets in a string with the number we should expect. \n// Returns true of that number is lower as this indicates some pairs of brackets\n// may have been forgotten.\ncountBrackets(s) < countBrackets(stringify(expression(s)))"}, "log": {"parameters": [["v", "?"]], "type": "anything", "language": "javascript", "definition": "console.log(\"log:\",v)\nreturn v"}, "fixNames": {"parameters": [["ex", "expression"]], "type": "anything", "language": "jme", "definition": "substitute([\"T\":True,\"F\":False],ex)"}, "findFirstBlank": {"parameters": [["answers", "list of string"]], "type": "number", "language": "javascript", "definition": "var blank = /^\\s*$/ /* look for blank strings.*/\n//var ind = answers.findIndex(x => x.match(blank))\n\nvar TNum = Numbas.jme.types.TNum\n\nvar ind;\nfor(ind=0;ind<answers.length;ind +=1) {\n  if(answers[ind].match(blank)) break;\n}\n\nreturn ind\n\nvar inp = $(\"#\"+countID)\nconsole.log(2*inp.val()-2)\n\nreturn(ind)\nreturn min(ind,2*inp.val()-2)"}, "findBlankIndex": {"parameters": [["answers", "list of string"]], "type": "number", "language": "jme", "definition": "findFirstBlank(answers)"}, "isgapvisible": {"parameters": [["gap_number", "number"]], "type": "anything", "language": "javascript", "definition": "const countID = question.scope.variables[\"countid\"].value;\nvar inp = $(question.getPart('p0').display.html).find(\"#\"+countID)\n\nreturn 2*inp.val()-2 <= gap_number"}}, "preamble": {"js": "var TNum = Numbas.jme.types.TNum\n\nquestion.signals.on('HTMLAttached',function() {\n  /* Only show the number of steps indicated in the counter \"countID\" */\n    \n  const countID = question.scope.variables[\"countid\"].value;\n  var inp = $(question.getPart('p0').display.html).find(\"#\"+countID)\n  \n  /* Find the table containing the steps.*/\n  var table = $(question.getPart('p0').display.html).find(\"#steps\")\n  var rows = table.find(\"tr\")\n  var ngaps = rows.length-1\n  \n  /* Always show the first and last row, and only show the appropriate number of intermediate rows.*/\n  rows.slice(0,inp.val()).show()\n  rows.slice(inp.val(),ngaps).hide()  \n\n  //ngaps[\"value\"] = inp.val()\n  \n  /* Whenever the counter is changed, update the rows accordingly. */\n  inp.change(function() {\n\n    rows.slice(0,inp.val()).show();\n    rows.slice(inp.val(),ngaps).hide();\n    });\n});", "css": "table#notations {\n  width: 50%;\n}\n\n.correct-answeraa {\n  display: none;\n}\n\n.type-jmeaa .feedback-icon {\n  display: none;\n  visibility: hidden;\n}\n\n.type-jme:first-childaa .feedback-icon {\n  display: none;\n  visibility: hidden;\n}\n\n.feedbackMessageaa {\n  display: none ; \n  visibility: hidden;\n  height: 0pt;\n}\n\n.error {\n  color: #c2323f;\n  visibility: visible;\n}\n\n.warning {\n  color: #9c2089;\n  visibility: visible;\n}\n\ncol.lhs {\n  align: right;\n}\n\ncol.rhs {\n  aligh: left;\n}\n\ncol.rhs {\n  align: left;\n}\n\ntd:nth-child(2) { text-align: left; }"}, "parts": [{"type": "gapfill", "useCustomName": true, "customName": "Logical Proof", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "gap_feedback (Feedback on each of the gaps):\n    map(\n        try(\n            let(\n                isinvisible, isgapvisible(gap_number),\n                answer, studentAnswer[answer_number],\n                oldanswer,if(answer_number<2,lhs,studentAnswer[answer_number-2]),\n                finalexpr,try(expression(normalize(oldanswer)),err,lhs),\n                result, submit_part(gaps[gap_number][\"path\"],answer),\n                endtest,if(answer=\"\" or isinvisible,\n                    multiply_credit(len(gaps)/gap_number,\"Scaling the grade on the number of steps to solution.\");\n                    if(finalexpr=rhs,\n                       positive_feedback(\"Proof completed with RHS.\"),\n                       negative_feedback(\"You need to finish the proof with the right hand side.\"); multiply_credit(0.5,\"Halving the mark.\")\n                    );\n                    end(),1),\n                gap, gaps[gap_number],\n                name, gap[\"name\"],\n                noFeedbackIcon, not gap[\"settings\"][\"showFeedbackIcon\"],\n                    assert(noFeedbackIcon,\n                        assert(name=\"\" or len(gaps)=1,feedback(translate('part.gapfill.feedback header',[\"name\": name])))\n                    );\n                    concat_feedback(filter(x[\"op\"]<>\"warning\",x,result[\"feedback\"]), if(marks>0,result[\"marks\"]/marks,1/len(gaps)), noFeedbackIcon);\n                    result\n            ),\n            err,\n            fail(translate(\"part.gapfill.error marking gap\",[\"name\": gaps[gap_number][\"name\"], \"message\": err]))\n        ),\n        [gap_number,answer_number],\n        zip(gap_order,answer_order)\n    )", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacements": [], "variableReplacementStrategy": "originalfirst", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "prompt": "<!-- <p>You may copy-paste the expression in the first box, and modify it according to your first step: {s_lhs}</p> -->\n<p>Select the number of steps you need: {countInput}</p>\n<table id=\"steps\">\n<tbody>\n<tr>\n<td>LHS &equiv;</td>\n<td>{s_lhs}</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[0]]</td>\n<td>[[1]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[2]]</td>\n<td>[[3]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[4]]</td>\n<td>[[5]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[6]]</td>\n<td>[[7]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[8]]</td>\n<td>[[9]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[10]]</td>\n<td>[[11]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[12]]</td>\n<td>[[13]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[14]]</td>\n<td>[[15]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[16]]</td>\n<td>[[17]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[18]]</td>\n<td>[[19]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[20]]</td>\n<td>[[21]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[22]]</td>\n<td>[[23]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[24]]</td>\n<td>[[25]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[26]]</td>\n<td>[[27]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[28]]</td>\n<td>[[29]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[30]]</td>\n<td>[[31]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[32]]</td>\n<td>[[33]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[34]]</td>\n<td>[[35]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[36]]</td>\n<td>[[37]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>[[38]]</td>\n<td>[[39]]</td>\n</tr>\n<tr>\n<td>&equiv;</td>\n<td>RHS</td>\n</tr>\n</tbody>\n</table>\n<hr/>\n<p>You may enter the operations by copying from the following table. Either versions are fine.</p>\n<table id=\"notations\">\n<thead>\n<tr>\n<th>Operation/Value</th>\n<th>True</th>\n<th>False</th>\n<th>negation</th>\n<th>conjunction</th>\n<th>inclusive disjunction</th>\n<th>exclusive disjunction</th>\n<th>implication</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>ascii version</td>\n<td>true</td>\n<td>false</td>\n<td>not</td>\n<td>and</td>\n<td>or</td>\n<td>xor</td>\n<td>implies</td>\n</tr>\n<tr>\n<td>symbol version</td>\n<td></td>\n<td></td>\n<td>&not;</td>\n<td>&and;</td>\n<td>&or;</td>\n<td></td>\n<td>\u27f9</td>\n</tr>\n</tbody>\n</table>", "gaps": [{"type": "jme", "useCustomName": true, "customName": "Equation 1", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 1", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr2", "part": "p0g0", "must_go_first": true}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 2", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 2", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g0", "must_go_first": true}, {"variable": "expr2", "part": "p0g2", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 3", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 3", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g2", "must_go_first": true}, {"variable": "expr2", "part": "p0g4", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 4", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 4", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g4", "must_go_first": true}, {"variable": "expr2", "part": "p0g6", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 5", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 5", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g6", "must_go_first": true}, {"variable": "expr2", "part": "p0g8", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 6", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 6", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g8", "must_go_first": true}, {"variable": "expr2", "part": "p0g10", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 7", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 7", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g10", "must_go_first": true}, {"variable": "expr2", "part": "p0g12", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 8", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 8", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g12", "must_go_first": true}, {"variable": "expr2", "part": "p0g14", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 9", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 9", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g14", "must_go_first": true}, {"variable": "expr2", "part": "p0g16", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 10", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 10", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g16", "must_go_first": true}, {"variable": "expr2", "part": "p0g18", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 11", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 11", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g18", "must_go_first": true}, {"variable": "expr2", "part": "p0g20", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 12", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 12", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g20", "must_go_first": true}, {"variable": "expr2", "part": "p0g22", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 13", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 13", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g22", "must_go_first": true}, {"variable": "expr2", "part": "p0g24", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 14", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 14", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g24", "must_go_first": true}, {"variable": "expr2", "part": "p0g26", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 15", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 15", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g26", "must_go_first": true}, {"variable": "expr2", "part": "p0g28", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 16", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 16", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g28", "must_go_first": true}, {"variable": "expr2", "part": "p0g30", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 17", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 17", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g30", "must_go_first": true}, {"variable": "expr2", "part": "p0g32", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 18", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 18", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g32", "must_go_first": true}, {"variable": "expr2", "part": "p0g34", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 19", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 19", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g34", "must_go_first": true}, {"variable": "expr2", "part": "p0g36", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}, {"type": "jme", "useCustomName": true, "customName": "Equation 20", "marks": "0", "scripts": {}, "customMarkingAlgorithm": "cleanAnswer (fix the answer by replacing \"T\" and \"F\" by True and False, and square brackets with round ones.): \n    normalize(studentAnswer)\n\n\nstudentExpr (The student's answer, parsed):\n    assert(trim(studentAnswer)<>\"\",\n        warn(translate(\"part.marking.nothing entered\"));\n        fail(translate(\"part.marking.nothing entered\"))\n    );\n    try(\n        simplify(\n            expand_juxtapositions(parse(cleanAnswer), expand_juxtapositions_settings),\n            'basic'\n        )\n    , message,\n        warn(translate(\"part.jme.answer invalid\",[\"message\":message]));\n        fail(translate(\"part.jme.answer invalid\",[\"message\":message]))\n    )\n\ninterpreted_answer (The student's answer, to be reused by other parts):\n    apply(studentExpr);\n    [studentExpr, cleanAnswer]", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": false, "variableReplacements": [], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": "0", "exploreObjective": null, "answer": "{p_lhs}", "showPreview": true, "checkingType": "absdiff", "checkingAccuracy": "0.001", "failureRate": 1, "vsetRangePoints": "5", "vsetRange": ["0", "1"], "checkVariableNames": false, "singleLetterVariables": false, "allowUnknownFunctions": true, "implicitFunctionComposition": false, "caseSensitive": false, "maxlength": {"length": "0", "partialCredit": "0", "message": ""}, "minlength": {"length": "0", "partialCredit": "0", "message": ""}, "valuegenerators": []}, {"type": "1_n_2", "useCustomName": true, "customName": "Step 20", "marks": 0, "scripts": {}, "customMarkingAlgorithm": "missingBrackets:\n  countBrackets(stringify(expr2[0])) - countBrackets(expr2[1])\n\nnumTicks (How many options did the student tick?): 1\n\nscore_ticks (The score for each choice/answer pair): 1\n\nmark:\n  apply(correctStep);\n  if(correctStep[0]=1,\"\",\n  negative_feedback(correctStep[1]));\n  set_credit(correctStep[0],\"\");\n  apply(missingBrackets);\n  if(missingBrackets>0,\n     feedback(\n     \"<p class=\\\"warning\\\">You omitted some brackets around some of your operations. This can cause some issues with the order in which the operations are evaluated.</p>\"\n     ),\"\");\n  end();\n  assert(numTicks>0,\n    warn(translate(\"part.marking.nothing entered\"));\n    fail(translate(\"part.marking.nothing entered\"))\n  )\n\ncorrectStep:\n  checkMyStep(expr1[0],expr2[0],studentAnswer)", "extendBaseMarkingAlgorithm": true, "unitTests": [], "showCorrectAnswer": false, "showFeedbackIcon": true, "variableReplacements": [{"variable": "expr1", "part": "p0g36", "must_go_first": true}, {"variable": "expr2", "part": "p0g38", "must_go_first": false}], "variableReplacementStrategy": "alwaysreplace", "nextParts": [], "suggestGoingBack": false, "adaptiveMarkingPenalty": 0, "exploreObjective": null, "minMarks": 0, "maxMarks": 0, "shuffleChoices": false, "displayType": "dropdownlist", "displayColumns": 0, "showCellAnswerState": true, "choices": "{laws}", "matrix": "repeat(1.0,length(laws))"}], "sortAnswers": false}], "partsMode": "all", "maxMarks": 0, "objectives": [], "penalties": [], "objectiveVisibility": "always", "penaltyVisibility": "always", "contributors": [{"name": "Julien Ugon", "profile_url": "https://numbas.mathcentre.ac.uk/accounts/profile/3575/"}]}]}], "contributors": [{"name": "Julien Ugon", "profile_url": "https://numbas.mathcentre.ac.uk/accounts/profile/3575/"}]}