This is the upper ontology designed particularly for and by Olive. It utilizes gist (thank you to Semantic Arts!) and skos (thank you to Alistair Miles, Sean Bechofer, and the W3C's SWDWG!). While even those ontologies are sometimes heavily edited for our purposes, we preserve the prefix here and have tried to minimize name or conceptual changes that would inhibit cross-compatibility.
Every instance of olive:Abstract is a summary of some (other) content, usually the content communicated by some formal content bearing thing such as a research paper or book. Note that, as the word itself indicates, an instance of olive:Abstract is an abstraction from the thing for which it is an abstract. Thus, if :Abstract01 is an abstract for :Content01, it will be true that (:Content01 olive:abstractsTo :Abstract01). Note that you should use olive:transcript if you want to relate an instance of olive:Abstract to a string that expresses the content of the abstract. If you want to skip reification of the abstract itself, you should use olive:abstract to relate a piece of content to a string expressing the content of the abstract.
accident
olive:Accident is the class of all events that have negative unintended consequences.
medical accident
olive:Accident-Medical is the class of all medical accidents.
account
This is the subclass of olive:Contract all instances of which are contractual business agreements between one agent (olive:accountSeller) and another (olive:accountCustomer). One should be careful to distinguish between instances of this class and the relationships that they govern: the latter are instances of olive:BusinessRelationship, each of which will be such that the following holds: (:Account1 olive:governsBehavior :BusinessRelationship1) . In practice, most instances of this class are instances of olive:Account-Olive, which is the subclass of accounts in which Olive is the olive:accountSeller.
Olive account
This is the subclass of olive:Account, wherein all instances have a olive:accountSeller of Olive.
account status
This is the class of 'tags' for account statuses. For example, we can identify an account as having its delivery completed.
action
web service action
Instances of olive:Action-WS are functions (see olive:Function) that (partly) compose a given web service (see olive:WebService).
address
A reference to a place (real or virtual) that can be located by some routing algorithm, and where messages or things can be sent to or retrieved from. E.g. PO Box or URL to a PDF file. Note that the address is the location, and not simply the string that refers to that that location. So, one's email address is distinct from the string for the addresss, and one's home address is distinct from the letters and numbers that one would put on an envelope to be shipped there.
Applicable when importing data from the RibbonHealth API
hospital admission
Each instance of olive:Admission is when an instance of olive:MedicalCareEvent in which a patient is admitted to the hospital or other care facility for treatment.
emergency admission
All admission type medical care events in which the patient requires immediate medical intervention as a result of sever, life threatening, o9r potentially disabling conditions.
elective admission
All admission type medical care events in which the patient's condition permits adequate time to schedule the admission based on the availability of a suitable accommodation.
newborn admission
All admission type medical care events in which the patient is a newborn. This requires use of special codes (see olive:admissionSource).
trauma admission
All admission type medical care events in which the patient the patient visits a trama center/hospital as licensed or designated by thte state or local government authority, usually requires surgery.
urgent admission
All admission type medical care events in which the patient requires immediate attention for the care and treaatment of a physical or mental disorder. Generally the patient is admitted to the first available and suitable accommodation.
olive:Agent is a very general class. Every instance is capable of action (see some hedges below). Important subclasses include olive:Person and olive:Organization. Agents are capable of entering into contracts (legal agents), affecting the world around them (causal agents), and/or being subjects of moral evaluation (moral agents). These three capacities are sufficient, but not necessary for agency. It is possible to treat an AI robot as an agent, even if we reject the claim that this robot can be morally evaluated for their actions. In some sense, this is a very contentious class. Some may bristle at organizations being considered agents (the same folks who object to corporations being considered persons in the US). Others may worry about whether a human being ceases to be an agent when they fall asleep, or enter a coma. And the already mentioned case of AI agents is sure to evoke strong response. As interesting as those disputes are, we can sidestep them here because of the primacy of contractual agreements and causal claims. Organizations can clearly enter into them, and human persons do not cease to be members of their ongoing contracts by merely falling asleep. Moreover, it is perfectly natural to say that the Exxon caused an oil spill or that the BLM movement has been incredibly influential in politics in 2020. It is an open question whether there are any circumstances where a living person may cease to be an agent. However, at this point, it seems unlikely that such a case will be fruitful to explore for the use of this ontology.
agreement
deal
Each instance of this class is a commitment (content) mutally made by two or more agents. Agreements are normatively bindings for the agents involved. Notable subclasses include olive:Contract.
alive
olive:AliveThing is the class of all things that are alive, as long as they are members of this class. In contrast to olive:LivingThing, olive:AliveThing has members who need not timelessly be members. When Beethoven dies, he ceases to be an instance of olive:AliveThing and becomes an instance of olive:DeceasedThing.
allergy
olive:Allergy is the class of all allergies. Instances will be allergies that particular persons have. So, :BillsPeanutAllergy is an instance of olive:Allergy, but :PeanutAllergy would not be (that would be the subclass of olive:Allergy that :BillsPeanutAllergy would be an instance of).
Alzheimer's Disease
olive:AlzheimersDisease is the class of all states in which someone has Alzheimer's disease.
attribute
property
characteristic
olive:Attribute is the class of all attributes, whether "universal"/"repeatable"/"multiply-instantiable" (e.g. redness, considered as a quality shared by all red things) or "individual"/"particular"/"non-repeatable" (e.g. the redness of my t-shirt, considered as an individual quality possessed - and, perhaps, possessable - only by my t-shirt, and which is exactly similar to yet distinct from, e.g., the redness of your t-shirt). An attribute can be thought of as an entity the existence of which depends on its being attributed to or instantiated in something (whether or not it is in fact so attributed or instantiated); "quality" is another way of characterizing such things, and one might further conceive of attributes/qualities as essentially being "qualifiers" of other things. For example, suppose my head has a mass of 8 lbs. The specific mass of my head - an instance of olive:Mass - is an attribute of my head: it is a characteristic of my head, and this mass doesn't exist outside of things that possess it (there are no "free-floating" masses). Attributes are most obviously contrasted with the things of which they are attributes: i.e. it is natural to contrast, e.g., my head's mass with my head, the former being an attribute and the latter being a non-attribute. It should be noted, though, that it is at least conceptually possible for attributes themselves to have attributes, so the fundamental contrast should be between things that can be attributed to other things (i.e. instances of olive:Attribute) and things that cannot be attributed to anything else in this way (i.e. non-attributes). Paradigmatic examples of the latter are physical objects. It is often simply a modeling choice whether to represent a feature of the world as an attribute or a non-attribute. For example, consider my blue shirt. How should we represent that this shirt is blue? One might simply make it an instance of the class olive:Blue, which would mean that olive:Blue is the class of blue things and consequently not an attribute. One could, alternatively, introduce a property - olive:hasColor, say - that relates an object to a color instance - i.e. its particular color - and make olive:Blue the class of all blue color instances. In this case, my shirt's blueness would be an instance of olive:Blue, but my shirt wouldn't be; we'd then relate my shirt to my shirt's blueness via olive:hasColor. This would be tantamount to making olive:Blue a subclass of olive:Attribute, and it might afford us the ability to represent certain facts (perhaps its color density) about my shirt's blueness as opposed to, say, the blueness of the pen I'm holding in way that we might be unable to if we were to simply model olive:Blue as the class of all blue things (of which my shirt is one). As a third alternative, we could make olive:Blue itself an instance of olive:Attribute (or one of its subclasses) and relate my shirt to olive:Blue directly via olive:hasColor - this would be tantamount to representing blueness itself as a "universal" attribute. In general, if a class is a class of things like my shirt, then it isn't a subclass of olive:Attribute. If, instead, it is a class of things more like the-blueness-of-my-shirt (and not "blueness" as it appears in my shirt, this pen, etc.), then it is a subclass of olive:Attribute. If, as a third alternative, something is represented as a "universal" quality (as when olive:Blue is treated as an individual instead of a class), it should be an instance of olive:Attribute rather than a subclass of it. In cases like this, it is often appropriate to ensure that such an attribute is an instance of olive:Category or one of its subclasses, since instances of olive:Category play the same basic ontological role of traditional "universals".
API
application programming interface
An API is a computing interface that defines interactions betwen multiple software intermediaries.
appointment
olive:Appointment is the class of agreements to meet, and thus the parties attending are committed to attend. Instances of this class are distinct from the actual events that fulfill (or fail to fullfill) the agreement - the appointment itself is the agreement that binds the interested parties, not the event that fulfills the agreement.
area
planar region
area unit
A unit of two-dimensional area, such as square inches or hectares.
artifact
technology
olive:Artifact is the general class of person-made things, including both physical and intellectual artifacts. This includes simple tools and daily items like hammers, pots and pans, and pencils. It also includes large constructions like bridges and buildings. Intellectual artifacts include things like works of fiction, arguments (e.g. JJ Thomson's 'violinist argument'). See olive:Content for more discussion. Some tempting non-examples include things like national parks. While such parks are dilineated by humans, and may include some artifacts (roads to the park, benches and buildings in it, etc.), almost all the terrain was not created by humans. Parts of mathematics might end up being in a grey area; some folks think that math is discovered, while others think it is created. In principle from this ontology's perspective, calling non-Euclidean geometry an artifact is acceptable. One should just be aware that making these claims is controversial in some circles. Also, other humans are not artifacts, even though one can pretty convincingly argue that humans are intentionally created by other persons. It is unclear whether this distinction is really theoretically tenable, but it probably relies on some sort of widely held distinction between 'naturally occurring' and 'unnatural' things. A hammer is unnatural in some sense. But humans reproducing is natural. Or at least it seems this is the intution that underlies keeping humans out of the class of artifacts. A slightly more careful explication of 'person-made' is required. If one is a theist, you might think that everything is made by a person, God, and as such it's perhaps better to think of artifacts as non-divine-person-made things. Morever, we may want to include more things than persons: corporate inventions or creations certainly seem like artifacts. They might also be thought of as made by individual persons, but perhaps better would be to fully expand the definition to include non-divine-agent-made things to include organizations and other actors.
assessing something
olive:AssessingSomething is the class of all events in which something is assessed. A paradigm example might be assessing someone's risk of having a heart attack in the next 10 years. You should specify (if possible) the date of the assessment (see olive:creationTime), the assessor (see olive:authorOf), the thing assessed, and the result of the assessment.
assertibility status
olive:AssertibilityStatus is the class of all statuses concerning the conditions of assertibility associated with a given term. The paradigmatic instance of this class is olive:NotAssertible, which is used to indicate that a given term should not be used for making assertions. See olive:assertibility for the annotation property the range of which covers this class.
auditory medium
audio
audio content
olive:AuditoryContentSource is the class of all content bearing things that are accessed (at least partially) auditorially. This includes music albums, recorded speeches, podcasts, and such.
bank
This is the subclass of olive:Organization, instances of which are financial institutions that have accounts (see olive:BankAccount) for clients. Clients can place deposits at the bank, and the bank will hold the money and return interest to its customers, as well as provide loans and other financial services.
bank account
An account where the olive:accountSeller is a bank (olive:Bank). Accounts have balances, account numbers, and so on.
base unit
Base units are primitive unit that cannot be decomposed into other units. Moreover, these units are used as the 'standard' for their respective types of magnitudes (e.g. meter is the base unit for length). The previous statements are cashed out in making olive:BaseUnit a subclass of olive:CoherentUnit and olive:SimpleUnit. It can be converted from one measurement system to another. The base units in olive (following gist's example) are the seven primitive units from the System Internationale (SI): (meter, second, kilogram, ampere, kelvin, mole, candela).
The class of all books considered as content: that is, each instance of this class is the content instantiated in or communicated by a "concrete" book (see olive:Book-Copy), whether a physical book or a virtual book. Thus, :MobyDick (considered as content) would be an instance of this class, whereas :MyCopyOfMobyDick would be an instance of olive:Book-Copy that instantiates :MobyDick.
The class of all books, considered as things that communicate content. This includes both traditional physical books and e-books. Note that this is distinct from the class of all books considered as content (see olive:Book-Content), each instance of which is the content communicated by or instantiated in an instance of olive:Book-Copy.
Bot configurations are instances of olive:Content that specify commands executable by a robot, particularly by an Olive bot (olive:OliveBot).
Every bot file expresses content that can be subdivided into one or more blocks, each of which is an instance of this class, olive:BotFileBlock.
Every instance of olive:BotRunningEvent consists of a bot (e.g. an olive:OliveBot) executing one or more program (e.g. an instance of olive:BotConfiguration).
building
A man-made structure for dwelling or working. This includes office buildings, houses, barns, sheds, and so on. Edge cases would be things like treehouses, which may or may not qualify depending on permanence and nature of construction.
An address to which you can send mail, or that you could find in the physical world.
This is the class of business partnerships, which are contractual partnerships between agents for the purpose of carrying on business.
This is the class of business relationships, which are relationships between agents for the purpose of carrying on business. Such relationships need not be, but often are, contractual in nature (see olive:Relationship-Contractual).
buying and selling
buying
selling
trading
This is the class of of simple buying-and-selling transactions. Instances of this are events in which (1) there are two exchanges of ownership (one from buyer to seller - usually ownership of money - and one from seller to buyer), and (2) the objects of ownership are actually transferred between the agents making the exchange. Thus, in every instance of this class, the buyer transfers to the seller both whatever it is that they have used to make the purchase as well as the right of ownership of that thing, and mutatis mutandis for the seller. Note that instances of this class may have a temporal extent that spans more than just an instantaneous (or semi-instantaneous) exchange (as when someone purchases an item in a store and pays cash). For example, an online purchase that involves a physical transfer of the focal item that takes a period of days can still be an instance of this class, but it may require a more complicated representation (particularly as regards its subevents) than a simpler transaction would. Likewise, for instances of this class that involve subevents that occur over an extended period of time (as with the aforementioned online purchase or a purchase that involves multiple payments), there should usually be associated contractual relationships (see, e.g., olive:Contract and olive:Account, on the one hand, and olive:BusinessRelationship and olive:Relationship-Contractual, on the other) that provide norms for how those subevents should occur. Note also that there may be complex cases, such as buying a house, in which subevents and subsequent events (e.g. making mortgage payments to a lender) may be required in order to fully represent what is happening. However, one can still use an instance of BuyingAndSelling in such a case to represent the "top-level" exchange between the buyer and the seller. The notion of "ownership" used above may be conceived of as including rights to a one-off performance of an service (as when one purchases a car wash) but not arrangements of ongoing use (e.g. leasing an apartment, signing up for a content-streaming service) or for recurring services (e.g. making arrangements for quarterly pest control service). For these latter sorts of arrangements, one should prefer to model the governing agreement and the situation(s) it governs (e.g. the use of the relevant thing - see olive:UsingSomething - or the type of service to be performed, and the (type of) payment for it - see olive:PayingForSomething - including frequency), perhaps along with the initial event in which the agreement was generated. Borderline cases are signing up for a "X-of-the-month-club", where, say, a product is sent to you every month in exchange for a monthly (or even one-time payment). These sorts of cases are probably best modeled along the lines of recurring services, although there may be cases in which it is more desirable to model them as instances of olive:BuyingAndSelling (with an associated contract and most likely a complex network of subevents).
CARC
claim adjustment reason code
These codes describe why a claim or service line was paid differently than it was billed. Each instance should be named olive:CARC-##. So the CARC code 15 is olive:CARC-15.
category
universal
olive:Category may be the single most-confusing class in the upper ontology for ontology laypersons. It is incredibly useful, but is necessary in part due to limitations on contingent facts about how triple-store ontologies work. Instances of olive:Category are ontological features that are class-like insofar as they can apply to multiple things, but they are represented in the ontology as individuals; one might usefully think of instances of olive:Category as labels. Suppose we are looking at a bunch of contracts somewhere in the sales pipeline. We might want to categorize some of these contracts as 'prospective', some as 'unlikely', and some as 'imminent'. In that case, we should create a specific subclass of olive:Category, say, ex:ContractStatus. Then we can create an individual status ex:ProspectiveContract, and we can then associate it with our particular contract, e.g. (:Contract_1 olive:categorizedBy ex:ProspectiveContract). For the philosophically inclined, instance of olive:Category play essentially the same ontological role as traditional philosophical "universals" do. (See also the comment on olive:Attribute for some related discussion.) (note: the following is more technical and only of interest to ontologists) You might be puzzled as to why we'd create categories for contracts when there's already a class: olive:Contract. Why not just create subclasses of olive:Contract? In this case, there might be no substantive reason. But in general, the need for categories stems from the limitation of owl that precludes a class from being the object of a triple (with a few exceptions). Suppose I want to say that some robot is used for security authentication. This relates our robot to a capability of performing some type of action, not performing some particular action. But we're not saying that this robot is an instance of a class, but rather capable of performing instances of some class. One way to accomplish this is via 'punning', whereby we create both the class, ex:SecurityAuthentication, and an individual, ex:SecurityAuthentication. They have the same name (thus, 'punning'), but they are two separate resources. This turns out to be a very unsatisfactory solution. Categories present an alternative: create an individual ex:SecurityAuthentication, which is a olive:Category. This is also not a perfect solution, but sometimes you're left to do unsatisfactory things to work around system limitations. The other reason that olive:Category has been used historically is to shove complexity into the 'C-Box'. In short, Semantic Arts (the creators of gist) prioritize simplicity in the upper ontology. To them, simplicity means having a small total number of terms in the upper ontology, certainly not more than 150 or so if you add up all the classes, properties, and individuals. But they know that users will have some expansive taxonomies, such as all of the prescription drugs being insured, or ICD-10 codes, etc. Rather than adding these things to the ontology at large, which would greatly increase the number of terms, Semantic Arts favor putting these structures under olive:Category--in the C-Box. For what it's worth, I find this second justification very unconvincing. If the world that we are modeling is complex, then so be it. It doesn't make the subject matter any less complex or more understandable to sweep it under the C-Box rug. Instead, we should be careful to create detailed comments, properly next our ontology, and write documentation or lexical information that will make the ontology as intuitive as possible for users.
Each instance of olive:Cell-Data is the content expressed by an element in a table (see olive:Table-Data). These cells will be members of exactly one row (see olive:Row-Data) and one column (see olive:Field-Data), so the intersection of any row and column of a table to produce a unique cell. Not to be confused with biological cells, or with cellphone data (though you could store such data in a relational database, and thus in data cells).
certification
accreditation
This the is the class of all certifications, considered as content (rather than as objects that communicate the certification). Certifications attest to someone or something satisfying requirements. Certifications may be instantiated by (see olive:instantiates) things such as a physical diploma, e-certificate, etc. This includes academic degrees, CPR certifications, or EHR's meaningful use stages.
change event
olive:ChangeEvent is the class of all events in which some primary object (see olive:changedThing) is altered. This includes haircuts, refinancing, painting a wall, or cooking an egg. It can be difficult to pick out the subject of change. Take a haircut, for example. Clearly something is changed here, but is it my hair, or is it me? This is really a question of granularity. Even among my hairs, it's not *all* of them that are changed, but rather some subset, and only parts of those hairs are changed (the roots may be entirely unchange, for instance). The key point here is that it is very easy to get lost in the details of whether something is a change event, and in particular what thing is changed during that event. If one is quibbling over these details, the battle is already lost. Use this class in an simple way, and create subclasses if you want to split hairs about the nature of the subject and such. Note: just like every other event, one should specify when it happened using olive:timeOfEvent or its subproperties. It's worth noting that the most recent change event will give us the olive:lastModifiedOn time for the subject of the change event.
This is the fourth subevent of the revenue cycle. Once it has been verified that the appropriate treatment has been given, the process of charge capture takes place. A claim is sent to the insurance company for provider payment.
check
Checks are written, dated, and signed instruments that instruct a bank to pay a specific sum of money to the recipient of the check. Checks express (see olive:instantiates) instructions and obligations (see olive:Obligation). This class includes both physical and electronic checks, once those checks are filled out. Prior to being filled out, the papers in a checkbook are merely templates on which a check may be made manifest.
citation
reference
A citation is a piece of content that references another piece of content. Each citation should be related to the content that contains it as well as the content that is being referenced. When applicable, the format of the citation may need to be specified (e.g. MLA versus APA references).
olive:City is the class of all geographical regions that are part of some city. Note that this is different from the city government or the population of the city. Here we use the term 'city' to refer loosely to apply to all settlement land areas. So, towns and other 'small' cities also count as cities. If classes are needed to highlight size disparities, other vocabulary should be used.
This is the sixth subevent of the revenue cycle. During claim processing, the filed insurance claim can be paid in full, partially, or rejected.
insurance claim status
olive:ClaimStatus is the class of all statuses that apply to insurance claims (see olive:InsuranceClaim).
This is the fifth subevent of the revenue cycle. This is simply the handoff of the insurance claim from the provider to the payer.
higher-order class
The class of all classes that (can) have classes as instances. This includes mixed classes (which could have individuals and classes as instances), if such there be. The primary motivation for introducing this class into the ontology is to allow for integration with other ontologies that make use of higher-order classes. In general, if you are trying to represent something using the Olive ontology alone, you should do so using first-order classes only. You should also try to use subclasses of this class where appropriate (e.g. olive:Class-SecondOrder for classes that can have only first-order classes as instances). An instance of a higher order class should be related to it via olive:instanceOf and not rdfs:type (which can only relate an individual to a class).
second-order class
The class of all classes that can have only first-order classes as instances. For example, suppose that each type of occupation is represented as a class of individuals (i.e. a first-order class), such that, e.g., olive:Doctor is the class of all individual doctors. One might then conceive of the class of all occupation types as a second-order class containing all of these first-order classes as instances.
third-order class
The class of all classes that can have only second-order classes as instances. For example, suppose that each type of occupation is represented as a class of individuals (i.e. a first-order class), such that, e.g., olive:Doctor is the class of all individual doctors. Suppose further that olive:PersonTypeByOccupation is the (second-order) class of all of the aforementioned classes. One could then conceive of a class of all of the second-order classes that facet the class of olive:Person in topical ways: instances of olive:PersonTypeByOccupation facet olive:Person into subclasses based on occupation, whereas something like olive:PersonTypeByExpressedGender might facet olive:Person into subclasses based on expressed gender. Such a class of all these second-order classes - for the sake of the example, call it olive:TypeOfPersonType - would be a third-order class.
client status
This subclass of olive:Category has instances that tag (potential) clients by their relationship to whoever has (or aspires to have) them as clients. For example, you might classify an organization/person as a customer, in negotiations, or signed with a competitor. We can use this information to assign levels of priority to associated accounts.
code of conduct
olive:CodeOfConduct is the class of all commitments that provide a template or specification for action. Paradigm examples include sets of rules for games, constitutions for governments, and diet plans. For each of these codes, one can somehow opt in or commit to the code, which would make it normatively binding. So, for example, I could commit to adhering to a vegan diet, in which case I would be committing to refraining from eating steak (among other things).
coherent product unit
A ratio unit whose numerator and denominator reduce to 1
coherent ratio unit
coherent unit
A coherent unit is essentially a ‘default unit’ for a given subclass of olive:Magnitude. So for mass, we use kg--every other mass unit must have a conversion to kilograms. For velocity, we use m/s. The choice of which unit is the coherent unit is purely a convention, though we try to base that convention on common use outside of ontology so that it will feel natural. There’s no real problem if we made mass be built around the lb, or the g, rather than kg. But once it’s fixed, you enter all other units for a given type of magnitude (e.g. mass, brightness, area) as needing to be converted to that unit. Base units are coherent units that are also simple units.
cohort
olive:Cohort is the class of all cohorts, which are classes of individuals that share some common set of traits. Cohorts are useful for using in studies or clinical trials. A cohort holds fixed the common traits so that you can test the effect that some other intervention has (or had) on some outcome. Subclasses of olive:Cohort will be distinguished by the type of instances their instances have (e.g. olive:PatientCohort is such that every instance cohort is a subclass of olive:Patient).
collection
This is the class of all collections of individual things. All of the pets that I own form a collection, as does my stamp collection, or all of the prime numbers less than 1200. Collections are very analogous to sets: they are defined by their members. Classes and collections are very similar. An individual may be an instance of a class (rdfs:type) or a member of a group (olive:memberOf). Some ontologies, such as the one developed at Cycorp, use collections instead of classes. At bottom, there is not a huge difference. However, it is best to think of classes as intensional, whereas collections are extensional. That is, a class is defined by the rules and/or characteristics for determining membership. A collection, on the other hand, is defined purely by which members are in it. For this reason, you might distinguish the class of renates (things with a kidney) from the class of cardiates (things with a heart), even if it turned out that every renate was a cardiate and vice-versa. If the collection of things with hearts turned out to have exactly the same members as the collection of things with kidneys, there would be only one collection. Collections should be typically used for relatively small and contingent smatterings of individuals. For example, a jury or other group of people is a good candidate. Or, the collection of hospitals that are 'in network' for a given insurance provider would also be a good candidate. But when in doubt, a class is probably a safer route than a collection.
commitment
olive:Commitment is the class of all content that is (potentially) normatively binding. Examples include laws, contracts, codes of conduct, and moral principles. Notice that these only need to be potentially binding; the fact that some law exists in Brazil does not automatically mean that the I am subject to the law. Commands like 'Open the door.' are still instances of gist:Commmitment, even if no person is responsible for satisfying that command. The important part is that instances of olive:Commitment are the sorts of things that can be satisfied, violated, or avoided. Commitments are not identical to the documents that make clear the commitment. That is, when I participate in a contract, the piece of paper on which the contract is written is not the thing that I'm bound to. My signing that piece of paper may have triggerd the commitment, but the paper is not itself the commitment. While I've stressed that even 'potentially' normatively binding things are commitments, in practice we tend to care about the ones that are *actually* binding. We care about the laws that someone is subject to, or the contracts they have signed, or morality (which is not the sort of thing that one can opt out of). So, any time a particular commitment is represented, one should also make clear who this commitment applies to.
commitment category
olive:CommitmentCategory is the class of all statuses that a commitment might have. There are three standards from the imperative logic literature: satisfied, violated, and avoided. However, additional categories also make sense, such as being in progress. Colloquially you can think of the instances here as answers you could give to a manager/spouse/yourself in regards to some task or obligation you have. You might have completed it (satisfied), failed at it (violated), or rendered it irrelevant (avoided). You should be able to construct a similar response for every instance of this category.
communication event
CommunicationEvent is the class of all events in which communication takes place. This includes placing a request, having a conversation, interacting with sales representatives, and so on.
comparison
Every instance of olive:Comparison is a piece of content in which at least two things are compared (see olive:comparedThing). This comparison may be used as the basis for making decisions, such as recommending a movie based on its being similar to another movie a coworker enjoys. Every comparison must specify the things compared, but we should usually also specify the degree of similarity using olive:hasAmount or some subproperty (or olive:quantitativeStrength). Absent an assertion of the strength of the simlarity, we assume at least weak similarity. Despite this default assumption, a comparison can also state that two or more things are very different. For example, a comparison with a olive:quantitativeStrength of 0 might mean that they have nothing in common. You might create or use a subclass of olive:Comparison to hold fixed something about the comparison, such as the types of objects being compared, or the number of objects being compared.
competition
olive:Competition is the class of all human activities where an agent tries to best another agent or some benchmark. Examples include instances of olive:Game, like cribbage, or instances of olive:Sport, like football. While competitions typically involve multiple agents, this class also includes events in which an agent is competing against themselves or some benchmark. For example, trying to free solo a particular mountain peak can still be classified as a competitive feat. Other more recreational activities like hiking would qualify as physical activities, but not competitions.
confused state
olive:ConfusedState is the class of all states of confusion. Persons in such a state will have trouble focusing and forming veridical judgments.
consignment use of something
using something on consignment
olive:ConsignmentUseOfSomething is the class of all events in which an agent allows for the use of something by another agent with the understanding that the former will be reimbursed by the latter based on the fact of use. A common example of this is an agent creating goods that are then sold on consigment by another agent, so that the latter reimburses the former after the fact of the sale. (In this sort of example, one could model the focal event as an instance of both olive:ConsignmentUseOfSomething and olive:BuyingAndSelling). Another sort of example is the consignment use of medical supplies, such that the vendor of a given medical supply is only reimbursed for the use of that supply after it is used. One important use of this class is in modeling instances of olive:Agreement (or olive:Contract) in which one party allows another party to use something on consignment.
type of contact information
olive:ContactAddressType is the class of all tags that identify what kind of address a thing is. For example, I may give you (253)432-0295 as my contact information; we know by the format that this is a phone number. I might also give you a @CoolOntologist83, which is more likely a Twitter handle. This category was created with the intention of making it easier to map to fhir contact types. However, this will also be suseful for connecting to other source systems in the future. That said, remember that categories are often very thin. If possible, and if it becomes robust enough, make sure to connect instances here with subclass of olive:Address or other classes.
container
bounded space
bounded spatial object
Instances of olive:Container are three-dimensional physical objects that are primarily composed of bounded space, so that they are natural thought as being focally constituted by spatial regions. Holes and rooms are a paradigmatic examples: these are physical objects (since they are countable and spatially located) that are focally constituted by a bounded spatial region. Non-examples include atoms: even though, technically, most of an atom is empty space, it is not focally constituted by that space. This class should be conceived of loosely enough that the (typically material) border regions of such an object (e.g. the region of dirt surrounding a hole in the ground) can be considered to be part of the object itself, depending on one's modeling purposes.
content
information
This is the class of all content/information. Content, on the current conception, is (1) nonphysical (see olive:NonphysicalThing), and (2) possibly but not necessarily artifactual (see olive:Artifact for the relevant, orthogonal class). Content is to be distinguished, fundamentally, from that which bears it (see olive:ContentBearingThing). The classic distinction is between a book's physical copies and the book considered as content. The book considered as content is an instance of olive:Content, whereas a physical copy of the book (or a stone-etched copy, or an audiobook, etc.) would be an instance of olive:ContentBearingThing, since it bears the content. Instances of olive:ContentBearingThing stand in the relation olive:instantiates to the instance of olive:Content that they bear. For example, (:MyCopyOfMobyDick olive:instantiates :MobyDick) . Virtual things that contain content - e.g. databases, websites - are likewise instances of olive:ContentBearingThing, but they are also instances of olive:VirtualThing (and are thus nonphysical content bearers).
materialized content
realized content
physical content
concrete content
content bearing thing
A content bearing thing is a concrete thing that bears, instantiates, or otherwise communicates content (see olive:Content). The classic example is a physical copy of a book making manifest the nonphysical story. For example, (:CatcherInTheRye a olive:Content), whereas (:MyCopyOfCatcherInTheRye a olive:ContentBearingThing). Notice that this class includes virtual content bearing things. This is because websites and databases, while not (obviously) physical, are indeed realized somewhere. I can distinguish the content of a website for matching lizard owners with the best terrarium for them from the (virtually!) concretized website that commmunicates that content.
:MyCopyOfCatcherInTheRye a olive:ContentBearingThing
content use type
olive:ContentUseType is the class of all
A main continuous landmass on a planet. There are seven on Earth: Africa, Antarctica, Asia, Australia, Europe, North America, and South America.
contract
Every instance of olive:Contract is a legally binding agreement - that is, instances of olive:Contract are the contents of agreements the binding power of which issues at least in part from their enforceability by a legal or government organization.
constraint
restriction
specification
standard
This is the subclass of olive:Content each instance of which is a constraining standard applicable to other pieces of content, actions, etc. Instances of this class specify constraints on the things to which they apply by specifying how things can or ought to be. Thus, standards may constitute descriptive/logical or normative constraints: clear examples of the former are data models (see olive:DataModel), which constrain how things can be represented, as a matter of fact, and other "structural" specifications; clear examples of the latter are codes of conduct.
vocabulary
A collection of terms approved and managed by some organization or person.
cost specification
Instances of olive:CostSpecification are commitments (see olive:Commitment) on behalf of a seller to sell some product. As with other commitments, use olive:bindingForAgent to relate instances to the relevant seller and olive:requires to relate instances to a representation of the type of activity specified. Note that this class is orthogonal to olive:Agreement: there may be instances of olive:CostSpecification that are also instances of olive:Agreement (and so are binding for all parties to the agreement), but instances of olive:CostSpecification may also be binding for one party only (as when a seller commits to selling a product at a given price but makes no explicit agreement with any buyer to do so).
count
A measure that involves countable amounts.
counting unit
A unit of counting, especially olive:_each, but also units such as dozens.
country
olive:Country is the class of all geographical regions that are part of some country. Note that this is different from the country government or population.
olive:County is the class of all geographical regions that are part of some county. Note that this is different from the county government or the population of the county.
CPT code
current procedural terminology code
olive:CPTCode is the class of all CPT codes. Each code should be connected with the class of events that it signifies, as well as the descriptions associated with said code.
creation
olive:CreationEvent is the class of all events in which some primary object (see olive:eventCreates) is created. Note that this class is disjoint with olive:DestructionEvent - this is not to say that creations and destructions cannot happen simultaneously or in the same vicinity, but that each creation and destruction should be modeled as a distinct event (two common sorts of cases are (1) an overarching creation that involves specific destructions as subevents, and (2) a creation and a destruction that occur simultaneously as subevents of some larger event). Note: just like every other event, one should specify when it happened using olive:timeOfEvent or its subproperties.
currency
hard currency
cash
money
olive:Currency is the class of all physical objects created with the purpose of being used as currency (paradigm examples include coins and paper notes). This class thus excludes de facto media of exchange, such as nuggets of gold, which may be used to facilitate an exchange but are not created with this explicit purpose. See also olive:boughtFor.
currency unit
A unit of money. Note: this is the only unit whose conversion factors include time (i.e., the conversion rates change on a daily basis).
A call to a custom function within some SPARQL query.
database
This is the class of all (deployed) databases. Databases are virtual things (see olive:VirtualThing) that are used to store and organize data and are supported by / accessed via a server. One must be careful to distinguish the database itself from the content that it stores (see olive:Database-Content) - the database is a medium which may store/bear/communicate that content (a file is an example of an alternative medium). This is the pattern for expressing the relationship between a deployed database and the content that it "contains": (:Database1 olive:instantiates :Database-Content1). See also olive:DataModel for a related notion of content.
data classification type
data type
This is the class of all categories used to classify data. Notable instances include :SensitiveInfo-OliveIP and :SensitiveInfo-PHI. Organizations may need to create their own instances of this class tailored to their own classification structure.
data load
data ingestion
Data Loads are invocations that move or copy data as their primary concern.
data model
database schema
This is the class of all data models, considered as abstract things. For a given relational database, its specific schema, table, and column definitions coupled with keys, restrictions, etc. jointly constitute its data model. For an RDF graph, the data model might be conceived of as the properties (and, perhaps, classes) used in expressing the graph. There is some flexibility here with regard to just what gets counted as part of the data model for a given database. The important thing is that this class affords us a way of representing cases in which two distinct databases (see olive:Database) contain different data (see olive:Database-Content) but nevertheless have the same specific structure (as when, say, a single DDL is loaded into two distinct relational databases, but they are then populated with different records).
data sensitivity level
data confidentiality level
This is the class of data sensitivity levels, each of which can be used to attribute a level of sensitivity (e.g. public use, internal use, confidential, etc.) to data or categories of data (see olive:DataClassificationType and its instances) using olive:categorizedBy. Organizations may need to create their own instances of this class tailored to their own classification structure.
dataset
structured data
This is the class of all datasets. A dataset is a data artifact, considered as content. Datasets are typically conceived of as structured, but we also allow for unstructured datasets; it is also conceivable that a dataset itself is unstructured while having structured datasets as parts or members (if it is represented as an instance of olive:Collection). The ontology is also agnostic as to whether the structure, format, language, etc. of a given dataset is essential to it: there may be various levels of abstraction involved in representing "a dataset". Note, though, that if a given dataset is represented as abstracting to a particular instances of olive:DataModel such a representation makes that data model (and its associated structure) essential to that dataset. Instances of this class can be instantiated by instances of olive:DataStore (see olive:instantiates). Instances of this class can, in turn, be abstracted to (see olive:abstractsTo) instances of olive:DataModel and/or more general instances of olive:Content. For example, suppose I have a relational database and a triplestore that I use to represent the content of some CSV file. In such a case, there are presumably three different instances of olive:DataStore (a triplestore and a relational database, each of which is accessed via a server, and a CSV file, which is, say, stored electronically on a hard drive). Each of these data stores may be represented as instantiating a unique instance of olive:Dataset, since the explicit content expressed by each data store differs from that expressed by the others. Each of these unique instances of olive:Dataset may, in turn, be represented as abstracting to a unique instance of olive:DataModel. However, it may also be the case that all three of these unique instances of olive:Dataset abstracts to a single, common instance of olive:Dataset, which is the "common" data present in each of the three unique datasets. And, as a consequence of the transitivity of olive:abstractsTo, this representation allows us to capture the sense in which each of the three unique data stores abstract to the same dataset, while also allowing for the representation of the fact that their formats and explicit content differ.
data size unit
A unit to measure amounts of digital information.
data store
This is the intersection of olive:ContentBearingThing and olive:VirtualThing. Instances of this class are virtual things that store information/data. Notable subclasses include olive:Database and the intersection of olive:File and olive:VirtualThing. See olive:Dataset for a class that is importantly related to this one.
date instant
A point in time known only to the accuracy of one day. Say the signing of the declaration of independence on 7/4/1776
This template is only for points of time with the granularity of a day (each of which should be uniquely identified by a date string of the form YYYY-MM-DD).
deactivation
olive:Deactivation is the class of all events in which some primary object (see olive:changedThing) is deactivated. Note: just like every other event, one should specify when it happened using olive:timeOfEvent or its subproperties. It's worth noting that the most recent change event will give us the olive:lastModifiedOn time for the subject of the change event.
death
olive:Death is the class of all events in which some instance of olive:LivingThing (see olive:changedThing) becomes deceased. Note that this is a subclass of olive:ChangeEvent rather than olive:DestructionEvent - this allows the ontology to remain neutral with regard to questions of personal identity and to allow for death to be modeled differently in different contexts. Note: just like every other event, one should specify when it happened using olive:timeOfEvent or its subproperties.
deceased
olive:DeceasedThing is the class of all things that are deceased, are no longer alive. Perhaps counterintuitively, this is a subclass of olive:LivingThing. This is because olive:LivingThing is not the class of *currently* living things, but rather the class of things that were alive at one time or another. As such, all deceased things must be (formerly) living things.
deception
olive:Deception is the class of all events in which some instance of olive:Agent (see olive:does) deceives one or more other agents (see olive:affectedObject-Direct). Note: just like every other event, one should specify when it happened using olive:timeOfEvent or its subproperties.
education degree
Instances are certifications from academic institutions, such as high school degrees, BA, BS, PhD, and so on. This does not include certifications for things such as CPR proficiency. Note that 'degree' involving low/medium/high amount is a different notion altogether. See olive:QualitativeAssessment.
academic degree
The subclass of olive:Degree all instances of which are awarded to a person upon completion of a course of study in higher education. Academic degrees are typically contrasted with professional degrees (see olive:Degree-Professional).
associate's degree
associate degree
The subclass of olive:Degree all instances of which are associate degrees (typically awarded after a course of study of 2-3 years).
Bachelor of Arts
The subclass of olive:Degree-Bachelors all instances of which are Bachelor of Arts degrees.
Bachelor of Science
The subclass of olive:Degree-Bachelors all instances of which are Bachelor of Science degrees.
bachelor's degree
bachelor degree
The subclass of olive:Degree wherein a bachelor's degree is awarded.
doctoral degree
The subclass of olive:Degree-Postgraduate all instances of which are doctoral degrees.
high school diploma
diploma
The subclass of olive:Degree wherein a high school diploma is awarded.
master's degree
The subclass of olive:Degree-Postgraduate all instances of which are master's degrees.
master of arts
The subclass of olive:Degree-Masters all instances of which are Master of Arts degrees.
Doctor of Medicine
The subclass of olive:Degree-Doctorate all instances of which are MD (Doctor of Medicine) degrees.
master of science
The subclass of olive:Degree-Masters all instances of which are Master of Science degrees.
PhD
doctorate
Doctor of Philosophy
The subclass of olive:Degree-Postgraduate wherein a PhD (Doctor of Philosophy) is awarded.
graduate degree
postgraduate degree
The subclass of olive:Degree all instances of which are degrees pursued following graduation from undergraduate study (see olive:Degree-Undergraduate).
professional degree
The subclass of olive:Degree all instances of which are designed to prepare a person for work in a particular profession. Professional degrees typically serve as a contrast to academic degree (see olive:Degree-Academic).
undergraduate degree
The subclass of olive:Degree all instances of which are degrees pursued during undergraduate study at a college or university.
delivery
olive:Delivery is the class of all events in which something is delivered. This requires both the movement of the thing and the handoff of control of that thing. Examples include delivering flowers, or bringing food to a patient's room.
deontic status
Deontic statuses have to do with whether something is optional, required, supererogatory, and so on. These are normative classifications. Note that there is also the class of olive:Obligation, which is clearly closely related to the instance olive:Required.
destruction
olive:DestructionEvent is the class of all events in which some primary object (see olive:changedThing) is destroyed. Note that this class is disjoint with olive:CreationEvent - this is not to say that creations and destructions cannot happen simultaneously or in the same vicinity, but that each creation and destruction should be modeled as distinct events. Note: just like every other event, one should specify when it happened using olive:timeOfEvent or its subproperties.
disbandment
olive:Disbandment is the class of all events in which an instance of olive:Organization (see olive:changedThing) becomes disbanded. In such events, the organizing principle of the organization is disrupted in such a way that the organization ceases to exist; consequently, this is a subclass of olive:DestructionEvent. Some examples are when a band breaks up or a company is dissolved. Note, though, that disbanded organizations can reform (as when a band gets back together). Note: just like every other event, one should specify when it happened using olive:timeOfEvent or its subproperties.
disease
olive:Disease is the class of all diseases. Diseases are distinguished from illnesses in that diseases are to be cured, whereas illnesses are to be managed.
distance
extent
length
A measure of distance, which could be distances over the Earth, and could also be height, width, length, depth, girth, etc.
distance unit
A unit to measure linear distance, such as feet or kilometers.
olive:Doctor is the subclass of olive:MedicalProfessionals who are medical doctors. Note that this class does not include dentists. It also does not include all Phd holders in general.
duration
EXAMPLE: One week (or seven days), but not Jan 1, 2008 to Jan 7, 2008 (which is an interval). Intervals have durations, but are not themselves durations.
duration unit
A unit to measure passage of time: hours, days, years.
drug
medication
olive:Drug is the class of all individual drugs. This class is orthogonal to olive:PhysicalSubstance and olive:PhysicalObject. That is, olive:Drug contains both countable objects and uncountable substances. A sample of Morphine is a drug, as well as a tablet of Motrin.
dispensing a drug
receiving a drug
acquiring a drug
Drug dispensations are when a drug has been given to the possession of some recipient. This is importantly different from olive:ReceivingADrug, wherein the drug is administered.
education
olive:Education is the class of all events in which someone is educated. This includes traditional schooling, such as olive:PrimaryEducation and olive:PostGraduateEducation, as well as training sessions where one is certified in, say, CPR. Often an education event culminates in the organization doing the educating furnishing the student (see olive:studentIn) with a certificate (see olive:Certification).
college
undergraduate education
undergrad
olive:Education-College is a subclass of olive:Education. This is reserved for undergraduate education, even though graduate school also takes place in a college/university setting.
graduate school
grad school
graduate education
olive:Education-GraduateSchool is a subclass of olive:Education.
medical school
med school
olive:Education-MedicalSchool is a subclass of olive:Education.
electrical current
electric current
electrical current unit
Unit of electrical current, which is charge per unit time. The SI unit is the ampere. (Note that electrical current is a composed unit.)
email
email account
An email address is a unique identifier for an email account. It is used to both send and receive email messages over the Internet. Each account should be associated with at least one agent (see olive:hasEmailAddress). Note that an email address in this sense is distinct from the string. One can use 'address' synonymously with 'account'. So, if you would send an email to 'ontologist@awesome.com', that string would be related to the email address
emotion
olive:EmotionalState is the class of all situations in which the focal state is an emotion. Paradigm examples are being in love, being angry, being disgusted, and being in awe. Of course, the psychology of emotions is complicated, at best, which means that many attempts to get more fine-grained on what exactly emotions are will be controversial. Be wary! As with the other states, you might want to track something related and more dynamic, which would be a corresponding event. So, if I want to talk about how my love of my wife has grown and deepened over the years, it might be better to talk about the event of our relationship. Just be mindful of whether you are focusing on the state or the event when modeling. Also note that many emotions appear to have direct objects. So, I might distinguish my anger as being anger at a customer service representative. This is fine, but it is not required for all emotions. We might just represent my unqualified angry state, or my unqualified joyful state. Worth noting that often emotional states with objects can also be represented as being caused by those things: the interaction with the customer service representative caused my anger. That said, we often experience emotions towards things that didn't cause them; humans aren't the most logically consistent creatures.
employment
olive:Employment is the class of all employment events. These events should specify, like all events, the start and end of the event when known. They should also specify the employer and the employee.
api endpoint
An interface for a remote (web-based) function call; it consists of both the location and the protocol by which someone interacts with the relevant API.
episode of care
olive:EpisodeOfCare is the class of all medical care 'episodes', which encompass everything used to care for some illness, condition, or medical event for a given patient. So, if Anne receives surgery on her wrist, the episode of care will include the pre-op, surgery, post-op, and perhaps the physical therapy that follows. Episodes are useful conceptually for gathering related procedures, and they are also becoming more popular as a way to bill--we might end up with more efficient care if we are maxxing out the cost-benefit of the episode of care, rather than the individual subevents. For example, certain surgical procedures may lower costs of surgeries, but may bear higher costs later in terms of therapy required. Contrast with olive:MedicalEncounter, which are the more 'bite-sized' events that combine to form an episode.
equipment
Equipment are tools, machines, or other physical pieces of technology that aid in completing some task. Paradigm instances include hard hats, hammers, cars, stethoscopes, MRI machines, baseball bats, and syringes.
evaluation
feedback
Instances of olive:Evaluation are instances of olive:Content in which something is being evaluated. As such, one should specify who is doing the evaluating (olive:evaluator), what is being evaluated (olive:evaluatedThing), and what the evaluation is (e.g. olive:quantitativeStrength or olive:qualitativeStrength). Paradigm examples would be a report card (though that might be best thought of as a collection of evaluations, usually one for each subject), a Pulse Survey response, or a letter of recommendation. Note that olive:Recommendation is orthogonal to olive:Evaluation. Recommendations may be evaluations or vice-versa, but they are not coextensive. For one thing, their purposes are not the same. I might recommend a hairstylist to you, but my purpose is to get you a good haircut, not to provide feedback to the stylist.
event
occurrence
happening
olive:Event is the class of all events. Roughly, an event is something that happens. They are temporal things, having start (olive:startOfEvent) and end (olive:endOfEvent) times. Paradigm examples include basketball games, doctor's visits, and chemical reactions. To describe an event beyond the bare classification (e.g. specifying that some event is an ex:BirthdayParty), use subproperties of olive:EventInvolves. This will allow you to specify the role that various things play in a given event. For example, a birthday cake may play the 'thing being eaten' role in a birthday cake eating event. Or Katy might play the 'birthday girl' role in a given birthday party. We can sometimes be tricky and use events to express more complex relations. Suppose I am sitting between two people on a bench. It would be great to say (:Me ex:isbetween [:Bill and :Sandy]), but we simply can't do that in triples. We can, however, say that there's some ex:SittingOnABench event in which the ex:personOnTheLeft is :Bill and the ex:personOnTheRight is :Sandy. As such, you can use this event as a nexus (or a Christmas tree!) to 'hang' off all the relevant details. Another way that you might use events is to provide temporal qualification. If Jeremy is wearing a blue sweater, you might hestitate to write (:Jeremy ex:wears :BlueSweater1), since it wasn't true yesterday and won't be true tomorrow. There are a few remedies here, including reification, but you could also reify a 'sweater wearing event' that holds between Jeremy and his sweater, and give that event a start and end time.
exchage
olive:Exchange is the subclass of olive:TransferEvent all instances of which are themselves constituted by multiple transfers, resulting in an end state such that the things transferred can be conceived of as replacing each other in some way. This sort of replacement can be physical (as when one replaces the strings on a guitar with a new set, or when people trade seats on an airplane), but it can also involve an exchange of (non-physical) control or rights (as in commercial transactions, where rights of ownership are exchanged). An important subclass of olive:Exchange is olive:Transaction, which is the class of exchanges such that the exchange occurs between two agents. In every instance of olive:Exchange, there should be more than one thing playing the role of olive:thingTransferred (or one of its subproperties), and one is licensed to conclude that the things playing this role are exchanged for one another in the event in question. Note that the each of the things playing the role of olive:thingTransferred in an instance of olive:Exchange should also, properly speaking, be conceived of as playing the olive:thingTransferred role in a transfer (see olive:TransferEvent) subevent (see olive:hasSubevent) of the top-level exchange. (Whether or not these subevents are explicitly represented depends on one's modeling purposes.)
exemplar individual
exemplar
paradigm individual
model
This is a strange class. Every class can be thought of as having a paradigm instance of that class: the paradigm cheeseburger, doctor, exercise, etc. olive:ExemplarIndividual is the class of all such paradigm/exemplar individuals. Every class has exactly one such exemplar individual, and that individual can be used as a stand-in for the class. For example, if I say that I desire a cheeseburger, then prima facie it looks like I'm relating my desire to the class ex:Cheeseburger. However, we could also say that there is a single thing that I desire, namely the 'exemplar cheeseburger' (it's probably the thing that you're picturing in your head right now). As a convention, we name the exemplar for CLASS :Exemplar_CLASS. So, the exemplar doctor is :Exemplar_Doctor. Given that every class has exactly one exemplar (see olive:exemplarForClass), you might think that learning (:X a olive:ExemplarIndividual, olive:CLASS) and (:Y a olive:ExemplarIndividual, olive:CLASS) means that (:X owl:sameAs :Y). But that's a mistake. It might be that :X is directly an instance of olive:CLASS, whereas :Y is an instance of SUBCLASS, such that (olive:SUBCLASS rdfs:subClassOf olive:CLASS). To make this more plain, both the exemplar burger and the exemplar cheeseburger would be exemplars and burgers, though only the exemplar burger is the exemplar burger. Note that being an exemplar does not mean that a thing is good. Oncologists treat cancer, and we can state this by using :Exemplar_Cancer. But this does not mean that we should all aspire to be more like or to get this cancer.
facet
olive:Facet is intended primarily to be a top-level instance of owl:Class that serves to collect (as subclasses) instances of olive:Class-SecondOrder. To put it another way, the primarily role of this class is to streamline the top-level nodes of the Olive ontology. Instances of this class are all second-order classes (see olive:Class-SecondOrder) that serve as (at least partial) facetings (see olive:facetingOfClass) of some first-order class in (or constructable from) the Olive ontology.
female
Female living things are of the sex that can bear offspring or produce eggs, distinguished biologically by the production of gametes (ova) which can be fertilized by male gametes.
Each instance of olive:Field-Data is the collection of cells (see olive:Cell-Data) for a given field or column. Each field should have an olive:fieldName, olive:fieldDataType, and olive:fieldProperty. These will give information about the logical meaning of the field.
Figures are graphics that appear in written or visual media that convey information, such as tables, charts, and graphs.
file
This is the class of all files, whether physical files (made of, e.g. paper) or virtual files stored on a computer (see olive:VirtualThing). One should be careful to distinguish instances of this class from the content (see olive:Content) that they instantiate (see olive:instantiates). So, for example, :NicksKnowledgeGraph-TTLFile, a turtle file, would be an instance of this class, but the content expressed by that file (:NicksKnowledgeGraph-Content, say), would be an instance of olive:Content and (:NicksKnowledgeGraph-TTLFile olive:instantiates :NicksKnowledgeGraph-Content) would hold.
paper file
This is the intersection of olive:File and olive:PhysicalObject. Paradigmatic examples are paper files; paradigmatic non-examples are computer files.
computer file
virtual file
electronic file
This is the intersection of olive:File and olive:VirtualThing. Paradigmatic examples are computer files; paradigmatic non-examples are paper files.
file attribute
olive:FileAttribute is the class of all accessibility attributes that can apply to content, usually computer files. Most notably, read/write status or whether a file is public/private might be expressed using instances of these categories.
force
olive:Force is the class of all events that are physical forces. This is a tricky class because it is natural to talk about forces as "physical" even though they are not physical things (since they are events). Forces are a particular type of interaction between physical bodies, and it is in virtue of the involved bodies being physical that the force is considered "physical". Note that often we will be more interested in the situation (and usually event) in which the force is applied than in the force situation itself. So, while a force is involved in kicking a field goal, we are more likely to model and be interested in the kicking event than on focusing on just the force itself.
form
This is the class of all forms considered as content (which may be expressed by some content-bearing thing - e.g. a paper form you fill out at the doctor's office). A form is a non-physical template that allows for information to be communicated in a structured way. Instances of this class are the "abstract" form structures themselves - e.g. the abstract template instantiated in a paper copy of an I-9 form. Filled-in forms communicate additional content, although they abstract to an instance of this class. So, for example, all of the following can consistently hold: (:MyFilledI9Form-PaperCopy olive:instantiates ::MyFilledI9Form-Content) (:MyFilledI9Form-PaperCopy olive:instantiates :I9Form) (:MyI9Form-Content olive:abstractsTo :I9Form) (:I9Form a olive:Form-Template)
fraud
olive:Fraud is the class of all events in which some instance of olive:Agent (see olive:does) commits fraud - that is, they engage in deception in order to achieve some sort of financial or personal gain (typically at the expense of one or more other agents). Note: just like every other event, one should specify when it happened using olive:timeOfEvent or its subproperties.
Functions have inputs and outputs. This class includes mathematical functions as well as software functions (see olive:TaskRunnerAction). This class is not the same as gist:Function, which is about the intended use of some artifact.
A specific direct invocation of some function with specific arguments
game
olive:Game is the class of all codes of conduct that are rules for games. Every time an activity conforms to an instance of game, that activity is an instance of olive:GameEvent.
olive:GameEvent is the class of all competitions played according to rules where there can be a winner or loser (though games can end in other states like ties). Moreover, games are typically events in which the players play for leisure, entertainment, or fun. olive:GameEvent includes playings of board games, sports, and party games. Note that this is distinct from olive:Game. Every olive:GameEvent must is played according to some normative specification that is an instance of olive:Game. For example, an instance of olive:ChessGame will be played according to the rules of olive:Chess, which is an instance of olive:Game.
gender category
olive:Gender-Category is the class of all genders that one might identify as. This includes male and female, but note that it is distinct from the notion of sex (see olive:Sex-Category). One's assigned sex may (and often does) differ from their identified gender, even if we use, say, the term 'female' to refer to both the female sex and the female gender.
gender expression category
olive:GenderExpression-Category is the class of all gender expressions. The two traditional 'extremes' are masculine and feminine, though it is unclear what the best conception of the range of possible values is. Rather than taking such a stand in the ontology, we will add in new values as they become relevant. It's possible, indeed probable, that this dimension of the ontology is never needed for a business case, but we want to have an ontology that has the space for the nuanced ways that one might discuss sex and gender, and it feels impoverished to just have identification (see olive:Gender-Category) without also expression.
location on the Earth's surface
An individual point on the Earth's surface, identified by latitude, longitude and altitude. If altitude is missing, it is assumed to be at the Earth's surface. However, altitude is measured from sea level. these points are to the WGS-84 coordinate system using the GPS decimal lat/long
NOTE: Assume coordinate system used by Google (WGS 84 Web Mercator).
government
The geopolitical body that governs a geopolitical region recognized as a country.
An organization established either by fiat (as a conquering army overtakes a land and declares a government) or by delegation from a fiat government, such as a state or local government or a specific agency. Differs from a corporation in that it cannot be owned.
EXAMPLES: The State of Washington Office of Financial Management; the Food and Drug Administration; the Scottish Parliament.
NOTE: Establishment by a CountryGovernment may be indirect via local, regional, or national GovernmentOrganization(s) that ultimately are recognized by a CountryGovernment.
group purchasing organization
GPO
A group purchasing organization (GPO) is an entity that helps healthcare providers — such as hospitals, nursing homes and home health agencies — realize savings and efficiencies by aggregating purchasing volume and using that leverage to negotiate discounts with manufacturers, distributors and other vendors.
group
A collection people. The group may or may not also be an instance of olive:Organization. Many organizations consist of groups of people, but that is not a defining characteristic. As with any group, this is defined extensionally rather than intensionally.
GUI
graphical user interface
A visual component via which a user may interact with a software application.
gynecologist
olive:Gynecologist is the class of all gynecologists.
HCPCS code
healthcare common procedure coding system code
olive:HCPCSCode is the class of all HCPCS codes. Each code should be connected with the class of events that it signifies, as well as the descriptions associated with said code.
healthcare system
health system
A healthcare system is an organization that consists of either at least one hospital plus at least one group of physicians or more than one group of physicians.
health condition
olive:HealthCondition is the class of all diseases, disorders, injuries, and other related health conditions. Paradigm examples include twisted ankles, diabetes, allergies to latex, and ADHD. Individual persons can have these conditions (see olive:hasCondition). The conditions might be treated, or have symptoms. Certain physicians may specialize in some of these conditions (e.g. an oncologist specializes in cancer; see olive:Oncologist). This class is meant to emcompass more or less the same subject matter that is mapped by the ICD.
home care event
olive:HomeCareEvent is the class of all events in which a person receives medical care at home. The care provider need not be, and usually is not, a medical care professional. This class of events will typically be used to document how a patient has historically been treating some condition, or as a disposition (see olive:patientDischargedTo) for some other medical care event.
olive:Hospital is a subclass of olive:Organization and olive:MedicalCareProvider where each instance is a hospital. Note that this class refers to the organization, not the building. When you are 'at the hospital', you are at the building that is the headquarters for a hospital organization. Conflating a building and an organization can lead to confusion.
children's hospital
Children's hospitals are a instances of olive:Hospital that provides services to children, persons up to 18 years old (sometimes 21 years old in the United States).
critical access hospital
Critical access hospitals are US hospitals that receive federal funding as part of a 1997 Balanced Budget Act provision to provide medical access to rural areas that would otherwise be too far from emergency medical care.
psychiatric hospital
Psychiatric hospitals are olive:Hospitals that focus on providing psychiatric care.
VA medical center
veteran's affairs hospital
VAMC
VA hospitals are run by the United States Department of Veterans Affairs.
hospital system
A hospital system is an organization that consists of more than one hospital that function together as part of a system.
type of human activity
olive:HumanActivityType is the class of all classes of events all instances of which are activities essentially performed by agents. Despite the 'human' in the name, the restriction is that every such activity must have an agent performer. ('human activity' is a more intuitive naming convention than 'agential activity').
identifier
EXAMPLE: e.g. SSN for a person, serial number for a product, employee id
EXAMPLES: SSN for a person; serial number for a product; employee ID.
This template uses the sha1 function to hash the following pattern: for ID, concat(CREATOR-NAME,"-",IDENTIFYING-TEXT), where (ID [owl:inverseOf olive:createsID]/olive:name CREATOR-NAME) and (ID olive:identifyingText IDENTIFYING-TEXT). This pattern should be encoded as olive:uniqueText on the ID in question when it is used.
ISO
implementation success owner
olive:ImplementationSuccessOwner, as per the latest Workable job description: 'you will lead and manage our SaaS and AI implementations with enterprise healthcare organizations and are the primary point of contact for our customers during the implementation process.'
injury
olive:Injury is the class of all injuries. Note that the injury is different from the injured thing. For example, when I twist my ankle, :MyAnkleInjury is not identical to :MyAnkle (which is injured).
intellectual property
A work, invention or concept, independent of its being expressed in text, audio, video, image, or live performance. IP can also be tacit knowledge, know-how, or skill. Also includes Brands.
EXAMPLES: ?The Old Man and The Sea?; the Page Rank algorithm; Coca Cola
NOTE: For literature this could be called the ?Work?, except that ?work? is a highly overloaded term (expenditure of energy, resource consumption, art). Often the first expression precedes our recognition of the IP, but subsequent expressions are known to be derivatives of the IP, even if they are expression-to-expression translations (or copies).
intention
olive:Intention is the class of relationships between a thing (often a person or an artifact) and some state of affairs. Things like intentions, and functions, and desires have some very simple and intuitive examples, but are difficult to give a general treatment. This comment will start with the simple and then move to more nuances. Take some simple examples: I have a desire to eat a hamburger. This hammer has the function of hammering nails. Olive AI has a goal of removing $1 trillion from healthcare expenses in the US. Here we have three things: a desire, a function, and a goal. And we have three actors: myself, a hammer, and Olive AI. And each of these things is related to some possible state of affairs: one where I eat a burger, one where the hammer is hitting some nails, and one where Olive AI has drastically reduced healthcare costs in the US. We also say that a bird's beak has the function of, say, penetrating the bark of some tree. This is so even if you don't believe there is some god who has intended it as such. If random chance, or natural selection, or whatever is the causal force that has led to a situation where a beak is well-suited for some task, it is still appropriate to use olive:Intention or a subclass to express this. In some ways, as natural as it is to say that we have a desire or function or goal, it is very weird to think of these as entities in and of themselves. Compare to the similar class olive:Magnitude. It's sensible to say that a baseball bat has a length and a weight, but it's weird to think that the bat and, say, 45 inches, are mediated by a length. The measure just *is* the length, and the measure directly reflects a part of the bat itself. Similarly, to say that I have a desire feels more like some direct relationship between myself and the state of affairs in which I eat a burger, and not that I stand in some relation to the desire, and that desire stands in some relation to the world. The above discussion just highlights that the representation in triples may not reflect the actual structure of reality. Or, our language might not. Or neither. In practice, intentions are used as intermediaries between things and states of the world which are intended/desired/etc.
invocation
execution
Every invocation is an event in which some plan/algorithm/function is carried out (see olive:invokes). So, if we define some function F such that F(x) = x^3, then applying that function to some specific value and getting an output, such as F(3) = 27 as a process would be the invocation. For another example, consider an offensive system in basketball, the Triangle. The Triangle is a system that is carried out by many basketball teams in particular plays and games. These events are invocations of that system. Invocations ought to specify the thing being implemented using olive:invokes (or subproperties).
function input
Inputs are the arguments that are inputs for a function (see olive:Function). By definition, every input in the domain of a function should be mapped to at least one output (see olive:Output).
olive:InsuranceClaim is the subclass of olive:Obligation where a policyholder (see olive:hasInsurancePolicy) places a claim against their insurer (see olive:insurerForPolicy). The claim is supported by the agreed upon policy (see olive:InsurancePolicy). The claim will then either be denied, leaving the policyholder with the cost burden, or accepted, in which case the insurer will bear at least some of the financial burden. Note that the claim is NOT the same as the event in which the covered party incurred a cost (e.g. an instance of olive:MedicalCareEvent). Nor is it the transfer of funds to the provider. Every claim should be connected (at least) to the relevant policy via olive:policyForClaim. It should also be connected to the event for which compensation is being requested.
:Claim123 a olive:InsuranceClaim; olive:claimForEvent :BillsAppt; [owl:inverseOf olive:policyForClaim] :BillsInsurancePolicy.
paid claim
Paid insurance claims are those where the full contracted amount has been recovered by the provider.
underpaid claim
underpayment
Underpayments are insurance claims that, for whatever reason, have not had their allowed amount paid in a reasonable period of time. Obviously this class is very important to providers, as they want to minimize the number of claims that are not reimbursed at the contractually agreed upon amounts.
types of insurance claims
Instances of this subclass of category are tags that are applied to instances of olive:InsuranceClaim. Notable subclasses include RARC and CARC, which provide comments on a given claim's features.
olive:InsuranceCompany is a subclass of olive:Organization where each instance is an insurance company. This includes health, home, life, and so on. Importantly, insurance companies are often the payors for medical care events (see olive:MedicalCareEvent).
insurance plan
Insurance plans are the predecessors to insurance policies in the sense that plans are broader guidelines that policies (are intended to) follow. Employers pick/craft a plan, and then there are are individual policies that employees receive, for instance.
EPO
exclusive provider organization insurance plan
olive:InsurancePlan-EPO is the class of all exclusive provider organization plans.
HDHP
high deductible health plan
olive:InsurancePlan-HDHP is the class of all high deductible health plans.
HMO
health maintenance organization insurance plan
olive:InsurancePlan-HMO is the class of all health maintenance organziation plans. These have lower premiums than, say, PPOs, but they do this by trading costs for flexibility in provider choice for members.
POS
point of service plan
olive:InsurancePlan-POS is the class of all point of service plans.
PPO
preferred provider plan
olive:InsurancePlan-PPO is the class of all preferred provider insurance plans. The premiums of PPOs are usually much higher than those of HMOs and HDHPs, but they aim to make up for this in flexibility in terms of provider selection for policyholders.
Uninsured
olive:InsurancePlan-Uninsured is the class of all 'plans' where the person has to pay their own way. For purposes of merging with other ontologies, it was expedient to make this a subclass of olive:InsurancePlan, though I certainly sympathize with others who might prefer to not call this class an insurance plan at all. Still, folks who are uninsured or self-insured can be said to be normatively bound to pay their own way, and as such this serves much the same purpose as, say, a PPO plan.
olive:InsurancePolicy is the subclass of olive:Contract between a policyholder (see olive:hasInsurancePolicy) and an insurance company (see olive:InsuranceCompany and olive:insurerForPolicy), where the policyholder distributes some risk of payment for qualifying health events to the insurance compan. Coverage usually includes doctor's visits, prescriptions, or consultations.
:Bob :hasInsurancePolicy [a olive:InsurancePolicy; olive:identifiedBy [olive:uniqueText "Policy ABC123"^^xsd:string]]
insuranceportal
olive:InsurancePortal is the class of all insurance portals.
internship
olive:Internship is the class of all internships. Internships sit somewhere in between traditional employment and schooling. They last for a relatively short period of time, and the intern is expected to receive less (or no) pay during this time but receive beneficial instruction from the employer.
Each instance of olive:KeyValuePair is a two-item list where the first item is a key and the second item is a value. Often these key/value pairs are stand-ins for two-thirds of a triple.
knowledge graph
olive:KnowledgeGraph is the class of all knowlege graphs, which are sets of n-tuples (usually triples) that model data. This very assertion is part of a knowledge graph.
read only knowledge graph
olive:KnowledgeGraph-ReadOnly is the class of all knowledge graphs that are read only.
language
This is the collection of recognized, organized set of symbols and grammar. It includes natural languages like Greek, Latin, English, Spanish, and French. It also includes programming languages, such as Lisp and C++.
letter grade
grade
Letter grades are things like A, B, C, D, and F. These will be the instances of this class.
license
The class of all licenses. A license is a kind of certification that constitutes an official permission to do, use, or own something. Instances of this class are not the concrete documents that serve to verify the possession of such a license, but instead are the abstract licenses themselves. So, the driver's license card I hold in my hand would not be an instance of this class, but permission for me to operate a motor vehicle attested to by that document would be an instance of this class.
Every instance of olive:LineItem is a part of some olive:Commitment and may itself be an instance of olive:Commitment (although it need not be). Line items are of accounting interest, and are typically related to whether they are paid, their amounts, identifying codes, and so on.
A list is a data structure that contains an ordered list of members.
living thing
This is the class of all things that have been alive, including trees, mushrooms, bacteria, persons, and kittens. One might worry about whether to classify Beethoven or any other such dead living thing as still being a living thing. This is worth considering, but it is not unique to living things. All things that can cease to exist, including living things and statues and sweaters, may only belong to their sortal category for a limited period of time. For this reason, once a thing comes to exist (at it's creation time, see olive:dateOfBirth, e.g.), it is a living thing eternally. Once the thing dies (see olive:dateOfDeath), that thing is even more particularly an instance of olive:DeceasedThing. Note that asserting that olive:Person to be subclass of olive:LivingThing would entail that robots/computers could not be persons unless they were also classified as living things. This does not seem problematic to me, but I expect some might find it controversial.
long term care facility
Long term care facilities are healthcare organizations that focus on delivering longterm care. This includes nursing homes, hospice care, and some (but not all) psychiatric facilities. Note that while the name ends in 'facility', this is about the organization and not the building/grounds for the organization.
brightness
A measure of the wavelength-weighted power emitted by a light source in a particular direction per unit solid angle. This is based on the luminosity function, a standardized model of the sensitivity of the human eye.
luminous intensity unit
The measure of brightness. The SI unit is the candela.
magnitude
Every member of olive:Magnitude is a quantitatively measurable feature of some physical thing. For example, a given object may have a weight, length, and temperature. Each of these could be magnitudes (e.g. [:_Weight_WeightOfRock1 rdfs:type olive:Magnitude]). Rarely should a given magnitude be directly asserted to be a magnitude. Instead, one should use the appropriate subclasses, such as olive:Mass, olive:Distance, and olive:Temperature. The count of something is also a magnitude, for instance, there being seventeen people in a crowd or three quarters in my pocket. The olive:Magnitude approach to representation usually requires at least three asseertions to be made. First, one connects the object in question to their magnitude. Then, one specifies the numeric component of the magnitude. Finally, one specifies the units. For example, suppose we want to specify that the Eiffel Tower is 300m tall. We can do this with the following triples: [:EiffelTower olive:hasMagnitude :_Extent_ETHeight], [:_Extent_ETHeight olive:decimalValue "300"^^xsd:double], and [:_Extent_ETHeight olive:hasUoM olive:_meter]. Notice that there are alternative approaches if you want to directly connect an object to some of its measures. One could use custom data types as a range and create a property to take you directly from the thing in question to its weight/length/temperature/etc. For example: [:EiffelTower ex:hasHeight ""^^dataEx:meter]. Ideally, such properties should be connected to the equivalent representation using olive:Magnitude (or subclass), and thus either representation can be derived from the other. Decisions about which representation to use initially or at query time may best be made in terms of practical considerations: flexibility, speed of queries, naturalness of representation for users, and so on. So, why bother having magnitudes at all if we could just use properties to skip straight to the important thing (the number/unit pair)? The answer is that you might want to say more about a magnitdue than just its amount. We might also want to specify the degree of precision (see olive:hasPrecision). Or we might want to note that two different magnitudes are equivalent to each other. This representation approach gives you a great deal of flexibility. Note that olive:Magnitude is a subclass of olive:Attribute, but it is neither a subclass of olive:Category nor disjoint with it. This is to allow for instances of olive:Magnitude to be "particularized" (e.g. :TheHeightOfTheEiffelTower, where this may have some specific associated quantity measure and quantity unit but is not identical to the combination of the two) or "universal" (e.g. 200 meters as a universal quantity).
:EiffelTower olive:hasMagnitude :_Extent_ETHeight
male
Male living things are of the sex that produces small, typically motile gametes, especially spermatozoa, with which a female may be fertilized or inseminated to produce offspring.
Every instance of olive:MappingEvent is an event in which some content (see olive:Content) is mapped to some other content (see olive:Content) using some defined mapping algorithm. For example, a medical dataset (input) might be mapped into the Olive ontology via a construct query (the mapping algorithm), thus resulting in a set of triples (output). This collection is designed to be especially useful in logging mapping failures during some mapping process.
mapping status
The category of mapping statuses. See the comment on the relation olive:mappingStatus.
mass
Magnitude of mass. In medical contexts, when we talk about a 'mass' we do mean something that has mass, but in the sense that it is a foreign or unwanted body in some tissue, which is differnt from olive:Mass.
mass unit
A unit representing the amount of matter in a particle or object. The SI unit of mass is the kilogram.
meaningful use stage
There are three meaningful use stages, and each one should eventually be a subclass of this class. They are certifications that a EHR service meets various requirements for accessibility, privacy, and efficiency.
Medicaid ID
Medicaid number
This is the subclass of olive:ID for all Medicaid Identifiers.
A subclass of olive:Event, this is the class of all events in which a patient (see olive:Patient) receives some form of medical care. The care is usually administered by a olive:MedicalProfessional. Examples include doctor/dentist/chiropractor/etc. visits, surgeries, consultations with medical professionals regarding medical issues, and medical testing for a particular person. The key is that there be at least one subject of the care event. For a counterexample, medical research on, say, some vaccine would not count as a medical care event, even if the output of the research was used for future medical care events. This class is intended to be very broad. When possible, use or create a more specific class that will have more details about the type of care event. Surgery will require a surgeon, for example. Or, virtual patient visits will take place over the phone or video chat as opposed to in a medical facility (from the patient's perspective, at least).
:MyDoctorVisit a olive:MedicalCareEvent; olive:occursAt :MyLocalHospital.
medical care event cohort
olive:MedicalCareEventCohort is the class of all cohorts that are subclasses of olive:MedicalCareEvent.
medical care organization
olive:MedicalCareOrganization is the class of all organizations that essentially provide medical care.
olive:MedicalCareProvider is the subclass of olive:Agent wherein each individual is involved in directly providing healthcare. Notable examples include hospitals, walk-in clinics, nurses (olive:Nurse), doctors (olive:Doctor). Health insurance companies (see olive:InsuranceCompany) and healthcare R&D companies are not instances of olive:MedicalCareProvider; though they are involved in the healthcare industry, they are not directly providing medical care to patients. (Exception: if an R&D company provides treatment to patients in the form of medical trials, then it would be a medical care provider. The point is that doing medical research alone is insufficient for membership in this class.) One of the main uses for this class is to identify agents who are eligible to be paid for medical services by a payer.
All health care providers (physicians, suppliers, hospitals, and others) may get an NPI.
An NPI is a unique identification number for covered health care providers, created to improve the efficiency and effectiveness of electronic transmission of health information.
While npi is the preferred method, you can also identify providers by their SSN.
medical encounter
olive:MedicalEncounter is a class best understood in juxtaposition to another, olive:EpisodeOfCare. Whereas an episode is a complete narrative for a given condition/illness/procedure, encounters are one-off events that combine to form episodes. An encounter is a temporally contiguous event, whereas episodes are events that can (and almost always) have 'gaps' of time in them.
elective medical encounter
olive:MedicalEncounter-Elective is the class of all medical encounters where the patient elects to be admitted for some procedure.
inpatient medical encounter
olive:MedicalEncounter-Inpatient is the class of all medical encounters where the patient needs to be admitted to the hospital for an extended period of time, usually at least over night.This class is contrasted with outpatient encounters.
outpatient medical encounter
olive:MedicalEncounter-Outpatient is the class of all medical encounters where the patient does not need to be admitted to the hospital for an extended period of time. Some outpatient encounters may require admission for a short period (say, for a few hours), but will not require an overnight hospital stay. Other outpatient encounters will not require admission at all. This class is contrasted with inpatient encounters.
fellowship
olive:MedicalFellowship is the class of all medical fellowships, which follow a residency (see olive:MedicalResidency) and result in certifying a physician in a particular specialty.
medical implant
implant
This class will likely be deprecated in favor of integrating with a medical device ontology.
olive:MedicalProfessional is a subclass of olive:Person that works in the healthcare or medical field. Notable subclasses include olive:Doctor and olive:Nurse. There is some ambiguity in whether one becomes a medical professional only i) when they are currently employed in the medical care field, ii) for life after they are employed (e.g. retired doctors are still doctors), or iii) as long as they are qualified to serve in a professional capacity in mediine. This list isn't mutually exclusive or exhaustive, but hopefully it is clear that there is some flexibility in how this term can be used. For most usecases, I do not expect this potential ambiguity will cause problems, and as such the ontological framework to resolve the ambiguity is unlikely to be worth the trouble. But if this assumption proves incorrect, we should be willing to revise and refine this term.
MRN
olive:MedicalRecordNumber is the class of all IDs that are medical record numbers. They are assigned by healthcare providers or hospital systems, and they therefore are not universal. They should be used for all care for a given patient in that system, and therefore should be consistent across appointments, etc.
residency
olive:MedicalResidency is the class of all education and employment events in which 'a qualified physician (one who holds the degree of MD, DO, DPM, MBBS, MBChB) who practices medicine, usually in a hospital or clinic, under the direct or indirect supervision of a senior medical clinician registered in that specialty such as an attending physician or consultant.' (Wikipedia)
Medicare ID
Medicare number
This is the subclass of olive:ID for all Medicare Identifiers.
Medicare OSCAR ID
Medicare OSCAR number
Medicare OSCAR provider number
This is the subclass of olive:MedicareIdentifier for all Medicare OSCAR (online survey certification and reporting system) provider IDs.
Medicare NSC ID
Medicare NSC number
This is the subclass of olive:MedicareIdentifier for all Medicare NSC (National Supplier Clearinghouse) IDs.
Medicare PIN
Medicare provider identification number (PIN)
This is the subclass of olive:MedicareIdentifier for all Medicare provider IDs.
Medicare UPIN
Medicare unique physician identification number (UPIN)
This is the subclass of olive:MedicareIdentifier for all Medicare unique physician identification numbers.
mental health condition
olive:MentalHealthCondition is the class of all health conditions and mental states; they typically negatively impact the lives of those who occupy those states.
mental state
olive:MentalState is the class of all static situations in which some actor (usually an agent) occupies a particular mental state.
message
A specific instance of content sent from one agent to another. This class doesn't assume the medium: message can be verbal, written, recorded, etc. Create subclasses if there are specific types of messages worth discussing (e.g. X12 835 messages). Note: you can send a message to yourself, though this is atypical. So, the olive:toAgent need not be different from the olive:fromAgent.
metagraph
olive:MetaGraph is the class of all knowledge graphs that give meta information about one or more other graphs. As such, you can query metagraphs to determine which graphs might contain information you want, and you can use metagraphs to get more information about the provenance of the data contained in those other graphs. Typical informaion contained in metagraphs include the topic of the graph, the number or types of classes/properties/subjects in the graph, the source from which the graph is drawn, and date and versioning information.
metal level
olive:MetalLevel is the class of all tags for 'metal levels', which are applied to insurance plans. Lower medals (e.g. Bronze) correspond to lower deductibles, but also to higher costs when you receive care.
molar quantity
Amount of a substance, as counted molecules.
mole unit
Amount of chemical material. Measured in Avogadro units (moles) of 6.02 x 10^23 molecules.
monetary amount
This is an amount of money. Such magnitudes should specify the amount (via olive:decimalValue) and the unit of currency (e.g olive:_USDollar) via olive:hasUoM.
month instant
moving something
Moving something is the class of all events in which an object (which may or may not be an agent) is moving. This would include delivering flowers, throwing a frisbee, driving a car, and walking. Many events involve moving objects. However, this class will be most useful when there is a focal moving object. So, while an entire basketball game might be an instance of olive:MovingSomething, but that would feature many players, referees, and the ball moving. Much better to focus on an individual event of a particular pass or shot where the ball is the focal moving object.
NPI
National Provider Identifier (NPI)
NPI number
This is the subclass of olive:ID for National Provider Identifiers.
replacement National Provider Identifier
This is the subclass of olive:NationalProviderIdentifiers all instances of which are NPIs for providers if the provider has been assigned a replacement NPI. In other words, if EXAMPLE is a member of this class, then EXAMPLE was assigned to its associated provider as a replacement NPI.
National Provider Identifier - Sole Proprietor
This is the subclass of olive:NationalProviderIdentifier that contains all NPIs that are used for sole proprietors. A sole proprietor in this sense is an individual medical care provider that provides care via an unincorprated business. Practically speaking, this prevents the medical care provider from applying for two distinct NPIs (one for oneself qua provider and one for oneself qua care organization/business). Thus, instances of this class are ambiguous with regard to whether they identify the individual provider or the unincorporated organization of which they are the sole proprietor (since no such distinct is made for these individuals insofar as NPI data is concerned).
network
A network is a connected set of links and nodes
network link
edge
A link in a network. This is the abstraction of the network. The physical instantiation couple be pipes, or wire but may also be non physical such as wireless networks or organization structures
network node
node
A node in a network. Note the network is the abstract representation of the network. It is physically instantiated with equipment, or in some cases People.
NUCC provider taxonomy code
This is the subclass of olive:ID for NUCC provider taxonomy codes.
olive:NaturalLanguage is the class of all languages that evolve 'naturally', usually juxtaposed with formal languages such as logics and programming languages.
olive:NonphysicalArtifact is a subclass of olive:Artifact, where the artifacts are essentially nonphysical. Paradigm instances include ideas, conceptual works (like stories or poems), rules for games, content (see olive:Content), and so on. Nonphysical artifacts are contrasted with physical artifacts. See the comment on olive:PhysicalArtifact for more discussion.
This is the class of all (wholly) non-physical things, and it serves as the complement of olive:PhysicalThing. Non-physical things are things that have no spatial extent (although they may - and often do - have a temporal extent), are not situations (see olive:Situation), are not time intervals, and possess "independent" existence (i.e. they are not "attribute-like", as contrasted with instances of olive:Attribute). Paradigmatic examples are conceptual works (including fictional characters as considered in contexts in which they are indeed fictional), virtual objects (such as an email address) insofar as they are virtual (i.e. considered apart from any underlying physical structure that supports their existence), and other abstract objects like variables and functions. As a rule of thumb, something belongs in this category if (1) it isn't state- or event-like (note, though, that fictional events do belong in this class since these are properly characterized as conceptual works and not events), (2) it isn't attribute-like (i.e. it cannot be attributed to something else in the manner that instances of olive:Attribute are), (3) is not a time interval, (4) it is not localizable in space. Note that based on this characterization, things like holes are actually instances of olive:PhysicalThing (even though they are not instances of olive:MaterialThing) since they are localizable in space.
olive:Nurse is the subclass of olive:MedicalProfessionals who are nurses.
obligation
Instances of olive:Obligation are normatively binding commitments for an agent that constitute specific demands on that agent's actions or relationships. A contract (see olive:Contract), for example, may contain/specify one or more obligations that are binding for multiple agents. A given obligation (considered as a content) may be conceived of as being a part of a larger content from which it issues (as in when a contract contains certain specific obligations), or it may be conceived as an abstraction from (see olive:abstractsTo) a specific agreement (e.g. as when my agreement to pay you $20 abstracts to the obligation that I pay you $20 - both are legitimately conceived of as normatively binding, but the obligation, considered in itself, is an abstraction from the content of the agreement). Agents can also have obligations that do not issue from any kind of agreement - for example, there are certain conceptions of moral obligations according to which those obligations do not issue from any antecedent agreement.
OHM
Olive human message
OHM stands for "Olive Human Message". An OHM is when Olive sends a message to a human and the human responds. Most commonly the medium for communication between Olive and a human is email. However, it could also include chat tools or other asynchronous messaging systems. The OHM is the center point for ensuring a Turing-like relationship with Olive and a customer. The OHM Manager, in Omega, oversees the creation, transmission, and performance of all OHMs.
Olive employee
olive:OliveEmployee is the class of all people who are employed by Olive.
oncologist
This is the class of all doctors who specialize in oncology. Not to be confused with an ontologist!
medical oncologist
This is the subclass of olive:Oncologist where they specialize in chemotherapy or other drug treatments for cancer.
ratiation oncologist
This is the subclass of olive:Oncologist where they specialize in radiation therapy to treat cancer.
surgical oncologist
This is the subclass of olive:Oncologist where they specialize in surgical treatments for cancer.
ontologist
ontological engineer
ontology engineer
olive:Ontologist is the class of all ontologists (aka ontological engineers). One is writing this comment right now. It is a noble profession, attracting the best and brightest who can't manage to get a real job.
ontology term type
olive:OntologyTermType is the class of all tags for an ontology term or resource. For example, a term might be created but not really fleshed out; we can categorize said term as a olive:StubTerm. However, since we're going to be relating any resource to a term type, we cannot use an object property. Instead of olive:categorizedBy, use olive:quotedCategorizedBy. See that property for more discussion for the 'quoted' aspect.
ordered collection
A collection where the members are in a fixed sequence.
list
An Ordered Collection where no item can be of the same rank as any other item. This is just a list, and is a subclass of rdf:List. It should be familiar to LISP users.
organization
Paradigm organizations include companies (e.g. Olive AI), countries (e.g. Germany), and clubs (e.g. the NRA). Organizations are distinct from individual persons (see olive:Person), though there can be single-person organizations, such as when an individual person starts a company and is the only employee. olive:Organization is closely related to, but different from, olive:Group. As noted in the comment on olive:Collection, collections are determined by their members. An organization, on the other hand, is not determined strictly by its members. To see this, suppose that Olive AI over time replaced every employee. It's reasonable to say that the organization would be the same, though the group of people that were employees was different. olive:Organization is a subclass of olive:Agent, which means that an organization is capable of action and engaging in contracts. There are some heavy and contentious metaphsyical claims in this vicinity (e.g. whether corporations are people or are subject to moral evaluation), but this ontology tries to remain neutral whenever possible.
function output
Outputs are the arguments that are outputs for a function (see olive:Function). By definition, every output in the range of a function should be mapped to exactly one input (see olive:Input).
This is the class of partnerships, which are relationships between agents engaged together in the same activity, often with equal (or approximately equal) status, though this need not be the case.
olive:Patient is the subclass of olive:Person in which each instance is the patient in a medical care event (see olive:patientInEvent). This representation is a little heavy-handed without temporal qualification. Virtually every preson will be the patient in some medical care event, and therefore they will be classified as patients. However, one might argue that one is only a patient during a given medical care event, or at least in reference to that event. For that reason, it may turn out that the property olive:patientInEvent is far more important than this class for meaningful representation."^^xsd:string ; olive:exampleTriple ":Bob a olive:Patient; olive:patientInEvent :DoctorApptOnJune13th.
patient cohort
olive:PatientCohort is the class of all cohorts that are subclasses of olive:Patient.
patient disposition category
olive:PatientDispositionCategory is the class of all dispositions that might conclude a olive:MedicalCareEncounter. It includes olive:Disposition-ToHomeCare, olive:Disposition-Deceased, and olive:Disposition-LongTermCare. While this class looks to be about the patient, and it is, note that these categories should be applied to patient encounters, not patients themselves.
encounter utilization review and case management
This is the third subevent of the revenue cycle. It starts after the patient leaves, and consists of both reviewing the treatment and planning for monitoring the patient's continued care.
Patient scheduling is the first subevent of the revenue cycle. It is the class of all events in which a patient has their pending medical events scheduled. It starts with the first contact with the patient and includes setting their appointment, checking their insurance eligibility, and reminding the patient of the upcoming appointment.
patient status
This is the class of tags for patients and their statuses. It can include patient triage scores, dispositions and so on.
paying for something
Every instance of olive:PayingForSomething is an event in which some agent pays some other agent for some good or service. Such events should probably specify the method (olive:paidWith) and amount (olive:paidAmount), the thing being paid for (olive:payingForThing), the payer (olive:paidBy), the payee (olive:paidTo), and link to any records of the transaction.
payment posting, appeals, and collections
This is the seventh and final subevent of the revenue cycle. The medical care provider receives the verdict from the insurance company with respect to the claim. If the claim is paid in full, the account may be closed. If the claim is partially paid or rejected, the provider will have some time to appeal to the insurance company. After this is resolved, whatever balance remains will be charged to the patient.
pediatrician
olive:Pediatrician is the class of all pediatricians.
Periodicals are (pieces of) content that are put out in some regular time intervals by an organization. This class is reserved for the most generic conception of a given periodical - e.g. The New York Times (considered as the overarching "content" that is common to all periodical releases). Thus, we can consistently say the following things: (:TheNewspaperInMyHand olive:instantiates :TheNewYorkTimes-13Dec2021) (:TheNewspaperInMyHand olive:instantiates :TheNewYorkTimes) (:TheNewYorkTimes-13Dec2021 olive:abstractsTo :TheNewYorkTimes) In other words, any concrete manifestation of a periodical may be represented as instantiating (1) a particular release/issue of that periodical and (2) the periodical itself. Likewise, any particular release/issue of a periodical (considered as content) may be represented as abstracting to the generic periodical, considered as content.
person
The class of all persons. Usually, one should think of this class as synonymous with 'human', but the intended meaning is the class of all non-group moral agents. In this sense, some may argue that some nonhuman animals, or even machines, may end up being persons. Or, conversely, some humans may cease to be moral agents (and therefore cease to be persons) in cases where they suffer irreversible debilitating brain damage or other conditions.
type of physical activity
olive:PhysicalActivityType is the class of classes of events all instances of which are such that human activity that is importantly physical. Paradigm examples include jogging (i.e. the class of jogging events), swimming, dancing, and so on. In short, this is the class for all of the events that correlate to action verbs that agents can perform. The 'importantly' in the definition is a little squishy, but I think it's the best we can do. It might be that playing chess or thinking are also essentially physical: if we had no physical bodies, we couldn't do them. Yet, they seem to lack the physicality that we intuitively want to define this class. Playing chess over the board with another player would be an instance of this class, but not playing chess generally. A good litmus test: if you can perform an activity virtually and still truly say you did that activity, then it is not physical. So, when I run through the virtual world of Skyrim, I cannot say that I have been doing any olive:Running. Whereas when I play a game of chess online, I can truly say that I was doing an instance of olive:PlayingChess.
This is the sublcass of olive:Place, olive:Address, and olive:PhysicalArtifact: they are physical places that can be referred to by some routing algorithm.
olive:PhysicalArtifact is a subclass of olive:Artifact, where the artifacts are essentially physical. Paradigm instances include hammers, fishing poles, cars, bridges, and buildings. Physical artifacts are contrasted with non-physical artifacts. The abstract content of Moby Dick is non-physical, whereas the physical instantiations of that content are necessarily physical. So, there's a difference between Moby Dick the story on one hand, and paperback copies of Moby Dick on the other. That is, (:MobyDick-TheStory a olive:NonphysicalArtifact), whereas (:MyCopyOfMobyDick a olive:PhysicalArtifact). One might think that physical and non-physical covers the whole space. And in a sense, this is right: every artifact must either be physical or non-physical. (This assumes there are no hybrid physical/non-physical artifacts.) However, there are a few classes that might straddle the distinction, in that instances of these classes might sometimes be physical and sometimes be non-physical. olive:System, for example, will include both physical and non-physical systems. Templates are also like this. A template might be physical, like a mold for a metal car part, but there are also abstract templates, like the structure for a sonata.
physical examination
physical exam
physical
This is the subclass of olive:MedicalCareEvent in which a patient receives a physical. This might be for general wellness or for being cleared for some activity, such as high school sports.
physical object
physical item
This is the class of all physical things that are objects (more on the technical meaning below). It includes everything from everyday 'moderate-sized specimens of dry goods' like pants and plates and bags of flour, to large things like bridges and planets and universes, to tiny things like grains of sand and molecules and lysosomes. If it is physical and countable, it is a physical identifiable item. What does it mean to say something is an object? It is contrasted with something's being stuff. Roughly, if you have an object of some type, the parts of that object will not themselves be of that type. A dog is an object, because the dog's leg is not itself a dog. Contrast this with substances like water: any portion of a sample of water is itself a sample of water. Another way to get at the distinction is to note which terms are count nouns rather than mass nouns. These tests are not foolproof. Things get a little weird on the molecular level, since a single Hydrogen atom is in some sense a part of a sample of water, but that atom is not a sample of water. And there are words that can be both used as mass and as count nouns (e.g. you can pick up two rocks or go mine for some rock). Still, this intuitive macro-distinction allows us to separate things like animals and tools from the substances that are used to make these things: matter, water, steel, and so on.
substance
This is the class of all physical things that are substances, as opposed to objects. Whereas objects are countable, substances are typically mass nouns that are not countable. Paradigm examples include water, gold, lemonade, and cotton. Note that individual instances of a physical substance will be some particular sample of that substance, rather than the type itself. That is, the water in my class of water would be an instane of olive:PhysicalSubstance--water itself would be a subclass (of which the water in my class would be an instance) but not an instance itself. For more discussion on the distinction between objects and substances, see the comment on olive:PhysicalObject.
olive:PhysicalThing is the most general category for physical objects (see olive:PhysicalObject) and substances (or 'stuff', see olive:PhysicalSubstance). Note that instances of this class must be at least partially - but need not be wholly - physical: that is, if a thing has at least one physical part (whether or not it has non-physical parts), it belongs in this class. Paradigm examples include ferrets, hammers, planets, and samples of water or nitrogen. Physical things are spatially located and take up space. As a basic test of whether something belongs in this class, one can ask the following question: Does the thing in question take up space and/or is it located in space? If so, it belongs in this class. If not (or if there's an open question about whether the answer is "yes"), then it doesn't belong in this class. Nonexamples include situations (see olive:Situation and its subclasses), ideas, and virtual things (see olive:VirtualThing). The latter might be tempting; Word documents and Google Sheets and such are usually engaged with via sense perception, and they are physically realized in physical circuits and electrical currents. While there are certainly physical things required to bring a virtual document into existence, the document itself is nonphysical. This class is primarily used for describing various properties that all physical things will have: spatial locations, mass, etc. However, in practice new individuals should almost always be placed 'lower' in more specific classes in the ontology.
physician group
A physician group is when three or more physicians formally organize as a legal entity in which business, clinical, and administrative facilities are shared.
place
olive:Place is the class of all individuals that are locations (physical and non-physical) that can be the answer to a 'where' question. Places include countries, buildings, and regions of space, as well as websites and email addresses. Conceptually, this is an easy class to get a grasp on. But we do have to be careful with the loose way that people talk. Oftentimes we use the same word for both a place and something else. For example, 'I went to the hospital. I paid the hospital for my recent procedure.' In those two sentences, 'the hospital' refers to different things. In the first, it refers to the place, probably best understood as the hospital building. In the second, it refers to the organization that uses the building. We certainly don't want to pay the building! Another looseness comes in talking of addresses. When we say that we visit some address (say 221B Baker Street), we mean that we visited the location that is denoted by the string-version of the address. This confusion rarely causes problems in conversation, but can really cause havoc in an ontology if it goes unnoticed.
The is the second subevent of the revenue cycle. It starts with patient check-in to the provider and concludes when the patient leaves after service is rendered.
post-graduate education
olive:PostGraduateEducation is the class of all education events that typically require and follow an undergraduate degree, such as a Bachelor's degree.
prescribing a drug
This is the subclass of olive:MedicalCareEvent in which the patient is prescribed some drug or drugs in a medical context.
prescription
Prescription is the class of all requests such that the requested thing is medication. This includes both inpatient and outpatient requests, despite inpatient requests more frequently called 'medication requests' than 'prescriptions'.
procedure
algorithm
process
method
Instances of olive:Procedure are algorithms or methods for solving some type of problem. This could be a cosin algorithm for calculating CPA similarity, or a method for bench pressing heavy weight.
product
olive:Product is the class of all artifacts that are intended to be sold.
product category
Any of many ways of categorizing products, including models, NATO product codes, and the like.
product unit type
unit type
This is a class of those classes each of which is a type of (mere) collection of products. For example, the six surgical masks in the my pack-of-6 surgical masks form a collection; the class of all collections of that sort would be an instance of this class. This class is designed to most useful in representing type-level information about product units (e.g. that surgical mask X is sold in cases of 12 - see also olive:ProductUnitType).
product magnitude
A magnitude expressed as a product of primitives. (E.g., Force = M*A).
product unit
A unit of measure that is the product of two or more simple units. The simpler units need not be distinct: square meters is a product unit. Other examples include foot pounds (for torque), or Newtons.
This is a class of those classes each of which is a type of product unit. For example, a certain kind of surgical mask may be sold in packs of twelve; thus, ex:TwelvePack might be an instance of olive:ProductUnitType (and, more generally, ex:Pack might be an instance, as might be the more specific class ex:PackOfSurgicalMaskX). Instances of this class should be conceived of as classes of "product units plus their packaging" - thus, a twelve pack of surgical masks has the collection constituted by the masks themselves (and, by transitivity, each of the masks itself) as a part, but it also may have (and typically does) have other parts (e.g. the packaging used to unify the individual pieces of the product unit). There are some important distinctions to be careful to make here. In the case of the pack of 12 instances of ex:SurgicalMaskX, the 12 surgical masks themselves are members of (see olive:memberOf) an instance of olive:Collection (and that instance of olive:Collection stands in olive:collectionOfType to ex:SurgicalMaskX, and it has an olive:memberCount of "12"^^xsd:integer). This collection, then, is a part (see olive:hasPart and its inverse) of an instance of ex:Pack (or one of its subclasses - e.g. ex:PackOfSurgicalMaskX); ex:Pack is an instance of olive:ProductUnitType (as are its subclasses, if such there be).
product status
This is the class of 'tags' for product statuses. For example, olive:Status-Inactive and olive:Status-Build are two statuses that can be applied to instances of olive:Product.
professional
employed person
olive:Professional is the class of all persons who do some job professionally.
This is the class of all propositions. When modeling a given content, such as a belief or goal, it is sometimes useful to explicitly represent that content as being expressable (see olive:abstractsTo) as a proposition (or colleciton of propositions). In such a case, you can use one or more instances of this class along with the following properties: olive:propositionSubject, olive:propositionProperty, olive:propositionObject. At base, then, each instance of this class is the reified content of a triple. For example, (:Proposition1 olive:propositionSubject :Desdemona) + (:Proposition1 olive:propositionProperty olive:loves) + (:Proposition1 olive:propositionObject :Casio) means that Proposition1 expressed in triple form is (:Desdemona olive:loves :Casio).
generic qualitative amount
Instances of this category allow us to qualitatively tag some amount with common language such as low/medium/high. See instances of this category for more discussion. By its very nature, qualitative assessments are going to be context-sensitive and difficult to establish protocols for. But they are nonetheless both ubiquitous and useful, so we will try our best to be systematic and true to the source material in our data.
qualitative assessment
Instances here qualitatively apply to something, as opposed to olive:Magnitude instances, which are quantitative measurements. Examples would include task priorities: low, medium, high, critical, blocker, etc.
query
olive:Query is the class of all queries, which are a more specific kind of request. Namely, they are requests for information.
SPARQL query
olive:Query-SPARQL is the class of all queries that are formatted to query RDF according to the W3C standard.
RARC
remittance advice remark code
These codes provide additional explanation for an adjustment already described by a Claim Adjustment Reason Code (CARC) or convey information about remittance processing. Each instance should be named olive:RARC-##. So the RARC code 15 is olive:RARC-15.
ratio magnitude
EXAMPLE: Speed. The ratio magnitude is 60, the unit of measure might be MilesPerHour.
NOTE: A RatioMagnitude just has one decimal value.
This is a number whose unit of measure is a ratio.
ratio unit
A UnitOfMeasure composed of a numerator unit and a denominator unit.
NOTE: If needed, a conversion factor for a RatioUnit can be (recursively) derived from the conversion factors of the numerator and denominator units. E.g., the derived conversion factor from km/minute to meters/second is 1000/60 or 16 2/3.
reactivation
olive:Reactivation is the class of all events in which some primary object (see olive:changedThing) is reactivated. Note: just like every other event, one should specify when it happened using olive:timeOfEvent or its subproperties.
reasoning level
olive:ReasoningLevel is the class of all reasoning types or levels. These can be thought of as isomorphic to inference engines.
recommendation
A recommendation is content that is designed to encourage/discourage some agent to take some action or acquire some thing. For example, Netflix might recommend that I watch Season 3 of Cobra Kai. Recommendations have several important elements: the recommender (olive:recommender), the recommendee (olive:recommendedTo), the thing recommended (olive:recommendedThing), and the level of recommendation (olive:recommendationDegree, olive:quantitativeStrength). To revist the above example, Netflix (recommender) recommends that I (recommendee) watch Cobra Kai (thing recommended) with some strength, say four stars (level of recomendation). Note that we could reasonably disagree about whether the thing recommended is Cobra Kai Season 3 or the *watching* of Cobra Kai Season 3. I expect this difference does not matter in most cases, but one should probably adopt a parallel structure if they are dealing with several recommendations. It would be strange, for example, to compare Netflix's recommendation that I watch New Girl Season 2 with their recommendation of Cobra Kai Season 3. Subclasses of olive:Recommendation can be made based on the classes that the above properties might be relating. For example, olive:Recommendation-CPA is the subclass of recommendations that are recommendations of instances of olive:CPA.
record (data)
The class of all records in some data source. Examples include a single row in a table in a relational database and the content of a physical file. This is a very broad class, intended to allow for suitable precisifications as needed.
This is a subclass of olive:Event in which someone 'receives' a drug (see olive:Drug). This includes taking medicine orally, being vaccinated via injection, or any other means of having a drug administered. Since it need not be administered by a medical professional, this is not a subclass of olive:MedicalCareEvent. Also, one does not receive a drug if it is merely given into their possession (see olive:DrugDispensation). Receipt here entails that that the drug has been administered.
region
olive:Region is the class of all geographical regions. They need not be contiguous, or on the planet Earth, though they typically are both of these. Paradigm examples: the land area of the United States, the lot my house is on, Crater Lake and its immediate surroundings. Note: the region is not identical to the geopolitical entity. The USA is distinct from the geographical region that partly constitutes the country. Also note that this is distinct from olive:Area. Every region has an area, however.
relationship
olive:Relationship is the class of all reified relationships that hold between agents (see olive:Agent). Marriages, friendships, and accounts are paradigm examples. Non-examples include relations between agents and non-agents, such as ownership being located in some location (those will naturally find correlates in subclasses of olive:Event). Also, instances of olive:Contract are NOT instances of olive:Relationship. If you have a contract with someone, then you stand in a special relationship to them, but the contract is distinct from that relationship; instead, you might say that the contract grounds the special relationship. We should specify the temporal extent of the relationship (using olive:timeOf and subproperties) as well as the agents involved (using olive:hasParty and subproperties). Each subclass should also likely be paired with a property that directly relates the parties of the relationship. So, if Bill and Susan are married, and we reify their marriage as :Marriage01, then we also probably want to be able to say something like (:Bill ex:isMarriedTo :Susan) to directly connect Bill and Susan. If such a property is created, make sure to note this in the comments for the property and corresponding class.
These are the relationships that are governed by some--that is, at least one--contract (see olive:Contract).
These are the relationships that are not governed by any contract. All other relationships are instances of olive:Relationship-Contractual.
requesting communication
Requesting communication is the class of all requests such that the requested thing is communication. For example, one might request a conversation with a sales associate, or summon you to the principal's office.
requesting equipment
Requesting equipment is the class of all requests such that the requested thing is equipment. For example, one might request an MRI machine, or a new baseball bat, or the surgeon may ask for a scalpel.
requesting a medical procedure
Requesting a medical care event is the class of all requests such that the requested thing is a medical procedure. For example, one might request physical therapy, or an appendectomy, or counseling. See olive:MedicalCareEvent.
requesting something
ordering something
Requesting something is the class of all communication events in which a request is made.
request
demand
order
Requests are content in which something is requested. We usually want to specify the thing requested and the requesting agent. It is also nice to specify who the request is made to. Compare this to the events in which an item is requested, olive:RequestingSomething.
requirement
Each instance of olive:Requirement is content that specifies conditions that must be satisfied (whether these are conditional/hypothetical or absolute). For example, the specification of a physical or functional need that a particular design, product, or process must be able to perform in order to satisfy some agreement constitutes a requirement. Likewise, the content of my belief that humans need water to live is a requirement (in this case, non-normative). The specification of an obligation for a person or organization to behave in a certain way also constitutes a requirement.
responding to something
olive:RespondingToSomething is the class of all communication events that are responses. Responses might be complicated, but they might also have simple contents like accepting or rejecting an offer. When possible, specify what the response is a response to.
The revenue cycle is the event that spans a patient's entire experience with the healthcare system. It starts with scheduling an appointment and ends with paying for the costs incured along the way.
room
Each instance of olive:Row-Data is the collection of cells (see olive:Cell-Data) for a given row or record. Each row should a referent (see olive:hasReferent).
school
olive:School is the class of all organizations that aim primarily provide a place for learning and teaching. This class includes traditional K-12 education and Universities as well as other types of schools, such as drivers education schools an d trade schools.
Sections are parts of content, considered abstractly. For examples: the introduction to one's speech, the conclusion of a paper, the bridge to a song, or the chase scene in an exciting movie. Since being a part of some broader content is essential to this class, every instance should be asserted to be part of some 'complete' content, which must be an instance of olive:Content. Again, note that this is for abstract content, not for any physical/virtual manifestation of the abstract content. If you have a particular page of some book, that page itself will be an instance of olive:Snippet. And, in turn, that olive:Snippet will instantiate (see olive:instantiate) the olive:Section that appears on the page.
segmentation strategy
Instances are tags for marketing strategies that segment the market along some specified difference. Examples would include regional or demographic segmentation.
type of sensitive information
olive:SensitiveInformationType is the class of all tags that indicate some information is sensitive. Notably, this includes PHI and Olive IP. These tags can be created to better regulate access to named graphs or other sources of information.
sensor
A device that can detect something and report it. Light sensors, temperature sensors,
service code
olive:ServiceCodeCategory is the class of all service codes (see olive:serviceCode and olive:hasServiceCode). A service code is like an identifier (see olive:ID), but instead of identifying an individual it identifies a class of medically related things. So, the ICD10 Diagnostic Service Code denoted by K00.0 is for Anodontia. Each instance is a code, and is used as a tag for individual persons/events/etc. that are tagged of that sort. The importance of the tagging depends on the kind of code, but it is often used for diagnosis or billing. Whenever possible, uses a subclass of service code category that picks out the particular convention being used (e.g. ICD9 or ICD10 or HCPCS).
sex and gender classification
olive:SexAndGenderCategory is the class of all (biological/assigned) sex and gender categories. This includes, but need not be limited to, sex assigned at birth, identified gender, and gender expression.
sex category
olive:Sex-Category is the class of all sexes that can be assigned at birth. Make sure to distinguish this from gender (see olive:Gender-Category). This category is notionally about some biological feature, such as number of X and Y chromosomes, of the individual. It's worth noting that in practice, medical assignments of sex may not actually be entirely based in physiological facts.
simple unit
Each simple unit has a base unit and a conversion factor to the base. The bases are from the System International (SI). The conversion factor is the number which one multiplies a Unit by to get to base, or divides by to get from base. E.g., the convertToBase for inch is 0.0254 to get to the base unit (meter).
situation
olive:Situation is the common generalization of two more intuitive classes: olive:Event and olive:State-Situation. Roughly speaking, a situation is either (1) something that happens in the world (an instance of olive:Event), or (2) some state of the world (an instance of olive:State-Situation). All instances of olive:Situation have a temporal extent (even if it's just an instant) and involve at least one role player (i.e. something that might be said to be "involved" in the situation in some way). Given that this class is intended as a common generalization of olive:Event and olive:State-Situation, one should almost always use one of those two subclasses when ontologizing an individual.
Snippets are parts of larger content bearing things. For examples: a page from a book, the portion of a physical CD that contains the first track of a song, the part of the Mona Lisa that contains her smile. Since being part of some broader content bearing thing is essential to this class, every instance should be asserted to be part of some 'complete' content bearing thing, which must be an instance of olive:ContentBearingThing. Again, note that this is for concrete content bearing things, not for the abstract content communicated by such things. If you have a particular page of some book, that page itself will be an instance of olive:Snippet. And, in turn, that olive:Snippet will instantiate (see olive:instantiate) the olive:Section that appears on the page.
This is the class of all software programs designed for end users. Notable subclasses include IDEs, Word Processing software, Notionally, this class does not include operating systems, though this is not enforced. If that distinction becomes important, an ontologist should update the ontology and this comment accordingly.
software engineer
olive:SoftwareEngineer is the class of all software engineers.
This is the class of all instances that are ways in which someone can interact with a olive:SoftwareApplication. Examples include olive:API, olive:GUI, etc.
sport
olive:Sport is the class of all games that are essentially physical. See the discussion on olive:SportsEvent; while this class is controversial at the margins, this ontology adopts a pretty inclusive conception of sports. Horseshoes and competitive cheerleading and e-sports are sports, even if they may be less obviously instances than basketball and rugby.
olive:SportsEvent is the class of all competitive physical activities that are typically performed for entertainment or leisure, though we include professional playing of such activities in this class as well (e.g. NBA games). This class is notoriously tricky to pin down. While just about everyone agrees on paradigm sports like boxing, basketball, baseball, and rugby, there is disagreement about activities that are less (directly) physical or less obviously competitive. Some take issue with e-sports on the grounds that the activity is not sufficiently physical. Others take issue with cheerleading or dance on the grounds that the physicality isn't directed at one's competitors. There is no doubt a social component here: in societies where ice dancing is popular and ice dancers are celebrities, I would expect ice dancing to be uncontroversially a sport. Note that like olive:GameEvent, olive:SportsEvent is the class of events in which some sport is played. For the sport itself, see olive:Sport.
SSN
Social Security Number (SSN)
social
social security number
This is the subclass of olive:ID for social security numbers.
SSV ID
olive:SSVID is the class of all identifiers for entities that occur in the SSV data.
state
static situation
state of affairs
olive:State-Situation is the class of all states of the world. Instances of this collection are temporally-extended (if even for an instant only) states that are constituted by one or more relations holding between one or more objects. The hallmark of such states is that if the focal relationship(s) change/fail to hold, the state ceases to exist. Examples of this class include: Barack Obama's being President, my having arthritis, and my being alive. Note that this class is disjoint with olive:Event and that there can be subtle differences between instances of this class and instances of that one. For example, we can distinguish between Barack Obama's being President (olive:State-Situation) and the presidency of Barack Obama (olive:Event). The former obtains simply as long as Barack Obama holds the office of President and involves no specific acts that Obama performed while being President. The latter, on the other hand, is an event that temporally overlaps (and is, in fact, temporally coextensive with) and is causally related to the former, subsumes all the various acts that Obama performed as President, but is not essentially constituted by the relationship that constitutes Obama's being president (even if, again, there is a causal relationship between the two). Likewise, we can distinguish the state (or condition) of my having arthritis from all the events that temporally overlap that state including the diagnosis of my arthritis, the various treatments of my arthritis, and various arthritic flare-ups that I might experience. Note also that instances of this collection need be "static" in the sense that they cannot involve, e.g., change or motion: my being alive is constituted by the proper functioning of certain biological systems, which certainly involves change and/or motion: the crucial point, though, is that the change and/or motion involved grounds the obtaining of the unchanging state of my being alive. There is a clear sense in which choices regarding how a particular thing is modeled will determine whether it is an instance of olive:Event or olive:State-Situation. For example, a top's spinning on my desk could be an instance of olive:State-Situation if the underlying model is of an object being in a (in some sense "unchanging") state of motion, or it could be an instance of olive:Event if the underlying model is of the top undergoing various movements (or one could choose to model things both ways, depending on one's interests). There is no real hard-and-fast rule with regard to which modeling idiom is preferable in any given case: whether one opts to model something as an instance of olive:State-Situation or olive:Event will largely depend on pragmatic considerations (although there are certainly exceptions to this). As a general rule, an instance of olive:State-Situation should not be conceived of as being divisible into multiple instances: there is no meaningful sense in which there are many different states of "Obama's being President". That state can obtain or fail to obtain, and it can do so at various times, but there is no sense in which any given occurrence of "Obama's being President" is different from any other. Now, we might want to distinguish between different occasions on which Obama is President: in such a case, we would need to model these different occasions as events, but there is also presumably a common state that temporally overlaps them - i.e. the state of Obama's being President. One can also see how these sorts of considerations might be applied to the top example from just above: there is the "top's being in some kind of motion" (state) and the various specific movements of the top (events) that overlap the former. When modeling the temporal extent of an instance of olive:State-Situation, one should use olive:stateObtainsDuring to relate the state to one or more time intervals.
The geographical territory for one of the fifty members of the United States. As with the other geographical regions, this is not identical to the state government or populace. That government governs this region, and the populace resides in the region.
This is the class of 'tags' for statuses. For example, olive:Status-Inactive can describe a project that that is inactive. Or we can describe that status of an account using an instance of olive:AccountStatus.
stored query
olive:StoredQuery is the class of all SPARQL queries that have been saved for future use.
This is the class of all subclasses of olive:Dataset all instances of which are encoded/expressed in a structure. Paradigmatic examples include data expressed by a CSV file and data stored in a database. Paradigmatic non-examples include data expressed in a free-text PDF.
student
olive:Student is the class of all students. One is only a student when they are attending classes of some sort. These classes may be academic (e.g. university classes) or non-academic (e.g. student at Cobra Kai dojo).
surgery
This is the subclass of olive:MedicalCareEvent in which a surgery is performed.
system
olive:System is the class of all things that have interconnected parts that 'work together' in performing some function. This includes both physical and non-physical systems. Physical systems include things like engines, HVAC systems, and humans. Nonphysical systems include abstract structures like languages and grammars, and strategic systems for games like chess (e.g. the Queen's Gambit). Upon reflection, you may realize that just about everything is a system. My coffee mug seems simple, but it's really a drink-holding system: the handle for ease of holding, the bottom is attached to the sides in a way that each component seals liquid off in a different direction. The rim is smooth so it doesn't cut my lips when I drink. The comic art on the side designed to get a chuckle from coworkers and make the drinking more pleasurable. In light of how ubiquitous systems are, you might think this class is worthless: if everything is special, then nothing is. In some sense, this is right. It's pointless to tag everything that is a system as a system. But it IS useful to note that something is a system when you are considering it as a system. Systems are what they are precisely because they have some function(s), and their having parts that are property situated and functional is essential to accomplishing what they are intended to accomplish. Note that many systems have parts which are themselves systems: my car is a system that has an electrical system, a drivetrain, a radio, and so on. The vast majority of things that will be represented in the ontology as systems will be physical systems. Even things that 'feel' abstract like an offensive scheme in football are physically realized by players executing the scheme. Moreover, we are usually concerned with how we can repair/replace/modify a part of the system in such a way as to preserve or improve performance. For example, when a bearing in some circular saw seizes up, how does that affect performance? And how can we fix it? If we are question-driven in this way, we should be sure to include information about what a system's parts are (see olive:hasPart and sub-properties), and what the system is intended to accomplish (see olive:Intention and subclasses).
Every relational database has at least one instance of olive:Table-Data as a part. Tables should be further specified by the number of columns, rows, as well as the logical meaning of those rows and columns.
task
olive:Task is the class of all tasks or jobs to be done. They can best be thought of as imperatives, or collections of imperatives. Finishing mapping the fhir ontology is a task for the ontologist currently writing this comment. That means that I can complete or fail to complete the task. To express this, one can use olive:categorizedBy and then an instance of olive:CommitmentCategory. Completed tasks may also be events, but not all tasks are events. For example, if I tell you to open the window, and you do so, then it is sensible to give start and end times to your satisfied task of opening the window. However, if I have a task to do the dishes and never do so, it seems wrong to say that there is some event that corresponds to my washing the dishes that failed to accomplish my task. If pressed we could describe the state of affairs in which I failed to do the dishes as being the task, but this seems a stretch (and probably not practical at any rate, even if it can be theoretically more satisfying).
taxonomy
olive:Taxonomy is the class of all tree-structure knowledge graphs that provide a hierarchical vocabulary for classifying things.
territory
The geographical territory for one of the unincorporated territories under the control of the United States government. As with the other geographical regions, this is not identical to the state government or populace. That government governs this region, and the populace resides in the region.
phone number
A numeric code a telephonic device uses for contacting another telephonic device.
EXAMPLES: Mobile, fax, or landline phone number.
Applicable when importing data from the RibbonHealth API. Uses the ribbonUuid of the olive:Locaton associated with the phone number in question. {number} distinguishes it from other numbers at the same location
temperature
The degree or intensity of heat present in a substance or object, especially as expressed according to a comparative scale.
temperature unit
Unit of measurement for expressing temperature. Per SI, the base of temperature is in Kelvin, to allow for all units to be expressed relative to a real (in this case absolute) zero.
template
EXAMPLE: A form. A filled-in form has the structure of the form with data entered into some or all of the fields.
Something used to make instances in its own image. In manufacturing this would be specialized as a die to make stamped parts, cookie cutters are templates for cookies, and forms are templates for data.
test
olive:Test is the class of all tests. There are a large variety of tests: medical tests (e.g. a blood test), academic tests (e.g. a math test), knowhow tests (e.g. a driver's test), and software tests (e.g. an integration test). See subclasses for the more specific version as needed. In general, a test is a request for information where the information conveys a capability. So, a blood test might tell us whether my body is capable of producing the right amount of insulin. A math test might tell you whether I have mastered the course material and can find the area under a given function. A driver's test might tell us whether I can safely join the driving population. An integration test might tell us whether my software program will reliably produce the desired results.
olive:Test-Software is the class of all tests designed to ensure the proper functioning of software.
This is the most general template involving a UUID.
tier
The collection of all tiers, which are components of "abstract" structures that help to enforce ordering of elements arranged in such a structure (or to which such a structure applies). Tiers may be thought of as parts of abstract ordering or ranking structures (see, e.g., olive:OrdinalCollection), which structures themselves may be thought of as applying to or being part of further abstract objects (e.g. the structure of a taxonomy). This class is designed to be especially useful for modeling cases in which the ordering of the elements of a structure is enforced by their association with tiers, rather than their association with tiers being dependent upon their ordering. In other words, it may be useful to make use of this class in cases in which one needs to represent information about tiers as ground-level facts rather than as being ultimately dependent upon other facts.
point in time
olive:TimeInstant is the class of all points in time. Despite the name 'instant', every point in time has some duration, and that duration is equal to the precision with which the time point is given. So, January 1, 1875 is an instance of olive:TimeInstant, and it has a duration of one day. On the other hand, 12:00:01 on 5-18-2829 is also a time instant, and it has a duration of one second. By convention, if no time zone is specified, we assume that the time is given in GMT. To relate a time instant to the date/time, use one of olive:universalDate, olive:universalTime, or olive:universalDateTime. To note the precision, use olive:hasPrecision.
time interval
time period
olive:TimeInterval is the class of all stretches of time. These might be used to describe when a contract is in effect, or the period of time in which some individual lived (e.g. King Arthur was alive during the Middle Ages). Each time period must have at least a start or an end time, though usually they will have both. Time periods with only one bound are probably things like 'The Modern Age', which is still ongoing and therefore may have no definitive end point. A subclass of time interval is olive:TimeInstant, which is a point (with some granularity) in time.
transaction
olive:Transaction is the subclass of olive:Exchange all instances of which involve agents as the "endpoints" of the exchange. In other words, transactions are exchanges that occur between agents (although the agents themselves need not be the things that are exchanged). An important subclass of olive:Transaction is olive:BuyingAndSelling.
transfer event
olive:TransferEvent is the class of all events in which the possession, ownership, or control of something is altered. Examples include, adoptions (custody is transferred), payment (money is transferred), buying something (the bought thing is transferred, as well as the payment), and passing a basketball (control is transferred). Notice that the control need not be, but is often, legal control. Note that this classification does not entail or exclude the object moving. Compare with olive:MovementEvent.
unit of measure
unit
The class of all units by which we measure things. Example units include kilogram, meter, pounds per square inch, and watts. olive:UnitOfMeasure instances are most frequently used in the object slot of triples using the olive:hasUoM. Note: when just counting something, the unit may be just the object type being counted. For instance, when I have 5 apples, the unit is apples. To denote this unit, use olive:_each.
university
olive:University is the class of all educational institutions that grant undergraduate degrees. Note that this combines what many in the US also call 'colleges'. While 'college' evokes a smaller, more intimate setting with fewer course offerings, in practice the terms are used synonymously so much that it would be counter-productive to separate them. Note that in other countries, 'college' may suggest other things, such as high school.
urgent care
olive:UrgentCareCenter is the class of all walk-in clinics that specialize in providing urgent care. They serve a similar purpose to emergency care facilities for patients with lower acuities.
URI template
olive:URITemplate is the class of all templates for minting URIs, in particular for the Olive ontology. See olive:uriTemplate and olive:uriTemplateUsesProperty. These templates are of two basic sorts. First, there are templates that are non-random, determined solely be a set of properties that are sufficient for picking out an individual. For example, the template for olive:MedicalCareProvider is like this, where you can identify a provider by their npi. Persons can also often be identified by their SSN, or by their name/dob, or by some other set of properties. Second, there are templates that include a UUID, a randomly generated string. These are not guaranteed to be unique, but they are incredibly unlikely to result in collisions and pose some advantages over blank nodes. In the end, we want our URIs to serve two main desiderata: 1) stably pick out distinct entities without collisions, and 2) still have names that gesture enough to the referent to be human readable.
use type
olive:UseType is the class of all tags that signify how a thing is intended to be used. This is a pretty generic tag, and is initially motivated as targets for some very general code-types in fhir. As a paradigm example, think about dishes. You can have dishes that are for everyday use, formal dining only, or perhaps just for display. As with many categories, if there is enough substance in the term you might be better off creating a non-Category class or using a more robust object property.
using something
making use of something
utilizing something
olive:UsingSomething is the class of all events in which something is used (related via olive:affectedObject-Direct) by something (related via olive:doneByAgent).
vaccination
This is the subclass of olive:ReceivingADrug and olive:MedicalCareEvent during which a patient is vaccinated. This usually is done via injection, but it need not be administered in that way.
variable
Variables are slots that can have values substituted in for them. Variables are often constituents of functions (see olive:Function).
Some Content is published as a series of instantiations with explicit version names. Such publications _abstractTo_ an instance of VersionedContent.
Something that typically uses a string or number to name content which abstracts to an instance of Versioned Content. Typically uses olive:identifyingText to specify the actual token used for identification, and said text typically lends itself to interpretation as an ordered sequence.
virtual location
virtual address
This is the subclass of olive:Address reserved for virtual addresses. Paradigm examples include websites and email accounts. As with physical addresses, note that these addresses are distinct from the strings that can be used to identify the address. Our way of speaking is often unhelpful here. We use 'address' to refer both to the string and the place designated by the string. Don't be fooled!
vector
olive:Vector is the class of all nonphysical things that are essentially composed of two parts: the direction, and the magnitude. This class includes all vectors, including physical forces and purely mathematical vectors (e.g. v = 2i - 3j).
virtual profile
online profile
profile
virtual account
olive:VirtualProfile is the class of all online accounts and profiles. They are virtual objects that are created and operated by persons. One's Facebook profile or LinkedIn account would be paradigm examples.
virtual currency
electronic payment
virtual money
olive:VirtualCurrency is the class of all virtual money. For example, if someone makes an online payment, they may be represented as purchasing something using an instance of this class with a particular monetary value (see also olive:boughtFor and olive:hasMonetaryValue).
virtual thing
This is the class of all things that are "located" on a computer system (and thus capable of being located on a computing network). This would include email, files, websites, and other such artifacts that (can) have a virtual address (see olive:VirtualAddress). Every virtual thing should be able to be located using a property such as olive:url (or another property specifying, e.g., a filepath). Note that every virtual thing will be associated with some physical thing(s), such as the servers or hard disks that store the information that supports a particular website.
visual medium
video
visual content
olive:VisualContentSource is the class of all content bearing things that are accessed (at least partly) visually. This includes photographs, charts, and videos.
volatile graph
olive:VolatileGraph is the class of all knowledge graphs whose contents can be modified by at least some users. Volatile graphs are unlikely to be versioned, since they can be updated directly. Contrast this class with graphs that are read only, which will be more stable but will also require new graph versions to be minted whenever they receive updates.
volumen
Three-dimensional space, or equivalent fluid measurement.
volume unit
Units of three-dimensional space, expressed here as an area times a distance.
vote
Every instance of vote is a tag by which we can qualitatively assess something. Most notable instances include olive:Upvote and olive:Downvote.
warning
olive:Warning is the class of all content that urges caution. Such content includes the images in instructino manuals that show users being dismembered for incorrectly using the equipment. It also includes spoken or written warnings; a police officer that lets a speeder off with a warning is communicating this content.
web service
service
A web service is a collection of olive:Functions, which are designed to facilitate communication between two electronic devices as they communicate over some network (such as the web). Strictly speaking a service that runs over a network but not the internet may be thought of as a service rather than a web service, but for our purposes 'web service' is a catch all term for any service.
week instant
white paper
whitepaper
olive:WhitePaper is the class of all white papers. They are typically of some length, and are of a business or marketing angle that expand on some philosophy towards products or services. They are usually used to generate sales leads, establish thought leadership, and make the company look good.
X12 message
olive:X12Message is the class of all olive:Messages that are in the EDI X12 format.
X12 835 message
olive:X12Message-835 is the class of all 835 X12 messages, which are messages about insurance claim payments.
X12 837 message
olive:X12Message-837 is the class of all 837 X12 messages, which are messages about insurance claims.
year instant
is about
(:_Thing_1 olive:about :_Thing_2) means that Thing1 is about, broadly construed, Thing2. For example, (:DatabaseRow6 olive:about :ElizabethFaye) would indicate that row 6 in our database was about Elizabeth. Aboutness is notoriously hard to pin down, but a good test is to imagine someone who was researching a thing. If it would be reasonable to recommend that they look at some particular piece of content to research a thing, then that content can be said to be about that thing. Typical uses of this property will be to state that some database or part thereof refers to some entity, or to state that a receipt or bill is about some particular event. This property is not functional. Content may be about many distinct things.
:DatabaseRow6 olive:about :ElizabethFaye
This is the class-level version of olive:about. Eventually we may adopt an alternative strategy of using paradigm instances as stand-ins for type-level claims. This property will at least be a stopgap until that vocabulary is in place.
This is the property-level version of olive:about. See olive:aboutClass. This indicates that some content communicates something that can be expressed with triples that use the property asserted. So, (:Content1 olive:aboutProperty olive:npi) would mean that content1 can be (partially) modelled using triples that have the olive:npi property. This may be useful in finding content such as knowledge graphs that contain a certain type of information.
is the abstract for
(:Abstract1 olive:abstractOf :Content1) means that Abstract1 is the abstract for Content1. For example, (:MyDissertationAbstract olive:abstractOf :MyDissertation). See olive:Abstract and olive:abstractText (the latter can be used if one wants to skip the reification of the abstract altogether).
:MyDissertationAbstract olive:abstractOf :MyDissertation
abstracts to
(:Thing1 olive:abstractsTo :NonphysicalThing1) means that NonphysicalThing1 is an abstraction from Thing1. A paradigmatic example of this relationship is that between objects that communicate content and the content that they communicate. For example, (:MyPhysicalCopyOfMobyDick olive:abstractsTo :MobyDick-Content) means that my physical copy of Moby Dick abstracts to Moby Dick (the conceptual work). Note that this is a very general property and is meant to include abstractions from abstractions. So, for example, (:OliveOntology-Version8December2021 olive:abstractsTo :OliveOntology) means that the 12/8/2021 version of the Olive ontology (itself a content) abstracts to the Olive ontology (a more generic content).
:MyPhysicalCopyOfMobyDick olive:abstractsTo :MobyDick-Content
has the following abstract:
(:Content1 olive:abstractText "TEXT"^^xsd:string) means that the abstract for Content1 is expressed by TEXT. For example, (:DissolvingHarmansDogmatismParadox olive:abstractText "Harman (1974) presents a paradox about knowledge that utilizes intuitive premises about misleading evidence. It looks like an agent is justified in disregarding misleading evidence with respect to propositions she knows to be true. But it also seems plausible that knowledge is fallible; knowing that p doesn’t require certainty that p. Harman points out that these two claims are in tension. I argue that this tension dissolves once we disambiguate notions of misleading evidence."^^xsd:string). Note that this property is useful when you want to skip reifying the abstract of the content itself; for cases in which you want to reify the abstract, see olive:abstractOf, olive:Abstract, and olive:transcript.
:DissolvingHarmansDogmatismParadox olive:abstractText "Harman (1974) presents a paradox about knowledge that utilizes intuitive premises about misleading evidence. It looks like an agent is justified in disregarding misleading evidence with respect to propositions she knows to be true. But it also seems plausible that knowledge is fallible; knowing that p doesn’t require certainty that p. Harman points out that these two claims are in tension. I argue that this tension dissolves once we disambiguate notions of misleading evidence."^^xsd:string
accepts
(:MedicalCareProvider1 olive:acceptsPlan :InsurancePlan1) means that MedicalCareProvider1 accepts InsurancePlan1. For example, (:DrBarry olive:acceptsPlan :CignaRedTopazPlan).
:DrBarry olive:acceptsPlan :CignaRedTopazPlan
services
(:Account_1 olive:accountCustomer :Agent1) means that Agent1 is the customer for Account1. For example, (:Acount234 olive:accountCustomer :GeneralMotors) would mean that Account234 was selling something or some service to GM.
:Acount234 olive:accountCustomer :GeneralMotors
has account number
Links an account or account-adjacent thing to the account number. Typically this account is a bank account, and the 'adjacent' thing might be a check or debit card.
:MyCheck olive:accountNumber "7722551"^^xsd:string
is managed by
(:Account_1 olive:accountSeller :Agent1) means that Agent1 is the seller for Account1. For example, (:Account234 olive:accountSeller :BankOfAmerica) could be used to denote that bank account Account234 was monitored by BoA.
:Account234 olive:accountSeller :BankOfAmerica
is located at
(:Address1 olive:address "ADDRESS"^^xsd:string) means that "ADDRESS" can be used to refer to the location Address1. For example, (:MyHouse olive:address "8825 29th St Ct E, Puyallup, WA 98371"^^xsd:string) shows you what you might write on an envelope to get a letter sent to my house. This property is not functional, as there are many strings that may point to a particular physical or virtual address. If there is a particular format, or a functional format, create or use a subproperty.
:MyHouse olive:address "8825 29th St Ct E, Puyallup, WA 98371"^^xsd:string
A specialization of olive:address for first-level administration areas, also called the "region" level; in the US, this is generally the state-level administration. E.g., (:Person1 olive:address-adminLevel2 "TX"^^xsd:string).
:Person1 olive:address-adminLevel2 "TX"^^xsd:string
A specialization of olive:address for second-level administration areas; in the US, this is generally the county-level administration. E.g., (:Person1 olive:address-adminLevel2 "Travis Country"^^xsd:string).
:Person1 olive:address-adminLevel2 "Travis County"^^xsd:string
A specialization of olive:address for third-level administration areas, also called the "locality" level; in the US, this is generally the city-level administration. E.g., (:Person1 olive:address-adminLevel2 "Austin"^^xsd:string).
:Person1 olive:address-adminLevel3 "Austin"^^xsd:string
A specialization of olive:address for this specific component. E.g., (:Person1 olive:address-line1 "Puyallup"^^xsd:string).
:Person1 olive:address-line1 "Puyallup"^^xsd:string
is located in
A specialization of olive:address for this specific component. E.g., (:Person1 olive:address-line1 "USA"^^xsd:string).
:Person1 olive:address-line1 "USA"^^xsd:string
A specialization of olive:address that is used to associated a resource with a full address string.
:Person1 olive:address-full "100 Washington Ave, Rochester, NY 00101, US"^^xsd:string
A specialization of olive:address for this specific component. E.g., (:Person1 olive:address-line1 "718 29th St Ct E"^^xsd:string).
:Person1 olive:address-line1 "718 29th St Ct E"^^xsd:string
A specialization of olive:address for this specific component. E.g., (:Person1 olive:address-line2 "Suite 100"^^xsd:string).
:Person1 olive:address-line2 "Suite 100"^^xsd:string
A specialization of olive:address for this specific component. E.g., (:Person1 olive:address-line1 "WA"^^xsd:string).
:Person1 olive:address-line1 "WA"^^xsd:string
A specialization of olive:address used to store the complete street address - i.e. including building and/or unit numbers. The concatenation of olive:address-line1 and olive:address-line2 (where available) should be equivalent to this property. E.g., (:Person1 olive:address-street "718 29th St Ct E Suite 100"^^xsd:string).
:Person1 olive:address-line1 "718 29th St Ct E Suite 100"^^xsd:string
has an adjusted cost of
costs
allowed amount
(:Thing1 olive:adjustedCost :Monetary1) means that Thing1 has an adjusted cost of Monetary1; this is the amount that actually will need to be paid for Thing1, taking into account discounts, etc. For example, (:MyDentalProcedure olive:grossCost [a olive:Monetary; olive:decimalValue "250"^^xsd:decimal ; olive:hasUoM olive:_USDollar]). The initial cost may have been much higher, but I only owe a $250 after the insurance company's adjustments. Specific to healthcare, the adjusted or allowed amount is the agreed amount that will be paid for a particular CPT (between a healthcare system and a payer). See olive:grossCost.
:MyDentalProcedure olive:grossCost [a olive:Monetary; olive:decimalValue "250"^^xsd:decimal ; olive:hasUoM olive:_USDollar]
is an admission with source
(:AdmissionEvent1 olive:admissionSource "NUM"^xsd:integer) means that AdmissionEvent1 was classified as NUM. These classifications are defined using the X12 standard (e.g. 1 is for Emergency admissions).
:CostasAdmission olive:admissionType "1"^xsd:integer
is an admission classified as
(:AdmissionEvent1 olive:admissionType "NUM"^xsd:integer) means that AdmissionEvent1 was classified as NUM. These classifications are defined using the X12 standard (e.g. 1 is for Emergency admissions).
began with a patient admission date of
(:Admission1 olive:admitDate :Instant1) means that that the admit date for Admission1 is Instant1. For example, (:MyHospitalStay olive:admitDate [a olive:TimeInstant; olive:universalDateTime "2004-12-09"^^xsd:string]).
:MyHospitalStay olive:admitDate [a olive:TimeInstant; olive:universalDateTime "2004-12-09"^^xsd:string])
is affected by
(:Thing1 olive:affects :Thing2) means that Thing1 affects Thing2. This is an incredibly general property. For example, (:MyHunger olive:affects :MyTestPerformance) would indicate that my hunger had some impact on my performance on the test. You almost always want to use a more specific property, such as olive:causes. Note that this is not a symmetric property. While things are often mutually affected, this is not always the case. Gravity affects me, but I don't affect it, for instance.
:MyHunger olive:affects :MyTestPerformance
(:Event1 olive:affectedObject :Thing1) means that Thing1 is an object affected by/in Event1. For example, (:NicksHunger olive:affectedObject :Nick) means that Nick is affected by Nick's hunger. Note that this property is not functional: more than one object can be affected in a given event. Unlike olive:affects, this property is intended to specifically relate an event to an object playing the "affected" role in that event.
(:Event1 olive:affectedObject-Direct :Thing1) means that Thing1 is an object directly affected by/in Event1. For example, (:NicksHunger olive:affectedObject-Direct :Nick) means that Nick is directly affected by Nick's hunger. Note that this property is not functional: there can be multiple objects that are directly affected in a given event.
:NicksHunger olive:affectedObject-Direct :Nick
(:Event1 olive:affectedObject-Indirect :Thing1) means that Thing1 is an object indirectly affected by/in Event1. For example, (:BreakingNicksWindow olive:affectedObject-Indirect :Nick) means that Nick is indirectly affected by the breaking of Nick's window (presumably Nick's window is directly affected). Note that this is not a functional property, as multiple objects may be directly affected by/in a given event. Note also that context will likely determine the scope of the "indirect effects" of a given event.
:BreakingNicksWindow olive:affectedObject-Indirect :Nick
(Person1 olive:affiliatedWith :Organization1) means that Person1 is affiliated with Organization1. This can be used to relate authors to organizations that funded the author during the production of some content. For example, (:CarolSwinburne olive:affiliatedWith :YaleUniversity) indicates that Yale provided financial support to Carol Swinburne, and as such would receive some credit for her publications during her time there. Other common uses (see subproperties) include employment, being a student of/at, and being partnered with. It is a symmetric relation. The author is affiliated with the organization and vice-versa. Note that not all the subproperties will be symmetric. An employee is affiliated with their empoloyer, and vice-versa. But the employee does not employ their employer.
:CarolSwinburne olive:affiliatedWith :YaleUniversity
has been alive for (in years):
(:LivingThing1 olive:age "DECIMAL"xsd:decimal) means that LivingThing1 has been alive for (in years): DECIMAL. For example, (: olive:age ""^^xsd:decimal).
(:Agent_1 olive:agentCreates :Artifact1) means that Agent1 is the creator of Artifact1. For example, (:AppleInc olive:agentCreates :MyMacbookPro).
:AppleInc olive:agentCreates :MyMacbookPro
does
This is the subproperty of olive:does where the doer is an agent. This does not require intentionality.
This is the specialization of olive:uses where the subject is an instance of olive:Agent. For example, (:NovakDjokovic olive:agentUses :HeadPT113B_1) can denote that Novak uses that particular racquet.
:NovakDjokovic olive:agentUses :HeadPT113B_1
allows
(:Commitment1 olive:allows :Situation1) means that Commitment1 normatively allows/permits Situation1 to occur as it is. For example, (:TheFifthAmendmentToTheUSConstitution olive:allows :MyRefusingToIncriminateMyself) means that the content of the fifth amendement to the US Constitution normatively permits a particular case in which I refuse to incriminate myself.
can be viewed on alpha suite at
(:Thing1 olive:alphaSuiteLink ) means that . For example, (:MemorialCare olive:alphasSuiteLink "http://www.alphasuite.secure.com/org"^^xsd:string). Often used for improving display in the Careminer search UI.
:MemorialCare olive:alphasSuiteLink "http://www.alphasuite.secure.com/org"^^xsd:string
has the following ANSI code:
has the following American National Standards Institute (ANSI) code:
(:Region1 olive:ansiCode "STRING"^^xsd:string) means that :Region1 has the ANSI (American National Standards Institute) code STRING.
olive:Texas olive:ansiCode "TX"^^xsd:string
has the following assertibility status:
(:Thing1 olive:assertibility :AssertibilityStatus) means that :Thing1 has the assertibility status of :AssertibilityStatus. For example, (olive:url-general olive:assertbility olive:NotAssertible) means that the property olive:url-general should not be used to make assertions. This is designed to be primarily used for declaring that a given property or class should not be used to make assertions (olive:NotAssertible).
olive:url-general olive:assertbility olive:NotAssertible
(:LivingThing1 olive:assignedSex :Sex-Category1) means that LivingThing1 is Sex-Category1. For example, (:BarackObama olive:assignedSex olive:Male-Sex). Note that this is different from their identified gender or gender expression (see olive:identifiesAs and olive:genderExpression).
:BarackObama olive:assignedSex olive:Male-Sex
is associated with the following text indicating sex:
(:LivingThing1 olive:assignedSexText "STRING"^^xsd:string) means that STRING is a code indicating the sex of LivingThing1. For example, (:ClintEastwood olive:assignedSexText "M"^^xsd:string) means that the string "M" can be interpreted as indicating the sex associated with Clint Eastwood. The appropriate interpretation of the string may enable the deduction of a new olive:assignedSex triple.
:ClintEastwood olive:assignedSexText "M"^^xsd:string
is associated in some way with a count of
(:Thing1 olive:associatedCount "N"^^xsd:integer) means that :Thing1 is somehow associated with a count of N items, e.g. via having N parts of a certain kind or via being related to N things in some way. For example, (:CaseysGradebook olive:associatedCount "10"^^xsd:integer) means that Casey's gradebook is in some way associated with a count of 10. This is a very general property, primarily useful as a super-property for all of the more specific (and more useful) count-relevant properties.
:CaseysGradebook olive:associatedCount "10"^^xsd:integer
attended
(:Person1 olive:attends :School1) means that Person1 attends/ed School1, whether or not they ultimately completed their education there. For example, (:Sarah olive:attends :Harvard) is true if Sarah is currently enrolled at Harvard, or if she is an alumnus. This property is timeless: once you stand in the attends relationship with a school, you do so forever. So, queries to determine whether someone is actively attending a given school may need to create/use a subproperty or search for additional facts about the related olive:Education event.
(:Agent1 olive:authorOf :Content1) means that Agent1 authored Content1. For example, (:JDSalinger olive:authorOf :CatcherInTheRye). Since it makes as much sense to say that Salinger wrote the abstract story as that he wrote any particular copy of (see olive:instantiationOf) the story, we can also say (:JDSalinger olive:authorOf :MyCopyOfCatcherInTheRye). Note that while 'author of' often indicates written content, the notion here is broader. A composer is an author of music, and an extemporaneous speaker is the author of their speech, even if said content is never written down.
:JDSalinger olive:authorOf :CatcherInTheRye
:JDSalinger olive:authorOf :MyCopyOfCatcherInTheRye
can be converted to the base unit by multiplying by
The conversion factor used to get to the base unit. E.g., multiplying by 0.0254 gets you from inches to meters. Divide by this number to go the other way. Used in conjunction with conversionOffset to convert from one unit to another. Degrees K = (Degrees F - conversionOffset) * convertToBase. Or K = (F-(-469.67)) * (5/9). To go the other way: F = (K * 9/5) -469.67. Try it on Google.
Note this kind of conversion will only work with temperatures if they are in Kelvin or Rankine (with a true 0). You multiply to get to the base, divide to go from the base. mph to mps is .44704. The multiple from kph to mps is .277778 . To convert 60 mph to kph is (60 * .44704 / .277778 or 96.56056 kph
is the basis for
(:Thing1 olive:basisFor :Thing2) means that Thing1 is the reason, or essential to the reason, for Thing2 happening/coming to be. For example, (:MyDoctorAppt olive:basisFor :InsuranceClaimLineItem) indicates that the line item on my insurance claim refers to, and is based on, my doctor visit.
:MyDoctorAppt olive:basisFor :InsuranceClaimLineItem
began with
(:Event1 olive:beginningSubevent :Event1) means that Event1 began with Event1. For example, (:SuperBowlXXIII olive:beginningSubevent :KickoffOfSuperBowlXXIII). This property is not functional. We can have events of various granularities. So, the kickoff started the football game, but so did the kickoff and return and opening drive. In those cases, when multiple events start some superevent, one of the starting events is a subevent of the other.
:SuperBowlXXIII olive:beginningSubevent :KickoffOfSuperBowlXXIII
can be cited as
(:Content1 olive:bibliographicInformation "STRING"xsd:string) means that Content1 can be cited as STRING. For example, (:UMLS olive:bibliographicInformation "Bodenreider O. The Unified Medical Language System (UMLS): integrating biomedical terminology. Nucleic Acids Res. 2004 Jan 1;32(Database issue):D267-70. doi: 10.1093/nar/gkh061. PubMed PMID: 14681409; PubMed Central PMCID: PMC308795."^^xsd:string).
:UMLS olive:bibliographicInformation "Bodenreider O. The Unified Medical Language System (UMLS): integrating biomedical terminology. Nucleic Acids Res. 2004 Jan 1;32(Database issue):D267-70. doi: 10.1093/nar/gkh061. PubMed PMID: 14681409; PubMed Central PMCID: PMC308795."^^xsd:string
(:Intention_or_Commitment1 olive:bindingForAgent :Agent1) means that Intention/Commitment1 is binding for Agent1. For example, (:KosherDiet olive:bindingForAgent :SarahFranzi) means that Sarah Franzi is obligated to follow the Kosher diet. This can be used to indicate which laws, norms, morals, etc. apply to given persons or organizations. It also indicates which goals apply to an agent. While agents are not required to satisfy their goals, one is 'on the hook' for failing to meet goals that are binding for themselves.
:KosherDiet olive:bindingForAgent :SarahFranzi
has a BMI of
(:Person1 olive:bodyMassIndex :RatioMagnitude1) means that Person1 has a BMI of RatioMagnitude1. For example, (:AlbertPujols olive:bodyMassIndex [olive:decimalValue "240"^^xsd:decimal ; olive:hasUoM olive:_kg_per_square_meter]).
:AlbertPujols olive:bodyMassIndex [olive:decimalValue "240"^^xsd:decimal ; olive:hasUoM olive:_kg_per_square_meter])
is an event in which the thing that is bought is bought for
(:BuyingAndSelling1 olive:boughtFor :Thing1) means that the thing that is bought in BuyingAndSelling1 (see olive:sold) is bought for Thing1. Thing1 will often be an instance of olive:Currency (or some other medium of exchange, since items that are bought are typically not acquired via barter), but it may be something else altogether - indeed, it could be an event (as when a person pays for their dinner by washing dishes). For example, (:BobsBuyingNewShoes olive:boughtFor [a olive:Currency ; olive:hasMonetaryValue [ olive:decimalValue "39.99"^^xsd:double ; olive:hasUoM olive:_USDollar]]) means that the focal thing purchased in the event of Bob buying new shoes was purchased for $39.99 in cash.
:BobsBuyingNewShoes olive:boughtFor [a olive:Currency ; olive:hasMonetaryValue [ olive:decimalValue "39.99"^^xsd:double ; olive:hasUoM olive:_USDollar]]
involves (as the buyer)
(:BuyingAndSelling1 olive:buyer :Agent1) means that Agent1 plays the buyer role in BuyingAndSelling1. For example, (:NickBuyingANewCar olive:buyer :Nick) means that Nick is the buyer in the event in which he buys a new car. Note that in cases in which the subject has no clear distinction between buyer and seller (as in a non-monetary trade), one can still make use of olive:buyer to represent one of the role players in the exchange.
is a business partner of
(:BillGates olive:businessPartners :PaulAllen) means that Agent1 and Agent2 are business partners. For example, (:BillGates olive:partners :PaulAllen) means that Bill Gates and Paul Allen are business partners.
BillGates: olive:businessPartners :PaulAllen
is, when current, the canonical graph for information about
(:KnowledgeGraph1 olive:canonicalGraphFor :Thing1) means that KnowledgeGraph1 is, when current, the canonical graph for information about Thing1. For example, (:UMLSGraph olive:canonicalGraphFor olive:UMLS). This is neither functional nor inversely functional. It is not functional because a given graph might be the canonical source for multiple things (may an HR graph is the canonical source for salary information for every employee, for instance). It is not inversely functional for temporal reasons. At any time, there can only be one most-recent canonical graph for a given topic. As such, a common query pattern is to find all canonical graphs for a given topic and query the most recent one. We retain older canonical graphs if someone needs to get information that applies to older points in time. CPT codes, for instance, might shift over time, and if one looks up a medical record from '94, they should use the canonical graph that is in force
:UMLSGraph olive:canonicalGraphFor olive:UMLS
(:KnowledgeGraph1 olive:canonicalGraphForProperty :Property1) means that KnowledgeGraph1 is, when current, the canonical graph for information about Property1. This is similar to folive:canonicalGraphFor. For example, (:RibbonHealthGraph olive:canonicalGraphForProperty olive:npi) would mean that npis are canonically provided in the Ribbon Health graph.
:RibbonHealthGraph olive:canonicalGraphForProperty olive:npi
(:KnowledgeGraph1 olive:canonicalGraphForType :Class1) means that KnowledgeGraph1 is, when current, the canonical graph for information about Class1. This is the type level equivalent to folive:canonicalGraphFor. For example, (:AlphaSuiteGraph olive:canonicalGraphForType olive:CPA) would mean that CPAs are canonically described in the Alpha Suite graph.
:AlphaSuiteGraph olive:canonicalGraphForType olive:CPA
is the carrier for
(:InsuranceCompany1 olive:carrierFor :InsurancePlan1) means that InsuranceCompany1 is the carrier for InsurancePlan1. For example, (:Cigna olive:carrierFor :CignaRedTopazPlan).
:Cigna olive:carrierFor :CignaRedTopazPlan
is categorized as
is tagged as
See the comment on olive:Category for deeper discussion. But in short, we use olive:Category as a way of instance-ifying a class so that we can get around the limitations in OWL/RDF of not having metaclasses. As such, we have a category, we still need an analogue of rdf:type to classify (and here, 'categorize') individuals that fall under that label. olive:categorizedBy is that analogous property. You can think of this property as a way of relating an individual to reified tags for that individual. In other words, it's a slighly more semantic way to approach labelling in many cases.
is the category version of the class
(:Category1 olive:categoryCorrespondsToClass :Class1) means that Category1, an instance of olive:Category, is a category-style representation of Class1, a class. This will be most often useful in stating equivalences between two different ontologies that rely on different modes of representation for the same concept. For example, (olive:Oncology-FieldCategory olive:categoryCorrespondsToClass wd:Q162555) means that olive:Oncology-FieldCategory is an instance of olive:Category that corresponds to the class Q162555 in the Wikidata ontology.
olive:Oncology-FieldCategory olive:categoryCorrespondsToClass wd:Q162555
causally contributes to
(:Thing1 olive:causes-general :Thing2) means that, in a very general sense, Thing1 causes Thing2. While the primary notion of causation is event-based (see olive:causes-events), we often speak of particular objects being causes, or being effects. For example, Bob's twisted ankle caused him to finish last in the race. We could express this as (:BobsAnkle olive:causes-general :BobsRaceFinish). This makes an object, Bob's ankle, the cause for an event, Bob's finishing the race in the way that he did. While we could redescribe this as a purely event-based relation ('The event of Bob twisting his ankle...'), this loose sense of causation that involves objects is intuitive enough to warrant having its own object property. Notable subproperties include olive:agentCreates.
:BobsAnkle olive:causes-general :BobsRaceFinish
(:Event1 olive:causes :Event2) means that Event1 causes Event2. While causation is a complex issue, the goal of this property is to capture the intuitive sense of 'cause'. For example, (:BillBreakingHisLeg olive:causes :BillsDoctorVisit) indicates that Bill went to the doctor because he broke his leg. Causation here means (at least) partial causation. Striking a match causes it to light. But this isn't the whole story, as we needed to strike the match in a sufficiently oxygen-rich environment, and the match needed to not be wet, and so on. Notice that the domain and range are events. The more general notion without these constraints is given by olive:causes-general. We often talk about objects being causes or caused by things, though. For example, 'The baby caused me to get no sleep last night'. We can translate this into event language: 'The baby crying all night caused me to get no sleep.' Similarly, we can talk about objects being effects, but this usually means that the creation of the object was the effect, as in 'The medical procedure caused the insurance claim'.
:BillBreakingHisLeg olive:causes :BillsDoctorVisit
has a cdr of
ends with
(:ListA olive:cdr :ListB) means that ListB is the list that contains all of ListA except for its first element. For example, if A = (1, 2, 3) and (:ListA olive:cdr :ListB), then B = (2, 3).
is a certification in
(:Certification olive:certificationInType :Field) means that Certification is a certification in the field of study Field. For example, (BobsMS olive:certificationInField Nursing) means that BobsMS is in the field of nursing.
:BobsMS olive:certificationInField Nursing
is a certification for
(:Certification1 olive:certificationForType :Class1) means that Certification1 certifies the possessor in some way with respect to Class1 - the object of the triple will help to determine the nature of the relationship. For example, (Certification1 olive:certificationForType olive:Dentist) means that Certification1 certifies its possessor with respect to being a dentist; (Certification1 olive:certificationForType olive:Fishing) means that Certification1 certifies its possessor with respect to the activity of fishing. And (Certification1 olive:certificationForType Nursing) means that Certification1 certifies in the field of nursing (note, though, that in this case there is a more specific property - olive:certificationInField - that would be more appropriate to use).
:Certification1 olive:certificationForType olive:Dentist
has a certification identified by the following:
(:Agent1 olive:certificationText "STRING"^^xsd:string) means that Agent1 has a certification commonly identified by STRING. For example, (:Nick olive:certificationText "Ph.D"^^xsd:string) means that Nick has a certification commonly identified by the string "Ph.D.". It is preferable whenever possible to use olive:hasCertification instead (or to leverage the information stored using olive:certificationText to generate an olive:hasCertification triple).
:Nick olive:certificationText "Ph.D"^^xsd:string
has certification(s) identified by the following:
(:Agent1 olive:certificationText-full "STRING"^^xsd:string) means that Agent1 has one or more certifications enumerated by STRING. For example, (:Nick olive:certificationText-full "RN,MA"^^xsd:string) means that Nick has certifications that may be identified by the string "RN,MA". It is preferable whenever possible to use olive:hasCertification instead (or to leverage the information stored using olive:certificationText-full to generate one or more olive:hasCertification triple).
:Nick olive:certificationText-full "RN,MA"^^xsd:string
changes the feature of the subject as follows:
(:ChangeEvent1 olive:changedProperty :List1) means that ChangeEvent1 changes the feature of the subject as follows: List1. The list will have three members: the property, the old value of the property, and the new value of the property. So, (:C olive:changedProperty (prop val1 val2)) means that it used to be true of the subject that (subject prop val1), but after change event :C, (subject prop val2) was true instead. For example, (:PaintingMyWall olive:changedProperty (:hasColor :Red :Blue)) would mean that the painting event changed the color from red to blue of the focal subject (see olive:changedThing), which is probably the wall in this case. This only captures cases where an attribute is changed from one value to another. In a case where an attribute is added, see olive:changeAdds. In a case where an attribute is removed, see olive:changeRemoves.
:PaintingMyWall olive:changedProperty (:hasColor :Red :Blue)
changed
(:ChangeEvent1 olive:changedThing :Thing1) means that ChangeEvent1 changed Thing1. For example, (:EditingMyDissertation olive:changedThing :MyDissertation).
:EditingMyDissertation olive:changedThing :MyDissertation
is check number
Relates a check to the check number (not the routing number--olive:routingNumber--or account number--olive:accountNumber).
:MyCheck olive:checkNumber "123451"^^xsd:string
(:Content1 olive:citedBy :Content2) means that Content1 is cited by Content2, or equivalently that Content2 cites Content1. For example, (:Wikipedia olive:citedBy :MyBookReport) means that my book report cites Wikipedia. Note that sometimes it feels natural to cite an agent rather than conent. For example, 'She cited the weatherman in her email, concluding that we should push the picnic back a day.' But in this case, we can interpret the citing a person as a loose way of speaking, shorthand for citing the person's testimony.
references
cites
(:Citation_1 olive:citedContent :Content_1) means that Citation1 is referencing the cited content, Content1. For example, (:Footnote3Citation olive:citedContent :NamingAndNecessity) means that footnote three's citation is referencing Naming and Necessity. See olive:citedBy for the property that relates to the two pieces of content directly.
:Footnote3Citation olive:citedContent :NamingAndNecessity
has claim number
Relates an instance of olive:InsuranceClaim to the claim number. Despite the name, the domain is a string. Note: this property is not asserted to be functional, though in practice we probably think of claim numbers as uniquely identifying. The unique identifier is probably a combination of insurance company and claim number, or perhaps claimant and claim number. Subproperties can be created as needed to get unique identification.
:MyClaim olive:claimNumber "1199324040235018"^^xsd:string
has original claim number
(:InsuranceClaim1 olive:claimNumber-Original "STRING"xsd:string) means that InsuranceClaim1 has original claim number STRING. For example, (:MyClaim olive:claimNumber-Original "7"^^xsd:string) means that my claim's original number was 7.
:MyClaim olive:claimNumber-Original "7"^^xsd:string
has the following number of classes:
(:KnowledgeGraph1 olive:classCount "INTEGER"xsd:integer) means that KnowledgeGraph1 has the following number of classes: INTEGER. For example, (:Graph21 olive:classCount "75"^^xsd:integer) means that Graph21 includes 75 classes.
:Graph21 olive:classCount "75"^^xsd:integer
has instances who are partly individuated by
(:Class1 olive:classIdentifyingProperty :Property1) means that instances of Class1 can be uniquely identified by the triples that involve that instance and all of the properties, such as :Property1, that stand in the olive:classIdentifyingProperty relation to Class1. In this sense we enforce a closed world assumption about olive:classIdentifyingProperty; at any time we assume that if any assertions have been made for some class using this property, the complete extent of those assertions have been made. So, if there are two class identifying properties for a class, then entity resolution should be possible for that class for any instance that have assertions using all of said properties. For example, suppose (olive:Person olive:classIdentifyingProperty olive:hasSSN) and (olive:Person olive:classIdentifyingProperty :DOB), but there are no other class identifying properties asserted for olive:Person. Then, if we know both Bob and Susan's SSNs and DOBs, we can conclude definitively whether those names refer to the same or different individuals; they are the same exactly when they have the same SSN and DOB. The extent of this property for a given class will likely go hand in hand with the structure for URIs that we use for instance data. See olive:uriTemplate.
olive:Person olive:classIdentifyingProperty olive:hasSSN
is part of
(:Class1 olive:classIsPartOf :Thing1) means that some sort of abstract partonomic relationship holds between Class1 and Thing1 (a non-class) such that Class1 may be said to be part of Thing1. An example would be a tier of classes in a taxonomy (see olive:Tier): those classes are in some sense part of a given tier, but the tiers themselves are (abstract) individuals.
olive:MedicalImplant olive:classIsPartOf Tier1InSomeMedicalSupplyTaxonomy
(:Collection1 olive:collectionOfType :Class1) means that every member of Collection1 is a member of Class1. For example, (:TrialJury32 olive:collectionOfType olive:Person) means that the jury in question is composed of people. Note that this is an annotation property, and so while useful for readers will be of limited use inferentially.
:TrialJury32 olive:collectionOfType olive:Person
conveyed
communicated
(:CommunicationEvent1 olive:communicatedContent :Content1) means that CommunicationEvent1 conveyed Content1. For example, (:OthelloPerformance223 olive:communicatedContent :Othello-Story).
:OthelloPerformance223 olive:communicatedContent :Othello-Story
compares
(:Comparison1 olive:comparedThing :Thing1) means that Thing1 is one of the things being compared in Comparison1. See olive:Comparison's comment for more detail.
has a relationship with/to
(:Thing1 olive:connectedTo :Thing2) means that Thing1 and Thing2 are connected. This is a painfully vague relationship. However, sometimes we just want to note that there's something important to say about the connection between two things despite not having any other vocabulary to say it. For that reason, any usage of this property should be seen as a cry out for precisification; either one should find the existing vocabulary that makes the right edge or someone should create new vocabulary to make the right edge. Technically you could view a property like olive:connectedTo as equivalent to owl:topObjectProperty, since whenver (:s :p :o) is true, (:s olive:connectedTo :o) would seem to be true. However, olive:connectedTo means that 'something holds between these two objects that we can't presently be more precise about', and therefore the above entailment doesn't hold. This has the added benefit of not generating tons of trivial triples, since without treating olive:connectedTo as a separate 'branch' of our property ontology, every triple would get a corresponding 'connected to' triple.
is consistent with
logically permits
logically allows
permits
is logically consistent with
(:CommitmentOrIntention1 olive:consistentWithSituation :Situation1) means that CommitmentOrIntention1 is logically consistent with Situation1. For example, (:MyDesireToLoseWeight olive:consistentWithSituation :MyEatingASalad) means that the content of my desire to lose weight is logically consistent with the occurrence of an event in which I eat a salad. Note that, in general, instances of olive:Intention are the proper candidates to serve as the subject of olive:consistentWithSituation, since the content of an intention, such as my desire to lose weight, is primarily descriptive in nature (it is my attitude toward this content that carries the modal/prescriptive content). In contrast, instances of olive:Commitment - i.e. the content of obligations, duties, laws, etc. - are essentially normative/prescriptive while also containing descriptive content (i.e. the content describes a state while also expressing that it ought to be the case). Thus, instances of olive:Commitment are better suited as the subjects of a subproperty of olive:consistentWithSituation that has normative force, even though they can also (as a result) be conceived of as being logically consistent with the relevant object.
(:Agent1 olive:contentContributor olive:Content1) means that Agent1 contributed to Content1. A more specific property should almost always be used, such as olive:authorOf or olive:publisherOf. For example, (:OxfordUniversityPress olive:contentContributor :Philosophy101Textbook) may be true in virtue of Oxford being the publisher for the textbook in question.
:OxfordUniversityPress olive:contentContributor :Philosophy101Textbook
This is the 'string version' of olive:hasCommunicationAddress. It relates an address or an agent to a string that represents some address that the person is reachable at. Consider using the more precise subproperties: olive:phoneNumber, olive:address, or olive:emailAddress.
has the contact person
(:Agent1 olive:contactPerson :Person1) means that Agent1 has the contact person Person1. For example, (:KevinDurant olive:contactPerson :RichKleiman).
:KevinDurant olive:contactPerson :RichKleiman
contains
(:PhysicalThing1 olive:contains :Thing2) means that Thing1 physically contains Thing2. For example, (:WashingMachine olive:contains :FluffyTheCat) tells us that Fluffy is in the washing machine. This is usually used for relating a container to contained thing or for locating something in a geographic region. For an example of the latter, (:France olive:contains :Casey) means that Casey is in France. Feel free to create or use more specific properties if we want to specify the domain or range more carefully. Also, since 'contains' is often as natural as 'was contained in', we use both this and its inverse propert, olive:containedIn.
:WashingMachine olive:contains :FluffyTheCat
(:Commitment1 olive:containsLineItem :LineItem1) means that Commitment1 . For example, (:InsuranceClaim2 olive:containsLineItem :VaccinationForJames) indicates that a line item in Insurance Claim 2 is James' vaccination.
:InsuranceClaim2 olive:containsLineItem :VaccinationForJames
(:Content1 olive:containsSensitiveInformationType :SensitiveInformationType1) means that Content1 contains SensitiveInformationType1. For example, (:NamedGraph21 olive:containsSensitiveInformationType olive:SensitiveInfo-PHI) means that Named Graph 21 has PHI in it.
:NamedGraph21 olive:containsSensitiveInformationType olive:SensitiveInfo-PHI
has a currency boolean of:
(:Content1 :contentIsCurrent "BOOLEAN"xsd:boolean) means that Content1 has a currency boolean of: BOOLEAN. For example, (:GradebookForPhil204 :contentIsCurrent "false"^^xsd:boolean) means that the gradebook is not up to date. If some content has a value of false, that means that at least some of the data is false in virtue of it being out of date. This is a sign of data being unreliable. Note that not every piece of content will ever go out of date. Often content is written in a way that is timeless, and therefore will be immune from becoming obsolete due to the passage of time.
:GradebookForPhil204 :contentIsCurrent "false"^^xsd:boolean
is for
is valued at
(:Contract_1 olive:contractValue :MonetaryValue_1) means that Contract1 is valued at MonetaryValue_1. For example, (:MedstarContract olive:contractValue [a olive:Monetary; olive:hasUoM olive:_USDollar; olive:decimalValue "150000"^^xsd:decimal]) means that the MedStar contract is for $150,000. Note that this reifies the value as a olive:Magnitude rather than going straight from the contract to a custom datatype for, say, US dollars. We could do a more direct property if needed. Such a direct property would be more specialized for that use, but specialization has drawbacks in requiring more specialized support and requiring users to learn more ontology terms.
:MedstarContract olive:contractValue [a olive:Monetary; olive:hasUoM olive:_USDollar; olive:decimalValue "150000"^^xsd:decimal]
controls
(:Agent1 olive:controls :Thing1) means that Agent1 has (partial) control over Thing1. This might be physical control, such as operating a machine or holding an object. Or it might be having authority over something, as when a government organization has jurisdiction over some region or person. For example, (:USFDA olive:controls :Pfizer) means that the US FDA has jurisdiction over Pfizer.
is a user of
(:Agent1 olive:controlsAccount :VirtualProfile1) means that Agent1 is a user of VirtualProfile1. For example, (:Casey olive:controlsAccount :XboxLiveTempestuousDuke) means that Casey oversees/owns/uses the Tempestuous Duke profile on Xbox Live.
:Casey olive:controlsAccount :XboxLiveTempestuousDuke
is offset from the base unit by
Add this number to get to the zero point. On the Celsius scale, the conversionOffset is -273.15 degrees C. On the Fahrenheit scale it is -459.67 degrees. Is equal to 0 when the unit has the same zero point as the base unit. e.g. inch, meter.
involves a conveyance of
(:Event1 olive:conveyedThing :Thing1) means that Event1 involves some sort of conveyance of Thing1. This is a very general notion, such that the particular sort of conveyance - transfer, movement, etc. - depends on the type of event. For example, (:MyRunThisMorning olive:conveyedThing :MyBody) means that my body is the thing that is physically moved during my morning run. Given the generality of this property, there may be different levels of granularity at which the conveyed item might be specified, depending on one's modeling purposes.
:MyRunThisMorning olive:conveyedThing :MyBody
conveys from
(:Event1 olive:conveysTo :Thing1) means that Event1 conveys from Thing1. For example, (:MyRunThisMorning olive:conveysFrom :BoylstonStreet). This means that my run begins at Boylston Street. Of course, we could be more precise here: the location of my body at the beginning of the event in question is Boylston Street. When possible, we want to use subproperties to express more nuanced relationships. This is a very general role property that tells us where something focal in the event begins. It could be a movement event, where a basketball is shot at a basket. It could be a request or other communication event where the message is transferred from some agent or location. It could be a transfer event in which the thing being bought begins in the possession of some agent. Be careful when representing transactions, since usually there will be at least two focal conveyances, as there are usually at least two things being exchanged; I might get the money while you get the expensive vase I sold you.
:MyRunThisMorning olive:conveysFrom :BoylstonStreet
conveys to
(:Event1 olive:conveysTo :Thing1) means that Event1 conveys to Thing1. For example, (:MyRunThisMorning olive:conveysTo :BoylstonStreet). This means that my run ends up at Boylston Street. Of course, we could be more precise here: my body ends up located on Boylston Street at the end of the event in question. When possible, we want to use subproperties to express more nuanced relationships. This is a very general role property that tells us where something focal in the event ends up. It could be a movement event, where a ball ends up at the basket. It could be a request or other communication event where the message is transferred to some agent or location (e.g. a message queue). It could be a transfer event in which the thing being bought ends up 'at' its new owner. Be careful when representing transactions, since usually there will be at least two focal conveyances, as there are usually at least two things being exchanged; I might get the money while you get the expensive vase I sold you.
:MyRunThisMorning olive:conveysTo :BoylstonStreet
has a copay of
(:InsuranceClaim1 olive:copayCost :Monetary1) means that InsuranceClaim1 has a copay of Monetary1. For example, (:MyApptClaim olive:copayCost [olive:decimalValue "15"^^xsd:decimal; olive:hasUoM olive:_USDollar]) means the copay associated with my claim is $15.
:MyApptClaim olive:copayCost [olive:decimalValue "15"^^xsd:decimal; olive:hasUoM olive:_USDollar]
is personally responsible for
(:Thing1 olive:cost-Patient :Monetary1) means that Thing1 is personally responsible for Monetary1. For example, (:MyInsClaim olive:cost-Patient [olive:decimalValue "70"^^xsd:decimal; olive:hasUoM olive:_USDollar]) means that I personally owe $70 for the event that my claim is based on, as opposed to the total amount owed, which includes the payer's obligation as well..
:MyInsClaim olive:cost-Patient [olive:decimalValue "70"^^xsd:decimal; olive:hasUoM olive:_USDollar]
is covered by
is bound to
(:Commitment_1 olive:coversAgent :Agent_1) means that Agent1 is 'covered' by Commitment1. For example, (:InsurancePolicy123 olive:coversAgent :Alice) means that Alice is covered by said insurance policy. She may either be the policyholder (see olive:hasInsurancePolicy) or is, say, a dependent of the policyholder. Note that this is not a subproperty of olive:hasParty, which would entail an active participation in the agreement. Dependents covered by their parents insurance stand in the 'covers agent' relation to the policy, but they are not parties of the agreement.
:InsurancePolicy123 olive:coversAgent :Alice
has the CPT code:
has the Current Procedural Terminology Code (CPT)
(:Event1 olive:cptCode "CODE"^^xsd:string) means that Event1 is classified by the Current Procedural Terminology (CPT) Code CODE. For example, (:BillsAppt olive:cptCode "47350"^^xsd:string) would mean that Bills appointment was for 'management of liver hemorrhage; simple suture of liver wound or injury.' Of course, to make these connections we also need the class of events affiliated with the CPT code strings.
:BillsAppt olive:cptCode "47350"^^xsd:string
creates
(:Thing1 olive:creates :Thing2) means that Thing1 creates Thing2. For example, (:Homer olive:creates :TheOdyssey). This is a general property; consider using more specific ones like olive:authorOf and olive:eventCreates when warranted.
assigns
Connection between an ID and the thing that minted the ID. It may be a person or organization, or could be an algorithm (next available or random number generator)
(:_Thing_1 olive:creationTime :_Time_1) means that Thing1 came to exist at Time1. Thing1 can be any thing that is not an event; for events, use olive:startOfEvent. For example, (:MyCellphone olive:creationTime [a olive:TimeInstant; olive:universalDate "2013-01-01"^^xsd:date]) shows that my cell phone was made in 2013. For specific types of creation, consider generating subproperties. Given the prevalence of birthdays in our data sets, it makes sense to have the subproperty olive:dateOfBirth. Similarly, you might want to create a subproperty for inventions, or for creating artistic works, and so on. Whenever you discuss a thing's coming to exist, you get into tricky metaphysical issues. One might think that persons exist eternally before or after life; perhaps they have souls or essences. While this is interesting and important, we need not get hung up on it here. Instead, we can note that, whatever one's eternal metaphysical views are, there is an important change in ontological status when a person is born or dies, or when a particular statue is formed or crumbles.
:MyCellphone olive:creationTime [a olive:TimeInstant; olive:universalDate "2013-01-01"^^xsd:date]
was current as of
(:Content1 olive:currentAsOf :TimeInstant1) means that Content1 was current as of TimeInstant1. For example, (:UMLSGraph2021AA olive:currentAsOf [olive:universalDate "2020-01-01"^^xsd:date]). This means that information from this source was up to date on Jan 1st, 2020. The information may still be current after that time, but the consumer of the content should be thoughtful about this. Note that this is distinct from olive:creationTime. A source is created on its creation time, but that doesn't mean that its information is up to date at the time of creation. Consider a reprinting of Darwin's Origin of Species. The printing might be created in 2021, but the information was current as of 1859 (or so).
:UMLSGraph2021AA olive:currentAsOf [olive:universalDate "2020-01-01"^^xsd:date]
has the following default data sensitivity level:
(:DataClassificationType1 olive:dataSensitivityDefaultLevel :DataSensitivityLevel1) means that DataClassificationType1 has, as an overridable default, the sensitivity level of DataSensitivityLevel1. This property is designed to be useful in declaring overridable defaults for types of data. In general, this property should be used to represent facts of the sort "If no specific sensitivity level is attributed to Dataset1, then, since Dataset1 is classified as DataClassificationType1, we should go ahead and assume that it has a sensitivity level of DataSensitivityLevel1".
stores data that can be semantically transformed using
(:DatatypeProperty1 olive:datatypePropertyUsesMappingProperty :MappingProperty1) means that DatatypeProperty1 stores data (in its object position) that can be semantically transformed into a resource using MappingProperty1. For example, (olive:npiEntityTypeCode olive:datatypePropertyUsesMappingProperty olive:mapsTo-NPIEntityTypeCode) means that the object values of olive:npiEntityTypeCode can be transformed into resources using olive:mapsTo-NPIEntityTypeCode.
olive:npiEntityTypeCode olive:datatypePropertyUsesMappingProperty olive:mapsTo-NPIEntityTypeCode
datatype property translates to property
stores data that can be semantically translated into a triple with the property
(:DatatypeProperty1 olive:datatypePropertyTranslatesToProperty :Property1) means that DatatypeProperty1 triples can be translated into Property1 triples given an appropriate decoding of the object of the DatatypeProperty1 triple (see olive:datatypePropertyUsesMappingProperty). For example, (olive:assignedSexText olive:datatypePropertyTranslatesToProperty olive:assignedSex) means that a triple of the form (SUBJ olive:assignedSexText CODE) can be translated into a triple of the form (SUBJ olive:assignedSex OBJ) given a suitable mapping between CODE and OBJ..
olive:assignedSexText olive:datatypePropertyTranslatesToProperty olive:assignedSex
is related to
(:Thing1 olive:date "DATE"xsd:date) means that Thing1 is related to DATE. For example, (:MyParty olive:date "2019-02-04"^^xsd:date) means that my party is associated with February 4th, 2019. Of course, this is a pretty general relation to a date; often we prefer more specific properties like olive:startDate. However, it is useful to have a more general property for querying purposes.
:MyParty olive:date "2019-02-04"^^xsd:date
was certified at/on
(:Thing1 olive:dateCertified :TimeInstant1) means that Thing1 was certified at/on TimeInstant1. For example, (:Record1 olive:dateCertified [olive:universalDate "2020-12-25"^^xsd:date]) expresses that Record1 was certified on 2020-12-25.
:Record1 olive:dateCertified [olive:universalDate "2020-12-25"^^xsd:date]
was born on
Date a living thing was "born" (or germinated, for plants).
was processed on
(:Commitment1 olive:dateProcessed :Timeinstant1) means that Commitment1 was processed on Timeinstant1. For example, (:MyRaiseRequest olive:dateProcessed [olive:date "2021-02-01"^^xsd:date]) means that my raise request was processed on February 2nd, 2021.
:MyRaiseRequest olive:dateProcessed [olive:date "2021-02-01"^^xsd:date]
was received at/on
(:Thing1 olive:dateReceived :TimeInstant1) means that Thing1 was received at/on TimeInstant1. For example, (:MyNewBike olive:dateReceived [olive:universalDate "2020-12-25"^^xsd:date]) expresses that I got my new bike last Christmas.
:MyNewBike olive:dateReceived [olive:universalDate "2020-12-25"^^xsd:date]
was received by Olive at/on
This is a subproperty of olive:dateReceived where the recipient (see olive:receives) of the thing in question is Olive. This might be used to show when Olive received the information about some insurance claim.
was submitted on
(:Commitment1 olive:dateSubmitted :TimeInstant1) means that Commitment1 was submitted on TimeInstant1. For example, (: olive:dateSubmitted :).
has the following deactivation date:
This links an individual with the date on which it was deactivated. For example (:DrRicesNPI olive:deactivationDate [olive:universalDate "02-13-2021"^^xsd:date]).
:DrRicesNPI olive:deactivationDate [olive:universalDate "02-13-2021"^^xsd:date]
has a decimal value of
[:_Magnitude_1 olive:decimalValue "NUM"^^xsd:double] means that the numeric value of magnitude1 is NUM. For example, [:ETHeight olive:decimalValue "300"^^xsd:string] means that the height of the Eiffel Tower is 300. Coupled with the assertion that [:ETHeight olive:hasUoM :_meter], we can conclude that the height of the Eiffel Tower is 300m. This property is functional. See the discussion on the comment for olive:hasUoM for detailed discussion.
:ETHeight olive:decimalValue "300"^^xsd:double
has the denominator unit of
Relates a RatioUnit such as meters/second to the denominator Unit (e.g. second).
depends on
is grounded by
is true in virtue of
is described by
(:Thing1 olive:description "DESC"^^xsd:string) means that Thing1 is described by DESC. For example, (:MyPonySnowball olive:description "Snowball is a Shetland pony with dark brown many and hindquarters, but is otherwise white."^^xsd:string).
:MyPonySnowball olive:description "Snowball is a Shetland pony with dark brown many and hindquarters, but is otherwise white."^^xsd:string
is described in depth by
This is the 'long' version of olive:description. Contrast it with olive:description-short. There is no hard and fast line where something is a short description versus a normal versus a long one. Instead, it may be useful to distinguish these levels for certain usecases. For example, CPT codes are associated with multiple descriptions, and it will be useful to separate the short from the long ones.
is briefly described by
This is the 'short' version of olive:description. Contrast it with olive:description-long. There is no hard and fast line where something is a short description versus a normal versus a long one. Instead, it may be useful to distinguish these levels for certain usecases. For example, CPT codes are associated with multiple descriptions, and it will be useful to separate the short from the long ones.
(:_Thing_1 olive:destructionTime :_Time_1) means that Thing1 ceased to exist at Time1. Thing1 can be any thing that is not an event; for events, use olive:endOfEvent. For example, (:MyCellphone olive:destructionTime [a olive:TimeInstant; olive:universalDate "2025-09-17"^^xsd:date]) shows that my cell phone will be destroyed on September 17, 2025. For specific types of destruction, consider generating subproperties. Given the prevalence of humans in our datasets, it makes sense to have the subproperty olive:timeOfDeath. Whenever you discuss a thing's coming to exist, you get into tricky metaphysical issues. One might think that persons exist eternally before or after life; perhaps they have souls or essences. While this is interesting and important, we need not get hung up on it here. Instead, we can note that, whatever one's eternal metaphysical views are, there is an important change in ontological status when a person is born or dies, or when a particular statue is formed or crumbles.
:MyCellphone olive:creationTime [a olive:TimeInstant; olive:universalDate "2025-09-17"^^xsd:date]
is directly a part of
(:Thing1 olive:directPartOf :Thing2) means that Thing1 is directly a part of Thing2. Parthood is transitive: if A is a part of B, and B is a part of C, then A is a part of C. But direct parthood is not transitive. While A may be a part of C, it is a part of C in virtue of B. This property is not functional, as a given individual may directly be parts of different things. However, this property should be 'functional qua parthood chain'. Suppose some piece of equipment, E, was part of two distinct machines, M1 and M2. Further, suppose that E is directly a part of M1a, which in turn is directly a part of M1. And E is directly a part of M2. This is fine, since E is only directly part of one whole in each of the two parthood chains in which it participates. E could not be a directly part of M1 in this scenario.
ended with a patient discharge date of
(:Admission1 olive:dischargeDate :Instant1) means that that the discharge date for Admission1 is Instant1. For example, (:MyHospitalStay olive:dischargeDate [a olive:TimeInstant; olive:universalDateTime "2004-12-09"^^xsd:date]).
:MyHospitalStay olive:dischargeDate [a olive:TimeInstant; olive:universalDateTime "2004-12-09"^^xsd:date])
is the distributor of
distributes
(:Agent1 olive:distributes :Thing1) means that Agent1 is the distributor of Thing1. For example, (:Pfizer olive:distributes :SampleOfXanax001). While we do talk about being a distributor of a specific item, we more frequently talk about being a distributor of types. For example, 'Bill is in shipping autoparts', rather than specifying that 'Bill distributed spark plug 001'. At the writing of this comment, I prefer to represent relations to types via selecting a 'paradigm individual' from a class and relating to that. But this remains unresolved. TODO: implement the type level relationship and update this comment accordingly.
:Pfizer olive:distributes :SampleOfXanax001
(:Thing1 olive:does :Event1) means that Thing1 is the 'doer', construed broadly, of Event1. For example, (:Casey olive:does :MakingMyCoffee) means that Casey is making my coffee. This is a subproperty of olive:eventInvolves, as it relates an event to some aspect of the event. You may want to use or create subproperties for more specific roles that a doer may play in an event, especially when there are multiple doers that one might want to distinguish from one another. This is obviously not functional; people and things can do multiple things. It's (perhaps less obviously) not inversely functinoal; the coffee pot may make my coffee as well as Casey.
is done by
(:Event1 olive:doneByAgent :Agent1) means that Event1 is done by Agent1. For example, (:BakingCookies olive:doneByAgent :DianeHart) means that Diane did the baking. Note that this is not a functional property, as a single event could have multiple doers.
:BakingCookies olive:doneByAgent :DianeHart
(:Event1 olive:doneForAgent :Agent1) means that Event1 was done for, or because of, Agent1. For example, (:DiversitySeminar olive:doneForAgent :MichaelScott) means that the diversity seminar is designed for Michael Scott. Often this can denote a beneficiary of some event, but it could also denote a maleficiary.
:DiversitySeminar olive:doneForAgent :MichaelScott
is done via the use of
involves the use of
(:Event1 olive:doneUsing :Thing1) means that the Thing1 is used by a doer of Event1 (see olive:doneByAgent) in doing Event1. To put it another way, olive:doneUsing relates an event to something used instrumentally in making that event occur. So, for example, (:BreakingMyCarWindow0001 olive:doneUsing :Baseball0001) means that Baseball0001 was used to break my car window.
:BreakingMyCarWindow0001 olive:doneUsing :Baseball0001
lasted
(:Event1 olive:duration :Duration1) means that Event1 lasted Duration1. For example, (:COVIDPandemic olive:duration [olive:decimalValue "18"^^xsd:decimal ; olive:hasUoM :_Month]) would indicate that the COVID pandemic lasted 18 months (fingers crossed!).
:COVIDPandemic olive:duration [olive:decimalValue "18"^^xsd:decimal ; olive:hasUoM :_Month]
(:Agent1 olive:editorOf :Content1) means that Agent1 edited Content1. For example, (:RobertGiroux olive:authorOf :CatcherInTheRye).
:RobertGiroux olive:authorOf :CatcherInTheRye
was at
(:Education1 olive:educationInstitution :School1) means that Education1 was at School1. For example, (:CaseysUndergradEducation olive:educationInstitution :PacificLutheranUniversity) indicates that Casey went to PLU for undergrad. Note that the direction assertion between student and school is olive:attends, whereas olive:educationInstitution goes through the intermediate node of the education event.
:CaseysUndergradEducation olive:educationInstitution :PacificLutheranUniversity
is effective from
takes effect on
(:Content1 olive:effectiveFrom :TimeInstant1) means that TimeInstant1 is the date (or time) at which Content1 goes into effect. Thus, TimeInstant1 can (and often does) differ from the date at which Content1 is created. For example, (:BobsEmploymentContractWithOlive olive:effectiveFrom [olive:universalDate "2021-01-01"^^xsd:date]) means that Bob's employment contract with Olive goes into effect on 1/1/2021.
:BobsEmploymentContractWithOlive olive:effectiveFrom [olive:universalDate "2021-01-01"^^xsd:date]
is effective until
remains in effect until
(:Content1 olive:effectiveUntil :TimeInstant1) means that TimeInstant1 is the date (or time) at which Content1 ceases to be effective. This relationship is distinct from the date at which Content1 is destroyed (although destruction may end up causing something to cease to be effective, that thing need not be destroyed in order to cease to be effective). For example, (:BobsEmploymentContractWithOlive olive:effectiveUntil [olive:universalDate "2021-01-01"^^xsd:date]) means that Bob's employment contract with Olive ends (i.e. is no longer effective or binding) on 1/1/2021.
:BobsEmploymentContractWithOlive olive:effectiveUntil [olive:universalDate "2021-01-01"^^xsd:date]
stores EHR using
(:MeriterHospital olive:ehrProvider :EpicSystems) means that Epic Systems stores the EHR data for Meriter Hospital. Notice that this relates the organizations, and not the organization to the software specific to Epic.
:MeriterHospital olive:ehrProvider :EpicSystems
has the following EIN:
has the following Employer Identification Number:
(:Agent olive:ein "ID"^^xsd:string) means that ID is the Employer Identification Number (EIN) for :Agent. For example, (:Olive olive:ein "212121212"^^xsd:string).
:Olive olive:ein "212121212"^^xsd:string
has a first element of
has a car of
(:List1 olive:element_1 :Item1) means that Item1 is the first item in List1.
(:List1 olive:element_2 :Item1) means that Item1 is the second item in List1.
(:List1 olive:element_3 :Item1) means that Item1 is the third item in List1.
(:Agent1 olive:emailAddress ""^^xsd:string) means that . For example, (:OliveSales olive:emailAddress "sales@oliveai.com"^^xsd:string) would mean that you could contact Olive's sales department by sending an email to sales@oliveai.com. Note that this is distinct from the olive:hasEmailAddress property.
:OliveSales olive:emailAddress "sales@oliveai.com"^^xsd:string
has the following number of employees:
(:Org1 olive:employeeCount "NUM"^^xsd:integer) means that Org1 has NUM employees. For example, (olive:Olive olive:employeeCount "457"^^xsd:string) means that Olive has 457 employees. Beware of temporal qualification here! Very few companies will have a set number of employees for very long.
olive:Olive olive:employeeCount "457"^^xsd:string
employed
(:Employment1 olive:employee :Agent1) means that Employment1 employed Agent1. For example, (:BillsEmploymentAtCigna olive:employee :Bill). Note that this property is functional. If two agents are hired simultaneously, there are still distinct hiring events, or otherwise we should reconceptualize the case as the employment of an agent that is composed by those two subagents.
:BillsEmploymentAtCigna olive:employee :Bill
was with
(:Employment1 olive:employer :Agent1) means that Employment1 was with Agent1. For example, (:BillsEmplomentAtCigna olive:employer :Cigna). This is not asserted to be a functional property. The reason is that I am still entertaining the possibility that there coudl be an employment event in which two employers jointly hire someone. Maybe such a case would be if my neighbor and I together pay for someone to take care of a tree that straddles our properties. Of course, we could model this as two different concurrent employments, but that strikes me as a less natural representation.
:BillsEmplomentAtCigna olive:employer :Cigna
(:_Organzation_1 olive:employs :_Person_1) means that Organization1 employs Person1. For example, (:MeriterHospital olive:employs :DrRice) means that Meriter Hospital has Dr. Rice as an employee. This is a subproperty of olive:hasPart; each employee is a part of the organization that employs them. Note that this only applies to organizations in the subject role, meaning that olive:employs cannot be used to capture, say, when an individual person hires a babysitter. If we want to handle this case, we will either need to modify this property (make it hold between an agent and a person, and no longer make it a subproperty of olive:hasPart), or create a new property that is specific to individuals.
ends on/at
(:TimeInterval1 olive:endDate "DATETIME"xsd:dateTime) means that TimeInterval1 ends on/at DATETIME. For example, (:MiddleAges olive:endDate "1517-01-01"^^xsd:date) shows that the Middle Ages ended in 1517.
:MiddleAges olive:endDate "1517-01-01"^^xsd:date
ended with
(:Event1 olive:endingSubevent :Event1) means that Event1 began with Event1. For example, (:SuperBowlXXIII olive:endingSubevent :FinalWhistle2391). This property is not functional. We can have events of various granularities. See the comment on olive:beginningSubevent.
:SuperBowlXXIII olive:endingSubevent :FinalWhistle2391
(:_Event_1 olive:endOfEvent :_Time_1) means that Event1 ends/ended at Time1. For example, (:_ThanksGivingDinner olive:startOfEvent [a olive:TimeInstant; olive:universalDateTime "2020-11-26T19:30:00"^^xsd:dateTime]) means that my Thanksgiving dinner ends at 7:30pm on November 26, 2020. Note that unlike olive:timeOfEvent, one cannot use the granularity to infer the duration of the event. Adding a olive:hasPrecision assertion is a way to indicate some +/- error bounds; to say an event ends at 9:30pm with a precision of one minute indicates the event will end anywhere between 19:29 and 19:30. Absent precision information, we assume that the time instant is maximally precise--to the second for datetimes and to the day for dates.
:_ThanksGivingDinner olive:startOfEvent [a olive:TimeInstant; olive:universalDateTime "2020-11-26T19:30:00"^^xsd:dateTime]
is an endpoint for
(:Endpoint1 olive:endpoint1 :SoftwareApplication1) means that Endpoint1 is an endpoint for SoftwareApplication1. For example, (:JenaEndpoint-Dev olive:endpointFor :OliveKG) might indicate that :JenaEndpoint-Dev is the (development) endpoint for Olive's knowledge graph.
:JenaEndpoint-Dev olive:endpointFor :OliveKG
has the following entity type code:
This links an individual with some corresponding entity type code. For example (:DrRice olive:entityTypeCode "1"^^xsd:string). In general, the data stored using this property and its subproperties should, in principle, allow for placing of the relevant individual into an appropriate class, assuming that there is enough information available to perform the string-entity transformation (see also olive:datatypePropertyUsesMappingProperty).
:DrRice olive:entityTypeCode "1"^^xsd:string
evaluates
(:Evaluation1 olive:evaluatedThing :Thing1) means that Evaluation is an evaluation of Thing1. For example, (:BillysReportCard olive:evaluatedThing :Billy).
:BillysReportCard olive:evaluatedThing :Billy
performed
(:Agent1 olive:evaluator :Evaluation1) means that Evaluation1 records Agent1's assessment of the subject in question (see olive:evaluatedThing). For example, (:CaseysManager olive:evaluator :CaseysPerformanceReview) indicates that Casey's manager was the 'author of' his performance review.
:CaseysManager olive:evaluator :CaseysPerformanceReview
was done by
This relates a medical care event to the care provider in that event. For example, (:Visit01 olive:eventCareProvider :DrMartin) indicates that Dr Martin was the care provider in visit 01.
:Visit01 olive:eventCareProvider :DrMartin
was done by attending provider
This is a subproperty of olive:eventCareProvider specific to range of admitting providers.
This is a subproperty of olive:eventCareProvider specific to range of attending providers.
was done by primary care provider
This is a subproperty of olive:eventCareProvider specific to range of primary care providers.
generates
(:MedicalCareEvent1 olive:eventClaim :InsuranceClaim1) means that MedicalCareEvent1 generates InsuranceClaim1. For example, (:Surgery201 olive:eventClaim :ClaimForSurgery201) means that the surgery in question is included (if not the sole basis for) in the related insurance claim.
:Surgery201 olive:eventClaim :ClaimForSurgery201
produces
(:Event1 olive:eventCreates :Thing1) means that Thing1 was created by/during Event1. For example, (:MyBakingParty olive:eventCreates :ThisPie) would indicate that this pie was created at my baking party. This property can be used to connect any creation event to the thing that is created. The creation does not need to be intentional. Byproducts are created just as well as primary product.
:MyBakingParty olive:eventCreates :ThisPie
(:Situation1 olive:eventInvolves :_Thing_1) means that Situation1 involves Thing1. This is the very loosest connection a thing can have to a given event. It applies to the doers, objects, location, equipment used, etc. that is somehow involved in a given event. For example, (:MyBirthdayParty olive:eventInvolves :MyIceCreamCake), since that cake was served at the party. But the event also involved myself, my guests, the table the cake was served on, my house in general (since it was held there), August 2, 2020 (the date the party was held), and so on. Since this property is so general, it should rarely be directly used. Instead, look at the subproperties, which will carry more specific meanings--and thus, inferential power. For example, while a given doctor's office is involved in a given doctor's visit, it's best to use olive:occursAt. This will ensure/infer that the office is a place where the visit happened. Contrast this with travelling to the doctor's office. That would also involve the office, but the office wouldn't be the location where the travelling occurs, but rather the destination. Notice that not all important, more specific, ways of being involved are subproperties of olive:eventInvolves. Sometimes the appropriate property is a subproperty of [owl:inverseOf olive:eventInvolves]. For example, while a patient is involved (olive:eventInvolves) in their doctor's visit, it would be best to say the visit has them as the patient (olive:eventPatient). So, when searching for the appropriate relationship, make sure to consider properties where the event is subject AND properties where the event is the object. Note that for legacy reasons the name of the property is "eventInvolves" despite the fact that its domain covers instances of olive:Situation.
:MyBirthdayParty olive:eventInvolves :MyIceCreamCake
has as an output
(:Event1 olive:eventOutputs :Thing1) means that Thing1 is in some sense an output of Event1. The notion of "being an output" used here presupposes that the output is affected by the event in some way (see olive:affectedObject-Direct) and that it is consequently conceived of as involved in the event in some way (see olive:eventInvolves). Thus, this relation is a "role player" relation and not an event-to-event relation (as is, say, olive:causes-events). Context and one's modeling purposes will determine the scope of the extent of this property. For example, (:Photosynthesis001 olive:eventOutputs :Glucose001) means that an output of the specific event Photosynthesis001 is the specific thing Glucose001. But note that there could be other objects that stand in olive:eventOutputs to :Photosynthesis001 (e.g. :Oxygen001); note also that the notion of an output involved can be far less of a direct one than in this example - e.g. (:CompanyXChangingTheUnitCostOfSomeProduct olive:eventOutputs :ANewCostSpecificationGoverningThatProduct). Again, context will help to determine how strict or loose the scope of an event is with regard to its outputs. Note also that distinguishing between olive:eventOutputs and olive:eventCreates allows for this sort of flexibility (changing the cost of something is not itself the creation of a new cost specification, but it might involve such a creation and thereby have the cost specification as an output).
:Photosynthesis001 olive:eventOutputs :Glucose001
has the patient
(:MedicalCareEvent1 olive:eventPatient :Patient1) means that MedicalCareEvent1 has the patient Patient1. For example, (:Visit01 olive:eventPatient :Casey) would mean that Casey was the patient in Visit01.
has the example:
An annotation property that allows ontologists to document the connection between a resource and illustrative examples. This property should almost never be directly asserted. Instead, use the subproperties such as olive:exampleTriple and olive:exampleSubclass.
might be bound to, for example,
(:Variable1 olive:exampleBinding :string1) means that Variable1 might be bound to, for example, string1. For example, (:Var1 olive:exampleBinding "<http://purl.bioontology.org/ontoloyg/STY/T121>"^^xsd:string) tells us that we might want to run the query with that particular URI as a binding for Var1.
:Var1 olive:exampleBinding "<http://purl.bioontology.org/ontoloyg/STY/T121>"^^xsd:string
has the example instance:
An annotation property that allows ontologists to document the connection between a class and some illustrative instances. Note that these don't need to be directly asserted: you might have a case where an instance of class is noteworthy, despite not being a direct instance (that is, it could be inferred). Further, it often makes sense to put an aspirational (that is, not even reified!) items here simply as strings. So, we omit the rdfs:range for this property; really you should either put in an owl:NamedIndividual or a xsd:string.
:Person olive:exampleInstance :BarackObama
has as a subclass, for example,
An annotation property that allows ontologists to document the connection between a class and its most notable subclasses. Note that these don't need to be directly asserted: you might have a case where a subclass of a subclass is noteworthy, despite not being a direct subclass.
:HeadOfState olive:exampleSubclass :USPresident
has the example subproperty:
An annotation property that allows ontologists to document the connection between a property and its most notable subproperties. Note that these don't need to be directly asserted: you might have a structure where [:p1 rdfs:subPropertyOf :p2], and [:p2 rdfs:subPropertyOf :p3], but nonetheless you might want to note that :p1 is a good example subproperty of :p3 using olive:exampleSubproperty.
:physicalPartOf olive:exampleSubproperty :bodyPartOf
can be used as follows, for example:
An annotation property that allows ontologists to give an example triple using the relevant term. Note that this triple does not need to be actually asserted; it just needs to be illustrative of the sort of triples you will be making with the term in question.
:subRegion olive:exampleTriple ":NorthAmerica :subRegion :PacificNorthwest"^^xsd:string
could be, for example:
(:Variable1 olive:exampleValue :Thing1) means that Thing1 is an example value that could be substituted in for Variable1. For example, (:JSONVar olive:exampleValue "{here: [is an example] }"^^olive:json).
:JSONVar olive:exampleValue "{here: [is an example] }"^^olive:json
runs
executes
partly consists in running
(:Event1 olive:executes :Content1) means that Event1 (partly) consists in the execution of Content1. For example, (:MyPlayingMinesweeper olive:executes :MinsweeperApplication) means that my playing consisted in running the application.
:MyPlayingMinesweeper olive:executes :MinsweeperApplication
is the exemplar
(:ExemplarIndividual1 olive:exemplarForClass :Class1) means that ExemplarIndividual1 is the (unique) exemplar for Class1. The naming convention is that each :CLASS should have a corresponding :Exemplar_CLASS as its exemplar individual. See the comment on olive:ExemplarIndividual.
(:Exemplar_Doctor olive:exemplarForClass olive:Doctor)
is expressed using
is equivalent to
(:Thing1 olive:equivalentTo :Thing2) means that Thing1 and Thing2 are the part of (at least) one equivalence class. For example, (:Superman olive:equivalentTo :ClarkKent) holds because they are the same individual. Every subproperty of olive:equivalentTo is an equivalence relation, meaning that it is reflexive, symmetric, and transitive. Example subproperties would include congruence (from geometry), being the same height as, or being the same time as (see olive:sameTimeAs).
represents a coherent way of subdividing
(:Class-HigherOrder1 olive:facetingOfClass :Class1) means that :Class-HigherOrder1 is a class that represents a specific way of grouping the instances of :Class1 into subclasses. For example, (ex:PersonTypeByOccupation olive:facetingOfClass olive:Person) means that ex:PersonTypeByOccupation is a class each instance of which is (1) a subclass of olive:Person, and (2) represents a subdivision of olive:Person based on the general organizing principle represented by ex:PersonTypeByOccupation.
ex:PersonTypeByOccupation olive:facetingOfClass olive:Person
has the following fax number:
(:AddressOrAgent1 olive:faxNumber "NUM"^^xsd:string) means that "NUM" is the fax number associated with AddressOrAgent1. For example, (:Bill olive:faxNumber "122345260982"xsd:string) shows you what you might dial to reach Bill by fax.
:Bill olive:faxNumber "122345260982"xsd:string
(:_Table_1 olive:fieldCount INT) means that Table1 has INT fields/columns. For example, (:CaseysGradebook olive:fieldCount 10) means that there are 10 columns in Casey's gradebook.
(:_Field_1 olive:fieldName "NAME"^^xsd:string) means that Field1 is named, or has the header, NAME. For example, (:ExField olive:fieldName "cake_flavor"xsd:string) would mean that :ExField is the field with header "cake_flavor". Note that this field name is merely the string, and isn't semantic. For the actual meaning, see olive:fieldType.
:ExField olive:fieldName "cake_flavor"xsd:string
(:_Field_1 olive:fieldType :_Class_1) means that every non-null cell (see olive:Cell-Data) in Field1 represents an instance of Class1. For example, (:FieldA olive:fieldType olive:Person) indicates that only persons are legitinmate values of cells in FieldA, such as :BenjaminFranklin or :ArnoldPalmer. Note that this is currently an annotation property. This means that it will serve for queries or documentaiton, but it will not enforce any typing via inference.
This is a subproperty of olive:authorOf, indicating first authorship.
:MyCelebration olive:follows :MarinersClinchingALWestIn2001
(:Resource1 olive:formerName "OLDNAME"^^xsd:string) means that the term Resource1 used to be called "OLDNAME" . For example, if I rename gist:actual to gist:timeOf, I would rename it and add the triple (gist:actual olive:formerName "gist:timeOf"^^xsd:string). This is an optional documentation predicate, but it may be useful for those familiar with the old term. Just as important is to include former names as skos:altLabels if they are appropriate lexifications for the term in question. This will aid in search as well.
gist:actual olive:formerName "gist:timeOf"^^xsd:string
(:Thing1 olive:foundAtCharacter "INT"^^xsd:nonNegativeInteger) means that Thing1 can be found at INT character in the text string in which it is located. For example, (:WikipediaCitation olive:foundAtCharacter "17"^^xsd:nonNegativeInteger) means that a given Wikipedia citation occurs (at least) on character 17 in some text. Obviously, more information is called for here: which text? For that, you should refer to the text that our :WikipediaCitation is directly a part of (see olive:directPartOf).
:WikipediaCitation olive:foundAtCharacter "17"^^xsd:nonNegativeInteger
(:Thing1 olive:foundAtEndingCharacter "INT"^^xsd:nonNegativeInteger) means that Thing1 ends at INT character in the text string in which it is located. For example, (:WikipediaCitation olive:foundAtEndingCharacter "21"^^xsd:nonNegativeInteger) means that a given Wikipedia citation ends on character 21 in some text. Obviously, more information is called for here: which text? For that, you should refer to the text that our :WikipediaCitation is directly a part of (see olive:directPartOf).
:WikipediaCitation olive:foundAtEndingCharacter "21"^^xsd:nonNegativeInteger
(:Thing1 olive:foundAtStartingCharacter "INT"^^xsd:nonNegativeInteger) means that Thing1 can be found starting at INT character in the text string in which it is located. For example, (:WikipediaCitation olive:foundAtStartingCharacter "17"^^xsd:nonNegativeInteger) means that a given Wikipedia citation starts on character 17 in some text. Obviously, more information is called for here: which text? For that, you should refer to the text that our :WikipediaCitation is directly a part of (see olive:directPartOf).
:WikipediaCitation olive:foundAtStartingCharacter "17"^^xsd:nonNegativeInteger
(:Thing1 olive:foundOnPage "INT"^^xsd:nonNegativeInteger) means that Thing1 can be found on the INT page in the content in which it is located. For example, (:Chapter3 olive:foundOnPage "17"^^xsd:nonNegativeInteger) means that chapter 3 occurs (at least) on page 17 of some text. Obviously, more information is called for here: which text? For that, you should refer to the text that our :Chapter3 is directly a part of (see olive:directPartOf).
:Chapter3 olive:foundOnPage "17"^^xsd:nonNegativeInteger
(:Thing1 olive:foundEndingOnPage "INT"^^xsd:nonNegativeInteger) means that Thing1 can be found ending on the INT page in the content in which it is located. For example, (:Chapter3 olive:foundEndingOnPage "25"^^xsd:nonNegativeInteger) means that chapter 3 ends on page 25 of some text. Obviously, more information is called for here: which text? For that, you should refer to the text that our :Chapter3 is directly a part of (see olive:directPartOf).
:Chapter3 olive:foundEndingOnPage "25"^^xsd:nonNegativeInteger
(:Thing1 olive:foundStartingOnPage "INT"^^xsd:nonNegativeInteger) means that Thing1 can be found starting on the INT page in the content in which it is located. For example, (:Chapter3 olive:foundStartingOnPage "17"^^xsd:nonNegativeInteger) means that chapter 3 starts on page 17 of some text. Obviously, more information is called for here: which text? For that, you should refer to the text that our :Chapter3 is directly a part of (see olive:directPartOf).
:Chapter3 olive:foundStartingOnPage "17"^^xsd:nonNegativeInteger
is from
The address source of some item or content.
The agential source of something. This can
Asserts a list of values describing arguments provided for a specific function call. These values may be either literals or resources referring to object descriptions. Note that we should be able to query for the ith argument using `?fnCall olive:functionArguments/rdf:rest{i}/rdf:first ?ith-arg.`
:MyFunctionCall olive:functionArguments ('arg1' 'arg2' ...)
holds between input and output akin to
(:Function1 olive:functionImplies :Property1) means that Function1(input) = output iff (:input :Property1 :output) holds. For example, (:SSNLookupFn olive:functionImplies olive:ssn) is true because whenever you get 123-45-6789 as an output of John Doe in our SSN Lookup Function, it will also be true that (:JohnDoe olive:ssn "123-45-6789"^^xsd:string). Note that this assertion maps the input variable from the function to the subject of the resulting assertion, and the output variable to the object. If the order is reversed, you can use [owl:inverseOf :PROPERTYHERE].
:SSNLookupFn olive:functionImplies olive:ssn
expresses
(:LivingThing1 olive:genderExpression :GenderExpression-Category1) means that LivingThing1 expresses GenderExpression-Category1. For example, (:ClintEastwood olive:genderExpression olive:Masculine). Compare this property with olive:identifiesAs and olive:assignedSex. Note that while male sex, male gender, and masculinity are often instantiated in the same individual, they need not be; sex, gender, and gender expression are distinct.
:ClintEastwood olive:genderExpression olive:Masculine
is associated with the following text indicating gender or sex:
(:LivingThing1 olive:genderOrSexText "STRING"^^xsd:string) means that STRING is a code indicating the gender or sex of LivingThing1. For example, (:ClintEastwood olive:genderOrSexText "M"^^xsd:string) means that the string "M" can be interpreted as indicating the gender or sex associated with Clint Eastwood. Context will determine the correct way of interpreting the code, and it may be appropriate to use a more specific property such as olive:genderText or olive:sexText.
:ClintEastwood olive:genderOrSexText "M"^^xsd:string
is associated with the following text indicating gender:
(:LivingThing1 olive:genderText "STRING"^^xsd:string) means that STRING is a code indicating the gender of LivingThing1. For example, (:ClintEastwood olive:genderText "M"^^xsd:string) means that the string "M" can be interpreted as indicating the gender associated with Clint Eastwood. Context will determine the correct way of interpreting the code and may allow for the deduction of a new olive:identifiesAs or olive:genderExpression triple.
:ClintEastwood olive:genderText "M"^^xsd:string
government for
governs
(:Government1 olive:governmentFor :Place1) means that the government for Place1 is Government1. For example, (:ArkansasGovt olive:governmentFor :Arkansas). This property is functional. While many regions are governed by multiple entities, we assume that no two governments have identical boundaries. So, the fact that the US government and the Arkansas state government both have authority in is not a problem. In other words, it is false to say that (:USGovt olive:governmentFor :PineBluffAR), but (:USGovt olive:governs :PineBluffAR). The only thing that would stand in the olive:governmentFor relation to Pine Bluff would be the, say, the city government.
:ArkansasGovt olive:governmentFor :Arkansas
The subject controls or inhibits the object in some way
normatively constrains
(:CommitmentOrIntention1 olive:governsBehavior :Situation1) means that CommitmentOrIntention1 is salient for determining whether or how Situation1 should occur. This is a general property that allows for the representation of either logical or normative constraints embodied in an intention or commitment and their application to specific actions. For example, (:Rule17A olive:governsBehavior :MyPetitioningTheCourt) indicates that I should pay attention to Rule 17A as a petition the court, as it normatively constrains my behavior. Again, this property is general. Usually one should prefer to be more precise about *what* the nature of the governance is. We don't want to just know that, say, a rule is relevant to a behavior, but rather whether the rule forbids, permits, or requires the behavior. Note that the range is olive:Situation: this property can apply both to events (including, and especially, actions) and "states" of the world (including, and especially, relationships). Thus, an instance of olive:Account (which is a kind of contractual business agreement) might stand in olive:governsBehavior to each of the following: :MyRelationshipWithBankOfAmerica (i.e. the instance of olive:BusinessRelationship established by this instance of olive:Account), and :MyTerminatingMyBusinessWithBankOfAmerica (i.e. an instance of olive:Event that is normatively governed by the terms of my account with Bank of America).
:Rule17A olive:governsBehavior :MyPetitioningTheCourt
has a confidence of
(:KnowledgeGraph1 olive:graphConfidence "DECIMAL"xsd:decimal) means that KnowledgeGraph1 has a confidence of DECIMAL, which is to say that a randomly selected assertion from the graph has a probability of DECIMAL of being true. For example, (:NamedGraph1 olive:graphConfidence ".6"^^xsd:decimal) means that there is a 60% chance that any given claim in that graph is true. Obviously in practice this is going to be hard to pin down--if we ever knew the exact value we'd probably just be able to fix th assertions to make it a confidence of 1. So, we will use these assertions as heuristics to inform when it is appropriate to use a given graph.
:NamedGraph1 olive:graphConfidence ".6"^^xsd:decimal
has a class count of
(:KnowledgeGraph1 :graphClassCount "INTEGER"xsd:integer) means that KnowledgeGraph1 has a class count of INTEGER. For example, (:HCPCSGraph :graphClassCount "1800"^^xsd:integer) would mean that the HCPCS graph contains 1800 distinct classes.
:HCPCSGraph :graphClassCount "1800"^^xsd:integer
has a gross cost of
(:Thing1 olive:grossCost :Monetary1) means that the gross cost of Thing1 is Monetary1. This amount is typically contrasted with the adjusted cost (e.g. after applying coupons, or a contractor adjustment). For example, (:MyDentalProcedure olive:grossCost [a olive:Monetary; olive:decimalValue "2000"^^xsd:decimal ; olive:hasUoM olive:_USDollar]). Compare with olive:adjustedCost.
:MyDentalProcedure olive:grossCost [a olive:Monetary; olive:decimalValue "2000"^^xsd:decimal ; olive:hasUoM olive:_USDollar]
grounds
(:Thing1 olive:grounds :Thing1) means that Thing1 grounds Thing1. For example, (:TheFifthAmendment olive:grounds :SupremeCourtDecision12) might mean that the Supreme Court's decision is grounded by, or depends on, the Fifth Amendment..
:TheFifthAmendment olive:grounds :SupremeCourtDecision12
has an altitude of
can be quantified/qualified by
(:Thing1 olive:hasAmount :Amount1) means that Thing1 can be quantified or qualified by Amount1. For example,(:PileOfLeaves olive:hasAmount :LargeAmount) might be used to indicate a quality of largeness of the pile. Or, we could use a more specific olive:hasMagnitude relationship to quantify the amount leaves (e.g. linking it to cubic meters or some such). See the subproperties to make either a qualitative or quantitative connection.
:PileOfLeaves olive:hasAmount :LargeAmount
has a remaining balance of
(:Thing1 olive:hasBalance :Monetary1) means that Thing1 has a remaining balance of Monetary1. For example, (:MyTractor olive:hasBalance [olive:decimalValue "2600"^^xsd:decimal ; olive:hasUoM olive:_USDollar]) means that I still owe $2600 on my tractor. This might be because it cost that much originally, or perhaps I have already paid down the balance somewhat.
:MyTractor olive:hasBalance [olive:decimalValue "2600"^^xsd:decimal ; olive:hasUoM olive:_USDollar]
can be converted to the base unit
EXAMPLE: saying that a furlong hasBaseUnit meter says it is a DistanceUnit.
Relates a UnitOfMeasure to its BaseUnit. This indicates what kind Unit something is, e.g. saying that a furlong hasBaseUnit meter says it is a DistanceUnit.
handles financial communications at
(:Agent1 :hasBillingAddress :Address1) means that Agent1 can be billed at Address1. For example, (:NewOrleansHospital :hasBillingAddress :Address32) means that Address32 is the address for New Orleans Hospital.
:NewOrleansHospital :hasBillingAddress :Address32
has the following certification:
(:Individual1 olive:hasCertification :Certification1) means that Individual1 has the certification Certification1. For example, (:Nick olive:hasCertification :DoctorOfPhilosophy) means that Nick has a Ph.D. degree.
:Nick olive:hasCertification :DoctorOfPhilosophy
can be reached at
(:Agent1 olive:hasCommunicationAddress :Address1) means that one can communicate with Agent1 at/via Address1. It might be their residence, a location for a PO Box, an email address, etc.
:Agent1 olive:hasCommunicationAddress :Address1
has
(:LivingThing1 olive:hasCondition :HealthCondition1) means that LivingThing1 has HealthCondition1. For example, (:Jeremy olive:hasCondition [a olive:Injury]) means that Jeremy is injured.
:Jeremy olive:hasCondition [a olive:Injury]
has a contract with
uses
(:Agent1 olive:hasContractWith :Agent2) means that Agent1 and Agent2 are part of some contract.
is classified by
(:Event1 olive:hasCPTCode :CPTCode1) means that Event1 is classified by CPTCode1. For example, (:AnniesProcedure olive:hasCPTCode :CPT73600) would mean that Annie's procedure was of the sort indicated by CPT 73600 (that is, an Xray of the ankle).
:AnniesProcedure olive:hasCPTCode :CPT73600
has a diameter of
(:Thing1 olive:hasDiameter :Distance1) means that Thing1 has a diameter of Distance1. For example, (TheGlassOnMyDesk olive:hasDiameter [a olive:Distance ; olive:hasUoM ex:_inch ; olive:decimalValue "2"^^xsd:double]) means that the glass on my desk has a diameter of 2 inches.
:TheGlassOnMyDesk olive:hasDiameter [a olive:Distance ; olive:hasUoM ex:_inch ; olive:decimalValue "2"^^xsd:double]
Relates a given ordered collection, often a list, to its elements. You should rarely use this property, instead using the more specific 'nth element' subproperties, such as olive:element_1 for the first element in a list.
(:Agent1 olive:hasEmailAddress :EmailAddress1) means that EmailAddress1 is (one of) Agent1's email address(es). For example, (:Sean_Lane olive:hasEmailAddress :SeansGmail) means that the thing denoted by :SeansGmail is an email address for Sean Lane. This property is neither functional nor inversely functional. A person may have multiple email addresses, and a given address may be owned by several persons. If the need arises to have an inversely functional version, one can be created (and this comment updated accordingly). Note that the email address is not just the string. See the comment on olive:EmailAddress for more details.
:Sean_Lane olive:hasEmailAddress :SeansGmail
has goal
has a goal to
(:Thing1 olive:hasGoal :Goal1) means that Thing1 has Goal1 as an evaluatable standard for whether they have met this success. Unlike a requirement (see olive:Requirement), goals are optional.
has the input variable
This is the subproperty fo olive:hasVariable for input variables, specifically.
(:_Person_1 olive:hasInsurancePolicy :_InsurancePolicy_1) means that Person1 is the policyholder of InsurancePolicy1. For example, (:Bill olive:hasInsurancePolicy :Pol1234) would mean that Bill is the policyholder of Pol1234, responsible for paying the premium, and receiving the benefits described in the agreement. Note that being the policy holder is different from being covered by the policy, though usually the policy holder is covered. In many cases, the policyholder's dependents will also receive coverage. This property is a subproperty of the inverse of olive:coversAgent. See olive:InsuranceClaim and olive:InsurancePolicy for important related vocabulary.
has a length of
(:Thing1 olive:hasLength :Distance1) means that Thing1 has a length of Distance1. For example, (MyIndexFinger olive:hasLength [a olive:Distance ; olive:hasUoM ex:_inch ; olive:decimalValue "3"^^xsd:double]) means that my index finger has a length of of 3 inches.
:MyIndexFinger olive:hasLength [a olive:Distance ; olive:hasUoM ex:_inch ; olive:decimalValue "3"^^xsd:double]
has the quantitative feature
Relates a thing to some measurable quantity. See olive:Magnitude. This comment should be updated.
includes
Relates a list (see rdf:List) or collection (see olive:Collection) to its elements.
(:Thing1 olive:hasMonetaryValue :Monetary1) means that the value of Thing1 is given by Monetary1. For example, (:CaseysMechanicalKeyboard olive:hasMonetaryValue [a olive:Monetary; olive:hasUoM olive:_USDollar; olive:decimalValue "75"^^xsd:decimal]) means that my mechanical keyboard is worth $75. You almost always want to use a more specific property, such as olive:costOf and its subproperties.
:CaseysMechanicalKeyboard olive:hasMonetaryValue [a olive:Monetary; olive:hasUoM olive:_USDollar; olive:decimalValue "75"^^xsd:decimal]
has the following npi:
This links a covered medical care provider or NPI with their National Provider Identifier Standard ID. For example, (:DrRice olive:hasNPI :DrRicesNPI).
has the output variable
This is the subproperty fo olive:hasVariable for output variables, specifically.
involves
has as a focal party
involves as a focal party
(:Relationship1 olive:hasParty :Agent1) means that Agent1 is involved in Relationship1 as a focal party to it. Thus, (:NicksBusinessRelationshipWithBankOfAmerica olive:hasParty :Nick) and (:NicksBusinessRelationshipWithBankOfAmerica olive:hasParty :BankOfAmerica) would be used to specify that both Nick and Bank of America are parties to Nick's business relationship with Bank of America.
can be contacted at
(:Agent1 olive:hasPhoneNumber :PhoneNumber1) means that Agent1 can be contacted via PhoneNumber1. For example, (:Bill olive:hasPhoneNumber [a olive:TelephoneNumber ; olive:uniqueText "122345260982"^^xsd:string]) Note that you can move directly from an agent to their phone number string using olive:phoneNumber.
(:Bill olive:hasPhoneNumber [a olive:TelephoneNumber ; olive:uniqueText "122345260982"^^xsd:string])
has a practice located at
(:MedicalCareProvider1 olive:hasPracticeAddress :Address1) means that :MedicalCareProvider1 has a practice located at :Address1. For example (:JohnDoe olive:hasPracticeAddress :Address632) means that John Doe has a medical practice at Address632.
:JohnDoe olive:hasPracticeAddress :Address632
is precise to
(:Magnitude1 olive:hasPrecision "NUM"^^xsd:double) means that Magnitude1 is precise to the nearest NUM. For example, if we suppose (:MyHeight olive:hasUoM :_inch) and (:MyHeight olive:decimalValue "74"^^xsd:decimal), then (:MyHeight olive:hasPrecision "1e-1"^^xsd:double) means that my height is precise to the nearest tenth of an inch. This can also be applied to instances of olive:TimeInstant to show how precisely some time instant is being presented. olive:formerName "gist:hasPrecision"^^xsd:string; Note that this is a slight departure from the Semantic Arts use of olive:hasPrecision. They used a range of olive:Magnitude. However, the datatype property will be easier, since you can be as precise and it does not require the reification of new magnitudes for things like :tenth_of_an_inch to express the example above. Presently (12/11/20) the domain is for time instants and magnitudes, though a measurement might also have a precision. As measurements are not in the ontology right now, we should consider expanding the domain at later date when measurements are incorporated.
:MyHeight olive:hasPrecision "1e-1"^^xsd:double
is dispreferred compared to
(:Resource1 olive:hasPreferredTerm :Resource2) means that Resource1 is dispreferred compared to Resource2. For example, (foaf:phone olive:hasPreferredTerm olive:hasPhoneNumber).
foaf:phone olive:hasPreferredTerm olive:hasPhoneNumber
(:Content1 olive:hasPublicationDate :Date) means that Content1 was published on Date1. For example, (:TheGreatGatsby olive:hasPublicationDate [a olive:TimeInstant; olive:universalDate "1925-04-10"^^xsd:date ;]) indicates that The Great Gatsby was published on April 10, 1925. If one only has the year of publication, you can still use this property but further add a (:Date olive:hasUoM :_year) and (:Date olive:hasPrecision "1.0"^^xsd:double) assertion.
:TheGreatGatsby olive:hasPublicationDate [a olive:TimeInstant; olive:universalDate "1925-04-10"^^xsd:date ;]
is revised as
(:Content1 olive:hasRevisedVersion :Content2) means that Content1 is revised as Content2. For example, (:CaseysDissertationDraft1 olive:hasRevisedVersion :CaseysDissertationDraft2).
:CaseysDissertationDraft1 olive:hasRevisedVersion :CaseysDissertationDraft2
(:DrugClass1 olive:hasRxNormCUI "ID"^^xsd:string) means that RxNorm refers to DrugClass1 as ID. For example, (:Ibuprofen olive:hasRxNormCUI "310965"^^xsd:string). Note that this is an annotation property, and as such will not be used in inference, though it can be used for querying.
:Ibuprofen olive:hasRxNormCUI "310965"^^xsd:string
has a SSN of
has social security number
(:Person1 olive:hasSSN :ID1) means that Person1 is identified by their social security number, represented as ID1. For example, (:BobSmith olive:hasSSN :BobsSSN) connects Bob to his SSN. This is similar to olive:hasEmailAddress, in that there is an intermediate thing, the ID, but you might also want to go straight to the datatype by means of another property (in this case, gist:uniqueText).
has the standard unit
For a complex unit refers to a unit that has all the component parts in SI
has the following status:
(:Artifact1 olive:hasStatus :Status1) means that Artifact1 has Status1. For example, (:CPA1 olive:hasStatus :Status-InProgress) indicates that CPA1 is in progress.
:CPA1 olive:hasStatus :Status-InProgress
(:_WholeEvent_1 olive:hasSubevent :_PartEvent_1) means that WholeEvent1 has PartEvent1 as a part. For example, (:MyBaseballGame olive:hasSubevent :TheSecondInningOfMyGame) means that the second inning was a part of my baseball game. You can use this property to indicate necessary subevents for some class. It is part of Olive's event scripting vocabulary. Note that for legacy reasons this property is called "hasSubevent" despite the fact that both its domain and range cover instances of olive:Situation.
:MyBaseballGame olive:hasSubevent :TheSecondInningOfMyGame
has as a subnode
(:Entity1 olive:hasSubNode :Entity2) means that Entity2 is in some sense a "subnode" of Entity1 in some representation. This property is designed to be extremely flexible in order to enable any number of relationships to hold between the super- and sub-nodes. It is especially useful in initial stages of semantic enrichment of data, when one may need to declare a simple super-to-subnode relationship between items without committing to what exactly the relationship between those items is. Note that there is no domain or range associated with this property because it is designed to allow anything whatsoever - named individuals, classes, literals - to stand as its arguments.
(:Class1 olive:hasUMLSCUI "ID"^^xsd:string) means that UMLS refers to Class1 as ID. For example, (:Headache olive:hasUMLSCUI "C0018681"^^xsd:string). Note that this is an annotation property, and as such will not be used in inference, though it can be used for querying.
:Headache olive:hasUMLSCUI "C0018681"^^xsd:string
is measured in
has units
(:_Magnitude_1 olive:hasUoM :_UnitOfMeasure_unit) means that magnitude1 is measured in unit1. For example, (:ETHeight olive:hasUoM :_meter) means that that the magnitude of the Eiffel Tower, which is denoted by the particular magnitdue :ETHeight, is measured in meters. When paired with the assertion that (:ETHeight gist:hasDecimalValue "300"^^xsd:string), this allows us to conclude that the Eiffel Tower is 300m tall. This property is functional. A given magnitdue has exactly one unit. This may seem incorrect; obviously you can measure the Eiffel Tower in feet just as well as you could in meters. That's the whole point of having conversions! While that sentiment is correct, we are somewhat restricted by using triples here. It's technically not the unit for a given height that is functional, but the <decimal, unit> pair. So, while you could say the Eiffel Tower is 300m or that it is 984ft, you would be in a bind if you could assert that a given magnitude had multiple decimal values AND multiple units. There simply isn't a way using triples alone there to know which units would go with which decimals. That said, this representation isn't all that limiting. One can still derive the measure of a magnitude in feet from the measure of a magnitude by converting to and from the base unit (see olive:BaseUnit, olive:baseConversionFactor, and olive:hasBaseUnit). If you want to express directly that the Eiffel Tower is 300m and also that it is 984ft, you could do so by creating two separate magnitudes (e.g both :ETHeightMeter and :ETHeightFt), and then you could connect this as congruent magnitudes.
contains the variable
contains the parameter
(:Function1 olive:hasVariable :Variable1) means that Function1 contains Variable1. For example, if our function was f(x) = x^2, we could say that (:OurFunction olive:hasVariable :x). Variables are best distinguished as input and output variables, see olive:Input and olive:Output, as well as the subproperties of olive:hasVariable.
(:_Thing_1 olive:identifiedBy :_ID_1) means that Thing1 is identified by ID1. For example, if Bob's social security number is 123-45-6789, we'd say that (:_Person_Bob olive:identifiedBy [:uniqueText "123-45-6789"^^xsd:string; [owl:inverseOf olive:createsID] :_Organization_USGovernment]). Note that there may be more complete ways to do this, but you get the idea: Bob gets related to the ID, which in turn is related to the string, number, or other identifying symbols. This is a inversely functional property, like a URI: a thing can have more than one ID, but each of the IDs must refer to a unique thing. For example, Barack Obama has many URIs, a SSN, and other identifiers. But each of those identifiers must have exactly one referent: Barack Obama. Note that you may want to create more specific properties here, depending on use. For example, if you are frequently using SSNs, you may wish to create ex:hasSSN, a subproperty of olive:identifiedBy, restricting the domain and range accordingly (to ex:USCitizen and ex:SSN). See the inverse property, olive:identifies.
(:_Person_Bob olive:identifiedBy [:uniqueText "123-45-6789"^^xsd:string; [owl:inverseOf olive:createsID] :_Organization_USGovernment])
is the identifier for
(:ID1 olive:identifierForType :Class1) means that ID1 is a unique identifier for Class1. For example, (SKU-10201301 olive:identifierForType ToyotaRav4) means that SKU-10201301 is an identifier used to signify that something is an instance of the class ToyotaRav4.
:SKU-1010201 olive:identifierForType ToyotaRav4
identifies
For details, see the comment on the inverse property, olive:identifiedBy. Note that this property is functional: every identifier must refer to exactly one thing.
identfies as
(:Person1 olive:identifiesAs :Gender-Category1) means that Person1 identfies as Gender-Category1. For example, (:Casey olive:identifiesAs olive:Female-Sex) would mean that Casey identifies as female. Notice this does not imply that Casey's assigned sex (see olive:assignedSex) is female. See also olive:genderExpression.
:Casey olive:identifiesAs olive:Female-Sex
is associated with
(:IDClass olive:identifierTypeSupportsURITemplate :URITemplate1) means that instances IDClass can be used to generate URIs based on URITemplate1. For example, (:SSVID olive:identifierTypeSupportsURITemplate :SSVURITemplate). This means that everything that is olive:identifiedBy an instance of olive:SSVID can be given a URI in accordance with SSVURITemplate. You can use this property to state, for example, that anything with a SSN or TIN can be given a URI that follows the pattern of the associated URI template. You'd do this by saying, for example, that the class of (olive:SSN olive:identifierTypeSupportsURITemplate :SSNURITemplate).
:SSVID olive:identifierTypeSupportsURITemplate :SSVURITemplate
is identified by
(:Thing1 olive:identifyingText "TEXT"^^xsd:string) means that TEXT identifies Thing1. For example, one's SSN, or one's name (given a unique name assumption), or an NPI will pick out unique individuals. Such as: (:DrRice olive:identifyingText "1203456789"^^xsd:string), which might be true in virtue of that being Dr Rice's NPI number (see olive:npi). In practice, this is used more as an umbrella property for the specific types of identifiers. olive:identifyingText is NEITHER functional NOR inversely functional. However, all of its subproperties are both at least inversely functional, and often one to one.
:DrRice olive:identifyingText "1203456789"^^xsd:string
is a type of
(:Class-HigherOrder1 olive:instancesAreSubclassesOf :Class1) means that Class-HigherOrder1 is a type of Class1. For example, (olive:PatientCohort olive:instancesAreSubclassesOf olive:Patient) means that every instance of olive:PatientCohort is a rdfs:subClassOf olive:Patient.
olive:PatientCohort olive:instancesAreSubclassesOf olive:Patient
is the intellectual property of
is the IP of
(:IntellectualProperty1 olive:intellectualPropertyOf :Agent1) means that :IntellectualProperty1 is the intellectual property of :Agent1. For example, (:LetItBleed olive:intellectualPropertyOf :TheRollingStones).
:LetItBleed olive:intellectualPropertyOf :TheRollingStones
can be invoked with the Rest URL
(:Function1 olive:invokedWithRestURL "STRING"xsd:string) means that Function1 can be invoked with the Rest URL STRING. For example, (:CIPipeline1 olive:invokedwithRestURL "https://gitlab.example.com/api/v4/projects/9/trigger/pipeline?token=TOKEN&ref=main"^^xsd:string).
:CIPipeline1 olive:invokedwithRestURL "https://gitlab.example.com/api/v4/projects/9/trigger/pipeline?token=TOKEN&ref=main"^^xsd:string
invokes
(:Event1 olive:invokes :Thing1) means that Thing1 is somehow invoked/impelemented/executed/performed during Event1. Examples include performances implementing scripts, or running a program implementing the program, or applying a function implementing the function. For example, (:LastNightsShow olive:invokes :MyFairLady-Content) might mean that the show we went to last night performed the content of My Fair Lady.
:LastNightsShow olive:invokes :MyFairLady-Content
directly invokes
This is the functional version subproperty of olive:invokes. While a given event may invoke several different pieces of content, an invocation can directly invoke exactly one.
is an instance of
(:LowerOrderClass1 olive:instanceOf :HigherOrderClass1) means that LowerOrderClass1 is an instance of HigherOrderClass1. This is the annotation property analogue of rdf:type, to be used only to relate instances of higher-order classes (see olive:Class-HigherOrder) to the higher-order classes of which they are instances. (olive:instanceOf is the class-specific sub-property of wdt:P31.)
is a manifestation of
instantiates
is a realization of
materializes
makes real
(:ContentBearingThing olive:instantiates :Content1) means that ContentBearingThing1 is a realization or instantiation of Content1. For example, (:MyCopyOfTheCatcherInTheRye olive:instantiates :TheCatcherInTheRye) means that my copy of the book materializes the abstract story.
:MyCopyOfTheCatcherInTheRye olive:instantiates :TheCatcherInTheRye
is the payer for
(:InsuranceCompany1 olive:insurerForClaim :InsuranceClaim1) means that InsuranceCompany1 is the payer for InsuranceClaim1. For example, (:Cigna olive:insurerForClaim :Claim257) means that Cigna is the payer for Claim257.
(:Agent1 olive:insurerForPlan olive:_InsurancePlan_1) means that Agent1 is the insurer for InsurancePlan1. For example, (:Cigna olive:insurerForPlan :PlanZ) means that Cigna is the insurer for PlanZ, and thus is responsible for paying for legitimate claims (see olive:InsurancePlan) made by the plan holder. Note that the domain here is NOT olive:InsuranceCompany, as one might have the plan of being uninsured, in which case they would be the payer for their own plan.
(:_InsuranceCompany_1 olive:insurerForPolicy olive:_InsurancePolicy_1) means that InsuranceCompany1 is the insurer for InsurancePolicy1. For example, (:Cigna olive:insurerForPolicy :Pol1234) means that Cigna is the insurer for Pol1234, and thus is responsible for paying for legitimate claims (see olive:InsurancePolicy) made by the policy holder (see olive:hasInsurancePolicy). This property is a subproperty of the inverse of olive:hasParty. See olive:InusranceClaim and olive:InsurancePolicy for important related vocabulary.
(:Situation1 olive:involvesAgent :Agent1) means that Situation1 involves Agent1. For example, (:2020Inauguration olive:involvesAgent :JoeBiden). This is a very general relationship, and users are encouraged to pick a subproperty when possible that can more specifically pin down the agent's role in the event.
:2020Inauguration olive:involvesAgent :JoeBiden
The most general 'from' property. This can relate any idea, object, message, etc. its source. For example, a letter can be from a person, sent from an address, or be on paper stock that came from some particular tree. In almost every case, a more specific property should be used. For the above three cases you should use: olive:fromAgent, olive:fromAddress, and gist:fromMaterial.
has the following ISO 3166 code:
has the following Internantional Organization for Standardization (ISO) 3166 code:
(:Region1 olive:iso3166Code "STRING"^^xsd:string) means that :Region1 has the International Organization for Standardization (ISO) 3166 code STRING. It is almost always best to use one of the subproperties of this property when asserting information.
olive:UnitedStates olive:iso3166Code "US"^^xsd:string
has the following ISO 3166-1 alpha-2 code:
has the following Internantional Organization for Standardization (ISO) 3166-1 alpha-2 code:
(:Region1 olive:iso3166Code-countryAlpha2 "STRING"^^xsd:string) means that :Region1 has the two-letter International Organization for Standardization (ISO) 3166-1 code STRING.
olive:UnitedStates olive:iso3166Code-countryAlpha2 "US"^^xsd:string
has the following ISO 3166-1 alpha-3 code:
has the following Internantional Organization for Standardization (ISO) 3166-1 alpha-3 code:
(:Region1 olive:iso3166Code-countryAlpha3 "STRING"^^xsd:string) means that :Region1 has the three-letter International Organization for Standardization (ISO) 3166-1 code STRING.
olive:UnitedStates olive:iso3166Code-countryAlpha3 "USA"^^xsd:string
has the following ISO 3166-1 numeric code:
has the following Internantional Organization for Standardization (ISO) 3166-1 numeric code:
(:Region1 olive:iso3166Code-countryNumeric "STRING"^^xsd:string) means that :Region1 has the numeric International Organization for Standardization (ISO) 3166-1 code STRING.
olive:UnitedStates olive:iso3166Code-countryNumeric "840"^^xsd:string
has the following ISO 639 code:
has the following Internantional Organization for Standardization (ISO) 639 code:
(:NaturalLanguage1 olive:iso639Code "STRING"^^xsd:string) means that :NaturalLanguage1 has the International Organization for Standardization (ISO) 639 code STRING. It is almost always best to use one of the subproperties of this property when asserting information.
olive:EnglishLanguage olive:iso639Code "eng"^^xsd:string
has the following ISO 639-1 code:
has the following Internantional Organization for Standardization (ISO) 639-1 code:
(:NaturalLanguage1 olive:iso639-1Code "STRING"^^xsd:string) means that :NaturalLanguage1 has the International Organization for Standardization (ISO) 639-1 code STRING. This is a two-letter code assigned to each ISO macrolanguage.
olive:EnglishLanguage olive:iso639-1Code "en"^^xsd:string
has the following ISO 639-2B code:
has the following Internantional Organization for Standardization (ISO) 639-2/B code:
(:NaturalLanguage1 olive:iso639-2BCode "STRING"^^xsd:string) means that :NaturalLanguage1 has the International Organization for Standardization (ISO) 639-2B code STRING. This is a three-letter code assigned to each ISO macrolanguage; most of these will be the same as olive:iso639-2TCode, but in some cases this code is derived from its English name rather than the native name of the language.
olive:EnglishLanguage olive:iso639-2BCode "eng"^^xsd:string
has the following ISO 639-2T code:
has the following Internantional Organization for Standardization (ISO) 639-2T code:
(:NaturalLanguage1 olive:iso639-2TCode "STRING"^^xsd:string) means that :NaturalLanguage1 has the International Organization for Standardization (ISO) 639-2T code STRING. This is a three-letter code assigned to each ISO macrolanguage and derived from the native name of the language.
olive:EnglishLanguage olive:iso639-2TCode "eng"^^xsd:string
has the following ISO 639-3 code:
has the following Internantional Organization for Standardization (ISO) 639-3 code:
(:NaturalLanguage1 olive:iso639-3Code "STRING"^^xsd:string) means that :NaturalLanguage1 has the International Organization for Standardization (ISO) 639-3 code STRING. This is a unique three-letter code for every language (macro or not).
(:Content1 olive:issueNumber "N"^xsd:nonNegativeInteger) means that Content1 is the Nth issue in some series. For example, (:Erkenntnis_vol_7 olive:issueNumber "7"^xsd:nonNegativeInteger) means that the thing referred to by ':Erkenntnis_issn_7' is the seventh issue.
:Erkenntnis_issn_7 olive:issueNumber "7"^xsd:nonNegativeInteger
(:Thing1 olive:issuingAgent :Agent1) means that Agent1 is the issuer of :Thing1. For example (:TomsPhD olive:issuingAgent :TheOhioStateUniversity) means that the Ohio State University granted Tom's Ph.D. Note that this property is agnostic with regard to ongoing control over the issued thing, unlike, e.g., olive:licensingAgent, which presupposes that the licenser has some sort of control over the certification that is granted.
:TomsPhD olive:issuingAgent :TheOhioStateUniversity
has a destination of
The most general 'to' property. This can relate any idea, object, message, etc. its (intended or not) destination. For example, a letter can be to a person or sent to an address. In almost every case, a more specific property should be used. For the above cases you should use olive:toAgent and olive:toPlace, respectively.
involves an item that costs
(:BuyingAndSelling1 olive:itemCost :Monetary1) means that BuyingAndSelling1 is an event in which some focal item is sold at a rate of Monetary1. For example, (ex:BuyingAndSelling111 olive:itemCost [olive:decimalValue "500"^^xsd:double ; olive:hasUoM olive:_USDollar ]) means that the focal item sold in ex:BuyingAndSelling111 (see olive:itemSold) is sold for $500 US. This property is intended for representing events in which a single, individual thing is sold; for representing events in which multiple instances of a given type are sold, it might be preferable to use olive:itemCost.
ex:BuyingAndSelling111 olive:itemCost [olive:decimalValue "500"^^xsd:double ; olive:hasUoM olive:_USDollar ]
was last modified on
(:Thing1 olive:lastModifiedOn :TimeInstant1) means that the last time Thing1 was modified was TimeInstant1. For example, (:CaseysWill olive:lastModifiedOn [a olive:TimeInstant ; olive:universalDateTime "2010-07-07"^^xsd:universalDate]) means that my will was last modified on July 7th, 2010.
:CaseysWill olive:lastModifiedOn [a olive:TimeInstant ; olive:universalDateTime "2010-07-07"^^xsd:universalDate]
latitude
is granted by
is issued by
(:Certification1 olive:licensingAgent :Agent1) means that Certification1 is governed/controlled/granted by Agent1; in other words, Agent1 is the agent with the authority to grant and enforce the permission characterized by License1. For example, (:NicksDriversLicense olive:licensingAgent :Texas-StateGovernment) means that Nick's driver's license is granted by the state of Texas.
:NicksDriversLicense olive:licensingAgent :Texas-StateGovernment
has license number
(:LicenseOrAgent1 olive:licenseNumber "N"^xsd:string) means that LicenseOrAgent1 has license number N (if LicenseOrAgent1 is an instance of olive:License-Content, N will be the license number for that particular license; if it is an instance of olive:Agent, it will be the license number for some license possessed by that agent). For example, (:NicksDriversLicense olive:licenseNumber "82828282"^xsd:string) means that Nick's driver's license number is 82828282.
:NicksDriversLicense olive:licenseNumber "82828282"^xsd:string
occurred at/on
is associated with a location with the following label:
(:Thing1 olive:locationText "STRING"^^xsd:string) means that STRING is a label for a location associated with thing Thing1. For example, (:Nick olive:locationText "TX"^^xsd:string) means that Nick is associated with a location associated with the text "TX". This a general property designed to allow context to determine how to identify what STRING refers to.
:Nick olive:locationText "TX"^^xsd:string
longitdue
is made of
manufactures
(:Agent1 olive:manufactures :Thing2) means that Agent1 manufactures Thing2. For example, (:Motorola olive:manufactures :NicksPhone).
:Motorola olive:manufactures :NicksPhone
(:Agent1 olive:manufacturesType :Class1) means that Agent1 manufactures one or more instances of Class1. For example, (:Motorola olive:manufacturesType :SmartPhone).
:Motorola olive:manufacturesType :SmartPhone
fails to identify the appropriate resource to use in place of
(:MappingEvent olive:mappingEventFailsToMap :Thing1) means that :MappingEvent fails to leverage some declared mapping schema to identify the appropriate resource to use in place of Thing1. Thing1 will typically be a blank node with further associated information concerning the mapping failure. See also olive:mappingEventFailsToMap-direct for a more specific subproperty identifying cases in which a direct mapping to a resource is unavailable.
(:MappingEvent olive:mappingEventFailsToMap-direct :Thing1) means that :MappingEvent fails to leverage some declared mapping schema to identify the appropriate resource to use in place of Thing1. Thing1 will typically be a blank node with further associated information concerning the mapping failure. This property is used for the specific case in which there is expected to be a direct mapping from something (typically a string) to a resource in the ontology, typically declared via a subproperty of olive:mapsTo, olive:mapsTo-class, or olive:mapsTo-property. For cases in which the mapping failure is not direct in this way, the more general olive:mappingEventFailsToMap should be used.
has been
(:Resource1 olive:mappingStatus :MappingStatus1) means that Resource1 has MappingStatus1. There are three values for mapping status: olive:Unmapped, olive:Mapped, and olive:IndirectlyMapped. A term is mapped into the Olive ontology if it has been defined in terms of Olive vocabulary. We do this using terms like owl:equivalentProperty, owl:equivalentClass, rdfs:subPropertyOf, and rdfs:subClassOf. Even other looser connections, like skos:mappingRelation and subproperties suffice. If no such assertions have been made, then the term is considered unmapped. The indirectly mapped term is the most complicated. Let's say there is some example ontology, Ex. It has two classes, ex:Super and ex:Sub, such that (ex:Sub rdfs:subClassOf ex:Super). Then, if (ex:Super olive:mappingStatus olive:Mapped), then (ex:Sub olive:mappingStatus olive:IndirectlyMapped). ex:Sub inherits its mapping via the mapping of ex:Super.
fhir:Medication olive:mappingStatus olive:Mapped
maps to
(:Thing1 olive:mapsTo "STRING"xsd:string) means that Thing1 maps to STRING. For example, (:NormalUse olive: "usual"^^xsd:string) means that the resource :NormalUse is somehow mapped to the string "usual" in some data source. These assertions almost always will use a subproperty of olive:mapsTo that is specific to the source, and they will serve to make simpler rules in mapping from some data source or source ontology into the Olive ontology. Subproperties should follow the naming convention olive:mapsTo-X, where is is the name for the source ontology or data, e.g. olive:mapsTo-fhir for the fhir mapping predicate.
(:Sex-Category1 olive:mapsTo-assignedSexText "STRING"xsd:string) means that Sex-Category1 maps to STRING.
(:Thing1 olive:mapsTo-certificationText "STRING"xsd:string) means that Thing1 maps to STRING.
(:Class1 olive:mapsTo-class "STRING"xsd:string) means that Class1 maps to STRING. For example, (olive:Organization olive:mapsTo-class "organization"^^xsd:string) means that the resource olive:Organization is somehow mapped to the string "organization" in some data source. These assertions almost always will use a subproperty of olive:mapsTo-class that is specific to the source, and they will serve to make simpler rules in mapping from some data source or source ontology into the Olive ontology. Subproperties should follow the naming convention olive:mapsTo-X, where is is the name for the source ontology or data, e.g. olive:mapsTo-fhir for the fhir mapping predicate.
olive:Organization olive:mapsTo-class "organization"^^xsd:string
maps to (in fhir)
(:Thing1 olive:mapsTo-fhir "STRING"xsd:string) means that Thing1 maps to (in fhir) STRING.
maps to (in the NUCC healthcare provider taxonomy)
(:Thing1 olive:mapsTo-NUCCProviderTaxonomy "STRING"xsd:string) means that Thing1 maps to (in the NUCC healthcare provider taxonomy) STRING.
(:Class1 olive:mapsTo-NUCCProviderTaxonomy "STRING"xsd:string) means that Class1 maps to (in the NUCC healthcare provider taxonomy) STRING and that Class1 is a type of provider specialty.
(:Class1 olive:mapsTo-NUCCProviderTaxonomy "STRING"xsd:string) means that Class1 maps to (in the NUCC healthcare provider taxonomy) STRING and that Class1 is a type of provider.
maps to NUCC provider taxonomy group label
has the following label in the NUCC provider taxonomy
(:Class1 olive:mapsTo-NUCCProviderTaxonomyGroupLabel :Label1) means that :Class1 maps to the label :Label1 in the Group field of the NUCC provider taxonomy.
(:Property1 olive:mapsTo-property "STRING"xsd:string) means that Property1 maps to STRING. For example, (olive:name-operating olive:mapsTo-property "3"^^xsd:string) means that the resource olive:name-operating is somehow mapped to the string "3" in some data source. These assertions almost always will use a subproperty of olive:mapsTo-property that is specific to the source, and they will serve to make simpler rules in mapping from some data source or source ontology into the Olive ontology. Subproperties should follow the naming convention olive:mapsTo-X, where is is the name for the source ontology or data, e.g. olive:mapsTo-fhir for the fhir mapping predicate.
olive:name-operating olive:mapsTo-property "3"^^xsd:string
This mapping is motivated by mapping Ribbon Health data.
(:Thing1 olive:mapsTo-ServiceCode "STRING"xsd:string) means that Thing1 maps to STRING.
maps to (in x12)
(:Thing1 olive:mapsTo-x12ClaimStatusCode "STRING"xsd:string) means that Thing1 maps to (in X12's 1029 Claim Status codes) STRING.
is married to
(:Person1 olive:marriedTo :Person1) means that Person1 is married to Person1. For example, (:BarackObama olive:marriedTo :MichelleObama). Note that sometimes we would be better off talking about the nature of the relationship (see olive:Relationship) rather than asserting the relation via the property. For example, it's easier to state the start or end of a marriage than it is to qualify the triple that relates two individuals via olive:marriedTo.
:BarackObama olive:marriedTo :MichelleObama
matches
(:Thing1 olive:matchesExemplar :ExemplarIndividual1) means that Thing1 matches the exemplar :ExemplarIndividual1. This means that Thing1 has been determined to possess characteristics sufficient for it to be identified as a match for ExemplarIndividual1. In practice, this will typically mean that characteristics possessed by ExemplarIndividual1 that aren't also currently known to be possessed by Thing1 should be provable of Thing1. For example, suppose (:Bob olive:matchesExemplar olive:ExemplarCredentialedIndividual_ANP) and (olive:ExemplarCredentialedIndividual_ANP a olive:AdultNursePractitioner) hold, and that (:Bob a olive:AdultNursePractitioner) is not currently known to hold. In such a case, it would be reasonable to conclude (:Bob a olive:AdultNursePractitioner).
(:Bob olive:matchesExemplar olive:ExemplarCredentialedIndividual_ANP)
can be used the following number of times:
(:Thing1 olive:maximumNumberOfUses "12"^^xsd:integer) means that Thing1 can be used a maximum of 12 times.
(SurgicalMask01 olive:maximumNumberOfUses "1"^^xsd:string
has the following number of members:
(:Collection1 olive:memberCount :Integer1) means that Collection1 has Integer1 members. For example, (:NicksBaseballCardCollection olive:memberCount "12"^^xsd:integer) means that Nick's baseball card collection has 12 members.
is a member of
The inverse of olive:hasMember. See that comment for details.
contains the meta information about
is the meta graph for
(:MetaGraph1 olive:metaGraphFor :KnowledgeGraph1) means that MetaGraph1 contains the meta information about KnowledgeGraph1. For example, (:UMLSMetaGraph olive:metaGraphFor :UMLSGraph). This property is functional and inversely functional. There is a one-to-one correspondence between graphs and their metagraphs.
:UMLSMetaGraph olive:metaGraphFor :UMLSGraph
was modified on
(:Thing1 olive:modifiedOn :TimeInstant1) means that Thing1 was modified on TimeInstant1. For example, (:OliveOntology olive:modifiedOn ["2020-01-02"^^xsd:date]) means that the Olive ontology was modifed on January 2, 2020. Of course, this is consistent with it being modified again afterward. For the latest modification, see olive:lastModifiedOn. Also, for details of the modifications, see olive:ChangeEvent and related properties.
:OliveOntology olive:modifiedOn ["2020-01-02"^^xsd:date]
has a product component unit of
Relates a unit of measure such as square mile or foot-pound to any of the units multiplied together (e.g. mile or pound). Note that we don't use
is named
(:Thing1 olive:name "NAME"^^xsd:string) relates Thing1 to (one of) its name(s), NAME. For example, (:BabeRuth olive:name "Sultan of Swat"^^xsd:string). Note that this is not a functional property, as an individual may have many names. And inversely, the same name may be used for many individuals. This can be used for non-persons, such as organizations, as well as non-agents. If I named my car or computer, this property would work. In many cases, this property is similar to skos:prefLabel. Both are ways to link name strings to things. The key differences are that skos:prefLabel is functional, and it is to be used as the preferred NL generation mechanism. Additionally, the prefLabel can be used for properties and other things for NL purposes where they could not be properly said to have a name.
:BabeRuth olive:name "Sultan of Swat"^^xsd:string
has the name
(:Thing olive:name-alt "FIRSTNAME"^^xsd:string) means that Thing1 has an alternative name of "NAME". For example, (:BabeRuth olive:name-alt "George"^^xsd:string). This is meant to be a very general super-property of all the various alternative name properties.
:BabeRuth olive:name-alt "George"^^xsd:string
has the following text associated with its name:
(:Thing olive:name-associatedText "TEXT"^^xsd:string) means that Thing1 has "TEXT" associated with its name. For example, (:JeffBezos olive:name-associatedText "CEO"^^xsd:string). This is meant to be a general super-property that covers sub-properties like olive:title and olive:certificationText.
:JeffBezos olive:name-associatedText "CEO"^^xsd:string
has the given name
(:LivingThing1 olive:name-first "FIRSTNAME"^^xsd:string) means that LivingThing1 has a first name of "FIRSTNAME". For example, (:BabeRuth olive:name-first "George"^^xsd:string).
:BabeRuth olive:name-first "George"^^xsd:string
(:LivingThing1 olive:name-firstAlt "FIRSTNAME"^^xsd:string) means that LivingThing1 has a non-preferred first name of "FIRSTNAME". For example, (:BabeRuth olive:name-firstAlt "George"^^xsd:string).
:BabeRuth olive:name-firstAlt "George"^^xsd:string
(:LivingThing1 olive:name-firstInitial "F"^^xsd:string) means that LivingThing1 has a first name initial of F . For example, (:BabeRuth olive:name-firstInitial "G"^^xsd:string).
:BabeRuth olive:name-firstInitial "G"^^xsd:string
has a former last name of
has a former family name of
has the former surname of
(:LivingThing1 olive:name-formerLast "LASTNAME"^^xsd:string) means that LivingThing1 has a former last name of "LASTNAME". For example, (:JadaPinkettSmith olive:name-formerLast "Pinkett"^^xsd:string).
:JadaPinkettSmith olive:name-formerLast "Pinkett"^^xsd:string
has a former legal name of
(:Agent1 olive:name-formerLegal "NAME"^^xsd:string) means that Agent1 has a former last name of "NAME". For example, (:JadaPinkettSmith olive:name-formerLegal "Jada Pinkett"^^xsd:string).
:JadaPinkettSmith olive:name-formerLegal "Jada Pinkett"^^xsd:string
has a full name of
(:LivingThing1 olive:name-full "NAME"^^xsd:string) means that LivingThing1 has the full name of "NAME". For example, (:BabeRuth olive:name-full "George Herman Ruth"^^xsd:string).
:BabeRuth olive:name-full "George Herman Ruth"^^xsd:string
has a last name of
has a family name of
has the surname of
(:LivingThing1 olive:name-last "LASTNAME"^^xsd:string) means that LivingThing1 has a last name of "LASTNAME". For example, (:BabeRuth olive:name-last "Ruth"^^xsd:string).
:BabeRuth olive:name-last "Ruth"^^xsd:string
has an alternative last name of
has an alternative family name of
has the alternative surname of
(:LivingThing1 olive:name-lastAlt "LASTNAME"^^xsd:string) means that LivingThing1 has an alternative last name of "LASTNAME". For example, (:JadaPinkettSmith olive:name-lastAlt "Pinkett"^^xsd:string).
:JadaPinkettSmith olive:name-lastAlt "Pinkett"^^xsd:string
(:LivingThing1 olive:name-lastInitial "F"^^xsd:string) means that LivingThing1 has a last name initial of F . For example, (:BabeRuth olive:name-lastInitial "R"^^xsd:string).
:BabeRuth olive:name-lastInitial "R"^^xsd:string
has the legal name
(:Agent olive:name-legal "NAME"^^xsd:string) means that Agent has a legal name of "NAME". For example, (:AmazonInc olive:name-legal "Amazon.com, Inc"^^xsd:string). Note that this property is intended to be general enough to cover names of, e.g., organizations.
:AmazonInc olive:name-legal "Amazon.com, Inc"^^xsd:string
is identified in Namely as
(:Professional1 olive:namelyHref "STRING"xsd:string) means that Professional1 is identified in Namely as STRING. For example, (:JustinDowdy olive:namelyHref "d30c7333-97kw-4887-a24l-1c6b5f0b4jl2"^^xsd:string).
has a middle name of
(:LivingThing1 olive:name-middle "MIDDLENAME"^^xsd:string) means that LivingThing1 has a middle name of "MIDDLENAME". For example, (:BabeRuth olive:name-middle "Herman"^^xsd:string).
:BabeRuth olive:name-middle "Herman"^^xsd:string
(:LivingThing1 olive:name-middleAlt "MIDDLENAME"^^xsd:string) means that LivingThing1 has a non-preferred middle name of "MIDDLENAME". For example, (:BabeRuth olive:name-middleAlt "Herman"^^xsd:string).
:BabeRuth olive:name-middleAlt "Herman"^^xsd:string
(:LivingThing1 olive:name-middleInitial "F"^^xsd:string) means that LivingThing1 has a middle name initial of F . For example, (:BabeRuth olive:name-middleInitial "H"^^xsd:string). Note that individuals may have multiple middle names, so this property is not functional.
:BabeRuth olive:name-middleInitial "H"^^xsd:string
has a nickname of
is nicknamed
(:Thing1 olive:name-nickname "NICKNAMENAME"^^xsd:string) means that Thing1 has a nickname name of "NICKNAMENAME". For example, (:BabeRuth olive:name-nickname "Babe"^^xsd:string). As opposed to the other olive-name* properties, this has a broad domain of owl:Thing. This is intentional, though may be revised at a later date (in which case this comment should be changed). The reasoning is that, say, a car can't really have a name in the same sense that a person can. We might call our car 'Thunder' or some such, but this isn't a first or last name; it's just a nickname. This property may often coincide with the documentation properties like rdfs:label, skos:prefLabel, and so on.
:BabeRuth olive:name-nickname "Babe"^^xsd:string
(:Agent olive:name-operating "NAME"^^xsd:string) means that Agent operates under the name of "NAME". Typically this will be used for names under which some agent operates professionally (and often when the professional/business name differs from the legal name - see name-legal). For example, (:AmazonInc olive:name-operating "Amazon"^^xsd:string).
:AmazonInc olive:name-operating "Amazon"^^xsd:string
has a name prefix of
(:LivingThing1 olive:name-prefix "PREFIX"^^xsd:string) means that LivingThing1 has a name prefix of "PREFIX". For example, (:BabeRuth olive:name-prefix "Mr."^^xsd:string).
:BabeRuth olive:name-prefix "Mr."^^xsd:string
(:LivingThing1 olive:name-prefixAlt "PREFIX"^^xsd:string) means that LivingThing1 has a name prefix of "PREFIX". For example, (:BabeRuth olive:name-prefixAlt "Mr."^^xsd:string).
:BabeRuth olive:name-prefixAlt "Mr."^^xsd:string
has a professional last name of
(:LivingThing1 olive:name-professionalLast "LASTNAME"^^xsd:string) means that LivingThing1 has a professional last name of "LASTNAME". For example, (:DeclanMcManus olive:name-last "Costello"^^xsd:string).
:DeclanMcManus olive:name-professionalLast "Costello"^^xsd:string
has a name suffix of
(:LivingThing1 olive:name-suffix "SUFFIX") means that LivingThing1 has a name suffix of "SUFFIX". For example, (:BabeRuth olive:name-suffix "Jr."^^xsd:string).
:BabeRuth olive:name-suffix "Jr."^^xsd:string
(:LivingThing1 olive:name-suffixAlt "SUFFIX") means that LivingThing1 has a name suffix of "SUFFIX". For example, (:BabeRuth olive:name-suffixAlt "Jr."^^xsd:string).
:BabeRuth olive:name-suffixAlt "Jr."^^xsd:string
is near
(:PhysicalThing1 olive:near :PhysicalThing1) means that PhysicalThing1 is near PhysicalThing1. For example, (:MyHouse olive:near :HellOrHighWaterBrewery) means that my place is close to said brewery. Of course, this is a notoriously subjective property. My father would always say that we were near the end of the hike, and frequently I would have disagreed with him if I knew how much longer I had to go. Use subproperties when appropriate. Also be wary of such a contingent property. I'm close to my keyboard now, but I won't be once I clock out for the day. If you are making this assertion in a context that will change in time, you might lead someone astray. But if you are giving directions to a location, it's pretty reasonable to assume the gas station on the main road will be there for long enough to use it as a nearby landmark.
:MyHouse olive:near :HellOrHighWaterBrewery
(:Thing1 olive:note "NOTE"^^xsd:string) means that NOTE conveys some information about Thing1. For example, (:Elizabeth olive:note "wants pony for Christmas"^^xsd:string) helps convey that Elizabeth wants a pony for Christmas. That said, remember that olive:note doesn't, by itself, have any meaning in the ontology. Much better for the Elizabeth case would be to assert triples involving Elizabeth, ponies, and her desires, rather than merely linking her to string that humans can interpret.
:Elizabeth olive:note "wants pony for Christmas"^^xsd:string
has the legal note:
(:Thing1 olive:note-Legal "STRING"xsd:string) means that Thing1 has the legal note: STRING. For example, (:Graph12 olive:note-Legal "This graph should only be used for patient care purposes."^^xsd:string).
:Graph12 olive:note-Legal "This graph should only be used for patient care purposes."^^xsd:string
This property is just like olive:note, except that it conveys that this note is structured in such a way that the information might easily be converted to more meanigful triples. For example, (:Bill olive:note-Structured "Bill, 27"^^xsd:string) is pretty easily deconstructed into two triples that reflect Bill's first name and age, respectively.
:Bill olive:note-Structured "Bill, 27"^^xsd:string
This property is just like olive:note, except that it conveys specifically what things need to be done regarding the thing in question. For example, (:My86Civic olive:note-ToDo "change the timing belt before it hits 112k miles"^^xsd:string). Like other notes, these are strings and not things, and so we should be careful not to lean on this property for semantic use. But it's a very useful property for columns in spreadsheets or other emails that have action items to capture the free text.
:My86Civic olive:note-ToDo "change the timing belt before it hits 112k miles"^^xsd:string
This links a covered medical care provider with their National Provider Identifier Standard number. For example, (:DrRice olive:npi "1203456789"^^xsd:string).
:DrRice olive:npi "1203456789"^^xsd:string
has a NUCC taxonomy code of
(:MedicalCareProvider1 olive:nuccTaxonomyCode "STRING"xsd:string) means that MedicalCareProvider1 has a NUCC taxonomy code of STRING. For example, (:DrSmith olive:nuccTaxonomyCode "207Q00000X"^^xsd:string).
:DrSmith olive:nuccTaxonomyCode "207Q00000X"^^xsd:string
has the numerator unit of
Relates a RatioUnit such as meter(s)/second to the numerator Unit (e.g. meter).
occupies
occurs at/in
The geospatial place where something happened or will happen
has a profile at
(:Agent1 olive:onlineProfile "STRING"xsd:string) means that Agent1 has a profile at STRING. For example, (:CaseyHart olive:onlineProfile "https://www.linkedin.com/in/casey-hart-7a032ba4/"^^xsd:string).
:CaseyHart olive:onlineProfile "https://www.linkedin.com/in/casey-hart-7a032ba4/"^^xsd:string
operates in
(:Agent1 olive:operatesIn :Place1) means that Agent1 performs at least some of its essential activities in Place1. This is a broad notion, but it is meant to capture the sense in which, e.g., businesses may conduct business in a given region (or at a specific address) as well as, e.g., criminals may carry out crimes in a given region. For example (:Olive olive:operatesIn :ColumbusOH) means that Olive carries out at least some of its essential functions in Columbus, OH. In many cases it will be more appropriate to use (or create and use) a subproperty of this one to express the facts of the matter precisely.
has as a member at least one
(:Organization1 olive:orgHasMemberOfType :Class1) means that Organization1 has at least one member that is an instance of Class1. For example, (:NicksOrganization olive:orgHasMemberOfType olive:Doctor) means that at least one doctor is a member of Nick's organization.
:NicksOrganization olive:orgHasMemberOfType olive:Doctor
primarily has members that are
(:Organization1 olive:orgHasMembersPrimarilyOfType :Class1) means that the members of Organization1 are primarily instances of Class1. For example, (:NicksOrganization olive:orgHasMembersPrimarilyOfType olive:Doctor) means the members of Nick's organization are primarily doctors.
:NicksOrganization olive:orgHasMembersPrimarilyOfType olive:Doctor
can be contacted via
is represented by
(:Org1 olive:organizationContact :Person1) means that you can contact Person1 as a representative of Org1. For example, (:UCDavis olive:organizationContact :JennySmith) means that one could contact Jenny Smith in order to interact with UCDavis. We assume that contacts are employed by the organizations that they are contacts for. Further, note that contact persons will be relative to one's purpose and organization. In many cases, organizations will have separate contacts for each of their clients, say. In such cases, you will want further disambiguating information, such as which projects they oversee. Still, even in a situation where you don't know which contact is the best fit, it's likely that reaching out to any contact for a given company will be fruitful in getting redirected to the right resource.
:UCDavis olive:organizationContact :JennySmith
is organized by
(:Event1 olive:organizedBy :Agent1) means that Event1 was organized by Agent1. For example, (:MySurpriseParty olive:organizedBy :MyMom) means that my mother organized my suprise party. This property can also be used to relate events to companies or government agencies that organize them, such as Pfizer or the FDA.
:MySurpriseParty olive:organizedBy :MyMom
(:_Organization_1 olive:orgSite :_Place_1) means that Organization1 operates out of Place1. For example, (:CIA olive:orgSite :ThePentagon). This property is not functional; organizations may operate out of many buildings, and many organizations may operate out of the same building. Often an organization may own (see olive:owns) the building. More specific notions would include identifying a headquarters, which would be functional. This property enables one to connect the closely related notions of an organization and where that organization is. Often people will talk about going to the hospital and paying the hospital. But these 'the hospital' terms refer to different things. You go to the location, and you pay the organization.
owns
(:Agent1 olive:owns :Thing1) means that Agent1 has (partial) legal ownership of Thing1.
overlaps
(:Place1 olive:overlapsSpatially :Place2) means that Place1 and Place2 spatially overlap each other, including the case in which Place1 spatially contains Place2 (or vice versa). For example, (:Arkansas olive:overlapsSpatially :UnitedStatesOfAmerica) means that Arkansas spatially overlaps the United States of America.
:Arkansas olive:overlapsSpatially :UnitedStatesOfAmerica
has had the following amount paid:
(:PayingForSomething1 olive:paidAmount :Monetary1) means that Monetary1 has been paid during PayingForSomething1. For example, (:PayingForMyCar olive:paidAmount [a olive:Monetary ; olive:decimalValue "8000"^^xsd:decimal ; olive:hasUoM olive:_USDollar]) means that I have paid $8000 off my car during the noted payment event. Note that I may have paid more than this in previous payment events.
:PayingForMyCar olive:paidAmount [a olive:Monetary ; olive:decimalValue "8000"^^xsd:decimal ; olive:hasUoM olive:_USDollar]
was paid by
(:PayingForSomething1 olive:paidBy :Agent1) means that PayingForSomething1 was paid by Agent1. For example, (:PayingForDinner olive:paidBy :Jerry) means that Jerry paid for dinner.
was paid to
(:PayingForSomething1 olive:paidTo :Agent1) means that PayingForSomething1 was paid to Agent1. For example, (:PayingForDinner olive:paidTo :Tortianos) means that Tortiano's was the recipient of the dinner payment.
:PayingForDinner olive:paidTo :Tortianos
was paid via
Relates a payment event with the thing that was used to pay, such as cash, a credit card, or a check. For example, (:Purchase23 olive:paidWith :Check25) means that that purchase was completed using that check.
is a parent of
(:LivingThing1 olive:parentOf :LivingThing2) means that LivingThing1 is a (biological) parent of LivingThing2. For example, (:CaseyHart olive:parentOf :JulietteHart) means that Casey is Juliette's parent.
is a partner of
(:Agent1 olive:partners :Agent2) means that, in some sense, Agent1 and Agent2 are partners. For example, (:Batman olive:partners :Robin) means that Batman and Robin are, in some sense, partners. This is a fairly general property - it is preferable to use one of its subproperties when representing knowledge whenever possible. It is also sometimes preferable to represent the relationship itself (see olive:Partnership) instead of asserting a direct link between partners using olive:partners or one of its subproperties.
is providing service to
(:Provider1 olive:patientCensus "NUM"^^xsd:integer) means that Provider1 is providing service to NUM patients. For example, (:GoodSamaritanER olive:patientCensus "23"^^xsd:integer) means that Good Sam has 23 patients in the ER.
:GoodSamaritanER olive:patientCensus "23"^^xsd:integer
provides service to an average of
(:Provider1 olive:patientCensus-DailyAverage "NUM"^^xsd:integer) means that Provider1 provides service to an average of NUM patients per day. For example, (:GoodSamaritanER olive:patientCensus-DailyAverage "112"^^xsd:integer) means that Good Sam has 112 patients in the ER every day, on average.
:GoodSamaritanER olive:patientCensus-DailyAverage "112"^^xsd:integer
concludes with the patient engaged in
(:MedicalCareEvent1 olive:patientDischargedTo :Event1) means that MedicalCareEvent1 concludes with the patient engaged in Event1. This property allows us to specify patient discharge dispositions. For example, (:RisingsACLSurgery olive:patientDischargedTo [a olive:HomeCareEvent]) indicates that the patient (Rising) in Rising's ACL Surgery ended that event and continued on as a patient in a home care event.
:RisingsACLSurgery olive:patientDischargedTo [a olive:HomeCareEvent]
is the patient mentioned in
(:Patient1 olive:patientForClaim :InsuranceClaim1) means that Patient1 is the patient mentioned in InsuranceClaim1. For example, (:JoeSmith olive:patientForClaim :Claim27) means that Claim27 is about a patient visit by Joe Smith.
:JoeSmith olive:patientForClaim :Claim27
is a patient classified as
(:Patient1 olive:patientStatusCode "CODE"^^xsd:integer) means that Patient1 has the status/disposition indicated by CODE. For example, (:Alice olive:patientStatusCode "02"^^xsd:integer) means that Alice was discharged/transferred to a short-term general hospital or inpatient care.
:Alice olive:patientStatusCode "02"^^xsd:integer
has the opportunity amount
(:Monetary1 olive:paymentOpportunityAmount "DECIMAL"xsd:decimal) means that Monetary1 has the opportunity amount DECIMAL. For example, ([olive:Monetary; olive:decimalValue "25"^^xsd:decimal; olive:hasUoM olive:_USDollar] olive:paymentOpportunityAmount "12"^^xsd:decimal) would mean that the inital amount has 12 more recoverable US dollars. The opportunity amount is simply the difference between the adjusted amount (see olive:adjustedCost) and what has been paid (see olive:paidAmount).
[olive:Monetary; olive:decimalValue "25"^^xsd:decimal; olive:hasUoM olive:_USDollar] olive:paymentOpportunityAmount "12"^^xsd:decimal
pays for
This is the subproperty of olive:payingForThing that restricts the thing paid for to an insurance claim.
(:PayingForSomething1 olive:payingForThing :Thing1) means that PayingForSomething1 pays for Thing1. For example, (:PayingForMyCar olive:payingForThing :MyCar).
:PayingForMyCar olive:payingForThing :MyCar
(:Agent1 olive:personalInformation :Thing1) means that Agent1 can be personally described by, in part, their relationship to Thing1. For example, (:Freddy olive:personalInformation :MadridSpain) is true in virtue of Fredy being educated in Madrid. This is a very broad property, and almost certainly you should use a more specific subproperty. For example, relate a person to their address using olive:hasCommunicationAddress, or a person to their alma mater via olive:almunusOf. This property is not identical to things that show up in PHI, but is closely related. TODO: flesh out this connection.
:Freddy olive:personalInformation :MadridSpain
(:PhoneNumber1 olive:phoneNumber "NUM"^^xsd:string) means that "NUM" can be used to call PhoneNumber. For example, (:Bill olive:phoneNumber "122345260982"xsd:string) shows you what you might dial to reach Bill.
:Bill olive:phoneNumber "122345260982"xsd:string
can be reached by fax via
(:PhysicalAddress1 olive:physicalAddressHasFaxNumber :TelephoneNumber1) means that :PhysicalAddress1 is associated with :TelephoneNumber1. For example, (:PhysicalAdress1234 olive:physicalAddressHasFaxNumber :TelephoneNumber8675309) means that PhysicalAddress1234 can be reached/communicated with by fax via TelephoneNumber8675309.
:PhysicalAdress1234 olive:physicalAddressHasFaxNumber :TelephoneNumber8675309
can be reached by telephone via
(:PhysicalAddress1 olive:physicalAddressHasPhoneNumber :TelephoneNumber1) means that :PhysicalAddress1 is associated with :TelephoneNumber1. For example, (:PhysicalAdress1234 olive:physicalAddressHasPhoneNumber :TelephoneNumber8675309) means that PhysicalAddress1234 can be reached/communicated with by phone via TelephoneNumber8675309.
:PhysicalAdress1234 olive:physicalAddressHasPhoneNumber :TelephoneNumber8675309
can be reached via
(:PhysicalAddress1 olive:physicalAddressHasVirtualAddress :VirtualAddress1) means that :PhysicalAddress1 is associated with :VirtualAddress1 (e.g. an instance of olive-TelephoneNumber). For example, (:PhysicalAdress1234 olive:physicalAddressHasVirtualAddress :TelephoneNumber8675309) means that PhysicalAddress1234 can be reached/communicated with virtually via TelephoneNumber8675309.
:PhysicalAdress1234 olive:physicalAddressHasVirtualAddress :TelephoneNumber8675309
A subproperty of olive:contains that is specific to places.
(:_InsurancePolicy_1 olive:policyForClaim :_InsuranceClaim_1) means that InsuranceClaim1 is based on, or governed by, the agreement InsurancePolicy1. For example, (:BobsPolicy olive:policyForClaim :BobsClaim) would mean that Bob's claim is based on his insurance policy. Usually this will be a straightforward connection, since most people have at most one insurance policy of each type (e.g. health, homeowners, car), and so claims of that type will be based on their only relevant policy. Note that this is inversely functional, but that does not mean that policyholders hold exactly one insurance policy. If one is covered by two health insurance policies, they may need to file two distinct insurance claims.
:BobsPolicy olive:policyForClaim :BobsClaim
is under
(:InsurancePolicy1 olive:policyUnderPlan :InsurancePlan1) means that InsurancePolicy1 is under InsurancePlan1. For example, (:JoesPolicy22 olive:policyUnderPlan :CignaTexasGoldPlan).
:JoesPolicy22 olive:policyUnderPlan :CignaTexasGoldPlan
has the postal code
This is a datatype property that links a person/place/address with the postal code in which it is located. Note that this property is more general than olive:zipCode and is designed to handle global postal codes. When possible, we'd prefer to list the full address. For example, (:Person1 olive:postalCode "98372"^^xsd:string) indicates that Person1 is somehow affiliated with the 98372 postal code; perhaps they live there, or are currently at that location, or have a business incorporated in that location.
:Person1 olive:postalCode "98372"^^xsd:string
follows
(:InsurancePolicy1 olive:policyPlanName "STRING"xsd:string) means that InsurancePolicy1 follows STRING. For example, (:MyInsPolicy1234 olive:policyPlanName "Cigna PPO"^^xsd:string).
:MyInsPolicy1234 olive:policyPlanName "Cigna PPO"^^xsd:string
A generic ordering relation indicating that the Subject has the same order as or comes before the Object. The 'greater than or equal to' symbol is often used for this relation.
is inconsistent with
precludes
disallows
is logically inconsistent with
logically precludes
logically disallows
(:CommitmentOrIntention1 olive:precludes :Situation1) means that :Situation1 is logically inconsistent with CommitmentOrIntention1 such that CommitmentOrIntention1 cannot be satisfied while Situation1 obtains. For example, (:MyDesireToLoseWeight olive:precludes :MyEatingAPieceOfPie) means that the content of my desire to lose weight is logically inconsistent with a particular event in which I eat a piece of pie. Note that this notion of "precludes" is a logical and NOT a causal one, although sometimes these logical preclusions also yield causal ones: my goal to lose weight is inconsistent with, say, my eating a piece of pie, and having that goal might cause me to abstain from eating pie; likewise, a piece of legislation that prohibits jaywalking may also have the effect that people do not jaywalk. But notice that these notions come apart. Very ineffective legislation may preclude behaviors in the sense that the legislation is logically inconsistent with the behavior, even if that legislation has no causal impact on the actual frequency of that behavior.
:MyDesireToLoseWeight olive:precludes :MyEatingAPieceOfPie
(:Event1 olive:prevents :Event2) means that Event1 prevents Event2. While causation and prevention is a complex issue, the goal of this property is to capture the intuitive sense of 'prevent'. For example, (:BillBreakingHisLeg olive:prevents :BillFinishingTheRace) indicates that Bill didn't finish the race because he broke his leg. Prevention here means (at least) partial prevention. Striking a match may fail to get it to light if the match is wet. But it may also fail because there is insufficient oxygen in the environment. Note that prevention is essentially causing something to not happen. So this property is closely related to olive:causes. See that comment for discussion on the domain and range being events.
:BillBreakingHisLeg olive:prevents :BillFinishingTheRace
is primarily about
primary subject
(:Content1 olive:primarilyAbout :Thing1) means that the primary focus of Content1 is Thing1. For example, (:TheDefinitiveDiana-Book olive:primarilyAbout :PrincessDiana). This property is just a functional version of olive:about.
:TheDefinitiveDiana-Book olive:primarilyAbout :PrincessDiana
(:_Field_1 olive:primaryKeyField :_Table_1) means that Field1 is the primary key for Table1. This property is reserved for cases where a single field is the primary key. In cases where the key is made up of multiple fields, another property must be used.
:_Field_1 olive:primaryKeyField :_Table_1
has a priority score of
(:Status1 olive:priorityScore "NUM"^^xsd:decimal) means that artifacts with (see olive:hasStatus) Status1 have a priority of NUM. For example, (olive:Status-Build olive:priorityScore "120"^^xsd:decimal).
olive:Status-Build olive:priorityScore "120"^^xsd:decimal
(:Agent1 olive:producerOf :Content1) means that Agent1 produced Content1. For example, (:KennethUtt olive:producerOf :SilenceOfTheLambs).
:KennethUtt olive:producerOf :SilenceOfTheLambs
prohibits
is violated by
proscribes
forbids
(:Commitment1 olive:prohibits :Situation1) means that :Situation1 violates a normative prohibition expressed in Commitment1. For example, (:TheFifthAmendmentToTheUSConstitution olive:prohibits :MyBeingCompelledToTestifyAgainstMyselfInCourtOn12-21-2021) means a specific case in which I am compelled to testify against myself in court violates the content of the fifth amendment to the US Constitution. Note that this is a normative notion - it entails the logical notion represented by olive:precludes, but, crucially, it is not a causal notion.
:TheFifthAmendmentToTheUSConstitution olive:precludes :MyBeingCompelledToTestifyAgainstMyselfInCourtOn12-21-2021
contains the following number of properties:
(:KnowledgeGraph1 olive:propertyCount "INTEGER"xsd:integer) means that KnowledgeGraph1 contains the following number of properties: INTEGER. For example, (:Graph21 olive:propertyCount "12"^^xsd:integer) means that Graph21 has 12 properties. Note that this includes object, datatype, and annotation properties.
:Graph21 olive:propertyCount "12"^^xsd:integer
property expresses sensitive information
expresses the following sensitive information:
(PROP olive:propertyExpressesSensitiveInformation SENSITIVE-INFO) means that for any triple of the form (SUBJ PROP OBJ), OBJ is sensitive information of the sort SENSITIVE-INFO. Note that this is an annotation property. At this point, the meaning of the property is not enforced by inference.
olive:hasSSN olive:propertyExpressesSensitiveInformation olive:SensitiveInfo-PHI
occurs in some sequence of properties in the following place number:
(:Property1 olive:propertySequenceNumber "N"^^xsd:nonNegativeInteger) means that Property1 occurs as the Nth member of some property sequence. For example, (olive:npiNUCCProviderTaxonomyCode-3 olive:propertySequenceNumber "3"^^xsd:nonNegativeInteger) means that olive:npiNUCCProviderTaxonomyCode-3 is the third element of some property sequence.
olive:npiNUCCProviderTaxonomyCode-3 olive:propertySequenceNumber "3"^^xsd:nonNegativeInteger
has meaning that can be (partly) denoting using
(:_Field_A olive:propertyRelevantToField PROP) means that part of the logical meaning of FieldA can be communicated by making assertions using PROP. Suppose that you had a gradebook with a field "leter_grade" in :FieldG. Then you could show that this meaning was captured by some :finalLetterGrade property by stating (:FieldG olive:propertyRelevantToField :finalLetterGrade). Note that this is an annotation property. At this point, the property only documents the meaning. It does not enforce it via inference.
:FieldG olive:propertyRelevantToField :finalLetterGrade
has as its object
(:Proposition1 olive:propositionObject :Thing1) means that the content of Proposition1 is expressable as a triple with Thing1 in the object place. See also olive:Proposition, olive:propositionSubject, and olive:propositionProperty.
has as its property
(:Proposition1 olive:propositionProperty :Property1) means that the content of Proposition1 is expressable as a triple with Property1 in the property place. See also olive:Proposition, olive:propositionObject, and olive:propositionSubject.
has as its subject
(:Proposition1 olive:propositionSubject :Thing1) means that the content of Proposition1 is expressable as a triple with Thing1 in the subject place. See also olive:Proposition, olive:propositionObject, and olive:propositionProperty.
is the provider for
(:MedicalCareProvider1 olive:providerForClaim :InsuranceClaim1) means that MedicalCareProvider1 is the provider for InsuranceClaim1. For example, (:MeriterHospital olive:providerForClaim :Claim257) means that Meriter was the provider for the medical care event(s) that are the basis for Claim257.
:MeriterHospital olive:providerForClaim :Claim257
was published in
This is the datatype version of olive:hasPublicationDate, where it relates a given piece of content to the year in which it was published. For example (:TheGreatGatsby olive:publicationYear "1925"^^xsd:integer).
:TheGreatGatsby olive:publicationYear "1925"^^xsd:integer
(:Agent1 olive:publisherOf :Content1) means that Agent1 published Content1. For example, (:LittleBrownAndCompany olive:publisherOf :CatcherInTheRye).
:LittleBrownAndCompany olive:publisherOf :CatcherInTheRye
converts to a decimal value of
(:Assessment1 olive:qagConversion "NUM"^^xsd:decimal) means that Assessment1 can be converted to the decimal NUM. This is a way of converting things like olive:Amount-Low to .25, olive:Amount-Medium to .5, and so on. Of course, these values won't be correct in every circumstance, as qualitative assessments. However, it does allow us to order the amounts and do some rough back-of-the-napkin math to draw conclusions from qualitative assessments.
olive:Amount-Low olive:qagConversion ".25"^^xsd:decimal
has the qualitative amount:
(:Thing1 olive:qualitativeStrength :Assessment1) means that Thing1 has the strength of Assessment1. For example, suppose I am recommending a realtor for you to use, and I think they are pretty good, but not amazing. Then we might say (:RealtorRecommendation olive:qualitativeStrength olive:ModeratelyHigh). Qualitative assessments are tricky. They are frequently contextual (I feel moderately warm right now, but I might feel warmer/cooler depending on the temperature outside.). However, they are important for accurately reporting people's assessments of things, as often folks will say they 'really like' something rather than assigning it a score of 72 on a 100 point scale. On the other hand, you might prefer to translate qualitative reports to quantitative ones in this way to make calculations easier in the future.
:RealtorRecommendation olive:qualitativeStrength olive:ModeratelyHigh
has a strength of
(:Thing1 olive:quantitativeStrength NUM) means that Thing1 is NUM strong. For example, (:RealtorRecommendation olive:quantitativeStrength ".72"^^xsd:decimal) means that the realtor recommendation has a strength of .72. This property is a datatype variant of olive:hasMagnitude. It takes one directly to the numeric strength rather than being mediated by a magnitude. There is no constraint on what a given strength means: how do I interpret .72 as a strength? By default, assume that strengths are bound from 0 to 1, with .5 being neutral, 0 being as strongly negative, and 1 being as strongly positive as one can be. This follows the probability calculus: assigning a probability of 0 means certainty that the thing is false/won't happen, 1 that it is certainly true/will happen.
:RealtorRecommendation olive:quantitativeStrength ".72"^^xsd:decimal
is intended to query
(:Query1 olive:olive:queriesDatabase :Database1) means that Query1 is intended to query Database1. For example, (:UMLSQuery olive:olive:queriesDatabase :UMLSDB). Note that even though the query is intended for a given database doesn't mean that it cannot be run against other DBs. This property is not functional, and as such it could be documented as intended for multiple DBs.
:UMLSQuery olive:olive:queriesDatabase :UMLSDB
(:Query1 olive:queriesGraph :KnowledgeGraph1) means that Query1 is intended to query KnowledgeGraph1. For example, (:UMLSQuery olive:queriesGraph :UMLSGraph). Note that even though the query is intended for a given knowledge graph doesn't mean that it cannot be run against other graphs. This is not functional, and as such it could be intended for multiple graphs.
:UMLSQuery olive:queriesGraph :UMLSGraph
has a privacy boolean of
(:Query1 olive:queryPrivacyBoolean "BOOLEAN"xsd:boolean) means that Query1 has a privacy boolean of BOOLEAN. For example, (:UMLSQuery olive:queryPrivacyBoolean "false"^^xsd:boolean) means that the UMLS query is not private, which is to say that it is accessible to all users of the system.
:UMLSQuery olive:queryPrivacyBoolean "false"^^xsd:boolean
has the following query sentence:
(:Query1 olive:querySentence "STRING"xsd:string) means that Query1 has the following query sentence: STRING. For example, (:UMLSQuery olive:querySentence "SELECT DISTINCT ?lcase_out.... = "en")}"^^xsd:string).
:UMLSQuery olive:querySentence "SELECT DISTINCT ?lcase_out.... = "en")}"^^xsd:string
is a
(:Resource1 olive:quotedCategorizedBy :OntologyTermType1) means that Resource1 is a OntologyTermType1. For example, (:BikeMessenger olive:quotedCategorizedBy :StubTerm). Note the 'quoted'. This is because this property mentions rather than uses the resource. We aren't saying that every bike messenger, or even that the concept of bike messenger, is stubby. We are saying that the term as it exists in the ontology is stubby. Of course, this status may change as the class gets fleshed out. Make sure to update these assertions when the ontology changes!
:BikeMessenger olive:quotedCategorizedBy olive:StubTerm
has a reasoning boolean of
(:Query1 olive:reasoningBoolean "BOOLEAN"xsd:boolean) means that Query1 has a reasoning boolean of BOOLEAN. For example, (:UMLSQuery olive:reasoningBoolean "true"^^xsd:boolean) would mean that UMLSQuery uses reasoning.
:UMLSQuery olive:reasoningBoolean "true"^^xsd:boolean
uses a reasoning level of
(:Query-SPARQL1 olive:reasoningLevel :ReasoningLevel1) means that Query-SPARQL1 uses a reasoning level of ReasoningLevel1. For example, (:UMLSQuery olive:reasoningLevel olive:SL-ReasoningLevel) would mean that the UMLS query uses SL reasoning.
:UMLSQuery olive:reasoningLevel olive:SL-ReasoningLevel
has the following reactivation date:
This links an individual with the date on which it was reactivated. For example (:DrRicesNPI olive:reactivationDate [olive:universalDate "02-13-2021"^^xsd:date]).
:DrRicesNPI olive:reactivationDate [olive:universalDate "02-13-2021"^^xsd:date]
recognizes the legitimacy of
(:Agent1 olive:recognizes :Agent2) means that Agent1 formally acknowledges the standing of Agent2, such as when the UN recognizes a sovereign nation; (:UN olive:recognizes :Uruguay). It can also be less formal, such as when Kanye reocgnizes an artist as being good. It implies the authority on the part of the recognizer over the recognized, and as such is a subproperty of olive:governs.
includes a recommendation regarding
(:Recommendation1 olive:recommendedThing :Thing1) means that Recommendation1 is (partly) a recommendation for Thing1. For example, (:DrRecommendatioon olive:recommendedThing :DrRice) means that Dr Rice is being recommended. Despite the usual connotation of 'recommended', recommendations can be both positive and negative. So, you need to see the degree of the recommendation to know whether, say, we are approving of Dr Rice or discouraging using her as your physician.
:DrRecommendatioon olive:recommendedThing :DrRice
is given to
(:Recommendation1 olive:recommendedTo :Agent1) means that Agent1 is the intended recipient of Recommendation1. For example, (:DrRecommendation olive:recommendedTo :JoePatient) means that the Dr Recommendation is for Joe's benefit.
:DrRecommendation olive:recommendedTo :JoePatient
recommends
(:Agent1 olive:recommender :Recommendation1) means that Recommendation1 was 'authored' by Agent1. For example, (:RogerEbert olive:recommender :EbertsReviewOfMovieX) indicates that the Ebert's review was made by him. We will default assuming that all recommendations are made sincerely. Of course, there are cases where someone may try to maniuplate another with deceitful recommendations. If those turn out to be important to model, we should carefully consider creating a new class or investigate whether the semantics of olive:Recommendation are consistent with such deceitful recommendations.
:RogerEbert olive:recommender :EbertsReviewOfMovieX
was recorded at/on
This reflects the date and time (if known) that some content was recorded. Note that the recorded time may differ from the posted time.
influences
applies to
regulates
has regulatory influence over
(:Thing1 olive:regulates :Thing2) means that Thing1 has some sort of regulatory influence over Thing2, whether this influence is actual or normative/suggestive. This may be agential, as when an agent controls an object or another agent (see olive:controls), or more abstract, such as the motivational influence that a goal has on the agent whose goal it is (see olive:hasGoal) or normative force, such as the binding "influence" that a law has with respect to the actions it applies to (see olive:governsBehavior). For example, (:OliveEmployeeHandbook olive:regulates :JoeOliveEmployee) means that the Olive handbook holds influence over Joe. This can be true even if Joe disregards the handbook if it means that the handbook is normatively (perhaps legally) binding for Joe. It could also hold influence if it wasn't binding but Joe nonetheless used the handbook as a set of guidelines for his actions. This is the most general property of this sort, and as such one should often find subproperty that is more specific to a given situation. One might be tempted to make olive:affects a subproperty of this; however, as is indicated by the example from above, olive:regulates encompasses cases in which something like the content of a handbook applies to an agent or action even when that agent disregards the content of the handbook and/or the action fails to be in accordance with its prescriptions. This is a clear case in which the content of the handbook regulates the agent/action without affecting them.
:OliveEmployeeHandbook olive:regulates :JoeOliveEmployee
(:Thing1 olive:relatedToClass :Class1) means that Thing1 is somehow related to :Class1. This is an extremely general relationship (akin to skos:related) and should be used only when a more precise characterization is unavailable (and, even then, it is worth asking whether an olive:relatedToClass triple is warranted).
is a request for
(:RequestOrRequestingSomething1 olive:requestedThing :Thing1) means that RequestOrRequestingSomething1 is (partly) a request for Thing1. For example, (:Prescription23 olive:requestedThing :SampleOfVicodin) the prescription in question is for a particular sample ofVicodin. This is a peculiar property because it allows for either an instance of olive:Request (a content) or an instance of olive:RequestingSomething (an event) to stand as its subject. (For this reason, it is not a subproperty of olive:eventInvolves.) As a rule of thumb, if the information that is being represented is at the level of requester/requestee/requested only (and we don't care about representing more specific information), then it's likely best to simply use an instance of olive:RequestingSomething and relate it to the various role players via olive:conveysFrom/olive:conveysTo/olive:requestedThing. If the content of the request that needs to be represented is richer than this, then it's likely best to relate an instance of olive:Request to an instance of olive:RequestingSomething via olive:communicatedContent and use the instance of olive:Request as the focal object for modeling the nuances of the request. Compare with olive:requestedType.
:DrBobsRequestEvent olive:requestedThing :SampleOfVicodin
(:RequestOrRequestingSomething1 olive:requestedType :Type1) means that RequestOrRequestingSomething1 is (partly) a request for some instance of Class1. For example, (:Prescription23 olive:requestedType :Ibuprofen-800mg) the prescription in question is for 800mg tablets of Ibuprofen. This is a peculiar property because it allows for either an instance of olive:Request (a content) or an instance of olive:RequestingSomething (an event) to stand as its subject. As a rule of thumb, if the information that is being represented is at the level of requester/requestee/requested only (and we don't care about representing more specific information), then it's likely best to simply use an instance of olive:RequestingSomething and relate it to the various role players via olive:conveysFrom/olive:conveysTo/olive:requestedType. If the content of the request that needs to be represented is richer than this, then it's likely best to relate an instance of olive:Request to an instance of olive:RequestingSomething via olive:communicatedContent and use the instance of olive:Request as the focal object for modeling the nuances of the request. Compare with olive:requestedThing.
:DrBobsRequestEvent olive:requestedType :Vicodin
requires
(:Commitment1 olive:requires :Situation1) means that Situation1 (partly) satisfies a normative requirement of Commitment1. For example (:ParentalCommand1 olive:requires :RoomCleaning01) means that the parental command was partially satisfied by the room cleaning; Mom told me to clean my room, and so I had to.
:ParentalCommand1 olive:requires :RoomCleaning01
known to RibbonHealth as
This links some entity to the name which RibbonHealth uses consistently to name unique entities, such as Insurance Carriers.
:MyInsuranceCarrier olive:ribbonName "ACME Insurance of Oregon"^^xsd:string
has a RibbonHealth UUID of
The RibbonHealth data has a key field for 'uuid', and this allows us to pick out the same entity every time we access the RibbonHealth data. olive:ribbonUuid is reserved for this relationship.
:MyInsurancePlan olive:ribbonUuid "77f37edf-a2a8-4303-ba95-7f84ecb9e94b"^^xsd:string
has the following risk of mortality:
(:MedicalCareEvent1 olive:riskOfMortality-DRG :QualitativeAssessment1) means that MedicalCareEvent1 has the following risk of mortality: QualitativeAssessment1. For example, (:JimsHeartSurgery olive:riskOfMortality-DRG olive:Amount-High). The values are often given in integers. Here, 0 maps to minimal, 1 to low, 2 to medium, 3 to high, and 4 to maximal. We should not understand minimal as no risk or maximal as guarantees of death.
:JimsHeartSurgery olive:riskOfMortality-DRG olive:Amount-High
has the routing number
Relates a olive:Check to its routing number. Not the same as the account number (olive:accountNumber) or check number (olive:checkNumber).
:MyCheck olive:routingNumber "1125523434"^^xsd:string
(:_Table_1 olive:rowCount INT) means that Table1 has INT rows. For example, (:CaseysGradebook olive:rowCount 32) means that there are 32 rows in Casey's gradebook (likely because there are 32 students). Note that this count excludes the header of the table.
(:_Row_1 olive:rowReferent :_Thing_1) means that Row1 refers to Thing1. For example, if you had a table about student grades, likely each row would describe a student. So you could say (:_GradebookRow12 olive:rowReferent :_JimSmith) to indicate that Row12 is about Jim.
:_GradebookRow12 olive:rowReferent :_JimSmith
is the same as
We can have two local time instants refer to the same time, the same universal time.
involves (as the seller)
(:BuyingAndSelling1 olive:seller :Agent1) means that Agent1 plays the seller role in BuyingAndSelling1. For example, (:NickBuyingANewCar olive:seller :CedarParkToyota) means that Cedar Park Toyota is the seller in the event in which Nick buys a new car. Note that in cases in which the subject has no clear distinction between buyer and seller (as in a non-monetary trade), one can still make use of olive:seller to represent one of the role players in the exchange.
:NickBuyingANewCar olive:seller :CedarParkToyota
sells
(:Agent1 olive:sellsType :Class1) means that Agent1 can or does sell one or more instances of Class1. For example, (:Motorola olive:sellsType :SmartPhone). This property is meant to indicate an ongoing disposition/ability to sell.
is number
(:Thing1 olive:seriesNumber N) means that :Thing1 is the Nth number in some series. For example, (:Erkenntnis_vol_7 olive:seriesNumber "7"^^xsd:nonNegativeInteger) means that :Erkenntnis_vol_7 is the seventh in some series. This is a very general property the primary use of which is to serve as a super-property for more specific (and useful) properties, e.g. olive:volumeNumber and olive:issueNumber. As such, the latter should be preferred when directly representing knowledge.
:Erkenntnis_vol_7 olive:seriesNumber "7"^^xsd:nonNegativeInteger
has service code
(:LineItem1 olive:serviceCode "CODE"^^xsd:string) means that LineItem1 is categorized by service code CODE. For example, (:Procedure01 olive:serviceCode "D0120"^^xsd:string) indicates that Procedure01 is characterized by D0120, which can in turn be related to its indicating an oral cancer evaluation. For more specific codes, such as a CPT code or DCT code, one can create/use the appropriate subproperties.
:Procedure01 olive:serviceCode "D0120"^^xsd:string
has the condition code
The subproperty of olive:serviceCode for condition codes.
has the DRG code
Diagnosis-Related Group code
The subproperty of olive:serviceCode for Diagnosis-Related Group (DRG) codes.
has the ICD10 admitting code
The subproperty of olive:serviceCode for ICD10 admitting codes.
has the ICD10 diagnosis code
The subproperty of olive:serviceCode for ICD10 diagnosis codes.
has the ICD10 principal diagnosis code
The subproperty of olive:serviceCode for ICD10 principal diagnosis codes.
has the NUBC code
The subproperty of olive:serviceCode for National Uniform Billing Committee (NUBC) codes.
has the occurrence code
The subproperty of olive:serviceCode for occurrence codes.
has the value code
The subproperty of olive:serviceCode for value codes.
has the following severity:
(:MedicalCareEvent1 olive:severityOfIllness-DRG :QualitativeAssessment1) means that MedicalCareEvent1 has the following severity: QualitativeAssessment1. For example, (:JimsHeartSurgery olive:severityOfIllness-DRG olive:Amount-Maximal). The values are often given in integers. Here, 0 maps to minimal, 1 to low, 2 to medium, 3 to high, and 4 to maximal. These values corespond with the extent of physiological decompensation or organ system loss of function.
:JimsHeartSurgery olive:severityOfIllness-DRG olive:Amount-High
is associated in some way with a cost of
(:Situation1 olive:situationHasAssociatedMonetaryValue [olive:decimalValue "500"^^xsd:double ; olive:hasUoM olive:_USDollar ]) means that Situation1 is in some way associated with a monetary value of $500. This is a very general property and should almost never be used for making assertions (it might, however, be useful for queries).
:Situation1 olive:situationHasAssociatedMonetaryValue [olive:decimalValue "500"^^xsd:double ; olive:hasUoM olive:_USDollar ]
is an event in which the thing that is sold is
(:BuyingAndSelling1 olive:sold :Thing1) means that the thing that is sold in BuyingAndSelling1 is Thing1. Thing1 may be some sort of object, but it could also be an event (as when someone purchases a service). For example, (:BobsBuyingANewCar olive:sold :Car00111) means that Car00111 is the thing that is sold during the event of Bob buying a new car.
(:_Database_1 olive:databaseLocation "/home/Desktop/Files/example.db"^^xsd:string) means that Database1 can be found via the filepath /home/Desktop/Files/example.db. The object can be any string that denotes a location, such as an URL, physical address, or filepath. For example, (:SampleGradebook olive:sourceLocation "https://docs.google.com/spreadsheets/d/1WBOQW3Ig8CXzVpaArX3E5gdm47_ADhasUuwOn_DGVJQ/edit#gid=0"^^xsd:string) tells you the URL at which you can access the sample gradebook.
:SampleGradebook olive:sourceLocation "https://docs.google.com/spreadsheets/d/1WBOQW3Ig8CXzVpaArX3E5gdm47_ADhasUuwOn_DGVJQ/edit#gid=0"^^xsd:string
comes from a source associated with the following label:
(:Thing1 olive:sourceText "STRING"^^xsd:string) means that STRING is a label associated with the source of Thing1. For example, (:NicksAmazonOrder olive:sourceText "Amazon"^^xsd:string) means that Nicks Amazon order has a source associated with the label "Amazon". This a general property designed to allow context to determine how to identify what STRING refers to.
:NicksAmazonOrder olive:sourceText "Amazon"^^xsd:string
has a source with version
(:Artifact1 olive:sourceVersion "STRING"xsd:string) means that Artifact1 has a source with version STRING. For example, (:CPTGraph olive:sourceVersion "2011AA"^^xsd:string). This means that the CPT graph was taken from data that was version 2011AA. This is a tricky property. First off, it's unfortunately stringy. This is because versions come in all sorts of stringy formats, and it's unrealistic to expect we can generalize all of them. That said, whenever possible we want to be able to convert these strings into more semantic properties, such as olive:currentAsOf and olive:creationTime. Secondly, it is tricky because the version only derivitively applies to the subject. In the example triple, the CPT graph isn't version 2011AA, but rather the graph was taken from a source that was version 2011AA, and thus we call the graph 2011AA. This isn't too bad in that example, but it could easily get confusing if there is a first knowledge graph created for a third version of some source material. That graph would have a source version of 3.0, even if it was the first graph we created for that source material.
:CPTGraph olive:sourceVersion "2011AA"^^xsd:string
(:PhysicalThing1 olive:spatiallyRelatedTo :PhysicalThing2) means that PhysicalThing1 and PhysicalThing2 stand in some spatial relationship. This is very broad: one might be on the other, or near the other, or six million miles away from the other. Trivially, any two physical objects in the same reality, wherever they may be, will stand in a spatial relationship with one another. For this reason, almost always a more precise subproperty should be used, such as olive:placeContains to show that something is found in a location.
:PhysicalThing1 olive:spatiallyRelatedTo :PhysicalThing2
speaks
(:Person1 olive:speaksLanguage :Language1) means that Person1 speaks Language1. For example, (:DanielNaroditsky olive:speaksLanguage olive:RussianLanguage) means that Daniel speaks Russian. Of course, speaking a language is not a binary thing. Like all capabilities, one can have more or less facility with the skill in question. One may only be able to count in a language, or identify colors. Or perhaps you can only ask for coffee and where the bathroom is in French. Here we rely on the fact that it is reasonable to ask someone whether they speak French; people will say yes or no based on a common sense standard of being able to communicate in a majority of expected situations. Also note that the word 'speaks' may be a little misleading. This is the most natural way to phrase the question, but technically this property is for folks who can communicate using a language. So, someone who was fluent in ancient Greek, though they were not good at speaking it, would still truly be able to say to 'speak' the language.
:DanielNaroditsky olive:speaksLanguage olive:RussianLanguage
specializes in
(:Agent1 olive:specializesIn :Thing1) means that Agent1 specializes in Thing1. This specialty may be broad: you might specialize in treating something, or cooking something, or simply knowing a lot about something. For example, if Dr. Rice is an ontologist, then (:DrRice olive:specializesIn olive:Exemplar_Cancer). Note that frequently the domain is an instance of olive:ExemplarIndividual.
:DrRice olive:specializesIn olive:Exemplar_Cancer
(:Agent1 olive:specializesInType :Class1) means that Agent1 specializes in instances of Class1. Class1 may be a type of field, or activity, or topic - this property should be construed broadly enough to allow for any kind of thing that one could special in to stand as the object.
:DrRice olive:specializesIn olive:Surgery
primarily specializes in
(:Agent1 olive:specializesInType-primary :Class1) means that instances of Class1 are the primary speciality of Agent1; context will help to determine just what this means. Class1 may be a type of field, or activity, or topic - this property should be construed broadly enough to allow for any kind of thing that one could special in to stand as the object.
:DrRice olive:specializesIn-primary olive:Surgery
This is the 'string version' of olive:hasStatus. It links an artifact directly to the string representation of the status. Triples of this form should be used to infer the olive:hasStatus equivalent, which is the more semantic representation.
starts on/at
(:TimeInterval1 olive:startDate "DATETIME"xsd:dateTime) means that TimeInterval1 starts on/at DATETIME. For example, (:MiddleAges olive:startDate "476-01-01"^^xsd:date) shows that the Middle Ages started in 476 (roughly the fall of the Roman Empire).
:MiddleAges olive:startDate "476-01-01"^^xsd:date
(:_Event_1 olive:startOfEvent :_Time_1) means that Event1 starts/started at Time1. For example, (:_ThanksGivingDinner olive:startOfEvent [a olive:TimeInstant; olive:universalDateTime "2020-11-26T15:30:00"^^xsd:dateTime]) means that my Thanksgiving dinner starts at 3:30pm on November 26, 2020. Note that unlike olive:timeOfEvent, one cannot use the granularity to infer the duration of the event. Adding a olive:hasPrecision assertion is a way to indicate some +/- error bounds; to say an event starts at 3pm with a precision of one minute indicates the event will start anywhere between 15:00 and 15:01. Absent precision information, we assume that the time instant is maximally precise--to the second for datetimes and to the day for dates.
:_ThanksGivingDinner olive:startOfEvent [a olive:TimeInstant; olive:universalDateTime "2020-11-26T15:30:00"^^xsd:dateTime]
is a state of
(:State-Situation1 olive:stateOfThing :Thing1) means that Thing1 is the thing that is focally "in" State-Situation1. For example, (:NicksStateOfConfusion olive:stateOfThing :Nick) means that Nick is the thing that is focally in NicksStateOfConfusion. Generally speaking, this property is used for relating a state of being to the thing of which it is a state.
(:NicksStateOfConfusion olive:stateOfThing :Nick)
is a subcategory of
This is the analogue of rdfs:subClassOf for olive:Category.
Note: This is essentially the same as skos:broaderTransitive, using olive:Category instead of skos:Concept.
The subject category is included by, or narrower than, the object category. Everything categorized by the subcategory can be inferred to be categorized by the supercategory.
has the suborganization of
(:Organization1 olive:suborganization :Organization2) means that Organization1 has the suborganization of Organization2. For example, (olive:Olive olive:suborganization olive:OliveWorks).
olive:Olive olive:suborganization olive:OliveWorks
Asserts that some Content should typically be preferred to some other earlier Content. Typically both of these Contents abstract to the same instance of Versioned Content.
olive:KnowledgeGraph/MyContent/v1.1 olive:supersedes olive:KnowledgeGraph/MyContent/v1.0;
supports
justifies
(:Content1 olive:supports :Content2) means that Content1 is (or could be) used to justify Content2. For example, (:MLAlgorithm23 olive:supports :Recommendation1) means that the recommendation in question is supported by that algorithm.
:MLAlgorithm23 olive:supports :Recommendation1
(:_Thing_1 olive:tag "TAG"^^xsd:string) means that Thing1 is tagged with "TAG". For example, (:MyPatentApplication olive:tag "DENIED"^^xsd:string) indicates that my patent application has been tagged as denied. This relation should only rarely be used in isolation. To revisit the example, we don't want to just note the tag that my patent received, but rather to indicate what this tag means. So, commonly we will create new classes that are defined by an owl restriction in which something has received that tag. For example, we could create :DeniedPatent and specify that this is equivalent to, or at least a subclass of, patents that have gotten the DENIED tag. Usually one will know that there is some (small) set of tags a particular thing might receive. For patents, it might be PENDING, APPROVED, DENIED, or UNDER APPEAL. In this case, consider creating a subproperty with the appropriate domain and range constraints to enforce well-formedness.
:MyPatentApplication olive:tag "DENIED"^^xsd:string
can be replaced with a(n)
(:Variable1 olive:takesInstanceOf :Class1) means that Variable1 'stands for' an instance of Class1. For example, (:x olive:takesInstanceOf :RealNumber) would mean that x is a variable that can be bound to some real number.
can be replaced with the class of
(:Variable1 olive:takesSubClassOf :Class1) means that Variable1 'stands for' a subclass of Class1. For example, (:HospitalTypeVariable olive:takesSubClassOf olive:Hospital) would mean that HospitalType is a variable that can be bound to some subclass of olive:Hospital (e.g. olive:ChildrensHospital).
:HospitalTypeVariable olive:takesSubClassOf olive:Hospital
(:Thing_1 olive:temporallyRelatedTo :Thing_2) means that Thing1 and Thing2 bear some temporal relation to each other. This is incredibly general, and as such should rarely be used directly. Instead, you should use subproperties such as olive:precedes and olive:follows to indicate temporal ordering. This is distinct from olive:timeOf. The timeOf property tells us when things happened, whereas the temporallyRelatedTo property orients other things relative to one another in time. Compare to geography: lattitude and longitude tell us where something happens, but they do not directly tell us about the spatial relationship between, say, the Statue of Liberty and the Grand Canyon; you would use olive:spatiallyRelatedTo for that. In that sense, both temporallyRelatedTo and spatiallyRelatedTo are 'direct' properties, whereas their correlates in timeOf and latitude/longitude are mediated by time or location.
(:Test-Software1 olive:testQuery :Query1) means that Test-Software1 runs Query1. For example, (:UMLSTest olive:testQuery :UMLSQuery) links the UMLS test with the UMLS query that it runs and checks the results of.
(:Thing1 olive:text "TEXT"^^xsd:string) means that Thing1 either contains or is importantly linked to TEXT. This is a pretty broad property, which can be used for many purposes including but not limited to: relating content to its text representation, relating audio/video content to captions, relating an identifier to its unique string (see olive:uniqueText), or something to notes about that thing. For example, (:XKCDHeistsAndEscapesComic olive:text "MY PLAN FOR THE GREATEST ESCAPE ROOM GAME OF ALL TIME"^^xsd:string) to relate that xkcd comic to its caption.
:XKCDHeistsAndEscapesComic olive:text "MY PLAN FOR THE GREATEST ESCAPE ROOM GAME OF ALL TIME"^^xsd:string
(:_Event_1 olive:thingTransferred :_Thing_1) means that Thing1 is transferred from one party to another during Event1. For example, (:JillAndBobsWeddingCeremony olive:thingTransferred :JillsWeddingRing) means that Jill's wedding ring gets transferred from one person to another during her wedding ceremony. Of course, more information is important here: who had the ring first? Who was it transferred to? For those things, see olive:conveysTo and olive:conveysFrom.
:JillAndBobsWeddingCeremony olive:thingTransferred :JillsWeddingRing
(:Thing1 olive:timeOf :Time1) means that Time1 is important for Thing1. This is the most general property to relate things and events to a time. It should almost never be asserted directly. Instead, for events, use olive:timeOfEvent. For non-events, consider olive:creationTime or olive:destructionTime, among the other subclasses of olive:timeOf.
died at/on
Datetime, at whatever granularity available, that a living thing died
(:Event1 olive:timeOfEvent :Time1) means that Event1 happened at Time1. For example, (:MyEuchreGame olive:timeOfEvent [a olive:TimeInstant; olive:universalDate "2020-05-01"^^xsd:date]) would show that my euchre game happend on May 1st of 2020. Absent any distinct start and end times (see olive:startOfEvent and olive:endOfEvent), we assume that the event happened for the entire granularity of the time instant. To determine the granularity, first see whether there is a olive:hasPrecision assertion. Absent one of those, defer to the most precise significant digit in the time encoding. So, if the time given is 12:00:03, we assume it is precise to the second, but given 15:17:00 we assume the precision is to the minute. These assumptions are risky, since 10:00:00 might be to the nearest ten hours or might be precise to the hour. But, absent any further information, we have to either do without or make an educated guess. I think better here to make an educated guess. Note also that there may be multiple olive:timeOfEvent triples with the same subject and different objects, which would indicate that the relevant situation is temporally disconnected. Note that for legacy reasons this property is called "timeOfEvent" despite the fact that its domain extends to instances of olive:Situation.
:MyEuchreGame olive:timeOfEvent [a olive:TimeInstant; olive:universalDate "2020-05-01"^^xsd:date]
has the following TIN:
has the following taxpayer identification number:
This links taxpayer with their Taxpayer Identification Number. For example, (:DrRice olive:tin "212121212"^^xsd:string).
:DrRice olive:tin "212121212"^^xsd:string
is called
is entitled
is titled
(:Content1 olive:titleForContent "TITLE"^^xsd:string) means that Content1 is titled TITLE. For example, (:MyPaper olive:titleForContent "Dissolving Harman's Dogmatism Paradox"^^xsd:string). This property is functional, meaning that no content can have more than one olive:titleForContent. It is not inversely functional, as more than one piece of content may have the same title. Not to be confused with olive:titleText, which gives the title for the role of an agent (e.g. a job title).
:MyPaper olive:titleForContent "Dissolving Harman's Dogmatism Paradox"^^xsd:string
has the title:
(:Agent1 olive:titleText "STRING"^^xsd:string) means that Agent1 has the title STRING. For example, (:JeffBezos olive:title "CEO"^^xsd:string) means that Jeff Bezos has the title string "CEO". Not to be confused with olive:titleForContent.
:JeffBezos olive:titleText "CEO"^^xsd:string
is intended for
(:_thing_1 olive:toAgent :_agent_1) means that :agent_1 is the intended recipient of :_thing_1. Note that this is not the inverse of olive:fromAgent; if it were, then (:Letter1 olive:toAgent :SantaClaus) would entail that (:SantaClaus olive:fromAgent :Letter1). There is an important inverse-like relationship between 'to' and 'from', but these are mediated through the thing that is being passed along.
involves a total cost of
(:BuyingAndSelling1 olive:totalCost :Monetary1) means that BuyingAndSelling1 is an event in which the total cost of the goods bought/sold is Monetary1. For example, (ex:BuyingAndSelling111 olive:totalCost [olive:decimalValue "500"^^xsd:double ; olive:hasUoM olive:_USDollar ]) means that the focal item(s) sold in ex:BuyingAndSelling111 (see olive:itemSold) are sold for $500 US. This property is intended to allow for distinctions to be made between the cost of an item (or a type of item) and the total cost of the transaction..
ex:BuyingAndSelling111 olive:totalCost [olive:decimalValue "500"^^xsd:double ; olive:hasUoM olive:_USDollar ]
is transcribed as:
(:Content1 olive:transcript "STRING"@langugagetag) means that STRING is a way of transcribing Content1. Note that this property is not functional in order to allow for transcripts in multiple different languages.
has the following number of triples:
(:KnowledgeGraph1 olive:tripleCount "INTEGER"xsd:integer) means that KnowledgeGraph1 has the following number of triples: INTEGER. For example, (:Graph21 olive:tripleCount "2000"^^xsd:integer) means that Graph21 has 2000 triples.
:Graph21 olive:tripleCount "2000"^^xsd:integer
is, when it relates specific types of things, a subproperty of
(:Property1 olive:typedSubPropertyOf :Property2) means that Property1 is, when it relates things that satisfy the domain and range specifications of Property2, a subproperty of Property2. For example, olive:dataSensitivityDefaultLevel has as its domain olive:DataClassificationType and as its range olive:DataSensitivityLevel. If we then asserted (olive:categorizedBy olive:typedSubPropertyOf olive:dataSensitivityDefaultLevel), that would mean that (:DataClassificationType1 olive:categorizedBy :DataSensitivityLevel1) (where the subject and object are instances of the aforementioned domain and range, respectively) entails (:DataClassificationType1 olive:dataSensitivityDefaultLevel :DataSensitivityLevel1).
is primarily a
(:Thing1 olive:type-primary :Class1) means (1) (:Thing1 a :Class1) and (2) Class1 is in some sense the "primary" taxonomic classification for Thing1. For example, (:Nick type-primary olive:HumanBeing) means that in some sense Nick's primarily taxonomic classification is as a human being.
:Nick olive:type-primary olive:HumanBeing
(:UnitWhole olive:unitComponent :UnitPart) means that UnitWhole is partly constituted by UnitPart. For example, meters per second (m/s) is composed of a numerator of meter and denominator of second. So, both (:_meterspersecond olive:unitComponent :_second) and (:_meterspersecond olive:unitComponent :_meter) are true. That said, one should almost always use a more specific property. In this case, we'd use olive:denominator and olive:numerator, respectively.
:_meterspersecond olive:unitComponent :_second
(:Thing1 olive:uniqueName "NAME"^^xsd:string) means that Thing1 is uniquely referred to by NAME. For example, (:CPA12 olive:uniqueName "Galaxy Med's CPA"^^xsd:string) means that anytime you hear about Galaxy Med's CPA, you know it refers to :CPA12, and anytime you see :CPA12, you know you can uniquely name it as Galaxy Med's CPA. See olive:name and olive:uniqueText. Oftentimes you might be better off using just one of those properties, or using an identifier (see olive:identifiedBy).
:CPA12 olive:uniqueName "Galaxy Med's CPA"^^xsd:string
involves a unit cost of
(:BuyingAndSelling1 olive:unitCost :Monetary1) means that BuyingAndSelling1 is an event in which some focal type of thing is sold at a rate of Monetary1 per unit. For example, (ex:BuyingAndSelling111 olive:unitCost [olive:decimalValue "500"^^xsd:double ; olive:hasUoM olive:_USDollar ]) means that one unit of the type of product sold in ex:BuyingAndSelling111 is sold for $500 US. This property is most useful for representing events in which a type of product is sold; for events in which a single, individual thing is sold, it's typically better to use olive:itemCost. (Note, though, that there may be cases in which you want to use both properties, as when a case of instances of a product type is sold - in this case, you may want to specify both the unit cost and the cost of the case itself).
ex:CostSpecification111 olive:unitCost [olive:decimalValue "500"^^xsd:double ; olive:hasUoM olive:_USDollar ]
has the following standard symbol:
The standard symbol for the unit NOT using any special characters. E.g. square meter would be m^2 rather than m?.
has the following unit symbol:
(:UnitOfMeasure1 olive:unitSymbol-general "SYMBOL"^^xsd:string) means that SYMBOL is a symbol for :UnitOfMeasure1. For example, (_ampere olive:unitSymbol-general "A"^^xsd:string) means that A is the symbol for ampere. This is a very general property intended to be a super-property of olive:unitSymbol, olive:unitSymbolHTML, and olive:unitSymbolUnicode; the latter should be used instead when representing knowledge.
_ampere olive:unitSymbol-general "A"^^xsd:string
has the following standard symbol (HTML):
The standard symbol for the unit in HTML format for pretty printing, may use special characters. E.g. to show square meter as m? rather than m^2, the value of this property would be "m²" This is for when Unicode not supported and the display will be HTML format.
has the following standard symbol (unicode):
The standard symbol for the unit preferred for pretty printing, may use special characters. E.g. square meter would be m? rather than m^2.
is uniquely associated with
This is used for the actual value of a key or ID where you don't want the possibility of having more than one.
has the following UNSPSC:
has the following United Nations Standard Prodcuts and Services Code:
(:Class1 olive:unspsc "STRING"^^xsd:string) means that STRING is the United Nations Standard Products and Services Code for Class1. This property is equivalent to the Wikidata property wdt:P2167.
ex:Nicotine olive:unspsc "51212202"^^xsd:string
has the following UPN code:
has the following Universal Product Number:
(:Class1 olive:upn "STRING"^^xsd:string) means that STRING is the Universal Product Number for Class1.
ex:ProductType2211 olive:upn "11111111"^^xsd:string
instances should have URIs that follow this template:
(:Class1 olive:uriTemplate :URITemplate1) means that converting data instances of Class1 can be done by minting URIs that follow URITemplate1. The scheme for a (non-UUID) URI is {URI for relevant class}/{some-predicate-alias}={value1};{some-other-predicate-alias}={value2}... . For example, (olive:CPA olive:uriTemplate [olive:uniqueText "http://data.oliveai.com/ontology/MedicalCareProvider/npi="]) means that medical care providers should get URIs that follow that pattern (e.g. http://data.oliveai.com/ontology/MedicalCareProvider/npi=1619420049). Of course, we can only follow this template if the NPI information is available. Note that this is an annotation property, and therefore is of limited use in inference. See also olive:classIdentifyingProperties and olive:URITemplate for more information.
olive:CPA olive:uriTemplate [olive:uniqueText "http://data.oliveai.com/ontology/MedicalCareProvider/npi="]
(:URITemplate1 olive:uriTemplateUsesProperty :Property1) means that URITemplate1 uses Property1. See the usage of olive:uriTemplateUsesProperty on olive:MedicalCareProvider, relating that class's template to both olive:npi and olive:ssn. Compare to olive:classIdentifyingProperty, which relates the class directly to a property that is useful for entity resolution.
can be accessed at
(:NetworkAccessibleThing1 olive:url "WEBADDRESS"^^xsd:string) means that you can access NetworkAccessibleThing1 at WEBADDRESS. For example, (:SecureDB olive:url "http://avd.secure.olive.com:8402"^^xsd:string) tells you where the endpoint to SecureDB is located.
:SecureDB olive:url "http://avd.secure.olive.com:8402"^^xsd:string
has a base url of
has fully qualified domain name
(:NetworkAccessibleThing1 olive:url-base "WEBADDRESS"^^xsd:string) means that you can access NetworkAccessibleThing1 at a url that starts with WEBADDRESS. For example, (:SecureDB olive:url-base "http://avd.secure.olive"^^xsd:string) tells you the endpoint to SecureDB has a url that starts with this. If you know the full url, use olive:url instead. The olive:url-base should always be a substring (more specifically, an initial substring) of a olive:url.
:SecureDB olive:url "http://avd.secure.olive"^^xsd:string
has a url of
(:Thing1 olive:url-general "WEBADDRESS"^^xsd:string) means that you can access :Thing1 at WEBADDRESS. For example, (:SecureDB olive:url-general "http://avd.secure.olive.com:8402"^^xsd:string) means that Secure DB can be accessed at http://avd.secure.olive.com:8402. This is intended to be a super-property of, e.g., olive:url and olive:url-base and shouldn't itself be used to represent URL information directly - you should use one of its subproperties instead.
:SecureDB olive:url-general "http://avd.secure.olive.com:8402"^^xsd:string
(:Thing1 olive:uses :Thing2) means that Thing1 uses--in a very general sense--Thing2. For example, a tree uses sunlight, or a computer program uses Python. (:MyProgram olive:uses :PythonLanguage) would mean that my program uses Python. This property is orthogonal to olive:affects. Sometimes using a thing affects the other thing, as in using a spoon to eat one's oatmeal. However, you can also use things in ways that leave them unaffected, such as content using a language (see olive:expressedIn) or a person using a data source (e.g. an excel spreadsheet) to discover information.
uses the portal
(:Thing1 olive:usesPortal :InsurancePortal1) means that Thing1 uses the portal InsurancePortal1. For example, (:MyClaim olive:usesPortal :CignaPortal) would mean that my insurance claim utilized the Cigna portal.
makes use of the following classification:
(:Thing1 olive:utilizesClassification :Class1) means that Thing1 makes use of - in some sense - Class1. One intended usecase for this property is circumstances in which a particular way of categorizing things is specific to a particular individual or schema - for example, if two different individuals categorize operating room supplies in different ways and one wants to declare which classes are employed by which individual.
takes values that are
(:Variable1 olive:variableDatatype :Datatype1) means that Variable1 takes values that are of type Datatype1. For example, (:MyNameVariable olive:variableDatatype xsd:string) means that my name variable must be filled with a string.
:MyNameVariable olive:variableDatatype xsd:string
invokes its function using this substitution:
(:Invocation1 olive:variableEquals (:Variable1 :Value1)) means that the function invoked (see olive:invokes) during Invocation1 has :Value1 substituted in for :Variable1; here :Value1 can either be any resource, including literals (e.g. "17"^^xsd:integer. For example, (:QuadraticFormulaSolvingEvent olive:variableEquals (:LeadingCoefficient "2"^^xsd:decimal)) indicates that the 'a' value in the quadratic formula had the value 2 subbed in during some particular solution represented by the subject of that triple. Or, perhaps we run a Google Search using a REST API: (:GoogleSearch123 olive:variableEquals (:SearchTermVar "Brisket Recipe"^^xsd:string)) indicates that our Google Search 123 involved searching for "Brisket Recipe".
:QuadraticFormulaSolvingEvent olive:variableEquals (:LeadingCoefficient "2"^^xsd:decimal)
Asserts that Content abstracting to some versioned content is assigned some VersionID
olive:Content/MyContent/v1.0 olive:version olive:Version/MyContent/idenfifyingText=1.0;
(:Content1 olive:volumeNumber "N"^xsd:nonNegativeInteger) means that Content1 is the Nth volume in some series. For example, (:Erkenntnis_vol_7 olive:volumeNumber "7"^xsd:nonNegativeInteger) means that the thing referred to by ':Erkenntnis_vol_7' is the seventh volume.
:Erkenntnis_vol_7 olive:volumeNumber "7"^xsd:nonNegativeInteger
has the ZIP code
This is a datatype property that links a person/place/entity with the zip code in which they are located. When possible, we'd prefer to list the full address. For example, (:Person1 olive:zipCode "98372"^^xsd:string) indicates that Person1 is somehow affiliated with the 98372 ZIP code; perhaps they live there, or are currently at that location, or have a business incorporated in that location.
:Person1 olive:zipCode "98372"^^xsd:string
has the plus-four code
has ZIP+4
has the ZIP and add-on of
This is the more specific zip code that includes the add-on/plus four digits. For example, (:Person1 olive:zipCodePlus4 "98372-9000"^^xsd:string) indicates that Person1 is somehow affiliated with the 98372-9000 ZIP code; perhaps they live there, or are currently at that location, or have a business incorporated in that location.
:Person1 olive:zipCodePlus4 "98372-9000"^^xsd:string
active
olive:Active is an instance of olive:Status. This is a general label that can apply to things like products or contracts. This is not to be used for tagging persons as active in terms of performing some activity (e.g. exercise).
alias graph
olive:AliasGraph is an instance of olive:VolatileGraph. This is the knowledge graph that stores the graph names where various frequently referenced information lives. Think of this as a graph that stores the symlinks for graphs: as we have updated versions of, say, olive:OliveOntology, the alias graph will track which named graph holds the latest version.
minimal amount
no amount
A qualitative amount, this is the tag for things that have a minimal or no amount.
low amount
A qualitative amount, this is the tag for things that have a low amount.
medium amount
moderate amount
A qualitative amount, this is the tag for things that have medium amount.
high amount
A qualitative amount, this is the tag for things that have high amount.
maximal amount
A qualitative amount, this is the tag for things that have a maximal amount.
avoided
olive:Avoided is an instance of olive:CommitmentCategory. See comment on olive:Satisfied for further discussion.
email address
olive:ContactType-Email is an instance of olive:ContactAddressType.
fax number
olive:ContactType-Fax is an instance of olive:ContactAddressType.
pager number
olive:ContactType-Pager is an instance of olive:ContactAddressType.
olive:ContactType-Phone is an instance of olive:ContactAddressType.
text message number
olive:ContactType-Text is an instance of olive:ContactAddressType.
web address
olive:ContactType-Web is an instance of olive:ContactAddressType.
anonymized data
Personal infomration that is anonymized in accordance with applicable law such that the data is no longer considered personal data/information. This does not include any de-identified information.
contracturally restricted data classification type
contracturally restricted data
Data whose use is restricted by contract.
controlled data - data classification type
controlled data
Data that is governed or restricted by law or regulation (i.e. export-controlled data) - excluding personal data and PHI.
de-identified information data classification type
de-identified data
de-identified PHI
PHI de-identified in accordance with the HIPAA Privacy Rule at 45 CFR 164.514, using either the Expert Determination (45 CFR 164.514(b)(1)) or Safe Harbor (45 CFR 164.541(b)(2)) method.
metadata
Metadata includes information about technical and business processes, data rules and constraints, and logical and physical data structures.
personal data - data classification type
personal data
personal information
personally identifying information
PII
Any information related to an identified or identifiable person, or as may be defined by applicable laws. This includes direct and indirect identifiers.
sensitive personal data - data classification type
sensitive personal data
sensitive personal information
Personal data/information relating to an individual’s social security, driver’s license, state identification card, or passport number; account log-in information; precise geolocation; race; ethnic origin; religious or philosophical beliefs or union membership; contents of an individual’s written communications unless the business is the intended recipient; genetic data; biometric data; health data (not covered by HIPAA); and sec life or sexual orientation. Applicable law may include other types of data/information as sensitive personal data/information.
public data
freely accessible data
This type of data is freely accessible to the public. It can be freely used, reused, and redistributed without repercussions.
sensitive business information
sensitive business data
Business information that would pose a risk if released. Examples include: sensitive financial and shareholder information, trade secrets, intellectual property, customer and supplier information.
public information
public
Data with this sensitivity level requires no confidential treatment because it is in the public sphere or otherwise is not expected to be protected or secured.
deprecated
olive:Deprecated is an instance of olive:UseType.
downvote
A negative assessment, downvotes indicate that the thing upvoted should be, if anything, less visible to fewer people.
English
olive:EnglishLanguage is an instance of olive:Language.
woman
womxn
olive:Female-Gender is an instance of olive:Gender-Category.
olive:Female-Sex is an instance of olive:Sex-Category.
feminine
olive:Feminine is an instance of olive:GenderExpressionCategory.
gendernonconforming
olive:GenderNonConforming is an instance of olive:Gender-Category.
home
olive:HomeUse is an instance of olive:UseType. For example, a phone may be a home phone.
inactive
olive:Inactive is an instance of olive:Status. Compare with olive:Active.
indirectly mapped into the Olive ontology
in progress
olive:InProgress is an instance of olive:CommitmentCategory. See the comment on olive:Satisfied for more discussion.
man
mxn
olive:Male-Gender is an instance of olive:Gender-Category.
olive:Male-Sex is an instance of olive:Sex-Category.
mapped into the Olive ontology
masculine
olive:Masculine is an instance of olive:GenderExpressionCategory.
bronze metal level
olive:MetalLevel-Bronze is an instance of olive:MetalLevel.
catastrophic metal level
olive:MetalLevel-Catastrophic is an instance of olive:MetalLevel.
gold metal level
olive:MetalLevel-Gold is an instance of olive:MetalLevel.
platinum metal level
olive:MetalLevel-Platinum is an instance of olive:MetalLevel.
silver metal level
olive:MetalLevel-Silver is an instance of olive:MetalLevel.
mobile
olive:MobileUse is an instance of olive:UseType. For example, a phone or blood pressure machine may be for mobile use, as opposed to one that is fixed in place.
normal
olive:NormalUse is an instance of olive:UseType.
NONE
olive:NONE-StardogReasoningLevel is an instance of olive:ReasoningLevel.
not assertible
olve:NotAssertible is an instance of olive:AssertibilityStatus used to indicate that a given term should not be used to make assertions. See also olive:assertibility.
official
olive:OfficialUse is an instance of olive:UseType.
Olive
This is the company, formerly known as CrossChx, founded by Sean Lane in 2012. Olive builds artificial intelligence and RPA solutions that empower healthcare organizations to improve efficiency and patient care while reducing costly administrative errors. Olive also hires exceptionally talented ontological engineers.
Olive ontology
olive:OliveOntology is an instance of owl:Ontology.
optional
The deontic status of being optional. Everything that is optional is also permitted.
other
olive:Other-Sex is an instance of olive:Sex-Category.
partially mapped into the Olive ontology
olive:QL-StardogReasoningLevel is an instance of olive:ReasoningLevel.
required
The deontic status of being required, obligatory. Required things are things that are not forbidden.
RDFS
olive:RDFS-StardogReasoningLevel is an instance of olive:ReasoningLevel.
read only
olive:ReadOnly is an instance of olive:FileAttribute. Files that are categorized by this attribute cannot be modified; users can only read the file's contents without contributing/modifying those contents.
satisfied
olive:Satisfied is an instance of olive:CommitmentCategory. A commitment is satisfied just in case all of its requirements have been met. It is violated, roughly, if the person(s) responsible for satisfying the commitment has made it such that the commitment is unsatisfiable. It is avoided if the commitment is no longer relevant to the relevant persons. A given commitment cannot be both satisfied and violated. Take an example: I promise to meet you for lunch at noon if I'm in town. If I make it to town and meet you for lunch, then that obligation is satisfied (that is, :MyObligation olive:categorizedBy olive:Satisfied). If I come to town and fail to meet your for lunch, I have violated my commitment. If I don't even come to town, the obligation is avoided. The status might also be up in the air for quite a while. If I come to town and and on my way to lunch but have not yet gotten there, we might say that the commitment is in progress despite not being satisfied, violated, or avoided (yet).
secondary
olive:SecondaryUse is an instance of olive:UseType.
Olive IP
olive:SensitiveInfo-OliveIP is an instance of olive:SensitiveInformationType.
PHI
Defined by HIPAA as individually identifiable information that relates to an individual’s past, present, future physical or mental health or condition, the provision of health care to an individual, or the past present or future payment for the provision of health care for the individual, and that identifies the individual or can be reasonably used to identify the individual. PHI is limited to health information received from or created by a Covered Entity, who is usually a healthcare system or provider. PHI may also include information related to health insurance details and associated payment information. Health data that is not regulated by HIPAA, should not be called PHI, and should be referred to as personal data/information.
build
olive:SL-StardogReasoningLevel is an instance of olive:ReasoningLevel.
SSV URI template
olive:SSVURITemplate is an instance of olive:URITemplate.
For the templated text, the {TYPE} will typically be one of: Doctor, Patient, or Hospital. And the {type_id} will be things like empi_id and provider_id.
stubterm
olive:StubTerm is an instance of olive:OntologyTermType.
temporary
olive:TemporaryUse is an instance of olive:UseType.
term requiring review
olive:TermRequiringReview is an instance of olive:OntologyTermType. Every term in this category should be reviewed and the categorization removed.
UMLS
olive:UnifiedMedicalLanguageSystem is an instance of olive:System and olive:NonphysicalArtifact.
not yet mapped into the Olive ontology
upvote
A positive assessment, upvotes indicate that the thing upvoted should be, if anything, more visible to more people.
violated
olive:Violated is an instance of olive:CommitmentCategory. See the comment on olive:Satisfied for more discussion.
work
olive:WorkUse is an instance of olive:UseType. For example, a phone or computer may be for work use.
US Dolalr
USD
ampere
amp
A bit (short for binary digit) is the smallest unit of data in a computer. A bit has a single binary value, either 0 or 1.
bit
candela
candle
day
each
olive:_each is the instance of olive:UnitOfMeasure that denotes counting individual objects. So, if I have 12 apples, I could denote that there are 12 things as follows: ex:MyAppleCollection a olive:Collection; olive:hasMagnitude [a olive:Count; gist:hasDecimalValue "12"^^xsd:double; olive:hasUoM olive:_each].
Kelvin
kilogram
kg/m^2
The standard unit for BMI (see olive:bodyMassIndex).
meter
millisecond
minute
mole
month
second
m^2
square meter
week
year
The range of skos:altLabel is the class of RDF plain literals.
skos:prefLabel, skos:altLabel and skos:hiddenLabel are pairwise disjoint properties.
alternative label
An alternative lexical label for a resource.
Acronyms, abbreviations, spelling variants, and irregular plural/singular forms may be included among the alternative labels for a concept. Mis-spelled terms are normally included as hidden labels (see skos:hiddenLabel).
change note
A note about a modification to a concept.
definition
A statement or formal explanation of the meaning of a concept.
editorial note
A note for an editor, translator or maintainer of the vocabulary.
example
An example of the use of a concept.
The range of skos:hiddenLabel is the class of RDF plain literals.
hidden label
A lexical label for a resource that should be hidden when generating visual displays of the resource, but should still be accessible to free text search operations.
history note
A note about the past state/use/meaning of a concept.
note
A general note, for any purpose.
This property may be used directly, or as a super-property for more specific note types.
A resource has no more than one value of skos:prefLabel per language tag, and no more than one value of skos:prefLabel without language tag.
The range of skos:prefLabel is the class of RDF plain literals.
preferred label
The preferred lexical label for a resource, in a given language.
scope note
A note that helps to clarify the meaning and/or the use of a concept.
has broader match
skos:broadMatch is used to state a hierarchical mapping link between two conceptual resources in different concept schemes.
Broader concepts are typically rendered as parents in a concept hierarchy (tree).
has broader
Relates a concept to a concept that is more general in meaning.
By convention, skos:broader is only used to assert an immediate (i.e. direct) hierarchical link between two conceptual resources.
has broader transitive
skos:broaderTransitive is a transitive superproperty of skos:broader.
By convention, skos:broaderTransitive is not used to make assertions. Rather, the properties can be used to draw inferences about the transitive closure of the hierarchical relation, which is useful e.g. when implementing a simple query expansion algorithm in a search application.
has close match
skos:closeMatch is used to link two concepts that are sufficiently similar that they can be used interchangeably in some information retrieval applications. In order to avoid the possibility of "compound errors" when combining mappings across more than two concept schemes, skos:closeMatch is not declared to be a transitive property.
skos:exactMatch is disjoint with each of the properties skos:broadMatch and skos:relatedMatch.
has exact match
skos:exactMatch is used to link two concepts, indicating a high degree of confidence that the concepts can be used interchangeably across a wide range of information retrieval applications. skos:exactMatch is a transitive property, and is a sub-property of skos:closeMatch.
has top concept
Relates, by convention, a concept scheme to a concept which is topmost in the broader/narrower concept hierarchies for that scheme, providing an entry point to these hierarchies.
is in scheme
Relates a resource (for example a concept) to a concept scheme in which it is included.
A concept may be a member of more than one concept scheme.
These concept mapping relations mirror semantic relations, and the data model defined below is similar (with the exception of skos:exactMatch) to the data model defined for semantic relations. A distinct vocabulary is provided for concept mapping relations, to provide a convenient way to differentiate links within a concept scheme from links between concept schemes. However, this pattern of usage is not a formal requirement of the SKOS data model, and relies on informal definitions of best practice.
is in mapping relation with
Relates two concepts coming, by convention, from different schemes, and that have comparable meanings
has member
Relates a collection to one of its members.
For any resource, every item in the list given as the value of the skos:memberList property is also a value of the skos:member property.
has member list
Relates an ordered collection to the RDF list containing its members.
has narrower match
skos:narrowMatch is used to state a hierarchical mapping link between two conceptual resources in different concept schemes.
Narrower concepts are typically rendered as children in a concept hierarchy (tree).
has narrower
Relates a concept to a concept that is more specific in meaning.
has narrower transitive
skos:narrowerTransitive is a transitive superproperty of skos:narrower.
By convention, skos:narrowerTransitive is not used to make assertions. Rather, the properties can be used to draw inferences about the transitive closure of the hierarchical relation, which is useful e.g. when implementing a simple query expansion algorithm in a search application.
skos:related is disjoint with skos:broaderTransitive
has related
Relates a concept to a concept with which there is an associative semantic relationship.
has related match
skos:relatedMatch is used to state an associative mapping link between two conceptual resources in different concept schemes.
is in semantic relation with
Links a concept to a concept related by meaning.
This property should not be used directly, but as a super-property for all properties denoting a relationship of meaning between concepts.
is top concept in scheme
Relates a concept to the concept scheme that it is a top level concept of.
notation
A notation, also known as classification code, is a string of characters such as "T58.5" or "303.4833" used to uniquely identify a concept within the scope of a given concept scheme.
By convention, skos:notation is used with a typed literal in the object position of the triple.
Collection
A meaningful collection of concepts.
Labelled collections can be used where you would like a set of concepts to be displayed under a 'node label' in the hierarchy.
Concept
An idea or notion; a unit of thought.
Concept Scheme
A set of concepts, optionally including statements about semantic relationships between those concepts.
Thesauri, classification schemes, subject heading lists, taxonomies, 'folksonomies', and other types of controlled vocabulary are all examples of concept schemes. Concept schemes are also embedded in glossaries and terminologies.
A concept scheme may be defined to include concepts from different sources.
Ordered Collection
An ordered collection of concepts, where both the grouping and the ordering are meaningful.
Ordered collections can be used where you would like a set of concepts to be displayed in a specific order, and optionally under a 'node label'.