QoSontology.gf

abstract QoSontology = MidLevelOntology, Engineering ** {

-- To exit a function or application without saving
-- any data that has been changed.
fun Abort : Class ;
fun Abort_Class : SubClass Abort ComputerProcess ;

-- This is a subclass of
-- TimingRequirementAttribute, which includes Instrument_AbstractionLevel,
-- Method_AbstractionLevel, Object_AbstractionLevel, Task_AbstractionLevel,
-- and TaskGroup_AbstractionLevel.
fun AbstractionLevelAttribute : Class ;
fun AbstractionLevelAttribute_Class : SubClass AbstractionLevelAttribute TimingRequirementAttribute ;

-- (AddressFn ?FILE) returns as its value the
-- physical address of the ComputerFile ?FILE.
fun AddressFn : El ComputerFile -> Ind PhysicalAddress ;

-- 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.
fun Assessment_DesignPattern : Class ;
fun Assessment_DesignPattern_Class : SubClass Assessment_DesignPattern DesignPatternAttribute ;

-- A program which is started
-- automatically, as opposed to an application started in response to
-- some condition becoming true.
fun AutomaticApplication : Class ;
fun AutomaticApplication_Class : SubClass AutomaticApplication ComputerProgram ;

-- 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.
fun BerkeleySoftwareDistribution : Class ;
fun BerkeleySoftwareDistribution_Class : SubClass BerkeleySoftwareDistribution OperatingSystem ;

-- The measurement of the speed of data
-- transfer in a communications system.
fun BitsPerSecond : Class ;

-- 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.
fun BusNetwork : Class ;
fun BusNetwork_Class : SubClass BusNetwork LAN ;

-- CPU (Central Processing Unit) is the computing part
-- of the computer.
fun CPU : Class ;
fun CPU_Class : SubClass CPU (both ComputerComponent ComputerHardware) ;

-- (CPUUtilizationFn ?PROGRAM) refers to
-- the percentage of time the CPU is used by an application ?PROGRAM.
fun CPUUtilizationFn : El ComputerProgram -> Ind ConstantQuantity ;

-- A subclass of
-- TimingRequirementAttribute, which includes
-- MultipleRequirement_Complexity and SingleRequirement_Complexity.
fun ComplexityAttribute : Class ;
fun ComplexityAttribute_Class : SubClass ComplexityAttribute TimingRequirementAttribute ;

-- Instances of ComputationalSystems
-- include instances of SoftwareSystems, HardwareSystems, and
-- ComputerNetworks.
fun ComputationalSystem : Class ;
fun ComputationalSystem_Class : SubClass ComputationalSystem Product ;

-- A general_purpose machine that processes
-- data according to a set of instructions that are stored internally
-- either temporarily or permanently.
fun Computer : Class ;
fun Computer_Class : SubClass Computer ElectricDevice ;

-- 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.
fun ComputerComponent : Class ;
fun ComputerComponent_Class : SubClass ComputerComponent ComputerHardware ;

-- The term ComputerData refers to files
-- and databases, text documents, and images.
fun ComputerData : Class ;
fun ComputerData_Class : SubClass ComputerData ContentBearingObject ;

-- 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. ComputerDirectory folders contain only files and other folders
fun ComputerDirectory : Class ;
fun ComputerDirectory_Class : SubClass ComputerDirectory ComputerFile ;

fun ComputerFile_ComputerData : SubClass ComputerFile ComputerData ;

-- The hardware is the physical part of
-- a computer system.
fun ComputerHardware : Class ;
fun ComputerHardware_Class : SubClass ComputerHardware EngineeringComponent ;

-- A peripheral device that generates
-- input for the computer such as a keyboard, scanner, or mouse.
fun ComputerInputDevice : Class ;
fun ComputerInputDevice_Class : SubClass ComputerInputDevice ComputerHardware ;

-- The EnglishLanguage 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.
fun ComputerMemory : Class ;
fun ComputerMemory_Class : SubClass ComputerMemory (both ComputerComponent ComputerHardware) ;

-- 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.
fun ComputerNetwork : Class ;
fun ComputerNetwork_Class : SubClass ComputerNetwork (both ComputationalSystem RealtimeSystem) ;

-- Any peripheral that presents
-- output from the computer, such as a screen or printer.
fun ComputerOutputDevice : Class ;
fun ComputerOutputDevice_Class : SubClass ComputerOutputDevice ComputerHardware ;

-- 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.
fun ComputerPassword : Class ;
fun ComputerPassword_Class : SubClass ComputerPassword SymbolicString ;

-- An instance of ComputerPath is a series
-- of programs that connects input devices, typically sensors, to output
-- devices, typically actuators.
fun ComputerPath : Class ;
fun ComputerPath_Class : SubClass ComputerPath ComputerData ;

-- The class of all attributes that are
-- specific to ComputerPaths.
fun ComputerPathAttribute : Class ;
fun ComputerPathAttribute_Class : SubClass ComputerPathAttribute SoftwareAttribute ;

-- An instance of ComputerProcess is a
-- process which manipulates data in the computer.
fun ComputerProcess : Class ;
fun ComputerProcess_Class : SubClass ComputerProcess InternalChange ;

-- A collection of data, presented in a preformatted
-- manner.
fun ComputerReport : Class ;
fun ComputerReport_Class : SubClass ComputerReport ComputerData ;

-- 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.
fun ComputerResource : Class ;
fun ComputerResource_Class : SubClass ComputerResource ComputationalSystem ;

-- A ComputerProcess which attempts to
-- comply with a user's request.
fun ComputerResponse : Class ;
fun ComputerResponse_Class : SubClass ComputerResponse ComputerProcess ;

-- An attribute which describes status of the
-- Computer, such as HostDown, HostReady.
fun ComputerStatus : Class ;
fun ComputerStatus_Class : SubClass ComputerStatus RelationalAttribute ;

-- In a multitasking environment, an
-- independently running program or subprogram. Each task is assigned
-- a task number.
fun ComputerTask : Class ;
fun ComputerTask_Class : SubClass ComputerTask ComputerProcess ;

-- 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.
fun ComputerTerminal : Class ;
fun ComputerTerminal_Class : SubClass ComputerTerminal ComputerOutputDevice ;

-- Any individual who interacts with a
-- computer.
fun ComputerUser : Class ;
fun ComputerUser_Class : SubClass ComputerUser CognitiveAgent ;

-- 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.
fun Concurrency_FormOfAdaptation : Class ;
fun Concurrency_FormOfAdaptation_Class : SubClass Concurrency_FormOfAdaptation FormOfAdaptationAttribute ;

-- A Program which is started inside
-- an Xterm or other console.
fun ConsoleApplication : Class ;
fun ConsoleApplication_Class : SubClass ConsoleApplication ComputerProgram ;

-- The attribute which denotes that the
-- path type is continuous, as opposed to transient or quasiconstinuous
-- paths. A continuous path handles a stream of data arriving at a comment
-- of rate.
fun ContinuousPath : Class ;
fun ContinuousPath_Class : SubClass ContinuousPath ComputerPathAttribute ;

-- Encoding data to take up less storage space.
fun DataCompression : Class ;
fun DataCompression_Class : SubClass DataCompression ComputerProcess ;

-- 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.
fun DataSaving : Class ;
fun DataSaving_Class : SubClass DataSaving ComputerProcess ;

-- A device or part of the computer that
-- receives data.
fun DataSink : Class ;
fun DataSink_Class : SubClass DataSink ComputerInputDevice ;

-- A subclass of ComputerProcesses which
-- send data over a computer channel or bus.
fun DataTransfer : Class ;
fun DataTransfer_Class : SubClass DataTransfer ComputerProcess ;

-- A set of related files that is created and
-- managed by a database management system (DBMS).
fun Database : Class ;
fun Database_Class : SubClass Database ComputerData ;

-- 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.
fun Dependent_TaskRelation : Ind TaskRelationAttribute ;

-- This is a subclass of
-- RealtimeSystemAttribute, which includes Guidance_DesignPattern,
-- Initiation_DesignPattern, and Assessment_DesignPattern.
fun DesignPatternAttribute : Class ;
fun DesignPatternAttribute_Class : SubClass DesignPatternAttribute RealtimeSystemAttribute ;

-- 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.
fun DeterministicDataStream : Class ;
fun DeterministicDataStream_Class : SubClass DeterministicDataStream ComputerPathAttribute ;

-- The attribute which denotes that the
-- path data stream type is dynamic, i.e. the time changes but the data
-- stream follows a pattern.
fun DynamicDataStream : Class ;
fun DynamicDataStream_Class : SubClass DynamicDataStream ComputerPathAttribute ;

-- 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.
fun EnvironmentSoftwareAttribute : Class ;
fun EnvironmentSoftwareAttribute_Class : SubClass EnvironmentSoftwareAttribute RelationalAttribute ;

-- An instant in time that is arbitrarily selected as a point of reference.
fun Epoch : Class ;
fun Epoch_Class : SubClass Epoch TimePoint ;

-- Able to be run in its current format.
fun Executable : Ind RelationalAttribute ;

-- The class of all messages to a resource
-- management program from one of its processes.
fun Feedback : Class ;
fun Feedback_Class : SubClass Feedback ContentBearingObject ;

-- An attribute that applies to a
-- RealtimeSystem just in case a fixed percentage of requirements
-- is met.
fun Firm_Strictness : Class ;
fun Firm_Strictness_Class : SubClass Firm_Strictness StrictnessAttribute ;

-- A subclass of
-- RealtimeSystemAttribute, which includes Precision_FormOfAdaptation,
-- Slack_FormOfAdaptation, Concurrency_FormOfAdaptation, and
-- ResourceAllocation_FormOfAdaptation.
fun FormOfAdaptationAttribute : Class ;
fun FormOfAdaptationAttribute_Class : SubClass FormOfAdaptationAttribute RealtimeSystemAttribute ;

-- 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.
fun Guidance_DesignPattern : Class ;
fun Guidance_DesignPattern_Class : SubClass Guidance_DesignPattern DesignPatternAttribute ;

-- 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.
fun HardDiskDrive : Class ;
fun HardDiskDrive_Class : SubClass HardDiskDrive (both ComputerComponent ComputerHardware) ;

-- An attribute that applies to a
-- RealtimeSystem just in case all deadlines are met.
fun Hard_Strictness : Class ;
fun Hard_Strictness_Class : SubClass Hard_Strictness StrictnessAttribute ;

-- 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.
fun HardwareSystem : Class ;
fun HardwareSystem_Class : SubClass HardwareSystem (both ComputationalSystem (both ComputerHardware RealtimeSystem)) ;

-- Used to indicate that a ComputationalSystem
-- has a high priority.
fun HighPriority : Ind PriorityAttribute ;

-- An attribute which applies to a computer that ceases to
-- operate due to hardware or software failure.
fun HostDown : Ind ComputerStatus ;

-- An attribute which applies to a computer that is
-- functional, operating properly, and ready to receive work requests.
fun HostReady : Ind ComputerStatus ;

-- 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.
fun Hybrid_Strictness : Class ;
fun Hybrid_Strictness_Class : SubClass Hybrid_Strictness StrictnessAttribute ;

-- 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.
fun Hybrid_SystemBehavior : Class ;
fun Hybrid_SystemBehavior_Class : SubClass Hybrid_SystemBehavior SystemBehaviorAttribute ;

-- The Internet Protocol address, a numeric address such as 123.231.32.2 that
-- the domain name server translates into a domain name.
fun IPAddress : Class ;
fun IPAddress_Class : SubClass IPAddress PhysicalAddress ;

-- 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.
fun ImageFile : Class ;
fun ImageFile_Class : SubClass ImageFile ComputerData ;

-- An attribute that applies to a
-- RealtimeSystem just in case it is designed and implemented to meet
-- the more important requirements first.
fun Importance_Strictness : Class ;
fun Importance_Strictness_Class : SubClass Importance_Strictness StrictnessAttribute ;

-- 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.
fun Independent_TaskRelation : Class ;
fun Independent_TaskRelation_Class : SubClass Independent_TaskRelation TaskRelationAttribute ;

-- The function which returns as its value
-- the initial profile of the program, i.e. a report of its execution
-- characteristics.
fun InitialProfileFn : El ComputerProgram -> Ind ProcessState ;

-- An instance of the class
-- RealtimeSystem has Initiation_DesignPattern if it consists of
-- one software module and the actuators it commands. The design pattern
-- is an event source which produces events for an event handler. The
-- event source is typically an evaluate_and_decide software module.
-- The event stream is necessarily asychronous, or transient. The arrival
-- rate of events may vary and is unbounded. Events may be either
-- homogeneous or heterogeneous. The workload per event for homogeneous
-- events is constant. The workload per event for heterogeneous events
-- is a function of each event type. There is one deadline for real_time
-- action initiation systems. It is the upper bound on the time to
-- generate a command for the actuator.
fun Initiation_DesignPattern : Class ;
fun Initiation_DesignPattern_Class : SubClass Initiation_DesignPattern DesignPatternAttribute ;

-- The attribute Instrument_AbstractionLevel is the lowest level of abstraction,
-- which can be used to describe a real_time system or subsystem.
fun Instrument_AbstractionLevel : Class ;
fun Instrument_AbstractionLevel_Class : SubClass Instrument_AbstractionLevel AbstractionLevelAttribute ;

-- 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. LAN A local_area network (LAN) whose topology is a ring.
-- That is, all of the nodes are connected in a closed loop. Messages
-- travel around the ring, with each node reading those messages addressed
-- to it.
fun LAN : Class ;
fun LAN_Class : SubClass LAN ComputerNetwork ;

-- Used to indicate that a ComputationalSystem
-- has a low priority.
fun LowPriority : Ind PriorityAttribute ;

-- Each element of MeasuringPerformance
-- is an event of measuring the performance of an instance of ComputerComponent,
-- performed by a MonitoringProgram.
fun MeasuringPerformance : Class ;
fun MeasuringPerformance_Class : SubClass MeasuringPerformance ComputerProcess ;

-- 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.
fun Method_AbstractionLevel : Class ;
fun Method_AbstractionLevel_Class : SubClass Method_AbstractionLevel AbstractionLevelAttribute ;

-- This command is to change the monitoring
-- for any component for which a componentDataID was sent on initial connection.
fun MonitorApplicationCmd : Class ;
fun MonitorApplicationCmd_Class : SubClass MonitorApplicationCmd MonitoringProgram ;

-- This is the command to monitor any of the
-- generic components _ hard drive, network, cpu, memory, etc.
fun MonitorComponentCmd : Class ;
fun MonitorComponentCmd_Class : SubClass MonitorComponentCmd MonitoringProgram ;

-- This is the command to get a list
-- of applications periodically.
fun MonitorConnectivityCmd : Class ;
fun MonitorConnectivityCmd_Class : SubClass MonitorConnectivityCmd MonitoringProgram ;

-- A program which monitors performance
-- of an application, a component, etc.
fun MonitoringProgram : Class ;
fun MonitoringProgram_Class : SubClass MonitoringProgram ComputerProgram ;

-- 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.
fun MultipleRequirement_Complexity : Class ;
fun MultipleRequirement_Complexity_Class : SubClass MultipleRequirement_Complexity ComplexityAttribute ;

-- 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.
fun Multitasking : Class ;
fun Multitasking_Class : SubClass Multitasking ComputerProcess ;

-- 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.
fun NetworkAdapter : Class ;
fun NetworkAdapter_Class : SubClass NetworkAdapter ComputerComponent ;

-- Network resources are the available
-- servers and printers in the network.
fun NetworkResource : Class ;
fun NetworkResource_Class : SubClass NetworkResource ComputerResource ;

-- 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).
fun Object_AbstractionLevel : Class ;
fun Object_AbstractionLevel_Class : SubClass Object_AbstractionLevel AbstractionLevelAttribute ;

