sysml-validate 0.11.0 → 0.14.2

package/resources/sysml.library/Kernel Libraries/Kernel Function Library/DataFunctions.kerml

@@ -1,43 +1,43 @@
-standard library package DataFunctions {
-	doc
-	/*
-	 * This package defines the abstract base functions corresponding to all the unary and binary operators 
-	 * in the KerML expression notation that might be defined on various kinds of DataValues.
-	 */
-
-	private import Base::DataValue;
-	private import ScalarValues::Boolean;
-	private import ControlFunctions::reduce;	
-	
-	abstract function '==' specializes BaseFunctions::'==' { in x: DataValue[0..1]; in y: DataValue[0..1]; 
-		return : Boolean[1];
-	}
-	function '===' specializes BaseFunctions::'==='{ in x: DataValue[0..1]; in y: DataValue[0..1]; 
-		return : Boolean[1] = x == y;
-	}
-	
-	abstract function '+' { in x: DataValue[1]; in y: DataValue[0..1]; return : DataValue[1]; }
-	abstract function '-' { in x: DataValue[1]; in y: DataValue[0..1]; return : DataValue[1]; }
-	abstract function '*' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
-	abstract function '/' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
-	abstract function '**' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
-	abstract function '^' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
-	abstract function '%' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
-	
-	abstract function 'not' { in x: DataValue[1]; return : DataValue[1]; }
-	abstract function 'xor' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
-
-	abstract function '~' { in x: DataValue[1]; return : DataValue[1]; }
-	abstract function '|' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
-	abstract function '&' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
-	
-	abstract function '<' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }
-	abstract function '>' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }
-	abstract function '<=' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }
-	abstract function '>=' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }
-	
-	abstract function max { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
-	abstract function min { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
-	
-	abstract function '..' { in lower: DataValue[1]; in upper: DataValue[1]; return : DataValue[0..*] ordered; }	
+standard library package DataFunctions {
+	doc
+	/*
+	 * This package defines the abstract base functions corresponding to all the unary and binary operators 
+	 * in the KerML expression notation that might be defined on various kinds of DataValues.
+	 */
+
+	private import Base::DataValue;
+	private import ScalarValues::Boolean;
+	private import ControlFunctions::reduce;	
+	
+	abstract function '==' specializes BaseFunctions::'==' { in x: DataValue[0..1]; in y: DataValue[0..1]; 
+		return : Boolean[1];
+	}
+	function '===' specializes BaseFunctions::'==='{ in x: DataValue[0..1]; in y: DataValue[0..1]; 
+		return : Boolean[1] = x == y;
+	}
+	
+	abstract function '+' { in x: DataValue[1]; in y: DataValue[0..1]; return : DataValue[1]; }
+	abstract function '-' { in x: DataValue[1]; in y: DataValue[0..1]; return : DataValue[1]; }
+	abstract function '*' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	abstract function '/' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	abstract function '**' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	abstract function '^' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	abstract function '%' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	
+	abstract function 'not' { in x: DataValue[1]; return : DataValue[1]; }
+	abstract function 'xor' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+
+	abstract function '~' { in x: DataValue[1]; return : DataValue[1]; }
+	abstract function '|' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	abstract function '&' { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	
+	abstract function '<' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }
+	abstract function '>' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }
+	abstract function '<=' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }
+	abstract function '>=' { in x: DataValue[1]; in y: DataValue[1]; return : Boolean[1]; }
+	
+	abstract function max { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	abstract function min { in x: DataValue[1]; in y: DataValue[1]; return : DataValue[1]; }
+	
+	abstract function '..' { in lower: DataValue[1]; in upper: DataValue[1]; return : DataValue[0..*] ordered; }	
 }

package/resources/sysml.library/Kernel Libraries/Kernel Function Library/IntegerFunctions.kerml

@@ -1,43 +1,43 @@
-standard library package IntegerFunctions {
-	doc
-	/*
-	 * This package defines functions on Integer values, including concrete specializations of the 
-	 * general arithmetic and comparison operations.
-	 */
-
-	public import ScalarValues::*;
-	
-	function abs specializes RationalFunctions::abs { in x: Integer[1]; return : Natural[1]; }
-	
-	function '+' specializes RationalFunctions::'+' { in x: Integer[1]; in y: Integer[0..1]; return : Integer[1]; }
-	function '-' specializes RationalFunctions::'-' { in x: Integer[1]; in y: Integer[0..1]; return : Integer[1]; }
-	function '*' specializes RationalFunctions::'*' { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }
-	function '/' specializes RationalFunctions::'/' { in x: Integer[1]; in y: Integer[1]; return : Rational[1]; }
-	function '**' specializes RationalFunctions::'**' { in x: Integer[1]; in y: Natural[1]; return : Integer[1]; }
-	function '^' specializes RationalFunctions::'^' { in x: Integer[1]; in y: Natural[1]; return : Integer[1]; }
-	function '%' specializes NumericalFunctions::'%' { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }
-	
-	function '<' specializes RationalFunctions::'<' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }
-	function '>' specializes RationalFunctions::'>' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }
-	function '<=' specializes RationalFunctions::'<=' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }
-	function '>=' specializes RationalFunctions::'>=' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }
-
-	function max specializes RationalFunctions::max { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }
-	function min specializes RationalFunctions::min { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }
-
-	function '==' specializes DataFunctions::'==' { in x: Integer[0..1]; in y: Integer[0..1]; return : Boolean[1]; }
-	
-	function '..' specializes ScalarFunctions::'..' { in lower: Integer[1]; in upper: Integer[1]; return : Integer[0..*]; }
-	
-	function ToString specializes RationalFunctions::ToString { in x: Integer[1]; return : String[1]; }
-	function ToNatural { in x: Integer[1]; return : Natural[1]; }
-	function ToInteger { in x: String[1]; return : Integer[1]; }
-	
-	function sum specializes RationalFunctions::sum { in collection: Integer[0..*]; 
-		return : Integer[1] default NumericalFunctions::sum0(collection, 0);
-	}
-	
-	function product specializes RationalFunctions::product { in collection: Integer[0..*];
-		return : Integer[1] default NumericalFunctions::product1(collection, 1);
-	}
-}	
+standard library package IntegerFunctions {
+	doc
+	/*
+	 * This package defines functions on Integer values, including concrete specializations of the 
+	 * general arithmetic and comparison operations.
+	 */
+
+	public import ScalarValues::*;
+	
+	function abs specializes RationalFunctions::abs { in x: Integer[1]; return : Natural[1]; }
+	
+	function '+' specializes RationalFunctions::'+' { in x: Integer[1]; in y: Integer[0..1]; return : Integer[1]; }
+	function '-' specializes RationalFunctions::'-' { in x: Integer[1]; in y: Integer[0..1]; return : Integer[1]; }
+	function '*' specializes RationalFunctions::'*' { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }
+	function '/' specializes RationalFunctions::'/' { in x: Integer[1]; in y: Integer[1]; return : Rational[1]; }
+	function '**' specializes RationalFunctions::'**' { in x: Integer[1]; in y: Natural[1]; return : Integer[1]; }
+	function '^' specializes RationalFunctions::'^' { in x: Integer[1]; in y: Natural[1]; return : Integer[1]; }
+	function '%' specializes NumericalFunctions::'%' { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }
+	
+	function '<' specializes RationalFunctions::'<' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }
+	function '>' specializes RationalFunctions::'>' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }
+	function '<=' specializes RationalFunctions::'<=' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }
+	function '>=' specializes RationalFunctions::'>=' { in x: Integer[1]; in y: Integer[1]; return : Boolean[1]; }
+
+	function max specializes RationalFunctions::max { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }
+	function min specializes RationalFunctions::min { in x: Integer[1]; in y: Integer[1]; return : Integer[1]; }
+
+	function '==' specializes DataFunctions::'==' { in x: Integer[0..1]; in y: Integer[0..1]; return : Boolean[1]; }
+	
+	function '..' specializes ScalarFunctions::'..' { in lower: Integer[1]; in upper: Integer[1]; return : Integer[0..*]; }
+	
+	function ToString specializes RationalFunctions::ToString { in x: Integer[1]; return : String[1]; }
+	function ToNatural { in x: Integer[1]; return : Natural[1]; }
+	function ToInteger { in x: String[1]; return : Integer[1]; }
+	
+	function sum specializes RationalFunctions::sum { in collection: Integer[0..*]; 
+		return : Integer[1] default NumericalFunctions::sum0(collection, 0);
+	}
+	
+	function product specializes RationalFunctions::product { in collection: Integer[0..*];
+		return : Integer[1] default NumericalFunctions::product1(collection, 1);
+	}
+}	

