mediKanren
Gleemin
mediKanren | Gleemin | |
---|---|---|
6 | 4 | |
316 | 86 | |
- | - | |
8.1 | 0.0 | |
16 days ago | over 12 years ago | |
Racket | Prolog | |
MIT License | - |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
mediKanren
-
Annotated implementation of microKanren: an embeddable logic language
Not really production, but probably THE most impressive biomedicine research work I've seen (and I'm an academic MD):
https://github.com/webyrd/mediKanren
This is a FOL theorem prover that uses medical research articles as terms. They use it to do genetics and drug repurposing metaresearch. It's like the wet dream of all the biomed machine learning fanboys out there, except that:
1. it's not machine learning
and
2. it really works
-
Human Knowledge and PhDs
And wow, he uses logic programming to deduce a diagnostic from the facts https://github.com/webyrd/mediKanren .. and used to find out what his son had https://www.statnews.com/2019/07/25/ai-expert-writing-code-save-son/
- With a nudge from AI, ketamine emerges as a potential rare disease treatment
-
William Byrd on Logic and Relational Programming, MiniKanren (2014)
Hi Kamaal!
I know Cisco is using core.logic, which is David Nolen's Clojure variant of miniKanren, in their ThreatGrid product. I think the Enterprisey uses of mediKanren are a bit different than the purely relational programming that I find most interesting, though.
Having said that, we are now on our second generation of mediKanren, which is software that performs reasoning over large biomedical knowledge graphs:
https://github.com/webyrd/mediKanren/tree/master/medikanren2
mediKanren is being developed by the Hugh Kaul Precision Medicine Institute at the University of Alabama at Birmingham (HKPMI). HKPMI is run by Matt Might, who you may know from his work on abstract interpretation and parsing with derivatives, or from his more recent work on precision medicine. mediKanren is part of the NIH NCATS Biomedical Data Translator Project, and is funded by NCATS:
https://ncats.nih.gov/translator
Greg Rosenblatt, who sped up Barliman's relational interpreter many order of magnitude, has been hacking on dbKanren, which augments miniKanren with automatic goal reordering, stratified queries/aggregation, a graph database engine, and many other goodies. dbKanren is the heart of mediKanren 2.
I can imagine co-writing a book on mediKanren 2, and its uses for precision medicine...
Cheers,
--Will
-
Bertrand Might: Life, legacy and next steps
The Precision Medicine Institute that I now run produces mediKanren: https://github.com/webyrd/mediKanren
It's an open source logical reasoning engine (read: 1960's AI) for drug repurposing that we deploy routinely to help patients.
There is always a need for better relationalization of biological data sets that feed such tools too.
For example, SemMedDB is really showing its age for NLP of the scientific literature and yet it is still astonishingly useful for helping patients even as is.
Gleemin
-
Annotated implementation of microKanren: an embeddable logic language
Here's some stuff I've written in Prolog, some for my own enjoyment, one for my degree project.
Most of the benefits I found come down to two things:
a) Prolog, like the various kanrens, is a relational language so a program is effectively a database. There's no need to do anything special to glue together a data layer and a logic layer, because you have both written in Prolog.
b) Prolog's declarative style makes translating rules and directives to code a breeze. The three projects below are all games and benefit heavily from this feature. I
1. Warhammer 40K simulation:
https://github.com/stassa/wh40ksim
Runs simulations of combat between WH40k units.
2. Gleemin, a Magic: the Gathering expert system:
https://github.com/stassa/Gleemin
Doesn't work anymore! Because backwards compatibility. Includes a) a parser for the rules text on M:tG cards written in Prolog's Definite Clause Grammars notation, b) a rules engine and c) a (primitive) AI player. The parser translates rules text from cards into rules engine calls. The cards themselves are Prolog predicates. Your data and your program are one and now you can also do stuff with them.
3. Nests & Insects, a roguelike TTRPG:
https://github.com/stassa/nests-and-insects
WIP! Here I use Prolog to keep the data about my tabletop rpg organised, and also to automatically fill-in the character sheets typeset in the rulebook. The Prolog code runs a character creation process and generates completed character sheets. I plan to do the same for enemies' stat blocks, various procedural generation tables, etc. I also use Prolog to typeset the ASCII-styled rulebook, but that's probably not a good application of Prolog.
You asked about "logic programming" in general and not miniKanren in particular. I haven't actually used miniKanren, so I commented about the logic programming language I've used the most, Prolog. I hope that's not a thread hijack!
All three of the projects above are basically games. I have more "serious" stuff on my github but I feel a certain shortfall of gravitas, I suppose.
-
50 Years of Prolog and Beyond
official name):
https://github.com/stassa/Gleemin/blob/master/mgl_interprete...
The first two-thirds of the source in the linked file is a grammar of a subset
-
An embeddable Prolog scripting language for Go
I've been keeping an eye on this to use for the rules engine in a card game I'm writing[0]. Very excited to get back into using Prolog; I think it's fallen by the wayside a bit in the last decade or two but there's some sectors that still have strong arguments for using it if not as the main language then at least an extension language.
[0] Inspired by a HN comment a while back about Gleemin, the MTG expert engine in Prolog: https://github.com/stassa/Gleemin
-
The Computers Are Getting Better at Writing
Representing costs in a meaningful manner is a constant problem in every M:tG generator I've seen.
The problems I highlight above are not with grammaticality, which is certainly a big step forward with respect to the past. But many of the abilities still don't make a lot of sense, or don't make sense to be on the same card, or have weird costs etc.
My intuition is that it would take a lot more than language modelling to generate M:tG cards that make enough sense that it's more fun to generate them than create them yourself. I think it would be necessary to have background knowledge of the game, at least its rules, if not some concept of a metagame.
Also, I note that the new online version of the game is capable of parsing cads as scripts in a programming language using a hand-crafted grammar rather than a machine-learned model [4] [5]. So it seems to me that the state-of-the-art for M:tG language modelling is still a hand-crafted grammar.
__________________
[1] https://github.com/stassa/Gleemin - unfortunately, doesn't run anymore after multiple changes to Prolog interepreters used to create and then port the project over.
[2] https://github.com/stassa/THELEMA - should work with older versions of Swi-Prolog, unfortunately not documented in the README.
[3] https://link.springer.com/article/10.1007/s10994-020-05945-w - see Section 3.3 "Experiment 3: M:tG fragment".
[4] https://www.reddit.com/r/magicTCG/comments/74hw1z/magic_aren...
[5] https://www.reddit.com/r/magicTCG/comments/9kxid9/mtgadisper...
What are some alternatives?
racketscript - Racket to JavaScript Compiler
ciao - Ciao is a modern Prolog implementation that builds up from a logic-based simple kernel designed to be portable, extensible, and modular.
microKanren - The implementation of microKanren, a featherweight relational programming language
nests-and-insects - A Roguelike Tabletop RPG
awesome-racket - A curated list of awesome Racket frameworks, libraries and software, maintained by Community
gpt-3-experiments - Test prompts for OpenAI's GPT-3 API and the resulting AI-generated texts.
gui
microKanren-py - Simple python3 implementation of microKanren with lots of type annotations for clarity
frog - Frog is a static blog generator implemented in Racket, targeting Bootstrap and able to use Pygments.
aleph - Port of Aleph to SWI-Prolog
iracket - Jupyter kernel for Racket
louise - Polynomial-time Meta-Interpretive Learning