From: janburse@fastmail.fm   
      
   Hi,   
      
   I am spekulating an NPU could give 1000x more LIPS.   
   For certain combinatorial search problems. It all   
   boils down to implement this thingy:   
      
   In June 2020, Stockfish introduced the efficiently   
   updatable neural network (NNUE) approach, based   
   on earlier work by computer shogi programmers   
   https://en.wikipedia.org/wiki/Stockfish_%28chess%29   
      
   There are varying degrees what gets updated of   
   a neural network. But the specs of an NPU tell   
   me very simply the following:   
      
   - An NPU can make 40 TFLOPS, all my AI Laptops   
      from 2025 can do that right now. The brands   
      are Intel Ultra, AMD Ryzen and Snapdragon X,   
      
      but I guess there might be more brands around,   
      which can do that with a price tag less   
      than 1000.- USD.   
      
   - SWI Prolog can make 30 MLIPS, Dogelog Player   
      runs similar, some Prolog systems are faster.   
      
   Now thats is 10^12 versus 10^6. If some of the   
   LIPS can be delegated to a NPU, and if we assume   
   for example less locality or more primitive   
      
   operations that require a layering. Would could assume   
   that from the NPU 10^12 a factor of 1000 goes   
   away. So we might still see 10'9 LIPS emerge.   
      
   Now make the calculation:   
      
   - Without NPU: MLIPS   
   - With NPU: GLIPS   
   - Ratio: 1000x times faster   
      
   Have fun!   
      
   Bye   
      
   Mild Shock schrieb:   
   > Mercio’s Algorithm (2012) for Rational   
   > Tree Compare is specified here mathematically.   
   > It is based on computing truncations A' = (A_0,   
   > A_1, etc..) of a rational tree A:   
   >   
   > A < B ⟺ A′ <_lex B′   
   >   
   > https://math.stackexchange.com/a/210730   
   >   
   > Here is an implementation in Prolog.   
   > First the truncation:   
   >   
   > trunc(_, T, T) :- var(T), !.   
   > trunc(0, T, F) :- !, functor(T, F, _).   
   > trunc(N, T, S) :-   
   >     M is N-1,   
   >     T =.. [F|L],   
   >     maplist(trunc(M), L, R),   
   >     S =.. [F|R].   
   >   
   > And then the iterative deepening:   
   >   
   > mercio(N, X, Y, C) :-   
   >     trunc(N, X, A),   
   >     trunc(N, Y, B),   
   >     compare(D, A, B),   
   >     D \== (=), !, C = D.   
   > mercio(N, X, Y, C) :-   
   >     M is N + 1,   
   >     mercio(M, X, Y, C).   
   >   
   > The main entry first uses (==)/2 for a   
   > terminating equality check and if the   
   > rational trees are not equal, falls back   
   > to the iterative deepening:   
   >   
   > mercio(C, X, Y) :- X == Y, !, C = (=).   
   > mercio(C, X, Y) :- mercio(0, X, Y, C).   
   >   
   > I couldn’t find yet a triple that violates   
   > transitivity. But I am also not much happy   
   > with the code. Looks a little bit expensive   
   > to create a truncation copy iteratively.   
   >   
   > Provided there is really no counter example,   
   > maybe we can do mit more smart and faster? It   
   > might also stand the test of conservativity?   
      
   --- SoupGate-Win32 v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)