package PM {

//----------------------- Forward declarations -------------------------

	class IntRange;  class Date;  class User;
        abstract class Term;  abstract class Type;
        abstract class ConceptNode; class QNode;

	// by representing numbers as strings, we can apply default values
	// to them, which is convenient until we upgrade HUTN to handle
	// default values on numbers
	typedef string Number;
	typedef string Natural; //positive (or null) integer

//------------------------------ KRelt ---------------------------------

	abstract class KRElt {

	abstract class EltWithCreator : KRElt {
		attribute string comment; //comment stored with the object
		attribute bag [0..1] of Date creationDate;
		reference creator to creator of HasCreator;
	}; //direct subclasses: Term, Partition, Node and Correction

	abstract class EltWithoutCreator : KRElt {
	}; //direct subclasses: Collection, Value, NameSpace, Quantifier
           //                   and ConflictResolution

	//A node is not a term (named category), it is a structure
	//aggregating a term, a quantifier (implicit/null if the term 
	//is an individual) and other stuff.
	//Similarly, values and name spaces are not terms; they won't 
	//be related by links (e.g. partOf links) like terms arewill.

	association HasCreator { //pm: was called HasCreatedElts
		end set [0..*] of EltWithCreator creatorOf;
		end single User creator;

//-------------------- Link (between named categories) ---------------------

	abstract class Link: EltWithCreator {
		//attribute string name; //instance, subtype, sameAs,
                                  //differentFrom, exclusion, complement, inverse,
                                  //member, part, substance, location, object, url
                attribute boolean isReversed;
		attribute Natural minDomain;
		attribute Natural maxDomain;
		attribute Natural minRange;
		attribute Natural maxRange;
		reference source to source of HasLinkSourceTerm;
		reference dest to dest of HasLinkDestTerm;
	class InstanceOf: Link {};  class Supertype: Link {};
        class Instance: Link {};  class Subtype: Link {};
        class SameAs: Link {}; class DifferentFrom:Link{}; class Exclusion:Link{};
	class Inverse: Link {};   class Complement: Link {};
	class Member: Link {};    class Part: Link {};   class Substance: Link{};
	class Location: Link {};  class Obj: Link{};  class Url: Link{};

	//class LinkBetweenTypes: Link {
	//	reference source to source of HasLinkSourceType;
	//	reference dest to dest of HasLinkDestType;
        //class Subtype:LinkBetweenTypes {};  class Exclusion: LinkBetweenTypes {};
	//class Inverse:LinkBetweenTypes {};  class Complement:LinkBetweenTypes {};

	//association HasLinkSourceType {
	//	end set [0..*] of Link sourceOf;
	//	end single Type source;
	//association HasLinkDestType {
	//	end set [0..*] of Link destOf;
	//	end single Type dest;

	//class LinkBetweenTerms: Link {
	//	reference source to source of HasLinkSourceTerms;
	//	reference dest to dest of HasLinkDestTerms;
        //class Instance: LinkBetweenTerms {};  class SameAs: LinkBetweenTerms {};
	//class DifferentFrom: LinkBetweenTerms {}; 
        //class Member: LinkBetweenTerms {};    class Part: LinkBetweenTerms {};
        //class Substance: LinkBetweenTerms {}; class Location: LinkBetweenTerms{};
        //class Object: LinkBetweenTerms {};    class Url: LinkBetweenTerms {};

	association HasLinkSourceTerm {
		end set [0..*] of Link sourceOf;
		composite end single Term source; // KR was here!
	association HasLinkDestTerm {
		end set [0..*] of Link destOf;
		end single Term dest;

//------------------------ Term (named category) -----------------------

	abstract class Term: EltWithCreator {
		reference identifier to identifier of HasIdentifier;
		reference name to name of HasName;

		reference sourceOf to sourceOf of HasLinkSourceTerm;
		reference destOf to destOf of HasLinkDestTerm;
		//reference sourceTypeOf to sourceOf of HasLinkSourceType;
		//reference destTypeOf to destOf of HasLinkDestType;

		//to refer to nodes (and hence statements) using this term
		//WITHOUT QUANTIFIER; if "this" is a type, the node is either
		//connected to a second-order relation or is an embedding node
		reference directTNode to termOf of HasConceptNodeTerm;

		//to refer to the user represented by this term
		reference representationOf to representationOf
		                           of HasRepresentation;

	class Indiv: Term { //Individual/type0: term that cannot have instances,
	};                  //                    subtypes or supertypes

	abstract class Type : Term {
		//reference instance to instance of HasInstance;
		//reference subtype to subtype of HasSubtype;
		//reference supertype to subtypeOf of HasSubtype;
		reference subtypePartition to subtypePartition
		                           of HasSubtypePartition;
		reference subtypePartitionEltOf to subtypePartitionEltOf
		                           of HasSubtypePartitionElt;
		reference partPartition to partPartition
		                        of HasPartPartition;
		reference partPartitionEltOf to partPartitionEltOf
		                           of HasPartPartitionElt;
		reference domainOf to domainOf of HasDomain; //default: any
		reference rangeOf to rangeOf of HasRange;    //default: any

		//to refer to definitions of this type
		reference definition to definition of HasDefinedType;

		//to refer to concept nodes and relations using this type
		reference directQNode to typeOf of HasConceptNodeType;
		reference relation to typeOf of HasRelationType;

	class MetaType : Type { //pm: not used below but Type is abstract

	class CType : Type { //pm: not used below but Type is abstract

	class RType : Type {
//pm: We may want to accept non binary relations even though we also want
//pm: to discourage their use. With the following, relations are only binary. 
		attribute Natural minDomain;
		attribute Natural maxDomain; //if =1, this is a function type?
		attribute Natural minRange; //always 0 (optional to use)!
		attribute Natural maxRange;
		reference domain to domain of HasDomain;
		reference range to range of HasRange;

//pm:	class Alias : Term { //Term that is the destination of an '=' link
//pm:	}; //Can probably be removed (it is an implementation issue).

//pm:	class Undefined : Term { //temporary and not mandatory since Term
//pm:	};                       //can be used instead

	//...... A few links between categories (2nd-order relations)
//pm: can creators be associated to links when represented this way?

	association HasDomain { //for the signature of binary relation
		end set [0..*] of RType domainOf;
		end single Type domain;
	association HasRange { //for the signature of binary relation
		end set [0..*] of  RType rangeOf;
		end single Type range;

//--------------------------- Partition --------------------------------

	//a partition is a set of exclusive types or statements

	abstract class Partition : EltWithCreator {
		attribute boolean isClosed; //if not, it is redundant since
		//its elements can be automatically found
	abstract class TypePartition : Partition {
	class SubtypePartition : TypePartition {
		reference subtype to subtype of HasSubtypePartitionElt;
	class PartPartition : TypePartition {
		reference partType to partType of HasPartPartitionElt;

	association HasSubtypePartition {
		composite end single Type subtypePartitionOf;
		end set [0..*] of SubtypePartition subtypePartition;
	association HasSubtypePartitionElt {
		end set [0..*] of SubtypePartition subtypePartitionEltOf;
		end set [0..*] of Type subtype;
	association HasPartPartition {
		composite end single Type partPartitionOf;
		end set [0..*] of PartPartition partPartition;
	association HasPartPartitionElt {
		end set [0..*] of PartPartition partPartitionEltOf;
		end set [0..*] of Type partType;

//----------------------------- Value  ---------------------------------

	abstract class Value: EltWithoutCreator { //it was OntologyElt

	class Time : Value { //originally Time was a struct but it broke HUTN
		attribute Natural year;
		attribute Natural month;
		attribute Natural day;
		attribute Natural hour;
		attribute Natural minute;
		attribute Natural second;
	class Date : Time { 
	class Duration : Time  { 
	class TimeValue: Value {     //pm: not yet used
		attribute Time t;
	class TimeRange: TimeValue { //pm: not yet used
		attribute Time t2;

	class IntValue: Value {     //pm: not yet used
		attribute Natural v;
	class StringValue: Value {
		attribute string s;

	typedef string Variable;

//---------------------- User/NameSpace and Name ----------------------

	// Names, like identifiers, include a reference to a
	// name space and to a name. In fact identifiers are names, the
	// only difference is that two terms may share the same name but
	// cannot share the same identifier. How is this issue dealt above?

	class Name: StringValue {
		reference nameSpace to nameSpace of HasNameSpace;
		reference nameOf to nameOf of HasName;
	class Identifier: Name {
		reference identifierOf to identifierOf of HasIdentifier;
	class NameSpace: EltWithoutCreator { //pm: not Term 
		attribute string name;
		attribute string password;
		//the term representing this namespace is likely to be an URL
		reference term to representation of HasRepresentation;
		reference nameSpaceOf to nameSpaceOf of HasNameSpace;
	class User: NameSpace {
		reference creatorOf to creatorOf of HasCreator;
	association HasRepresentation { //"has a term representing it"
		end single NameSpace representationOf;
		end set [0..*] of Term representation; //most likely only 1
	association HasName {
		end set [0..*] of Term nameOf;
		end set [0..*] of Name name;
	association HasIdentifier {
		end single Term identifierOf; //uniquely identified term
		end set [0..*] of Name identifier; //possibly many identifiers
	association HasNameSpace {
		end ordered set [0..*] of Name nameSpaceOf;
		end set [0..*] of NameSpace nameSpace;

//-------------------------- Collection --------------------------------

	typedef string CollKind; //enum CollKind {cSet,cBag,cList,cSequence};

	typedef string CollAggregation;	//enum CollAggregation {and,or,xor};
	// enum CollInterpretation { distributive, collective, cumulative };
	typedef string CollInterpretation;  //default: distributive

	abstract class Collection : EltWithoutCreator {
		attribute CollKind kind;
		attribute boolean isOpenColl;
		attribute CollAggregation aggregation;
		attribute CollInterpretation interpretation;
	//pm:   attribute Number size; //number of elems: not all may be given

//----------------------------- Node -----------------------------------

	abstract class Node : EltWithCreator {

	abstract class ConceptNode : Node {
		reference sourceOf to sourceOf of HasSourceNode;
		reference destOf to destOf of HasDestNode;
		reference destRefOf to destOf of HasReferredDestNode;
		reference collEltOf to collEltOf of HasCollectionElt;

		//a class EmbeddedNode could be created for the next 2 lines
		//but multi-instantiation would be needed to permit instances
		//of subclasses of Node to be also instance of EmbeddedNode
		attribute boolean isNegated;
		reference embeddingNode to embeddedNodeOf of HasEmbeddedNode;
		reference embeddedNode1RefOf to embeddedNodeOf
                                             of HasReferredFirstEmbeddedNode;

		//Using variables is one of the ways to
		//1) connect this node to a definition parameter,
		//2) specify that this connect is identical to another node.
		//In both cases, if multi-instantiation is possible,
		//an association could also be used.
		attribute Variable var;

//	enum Modality { noneM, must, may, can }; //default: none
	typedef string Modality;
	class Relation : Node {
                attribute boolean isReversed;
  		attribute Modality modality;
		reference rType to rType of HasRelationType;
		reference source to source of HasSourceNode;
		reference dest to dest of HasDestNode;
		reference destRef to dest of HasReferredDestNode;
	association HasRelationType {
		end set [0..*] of Relation typeOf;
		end single Type rType; //not always RelationType
	association HasSourceNode { //pm: I have reversed the order/direction
		end set [0..*] of Relation sourceOf; //normally 1
		composite end single ConceptNode source;
	association HasDestNode { //pm: I have reversed the order/direction
		composite end single Relation destOf;
		end single ConceptNode dest;
	association HasReferredDestNode { //pm: I have reversed the order/direction
		end set [0..*] of Relation destOf;
		end single ConceptNode dest;

	//.................. VNode (ConceptNodeForValue) ......................

	// Concept node with just a value (number or time) or an interval of
	// value. Nno term, no quantifier.

	class VNode : ConceptNode {
	//	enum Precision { exact, about, around, atLeast,atMost,between };
	typedef string Precision; //default: exact

	class NodeForNumber : VNode {
		attribute Precision precision;
		attribute Number num;   attribute Number toNumber;
	class NodeForTime : VNode { //point in time or duration
		attribute Time aTime;   attribute Time toTime;

	//................. QNode (QuantifiedConceptNode) .....................

	//enum QuantifierKind { some, few, most, several,
	//                      all, percent, local_any, local_percent };
	typedef string QuantifierKind; //default: some

	class Quantifier : EltWithoutCreator {
		attribute QuantifierKind kind;
		attribute Number num;  //Number HUTNs better than Value
		attribute Number toNumber;
		attribute Precision precision;
	//enum Qualifier {noneQ,small,important,big,great, good,bad};
	typedef string Qualifier; //default: noneQ

	class QNode : ConceptNode {
		reference cType to cType of HasConceptNodeType;
		attribute boolean isNegatedType; //NEW!
		attribute bag [0..1] of Quantifier quantifier;
		//reference quantifier to quantifier of HasQuantifier;
		attribute Qualifier qualifier;
	};                     //a type may also be used without quantifier 

//	association HasQuantifier {
//		composite end single QNode quantifierOf;
//		end single Quantifier quantifier;
//	};
	association HasConceptNodeType {
		end set [0..*] of Node typeOf;
		end single Type cType;

	//...................... NodeCollection ..........................

	class NodeCollection : QNode, Collection {
		reference collElt to collElt of HasCollectionElt;

	association HasCollectionElt {
		composite end single NodeCollection collEltOf;
		end set [0..*] of ConceptNode collElt;

	//................. TNode (ConceptNodeForTerm) ..................

	//the term may be a type if a second-order relation is connected
	//or, in the case this node is an embedding node (see below), if a
	//statement type (e.g. hypothesis or proof) is given instead of an 
	//individual (if neither is given, the statement type is "statement")

	class TNode : ConceptNode {
		reference term to term of HasConceptNodeTerm;
	association HasConceptNodeTerm {
		end set [0..*] of TNode termOf;
		end single Term term;

	//.................... EmbeddingNode (statement) ......................

	//an embedding node may or may not be quantified.

	abstract class EmbeddingNode : TNode { //assertion/defin./query
		attribute string text; //text used for asserting the node
		                 //or application-dependant place of storage
		reference embeddedNode  to embeddedNode of HasEmbeddedNode;
		reference embeddedNode1 to firstEmbeddedNode
		                           of HasFirstEmbeddedNode;
		reference embeddedNode1Ref to firstEmbeddedNode
		                           of HasReferredFirstEmbeddedNode;
//pm:	class EmbeddedNode : ConceptNode { //replaced by ENode below
//pm:		reference embeddingNode to embeddedNodeOf of HasEmbeddedNode;
//pm:	};
	association HasEmbeddedNode {
		composite end single EmbeddingNode embeddedNodeOf;
		end set [0..*] of Node embeddedNode; //Node or EmbeddedNode
	association HasFirstEmbeddedNode { //the first node of the statement
		composite end single Node embeddedNodeOf;
		end single Node firstEmbeddedNode;
	association HasReferredFirstEmbeddedNode {
		end set [0..*] of Node embeddedNodeOf;
		end single Node firstEmbeddedNode;

	class KRQuery : EmbeddingNode { //to query statements

	class LNode : EmbeddingNode { //a node defining And using a lambda
	};                     //e.g. [most (cat, chrc: a great hapiness)]

	//enum DefKind { NC, SC, NSC }; //necessary and/or sufficient conditions
	typedef string DefKind;
	class Definition : EmbeddingNode {
		reference dType to definedType of HasDefinedType;
		attribute DefKind kind;
		attribute ordered set [0..*] of Variable parameter;
	association HasDefinedType {
		end set [0..*] of Definition definition;
		end single Type definedType;

	class Assertion : EmbeddingNode { //to assert stuff
		reference sourceCorrectionOf to sourceCorrectionOf
		                             of HasSourceCorrection;
		reference destCorrectionOf to destCorrectionOf
		                           of HasDestCorrection;
		reference conflictingNodeOf to conflictingNodeOf
		                            of HasConflictingNode;

	class ENode : EmbeddingNode { //for embedded and embedding statements

//----------------- Correction between assertions  -------------------

	//To permit a user to record conflicting between 2 statements/beliefs.
	typedef string CorrectionKind; //e.g. corrective_specialization,
	   //corrective_generalization, correction (if previous don't apply),
	   //correction (if the previous do not apply; e.g. "counterexample"),
	   //overriding_specialization (e.g. "instantiation")

	class Correction : EltWithCreator {
		attribute CorrectionKind kind;
		reference source to sourceCorrection of HasSourceCorrection;
		reference dest to destCorrection of HasDestCorrection;
		reference correctionOf to correctionOf of HasCorrection;
	association HasSourceCorrection {
		end single Correction sourceCorrectionOf;
		end set [1..1] of Assertion sourceCorrection;
	association HasDestCorrection {
		end single Correction destCorrectionOf;
		end set [1..1] of Assertion destCorrection;

	//Simple elaborations are automatically detected or should be stored
	//using rhetorical/argumentation relations between assertions.

//-------------------- ConflictResolution ----------------------------

	//To record that two (or more?) assertions are in conflict
	//and the corrections that have been made to solve that conflict.

	typedef string ConflictResolutionStrategy;

	class ConflictResolution : EltWithoutCreator {//Correction has creator
		attribute ConflictResolutionStrategy strategy;
		reference input to conflictingNode of HasConflictingNode;
		reference output to correction of HasCorrection;
	association HasConflictingNode {
		end single ConflictResolution conflictingNodeOf;
		end set [2..*] of Assertion conflictingNode;
	association HasCorrection {
		end set [0..*] of ConflictResolution correctionOf;
		end set [0..*] of Correction correction;