@logic-pad/core 0.25.3 → 0.26.1

package/dist/src/data/solver/z3/modules/letterModule.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 LetterModule extends Z3Module {
-    readonly id: string;
-    encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name, Solver<Name> | Optimize<Name>>): void;
-}
-export declare const instance: LetterModule;

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

@@ -1,33 +0,0 @@
-import Z3Module from './z3Module.js';
-import { instance as letterInstance, } from '../../../symbols/letterSymbol.js';
-import { Point } from 'grilops';
-export default class LetterModule extends Z3Module {
-    id = letterInstance.id;
-    encode(grid, ctx) {
-        const symbols = grid.symbols.get(this.id);
-        if (!symbols || symbols.length === 0) {
-            return;
-        }
-        const rc = ctx.regionConstrainer;
-        const letterMap = new Map();
-        for (const symbol of symbols) {
-            const x = Math.floor(symbol.x);
-            const y = Math.floor(symbol.y);
-            if (letterMap.has(symbol.letter)) {
-                ctx.solver.add(letterMap
-                    .get(symbol.letter)
-                    .eq(rc.regionIdGrid.get(new Point(y, x))));
-            }
-            else {
-                letterMap.set(symbol.letter, rc.regionIdGrid.get(new Point(y, x)));
-            }
-        }
-        const letters = Array.from(letterMap.values());
-        for (let i = 0; i < letters.length - 1; i++) {
-            for (let j = i + 1; j < letters.length; j++) {
-                ctx.solver.add(letters[i].neq(letters[j]));
-            }
-        }
-    }
-}
-export const instance = new LetterModule();

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

@@ -1,8 +0,0 @@
-export { instance as AreaNumberModule } from './areaNumberModule.js';
-export { instance as CellCountModule } from './cellCountModule.js';
-export { instance as ConnectAllModule } from './connectAllModule.js';
-export { instance as DartModule } from './dartModule.js';
-export { instance as LetterModule } from './letterModule.js';
-export { instance as MyopiaModule } from './myopiaModule.js';
-export { instance as RegionAreaModule } from './regionAreaModule.js';
-export { instance as ViewpointModule } from './viewpointModule.js';

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

@@ -1,12 +0,0 @@
-/* prettier-ignore-start */
-/* eslint-disable */
-// @ts-nocheck
-// noinspection JSUnusedGlobalSymbols
-export { instance as AreaNumberModule } from './areaNumberModule.js';
-export { instance as CellCountModule } from './cellCountModule.js';
-export { instance as ConnectAllModule } from './connectAllModule.js';
-export { instance as DartModule } from './dartModule.js';
-export { instance as LetterModule } from './letterModule.js';
-export { instance as MyopiaModule } from './myopiaModule.js';
-export { instance as RegionAreaModule } from './regionAreaModule.js';
-export { instance as ViewpointModule } from './viewpointModule.js';

package/dist/src/data/solver/z3/modules/myopiaModule.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 MyopiaModule extends Z3Module {
-    readonly id: string;
-    encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name, Solver<Name> | Optimize<Name>>): void;
-}
-export declare const instance: MyopiaModule;

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

@@ -1,56 +0,0 @@
-import Z3Module from './z3Module.js';
-import { instance as myopiaInstance, } from '../../../symbols/myopiaSymbol.js';
-import { Point, reduceCells } from 'grilops';
-import { DIRECTIONS, ORIENTATIONS } from '../../../primitives.js';
-import { convertDirection } from '../utils.js';
-import { move } from '../../../dataHelper.js';
-export default class MyopiaModule extends Z3Module {
-    id = myopiaInstance.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 startPos = new Point(y, x);
-            const origin = ctx.grid.cellAt(new Point(y, x));
-            const pointedTerms = [];
-            const otherTerms = [];
-            ORIENTATIONS.filter(d => symbol.directions[d]).forEach(direction => {
-                pointedTerms.push(reduceCells(ctx.grid.ctx, ctx.grid, startPos, convertDirection(direction), ctx.ctx.Int.val(0), (acc, cell, p) => {
-                    const nextPos = move({ x: p.x, y: p.y }, direction);
-                    if (grid.isPositionValid(nextPos.x, nextPos.y)) {
-                        return ctx.ctx.If(cell.eq(origin), acc.add(1), acc);
-                    }
-                    else {
-                        return ctx.ctx.If(cell.eq(origin), acc.add(Number.MAX_SAFE_INTEGER), acc);
-                    }
-                }, (_, cell) => cell.neq(origin)));
-            });
-            (symbol.diagonals ? ORIENTATIONS : DIRECTIONS)
-                .filter(d => !symbol.directions[d])
-                .forEach(direction => {
-                otherTerms.push(reduceCells(ctx.grid.ctx, ctx.grid, startPos, convertDirection(direction), ctx.ctx.Int.val(0), (acc, cell, p) => {
-                    const nextPos = move({ x: p.x, y: p.y }, direction);
-                    if (grid.isPositionValid(nextPos.x, nextPos.y)) {
-                        return ctx.ctx.If(cell.eq(origin), acc.add(1), acc);
-                    }
-                    else {
-                        return ctx.ctx.If(cell.eq(origin), acc.add(Number.MAX_SAFE_INTEGER), acc);
-                    }
-                }, (_, cell) => cell.neq(origin)));
-            });
-            for (let i = 1; i < pointedTerms.length; i++) {
-                ctx.solver.add(pointedTerms[i].eq(pointedTerms[0]));
-            }
-            for (const otherTerm of otherTerms) {
-                ctx.solver.add(otherTerm.gt(pointedTerms[0]));
-            }
-        }
-    }
-}
-export const instance = new MyopiaModule();

package/dist/src/data/solver/z3/modules/regionAreaModule.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 RegionAreaModule extends Z3Module {
-    readonly id: string;
-    encode<Name extends string>(grid: GridData, ctx: Z3SolverContext<Name, Solver<Name> | Optimize<Name>>): void;
-}
-export declare const instance: RegionAreaModule;

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

@@ -1,40 +0,0 @@
-import Z3Module from './z3Module.js';
-import { instance as regionAreaInstance, } from '../../../rules/regionAreaRule.js';
-export default class RegionAreaModule extends Z3Module {
-    id = regionAreaInstance.id;
-    encode(grid, ctx) {
-        const rules = grid.rules.filter(rule => rule.id === this.id);
-        // optimizations
-        if (rules.length === 0) {
-            return;
-        }
-        const colorMap = new Map();
-        for (const rule of rules) {
-            if (colorMap.has(rule.color)) {
-                if (colorMap.get(rule.color) !== rule.size) {
-                    ctx.solver.add(ctx.ctx.Bool.val(false));
-                    return;
-                }
-            }
-            else {
-                colorMap.set(rule.color, rule.size);
-            }
-        }
-        for (const [color, count] of colorMap.entries()) {
-            if (count < 0 || count > grid.getColorCount(color).max) {
-                ctx.solver.add(ctx.ctx.Bool.val(false));
-                return;
-            }
-        }
-        // encode for real
-        const rc = ctx.regionConstrainer;
-        for (const [color, count] of colorMap.entries()) {
-            for (const [p, cell] of ctx.grid.grid.entries()) {
-                ctx.solver.add(cell
-                    .eq(ctx.symbolSet.indices[color])
-                    .implies(rc.regionSizeGrid.get(p).eq(count)));
-            }
-        }
-    }
-}
-export const instance = new RegionAreaModule();

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;
-    }
-}