tried = new HashSet<>();\n\n // Stage 1: the canonical Zhang MAG, exactly as the staged search tries it first.\n if (!escape) {\n if (closureGateAndCommit(new EdgeListGraph(base), x, y, b, pValue, excludeSelectionBias,\n _removed, _edge, () -> zhangCommits++) == GateStatus.COMMITTED) {\n return true;\n }\n tried.add(magKey(base));\n }\n\n // Phase A: stamp-compatibility propagation. Pins the TAILs the stamp gate will\n // demand and records the stamp's own arrowheads as virtual pins so cover moves\n // cannot contradict them.\n Map<String, Endpoint> pins = new HashMap<>();\n Graph cand = new EdgeListGraph(base);\n applyStampCompatPins(_pag, cand, pins, x, y, b);\n\n // The skeleton is class-invariant, so the paths are enumerated once, shortest first.\n List<List<Node>> paths = boundedSkeletonPaths(_pag, x, y, closureMaxPathLength, closureMaxPaths);\n\n int budget = (maxCoverMoves >= 0) ? maxCoverMoves : autoBudget(_pag, paths);\n\n boolean committed = closureCoverDfs(cand, pins, paths, budget, _pag, basePag,\n x, y, b, pValue, excludeSelectionBias, _removed, _edge, escape, false, tried, deadline);\n\n if (!committed) {\n // SECOND PASS, FULLY RELAXED. The frozen-marks assumption is only as sound as the\n // PAG, and MagToPag can over-commit (see slotCanBe) -- when it does, the witness\n // sits outside the frozen search space entirely and no amount of searching inside\n // it helps. The per-node fallback above catches only the case where a node has NO\n // frozen move; it cannot catch the case that matters more, where frozen moves exist\n // in abundance and every one of them leads somewhere out of class. PKE8's 6-observed\n // V6--V4 class is that case: nine free slots kept the frozen search busy for\n // hundreds of candidates, while the hosting representative needed arrowheads at V1\n // and V2 on edges the PAG had already called tails. So the trigger is the failure of\n // the whole frozen search, not the emptiness of one node's move set.\n //\n // Correctness is unaffected: relaxation widens only move GENERATION. Class\n // membership is still certified by MagToPag equality and every candidate still\n // clears the same gates, so a relaxed pass can commit nothing a frozen pass would\n // have been wrong to commit.\n closureRelaxedPasses++;\n\n Map<String, Endpoint> pins2 = new HashMap<>();\n Graph cand2 = new EdgeListGraph(base);\n applyStampCompatPins(_pag, cand2, pins2, x, y, b);\n\n // Leaf verdicts are pass-independent, but the MOVES available at a leaf are not,\n // so a state adjudicated frozen must be re-openable under relaxation.\n tried.clear();\n if (!escape) tried.add(magKey(base));\n\n committed = closureCoverDfs(cand2, pins2, paths, budget, _pag, basePag,\n x, y, b, pValue, excludeSelectionBias, _removed, _edge, escape, true, tried, deadline);\n }\n\n if (!committed && closureFallbackToStaged) {\n // FALLBACK TO THE STAGED GENERATOR. The closure search's weakness is structural,\n // not a missing move: it searches MAG space and tests class membership at the end,\n // whereas LegEnumerator only ever visits class members. Where the class is a small\n // share of the separating assignments -- dense PAGs at 6+ observed variables -- the\n // closure DFS can generate exactly the right moves (verified) and still never land\n // in class. Deferring to the staged search on failure makes this generator's reach a\n // superset of staged's while keeping its speed on the cases it does host, at the\n // cost that such edges' provenance reads as staged. {@code closureFallbackCommits}\n // counts them, so the ledger stays honest and the residual rate stays visible.\n //\n // Nothing has been mutated at this point: the closure search touches interimPags\n // and sepsets only via closureGateAndCommit, which runs only on success. So the\n // staged search sees exactly the state it would have seen had it run alone.\n closureFallbackAttempts++;\n committed = tryToModifyGraph(x, y, b, pValue, excludeSelectionBias, escape);\n if (committed) closureFallbackCommits++;\n }\n\n if (!committed && verbose) {\n TetradLogger.getInstance().log(\"\\tClosure-cover search: no candidate hosted \" + _edge\n + (escape ? \" (escape mode)\" : \" (within-class mode)\") + \", sepset = \" + b);\n }\n\n return committed;\n }\n\n /**\n * Gate outcomes for the closure path; the diagnosis drives repair-move generation at\n * separating leaves (see {@link #closureCoverDfs}).\n */\n private enum GateStatus {COMMITTED, STAMP_REFUSED, ILLEGAL_MAG, INDUCING_PATH, BATTERY_REFUSED}\n\n /**\n * AUTO move budget: the number of free (circle) endpoint slots on the closure of the\n * enumerated x..y paths, floored at 4 so short closures still get the historical budget\n * and capped by {@link #closureAutoBudgetCap} to bound the DFS. This is the local measure\n * of how far the search may have to travel -- every move sets a slot that was free, so a\n * witness cannot be further than the number of free slots, and bounding by the closure\n * rather than by a constant is what keeps the bound meaningful as models grow.\n */\n private int autoBudget(Graph pag, List<List<Node>> paths) {\n Set<Node> closure = new LinkedHashSet<>();\n for (List<Node> p : paths) closure.addAll(p);\n\n Set<String> free = new LinkedHashSet<>();\n for (Node u : closure) {\n for (Node w : pag.getAdjacentNodes(u)) {\n if (pag.getEndpoint(w, u) == Endpoint.CIRCLE) free.add(slotKey(w, u));\n if (pag.getEndpoint(u, w) == Endpoint.CIRCLE) free.add(slotKey(u, w));\n }\n }\n\n return Math.max(4, Math.min(closureAutoBudgetCap, free.size()));\n }\n\n /**\n * The gate pipeline, factored for the closure path but IDENTICAL in content and order to\n * the inline gates of {@link #tryToModifyGraph}: honour the stored sepsets by stamping the\n * common colliders of the pair; require the stamped graph to be a legal MAG (the H' every\n * lemma quantifies over -- see the inducing-path incident documented at the corresponding\n * gate in tryToModifyGraph); remove the edge; require no inducing path at the pair (prong\n * A, localized by Lemma 3.6); pass the deleted-pair battery (prong B); then commit and\n * record provenance. Returns the failure kind rather than a bare boolean so the caller\n * can target repairs at the actual obstruction.\n */\n private GateStatus closureGateAndCommit(Graph candidate, Node x, Node y, Set<Node> b, double pValue,\n boolean excludeSelectionBias, List<Edge> removed, Edge edgeForLog,\n Runnable provenance) throws InterruptedException {\n Graph _mag = candidate.copy();\n\n if (!stampLegColliders(_mag, b, x, y)) {\n return GateStatus.STAMP_REFUSED;\n }\n\n if (!_mag.paths().isLegalMag()) {\n otherRejects++;\n return GateStatus.ILLEGAL_MAG;\n }\n\n _mag.removeEdge(x, y);\n\n legalityChecks++;\n\n if (_mag.paths().existsInducingPath(x, y, Set.of())) {\n ipRejects++;\n return GateStatus.INDUCING_PATH;\n }\n\n if (!deletedPairBatteryPasses(_mag, removed)) {\n return GateStatus.BATTERY_REFUSED;\n }\n\n if (verbose) {\n TetradLogger.getInstance().log(\"Removing \" + edgeForLog + \", sepset = \" + b\n + (Double.isNaN(pValue) ? \"\" : \", p = \" + pValue));\n }\n\n provenance.run();\n\n this.interimPags.add(new MagToPag(_mag).convert(false, excludeSelectionBias));\n sepsets.set(x, y, b);\n return GateStatus.COMMITTED;\n }\n\n /**\n * Stamp-compatibility propagation (Phase A). For each common neighbour c of x and y outside\n * S, the gate will stamp x *-> c <-* y. {@link #stampLegColliders} refuses when some d\n * with an arrowhead into c is unshielded from x (or y) without the triple already being a\n * definite collider -- the stamp would mint a new unshielded collider. So wherever the\n * current PAG leaves the mark at c on d--c FREE (a circle), pin it TAIL in the candidate:\n * this is exactly the \"reversal needed for the stamp\" that the staged search can reach only\n * by walking to the right LEG, obtained here by unit propagation before any search. Where\n * the PAG mark is an INVARIANT arrowhead and the triple is not an invariant collider, the\n * obstruction is recorded ({@code closureStampObstructions}) but NOT treated as a proof of\n * non-hostability: stampLegColliders' pre-check consults the candidate's marks, and a\n * candidate that pre-orients the x-side arrowhead at c can still satisfy it, so we leave\n * such cases for the gate to adjudicate rather than over-prune. (An obstruction count that\n * tracks refusals one-for-one at the oracle would be evidence the pre-check could be\n * strengthened to a certificate; PKE can audit that.)\n */\n private void applyStampCompatPins(Graph pag, Graph cand, Map<String, Endpoint> pins,\n Node x, Node y, Set<Node> b) {\n List<Node> common = pag.getAdjacentNodes(x);\n common.retainAll(pag.getAdjacentNodes(y));\n\n for (Node c : common) {\n if (b.contains(c)) continue; // not stamped; no requirement\n if (pag.isDefCollider(x, c, y)) continue; // stamp is a no-op here\n\n // The stamp will force arrowheads at c from x and y; record them as virtual\n // pins (NOT applied to cand -- the gate re-derives them, and classification is\n // pre-stamp) so no cover move tries to tail them.\n pins.putIfAbsent(slotKey(x, c), Endpoint.ARROW);\n pins.putIfAbsent(slotKey(y, c), Endpoint.ARROW);\n\n for (Node d : pag.getAdjacentNodes(c)) {\n if (d == x || d == y) continue;\n\n boolean unshX = !pag.isAdjacentTo(d, x);\n boolean unshY = !pag.isAdjacentTo(d, y);\n if (!unshX && !unshY) continue;\n\n // Positing an arrowhead at c from d: stampLegColliders' pre-check passes iff\n // d*->c<-*x is ALREADY a definite collider, and since the stamp sets its own\n // arrowheads only AFTER the check, that reduces to \"the candidate already\n // carries an arrowhead at c from x\". Judging this on the PAG's circles\n // instead pins TAIL far too often -- in PKE8's X1--X5 case the Zhang MAG\n // already had X1 --> X4, so an arrowhead at X4 from X7 was perfectly legal,\n // yet the PAG-based test pinned it TAIL and blocked the only cut that breaks\n // X4's ancestry into S, leaving the DFS with no moves at all. Erring\n // permissive is the safe direction: a branch the stamp would refuse is caught\n // by the STAMP_REFUSED prune, whereas an over-tight pin silently removes the\n // witness from the search space.\n boolean okWithArrow = (!unshX || cand.getEndpoint(x, c) == Endpoint.ARROW)\n && (!unshY || cand.getEndpoint(y, c) == Endpoint.ARROW);\n if (okWithArrow) continue;\n\n Endpoint atC = pag.getEndpoint(d, c);\n\n if (atC == Endpoint.ARROW) {\n // Invariant arrowhead: every candidate this generator freezes-and-flips\n // carries it, and the stamp's conservative pre-check will likely refuse.\n // Recorded as evidence, adjudicated by the gate.\n closureStampObstructions++;\n } else if (atC == Endpoint.CIRCLE) {\n Endpoint prev = pins.putIfAbsent(slotKey(d, c), Endpoint.TAIL);\n if (prev == null) {\n // Legal-shape companion: a tail at c against a tail at d would make\n // d -- c UNDIRECTED (a selection edge, illegal here), so anticipate\n // the arrowhead at d when the PAG allows it; when it doesn't, the\n // pin is infeasible in every candidate this generator produces --\n // release it, record the obstruction, and let the gate adjudicate.\n if (cand.getEndpoint(c, d) == Endpoint.TAIL) {\n if (slotCanBe(pag, pins, c, d, Endpoint.ARROW)) {\n cand.setEndpoint(d, c, Endpoint.TAIL);\n cand.setEndpoint(c, d, Endpoint.ARROW);\n pins.put(slotKey(c, d), Endpoint.ARROW);\n } else {\n pins.remove(slotKey(d, c));\n closureStampObstructions++;\n }\n } else {\n cand.setEndpoint(d, c, Endpoint.TAIL);\n }\n }\n // prev == TAIL: already pinned, nothing to do. prev == ARROW cannot\n // happen: arrow pins live only at c's marks on x--c / y--c.\n }\n // atC == TAIL: invariant tail already satisfies the requirement.\n }\n }\n }\n\n /**\n * The cover-and-repair search (Phase B). Each node: stamp the current partial assignment\n * (a refused stamp abandons the branch -- {@code closureStampPrunes} -- since the gate\n * would refuse every completion that leaves the obstructing marks untouched; completions\n * that change them are reached on sibling branches), then find the first enumerated path\n * still active given S.\n * <p>\n * ACTIVE PATH: branch on the COVER moves that could block it (see {@link #coverMoves}).\n * <p>\n * NO ACTIVE PATH: confirm exactly, classify, and hand to the gates. When the gate refuses\n * a separating candidate, the leaf is NOT abandoned: no path-driven move can exist (there\n * is no active path to derive one from), but OTHER representatives that also separate may\n * survive the gate -- the staged search reaches them by walking LEGs; this search reaches\n * them by REPAIR moves generated from the gate's own diagnosis: for a stamp-induced\n * illegality, break the offending directed/almost-directed cycle or non-maximal inducing\n * path (reversals first -- the LEG-style fix -- then bidirected cuts); for a prong-(A)\n * failure, break the removed pair's inducing path. This was learned from the V3--V4\n * five-node case, where the unique-up-to-reversal separating assignment was stamp-illegal\n * and only a V2--V4-style reversal (a Stage-2 LEG in the staged search) hosts the\n * deletion. Battery refusals get no repair -- they are data verdicts, terminal per\n * candidate exactly as in the staged search. First commit wins.\n */\n private boolean closureCoverDfs(Graph cand, Map<String, Endpoint> pins, List<List<Node>> paths,\n int movesLeft, Graph pag, Graph basePag, Node x, Node y, Set<Node> b,\n double pValue, boolean excludeSelectionBias, List<Edge> removed,\n Edge edgeForLog, boolean escape, boolean relaxed,\n Set<String> tried, long deadline)\n throws InterruptedException {\n if (Thread.currentThread().isInterrupted()) {\n throw new InterruptedException();\n }\n\n if (System.currentTimeMillis() > deadline) {\n return false;\n }\n\n // Judge activity on what the gate will actually evaluate: the stamped candidate\n // minus the edge.\n Graph stamped = new EdgeListGraph(cand);\n if (!stampLegColliders(stamped, b, x, y)) {\n closureStampPrunes++;\n return false;\n }\n Graph probe = new EdgeListGraph(stamped);\n probe.removeEdge(x, y);\n\n List<Node> active = firstActivePath(probe, paths, b);\n\n List<CoverMove> moves;\n\n if (active != null) {\n if (movesLeft == 0) return false;\n moves = coverMoves(pag, stamped, cand, pins, active, paths, b, relaxed);\n if (moves.isEmpty() && !relaxed) {\n // No move exists under the frozen-marks assumption. The assumption itself may\n // be what is wrong here (see slotCanBe), so retry with the PAG's non-circle\n // marks unfrozen; class membership and every gate still adjudicate.\n moves = coverMoves(pag, stamped, cand, pins, active, paths, b, true);\n if (!moves.isEmpty()) closureRelaxedExpansions++;\n }\n } else {\n // Every enumerated path is blocked; confirm exactly (an active path beyond the\n // enumeration bounds would otherwise slip through the covering heuristic).\n if (!new MsepTest(probe).checkIndependence(x, y, b).isIndependent()) {\n closureLongPathMisses++;\n return false;\n }\n\n String key = magKey(cand);\n if (!tried.add(key)) return false; // separating state already adjudicated\n\n if (!cand.paths().isLegalMag()) {\n // A separating assignment that is not itself a MAG. The obstruction is an\n // ancestrality violation or a non-maximality, so the SAME repair family that\n // services a post-stamp illegality applies -- the only difference is that it\n // is read off the candidate rather than the stamped candidate. (PKE8's\n // 5-node V1--V5 case: de-collider-izing V3 on the V1--V3--V5 leg via the V1\n // side closed the directed cycle V3->V1->V5->V3; breaking it is on the road\n // to the in-class witness.)\n closureIllegalCands++;\n if (movesLeft == 0) return false;\n moves = illegalityRepairMoves(pag, cand, pins, relaxed);\n } else {\n closureCandidatesEmitted++;\n\n // Class membership, certified as seedMags certifies seeds: pre-stamp, by\n // MagToPag equality against the base PAG.\n boolean inClass = new MagToPag(new EdgeListGraph(cand))\n .convert(false, excludeSelectionBias).equals(basePag);\n\n if (inClass == escape) {\n // Separating and legal, but on the wrong side of the class boundary.\n // The staged search never meets this state because LegEnumerator walks\n // only in-class representatives; this search reaches the class the other\n // way round, by repairing the marks that MagToPag over- or\n // under-determines relative to the class. See {@link #classRepairMoves}.\n closureClassFiltered++;\n if (movesLeft == 0) return false;\n moves = classRepairMoves(pag, cand, pins, basePag, excludeSelectionBias, relaxed);\n } else {\n GateStatus st = closureGateAndCommit(cand, x, y, b, pValue, excludeSelectionBias,\n removed, edgeForLog,\n escape ? () -> closureEscapeCommits++ : () -> closureInClassCommits++);\n\n if (st == GateStatus.COMMITTED) return true;\n if (movesLeft == 0) return false;\n\n moves = switch (st) {\n case ILLEGAL_MAG -> illegalityRepairMoves(pag, stamped, pins, relaxed);\n case INDUCING_PATH -> inducingRepairMoves(pag, probe, pins, x, y, relaxed);\n default -> List.of(); // STAMP_REFUSED cannot recur; BATTERY is terminal\n };\n }\n }\n }\n\n for (CoverMove mv : moves) {\n // Skip no-op moves (every assignment already holds): they would burn budget\n // re-deriving the same state one level deeper.\n boolean noop = true;\n for (Assign a : mv.assigns()) {\n if (cand.getEndpoint(a.from(), a.at()) != a.end()) {\n noop = false;\n break;\n }\n }\n if (noop) continue;\n\n List<Endpoint> saved = new ArrayList<>();\n List<String> addedPins = new ArrayList<>();\n applyMove(cand, pins, mv, saved, addedPins);\n\n boolean done = closureCoverDfs(cand, pins, paths, movesLeft - 1, pag, basePag, x, y, b,\n pValue, excludeSelectionBias, removed, edgeForLog, escape, relaxed, tried, deadline);\n\n undoMove(cand, pins, mv, saved, addedPins);\n\n if (done) return true;\n }\n\n return false;\n }\n\n /**\n * Repair moves for a separating, legal candidate that landed OUTSIDE the current class.\n * The class boundary is not a path property, so no cover move targets it; but it is\n * legible as a mark-by-mark difference between the candidate's own PAG and the base PAG.\n * For every slot where {@code MagToPag(cand)} determines a mark that the class leaves as\n * a circle (or determines the other way), propose the assignment ON THE CANDIDATE that\n * relaxes it: a candidate arrowhead that the class does not entail becomes a tail (with\n * the legal-shape companion, i.e. a reversal), a candidate tail becomes an arrowhead.\n * <p>\n * This is the closure-side image of LegEnumerator's walk. The staged search never sees an\n * out-of-class state because it only ever enumerates in-class representatives; this search\n * arrives at the class from outside, and each such difference names an edge whose\n * orientation has to change to get back in. In PKE8's 5-node V1--V5 case the candidate's\n * PAG carried V2 o-> V5 where the class has V2 o-o V5 -- V5 had become an unshielded\n * collider -- and relaxing exactly that arrowhead is the second reversal that the staged\n * search's winning LEG performs.\n * <p>\n * Purely a move generator: class membership itself is still certified by MagToPag\n * equality, and every candidate still passes the same gates.\n */\n private List<CoverMove> classRepairMoves(Graph pag, Graph cand, Map<String, Endpoint> pins,\n Graph basePag, boolean excludeSelectionBias, boolean relaxed)\n throws InterruptedException {\n List<CoverMove> out = new ArrayList<>();\n\n Graph candPag = new MagToPag(new EdgeListGraph(cand)).convert(false, excludeSelectionBias);\n\n for (Edge e : basePag.getEdges()) {\n String un = e.getNode1().getName(), wn = e.getNode2().getName();\n proposeMarkRepair(pag, cand, pins, basePag, candPag, un, wn, out, relaxed);\n proposeMarkRepair(pag, cand, pins, basePag, candPag, wn, un, out, relaxed);\n }\n\n // AGGREGATE CLASS REPAIR, tried first. Class membership is a GLOBAL property of the\n // assignment: relaxing one over-determined mark generally leaves the candidate still\n // out of class, so repairing mark-by-mark costs one move per difference and the move\n // budget -- not the move set -- becomes what decides whether the witness is reachable.\n // That is a scaling trap: the number of differing marks grows with the model while the\n // budget does not. PKE8's V1--V5 class made it concrete -- the winning representative\n // sits five endpoint-changes from the Zhang MAG, so it was unreachable at the default\n // budget of 4 and appeared only when the budget was raised. Applying every proposed\n // relaxation at once puts the class one move away regardless of how many marks differ,\n // which is the same lesson the aggregate fork-flip taught. Conflicting proposals (the\n // same slot wanted both ways) mean no single composite exists, so only the individual\n // moves are offered.\n if (out.size() > 1) {\n Map<String, Assign> union = new LinkedHashMap<>();\n boolean conflict = false;\n for (CoverMove mv : out) {\n for (Assign a : mv.assigns()) {\n Assign prev = union.putIfAbsent(slotKey(a.from(), a.at()), a);\n if (prev != null && prev.end() != a.end()) {\n conflict = true;\n break;\n }\n }\n if (conflict) break;\n }\n if (!conflict) out.addFirst(new CoverMove(new ArrayList<>(union.values())));\n }\n\n return dedupMoves(out);\n }\n\n /**\n * One slot of {@link #classRepairMoves}: the mark at {@code atName} on the edge\n * {@code fromName}--{@code atName}. Nodes are resolved by NAME in each graph, since the\n * PAGs are built by conversion and need not share node objects with the candidate.\n */\n private void proposeMarkRepair(Graph pag, Graph cand, Map<String, Endpoint> pins,\n Graph basePag, Graph candPag, String fromName, String atName,\n List<CoverMove> out, boolean relaxed) {\n Node bf = basePag.getNode(fromName), ba = basePag.getNode(atName);\n Node pf = candPag.getNode(fromName), pa = candPag.getNode(atName);\n if (bf == null || ba == null || pf == null || pa == null) return;\n if (!candPag.isAdjacentTo(pf, pa)) return;\n\n Endpoint want = basePag.getEndpoint(bf, ba);\n Endpoint got = candPag.getEndpoint(pf, pa);\n if (want == got) return;\n\n Node cf = cand.getNode(fromName), ca = cand.getNode(atName);\n if (cf == null || ca == null || !cand.isAdjacentTo(cf, ca)) return;\n\n // Only the candidate's own mark at this slot is movable; MagToPag may have derived\n // the differing mark from elsewhere, in which case another slot's repair carries it.\n if (got == Endpoint.ARROW && cand.getEndpoint(cf, ca) == Endpoint.ARROW) {\n addTailMove(pag, cand, pins, cf, ca, out, relaxed);\n } else if (got == Endpoint.TAIL && cand.getEndpoint(cf, ca) == Endpoint.TAIL\n && slotCanBe(pag, pins, cf, ca, Endpoint.ARROW, relaxed)) {\n out.add(new CoverMove(List.of(new Assign(cf, ca, Endpoint.ARROW))));\n }\n }\n\n /**\n * Repair moves for a stamped candidate {@code isLegalMag} rejected: locate each\n * ancestrality violation -- a bidirected edge with a directed path between its endpoints\n * (almost-directed cycle) or a directed edge opposed by a directed path (directed cycle)\n * -- and each non-maximality (an inducing path over the empty set between a nonadjacent\n * pair), and propose the assignments that break them. The bidirected edge itself is\n * typically stamp-pinned, so {@link #slotCanBe} steers repairs at the directed path,\n * which is exactly where the staged search's winning LEGs differ from the Zhang MAG.\n */\n private List<CoverMove> illegalityRepairMoves(Graph pag, Graph stamped, Map<String, Endpoint> pins,\n boolean relaxed) {\n List<CoverMove> out = new ArrayList<>();\n\n for (Edge e : stamped.getEdges()) {\n Node u = e.getNode1(), w = e.getNode2();\n Endpoint atU = stamped.getEndpoint(w, u), atW = stamped.getEndpoint(u, w);\n\n if (atU == Endpoint.ARROW && atW == Endpoint.ARROW) { // u <-> w\n // An almost-directed cycle u <-> w with u ~> w has TWO resolutions: break the\n // directed path, or relax the bidirected edge itself to u --> w (which is not\n // a cycle at all). Only the first was generated, and the second is what\n // PKE8's V4--V5 family needs -- there the winning LEG differs from the\n // candidate purely by carrying V5 --> V3 where the search had cut to V5 <-> V3.\n List<Node> p = firstDirectedPath(stamped, u, w, closureMaxPathLength);\n if (p != null) {\n addPathBreakMoves(pag, pins, p, out, relaxed);\n addTailMove(pag, stamped, pins, w, u, out, relaxed); // u <-> w ==> u --> w\n } else {\n p = firstDirectedPath(stamped, w, u, closureMaxPathLength);\n if (p != null) {\n addPathBreakMoves(pag, pins, p, out, relaxed);\n addTailMove(pag, stamped, pins, u, w, out, relaxed); // u <-> w ==> w --> u\n }\n }\n } else if (atU == Endpoint.TAIL && atW == Endpoint.ARROW) { // u --> w\n List<Node> p = firstDirectedPath(stamped, w, u, closureMaxPathLength);\n if (p != null) addPathBreakMoves(pag, pins, p, out, relaxed); // w ~> u closes a cycle\n }\n }\n\n // Non-maximality: an inducing path between a nonadjacent pair.\n List<Node> nodes = stamped.getNodes();\n for (int i = 0; i < nodes.size() && out.isEmpty(); i++) {\n for (int j = i + 1; j < nodes.size() && out.isEmpty(); j++) {\n Node u = nodes.get(i), w = nodes.get(j);\n if (stamped.isAdjacentTo(u, w)) continue;\n List<Node> ip = firstInducingPathOverEmpty(stamped, u, w, closureMaxPathLength);\n if (ip != null) addInducingBreakMoves(pag, stamped, pins, ip, u, w, out, relaxed);\n }\n }\n\n return out;\n }\n\n /**\n * Repair moves for a prong-(A) rejection: break the removed pair's inducing path in the\n * deleted graph, by de-collider-izing an interior node or cutting its ancestry to the\n * endpoints.\n */\n private List<CoverMove> inducingRepairMoves(Graph pag, Graph probe, Map<String, Endpoint> pins,\n Node x, Node y, boolean relaxed) {\n List<CoverMove> out = new ArrayList<>();\n List<Node> ip = firstInducingPathOverEmpty(probe, x, y, closureMaxPathLength);\n if (ip != null) addInducingBreakMoves(pag, probe, pins, ip, x, y, out, relaxed);\n return out;\n }\n\n /**\n * Assignments that break one link of a directed path: for each edge p --> q on it,\n * the reversal (arrowhead at p, tail at q -- the LEG-style fix, proposed first) and the\n * bidirected cut (arrowhead at p alone), wherever the PAG and pins allow.\n */\n private void addPathBreakMoves(Graph pag, Map<String, Endpoint> pins, List<Node> path,\n List<CoverMove> out, boolean relaxed) {\n for (int i = 0; i < path.size() - 1; i++) {\n Node p = path.get(i), q = path.get(i + 1);\n boolean arrowAtP = slotCanBe(pag, pins, q, p, Endpoint.ARROW, relaxed);\n if (arrowAtP && slotCanBe(pag, pins, p, q, Endpoint.TAIL, relaxed)) {\n out.add(new CoverMove(List.of(\n new Assign(q, p, Endpoint.ARROW),\n new Assign(p, q, Endpoint.TAIL))));\n }\n if (arrowAtP) {\n out.add(new CoverMove(List.of(new Assign(q, p, Endpoint.ARROW))));\n }\n }\n }\n\n /**\n * Assignments that break an inducing path over the empty set: de-collider-ize an interior\n * node (tail move with its legal-shape companion), or cut its ancestry to the endpoints\n * (individual and aggregate arrowhead cuts on its outgoing directed edges), wherever the\n * PAG and pins allow.\n */\n private void addInducingBreakMoves(Graph pag, Graph g, Map<String, Endpoint> pins,\n List<Node> path, Node u, Node w, List<CoverMove> out,\n boolean relaxed) {\n for (int i = 1; i < path.size() - 1; i++) {\n Node prev = path.get(i - 1), m = path.get(i), next = path.get(i + 1);\n\n addTailMove(pag, g, pins, prev, m, out, relaxed);\n addTailMove(pag, g, pins, next, m, out, relaxed);\n\n List<Assign> quench = new ArrayList<>();\n for (Node z : g.getAdjacentNodes(m)) {\n if (g.getEndpoint(z, m) == Endpoint.TAIL && g.getEndpoint(m, z) == Endpoint.ARROW\n && slotCanBe(pag, pins, z, m, Endpoint.ARROW, relaxed)) {\n Assign cut = new Assign(z, m, Endpoint.ARROW);\n out.add(new CoverMove(List.of(cut)));\n quench.add(cut);\n }\n }\n if (quench.size() > 1) out.add(new CoverMove(List.copyOf(quench)));\n }\n }\n\n /**\n * First directed path from {@code from} to {@code to} (edges with a tail at the source and\n * an arrowhead at the target), BFS, bounded; null if none within the bound.\n */\n private List<Node> firstDirectedPath(Graph g, Node from, Node to, int maxLen) {\n Map<Node, Node> parent = new LinkedHashMap<>();\n Deque<Node> queue = new ArrayDeque<>();\n Map<Node, Integer> depth = new LinkedHashMap<>();\n queue.add(from);\n depth.put(from, 0);\n\n while (!queue.isEmpty()) {\n Node cur = queue.removeFirst();\n if (depth.get(cur) >= maxLen) continue;\n for (Node z : g.getAdjacentNodes(cur)) {\n if (depth.containsKey(z)) continue;\n if (g.getEndpoint(z, cur) == Endpoint.TAIL && g.getEndpoint(cur, z) == Endpoint.ARROW) {\n parent.put(z, cur);\n depth.put(z, depth.get(cur) + 1);\n if (z.equals(to)) {\n LinkedList<Node> path = new LinkedList<>();\n for (Node n = z; n != null; n = parent.get(n)) path.addFirst(n);\n return path;\n }\n queue.addLast(z);\n }\n }\n }\n return null;\n }\n\n /**\n * First inducing path over the empty conditioning set between {@code u} and {@code w}:\n * a path on which every interior node is a collider AND an ancestor of {@code u} or\n * {@code w}. Bounded DFS; null if none within the bound.\n */\n private List<Node> firstInducingPathOverEmpty(Graph g, Node u, Node w, int maxLen) {\n Deque<Node> path = new ArrayDeque<>();\n Set<Node> onPath = new HashSet<>();\n path.addLast(u);\n onPath.add(u);\n return inducingDfs(g, u, w, maxLen, path, onPath);\n }\n\n private List<Node> inducingDfs(Graph g, Node cur, Node w, int maxLen,\n Deque<Node> path, Set<Node> onPath) {\n if (cur.equals(w)) {\n return path.size() >= 3 ? new ArrayList<>(path) : null;\n }\n if (path.size() > maxLen) return null;\n\n Node u = path.peekFirst();\n List<Node> asList = new ArrayList<>(path);\n\n for (Node next : g.getAdjacentNodes(cur)) {\n if (onPath.contains(next)) continue;\n\n // The node BEFORE next (i.e. cur) becomes interior once we extend; check its\n // collider/ancestry duty on the extended path (skip for the first hop, where\n // cur is the endpoint u).\n if (asList.size() >= 2) {\n Node prev = asList.get(asList.size() - 2);\n boolean collider = g.getEndpoint(prev, cur) == Endpoint.ARROW\n && g.getEndpoint(next, cur) == Endpoint.ARROW;\n if (!collider) continue;\n if (!(g.paths().isAncestorOf(cur, u) || g.paths().isAncestorOf(cur, w))) continue;\n }\n\n path.addLast(next);\n onPath.add(next);\n List<Node> found = inducingDfs(g, next, w, maxLen, path, onPath);\n onPath.remove(next);\n path.removeLast();\n if (found != null) return found;\n }\n return null;\n }\n\n /**\n * Moves that could block the given active path, respecting the PAG's invariant marks and\n * the current pins. Collider/ancestry STATUS is judged on the stamped view (what the gate\n * evaluates); feasibility on the PAG and pins; assignments apply to the pre-stamp\n * candidate. Three move families:\n * <p>\n * (1) COLLIDER-IZE: an interior node m outside S that is not yet a collider on its path\n * edges gets arrowheads in from both path neighbours -- proposed only when the PAG's\n * invariant directed edges do not already force m into An(S), since then no in-scope\n * assignment makes the collider block.\n * <p>\n * (2) DESCENDANT CUT: an interior node m outside S that IS a collider but remains an\n * ancestor of S (so the collider does not block). For each outgoing directed edge\n * m --> w whose mark at m is free, a cut converts it to m <-> w, severing that\n * ancestry route; individually, and -- when several are cuttable -- as one aggregate\n * \"quench\" move that severs them all at once. The quench is the closure analog of the\n * staged search's makeCollider stamping arrowheads in from every path neighbour: the\n * seed-9025-style witness (all of a fork's outgoing edges turned bidirected so the\n * stamped collider stops being an ancestor and prong (A)'s inducing path dies) is\n * reached in one step. Cuts one hop deeper (m --> w fixed but w --> z free) are\n * not generated; the budget and other triples give partial reach, and PKE residue will\n * show whether deeper cuts are ever needed.\n * <p>\n * (3) DE-COLLIDER-IZE: an interior node m in S sitting as a collider frees one side to a\n * tail -- with a companion arrowhead at the far end when the far mark is a tail, since\n * tail--tail is an undirected (selection) edge, illegal here; if the companion is not\n * available the move is infeasible.\n */\n private List<CoverMove> coverMoves(Graph pag, Graph stamped, Graph cand, Map<String, Endpoint> pins,\n List<Node> path, List<List<Node>> allPaths, Set<Node> S,\n boolean relaxed) {\n List<CoverMove> out = new ArrayList<>();\n\n for (int i = 1; i < path.size() - 1; i++) {\n Node a = path.get(i - 1), m = path.get(i), c = path.get(i + 1);\n\n if (!S.contains(m)) {\n if (!stamped.isDefCollider(a, m, c)) {\n if (slotCanBe(pag, pins, a, m, Endpoint.ARROW, relaxed)\n && slotCanBe(pag, pins, c, m, Endpoint.ARROW, relaxed)\n && !invariantAncestorOfS(pag, m, S)) {\n out.add(new CoverMove(List.of(\n new Assign(a, m, Endpoint.ARROW),\n new Assign(c, m, Endpoint.ARROW))));\n }\n } else if (ancestorInS(stamped, m, S) && !invariantAncestorOfS(pag, m, S)) {\n List<Assign> quench = new ArrayList<>();\n for (Node w : stamped.getAdjacentNodes(m)) {\n if (stamped.getEndpoint(w, m) == Endpoint.TAIL // tail at m\n && stamped.getEndpoint(m, w) == Endpoint.ARROW // m --> w\n && slotCanBe(pag, pins, w, m, Endpoint.ARROW, relaxed)) {\n Assign cut = new Assign(w, m, Endpoint.ARROW);\n out.add(new CoverMove(List.of(cut)));\n quench.add(cut);\n }\n }\n if (quench.size() > 1) {\n out.add(new CoverMove(List.copyOf(quench)));\n }\n\n // ANCESTRY ROUTE BREAK. A collider blocks only if it has no descendant in\n // S, and the route from m into S may run several edges deep -- severing\n // only edges INCIDENT to m cannot reach past the first hop. So locate the\n // directed route and offer the same reversal/cut breaks used on cycles, at\n // every edge along it. PKE8's 6-observed V5--V6 class is the case that\n // needs this: cutting V1 --> V4 still leaves V1 --> V2 --> V4 alive, the\n // first hop is frozen by a Phase-A pin, and the staged winner breaks the\n // route at its SECOND edge, reversing V2 --> V4 to V4 --> V2.\n for (Node z : S) {\n List<Node> route = firstDirectedPath(stamped, m, z, closureMaxPathLength);\n if (route != null) {\n addPathBreakMoves(pag, pins, route, out, relaxed);\n break;\n }\n }\n }\n } else {\n if (stamped.isDefCollider(a, m, c)) {\n addTailMove(pag, cand, pins, a, m, out, relaxed);\n addTailMove(pag, cand, pins, c, m, out, relaxed);\n }\n }\n }\n\n // (4) AGGREGATE FORK-FLIP -- the Stage-2b move, ported. A fork can lie on several\n // active paths at once, and the staged search's makeCollider stamps arrowheads in\n // from EVERY neighbour occurring beside it on ANY of them, in a single step. The\n // per-path move above only ever stamps the two neighbours on the path being covered,\n // and reaching the same state pairwise means passing through intermediate assignments\n // that are typically illegal or off-class -- so the composite is unreachable by parts\n // and has to be generated whole. This is what PKE8's V3--V4 / V3--V5 class needs: the\n // fork sits on two active paths, and only the simultaneous flip both blocks them and\n // stays in class.\n Map<Node, Set<Node>> forkNbrs = new LinkedHashMap<>();\n for (List<Node> p : allPaths) {\n if (!isActiveGivenS(stamped, p, S)) continue;\n for (int i = 1; i < p.size() - 1; i++) {\n Node a = p.get(i - 1), m = p.get(i), c = p.get(i + 1);\n if (S.contains(m)) continue;\n if (stamped.isDefCollider(a, m, c)) continue;\n forkNbrs.computeIfAbsent(m, k -> new LinkedHashSet<>()).add(a);\n forkNbrs.get(m).add(c);\n }\n }\n\n for (Map.Entry<Node, Set<Node>> en : forkNbrs.entrySet()) {\n Node m = en.getKey();\n if (invariantAncestorOfS(pag, m, S)) continue;\n\n List<Assign> assigns = new ArrayList<>();\n boolean feasible = true;\n for (Node w : en.getValue()) {\n if (!slotCanBe(pag, pins, w, m, Endpoint.ARROW, relaxed)) {\n feasible = false;\n break;\n }\n assigns.add(new Assign(w, m, Endpoint.ARROW));\n }\n if (feasible && !assigns.isEmpty()) out.add(new CoverMove(assigns));\n }\n\n return dedupMoves(out);\n }\n\n /**\n * Drops moves with an identical assignment set (the aggregate fork-flip coincides with the\n * per-path collider-ization whenever the fork lies on exactly one active path); duplicates\n * are harmless but would spend budget re-deriving the same state.\n */\n private List<CoverMove> dedupMoves(List<CoverMove> moves) {\n Set<String> seen = new HashSet<>();\n List<CoverMove> out = new ArrayList<>();\n for (CoverMove mv : moves) {\n List<String> toks = new ArrayList<>();\n for (Assign a : mv.assigns()) toks.add(slotKey(a.from(), a.at()) + \"=\" + a.end());\n Collections.sort(toks);\n if (seen.add(String.join(\"|\", toks))) out.add(mv);\n }\n return out;\n }\n\n /**\n * A de-collider-ize move: tail at m on far--m, with the legal-shape companion arrowhead\n * at the far end when needed (see {@link #coverMoves}, family 3). Adds nothing when\n * infeasible.\n */\n private void addTailMove(Graph pag, Graph cand, Map<String, Endpoint> pins, Node far, Node m,\n List<CoverMove> out) {\n addTailMove(pag, cand, pins, far, m, out, false);\n }\n\n private void addTailMove(Graph pag, Graph cand, Map<String, Endpoint> pins, Node far, Node m,\n List<CoverMove> out, boolean relaxed) {\n if (!slotCanBe(pag, pins, far, m, Endpoint.TAIL, relaxed)) return;\n\n List<Assign> assigns = new ArrayList<>();\n assigns.add(new Assign(far, m, Endpoint.TAIL));\n\n if (cand.getEndpoint(m, far) == Endpoint.TAIL) {\n if (!slotCanBe(pag, pins, m, far, Endpoint.ARROW, relaxed)) return; // tail--tail illegal\n assigns.add(new Assign(m, far, Endpoint.ARROW));\n }\n\n out.add(new CoverMove(assigns));\n }\n\n /**\n * True iff the endpoint at {@code at} on the edge {@code from}--{@code at} may be assigned\n * {@code want}: the PAG's mark there is a circle or already {@code want}, and no pin says\n * otherwise.\n */\n private boolean slotCanBe(Graph pag, Map<String, Endpoint> pins, Node from, Node at, Endpoint want) {\n return slotCanBe(pag, pins, from, at, want, false);\n }\n\n /**\n * True iff the endpoint at {@code at} on the edge {@code from}--{@code at} may be assigned\n * {@code want}. Normally the PAG's non-circle marks are treated as invariants of the class\n * and frozen; under {@code relaxed} that restriction is lifted and only Phase A's\n * stamp-compatibility pins constrain the slot.\n * <p>\n * The relaxation exists because the freeze is only as sound as the PAG. A true PAG's tails\n * and arrowheads hold in EVERY class member, so freezing them loses nothing -- but the\n * interim PAGs here come from {@code MagToPag}, and at least one of them over-commits: in\n * PKE8's V3--V7 class the PAG carries V4 --> V7 while a MAG verified Markov-equivalent\n * to the Zhang MAG (zero m-separation differences over all pairs and conditioning sets)\n * carries V7 <-> V4. Freezing that tail put the only witness outside the search space\n * entirely, which is why the DFS reported no moves at all. The staged search never meets\n * this because LegEnumerator walks MAG space from the Zhang MAG and never consults PAG\n * marks as constraints.\n * <p>\n * Relaxation costs nothing in soundness: class membership is still certified by MagToPag\n * equality at emission and every candidate still passes the same gates. It is applied only\n * as a fallback, when the frozen search yields no move at all, so the common case keeps the\n * smaller space.\n */\n private boolean slotCanBe(Graph pag, Map<String, Endpoint> pins, Node from, Node at, Endpoint want,\n boolean relaxed) {\n if (!relaxed) {\n Endpoint e = pag.getEndpoint(from, at);\n if (e != Endpoint.CIRCLE && e != want) return false;\n }\n Endpoint pinned = pins.get(slotKey(from, at));\n return pinned == null || pinned == want;\n }\n\n /**\n * True iff the PAG's INVARIANT directed edges alone certify m in An(S): a directed path\n * m --> ... --> s for some s in S using only edges with a tail at the source and an\n * arrowhead at the target in the PAG. Such ancestry holds in EVERY member of the class, so\n * a collider at m can never block for any candidate this generator produces.\n */\n private boolean invariantAncestorOfS(Graph pag, Node m, Set<Node> S) {\n Deque<Node> queue = new ArrayDeque<>();\n Set<Node> seen = new HashSet<>();\n queue.add(m);\n seen.add(m);\n\n while (!queue.isEmpty()) {\n Node cur = queue.removeFirst();\n if (!cur.equals(m) && S.contains(cur)) return true;\n\n for (Node w : pag.getAdjacentNodes(cur)) {\n if (seen.contains(w)) continue;\n if (pag.getEndpoint(w, cur) == Endpoint.TAIL\n && pag.getEndpoint(cur, w) == Endpoint.ARROW) { // cur --> w invariant\n seen.add(w);\n queue.addLast(w);\n }\n }\n }\n\n return false;\n }\n\n /**\n * Applies a move, recording prior endpoints so {@link #undoMove} can restore them.\n * <p>\n * Deliberately does NOT pin the slots it assigns. The pin map carries only the HARD\n * constraints of the subproblem -- the PAG's invariant marks (consulted directly) and\n * Phase A's stamp-compatibility requirements -- and a move's own assignment is not one of\n * those: it is a hypothesis the search may need to revise. Pinning moves made them\n * irreversible within a branch and so blocked repairs from undoing them, which is exactly\n * how PKE8's V4--V5 family stalled: a cover move cut V2--V5 to bidirected and pinned the\n * arrowhead, the stamp then minted an inducing path over the nonadjacent pair (V2,V4),\n * and the one repair that fixes it -- relaxing that same arrowhead to a tail, i.e. the\n * reversal the staged search's winning LEG performs -- was refused by the move's own pin.\n * Termination does not depend on these pins: depth is bounded by the move budget and\n * separating states are deduplicated by {@code magKey}.\n */\n private void applyMove(Graph cand, Map<String, Endpoint> pins, CoverMove mv,\n List<Endpoint> saved, List<String> addedPins) {\n for (Assign a : mv.assigns()) {\n saved.add(cand.getEndpoint(a.from(), a.at()));\n cand.setEndpoint(a.from(), a.at(), a.end());\n }\n }\n\n /**\n * Undoes a move in reverse order and releases only the pins it added.\n */\n private void undoMove(Graph cand, Map<String, Endpoint> pins, CoverMove mv,\n List<Endpoint> saved, List<String> addedPins) {\n for (int i = mv.assigns().size() - 1; i >= 0; i--) {\n Assign a = mv.assigns().get(i);\n cand.setEndpoint(a.from(), a.at(), saved.get(i));\n }\n for (String k : addedPins) {\n pins.remove(k);\n }\n }\n\n /**\n * Simple x..y paths in the (class-invariant) skeleton, bounded in length and count,\n * shortest first so cover moves target cheap paths early. Marks-blind: whether a path is\n * BLOCKED is a property of the candidate, so activity is judged per-candidate by\n * {@link #firstActivePath}; the enumeration here fixes only the universe of paths the\n * covering heuristic can see.\n */\n private List<List<Node>> boundedSkeletonPaths(Graph g, Node x, Node y, int maxLen, int maxPaths) {\n List<List<Node>> out = new ArrayList<>();\n Deque<Node> path = new ArrayDeque<>();\n Set<Node> onPath = new HashSet<>();\n path.addLast(x);\n onPath.add(x);\n skeletonDfs(g, x, y, maxLen, maxPaths, path, onPath, out);\n out.sort(Comparator.<List<Node>>comparingInt(List::size));\n return out;\n }\n\n private void skeletonDfs(Graph g, Node cur, Node y, int maxLen, int maxPaths,\n Deque<Node> path, Set<Node> onPath, List<List<Node>> out) {\n if (out.size() >= maxPaths) return;\n\n if (cur.equals(y)) {\n if (path.size() >= 3) out.add(new ArrayList<>(path)); // exclude the direct edge\n return;\n }\n\n if (path.size() > maxLen) return;\n\n for (Node next : g.getAdjacentNodes(cur)) {\n if (onPath.contains(next)) continue;\n path.addLast(next);\n onPath.add(next);\n skeletonDfs(g, next, y, maxLen, maxPaths, path, onPath, out);\n onPath.remove(next);\n path.removeLast();\n if (out.size() >= maxPaths) return;\n }\n }\n\n /**\n * The first enumerated path that is m-connecting given S in {@code probe} (the stamped\n * candidate minus the edge), or null if all are blocked.\n */\n private List<Node> firstActivePath(Graph probe, List<List<Node>> paths, Set<Node> S) {\n for (List<Node> p : paths) {\n if (isActiveGivenS(probe, p, S)) return p;\n }\n return null;\n }\n\n // ================== END CLOSURE-COVER WITNESS SEARCH ==================\n\n // ==================== GUIDED WITNESS CONSTRUCTION ====================\n //\n // A third CANDIDATE GENERATOR behind the SAME commit gates. See the javadoc at\n // {@link #useGuidedConstruction} for the full rationale; in one line: search over\n // RESTRICTED PAGs (committed circle orientations) with R1/R2 propagation and in-class\n // pruning after every move, so a hosting representative is CONSTRUCTED from the blocking\n // requirements the deletion imposes, never found by enumerating the class.\n //\n // Per (x, y, S): every x..y skeleton path must be blocked by S in the witness minus the\n // edge. The blocking options at an interior node are exactly the expert's: an S-node must\n // be a definite non-collider (a tail at it on a path edge), a non-S node blocks only as a\n // definite collider with no possibly-directed route into S. Each option is a small mark\n // commitment on the restricted PAG; propagation then commits everything the choice\n // entails and the consistency checks refuse choices no class member can realize. A state\n // in which every enumerated path is DEFINITELY blocked by committed marks alone is\n // completed to a MAG by zhangMagFromPag -- the untouched circles resolved coherently with\n // the commitments -- confirmed exactly, certified in-class by MagToPag equality, and\n // handed to closureGateAndCommit.\n //\n // Proved-vs-conjectured ledger: the collider filter, the propagation-conflict prune, and\n // the consistency prunes are all SOUND (each violated condition fails in every class\n // member consistent with the branch); their incompleteness costs only wasted branches.\n // Nothing here changes what is certified or committed.\n\n /**\n * Guided-construction replacement for {@link #tryToModifyGraph}: same contract, same\n * gates, different candidate generator. Stage 1 (the plain Zhang MAG) is preserved\n * verbatim and counted in {@code zhangCommits}, so the common case costs what it costs\n * today and the provenance ledger stays comparable across generators.\n * <p>\n * ESCAPE mode is delegated to the legacy path: this generator is in-class by design\n * (it never orients against the PAG's invariant marks and prunes new unshielded\n * colliders), so it has nothing to offer pass 3.\n */\n private boolean tryToModifyGraphGuided(Node x, Node y, Set<Node> b, double pValue,\n boolean excludeSelectionBias, boolean escape)\n throws InterruptedException {\n if (escape) {\n return legacyTryToModify(x, y, b, pValue, excludeSelectionBias, true);\n }\n\n Edge _edge = interimPags.getLast().getEdge(x, y);\n Graph _pag = new EdgeListGraph(interimPags.getLast());\n List<Edge> _removed = Collections.singletonList(Objects.requireNonNull(_edge));\n\n final long deadline = (timeout < 0L) ? Long.MAX_VALUE : System.currentTimeMillis() + timeout;\n\n Graph base = GraphTransforms.zhangMagFromPag(_pag);\n Graph basePag = new MagToPag(base).convert(false, excludeSelectionBias);\n\n // Stage 1: the canonical Zhang MAG, exactly as the other generators try it first.\n if (closureGateAndCommit(new EdgeListGraph(base), x, y, b, pValue, excludeSelectionBias,\n _removed, _edge, () -> zhangCommits++) == GateStatus.COMMITTED) {\n return true;\n }\n\n // Restricted-PAG state: the interim PAG's own marks. Stamp-compatibility TAILs are\n // committed as marks (so propagation sees their consequences up front); the stamp's\n // own arrowheads are held as PINS only, never committed -- classification is\n // pre-stamp, exactly as in the closure search.\n Graph W = new EdgeListGraph(_pag);\n Map<String, Endpoint> pins = new HashMap<>();\n applyStampCompatPinsGuided(_pag, base, W, pins, x, y, b);\n\n boolean committed = false;\n\n List<Object[]> trail0 = new ArrayList<>();\n boolean rootOk = guidedPropagate(W, pins, trail0);\n if (rootOk && !guidedNoNewColliders(W, _pag)) {\n guidedClassPrunes++;\n rootOk = false;\n }\n if (rootOk && W.paths().existsDirectedCycle()) {\n guidedCyclePrunes++;\n rootOk = false;\n }\n\n if (rootOk) {\n List<List<Node>> paths = boundedSkeletonPaths(_pag, x, y, closureMaxPathLength, closureMaxPaths);\n int budget = (maxCoverMoves >= 0) ? maxCoverMoves : autoBudget(_pag, paths);\n\n Set<String> visited = new HashSet<>();\n Set<String> leafTried = new HashSet<>();\n // NOTE: the Stage-1 Zhang key is deliberately NOT pre-seeded. When the root state\n // is already all-def-blocked its completion IS the Zhang MAG, and re-adjudicating\n // it here is what lets the m-sep confirm fail visibly so a counterexample path\n // (one beyond the enumeration bounds) can be extracted and targeted. Pre-seeding\n // silently deduplicated that leaf and dead-ended the whole search (the 15:3+3\n // X11--X17 miss that motivated the counterexample loop).\n int[] leafBudget = {guidedMaxLeaves < 0 ? Integer.MAX_VALUE : guidedMaxLeaves};\n\n committed = guidedDfs(W, pins, paths, budget, _pag, basePag, x, y, b, pValue,\n excludeSelectionBias, _removed, _edge, visited, leafTried, leafBudget, deadline);\n }\n\n if (!committed && guidedFallbackToLegacy) {\n // Same shape as closureFallbackToStaged: nothing has been mutated at this point\n // (interimPags and sepsets are touched only via closureGateAndCommit, which runs\n // only on success), so the legacy generator sees exactly the state it would have\n // seen had it run alone.\n guidedFallbackAttempts++;\n committed = legacyTryToModify(x, y, b, pValue, excludeSelectionBias, false);\n if (committed) guidedFallbackCommits++;\n }\n\n if (!committed && verbose) {\n TetradLogger.getInstance().log(\"\\tGuided construction: no candidate hosted \" + _edge\n + \", sepset = \" + b);\n }\n\n return committed;\n }\n\n /**\n * The generator the guided search defers to: closure-cover when\n * {@link #useClosureCoverSearch} is set, else the staged / class-walk search.\n */\n private boolean legacyTryToModify(Node x, Node y, Set<Node> b, double pValue,\n boolean excludeSelectionBias, boolean escape)\n throws InterruptedException {\n return useClosureCoverSearch\n ? tryToModifyGraphClosure(x, y, b, pValue, excludeSelectionBias, escape)\n : tryToModifyGraph(x, y, b, pValue, excludeSelectionBias, escape);\n }\n\n /**\n * Guided analog of {@link #applyStampCompatPins}. Two deliberate differences: the\n * okWithArrow probe reads the ZHANG MAG (as the original reads its Zhang-seeded\n * candidate -- probing the restricted PAG instead would pin TAIL far too often, the\n * over-tight-pin failure documented at the original), while the compat TAILs are\n * committed INTO the restricted PAG so propagation can derive their consequences\n * immediately rather than discovering them one refused branch at a time.\n */\n private void applyStampCompatPinsGuided(Graph pag, Graph base, Graph W, Map<String, Endpoint> pins,\n Node x, Node y, Set<Node> b) {\n List<Node> common = pag.getAdjacentNodes(x);\n common.retainAll(pag.getAdjacentNodes(y));\n\n for (Node c : common) {\n if (b.contains(c)) continue; // not stamped; no requirement\n if (pag.isDefCollider(x, c, y)) continue; // stamp is a no-op here\n\n pins.putIfAbsent(slotKey(x, c), Endpoint.ARROW);\n pins.putIfAbsent(slotKey(y, c), Endpoint.ARROW);\n\n for (Node d : pag.getAdjacentNodes(c)) {\n if (d == x || d == y) continue;\n\n boolean unshX = !pag.isAdjacentTo(d, x);\n boolean unshY = !pag.isAdjacentTo(d, y);\n if (!unshX && !unshY) continue;\n\n boolean okWithArrow = (!unshX || base.getEndpoint(x, c) == Endpoint.ARROW)\n && (!unshY || base.getEndpoint(y, c) == Endpoint.ARROW);\n if (okWithArrow) continue;\n\n Endpoint atC = pag.getEndpoint(d, c);\n\n if (atC == Endpoint.ARROW) {\n // Invariant arrowhead: recorded as evidence, adjudicated by the gate.\n guidedStampObstructions++;\n } else if (atC == Endpoint.CIRCLE) {\n if (W.getEndpoint(d, c) == Endpoint.CIRCLE) {\n W.setEndpoint(d, c, Endpoint.TAIL);\n pins.putIfAbsent(slotKey(d, c), Endpoint.TAIL);\n }\n }\n // atC == TAIL: invariant tail already satisfies the requirement.\n }\n }\n }\n\n /**\n * The construction DFS. At each node: find the first enumerated path NOT definitely\n * blocked by committed marks alone; branch on the blocking commitments that could close\n * it; propagate and consistency-check each; recurse. A state with no open path is\n * completed, confirmed, certified, and gated.\n */\n private boolean guidedDfs(Graph W, Map<String, Endpoint> pins, List<List<Node>> paths, int movesLeft,\n Graph pag, Graph basePag, Node x, Node y, Set<Node> b, double pValue,\n boolean excludeSelectionBias, List<Edge> removed, Edge edgeForLog,\n Set<String> visited, Set<String> leafTried, int[] leafBudget, long deadline)\n throws InterruptedException {\n if (Thread.currentThread().isInterrupted()) {\n throw new InterruptedException();\n }\n if (System.currentTimeMillis() > deadline) return false;\n if (leafBudget[0] <= 0) return false;\n\n // Restricted states recur across move orders; explore each once.\n if (!visited.add(magKey(W))) return false;\n\n List<Node> open = firstOpenPath(W, paths, x, y, b);\n\n while (open == null) {\n // Every enumerated path is DEFINITELY blocked by committed marks alone -- blocked\n // in every completion of W, so the completion below cannot un-block one. But the\n // ENUMERATION is bounded: the completion may still be m-connected over a path the\n // enumeration never saw. When the exact confirm below fails, that path is\n // extracted from the completion and appended to the universe (a def-blocked\n // verdict on the committed marks would contradict its activity in a completion,\n // so it is guaranteed open), and the search resumes here with moves that can\n // finally target it. Progress: each pass through this loop either returns or\n // spends leaf budget on a new completion key.\n leafBudget[0]--;\n if (leafBudget[0] < 0) return false;\n\n Graph cand = guidedComplete(W, excludeSelectionBias);\n if (!leafTried.add(magKey(cand))) {\n guidedLeafDedups++;\n return false;\n }\n guidedLeavesEmitted++;\n\n // Exact confirmation (an active path beyond the enumeration bounds would\n // otherwise slip through), then legality, then class certification, then gates.\n Graph probe = new EdgeListGraph(cand);\n probe.removeEdge(x, y);\n if (!new MsepTest(probe).checkIndependence(x, y, b).isIndependent()) {\n guidedLeafMisseps++;\n List<Node> witness = activeSimplePath(probe, x, y, b);\n if (witness == null || containsPath(paths, witness)) {\n return false; // extraction cap hit, or no genuinely new path: dead end\n }\n paths.add(witness);\n guidedCounterexamplePaths++;\n open = firstOpenPath(W, paths, x, y, b);\n continue;\n }\n\n if (!cand.paths().isLegalMag()) {\n guidedLeafIllegal++;\n return false;\n }\n\n boolean inClass = new MagToPag(new EdgeListGraph(cand))\n .convert(false, excludeSelectionBias).equals(basePag);\n if (!inClass) {\n guidedLeafOffClass++;\n return false;\n }\n\n GateStatus st = closureGateAndCommit(cand, x, y, b, pValue, excludeSelectionBias,\n removed, edgeForLog, () -> guidedCommits++);\n if (st == GateStatus.COMMITTED) return true;\n\n guidedLeafGateRefusals++;\n return false;\n }\n\n if (movesLeft == 0) return false;\n\n List<CoverMove> moves = guidedMoves(W, pag, pins, open, paths, x, y, b);\n\n for (CoverMove mv : moves) {\n boolean noop = true;\n for (Assign a : mv.assigns()) {\n if (W.getEndpoint(a.from(), a.at()) != a.end()) {\n noop = false;\n break;\n }\n }\n if (noop) continue;\n\n List<Object[]> trail = new ArrayList<>();\n boolean ok = true;\n for (Assign a : mv.assigns()) {\n if (!guidedSet(W, pins, a.from(), a.at(), a.end(), trail)) {\n ok = false;\n break;\n }\n }\n\n if (ok && !guidedPropagate(W, pins, trail)) {\n guidedPropagationPrunes++;\n ok = false;\n }\n if (ok && !guidedNoNewColliders(W, pag)) {\n guidedClassPrunes++;\n ok = false;\n }\n if (ok && W.paths().existsDirectedCycle()) {\n guidedCyclePrunes++;\n ok = false;\n }\n\n boolean done = ok && guidedDfs(W, pins, paths, movesLeft - 1, pag, basePag, x, y, b,\n pValue, excludeSelectionBias, removed, edgeForLog, visited, leafTried,\n leafBudget, deadline);\n\n for (int i = trail.size() - 1; i >= 0; i--) {\n Object[] t = trail.get(i);\n W.setEndpoint((Node) t[0], (Node) t[1], (Endpoint) t[2]);\n }\n\n if (done) return true;\n }\n\n return false;\n }\n\n /**\n * Commits a single mark on the restricted PAG, recording the prior value on the trail.\n * Only circles may be filled: an attempt to overwrite any committed or invariant mark, or\n * to contradict a stamp pin, reports failure -- during propagation that failure IS the\n * expert's contradiction (\"that choice would force an arrowhead where the class has a\n * tail\"), and the branch is abandoned.\n */\n private boolean guidedSet(Graph W, Map<String, Endpoint> pins, Node from, Node at, Endpoint want,\n List<Object[]> trail) {\n Endpoint cur = W.getEndpoint(from, at);\n if (cur == want) return true;\n if (cur != Endpoint.CIRCLE) return false;\n\n Endpoint pin = pins.get(slotKey(from, at));\n if (pin != null && pin != want) return false;\n\n trail.add(new Object[]{from, at, cur});\n W.setEndpoint(from, at, want);\n guidedPropagatedMarks++;\n return true;\n }\n\n /**\n * Sound, PARTIAL propagation of class-membership consequences on the restricted PAG:\n * Zhang's R1 and R2 to fixpoint, every assignment trailed for undo, every conflict\n * reported. R1 is exactly the \"no new unshielded collider\" constraint made productive\n * (a*->m o-* c unshielded forces m -> c); R2 is ancestrality (chains force\n * arrowheads). No R3/R4/R8-R10 and no discriminating-path reasoning: missing propagation\n * costs only wasted branches, never a wrong commit -- class membership is certified at\n * the leaf regardless.\n */\n private boolean guidedPropagate(Graph W, Map<String, Endpoint> pins, List<Object[]> trail) {\n boolean changed = true;\n\n while (changed) {\n changed = false;\n\n // R1: a*->m o-* c, a and c nonadjacent ==> m --> c.\n for (Node m : W.getNodes()) {\n List<Node> adj = W.getAdjacentNodes(m);\n for (Node a : adj) {\n if (W.getEndpoint(a, m) != Endpoint.ARROW) continue;\n for (Node c : adj) {\n if (c == a) continue;\n if (W.isAdjacentTo(a, c)) continue;\n if (W.getEndpoint(c, m) != Endpoint.CIRCLE) continue;\n\n if (!guidedSet(W, pins, c, m, Endpoint.TAIL, trail)) return false;\n if (!guidedSet(W, pins, m, c, Endpoint.ARROW, trail)) return false;\n changed = true;\n }\n }\n }\n\n // R2: (a --> m *-> c) or (a *-> m --> c), a *-o c ==> a *-> c.\n for (Node m : W.getNodes()) {\n List<Node> adj = W.getAdjacentNodes(m);\n for (Node a : adj) {\n for (Node c : adj) {\n if (c == a) continue;\n if (!W.isAdjacentTo(a, c)) continue;\n if (W.getEndpoint(a, c) != Endpoint.CIRCLE) continue;\n\n boolean form1 = W.getEndpoint(a, m) == Endpoint.ARROW\n && W.getEndpoint(m, a) == Endpoint.TAIL\n && W.getEndpoint(m, c) == Endpoint.ARROW;\n boolean form2 = W.getEndpoint(a, m) == Endpoint.ARROW\n && W.getEndpoint(m, c) == Endpoint.ARROW\n && W.getEndpoint(c, m) == Endpoint.TAIL;\n\n if (form1 || form2) {\n if (!guidedSet(W, pins, a, c, Endpoint.ARROW, trail)) return false;\n changed = true;\n }\n }\n }\n }\n }\n\n return true;\n }\n\n /**\n * No unshielded triple may be a definite collider in the restricted PAG unless it is one\n * in the interim PAG: unshielded colliders are class invariants, so a new one fails in\n * every class member consistent with the branch. Necessary only; sufficiency is the\n * leaf's MagToPag certification.\n */\n private boolean guidedNoNewColliders(Graph W, Graph pag) {\n for (Node m : W.getNodes()) {\n List<Node> adj = W.getAdjacentNodes(m);\n for (int i = 0; i < adj.size(); i++) {\n for (int j = i + 1; j < adj.size(); j++) {\n Node a = adj.get(i), c = adj.get(j);\n if (W.isAdjacentTo(a, c)) continue;\n if (W.isDefCollider(a, m, c) && !pag.isDefCollider(a, m, c)) return false;\n }\n }\n }\n return true;\n }\n\n /**\n * First enumerated path NOT definitely blocked by committed marks alone. The 2-node path\n * is the deleted edge itself and never counts.\n */\n private List<Node> firstOpenPath(Graph W, List<List<Node>> paths, Node x, Node y, Set<Node> S) {\n for (List<Node> p : paths) {\n if (p.size() <= 2) continue;\n if (!isDefBlockedGivenS(W, p, x, y, S)) return p;\n }\n return null;\n }\n\n /**\n * A simple m-connecting x..y path given S in {@code probe} (a MAG with the x--y edge\n * already removed), or null if the expansion cap is hit first. Used only for\n * counterexample extraction after an exact m-separation confirm has FAILED, so a\n * connecting path is known to exist; the cap is a defensive bound, not a completeness\n * bound. Standard per-triple activity: a collider on the path is active iff it has a\n * descendant in S (itself included); a non-collider is active iff it is outside S.\n * If an active walk exists, an active simple path exists, so the simple-path DFS is\n * exhaustive in principle.\n */\n private List<Node> activeSimplePath(Graph probe, Node x, Node y, Set<Node> S) {\n Deque<Node> path = new ArrayDeque<>();\n Set<Node> onPath = new HashSet<>();\n path.addLast(x);\n onPath.add(x);\n int[] steps = {200_000};\n List<Node> out = activeSimplePathDfs(probe, x, y, S, path, onPath, steps);\n return (out != null && out.size() >= 3) ? out : null;\n }\n\n private List<Node> activeSimplePathDfs(Graph probe, Node cur, Node y, Set<Node> S,\n Deque<Node> path, Set<Node> onPath, int[] steps) {\n if (--steps[0] < 0) return null;\n\n for (Node next : probe.getAdjacentNodes(cur)) {\n if (onPath.contains(next)) continue;\n\n // The triple (prev, cur, next) must be active before extending through cur.\n if (path.size() >= 2) {\n Iterator<Node> it = path.descendingIterator();\n it.next(); // cur\n Node prev = it.next();\n boolean collider = probe.getEndpoint(prev, cur) == Endpoint.ARROW\n && probe.getEndpoint(next, cur) == Endpoint.ARROW;\n boolean active = collider\n ? hasDescendantIn(probe, cur, S)\n : !S.contains(cur);\n if (!active) continue;\n }\n\n path.addLast(next);\n onPath.add(next);\n if (next.equals(y)) {\n List<Node> found = new ArrayList<>(path);\n onPath.remove(next);\n path.removeLast();\n return found;\n }\n List<Node> found = activeSimplePathDfs(probe, next, y, S, path, onPath, steps);\n onPath.remove(next);\n path.removeLast();\n if (f"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":1825,"numItemsPerPage":100,"numTotalItems":835100,"offset":182500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sInJlcG9JZHMiOlsiNmFiODVhOGYzODBjYmQ4YzAzYWQ5MjY3Il0sImlhdCI6MTc5NDA0ODg5MiwianRpIjoiMzE5OWVlZTctOGMyZi00NjdkLTkzMTAtMTFhZDliMmI1ZDU4Iiwic3ViIjoiL2RhdGFzZXRzL09wZW5TY2llbnRpZmljQ29kZVJlZ2lzdHJ5L0RhdGFiYXNlIiwiZXhwIjoxNzk0MDUyNDkyLCJpc3MiOiJodHRwczovL2h1Z2dpbmdmYWNlLmNvIn0.wCSaFPaMtHXwd1H1N_fqsR9ow-QaMQT11qu75_9zFF8d3vk-D7gTEQwQM1FHin1b-h0qRPY3moneFMHXT26oBw","displayUrls":true,"splitSizeSummaries":[{"config":"scripts","split":"train","numRows":835100,"numBytesParquet":1400428785}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
sha256 stringlengths 64 64 | language stringclasses 28
values | size int32 1 491k | lines int32 1 23.2k | content stringlengths 1 200k |
|---|---|---|---|---|
c48dfdcb63cfff6c3a33eb2998b9069fad372f72a2f13c36bd938070859fe48f | Java | 57,078 | 1,377 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
fa2eb391164c829c3cc68dd8d9c9a20fcd7af69acf4d6b2d68187eeb08a048b9 | Java | 57,712 | 1,247 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
3b72ede803d28867682cd37616520ec71da5eb480fddaa08b99d7c7b944cd540 | Java | 58,069 | 1,587 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
8c03c65c89a3a8fd788c752463543b5fe83a3df4fd0ab6f1b7bda759ed1aaa6c | Java | 58,398 | 1,651 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
fa2d83cd25538c445db320f4f66ffcaf4464a2725e2c80234fb2c0b798e8da3f | Java | 58,483 | 1,336 | package edu.cmu.tetrad.search;/*
* Cord.java -- Faithful single-file Java port of CORD (Orthogonal Rank-Score
* Conditional Independence Test) for H0: Y _||_ Z | X.
*
* This is a dependency-free (pure JDK, Java 8+) port of the Python reference
* `cord.py` (numpy + scipy + scikit-learn). It reproduces the CORD alg... |
c1dcd450b2455d18da67d6963dbfb4186dc0b4b5f629760542e4e6d9d5d5a2ab | Java | 58,506 | 1,490 | package edu.cmu.tetrad.search.utils;
import org.apache.commons.math3.distribution.ChiSquaredDistribution;
import org.apache.commons.math3.distribution.FDistribution;
import org.apache.commons.math3.distribution.TDistribution;
import org.apache.commons.math3.stat.inference.TTest;
import java.util.*;
import edu.cmu.te... |
6e86663e71eeabfe23c107c62f378c4cbb78bd75d72add3066bbd35c815c91e4 | Java | 58,614 | 1,198 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
27e6af604653b1e9283e0be327636f24cc7fa34b39cfc53a675369e45e1a9722 | Java | 58,719 | 1,061 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator11.java (parallel, PAG-space, end-to-end FcitSl) //
// //
// PKE11 = PKE8's QUESTION over PKE10's POPULATION. ... |
202f141e54311adc6d7d67e4014d364ba322e3f7d31d115d566a97eb5e66ab22 | Java | 58,990 | 1,749 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
af0f5421c0b3e7263a4ac57aa67c8f5916c6f873f0b0f7e823e42f87e148bdc4 | Java | 59,008 | 1,506 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2026 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
21a49ccd64cccbc4fd15dc1d54141e956f503e984241b02bac21ac23c074a882 | Java | 59,044 | 1,352 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
116b176d0d14e06b26c7145f2e9b83bb8a5897d49da34c31ef15042c63b82915 | Java | 59,325 | 1,072 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator12.java (parallel, PAG-space, end-to-end Fcit) //
// //
// pke12 = PKE8's QUESTION over PKE10's POPULATION. ... |
0468d6a7a013064cad3ca9f50d7cf8a9ef7ad4adb3e5aa9ee3406973bed6deba | Java | 59,842 | 1,099 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
81a0d1c8f39e965dc1ee3781fe8ddc7600033814a914bc0ef8ab53dcb7e5650f | Java | 59,990 | 1,405 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
838fcc1facf86938b23bd4cf6ee78bbcdc78ae864c61e7b86180aff65b0abeda | Java | 60,016 | 1,424 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
5546147eac87f924bfeec1bf56ff8097a50e6f05bb62158b3ada0462f7632b7d | Java | 60,583 | 1,089 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator14.java (parallel, PAG-space, end-to-end FcitZm) //
// //
// pke14 = pke12's QUESTION and POPULATION, with FcitZm under test. ... |
0ca373031891a9c0ff5c5b94d9b449618f2e1768184dc040a4846a714196386b | Java | 60,584 | 1,345 | package edu.cmu.tetrad.search;/*
* Cord.java -- Faithful single-file Java port of CORD (Orthogonal Rank-Score
* Conditional Independence Test) for H0: Y _||_ Z | X.
*
* This is a dependency-free (pure JDK, Java 8+) port of the Python reference
* `cord.py` (numpy + scipy + scikit-learn). It reproduces the CORD alg... |
afe76d094119e166bafbd786169021fc6251152f594c5edae78689500d2ef95e | Java | 61,162 | 1,387 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
aa8ef2e18bfa7dbe4243d4aba0e80e76ecca264cd563ac5c1fc852e2f785d902 | Java | 61,561 | 1,386 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
89545aa1b873c64589b791a844dca32ca13bce34330523b8961df9f2254be95d | Java | 62,148 | 1,104 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator13.java (parallel, PAG-space, end-to-end GraspFci) //
// //
// pke13 = pke12 (PKE8's QUESTION over PKE10's POPULATION) with the SEARC... |
8a6b56dbad5f62547442a5831b72b44a08262cbf9289f0567591fb011028893a | Java | 62,257 | 1,610 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
f2981bc25c39104d8e5d59101c233eb470acfaed3d2ae2d83363c0ddeabaf67a | Java | 63,202 | 1,487 | package edu.cmu.tetrad.search;
/*
* CordEngine5.java -- CORD (Orthogonal Rank-Score Conditional Independence Test)
* for H0: Y _||_ Z | X, revision 5.
*
* Engine 5 is to engine 2 what engine 4 is to engine 3: it carries the same
* nuisance-quality and calibration upgrades, but it AGGREGATES AT THE LEVEL OF
* P-VA... |
1252eafb89860ffac54d4bbcd24f3d7217837d5baab0396792997df66c159ba6 | Java | 63,839 | 2,849 |
package libsvm;
import java.io.*;
import java.util.*;
//
// Kernel Cache
//
// l is the number of total data items
// size is the cache size limit in bytes
//
class Cache {
private final int l;
private long size;
private final class head_t
{
head_t prev, next; // a cicular list
float[] data;
int len; /... |
35df4f9862f83dc331e48c045a2b8f25a0189c9b7a97bc1838788f7a5d39b627 | Java | 63,969 | 1,680 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
23966e286710f6300f73836bb8e3d5e4eac0313df25f689767e3d200d32d5ba6 | Java | 64,281 | 1,563 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
4cc7f609e3a4a9aad414ae73c2623d7d8e36c58defe513423973545c815d79bb | Java | 64,601 | 1,498 | package edu.cmu.tetrad.search;
import edu.cmu.tetrad.data.ContinuousVariable;
import edu.cmu.tetrad.data.DataSet;
import edu.cmu.tetrad.data.Knowledge;
import edu.cmu.tetrad.graph.*;
import edu.cmu.tetrad.search.blocks.BlockSpec;
import edu.cmu.tetrad.search.mimic.TrekMeasurementModelBuilderBoss;
import edu.cmu.tetrad... |
a5cc69342ef3a27803361e95a1eb593f7fdec8081f1469eebcdd3630de3e755e | Java | 65,075 | 1,377 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
875836d916fe69842459fa7b2168e938e2b09d17f027999c31da4e1052b0be66 | Java | 65,396 | 1,707 | package edu.cmu.tetrad.search.score;
import edu.cmu.tetrad.data.missing.MissingValueSupport;
import edu.cmu.tetrad.data.DataModel;
import edu.cmu.tetrad.data.DataSet;
import edu.cmu.tetrad.data.DiscreteVariable;
import edu.cmu.tetrad.graph.Node;
import edu.cmu.tetrad.util.EffectiveSampleSizeSettable;
import edu.cmu.te... |
2775d7bc63b1ea6eb696012d2a2f66406f4e457521b497356660f120200c8bb1 | Java | 65,423 | 1,688 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
ee9755afd7db7690eb16d2d388f5900ea6b3a241285e04c61e0680e072d31ff8 | Java | 65,454 | 1,637 | package edu.cmu.tetrad.search.score;
import edu.cmu.tetrad.data.DataModel;
import edu.cmu.tetrad.data.DataSet;
import edu.cmu.tetrad.graph.Node;
import edu.cmu.tetrad.util.EffectiveSampleSizeSettable;
import edu.cmu.tetrad.util.RandomUtil;
import edu.cmu.tetrad.util.TetradLogger;
import edu.cmu.tetrad.util.TMath;
impo... |
612d9128aa6bf21c2f67fc5be12e041e0052c05f771e09b75ce0536f5e018abf | Java | 65,456 | 1,637 | package edu.cmu.tetrad.search.score;
import edu.cmu.tetrad.data.DataModel;
import edu.cmu.tetrad.data.DataSet;
import edu.cmu.tetrad.graph.Node;
import edu.cmu.tetrad.util.EffectiveSampleSizeSettable;
import edu.cmu.tetrad.util.RandomUtil;
import edu.cmu.tetrad.util.TMath;
import edu.cmu.tetrad.util.TetradLogger;
impo... |
8e00f3d7a284e34cdffc6a95148b6f8f9dff92db1621541e07257f2f9581006a | Java | 65,598 | 1,272 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator4.java (parallel, deduplicated, checkpointed) //
// //
// Trimmed successor to PhantomKernelEnumerator2, specialized to the two ... |
b6c2afd4e2efeb071f71a803977821a1e8033529ce707b23b53d7116a7015de3 | Java | 68,121 | 1,496 | package edu.cmu.tetrad.search;
/*
* CordEngine4.java -- CORD (Orthogonal Rank-Score Conditional Independence Test)
* for H0: Y _||_ Z | X, revision 4.
*
* This engine keeps the CORD estimand and the Neyman-orthogonal (doubly
* residualized) score of CordEngine3, but upgrades the cross-fitting design,
* the thresh... |
e341eda8b66a1af32a7223be41f7d7e4f507eb24fad7284ced94c4105183a682 | Java | 69,354 | 1,478 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
37f381fe86a6eed72b36e780cef0d7eebd15a45fe9653589fb136025cc3e0345 | Java | 70,558 | 1,592 | package edu.cmu.tetrad.search;
import edu.cmu.tetrad.graph.Endpoint;
import edu.cmu.tetrad.graph.Graph;
import edu.cmu.tetrad.graph.Node;
import edu.cmu.tetrad.graph.NodeType;
import java.util.*;
import java.util.concurrent.TimeoutException;
/**
* Implements a procedure for constructing candidate separating sets be... |
33668aa48a9594f6f7ac613765c5cd13f871c5fa21155ea3d640dd56d8ad4772 | Java | 71,066 | 1,822 | /// ////////////////////////////////////////////////////////////////////////////
// IndependenceFactsDslEditor.java
//
// A modern replacement for the legacy IndependenceFactsEditor:
// - Free-form DSL in a text area (one template per line)
// - Expands templates using ? (single var wildcard) and + (choose-k conditioni... |
119fd222fc12b7fc90e7d4072dca25caac1af0e8046d7f297abf69061d87ea29 | Java | 71,662 | 1,663 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
f0d8656af9fe9e00b6c70f3157dc15032dd9d501b34bdb112ee2daf6ca667233 | Java | 71,743 | 1,631 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
2c8adb65d6399217e5d6c8ac3ad71d45b81740e76eee5d728359504d67a49336 | Java | 72,852 | 1,422 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2026 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
5e8ef7f9636a0461479b06c4e37ee9cbd1fd1e31fcc1189d185b722075327ef9 | Java | 73,935 | 1,616 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
93dfa85a8b5aaa4367f59d20c82b3043ce72194806a220f1c8d4914a97adbd38 | Java | 77,769 | 2,076 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
475a0292425966deea13a20d21ac784456338522985bdc04fc1403d6d3729724 | Java | 77,787 | 2,045 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
ff09dc9b25fc93bd5fcf4488a0eb8cc060f3eead765102edc5329f8d09e9e387 | Java | 78,332 | 1,615 | package edu.cmu.tetradapp.editor;
import edu.cmu.tetrad.data.ContinuousVariable;
import edu.cmu.tetrad.data.DataSet;
import edu.cmu.tetrad.data.DiscreteVariable;
import edu.cmu.tetrad.data.Histogram;
import edu.cmu.tetrad.graph.Graph;
import edu.cmu.tetrad.graph.Node;
import edu.cmu.tetrad.sem.CVReport;
import edu.cmu... |
7faf2386e975fbcc64dcf4add4629087955f4735ef1afc8b3af7687c95541e3f | Java | 78,366 | 1,589 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator7.java (parallel, deduplicated, checkpointed) //
// //
// PKE7 answers ONE question: does any reachable Markov state exist that th... |
9d87f89f232c6f23ac91cfb66388d6dd9ff9fe82f44afb06a190fb7aa8f26396 | Java | 78,474 | 2,151 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
9cec4c3cdda5d926ec46378f4c9f304e610c872d9353b73945ccd439a659d4fd | Java | 79,893 | 2,002 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
933dc9455c17840dc28697a0c64c9d0ea73f5e76978288f853a37b82c9c63ae8 | Java | 79,956 | 2,005 | package edu.cmu.tetrad.search.score;
import edu.cmu.tetrad.data.missing.MissingValueSupport;
import edu.cmu.tetrad.data.DataModel;
import edu.cmu.tetrad.data.DataSet;
import edu.cmu.tetrad.data.DiscreteVariable;
import edu.cmu.tetrad.graph.Node;
import edu.cmu.tetrad.util.EffectiveSampleSizeSettable;
import edu.cmu.te... |
db0077527c42c01a9078b0941a1ea1818d8d9c2bb941ad1d1713e84ff260e1d6 | Java | 80,211 | 1,920 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
d1351bb55dbed426c769343e4d68e51aafed61ce1fce7bfcab3209119b2cc681 | Java | 80,271 | 2,473 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
3273a0c4eb65deeb256dba485e6a20906f9da82c53ec0f04c7c0fb06aee93470 | Java | 80,273 | 2,049 | package edu.cmu.tetrad.search.score;
import edu.cmu.tetrad.data.missing.MissingValueSupport;
import edu.cmu.tetrad.data.DataModel;
import edu.cmu.tetrad.data.DataSet;
import edu.cmu.tetrad.data.DiscreteVariable;
import edu.cmu.tetrad.graph.Node;
import edu.cmu.tetrad.util.EffectiveSampleSizeSettable;
import edu.cmu.te... |
451190077b0a8ad2df674252bd69a1c7d3fd9f646b51287c1d68264255937188 | Java | 80,760 | 2,260 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
978ee97c6bf6834c49f7f34f347bba3b97d78ed93f541b604d6f25e5b860610c | Java | 81,506 | 1,883 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
e147bec49d6b59908285e528de9b3e6a6f3249d0a4481afde6b3e04c9436e4e9 | Java | 85,136 | 2,284 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
e4958942fe7ff39c2382f6bf2e82ec7ad81ecbe8a4b58db60e80966da2dc1d2c | Java | 85,196 | 2,075 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
b83e48792495c884fca710db403635a0551367ca54b99d70f66eb6cddb6e4db8 | Java | 85,316 | 2,049 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
7e55bda3b035b0a7ff562cf69a3d0675ba5b8194ae0f441900ebb0c990ac197c | Java | 85,769 | 2,416 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
be5b48e28fe73d2b58b0956a130e168d4ebfe7869c9ebde9de2f3cb7d9c4cde5 | Java | 85,901 | 1,900 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
acea86625e343968ad4fd9e7e0a3b4dcda557b6c4551473f4bfd550a7c654576 | Java | 86,946 | 2,040 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
7d1d8cc506c007b0c95089037a2b6b42f9faf3149ac664ecf38b8bb8fa77f6b1 | Java | 87,854 | 2,156 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
1389dafe88f0f8523d08b924596c8351c2a61b7a108500c16086dff582d5b617 | Java | 87,887 | 1,998 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
1d85f33822c1d3cb66f411b34548192a771e6b1b4c2b9e9028b748ba98ba92e5 | Java | 88,183 | 1,681 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
741b3bcbb4b14cbff1792969d0eb28cb609ec6ab97fce28fbce6aeca087ae28a | Java | 88,729 | 2,073 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
a6f5f8a3c67c35aeb3aec11e78eac1f62f7ccdc53432c0acf7f0c68816d66fce | Java | 89,021 | 2,115 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
bd5d9d14398f89a64e66646b19092b599cdf6e5c4d4dbc14e47d267999f002dd | Java | 96,679 | 1,687 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator9.java (parallel) //
// //
// EXHAUSTIVE companion to the RB/FCIT reachability appendix. Enumerates EV... |
74de3d788824196309b007f7ce0e64b9792a3ad3c815f4e0df0ea625e8845466 | Java | 97,318 | 2,168 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
c3e82b61e01d01bca885134ebce08e28aa275d6de00282cbe7a4f757dfc76a4b | Java | 98,318 | 2,576 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
45f195a373819eb783374c3aaad9e47bee055c6dc268ffa7710f863662b125bb | Java | 98,565 | 2,056 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
21e5e0eddf2bb4cd88c57e86b647d6b2c661e70d4376dd3d58a19c3adea49dc4 | Java | 99,518 | 2,214 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
935afe606381b16445af4ae791a9bca0e68e314194c558524660d1393094e41a | Java | 99,903 | 1,904 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
54c7a3e97bd9c9ae527944c4bb39172ce7dc3f96f7c8dfbde8f24db8ba38da6c | Java | 100,643 | 2,281 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
4f5372a0ea160ddc9d8170fc525134a0f9a30bd6ade4e6d2b8796d07cee99a06 | Java | 106,126 | 1,951 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator10.java (parallel, PAG-space) //
// //
// PKE9 enumerated DAG x latent placement. Everything it measures, however,... |
16efa405e0b1b097e6d9d1d912d7fce2f427799b146cdf4cffb0de969bc821bc | Java | 108,981 | 2,844 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
300ef7ce80e90e69f90e452f78f6319428a39cb0e8731af4e654268e326c7b38 | Java | 109,947 | 2,256 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
8cc01d4c42a8873d808f6236cedb57963de6b090ec6d53993dec4685046b3954 | Java | 115,560 | 2,402 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
a3e98d5096a17769870be23060a8b88b5e1ea60d9d54e042a783af8c64d25af4 | Java | 117,629 | 2,880 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
c3e7bc12ca4152d20386eb4623df9a0755908065a77d262c3f4f174c0145d4d3 | Java | 120,145 | 2,983 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
96b0535ff1884c08189826d99f76e4dd9acf633ac792de8ca0cae77728727ead | Java | 120,870 | 1,967 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator.java (parallel) //
// //
// EXHAUSTIVE companion to PhantomCounterexampleHarness. Enumerates EVERY DA... |
9a096a117f5274cd5642775dcf6a60b21cfd7e1e7db09b8962dd10bdd6932a7f | Java | 123,046 | 2,586 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
e315bc990219e7ceeb2c03d4f71b2f8986ae18136f25b832d0c87ac0a7884ad8 | Java | 123,354 | 3,510 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
04d332583d4dbc7befb08b6ab6fa94e010e4acd643edabddc3093ca4519732f5 | Java | 124,293 | 2,626 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
83ab865b129d4de2ba26dc5121cd015d981a89938e5cf466b970dc7c0adda464 | Java | 134,840 | 3,421 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
e309e7f561a810ae22822f857421bd4affd8e61fd33906cb0124283e4e0e4d96 | Java | 142,956 | 2,513 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator5.java (parallel, deduplicated, checkpointed) //
// //
// DIAGNOSTIC successor to PhantomKernelEnumerator4. Same enumeration, ded... |
4767cf1c5ca5d287069894650b5475d8a6bbcc6b8f0bdacbfb440450e8560bf1 | Java | 143,176 | 3,088 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
600dbf0102c187d83db5682c8b4573a539b70d85facbf694f17daf0b881b5002 | Java | 145,497 | 2,450 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator.java (parallel) //
// //
// EXHAUSTIVE companion to PhantomCounterexampleHarness. Enumerates EVERY DA... |
2044a9b79fbc2291746bb89fc28e1440fb6b1b985aa0dc2ed0e28223e3a604d6 | Java | 150,051 | 2,808 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
fed8334163dd7c5301437742fa2e57811969ad72de4bbb80f37bd56980bde26a | Java | 153,035 | 2,639 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator.java (parallel) //
// //
// EXHAUSTIVE companion to PhantomCounterexampleHarness. Enumerates EVERY DA... |
6b3528136b31ce8592613379bef0f4ce02154eee153fee0c785ed8c68ec8a7b5 | Java | 154,029 | 3,097 | ///////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2026 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //
... |
879c4e86ebb8703af03bf16a53d5ad86f6be31d606731225c0b7314f4974a9d5 | Java | 162,155 | 4,598 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
5b3ad69452fdf3bc7e5941d5c5737f3b8a37ccce8b116e3798eecd065f4438d6 | Java | 168,242 | 3,597 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
851f0807115cd523520d70b1a5980166ffa101676ec49526bdb69e242ef9773f | Java | 169,424 | 4,516 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
3a55d8abb2a66d19f8987b613932d4dc71d1a64dea8041ccb7fb0ce0b6e30f90 | Java | 170,865 | 2,985 | /// ////////////////////////////////////////////////////////////////////////////
// PhantomKernelEnumerator6.java (parallel, deduplicated, checkpointed) //
// //
// PKE6 = PKE5 + the STEP-LEMMA (A)-vs-(B) AUDIT at every gated I-map H0 ... |
2fee3ed7d6f87e842bd177a8be702cb983b9bd669b7a0a090fd407855518bc05 | Java | 177,637 | 3,976 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
6f873f681b5d91feb94a2189370f1a86b210f56e956967e2220f4608e3c0f9f8 | Java | 183,043 | 4,333 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
5af14f5391165aac36c7140daffcd7daad8656df72e04506b980c5d2adedbce7 | Java | 186,345 | 3,532 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
16fbe7a5e2800fa5a6ffb99eb014e71b3f04321833a24b7d37ae4456ffa8e9f0 | Java | 200,000 | 4,532 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
4fdf0e73cb0c04dd67000264548dc38eaf175af7ca625e1e381be84e7f3da2da | Java | 200,004 | 4,243 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
68f595d65793f2bee8ed995972cc943301ae6143cb3986ab592ca528066e188a | Java | 200,007 | 4,737 | /*-
* #%L
* Fiji distribution of ImageJ for the life sciences.
* %%
* Copyright (C) 2010 - 2026 Fiji developers.
* %%
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as
* published by the Free Software Foundation, either version 3 of ... |
ac875ad3d0097cd6a5871efa7207109ac8db2b7f27cdceac5b568df7f384cf5c | Java | 200,008 | 4,036 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
b37f31c4d4a73c49960bbb7c386534d9b0820dc91c5c2c11c02d9011f93cd916 | Java | 200,008 | 4,086 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
d3b1763d20635d22cb1be19f1281ab9052364a0a78aa7844c969f115469094d5 | Java | 200,008 | 3,953 | /// ////////////////////////////////////////////////////////////////////////////
// For information as to what this class does, see the Javadoc, below. //
// //
// Copyright (C) 2025 by Joseph Ramsey, Peter Spirtes, Clark Glymour, //... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.