Olive's upper ontology
type: Ontology
comment: 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.

abstract
type: Class
subclass of: content
subclass of: nonphysical artifact
preferred label: abstract for some content
comment: 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
type: Class
subclass of: event
comment: olive:Accident is the class of all events that have negative unintended consequences.
example subclass: medical accident
example instance: ex:CarAccidentOn22ndStreet

medical accident
type: Class
subclass of: accident
comment: olive:Accident-Medical is the class of all medical accidents.

account
type: Class
subclass of: contract
comment: 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
type: Class
subclass of: account
comment: This is the subclass of olive:Account, wherein all instances have a olive:accountSeller of Olive.
equivalent class: Class
  intersection of: account
  intersection of: Restriction
    on property: account seller
    has value: Olive

account status
type: Class
subclass of: status
comment: This is the class of 'tags' for account statuses. For example, we can identify an account as having its delivery completed.

web service action
type: Class
subclass of: function
preferred label: action
comment: Instances of olive:Action-WS are functions (see olive:Function) that (partly) compose a given web service (see olive:WebService).

address
type: Class
subclass of: place
subclass of: artifact
comment: 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.
equivalent class: Restriction
  on property: address
  some values from: string
former name: gist:Address
URI template:
  unique text: olive:Address/ribbonUuid=
  uri uses property: ribbonUuid
  note: Applicable when importing data from the RibbonHealth API

admission
type: Class
subclass of: medical care event
preferred label: hospital admission
comment: 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.
example subclass: emergency admission

emergency admission
type: Class
subclass of: admission
comment: 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.
equivalent class: Restriction
  on property: admissionType
  has value: 1

elective admission
type: Class
subclass of: admission
comment: 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.
equivalent class: Restriction
  on property: admissionType
  has value: 3

newborn admission
type: Class
subclass of: admission
comment: All admission type medical care events in which the patient is a newborn. This requires use of special codes (see olive:admissionSource).
equivalent class: Restriction
  on property: admissionType
  has value: 4

trauma admission
type: Class
subclass of: admission
comment: 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.
equivalent class: Restriction
  on property: admissionType
  has value: 3

urgent admission
type: Class
subclass of: admission
comment: 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.
equivalent class: Restriction
  on property: admissionType
  has value: 2

agent
type: Class
subclass of: Thing
comment: 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.
example subclass: organization
example subclass: person

agreement
type: Class
alternative label: deal
comment: 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.
subclass of: commitment
subclass of: Restriction
  on property: creation time
  some values from: time instant
equivalent class: Class
  intersection of: commitment
  intersection of: Restriction
    on property: binding for agent
    min cardinality: 2
former name: gist:Agreement

alive thing
type: Class
preferred label: alive
subclass of: living thing
comment: 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.
example instance: ex:CaseyHart (for now!)
disjoint with: deceased thing

allergy
type: Class
subclass of: health condition
comment: 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).
example subclass: ex:PeanutAllergy
example instance: ex:FredsLatexAllergy

alzheimers disease
type: Class
subclass of: disease
preferred label: Alzheimer's Disease
comment: olive:AlzheimersDisease is the class of all states in which someone has Alzheimer's disease.

attribute
type: Class
alternative label: property
alternative label: characteristic
comment: 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 a…
example subclass: olive:Magnitude
example instance: ex:TheMassOfNicksHead

API
type: Class
subclass of: software interface
alternative label: application programming interface
comment: An API is a computing interface that defines interactions betwen multiple software intermediaries.

appointment
type: Class
subclass of: agreement
comment: 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.
example instance: ex:MyDoctorsAppointment

area
type: Class
alternative label: planar region
comment: A measurement of two-dimensional space.
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: area unit
former name: gist:Area

area unit
type: Class
comment: A unit of two-dimensional area, such as square inches or hectares.
equivalent class: Class
  intersection of: product unit
  intersection of: Restriction
    on property: multiplicand
    on class: distance unit
    qualified cardinality: 2
former name: gist:AreaUnit

artifact
type: Class
subclass of: Thing
alternative label: technology
comment: 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 i…
example subclass: equipment
example subclass: building
example subclass: content
former name: gist:Artifact

assessing something
type: Class
subclass of: event
comment: 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.
example subclass: ex:RiskAssessment

assertibility status
type: Class
subclass of: status
comment: 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 content source
type: Class
preferred label: auditory medium
alternative label: audio
alternative label: audio content
subclass of: content bearing thing
comment: 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
type: Class
subclass of: organization
comment: 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
type: Class
subclass of: account
equivalent class:
  intersection of: account
  intersection of: Restriction
    on property: account seller
    some values from: bank
comment: An account where the olive:accountSeller is a bank (olive:Bank). Accounts have balances, account numbers, and so on.

base unit
type: Class
subclass of: simple unit
subclass of: coherent unit
comment: 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).
former name: gist:BaseUnit

book content
type: Class
subclass of: content
subclass of: nonphysical artifact
preferred label: book
comment: 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.

book content bearer
type: Class
subclass of: content bearing thing
preferred label: book
comment: 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 configuration
type: Class
subclass of: content
subclass of: nonphysical artifact
alternative label: bot file
comment: Bot configurations are instances of olive:Content that specify commands executable by a robot, particularly by an Olive bot (olive:OliveBot).

bot file block
type: Class
subclass of: bot configuration
preferred label: block
comment: 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.

bot running event
type: Class
subclass of: invocation
comment: 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
type: Class
subclass of: physical artifact
subclass of: place
comment: 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.
former name: gist:Building

building address
type: Class
subclass of: physical address
preferred label: address
comment: An address to which you can send mail, or that you could find in the physical world.
former name: gist:BuildingAddress

business partnership
type: Class
subclass of: contractual relationship
subclass of: partnership
subclass of: business relationship
comment: This is the class of business partnerships, which are contractual partnerships between agents for the purpose of carrying on business.
equivalent class: Class
  intersection of: business relationship
  intersection of: partnership
  intersection of: contractual relationship

business relationship
type: Class
subclass of: relationship
comment: 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
type: Class
subclass of: transaction
alternative label: buying
alternative label: selling
alternative label: trading
comment: 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…

CARC
type: Class
subclass of: insurance claim type
alternative label: claim adjustment reason code
comment: 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
type: Class
subclass of: attribute
alternative label: universal
comment: 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 cla…
example subclass: product category
example subclass: status
former name: gist:Category

data cell
type: Class
subclass of: section
preferred label: cell
comment: 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
type: Class
subclass of: content
subclass of: nonphysical artifact
alternative label: accreditation
comment: 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.
example subclass: degree
example subclass: MeaningfulUseCertification

change event
type: Class
subclass of: event
comment: 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.
example subclass: ex:Haircut
example instance: ex:RoastingLastNightsBrisket

charge capture coding
type: Class
subclass of: event
comment: 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.
subclass of: Restriction
  on property: Precedes
  some values from: claim submission

check
type: Class
subclass of: content bearing thing
comment: 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
type: Class
subclass of: content
subclass of: nonphysical artifact
alternative label: reference
comment: 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).

city
type: Class
subclass of: region
comment: 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.

claim processing
type: Class
subclass of: event
preferred label: remittance processing and rejection
comment: This is the sixth subevent of the revenue cycle. During claim processing, the filed insurance claim can be paid in full, partially, or rejected.
subclass of: Restriction
  on property: Precedes
  some values from: payment posting, appeals, and collections

claim status
type: Class
preferred label: insurance claim status
subclass of: status
comment: olive:ClaimStatus is the class of all statuses that apply to insurance claims (see olive:InsuranceClaim).
example instance: olive:PaidClaim

claim submission
type: Class
subclass of: communication event
preferred label: insurance claim submission
comment: This is the fifth subevent of the revenue cycle. This is simply the handoff of the insurance claim from the provider to the payer.
equivalent class:
  intersection of: Restriction
    on property: conveys to
    some values from: insurance company
  intersection of: Restriction
    on property: conveys from
    some values from: medical care provider
  intersection of: Restriction
    on property: communicated content
    some values from: insurance claim
subclass of: Restriction
  on property: Precedes
  some values from: claim processing

higher order class
type: Class
preferred label: higher-order class
comment: 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
type: Class
subclass of: higher order class
disjoint with: third order class
preferred label: second-order class
comment: 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
type: Class
subclass of: higher order class
preferred label: third-order class
comment: 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
type: Class
subclass of: status
comment: 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
type: Class
subclass of: commitment
comment: 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
type: Class
subclass of: product unit
subclass of: coherent unit
comment: A ratio unit whose numerator and denominator reduce to 1
former name: gist:CoherentProductUnit

coherent ratio unit
type: Class
comment: A ratio unit whose numerator and denominator reduce to 1
equivalent class: Class
  intersection of: ratio unit
  intersection of: Restriction
    on property: denominator
    all values from: Class
      union of: base unit
      union of: coherent product unit
      union of: coherent ratio unit
  intersection of: Restriction
    on property: numerator
    all values from: Class
      union of: base unit
      union of: coherent product unit
      union of: coherent ratio unit
former name: gist:CoherentRatioUnit

coherent unit
type: Class
subclass of: unit of measure
comment: 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.
example subclass: base unit
equivalent class: Class
  union of: base unit
  union of: coherent product unit
  union of: coherent ratio unit
former name: gist:CoherentUnit

cohort
type: Class
instance of: second order class
subclass of: facet
comment: 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).
example subclass: patient cohort
example subclass: medical care event cohort

collection
type: Class
subclass of: Restriction
  on property: has member
  some values from: Thing
comment: 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.
example subclass: group
former name: gist:Collection
example instance: ex:SomeJury

commitment
type: Class
subclass of: requirement
comment: 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.
example subclass: agreement
example subclass: obligation
former name: gist:Commitment

commitment category
type: Class
subclass of: category
comment: 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
type: Class
subclass of: event
comment: 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.
example subclass: requesting something
equivalent class: Restriction
  on property: communicated content
  some values from: content

comparison
type: Class
subclass of: content
subclass of: nonphysical artifact
comment: 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
type: Class
subclass of: event
instance of: human activity type
comment: 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.
example instance: Cribbage
example instance: Football

confused state
type: Class
subclass of: mental state
comment: 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
type: Class
subclass of: using something
alternative label: using something on consignment
comment: 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.

contact address type
type: Class
preferred label: type of contact information
subclass of: category
comment: 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
type: Class
subclass of: physical object
alternative label: bounded space
alternative label: bounded spatial object
comment: 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.
example subclass: olive:Room

content
type: Class
subclass of: nonphysical thing
alternative label: information
comment: 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).
example subclass: book content

content bearing thing
type: Class
subclass of: artifact
alternative label: materialized content
alternative label: realized content
alternative label: physical content
alternative label: concrete content
comment: 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.
example triple: :MyCopyOfCatcherInTheRye a olive:ContentBearingThing
example subclass: Book-Concrete
example subclass: database

content use type
type: Class
subclass of: use type
comment: olive:ContentUseType is the class of all

continent
type: Class
subclass of: region
comment: A main continuous landmass on a planet. There are seven on Earth: Africa, Antarctica, Asia, Australia, Europe, North America, and South America.

contract
type: Class
alternative label: deal
comment: 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.
equivalent class: Class
  intersection of: agreement
  intersection of: Restriction
    on property:
      inverse of: governs
    some values from: government organization
former name: gist:Contract

constraint
type: Class
subclass of: content
alternative label: restriction
alternative label: specification
alternative label: standard
comment: 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.
former name: gist:Restriction

controlled vocabulary
type: Class
preferred label: vocabulary
comment: A collection of terms approved and managed by some organization or person.
equivalent class: Class
  intersection of: collection
  intersection of: Restriction
    on property:
      inverse of: governs
    some values from: agent
  intersection of: Restriction
    on property: has member
    some values from: category
former name: gist:ControlledVocabulary

cost specification
type: Class
subclass of: commitment
comment: 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
type: Class
comment: A measure that involves countable amounts.
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: counting unit
former name: gist:Count

counting unit
type: Class
comment: A unit of counting, especially olive:_each, but also units such as dozens.
equivalent class: Class
  intersection of: simple unit
  intersection of: Restriction
    on property: has base unit
    has value: each
former name: gist:CountingUnit

country
type: Class
subclass of: region
comment: 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.

county
type: Class
subclass of: region
comment: 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
type: Class
alternative label: current procedural terminology code
subclass of: service code category
comment: 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
type: Class
disjoint with: destruction
subclass of: change event
comment: 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
type: Class
subclass of: physical artifact
alternative label: hard currency
alternative label: cash
alternative label: money
comment: 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
type: Class
comment: 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).
disjoint with: data size unit
disjoint with: distance unit
disjoint with: duration unit
disjoint with: electrical current unit
disjoint with: luminous intensity unit
disjoint with: mass unit
disjoint with: Mole Unit
disjoint with: temperature unit
equivalent class: Class
  intersection of: simple unit
  intersection of: Restriction
    on property: has base unit
    has value: US Dollar
former name: gist:CurrencyUnit

custom function call
type: Class
subclass of: function call
comment: A call to a custom function within some SPARQL query.

database
type: Class
subclass of: data store
comment: 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
type: Class
subclass of: category
alternative label: data type
comment: 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.

load
type: Class
subclass of: invocation
preferred label: data load
alternative label: data ingestion
comment: Data Loads are invocations that move or copy data as their primary concern.

data model
type: Class
subclass of: constraint
alternative label: database schema
comment: 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
type: Class
subclass of: category
alternative label: data confidentiality level
comment: 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 content
type: Class
subclass of: content
subclass of: nonphysical artifact
preferred label: dataset
alternative label: structured data
comment: 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:abstracts…

data size unit
type: Class
comment: A unit to measure amounts of digital information.
disjoint with: distance unit
disjoint with: duration unit
disjoint with: electrical current unit
disjoint with: luminous intensity unit
disjoint with: mass unit
disjoint with: Mole Unit
disjoint with: temperature unit
equivalent class: Class
  intersection of: simple unit
  intersection of: Restriction
    on property: has base unit
    has value: bit
former name: gist:DataSizeUnit

data store
type: Class
subclass of: content bearing thing
subclass of: virtual thing
equivalent class:
  intersection of: content bearing thing
  intersection of: virtual thing
comment: 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
type: Class
comment: A point in time known only to the accuracy of one day. Say the signing of the declaration of independence on 7/4/1776
equivalent class: Class
  intersection of: time instant
  intersection of: Restriction
    on property: has magnitude
    some values from: Class
      intersection of: Restriction
        on property: has precision
        has value: 1
      intersection of: Restriction
        on property: has unit of measure
        has value: day
former name: gist:DateInstant
URI template:
  unique text: http://data.oliveai.com/ontology/DateInstant/universalDate=
  note: 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).
  uri template uses property: universal date

deactivation
type: Class
disjoint with: reactivation
subclass of: change event
comment: 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
type: Class
subclass of: change event
comment: 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 thing
type: Class
preferred label: deceased
subclass of: living thing
equivalent class: Class
  intersection of: living thing
  intersection of: Restriction
    on property:
      inverse of: changed thing
    some values from: death
comment: 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.
example instance: ex:AbrahamLincoln

deception
type: Class
subclass of: event
comment: 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.

degree
type: Class
subclass of: certification
preferred label: education degree
comment: 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
type: Class
subclass of: degree
comment: 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 degree
type: Class
subclass of: undergraduate degree
subclass of: academic degree
disjoint with: bachelor's degree
preferred label: associate's degree
comment: 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 degree
type: Class
subclass of: bachelor's degree
disjoint with: bachelor of science degree
preferred label: BA
alternative label: AB
alternative label: Bachelor of Arts
comment: The subclass of olive:Degree-Bachelors all instances of which are Bachelor of Arts degrees.

bachelor of science degree
type: Class
subclass of: bachelor's degree
disjoint with: bachelor of arts degree
preferred label: BS
alternative label: Bachelor of Science
comment: The subclass of olive:Degree-Bachelors all instances of which are Bachelor of Science degrees.

bachelor's degree
type: Class
subclass of: undergraduate degree
subclass of: academic degree
disjoint with: associate degree
alternative label: bachelor degree
comment: The subclass of olive:Degree wherein a bachelor's degree is awarded.

doctorate
type: Class
subclass of: postgraduate degree
disjoint with: master's degree
preferred label: doctoral degree
comment: The subclass of olive:Degree-Postgraduate all instances of which are doctoral degrees.

hs degree
type: Class
subclass of: degree
disjoint with: undergraduate degree
disjoint with: postgraduate degree
preferred label: high school diploma
alternative label: diploma
comment: The subclass of olive:Degree wherein a high school diploma is awarded.

master's degree
type: Class
subclass of: postgraduate degree
subclass of: academic degree
disjoint with: doctorate
comment: The subclass of olive:Degree-Postgraduate all instances of which are master's degrees.

MA degree
type: Class
subclass of: master's degree
preferred label: MA
alternative label: master of arts
comment: The subclass of olive:Degree-Masters all instances of which are Master of Arts degrees.
maps to: MA

MD degree
type: Class
subclass of: doctorate
subclass of: professional degree
preferred label: MD
alternative label: Doctor of Medicine
comment: The subclass of olive:Degree-Doctorate all instances of which are MD (Doctor of Medicine) degrees.
maps to: MD

MS degree
type: Class
subclass of: master's degree
preferred label: MS
alternative label: master of science
comment: The subclass of olive:Degree-Masters all instances of which are Master of Science degrees.

PhD degree
type: Class
subclass of: doctorate
subclass of: academic degree
preferred label: PhD
alternative label: doctorate
alternative label: Doctor of Philosophy
comment: The subclass of olive:Degree-Postgraduate wherein a PhD (Doctor of Philosophy) is awarded.
maps to: PHD

postgraduate degree
type: Class
subclass of: degree
disjoint with: undergraduate degree
preferred label: graduate degree
comment: The subclass of olive:Degree all instances of which are degrees pursued following graduation from undergraduate study (see olive:Degree-Undergraduate).

professional degree
type: Class
subclass of: degree
comment: 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
type: Class
subclass of: degree
disjoint with: postgraduate degree
comment: The subclass of olive:Degree all instances of which are degrees pursued during undergraduate study at a college or university.

delivery
type: Class
subclass of: moving something
subclass of: transfer event
comment: 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.
example instance: ex:AmazonPackageDelivery1032

deontic status
type: Class
subclass of: category
comment: 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.
example instance: required
example instance: optional

destruction
type: Class
subclass of: change event
comment: 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
type: Class
subclass of: destruction
comment: 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
type: Class
subclass of: health condition
comment: 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
type: Class
alternative label: extent
alternative label: length
comment: A measure of distance, which could be distances over the Earth, and could also be height, width, length, depth, girth, etc.
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: distance unit
former name: gist:Extent

distance unit
type: Class
comment: A unit to measure linear distance, such as feet or kilometers.
disjoint with: duration unit
disjoint with: electrical current unit
disjoint with: luminous intensity unit
disjoint with: mass unit
disjoint with: Mole Unit
disjoint with: temperature unit
equivalent class: Class
  intersection of: simple unit
  intersection of: Restriction
    on property: has base unit
    has value: meter
former name: gist:DistanceUnit

doctor
type: Class
subclass of: medical professioal
alternative label: physician
comment: 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.
mapsTo-provider type: Doctor

duration
type: Class
comment: 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.
comment: Time, but not on a timeline.
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: duration unit
former name: gist:Duration

duration unit
type: Class
comment: A unit to measure passage of time: hours, days, years.
disjoint with: electrical current unit
disjoint with: luminous intensity unit
disjoint with: mass unit
disjoint with: Mole Unit
disjoint with: temperature unit
equivalent class: Class
  intersection of: simple unit
  intersection of: Restriction
    on property: has base unit
    has value: second
former name: gist:DurationUnit

drug
type: Class
subclass of: physical artifact
alternative label: medication
comment: 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.

drug dispensation
type: Class
subclass of: transfer event
preferred label: dispensing a drug
alternative label: receiving a drug
alternative label: acquiring a drug
comment: 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.
disjoint with: receiving a drug

education
type: Class
subclass of: event
comment: 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).
example subclass: PrimaryEducation
example subclass: post graduate education
example instance: my undergraduate education at PLU
URI template:
  unique text: olive:Education/ribbonUuid=
  uri uses property: ribbonUuid
  note: Applicable when importing data from the RibbonHealth API

college education
type: Class
preferred label: college
alternative label: undergraduate education
alternative label: undergrad
subclass of: education
comment: 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 schoool education
type: Class
preferred label: graduate school
alternative label: grad school
alternative label: graduate education
subclass of: post graduate education
comment: olive:Education-GraduateSchool is a subclass of olive:Education.
disjoint with: college education

medical school education
type: Class
preferred label: medical school
alternative label: med school
subclass of: graduate schoool education
comment: olive:Education-MedicalSchool is a subclass of olive:Education.
maps to: Medical School

electrical current
type: Class
alternative label: electric current
comment: A flow of electric charge.
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: electrical current unit
former name: gist:ElectricCurrent

electrical current unit
type: Class
comment: Unit of electrical current, which is charge per unit time. The SI unit is the ampere. (Note that electrical current is a composed unit.)
disjoint with: luminous intensity unit
disjoint with: mass unit
disjoint with: Mole Unit
disjoint with: temperature unit
equivalent class: Class
  intersection of: simple unit
  intersection of: Restriction
    on property: has base unit
    has value: ampere
former name: gist:ElectricalCurrentUnit

email address
type: Class
subclass of: virtual address
preferred label: email
alternative label: email account
former name: gist:EmailAddress
comment: 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

emotional state
type: Class
preferred label: emotion
subclass of: mental state
comment: 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.
example subclass: AngryState
example subclass: JoyfulState

employment
type: Class
subclass of: event
comment: 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.

endpoint
type: Class
subclass of: virtual thing
preferred label: api endpoint
comment: 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
type: Class
subclass of: medical care event
subclass of: Restriction
  on property: has subevent
  some values from: medical encounter
comment: 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.
disjoint with: medical encounter

equipment
type: Class
subclass of: physical artifact
comment: 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.
former name: gist:Equipment
disjoint with: building

evaluation
type: Class
subclass of: content
subclass of: nonphysical artifact
alternative label: feedback
comment: 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
type: Class
disjoint with: situation state
alternative label: occurrence
alternative label: happening
subclass of: situation
comment: 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.
example subclass: revenue cycle
example subclass: medical care event

exchange
type: Class
preferred label: exchage
subclass of: transfer event
comment: 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.)
example sub class: transaction

exemplar individual
type: Class
alternative label: exemplar
alternative label: paradigm individual
alternative label: model
alternative label: standard
comment: 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
type: Class
instance of: second order class
comment: 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
type: Class
subclass of: living thing
comment: 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.
equivalent class: Restriction
  on property: assigned sex
  has value: female sex

data field
type: Class
subclass of: collection
subclass of: section
preferred label: field
comment: 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.

figure
type: Class
subclass of: visual content source
comment: Figures are graphics that appear in written or visual media that convey information, such as tables, charts, and graphs.

file
type: Class
subclass of: content bearing thing
comment: 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.

physical file
type: Class
subclass of: file
subclass of: physical object
preferred label: file
alternative label: paper file
equivalent class:
  intersection of: file
  intersection of: physical object
comment: This is the intersection of olive:File and olive:PhysicalObject. Paradigmatic examples are paper files; paradigmatic non-examples are computer files.

virtual file
type: Class
subclass of: file
subclass of: data store
preferred label: file
alternative label: computer file
alternative label: electronic file
equivalent class:
  intersection of: file
  intersection of: virtual thing
comment: This is the intersection of olive:File and olive:VirtualThing. Paradigmatic examples are computer files; paradigmatic non-examples are paper files.

file attribute
type: Class
subclass of: category
comment: 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.
example instance: read only

force
type: Class
subclass of: event
comment: 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 template
type: Class
preferred label: form
subclass of: constraint
subclass of: template
comment: 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
type: Class
subclass of: deception
comment: 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.

function
type: Class
subclass of: nonphysical thing
comment: 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.
example subclass: TaskRunnerAction

function call
type: Class
subclass of: invocation
comment: A specific direct invocation of some function with specific arguments
example subclass: custom function call

game
type: Class
subclass of: code of conduct
comment: 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.

game event
type: Class
preferred label: game
subclass of: competition
comment: 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
type: Class
subclass of: sex and gender category
comment: 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.
example instance: female gender
example instance: male gender

GenderExpression-category
type: Class
preferred label: gender expression category
subclass of: sex and gender category
comment: 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.
example instance: feminine
example instance: masculine

geographic point
type: Class
subclass of: region
preferred label: location on the Earth's surface
comment: 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
comment: NOTE: Assume coordinate system used by Google (WGS 84 Web Mercator).
disjoint with: intellectual property
disjoint with: intention
disjoint with: language
disjoint with: magnitude
disjoint with: organization
disjoint with: physical object
disjoint with: physical substance
disjoint with: time instant
disjoint with: unit of measure
equivalent class: Class
  intersection of: Restriction
    on property: has altitude
    some values from: distance
  intersection of: Restriction
    on property: latitude
    some values from: double
  intersection of: Restriction
    on property: longitude
    some values from: double
former name: gist:GeoPoint

country government
type: Class
preferred label: government
comment: The geopolitical body that governs a geopolitical region recognized as a country.
equivalent class: Class
  intersection of: government organization
  intersection of: Restriction
    on property: governs
    some values from: region
  intersection of: Restriction
    on property:
      inverse of: recognizes
    some values from: organization
former name: gist:CountryGovernment