package/resources/sysml.library/Kernel Libraries/Kernel Function Library/NaturalFunctions.kerml

@@ -1,27 +1,27 @@
-standard library package NaturalFunctions {
-	doc
-	/*
-	 * This package defines functions on Natural values, including concrete specialization of the 
-	 * general arithmetic and comparison operations.
-	 */
-
-	public import ScalarValues::*;
-	
-	function '+' specializes IntegerFunctions::'+' { in x: Natural[1]; in y: Natural[0..1]; return : Natural[1]; }
-	function '*' specializes IntegerFunctions::'*' { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
-	function '/' specializes IntegerFunctions::'/' { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
-	function '%' specializes IntegerFunctions::'%' { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
-	
-	function '<' specializes IntegerFunctions::'<' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }
-	function '>' specializes IntegerFunctions::'>' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }
-	function '<=' specializes IntegerFunctions::'<=' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }
-	function '>=' specializes IntegerFunctions::'>=' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }	
-
-	function max specializes IntegerFunctions::max { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
-	function min specializes IntegerFunctions::min { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
-
-	function '==' specializes IntegerFunctions::'==' { in x: Natural[0..1]; in y: Natural[0..1]; return : Boolean[1]; }
-	
-	function ToString specializes IntegerFunctions::ToString { in x: Natural[1]; return : String[1]; }
-	function ToNatural{ in x: String[1]; return : Natural[1]; }
-}	
+standard library package NaturalFunctions {
+	doc
+	/*
+	 * This package defines functions on Natural values, including concrete specialization of the 
+	 * general arithmetic and comparison operations.
+	 */
+
+	public import ScalarValues::*;
+	
+	function '+' specializes IntegerFunctions::'+' { in x: Natural[1]; in y: Natural[0..1]; return : Natural[1]; }
+	function '*' specializes IntegerFunctions::'*' { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
+	function '/' specializes IntegerFunctions::'/' { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
+	function '%' specializes IntegerFunctions::'%' { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
+	
+	function '<' specializes IntegerFunctions::'<' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }
+	function '>' specializes IntegerFunctions::'>' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }
+	function '<=' specializes IntegerFunctions::'<=' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }
+	function '>=' specializes IntegerFunctions::'>=' { in x: Natural[1]; in y: Natural[1]; return : Boolean[1]; }	
+
+	function max specializes IntegerFunctions::max { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
+	function min specializes IntegerFunctions::min { in x: Natural[1]; in y: Natural[1]; return : Natural[1]; }
+
+	function '==' specializes IntegerFunctions::'==' { in x: Natural[0..1]; in y: Natural[0..1]; return : Boolean[1]; }
+	
+	function ToString specializes IntegerFunctions::ToString { in x: Natural[1]; return : String[1]; }
+	function ToNatural{ in x: String[1]; return : Natural[1]; }
+}	

package/resources/sysml.library/Kernel Libraries/Kernel Function Library/NumericalFunctions.kerml

@@ -1,43 +1,43 @@
-standard library package NumericalFunctions {
-	doc
-	/*
-	 * This package defines abstract functions on Numerical values for general arithmetic and comparison operations.
-	 */
-
-	public import ScalarValues::*;
-	private import ControlFunctions::reduce;
-	
-	abstract function isZero{ in x: NumericalValue[1]; return : Boolean; }
-	abstract function isUnit{ in x : NumericalValue[1]; return : Boolean; }
-	
-	abstract function abs{ in x: NumericalValue[1]; return : NumericalValue[1]; }
-		
-	abstract function '+' specializes ScalarFunctions::'+' { in x: NumericalValue[1]; in y: NumericalValue[0..1]; return : NumericalValue[1]; }
-	abstract function '-' specializes ScalarFunctions::'-' { in x: NumericalValue[1]; in y: NumericalValue[0..1]; return : NumericalValue[1]; }
-	abstract function '*' specializes ScalarFunctions::'*' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
-	abstract function '/' specializes ScalarFunctions::'/' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
-	abstract function '**' specializes ScalarFunctions::'**' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
-	abstract function '^' specializes ScalarFunctions::'^' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
-	abstract function '%' specializes ScalarFunctions::'%' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
-	
-	abstract function '<' specializes ScalarFunctions::'<' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }
-	abstract function '>' specializes ScalarFunctions::'>' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }
-	abstract function '<=' specializes ScalarFunctions::'<=' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }
-	abstract function '>=' specializes ScalarFunctions::'>=' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }
-	
-	abstract function max specializes ScalarFunctions::max { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
-	abstract function min specializes ScalarFunctions::min { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
-	
-	abstract function sum { in collection: ScalarValue[0..*]; return : ScalarValue[1]; }	
-	abstract function product { in collection: ScalarValue[0..*]; return : ScalarValue[1]; }
-	
-	function sum0 { in collection: NumericalValue[0..*]; in zero: ScalarValue[1]; 
- 		inv { isZero(zero) }		
-        return : ScalarValue = collection->reduce '+' ?? zero;
-	}
-	
-	function product1 { in collection: ScalarValue[0..*]; in one: ScalarValue[1]; 
-		inv { isUnit(one) }		
-        return : ScalarValue = collection->reduce '*' ?? one;
-	}
+standard library package NumericalFunctions {
+	doc
+	/*
+	 * This package defines abstract functions on Numerical values for general arithmetic and comparison operations.
+	 */
+
+	public import ScalarValues::*;
+	private import ControlFunctions::reduce;
+	
+	abstract function isZero{ in x: NumericalValue[1]; return : Boolean; }
+	abstract function isUnit{ in x : NumericalValue[1]; return : Boolean; }
+	
+	abstract function abs{ in x: NumericalValue[1]; return : NumericalValue[1]; }
+		
+	abstract function '+' specializes ScalarFunctions::'+' { in x: NumericalValue[1]; in y: NumericalValue[0..1]; return : NumericalValue[1]; }
+	abstract function '-' specializes ScalarFunctions::'-' { in x: NumericalValue[1]; in y: NumericalValue[0..1]; return : NumericalValue[1]; }
+	abstract function '*' specializes ScalarFunctions::'*' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	abstract function '/' specializes ScalarFunctions::'/' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	abstract function '**' specializes ScalarFunctions::'**' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	abstract function '^' specializes ScalarFunctions::'^' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	abstract function '%' specializes ScalarFunctions::'%' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	
+	abstract function '<' specializes ScalarFunctions::'<' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }
+	abstract function '>' specializes ScalarFunctions::'>' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }
+	abstract function '<=' specializes ScalarFunctions::'<=' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }
+	abstract function '>=' specializes ScalarFunctions::'>=' { in x: NumericalValue[1]; in y: NumericalValue[1]; return : Boolean[1]; }
+	
+	abstract function max specializes ScalarFunctions::max { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	abstract function min specializes ScalarFunctions::min { in x: NumericalValue[1]; in y: NumericalValue[1]; return : NumericalValue[1]; }
+	
+	abstract function sum { in collection: ScalarValue[0..*]; return : ScalarValue[1]; }	
+	abstract function product { in collection: ScalarValue[0..*]; return : ScalarValue[1]; }
+	
+	function sum0 { in collection: NumericalValue[0..*]; in zero: ScalarValue[1]; 
+ 		inv { isZero(zero) }		
+        return : ScalarValue = collection->reduce '+' ?? zero;
+	}
+	
+	function product1 { in collection: ScalarValue[0..*]; in one: ScalarValue[1]; 
+		inv { isUnit(one) }		
+        return : ScalarValue = collection->reduce '*' ?? one;
+	}
 }

