Property:Has processing error text

"Has processing error text" is a predefined property containing a textual description of an error and is provided by Semantic MediaWiki. This property is pre-deployed (also known as special property) and comes with additional administrative privileges but can be used just like any other user-defined property.

Pages using the property "Has processing error text"

Showing 25 pages using this property.

View (previous 25 | next 25) (20 | 50 | 100 | 250 | 500)

C
ComputationalEnvironment +Some subquery has no valid condition.  +
ComputationalEnvironment +

The wikipage input value "Our goal was to arrive at an ontology design pattern that is capable of answering the following competency questions:

– What environment do I need to put in place in order to replicate the work in Paper X?

– There has been an error found in Script Y. Which analyses need to be re-run?

– Based on recent research in Field Z" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.

  +,

The wikipage input value "what tools and resources should new students work to become familiar with?

– Are the results from Study A and Study B comparable from a computational environment perspective?" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.

  +
Computer System +The wikipage input value "
  • The computer uses Ubuntu 16.04.
  • The graphics card requires driver A.
  • The software is compatible with Windows 10.
  • The processor is compatible with motherboard B.
" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.   +
Computer System +The wikipage input value "

What is currently installed in a computer? A computer uses specific pieces of hardware and software.

  • What software or hardware is required so that some other software or hardware can operate properly? This relationship is represented with properties requiresSoftware and requiresHardware.

  • What software or hardware is compatible with other software or hardware? This is expressed via the isCompatibleWith relationship.

" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.   +
Computer System +The wikipage input value "The pattern intends to model computer systems based on a hardware/software approach. This pattern has been developed by MKLab at CERTH/ITI and Tate for the PERICLES FP7 project." contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.  +
Computer System +Some subquery has no valid condition.  +
ConceptGroup +Some subquery has no valid condition.  +
ConceptTerms +The wikipage input value "This CP allows designers to represent jointly conceptual and linguistic part of a vocabulary. The pattern purpose is not to encompass all linguistic complexity as Linginfo or LMF does, but to describe linguistic information in more details than SKOS which names concept whith simple labels." contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.  +
ConceptTerms +Some subquery has no valid condition.  +
ConceptTerms +The wikipage input value "a preferred term and some simple non preferred terms. We are convinced that maintaining this model can be optimized by reifying those relations in a single relation class. That is why we defines the Concept-Terms relation which reusing N-ary pattern in order to represent terms on a concept. Between all terms" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.  +, The wikipage input value "BS8723-5 model: http://schemas.bs8723.org/Examples.aspx In BS8723 model" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.  +
ConceptTerms +The wikipage input value "A concept is named in a particular language by a preferred term and a set of simple non preferred terms. Those terms artifacts specialize the term entity which owns common properties. This list of properties may be extended depending on vocabulary specific needs. This pattern suits for various vocabularies (thesaurus, terminology, taxonomy…) and has been applied to GEMET, Eurovoc, CIM10 among other. Modeling takes into account: -the possibility to extend the current pattern in order to add some more precise linguistic information (for instance represent translation relation between two terms since term is a class) -minimal linguistic artifacts necessary for vocabulary resource access by providing a preferred Term to name a concept and some synonyms which are Simple non preferred terms." contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.  +
ConceptTerms +The wikipage input value "a concept has a preferred term "social sciences" in english and a simple non preferred term (i.e. synonyms) "humanities" in the same language whereas the same concept has a preferred term "sciences sociales" in french and a simple non preferred term "sciences humaines" in this language. If we wanted to add a translation relation between terms we could state that "social sciences" english term is a translation of "sciences sociales" french term. If we consider a second preferred term in english "award" which names a concept" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.  +
Constituency +Some subquery has no valid condition.  +
Constituency +The wikipage input value "A desirable advantage of this CP is that we are able to talk e.g. of physical constituents of non-physical objects (e.g. systems), while this is typically impossible in terms of parts. This Content OP has to be distinguished from part of, collection entity, and componency Content OPs." contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.  +
Context Slices +

The wikipage input value "As shown in the example, the idea of the context slices pattern is, rather than reifying the statement itself, to create a projection of the relation arguments in each context for which some binary relation holds between them.

Take for example the statement "Chris believes Sam is CEO of IBM". Say we already have nodes in some graph representing Sam and IBM.

We create, as shown in the diagram, the context c1 corresponding to Chris' belief, and two nodes representing Chris' belief about Sam and Chris' belief about IBM (shown as Sam@c1 and IBM@c1).

This allows us to represent ceoOf as a binary relation, which seems more natural, and it allows us to use the expressivity of OWL in more ways. We can say of the ceoOf relation that it has an inverse, hasCeo. We can express cardinality, e.g. a company may have only one CEO within a context. We can say that a relation is transitive or symmetric. We can express relation taxonomies in the usual way.

