Integrate with OpenCog

[ceo-4com]

We have to get the best, worst, expected points from OpenCog API, when we:

• creating/changing weight of relationship/attribute/implication

[jac2130]

Yes well in order to get this we first need to put all of the data into the opencog system ....it will then calculate these and there is an API now that should be able to handle this, although there are likely or almost definitely a few minor changes that will be needed and we should collaborate on.

The Opencog API that we have built so far has the following functions and you can see how it is used as well, in the code underneath this line:

if name=="main"

in this file: https://bitbucket.org/collectiwise/flask-oc/src/master/py2scheme.py

You can see that in order to get worst case, expected and best cases you have to first put all related (connected) statements into OpenCog. We will need to insert the entire ConceptNet when we build ConceptNet we should also build the AtomSpace database which is a translation of our ConceptNet data into the Atomese format: https://wiki.opencog.org/w/Atomese

Also this python code might even be better to be used, depending on what we decide:

For persistence: https://github.com/opencog/atomspace/blob/master/opencog/persist/README Scheme Router

[ceo-4com]

Let's separate this job into stages.

1. We get final open cog image with API and run it
2. We will import all current data into open cog
3. We will call Open Cog each time when we create smth or need to get the data

[ceo-4com]

For 1 - @jac2130 share the current image so we can run it

[ceo-4com]

Also, we need next endpoints and parameters description with examples, you can put it into the doc:

1. Create concept (user or any other concept) - you have to check duplicates and give us error if concept exists (coz it have to be unique) --Done

2. Create relation --Done

3. Create predicate --Done

4. Create relationship --Done

5. Get relationship weight --Done

6. Change relationship weight --Done

7. Create attribute --Done

8. Get attribute weight --Done

9. Change attribute weight --Done

10. Create implication

11. Get implication weight

12. Change implication weight

[jac2130]

Functions I've built and (in the case of implication, I'm still working on): with names of things: (uri==uri string == id string)

1) find_users (GET):

• takes nothing
• returns a list of user uri strings (IDs).

2) create_user (POST):

• takes: ID: uri string, first: string of first name, last: string of last name
• returns: nothing

3) find_synonyms (GET):

• takes: ID:uri string
• returns a list of names that are synonyms.

4) create_concept (POST):

• takes: concept_id: a uri string, concept_name: a name string, user: a uri string
• returns nothing

5) create_predicate (POST):

• takes: name_id: a predicate name, which is also an id, user: a uri string, and optionally context: a uri string, representing a concept that is a context.
• returns nothing

6) create_relation (POST):

• takes: name_id, again a name that serves as id, user_id: a uri string, properties: a dictionary with properties and truth values, such as {"transitive":True, "symmetric":False}
• returns nothing

7) create_relationship (POST)

• takes: user, concept1: uri string, concept2: uri string, relation: name id, weight: float
• returns nothing

8) create_attribute (POST)

• takes: user: uri, concept: uri, predicate: name id, weight: float, and optionally a context: uri -returns nothing

9) create_implication (POST)

• takes: user: uri, arguments: dictionary with labels as keys and statements as values, if_formula: a string like "(A AND B) OR (A AND C) OR (B AND (A OR C))", then_formula: another string like "C OR (B AND A)" , weight: a float. For the two formula-stings, the parentheses must match; or it throws an error! The formulas must only contain 1) parentheses, 2) label-strings, "A", "b", "A0, ...,W875" etc and 3) "OR" and "AND" strings. "NOT" is not yet implemented but I'll be doing that soon!
• returns nothing

10) change_weight_attribute (POST)

• takes: same as create_attribute, where the weight parameter now is the new weight. It will effect the user's points though and thus, get_user_points should be called after this one. To get the new points. It also adds to the list of participants to the discussion of the attribute and thus get_statement_users(attribute) should also be called after this function, to get an update.
• returns nothing 11) change_weight_relationship (POST)
• same signature as create_relationship
• adds to the relationship's discussants? participants? don't know what to call them. Also changes price of relationship and of course the points of the user etc.

12) change_weight_implication (POST)

• same signature as create_implication. Many effects on various data points.

  there are a number of other functions that I can expose (get_statement_maker, which returns the user id of the person who initially created the statement.

*****WARNING! THE get_weight functions are different in that they don't take a user_id!

13) get_weight_attribute (GET)

• takes: concept: a uri, predicate: a name_id
• returns a float between 0 and 1

14) get_weight_relationship (GET)

• takes: concept1: a uri, concept2: a uri, relation: a name_id
• returns: float between 0 and 1

15) get_weight_implication (GET)

• takes: arguments: a dictionary of the form {"A": {"type": relationship, etc etc}, "B": {"type": "implication", etc. etc.}}, if_formula: a string with balanced parenthesis, containing "OR" and "AND" statements, as well as labels, "A0", ...."R3976", "Z917656432" etc. and finally, a then_formula: another string of the form "A AND B OR (F OR X)" etc. If the parentheses aren't balanced an error is thrown.

16) get_points (GET)

• takes: user: a uri
• returns an integer, such as 100054

17) lookup_exp_attribute (GET)

• takes: concept:uri, predicate: name_id, newweight: float between 0 and 1
• returns worst_case, expected_case, best_case: a tuple with three integers of points that are possible to gain or lose.

18) lookup_exp_relationship (GET)

• takes: concept1: uri, concept2: uri, relation: name_id, newweight: float between 0 and 1
• returns as 17)

19) lookup_exp_implication (GET)

• takes: arguments (as described above, see change_weight_implication), if_formula: as described above, then_formula: as described above
• returns as 17, 18

20) get_user_points (GET)

• takes: user: uri
• returns integer ...to be continued