package/resources/sysml.library/Kernel Libraries/Kernel Function Library/OccurrenceFunctions.kerml

@@ -1,154 +1,154 @@
-standard library package OccurrenceFunctions {
-	doc
-	/*
-	 * This package defines utility functions that operate on occurrences, primarily related to 
-	 * time during which those occurrences exist.
-	 */
-	
-	private import Occurrences::Occurrence;
-	private import Occurrences::HappensDuring;
-	private import ScalarValues::Boolean;
-	private import ScalarValues::Positive;
-	private import SequenceFunctions::notEmpty;
-	private import SequenceFunctions::size;
-	private import SequenceFunctions::add;
-	private import SequenceFunctions::addAt;
-	private import SequenceFunctions::remove;
-	private import SequenceFunctions::removeAt;
-	private import ControlFunctions::forAll;
-	 
-	function '==='  specializes BaseFunctions::'===' { 
-		doc
-		/*
-		 * Test whether two occurrences are portions of the same life. That is, whether they 
-		 * represent different portions of the same entity (colloquially, whether they have
-		 * the same "identity").
-		 */
-		 
-		in x: Occurrence[0..1]; 
-		in y: Occurrence[0..1];
-		
-		return : Boolean[1] = x.portionOfLife == y.portionOfLife;
-	}
-	
-	function isDuring {
-		doc
-		/*
-		 * Test whether a performance of this function happens during the input occurrence.
-		 */
-		
-		in occ: Occurrence[1];
-		
-		private connector all during: HappensDuring[0..1] from self to occ;
-		
-		return : Boolean[1] = notEmpty(during);
-	}
-	
-	function create {
-		doc
-		/*
-		 * Ensure that the start of a given occurrence happens during a performance of this
-		 * function. The occurrence is also returned from the function.
-		 */
-		
-		inout occ: Occurrence[1];
-			
-		private connector : HappensDuring from occ.startShot to self;	
-		
-		return : Occurrence[1] = occ;
-	}
-	
-	function destroy {
-		doc
-		/*
-		 * Ensure that the end of a given occurrence happens during a performance of this
-		 * function. The occurrence is also returned from the function.
-		 */
-
-		inout occ: Occurrence[0..1];
-		
-		private connector : HappensDuring from [0..1] occ.endShot to self;
-		
-		return : Occurrence[0..1] = occ;
-	}
-	
-	function addNew {
-		doc
-		/*
-		 * Add a newly created occurrence to the given group of occurrences and return the
-		 * new occurrence.
-		 */
-
-		inout group: Occurrence[0..*] nonunique;
-		inout occ: Occurrence[1];
-		
-		private composite step : add {
-			inout seq1 = group;
-			in seq2 = create(occ);
-		}
-		
-		return : Occurrence[1] = occ;
-	}
-	
-	function addNewAt {
-		doc
-		/*
-		 * Add a newly created occurrence to the given ordered group of occurrences at the given
-		 * index and return the new occurrence.
-		 */
-
-		inout group: Occurrence[0..*] ordered nonunique;
-		inout occ: Occurrence[1];
-		in index: Positive[1];
-		
-		private composite step : addAt {
-			inout seq = group;
-			in values = create(occ);
-			in startIndex = index;
-		}
-		
-		return : Occurrence[1] = occ;
-	}
-	
-	behavior removeOld {
-		doc
-		/*
-		 * Remove a given occurrence from a group of occurrences and destroy it.
-		 */
-
-		inout group: Occurrence[0..*] nonunique;
-		inout occ: Occurrence[0..1];
-		
-		private composite step removeStep : remove {
-			inout seq = group;
-			in values = occ;
-		}
-		private succession removeStep then destroyStep;
-		private composite step destroyStep : destroy {
-			inout occ = removeOld::occ;
-		}
-		
-	}
-	
-	behavior removeOldAt {
-		doc
-		/*
-		 * Removes the occurrence at a given index in an ordered group of occurrences 
-		 * and destroy it.
-		 */
-		inout group: Occurrence[0..*] ordered nonunique;
-		in index: Positive[1];
-		
-		private feature oldOcc = group#(index);
-		
-		private composite step removeStep : remove {
-			inout seq = group;
-			in index = removeOldAt::index;
-		}
-		private succession removeStep then destroyStep;
-		private composite step destroyStep : destroy {
-			inout occ = oldOcc;
-		}
-		
-	}
+standard library package OccurrenceFunctions {
+	doc
+	/*
+	 * This package defines utility functions that operate on occurrences, primarily related to 
+	 * time during which those occurrences exist.
+	 */
+	
+	private import Occurrences::Occurrence;
+	private import Occurrences::HappensDuring;
+	private import ScalarValues::Boolean;
+	private import ScalarValues::Positive;
+	private import SequenceFunctions::notEmpty;
+	private import SequenceFunctions::size;
+	private import SequenceFunctions::add;
+	private import SequenceFunctions::addAt;
+	private import SequenceFunctions::remove;
+	private import SequenceFunctions::removeAt;
+	private import ControlFunctions::forAll;
+	 
+	function '==='  specializes BaseFunctions::'===' { 
+		doc
+		/*
+		 * Test whether two occurrences are portions of the same life. That is, whether they 
+		 * represent different portions of the same entity (colloquially, whether they have
+		 * the same "identity").
+		 */
+		 
+		in x: Occurrence[0..1]; 
+		in y: Occurrence[0..1];
+		
+		return : Boolean[1] = x.portionOfLife == y.portionOfLife;
+	}
+	
+	function isDuring {
+		doc
+		/*
+		 * Test whether a performance of this function happens during the input occurrence.
+		 */
+		
+		in occ: Occurrence[1];
+		
+		private connector all during: HappensDuring[0..1] from self to occ;
+		
+		return : Boolean[1] = notEmpty(during);
+	}
+	
+	function create {
+		doc
+		/*
+		 * Ensure that the start of a given occurrence happens during a performance of this
+		 * function. The occurrence is also returned from the function.
+		 */
+		
+		inout occ: Occurrence[1];
+			
+		private connector : HappensDuring from occ.startShot to self;	
+		
+		return : Occurrence[1] = occ;
+	}
+	
+	function destroy {
+		doc
+		/*
+		 * Ensure that the end of a given occurrence happens during a performance of this
+		 * function. The occurrence is also returned from the function.
+		 */
+
+		inout occ: Occurrence[0..1];
+		
+		private connector : HappensDuring from [0..1] occ.endShot to self;
+		
+		return : Occurrence[0..1] = occ;
+	}
+	
+	function addNew {
+		doc
+		/*
+		 * Add a newly created occurrence to the given group of occurrences and return the
+		 * new occurrence.
+		 */
+
+		inout group: Occurrence[0..*] nonunique;
+		inout occ: Occurrence[1];
+		
+		private composite step : add {
+			inout seq1 = group;
+			in seq2 = create(occ);
+		}
+		
+		return : Occurrence[1] = occ;
+	}
+	
+	function addNewAt {
+		doc
+		/*
+		 * Add a newly created occurrence to the given ordered group of occurrences at the given
+		 * index and return the new occurrence.
+		 */
+
+		inout group: Occurrence[0..*] ordered nonunique;
+		inout occ: Occurrence[1];
+		in index: Positive[1];
+		
+		private composite step : addAt {
+			inout seq = group;
+			in values = create(occ);
+			in startIndex = index;
+		}
+		
+		return : Occurrence[1] = occ;
+	}
+	
+	behavior removeOld {
+		doc
+		/*
+		 * Remove a given occurrence from a group of occurrences and destroy it.
+		 */
+
+		inout group: Occurrence[0..*] nonunique;
+		inout occ: Occurrence[0..1];
+		
+		private composite step removeStep : remove {
+			inout seq = group;
+			in values = occ;
+		}
+		private succession removeStep then destroyStep;
+		private composite step destroyStep : destroy {
+			inout occ = removeOld::occ;
+		}
+		
+	}
+	
+	behavior removeOldAt {
+		doc
+		/*
+		 * Removes the occurrence at a given index in an ordered group of occurrences 
+		 * and destroy it.
+		 */
+		inout group: Occurrence[0..*] ordered nonunique;
+		in index: Positive[1];
+		
+		private feature oldOcc = group#(index);
+		
+		private composite step removeStep : remove {
+			inout seq = group;
+			in index = removeOldAt::index;
+		}
+		private succession removeStep then destroyStep;
+		private composite step destroyStep : destroy {
+			inout occ = oldOcc;
+		}
+		
+	}
 }