government organization
type: Class
preferred label: government
comment: 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.
comment: EXAMPLES: The State of Washington Office of Financial Management; the Food and Drug Administration; the Scottish Parliament.
comment: NOTE: Establishment by a CountryGovernment may be indirect via local, regional, or national GovernmentOrganization(s) that ultimately are recognized by a CountryGovernment.
equivalent class: Class
  intersection of: organization
  intersection of: Restriction
    on property:
      inverse of: recognizes
    some values from: country government
former name: gist:GovernmentOrganization

group purhasing organization
type: Class
subclass of: organization
preferred label: group purchasing organization
alternative label: GPO
comment: 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
type: Class
subclass of: collection
comment: 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.
equivalent class: Restriction
  on property: has member
  all values from: person
former name: gist:Group

GUI
type: Class
subclass of: software interface
alternative label: graphical user interface
comment: A visual component via which a user may interact with a software application.

gynecologist
type: Class
subclass of: doctor
comment: olive:Gynecologist is the class of all gynecologists.

HCPCS code
type: Class
alternative label: healthcare common procedure coding system code
subclass of: service code category
comment: 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
type: Class
subclass of: medical care organization
subclass of: system
preferred label: health system
comment: 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
type: Class
subclass of: situation state
comment: 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.
example subclass: injury
example subclass: allergy
example instance: ex:MyTwistedAnkle

home care event
type: Class
subclass of: medical care event
comment: 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.
example instance: :CaseysHomeCarePostSurgery

hospital
type: Class
subclass of: medical care organization
comment: 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.
maps to: Hospital
URI template:
  unique text: olive:Hospital/ribbonUuid=
  uri uses property: ribbonUuid
  note: Applicable when importing data from the RibbonHealth API

childrens hospital
type: Class
subclass of: hospital
preferred label: children's hospital
comment: 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
type: Class
subclass of: hospital
comment: 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
type: Class
subclass of: hospital
comment: Psychiatric hospitals are olive:Hospitals that focus on providing psychiatric care.

VA hospital
type: Class
subclass of: hospital
preferred label: VA medical center
alternative label: veteran's affairs hospital
alternative label: VA
alternative label: VAMC
comment: VA hospitals are run by the United States Department of Veterans Affairs.

hospital system
type: Class
subclass of: medical care organization
subclass of: system
preferred label: health system
comment: A hospital system is an organization that consists of more than one hospital that function together as part of a system.
disjoint with: healthcare system

human activity type
type: Class
instance of: second order class
subclass of: facet
preferred label: type of human activity
instances are subclasses Of: event
faceting of class: Restriction
  on property: done by agent
  some values from: agent
comment: 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').
example subclass: physical activity type

ID
type: Class
subclass of: content
subclass of: nonphysical artifact
preferred label: identifier
comment: EXAMPLE: e.g. SSN for a person, serial number for a product, employee id
comment: EXAMPLES: SSN for a person; serial number for a product; employee ID.
equivalent class: Class
  intersection of: content
  intersection of: Restriction
    on property:
      inverse of: creates ID
    some values from: Class
      union of: intellectual property
      union of: organization
      union of: person
  intersection of: Restriction
    on property: unique text
    some values from: string
URI template:
  unique text: http://data.oliveai.com/ontology/ID/uniqueText/sha1=
  note: 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.
  uri template uses property: creates ID
  uri template uses property: name
  uri template uses property: identifying text

implementation success owner
type: Class
alternative label: ISO
subclass of: professional
comment: 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
type: Class
subclass of: health condition
comment: 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).
example instance: ex:MyTwistedAnkle

intellectual property
type: Class
subclass of: nonphysical artifact
equivalent class: Restriction
  on property: intellectual property of
  some values from: agent
alternative label: IP
comment: 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.
comment: EXAMPLES: ?The Old Man and The Sea?; the Page Rank algorithm; Coca Cola
comment: 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).
disjoint with: intention
disjoint with: magnitude
disjoint with: organization
disjoint with: physical object
disjoint with: physical substance
disjoint with: time instant
disjoint with: unit of measure
former name: gist:IntellectualProperty

intention
type: Class
comment: 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 t…
example subclass: Desire
example subclass: Goal
former name: gist:Intention
disjoint with: magnitude
disjoint with: organization
disjoint with: physical object
disjoint with: physical substance
disjoint with: time instant
disjoint with: unit of measure

invocation
type: Class
subclass of: event
alternative label: execution
comment: 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).

input
type: Class
subclass of: variable
preferred label: function input
comment: 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).

insurance claim
type: Class
subclass of: obligation
comment: 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.
example triple: :Claim123 a olive:InsuranceClaim; olive:claimForEvent :BillsAppt; [owl:inverseOf olive:policyForClaim] :BillsInsurancePolicy.

paid insurance claim
type: Class
subclass of: insurance claim
preferred label: paid claim
comment: Paid insurance claims are those where the full contracted amount has been recovered by the provider.
disjoint with: underpaid insurance claim
equivalent class: Restriction
  on property: has status
  has value: PaidClaim

underpaid insurance claim
type: Class
subclass of: insurance claim
preferred label: underpaid claim
alternative label: underpayment
comment: 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.

insurance claim type
type: Class
subclass of: category
preferred label: types of insurance claims
comment: 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.
example subclass: RARC
example subclass: CARC

insurance company
type: Class
subclass of: organization
alternative label: payor
comment: 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).
URI template:
  unique text: olive:InsuranceCompany/ribbonName=
  uri uses property: Ribbon name
  note: Applicable when importing data from the RibbonHealth API

insurance plan
type: Class
subclass of: commitment
comment: 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.
example instance: ex:OlivesCignaPlan
URI template:
  unique text: olive:InsurancePlan/ribbonUuid=
  uri uses property: ribbonUuid
  note: Applicable when importing data from the RibbonHealth API

EPO insurance plan
type: Class
preferred label: EPO
alternative label: exclusive provider organization insurance plan
subclass of: insurance plan
comment: olive:InsurancePlan-EPO is the class of all exclusive provider organization plans.
maps to: EPO

HDHP insurance plan
type: Class
preferred label: HDHP
alternative label: high deductible health plan
subclass of: insurance plan
comment: olive:InsurancePlan-HDHP is the class of all high deductible health plans.
maps to: HDHP

HMO insurance plan
type: Class
preferred label: HMO
alternative label: health maintenance organization insurance plan
subclass of: insurance plan
comment: 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.
maps to: HMO

POS insurance plan
type: Class
preferred label: POS
alternative label: point of service plan
subclass of: insurance plan
comment: olive:InsurancePlan-POS is the class of all point of service plans.
maps to: POS

PPO insurance plan
type: Class
preferred label: PPO
alternative label: preferred provider plan
subclass of: insurance plan
comment: 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.
maps to: PPO

Uninsured insurance plan
type: Class
preferred label: Uninsured
alternative label: preferred provider plan
subclass of: insurance plan
comment: 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.

insurance policy
type: Class
subclass of: contract
comment: 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.
example triple: :Bob :hasInsurancePolicy [a olive:InsurancePolicy; olive:identifiedBy [olive:uniqueText "Policy ABC123"^^xsd:string]]

insurance portal
type: Class
preferred label: insuranceportal
subclass of: nonphysical artifact
comment: olive:InsurancePortal is the class of all insurance portals.

internship
type: Class
subclass of: employment
comment: 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.
maps to: Internship

key value pair
type: Class
subclass of: list
comment: 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
type: Class
subclass of: network
subclass of: dataset content
comment: 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.
instance of: structured data

read only knowledge graph
type: Class
equivalent class:
  intersection of: knowledge graph
  intersection of: Restriction
    on property: categorized by
    has value: read only
comment: olive:KnowledgeGraph-ReadOnly is the class of all knowledge graphs that are read only.
disjoint with: volatile graph

language
type: Class
subclass of: nonphysical artifact
comment: 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++.
disjoint with: magnitude
disjoint with: organization
disjoint with: physical object
disjoint with: physical substance
disjoint with: time instant
disjoint with: unit of measure
former name: gist:Language

letter grade
type: Class
subclass of: qualitative assessment
alternative label: grade
comment: Letter grades are things like A, B, C, D, and F. These will be the instances of this class.

license
type: Class
subclass of: certification
comment: 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.

line item
type: Class
subclass of: content
comment: 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.

list
type: Class
subclass of: content
subclass of: ordered collection
comment: A list is a data structure that contains an ordered list of members.
example subclass: key value pair

living thing
type: Class
subclass of: physical object
former name: gist:LivingThing
comment: 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
type: Class
subclass of: medical care organization
comment: 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.
example subclass: NursingHome

luminous intensity
type: Class
preferred label: brightness
comment: 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.
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: luminous intensity unit
former name: gist:LuminousIntensity

luminous intensity unit
type: Class
comment: The measure of brightness. The SI unit is the candela.
disjoint with: mass unit
disjoint with: Mole Unit
disjoint with: temperature unit
equivalent class: Class
  intersection of: simple unit
  intersection of: Restriction
    on property: has base unit
    has value: candela
former name: gist:LuminousIntensityUnit

magnitude
type: Class
subclass of: attribute
comment: 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 m…
example subclass: temperature
example subclass: distance
example subclass: mass
example triple: :EiffelTower olive:hasMagnitude :_Extent_ETHeight
disjoint with: organization
disjoint with: physical object
disjoint with: physical substance
disjoint with: time instant
disjoint with: unit of measure
former name: gist:Magnitude

male
type: Class
subclass of: living thing
comment: 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.
equivalent class: Restriction
  on property: assigned sex
  has value: male sex

mapping event
type: Class
subclass of: invocation
comment: 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
type: Class
subclass of: category
comment: The category of mapping statuses. See the comment on the relation olive:mappingStatus.

mass
type: Class
comment: 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.
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: mass unit
former name: gist:Mass

mass unit
type: Class
comment: A unit representing the amount of matter in a particle or object. The SI unit of mass is the kilogram.
disjoint with: Mole Unit
disjoint with: temperature unit
equivalent class: Class
  intersection of: simple unit
  intersection of: Restriction
    on property: has base unit
    has value: kilogram
former name: gist:MassUnit

meaningful use stage
type: Class
subclass of: certification
comment: 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 identifier
type: Class
subclass of: ID
preferred label: Medicaid ID
alternative label: Medicaid number
comment: This is the subclass of olive:ID for all Medicaid Identifiers.

medical care event
type: Class
subclass of: event
comment: 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).
example triple: :MyDoctorVisit a olive:MedicalCareEvent; olive:occursAt :MyLocalHospital.
subclass of: Class
  intersection of: Restriction
    on property: event patient
    some values from: patient
  intersection of: Restriction
    on property: event care provider
    some values from: medical professioal

medical care event cohort
type: Class
subclass of: cohort
comment: olive:MedicalCareEventCohort is the class of all cohorts that are subclasses of olive:MedicalCareEvent.
faceting of class: medical care event

medical care organization
type: Class
subclass of: medical care provider
subclass of: organization
comment: olive:MedicalCareOrganization is the class of all organizations that essentially provide medical care.
URI template:
  unique text: olive:MedicalCareOrganization/ribbonUuid=
  uri uses property: ribbonUuid
  note: Applicable when importing data from the RibbonHealth API

medical care provider
type: Class
subclass of: agent
comment: 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.
example subclass: doctor
example subclass: hospital
URI template:
  unique text: http://data.oliveai.com/ontology/MedicalCareProvider/npi=
  note: All health care providers (physicians, suppliers, hospitals, and others) may get an NPI.
  note: 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.
  uri template uses property: npi
URI template:
  unique text: http://data.oliveai.com/ontology/MedicalCareProvider/ssn=
  comment: While npi is the preferred method, you can also identify providers by their SSN.
  uri template uses property: ssn
class identifying property: npi
class identifying property: ssn

medical encounter
type: Class
subclass of: medical care event
comment: 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
type: Class
subclass of: medical encounter
comment: olive:MedicalEncounter-Elective is the class of all medical encounters where the patient elects to be admitted for some procedure.
disjoint with: MedicalEncounter-outpatient

MedicalEncounter-inpatient
type: Class
preferred label: inpatient medical encounter
subclass of: medical encounter
comment: 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.
disjoint with: MedicalEncounter-outpatient

MedicalEncounter-outpatient
type: Class
preferred label: outpatient medical encounter
subclass of: medical encounter
comment: 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.

medical fellowship
type: Class
preferred label: fellowship
subclass of: post graduate education
subclass of: employment
comment: 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.
disjoint with: medical residency
maps to: Fellowship

medical implant
type: Class
subclass of: physical artifact
alternative label: implant
comment: The class of all medical implants.
note: This class will likely be deprecated in favor of integrating with a medical device ontology.

medical professioal
type: Class
subclass of: professional
subclass of: medical care provider
preferred label: medical professional
comment: 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.
example subclass: doctor
example subclass: nurse

medical record number
type: Class
preferred label: MRN
subclass of: ID
comment: 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.

medical residency
type: Class
preferred label: residency
subclass of: post graduate education
subclass of: employment
comment: 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)
example instance: Barb's residency at Meriter Hospital
maps to: Residency

Medicare identifier
type: Class
subclass of: ID
preferred label: Medicare ID
alternative label: Medicare number
comment: This is the subclass of olive:ID for all Medicare Identifiers.

Medicare OSCAR ID
type: Class
subclass of: Medicare identifier
alternative label: Medicare OSCAR number
alternative label: Medicare OSCAR provider number
comment: This is the subclass of olive:MedicareIdentifier for all Medicare OSCAR (online survey certification and reporting system) provider IDs.

Medicare NSC ID
type: Class
subclass of: Medicare identifier
alternative label: Medicare NSC number
comment: This is the subclass of olive:MedicareIdentifier for all Medicare NSC (National Supplier Clearinghouse) IDs.

Medicare PIN
type: Class
subclass of: Medicare identifier
alternative label: Medicare provider identification number (PIN)
comment: This is the subclass of olive:MedicareIdentifier for all Medicare provider IDs.

Medicare UPIN
type: Class
subclass of: Medicare identifier
alternative label: Medicare unique physician identification number (UPIN)
comment: This is the subclass of olive:MedicareIdentifier for all Medicare unique physician identification numbers.

mental health condition
type: Class
subclass of: mental state
subclass of: health condition
comment: 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
type: Class
subclass of: situation state
comment: olive:MentalState is the class of all static situations in which some actor (usually an agent) occupies a particular mental state.
example subclass: emotional state
example subclass: confused state
example subclass: mental health condition

message
type: Class
subclass of: content
subclass of: nonphysical artifact
comment: 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.
subclass of:
  intersection of: content
  intersection of: Restriction
    on property: from agent
    some values from: agent
  intersection of: Restriction
    on property: to agent
    some values from: agent
former name: gist:Message

meta graph
type: Class
preferred label: metagraph
subclass of: knowledge graph
comment: 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
type: Class
subclass of: product category
comment: 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.
example instance: bronze metal level

molar quantity
type: Class
comment: Amount of a substance, as counted molecules.
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: Mole Unit
former name: gist:MolarQuantity

Mole Unit
type: Class
preferred label: mole unit
comment: Amount of chemical material. Measured in Avogadro units (moles) of 6.02 x 10^23 molecules.
disjoint with: temperature unit
equivalent class: Class
  intersection of: simple unit
  intersection of: Restriction
    on property: has base unit
    has value: mole
former name: gist:MoleUnit

monetary
type: Class
preferred label: monetary amount
comment: 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.
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: currency unit
former name: gist:Monetary

month instant
type: Class
comment: A point in time known only to the accuracy of one day. Say the signing of the declaration of independence on 7/4/1776
equivalent class: Class
  intersection of: time instant
  intersection of: Restriction
    on property: has magnitude
    some values from: Class
      intersection of: Restriction
        on property: has precision
        has value: 1
      intersection of: Restriction
        on property: has unit of measure
        has value: month

moving something
type: Class
subclass of: event
comment: 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.
example subclass: delivery
example instance: ex:StephCurrysGamewinningShot

National Provider Identifier
type: Class
subclass of: ID
preferred label: NPI
alternative label: National Provider Identifier (NPI)
alternative label: NPI number
comment: This is the subclass of olive:ID for National Provider Identifiers.
URI template:
  unique text: http://data.oliveai.com/ontology/NationalProviderIdentifier/uniqueText=
  note: 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.
  uri template uses property: unique text

replacement National Provider Identifier
type: Class
subclass of: National Provider Identifier
preferred label: NPI
alternative label: National Provider Identifier (NPI)
alternative label: NPI number
comment: 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
type: Class
subclass of: National Provider Identifier
preferred label: NPI
alternative label: National Provider Identifier (NPI)
alternative label: NPI number
comment: 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
type: Class
comment: A network is a connected set of links and nodes
subclass of: nonphysical thing
former name: gist:Network

network link
type: Class
subclass of: nonphysical thing
alternative label: edge
comment: 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
former name: gist:NetworkLink

network node
type: Class
subclass of: nonphysical thing
alternative label: node
comment: 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.
former name: gist:NetworkNode

NUCC provider taxonomy code
type: Class
subclass of: ID
comment: This is the subclass of olive:ID for NUCC provider taxonomy codes.
URI template:
  unique text: http://data.oliveai.com/ontology/NUCCProviderTaxonomyCode/uniqueText=
  uri template uses property: unique text

natural language
type: Class
preferred label: language
subclass of: language
comment: olive:NaturalLanguage is the class of all languages that evolve 'naturally', usually juxtaposed with formal languages such as logics and programming languages.
example instance: english language
example instance: FarsiLanguage

nonphysical artifact
type: Class
subclass of: artifact
subclass of: nonphysical thing
equivalent class:
  intersection of: artifact
  intersection of: nonphysical thing
alternative label: abstract artifact
alternative label: conceptual work
comment: 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.
example subclass: content
example subclass: intellectual property
disjoint with: physical artifact

nonphysical thing
type: Class
subclass of: Thing
disjoint with: physical thing
disjoint with: attribute
disjoint with: situation
disjoint with: time interval
comment: 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.
example subclass: nonphysical artifact
example subclass: variable

nurse
type: Class
subclass of: medical professioal
comment: olive:Nurse is the subclass of olive:MedicalProfessionals who are nurses.
mapsTo-provider type: Nursing

obligation
type: Class
subclass of: requirement
comment: 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.
subclass of: Restriction
  on property: binding for agent
  some values from: agent
former name: gist:Obligation

OHM
type: Class
subclass of: message
alternative label: Olive human message
comment: 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
type: Class
preferred label: Olive employee
subclass of: professional
equivalent class: Restriction
  on property: employer
  has value: Olive
equivalent class: Restriction
  on property: employee
  some values from:
    intersection of: employment
    intersection of: Restriction
      on property: employer
      has value: Olive
comment: olive:OliveEmployee is the class of all people who are employed by Olive.
URI template:
  unique text: http://data.oliveai.com/ontology/OliveEmployee/namelyHref=
  uri uses property: namely href

oncologist
type: Class
subclass of: doctor
comment: This is the class of all doctors who specialize in oncology. Not to be confused with an ontologist!
example subclass: medical oncologist
example subclass: surgical oncologist
example subclass: radiation oncologist
equivalent class: Class
  intersection of: doctor
  intersection of: Restriction
    on property: specializes in
    has value: Exemplar Cancer

medical oncologist
type: Class
subclass of: oncologist
comment: This is the subclass of olive:Oncologist where they specialize in chemotherapy or other drug treatments for cancer.
equivalent class: Class
  intersection of: oncologist
  intersection of: Restriction
    on property: specializes in
    has value: Exemplar Chemotherapy

radiation oncologist
type: Class
subclass of: oncologist
preferred label: ratiation oncologist
comment: This is the subclass of olive:Oncologist where they specialize in radiation therapy to treat cancer.
equivalent class: Class
  intersection of: oncologist
  intersection of: Restriction
    on property: specializes in
    has value: Exemplar RadiationTherapy

surgical oncologist
type: Class
subclass of: oncologist
comment: This is the subclass of olive:Oncologist where they specialize in surgical treatments for cancer.
equivalent class: Class
  intersection of: oncologist
  intersection of: Restriction
    on property: specializes in
    has value: Exemplar Surgery

ontologist
type: Class
alternative label: ontological engineer
alternative label: OE
alternative label: ontology engineer
subclass of: professional
comment: 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
type: Class
subclass of: category
comment: 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.
example instance: stub term
example instance: term requiring review

ordered collection
type: Class
subclass of: collection
comment: A collection where the members are in a fixed sequence.
former name: gist:OrderedCollection

ordinal collection
type: Class
subclass of: list
subclass of: ordered collection
preferred label: list
comment: 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.
former name: gist:OrdinalCollection

organization
type: Class
subclass of: agent
comment: 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.
example subclass: government organization
disjoint with: physical object
disjoint with: physical substance
disjoint with: time instant
disjoint with: unit of measure

output
type: Class
subclass of: variable
preferred label: function output
comment: 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).

partnership
type: Class
subclass of: relationship
comment: 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.

patient
type: Class
subclass of: person
comment: 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
type: Class
subclass of: cohort
comment: olive:PatientCohort is the class of all cohorts that are subclasses of olive:Patient.
faceting of class: patient

patient disposition category
type: Class
subclass of: category
comment: 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.
example instance: Disposition-ToHomeCare
example instance: Disposition-Deceased
example instance: Disposition-LongTermCare

patient encounter review
type: Class
subclass of: assessing something
alternative label: encounter utilization review
alternative label: case management
alternative label: encounter utilization review and case management
comment: 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.
subclass of: Restriction
  on property: Precedes
  some values from: charge capture coding

patient scheduling
type: Class
subclass of: event
comment: 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.
subclass of: Restriction
  on property: Precedes
  some values from: point of service event

patient status
type: Class
subclass of: status
comment: This is the class of tags for patients and their statuses. It can include patient triage scores, dispositions and so on.

paying for something
type: Class
subclass of: transfer event
comment: 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
type: Class
subclass of: event
preferred label: payment resolution
comment: 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
type: Class
subclass of: doctor
comment: olive:Pediatrician is the class of all pediatricians.

periodical
type: Class
subclass of: content
subclass of: nonphysical artifact
comment: 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
type: Class
subclass of: agent
subclass of: living thing
comment: 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.
former name: gist:Person
URI template:
  unique text: olive:Person/ssn=
  uri template uses property: ssn
class identifying property: ssn

physical activity type
type: Class
preferred label: type of physical activity
instance of: second order class
subclass of: human activity type
faceting of class: Restriction
  on property: done by agent
  some values from: agent
comment: 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.
example instance: Running
example instance: Biking
example instance: Walking

physical address
type: Class
subclass of: address
subclass of: physical artifact
equivalent class:
  intersection of: address
  intersection of: physical thing
comment: 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.

physical artifact
type: Class
subclass of: artifact
subclass of: physical thing
equivalent class:
  intersection of: artifact
  intersection of: physical thing
comment: 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.
example subclass: building
example subclass: equipment

physical exam
type: Class
subclass of: medical care event
preferred label: physical examination
alternative label: physical
comment: 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
type: Class
subclass of: physical thing
alternative label: physical item
comment: 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.
example subclass: equipment
example subclass: living thing
disjoint with: time instant
disjoint with: unit of measure
disjoint with: physical substance
former name: gist:PhysicalIdentifiableItem

physical substance
type: Class
subclass of: physical thing
subclass of:
  intersection of: Restriction
    on property: has magnitude
    some values from: mass
  intersection of: Restriction
    on property: has magnitude
    some values from: volume
preferred label: substance
comment: 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.
former name: gist:PhysicalSubstance
disjoint with: time instant
disjoint with: unit of measure

physical thing
type: Class
comment: 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.
example subclass: physical object
example subclass: physical substance
example subclass: equipment
disjoint with: situation
disjoint with: attribute
disjoint with: time interval

physician group
type: Class
subclass of: medical care organization
subclass of: group
comment: 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
type: Class
alternative label: area
comment: 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.
example subclass: region
example subclass: building
example subclass: virtual address
former name: gist:Place

point of service event
type: Class
subclass of: event
comment: 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.
subclass of: Restriction
  on property: has subevent
  some values from: medical care event
subclass of: Restriction
  on property: Precedes
  some values from: patient encounter review

post graduate education
type: Class
preferred label: post-graduate education
subclass of: education
comment: olive:PostGraduateEducation is the class of all education events that typically require and follow an undergraduate degree, such as a Bachelor's degree.
example subclass: medical residency

prescribing a drug
type: Class
subclass of: medical care event
subclass of: requesting something
comment: This is the subclass of olive:MedicalCareEvent in which the patient is prescribed some drug or drugs in a medical context.
equivalent class: Restriction
  on property: event creates
  some values from: prescription
subclass of: Restriction
  on property: communicated content
  some values from: prescription

prescription
type: Class
subclass of: request
comment: 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'.
example instance: :MyXanaxPrescription
equivalent class:
  intersection of: Restriction
    on property:
      inverse of: author of
    some values from: medical professioal
  intersection of: Restriction
    on property: requested thing
    some values from: drug

procedure
type: Class
subclass of: nonphysical artifact
subclass of: template
subclass of: constraint
alternative label: algorithm
alternative label: process
alternative label: method
comment: 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
type: Class
subclass of: artifact
comment: olive:Product is the class of all artifacts that are intended to be sold.

product category
type: Class
subclass of: category
comment: Any of many ways of categorizing products, including models, NATO product codes, and the like.
former name: gist:ProductCategory

product unit type
type: Class
instance of: second order class
subclass of: facet
alternative label: unit type
instances are subclasses Of: collection
comment: 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).
see also: product unit type

product magnitude
type: Class
comment: A magnitude expressed as a product of primitives. (E.g., Force = M*A).
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: product unit
former name: gist:ProductMagnitude

product unit
type: Class
subclass of: unit of measure
comment: 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.
former name: gist:ProductUnit