While clearly OWL does not support RDF reification, and so none of this is possible if statement reification is used, as mentioned above a more standard way of representing this kind of information (including time, belief, knowledge, etc.) is to create an OWL class that represents the relation holding, with properties for the arguments. This approach makes it possible to express global but not local range and domain constraints, global but not local cardinality, and symmetry.

Note that the ContextualProjection class should be considered disjoint with any of the classes in an ontology that have projections." contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.

  +
Context Slices +

The wikipage input value "This logical pattern is a generalization of the 4D "Reusable Ontology for Fluents in OWL", presented at FOIS-2006.

Welty, Chris and Richard E. Fikes. 2006. A Reusable Ontology for Fluents in OWL. In Bennet and Fellbaum, eds., Proceedings of the Fourth International Conference on Formal Ontology in Information Systems. IOS Press. See http://www.booksonline.iospress.nl/Content/View.aspx?piid=2209

It has been suggestion in Reviews:ValentinaPresutti_about_Context_Slices that this may be a specialization of Submissions:DescriptionAndSituation. The DandS pattern is described in a bit of distributed way across four or so patterns, lacks an example, and uses terms like "description" and "concept" in an unfamiliar way, so I am unable to understand it. The main objective of the CS pattern is to form projections of the objects into the contexts, not the relations, which is I think what DandS does." contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.

  +
Context Slices +

The wikipage input value "In OWL functional syntax: 

Ontology(<http://example.org/ContextSlices>
  Annotation(owl:versionInfo "1.0"@en)
  Annotation(rdfs:label "Context slices ontology logical pattern"@en)

  Declaration(Class(cs:Context))
  DisjointClasses(cs:Context cs:ContextualProjection)
  Declaration(Class(cs:ContextualProjection))
  SubClassOf(cs:ContextualProjection ObjectAllValuesFrom(cs:hasContext cs:Context))
  SubClassOf(cs:ContextualProjection ObjectExactCardinality(1 cs:hasContext))
  SubClassOf(cs:ContextualProjection ObjectExactCardinality(1 cs:projectionOf))
  DisjointClasses(cs:ContextualProjection cs:Context)
  Declaration(ObjectProperty(cs:contextualProperty))
  ObjectPropertyDomain(cs:contextualProperty cs:ContextualProjection)
  ObjectPropertyRange(cs:contextualProperty cs:ContextualProjection)
  Declaration(ObjectProperty(cs:hasContext))
  FunctionalObjectProperty(cs:hasContext)
  ObjectPropertyDomain(cs:hasContext cs:ContextualProjection)
  Declaration(ObjectProperty(cs:projectionOf))
  FunctionalObjectProperty(cs:projectionOf)
  ObjectPropertyDomain(cs:projectionOf cs:ContextualProjection)
 )

In RDF/XML: 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE rdf:RDF [
  <!ENTITY owl "http://www.w3.org/2002/07/owl#">
  <!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">
  <!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#">
  <!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">
]>
<rdf:RDF xml:base=""
         xmlns:owl="&owl;"
         xmlns:rdf="&rdf;"
         xmlns:rdfs="&rdfs;"> 
  <owl:Ontology rdf:about="">
    <rdfs:label xml:lang="en">Context slices ontology logical  pattern</rdfs:label>
    <owl:versionInfo xml:lang="en">1.0</owl:versionInfo>
  </owl:Ontology>
  <owl:Class rdf:about="ContextualProjection">
    <rdfs:comment rdf:datatype="&xsd;string">A contextual projection or slice of an entity or event.  
The context defines the contextual extent of the slice.  If any relations hold in a context, they 
must be to other slices of the same context (there is no way to enforce this constraint in OWL).
    </rdfs:comment>
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:cardinality>
        <owl:onProperty rdf:resource="#hasContext"/>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:cardinality rdf:datatype="&xsd;nonNegativeInteger">1</owl:cardinality>
        <owl:onProperty rdf:resource="#projectionOf"/>
      </owl:Restriction>
    </rdfs:subClassOf>
    <rdfs:subClassOf>
      <owl:Restriction>
        <owl:allValuesFrom rdf:resource="Context"/>
        <owl:onProperty rdf:resource="#hasContext"/>
      </owl:Restriction>
    </rdfs:subClassOf>
    <owl:disjointWith rdf:resource="Context"/>
  </owl:Class>
  <owl:Class rdf:about="Context">
    <rdfs:comment rdf:datatype="&xsd;string">It is intended that this class  should be equated
with whatever class represents contexts, with possibly subclasses for different kinds 
such as BeliefContext, TemporalInterval, etc.</rdfs:comment>
    <owl:disjointWith rdf:resource="#ContextualProjection"/>
  </owl:Class>
  <owl:ObjectProperty rdf:about="#contextualProperty">
    <rdfs:comment rdf:datatype="&xsd;string">A property that holds in a  context.</rdfs:comment>
    <rdfs:domain rdf:resource="#ContextualProjection"/>
    <rdfs:range rdf:resource="#ContextualProjection"/>
  </owl:ObjectProperty>
  <owl:FunctionalProperty rdf:about="#hasContext">
    <rdf:type rdf:resource="&owl;ObjectProperty"/>
    <rdfs:comment rdf:datatype="&xsd;string">The relation from a  ContextualProjection to the context 
