// Numbas version: exam_results_page_options
{"showstudentname": true, "metadata": {"licence": "Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International", "description": "<p>A collection of questions (frequently updated) to demonstrate the usage of the <a href=\"https://github.com/Tandethsquire/LogicNode\">Logic extension</a>.</p>\n<p>Current questions:</p>\n<ul>\n<li>Make syllogisms (either valid, invalid or valid under an additional assumption);</li>\n<li>Write statements in Polish and reverse Polish notation, find the truth table, determine satisfiability;</li>\n<li>Test whether a collection of statements $\\Gamma$ models a statement $\\phi$;</li>\n<li>Write the Disjunctive and Conjunctive Normal Forms for a statement.</li>\n</ul>\n<p><strong>Needs the Logic Extension!</strong></p>"}, "question_groups": [{"pickQuestions": 1, "name": "Group", "pickingStrategy": "all-ordered", "questions": [{"name": "Syllogisms", "extensions": ["Logic"], "custom_part_types": [], "resources": [], "navigation": {"allowregen": true, "showfrontpage": false, "preventleave": false, "typeendtoleave": false}, "contributors": [{"name": "Andrew Iskauskas", "profile_url": "https://numbas.mathcentre.ac.uk/accounts/profile/724/"}], "statement": "<p>For the following syllogisms, determine whether they are valid, invalid, or valid under an additional assumption.</p>\n<p><em>Note that a premise may, on its own, be incorrect! However, you should assume that the two premises are true to determine the validity of the syllogism.</em></p>", "ungrouped_variables": ["marking_matrix", "checkforcoverage"], "metadata": {"description": "<p>A syllogism generator. For some sets of three categories, it generates syllogisms that can be either valid, invalid, or valid under an assumption of existence.</p>\n<p><strong>Uses the \"Logic\" extension: for details see the <a href=\"https://github.com/Tandethsquire/LogicNode\">documentation</a>.</strong></p>", "licence": "Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International"}, "variables": {"true2": {"definition": "random([true,false])", "description": "<p>Determines whether the syllogism is to be true. This, along with exist2, motivates the choice of syllogism.</p>", "name": "true2", "templateType": "anything", "group": "Set 2"}, "fig3": {"definition": "random(1..4)", "description": "<p>Selects the 'figure type'. If a statement has a middle M, subject S, and predicate P, then the figures have major and minor premise</p>\n<p>Figure 1: M-P; S-M</p>\n<p>Figure 2: P-M; S-M</p>\n<p>Figure 3: M-P; M-S;</p>\n<p>Figure 4: P-M; M-S.</p>\n<p>All figures end with the conclusion S-P.</p>", "name": "fig3", "templateType": "anything", "group": "Set 3"}, "exist5": {"definition": "random([true,false])", "description": "<p>Determines whether (if the syllogism is true), it is only true under an additional existential assumption.</p>", "name": "exist5", "templateType": "anything", "group": "Set 5"}, "set4": {"definition": "[\"X\",\"Z\",\"Y\"]", "description": "<p>List of three (potentially connected) items.</p>", "name": "set4", "templateType": "anything", "group": "Set 4"}, "set2": {"definition": "[\"Martian\",\"human\",\"alien\"]", "description": "<p>List of three (potentially connected) items.</p>", "name": "set2", "templateType": "anything", "group": "Set 2"}, "true4": {"definition": "random([true,false])", "description": "<p>Determines whether the syllogism is to be true. This, along with exist4, motivates the choice of syllogism.</p>", "name": "true4", "templateType": "anything", "group": "Set 4"}, "fig2": {"definition": "random(1..4)", "description": "<p>Selects the 'figure type'. If a statement has a middle M, subject S, and predicate P, then the figures have major and minor premise</p>\n<p>Figure 1: M-P; S-M</p>\n<p>Figure 2: P-M; S-M</p>\n<p>Figure 3: M-P; M-S;</p>\n<p>Figure 4: P-M; M-S.</p>\n<p>All figures end with the conclusion S-P.</p>", "name": "fig2", "templateType": "anything", "group": "Set 2"}, "fig5": {"definition": "random(1..4)", "description": "", "name": "fig5", "templateType": "anything", "group": "Set 5"}, "set3": {"definition": "[\"cat\",\"animal\",\"mammal\"]", "description": "<p>List of three (potentially connected) items.</p>", "name": "set3", "templateType": "anything", "group": "Set 3"}, "exist2": {"definition": "random([true,false] except exist1)", "description": "<p>Determines whether (if the syllogism is true), it is only true under an additional existential assumption.</p>", "name": "exist2", "templateType": "anything", "group": "Set 2"}, "fig1": {"definition": "random(1..4)", "description": "<p>Selects the 'figure type'. If a statement has a middle M, subject S, and predicate P, then the figures have major and minor premise</p>\n<p>Figure 1: M-P; S-M</p>\n<p>Figure 2: P-M; S-M</p>\n<p>Figure 3: M-P; M-S;</p>\n<p>Figure 4: P-M; M-S.</p>\n<p>All figures end with the conclusion S-P.</p>", "name": "fig1", "templateType": "anything", "group": "Set 1"}, "set5": {"definition": "[\"Engineer\",\"Mathematician\",\"Physicist\"]", "description": "<p>List of three (potentially connected) items.</p>", "name": "set5", "templateType": "anything", "group": "Set 5"}, "exist1": {"definition": "random([true,false])", "description": "<p>Determines whether (if the syllogism is true), it is only true under an additional existential assumption.</p>", "name": "exist1", "templateType": "anything", "group": "Set 1"}, "fig6": {"definition": "random(1..4)", "description": "", "name": "fig6", "templateType": "anything", "group": "Set 6"}, "true5": {"definition": "random([true,false])", "description": "<p>Determines whether the syllogism is to be true. This, along with exist5, motivates the choice of syllogism.</p>", "name": "true5", "templateType": "anything", "group": "Set 5"}, "fig4": {"definition": "random(1..4)", "description": "<p>Selects the 'figure type'. If a statement has a middle M, subject S, and predicate P, then the figures have major and minor premise</p>\n<p>Figure 1: M-P; S-M</p>\n<p>Figure 2: P-M; S-M</p>\n<p>Figure 3: M-P; M-S;</p>\n<p>Figure 4: P-M; M-S.</p>\n<p>All figures end with the conclusion S-P.</p>", "name": "fig4", "templateType": "anything", "group": "Set 4"}, "exist4": {"definition": "random([true,false] except exist3)", "description": "<p>Determines whether (if the syllogism is true), it is only true under an additional existential assumption.</p>", "name": "exist4", "templateType": "anything", "group": "Set 4"}, "true1": {"definition": "random([true,false])", "description": "<p>Determines whether the syllogism is to be true. This, along with exist1, motivates the choice of syllogism.</p>", "name": "true1", "templateType": "anything", "group": "Set 1"}, "checkforcoverage": {"definition": "oneofeach([[true1,exist1],[true2,exist2],[true3,exist3],[true4,exist4],[true5,exist5],[true6,exist6]])", "description": "<p>Makes sure that the results contains at least one of \"True\", \"False\", and \"True under an additional assumption\". Script for oneofeach is in 'extensions and scripts'.</p>", "name": "checkforcoverage", "templateType": "anything", "group": "Ungrouped variables"}, "set1": {"definition": "[\"grommet\",\"widget\",\"gadget\"]", "description": "<p>List of three (potentially connected) items.</p>", "name": "set1", "templateType": "anything", "group": "Set 1"}, "set6": {"definition": "[\"elf\",\"orc\",\"wizard\"]", "description": "<p>List of three (potentially connected) items.</p>", "name": "set6", "templateType": "anything", "group": "Set 6"}, "exist6": {"definition": "random([true,false])", "description": "<p>Determines whether (if the syllogism is true), it is only true under an additional existential assumption.</p>", "name": "exist6", "templateType": "anything", "group": "Set 6"}, "true6": {"definition": "random([true,false])", "description": "<p>Determines whether the syllogism is to be true. This, along with exist6, motivates the choice of syllogism.</p>", "name": "true6", "templateType": "anything", "group": "Set 6"}, "exist3": {"definition": "random([true,false])", "description": "<p>Determines whether (if the syllogism is true), it is only true under an additional existential assumption.</p>", "name": "exist3", "templateType": "anything", "group": "Set 3"}, "true3": {"definition": "random([true,false])", "description": "<p>Determines whether the syllogism is to be true. This, along with exist3, motivates the choice of syllogism.</p>", "name": "true3", "templateType": "anything", "group": "Set 3"}, "marking_matrix": {"definition": "matrix([if(true1, if(exist1, [0,0,1], [1,0,0]), [0,1,0]),\n  if(true2, if(exist2, [0,0,1], [1,0,0]), [0,1,0]),\n  if(true3, if(exist3, [0,0,1], [1,0,0]), [0,1,0]),\n  if(true4, if(exist4, [0,0,1], [1,0,0]), [0,1,0]),\n  if(true5, if(exist5, [0,0,1], [1,0,0]), [0,1,0]),\n  if(true6, if(exist6, [0,0,1], [1,0,0]), [0,1,0])])", "description": "<p>Marking matrix formed from the results of true1-6 and exist1-6.</p>", "name": "marking_matrix", "templateType": "anything", "group": "Ungrouped variables"}}, "functions": {"oneofeach": {"parameters": [["arr", "list"]], "definition": "// Simple check that a set contains each of [0,i], [1,0], [1,1] (i can be 0 or 1).\nvar sometrue = false, somefalse = false, someexist = false;\nfor (i=0; i<arr.length; i++)\n{\n  if (arr[i][0]&&arr[i][1])\n    someexist = true;\n  if (arr[i][0]&&!arr[i][1])\n    sometrue = true;\n  if (!arr[i][0])\n    somefalse = true;\n}\nreturn someexist&&sometrue&&somefalse;", "language": "javascript", "type": "boolean"}}, "preamble": {"css": "", "js": ""}, "advice": "<p>We can break down any syllogism into a predicate, subject and middle: the conclusion relates the subject and the predicate. The ordering of subject, middle and predicate in the major and minor premises, and the use of \"all are...\", \"all are not...\", \"some are...\" and \"some are not...\" determines the validity.</p>\n<p>Consider the following syllogisms</p>\n<table>\n<tbody>\n<tr>\n<td style=\"text-align: left;\">\n<p><em>All mammals are animals;</em></p>\n<p><em>All cats are mammals;</em></p>\n<p><em>Therefore all cats are animals.</em></p>\n</td>\n<td style=\"text-align: left;\">\n<p><em>Some mammal is an animal;</em></p>\n<p><em>All cats are mammals;</em></p>\n<p><em>Therefore some cats are mammals.</em></p>\n</td>\n<td style=\"text-align: left;\">\n<p><em>All mammals are animals;</em></p>\n<p><em>All cats are mammals;</em></p>\n<p><em>Therefore some cat is an animal.</em></p>\n</td>\n</tr>\n</tbody>\n</table>\n<p>Let's denote by $M$, $A$ and $C$ the sets of mammals, animals and cats, respectively.</p>\n<p>The first syllogism is valid: we can see this through transitivity of equivalence: $M=C=A$. (Note that even if every set is empty, the equivalence still holds: we will see the importance of that shortly)</p>\n<p>The second syllogism is not valid: it is not necessarily true that the shared set $C \\cup M \\cup A$ is non-empty. $C$ is a subset of $M$, and some elements of $M$ must be in $A$, but those elements needn't be contained in $C$.</p>\n<p>The final syllogism is valid, but only if we&nbsp;assume the existence of cats (i.e. assume the set $C$ is non-empty). If a cat exists, then it must be an animal and therefore the syllogism holds; if no cat exists, then the conclusion (a particular cat is an animal) does not hold.</p>", "variable_groups": [{"variables": ["set1", "fig1", "true1", "exist1"], "name": "Set 1"}, {"variables": ["set2", "fig2", "true2", "exist2"], "name": "Set 2"}, {"variables": ["set3", "fig3", "true3", "exist3"], "name": "Set 3"}, {"variables": ["set4", "fig4", "true4", "exist4"], "name": "Set 4"}, {"variables": ["set5", "fig5", "true5", "exist5"], "name": "Set 5"}, {"variables": ["set6", "fig6", "true6", "exist6"], "name": "Set 6"}], "parts": [{"unitTests": [], "warningType": "none", "answers": ["<p>Valid</p>", "<p>Invalid</p>", "<p>Valid under an additional assumption</p>"], "extendBaseMarkingAlgorithm": true, "marks": 0, "variableReplacementStrategy": "originalfirst", "minMarks": 0, "showCorrectAnswer": true, "shuffleChoices": true, "showFeedbackIcon": true, "displayType": "radiogroup", "scripts": {}, "layout": {"expression": "", "type": "all"}, "customMarkingAlgorithm": "", "choices": ["<p>{syllogism({set1},{fig1},{true1},{exist1})}</p>", "<p>{syllogism({set2},{fig2},{true2},{exist2})}</p>", "<p>{syllogism({set3},{fig3},{true3},{exist3})}</p>", "<p>{syllogism({set4},{fig4},{true4},{exist4})}</p>", "<p>{syllogism({set5},{fig5},{true5},{exist5})}</p>", "<p>{syllogism({set6},{fig6},{true6},{exist6})}</p>"], "variableReplacements": [], "type": "m_n_x", "maxMarks": "6", "matrix": "marking_matrix", "minAnswers": 0, "maxAnswers": 0, "shuffleAnswers": false}], "variablesTest": {"condition": "checkforcoverage", "maxRuns": "200"}, "tags": [], "rulesets": {}, "type": "question"}, {"name": "Logical Statements and Truth Tables", "extensions": ["Logic"], "custom_part_types": [], "resources": [], "navigation": {"allowregen": true, "showfrontpage": false, "preventleave": false, "typeendtoleave": false}, "contributors": [{"name": "Andrew Iskauskas", "profile_url": "https://numbas.mathcentre.ac.uk/accounts/profile/724/"}], "rulesets": {}, "tags": [], "ungrouped_variables": [], "variablesTest": {"condition": "", "maxRuns": 100}, "preamble": {"js": "", "css": ""}, "variable_groups": [{"variables": ["noofvbls", "components", "prefix", "infix", "postfix", "truth_table", "answer_output", "taut"], "name": "Statements and Truth Tables"}], "parts": [{"unitTests": [], "variableReplacements": [], "marks": 0, "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "prompt": "<p>Write the statement in Polish notation.</p>\n<p>[[0]]</p>", "showFeedbackIcon": true, "showCorrectAnswer": true, "extendBaseMarkingAlgorithm": true, "type": "gapfill", "gaps": [{"unitTests": [], "variableReplacements": [], "marks": "2", "displayAnswer": "{prefix}", "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "matchMode": "exact", "showFeedbackIcon": true, "showCorrectAnswer": true, "extendBaseMarkingAlgorithm": true, "type": "patternmatch", "answer": "{prefix}"}], "sortAnswers": false}, {"unitTests": [], "variableReplacements": [], "marks": 0, "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "prompt": "<p>Write the statement in reverse Polish notation.</p>\n<p>[[0]]</p>", "showFeedbackIcon": true, "showCorrectAnswer": true, "extendBaseMarkingAlgorithm": true, "type": "gapfill", "gaps": [{"unitTests": [], "variableReplacements": [], "marks": "2", "displayAnswer": "{postfix}", "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "matchMode": "exact", "showFeedbackIcon": true, "showCorrectAnswer": true, "extendBaseMarkingAlgorithm": true, "type": "patternmatch", "answer": "{postfix}"}], "sortAnswers": false}, {"unitTests": [], "variableReplacements": [], "marks": 0, "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "prompt": "<p>Compute the truth table for the statement.</p>\n<table style=\"margin-left: auto; margin-right: auto; text-align: center;\" border=\"1 px black\">\n<tbody>\n<tr>\n<td><strong>P</strong></td>\n<td><strong>Q</strong></td>\n<td><strong>R</strong></td>\n<td><strong>Statement</strong></td>\n</tr>\n<tr>\n<td>1</td>\n<td>1</td>\n<td>1</td>\n<td>[[0]]</td>\n</tr>\n<tr>\n<td>1</td>\n<td>1</td>\n<td>0</td>\n<td>[[1]]</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td>[[2]]</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>0</td>\n<td>[[3]]</td>\n</tr>\n<tr>\n<td>0</td>\n<td>1</td>\n<td>1</td>\n<td>[[4]]</td>\n</tr>\n<tr>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n<td>[[5]]</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>1</td>\n<td>[[6]]</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td>[[7]]</td>\n</tr>\n</tbody>\n</table>", "showFeedbackIcon": true, "showCorrectAnswer": true, "extendBaseMarkingAlgorithm": true, "type": "gapfill", "gaps": [{"unitTests": [], "expectedVariableNames": [], "variableReplacements": [], "marks": "0.5", "failureRate": 1, "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "vsetRange": [0, 1], "showPreview": false, "showFeedbackIcon": true, "vsetRangePoints": 5, "showCorrectAnswer": true, "checkingAccuracy": 0.001, "extendBaseMarkingAlgorithm": true, "checkingType": "absdiff", "type": "jme", "checkVariableNames": false, "answer": "{answer_output[0]}"}, {"unitTests": [], "expectedVariableNames": [], "variableReplacements": [], "marks": "0.5", "failureRate": 1, "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "vsetRange": [0, 1], "showPreview": false, "showFeedbackIcon": true, "vsetRangePoints": 5, "showCorrectAnswer": true, "checkingAccuracy": 0.001, "extendBaseMarkingAlgorithm": true, "checkingType": "absdiff", "type": "jme", "checkVariableNames": false, "answer": "{answer_output[1]}"}, {"unitTests": [], "expectedVariableNames": [], "variableReplacements": [], "marks": "0.5", "failureRate": 1, "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "vsetRange": [0, 1], "showPreview": false, "showFeedbackIcon": true, "vsetRangePoints": 5, "showCorrectAnswer": true, "checkingAccuracy": 0.001, "extendBaseMarkingAlgorithm": true, "checkingType": "absdiff", "type": "jme", "checkVariableNames": false, "answer": "{answer_output[2]}"}, {"unitTests": [], "expectedVariableNames": [], "variableReplacements": [], "marks": "0.5", "failureRate": 1, "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "vsetRange": [0, 1], "showPreview": false, "showFeedbackIcon": true, "vsetRangePoints": 5, "showCorrectAnswer": true, "checkingAccuracy": 0.001, "extendBaseMarkingAlgorithm": true, "checkingType": "absdiff", "type": "jme", "checkVariableNames": false, "answer": "{answer_output[3]}"}, {"unitTests": [], "expectedVariableNames": [], "variableReplacements": [], "marks": "0.5", "failureRate": 1, "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "vsetRange": [0, 1], "showPreview": false, "showFeedbackIcon": true, "vsetRangePoints": 5, "showCorrectAnswer": true, "checkingAccuracy": 0.001, "extendBaseMarkingAlgorithm": true, "checkingType": "absdiff", "type": "jme", "checkVariableNames": false, "answer": "{answer_output[4]}"}, {"unitTests": [], "expectedVariableNames": [], "variableReplacements": [], "marks": "0.5", "failureRate": 1, "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "vsetRange": [0, 1], "showPreview": false, "showFeedbackIcon": true, "vsetRangePoints": 5, "showCorrectAnswer": true, "checkingAccuracy": 0.001, "extendBaseMarkingAlgorithm": true, "checkingType": "absdiff", "type": "jme", "checkVariableNames": false, "answer": "{answer_output[5]}"}, {"unitTests": [], "expectedVariableNames": [], "variableReplacements": [], "marks": "0.5", "failureRate": 1, "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "vsetRange": [0, 1], "showPreview": false, "showFeedbackIcon": true, "vsetRangePoints": 5, "showCorrectAnswer": true, "checkingAccuracy": 0.001, "extendBaseMarkingAlgorithm": true, "checkingType": "absdiff", "type": "jme", "checkVariableNames": false, "answer": "{answer_output[6]}"}, {"unitTests": [], "expectedVariableNames": [], "variableReplacements": [], "marks": "0.5", "failureRate": 1, "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "vsetRange": [0, 1], "showPreview": false, "showFeedbackIcon": true, "vsetRangePoints": 5, "showCorrectAnswer": true, "checkingAccuracy": 0.001, "extendBaseMarkingAlgorithm": true, "checkingType": "absdiff", "type": "jme", "checkVariableNames": false, "answer": "{answer_output[7]}"}], "sortAnswers": false}, {"unitTests": [], "minMarks": 0, "variableReplacements": [], "marks": 0, "matrix": "{taut}", "variableReplacementStrategy": "originalfirst", "scripts": {}, "customMarkingAlgorithm": "", "maxMarks": 0, "choices": ["<p>A tautology?</p>", "<p>Satisfiable?</p>", "<p>Contradictory?</p>"], "prompt": "<p>Is the statement:</p>\n<p></p>", "shuffleChoices": false, "showFeedbackIcon": true, "showCorrectAnswer": true, "extendBaseMarkingAlgorithm": true, "type": "1_n_2", "displayType": "radiogroup", "displayColumns": 0}], "statement": "<p>Consider the following statement:</p>\n<p>{texify({infix},true)}</p>\n<p><em>N.B. In subsequent answers, you should write your statements as a descriptive string, with components separated by a space. For example, the&nbsp;statement&nbsp;$\\rightarrow P \\vee Q \\neg \\wedge R S$ would be entered as IMPLIES P OR Q NOT AND R S.</em></p>", "advice": "<p>One can draw the parse tree for the statement: with the parse tree in hand, it is relatively straightforward to generate the Polish and reverse Polish notation statements.</p>\n<p>The truth table is simply a matter of evaluating the statement for all possible truth values of the arguments. Don't forget that $P\\rightarrow Q$ is equivalent to $(\\neg P)\\vee Q$.</p>\n<p>Recall that a statement is</p>\n<ul>\n<li>Tautological if the statement is true for all valuations;</li>\n<li>Satisfiable if the statement is true for at least one valuation;</li>\n<li>Contradictory if the statement is false for all valuations.</li>\n</ul>", "variables": {"noofvbls": {"templateType": "anything", "description": "<p>Determines how many different propositions are to be in the statement. noofvbls=3 gives a statement in P,Q,R; noofvbls=4 would give a statement in P,Q,R,S.</p>", "group": "Statements and Truth Tables", "name": "noofvbls", "definition": "3"}, "infix": {"templateType": "anything", "description": "<p>The statement in standard form.</p>", "group": "Statements and Truth Tables", "name": "infix", "definition": "string_from_tree(components,\"in\")"}, "taut": {"templateType": "anything", "description": "<p>A marking matrix for the final part: checking whether the statement is tautological (true for all valuations), satisfiable (true for some valuations), or contradictory (true for none).</p>", "group": "Statements and Truth Tables", "name": "taut", "definition": "if(sum(answer_output)=8,[2,0,0],if(sum(answer_output)=0,[0,0,2],[0,2,0]))"}, "components": {"templateType": "anything", "description": "<p>A list of parts of the statement. A component can be a proposition P,Q,R,S..., a binary operator AND, OR, IMPLIES, or the unary operator NOT. For details of how the components are ordered, see the Logic.js documentation.</p>", "group": "Statements and Truth Tables", "name": "components", "definition": "make_components(noofvbls*2,noofvbls,floor(noofvbls/2))"}, "prefix": {"templateType": "anything", "description": "<p>The statement in prefix (Polish) form.</p>", "group": "Statements and Truth Tables", "name": "prefix", "definition": "string_from_tree(components,\"pre\")"}, "postfix": {"templateType": "anything", "description": "<p>The statement in postfix (reverse Polish) form.</p>", "group": "Statements and Truth Tables", "name": "postfix", "definition": "string_from_tree(components,\"post\")"}, "truth_table": {"templateType": "anything", "description": "<p>Generated truth table from the statement: for details of the computation, see the Logic.js docs.</p>", "group": "Statements and Truth Tables", "name": "truth_table", "definition": "truth_table_results(components,3)"}, "answer_output": {"templateType": "anything", "description": "<p>A dirty fix to ensure that the truth table results are in [0,1] form, rather than [true,false].</p>", "group": "Statements and Truth Tables", "name": "answer_output", "definition": "map(if(truth_table[n],1,0),n,0..length(truth_table)-1)"}}, "functions": {}, "metadata": {"description": "<p>Gives a statement in standard notation: students must write it in Polish and reverse Polish notation, construct the truth table, and determine whether it is tautological, satisfiable, or contradictory.</p>\n<p><strong>Uses the \"Logic\" extension: for details see the <a href=\"https://github.com/Tandethsquire/LogicNode\">documentation</a>.</strong></p>", "licence": "Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International"}, "type": "question"}, {"name": "Equivalence", "extensions": ["Logic"], "custom_part_types": [], "resources": [], "navigation": {"allowregen": true, "showfrontpage": false, "preventleave": false, "typeendtoleave": false}, "contributors": [{"name": "Andrew Iskauskas", "profile_url": "https://numbas.mathcentre.ac.uk/accounts/profile/724/"}], "parts": [{"prompt": "<p>$\\Gamma$: $\\{$ {formula_tex} $\\}$</p>\n<p>$\\phi$: {texify({statement},false)}</p>\n<p>Variables: $[P,Q,R,S]$</p>\n<p></p>", "checkingAccuracy": 0.001, "vsetRange": [0, 1], "variableReplacements": [], "customMarkingAlgorithm": "", "marks": "4", "answer": "{cEx[0]}", "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacementStrategy": "originalfirst", "showPreview": true, "checkingType": "absdiff", "scripts": {"mark": {"order": "instead", "script": "/* Ideally, this would all be converted to a marking algorithm in the style of the Numbas 3.0 update */\n\n// Compare two arrays and return the number of matching elements.\nfunction howManyMatch(arr1,arr2)\n{\n   if (arr1.length!=arr2.length)\n      return 0;\n   var tot = 0;\n   for (i=0; i<arr1.length; i++)\n   {\n     if (arr1[i]==arr2[i])\n       tot++;\n   }\n   return tot;\n}\n\n  var variables = this.question.scope.variables;\n  var unwrap = Numbas.jme.unwrapValue;\n  var sA = this.studentAnswer;\n  // Gets the elements of the student's array, and calculates a score.\n  sA = sA.slice(1,-1).split(\",\");\n  var testarr = unwrap(variables.cex);\n  var bestCred = 0;\n  for (j=0; j<testarr.length; j++)\n  {\n     if (howManyMatch(testarr[j],sA)>bestCred)\n       bestCred = howManyMatch(testarr[j],sA);\n  }\n  this.setCredit(bestCred/4);\n\nthis.answered = true;"}}, "vsetRangePoints": 5, "extendBaseMarkingAlgorithm": true, "type": "jme", "unitTests": [], "expectedVariableNames": [], "checkVariableNames": false, "failureRate": 1}, {"prompt": "<p>$\\Gamma$: $\\{$ {formula_tex2} $\\}$</p>\n<p>$\\phi$: {texify({statement2},false)}</p>\n<p>Variables: $[P,Q,R,S,T]$</p>\n<p></p>", "checkingAccuracy": 0.001, "vsetRange": [0, 1], "variableReplacements": [], "customMarkingAlgorithm": "", "marks": "5", "answer": "{cEx2[0]}", "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacementStrategy": "originalfirst", "showPreview": true, "checkingType": "absdiff", "scripts": {"mark": {"order": "instead", "script": "// As in Part a).\n\nfunction howManyMatch(arr1,arr2)\n{\n   if (arr1.length!=arr2.length)\n      return 0;\n   var tot = 0;\n   for (i=0; i<arr1.length; i++)\n   {\n     if (arr1[i]==arr2[i])\n       tot++;\n   }\n   return tot;\n}\n\n  var variables = this.question.scope.variables;\n  var unwrap = Numbas.jme.unwrapValue;\n  var sA = this.studentAnswer;\n  sA = sA.slice(1,-1).split(\",\");\n  var testarr = unwrap(variables.cex2);\n  var bestCred = 0;\n  for (j=0; j<testarr.length; j++)\n  {\n     if (howManyMatch(testarr[j],sA)>bestCred)\n       bestCred = howManyMatch(testarr[j],sA);\n  }\n  this.setCredit(bestCred/5);\n\nthis.answered = true;"}}, "vsetRangePoints": 5, "extendBaseMarkingAlgorithm": true, "type": "jme", "unitTests": [], "expectedVariableNames": [], "checkVariableNames": false, "failureRate": 1}], "rulesets": {}, "variablesTest": {"maxRuns": "150", "condition": "length(formula_set)>=2 and length(formula_set2)>=2 and not(statement in formula_set) and not (statement2 in formula_set2) and not (length(cList)=0 and length(cList2)=0)"}, "metadata": {"description": "<p>Two questions on checking equivalence between a model and a statement. At least one of the two parts is guaranteed to admit a non-trivial solution (that is, actually have an instance where $\\Gamma$ holds and $\\phi$ doesn't.</p>\n<p><strong>Uses the \"Logic\" extension: for details see the <a href=\"https://github.com/Tandethsquire/LogicNode\">documentation</a>.</strong></p>", "licence": "Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International"}, "tags": [], "statement": "<p>For each of the following sets of formulae $\\Gamma$ and statement $\\phi$, determine whether $\\Gamma\\models\\phi$. If it does not, give an example of values for the variables for which the equivalence fails. If $\\Gamma\\models\\phi$, then enter&nbsp;'1'&nbsp;as a value&nbsp;for all variables.</p>\n<p><em>Enter your solution as an array of values: for example, if a counterexample is $v(P)=T,\\,v(Q)=F,\\,v(R)=T$, then your answer would be $[1,0,1]$.</em></p>", "functions": {"cleanup": {"type": "string", "definition": "// Simple function to replace IMPLIES in a statement, for valuation.\n// Note that this only works because IMPLIES only occurs in statements of the form \"P IMPLIES Q\"\n// More complicated statements (eg \"P IMPLIES (Q OR R)\") would not behave as expected.\nreturn statement.replace(/\\((.) IMPLIES (.)\\)/g,\"((NOT \"+'$1'+\") OR \"+'$2)');", "parameters": [["statement", "string"]], "language": "javascript"}}, "ungrouped_variables": [], "advice": "<p>Recall that a set of statements $\\Gamma$&nbsp;<em>models&nbsp;</em>a proposition $\\phi$ if the satisfaction of $\\Gamma$ implies the satisfaction of $\\phi$. Therefore, the easiest way to check such a system is to find any valuation in which $\\phi$ fails to hold, but $\\Gamma$ can be seen to be true.</p>\n<p>Consider $\\Gamma=\\{R\\vee P,\\,Q\\rightarrow R\\}$ and $\\phi=P\\wedge R$. Then we can see that $\\phi$ will be false if $P$ or $R$ are false. Since $\\Gamma$ contains $P\\vee R$, we need at least one to be true: taking $P=1,\\,Q=0$ and $R=0$ allows $\\Gamma$ to hold but $P\\wedge R$ to be false. The valuation is often not unique: if we instead took $P=0$, $R=1$ and then $Q$ could take either value.</p>", "variables": {"cList": {"definition": "filter((formula_output[x]=true and statement_output[x]=false),x,0..length(formula_output)-1)", "description": "<p>A list of indices for which gamma holds but the statement fails. The 'index' n is equivalent to a binary expression of 15-n, which gives a valuation of the variables.</p>", "templateType": "anything", "group": "Part 1", "name": "cList"}, "formula_statement": {"definition": "join(formula_set,\" AND \")", "description": "<p>A 'machine readable' version of gamma.</p>", "templateType": "anything", "group": "Part 1", "name": "formula_statement"}, "formula_statement2": {"definition": "join(formula_set2,\" AND \")", "description": "<p>A 'machine readable' version of gamma.</p>", "templateType": "anything", "group": "Part 2", "name": "formula_statement2"}, "formula_size": {"definition": "random(2..4)", "description": "<p>The number of statements in the formula, gamma.</p>", "templateType": "anything", "group": "Part 1", "name": "formula_size"}, "formula_set": {"definition": "distinct(make_model(formula_size,noofvbls))", "description": "<p>Generated list of statements in gamma.</p>", "templateType": "anything", "group": "Part 1", "name": "formula_set"}, "formula_output2": {"definition": "truth_table_results(cleanup(formula_statement2),noofvbls2)", "description": "<p>The truth table for the formula.</p>", "templateType": "anything", "group": "Part 2", "name": "formula_output2"}, "formula_size2": {"definition": "random(2..5)", "description": "<p>The number of statements in the formula, gamma.</p>", "templateType": "anything", "group": "Part 2", "name": "formula_size2"}, "formula_tex2": {"definition": "texify(join(formula_set2,\", \"),false)", "description": "<p>A version of gamma for display.</p>", "templateType": "anything", "group": "Part 2", "name": "formula_tex2"}, "noofvbls": {"definition": "4", "description": "<p>How many propositions are in the sets of statements: eg noofvbls=3 gives P,Q,R; noofvbls=4 gives P,Q,R,S.</p>", "templateType": "anything", "group": "Part 1", "name": "noofvbls"}, "formula_output": {"definition": "truth_table_results(cleanup(formula_statement),noofvbls)", "description": "<p>The truth table for the formula gamma.</p>", "templateType": "anything", "group": "Part 1", "name": "formula_output"}, "statement": {"definition": "make_model(1,noofvbls)[0]", "description": "<p>The statement with which to compare equivalence.</p>", "templateType": "anything", "group": "Part 1", "name": "statement"}, "formula_set2": {"definition": "make_model(formula_size2,noofvbls2)", "description": "<p>Generated list of statements in gamma.</p>", "templateType": "anything", "group": "Part 2", "name": "formula_set2"}, "cEx2": {"definition": "if(length(cList2)=0,[[1,1,1,1,1]],map(int_to_binary_array(31-cList2[n],5),n,0..length(cList2)-1))", "description": "<p>The result: if cList is empty, then the model is valid (and thus it returns [1,1,1,1,1]). If not, then this is a list of valuations for which the model fails</p>", "templateType": "anything", "group": "Part 2", "name": "cEx2"}, "statement_output": {"definition": "truth_table_results(cleanup(statement),noofvbls)", "description": "<p>The truth table for the statement</p>", "templateType": "anything", "group": "Part 1", "name": "statement_output"}, "noofvbls2": {"definition": "5", "description": "<p>How many propositions are in the sets of statements: eg noofvbls2=3 gives P,Q,R; noofvbls2=4 gives P,Q,R,S.</p>", "templateType": "anything", "group": "Part 2", "name": "noofvbls2"}, "statement2": {"definition": "make_model(1,noofvbls2)[0]", "description": "<p>The statement with which to compare equivalence.</p>", "templateType": "anything", "group": "Part 2", "name": "statement2"}, "cList2": {"definition": "filter((formula_output2[x] and not statement_output2[x]),x,0..length(formula_output2)-1)", "description": "<p>A list of indices for which gamma holds but the statement fails. The 'index' n is equivalent to a binary expression of 31-n, which gives a valuation of the variables.</p>", "templateType": "anything", "group": "Part 2", "name": "cList2"}, "statement_output2": {"definition": "truth_table_results(cleanup(statement2),noofvbls2)", "description": "<p>The truth table for the statement.</p>", "templateType": "anything", "group": "Part 2", "name": "statement_output2"}, "cEx": {"definition": "if(length(cList)=0,[[1,1,1,1]],map(int_to_binary_array(15-cList[n],4),n,0..length(cList)-1))", "description": "<p>The result: if cList is empty, then the model is valid (and thus it returns [1,1,1,1]). If not, then this is a list of valuations for which the model fails.</p>", "templateType": "anything", "group": "Part 1", "name": "cEx"}, "formula_tex": {"definition": "texify(join(formula_set,\", \"),false)", "description": "<p>A version of gamma for display.</p>", "templateType": "anything", "group": "Part 1", "name": "formula_tex"}}, "variable_groups": [{"variables": ["formula_size", "noofvbls", "formula_set", "statement", "formula_tex", "formula_statement", "formula_output", "statement_output", "cList", "cEx"], "name": "Part 1"}, {"variables": ["formula_size2", "noofvbls2", "formula_set2", "statement2", "formula_tex2", "formula_statement2", "formula_output2", "statement_output2", "cList2", "cEx2"], "name": "Part 2"}], "preamble": {"js": "", "css": ""}, "type": "question"}, {"name": "Disjunctive and Conjunctive Normal Forms", "extensions": ["Logic"], "custom_part_types": [], "resources": [], "navigation": {"allowregen": true, "showfrontpage": false, "preventleave": false, "typeendtoleave": false}, "contributors": [{"name": "Andrew Iskauskas", "profile_url": "https://numbas.mathcentre.ac.uk/accounts/profile/724/"}], "parts": [{"prompt": "<p>{texify({statement},true)}</p>\n<p>Disjunctive Normal Form: [[0]]</p>\n<p>Conjunctive Normal Form: [[1]]</p>", "variableReplacements": [], "customMarkingAlgorithm": "", "marks": 0, "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacementStrategy": "originalfirst", "scripts": {}, "extendBaseMarkingAlgorithm": true, "type": "gapfill", "unitTests": [], "gaps": [{"variableReplacements": [], "customMarkingAlgorithm": "", "marks": "2", "answer": "(?:\\((?:(?:NOT .|.) AND )+(?:NOT .|.)\\)(?:\\s*OR\\s*\\((?:(?:NOT .|.) AND )+(?:NOT .|.)\\))*|(?:(?:(?:NOT .|.) AND )+(?:NOT .|.))|(?:NOT .|.))", "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacementStrategy": "originalfirst", "matchMode": "regex", "displayAnswer": "{dnf1}", "scripts": {"mark": {"order": "after", "script": "/*\nThis should really be converted into marking algorithm code, a la Numbas v3.0\n*/\n\n// Checks whether two arrays are the same.\nfunction sameArr(arr1,arr2)\n{\n if (arr1.length!=arr2.length)\n {\n   return false;\n }\n for (i=0; i<arr1.length; i++)\n {\n   if (arr1[i]!=arr2[i])\n     return false;\n }\n return true;\n}\n\n// Checks whether the answer matches the requisite pattern and, if it does,\n// checks whether the answer has the same truth table as the original statement.\nvar cred = this.credit;\nvar feed = [];\nif (this.credit != 1)\n  feed.push(\"Your answer is not in Disjunctive Normal Form.\");\nelse\n{\n  cred = 2;\n  feed.push(\"Your answer is in Disjunctive Normal Form.\");\n  var sA = this.studentAnswer;\n  var vars = this.question.scope.variables;\n  var truths = Numbas.jme.unwrapValue(vars.conversion);\n  var sTruths = truth_table(sA,3);\n\n  if (!sameArr(truths,sTruths))\n  {\n    cred-=0.5;\n    feed.push(\"Your statement is not equivalent to the original one.\");\n  }\n}\nthis.setCredit(cred,feed);"}}, "extendBaseMarkingAlgorithm": true, "type": "patternmatch", "unitTests": []}, {"variableReplacements": [], "customMarkingAlgorithm": "", "marks": "2", "answer": "(?:\\((?:(?:NOT .|.) OR )+(?:NOT .|.)\\)(?:\\s*AND\\s*\\((?:(?:NOT .|.) OR )+(?:NOT .|.)\\))*|(?:(?:(?:NOT .|.) OR )+(?:NOT .|.))|(?:NOT .|.))", "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacementStrategy": "originalfirst", "matchMode": "regex", "displayAnswer": "{cnf1}", "scripts": {"mark": {"order": "after", "script": "/*\nThis should really be converted into marking algorithm code, a la Numbas v3.0\n*/\n\n// Checks whether two arrays are the same.\nfunction sameArr(arr1,arr2)\n{\n if (arr1.length!=arr2.length)\n {\n   return false;\n }\n for (i=0; i<arr1.length; i++)\n {\n   if (arr1[i]!=arr2[i])\n     return false;\n }\n return true;\n}\n\n// Checks whether the answer matches the requisite pattern and, if it does,\n// checks whether the answer has the same truth table as the original statement.\nvar cred = this.credit;\nvar feed = [];\nif (this.credit != 1)\n  feed.push(\"Your answer is not in Conjunctive Normal Form.\");\nelse\n{\n  cred = 2;\n  feed.push(\"Your answer is in Conjunctive Normal Form.\\n\");\n  var sA = this.studentAnswer;\n  var vars = this.question.scope.variables;\n  var truths = Numbas.jme.unwrapValue(vars.conversion);\n  var sTruths = truth_table(sA,3);\n\n  if (!sameArr(truths,sTruths))\n  {\n    cred-=0.5;\n    feed.push(\"Your statement is not equivalent to the original one.\");\n  }\n}\nthis.setCredit(cred,feed);"}}, "extendBaseMarkingAlgorithm": true, "type": "patternmatch", "unitTests": []}], "sortAnswers": false}, {"prompt": "<p>{texify({statement2},true)}</p>\n<p>Disjunctive Normal Form: [[0]]</p>\n<p>Conjunctive Normal Form: [[1]]</p>", "variableReplacements": [], "customMarkingAlgorithm": "", "marks": 0, "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacementStrategy": "originalfirst", "scripts": {}, "extendBaseMarkingAlgorithm": true, "type": "gapfill", "unitTests": [], "gaps": [{"variableReplacements": [], "customMarkingAlgorithm": "", "marks": "2", "answer": "(?:\\((?:(?:NOT .|.) AND )+(?:NOT .|.)\\)(?:\\s*OR\\s*\\((?:(?:NOT .|.) AND )+(?:NOT .|.)\\))*|(?:(?:(?:NOT .|.) AND )+(?:NOT .|.))|(?:NOT .|.))", "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacementStrategy": "originalfirst", "matchMode": "regex", "displayAnswer": "{dnf2}", "scripts": {"mark": {"order": "after", "script": "// As in Part a)\nfunction sameArr(arr1,arr2)\n{\n if (arr1.length!=arr2.length)\n {\n   return false;\n }\n for (i=0; i<arr1.length; i++)\n {\n   if (arr1[i]!=arr2[i])\n     return false;\n }\n return true;\n}\n\nvar cred = this.credit;\nvar feed = [];\nif (this.credit != 1)\n  feed.push(\"Your answer is not in Disjunctive Normal Form.\");\nelse\n{\n  cred = 2;\n  feed.push(\"Your answer is in Disjunctive Normal Form.\");\n  var sA = this.studentAnswer;\n  var vars = this.question.scope.variables;\n  var truths = Numbas.jme.unwrapValue(vars.conversion2);\n  var sTruths = truth_table(sA,2);\n\n  if (!sameArr(truths,sTruths))\n  {\n    cred-=0.5;\n    feed.push(\"Your statement is not equivalent to the original one.\");\n  }\n}\nthis.setCredit(cred,feed);"}}, "extendBaseMarkingAlgorithm": true, "type": "patternmatch", "unitTests": []}, {"variableReplacements": [], "customMarkingAlgorithm": "", "marks": "2", "answer": "(?:\\((?:(?:NOT .|.) OR )+(?:NOT .|.)\\)(?:\\s*AND\\s*\\((?:(?:NOT .|.) OR )+(?:NOT .|.)\\))*|(?:(?:(?:NOT .|.) OR )+(?:NOT .|.))|(?:NOT .|.))", "showCorrectAnswer": true, "showFeedbackIcon": true, "variableReplacementStrategy": "originalfirst", "matchMode": "regex", "displayAnswer": "{cnf2}", "scripts": {"mark": {"order": "after", "script": "// As in part a).\nfunction sameArr(arr1,arr2)\n{\n if (arr1.length!=arr2.length)\n {\n   return false;\n }\n for (i=0; i<arr1.length; i++)\n {\n   if (arr1[i]!=arr2[i])\n     return false;\n }\n return true;\n}\n\nvar cred = this.credit;\nvar feed = [];\nif (this.credit != 1)\n  feed.push(\"Your answer is not in Conjunctive Normal Form.\");\nelse\n{\n  cred = 2;\n  feed.push(\"Your answer is in Conjunctive Normal Form.\");\n  var sA = this.studentAnswer;\n  var vars = this.question.scope.variables;\n  var truths = Numbas.jme.unwrapValue(vars.conversion2);\n  var sTruths = truth_table(sA,2);\n\n  if (!sameArr(truths,sTruths))\n  {\n    cred-=0.5;\n    feed.push(\"Your statement is not equivalent to the original one.\");\n  }\n}\nthis.setCredit(cred,feed);"}}, "extendBaseMarkingAlgorithm": true, "type": "patternmatch", "unitTests": []}], "sortAnswers": false}], "rulesets": {}, "variablesTest": {"maxRuns": 100, "condition": "not (sum(conversion)=0 or sum(conversion)=length(conversion)) and not (sum(conversion2)=0 or sum(conversion2)=length(conversion2))"}, "metadata": {"description": "<p>Generate Disjunctive Normal Form and Conjunctive Normal Form for logical statements.</p>\n<p><strong>Uses the \"Logic\" extension: for details see the <a href=\"https://github.com/Tandethsquire/LogicNode\">documentation</a>.</strong></p>", "licence": "Creative Commons Attribution-ShareAlike 4.0 International"}, "tags": [], "statement": "<p>Give the following statements in Disjunctive Normal Form (DNF) and Conjunctive Normal Form (CNF).</p>\n<p><em>N.B. In subsequent answers, you should write your statements as a descriptive string, with components separated by a space. For example, the&nbsp;statement&nbsp;$(P \\vee Q \\wedge \\neg R) \\wedge (R \\vee P)$ would be entered as (P OR Q AND NOT R) AND (R OR P).</em></p>", "functions": {}, "ungrouped_variables": [], "advice": "<p>Suppose the statement was $(P \\vee \\neg Q)\\rightarrow (\\neg Q \\wedge \\neg P)$. The first step would be to generate the truth table for this statement: we can see that this will be</p>\n<table align=\"center\">\n<tbody>\n<tr>\n<td style=\"text-align: center;\"><strong>P</strong></td>\n<td style=\"text-align: center;\"><strong>Q</strong></td>\n<td style=\"text-align: center;\"><strong>Statement</strong></td>\n</tr>\n<tr>\n<td style=\"text-align: center;\"><strong></strong>1</td>\n<td style=\"text-align: center;\">1</td>\n<td style=\"text-align: center;\">0</td>\n</tr>\n<tr>\n<td style=\"text-align: center;\">1</td>\n<td style=\"text-align: center;\"><strong></strong>0</td>\n<td style=\"text-align: center;\">0</td>\n</tr>\n<tr>\n<td style=\"text-align: center;\">0</td>\n<td style=\"text-align: center;\">1</td>\n<td style=\"text-align: center;\">1</td>\n</tr>\n<tr>\n<td style=\"text-align: center;\">0</td>\n<td style=\"text-align: center;\">0</td>\n<td style=\"text-align: center;\">1</td>\n</tr>\n</tbody>\n</table>\n<p>To obtain the disjunctive normal form (DNF), we take the union of any valuations of $P$ and $Q$ that make the statement true. In this case,&nbsp;working down the rows of the truth table give</p>\n<p>$(\\neg P \\wedge Q)\\vee(\\neg P \\wedge \\neg Q).$</p>\n<p>The conjunctive normal form is given by the negation of the DNF of the negation of the statement: the cases for which the statement fails are $( P \\wedge Q)\\vee(P \\wedge \\neg Q)$. So negating this gives</p>\n<p>$\\neg((P \\wedge Q)\\vee(P \\wedge \\neg Q))=(\\neg P\\vee \\neg Q)\\wedge(\\neg P \\vee Q),$</p>\n<p>which is the CNF for the statement.</p>\n<p>Note that this method needn't give the simplest result: from inspecting the table the statement is equivalent to $\\neg P$, which is in DNF and CNF already!</p>", "variables": {"dnf2": {"definition": "normal_form(truth_table2,2,true)", "description": "<p>A&nbsp;disjunctive normal form for the statement. Not necessarily the most efficient; only used for answer display purposes.</p>", "templateType": "anything", "group": "Statement 2", "name": "dnf2"}, "cnf2": {"definition": "normal_form(truth_table2,2,false)", "description": "<p>A&nbsp;conjunctive normal form for the statement. Not necessarily the most efficient; only used for answer display purposes.</p>", "templateType": "anything", "group": "Statement 2", "name": "cnf2"}, "truth_table": {"definition": "truth_table_results(components,3)", "description": "<p>The truth table for the statement.</p>", "templateType": "anything", "group": "Statement 1", "name": "truth_table"}, "truth_table2": {"definition": "truth_table_results(components2,2)", "description": "<p>The truth table for the statement.</p>", "templateType": "anything", "group": "Statement 2", "name": "truth_table2"}, "statement": {"definition": "string_from_tree(components, \"in\")", "description": "<p>The components reexpressed in infix (standard) form.</p>", "templateType": "anything", "group": "Statement 1", "name": "statement"}, "components": {"definition": "make_components(5,3,2)", "description": "<p>Creates a list of components for the statement: for details on this, see the Logic.js docs.</p>", "templateType": "anything", "group": "Statement 1", "name": "components"}, "cnf1": {"definition": "normal_form(truth_table,3,false)", "description": "<p>A&nbsp;conjunctive normal form for the statement. Not necessarily the most efficient; only used for answer display purposes.</p>", "templateType": "anything", "group": "Statement 1", "name": "cnf1"}, "conversion2": {"definition": "map(if(truth_table2[n] = true, 1, 0), n, 0..length(truth_table2)-1)", "description": "<p>Quick-and-dirty way to ensure that the truth table output has elements [1,0], rather than [true, false].</p>", "templateType": "anything", "group": "Statement 2", "name": "conversion2"}, "statement2": {"definition": "string_from_tree(components2,\"in\")", "description": "<p>The components reexpressed in infix (standard) form.</p>", "templateType": "anything", "group": "Statement 2", "name": "statement2"}, "dnf1": {"definition": "normal_form(truth_table,3,true)", "description": "<p>A&nbsp;disjunctive normal form for the statement. Not necessarily the most efficient; only used for answer display purposes.</p>", "templateType": "anything", "group": "Statement 1", "name": "dnf1"}, "components2": {"definition": "make_components(3,2,2)", "description": "<p>Creates a list of components for the statement: for details on this, see the Logic.js docs.</p>", "templateType": "anything", "group": "Statement 2", "name": "components2"}, "conversion": {"definition": "map(if(truth_table[n]=true,1,0),n,0..length(truth_table)-1)", "description": "<p>Quick-and-dirty way to ensure that the truth table output has elements [1,0], rather than [true, false].</p>", "templateType": "anything", "group": "Statement 1", "name": "conversion"}}, "variable_groups": [{"variables": ["components", "statement", "truth_table", "conversion", "dnf1", "cnf1"], "name": "Statement 1"}, {"variables": ["components2", "statement2", "truth_table2", "conversion2", "dnf2", "cnf2"], "name": "Statement 2"}], "preamble": {"js": "", "css": ""}, "type": "question"}, {"name": "Propositional Formulae", "extensions": ["Logic"], "custom_part_types": [], "resources": [], "navigation": {"allowregen": true, "showfrontpage": false, "preventleave": false, "typeendtoleave": false}, "contributors": [{"name": "Andrew Iskauskas", "profile_url": "https://numbas.mathcentre.ac.uk/accounts/profile/724/"}, {"name": "Alexander Hague", "profile_url": "https://numbas.mathcentre.ac.uk/accounts/profile/2654/"}], "variable_groups": [{"variables": ["TT1", "dnf1", "cnf1", "output1"], "name": "(a)"}, {"variables": ["TT2", "dnf2", "cnf2", "output2"], "name": "(b)"}, {"variables": ["TT3", "dnf3", "cnf3", "output3"], "name": "(c)"}, {"variables": ["TT4", "dnf4", "cnf4", "output4"], "name": "(d)"}], "parts": [{"answer": ".*", "matchMode": "regex", "unitTests": [], "showFeedbackIcon": true, "showCorrectAnswer": true, "scripts": {"mark": {"order": "instead", "script": "/*\nShould be converted to marking algorithm, a la Numbas v3.0\n*/\n\n// Checks whether two arrays are the same.\nfunction sameArr(arr1,arr2)\n{\n if (arr1.length!=arr2.length)\n {\n   return false;\n }\n for (i=0; i<arr1.length; i++)\n {\n   if (arr1[i]!=arr2[i])\n     return false;\n }\n return true;\n}\n\n// Compares TT1 and the truth table of the student answer, awarding credit accordingly.\nvar sA = this.studentAnswer;\nvar vars = this.question.scope.variables;\nvar truths = Numbas.jme.unwrapValue(vars.tt1);\nvar sTruths = truth_table(sA,3);\n\nif (!sameArr(truths,sTruths))\n  this.setCredit(0,\"Your statement does not generate the truth table.\");\nelse\n  this.setCredit(1,\"Your statement is correct.\");\nthis.answered = true;"}}, "displayAnswer": "{output1}", "marks": 1, "variableReplacementStrategy": "originalfirst", "type": "patternmatch", "customMarkingAlgorithm": "", "extendBaseMarkingAlgorithm": true, "variableReplacements": []}, {"answer": ".*", "matchMode": "regex", "unitTests": [], "showFeedbackIcon": true, "showCorrectAnswer": true, "scripts": {"mark": {"order": "instead", "script": "// As in Part a).\nfunction sameArr(arr1,arr2)\n{\n if (arr1.length!=arr2.length)\n {\n   return false;\n }\n for (i=0; i<arr1.length; i++)\n {\n   if (arr1[i]!=arr2[i])\n     return false;\n }\n return true;\n}\n\nvar sA = this.studentAnswer;\nvar vars = this.question.scope.variables;\nvar truths = Numbas.jme.unwrapValue(vars.tt2);\nvar sTruths = truth_table(sA,3);\n\nif (!sameArr(truths,sTruths))\n  this.setCredit(0,\"Your statement does not generate the truth table.\");\nelse\n  this.setCredit(1,\"Your statement is correct.\");\nthis.answered = true;"}}, "displayAnswer": "{output2}", "marks": 1, "variableReplacementStrategy": "originalfirst", "type": "patternmatch", "customMarkingAlgorithm": "", "extendBaseMarkingAlgorithm": true, "variableReplacements": []}, {"answer": ".*", "matchMode": "regex", "unitTests": [], "showFeedbackIcon": true, "showCorrectAnswer": true, "scripts": {"mark": {"order": "instead", "script": "// As in part a).\nfunction sameArr(arr1,arr2)\n{\n if (arr1.length!=arr2.length)\n {\n   return false;\n }\n for (i=0; i<arr1.length; i++)\n {\n   if (arr1[i]!=arr2[i])\n     return false;\n }\n return true;\n}\n\nvar sA = this.studentAnswer;\nvar vars = this.question.scope.variables;\nvar truths = Numbas.jme.unwrapValue(vars.tt3);\nvar sTruths = truth_table(sA,3);\n\nif (!sameArr(truths,sTruths))\n  this.setCredit(0,\"Your statement does not generate the truth table.\");\nelse\n  this.setCredit(1,\"Your statement is correct.\");\nthis.answered = true;"}}, "displayAnswer": "{output3}", "marks": 1, "variableReplacementStrategy": "originalfirst", "type": "patternmatch", "customMarkingAlgorithm": "", "extendBaseMarkingAlgorithm": true, "variableReplacements": []}, {"answer": ".*", "matchMode": "regex", "unitTests": [], "showFeedbackIcon": true, "showCorrectAnswer": true, "scripts": {"mark": {"order": "instead", "script": "// As in part a).\nfunction sameArr(arr1,arr2)\n{\n if (arr1.length!=arr2.length)\n {\n   return false;\n }\n for (i=0; i<arr1.length; i++)\n {\n   if (arr1[i]!=arr2[i])\n     return false;\n }\n return true;\n}\n\nvar sA = this.studentAnswer;\nvar vars = this.question.scope.variables;\nvar truths = Numbas.jme.unwrapValue(vars.tt4);\nvar sTruths = truth_table(sA,3);\n\nif (!sameArr(truths,sTruths))\n  this.setCredit(0,\"Your statement does not generate the truth table.\");\nelse\n  this.setCredit(1,\"Your statement is correct.\");\nthis.answered = true;"}}, "displayAnswer": "{output4}", "marks": 1, "variableReplacementStrategy": "originalfirst", "type": "patternmatch", "customMarkingAlgorithm": "", "extendBaseMarkingAlgorithm": true, "variableReplacements": []}], "variablesTest": {"maxRuns": 100, "condition": "length(distinct([TT1,TT2,TT3,TT4]))=4"}, "functions": {"": {"language": "jme", "definition": "", "type": "number", "parameters": []}}, "advice": "<p>There are a number of ways to approach this. The most algorithmic is to apply the method used to get disjunctive and conjunctive normal form, as seen before. From this expression, it may be possible to simplify: for example the statement $(P \\wedge Q \\wedge R)\\vee(P \\wedge Q \\wedge \\neg R)$ clearly allows for both valuations of $R$, so is equivalent to the statement $P \\wedge Q$. You may be able to spot such simplifications from the truth table: for example a truth table</p>\n<table align=\"center\" style=\"margin-left: auto; margin-right: auto;\">\n<tbody>\n<tr>\n<td><strong>P</strong></td>\n<td><strong>Q</strong></td>\n<td><strong>R</strong></td>\n<td>Statement</td>\n</tr>\n<tr>\n<td>1</td>\n<td>1</td>\n<td>1</td>\n<td style=\"text-align: center;\">1</td>\n</tr>\n<tr>\n<td>1</td>\n<td>1</td>\n<td>0</td>\n<td style=\"text-align: center;\">0</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>1</td>\n<td style=\"text-align: center;\">1</td>\n</tr>\n<tr>\n<td>1</td>\n<td>0</td>\n<td>0</td>\n<td style=\"text-align: center;\">0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>1</td>\n<td>1</td>\n<td style=\"text-align: center;\">1</td>\n</tr>\n<tr>\n<td>0</td>\n<td>1</td>\n<td>0</td>\n<td style=\"text-align: center;\">0</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>1</td>\n<td style=\"text-align: center;\">1</td>\n</tr>\n<tr>\n<td>0</td>\n<td>0</td>\n<td>0</td>\n<td style=\"text-align: center;\">1</td>\n</tr>\n</tbody>\n</table>\n<p>values as true when $R$ is true, and also when all parameters are false. So one could write $R\\vee(\\neg P \\wedge \\neg Q \\wedge \\neg R)$.</p>", "rulesets": {}, "metadata": {"description": "<p>From a truth table, find a statement in three variables that satisfies it.</p>\n<p><strong>Uses the \"Logic\" extension: for details see the <a href=\"https://github.com/Tandethsquire/LogicNode\">documentation</a>.</strong></p>", "licence": "Creative Commons Attribution-ShareAlike 4.0 International"}, "statement": "<p>Find propositional formulae for the following truth tables.</p>\n<table>\n<tbody>\n<tr style=\"border-top: 1px black; border bottom: 1px black;\">\n<td style=\"border-left: 1px black;\"><strong>P</strong></td>\n<td><strong>Q</strong></td>\n<td style=\"border-right: 1px black;\"><strong>R</strong></td>\n<td>(a)</td>\n<td>(b)</td>\n<td style=\"border-right: 1px black;\">(c)</td>\n<td style=\"border-right: 1px black;\">(d)</td>\n</tr>\n<tr>\n<td style=\"border-left: 1px black;\">1</td>\n<td>1</td>\n<td style=\"border-right: 1px black;\">1</td>\n<td>{TT1[0]}</td>\n<td>{TT2[0]}</td>\n<td style=\"border-right: 1px black;\">{TT3[0]}</td>\n<td style=\"border-right: 1px black;\">{TT4[0]}</td>\n</tr>\n<tr>\n<td style=\"border-left: 1px black;\">1</td>\n<td>1</td>\n<td style=\"border-right: 1px black;\">0</td>\n<td>{TT1[1]}</td>\n<td>{TT2[1]}</td>\n<td style=\"border-right: 1px black;\">{TT3[1]}</td>\n<td style=\"border-right: 1px black;\">{TT4[1]}</td>\n</tr>\n<tr>\n<td style=\"border-left: 1px black;\">1</td>\n<td>0</td>\n<td style=\"border-right: 1px black;\">1</td>\n<td>{TT1[2]}</td>\n<td>{TT2[2]}</td>\n<td style=\"border-right: 1px black;\">{TT3[2]}</td>\n<td style=\"border-right: 1px black;\">{TT4[2]}</td>\n</tr>\n<tr>\n<td style=\"border-left: 1px black;\">1</td>\n<td>0</td>\n<td style=\"border-right: 1px black;\">0</td>\n<td>{TT1[3]}</td>\n<td>{TT2[3]}</td>\n<td style=\"border-right: 1px black;\">{TT3[3]}</td>\n<td style=\"border-right: 1px black;\">{TT4[3]}</td>\n</tr>\n<tr>\n<td style=\"border-left: 1px black;\">0</td>\n<td>1</td>\n<td style=\"border-right: 1px black;\">1</td>\n<td>{TT1[4]}</td>\n<td>{TT2[4]}</td>\n<td style=\"border-right: 1px black;\">{TT3[4]}</td>\n<td style=\"border-right: 1px black;\">{TT4[4]}</td>\n</tr>\n<tr>\n<td style=\"border-left: 1px black;\">0</td>\n<td>1</td>\n<td style=\"border-right: 1px black;\">0</td>\n<td>{TT1[5]}</td>\n<td>{TT2[5]}</td>\n<td style=\"border-right: 1px black;\">{TT3[5]}</td>\n<td style=\"border-right: 1px black;\">{TT4[5]}</td>\n</tr>\n<tr>\n<td style=\"border-left: 1px black;\">0</td>\n<td>0</td>\n<td style=\"border-right: 1px black;\">1</td>\n<td>{TT1[6]}</td>\n<td>{TT2[6]}</td>\n<td style=\"border-right: 1px black;\">{TT3[6]}</td>\n<td style=\"border-right: 1px black;\">{TT4[6]}</td>\n</tr>\n<tr style=\"border-bottom: 1px black;\">\n<td style=\"border-left: 1px black;\">0</td>\n<td>0</td>\n<td style=\"border-right: 1px black;\">0</td>\n<td>{TT1[7]}</td>\n<td>{TT2[7]}</td>\n<td style=\"border-right: 1px black;\">{TT3[7]}</td>\n<td style=\"border-right: 1px black;\">{TT4[7]}</td>\n</tr>\n</tbody>\n</table>\n<p><em>As always, you should write your statements as a descriptive string, with components separated by a space. For example, the&nbsp;statement&nbsp;$(P \\vee Q \\wedge \\neg R) \\wedge (R \\vee P)$ would be entered as (P OR Q AND NOT R) AND (R OR P).</em></p>", "variables": {"output4": {"templateType": "anything", "description": "<p>Takes the simplest of the two of dnf4, cnf4. For answer display purposes only.</p>", "definition": "if (length(dnf4)>length(cnf4), cnf4, dnf4)", "name": "output4", "group": "(d)"}, "dnf2": {"templateType": "anything", "description": "<p>Generates a disjunctive normal form based on TT2.</p>", "definition": "if (sum(TT2)=0, \"P AND NOT P\", normal_form(TT2,3,true))", "name": "dnf2", "group": "(b)"}, "cnf1": {"templateType": "anything", "description": "<p>Generates a conjunctive normal form based on TT1</p>", "definition": "if (sum(TT1)=8, \"P OR NOT P\", normal_form(TT1,3,false))", "name": "cnf1", "group": "(a)"}, "cnf2": {"templateType": "anything", "description": "<p>Generates a conjunctive normal form based on TT2.</p>", "definition": "if (sum(TT2)=8, \"P OR NOT P\", normal_form(TT2,3,false))", "name": "cnf2", "group": "(b)"}, "TT2": {"templateType": "anything", "description": "<p>A random collection of true and false.</p>", "definition": "map(random([0,1]),n,0..7)", "name": "TT2", "group": "(b)"}, "output1": {"templateType": "anything", "description": "<p>Takes the simplest of the two of dnf1, cnf1. For answer display purposes only.</p>", "definition": "if(length(dnf1)>length(cnf1),cnf1,dnf1)", "name": "output1", "group": "(a)"}, "cnf3": {"templateType": "anything", "description": "<p>Generates a conjunctive normal form based on TT3.</p>", "definition": "if (sum(TT3)=8, \"P OR NOT P\", normal_form(TT3,3,false))", "name": "cnf3", "group": "(c)"}, "TT1": {"templateType": "anything", "description": "<p>A random collection of true and false.</p>", "definition": "map(random([0,1]),n,0..7)", "name": "TT1", "group": "(a)"}, "TT3": {"templateType": "anything", "description": "<p>A random collection of true and false.</p>", "definition": "map(random([0,1]),n,0..7)", "name": "TT3", "group": "(c)"}, "dnf4": {"templateType": "anything", "description": "<p>Generates a disjunctive normal form based on TT4.</p>", "definition": "if (sum(TT4)=0, \"P AND NOT P\", normal_form(TT4,3,true))", "name": "dnf4", "group": "(d)"}, "output3": {"templateType": "anything", "description": "<p>Takes the simplest of the two of dnf3, cnf3. For answer display purposes only.</p>", "definition": "if(length(dnf3)>length(cnf3),cnf3,dnf3)", "name": "output3", "group": "(c)"}, "output2": {"templateType": "anything", "description": "<p>Takes the simplest of the two of dnf2, cnf2. For answer display purposes only.</p>", "definition": "if(length(dnf2)>length(cnf2),cnf2,dnf2)", "name": "output2", "group": "(b)"}, "dnf3": {"templateType": "anything", "description": "<p>Generates a disjunctive normal form based on TT3.</p>", "definition": "if(sum(TT3)=0, \"P AND NOT P\", normal_form(TT3,3,true))", "name": "dnf3", "group": "(c)"}, "dnf1": {"templateType": "anything", "description": "<p>Generates a disjunctive normal form based on TT1.</p>", "definition": "if (sum(TT1)=0, \"P AND NOT P\", normal_form(TT1,3,true))", "name": "dnf1", "group": "(a)"}, "cnf4": {"templateType": "anything", "description": "<p>Generates a conjunctive normal form based on TT4.</p>", "definition": "if (sum(TT4)=8, \"P OR NOT P\", normal_form(TT4,3,false))", "name": "cnf4", "group": "(d)"}, "TT4": {"templateType": "anything", "description": "<p>A random collection of true and false.</p>", "definition": "map(random([0,1]),n,0..7)", "name": "TT4", "group": "(d)"}}, "preamble": {"js": "", "css": ""}, "tags": [], "ungrouped_variables": [], "type": "question"}]}], "name": "Logic Node Demo", "feedback": {"advicethreshold": 0, "showanswerstate": true, "allowrevealanswer": true, "feedbackmessages": [], "showactualmark": true, "showtotalmark": true, "intro": ""}, "percentPass": 0, "navigation": {"browse": true, "allowregen": true, "showresultspage": "oncompletion", "showfrontpage": true, "preventleave": true, "onleave": {"action": "none", "message": ""}, "reverse": true}, "showQuestionGroupNames": false, "timing": {"timeout": {"action": "none", "message": ""}, "allowPause": true, "timedwarning": {"action": "none", "message": ""}}, "duration": 0, "type": "exam", "contributors": [{"name": "Andrew Iskauskas", "profile_url": "https://numbas.mathcentre.ac.uk/accounts/profile/724/"}], "extensions": ["Logic"], "custom_part_types": [], "resources": []}