CMake cython version, undefined symbol: _ZN7opencog22IMPLICATION_SCOPE_LINKE"

[mani....@gmail.com]

Hi,

On ubuntu 24.04 (Python 3.12 , Cython 3.0.8) I had to hack FindCython.cmake for it to accept the Cython version. Also loading the PLN module in guile gives the following error:

In procedure dlopen: file "/usr/local/lib/opencog/libpln-types.so", message "/usr/local/lib/opencog/libpln-types.so: undefined symbol: _ZN7opencog22IMPLICATION_SCOPE_LINKE"

 

Does PLN being abandoned means this kind of errors gonna grow more overtime and I should think of something else ?

Thank you,

Mani

[Linas Vepstas]

Hi Mani,

Make sure you git pull build and reinstall all prior dependencies,
including cog-utils, atomspace, the unifier, and URE. There have been
significant changes in the last few months.

I'm confused about the comment about cython. I get `cython3 --version`
0.29.32 and cython never got above 0.2xx never mind something close to
1.0 Perhaps you're using cython 0.30.8 ?? -- "should work", famous
last words.

The PLN build should have worked. The github circleci test uses ubuntu
24.04 and last time it ran, it passed:
https://github.com/opencog/pln
https://app.circleci.com/pipelines/github/opencog/pln

Its unmaintained code but it's also not bit-rotting. It should work
the same as it used to.

There were multiple problems with PLN, the biggest perhaps was that
it was slow.

A nit-pick critique is that It should use RuleLink instead of the
much heavier and slower BindLink. This is a historical design
artifact, but it had a huge performance hit.

A theoretical issue is that It was built on the assumption that
expectation values propagate, and they don't. People who work on
stochastic differential equations deal with this situation in one of
two different ways: either they take a million samples, and analyze
the resulting distribution, or they take a highly technical,
theoretical approach of looking at filtrations (sequences of sigma
algebras) and the cylinder sets and measures thereupon.

The sample-a-lot solution would have been to use crisp-logic inference
(e.g. with SAT solvers or ASP solvers or even prolog solvers) and try
every true-false combo possible, weighting them according to the PLN
formulas. The benefit of this is SAT/ASP are blindingly fast, so you
can map out a million possibilities quickly. The so-called
"probabilistic programming" people tried something like this, slicing
the cake in a different way.

The technical approach is harder, but you'd need portions of it
anyway, just to get the right "sample a lot" answer. I have a vague
inkling that it rubs elbows with some of the deep-learning approaches,
but I get distracted by side-quests whenever I start to think
seriously about such things. There are soooo many interesting things
to work on. It's a bit like being in a candy shop: each theory looks
more delicious than the last one.

Anyway, my impression was that PLN in the literal sense wasn't that
useful (for anything I do.). In the metaphorical sense, where
collections of sensori-motor systems or agents self-organize near a
critical point, interacting with one another by sending snippets of
PLN rules (or snippets or prolog-rules, or snippets of
predicate-logic-type interconnections with each other, ... I'm
agnostic about which) yes I think this is where rules systems get
interesting. Think "a-life" (artificial life) or perhaps
Conways-game-of-life, but instead of being on a square grid, it's on a
random grid, and instead of exchanging single bits, exchange rules or
rule-sets. (and of course, the random network reconfigures, because
some agents will want to communicate more than others.) ***This*** is
where I think the fun stuff is.

If you get the last paragraph, then read through Michael Levin's
"Ingressing Minds" paper, take it as an inspiration (he's a biologist,
not a compsci/math guy), and now apply it to collections of simple
sensori-motor systems (simple systems that can perceive structures,
and move through them. For example "perceive file systems" (I think
that's more interesting than vision, sound, walls of text, because it
disposes of the regularity, and goes for the throat of recursive
structure.) and then move around through that space, interacting with
it, as autonomous agents. (Again, instead of 3D minecraft, move
through an abstract space of relational structure.))

Whatever. I think it's cool, but I find it very difficult to make
forward progress. It gets abstract and complicated really fast. But
still, this is where I've been poking, when it comes to "doing stuff
with rule-based systems".

-- linas

> --
> You received this message because you are subscribed to the Google Groups "opencog" group.
> To unsubscribe from this group and stop receiving emails from it, send an email to opencog+u...@googlegroups.com.
> To view this discussion visit https://groups.google.com/d/msgid/opencog/5b90c7dd-16f7-44cb-887d-188e35cea02en%40googlegroups.com.



--
Patrick: Are they laughing at us?
Sponge Bob: No, Patrick, they are laughing next to us.