in which some property holds</rdfs:comment>
    <rdfs:domain rdf:resource="#ContextualProjection"/>
  </owl:FunctionalProperty>
  <owl:FunctionalProperty rdf:about="#projectionOf">
    <rdf:type rdf:resource="&owl;ObjectProperty"/>
    <rdfs:comment rdf:datatype="&xsd;string">The entity or event that a  context slice is a slice of.</rdfs:comment>
    <rdfs:domain rdf:resource="#ContextualProjection"/>
  </owl:FunctionalProperty>
</rdf:RDF>" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.
  +
Context Slices +The wikipage input value "As shown in the diagram, the pattern uses two predefined classes, cs:ContextualProjection and cs:Context. It uses two predefined properties, cs:projectionOf (ContextualProjection x TOP), and cs:hasContext (cs:ContextualProjection x cs:Context). Properties that hold in a context can extend the property cs:contextualProperty." contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.  +
Context Slices +

The wikipage input value "Most information on the web is contextualized somehow, for example information may be believed by a person or organization, it may hold only for some time period, it may have been reported/observed by an individual, etc. There are myriad proposals and logics for context, but none are standards and few have even prototype implementations.

In RDF and other binary relation languages (like object oriented languages and description logics), one typical way to represent that a binary relation holds in some context is to "reify" the relation-holding in the context as an node with a binary relations for the subject, object, and property, and a fourth binary relation to the object representing the context itself. The downside to this approach is the expressive ability of the language to describe the binary relation, especially in the case of description logics, is lost. For example, the ancestor relation is transitive. OWL allows one to express transitivity of a binary relation, but this expressiveness is lost if the statements of the relation are reified. The same would be true for symmetry, reflexivity, etc. One can get the effect of cardinality and range/domain restrictions by reifying a relation as an OWL class (instead of using RDF reification), with properties for the roles (as in the n-ary relations W3C note), but not transitivity etc.

The motivation for context slices is to provide a logical pattern for encoding context information in standard RDF graphs that allows some of the expressiveness of OWL to be used in describing the relations that hold in contexts.

This is a generaliztion of the four dimensional ontology for fluents published in [Welty & Fikes, 2006]." contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.

  +
Context Slices +

The wikipage input value "Here is a simple ontology that extends the logical pattern ontology and represents the statement, "Chris believes Sam is CEO of IBM". 

<?xml version="1.0"?>
<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:cs="http://www.example.org/ContextSlices#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:daml="http://www.daml.org/2001/03/daml+oil#"
    xmlns:dc="http://purl.org/dc/elements/1.1/"
  xml:base="http://www.example.org/ContextSlicesExample">

  <owl:Ontology rdf:about="">
    <rdfs:label xml:lang="en">Example of using context slices</rdfs:label>
    <owl:versionInfo xml:lang="en">1.0</owl:versionInfo>
  </owl:Ontology>
  <owl:Class rdf:ID="Company"/>
  <owl:Class rdf:ID="Person"/>
  <owl:Class rdf:ID="BeliefContext">
    <rdfs:subClassOf rdf:resource="http://www.example.org/ContextSlices#Context"/>
  </owl:Class>
  <owl:ObjectProperty rdf:ID="believedBy"/>
  <owl:ObjectProperty rdf:ID="ceoOf">
    <rdfs:subPropertyOf>
      <owl:ObjectProperty rdf:ID="contextualProperty"/>
    </rdfs:subPropertyOf>
  </owl:ObjectProperty>

  <Person rdf:ID="Sam"/>
  <Person rdf:ID="Chris"/>
  <Company rdf:ID="IBM"/>

  <BeliefContext rdf:ID="c1">
    <believedBy rdf:resource="#Chris"/>
  </BeliefContext>
  <cs:ContextualProjection rdf:about="#IBM$c1">
    <cs:hasContext rdf:resource="#c1"/>
    <cs:projectionOf rdf:resource="#IBM"/>
  </cs:ContextualProjection>
  <cs:ContextualProjection rdf:about="#Sam$c1">
    <cs:hasContext rdf:resource="#c1"/>
    <ceoOf rdf:resource="#IBM$c1"/>
    <cs:projectionOf rdf:resource="#Sam"/>
  </cs:ContextualProjection>
</rdf:RDF>" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.
  +
Context Slices +Some subquery has no valid condition.  +
ContextualizedWinstonPartWhole +Some subquery has no valid condition.  +
Controlflow +Some subquery has no valid condition.  +
CountingAs +Some subquery has no valid condition.  +
Course +Some subquery has no valid condition.  +
Retrieved from "http://ontologydesignpatterns.org/index.php/Property:Has_processing_error_text#SMWResults"
The page [[Bootstrap:Footer]] was not found.