product unit type
type: Class
instance of: second order class
subclass of: facet
alternative label: unit type
instances are subclasses Of: artifact
comment: 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
type: Class
subclass of: product category
subclass of: status
comment: 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
type: Class
alternative label: employed person
subclass of: person
comment: olive:Professional is the class of all persons who do some job professionally.

proposition
type: Class
subclass of: content
comment: 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
type: Class
subclass of: qualitative assessment
comment: 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
type: Class
subclass of: category
comment: 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
type: Class
subclass of: request
subclass of: function
comment: olive:Query is the class of all queries, which are a more specific kind of request. Namely, they are requests for information.
example subclass: SPARQL query

SPARQL query
type: Class
subclass of: query
comment: olive:Query-SPARQL is the class of all queries that are formatted to query RDF according to the W3C standard.
example instance: UMLS_stored_query

RARC
type: Class
subclass of: insurance claim type
alternative label: remittance advice remark code
comment: 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
type: Class
comment: EXAMPLE: Speed. The ratio magnitude is 60, the unit of measure might be MilesPerHour.
comment: NOTE: A RatioMagnitude just has one decimal value.
comment: This is a number whose unit of measure is a ratio.
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: ratio unit
former name: gist:RatioMagnitude

ratio unit
type: Class
comment: A UnitOfMeasure composed of a numerator unit and a denominator unit.
comment: EXAMPLE: Miles per hour.
comment: 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.
equivalent class: Class
  intersection of: unit of measure
  intersection of: Restriction
    on property: denominator
    some values from: unit of measure
  intersection of: Restriction
    on property: numerator
    some values from: unit of measure
former name: gist:RatioUnit

reactivation
type: Class
subclass of: change event
comment: 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
type: Class
subclass of: category
comment: olive:ReasoningLevel is the class of all reasoning types or levels. These can be thought of as isomorphic to inference engines.
example instance: SL-stardog reasoning level

recommendation
type: Class
subclass of: content
subclass of: nonphysical artifact
comment: 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.
example subclass: Recommendation-CPA

data record
type: Class
subclass of: content
subclass of: nonphysical artifact
preferred label: record (data)
comment: 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.

receiving a drug
type: Class
subclass of: transfer event
comment: 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.
example subclass: vaccination

region
type: Class
subclass of: place
subclass of: physical object
comment: 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.
disjoint with: intellectual property
disjoint with: magnitude
disjoint with: organization
disjoint with: time instant
disjoint with: unit of measure
former name: gist:GeoRegion

relationship
type: Class
subclass of: situation state
comment: 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.
example subclass: account
subclass of: Restriction
  on property: has party
  min cardinality: 2
disjoint with: contract

contractual relationship
type: Class
subclass of: relationship
comment: These are the relationships that are governed by some--that is, at least one--contract (see olive:Contract).
equivalent class: Class
  intersection of: relationship
  intersection of: Restriction
    on property:
      inverse of: governs
    some values from: contract

non-contractual relationship
type: Class
subclass of: relationship
comment: These are the relationships that are not governed by any contract. All other relationships are instances of olive:Relationship-Contractual.
disjoint with: contractual relationship

requesting communication
type: Class
subclass of: requesting something
comment: 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.
example instance: ex:SurveyRequest201
equivalent class:
  intersection of: requesting something
  intersection of: Restriction
    on property: requested thing
    some values from: communication event

requesting equipment
type: Class
subclass of: requesting something
comment: 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.
example instance: :BillsOrderingAnAlternator
equivalent class:
  intersection of: requesting something
  intersection of: Restriction
    on property: requested thing
    some values from: equipment

requesting medical care event
type: Class
preferred label: requesting a medical procedure
subclass of: requesting something
comment: 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.
example instance: :BillsOrderingAnAlternator
equivalent class:
  intersection of: requesting something
  intersection of: Restriction
    on property: requested thing
    some values from: medical care event

requesting something
type: Class
alternative label: ordering something
subclass of: communication event
comment: Requesting something is the class of all communication events in which a request is made.
example subclass: prescribing a drug
example instance: ex:MyAskingForARaise
equivalent class: Restriction
  on property: communicated content
  some values from: request

request
type: Class
alternative label: demand
alternative label: order
subclass of: content
subclass of: nonphysical artifact
comment: 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.
example subclass: prescription
example instance: :Prescription1

requirement
type: Class
subclass of: intention
subclass of: constraint
comment: 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.
former name: gist:Requirement

responding to something
type: Class
subclass of: communication event
comment: 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.

revenue cycle
type: Class
subclass of: event
alternative label: rev cycle
comment: 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.
equivalent class: Class
  intersection of: Restriction
    on property: has subevent
    some values from: patient scheduling
  intersection of: Restriction
    on property: has subevent
    some values from: point of service event
  intersection of: Restriction
    on property: has subevent
    some values from: patient encounter review
  intersection of: Restriction
    on property: has subevent
    some values from: charge capture coding
  intersection of: Restriction
    on property: has subevent
    some values from: claim submission
  intersection of: Restriction
    on property: has subevent
    some values from: claim processing
  intersection of: Restriction
    on property: has subevent
    some values from: payment posting, appeals, and collections

room
type: Class
subclass of: place
subclass of: container
subclass of: physical artifact
comment: An enclosed area within a building.
former name: gist:Room

data row
type: Class
subclass of: collection
subclass of: section
preferred label: row
alternative label: record
comment: 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
type: Class
subclass of: organization
comment: 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.
example subclass: university

section
type: Class
subclass of: content
comment: 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.
equivalent class:
  intersection of: Restriction
    on property: part of
    some values from: content
  intersection of: content

segmentation strategy
type: Class
subclass of: category
comment: Instances are tags for marketing strategies that segment the market along some specified difference. Examples would include regional or demographic segmentation.

sensitive information type
type: Class
subclass of: data classification type
preferred label: type of sensitive information
comment: 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.
example instance: SensitiveInfo PHI
example instance: SensitiveInfo Olive IP

sensor
type: Class
subclass of: equipment
comment: A device that can detect something and report it. Light sensors, temperature sensors,
former name: gist:Sensor

service code category
type: Class
preferred label: service code
subclass of: category
comment: 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 category
type: Class
preferred label: sex and gender classification
subclass of: category
comment: 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.
example subclass: sex-category
example subclass: gender category
example instance: male sex
example instance: male gender

sex-category
type: Class
preferred label: sex category
subclass of: sex and gender category
comment: 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.
example instance: female sex
example instance: male sex

simple unit
type: Class
subclass of: unit of measure
comment: 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).
former name: gist:SimpleUnitOfMeasure

situation
type: Class
equivalent class:
  union of: event
  union of: situation state
comment: 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.

snippet
type: Class
subclass of: content bearing thing
comment: 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.
equivalent class: Restriction
  on property: instantiates
  some values from: section
equivalent class:
  intersection of: Restriction
    on property: part of
    some values from: content bearing thing
  intersection of: content bearing thing

software application
type: Class
subclass of: nonphysical artifact
comment: 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
type: Class
subclass of: professional
comment: olive:SoftwareEngineer is the class of all software engineers.

software interface
type: Class
subclass of: nonphysical artifact
subclass of: Restriction
  on property: part of
  some values from: software application
comment: 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.
example subclass: API
example subclass: GUI

sport
type: Class
subclass of: game
comment: 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.
example subclass: TeamSport
example subclass: BallSport
example subclass: CourtSport

sport
type: Class
subclass of: game event
instance of: physical activity type
comment: 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.
example subclass: BasketballGame
example subclass: FootballGame

SSN
type: Class
subclass of: ID
alternative label: Social Security Number (SSN)
alternative label: social
alternative label: social security number
comment: This is the subclass of olive:ID for social security numbers.

SSVID
type: Class
preferred label: SSV ID
subclass of: ID
comment: olive:SSVID is the class of all identifiers for entities that occur in the SSV data.
identifier supports URI template: SSV URI template

situation state
type: Class
disjoint with: event
subclass of: situation
preferred label: state
alternative label: static situation
alternative label: state of affairs
comment: 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 …

US state
type: Class
subclass of: region
preferred label: state
comment: 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.

status
type: Class
subclass of: category
comment: 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.
example subclass: account status
example subclass: product status

stored query
type: Class
subclass of: SPARQL query
comment: olive:StoredQuery is the class of all SPARQL queries that have been saved for future use.

structured data
type: Class
instance of: second order class
subclass of: facet
instances are subclasses Of: dataset content
comment: 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
type: Class
subclass of: person
comment: 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).
mapsTo-provider type: Student

surgery
type: Class
subclass of: medical care event
comment: This is the subclass of olive:MedicalCareEvent in which a surgery is performed.

system
type: Class
subclass of: Thing
comment: 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? …

data table
type: Class
subclass of: section
preferred label: table
comment: 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
type: Class
subclass of: commitment
comment: 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).
example instance: ex:MyDoingTheDishes

taxonomy
type: Class
subclass of: knowledge graph
comment: olive:Taxonomy is the class of all tree-structure knowledge graphs that provide a hierarchical vocabulary for classifying things.
example instance: the Linnaean taxonomy

US territory
type: Class
subclass of: region
preferred label: territory
comment: 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.

telephone number
type: Class
subclass of: virtual address
preferred label: phone number
comment: A numeric code a telephonic device uses for contacting another telephonic device.
comment: EXAMPLES: Mobile, fax, or landline phone number.
former name: gist:TelephoneNumber
equivalent class: Restriction
  on property: categorized by
  has value: phone contact type
URI template:
  unique text: olive:PhoneNumber/ribbonUuid={uuid};number={number}
  uri uses property: ribbonUuid
  note: 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
type: Class
comment: The degree or intensity of heat present in a substance or object, especially as expressed according to a comparative scale.
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: temperature unit
former name: gist:Temperature

temperature unit
type: Class
comment: 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.
equivalent class: Class
  intersection of: simple unit
  intersection of: Restriction
    on property: has base unit
    has value: Kelvin
  intersection of: Restriction
    on property: conversion offset
    some values from: double
former name: gist:TemperatureUnit

template
type: Class
subclass of: artifact
comment: EXAMPLE: A form. A filled-in form has the structure of the form with data entered into some or all of the fields.
comment: 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.
disjoint with: time instant
disjoint with: unit of measure
former name: gist:Template

test
type: Class
subclass of: request
comment: 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.
example subclass: Test-software

Test-software
type: Class
preferred label: test
subclass of: test
comment: olive:Test-Software is the class of all tests designed to ensure the proper functioning of software.

Thing
URI template:
  unique text: olive:{salient-class}/uuid=
  note: This is the most general template involving a UUID.

tier
type: Class
subclass of: section
comment: 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.

time instant
type: Class
subclass of: time interval
subclass of: Restriction
  on property: has precision
  some values from: double
subclass of: Restriction
  on property: local date
  some values from: string
subclass of: Restriction
  on property: local date time
  some values from: dateTime
subclass of: Restriction
  on property: local time
  some values from: string
subclass of: Restriction
  on property: universal date
  some values from: string
subclass of: Restriction
  on property: universal date time
  some values from: dateTime
subclass of: Restriction
  on property: universal time
  some values from: string
preferred label: point in time
comment: 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.
disjoint with: unit of measure

time interval
type: Class
alternative label: time period
subclass of: Thing
comment: 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.
example subclass: time instant
example instance: ex:TheMiddleAges

transaction
type: Class
subclass of: exchange
instance of: human activity type
comment: 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.
example sub class: buying and selling

transfer event
type: Class
subclass of: event
comment: 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.
example subclass: drug dispensation
example subclass: paying for something

unit of measure
type: Class
subclass of: nonphysical thing
alternative label: unit
comment: 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.
example subclass: base unit
example subclass: mass unit
example subclass: ratio unit
former name: gist:UnitOfMeasure

university
type: Class
subclass of: school
comment: 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.
example instance: Harvard
example instance: Pacific Lutheran University
example instance: Mount Holyoke College

urgent care center
type: Class
preferred label: urgent care
subclass of: medical care organization
comment: 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.
maps to: Urgent Care

URI template
type: Class
subclass of: template
comment: 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
type: Class
subclass of: category
comment: 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.
example instance: normal use

using something
type: Class
subclass of: event
alternative label: making use of something
alternative label: utilizing something
comment: 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
type: Class
subclass of: medical care event
subclass of: receiving a drug
comment: 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
type: Class
subclass of: nonphysical thing
comment: Variables are slots that can have values substituted in for them. Variables are often constituents of functions (see olive:Function).
example subclass: input
example subclass: output

versioned content
subclass of: content
comment: Some Content is published as a series of instantiations with explicit version names. Such publications _abstractTo_ an instance of VersionedContent.

version
subclass of: ID
preflabel: version of
comment: 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 address
type: Class
subclass of: address
subclass of: virtual thing
equivalent class:
  intersection of: address
  intersection of: virtual thing
preferred label: virtual location
comment: 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!
example subclass: email address

vector
type: Class
subclass of: nonphysical thing
comment: 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).
example subclass: force

virtual profile
type: Class
alternative label: online profile
alternative label: profile
alternative label: account
alternative label: virtual account
subclass of: virtual thing
comment: 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
type: Class
subclass of: virtual thing
alternative label: electronic payment
alternative label: virtual money
comment: 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
type: Class
subclass of: nonphysical artifact
comment: 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.
example subclass: VirtualAddress
example subclass: endpoint

visual content source
type: Class
preferred label: visual medium
alternative label: video
alternative label: visual content
subclass of: content bearing thing
comment: olive:VisualContentSource is the class of all content bearing things that are accessed (at least partly) visually. This includes photographs, charts, and videos.
example subclass: figure

volatile graph
type: Class
subclass of: knowledge graph
comment: 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.

volume
type: Class
preferred label: volumen
comment: Three-dimensional space, or equivalent fluid measurement.
equivalent class: Class
  intersection of: magnitude
  intersection of: Restriction
    on property: has unit of measure
    some values from: volume unit
former name: gist:Volume

volume unit
type: Class
subclass of: product unit
comment: Units of three-dimensional space, expressed here as an area times a distance.
former name: gist:VolumeUnit

vote
type: Class
subclass of: qualitative assessment
comment: Every instance of vote is a tag by which we can qualitatively assess something. Most notable instances include olive:Upvote and olive:Downvote.

warning
type: Class
subclass of: request
comment: 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
type: Class
subclass of: collection
subclass of: software interface
subclass of: Restriction
  on property: collection of type
  has value: function
alternative label: service
comment: 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.
example subclass: TaskRunner

week instant
type: Class
comment: A point in time known only to the accuracy of one day. Say the signing of the declaration of independence on 7/4/1776
equivalent class: Class
  intersection of: time instant
  intersection of: Restriction
    on property: has magnitude
    some values from: Class
      intersection of: Restriction
        on property: has precision
        has value: 1
      intersection of: Restriction
        on property: has unit of measure
        has value: week

white paper
type: Class
alternative label: whitepaper
subclass of: content
subclass of: nonphysical artifact
comment: 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.
maps to: White Papers

X12 message
type: Class
subclass of: message
comment: olive:X12Message is the class of all olive:Messages that are in the EDI X12 format.
example subclass: X12 835 message
example subclass: X12 837 message

X12 835 message
type: Class
subclass of: X12 message
comment: olive:X12Message-835 is the class of all 835 X12 messages, which are messages about insurance claim payments.

X12 837 message
type: Class
subclass of: X12 message
comment: olive:X12Message-837 is the class of all 837 X12 messages, which are messages about insurance claims.

year instant
type: Class
comment: A point in time known only to the accuracy of one day. Say the signing of the declaration of independence on 7/4/1776
equivalent class: Class
  intersection of: time instant
  intersection of: Restriction
    on property: has magnitude
    some values from: Class
      intersection of: Restriction
        on property: has precision
        has value: 1
      intersection of: Restriction
        on property: has unit of measure
        has value: year

about
type: ObjectProperty
sub property of: connected to
preferred label: is about
preferred label: contains information about
comment: (:_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.
example triple: :DatabaseRow6 olive:about :ElizabethFaye
comment: Subject matter of a document.
domain: content
range: Thing
example subproperty: identifies
former name: gist:about

about class
type: AnnotationProperty
sub property of: related to class
preferred label: is about
domain: content
range: Class
comment: 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.

about property
type: AnnotationProperty
preferred label: is about
domain: content
range: Property
comment: 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.
example triple: :Content1 olive:aboutProperty olive:npi

abstract of
type: ObjectProperty
sub property of: about
sub property of:
  inverse of: abstracts to
preferred label: is the abstract for
domain: abstract
range: content
comment: (: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).
example triple: :MyDissertationAbstract olive:abstractOf :MyDissertation

abstracts to
type: ObjectProperty
type: TransitiveProperty
sub property of: connected to
domain: Thing
range: nonphysical thing
comment: (: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).
example triple: :MyPhysicalCopyOfMobyDick olive:abstractsTo :MobyDick-Content

abstract text
type: DatatypeProperty
sub property of: text
preferred label: has the following abstract:
domain: content
range: string
comment: (: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.
example triple: :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 plan
type: ObjectProperty
preferred label: accepts
sub property of: agent uses
domain: medical care provider
range: insurance plan
comment: (:MedicalCareProvider1 olive:acceptsPlan :InsurancePlan1) means that MedicalCareProvider1 accepts InsurancePlan1. For example, (:DrBarry olive:acceptsPlan :CignaRedTopazPlan).
example triple: :DrBarry olive:acceptsPlan :CignaRedTopazPlan

account customer
type: ObjectProperty
sub property of: binding for agent
preferred label: services
domain: account
range: agent
comment: (: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.
example triple: :Acount234 olive:accountCustomer :GeneralMotors

account number
type: DatatypeProperty
sub property of: text
preferred label: has account number
domain: Class
  union of: account
  union of: check
  union of: commitment
range: string
comment: 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.
example triple: :MyCheck olive:accountNumber "7722551"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

account seller
type: ObjectProperty
sub property of: binding for agent
preferred label: is managed by
domain: account
range: agent
comment: (: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.
example triple: :Account234 olive:accountSeller :BankOfAmerica

address
type: DatatypeProperty
sub property of: contact information
preferred label: is located at
domain: Class
  union of: address
  union of: agent
range: string
comment: (: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.
example triple: :MyHouse olive:address "8825 29th St Ct E, Puyallup, WA 98371"^^xsd:string

address admin level 1
type: DatatypeProperty
sub property of: address
preferred label: is located at
range: string
comment: 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).
example triple: :Person1 olive:address-adminLevel2 "TX"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

address admin level 2
type: DatatypeProperty
sub property of: address
preferred label: is located at
range: string
comment: 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).
example triple: :Person1 olive:address-adminLevel2 "Travis County"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

address admin level 3
type: DatatypeProperty
sub property of: address
preferred label: is located at
range: string
comment: 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).
example triple: :Person1 olive:address-adminLevel3 "Austin"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

address city
type: DatatypeProperty
sub property of: address admin level 3
preferred label: is located at
range: string
comment: A specialization of olive:address for this specific component. E.g., (:Person1 olive:address-line1 "Puyallup"^^xsd:string).
example triple: :Person1 olive:address-line1 "Puyallup"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

address country
type: DatatypeProperty
sub property of: address
preferred label: is located in
range: string
comment: A specialization of olive:address for this specific component. E.g., (:Person1 olive:address-line1 "USA"^^xsd:string).
example triple: :Person1 olive:address-line1 "USA"^^xsd:string

full address
type: DatatypeProperty
sub property of: address
preferred label: is located at
range: string
comment: A specialization of olive:address that is used to associated a resource with a full address string.
example triple: :Person1 olive:address-full "100 Washington Ave, Rochester, NY 00101, US"^^xsd:string

address line 1
type: DatatypeProperty
sub property of: address
preferred label: is located at
range: string
comment: A specialization of olive:address for this specific component. E.g., (:Person1 olive:address-line1 "718 29th St Ct E"^^xsd:string).
example triple: :Person1 olive:address-line1 "718 29th St Ct E"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

address line 2
type: DatatypeProperty
sub property of: address
preferred label: is located at
range: string
comment: A specialization of olive:address for this specific component. E.g., (:Person1 olive:address-line2 "Suite 100"^^xsd:string).
example triple: :Person1 olive:address-line2 "Suite 100"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

address state
type: DatatypeProperty
sub property of: address admin level 1
preferred label: is located at
range: string
comment: A specialization of olive:address for this specific component. E.g., (:Person1 olive:address-line1 "WA"^^xsd:string).
example triple: :Person1 olive:address-line1 "WA"^^xsd:string

street address
type: DatatypeProperty
sub property of: address
preferred label: is located at
range: string
comment: 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).
example triple: :Person1 olive:address-line1 "718 29th St Ct E Suite 100"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

adjusted cost
type: ObjectProperty
sub property of: hasMonetaryValue
preferred label: has an adjusted cost of
alternative label: costs
alternative label: allowed amount
comment: (: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.
example triple: :MyDentalProcedure olive:grossCost [a olive:Monetary; olive:decimalValue "250"^^xsd:decimal ; olive:hasUoM olive:_USDollar]

admission source
type: DatatypeProperty
preferred label: is an admission with source
domain: medical care event
range: integer
comment: (: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).
example triple: :CostasAdmission olive:admissionType "1"^xsd:integer

admissionType
type: DatatypeProperty
preferred label: is an admission classified as
domain: medical care event
range: integer
comment: (: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).
example triple: :CostasAdmission olive:admissionType "1"^xsd:integer

admit date
type: ObjectProperty
sub property of: time of event
preferred label: began with a patient admission date of
domain: admission
range: time instant
comment: (: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]).
example triple: :MyHospitalStay olive:admitDate [a olive:TimeInstant; olive:universalDateTime "2004-12-09"^^xsd:string])
property expresses sensitive information: SensitiveInfo PHI

affected by
type: ObjectProperty
preferred label: is affected by
domain: Thing
range: Thing
inverse of: affects
comment: This is the inverse of olive:affects.

