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.  See also http://www.ontologyportal.org

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

(subclass ComputationalSystem Product)
(documentation ComputationalSystem EnglishLanguage "Instances of &%ComputationalSystems 
include instances of &%SoftwareSystems, &%HardwareSystems, and 
&%ComputerNetworks.")  
                          
(subclass Computer ElectricDevice)
(documentation Computer EnglishLanguage "A general-purpose machine that processes 
data according to a set of instructions that are stored internally 
either temporarily or permanently.") 

(subclass ComputerNetwork ComputationalSystem)
(documentation ComputerNetwork EnglishLanguage "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.")

(subclass LAN ComputerNetwork)
(disjointDecomposition LAN BusNetwork StarNetwork RingNetwork)
(documentation LAN EnglishLanguage "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.") 

(subclass BusNetwork LAN)
(documentation BusNetwork EnglishLanguage "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.")

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

(subclass RingNetwork LAN)
(documentation RingNetwork EnglishLanguage "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.")

(subclass ComputerHardware Product)
(documentation ComputerHardware EnglishLanguage "The hardware is the physical part of 
a computer system.")

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

(subclass ComputerMemory ComputerComponent)
(documentation ComputerMemory EnglishLanguage "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.") 

(subclass HardDiskDrive ComputerComponent)
(subclass HardDiskDrive DigitalDataStorageDevice)
(documentation HardDiskDrive EnglishLanguage "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.")

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

(=>
  (instance ?CPU CPU)
  (unitMeasuringPerformance ?CPU InstructionsPerSecond))

(subclass DataTransfer ComputerProcess)
(documentation DataTransfer EnglishLanguage "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 DigitalData)
			(instance ?System HardwareSystem)
			(instance ?Origin HardwareSystem)
			(instance ?Destination ComputationalSystem)))) 
			
;;DeletingData
(subclass DeletingData ComputerProcess)
(documentation DeletingData EnglishLanguage "A &%ComputerProcess that makes some &%DigitalData unusable for any other &%ComputerProcess.")

(=>
  (instance ?X DeletingData)
  (and
    (exists (?DATA)
      (and
        (instance ?DATA DigitalData)
        (patient ?X ?DATA)))
    (not
      (exists (?PROC ?CLASS)
        (and
          (instance ?PROC ComputerProcess)
          (instance ?PROC ?CLASS)
          (not
            (instance ?PROC RestoringData))
          (holdsDuring
            (ImmediateFutureFn
              (WhenFn ?X))
            (capability ?CLASS patient ?DATA)))))))

;;RestoringData
(subclass RestoringData ComputerProcess)
(documentation RestoringData EnglishLanguage "A &%ComputerProcess that makes &%DigitalData that has been deleted, again accessible for other &%ComputerProcess")

(=>
  (instance ?X RestoringData)
  (exists (?DEL ?PROC ?DATA ?CLASS)
    (and
      (instance ?DEL DeletingData)
      (instance ?DATA DigitalData)
      (patient ?X ?DATA)
      (patient ?DEL ?DATA)
      (earlier 
        (WhenFn ?DEL) 
        (WhenFn ?X))
      (instance ?PROC ComputerProcess)
      (instance ?PROC ?CLASS)
      (holdsDuring
        (ImmediateFutureFn
          (WhenFn ?X))
        (capability ?CLASS patient ?DATA))))) 
        
(subclass ComputerProcess InternalChange)
(documentation ComputerProcess EnglishLanguage "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)))

(subclass ComputerFile DigitalData)
(documentation ComputerFile EnglishLanguage "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.")

(subclass ComputerDirectory ComputerFile)
(documentation ComputerDirectory EnglishLanguage "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.")

(instance runningOn BinaryPredicate)
(domain runningOn 1 ComputerProgram)
(domain runningOn 2 Computer)
(documentation runningOn EnglishLanguage "(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))))

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

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

(instance directoryOf BinaryPredicate)
(domain directoryOf 1 ComputerFile)
(domain directoryOf 2 ComputerDirectory)

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

(instance AddressFn UnaryFunction)
(domain AddressFn 1 ComputerFile)
(range AddressFn PhysicalAddress)
(documentation AddressFn EnglishLanguage "(&%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)) 

(instance BitsPerSecond CompositeUnitOfMeasure)
(documentation BitsPerSecond EnglishLanguage "The measurement of the speed of data 
transfer in a communications system.")

(=>
  (equal ?MEASURE (MeasureFn ?NUMBER BitsPerSecond))
  (instance ?MEASURE TimeDependentQuantity))

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

(=>
  (equal ?MEASURE (MeasureFn ?NUMBER PacketsPerSecond))
  (instance ?MEASURE TimeDependentQuantity))
  
(instance InstructionsPerSecond CompositeUnitOfMeasure)
(documentation InstructionsPerSecond EnglishLanguage "The measure of the processing 
speed of a &%Computer's &%CPU.")

(=>
  (equal ?MEASURE (MeasureFn ?NUMBER InstructionsPerSecond))
  (instance ?MEASURE TimeDependentQuantity))

(subclass Packet DigitalData)
(documentation Packet EnglishLanguage "A block of &%DigitalData used for transmission in packet 
switched systems.")

;; The following constants are specific to the Quite project

(subclass SoftwareSystem ComputerProgram)
(documentation SoftwareSystem EnglishLanguage "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)))))

(subclass HardwareSystem ComputerHardware)
(subclass HardwareSystem ComputationalSystem)
(documentation HardwareSystem EnglishLanguage "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))
  (and
    (instance ?Network ComputerNetwork)
    (instrument ?Event ?Network)))

(instance runsOn BinaryPredicate)
(instance runsOn AsymmetricRelation)
(domain runsOn 1 ComputerProgram)
(domain runsOn 2 Computer)
(documentation runsOn EnglishLanguage "(runsOn ?Program ?Computer) means that ?Program 
is capable of running on ?Computer with its current configuration of installed software.")

(=>
  (and
    (programRunning ?Process ?Program)
    (computerRunning ?Process ?Computer))
  (runsOn ?Program ?Computer))

(instance canRunOn BinaryPredicate)
(instance canRunOn AsymmetricRelation)
(domainSubclass canRunOn 1 ComputerProgram)
(domainSubclass canRunOn 2 Computer)
(documentation canRunOn EnglishLanguage "A weaker relation than &%runOn that
says merely that a properly configured computer should be able to run the
given software.")

(=>
  (and
    (programRunning ?Process ?Program)
    (instance ?Program ?PC)
    (instance ?Computer ?CC)
    (computerRunning ?Process ?Computer))
  (canRunOn ?PC ?CC))
	
(subclass StartupBlock ComputerProgram)
(documentation StartupBlock EnglishLanguage "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.")

(instance startupOf BinaryPredicate)
(domain startupOf 1 StartupBlock)
(domain startupOf 2 ComputerProgram)
(documentation startupOf EnglishLanguage "(&%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))))  

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

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

(instance shutdownOf BinaryPredicate)
(domain shutdownOf 1 ShutdownBlock)
(domain shutdownOf 2 ComputerProgram)
(documentation shutdownOf EnglishLanguage "(&%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))))  

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

(subclass EnvironmentSoftwareAttribute RelationalAttribute)
(documentation EnvironmentSoftwareAttribute EnglishLanguage "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)
(instance environmentAttributes BinaryPredicate)
(domain environmentAttributes 1 ComputerProgram)
(domain environmentAttributes 2 EnvironmentSoftwareAttribute)
(documentation environmentAttributes EnglishLanguage "(&%environmentAttributes ?Program 
?Attribute) holds if ?Attribute is an &%EnvironmentSoftwareAttribute 
which describes the &%ComputerProgram ?Program.")

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

(subclass ComputerKeyboard ComputerInputDevice)
(documentation ComputerKeyboard EnglishLanguage "A &%ComputerInputDevice containing a set of 
keys and used to input different characters.")

(lexicon ComputerKeyboard LexNoun "keyboard")
 
(subclass ComputerOutputDevice ComputerHardware)

(documentation ComputerOutputDevice EnglishLanguage "Any peripheral that presents 
output from the computer, such as a screen or printer.")

(subclass ThreeDPrinter ComputerOutputDevice)
(documentation ThreeDPrinter EnglishLanguage "A &%ThreeDPrinter is a &%ComputerOutputDevice 
for the construction of a three-dimensional &%Object from a Computer-Aided Design (CAD) 
model or a digital 3D model. Three-dimensional models represent a physical body using 
a collection of points in 3D space, connected by various geometric entities such as
triangles, lines, curved surface etc. In a 3D printing process, material is deposited, 
joined or solidified under computer control, with the material being added together 
(such as plastics, liquids or powder grains being fused), typically layer by layer. [Wikipedia]")

(=>
  (instance ?X ThreeDPrinter)
  (hasPurpose ?X
    (exists (?P)
      (and
        (instance ?P ThreeDPrinting)
        (instrument ?P ?X)))))
        
(subclass ThreeDPrinting Making)
(documentation ThreeDPrinting EnglishLanguage "&%ThreeDPrinting is the &%Making
of a three-dimensional &%Object from a Computer-Aided Design (CAD) 3D
model or a digital 3D model.[Wikipedia]")

(=>
  (instance ?P ThreeDPrinting)
  (exists (?X ?A)
    (and
      (instance ?X DigitalData)
      (represents ?X ?A)
      (instance ?A Artifact)
      (result ?P ?A))))
      
(=>
  (and
    (instance ?P ThreeDPrinting)
    (instance ?X Substance)
    (resource ?P ?X))
  (exists (?R)
    (and
      (instance ?R Reservoir)
      (part ?R ?P)
      (origin ?P ?R)
      (located ?X ?R))))

(=>
  (and      
    (instance ?P ThreeDPrinting)
    (instance ?X CompoundSubstance)
    (patient ?P ?X))
  (exists (?SC)
    (and
      (instance ?SC ShapeChange)
      (subProcess ?SC ?P)
      (patient ?SC ?X))))
          
(=>
  (and
    (instance ?P ThreeDPrinting)
    (instance ?O Artifact)
    (result ?P ?O))
  (exists (?A ?X ?B ?Y)
    (and
      (instance ?A Making)
      (subProcess ?A ?P)
      (instance ?X SelfConnectedObject)
      (part ?X ?O)
      (result ?A ?X)
      (instance ?B Making)
      (subProcess ?B ?P)
      (instance ?Y SelfConnectedObject)
      (part ?Y ?O)
      (overlapsSpatially ?X ?Y)
      (orientation ?X ?Y Below)
      (during
        (WhenFn ?A)
        (WhenFn ?P))
      (during
        (WhenFn ?B)
        (WhenFn ?P))
      (earlier
        (WhenFn ?A)
        (WhenFn ?B)))))
        
(subclass Metallic3DPrinter ThreeDPrinter)
(documentation Metallic3DPrinter EnglishLanguage "A &%Metallic3DPrinter is 
&%3DPrinter using &%Metals as printing material.")

(=>
  (and
    (instance ?P ThreeDPrinting)
    (instance ?X Metal)
    (resource ?P ?X)
    (instrument ?P ?I))
  (instance ?I Metallic3DPrinter))
  
(subclass PlasticPrinter ThreeDPrinter)
(documentation Plastic3DPrinter EnglishLanguage "A &%Plastic3DPrinter is 
&%3DPrinter using &%Plastic as printing material.")

(=>
  (and
    (instance ?P ThreeDPrinting)
    (instance ?X Plastic)
    (resource ?P ?X)
    (instrument ?P ?I))
  (instance ?I PlasticPrinter))
 
(subclass TouchScreen ComputerInputDevice)
(subclass TouchScreen ComputerOutputDevice)
(subclass TouchScreen VideoDisplay)

(documentation TouchScreen EnglishLanguage "A display screen that also functions
as a pointing device by letting users touch on it")

(=>
  (instance ?TOUCHSCREEN TouchScreen)
  (attribute ?TOUCHSCREEN Flat))
 
(subclass ComputerTerminal ComputerOutputDevice)
(subclass ComputerTerminal DataDisplayDevice)
(documentation ComputerTerminal EnglishLanguage "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)
(instance standardInputDevice CaseRole)
(instance standardInputDevice BinaryPredicate)
(domain standardInputDevice 1 ComputerProcess)
(domain standardInputDevice 2 ComputerInputDevice)
(documentation standardInputDevice EnglishLanguage "(&%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)
(instance standardOutputDevice CaseRole)
(instance standardOutputDevice BinaryPredicate)
(domain standardOutputDevice 1 ComputerProcess)
(domain standardOutputDevice 2 ComputerOutputDevice)
(documentation standardOutputDevice EnglishLanguage "(&%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)))

(subrelation standardErrorDevice instrument)
(instance standardErrorDevice CaseRole)
(instance standardErrorDevice BinaryPredicate)
(domain standardErrorDevice 1 ComputerProcess)
(domain standardErrorDevice 2 ComputerOutputDevice)
(documentation standardErrorDevice EnglishLanguage "(&%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)))

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

(subclass ProcessState ContentBearingObject)
(documentation ProcessState EnglishLanguage "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))))))

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

(subclass AutomaticApplication ComputerProgram)
(documentation AutomaticApplication EnglishLanguage "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))) 


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

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

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

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

(instance rMProgramOf BinaryPredicate)
(domain rMProgramOf 1 ResourceManagementProgram)
(domain rMProgramOf 2 SoftwareSystem)
(documentation rMProgramOf EnglishLanguage "(&%rMProgramOf ?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" .

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

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

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

(instance startupTimeDelay BinaryPredicate)
(domain startupTimeDelay 1 ComputerProgram)
(domain startupTimeDelay 2 TimeDuration)
(documentation startupTimeDelay EnglishLanguage "(&%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."

(=>
  (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))
  (duration ?Time ?Delay))

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

(=>
	(instance ?Feedback Feedback)
	(exists (?RM ?Process ?Program ?Send)
		(and
			(rMProgramOf ?RM ?Program)
			(programRunning ?Process ?Program)
			(instance ?Send DataTransfer) 
			(patient ?Send ?Feedback)
			(destination ?Send ?RM))))

(instance processList Predicate)
(instance processList VariableArityRelation)		
(documentation processList EnglishLanguage "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))) 

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

(instance  minimumReplications BinaryPredicate)
(domain minimumReplications  1 ComputerProgram)
(domain minimumReplications  2 PositiveInteger)
(documentation minimumReplications EnglishLanguage "(&%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)) 

(instance maximumReplications BinaryPredicate)
(domain maximumReplications 1 ComputerProgram)
(domain maximumReplications 2 PositiveInteger)
(documentation maximumReplications EnglishLanguage "(&%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)))))

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

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

(instance portNumber BinaryPredicate)
(domain portNumber 1 ComputerProgram)
(domain portNumber 2 PositiveInteger)
(documentation portNumber EnglishLanguage "(&%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.")

(instance processID BinaryPredicate)
(domain processID 1 ComputerProcess)
(domain processID 2 PositiveInteger)
(documentation processID EnglishLanguage "(&%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.")

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

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

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

(subrelation status property)
(instance status BinaryPredicate)
(domain status 1 ComputerProcess)
(domain status 2 ProcessStatus)
(documentation status EnglishLanguage "(&%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)))
        
(subclass ComputerComponent ComputerHardware)
(documentation ComputerComponent EnglishLanguage "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.")

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

(subclass NetworkAdapter ComputerComponent)
(documentation NetworkAdapter EnglishLanguage "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))))

(instance unitMeasuringPerformance BinaryPredicate)
(domain unitMeasuringPerformance 1 ComputerComponent)
(domain unitMeasuringPerformance 2 UnitOfMeasure)
(documentation unitMeasuringPerformance EnglishLanguage "(&%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)) 

(subclass MonitoringProgram ComputerProgram)
(documentation MonitoringProgram EnglishLanguage "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))))

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

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

(subclass MeasuringPerformance ComputerProcess)
(documentation MeasuringPerformance EnglishLanguage "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)))) 

(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 EnglishLanguage "(&%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)) 

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

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

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

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

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

(instance monitorComponentData TernaryPredicate)
(domain monitorComponentData 1 TimePosition)
(domain monitorComponentData 2 SymbolicString)
(domain monitorComponentData 3 RealNumber)
(documentation monitorComponentData EnglishLanguage "(&%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)))) 

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

(instance monitorApplicationData BinaryPredicate)
(domain monitorApplicationData  1 TimePosition)
(domain monitorApplicationData  2 ComputerProgram)
(documentation monitorApplicationData EnglishLanguage "(&%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))))

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

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

(subclass OperatingSystem SoftwareSystem)
(termFormat EnglishLanguage OperatingSystem "OS")
(documentation OperatingSystem EnglishLanguage "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.")

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

(subclass Solaris OperatingSystem)
(documentation Solaris EnglishLanguage "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.")

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

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

;;
;; axioms deleted
;; Jennie Pease 17th October 2022
;;

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

(instance benchmarkPerformance TernaryPredicate)
(domain benchmarkPerformance 1 ComputationalSystem)
(domain benchmarkPerformance 2 MonitoringProgram)
(domain benchmarkPerformance 3 Quantity)
(documentation benchmarkPerformance EnglishLanguage "(&%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))))

(instance bandwidth BinaryPredicate)
(domain bandwidth 1 ComputerNetwork)
(domain bandwidth 2 FunctionQuantity)
(documentation bandwidth EnglishLanguage "(&%bandwidth ?NET ?BANDWIDTH) holds if
?BANDWIDTH is the amount of data which can be sent through an instance 
of a &%ComputerNetwork ?NET.")

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

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

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

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

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

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

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

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

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

(instance PathImportanceFunction ComputerPathAttribute)
(documentation PathImportanceFunction EnglishLanguage  "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.")

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

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

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

(subclass DeterministicDataStream ComputerPathAttribute) 
(documentation DeterministicDataStream EnglishLanguage "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)))

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

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

(subclass QuasicontinuousPath ComputerPathAttribute)
(documentation QuasicontinuousPath EnglishLanguage "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)))

(instance simpleDeadline BinaryPredicate)
(domain simpleDeadline 1 ComputerPath)
(domain simpleDeadline 2 TimeDuration)
(documentation simpleDeadline EnglishLanguage "(&%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.")

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

(instance batchInterArrival BinaryPredicate)
(domain batchInterArrival 1 ComputerPath)
(domain batchInterArrival 2 TimeDuration)
(documentation batchInterArrival EnglishLanguage "(&%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.")

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

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

(instance dataStreamSlack BinaryPredicate)
(domain dataStreamSlack 1 ComputerPath)
(domain dataStreamSlack 2 PositiveInteger)
(documentation dataStreamSlack EnglishLanguage "(&%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)))

(instance dependencyType BinaryPredicate)
(domain dependencyType 1 ComputerProgram)
(domainSubclass dependencyType 2 ComputerProgram)
(documentation dependencyType EnglishLanguage "(&%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)))

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

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

(instance dependencyDelay BinaryPredicate)
(domain dependencyDelay 1 ComputerProgram)
(domain dependencyDelay 2 TimeDuration)
(documentation dependencyDelay EnglishLanguage "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)) 

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

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

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

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

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

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

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

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

(subclass HardwareSystem RealtimeSystem) 
(subclass ComputerNetwork  RealtimeSystem) 

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

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

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

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

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

(subclass Hybrid-SystemBehavior SystemBehaviorAttribute)
(subAttribute Hybrid-SystemBehavior Transient-SystemBehavior)
(subAttribute Hybrid-SystemBehavior Periodic-SystemBehavior)
(documentation Hybrid-SystemBehavior EnglishLanguage "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.") 

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

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

(subclass GuidanceDesignPattern DesignPatternAttribute)
(documentation GuidanceDesignPattern EnglishLanguage "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))

(subclass InitiationDesignPattern DesignPatternAttribute)
(documentation InitiationDesignPattern EnglishLanguage "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 asynchronous, 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 InitiationDesignPattern)
	(systemBehavior ?System TransientSystemBehavior))

(subclass AssessmentDesignPattern  DesignPatternAttribute)
(documentation AssessmentDesignPattern EnglishLanguage "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.")

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

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

(subclass IndependentTaskRelation  TaskRelationAttribute)
(documentation IndependentTaskRelation EnglishLanguage "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.")

(instance DependentTaskRelation TaskRelationAttribute)
(documentation DependentTaskRelation EnglishLanguage "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.")

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

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

(subclass PrecisionFormOfAdaptation FormOfAdaptationAttribute)

(subclass SlackFormOfAdaptation FormOfAdaptationAttribute)
(documentation SlackFormOfAdaptation EnglishLanguage "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.")

(subclass ConcurrencyFormOfAdaptation FormOfAdaptationAttribute)
(documentation ConcurrencyFormOfAdaptation EnglishLanguage "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.")

(subclass ResourceAllocationFormOfAdaptation FormOfAdaptationAttribute)
(documentation ResourceAllocationFormOfAdaptation EnglishLanguage "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.")

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

(instance granularity BinaryPredicate)   
(domain granularity 1 RealtimeSystem) 
(domain granularity 2 TimeDuration)
(documentation granularity EnglishLanguage  "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.")

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

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

(subclass SingleRequirementComplexity ComplexityAttribute)
(documentation SingleRequirementComplexity EnglishLanguage  "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 
&%PeriodicSystemBehavior.")

(=>
	(systemBehavior ?System TransientSystemBehavior)
	(complexity ?System SingleRequirementComplexity))

(=>
	(systemBehavior ?System PeriodicSystemBehavior)
	(complexity ?System SingleRequirementComplexity))

(subclass MultipleRequirementComplexity ComplexityAttribute)
(documentation MultipleRequirementComplexity EnglishLanguage "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 HybridSystemBehavior)
	(complexity ?System MultipleRequirementComplexity))

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

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

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

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

(subclass SoftStrictness StrictnessAttribute)
(documentation SoftStrictness EnglishLanguage "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.")

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

(subclass UtilityStrictness StrictnessAttribute)
(documentation UtilityStrictness EnglishLanguage "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.")

(subclass HybridStrictness StrictnessAttribute)
(documentation HybridStrictness EnglishLanguage "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 HybridStrictness)
	(or
		(and
			(strictness ?System ImportanceStrictness)
			(strictness ?System UtilityStrictness))
		(and
			(strictness ?System ImportanceStrictness)
			(strictness ?System HardStrictness))
		(and
			(strictness ?System ImportanceStrictness)
			(strictness ?System FirmStrictness))
		(and
			(strictness ?System Importance-Strictness)
			(strictness ?System SoftStrictness))))

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

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

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

(subclass MethodAbstractionLevel AbstractionLevelAttribute)
(documentation MethodAbstractionLevel EnglishLanguage  "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.")

(subclass ObjectAbstractionLevel AbstractionLevelAttribute)
(documentation ObjectAbstractionLevel EnglishLanguage "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).")

(subclass TaskAbstractionLevel AbstractionLevelAttribute)
(documentation TaskAbstractionLevel EnglishLanguage "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.")

(subclass TaskGroupAbstractionLevel AbstractionLevelAttribute)
(documentation TaskGroupAbstractionLevel EnglishLanguage "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.")

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

(subclass Sensor ComputerHardware)
(documentation Sensor EnglishLanguage "&%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.")

(subclass UniformResourceIdentifier ContentBearingObject)
(exhaustiveDecomposition UniformResourceIdentifier UniformResourceLocator UniformResourceName) 
(documentation UniformResourceIdentifier EnglishLanguage  "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 DigitalData)
			(refers ?URI ?Resource)))) 

(subclass UniformResourceLocator UniformResourceIdentifier)
(documentation UniformResourceLocator EnglishLanguage  "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)))) 

(subclass UniformResourceName UniformResourceIdentifier)
(documentation UniformResourceName EnglishLanguage "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).")

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

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

(instance ComputerUser RelationalAttribute)
(documentation ComputerUser EnglishLanguage "Any individual who interacts with a 
computer.") 

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

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

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

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

(instance computerResponseTo BinaryPredicate)
(domain computerResponseTo 1 ComputerResponse)
(domain computerResponseTo 2 UserRequest)
(documentation computerResponseTo EnglishLanguage "(&%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 EnglishLanguage "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))

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

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

(subclass Multitasking ComputerProcess)
(documentation Multitasking EnglishLanguage "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)))))

(subclass ComputerTask ComputerProcess)
(documentation ComputerTask EnglishLanguage "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))))

(subclass ComputerResource ComputationalSystem) 
(documentation ComputerResource EnglishLanguage "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))))

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

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

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

(subclass Server ComputationalSystem)
(documentation Server EnglishLanguage "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.") 

(instance load BinaryPredicate)
(domain load 1 ComputerComponent)
(domain load 2 RealNumber)
(documentation load EnglishLanguage "In performance measurement, the current use of a 
system as a percentage of total capacity.")

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

(subclass DigitalData SymbolicString)
(documentation DigitalData EnglishLanguage "This term refers to any data that is
recorded, displayed, or stored as a string of &%BinaryNumbers.")

(=>
	(instance ?DATA DigitalData)
	(exists (?DEVICE)
		(and
			(instance ?DEVICE DigitalDataStorageDevice)
			(located ?DATA ?DEVICE))))

(subclass ImageFile DigitalData)
(documentation ImageFile EnglishLanguage "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.") 

(subclass Database DigitalData)
(documentation Database EnglishLanguage "A database is an organized collection of 
Data that is used for one or more purposes.  It is usually managed by some sort of 
Database Management System (DBMS).") 

(subrelation dataProcessed patient)
(instance dataProcessed CaseRole)
(instance dataProcessed BinaryPredicate)
(domain dataProcessed 1 ComputerProcess)
(domain dataProcessed 2 DigitalData)
(documentation dataProcessed EnglishLanguage "The data being processed during a 
&%ComputerProcess.") 

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

(instance processAborted BinaryPredicate)
(instance processAborted AsymmetricRelation)
(domain processAborted 1 Abort)
(domain processAborted 2 ComputerProcess)
(documentation processAborted EnglishLanguage "(&%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)))))

(subclass DataSaving ComputerProcess)
(documentation DataSaving EnglishLanguage "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)))

(=>
  (instance ?DSAVE DataSaving)
  (exists (?DSTORE)
    (and
      (instance ?DSTORE DataStorageDevice)
      (resource ?DSAVE ?DSTORE))))
    

(subclass DataCompression ComputerProcess) 
(documentation DataCompression EnglishLanguage "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))

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

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

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

(subclass UsingAResource ComputerProcess)
(documentation UsingAResource EnglishLanguage "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 ?Resource ?Agent))

(subclass ReusingAResource ComputerProcess)
(documentation ReusingAResource EnglishLanguage "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)))))

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

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

;; Optimization 

(subclass Optimization ProcessTask)
(disjoint Optimization SatisfyingRequirements)
(documentation Optimization EnglishLanguage "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 EnglishLanguage "&%SatisfyingRequirements covers cases of 
finding a solution that satisfies necessary conditions.") 

;; Utility

(subclass Utility ComputerProgram)
(documentation Utility EnglishLanguage "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 EnglishLanguage "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 EnglishLanguage "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 ?Account ?Name)))

;; userName

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

;; hasAccount

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

(=>
  (holdsDuring ?T
    (hasAccount ?A ?UA))
  (holdsDuring ?T
    (attribute ?A ComputerUser)))
    
;; ComputerPassword

(subclass ComputerPassword SymbolicString)
(documentation ComputerPassword EnglishLanguage "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 ?Account)))

;; password

(subrelation password names)
(instance password AsymmetricRelation)
(domain password 1 ComputerPassword)
(domain password 2 UserAccount) 

(documentation password EnglishLanguage "(&%password ?Password
?Account) means that ?Password is the password associated with the
&%UserAccount that the &%ComputerUser uses while logging onto a
computer system.")

(subclass ComputerReport DigitalData)
(documentation ComputerReport EnglishLanguage "A collection of data, presented in a preformatted 
manner.")

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

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

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

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

(instance hostJitter BinaryPredicate)
(domain hostJitter 1 Computer)
(domain hostJitter 2 ConstantQuantity)
(documentation hostJitter EnglishLanguage "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.")

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

(instance UnixEpoch Epoch)
(documentation UnixEpoch EnglishLanguage "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 January (YearFn 1970)))))))

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

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

(subclass BerkeleySoftwareDistribution OperatingSystem)
(documentation BerkeleySoftwareDistribution EnglishLanguage  "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.")

(subclass CodingScheme Procedure)
(documentation CodingScheme EnglishLanguage "A &%Procedure for &%Encoding and/or &%Decoding
information.  A coding scheme is often implemented as a &%ComputerProgram.
Some examples of coding schemes include MPEG, WAV, and pig-latin.")

(=>
  (and
    (instance ?P Encoding)
    (agent ?P ?A))
  (exists (?CODE)
    (or
      (knows ?A ?CODE)
      (exists (?OBJ)
        (and
          (instrument ?P ?OBJ)
          (containsInformation ?OBJ ?CODE))))))

(=>
  (and
    (instance ?P Decoding)
    (agent ?P ?A))
  (exists (?CODE)
    (or
      (knows ?A ?CODE)
      (exists (?OBJ)
        (and
          (instrument ?P ?OBJ)
          (containsInformation ?OBJ ?CODE))))))

(instance coding BinaryPredicate)
(instance coding PartialValuedRelation)
(documentation coding EnglishLanguage "A relation between a &%ContentBearingObject and a 
&%CodingScheme that specifies how the content is expressed.  Typically,
this will be used either for encoded secret communications or computer
files that might be coded simply for data compression instead of 
information security.")
(domain coding 1 ContentBearingObject)
(domain coding 2 CodingScheme)                                                                    
            
(instance filename BinaryPredicate)
(instance filename PartialValuedRelation)
(subrelation filename names)
(domain filename 1 SymbolicString)
(domain filename 2 DigitalData)

(documentation filename EnglishLanguage "A relation between a &%SymbolicString and an 
instance of &%DigitalData that specified the filename of the data on a 
particular computer file system.  This relation is for a fully qualified 
filename including a device specification such as a drive letter or name, 
a directory, and a name.  This can include names that are aliases for a 
different physical file location.  It does not include the specification 
of a particular machine on a network, such as an internet domain name, 
although it may reference a device specification that ultimately resolves 
to a storage device on a network.") 

(relatedInternalConcept filename directoryOf)

; documentation from QoSOntology.txt changed
(documentation directoryOf EnglishLanguage "(directoryOf ?FILE ?DIRECTORY) means that the 
ComputerFile ?FILE is in the ComputerDirectory ?DIRECTORY.  Note that the
directory of a file is a component of the fully qualified name specification
given to the relation &%filename.  Note also that the directory does not
include the specification of a machine location on the Internet.  See
&%filename for more information.") 

; Note this is just a "sketch" of the definitions of Mime types, which would
; need to be axiomatized
                                 
(subclass MimeEncodingScheme CodingScheme)
(documentation MimeEncodingScheme EnglishLanguage "A coding scheme and designator for
coding Internet messages, usually for consumption by web browsers.  The
scheme designator should conform to IETF RFC 2045.")
(subclass MimeText MimeEncodingScheme)
(subclass MimeEnrichedText MimeText)
(termFormat EnglishLanguage MimeEncodingScheme "MIME encoding scheme")
; many other subtypes should follow...

(subclass MimeImage MimeEncodingScheme)
(subclass MimeAudio MimeEncodingScheme)
(subclass MimeVideo MimeEncodingScheme)
(subclass MimeApplication MimeEncodingScheme)
(subclass MimeMessage MimeEncodingScheme)
(subclass MimeMultipart MimeEncodingScheme) 

(instance mimeType BinaryPredicate)
(instance mimeType PartialValuedRelation)
(subrelation mimeType coding)
(domain mimeType 2 MimeEncodingScheme)
(documentation mimeType EnglishLanguage "A relation between &%ComputerData and the 
MIME type it is coded in, with respect to IETF RFC 2045.")

(subclass EncodingProcedure Procedure)
(documentation EncodingProcedure EnglishLanguage "A &%Procedure for performing an
&%Encoding.")