From a Python function to a true relation (a short personal essay)

[haijinSk]

“We should ask ourselves what constraints could do that would capture the imagination […] we need to have big dreams […]”

Eugene C. Freuder: Holy Grail Redux, Constraint Programming Letters 1, 2007

“At the root of every discipline lies a mystery: the mystery of life, matter, the stars, number, or space. It is the mystery that fascinates us and impels us to know more.”

J. N. Hooker: Good and Bad Futures for Constraint Programming (and Operations Research), Constraint Programming Letters 1, 2007

“Conceptualizations are our inventions, and their justification is based solely on their utility. This lack of commitment indicates the essential ontological promiscuity of Logic Programming: Any conceptualization of the world is accommodated, and we seek those that are useful for our purposes.”

Michael Genesereth, Vinay K. Chaudhri: Introduction to Logic Programming, 2020

“Using DCGs for tasks other than parsing is an acquired programming taste.”

Leon Sterling, Ehud Shapiro: The Art of Prolog, 1994

I can live without Prolog. I have to say, I can live even without programming. But I can’t live without imagination and my imagination, too, was captured by the web-book and videos The Power of Prolog. Somehow, I like ideas about programming in themselves.

In Decremental Development by Kevlin Henney (YouTube), I saw this Python code:

def roman(number):
    numerals = [
        [1000,"M"], [900, "CM"],
        [500, "D"], [400, "CD"],
        [100, "C"], [90,  "XC"],
        [50,  "L"], [40,  "XL"],
        [10,  "X"], [9,   "IX"],
        [5,   "V"], [4,   "IV"],
        [1,   "I"]
    ]
    result = ""
    for divisor, letters in numerals:
        result += (number // divisor) * letters
        number %= divisor
    return result

Yes, the idea is that the heart of the program lies in the representation of the data; representation as the essence of programming.

I can live without Prolog, yet Prolog, the modern Prolog, haunts me. I saw that code and immediately: Can I write it in Scryer without thinking? I mean, preserving the structure/shape of the Python code as much as I can. And, can I write it as a true (bidirectional) relation?

My previous attempt to write a “code-essay” (as an unexperienced beginner), a lyric essay even, was… weird. Unfortunately, I’m still an unexperienced beginner. I can write only baby-code. And baby-English.

I said without thinking? Then, all I need is the power of modern Prolog…

“Constraint programming represents one of the closest approaches computer science has yet made to the Holy Grail of programming: the user states the problem, the computer solves it. […] All of this would be irrelevant were not constraints a natural medium for people to express problems in many fields.”

Eugene C. Freuder: In Pursuit of the Holy Grail, 1997

I know, this is the “large language models” age. But my soul hungers for ideas how to program. On my own computer. Offline.

I’m “intuition first” person. I have blind spots in numbers and long deductive chains. In my fantasy, I can use Scryer, at least sometimes, as AI made exactly for me.

:- use_module(library(clpz)).
:- use_module(library(dcgs)).

clpz:monotonic.

numerals([
  [1000,"M"], [900, "CM"],
  [500, "D"], [400, "CD"],
  [100, "C"], [90,  "XC"],
  [50,  "L"], [40,  "XL"],
  [10,  "X"], [9,   "IX"],
  [5,   "V"], [4,   "IV"],
  [1,   "I"]]).

roman(0,[]) --> "".
roman(N, [[Divisor, Letters] | Numerals]) -->
  { #Multi #= #N div #Divisor,
    #N2    #= #N mod #Divisor,
    #N     #= #Divisor * #Multi + #N2 },
  letters(Letters, Multi),
  roman(N2, Numerals).

letters(_,0) --> "".
letters(L,M) -->
  { #M #> 0, #M2 #= #M - 1 },
  L,
  letters(L,M2).

number_roman(Number, Roman) :-
  numerals(Numerals),
  phrase(roman(Number, Numerals), Roman).

My string multiplication is letters//2. To make it work nicely in a “two-way” mode, “backward” from the string of roman numerals, I had to add (it’s not in the Python code), in roman//2, this line, this (intuitive) constraint:

#N #= #Divisor * #Multi + #N2

For example, the most general query:

?- number_roman(N,R).
   N = 0, R = []
;  N = 1, R = "I"
;  N = 2, R = "II"
;  N = 3, R = "III"
;  N = 4, R = "IV"
;  N = 5, R = "V"
;  N = 6, R = "VI"
;  N = 7, R = "VII"
;  N = 8, R = "VIII"
;  N = 9, R = "IX"
;  N = 10, R = "X"
;  N = 11, R = "XI"
;  N = 12, R = "XII"
;  N = 13, R = "XIII"
;  N = 14, R = "XIV"
;  N = 15, R = "XV"
;  N = 16, R = "XVI"
;  N = 17, R = "XVII"
;  N = 18, R = "XVIII"
;  ... .

This is not my first version of the roman numerals code (I experimented with foldl/maplist/length/lambda version: without explicit recursions), but thanks to CLP(ℤ), my main “contribution” in the transformation was the simple line.

[UWN]

No need for numbers.

[haijinSk]

Thank you for reading, thank you for the link. I've not seen that before.

But, I know, I'm the last person suited for sharing any code (let alone an effective solution to a problem) or to educate others. Perhaps, I wanted to share how the quotations are expressing something.

[jjtolton]

❤️ ❤️ ❤️ ❤️

“We should ask ourselves what constraints could do that would capture the imagination […] we need to have big dreams […]”

Eugene C. Freuder: Holy Grail Redux, Constraint Programming Letters 1, 2007

“At the root of every discipline lies a mystery: the mystery of life, matter, the stars, number, or space. It is the mystery that fascinates us and impels us to know more.”

J. N. Hooker: Good and Bad Futures for Constraint Programming (and Operations Research), Constraint Programming Letters 1, 2007

“Conceptualizations are our inventions, and their justification is based solely on their utility. This lack of commitment indicates the essential ontological promiscuity of Logic Programming: Any conceptualization of the world is accommodated, and we seek those that are useful for our purposes.”

Michael Genesereth, Vinay K. Chaudhri: Introduction to Logic Programming, 2020

“Using DCGs for tasks other than parsing is an acquired programming taste.”

Leon Sterling, Ehud Shapiro: The Art of Prolog, 1994
...snip...
I said without thinking? Then, all I need is the power of modern Prolog…

“Constraint programming represents one of the closest approaches computer science has yet made to the Holy Grail of programming: the user states the problem, the computer solves it. […] All of this would be irrelevant were not constraints a natural medium for people to express problems in many fields.”

Eugene C. Freuder: In Pursuit of the Holy Grail, 1997
... snip ...
but thanks to CLP(ℤ) ... snip...

Yes, yes, YES to all of this!! Thanks for giving me some amazing reading to follow up on!! As someone who, too, was recently intellectually seduced ( 🤣 🥀 🍷 🌹 🍻 🥳 🕺 ) by the power of modern Prolog, and as a looooong time Python developer, this really hit home! Thanks for giving me some great reading and some great sources to follow up.

I know, this is the “large language models” age, but

This very thing led me to Prolog in the first place, the complete lack of "programmability" of language models to do anything remotely useful with any speed or reliability. In the AI field (pre-LLM days), I think many people were more aware of the fact that the greatest breakthroughs are not going to be with ever increasing model sizes but with neurosymbolic architecture, and you can't spell "Neurosymbolic" without "Prolog", and I've finally learned enough Scryer to prove it!

string_substring(String0, String) :-
        String=[_|_],
        append(_, String1, String0),
        append(String, _, String1).
        
cant_spell_without(String, Substring) :-
        (   cant_spell_without_(String, Substring)
        ;   string_substring(String, Substring)
        ).
cant_spell_without_("neurosymbolic", "prolog").        

?- once(cant_spell_without("neurosymbolic", N)).
%@    N = "prolog", Joke=😂.