-- 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.
fun OperatingSystem : Class ;
fun OperatingSystem_Class : SubClass OperatingSystem SoftwareSystem ;

-- 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.
fun Optimization : Class ;
fun Optimization_Class : SubClass Optimization ProcessTask ;

-- A block of data used for transmission in packet
-- switched systems.
fun Packet : Class ;
fun Packet_Class : SubClass Packet ComputerData ;

-- The rate or speed of Packet_Networks
-- transferred in a second.
fun PacketsPerSecond : Ind CompositeUnitOfMeasure ;

-- 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.
fun PathImportanceFunction : Ind ComputerPathAttribute ;

-- An instance of the class
-- RealtimeSystem is described as a system with Periodic_SystemBehavior
-- when it is activated at regular intervals.
fun Periodic_SystemBehavior : Class ;
fun Periodic_SystemBehavior_Class : SubClass Periodic_SystemBehavior SystemBehaviorAttribute ;

-- The collection of all addresses which
-- identify a location of a ComputerFile.
fun PhysicalAddress : Class ;
fun PhysicalAddress_Class : SubClass PhysicalAddress SymbolicString ;

fun Precision_FormOfAdaptation : Class ;
fun Precision_FormOfAdaptation_Class : SubClass Precision_FormOfAdaptation FormOfAdaptationAttribute ;
-- A device that converts computer output into
-- printed images.
fun Printer : Class ;
fun Printer_Class : SubClass Printer ComputerOutputDevice ;

