Re: RDF based messaging, negotiating, and dataset semantics

Kevin Singer pointed out to me that there is a downside to the 
'ex:undeletes' property: it introduces unnecessary complexity and 
ambiguity. To undelete a deleted message, m1 one could delete the 
message m2 that deleted m1, or one could explicitly undelete m1. This 
ambiguity may lead to more complex implementations.

The advantage of the 'ex:undelete' property is that one can easily 
determine which URI to use for the object: just the uri of the message 
to be deleted. In order to undelete a deleted message m1 without the 
'ex:undeletes' property, one has to find the last 'ex:delete' statement 
in a possibly long chain of 'ex:delete' statements the first of which 
deletes m1.

So I currently see three options:
1. Leave the design as it is
2. Remove  the 'ex:undeletes' property
3. Fix the ambiguity problem of the suggested design by disallowing to 
delete delete statements.

Any thoughts on which to prefer?

Am 04.07.2017 um 20:47 schrieb Florian Kleedorfer:
> Thanks for all your contributions! From what I can gather there does 
> not seem to be an existing approach for what I need, so here's an 
> informal attempt:
>
> For editing of the message history, I think we only need two 
> properties, one for deleting a previously added named graph from the 
> dataset (e.g., ex:msg1 ex:deletes ex:msg2), and one for undeleting a 
> named graph (e.g., ex:msg3 ex:undeletes ex:msg2).
>
> For determining the meaning of the dataset, one would iterate over the 
> named graphs in reverse chronological order and build a set 'del' of 
> named graph URIs that are to be interpreted as deleted. For each 
> message, it is only processed if its URI is not in del. Whenever an 
> 'ex:deletes' triple is encountered, the URI in the object of the 
> triple is added to del. Whenever an 'ex:undeletes' triple is 
> encountered, the URI in the object is removed from del. Both 
> operations are only executed when the sender of the deletes/undeletes 
> message is also the sender of the message to be deleted/undeleted. 
> Each processed message (named graph) is added to the result dataset.
>
> The case of negotiation, I think requires two additional properties, 
> 'ex:proposes' (range: Message) and 'ex:agreesWith' (range: Message) . 
> 'ex:proposes' indicates that the 'proposed' message is not just any 
> statement, but one that the sender wants the recipient's agreement 
> on.  'ex:agreesWith' indicates that the sender agrees with the content 
> of another message, the default interpretation being that nobody 
> agrees with anything.
>
> Such messages can also be deleted as described above, with a later 
> 'deletes' message - allowing for dynamically proposing, accepting and 
> un-accepting graphs (which may be suggestions for clauses in a 
> contract, for example).
>
> So, when the full conversation dataset has been filtered based on 
> deletes/undeletes information as explained above, one can decide 
> whether the agents agree. When all messages that have been 'proposed' 
> by one agent are 'agreed' to by the other, the participants can be 
> said to agree. If there is at least one proposed message that is not 
> agreed to, the participants disagree. Otherwise (if no messages are 
> proposed), there is no agreement status.
>
> In case of agreement, the dataset can be filtered easily to select 
> only the graphs that are part of the agreement. In case of 
> disagreement, it should be easily possible to determine agreed-upon 
> graphs and graphs that are proposed by each agent but not agreed to by 
> the other.
>
> Again, comments welcome!
>
> Cheers,
> Florian
>
> Am 03.07.2017 um 16:17 schrieb Florian Kleedorfer:
>> Hi,
>>
>> Consider a communication channel between two agents who exchange 
>> messages in the form of named RDF Graphs. The channel allows for 
>> adding new messages but not for removing any data. The history of the 
>> channel is unambiguous and always accessible to both agents. This 
>> construct can be seen as an RDF dataset that both agents have 
>> read/write but no replace or delete access to. Its use is that of a 
>> negotiation device that allows for setting up terms of a contract.
>>
>> The way the system is built, the messages consist of any number of 
>> 'content' RDF graphs (the message's payload), 'envlope' graphs with 
>> address information (sender, recipient etc),  and graphs containing 
>> cryptographic signatures.
>>
>> What's needed is an approach that allows these agents to make 
>> assertions about earlier messages (their content graphs) in the 
>> conversation dataset so as to modify the meaning of the dataset.
>>
>> The simplest example I can think of is that one agent might realize 
>> they made a typing error in an earlier message and want to correct 
>> the information by sending a message stating that the earlier graph 
>> should be disregarded and another message containing the corrected 
>> information.
>>
>> Similar situations occur when negotiating aspects of the agreement, 
>> e.g. price.
>>
>> For both agents, at any point in the conversation, the meaning of the 
>> conversation dataset must always be unambiguous and equal, and it 
>> must be clear to both agents if they agree (both hold the same graphs 
>> true) or if there is a conflict.
>>
>> I am contemplating defining a vocabulary that allows for making such 
>> statements and defining dataset semantics that take these statements 
>> into account, unless I find a suitable existing approach. I found the 
>> SWP (Semantic Web Publishing) vocabulary, which is intended to do 
>> something similar, but does not seem to have a negative property for 
>> rejecting a graph, so I'm not convinced. Any Ideas, pointers, or 
>> followup discussions are greatly appreciated!
>>
>> Thanks,
>> Florian
>>
>>
>>
>>
>
>

Received on Thursday, 6 July 2017 10:12:42 UTC