Core.rdf

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE rdf:RDF [
	<!ENTITY bfo "http://purl.obolibrary.org/obo/">
	<!ENTITY dcterms "http://purl.org/dc/terms/">
	<!ENTITY iof-av "https://purl.industrialontologies.org/ontology/core/meta/AnnotationVocabulary/">
	<!ENTITY iof-core "https://purl.industrialontologies.org/ontology/core/Core/">
	<!ENTITY owl "http://www.w3.org/2002/07/owl#">
	<!ENTITY rdf "http://www.w3.org/1999/02/22-rdf-syntax-ns#">
	<!ENTITY rdfs "http://www.w3.org/2000/01/rdf-schema#">
	<!ENTITY skos "http://www.w3.org/2004/02/skos/core#">
	<!ENTITY xsd "http://www.w3.org/2001/XMLSchema#">
]>
<rdf:RDF xml:base="https://purl.industrialontologies.org/ontology/core/Core/"
	xmlns:bfo="http://purl.obolibrary.org/obo/"
	xmlns:dcterms="http://purl.org/dc/terms/"
	xmlns:iof-av="https://purl.industrialontologies.org/ontology/core/meta/AnnotationVocabulary/"
	xmlns:iof-core="https://purl.industrialontologies.org/ontology/core/Core/"
	xmlns:owl="http://www.w3.org/2002/07/owl#"
	xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
	xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
	xmlns:skos="http://www.w3.org/2004/02/skos/core#"
	xmlns:xsd="http://www.w3.org/2001/XMLSchema#">
	
	<owl:Ontology rdf:about="https://purl.industrialontologies.org/ontology/core/Core/">
		<rdfs:label xml:lang="en">Core Ontology</rdfs:label>
		<dcterms:abstract>The IOF Core Ontology contains terms and concepts found to be common across multiple domains of industry and represents an OWL implementation of them. The ontology itself utilizes the Basic Formal Ontology or BFO as a philosophical foundation but also imports terms from various domain-independent or &quot;mid-level&quot; ontologies. The purpose of the ontology is to serve or is intended to serve as a core for IOF&apos;s domain-specific ontologies, with a goal being to ensure consistency and interoperability across the suite of ontologies the IOF publishes.</dcterms:abstract>
		<dcterms:contributor xml:lang="en">Elisa Kendall, Thematix Partners LLC</dcterms:contributor>
		<dcterms:contributor xml:lang="en">Will Sobel, W. V. Sobel LLC</dcterms:contributor>
		<dcterms:creator xml:lang="en">Chris Will, National Center for Ontological Research (NCOR)</dcterms:creator>
		<dcterms:creator xml:lang="en">IOF Core Working Group</dcterms:creator>
		<dcterms:license rdf:datatype="&xsd;anyURI">http://opensource.org/licenses/MIT</dcterms:license>
		<dcterms:publisher xml:lang="en">Industrial Ontology Foundry</dcterms:publisher>
		<dcterms:references rdf:resource="http://purl.org/dc/terms/"/>
		<dcterms:references rdf:resource="http://www.w3.org/2004/02/skos/core#"/>
		<dcterms:title>Industrial Ontology Foundry (IOF) Core Ontology</dcterms:title>
		<owl:imports rdf:resource="http://purl.obolibrary.org/obo/bfo/2020/bfo.owl"/>
		<owl:imports rdf:resource="https://purl.industrialontologies.org/ontology/core/meta/AnnotationVocabulary/"/>
		<owl:versionIRI rdf:resource="https://purl.industrialontologies.org/ontology/core/20220506/Core/"/>
		<owl:versionInfo>Version 1 Beta - 2022-05-06</owl:versionInfo>
		<iof-av:copyright>Copyright (c) 2022 Open Applications Group</iof-av:copyright>
	</owl:Ontology>
	
	<rdf:Description rdf:about="&bfo;BFO_0000029">
		<rdfs:comment>Even though site (physical location) always refers to a 3D space it is fine to define it practically just through 2D or 1D or 0D spatial region. For example when we want to talk about 2x2m area within a factory floor even though the space specified is 2D it is still ok to assert it as site as there is always the third dimension above the area that is implicit.</rdfs:comment>
		<skos:example>location of a container, floor area in a factory building, location of a machine (relative to the coordinate of a factory floor), location on a shelf in a warehouse</skos:example>
		<iof-av:synonym>physical location</iof-av:synonym>
	</rdf:Description>
	
	<rdf:Description rdf:about="&bfo;BFO_0000054">
		<iof-av:synonym>realized in</iof-av:synonym>
	</rdf:Description>
	
	<rdf:Description rdf:about="&bfo;BFO_0000057">
		<owl:propertyChainAxiom rdf:parseType="Collection">
			<rdf:Description rdf:about="&bfo;BFO_0000117">
			</rdf:Description>
			<rdf:Description rdf:about="&bfo;BFO_0000057">
			</rdf:Description>
		</owl:propertyChainAxiom>
	</rdf:Description>
	
	<rdf:Description rdf:about="&bfo;BFO_0000063">
		<iof-av:naturalLanguageDefinition>comes before (something) in time</iof-av:naturalLanguageDefinition>
	</rdf:Description>
	
	<owl:Class rdf:about="&iof-core;ActionSpecification">
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:label>action specification</rdfs:label>
		<rdfs:comment>1.Some of the items that may be contained within the action specification include:
- specifying the role (which may reflect the actions that a participant should do) that can inhere in a participant of the process
- specifying the types of participants in a process

2. Typically is part of a plan specification</rdfs:comment>
		<skos:example xml:lang="en">Pour the contents of flask 1 into flask 2</skos:example>
		<iof-av:adaptedFrom>http://www.obofoundry.org/ontology/iao.html</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>InformationContentEntity(x) ∧ ∃p (Process(p) ∧ (prescribes(x,p)) → ActionSpecification(x)</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>information content entity that prescribes what participants shall do in a process</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>x is an Information Content Entity that prescribes some Process p implies x is an Action Specification</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>An action specification provide details about what an agent (person, group of persons or engineered system) should do to successfully realize a particular kind of process.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;Agent">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000040"/>
		<rdfs:label>agent</rdfs:label>
		<rdfs:comment>The IOF has elected to exclude material substances that may, at times, act like or are often referred to as agents, in that they realize some specific function that some person desires (e.g., platinum is a reducing agent in various reduction-type reactions -- as used in a catalytic converter to eliminate or reduce various pollutants in exhausts).

The IOF has at this time excluded other types of non-human agents, such as animals and other organisms (often referred to as biological agents).</rdfs:comment>
		<rdfs:comment>When an organization is an agent, this is because one or more of the persons who are members of the organization (usually referred to an agency), realize its goals, objectives and plans.</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<owl:Class>
						<owl:unionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;EngineeredSystem">
							</rdf:Description>
							<rdf:Description rdf:about="&iof-core;GroupOfAgents">
							</rdf:Description>
							<rdf:Description rdf:about="&iof-core;Person">
							</rdf:Description>
						</owl:unionOf>
					</owl:Class>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;hasRole"/>
						<owl:someValuesFrom rdf:resource="&iof-core;AgentRole"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example>an employee; a transportation &amp; logistics provider; a robot; a scheduling system</skos:example>
		<iof-av:counterExample>1. Of physical and chemical in nature: Cleaning, vulcanizing, fluxing, indicator, sterilizing, emulisifying, refining.

2. Organisms: animals, cells, parts of organisms (organs, organelles, viruses).</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>Agent(x) ↔ (Person(x) ∨ GroupOfAgents(x) ∨ EngineeredSystem(x)) ∧ ∃y (AgentRole(y) ∧ hasRole(x,y))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>person, group of persons, or engineered system with an agent role</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Agent is a Person, Group Of Agents, or Engineered System when it &apos;has role&apos; some Agent Role.</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>From the dictionary:
1. A person who acts on behalf of another person or group.

2. A person or thing that takes an active role or produces a specified effect.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;AgentRole">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000023"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;roleOf"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<owl:Class>
								<owl:intersectionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&bfo;BFO_0000040">
									</rdf:Description>
									<owl:Class>
										<owl:complementOf rdf:resource="&bfo;BFO_0000024"/>
									</owl:Class>
								</owl:intersectionOf>
							</owl:Class>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&iof-core;actsOnBehalfOfAtSomeTime"/>
								<owl:someValuesFrom>
									<owl:Class>
										<owl:unionOf rdf:parseType="Collection">
											<rdf:Description rdf:about="&iof-core;EngineeredSystem">
											</rdf:Description>
											<rdf:Description rdf:about="&iof-core;GroupOfAgents">
											</rdf:Description>
											<rdf:Description rdf:about="&iof-core;Person">
											</rdf:Description>
										</owl:unionOf>
									</owl:Class>
								</owl:someValuesFrom>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label>agent role</rdfs:label>
		<rdfs:comment>The IOF has elected to exclude material substances that may, at times, act like or are often referred to as agents, in that they realize some specific function that some person desires (e.g., platinum is a reducing agent in various reduction-type reactions -- as used in a catalytic converter to eliminate or reduce various pollutants in exhausts).

The IOF has at this time excluded other types of non-human agents, such as animals and other organisms (often referred to as biological agents).</rdfs:comment>
		<skos:example>an employee; a transportation &amp; logistics provider; material handler; scheduler</skos:example>
		<iof-av:counterExample>Other types of agents we are not including at this stage are: 
1. Those that are physical and chemical in nature: Cleaning, vulcanizing, fluxing, indicator, sterilizing, emulisifying, refining.

2. Organisms: animals, cells, parts of organisms (organs, organelles, viruses).

3. In computing: intelligent, artificial, mobile, &amp; autonomous</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>AgentRole(x) → Role(x) ∧ ∃m ∃n ((MaterialEntity(m) ∧ ¬FiatObjectPart(x)) ∧ (Person(n) ∨ GroupOfAgents(n) ∨ EngineeredSystem(n)) ∧ actsOnBehalfOfAtSomeTime(m, n) ∧ roleOf(x,m))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>role that someone or something has when they act on behalf of a person, engineered system or a group of agents</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Agent Role x implies x is a &apos;role&apos; that is the &apos;role of&apos; a &apos;material entity&apos; (that is not a Fiat Object Part) m when it &apos;acts on behalf of at some time&apos; some Person or Group of Agents or Engineered System y</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;Algorithm">
		<rdfs:subClassOf rdf:resource="&iof-core;PlanSpecification"/>
		<rdfs:label>algorithm</rdfs:label>
		<rdfs:comment>Algorithms considered under BFO are strictly mathematical or computer science algorithms. As such, any possible inputs or outputs of an algorithm must be of type IOF:Information Content Entity</rdfs:comment>
		<skos:example>source, pseudo, or executable code for sorting data, flowchart for automatic control of a process</skos:example>
		<iof-av:adaptedFrom>Information Artifact Ontology: http://purl.obolibrary.org/obo/IAO_0000064 and also the Common Core Ontology, http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>PlanSpecification(x) ∧ ∃y(ComputingProces(y) ∧ prescribes(x,y)) → Algorithm(x)</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>plan specification that prescribes a computing process</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>x is a Plan Specification that &apos;prescribes&apos; some Computing Process y implies x is an Algorithm</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>1. Plan specification that has an action specification as part that prescribes procedural or declarative (declarative in the sense of declarative programming) steps, which can be 1) translated to computer interpretable instructions and 2) concretized in a computing process

2.an informational entity that specifies the inputs and outputs of some mathematical function as well as workflow of execution for achieving a predefined objective [CCO; IAO]</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;Assembly">
		<rdfs:subClassOf rdf:resource="&iof-core;MaterialArtifact"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;hasComponentPartAtAllTimes"/>
				<owl:someValuesFrom rdf:resource="&iof-core;MaterialComponent"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">assembly</rdfs:label>
		<rdfs:comment>An assembly can be a manufactured product or a component of a higher-level assembly, or both.</rdfs:comment>
		<rdfs:comment>a component can also be a portion of material so if something has a component part it is not necessairly an assembly</rdfs:comment>
		<skos:example>powertrain assembly; partially-assembled powertrain + transmission assembly lying nearby; driveshaft assembly temporarily disassembled for repair or routine maintenance; separator assembly consisting of variously-shaped separator parts that safeguard wine bottles in a case of wine during transport; a material artifact produced entirely through additive manufacturing (provided it is a component somewhere, and can it can be disassembled without damage/destruction).</skos:example>
		<iof-av:counterExample>a portion of material, signle piece of glass, a bar, an aluminum roll, an engine block</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>Assembly(x) → MaterialArtifact(x) ∧ ∃c (MaterialComponent(c) ∧ hasComponentPartAtAllTimes(x,c))</iof-av:firstOrderLogicDefinition>
		<iof-av:firstOrderLogicDefinition>MaterialArtifact(x) ∧ ∃p( AssemblyProcess(p)  ∧ isSpecifiedOutputOf(x,p)) → Assembly(x)</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>material artifact that is composed of a number of material components that are physically connected together to realize a function and that can be disassembled later on</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Assembly  x implies x is a Material Artifact and there is some Material Component c and x &apos;has component part at all times&apos; c</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Material Artifact x that &apos;is specified output of&apos; some Assembly Process p implies x is an Assembly</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>1. Material artifact composed of parts that are put together to realize a particular function as prescribed by some design, and in a manner whereby it can be later disassembled.

2. A group of subassemblies and/or parts that are put together and that constitute a major subdivision for the final product. An assembly may be an end item or a component of a higher level assembly [APICS].

3. A combination of parts, components [or] units that form a functional entity [ISO 10795].

4. A set of one or more sub-assemblies or components constituting a single end-use product [ISO/TS 21619].

5. A component or end item comprising of a number of parts or subassemblies put together to perform a specific function, and capable of disassembly without destruction [businessdictionary.com].</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;AssemblyProcess">
		<rdfs:subClassOf rdf:resource="&iof-core;ManufacturingProcess"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;hasInput"/>
				<owl:someValuesFrom rdf:resource="&iof-core;MaterialComponent"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;hasSpecifiedOutput"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;Assembly">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&iof-core;hasComponentPartAtAllTimes"/>
								<owl:someValuesFrom>
									<owl:Class>
										<owl:intersectionOf rdf:parseType="Collection">
											<rdf:Description rdf:about="&iof-core;MaterialComponent">
											</rdf:Description>
											<owl:Restriction>
												<owl:onProperty rdf:resource="&iof-core;isInputOf"/>
												<owl:someValuesFrom rdf:resource="&iof-core;ManufacturingProcess"/>
											</owl:Restriction>
										</owl:intersectionOf>
									</owl:Class>
								</owl:someValuesFrom>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">assembly process</rdfs:label>
		<rdfs:comment>because the process like 3D printing can also produce an assembly, has specified output some assembly is not necesssary and sufficient condition for an assembly process</rdfs:comment>
		<skos:example>Driving a lug nut to hold the wheel of a car in place; welding two metal parts into a single object; automated drilling and riveting of a skin panel operation during fuselage assembly;</skos:example>
		<iof-av:counterExample>3D printing on an existing part (existing part + a pool of printing material -&gt; new part) -- Note that the pool of material is an object before the process but becomes liquid (there is physical state change) during the &quot;assembly&quot; process.</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>AssemblyProcess(x) →  ManufacturingProcess(x) ∧ ∃a, ∃c (Assembly(a) ∧ MaterialComponent(c)  ∧ isInputOf(c,x) ∧ hasComponentPartAtAllTimes(a,c) ∧  hasSpecifiedOutput(x,a))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>manufacturing process in which a number of material components are physically connected to each other to form an assembly</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Assembly Process x implies x is a Manufacturing Process that &apos;has specified output&apos; some Assembly a which &apos;has component part at all times&apos; some Material Component c that &apos;is input of&apos; x</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;BusinessIdentification">
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:label>business identification</rdfs:label>
		<rdfs:comment>Business identifications are typically managed by an official organization</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&iof-core;InformationContentEntity">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;designates"/>
						<owl:someValuesFrom rdf:resource="&iof-core;BusinessOrganization"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example>DUNS Number, CAGE Code, EIN, FIIN,  BICID, DODAACID, SCACID</skos:example>
		<iof-av:firstOrderLogicDefinition>BusinessIdentification(x) ↔ InformationContentEntity(x) ∧ ∃b(BusinessOrganization(b) ∧ designates(x,b))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>information content entity that identifies a business</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Business Identification is an Information Content Entity that &apos;designates&apos; some Business Organization</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">Identifier for a business entity typically provided by a government or a well know business entity such as Dun and Bradstreet. It has significance in conducting trades between business entities.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;BusinessOrganization">
		<rdfs:subClassOf rdf:resource="&iof-core;OrganizedGroupOfAgents"/>
		<rdfs:label>business organization</rdfs:label>
		<rdfs:comment>1. As defined here, business entity includes both for-profit and non-profit organizations as well as groups of nation states or parts thereof assembling under some identity. 

