;; ===================================================================
;; Definitions for User Experience Experimental Terms.
;; ===================================================================
;;
;; Authors: Jay Weiler, Adam Pease.
;;
;; This file is released under the GNU Public License <http://www.gnu.org/copyleft/gpl.html>.  
;; Users of this code also consent, by  use of this material, to credit Articulate Software in any 
;; writings, briefings, publications, presentations, or other representations of any code or other 
;; product which incorporates, builds on, or uses this material. 
;;
;; We ask that people using or referencing this work cite our primary paper:
;;
;; Niles, I., and Pease, A.  2001.  Towards a Standard Upper Ontology.  In Proceedings of the 2nd 
;; International Conference on Formal Ontology in Information Systems (FOIS-2001), Chris Welty and 
;; Barry Smith, eds, Ogunquit, Maine, October 17-19, 2001. 
;; 
;; See also http://www.ontologyportal.org
;;
;; BEGIN FILE:

;; -------------------------------------------------------------------
;; LISTINGS
;; -------------------------------------------------------------------


;; WebListing
;; -------------------------------------------------------------------

(subclass WebListing Advertising)

(termFormat EnglishLanguage WebListing "web listing")

(documentation WebListing EnglishLanguage "A subclass of &%Avertising which is hostedOn a WebSite. 
 The &%Creator of the WebListing must be a &%webSeller on the &%WebSite it is &%hostedOn.")

(=>
  (instance ?LISTING WebListing)
  (exists (?SITE)
    (and
      (instance ?SITE WebSite)
      (hostedOn ?LISTING ?SITE))))

(=>
  (and
    (instance ?LISTING WebListing)
    (instance ?SITE WebSite)
    (hostedOn ?LISTING ?SITE)
    (creator ?LISTING ?AGENT))
  (webSeller ?AGENT ?SITE))


;; listingSeller
;; -------------------------------------------------------------------

(instance listingSeller BinaryRelation)

(domain listingSeller 1 WebListing)

(domain listingSeller 2 AutonomousAgent)

(termFormat EnglishLanguage listingSeller "listing seller")

(documentation listingSeller EnglishLanguage "(listingSeller ?LISTING ?AGENT) relates an &%AutonomousAgent to 
 a &%WebListing. It represents that ?AGENT is the entity that &%desires the &%Selling of the 
 &%patient of the ?LISTING. It also means that ?AGENT is the &%creator of ?LISTING and that ?AGENT
 is a &%webSeller on the &%WebSite that ?LISTING is &%hostedOn.")

(=>
  (listingSeller ?LISTING ?AGENT)
  (creator ?LISTING ?AGENT))

(=>
  (and
    (listingSeller ?LISTING ?AGENT)
    (instance ?OBJ Object)
    (patient ?LISTING ?OBJ))
  (desires ?AGENT
    (exists (?SELLING)
      (patient ?SELLING ?OBJ))))

(=>
  (and
    (listingSeller ?LISTING ?AGENT)
    (hostedOn ?LISTING ?SITE))
  (webSeller ?AGENT ?SITE))


;; listingBuyer
;; -------------------------------------------------------------------

(instance listingBuyer BinaryRelation)

(domain listingBuyer 1 WebListing)

(domain listingBuyer 2 AutonomousAgent)

(termFormat EnglishLanguage listingBuyer "listing buyer")

(documentation listingBuyer EnglishLanguage "(listingBuyer ?LISTING ?AGENT) relates an &%AutonomousAgent to 
 a &%WebListing. It represents that ?AGENT is the entity that was the &%agent of a &%Buying
 where the &%Object which is the &%patient of the buying is also the &%patient the ?LISTING, and the
 &%WebSite which the ?LISTING is &%hostedOn is the &%eCommerceSite of the buying.")

(=>
  (and
    (listingBuyer ?LISTING ?BUYER)
    (instance ?OBJ Object)
    (instance ?SITE WebSite)
    (patient ?LISTING ?OBJECT)
    (hostedOn ?LISTING ?SITE))
  (exists (?BUYING)
    (and
      (instance ?BUYING Buying)
      (patient ?BUYING ?OBJ)
      (eCommerceSite ?BUYING ?SITE)
      (agent ?BUYING ?BUYER))))


;; listingBidder
;; -------------------------------------------------------------------

(instance listingBidder BinaryRelation)

(domain listingBidder 1 WebListing)

(domain listingBidder 2 AutonomousAgent)

(termFormat EnglishLanguage listingBidder "listing bidder")

(documentation listingBidder EnglishLanguage "(listingBidder ?LISTING ?AGENT) means that ?AGENT bid 
 on the &%Object which is the &%patient of the &%webListing ?LISTING - i.e. if ?OBJECT is the
 patient of ?LISTING, there exists some ?MONEY where (&%bidPrice ?OBJECT ?MONEY ?AGENT)")

 (=>
  (and
    (listingBidder ?LISTING ?AGENT)
    (instance ?OBJ Object)
    (patient ?LISTING ?OBJ))
  (exists (?MONEY)
    (bidPrice ?OBJ ?MONEY ?AGENT)))


;; hostedOn
;; -------------------------------------------------------------------
(instance hostedOn BinaryPredicate)

(domain hostedOn 1 WebListing)

(domain hostedOn 2 WebSite)

(termFormat EnglishLanguage hostedOn "hosted on")

(documentation hostedOn EnglishLanguage "(hostedOn ?LISTING ?SITE) means that the &%WebListing 
 ?LISTING is a &%Component of a &%WebPage which is a &%Component of the &%WebSite ?SITE.")

(=>
  (hostedOn ?LISTING ?SITE)
  (exists (?PAGE)
    (and
      (instance ?PAGE WebPage)
      (component ?LISTING ?PAGE)
      (component ?PAGE ?SITE))))


;; WebListingCategory
;; -------------------------------------------------------------------

(subclass WebListingCategory Collection)

(termFormat EnglishLanguage WebListingCategory "web listing category")

(documentation WebListingCategory EnglishLanguage "a &%collection of &%WebListings where all the 
 items being advertised in those listings are of the same class.")

(=>
  (and
    (instance ?CATEG WebListingCategory)
    (member ?LISTING ?CATEG))
  (instance ?LISTING WebListing))

(=>
  (and
    (instance ?CATEG WebListingCategory)
    (instance ?LISTING1 WebListing)
    (instance ?LISTING2 WebListing)
    (instance ?ITEM1 Object)
    (instance ?ITEM2 Object)
    (member ?LISTING1 ?CATEG)
    (member ?LISTING2 ?CATEG)
    (patient ?ITEM1 ?LISTING1)
    (patient ?ITEM2 ?LISTING2))
  (exists (?CLASS)
    (and
      (instance ?CLASS Class)
      (instance ?ITEM1 ?CLASS)
      (instance ?ITEM2 ?CLASS))))


;; categoryID
;; -------------------------------------------------------------------

(instance categoryID BinaryRelation)

(domain categoryID 1 Identifier)

(domain categoryID 2 WebListingCategory)

(documentation categoryID EnglishLanguage "(categoryID ?STRING ?CAT) Associates an 
 &%Identifer ?STRING to a &%WebListingCategory ?CAT. They are likely to be unique.")

(termFormat EnglishLanguage categoryID "category identifier string")

(=>
  (categoryID ?STRING ?CAT)
  (represents ?STRING ?USER))

;; categoryOf
;; -------------------------------------------------------------------

(instance categoryOf BinaryPredicate)

(domain categoryOf 1 WebListingCategory)

(domain categoryOf 2 WebSite)

(termFormat EnglishLanguage categoryOf "category of")

(documentation categoryOf EnglishLanguage "A &%BinaryPredicate which relates a &%WeblistingCategory 
 to a &%WebSite that uses that category to organize its listings.")


;; advertisedOn
;; -------------------------------------------------------------------

(instance advertisedOn BinaryPredicate)

(domain advertisedOn 1 Object)

(domain advertisedOn 2 WebSite)

(format EnglishLanguage advertisedOn "%1 was &%advertisedOn %2")

(termFormat EnglishLanguage advertisedOn "advertised on")

(documentation advertisedOn EnglishLanguage "(advertisedOn ?OBJ ?SITE) means that there exists an instance 
 of &%Advertising where ?OBJ is the patient of the Advertising and the advertising is a &%component of
 a &%WebPage which is a component of ?SITE.")

(=>
  (advertisedOn ?OBJ ?SITE)
  (exists (?ADVERT)
    (and
      (instance ?ADVERT Advertising)
      (hostedOn ?ADVERT ?SITE)
      (patient ?ADVERT ?OBJ))))


;; InsertionFee
;; -------------------------------------------------------------------

(subclass InsertionFee ChargingAFee)

(termFormat EnglishLanguage InsertionFee "insertion fee")

(documentation InsertionFee EnglishLanguage "A type of &%ChargingAFee where the &%agent of the 
 &%InsertionFee is the &%AutonomousAgent who &%possesses a %&WebSite where a &%WebListing is &%hostedOn. A 
 &%ListOnSite &%causes the &%InsertionFee, and the &%agent of both is an &%AutonomousAgent who &%Possesses the 
 &%WebSite.")

(=>
  (instance ?CHARGE InsertionFee)
  (exists (?SITE ?OWNER ?ADVERT)
    (and
      (instance ?SITE WebSite)
      (instance ?OWNER AutonomousAgent)
      (instance ?ADVERT WebListing)
      (hostedOn ?ADVERT ?SITE)
      (possesses ?OWNER ?SITE)
      (agent ?CHARGE ?OWNER))))

(=>
  (instance ?CHARGE InsertionFee)
  (exists (?ADVERT ?PROC ?OWNER)
    (and
      (instance ?ADVERT WebListing)
      (instance ?PROC ListOnSite)
      (instance ?OWNER AutonomousAgent)
      (patient ?PROC ?ADVERT)
      (causes ?PROC ?CHARGE)
      (agent ?CHARGE ?OWNER)
      (agent ?PROC ?OWNER))))


;; FinalValueFee
;; -------------------------------------------------------------------

(subclass FinalValueFee ChargingAFee)

(termFormat EnglishLanguage FinalValueFee "final fee")

(documentation FinalValueFee EnglishLanguage "A type of &%ChargingAFee where the &%agent of the 
 &%FinalValueFee is the &%AutonomousAgent who &%possesses a %&WebSite where a &%WebListing is &%hostedOn. A 
 &%Selling of the &%patient of the listing where the &%WebSite is the &%eCommerceSite of the selling
 &%causes the &%FinalValueFee.")

(=>
  (instance ?CHARGE FinalValueFee)
  (exists (?ADVERT ?SELLING ?OWNER ?ITEM ?SITE)
    (and
      (instance ?ADVERT WebListing)
      (instance ?SELLING Selling)
      (instance ?OWNER AutonomousAgent)
      (instance ?ITEM Physical)
      (instance ?ADVERT WebListing)
      (patient ?ADVERT ?ITEM)
      (patient ?SELLING ?ITEM)
      (causes ?SELLING ?CHARGE)
      (agent ?CHARGE ?OWNER)
      (hostedOn ?ADVERT ?SITE)
      (possesses ?OWNER ?SITE)
      (eCommerceSite ?SELLING ?OWNER))))


;; ListOnSite
;; -------------------------------------------------------------------

(subclass ListOnSite IntentionalProcess)

(termFormat EnglishLanguage ListOnSite "list on site")

(documentation ListOnSite EnglishLanguage "An &%IntentionalProcess meant to represent the actions
 taken to initially list a &%Weblisting on a &%WebSite. There &%exists a &%TimeInterval before the
 processes occurred where the &%patient &%WebListing was not &%hostedOn the WebSite and a 
 &%TimeInterval after which it does. The &%TimePoint marking the end of when the site is not hosted 
 is the same as the end of the process (i.e. when WebListing began to be listed.")
    
(=>
  (instance ?LIST ListOnSite)
  (exists (?SITE ?ADVERT ?EARLIER ?AFTER)
    (and
      (instance ?SITE WebSite)
      (instance ?ADVERT WebListing)
      (instance ?EARLIER TimeInterval)
      (instance ?AFTER TimeInterval)
      (patient ?LIST ?ADVERT)
      (equal
        (EndFn ?EARLIER)
        (EndFn ?LIST))
      (earlier ?LIST ?AFTER)
      (meetsTemporally ?LIST ?AFTER)
      (holdsDuring ?EARLIER
        (not
          (hostedOn ?ADVERT ?SITE)))
      (holdsDuring ?AFTER
        (hostedOn ?ADVERT ?SITE))
      (agent ?LIST ?OWNER)
      (possesses ?OWNER ?SITE))))
    

;; -------------------------------------------------------------------
;; LISTING TYPES AND ATTRIBUTES
;; -------------------------------------------------------------------

;; ListingAttribute
;; -------------------------------------------------------------------

(subclass ListingAttribute Attribute)

(termFormat EnglishLanguage ListingAttribute "web listing attribute")

(documentation ListingAttribute EnglishLanguage "A &%subclass of &%Attribute specific to describe 
 &%Weblistings.")  

(=>
  (and
    (attribute ?LISTING ?ATTRIBUTE)
    (instance ?ATTRIBUTE ListingAttribute))
  (instance ?LISTING WebListing))


;; AuctionAttribute
;; -------------------------------------------------------------------

(instance AuctionAttribute ListingAttribute)

(termFormat EnglishLanguage AuctionAttribute "auction attribute")

(documentation AuctionAttribute EnglishLanguage "A &%ListingAttribute of a &%WebListing where the 
 &%creator of the listing &%desires the successful &%Auctioning of the item which is the &%patient
 of the listing.")

(=>
  (and
    (instance ?LISTING WebListing)
    (instance ?ITEM Object)
    (instance ?CREATOR AutonomousAgent)
    (attribute ?LISTING AuctionAttribute)
    (patient ?ITEM ?LISTING)
    (creator ?CREATOR ?LISTING))
  (desires ?CREATOR
    (exists (?AUCTION)
      (and
        (instance ?AUCTION Auctioning)
        (patient ?AUCTION ?ITEM)))))


;; Auctioning:
;; -------------------------------------------------------------------

(subclass Auctioning Selling)

(documentation Auctioning EnglishLanguage "A type of &%Selling where the &%destination of the
 &%patient of the Auctioning (i.e. the item being sold) is the &%AutonomousAgent who placed the highest
 &%bidPrice.")

(termFormat EnglishLanguage Auctioning "auctioning")

(=>
  (instance ?AUCTIONING Auctioning)
  (exists (?ITEM)
    (and
      (instance ?ITEM Object)
      (patient ?AUCTIONING ?ITEM))))

(=>
  (and
    (instance ?AUCTIONING Auctioning)
    (instance ?ITEM Object)
    (patient ?AUCTIONING ?ITEM))
  (exists (?BIDDER ?OFFER)
    (and
      (instance ?BIDDER AutonomousAgent)
      (instance ?OFFER CurrencyMeasure)
      (bidPrice ?ITEM ?OFFER ?BIDDER))))

(=>
  (and
    (instance ?AUCTIONING Auctioning)
    (instance ?BIDDER1 AutonomousAgent)
    (instance ?BIDDER2 AutonomousAgent)
    (instance ?ITEM Object)
    (instance ?U UnitOfCurrency)
    (patient ?AUCTIONING ?ITEM)
    (bidPrice ?ITEM (MeasureFn ?OFFER1 ?U) ?BIDDER1)
    (bidPrice ?ITEM (MeasureFn ?OFFER2 ?U) ?BIDDER2)
    (greaterThan ?OFFER1 ?OFFER2))
  (destination ?AUCTIONING ?BIDDER1))

;; JW: 
;; Needs mapping to wordnet 202244773


;; ForSaleByOwner
;; -------------------------------------------------------------------

(instance ForSaleByOwner ListingAttribute)

(termFormat EnglishLanguage ForSaleByOwner "FSBO")

(documentation ForSaleByOwner EnglishLanguage "A ListingAttribute Where the item which is the
 &%patient is a &%Vehicle and the owner is a &%Human (i.e. not a dealership.")

(=>
  (and
    (instance ?ITEM Object)
    (instance ?LISTING WebListing)
    (attribute ?LISTING ForSaleByOwner)
    (patient ?LISTING ?ITEM))
  (instance ?ITEM Vehicle))

(=>
  (and
    (instance ?ITEM Object)
    (instance ?LISTING WebListing)
    (instance ?OWNER AutonomousAgent)
    (attribute ?LISTING ForSaleByOwner)
    (possesses ?OWNER ?ITEM))
  (instance ?OWNER Human))


;; prohibitedItem
;; -------------------------------------------------------------------

(instance prohibitedItem BinaryPredicate)

(termFormat EnglishLanguage prohibitedItem "prohibited item")

(domain prohibitedItem 1 Object)

(domain prohibitedItem 2 WebSite)

(documentation prohibitedItem EnglishLanguage "(prohibitedItem ?Object ?SITE means that ?ITEM is 
 not allowed to be sold on &%WebSite ?SITE.")
    
(=>
  (prohibitedItem ?ITEM ?SITE)
  (modalAttribute
    (exists (?SELLING)
      (and  
        (instance ?SELLING Selling)
        (eCommerceSite ?SELLING ?SITE)))
    Prohibition))


;; reservePrice
;; -------------------------------------------------------------------

(instance reservePrice BinaryPredicate)

(termFormat EnglishLanguage reservePrice "reserve Price")

(domain reservePrice 1 Auctioning)

(domain reservePrice 2 CurrencyMeasure)

(documentation reservePrice EnglishLanguage "(reservePrice ?AUCTION ?AMOUNT) means that if an 
 &%Auctioning was won (i.e. has a &%destination) then the buyer bid higher than ?AMOUNT.")

(=>
  (and
    (instance ?U UnitOfCurrency)
    (reservePrice ?AUCTION (MeasureFn ?AMOUNT ?U))
    (destination ?AUCTION ?BUYER))
  (exists (?OFFER)
    (and
      (bidPrice ?ITEM (MeasureFn ?OFFER ?U) ?BUYER)
      (greaterThan ?OFFER ?AMOUNT))))


;; webStoreAdvertisement
;; -------------------------------------------------------------------

(instance webStoreAdvertisement BinaryPredicate)

(domain webStoreAdvertisement 1 Advertising)

(domain webStoreAdvertisement 2 WebStore)

(termFormat EnglishLanguage webStoreAdvertisement "web store advertisement")

(documentation webStoreAdvertisement EnglishLanguage "(webstoreAdvertisement ?ADVERT ?STORE) means
 that ?ADVERT is an an instance of &%Advertising which is a component of a &%WebPage which a member
 of the &%WebStore ?STORE.")
    
(=>
  (webStoreAdvertisement ?ADVERT ?STORE)
  (exists (?ITEM ?PAGE)
    (and
      (refers ?ADVERT ?ITEM)
      (component ?ADVERT ?PAGE)
      (instance ?PAGE WebPage)
      (member ?PAGE ?STORE))))


;; unpaidItem
;; -------------------------------------------------------------------

(instance unpaidItem BinaryPredicate)

(domain unpaidItem 1 Object)

(domain unpaidItem 2 AutonomousAgent)

(termFormat EnglishLanguage unpaidItem "unpaid item")

(documentation unpaidItem EnglishLanguage "(unpaidItem ?ITEM ?AGENT) means that ?AGENT &%Promised to
buy ?ITEM, but did not.")
    
(=> 
  (unpaidItem ?ITEM ?AGENT)
  (and
    (modalAttribute 
      (exists (?BUYING)
        (and
          (instance ?BUYING Buying)
          (patient ?BUYING ?ITEM)
          (agent ?BUYING ?AGENT))) Promise)
    (not
      (exists (?BUYING)
        (and
          (instance ?BUYING Buying)
          (patient ?BUYING ?ITEM)
          (agent ?BUYING ?AGENT))))))


;; -------------------------------------------------------------------
;;  STATISTICAL TERMS
;; -------------------------------------------------------------------

;; statisticalPopulation
;; -------------------------------------------------------------------


(instance statisticalPopulation TernaryPredicate)

(domain statisticalPopulation 1 Collection)

(domain statisticalPopulation 2 Collection)

(domain statisticalPopulation 3 Experimenting)

(documentation statisticalPopulation EnglishLanguage "A statistical population is a set of entities
 concerning which statistical inferences are to be drawn. (statisticalPopulation ?SAMPLE_COLL
 ?POP_COLL ?EXPERIMENT) means that the &%Collection ?SAMPLE_COLL is meant to be a representitive
 sample of the population &%Collection ?POP_COLL in the intance of &%Experimenting ?EXPERIMENT.")

(=>
  (and
    (instance ?SAMPLE_COLL Collection)
    (instance ?POP_COLL Collection)
    (instance ?EXPERIMENT Experimenting)
    (statisticalPopulation ?SAMPLE_COLL ?POP_COLL ?EXPERIMENT))
  (subCollection ?SAMPLE_COLL ?POP_COLL))

;; RepresentitiveSample
;; -------------------------------------------------------------------

(instance RepresentativeSample Attribute)

(termFormat EnglishLanguage RepresentativeSample "representative sample")

(documentation RepresentativeSample EnglishLanguage "An &%Attribute that is a &%property of a 
 collection that is the statistical sample in an experiment. If a collection representing the sample
 has the property, then every other attribute that is a property of the collection and is also
 &%inScopeOfInterest of the &%CognitiveAgent performing the experiment is also a property of the 
 collection representing the population.")

 (=>
  (and
    (instance ?SAMPLE_COLL Collection)
    (instance ?POP_COLL Collection)
    (instance ?EXPERIMENT Experimenting)
    (instance ?AGENT CognitiveAgent)
    (agent ?EXPERIMENT ?AGENT)
    (statisticalPopulation ?SAMPLE_COLL ?POP_COLL ?EXPERIMENT))
  (forall (?ATTRIBUTE)
    (=>
      (and
        (instance ?ATTRIBUTE Attribute)
        (property ?SAMPLE_COLL ?ATTRIBUTE)
        (inScopeOfInterest ?AGENT ?ATTRIBUTE)
        (not
          (equal ?ATTRIBUTE RepresentativeSample)))
      (property ?POP_COLL ?ATTRIBUTE))))


;; confidenceInterval
;; -------------------------------------------------------------------

(instance confidenceInterval BinaryPredicate)

(termFormat EnglishLanguage confidenceInterval "confidence interval")

(documentation confidenceInterval EnglishLanguage "(confidenceInterval ?EXPERIMENT ?CONFIDENCE) is
 meant to represent the confidence interval of the conclusions of ?EXPERIMENT. ?CONFIDENCE is a
 number which represents the percentage of the confidence interval. It represents the
 &%ProbabilityFn of the results.")

(domain confidenceInterval 1 Experimenting)

(domain confidenceInterval 2 RealNumber)

(=>
  (and
    (confidenceInterval ?EXPERIMENT ?CONFIDENCE)
    (instance ?EXPERIMENT Experimenting)
    (instance ?FORMULA Formula)
    (patient ?EXPERIMENT ?FORMULA))
  (represents ?CONFIDENCE (ProbabilityFn ?FORMULA)))


(=>
  (and
    (confidenceInterval ?EXPERIMENT ?CONFIDENCE)
    (instance ?EXPERIMENT Experimenting)
    (instance ?FORMULA Formula)
    (patient ?EXPERIMENT ?FORMULA)
    (equal ?CONFIDENCE 100))
  (truth ?FORMULA True))

(=>
  (and
    (confidenceInterval ?EXPERIMENT ?CONFIDENCE)
    (instance ?EXPERIMENT Experimenting)
    (instance ?FORMULA Formula)
    (patient ?EXPERIMENT ?FORMULA)
    (equal ?CONFIDENCE 100))
  (truth ?FORMULA False))

;; pValue
;; -------------------------------------------------------------------

(instance pValue BinaryPredicate)

(termFormat EnglishLanguage pValue "confidence interval")

(documentation pValue EnglishLanguage "(pValue ?EXPERIMENT ?VALUE) is meant to represent the p-value
 of the conclusions of ?EXPERIMENT. ?VALUE is a number which represents the percentage of the
 confidence interval. It represents the &%ProbabilityFn of the results.")

(domain pValue 1 Experimenting)

(domain pValue 2 RealNumber)

(=>
  (and
    (pValue ?EXPERIMENT ?VALUE)
    (instance ?EXPERIMENT Experimenting)
    (instance ?FORMULA Formula)
    (patient ?EXPERIMENT ?FORMULA))
  (represents ?VALUE (ProbabilityFn ?FORMULA)))

(=>
  (and
    (pValue ?EXPERIMENT ?VALUE)
    (instance ?EXPERIMENT Experimenting)
    (instance ?FORMULA Formula)
    (patient ?EXPERIMENT ?FORMULA)
    (equal ?VALUE 0))
  (truth ?FORMULA True))

(=>
  (and
    (pValue ?EXPERIMENT ?VALUE)
    (instance ?EXPERIMENT Experimenting)
    (instance ?FORMULA Formula)
    (patient ?EXPERIMENT ?FORMULA)
    (equal ?VALUE 1))
  (truth ?FORMULA False))

;; tTest
;; -------------------------------------------------------------------

(instance tTest TernaryPredicate)

(termFormat EnglishLanguage tTest "t test result")

(documentation tTest EnglishLanguage "A t-Test is a way testing a hypothesis on the basis of a 
 difference between sample means. Here (tTest ?COLL1 ?COLL2 ?PROB) means that ?PROB is the
 probability that ?COLL1 and ?COLL2 are samples of the same &%statisticalPopulation. This is meant to be used when ?COLL1 and ?COLL2
 are two different &%statisticalPopulations.")
    

(domain tTest 1 Collection)

(domain tTest 2 Collection)

(domain tTest 3 RealNumber)

(=>
  (tTest ?SAMPLE_COLL1 ?SAMPLE_COLL2 ?PROB)
  (exists (?POP1 ?POP2 ?EXPERIMENT)
    (and
      (instance ?POP_COLL1 Collection)
      (instance ?POP_COLL2 Collection)
      (statisticalPopulation ?SAMPLE_COLL1 ?POP_COLL1 ?EXPERIMENT)
      (statisticalPopulation ?SAMPLE_COLL2 ?POP_COLL2 ?EXPERIMENT)
      (equal
        ?PROB
        (ProbabilityFn (equal ?POP1 ?POP2))))))


;; -------------------------------------------------------------------
;; Users and User Accounts
;; -------------------------------------------------------------------


;; accountAtSite
;; -------------------------------------------------------------------

(instance accountAtSite BinaryPredicate)

(termFormat EnglishLanguage accountAtSite "account at site")

(domain accountAtSite 1 UserAccount)

(domain accountAtSite 2 WebSite)

(documentation accountAtSite EnglishLanguage "(accountAtSite ?ACCT ?SITE) means that the 
  &%UserAccount ?ACCT is associate with the &%WebSite ?SITE.")
    

(=>
  (accountAtSite ?ACCT ?SITE)
  (exists (?DATABASE ?SITE_OWNER)
    (and
      (instance ?DATABASE Database)
      (instance ?SITE_OWNER AutonomousAgent)
      (possesses ?SITE_OWNER ?SITE)
      (possesses ?SITE_OWNER ?DATABASE)
      (part ?ACCT ?DATABASE))))


;; AccountAttribute
;; -------------------------------------------------------------------

(subclass AccountAttribute Attribute)

(documentation AccountAttribute EnglishLanguage "A &%Class of &%Attributes pertaining to 
  &%UserAccounts.")

(termFormat EnglishLanguage AccountAttribute "account attribute")

(=>
  (and
    (attribute ?ACCT ?ATTR)
    (instance ?ATTR AccountAttribute))
  (instance ?ACCT UserAccount))


;; BusinessAccount
;; -------------------------------------------------------------------

(instance BusinessAccount AccountAttribute)

(termFormat EnglishLanguage BusinessAccount "business account")

(documentation BusinessAccount EnglishLanguage "This attribute represents that the account is 
  considered to be a business account.")

(=>
  (and
    (instance ?ACCOUNT UserAccount)
    (attribute ?ACCOUNT BusinessAccount)
    (hasAccount ?USER ?ACCOUNT))
  (instance ?USER Business))


;; ConsumerAccount
;; -------------------------------------------------------------------

(instance ConsumerAccount AccountAttribute)

(termFormat EnglishLanguage ConsumerAccount "consumer account")

(documentation ConsumerAccount EnglishLanguage "This attribute represents that the account is 
  considered to be a consumer account.")


;; webCart
;; -------------------------------------------------------------------

(instance webcart TernaryPredicate)

(termFormat EnglishLanguage webcart "web cart")

(documentation webcart EnglishLanguage "(webCart ?USER ?COLL ?SITE) associates a &%Collection of
 &%Objects ?COLL with an &%AutonomousAgent ?USER and a &%WebSite ?SITE. It specifies that ?COLL is the users
 webcart at ?SITE, and that ?USER &%desires to buy the &%members of ?COLL.")

(domain webcart 1 AutonomousAgent)

(domain webcart 2 Collection)

(domain webcart 3 WebSite)

(=>
  (and
    (webcart ?USER ?COLL ?SITE)
    (member ?OBJ ?COLL))
  (instance ?OBJ Object))

(=>
  (and
    (webcart ?USER ?COLL ?SITE)
    (instance ?OBJ Object)
    (member ?OBJ ?COLL))
  (desires ?USER
    (exists (?BUYING)
      (and
        (instance ?BUYING Buying)
        (patient ?BUYING ?OBJ)
        (agent ?BUYING ?USER)))))


;; userFeedbackScore
;; -------------------------------------------------------------------

(instance userFeedbackScore BinaryPredicate)

(termFormat EnglishLanguage userFeedbackScore "user feedback score")

(documentation userFeedbackScore EnglishLanguage "(userFeedbackScore ?ACCOUNT ?SCORE) associates a
 &%UserAccount with a &%RealNumber which represents the scored feedback on that account by other
 users on the same site.")

(domain userFeedbackScore 1 UserAccount)

(domain userFeedbackScore 2 RealNumber)
    

(=>
  (userFeedbackScore ?ACCOUNT ?SCORE)
  (greaterThanOrEqualTo 100 ?SCORE))

(=>
  (userFeedbackScore ?ACCOUNT ?SCORE)
  (greaterThanOrEqualTo ?SCORE 0))


;; browserID
;; -------------------------------------------------------------------

(instance browserID TernaryPredicate)

(documentation browserID EnglishLanguage "Machine identifier based on browser
 cookies. (browserID ?STRING ?BROWSER ?SITE) means that ?STRING is the &%Identifier of the &%Agent
 of &%AccessingWebPage of a &%Webpage which is a &%component of ?SITE, where ?BROWSER was the
 instrument of the accessing. i.e. ?STRING represents the users who use the browser to access the
 site while the string is stored in the browser. &%browserIDs are highly likely to be unique.")

(termFormat EnglishLanguage browserID "browser identifier string")

(domain browserID 1 Identifier)

(domain browserID 2 WebBrowser)

(domain browserID 3 WebSite)

(=>
  (browserID ?STRING ?BROWSER ?SITE)
  (exists (?WEBPAGE ?ACCESSING ?AGENT)
    (and
      (instance ?WEBPAGE WebPage)
      (component ?WEBPAGE ?SITE)
      (instance ?ACCESSING AccessingWebPage)
      (instance ?AGENT AutonomousAgent)
      (agent ?ACCESSING ?AGENT)
      (instrument ?ACCESSING ?BROWSER)
      (destination ?ACCESSING ?WEBPAGE)
      (represents ?STRING ?AGENT))))

(=>
  (browserID ?STRING ?BROWSER ?SITE)
  (modalAttribute
    (not
      (exists (?BROWSER2)
        (and
          (instance ?BROWSER2 WebBrowser)
          (browserID ?STRING ?BROWSER2 ?SITE))))
    Likely))


;; ViewedItemList
;; -------------------------------------------------------------------

(instance viewedItemList BinaryPredicate)

(domain viewedItemList 1 AutonomousAgent)

(domain viewedItemList 2 List)

(termFormat EnglishLanguage viewedItemList "list of viewed items")

(documentation viewedItemList EnglishLanguage "(viewedItemList ?USER ?LIST) relates a &%List
 composed of &%AccessingWebPages in the order visited by ?USER, where each of the &%WebPages which
 are the &%destinations of those accessings is contains a &%WebListing. The most recent
 &%AccessingWebPage is at index 1")

(=>
  (and
    (viewedItemList ?USER ?LIST)
    (inList ?ACCESSING ?LIST))
  (and
    (instance ?ACCESSING AccessingWebPage)
    (agent ?ACCESSING ?USER)
    (exists (?DEST)
      (and
        (instance ?DEST WebPage)
        (destination ?ACCESSING WebPage)))))

(=>
  (and
    (viewedItemList ?USER ?LIST)
    (instance ?ACCESSING AccessingWebPage)
    (equal
      (FirstFn ?LIST)
      ?ACCESSING))
  (not
    (exists (?ACCESSING2)
      (and
        (instance ?ACCESSING2 AccessingWebPage)
        (agent ?ACCESSING2 ?USER)
        (earlier
          (WhenFn ?ACCESSING2)
          (WhenFn ?ACCESSING))))))

(=>
  (and
    (viewedItemList ?USER ?LIST)
    (instance ?ACCESSING1 AccessingWebPage)
    (instance ?ACCESSING2 AccessingWebPage)
    (agent ?ACCESSING1 ?USER)
    (agent ?ACCESSING2 ?USER)
    (instance ?INDEX1 PositiveInteger)
    (instance ?INDEX2 PositiveInteger)
    (equal
      (ListOrderFn ?LIST ?INDEX1)
      ?ACCESSING1)
    (equal
      (ListOrderFn ?LIST ?INDEX2)
      ?ACCESSING2)
    (greaterThan ?INDEX1 ?INDEX2))
  (earlier
    (WhenFn ?ACCESSING2)
    (WhenFn ?ACCESSING1)))


;; webPurchases
;; -------------------------------------------------------------------

(instance webPurchases TernaryPredicate)

(domain webPurchases 1 Collection)

(domain webPurchases 2 Human)

(domain webPurchases 3 WebSite)

(documentation webPurchases EnglishLanguage "(webPurchases ?COLLECTION ?HUMAN) relates a
 collection of all instances of &%Buying by a &%Human on the &%WebSite.")

(termFormat EnglishLanguage webPurchases "web purchases")

(=>
  (webPurchases ?PURCHASES ?BUYER ?SITE)
  (forall (?BUYING)
    (=>
      (and
        (instance ?BUYING Buying)
        (agent ?BUYING ?BUYER)
        (eCommerceSite ?BUYING ?SITE))
      (member ?BUYING ?PURCHASES))))

(=>
  (and
    (webPurchases ?PURCHASES ?BUYER ?SITE)
    (member ?BUYING ?PURCHASES))
  (and
    (instance ?BUYING Buying)
    (agent ?BUYING ?BUYER)
    (eCommerceSite ?BUYING ?SITE)))


;; registeredUser
;; -------------------------------------------------------------------

(instance registeredUser BinaryPredicate)

(domain registeredUser 1 AutonomousAgent)

(domain registeredUser 2 WebSite)

(documentation registeredUser EnglishLanguage "(registedUser ?AGENT ?SITE) means that ?AGENT is a 
 registered user at the &%WebSite ?SITE - i.e. ?AGENT &%hasAccount a &%UserAccount and that
 &%UserAccount is an &%accountAtSite ?SITE. This also means that there is a part of the
 &%userDatabase of ?SITE that represents the ?AGENT.")

(termFormat EnglishLanguage registeredUser "registered user")

(=>
  (registeredUser ?USER ?WEBSITE)
  (exists (?DATABASE ?PART)
    (and
      (userDatabase ?DATABASE ?WEBSITE)
      (part ?PART ?DATABASE)
      (represents ?PART ?USER))))
      
(=>
  (registeredUser ?USER ?SITE)
  (exists (?ACCT)
    (and
      (instance ?ACCT UserAccount)
      (hasAccount ?USER ?ACCT)
      (accountAtSite ?ACCT ?SITE))))

(=>
  (and
    (accountAtSite ?ACCOUNT ?SITE)
    (hasAccount ?USER ?ACCOUNT))
  (registeredUser ?USER ?SITE))


;; confirmedRegisteredUser
;; -------------------------------------------------------------------

(instance confirmedRegisteredUser BinaryPredicate)

(domain confirmedRegisteredUser 1 AutonomousAgent)

(domain confirmedRegisteredUser 2 WebSite)

(termFormat EnglishLanguage confirmedRegisteredUser "confirmed registed user")

(documentation confirmedRegisteredUser EnglishLanguage "(confirmedRegisteredUser ?AGENT ?SITE) means
 that the &%AutonomousAgent ?Agent is a &%registeredUser of &%WebSite ?SITE, and has confirmed that 
 registration by responding to a registration email.")

(=>
  (confirmedRegisteredUser ?USER ?SITE)
  (registeredUser ?USER ?SITE))


;; webSales
;; -------------------------------------------------------------------

(instance webSales TernaryPredicate)

(domain webSales 1 Collection)

(domain webSales 2 Human)

(domain webSales 3 WebSite)

(documentation webSales EnglishLanguage "(webSales ?COLLECTION ?HUMAN ?SITE) relates a &%collection
 of all instances of &%Selling by a &%Human on the ?SITE.")

(termFormat EnglishLanguage webSales "web sales")
    
(=>
  (webSales ?SALES ?SELLER ?SITE)
  (forall (?SELLING)
    (=>
      (and
        (instance ?SELLING Selling)
        (agent ?SELLING ?SELLER)
        (eCommerceSite ?SELLING ?SITE))
      (member ?SELLING ?SALES))))

(=>
  (and
    (webSales ?SALES ?SELLER ?SITE)
    (member ?SELLING ?SALES))
  (and
    (instance ?SELLING Selling)
    (agent ?SELLING ?SELLER)
    (eCommerceSite ?SELLING ?SITE)))


;; webSeller
;; -------------------------------------------------------------------

(instance webSeller BinaryPredicate)

(domain webSeller 1 Human)

(domain webSeller 2 WebSite)

(termFormat EnglishLanguage webSeller "web seller")

(documentation webSeller EnglishLanguage "(webSeller ?SELLER ?SITE) means that item is advertised on
 the &%WebSite ?SITE and ?SELLER &%desires there to be a &%selling (implicitly of that item) where
 ?SELLER is the agent.")
    
(=>
  (webSeller ?SELLER ?SITE)
  (exists (?LISTING)
    (and
      (instance ?LISTING WebListing)
      (listingSeller ?LISTING ?SELLER)
      (hostedOn ?LISTING ?SITE))))
     
(=>
  (webSeller ?SELLER ?SITE)
  (desires ?SELLER 
    (exists (?SELLING)
      (and
        (instance ?SELLING Selling)
        (agent ?SELLING ?SELLER)))))


;; SellersItemsFn
;; -------------------------------------------------------------------

(instance SellersItemsFn BinaryFunction)

(domain SellersItemsFn 1 AutonomousAgent)

(domain SellersItemsFn 2 WebSite)

(range SellersItemsFn Collection)

(termFormat EnglishLanguage SellersItemsFn "sellers items")

(documentation SellersItemsFn EnglishLanguage "(SellersItemsFn ?AGENT ?SITE) is a &%BinaryFunction 
 that returns a &%Collection of the items for sale by ?AGENT on the &%WebSite ?SITE")

(=>
  (and
    (instance ?AGENT AutonomousAgent)
    (instance ?SITE WebSite))
  (exists (?COLL)
    (and
      (instance ?COLL Collection)
      (forall (?LISTING)
        (=>
          (and
            (instance ?LISTING WebListing)
            (hostedOn ?LISTING ?SITE)
            (listingSeller ?LISTING ?AGENT))
          (member ?LISTING ?COLL)))
      (equal
        (SellersItemsFn ?AGENT ?SITE)
        ?COLL))))


;; SellersOtherItemsFn
;; -------------------------------------------------------------------

(instance SellersOtherItemsFn QuaternaryFunction)

(domain SellersOtherItemsFn 1 AutonomousAgent)

(domain SellersOtherItemsFn 2 WebSite)

(domain SellersOtherItemsFn 3 WebListing)

(domain SellersOtherItemsFn 4 TimePoint)

(range SellersOtherItemsFn Collection)

(termFormat EnglishLanguage SellersOtherItemsFn "sellers other items")

(documentation SellersOtherItemsFn EnglishLanguage "(SellersOtherItemsFn ?AGENT ?SITE ?LISTING 
 ?TIMEPOINT) returns a &%Collection of all &%WebListings except ?LISTING &%hostedOn ?SITE where 
 ?AGENT is the &%listingSeller and where ?TIMEPOINT is a &%Temporal part of &%WhenFn of those 
 &%WebListings.")

(=>
  (and
    (instance ?COLL Collection)
    (instance ?SITE WebSite)
    (instance ?AGENT AutonomousAgent)
    (instance ?LISTING WebListing)
    (instance ?TIME TimePoint)
    (listingSeller ?LISTING ?AGENT)
    (not
      (member ?LISTING ?COLL))
    (forall (?ITEM ?MEMBER)
      (and
        (=>
          (and
            (instance ?ITEM WebListing)
            (member ?ITEM (SellersItemsFn ?AGENT ?SITE))
            (temporalPart ?TIME (WhenFn ?ITEM))
            (not
              (equal ?ITEM ?LISTING)))
          (member ?ITEM ?COLL))
        (=>
          (member ?MEMBER ?COLL)
          (and
            (temporalPart ?TIME (WhenFn ?ITEM))
            (instance ?MEMBER WebListing))))))
  (equal
    (SellersOtherItemsFn ?AGENT ?SITE ?LISTING ?TIME)
    ?COLL))

;; underageUser
;; ------------------------------------------------------------------- 

(instance underageUser BinaryPredicate)

(domain underageUser 1 Human)

(domain underageUser 2 WebSite)

(documentation underageUser EnglishLanguage "(underageUser ?HUMAN ?SITE) means that ?HUMAN is a 
  &%webVisitor of ?SITE but is under 18 years old.")

(=>
  (underageUser ?HUMAN ?SITE)
  (webVisitor ?HUMAN ?SITE))

(=>
  (and
    (underageUser ?HUMAN ?SITE)
    (age ?HUMAN (MeasureFn ?AGE YearDuration)))
  (greaterThanOrEqualTo ?AGE 18))

;; UserIDString
;; -------------------------------------------------------------------

(instance userIDString BinaryRelation)

(domain userIDString 1 Identifier)

(domain userIDString 2 UserAccount)

(documentation userIDString EnglishLanguage "(userIDString ?STRING ?ACCOUNT) Associates an 
 &%Identifer ?STRING to a &%UserAccount ?ACCOUNT. The ?STRING &%represents the user which
 &%hasAccount ?ACCOUNT. Every &%UserAccount has a &%userIDString. They are likely to be unique.")

(termFormat EnglishLanguage userIDString "user identifier string")

(=>
  (and
    (userIDString ?STRING ?ACCOUNT)
    (hasAccount ?USER ?ACCOUNT))
  (represents ?STRING ?USER))

(=>
  (instance ?ACCOUNT UserAccount)
  (exists (?STRING)
    (and
      (instance ?STRING Identifier)
      (userIDString ?STRING ?ACCOUNT))))

(=>
  (userIDString ?STRING ?ACCOUNT)
  (modalAttribute
    (not
      (exists (?ACCOUNT2)
        (and
          (instance ?ACCOUNT2 UserAccount)
          (userIDString ?STRING ?ACCOUNT2))))
  Likely))


;; VistorProfile
;; -------------------------------------------------------------------

(subclass VisitorProfile Collection)

(termFormat EnglishLanguage VisitorProfile "visitor profile")

(documentation VisitorProfile EnglishLanguage "A type of &%Collection of &%Formulas which are known 
 by someone who &%possesses a &%WebSite. All the &%members of this collection refer to a common 
 &%AutonomousAgent, and &%visitorParameters of a common &%WebSite")

(=>
  (and
    (instance ?PROFILE VisitorProfile)
    (member ?FORMULA ?PROFILE))
  (instance ?FORMULA Formula))

(=>
  (instance ?PROFILE VisitorProfile)
  (exists (?USER ?SITE)
    (and
      (instance ?USER AutonomousAgent)
      (instance ?SITE WebSite)
      (forall (?FORMULA)
        (=>
          (and
            (member ?FORMULA ?PROFILE)
            (instance ?FORMULA Formula))
          (visitorParameter ?USER ?FORMULA ?SITE))))))


;; vistorParameter
;; -------------------------------------------------------------------

(instance visitorParameter TernaryPredicate)

(termFormat EnglishLanguage visitorParameter "visitor profile parameter")

(domain visitorParameter 1 AutonomousAgent)

(domain visitorParameter 2 Formula)

(domain visitorParameter 3 WebSite)

(documentation visitorParameter EnglishLanguage "Links a &%webVisitor of a &%webSite to facts known 
about that visitor by someone who &%possesses that website. These facts are &%Formulas which &%refer
to the user. These formulas are part of the user's &%VistorProfile.")

(=>
  (visitorParameter ?VISITOR ?FORMULA ?SITE)
  (webVisitor ?VISITOR ?SITE))

(=>
  (visitorParameter ?VISITOR ?FORMULA ?SITE)
  (refers ?FORMULA ?USER))

(=>
  (visitorParameter ?VISITOR ?FORMULA ?SITE)
  (exists (?AGENT)
    (and
      (instance ?AGENT CognitiveAgent)
      (possesses ?AGENT ?SITE)
      (knows ?AGENT ?FORMULA))))

(=>
  (visitorParameter ?VISITOR ?FORMULA ?SITE)
  (exists (?PROFILE)
    (and
      (instance ?PROFILE VisitorProfile)
      (member ?FORMULA ?PROFILE))))


;; webVisitor
;; -------------------------------------------------------------------

(instance webVisitor BinaryPredicate)

(domain webVisitor 1 Human)

(domain webVisitor 2 WebSite)

(termFormat EnglishLanguage webVisitor "web visitor")

(documentation webVisitor EnglishLanguage "(webvisitor ?HUMAN ?SITE) means that there exists an
 &%AccessingWebPage where ?HUMAN is the agent, and the page accessed is a component of ?SITE.")
    
(=>
  (webVisitor ?VISITOR ?SITE)
  (exists (?ID ?BROWSER)
    (and
      (instance ?ID Identifier)
      (instance ?BROWSER WebBrowser)
      (browserID ?ID ?BROWSER ?SITE)
      (represents ?ID ?VISITOR))))

(=>
  (webVisitor ?VISITOR ?SITE)
  (exists (?ACCESSING ?PAGE)
    (and
      (instance ?ACCESSING AccessingWebPage)
      (instance ?PAGE WebPage)
      (patient ?ACCESSING ?PAGE)
      (component ?PAGE ?SITE)
      (agent ?ACCESSING ?VISITOR))))


;; watchingListings
;; -------------------------------------------------------------------

(instance watchingListings TernaryPredicate)

(documentation watchingListings EnglishLanguage "(watchingListings ?USER ?COLL ?SITE) relates a 
 &%registeredUser of the &%WebSite ?SITE to the &%Collection ?COLL of items that user is 'watching' 
 on the site. It is likely the user &%desires there to be &%Buyings of the &%Objects which are
 the &%patients of the &%Listings being watched.")

(termFormat EnglishLanguage watchingListings "watching listings")

(domain watchingListings 1 AutonomousAgent)

(domain watchingListings 2 Collection)

(domain watchingListings 3 WebSite)

(=>
  (watchingListings ?USER ?COLL ?SITE)
  (registeredUser ?USER ?SITE))

(=>
  (and
    (watchingListings ?USER ?COLL ?SITE)
    (member ?LISTING ?COLL))
  (instance ?LISTING WebListing))

(=>
  (and
    (watchingListings ?USER ?COLL ?SITE)
    (instance ?LISTING WebListing)
    (instance ?OBJ Object)
    (patient ?LISTING ?OBJ)
    (member ?LISTING ?COLL))
  (modalAttribute
    (desires ?USER
      (exists (?BUYING)
        (and
          (instance ?BUYING Buying)
          (patient ?BUYING ?OBJ)
          (agent ?BUYING ?USER))))
    Likely))


;; customerValue
;; -------------------------------------------------------------------

(instance customerValue TernaryRelation)

(termFormat EnglishLanguage customerValue "customer value")

(domain customerValue 1 Human)

(domain customerValue 2 Business)

(domain customerValue 3 CurrencyMeasure)

(documentation customerValue EnglishLanguage "(customerValue ?HUM ?BUS ?AMOUNT) means that the 
 &%CurrencyMeasure ?AMOUNT is a representation of how much the &%Human ?HUM (who is presumably a 
 current or potential customer) is worth to the &%Business ?BUS.")

;; JW: Blank for now, as this is pretty subjective to each busines. Would be nice to relate it in 
;; some way to &%monetaryValue, but that is a universal assessment of value.


;; -------------------------------------------------------------------
;; USER ACTIONS
;; -------------------------------------------------------------------


;; AddToCart
;; -------------------------------------------------------------------

(subclass AddToCart Process)

(termFormat EnglishLanguage AddToCart "add to cart")

(documentation AddToCart EnglishLanguage "A &%Process where the &%patient was not a &%member of the 
&%agent's &%webcart &%collection before the &%EndFn of the &%AddToCart, but is afterward. This 
&%proccess signifies that the &%agent &%desires there to be a &%buying in which the item which is 
the &%patient and the &%agent is also the &%agent of the buying.")
    
(=>
  (and
    (instance ?ATC AddToCart)
    (instance ?USER AutonomousAgent)
    (instance ?OBJ Object)
    (agent ?ATC ?USER)
    (patient ?ATC ?OBJ))
  (desires ?USER
    (exists (?BUYING)
      (and
        (instance ?BUYING Buying)
        (patient ?BUYING ?OBJ)
        (agent ?BUYING ?USER)))))

(=>
  (and
    (instance ?ATC AddToCart)
    (instance ?OBJ Object)
    (patient ?ATC ?OBJ)
    (agent ?ATC ?USER))
  (exists (?COLL ?SITE ?AFTER)
    (and
      (instance ?COLL Collection)
      (instance ?SITE WebSite)
      (instance ?INTERVAL TimeInterval)
      (webcart ?USER ?COLL ?SITE)
      (equal
        (BeginFn ?INTERVAL)
        (EndFn ?ATC))
      (holdsDuring ?AFTER
        (member ?OBJ ?COLL)))))


;; Bidding
;; -------------------------------------------------------------------

(subclass Bidding Requesting)

(termFormat EnglishLanguage Bidding "bidding")

(documentation Bidding EnglishLanguage "A &%Requesting where the &%patient is a &%Formula specifying
 that there is a &%Buying for a certain &%transactionAmount, where the &%agent of the &%Bidding is 
 the &%agent of the &%Buying.")


;(=>
;  (and
;    (instance ?BIDDING Bidding)
;    (patient ?BIDDING ?FORMULA))
;  (exists (?ITEM ?AMOUNT)
;    (and
;      (instance ?ITEM Physical)
;      (instance ?AMOUNT CurrencyMeasure)
;      (equal
;        ?FORMULA
;        (exists (?BUYING)
;          (and
;            (instance ?BUYING Buying)
;            (agent ?BUYING ?BUYER)
;            (patient ?BUYING ?ITEM)
;            (transactionAmount ?BUYING ?AMOUNT)))))))

;(=>
;  (and
;    (instance ?BIDDING Bidding)
;    (patient ?BIDDING ?FORMULA)
;    (objectOfBid ?BIDDING ?ITEM))
;  (exists (?AMOUNT)
;    (and
;      (instance ?AMOUNT CurrencyMeasure)
;      (equal
;        ?FORMULA
;        (exists (?BUYING)
;          (and
;            (instance ?BUYING Buying)
;            (agent ?BUYING ?BUYER)
;            (patient ?BUYING ?ITEM)
;            (transactionAmount ?BUYING ?AMOUNT)))))))

;(=>
;  (and
;    (instance ?BIDDING Bidding)
;    (patient ?BIDDING ?FORMULA)
;    (amountOfBid ?BIDDING ?AMOUNT))
;  (exists (?ITEM)
;    (and
;      (instance ?ITEM Physical)
;      (equal
;        ?FORMULA
;        (exists (?BUYING)
;          (and
;            (instance ?BUYING Buying)
;            (agent ?BUYING ?BUYER)
;            (patient ?BUYING ?ITEM)
;            (transactionAmount ?BUYING ?AMOUNT)))))))

(=>
  (bidPrice ?OBJECT ?AMOUNT ?AGENT)
  (exists (?BIDDING)
    (and
      (instance ?BIDDING Bidding)
      (objectOfBid ?BIDDING ?OBJECT)
      (amountOfBid ?BIDDING ?AMOUNT)
      (agent ?BIDDING ?AGENT))))

(=>
  (and
    (instance ?BIDDING Bidding)
    (instance ?OBJECT Physical)
    (instance ?AMOUNT CurrencyMeasure)
    (instance ?AGENT ?AGENT)
    (objectOfBid ?BIDDING ?OBJECT)
    (amountOfBid ?BIDDING ?AMOUNT)
    (agent ?BIDDING ?AGENT))
  (bidPrice ?OBJECT ?AMOUNT ?AGENT))


;; Needs mapping to wordnet #202298632
;; JW: bidprice needs domain 1 changed to from "Object" to Physical"
;; JW: This and the CaseRoles below need to be merged with &%OfferingToPurchase


;; objectOfBid
;; -------------------------------------------------------------------

(instance objectOfBid CaseRole)

(domain objectOfBid 1 Bidding)

(domain objectOfBid 2 Physical)

(termFormat EnglishLanguage objectOfBid "object of bidding")

(documentation objectOfBid EnglishLanguage "A &%CaseRole of &%Bidding identifying the &%instance of 
&%Physical being bid on.")
    

;; amountOfBid
;; -------------------------------------------------------------------

(instance amountOfBid CaseRole)

(domain amountOfBid 1 Bidding)

(domain amountOfBid 2 CurrencyMeasure)

(termFormat EnglishLanguage amountOfBid "bid amount")

(documentation amountOfBid EnglishLanguage "A &%CaseRole of &%Bidding identifying the 
&%CurrencyMeasure of the bid.")


;; Checkout
;; -------------------------------------------------------------------

(subclass Checkout Process)

(documentation Checkout EnglishLanguage "The final &%subProcess of a &%Buying - i.e. there does not 
exist any &%subProcess of the &%Buying of which the &%Checkout is a &%subProcess that where the 
&%Checkout occurs &%earier.")

(termFormat EnglishLanguage Checkout "checkout")

(=>
  (instance ?CHECKOUT Checkout)
  (exists (?BUYING)
    (and
      (instance ?BUYING Buying)
      (subProcess ?CHECKOUT ?BUYING)
      (not
        (exists (?PROCESS)
          (and
            (subProcess ?PROCESS ?BUYING)
            (earlier (WhenFn ?CHECKOUT) (WhenFn ?PROCESS))))))))


;; TTFxFn
;; -------------------------------------------------------------------

(instance TTFxFn BinaryFunction)

(documentation TTFxFn EnglishLanguage "(TTFxFn ?CLASS ?ACCESSING) returns a &%TimeInterval where the
 &%BeginFn is the begining of the &%AccessingWebPage ?ACCESSING and and the &%EndFn is the &%BeginFn
  of the first &%instance of a &%Process of &%class ?CLASS that occcurs &%during ?ACCESSING, and the
  &%agent of that &%Proccess is the same as the &%agent of the ?ACCESSING.")

(termFormat EnglishLanguage TTFxFn "TTFx")

(domain TTFxFn 1 Class)

(domain TTFxFn 2 AccessingWebPage)

(range TTFxFn TimeInterval)

(=>
  (and
    (instance ?PROCESS ?PROCESS_CLASS)
    (subclass ?PROCESS_CLASS Process)
    (instance ?ACCESSING AccessingWebPage)
    (instance ?AGENT AutonomousAgent)
    (agent ?PROCESS ?AGENT)
    (agent ?ACCESSING ?AGENT)
    (during ?PROCESS ?ACCESSING)
    (instance ?TIMETOFIRST TimeInterval)
    (not
      (exists (?PROCESS2)
        (and
          (instance ?PROCESS2 ?PROCESS_CLASS)
          (agent ?PROCESS2 ?AGENT)
          (during ?PROCESS2 ?ACCESSING)
          (before (BeginFn (WhenFn ?PROCESS2)) (BeginFn (WhenFn ?PROCESS))))))
    (equal
      (BeginFn (WhenFn ?ACCESSING)) (BeginFn (WhenFn ?TIMETOFIRST)))
    (equal
      (BeginFn (WhenFn ?PROCESS)) (EndFn (WhenFn ?TIMETOFIRST))))
  (equal
    (TTFxFn ?PROCESS_CLASS ?ACCESSING) ?TIMETOFIRST))


;; viewedListing
;; -------------------------------------------------------------------

(instance viewedListing BinaryPredicate)

(documentation viewedListing EnglishLanguage "(viewedListing ?AGENT ?LISTING) means that there is an
  instance of &%AccessingWebPage where ?AGENT is the &%agent of the accessing and a &%component
  of the page is the &%WebListing ?LISTING")

(termFormat EnglishLanguage viewedListing "viewed listing")

(domain viewedListing 1 AutonomousAgent)

(domain viewedListing 2 WebListing)

(=>
  (viewedListing ?AGENT ?LISTING)
  (exists (?PAGE ?ACCESSING)
    (and
      (instance ?PAGE WebPage)
      (instance ?ACCESSING AccessingWebPage)
      (component ?LISTING ?PAGE)
      (agent ?ACCESSING ?AGENT)
      (destination ?ACCESSING ?PAGE))))


;; ViewItemRequest
;; -------------------------------------------------------------------

(subclass ViewItemRequest UserSignifiedAction)

(documentation ViewItemRequest EnglishLanguage "A &%UserSignifiedAction with the &%subProcess of
 &%RequestingHyperLink, where the &%RequestingHyperlink causes the the &%AccessingWebPage, and the 
 &%WebPage being accessed is a &%ViewItemPage. If ?AGENT views ?LISTING as part of a &%ViewItemRequest, 
 then (viewedListing ?AGENT ?LISTING) holds.")

(termFormat EnglishLanguage ViewItemRequest "view item request")

(=>
  (instance ?REQUEST ViewItemRequest)
  (exists (?CLICK ?ACCESSING ?PAGE)
    (and
      (instance ?CLICK RequestingHyperlink)
      (instance ?PAGE ViewItemPage)
      (instance ?ACCESSING AccessingWebPage)
      (causes ?CLICK ?ACCESSING)
      (destination ?ACCESSING ?PAGE)
      (subProcess ?CLICK ?REQUEST))))

(=>
  (and
    (instance ?REQUEST ViewItemRequest)
    (instance ?ACCESSING AccessingWebPage)
    (instance ?PAGE ViewItemPage)
    (instance ?AGENT AutonomousAgent)
    (instance ?LISTING Advertising)
    (subProcess ?ACCESSING ?REQUEST)
    (component ?PAGE ?LISTING)
    (destination ?ACCESSING ?PAGE)
    (agent ?ACCESSING ?AGENT))
  (viewedListing ?AGENT ?LISTING))


;; WatchItem
;; -------------------------------------------------------------------

(subclass WatchItem Process)

(termFormat EnglishLanguage WatchItem "watch item")

(documentation WatchItem EnglishLanguage "A &%Process where the &%patient was not a &%member of the 
&%agent's &%watchingListings &%collection before the &%EndFn of the &%WatchItem, but is afterward. 
This &%proccess signifies that the &%Object which is the &%patient of the &%WatchItem is 
&%inScopeOfInterest for the &%agent.")

(=>
  (and
    (instance ?WATCH WatchItem)
    (instance ?AGENT AutonomousAgent)
    (instance ?OBJ Object)
    (agent ?WATCH ?AGENT)
    (patient ?WATCH ?OBJ))
  (inScopeOfInterest ?AGENT ?OBJ))

(=>
  (and
    (instance ?WATCH WatchItem)
    (instance ?OBJ Object)
    (patient ?WATCH ?OBJ)
    (agent ?WATCH ?USER))
  (exists (?COLL ?SITE ?AFTER)
    (and
      (instance ?COLL Collection)
      (instance ?SITE WebSite)
      (instance ?INTERVAL TimeInterval)
      (watchingListings ?USER ?COLL ?SITE)
      (equal
        (BeginFn ?INTERVAL)
        (EndFn ?WATCH))
      (holdsDuring ?AFTER
        (member ?OBJ ?COLL)))))


;; -------------------------------------------------------------------
;; TRANSACTIONS
;; -------------------------------------------------------------------

;; TransactionAttribute
;; -------------------------------------------------------------------

(subclass TransactionAttribute Attribute)

(termFormat EnglishLanguage TransactionAttribute "transaction attribute")

(documentation TransactionAttribute EnglishLanguage "A class of &%Attributes pertaining to 
  &%FinancialTransactions.")

(=>
  (and
    (attribute ?TRANS ?ATTR)
    (instance ?ATTR AccountAttribute))
  (instance ?TRANS FinancialTransaction))


;; BestOffering
;; -------------------------------------------------------------------

(subclass BestOffering OfferingToPurchase)

(documentation BestOffering EnglishLanguage "A case of &%OfferingToPurchase where there does not
 exist another instance of &%OfferingToPurchase the same &%Object at a higher price.")

(termFormat EnglishLanguage BestOffering "best offer")

(=>
  (instance ?BEST_OFFER BestOffering)
  (and
    (containsInformation ?BEST_OFFER
      (exists (?BUYING)
          (and
            (instance ?BUYING Buying)
            (agent ?BUYING ?AGENT)
            (patient ?BUYING ?OBJECT)
            (transactionAmount ?BUYING 
              (MeasureFn ?MONEY1 ?U)))))
    (not
      (exists (?OFFER2)
          (containsInformation ?OFFER2
            (exists (?BUYING2 ?AGENT2 ?MONEY2)
              (and
                (instance ?BUYING2 Buying)
                (agent ?BUYING2 ?AGENT2)
                (patient ?BUYING2 ?OBJECT)
                (transactionAmount ?BUYING2 
                  (MeasureFn ?MONEY2 ?U))
                (greaterThan ?MONEY2 ?MONEY1))))))))

;; broker
;; -------------------------------------------------------------------

(instance broker CaseRole)

(termFormat EnglishLanguage broker "broker")
(format EnglishLanguage broker "%2 brokers the sale of %1")

(domain broker 1 FinancialTransaction)
(domain broker 2 AutonomousAgent)

(documentation broker EnglishLanguage "This &%CaseRole relates an instance of a
 &%FinancialTransaction to the &%Broker of the sale.")

(=>
  (broker ?SALE ?AGENT)
  (attribute ?AGENT Broker)) 

;; JW:
;; Broker already exists but is undefined in SUMO
;; Need richer model of &%FinanacialTransaction to define completely.


;; eCommerceSite
;; -------------------------------------------------------------------

(instance eCommerceSite CaseRole)

(domain eCommerceSite 1 FinancialTransaction)

(domain eCommerceSite 2 WebSite)

(subrelation eCommerceSite instrument)

(subrelation eCommerceSite broker)

(documentation eCommerceSite EnglishLanguage "This &%CaseRole relates an instance of a
 &%FinancialTransaction to the &%WebSite that facilitaed the sale.")


;; BusinessToBusiness
;; -------------------------------------------------------------------

(instance BusinessToBusiness TransactionAttribute)

(termFormat EnglishLanguage BusinessToBusiness "business to business transaction")

(documentation BusinessToBusiness EnglishLanguage "A &%FinancialTransaction where both the &%agent
  and the &%destination &%hasAccount &%BusinessAcounts")

(=>
  (and
    (instance ?TRANS FinancialTransaction)
    (attribute ?TRANS BusinessToBusiness))
  (exists (?ACCT1 ?ACCT2 ?USER1 ?USER2 ?SITE)
    (and
      (instance ?ACCT1 UserAccount)
      (instance ?ACCT2 UserAccount)
      (instance ?USER1 AutonomousAgent)
      (instance ?USER2 AutonomousAgent)
      (instance ?SITE WebSite)
      (agent ?TRANS ?USER1)
      (destination ?TRANS ?USER2)
      (instrument ?TRANS ?SITE)
      (hasAccount ?USER1 ?ACCT1)
      (hasAccount ?USER2 ?ACCT2)
      (accountAtSite ?ACCT1 ?SITE)
      (accountAtSite ?ACCT2 ?SITE)
      (attribute ?ACC1 BusinessAccount)
      (attribute ?ACC2 BusinessAccount))))


;; BusinessToConsumer
;; -------------------------------------------------------------------

(instance BusinessToConsumer TransactionAttribute)

(termFormat EnglishLanguage BusinessToConsumer "business to consumer transaction")

(documentation BusinessToConsumer EnglishLanguage "A &%FinancialTransaction where the &%agent has a
  &%BusinessAccount and the &%destination has a &%ConsumerAccount")

(=>
  (and
    (instance ?TRANS FinancialTransaction)
    (attribute ?TRANS BusinessToConsumer))
  (exists (?ACCT1 ?ACCT2 ?USER1 ?USER2 ?SITE)
    (and
      (instance ?ACCT1 UserAccount)
      (instance ?ACCT2 UserAccount)
      (instance ?USER1 AutonomousAgent)
      (instance ?USER2 AutonomousAgent)
      (instance ?SITE WebSite)
      (agent ?TRANS ?USER1)
      (destination ?TRANS ?USER2)
      (instrument ?TRANS ?SITE)
      (hasAccount ?USER1 ?ACCT1)
      (hasAccount ?USER2 ?ACCT2)
      (accountAtSite ?ACCT1 ?SITE)
      (accountAtSite ?ACCT2 ?SITE)
      (attribute ?ACCOUNT1 BusinessAccount)
      (attribute ?ACCOUNT2 ConsumerAccount))))


;; ConsumerToConsumer
;; -------------------------------------------------------------------

(instance ConsumerToConsumer TransactionAttribute)

(termFormat EnglishLanguage ConsumerToConsumer "consumer to consumer transaction")

(documentation ConsumerToConsumer EnglishLanguage "A &%FinancialTransaction where both the &%agent
  and the &%destination &%hasAccount &%ConsumerAccounts")

(=>
  (and
    (instance ?TRANS FinancialTransaction)
    (attribute ?TRANS ConsumerToConsumer))
  (exists (?ACCT1 ?ACCT2 ?USER1 ?USER2 ?SITE)
    (and
      (instance ?ACCT1 UserAccount)
      (instance ?ACCT2 UserAccount)
      (instance ?USER1 AutonomousAgent)
      (instance ?USER2 AutonomousAgent)
      (instance ?SITE WebSite)
      (agent ?TRANS ?USER1)
      (destination ?TRANS ?USER2)
      (instrument ?TRANS ?SITE)
      (hasAccount ?USER1 ?ACCT1)
      (hasAccount ?USER2 ?ACCT2)
      (accountAtSite ?ACCT1 ?SITE)
      (accountAtSite ?ACCT2 ?SITE)
      (attribute ?ACCOUNT1 ConsumerAccount)
      (attribute ?ACCOUNT2 ConsumerAccount))))


;; CBT
;; -------------------------------------------------------------------

(instance CBT TransactionAttribute)

(documentation CBT EnglishLanguage "A &%TransactionAtrribute signifying that the buyer and seller 
 are &%located in different &%GeoPoliticalAreas.")

(termFormat EnglishLanguage CBT "cross border trade")

(=>
  (and
    (instance ?TRANS Selling)
    (attribute ?TRANS CBT)
    (patient ?TRANS ?OBJ)
    (instance ?OBJ Object))
  (exists (?SELLER ?BUYER ?BUYER_LOCATION ?SELLER_LOCATION)
    (and
      (instance ?BUYER AutonomousAgent)
      (instance ?SELLER AutonomousAgent)
      (destination ?TRANS ?BUYER)
      (agent ?TRANS ?SELLER)
      (instance ?BUYER_LOCATION GeopoliticalArea)
      (instance ?SELLER_LOCATION GeopoliticalArea)
      (located ?SELLER ?SELLER_LOCATION)
      (located ?BUYER ?BUYER_LOCATION)
      (not
        (equal ?BUYER_LOCATION ?SELLER_LOCATION)))))

(=>
  (and
    (instance ?TRANS Buying)
    (attribute ?TRANS CBT)
    (patient ?TRANS ?OBJ)
    (instance ?OBJ Object))
  (exists (?SELLER ?BUYER ?BUYER_LOCATION ?SELLER_LOCATION)
    (and
      (instance ?BUYER AutonomousAgent)
      (instance ?SELLER AutonomousAgent)
      (agent ?TRANS ?BUYER)
      (origin ?TRANS ?SELLER)
      (instance ?BUYER_LOCATION GeopoliticalArea)
      (instance ?SELLER_LOCATION GeopoliticalArea)
      (located ?SELLER ?SELLER_LOCATION)
      (located ?BUYER ?BUYER_LOCATION)
      (not
        (equal ?BUYER_LOCATION ?SELLER_LOCATION)))))


;; Repayment
;; -------------------------------------------------------------------

(subclass Repayment Payment)

(termFormat EnglishLanguage Repayment "repayment")

(documentation Repayment EnglishLanguage "A Repayment is a subclass of &%Payment where
 the origin of a previous payment is the destination of the repayment, and vice versa. The 
 transactionAmount is the same as that previous payment.")

(=>
  (instance ?REPAYMENT Repayment)
  (exists (?PAYMENT ?PAYMENT_AMOUNT ?REPAYMENT_AMOUNT)
    (and
      (instance ?PAYMENT ?PAYMENT)
      (not
        (equal ?PAYMENT ?REPAYMENT))
      (transactionAmount ?PAYMENT ?PAYMENT_AMOUNT)
      (transactionAmount ?REPAYMENT ?REPAYMENT_AMOUNT)
      (equal ?PAYMENT_AMOUNT ?REPAYMENT_AMOUNT))))

(=>
  (and
    (instance ?REPAYMENT Repayment)
    (instance ?REPAYMENT_DESTINATION Object)
    (destination ?REPAYMENT ?REPAYMENT_DESTINATION)
    (instance ?REPAYMENT_ORIGIN Object)
    (origin ?REPAYMENT ?REPAYMENT_ORIGIN))
  (exists (?PAYMENT ?PAYMENT_ORIGIN ?PAYMENT_DESTINATION)
    (and
      (instance ?PAYMENT Payment)
      (instance ?PAYMENT_ORIGIN Object)
      (instance ?PAYMENT_DESTINATION Object)
      (not
        (equal ?PAYMENT ?REPAYMENT))
      (destination ?PAYMENT ?PAYMENT_DESTINATION)
      (origin ?PAYMENT ?PAYMENT_ORIGIN)
      (equal ?PAYMENT_ORIGIN ?REPAYMENT_DESTINATION)
      (equal ?PAYMENT_DESTINATION ?REPAYMENT_ORIGIN))))

;; JW: instances of object used here since, because of the nuances of financialTransaction, these 
;; could be either people or accounts.


;; TransactionCollection
;; -------------------------------------------------------------------

(subclass TransactionCollection FinancialTransaction)

(documentation TransactionCollection EnglishLanguage "A &%FinancialTransaction which has multiple 
 &%subProcess which are &%Buyings, and where both the &%instrument and &%agent of the 
 &%TransactionCollection is the same as the &%agent and &%instrument of the &%Buyings. The &%Buyings 
 occur simultaneously.")

(termFormat EnglishLanguage TransactionCollection "collection of transactions")

(=>
  (instance ?PURCHASE TransactionCollection)
  (exists (?SUBPROCESS1 ?SUBPROCESS2)
    (and
      (instance ?SUBPROCESS1 Buying)
      (subProcess ?SUBPROCESS1 ?PURCHASE)
      (instance ?SUBPROCESS2 Buying)
      (subProcess ?SUBPROCESS2 ?PURCHASE)
      (not
        (equal ?SUBPROCESS1 ?SUBPROCESS2)))))

(=>
  (and
    (instance ?PURCHASE TransactionCollection)
    (instance ?BUYING1 Buying)
    (instance ?BUYING2 Buying)
    (subProcess ?BUYING1 ?PURCHASE)
    (subProcess ?BUYING2 ?PURCHASE))
  (equal
    (WhenFn ?BUYING1)
    (WhenFn ?BUYING2)))

(=>
  (and
    (instance ?PURCHASE TransactionCollection)
    (instance ?BUYING1 Buying)
    (instance ?BUYING2 Buying)
    (subProcess ?BUYING1 ?PURCHASE)
    (subProcess ?BUYING2 ?PURCHASE)
    (agent ?PURCHASE ?AGENT)
    (instrument ?PURCHASE ?INST))
  (and
    (agent ?BUYING1 ?AGENT)
    (agent ?BUYING2 ?AGENT)
    (instrument ?BUYING1 ?INST)
    (instrument ?BUYING2 ?INST)))


;; -------------------------------------------------------------------
;; SITE COMPONENTS
;; -------------------------------------------------------------------


;; homePage
;; -------------------------------------------------------------------

(instance homePage BinaryPredicate)

(domain homePage 1 WebPage)

(domain homePage 2 WebSite)

(termFormat EnglishLanguage homePage "homepage")

(documentation homePage EnglishLanguage "(homePage ?PAGE ?SITE) identifies the &%WebPage ?PAGE as 
 the home page of the &%WebSite ?SITE")

(=>
  (homePage ?PAGE ?SITE)
  (component ?PAGE ?SITE))


;; WebPageModule
;; -------------------------------------------------------------------

(subclass WebPageModule UIElement)

(documentation WebPageModule EnglishLanguage "A &%UIElement that is a component of a &%WebPage.")

(termFormat EnglishLanguage WebPageModule "module")

(=>
  (instance ?MODULE WebPageModule)
  (exists (?PAGE)
    (and
      (instance ?PAGE WebPage)
      (component ?MODULE ?PAGE))))


;; PageModuleServer
;; -------------------------------------------------------------------

(subclass PageModuleServer Software)

(termFormat EnglishLanguage PageModuleServer "page module server")

(documentation PageModuleServer EnglishLanguage "&%Software which is a &%part of a 
 &%ComputerProgram, and &%hasPurpose of being the &%origin of a &%DataTransfer where a 
 &%PageServerModule is the destination.")

(=>
  (instance ?MODULE_SERVER PageModuleServer)
  (part ?MODULE_SERVER ComputerProgram))

(=>
  (instance ?MODULE WebPageModule)
  (hasPurpose ?MODULE
    (exists (?TRANSFER ?ORIGIN ?MODULE_SERVER)
      (and
        (instance ?TRANSFER DataTransfer)
        (instance ?MODULE_SERVER PageModuleServer)
        (instance ?ORIGIN ?MODULE_SERVER)
        (origin ?TRANSFER ?MODULE_SERVER)
        (destination ?TRANSFER ?MODULE)))))


;; ProductDescriptionPage
;; -------------------------------------------------------------------

(subclass ProductDescriptionPage WebPage)

(documentation ProductDescriptionPage EnglishLanguage "A &%WebPage which contains &%Advertising for 
a &%Class of products and descsriptions (&%Statings) which &%refer to them.")

(termFormat EnglishLanguage ProductDescriptionPage "product description page")

(=>
  (instance ?DESCRIPTIONPAGE ProductDescriptionPage)
  (exists (?PRODUCT ?ADVERTISEMENT)
    (and
      (instance ?PRODUCT Class)
      (instance ?ADVERTISEMENT Advertising)
      (patient ?ADVERTISEMENT ?PRODUCT)
      (part ?ADVERTISEMENT ?DESCRIPTIONPAGE))))

(=>
  (instance ?DESCRIPTIONPAGE ProductDescriptionPage)
  (exists (?PRODUCT ?DESCRIPTION ?STATING ?DESCRIPTIONCONTENT)
    (and
      (instance ?PRODUCT Class)
      (instance ?STATING Stating)
      (patient ?STATING ?DESCRIPTION)
      (refers ?DESCRIPTION ?PRODUCT)
      (result ?DESCRIPTION ?DESCRIPTIONCONTENT)
      (part ?DESCRIPTIONCONTENT ?DESCRIPTIONPAGE))))


;; ViewItemPage
;; -------------------------------------------------------------------

(subclass ViewItemPage WebPage)

(documentation ViewItemPage EnglishLanguage "A &%WebPage which contains a &%WebListing and 
description of the &%patient of the listing.")

(termFormat EnglishLanguage ViewItemPage "next generation view item")

(=>
  (and
    (instance ?PAGE ViewItemPage)
    (instance ?SITE WebSite)
    (component ?PAGE ?SITE))
  (exists (?ITEM ?ADVERTISING)
    (and
      (instance ?ITEM Object)
      (instance ?ADVERTISING WebListing)
      (component ?ADVERTISING ?PAGE)
      (hostedOn ?ADVERTISING ?SITE)
      (patient ?ADVERTISING ?ITEM))))

(=>
  (and
    (instance ?PAGE ViewItemPage)
    (instance ?ADVERTISING WebListing)
    (component ?ADVERTISING ?PAGE)
    (patient ?ADVERTISING ?ITEM)
    (instance ?ITEM Physical))
  (exists (?DESCRIPTION ?STATING ?DESCRIPTIONCONTENT)
    (and
      (instance ?STATING Stating)
      (patient ?STATING ?DESCRIPTION)
      (refers ?DESCRIPTION ?ITEM)
      (result ?DESCRIPTION ?DESCRIPTIONCONTENT)
      (part ?DESCRIPTIONCONTENT ?PAGE))))


;; WebBrowswer
;; -------------------------------------------------------------------

(subclass WebBrowser ComputerProgram)

(termFormat EnglishLanguage WebBrowser "web browser")

(documentation WebBrowser EnglishLanguage "A &%ComputerProgram which is the instrument of 
 &%AccessingWebPage.")

(=>
  (instance ?BROWSER WebBrowser)
  (hasPurpose ?BROWSER
    (exists (?ACCESSING)
      (and
        (instance ?ACCESSING AccessingWebPage)
        (instrument ?ACCESSING ?BROWSER)))))

;; JW: 
;; Needs Mapping to wordnet 106571301
;; Should this actually be the instrument of *rendering* a webPage? If so how to define rendering?

;; WebStore
;; -------------------------------------------------------------------

(subclass WebStore Collection)

(termFormat EnglishLanguage WebStore "web store")

(documentation WebStore EnglishLanguage "A &%Collection of &%WebPages that is a component of a
  &%WebSite, that &%hasPurpose of being where &%Selling occurs.")

(=>
  (instance ?STORE WebStore)
  (exists (?SITE)
    (and
      (instance ?SITE WebSite)
      (component ?STORE ?SITE))))

(=>
  (instance ?STORE WebStore)
  (hasPurpose ?STORE
    (exists (?SELLING)
      (and
        (instance ?SELLING Selling)
        (instrument ?SELLING ?STORE)))))

(=>
  (and
    (instance ?STORE WebStore)
    (member ?PAGE ?STORE))
  (instance ?PAGE WebPage))


(=>
  (instance ?STORE WebStore)
  (exists (?OWNER)
    (and
      (instance ?OWNER Human)
      (possesses ?OWNER ?STORE))))


;; -------------------------------------------------------------------
;; BACKEND
;; -------------------------------------------------------------------

(instance userDatabase BinaryPredicate)

(domain userDatabase 1 Database)

(domain userDatabase 2 WebSite)

(documentation userDatabase EnglishLanguage "(userDatabase ?DATABASE ?WEBSITE) relates a &%Database 
 and a &%WebSite, and signifies that ?DATABASE has a &%part which &%represents the &%Collection of 
 users of the ?WEBSITE - i.e. &%members of this collection are &%Agents who are &%agents of an 
 &%AccessingWebPage where the &%patient of the accessing is &%component of ?WebSite.")

(termFormat EnglishLanguage userDatabase "user database")

(=>
  (userDatabase ?DATABASE ?WEBSITE)
  (exists (?PART)
    (and
      (instance ?USERS Collection)
      (part ?PART ?DATABASE)
      (represents ?PART ?USERS)
      (forall (?MEMBER)
        (=>
          (member ?MEMBER ?USERS)
          (and
            (instance ?MEMBER AutonomousAgent)
            (exists (?ACCESSING ?PAGE)
              (and
                (instance ?ACCESSING AccessingWebPage)
                (instance ?PAGE WebPage)
                (patient ?ACCESSING Page)
                (agent ?ACCESSING AutonomousAgent)
                (component ?PAGE ?WEBSITE)))))))))


;; DataWarehouse
;; -------------------------------------------------------------------

(subclass DataWarehouse Database)

(documentation DataWarehouse EnglishLanguage "A &%Database that &%hasPurpose of containing 
 information about a particular subject &%inScopeOfInterest of a particular &%AutonomousAgent.")

(termFormat EnglishLanguage DataWarehouse "data warehouse")

(=>
  (instance ?WAREHOUSE DataWarehouse)
  (hasPurpose ?WAREHOUSE
    (exists (?SUBJECT)
      (and
        (instance ?SUBJECT Proposition)
        (forall (?DATA)
          (and
            (refers ?DATA ?SUBJECT)
            (component ?DATA ?WAREHOUSE)))))))

(=>
  (instance ?WAREHOUSE DataWarehouse)
  (hasPurpose ?WAREHOUSE
    (exists (?AGENT)
      (and
        (instance ?AGENT AutonomousAgent)
        (forall (?DATA)
            (and
              (inScopeOfInterest ?DATA ?AGENT)
              (component ?DATA ?WAREHOUSE)))))))

;; siteCatalog
;; -------------------------------------------------------------------

(instance siteCatalog BinaryPredicate)

(domain siteCatalog 1 Database)

(domain siteCatalog 2 WebSite)

(documentation siteCatalog EnglishLanguage "(siteCatalog ?DATABASE ?WEBSITE) relates a &%Database 
 and a &%WebSite, and signifies that ?DATABASE has a &%part which &%represents a &%Collection of 
 &%Physicals which have the capability of being the &%patient of a &%Buying where ?WEBSITE is the 
 &%eCommerceSite of the &%Buying.")

(termFormat EnglishLanguage siteCatalog "site catalog")

(=>
  (siteCatalog ?DATABASE ?WEBSITE)
  (exists (?PART)
    (and
      (instance ?PRODUCTS Collection)
      (part ?PART ?DATABASE)
      (represents ?PART ?PRODUCTS)
      (forall (?MEMBER)
        (=>
          (member ?MEMBER ?PRODUCTS)
          (and
            (instance ?MEMBER Physical)
            (capability 
              (KappaFn ?BUYING
                (and
                  (instance ?BUYING Buying)
                  (eCommerceSite ?BUYING ?WEBSITE)))
              patient ?MEMBER)))))))


;; -------------------------------------------------------------------
;; SEARCH
;; -------------------------------------------------------------------


;; BestMatchAlgorithm
;; -------------------------------------------------------------------

(subclass BestMatchAlgorithm Procedure)

(documentation BestMatchAlgorithm EnglishLanguage "A &%Procedure that &%hasPurpose of there being a 
 &%SearchEngine that is its &%agent, a &%SearchQuery which is its &%patient &%SRPResults being its 
 agent.")

(termFormat EnglishLanguage BestMatchAlgorithm "best match sort")

(=>
  (instance ?BM BestMatchAlgorithm)
  (hasPurpose ?BM
    (exists (?SEARCHENGINE)
      (and
        (instance ?SEARCHENGINE SearchEngine)
        (agent ?BM ?SEARCHENGINE)))))

(=>
  (instance ?BM BestMatchAlgorithm)
  (hasPurpose ?BM
    (exists (?SearchQuery)
      (and
        (instance ?SearchQuery SearchQuery)
        (patient ?BM ?SearchQuery)))))

(=>
  (instance ?BM BestMatchAlgorithm)
  (hasPurpose ?BM
    (exists (?RESULT)
      (and
        (instance ?RESULT SRPResults)
        (result ?BM ?RESULT)))))

(=>
  (instance ?BM BestMatchAlgorithm)
  (hasPurpose ?BM
    (exists (?QUERY ?SEARCHATTEMPT ?OBJECT ?AGENT)
      (and    
        (instance ?QUERY SearchQuery)
        (instance ?SEARCHATTEMPT SearchAttempt)
        (represents ?QUERY ?SEARCHATTEMPT)
        (patient ?BM ?QUERY)
        (instance ?AGENT AutonomousAgent)
        (patient ?SEARCHATTEMPT ?OBJECT)
        (agent ?SEARCHATTEMPT ?AGENT)))))

;; JW: Is this a process, a procedure, or a ComputerProgram?


;; searchResult
;; -------------------------------------------------------------------

(instance searchResult BinaryPredicate)

(domain searchResult 1 WebListing)

(domain searchResult 2 SearchAttempt)

(termFormat EnglishLanguage searchResult "search result")

(documentation searchResult EnglishLanguage "(searchResult ?RESULT ?SA) relates a &%WebListing to a 
 &%SearchAttempt where the listing is in the &%SRPResults.")
    
(=>
  (searchResult ?RESULT ?SA)
  (exists (?RESULTS)
    (and
      (instance ?RESULTS SRPResults)
      (inList ?RESULT ?RESULTS))))


;; SearchAttempt
;; -------------------------------------------------------------------

(subclass SearchAttempt Pursuing)

(termFormat EnglishLanguage SearchAttempt "search attempt")

(documentation SearchAttempt EnglishLanguage "A &%subclass of &%Pursuing where there is a 
 &%SearchQuery which represents the &%SearchAttempt.")

(=>
  (instance ?SA SearchAttempt)
  (exists (?QUERY)
    (and
      (instance ?QUERY SearchQuery)
      (represents ?QUERY ?SA))))


;; SearchEngine
;; -------------------------------------------------------------------

(subclass SearchEngine ComputerProgram)

(documentation SearchEngine EnglishLanguage "A computer program that retrieves documents or files or
 data from a database or from a computer network (especially from the internet).")

(termFormat EnglishLanguage SearchEngine "search engine")

;; JW:
;; This is essentially a placeholder definition, but should work for currently forseen purposes.
;; Needs Mapping to wordnet 106578654


;; SEO
;; -------------------------------------------------------------------

(instance SEO Process)

(termFormat EnglishLanguage SEO "search engine optimization")

(documentation SEO EnglishLanguage "A &%Process which makes a &%WebPage more likely to be listed
  higher in a &%SRPResults &%List.")

(=>
  (and
    (instance ?SEO SEO)
    (patient ?SEO ?PAGE))
  (instance ?PAGE WebPage))

(=>
  (and
    (instance ?SEO SEO)
    (patient ?SEO ?PAGE))
  (hasPurpose ?SEO
    (exists (?SRPRESULT_BEFORE ?SRPRESULT_AFTER ?BM1 ?BM2)
      (and
        (instance ?SRPRESULT_BEFORE SRPResults)
        (instance ?SRPRESULT_AFTER SRPResults)
        (equal ?PAGE (ListOrderFn ?SRPRESULT_BEFORE ?BEFORE))
        (equal ?PAGE (ListOrderFn ?SRPRESULT_AFTER ?AFTER))
        (instance ?BM1 BestMatchAlgorithm)
        (instance ?BM2 BestMatchAlgorithm)
        (earlier (WhenFn ?BM1) (WhenFn ?BM2))
        (earlier (WhenFn ?SEO) (WhenFn ?BM2))
        (earlier (WhenFn ?BM1) (WhenFn ?SEO))
        (greaterThan ?BEFORE ?AFTER)))))


;; SearchQuery
;; -------------------------------------------------------------------

(subclass SearchQuery SymbolicString)

(documentation SearchQuery EnglishLanguage "A &%SymbolicString which is the &%result of a 
 &%Questioning where the &%destination of the &%Questioning is a &%SearchEngine.")

(termFormat EnglishLanguage SearchQuery "Search query")

(=>
  (instance ?QUERY SearchQuery)
  (exists (?QUESTION ?SEARCHENGINE)
    (and
      (instance ?QUESTION Questioning)
      (result ?QUESTION ?QUERY)
      (destination ?QUESTION ?SEARCHENGINE)
      (instance ?SEARCHENGINE SearchEngine))))

(=>
  (and    
    (instance ?QUERY SearchQuery)
    (instance ?SEARCHATTEMPT SearchAttempt)
    (represents ?QUERY ?SEARCHATTEMPT))
  (exists (?AGENT ?OBJ)
    (and
      (instance ?AGENT AutonomousAgent)
      (patient ?SEARCHATTEMPT ?OBJ)
      (agent ?SEARCHATTEMPT ?AGENT))))


;; searchQueryRewrite
;; -------------------------------------------------------------------

(instance searchQueryRewrite BinaryPredicate)

(documentation searchQueryRewrite EnglishLanguage "(SearchQueryRewrite ?QUERY1 ?QUERY2) means that 
  the &%SearchQuery ?QUERY2 occured before the &SearchQuery ?QUERY1, and they both represent the
  same &%SearchAttempt.")

(termFormat EnglishLanguage searchQueryRewrite "search query rewrite")

(domain searchQueryRewrite 1 SearchQuery)

(domain searchQueryRewrite 2 SearchQuery)

(=>
  (searchQueryRewrite ?QUERY1 ?QUERY2)
  (exists (?SEARCHATTEMPT)
      (and    
        (instance ?SEARCHATTEMPT SearchAttempt)
        (represents ?QUERY1 ?SEARCHATTEMPT)
        (represents ?QUERY2 ?SEARCHATTEMPT))))

(=>
  (searchQueryRewrite ?QUERY1 ?QUERY2)
  (earlier (WhenFn ?QUERY2) (WhenFn ?QUERY1)))


;; SRPResults
;; -------------------------------------------------------------------

(subclass SRPResults List)

(termFormat EnglishLanguage SRPResults "search results")

(documentation SRPResults EnglishLanguage "A &%List containing &%WebListings or &%WebPages the is 
 the result of a &%BestMatchAlgorithm, and is a &%component of a &%SearchResultsPage.")

(=>
  (instance ?RESULTS SRPResults)
  (exists (?BM)
    (and
      (instance ?BM BestMatchAlgorithm)
      (result ?BM ?RESULTS))))

(=>
  (and
    (inList ?ITEM ?RESULTS)
    (instance ?RESULTS SRPResults))
  (or
    (instance ?ITEM WebListing)
    (instance ?ITEM WebPage)))

(=>
  (and
    (inList ?ITEM ?RESULTS)
    (instance ?RESULTS SRPResults))
  (exists (?SRP)
    (and
      (instance ?SRP SearchResultsPage)
      (component ?RESULTS ?SRP))))


;; SearchTerm
;; -------------------------------------------------------------------

(subclass SearchTerm Word)

(termFormat EnglishLanguage SearchTerm "search term")

(documentation SearchTerm EnglishLanguage "A &%Word that is &%represented by a part of 
 &%SearchQuery")
    
(=>
  (instance ?TERM SearchTerm)
  (exists (?QUERY ?PART)
    (and
      (instance ?QUERY SearchQuery)
      (part ?PART ?QUERY)
      (represents ?PART ?TERM))))


;; SearchResultsPage
;; -------------------------------------------------------------------

(subclass SearchResultsPage WebPage)

(documentation SearchResultsPage EnglishLanguage "A &%WebPage which contains &%SRPResults as a 
 &%component.")

(termFormat EnglishLanguage SearchResultsPage "search results page")

(=>
  (instance ?PAGE SearchResultsPage)
  (exists (?RESULTS)
    (and
      (instance ?RESULTS SRPResults)
      (component ?RESULTS ?PAGE))))


;; -------------------------------------------------------------------
;; BUSINESS TERMS
;; -------------------------------------------------------------------

;; businessUnit
;; -------------------------------------------------------------------

(instance businessUnit BinaryPredicate)

(domain businessUnit 1 Organization)

(domain businessUnit 2 Business)

(termFormat EnglishLanguage businessUnit "business unit")

(documentation businessUnit EnglishLanguage "A &%BinaryPredicate relating an &%Organization to a 
 &%Business, specifying that the &%Organization is a &%subOrganization of the &%Business, the 
 organization is the &%agent of some process that &%benefits the &%Business, and there is something 
 specific that is &%inScopeOfInterest of the &%Organization.")


(=>
  (businessUnit ?BU ?ORG)
  (subOrganization ?BU ?ORG))

(=>
  (businessUnit ?BU ?ORG)
  (hasPurpose ?BU
    (exists (?PROCESS)
      (and
        (instance ?PROCESS Process)
        (agent ?PROCESS ?BU)
        (benefits ?PROCESS ?ORG)))))

(=>
  (businessUnit ?BU ?ORG)
  (exists (?INTEREST)
    (and
      (instance ?INTEREST Entity)
      (inScopeOfInterest ?BU ?INTEREST))))

(=>
  (and
    (businessUnit ?ORG ?BUSINESS)
    (member ?MEMBER ?ORG))
  (instance ?MEMBER Human))


;; BusinessRequirementDocument
;; -------------------------------------------------------------------

(subclass BusinessRequirementDocument Document)

(termFormat EnglishLanguage BusinessRequirementDocument "business requirement document")

(documentation BusinessRequirementDocument EnglishLanguage "A &%Document that &%containsInformation 
 about a &%Plan for a &%subProcess of an instance of &%Experimenting.")

(=>
  (instance ?BRD BusinessRequirementDocument)
  (exists (?PLAN ?BU ?PROC)
    (and
      (instance ?PLAN Plan)
      (instance ?BU Business)
      (instance ?PROC Process)
      (represents ?PLAN ?PROC)
      (desires ?BU ?PROC)
      (containsInformation ?BRD ?PLAN))))


;; CrossFunctionalTeam
;; -------------------------------------------------------------------

(subclass CrossFunctionalTeam Organization)

(documentation CrossFunctionalTeam EnglishLanguage "An &%Organization where &%members of that 
 organization have different skills, but a common &%Entity inScopeOfInterest.")

(termFormat EnglishLanguage CrossFunctionalTeam "cross-functional team")

(=>
  (instance ?TEAM CrossFunctionalTeam)
  (exists (?INTEREST)
    (and
      (instance ?INTEREST Entity)
      (forall (?MEMBER)
        (=>
          (and
            (instance ?MEMBER Human)
            (member ?MEMBER ?TEAM))
          (inScopeOfInterest ?MEMBER ?INTEREST))))))

(=>
  (instance ?TEAM CrossFunctionalTeam)
  (exists (?SKILL ?MEMBER1 ?MEMBER2 ?INST)
    (and
      (subclass ?SKILL Process)
      (instance ?MEMBER1 Human)
      (instance ?MEMBER2 Human)
      (member ?MEMBER1 ?TEAM)
      (member ?MEMBER2 ?TEAM)
      (hasSkill ?SKILL ?MEMBER1)
      (not
        (hasSkill ?SKILL ?MEMBER2))
      (instance ?INST ?SKILL)
      (inScopeOfInterest ?TEAM ?INST))))

;; crossFunctionalTeamFocus
;; -------------------------------------------------------------------

(instance crossFunctionalTeamFocus BinaryPredicate)

(termFormat EnglishLanguage crossFunctionalTeamFocus "BinaryPredicate")

(documentation crossFunctionalTeamFocus EnglishLanguage "(crossFunctionalTeamFocus ?FOCUS ?TEAM) 
 means that ?FOCUS is &%inScopeOfInterest of each &%member of &%CrossFunctionalTeam ?TEAM.")

(domain crossFunctionalTeamFocus 1 Entity)

(domain crossFunctionalTeamFocus 2 CrossFunctionalTeam)

(=>
  (and
    (crossFunctionalTeamFocus ?FOCUS ?TEAM)
    (member ?MEMBER ?TEAM))
  (inScopeOfInterest ?MEMBER ?FOCUS))


;; experimentUpdate
;; -------------------------------------------------------------------

(instance experimentUpdate BinaryPredicate)

(domain experimentUpdate 1 ContentBearingPhysical)

(domain experimentUpdate 2 Experimenting)

(documentation experimentUpdate EnglishLanguage "A &%BinaryPredicate used to convey that a 
 &%ContentBearingPhysical conveys an update of an &%instance of &%Experimenting in progress.")

(termFormat EnglishLanguage experimentUpdate "live experiment update")

(=>
  (experimentUpdate ?CBP ?EXP)
  (refers ?CBP ?EXP))

;; JW: Needs a way to convey "results so far."


;; finalExperimentReport
;; -------------------------------------------------------------------

(instance finalExperimentReport BinaryPredicate)

(domain finalExperimentReport 1 ContentBearingPhysical)

(domain finalExperimentReport 2 Experimenting)

(documentation finalExperimentReport EnglishLanguage "(finalExperimentReport ?CBP ?EXPERIMENT) means
 that ?CBP is a &%ContentBearingPhysical which &%containsInformation about the &%result of 
 ?EXPERIMENT.")

(termFormat EnglishLanguage finalExperimentReport "final experiment report")

(=>
  (finalExperimentReport ?CBP ?EXPERIMENT)
  (exists (?RESULT)
    (and
      (result ?EXPERIMENT ?RESULT)
      (containsInformation ?CBP ?RESULT))))

(=>
  (finalExperimentReport ?CBP ?EXP)
  (refers ?CBP ?EXP))

;; JW:
;; Contains not just results, clarifying significance etc. as well.
;; Needs way to represent that experiment is completed.


;; GlobalCrossFunctionalTeam
;; -------------------------------------------------------------------

(subclass GlobalCrossFunctionalTeam CrossFunctionalTeam)

(termFormat EnglishLanguage GlobalCrossFunctionalTeam "global cross-functional team")

(documentation GlobalCrossFunctionalTeam EnglishLanguage "A &%CrossFunctionalTeam where &%members 
 are &%located in different &%GeoPoliticalAreas.")

(=>
  (instance ?GXT GlobalCrossFunctionalTeam)
  (exists (?MEMBER1 ?MEMBER1_LOC ?MEMBER2 ?MEMBER2_LOC)
    (and
      (instance ?MEMBER1 Human)
      (instance ?MEMBER2 Human)
      (instance ?MEMBER1_LOC GeopoliticalArea)
      (instance ?MEMBER2_LOC GeopoliticalArea)
      (member ?MEMBER1 ?GXT)
      (member ?MEMBER2 ?GXT)
      (located ?MEMBER1 ?MEMBER1_LOC)
      (located ?MEMBER2 ?MEMBER2_LOC)
      (not
        (equal ?MEMBER1_LOC ?MEMBER2_LOC)))))


;; TestProtocolSpecification
;; -------------------------------------------------------------------

(subclass TestProtocolSpecification Document)

(termFormat EnglishLanguage TestProtocolSpecification "test protocol specification")

(documentation TestProtocolSpecification EnglishLanguage "A &%Document that &%containsInformation 
 about a &%Plan for a &%subProcess of an instance of &%Experimenting.")

(=>
  (instance ?TPS TestProtocolSpecification)
  (exists (?PLAN ?EXPERIMENT ?PROC)
    (and
      (instance ?PLAN Plan)
      (instance ?EXPERIMENT Experimenting)
      (instance ?PROC Process)
      (represents ?PLAN ?PROC)
      (subProcess ?EXPERIMENT ?PROC)
      (containsInformation ?TPS ?PLAN))))


;; DatabaseAdministrator
;; -------------------------------------------------------------------

(instance DatabaseAdministrator Position)

(termFormat EnglishLanguage DatabaseAdministrator "database administrator")

(documentation DatabaseAdministrator EnglishLanguage "A person responsible for the installation, 
 configuration, upgrade, administration, monitoring and maintenance of databases in an 
 organization.")


;; CustomerSupport
;; -------------------------------------------------------------------

(subclass CustomerSupport Organization)

(termFormat EnglishLanguage CustomerSupport "customer support")

(documentation CustomerSupport EnglishLanguage "An &%Organization which is a &%businessUnit of a 
 company, that &%hasPurpose of having its &%members be &%customerRepresentatives.")
    
(=>
  (instance ?CS CustomerSupport)
  (exists (?ORG)
    (and
      (instance ?ORG Organization)
      (businessUnit ?CS ?ORG))))

(=>
  (instance ?CS CustomerSupport)
  (hasPurpose ?CS
    (exists (?MEMBER ?CUSTOMER ?ORG)
      (and
        (instance ?MEMBER CognitiveAgent)
        (instance ?CUSTOMER CognitiveAgent)
        (instance ?ORG Organization)
        (businessUnit ?CS ?ORG)
        (member ?MEMBER ?CS)
        (customerRepresentative ?MEMBER ?CUSTOMER ?ORG)))))


;; -------------------------------------------------------------------
;; Metrics
;; -------------------------------------------------------------------


;; conversionEvent
;; -------------------------------------------------------------------

(instance conversionEvent BinaryPredicate )

(termFormat EnglishLanguage conversionEvent "conversionEvent")

(documentation conversionEvent EnglishLanguage "(conversionEvent ?EXP ?PROC) specifies that a 
 &%Process ?PROC is considered a conversionEvent, i.e. a success event, in the context of 
 &%Experimenting ?EXP")

(domain conversionEvent 1 Experimenting)

(domain conversionEvent 2 Process)


;; ConversionRateFn
;; -------------------------------------------------------------------

(instance ConversionRateFn UnaryFunction)

(termFormat EnglishLanguage ConversionRateFn "conversion rate")

(documentation ConversionRateFn EnglishLanguage "(ConversionRateFn ?COLL) returns the Quantity 
 representing the &%CardinalityFn of the &%Collection of &%WebListings ?COLL wich are are successful
 (i.e. there was a &%Buying of the item which is the &%patient of the listing) divided by the 
 &%CardinalityFn of the whole collection.")

(domain ConversionRateFn 1 Collection)

(range ConversionRateFn Quantity)

(=>
  (and
    (instance ?COLL Collection)
    (forall (?MEMBER)
      (=>
        (member ?MEMBER ?COLL)
        (instance ?MEMBER WebListing))))
  (equal
    (DivisionFn 
      (CardinalityFn
        (KappaFn ?LISTING
          (and
            (instance ?LISTING WebListing)
            (instance ?SITE WebSite)
            (instance ?ITEM Physical)
            (member ?LISTING ?COLL)
            (patient ?LISTING ?ITEM)
            (hostedOn ?LISTING ?SITE)
            (exists (?BUYING)
              (and
                (instance ?BUYING Buying)
                (patient ?BUYING ?ITEM)
                (eCommerceSite ?BUYING ?SITE))))))
      (CardinalityFn ?COLL))
    (BidCountFn ?COLL)))


;; BoughtItemsFn
;; -------------------------------------------------------------------

(instance BoughtItemsFn UnaryFunction)

(domain BoughtItemsFn 1 Collection)

(range BoughtItemsFn NonnegativeInteger)

(termFormat EnglishLanguage BoughtItemsFn "bought items")

(documentation BoughtItemsFn EnglishLanguage "(BoughtItemsFn ?COLL) returns the number of &%Physical
 which are &%patients of &%Buyings which are &%members of ?COLL.")

(=>
  (and
    (instance ?COLL Collection)
    (forall (?MEMBER)
      (=>
        (member ?MEMBER ?COLL)
        (instance ?MEMBER FinancialTransaction))))
  (equal 
    (CardinalityFn
      (KappaFn ?ITEM
        (and
          (instance ?ITEM Physical)
          (instance ?BUYING Buying)
          (member ?BUYING ?COLL)
          (patient ?BUYING ?ITEM))))
    (BoughtItemsFn ?COLL)))
    
    

;; BidCountFn
;; -------------------------------------------------------------------

(instance BidCountFn UnaryFunction)

(domain BidCountFn 1 Collection)

(range BidCountFn NonnegativeInteger)

(termFormat EnglishLanguage BidCountFn "bid count")

(documentation BidCountFn EnglishLanguage "(BidCountFn ?COLL) returns the number of &%Biddings
 which were the &%objectOfBid of the &%Biddings are also the &%patients of &%WebListings which are 
 &%members of ?COLL.")

(=>
  (and
    (instance ?COLL Collection)
    (forall (?MEMBER)
      (=>
        (member ?MEMBER ?COLL)
        (instance ?MEMBER WebListing))))
  (equal 
    (CardinalityFn
      (KappaFn ?BIDDING
        (and
          (instance ?ITEM Physical)
          (instance ?LISTING WebListing)
          (instance ?BIDDING Bidding)
          (member ?LISTING ?COLL)
          (objectOfBid ?BIDDING ?ITEM)
          (patient ?LISTING ?ITEM))))
    (BidCountFn ?COLL)))

;; GMBFn
;; -------------------------------------------------------------------

(instance GMBFn UnaryFunction)

(domain GMBFn 1 Collection)

(range GMBFn CurrencyMeasure)

(documentation GMBFn EnglishLanguage "The sum of all &%transactionAmounts for a &%collection of 
 &%Buyings where all the &%agents of the buyings are in the same &%GeopoliticalArea.")

(termFormat EnglishLanguage GMBFn "gross merchandise bought")

(=>
  (and
    (instance ?PURCHASES Collection)
    (forall (?MEMBER)
      (=>
        (member ?MEMBER ?PURCHASES)
        (instance ?MEMBER Buying)))
    (exists (?REGION)
      (and
        (instance ?REGION GeopoliticalArea)
        (forall (?BUYER ?BUYING)
          (=>
            (and
              (instance ?BUYER AutonomousAgent)
              (instance ?BUYING Buying)
              (member ?BUYING ?PURCHASES)
              (agent ?BUYING ?BUYER))
            (located ?BUYER ?REGION))))))
  (and
    (total (KappaFn ?AMOUNT
      (and
        (instance ?PURCHASE Buying)
        (member ?PURCHASE ?PURCHASES)
        (transactionAmount ?PURCHASE ?AMOUNT)))
      ?TOTAL_PURCHASE_AMOUNT)
    (equal 
      (GMBFn ?PURCHASES) ?TOTAL_PURCHASE_AMOUNT)))


;; GMVFn
;; -------------------------------------------------------------------

(instance GMVFn UnaryFunction)

(domain GMVFn 1 Collection)

(range GMVFn CurrencyMeasure)

(documentation GMVFn EnglishLanguage "The sum of all &%transactionAmounts for a &%collection of 
 &%Sellings where all the &%agents of the sellings are in the same &%GeopoliticalArea.")

(termFormat EnglishLanguage GMVFn "gross merchandise volume")

(=>
  (and
    (instance ?SALES Collection)
    (forall (?MEMBER)
      (=>
        (member ?MEMBER ?SALES)
        (instance ?MEMBER Selling)))
    (exists (?REGION)
      (and
        (instance ?REGION GeopoliticalArea)
        (forall (?SELLER ?SELLING)
          (=>
            (and
              (instance ?SELLER AutonomousAgent)
              (instance ?SELLING Buying)
              (member ?SELLING ?SALES)
              (agent ?SELLING ?SELLER))
            (located ?SELLER ?REGION))))))
  (and
    (total (KappaFn ?AMOUNT
      (and
        (instance ?SALE Selling)
        (member ?SALE ?SALES)
        (transactionAmount ?SALE ?AMOUNT)))
      ?TOTAL_SALE_AMOUNT)
    (equal 
      (GMVFn ?SALES) ?TOTAL_SALE_AMOUNT)))


;; QualifyingPurchasesFn
;; -------------------------------------------------------------------
    
(instance QualifyingPurchasesFn UnaryFunction)

(domain QualifyingPurchasesFn 1 Experimenting)

(range QualifyingPurchasesFn Collection)

(termFormat EnglishLanguage QualifyingPurchasesFn "Qualifying Purchase")

;(documentation QualifyingPurchasesFn EnglishLanguage "(QualifyingPurchasesFn ?EXPERIMENT) returns the 
; &%Collection of all &%Purchases that result from ?EXPERIMENT.")

;; PPSFn
;; -------------------------------------------------------------------

(instance PPSFn UnaryFunction)

(domain PPSFn 1 Experimenting)

(range PPSFn RealNumber)

(documentation PPSFn EnglishLanguage "QualifyingPurchases per TreatedUser.
 Accounts for purchases immediately following a qualifying event")

(termFormat EnglishLanguage PPSFn "qualifying purchases per user")

(=>
  (and
    (instance ?EXPERIMENT Experimenting)
    (instance ?INTERVAL TimeInterval))
  (equal
    (DivisionFn
      (CardinalityFn 
        (KappaFn ?PURCHASE
          (and
            (instance ?PURCHASE Buying)
            (member ?PURCHASE (QualifyingPurchasesFn ?EXPERIMENT)))))
      (CardinalityFn 
        (KappaFn ?USER
          (and
            (member ?USER (TreatedUsersFn ?EXPERIMENT))
            (instance ?ACCESSING AccessingWebPage)
            (agent ?ACCESSING ?USER)))))
    (PPSFn ?EXPERIMENT)))

;; JW: 
;; Needs to be able to be limited to a test variant


;; PPIFn
;; -------------------------------------------------------------------

(instance PPIFn BinaryFunction)

(domain PPIFn 1 Experimenting)

(domain PPIFn 2 TimeInterval)

(range PPIFn RealNumber)

(documentation PPIFn EnglishLanguage "QualifyingPurchases per TreatedUser in &%TimeInterval.
 Accounts for purchases immediately following a qualifying event")

(termFormat EnglishLanguage PPIFn "qualifying purchases per user per interval")

(=>
  (and
    (instance ?EXPERIMENT Experimenting)
    (instance ?INTERVAL TimeInterval))
  (equal
    (DivisionFn
      (CardinalityFn 
        (KappaFn ?PURCHASE
          (and
            (instance ?PURCHASE Buying)
            (member ?PURCHASE (QualifyingPurchasesFn ?EXPERIMENT))
            (during (WhenFn ?PURCHASE) ?INTERVAL))))
      (CardinalityFn 
        (KappaFn ?USER
          (and
            (member ?USER (TreatedUsersFn ?EXPERIMENT))
            (instance ?ACCESSING AccessingWebPage)
            (during (WhenFn ?ACCESSING) ?INTERVAL)
            (agent ?ACCESSING ?USER)))))
    (PPIFn ?EXPERIMENT ?INTERVAL)))

;; JW: 
;; Needs to be able to be limited to a test variant


;; GPSFn
;; -------------------------------------------------------------------

(instance GPSFn BinaryFunction)

(domain GPSFn 1 Experimenting)

(documentation GPSFn EnglishLanguage "GMB value for PPS purchases (item Price * Quantity Sold)")

(termFormat EnglishLanguage GPSFn "GPS")

;;(=>
;;  (and
;;    (instance ?EXPERIMENT Experimenting)
;;    (instance ?INTERVAL TimeInterval))
;;  (equal 
;;    (DivisionFn
;;      (monetaryValue 
;;        (KappaFn ?AMOUNT
;;          (exists (?PURCHASE)
;;            (and
;;              (member ?PURCHASE (QualifyingPurchasesFn ?EXPERIMENT))
;;              (during (WhenFn ?PURCHASE) ?INTERVAL)
;;              (transactionAmount ?PURCHASE ?AMOUNT)))))
;;      (CardinalityFn (KappaFn ?USER
;;        (exists (?PURCHASE)
;;          (and
;;            (member ?PURCHASE (QualifyingPurchasesFn ?EXPERIMENT))
;;            (during (WhenFn ?PURCHASE) ?INTERVAL)
;;            (agent ?PURCHASE ?USER))))))
;;    (GPSFn ?EXPERIMENT)))


;; GPIFn
;; -------------------------------------------------------------------

(instance GPIFn BinaryFunction)

(domain GPIFn 1 Experimenting)

(domain GPIFn 2 TimeInterval)

(documentation GPIFn EnglishLanguage "GMB value for PPS purchases (item Price * Quantitiy Sold) over
 an interval.")

(termFormat EnglishLanguage GPIFn "GPW")

;(=>
;  (and
 ;   (instance ?EXPERIMENT Experimenting)
;    (instance ?INTERVAL TimeInterval))
;  (equal 
;    (DivisionFn
;      (monetaryValue (KappaFn ?AMOUNT
;        (exists (?PURCHASE)
;          (and
;            (member ?PURCHASE (QualifyingPurchasesFn ?EXPERIMENT))
;            (during (WhenFn ?PURCHASE) ?INTERVAL)
;            (transactionAmount ?PURCHASE ?AMOUNT)))))
;      (CardinalityFn (KappaFn ?USER
;        (exists (?PURCHASE)
;          (and
;            (member ?PURCHASE (QualifyingPurchasesFn ?EXPERIMENT))
;            (during (WhenFn ?PURCHASE) ?INTERVAL)
;            (agent ?PURCHASE ?USER))))))
;    (GPIFn ?EXPERIMENT ?INTERVAL)))


;; AuctionGMBFn
;; -------------------------------------------------------------------

(instance AuctionGMBFn UnaryFunction)

(domain AuctionGMBFn 1 Collection)

(range AuctionGMBFn CurrencyMeasure)

(documentation AuctionGMBFn EnglishLanguage "The sum of all purchase prices in a collection of 
 &%Auctionings.")

(termFormat EnglishLanguage AuctionGMBFn "gross merchandise bought in auctions")

(=>
  (and
    (instance ?AUCTIONS Collection)
    (forall (?AUC)
      (=>
        (member ?AUC ?AUCTIONS)
        (instance ?AUC Auctioning))))
  (and
    (total (KappaFn ?AMOUNT
      (and
        (instance ?AUCTION Auctioning)
        (member ?AUCTION ?AUCTIONS)
        (transactionAmount ?AUCTION ?AMOUNT)))
      ?TOTAL_PURCHASE_AMOUNT)
    (equal 
      (AuctionGMBFn ?AUCTIONS) ?TOTAL_PURCHASE_AMOUNT)))


;; ABPFn
;; -------------------------------------------------------------------

(instance ABPFn UnaryFunction)

(documentation ABPFn EnglishLanguage "Average buying price. Total GMB divided by the total number of
 items sold (not the transactions) in a given time interval.")

(domain ABPFn 1 Collection)

(range ABPFn CurrencyMeasure)

(termFormat EnglishLanguage ABPFn "average buying price")

(=>
  (and
    (equal ?X (ABPFn ?BUYINGS))
    (member ?BUYING ?BUYINGS))
  (instance ?BUYING Buying))
;;
;; Jennie 14th August 2022
;; reversed the order of the arguements for patient
(=>
  (and
    (instance ?BUYINGS Collection)
    (instance ?GMB CurrencyMeasure)
    (instance ?TOTAL RealNumber)
    (equal
      ?GMB
      (GMBFn ?BUYINGS))
    (equal
      ?TOTAL
      (CardinalityFn 
        (KappaFn ?ITEM
          (and
            (instance ?ITEM Object)
            (exists (?BUYING)
              (and
                (member ?BUYING ?BUYINGS)
                (patient ?BUYING ?ITEM))))))))
    (equal
      (ABPFn ?BUYINGS)
      (DivisionFn ?GMB ?TOTAL)))


;; ASPFn
;; -------------------------------------------------------------------

(instance ASPFn UnaryFunction)

(documentation ASPFn EnglishLanguage "Average Selling Price. Total GMV divided by the total number 
 of items sold (not the transactions) in a given time interval.")

(domain ASPFn 1 Collection)

(range ASPFn CurrencyMeasure)

(termFormat EnglishLanguage ASPFn "average buying price")

(=>
  (and
    (equal ?X (ASPFn ?SELLINGS))
    (member ?SELLING ?SELLINGS))
  (instance ?SELLING Selling))

(=>
  (and
    (instance ?SELLINGS Collection)
    (instance ?GMV CurrencyMeasure)
    (instance ?TOTAL RealNumber)
    (equal
      ?GMV
      (GMVFn ?SELLINGS))
    (equal
      ?TOTAL
      (CardinalityFn 
        (KappaFn ?ITEM
          (and
            (instance ?ITEM Object)
            (exists (?SELLING)
              (and
                (member ?SELLING ?SELLINGS)
                (patient ?SELLING ?ITEM))))))))
    (equal
      (ASPFn ?SELLINGS)
      (DivisionFn ?GMV ?TOTAL)))

(subclass HypertextLink DigitalData)
(documentation HypertextLink EnglishLanguage "A link embedded in one 
documentation that &%refers to another document, and can be processed
automatically by a &%ComputerProgram to retrieve and display the
referenced document.  Most typically an HTML 'A' tag but also found
in other markup languages.")
(termFormat EnglishLanguage HypertextLink "hyperlink")

(=>
  (instance ?HL HypertextLink)
  (refers ?HL DigitalData))
  
;; ClickThroughRateFn
;; -------------------------------------------------------------------

(instance ClickThroughRateFn BinaryFunction)

(documentation ClickThroughRateFn EnglishLanguage "(clickThroughRateFn ?VISITS ?HYPERLINK) returns 
 the &%RealNumber that represents the number of times users click ?HYPERLINK divided by the number
 of &%AccessingWebPages in ?VISITS")
    
(termFormat EnglishLanguage ClickThroughRateFn "click-through rate")

(domain ClickThroughRateFn 1 Collection)

(domain ClickThroughRateFn 2 HypertextLink)

(range ClickThroughRateFn RealNumber)

(=>
  (and
    (instance ?VISITS Collection)
    (instance ?HYPERLINK HypertextLink)
    (forall (?ACCESSING)
      (and
        (member ?ACCESSING ?PAGE)
        (and
          (instance ?ACCESSING AccessingWebPage)
          (component ?PAGE ?HYPERLINK)))))
  (exists (?CLICKS)
    (and
      (instance ?CLICKS Collection)
      (forall (?CLICK)
        (=>
          (and
            (instance ?CLICK RequestingHyperlink)
            (patient ?CLICK ?HYPERLINK))
          (member ?CLICK ?CLICKS)))
      (equal
        (ClickThroughRateFn ?VISITS ?HYPERLINK)
        (DivisionFn
          (CardinalityFn ?CLICKS)
          (CardinalityFn ?VISITS))))))


;; SiteWideNewBuyersFn
;; -------------------------------------------------------------------

(instance SiteWideNewBuyersFn BinaryFunction)

(domain SiteWideNewBuyersFn 1 TimeInterval)

(domain SiteWideNewBuyersFn 2 WebSite)

(range SiteWideNewBuyersFn Collection)

(termFormat EnglishLanguage SiteWideNewBuyersFn "new buyers")

(documentation SiteWideNewBuyersFn EnglishLanguage "(SiteWideNewBuyersFn ?INTERVAL ?SITE) Returns a 
 collection of &%Agents who were agents of a &%Buying &%during &%TimeInterval ?INTERVAL where ?SITE 
 was the &%instrument, and who were not &%registeredUsers before ?INTERVAL.")

(=>
  (and
    (instance ?INTERVAL TimeInterval)
    (instance ?SITE WebSite))
  (exists (?NEWBUYERS)
    (and
      (instance ?NEWBUYERS Collection)
      (forall (?AGENT)
        (=>
          (member ?AGENT ?NEWBUYERS)
          (and
            (exists (?BUYING)
              (and
                (instance ?AGENT AutonomousAgent)
                (instance ?BUYING Buying)
                (agent ?BUYING ?AGENT)
                (instrument ?BUYING ?SITE)
                (during ?BUYING ?INTERVAL)))
            (not
              (exists (?INTERVAL_BEFORE)
                (and
                  (instance ?INTERVAL_BEFORE TimeInterval)
                  (earlier ?INTERVAL_BEFORE ?INTERVAL)
                  (holdsDuring ?INTERVAL_BEFORE
                    (exists (?BUYING_BEFORE)
                      (and
                        (instance ?BUYING_BEFORE Buying)
                        (agent ?BUYING_BEFORE ?AGENT)
                        (instrument ?BUYING_BEFORE ?SITE)
                        (during ?BUYING_BEFORE ?INTERVAL))))))))))
      (equal
        (SiteWideNewBuyersFn ?INTERVAL ?SITE)
        ?NEWBUYERS))))


;; SiteWideNewRegistrationsFn
;; -------------------------------------------------------------------

(instance SiteWideNewRegistrationsFn BinaryFunction)

(domain SiteWideNewRegistrationsFn 1 TimeInterval)

(domain SiteWideNewRegistrationsFn 2 WebSite)

(range SiteWideNewRegistrationsFn Collection)

(termFormat EnglishLanguage SiteWideNewRegistrationsFn "site-wide new registrations")

(documentation SiteWideNewRegistrationsFn EnglishLanguage "(SiteWideNewRegistrationsFn ?INTERVAL ?SITE)
 returns a collection of &%Agents who were not registerUsers of ?SITE before ?INTERVAL, but were 
 registeredUsers for some &%Interval &%during ?INTERVAL")

 (=>
  (and
    (instance ?INTERVAL TimeInterval)
    (instance ?SITE WebSite))
  (exists (?NEWREGISTRATIONS)
    (and
      (instance ?NEWREGISTRATIONS Collection)
      (forall (?USER)
        (=>
          (and
            (instance ?USER Human)
            (not
              (exists (?INTERVAL_BEFORE)
                (and
                  (instance ?INTERVAL_BEFORE TimeInterval)
                  (earlier ?INTERVAL_BEFORE ?INTERVAL)
                  (holdsDuring ?INTERVAL_BEFORE
                    (registeredUser ?USER ?SITE)))))
            (exists (?INTERVAL_DURING)
              (and
                (instance ?INTERVAL_DURING TimeInterval)
                (during ?INTERVAL_DURING ?INTERVAL)
                (holdsDuring ?INTERVAL
                  (registeredUser ?USER ?SITE)))))
        (member ?USER ?NEWREGISTRATIONS)))
      (equal
        ?NEWREGISTRATIONS
        (SiteWideNewRegistrationsFn ?INTERVAL ?SITE)))))


;; SiteWideNewSellersFn
;; -------------------------------------------------------------------

(instance SiteWideNewSellersFn BinaryFunction)

(domain SiteWideNewSellersFn 1 TimeInterval)

(domain SiteWideNewSellersFn 2 WebSite)

(range SiteWideNewSellersFn Collection)

(termFormat EnglishLanguage SiteWideNewSellersFn "site-wide new sellers")

(documentation SiteWideNewSellersFn EnglishLanguage "(SiteWideNewSellersFn ?INTERVAL ?SITE) Returns 
 a collection of &%Agents who were agents of a &%Selling &%during &%TimeInterval ?INTERVAL where 
 ?SITE was the &%instrument, and who were not &%registeredUsers before ?INTERVAL.")

(=>
  (and
    (instance ?INTERVAL TimeInterval)
    (instance ?SITE WebSite))
  (exists (?NEWSELLERS)
    (and
      (instance ?NEWSELLERS Collection)
      (forall (?AGENT)
        (=>
          (member ?AGENT ?NEWSELLERS)
          (and
            (exists (?SELLING)
              (and
                (instance ?AGENT AutonomousAgent)
                (instance ?SELLING Selling)
                (agent ?SELLING ?AGENT)
                (instrument ?SELLING ?SITE)
                (during ?SELLING ?INTERVAL)))
            (not
              (exists (?INTERVAL_BEFORE)
                (and
                  (instance ?INTERVAL_BEFORE TimeInterval)
                  (earlier ?INTERVAL_BEFORE ?INTERVAL)
                  (holdsDuring ?INTERVAL_BEFORE
                    (exists (?SELLING_BEFORE)
                      (and
                        (instance ?SELLING_BEFORE Selling)
                        (agent ?SELLING_BEFORE ?AGENT)
                        (instrument ?SELLING_BEFORE ?SITE)
                        (during ?SELLING_BEFORE ?INTERVAL))))))))))
      (equal
        (SiteWideNewSellersFn ?INTERVAL ?SITE)
        ?NEWSELLERS))))


;; firstTimeBuyers
;; -------------------------------------------------------------------

(instance firstTimeBuyers TernaryPredicate)

(domain firstTimeBuyers 1 TimeInterval)

(domain firstTimeBuyers 2 WebSite)

(domain firstTimeBuyers 3 Collection)

(termFormat EnglishLanguage firstTimeBuyers "first time buyers")

(documentation firstTimeBuyers EnglishLanguage "(firstTimeBuyers ?INT ?SITE ?COLL) means that ?COLL
 is the &%Collection of &%Agents who are &%agents of &%Buyings where the &%WebSite ?SITE is the
 &%eCommerceSite ?SITE &%during the &%TimeInterval ?INT, where no &%Buyings exist with the same
 conditions prior to ?INT.")

(=>
  (and
    (firstTimeBuyers ?INT ?SITE ?COLL)
    (member ?MEMBER ?COLL))
  (instance ?MEMBER AutonomousAgent))

(=>
  (and
    (firstTimeBuyers ?INT ?SITE ?COLL)
    (member ?MEMBER ?COLL))
  (exists (?BUYING)
    (and
      (instance ?BUYING Buying)
      (agent ?BUYING ?MEMBER)
      (eCommerceSite ?BUYING ?SITE)
      (during (WhenFn ?BUYING) ?INT))))

(=>
  (and
    (firstTimeBuyers ?INT ?SITE ?COLL)
    (member ?MEMBER ?COLL))
  (not
    (exists (?BUYING)
      (and
        (instance ?BUYING Buying)
        (agent ?BUYING ?MEMBER)
        (eCommerceSite ?BUYING ?SITE)
        (earlier (WhenFn ?BUYING) ?INT)))))


;; firstTimeSellers
;; -------------------------------------------------------------------

(instance firstTimeSellers TernaryPredicate)

(domain firstTimeSellers 1 TimeInterval)

(domain firstTimeSellers 2 WebSite)

(domain firstTimeSellers 3 Collection)

(termFormat EnglishLanguage firstTimeSellers "first time buyers")

(documentation firstTimeSellers EnglishLanguage "(firstTimeSellers ?INT ?SITE ?COLL) means that 
 ?COLL is the &%Collection of &%Agents who are &%agents of &%Sellings where the &%WebSite ?SITE is 
 the &%eCommerceSite ?SITE &%during the &%TimeInterval ?INT, where no &%Selling exist with the same
 conditions prior to ?INT.")

(=>
  (and
    (firstTimeSellers ?INT ?SITE ?COLL)
    (member ?MEMBER ?COLL))
  (instance ?MEMBER AutonomousAgent))

(=>
  (and
    (firstTimeSellers ?INT ?SITE ?COLL)
    (member ?MEMBER ?COLL))
  (exists (?SELLING)
    (and
      (instance ?SELLING Selling)
      (agent ?SELLING ?MEMBER)
      (eCommerceSite ?SELLING ?SITE)
      (during (WhenFn ?SELLING) ?INT))))

(=>
  (and
    (firstTimeSellers ?INT ?SITE ?COLL)
    (member ?MEMBER ?COLL))
  (not
    (exists (?SELLING)
      (and
        (instance ?SELLING Selling)
        (agent ?SELLING ?MEMBER)
        (eCommerceSite ?SELLING ?SITE)
        (earlier (WhenFn ?SELLING) ?INT)))))


;; newRegisteredUsers
;; -------------------------------------------------------------------

(instance newRegisteredUsers TernaryPredicate)

(domain newRegisteredUsers 1 TimeInterval)

(domain newRegisteredUsers 2 WebSite)

(domain newRegisteredUsers 3 Collection)

(termFormat EnglishLanguage newRegisteredUsers "new registered users")

(documentation newRegisteredUsers EnglishLanguage "(newRegisteredUsers ?INT ?SITE ?COLL) means that 
 ?COLL is the &%Collection of &%Agents who are &%registeredUsers of the &%WebSite ?SITE during some
 &%TimeInterval &%during the &%TimeInterval ?INT, but were not during an &%earlier &%TimeInterval.")

(=>
  (and
    (newRegisteredUsers ?INT ?SITE ?COLL)
    (member ?MEMBER ?COLL))
  (instance ?MEMBER AutonomousAgent))

(=>
  (and
    (newRegisteredUsers ?INT ?SITE ?COLL)
    (member ?MEMBER ?COLL))
  (exists (?DURING)
    (and
      (instance ?DURING TimeInterval)
      (during ?DURING ?INT)
      (holdsDuring ?DURING
        (registeredUser ?MEMBER ?SITE)))))

(=>
  (and
    (newRegisteredUsers ?INT1 ?SITE ?COLL)
    (member ?MEMBER ?COLL))
  (not
    (exists (?INT2)
      (and
        (instance ?INT2 TimeInterval)
        (earlier ?INT2 ?INT1)
        (holdsDuring ?INT2
          (registeredUser ?MEMBER ?SITE))))))


;; SCRFn
;; -------------------------------------------------------------------
    
(instance SCRFn BinaryFunction)

(domain SCRFn 1 Collection)

(domain SCRFn 2 TimeInterval)

(termFormat EnglishLanguage SCRFn "sales conversion rate")

(documentation SCRFn EnglishLanguage "(SCRFn ?COLL ?INTERVAL) returns purchases made
 during an interval / the number of visits made during the interval.  This accounts for single 
 visits resulting in multiple purchases by the buyer.")

(=>
  (and
    (instance ?VISITS Collection)
    (instance ?PURCHASES Collection)
    (subCollection ?PURCHASES ?VISITS)
    (forall (?MEMBER)
      (=>
        (member ?MEMBER ?VISITS)
        (instance ?MEMBER AccessingWebPage)))
    (forall (?BUYING ?VISITOR ?ACCESSING ?BUYING ?PAGE)
      (=>
        (and
          (instance ?VISITOR Human)
          (instance ?BUYING Buying)
          (instance ?ACCESSING AccessingWebPage)
          (instance ?PAGE WebPage)
          (member ?ACCESSING ?VISITS)
          (destination ?ACCESSING ?PAGE)
          (agent ?BUYING ?VISITOR)
          (agent ?ACCESSING ?VISITOR)
          (during (WhenFn ?BUYING) (WhenFn ?ACCESSING))
          (instrument ?BUYING ?PAGE))
        (member ?BUYING ?PURCHASES))))
    (equal
      (SCRFn ?VISITS ?INTERVAL)
      (DivisionFn
        (CardinalityFn 
          (KappaFn ?PURCHASE_IN_INTERVAL
            (and
              (member ?PURCHASE_IN_INTERVAL ?PURCHASES)
              (during (WhenFn ?PURCHASE_IN_INTERVAL) ?INTERVAL))))
        (CardinalityFn 
          (KappaFn ?VISIT_IN_INTERVAL
            (and
              (member ?VISIT_IN_INTERVAL ?VISITS)
              (during (WhenFn ?PURCHASE_IN_INTERVAL) ?INTERVAL)))))))

;; SRPEngagementFn
;; -------------------------------------------------------------------

(instance SRPEngagementFn UnaryFunction)

(domain SRPEngagementFn 1 SearchResultsPage)

(range SRPEngagementFn RealNumber)

(termFormat EnglishLanguage SRPEngagementFn "SRP Engagement")

(documentation SRPEngagementFn EnglishLanguage "(SRPEngagementFn ?SRP) returns the number of 
 &%RequestingHyperlinks from a &%SearchResultsPage where the &%destination is either 
 &%ProductDescriptionPage or a &%ViewItemPage, over the number of &%SRPResults")

(=>
  (and
    (instance ?PAGE SearchResultsPage)
    (instance ?RESULTS SRPResults)
    (component ?RESULTS ?PAGE))
  (equal
    (DivisionFn
      (CardinalityFn (KappaFn ?CLICK
        (and
          (instance ?CLICK RequestingHyperlink)
          (patient ?CLICK ?ELEMENT)
          (destination ?CLICK ?LINKEDPAGE)
          (instance ?ELEMENT HypertextLink)
          (component ?ELEMENT ?PAGE)
          (or
            (instance ?LINKEDPAGE ProductDescriptionPage)
            (instance ?LINKEDPAGE ViewItemPage)))))
      (ListLengthFn ?RESULTS))
    (SRPEngagementFn ?PAGE)))


;; SiteSpeedFn
;; -------------------------------------------------------------------

(instance SiteSpeedFn UnaryFunction)

(domain SiteSpeedFn 1 AccessingWebPage)

(range SiteSpeedFn TimeInterval)

(termFormat EnglishLanguage SiteSpeedFn "site speed")

(documentation SiteSpeedFn EnglishLanguage "(SiteSpeedFn ?ACCESSING) returns the &%TimeInterval that
 represents the length of time it takes to load the &%WebPage which is the &%patient of the 
 &%AccessingWebPage ?ACCESSING. The interval begins at the &%EndFn of a &%Requesting of that page by
  the &%WebBrowser, and ends at the &%EndFn of a &%DataTransfer of that page where the browser is 
  the &%destination of the transfer.")

(=>
  (and
    (instance ?ACCESSING AccessingWebPage)
    (instance ?PAGE WebPage)
    (instance ?TRANSFER DataTransfer)
    (instance ?SERVER Server)
    (instance ?REQUESTING Requesting)
    (instance ?BROWSER WebBrowser)
    (instance ?INTERVAL TimeInterval)
    (patient ?ACCESSING ?PAGE)
    (agent ?REQUESTING ?BROWSER)
    (destination ?REQUESTING ?SERVER)
    (patient ?REQUESTING ?PAGE)
    (origin ?TRANSFER ?SERVER)
    (destination ?TRANSFER ?BROWSER)
    (patient ?TRANSFER ?PAGE)
    (subProcess ?TRANSFER ?ACCESSING)
    (subProcess ?REQUESTING ?ACCESSING)
    (equal
      (EndFn (WhenFn ?REQUESTING)) 
      (BeginFn ?INTERVAL))
    (equal
      (EndFn (WhenFn ?TRANSFER)) 
      (EndFn ?INTERVAL)))
  (equal
    (SiteSpeedFn ?ACCESSING) ?INTERVAL))


;; -------------------------------------------------------------------
;; EXPERIMENTING
;; -------------------------------------------------------------------

;; Additions to the definition of &%Experimenting (&%result of experimenting)
;; -------------------------------------------------------------------

(=>
  (and
    (instance ?EXPERIMENT Experimenting)
    (result ?EXPERIMENT ?RESULT))
  (instance ?RESULT Formula))

(=>
  (instance ?EXPERIMENT Experimenting)
  (exists (?FORMULA ?RESULT)
    (and
      (instance ?RESULT Formula)
      (result ?EXPERIMENT ?RESULT)
      (instance ?FORMULA Formula)
      (patient ?EXPERIMENT ?FORMULA)
      (represents 
        (ProbabilityFn ?FORMULA)
       ?RESULT))))
    

;; experimentalControlProcess
;; -------------------------------------------------------------------

(instance experimentalControlProcess BinaryPredicate) 

(documentation experimentalControlProcess EnglishLanguage "(experimentalControlProcess ?EXPERIMENT 
 ?PROC) means that the &%experiencing of the &%Process ?PROC is the control in the instance of 
 experimenting ?EXPERIMENT, i.e. ?PROC is what is different from an &%experimentalVariableProcess 
 &%experienced by the experimental group in the experiment.")

(domain experimentalControlProcess 1 Experimenting)

(domain experimentalControlProcess 2 Process) 

(termFormat EnglishLanguage experimentalControlProcess "experimental control (process)")

(=>
  (and
    (instance ?EXPERIMENT Experimenting)
    (experimentalControlProcess ?EXPERIMENT ?CONTROL))
  (subProcess ?CONTROL ?EXPERIMENT))


;; controlGroup
;; -------------------------------------------------------------------

(instance controlGroup BinaryPredicate)

(domain controlGroup 1 Collection)

(domain controlGroup 2 Experimenting)

(documentation controlGroup EnglishLanguage "(controlGroup ?COLLECTION ?EXPERIMENT) means that 
 ?COLLECTION is the group of all agents who have experienced an &%experimentalControlProcess of 
 ?EXPERIMENT, where ?EXPERIMENT is an instance of &%Experimenting.")

(termFormat EnglishLanguage controlGroup "control group")    

(=>
  (and
    (instance ?VARIABLE Process)
    (instance ?EXPERIMENT Experimenting)
    (instance ?AGENT AutonomousAgent)
    (experiencer ?AGENT AutonomousAgent)
    (experimentalVariableProcess ?EXPERIMENT ?VARIABLE))
  (exists (?CONTROL_GROUP)
    (and
      (instance ?CONTROL_GROUP Collection)
      (member ?AGENT ?CONTROL_GROUP)
      (controlGroup ?CONTROL_GROUP ?EXPERIMENT))))


;; experimentalVariableProcess
;; -------------------------------------------------------------------

(instance experimentalVariableProcess BinaryPredicate)

(domain experimentalVariableProcess 1 Experimenting)

(domain experimentalVariableProcess 2 Process)  

(termFormat EnglishLanguage experimentalVariableProcess "experimental variable (process)")

(documentation experimentalVariableProcess EnglishLanguage "(experimentalVariableProcess 
 ?EXPERIMENT ?PROC) means that an &%AutonomousAgent being the &%experiencer of the &%Process ?PROC is the
 experimental independent variable in the instance of experimenting ?EXPERIMENT, i.e. ?PROC is what
 is different from the &%experimentalControlProcess &%experienced by the control group in the
 experiment")

(=>
  (and
    (instance ?EXPERIMENT Experimenting)
    (experimentalVariableProcess ?EXPERIMENT ?VARIABLE))
  (subProcess ?VARIABLE ?EXPERIMENT))


(=>
  (and
    (instance ?EXPERIMENT Experimenting)
    (experimentalVariableProcess ?EXPERIMENT ?VARIABLE))
  (not
    (experimentalControlProcess ?EXPERIMENT ?VARIABLE)))


(=>
  (and
    (instance ?EXPERIMENT Experimenting)
    (experimentalControlProcess ?EXPERIMENT ?CONTROL))
  (not
    (experimentalVariableProcess ?EXPERIMENT ?CONTROL)))

;; JW:
;; Is an experimentalVariableProcess really a subProcess of the experimenting?


;; experimentalSubject
;; -------------------------------------------------------------------

(instance experimentalSubject CaseRole)

(domain experimentalSubject 1 Experimenting)

(domain experimentalSubject 2 Human)

(termFormat EnglishLanguage experimentalSubject "experimental subject")

(documentation experimentalSubject EnglishLanguage "The &%CaseRole (experimentalSubject ?EXPERIMENT
 ?SUBJECT) means that ?SUBJECT is a &%Human who is the &%experiencer of either and
 &%experimentalControlProcess or an &%experimentalVariableProcess.")

(=>
  (and
    (instance ?EXPERIMENT Experimenting)
    (instance ?SUBJECT Human)
    (experimentalSubject ?EXPERIMENT ?SUBJECT))
  (exists (?PROCESS)
    (and
      (instance ?PROCESS Process)
      (experiencer ?PROCESS ?SUBJECT)
      (or
        (experimentalControlProcess ?EXPERIMENT ?PROCESS)
        (experimentalVariableProcess ?EXPERIMENT ?PROCESS)))))


;; experimenter
;; -------------------------------------------------------------------

(instance experimenter CaseRole)

(domain experimenter 1 Experimenting)

(domain experimenter 2 CognitiveAgent)

(termFormat EnglishLanguage experimenter "experimental subject")

(documentation experimenter EnglishLanguage "The &%CaseRole (experimenter ?EXPERIMENT
 ?HUMAN) means that ?HUMAN is one of the &%CognitiveAgents either conducting or analyzing the
 &%Experimenting ?EXPERIMENT.")


;; treatmentGroup
;; -------------------------------------------------------------------

(instance treatmentGroup BinaryPredicate)

(domain treatmentGroup 1 Collection)

(domain treatmentGroup 2 Experimenting)

(termFormat EnglishLanguage treatmentGroup "treatment group")

(documentation treatmentGroup EnglishLanguage "(treatmentGroup ?COLLECTION ?EXPERIMENT) means that
?COLLECTION is the group of all agents who have experienced an &%experimentalVariableProcess of
?EXERIMENT, where ?EXPERIMENT is an instance of &%Experimenting.")
    
(=>
  (and
    (instance ?VARIABLE Process)
    (instance ?EXPERIMENT Experimenting)
    (instance ?AGENT AutonomousAgent)
    (experiencer ?AGENT AutonomousAgent)
    (experimentalVariableProcess ?EXPERIMENT ?VARIABLE))
  (exists (?TREATMENT_GROUP)
    (and
      (instance ?TREATMENT_GROUP Collection)
      (member ?AGENT ?TREATMENT_GROUP)
      (treatmentGroup ?TREATMENT_GROUP ?EXPERIMENT))))

;; JW:
;; Should it be easier to distinguish between multiple different treatment groups in multivariate
;; experiments?
;; Tie into ExperimentalTreatment

;; treatedUser
;; -------------------------------------------------------------------

(domain treatedUser 1 Human)

(domain treatedUser 2 Experimenting)

(documentation treatedUser EnglishLanguage  "(treatedUser
 ?VISITOR ?EXPERIMENT) means that ?VISITOR experienced a Qualifying Event of ?EXPERIMENT.")

(instance treatedUser BinaryPredicate)

(=>
  (treatedUser ?VISITOR ?EXPERIMENT)
  (exists (?EVENT)
    (and
      (member ?EVENT (QualifyingEventsFn ?EXPERIMENT))
      (experiencer ?VISITOR ?EVENT))))

(=>
  (treatedUser ?VISITOR ?EXPERIMENT)
  (experimentalSubject ?VISITOR ?EXPERIMENT))


;; experimentID
;; -------------------------------------------------------------------

(instance experimentID BinaryRelation)

(domain experimentID 1 Identifier)

(domain experimentID 2 Experimenting)

(documentation experimentID EnglishLanguage "(experimentID ?STRING ?EXP) Associates an 
 &%Identifer ?STRING to a &%Experimenting ?EXP. They are likely to be unique.")

(termFormat EnglishLanguage experimentID "experiment identifier string")

(=>
  (experimentID ?STRING ?EXP)
  (represents ?STRING ?USER))


;; experimentalTreatmentCollection
;; -------------------------------------------------------------------

(instance experimentalTreatmentCollection BinaryPredicate)

(domain experimentalTreatmentCollection 1 Collection)

(domain experimentalTreatmentCollection 2 Experimenting)

(termFormat EnglishLanguage experimentalTreatmentCollection "experimental treatment")

(documentation experimentalTreatmentCollection EnglishLanguage "A &%BinaryPredicate specifying the 
 the collection of &%Processes which are &%experimentalVariableProcesses of an &%Experimenting.")

(=>
  (and
    (experimentalTreatmentCollection ?COLLECTION ?EXPERIMENTING)
    (member ?PROCESS ?COLLECTION))
  (experimentalVariableProcess ?EXPERIMENTING ?PROCESS))

;; qualifiedExperiment
;; -------------------------------------------------------------------

(instance qualifiedExperiment BinaryPredicate)

(domain qualifiedExperiment 1 Experimenting)

(domain qualifiedExperiment 2 Human)

(documentation qualifiedExperiment EnglishLanguage "(qualifiedExperiment ?EXPERIMENT ?HUMAN means 
 that ?HUMAN has the capabilty of being the experimentalSubject of ?EXPERIMENT")

 (=>
  (qualifiedExperiment ?EXPERIMENT ?VISITOR)
  (and
    (instance ?EXPERIMENT ?CLASS)
    (capability ?CLASS experimentalSubject ?VISITOR)))

;; qualifiedPageView
;; -------------------------------------------------------------------

(instance qualifiedPageView BinaryPredicate)

(domain qualifiedPageView 1 Experimenting)

(domain qualifiedPageView 2 AccessingWebPage)

(documentation qualifiedPageView EnglishLanguage "(qualifedPageView ?EXPERIMENT ?ACCESSING)
 represents that the patient of &%AccessingWebPage ?ACCESSING is a &%treatedPage in ?EXPERIMENT")

(=>
  (qualifiedPageView ?EXPERIMENT ?ACCESSING)
  (exists (?PAGE)
    (and
      (instance ?PAGE WebPage)
      (patient ?ACCESSING ?PAGE)
      (treatedPage ?EXPERIMENT ?PAGE))))


;; qualifiedTreatment
;; -------------------------------------------------------------------

(instance qualifiedTreatment BinaryPredicate)

(domain qualifiedTreatment 1 Experimenting)

(domain qualifiedTreatment 2 Human)

(termFormat EnglishLanguage qualifiedTreatment "qualified treatment")

(documentation qualifiedTreatment EnglishLanguage "(qualifiedTreatment ?TREATMENT ?HUMAN) means that
 ?HUMAN has &%capability to be put into &%Experimenting track ?TREATMENT")

(=>
  (qualifiedTreatment ?TREATMENT ?VISITOR)
  (exists (?PROCESS)
    (and
      (instance ?PROCESS ?CLASS)
      (member ?PROCESS ?TREATMENT)
      (capability ?CLASS experiencer ?VISITOR))))

;; treatedPage
;; -------------------------------------------------------------------
(domain treatedPage 1 WebPage)

(domain treatedPage 2 Experimenting)

(termFormat EnglishLanguage treatedPage "treated page")

(instance treatedPage BinaryPredicate)

(documentation treatedPage EnglishLanguage "&%BinaryPredicate tying pages to an experiment. 
 (treatedPage ?WEBPAGE ?EXPERIMENT) means that an &%agent of &%AccessingWebPage where the &%WebPage 
 ?WEBPAGE is the &%destination will be the &%experiencer of a &%Process which is a &%member of the 
 &%QualifyingEventsFn of the &%Experimenting ?EXPERIMENT.")

(=>
  (treatedPage ?WEBPAGE ?EXPERIMENT)
  (exists (?EVENT)
    (and
      (member ?EVENT (QualifyingEventsFn ?EXPERIMENT))
      (=>
        (and
          (instance ?VISITOR Human)
          (instance ?ACCESSING AccessingWebPage)
          (agent ?ACCESSING ?VISITOR)
          (destination ?ACCESSING ?WEBPAGE))
        (experiencer ?VISITOR ?EVENT)))))

;; treatedPageDefinition
;; -------------------------------------------------------------------
(domain treatedPageDefinition 1 Experimenting)

(domain treatedPageDefinition 2 Formula)

(termFormat EnglishLanguage treatedPageDefinition "treated page definition")

(instance treatedPageDefinition BinaryPredicate)

(documentation treatedPageDefinition EnglishLanguage "(treatedPageDefinition ?EXPERIMENT ?FORMULA)
 means that if the the &%Formula ?FORMULA &%refers to a &%WebPage, that &%WebPage is a &%treatedPage
 in the context of the &%Experimenting ?EXPERIMENT.")

(=>
  (and
    (treatedPageDefinition ?EXPERIMENT ?FORMULA)
    (instance ?PAGE WebPage)
    (refers ?FORMULA ?PAGE))
  (treatedPage ?PAGE ?EXPERIMENT))



;; QPViewsFn
;; -------------------------------------------------------------------

(instance QPViewsFn UnaryFunction)

(domain QPViewsFn 1 Human)

(range QPViewsFn Collection)

(termFormat EnglishLanguage QPViewsFn "qualifed page views")

(documentation QPViewsFn EnglishLanguage "(QPViewsFn ?VISITOR) returns all the instances of 
 &%AccessingWebPage where ?Visitor is the &%agent and the &%desitination is a &%treatedPage")

(=>
  (and
    (instance ?VISITOR Human)
    (instance ?QPVIEWS Collection) 
    (forall (?PAGE ?ACCESSING ?EXPERIMENT)
      (=>
        (and
          (instance ?PAGE WebPage)
          (instance ?ACCESSING AccessingWebPage)
          (instance ?EXPERIMENT Experimenting)
          (agent ?ACCESSING ?VISITOR)
          (patient ?ACCESSING ?PAGE)
          (treatedPage ?PAGE ?EXPERIMENT))
        (member ?ACCESSING ?QPVIEWS))))
  (equal ?QPVIEWS
    (QPViewsFn ?VISITOR)))


;; QualifyingEventsFn
;; -------------------------------------------------------------------
    
(instance QualifyingEventsFn UnaryFunction)

(domain QualifyingEventsFn 1 Experimenting)

(range QualifyingEventsFn Collection)

(termFormat EnglishLanguage QualifyingEventsFn "Qualifying Factor or Event")

(documentation QualifyingEventsFn EnglishLanguage "(QualifyingEventsFn ?EXPERIMENT) returns the 
 &%Collection of all &%Processes that are &%experimentalControlProcesses or 
 &%experimentalVariableProcesses of ?EXPERIMENT.")

(=>
  (instance ?EXPERIMENT Experimenting)
  (exists (?QUALIFYING_EVENTS)
    (and
      (instance ?QUALIFYING_EVENTS Collection)
      (forall (?EVENT)
        (=>
          (and
            (instance ?EVENT Process)
            (or
              (experimentalControlProcess ?EXPERIMENT ?EVENT)
              (experimentalVariableProcess ?EXPERIMENT ?EVENT)))
          (member ?EVENT ?QUALIFYING_EVENTS)))
      (equal
        (QualifyingEventsFn ?EXPERIMENT)
        ?QUALIFYING_EVENTS))))


;; QualifiedTreatmentsFn
;; -------------------------------------------------------------------

(instance QualifiedTreatmentsFn UnaryFunction)

(domain QualifiedTreatmentsFn 1 Human)

(range QualifiedTreatmentsFn Collection)

(documentation QualifiedTreatmentsFn EnglishLanguage "(QualifiedTreatmentsFn ?VISITOR) returns all 
 the &%Processes that ?VISITOR has the &%capability of being the &%experiencer of which are 
 qualifying events of &%Experimentings.")

(termFormat EnglishLanguage QualifiedTreatmentsFn "qualifed treatments")

(=>
  (and
    (instance ?VISITOR Human)
    (instance ?COLL Collection)
    (forall (?EXPERIMENT ?EVENT)
      (=>
        (exists (?CLASS)
          (and
            (instance ?EXPERIMENT Experimenting)
            (instance ?EVENT Process)
            (member ?EVENT (QualifyingEventsFn ?EXPERIMENT))
            (instance ?EVENT ?CLASS)
            (capability ?CLASS experiencer ?VISITOR)))
        (member ?EVENT ?COLL)))
    (=>
      (member ?PROC ?COLL)
      (and
        (instance ?PROC Process)
        (exists (?EXP ?PROCESS)
          (and
            (instance ?EXP Experimenting)
            (member ?PROC (QualifyingEventsFn ?EXP))
            (instance ?PROC ?PROCESS)
            (capability ?PROCESS experiencer ?VISITOR))))))
  (equal
    (QualifiedTreatmentsFn ?VISITOR)
    ?COLL))

;; TreatedUsersFn
;; -------------------------------------------------------------------

(instance TreatedUsersFn UnaryFunction)

(domain TreatedUsersFn 1 Experimenting)

(range TreatedUsersFn Collection)

(documentation TreatedUsersFn EnglishLanguage "(TreatedUsersFn ?EXPERIMENT) returns a 
 &%Collection of all &%Humans who where &%treatedUsers in ?EXPERIMENT.")

(=>
  (instance ?EXPERIMENT Experimenting)
  (exists (?TREATED_USERS)
    (and
      (instance ?TREATED_USERS Collection)
      (forall (?USER)
        (=>
          (and
            (instance ?USER Human)
            (treatedUser ?USER ?EXPERIMENT))
          (member ?USER ?TREATED_USERS)))
      (equal
        (TreatedUsersFn ?EXPERIMENT) ?TREATED_USERS))))


;; burnInPeriod
;; -------------------------------------------------------------------

(instance burnInPeriod BinaryRelation)

(domain burnInPeriod 1 Experimenting)

(domain burnInPeriod 2 TimeInterval)

(termFormat EnglishLanguage burnInPeriod "burn-in period")

(documentation burnInPeriod EnglishLanguage "(burnInPeriod ?EXPERIMENT ?INTERVAL) means that the 
 &%TimeInterval ?INTERVAL, which occurs at the begining of the &%Experimenting ?EXPERIMENT, is a 
 period not counted when the data are being analyzed.")

(=>
  (burnInPeriod ?EXP ?INTERVAL)
  (equal
    (BeginFn (WhenFn ?EXP)) 
    (BeginFn ?INTERVAL)))

(=>
  (burnInPeriod ?EXP ?INTERVAL)
  (before
    (EndFn ?INTERVAL)
    (EndFn (WhenFn ?EXP))))


;; exclusiveEvent
;; -------------------------------------------------------------------

(instance exclusiveEvent BinaryPredicate)

(termFormat EnglishLanguage exclusiveEvent "exclusive")

(domain exclusiveEvent 1 Experimenting)

(domain exclusiveEvent 2 Process)

(documentation exclusiveEvent EnglishLanguage "(exclusiveEvent ?EXP ?PROC) specifies that &%Process
 ?PROC is a &%SuccessEvent of &%Experimenting ?EXP and that it occurs after an
 &%ExperimentalVariableProcess where a &%treatedUser of ?EXP is an &%experiencer of ?PROC
 and that &%experimentalVariableProcess. Further, some &%experimenter &%believes it &%Likely that 
 the &%experimentalVariableProcess was in some part responsible for &%causing ?PROC.")

(=>
  (exclusiveEvent ?EXP ?PROC)
  (successEvent ?EXP ?PROC))

(=>
  (exclusiveEvent ?EXP ?PROC)
  (exists (?EVP ?AGENT)
    (and
      (instance ?EVP Process)
      (instance ?AGENT AutonomousAgent)
      (treatedUser ?AGENT ?EXP)
      (experimentalVariableProcess ?EXP ?EVP)
      (experiencer ?PROC ?AGENT)
      (experiencer ?EVP ?AGENT)
      (earlier (WhenFn ?EVP) (WhenFn ?PROC)))))

(=>
  (and
    (instance ?EVP Process)
    (instance ?AGENT AutonomousAgent)
    (instance ?EXP Experimenting)
    (treatedUser ?AGENT ?EXP)
    (experimentalVariableProcess ?EXP ?EVP)
    (experiencer ?PROC ?AGENT)
    (experiencer ?EVP ?AGENT)
    (exclusiveEvent ?EXP ?PROC))
  (exists (?EXPERIMENTER)
    (and
      (instance ?EXPERIMENTER AutonomousAgent)
      (experimenter ?EXP ?EXPERIMENTER)
      (believes ?EXPERIMENTER
        (modalAttribute
          (causes ?EVP ?PROC)
        Likely)))))


;; successEvent
;; -------------------------------------------------------------------

(instance successEvent BinaryPredicate)

(termFormat EnglishLanguage successEvent "exclusive")

(domain successEvent 1 Experimenting)

(domain successEvent 2 Process)

(documentation successEvent EnglishLanguage "(successEvent ?EXP ?PROC) specifies that &%Process
 ?PROC is a &%SuccessEvent of &%Experimenting - i.e. that it is used as the dependent variable being
 tracked.")


;; -------------------------------------------------------------------
;; EXPERIMENT TYPES AND ATTRIBUTES
;; -------------------------------------------------------------------

;; ExperimentAttribute
;; -------------------------------------------------------------------

(subclass ExperimentAttribute Attribute)

(termFormat EnglishLanguage ExperimentAttribute "experiment attribute")

(documentation ExperimentAttribute EnglishLanguage "The class of &%Attributes which relate to 
 instances of &%Experimenting.")

(=>
  (and
    (attribute ?EXP ?ATTR)
    (instance ?ATTR ExperimentAttribute))
  (instance ?EXP Experimenting))


;; AB Test
;; -------------------------------------------------------------------

(instance ABTest ExperimentAttribute)

(documentation ABTest EnglishLanguage "An &%ExperimentAttribute signifying the &%experimenting has 
 at least one &%experimentalControlProcess and at least one &%experimentalVariableProcess being 
 tested.")

(termFormat EnglishLanguage ABTest "A/B test")

(=>
  (attribute ?TEST ABTest)
  (exists (?PROCESS)
    (and
      (instance ?PROCESS Process)
      (experimentalControlProcess ?TEST ?PROCESS))))

(=>
  (attribute ?TEST ABTest)
  (exists (?PROCESS)
    (and
      (instance ?PROCESS Process)
      (experimentalVariableProcess ?TEST ?PROCESS))))


;; orthogonalTests
;; -------------------------------------------------------------------

(instance orthogonalTests SymmetricRelation)

(domain orthogonalTests 1 Collection)

(domain orthogonalTests 2 Collection)

(termFormat EnglishLanguage orthogonalTests "managed orthogonal")

(documentation orthogonalTests EnglishLanguage "A &%SymmetricRelation between two &%Collections of 
 &%Experimentings signfying that &%experimentalSubjects can be shared between them.")

(=>
  (and
    (orthogonalTests ?TESTCOL1 ?TESTCOL2)
    (member ?MEMBER ?TESTCOL1))
  (instance ?MEMBER Experimenting))

(=>
  (and
    (orthogonalTests ?TESTCOL1 ?TESTCOL2)
    (member ?MEMBER ?TESTCOL2))
  (instance ?MEMBER Experimenting))

(=>
  (and
    (orthogonalTests ?TESTCOL1 ?TESTCOL2)
    (instance ?SUBJECT Human)
    (instance ?EXPERIMENT1 ?CLASS1)
    (subclass ?CLASS1 Experimenting)
    (member ?EXPERIMENT1 ?TESTCOL1)
    (capability ?CLASS1 experimentalSubject ?SUBJECT))
  (exists (?EXPERIMENT2)
    (and
      (instance ?EXPERIMENT2 ?CLASS2)
      (member ?EXPERIMENT2 ?TESTCOL2)
      (subclass ?CLASS2 Experimenting)
      (capability ?CLASS2 experimentalSubject ?SUBJECT))))


;; MultivariateTest
;; -------------------------------------------------------------------

(subclass MultivariateTest Collection)

(documentation MultivariateTest EnglishLanguage "A multivariate is test where multiple componenets
 are tested simultaneously. Here it is represented as a &%Collection of discrete instances of 
 &%Experimenting, where the experimentalVariableProcesses in the tests are not equal, but there 
 exists a &%Process of which they are both &%subProcesses.")

(termFormat EnglishLanguage MultivariateTest "multivariate test")

(=>
  (and
    (instance ?TEST MultivariateTest)
    (member ?EXPERIMENT ?TEST))
  (instance ?EXPERIMENT Experimenting))

(=>
  (and
    (instance ?TEST MultivariateTest)
    (subProcess ?EXPERIMENT1 ?TEST)
    (subProcess ?EXPERIMENT2 ?TEST)
    (instance ?EXPERIMENT1 Experimenting)
    (instance ?EXPERIMENT2 Experimenting)
    (instance ?VARIABLE1 Process)
    (instance ?VARIABLE2 Process)
    (experimentalVariableProcess ?EXPERIMENT1 ?VARIABLE1)
    (experimentalVariableProcess ?EXPERIMENT2 ?VARIABLE2))
  (exists (?PROCESS)
    (and
      (instance ?PROCESS Process)
      (subProcess ?VARIABLE1 ?PROCESS)
      (subProcess ?VARIABLE2 ?PROCESS)
      (not
        (equal ?VARIABLE1 ?VARIABLE2)))))



;; -------------------------------------------------------------------
;; MISC
;; -------------------------------------------------------------------

;; total
;; -------------------------------------------------------------------

(instance total BinaryPredicate)

(domain total 1 Class)

(domain total 2 Quantity)

(termFormat EnglishLanguage total "total")

(documentation total EnglishLanguage "A binaryPredicate which relates a class of &%Quantities to 
 their sum.")

(=>
  (and
    (total ?CLASS ?QUANTITY)
    (instance ?ITEM ?CLASS))
  (instance ?ITEM Quantity))

;; lift
;; -------------------------------------------------------------------

(instance LiftFn BinaryFunction)

(domain LiftFn 1 Quantity)

(domain LiftFn 2 Quantity)

(range LiftFn RealNumber)

(termFormat EnglishLanguage LiftFn "lift")

(documentation LiftFn EnglishLanguage "(LiftFn ?QUANTITY1 ?QUANTITY2) returns the lift of the
 quantities. i.e. (?QUANTITY1 - ?QUANTITY2)/(?QUANTITY2). In an experiment ?QUANTITY2 is the 
 &%Quantity that represents the control group.")

(=>
  (and
    (instance ?QUANTITY1 Quantity)
    (instance ?QUANTITY2 Quantity))
  (equal 
    (LiftFn ?QUANTITY1 ?QUANTITY2)
    (DivisionFn
      (SubtractionFn ?QUANTITY1 ?QUANTITY2)
      ?QUANTITY2)))


;; ChromeBrowser
;; -------------------------------------------------------------------

(subclass ChromeBrowser WebBrowser)

(termFormat EnglishLanguage ChromeBrowser "Chrome")

(documentation ChromeBrowser EnglishLanguage "The Google Chrome &%WebBrowser.")


;; IEBrowser
;; -------------------------------------------------------------------

(subclass IEBrowser WebBrowser)

(termFormat EnglishLanguage IEBrowser "IE")

(documentation IEBrowser EnglishLanguage "The Microsoft Internet Explorer &%WebBrowser.")


;; FireFoxBrowser
;; -------------------------------------------------------------------

(subclass FireFoxBrowser WebBrowser)

(termFormat EnglishLanguage FireFoxBrowser "Firefox")

(documentation FireFoxBrowser EnglishLanguage "The Mozilla Firefox &%WebBrowser.")


;; MECE
;; -------------------------------------------------------------------

(instance meceCollection BinaryPredicate)

(domain meceCollection 1 Collection)

(domain meceCollection 2 Collection)

(termFormat EnglishLanguage meceCollection "mutually exclusive completely exhaustive")

(documentation meceCollection EnglishLanguage "(meceCollection ?COLL1 ?COLL2) means that every 
 &%member of ?COLL1 is in a &%Collection which is a member of &%Coll2, but not a member of two 
 different &%Collections which are &%members of ?COLL2.")
    

(=>
  (and
    (meceCollection ?COLL1 ?COLL2)
    (member ?MEMBER ?COLL2)
    (instance ?MEMBER SelfConnectedObject))
  (instance ?MEMBER Collection))

(=>
  (and
    (meceCollection ?COLL1 ?COLL2)
    (member ?MEMBER ?COLL1)
    (instance ?MEMBER SelfConnectedObject))
  (exists (?COLL3)
    (and
      (instance ?COLL3 Collection)
      (member ?MEMBER ?COLL3)
      (member ?COLL3 ?COLL2))))

(=>
  (and
    (meceCollection ?COLL1 ?COLL2)
    (instance ?COLL3 Collection)
    (instance ?COLL4 Collection)
    (instance ?MEMBER SelfConnectedObject)
    (member ?MEMBER ?COLL1)
    (member ?COLL3 ?COLL2)
    (member ?COLL4 ?COLL2)
    (not
      (equal ?COLL3 ?COLL4)))
  (not
    (and
      (member ?MEMBER ?COLL3)
      (member ?MEMBER ?COLL4))))