I originally asked on /sci/ because I don't think "propositional grammar parsing" is the phrasing academia would use to describe this concept, and I don't think software in general is any good at giving useful names to abstract processes. (Otherwise it would be hell to Google.)
I figured it couldn't hurt to ask Sup Forums as well.
Other urls found in this thread:
en.wikipedia.org
twitter.com
Can you give a sample input and output of what you want and what you expect? There are tons of proof-based languages like coq, etc. that deal with this kind of stuff.
I love coq
I licked a negro once
I don't know what I would want it to look like, just that it understands all logic-conveying words and grammar structures. For example, "I think I'll eat fruit today because it's healthy," can translate into either:
while(eng("it's healthy","fruit")){cause(eng("I think I'll eat fruit today"));}
Or:
for(;today();){if (Fruit.isHealthy()){I.think(I.will("eat %@",Fruit));}}
In other words I don't care about the level of abstraction so long as it's able to output some measure of more readily accessed formatting of logical premises than all the different words and grammar structures out there.
Can't help you but I'd like to know more about this as well
And I don't necessarily need lexical/textual output either.
+-----+-------+
|fruit|healthy|
+-----+-------+
-->
+-----+-----+
|think|I -->|
+-----+-----+
| eat |fruit|
+-----+-----+
Worst case scenario we could just roll our own.
Flow control designators:
if then unless else whether [be]cause by as with
Boolean operators:
or and not
Modifiers:
either (to designate XOR (from an "or" clause))
Only an actual complete list. Honestly, getting a complete list is the hard part. I could do the rest on my own.
This is not my area, so be patient. Do you want a parser that can put the sentence under a dependency tree, then do substitutions of certain verb sentences to certain logic symbols, creating the logical equivalent of that initial sentence?
Yes, pretty much that exactly. But I don't mind if it processes the delimited clauses themselves into a psuedo-object-oriented statement graph too.
Your original problem involves natural language processing. There are tons of libraries like python's nltk which can help you there. The point is to try to get to an abstract syntax tree which you can process easily. if you constrain it to keywords, I'd recommend trying to construct a context-free grammar where your flow control designators, boolean operators, modifiers, etc. are "keywords" and then construct an abstract syntax tree with a parser; parser generators like yacc and antlr could help. Once you have this, you'll have to come up with the substitution rules themselves. Although, there a couple of simple ones like (p => q) (!q => !p). From here on, you'll need to decide what it means for two clauses to be equal.
Our lord and savior Stephen Wolfram (praise upon him) has a interpretative language called Wolfram Language (very creative), and as far as I know, it can do that automatically. How to download their interpreter to avoid the (((cloud)))? I don't know.
You have to pay if you don't want a shitty plan. That fucking jew...
Well the reason this question came up was because humans are able to entertain propositions and reason about them to decide if they want to believe or agree with those propositions or not. A thinking algorithm would need to be able to do the same if we want it to possess the trait known as "general intelligence."
So restricting a technology like that to the cloud is almost like literally stealing consciousness.
The problem is that you need to create a database. I'm so angry that there is no free alternative for the wolfram language.
Not for what I'm thinking. Once you have the algorithm figured out, you can make a library that processes English phrases into programmatically separate clauses. It may be a pretty big algorithm with a ton of moving parts, but you don't need a database because there aren't infinitely many grammatical structures in any natural language.
I see what you want to do with the parser, and I must say it is not absurdly difficult to do, I was thinking about what comes next. But yes, you can elaborate a predicate logic system with temporal quantifiers, or something like that, so you could turn a sentence into a very compact logic sentence.
I'm abusing wikipedia, Jesus. Someone back in the day knew we would have this thread, so he already made up this tool for us: en.wikipedia.org
I keep opening more and more links, how deep the rabbit hole goes?!
Coalburner.
You haven't imagined a random guy entering KFC and licking a random costumer in the cheek, then right after that leaving the place?
>what comes next
Hence "pseudo" object-oriented. A dictionary is a database by any standard, so it would be a lot easier to deal with a database of words than to try to turn every concept-clause into a object class hierarchy. The idea is that if you had this, you could abstract out the bulk of the logic and just deal with discrete noun/verb/ad(verb/jective) on a more readily accessed programmatic basis. Think like a programmable NLP interface being one use of this algorithm.
Chatbots would explode.
Thanks, I'll look into its semiotics. One keyword in abstraction of 'natural language processing' is a hell of a lot better from a Google standpoint than no keywords worth of abstraction.
It's mathematical logic all the way down.
yacc/lex or bison/flex are pretty easy to program, just look at a couple of tutorials first.
While NLP, translation, etc is cool stuff, it's probably hell to actually implement in code. Good luck.
I am officially god of this concept.
I'm not actually going to make anything. I guess I was mostly just disappointed that in all the time natural language processing has been around, nobody thought to ask, "Does automated reasoning not rely on locating the parts of language that denote logic and reason?" It seems kind of obvious in retrospect, so I figured maybe it was already out there.
What a mess. I can tell by the number of red links on that article that this field isn't being well-tended to.
That looks like it'd be overkill for something like this. Plus, formal proofs in the space of natural language are really hard to work with or think about.