affects
type: ObjectProperty
domain: Thing
range: Thing
comment: (: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.
example subproperty: causes
example triple: :MyHunger olive:affects :MyTestPerformance

affected object
type: ObjectProperty
preferred label: affects
sub property of: affects
sub property of: event involves
domain: event
range: Thing
comment: (: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.
example triple: :NicksHunger olive:affectedObject :Nick

directly affected object
type: ObjectProperty
preferred label: directly affects
sub property of: affected object
domain: event
range: Thing
comment: (: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.
example triple: :NicksHunger olive:affectedObject-Direct :Nick

indirectly affected object
type: ObjectProperty
preferred label: indirectly affects
sub property of: affected object
domain: event
range: Thing
comment: (: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.
example triple: :BreakingNicksWindow olive:affectedObject-Indirect :Nick

affiliated with
type: ObjectProperty
type: SymmetricProperty
preferred label: is affiliated with
domain: agent
range: agent
comment: (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.
example subproperty: employs
example triple: :CarolSwinburne olive:affiliatedWith :YaleUniversity

age
type: DatatypeProperty
preferred label: has been alive for (in years):
domain: living thing
range: decimal
comment: (:LivingThing1 olive:age "DECIMAL"xsd:decimal) means that LivingThing1 has been alive for (in years): DECIMAL. For example, (: olive:age ""^^xsd:decimal).

creates
type: ObjectProperty
sub property of: creates
domain: agent
range: artifact
comment: (:Agent_1 olive:agentCreates :Artifact1) means that Agent1 is the creator of Artifact1. For example, (:AppleInc olive:agentCreates :MyMacbookPro).
example subproperty: creates ID
example triple: :AppleInc olive:agentCreates :MyMacbookPro
former name: olive:creates

agent does
type: ObjectProperty
preferred label: does
sub property of: does
domain: agent
range: event
comment: This is the subproperty of olive:does where the doer is an agent. This does not require intentionality.

agent uses
type: ObjectProperty
sub property of: uses
preferred label: uses
domain: agent
range: Thing
comment: 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.
example triple: :NovakDjokovic olive:agentUses :HeadPT113B_1

allows
type: ObjectProperty
sub property of: consistent with situation
comment: (: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.
domain: commitment
range: situation
former name: gist:allows

alpha suite link
type: DatatypeProperty
sub property of: seeAlso
sub property of: general url
preferred label: can be viewed on alpha suite at
domain: Thing
range: string
comment: (: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.
example triple: :MemorialCare olive:alphasSuiteLink "http://www.alphasuite.secure.com/org"^^xsd:string

ANSI code
type: DatatypeProperty
sub property of: identifying text
sub property of: maps to
preferred label: has the following ANSI code:
alternative label: has the following American National Standards Institute (ANSI) code:
domain: region
range: string
comment: (:Region1 olive:ansiCode "STRING"^^xsd:string) means that :Region1 has the ANSI (American National Standards Institute) code STRING.
example triple: olive:Texas olive:ansiCode "TX"^^xsd:string

assertibility
type: AnnotationProperty
preferred label: has the following assertibility status:
domain: Thing
range: assertibility status
comment: (: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).
example triple: olive:url-general olive:assertbility olive:NotAssertible

assigned sex
type: ObjectProperty
preferred label: is
sub property of: categorized by
domain: living thing
range: sex-category
comment: (: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).
example triple: :BarackObama olive:assignedSex olive:Male-Sex

sex text
type: DatatypeProperty
sub property of: gender or sex text
preferred label: is associated with the following text indicating sex:
domain: living thing
range: string
comment: (: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.
example triple: :ClintEastwood olive:assignedSexText "M"^^xsd:string
datatype property uses mapping property: mapsTo-assignedSexText
datatype property translates to property: assigned sex

associated count
type: DatatypeProperty
preferred label: is associated in some way with a count of
domain: Thing
range: integer
assertibility: not assertible
comment: (: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.
example triple: :CaseysGradebook olive:associatedCount "10"^^xsd:integer

attends
type: ObjectProperty
preferred label: attended
sub property of: affiliated with
domain: person
range: school
comment: (: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.
example triple: :Sarah olive:attends :Harvard

author of
type: ObjectProperty
sub property of: creates
sub property of: content contributor
sub property of:
  inverse of: from agent
preferred label: is the author of
domain: agent
range: content
comment: (: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.
example subproperty: first author
example subproperty: secondAuthor
example triple: :JDSalinger olive:authorOf :CatcherInTheRye
example triple: :JDSalinger olive:authorOf :MyCopyOfCatcherInTheRye

base conversion factor
type: DatatypeProperty
preferred label: can be converted to the base unit by multiplying by
comment: 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.
domain: unit of measure
range: double
former name: gist:convertToBase

base standard conversion factor
type: DatatypeProperty
sub property of: base conversion factor
preferred label: can be converted to the base unit by multiplying by
comment: 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
domain: unit of measure
range: double
former name: gist:convertToStandard

basis for
type: ObjectProperty
sub property of: causes
preferred label: is the basis for
comment: (: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.
domain: Thing
range: Thing
example triple: :MyDoctorAppt olive:basisFor :InsuranceClaimLineItem
former name: gist:basisFor

beginning subevent
type: ObjectProperty
preferred label: began with
sub property of: has subevent
domain: event
range: situation
comment: (: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.
example triple: :SuperBowlXXIII olive:beginningSubevent :KickoffOfSuperBowlXXIII

bibliographic information
type: DatatypeProperty
preferred label: can be cited as
domain: content
range: string
comment: (: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).
example triple: :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

binding for agent
type: ObjectProperty
sub property of: regulates
preferred label: is normatively binding for
domain: Class
  union of: intention
  union of: commitment
range: agent
comment: (: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.
example triple: :KosherDiet olive:bindingForAgent :SarahFranzi

body mass index
type: ObjectProperty
preferred label: has a BMI of
sub property of: has magnitude
domain: person
range: ratio magnitude
comment: (: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]).
example triple: :AlbertPujols olive:bodyMassIndex [olive:decimalValue "240"^^xsd:decimal ; olive:hasUoM olive:_kg_per_square_meter])

bought for
type: ObjectProperty
sub property of: thing transferred
preferred label: is an event in which the thing that is bought is bought for
domain: buying and selling
range: Thing
comment: (: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.
example triple: :BobsBuyingNewShoes olive:boughtFor [a olive:Currency ; olive:hasMonetaryValue [ olive:decimalValue "39.99"^^xsd:double ; olive:hasUoM olive:_USDollar]]

buyer
type: ObjectProperty
sub property of: done by agent
preferred label: involves (as the buyer)
domain: buying and selling
range: agent
comment: (: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.
example triple: :NickBuyingANewCar olive:buyer :Nick

business partners
type: ObjectProperty
type: SymmetricProperty
sub property of: partners
preferred label: is a business partner of
domain: agent
range: agent
comment: (: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.
example triple: BillGates: olive:businessPartners :PaulAllen

canonical graph for
type: ObjectProperty
preferred label: is, when current, the canonical graph for information about
sub property of: about
domain: knowledge graph
range: Thing
comment: (: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
example triple: :UMLSGraph olive:canonicalGraphFor olive:UMLS

canonical graph for property
type: AnnotationProperty
preferred label: is, when current, the canonical graph for information about
sub property of: about property
domain: knowledge graph
range: Property
comment: (: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.
example triple: :RibbonHealthGraph olive:canonicalGraphForProperty olive:npi

canonical graph for type
type: AnnotationProperty
preferred label: is, when current, the canonical graph for information about
sub property of: about class
domain: knowledge graph
range: Class
comment: (: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.
example triple: :AlphaSuiteGraph olive:canonicalGraphForType olive:CPA

carrier for
type: ObjectProperty
preferred label: is the carrier for
sub property of: governs
domain: insurance company
range: insurance plan
comment: (:InsuranceCompany1 olive:carrierFor :InsurancePlan1) means that InsuranceCompany1 is the carrier for InsurancePlan1. For example, (:Cigna olive:carrierFor :CignaRedTopazPlan).
example triple: :Cigna olive:carrierFor :CignaRedTopazPlan

categorized by
type: ObjectProperty
preferred label: is categorized as
alternative label: is tagged as
comment: 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.
domain: Thing
range: category
former name: gist:categorizedBy
typed subproperty of: data sensitivity default level

category corresponds to
type: AnnotationProperty
sub property of: related to class
preferred label: is the category version of the class
comment: (: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.
example triple: olive:Oncology-FieldCategory olive:categoryCorrespondsToClass wd:Q162555

causes
type: ObjectProperty
sub property of: affects
preferred label: causally contributes to
domain: Thing
range: Thing
comment: (: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.
example subproperty: creates
example triple: :BobsAnkle olive:causes-general :BobsRaceFinish

causes
type: ObjectProperty
type: TransitiveProperty
sub property of: causes
sub property of: Precedes
alternative label: causally contributes to
preferred label: caused
domain: event
range: event
comment: (: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'.
example triple: :BillBreakingHisLeg olive:causes :BillsDoctorVisit

cdr
type: ObjectProperty
sub property of: has part
preferred label: has a cdr of
alternative label: ends with
domain: list
range: list
comment: (: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).
example triple: :ListA olive:cdr :ListB

certification in field
type: AnnotationProperty
sub property of: certification for type
preferred label: is a certification in
domain: certification
range: Class
comment: (: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.
example triple: :BobsMS olive:certificationInField Nursing

certification for type
type: AnnotationProperty
sub property of: related to class
preferred label: is a certification for
domain: certification
range: Class
comment: (: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).
example triple: :Certification1 olive:certificationForType olive:Dentist

certification text
type: DatatypeProperty
sub property of: associated name text
preferred label: has a certification identified by the following:
domain: agent
range: string
comment: (: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).
example triple: :Nick olive:certificationText "Ph.D"^^xsd:string

full certification text
type: DatatypeProperty
sub property of: certification text
preferred label: has certification(s) identified by the following:
domain: agent
range: string
comment: (: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).
example triple: :Nick olive:certificationText-full "RN,MA"^^xsd:string

changed property
type: ObjectProperty
preferred label: changes the feature of the subject as follows:
sub property of: event involves
domain: change event
range: list
comment: (: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.
example triple: :PaintingMyWall olive:changedProperty (:hasColor :Red :Blue)

changed thing
type: ObjectProperty
preferred label: changed
sub property of: affected object
domain: change event
range: Thing
comment: (:ChangeEvent1 olive:changedThing :Thing1) means that ChangeEvent1 changed Thing1. For example, (:EditingMyDissertation olive:changedThing :MyDissertation).
example triple: :EditingMyDissertation olive:changedThing :MyDissertation

check number
type: DatatypeProperty
sub property of: text
preferred label: is check number
domain: check
range: string
comment: Relates a check to the check number (not the routing number--olive:routingNumber--or account number--olive:accountNumber).
example triple: :MyCheck olive:checkNumber "123451"^^xsd:string

cited by
type: ObjectProperty
sub property of: affects
preferred label: is cited by
range: content
domain: content
comment: (: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.
example triple: :Wikipedia olive:citedBy :MyBookReport

cited content
type: ObjectProperty
sub property of: causes
preferred label: references
alternative label: cites
domain: citation
range: content
comment: (: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.
example triple: :Footnote3Citation olive:citedContent :NamingAndNecessity

claim number
type: DatatypeProperty
sub property of: text
preferred label: has claim number
domain: insurance claim
range: string
comment: 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.
example triple: :MyClaim olive:claimNumber "1199324040235018"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

claimNumber-original
type: DatatypeProperty
preferred label: has original claim number
sub property of: claim number
comment: (: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.
example triple: :MyClaim olive:claimNumber-Original "7"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

class count
type: DatatypeProperty
preferred label: has the following number of classes:
domain: knowledge graph
range: integer
comment: (: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.
example triple: :Graph21 olive:classCount "75"^^xsd:integer

class identifying property
type: AnnotationProperty
preferred label: has instances who are partly individuated by
domain: Class
range: FunctionalProperty
comment: (: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.
example triple: olive:Person olive:classIdentifyingProperty olive:hasSSN

class is part of
type: AnnotationProperty
preferred label: is part of
domain: Class
range: Thing
comment: (: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.
example triple: olive:MedicalImplant olive:classIsPartOf Tier1InSomeMedicalSupplyTaxonomy

collection of type
type: AnnotationProperty
sub property of: related to class
preferred label: is a collection composed of
domain: collection
range: Class
comment: (: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.
example triple: :TrialJury32 olive:collectionOfType olive:Person

communicated content
type: ObjectProperty
preferred label: conveyed
alternative label: communicated
sub property of: conveyed thing
domain: communication event
range: content
comment: (:CommunicationEvent1 olive:communicatedContent :Content1) means that CommunicationEvent1 conveyed Content1. For example, (:OthelloPerformance223 olive:communicatedContent :Othello-Story).
example triple: :OthelloPerformance223 olive:communicatedContent :Othello-Story

compared thing
type: ObjectProperty
sub property of: about
preferred label: compares
domain: comparison
range: Thing
comment: (:Comparison1 olive:comparedThing :Thing1) means that Thing1 is one of the things being compared in Comparison1. See olive:Comparison's comment for more detail.
example triple: Comparison1 olive:comparedThing :Thing1

connected to
type: ObjectProperty
type: SymmetricProperty
preferred label: has a relationship with/to
domain: Thing
range: Thing
comment: (: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.
example triple: :Thing1 olive:connectedTo :Thing2
former name: gist:connectedTo

consistent with situation
type: ObjectProperty
sub property of: governs behavior
preferred label: is consistent with
alternative label: logically permits
alternative label: logically allows
alternative label: allows
alternative label: permits
alternative label: is logically consistent with
domain:
  union of: commitment
  union of: intention
range: situation
comment: (: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.

content contributor
type: ObjectProperty
sub property of: causes
preferred label: contributed to
domain: agent
range: content
comment: (: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.
example subproperty: author of
example subproperty: editor of
example subproperty: publisher of
example triple: :OxfordUniversityPress olive:contentContributor :Philosophy101Textbook

contact information
type: DatatypeProperty
preferred label: can be contacted at
domain: Class
  union of: agent
  union of: address
range: string
comment: 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.
example subproperty: phone number
example subproperty: address
example subproperty: email address string

contact person
type: ObjectProperty
preferred label: has the contact person
sub property of: affiliated with
domain: agent
range: person
comment: (:Agent1 olive:contactPerson :Person1) means that Agent1 has the contact person Person1. For example, (:KevinDurant olive:contactPerson :RichKleiman).
example triple: :KevinDurant olive:contactPerson :RichKleiman

contains
type: ObjectProperty
sub property of: spatially related to
domain: Class
  union of: place
  union of: physical thing
range: Thing
comment: (: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.
example triple: :WashingMachine olive:contains :FluffyTheCat
example triple: :France olive:contains :Casey

contains line item
type: ObjectProperty
sub property of: has part
preferred label: contains
domain: commitment
range: line item
comment: (: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.
example triple: :InsuranceClaim2 olive:containsLineItem :VaccinationForJames

contains sensitive information type
type: ObjectProperty
preferred label: contains
sub property of: categorized by
domain: content
range: sensitive information type
comment: (: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.
example triple: :NamedGraph21 olive:containsSensitiveInformationType olive:SensitiveInfo-PHI

content is current
type: DatatypeProperty
preferred label: has a currency boolean of:
domain: content
range: boolean
comment: (: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.
example triple: :GradebookForPhil204 :contentIsCurrent "false"^^xsd:boolean

contract value
type: ObjectProperty
sub property of: has magnitude
preferred label: is for
alternative label: is valued at
domain: contract
range: monetary
comment: (: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.
example triple: :MedstarContract olive:contractValue [a olive:Monetary; olive:hasUoM olive:_USDollar; olive:decimalValue "150000"^^xsd:decimal]

controls
type: ObjectProperty
sub property of: regulates
domain: agent
range: Thing
comment: (: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.
example subproperty: owns
example triple: :USFDA olive:controls :Pfizer

controls account
type: ObjectProperty
preferred label: is a user of
sub property of: owns
domain: agent
range: virtual profile
comment: (: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.
example triple: :Casey olive:controlsAccount :XboxLiveTempestuousDuke

conversion offset
type: DatatypeProperty
preferred label: is offset from the base unit by
comment: 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.
domain: unit of measure
range: double
former name: gist:conversionOffset

conveyed thing
type: ObjectProperty
preferred label: involves a conveyance of
sub property of: affected object
domain: event
range: Thing
comment: (: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.
example triple: :MyRunThisMorning olive:conveyedThing :MyBody

conveys from
type: ObjectProperty
sub property of: event involves
domain: event
range: Thing
comment: (: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.
example triple: :MyRunThisMorning olive:conveysFrom :BoylstonStreet

conveys to
type: ObjectProperty
sub property of: event involves
domain: event
range: Thing
comment: (: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.
example triple: :MyRunThisMorning olive:conveysTo :BoylstonStreet

copay cost
type: ObjectProperty
preferred label: has a copay of
sub property of: hasMonetaryValue
domain: insurance claim
range: monetary
comment: (: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.
example triple: :MyApptClaim olive:copayCost [olive:decimalValue "15"^^xsd:decimal; olive:hasUoM olive:_USDollar]

cost-patient
type: ObjectProperty
preferred label: is personally responsible for
sub property of: hasMonetaryValue
domain: Thing
range: monetary
comment: (: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..
example triple: :MyInsClaim olive:cost-Patient [olive:decimalValue "70"^^xsd:decimal; olive:hasUoM olive:_USDollar]

covers agent
type: ObjectProperty
sub property of: binding for agent
preferred label: is covered by
alternative label: is bound to
range: agent
comment: (: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.
example triple: :InsurancePolicy123 olive:coversAgent :Alice

cpt code
type: DatatypeProperty
sub property of: service code
preferred label: has the CPT code:
alternative label: has the Current Procedural Terminology Code (CPT)
domain: medical care event
range: string
comment: (: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.
example triple: :BillsAppt olive:cptCode "47350"^^xsd:string
mapsTo-ServiceCode: CJ

creates
type: ObjectProperty
sub property of: causes
domain: Thing
range: Thing
comment: (: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.
example triple: :Homer olive:creates :TheOdyssey

creates ID
type: ObjectProperty
sub property of: creates
sub property of:
  inverse of: issuing agent
preferred label: assigns
comment: 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)
domain: agent
range: ID
former name: gist:allocates

creation time
type: ObjectProperty
sub property of: time of
preferred label: was created at/on
domain: Class
  complement of: event
range: time instant
comment: (:_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.
example subproperty: has birthdate
example subproperty: recorded on
example triple: :MyCellphone olive:creationTime [a olive:TimeInstant; olive:universalDate "2013-01-01"^^xsd:date]

current as Of
type: ObjectProperty
preferred label: was current as of
sub property of: time of
domain: content
range: time instant
comment: (: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).
example triple: :UMLSGraph2021AA olive:currentAsOf [olive:universalDate "2020-01-01"^^xsd:date]

data sensitivity default level
type: ObjectProperty
preferred label: has the following default data sensitivity level:
domain: data classification type
range: data sensitivity level
comment: (: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".

datatype property uses mapping property
type: AnnotationProperty
preferred label: stores data that can be semantically transformed using
domain: DatatypeProperty
range: Property
comment: (: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.
example triple: olive:npiEntityTypeCode olive:datatypePropertyUsesMappingProperty olive:mapsTo-NPIEntityTypeCode

datatype property translates to property
type: AnnotationProperty
preferred label: stores data that can be semantically translated into a triple with the property
domain: DatatypeProperty
range: Property
comment: (: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..
example triple: olive:assignedSexText olive:datatypePropertyTranslatesToProperty olive:assignedSex

date
type: DatatypeProperty
preferred label: is related to
domain: Thing
range: date
comment: (: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.
example triple: :MyParty olive:date "2019-02-04"^^xsd:date

date certified
type: ObjectProperty
preferred label: was certified at/on
sub property of: time of
domain: Thing
range: time instant
comment: (: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.
example triple: :Record1 olive:dateCertified [olive:universalDate "2020-12-25"^^xsd:date]

has birthdate
type: ObjectProperty
sub property of: personal information
sub property of: creation time
preferred label: was born on
comment: Date a living thing was "born" (or germinated, for plants).
domain: living thing
range: time instant
former name: gist:hasBirthDate
property expresses sensitive information: SensitiveInfo PHI

date processed
type: ObjectProperty
preferred label: was processed on
sub property of: time of
domain: commitment
range: time instant
comment: (: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.
example triple: :MyRaiseRequest olive:dateProcessed [olive:date "2021-02-01"^^xsd:date]

date received
type: ObjectProperty
preferred label: was received at/on
sub property of: time of
domain: Thing
range: time instant
comment: (: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.
example triple: :MyNewBike olive:dateReceived [olive:universalDate "2020-12-25"^^xsd:date]

dateReceived-olive
type: ObjectProperty
preferred label: was received by Olive at/on
sub property of: date received
domain: Thing
range: time instant
comment: 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.

date submitted
type: ObjectProperty
preferred label: was submitted on
sub property of: time of
domain: commitment
range: time instant
comment: (:Commitment1 olive:dateSubmitted :TimeInstant1) means that Commitment1 was submitted on TimeInstant1. For example, (: olive:dateSubmitted :).

deactivation date
type: ObjectProperty
sub property of: time of
preferred label: has the following deactivation date:
domain: Thing
range: time instant
comment: This links an individual with the date on which it was deactivated. For example (:DrRicesNPI olive:deactivationDate [olive:universalDate "02-13-2021"^^xsd:date]).
example triple: :DrRicesNPI olive:deactivationDate [olive:universalDate "02-13-2021"^^xsd:date]

decimal value
type: DatatypeProperty
type: FunctionalProperty
preferred label: has a decimal value of
comment: [:_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.
example triple: :ETHeight olive:decimalValue "300"^^xsd:double
domain: magnitude
range: double
former name: gist:decimalValue

denominator
type: ObjectProperty
sub property of: unit component
preferred label: has the denominator unit of
comment: Relates a RatioUnit such as meters/second to the denominator Unit (e.g. second).
domain: ratio unit
range: unit of measure
former name: gist:denominator

depends on
type: ObjectProperty
sub property of: connected to
inverse of: grounds
alternative label: is grounded by
alternative label: is true in virtue of

description
type: DatatypeProperty
preferred label: is described by
sub property of: note
domain: Thing
range: string
comment: (: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).
example triple: :MyPonySnowball olive:description "Snowball is a Shetland pony with dark brown many and hindquarters, but is otherwise white."^^xsd:string

long description
type: DatatypeProperty
preferred label: is described in depth by
sub property of: description
domain: Thing
range: string
comment: 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.

short description
type: DatatypeProperty
preferred label: is briefly described by
sub property of: description
domain: Thing
range: string
comment: 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.

destruction time
type: ObjectProperty
sub property of: time of
preferred label: was destroyed at/on
domain: Class
  complement of: event
range: time instant
comment: (:_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.
example subproperty: time of death
example triple: :MyCellphone olive:creationTime [a olive:TimeInstant; olive:universalDate "2025-09-17"^^xsd:date]

direct part of
type: ObjectProperty
sub property of: part of
preferred label: is directly a part of
comment: (: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.
former name: gist:directPartOf

discharge date
type: ObjectProperty
sub property of: end of event
preferred label: ended with a patient discharge date of
domain: admission
range: time instant
comment: (: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]).
example triple: :MyHospitalStay olive:dischargeDate [a olive:TimeInstant; olive:universalDateTime "2004-12-09"^^xsd:date])
property expresses sensitive information: SensitiveInfo PHI

distributes
type: ObjectProperty
sub property of: controls
alternative label: is the distributor of
domain: agent
range: Class
  union of: content
  union of: physical thing
comment: (: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.
example triple: :Pfizer olive:distributes :SampleOfXanax001

does
type: ObjectProperty
sub property of: causes
sub property of:
  inverse of: event involves
domain: Thing
range: event
comment: (: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.
example triple: :Casey olive:does :MakingMyCoffee

done by agent
type: ObjectProperty
preferred label: is done by
sub property of: involves agent
domain: event
range: agent
comment: (: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.
example triple: :BakingCookies olive:doneByAgent :DianeHart

done for agent
type: ObjectProperty
sub property of: involves agent
preferred label: is done for
domain: event
range: agent
comment: (: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.
example triple: :DiversitySeminar olive:doneForAgent :MichaelScott

done using
type: ObjectProperty
sub property of: event involves
preferred label: is done via the use of
alternative label: involves the use of
domain: event
range: Thing
comment: (: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.
example triple: :BreakingMyCarWindow0001 olive:doneUsing :Baseball0001

duration
type: ObjectProperty
preferred label: lasted
sub property of: has magnitude
domain: event
range: duration
comment: (: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!).
example triple: :COVIDPandemic olive:duration [olive:decimalValue "18"^^xsd:decimal ; olive:hasUoM :_Month]

editor of
type: ObjectProperty
sub property of: content contributor
preferred label: is the editor of
domain: agent
range: content
comment: (:Agent1 olive:editorOf :Content1) means that Agent1 edited Content1. For example, (:RobertGiroux olive:authorOf :CatcherInTheRye).
example triple: :RobertGiroux olive:authorOf :CatcherInTheRye

education institution
type: ObjectProperty
preferred label: was at
sub property of: done by agent
domain: education
range: school
comment: (: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.
example triple: :CaseysUndergradEducation olive:educationInstitution :PacificLutheranUniversity

effective from
type: ObjectProperty
preferred label: is effective from
alternative label: takes effect on
sub property of: time of
domain: content
range: time instant
comment: (: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.
example triple: :BobsEmploymentContractWithOlive olive:effectiveFrom [olive:universalDate "2021-01-01"^^xsd:date]

effective until
type: ObjectProperty
preferred label: is effective until
alternative label: remains in effect until
sub property of: time of
domain: content
range: time instant
comment: (: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.
example triple: :BobsEmploymentContractWithOlive olive:effectiveUntil [olive:universalDate "2021-01-01"^^xsd:date]

ehr provider
type: ObjectProperty
sub property of: has contract with
preferred label: stores EHR using
domain: organization
range: organization
comment: (: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.
example triple: :MeriterHospital olive:ehrProvider :EpicSystems

ein
type: DatatypeProperty
type: FunctionalProperty
type: InverseFunctionalProperty
sub property of: identifying text
preferred label: has the following EIN:
alternative label: has the following Employer Identification Number:
domain: agent
range: string
comment: (: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).
example triple: :Olive olive:ein "212121212"^^xsd:string

element 1
type: ObjectProperty
sub property of: has element
preferred label: has a first element of
alternative label: has a car of
comment: (:List1 olive:element_1 :Item1) means that Item1 is the first item in List1.
example triple: :List1 olive:element_1 :Item1

element 2
type: ObjectProperty
sub property of: has element
preferred label: has a second element of
comment: (:List1 olive:element_2 :Item1) means that Item1 is the second item in List1.
example triple: :List1 olive:element_2 :Item1

element 3
type: ObjectProperty
sub property of: has element
preferred label: has a third element of
comment: (:List1 olive:element_3 :Item1) means that Item1 is the third item in List1.
example triple: :List1 olive:element_3 :Item1

email address string
type: DatatypeProperty
sub property of: contact information
sub property: address
preferred label: can be contacted via
domain: Class
  union of: agent
  union of: email address
range: string
comment: (: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.
example triple: :OliveSales olive:emailAddress "sales@oliveai.com"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

employee count
type: DatatypeProperty
sub property of: associated count
preferred label: has the following number of employees:
domain: organization
range: integer
comment: (: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.
example triple: olive:Olive olive:employeeCount "457"^^xsd:string

employee
type: ObjectProperty
type: FunctionalProperty
preferred label: employed
sub property of: done for agent
sub property of: done by agent
domain: employment
range: agent
comment: (: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.
example triple: :BillsEmploymentAtCigna olive:employee :Bill

employer
type: ObjectProperty
preferred label: was with
sub property of: done for agent
sub property of: done by agent
domain: employment
range: agent
comment: (: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.
example triple: :BillsEmplomentAtCigna olive:employer :Cigna

employs
type: ObjectProperty
sub property of: has part
sub property of: affiliated with
sub property of: governs
domain: organization
range: person
comment: (:_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.
example triple: :MeriterHospital olive:employs :DrRice

end date
type: DatatypeProperty
preferred label: ends on/at
sub property of: date
domain: time interval
range: dateTime
comment: (: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.
example triple: :MiddleAges olive:endDate "1517-01-01"^^xsd:date

ending subevent
type: ObjectProperty
preferred label: ended with
sub property of: has subevent
domain: event
range: situation
comment: (: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.
example triple: :SuperBowlXXIII olive:endingSubevent :FinalWhistle2391

end of event
type: ObjectProperty
sub property of: time of event
preferred label: ends at/on
domain: event
range: time instant
comment: (:_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.
example triple: :_ThanksGivingDinner olive:startOfEvent [a olive:TimeInstant; olive:universalDateTime "2020-11-26T19:30:00"^^xsd:dateTime]

endpoint for
type: ObjectProperty
type: InverseFunctionalProperty
sub property of: affects
preferred label: is an endpoint for
domain: endpoint
range: software application
comment: (: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.
example triple: :JenaEndpoint-Dev olive:endpointFor :OliveKG

entity type code
type: DatatypeProperty
sub property of: has tag
preferred label: has the following entity type code:
domain: Thing
range: string
comment: 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).
example triple: :DrRice olive:entityTypeCode "1"^^xsd:string

evaluated thing
type: ObjectProperty
sub property of: primarily about
sub property of:
  inverse of: causes
preferred label: evaluates
domain: evaluation
range: Thing
comment: (:Evaluation1 olive:evaluatedThing :Thing1) means that Evaluation is an evaluation of Thing1. For example, (:BillysReportCard olive:evaluatedThing :Billy).
example triple: :BillysReportCard olive:evaluatedThing :Billy

evaluator
type: ObjectProperty
sub property of: author of
preferred label: performed
domain: agent
range: evaluation
comment: (: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.
example triple: :CaseysManager olive:evaluator :CaseysPerformanceReview

event care provider
type: ObjectProperty
sub property of: done by agent
preferred label: was done by
domain: medical care event
range: medical care provider
comment: 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.
example triple: :Visit01 olive:eventCareProvider :DrMartin

admitting event care provider
type: ObjectProperty
sub property of: event care provider
preferred label: was done by attending provider
comment: This is a subproperty of olive:eventCareProvider specific to range of admitting providers.

attending event care provider
type: ObjectProperty
sub property of: event care provider
preferred label: was done by attending provider
comment: This is a subproperty of olive:eventCareProvider specific to range of attending providers.

primary care event care provider
type: ObjectProperty
sub property of: event care provider
preferred label: was done by primary care provider
comment: This is a subproperty of olive:eventCareProvider specific to range of primary care providers.

event claim
type: ObjectProperty
preferred label: generates
sub property of: indirectly affected object
domain: medical care event
range: insurance claim
comment: (: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.
example triple: :Surgery201 olive:eventClaim :ClaimForSurgery201

event creates
type: ObjectProperty
sub property of: creates
sub property of: event outputs
preferred label: produces
alternative label: creates
domain: creation
range: Thing
comment: (: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.
example triple: :MyBakingParty olive:eventCreates :ThisPie

event involves
type: ObjectProperty
preferred label: involves
domain: situation
range: Thing
comment: (: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.
example subproperty: event patient
example subproperty: occurs at
example triple: :MyBirthdayParty olive:eventInvolves :MyIceCreamCake

event outputs
type: ObjectProperty
sub property of: directly affected object
pref labe: has as an output
domain: event
range: Thing
comment: (: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).
example triple: :Photosynthesis001 olive:eventOutputs :Glucose001

event patient
type: ObjectProperty
preferred label: has the patient
sub property of: done for agent
domain: medical care event
range: patient
comment: (: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.
example triple: :Visit01 olive:eventPatient :Casey

example
type: AnnotationProperty
preferred label: has the example:
domain: Resource
comment: 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.

example binding
type: AnnotationProperty
preferred label: might be bound to, for example,
sub property of: example
domain: variable
range: string
comment: (: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.
example triple: :Var1 olive:exampleBinding "<http://purl.bioontology.org/ontoloyg/STY/T121>"^^xsd:string

example instance
type: AnnotationProperty
sub property of: example
preferred label: has the example instance:
domain: Class
comment: 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.
example triple: :Person olive:exampleInstance :BarackObama

example subclass
type: AnnotationProperty
sub property of: example
preferred label: has as a subclass, for example,
domain: Class
range: Class
comment: 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.
example triple: :HeadOfState olive:exampleSubclass :USPresident

example subproperty
type: AnnotationProperty
sub property of: example
preferred label: has the example subproperty:
domain: Property
range: Property
comment: 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.
example triple: :physicalPartOf olive:exampleSubproperty :bodyPartOf

example triple
type: AnnotationProperty
sub property of: example
preferred label: can be used as follows, for example:
range: string
comment: 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.
example triple: :subRegion olive:exampleTriple ":NorthAmerica :subRegion :PacificNorthwest"^^xsd:string

example value
type: AnnotationProperty
sub property of: example
preferred label: could be, for example:
domain: variable
comment: (: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).
example triple: :JSONVar olive:exampleValue "{here: [is an example] }"^^olive:json

executes
type: ObjectProperty
sub property of: invokes
preferred label: runs
alternative label: partly consists in running
domain: event
range: content
comment: (: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.
example triple: :MyPlayingMinesweeper olive:executes :MinsweeperApplication

exemplar for class
type: AnnotationProperty
type: FunctionalProperty
sub property of: related to class
preferred label: is the exemplar
domain: exemplar individual
range: Class
comment: (: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.
example triple: (:Exemplar_Doctor olive:exemplarForClass olive:Doctor)

expressed in
type: ObjectProperty
sub property of: uses
preferred label: is expressed using
comment: The language something was expressed in
domain: content bearing thing
range: language
former name: gist:expressedIn

equivalent to
type: ObjectProperty
type: ReflexiveProperty
type: SymmetricProperty
type: TransitiveProperty
preferred label: is equivalent to
domain: Thing
range: Thing
comment: (: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).
example subproperty: same time as
example triple: :Superman olive:equivalentTo :ClarkKent

faceting of class
type: AnnotationProperty
sub property of: instances are subclasses Of
preferred label: represents a coherent way of subdividing
domain: higher order class
range: Class
comment: (: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.
example triple: ex:PersonTypeByOccupation olive:facetingOfClass olive:Person

fax number
type: DatatypeProperty
sub property of: contact information
preferred label: has the following fax number:
domain: Class
  union of: address
  union of: agent
range: string
comment: (: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.
example triple: :Bill olive:faxNumber "122345260982"xsd:string
property expresses sensitive information: SensitiveInfo PHI

field count
type: DatatypeProperty
type: FunctionalProperty
sub property of: associated count
preferred label: has the following number of fields:
domain: data table
range: integer
comment: (:_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.
example triple: :CaseysGradebook olive:fieldCount 10

field name
type: DatatypeProperty
sub property of: name
domain: data field
range: string
comment: (:_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.
example triple: :ExField olive:fieldName "cake_flavor"xsd:string

field type
type: AnnotationProperty
preferred label: has cells containing instances of
domain: data field
range: Class
comment: (:_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.
example triple: :FieldA olive:fieldType olive:Person

first author
type: ObjectProperty
sub property of: author of
preferred label: is the first author of
domain: agent
range: content
comment: This is a subproperty of olive:authorOf, indicating first authorship.

follows
type: ObjectProperty
sub property of: temporally related to
domain: Thing
range: Thing
inverse of: Precedes
example triple: :MyCelebration olive:follows :MarinersClinchingALWestIn2001

former name
type: AnnotationProperty
preferred label: was formerly called
range: string
comment: (: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.
example triple: gist:actual olive:formerName "gist:timeOf"^^xsd:string

found at character
type: DatatypeProperty
preferred label: is found at character
domain: Thing
range: nonNegativeInteger
comment: (: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).
example subproperty: found at starting character
example subproperty: found at character
example triple: :WikipediaCitation olive:foundAtCharacter "17"^^xsd:nonNegativeInteger

found at character
type: DatatypeProperty
sub property of: found at character
preferred label: is found at ending character
domain: Thing
range: nonNegativeInteger
comment: (: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).
example triple: :WikipediaCitation olive:foundAtEndingCharacter "21"^^xsd:nonNegativeInteger

found at starting character
type: DatatypeProperty
sub property of: found at character
preferred label: is found at character
domain: Thing
range: nonNegativeInteger
comment: (: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).
example triple: :WikipediaCitation olive:foundAtStartingCharacter "17"^^xsd:nonNegativeInteger

found on page
type: DatatypeProperty
preferred label: is found on page
domain: Thing
range: nonNegativeInteger
comment: (: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).
example subproperty: found at starting character
example subproperty: found at character
example triple: :Chapter3 olive:foundOnPage "17"^^xsd:nonNegativeInteger

found ending on page
type: DatatypeProperty
sub property of: found on page
preferred label: ends on page
domain: Thing
range: nonNegativeInteger
comment: (: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).
example subproperty: found at starting character
example subproperty: found at character
example triple: :Chapter3 olive:foundEndingOnPage "25"^^xsd:nonNegativeInteger

found starting on page
type: DatatypeProperty
sub property of: found on page
preferred label: starts on page
domain: Thing
range: nonNegativeInteger
comment: (: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).
example subproperty: found at starting character
example subproperty: found at character
example triple: :Chapter3 olive:foundStartingOnPage "17"^^xsd:nonNegativeInteger

from address
type: ObjectProperty
preferred label: is from
sub property of: from place
comment: The address source of some item or content.
range: address
former name: gist:fromAddress

from agent
type: ObjectProperty
preferred label: is from
sub property of: is from
comment: The agential source of something. This can
range: agent
former name: gist:fromAgent

from place
type: ObjectProperty
preferred label: is from
sub property of: is from
comment: origin
range: place
former name: gist:fromPlace

function arguments
type: Property
domain: function call
range: list
comment: 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.`
example triple: :MyFunctionCall olive:functionArguments ('arg1' 'arg2' ...)

function implies
type: AnnotationProperty
preferred label: holds between input and output akin to
domain: function
range: Property
comment: (: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].
example triple: :SSNLookupFn olive:functionImplies olive:ssn

gender expression
type: ObjectProperty
preferred label: expresses
sub property of: categorized by
domain: living thing
range: GenderExpression-category
comment: (: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.
example triple: :ClintEastwood olive:genderExpression olive:Masculine

gender or sex text
type: DatatypeProperty
sub property of: has tag
preferred label: is associated with the following text indicating gender or sex:
domain: living thing
range: string
comment: (: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.
example triple: :ClintEastwood olive:genderOrSexText "M"^^xsd:string

gender text
type: DatatypeProperty
sub property of: gender or sex text
preferred label: is associated with the following text indicating gender:
domain: living thing
range: string
comment: (: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.
example triple: :ClintEastwood olive:genderText "M"^^xsd:string

government for
type: ObjectProperty
type: FunctionalProperty
sub property of: governs
preferred label: governs
domain: government organization
range: place
comment: (: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.
example triple: :ArkansasGovt olive:governmentFor :Arkansas

governs
type: ObjectProperty
sub property of: controls
comment: The subject controls or inhibits the object in some way
domain: Class
  union of: intention
  union of: agent
  union of: template
range: Thing
former name: gist:governs

governs behavior
type: ObjectProperty
preferred label: normatively constrains
alternative label: governs
sub property of: regulates
domain:
  union of: commitment
  union of: intention
range: situation
comment: (: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).
example subproperty: requires
example subproperty: permits
example triple: :Rule17A olive:governsBehavior :MyPetitioningTheCourt

graph confidence
type: DatatypeProperty
sub property of: quantitative strength
preferred label: has a confidence of
domain: knowledge graph
range: decimal
comment: (: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.
example triple: :NamedGraph1 olive:graphConfidence ".6"^^xsd:decimal

graph class count
type: DatatypeProperty
preferred label: has a class count of
domain: knowledge graph
range: integer
comment: (: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.
example triple: :HCPCSGraph :graphClassCount "1800"^^xsd:integer

gross cost
type: ObjectProperty
sub property of: hasMonetaryValue
preferred label: has a gross cost of
comment: (: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.
example triple: :MyDentalProcedure olive:grossCost [a olive:Monetary; olive:decimalValue "2000"^^xsd:decimal ; olive:hasUoM olive:_USDollar]

grounds
type: ObjectProperty
sub property of: causes
domain: Thing
range: Thing
comment: (: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..
example triple: :TheFifthAmendment olive:grounds :SupremeCourtDecision12

has altitude
type: ObjectProperty
sub property of: has magnitude
preferred label: has an altitude of
comment: Distance above sea level
domain: place
range: distance
former name: gist:hasAltitude

has amount
type: ObjectProperty
preferred label: can be quantified/qualified by
domain: Thing
range: Class
  union of: magnitude
  union of: qualitative assessment
comment: (: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.
example subproperty: has magnitude
example subproperty: qualitative strength
example triple: :PileOfLeaves olive:hasAmount :LargeAmount

has balance
type: ObjectProperty
preferred label: has a remaining balance of
sub property of: hasMonetaryValue
domain: Thing
range: monetary
comment: (: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.
example triple: :MyTractor olive:hasBalance [olive:decimalValue "2600"^^xsd:decimal ; olive:hasUoM olive:_USDollar]

has base unit
type: ObjectProperty
sub property of: has standard unit
preferred label: can be converted to the base unit
comment: EXAMPLE: saying that a furlong hasBaseUnit meter says it is a DistanceUnit.
comment: 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.
domain: unit of measure
range: base unit
former name: gist:hasBaseUnit

has billing address
type: ObjectProperty
preferred label: handles financial communications at
sub property of: has communication address
domain: agent
range: address
comment: (: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.
example triple: :NewOrleansHospital :hasBillingAddress :Address32

has certification
type: ObjectProperty
sub property of: personal information
preferred label: has the following certification:
domain: Thing
range: certification
comment: (: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.
example triple: :Nick olive:hasCertification :DoctorOfPhilosophy

has communication address
type: ObjectProperty
sub property of: controls
sub property of: personal information
preferred label: can be reached at
comment: (: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.
range: address
example triple: :Agent1 olive:hasCommunicationAddress :Address1
former name: gist:hasCommunicationAddress

has condition
type: ObjectProperty
preferred label: has
sub property of: affected by
domain: living thing
range: health condition
comment: (:LivingThing1 olive:hasCondition :HealthCondition1) means that LivingThing1 has HealthCondition1. For example, (:Jeremy olive:hasCondition [a olive:Injury]) means that Jeremy is injured.
example triple: :Jeremy olive:hasCondition [a olive:Injury]

has contract with
type: ObjectProperty
type: SymmetricProperty
sub property of: connected to
preferred label: has a contract with
alternative label: uses
domain: agent
range: agent
comment: (:Agent1 olive:hasContractWith :Agent2) means that Agent1 and Agent2 are part of some contract.

has cpt Code
type: ObjectProperty
preferred label: is classified by
sub property of: categorized by
domain: event
range: CPT code
comment: (: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).
example triple: :AnniesProcedure olive:hasCPTCode :CPT73600

has diameter
type: ObjectProperty
sub property of: has magnitude
preferred label: has a diameter of
domain: Thing
range: distance
comment: (: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.
example triple: :TheGlassOnMyDesk olive:hasDiameter [a olive:Distance ; olive:hasUoM ex:_inch ; olive:decimalValue "2"^^xsd:double]

has element
type: ObjectProperty
sub property of: has member
preferred label: contains
domain: ordered collection
range: Thing
comment: 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.
example subproperty: element 1
example subproperty: element 2

has email address
type: ObjectProperty
sub property of: has communication address
preferred label: can be contacted via email at
domain: agent
range: email address
comment: (: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.
example triple: :Sean_Lane olive:hasEmailAddress :SeansGmail

has goal
type: ObjectProperty
sub property of:
  inverse of: governs
preferred label: has a goal to
comment: (: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.
former name: gist:hasGoal

has input variable
type: ObjectProperty
sub property of: has variable
preferred label: has the input variable
domain: function
range: input
comment: This is the subproperty fo olive:hasVariable for input variables, specifically.

has insurance policy
type: ObjectProperty
sub property of: owns
sub property of:
  inverse of: covers agent
preferred label: is the policyholder of
domain: person
range: insurance policy
comment: (:_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.
example triple: :Bill olive:hasInsurancePolicy :Pol1234

has length
type: ObjectProperty
sub property of: has magnitude
preferred label: has a length of
domain: Thing
range: distance
comment: (: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.
example triple: :MyIndexFinger olive:hasLength [a olive:Distance ; olive:hasUoM ex:_inch ; olive:decimalValue "3"^^xsd:double]

has magnitude
type: ObjectProperty
sub property of: has amount
preferred label: has the quantitative feature
comment: Relates a thing to some measurable quantity. See olive:Magnitude. This comment should be updated.
range: magnitude
former name: gist:hasMagnitude

has member
type: ObjectProperty
sub property of: has part
preferred label: includes
alternative label: contains
comment: Relates a list (see rdf:List) or collection (see olive:Collection) to its elements.
domain: collection
range: Thing
inverse of: member of
former name: gist:hasMember

hasMonetaryValue
type: ObjectProperty
sub property of: has magnitude
typed subproperty of: event has associated cost
domain: Thing
range: monetary
comment: (: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.
example triple: :CaseysMechanicalKeyboard olive:hasMonetaryValue [a olive:Monetary; olive:hasUoM olive:_USDollar; olive:decimalValue "75"^^xsd:decimal]

has npi
type: ObjectProperty
type: FunctionalProperty
type: InverseFunctionalProperty
sub property of: identified by
preferred label: has the following npi:
domain: medical care provider
range: National Provider Identifier
comment: This links a covered medical care provider or NPI with their National Provider Identifier Standard ID. For example, (:DrRice olive:hasNPI :DrRicesNPI).
example triple: :DrRice olive:hasNPI :DrRicesNPI

has output variable
type: ObjectProperty
sub property of: has variable
preferred label: has the output variable
domain: function
range: output
comment: This is the subproperty fo olive:hasVariable for output variables, specifically.

has part
type: ObjectProperty
type: TransitiveProperty
preferred label: includes
comment: The inverse of olive:partOf
inverse of: part of
former name: gist:hasPart

has party
type: ObjectProperty
sub property of: involves agent
preferred label: involves
alternative label: has as a focal party
alternative label: involves as a focal party
comment: (: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.
domain: relationship
range: agent

has phone number
type: ObjectProperty
sub property of: has communication address
preferred label: can be contacted at
domain: agent
range: telephone number
comment: (: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.
example triple: (:Bill olive:hasPhoneNumber [a olive:TelephoneNumber ; olive:uniqueText "122345260982"^^xsd:string])

has practice address
type: ObjectProperty
sub property of: operates in
sub property of: has communication address
preferred label: has a practice located at
domain: medical care provider
range: address
comment: (: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.
example triple: :JohnDoe olive:hasPracticeAddress :Address632

has precision
type: DatatypeProperty
preferred label: is precise to
comment: (: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.
domain: Class
  union of: magnitude
  union of: time instant
range: double
example triple: :MyHeight olive:hasPrecision "1e-1"^^xsd:double

has preferred term
type: AnnotationProperty
preferred label: is dispreferred compared to
domain: Resource
range: Resource
comment: (:Resource1 olive:hasPreferredTerm :Resource2) means that Resource1 is dispreferred compared to Resource2. For example, (foaf:phone olive:hasPreferredTerm olive:hasPhoneNumber).
example triple: foaf:phone olive:hasPreferredTerm olive:hasPhoneNumber

publication date
type: ObjectProperty
sub property of: creation time
preferred label: was published in/at
domain: content
range: time instant
comment: (: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.
example triple: :TheGreatGatsby olive:hasPublicationDate [a olive:TimeInstant; olive:universalDate "1925-04-10"^^xsd:date ;]

has revised version
type: ObjectProperty
preferred label: is revised as
sub property of: basis for
domain: content
range: content
comment: (:Content1 olive:hasRevisedVersion :Content2) means that Content1 is revised as Content2. For example, (:CaseysDissertationDraft1 olive:hasRevisedVersion :CaseysDissertationDraft2).
example triple: :CaseysDissertationDraft1 olive:hasRevisedVersion :CaseysDissertationDraft2

has RxNorm CUI
type: AnnotationProperty
type: FunctionalProperty
preferred label: is identified by RxNorm as
domain: Class
range: string
comment: (: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.
example triple: :Ibuprofen olive:hasRxNormCUI "310965"^^xsd:string

has SSN
type: ObjectProperty
sub property of: personal information
sub property of: identified by
preferred label: has a SSN of
alternative label: has social security number
domain: person
range: SSN
property expresses sensitive information: SensitiveInfo PHI
comment: (: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).
example triple: :BobSmith olive:hasSSN :BobsSSN

has standard unit
type: ObjectProperty
preferred label: has the standard unit
comment: For a complex unit refers to a unit that has all the component parts in SI
domain: unit of measure
range: coherent unit
former name: gist:hasStandardUnit

has status
type: ObjectProperty
sub property of: categorized by
preferred label: has the following status:
alternative label: is
domain: artifact
range: status
comment: (:Artifact1 olive:hasStatus :Status1) means that Artifact1 has Status1. For example, (:CPA1 olive:hasStatus :Status-InProgress) indicates that CPA1 is in progress.
example triple: :CPA1 olive:hasStatus :Status-InProgress

has subevent
type: ObjectProperty
sub property of: has part
sub property of: event involves
preferred label: includes
domain: situation
range: situation
comment: (:_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.
example triple: :MyBaseballGame olive:hasSubevent :TheSecondInningOfMyGame

has subnode
type: AnnotationProperty
preferred label: has as a subnode
comment: (: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.

has UMLS CUI
type: AnnotationProperty
type: FunctionalProperty
preferred label: is identified by UMLS as
domain: Class
range: string
comment: (: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.
example triple: :Headache olive:hasUMLSCUI "C0018681"^^xsd:string

has unit of measure
type: ObjectProperty
type: FunctionalProperty
preferred label: is measured in
alternative label: has units
comment: (:_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.
example triple: :ETHeight olive:hasUoM :_meter
domain: magnitude
range: unit of measure
former name: gist:hasUoM

has variable
type: ObjectProperty
sub property of: has part
preferred label: contains the variable
alternative label: contains the parameter
domain: function
range: variable
comment: (: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.
example subproperty: has input variable
example subproperty: has output variable
example triple: :OurFunction olive:hasVariable :x

identified by
type: InverseFunctionalProperty
type: ObjectProperty
sub property of: causes
comment: (:_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.
domain: Thing
range: ID
inverse of: identifies
example triple: (:_Person_Bob olive:identifiedBy [:uniqueText "123-45-6789"^^xsd:string; [owl:inverseOf olive:createsID] :_Organization_USGovernment])
former name: gist:identifiedBy

identifier for type
type: AnnotationProperty
preferred label: is the identifier for
sub property of: related to class
domain: ID
range: Class
comment: (: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.
example triple: :SKU-1010201 olive:identifierForType ToyotaRav4

identifies
type: FunctionalProperty
type: ObjectProperty
sub property of: about
former name: gist:identifies
comment: 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.

identifies as
type: ObjectProperty
preferred label: identfies as
sub property of: categorized by
domain: person
range: gender category
comment: (: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.
example triple: :Casey olive:identifiesAs olive:Female-Sex

identifier supports URI template
type: AnnotationProperty
preferred label: is associated with
domain: Class
range: URI template
comment: (: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).
example triple: :SSVID olive:identifierTypeSupportsURITemplate :SSVURITemplate

identifying text
type: DatatypeProperty
sub property of: text
preferred label: is identified by
domain: Thing
range: string
comment: (: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.
example subproperty: unique text
example subproperty: npi
example triple: :DrRice olive:identifyingText "1203456789"^^xsd:string

instances are subclasses Of
type: AnnotationProperty
preferred label: is a type of
domain: higher order class
range: Class
comment: (: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.
example triple: olive:PatientCohort olive:instancesAreSubclassesOf olive:Patient

intellectual property of
type: ObjectProperty
sub property of:
  inverse of: owns
preferred label: is the intellectual property of
preferred label: is the IP of
domain: intellectual property
range: agent
comment: (:IntellectualProperty1 olive:intellectualPropertyOf :Agent1) means that :IntellectualProperty1 is the intellectual property of :Agent1. For example, (:LetItBleed olive:intellectualPropertyOf :TheRollingStones).
example triple: :LetItBleed olive:intellectualPropertyOf :TheRollingStones

invoked with rest U R L
type: DatatypeProperty
preferred label: can be invoked with the Rest URL
domain: function
range: string
comment: (: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).
example triple: :CIPipeline1 olive:invokedwithRestURL "https://gitlab.example.com/api/v4/projects/9/trigger/pipeline?token=TOKEN&ref=main"^^xsd:string

invokes
type: ObjectProperty
sub property of: event involves
domain: event
range:
  union of: function
  union of: content
comment: (: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.
example triple: :LastNightsShow olive:invokes :MyFairLady-Content

invokes direct
type: ObjectProperty
type: FunctionalProperty
sub property of: invokes
preferred label: directly invokes
domain: invocation
comment: 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.

instance of
type: AnnotationProperty
preferred label: is an instance of
domain: Class
range: higher order class
comment: (: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.)

instantiates
type: ObjectProperty
sub property of: abstracts to
preferred label: is a manifestation of
alternative label: is a realization of
alternative label: materializes
alternative label: makes real
domain: content bearing thing
range: content
comment: (: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.
example triple: :MyCopyOfTheCatcherInTheRye olive:instantiates :TheCatcherInTheRye

insurer for claim
type: ObjectProperty
preferred label: is the payer for
sub property of: governs
domain: insurance company
range: insurance claim
comment: (: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.
example triple: :Cigna olive:insurerForClaim :Claim257

insurer for plan
type: ObjectProperty
sub property of: causes
sub property of: governs
preferred label: is the carrier of
domain:
  union of: insurance company
  union of: person
range: insurance plan
comment: (: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.
example triple: :Cigna olive:insurerForPlan :PlanZ

insurer for policy
type: ObjectProperty
sub property of: causes
sub property of: governs
preferred label: is the carrier of
domain: insurance company
range: insurance policy
comment: (:_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.
example triple: :Cigna olive:insurerForPolicy :Pol1234

involves agent
type: ObjectProperty
preferred label: involves
sub property of: event involves
domain: situation
range: agent
comment: (: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.
example triple: :2020Inauguration olive:involvesAgent :JoeBiden

is from
type: ObjectProperty
comment: 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.
example triple: :Casey olive:isFrom :PuyallupWashington

ISO 3166 code
type: DatatypeProperty
sub property of: identifying text
sub property of: maps to
preferred label: has the following ISO 3166 code:
alternative label: has the following Internantional Organization for Standardization (ISO) 3166 code:
domain: region
range: string
comment: (: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.
example triple: olive:UnitedStates olive:iso3166Code "US"^^xsd:string

ISO 3166-1 alpha-2 code
type: DatatypeProperty
sub property of: ISO 3166 code
preferred label: has the following ISO 3166-1 alpha-2 code:
alternative label: has the following Internantional Organization for Standardization (ISO) 3166-1 alpha-2 code:
domain: region
range: string
comment: (:Region1 olive:iso3166Code-countryAlpha2 "STRING"^^xsd:string) means that :Region1 has the two-letter International Organization for Standardization (ISO) 3166-1 code STRING.
example triple: olive:UnitedStates olive:iso3166Code-countryAlpha2 "US"^^xsd:string

ISO 3166-1 alpha-3 code
type: DatatypeProperty
sub property of: ISO 3166 code
preferred label: has the following ISO 3166-1 alpha-3 code:
alternative label: has the following Internantional Organization for Standardization (ISO) 3166-1 alpha-3 code:
domain: region
range: string
comment: (:Region1 olive:iso3166Code-countryAlpha3 "STRING"^^xsd:string) means that :Region1 has the three-letter International Organization for Standardization (ISO) 3166-1 code STRING.
example triple: olive:UnitedStates olive:iso3166Code-countryAlpha3 "USA"^^xsd:string

ISO 3166-1 numeric code
type: DatatypeProperty
sub property of: ISO 3166 code
preferred label: has the following ISO 3166-1 numeric code:
alternative label: has the following Internantional Organization for Standardization (ISO) 3166-1 numeric code:
domain: region
range: string
comment: (:Region1 olive:iso3166Code-countryNumeric "STRING"^^xsd:string) means that :Region1 has the numeric International Organization for Standardization (ISO) 3166-1 code STRING.
example triple: olive:UnitedStates olive:iso3166Code-countryNumeric "840"^^xsd:string

ISO 639 code
type: DatatypeProperty
sub property of: identifying text
sub property of: maps to
preferred label: has the following ISO 639 code:
alternative label: has the following Internantional Organization for Standardization (ISO) 639 code:
domain: natural language
range: string
comment: (: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.
example triple: olive:EnglishLanguage olive:iso639Code "eng"^^xsd:string

ISO 639-1 code
type: DatatypeProperty
sub property of: ISO 639 code
preferred label: has the following ISO 639-1 code:
alternative label: has the following Internantional Organization for Standardization (ISO) 639-1 code:
domain: natural language
range: string
comment: (: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.
example triple: olive:EnglishLanguage olive:iso639-1Code "en"^^xsd:string

ISO 639-2/B code
type: DatatypeProperty
sub property of: ISO 639 code
preferred label: has the following ISO 639-2B code:
alternative label: has the following Internantional Organization for Standardization (ISO) 639-2/B code:
domain: natural language
range: string
comment: (: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.
example triple: olive:EnglishLanguage olive:iso639-2BCode "eng"^^xsd:string

ISO 639-2T code
type: DatatypeProperty
sub property of: ISO 639 code
preferred label: has the following ISO 639-2T code:
alternative label: has the following Internantional Organization for Standardization (ISO) 639-2T code:
domain: natural language
range: string
comment: (: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.
example triple: olive:EnglishLanguage olive:iso639-2TCode "eng"^^xsd:string

ISO 639-3 code
type: DatatypeProperty
sub property of: ISO 639 code
preferred label: has the following ISO 639-3 code:
alternative label: has the following Internantional Organization for Standardization (ISO) 639-3 code:
domain: natural language
range: string
comment: (: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).
example triple: olive:EnglishLanguage olive:iso639Code "eng"^^xsd:string

issue number
type: DatatypeProperty
sub property of: series number
preferred label: is issue number
domain: content
range: nonNegativeInteger
comment: (: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.
example triple: :Erkenntnis_issn_7 olive:issueNumber "7"^xsd:nonNegativeInteger

issuing agent
type: ObjectProperty
sub property of: from agent
preferred label: is issued by
domain: Thing
range: agent
comment: (: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.
example triple: :TomsPhD olive:issuingAgent :TheOhioStateUniversity

is to
type: ObjectProperty
preferred label: has a destination of
comment: 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.

item cost
type: ObjectProperty
sub property of: event has associated cost
preferred label: involves an item that costs
domain: buying and selling
range: monetary
comment: (: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.
example triple: ex:BuyingAndSelling111 olive:itemCost [olive:decimalValue "500"^^xsd:double ; olive:hasUoM olive:_USDollar ]

last modified on
type: ObjectProperty
sub property of: modified on
preferred label: was last modified on
comment: (: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.
range: time instant
example triple: :CaseysWill olive:lastModifiedOn [a olive:TimeInstant ; olive:universalDateTime "2010-07-07"^^xsd:universalDate]

latitude
type: DatatypeProperty
comment: degrees above or below equator
domain: geographic point
range: double
former name: gist:latitude

licensing body
type: ObjectProperty
sub property of:
  inverse of: governs
sub property of: issuing agent
preferred label: is granted by
preferred label: is issued by
domain: certification
range: agent
comment: (: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.
example triple: :NicksDriversLicense olive:licensingAgent :Texas-StateGovernment

license number
type: DatatypeProperty
sub property of: identifying text
preferred label: has license number
domain: Class
  union of: license
  union of: agent
range: string
comment: (: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.
example triple: :NicksDriversLicense olive:licenseNumber "82828282"^xsd:string

local date
type: DatatypeProperty
preferred label: occurred at/on
sub property of: date
comment: LD
domain: time instant
former name: gist:localDate

local date time
type: DatatypeProperty
preferred label: occurred at/on
sub property of: date
comment: LDT
domain: time instant
range: dateTime
former name: gist:localDateTime

local time
type: DatatypeProperty
preferred label: occurred at/on
sub property of: date
comment: LT
domain: time instant
former name: gist:localTime

location text
type: DatatypeProperty
sub property of: text
preferred label: is associated with a location with the following label:
domain: Thing
range: string
comment: (: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.
example triple: :Nick olive:locationText "TX"^^xsd:string

longitude
type: DatatypeProperty
preferred label: longitdue
comment: degrees from GM
domain: geographic point
range: double
former name: gist:longitude

made of
type: ObjectProperty
sub property of: is from
preferred label: is made of
comment: as in the vase is made up of clay
range: physical substance
former name: gist:madeUpOf

manufactures
type: ObjectProperty
sub property of: creates
domain: agent
range: Thing
comment: (:Agent1 olive:manufactures :Thing2) means that Agent1 manufactures Thing2. For example, (:Motorola olive:manufactures :NicksPhone).
example triple: :Motorola olive:manufactures :NicksPhone

manufactures type
type: AnnotationProperty
preferred label: manufactures
sub property of: related to class
domain: agent
range: Class
comment: (:Agent1 olive:manufacturesType :Class1) means that Agent1 manufactures one or more instances of Class1. For example, (:Motorola olive:manufacturesType :SmartPhone).
example triple: :Motorola olive:manufacturesType :SmartPhone

mapping event fails to map
type: ObjectProperty
sub property of: event involves
preferred label: fails to identify the appropriate resource to use in place of
domain: mapping event
range: Thing
comment: (: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.

mapping event fails to map directly
type: ObjectProperty
sub property of: mapping event fails to map
preferred label: fails to identify the appropriate resource to use in place of
domain: mapping event
range: Thing
comment: (: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.

mapping status
type: AnnotationProperty
preferred label: has been
domain: Resource
range: mapping status
comment: (: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.
example triple: fhir:Medication olive:mappingStatus olive:Mapped

maps to
type: DatatypeProperty
domain: Thing
range: string
comment: (: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.
example triple: :NormalUse olive: "usual"^^xsd:string

mapsTo-assignedSexText
type: DatatypeProperty
preferred label: maps to
sub property of: maps to
domain: sex-category
range: string
comment: (:Sex-Category1 olive:mapsTo-assignedSexText "STRING"xsd:string) means that Sex-Category1 maps to STRING.

mapsTo-certificationText
type: DatatypeProperty
preferred label: maps to
sub property of: maps to
domain: Thing
range: string
comment: (:Thing1 olive:mapsTo-certificationText "STRING"xsd:string) means that Thing1 maps to STRING.

mapsTo-class
type: AnnotationProperty
preferred label: maps to
domain: Class
range: string
comment: (: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.
example triple: olive:Organization olive:mapsTo-class "organization"^^xsd:string

mapsTo-fhir
type: DatatypeProperty
preferred label: maps to (in fhir)
sub property of: maps to
domain: Thing
range: string
comment: (:Thing1 olive:mapsTo-fhir "STRING"xsd:string) means that Thing1 maps to (in fhir) STRING.

mapsTo-NUCCProviderTaxonomy
type: AnnotationProperty
preferred label: maps to (in the NUCC healthcare provider taxonomy)
sub property of: maps to
domain: Thing
range: string
comment: (:Thing1 olive:mapsTo-NUCCProviderTaxonomy "STRING"xsd:string) means that Thing1 maps to (in the NUCC healthcare provider taxonomy) STRING.

mapsTo-NUCCProviderTaxonomy-providerSpecialtyType
type: AnnotationProperty
preferred label: maps to (in the NUCC healthcare provider taxonomy)
sub property of: mapsTo-class
domain: Class
range: string
comment: (: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.

mapsTo-NUCCProviderTaxonomy-providerType
type: AnnotationProperty
preferred label: maps to (in the NUCC healthcare provider taxonomy)
sub property of: mapsTo-class
domain: Class
range: string
comment: (: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
type: AnnotationProperty
preferred label: has the following label in the NUCC provider taxonomy
sub property of: mapsTo-class
domain: Class
range: string
comment: (:Class1 olive:mapsTo-NUCCProviderTaxonomyGroupLabel :Label1) means that :Class1 maps to the label :Label1 in the Group field of the NUCC provider taxonomy.

mapsTo-property
type: AnnotationProperty
preferred label: maps to
domain: Property
range: string
comment: (: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.
example triple: olive:name-operating olive:mapsTo-property "3"^^xsd:string

mapsTo-provider type
type: DatatypeProperty
preferred label: maps to
sub property of: maps to
domain: Thing
range: string
comment: This mapping is motivated by mapping Ribbon Health data.

mapsTo-ServiceCode
type: DatatypeProperty
preferred label: maps to
sub property of: maps to
domain: Thing
range: string
comment: (:Thing1 olive:mapsTo-ServiceCode "STRING"xsd:string) means that Thing1 maps to STRING.

mapsTo-x12ClaimStatusCode
type: DatatypeProperty
preferred label: maps to (in x12)
sub property of: maps to
domain: Thing
range: string
comment: (:Thing1 olive:mapsTo-x12ClaimStatusCode "STRING"xsd:string) means that Thing1 maps to (in X12's 1029 Claim Status codes) STRING.

married to
type: ObjectProperty
preferred label: is married to
sub property of: partners
domain: person
range: person
comment: (: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.
example triple: :BarackObama olive:marriedTo :MichelleObama

matches exemplar
type: ObjectProperty
preferred label: matches
sub property of: connected to
domain: Thing
range: exemplar individual
comment: (: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).
example triple: (:Bob olive:matchesExemplar olive:ExemplarCredentialedIndividual_ANP)

maximum number of uses
type: DatatypeProperty
sub property of: associated count
preferred label: can be used the following number of times:
domain: Thing
range: integer
comment: (:Thing1 olive:maximumNumberOfUses "12"^^xsd:integer) means that Thing1 can be used a maximum of 12 times.
example triple: (SurgicalMask01 olive:maximumNumberOfUses "1"^^xsd:string

member count
type: DatatypeProperty
type: FunctionalProperty
preferred label: has the following number of members:
sub property of: associated count
domain: collection
range: integer
comment: (: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.

member of
type: ObjectProperty
sub property of: part of
preferred label: is a member of
comment: The inverse of olive:hasMember. See that comment for details.
domain: collection
range: Thing
former name: gist:memberOf

meta graph for
type: ObjectProperty
type: FunctionalProperty
type: InverseFunctionalProperty
preferred label: contains the meta information about
alternative label: is the meta graph for
sub property of: primarily about
domain: meta graph
range: knowledge graph
comment: (: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.
example triple: :UMLSMetaGraph olive:metaGraphFor :UMLSGraph

modified on
type: ObjectProperty
preferred label: was modified on
sub property of: time of
domain: Thing
range: time instant
comment: (: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.
example triple: :OliveOntology olive:modifiedOn ["2020-01-02"^^xsd:date]

multiplicand
type: ObjectProperty
sub property of: unit component
preferred label: has a product component unit of
comment: 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
domain: product unit
range: unit of measure
former name: gist:multiplicand

name
type: DatatypeProperty
preferred label: is named
comment: (: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.
range: string
example triple: :BabeRuth olive:name "Sultan of Swat"^^xsd:string
former name: gist:name

first name
type: DatatypeProperty
sub property of: name
preferred label: has an alternative name of
alternative label: has the name
domain: Thing
range: string
comment: (: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.
example triple: :BabeRuth olive:name-alt "George"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

associated name text
type: DatatypeProperty
sub property of: text
preferred label: has the following text associated with its name:
domain: Thing
range: string
comment: (: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.
example triple: :JeffBezos olive:name-associatedText "CEO"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

first name
type: DatatypeProperty
type: FunctionalProperty
sub property of: name
preferred label: has a first name of
alternative label: has the given name
domain: living thing
range: string
comment: (: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).
example triple: :BabeRuth olive:name-first "George"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

alternative first name
type: DatatypeProperty
sub property of: first name
preferred label: has a first name of
alternative label: has the given name
domain: living thing
range: string
comment: (: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).
example triple: :BabeRuth olive:name-firstAlt "George"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

first name initial
type: DatatypeProperty
sub property of: name
preferred label: has the first initial
domain: living thing
range: string
comment: (: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).
example triple: :BabeRuth olive:name-firstInitial "G"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

former last name
type: DatatypeProperty
sub property of: alternative last name
preferred label: has a former last name of
alternative label: has a former family name of
alternative label: has the former surname of
domain: living thing
range: string
comment: (: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).
example triple: :JadaPinkettSmith olive:name-formerLast "Pinkett"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

former legal name
type: DatatypeProperty
sub property of: first name
preferred label: has a former legal name of
domain: agent
range: string
comment: (: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).
example triple: :JadaPinkettSmith olive:name-formerLegal "Jada Pinkett"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

full name
type: DatatypeProperty
sub property of: name
preferred label: has a full name of
domain: living thing
range: string
comment: (: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).
example triple: :BabeRuth olive:name-full "George Herman Ruth"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

last name
type: DatatypeProperty
sub property of: name
preferred label: has a last name of
alternative label: has a family name of
alternative label: has the surname of
domain: living thing
range: string
comment: (: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).
example triple: :BabeRuth olive:name-last "Ruth"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

alternative last name
type: DatatypeProperty
sub property of: first name
preferred label: has an alternative last name of
alternative label: has an alternative family name of
alternative label: has the alternative surname of
domain: living thing
range: string
comment: (: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).
example triple: :JadaPinkettSmith olive:name-lastAlt "Pinkett"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

last name initial
type: DatatypeProperty
sub property of: name
preferred label: has the last initial
domain: living thing
range: string
comment: (: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).
example triple: :BabeRuth olive:name-lastInitial "R"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

legal name
type: DatatypeProperty
type: FunctionalProperty
sub property of: name
preferred label: is named
alternative label: has the legal name
domain: agent
range: string
comment: (: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.
example triple: :AmazonInc olive:name-legal "Amazon.com, Inc"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

namely href
type: DatatypeProperty
preferred label: is identified in Namely as
sub property of: identifying text
domain: professional
range: string
comment: (: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).

middle name
type: DatatypeProperty
sub property of: name
preferred label: has a middle name of
domain: living thing
range: string
comment: (: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).
example triple: :BabeRuth olive:name-middle "Herman"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

alternative middle name
type: DatatypeProperty
sub property of: first name
preferred label: has a middle name of
domain: living thing
range: string
comment: (: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).
example triple: :BabeRuth olive:name-middleAlt "Herman"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

middle name initial
type: DatatypeProperty
sub property of: name
preferred label: has the middle initial
domain: living thing
range: string
comment: (: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.
example triple: :BabeRuth olive:name-middleInitial "H"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

nickname
type: DatatypeProperty
sub property of: name
preferred label: has a nickname of
alternative label: is nicknamed
domain: Thing
range: string
comment: (: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.
example triple: :BabeRuth olive:name-nickname "Babe"^^xsd:string

operating name
type: DatatypeProperty
sub property of: name
preferred label: operates under the named
alternative label: is named
domain: agent
range: string
comment: (: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).
example triple: :AmazonInc olive:name-operating "Amazon"^^xsd:string

name prefix
type: DatatypeProperty
sub property of: name
preferred label: has a name prefix of
domain: living thing
range: string
comment: (: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).
example triple: :BabeRuth olive:name-prefix "Mr."^^xsd:string

alternative name prefix
type: DatatypeProperty
sub property of: first name
preferred label: has a name prefix of
domain: living thing
range: string
comment: (: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).
example triple: :BabeRuth olive:name-prefixAlt "Mr."^^xsd:string

professional last name
type: DatatypeProperty
sub property of: alternative last name
preferred label: has a professional last name of
domain: living thing
range: string
comment: (: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).
example triple: :DeclanMcManus olive:name-professionalLast "Costello"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

name suffix
type: DatatypeProperty
sub property of: name
preferred label: has a name suffix of
domain: living thing
range: string
comment: (:LivingThing1 olive:name-suffix "SUFFIX") means that LivingThing1 has a name suffix of "SUFFIX". For example, (:BabeRuth olive:name-suffix "Jr."^^xsd:string).
example triple: :BabeRuth olive:name-suffix "Jr."^^xsd:string

alternative name suffix
type: DatatypeProperty
sub property of: first name
preferred label: has a name suffix of
domain: living thing
range: string
comment: (:LivingThing1 olive:name-suffixAlt "SUFFIX") means that LivingThing1 has a name suffix of "SUFFIX". For example, (:BabeRuth olive:name-suffixAlt "Jr."^^xsd:string).
example triple: :BabeRuth olive:name-suffixAlt "Jr."^^xsd:string

near
type: ObjectProperty
preferred label: is near
sub property of: spatially related to
domain: physical thing
range: physical thing
comment: (: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.
example triple: :MyHouse olive:near :HellOrHighWaterBrewery

note
type: DatatypeProperty
preferred label: has the following note:
domain: Thing
range: string
comment: (: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.
example subproperty: structured note
example triple: :Elizabeth olive:note "wants pony for Christmas"^^xsd:string

note-legal
type: DatatypeProperty
preferred label: has the legal note:
sub property of: note
domain: Thing
range: string
comment: (: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).
example triple: :Graph12 olive:note-Legal "This graph should only be used for patient care purposes."^^xsd:string

structured note
type: DatatypeProperty
sub property of: note
preferred label: :
domain: Thing
range: string
comment: 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.
example triple: :Bill olive:note-Structured "Bill, 27"^^xsd:string

note-to do
type: DatatypeProperty
preferred label: :
sub property of: note
domain: Thing
range: string
comment: 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.
example triple: :My86Civic olive:note-ToDo "change the timing belt before it hits 112k miles"^^xsd:string

npi
type: DatatypeProperty
type: FunctionalProperty
type: InverseFunctionalProperty
sub property of: identifying text
preferred label: has the following npi:
domain: medical care provider
range: string
comment: This links a covered medical care provider with their National Provider Identifier Standard number. For example, (:DrRice olive:npi "1203456789"^^xsd:string).
example triple: :DrRice olive:npi "1203456789"^^xsd:string

nucc taxonomy code
type: DatatypeProperty
preferred label: has a NUCC taxonomy code of
domain: medical care provider
range: string
comment: (:MedicalCareProvider1 olive:nuccTaxonomyCode "STRING"xsd:string) means that MedicalCareProvider1 has a NUCC taxonomy code of STRING. For example, (:DrSmith olive:nuccTaxonomyCode "207Q00000X"^^xsd:string).
example triple: :DrSmith olive:nuccTaxonomyCode "207Q00000X"^^xsd:string

numerator
type: ObjectProperty
sub property of: unit component
preferred label: has the numerator unit of
comment: Relates a RatioUnit such as meter(s)/second to the numerator Unit (e.g. meter).
domain: ratio unit
range: unit of measure
former name: gist:numerator

occupies
type: ObjectProperty
sub property of: overlaps spatially
comment: A thing occupies are region
domain: physical thing
range: place
former name: gist:geoOccupies

occurs at
type: ObjectProperty
sub property of: event involves
preferred label: occurs at/in
comment: The geospatial place where something happened or will happen
former name: gist:occursAt

online profile
type: DatatypeProperty
preferred label: has a profile at
sub property of: seeAlso
domain: agent
range: string
comment: (: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).
example triple: :CaseyHart olive:onlineProfile "https://www.linkedin.com/in/casey-hart-7a032ba4/"^^xsd:string

operates in
type: ObjectProperty
sub property of: spatially related to
domain: agent
range: place
comment: (: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.
example triple: :Olive olive:operatesIn :ColumbusOH

org has member of type
type: AnnotationProperty
preferred label: has as a member at least one
domain: organization
range: Class
comment: (: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.
example triple: :NicksOrganization olive:orgHasMemberOfType olive:Doctor

org has members primarily of type
type: AnnotationProperty
sub property of: org has member of type
preferred label: primarily has members that are
domain: organization
range: Class
comment: (: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.
example triple: :NicksOrganization olive:orgHasMembersPrimarilyOfType olive:Doctor

contact person
type: ObjectProperty
sub property of: employs
sub property of: contact person
preferred label: can be contacted via
alternative label: is represented by
domain: organization
range: person
comment: (: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.
example triple: :UCDavis olive:organizationContact :JennySmith
former name: olive:contactPerson

organized by
type: ObjectProperty
sub property of: done by agent
preferred label: is organized by
domain: event
range: agent
comment: (: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.
example triple: :MySurpriseParty olive:organizedBy :MyMom

building for organization
type: ObjectProperty
sub property of: controls
preferred label: operates out of
domain: organization
range: place
comment: (:_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.
example triple: :CIA olive:orgSite :ThePentagon

owns
type: ObjectProperty
sub property of: controls
comment: (:Agent1 olive:owns :Thing1) means that Agent1 has (partial) legal ownership of Thing1.
domain: agent
range: Thing
former name: gist:owns

overlaps spatially
type: ObjectProperty
type: SymmetricProperty
preferred label: overlaps
sub property of: spatially related to
domain:
  union of: physical thing
  union of: place
range:
  union of: physical thing
  union of: place
comment: (: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.
example triple: :Arkansas olive:overlapsSpatially :UnitedStatesOfAmerica

paid amount
type: ObjectProperty
type: FunctionalProperty
sub property of: event has associated cost
preferred label: has had the following amount paid:
domain: paying for something
range: monetary
comment: (: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.
example triple: :PayingForMyCar olive:paidAmount [a olive:Monetary ; olive:decimalValue "8000"^^xsd:decimal ; olive:hasUoM olive:_USDollar]

paid by
type: ObjectProperty
preferred label: was paid by
sub property of: done by agent
sub property of: conveys from
domain: paying for something
range: agent
comment: (:PayingForSomething1 olive:paidBy :Agent1) means that PayingForSomething1 was paid by Agent1. For example, (:PayingForDinner olive:paidBy :Jerry) means that Jerry paid for dinner.
example triple: :PayingForDinner olive:paidBy :Jerry

paid to
type: ObjectProperty
preferred label: was paid to
sub property of: done for agent
sub property of: conveys to
domain: paying for something
range: agent
comment: (: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.
example triple: :PayingForDinner olive:paidTo :Tortianos

paid with
type: ObjectProperty
sub property of: done using
sub property of: thing transferred
preferred label: was paid via
domain: paying for something
range: artifact
comment: 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.
example triple: :Purchase23 olive:paidWith :Check25

parent of
type: ObjectProperty
sub property of: causes
preferred label: is a parent of
domain: living thing
range: living thing
comment: (: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.
former name: gist:parentOf

partners
type: ObjectProperty
type: SymmetricProperty
sub property of: affiliated with
preferred label: is a partner of
domain: agent
range: agent
comment: (: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.
example triple: :Batman olive:partners :Robin

part of
type: ObjectProperty
type: TransitiveProperty
preferred label: is part of
comment: The transitive version of directPartOf
former name: gist:partOf

patient census
type: DatatypeProperty
sub property of: associated count
preferred label: is providing service to
domain: medical care provider
range: integer
comment: (: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.
example triple: :GoodSamaritanER olive:patientCensus "23"^^xsd:integer

daily average patient census
type: DatatypeProperty
preferred label: provides service to an average of
domain: medical care provider
range: decimal
comment: (: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.
example triple: :GoodSamaritanER olive:patientCensus-DailyAverage "112"^^xsd:integer

patient discharged To
type: ObjectProperty
preferred label: concludes with the patient engaged in
sub property of: Precedes
domain: medical care event
range: situation
comment: (: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.
example triple: :RisingsACLSurgery olive:patientDischargedTo [a olive:HomeCareEvent]

patient for claim
type: ObjectProperty
preferred label: is the patient mentioned in
sub property of: causes
domain: patient
range: insurance claim
comment: (: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.
example triple: :JoeSmith olive:patientForClaim :Claim27

patient status code
type: DatatypeProperty
preferred label: is a patient classified as
domain: patient
range: integer
comment: (: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.
example triple: :Alice olive:patientStatusCode "02"^^xsd:integer

payment opportunity amount
type: DatatypeProperty
preferred label: has the opportunity amount
domain: monetary
range: decimal
comment: (: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).
example triple: [olive:Monetary; olive:decimalValue "25"^^xsd:decimal; olive:hasUoM olive:_USDollar] olive:paymentOpportunityAmount "12"^^xsd:decimal

pays for claim
type: ObjectProperty
preferred label: pays for
sub property of: paying for thing
domain: paying for something
range: insurance claim
comment: This is the subproperty of olive:payingForThing that restricts the thing paid for to an insurance claim.

paying for thing
type: ObjectProperty
preferred label: pays for
sub property of: event involves
domain: paying for something
range: Thing
comment: (:PayingForSomething1 olive:payingForThing :Thing1) means that PayingForSomething1 pays for Thing1. For example, (:PayingForMyCar olive:payingForThing :MyCar).
example triple: :PayingForMyCar olive:payingForThing :MyCar

personal information
type: ObjectProperty
preferred label: is partly identified in relation to
domain: agent
range: Thing
comment: (: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.
example subproperty: has communication address
example subproperty: alumnusOf
example triple: :Freddy olive:personalInformation :MadridSpain

phone number
type: DatatypeProperty
sub property of: contact information
preferred label: can be reached at
domain: Class
  union of: address
  union of: agent
range: string
comment: (: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.
example triple: :Bill olive:phoneNumber "122345260982"xsd:string
property expresses sensitive information: SensitiveInfo PHI

physical address has fax number
type: ObjectProperty
sub property of: physical address has virtual address
preferred label: can be reached by fax via
domain: physical address
range: telephone number
comment: (: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.
example triple: :PhysicalAdress1234 olive:physicalAddressHasFaxNumber :TelephoneNumber8675309

physical address has phone number
type: ObjectProperty
sub property of: physical address has virtual address
preferred label: can be reached by telephone via
domain: physical address
range: telephone number
comment: (: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.
example triple: :PhysicalAdress1234 olive:physicalAddressHasPhoneNumber :TelephoneNumber8675309

physical address has virtual address
type: ObjectProperty
sub property of: connected to
preferred label: can be reached via
domain: physical address
range: virtual address
comment: (: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.
example triple: :PhysicalAdress1234 olive:physicalAddressHasVirtualAddress :TelephoneNumber8675309

place contains
type: ObjectProperty
type: TransitiveProperty
sub property of: contains
sub property of: overlaps spatially
preferred label: contains
comment: A subproperty of olive:contains that is specific to places.
domain: place
range: place
former name: gist:geoContains

policy for claim
type: ObjectProperty
type: InverseFunctionalProperty
preferred label: governs
sub property of: causes
range: insurance claim
domain: insurance policy
comment: (:_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.
example triple: :BobsPolicy olive:policyForClaim :BobsClaim

policy under plan
type: ObjectProperty
preferred label: is under
sub property of: regulatedBy
domain: insurance policy
range: insurance plan
comment: (:InsurancePolicy1 olive:policyUnderPlan :InsurancePlan1) means that InsurancePolicy1 is under InsurancePlan1. For example, (:JoesPolicy22 olive:policyUnderPlan :CignaTexasGoldPlan).
example triple: :JoesPolicy22 olive:policyUnderPlan :CignaTexasGoldPlan

postal code
type: DatatypeProperty
sub property of: contact information
preferred label: has the postal code
range: string
comment: 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.
example triple: :Person1 olive:postalCode "98372"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

policy plan name
type: DatatypeProperty
preferred label: follows
domain: insurance policy
range: string
comment: (:InsurancePolicy1 olive:policyPlanName "STRING"xsd:string) means that InsurancePolicy1 follows STRING. For example, (:MyInsPolicy1234 olive:policyPlanName "Cigna PPO"^^xsd:string).
example triple: :MyInsPolicy1234 olive:policyPlanName "Cigna PPO"^^xsd:string

Precedes
type: ObjectProperty
type: TransitiveProperty
preferred label: precedes
sub property of: temporally related to
comment: 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.
former name: gist:precedes

precludes
type: ObjectProperty
sub property of: governs behavior
former name: prevents
preferred label: is inconsistent with
alternative label: disallows
alternative label: is logically inconsistent with
alternative label: logically precludes
alternative label: logically disallows
comment: (: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.
domain:
  union of: commitment
  union of: intention
example triple: :MyDesireToLoseWeight olive:precludes :MyEatingAPieceOfPie
range: situation
former name: gist:intentionPrecludes

prevents
type: ObjectProperty
sub property of: affects
domain: event
range: event
comment: (: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.
example triple: :BillBreakingHisLeg olive:prevents :BillFinishingTheRace

primarily about
type: ObjectProperty
type: FunctionalProperty
sub property of: about
preferred label: is primarily about
alternative label: primary subject
domain: content
range: Thing
comment: (: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.
example subproperty: evaluated thing
example triple: :TheDefinitiveDiana-Book olive:primarilyAbout :PrincessDiana

primary key
type: ObjectProperty
preferred label: is the primary key for
sub property of: part of
domain: data field
range: data table
comment: (:_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.
example triple: :_Field_1 olive:primaryKeyField :_Table_1

priority score
type: DatatypeProperty
preferred label: has a priority score of
domain: status
range: decimal
comment: (: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).
example triple: olive:Status-Build olive:priorityScore "120"^^xsd:decimal

producer of
type: ObjectProperty
sub property of: content contributor
preferred label: is the producer of
domain: agent
range: content
comment: (:Agent1 olive:producerOf :Content1) means that Agent1 produced Content1. For example, (:KennethUtt olive:producerOf :SilenceOfTheLambs).
example triple: :KennethUtt olive:producerOf :SilenceOfTheLambs

prohibits
type: ObjectProperty
sub property of: precludes
alternative label: is violated by
alternative label: proscribes
alternative label: disallows
alternative label: forbids
domain: commitment
range: situation
comment: (: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.
example triple: :TheFifthAmendmentToTheUSConstitution olive:precludes :MyBeingCompelledToTestifyAgainstMyselfInCourtOn12-21-2021

property count
type: DatatypeProperty
preferred label: contains the following number of properties:
domain: knowledge graph
range: integer
comment: (: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.
example triple: :Graph21 olive:propertyCount "12"^^xsd:integer

property expresses sensitive information
type: AnnotationProperty
preferred label: expresses the following sensitive information:
domain: Property
range: sensitive information type
comment: (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.
example triple: olive:hasSSN olive:propertyExpressesSensitiveInformation olive:SensitiveInfo-PHI

property sequence number
type: AnnotationProperty
preferred label: occurs in some sequence of properties in the following place number:
domain: Property
range: nonNegativeInteger
comment: (: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.
example triple: olive:npiNUCCProviderTaxonomyCode-3 olive:propertySequenceNumber "3"^^xsd:nonNegativeInteger

property relevant to field
type: AnnotationProperty
preferred label: has meaning that can be (partly) denoting using
domain: data field
range: Property
comment: (:_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.
example triple: :FieldG olive:propertyRelevantToField :finalLetterGrade

proposition object
type: AnnotationProperty
preferred label: has as its object
domain: proposition
range: Thing
comment: (: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.

proposition property
type: AnnotationProperty
preferred label: has as its property
domain: proposition
range: Property
comment: (: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.

proposition subject
type: AnnotationProperty
preferred label: has as its subject
domain: proposition
range: Thing
comment: (: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.

provider for claim
type: ObjectProperty
preferred label: is the provider for
sub property of: author of
domain: medical care provider
range: insurance claim
comment: (: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.
example triple: :MeriterHospital olive:providerForClaim :Claim257

publication year
type: DatatypeProperty
preferred label: was published in
domain: content
range: integer
comment: 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).
example triple: :TheGreatGatsby olive:publicationYear "1925"^^xsd:integer

publisher of
type: ObjectProperty
sub property of: content contributor
preferred label: is the publisher of
domain: agent
range: content
comment: (:Agent1 olive:publisherOf :Content1) means that Agent1 published Content1. For example, (:LittleBrownAndCompany olive:publisherOf :CatcherInTheRye).
example triple: :LittleBrownAndCompany olive:publisherOf :CatcherInTheRye

qag conversion
type: DatatypeProperty
preferred label: converts to a decimal value of
domain: generic qualitative amount
range: decimal
comment: (: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.
example triple: olive:Amount-Low olive:qagConversion ".25"^^xsd:decimal

qualitative strength
type: ObjectProperty
sub property of: has amount
preferred label: has the qualitative amount:
domain: Thing
range: qualitative assessment
comment: (: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.
example triple: :RealtorRecommendation olive:qualitativeStrength olive:ModeratelyHigh

quantitative strength
type: DatatypeProperty
preferred label: has a strength of
domain: Thing
range: decimal
comment: (: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.
example triple: :RealtorRecommendation olive:quantitativeStrength ".72"^^xsd:decimal

olive:queries database
type: ObjectProperty
preferred label: is intended to query
sub property of: connected to
domain: query
range: database
comment: (: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.
example triple: :UMLSQuery olive:olive:queriesDatabase :UMLSDB

queries graph
type: ObjectProperty
preferred label: is intended to query
sub property of: connected to
domain: query
range: knowledge graph
comment: (: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.
example triple: :UMLSQuery olive:queriesGraph :UMLSGraph

query privacy boolean
type: DatatypeProperty
preferred label: has a privacy boolean of
domain: query
range: boolean
comment: (: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.
example triple: :UMLSQuery olive:queryPrivacyBoolean "false"^^xsd:boolean

query sentence
type: DatatypeProperty
type: FunctionalProperty
preferred label: has the following query sentence:
sub property of: text
domain: query
range: string
comment: (: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).
example triple: :UMLSQuery olive:querySentence "SELECT DISTINCT ?lcase_out.... = "en")}"^^xsd:string

quoted categorized By
type: AnnotationProperty
preferred label: is a
domain: Resource
range: ontology term type
comment: (: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!
example triple: :BikeMessenger olive:quotedCategorizedBy olive:StubTerm

reasoning boolean
type: DatatypeProperty
preferred label: has a reasoning boolean of
domain: query
range: boolean
comment: (: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.
example triple: :UMLSQuery olive:reasoningBoolean "true"^^xsd:boolean

reasoning level
type: ObjectProperty
preferred label: uses a reasoning level of
sub property of: categorized by
domain: SPARQL query
range: reasoning level
comment: (: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.
example triple: :UMLSQuery olive:reasoningLevel olive:SL-ReasoningLevel

reactivation date
type: ObjectProperty
sub property of: time of
preferred label: has the following reactivation date:
domain: Thing
range: time instant
comment: This links an individual with the date on which it was reactivated. For example (:DrRicesNPI olive:reactivationDate [olive:universalDate "02-13-2021"^^xsd:date]).
example triple: :DrRicesNPI olive:reactivationDate [olive:universalDate "02-13-2021"^^xsd:date]

recognizes
type: ObjectProperty
sub property of: governs
preferred label: recognizes the legitimacy of
comment: (: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.
domain: agent
range: agent
example triple: :UN olive:recognizes :Uruguay
former name: gist:recognizes

recommended thing
type: ObjectProperty
sub property of: about
preferred label: includes a recommendation regarding
domain: recommendation
range: Thing
comment: (: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.
example triple: :DrRecommendatioon olive:recommendedThing :DrRice

recommended to
type: ObjectProperty
sub property of: to agent
preferred label: is given to
domain: recommendation
range: agent
comment: (: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.
example triple: :DrRecommendation olive:recommendedTo :JoePatient

recommender
type: ObjectProperty
sub property of: author of
preferred label: recommends
domain: agent
range: recommendation
comment: (: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.
example triple: :RogerEbert olive:recommender :EbertsReviewOfMovieX

recorded on
type: ObjectProperty
preferred label: was recorded at/on
sub property of: creation time
comment: This reflects the date and time (if known) that some content was recorded. Note that the recorded time may differ from the posted time.
domain: content
range: time instant
former name: gist:recordedOn

regulates
type: ObjectProperty
preferred label: influences
alternative label: applies to
alternative label: has regulatory influence over
domain: Thing
range: Thing
comment: (: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.
example subproperty: governs behavior
example subproperty: controls
example triple: :OliveEmployeeHandbook olive:regulates :JoeOliveEmployee

related to class
type: AnnotationProperty
preferred label: is related to
domain: Thing
range: Class
comment: (: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).

requested thing
type: ObjectProperty
sub property of: connected to
typed subproperty of: event involves
preferred label: is a request for
domain:
  union of: request
  union of: requesting something
range: Thing
comment: (: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.
example triple: :DrBobsRequestEvent olive:requestedThing :SampleOfVicodin

requested type
type: AnnotationProperty
sub property of: about class
preferred label: is a request for
domain:
  union of: request
  union of: requesting something
range: Class
comment: (: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.
example triple: :DrBobsRequestEvent olive:requestedType :Vicodin

requires
type: ObjectProperty
sub property of: allows
comment: (: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.
domain: commitment
range: situation
example triple: :ParentalCommand1 olive:requires :RoomCleaning01
former name: gist:requires

Ribbon name
type: DatatypeProperty
type: FunctionalProperty
type: InverseFunctionalProperty
sub property of: identifying text
preferred label: known to RibbonHealth as
domain: Thing
range: string
comment: This links some entity to the name which RibbonHealth uses consistently to name unique entities, such as Insurance Carriers.
example triple: :MyInsuranceCarrier olive:ribbonName "ACME Insurance of Oregon"^^xsd:string

ribbonUuid
type: DatatypeProperty
type: FunctionalProperty
type: InverseFunctionalProperty
sub property of: identifying text
preferred label: has a RibbonHealth UUID of
range: string
comment: 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.
example triple: :MyInsurancePlan olive:ribbonUuid "77f37edf-a2a8-4303-ba95-7f84ecb9e94b"^^xsd:string

DRG risk of mortality
type: ObjectProperty
preferred label: has the following risk of mortality:
sub property of: qualitative strength
domain: medical care event
range:
  one of: minimal amount
  one of: low amount
  one of: medium amount
  one of: high amount
  one of: maximal amount
comment: (: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.
example triple: :JimsHeartSurgery olive:riskOfMortality-DRG olive:Amount-High

routing number
type: DatatypeProperty
sub property of: text
preferred label: has the routing number
domain: check
range: string
comment: Relates a olive:Check to its routing number. Not the same as the account number (olive:accountNumber) or check number (olive:checkNumber).
example triple: :MyCheck olive:routingNumber "1125523434"^^xsd:string

row count
type: DatatypeProperty
type: FunctionalProperty
sub property of: associated count
preferred label: has the following number of rows:
domain: data table
range: integer
comment: (:_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.
example triple: :CaseysGradebook olive:rowCount 32

row referent
type: ObjectProperty
sub property of: about
preferred label: refers to
domain: data row
range: Thing
comment: (:_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.
example triple: :_GradebookRow12 olive:rowReferent :_JimSmith

same time as
type: ObjectProperty
sub property of: equivalent to
preferred label: is the same as
comment: We can have two local time instants refer to the same time, the same universal time.
domain: time instant
range: time instant
former name: gist:sameTimeAs

seller
type: ObjectProperty
sub property of: done by agent
preferred label: involves (as the seller)
domain: buying and selling
range: agent
comment: (: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.
example triple: :NickBuyingANewCar olive:seller :CedarParkToyota

sells type
type: AnnotationProperty
preferred label: sells
sub property of: related to class
domain: agent
range: Class
comment: (: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.
example triple: :Motorola olive:sellsType :SmartPhone

series number
type: DatatypeProperty
preferred label: is number
domain: Thing
range: nonNegativeInteger
assertibility: not assertible
comment: (: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.
example triple: :Erkenntnis_vol_7 olive:seriesNumber "7"^^xsd:nonNegativeInteger

service code
type: DatatypeProperty
sub property of: text
preferred label: has service code
domain: Class
  union of: line item
  union of: insurance claim
  union of: event
range: string
comment: (: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.
example triple: :Procedure01 olive:serviceCode "D0120"^^xsd:string

condition service code
type: DatatypeProperty
preferred label: has the condition code
sub property of: service code
comment: The subproperty of olive:serviceCode for condition codes.

DRG service code
type: DatatypeProperty
preferred label: has the DRG code
alternative label: Diagnosis-Related Group code
sub property of: service code
comment: The subproperty of olive:serviceCode for Diagnosis-Related Group (DRG) codes.

ICD10 admitting service code
type: DatatypeProperty
preferred label: has the ICD10 admitting code
sub property of: service code
comment: The subproperty of olive:serviceCode for ICD10 admitting codes.

ICD10 diagnosis service code
type: DatatypeProperty
preferred label: has the ICD10 diagnosis code
sub property of: service code
comment: The subproperty of olive:serviceCode for ICD10 diagnosis codes.

ICD10PrincipalDiagnosis service code
type: DatatypeProperty
preferred label: has the ICD10 principal diagnosis code
sub property of: service code
comment: The subproperty of olive:serviceCode for ICD10 principal diagnosis codes.

NUBC code
type: DatatypeProperty
preferred label: has the NUBC code
sub property of: service code
comment: The subproperty of olive:serviceCode for National Uniform Billing Committee (NUBC) codes.
mapsTo-ServiceCode: NU

occurrence service code
type: DatatypeProperty
preferred label: has the occurrence code
sub property of: service code
comment: The subproperty of olive:serviceCode for occurrence codes.

value service code
type: DatatypeProperty
preferred label: has the value code
sub property of: service code
comment: The subproperty of olive:serviceCode for value codes.

DRG severity of illness
type: ObjectProperty
preferred label: has the following severity:
sub property of: qualitative strength
domain: medical care event
range:
  one of: minimal amount
  one of: low amount
  one of: medium amount
  one of: high amount
  one of: maximal amount
comment: (: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.
example triple: :JimsHeartSurgery olive:severityOfIllness-DRG olive:Amount-High

event has associated cost
type: ObjectProperty
sub property of: event involves
preferred label: is associated in some way with a cost of
domain: situation
range: monetary
comment: (: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).
example triple: :Situation1 olive:situationHasAssociatedMonetaryValue [olive:decimalValue "500"^^xsd:double ; olive:hasUoM olive:_USDollar ]

sold
type: ObjectProperty
sub property of: thing transferred
preferred label: is an event in which the thing that is sold is
domain: buying and selling
range: Thing
comment: (: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.
example triple: :BobsBuyingANewCar olive:sold :Car00111

source location
type: DatatypeProperty
preferred label: can be found at
domain: content
range: string
comment: (:_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.
example triple: :SampleGradebook olive:sourceLocation "https://docs.google.com/spreadsheets/d/1WBOQW3Ig8CXzVpaArX3E5gdm47_ADhasUuwOn_DGVJQ/edit#gid=0"^^xsd:string

source text
type: DatatypeProperty
sub property of: text
preferred label: comes from a source associated with the following label:
domain: Thing
range: string
comment: (: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.
example triple: :NicksAmazonOrder olive:sourceText "Amazon"^^xsd:string

source version
type: DatatypeProperty
preferred label: has a source with version
sub property of: text
domain: artifact
range: string
comment: (: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.
example triple: :CPTGraph olive:sourceVersion "2011AA"^^xsd:string

spatially related to
type: ObjectProperty
type: SymmetricProperty
preferred label: stands in a physical relationship with
domain: physical thing
range: physical thing
comment: (: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.
example subproperty: place contains
example triple: :PhysicalThing1 olive:spatiallyRelatedTo :PhysicalThing2

speaks language
type: ObjectProperty
preferred label: speaks
sub property of: agent uses
domain: person
range: language
comment: (: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.
example triple: :DanielNaroditsky olive:speaksLanguage olive:RussianLanguage

specializes in
type: ObjectProperty
sub property of: personal information
domain: agent
range: Thing
comment: (: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.
example triple: :DrRice olive:specializesIn olive:Exemplar_Cancer

specializes in type
type: AnnotationProperty
sub property of: related to class
preferred label: specializes in
domain: agent
range: Class
comment: (: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.
example triple: :DrRice olive:specializesIn olive:Surgery

primarily specializes in type
type: AnnotationProperty
sub property of: specializes in type
preferred label: primarily specializes in
domain: agent
range: Class
comment: (: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.
example triple: :DrRice olive:specializesIn-primary olive:Surgery

status
type: DatatypeProperty
sub property of: text
preferred label: is
domain: artifact
range: string
comment: 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.

start date
type: DatatypeProperty
preferred label: starts on/at
sub property of: date
domain: time interval
range: dateTime
comment: (: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).
example triple: :MiddleAges olive:startDate "476-01-01"^^xsd:date

start of event
type: ObjectProperty
sub property of: time of event
preferred label: begins at/on
domain: event
range: time instant
comment: (:_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.
example triple: :_ThanksGivingDinner olive:startOfEvent [a olive:TimeInstant; olive:universalDateTime "2020-11-26T15:30:00"^^xsd:dateTime]

state of thing
type: ObjectProperty
sub property of: event involves
preferred label: is a state of
domain: situation state
range: Thing
comment: (: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.
example triple: (:NicksStateOfConfusion olive:stateOfThing :Nick)

subcategory of
type: ObjectProperty
type: TransitiveProperty
preferred label: is a subcategory of
comment: This is the analogue of rdfs:subClassOf for olive:Category.
comment: Note: This is essentially the same as skos:broaderTransitive, using olive:Category instead of skos:Concept.
comment: 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.
former name: gist:hasSuperCategory

suborganization
type: ObjectProperty
preferred label: has the suborganization of
sub property of: has part
domain: organization
range: organization
comment: (:Organization1 olive:suborganization :Organization2) means that Organization1 has the suborganization of Organization2. For example, (olive:Olive olive:suborganization olive:OliveWorks).
example triple: olive:Olive olive:suborganization olive:OliveWorks

supersedes
sub property of: affects
preferred label: supersedes earlier content
domain: content
range: content
comment: 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.
example triple: olive:KnowledgeGraph/MyContent/v1.1 olive:supersedes olive:KnowledgeGraph/MyContent/v1.0;

supports
type: ObjectProperty
sub property of: causes
alternative label: justifies
domain: content
range: content
comment: (: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.
example subproperty: cited content
example triple: :MLAlgorithm23 olive:supports :Recommendation1

has tag
type: DatatypeProperty
preferred label: is tagged as
domain: Thing
range: string
comment: (:_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.
example triple: :MyPatentApplication olive:tag "DENIED"^^xsd:string

takes instance of
type: AnnotationProperty
sub property of: related to class
preferred label: can be replaced with a(n)
domain: variable
range: Class
comment: (: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.
example triple: :x olive:takesInstanceOf :RealNumber

takes subclass of
type: AnnotationProperty
sub property of: related to class
preferred label: can be replaced with the class of
domain: variable
range: Class
comment: (: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).
example triple: :HospitalTypeVariable olive:takesSubClassOf olive:Hospital

temporally related to
type: ObjectProperty
type: SymmetricProperty
sub property of: topObjectProperty
preferred label: occurs in time relative to
domain: Thing
range: Thing
comment: (: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.
example subproperty: Precedes
example subproperty: follows

test query
type: ObjectProperty
preferred label: runs
sub property of: depends on
domain: Test-software
range: query
comment: (: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.
example triple: :UMLSTest olive:testQuery :UMLSQuery

text
type: DatatypeProperty
preferred label: has text:
domain: Thing
range: string
comment: (: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.
example subproperty: unique text
example subproperty: abstract
example triple: :XKCDHeistsAndEscapesComic olive:text "MY PLAN FOR THE GREATEST ESCAPE ROOM GAME OF ALL TIME"^^xsd:string

thing transferred
type: ObjectProperty
sub property of: conveyed thing
preferred label: involves transferring
domain: transfer event
range: Thing
comment: (:_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.
example triple: :JillAndBobsWeddingCeremony olive:thingTransferred :JillsWeddingRing

time of
type: ObjectProperty
preferred label: existed on
domain: Thing
range: time interval
comment: (: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.
example subproperty: time of event
example subproperty: has birthdate

time of death
type: ObjectProperty
sub property of: destruction time
preferred label: died at/on
comment: Datetime, at whatever granularity available, that a living thing died
domain: living thing
range: time instant
former name: gist:hasDeathDate
property expresses sensitive information: SensitiveInfo PHI

time of event
type: ObjectProperty
sub property of: event involves
sub property of: time of
preferred label: happened at/on
domain: situation
range: time instant
comment: (: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.
example subproperty: start of event
example subproperty: end of event
example triple: :MyEuchreGame olive:timeOfEvent [a olive:TimeInstant; olive:universalDate "2020-05-01"^^xsd:date]

tin
type: DatatypeProperty
type: FunctionalProperty
type: InverseFunctionalProperty
sub property of: identifying text
preferred label: has the following TIN:
alternative label: has the following taxpayer identification number:
domain: agent
range: string
comment: This links taxpayer with their Taxpayer Identification Number. For example, (:DrRice olive:tin "212121212"^^xsd:string).
example triple: :DrRice olive:tin "212121212"^^xsd:string

title for content
type: DatatypeProperty
type: FunctionalProperty
sub property of: name
preferred label: is called
alternative label: is entitled
alternative label: is titled
domain: content
range: string
comment: (: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).
example triple: :MyPaper olive:titleForContent "Dissolving Harman's Dogmatism Paradox"^^xsd:string

title text
type: DatatypeProperty
sub property of: associated name text
preferred label: has the title:
domain: agent
range: string
comment: (: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.
example triple: :JeffBezos olive:titleText "CEO"^^xsd:string

to agent
type: ObjectProperty
sub property of: is to
preferred label: is intended for
comment: (:_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.
range: agent

to place
type: ObjectProperty
sub property of: is to
preferred label: has a destination of
comment: Destination
range: place
former name: gist:toPlace

total cost
type: ObjectProperty
sub property of: event has associated cost
preferred label: involves a total cost of
domain: buying and selling
range: monetary
comment: (: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..
example triple: ex:BuyingAndSelling111 olive:totalCost [olive:decimalValue "500"^^xsd:double ; olive:hasUoM olive:_USDollar ]

is transcribed as:
type: DatatypeProperty
sub property of: text
domain: content
range: string
comment: (: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.

triple count
type: DatatypeProperty
preferred label: has the following number of triples:
domain: knowledge graph
range: integer
comment: (: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.
example triple: :Graph21 olive:tripleCount "2000"^^xsd:integer

typed subproperty of
type: AnnotationProperty
preferred label: is, when it relates specific types of things, a subproperty of
domain: Property
range: Property
comment: (: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).

primary type
type: AnnotationProperty
sub property of: related to class
preferred label: is primarily a
domain: Thing
range: Class
comment: (: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.
example triple: :Nick olive:type-primary olive:HumanBeing

unit component
type: ObjectProperty
sub property of: has part
preferred label: includes the subunit
domain: unit of measure
range: unit of measure
comment: (: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.
example subproperty: numerator
example subproperty: denominator
example triple: :_meterspersecond olive:unitComponent :_second

unique name
type: DatatypeProperty
type: FunctionalProperty
type: InverseFunctionalProperty
sub property of: name
preferred label: is uniquely called
domain: Thing
range: string
comment: (: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).
example triple: :CPA12 olive:uniqueName "Galaxy Med's CPA"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

unit cost
type: ObjectProperty
sub property of: event has associated cost
preferred label: involves a unit cost of
domain: buying and selling
range: monetary
comment: (: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).
example triple: ex:CostSpecification111 olive:unitCost [olive:decimalValue "500"^^xsd:double ; olive:hasUoM olive:_USDollar ]

Unit Symbol
type: DatatypeProperty
sub property of: unit symbol
preferred label: has the following standard symbol:
comment: The standard symbol for the unit NOT using any special characters. E.g. square meter would be m^2 rather than m?.
domain: unit of measure
range: string
former name: gist:unitSymbol

unit symbol
type: DatatypeProperty
preferred label: has the following unit symbol:
comment: (: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.
domain: unit of measure
range: string
assertibility: not assertible
example triple: _ampere olive:unitSymbol-general "A"^^xsd:string

Unit Symbol HTML
type: DatatypeProperty
sub property of: unit symbol
preferred label: has the following standard symbol (HTML):
comment: 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.
domain: unit of measure
range: string
former name: gist:unitSymbolHTML

Unit Symbol Unicode
type: DatatypeProperty
sub property of: unit symbol
preferred label: has the following standard symbol (unicode):
comment: 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.
domain: unit of measure
range: string
former name: gist:unitSymbolUnicode

unique text
type: DatatypeProperty
type: FunctionalProperty
sub property of: identifying text
preferred label: is uniquely associated with
comment: This is used for the actual value of a key or ID where you don't want the possibility of having more than one.
range: string
former name: gist:uniqueText

universal date
type: DatatypeProperty
preferred label: occurred at/on
sub property of: date
comment: UD
domain: time instant
range: date
former name: gist:universalDate

universal date time
type: DatatypeProperty
preferred label: is
sub property of: date
comment: UDT
domain: time instant
range: dateTime
former name: gist:universalDateTime

universal time
type: DatatypeProperty
preferred label: occurred at/on
sub property of: date
comment: UT
domain: time instant
former name: gist:universalTime

UNSPSC
type: AnnotationProperty
sub property of: mapsTo-Class
preferred label: has the following UNSPSC:
alternative label: has the following United Nations Standard Prodcuts and Services Code:
domain: Class
range: string
comment: (: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.
example triple: ex:Nicotine olive:unspsc "51212202"^^xsd:string

UPN code
type: AnnotationProperty
sub property of: mapsTo-Class
preferred label: has the following UPN code:
alternative label: has the following Universal Product Number:
domain: Class
range: string
comment: (:Class1 olive:upn "STRING"^^xsd:string) means that STRING is the Universal Product Number for Class1.
example triple: ex:ProductType2211 olive:upn "11111111"^^xsd:string

URI template
type: AnnotationProperty
preferred label: instances should have URIs that follow this template:
domain: Class
range: URI template
comment: (: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.
example triple: olive:CPA olive:uriTemplate [olive:uniqueText "http://data.oliveai.com/ontology/MedicalCareProvider/npi="]

uri template uses property
type: AnnotationProperty
preferred label: uses
sub property of: uses
domain: URI template
range: Property
comment: (: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.

url
type: DatatypeProperty
sub property of: general url
sub property of: source location
preferred label: can be accessed at
domain: virtual thing
range: string
comment: (: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.
example triple: :SecureDB olive:url "http://avd.secure.olive.com:8402"^^xsd:string

base url
type: DatatypeProperty
sub property of: general url
sub property of: source location
preferred label: has a base url of
alternative label: has fully qualified domain name
domain: virtual thing
range: string
comment: (: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.
example triple: :SecureDB olive:url "http://avd.secure.olive"^^xsd:string

general url
type: DatatypeProperty
preferred label: has a url of
domain: Thing
range: string
assertibility: not assertible
comment: (: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.
example triple: :SecureDB olive:url-general "http://avd.secure.olive.com:8402"^^xsd:string

uses
type: ObjectProperty
domain: Thing
range: Thing
comment: (: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.
example subproperty: agent uses
example subproperty: expressed in
example triple: :MyProgram olive:uses :PythonLanguage

uses portal
type: ObjectProperty
preferred label: uses the portal
sub property of: uses
domain: Thing
range: insurance portal
comment: (: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.
example triple: :MyClaim olive:usesPortal :CignaPortal

utilizes classification
type: AnnotationProperty
sub property of: related to class
preferred label: makes use of the following classification:
domain: Thing
range: Class
comment: (: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.

variable datatype
type: ObjectProperty
preferred label: takes values that are
domain: variable
range: Datatype
comment: (: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.
example triple: :MyNameVariable olive:variableDatatype xsd:string

variable equals
type: ObjectProperty
sub property of: uses
preferred label: invokes its function using this substitution:
domain:
  union of: invocation
  union of: test
range: list
comment: (: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".
example triple: :QuadraticFormulaSolvingEvent olive:variableEquals (:LeadingCoefficient "2"^^xsd:decimal)

version
sub property of: identified by
domain: Restriction
  on property: abstracts to
  some values from: versioned content
range: version
comment: Asserts that Content abstracting to some versioned content is assigned some VersionID
example triple: olive:Content/MyContent/v1.0 olive:version olive:Version/MyContent/idenfifyingText=1.0;

volume number
type: DatatypeProperty
sub property of: series number
preferred label: is volume number
domain: content
range: nonNegativeInteger
comment: (: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.
example triple: :Erkenntnis_vol_7 olive:volumeNumber "7"^xsd:nonNegativeInteger

ZIP code
type: DatatypeProperty
sub property of: postal code
preferred label: has the ZIP code
range: string
comment: 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.
example triple: :Person1 olive:zipCode "98372"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

ZIP code
type: DatatypeProperty
sub property of: ZIP code
preferred label: has the ZIP code
alternative label: has the plus-four code
alternative label: has ZIP+4
alternative label: has the ZIP and add-on of
range: string
comment: 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.
example triple: :Person1 olive:zipCodePlus4 "98372-9000"^^xsd:string
property expresses sensitive information: SensitiveInfo PHI

active
type: status
comment: 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
type: volatile graph
comment: 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
type: NamedIndividual
type: generic qualitative amount
alternative label: no amount
comment: A qualitative amount, this is the tag for things that have a minimal or no amount.
qag conversion: 0.0

low amount
type: NamedIndividual
type: generic qualitative amount
comment: A qualitative amount, this is the tag for things that have a low amount.
qag conversion: 0.25

medium amount
type: NamedIndividual
type: generic qualitative amount
alternative label: moderate amount
comment: A qualitative amount, this is the tag for things that have medium amount.
qag conversion: 0.50

high amount
type: NamedIndividual
type: generic qualitative amount
comment: A qualitative amount, this is the tag for things that have high amount.
qag conversion: 0.75

maximal amount
type: NamedIndividual
type: generic qualitative amount
comment: A qualitative amount, this is the tag for things that have a maximal amount.
qag conversion: 1.0

avoided
type: commitment category
comment: olive:Avoided is an instance of olive:CommitmentCategory. See comment on olive:Satisfied for further discussion.

email contact type
type: contact address type
preferred label: email address
comment: olive:ContactType-Email is an instance of olive:ContactAddressType.
mapsTo-fhir: email

fax contact type
type: contact address type
preferred label: fax number
comment: olive:ContactType-Fax is an instance of olive:ContactAddressType.
mapsTo-fhir: fax

pager contact type
type: contact address type
preferred label: pager number
comment: olive:ContactType-Pager is an instance of olive:ContactAddressType.
mapsTo-fhir: pager

phone contact type
type: contact address type
preferred label: phone number
comment: olive:ContactType-Phone is an instance of olive:ContactAddressType.
mapsTo-fhir: phone

text contact type
type: contact address type
preferred label: text message number
comment: olive:ContactType-Text is an instance of olive:ContactAddressType.
mapsTo-fhir: sms

web contact type
type: contact address type
preferred label: web address
comment: olive:ContactType-Web is an instance of olive:ContactAddressType.
mapsTo-fhir: url

anonymized data classification type
type: data classification type
preferred label: anonymized data
comment: 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
type: sensitive information type
preferred label: contracturally restricted data
comment: Data whose use is restricted by contract.

controlled data - data classification type
type: sensitive information type
preferred label: controlled data
comment: 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
type: data classification type
preferred label: de-identified data
alternative label: de-identified PHI
comment: 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 data classification type
type: sensitive information type
preferred label: metadata
comment: Metadata includes information about technical and business processes, data rules and constraints, and logical and physical data structures.

personal data - data classification type
type: sensitive information type
preferred label: personal data
alternative label: personal information
alternative label: personally identifying information
alternative label: PII
comment: 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
type: sensitive information type
preferred label: sensitive personal data
alternative label: sensitive personal information
comment: 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 classification type
type: data classification type
preferred label: public data
alternative label: freely accessible data
comment: This type of data is freely accessible to the public. It can be freely used, reused, and redistributed without repercussions.
categorized by: public data sensitivity level

sensitive business information
type: sensitive information type
alternative label: sensitive business data
comment: 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 data sensitivity level
type: data sensitivity level
preferred label: public information
alternative label: public
comment: 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
type: use type
comment: olive:Deprecated is an instance of olive:UseType.
mapsTo-fhir: old

downvote
type: vote
comment: A negative assessment, downvotes indicate that the thing upvoted should be, if anything, less visible to fewer people.

english language
type: natural language
preferred label: English
comment: olive:EnglishLanguage is an instance of olive:Language.
maps to: en
maps to: english

female gender
type: gender category
preferred label: female
alternative label: woman
alternative label: womxn
comment: olive:Female-Gender is an instance of olive:Gender-Category.

female sex
type: sex-category
preferred label: female
comment: olive:Female-Sex is an instance of olive:Sex-Category.
mapsTo-fhir: female
mapsTo-assignedSexText: F
mapsTo-assignedSexText: f
mapsTo-assignedSexText: Female
mapsTo-assignedSexText: Woman

feminine
type: GenderExpression-category
comment: olive:Feminine is an instance of olive:GenderExpressionCategory.

gender non conforming
type: gender category
preferred label: gendernonconforming
comment: olive:GenderNonConforming is an instance of olive:Gender-Category.

home use
type: use type
preferred label: home
comment: olive:HomeUse is an instance of olive:UseType. For example, a phone may be a home phone.
mapsTo-fhir: home

inactive
type: status
comment: olive:Inactive is an instance of olive:Status. Compare with olive:Active.

indirectly mapped
type: NamedIndividual
type: mapping status
preferred label: indirectly mapped into the Olive ontology
comment: See the comment on olive:mappingStatus.

in progress
type: commitment category
comment: olive:InProgress is an instance of olive:CommitmentCategory. See the comment on olive:Satisfied for more discussion.

male gender
type: gender category
preferred label: male
alternative label: man
alternative label: mxn
comment: olive:Male-Gender is an instance of olive:Gender-Category.

male sex
type: sex-category
preferred label: male
comment: olive:Male-Sex is an instance of olive:Sex-Category.
mapsTo-fhir: male
mapsTo-assignedSexText: M
mapsTo-assignedSexText: m
mapsTo-assignedSexText: Male
mapsTo-assignedSexText: Man

mapped
type: NamedIndividual
type: mapping status
preferred label: mapped into the Olive ontology
comment: See the comment on olive:mappingStatus.

masculine
type: GenderExpression-category
comment: olive:Masculine is an instance of olive:GenderExpressionCategory.

bronze metal level
type: metal level
comment: olive:MetalLevel-Bronze is an instance of olive:MetalLevel.
maps to: Bronze

catastrophic metal level
type: metal level
comment: olive:MetalLevel-Catastrophic is an instance of olive:MetalLevel.
maps to: Catastrophic

gold metal level
type: metal level
comment: olive:MetalLevel-Gold is an instance of olive:MetalLevel.
maps to: Gold

platinum metal level
type: metal level
comment: olive:MetalLevel-Platinum is an instance of olive:MetalLevel.
maps to: Platinum

silver metal level
type: metal level
comment: olive:MetalLevel-Silver is an instance of olive:MetalLevel.
maps to: Silver

mobile use
type: use type
preferred label: mobile
comment: 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.
mapsTo-fhir: mobile

normal use
type: use type
preferred label: normal
comment: olive:NormalUse is an instance of olive:UseType.
mapsTo-fhir: usual

NONE-stardog reasoning level
type: reasoning level
preferred label: NONE
comment: olive:NONE-StardogReasoningLevel is an instance of olive:ReasoningLevel.

not assertible
type: assertibility status
comment: 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 use
type: use type
preferred label: official
comment: olive:OfficialUse is an instance of olive:UseType.
mapsTo-fhir: official

Olive
type: NamedIndividual
type: organization
comment: 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.
suborganization: OliveAssures
suborganization: OliveEnables
suborganization: OliveHelps
suborganization: OliveKnows
suborganization: OliveWorks

olive ontology
type: Ontology
preferred label: Olive ontology
comment: olive:OliveOntology is an instance of owl:Ontology.

optional
type: NamedIndividual
type: deontic status
comment: The deontic status of being optional. Everything that is optional is also permitted.

other sex
type: sex-category
preferred label: other
comment: olive:Other-Sex is an instance of olive:Sex-Category.
mapsTo-fhir: other
mapsTo-assignedSexText: O
mapsTo-assignedSexText: o
mapsTo-assignedSexText: Other
mapsTo-assignedSexText: Intersex

partially mapped
type: NamedIndividual
type: mapping status
preferred label: partially mapped into the Olive ontology
comment: See the comment on olive:mappingStatus.

QL-stardog reasoning level
type: reasoning level
preferred label: QL
comment: olive:QL-StardogReasoningLevel is an instance of olive:ReasoningLevel.

required
type: NamedIndividual
type: deontic status
comment: The deontic status of being required, obligatory. Required things are things that are not forbidden.

RDFS-stardog reasoning level
type: reasoning level
preferred label: RDFS
comment: olive:RDFS-StardogReasoningLevel is an instance of olive:ReasoningLevel.

read only
type: file attribute
comment: 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
type: commitment category
comment: 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 use
type: use type
preferred label: secondary
comment: olive:SecondaryUse is an instance of olive:UseType.
mapsTo-fhir: secondary

SensitiveInfo Olive IP
type: sensitive information type
preferred label: Olive IP
comment: olive:SensitiveInfo-OliveIP is an instance of olive:SensitiveInformationType.
categorized by: DataSensitivityLevel-OliveHighlyConfidential
subcategory of: sensitive business information

SensitiveInfo PHI
type: sensitive information type
preferred label: PHI
comment: 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.
categorized by: DataSensitivityLevel-OliveHighlyConfidential

build
type: product status
priority score: 120

SL-stardog reasoning level
type: reasoning level
preferred label: SL
comment: olive:SL-StardogReasoningLevel is an instance of olive:ReasoningLevel.

SSV URI template
type: URI template
comment: olive:SSVURITemplate is an instance of olive:URITemplate.
unique text: olive:{TYPE}/{type_id}={VALUE};hospital_system_name={VALUE}
note: 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.

stub term
type: ontology term type
preferred label: stubterm
comment: olive:StubTerm is an instance of olive:OntologyTermType.

temporary use
type: use type
preferred label: temporary
comment: olive:TemporaryUse is an instance of olive:UseType.
mapsTo-fhir: temp

term requiring review
type: ontology term type
comment: olive:TermRequiringReview is an instance of olive:OntologyTermType. Every term in this category should be reviewed and the categorization removed.

unified medical language system
type: system
type: nonphysical artifact
preferred label: UMLS
comment: olive:UnifiedMedicalLanguageSystem is an instance of olive:System and olive:NonphysicalArtifact.

unmapped
type: NamedIndividual
type: mapping status
preferred label: not yet mapped into the Olive ontology
comment: See the comment on olive:mappingStatus.

upvote
type: vote
comment: A positive assessment, upvotes indicate that the thing upvoted should be, if anything, more visible to more people.

violated
type: commitment category
comment: olive:Violated is an instance of olive:CommitmentCategory. See the comment on olive:Satisfied for more discussion.

work use
type: use type
preferred label: work
comment: olive:WorkUse is an instance of olive:UseType. For example, a phone or computer may be for work use.
mapsTo-fhir: work

US Dollar
type: NamedIndividual
type: Thing
type: base unit
preferred label: US Dolalr
alternative label: USD
alternative label: $
base conversion factor: 1e+00
former name: gist:_USDollar

ampere
type: NamedIndividual
type: Thing
type: base unit
alternative label: amp
base conversion factor: 1e+00
former name: gist:_ampere

bit
type: NamedIndividual
type: Thing
type: base unit
comment: 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.
base conversion factor: 1e+00
former name: gist:_bit

candela
type: NamedIndividual
type: Thing
type: base unit
alternative label: candle
base conversion factor: 1e+00
former name: gist:_candela

day
type: NamedIndividual
type: duration unit
base conversion factor: 8.64e+04
has base unit: second
former name: gist:_day

each
type: NamedIndividual
type: Thing
type: base unit
comment: 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].
base conversion factor: 1e+00
former name: gist:_each

Kelvin
type: NamedIndividual
type: Thing
type: base unit
conversion offset: 0e+00
base conversion factor: 1e+00
former name: gist:_kelvin

kilogram
type: NamedIndividual
type: Thing
type: base unit
alternative label: kg
base conversion factor: 1e+00
former name: gist:_kilogram

kilogram per square meter
type: ratio unit
type: base unit
preferred label: kg/m^2
comment: The standard unit for BMI (see olive:bodyMassIndex).
base conversion factor: 1e+00
numerator: kilogram
denominator: square meter

meter
type: NamedIndividual
type: Thing
type: base unit
alternative label: m
base conversion factor: 1e+00
former name: gist:_meter

millisecond
type: NamedIndividual
type: duration unit
alternative label: ms
base conversion factor: 1e-03
has base unit: second
former name: gist:_millisecond

minute
type: NamedIndividual
type: duration unit
base conversion factor: 6e+01
has base unit: second
former name: gist:_minute

mole
type: NamedIndividual
type: Thing
type: base unit
base conversion factor: 1e+00
former name: gist:_mole

month
type: NamedIndividual
type: duration unit
base conversion factor: 3.80517e-7
has base unit: second

second
type: NamedIndividual
type: Thing
type: base unit
type: duration unit
base conversion factor: 1e+00
former name: gist:_second

square meter
type: NamedIndividual
type: Thing
type: base unit
type: area unit
preferred label: m^2
has base conversion factr: 1e+00
multiplicand: meter

week
type: NamedIndividual
type: duration unit
base conversion factor: 1.65344e-6
has base unit: second

year
type: NamedIndividual
type: duration unit
base conversion factor: 3.171e-8
has base unit: second

alternative label
type: AnnotationProperty
comment: The range of skos:altLabel is the class of RDF plain literals.
comment: skos:prefLabel, skos:altLabel and skos:hiddenLabel are pairwise disjoint properties.
definition: An alternative lexical label for a resource.
example: 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).
sub property of: label

change note
type: AnnotationProperty
definition: A note about a modification to a concept.
sub property of: note

definition
type: AnnotationProperty
definition: A statement or formal explanation of the meaning of a concept.
sub property of: note

editorial note
type: AnnotationProperty
definition: A note for an editor, translator or maintainer of the vocabulary.
sub property of: note

example
type: AnnotationProperty
definition: An example of the use of a concept.
sub property of: note

hidden label
type: AnnotationProperty
comment: The range of skos:hiddenLabel is the class of RDF plain literals.
comment: skos:prefLabel, skos:altLabel and skos:hiddenLabel are pairwise disjoint properties.
definition: 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.
sub property of: label

history note
type: AnnotationProperty
definition: A note about the past state/use/meaning of a concept.
sub property of: note

note
type: AnnotationProperty
definition: A general note, for any purpose.
scope note: This property may be used directly, or as a super-property for more specific note types.

preferred label
type: AnnotationProperty
comment: 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.
comment: The range of skos:prefLabel is the class of RDF plain literals.
comment: skos:prefLabel, skos:altLabel and skos:hiddenLabel are pairwise disjoint properties.
definition: The preferred lexical label for a resource, in a given language.
sub property of: label

scope note
type: AnnotationProperty
definition: A note that helps to clarify the meaning and/or the use of a concept.
sub property of: note

has broader match
type: ObjectProperty
sub property of: has broader
sub property of: is in mapping relation with
inverse of: has narrower match
definition: skos:broadMatch is used to state a hierarchical mapping link between two conceptual resources in different concept schemes.

has broader
type: ObjectProperty
sub property of: has broader transitive
inverse of: has narrower
comment: Broader concepts are typically rendered as parents in a concept hierarchy (tree).
definition: Relates a concept to a concept that is more general in meaning.
scope note: By convention, skos:broader is only used to assert an immediate (i.e. direct) hierarchical link between two conceptual resources.

has broader transitive
type: ObjectProperty
sub property of: is in semantic relation with
inverse of: has narrower transitive
type: TransitiveProperty
definition: skos:broaderTransitive is a transitive superproperty of skos:broader.
scope note: 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
type: ObjectProperty
sub property of: is in mapping relation with
type: SymmetricProperty
definition: 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.

has exact match
type: ObjectProperty
sub property of: has close match
type: SymmetricProperty
type: TransitiveProperty
comment: skos:exactMatch is disjoint with each of the properties skos:broadMatch and skos:relatedMatch.
definition: 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
type: ObjectProperty
inverse of: is top concept in scheme
domain: Concept Scheme
range: Concept
definition: 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
type: ObjectProperty
range: Concept Scheme
definition: Relates a resource (for example a concept) to a concept scheme in which it is included.
scope note: A concept may be a member of more than one concept scheme.

is in mapping relation with
type: ObjectProperty
sub property of: is in semantic relation with
comment: 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.
definition: Relates two concepts coming, by convention, from different schemes, and that have comparable meanings

has member
type: ObjectProperty
domain: Collection
range: Class
  union of: Collection
  union of: Concept
definition: Relates a collection to one of its members.

has member list
type: ObjectProperty
type: FunctionalProperty
domain: Ordered Collection
comment: 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.
definition: Relates an ordered collection to the RDF list containing its members.

has narrower match
type: ObjectProperty
sub property of: is in mapping relation with
sub property of: has narrower
definition: skos:narrowMatch is used to state a hierarchical mapping link between two conceptual resources in different concept schemes.

has narrower
type: ObjectProperty
sub property of: has narrower transitive
comment: Narrower concepts are typically rendered as children in a concept hierarchy (tree).
definition: Relates a concept to a concept that is more specific in meaning.
scope note: By convention, skos:broader is only used to assert an immediate (i.e. direct) hierarchical link between two conceptual resources.

has narrower transitive
type: ObjectProperty
sub property of: is in semantic relation with
type: TransitiveProperty
definition: skos:narrowerTransitive is a transitive superproperty of skos:narrower.
scope note: 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.

has related
type: ObjectProperty
sub property of: is in semantic relation with
type: SymmetricProperty
comment: skos:related is disjoint with skos:broaderTransitive
definition: Relates a concept to a concept with which there is an associative semantic relationship.

has related match
type: ObjectProperty
sub property of: is in mapping relation with
sub property of: has related
type: SymmetricProperty
definition: skos:relatedMatch is used to state an associative mapping link between two conceptual resources in different concept schemes.

is in semantic relation with
type: ObjectProperty
domain: Concept
range: Concept
definition: Links a concept to a concept related by meaning.
scope note: 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
type: ObjectProperty
sub property of: is in scheme
domain: Concept
range: Concept Scheme
definition: Relates a concept to the concept scheme that it is a top level concept of.

notation
type: DatatypeProperty
definition: 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.
scope note: By convention, skos:notation is used with a typed literal in the object position of the triple.

Collection
type: Class
disjoint with: Concept
disjoint with: Concept Scheme
definition: A meaningful collection of concepts.
scope note: Labelled collections can be used where you would like a set of concepts to be displayed under a 'node label' in the hierarchy.

Concept
type: Class
disjoint with: Concept Scheme
definition: An idea or notion; a unit of thought.

Concept Scheme
type: Class
definition: A set of concepts, optionally including statements about semantic relationships between those concepts.
example: 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.
scope note: A concept scheme may be defined to include concepts from different sources.

Ordered Collection
type: Class
subclass of: Collection
definition: An ordered collection of concepts, where both the grouping and the ordering are meaningful.
scope note: 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'.