@logic-pad/core 0.1.0

package/dist/data/solver/z3/utils.js

@@ -0,0 +1,26 @@
+import { RectangularLattice } from 'grilops';
+import { Direction, Orientation } from '../../primitives';
+export function convertDirection(direction) {
+    switch (direction) {
+        case Direction.Up:
+        case Orientation.Up:
+            return RectangularLattice.VERTEX_DIRECTIONS.N;
+        case Direction.Down:
+        case Orientation.Down:
+            return RectangularLattice.VERTEX_DIRECTIONS.S;
+        case Direction.Left:
+        case Orientation.Left:
+            return RectangularLattice.VERTEX_DIRECTIONS.W;
+        case Direction.Right:
+        case Orientation.Right:
+            return RectangularLattice.VERTEX_DIRECTIONS.E;
+        case Orientation.DownLeft:
+            return RectangularLattice.VERTEX_DIRECTIONS.SW;
+        case Orientation.DownRight:
+            return RectangularLattice.VERTEX_DIRECTIONS.SE;
+        case Orientation.UpLeft:
+            return RectangularLattice.VERTEX_DIRECTIONS.NW;
+        case Orientation.UpRight:
+            return RectangularLattice.VERTEX_DIRECTIONS.NE;
+    }
+}

package/dist/data/solver/z3/z3Solver.d.ts

@@ -0,0 +1,10 @@
+import GridData from '../../grid';
+import Solver from '../solver';
+export default class Z3Solver extends Solver {
+    readonly id = "z3";
+    readonly description = "Good for confirming that a solution is unique, especially for larger puzzles. It is otherwise slower than most solvers in small to medium-sized puzzles.";
+    isEnvironmentSupported(): Promise<boolean>;
+    solve(grid: GridData): AsyncGenerator<GridData | null>;
+    isInstructionSupported(instructionId: string): boolean;
+    isGridSupported(grid: GridData): boolean;
+}

package/dist/data/solver/z3/z3Solver.js

@@ -0,0 +1,134 @@
+import { Point, PointSet, SymbolGrid, SymbolSet, getRectangleLattice, } from 'grilops';
+import Solver from '../solver';
+import { allZ3Modules } from './modules';
+import { Color } from '../../primitives';
+import { init } from 'z3-solver';
+import Z3SolverContext from './z3SolverContext';
+import { array } from '../../dataHelper';
+export default class Z3Solver extends Solver {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'z3'
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'Good for confirming that a solution is unique, especially for larger puzzles. It is otherwise slower than most solvers in small to medium-sized puzzles.'
+        });
+    }
+    async isEnvironmentSupported() {
+        try {
+            await init();
+            return true;
+        }
+        catch (ex) {
+            return false;
+        }
+    }
+    async *solve(grid) {
+        console.log('Initializing dependencies');
+        const { Z3, Context } = await init();
+        const z3Ctx = Context('main');
+        const grilopsCtx = {
+            z3: Z3,
+            context: z3Ctx,
+        };
+        const symbolSet = new SymbolSet([
+            ['empty', ' '],
+            [Color.Dark, 'B'],
+            [Color.Light, 'W'],
+        ]);
+        const lattice = getRectangleLattice(grid.height, grid.width);
+        const symbolGrid = new SymbolGrid(grilopsCtx, lattice, symbolSet, new z3Ctx.Solver('QF_FD'));
+        const ctx = new Z3SolverContext(symbolGrid);
+        console.log('Encoding constraints');
+        grid.forEach((tile, x, y) => {
+            // encode all empty tiles
+            if (!tile.exists)
+                ctx.solver.add(symbolGrid.cellAt(new Point(y, x)).eq(symbolSet.indices.empty));
+            // encode all given tiles
+            else if (tile.fixed)
+                ctx.solver.add(symbolGrid.cellAt(new Point(y, x)).eq(symbolSet.indices[tile.color]));
+            // make sure tiles are filled
+            else {
+                ctx.solver.add(symbolGrid.cellAt(new Point(y, x)).neq(symbolSet.indices.empty));
+            }
+        });
+        // encode connections
+        const visited = array(grid.width, grid.height, () => false);
+        const queue = new PointSet();
+        grid.connections.edges.forEach(edge => {
+            queue.add(new Point(edge.y1, edge.x1));
+            queue.add(new Point(edge.y2, edge.x2));
+        });
+        queue.forEach(point => {
+            if (visited[point.y][point.x])
+                return;
+            visited[point.y][point.x] = true;
+            const connected = grid.connections.getConnectedTiles({
+                x: point.x,
+                y: point.y,
+            });
+            connected.forEach(p => (visited[p.y][p.x] = true));
+            const filtered = connected
+                .filter(p => grid.getTile(p.x, p.y).exists)
+                .map(p => new Point(p.y, p.x));
+            if (filtered.length < 2)
+                return;
+            for (let i = 1; i < filtered.length; i++) {
+                ctx.solver.add(symbolGrid.cellAt(point).eq(symbolGrid.cellAt(filtered[i])));
+            }
+        });
+        [...new Set(grid.rules.map(r => r.id))].forEach(ruleId => {
+            if (!allZ3Modules.has(ruleId))
+                return;
+            allZ3Modules.get(ruleId).encode(grid, ctx);
+        });
+        [...grid.symbols.keys()].forEach(symbolId => allZ3Modules.get(symbolId).encode(grid, ctx));
+        const decodeResult = (model) => {
+            const tiles = array(grid.width, grid.height, (x, y) => {
+                const tile = grid.getTile(x, y);
+                if (!tile.exists || tile.fixed)
+                    return tile;
+                const color = Number(model.eval(symbolGrid.cellAt(new Point(y, x))));
+                return tile.withColor(symbolSet.symbols.get(color).name);
+            });
+            return grid.withTiles(tiles);
+        };
+        console.log('Solving');
+        console.time('Solve time');
+        const result = await symbolGrid.solve();
+        console.timeEnd('Solve time');
+        if (!result) {
+            yield null;
+            return;
+        }
+        const model = ctx.solver.model();
+        yield decodeResult(model);
+        console.log('Checking uniqueness');
+        console.time('Uniqueness time');
+        const result2 = await symbolGrid.isUnique();
+        console.timeEnd('Uniqueness time');
+        if (result2) {
+            yield null;
+            return;
+        }
+        const model2 = ctx.solver.model();
+        yield decodeResult(model2);
+    }
+    isInstructionSupported(instructionId) {
+        return allZ3Modules.has(instructionId);
+    }
+    isGridSupported(grid) {
+        if (!super.isGridSupported(grid))
+            return false;
+        if (grid.getTileCount(true, true, Color.Gray) > 0)
+            return false;
+        return true;
+    }
+}