-- A class of attributes which describe
-- priorities of ComputationalSystems.
fun PriorityAttribute : Class ;
fun PriorityAttribute_Class : SubClass PriorityAttribute RelationalAttribute ;

-- An attribute that denotes the failure of the Process to achieve
-- its goal.
fun ProcessFailure : Ind ProcessStatus ;

-- 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.
fun ProcessState : Class ;
fun ProcessState_Class : SubClass ProcessState ContentBearingObject ;

-- A class of attributes. Each instance of ProcessStatus describes a
-- status of a Process, such as ProcessFailure, ProcessSuccess, etc.
fun ProcessStatus : Class ;
fun ProcessStatus_Class : SubClass ProcessStatus RelationalAttribute ;

-- An attribute that denotes the success of the Process to achieve
-- its goal.
fun ProcessSuccess : Ind ProcessStatus ;

-- A function to be performed.
fun ProcessTask : Class ;
fun ProcessTask_Class : SubClass ProcessTask Abstract ;

-- 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.
fun QuasicontinuousPath : Class ;
fun QuasicontinuousPath_Class : SubClass QuasicontinuousPath ComputerPathAttribute ;

-- A program started by a Resource
-- Management program, which determines if and where to start the
-- application.
fun RM_StartApplication : Class ;
fun RM_StartApplication_Class : SubClass RM_StartApplication ComputerProgram ;

