early influence graph of fp languages -- this is not meant to be a complete time line. I'm mostly concerned with the root and inner nodes.

fp.dot

digraph G {
ranksep=1.0;
ratio=0.6;

APL [color=Blue, shape=box];
Simula [color=Blue, shape=box];
LISP [color=Blue, shape=box];
ALGOL [color=Blue, shape=box];
Planner [color=Blue, shape=box];
ACTOR [shape=hexagon];
CSP [shape=hexagon];

FORTRAN -> LISP;
FORTRAN -> ALGOL;
ALGOL -> Simula;
ACTOR -> Erlang;
Simula -> OCaml;
Simula -> CommonLisp;
KRC -> Miranda;
KRC -> SASL;
KRC -> Haskell;
SASL -> Haskell;
SASL -> Miranda;
Miranda -> Haskell;
Hope -> Haskell;
Hope -> ML;
Clean -> Haskell;
FP -> Haskell;         // point-free style. not interested in whole chain through APL ATM
APL -> Haskell;
APL -> FP;
ISWIM -> Haskell;
Prolog -> Erlang;
Prolog -> Clojure;
Prolog -> Mercury;
Prolog -> "Qi/Shen";
CSP -> Erlang;
Haskell -> FSharp
Haskell -> Clojure;
Haskell -> "Qi/Shen";
Haskell -> Mercury;
Haskell -> Clean;
Haskell -> Agda;
Haskell -> OCaml;     // GADTs
Haskell -> Curry;
Haskell -> Scala;
ISWIM -> SASL;
ISWIM -> Miranda;
ISWIM -> Lucid;
ISWIM -> ML;
LISP -> ISWIM;
Id -> Haskell; // M-structure are managed refs
ML -> Clojure;
ML -> Erlang;
ML -> Miranda;
ML -> Caml -> OCaml -> FSharp;
ML -> SML;
ML -> Haskell;
Erlang -> Clojure;
Erlang -> Scala; // Actors lib
Scheme -> Clojure;
Scheme -> Haskell;
Scheme -> Racket;
LISP -> Scheme;
LISP -> "Qi/Shen";
LISP -> Mathematica;
ML -> Scala;
SystemF -> Haskell;     // GHC Core IR is basically SystemF
ALGOL -> ISWIM;
ALGOL -> Scheme;
LISP -> Planner -> Prolog;
Simula -> ACTOR;
Planner -> ACTOR -> Scheme;
Clojure -> Scala;
SML -> Haskell;
LISP -> FP;
LISP -> CommonLisp;
Scheme -> CommonLisp;
CommonLisp -> Clojure;
CommonLisp -> Haskell;
CommonLisp -> "Qi/Shen";
APL -> Mathematica;
Mathematica -> Clojure;
Mathematica -> Pure;

{ rank=same; CSP; ACTOR; };           // Ideas
{ rank=same; LISP; ALGOL; };           // 1950s
{ rank=same; Planner; APL; Simula; ISWIM; };   // 1960s
{ rank=same; Hope; ML; SASL; Lucid; Scheme; SystemF; FP; Id; Prolog; };   // 1970s
{ rank=same; KRC; Miranda; CommonLisp; Mathematica; Caml; Erlang; Clean; };   // 1980s
{ rank=same; SML; OCaml; Haskell; Mercury; };   // 1990s
{ rank=same; Clojure; Agda; Curry; FSharp; Scala; Pure; Racket; };   // 2000s
{ rank=same; "Qi/Shen"; };   // 2010s

}

Is Prolog influencing Clojure via library (core.logic)?
If so, is Prolog influencing Scheme via library (miniKanren)?