Merge pull request #133 from vincentvialard/fix-typos-in-model-description-and-in-specifications

fix typos in model description and specification

Author: hsolbrig

linkml_model/model/schema/meta.yaml

@@ -474,7 +474,7 @@ slots:
     domain: definition
     range: boolean
     description: >-
-      Indicates the class or slot is not intended to inherited from without being an is_a parent. mixins should not be inherited from using is_a, except by other mixins.
+      Indicates the class or slot is intended to be inherited from without being an is_a parent. mixins should not be inherited from using is_a, except by other mixins.
     see_also:
       - https://en.wikipedia.org/wiki/Mixin
     in_subset:
@@ -1736,7 +1736,7 @@ slots:
 
   locally_reflexive:
     is_a: relational_logical_characteristic
-    description: If s is locally_reflexive, then i.s=i for all instances i where s if a class slot for the type of i
+    description: If s is locally_reflexive, then i.s=i for all instances i where s is a class slot for the type of i
     in_subset:
       - SpecificationSubset
 

specification/03schemas.md

@@ -51,7 +51,7 @@ However, it should be understood these are not equivalents.
      - [enumerated types](https://en.wikipedia.org/wiki/Enumerated_type) in programming languages and some relational systems
      - drop-down selections in spreadsheets       
      - Note however that in LinkML enums are optionally backed by stronger semantics with enum elements (permissible values) mapped to vocabularies or ontologies
- * EnumDefinitions are analogous to:
+ * TypeDefinitions are analogous to:
      - [data types](https://en.wikipedia.org/wiki/Data_type) in most object-oriented languages 
      - primitive types in database systems
      - extensible types in some systems
@@ -93,7 +93,6 @@ classDiagram
     SchemaDefinition "1" --> "*" ClassDefinition: classes
     SchemaDefinition "1" --> "*" SlotDefinition: slots
     SchemaDefinition "1" --> "*" EnumDefinition: enums
-    SchemaDefinition "1" --> "*" EnumDefinition: Enums
     SchemaDefinition "1" --> "*" SubsetDefinition: subsets
     SchemaDefinition "1" --> "*" Prefix: prefixes
     ClassDefinition --|> Element

specification/04derived-schemas.md

@@ -94,7 +94,7 @@ For all `x` in `ReflexiveAncestors(c)`
 
 ### Rule: Derived Attributes
 
-Derived attributes can be calculated for every *applicable* slot name for any class `c`
+Derived attributes can be calculated for every *applicable* slot name `s` for any class `c`
 
 `c.attributes[s] = DerivedAttributes(c,s)`
 
@@ -111,11 +111,7 @@ and ancestors of `c`
 
 The precedence rules for derived attributes are as follows:
 
-If a metaslot `s` is declared `multivalued` then when copying `s` from a parent to a child, the values are appended.
-
-If a metaslot `s` is declared `multivalued` 
-
-if a slot is multi valued then copying will append, unless the element already exists.
+If a metaslot `s` is declared `multivalued` then when copying `s` from a parent to a child, the values are appended, unless the element already exists.
 
 if the slot is single valued, and intersection rules can be applied to the slot, then these are performed on all values
 

specification/05validation.md

@@ -63,16 +63,16 @@ for each `slot=value` assignment in **Assignments**, the validation procedure is
 
 `C` SHOULD have all the following properties:
 
-- `C.deprecated` SHOULD be **None**
-- `C.abstract` SHOULD NOT be **True**
-- `C.mixin` SHOULD NOT be **True**
+- `C.deprecated` SHOULD be `None`
+- `C.abstract` SHOULD NOT be `True`
+- `C.mixin` SHOULD NOT be `True`
 
 ### Rule: identifiers must be unique
 
 We define a procedure **IdVal**(`i`) which yields the value of `i.<identifier_slot>` where `identifier_slot`
-is the slot n **Assignments** with metaslot assignment `identifier`=**True**
+is the slot in **Assignments** with metaslot assignment `identifier=True`
 
-If there is no such slot then `**IdVal**(`i`) is None and this check is ignored.
+If there is no such slot then **IdVal**(`i`) is `None` and this check is ignored.
 
 `i` is invalid if there exists another instance `j` such that `j` is reachable from `root`,
 and **IdVal**(`i`)=**IdVal**(`j`) and `i` and `j` are distinct.
@@ -97,27 +97,27 @@ If this condition is not met, this is considered a warning rather than invalidit
 
 For each slot `s` in **Assignments**,
 
- * if `s.multivalued` is True, then `i.<s>` must be a collection or None
- * If `s.multivalued` is False, then `i.<s>` must not be a collection
+ * if `s.multivalued` is `True`, then `i.<s>` must be a collection or `None`
+ * If `s.multivalued` is `False`, then `i.<s>` must not be a collection
 
 ### Rule: values should be within stated bounds
 
 For each slot `s` in **Assignments**,
 
- * if `s.maximum_value` is not None, then `i.<s>` must be a number and must be less that or equal to the maximum value
- * if `s.minimum_value` is not None, then `i.<s>` must be a number and must be greater that or equal to the minimum value
+ * if `s.maximum_value` is not `None`, then `i.<s>` must be a number and must be less that or equal to the maximum value
+ * if `s.minimum_value` is not `None`, then `i.<s>` must be a number and must be greater that or equal to the minimum value
 
 ### Rule: values should equal evaluable expression
 
-For each slot `s` in **Assignments**, if `s.equals_expression` is not None, then `i.<s>` must equal
+For each slot `s` in **Assignments**, if `s.equals_expression` is not `None`, then `i.<s>` must equal
 the value of `Eval(s.equals_expression)`. See section on expression language
 for details of syntax.
 
 Note: this rule can be executed in inference mode
 
 ### Rule: values should equal string_serialization
 
-For each slot `s` in **Assignments**, if `s.string_serialization` is not None, then `i.<s>` must equal
+For each slot `s` in **Assignments**, if `s.string_serialization` is not `None`, then `i.<s>` must equal
 the value of `Stringify(s.string_serialization)`. See section on expression language
 for details of syntax.
 
@@ -127,15 +127,15 @@ Note: this rule can be executed in inference mode
 
 ### Range class instantiation check
 
-For each slot `s` in **Assignments**, if `i.<s>` is not None, and `s.range` is in `m*.classes`,
+For each slot `s` in **Assignments**, if `i.<s>` is not `None`, and `s.range` is in `m*.classes`,
 then `s.range` must be in `ReflexiveAncestors(Type(i.<s>))`
 
- Additional checks MAY be performed based on whether `s.inlined` is True
+ Additional checks MAY be performed based on whether `s.inlined` is `True`
 
- * if `s.inlined`, then `i.<s>`  SHOULD NOT be a Reference
- * if `s.inlined` is False, then EITHER:
+ * if `s.inlined` is `True`, then `i.<s>`  SHOULD NOT be a Reference
+ * if `s.inlined` is `False`, then EITHER:
      * `i.<s>`  SHOULD be a Reference
-     * OR `i.<s>` instantiates a class `R` such that R has no slot `rs` that is declared to be an identifier. i.e. `rs.identifier = True`
+     * OR `i.<s>` instantiates a class `R` such that `R` has no slot `rs` that is declared to be an identifier. i.e. `rs.identifier = True`
 
 
 
@@ -166,14 +166,14 @@ In all cases, the semantics are as follows:
 
 ### range expression checks
 
-For each slot `s` in **Assignments**, if `i.<s>` is not None, and `RE = s.range_expression` is not None, then a check
+For each slot `s` in **Assignments**, if `i.<s>` is not `None`, and `RE = s.range_expression` is not `None`, then a check
 **CE**(`x`) is performed on `i.<s>`
 
 ### Rule evaluation
 
 For each rule `r` in *C*.rules:
 
-- if `r.preconditions` is None or `r.preconditions` is satisfied, then
+- if `r.preconditions` is `None` or `r.preconditions` is satisfied, then
 - `r.postconditions` are applied
 
 ### Classification Rule evaluation
@@ -182,19 +182,19 @@ For each rule `r` in *C*.rules:
 
 ## Validation of TypeDefinitions
 
-For each slot `s` in **Assignments**, if `i.<s>` is not None, and `s.range` is in `m*.types`,
+For each slot `s` in **Assignments**, if `i.<s>` is not `None`, and `s.range` is in `m*.types`,
 where `i.<s> = *T*( **AtomicValue** )` must match `s.range`,
 
 here `T.uri` is used to determine the type:
 
 - for xsd floats, doubles, and decimals, AtomicValue must be a decimal- for xsd floats, doubles, and decimals, AtomicValue must be a decimal
 - for xsd ints, AtomicValue must be an Integer
 - for xsd dates, datetimes, and times, AtomicValue must be a string conforming to the relevant ISO type
-- for xsd booleans, AtomicValue must be True or False
+- for xsd booleans, AtomicValue must be `True` or `False`
 
 ## Validation of EnumDefinitions
 
-For each slot `s` in **Assignments**, if `i.<s>` is not None, and `s.range` is in `m*.enums`,
+For each slot `s` in **Assignments**, if `i.<s>` is not `None`, and `s.range` is in `m*.enums`,
 then `i.<s>` must be equal to `pv.text` for some pv in `m*.enums[s.range]`
 
 ## Inference of new values