[sc34wg3] Illustrating SIDPs

[Dmitry]

On May 8, 2004, at 1:15 PM, Patrick Durusau wrote:

> Dmitry wrote:
>> On May 4, 2004, at 2:30 PM, Patrick Durusau wrote:
>>> SIDPs (and, for that matter, OPs) can be arbitrarily complex.
>>>
>> That is what I cannot find in current TMRM. I see that SIDP can be 
>> defined as "combination of properties"  which I cannot call 
>> "arbitrarily complex".
>
> Why did you decide that "combination of properties" does not equal 
> "arbitrarily complex?"
>
> Would you prefer "arbitrary combination of properties?"
>
> Curious because that "combination of properties" is understood (by me 
> at any rate) to mean "arbitrarily complex."
>

 From my perspective "combination of properties" is quite arbitrarily 
choice  as a mechanism of identity disclose. I share understanding of 
necessity to disclose identity concepts. I just try to understand 
different options available to do that. And I try to understand why 
SIDPs-based solution is better than others.

>> TMCL on the other hand can express any equivalence function. I just 
>> think that TMCL is more general and powerful approach for defining 
>> equivalence classes. "Combination of properties" is a subset of 
>> possible equivalence functions.
>
> There is no other hand. The TMRM and TMCL are addressing completely 
> different levels of the topic map paradigm.
>
> The TMRM is not defining a syntax but the rules for a disclosure 
> statement, on which a syntax would be based.
>
> In other words, the TMRM allows disclosure of the basis for identity 
> that must underlie any equivalence or other functions.

OK,  let's forget about 'TMCL'  label for a moment.  It looks like it 
does not help in this discussion.

Let's say that I would like to suggest my own mechanism to disclose 
identity doctrines.
In my model I have  "same_as" equivalence  function which defines 
equivalent entities. Disclosing identity doctrine  is done by providing 
a definition of this equivalence function.

Definition can use any logical constructs including statements such 
every X in P(X) satisfies Q(X) etc.

Patrick, can you consider for a moment this alternative way  to 
disclose identity doctrines?

I hope I work at the same level as TMRM now. From my perspective, any 
SIDPs-based identity disclose can be expressed as equivalence function 
disclose.


>> Let's, for example,  introduce concept "ordered sets" in topic map.
>> With TMCL we can easily define following equivalence function:
>> Two topics of class "ordered set" are equivalent if they have 
>> equivalent members.
>> Can TMRM (using SIDPs) allow to disclose these kind of equivalence 
>> rules?
>
> Mixing levels again. The TMRM, using SIDPs, enables the disclosure of 
> identity that must be present for any such rules to make sense. And 
> yes, you can then disclose the equivalence (or any other rule) that 
> you like.
>
>> TMCL can do it because it allows to specify conditions such as "each 
>> X in P1(X) satisfies P2(X)" and use full power of logical operators.
>>
>
> So, modulo your supplement post and yes, I understand what ordered set 
> means, let's look at two ordered sets:
>

My sample, I think,  is at  the same abstraction level as your "person 
identification" example. SIDPs can easily handle your case. I try to 
understand how SIDPs can be used to disclose identity rule in my 
sample.

I know how it can be done with equivalence function:

same_as(X,Y):-
       instanceOf(X, Z),
       instanceOf(Y, Z),
       subjectIndicator(Z,"http://www.example.com/#orderedSet"),
       every NthX, N in member( X,N,NthX)  satisfies 
member(Y,N,NthYEl),same_as(NthX,NthYEl),
       every NthY, M in member(Y,M,NthY) satisfies  member(X,M,NthXEl), 
same_as(NthY,NthXEl).


This partial definition can be added to predefined in TMDM identity 
rules which can be disclosed using equivalence function.

same_as(X,Y):-
     subjectIndicator(X,XURI),
     subjectIndicator(Y,YURI),
     same_as(XURI,YURI).

same_as(X,Y):-
     subjectLocator(X,XURI),
     subjectLocator(Y,YURI),
     same_as(XURI,YURI).

same_as(X,Y):-
     sourceLocator(X,XURI),
     sourceLocator(Y,YURI),
     same_as(XURI,YURI).

Of course, we also need to explain what URI, string equivalence means. 
These are our  identity "axioms".

I also understand that not all identity rules can be deduced from 
subject properties and relationships.

We can specify explicitly that some entities are the same using same_as 
"facts".

same_as(I1,I2):
    subjectIndicator(I1,"http://www.example.com/#johnSmith"),
    subjectIndicator(I2,"http://www.example.com/#ceo(allconsulting)").


> P1(carol, bambi, clarence) and a second ordered set, P2(carol, bambi, 
> clarence).
>
> Hmmm, looks like TMCL would say these are equivalent ordered sets.
>
> But wait:
>
> P1 (carol (wife of patrick), bambi (deer in Walt Disney movie), 
> clarence (patrick's dog), and
>
> P2 (carol (as to sing), bambi (a stripper), clarence (ghost in "It's a 
> Wonderful Life," a movie).
>
> Hmmm, where is the power of TMCL now?
>
> Answer: Well, TMCL presumes a doctrine of identity (that should be 
> defined elsewhere) that allows it to make meaningful comparison of the 
> members of each ordered set.
>

Equivalence function-based disclose relies on  recursive definition of 
"same-as" function.

P1 (carol (wife of patrick), bambi (deer in Walt Disney movie),clarence 
(patrick's dog))
is the same as
P2 (carol (as to sing), bambi (a stripper), clarence (ghost in "It's a 
Wonderful Life," a movie))

if

carol (wife of patrick) is the same as carol (as to sing)
and
bambi (deer in Walt Disney movie) is the same as bambi (a stripper)
and
clarence (patrick's dog) is the same as clarence (ghost in "It's a 
Wonderful Life," a movie)

Equivalence function works well in this case.


> The power of logical operators is available only if there is either:
>
> 1. A presumption of the identity doctrines of the surrogates to which 
> they are to be applied (which can lead to real problems), or:
>
> 2. A disclosure of the identity doctrines of the surrogates to which 
> they are to be applied, in which case the rules for equivalence can be 
> matched to the basis for identity of each surrogate.
>

I need to think about this one more...

I use logical operators to define equivalence function which is a 
formal disclose of identity doctrine (in my case). Well... together 
with identity "axioms" such as URI identity and string identity.

There are several main differences from SIDP-based approach:
  -  We do not need additional "properties" (equivalence function uses 
assertions)
  -  We specify identity "axioms" (URI, string equivalence, may be 
numbers?)
  -  We define a way to build more complex identity doctrines from 
"simple" doctrines (by recursive definition of equivalence function)
  -  We can use assertion categories to simplify expressions
(I can provide once disclose of "subjectIdentifier " assertion category 
and use it later for definitions of additional identity doctrines)


> The degree to which one can presume an identity doctrine or to which 
> disclosure of an identity doctrine is necessary, will vary from case 
> to case. All the TMRM is trying to do is provide the ability to have 
> that disclosure and to be able to therefore build rules based upon 
> that disclosure. If you don't need/want it, not a problem. (Noting 
> that your mileage may vary if you don't use disclosure, but that is a 
> choice everyone gets to make.)

I share understanding of necessity to disclose different identity 
doctrines. I just try to understand how SIDPs-based approach is 
comparable with other ways to disclose identity doctrines.



Dmitry