2. Business entities are formally organized according to the laws prevailing in the locales and countries in which it operates or conducts business, and includes company, corporation,  partnership, or sole proprietorship.</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&iof-core;OrganizedGroupOfAgents">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&bfo;BFO_0000056"/>
						<owl:someValuesFrom rdf:resource="&iof-core;BusinessProcess"/>
					</owl:Restriction>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;designatedBy"/>
						<owl:someValuesFrom rdf:resource="&iof-core;BusinessIdentification"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example>Mercedes-Benz, Deloitte; OPC Foundation;  OPEC (whose mission is to coordinate and unify the petroleum policies of its member countries and ensure the stabilization of oil markets in order to...)</skos:example>
		<iof-av:firstOrderLogicDefinition>BusinessOrganization(x) ↔ OrganizedGroupOfAgents(x) ∧ ∃p,∃b(BusinessProcess(p) ∧ BusinessIdentification(b) ∧  participatesInAtSomeTime(x,p) ∧ designatedBy(x,b))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>organized group of agents that have a business identification assigned with the purpose to get involved in business processes</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Business Organization is an Organized Group Of Agents that &apos;participates in at some time&apos; some Business Process and is &apos;designated by&apos; some Business Identification</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">1. Any undertaking, venture, initiative, or business organization with a defined mission [APICS].