-- An computer_controlled system, the
-- correct operation of which depends on meeting specified timing
-- constraints.
fun RealtimeSystem : Class ;
fun RealtimeSystem_Class : SubClass RealtimeSystem ComputationalSystem ;

-- The class of Attributes which
-- describe instances of the class RealtimeSystem.
fun RealtimeSystemAttribute : Class ;
fun RealtimeSystemAttribute_Class : SubClass RealtimeSystemAttribute RelationalAttribute ;

-- The attribute which denotes that
-- a program can be restarted on the same host.
fun ReplicationsOnSameHostOK : Ind SoftwareAttribute ;

-- 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.
fun ResourceAllocation_FormOfAdaptation : Class ;
fun ResourceAllocation_FormOfAdaptation_Class : SubClass ResourceAllocation_FormOfAdaptation FormOfAdaptationAttribute ;

-- The class of resource
-- management programs.
fun ResourceManagementProgram : Class ;
fun ResourceManagementProgram_Class : SubClass ResourceManagementProgram ComputerProgram ;

-- The attribute which denotes that a program
-- can be restarted.
fun Restartable : Ind SoftwareAttribute ;

-- To use the same resource again.
fun ReusingAResource : Class ;
fun ReusingAResource_Class : SubClass ReusingAResource ComputerProcess ;

fun RingNetwork : Class ;
fun RingNetwork_Class : SubClass RingNetwork LAN ;
-- SatisfyingRequirements covers cases of
-- finding a solution that satisfies necessary conditions.
fun SatisfyingRequirements : Class ;
fun SatisfyingRequirements_Class : SubClass SatisfyingRequirements ProcessTask ;

-- The attribute which denotes that
-- an application can combine its input stream from different preceding
-- applications or devices for greater scalability.
fun ScalabilityCombining : Ind SoftwareAttribute ;

-- The attribute which denotes that
-- a program can split its output stream to different succeeding
-- applications or devices for greater scalability.
fun ScalabilitySplitting : Ind SoftwareAttribute ;

-- The attribute which denotes that the path is
-- scalable, i.e. the applications in the path can be replicated to meet
-- realtime QoS requirements.
fun Scalable : Class ;
fun Scalable_Class : SubClass Scalable ComputerPathAttribute ;

-- 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.
fun Sensor : Class ;
fun Sensor_Class : SubClass Sensor ComputerHardware ;

-- 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.
fun Server : Class ;
fun Server_Class : SubClass Server ComputationalSystem ;

-- A typically small instance of
-- ComputerProgram whose function is to end a typically larger
-- instance of ComputerProgram.
fun ShutdownBlock : Class ;
fun ShutdownBlock_Class : SubClass ShutdownBlock ComputerProgram ;

-- (ShutdownFn ?Program) returns an instance of
-- ShutdownBlock which contains the instructions to end ?PROGRAM.
fun ShutdownFn : El ComputerProgram -> Ind ShutdownBlock ;

