@logic-pad/core 0.25.3 → 0.26.0

package/dist/src/data/solver/z3/modules/viewpointModule.d.ts

@@ -1,9 +0,0 @@
-import { Solver, Optimize } from 'z3-solver';
-import GridData from '../../../grid.js';
-import Z3SolverContext from '../z3SolverContext.js';
-import Z3Module from './z3Module.js';
-export default class ViewpointModule extends Z3Module {
-    readonly id: string;
-    encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name, Solver<Name> | Optimize<Name>>): void;
-}
-export declare const instance: ViewpointModule;

package/dist/src/data/solver/z3/modules/viewpointModule.js

@@ -1,29 +0,0 @@
-import Z3Module from './z3Module.js';
-import { instance as viewpointInstance, } from '../../../symbols/viewpointSymbol.js';
-import { Point, reduceCells } from 'grilops';
-import { DIRECTIONS } from '../../../primitives.js';
-import { move } from '../../../dataHelper.js';
-import { convertDirection } from '../utils.js';
-export default class ViewpointModule extends Z3Module {
-    id = viewpointInstance.id;
-    encode(grid, ctx) {
-        const symbols = grid.symbols.get(this.id);
-        // optimizations
-        if (!symbols || symbols.length === 0) {
-            return;
-        }
-        // encode for real
-        for (const symbol of symbols) {
-            const x = Math.floor(symbol.x);
-            const y = Math.floor(symbol.y);
-            const origin = ctx.grid.cellAt(new Point(y, x));
-            const sumTerms = [];
-            DIRECTIONS.forEach(direction => {
-                const startPos = move({ x, y }, direction);
-                sumTerms.push(reduceCells(ctx.grid.ctx, ctx.grid, new Point(startPos.y, startPos.x), convertDirection(direction), ctx.ctx.Int.val(0), (acc, cell) => ctx.ctx.If(cell.eq(origin), acc.add(1), acc), (_, cell) => cell.neq(origin)));
-            });
-            ctx.solver.add(ctx.ctx.Sum(ctx.ctx.Int.val(1), ...sumTerms).eq(symbol.number));
-        }
-    }
-}
-export const instance = new ViewpointModule();

package/dist/src/data/solver/z3/modules/z3Module.d.ts

@@ -1,7 +0,0 @@
-import GridData from '../../../grid.js';
-import Z3SolverContext from '../z3SolverContext.js';
-export default abstract class Z3Module {
-    abstract get id(): string;
-    abstract encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name>): void;
-}
-export declare const instance: undefined;

package/dist/src/data/solver/z3/modules/z3Module.js

@@ -1,3 +0,0 @@
-export default class Z3Module {
-}
-export const instance = undefined;

package/dist/src/data/solver/z3/utils.d.ts

@@ -1,2 +0,0 @@
-import { Direction, Orientation } from '../../primitives.js';
-export declare function convertDirection(direction: Orientation | Direction): import("grilops").Direction;

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

@@ -1,26 +0,0 @@
-import { RectangularLattice } from 'grilops';
-import { Direction, Orientation } from '../../primitives.js';
-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/src/data/solver/z3/z3Solver.d.ts

@@ -1,12 +0,0 @@
-import GridData from '../../grid.js';
-import Solver from '../solver.js';
-export default class Z3Solver extends Solver {
-    readonly id = "z3";
-    readonly author = "Lysine";
-    readonly description = "(Obsolete) A WebAssembly solver that supports a limited set of rules and symbols.";
-    readonly supportsCancellation = false;
-    protected isEnvironmentSupported(): Promise<boolean>;
-    solve(grid: GridData): AsyncGenerator<GridData | null>;
-    isInstructionSupported(instructionId: string): boolean;
-    isGridSupported(grid: GridData): boolean;
-}

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

@@ -1,123 +0,0 @@
-import { Point, PointSet, SymbolGrid, SymbolSet, getRectangleLattice, } from 'grilops';
-import Solver from '../solver.js';
-import { allZ3Modules } from './modules/index.js';
-import { Color } from '../../primitives.js';
-import { init } from 'z3-solver';
-import Z3SolverContext from './z3SolverContext.js';
-import { array } from '../../dataHelper.js';
-export default class Z3Solver extends Solver {
-    id = 'z3';
-    author = 'Lysine';
-    description = '(Obsolete) A WebAssembly solver that supports a limited set of rules and symbols.';
-    supportsCancellation = false;
-    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;
-    }
-}

package/dist/src/data/solver/z3/z3SolverContext.d.ts

@@ -1,13 +0,0 @@
-import { RegionConstrainer, SymbolGrid } from 'grilops';
-import { Optimize, Solver, Z3LowLevel } from 'z3-solver';
-export default class Z3SolverContext<Name extends string, const Core extends Solver<Name> | Optimize<Name> = Solver<Name> | Optimize<Name>> {
-    readonly grid: SymbolGrid<Name, Core>;
-    private _regionConstrainer;
-    constructor(grid: SymbolGrid<Name, Core>);
-    get solver(): Core;
-    get lattice(): import("grilops").Lattice;
-    get symbolSet(): import("grilops").SymbolSet;
-    get ctx(): import("z3-solver").Context<Name>;
-    get z3(): Z3LowLevel['Z3'];
-    get regionConstrainer(): RegionConstrainer<Name, Core>;
-}

package/dist/src/data/solver/z3/z3SolverContext.js

@@ -1,40 +0,0 @@
-import { RegionConstrainer } from 'grilops';
-export default class Z3SolverContext {
-    grid;
-    _regionConstrainer;
-    constructor(grid) {
-        this.grid = grid;
-        this.grid = grid;
-    }
-    get solver() {
-        return this.grid.solver;
-    }
-    get lattice() {
-        return this.grid.lattice;
-    }
-    get symbolSet() {
-        return this.grid.symbolSet;
-    }
-    get ctx() {
-        return this.grid.ctx.context;
-    }
-    get z3() {
-        return this.grid.ctx.z3;
-    }
-    get regionConstrainer() {
-        if (!this._regionConstrainer) {
-            this._regionConstrainer = new RegionConstrainer(this.grid.ctx, this.lattice, this.solver, true, false, 1);
-            for (const p of this.lattice.points) {
-                for (const np of this.lattice.edgeSharingNeighbors(this.grid.grid, p)) {
-                    this.solver.add(this.grid
-                        .cellAt(p)
-                        .eq(this.grid.cellAt(np.location))
-                        .eq(this._regionConstrainer.regionIdGrid
-                        .get(p)
-                        .eq(this._regionConstrainer.regionIdGrid.get(np.location))));
-                }
-            }
-        }
-        return this._regionConstrainer;
-    }
-}