libera/#lisp - IRC Chatlog
Search
19:38:08
White_Flame
the input allows many broad logics, while the intermediate is a normalized logical form that fits its inference mechanisms
19:38:18
Shark8
"The Evolution of CycL, The Cyc Representation Language"? -- Reading it now. That's where the first gut-feel of being related to ACE came from.
19:44:07
Shark8
prokhor__, Unknown ATM; I'm too unfamiliar with CycDB. // Gut-feel? Given your noting of a [previous] English-parser for the DB, quite probably.
19:44:47
Shark8
prokhor__, (Though, I haven't directly used ACE, the reading I've done on it indicates it is quite usable.)
19:46:17
Shark8
ACE? Nope. / I came across it several years ago looking into DBs and Query-langs, thought it sounded interesting.
19:47:10
prokhor__
https://libgen.rocks/ads.php?md5=86945e333d2468f0a386ea5c33324b2f&downloadname=10.1016/0004-3702(93)90095-s
19:47:57
prokhor__
i know of many attempts to implement a subset of English as a programming/query language...
19:48:07
White_Flame
Shark8: the goal of Cyc is to be able to store & use "common sense knowledge of the world", as in "Something falls when it's dropped", and "A block of iron is not sentient" etc, that we constantly assume when we make statements & descriptions
19:48:38
White_Flame
of course, not expressed in English, but having created a logical & even philosophical ontology about how to describe things
19:49:08
White_Flame
and thus it is required to store a massively broad variety of types of information
19:49:58
Shark8
White_Flame, ight. Which is precisely *WHY* I connected it to ACE: those are the sort of queries that they use to demonstrate the character of ACE.
19:51:37
prokhor__
btw: https://libgen.li/index.php?req=lenat+douglas&columns%5B%5D=t&columns%5B%5D=a&columns%5B%5D=s&columns%5B%5D=y&columns%5B%5D=p&columns%5B%5D=i&objects%5B%5D=f&objects%5B%5D=e&objects%5B%5D=s&objects%5B%5D=a&objects%5B%5D=p&objects%5B%5D=w&topics%5B%5D=l&topics%5B%5D=c&topics%5B%5D=f&topics%5B%5D=a&topics%5B%5D=m&topics%5B%5D=r&topics%5B%5D=s&res=25&filesuns=all&curtab=f&order=&ordermode=desc&filesuns=all&page=2
19:59:18
Shark8
White_Flame, prokhor__ -- The HL/EL use/interaction (in the evo. paper) seems like using multiple prover-engines in Ada/SPARK: launch them all, and when one finished, terminate the other and produce the result.
20:00:08
White_Flame
but cyc is the only system that has achieve its level of capability and scale, which makes it interesting
20:01:18
prokhor__
thats why i am eager to see what it can do combined with that 5th gen stuff (cyc being a direct reaction to it)...
20:04:09
Shark8
Hm, Microtheories/Contexts has the feel of windows/virtual-tables in SQL, with a dash of stored-procedures/triggers.
20:04:50
prokhor__
is free to look at the Cyc KB and draw inferences as it requires them. " does that mean, it is query based(though multiple queries at once)?
20:04:56
White_Flame
it's a segmentation of the universe, allowing bounding the search as well as allowing discrepancies between how different microtheories describe things
20:05:41
White_Flame
but when you write a cyc application, you're intended to integrate it with cyc,not just have it as an external program talking to it
20:06:26
White_Flame
those are all up to you to implement, they are not "reactive" in that sense, except for indexing
20:06:56
White_Flame
but it's also intended to be a model of first dumping a lot of information into it, then querying it; as opposed to constantly asserting & retracting stateful information
20:30:01
prokhor__
White_Flame, Shark8 : given i have access to that: what do your gut-feelings say? could i implement / translate the cyc db into that framework?
20:34:58
Shark8
prokhor__, (that = ACE, or ADA/SPARK?) -- ASE is [IIUC] more about the querying, Ada/SPARK's are about theorem-proving, whereas Cyc is the DB representation (?), and CyCL is the Query/manipulation language (?)... all of these are separate "modules" and, in the whole-of-the-knowledgebase holistic-sense could all work together.
20:36:06
prokhor__
Shark8: well: the cyc db is implemented in cycl (ie its "records" are written in cycl).
20:36:30
Shark8
prokhor__, So, I think the answer is 'yes'... the real question though is how hard or easy would realizing the implementation *be*?
20:42:01
prokhor__
Shark8: the main constraint is, that i have to translate the facts from s-expressions automatically i cannot handle 10^x, x > 5, manually
20:44:35
Shark8
prokhor__, The LispWorks/KnowledgeWorks link you provided means you're using (or have access to) that system?
20:47:02
Shark8
prokhor__, I see a mention of a Prolog implementation/// was that what you were going to use? (i.e. automating the equivelant of translating the 'fact' to a prolog-statement and obtaining its CLOS-object?) Or am I misunderstanding your initial thrust/approach?
20:55:53
prokhor__
White_Flame: if i have to separate between "mere" facts & rules in the db: i was thinking of considering everything which has an arity a rule - do you think , that would be a valid approach (given your experience wth the db)?
20:56:26
White_Flame
every fact (foo 1 2) is semantically equivalent to the single rule (foo 1 2) <- (true)
20:57:17
White_Flame
most systems actually handle both heads equivalently, and an empty rule body is considered <- (true), so I'm not sure it makes much of a difference
20:57:47
prokhor__
which would mean, you could write every fact in cycs db as a rule (or vice-versa)(?)
20:57:47
White_Flame
interpreting the "<- (true)" body (instead of just having a quick-path test to true) might slow things down a bit
21:01:27
prokhor__
White_Flame: maybe youll have a look at the quixote kr language/db some time (implemented in guarded horn clauses)...
21:01:49
Shark8
prokhor__, That's a solid plan; the only things that I would recommend are: (1) have your "target" for the translation [mostly] fixed, e.g. as you said separating facts & rules, so that your "structure" is consistent; (2) consider whether or not [and how much] the Cyc/CycL views should be structured into it as well; and (3) consider whether it would be useful to have a common-interface such as using facts & rules interchangeably WRT the "public" or
21:01:50
Shark8
"private"-interface (that is to say, whether it would be useful to have "implementation-hidden" objects, using a good interface to "unify" interaction).
21:02:33
White_Flame
prokhor__: it doesn't seem on the surface that GHC changes the actual syntax all that much
21:03:08
White_Flame
in terms of what you can & can't do with prolog, but I haven't looked into quixote specifically, just read through taht ghc paper
21:06:43
prokhor__
https://www.airc.aist.go.jp/aitec-icot/ICOT/Museum/SOFTWARE/QUIXOTE/introE/primer1.html
21:39:02
prokhor__
Shark8, White_Flame: thx for the discussion btw, didnt have such a good talk in a while...
21:42:49
Shark8
prokhor__, I had a good talk, too; last year I was in the middle of going down the IR rabbit-hole, thinking about several things: how it would have been better if (e.g.) WebAssembly had done a more parallel-friendly design [akin to the conclusion in the Guy Steele vid], how to design the IR to be storable/decomposable in a DB, and how to manipulate such a DB-based IR.
21:48:46
prokhor__
but the essence of that vid, imho, is like White_Flame said: the implementor has to deal with the implementation, so the user doesnt have to...
21:58:03
Shark8
prokhor__, Yes, but again with the caveat that you can make things easier on yourself; as I used in the example upthread, you could have gotten an OS to be multi-core by writing the OS using the TASK/TASK TYPE in Ada and recompiling with a multicore aware compiler, exactly by minimizing your dependence on the implementation details (via usage of the TASK/TASK TYPE constructs).
21:59:51
prokhor__
i think there is not one correct answer to that... everybody does as he is used to/suits him best...
22:00:51
Shark8
In some sense it *is* sweeping things under the rug (ie being unconcerned that the TASK *might* be compiled with only a single-core assuming compiler) and putting the onus on the compiler, but on the other hand it's (a) using high-level specification/construction, and (b) allowing the abstraction to be interpreted/realized in some other manner.
22:00:57
prokhor__
i have some vague top-level ideas of my implementations, but i also test them by thinking about specific low-level problems in those cases...
22:03:58
Shark8
prokhor__, (re: Top-down vs Bottom-up) -- I've talked with some programmers who really love Ada because you can do some nice things like Top-down design and bottom-up implementation (in this case by defining the packages, types, and [visible] subprograms [as stubs], getting a clean compile, then "backfilling" by implementing them).
7:28:59
rendar
can we say that apply internally checks the number of arguments that the functions accepts, and if its 2, and the list of params len > 2, it will act like a reduce