-- An attribute that describes
-- instances of RealtimeSystems which require a single timing requirement,
-- either a bound for completion time for systems with
-- Transient_SystemBehavior or cycle deadline for systems with
-- Periodic_SystemBehavior.
fun SingleRequirement_Complexity : Class ;
fun SingleRequirement_Complexity_Class : SubClass SingleRequirement_Complexity ComplexityAttribute ;

-- 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.
fun Slack_FormOfAdaptation : Class ;
fun Slack_FormOfAdaptation_Class : SubClass Slack_FormOfAdaptation FormOfAdaptationAttribute ;

-- 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.
fun Soft_Strictness : Class ;
fun Soft_Strictness_Class : SubClass Soft_Strictness StrictnessAttribute ;

-- The class of all attributes that are
-- specific to SoftwareSystems.
fun SoftwareAttribute : Class ;
fun SoftwareAttribute_Class : SubClass SoftwareAttribute RelationalAttribute ;

-- 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.
fun SoftwareSystem : Class ;
fun SoftwareSystem_Class : SubClass SoftwareSystem (both ComputationalSystem RealtimeSystem) ;

-- 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.
fun Solaris : Class ;
fun Solaris_Class : SubClass Solaris OperatingSystem ;

-- A local_area network (LAN) that uses a star
-- topology in which all nodes are connected to a central computer.
fun StarNetwork : Class ;
fun StarNetwork_Class : SubClass StarNetwork LAN ;

-- 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.
fun StartupBlock : Class ;
fun StartupBlock_Class : SubClass StartupBlock ComputerProgram ;

-- (StartupFn ?Program) returns an instance of
-- StartupBlock which contains the instructions to start the ?Program.
fun StartupFn : El ComputerProgram -> Ind StartupBlock ;

-- The attribute which denotes that
-- the time between data or groups of data changes according to no
-- discernible pattern.
fun StochasticDataStream : Class ;
fun StochasticDataStream_Class : SubClass StochasticDataStream ComputerPathAttribute ;

-- This is a subclass of
-- TimingRequirementAttribute, which includes Hard_Strictness,
-- Firm_Strictness, Soft_Strictness, Importance_Strictness,
-- Utility_Strictness, and Hybrid_Strictness
fun StrictnessAttribute : Class ;
fun StrictnessAttribute_Class : SubClass StrictnessAttribute TimingRequirementAttribute ;

-- A subclass of
-- RealtimeSystemAttribute, which includes the following Attributes:
-- Periodic_SystemBehavior, Transient_SystemBehavior, and
-- Hybrid_SystemBehavior.
fun SystemBehaviorAttribute : Class ;
fun SystemBehaviorAttribute_Class : SubClass SystemBehaviorAttribute RealtimeSystemAttribute ;

-- 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.
fun TaskGroup_AbstractionLevel : Class ;
fun TaskGroup_AbstractionLevel_Class : SubClass TaskGroup_AbstractionLevel AbstractionLevelAttribute ;

-- This is a subclass of
-- RealtimeSystemAttribute, which includes Independent_TaskRelation
-- and Dependent_TaskRelation.
fun TaskRelationAttribute : Class ;
fun TaskRelationAttribute_Class : SubClass TaskRelationAttribute RealtimeSystemAttribute ;

-- 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.
fun Task_AbstractionLevel : Class ;
fun Task_AbstractionLevel_Class : SubClass Task_AbstractionLevel AbstractionLevelAttribute ;

-- A subclass of
-- RealtimeSystemAttribute which includes ComplexityAttribute,
-- StrictnessAttribute, and AbstractionLevelAttribute.
fun TimingRequirementAttribute : Class ;
fun TimingRequirementAttribute_Class : SubClass TimingRequirementAttribute RealtimeSystemAttribute ;

-- An attribute which applies to computer
-- paths which handle random events.
fun TransientPath : Class ;
fun TransientPath_Class : SubClass TransientPath ComputerPathAttribute ;

-- An instance of the class
-- RealtimeSystem shows Transient_SystemBehavior when it is
-- activated by sporadic events.
fun Transient_SystemBehavior : Class ;
fun Transient_SystemBehavior_Class : SubClass Transient_SystemBehavior SystemBehaviorAttribute ;

-- 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).
fun UniformResourceIdentifier : Class ;
fun UniformResourceIdentifier_Class : SubClass UniformResourceIdentifier ContentBearingObject ;

-- 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).
fun UniformResourceLocator : Class ;
fun UniformResourceLocator_Class : SubClass UniformResourceLocator UniformResourceIdentifier ;

-- 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).
fun UniformResourceName : Class ;
fun UniformResourceName_Class : SubClass UniformResourceName UniformResourceIdentifier ;

-- The Unix epoch or point of reference is 00:00:00 UTC,
-- January 1, 1970.
fun UnixEpoch : Ind Epoch ;

-- 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.
fun UserAccount : Class ;
fun UserAccount_Class : SubClass UserAccount ContentBearingObject ;

-- The name a person uses to identify himself or herself
-- when logging onto a computer system or online service.
fun UserName : Class ;
fun UserName_Class : SubClass UserName SymbolicString ;

-- A request made by a ComputerUser, such as
-- looking up a customer record.
fun UserRequest : Class ;
fun UserRequest_Class : SubClass UserRequest ComputerProcess ;

-- A ComputerProcess which requires access to a
-- ComputerResource.
fun UsingAResource : Class ;
fun UsingAResource_Class : SubClass UsingAResource ComputerProcess ;

-- 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.
fun Utility : Class ;
fun Utility_Class : SubClass Utility ComputerProgram ;

