Re: EARL Primer notes

> I don't know if this is too basic, [...]

Not at all; I think it's a great introduction, and although I'm not
sure exactly what the "target market" of EARL really is, I think that
the following statement is enough to introduce anyone to the
mysterious way of EARL:-

> EARL allows someone to describe how well Web content or a tool
> follows guidelines or specifications.  For example, using EARL you
> can describe if a particular image is used in an accessible way on a
> Web page.  Or if a user agent displays SVG images properly.
> "Properly" is defined by the SVG specification.  "Accessible" is
> defined in WCAG.

That's just it, and although people can go further, it certainly whets
their appetites.

Note that although I like the proposed changes to make it clearer as
well, don't forget that this will end up being hyperlinked, so you can
just link SVG and WCAG to their own respective URIs. Then, if anyone
wants to know what they are, they can just follow the links and find
out - although chances are that they'll already know.

> For example, "the dog howled at the moon."

In triples form:-

   [ a :Dog ] :howledAt :TheMoon .

Actually, that just means that one instance of Dog howled at the moon,
but because you didn't say which Dog it was in the sentence, I guess
"a" for "the" is a good approximation. What I've actually said there
in the triple is that "something which is a Dog howled at The Moon".

If you really want to say "the", then you can give that Dog a name,
for example, "Fido the dog howled at the Moon." In Notation3 that
would be:-

   :Fido a :Dog; :howledAt :TheMoon .

This very simple phrase actually has quite a bit of power in itself.
For example, you could say that if anything howls at something else,
then it is a "Dog". In that case, all you need to say is that "Fido
howled at the Moon", and you know that Fido is a Dog, thanks to this
preconception you have about Dogs. In fact, this is a simple domain
statement, which in Notation3 would be something like:-

   :howledAt rdfs:domain :Dog . :Fido :howledAt :TheMoon .

i.e. " the subject of howledAt (we call this a domain) is always a
Dog. Fido howlsAt something". When you process this, first you'll come
to the conclusion that "Fido is a subject of howledAt", and then,
using the "rule" that you know about, you end up with:-

   :Fido a :Dog .

This whole process can be summed up in Notation3 by the following
simple rule:-

   { :x rdfs:domain :y . :p :x :q } log:implies { :p a :y } .

i.e. "If something does X to something else, and the subject of X is
always a Y (domain), then that thing is a Y". The whole lot could also
be done in Prolog, by saying:-

   triple(':howledAt', ':Fido', ':TheMoon').
   triple('rdfs:domain', ':howledAt', ':Dog').
   domain(E, F) :- triple('rdfs:domain', E, F).
   type(P, Y) :- domain(X, Y), triple(X, P, Q).

And then running the following queries:-

   ?- type(':Fido', ':Dog').
   ?- type(':Fido', X).

Where you get:-

   ?- type(':Fido', ':Dog').
   Yes
   ?- type(':Fido', X).
   X = ':Dog'
   Yes

or, in English:-

   Me: Is Fido a Dog?
   Prolog: Yes.
   Me: What is Fido?
   Prolog: A Dog?
   Me: Yes.

> "The cute Siberian husky named Iko howled deeply at
> the full moon last Thursday when his owner forget to
> feed him dinner."

Hmm...

   { [ :quality :Cute;
        :breed [ a :Husky; :type "Siberian" ];
        :name "Iko";
        :gender :Male ]
      [ :action :howled; :depth "Deeply" ]
      [ :object :TheMoon; :phase "Full" ] }
        :time :LastThursday;
        :reason [ :name "Iko";
                      :wasNotFedBy [ :ownerOf [ :name "Iko" ] ] .
   :name a daml:UnambiguousProperty .

Although Seth Russell made a different model [1] in his mentographies
along those lines, which would make it:-

   [ a :Howl; :depth "Deeply";
      :by [ :quality :Cute;
              :breed [ a :Husky; :type "Siberian" ];
              :name "Iko";
              :gender :Male ];
      :at [ :object :TheMoon; :phase "Full" ];
      :when :LastThursday;
      :reason [ :name "Iko";
                    :wasNotFedBy [ :ownerOf [ :name "Iko" ] ] ] .

Something even nicer would be some song lyrics:-

   { [ :betterThan :x ] . :x daml:complimentOf :BeingInLove }
     log:forAll :x .

i.e. "something is better than anything that isn't being in love".
And, in fact, if you can work out the following:-

   { { { [ :betterThan :x ] . :x daml:complimentOf :y }
       log:forAll :x }
   log:implies
     { :y a :BestThing }} log:forAll :y .

i.e. "if something is better than anything that isn't y, then y is the
best thing", then you'll get the intended result :-)

[1] http://robustai.net/mentography/conceptualDependency.gif

--
Kindest Regards,
Sean B. Palmer
@prefix : <http://webns.net/roughterms/> .
:Sean :hasHomepage <http://purl.org/net/sbp/> .

Received on Saturday, 19 May 2001 22:44:06 UTC