Update to work.

flake.lock

@@ -5,17 +5,16 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1705309234,
-        "narHash": "sha256-uNRRNRKmJyCRC/8y1RqBkqWBLM034y4qN7EprSdmgyA=",
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "1ef2e671c3b0c19053962c07dbda38332dcebf26",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
         "type": "github"
       },
       "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
+        "id": "flake-utils",
+        "type": "indirect"
       }
     },
     "flake-utils_2": {
@@ -120,18 +119,16 @@
     },
     "nixpkgs_2": {
       "locked": {
-        "lastModified": 1707939175,
-        "narHash": "sha256-D1xan0lgxbmXDyzVqXTiSYHLmAMrMRdD+alKzEO/p3w=",
-        "owner": "nixos",
+        "lastModified": 1739863612,
+        "narHash": "sha256-UbtgxplOhFcyjBcNbTVO8+HUHAl/WXFDOb6LvqShiZo=",
+        "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "f7e8132daca31b1e3859ac0fb49741754375ac3d",
+        "rev": "632f04521e847173c54fa72973ec6c39a371211c",
         "type": "github"
       },
       "original": {
-        "owner": "nixos",
-        "ref": "nixpkgs-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
+        "id": "nixpkgs",
+        "type": "indirect"
       }
     },
     "root": {

flake.nix

 {
   inputs = {
-    nixpkgs.url = github:nixos/nixpkgs/nixpkgs-unstable;
-    flake-utils.url = github:numtide/flake-utils;
-    nix-filter.url = github:numtide/nix-filter;
+    nix-filter.url = "github:numtide/nix-filter";
     language-c = {
-      url = github:kalhauge/language-c;
+      url = "github:kalhauge/language-c";
       flake = false;
     };
-    hspec-glitter.url = github:kalhauge/hspec-glitter;
+    hspec-glitter.url = "github:kalhauge/hspec-glitter";
   };
   outputs = {
     self,
@@ -19,33 +17,41 @@
     load = p: n:
       p.callCabal2nixWithOptions n (nix-filter.lib {root = "${self}/${n}";}) "" {};
 
-    packages = lib: p: {
-      "language-c" = lib.dontCheck (p.callCabal2nixWithOptions "language-c" inputs.language-c "" {});
-      "hspec-glitter" = p.callCabal2nixWithOptions "hspec-glitter" inputs.hspec-glitter "" {};
-      "rtree" = lib.dontCheck (load p "rtree");
-      "rtree-c" = lib.dontCheck (load p "rtree-c");
+    packages = lib: final: prev: {
+      "language-c" = lib.dontCheck (final.callCabal2nixWithOptions "language-c" inputs.language-c "" {});
+      "hspec-glitter" = final.callCabal2nixWithOptions "hspec-glitter" inputs.hspec-glitter "" {};
+      "rtree" = lib.dontCheck (load final "rtree");
+      "rtree-c" = lib.dontCheck (load final "rtree-c");
+    };
+
+    overlay = final: prev: let
+      lib = final.haskell.lib;
+      hpkgs = prev.haskellPackages.override (hpArgs: {
+        overrides = final.lib.composeExtensions (hpArgs.overrides or (_: _: {})) (packages lib);
+      });
+    in {
+      haskellPackages = hpkgs;
+      rtree-c = lib.justStaticExecutables (hpkgs.rtree-c);
+      rtree = hpkgs.rtree;
     };
   in
-    flake-utils.lib.eachDefaultSystem
+    {
+      overlays.default = overlay;
+    }
+    // flake-utils.lib.eachDefaultSystem
     (system: let
       pkgs = import nixpkgs {
         inherit system;
-        overlays = [];
+        overlays = [overlay];
       };
-      lib = pkgs.haskell.lib;
-      hpkgs = pkgs.haskellPackages.override (hpArgs: {
-        overrides = pkgs.lib.composeExtensions (hpArgs.overrides or (_: _: {})) (
-          _hfinal: hprev: packages lib hprev
-        );
-      });
     in {
       packages = {
-        default = lib.justStaticExecutables (hpkgs.rtree-c);
-        rtree = hpkgs.rtree;
-        rtree-c = hpkgs.rtree-c;
+        default = pkgs.rtree-c;
+        rtree = pkgs.rtree;
+        rtree-c = pkgs.rtree-c;
       };
       devShells = let
-        nativeBuildInputs = with hpkgs; [
+        nativeBuildInputs = with pkgs.haskellPackages; [
           cabal-install
           ghcid
           haskell-language-server
@@ -53,7 +59,7 @@
           fourmolu
         ];
         withHoogle = true;
-        profiles = hpkgs.override (hpArgs: {
+        profiles = pkgs.haskellPackages.override (hpArgs: {
           overrides = pkgs.lib.composeExtensions (hpArgs.overrides or (_: _: {})) (
             _hfinal: hprev: {
               mkDerivation = args:
@@ -80,14 +86,14 @@
           );
         });
       in {
-        rtree = hpkgs.rtree;
+        rtree = pkgs.haskellPackages.rtree;
         default =
           profiles.shellFor
           {
             name = "rtree-shells";
             packages = p: [
-              (lib.doCheck p.rtree)
-              (lib.doCheck p.rtree-c)
+              (pkgs.haskell.lib.doCheck p.rtree)
+              (pkgs.haskell.lib.doCheck p.rtree-c)
             ];
             doBenchmark = true;
             genericBuilderArgsModifier = args:

pyrtree/rtree.py

 from dataclasses import dataclass
+import math
+from typing import TypeVar
+
+
+def reduce_simp(predicate, rtree):
+    path: list[bool] = []
+    labels: list[str] = []
+
+    def check(label):
+        labels.append(label)
+        return path[len(labels) - 1] if len(path) >= len(labels) else False
+
+    i = rtree(check)
+    while len(path) < len(labels):
+        path.append(True)
+        labels.clear()
+        if t := predicate(j := rtree(check)):
+            i = j
+        else:
+            path[-1] = False
+        print(f"{labels[len(path) - 1]} ... test {j!r:<10} ... {t}")
+    return i
 
 
 class Probe:
@@ -20,6 +42,23 @@ class Probe:
         return len(self.reasons) - len(self.path)
 
 
+def reduce1(predicate, rtree):
+    # Extract the initial reduction probe, from the rightmost branch.
+    rp = Probe(rtree, [])
+    # Run exponential search after the depest sequence of trues
+    # that can be appended to the path without failing the predicate
+    depth = 1
+    # Invariant: predicate(rp) == True
+    while rp.undecided() > 0:
+        # Try to probe the with current path extended by one trues
+        if predicate(rp_ := Probe(rtree, rp.path, depth)):
+            rp = rp_
+            continue
+        rp.path.append(False)
+    # return the input.
+    return rp
+
+
 def reduce(predicate, rtree):
     # Extract the initial reduction probe, from the rightmost branch.
     rp = Probe(rtree, [])
@@ -89,6 +128,29 @@ def latex(
     return newpred
 
 
+def table(
+    predicate,
+    input_format="{}".format,
+    query_format=str,
+    start_count=0,
+):
+    counter = start_count - 1
+
+    def newpred(rp):
+        nonlocal counter
+        counter += 1
+        t = predicate(rp.input)
+        query = ", ".join(
+            query_format(a) for a in rp.reasons[len(rp.path) - rp.depth : len(rp.path)]
+        )
+        theck = "true " if t else "false"
+
+        print(f"{counter:02} - {input_format(rp.input)} - {theck} - {query}")
+        return t
+
+    return newpred
+
+
 def pretty(rp):
     from itertools import zip_longest
 
@@ -103,14 +165,94 @@ def pretty(rp):
 
 def reduce_abc(check) -> str:
     result = ""
-    for x in "abcdefghijklmnopqrstuvxyz":
-        if not check(f"{x}"):
+    for x in "abc":
+        if not check(f"remove {x}?"):
             result += x
         else:
             result += " "
     return result
 
 
+def reduce_dd2(c: list, check) -> list:
+    if check(f"ignore {c}?"):
+        return []
+    if len(c) == 1:
+        return c
+    pivot = len(c) // 2
+    c2 = reduce_dd(c[pivot:], check)
+    c1 = reduce_dd(c[:pivot], check)
+    return c1 + c2
+
+
+def reduce_dd(c: list, check) -> list:
+    if len(c) == 1:
+        return c
+    pivot = len(c) // 2
+    c1 = c[:pivot]
+    c2 = c[pivot:]
+    if check(f"result in c1: {c1}?"):
+        return reduce_dd(c1, check)
+    elif check(f"result in c2: {c2}?"):
+        return reduce_dd(c2, check)
+    else:
+        return reduce_dd(c1, check) + reduce_dd(c2, check)
+
+
+I = TypeVar("I")
+
+
+def reduce_df(i: I, actions, check) -> I:
+    j = None
+    while i != j:
+        for act in actions:
+            if check(f"apply {act}?"):
+                i, j = act(i), i
+        else:
+            break
+    return i
+
+
+def reduce_ddmin(input: list, check, n=2) -> list:
+    def find_next(input, n):
+        step = math.ceil(len(input) / n)
+        subsets = [(step * i, step * (i + 1)) for i in range(n)]
+        for i, (f, t) in enumerate(subsets):
+            if check(f"delta: {i}/{n}"):
+                return input[f:t], 2
+
+        for i, (f, t) in enumerate(subsets) if n != 2 else []:
+            if check(f"complement: {i}/{n}"):
+                return input[:f] + input[t:], max(n - 1, 2)
+
+        return input, n * 2
+
+    while len(input) > 1 and n < 2 * len(input):
+        input, n = find_next(input, n)
+
+    return input
+
+
+def test_reduce_dd():
+    from functools import partial
+
+    p = debug(lambda a: 3 in a and 6 in a)
+    rp = reduce(p, partial(reduce_dd, [1, 2, 3, 4, 5, 6, 7, 8]))
+    print(rp)
+
+
+def test_reduce_ddmin():
+    from functools import partial
+
+    input_format = lambda a: "".join("X" if i in a else "." for i in range(1, 9))
+    p = table(
+        lambda a: 1 in a and 7 in a and 8 in a,
+        input_format=input_format,
+        query_format=str,
+    )
+    rp = reduce1(p, partial(reduce_ddmin, [1, 2, 3, 4, 5, 6, 7, 8]))
+    print(f"   - {input_format(rp.input)}")
+
+
 if __name__ == "__main__":
     p = latex(
         lambda e: "a" in e or "p" in e,

rtree-c/bin/Main.hs

@@ -82,7 +82,7 @@ run = do
       fold
         [ long "keyword"
         , short 'k'
-        , help "don't do any reduction"
+        , help "special versions of the code"
         ]
 
   validity <-

rtree/rtree.cabal

 cabal-version: 1.12
 
--- This file has been generated from package.yaml by hpack version 0.35.2.
+-- This file has been generated from package.yaml by hpack version 0.36.1.
 --
 -- see: https://github.com/sol/hpack
 
@@ -13,7 +13,6 @@ library
       Control.Monad.IRTree
       Control.Monad.Reduce
       Control.Monad.RTree
-      Control.Monad.RTree.Simple
       Data.RPath
       Data.Valuation
   other-modules:

rtree/src/Control/Monad/IRTree.hs

@@ -37,6 +37,7 @@ import Control.Monad.Reader
 import Control.Monad.Reduce
 import Data.Bits
 import Data.Foldable
+import Data.Monoid
 import Data.Function
 import Data.Functor
 import Data.Functor.Identity

rtree/src/Control/Monad/RTree.hs

@@ -36,9 +36,9 @@ module Control.Monad.RTree (
 import Control.Monad
 import Control.Monad.Identity
 import Control.Monad.Reduce
-import Data.Foldable
 import Data.Foldable.WithIndex
-import Data.Function ((&))
+import Data.Function ((&), fix)
+import Data.Foldable
 import Data.RPath
 import qualified Data.Sequence as Seq
 

rtree/src/Control/Monad/RTree/Simple.hs

-{-# LANGUAGE BlockArguments #-}
-{-# LANGUAGE DerivingVia #-}
-
-module Control.Monad.RTree.Simple where
-
-import Control.Monad.Identity
-import Control.Monad.State
-
-type RTree a = State ([Bool], Int) a
-
-check :: RTree Bool
-check = state \(c : cs, n) -> (c, (cs, n + 1))
-
-probe :: RTree a -> [Bool] -> (a, Int)
-probe root path = (extract, depth - length path)
- where
-  (extract, (_, depth)) = runState root (path ++ repeat False, 0)
-
-reduce :: (a -> IO Bool) -> RTree a -> [Bool] -> IO a
-reduce predicate root path
-  | undecided > 0 = do
-      result <- predicate (fst (probe root (path ++ [True])))
-      reduce predicate root (path ++ [result])
-  | otherwise = pure extract
- where
-  (extract, undecided) = probe root path
-
-reduceAbc :: RTree [Char]
-reduceAbc = filterM (\_ -> check) "abc"