Add jsnx library to help calculate mvc

Author: SethPoulsen

package-lock.json

@@ -18,8 +18,8 @@
     "author": "",
     "license": "ISC",
     "devDependencies": {
-        "copy-webpack-plugin": "^9.0.0",
         "compression-webpack-plugin": "^9.0.0",
+        "copy-webpack-plugin": "^9.0.0",
         "css-loader": "^6.0.0",
         "css-minimizer-webpack-plugin": "^3.0.0",
         "html-loader": "^3.0.0",
@@ -36,6 +36,7 @@
         "handsontable": "7.2.2",
         "jexcel": "^3.9.1",
         "jquery-ui": "1.10.4",
+        "jsnetworkx": "^0.3.4",
         "select2": "^4.1.0-rc.0",
         "sql.js": "1.5.0",
         "vega-embed": "3.14.0",

package.json

@@ -1,11 +1,102 @@
 import LineBasedGrader from "./lineGrader";
+import { DiGraph } from "jsnetworkx/node/classes";
+import { hasPath } from "jsnetworkx/node/algorithms/shortestPaths/generic";
+
+function graphToNX(answerBlocks) {
+    var graph = new DiGraph();
+    for (let block of answerBlocks) {
+        let line = block.lines[0]; // FIXME assume each block only has one line, won't work with adaptivity
+        graph.addNode(line.tag);
+        for (let line2 of line.depends) {
+            // the depends graph lists the *incoming* edges of a node
+            graph.addEdge(line2, line);
+        }
+    }
+    return graph;
+}
+
+function isVertexCover(graph, vertexCover) {
+    for (let edge of graph.edges()) {
+        if (!(vertexCover.has(edge[0]) || vertexCover.has(edge[1]))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function allSubsets(arr) {
+    let subsets = {};
+    for (let i = 0; i <= arr.length; i++) {
+        subsets[i] = [];
+    }
+    for (let i = 0; i < Math.pow(2, arr.length); i++) {
+        let bin = i.toString(2);
+        while (bin.length < arr.length) {
+            bin = "0" + bin;
+        }
+        let subset = new Set();
+        for (let j = 0; j < bin.length; j++) {
+            if (bin[j] == '1') {
+                subset.add(arr[j]);
+            }
+        }
+        subsets[subset.size].push(subset);
+    }
+    return subsets;
+}
 
 export default class DAGGrader extends LineBasedGrader {
 
-    inverseLISIndices(arr) {
-        // TODO implement this properly for the DAG grader so that it is the shortest edit distance
+
+    inverseLISIndices(answerBlocks, solution) {
+        // For more details and a proof of the correctness of the algorithm, see the paper: https://arxiv.org/abs/2204.04196
+        let graph = graphToNX(answerBlocks);
+        console.log(allSubsets([1,2,3]))
+
+        let seen = new Set();
+        let problematicSubgraph = new DiGraph();
+        let distractors = [];
+        for (let block of solution) {
+
+            if (block.distractor) {
+                distractors.push(block);
+                continue;
+            }
+
+            for (let block2 of seen) {
+                let problematic = hasPath(graph, block, block2);
+                if (hasPath(graph, block, block2)) {
+                    problematicSubgraph.addEdge(block, block2);
+                }
+            }
+
+            seen.add(block);
+        }
+
+        console.log(problematicSubgraph);
+
+        if (problematicSubgraph.numberOfNodes() == 0) {
+            // just return the indices of the distractors, I guess???
+        } else {
+            let mvc = null;
+            let subsets = allSubsets(problematicSubgraph.nodes());
+            for (let i = 0; i <= problematicSubgraph.numberOfNodes(); i++) {
+                for (let subset of subsets[i]) {
+                    if (isVertexCover(problematicSubgraph, subset)) {
+                        mvc = subset;
+                        console.log(mvc)
+                        break;
+                    }
+                }
+                if (mvc != null) {
+                    break;
+                }
+            }
+        }
+
+        // TODO implement the algorithm properly for the DAG grader so that it is the shortest edit distance
         // to ANY of the correct solutions instead of just to the model solution
-        return super.inverseLISIndices(arr)
+        return super.inverseLISIndices(answerBlocks, solution)
     }
 
     checkCorrectOrdering(solutionLines, answerLines) {

runestone/parsons/js/dagGrader.js

@@ -4,7 +4,22 @@ export default class LineBasedGrader {
     }
     // Use a LIS (Longest Increasing Subsequence) algorithm to return the indexes
     // that are not part of that subsequence.
-    inverseLISIndices(arr) {
+    inverseLISIndices(answerBlocks, solution) {
+        var inSolution = [];
+        var inSolutionIndexes = [];
+        var notInSolution = [];
+        for (let i = 0; i < answerBlocks.length; i++) {
+            var block = answerBlocks[i];
+            var index = solution.indexOf(block.lines[0]);
+            if (index == -1) {
+                notInSolution.push(block);
+            } else {
+                inSolution.push(block);
+                inSolutionIndexes.push(index);
+            }
+        }
+        let arr = inSolutionIndexes;
+
         // Get all subsequences
         var allSubsequences = [];
         for (var i = 0; i < arr.length; i++) {

runestone/parsons/js/lineGrader.js

@@ -1424,7 +1424,7 @@ export default class Parsons extends RunestoneBase {
                     inSolutionIndexes.push(index);
                 }
             }
-            var lisIndexes = this.grader.inverseLISIndices(inSolutionIndexes);
+            var lisIndexes = this.grader.inverseLISIndices(this.answerBlocks(), this.solution);
             for (let i = 0; i < lisIndexes.length; i++) {
                 notInSolution.push(inSolution[lisIndexes[i]]);
             }