QoSontology.kif

;; Access to and use of these products is governed by the GNU General Public 
;; License <http://www.gnu.org/copyleft/gpl.html>. 
;; By using these products, you agree to be bound by the terms 
;; of the GPL.

;; We ask that people using or referencing this work cite our primary paper:

;; Niles, I., and Pease, A.  2001.  Towards a Standard Upper Ontology.  In 
;; Proceedings of the 2nd International Conference on Formal Ontology in 
;; Information Systems (FOIS-2001), Chris Welty and Barry Smith, eds, 
;; Ogunquit, Maine, October 17-19, 2001.  

;; definition of productModel

(instance productModel AsymmetricRelation)
(subrelation productModel represents)
(domain productModel 1 SymbolicString)
(domainSubclass productModel 2 Product)
(documentation productModel "(productModel ?Model ?Product) means that 
?Model represents the type of the Product ?Product")

;; definition of ComputationalSystem

(subclass ComputationalSystem Product)
(documentation ComputationalSystem "Instances of &%ComputationalSystems 
include instances of &%SoftwareSystems, &%HardwareSystems, and 
&%ComputerNetworks.")  

;; definition of Computer

(subclass Computer Device)
(documentation Computer "A general-purpose machine that processes 
data according to a set of instructions that are stored internally 
either temporarily or permanently.") 

;; definition of ComputerNetwork

(subclass ComputerNetwork ComputationalSystem)
(documentation ComputerNetwork "The network includes the network 
operating system in the client and server machines, the cables 
connecting them and all supporting hardware in between such as 
bridges, routers and switches.")

;; definition of LAN

(subclass LAN ComputerNetwork)
(disjointDecomposition LAN BusNetwork StarNetwork RingNetwork)
(documentation LAN "A computer network that spans a relatively small 
area. Most LANs are confined to a single building or group of buildings. 
However, one LAN can be connected to other LANs over any distance via 
telephone lines and radio waves.") 

;; definition of BusNetwork

(subclass BusNetwork LAN)
(documentation BusNetwork "A network in which all nodes are connected 
to a single wire (the bus) that has two endpoints. Ethernet 10Base-2 
and 10Base-5 networks, for example, are bus networks. Other common 
network types include &%StarNetworks and &%RingNetworks.")

;; definition of StarNetwork

(subclass StarNetwork LAN)
(documentation StarNetwork "A local-area network (LAN) that uses a star 
topology in which all nodes are connected to a central computer.")

;; definition of RingNetwork

(subclass RingNetwork LAN)
(documentation LAN "A local-area network (LAN) whose topology is a ring. 
That is, all of the nodes are connected in a closed loop.  Messages 
travel around the ring, with each node reading those messages addressed 
to it.")

;; definition of ComputerHardware

(subclass ComputerHardware EngineeringComponent)
(documentation ComputerHardware "The hardware is the physical part of 
a computer system; the machinery and equipment.")

(<=>
	(instance ?Hardware ComputerHardware)
	(exists (?Computer)
		(and
			(instance ?Computer Computer)
			(component ?Hardware ?Computer))))

;; definition of ComputerMemory

(subclass ComputerMemory ComputerHardware)
(documentation ComputerMemory	"The computer's workspace (physically, 
a collection of RAM chips). It is an important resource, since it 
determines the size and number of programs that can be run at the 
same time, as well as the amount of data that can be processed 
instantly.")

;; definition of HardDiskDrive 

(subclass HardDiskDrive ComputerHardware)
(documentation HardDiskDrive "The primary computer storage medium, which 
is made of one or more aluminum or glass platters, coated with a 
ferromagnetic material. Most hard disks are fixed disks, which are 
permanently sealed in the drive.")

;; definition of CPU 

(subclass CPU ComputerHardware) 
(documentation CPU "CPU (Central Processing Unit) is the computing part 
of the computer.") 

;; definition of DataTransfer

(subclass DataTransfer ComputerProcess)
(documentation DataTransfer "A subclass of &%ComputerProcesses which 
send data over a computer channel or bus.") 

(=>
	(instance ?Transfer DataTransfer)
	(exists (?Origin ?Destination ?System ?Data)
		(and
			(origin ?Transfer ?Origin)
			(destination ?Transfer ?Destination)
			(instrument ?Transfer ?System)
			(patient ?Transfer ?Data)
			(instance ?Data ComputerData)
			(instance ?System HardwareSystem)
			(instance ?Origin HardwareSystem)
			(instance ?Destination ComputationalSystem)))) 

;;definition of ComputerProcess

(subclass ComputerProcess InternalChange)
(documentation ComputerProcess "An instance of &%ComputerProcess is a 
process which manipulates data in the computer.")

(=>  
     (instance ?Process ComputerProcess)
     (exists (?Computer ?Program)
	     (and
	             (instance ?Computer Computer)
		     (computerRunning ?Process ?Computer)
		     (instance ?Program ComputerProgram)
		     (programRunning ?Process ?Program))))

(=>
	(programRunning ?Process ?Program)
	(exists (?Computer)
		(runningOn ?Program ?Computer)))

;; definition of ComputerFile

(subclass ComputerFile ComputerData)
(documentation ComputerFile "A collection of bytes stored as an 
individual entity. All data on disk is stored as a file with an 
assigned file name that is unique within the folder (directory) 
it resides in.")

;;  definition of ComputerDirectory 

(subclass ComputerDirectory ComputerFile)
(documentation ComputerDirectory "This is the class of catalogs that 
identify and locate instances of &%ComputerFiles.  The catalog's entries 
consist of at least &%ComputerFile names and a physical address on a memory
device of the &%ComputerFile or an index (e.g., file descriptor) into a 
table of &%ComputerFile physical addresses.  &%ComputerDirectories are thus 
collections of data elements and must be named and stored on memory devices; 
hence, &%ComputerDirectory is a subset of &%ComputerFile.")

;; definition of runningOn

(instance runningOn BinaryRelation)
(domain runningOn 1 ComputerProgram)
(domain runningOn 2 Computer)
(documentation runningOn "(runningOn ?Program ?Computer) holds if the 
&%ComputerProgram ?Program is being executed on ?Computer.")

(=>
	(runningOn ?Program ?Computer)
	(exists (?Process)
		(and
			(programRunning ?Process ?Program)
			(computerRunning ?Process ?Computer))))

;; definition of computerRunning

(subrelation computerRunning instrument)
(domain computerRunning 1 ComputerProcess)
(domain computerRunning 2 Computer)
(documentation computerRunning "(&%computerRunning ?Process ?Computer) 
means that the ComputerProcess ?Process is running on ?Computer.")

;; definition of programRunning

(instance programRunning BinaryPredicate)
(domain programRunning 1 ComputerProcess)
(domain programRunning 2 ComputerProgram)
(documentation programRunning "(&%programRunning ?Process ?Program) 
means that the &%ComputerProcess ?Process is executing the 
&%ComputerProgram ?Program.")

;;  definition of directoryOf

(instance directoryOf BinaryPredicate)
(domain directoryOf 1 ComputerFile)
(domain directoryOf 2 ComputerDirectory)
(documentation directoryOf "(&%directoryOf ?FILE ?DIRECTORY) means that 
the &%ComputerFile ?FILE is in the &%ComputerDirectory ?DIRECTORY.")

;;  definition of PhysicalAddress.

(subclass PhysicalAddress SymbolicString)
(documentation PhysicalAddress "The collection of all addresses which 
identify a location of a &%ComputerFile.")

;;  definition of AddressFn .

(instance AddressFn UnaryFunction)
(domain AddressFn 1 ComputerFile)
(range AddressFn PhysicalAddress)
(documentation AddressFn "(&%AddressFn ?FILE) returns as its value the 
physical address of the &%ComputerFile ?FILE.")

; "ComputerDirectories contain information about the physical addresses 
; of ComputerFiles which are listed in these directories" .

(=>
	(and
		(instance ?Directory ComputerDirectory)
		(instance ?File ComputerFile)
		(directoryOf ?File ?Directory))
	(refers (AddressFn ?File) ?Directory)) 

;; definition of BitsPerSecond

(subclass BitsPerSecond TimeDependentQuantity)
(instance BitsPerSecond UnitOfMeasure)
(documentation BitsPerSecond "The measurement of the speed of data 
transfer in a communications system.")

;;  definition of PacketsPerSecond 

(subclass PacketsPerSecond TimeDependentQuantity)
(instance PacketsPerSecond UnitOfMeasure)
(documentation PacketsPerSecond "The rate or speed of &%Packet-Networks 
transferred in a second.")

;;  definition of Packet

(subclass Packet ComputerData)
(documentation Packet "A block of data used for transmission in packet 
switched systems.") 

;; The following constants are specific to the Quite project

;;  definition of SoftwareSystem 

(subclass SoftwareSystem ComputationalSystem)
(documentation SoftwareSystem "This is the class of mutually supportive 
groups of instances of &%ComputerProgram for a single general purpose. 
For example, a database management system is a collection of many instances
of &%ComputerProgram that work together to store, retrieve, modify, and 
delete data.")

; "A software system is a group of computer programs for a single 
; general purpose" .

(=>
	(instance ?System SoftwareSystem)
	(forall (?Program ?Process)
		(=>
			(and
				(part ?Program ?System)
				(programRunning ?Process ?Program))
			(exists (?Purpose)
				(hasPurpose ?Process ?Purpose)))))

;;  definition of HardwareSystem 

(subclass HardwareSystem ComputerHardware)
(subclass HardwareSystem ComputationalSystem)
(documentation HardwareSystem "The class of hardware systems is the 
connection of three types of physical modules: instances of 
&%ComputerProcessor(s), &%ComputerMemory, and &%ComputerNetwork. 
&%ComputerProcessors execute instructions from &%ComputerPrograms, 
which usually include instructions to read and write data from 
memory, and send data via instances of &%ComputerNetworks.")

; "A software system requires a hardware system to execute" .

(=>
	(and
		(instance ?Software SoftwareSystem)
		(instance ?Process ComputerProcess)
		(programRunning ?Process ?Software))
	(exists (?Hardware)
		(and
			(instance ?Hardware HardwareSystem)
			(computerRunning ?Process ?Hardware)))) 

; "A hardware system consists of three physical modules: processors, 
; memory, and networks" .

(=>
	(instance ?System HardwareSystem)
	(exists (?Processor ?Memory ?Network)
		(and
			(instance ?Processor CPU)
			(component ?System ?Processor)
			(instance ?Memory ComputerMemory)
			(component ?System ?Memory)
			(instance ?Network ComputerNetwork)
			(component ?System ?Network))))

; "When the data is sent from HardwareSystems, it is send via 
; ComputerNetworks" .

(=>
	(and
		(instance ?System ?HardwareSystem)
		(component ?Network ?System)
		(instance ?Event DataTransfer)
		(origin ?Event ?System))
	(exists (?Network)
		(and
			(instance ?Network ComputerNetwork)
			(instrument ?Event ?Network))))

;; definition of runsOn

(instance runsOn BinaryPredicate)
(instance runsOn AsymmetricRelation)
(domain runsOn 1 ComputerProgram)
(domain runsOn 2 Computer)
(documentation runsOn "(runsOn ?Program ?Computer) means that ?Program 
is capable of running on ?Computer.")

(=>
	(exists (?Process)
		(and
			(programRunning ?Process ?Program)
			(computerRunning ?Process ?Computer)))
	(runsOn ?Program ?Computer))
	
;;  definition of StartupBlock .

(subclass StartupBlock ComputerProgram)
(documentation StartupBlock "A typically small instance of &%ComputerProgram 
(a sequence of instructions that will run on a computer) whose function is 
to load and initialize a typically larger instance of &%ComputerProgram 
and start it running.")

;;  definition of startupOf 

(instance startupOf BinaryPredicate)
(domain startupOf 1 StartupBlock)
(domain startupOf 2 ComputerProgram)
(documentation startupOf "(&%startupOf ?STARTUP ?PROGRAM) holds just in 
case an instance of &%StartupBlock ?STARTUP specifies a set of instructions 
to start the ?PROGRAM.")

; "Each StartupBlock is a startup of some program" .

(=>
	(instance ?Startup StartupBlock)
	(exists (?Application)
		(startupOf ?Startup ?Application))) 

; "The startupBlock of an application starts the application" .

(=>
	(and
		(startupOf ?Startup ?Application)
		(instance ?Process1 ComputerProcess)
		(programRunning ?Process1 ?Startup)
		(equal (WhenFn ?Process1) ?Time1))
	(exists (?Process2 ?Time2)
		(and
			(instance ?Process2 ComputerProcess)
			(programRunning ?Process2 ?Application)
			(equal (WhenFn ?Process2) ?Time2)
			(meetsTemporally ?Time1 ?Time2))))  

;;  definition of StartupFn

(instance StartupFn UnaryFunction)
(domain StartupFn 1 ComputerProgram)
(range StartupFn StartupBlock)
(documentation StartupFn "(&%StartupFn ?Program) returns an instance of 
&%StartupBlock which contains the instructions to start the ?Program.")

;;  definition of ShutdownBlock .

(subclass ShutdownBlock ComputerProgram)
(documentation ShutdownBlock "A typically small instance of 
&%ComputerProgram whose function is to end a typically larger
instance of &%ComputerProgram.")

;;  definition of shutdownOf .

(instance shutdownOf BinaryPredicate)
(domain shutdownOf 1 ShutdownBlock)
(domain shutdownOf 2 ComputerProgram)
(documentation shutdownOf "(&%shutdownOf ?SHUTDOWN ?PROGRAM) holds just 
in case an instance of &%ShutdownBlock ?SHUTDOWN specifies a set of 
instructions to end ?PROGRAM.")

; "ShutdownBlock is a shutdown of an application"

(=>
	(instance ?Shutdown ShutdownBlock)
	(exists (?Application)
		(shutdownOf ?Shutdown ?Application)))

; "ShutdownBlock of an application ends the running version of the application"

(=>
	(and
		(shutdownOf ?Shutdown ?Application)
		(instance ?Process1 ComputerProcess)
		(programRunning ?Process1 ?Shutdown)
		(equal (WhenFn ?Process1) ?Time1))
	(exists (?Process2 ?Time2)
		(and
			(instance ?Process2 ComputerProcess)
			(programRunning ?Process2 ?Application)
			(equal (WhenFn ?Process2) ?Time2)
			(meetsTemporally ?Time2 ?Time1))))  

;;  definition of ShutdownFn

(instance ShutdownFn UnaryFunction)
(domain ShutdownFn 1 ComputerProgram)
(range ShutdownFn ShutdownBlock)
(documentation ShutdownFn "(&%ShutdownFn ?Program) returns an instance of 
&%ShutdownBlock which contains the instructions to end ?PROGRAM.")

;;  definition of EnvironmentSoftwareAttribute .

(subclass EnvironmentSoftwareAttribute Attribute)
(documentation EnvironmentSoftwareAttribute "The class of attributes which 
correspond to environment variables.  Environment variables are defined 
outside of a &%ComputerProgram, unlike ordinary variables that are 
defined in the source code of the &%ComputerProgram. Typically, the 
environment variable stores some value that many if not all 
&%ComputerProgams will need when they execute. An example is the
environment variable PATH under Unix-like operating systems that stores 
the &%ComputerDirectories where executable &%ComputerPrograms can be found. 
Another example is the environment variable CLASSPATH for Java programs, 
which stores the directory where Java class files can be found that will be 
needed by any &%ComputerProgram written in Java.")

(subrelation environmentAttributes property)
(domain environmentAttributes 1 ComputerProgram)
(domain environmentAttributes 2 EnvironmentSoftwareAttribute)
(documentation environmentAttributes "(&%environmentAttributes ?Program 
?Attribute) holds if ?Attribute is an &%EnvironmentSoftwareAttribute 
which describes the &%ComputerProgram ?Program.")

(subclass ComputerInputDevice ComputerHardware)
(documentation ComputerInputDevice "A peripheral device that generates 
input for the computer such as a keyboard, scanner, or mouse.")

(subclass ComputerOutputDevice ComputerHardware)
(documentation ComputerOutputDevice "Any peripheral that presents 
output from the computer, such as a screen or printer.")
 
(subclass ComputerTerminal ComputerOutputDevice)
(documentation ComputerTerminal "A &%ComputerOutputDevice for displaying
information on some sort of screen or other reusable output surface.  This
is contrasted with a &%Printer, which places a substance on a surface
that is for practical purposes, permanent.")

(subrelation standardInputDevice instrument)
(domain standardInputDevice 1 ComputerProcess)
(domain standardInputDevice 2 ComputerInputDevice)
(documentation  standardInputDevice "(&%standardInputDevice ?PROCESS 
?DEVICE) holds just in case the DEVICE is the predefined input channel
with which the running version of the program PROCESS is initialised.")

(=>
	(programRunning ?Process ?Program)
	(exists (?Device)
		(standardInputDevice ?Process ?Device)))

(subrelation standardOutputDevice instrument)
(domain standardOutputDevice 1 ComputerProcess)
(domain standardOutputDevice 2 ComputerOutputDevice)
(documentation standardOutputDevice "(&%standardOutputDevice ?PROGRAM 
?DEVICE) holds just in case the DEVICE is the predefined output channel 
with which the running version of this program is initialised.")

; "The program of the process contains information about the standard 
; output device of the process"

(=>
	(programRunning ?Process ?Program)
	(exists (?Device)
		(standardOutputDevice ?Process ?Device)))

;;  definition of standardErrorDevice .

(subrelation standardErrorDevice instrument)
(domain standardErrorDevice 1 ComputerProcess)
(domain standardErrorDevice 2 ComputerOutputDevice)
(documentation standardErrorDevice "(&%standardErrorDevice ?PROGRAM 
?DEVICE) holds just in case the DEVICE is the predefined error channel
with which the running version of this program is initialised.")

; "The program of the process contains information about the standard 
; error device of the process"

(=>
	(programRunning ?Process ?Program)
	(exists (?Device)
		(standardErrorDevice ?Process ?Device)))

;;  definition of hostOf


(instance hostOf BinaryPredicate)
(domain hostOf 1 ComputationalSystem)
(domain hostOf 2 Computer)
(documentation hostOf "(hostOf ?SYSTEM ?COMPUTER) means that ?COMPUTER 
is the host of the computational system ?SYSTEM.")

;;  definition of ProcessState

(subclass ProcessState ContentBearingObject)
(documentation ProcessState "The class of all the information required 
for a &%ComputerProgram to run on a processor. It is a vector that 
contains a pointer to the next program instruction to be executed as well 
as the values of all intermediate and defined variables, the state of the 
processor executing the program, and the allocated address space among 
other data.")

(=>
	(instance ?State ProcessState)
	(exists (?Program)
		(and
			(instance ?Program ComputerProgram)
			(forall (?Process)
				(=>
					(programRunning ?Process ?Program)
					(represents ?State ?Process))))))

;;  definition of stateOfProcess

(instance stateOfProcess BinaryRelation)
(domain  stateOfProcess 1 ComputerProcess)
(domain  stateOfProcess 2 ProcessState)
(documentation  stateOfProcess "(&%stateOfProcess ?PROCESS ?STATE) says 
that ?STATE is a state of the &%ComputerProcess ?PROCESS.")

;;  definition of AutomaticApplication . 

(subclass AutomaticApplication ComputerProgram)
(documentation AutomaticApplication "A program which is started 
automatically, as opposed to an application started in response to 
some condition becoming true.")

; "If an application is an automatic application, it is started when 
; the software system is started".

(=>
	(and
		(instance ?Application AutomaticApplication)
		(instance ?System SoftwareSystem)
		(part ?Application ?System))
	(part (StartupFn ?Application) (StartupFn ?System))) 

;;  definition of RM_StartApplication 

(subclass RM_StartApplication ComputerProgram)
(documentation RM_StartApplication  "A program started by a Resource 
Management program, which determines if and where to start the 
application.")

(=>
	(instance ?RM RM_StartApplication)
	(exists (?Application ?Process ?RMCopy)
		(and
			(instance ?Application ComputerProgram)
			(programCopy ?RMCopy ?RM)
			(programRunning ?Process (StartupFn ?Application))
			(agent ?Process ?RMCopy))))

;;  definition of ConsoleApplication . 

(instance ConsoleApplication ComputerProgram)
(documentation ConsoleApplication "A Program which is started inside 
an Xterm or other console.")

;;  definition of RMProgram .

(subclass ResourceManagementProgram ComputerProgram)
(documentation ResourceManagementProgram "The class of resource 
management programs.")

;;  definition of rMProgram-of .

(instance rMProgram-of BinaryPredicate)
(domain rMProgram-of 1 ResourceManagementProgram)
(domain rMProgram-of 2 SoftwareSystem)
(documentation rMProgram-of "(&%rMProgram-of ?RM ?SYSTEM) means that 
?RM is the resource management program of &%the SoftwareSystem ?SYSTEM.")

; "The resource management program of a software system controls 
; applications in this system" .

(=>
	(rMProgram-of ?RM ?System)
	(exists (?Application ?Process ?RMCopy)
		(and
			(part ?Application ?System)
			(programCopy ?RMCopy ?RM)
			(programRunning ?Process ?Application)
			(agent ?Process ?RMCopy))))

;; definition of programCopy

(instance programCopy AsymmetricRelation)
(subrelation programCopy containsInformation)
(domain programCopy 1 ComputerFile)
(domain programCopy 2 ComputerProgram)
(documentation programCopy "(&%programCopy ?File ?Program) means that 
the &%ComputerFile ?File is one of the copies of the &%ComputerProgram 
?Program.")

;;  definition of criticalityLevel.

(instance criticalityLevel BinaryPredicate)
(domain criticalityLevel 1 ComputerProgram)
(domain criticalityLevel 2 Integer)
(documentation criticalityLevel "(&%criticalityLevel ?PROGRAM ?INTEGER) 
holds just in case ?INTEGER indicates the relative priority of ?PROGRAM 
with respect to other applications within the &%SoftwareSystem.")

;;  definition of startupTimeDelay

(instance startupTimeDelay BinaryRelation)
(domain startupTimeDelay 1 ComputerProgram)
(domain startupTimeDelay 2 TimeDuration)
(documentation startupTimeDelay "(&%startupTimeDelay ?PROGRAM ?TIME) 
says that ?TIME is the time to delay after the previous application 
was started before starting the application ?PROGRAM.")

; "If an application has a startupTimeDelay of n seconds, then
; any process which runs after this application has a starting point 
; n seconds later than the startup of this application."

(=>
	(exists (?Time1 ?Time2 ?Time)
		(and
			(startupTimeDelay ?Application ?Delay)
			(instance ?Process1 ComputerProcess)
			(programRunning ?Process1 ?Application)
			(equal (WhenFn ?Process1) ?Time1)
			(instance ?Process2 ComputerProcess)
			(equal (WhenFn ?Process2) ?Time2)
			(meetsTemporally ?Time1 ?Time)
			(meetsTemporally ?Time ?Time2)))
	(measure ?Time ?Delay)) 

;;  definition of Feedback 

(subclass Feedback ContentBearingObject)
(documentation Feedback "The class of all messages to a resource 
management program from one of its processes.")

(<=>
	(instance ?Feedback Feedback)
	(exists (?RM ?Process ?Program)
		(and
			(rMProgram-of ?RM ?Program)
			(programRunning ?Process ?Program)
			(instance ?Send DataTransfer) 
			(patient ?Send ?Feedback)
			(destination ?Send ?RM))))

;;  definition of processList	

(instance processList Predicate)
(instance processList VariableArityRelation)		
(documentation processList "The arguments of this relation are data 
structures, each of which contains the information necessary for the 
process already loaded by the operating system to execute on a processor.")

; "The processes in the list are ordered by the start time" .

(=>
	(and
		(processList @ROW)
                (inList ?Process1 (ListFn @ROW))
                (inList ?Process2 (ListFn @ROW))
                (equal (ListOrderFn (ListFn @ROW) ?Number1) ?Process1)
                (equal (ListOrderFn (ListFn @ROW) ?Number2) ?Process2)
                (lessThan ?Number1 ?Number2))
	(earlier (WhenFn ?Process1) (WhenFn ?Process2))) 

;;  definition of settlingTime

(instance settlingTime BinaryPredicate)
(domain settlingTime 1 ComputerProgram)
(domain settlingTime 2 TimeDuration)
(documentation settlingTime "(&%settlingTime ?PROGRAM ?TIME) says that 
?TIME represents seconds to delay after an action was taken with respect 
to QoS.")

;;  definition of minimumReplications

(instance  minimumReplications BinaryPredicate)
(domain minimumReplications  1 ComputerProgram)
(domain minimumReplications  2 PositiveInteger)
(documentation minimumReplications "(&%minimumReplications ?PROGRAM 
?INTEGER) means that ?INTEGER represents the minimum copies of the 
application ?PROGRAM required to be survivable, where a program is 
survivable if the failure of one or more resources does not result 
in the failure of the program.  Either long MTTF for the system as a 
whole or short MTTR when failure occurs would improve the survivability
of a program.")

; "MinimumReplications is the mininum number of copies of the application 
; involved in a running process".

(=>
	(minimumReplications ?Application ?MinCopies)
	(greaterThanOrEqualTo 
		(CardinalityFn 
		        (KappaFn ?Copy 
			        (programRunning ?Copy ?Application))) ?MinCopies)) 

;;  definition of maximumReplications

(instance maximumReplications BinaryPredicate)
(domain maximumReplications 1 ComputerProgram)
(domain maximumReplications 2 PositiveInteger)
(documentation maximumReplications "(&%maximumReplications ?PROGRAM ?INTEGER) means that 
?INTEGER represents the maximum number of copies of this application which can be run 
during a process.")

; "MaximumReplications is the maximum number of copies of the application 
; allowed to run during a process".

(=>
	(maximumReplications ?Application ?MaxCopies)
	(greaterThanOrEqualTo ?MaxCopies 
			      (CardinalityFn 
					     (KappaFn ?Copy 
						      (programRunning ?Copy ?Application))))) 


;; definition of IPAddress

(subclass IPAddress PhysicalAddress)
(documentation IPAddress "The Internet Protocol address; a numeric address such as 123.231.32.2 that 
the domain name server translates into a domain name.")

;;  definition of ipAddressOf 

(instance ipAddressOf BinaryPredicate)
(domain ipAddressOf 1 Computer)
(domain ipAddressOf 2 IPAddress)
(documentation ipAddressOf "(&%ipAddressOf ?HOST ?ADDRESS) holds if ?ADDRESS is the &%IPAddress of 
the computer ?HOST.")

;;  definition of portNumber 

(instance portNumber BinaryPredicate)
(domain portNumber 1 ComputerProgram)
(domain portNumber 2 PositiveInteger)
(documentation portNumber "(&%portNumber ?PROGRAM ?NUMBER) holds if ?NUMBER identifies a protocol 
port, i.e. a TCP-IP software abstraction used to distinguish different applications providing 
services within a single destination computer. The different ports on a host are identified by a 
positive 16-bit number.")

;;  definition of processID .

(instance processID BinaryPredicate)
(domain processID 1 ComputerProcess)
(domain processID 2 PositiveInteger)
(documentation processID "(&%processID ?PROCESS ?NUMBER) holds if ?NUMBER is a unique number 
generated by the operating system and used to refer to the &%ComputerProcess ?PROCESS.  There 
is usually no significance to the numbers as they are reused as old processes die and new processes 
are created.")

;;  definition of ProcessStatus .

(subclass ProcessStatus Attribute)
(documentation ProcessStatus "A class of attributes. Each instance of &%ProcessStatus describes a 
status of a &%Process, such as &%ProcessFailure, &%ProcessSuccess, etc.")

;;  definition of ProcessFailure .

(instance ProcessFailure ProcessStatus)
(documentation ProcessFailure "An attribute that denotes the failure of the &%Process to achieve 
its goal.")

;;  definition of ProcessSuccess .

(instance ProcessSuccess ProcessStatus)
(contraryAttribute ProcessSuccess ProcessFailure)
(documentation ProcessSuccess "An attribute that denotes the success of the &%Process to achieve 
its goal.")

;;  definition of status .

(subrelation status property)  
(domain status 1 ComputerProcess)
(domain status 2 ProcessStatus)
(documentation status "(&%status ?PROCESS ?STATUS) holds if ?STATUS is the current status of ?PROCESS.")

(=>
	(and
		(status ?Process ProcessFailure)
		(hasPurpose ?Process ?Purpose))
	(not (holdsDuring (ImmediatePastFn (WhenFn ?Process)) ?Purpose)))

;;  definition of ComputerComponent

(subclass ComputerComponent ComputerHardware)
(documentation ComputerComponent "An instance of &%ComputerComponent is a 
piece of computer hardware that has measurable performance characteristics 
in terms of different units. Components include hard drives, the performance
of which can be measured in terms of BitsPerSecond required to transfer data 
to and from the drive, network adapters, the performance of which can be 
measured by &%PacketsPerSecond units of data transfered to and from the adapter, 
and other common components like &%ComputerMemory and &%CentralProcessingUnit.")

(subclass ComputerMemory ComputerComponent) 

(subclass HardDiskDrive ComputerComponent) 

(subclass CentralProcessingUnit ComputerComponent) 

(=>
	(instance ?Component ComputerComponent)
	(exists (?Unit)
		(unitMeasuringPerformance ?Component ?Unit)))

;;  definition of NetworkAdapter

(subclass NetworkAdapter ComputerComponent)
(documentation NetworkAdapter "A network adapter, also known as a Network 
Interface Card or NIC, is a physical device installed in a computer on its 
system bus. Its purpose is to connect to a specific type of network,
usually an ethernet or a token ring network.")

(=>
	(instance ?NA NetworkAdapter)
	(exists (?Net)
		(and
			(instance ?Net ComputerNetwork)
			(connected ?NA ?Net))))

;;  definition of unitMeasuringPerformance .

(instance unitMeasuringPerformance  BinaryPredicate)
(domain unitMeasuringPerformance  1 ComputerComponent)
(domain unitMeasuringPerformance  2 UnitOfMeasure)
(documentation unitMeasuringPerformance "(&%unitMeasuringPerformance ?COMPONENT 
?UNIT) holds in case ?UNIT is an instance of &%UnitOfMeasure which is used to 
measure the performance of ?COMPONENT.")

; "The performance of Hard Drives is measured in BitsPerSecond" .

(=>
	(instance ?HardDrive HardDiskDrive)
	(unitMeasuringPerformance ?HardDrive BitsPerSecond)) 

; "The performance of network adapters is measured by packets/second" .

(=>
	(instance ?NA NetworkAdapter)
	(unitMeasuringPerformance ?NA PacketsPerSecond)) 

;;  definition of MonitoringProgram .

(subclass MonitoringProgram ComputerProgram)
(documentation  MonitoringProgram "A program which monitors performance 
of an application, a component, etc.")

(=>
	(instance ?Monitor MonitoringProgram)
	(exists (?System ?Event ?MonitorCopy)
		(and
			(systemMeasured ?Event ?System)
			(programCopy ?MonitorCopy ?Monitor)
			(agent ?Event ?MonitorCopy))))

;; definition of systemMeasured

(instance systemMeasured BinaryPredicate)
(instance systemMeasured AsymmetricRelation)
(domain systemMeasured 1 MeasuringPerformance)
(domain systemMeasured 2 ComputationalSystem)
(documentation systemMeasured "(&%systemMeasured ?Event ?System) means that 
?Event is an event of measuring the performance of the &%ComputationalSystem 
?System.")

;;  definition of dataID .

(instance dataID BinaryPredicate)
(domain dataID 1 MonitoringProgram)
(domain dataID 2 SymbolicString)
(documentation dataID "(&%dataID ?PROGRAM ?NUMBER) holds if ?NUMBER is a small 
number associated with an instance of &%MonitoringProgram.")

;;  definition of MeasuringPerformance .

(subclass MeasuringPerformance ComputerProcess)
(documentation MeasuringPerformance "Each element of &%MeasuringPerformance 
is an event of measuring the performance of an instance of &%ComputerComponent, 
performed by a &%MonitoringProgram.")

(=>
	(instance ?Event MeasuringPerformance)
	(exists (?Program ?Copy)
		(and
			(instance ?Program MonitoringProgram)
			(programCopy ?Copy ?Program)
			(agent ?Event ?Copy)))) 

;;  definition of componentDataID .

(instance componentDataID QuintaryPredicate)
(domain componentDataID 1 TimePosition)
(domainSubclass componentDataID 2 ComputerComponent)
(domain componentDataID 3 ComputerComponent)
(domain componentDataID 4 UnitOfMeasure)
(domain componentDataID 5 SymbolicString)
(documentation componentDataID "(&%componentDataID ?TIME ?COMPONENT ?INSTANCE 
?UNIT ?NUMBER) holds if ?INSTANCE is an instance of ?COMPONENT, identified by 
&%IDNumber ?NUMBER, and whose performance is measured by a &%UnitOfMeasure-ComputerPerformance ?UNIT. The timestamp ?TIME identifies the time when this 
information was created.")

(=>
	(componentDataID ?Time ?Component ?Instance ?Unit ?Number)
	(instance ?Instance ?Component)) 


(=>
	(componentDataID ?Time ?Component ?Instance ?Unit ?Number)
	(unitMeasuringPerformance ?Instance ?Unit)) 


(=>
	(componentDataID ?Time ?Component ?Instance ?Unit ?Number)
	(refers ?Number ?Instance)) 

;;  definition of heartBeatRate .

(subrelation heartBeatRate frequency) 
(domain heartBeatRate 1 ComputerProgram)
(domain heartBeatRate 2 TimeDuration)
(documentation heartBeatRate "(&%heartBeatRate ?Program ?Period) holds if 
?Period is the period at which the ComputerProgram ?Program sends its heartbeat 
to a monitoring process.")

;;  definition of MonitorConnectivityCmd .

(subclass MonitorConnectivityCmd MonitoringProgram)
(documentation  MonitorConnectivityCmd "This is the command to get a list 
of applications periodically.")

;;  definition of MonitorApplicationCmd 

(subclass MonitorApplicationCmd MonitoringProgram)
(documentation MonitorApplicationCmd "This command is to change the monitoring 
for any component for which a &%componentDataID was sent on initial connection.")

;;  definition of MonitorComponentCmd

(subclass MonitorComponentCmd MonitoringProgram)
(documentation MonitorComponentCmd "This is the command to monitor any of the 
generic components - hard drive, network, cpu, memory, etc." )

;;  definition of performanceResult.

(instance  performanceResult TernaryPredicate)
(domain  performanceResult 1 MeasuringPerformance)
(domain  performanceResult 2 ComputerComponent)
(domain  performanceResult 3 RealNumber)
(documentation  performanceResult "(&%performanceResult ?EVENT ?COMPONENT 
?NUMBER) holds if the performance of ?COMPONENT has a value ?NUMBER, 
measured by ?EVENT, an instance of &%MeasuringPerformance.")

;;  definition of monitorComponentData .

(instance monitorComponentData TernaryPredicate)
(domain monitorComponentData 1 TimePosition)
(domain monitorComponentData 2 SymbolicString)
(domain monitorComponentData 3 RealNumber)
(documentation monitorComponentData "(&%monitorComponentData ?TIME ?ID 
?NUMBER) holds if at time ?TIME, a component with the &%IDNumber ?ID 
has a performance of a value ?NUMBER.")

(=>
	(and
		(monitorComponentData ?Time1 ?ID ?Number)
		(componentDataID ?Time2 ?Component ?Instance ?Unit ?ID))
	(exists (?Event)
		(and
			(instance ?Event MeasuringPerformance)
			(unitMeasuringPerformance ?Instance ?Unit)
			(time ?Event ?Time1)
			(performanceResult ?Event ?Instance ?Number)))) 

;;  definition of monitorConnectivityData .

(instance monitorConnectivityData BinaryRelation)
(domain  monitorConnectivityData 1 TimePosition)
(domain  monitorConnectivityData 2 IPAddress)
(documentation  monitorConnectivityData "(&%monitorConnectivityData ?TIME 
?IPADDRESS) is a relation between a timestamp ?TIME and an ?IP address.")

;;  definition of monitorApplicationData .

(instance monitorApplicationData BinaryPredicate)
(domain monitorApplicationData  1 TimePosition)
(domain monitorApplicationData  2 ComputerProgram)
(documentation monitorApplicationData "(&%monitorApplicationData ?TIME 
?APPLICATION) holds if the time stamp ?TIME specifies the time at which 
?APPLICATION is running.")

(=>
	(monitorApplicationData ?Time ?Application)
	(exists (?Process)
		(and
			(programRunning ?Process ?Application)
			(time ?Process ?Time))))

;; definition of Executable

(instance Executable Attribute)
(documentation Executable "Able to be run in its current format.")

(<=> 
	(exists (?Process)
		(programRunning ?Process ?Program))
	(property ?Program Executable)) 

;; definition of OperatingSystem

(subclass OperatingSystem SoftwareSystem)
(documentation OperatingSystem "The master control program that runs the 
computer. It is the first program loaded when the computer is turned on, 
and its main part, called the kernel, resides in memory at all times. It 
may be developed by the vendor of the computer it's running in or by a 
third party.")

;; definition of defaultNetwork.

(instance defaultNetwork BinaryPredicate)
(domain defaultNetwork 1 HardwareSystem)
(domain defaultNetwork 2 ComputerNetwork)
(documentation defaultNetwork "(&%defaultNetwork ?SYSTEM ?NET) holds if 
?NET is the default network of the &%HardwareSystem ?SYSTEM.")

;; definition of Solaris.

(subclass Solaris OperatingSystem)
(documentation Solaris "The class of all instances of Solaris , a 
unix-based operating system for Sun SPARC computers. It includes the 
Open Look and Motif graphical user interfaces, OpenWindows (the Sun 
version of X Windows), DOS and Windows Emulation, and ONC networking.")

;; definition of numberOfCPUs.

(instance numberOfCPUs BinaryPredicate)
(domain numberOfCPUs 1 Computer)
(domain  numberOfCPUs 2 PositiveInteger)
(documentation numberOfCPUs "(&%numberOfCPUs ?COMPUTER ?INTEGER) means 
that the number of CPUs for the host ?COMPUTER is equal to INTEGER.")

;; definition of hardwareType.

(subrelation hardwareType represents)
(domain  hardwareType 1 SymbolicString)
(domain  hardwareType 2 Computer)
(documentation hardwareType "(&%hardwareType ?TYPE ?COMPUTER) means that 
TYPE represents the computer vendor model name, as well as the version 
of the product.")

(=>
	(and
		(hardwareType ?Type ?Computer)
		(productModel ?Model ?Computer))
	(subsumesContentInstance ?Type ?Model))

(=>
	(and
		(hardwareType ?Type ?Computer)
		(version ?Version ?Computer))
	(subsumesContentInstance ?Type ?Version))

;; definition of thresholdOf.

(instance thresholdOf BinaryPredicate)
(domain thresholdOf 1 Computer) 
(domain thresholdOf 2 PositiveRealNumber)

;; definition of benchmarkPerformance.

(instance benchmarkPerformance TernaryPredicate)
(domain benchmarkPerformance 1 ComputationalSystem)
(domain benchmarkPerformance 2 MonitoringProgram)
(domain benchmarkPerformance 3 Quantity)
(documentation benchmarkPerformance "(&%benchmarkPerformance ?SYSTEM 
?TEST ?NUMBER) holds if ?NUMBER is a benchmark for measuring the performance 
of an instance of a &%ComputationalSystem.")

(=>
	(benchmarkPerformance ?System ?Test ?Number)
	(exists (?Event)
		(and
			(instance ?Event MeasuringPerformance)
			(performanceResult ?Event ?System ?Number))))

;; definition of bandwidthOf.

(instance bandwidthOf BinaryPredicate)
(domain bandwidthOf 1 ComputerNetwork)
(domain bandwidthOf 2 BitsPerSecond)
(documentation bandwidthOf "(&%bandwidthOf ?NET ?BANDWIDTH) holds if 
?BANDWIDTH is the amount of data which can be sent through an instance 
of a &%ComputerNetwork ?NET, measured in bits per second.")

;; definition of priority.

(instance priority  BinaryPredicate)
(domain priority 1 ComputationalSystem)
(domain priority 2 PriorityAttribute)
(documentation priority "(&%priority ?SYSTEM ?QUANTITY) means that the 
priority of the ?SYSTEM is characterized by a &%PriorityAttribute, such 
as &%HighPriority or &%LowPriority.")

;; definition of PriorityAttribute

(subclass PriorityAttribute Attribute)
(documentation PriorityAttribute "A class of attributes which describe 
priorities of &%ComputationalSystems.")

(instance HighPriority PriorityAttribute)
(documentation HighPriority "Used to indicate that a &%ComputationalSystem 
has a high priority.")

(instance LowPriority PriorityAttribute) 
(documentation LowPriority "Used to indicate that a &%ComputationalSystem 
has a low priority.")

;; definition of ComputerPath.

(subclass ComputerPath ComputerData)
(documentation ComputerPath "An instance of &%ComputerPath is a series 
of programs that connects input devices, typically sensors, to output 
devices, typically actuators.")

;; definition of softwarePath.

(instance softwarePath BinaryPredicate)
(domain softwarePath 1 SoftwareSystem)
(domain softwarePath 2 ComputerPath)
(documentation softwarePath "(&%softwarePath ?SYSTEM ?PATH) means that 
?PATH is a computer path for the instance of &%SoftwareSystem ?SYSTEM.")

;; definition of SoftwareAttribute

(subclass SoftwareAttribute Attribute)
(documentation SoftwareAttribute "The class of all attributes that are 
specific to &%SoftwareSystems.")

;; definition of ComputerPathAttribute.

(subclass ComputerPathAttribute SoftwareAttribute)
(documentation ComputerPathAttribute "The class of all attributes that are 
specific to &%ComputerPaths.")

(=>
	(instance ?Attribute ComputerPathAttribute)
	(exists (?Path)
		(and
			(instance ?Path ComputerPath)
			(property ?Path ?Attribute))))

;; definition of PathImportanceFunction.

(instance PathImportanceFunction ComputerPathAttribute)
(documentation PathImportanceFunction  "The attribute which denotes that 
the path importance is defined by the dynamic library procedure 
&%pathImportanceFunction. This functions passes arguments for priority 
and current time and returns an integer that represents importance.")

;; definition of Scalable.

(subclass Scalable ComputerPathAttribute)
(documentation Scalable "The attribute which denotes that the path is 
scalable, i.e. the applications in the path can be replicated to meet 
realtime QoS requirements.")

;; definition of DynamicDataStream.

(subclass DynamicDataStream ComputerPathAttribute)
(documentation DynamicDataStream "The attribute which denotes that the 
path data stream type is dynamic, i.e. the time changes but the data 
stream follows a pattern.")

;; definition of StochasticDataStream.

(subclass StochasticDataStream ComputerPathAttribute)
(documentation  StochasticDataStream "The attribute which denotes that 
the time between data or groups of data changes according to no 
discernible pattern.")

;; definition of DeterministicDataStream.

(subclass DeterministicDataStream ComputerPathAttribute) 
(documentation DeterministicDataStream "The attribute which denotes that 
the data stream is conceived as a stream of one datum after another, and 
each datum or identifiable group of data is separated by a constant of 
time.")

(=>
	(and
		(instance ?Path ComputerPath)
		(property ?Path DynamicDataStream))
	(not (property ?Path StochasticDataStream)))

(=>
	(and
		(instance ?Path ComputerPath)
		(property ?Path DynamicDataStream))
	(not (property ?Path DeterministicDataStream)))

;; definition of ContinuousPath

(subclass ContinuousPath ComputerPathAttribute)
(documentation  ContinuousPath "The attribute which denotes that the 
path type is continuous, as opposed to transient or quasiconstinuous 
paths. A continuous path handles a stream of data arriving at a comment 
of rate.")

;; definition of TransientPath.

(subclass TransientPath ComputerPathAttribute)
(documentation TransientPath "An attribute which applies to computer 
paths which handle random events.") 

;; definition of QuasicontinuousPath.

(subclass QuasicontinuousPath ComputerPathAttribute)
(documentation  QuasicontinuousPath "An attribute which applies to 
computer paths which handle random events, which initiate a bounded 
stream of data arriving at a comment of rate, which the path must 
process.")

(=>
	(and
		(instance ?Path ComputerPath)
		(property ?Path ContinuousPath))
	(not (property ?Path TransientPath)))

(=>
	(and
		(instance ?Path ComputerPath)
		(property ?Path ContinuousPath))
	(not (property ?Path QuasicontinuousPath)))

;; definition of simpleDeadline.

(instance simpleDeadline BinaryPredicate)
(domain simpleDeadline 1 ComputerPath)
(domain simpleDeadline 2 TimeDuration)
(documentation  simpleDeadline "(&%simpleDeadline ?PATH ?TIME)holds if 
?TIME is the maximum end-to-end path latency during a cycle of a 
continuous or quasicontinuous path or during the activation of a transient 
path.")

;; definition of batchLatency.

(instance batchLatency BinaryPredicate)
(domain batchLatency 1 ComputerPath)
(domain batchLatency 2 TimeDuration)
(documentation batchLatency "(&%batchLatency ?PATH ?TIME)holds if ?TIME 
is the maximum allowed latency for all cycles of a quasicontinuous path.")

;; definition of batchInterArrival.

(instance batchInterArrival BinaryPredicate)
(domain batchInterArrival 1 ComputerPath)
(domain batchInterArrival 2 TimeDuration)
(documentation batchInterArrival "(&%batchInterArrival ?PATH ?TIME) 
holds if ?TIME is the maximum allowable time between processing of a 
particular element of a continuous or quasicontinuous path's data 
stream in successive cycles.")

;; definition of qoSSlack.

(instance qoSSlack TernaryRelation)
(domain qoSSlack 1 ComputerPath)
(domain qoSSlack 2 ConstantQuantity)
(domain qoSSlack 3 ConstantQuantity)
(documentation qoSSlack "(&%qoSSlack ?PATH ?MIN ?MAX) holds if ?PATH 
has a realtime QoS maximum slack percentage of ?MAX and minimum of 
?MIN.")

;; definition of slidingWindowSize.

(instance slidingWindowSize BinaryPredicate)
(domain slidingWindowSize 1 ComputerPath)
(domain slidingWindowSize 2 PositiveInteger)
(documentation slidingWindowSize "(&%slidingWindowSize ?PATH ?N) holds 
if PATH has a realtime QoS sliding window size of ?N measured samples.")

;; definition of dataStreamSlack.

(instance dataStreamSlack BinaryPredicate)
(domain dataStreamSlack 1 ComputerPath)
(domain dataStreamSlack 2 PositiveInteger)
(documentation dataStreamSlack "(&%dataStreamSlack ?PATH ?N) means that 
a continuous or quasicontinuous path ?PATH should be able to process ?N 
additional data items at any time.")

(=>
	(dataStreamSlack ?Path ?Number)
	(or
		(property ?Path  ContinuousPath)
		(property ?Path QuasicontinuousPath)))

;; definition of dependencyType.

(instance dependencyType BinaryPredicate)
(domain dependencyType 1 ComputerProgram)
(domainSubclass dependencyType 2 ComputerProgram)
(documentation dependencyType "(&%dependencyType ?PROGRAM ?TYPE) means 
that ?PROGRAM has a dependency type ?TYPE, where ?TYPE can be either 
&%StartupBlock or &%ShutdownBlock.") 

(=>
	(dependencyType ?Program ?Type)
	(or
		(equal ?Type StartupBlock)
		(equal ?Type ShutdownBlock)))

;; definition of Restartable.

(instance Restartable SoftwareAttribute)
(documentation Restartable "The attribute which denotes that a program 
can be restarted.")

;; definition of hasDependency.

(instance hasDependency BinaryPredicate)
(domain hasDependency 1 ComputerProgram)
(domain hasDependency 2 ComputerProgram)
(documentation hasDependency "(&%hasDependency ?PROGRAM1 ?PROGRAM2) 
holds if ?PROGRAM1 is dependent on the application ?PROGRAM2.")

;; definition of dependencyDelay.

(instance dependencyDelay BinaryPredicate)
(domain dependencyDelay 1 ComputerProgram)
(domain dependencyDelay 2 TimeDuration)
(documentation dependencyDelay "if the dependency type is &%StartupBlock, 
then (&%dependencyDelay ?PROGRAM ?TIME) means that the application 
?PROGRAM can only be started after a dependency delay of ?TIME after the 
startup of the application. If the dependency type is &%ShutdownBlock, then 
(&%dependencyDelay ?PROGRAM ?TIME) means that the application ?PROGRAM can 
only be stopped after a dependency delay of ?TIME after the application 
is stopped.")

(=>
	(exists (?Time1 ?Time2)
		(and
			(dependencyDelay ?Program1 ?Delay)
			(dependencyType ?Program1 StartupBlock)
			(hasDependency ?Program1 ?Program2)
			(instance ?Process1 ComputerProcess)
			(programRunning ?Process1 ?Program1)
			(instance ?Process2 ComputerProcess)
			(programRunning ?Process2 ?Program2)
			(equal (WhenFn ?Process2) ?Time2)
			(starts ?Time2 ?Time)
			(equal (WhenFn ?Process1) ?Time1)
			(equal (EndFn ?Time) (BeginFn ?Time1))))
	(duration ?Time ?Delay)) 

(=>
	(exists (?Time1 ?Time2)
		(and
			(dependencyDelay ?Program1 ?Delay)
			(dependencyType ?Program1 ShutdownBlock)
			(hasDependency ?Program1 ?Program2)
			(instance ?Process1 ComputerProcess)
			(programRunning ?Process1 ?Program1)
			(instance ?Process2 ComputerProcess)
			(programRunning ?Process2 ?Program2)
			(equal (WhenFn ?Process2) ?Time2)
			(finishes ?Time ?Time1)
			(equal (WhenFn ?Process2) ?Time2)
			(equal (BeginFn ?Time) (EndFn ?Time2)))) 
	(duration ?Time ?Delay)) 

;; definition of ReplicationsOnSameHostOK.

(instance ReplicationsOnSameHostOK SoftwareAttribute)
(documentation ReplicationsOnSameHostOK "The attribute which denotes that 
a program can be restarted on the same host.")

(=>
	(property ?Program ReplicationsOnSameHostOK)
	(property ?Program Restartable))

;; definition of commandLineArguments.

(instance commandLineArguments BinaryPredicate)
(domain commandLineArguments 1 ComputerProgram)
(domain commandLineArguments 2 List)
(documentation commandLineArguments "(&%commandLineArguments ?PROGRAM 
?LIST) means that the application ?PROGRAM requires command line 
arguments, as specified in ?LIST.")

;; definition of ScalabilityCombining.

(instance ScalabilityCombining SoftwareAttribute)
(documentation ScalabilityCombining "The attribute which denotes that 
an application can combine its input stream from different preceding 
applications or devices for greater scalability.")

;; definition of ScalabilitySplitting.

(instance ScalabilitySplitting SoftwareAttribute)
(documentation ScalabilitySplitting "The attribute which denotes that 
a program can split its output stream to different succeeding 
applications or devices for greater scalability.")

;; definition of InitialProfileFn.

(instance InitialProfileFn UnaryFunction)
(domain InitialProfileFn 1 ComputerProgram)
(range InitialProfileFn ProcessState)             ;; RAP - added, but not sure if this is what was intended
(documentation InitialProfileFn "The function which returns as its value 
the initial profile of the program, i.e. a report of its execution 
characteristics.")

;; definition of CPUUtilizationFn.

(subrelation CPUUtilizationFn UnaryFunction)
(domain CPUUtilizationFn 1 ComputerProgram)
(range CPUUtilizationFn ConstantQuantity)
(documentation  CPUUtilizationFn "(&%CPUUtilizationFn ?PROGRAM) refers to 
the percentage of time the CPU is used by an application ?PROGRAM.")

; definition of RealtimeSystem 

(subclass RealtimeSystem ComputationalSystem)    
(documentation RealtimeSystem "An  computer-controlled system, the 
correct operation of which depends on meeting specified timing 
constraints.")

(subclass SoftwareSystem RealtimeSystem) 

(subclass HardwareSystem RealtimeSystem) 

(subclass ComputerNetwork  RealtimeSystem) 

; definition of RealtimeSystemAttribute

(subclass RealtimeSystemAttribute Attribute)   
(documentation RealtimeSystemAttribute "The class of &%Attributes which 
describe instances of the class &%RealtimeSystem.") 

; definition of SystemBehaviorAttribute    

(subclass SystemBehaviorAttribute RealtimeSystemAttribute) 
(documentation SystemBehaviorAttribute "A subclass of 
&%RealtimeSystemAttribute, which includes the following &%Attributes: 
&%Periodic-SystemBehavior, &%Transient-SystemBehavior, and 
&%Hybrid-SystemBehavior.")

; definition of systemBehavior 

(subrelation systemBehavior property)   
(domain systemBehavior 1 RealtimeSystem)
(domain systemBehavior 2 SystemBehaviorAttribute)
(documentation systemBehavior "(&%systemBehavior ?System ?Attribute) 
holds if ?Attribute is a SystemBehaviorAttribute which describes the 
&%RealtimeSystem ?System.") 

; definition of Periodic-SystemBehavior 

(subclass Periodic-SystemBehavior SystemBehaviorAttribute)
(documentation Periodic-SystemBehavior "An instance of the class 
&%RealtimeSystem is described as a system with &%Periodic-SystemBehavior 
when it is activated at regular intervals.")

; definition of Transient-SystemBehavior 

(subclass Transient-SystemBehavior SystemBehaviorAttribute)
(documentation Transient-SystemBehavior "An instance of the class 
&%RealtimeSystem shows &%Transient-SystemBehavior when it is 
activated by sporadic events.")

; definition of Hybrid-SystemBehavior 

(subclass Hybrid-SystemBehavior SystemBehaviorAttribute)
(subAttribute Hybrid-SystemBehavior Transient-SystemBehavior)
(subAttribute Hybrid-SystemBehavior Periodic-SystemBehavior)
(documentation Hybrid-SystemBehavior "An instance of the class 
&%RealtimeSystem shows &%Hybrid-SystemBehavior if it is 
activated by transient events, i.e. it is executed at regular 
intervals when activated, and is deactivated by action completion.") 

; definition of DesignPatternAttribute

(subclass DesignPatternAttribute RealtimeSystemAttribute) 
(documentation DesignPatternAttribute "This is a subclass of 
&%RealtimeSystemAttribute, which includes &%Guidance-DesignPattern, 
&%Initiation-DesignPattern, and &%Assessment-DesignPattern.") 

; definition of designPattern 

(subrelation designPattern property)   
(domain designPattern 1 RealtimeSystem) 
(domain designPattern 2 DesignPatternAttribute) 
(documentation designPattern "(&%designPattern ?System ?Attribute) holds 
if ?Attribute is a &%DesignPatternAttribute which describes the 
&%RealtimeSystem ?System.") 

; definition of Guidance-DesignPattern 

(subclass Guidance-DesignPattern DesignPatternAttribute)
(documentation Guidance-DesignPattern "Instances of &%RealtimeSystems 
are described as systems with &%Guidance-DesignPattern if they consist 
of sensors connected to a software module that filters data from the 
sensors and sends the filtered data to a software module that evaluates 
the filtered data and sends instructions to a software module that 
commands actuators.  The design pattern is an event source that produces 
events and a data source that produces data, both executing in parallel 
and handled by a single event-driven periodic data handler.  The two 
separate input streams have fundamentally different characteristics.  
The event stream is necessarily asychronous, or transient.  Once an 
event is sensed, the handler accepts data from the data stream, which 
has an invariant cycle time.  There are two deadlines for a real-time 
guidance system.  The period deadline is the time to process all elements 
in the data stream once and generate an actuator command.  The action 
completion deadline is the time to guide the actuator to completion of 
the action.")

(=>
	(designPattern ?System Guidance-DesignPattern)
	(systemBehavior ?System Transient-SystemBehavior))

; definition of Initiation-DesignPattern 

(subclass Initiation-DesignPattern DesignPatternAttribute)
(documentation Initiation-DesignPattern "An instance of the class 
&%RealtimeSystem has &%Initiation-DesignPattern if it consists of 
one software module and the actuators it commands.  The design pattern 
is an event source which produces events for an event handler.  The 
event source is typically an evaluate-and-decide software module.  
The event stream is necessarily asychronous, or transient.  The arrival 
rate of events may vary and is unbounded.  Events may be either 
homogeneous or heterogeneous.  The workload per event for homogeneous 
events is constant.  The workload per event for heterogeneous events 
is a function of each event type.  There is one deadline for real-time 
action initiation systems.  It is the upper bound on the time to 
generate a command for the actuator.")

(=>
	(designPattern ?System Initiation-DesignPattern)
	(systemBehavior ?System Transient-SystemBehavior))

; definition of Assessment-DesignPattern 

(subclass Assessment-DesignPattern  DesignPatternAttribute)
(documentation Assessment-DesignPattern "An instance of the class 
&%RealtimeSystem has &%Initiation-DesignPattern if it consists of 
sensors connected to a software module that filters data from the 
sensors and sends the filtered data to another software module that 
evaluates the filtered data and sends decisions to a subsystem.  
The design pattern is a data source that produces a data stream for 
a data handler.  The data source is typically a periodically sampled 
collection of sensors.  The data stream's size may vary and is 
unbounded.  Data may be either homogeneous or heterogeneous.  The 
workload per data element for homogeneous data is constant.  The 
workload per data element for heterogeneous data is a function of 
each element type.  There is one deadline for real-time situation 
assessment systems.  It is the upper bound on the time to process 
all elements in the data stream once.")

; definition of TaskRelationAttribute 

(subclass TaskRelationAttribute Attribute)   
(documentation TaskRelationAttribute "This is a subclass of 
&%RealtimeSystemAttribute, which includes &%Independent-TaskRelation 
and &%Dependent-TaskRelation.")

; definition of taskRelation 

(subrelation taskRelation property)
(domain taskRelation 1 RealtimeSystem) 
(domain taskRelation 2 TaskRelationAttribute) 
(documentation taskRelation "(&%taskRelation ?System ?Attribute) holds 
if ?Attribute is a &%TaskRelationAttribute which describes the 
&%RealtimeSystem ?System.") 

; definition of Independent-TaskRelation 

(subclass Independent-TaskRelation  TaskRelationAttribute)
(documentation Independent-TaskRelation "An instance of &%RealtimeSystem 
is described as &%Independent-TaskRelation if its correct execution 
does not depend on the inputs from any other function, the execution state 
of any other function, or the acceptance of its outputs by any other 
function.")

; definition of Dependent-TaskRelation 

(instance Dependent-TaskRelation TaskRelationAttribute) 
(documentation Dependent-TaskRelation "An instance of &%RealtimeSystem 
is described as &%Dependent-TaskRelation if it depends on at least one 
other function in the system; that is, its correct execution depends on 
the input from another function, the execution state of another function, 
or the acceptance of its outputs by another function.")

; definition of FormOfAdaptationAttribute 

(subclass FormOfAdaptationAttribute Attribute)   
(documentation FormOfAdaptationAttribute "A subclass of 
&%RealtimeSystemAttribute, which includes &%Precision-FormOfAdaptation, 
&%Slack-FormOfAdaptation, &%Concurrency-FormOfAdaptation, and 
&%ResourceAllocation-FormOfAdaptation.")

; definition of formOfAdaptation 

(subrelation formOfAdaptation property)   
(domain formOfAdaptation 1 RealtimeSystem) 
(domain formOfAdaptation 2 FormOfAdaptationAttribute )
(documentation formOfAdaptation "(&%formOfAdaptation ?System ?Attribute) 
holds if ?Attribute is a &%FormOfAdaptationAttribute which describes the 
&%RealtimeSystem ?System.") 

; definition of Precision-FormOfAdaptation 


(subclass Precision-FormOfAdaptation FormOfAdaptationAttribute) 

; definition of Slack-FormOfAdaptation 

(subclass Slack-FormOfAdaptation FormOfAdaptationAttribute) 
(documentation Slack-FormOfAdaptation "The attribute &%Slack-FormOfAdaptation 
applies to real-time systems that are designed and implemented with enough 
resource overhead that the system can always adapt by utilizing the overhead 
without complicated decision making.")

; definition of Concurrency-FormOfAdaptation 

(subclass Concurrency-FormOfAdaptation FormOfAdaptationAttribute) 
(documentation Concurrency-FormOfAdaptation "This attribute applies to 
real-time systems that are designed and implemented so that the system 
can adapt by replicating the system components and executing them 
concurrently.")

; definition of ResourceAllocation-FormOfAdaptation 

(subclass ResourceAllocation-FormOfAdaptation FormOfAdaptationAttribute)
(documentation ResourceAllocation-FormOfAdaptation "This attribute applies 
to real-time systems that are designed and implemented so that the system 
can adapt under the control of a resource allocation manager like Desiderata.")

; definition of TimingRequirementAttribute

(subclass TimingRequirementAttribute RealtimeSystemAttribute) 
(documentation TimingRequirementAttribute "A subclass of 
&%RealtimeSystemAttribute which includes &%ComplexityAttribute, 
&%StrictnessAttribute, and &%AbstractionLevelAttribute.") 

; definition of granularity 

(instance granularity BinaryPredicate)   
(domain granularity 1 RealtimeSystem) 
(domain granularity 2 TimeDuration)
(documentation granularity  "Granularity is a sub-property of the 
timing requirements property of real-time systems.  Granularity is 
defined by how a timing requirement is specified in units of time.")

; definition of ComplexityAttribute   

(subclass ComplexityAttribute TimingRequirementAttribute)
(documentation ComplexityAttribute "A subclass of 
&%TimingRequirementAttribute, which includes
&%MultipleRequirement-Complexity and &%SingleRequirement-Complexity.")

; definition of complexity 

(subrelation complexity property)   
(domain complexity 1 RealtimeSystem) 
(domain complexity 2 TimingRequirementAttribute)
(documentation complexity "(&%complexity ?System ?Attribute) holds if 
?Attribute is a &%TimingRequirementAttribute which describes the 
&%RealtimeSystem ?System.") 

; definition of SingleRequirement-Complexity 

(subclass SingleRequirement-Complexity  ComplexityAttribute) 
(documentation SingleRequirement-Complexity  "An attribute that  describes 
instances of &%RealtimeSystems which require a single timing requirement,
either a bound for completion time for systems with 
&%Transient-SystemBehavior or cycle deadline for systems with 
&%Periodic-SystemBehavior.")

(=>
	(systemBehavior ?System Transient-SystemBehavior)
	(complexity ?System SingleRequirement-Complexity))

(=>
	(systemBehavior ?System Periodic-SystemBehavior)
	(complexity ?System SingleRequirement-Complexity))

; definition of MultipleRequirement-Complexity 

(subclass MultipleRequirement-Complexity ComplexityAttribute)
(documentation MultipleRequirement-Complexity "An attribute that describes 
instances of &%RealtimeSystems which require multiple timing requirements, 
both a bound for completion time for its transient behavior and a cycle 
deadline for its periodic behavior.")

(=>
	(systemBehavior ?System Hybrid-SystemBehavior)
	(complexity ?System MultipleRequirement-Complexity))

; definition of StrictnessAttribute 

(subclass StrictnessAttribute TimingRequirementAttribute)
(documentation StrictnessAttribute "This is a subclass of 
&%TimingRequirementAttribute, which includes &%Hard-Strictness, 
&%Firm-Strictness, &%Soft-Strictness, &%Importance-Strictness,
&%Utility-Strictness, and &%Hybrid-Strictness") 

; definition of strictness 

(subrelation strictness property)   
(domain strictness 1 RealtimeSystem) 
(domain strictness 2 StrictnessAttribute) 
(documentation strictness "(&%strictness ?System ?Attribute) holds if 
the &%StrictnessAttribute ?Attribute describes the &%RealtimeSystem 
?System.") 

; definition of Hard-Strictness 

(subclass Hard-Strictness StrictnessAttribute) 
(documentation Hard-Strictness "An attribute that applies to a 
&%RealtimeSystem just in case all deadlines are met.")

; definition of Firm-Strictness 

(subclass Firm-Strictness StrictnessAttribute) 
(documentation Firm-Strictness "An attribute that applies to a 
&%RealtimeSystem just in case a fixed percentage of requirements 
is met.")

; definition of Soft-Strictness 

(subclass Soft-Strictness StrictnessAttribute) 
(documentation Soft-Strictness "An attribute that applies to a 
&%RealtimeSystem just in case it  maximizes the number of timing 
requirements like deadlines that are met but does not guarantee that 
all such requirements will be met or any fixed percentage of 
requirements will be met.")

; definition of Importance-Strictness   

(subclass Importance-Strictness StrictnessAttribute) 
(documentation Importance-Strictness "An attribute that applies to a 
&%RealtimeSystem just in case it is designed and implemented to meet 
the more important requirements first.")

; definition of Utility-Strictness 

(subclass Utility-Strictness StrictnessAttribute) 
(documentation Utility-Strictness "An attribute that applies to a 
&%RealtimeSystem just in case it is designed and implemented to use 
a utility-computing function, which is applied to competing timing 
requirements to determine which should be met because meeting the 
requirement produces higher utility as defined by the function.")

; definition of Hybrid-Strictness 

(subclass Hybrid-Strictness StrictnessAttribute)
(documentation Hybrid-Strictness "An attribute that applies to a 
&%RealtimeSystem just in case the strictness of the system is a 
combination of &%Hard/Firm/Soft-Strictness with &%Importance-Strictness 
or a combination of &%Utility-Strictness with &%Importance-Strictness.")

(=>
	(strictness ?System Hybrid-Strictness)
	(or
		(and
			(strictness ?System Importance-Strictness)
			(strictness ?System Utility-Strictness))
		(and
			(strictness ?System Importance-Strictness)
			(strictness ?System Hard-Strictness))
		(and
			(strictness ?System Importance-Strictness)
			(strictness ?System Firm-Strictness))
		(and
			(strictness ?System Importance-Strictness)
			(strictness ?System Soft-Strictness))))

; definition of AbstractionLevelAttribute 

(subclass AbstractionLevelAttribute TimingRequirementAttribute)
(documentation AbstractionLevelAttribute "This is a subclass of 
&%TimingRequirementAttribute, which includes &%Instrument-AbstractionLevel, 
&%Method-AbstractionLevel, &%Object-AbstractionLevel, &%Task-AbstractionLevel,
and &%TaskGroup-AbstractionLevel.") 

; definition of abstractionLevel 

(subrelation abstractionLevel property)   
(domain abstractionLevel 1 RealtimeSystem)
(domain abstractionLevel 2 AbstractionLevelAttribute) 

; definition of Instrument-AbstractionLevel 

(subclass Instrument-AbstractionLevel AbstractionLevelAttribute) 
(documentation Instrument-AbstractionLevel "The attribute 
&%Instrument-AbstractionLevel is the lowest level of abstraction, 
which can be used to describe a real-time system or subsystem.")

; definition of Method-AbstractionLevel 

(subclass Method-AbstractionLevel AbstractionLevelAttribute) 
(documentation Method-AbstractionLevel  "The attribute 
&%Method-AbstractionLevel is the next to the lowest level of 
abstraction that can be used to describe a real-time system or 
subsystem.  This is at the level of describing every callable 
function (or method in an object-oriented language) implemented 
in software.")

; definition of Object-AbstractionLevel 

(subclass Object-AbstractionLevel AbstractionLevelAttribute) 
(documentation Object-AbstractionLevel "The attribute 
&%Object-AbstractionLevel is immediately above the attribute 
&%Method-AbstractionLevel and can be used to describe a real-time 
system or subsystem.  This is at the level of describing every software 
object that can be created from a class together with its data structures 
and methods (which define the interface for manipulating the object).")

; definition of Task-AbstractionLevel

(subclass Task-AbstractionLevel AbstractionLevelAttribute) 
(documentation Task-AbstractionLevel "The attribute 
&%Task-AbstractionLevel is immediately above the attribute 
&%Object-AbstractionLevel and can be used to describe a real-time 
system or subsystem.  This is at the level of describing the major 
tasks that are carried out by the real-time systems and are typically 
executable as individual processes.  The description of a task would 
consist of listing all the software objects used to perform the task.")

; definition of TaskGroup-AbstractionLevel 

(subclass TaskGroup-AbstractionLevel AbstractionLevelAttribute) 
(documentation TaskGroup-AbstractionLevel "The attribute 
&%TaskGroup-AbstractionLevel is immediately above the attribute 
&%Task-AbstractionLevel and can be used to describe a real-time 
system or subsystem This is at the level of describing groups of 
tasks which are related or connected by the real-time systems and 
are typically part of a concurrently executing path.")

;; definition of memorySize

(subrelation memorySize measure)
(domain memorySize 1 ComputationalSystem)
(domain memorySize 2 ConstantQuantity)
(documentation memorySize "(&%memorySize ?System ?Size) holds if 
?Size is the required memory size for the &%ComputationalSystem 
?System.")

;; definition of Sensor

(subclass Sensor ComputerHardware)
(documentation Sensor "&%Sensors include software that measures any 
attribute of executing computer programs or collections of executing 
programs, such as CPU utilization, aka load, memory utilization, I/O, 
overall task performance, network load and latency, etc.")

;; definition of UniformResourceIdentifier

(subclass UniformResourceIdentifier ContentBearingObject)
(exhaustiveDecomposition UniformResourceIdentifier UniformResourceLocator UniformResourceName) 
(documentation UniformResourceIdentifier  "A &%UniformResourceIdentifier 
(URI) is a compact string of characters for identifying an abstract or 
physical resource. A URI can be further classified as a locator, a name, 
or both (source: http://www.ietf.org/rfc/rfc2396.txt).") 

(=>
	(instance ?URI UniformResourceIdentifier)
	(exists (?Resource)
		(and
			(instance ?Resource ComputerData)
			(refers ?URI ?Resource)))) 

;; definition of UniformResourceLocator

(subclass UniformResourceLocator UniformResourceIdentifier)
(documentation UniformResourceLocator  "The term &%UniformResourceLocator 
(URL) refers to the subset of URI that identify resources via a 
representation of their primary access mechanism (e.g., their network 
location), rather than identifying the resource by name or by some other 
attribute(s) of that resource (source: http://www.ietf.org/rfc/rfc2396.txt).") 

(=>
	(instance ?URL UniformResourceLocator)
	(exists (?Address)
		(and
			(instance ?Address IPAddress)
			(represents ?URL ?Address)))) 

;; definition of UniformResourceName

(subclass UniformResourceName UniformResourceIdentifier)
(documentation UniformResourceName "The term UniformResourceName (URN) 
refers to the subset of URI that are required to remain globally unique 
and persistent even when the resource ceases to exist or becomes 
unavailable (source: http://www.ietf.org/rfc/rfc2396.txt).")

;; definition of DataSink

(subclass DataSink ComputerInputDevice)
(documentation ComputerHardware "A device or part of the computer that 
receives data.")

(=>
	(instance ?Sink DataSink)
	(exists (?Transfer)
		(and
			(instance ?Transfer DataTransfer)
			(destination ?Transfer ?Sink))))

;; definition of ComputerUser

(subclass ComputerUser CognitiveAgent)
(documentation ComputerUser "Any individual who interacts with a 
computer.") 

(=>
	(instance ?User ComputerUser)
	(exists (?Computer)
		(and
			(instance ?Computer Computer)
			(uses ?User ?Computer))))

;; definition of UserRequest

(subclass UserRequest ComputerProcess)
(documentation UserRequest "A request made by a &%ComputerUser, such as 
looking up a customer record.")

(=>
	(instance ?Request UserRequest)
	(exists (?User)
		(and
			(instance ?User ComputerUser)
			(agent ?Request ?User))))

;; definition of ComputerResponse

(subclass ComputerResponse ComputerProcess)
(documentation ComputerResponse "A &%ComputerProcess which attempts to 
comply with a user's request.")

;; definition of computerResponseTo

(instance computerResponseTo BinaryPredicate)
(domain computerResponseTo 1 ComputerResponse)
(domain computerResponseTo 2 UserRequest)
(documentation computerResponseTo "(&%computerResponseTo ?Response ?Request) means that 
?Response is a &%ComputerResponse to the &%UserRequest ?Request.")

;;definition of responseTime

(instance responseTime BinaryPredicate)
(domain responseTime 1 UserRequest) 
(domain responseTime 2 TimeDuration)
(documentation responseTime "The time it takes for the computer to comply 
with a user's request, such as looking up a customer record.")

(=>
	(and
		(responseTime ?Request ?Time)
		(computerResponseTo ?Response ?Request))
	(duration (WhenFn ?Response) ?Time))

;; definition of responseRate

(subrelation responseRate frequency)
(domain responseRate 1 ComputerResponse)
(domain responseRate 2 TimeDuration) 
(documentation responseRate "(&%responseRate ?Response ?Period) means 
that ?Period is the period at which the computer sends its ?Response.") 

;; definition of requestRate

(subrelation requestRate frequency)
(domain requestRate 1 UserRequest)
(domain requestRate 2 TimeDuration) 
(documentation requestRate "(&%requestRate ?Request ?Period) means that 
?Period is the period at which the user sends its ?Request.")

;; definition of Multitasking

(subclass Multitasking ComputerProcess)
(documentation Multitasking "The running of two or more programs in one 
computer at the same time. The number of programs that can be effectively 
multitasked depends on the type of multitasking performed (preemptive vs 
cooperative), CPU speed and memory and disk capacity.")

(=>
	(instance ?Process Multitasking)
	(exists (?Program1 ?Program2)
		(and
			(programRunning ?Process ?Program1)
			(programRunning ?Process ?Program2)
			(not (equal ?Program1 ?Program2)))))

;; definition of ComputerTask

(subclass ComputerTask ComputerProcess)
(documentation ComputerTask "In a multitasking environment, an 
independently running program or subprogram. Each task is assigned 
a task number.")

(=>
	(instance ?Task ComputerTask)
	(exists (?Program ?Process)
		(and
			(part ?Task ?Process)
			(instance ?Process Multitasking)
			(programRunning ?Task ?Program))))

;; definition of ComputerResource

(subclass ComputerResource ComputationalSystem) 
(documentation ComputerResource "One element of hardware, software or data 
that is part of a larger system.  For example, network resources are the 
available servers and printers in the network. Software resources can be 
programs, utilities or even smaller elements within a program. Data 
resources are the files and databases that can be accessed.")

(=>
        (instance ?Resource ComputerResource)
	(exists (?System)
		(and
			(instance ?System ComputationalSystem)
			(part ?Resource ?System))))

;; definition of NetworkResource

(subclass NetworkResource ComputerResource)
(documentation NetworkResource "Network resources are the available 
servers and printers in the network.")

(=>
	(instance ?Resource NetworkResource)
	(or
		(instance ?Resource Server)
		(instance ?Resource Printer)))

;; definition of Printer  

(subclass Printer ComputerOutputDevice)
(documentation Printer "A device that converts computer output into 
printed images.") 

;; definition of Server

(subclass Server ComputationalSystem)
(documentation Server "A computer in a network shared by multiple users. 
The term may refer to both the hardware and software or just the software 
that performs the service.") 

;; definition of load

(subrelation load measure)
(domain load 1 ComputerComponent)
(domain load 2 ConstantQuantity)
(documentation load "In performance measurement, the current use of a 
system as a percentage of total capacity.")

(=>
	(load ?System ?Load)
	(exists (?Event)
		(performanceResult ?Event ?System ?Load)))

;; definition of ComputerData

(subclass ComputerData ContentBearingObject)
(documentation ComputerData "The term &%ComputerData refers to files 
and databases, text documents, and images.")

(=>
	(instance ?Data ComputerData)
	(exists (?Hardware)
		(and
			(instance ?Hardware ComputerHardware)
			(located ?Data ?Hardware))))

;; definition of Image

(subclass ImageFile ComputerData)

(documentation ImageFile "A picture (graphic) stored in a particular 
coding scheme and stored as a file.  Note that this can include vector as 
well as raster images.  Raster images will entail a particular number of 
horizontal and vertical pixels.  Vector images will not entail a 
particular size or resolution.") 

;; definition of Database

(subclass Database ComputerData)
(documentation Database "A set of related files that is created and 
managed by a database management system (DBMS).") 

;; definition of dataProcessed

(subrelation dataProcessed patient)
(domain dataProcessed 1 ComputerProcess)
(domain dataProcessed 2 ComputerData)
(documentation dataProcessed "The data being processed during a 
&%ComputerProcess.") 

;; definition of Abort

(subclass Abort ComputerProcess)
(documentation Abort "To exit a function or application without saving 
any data that has been changed.")

;; definition of processAborted

(instance processAborted BinaryPredicate)
(instance processAborted AsymmetricRelation)
(domain processAborted 1 Abort)
(domain processAborted 2 ComputerProcess)
(documentation processAborted "(&%processAborted ?Abort ?Process) means 
that the &%ComputerProcess ?Process is aborted as the result of ?Abort.")

(=>
	(and
		(processAborted ?Abort ?Process)
		(dataProcessed ?Process ?Data))
	(not (exists (?Save)
	     (and
		(instance ?Save DataSaving)
		(dataProcessed ?Save ?Data)))))

;; definition of DataSaving

(subclass DataSaving ComputerProcess)
(documentation DataSaving "A process of copying the document, record or 
image being worked on onto a storage medium. Saving updates the file by 
writing the data that currently resides in memory (RAM) onto disk or tape. 
Most applications prompt the user to save data upon exiting.")

(=>
	(instance ?Save DataSaving)
	(exists (?Data)
		(dataProcessed ?Save ?Data)))

;; definition of DataCompression

(subclass DataCompression ComputerProcess) 
(documentation DataCompression "Encoding data to take up less storage 
space.")

(=>
	(and
		(instance ?Compression DataCompression)
		(dataProcessed ?Compression ?Data)
		(holdsDuring (ImmediatePastFn (WhenFn ?Compression)) 
			     (memorySize ?Data (MeasureFn ?Memory ?Measure)))
		(holdsDuring (ImmediateFutureFn (WhenFn ?Compression)) 
			     (memorySize ?Data (MeasureFn ?NewMemory ?Measure))))
	(lessThan ?NewMemory ?Memory)) 

;; definition of ProcessTask

(subclass ProcessTask Abstract)
(documentation ProcessTask "A function to be performed.") 

(=>
	(instance ?Task ProcessTask)
	(exists (?Process)
		(task ?Process ?Task)))

;; definition of task

(instance task BinaryPredicate)
(instance task AsymmetricRelation)
(domain task 1 ComputerProcess)
(domain task 2 ProcessTask) 
(documentation task "(&%task ?Process ?Task) means that ?Task is a function to 
be performed by the &%ComputerProcess ?Process.")

;; definition of UsingAResource

(subclass UsingAResource ComputerProcess)
(documentation UsingAResource "A &%ComputerProcess which requires access to a 
&%ComputerResource.") 

(=>
	(instance ?Using UsingAResource)
	(exists (?Resource)
		(resourceUsed ?Using ?Resource)))


(=>
	(and
		(instance ?Using UsingAResource)
		(resourceUsed ?Using ?Resource)
		(agent ?Using ?Agent))
	(uses ?Agent ?Resource))

;; definition of ReusingAResource

(subclass ReusingAResource ComputerProcess)
(documentation ReusingAResource "To use the same resource again.")

(=>
	(instance ?Using ReusingAResource)
	(exists (?Resource)
		(resourceUsed ?Using ?Resource)))

(=>
	(and
		(instance ?Reusing ReusingAResource)
		(resourceUsed ?Reusing ?Resource))
	(exists (?Using)
		(and
			(instance ?Using UsingAResource)
			(resourceUsed ?Using ?Resource)
			(earlier (WhenFn ?Using) (WhenFn ?Reusing)))))

;; definition of resourceUsed

(subrelation resourceUsed patient)
(domain resourceUsed 1 ComputerProcess)
(domain resourceUsed 2 ComputerResource)
(documentation resourceUsed "(&%resourceUsed ?Process ?Resource) means that the 
&%ComputerProcess ?Process has access to the &%ComputerResource ?Resource.")

;; definition of imageResolution

(instance imageResolution BinaryPredicate)
(domain imageResolution 1 ImageFile)
(domain imageResolution 2 PhysicalQuantity)
(documentation imageResolution "The degree of sharpness of a displayed or printed 
image.") 

;; Optimization 

(subclass Optimization ProcessTask)
(disjoint Optimization SatisfyingRequirements)
(documentation Optimization "Optimization means finding the best solution according 
to a set of criteria. For a computer program, an optimal solution would be the 
fastest program (according to some benchmark) or the smallest program.") 

;; definition of  SatisfyingRequirements 

(subclass SatisfyingRequirements ProcessTask)
(documentation SatisfyingRequirements "&%SatisfyingRequirements covers cases of 
finding a solution that satisfies necessary conditions.") 

;; Utility

(subclass Utility ComputerProgram)
(documentation Utility "A program that performs a specific task related to the 
management of computer functions, resources, or files. Utility programs range 
from the simple to the sophisticated, and many programmers specialize in producing 
and distributing them as shareware.  There are utilities that perform file and 
directory management, data compression, disk defragmentation and repair, system 
diagnostics, graphics viewing, and system security, for example. Many utilities 
are written as memory-resident programs meant to serve as adjuncts to operating 
systems. Many operating systems incorporate such popular utility functions as 
undeleting, password protection, memory management, virus protection, and file 
compression.")

;; UserAccount

(subclass UserAccount ContentBearingObject)
(documentation UserAccount "An established relationship between a user and a 
computer, network or information service. User accounts require a username and 
password, and new user accounts are given a default set of permissions.") 

(=>
	(instance ?Account UserAccount)
	(exists (?User)
		(hasAccount ?User ?Account)))

;; UserName

(subclass UserName SymbolicString)
(documentation UserName "The name a person uses to identify himself or herself 
when logging onto a computer system or online service.") 

(=>
	(hasAccount ?User ?Account)
	(exists (?Name)
		(userName ?User ?Name)))

;; userName

(subrelation userName names)
(instance userName AsymmetricRelation)
(domain userName 1 ComputerUser)
(domain userName 2 UserName)
(documentation userName "(&%userName ?Name ?User) means that ?Name is the name 
the &%ComputerUser uses to identify himself or herself when logging onto a 
computer system.")

;; hasAccount

(subrelation hasAccount possesses)
(instance hasAccount AsymmetricRelation)
(domain hasAccount 1 ComputerUser)
(domain hasAccount 2 UserAccount)
(documentation hasAccount "(&%hasAccount ?User ?Account) holds if ?User is 
assigned the &%UserAccount ?Account.")

;; ComputerPassword

(subclass ComputerPassword SymbolicString)
(documentation ComputerPassword "A word or code used to serve as a security 
measure against unauthorized access to data. It is normally managed by the 
operating system or DBMS.")

(=>
	(hasAccount ?User ?Account)
	(exists (?Password)
		(password ?Password ?User)))

;; password

(subrelation password names)
(instance password AsymmetricRelation)
(domain password 2 ComputerUser) 
(domain password 1 ComputerPassword)
(documentation password "(&%password ?Password ?User) means that ?Password is 
the password the &%ComputerUser uses while logging onto a computer system.")

;; definition of Report

(subclass Report ComputerData)
(documentation Report "A collection of data, presented in a preformatted 
manner.")

;; definition of hostStatus

(subrelation hostStatus attribute)
(domain hostStatus 1 Computer)
(domain hostStatus 2 ComputerStatus)
(documentation hostStatus "(&%hostStatus ?Computer ?Status) means that ?Status 
describes the status of the Computer, such as &%HostDown, &%HostReady.") 

;; definition of ComputerStatus

(subclass ComputerStatus Attribute)
(documentation ComputerStatus "An attribute which describes status of the 
&%Computer, such as &%HostDown, &%HostReady.")

;; definition of HostDown

(instance HostDown ComputerStatus)
(documentation HostDown "An attribute which applies to a computer that ceases to 
operate due to hardware or software failure.")

;; definition of HostReady

(instance HostReady ComputerStatus)
(documentation HostReady "An attribute which applies to a computer that is 
functional, operating properly, and ready to receive work requests.")

;; definition of hostJitter

(instance hostJitter BinaryPredicate)
(domain hostJitter 1 Computer)
(domain hostJitter 2 ConstantQuantity)
(documentation hostJitter "Interference on an analog line caused by a variation 
of a signal from its reference timing slots. Jitter can cause problems in the receipt 
of data and any subsequent processing of that data.")

;; definition of Epoch

(subclass Epoch TimePoint)
(documentation Epoch "An instant in time that is arbitrarily selected as a point 
of reference.")


;; definition of UnixEpoch

(instance UnixEpoch Epoch)
(documentation UnixEpoch "The Unix epoch or point of reference is 00:00:00 UTC, 
January 1, 1970.")

(equal UnixEpoch (SecondFn 0 (MinuteFn 0 (HourFn 0 (DayFn 1 (MonthFn 1 (YearFn 1970)))))))

;;  definition of collectRate

(subrelation collectRate frequency) 
(domain collectRate 1 ComputationalSystem)
(domain collectRate 2 TimeDuration)
(documentation collectRate "(&%collectRate ?System ?Period) holds if ?Period is 
the period at which &%ComputationalSystem ?System collects data.")

;;  definition of sendRate

(subrelation sendRate frequency) 
(domain sendRate 1 ComputationalSystem)
(domain sendRate 2 TimeDuration)
(documentation sendRate "(&%sendRate ?Program ?Period) holds if ?Period is the 
period at which the &%ComputationalSystem ?System sends data reports.")

;; definition of BerkeleySoftwareDistribution

(subclass BerkeleySoftwareDistribution OperatingSystem)
(documentation BerkeleySoftwareDistribution  "Berkeley Software Distribution (UNIX), 
a version of Unix distributed by the University of California at Berkeley. Widely 
used as a standard for early versions of Unix and Unix software libraries.")