Upper Ontology
_________________________________________________________________________________________
Table of Contents
0. Uppermost or Primitive Types
0.0. Informal “Decision Trees” of Most Important Types
0.1. Uppermost Concept Type Distinctions (Situation/Entity, Type/ ...)
0.1.1. Situation Uppermost Types
0.1.2. Entity Uppermost Type
0.2. Second-order Types and Their Uppermost Instances
0.2.0. Common 2nd-order Types For Concept Types and Uppermost Instances
0.2.1. Function_type and Uppermost Instances
0.2.2. Relation_type and Uppermost Instances
0.2.2.1. Binary-relation_type and Uppermost Instances
0.2.2.2. Binary Relations Uppermost Distinctions (Functional/Non-functional, ...)
0.3. Types of Basic Relations/Functions (most of which are from an Information_object)
0.3.0. Context (Weakly_true, ...), If, While, ...
0.3.1. Logic Functions (Logic Operators)
0.3.2. Comparable Or Uncomparable, Esp. Via Entailment, Generalisation, PartOf, MemberOf
0.3.2.1. Comparable Or Uncomparable Via Semantic Equivalence (Or Identity)
0.3.2.2. Comparable Or Uncomparable Via Extended Entailment
0.3.2.3. SUP-comparable Or SUP-uncomparable Via Extended Entailment
0.3.2.4. Comparable Via Extended PartOf
0.3.3. Extended Entailments, Their Inverses and Exclusions
0.3.3.1. (Extended) Entailment (Spec/Gen)
0.3.3.2. (Extended) Entailed-By (Spec/Gen)
0.3.4. Semantic Generalizations/Specializations and Their Exclusions
0.3.4.0. Set_of_things_that_may_be_specialized and Spec-exclusive_things
0.3.4.1. Semantic Specializations (Instance/...)
0.3.4.2. Semantic Core Specializations (Natural/Non-natural)
0.3.4.3. Semantic Generalizations (Type/...)
0.3.4.4. Semantic Core Generalizations
0.3.4.5. Statement Generalizations (Truth_preserving/..., Adding_information/...)
0.3.5. Parts, Members, Their Inverses and Exclusions
0.3.5.1. Parts and Exclusions
0.3.5.2. Parts Of
0.3.6. Relations Between Two Statements
0.3.6.1. Relation Between Two Statements, Wrt. the Assertion Of the Source
0.3.6.2. Relation Between Two Statements, Wrt. Truth Preservation
0.3.6.3. Overriding or Correcting Relations Between Two Statements
0.4. Collections and Their Interpretations
0.4.1. Set of Potential Sources of a Transitive Relation (Spec-partition, Part-partition, ...)
1. Attributes/Characteristics/Dimension/Measures
1.1. Attributes Wrt. Object Types
1.2. Attributes Wrt. Roles
1.2.1. Positive/Negative Attribute
1.2.2. Quality Increasing the Usability of the Qualified Thing
1.2.3. Ratio-based Value of a Positive Attribute
1.2.4. N-valuated-Logic Values and Modal Values
1.3. Attributes Wrt What They Qualify
1.4. Attribute Aggregating Other Attributes
1.4.1. Positive Attribute Aggregating Other Attributes
2. Situations
2.1. Relations From Situations
2.1.1. Relations From Situations To Situations
2.1.2. Relations From Situations To Entities
2.1.2.1. Relation From Situations To Contextualizing Things
2.1.2.2. Process Participants
2.2. Processes wrt. Their Relations
3. Description Content/Instruments/Results/Containers (Additional Types
for Creating/Storing or Accessing Representations of Entities/Situations)
3.1. Description Semantic Content
3.2. Description Instruments/Results (Information Objects)
3.2.1. Description Results
3.2.2. Description Instruments
3.2.2.1. Programming Languages
3.2.3. Abstract Description Instruments Or Results (i.e. Abstract Information-objects)
Wrt. the Described Thing(s)
3.2.4. Abstract Information-objects Wrt. the Used Method or Language-element
(e.g. Terms, Statements, Commands)
3.2.5. Statements
3.2.5.1. Statements Wrt. the Described Thing(s)
3.2.5.2. Statements Wrt. Roles (e.g. ODPs, ODRs, Constraints)
3.2.5.3. Statements Wrt. Thruth, Logic Or Composition
3.2.5.4. Statements Wrt. Assertion
3.2.5.5. Statement Wrt. Contradictions or Supports
3.2.6. Composite Information Objects
3.3. Description Containers
0. Uppermost Types
and Types Not Specific to Entities or Situations
0.0. Informal “Decision Trees” of Most Important Types
"80% minimal upper ontology":
types – along with their definitions – that
i) belong to 80% of the most used primitive types in upper ontologies, or
ii) are primitives types useful for partially defining these most used primitive types.
Every type has 0..* (complete or not) sets of (exlusive or not) direct subtypes.
The direct subtypes that should be used for categorization are
i) informally in bold characters,
ii) in a set with [__ use].
Combinations of those direct subtypes are not necessarily provided (via indirect subtypes),
even for the first/main set (so no explicit decision tree but a graphical interface can still
generate a decition tree for search/categoriation).
A natural type may have i) 0..* sets of natural subtypes,
ii) 0..* sets of role subtypes, ii) 0..* sets of phase subtypes, etc.
A role/phase type can only have role/phase subtypes.
There should be many depths|encodings, e.g.,
i) 1(+) Type-set_wrt _(natural_type) (e.g. Type/Sit/Ent, ex Type_for_categorizing_wrt_object_natural_types),
ii) 1(+) Type-set_wrt _(object_natural-type) (ex Set-of-types_for_categorizing_wrt_object_types),
iii) 1+ Type-set_wrt _(role_of) (ex Type_for_categorizing_wrt_role),
iv) 1+ Type-set_wrt _(attribute) (ex Type_of_Type-set_wrt _(attribute)),
v) 1+ Type-set_wrt _(contextualizing_relation) (e.g. phases).
//no: 2 bits for binary partitioning: 0(non)/1(oui)/2(unknown)/3(role)
//complex and a default max depth of 32 might be too restrictive
//yes: 1 bit for binary partitioning (if unknown, parent is used; Thing=1stBit; Nothing=Impossibility=0)
// so use the order amongst partitions (or the types 1stDiscriminantPartition, 2nd... but complex)
// with warning/fix if the 1stPartition is not a natural one, given the type definitions
// and all but one (the first natural one) *may* not have fully defined types;
// in an {\.,=,=!}intern-complete KB, any two of 2^64 non-equiv types can be compared via at most 64 bits
// from the lowest bit to the highest bit; in 2 groups of 32 or 64 bits: see above i) and ii)
// warning: v_p{...} should count too!
==== Natural type/kind:
Thing
Type //2nd-order concept type //depth 1 (or more if relation accessed via role types)
Concept_type //e.g. Ontoclean
Relation_type //types for RTs: Symmetry Reflexivity Injectivity, TotalOrder, ...
Non-type_thing = Individual_thing
Relation-or-function_individual = relation_or_function //= Proposition ?
fct //depth 3
relation //! symmetry reflexivity injectivity //depth 3
!order
order //depth 4
totalOrder //depth 5, for now; symmetry, reflex, ...
partialOrder!TotalOrder //asymetry, ...
!strictPartialOrder
strictPartialOrder //depth 6
p{ ...OnTypes (...OnIndivs p{ ...onStatements ...onIndiv!Statements }) }
p{ output_or_successor_or_implication !Output_or_successor_or_implication } //depth 7
!gSpec p{ !Part !Part (e.g. SubProcess, PhysicalPart) } //what about GSpecAndPart?
gSpec //depth 7
lexicalGSpec
semanticGSpec p{ ...OnTypes (...OnIndivs p{ ...onStatements
...onIndiv!Statements }) }
Concept_individual
Situation //depth 2
State //wrt. rel. from main object
Process //wrt. input/output then agent then union/division
Entity //depth 2
Attribute_or_characteristic_or_dimension_or_measure //Value vs. !Value //depth 3
Entity_that_is_not_a_characteristic_or_dimension_or_measure //Endurant //depth 3
Entity_not_having_at_least_1_spatial_attribute //depth 4
Entity_not_having_at_least_1_spatial_attribute_and _not being_a_description_object
Description_content-or-instrument-or-result-or-container = Description_object //depth 5
Description_container //e.g. File, Software, Web_server, KB_server
Description_semantic-content //e.g. Proposition_content
Description_instrument-or-result = Information-object //e.g. Proposition //depth 6
p{ Fully-informal_information-object Not-fully-informal_information-object }
p{ Concrete_information-object //e.g. Java_concrete_grammar, Character
Abstract_information-object }
p{ Fully-declarative_information-object Non-fully-declarative_information-object }
p{ Expression //cannot have a truth value|status, e.g., Type, Word, Quantifier, ...
Statement_or_proposition //has or can have a truth value|status //depth 7
Statement = Information //rt instance //e.g. Type_description/definition)
Proposition = relation //can have -- but does not have -- truth value|status
}
Semantic_information-object = Representation_object //but still viewable as !semantic
Non-semantic_description_instrument-or-result
Lexical_information-object //depth 8
Structural_information-object //depth 8
!ADT //Abstract_function, ...
Abstract_data_type //depth 10
!Structured_ADT //Char vs. !Char
Structured_ADT //depth 11
!Array //struct/OO_class vs. !...
Array //depth 12
!NumericallyIndexedArray //AA vs. !AA
NumericallyIndexedArray //String vs. !String
Entity_having_at_least_1_spatial_attribute //Spatial_entity, e.g. Spatial_point //depth 4
Non-physical_spatial-entity //e.g. Mathematical_square //depth 5
Physical_spatial-entity
Non-concrete_physical_spatial_entity //e.g. Radio_wave, Magnetic field //depth 6
Concrete_spatial-entity
Concrete_spatial-entity_that_is_not_a_physical-object //e.g. Matter, Clay //depth 7
Physical_object
Non-biological_physical_object //Natural vs. Artefact //depth 8
Biological_object
Non-animal_biological_object //depth 9
Animal \. p{ Human_being vs. Not_human-being }
==== Role-based type/kind:
from_an_Entity //link to Entity made via the signature or the supertype links
from_a_Situation
!from_a_Situation_to_an_Entity
from_a_Situation_to_an_Entity
relation_from_a_Situation_to_a_contextualizing_thing // !Participant; no: use context
relation_from_a_Situation_to_a_non-contextualizing_thing //Participant
!agent_or_from-or-to-agent
!input_or_output
input_or_output
!input
input //e.g. parameter
!output //deleted vs. !deleted, then (intrinsically) modified vs.!
output //created vs. !created, then (intrinsically) modified vs.!
agent_or_from-or-to-agent //causal vs !causal, then conscious/!conscious, then Person/!person
!from_agent
from_agent //e.g. Student, Driver
!to_agent //(intrinsically) modified vs.! OR volitional/!volitional
to_agent //(intrinsically) modified vs.! //experiencer/beneficiary
==== Generated phase-based/location-based type/kind: //no need: simply give temporal context
for_an_Entity //with the link to Entity made via the signature ?
Living/mature/... (for once potentially living being / animal)
for_a_Situation
0.1. Uppermost Concept Type Distinctions (Situation/Entity, Type/ ...)
Thing .[] //".[]" is a way to signal the parser that "Thing" is a concept type
:= "anything is a Thing" //^'Thing' has for full_definition "anything is a Thing"
`∀x Thing(x)', //formal full_definition in PRN
= owl#Thing,
=! //"=!" is an abbreviation for pm#complement_class
(
owl#nothing = kif#bottom __[pm] sowa#absurdity __[pm] daml#empty __[pm],
:= "the type of logically impossible objects (not of imaginary objects such as unicorns);
this type cannot have any instance or subtype" ),
\_ //"\_" is for natural_strict-subtype, "\~" for non-natural_strict-subtype
//next line: "v_p", not "p", because a relation may be viewed as a Proposition or Statement
v_p{
Type /* //---------- this commented part is asserted and detailed in Section 0.2.1:
._( := ^"supertype of all 2nd-order types (those with types as instances)", = sub#Type,
\_ p{ (
Concept_type = Class Non-statement_type)
(
Function-or-non-unary-relation_type = Statement_type)
} ) //---------- end of commented part */
(Non-type_thing = Individual_thing Statement-or-not_Individual_thing,
\. v_p{ Function_or-N-ary-relation_individual // _( = relation function ) //see 0.3 and 2.1
(Concept_individual
\_ p{ Situation (Entity_individual = ^@(Entity exceptFor: Type)) })
} )
._(type _[.*->.]: Main_partition, type _[.&->.]: Ignored_partition)
//this partition (not its items: "_[.->.]") is first for exploitation but ignored for display
},
\_ p{
Situation //see next partition and next subsection
Entity //See Section 0.1.2
}
._(type _[.&->.]: Main_partition, type _[.*->.]: Ignored_partition)
//this partition (not its items: "_[.->.]") is first for display but ignored for exploitation
p{ (Thing_with_temporal_part = Occurrent, //existence_related_to_a_time_period,
// = "Thing defined wholly with reference to time or
// which consists of one or more things which are defined wholly with reference to time",
// ^"Thing that cannot have one of its parts removed without loosing its identity"
// ^"Thing that happens (has participants)"
\. Process //= Occurrent_that_is_a_perdurant Occurrent_that_is_a_situation
// ^"temporally extended entity of which the temporal parts are
// temporal entities (occurrents), down to the theoretical limit of instants"
// ^"Thing that happens (has participants) and makes a changes"
Entity_seen_as_4D ) //viewpoint
(Thing_without_temporal_part = Continuant, //existence may be related to time period
= ^"Thing, when it exists, exists in all its parts, even if it changes over time",
\. p{ Thing_related_to_a_time_period Thing_not_related_to_a_time_period }
p{ State //= Continuant_that_is_a_perdurant Continuant_that_is_a_situation
// ^"temporally extended entity of which the temporal parts are spatial entities
// (continuants), down to the theoretical limit of spatial points"
//
https://www.researchgate.net/post/Perdurant-occurrents-and-perdurant-continuants-definitions-and-implications
Endurant // \.viewpoint: Entity_seen_as_3D //Endurants "participate"
} )
}
p{ (Thing_whose_existence_is_related_to_a_time_period = Thing_with_temporal_extent Particular,
\. p{ Situation //= pm#Perdurant //"pm#"! //e.g. my life
//in DOLCE: State Process Achievement Accomplishment
Endurant // \.viewpoint: Entity_seen_as_3D //e.g. me at a certain time period
} ) //an endurant is a particular reification of a perdurant = commitment to an identity
// Leibniz's Law: identity is based on having the same properties
// but parts and other properties change over time
//Endurant: something which exists and retains its identity across points in time
(Thing_whose_existence_is_not_related_to_a_time_period = Thing_without_temporal_extent,
\. Type Mathematical_thing
Attribute_or_characteristic_or_dimension_or_measure ) //Section 1
}
p{ sub#Statement //= Logical-or-not_sentence ... see Section 3 //or Proposition
(sub#Individual = sub#Non-statement_individual sub#Individual_in_the_sense_of_OWL-DL)
}
v_c{ (sowa#Firstness_thing = ^"Thing considered as an atomic separate entity")
(sowa#Secondneness_thing = ^"Thing considered wrt. its parts")
(sowa#Thirdness_thing = ^"Thing considered wrt. some of its relationships to some other things")
},
\~= Thing_wrt_role |^ Type_wrt _(role_of), //e.g., wrt. agent/object/end_situation relations
(Thing_wrt_part_relations |^ Type_wrt _(part),
\~ v_p{ Atomic_thing Composite_thing /*alias Collection; details in
Section 0.4 */
} ).
0.1.1. Situation Uppermost Types
Situation = Perdurant,
:= ^"Thing 'occurring' ('happening') in a real/imaginary region of some time and space"
^"
Thing that has temporal part: sequential ones if it is not instantaneous, i.e. if it
is a
perduring occurrent, a thing for which only a part exists at any point in time",
/* \. Perdurant_continuant: temporally extended entity of which the temporal parts are spatial
entities (continuants), down to the theoretical limit of spatial points;
Perdurant_occurrent: temporally extended entity of which the temporal parts are temporal
entities (occurrents), down to the theoretical limit of instants.
//https://www.researchgate.net/post/Perdurant-occurrents-and-perdurant-continuants-definitions-and-implications
// David Hirst
*/
\. v_p{ (
Process .[1..* Agent ?a ~% 1..* Object ?o] ?p //a signature associated to a concept type
// ?ct (here Process the type of ?p) supports the automatic derivation of a
// relation type ?rt, the definition of which can also be directly associated
// to ?ct (see the 1st formal definition below). If a relation of type
// ^'derived_relation-type' (from ?ct to ?rt, as illustrated below) is also
// specified, ?rt is identified/specified. If a relation of type
// ^'derived_relation-type' is specified but no relation signature is associated
// to ?ct or ?rt, this signature is `.[Thing ~% ?ct]'.
// From each subtype of ?ct a subtype of ?rt can be automatically derived.
// This may be used as a way to fully derive the relation type hierarchy from
// the concept type one and hence help normalize and organize the KB.
//Furthermore, in FL, ?ct can directly be used instead of ?rt in a relation node
// (or a function head node if the signature is one of a function type)
:= ^"Situation making a change, hence whose end_situation is different from its
begin_situation",
end_situation:=> (a Situation != (the Situation begin_situation of: ?p)),
agent:=> 1..* Agent ?a, object:=> 1..* Object ?o, //definition of ?rt
\. (Cooperation_related_process //further defined in Section 2.0a
\. Information-sharing_related_process /* defined in Section 1.0.1 */
(Representing_knowledge
\. Representing_knowledge_for_particular_applications
Representing_knowledge_for_knowledge-sharing ) ) )
(
State := ^"Situation that is not seen as a Process")
}
p{ (Spatial_situation = Situation_with_spatial-entity_as_output
^(Situation output: a Spatial_entity) )
Non-spatial_situation
},
\~= (Situation_wrt_non-natural_type |^ Type_wrt _(non-naturel_type),
\~= (Situation_wrt_attribute |^ Type_wrt _(attribute)),
relation_from_this_type _[.->.]: relation_from_a_Situation //see
Section 2.2
)
//Section 2.2 gives the signature and direct subtypes of this relation type.
// Based on this signature, an FL parser would actually have generated this last
// ^'relation_from_this_type' relation if it had not been manually specified here.
// The `_[.->.]' part specifies that this relation is between types, not between
// their instances. This `_[.->.]' part is optional for relations whose signature
// specifies that they are between types, i.e. between instances of Type that are
// different from the type Thing.
0.1.2 Entity Uppermost Types
Entity
:= ^"Thing that is not a Situation, hence that may be
1. an
Endurant (thing that has no conceptually distinguishable temporal parts
and thus exists in its entirety at each instant of its existence,
i.e., it is temporally complete at any point in time)
participating in a situation (i.e.,
involved in one), or
2. an Attribute (
Characteristic|Dimension|Property|Quality|Trope|Criteria
or a Measure|Value|Quale for it) of an Endurant",
\. p{ (
Attribute_or_characteristic_or_dimension_or_measure //Section 1
=
Attribute .[1..* Thing ?o ~% ?a] ?a //e.g. Temporal_attribute (Section 1.1)
:= ^"
Characteristic|Dimension|Property of something (e.g. Speed)
or measure for it, via a constant (e.g. '27m/s')",
:=> //as further explained at the beginning of
Section 2.3:
"at least in FL, a function type or the definition of a
function can be used for defining its result, typically
a measure; thus, for example, the measure of speed can be
defined via a function dividing a distance by a duration",
derived_relation-type: (attribute = attr, \. chrc),
\. p{ (Characteristic = dolce#Quality,
:=> "sometimes also named Dimension, Property, Trope or Criteria",
derived_relation-type: (characteristic = chrc property) )
(Measure = dolce#Quale Attribute_value,
= ^(Attribute chrc_measure of: a Characteristic),
\~ v_p{
Value_of_a_positive_attribute Value_of_a_negative_attribute },
(Percentage_value \. p{ 0pc Between_0_an_100pc 100pc })
(Logical-or-modal_value
\. p{ (Logical_value = Truth_value Truth_status,
\. (Boolean_value \. p{ (False_value /^ 0pc) (True_value /^ 100pc) } ) )
Non-logical_modal_value
} ),
derived_relation-type:
(measure
\. p{ measure_with_unit
(value := ^"measure without associated unit",
\. (normalized_value := ^"value in the standard/default unit") )
}
chrc_measure ) )
}
p{ Numerical_attribute Non-numerical_attribute
} //the next two subtypes should be generated
\~ (Attribute_wrt_object_natural_type //with (for attributes) "object" = "attr of"
object_natural-type @:=> Thing /* subtypes generated for navig even if no spec.
@|^ Type_wrt _(object_natural-type) //'@' not needed when 1..* non-generated spec. */ )
(Attribute_wrt_role |^ Type_wrt _(role_of) //with "role" = "(attrOf)agent/object of Process"
) //@@@@ to do: define object_natural-type, role_of and core-object_natural-type
(Endurant = Entity_that_is_not_a_characteristic_or_dimension_or_measure,
\. p{ (
Spatial_entity = Entity-with-spatial-dimentions_or_point-in-some-space
Entity_having_at_least_1_spatial_attribute,
\. p{ (Spatial_entity_without_physical_attribute \. Mathematical_square)
(Spatial_entity_with_physical_attributes
\. Animal Building Street Market_square Electron )
})
(Non-spatial_endurant
\.
Description_content-or-instrument-or-result-or-container ) //
Section 3
} )
},
\= (Entity_instance_of_non-natural_type
:=> "the subtypes of this type are 'non-natural types';
they are one way to categorize natural type instances having particular relations
in a particular temporal/spatial/modal/... context; e.g.,
from the definition (of the non-natural type Not-yet-adult_cat)
`Not-yet-adult_cat = ^(cat attribute: (an age less_than: 1 year))'
and the fact
` `Tom attribute: (an age less_than: 1 year)' time: between 1980 and 1999'
an inference engine could derive
` `Tom type: Not-yet-adult_cat' time: between 1980 and 1999' ",
\= Closed_set //or simply "c"
{ (Entity_with_a_relation_to_a_situation
\. (Situation_participant
derived_relation-type: relation_from_a_Situation_to_an_Entity
/*
Section 2.2 presents many relation subtypes */ )
(Entity_with_a_relation_to_a_process
\. (Entity_that_can-or-is-or-was-or-will-be_playing_a_role
\. (Entity_that_can_play_a_role
\. Non-exclusive_set
{ (
Causal_entity := ^"Entity that can cause something",
initiator of:=> 0..* Process,
\. p{ (Physical_causal-entity /^ Physical_entity)
(Non-physical_causal-entity \. Software)
}
p{ (Volitional_causal_entity =
Agent,
agent of:=> a Process,
part: 0..* Agent, //i.e. may be a group of agents
\. p{ (Agent_able_to_experience_satisfaction_or_dissatifaction
= Conscious_agent )
Agent_not_able_to_experience_satisfaction_or_dissatifaction
}
p{ Physical_agent
(Non-physical_agent \. (Software_agent /^Software))
}
v_p{ (Set_of_agents := Set{1..* Agent})
(Atomic_agent \.p{Sofware Living_entity})
} )
Non-volitional_causal-entity
} )
(
Instrument := ^"Entity usable as instrument",
instrument of:=> 0..* Process,
\. c{ (Physical_causal-entity supertype: Physical_entity)
Agent
} )
} )
(Entity_playing_a_role .[?source ~% ?r] ?r
derived_relation-type:
relation_to_an_Entity //click for details
) ) ) )
(Entity_with_a_relation_to_something-other-than-a-situation
\= (Entity_with_a_temporal_relation
\= (Entity_in_a_temporal_phase
\. (Animal_in_a_temporal_phase //this is just an example
\. p{ Not_yet_adult_animal Adult_animal } ) ) ) )
}.
0.2. Second-order Types and Their Uppermost Instances
0.2.0 Common 2nd-order Types For Concept Types and Uppermost Instances
Type := ^"supertype of all 2nd-order types (those with types as instances)", = sub#Type,
\. //An "individual constant" (i.e. a Concept_individual that is not a Proposition) is often identified
// as a zero-ary function constant.
//A Proposition symbol is often identified as a zero-ary relation symbol.
//A(n N-ary) Relation is often identified as a function mapping its arguments to a zero-ary relation.
//In KIF(Knowledge Interchange Format), a Concept_type is represented a Unary-relation_type,
// and a function with N arguments is represented as an n+1-ary functional relation that maps
// the arguments to the value returned by the function.
//These viewpoints are not incompatible. None of them is explicitly represented below.
p{
(
Concept_type = Class Non-statement_type, := ^"type of all concept types",
:=> "for people who view a Concept_type as a Zero-ary-relation_type
or a Unary_relation_type, Concept_type is subtype of Relation_type",
\= (rdfs#Class \= owl#class),
\. (Attribute_type = ^(Type /^ Attribute)
derived_relation-type: (attr_type .(Thing ?o, Attribute_type ?at)
:= [?o attr: (an Attribute type: ?at)] ) )
)
(
Function-or-non-unary-relation_type = Statement_type,
:= ^"type of all function or non-unary relation types", //see Section 2.1
\. p{ Function_type
(Non-unary-relation_type
\. (
Binary-relation_type = rdf#Property,
|.
binary_relation, //see below
\. p{ (Functional-binary-relation_type ?rt
:= [ [^src ?rt: ^dest1 ^dest2] => [^dest1 = ^dest2] ],
|.
functional_binary_relation ) //see below
(Non-functional-binary-relation_type
|.
non-functional_binary_relation ) //see below
} ) )
}
p{ (
Non-functional-relation_type |.
non-functional_relation) //see below
(Function-or-functional-relation_type
\. p{ Function_type
(Functional-relation_type |. functional_relation)
} )
} )
}
(Essential_type) //from Ontoclean, DOLCE, Onto-UML
p{ (Rigid_type)
(Anti-rigid_type ?t
\.:=> an Anti-rigid_type )
}
(Semi-rigid_type).
0.2.1. Function_type and Uppermost Instances
Function_type //2nd-order type
|. function. //1st-order type
function
\. (Aggregation_function = aggregation_function), //in WebKB, this '=' is useless (→ automatic)
\~ (function_wrt_result_type |^ Type_wrt _(result_type),
\. p{ (Type_generating_function = ^(function result: a Type),
\. p{ Concept_type_generating_function
(Function-or-non-unary-relation_type_generating_function
\. p{ Function_type_generating_function
(Non-unary-relation_type_generating_function
\. (f-rt__attributeRT__operRT .(Attribute_type ?attrRT,
function ?operRT)
-% (?subOperRT .(?x,?y) /^ ?operRT,
:= [?x ?attrRT: (a Measure ?vx :_ ?operRT :
(the Measure ?vy :_ ?attrRT of: ?y))
] ) ) //this (and the next) used below for defining
// the fct ^'>=' (= superior_or_equal)
(f-rt__attributeRT__operRT .({2..* Attribute_type ?attrRT
} ?attrRTs, function ?operRT)
-% (?subOperRT .(?x,?y) /^ ?operRT,
:=% //not ":=%" to let users add defs for some ?operRT
[?x /*for each*/?attrRT: (a Measure ?vx :_ ?operRT :
(the Measure ?vy :_ ?attrRT of: ?y))
] ) )
(f-rt__attributeRT-set__operRT .(1..* Attribute_type ?attrRT,
?operRT,
Aggregation_function_on_proposition-set_and_generating_a_proposition
?aggregFctOnPropSetAndGeneratingProp)
-% (?subOperRT .(?x,?y) /^ ?operRT,
:= ?aggregFctOnPropSetAndGeneratingProp
_(.{each [?x ?attrRT: (a Measure ?vx :_ ?operRT :
(the Measure ?vy :_ ?attrRT of: ?y))]
}) ) )
} )
}
(Type_wrt .(?relRt) -% Type ?t
\. p{ (Concept-type_wrt .(Binary-relation_type ?relRt) -% Concept_type ?subCT
:= [?subCT = ^(Thing ?relRT: a Thing)] )
Function-or-non-unary-relation_type (Concept-type ?ct)
-% Function-or-non-unary-relation_type ?subRT
} )
)
(Non-type_thing_generating_function = ^(function result: a Type),
\. e{ Statement-or-logical-value_generating_function //Section 0.3.1
(Information-object_generating_function -% Information-object
\. (Aggregation_function_on_proposition-set_and_generating_a_proposition
.(.{1..* Proposition?p} ?ps) -% Proposition ?resultProp,
/^ Aggregation_function,
\. (Majority-based_aggregFct_on-propositions_and_generating_a_prop
:= [?resultProp = .AND{at least 51% of .p}] ) ) )
} )
} ).
0.2.2. Relation_type and Uppermost Instances
Each relation type implicitly or explicitly has a signature: the array of the
types of the information objects connected by a relation of this type.
In these signatures, for each type, a variable may also be used for referring to
universally quantified instances of this type.
In FL, variable identifiers begin by "?".
Signatures of a relation type are inherited by its subtypes and may be overrided
by the signature of these subtypes.
The default (i.e. implicit) signature is "(+)".
In a signature, "*" refers to a positive (natural) number of arguments of type Thing,
and "+" refers to a strictly positive number of arguments of type Thing,
Non-unary-relation_type
\. (Type_of_fake_uppermost_relation_type
:= "Warning: any instance ?rt of this type is a supertype for all relation types ?rt that
are instances of a particular subtype of Relation_type ?s BUT these relation types ?rt may
ALSO be subtyped - or at least specialized - by relation types which are NOT instances
of ?s; thus, an ?rt is only useful for navigation purposes: it should not be used for
inferencing purposes" )
p{ sub#object_not_known_to_be_related-to_via .(.{1 Thing, 0..* Thing ?otherParameters} -: ?x)
(sub#object_known_to_be_related-to_via
\. comparable-or-uncomparable_via )
},
|. (relation_from_a_Thing .(Thing ?t, *) = relation,
:= ^"supertype of all relation types", //uppermost instance of Relation_type
\. e{ relation_from_a_Situation relation_from_an_Information-object
} ).
0.2.2.1. Binary-relation_type and Uppermost Instances
Binary-relation_type = rdf#Property,
|. binary_relation, //see below
\. (Inverse-functional-relation_type ?rt
:= [ [^dest ?rt of: ^src1 ^src2] => [^src1 := ^src2] ],
|. (identifier .(Thing %- Concrete_language-element) = id)
(inverse-functional_attribute // /^ attribute, //below
= i_attr,
:= ^"attribute individual generated to uniquely identify its
source, even though its value may be shared by many other
such attribute",
:=> "this relation is crucial to ease the definition
of particular types of attributes" ) )
(Transitive-binary-relation_type ?rt
:= [ [^?x ?rt: (^y ?rt: ^z)] => [^x ?rt: ^z] ],
|. transitive_binary_relation ) //below
(Type_of_relation-type_necessary_for_any_instance_of_its_domain ?rt
:= [ [?rt .(?tSrc, ?tDest) ] => [any ?ct ?rt: a ?Dest] ],
|. part consequence )
(Type_of_preference_relation |. preferred_thing //total/partial ordering
).
0.2.2.2. Binary Relations Uppermost Distinctions (Functional/Non-functional, ...)
binary_relation .(Thing ?t, Thing ?t) ?
= relation_to_a_Thing owl#topObjectProperty sub#relation ,
= ^"fake supertype of all binary relation types",
:= [by default any ^(type subtype of: binary_relation) type: Binary-relation_type],
type: Type_of_fake_uppermost_relation_type,
:=> "Warning: a binary relation type may be specialized
(although not 'subtyped' in its most common sense) by a relation type
with more arguments (that contextualize/precise it) or
with less arguments (some being hard-coded by
currying)",
\. p{ relation_to_a_Situation .(Thing, Situation)
relation_to_an_Entity .(Thing, Entity)
}
n{
non-functional_binary_relation //should not be used, the signature states this
functional_relation
}
n{
transitive_binary_relation non-transitive_binary_relation }.
transitive_binary_relation //= comparison_relation, ???
type: Type_of_fake_uppermost_relation_type,
= ^"fake supertype of all transitive relation types",
:= [by default any ^(type subtype of: transitive_binary_relation)
type: Transitive-binary-relation_type],
:=> "Warning: a transitive relation type may be specialized by a non-transitive relation type",
\. p{
transitive_binary_relation_definable_using_a_part_or_member_relation
transitive_binary_relation_not_definable_using_a_part_or_member_relation
}.
transitive_binary_relation_definable_using_a_part_or_member_relation
\. e{ gGeneralization_or_equivalent gSpecialization_or_equivalent
part //defined in Section 2.3
(
transitive_member-relation
:= ^"member relation that is transitive",
\. (
definition_member .(?t, ?dm)
=
definable-with, //sub#definition_element (ex "definition_part")
//:= [?t definition: (a NR_Statement member: a Thing ?dm)],
:= OR{ [?x gGen: ?y] [?y gGen: ?x]
[?x type: Type, definition: (a Definition member: (a Thing gSpecEq of: ?y))]
[?y type: Type, definition: (a Definition member: (a Thing gSpecEq of: ?x))]
[?x type: Individual (?t != Individual),
definition: (a Definition member: (a Thing type: ?t, gSpecEq of: ?y)) ]
[?y type: Individual (?t != Individual),
definition: (a Definition member: (a Thing type: ?t, gSpecEq of: ?x)) ]
},
\. gGen gSpec //given the above definition
(definition_type-member .(?t, Type)
\. (main_definition-type-member = genus,
\. cGeneralization,
converse: (genus_of \. derived_relation-type) //next definition below
) )
) )
}.
transitive_binary_relation_not_definable_using_a_part_or_member_relation
\. e{ (
output_or_successor_or_conclusion = ^'*->' ^'*→' ^'*/^',
\. p{ output successor_situation
formal-or-informal_conclusion_of_a_rule-or-inference_meant_to_be_valid
} )
preferred_thing .({1..* ?other_thing}, ?preferred_thing) //partial/total ordering
superior_or_equal //not set-based; has a subtype `maximum' overloaded by the next one
}
(
maximum .(.{1..* ?t ?x}, ?t ?y) := [each ?x =< (?y =< no ?t ?z)]
).
superior_or_equal .(?t ?x, ?t ?y) = ^'=<' less-than_or_equal lte,
derived_function_type: //overloading identifiers thanks to their different signatures
e{ (^'=<' .(1..* Attribute_type ?attrRT) = f-rt__attributeRT__operRT _(?attrRT,lte))
(^'=<' .(1..* Attribute_type ?attrRT,
Aggregation_function_on_proposition-set_and_generating_a_proposition ?ft)
= f-rt__attributeRT-set__operRT _(?attrRT,lte,?ft) )
},
\. e{ (superior-or-equal_for .(?x, ?y, Attribute_type ?attrRT) //called as in this def:
:= [?x =< _(?attrRT,lte): ?y] )
(superior-or-equal_for .(?x, ?y, 1..* Attribute_type ?attrRT,
Aggregation_function_on_proposition-set_and_generating_a_proposition ?ft)
:= [?x =< _(?attrRT,lte,?ft): ?y] )
},
converse:
(strict_inferior = ^'>' greater-than greater_than gt more-than more_than,
\. (better-than
\. (better-than_wrt_argumentations-or-preferences
\. { (better-than_wrt_argumentations
\. p{ (better-statement_than //def. in 0.3.6.1, used in 3.2.5.4
= better-supported_than )
(Uncontradicted-or-unsuccessfully-contradicted_better-than
:= [ [?x better-than: ?y ] |^
Uncontradicted-or-unsuccessfully-contradicted_statement
] )
} )
} )
(better-than_wrt_ethicalities-conform_argumentations-or-preferences ?s
:=% [[[?x attr: no ^(Attribute_type exclusion: each Ethicality_to_be_used)]
[?y attr: no ^(Attribute_type exclusion: each Ethicality_to_be_used)]
[?s attr: no ^(Attribute_type exclusion: each Ethicality_to_be_used)]
] <= ThisKB ] //closed-world each + global paramameter
derived_function_type:
(f-rt_better-than_wrt_ethicalities-conform_argumentations-or-preferences
.(1..* ^(Type /^ Ethicality_to_be_used) ?et) -% ?rt .(?x,?y)
:=[ [?x attr: no ^(Attribute_type cSpec_exclusion: each ?et)]
[?y attr: no ^(Attribute_type cSpec_exclusion: each ?et)]
[?s attr: no ^(Attribute_type cSpec_exclusion: each ?et)] ] )
) )
(
minNE = minimum_not-equal) ),
\. p{ equal
(strict_superior = ^'<' less-than lt,
converse: (inferior_or_equal = ^'>=' more-than_or_equal gte)
derived_function_type:
e{ (^'<' .(1..* Attribute_type ?attrRT)
= f-rt__attributeRT__operRT _(?attrRT,lt),
\. better-than_wrt .(1..* Positive_attribute ?criteria) )
(^'<' .(1..* Attribute_type ?attrRT,
Aggregation_function_on_proposition-set_and_generating_a_proposition ?ft)
= f-rt__attributeRT-set__operRT _(?attrRT,lt,?ft) )
} )
}
p{ (
maximum .(?t ?x, ?t ?y) := [?x =< (?y =< no ?t ?z)], //overloaded
\. p{ (
maxNE /^ strict_superior)
maxE } // (see above)
best .(.{1..* (Positive_attribute ?t) ?x}, ?t ?y) )
(not_maximum \. (minimum \. p{
minNE min }))
}
)
}.
non-transitive_binary_relation
\. n{ (
exclusion .(?x, ?y)
\. e{ (
core-specialization_exclusion .(?x, ?y) = cSpec_exclusion cSpec_excl,
:= [ [^ix type: (^sx cSpec of: ?x), != (^iy type: (^sy cSpec of: ?y))]
=> [ [?ix != ?iy] [?sx != ?sy] ] ] )
(
part_exclusion .(?x, ?y) = part_excl,
:= [ [^ix cSpec of: (^sx part of: ?x),
!= (^iy cSpec of: (^sy part of: ?y))]
=> [ [?ix != ?iy] [?sx != ?sy] ] ] )
} )
(
attribute .(Thing, Attribute) = attr, \. inverse-functional_attribute)
(
instrument .(Thing, Thing) = instr)
(
derived_relation-type .(Concept_type .?ct, Relation_type ?rt)
:=> [ [^ct1 ?ct: ^ct2] => [^ct1 ?rt: ^ct2] ],
:= "using ?ct in a relation node in the place of a relation type
(if this is allowed by the used KR) is equivalent to using ?rt" )
}.
0.2.2.2.1. Functional Binary Relations
functional_binary_relation .(Thing -: Thing) //or: .(Thing, 0..1 Thing)
url: "https://encyclopediaofmath.org/wiki/Functional_relation",
type: Functional_relation_type Type_of_fake_uppermost_relation_type,
\. ne{ (converse .(Binary-relation_type ?rt1 -: Binary-relation_type ?rt2)
:= [ [^src ?rt1: ^dest] => [^dest ?rt2: ^src] ],
\. (inverse := [?rt1 converse: rt2, type: Bijective_relation_type])
)
(negation /^ exclusion,
\. e{ negated_statement-or-logical-value //defined in Section 0.3.1
(negated_relation-type .(Type ?rt1, Type ?rt2)
:= [ [^x ?rt1: ^y] <=> ![^x ?rt2: ^y] ] )
} )
(monotonic_functional_binary_relation .(^Numerical_attribute -: ^Numerical_attribute)
//relation between numerical attribute types, not instances of them
\. (monotonic_numeric_functional_relation
\. p{ (monotonously-increasing_numeric_functional_relation
\. (positive_gradual-rule_destination = ^'++/^' ^'++:',
converse: (positive_gradual-rule_destination_of
= ^'^\++' ^':++' ),
:= "The more the source increases, the more the destination increases",
example: "the more food a man eats, the more this man puts on weight"
[any Man ?m [^(?mass mass of: (the food object of:
1..* ^(eating agent: ?m) ) )
++/^ ^(?w weight of: ?m) ] ] ) )
(monotonously-non-increasing_numeric_functional_relation
\. (monotonously-decreasing_numeric_functional_relation
\. (negative_gradual-rule_destination
= ^'+-/^' ^'+-:',
converse: (negative_gradual-rule_destination_of
= ^'^\-+' ^':-+' ),
:= "The more the source increases,
the more the destination decreases" ) ) )
}) )
}.
As seen in Section 0.2, although somewhat implicitly,
each ^'Term' in a KR is an Abstract_language-element but
i) can refer to anything (typically via Description_semantic-content),
ii) is written via – and may also be –
a Concrete_language-element.
KRs often do not use relations to make explicit and relate these different notions.
Indeed, using such relations makes KRs very cumbersome to read and write.
Therefore, KR parsers/interpreters/checkers
– or at least FL ones – take into account the
conflating of these notions when checking that KRs respect the signatures
the types of the relations they include (however, if there is an ambiguity,
it should be signaled). E.g., writing
[ [a Cat place: a Mat] type: Description_semantic-content Description_instrument]
is not a contradiction even though these last two types are exclusive:
indeed, two different things are typed here. This sentence is only useless: it
brings no additional information to interpreters that know about the
meaning of Description_semantic-content and Description_instrument (and
interpreters that do not know may conclude this is an error).
Similarly, a function is an information object but, at least with FL, can be
used as a definition for i) a process type, ii) any type equal to
the function result type, or iii) a type which can be defined by the
information object result of the function. Again, any ambiguity or contradiction
should be signaled by the parser.
relation_to_an_Information-object .(+, Information_object)
\. (information_object
\. representing_information-object
method_descr .(Process, Method_description) )
relation_between_2_Information-objects.
relation_from_an_Information-object .(Information_object .?, *)
\. (information-object_container .(Information_object .?, Information_container)
/^ description_container )
relation_between_2_Information-objects.
relation_between_2_Information-objects .(Information_object .?, Information_object)
\. p{ (relation_from_an_Information-object_to_a_Statement .(Information_object .?, Statement)
\. ne{ (relation_from_a_Term_to_a_Statement .(Term .?, Statement)
\. (definition .(Information_object .?, Statement)
:=> "a full definition of a statement is equivalent to this statement",
\. c{ sub#"<=" sub#"=>" }
(full_definition = ^':=')
(necessary_condition = ^':=>' ^':=%')
(sufficient_condition = ^':<=' ^':%=')
annotation
) )
relation_between_two_statements //Section 0.3.6
} )
(relation_from_an_Information-object_to_one_that-is-not-a-Statement
\. (relation_from_a_Statement_to_an_information-object_that-is-not-a-Statement
\. (statement_contextualizing_object-that-is_not-a-statement
\. pm#believer .(pm#description,pm#causal_entity)
pm#modality .(pm#description,pm#modality_measure) )
) )
}
(contextualizing_object
\. p{ (contextualizing_object-that-is_not-a-statement
\. statement_contextualizing_object-that-is_not-a-statement ) //above
(contextualizing_statement \. statement-contextualizing_statement) //below in Section 0.3.6
} )
logic_operator
comparable-or-uncomparable_via_gSpecialization_or_part .
0.3.0. Context (Weakly_true, ...), If, While, ...
/*
kif98#weakly_true = kif9_#wtr
kif93#true
IKL#isTrue =?=
IKL#ist
+ translation into fct with added param or other ad-hoc forms
*/
if .(Situation ?condition, Situation ?thenStmt, Situation ?elseStmt) -% Situation o
:= [ [ ?condition => [?o = ?thenStmt] ] [! ?condition => [?o = ?elseStmt] ] ].
while .(Situation ?condition, Process ?loopProcess, Situation ?i) -% Situation ?o
:= [ [ ?condition => [?o = while _(?condition,?loopProcess,(the Situation output of: ?loopProcess))] ]
[!?condition => [?o = ?i] ] ].
0.3.1. Logic Functions (Logic Operators)
//the '-%' syntax used below come from the ':->" syntax of the
KIF standard of 1998
//to do (redo): G dpANS "NCITS.T2/98-004"
logic_operator = truth_function //declared in the previous subsection
.(Distr{1..* Statement_or_logical-value ?i}
-> Statement_or_logical-value ?o) //defined in
Section 3.2.4
/^ Statement-or-logical-value_generating_function, //redundant <- signature; introduced in Section 0.2.1
\. p{ (truth-status-restricting_logic_operator
\. e{
disjunction negation truth-preserving_conclusion })
(not-truth-status-restricting_logic_operator \. c{
conjunction })
}
e{ (unary_logic_operator \. negation/*below*/)
(binary-based_logic_operator
|^ Type_of_more-than-unary-relation_repeating_the_same_binary_relation_to_each_destination)
}
p{ logic_operator_that_has_only_2_possible_values_for_its_output
(logic_operator_that_does_not_necessarily_have_only_2_possible_values_for_its_output
:=> "using 'unknown' as the third possible value besides True and False is
using a logic that is not
bivalent (alias two-valued) and yet, semantically,
this does not seem to be rejecting the
principle of bivalence"
"the (
three-valued)
Logic of Paradox (LP) validates the law of excluded middle
but not the
law of non-contradiction (¬(P ∧ ¬P)) and (
hence?) its
intended semantics is not bivalent" )
\. (logic_operator_that_can_have_3_possible_values_for_its_output
\. (logic-operator_of_Kleene-or-Lukasiewicz
\. c{ (logic-operator_of_Kleene \. logic-operator_of_Kleene-and-Lukasiewicz)
(logic-operator_of_Lukasiewicz
\. (logic-operator_of_Kleene_and_Lukasiewicz
\. e{ and_of_Kleene-and-Lukasiewicz or_of_Kleene-and-Lukasiewicz
(not_of_Kleene-and-Lukasiewicz
\. (open-world_not = ow_not, /^ open-world_operator) )
}
(operator_of_Kleene-Lukasiewicz_returning_FALSE_TRUE_or_ERROR
\. SQL_logical_operator Javascript_operator )
(operator_of_Kleene-Lukasiewicz_returning_FALSE_TRUE_or_UNKNOWN
/^ open-world_operator )
) )
}
open-world_operator ) ) )
}.
conjunction .(Distr{2..* Statement_or_logical-value ?i} -% Statement_or_logical-value ?o)
:= "supertype of 'and' in any logic (multi-valued or not) except may be of quantum logic",
:=> [ [some ?i |^ False] => [?o |^ False] ],
:=> [ [every ?i |^ True ] => [?o |^ True ] ], //redundant only in binary_logic
\. (and = classic_and, //the one in this document
\. (and_of_Kleene-and-Lukasiewicz
:=> [ AND_{ [some ?i |^ Neither_true_nor_false], [no ?i |^ False] }
=> [?o |^ Neither_true_nor_false]
] ) )
multiplicative_conjunction_of_
linear-logic
additive_conjunction_of_
linear-logic.
disjunction .(Distr{2..* Statement_or_logical-value ?i} -% Statement_or_logical-value ?o)
:=> [ [some ?i |^ True ] => [?o |^ True ] ],
:=> [ [every ?i |^ False] => [?o |^ False] ], //redundant only in binary_logic
\. (or = classic_or, //the one in this document
\. (or_of_Kleene-and-Lukasiewicz
:=> [ AND_{ [some ?i |^ Neither_true_nor_false], [no ?i |^ True] }
=> [?o |^ Neither_true_nor_false]
] ) )
multiplicative_disjunction_of_
linear-logic
additive_disjunction_of_
linear-logic.
/* in FL: [pm#English#not] <=> [user: pm; English#not] <=> [ [__ notation: FL] &.&(pm#English#not) ]
<=> [ &.&[__ notation: FL Notation_in_which_a_colon_plays_the_role_of_diese_in_FL
] pm:English:not ] //in FL, the role of '#" is only by default
Notation_in_which_a_colon_can_play_the_role_of_diese_in_FL
\. (Notation_in_which_a_semicolon_plays_the_role_of_diese_in_FL
\. FL_where_the_roles_of_colon_and_diese_are_inversed XML Turtle ).
Notion of KRL_limited_to_data_representation //RDF-based as opposed to OWL-DL based
*/
Negated_statement .[-% ?s] ?s = owl#NegativePropertyAssertion,
derived_relation-type: r_negation .(Statement_or_logical-value ?i) -% Statement_or_logical-value ?o,
derived_function-type: f_negation .
negation .(Statement_or_logical-value ?i, Statement_or_logical-value ?o)
=
r_negation negated_statement-or-logical-value,
\. f_negation .(Statement_or_logical-value ?i) -% Statement_or_logical-value ?o
:=> [ [?i |^ False] => [?o |^ True] ],
:=> [ [?i |^ True] => [?o |^ False] ], //redundant only in binary_logic
\. e{ (
bivalent_not = ^'¬',
/^ logic_operator_that_can_have_2_possible_values_for_its_output,
\. (
closed-world_not = ^'¬°') ) //redundant: closed-world_bivalent-not
(three-valued_not
\. (
not_of_Kleene-and-Lukasiewicz = ^'!' open-world_not, /^ open-world_operator,
:=> [ [?i |^ Neither_true_nor_false] => [?o |^ Neither_true_nor_false] ] ) )
}.
truth-preserving_conclusion//also in Section 0.3.6
.(Distr{2..* Statement_or_logical-value ?premise} -% Statement_or_logical-value ?concl)
\. (logic_implication
:=> [ [some ?premise |^ False] => [?o |^ True] ],
:=> [ AND_{[no ?premise |^ False], [every ?concl |^ True]} => [?o |^ True] ],
:=> [ AND_{ [every ?premise |^ True], [every ?concl |^ False] } => [?o |^ False] ],
//every ?concl False since if 1..* is unknown then their AND is unknown and ?o is unknown
\. (ternary-logic_implication
\. (implication_of_Kleene-or-Lukasiewicz
:=> "see http://en.wikipedia.org/wiki/Kleene_logic#Kleene_logic",
:=> [ AND_{ [some ?premise |^ Neither_true_nor_false],
[no ?premise |^ False], //to be safe even (this case is covered above)
[some ?concl |^ !True] //OR_{False, Neither_true_nor_false}
//if all True, already handled above
} => [?o |^ Neither_true_nor_false] ], //avoid OR_{...} after =>
:=> [ AND_{ [every ?premise |^ True],
[some ?concl |^ Neither_true_nor_false]
} => [?o |^ Neither_true_nor_false] ],
\. (implication_of_Kleene-only
:=> [ AND_{ [some ?premise |^ Neither_true_nor_false],
[no ?concl |^ False],
[some ?concl |^ Neither_true_nor_false] }
=> [?o |^ Neither_true_nor_false]
] )
(implication_of_Lukasiewicz-only
:=> [ AND_{ [some ?premise |^ Neither_true_nor_false],
[no ?concl |^ False],
[some ?concl |^ Neither_true_nor_false] }
=> [?o |^ True]
] )
) )
(
equivalent_statement = statement_necessary-and-sufficient_condition,
/^ statement_sufficient_condition )
(linear_implication = implication_of_
linear-logic ^'
⊸') ).
0.3.2. Comparable Or Uncomparable, Esp. Via
Entailment, Generalisation, PartOf, MemberOf
As made explicit va the partion "{ sub#object_not_known_to_be_related-to_via
sub#object_known_to_be_related-to_via }" in Section 0.2.2,
"uncomparable" means "explicitly (i.e. known to be) not comparable",
i.e. the KB includes relations stating that the related objects cannot be compared.
When not prefixed by "explicitly" or "known to be"; the expression "not comparable" means
that the KB does not include relations stating that the related objects can be compared or not.
sub#comparable-or-uncomparable_via .(.{1 Thing, 0..* Thing ?otherParameters} -: ?x)
= object_known_to_be_comparable-or-uncomparable_via,
\. p{ uncomparable_via
(comparable_via //generic; ingerited signature
\. (comparable_via_semantic-or-lexical_generalization-or-equivalence
= comparable_via_semantic-or-lexical_specialization-or-equivalence,
\. p{ (semantic-or-lexical_equivalent
\. p{ semantic_equivalent lexical_equivalent })
(semantic-or-lexical_strict_specialization
\. p{ semantic_strict_specialization //below
(lexical_strict_specialization converse: semantic_strict_generalization)
})
(semantic-or-lexical_strict_generalization
\. p{ semantic_strict_generalization //below
(lexical_strict_generalization .(String .?, Regular_expression)
= matching_regular_expression,
:= ^"generalization where the destination is a
regular expression matching the source" )
})
}
c{ (semantic-or-lexical_specialization_or_equivalent //specialization
\. p{ semantic-or-lexical_equivalent
semantic-or-lexical_strict_specialization }
p{ semantic_specialization_or_equivalent //Section 0.3.4.1
lexical_specialization-or-equivalent })
(semantic-or-lexical_generalization_or_equivalent //generalization
\. p{ semantic-or-lexical_equivalent
(semantic-or-lexical_strict_generalization
\. (semantic-or-lexical_core_generalization
:= ^"type of relation for which the destination contains
less information than the source",
converse: semantic-or-lexical_core-specialization ) )
}
p{ semantic_generalization_or_equivalent //Section 0.3.4.2
lexical_generalization_or_equivalent })
}
(comparable_via_semantic_generalization-or-equivalence
= comparable_via_semantic_specialization-or-equivalence,
\. c{ semantic_specialization_or_equivalent //Section 0.3.4.1
semantic_generalization_or_equivalent //Section 0.3.4.2
}) ) )
}
(comparable-or-uncomparable_via_semantic-generalization-or-equivalence-or-part-or-member
\. (comparable-or-uncomparable_via_semantic-generalization-or-equivalence
\. comparable-or-uncomparable_via_semantic-equivalence //below
(comparable-or-uncomparable_via_extended-entailment
= sub#object_known_to_be_comparable_or_uncomparable_via_extended-entailment
\. sub#object_known_to_be_SUP-comparable-or-uncomparable_via_extended-entailment
) )
(sub#object_known_to_be_comparable-or-uncomparable_via_part
= sub#object_known_to_be_part-comparable-or-uncomparable,
\. p{ (sub#comparable_via_part \. p{ owl#sameAs sub#part sub#part_of } )
(sub#uncomparable_via_part
\. p{ sub#part_exclusion
sub#part-uncomparable_but_not_part-exclusive
})
}
(sub#object_known_to_be_c_comparable-or-uncomparable_via_part
= sub#object_known_to_be_c_part-comparable-or-uncomparable,
\. p{ (sub#comparable_via_c_part \. p{ sub#eqC sub#c_part sub#c_part_of } )
(sub#uncomparable_via_c_part
\. p{ sub#c_part_exclusion
sub#c_part-uncomparable_but_not_c_part-exclusive
})
}) )
(extended-part-or-gSpecialization-or-equivalent-or-exclusion_comparable .(?o1,?o2)
= extendedPartOrGspecEqOrExcl_comparable,
:= ^"relation excluding the case where, for any two objects in the KB, it is not known
whether or not there exists an asserted/inferrable
part/gSpecialization/equivalence/exclusion relation between the two objects
(without using closed world inferences)",
:= [OR_{[?o1 partOrGspecEqOrExcl: ?o2], [?o1 partOrGspecEqOrExcl of: ?o2]}],
\. c{ comparable_via_semantic_generalization-or-equivalence //above
comparable_via_extended_part_or_equivalence //0.3.2.4
}
ne{ (part_or_gSpecialization_or_equivalent_or_exclusion = partOrGspecEqOrExcl,
\. p{ part
(gSpecialization_or_equivalent_or_exclusion = gSpecEqOrExcl,
\. p{ gSpecialization_or_equivalent //Section 0.3.4.1
core-specialization_exclusion //Section 0.2.2.2
} )
}
p{ part_or_equivalent
(gSpecialization_or_exclusion \. p{ gSpec exclusion } )
} )
(gSpecialization-or-equivalent-or-exclusion_comparable .(?o1,?o2)
= gSpecEqOrExcl_comparable,
:= [OR_{[?o1 gSpecEqOrExcl: ?o2], [?o1 gSpecEqOrExcl of: ?o2]}],
\. p{ (exclusion_comparable := [OR_{[?o1 exclusion: ?o2],
[?o1 exclusion of: ?o2]}])
(gSpecialization-or-equivalent_comparable
\. p{ (gSpecEq converse: gSpecEq_of) gSpecEq_of }
(gSpecialization_comparable = gSpec_comparable,
\. p{ (gSpec converse: gSpec_of) gSpec } ) )
}
p{ (type_comparable := [OR_{[?o1 type: ?o2], [?o1 type of: ?o2]}])
(core-specialization-or-equivalent-or-exclusion_comparable
= cSpecEqOrExcl_comparable,
\. p{ (cSpecEqOrExcl converse: cSpecEqOrExcl_of) cSpecEqOrExcl_of }
(core-specialization-or-equivalent_comparable
= cSpecEq_comparable,
\. p{ (cSpecEq converse: cSpecEq_of) cSpecEq_of }
(core-specialization_comparable = cSpec_comparable,
\. p{ (cSpec converse: cSpec_of) cSpec_of } ) ) )
} )
}) ).
0.3.2.1. Comparable Or Uncomparable Via Semantic Equivalence (Or Identity)
comparable-or-uncomparable_via_semantic-equivalence
\. (comparable-or-uncomparable_via_identity = identical_or_not,
\. p{ (equal .(Thing .?t1, Thing+) = ^'==',
//".?" means that the source does not have the
// default quantifier 'any' if it has no explicit quantifier
converse: equal, //symmetric relation
\. (identical_to = ^'===' owl#sameAs,
:=> "same abbreviation as in Javascript" )
(equal_to_a_type_representing_a_distributive_set_of_types
= ^'====' ) )
(not_equal = ^'!==',
\. (not_identical_to = ^'!===' owl#differentFrom,
\. p{ sub#different_but_equivalent sub#different_and_non-equivalent })
(not_equal_to_a_type_representing_a_distrib_set_of_types = ^'!====' ) )
})
p{ (semantic_equivalent .(Thing .?t1, Thing+)
= equal_or_equivalent ^'=' sub#eq sub#equivalent sub#"<=>",
\. p{ equal sub#different_but_equivalent }
p{ (sub#equivalent_type = sub#equivalentType,
\. p{ (owl#equivalentProperty = sub#eqP)
(owl#equivalentClass = sub#eqC)
})
(sub#equivalent_non-type_thing = sub#eqT,
\. p{ (sub#equivalent_statement .(sub#Statement, sub#Statement)
= sub#eqS sub#"<==>" ^'<=>' ^'*=*' ^'≡' )
(sub#equivalent_individual = sub#eqI)
})
}
p{ sub#equivalent_statement (sub#equivalent_non-statement = sub#eqNS) }
)
(non_semantically_equivalent = different_from sub#non-equivalent ^'!=' sub#"!<=>",
converse: not_equal-or-equivalent, //symmetric relation
\. not_equal core-specialization_exclusion //Section 2.1
(sub#non-equivalent_nor_entailing
! sub#extended-entailed_thing_or_equivalent,
\. p{ (sub#non-equivalent_type .(sub#Type, sub#Type)
\. p{ (sub#non-equivalent_property
\. p{ owl#propertyDisjointWith
(sub#non-equivalent_nor_exclusive_property = sub#neP)
})
(sub#non-equivalent_class .(rdfs#Class, rdfs#Class)
\. p{ owl#disjointWith
(sub#non-equivalent_nor_exclusive_class = sub#neC)
}
(sub#non-equivalent_nor_subClassOf ! rdfs#subClassOf ) )
})
sub#non-equivalent_non-type_thing
}
(sub#non-equivalent_nor_exclusive_things
.(owl#Thing ?t, .{2..* owl#Thing} ?ts) = sub#neTs,
:= [ [?ts sub#member: ^t1 (^t2 != ^t1)]
==> [^t1 sub#non-equivalent_nor_exclusive_thing: ^t2, ?t] ],
\. p{ (sub#non-equivalent_nor_exclusive_types .(sub#Type, sub#Type)
\. p{ (sub#non-equivalent_nor_exclusive_classes
.(rdfs#Class, .{2..* rdfs#Class}) = sub#neCs)
(sub#non-equivalent_nor_exclusive_properties
.(rdf#Property, .{2..* rdf#Property}) = sub#nePs)
})
sub#non-equivalent_nor_exclusive_non-types
})
//each of the next subtypes is specialized in a next (sub-)section
sub#strict_semantic_generalization_or_specialization
sub#strict_extended_part_or_part-of
sub#contextualizing-or-negating_relation ))
}.
0.3.2.2. Comparable Or Uncomparable Via Extended Entailment
sub#object_known_to_be_comparable_or_uncomparable_via_extended-entailment
= sub#object_known_to_be_comparable_or_uncomparable,
\. p{ (sub#comparable_via_extended-entailment
\. p{ extended_entailed-by_or_equivalent //below (Section 0.3.3.2)
extended_entailment_or_equivalent //= SUP-comparable_via_extended-entailment
},
(sub#comparable_class .(rdfs#Class, rdfs#Class)
//hence: \. p{ sub#equivalentClass sub#strict_superClass sub#strict_subClass }
//or: \. p{ rdfs:subClassOf sub#strict_subClass)
))
(sub#uncomparable_via_extended-entailment
\. p{ sub#extended-entailment_exclusion
(sub#known_to_be_uncomparable_but_not_exclusive_via_extended-entailment
\. (sub#uncomparable-but-not-disjoint_type .(sub#Type, sub#Type)
\. (sub#uncomparable-but-not-disjoint_class .(rdfs#Class, rdfs#Class)
! owl#disjointWith ) ) )
}
p{ (sub#uncomparable_type .(sub#Type, sub#Type)
\. (sub#uncomparable_class .(rdfs#Class, rdfs#Class)
\. sub#uncomparable-but-not-disjoint_class ) )
sub#uncomparable_non-type
})
}
p{ (sub#type_known_to_be_comparable_or_uncomparable .(sub#Type, sub#Type)
\. p{ (sub#class_known_to_be_comparable_or_uncomparable .(rdfs#Class, rdfs#Class)
//hence: \. p{ sub#comparable_class sub#uncomparable_class }
// or: \. p{ sub#comparable_class owl#disjointWith
// sub#non-equivalent_class_nor_subClassOf }
)
sub#property_known_to_be_comparable_or_uncomparable
})
sub#non-type_known_to_be_comparable_or_uncomparable
}.
0.3.2.3. SUP-comparable Or SUP-uncomparable Via Extended Entailment
sub#object_known_to_be_SUP-comparable-or-uncomparable_via_extended-entailment
= sub#object_known_to_be_SUP-comparable_or_SUP-uncomparable,
\. sub#object_known_to_be_comparable_or_uncomparable_via_extended-entailment
p{ (sub#extended_entailment_or_equivalent //= sub#SUP-comparable_via_extended-entailment
\. sub#superClass_or_equivalent )
sub#not_known_to_be_SUP-comparable-or-uncomparable_via_extended-entailment
(sub#SUP-uncomparable_via_extended-entailment
\. p{ (sub#SUP-uncomparable_type .(sub#Type, sub#Type)
\. (sub#SUP-uncomparable_class .(rdfs#Class, rdfs#Class)
= sub#non-equivalent_class_nor_subClassOf
\. sub#SUP-uncomparable-but-not-disjoint_class ) )
sub#SUP-uncomparable_non-type
}
sub#uncomparable_via_extended-entailment )
}
p{ (sub#type_known_to_be_SUP-comparable-or-uncomparable .(sub#Type, sub#Type)
\. p{ (sub#class_known_to_be_SUP-comparable-or-uncomparable .(rdfs#Class, rdfs#Class)
= sub#class_known_to_be_SUP-comparable_or_exclusive_or_SUP-uncomparable
//hence: \. p{ sub#comparable_class sub#uncomparable_class }
// or: \. p{ sub#comparable_class owl#disjointWith
// sub#non-equivalent_class_nor_subClassOf }
)
sub#property_known_to_be_SUP-comparable-or-SUP-uncomparable
})
sub#non-type_known_to_be_comparable_or_uncomparable
}.
0.3.2.2. Comparable Via Extended PartOf
comparable_via_extended_part_or_equivalence = sub#extended_part_or_part-of,
sub#type: owl#TransitiveProperty,
\. p{ sub#eq
(sub#strict_extended_part_or_part-of
\. p{ sub#strict_extended_part sub#strict_extended_part-of } )
}
p{ sub#extended_part_or_part-of_directly_between_individuals .(sub#Individual, sub#Individual)
(sub#extended_part_or_part-of_between_types_but_for_their_instances .(sub#Type, sub#Type)
\. (sub#part_or_part-of_between_types_but_for_their_instances
\. c{ sub#part_between_types_but_for_their_instances
sub#part-of_between_types_but_for_their_instances
}) )
}.
0.3.3. Extended Entailments, Their Inverses and Exclusions
Box ??. Example <=/=> relations that are spec/gen (correction or not) relations
∀x P5(x) ∃y P5(y)
↑g ⇓cS(restr) ⇑cG ↓s ⇑cG ↓s
∀x P1(x) => P5(x) ∀x P5(x) ^ ∃y P5(y) ^ P6(y)
⇑cG ↓s(prec) ↑g ⇓cS(restr)
∀x P1(x) => P5(x) ^ P6(x) ∀x P1(x) ^ P2(x) => P5(x)
↑g ⇓cS(restr) ⇑cG ↓s(prec)
∀x P1(x) ^ P2(x) => P5(x) ^ P6(x)
[98%-100%]x P5(x) [98-100]y P5(y)
⇑cG ↓s ⇑cG ↓s
[98%-100[x P5(x) 98y P5(y)
↑(c)g ↓(c)s ↑g ⇓cS(restr) ⇑cG ↓s ⇑cG ↓s
98-99%xP1(x)=>P5(x) 98%x P1(x) => P5(x) 98%x P5(x) ^ 98y P5(y) ^ P6(y)
⇑cG ↓s(prec) ↑g ⇓cS(restr)
98%x P1(x) => P5(x) ^ P6(x) 98%x P1(x) ^ P2(x) => P5(x)
↑g ⇓cS(restr) ⇑cG ↓s(prec)
98%x P1(x) ^ P2(x) => P5(x) ^ P6(x)
Legend: ↑g : generalization without implication
⇑cG: corrective generalization and implication
↓s : specialization without implication
⇓cS: corrective specialization and implication
[98%-100%]x P(x): [98%-100%]x Thing(x) => P(x)
[98%-100%]x P1(x) => P2(x): 98-100%x P1(x) => P2(x)
for each x member of 98% to 100% of instances of P1, P2(x) is true
[98-100]x P1(x) => P2(x): for each of 98 to 100 instances of P1, P2(x) is true
|
|
0.3.3.1. (Extended) Entailment (Spec/Gen)
extended_entailment_or_equivalent .(.?o1, ?o2)
= sub#SUP-comparable_via_extended-entailment sub#"=>"
\. p{ semantic_core-generalization_or_equivalent
(sub#entailed_specialing_statement_or_equivalent
\. p{ sub#eqS sub#strict_entailed_specialing_statement })
}
p{ sub#eq
(strict_extended_entailment
\. p{ strict_semantic_core-generalization sub#strict_entailed_specialing_statement }
p{ (strict_statement_entailment .(sub#Statement, sub#Statement)
= strict_classic_entailment)
strict_semantic_non-statement_generalization
})
}
p{ (statement_entailment_or_equivalent = classic_entailment_or_equivalent sub#"==>",
\. c{ sub#entailed_generalizing_statement_or_equivalent
sub#entailed_specialing_statement_or_equivalent })
(semantic_non-statement_generalization_or_equivalent
\ c{ sub#entailed_generalizing_statement_or_equivalent
sub#entailed_specialing_statement_or_equivalent })
}.
0.3.3.2. (Extended) Entailed-By (Spec/Gen)
extended_entailed-by_or_equivalent .(.?o1, ?o2) = sub#"<=",
converse: extended_entailment_or_equivalent,
\. p{ (semantic_core-specialization_or_equivalent //below (statement ot not)
converse: semantic_core-generalization_or_equivalent )
(sub#extended_entailed-by_generalisation_or_equivalent //statement ot not
converse: sub#entailed_specialing_statement_or_equivalent,
\. p{ sub#eqS
(sub#strict_entailed-by_generalizing_statement
converse: sub#strict_entailed_specialing_statement)
})
}
p{ sub#eq
(strict_extended_entailed-by converse: strict_extended_entailment,
\. p{ sub#strict_semantic_core-specialization //=strict_extended-entailed-by_specialization
sub#strict_entailed-by_generalizing_statement }
p{ (sub#strict_entailed-by_statement .(sub#Statement, sub#Statement)
= strict_classic_entailed-by,
converse: strict_statement_entailment )
(strict_semantic_non-statement_specialization
converse: strict_semantic_non-statement_generalization )
})
}
p{ (statement_entailed-by_or_equivalent = classic_entailed-by_or_equivalent,
converse: statement_entailment_or_equivalent,
\. c{ (sub#entailed-by_generalizing_statement_or_equivalent
converse: sub#entailed_generalizing_statement_or_equivalent )
(sub#entailed-by_specialing_statement_or_equivalent
converse: sub#entailed_specialing_statement_or_equivalent )
})
(semantic_non-statement_entailed-by_or_equivalent
\ c{ (sub#entailed-by_generalizing_statement_or_equivalent
converse: sub#entailed_generalizing_statement_or_equivalent )
(sub#entailed-by_specialing_statement_or_equivalent
converse: sub#entailed_specialing_statement_or_equivalent )
})
}.
0.3.4. Semantic Generalizations/Specializations and Their Exclusions
0.3.4.0. Set_of_things_that_may_be_specialized and Spec-exclusive_things
Set_of_things_that_may_be_specialized ?s
:= [ [^m member of: ?s] => [^m gSpec: 0..* Thing] ],
\. (
Set_of_specializations_for_a_same_thing ?s
:=> [a Thing ?x0 cSpec: every ^(Thing member of ?s)],
\. p{ (Open_set_of_specializations_for_a_same_thing =
d)
(
Closed_set_of_specializations_for_a_same_thing ?s =
cd, // /^ Closed_set,
:= "if ^x is that thing, any spec of ^x is a specEq of a member of ?s",
:= [ [any ^(Thing member of ?s) cSpec of: (?x cSpec: only a ^(Thing member of: ?s))]
] => [any ^(Thing gGen: ^x) gGenEq: (a Thing member of: ?s)] ] )
}
e{ (Set_of_spec-comparable_specializations_for_a_same_thing ?s
:= [ [?s member: ?m1 (?m2 != ?m1)] => [?m1 cSpec_comparable: ?m2] ] )
(Set_of_non-spec-comparable_specializations_for_a_same_thing
\. p{ (Set_of_different_but_not-spec-uncomparable_specializations_for_a_same_thing
\. p{ (Open_set_of_different_but_not-spec-uncomparable_specializations
=
cd )
(Closed_set_of_different_but_not-spec-uncomparable_specializations
=
d, /^ Closed_set_of_specializations_for_a_same_thing )
} )
(Set_of_spec-uncomparable_specializations_for_a_same_thing ?s
:= [ [?s member: ?m1 (?m2 != ?m1)] => [?m1 !cSpec_comparable: ?m2] ],
\. p{ (Open_set_of_at-least-weakly_spec-uncomparable_specializations
=
ne )
(Closed_set_of_at-least-weakly_spec-uncomparable_specializations
=
ce, /^ Closed_set_of_specializations_for_a_same_thing )
}
p{ (Set_of_weakly_spec-uncomparable_specializations_for_a_same_thing
\. p{ (Open_set_of_weakly_spec-uncomparable_specializations
=
we wu )
(Closed_set_of_weakly_spec-uncomparable_specializations
=
wp, /^ Closed_set_of_specializations_for_a_same_thing)
} )
(Set_of_strongly_spec-uncomparable_specializations_for_a_same_thing
/^
Spec-exclusive_things ) //below
} )
} )
} ).
Spec-exclusive_things
\. p{ (Things_that_are_
spec-exclusive-always //the next 2 defs are equivalent
:= [ [^m1 member of: ?s, != (^m2 member of: ?s)]
=> [no ^(Thing cGen: ^m1, cGen: ^m2)] ],
:= [ [^i1 gGen: (^m1 member of: ?s, != (^m2 member of: ?s, gGen of: ^i2))]
=> [^i1 != ^i2] ], //generalization of the next def for types only
\. (Types_that_are_spec-exclusive-always ?s /^ Set_of_types,
:=> [ [^i1 type: (^m1 member of: ?s, != (^m2 member of: ?s, type of: ?i2))]
=> [^i1 != ^i2] ] ),
e{ (Spec-open-exclusion_always =
e Excl)
(Spec-
partition_always ?s =
p,
/^ Closed_set_of_specializations_for_a_same_thing )
} )
(Things_that_are_
spec-exclusive_for-a-time ?s
:= [ [?s type: Things_that_are_spec-exclusive-always] time: a time ?t],
\. (Types_that_are_spec-exclusive-for-a-time ?s /^ Set_of_types,
:=> [ [?s type: Types_that_are_spec-exclusive-always] time: a time ?t] )
e{ (Spec-open_exclusion_for_a_time =
t_e Excl)
(Spec-partition_for_a_time =
t_p,
/^ Closed_set_of_specializations_for_a_same_thing,
:=> "in 't_p', the 't' is for 'time-dependent' ",
:= [ [?s type: Spec-partition_always] time: ?t] )
} )
(Things_that_are_
spec-exclusive_for-an-agent ?s
:= [ [?s type: Things_that_are_spec-exclusive-for-an-agent]
believer: an agent ?a],
\. (Types_that_are_spec-exclusive-for-an-agent ?s /^ Set_of_types,
:=> [ [?s type: Types_that_are_spec-exclusive-for-an-agent]
author: an agent ?a] )
e{ (Spec-open_exclusion_for_an-agent =
v_e Excl)
(Spec-partition_for_an-agent =
v_p,
/^ Closed_set_of_specializations_for_a_same_thing,
:=> "in 'v_p', the 'v' is for 'viewpoint/agent-dependent' ",
:= [ [?s type: Spec-partition_for-an-agent] believer: an agent ?a] )
} )
}.
0.3.4.1. Semantic Specializations (Instance/...)
semantic_specialization_or_equivalent .(.?superObject, ?subObject)
//reminder: the above ".?" means that the source does not have the
// default quantifier 'any' if it has no explicit quantifier
= sSpecEq gSpecEq gSpecialization_or_equivalent,
converse: sub#semantic_generalization_or_equivalent,
\. p{ sub#eq
(strict_semantic_specialization
= sSpec sub#strict_semantic_specialization ^'\~.' ,
\. p{ instance scSpec }) //both types are defined in the next two subsections
}
p{ (instance_or_equivalent
\. p{ sub#eq
(instance .(Information_object, Type) = ^'|.' sub#instance,
:= ^"specialization from a type to an individual, e.g. [Cat |. Tom]",
\. example )
})
semantic_core-specialization_or_equivalent //next subsection
}.
0.3.4.2. Semantic Core Specializations (Natural/Non-natural)
sub#semantic_core-specialization_or_equivalent .(?t1 ?o1, ?t2 ?o2)
= cSpecEq,
\. p{ sub#eq
(sub#strict_semantic_core-specialization
= scSpec subterm subtype_or_subindividual_or_substatement
0.3.4.3. Semantic Generalizations (Type/...)
semantic_generalization_or_equivalent .(.?subObject, ?superObject)
//reminder: the above ".?" means that the source does not have the
// default quantifier 'any' if it has no explicit quantifier
= type_or_core-generalization-or-equivalent sGenEq gGenEq,
,
converse: semantic_specialization_or_equivalent,
\. p{ sub#eq
(strict_semantic_generalization = sGen,
\. p{ type scGen }) //both types are defined in the next two subsections
}
p{ (type_or_equivalent = rdf#type, //e.g. in Turtle: "owl:Class rdf:type owl:Class"
\. p{ sub#equivalent_type
(type .(Information_object, Type) = ^'|^' sub#type,
converse: instance )
})
semantic_core-generalization_or_equivalent //see below
}
p{ (semantic_gGeneralization_inferred_using_at_least_this_source
\. semantic_generalizing-statement_inferred_using_at_least_this_source //Section 0.3.6
^"generalization in Formal Concept Analysis or all those for indexing KB objects" )
(semantic_gGeneralization_not_inferred_using_this_source
\. (semantic_generalizing-statement_not_inferred_using_this_source /*def.: Section 1.3.8.2
\. ^"given rule or a definition (e.g. a supertype relation) enabling generalizations"
non-generated_semantic-generalizing-statement
p{ corrective_generalization non-corrective_generalizing-statement } */ ) )
}
p{ statement_generalization //see below
(semantic_gGeneralization_of_a_term_that_is_not_a_reference_to_a_statement
converse: semantic_gSpecialization_of_a_term_that_is_not_a_reference_to_a_statement,
\. p{ (semantic_gGeneralization_of_a_formal_term_that_is_not_a_reference_to_a_statement
\. ne{ type strict_semantic_core-generalization } ) //see below
(semantic_gGeneralization_of_an_informal_term_that_is_not_a_reference_to_a_statement
:=> "each meaning of the source term must be generalized by at least one
meaning of the destination term" )
})
}.
0.3.4.4. Semantic Core Generalizations
sub#semantic_core-generalization_or_equivalent .(?t1 ?o1, ?t2 ?o2)
= cGenEq sub#extended-entailed_generalization,
:=> [?t1 cSpecEq_comparable: ?t2],
converse: (cSpecialization_or_equivalent = ^'\='),
\. p{ sub#eq
(strict_semantic_core-generalization
= scGen super_term supertype_or_super-individual ^'/°'
sub#strict_extended-entailed_generalization,
converse: (subterm = ^'°\'),
\. e{ (sub#strict_supertype .(sub#Type, sub#Type) = '/^' ^'<',
:= ^"generalization between types, e.g. [Cat /^ Feline]",
converse: (strict_subtype = ^'>',
\. (ne_subtype .(Type ?t1, ne{Type} ?t2s) = ^'\.',
:= [?t1 > ne ?t2s] ) ),
:= [ [^subObject type: ^superObject] => [^subObject type: ^superObject] ],
\. p{ (sub#strict_superProperty .(rdf#Property, rdf#Property)
= sub#proper-subPropertyOf )
(sub#strict_superClass = sub#proper-subClassOf,
\. p{ (strict_natural-type_supertype .(Type, Type) = ^':/',
converse: (natural_subtype = ^'\_') )
(strict_non-natural-type_supertype .(Type, Type) = ^'_/',
converse: (non-natural_subtype = '\~') )
})
})
(sub#strict_superIndividual .(sub#Individual, sub#Individual)
:= ^"generalization from an Individual to another,
e.g. [Tom_in_2018 ../ Tom]",
converse: (sub-individual = ^'\..') )
sub#strict_entailed_statement .(sub#Statement, sub#Statement)
}) )
}
e{ (sub#supertype_or_equivalent .(sub#Type, sub#Type)
\. p{ sub#equivalent_type sub#strict_supertype }
p{ (sub#superProperty_or_equivalent = owl#subPropertyOf,
\. p{ owl#equivalentProperty sub#strict_superProperty } )
(sub#superClass_or_equivalent .(rdfs#Class, rdfs#Class)
= rdfs#subClassOf sub#SUP-comparable_class,
//e.g. in Turtle: owl:Class rdfs#subClassOf owl:Class
\. p{ owl#equivalentClass sub#strict_superClass } )
})
(sub#superIndividual_or_equivalent .(sub#Individual, sub#Individual)
converse: sub#subIndividual_or_equivalent )
(sub#semantic_statement_generalization_or_equivalent .(sub#Statement, sub#Statement)
converse: sub#semantic_statement_specialization_or_equivalent,
\. p{ sub#eqS
(sub#strict_semantic_statement_generalization
converse: sub#strict_semantic_statement_specialization )
}
p{ (sub#entailed_generalizing_statement_or_equivalent
\. p{ sub#eqS
(sub#strict_entailed_generalizing_statement
converse: sub#strict_entailed_specializing_statement )
})
(sub#non-entailed_generalizing_statement_or_equivalent
\. p{ sub#eqS
(sub#strict_non-entailed_generalizing_statement
converse: sub#strict_non-entailed_specializing_statement )
})
}
p{ (sub#entailed-by_generalizing_statement_or_equivalent
\. p{ sub#eqS
(sub#strict_entailed-by_generalizing_statement
converse: sub#strict_entailed-by_specializing_statement )
})
(sub#non-entailed_by_generalizing_statement_or_equivalent
\. p{ sub#eqS
(sub#strict_non-entailed_by_generalizing_statement
converse: sub#strict_non-entailed_by_specializing_statement )
})
})
)
}.
0.3.4.5. Statement Generalizations (Truth_preserving/..., Adding_information/...)
statement_generalization .(Statement .?p1, Statement ?p2) = ^'__/',
converse: (statement_specialization = ^'\~_',
\. e{ (truth_preserving_specialization)
(not-truth-preserving_generalization)
}
(statement_instantiation = instantiation) ),
\. p{ (statement_generalization_adding_information = generalization_adding_information)
(statement_generalization_loosing_information = generalization_loosing_information,
converse: (statement_specialization_adding_information
= specialization_adding_information ) )
}
p{ (truth_preserving_generalizing-statement
converse: truth_preserving_specializing-statement,
\. (generalization_of_conjunctive_existential_statement_with_no_context
:= ^"generalization of a statement whose quantifiers are only existential,
whose logical connector are only 'and' and whose meta-statement (if
any) are not context, i.e. are truth preserving",
:=> "the destination and the source
- only include individuals or existentially quantified terms;
- only include ^'and' as logical connector;
- may be meta-statements but not contexts",
example:
[ [ [Tom color: a Light_grey, part: a Leg] language: FL]
__/ [ [a Cat color: a Grey] //there exists a grey cat
language: a KRL ] ]
[ [57 Cat color: a Grey] __/ [at least 57 Cat color: a Grey] ]
) )
(not-truth-preserving_generalizing-statement
converse: not-truth-preserving_specializing-statement,
example: //here, the source statements have universal quantifiers and contexts
[ [ [every Legged_cat color: a Grey, part: a Leg] time: 23/12/2017 ]
__/ [ [every Cat color: a Grey] //every cat is grey
time: 2017 ] ] )
}.
0.3.5. Parts, Members, Their Inverses and Exclusions
0.3.5.1. Parts and Exclusions
extended_part_or_equivalent = extendedPartEq,
derived_relation-type of: (Extended_part_or_equivalent /^ Thing_wrt_role).
\. p{ sub#eq
(sub#strict_extended_part
\. (sub#strict_part .(?t1 ?o1, ?t2 ?o2) = sub#part,
\. sub#sPart,
:=> [?t1 cSpecEq_comparable: ?t2],
\. e{ subprocess .(Process, Process)
spatial-part .(Spatial_entity, Spatial_entity)
},
:=> "the partial definition requiring that the source and
destination are cSpecEq_comparable prevents the combination of
part relations such subprocess and spatial-part" )
(sub#part_between_types_but_for_their_instances .(sub#Type ?t1, sub#Type ?t2)
= c_part, := [ [^i sub#type: ?t1] ==> [^i sub#part: a ?t2] ],
\. c_sPart
)
(sub#strict_member .(owl#Thing, owl#Thing)
\. (sub#statement_member .(sub#Statement, owl#Thing)
\. (sub#definition_member
\. sub#definition_member_via_OWL ) //see Section 3
//just another example:
(sub#relation_member .(sub#Statement, owl#Thing)
\. (sub#relation_type .(sub#Statement, owl#Thing)
\. (sub#relation_type_of_an_RDF_reified_statement = rdf#predicate)))))
(sub#"=>-element" = sub#extended-entailment_element,
\. p{ (sub#"==>-element" .(sub#Statement ?X, sub#Statement ?y)
= sub#entailment_element,
:= "∀X,y ==>-element(X,y) <==>
(∃y2,Y (X==>Y) ∧ (Y <==> (y ∧ y2)))",
:= [?X ==> (a sub#Statement ?Y <==> [?y. (?y2 != ?y)])],
\. (sub#"<==>-element" .(sub#Statement ?X, sub#Statement ?y)
= sub#equivalent-statement_element,
:= [?X <==> [?y. (?y2 != ?y)] ] ) )
(sub#NC-definition_element .(owl#Thing ?t, owl#Thing ?e)
:= [?t sub#"=>": (a sub#Statement sub#statement_member: ?e)],
\. (sub#NSC-definition_element .(owl#Thing ?t, owl#Thing ?e)
:= [?t <==> (a sub#Statement sub#statement_member: ?e)] ) )
})
(sub#"<=-element" = sub#extended-reverse-entailment_element,
\. p{ (sub#"<==-element" .(sub#Statement ?X, sub#Statement ?y)
= sub#reverse-entailment_element,
:= [?X <== (a sub#Statement ?Y <==> [?y. (?y2 != ?y)])],
\. sub#"<==>-element" )
(sub#SC-definition_element .(owl#Thing ?t, owl#Thing ?e)
:= [?t sub#"<=": (a sub#Statement sub#statement_member: ?e)],
\. sub#NSC-definition_element )
})
(sub#definition-element .(owl#Thing ?t, owl#Thing ?e)
|^ owl#TransitiveProperty, >
\. c{ sub#NC-definition_element sub#SC-definition_element }
p{ sub#def_necessary-element sub#def_non-necessary_element },
sub#definition-element_via_OWL //defined in Section 2
)
sub#strict_extended_parts
)
}
e{ (sub#member_or_equivalent \. p{ sub#eq sub#strict_member })
(sub#part_or_equivalent = partEq, \. p{ sub#eq sub#strict_part })
(sub#c_part_or_equivalent \. p{ sub#eqC sub#strict_c_part })
}.
0.3.5.1.1. Relations to Extended Parts
sub#strict_extended_parts
\. (sub#part-exclusive_parts .( sub#Individual ?i, .{2..* sub#Individual} ?pIs )
= sub#non-overlapping_parts,
:= [[?pIs sub#member: ^pI1 (^pI2 != ^pI1)] ==> [^pI1 sub#part_exclusion ^pI2]],
\. p{ (sub#part_partition = sub#partPartition sub#pParts) //pParts
(sub#incomplete_set_of_part-exclusive_parts = sub#eParts) //eParts
})
(sub#c_part-exclusive_parts .( sub#Type ?t, .{2..* sub#Type} ?pTs )
:= [ [^i sub#type: ?t, sub#part-exclusive_parts: ?pIs]
[ [^pI sub#member of: ?pIs]
==> [^pI sub#type: (a sub#Type sub#member of: ?pTs)] ] ],
\. p{ (sub#c_part_partition = sub#c_pParts) //c_pParts
(sub#incomplete_set_of_part-exclusive_parts = sub#c_eParts) //c_eParts
})
(sub#complete_set_of_parts .( sub#Individual ?i, .{2..* sub#Individual} ?pIs )
:= [ [^e sub#part of: ?i] ==>
[^e sub#part of: (a owl#Thing sub#member of: ?pIs)] ],
\. p{ sub#part_partition
(sub#complete_set_of_non-part-exclusive_parts = sub#cParts) //cParts
})
(sub#c_complete_set_of_parts .( sub#Type ?t, .{2..* sub#Type} ?pTs )
:= [ [^i sub#type: ?t, sub#union_of_parts: ?pIs]
[ [^pI sub#member of: ?pIs]
==> [^pI sub#type: (a sub#Type sub#member of: ?pTs)] ] ],
\. p{ sub#c_part_partition
(sub#complete_set_of_c_non-part-exclusive_parts = sub#c_cParts) //c_cParts
}).
0.3.5.1.2. Set_of_things_that_may_have_a_part and Part-exclusive_things
Set_of_things_that_may_have_a_part ?s
:= [ [^m member of: ?s] => [^m part: 0..* Thing] ],
\. (Set_of_parts_for_a_same_thing ?s
:=> [a Thing ?x0 part: every ^(Thing member of ?s)],
:= [ [^x member of: ?s] => [a Thing ?x0 part: every ^(Thing ?xi member of ?s)] ],
\. p{ (Open_set_of_parts_for_a_same_thing = d)
(Closed_set_of_parts_of_a_same_thing ?s = cd, // /^ Closed_set,
:= "if ^x is that thing, any part of ^x is a partEq of a member of ?s",
:= [ [ [^x part: only a ^(Thing member of ?s) ]
[any ^(Thing member of ?s) part of ?x] //^x is that thing
] => [any ^(Thing part of: ^x) partEq of: (a Thing member of: ?s)] ] )
}
e{ (Set_of_part-comparable_parts_for_a_same_thing ?s
:= [ [?s member: ?m1 (?m2 != ?m1)] => [?m1 cPart_comparable: ?m2] ] )
(Set_of_non-part-comparable_parts_for_a_same_thing
\. p{ Set_of_different_but_not-part-uncomparable_parts_for_a_same_thing
(Set_of_part-uncomparable_partializations_for_a_same_thing ?s
:= [ [?s member: ?m1 (?m2 != ?m1)] => [?m1 !cPart_comparable: ?m2] ],
\. p{ (Open_set_of_at-least-weakly_part-uncomparable_parts = npe )
(Closed_set_of_at-least-weakly_part-uncomparable_parts
= cpe, /^ Closed_set_of_parts_for_a_same_thing )
}
p{ Set_of_weakly_part-uncomparable_parts_for_a_same_thing
(Set_of_strongly_part-uncomparable_parts_for_a_same_thing
/^ Part-exclusive_things ) //below
} )
} )
} ).
Part-exclusive_things
\. p{ (Things_that_are_part-exclusive-always ?s //the next 2 defs are equivalent
:= [ [^m1 member of: ?s, != (^m2 member of: ?s)]
=> [no ^(Thing part of: ^m1, part of: ^m2)] ],
:= [ [^i1 part of: (^m1 member of: ?s, != (^m2 member of: ?s, part: ^i2))]
=> [^i1 != ^i2] ],
\. e{ (Part-open-exclusion_always = part_e)
(Part-partition_always = part_p,
/^ Closed_set_of_parts_for_a_same_thing )
} )
(Things_that_are_part-exclusive_for-a-time ?s
:= [ [?s type: Things_that_are_part-exclusive-always] time: a time ?t],
\. e{ (Part-open-exclusion_for_a_time = t_part_e, )
(Part-partition_for_a_time = t_part_p,
/^ Closed_set_of_specializations_for_a_same_thing,
:= [ [?s type: Part-partition_always] time: ?t] )
} )
(Things_that_are_part-exclusive_for-an-agent ?s
:= [ [?s type: Things_that_are_part-exclusive-for-an-agent]
believer: an agent ?a],
\. e{ (Part-open_exclusion_for_an-agent = v_e Excl)
(Part-partition_for_an-agent = v_p,
/^ Closed_set_of_parts_for_a_same_thing,
:=> "in 'v_p', the 'v' is for 'viewpoint/agent-dependent' ",
:= [ [?s type: Part-partition_for-an-agent] believer: an agent ?a] )
} )
}.
0.3.5.2. Parts Of
sub#extended_part-of_or_equivalent
converse: sub#extended_part-of_or_equivalent,
\. p{ sub#eq
(sub#strict_extended_part-of
\. (sub#strict_part-of = sub#part_of sub#partOf,
converse: sub#strict_part )
(sub#part-of_between_types_but_for_their_instances = sub#c_part_of sub#c_partOf,
converse: sub#part_between_types_but_for_their_instances )
(sub#"elementOf-=>" = sub#elementOf-extended-entailment,
\. p{ (sub#"elementOf-==>" .(sub#Statement ?x, sub#Statement ?Y)
= sub#elementOf-entailment,
:= "∀x,Y elementOf-==>(x,Y) <==>
(∃X,x2!=x (X==>Y) ∧ (X <==> (x ∧ x2)))",
:= [a sub#Statement ?X ==> ?Y, <==> [?x. (?x2 != ?x)] ],
\. (sub#"elementOf-<==>" .(sub#Statement ?x, sub#Statement ?Y)
= sub#elementOf-equivalent-statement,
:= [?Y <==> [?x. (?x2 != ?x)] ] ) )
(sub#elementOf-NC-definition owl#inverseOf: sub#NC-definition-element)
})
(sub#"elementOf-<=" = sub#elementOf-extended-reverse-entailment,
\. p{ (sub#"elementOf-<==" .(sub#Statement ?x, sub#Statement ?Y)
:= [a sub#Statement ?X <== ?Y, <==> [?x. (?x2 != ?x)] ],
\. sub#"elementOf-<==>" )
(sub#elementOf-SC-definition owl#inverseOf: sub#SC-definition-element)
})
)
}
partOf_or_equivalent .
0.3.6. Relations Between Two Statements
relation_between_two_statements .(Statement .?, Statement)
= relation_to_another_statement related_statement,
\= relation-between-two-statements_wrt_the_assertion_of_the_source //see subsection below
relation-between-two-statements_wrt_truth-preservation, //see subsection below
\. overriding-or-correcting_statement //see subsection below
p{ relation-to-another-statement_that_is_not_a_logic_operator
logic_operator //defined in Section 0.3.1
// \. (truth-status-restricting_logic_operator \. e{or xor implication not})
}
p{ (not-truth-status-restricting_relation_to_another_statement
:= "the destination statement does not modify the truth status of the source statement" )
(truth-status-restricting_relation_to_another_statement
:= "the destination statement modifies the truth status of the source statement,
at least according to the author of the relation",
\. e{ statement-contextualizing_statement //defined in 0.3.6.1 (next subsection)
logic-objection_or_correction //defined in 0.3.6.1
truth-status-restricting_logic_operator //in Section 0.3.1
} )
}
p{ (statement_not_inferred_using_this_source
\. p{ semantic_generalizing-statement_not_inferred_using_this_source //Section 1.3.8.2
(semantic_specializing-statement_not_inferred_using_this_source
/^ semantic_gSpecialization )
} )
(statement_inferred_using_at_least_this_source
\. p{ not-necessarily-truth-preserving_inference truth-preserving_conclusion }
p{ semantic_generalizing-statement_inferred_using_at_least_this_source //Section 0.3.4.3
(semantic_specializing-statement_inferred_using_at_least_this_source
/^ semantic_gSpecialization )
} )
}
(version \. (summary \. truth_preserving_summary))
overriding-or-correcting_statement . //see subsection below
0.3.6.1. Relation Between Two Statements, Wrt. the Assertion Of the Source
relation-between-two-statements_wrt_the_assertion_of_the_source
\. p{ (relation_to-another-statement_not_meaning_that_the_source_was_asserted
:=> //the following note was also given in Section 0.2.1, although it was
// about FL statements whereas here it is for any statement
"A statement that is source/destination of a relation, function or operator
(except for "and") is not asserted. Conversely, a statement is asserted if the
statement is an un-embedded statement (an embedding via an "and" operator does
not count). However, FL provides an exception: by prefixing a statement (or a
relation the statement is source of) by '.', the statement is asserted
regardless of its embedding level. This for example permits
[.?p => ?p2] and
[?p .=> ?p2] to be equivalent (and shortcuts for)
[?p [?p => ?p2]].",
\. p{ (relation_to-another-statement_meaning_that_the_source_should_be_asserted
\. (
statement-contextualizing_statement .(.?p, ?c)
:= [?p descr_instrument of:
(a Situation situation_contextualizing-thing:
(a Thing descr_instrument: ?c)) ]
) ) //situation_contextualizing-thing is defined in
Section 2.2
(^"relation_to_another_statement_where_the_source_does_not_need_to_be_asserted
and not_meaning_that_the_source_was_asserted"
\. e{ (rule_conclusion converse: rule_premise) rule_premise
truth-status-restricting_logic_operator //see Section 0.3.1
// \. e{or xor implication not}
} )
} )
(relation-to-another-statement_meaning_that_the_source_was_asserted
.(Statement .?p1, Statement ?p2)
:=> ?p1,
\. (argument_or_objection
\. p{ (argument \. logic-argument)
(objection .(.?p1, ?p2) \. logic-objection,
:= [?p1 negation: (a Statement argument: ?p2)] )
}
(
logic-argument-or-objection_or_correction
\. p{ (
logic-argument .(Statement, Logically-atomic_statement)
:=> "any logic-argument should be asserted and without
superfluous relations",
\. p{ (formal-or-informal_proof \. formal_proof)
(logic-argument_that_is_not_a_formal-or-informal_proof
\. (implied_logic-argument_that_is_not_a_formal-or-informal_proof
= ^"logic-argument that is not a formal-or-informal_proof
but still the destination of an implication" ) )
} )
(
logic-objection_or_correction
\. p{ (
logic-objection .(.?p1, ?p2)
:= [?p1 negation: (a Statement logic-argument: ?p2)] )
corrective_statement //next subsection
} )
}) )
(better-supported_than .(Statement ?s, Statement ?d)
\. OR{ [ [?s |^ Successfully-supported_statement
Uncontradicted-or-unsuccessfully-contradicted_statement ]
[?d |^ Unsupported_or_unsuccessfully-supported_statement] ]
[ [?s |^ Uncontradicted-or-unsuccessfully-contradicted_statement]
[?d |^ Successfully-contradicted_statement] ],
} ) //apparently no need for ?s and ?d to be argument_or_objection related
)
}.
0.3.6.2. Relation Between Two Statements, Wrt. Truth Preservation
relation-between-two-statements_wrt_truth-preservation
\. p{ (relation-to-another-statement_not_necessarily_meant_to_be_truth-preserving
:= "the destination statement is not necessarily true when the source statement is true",
\. e{ (not-necessarily-truth-preserving_inference \. analogy induction abduction )
(argument_or_objection
\.
logic-argument-or-objection_or_correction )
} )
(relation-to-another-statement_meant_to_be_truth-preserving //equal to next subtype?
:= "the destination statement is necessarily true when the source statement is true",
\. (
formal-or-informal_conclusion_of_a_rule-or-inference_meant_to_be_valid
.(Statement .?premise, Statement ?conclusion)
converse: (premise \. e{ cause_description logic-argument } ), //both defined below
\. c{ //not exclusive because a common-knowledge_based_implication may implicitly
// involve physical consequence
(
formal-or-informal_consequence_descr .(.?p, ?c) = ^'->'
^'→',
:= [?p descr_instrument of:
(a Situation consequence: (a Situation descr_instrument: ?c)) ],
converse: cause_description )
(
truth-preserving_conclusion
=
formal-or-informal_logic-based_conclusion
formal-or-informal_implication-or-deduction-or-derivation ^'==>',
:= ^"extension of the formal logic implication to allow
1. ?premise and ?conclusion to be informal statements, and
2. common-knowledge_based_implication (see the subtype)",
//reminder: [_?p => ?p2] is equivalent to [?p [?p => ?p2]]
converse:
(
formal-or-informal_logic-based_premise
\. p{ (
premisse_of_formal-or-informal_logic-derivation = ^'<=|',
\. (premise_of_formal_logic-derivation = ^'–|' ^'-|') )
(
premise_of_rule-exploitable-by-a-rule-of-inference
=
statement_sufficient_condition,
:= ^"statement of logic premise, at least within
a context where particular axioms are asserted if this
premise depends on particular axioms",
\. e{ (
premise_of_rule_for_modus-ponens_and_modus-tollens
= ^'<=' ^'
⇐' )
(
premise_of_rule_for_modus-ponens_not_modus-tollens
= ^'<<=' )
}
logic-argument )/defined below
} )
\. p{ (
formal-or-informal_logic-derivation = ^'|=>',
converse: premisse_of_formal-or-informal_logic-derivation,
:= ^"application of - or way to define - a
rule-of-inference_conclusion",
\. (formal_logic-derivation = ^'⊢' ^'|–' ^'|-',
converse: premise_of_formal_logic-derivation ) )
(
conclusion_of_rule-exploitable-by-a-rule-of-inference
=
statement_necessary_condition logic_implication,
converse: statement_sufficient_condition,
\. e{ (
conclusion_of_rule_for_modus-ponens_and_modus-tollens
=
classic_implication ^'=>' ^'
⇒' )
(
conclusion_of_rule_for_modus-ponens_not_modus-tollens
= ^'=>>' )
}
e{ conclusion_of_formal_rule-or-implication_statement
(conclusion_of_common-knowledge_reying_rule-or-implication
:= ^"conclusion of an implication in which ?premise does not
include all the information necessary to deduce
?conclusion but where the missing information is easily
retrievable by people given common knowledge and
common sense" )
} )
}
p{ truth_preserving_generalizing-statement //see below
truth_preserving_specializing-statement //see below
sub#equivalent_statement
}
truth_preserving_summary )
} ) )
}.
0.3.6.3. Overriding or Correcting Relations Between Two Statements
overriding-or-correcting_statement .(Statement .?p1, Statement ?p2)
\. ne{ (overriding_statement
\. (pm#overriding_specialization /^ statement_specialization,
\. (statement_overriding_instantiation /^ statement_instantiation ) ) )
(correcting_statement .(Statement .?p1, Statement ?p2) = truer_reformulation,
\. p{ (corrective_spec-comparable_statement /^ gSpec_comparable
\. (corrective_generalization /^ statement_generalization,
= generalizing_correction truer_generalization c_/ )
(corrective_specialization /^ statement_specialization,
= specializing_correction truer_specialization c\~ ) )
(corrective_not-spec-comparable_statement .(Statement .?p1, Statement ?p2)
\. (corrective_at-least-weakly-spec-uncomparable_statement := [wu{?p1,?p2}],
\. (corrective_strongly-spec-uncomparable_statement
= corrective_exclusion corr_excl cExcl ce, := [e{?p1,?p2}],
\. (corrective_negation = corr_neg c!:= [?p1 = not ,p2]) )
(corrective_alternative = correction_via_an_alternative)
) )
} )
}.
0.4. Collections and Their Interpretations
Composite_thing = Collection,
\. p{ (Collection_that_is_not_necessarily-at-least-partially-ordered
\. ne{ (OR_collection = OR_coll OR_, \. (OR_set /^ Set))
(XOR_collection = XOR_coll XOR_, \. (XOR_set /^ Set))
(AND_collection = AND_coll AND_, \. (AND_set /^ Set))
} )
(Collection_that_is_necessarily-at-least-partially-ordered
\. e{ (Collection_that_is_necessarily-at-least-partially-ordered-but-not-totally-ordered
\. Partially-ordered_graph Hash_table )
(Collection_that_is_necessarily-totally-ordered
\. p{ (Collection_that_is_necessarily-totally-ordered_and_indexed
\. p{ (Collection_necessarily-indexed-by-a-positive-natural-number = Array,
\. e{ Static_array (Dynamic_array = Vector) }
(Array_part_of_an_array \. Column (Row \. Head_row) ) )
(^"Collection that necessarily has a totally-ordered index that is
not necessarily-a-positive-natural-number" = Associative_array,
\. (Collection_necessarily-indexed-by-strings = Object_ADT,
\. p{ (Static_object-ADR = Record)
(Dynamic_object = Dictionnary)
} ) )
}
(Array_of_array = Table, part: 1..* Array_part_of_an_array)
)
(Collection_that_is_necessarily-totally-ordered_and_not-indexed
\. (List \. e{ (FIFO_list = Queue) (LIFO_list = Stack) } ) )
} )
} )
}
t_p{ (List_with_no_element = Null_list = kif#nil)
(List_with_one_element = Singleton)
List_with_more_than_one_element
}
(sumo#Unique_list = "list which happens to have no repetition_of_element")
p{ (Collection_with_possible_repetition_of_elements = Bag Multiset)
(Collection_without_possible_repetition_of_elements ?s = Set,
:= [ [?s member: ^m1 ^m2] => [^m1 != ^m2] ], //???
\. (Relation-type_instances = Relation_in_mathematics Relationship)
(Set_of_types = Set_of_things_that_can_have_an_instance,
= ^(Set member: only 1..* Type) )
}
p{ (Open_collection \. (Open_set = nc))
(Closed_collection
\. (Closed_set ?s = Complete_set c,
:= "if ^r is a type of relation from(/to) the members of a Closed_set
then from any ^x destination(/source) of that relation
any relation of type ^r from ^x is a member of ?s",
:= AND{ [ [any ^(Thing member of ?s) ^r of: (?x ^r: only a ^(Thing member of: ?s))]
] => [any ^(Thing ^r of: ^x) ^r of: (a Thing member of: ?s)],
[ [any ^(Thing member of ?s) ^r: (?x ^r of: only a ^(Thing member of: ?s))]
] => [any ^(Thing ^r: ^x) ^r: (a Thing member of: ?s)]
} ) ) //^r or equal?
}
Set_of_sources-of-a-transitive-relation. //specialized below
0.4.1. Potential Sources of a Transitive Relation
(Spec-partition, Part-partition, ...)
Collection_of_sources-of-a-transitive-relation
\. (Set_of_sources-of-a-transitive-relation /^ Set,
\. Set_of_things_that_may_be_specialized //0.3.4.1
Set_of_things_that_may_have_a_part ) //0.3.5.1.2
(Exclusive_things
\. Spec-exclusive_things //0.3.4.1
Part-exclusive_things ). //0.3.5.1.2
1. Attributes/Characteristics/Dimension/Measures
The starting types in the next subsections wer introduced in
Section 0.1.2 ( Entity Uppermost Types).
1.1. Attributes Wrt. Object Types
Physical_numerical_attribute = ^(Numerical_attribute attr of: a Physical_entity)
//hence /^ Attribute_of_Physical_entity if automatically generated
Attribute_about_an_increase_or_decrease
attribute of:=> Process_about_an_increase_or_decrease,
\.
Marginal_utility .
/* ne{ (Numerical_attribute \. Physical_numerical_attribute)
(Physical_attribute //for a physical process/entity, so could also be in Section 3.4
\. Physical_numerical_attribute (Spatial_attribute \. Volume)
(
Temporal_attribute
\. e{ (Past_time = ^(Temporal_attribute numerically-superior_attribute: Present])
(Future_time = ^(Temporal_attribute numerically-inferior_attribute: Present])
},
|. Present, //if directly/indirectly used (e.g., via the use of Past_time)
// but not defined with a value (as in [Present := 31/12/2018]), the inference
// engine should signal an error
) )
} ._(type _[.->.]: Type-set_wrt _(object_natural-type).
*/
1.2. Attributes Wrt. Roles
Attribute_wrt_role
\~ v_p{ Negative_attribute Positive_attribute }
Attribute_that_is_a_criteria
(Attribute_aggregating_other_attributes
\. Positive_attribute_aggregating_other_attributes )
/* (Attribute_value /^ Measure, //not here, useless, already declared in Section 0.1.2
\~ v_p{ Value_of_a_positive_attribute Value_of_a_negative_attribute },
(Percentage_value \. p{ 0pc Between_0_an_100pc 100pc })
(Logical-or-modal_value
\. p{ (Logical_value = Truth_value Truth_status,
\. (Boolean_value \. p{ (False_value /^ 0pc) (True_value /^ 100pc) } ) )
Non-logical_modal_value
} )
) */ .
1.2.1. Positive/Negative Attribute
Negative_attribute = Attribute_expressing_a_dissatisfaction_or_fitness-to-dissatisfy-an-agent-or-a-use,
:= ^"Characteristic or measure of 1. the dissatifaction of an agent or
2. how (and how much) a Thing may lead to the dissatisfaction of an agent or a use",
:=> "whether or not something leads to the dissatisfaction of an agent
depends on the preferences of each Agent but some preferences are
common to most agents; if (instances of) this type and its subtypes are
used without identifying a particular (group of) agents, they (implicitly
but clearly)
should apply to most agents",
\. p{ Attribute_expressing_a_dissatisfaction
(Fitness-to-dissatisfy-an-agent-or-a-use
\~ ne{ (Consumption-seen-as-cost_attribute
\. (Monetary-consumption_seen-as-cost = Cost)
Energy-consumption_seen-as-cost Network-consumption_seen-as-cost )
} )
}.
Positive_attribute ?a
\. (Globally-positive_wrt .[1..* Attribute ?attr]
\. (Globally_positive //either directly asserted or calculated (e.g. via this next subtype)
\. (Globally_positive_wrt_all_other_attributes ?a
:= [ [?a attr of: (?e attr _[inferencing: closed_world]: c{1..* Attribute ?a} ?as)]
[ [[an Aggregation_function ?f input: ?as] <= #ThisKB] //_[inferencing: closed_world]
=> [?a = ?f _(?as)] ] //?as is distributive, @.?as would be cumulative
[ [[no Aggregation_function ?f input: ?as] <= #ThisKB] => [?a value: false] ]
] ) ) )
(Attribute_expressing_a_satisfaction_or_fitness-to-satisfy-an-agent-or-a-use
= Utility ?u, //cardinal/ordinal
:=> [a Like-or-dislike-or-preference_description part: [?u attr of: a Thing ?object],
result of: (a Valuating_satisfaction object: ?object) ],
\. p{ (
Cardinal_utility ?cardUtil = Attribute_characterizing_a_valuation,
measure_unit_type: Util Satisfaction_unit Currency_unit,
)
(
Ordinal_utility ?ordUtil
= Attribute_characterizing_a_preference,
:= [?ordUtil attribute of: a Preference],
\. Attribute_characterizing_a_situation_that_is_a_right_or_a_duty )
}
p{ (Attribute_expressing_a_satisfaction
= Attribute_characterizing_an_agent_experiencing_a_satisfaction,
:=> "a measure of the satisfaction of an agent which is a group of
individual agents is an aggregation of measures for the satisfactions
of these individual agents;
for software agents, a measure of satisfaction may be a measure of how
well they have (or will be able to) achieve the goals they have;
a measure may be an aggregation of measures for different criteria",
\. ne{ (
Well-being = Wellness Welfare, /^ Characteristic )
Happiness_as_attribute Joy_as_attribute Pride_as_attribute
} )
(Fitness-to-satisfy-an-agent-or-a-use
= Attribute_characterizing_a_participant_to_a_potential_satisfaction,
\. (
Economic_value_of-at-least-1-thing_for-at-least-1-agent =
Economic_utility )
p{ (
Fitness_for_an_agent = Conformity_to_the_preferences_of_an_agent,
:= ^"how (and how much) a Thing may lead to the satisfaction of an Agent",
:=> "whether or not something leads to the dissatisfaction of an
agent depends on the preferences of each Agent but some preferences are
this depends on the preferences and goals of each Agent but some
preferences are common to most agents; if (instances of) this type and
its subtypes are used without identifying a particular (group of) agents,
they (implicitly but clearly)
should apply to most agents;
the use of attributes instances of this type - instead of attributes not
instances of this type - participates to normalizing the KB, e.g. it leads
to the creation and use of the Attribute type
^'Usability_of_the_qualified_thing_according_to_its_licensing' instead of
the Attribute type ^'Licensing' whose meaning is less constrained and
hence more likely to lead to uses that are not
compatible/comparable/inter-operable",
\. Fitness_for_an_agent_and_a_use )
(
Fitness_for_a_use
= Quality Conformity_to_a_specification_for_something_useful,
:= ^"Characteristic (and valuation) of/increasing the usability of a Thing;
for a particular use or specification, it can be possible to prove that
an attribute measures something that helps this use or helps satisfy
this specification",
//exclusion: Default, //no such exclusion exists since instantiating
// Quality and Default may depend on preferences
\. Fitness_for_an_agent_and_a_use
e{ (Usability \. Re-usability)
Quality_increasing_the_usability_of_the_qualified_thing
} )
} )
}.
1.2.2. Quality Increasing the Usability of the Qualified Thing
Quality_increasing_the_usability_of_the_qualified_thing
=
Quality_increasing_the_conformity_to_a_specification_for_something_useful,
++/^ Usability,
:=> "this category and its direct subtypes might seem strange but
they permit the grouping and organisation of some related
process qualities and entity qualities, e.g. they permit the
organisation/alignment and generalization+complementation of
1. the Dependability/Security related qualities extracted from
this ontology derived from the RESIST taxonomy", and
2. categorisations from [
Zaveri et al., 2016] via the types
Usability-increasing-quality_dependent_of_the_quality_evaluation_context
and Accessibility-or-dependability-or-security_related_quality",
\. p{ (
Usability-increasing-quality_dependent_of_the_quality_evaluation_context
\. (^"Usability-increasing-quality dependent_of when_the_quality-evaluation_occurs"
\. (Timeliness := ^"how up-to-date data is relative to a specific task",
/^ Description_semantic-content_attribute ) )
(^"Usability-increasing-quality dependent_of who_performs_the_quality_evaluation"
\. (Trustworthiness \. Authority) )
Relevancy
(Usability-increasing_description-instrument-quality_dependent_of_the_evaluation_context
/^ Description-instrument_attribute,
\. Naturalness (Understandability = Clarity, ^\++ Naturalness)
Learnability Operability )
)
(
Usability-increasing-quality_independent_of_the_quality_evaluation_context
\. (Conciseness /^ Description-instrument_attribute,
:=> "somewhat opposite to Redundancy" ) )
}
(
Accessibility-or-dependability-or-security_related_quality ?a
//note: the last above partition and the first one below have not yet been mixed;
// this will be done when this mix can be applied to several subtypes
\. p{ (
Quality_increasing_accessibility-or-dependability_but_not_security
++/^ Accessibility Dependability,
\. (
Information_sharability
= Info_sharability Info-sharability_attribute,
\. p{ Description-semantic-content_sharability
Description-instrument_sharability
Description-container_sharability
}
p{ (
Ratio-based_information_sharability
\. (Info-sharability_of_100pc = ^(Info-sharability value: 1))
(ODR-G-R_attribute //next attribute defined in
Section 0.6.2.1
\. ODR-G-R_attribute_derived_from_an_ODR-NG_relation ) )
(Not-ratio-based_information_sharability
\. ODR-NG_attribute )
}
p{
}
p{ (Strictly-internal_information_sharability
:= ^"Sharability only based on relations within the information" )
Non-strictly-internal_information_sharability
}
p{ //'p' even though `Information \. v_p{ Knowledge Data }'
(Knowledge_sharability = kr_sharability)
(Data_sharability \. Structured-data_sharability)
}
ne{ (Info-sharability_for_at-least-minimal_absolute-scalability
\. (Info-sharability_for_unique_place_to_insert-or-search_a_new_object
= ^"Degree of comparability-or-not via specialization relations
between any 2 objects (member objects for
Internal_info_sharability, member-of object otherwise)"
Degree_of_explicit-irredundancy-between-any-2-sub-objects,
\. (Info-sharability_for_differentia
= ^"Degree of explicit_differentia-or-not beween any 2 objects
(member objects for Internal_info_sharability)" )
)__[<=_ AND_{"any inference (and thereby any knowledge engineering
task) directly or indirectly relies on
comparability-or-not_via_gSpec_relations between
at least some objects",
"information sharing scalability requires inferences
for checking and guiding information sharing"
} ] )
Info-sharability_for_at-least-minimal_scalability-wrt-declared-relations
}
)
(Information-sharability_increasing_quality ++/^ Information_sharability)
(Maintenability := ^"ability to undergo repairs and modifications, or
time to restoration from the last failure occurrence")
(Maintenability_increasing_quality ++/^ Maintenability,
\. Testability Observability Stability
(Modifiability \. Extendability) (Reusability ^\++ Modularity) )
(Reliability := ^"measure of continuous delivery of correct service, or
measure of the time to failure",
\. (Safety := ^"reliability in case of catastrophic failure, or
measure of the time to catastrophic failure" ) )
(Reliability_increasing_quality ++/^ Reliability,
\. Robustness Tolerance_to_faults Recoverability
(Resilience \. Survivability) )
)
(
Quality_increasing_accessibility_and_dependability_and_security
++/^ Accessibility Dependability Security,
\. (Availability //what "Denial of service attacks" compromise
\. e{ Readiness_for_a_correct_service Service_correctness }
e{ Process_availability Description-container_availability } )
(Integrity := ^"absence of improper alterations",
\. (Authenticity := ^"integrity of a message content+origin(+other
information, e.g. the time of emission)"
\. e{ (Data-origin_authenticity
:= "whether the data truly originates from a particular agent" )
(Process_authenticity
:= "whether a process authentically did - or was object of -
particular actions (after/before some others)" )
} )
e{ Process_integrity Description-semantic-content_integrity
Agent_integrity } )
(Accountability := ^"Availability&integrity of the identity of the
person who performed an operation",
\. e{ Process_accountability Agent_accountability } )
(Non-repudiability //agent tracability, proof of agent authenticity
//no (action too):
// /^ Attribute_of_description_content-or-result-or-instrument-or-container,
\. (Non-repudiability_of_origin
:= ^"availability and integrity of the identity of message sender" )
(Non-repudiability_of_origin
:= ^"availability and integrity of the identity of a message receiver" ) )
(Trustability
\. (Autorisability
:= "represents whether an agent can do some action on something,
based on their characteristics and Action Control Policies" ) )
(Freshness
/^ Attribute_of_description_content-or-instrument-or-result-or-container,
:= "the (received) object received by an entity is not a copy of another
received by the same or another entity in the past" )
Tolerance_to_faults
Graceful degradation
)
(
Quality_increasing_security_but_not_accessibility_nor_dependability
++/^ Security,
\. (Confidentiality
:= ^"(relative) absence of (unauthorized) disclosure of information
that may permit particular agent to infer particular information",
\. Privacy )
Unlinkability Anonymity )
}
(
Completeness_with_respect_to_a_world_or_a_specification_for_something_useful
\. ne{ (Representation-completeness_with_respect_to_a_world // ++/^ Relevancy,
\. (Accuracy = Validity Correctness) //Relevancy Precision
(Description-semantic-content_completeness
/^ Description-semantic-content_attribute,
\. Logical_expressiveness Logical_completeness )
(Organization = Cohesiveness, //for any Thing, even a Process
\. Interlinking Intralinking Modularity )
(Origin_verifiability := ^"calcul on the existence of links to a reference
supporting the veracity of the qualified thing" )
)
(Completeness_wrt_specification-or-constraints \. Versatility )
}
(Completeness_of_description_content-or-instrument-or-result-or-container
\. Description-semantic-content_completeness Description-instrument_completeness
Description-container_completeness )
)
(
Consistency_of_behavior-or-content ++/^ Relevancy,
\. (Description-semantic-content_consistency /^ Description-semantic-content_attribute,
\. e{ Logical_consistency Semantic_consistency } )
(Description-instrument_consistency /^ Description-instrument_attribute,
\. e{ Structural_consistency Lexical_consistency } ) )
(
Efficiency \. Performance_efficiency Algorithmic_efficiency)
Usability_of_the_qualified_thing_according_to_its_licensing
//
Cooperativeness //in coop.html
).
1.2.3. Ratio-based Value of a Positive Attribute
Value_of_a_positive_attribute
\. e{ (Absolute_value_of_a_positive_attribute
= Positive_attribute_with_an_absolute_value )
(Percentage-based_value_of_a_positive_attribute
= Percentage_valuated_positive_attribute
Positive_attribute_valuated_with_a_percentage_of_the_maximal-fitness,
\. (Minus100percent_of_maximal-fitness-to-satisfy = -100pc_fit, value: -1)
(0percent_of_maximal-fitness-to-satisfy = 0pc_fit, value: 0)
(100percent_of_maximal-fitness-to-satisfy = 100pc_fit, value: 1)
e{ (0-33percent_of_maximal-fitness-to-satisfy = 0-33pc_fit,
value: (a real minE: 0, maxNE: 0.33) )
(^"[33-67[ percent of maximal-fitness-to-satisfy" = 33-67pc_fit,
value: (a real minE: 0.33, maxNE: 0.67) )
(67to00percent_of_maximal-fitness-to-satisfy = 67to100pc_fit,
value: (a real minE: 0.67, maxE: 1) )
}
e{ (0-20percent_of_maximal-fitness-to-satisfy = 0-20pc_fit,
value: (a real minE: 0, maxNE: 0.2),
\. p{ (Less-than-10-percent_of_maximal-fitness-to-satisfy= 0-10pc_fit,
value: (a real minE: 0, maxNE: 0.1) )
(^"[10-20[ percent of maximal-fitness-to-satisfy"= 10-20pc_fit,
value: (a real minE: 0.1, maxNE: 0.2) )
} )
(20to100-percent_of_maximal-fitness-to-satisfy = 20to100pc_fit,
value: (a real minE: 0.2, maxE: 1),
\. p{ (^"[20-40[ percent of maximal-fitness" = 20-39pc_fit,
value: (a real minE: 0.2, maxNE: 0.4),
\. p{ (^"[20-30[ percent of maximal-fitness"=20-30pc_fit,
value: (a real minE: 0.2, maxNE: 0.3) )
(^"[30-40[ percent of maximal-fitness"=30-40pc_fit,
value: (a real minE: 0.3, maxNE: 0.4) )
} )
(^"[40-60[ percent of maximal-fitness" = 40-59pc_fit,
value: (a real minE: 0.4, maxNE: 0.6),
\. p{ (^"[40-50[ percent of maximal-fitness"=40-50pc_fit,
value: (a real minE: 0.4, maxNE: 0.5) )
(^"[50-60[ percent of maximal-fitness"=50-60pc_fit,
value: (a real minE: 0.5, maxNE: 0.6) )
} )
(^"[60-80[ percent of maximal-fitness" = 60-79pc_fit,
value: (a real minE: 0.6, maxNE: 0.8),
\. p{ (^"[60-70[ percent of maximal-fitness" = 60-70pc_fit,
value: (a real minE: 0.6, maxNE: 0.7) )
(^"[70-80[ percent of maximal-fitness" =70-80pc_fit,
value: (a real minE: 0.7, maxNE: 0.8) )
} )
(80to100-percent_of_maximal-fitness = 80to100pc_fit,
value: (a real minE: 0.8, maxE: 1),
\. p{ (^"[80-90[ percent of maximal-fitness"=80-90pc_fit,
value: (a real minE: 0.8, maxNE: 0.9) )
(90to100-percent_of_maximal-fitness = 90to100pc_fit,
value: (a real minE: 0.9, maxE: 1) )
} )
} )
} )
}.
1.2.4. N-valuated-Logic Values and Modal Values
//see
Section 0.3.1. (Logic Operators) for details/exploitations
Statement_or_logical-value_or_modal-value
\. (Statement_or_logical-value
\. p{ Statement Logical_value } //both previously declared
c{ (Statement_or_logical-value_of_infinite-valued_logic
\. Value_of_fuzzy_logic Value_of_probability_logic)
(Statement_or_logical-value_of-finite-valued_logic
\. e{ (Binary-logic_value \. p{ (FALSE = false) (TRUE = true) })
} )
}
p{ (False \. p{ False_statement False_value }, |. c{FALSE})
(Not_false
\. p{ (True \. p{ True_statement True_value}, |. c{TRUE})
(Neither_true_nor_false |. c{ (Neither_true_nor_false = NTNF) }
\. (Ternary-logic_unknown |. c{ (UNKNOWN ../ NTNF) })
(Ternary-logic_error |. c{ (ERROR ../ NTNF) })
(Ternary-logic_undecidable |. c{ (UNDECIDABLE ../ NTNF) })
)
} )
} )
(
Modal_statement-or-value
\. p{ (Modal_statement = ^(Statement measure: a Modal_value))
Modal_value
}
(Statement-or-value_expressing_a_checking_constraint = PvC,
\. p{ (Checking_constraint = ^(Statement measure: a Checking-constraint_modality),
\. Rule-based-checking_constraint ) /*
Section 3.2.5.3 */
(Checking-constraint_modality /^ Modal_value)
} )
(Statement-or-value_of_alethic_modality = Statement-or-value_about_the_truth_in_the_world,
\. (Statement-or-value_of_alethic-modality_of_
classical_modal_logic
:=> "Every
Normal_modal_logic is a
Regular_modal_logic and every
Regular_modal_logic is a
Classical_modal_logic",
\. p{ (Necessarily_false = Impossible Not_possibly_true, /^ False)
(Not_necessarily_false = Possible Possibly_true,
:=> "may be actually true or actually false",
\. p{ (Contingent /^ Not_necessarily_true,
:= ^"possible and|but not necessarily true" )
(Necessarily_false = Impossible, /^ False)
} )
}
p{ (Necessary = Necessarily_true Not_possibly_false, /^ True)
(Not_necessarily_true = Possibly_false,
\. p{ Contingent
(Necessarily_true /^ True)
} )
} )
e{ //https://en.wikipedia.org/wiki/Modal_logic#Alethic_logic
(Statement-or-value_of_alethic-modality_only_about_logical_possibility
= ^"Statement-or-value_of_alethic-modality where the used modality only
involves logic rules, not physical/... rules of the current world/context")
(Statement-or-value_of_alethic-modality_only_about_physical_possibility
= ^"Statement-or-value_of_alethic-modality where the used modality only
involves physical rules of the current world/context")
(Statement-or-value_of_alethic-modality_only_about_metaphysical_possibility
= ^"Statement-or-value_of_alethic-modality where the used modality only
involves metaphysical rules/axioms of the current world/context")
} )
(Statement-or-value_of_epistemic-modality
= Statement-or-value_about_the_truth_in_an_individual-s_mind_given_what_he_knows )
Statement-or-value_of_temporal-modality
(Statement-or-value_of_deontic-modality
:=> "related to may/must regarding morality/obligations/norms",
\. p{ Value_of_deontic-modality
(Statement_of_deontic-modality /^ Statement,
\. e{ (Statement_authorizing-or-not_some_actions_on_some_possessions ?p
:= [?p descr_instrument of:
[an authorization object:
[1..* action object: (1..* Thing owner: 1..* Agent)] ] ],
\.
(Statement_by_an_agent_authorizing-or-not_some_actions_on_its_possessions
?p := [?p descr_instrument of:
[an agent ?a agent of: (an authorization object:
[1..* action object: (1..* Thing owner: ?a)] )] ] ) )
(Statement_using_a_deontic-modality_to_express_a_best_practice
\.
Statement_using_RFC-2119_to_express_a_best_practice )
} )
}
e{ (Statement-or-value_of_deontic-modality_about_rule_compliance
\. e{ (^"Statement-or-value_of_deontic-modality_about_rule_compliance
as informally defined in RFC 2119"
\. Statement_using_RFC-2119_to_express_a_best_practice )
} )
} )
(Statement-or-value_of_doxastic-modality
:=> "modality expressing 'It is believed by all/some/x/y/... that' " )
).
1.3. Attributes Wrt What They Qualify
Attribute_qualifying_something
\. Complete_set { Situation_attribute Entity_attribute } //not exclusive_set
Exclusive_set{ Situation-specific_attribute Entity_specific_attribute }.
Situation_attribute
= ^(Attribute attribute of: a Situation) //to inherit the non-specific_attributes
\. Complete_set{ (Process_attribute = ^(Attribute attribute of: a Process))
(State_attribute = ^(Attribute attribute of: a State))
}
(Situation-specific_attribute = ^(Situation_attribute not attribute of: an Entity),
\. (Process-specific_attribute = ^(Process_attribute not attribute of: a State),
\. (Process_cooperativeness
\. (Cooperativeness_of_a_process_wrt_its_instruments
\. (Cooperativeness-sum_of_a_process_wrt_its_instruments ?csp
:= ^"sum of the cooperativenesses of the instruments of this process",
:= sum_( {1..* ^(Cooperativeness attribute of:
(a Thing instrument of: ?csp) ) } ) )
(Cooperativeness-average_of_a_process_wrt_its_instruments ?cap
:= ^"average of the cooperativenesses of the instruments of this process",
:= div_( (the Cooperativeness-sum_of_a_process_wrt_its_instruments
attribute of: ?cap),
Cardinality_( {1..* ^(Thing instrument of: ?cap)} ) ) )
) ) )
)
(Attribute_of_situation_via_a_participant_of_it .(Situation, Situation_attribute)
\. (Attribute_of_process_via_a_participant_of_it .(Process ?p, Process_attribute ?pa)
:= [?pa attribute of: (a Thing process_participant of: ?p)]
) ).
Entity_attribute
= ^(Attribute attribute of: an Entity), //to inherit the non-specific_attributes
\. c{ (Spatial-entity_attribute = ^(Attribute attribute of: a Spatial_entity)
Non-spatial-entity_attribute
}
(Entity-specific_attribute = ^(Entity_attribute not attribute of: a Situation),
\. Agent_attribute
(Attribute_of_description_content-or-instrument-or-result-or-container //see Section 1
\. Description-semantic-content_attribute
(Description-instrument_attribute
\. (Description-instrument_usability /^ Usability,
\. Description-instrument_sharability ) ) // /^ Information_sharability
Description-container_attribute ) )
(Statement_attribute = ^(Entity_attribute attribute of: a Statement) ). //Section 1.3.9
Agent_attribute
= ^(Attribute attribute of: an Agent),
\. (Cooperativeness_of_an_agent
\. e{ (Cooperativeness-sum_of_an_agent ?csa
:= ^"sum of the cooperativenesses of past actions of this agent",
:= sum_( {1..* ^(Cooperativeness attribute of:
(a Process agent: (an Agent attr: ?csa), time: a Past_time) )
} ) )
(Cooperativeness-average_of_an_agent ?caa
:= ^"average of the cooperativenesses of past actions of this agent",
:= div_( (the Cooperativeness-sum_of_an_agent attribute of: ?caa),
Cardinality_( {1..* ^(Process agent: (an Agent attr: ?caa),
time: a Past_time ) } ) ) )
} )
(Satisfaction_of_an_agent
\. e{ (Satisfaction-sum_of_an_agent ?ssa
:= ^"sum of the satisfactions of this agent",
:= sum_( {1..* ^(Agent_satisfaction attribute of: (an Agent attr: ?ssa)) } ) )
(Satisfaction-average_of_an_agent ?saa
:= ^"average of the satisfactions of this agent",
:= div_( (the Satisfaction-sum_of_an_agent attribute of: ?saa),
Cardinality_( {1..* ^(Agent attr: ?saa)} ) ) )
} ).
Agents_attribute = ^(Attribute attribute of: {1..* Agent}),
\. (Cooperativeness_of_agents
\. (Cooperativeness-sum_of_agents ?csas
:= sum_( { (1..* ^(Cooperativeness-average_of_an_agent
attr of: (an Agent member of: ({1..* Agent} attr: ?csas)) ) )
} ) )
(Cooperativeness-average_of_agents ?caas
:= div_( (Cooperativeness-sum_of_agents attribute of: ?caas),
Cardinality_( {1..* ^(Agent member of: ({1..* Agent} attr: ?caas))} )
) )
)
(Satisfaction_of_agents
\. (Satisfaction-sum_of_agents ?ssas
:= sum_( { (1..* ^(Satisfaction-average_of_an_agent
attr of: (an Agent member of: ({1..* Agent} attr: ?ssas)) ) )
} ) )
(Satisfaction-average_of_agents ?saas
:= div_( (Satisfaction-sum_of_agents attribute of: ?saas),
Cardinality_( {1..* ^(Agent member of: ({1..* Agent} attr: ?saas))} )
) )
).
1.4. Attribute Aggregating Other Attributes
Attribute_aggregating_other_attributes
\. Positive_attribute_aggregating_other_attributes.
1.4.1. Positive Attribute Aggregating Other Attributes
Positive_attribute_aggregating_other_attributes
\.(Positive_attribute-of-a-thing_aggregating_pc-valuated_attributes_of_this_thing
\. e{(Positive-attr-of-a-thing_arithmetic-average-of-pc-valuated-attrs-of-this-thing ?a
:= arithmetic_average_({1..* ^(Percentage_valuated_positive_attribute
attr of: (the Thing attr: ?a), != ?a)}) )
(Positive-attribute-of-a-set-of-things_aggregating_pc-valuated-attrs_of_these_things
\. (Positive-attr-of-a-set-of-things_arithm-average-of-pc-valuated-attr-of-the-things ?a
:= arithmetic_average _({1..*
^(Positive-attr-of-a-thing_arithmetic-average-of-pc-valuated-attrs-of-this-thing
attr of: (a Thing member of: (a set attr: ?a)) ) }) ) )
} )
(Positive-attr-of-a-set-of-things
\. (Pos-attr-of-a-set_arithm-average-of-non-default-pc-valuated-attrs-for-given-type
.(Set ?set, ^Percentage_valuated_positive_attribute ?givenAttrType) -: ?a
:= 1 - (sum _({1..* ?givenAttrType attr of: (a Thing member of: ?set) })
/size(?set) ),
\. (Pos-attr-of-a-KB_arithm-average-of-non-default-pc-valuated-attrs-for-the-given-type
.(^Attribute ?givenAttrType) -: ?a
:= Pos-attr-of-a-set_arithm-average-of-non-default-pc-valuated-attrs-for-given-type
_((the KB attr: ?a), ?givenAttrType) )
)
(Positive-attr-of-a-set-of-things_average-of-pc-valuated-attrs-for-the-given-type
.(Set ?set, ?average_fct, ^Percentage_valuated_positive_attribute ?givenAttrType) -: ?a
:= ?average_fct _({1..* ?givenAttrType attr of: (a Thing member of: ?set) }),
\. (Pos-attr-of-a-KB_arithm_average-of-pc-valuated-attrs-of_its_objects_for-the-given-type
.(^Attribute ?givenAttrType) -: ?a
:= Positive-attr-of-a-set_average-of-pc-valuated-attrs-for-the-given-type
_((the KB attr: ?a), ?arithmetic_average, ?givenAttrType) ) )
).
2. Situations
2.1. Relations From Situations
relation_from_a_Situation .(Situation, *)
\. p{ relation_from_a_Situation_to_a_Situation relation_from_a_Situation_to_an_Entity }.
2.1.1. Relations From Situations To Situations
relation_from_a_Situation_to_a_Situation .(Situation, Situation)
/^ relation_to_a_Situation,
\. (predecessor_situation converse: successor_situation,
\. p{ predecessor_process predecessor_state }
(cause converse: consequence, \. p{ cause_state cause_process} )
(consequence \. p{ consequence_state consequence_process} ) )
p{ (relation_from_a_Situation_to_a_Process \. predecessor_process)
(relation_from_a_Situation_to_a_State
\. (predecessor_state converse: successor_state,
\. beginning_state precondition cause )
(successor_state \. end_state postcondition consequence purpose ) )
}.
2.1.2. Relations From Situations To Entities
relation_from_a_Situation_to_an_Entity .(Situation, Entity)
/^ relation_to_an_Entity,
\. p{ (relation_from_a_Situation_to_a_non-contextualizing_entity
\. (relation_from_a_Process_to_a_non-contextualizing_entity .(Process, Entity)
\. e{ (relation_from_a_Process_to_a_non-contextualizing_attribute
.(Process, Entity) \. manner speed )
process_participant
} ) )
relation_from_a_Situation_to_a_contextualizing_thing
}.
2.1.2.1. Relation From Situations To Contextualizing Things
relation_from_a_Situation_to_a_contextualizing_thing = situation_contextualizing-thing
\. (universally-quantified-situation_contextualizing-thing .(Situation ?si, Thing ?t)
:=> [?si __/ [ .]0--100%] Situation relation: a Thing] ],
relation_from_a_universally-quantified-Situation_to_a_Spatial-entity
)
e{ (relation_from_a_universally-quantified-Situation_to_a_Spatial-entity
.(Situation ?si, Spatial-entity ?sp)
\. place
(relation_from_a_Process_to_a_Spatial-entity .(Process, Spatial-entity)
\. from_place (to_place = destination)
path_length .(Process -: Spatial_attribute)
via_places .(Situation,
{Spatial-entity+} //non-empty distributive set of
) ) ) // spatial entities
(relation_from_a_Situation_to_a_Temporal-attribute .(Situation, Temporal_attribute)
\. time //as noted in Section 0.6, if Present is valuated, ^'a Past_time' and
// ^'a Future_time' are usable as destinations of ^'time' relation
// in assertions or queries
(from_time = since_time) (to_time = until_time) duration
via_times .(Situation, {Temporal_attribute+}) )
relation_from_a_Situation_to_a_modality
}.
2.1.2.2. Process Participants
Participants vs. modifications (creation, update, deletion)
Legend: "-": "unexpected" (bad practice, ...); "+": "expected";
" ": "not un-expected" (but, if subtypes exist, an enticement to use them is valuable);
"-/+": "unexpected in I.T., expected in the physicical world";
other: only subtype where expected |
| not
modified |
non-intrinsically
modified |
intrinsically
modified |
| *-agent | | |
|
| agent | | |
– |
| initiator | + | – |
– |
| permanent_agent | | + |
– |
| from-agent | + | – |
– |
| to-agent | – | recipient |
patient |
| input_or_output | | |
|
| input_only | | |
|
| input-only_object | + |
–/+ |
deleted_input |
| instrument | + | –/+ |
–/+ |
| parameter | + | – |
– |
| input-output | – | + |
+ |
| output_only | – | – |
+ |
process_participant .(Process, Entity) = case_relation_with thematic_relation_with,
\= process-participant_wrt_modification,
\. e{ agent_or_from-or-to-agent input_or_output }[__ use] //below
p{ constant_participant temporary_participant }
p{ (core_participant \. main_participant) non-core_participant }.
process-participant_wrt_modification
\. p{ (unmodified_process-participant \. e{ unmodified_agent unmodified_input-or-output })
(modified_process-participant
\. p{ (participant_that_is_modified_but_not_intrinsically
\. e{ participant_that_is_updated_but_not_intrinsically }
e{ agent_that_is_modified_but_not_intrinsically
input-or-output_that_is_modified_but_not_intrinsically
} )
(intrinsically-modified_participant
\. p{ created_participant intrinsically-updated_participant deleted_participant }
e{ intrinsically-modified_agent intrinsically-modified_input-or-output } )
}
p{ (created_participant \. e{ created_agent created_input-or-output })
(updated_participant
\. p{ participant_that_is_updated_but_not_intrinsically
intrinsically-updated_participant
}
e{ updated_agent updated_input-or-output } )
(deleted_participant \. e{ deleted_agent deleted_input-or-output })
} )
}
p{ (participant_that_is_not_modified_or_at_least_not_intrinsically
\. p{ unmodified_process-participant
participant_that_is_modified_but_not_intrinsically
} )
(intrinsically-modified_participant
:=> "by '
intrinsic', the usual philosophical meaning is here refered
(without intrinsicism), e.g., parts are intrinsic while colors, containers
and space/time positions generally are not unless the modified thing is
'specifically dependent' on them; for an information record/structure/object,
any modification of its recorded parts, attributes or methods is an
intrinsic modification" )
}.
agent_or_from-or-to-agent .(Process ?p, Causal_entity ?ce) = do-er doer,
\. (
agent
\. p{ permanent_agent (temporary_agent \. initiator) }
(agent_and_instrument .(Process ?p, Instrument ?i)
:= [?p agent: (?i instrument of: ?p)] ) )
n{ from_agent
(to_agent \. n{ (
recipient \.
beneficiary .(Process, Volitional_agent))
(
patient =
experiencer) } )
}
p{ (agent_that_is_not_modified_or_at_least_not_intrinsically
\. p{ (unmodified_agent \. initiator from_agent)
(agent_that_is_modified_but_not_intrinsically \. c{
recipient })
}
agent __[modality: by_default_with_warning_if_used_otherwise] )
(intrinsically-modified_agent
\. p{ created_agent (intrinsically-updated_agent \. c{
patient } )
deleted_agent
} )
}.
input_or_output .(Process ?p, sub#Individual ?i)
\. p{ (
input_only
\. p{ (core_input-only = input-only_object, := [?p, core input-only: ?i],
\. p{ unmodified_input-only_object
(modified_input-only_object
\. p{ input-only_object_that_is_modified_but_not_intrinsically
(intrinsically-modified_input-only_object \. deleted_object)
} )
}
p{ (core_physical_input-only = input-only_physical-object,
:= [?p core_input-only: (?i type: Physical_object)] )
(core_non-physical_input-only = input-only_non-physical-object)
} )
(non-core_input-only
\. e{ (parameter \. p{ input_parameter process_parameter output_parameter })
(instrument \. p{ non-physical_instrument physical_instrument })
} )
}[__ use]
p{ (
unmodified_input-only
\. e{
parameter non-physical_instrument input-only_non-physical-object } )
(
modified_input-only
\. e{
physical_instrument input-only_physical-object }
p{ input-only_that_is_modified_but_not_intrinsically //no more details below
(intrinsically-modified_input-only
\. p{ (
deleted_input \. deleted_object)
intrinsically-updated_input-only } )
} )
} )
(
input-output
\. p{ unmodified_input-output //as below
(modified_input-output
\. p{ input-output_that_is_modified_but_not_intrinsically //below
intrinsically-modified_input-output //below
}
p{ (modified_input-output_object := [?p, core modified_input-output: ?i])
modified_non-core_input-output
} )
} )
(
output_only = intrinsically-modified_output-only
core_output-only created_output created_object,
\. p{ physical_output-only non-physical_output-only } )
}
c{ (
input
\. p{ input_only input-output }
p{ unmodified_input
(
modified_input
\. p{ input_that_is_modified_but_not_intrinsically
(
intrinsically-modified_input
\. p{ intrinsically-modified_input-only //above
intrinsically-modified_input-output //as above
} )
}
p{ (
modified_input_object := [?p, core modified_input: ?i],
\. p{ modified_input-only modified_input-output } ) //above
modified_non-core_input
} )
} )
(
output = result,
\. p{ input-output
output_only //above: (intrinsically-modified created object)
} )
}
p{ (unmodified_input-or-output //not deleted, not created/assigned, not updated
\. p{ unmodified_input-only unmodified_input-output unmodified_output-only } )
(modified_input-or-output
\. p{ (
modified_object := [?p, core modified_input-or-output: ?i],
\. modified_input_object input-only_object) //above
(modified_non-core_input-or-output \. modified_non-core_input) //above
}
p{ modified_input-only modified_input-output //above
output-only //above: (intrinsically-modified created object)
}
p{ (input-or-output_that_is_modified_but_not_intrinsically
\. p{ input-only_that_is_modified_but_not_intrinsically //as above
input-output_that_is_modified_but_not_intrinsically
} )
(intrinsically-modified_input-or-output
= created-or-intrinsically-updated-or-deleted_input-or-output,
\. p{ (
intrinsically-modified_object
:= [?p, core intrinsically-modified_input-or-output: ?i] )
intrinsically-modified_non-core_input-or-output
}
c{ (intrinsically-modified_input = deleted-or-intrinsically-updated_input,
\. p{ intrinsically-modified_input-only //above
(intrinsically-modified_input-output
= intrinsically-updated_input-output )
}
p{ deleted_input
(intrinsically-updated_input
\. p{ intrinsically-updated_input-only
intrinsically-modified_input-output } )
} )
output-only //above: (intrinsically-modified created object)
}
p{ intrinsically-modified_input-only //above
intrinsically-modified_input-output //above
output-only //(intrinsically-modified created object)
}
p{ deleted_input //below
(created-or-intrinsically-updated_input-or-output
= created-or-modified_output , /^ output,
\. p{ (created_output = created_object)
(intrinsically-modified_input-output
= intrinsically-modified_input,
\. p{ (intrinsically-modified_object
\. material resource muted_object)
intrinsically-modified_instrument
} )
} )
}
c{ intrinsically-modified_input
\. p{ deleted_input intrinsically-modified_input-output } )
(created-or-modified_output
} )
} )
}
p{ (created_input-or-output \. p{ created_input-output output-only })
(updated_input-or-output \. p{ updated_input-only updated_input-output updated_output-only })
(deleted_input-or-output = deleted_input deleted_object)
}
p{ (physical_input-or-output := [?p input_or_output: (?i type: Physical_object)],
\. p{ (physical_input-only
\. p{ core_physical_input-only //= input-only_physical-object
(non-core_physical_input-only \. physical_instrument)
} )
physical_input-output physical_output-only
} )
(non-physical_input-or-output
\. p{ (non-physical_input-only
\. p{ core_non-physical_input-only //= input-only_non-physical-object
(non-core_non-physical_input-only \. e{ parameter non-physical_instrument })
} )
non-physical_input-output non-physical_output-only
} )
}
p{ (core_input-or-output = input-or-output_object
core_object,
:= [?p, core input-or-output: ?i],
\. p{ core_input-only core_input-output core_output-only } )
(non-core_input-or-output
\. p{ non-core_input-only non-core_input-output non-core_output-only } )
}[__ use].
2.2. Processes wrt. Their Relations
Process
\= n{ //old?: naming of 2 partitions:
Process_wrt_input_modification
(Process_wrt_goal
\. (Process_wrt_CRUD
\. n{ Getting-or-retrieving //below
(Creating_or_updating_or_deleting
\. p{ Creating-or-updating-or-deleting_without_object-intrinsic-modification
Creating-or-updating-or-deleting_via_object-intrinsic-modification
} ) //details below
} ) )
(Process_wrt_core-object_type |^ Type_wrt _(core-object_natural-type)
\. n{ //not exclusive??? how to tell Type_wrt???
(
Process_having_a_physical_object_as_core_object
:= [Process core_object: a Physical_object] )
(
Process_having_an_information_object_as_core_object
:= [Process core_object: an Information_object] )
(
Process_having_an_agent_as_core_object
:= [Process core_object: an Agent],
\. Restriction_of_an_agent )
} )
}
n{ Union-or-addition_based_process
Intersection-or-substraction_based_process
} .
Process_wrt_input_modification
\. p{ (Process_not_modifying_its_inputs_or_at_least_not_intrinsically
= ^(Process intrinsically-modified_input: 0 Thing),
\. p{ Process_not_modifying_its_inputs //below
Process_modifying_some_of_its_inputs_but_never_intrinsically //below
} )
(Process_intrinsically_modifying_an_input
\. Process_intrinsically_modifying_a_core_object ) //modifying, not creating it
}
p{ (
Process_not_modifying_its_core_objects_or_at_least_not_intrinsically
= ^(Process intrinsically-modified_object: 0 Thing),
\. Process_not_modifying_its_inputs_or_at_least_not_intrinsically //above
p{ Process_not_modifying_its_core_objects //below
Process_modifying_some_of_its_core_objects_but_never_intrinsically //below
}
p{ Getting-or-retrieving_without_object-intrinsic-modification //below
Creating-or-updating-or-deleting_without_object-intrinsic-modification
Conservatively_creating Conservatively_modifying
} )
(Process_intrinsically_modifying_a_core_object
= ^(Process intrinsically-modified_object: 1.* Thing) )
}
p{ (
Process_not_modifying_its_inputs = ^(Process modified_input: 0 Thing),
\. (Process_not_modifying_its_core_objects = ^(Process modified_input_object: 0 Thing))
ne{ Creating-or-updating-or-deleting_without_input_modification //below
Getting-or-retrieving_without_input_modification //below
}
(Function-based_process_on_information_object
input: 1..* Info_object, output: 1..* Info_object
) )
(Process_modifying_an_input_intrinsically-or-not
\. p{ (
Process_modifying_some_of_its_inputs_but_never_intrinsically
= ^(Process modified_input: 1..* Thing,
intrinsically-modified_input: 0 Thing),
\. (
Process_modifying_some_of_its_core_objects_but_never_intrinsically
= ^(Process modified_object: 1..* Thing,
intrinsically-modified_object: 0 Thing) ) )
(Process_intrinsically_modifying_an_input
= ^(Process intrinsically-modified_input: 1..* Thing),
\. (
Process_intrinsically_modifying_a_core_object
\. p{ (Process_structurally_modifying_an_object
\. p{ Process_additively_modifying_an_object
Process_non-additively_modifying_an_object
} )
Process_intrinsically-but-not-structurally_modifying_an_object
} ) )
} )
}
(Process_about_an_increase_or_decrease).
Getting-or-retrieving
\. p{ (Getting-or-retrieving_via_object-intrinsic-modification
/^ Process_intrinsically_modifying_a_core_object,
\. Info-object_getting-or-retrieval_directly_used_for_creation-or-update )
(Getting-or-retrieving_without_object-intrinsic-modification
/^ Process_not_modifying_its_core_objects_or_at_least_not_intrinsically,
\. e{ Getting-or-retrieving_of_a_physical_object_by_moving_it
(Information-object_getting-or-retrieval_without_object-intrinsic-modification
:=> "e.g., as in the
Read operations in databases,
\. (Information-object_getting-or-retrieval_that_is_not_also_a_creation-or-update
\. ^"Getting-or-retrieving_of_an_information_object
without_input-output-variable_initialization" ) )
} )
}.
Creating-or-updating-or-deleting_without_object-intrinsic-modification
/^ Process_not_modifying_its_core_objects_or_at_least_not_intrinsically,
\. p{ (Creating-or-updating-or-deleting_without_input_modification
/^ Process_not_modifying_its_inputs,
\. (Creating-or-updating-or-deleting_of_information_object_without_input_modification
/^ Function-based_process_on_information_object ) )
(Creating-or-updating-or-deleting_with_some_input_modification_but_never_intrinsically
/^ Process_modifying_some_of_its_inputs_but_never_intrinsically
}
n{ (Creating_without_object-intrinsic-modification created_output: 1..* Thing,
\. Creating_by_duplication_of_the_core_objects ) //below
(Updating_without_object-intrinsic-modification
non-intrinsically-modified_input-output: 1..* Thing)
(Deleting_without_object-intrinsic-modification deleted_object: 1..* Thing)
}
n{ (Creating-or-updating-or-deleting_by_duplication_of_the_core_objects ?p
created-or-intrinsically-modified-or-deleted_input-or-output:
1..* ^(Thing copy of: (a Thing input of ?p)),
\. Creating_by_duplication_of_the_core_objects ?p
\. Creating_an_information-object_via_duplication ) ) //below
(Creating-or-updating-or-deleting_by_association_without_duplication
\. n{ (Creating_by_associating_to_core_objects
/^ Creating_without_object-intrinsic-modification,
\. Creating_an_information-object_by_association )
(Updating_by_associating_to_core_objects
/^ Updating_without_object-intrinsic-modification,
\. Updating_an_information-object_by_association )
(Deleting_by_associating_to_core_objects
/^ Updating_without_object-intrinsic-modification,
\. Deleting_an_information-object_by_association Deactivating )
} )
}.
Creating-or-updating-or-deleting_via_object-intrinsic-modification
:=> "e.g., as in the
Create, Update and Delete operations in databases,
/^ Process_intrinsically_modifying_a_core_object,
\. p{ (Creating_or_updating-by-adding-to_via_object-intrinsic-modification
:=> "e.g., as the
Create operations for databases",
\. p{ Creating_without_updating-by-adding-to_via_object-intrinsic-modif
Updating-by-adding-to_via_object-intrinsic-modification
} )
(^"Updating-without-adding-to-nor-removing-from
via_object-intrinsic-modification"
:=> "e.g., as the
Update operations for databases" )
(Deleting-or-deactivating-or-removing-from_via_object-intrinsic-modification
:=> "e.g., as the
Delete operations for databases"
\. p{ ^"Deleting_without_removing-from-nor-deactivating
via_object-intrinsic-modification"
(Deactivating_or_removing-from_via_object-intrinsic-modification
\. p{ (Deactivating_via_object-intrinsic-modification
/^ "Updating-without-adding-to-nor-removing-from
via_object-intrinsic-modification" )
Updating-by-removing-from_via_object-intrinsic-modification
} )
} )
}
n{ (Creating_without_updating-by-adding-to_via_object-intrinsic-modification
\. )
(Updating_via_object-intrinsic-modification
\. p{ ^"Updating-without-adding-to-nor-removing-from
via_object-intrinsic-modification"
(^"Updating-by-adding-to-or-removing-from
via_object-intrinsic-modification"
\. p{ Updating-by-adding-to_via_object-intrinsic-modification
Updating-by-removing-from_via_object-intrinsic-modification
} )
} )
(^"Deleting_without_removing-from-nor-deactivating
via_object-intrinsic-modification"
deleted_input: 1..* Thing )
}.
Process_having_an_information_object_as_core_object
object: 1..* Info_object,
\. n{ (Information-object_getting-or-retrieval
\. p{ Info-object_getting-or-retrieval_directly_used_for_creation-or-update //below
Information-object_getting-or-retrieval_that_is_not_also_a_creation-or-update
}
n{ Info-object_reading (Info-object_selection \. Info-object_search)
(Info_object_extraction \. Info-object_interpretation)
} )
(Information-object_creation-or-update
input: 1..* Info_object, output: 1..* Info_object,
\. n{ (
Information-object_aggregation
/^ Union-or-addition_based_process,
\. (Information-object_synthesis
\. (Modeling succ: Designing Planning)
Designing Planning Conservative_merging ) )
(
Information-object_selection-or-intersection-or-substraction
/^ Intersection-or-substraction_based_process,
\. p{ (Info-object_getting-or-retrieval_directly_used_for_creation-or-update
\. Copying Storing Distributing Sharing )
(^"Information-object_creation-or-update not just using the
result of a selection-or-intersection-or-substraction"
\. Representing Teaching
(Analysing \. (Predicting succ: (Assessing succ: Correcting))
(Monitoring succ: (Diagnosis succ: Repairing))
Assessing Diagnosis ) )
} )
(
Information-object_transformation_or_initialization
\. p{ (Information-object_update_without_object-intrinsic-modification
/^ Updating_without_object-intrinsic-modification )
(Information-object_update_via_object-intrinsic-modification
/^ Updating_via_object-intrinsic-modification )
}
p{ (Information-object_transformation
\. Translating Exporting Repairing Reconstructing )
(Information-object_initialization \. Assigning Writing)
} )
(
Information-object_creation_via_an_association
\. Comparing
(Valuating = Evaluating,
\. e{ Validating
(Valuating_satisfaction .[?agent, ?object, ?util] ?v
:= [?v agent: ?agent,
object: a Thing ?object, //cardinal/ordinal utility
result: (a Like-or-dislike-or-preference_description
part: [?object attr: an Utility ?util]) ],
derived_relation-type: (valuation .(?object, ?util)
\. valuation_by .(?agent, ?object, ?util) )
) ) )
(
Information-object_update_via_an_association
\. Indexing Annotating Classifying Aligning )
}
Inferencing )
Information-object_deletion
}.
3. Description Content/Instruments/Results/Containers
(Additional Types for Creating, Storing or Accessing
Representations of Entities/Situations)
A "description content" represents (the meaning of) a real/imaginary thing.
This representation uses "description instruments" and is stored inside at least one
"description container". More details on description objects and their relationships are given.
/*
any Thing //(referent,object), e.g. Tom, [Tom place: a mat], (*&Tom = ^(Thing repr: &Tom))
description_semantic-content: //this type must be interpreted in a special way!
0..* (Description_semantic-content //(internal repr/thought) e.g. &Tom, &[Tom place: a mat]
semantic_abstract_description_result:
1..* (Semantic_abstract_description_result //(symbol/id) e.g. &&Tom, &&[Tom place: a mat]
semantic_concrete_description_instrument:
1..* (Semantic_concrete_description_instrument: //e.g. "[Tom place: a mat]"
description_container:
1..* (Description_container //e.g. &0xFA01, RAM, File
physical_support: 1..* Physical_entity ) ) ) ).
any Situation
description_semantic-content:
0..* (Proposition
logic-independent_semantic_description_result:
1..* (sub#Statement_of_a_proposition = sub#Logical_statement,
logic-dependent_description_instrument:
1..* (sub#Logical_statement
concrete_description_instrument: 1..* String ) ) ).
Example:
^"content-representation of John's car" descr_instrument: 1..*
(^"abstract elements representing John's car" descr_instrument: 1..*
(^"concrete elements used for representing the abstract elements representing John's car"
descr_container: 1..* ^"description container that includes concrete elements used for
representing the abstract elements representing John's car" ) ).
*/
At its heart, the initial creation of information is based on description processes.
Here is a representation of such processes.
any Description_process
input: 0..* Thing, //e.g. a Situation or a Cat, as it is perceived by someone
output: 0..* Abstract_description_instrument //e.g. a Statement, a Function
0..* Concrete_description_instrument, //e.g. a String, a Graphic
(a Description_content ?dc
descr_instrument: {1..* Description_instrument ?di} ?dis,
descr_container: {1..* Description_container ?dctn} ?dctns ),
instrument: /* 0..* Description_instrument */ ?dis, //e.g. terms and a Language
agent: 1..* Agent ?writer,
recipient: ({1..* Agent} ?readers attr: (a Satisfaction_of_agents ^\++ ??) ),
attribute: a Cooperativeness-average_of_a_process_wrt_its_instruments.
/*
Description_content-or-instrument-or-result-or-container = Description_object //depth 5
Description_container //E.g. File, Software, Web_server, KB_server
Description_semantic-content //E.g. Proposition_content //depth 6
Description_instrument-or-result = Information-object //e.g. Proposition
p{ Fully-informal_information-object Not-fully-informal_information-object }
p{ Abstract_description_instrument-or-result
Abstract_description_instrument-or-result_wrt_the_described_thing
Situation_abstract_description_instrument-or-result //E.g. Principle_of_Coriolis_acceleration
Process_abstract_description_instrument-or-result
Control-structure_based_description_instrument-or-result //E.g. While_loop, Procedure
Declarative_based_abstract_description_instrument-or-result //E.g. Petri-Net
Search_algorithm
Graph-traversal_and_path-search_algorithm //E.g. the A* algorithm
State_abstract_description_instrument-or-result //E.g. Object_oriented_class, Array
Entity_abstract_description_instrument-or-result //E.g. Path_description, Integer
Abstract_description_instrument-or-result_wrt_the_used_method_or_instrument
Non-declarative_abstract_description_instrument-or-result
Declarative_abstract_description_instrument-or-result
Semantic_abstract_description_instrument-or-result
Semantic_description_instrument //E.g. Java_semantic, Logic_semantic, Type
Semantic_description_result //E.g. Semantic_of_a_KB, Semantic_of_a_program
Logic-independent_semantic_description_result //E.g. Logical_statement
Logic-dependent_description_instrument //E.g. Logical_sentence
Structural_abstract_description_instrument-or-result
Abstract_data_type //E.g. Object_oriented_class, Array, Integer
Structural_abstract_language-or-language_element //E.g. Java_abstract_grammar
Concrete_description_instrument-or-result
Concrete_description_instrument //E.g. Java_concrete_grammar, Character
Concrete_description_result //E.g. Java_concrete_function
Semantic_concrete_description_instrument
Structural_concrete_description_instrument
}
p{ Fully-declarative_information-object Non-fully-declarative_information-object }
p{ Expression //cannot have a truth value|status, e.g., Word, Quantifier, ...
Statement_or_proposition //has or can have a truth value|status //depth 7
Statement = Information //rt instance //e.g. Type_description/definition
Proposition = relation //can have -- but does not have -- truth value|status //depth 8
}
Semantic_information-object = Representation_object //but still viewable as !semantic
Non-semantic_description_instrument-or-result
Lexical_information-object //depth 8
Structural_information-object //depth 8
!ADT //Abstract_function, ...
Abstract_data_type //depth 10
*/
Description_content-or-instrument-or-result-or-container = Description_object,
derived_relation-type: (description_content-or-instrument-or-result-or-container = descr,
\. p{ description_semantic-content description_container
(description_instrument-or-result
\. p{ description_result description_instrument })
}),
\. p{ (
Description_semantic-content .[Thing ~% ?d] ?d
=
Thing_actually_described_by_a_description-instrument-or-result ,
:= ^"Thing that is actually represented, e.g.
1. when a particular cat or type of cats is referred to or defined by a person,
what is actually represented is not the real cat(s) but the person's mental object
for the cat(s),
2. when the representation is a statement or is defined, what is actually represented
may not be what the representation author really intended to represented",
attr: 0..* Description-semantic-content_attribute, //e.g. Consistency, Completeness wrt ...
\. (Description_of_relations_between_parts_of_an_entity
\. (Architecture \. Software_architecture)
(Design_pattern \. Software_architecture_design_pattern) ),
derived_relation-type: (description_semantic-content = descr_content),
description_instrument: 1..* Description_instrument
)
(
Description_instrument-or-result // =
Information_object
.[Description_semantic-content ~% ?d] ?d
=
Information_object,
:= ^"Thing useful for representing a Description_semantic-content,
e.g. Term, Statement, Language, Information_repository (Database, ...)",
derived_relation-type: description_instrument-or-result,
descr_instr of: 0..* Description_semantic-content,
attribute: 0..* Description-instrument_attribute, //e.g. High-levelness, Translatability,
object of: 0..* ^(Storage output: 1..* Description_container
physical_support: 1..* Physical_entity, //e.g. some Paper or a Disk
input of: 0..* Information-Technology_task ),
\. p{
Semantic_information-object = Representation_object //but still viewable as !semantic
(Non-semantic_description_instrument-or-result //added on 2023-02-28
\. p{
Lexical_information-object //depth 8
(
Structural_information-object
\. { Abstract_data_type Non-ADT_structural_information-object } ) //depth 10
} )
}
c{
Description_instrument
Description_result //= (Information \. v_p{ Knowledge Data }); see
Section 3.2
}
c{ (
Abstract_description_instrument-or-result = Abstract_information_object,
\~=
Abstract_information_object_wrt_the_described_thing //Section 3.2.3 )
(Concrete_description_instrument-or-result
\. c{ Concrete_description_instrument Concrete_description_result }
e{ Semantic_concrete_description_instrument
Structural_concrete_description_instrument } )
}
p{
Type Individual_information-object }
p{ (Expression = ^"group of words that is not a sentence, e.g. Token, Word, Term, Quantifier, ...",
\.
Type ) //see 0.2.1 (some general 2nd-order Types) and now hidden 3.2.4
(Sentence = Statement Statement_from_an_information_technology_viewpoint
Logic-or-not_statement, /*
Section 3.2.5 */
/^ Individual_information-object,
= ^"
group of words (e.g., Question, Command, Exclamation, Grammatical_statement ) that
is complete in itself and makes sense in at least one particular language or logic",
\. (Fully-or-not_declarative_sentence
= Statement_from_a_grammatical_or_philosophical_viewpoint,
/^ Fully-or-not_declarative_information-object,
= ^"grammatically declarative sentence that must be either true or untrue (thus,
it cannot be a question), although the truth or falsehood of the provided
statement may be unknown",
\. p{ (Proposition = Logic_statement relation, //can have truth value|status
= ^"declarative logic statement (hence not restricted to a particular
language); may be asserted or denied",
\. Asserted_proposition ) ) )
}
p{ Fully_non-declarative_information-object
(Fully-or-not_declarative_information-object \. Proposition)
}
p{ Not-fully-declarative_information_object //subtypes in 3.2.2.1
(Fully-declarative_information-object \. e{ Value Fully-declarative_statement }
\. p{ (Semantic_description_instrument-or-result
\. c{ Semantic_description_instrument //E.g. Java_semantic, Logic_semantic, Type
Semantic_description_result //E.g. Semantic_of_a_KB, Semantic_of_a_program
}
p{ (Logic-independent_semantic_description_result \. Logic_statement)
(Logic-dependent_description_instrument \. Logic_sentence)
}
)
(Structural_abstract_description_instrument-or-result //E.g. Java_abstract_grammar
\. Grammar Abstract-data-type )
})
}
p{ Formal_information-object Informal-or-semi-formal_information-object }
p{ Informal_information-object
(Formal-or-semi-formal_information-object
\. p{ (Formal_information-object
:= ^"information object which, given its syntax or embedding module (e.g. document
or statement), can automatically be recognised as refering to only 1 meaning")
(Semi-formal_information-object
\. p{ (Semi-formal_statement /^ Statement, //see below
:= ^"Statement which is a well-formed knowledge representation but
contains some informal terms" )
(Semi-formal_information-object_that_is_not_a_statement)
} )
} )
}
p{ (Information_object_not_composed_of_other_information_objects \. Token)
Information_object_composed_of_other_information_objects /*
Section 3.2.6
categorizes its subtypes according to the structuration by semantic relations:
- none: Unstructured_informal_document
- few predefined one: Structured_document, Database, Object-oriented_program
- defined by end-users: KB (fully formal or not) */
}
)
(
Description_container
.[Description_content-or-instrument-or-result-or-container ~% ?c] ?c
:= ^"Thing containing instances of Language_element (e.g. a File containing a Database)
and/or tool enabling the access to these instances (e.g. a Database server)",
derived_relation-type: (description_container = descr_container) )
}.
3.1. Description Semantic Content
This section is empty on purpose: its objects are always referred-to/accessed-from
Description_instrument-or-result objects,
using inverses of descr_instrument relations (or, more precisely inverse of
semantic_abstract_description_result relations) or,
equivalently, via the '*' shortcut.
3.2. Description Instruments/Results (Information Objects)
Description_instrument-or-result (Information_object) is declared a bit above,
at the beginning of Section 3.
3.2.1. Description Results
Description_result .[1..* Thing ?described_thing ~% ?dr] ?dr
= Information,
derived_relation-type: (description_result = descr_result),
\. v_p{ (Represented_data = Data)
(
Represented_Knowledge =
Knowledge_representation KR) //
Section 3.2.5.3
}
c{ (Abstract_description_result /^ Abstract_information_object,
\. e{ Semantic_abstract_description_result Structural_abstract_description_result } )
(Concrete_description_result /^ Concrete_description_instrument-or-result,
\. e{ Semantic_concrete_description_result Structural_concrete_description_result } )
},
e{ (Semantic_description_result /^ Semantic_information-object,
\. c{ Semantic_abstract_description_result Semantic_concrete_description_result }
ne{ (Like-or-dislike-or-preference_description
.[0..* Attribute_type ?attrRT] //if used, this parameter should be specified first
.[0..* Agent ?a ~% ?d] ?d
= ^"Description that relates 1..* agent ?a to the cardinal/ordinal utilities of
what each ?a likes or dislikes",
.{1..* Atomic_like-or-dislike-or-preference_description}, //via a Function/Array/formula/...
\. p{ (Atomic_like-or-dislike-or-preference_description .[0..* Attribute_type ?attrRT]
//preferences of a same agent should be consistent (default protocol)
// (+maybe: the normalized sum of an agent's contradictory preferences values
// should be the same for all agents)
attr_type:=> ?attrRT, //if given
\. (Atomic_preference_description .[Agent ?a1, a Thing ?o1, a Thing ?o2,
0..* Attribute_type ?attrRT]
= (&[ [?o1 < _(?attrRT): ?o2] believer: ?a1]
result of: (a Valuating_satisfaction agent: ?a1, object: ?o1 ?o2) ) )
(Atomic_valuation_description_wrt_attr .[Agent ?a1, a Thing ?o1, a Utility ?u]
= (&[ [?o1 value: ?u] believer: ?a1] //Utility_function
result of: (a Valuating_satisfaction agent: ?a1, object: ?o1) ),
\. e{ (Atomic_negative_valuation_description_wrt_attr := [?u < 0])
(Atomic_positive_valuation_description_wrt_attr := [?u > 0])
} )
(Atomic_like-or-dislike_description .[Agent ?a1, a Thing ?o1]
= &[ [ [a Liking agent: ?a1, object: ?o1] value: a Logical-or-modal_value ?v
] believer: ?a1 ],
\. e{ (Atomic_description_of_a_disliking := [?v < 0])
(Atomic_description_of_a_positive_liking := [?v > 0])
} )
e{ (Atomic_dislike_description
\. Atomic_negative_valuation_description_wrt_attr
Atomic_description_of_a_disliking )
(Atomic_positive-liking_description
\. Atomic_positive_valuation_description_wrt_attr
Atomic_description_of_a_positive_liking )
} )
(Composite_like-or-dislike-or-preference_description
.[0..* Attribute_type ?attrRT] .[0..* Agent ?a ~% ?d]
= .{2..* Atomic_like-or-dislike-or-preference_description _(?attrRT) _(?a) } )
}
p{ Like-or-dislike_description_without_preference_implication
(Preference_description
=
Preference-relationship_description,
result of: a (
Preference_situation .[?agent, {1..* ?other_thing},
?preferred_thing] ?p
:= [?p agent: ?agent, input: {1..* Thing ?other_thing},
input: a Thing ?preferred_thing, output: ?preferred_thing ],
derived_relation-type:
(preferred_thing .({1..* ?other_thing}, ?preferred_thing)
\. preference_by .(?agent, {1..* ?other_thing}, ?preferred_thing)
) ),
part: 0..*
Ordinal_utility,
\. e{ Preference_
weak-total-ordering
Preference_
semiordering
} )
}
(Non-restrictive_preference_description //to do: refine @@
) )
} )
(Structural_description_result /^ Structural_information-object,
\. c{ Structural_abstract_description_result Structural_concrete_description_result } )
}
ne{ Document_element
}.
3.2.2. Description Instruments
Description_instrument
derived_relation-type: (description_instrument = descr_instr),
\. //each Abstract_description_instrument may have may concrete (re)presentations
c{ (Abstract_description_instrument /^ Abstract_information_object,
\. e{Semantic_abstract_description_instrument Structural_abstract_description_instrument }
Abstract_language-or-language-element )
(Concrete_description_instrument /^ Concrete_description_instrument-or-result,
\. e{Semantic_concrete_description_instrument Structural_concrete_description_instrument }
Concrete_language-or-language-element )
},
e{ (Semantic_description_instrument /^ Semantic_information-object,
\. c{ Semantic_abstract_description_instrument Semantic_concrete_description_instrument })
(Structural_description_instrument /^ Structural_information-object,
\. c{Structural_abstract_description_instrument Structural_concrete_description_instrument})
},
(
Language_or_language-element
\. c{ (Abstract_language-or-language-element
\. c{ Abstract_language-model Abstract_language-element } )
(Concrete_language-or-language-element
\. c{ Concrete_language-model Concrete_language-element } )
}
c{ (Language
part:= 1 Language_model 1 Language_notation 1..* Language_element,
descr_instrument: 1..* Language,
\. p{ (Language_abstract-model = Language_model,
r_member:= only ^(Language_element
descr_instr of: 1..* Abstract_language-element) )
(Language_concrete-model = Language_notation,
r_member:= only ^(Language_element
descr_instr of: 1..* Concrete_language-element) )
}
p{ (Formal_language /^ Formal_information-object,
part:=> only a Formal_information-object)
(Informal-or-semi-formal_language /^ Informal-or-semi-formal_information-object,
\. p{ (Semi-Formal_language part:= a Formal_grammar)
Informal_language } )
}
p{ Programming_language //see below: Section 3.2.2.1
Non-programming_language
}
p{ //some languages permit the use of "instructions" and "assertions"
(Fully-or-not_non-declarative_language /^ Fully-or-not_declarative_information-object,
\. Fully_non-declarative_language )
(Fully-declarative_language /^ Fully-declarative_information-object,
r_member:= only Fully-declarative_information_object,
\. (Fully-declarative_logic-based_language
r_member:= only Logic-based_information_object,
\. (KRL = Knowledge_representation_language,
\. Non-exclusive_set
{ (KRL_model /^ Language_model)
(KRL_notation /^ Language_notation) },
r_KRL of: 1..* Language_element ) )
(Grammar r_member: 1..* Grammar_element,
\. p{ (Formal_grammar /^ Formal_language)
(Informal-or-semi-formal_grammar
/^ Informal-or-semi-formal_language)
}
ne{ (Abstract_grammar /^ Language_model)
(Concrete_grammar /^ Language_notation)
} ) )
}
p{ (Fully_non-declarative_language /^ Fully-non-declarative_information-object,
r_member: only Not-fully-declarative_information_object),
(Fully-or-not_declarative_language \. Logic-based_language )
}
)
(Language_element
\. c{ Abstract_language-element
(Concrete_language-element
\. p{ (Non-symbolic_concrete_language-element
\. (Image_element \. Image) Audio_element )
(Symbolic_concrete_language-element
\. (String_element \. String) (Graphic_element \. Graphic) )
} )
} )
}).
3.2.2.1. Programming Languages
Programming_language /^ Formal_language,
descr_instrument of: 1..* Program,
:= ^"formal language that (solely/also) has 'instructions',
and hence permits the description of programs",
\. /* the categories in italic bold below are derived from
https://en.wikipedia.org/wiki/Programming_paradigm */
Non-exclusive_set //since some languages permit the use of "instructions" and "assertions"
{ (
Fully-or-not_non-declarative_programming_language
/^ Fully-or-not_non-declarative_language,
:= ^"language with which the programmer merely declares properties of the desired result,
but not how to compute it",
\. (Fully_non-declarative_programming_language /^ Fully_non-declarative_language,
\. Procedural_language ) )
(
Fully-or-not_declarative_programming_language /^ Fully-or-not_declarative_language,
:= ^"language with which the programmer can declare properties of the desired result,
rather than giving instructions of how to compute this result",
\. (Fully-declarative_programming_language /^ Fully-declarative_language,
\. Purely-functional_programming_language Purely-logic_programming_language )
(Logic-based_declarative_programming_language
r_member:= only Logic-based_information_object ) //to do: declare!
(Mathematical_programming_language
:= ^"language with which the desired result can be declared as the solution of
an optimization problem" )
)
}
(Functional-or-procedural_like_programming_language
descr_instrument of: 1..* Function_or_procedure,
\. (
Functional_programming_language
:= ^"language with which the desired result can be declared as the value of a series of
function applications",
\. Purely-functional_programming_language )
(
Imperative_language
descr_instrument of: 1..* Non-declarative_information_object,
\. (
Procedural_programming_language
:= ^"language with which instructions can be grouped into procedures" )
(
Object-oriented_language
:= ^"language with which instructions can be grouped according to the
state they operate on" )
) ).
/*to do: categorize instruction/phrase kinds based on
https://en.wikipedia.org/wiki/Programming_paradigm
and, from these kinds, let language kinds be derived */
Expression_in_a_program /^ Expresssion,
\. p{ (Fully-declarative_expression \. IF_THEN_ELSE_expression Pure_function)
(Not-fully-declarative_expression =
Not-fully-declarative_information_object,
\. p{ (Not-fully-declarative_expression_that_can_be_converted_into_a_declarative_one
\. LOOP_expression
Global-variable_set_expression_that_can_be_converted_into_a_declarative_one )
(Not-fully-declarative_expression_that_cannot_be_converted_into_a_declarative_one
\. Global-variable_set_expression_that_cannot_be_converted_into_a_declarative_one )
} )
}
(Control-flow_expression
\. IF_THEN_ELSE_expression LOOP_expression BREAK_expression RETURN_expression )
(Set_expression
\. p{ Local-variable_set_expression
(Global-variable_set_expression
\. p{ (Global-variable_set_expression_that_can_be_converted_into_a_declarative_one
\. "Global-variable_set_expression_that_can_be_converted_into
_a_declarative_one_via_a_monome" )
Global-variable_set_expression_that_cannot_be_converted_into_a_declarative_one
} )
} )
(Function_or_procedure_or_method
\. Pure_function
(Procedure_or_method
\. p{ (Procedure-or-method_that_can_be_converted_into_a_declarative_one
\. "Procedure or method where only the 1st parameter (the class instance
in case of a class method) is modifiable and this parameter is the
environment or has access to it" )
(Procedure-or-method_that_cannot_be_converted_into_a_declarative_one)
}
) ).
Abstract_information_object_wrt_the_described_thing
\. p{ Statement_wrt_the_described_thing //Section 3.2.5.1
Non-statement_information_object_wrt_the_described_thing
}
p{ (Situation_abstract_description_instrument-or-result//E.g. Principle_of_Coriolis_acceleration
descr of: Situation, //precicely, automatically: abstract_description_instrument-or-result
\. p{ (Process_abstract_description_instrument-or-result //E.g. While_loop, Petri-Net
descr of: Process,
\. (Control-structure_based_description_instrument-or-result
\. e{ (Procedure \. Declarative-or-not_function Object_oriented_method)
(Control-structure \. While_loop If_statement)
}
p{(Declarative_control-structure_based_description_instrument-or-result
\. Petri-Net_structure_element )
(Non-declarative_control-structure_based_description_instrument-or-result
\. Global_variable_assignment )
})
(Search_algorithm
\. Graph-traversal_and_path-search_algorithm ) ) //E.g. the A* algorithm
(State_abstract_description_instrument-or-result descr of: State,
\. Non-atomic_abstract-data-type ) //E.g. Object_oriented_class, Array
} )
(Entity_abstract_description_instrument-or-result descr of: Entity,
\. p{ (Spatial_entity_abstract_description_instrument-or-result //E.g. Path_description
descr of: Spatial_entity )
(Non-spatial_entity_description_instrument-or-result descr of: Non-spatial_entity,
\. p{ (Attribute_abstract_description_instrument-or-result //E.g. Integer
descr of: an Attribute )
(Non-attribute-non-spatial-entity_abstract_description_instrument-or-result
descr of: a Non-spatial_entity_that_is_not_an_attribute )
} )
} )
}.
3.2.5. Statements
Statement
= Reference-to-statement_or_non-reference_statement
sub#Statement sub#abstract-structure_statement AS_Phrase
sub#Statement_content_from_a_logic_or_abstract-structure_viewpoint,
:= "Statement (syntactic/structural abstract statement) or reference to it",
//type: Zero-ary-relation_type,//at least for some people (see Section 2.1)
\=
Statement_wrt_the_described_thing Statement_wrt_role //below
Statement_wrt_thruth_or_logic_or_composition //below
Statement_wrt_assertion Statement_wrt_contradiction_or_support, //below
\. p{ (
Non-reference_statement
= NR_statement, //see the subtypes in Section 3.2.5.3
\.
NR_statement_that_can_be_represented_by_an_open-or-closed_logical_formula )
Reference_to_a_statement
}.
3.2.5.1. Statements Wrt. the Described Thing(s)
Statement_wrt_the_described_thing
desc of: a Situation, //State or (Process outcome: a State, result: an Entity,
// pred of: 0..* Process, pred: 0..* Process )
\. p{Statement_describing_an_entity
(Statement_describing_a_situation
\. p{ Statement_describing_a_state
(Statement_describing_a_process //ref (e.g.Fct_call) or not (e.g.Fct_def)
\. (Statement_describing_a_process_on_a_description_object
= Statement_describing_an_information_management_process,
\. p{ (Fully-declarative_statement_describing_an_information_management_process
/^ Fully-declarative_statement )
(Not-fully_declarative_statement
= ^"Executable Statement with side effects" )
}
Statement_describing_an_information_management_process ) )
} )
}.
3.2.5.2. Statements Wrt. Roles (e.g. ODPs, ODRs, Constraints)
Statement_wrt_role
\~ p{ Statement_usable_for_proof //also below
Statement_not_usable_for_proof
}
(Method_description = ^(Statement method_descr of: a Process)
\. (Design_pattern := "how something can be designed",
\. (Ontology-design_pattern = ODP,
:= "description of a method to represent something
while satisfying particular conditions/criteria",
\. (Meta-ODR |. ODR)
(Ontology-design_best-practice
:= "one of the best ODPs to achieve particular good criteria" ) ) ) )
(Design_pattern-or-rule
\. p{ Design_pattern //just above
(Design_rule /^ Checking_constraint,
:= "how something should be designed to achieve particular criteria",
\. Software_design_rule
(Ontology_design_rule = ODR)
p{ (Gradual_design-rule := "the more ... the better",
\. p{ (Ratio-based_gradual_design-rule
\. (Ratio-based_gradual_ODR = ODR-G-R, /^ ODR) )
(Non-ratio-based_gradual_design-rule
\. (Non-ratio-based_gradual_ODR = ODR-G-NR, /^ ODR) )
} )
(Non-gradual_design_rule = Boolean_design_rule,
\. (Non-gradual_ODR = ODR-NG, /^ ODR) )
} )
}
p{ (Checkable_design-pattern-or-rule
\. p{ (Checkable_design-pattern \. (Checkable_ODP /^ ODP))
(Checkable_design-rule
\. (Checkable_ODR /^ ODR,
\. (CODR-G-R /^ ODR-G-R) (CODR-G-NR /^ ODR-G-NR)
(CODR-NG /^ ODR-NG) ) )
} )
(Non-automatically-checkable_design-pattern-or-rule
\. p{ (Non-automatically-checkable_design-pattern
\. (Non-automatically-checkable_ODP /^ ODP) )
(Non-automatically-checkable_design-rule
\. (Non-automatically-checkable_ODR /^ ODR,
\. (NCODR-G-R /^ ODR-G-R) (NCODR-G-NR /^ ODR-G-NR)
(NCODR-NG /^ ODR-NG,
\. (Meta-ODR instance:=> an ODR) ) ) )
} )
} ).
3.2.5.3. Statements Wrt. Statements Wrt. Thruth, Logic Or Composition
Statement_wrt_thruth_or_logic_or_composition
\. (sub#NR_statement_that_can_be_represented_by_an_open-or-closed_logical_formula
\. (sub#NR_statement_that_can_be_represented_via_a_closed_logical-formula
= sub#Logical_NR-statement sub#Logical_content_of_a_logical_NR_statement
sub#NR_statement_of_a_proposition
sub#NR_statement_describing_a_situation sub#Statement,
\= (
rdf#Statement
\. (
owl#NegativePropertyAssertion ?ns
:= [?ns <==> [ [a rdf#statement ?s] [?ns <==> ! ?s] ]]) ) ) )
p{ Statement_that_is_true Statement_that_is_false
(Statement_that_is_neither_true_nor_false = ^(Statement attr:= NTNF),
\. Statement_that_is_undecidable )
}
p{ (Informal_statement /^ Informal_information-object) (Formal_statement \. Formal_KR) }
p{ Non-fully-declarative_statement /^ Not-fully-declarative_information_object,
(Fully-declarative_statement
\. p{ Logic_statement //subtype of Logic-independent_semantic_description_result
Logic_sentence //"sentence" in the sense used in logics
}
(
KR, //
declared in Section 3.2.1
part: 1..* Information_object, //any KR has for part at least 1 Object
\. p{ Formal_KR Semi-formal_KR } ) )
}
p{ (Statement_without_embedding_statement =
Command)
(
Statement_with_embedding_statement
= ^(Statement ?s1 part of: (a Statement ?s2!= ?s1)),
\. p{ (Statement_with_opaque_embedding_statement
=
Statement_with_contextualizing_statement,
= ^(Statement ?s1
statement-contextualizing_statement: (a Statement ?s2 != ?s1)))
(Statement_with_transparent_embedding_statement =Statement_with_white_meta-statement,
\. (Implication_conclusion_with_unasserted_premisse
= ^(Implication_conclusion type: no Asserted_deduction) )
(Unasserted_implication-premise
= ^(Implication_premise type: no Asserted_statement) )
Denotation-level_change_source Denotation-level_change_destination )
} )
}
p{ Statement_without_embedded_statement
(Statement_with_embedded_statement = Meta-statement,
= ^(Statement ?s1 part: (a Statement ?s2!= ?s1)) )
}
(
Logically-atomic_statement ?laS = Minimally-logically-complete_statement,
:= "for any relation ?r part of a Logically-atomic_statement ?laS, ?laS minus ?r is false
(i.e. the AND-set of the other relations part of ?laS is false)"
[ [^r type: relation, part of: ?laS]
=> ! AND{ any ^(relation part of: ?laS, != ^r) } ]
)
(Rule_or_logical-implication = Statement_directy_suporting_logical_inferences,
\. p{ (Logical_implication ?p = Statement_supporting_modus-ponens_and_modus-tollens,
:= ^"Statement translatable to the form [X => Y]"
[?p <=> [a Statement ?p1 => a Statement ?p2]] )
(Rule = Unidirectional_rule Statement_supporting_modus-ponens_but_not_modus-tollens,
:= ^"Statement translatable to the form [X =>> Y]"
[?p <=> [a Statement ?p1 =>> a Statement ?p2]],
\. c{ Rule_without_modal-statement_as_conclusion
(Rule_with_modal-statement_as_conclusion
\. (Rule_with_conclusion-using-should-or-must
\. (
Rule-based-checking_constraint ?c
// /^ Checking_constraint, //
Section 1.2.4
:= ^"Rule_with_conclusion-using-must where the 'must' means that
the constraint should be used for checking statements,
not deriving statements"
^"Rule_with_conclusion-using-must equivalent to a
Rule_without_modal-statement_as_conclusion with False as
conclusion",
:= [?c <=> [a Statement ?p1 =>> False]],
\. v_p{ (Negative_rule-based-constraint
:= ^"Constraint that has False as conclusion or which
uses 'must not' in its conclusion",
\. (Constraint_in_inconsistency-implying_form
:= ^"Constraint that has False as conclusion"
[?c <=> [a Statement ?p1 =>> False]] ) )
Positive_rule-based-constraint
}
p{ (
Rule-based-constraint_not_using_all_possible_inferences
\. (Rule-based-constraint_for_manual_entering
= Prescriptive_constraint ) )
Descriptive_constraint
}) ) )
})
}).
3.2.5.4. Statements Wrt. Assertion
Statement_wrt_assertion
\. p{ (Statement_assertion_equivalent_to_the_asserted_statement = Asserted_statement,
/^ Fully-declarative_statement
(Statement_assertion r_operator:= an Assertion_operator, r_arg: 1 Statement),
= ^(Statement_assertion ?pa r_arg: (1 asserted_statement <=> ?pa)) )
(^"Statement_which_when-interpreted_leads_to an_information-object removal or
modification that is not simply an addition"
/^ Statement_describing_a_process_on_a_description_object,
\. Statement_modification Statement_removal )
}
p{ //this partition is detailed in
Section 3.2.2.1
(Statement_that_could_not_be_asserted,
\. (Program r_member:= 1..* Not-fully-declarative_expression )
Not-fully_declarative_command
)
(Statement_that_can_be_asserted = Fully-declarative_statement,
\~ ne{ (Like-or-dislike-or-preference_description
\. Like-or-dislike-or-preference_description_about_oneself ) //ex Own_preference
(Observation_description = ^(Statement descr_instrument of: an Observation)
\. Own_observation)
Belief
Axiom_or_definition Inference_rule
},
\. e{ (Statement_with_only_a_preference_or-observation_based_argument
\. p{ (Statement_with_only_a_preference-based_argument
= ^(Statement logic-argument: //recursive definition:
only 1..* OR{Like-or-dislike-or-preference_description, //recursion end
Statement_with_only_a_preference-based_argument //recurs.
} ) )
(Statement_with_only_an_observation-based_argument
= ^(Statement logic-argument:
only a OR{Observation_description, //recursion end
Statement_with_only_an_observation-based_argument //recursion
} ),
better-supported_than: any Statement_with_only_a_preference-based_argument )
} )
(Statement_with_an_axiom-or-definition-based_argument
= ^(Statement logic-argument:
1..* OR{ Axiom_or_definition, //recursion end
Statement_with_an_axiom-or-definition-based_argument
} ),
better-supported_than:
any Statement_with_only_a_preference_or-observation_based_argument )
}
},
\. p{ (Unasserted_statement = Statement_that_is_not_an_assertion,
\. p{ Statement_that_could_not_be_asserted
(Statement_that_could_be_asserted_but_is_not /^ Statement_that_could_be_asserted)
} )
(Asserted_statement
\. p{ (Asserted-statement_that_cannot_be_false
=
Statement_that_cannot_be_contradicted Statement_usable_for_a_proof,
\. Axiom Asserted_definition )
(Asserted-statement_that_can_be_false //false = incorrect
//below: Successfully-supported_statement = Validated_statement
// Successfully-contradicted_statement = Invalidated_statement"
\. p{(
Asserted-statement_that_can_be_false_but_not_successfully_contradicted
\. (Asserted-statement_about_one-s-own_preference
=
Asserted_like/dislike/preference_description_about_oneself,
= ^(Asserted_statement agent: an agent ?a,
description of: (a Preference owner: ?a) ) )
(Asserted-statement_about_one-s-own_observation =
Own_observation,
= ^(Asserted_statement agent: an agent ?a,
description of: (a Situation object of: (an Observation
agent: ?a) ) ) )
(
Successfully-supported_statement_that_can_be_false
/^ Successfully-supported_statement, //defined below
:=> "a successfully supported statement cannot be directly
successfully objected/corrected: its arguments must first be
successfully objected/corrected" )
Asserted_axiom
(
Asserted-statement_that_can_be_successfully_contradicted
=
Counter-arguable_statement,//counter-argued/corrected/contradicted
\. p{ (Counter-arguable_statement_not_derived_from_other_statements
:=>
"Asserted fact/belief that is not an axiom, nor an
assertion of own preference or observation, nor
derived from other statements;
here, 'belief' is to be interpreted as a situation
description with recorded authors/believers,
not as the description that they believe the
situation; for scalable knowledge sharing
purposes, when fact descriptions are represented
their believers/authors should be too, i.e. beliefs
should be represented instead of facts" )
(Asserted-statement_derived_from_other_statements
\. (Asserted_deduction
= ^(Asserted_statement ?a formal-or-informal_deduction of:
(an Asserted_statement != ?a) ) ) )
}
(
Belief \. Believed_fact Believed_physical_law) )
} )
} )
}.
3.2.5.4. Statements Wrt. Contradictions or Supports
Statement_wrt_contradiction_or_support
\. p{ (Statement_that_cannot_be_successfully_contradicted
= Not-successfully_contradictable_statement
Statement_that_cannot_have_a_contradiction_worth_to_exploit, //"successfully" implies that
\. p{ ^(Statement type: Statement_that_is_not_an_assertion //see above
__[!type: Successfully-contradicted_statement] )
^(Statement type: Asserted-statement_that_cannot_be_false //see above
__[!type: Successfully-contradicted_statement] )
^(Statement
type: Asserted-statement_that_can_be_false_but_not_successfully_contradicted
__[!type: Successfully-contradicted_statement] )
} )
Asserted-statement_that_can_be_successfully_contradicted //see above
}
p{ (Uncontradicted_statement
\. p{ Statement_that_cannot_be_contradicted
(Statement_that_can_be_contradicted_but_is_not
/^ Asserted-statement_that_can_be_contradicted )
} )
(Contradicted_statement /^ Asserted-statement_that_can_be_contradicted,
= ^(Statement negation: a Supported_statement),
\. Logically-contradicted_statement ) //below
}
p{ Unsupported_statement
(Supported_statement = ^(Statement argument: a Statement),
\. Logically-supported_statement ) //below
}
p{ (Unsupported_or_unsuccessfully-supported_statement
\. p{ Unsupported_statement Logically-but-unsuccessfully-supported_statement } )
Successfully-supported_statement
}
p{ (Uncontradicted-or-unsuccessfully-contradicted_statement
\. p{ Uncontradicted_statement Logically-but-unsuccessfully-contradicted_statement } )
Successfully-contradicted_statement
}.
3.2.5.4.1. Logically-contradicted Statements
Logically-contradicted_statement
= ^(Statement logic-objection_or_correction: a Statement), //Section 0.3.6
\. p{ (Logically-but-unsuccessfully-contradicted_statement
\. p{ (Logically-contradicted_statement_that_cannot_be_successfully_contradicted
/^ Statement_that_cannot_be_successfully_contradicted ) //see above
Unsuccessfully-contradicted_statement_that_can_be_successfully_contradicted
} )
(Successfully-contradicted_statement = Invalidated_statement,
= ^(Statement exclusion: a (Successfully-supported_statement = Validated_statement),
\. p{ (Successfully-contradicted_and_unsuccessfully-supported_statement
= ^(Successfully-contradicted_statement
type: Logically-but-unsuccessfully-supported_statement ) )
Successfully-contradicted_and_unsupported-or-unsuccessfully-supported_statement
} )
}
p{ (Corrected_statement = ^(Statement correcting_statement: a Statement),
\. p{ (Successfully-corrected_statement
= ^(Corrected_statement correcting_statement: an
Uncontradicted-or-unsuccessfully-contradicted_statement ) )
Unsuccessfully_corrected_statement
} )
Contradicted-but-uncorrected_statement
}.
3.2.5.4.2. Logically-supported Statements
Logically-supported_statement
= ^(Statement logic-argument: a Statement),
\.p{ Logically-but-unsuccessfully-supported_statement
(Successfully-supported_statement
/^ ^(Uncontradicted-or-unsuccessfully-contradicted_statement //below
logic-argument _[logic-objection: //(probably not: logic-objection_or_correction)
0 Uncontradicted-or-unsuccessfully-contradicted_statement]
: an Uncontradicted-or-unsuccessfully-contradicted_statement),//see below
:=> "Warning: this definition may lead non-monotonicity if inferencing can
generate arguments/objections"
"Warning: since this type is important (it permits the definition of
other important types) and has no direct full definition, it is crucial
for it to have a complete set of fully defined direct subtypes"
"a successfully contradicted statement cannot be directly
successfully supported: its objections/corrections must first be
successfully objected/corrected",
\.p{ //is this really a partition: is there really nothing else?
(Successfully-supported_observation
= ^(Successfully-supported_statement type: Observation_description,
description_container: a Document ),
:=> "Warning: this definition is application/community dependent
and, strictly speaking, '/^' should be used instead of ':='
in this definition but ':=' is needed for inferencing purposes;
here, the use of Document is meant to require each
observation to be in a recorded source in addition to
not be an Uncontradicted-or-unsuccessfully-contradicted_statement;
an authentified source may need to be required too" )
(Successfully-supported_deduction
= ^(Successfully-supported_statement type: Asserted_deduction) )
}
p{ (Successfully-supported_and_uncontradicted-or-unsuccessfully-contradicted_statement
/^ ^(Successfully-supported_statement
type: Uncontradicted-or-unsuccessfully-contradicted_statement ),
:=> "'/^' is used instead of ':=' because that definition
would be circular if the statement is not uncontradicted" )
Successfully-supported_and_successfully-contradicted_statement
} )
}.
Information_object_composed_of_other_information_objects
=
Composite_information_object Information-repository_representation_instrument,
part: 1..* Information_object,
\. p{ (Composite-information-object_not_structured_by_any_formal_semantic_relation
= Unstructured_informal_document,
attr: a 0-10pc_fit Description-instrument_completeness,
\_ (Composite-concrete-information-object_not_structured_by_any_formal_semantic_relation
\. p{ (Non-symbolic_composite-concrete-information-object
/^ Non-symbolic_concrete_language-element,
\. (Audio_composite-information-object
\. (Audio_file part: 0..* Audio_composite-information-object) )
(Image_composite-information-object
\. (Image_file part: 0..* Image_composite-information-object) ) )
("Symbolic_composite-concrete-information-object
not_structured_by_any_formal_semantic_relation"
/^ Symbolic_concrete_language-element Informal_information-object )
} ) )
(Composite-information-object_structured_by_at_least_some_formal_semantic_relations
\. p{ (Composite-information-object_structured_only_by_few_predefined_relations
attr: a 10-20pc_fit Description-instrument_completeness,
\.
Structured_document-element Database Object-oriented_program )
(Composite-information-object_structured_by_unpredefined_semantic_relations
=
Knowledge_base KB,
attr: a 20to100pc_fit Description-instrument_completeness,
part: Parts_partition
{ 0..1 (Onto-terminology
:= ^"KB part consisting in the list of its non-predefined terms and
the list of formal/informal complete/incomplete definitions
formally associated to the terms",
\. (Ontology := ^"Onto-terminology about formal terms") )
0..1 (Fact_base := ^"part of the KB that is not its onto-terminology",
\. Formal_fact_base )
},
\. p{ (Fully-formal_KB part: Parts_partition{ Ontology Formal_fact_base })
Not-fully-formal_KB
}
e{ (Ontology := ^"KB containing only relations between types")
(Fact_base := ^"KB containing only relations from individuals")
(Thesaurus := ^"KB with an onto-terminology that is not an ontology")
}
ne{ (
KB_about_an_agent .[Agent ?a, KB ?kb],
derived_relation-type: kb_about_this_agent .( ?a, KB ?kb),
description_instrument of: ?a,
part: 0..* (
Like-or-dislike-or-preference_description
:= ^"KRs for the preferences of an Agent"
^(Phrase description_instrument of:
1..* ^(Preference agent: ?a) ) )
0..* ^(
Belief believer: ?a) )
(
KB_of_an_agent
derived_relation-type:
(kb_of_this agent .(Agent ?a -% KB ?kb) = ^(KB ?kb owner: ?a)
) //inverse:_kb
\. (
Agent-s_kb = ^"Agent's KB", /^ KB_about_an_agent,
:= ^"set of rules, preferences and believed facts of an agent;,
set of statements (rules/preferences/facts) which the agent
has explicitly declared that he follows/prefers/believes and
hence that s/he can be judged by"
annotation: "statements declared under duress are not valid;
logically conflicting statements in an agent's kb do not count;
the 'rules of inference' of classical predicate logic (e.g., see
https://en.wikipedia.org/wiki/List_of_rules_of_inference) are
by default part of any agent's kb but may be removed or
complemented by this agent as long as this does not introduce
nor remove internal contradiction in the rest of the principles
nor means to detect any such internal contradiction" )
} )
} )
}.
3.3. Description Containers
Description-container_attribute
\. (
Description-container_quality := ^(Quality attribute of: a Description_container),
\. e{ (Description-container_quality_dependent_of_the_quality_evaluation_context
/^ Quality_dependent_of_the_quality_evaluation_context )
(Description-container_quality_independent_of_the_quality_evaluation_context
/^ Context-independent_quality,
\. p{ (Description-container_quality_directly_easing_the_access_of_an_expected_object
/^ Quality_directly_easing_the_access_of_an_expected_object )
("Context-independent_description-container_quality_not_directly_easing_the
access_of_an_expected_object"
/^ "Context-independent_quality_not_directly_easing_the
access_of_an_expected_object" )
} )
} ).
//satisfaction|confort, efficiency souplesse, easiness
Description-container_maintenability cf. process
Description_container
\. p{ Static_container Dynamic_container }.
Static_container = File Information-repository_container,
:= ^(Description_container
descr_content: an ^(Information-repository_content
:= ^(Description-content
descr_instrument: an
Information-repository_representation_instrument
) ) ),
\. p{ (Dynamic_file := ^"File at least partially generated by a software_tool
in answer to a query or command" )
(Static_File \. Program_file Data_file)
}
p{ (File_not_structured_by_any_semantic_relation
descr_container of: only 1..*
Composite-information-object_structured_only_by_few_predefined_relations )
(File_structured_by_some_semantic_relation
descr_container of: only 1..*
Composite-information-object_structured_by_unpredefined_semantic_relations )
}.
Dynamic_container = Software_tool Software_actor,
agent of: 0..1 (Software_process := ^(Process parameter: a Program_file)),
\. (Software_tool_for_vieving_an_information_repository
\. (Software_tool_for_accessing_parts_of_a_file_or_other_information_repositories
\. (Information_repository_viewer
\. Information_repository_editor )
(Information_repository_management_system
\. FileMS DBMS KBMS ) // Language-element(Text/image/Graph/...)_viewer
) //very bad: image, no copy-paste
(Software_tool_of_a_client-server_architecture
\. (Server_software-tool \. Web_server Mail_server)
(Client_software-tool \. Web_client Mail_client)
).
(Description-container_management_system = Language-element_management_system
Information-object_management_system Document-element_management_system,
\. Static-file_management_system Set-of-static-files_management_system
Mail_server_parameter_file \. replcomps components .netrc .forward //+vacation ...
//the next type and its subtypes are here for convenience purposes even though,
// as shown in
Section 0.3 [1.2.1], they are subtypes of Description_content
Software_architecture
\. (Distributed_software_architecture
\. (Client_server_architecture
//no: part: 1..* Server_software-tool 1..* Client_software-tool,
\. (Multi-tier_architecture = N-tier_architecture,
\. e{ (Two-tier_architecture
\. Model_architecture View_architecture Presenter_architecture
View-Model_architecture )
(Three-tier_architecture
\. (Model-View-Controller_architecture /*
//design_pattern: a MVC_design_pattern */)
Presentation-Abstraction-Control_architecture
(Genuine_three-tier_architecture
annotation: "communications should not occur directly between
the 'Presentation tier' (e.g., 'Client'; 'View' in the MVC
terminology) and the 'Data tier' (e.g., DBMS of a 'Server';
'Model' in MVC) but should go via the 'Application tier'
(of the Server; 'Controller' in the MVC terminology)" ) )
} ) )
). //webkb.org/kb/it/o_software/d_archi.html#IS_architecture