What's the best logic lang for noobs? (I know datalog is teh hotness, just want to invest hours in the right place) Is there a good primer you'd recommend?

I purpose that logic programming is about decoupling how information was added to a system from re-actively taking action on that information. This model is particularly important in traditional browser/front-end applications. The current front end ecosystem structures applications in terms of the DOM, but its also valuable to view But really we need tools that can view the system through either the DOM view or the Action based view. To be concrete: traditional dom view: html when event then html/action/etc... action view action when event then html/action/etc... The key to having both these views is that the system be encoded in such a way that it can read itself and produce multiple views. The closest implementation i have seen to realizing an efficient version of this is https://github.com/oakes/odoyle-rum-todo. Though it doesn't actively try to realize multiple views, the data centric approach gives me how that tools can easily read it to provide this. Here we see the action that effects the footer.

[:what
      [::global ::all-todos all-todos]
      [::global ::showing showing]
      :then
      (let [*session (orum/prop)
            active-todos (remove :done all-todos)
            completed-todos (filter :done all-todos)
            active (count active-todos)
            completed (count completed-todos)
            filter-attrs (fn [filter-kw]
                           {:class (when (= filter-kw showing) "selected")
                            :on-click #(insert! *session ::global {::showing filter-kw})})]
        [:footer#footer
         [:span#todo-count
          [:strong active] " " (case active 1 "item" "items") " left"]
         [:ul#filters
          [:li [:a (filter-attrs :all) "All"]]
          [:li [:a (filter-attrs :active) "Active"]]
          [:li [:a (filter-attrs :completed) "Completed"]]]
         (when (pos? completed)
           [:button#clear-completed {:on-click #(run! (partial retract! *session)
                                                      (map :id completed-todos))}
            "Clear completed"])])]

What do folks think about situational calculus? http://artint.info/html/ArtInt_335.html Specifically I'm interested in ideas and projects where this has been used in "high level programing". One example is that I specify I want to "add a message to a room". This is my goal. This requires planning, e.g. looking at the current situation I see that the message is on client, room is a database on server. Then I determine the sequence of smaller steps (send message to server, append message to db). Often we do the planning in our heads and write out the plan by hand, but can situational calculus help us use the computer to do this planning if we specify the high level goals? It could even provide multiple altenrnative plans and maybe we could choose? Have you seen examples of such use?

Has anyone encountered Dyna before? The project seems to be abandoned now (hence archived link), but it's a logic language that generalises Datalog (a binary logic) to a "weighted logic". Essentially, every fact in the program can be associated with an aggregate number, rather than just "true" and "false". I'm particularly curious whether this is a good approach for providing aggregation in a logic language. Aggregation is an essential feature for writing a non-trivial logic program, but I don't like the kind of aggregation made available in Prolog and traditional Datalog extensions: they feel far too clunky. You could describe the difference as: "Datalog aggregates by combining reads" whereas "Dyna aggregates by combining writes". I'm going to deep dive into Dyna; it would be good to know if anyone here has already explored it 🙂

@Nick Smith IIRC, their new work is all against Dyna-R, for which there's another repo. (No time to go hunting just now.)

came across this book that I haven't heard about before, maybe people here will find it interesting http://webdam.inria.fr/Alice/

resources to implement prolog interpreters https://news.ycombinator.com/item?id=26242450

Found out that PAIP's chapter 11 is a nice intro to implementing prolog https://github.com/norvig/paip-lisp/blob/master/docs/chapter11.md Although, yeah... had to undust my commonlisp environment to work through it 😛 Chapter 12 is about compiling a prolog like dialect, haven't look at the chapter yet but looks interesting too. PAIP also recommends:

Maier and Warren's Computing with Logic (1988) is the best reference for those interested in implementing Prolog. It starts with a simple interpreter for a variable-free version of Prolog, and then moves up to the full language, adding improvements to the interpreter along the way.

... seems to be a cool book but a bit archaic with example code in Pascal... but I guess Pascal is a simple enough language to port to something else without too much effort... hopefully 😛 The bad thing is that I couldn't find the source code anywhere so I'm afraid it may be missing bits and pieces in the book.

With the addition of LAMBDA (a way to write reusable functions) in Excel, could logic programming translate well into a spreadsheet format? I found an old paper that talks about it but not many examples. https://dl.acm.org/doi/abs/10.1145/67449.67466

does anybody know if the ":-" from prolog has a name? I thought it was a textual form of "turnstile", but it seems the turnstile operator works on the "opposite direction"

So if I’m understanding logic programming right, it’s basically that I specify the conditions that need to be at some degree of truthiness, and it builds out from there? How does that relate to the actor model?

Following some prolog tutorials, it looks like the data/terms always has sort of a "global scope". How do ppl manage the "database" on medium / big prolog programs? Can there be more than one database? Are there some sort of namespacing and/or modularity features? Sometimes the concept of relations is a bit mind-boggling because it seems difficult to distinguish between relations that act as "routines" or "procedures", or something alike, and terms that act more like pure data. It just feels like, if I was writing an imperative program in prolog style, it would be something akin to code interspersed with, say, embedded CSV data 😕 Hope this makes a bit of sense 🙂

what are good examples of embedded logic programming into other languages? All I can think of are "prologs in lisp" • https://docs.racket-lang.org/racklog/ • https://github.com/clojure/core.logic • https://franz.com/support/documentation/current/doc/prolog.html

Been thinking a bit about "custom unification", or extensible unification. It seems it is a pretty common thing: • A library that implements unification / custom unification in JavaScript • Extending unification in clojure's core.logic • An unification library for Python • Also TIL SWI prolog supports maps/dictionaries Wondering how much it makes sense to use more complex data structures in prolog-like searches. Datalog seems to be an example that going "the other way", being more restrictive, may be more productive:

Datalog disallows complex terms as arguments of predicates, e.g., p (1, 2) is admissible but not p (f (1), 2)

Perhaps unification of complex/custom data structures is more productive for pattern matching than for general logic programming ... but not sure (SWI prolog's dict maybe contradicts this idea).

I was wondering what, if any, was the connection between prolog and theorem provers: https://www.metalevel.at/prolog/theoremproving

Hi, are there any open source databases on the level of postgres that use a prolog or datalog esque logic programming language for querying?

Trying to come up with a list of interesting logic programming systems to learn from and maybe try. Maybe someone here want to contribute to it? BTW, I'm sure there are other lists like this, maybe we can add links to them? For instance, I included a link to a Wikipedia's list of logic PL, but it lists a lot of defunct systems which are more difficult to learn from imho.

Paper showing how you can convert a logic program into a graph, translate it to three different varieties of ASP, and get your choice of stable model, well-founded, or co-stable answers, all with justifications built-in for free, on an open source ASP reasoner. So you can write logic code by drawing a graph. Not sure if it works for prepositional programs, though.

Does anyone know of any circles what help you understand the concepts in the paper jason linked? I google my way to victory in about a dedicated year, but actually talking to the people who know how to read between the lines would probably take that down to a month.

I just invited people in #share-your-work to test out Blawx. I will be presenting a paper and demoing at the ICLP-colocated GDE workshop soon. Interested in feedback from this channel.

Hey! I found some logic programming related stuff in the dev holochain discord which I found somehow relevant and wanted to share here: and here:

Link to prolog Code: https://github.com/perspect3vism/ad4m-executor/blob/main/src/tests/sdna/todo.pl Link to discord message https://discord.com/channels/919686143581253632/966000883391430696/1001443505492729907

Link to Github project: https://github.com/perspect3vism/ad4m-executor

Example please?

Anyone here have some experience with answer set programming? I'm struggling to understand a negation issue, this week.

Working on a paper for the ICLP this week on Blawx as a visual interface for logic programming. Any tips for getting accepted at ICLP would be appreciated. 🙂

Paper accepted! Blawx will have a peer-reviewed citation come summer. Anyone want to fund my trip to England for the conference, so I can actually meet my co-author? 😉

I am trying to suss out what the significance-of/meaning is of “drop_amount...bwd” in the Dungeon Crawler source code (Ceptre). Line 50 https://github.com/guitarvydas/ceptre/blob/dev/dc/dc.cep. Comments? background: I’m building a Ceptre compiler - to Lisp (then “the world”). I think that I can handle most rules by treating them as 3 parts: (1) a pattern to be matched (using PROLOG backtracking), (2) retractions (3) assertions (PROLOG meaning, imperitivized). As it stands, the “compiler” transpiles Ceptre to RT (an intermediate language I created) then RT to Lisp. The significance of forward chaining vs backward chaining is blurring in my mind, esp. the significance of

drop_amount

. Then, I will need to figure out what

z

and

none

are ... Aside: I’m using Nils Holm’s “Prolog ... in 6 Slides” (Scheme code ported to CL (and JS)).

Anyone ever played with Symboleo? I'm only now learning it is under development in Canada (University of Ottawa) for use in legal contracts. Logic based, uses event calculus, implemented in Prolog-inside-Java, looks like. Shares a lot of design objectives with what I'm doing with Blawx.

Excellent talk on meta-interpretation in Prolog