-- 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.
fun Utility_Strictness : Class ;
fun Utility_Strictness_Class : SubClass Utility_Strictness StrictnessAttribute ;

fun abstractionLevel : El RealtimeSystem -> El AbstractionLevelAttribute -> Formula ;

-- (bandwidthOf ?NET ?BANDWIDTH) holds if
-- ?BANDWIDTH is the amount of data which can be sent through an instance
-- of a ComputerNetwork ?NET, measured in bits per second.
fun bandwidthOf : El ComputerNetwork -> El BitsPerSecond -> Formula ;

-- (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.
fun batchInterArrival : El ComputerPath -> El TimeDuration -> Formula ;

-- (batchLatency ?PATH ?TIME)holds if ?TIME
-- is the maximum allowed latency for all cycles of a quasicontinuous path.
fun batchLatency : El ComputerPath -> El TimeDuration -> Formula ;

-- (benchmarkPerformance ?SYSTEM
-- ?TEST ?NUMBER) holds if ?NUMBER is a benchmark for measuring the performance
-- of an instance of a ComputationalSystem.
fun benchmarkPerformance : El ComputationalSystem -> El MonitoringProgram -> El Quantity -> Formula ;

-- (collectRate ?System ?Period) holds if ?Period is
-- the period at which ComputationalSystem ?System collects data.
fun collectRate : El ComputationalSystem -> El TimeDuration -> Formula ;

-- (commandLineArguments ?PROGRAM ?LIST) means that the application ?PROGRAM requires command line
-- arguments, as specified in ?LIST.
fun commandLineArguments : El ComputerProgram -> El List -> Formula ;

-- (complexity ?System ?Attribute) holds if
-- ?Attribute is a TimingRequirementAttribute which describes the
-- RealtimeSystem ?System.
fun complexity : El RealtimeSystem -> El TimingRequirementAttribute -> Formula ;

-- (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.
fun componentDataID: El TimePosition -> Desc ComputerComponent -> El ComputerComponent -> El UnitOfMeasure -> El SymbolicString -> Formula ;

-- (computerResponseTo ?Response ?Request) means that
-- ?Response is a ComputerResponse to the UserRequest ?Request.
fun computerResponseTo : El ComputerResponse -> El UserRequest -> Formula ;

-- (computerRunning ?Process ?Computer)
-- means that the ComputerProcess ?Process is running on ?Computer.
fun computerRunning : El ComputerProcess -> El Computer -> Formula ;

-- (criticalityLevel ?PROGRAM ?INTEGER)
-- holds just in case ?INTEGER indicates the relative priority of ?PROGRAM
-- with respect to other applications within the SoftwareSystem.
fun criticalityLevel : El ComputerProgram -> El Integer -> Formula ;

-- (dataID ?PROGRAM ?NUMBER) holds if ?NUMBER is a small
-- number associated with an instance of MonitoringProgram.
fun dataID : El MonitoringProgram -> El SymbolicString -> Formula ;

-- The data being processed during a ComputerProcess.
fun dataProcessed : El ComputerProcess -> El ComputerData -> Formula ;

-- (dataStreamSlack ?PATH ?N) means that
-- a continuous or quasicontinuous path ?PATH should be able to process ?N
-- additional data items at any time.
fun dataStreamSlack : El ComputerPath -> El PositiveInteger -> Formula ;

-- (defaultNetwork ?SYSTEM ?NET) holds if
-- ?NET is the default network of the HardwareSystem ?SYSTEM.
fun defaultNetwork : El HardwareSystem -> El ComputerNetwork -> Formula ;

-- 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.
fun dependencyDelay : El ComputerProgram -> El TimeDuration -> Formula ;

-- (dependencyType ?PROGRAM ?TYPE) means
-- that ?PROGRAM has a dependency type ?TYPE, where ?TYPE can be either
-- StartupBlock or ShutdownBlock.
fun dependencyType: El ComputerProgram -> Desc ComputerProgram -> Formula ;

-- (designPattern ?System ?Attribute) holds
-- if ?Attribute is a DesignPatternAttribute which describes the
-- RealtimeSystem ?System.
fun designPattern : El RealtimeSystem -> El DesignPatternAttribute -> Formula ;

-- (directoryOf ?FILE ?DIRECTORY) means that
-- the ComputerFile ?FILE is in the ComputerDirectory ?DIRECTORY.
fun directoryOf : El ComputerFile -> El ComputerDirectory -> Formula ;

-- (environmentAttributes ?Program ?Attribute) holds if ?Attribute is an EnvironmentSoftwareAttribute
-- which describes the ComputerProgram ?Program.
fun environmentAttributes : El ComputerProgram -> El EnvironmentSoftwareAttribute -> Formula ;

-- (formOfAdaptation ?System ?Attribute)
-- holds if ?Attribute is a FormOfAdaptationAttribute which describes the
-- RealtimeSystem ?System.
fun formOfAdaptation : El RealtimeSystem -> El FormOfAdaptationAttribute -> Formula ;

-- 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.
fun granularity : El RealtimeSystem -> El TimeDuration -> Formula ;

-- (hardwareType ?TYPE ?COMPUTER) means that
-- TYPE represents the computer vendor model name, as well as the version
-- of the product.
fun hardwareType : El SymbolicString -> El Computer -> Formula ;

-- (hasAccount ?User ?Account) holds if ?User is
-- assigned the UserAccount ?Account.
fun hasAccount : El ComputerUser -> El UserAccount -> Formula ;

-- (hasDependency ?PROGRAM1 ?PROGRAM2)
-- holds if ?PROGRAM1 is dependent on the application ?PROGRAM2.
fun hasDependency : El ComputerProgram -> El ComputerProgram -> Formula ;

-- (heartBeatRate ?Program ?Period) holds if
-- ?Period is the period at which the ComputerProgram ?Program sends its heartbeat
-- to a monitoring process.
fun heartBeatRate : El ComputerProgram -> El TimeDuration -> Formula ;

-- 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.
fun hostJitter : El Computer -> El ConstantQuantity -> Formula ;

-- (hostOf ?SYSTEM ?COMPUTER) means that ?COMPUTER
-- is the host of the computational system ?SYSTEM.
fun hostOf : El ComputationalSystem -> El Computer -> Formula ;

-- (hostStatus ?Computer ?Status) means that ?Status
-- describes the status of the Computer, such as HostDown, HostReady.
fun hostStatus : El Computer -> El ComputerStatus -> Formula ;

-- The degree of sharpness of a displayed or printed image.
fun imageResolution : El ImageFile -> El PhysicalQuantity -> Formula ;

-- (ipAddressOf ?HOST ?ADDRESS) holds if ?ADDRESS is the IPAddress of
-- the computer ?HOST.
fun ipAddressOf : El Computer -> El IPAddress -> Formula ;

-- In performance measurement, the current use of a
-- system as a percentage of total capacity.
fun load : El ComputerComponent -> El ConstantQuantity -> Formula ;

-- (maximumReplications ?PROGRAM ?INTEGER) means that
-- ?INTEGER represents the maximum number of copies of this application which can be run
-- during a process.
fun maximumReplications : El ComputerProgram -> El PositiveInteger -> Formula ;

-- (memorySize ?System ?Size) holds if
-- ?Size is the required memory size for the ComputationalSystem ?System.
fun memorySize : El ComputationalSystem -> El ConstantQuantity -> Formula ;

-- (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.
fun minimumReplications : El ComputerProgram -> El PositiveInteger -> Formula ;

-- (monitorApplicationData ?TIME
-- ?APPLICATION) holds if the time stamp ?TIME specifies the time at which
-- ?APPLICATION is running.
fun monitorApplicationData : El TimePosition -> El ComputerProgram -> Formula ;

-- (monitorComponentData ?TIME ?ID
-- ?NUMBER) holds if at time ?TIME, a component with the IDNumber ?ID
-- has a performance of a value ?NUMBER.
fun monitorComponentData : El TimePosition -> El SymbolicString -> El RealNumber -> Formula ;

-- (monitorConnectivityData ?TIME
-- ?IPADDRESS) is a relation between a timestamp ?TIME and an ?IP address.
fun monitorConnectivityData : El TimePosition -> El IPAddress -> Formula ;

-- (numberOfCPUs ?COMPUTER ?INTEGER) means
-- that the number of CPUs for the host ?COMPUTER is equal to INTEGER.
fun numberOfCPUs : El Computer -> El PositiveInteger -> Formula ;

-- (password ?Password ?User) means that ?Password is
-- the password the ComputerUser uses while logging onto a computer system.
fun password : El ComputerUser -> El ComputerPassword -> Formula ;

-- (performanceResult ?EVENT ?COMPONENT ?NUMBER) holds if the performance of
-- ?COMPONENT has a value ?NUMBER, measured by ?EVENT, an instance of MeasuringPerformance.
fun performanceResult : El MeasuringPerformance -> El ComputerComponent -> El RealNumber -> Formula ;

-- (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.
fun portNumber : El ComputerProgram -> El PositiveInteger -> Formula ;

-- (priority ?SYSTEM ?QUANTITY) means that the
-- priority of the ?SYSTEM is characterized by a PriorityAttribute, such
-- as HighPriority or LowPriority.
fun priority : El ComputationalSystem -> El PriorityAttribute -> Formula ;

-- (processAborted ?Abort ?Process) means
-- that the ComputerProcess ?Process is aborted as the result of ?Abort.
fun processAborted : El Abort -> El ComputerProcess -> Formula ;

-- (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.
fun processID : El ComputerProcess -> El PositiveInteger -> Formula ;

-- 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.
fun processList : [El Entity] -> Formula ;

-- (productModel ?Model ?Product) means that
-- ?Model represents the type of the Product ?Product
fun productModel : El SymbolicString -> El Product -> Formula ;

-- (programCopy ?File ?Program) means that
-- the ComputerFile ?File is one of the copies of the ComputerProgram
-- ?Program.
fun programCopy : El ComputerFile -> El ComputerProgram -> Formula ;

-- (programRunning ?Process ?Program)
-- means that the ComputerProcess ?Process is executing the
-- ComputerProgram ?Program.
fun programRunning : El ComputerProcess -> El ComputerProgram -> Formula ;

-- (qoSSlack ?PATH ?MIN ?MAX) holds if ?PATH
-- has a realtime QoS maximum slack percentage of ?MAX and minimum of ?MIN.
fun qoSSlack : El ComputerPath -> El ConstantQuantity -> El ConstantQuantity -> Formula ;

-- (rMProgram_of ?RM ?SYSTEM) means that
-- ?RM is the resource management program of the SoftwareSystem ?SYSTEM.
fun rMProgram_of : El ResourceManagementProgram -> El SoftwareSystem -> Formula ;

-- (requestRate ?Request ?Period) means that
-- ?Period is the period at which the user sends its ?Request.
fun requestRate : El UserRequest -> El TimeDuration -> Formula ;

-- (resourceUsed ?Process ?Resource) means that the
-- ComputerProcess ?Process has access to the ComputerResource ?Resource.
fun resourceUsed : El ComputerProcess -> El ComputerResource -> Formula ;

-- (responseRate ?Response ?Period) means
-- that ?Period is the period at which the computer sends its ?Response.
fun responseRate : El ComputerResponse -> El TimeDuration -> Formula ;

-- The time it takes for the computer to comply
-- with a user's request, such as looking up a customer record.
fun responseTime : El UserRequest -> El TimeDuration -> Formula ;

-- (runningOn ?Program ?Computer) holds if the
-- ComputerProgram ?Program is being executed on ?Computer.
fun runningOn : El ComputerProgram -> El Computer -> Formula ;

-- (runsOn ?Program ?Computer) means that ?Program
-- is capable of running on ?Computer.
fun runsOn : El ComputerProgram -> El Computer -> Formula ;

-- (sendRate ?Program ?Period) holds if ?Period is the
-- period at which the ComputationalSystem ?System sends data reports.
fun sendRate : El ComputationalSystem -> El TimeDuration -> Formula ;

-- (settlingTime ?PROGRAM ?TIME) says that ?TIME represents seconds to delay
-- after an action was taken with respect to QoS.
fun settlingTime : El ComputerProgram -> El TimeDuration -> Formula ;

-- (shutdownOf ?SHUTDOWN ?PROGRAM) holds just
-- in case an instance of ShutdownBlock ?SHUTDOWN specifies a set of
-- instructions to end ?PROGRAM.
fun shutdownOf : El ShutdownBlock -> El ComputerProgram -> Formula ;

-- (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.
fun simpleDeadline : El ComputerPath -> El TimeDuration -> Formula ;

-- (slidingWindowSize ?PATH ?N) holds
-- if PATH has a realtime QoS sliding window size of ?N measured samples.
fun slidingWindowSize : El ComputerPath -> El PositiveInteger -> Formula ;

-- (softwarePath ?SYSTEM ?PATH) means that
-- ?PATH is a computer path for the instance of SoftwareSystem ?SYSTEM.
fun softwarePath : El SoftwareSystem -> El ComputerPath -> Formula ;

-- (standardErrorDevice ?PROGRAM ?DEVICE) holds just in case the DEVICE is the predefined
-- error channel with which the running version of this program is initialised.
fun standardErrorDevice : El ComputerProcess -> El ComputerOutputDevice -> Formula ;

-- (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.
fun standardInputDevice : El ComputerProcess -> El ComputerInputDevice -> Formula ;

-- (standardOutputDevice ?PROGRAM ?DEVICE) holds just in case the DEVICE is
-- the predefined output channel with which the running version of this program is initialised.
fun standardOutputDevice : El ComputerProcess -> El ComputerOutputDevice -> Formula ;

-- (startupOf ?STARTUP ?PROGRAM) holds just in case an instance of
-- StartupBlock ?STARTUP specifies a set of instructions to start the ?PROGRAM.
fun startupOf : El StartupBlock -> El ComputerProgram -> Formula ;

-- (startupTimeDelay ?PROGRAM ?TIME)
-- says that ?TIME is the time to delay after the previous application
-- was started before starting the application ?PROGRAM.
fun startupTimeDelay : El ComputerProgram -> El TimeDuration -> Formula ;

-- (stateOfProcess ?PROCESS ?STATE) says
-- that ?STATE is a state of the ComputerProcess ?PROCESS.
fun stateOfProcess : El ComputerProcess -> El ProcessState -> Formula ;

-- (status ?PROCESS ?STATUS) holds if ?STATUS is the current status of ?PROCESS.
fun status : El ComputerProcess -> El ProcessStatus -> Formula ;

-- (strictness ?System ?Attribute) holds if
-- the StrictnessAttribute ?Attribute describes the RealtimeSystem ?System.
fun strictness : El RealtimeSystem -> El StrictnessAttribute -> Formula ;

-- (systemBehavior ?System ?Attribute)
-- holds if ?Attribute is a SystemBehaviorAttribute which describes the
-- RealtimeSystem ?System.
fun systemBehavior : El RealtimeSystem -> El SystemBehaviorAttribute -> Formula ;

-- (systemMeasured ?Event ?System) means that ?Event is an event of measuring
-- the performance of the ComputationalSystem ?System.
fun systemMeasured : El MeasuringPerformance -> El ComputationalSystem -> Formula ;

-- (task ?Process ?Task) means that ?Task is a function to
-- be performed by the ComputerProcess ?Process.
fun task : El ComputerProcess -> El ProcessTask -> Formula ;

-- (taskRelation ?System ?Attribute) holds
-- if ?Attribute is a TaskRelationAttribute which describes the
-- RealtimeSystem ?System.
fun taskRelation : El RealtimeSystem -> El TaskRelationAttribute -> Formula ;

fun thresholdOf : El Computer -> El PositiveRealNumber -> Formula ;

-- (unitMeasuringPerformance ?COMPONENT ?UNIT) holds in case ?UNIT is
-- an instance of UnitOfMeasure which is used to measure the performance of ?COMPONENT.
fun unitMeasuringPerformance : El ComputerComponent -> El UnitOfMeasure -> Formula ;

-- (userName ?Name ?User) means that ?Name is the name the ComputerUser uses
-- to identify himself or herself when logging onto a computer system.
fun userName : El ComputerUser -> El UserName -> Formula ;

}