Rules involving lists

[MattHood]

I'm new to logic programming, and as a learning project I've been using Soufflé to express constructs from music theory.

I'm stuck on trying represent scales and chords as lists of notes separated by intervals. A simpler, equivalent problem would be this: Consider a list Intervals = [1, 3, 4] and a number Root = 3, then the list Notes would be associated with [3, 4, 7, 11], i.e. [3, 3 + 1, 3 + 1 + 3, 3 + 1 + 3 + 4]

In invalid Souffle, which generates errors warning of ungrounded variables and records.:

.type List = [ head: number, tail: List]
.decl Relation(root: number, intervals: List, notes: List)

// Perhaps there needs to be more base cases, but I couldn't work out how to express them.
Relation(root, [int_head, nil], [root, [notes_next, nil]]) :- notes_next = root + int_head.
Relation(root, [int_head, int_tail], [root, [notes_next, notes_tail]]) 
   :-  notes_next = root + int_head,
       Relation(notes_next, int_tail, [notes_next, notes_tail]).

.output Relation

How might one successfully express this problem in Soufflé?

I'm sure this formulation betrays some fundamental misunderstandings of how Datalog and Soufflé work, so if there are no straightforward corrections to be made here, I would really appreciate some advice on how to learn more. For example, I'm struggling to understand what it means for a variable to be ungrounded, and I would love to spend some time with resources (textbooks, tutorials, etc) that would explain this.

Thanks!

[XiaowenHu96]

.type List = [ head: number, tail: List]

.decl Intervals(x : List)
Intervals([1,[3,[4,nil]]]).

.decl SumIntervals(before:List, after: List)
SumIntervals(xs, xs) :- Intervals(xs).
SumIntervals(xs, [z + y, zs]) :- 
    SumIntervals([x, xs], [y, ys]), xs = [z, zs].
.output SumIntervals(IO=stdout)

.decl Result(before: List, after: List)
Result(xs, ys) :- SumIntervals(xs, ys), ys = [y, nil].
Result([x, xs], [y, zs]) :- 
    SumIntervals([x, xs], [y, ys]), Result(ys, zs).
.output Result(IO=stdout)

After that, extract the longest list and add the value of Root to each of the elements.
I'm just unaware of any beginner-friendly textbook, all the textbooks I know for Datalog are all too theoretical and therefore a bit boring. You don't get much programming practice like you would get if you pick up a C++/Haskell textbook.
You can have a look at the test/example directory, and also our documentation page. Besides that, I think try implementing a couple of programming analysis algorithms is also very helpful.
Maybe others can recommend some nice materials.

[MattHood]

Thanks so much - this has definitely helped my understanding. It seems like I had the structure backwards; I was imagining that I should specify some general rules, and then pass my inputs into a query that uses those rules. Instead, it seems like I should start with the inputs (i.e. Interval([1, 3, 4])) as ground facts, and build the rules on top of them. Do you think this is a reasonable conclusion?

Thank you also for suggesting test/example as a resource. I just took a look at some of the examples and I think they're going to be really helpful.