2. Organization that sells products or services, or plans to do so.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;BusinessProcess">
		<rdfs:subClassOf rdf:resource="&iof-core;PlannedProcess"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:unionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;BusinessOrganization">
							</rdf:Description>
							<owl:Class>
								<owl:intersectionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&iof-core;Agent">
									</rdf:Description>
									<owl:Restriction>
										<owl:onProperty rdf:resource="&iof-core;actsOnBehalfOfAtSomeTime"/>
										<owl:someValuesFrom rdf:resource="&iof-core;BusinessOrganization"/>
									</owl:Restriction>
								</owl:intersectionOf>
							</owl:Class>
						</owl:unionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;prescribedBy"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;PlanSpecification">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&bfo;BFO_0000110"/>
								<owl:someValuesFrom>
									<owl:Class>
										<owl:intersectionOf rdf:parseType="Collection">
											<rdf:Description rdf:about="&iof-core;ObjectiveSpecification">
											</rdf:Description>
											<owl:Restriction>
												<owl:onProperty rdf:resource="&bfo;BFO_0000084"/>
												<owl:someValuesFrom rdf:resource="&iof-core;BusinessOrganization"/>
											</owl:Restriction>
										</owl:intersectionOf>
									</owl:Class>
								</owl:someValuesFrom>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">business process</rdfs:label>
		<rdfs:comment>This definition leaves open the possibility that the business entity that carries the plan that prescribes the process, has no direct participation in the process, which would imply that some 3rd-party agent is playing a causal role as the process unfolds, and is acting on behalf of the Business Entity&apos;s interests.</rdfs:comment>
		<skos:example>product production process; manufacturing enterprise process; finance operation; logistics operation.</skos:example>
		<iof-av:firstOrderLogicDefinition>BusinessProcess (p) → PlannedProcess(p) ∧ ∃o,∃b,∃s (ObjectiveSpecification(o) ∧ BusinessOrganization(b) ∧ PlanSpecification(s) ∧ isCarrierOfAtSomeTime(b,o) ∧ continuantPartofAtAllTimes(o,s) ∧ (participatesInAtSomeTime(b,x) ∨∃y (Agent(y) ∧ actsOnBehalfOfAtSomeTime(y,b) ∧ participatesInAtSomeTime(y,x)))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>planned process which is prescribed by a plan specification with one or more objectives specified by a business organization</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Business Process x implies x is a Planned Process that is &apos;prescribed by&apos; some Plan Specification p that &apos;has continuant part at all times&apos; some Objective Specification o which &apos;generically depends on at some time&apos; some Business Organization b and x &apos;has participant at some time&apos; b or an Agent a that &apos;acts on behalf of at some time&apos; b</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">1. Partially ordered, often nested, set of enterprise activities that can be executed to achieve some desired result in pursuit of a specified objective of an enterprise or a part of an enterprise [ISO 15704]

2. Partially ordered set of enterprise activities that can be executed to achieve some desired end-result in pursuit of a given objective of an organization [ISO/IEC/IEEE 24765].

3. A set of logically related tasks or activities performed to achieve a defined business outcome [APICS].

4. A business process is a collection of related, structured activities or tasks that produce a specific service or product for a particular customer or customers [OMG].</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;BuyerRole">
		<rdfs:subClassOf rdf:resource="&iof-core;AgentRole"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;roleOf"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<owl:Class>
								<owl:unionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&iof-core;BusinessOrganization">
									</rdf:Description>
									<rdf:Description rdf:about="&iof-core;EngineeredSystem">
									</rdf:Description>
									<rdf:Description rdf:about="&iof-core;Person">
									</rdf:Description>
								</owl:unionOf>
							</owl:Class>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&bfo;BFO_0000056"/>
								<owl:someValuesFrom rdf:resource="&iof-core;BuyingBusinessProcess"/>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">buyer role</rdfs:label>
		<iof-av:firstOrderLogicDefinition>BuyerRole(x) → Role(x) ∧ ∃y,∃p ((BusinessOrganization(y) ∨ Person(y) ∨ EngineeredSystem(y)) ∧ BuyingBusinessProcess(p) ∧ participatesInAtSomeTime(y,p) ∧ roleOf(x, y))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>role held by a person, business organization or an automated system when it buys a product or a service</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Buyer Role x implies x is an Agent Role that is the &apos;role of&apos; an Agent (person, organization or automated system acting on behalf of one) a when it &apos;participates in at some time&apos; some Buying Business Process b</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>Individual or business organization or automated system that is responsible for buying a product or a service according to a service-agreement [OAGIS]</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;BuyingBusinessProcess">
		<rdfs:subClassOf rdf:resource="&iof-core;BusinessProcess"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&bfo;BFO_0000040">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&iof-core;hasRole"/>
								<owl:someValuesFrom rdf:resource="&iof-core;BuyerRole"/>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:unionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;CommercialServiceAgreement">
							</rdf:Description>
							<rdf:Description rdf:about="&iof-core;MaterialProduct">
							</rdf:Description>
						</owl:unionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label>buying business process</rdfs:label>
		<rdfs:comment>1.The agent who uses the finiancial instrument may not own the financial instrument and hence agent may not be the paying agent.
2. It should be noted that we consciously exclude the person-to-person transactions, but person-to-business is not excluded.</rdfs:comment>
		<skos:example>GM buys tires from Good Year to be assembled into its cars; GE Conglomerate (buyer) buys steels for uses in productions by its GE aviation subsidiary (customer) and GE Transportation subsidiary (customer)</skos:example>
		<iof-av:adaptedFrom>CCO:http://www.ontologyrepository.com/CommonCoreOntologies/ActOfBuying
elucidation: OAGIS and CCO</iof-av:adaptedFrom>
		<iof-av:elucidation>business process wherein financial instrument is used by an agent (buyer) to acquire ownership of product or commercial service from another agent (seller) for the buyer itself or another agent (customer)</iof-av:elucidation>
		<iof-av:firstOrderLogicDefinition>BuyingBusinessProcess(x) → BusinessProcess(x) ∧ ∃y,∃z.∃r ((MaterialProduct(y) ∨ CommercialServiceAgreement(y)) ∧ MaterialEntity(z) ∧ BuyerRole(r)  ∧ hasRole(z,r) ∧ hasParticipantAtSomeTIme(x,y)  ∧ hasParticipantAtSomeTime(x,z))</iof-av:firstOrderLogicDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Buying Business Process x implies x is a Business Process that &apos;has participant at some time&apos; some &apos;material entity&apos; m that &apos;has role&apos; some Buyer Role r and x &apos;has participant at some time&apos; some Material Product or Commercial Service Agreement y</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;Capability">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000016"/>
		<rdfs:label xml:lang="en">capability</rdfs:label>
		<rdfs:comment>1. Whereas the BFO term &apos;disposition refers to all tendencies, powers, habits, skills, potentials, and so forth, that a material entity may possess, a Capability narrows this down by requiring the existence of an Agent that has an interest in the realization of the capability

2. This definition does not attempt to capture &quot;task-based&quot; capabilities that an entity may bear -- e.g., a stone&apos;s capability to kill when used by some person. Rather, it captures &quot;proper capabilities.&quot; See related discussion of &quot;proper functions&quot; in the literature. 

3. All functions are capabilities and in a future release BFO:Function will be asserted directly under capability.  

4. Not all capabilities are functions. Capabilities are often added to an artifact by the designer/engineer, or to a biological entity through evolution, as &quot;additional benefits,&quot; and are differentiated from function (i.e., purpose). Examples: the air conditioner in your car is a capability but not the function of your car. Yet the function of the car air conditioner certainly forms some material basis of your car&apos;s ability to provide a comfortable experience. The ability of your heart to beat fast to support your need to run fast to escape a threat. The decaying stick on the forest lawn does not have the function to be used as a tool, but certainly a chimpanzee
 may have an interest in using a stick to extract food from a termite mound.</rdfs:comment>
		<rdfs:comment>Maybe describing Capability vs. Function per Chandrasekaran and Josephson (2000) is a better way to go? Capability = Environment Centric Function and Function = Device Centric function. Function of a Drill is to remove material, it has capability to create hole in a workpiece. Function of a bulb is to produce light/photon particles, it has illumination capability. Capabilities are enabled by functions.</rdfs:comment>
		<skos:example xml:lang="en">Capability of a person to play chess at the &quot;master&quot; level; of a team to play football in the professional league; of a lathe to turn at maximal speed of 4,000 RPM; or of your digestive system to digest tiramisu.</skos:example>
		<iof-av:adaptedFrom>http://www.ontologyrepository.com/CommonCoreOntologies/Mid/AgentOntology</iof-av:adaptedFrom>
		<iof-av:elucidation>disposition in whose realization some agent has an interest</iof-av:elucidation>
		<iof-av:subjectMatterExpertExplanation>1. Someone’s or something&apos;s ability to bring about processes of a certain kind.
2.From Oxford Languages: Capability is
(1) the power or ability to do something, and
(2) the extent of someone&apos;s or something&apos;s ability.</iof-av:subjectMatterExpertExplanation>
		<iof-av:synonym>ability</iof-av:synonym>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;CommercialService">
		<rdfs:subClassOf rdf:resource="&iof-core;BusinessProcess"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;Agent">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&iof-core;hasRole"/>
								<owl:someValuesFrom rdf:resource="&iof-core;SupplierRole"/>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000117"/>
				<owl:someValuesFrom rdf:resource="&iof-core;SupplyingBusinessProcess"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;isSubjectOf"/>
				<owl:someValuesFrom rdf:resource="&iof-core;CommercialServiceAgreement"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;prescribedBy"/>
				<owl:someValuesFrom rdf:resource="&iof-core;CommercialServiceSpecification"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label>commercial service</rdfs:label>
		<rdfs:comment>1.Service provisioning process is considered in IOF as the Supplying Process

2. A consumption process means using or benefiting.

3.Typically, the service provisioning process and consumption process coincide temporally which is different from a material product that is consumed (used) only after supplied.</rdfs:comment>
		<skos:example>Lufthansa Aviation Services maintains airplanes for United Airlines when the plane stops at Frankfurt International Airport.</skos:example>
		<iof-av:firstOrderLogicDefinition>CommercialService(x) →  BusinessProcess(x) ∧ ∃p,∃y,∃r,∃a,∃s (CommercialServiceSpecification(p) ∧ Agent(y)  ∧ CommercialServiceAgreement(s) ∧ SupplierRole(r) ∧ SupplyingBusinessProcess(a) ∧ hasRole(y,r) ∧ hasParticipantAtSomeTime(x,y) ∧ hasOccurentPart(x,a) ∧ prescribedBy(x,p) ∧ isSubjectOf(x,s))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>business process that consists of a service provisioning process and a consumption process</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Commercial Service x implies x is a Business Process that is &apos;prescribed by&apos; some Commercial Service Specification p and that &apos;has participant at some time&apos; some Agent y that &apos;has role&apos; some Supplier Role r and x &apos;has occurent part&apos; some Supplying Business Process a and x &apos;is subject of&apos; some Commercial Service Agreement s</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;CommercialServiceAgreement">
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:label>commercial service agreement</rdfs:label>
		<skos:example>a cellphone plan, a maintenance service agreement, equipment lease agreement that includes a maintenance plan</skos:example>
		<iof-av:adaptedFrom>https://spec.edmcouncil.org/fibo/ontology/FND/Agreements/Agreements/Agreement</iof-av:adaptedFrom>
		<iof-av:counterExample>a blanket purchase order, commodity contract</iof-av:counterExample>
		<iof-av:elucidation>agreement that is about the provision of a commercial service and associated conditions</iof-av:elucidation>
		<iof-av:subjectMatterExpertExplanation>written contract between a client and service provider whereby the service provider supplies some service in the form of time, effort, and/or expertise in exchange for compensation [FIBO]</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;CommercialServiceSpecification">
		<rdfs:subClassOf rdf:resource="&iof-core;PlanSpecification"/>
		<rdfs:label>commercial service specification</rdfs:label>
		<iof-av:firstOrderLogicDefinition>PlanSpecification(x) ∧ ∃c(CommercialService(c) ∧ prescribes(x,c)) → CommercialServiceSpecification(x)</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>plan specification that prescribes a commercial service</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>x is a Plan Specification that &apos;prescribes&apos; some Commercial Service c implies x is a Commercial Service Specification</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;ComputingProcess">
		<rdfs:subClassOf rdf:resource="&iof-core;PlannedProcess"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:unionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;Agent">
							</rdf:Description>
							<rdf:Description rdf:about="&iof-core;Machine">
							</rdf:Description>
						</owl:unionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000059"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;Algorithm">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&bfo;BFO_0000084"/>
								<owl:someValuesFrom>
									<owl:Class>
										<owl:unionOf rdf:parseType="Collection">
											<rdf:Description rdf:about="&iof-core;Agent">
											</rdf:Description>
											<rdf:Description rdf:about="&iof-core;Machine">
											</rdf:Description>
										</owl:unionOf>
									</owl:Class>
								</owl:someValuesFrom>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label>computing process</rdfs:label>
		<iof-av:firstOrderLogicDefinition>ComputingProcess(x) → PlannedProcess(x) ∧ ∃y,∃a ((Agent(y) ∨ Machine(y)) ∧ Algorithm(a) ∧ hasParticipantAtSomeTIme(x,y) ∧ genericallyDependsOnAtSomeTime(a,y) ∧ concretizesAtSomeTime(x,a))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>planned process in which an algorithm is realized by an agent or a machine</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Computing Process x implies x is a Planned Process that &apos;has participant at some time&apos; some Agent or Machine y and that &apos;concretizes at some time&apos; some Algorithm a which &apos;generically depends on at some time&apos; y</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;CustomerRole">
		<rdfs:subClassOf rdf:resource="&iof-core;AgentRole"/>
		<rdfs:label>customer role</rdfs:label>
		<iof-av:elucidation>role held by an agent when it utilizes the product or receives the service or subscribes to the commercial service agreement</iof-av:elucidation>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">[OAGIS] Person, organization or automated system that is the end customer of the goods or services being provided in the associated transaction.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;DescriptiveInformationContentEntity">
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:label xml:lang="en">descriptive information content entity</rdfs:label>
		<rdfs:comment xml:lang="en">This class is intended to be a defined class and can be used for axiomatization and assertion convenience. It is not expected that entities will be asserted a subclass of this class.</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&iof-core;InformationContentEntity">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;describes"/>
						<owl:someValuesFrom rdf:resource="&bfo;BFO_0000001"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example>a description of a product in a product catalogue, the wheelbase of this car is 3m, digital copy of a Mona Lisa drawing</skos:example>
		<iof-av:abbreviation xml:lang="en">descriptive ICE</iof-av:abbreviation>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>DescriptiveInformationContentEntity(x) ↔ InformationContentEntity(x) ∧ ∃e(Entity(e) ∧ describes(x,e))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>information content entity that characterizes an entity</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Descriptive Information Content Entity is an Information Content Entity that &apos;describes&apos; some Entity</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">A textual or schematic representation as it is used to characterize (give a description of) someone or something.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;DesignSpecification">
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;prescribes"/>
				<owl:allValuesFrom rdf:resource="&bfo;BFO_0000002"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label>design specification</rdfs:label>
		<rdfs:comment>1. Design specification can take the form of a model, or of a textual or graphical specification

2. This class is not intended to be used to model planned processes and for that purpose plan specification should be used

3. Something man-made’ comprehends those physical and non-physical things that are intentionally created by human beings. Hence the thing specified by a design specification may be either BFO:GDC or BFO:Material Entity.

4. A design specification specifies what the thing should be such as shape, size, tolerance, performance but not necessarily how the thing should be made 

5. Typically, a design specification satisfies a set of requirements</rdfs:comment>
		<skos:example>document specifying the characteristics of a pharmaceutical product; the design of a software program to schedule the work orders in a factory</skos:example>
		<iof-av:adaptedFrom>http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:counterExample>process design</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>DesignSpecification(x) → InformationContentEntity(x)  ∧ 
 ∀c(prescribes(x,c) → Continuant(c))</iof-av:firstOrderLogicDefinition>
		<iof-av:firstOrderLogicDefinition>InformationContentEntity(x)  ∧ ∃c, ∃r ( continuant(c) ∧ RequirementSpecification(r) ∧ satisfies(x,r)  ∧ prescribes(x,c)) ∧ ∀c&apos;(prescribes(x,c&apos;) → Continuant(c&apos;)) → DesignSpecification(x)</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>information content entity that prescribes something man-made</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Design Specification d implies d is an Information Content Entity and that if d &apos;prescribes&apos; an entity y that y must be a &apos;continuant&apos;</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>d is a Information Content Entity and d prescribes some &apos;continuant&apos; c and d &apos;satisfies&apos; some Requirement Specification r and  all y &apos;prescribed by&apos; d are continuants implies d is a Design Specification</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">1. [ISO 14813-5]: How parts or constituents are related to an organised whole, providing specification for the structure, organization, appearance, etc., of a system or entity.

2. Detailed specification or model of something man-made that may satisfy a set of requirements.[CCO]</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;DesignativeInformationContentEntity">
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:label xml:lang="en">designative information content entity</rdfs:label>
		<rdfs:comment xml:lang="en">This class is intended to be a defined class and can be used for axiomatization and assertion convenience. It is not expected that entities will be asserted a subclass of this class.</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&iof-core;InformationContentEntity">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;designates"/>
						<owl:someValuesFrom rdf:resource="&bfo;BFO_0000001"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example xml:lang="en">uri of a website, social security number of a person, lot number of a batch of products, a serial number on a machine, a credit card number, a combination of data in a database table uniquely identify each record in the table</skos:example>
		<iof-av:abbreviation xml:lang="en">designative ICE</iof-av:abbreviation>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>DesignativeInformationContentEntity(x) ↔ InformationContentEntity(x) ∧ ∃e(Entity(e) ∧ designates(x,e))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>information content entity that uniquely identifies an entity</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Designative Information Content Entity is an Information Content Entity that &apos;designates&apos; some Entity</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">some pieces of information such as a sequence of symbols that are used for uniquely identifying an entity</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;DirectiveInformationContentEntity">
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:label xml:lang="en">directive information content entity</rdfs:label>
		<rdfs:comment xml:lang="en">This class is intended to be a defined class and can be used for axiomatization and assertion convenience. It is not expected that entities will be asserted a subclass of this class.</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&iof-core;InformationContentEntity">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;prescribes"/>
						<owl:someValuesFrom rdf:resource="&bfo;BFO_0000001"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example>blueprint of a building, process plan, software functional requirement</skos:example>
		<iof-av:abbreviation xml:lang="en">directive ICE</iof-av:abbreviation>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>DirectiveInformationContentEntity(x) ↔ InformationContentEntity(x) ∧ ∃e(Entity(e) ∧ prescribes(x,e))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>information content entity that prescribes a set of rules or guidelines for a process or a model of something man-made</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Directive Information Content Entity is an Information Content Entity that &apos;prescribes&apos; some Entity</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">A textual or schematic representation as it is used to guide or govern some tasks or used as a blueprint for building something.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;EngineeredSystem">
		<rdfs:subClassOf rdf:resource="&iof-core;System"/>
		<rdfs:label xml:lang="en">engineered system</rdfs:label>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&iof-core;System">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&bfo;BFO_0000196"/>
						<owl:someValuesFrom rdf:resource="&iof-core;Capability"/>
					</owl:Restriction>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;prescribedBy"/>
						<owl:someValuesFrom rdf:resource="&iof-core;DesignSpecification"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example>machine, laptop, traffic light system</skos:example>
		<iof-av:firstOrderLogicDefinition>EngineeredSystem(x) ↔ System(x) ∧ ∃d,∃c(DesignSpecification(d) ∧ Capability(c) ∧ prescribes(d,x) ∧ bearerOf(x,c))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>system which is designed to provide certain capabilities</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Engineered System is a System that is &apos;prescribed by&apos; some Design Specification and that is the &apos;bearer of&apos; some Capability</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;Event">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000003"/>
		<rdfs:subClassOf>
			<owl:Class>
				<owl:unionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000015">
					</rdf:Description>
					<rdf:Description rdf:about="&bfo;BFO_0000035">
					</rdf:Description>
				</owl:unionOf>
			</owl:Class>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;recognizedByAtSomeTime"/>
				<owl:someValuesFrom rdf:resource="&iof-core;Agent"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label>event</rdfs:label>
		<skos:example>a machine failure event, the amount of cells in a bioreactor reaches a certain threshold</skos:example>
		<iof-av:counterExample>an event in discrete event simulation is too generic and that notion of event is just BFO:Occurrent</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>Event(x) →  (Process(x) ∨ ProcessBoundary(x)) ∧ ∃a(Agent(a) ∧ recognizedByAtSomeTime(x,a))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>occurrent that is recognized by an agent and typically recorded</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Event x implies x is a &apos;process&apos; or &apos;process boundary&apos; and there is some Agent a that &apos;recognizes at some time&apos; x</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;GroupOfAgents">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000027"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000172"/>
				<owl:allValuesFrom rdf:resource="&iof-core;Agent"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label>group of agents</rdfs:label>
		<rdfs:comment>Group of agents being a BFO:Object Aggregate allows for a point in time where there is only one Agent present.</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000027">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&bfo;BFO_0000172"/>
						<owl:someValuesFrom rdf:resource="&iof-core;Agent"/>
					</owl:Restriction>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&bfo;BFO_0000172"/>
						<owl:allValuesFrom rdf:resource="&iof-core;Agent"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<iof-av:adaptedFrom>http://www.ontologyrepository.com/CommonCoreOntologies/Mid/AgentOntology</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>GroupOfAgents(x) ↔ ObjectAggregate(x) ∧ ∃y (Agent(y) ∧ memberPartOfAtAllTimes(y, x)) ∧ ∀z (memberPartOfAtAllTimes(z, x) → Agent(z))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>object aggregate that has a number of agents as member parts</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Group of Agents is an &apos;object aggregate&apos; that only has Agents as &apos;member parts&apos;</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>Group that typically consists of two or more (although there might be a point in time with only one member) persons, organizations or engineered systems, or any combination of these</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;InformationContentEntity">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000031"/>
		<rdfs:label xml:lang="en">information content entity</rdfs:label>
		<rdfs:comment>1.Information Content Entity is here intended to be a class of Entities whose instances are the informational content of Information Bearing Entities. For example, three instances of information bearers -- such as a bar chart, color-coded map, and a written report -- each of which lists the GDP of Countries for the year 2010 are each different bearers of the same information content. It is this content that is generically dependent upon its bearer. This treatment of Informational Content Entity (cf. the Information Artifact Ontology) leads to a principle of subtyping based upon the relationship that ICE&apos;s have with the Entity they are about rather than characteristics such as format, language, measurement scale, or media. The latter are treated here as being Qualities of bearers.

2. Information content entities are typically a string or array of symbols. Thus, they can be a textual or schematic representation.</rdfs:comment>
		<skos:example>the content of an email, the content of a document, the content in a STEP file</skos:example>
		<iof-av:abbreviation>ICE</iof-av:abbreviation>
		<iof-av:adaptedFrom>Information Artifact Ontology, http://purl.obolibrary.org/obo/IAO_0000030 and also the Common Core Ontology, http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>GenericallyDependentContinuant(x) ∧ ∃e(Entity(e) ∧ isAbout(x,e)) →
InformationContentEntity(x)</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>generically dependent continuant that is about an entity</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>x is a &apos;generically dependent continuant&apos; that &apos;is about&apos; some &apos;entity&apos; e implies x is an Information Content Entity</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>Information, specification, pattern, thought, or idea independent from its physical media. The physical media can be virtually any physical objects such as human brain, disc, paper, cave wall (as when ancient people wrote on the wall).</iof-av:subjectMatterExpertExplanation>
		<iof-av:synonym>Information Entity</iof-av:synonym>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;LocationIdentification">
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:label>location identification</rdfs:label>
		<rdfs:comment>1.more entities need to be created to be able to represent coordinates , for that purpose this OGC specification can be a good source:
http://docs.opengeospatial.org/is/18-010r7/18-010r7.html#106

2.at this point IOF:Core is only dealing with physical locations while virtual locations will be considered in a future version.
 
3. physical location is a synonym for BFO:Site and hence the usage of BFO:Site within the axioms should be interpreted as physical location</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&iof-core;InformationContentEntity">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;designates"/>
						<owl:someValuesFrom rdf:resource="&bfo;BFO_0000029"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example>postal address, GPS coordinate, GS1 global location number (GLN) for physical and digital location, 42.8864° N, 78.8784° W,  London, the factory floor</skos:example>
		<iof-av:firstOrderLogicDefinition>LocationIdentification(x) ↔ InformationContentEntity(x) ∧ ∃l(Site(l) ∧ designates(x,l))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>information content entity that identifies a physical location</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition xml:lang="en">Location Identification is an Information Content Entity that &apos;designates&apos; some &apos;site&apos;</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>Information that identifies a location typically through coordinate values or through a name or description</iof-av:subjectMatterExpertExplanation>
		<iof-av:synonym>site identifier, site designator</iof-av:synonym>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;Machine">
		<rdfs:subClassOf rdf:resource="&iof-core;MaterialArtifact"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000110"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;Assembly">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&bfo;BFO_0000163"/>
								<owl:someValuesFrom rdf:resource="&bfo;BFO_0000034"/>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">machine</rdfs:label>
		<rdfs:comment xml:lang="en">the current axiom cannot be N&amp;S condition because it would conclude that something like a coffee mug with a lid is a machine</rdfs:comment>
		<iof-av:firstOrderLogicDefinition>Machine(x) → MaterialArtifact(x) ∧ ∃c,∃f(Assembly(c) ∧ Function(f) ∧ hasMaterialBasisAtAllTimes(f,c) ∧ hasContinuantPartAtAllTimes(x,c) ∧ inheresIn(f,x))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>material artifact that contains a number of physically connected assemblies that work together to realize the artifact’s designed  function</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Machine x implies x is a Material Artifact that &apos;has continuant part at all times&apos;, one or more Assemblies c  that are the &apos;material basis at all times&apos; of the &apos;function&apos; f that &apos;inheres in&apos; x</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">Man-made artifact containing a set of physically-connected components that work together as a unit with some designed function.

Other common definitions:

1. ISO 22096:2007(en): Is a mechanical system designed expressly to perform a specific task, such as the forming of material or the transference and transformation of motion, force or energy.

2. Is a mechanical structure that uses power to apply forces and control movement to perform an intended action. Machines can be driven by animals and people, by natural forces such as wind and water, and by chemical, thermal, or electrical power, and include a system of mechanisms that shape the actuator input to achieve a specific application of output forces and movement [WIkipedia].</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;MaintainableMaterialItem">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000040"/>
		<rdfs:label>maintainable material item</rdfs:label>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<owl:Class>
						<owl:unionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;EngineeredSystem">
							</rdf:Description>
							<rdf:Description rdf:about="&iof-core;MaterialArtifact">
							</rdf:Description>
						</owl:unionOf>
					</owl:Class>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;hasRole"/>
						<owl:someValuesFrom rdf:resource="&iof-core;MaintainableMaterialItemRole"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<iof-av:firstOrderLogicDefinition>MaintainableMaterialItem(x) ↔ (MaterialArtifact(x) ∨ EngineeredSystem(x)) ∧ ∃y (MaintainableMaterialItemRole(y) ∧ hasRole(x,y))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>material artifact or engineered system which has the maintainable material item role</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Maintainable Material Item is a Material Artifact or an Engineered System which &apos;has role&apos; some Maintainable Material Item Role</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>A physical asset on which maintenance is actioned according to a maintenance strategy.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;MaintainableMaterialItemRole">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000023"/>
		<rdfs:label>maintainable material item role</rdfs:label>
		<iof-av:elucidation>role played by an asset when there is a maintenance strategy prescribing its maintenance process</iof-av:elucidation>
		<iof-av:subjectMatterExpertExplanation>The role played by an asset when it is assigned a maintenance strategy.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;ManufacturerRole">
		<rdfs:subClassOf rdf:resource="&iof-core;AgentRole"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;roleOf"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;BusinessOrganization">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&bfo;BFO_0000056"/>
								<owl:someValuesFrom rdf:resource="&iof-core;ProductProductionProcess"/>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label>manufacturer role</rdfs:label>
		<iof-av:firstOrderLogicDefinition>ManufacturerRole(x) → Role(x) ∧ ∃y,∃p (BusinessOrganization(y)  ∧ ProductProductionProcess(p) ∧  participatesInAtSomeTime(y,p) ∧ roleOf(x, y))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>role held by a business organization when it produces material products</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Manufacturer Role x implies x is an Agent Role that is the &apos;role of&apos; a Business Organization y when it &apos;participates in at some time&apos; some Product Production Process p</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>An organization has a manufacturer role when it produces goods for sale to wholesalers, retailers or end consumers.[bizfluent.com]</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;ManufacturingProcess">
		<rdfs:subClassOf rdf:resource="&iof-core;PlannedProcess"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<owl:Class>
								<owl:unionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&iof-core;Machine">
									</rdf:Description>
									<rdf:Description rdf:about="&iof-core;Person">
									</rdf:Description>
								</owl:unionOf>
							</owl:Class>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&bfo;BFO_0000101"/>
								<owl:someValuesFrom rdf:resource="&iof-core;PlanSpecification"/>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;hasInput"/>
				<owl:someValuesFrom rdf:resource="&bfo;BFO_0000040"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;hasSpecifiedOutput"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:unionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;MaterialArtifact">
							</rdf:Description>
							<owl:Class>
								<owl:intersectionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&bfo;BFO_0000040">
									</rdf:Description>
									<owl:Restriction>
										<owl:onProperty rdf:resource="&iof-core;prescribedBy"/>
										<owl:someValuesFrom rdf:resource="&iof-core;DesignSpecification"/>
									</owl:Restriction>
								</owl:intersectionOf>
							</owl:Class>
						</owl:unionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">manufacturing process</rdfs:label>
		<rdfs:comment>1. This definition presupposes that the outputs of a manufacturing process are in every case material artifacts or man-made substances. 

2. Processes that have as their primary output, something immaterial or informational in nature (digital outputs), such as found in the production of software, will be considered speparately at a later stage.
 
3.. There are other processes that while they may come into direct contact with a manufactured component or substance and are often considered part of the overall set of activities planned and executed to manufacture something, they are not &quot;transformative&quot; in nature relative to that which is manufactured, and are specifically excluded the definition. Examples include setup, tear down, transporting components or materials between locations, inspection, and so forth.
This is addressed by output in the axiom. Setup =&gt; does not have output. Tear down like disassembly should still be considered transformative.

4. This definition places no additional restrictions on the output of a manufacturing process in terms of being in a state of completion (completed component or finished good).</rdfs:comment>
		<skos:example>Drilling a hole on an engine block; manufacturing operation for making a shaft consisting of milling, turning, and drilling manufacturing processes; assembly process, and quality control process; a manufacturing process that uses 3D printing to create the output material entity.</skos:example>
		<iof-av:counterExample>statistical process control and preventative maintenance management processes that maximize machine availability and the product quality of manufactured products.</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>ManufacturingProcess(x) →  PlannedProcess(x) ∧ ∃m,∃y,∃p,∃z (MaterialEntity(m) ∧ (MaterialArtifact(y) ∨ ∃d( MaterialEntity(y) ∧ DesignSpecification(d) ∧ prescribes(d,y))  ∧ PlanSpecification(p) ∧ prescribes(p,x) ∧ (Person(z)  ∨ Machine(z)) ∧ isCarrierOf(z,p)  ∧ particiaptesInAtSomeTime(z,x) ∧ isInputOf(m,x) ∧ hasSpecifiedOutput(x,y))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>planned process that consists of a structured set of operations through which input material is transformed or modified into another material entity</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Manufacturing Process x implies x is a Planned Process that &apos;has input&apos; some &apos;material entity&apos; m and &apos;has specified output&apos; y which is a Material Artifact or a &apos;material entity&apos; that is &apos;prescribes by&apos; some Design Specification d and x &apos;has participant at some time&apos; some Machine or Person z that is the &apos;carrier of&apos; some Plan Specification p that prescribes x</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>1. Structured set of activities or operations performed upon material to convert it from the raw material or a semifinished state to a state of further completion. [ISO 15531-1,ISO 15531-43:2006(en)]
2.  Series of operations performed on material to convert it from a raw material or a semifinished state to a state of further completion. Manufacturing processes can be arranged in a process layout, product layout, cellular layout, or fixed-position layout. Manufacturing processes can be planned to support make-to-stock, make-to-order, assemble-to-order, and so forth, based on the strategic use and placement of inventories [APICS &amp; ISO 15531-43].</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;MaterialArtifact">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000030"/>
		<rdfs:label xml:lang="en">material artifact</rdfs:label>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000030">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&bfo;BFO_0000196"/>
						<owl:someValuesFrom>
							<owl:Class>
								<owl:intersectionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&bfo;BFO_0000034">
									</rdf:Description>
									<owl:Restriction>
										<owl:onProperty rdf:resource="&iof-core;prescribedBy"/>
										<owl:someValuesFrom rdf:resource="&iof-core;DesignSpecification"/>
									</owl:Restriction>
								</owl:intersectionOf>
							</owl:Class>
						</owl:someValuesFrom>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example>a machine, a screwdriver, a screw, a sheet of paper</skos:example>
		<iof-av:adaptedFrom>http://www.ontologyrepository.com/CommonCoreOntologies/Mid/ArtifactOntology</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>MaterialArtifact(x) ↔ Object(x)  ∧ ∃f,∃d(Function(f) ∧ DesignSpecification(d) ∧ bearerOf(x,f) ∧ prescribes(d,f))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>object that is deliberately created to have a certain function</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Material Artifact is an Object that is a &apos;bearer of&apos; some &apos;function&apos; &apos;prescribed by&apos; some Design Specification</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">Object designed by some person or organization to have a certain function.

Other common definitions
1. An object made by a human being, typically an item of cultural or historical interest [dictionary].

2. object made or shaped by a human [ISO 18461]. Note 1: Objects created for their aesthetic value are considered art objects. Note 2: Replicas are excluded.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;MaterialComponent">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000040"/>
		<rdfs:label>material component</rdfs:label>
		<rdfs:comment>1. Assemblies that are components for one manufacturer may be final products for another (e.g., the selling of diesel engines is a primary product line of Cummins diesel engine yet a component assembly for its customers, Freightliner Trucks). The context in which a material entity is used needs to be considered to whether it bears the component role.

2. In most manufacturing use cases material components will be subclass of Material Artifact</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;hasRole"/>
						<owl:someValuesFrom rdf:resource="&iof-core;MaterialComponentRole"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example>portion of water; portion of crude oil; sea shells; bolt; transmission assembly;engine in an airplane</skos:example>
		<iof-av:counterExample>Braking subsystem -- systems and subsystems are object aggregates and often have fiat boundaries, in which case they may be incorrectly inferred as product components. Othertimes, they are systems with bonafide boundaries and should be inferred as a product component.</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>MaterialComponent(x) ↔ MaterialEntity(x) ∧  ∃r(MaterialComponentRole(x) ∧ hasRole(x,r))</iof-av:firstOrderLogicDefinition>
		<iof-av:firstOrderLogicDefinition>MaterialEntity(x) ∧∃y (MaterialEntity(y) ∧ componentPartOfAtAllTimes(x,y)) → MaterialComponent(x)</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>material entity which has the material component role</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Material Component is a &apos;material entity&apos; that &apos;has role&apos; some Material Component Role</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>x is a &apos;material entity&apos; that is &apos;component part of at all times&apos; some &apos;material entity&apos; implies x is a Material Component</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>From Industrial Contexts:
1. A raw material, part, or subassembly that goes into a higher level assembly, compound, or the final product. This term may also include packaging materials for finished items [APICS].

2. An individual piece used in the assembly of a single unit of equipment [ISO 13533:2001]</iof-av:subjectMatterExpertExplanation>
		<iof-av:synonym>part</iof-av:synonym>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;MaterialComponentRole">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000023"/>
		<rdfs:label>material component role</rdfs:label>
		<iof-av:firstOrderLogicDefinition>Role(x) ∧ ∃c, ∃y(MaterialEntity(c) ∧ MaterialEntity(y) ∧ componentPartOfAtSomeTime(c,y) ∧ roleOf(x, c)) → MaterialComponentRole(x)</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>role held by a material entity when it is a proper part of another material entity or is planned to be a proper part of another material entity</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>x is a &apos;role of&apos; some material entity c that is &apos;component part of at some time&apos; some material entity y implies x is Material Component Role</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;MaterialLocationChangeProcess">
		<rdfs:subClassOf rdf:resource="&iof-core;PlannedProcess"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&bfo;BFO_0000040">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty>
									<rdf:Description>
										<owl:inverseOf rdf:resource="&bfo;BFO_0000170"/>
									</rdf:Description>
								</owl:onProperty>
								<owl:someValuesFrom>
									<owl:Class>
										<owl:intersectionOf rdf:parseType="Collection">
											<rdf:Description rdf:about="&bfo;BFO_0000004">
											</rdf:Description>
											<owl:Restriction>
												<owl:onProperty rdf:resource="&bfo;BFO_0000082"/>
												<owl:someValuesFrom rdf:resource="&bfo;BFO_0000029"/>
											</owl:Restriction>
											<owl:Restriction>
												<owl:onProperty rdf:resource="&bfo;BFO_0000108"/>
												<owl:someValuesFrom>
													<owl:Class>
														<owl:intersectionOf rdf:parseType="Collection">
															<rdf:Description rdf:about="&bfo;BFO_0000203">
															</rdf:Description>
															<owl:Class>
																<owl:intersectionOf rdf:parseType="Collection">
																	<owl:Restriction>
																		<owl:onProperty rdf:resource="&bfo;BFO_0000221"/>
																		<owl:someValuesFrom rdf:resource="&bfo;BFO_0000008"/>
																	</owl:Restriction>
																	<owl:Restriction>
																		<owl:onProperty>
																			<rdf:Description>
																				<owl:inverseOf rdf:resource="&bfo;BFO_0000199"/>
																			</rdf:Description>
																		</owl:onProperty>
																		<owl:someValuesFrom rdf:resource="&iof-core;PlannedProcess"/>
																	</owl:Restriction>
																</owl:intersectionOf>
															</owl:Class>
														</owl:intersectionOf>
													</owl:Class>
												</owl:someValuesFrom>
											</owl:Restriction>
										</owl:intersectionOf>
									</owl:Class>
								</owl:someValuesFrom>
							</owl:Restriction>
							<owl:Restriction>
								<owl:onProperty>
									<rdf:Description>
										<owl:inverseOf rdf:resource="&bfo;BFO_0000170"/>
									</rdf:Description>
								</owl:onProperty>
								<owl:someValuesFrom>
									<owl:Class>
										<owl:intersectionOf rdf:parseType="Collection">
											<rdf:Description rdf:about="&bfo;BFO_0000004">
											</rdf:Description>
											<owl:Restriction>
												<owl:onProperty rdf:resource="&bfo;BFO_0000082"/>
												<owl:someValuesFrom rdf:resource="&bfo;BFO_0000029"/>
											</owl:Restriction>
											<owl:Restriction>
												<owl:onProperty rdf:resource="&bfo;BFO_0000108"/>
												<owl:someValuesFrom>
													<owl:Class>
														<owl:intersectionOf rdf:parseType="Collection">
															<rdf:Description rdf:about="&bfo;BFO_0000203">
															</rdf:Description>
															<owl:Restriction>
																<owl:onProperty rdf:resource="&bfo;BFO_0000223"/>
																<owl:someValuesFrom>
																	<owl:Class>
																		<owl:intersectionOf rdf:parseType="Collection">
																			<rdf:Description rdf:about="&bfo;BFO_0000008">
																			</rdf:Description>
																			<owl:Restriction>
																				<owl:onProperty>
																					<rdf:Description>
																						<owl:inverseOf rdf:resource="&bfo;BFO_0000199"/>
																					</rdf:Description>
																				</owl:onProperty>
																				<owl:someValuesFrom rdf:resource="&iof-core;PlannedProcess"/>
																			</owl:Restriction>
																		</owl:intersectionOf>
																	</owl:Class>
																</owl:someValuesFrom>
															</owl:Restriction>
														</owl:intersectionOf>
													</owl:Class>
												</owl:someValuesFrom>
											</owl:Restriction>
										</owl:intersectionOf>
									</owl:Class>
								</owl:someValuesFrom>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">material location change process</rdfs:label>
		<rdfs:comment>1. Material transfer process includes both the internal (e.g., inside a factory) and external (e.g., between factories) movement of an object

2. BFO:Site is the synonym for physical location which is why Site is used in the axioms</rdfs:comment>
		<skos:example>Shipping goods from a warehouse to a customer; moving a tool from one location (work center) to another within the factory; transporting finished goods from one warehouse to another; pumping portions of crude oil through a pipeline; transferring a load of apples from a bin to a container; picking an apple; transporting passengers on a bus;</skos:example>
		<iof-av:counterExample>A specific type of material handling: E.g., changing only the orientation of the object within the same site (this does not change the site from t to t&apos;); throwing waste into a garbage bin; removing a wing nut from a fixture in preparation for inserting a workpiece into the fixture.</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>MaterialLocationChangeProcess(​x​) → PlannedProcess(​x)​ ∧ ​∃​y ∃​​t ∃​​t′​​ ∃​​t&apos;&apos; ∃​s ∃​s′​ ∃​z ∃​z′(Material Entity(​y​) ∧ TemporalInstant(t) ∧ TemporalInstant(t&apos;) ∧ TemporalRegion(t&apos;&apos;) ∧ IndependentContinuant(s) ∧ IndependentContinuant(s&apos;) ∧ Site(z)  ∧ Site(z&apos;) ∧ hasParticipantAtSomeTime(x,y)
∧ firstInstantOf(​t​, ​t&apos;&apos;​) ∧ lastInstantOf(​t&apos;​, ​t&apos;&apos;​) ∧ occupiesTemporalRegion(​x,​t&apos;&apos;)​ ∧  existsAt(s,t) ∧ existsAt(s&apos;,t&apos;) ∧  locatedInAtalltimes(s,z)  ∧ locatedInAtAlltimes(s&apos;,z&apos;) ∧  locationOfAtAlltimes(s,y)  ∧ locationOfAtAllTimes(s&apos;,y))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>planned process that results in a material entity moving from one physical location to another</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition xml:lang="en">Material Location Change Process implies a Planned Process in which a &apos;material entity&apos; is moved from one &apos;site&apos; to another.</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>A process that results in a piece of material such as part or portion of material such as a bucket of metal powder moving from one physical location to another typically by some person, machine, piece of equipment or engineered system but not necessary the case.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;MaterialProduct">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000040"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000056"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:unionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;BuyingBusinessProcess">
							</rdf:Description>
							<rdf:Description rdf:about="&iof-core;SellingBusinessProcess">
							</rdf:Description>
							<rdf:Description rdf:about="&iof-core;SupplyingBusinessProcess">
							</rdf:Description>
						</owl:unionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">material product</rdfs:label>
		<rdfs:comment>The definition does exclude services sold as product which deviates from some standard definitions and economic theory. 
Services as products as well as software products will be considered in the next version of the IOF</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;hasRole"/>
						<owl:someValuesFrom rdf:resource="&iof-core;MaterialProductRole"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example>1. Natural resources: the seashells lying on the beach that some person intends to collect, package and sell; the iron ore in a mountain the rights to which some mining company has just purchased which they intend to mine and sell to iron-making processors. Parcels of real estate some land developer sells to builders.

2. Any manufactured good</skos:example>
		<iof-av:counterExample>certified pre-owned warranty plan; software as a service (SaaS); training course; consultancy services;
Office 365</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>MaterialProduct(x) → MaterialEntity(x) ∧ ∃y((BuyingBusinessProcess(y) ∨ OfferingForSaleBusinessProcess(y) ∨SupplyingBusinessProcess(y)) ∧  participatesInAtSomeTime(x,y))</iof-av:firstOrderLogicDefinition>
		<iof-av:firstOrderLogicDefinition>MaterialProduct(x) ↔ MaterialEntity(x) ∧  ∃r(MaterialProductRole(x) ∧ hasRole(x,r))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>material entity which has the material product role</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Material Product is a &apos;material entity&apos; that is the &apos;has role&apos; some Material Product Role</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition xml:lang="en">Material Product x implies x is a &apos;material entity&apos; that &apos;participates in at some time&apos; some Buying Business Process or Offering for Sale Business Process or Supplying Business Process y</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">1. Material entity for which there is market or internal demand, which some person or organization plans to sell or grant ownership rights to in some economic exchange.
2. A good or service produced for sale or barter [APICS].
3. Any good or service [ISO/Guide 64:2008]</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;MaterialProductRole">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000023"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;roleOf"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&bfo;BFO_0000040">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&bfo;BFO_0000056"/>
								<owl:someValuesFrom>
									<owl:Class>
										<owl:unionOf rdf:parseType="Collection">
											<rdf:Description rdf:about="&iof-core;BuyingBusinessProcess">
											</rdf:Description>
											<rdf:Description rdf:about="&iof-core;SellingBusinessProcess">
											</rdf:Description>
											<rdf:Description rdf:about="&iof-core;SupplyingBusinessProcess">
											</rdf:Description>
										</owl:unionOf>
									</owl:Class>
								</owl:someValuesFrom>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">material product role</rdfs:label>
		<iof-av:firstOrderLogicDefinition>MaterialProductRole(x) → Role(x)  ∧ ∃y,∃z((BuyingBusinessProcess(y) ∨ OfferingForSaleBusinessProcess(y) ∨SupplyingBusinessProcess(y)) ∧ MaterialEntity(z) participatesInAtSomeTime(z,y) ∧ roleOf(x,z))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>role held by a material entity when it is being offered for sale, or for supplying or is being bought</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Material Product Role x implies x is a &apos;role&apos; that is the &apos;role of&apos; some &apos;material entity&apos; m when it &apos;participates in at some time&apos; some Buying Business Process or Offering For Sale Business Process or Supplying Business Process y</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;MaterialResource">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000040"/>
		<rdfs:label>material resource</rdfs:label>
		<rdfs:comment>1. This defined class is designed to group material entities according to a very broad criterion and is not intended to be used as a parent class for resource types that can be more specifically asserted under another class.

2. Skills and capabilities or other entities in the sdc branch are not resources but they can be considered resources indirectly through their bearer</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;hasRole"/>
						<owl:someValuesFrom rdf:resource="&iof-core;MaterialResourceRole"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;isAvailableToAtSomeTime"/>
						<owl:someValuesFrom>
							<owl:Class>
								<owl:unionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&iof-core;EngineeredSystem">
									</rdf:Description>
									<rdf:Description rdf:about="&iof-core;GroupOfAgents">
									</rdf:Description>
									<rdf:Description rdf:about="&iof-core;Person">
									</rdf:Description>
								</owl:unionOf>
							</owl:Class>
						</owl:someValuesFrom>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example xml:lang="en">Intangible examples:  intellectual property; software program; data; knowledge. Tangible examples: person; factory; a body of water available to cool a reactor; money; a portion of raw material available to produce a good or service.</skos:example>
		<iof-av:counterExample>(ambiguous/undesirable): a portion of water on my factory floor that formed after a recent rainshower.</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>MaterialResource(x) ↔ MaterialEntity(x) ∧  ∃r(MaterialResourceRole(x) ∧ hasRole(x,r))</iof-av:firstOrderLogicDefinition>
		<iof-av:firstOrderLogicDefinition>MaterialResource(x) ↔ MaterialEntity(x) ∧ ∃a((Person(a) ∨ GroupOfAgents(a) ∨ EngineeredSystem(a)) ∧ isAvailableToAtSomeTime(x,a))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>material entity which has the material resource role</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Material Resource is a &apos;material entity&apos; that &apos;has role&apos; some Material Resource Role</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Material Resource is a &apos;material entity&apos; that &apos;is available to at some time&apos; some Person or Group of Agents or Engineered System</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">1. A stock or supply of money, materials, staff, and other assets that can be drawn on by a person or organization in order to function effectively [Oxford Languages].

2. A source or supply from which a benefit is produced and that has some utility [Wikipedia].</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;MaterialResourceRole">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000023"/>
		<rdfs:label>material resource role</rdfs:label>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000023">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;roleOf"/>
						<owl:someValuesFrom>
							<owl:Class>
								<owl:intersectionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&bfo;BFO_0000040">
									</rdf:Description>
									<owl:Restriction>
										<owl:onProperty rdf:resource="&iof-core;isAvailableToAtSomeTime"/>
										<owl:someValuesFrom>
											<owl:Class>
												<owl:unionOf rdf:parseType="Collection">
													<rdf:Description rdf:about="&iof-core;EngineeredSystem">
													</rdf:Description>
													<rdf:Description rdf:about="&iof-core;GroupOfAgents">
													</rdf:Description>
													<rdf:Description rdf:about="&iof-core;Person">
													</rdf:Description>
												</owl:unionOf>
											</owl:Class>
										</owl:someValuesFrom>
									</owl:Restriction>
								</owl:intersectionOf>
							</owl:Class>
						</owl:someValuesFrom>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<iof-av:adaptedFrom xml:lang="en">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/ArtifactOntology</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>MaterialResourceRole(x) ↔ Role(x) ∧ ∃a,∃y((Person(a) ∨ GroupOfAgents(a) ∨ EngineeredSystem(y)) ∧ MaterialEntity(y) ∧ isAvailableToAtSomeTime(y,a) ∧ roleOf(x,y))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>role played by a material entity that consists in it being available to a person or group of agents or engineered system</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Material Resource Role is a &apos;role&apos; that is the &apos;role of&apos; some &apos;material entity&apos; when it &apos;is available to at some time&apos; some Person or Group of Agents or Engineered System</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;MeasurementInformationContentEntity">
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;isOutputOf"/>
				<owl:someValuesFrom rdf:resource="&iof-core;MeasurementProcess"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">measurement information content entity</rdfs:label>
		<skos:example>10 meter (measurement information content entity of a length quality of something); similarity measurement of information; a two fold increase in expression of a gene in a cancer patient; result of the DNA sequencing</skos:example>
		<iof-av:abbreviation xml:lang="en">measurement ICE</iof-av:abbreviation>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>MeasurementInformationContentEntity → InformationContentEntity(x) ∧ ∃m(MeasurementProcess(m) ∧ isOutputOf(x,m))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>information content entity that is the result of a measurement process</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>x is an Measurement Content Entity implies x is an Information Content Entity and &apos;is output of&apos; some Measurement Process</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>A numerical or categorical representation of some attribute of an entity relative to some scale or classification scheme</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;MeasurementProcess">
		<rdfs:subClassOf rdf:resource="&iof-core;PlannedProcess"/>
		<rdfs:label>measurement process</rdfs:label>
		<iof-av:adaptedFrom>elucidation was adapted from: ISO 9000:2015(en), 3.11.5</iof-av:adaptedFrom>
		<iof-av:elucidation>planned process to determine the value of a quantity</iof-av:elucidation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;ObjectiveSpecification">
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:label xml:lang="en">objective specification</rdfs:label>
		<rdfs:comment>Typically is part of the plan specification</rdfs:comment>
		<skos:example xml:lang="en">The objective specification in a manufacturer&apos;s six-sigma process improvement program will describe in some detail, the quality improvements to be achieved (as in e.g. the level of reduction in causes of defects, or in the level variability in either or both manufacturing and business processes).</skos:example>
		<iof-av:adaptedFrom>http://www.obofoundry.org/ontology/iao.html</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>InformatiionContentEntity(x) ∧ (∃y(ProcessCharacteristic(y) ∨ Capability(y) ∧ prescribes(x,y)) ∨ ∃c,∃p(Continuant(c) ∧ Process(p) ∧ isOutputOf(c,p) ∧  prescribes(x,c))) → ObjectiveSpecification(x)</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>information content entity that prescribes what the outcome of some process should be</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition xml:lang="en">x is an Information Content Entity that &apos;prescribes&apos; some Process Characteristic or Capability y or &apos;continuant&apos; c which is the &apos;output of&apos; some &apos;process&apos; p implies an x is an Objective Specification</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>A detailed description of what the outcomes of some process should be.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;OrganizedGroupOfAgents">
		<rdfs:subClassOf rdf:resource="&iof-core;GroupOfAgents"/>
		<rdfs:label xml:lang="en">organized group of agents</rdfs:label>
		<rdfs:comment xml:lang="en">1. Members of organizations are either Organizations themselves or individual Persons. Members can bear specific Organization Member Roles that are determined in the organization rules. The organization rules also determine how decisions are made on behalf of the Organization by the organization members.
2. The group of agents will be such that its activities are governed by a common set of rules.
3. This wasn&apos;t called Organization because, it can be a group of machines. It would sound odd to conclude that it is an organization.</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&iof-core;GroupOfAgents">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&bfo;BFO_0000196"/>
						<owl:someValuesFrom>
							<owl:Class>
								<owl:intersectionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&bfo;BFO_0000034">
									</rdf:Description>
									<owl:Restriction>
										<owl:onProperty rdf:resource="&iof-core;prescribedBy"/>
										<owl:someValuesFrom rdf:resource="&iof-core;DirectiveInformationContentEntity"/>
									</owl:Restriction>
								</owl:intersectionOf>
							</owl:Class>
						</owl:someValuesFrom>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example xml:lang="en">goverment, a company, a political party, a city goverment, yakuza, business unit, department, division, an automated manufacturing cell</skos:example>
		<iof-av:adaptedFrom>http://www.ontologyrepository.com/CommonCoreOntologies/Mid/AgentOntology</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>OrganizedGroupOfAgents(x) ↔ ObjectAggregate(x) ∧ ∃i,∃f(DirectiveInformationContentEntity(i) ∧ Function(f) ∧ bearerOf(x, f) ∧ prescribes(i, f))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>group of agents that is pursuing a common set of plans and objectives</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Organized Group Of Agents is a Group of Agents that is the &apos;bearer of some&apos; &apos;function&apos; which is &apos;prescribed by&apos; some Directive Information Content Entity</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;Person">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000030"/>
		<rdfs:label>person</rdfs:label>
		<iof-av:elucidation>object that is the member of the species of homo sapiens</iof-av:elucidation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;PlanSpecification">
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000110"/>
				<owl:someValuesFrom rdf:resource="&iof-core;ActionSpecification"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000110"/>
				<owl:someValuesFrom rdf:resource="&iof-core;ObjectiveSpecification"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">plan specification</rdfs:label>
		<rdfs:comment>When concretized, plan specification may be realized in a process performed by some agent to achieve the prescribed process objectives by taking the prescribed actions.</rdfs:comment>
		<skos:example>a manufacturer&apos;s sales plan for this quarter, process plan for producing a part</skos:example>
		<iof-av:adaptedFrom>http://purl.obolibrary.org/obo/IAO_0000104</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>InformationContentEntity(x) ∧ ∃a, ∃o,∃p(ActionSpecification(a) ∧ ObjectiveSpecification(o) ∧ PlannedProcess(p) ∧ continuantPartOfAtAllTimes(a,x) ∧ continuantPartOfAtAllTimes(o,x) ∧ prescribes(x,p)) → PlanSpecification(x)</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>information content entity that has action specifications and objective specifications as parts</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition xml:lang="en">x is an Information Content Entity that &apos;prescribes&apos; some Planned Process p and &apos;has continuant part at all times&apos; some Action Specification a and some Objective Specification o implies x is a Plan Specification</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>Detailed description for doing or realizing something. [Oxford Languages]</iof-av:subjectMatterExpertExplanation>
		<iof-av:synonym>process design</iof-av:synonym>
		<iof-av:synonym>process specification</iof-av:synonym>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;PlannedProcess">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000015"/>
		<rdfs:label xml:lang="en">planned process</rdfs:label>
		<rdfs:comment>1. &apos;Planned&apos; is here functioning as a specifier, rather than as a modifier analogous to &apos;cancelled&apos; or &apos;averted&apos;. Therefore, to say that a process is planned is not to say that it has not yet taken place. Rather, it is to say that it is (was or will have been) protocol-driven, instruction-driven, command-driven, or software-driven, or in some combination thereof, as prescribed by one or more directive information content entities. 
				  
2. &apos;Planned&apos; means &apos;protocol driven&apos;. Protocols may be written, spoken, or simply thought – as when upon waking up, we plan, for instance, what to eat for breakfast.</rdfs:comment>
		<rdfs:comment>By specifying &apos;PlannedProcess prescribed by some &apos;Plan Specification&apos; as N&amp;S condition, we are saying a Process resulting from just Objective Specification or Requirement Specification cannot be a planned process. This may need further consideration. If this does not hold, we would need to change the axiom to ‘prescribes by some Directive ICE’ and the axiom can be only necessary condition. And ‘prescribes by some &apos;Plan Specification&apos; becomes only sufficient condition.</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000015">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;prescribedBy"/>
						<owl:someValuesFrom rdf:resource="&iof-core;PlanSpecification"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example xml:lang="en">A tire manufacturing process occurs as prescribed by a manufacturing plan specification.</skos:example>
		<iof-av:counterExample>unexpected failure events; unexpected malfunctioning of a machine; safety occurrence (that lacks explicit plan specifications);</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>PlannedProcess(x) ↔ Process(x) ∧ ∃s (PlanSpecification(s) ∧ prescribes(s, x))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>process that is prescribed by a plan specification</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Planned Process is a &apos;process&apos; that is &apos;prescribed by&apos; some Plan Specification</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">Process that is documented by both a description and a plan. Note 1 to entry: The related process description and plan are coordinated, and the plan can include standards, requirements, objectives, resources, and assignments.
 [ISO/IEC/IEEE 24765]</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;ProcessCharacteristic">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000003"/>
		<rdfs:label xml:lang="en">process characteristic</rdfs:label>
		<rdfs:comment>Here ‘attribute’ is not a technical term.</rdfs:comment>
		<skos:example>the rate of production of a product production process, heart rate, the rate of temperature change resulting from a heating process</skos:example>
		<iof-av:elucidation>attribute of a process</iof-av:elucidation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;ProcuringBusinessProcess">
		<rdfs:subClassOf rdf:resource="&iof-core;BusinessProcess"/>
		<rdfs:label>procuring business process</rdfs:label>
		<rdfs:comment>1. The procurement process considers the whole cycle from identification of needs through to the end of a services contract or the end of the life of goods, including disposal.

2. Sourcing is a part of the procurement process that includes planning, defining specifications (3.26) and selecting suppliers. [Source: ISO 20400:2017]

3. It should be noted that we consciously exclude the person-to-person transactions, but person-to-business is not excluded.</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&iof-core;BusinessProcess">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&bfo;BFO_0000117"/>
						<owl:someValuesFrom rdf:resource="&iof-core;BuyingBusinessProcess"/>
					</owl:Restriction>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&bfo;BFO_0000117"/>
						<owl:someValuesFrom>
							<owl:Class>
								<owl:unionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&iof-core;SellingBusinessProcess">
									</rdf:Description>
									<rdf:Description rdf:about="&iof-core;SupplyingBusinessProcess">
									</rdf:Description>
								</owl:unionOf>
							</owl:Class>
						</owl:someValuesFrom>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<iof-av:firstOrderLogicDefinition>ProcuringBusinessProcess(x) ↔ BusinessProcess(x) ∧ ∃b,∃s (BuyingBusinessProcess(b) ∧ SupplyingBusinessProcess(s) ∧ hasOccurrentPart(x,b) ∧ hasOccurrentPart(x,s))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>business Process that consists of buying and supplying products or services</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Procuring Business Process is a Business Process that has some Buying Business Process and Supplying Business Process as &apos;occurent parts&apos;</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">1. Activity of acquiring goods or services from suppliers.
2. process which creates, manages and fulfils contracts relating to the provision of goods, services and construction works or disposals, or any combination thereof [SOURCE: ISO 6707-2:2017, 3.5.18]</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;ProductProductionProcess">
		<rdfs:subClassOf rdf:resource="&iof-core;BusinessProcess"/>
		<rdfs:label xml:lang="en">product production process</rdfs:label>
		<rdfs:comment>1. A product production process is distinct from a maintenance process in that, in the latter case, the product exists both before and after the process occurs.

2. A product production process has several planned processes as parts (sub-processes), including at least one manufacturing or assembly process, and  optionally, may include other planned process types such as inspection, packaging, rework, and material-handling.  

3. Note that the various parts of a product production process, for example, inspection, testing, cannot be a product production process by themselves.

4. Some manufacturing processes will also be product production processes.</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&iof-core;BusinessProcess">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&bfo;BFO_0000117"/>
						<owl:someValuesFrom rdf:resource="&iof-core;ManufacturingProcess"/>
					</owl:Restriction>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&bfo;BFO_0000199"/>
						<owl:someValuesFrom>
							<owl:Class>
								<owl:intersectionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&bfo;BFO_0000008">
									</rdf:Description>
									<owl:Restriction>
										<owl:onProperty rdf:resource="&bfo;BFO_0000222"/>
										<owl:someValuesFrom>
											<owl:Class>
												<owl:intersectionOf rdf:parseType="Collection">
													<rdf:Description rdf:about="&bfo;BFO_0000203">
													</rdf:Description>
													<owl:Class>
														<owl:complementOf>
															<owl:Restriction>
																<owl:onProperty>
																	<rdf:Description>
																		<owl:inverseOf rdf:resource="&bfo;BFO_0000108"/>
																	</rdf:Description>
																</owl:onProperty>
																<owl:someValuesFrom rdf:resource="&iof-core;MaterialProduct"/>
															</owl:Restriction>
														</owl:complementOf>
													</owl:Class>
												</owl:intersectionOf>
											</owl:Class>
										</owl:someValuesFrom>
									</owl:Restriction>
								</owl:intersectionOf>
							</owl:Class>
						</owl:someValuesFrom>
					</owl:Restriction>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;hasOutput"/>
						<owl:someValuesFrom rdf:resource="&iof-core;MaterialProduct"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example>Making of an engine block as a product that consits of many processes such as manufacturing process, assembly process, inspection process etc.</skos:example>
		<iof-av:counterExample>1.Providing a service that does not deliver any tangible good
2.Acquiring unprocessed raw material (e.g., roll of aluminum) with intention to sell them or reselling. The Product existed before the initiation of the planned process.</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>ProductProductionProcess(x) ↔ BusinessProcess(x) ∧ ∃m (ManufacturingProcess(m) ∧ occurentPartOf(m,x)) ∧ ∃y ∃t ∃t′ (MaterialProduct(y) ∧ TemporalRegion(t) ∧ TemporalInstant(t&apos;) ∧ hasOutput(x, y) ∧  occupiesTemporalRegion(x, t) ∧ firstInstant(t′, t) ∧ ¬existsAt(y, t′))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>business process that consists of at least one manufacturing process through which raw materials and components are transformed or modified to create a material product</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Product Production Process is a Business Process that &apos;has occurrent part&apos;, some Planned Process, including at least one Manufacturing Process, and &apos;has output&apos; some Material Product and which did not &apos;exist at&apos; the beginning of the Product Production Process</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation xml:lang="en">1.  (i) Steps through which raw materials are transformed into a final product.
 (ii) Process in which] raw materials from primary industry are transformed into finished goods on a large scale.
(iii) Production of products for use or sale using labor and machines, tools, chemical or biological processing or formulation, and is the essence of secondary industry. [Wikipedia]</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;RawMaterial">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000040"/>
		<rdfs:label>raw material</rdfs:label>
		<rdfs:comment>this class is very general and it is intended to be used for grouping inputs to the product production process external to the bussiness organization but things like material artifacts should not be asserted as subclasses of this class</rdfs:comment>
		<owl:equivalentClass>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&iof-core;hasRole"/>
						<owl:someValuesFrom rdf:resource="&iof-core;RawMaterialRole"/>
					</owl:Restriction>
				</owl:intersectionOf>
			</owl:Class>
		</owl:equivalentClass>
		<skos:example>rolls of aluminum a manufacturer purchases to be consumed on its bottling lines to produce aluminum cans to package its product, crude oil that is converted into gasoline in a refining process; wheels an automobile manufacturer purchases to assemble into a car</skos:example>
		<iof-av:counterExample>oil used to power the refining process</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>RawMaterial(x) ↔ MaterialEntity(x) ∧  ∃r(RawMaterialRole(x) ∧ hasRole(x,r))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>material entity which has the raw material role</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Raw Material  is a &apos;material entity&apos; that &apos;has role&apos; some Raw Material Role</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>Material substance, part, or assembly that is purchased by a manufacturing business to be transformed or modified in some manufacturing process such that it becomes a part of the final product.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;RawMaterialRole">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000023"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;roleOf"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&bfo;BFO_0000040">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&bfo;BFO_0000056"/>
								<owl:someValuesFrom>
									<owl:Class>
										<owl:intersectionOf rdf:parseType="Collection">
											<rdf:Description rdf:about="&iof-core;BuyingBusinessProcess">
											</rdf:Description>
											<owl:Restriction>
												<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
												<owl:someValuesFrom>
													<owl:Class>
														<owl:intersectionOf rdf:parseType="Collection">
															<rdf:Description rdf:about="&iof-core;BusinessOrganization">
															</rdf:Description>
															<owl:Restriction>
																<owl:onProperty rdf:resource="&iof-core;hasRole"/>
																<owl:someValuesFrom rdf:resource="&iof-core;ManufacturerRole"/>
															</owl:Restriction>
														</owl:intersectionOf>
													</owl:Class>
												</owl:someValuesFrom>
											</owl:Restriction>
										</owl:intersectionOf>
									</owl:Class>
								</owl:someValuesFrom>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">raw material role</rdfs:label>
		<rdfs:comment>1. IOF considers as raw materials only material entities that are aquired from an external source
2. Raw materials are incorporated during the product production process into the final product.</rdfs:comment>
		<skos:example>rolls of aluminum a manufacturer purchases to be consumed to produce aluminum cans</skos:example>
		<iof-av:counterExample>a component produced by one division of a manufacturer and consumed in another</iof-av:counterExample>
		<iof-av:firstOrderLogicDefinition>RawMaterialRole(x) → Role(x) ∧ ∃a,∃b,∃r, ∃z(BuyingBusinessProcess(a)  ∧ BusinessOrganization(b) ∧ ManufacturerRole(r) ∧MaterialEntity(z) ∧ roleOf(r,b) ∧ hasParticipantAtSomeTime(a,b) ∧ hasParticipantAtSomeTime(a,z))</iof-av:firstOrderLogicDefinition>
		<iof-av:firstOrderLogicDefinition>Role(x) ∧ ∃p,∃a,∃b,∃y,∃r, ∃z(ProductProductionProcess(p) ∧ BuyingBusinessProcess(a)  ∧ BusinessOrganization(b) ∧ MaterialProduct(y) ∧ ManufacturerRole(r) ∧MaterialEntity(z) ∧ roleOf(r,b) ∧ hasParticipantAtSomeTime(a,b) ∧ hasParticipantAtSomeTime(a,z) ∧ isInputOf(z,p) ∧ hasOutput(p,y) ∧ continuantPartOfAtAllTimes(z,y) ∧ roleOf(x,z)) → RawMaterialRole(x)</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>role held by a material entity when it is aquired by a business organization with the plan to be transformed or modified in a product production process</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>x is a &apos;role&apos; that is the &apos;role of&apos; some &apos;material entity&apos; m when &apos;participates at some time&apos; some Buying Business Process b in which a Business Organization o that &apos;has role&apos; a Manufacturer Role r &apos;participates in at some time&apos; and is an &apos;input of&apos; some Product Production Process p where it becomes a &apos;continuant part of at all times&apos; some Material Product y which is the &apos;output of&apos; p implies x is a Raw Material Role</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>x is a Raw Material role implies x is a &apos;role&apos; that is the &apos;role of&apos; some &apos;material entity&apos; m when m &apos;participates in at some time&apos; some Buying Business Process b in which some Business Organization o that &apos;has role&apos; a Manufacturer role r &apos;participates in at some time&apos;</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>[APICS] material which is purchased and that is converted or consumed via a manufacturing process into components and products</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;RequirementSpecification">
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;isAbout"/>
				<owl:someValuesFrom rdf:resource="&iof-core;ObjectiveSpecification"/>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label>requirement specification</rdfs:label>
		<rdfs:comment>This can be context specific also. For example an UML class diagram may be a requirement specification for a data exchange specification or it can be a design specification for software code</rdfs:comment>
		<skos:example>UML use case document, competency questions, high level activity diagram</skos:example>
		<iof-av:adaptedFrom>https://demo-irm-dnvgl.northeurope.cloudapp.azure.com/ontology/requirement-ontology/core/A01A</iof-av:adaptedFrom>
		<iof-av:firstOrderLogicDefinition>InformationContentEntity(x)  ∧ ∃y (Entity(y) ∧ satisfiedBy(x,y)) → RequirementSpecification(x)</iof-av:firstOrderLogicDefinition>
		<iof-av:firstOrderLogicDefinition>RequirementSpecification(x) → InformationContentEntity(x)  ∧ ∃y (ObjectiveSpecification(y) ∧ isAbout(x,y))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>information content entity that prescribes a set of requirements</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Requirement Specification x implies x is an Information Content Entity that &apos;is about&apos; some Objective Specification o</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>r is an Information Content Entity and there is an entity e that &apos;satisfies&apos; e implies r is a Requirement Specification</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;SellingBusinessProcess">
		<rdfs:subClassOf rdf:resource="&iof-core;BusinessProcess"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&bfo;BFO_0000040">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&iof-core;hasRole"/>
								<owl:someValuesFrom rdf:resource="&iof-core;SupplierRole"/>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:unionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;CommercialServiceAgreement">
							</rdf:Description>
							<rdf:Description rdf:about="&iof-core;MaterialProduct">
							</rdf:Description>
						</owl:unionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label>offering for sale business process</rdfs:label>
		<rdfs:comment>It should be noted that we consciously exclude the person-to-person transactions, but person-to-business is not excluded.</rdfs:comment>
		<skos:example>Good Year sells tires to GM, Boeing sells 737 and 10 Service Agreement to United Airlines.</skos:example>
		<iof-av:elucidation>business process wherein product or commercial service is offered by an agent (seller) for another agent (buyer) to acquire ownership via a financial instrument</iof-av:elucidation>
		<iof-av:firstOrderLogicDefinition>OfferingForSaleBusinessProcess(x) → BusinessProcess(x) ∧ ∃y,∃z.∃r ((MaterialProduct(y) ∨ CommercialServiceAgreement(y)) ∧ MaterialEntity(z) ∧ SupplierRole(r)  ∧ hasRole(z,r) ∧ hasParticipantAtSomeTIme(x,y)  ∧ hasParticipantAtSomeTime(x,z))</iof-av:firstOrderLogicDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Offering for Sale Business Process x implies x is a Business Process that &apos;has participant at some time&apos; some &apos;material entity&apos; m that &apos;has role&apos; some Supplier Role r and x &apos;has participant at some time&apos; some Material Product or Commercial Service Agreement y</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;State">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000015"/>
		<rdfs:label>state</rdfs:label>
		<rdfs:comment>1.In the elucidation &apos;attribute&apos; is not intended as a technical term. It comprehends specifically dependent continuants and locations.
2. the current class is not intended to be used for modeling states of processes. They will be considered in a future version of the core.</rdfs:comment>
		<skos:altLabel>stasis</skos:altLabel>
		<skos:example>the lightswitch in the off state from 9 PM to 8 AM; the machine in fail state from 4 PM to 5 PM; perfusion bioreactor was run in steady state for two days, a truck is in a stop state because its position has been unchanged</skos:example>
		<iof-av:adaptedFrom>http://www.ontologyrepository.com/CommonCoreOntologies/Mid/EventOntology</iof-av:adaptedFrom>
		<iof-av:elucidation>process in which one or more of the attributes of a participant in the process remain constant or within specified ranges</iof-av:elucidation>
		<iof-av:subjectMatterExpertExplanation>the particular condition that someone or something is in at a specific time [https://www.lexico.com/en/definition/state]</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;SupplierRole">
		<rdfs:subClassOf rdf:resource="&iof-core;AgentRole"/>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;roleOf"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<owl:Class>
								<owl:unionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&iof-core;BusinessOrganization">
									</rdf:Description>
									<rdf:Description rdf:about="&iof-core;EngineeredSystem">
									</rdf:Description>
									<rdf:Description rdf:about="&iof-core;Person">
									</rdf:Description>
								</owl:unionOf>
							</owl:Class>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&bfo;BFO_0000056"/>
								<owl:someValuesFrom>
									<owl:Class>
										<owl:unionOf rdf:parseType="Collection">
											<rdf:Description rdf:about="&iof-core;SellingBusinessProcess">
											</rdf:Description>
											<rdf:Description rdf:about="&iof-core;SupplyingBusinessProcess">
											</rdf:Description>
										</owl:unionOf>
									</owl:Class>
								</owl:someValuesFrom>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label xml:lang="en">supplier role</rdfs:label>
		<skos:example>logistics service provider; vending machine; the material handling department (which manages the raw material and finished goods in company warehouses, and provides material handling services to manufacturing and other departments within its factories)</skos:example>
		<iof-av:firstOrderLogicDefinition>SupplierRole(x) → Role(x) ∧ ∃y,∃p ((BusinessOrganization(y) ∨ Person(y) ∨ EngineeredSystem(y)) ∧ ((SupplyingBusinessProcess(p)  ∨ OfferingForSaleBusinessProcess(p)) ∧ participatesInAtSomeTime(y,p) ∧ roleOf(x, y))</iof-av:firstOrderLogicDefinition>
		<iof-av:naturalLanguageDefinition>role held by a person, business organization or an automated system when it offers to sell or provide products or services</iof-av:naturalLanguageDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Supplier Role x implies x is an Agent Role that is the &apos;role of&apos; an Agent (person, organization or automated system acting on behalf of one) a when it &apos;participates in at some time&apos; some Supplying Business Process or Offering for Sale Business Process s</iof-av:semiFormalNaturalLanguageDefinition>
		<iof-av:subjectMatterExpertExplanation>1. [Oxford Languages]: A person, organization or automated system that provides something needed such as a product or service.

2. [APICS]: (a) A provider of goods or services. (b) A seller with whom a buyer does business (as opposed to vendor, which is a generic term referring to all
sellers in the marketplace).</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;SupplyingBusinessProcess">
		<rdfs:subClassOf rdf:resource="&iof-core;BusinessProcess"/>
		<rdfs:subClassOf>
			<owl:Class>
				<owl:unionOf rdf:parseType="Collection">
					<owl:Restriction>
						<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
						<owl:someValuesFrom rdf:resource="&iof-core;MaterialProduct"/>
					</owl:Restriction>
					<owl:Restriction>
						<owl:onProperty rdf:resource="&bfo;BFO_0000132"/>
						<owl:someValuesFrom rdf:resource="&iof-core;CommercialService"/>
					</owl:Restriction>
				</owl:unionOf>
			</owl:Class>
		</rdfs:subClassOf>
		<rdfs:subClassOf>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&bfo;BFO_0000040">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&iof-core;hasRole"/>
								<owl:someValuesFrom rdf:resource="&iof-core;SupplierRole"/>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</rdfs:subClassOf>
		<rdfs:label>supplying business process</rdfs:label>
		<rdfs:comment>1. To supply a product means to deliver the product to another agent.
2.To supply a service means to perform a process (e.g. commercial service) for another agent, typically involving a service agreement
3.It should be noted that we consciously exclude the person-to-person transactions, but person-to-business is not excluded.</rdfs:comment>
		<skos:example>A BMW dealer supplies  a car to the Customer, A US importer of steel from China supplies the steel to a US manufacturer, A company (supplier) supplied (ship directly) a product to a buyer who bought the product on Amazon (seller)</skos:example>
		<iof-av:counterExample>A BMW dealer supplies a car to a Customer in the US, but the BMW Manufacturer in Germany does not supply the car to the Customer. The BMW Manufacturer supplies the car to the BMW dealer.</iof-av:counterExample>
		<iof-av:elucidation>business process wherein product or service is supplied</iof-av:elucidation>
		<iof-av:firstOrderLogicDefinition>SupplyingBusinessProcess(x) → BusinessProcess(x) ∧ ∃y,∃r(MaterialEntity(y) ∧ SupplierRole(r) ∧ hasRole(y,r) ∧ hasParticipantAtSomeTime(x,y)) ∧ (∃p(MaterialProduct(p) ∧ hasParticipantAtSomeTime(x,p)) ∨ ∃c(CommercialService(c) ∧ occurrentPartOf(x,c)))</iof-av:firstOrderLogicDefinition>
		<iof-av:semiFormalNaturalLanguageDefinition>Supplying Business Process x implies x is a Business Process that &apos;has participant at some time&apos; some &apos;material entity&apos; m that &apos;has role&apos; some Supplier Role r and x &apos;has participant at some time&apos; some Material Product y or is &apos;occurent part of&apos; some Commercial Service c</iof-av:semiFormalNaturalLanguageDefinition>
	</owl:Class>
	
	<owl:Class rdf:about="&iof-core;System">
		<rdfs:subClassOf rdf:resource="&bfo;BFO_0000027"/>
		<rdfs:label xml:lang="en">system</rdfs:label>
		<rdfs:comment>1. In almost all cases elements are objects, so that the system itself is a BFO: object aggregate

2. Although System as an object aggregate is constrained by BFO to have only Material Entity (or Site or Continuant Fiat Boundary) as continuant parts, system of software and hardware (also known as cyberphysical system) can still be modeled. The approach is that there is a hardware (Material Entity) that software (as Information Content Entity) generically depends on for the software to indirectly be part of a system.</rdfs:comment>
		<skos:example>solar system, digestive system, forest ecosystem, hydraulic system, subway system, social system, technical system, natural system</skos:example>
		<iof-av:elucidation>object aggregate that has continuant part two or more elements that interact with each other</iof-av:elucidation>
		<iof-av:subjectMatterExpertExplanation>1. A set of things working together as parts of a mechanism or an interconnecting network. [Oxford Languages]
2. Collection of elements in interaction. Definition applies to natural, social or technical systems.</iof-av:subjectMatterExpertExplanation>
	</owl:Class>
	
	<owl:ObjectProperty rdf:about="&iof-core;achievesAtSomeTIme">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000059"/>
		<rdfs:label xml:lang="en">achieves at some time</rdfs:label>
		<rdfs:domain rdf:resource="&iof-core;PlannedProcess"/>
		<rdfs:range rdf:resource="&iof-core;InformationContentEntity"/>
		<owl:inverseOf rdf:resource="&iof-core;isAchievedByAtSomeTime"/>
		<skos:example>The staffing and ramping up of production to 2 shifts per work day acheives the company plan of satisfying a surge in demand for its products.</skos:example>
		<iof-av:elucidation>x achieves y holds when x is a Planned Process and y is an Information Content Entity that &apos;prescribes&apos; x and  x &apos;concretizes&apos; y or a &apos;continuant part of&apos; y, at some time t

FOL: achieves(x,y) → PlannedProcess(x) ∧ InformationContentEntity(y) ∧ (concretizesAtSomeTime(x,y) ∨ ∃z(continuantPartOf(z,y) ∧ InformationContentEntity(z)  ∧ concretizesAtSomeTime(x,z))</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;actsOnBehalfOfAtSomeTime">
		<rdfs:label>acts on behalf of at some time</rdfs:label>
		<rdfs:domain>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Class>
						<owl:complementOf rdf:resource="&bfo;BFO_0000024"/>
					</owl:Class>
				</owl:intersectionOf>
			</owl:Class>
		</rdfs:domain>
		<rdfs:range>
			<owl:Class>
				<owl:unionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&iof-core;EngineeredSystem">
					</rdf:Description>
					<rdf:Description rdf:about="&iof-core;GroupOfAgents">
					</rdf:Description>
					<rdf:Description rdf:about="&iof-core;Person">
					</rdf:Description>
				</owl:unionOf>
			</owl:Class>
		</rdfs:range>
		<skos:example>An agent acts on behalf of a business organization. A laywer acts on behalf of a person.</skos:example>
		<iof-av:elucidation>x acts on behalf of at some time y holds when x is a &apos;material entity&apos; (that is not a &apos;fiat object part&apos;) and y is some Person or Group of Agents or Engineered System and at some time t, there exists a Planned Process p such that x &apos;participates in&apos; p and p &apos;achieves at some time&apos; some Directive Information Content Entity d that &apos;generically depends on at some time&apos; y

FOL:  actsOnBehalfOfAtSomeTime(x,y) → (MaterialEntity(x) ∧ ¬(FiatObjectPart(x)) ∧ (Person(y) ∨ GroupOfAgents(y) ∨ EngineeredSystem(x)) ∧ ∃p,∃d (PlannedProcess(p) ∧ DirectiveInformationContentEntity(d) ∧ participatesInAtSomeTime(x,p) ∧achievesAtSomeTime(p,d) ∧ genericallyDependsOnAtSomeTime(d,y))</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;componentPartOfAtAllTimes">
		<rdf:type rdf:resource="&owl;TransitiveProperty"/>
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000137"/>
		<rdfs:subPropertyOf rdf:resource="&iof-core;componentPartOfAtSomeTime"/>
		<rdfs:label>component part of at all times</rdfs:label>
		<rdfs:domain>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Class>
						<owl:complementOf rdf:resource="&bfo;BFO_0000024"/>
					</owl:Class>
				</owl:intersectionOf>
			</owl:Class>
		</rdfs:domain>
		<rdfs:range>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Class>
						<owl:complementOf rdf:resource="&bfo;BFO_0000024"/>
					</owl:Class>
				</owl:intersectionOf>
			</owl:Class>
		</rdfs:range>
		<skos:example>transmission assembly is a component part of a car; engine control ;sparger is a component part of a bioreactor</skos:example>
		<iof-av:elucidation>x component part of at all times y holds when x is a &apos;material entity&apos; that is not a &apos;fiat object part&apos; and y is a &apos;material entity&apos; that is not a &apos;fiat object part&apos; and x is &apos;proper continuant part of at all times&apos; y

FOL: componentPartOfAtAllTimes(x,y) → (MaterialEntity(x) ∧ ¬(FiatObjectPart(x))) ∧ (MaterialEntity(y) ∧ ¬(FiatObjectPart(y)))  ∧ properContinuantPartOfAtAllTimes(x,y)</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;componentPartOfAtSomeTime">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000175"/>
		<rdfs:label>component part of at some time</rdfs:label>
		<rdfs:domain>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Class>
						<owl:complementOf rdf:resource="&bfo;BFO_0000024"/>
					</owl:Class>
				</owl:intersectionOf>
			</owl:Class>
		</rdfs:domain>
		<rdfs:range>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Class>
						<owl:complementOf rdf:resource="&bfo;BFO_0000024"/>
					</owl:Class>
				</owl:intersectionOf>
			</owl:Class>
		</rdfs:range>
		<owl:inverseOf rdf:resource="&iof-core;hasComponentPartAtSomeTime"/>
		<iof-av:elucidation>x component part of at some time y holds when x is a &apos;material entity&apos; that is not a &apos;fiat object part&apos; and y is a &apos;material entity&apos; that is not a &apos;fiat object part&apos; and x is &apos;proper continuant part of at some time&apos; y

FOL: componentPartOfAtSomeTime(x,y) → (MaterialEntity(x) ∧ ¬(FiatObjectPart(x))) ∧ (MaterialEntity(y) ∧ ¬(FiatObjectPart(y)))  ∧ properContinuantPartOfAtSomeTime(x,y)</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;describedBy">
		<rdfs:subPropertyOf rdf:resource="&iof-core;isSubjectOf"/>
		<rdfs:label xml:lang="en">described by</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000001"/>
		<rdfs:range rdf:resource="&iof-core;InformationContentEntity"/>
		<owl:inverseOf rdf:resource="&iof-core;describes"/>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">x described by y iff y is an instance of Information Content Entity, and x is an instance of &apos;entity&apos;, such that y is about the characteristics by which y can be recognized or visualized.</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;describes">
		<rdfs:subPropertyOf rdf:resource="&iof-core;isAbout"/>
		<rdfs:label xml:lang="en">describes</rdfs:label>
		<rdfs:comment xml:lang="en">It is possible that this relation should be a functional property, that is for all x, y, z if x describes y and x describes z then y = z. For example, if a financial report x describes the quarterly results of a company y and that same financial report describes the quarterly results of a company z, then it should be inferred that companies y and z are the same. We refrained from classifying the relation as a functional property on the concern that descriptions are multifaceted and so consequently it may be that the same report would contain descriptions of multiple entities.</rdfs:comment>
		<rdfs:domain rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000001"/>
		<skos:example>the content of a newspaper article describes some current event; the content of a visitor&apos;s log describes some facility visit; the content of an accident report describes some accident</skos:example>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">x describes y iff x is an instance of Information Content Entity, and y is an instance of &apos;entity&apos;, such that x &apos;is about&apos; the characteristics by which y can be recognized or visualized</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;designatedBy">
		<rdf:type rdf:resource="&owl;InverseFunctionalProperty"/>
		<rdfs:subPropertyOf rdf:resource="&iof-core;isSubjectOf"/>
		<rdfs:label xml:lang="en">designated by</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000001"/>
		<rdfs:range rdf:resource="&iof-core;InformationContentEntity"/>
		<owl:inverseOf rdf:resource="&iof-core;designates"/>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">x designated by y iff y is an instance of Information Content Entity and x is an instance of &apos;entity&apos;, such that given some context, y uniquely distinguishes x from other entities.</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;designates">
		<rdf:type rdf:resource="&owl;FunctionalProperty"/>
		<rdfs:subPropertyOf rdf:resource="&iof-core;isAbout"/>
		<rdfs:label xml:lang="en">designates</rdfs:label>
		<rdfs:domain rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000001"/>
		<skos:example>a person&apos;s name designates that person; a URL designates the location of a Web Page on the internet; a vehicle identification number designates some vehicle</skos:example>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">x designates y iff x is an instance of an Information Content &apos;entity&apos;, and y is an instance of an Entity, such that given some context, x uniquely distinguishes y from other entities.</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;dispositionOf">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000197"/>
		<rdfs:label xml:lang="en">disposition of</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000016"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000004"/>
		<owl:inverseOf rdf:resource="&iof-core;hasDisposition"/>
		<iof-av:adaptedFrom>http://purl.obolibrary.org/obo/RO_0000092</iof-av:adaptedFrom>
		<iof-av:elucidation>inverse of has disposition</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;functionOf">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000197"/>
		<rdfs:label xml:lang="en">function of</rdfs:label>
		<rdfs:comment xml:lang="en">A function inheres in its bearer at all times for which the function exists, however the function need not be realized at all the times that the function exists.</rdfs:comment>
		<rdfs:domain rdf:resource="&bfo;BFO_0000034"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000004"/>
		<owl:inverseOf rdf:resource="&iof-core;hasFunction"/>
		<skos:example xml:lang="en">this catalysis function is a function of this enzyme</skos:example>
		<iof-av:adaptedFrom>http://purl.obolibrary.org/obo/RO_0000079</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">a relation between a function and an independent continuant (the bearer), in which the function specifically depends on the bearer for its existence</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;hasComponentPartAtAllTimes">
		<rdf:type rdf:resource="&owl;TransitiveProperty"/>
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000111"/>
		<rdfs:subPropertyOf rdf:resource="&iof-core;hasComponentPartAtSomeTime"/>
		<rdfs:label>has component part at all times</rdfs:label>
		<rdfs:domain>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Class>
						<owl:complementOf rdf:resource="&bfo;BFO_0000024"/>
					</owl:Class>
				</owl:intersectionOf>
			</owl:Class>
		</rdfs:domain>
		<rdfs:range>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Class>
						<owl:complementOf rdf:resource="&bfo;BFO_0000024"/>
					</owl:Class>
				</owl:intersectionOf>
			</owl:Class>
		</rdfs:range>
		<iof-av:elucidation>x has component part at all times y holds when x is a &apos;material entity&apos; that is not a &apos;fiat object part&apos; and y is a &apos;material entity&apos; that is not a &apos;fiat object part&apos; and x is &apos;has proper continuant part at all times&apos; y

FOL: hasComponentPartAtAllTimes(x,y) → (MaterialEntity(x) ∧ ¬(FiatObjectPart(x))) ∧ (MaterialEntity(y) ∧ ¬(FiatObjectPart(y)))  ∧ hasProperContinuantPartAtAllTimes(x,y)</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;hasComponentPartAtSomeTime">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000174"/>
		<rdfs:label>has component part at some time</rdfs:label>
		<rdfs:domain>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Class>
						<owl:complementOf rdf:resource="&bfo;BFO_0000024"/>
					</owl:Class>
				</owl:intersectionOf>
			</owl:Class>
		</rdfs:domain>
		<rdfs:range>
			<owl:Class>
				<owl:intersectionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000040">
					</rdf:Description>
					<owl:Class>
						<owl:complementOf rdf:resource="&bfo;BFO_0000024"/>
					</owl:Class>
				</owl:intersectionOf>
			</owl:Class>
		</rdfs:range>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;hasDisposition">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000196"/>
		<rdfs:label xml:lang="en">has disposition</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000004"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000016"/>
		<iof-av:adaptedFrom>http://purl.obolibrary.org/obo/RO_0000091</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">a relation between an independent continuant (the bearer) and a disposition, in which the disposition specifically depends on the bearer for its existence</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;hasFunction">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000196"/>
		<rdfs:label xml:lang="en">has function</rdfs:label>
		<rdfs:comment xml:lang="en">A bearer can have many functions, and its functions can exist for different periods of time, but none of its functions can exist when the bearer does not exist. A function need not be realized at all the times that the function exists.</rdfs:comment>
		<rdfs:domain rdf:resource="&bfo;BFO_0000004"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000034"/>
		<skos:example xml:lang="en">this enzyme has function this catalysis function (more colloquially: this enzyme has this catalysis function)</skos:example>
		<iof-av:adaptedFrom>http://purl.obolibrary.org/obo/RO_0000085</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">a relation between an independent continuant (the bearer) and a function, in which the function specifically depends on the bearer for its existence</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;hasInput">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000057"/>
		<rdfs:label xml:lang="en">has input</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000015"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000002"/>
		<owl:inverseOf rdf:resource="&iof-core;isInputOf"/>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/ExtendedRelationOntology</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">y has input x iff x is an instance of Continuant and y is an instance of Process, such that the presence of x at the begining of y is a necessary condition for the start of y.</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;hasOutput">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000057"/>
		<rdfs:label xml:lang="en">has output</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000015"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000002"/>
		<owl:inverseOf rdf:resource="&iof-core;isOutputOf"/>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/ExtendedRelationOntology</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">y has output x iff x is an instance of Continuant and y is an instance of Process, such that the presence of x at the end of y is a necessary condition for the completion of y.</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;hasProcessCharacteristic">
		<rdfs:subPropertyOf rdf:resource="&owl;topObjectProperty"/>
		<rdfs:label>has process characteristic</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000015"/>
		<rdfs:range rdf:resource="&iof-core;ProcessCharacteristic"/>
		<owl:inverseOf rdf:resource="&iof-core;processCharacteristicOf"/>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;hasQuality">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000196"/>
		<rdfs:label xml:lang="en">has quality</rdfs:label>
		<rdfs:comment xml:lang="en">A bearer can have many qualities, and its qualities can exist for different periods of time, but none of its qualities can exist when the bearer does not exist.</rdfs:comment>
		<rdfs:range rdf:resource="&bfo;BFO_0000019"/>
		<owl:inverseOf rdf:resource="&iof-core;qualityOf"/>
		<skos:example xml:lang="en">this apple has quality this red color</skos:example>
		<iof-av:adaptedFrom>http://purl.obolibrary.org/obo/RO_0000086</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">a relation between an independent continuant (the bearer) and a quality, in which the quality specifically depends on the bearer for its existence</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;hasRole">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000196"/>
		<rdfs:label xml:lang="en">has role</rdfs:label>
		<rdfs:comment xml:lang="en">A bearer can have many roles, and its roles can exist for different periods of time, but none of its roles can exist when the bearer does not exist. A role need not be realized at all the times that the role exists.</rdfs:comment>
		<rdfs:domain rdf:resource="&bfo;BFO_0000004"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000023"/>
		<owl:inverseOf rdf:resource="&iof-core;roleOf"/>
		<skos:example xml:lang="en">this person has role this investigator role (more colloquially: this person has this role of investigator)</skos:example>
		<iof-av:adaptedFrom>http://purl.obolibrary.org/obo/RO_0000087</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">a relation between an independent continuant (the bearer) and a role, in which the role specifically depends on the bearer for its existence</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;hasSpecifiedOutput">
		<rdfs:subPropertyOf rdf:resource="&iof-core;hasOutput"/>
		<rdfs:label>has specified output</rdfs:label>
		<rdfs:comment>this relation was added to specifically model the outputs that are not byproducts/wasteproducts</rdfs:comment>
		<rdfs:domain rdf:resource="&iof-core;PlannedProcess"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000002"/>
		<owl:inverseOf rdf:resource="&iof-core;isSpecifiedOutputOf"/>
		<iof-av:adaptedFrom>http://purl.obolibrary.org/obo/IAO_0000122</iof-av:adaptedFrom>
		<iof-av:elucidation>x has specified output y when x is a planned process and y is a continuant that participates in x and the presence of y at the end of x is prescribed by some objective specification o which x achieves


FOL: hasSpecifiedOutput(x,y) → PlannedProcess(x) ∧ Continuant(y) ∧ ∃o (ObjectiveSpecification(o) ∧ prescribes(o,y) ∧ achieves(x,o) ∧ hasOutput(x,y))</iof-av:elucidation>
		<iof-av:synonym>has intended output</iof-av:synonym>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;isAbout">
		<rdfs:label xml:lang="en">is about</rdfs:label>
		<rdfs:domain rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000001"/>
		<owl:inverseOf rdf:resource="&iof-core;isSubjectOf"/>
		<iof-av:adaptedFrom>IAO:http://purl.obolibrary.org/obo/IAO_0000136 and CCO:http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">primitive, generic relationship between an Information Content Entity and some &apos;entity&apos;</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;isAchievedByAtSomeTime">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000058"/>
		<rdfs:label>is achieved by at some time</rdfs:label>
		<rdfs:domain rdf:resource="&iof-core;DirectiveInformationContentEntity"/>
		<rdfs:range rdf:resource="&iof-core;PlannedProcess"/>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;isAvailableToAtSomeTime">
		<rdfs:label>is available to at some time</rdfs:label>
		<rdfs:comment>this definition of &apos;is available to&apos; is not the same as the state of availability e.g a machine is idle hence it is in the available state</rdfs:comment>
		<rdfs:domain>
			<owl:Class>
				<owl:unionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&bfo;BFO_0000031">
					</rdf:Description>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&bfo;BFO_0000004">
							</rdf:Description>
							<owl:Class>
								<owl:complementOf rdf:resource="&bfo;BFO_0000006"/>
							</owl:Class>
						</owl:intersectionOf>
					</owl:Class>
				</owl:unionOf>
			</owl:Class>
		</rdfs:domain>
		<rdfs:range>
			<owl:Class>
				<owl:unionOf rdf:parseType="Collection">
					<rdf:Description rdf:about="&iof-core;EngineeredSystem">
					</rdf:Description>
					<rdf:Description rdf:about="&iof-core;GroupOfAgents">
					</rdf:Description>
					<rdf:Description rdf:about="&iof-core;Person">
					</rdf:Description>
				</owl:unionOf>
			</owl:Class>
		</rdfs:range>
		<skos:example>a plan specification (resource) is available to an operator to use in a machining process, a roll of aluminum (resource) is avaiable to an agent to use in a forming process, a milling workstation (resource) is avaialable to a manufacturing factory to produce some parts</skos:example>
		<iof-av:elucidation>independent continuant x is available to at some time agent y means y is a Person or Group of Agents or Engineered system and y is the &apos;carrier of at some time&apos; some Directive Information Content Entity i which is &apos;achieved by at some time&apos; some Planned Process p whereby x  has some &apos;disposition&apos; d that p &apos;realizes&apos; or x merely &apos;participates in&apos; p 

generically dependent continuant x is available to at some time y means y is a Person or Group of Agents or Engineered system and y is the &apos;carrier of at some time&apos; some Directive Information Content Entity i which is &apos;achieved by&apos; at some time some Planned Process p whereby x  is &apos;concretized by&apos;  p or x &apos;prescribes&apos; p 

FOL:  isAvailableToAtSomeTime (x, y) → ((IndependentContinuant(x) ∧¬SpatialRegion(x)) ∨ GenericallyDependentContinuant(x))  ∧ (Person(y) ∨ GroupOfAgents(y) ∨ EngineeredSystem(y))  ∧ 
∃p,∃i (PlannedProcess(p) ∧ DirectiveInformationContentEntity(i) ∧  participatesInAtSomeTime(y, p) ∧ isAchievedByAtSomeTime(i,p) ∧ isCarrierOfAtSomeTime(y,i) ∧ 
(participatesInAtSomeTime(x, p) ∨ ∃d (Disposition(d) ∧ bearerOf(x, d) ∧ realizes(p, d)) ∨  
concretizesAtSomeTime(p,x) ∨ prescribes(x,p)))</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;isInputOf">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000056"/>
		<rdfs:label xml:lang="en">is input of</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000002"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000015"/>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/ExtendedRelationOntology</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">x is input of y iff x is an instance of Continuant and y is an instance of Process, such that the presence of x at the begining of y is a necessary condition for the start of y.</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;isOutputOf">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000056"/>
		<rdfs:label xml:lang="en">is output of</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000002"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000015"/>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/ExtendedRelationOntology</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">x is output of y iff x is an instance of Continuant and y is an instance of Process, such that the presence of x at the end of y is a necessary condition for the completion of y.</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;isSpecifiedOutputOf">
		<rdfs:subPropertyOf rdf:resource="&iof-core;isOutputOf"/>
		<rdfs:label>is specified output of</rdfs:label>
		<iof-av:synonym>is intended output of</iof-av:synonym>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;isSubjectOf">
		<rdfs:label xml:lang="en">is subject of</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000001"/>
		<rdfs:range rdf:resource="&iof-core;InformationContentEntity"/>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">A primitive relationship between an instance of an Entity and an instance of an Information Content Entity.</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;observedByAtSomeTime">
		<rdfs:subPropertyOf rdf:resource="&owl;topObjectProperty"/>
		<rdfs:label>observed by at some time</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000001"/>
		<rdfs:range rdf:resource="&iof-core;Agent"/>
		<owl:inverseOf rdf:resource="&iof-core;observesAtSomeTime"/>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;observesAtSomeTime">
		<rdfs:subPropertyOf rdf:resource="&owl;topObjectProperty"/>
		<rdfs:label>observes at some time</rdfs:label>
		<rdfs:comment>this property was not put under participates in at some time because the target of observation can be continuant or an occurent and in the case of an occurent an agent that observes the occurent might not participate in that occurent</rdfs:comment>
		<rdfs:comment>we are not sure if monitoring should be an alternate label or a subproperty of this</rdfs:comment>
		<rdfs:comment>we are not sure if we should constrain the domain of observes to occurent, because when we observe something we observe some changes</rdfs:comment>
		<rdfs:domain rdf:resource="&iof-core;Agent"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000001"/>
		<skos:example>a scientist observing a chemical reaction in an experiment recognizes an explosion, an operator observes a machining process recognizes a defect in a part, a doctor observes a group of COVID patients and recognizes that majority of them have difficulty breathing</skos:example>
		<iof-av:elucidation>b observes p at some time t holds when there is a &apos;process&apos; o that an agent b &apos;participates in&apos; at t1 and &apos;recognizes at some time&apos; t2 an &apos;entity&apos; e that is an attribute of p or an entity related to p</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;prescribedBy">
		<rdfs:subPropertyOf rdf:resource="&iof-core;isSubjectOf"/>
		<rdfs:label xml:lang="en">prescribed by</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000001"/>
		<rdfs:range rdf:resource="&iof-core;InformationContentEntity"/>
		<owl:inverseOf rdf:resource="&iof-core;prescribes"/>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">x prescribed by y iff y is an instance of Information Content Entity and x is an instance of &apos;entity&apos;, such that y serves as a rule or guide for x if x is an &apos;occurrent&apos;, or y serves as a model for x if x is a &apos;continuant&apos;.</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;prescribes">
		<rdfs:subPropertyOf rdf:resource="&iof-core;isAbout"/>
		<rdfs:label xml:lang="en">prescribes</rdfs:label>
		<rdfs:domain rdf:resource="&iof-core;InformationContentEntity"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000001"/>
		<skos:example>a blueprint serves as a model of some Artifact or Facility; a professional code of conduct serves as a set of rules to be followed while acting in a role within that profession; an Operations Plan serves as a guide for the tasks that need to be performed to achieve the Objectives of the Operation</skos:example>
		<iof-av:adaptedFrom rdf:datatype="&xsd;anyURI">http://www.ontologyrepository.com/CommonCoreOntologies/Mid/InformationEntityOntology</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">x prescribes y iff x is an instance of Information Content Entity and y is an instance of &apos;entity&apos;, such that x serves as a rule or guide for y if y an &apos;occurrent&apos;, or x serves as a model for y if y is a &apos;continuant&apos;</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;processCharacteristicOf">
		<rdfs:subPropertyOf rdf:resource="&owl;topObjectProperty"/>
		<rdfs:label>process characteristic of</rdfs:label>
		<rdfs:domain rdf:resource="&iof-core;ProcessCharacteristic"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000015"/>
		<iof-av:elucidation>relation between a characteristic and the process it is a characteristic of</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;qualityOf">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000197"/>
		<rdfs:label xml:lang="en">quality of</rdfs:label>
		<rdfs:comment xml:lang="en">A quality inheres in its bearer at all times for which the quality exists.</rdfs:comment>
		<rdfs:domain rdf:resource="&bfo;BFO_0000019"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000004"/>
		<skos:example xml:lang="en">this red color is a quality of this apple</skos:example>
		<iof-av:adaptedFrom>http://purl.obolibrary.org/obo/RO_0000080</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">a relation between a quality and an independent continuant (the bearer), in which the quality specifically depends on the bearer for its existence</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;recognizedByAtSomeTime">
		<rdfs:label>recognized by at some time</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000001"/>
		<rdfs:range rdf:resource="&iof-core;Agent"/>
		<owl:inverseOf rdf:resource="&iof-core;recognizesAtSomeTime"/>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;recognizesAtSomeTime">
		<rdfs:subPropertyOf rdf:resource="&owl;topObjectProperty"/>
		<rdfs:label>recognizes at some time</rdfs:label>
		<rdfs:comment>this property was not put under participates in at some time because the target of recognition can be continuant or an occurent and in the case of an occurent an agent that recognizes the occurent might not participate in that occurent</rdfs:comment>
		<rdfs:domain rdf:resource="&iof-core;Agent"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000001"/>
		<skos:example>operator recognizes a failure event that results in information about the event such as the time of occurrence and the description about the failure,  a quality control engineer recognizes a defect on a part that results in information about the defect such as the nature of the defect and the cause of the defect</skos:example>
		<iof-av:elucidation>b recognizes p at some time t when there is a &apos;process&apos; r that an agent b &apos;participates in&apos; at t1 and r &apos;has output&apos; some Descriptive Information Content Entity d at t2 &gt;= t1 &apos;about&apos; &apos;entity&apos; p

FOL: recognizes(b,p) → Agent(b) ∧ Entity(p) ∧ ∃r,∃d (Process(r) ∧ DescriptiveInformationContentEntity(d) ∧ participatesInAtSomeTime(b,r) ∧ hasOutput(r,d) ∧ isAbout(d,p))</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;roleOf">
		<rdfs:subPropertyOf rdf:resource="&bfo;BFO_0000197"/>
		<rdfs:label xml:lang="en">role of</rdfs:label>
		<rdfs:comment xml:lang="en">A role inheres in its bearer at all times for which the role exists, however the role need not be realized at all the times that the role exists.</rdfs:comment>
		<rdfs:domain rdf:resource="&bfo;BFO_0000023"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000004"/>
		<skos:example xml:lang="en">this investigator role is a role of this person</skos:example>
		<iof-av:adaptedFrom>http://purl.obolibrary.org/obo/RO_0000081</iof-av:adaptedFrom>
		<iof-av:elucidation xml:lang="en">a relation between a role and an independent continuant (the bearer), in which the role specifically depends on the bearer for its existence</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;satisfiedBy">
		<rdfs:subPropertyOf rdf:resource="&owl;topObjectProperty"/>
		<rdfs:label>satisfied by</rdfs:label>
		<rdfs:domain rdf:resource="&iof-core;RequirementSpecification"/>
		<rdfs:range rdf:resource="&bfo;BFO_0000001"/>
		<owl:inverseOf rdf:resource="&iof-core;satisfies"/>
	</owl:ObjectProperty>
	
	<owl:ObjectProperty rdf:about="&iof-core;satisfies">
		<rdfs:label>satisfies</rdfs:label>
		<rdfs:domain rdf:resource="&bfo;BFO_0000001"/>
		<rdfs:range rdf:resource="&iof-core;RequirementSpecification"/>
		<skos:example>a piece of software satisfies a UML requirement specification, a design specification of a car satisfies its functional requirement specification</skos:example>
		<iof-av:elucidation>x satisfies r holds when &apos;entity&apos; x conforms to all &apos;continuant parts of&apos; Requirement Specification r and r &apos;prescribes&apos; x</iof-av:elucidation>
	</owl:ObjectProperty>
	
	<owl:Class>
		<rdfs:subClassOf rdf:resource="&iof-core;ActionSpecification"/>
		<owl:intersectionOf rdf:parseType="Collection">
			<rdf:Description rdf:about="&iof-core;InformationContentEntity">
			</rdf:Description>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;prescribes"/>
				<owl:someValuesFrom rdf:resource="&bfo;BFO_0000015"/>
			</owl:Restriction>
		</owl:intersectionOf>
	</owl:Class>
	<owl:Class>
		<rdfs:subClassOf rdf:resource="&iof-core;Algorithm"/>
		<owl:intersectionOf rdf:parseType="Collection">
			<rdf:Description rdf:about="&iof-core;PlanSpecification">
			</rdf:Description>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;prescribes"/>
				<owl:someValuesFrom rdf:resource="&iof-core;ComputingProcess"/>
			</owl:Restriction>
		</owl:intersectionOf>
	</owl:Class>
	<owl:Class>
		<rdfs:subClassOf rdf:resource="&iof-core;Assembly"/>
		<owl:intersectionOf rdf:parseType="Collection">
			<rdf:Description rdf:about="&iof-core;MaterialArtifact">
			</rdf:Description>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;isSpecifiedOutputOf"/>
				<owl:someValuesFrom rdf:resource="&iof-core;AssemblyProcess"/>
			</owl:Restriction>
		</owl:intersectionOf>
	</owl:Class>
	<owl:Class>
		<rdfs:subClassOf rdf:resource="&iof-core;CommercialServiceSpecification"/>
		<owl:intersectionOf rdf:parseType="Collection">
			<rdf:Description rdf:about="&iof-core;PlanSpecification">
			</rdf:Description>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;prescribes"/>
				<owl:someValuesFrom rdf:resource="&iof-core;CommercialService"/>
			</owl:Restriction>
		</owl:intersectionOf>
	</owl:Class>
	<owl:Class>
		<rdfs:subClassOf rdf:resource="&iof-core;DesignSpecification"/>
		<owl:intersectionOf rdf:parseType="Collection">
			<rdf:Description rdf:about="&iof-core;InformationContentEntity">
			</rdf:Description>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;prescribes"/>
				<owl:someValuesFrom rdf:resource="&bfo;BFO_0000002"/>
			</owl:Restriction>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;satisfies"/>
				<owl:someValuesFrom rdf:resource="&iof-core;RequirementSpecification"/>
			</owl:Restriction>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;prescribes"/>
				<owl:allValuesFrom rdf:resource="&bfo;BFO_0000002"/>
			</owl:Restriction>
		</owl:intersectionOf>
	</owl:Class>
	<owl:Class>
		<rdfs:subClassOf rdf:resource="&iof-core;InformationContentEntity"/>
		<owl:intersectionOf rdf:parseType="Collection">
			<rdf:Description rdf:about="&bfo;BFO_0000031">
			</rdf:Description>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;isAbout"/>
				<owl:someValuesFrom rdf:resource="&bfo;BFO_0000001"/>
			</owl:Restriction>
		</owl:intersectionOf>
	</owl:Class>
	<owl:Class>
		<rdfs:subClassOf rdf:resource="&iof-core;MaterialComponent"/>
		<owl:intersectionOf rdf:parseType="Collection">
			<rdf:Description rdf:about="&bfo;BFO_0000040">
			</rdf:Description>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;componentPartOfAtAllTimes"/>
				<owl:someValuesFrom rdf:resource="&bfo;BFO_0000040"/>
			</owl:Restriction>
		</owl:intersectionOf>
	</owl:Class>
	<owl:Class>
		<rdfs:subClassOf rdf:resource="&iof-core;MaterialComponentRole"/>
		<owl:intersectionOf rdf:parseType="Collection">
			<rdf:Description rdf:about="&bfo;BFO_0000023">
			</rdf:Description>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;roleOf"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&bfo;BFO_0000040">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&iof-core;componentPartOfAtSomeTime"/>
								<owl:someValuesFrom rdf:resource="&bfo;BFO_0000040"/>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</owl:intersectionOf>
	</owl:Class>
	<owl:Class>
		<rdfs:subClassOf rdf:resource="&iof-core;ObjectiveSpecification"/>
		<owl:intersectionOf rdf:parseType="Collection">
			<rdf:Description rdf:about="&iof-core;InformationContentEntity">
			</rdf:Description>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;prescribes"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:unionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&iof-core;Capability">
							</rdf:Description>
							<rdf:Description rdf:about="&iof-core;ProcessCharacteristic">
							</rdf:Description>
							<owl:Class>
								<owl:intersectionOf rdf:parseType="Collection">
									<rdf:Description rdf:about="&bfo;BFO_0000002">
									</rdf:Description>
									<owl:Restriction>
										<owl:onProperty rdf:resource="&iof-core;isOutputOf"/>
										<owl:someValuesFrom rdf:resource="&bfo;BFO_0000015"/>
									</owl:Restriction>
								</owl:intersectionOf>
							</owl:Class>
						</owl:unionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</owl:intersectionOf>
	</owl:Class>
	<owl:Class>
		<rdfs:subClassOf rdf:resource="&iof-core;PlanSpecification"/>
		<owl:intersectionOf rdf:parseType="Collection">
			<rdf:Description rdf:about="&iof-core;InformationContentEntity">
			</rdf:Description>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000110"/>
				<owl:someValuesFrom rdf:resource="&iof-core;ActionSpecification"/>
			</owl:Restriction>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&bfo;BFO_0000110"/>
				<owl:someValuesFrom rdf:resource="&iof-core;ObjectiveSpecification"/>
			</owl:Restriction>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;prescribes"/>
				<owl:someValuesFrom rdf:resource="&iof-core;PlannedProcess"/>
			</owl:Restriction>
		</owl:intersectionOf>
	</owl:Class>
	<owl:Class>
		<rdfs:subClassOf rdf:resource="&iof-core;RawMaterialRole"/>
		<owl:intersectionOf rdf:parseType="Collection">
			<rdf:Description rdf:about="&bfo;BFO_0000023">
			</rdf:Description>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;roleOf"/>
				<owl:someValuesFrom>
					<owl:Class>
						<owl:intersectionOf rdf:parseType="Collection">
							<rdf:Description rdf:about="&bfo;BFO_0000040">
							</rdf:Description>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&bfo;BFO_0000056"/>
								<owl:someValuesFrom>
									<owl:Class>
										<owl:intersectionOf rdf:parseType="Collection">
											<rdf:Description rdf:about="&iof-core;BuyingBusinessProcess">
											</rdf:Description>
											<owl:Restriction>
												<owl:onProperty rdf:resource="&bfo;BFO_0000057"/>
												<owl:someValuesFrom>
													<owl:Class>
														<owl:intersectionOf rdf:parseType="Collection">
															<rdf:Description rdf:about="&iof-core;BusinessOrganization">
															</rdf:Description>
															<owl:Restriction>
																<owl:onProperty rdf:resource="&iof-core;hasRole"/>
																<owl:someValuesFrom rdf:resource="&iof-core;ManufacturerRole"/>
															</owl:Restriction>
														</owl:intersectionOf>
													</owl:Class>
												</owl:someValuesFrom>
											</owl:Restriction>
										</owl:intersectionOf>
									</owl:Class>
								</owl:someValuesFrom>
							</owl:Restriction>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&bfo;BFO_0000177"/>
								<owl:someValuesFrom>
									<owl:Class>
										<owl:intersectionOf rdf:parseType="Collection">
											<rdf:Description rdf:about="&iof-core;MaterialProduct">
											</rdf:Description>
											<owl:Restriction>
												<owl:onProperty rdf:resource="&iof-core;isOutputOf"/>
												<owl:someValuesFrom rdf:resource="&iof-core;ProductProductionProcess"/>
											</owl:Restriction>
										</owl:intersectionOf>
									</owl:Class>
								</owl:someValuesFrom>
							</owl:Restriction>
							<owl:Restriction>
								<owl:onProperty rdf:resource="&iof-core;isInputOf"/>
								<owl:someValuesFrom rdf:resource="&iof-core;ProductProductionProcess"/>
							</owl:Restriction>
						</owl:intersectionOf>
					</owl:Class>
				</owl:someValuesFrom>
			</owl:Restriction>
		</owl:intersectionOf>
	</owl:Class>
	<owl:Class>
		<rdfs:subClassOf rdf:resource="&iof-core;RequirementSpecification"/>
		<owl:intersectionOf rdf:parseType="Collection">
			<rdf:Description rdf:about="&iof-core;InformationContentEntity">
			</rdf:Description>
			<owl:Restriction>
				<owl:onProperty rdf:resource="&iof-core;satisfiedBy"/>
				<owl:someValuesFrom rdf:resource="&bfo;BFO_0000001"/>
			</owl:Restriction>
		</owl:intersectionOf>
	</owl:Class>
</rdf:RDF>