;; ============================================================================
;;                  	REARDEN COMMERCE, INC.
;;                  	Dining Ontology
;; ============================================================================

;; Created by: Karen Joy Nomorosa (karen.nomorosa [at] reardencommerce [dot] com)
;; Created on: March 8, 2011
;; Last modified: August 3, 2011
;; Modified by: Karen Joy Nomorosa (karen.nomorosa [at] reardencommerce [dot] com)

;; Description:  This ontology describes different concepts related to Dining

;; Ontology dependencies for Dining.kif: Merge.kif, Mid-level-ontology.kif

;; Access to and use of these products is governed by the GNU General Public 
;; License <http://www.gnu.org/copyleft/gpl.html>. 
;; By using these products, you agree to be bound by the terms 
;; of the GPL.

;; We ask the 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

;; ----------------------------------------------------------------------------
;; Restaurant Subclasses
;; ----------------------------------------------------------------------------
      
(subclass Coffeeshop Cafeteria)
(documentation Coffeeshop EnglishLanguage "a type of &%Cafeteria that 
specializes in serving &%Coffee")
(termFormat EnglishLanguage Coffeeshop "coffee shop")

(=>
  (instance ?COMPANY Coffeeshop)
  (exists (?SERVICE ?BEVERAGE)
    (and
      (instance ?SERVICE CommercialService)
      (agent ?SERVICE ?COMPANY)
      (instance ?SERVICE Selling)
      (patient ?SERVICE ?BEVERAGE)
      (instance ?BEVERAGE Coffee))))

(subclass Brewpub Tavern)
(documentation Brewpub EnglishLanguage "a type of &%Tavern that brews 
&%Beer and whose primary service is selling that &%Beer to customers")
(termFormat EnglishLanguage Brewpub "Brewpub")

(=>
  (instance ?PUB Brewpub)
  (exists (?SERVICE ?BEER ?BREW)
    (and
      (instance ?BREW Making)
      (result ?BREW ?BEER)
      (instance ?BEER Beer)
      (agent ?BREW ?PUB)
      (instance ?SERVICE CommercialService)
      (agent ?SERVICE ?PUB)
      (instance ?SERVICE Selling)
      (patient ?SERVICE ?BEER))))

;; KJN: Edit.  Subclassing from Business instead of CommercialAgent      
(subclass Bakery Business)
(documentation Bakery EnglishLanguage "a type of &%Business that specializes 
in the production and selling of the &%result of the process &%Baking")
(termFormat EnglishLanguage Bakery "bakery")

(=> 
  (instance ?BAKERY Bakery)
  (exists (?SERVICE ?FOOD ?BAKE)
    (and
      (instance ?BAKE Baking)
      (result ?BAKE ?FOOD)
      (instance ?FOOD (FoodForFn Human))
      (agent ?BAKE ?BAKERY)
      (instance ?SERVICE CommercialService)
      (agent ?SERVICE ?BAKERY)
      (instance ?SERVICE Selling)
      (patient ?SERVICE ?FOOD))))

(subclass Steakhouse Restaurant)
(documentation Steakhouse EnglishLanguage "a type of &%Restaurant that 
specializes in serving steak, which is cooked &%Beef")
(termFormat EnglishLanguage Steakhouse "steakhouse")

(=>
  (instance ?STEAKHOUSE Steakhouse)
  (exists (?SERVICE ?STEAK ?BEEF ?COOK)
    (and
      (instance ?COOK Cooking)
      (instance ?BEEF Beef)
      (resource ?COOK ?BEEF)
      (result ?COOK ?STEAK)
      (instance ?SERVICE CommercialService)
      (agent ?SERVICE ?STEAKHOUSE)
      (instance ?SERVICE Selling)
      (patient ?SERVICE ?STEAK))))


;; ----------------------------------------------------------------------------
;; Dining Concepts
;; ----------------------------------------------------------------------------
(subclass Corkage ChargingAFee)
(documentation Corkage EnglishLanguage "&%Corkage is a &%FinancialTransaction imposed
by an &%AutonomousAgent to a customer for bringing items not purchased from &%AutonomousAgent")
(termFormat EnglishLanguage Corkage "corkage")

(=>
  (instance ?C Corkage)
  (exists (?AMT)
    (amountCharged ?C ?AMT)))

(instance corkageFee TernaryPredicate)
(documentation corkageFee EnglishLanguage "(&%corkageFee ?AMT ?ITEM ?AGENT) refers to 
the amount ?AMT that ?AGENT charges during a &%Corkage when a customer brings in ?ITEM")
(termFormat EnglishLanguage corkageFee "corkage fee")
(domain corkageFee 1 CurrencyMeasure)
(domainSubclass corkageFee 2 Object)
(domain corkageFee 3 AutonomousAgent)

  
;; if an agent charges corkage for a particular class of items, and customer brings
;; instances of said items not purchased from agent and consumed while at agent's location,
;; then an instance of corkage occurs

;; Note: This is still problematic as IntentionalProcess can include something like 
;; Carrying in which case corkage may not be charged even if ?ITEM is brought in
(=>
  (and
    (customer ?CUST ?AGENT)
    (corkageFee ?AMT ?ITEM ?AGENT)
    (instance ?X ?ITEM)
    (not 
      (exists (?B)
        (and
          (instance ?B Buying)
          (patient ?B ?X)
          (destination ?B ?CUST)
          (origin ?B ?AGENT))))
    (instance ?D Drinking)
    (agent ?D ?CUST)
    (resource ?D ?X))
  (exists (?C)
    (and
      (instance ?C Corkage)
      (agent ?C ?CUST)
      (refers ?C ?X)
      (destination ?C ?AGENT))))

;; Outdoor Dining 
(subclass OutdoorDiningArea DiningArea)
(documentation OutdoorDiningArea EnglishLanguage "&%OutdoorDiningArea 
refers to a place for eating that is not inside a building")
(termFormat EnglishLanguage OutdoorDiningArea "outdoor dining")
(disjoint OutdoorDiningArea DiningRoom)

(=>
  (instance ?D OutdoorDiningArea)
  (exists (?O)
    (and
      (instance ?O Outdoors)
      (located ?D ?O))))

    
;; ----------------------------------------------------------------------------
;; Menu / Food Concepts
;; ----------------------------------------------------------------------------
      
;; Menu
(subclass Menu Catalog)
(documentation Menu EnglishLanguage "a &%Menu is a type of &%Catalog that specifically
contains the classes of food that is expected to be or proposed to be cooked and 
served")
(termFormat EnglishLanguage Menu "menu")

(=>
  (and
    (instance ?MENU Menu)
    (catalogItem ?X ?MENU))
  (subclass ?X (FoodForFn Human)))

(subclass SetMenu Menu)
(documentation SetMenu EnglishLanguage "a &%SetMenu is a type of &%Menu that contains
a specific set of prepared food which is all served and is given one price")
(termFormat EnglishLanguage SetMenu "set menu")

(=>
  (and
    (instance ?MENU SetMenu)
    (offers ?AGENT ?MENU)
    (catalogItem ?CLASS ?MENU)
    (subclass ?CLASS PreparedFood)
    (instance ?X ?VLASS)
    (instance ?Y ?CLASS)
    (not
      (equal ?X ?Y))
    (price ?X ?PRICE1 ?AGENT1)        
    (price ?Y ?PRICE2 ?AGENT2))
  (equal ?PRICE1 ?PRICE2))
                  
(subclass BeverageMenu Menu)
(documentation BeverageMenu EnglishLanguage "a &%BeverageMenu is a &%Menu 
of &%Beverages")
(termFormat EnglishLanguage BeverageMenu "drinks menu")

(=>
  (and
    (instance ?MENU BeverageMenu)
    (catalogItem ?X ?MENU))
  (subclass ?X Beverage))

(subclass AlcoholMenu BeverageMenu)
(documentation AlcoholMenu EnglishLanguage "an &%AlcoholMenu is a &%Menu 
of &%AlcoholicBeverage")
(termFormat EnglishLanguage AlcoholMenu "cocktail menu")

(=>
  (and
    (instance ?MENU AlcoholMenu)
    (catalogItem ?X ?MENU))
  (subclass ?X AlcoholicBeverage))

(subclass WineMenu AlcoholMenu)
(documentation WineMenu EnglishLanguage "a &%WineMenu is a &%Menu of &%Wine")
(termFormat EnglishLanguage WineMenu "wine list")

(=>
  (and 
    (instance ?MENU WineMenu)
    (catalogItem ?X ?MENU))
  (subclass ?X WineMenu))
 
;; Braille
(instance Braille PerceptualAttribute)
(documentation Braille EnglishLanguage "&%Braille is an &%Attribute that 
describes &%ContentBearingObject that can be interpreted by a &%Blind &%Human")
  
(=>
  (attribute ?X Braille)
  (instance ?X ContentBearingObject))

(=>
  (and
    (instance ?X ContentBearingObject)
    (attribute ?X Braille))
  (exists (?H)
    (and
      (instance ?H Human)
      (attribute ?H Blind)
      (capability Interpreting agent ?H)
      (capability Interpreting patient ?X))))
                  
(subclass Buffet Collection)
(documentation Buffet EnglishLanguage "&%Buffet refers to a &%Collection of food that
is served in a central location where guests can get their own servings")
(termFormat EnglishLanguage Buffet "buffet")

(=>
  (instance ?X Buffet)
  (forall (?ITEM)
    (=>
      (member ?ITEM ?X)
      (instance ?ITEM (FoodForFn Human)))))

(=>
  (instance ?X Buffet)
  (attribute ?X CommunalAttribute))
  
;; if a person is eating something from a buffet, then the person getting the food 
;; from the buffet's location occurs before the agent eating the food at another 
;; location  
(=>
  (and
    (instance ?X Buffet)
    (member ?ITEM ?X)
    (located ?X ?LOC1)
    (instance ?E Eating)
    (agent ?E ?AGENT)
    (eventLocated ?E ?LOC2)
    (patient ?E ?ITEM))
  (and
    (not (equal ?LOC1 ?LOC2))
    (exists (?G)
      (and
        (instance ?G Getting)
        (patient ?G ?ITEM)
        (origin ?G ?LOC1)
        (agent ?G ?AGENT)
        (before (WhenFn ?G) (WhenFn ?E))))))

;; if a buffet is a breakfast buffet, then it is likely that all of the food in the
;; buffet is a breakfast food
(=>
  (and
    (instance ?X Buffet)
    (attribute ?X Breakfast))
  (modalAttribute
    (forall (?FOOD)
      (=>
        (member ?FOOD ?X)
        (attribute ?FOOD Breakfast))) Likely))
  
;; ----------------------------------------------------------------------------
;; Restaurant Properties
;; ----------------------------------------------------------------------------

;; (subjectiveAttribute ?ENTITY ?ATTRIBUTE ?AGENT)
(documentation subjectiveAttribute EnglishLanguage "(&%subjectiveAttribute 
?ENTITY ?ATTR ?AGENT) means that ?AGENT attaches ?ATTR to ?ENTITY")
(instance subjectiveAttribute TernaryPredicate)
(domain subjectiveAttribute 1 Entity)
(domain subjectiveAttribute 2 Attribute)
(domain subjectiveAttribute 3 AutonomousAgent)
(termFormat EnglishLanguage subjectiveAttribute "subjective attribute")

(=> 
  (subjectiveAttribute ?ENTITY ?ATTR ?AGENT)
  (exists (?RATE)
    (and
      (instance ?RATE Classifying)
      (agent ?RATE ?AGENT)
      (patient ?RATE ?ATTR)
      (destination ?RATE ?ENTITY))))				

(instance facility BinaryPredicate)
(documentation facility EnglishLanguage "(&%facility ?AGENT ?OBJ) means 
that an ?AGENT provides some ?OBJ to fulfill some goal or need")
(domain facility 2 Object)
(domain facility 1 AutonomousAgent)
(termFormat EnglishLanguage facility "facility")

;; if an AGENT provides some OBJECT, and there exists a customer who wants 
;; to use that object, then AGENT may allow the customer to use that OBJECT
(=>
  (and
    (facility ?AGENT ?OBJ)
    (customer ?CUST ?AGENT)
    (instance ?X ?OBJ)
    (desires ?CUST
      (exists (?PROC)
        (and
          (instance ?PROC IntentionalProcess)
          (patient ?PROC ?X)
          (agent ?PROC ?CUST)))))
  (modalAttribute           
    (confersRight
      (uses ?X ?CUST) ?AGENT ?CUST)
    Possibility))
      
;; NOTE: You can use RecurrentTimeIntervalFn(HourFn HourFn) to come up with
;; ?TIMEINT
;; (businessHours ?TIMEINT ?AGENT)
(instance businessHours BinaryPredicate)
(documentation businessHours EnglishLanguage "(&%businessHours ?TIMEINT 
?AGENT) means that an ?AGENT conducts business-related activities during 
?TIMEINT")
(domainSubclass businessHours 1 TimeInterval)
(domain businessHours 2 AutonomousAgent)
(termFormat EnglishLanguage businessHours "business hours")

;; (standardRetailHours ?TIMEINT ?AGENT)
(subrelation standardRetailHours businessHours)
(instance standardRetailHours BinaryPredicate)
(documentation standardRetailHours EnglishLanguage "(%&standardRetailHours 
?TIMEINT ?AGENT) means that an ?AGENT engages in &%Selling processes with 
customers only within the time specified by ?TIMEINT")
(domainSubclass standardRetailHours 1 TimeInterval)
(domain standardRetailHours 2 AutonomousAgent)
(termFormat EnglishLanguage standardRetailHours "standard retail hours")

(=>
  (standardRetailHours ?TIMEINT ?AGENT)
  (exists (?S ?T ?C)
    (and
      (instance ?S Selling)
      (instance ?T ?TIMEINT)
      (agent ?S ?AGENT)
      (customer ?C ?AGENT)
      (during
        (whenFn ?S) ?T))))

;; the probability that a customer can be served is higher if it is within
;; standardRetailHours
;; Jennie Pease 19 Oct 2022 added above axioms and revised axioms below~

(=>
  (standardRetailHours ?TIMEINT ?AGENT)
  (exists (?FT ?T ?C ?SRH ?NONSRH)
    (and
      (instance ?FT FinancialTransaction)
      (agent ?FT ?AGENT)
      (instance ?T ?TIMEINT)
      (destination ?FT ?C)
      (equal ?SRH 
        (ProbabilityFn
          (and
            (during (WhenFn ?FT) ?T)
            (customer ?C ?AGENT))))
      (equal ?NONSRH
        (ProbabilityFn
          (and
            (not
              (during (WhenFn ?FT) ?T))
            (customer ?C ?AGENT))))
      (greaterThan ?SRH ?NONSRH))))

;; KJN: Importing from MILO, but only the part re: standardRetailHours
;;(=>
;;  (instance ?X NightClub)
;;  (exists (?TIME ?BAR)
;;    (and
;;      (instance ?BAR Tavern)
;;      (located ?BAR ?X)
;;      (standardRetailHours ?X ?TIME)
;;      (during (BeginFn ?TIME) NightTime))))

(=>
  (and
    (instance ?X NightClub)
    (standardRetailHours ?TIME ?X))  
  (exists (?T)
    (and
      (instance ?T ?TIME)
      (during ?T NightTime))))
  
;; payment with a credit card
(subclass BankCardPayment Payment)
(documentation BankCardPayment EnglishLanguage "a &%BankCardPayment is a 
type of &%Payment where a &%CreditCard or a &%DebitCard is used as the 
&%FinancialInstrument in the transaction.")
(termFormat EnglishLanguage BankCardPayment "bank card payment")

;; if a process for BankCardPayment is undergone, then the instrument in 
;; that payment should be a ValidCard
(=>
  (and
    (instance ?P BankCardPayment)
    (destination ?P ?AGENT))
  (capability BankCardPayment destination ?AGENT))

(=>
  (instance ?P BankCardPayment)
  (exists (?C)
    (and
      (instrument ?P ?C)
      (instance ?C BankCard))))
  
;; payment with cash
(subclass CashPayment Payment)
(documentation CashPayment EnglishLanguage "a &%CashPayment is a type of 
&%Payment where &%Currency is used as the &%FinancialInstrument in the 
transaction")
(termFormat EnglishLanguage CashPayment "cash payment")

(=>
  (instance ?P CashPayment)
  (exists (?C)
    (and
      (instrument ?P ?C)
      (instance ?C Currency))))

(subclass Outfit Collection)
(documentation Outfit EnglishLanguage "&%Outfit describes the set of 
clothes worn by a person")
(termFormat EnglishLanguage Outfit "outfit")

(=>
  (and
    (instance ?X Outfit)
    (member ?ITEM1 ?X)
    (holdsDuring ?TIME
      (wears ?PERSON ?ITEM1)))
  (forall (?ITEM2)
    (=>
      (member ?ITEM2 ?X)
      (holdsDuring ?TIME
        (wears ?PERSON ?ITEM2)))))

;; (dressCode ?CODE ?AGENT)
(instance dressCode BinaryPredicate)
(documentation dressCode EnglishLanguage "(&%dressCode ?CODE ?AGENT) 
means that ?AGENT obligates his customers to wear at the minimum clothes 
that fulfill ?CODE")
(domain dressCode 1 AmbienceAttribute)
(domain dressCode 2 AutonomousAgent)

;; if an agent has a dresscode, then the agent requires the customer to wear an 
;; outfit that conform to that dress code.

(=>
  (dressCode ?CODE ?AGENT)
  (modalAttribute
    (exists (?OUTFIT ?T)
      (and
        (instance ?OUTFIT Outfit)
        (subjectiveAttribute ?OUTFIT ?CODE ?AGENT)
        (holdsDuring ?T
          (forall (?CUST ?ITEM)
            (and
              (customer ?CUST ?AGENT)
              (locatedAtTime ?CUST ?T ?AGENT)                 
              (memeber ?ITEM ?OUTFIT)
              (wears ?CUST ?ITEM)))))) Obligation))
;;
;;(=>
;;  (dressCode ?CODE ?AGENT)
;;  (modalAttribute
;;    (exists (?CUST ?OUTFIT)
;;      (and
;;        (subjectiveAttribute ?OUTFIT ?CODE ?AGENT)
;;       (instance ?OUTFIT Outfit)
;;        (customer ?CUST ?AGENT)
;;        (holdsDuring (WhenFn (located ?CUST ?AGENT))
;;         (forall (?ITEM)
;;          (=>
;;            (member ?ITEM ?OUTFIT)
;;            (wears ?CUST ?ITEM))))) Obligation))
                       
;; ----------------------------------------------------------------------------
;; Restaurant Services
;; ----------------------------------------------------------------------------


(subclass DeliveryService Transfer)
(documentation DeliveryService EnglishLanguage "&%DeliveryService refers to 
the &%Transfer of an &%AutonomousAgent bringing objects purchased from &%AutonomousAgent to a 
location indicated by the customer")
(termFormat EnglishLanguage DeliveryService "delivery service")

(=>
  (and
    (instance ?D DeliveryService)
    (agent ?D ?AGENT))
  (capability DeliveryService agent ?AGENT))

;; (deliveryRegion ?AGENT ?REGION)
(instance deliveryRegion BinaryPredicate)
(documentation deliveryRegion EnglishLanguage "(&%deliveryRegion ?AGENT 
?REGION ?DELIVERY) means that ?AGENT only does a &%DeliveryService if the 
destination is within ?REGION")
(domain deliveryRegion 1 AutonomousAgent)
(domain deliveryRegion 2 GeographicArea)

(=>
  (deliveryRegion ?AGENT ?REGION)
  (capability DeliveryService agent ?AGENT))

;; the probability of an agent being capable of a delivery service is less 
;; if the location is outside of the delivery region
(=>
  (and
    (instance ?D DeliveryService)
    (destination ?D ?LOC1)
    (deliveryRegion ?AGENT ?REGION)
    (conditionalProbability 
      (located ?LOC1 ?REGION) (agent ?D ?AGENT) ?NUMBER1)
    (conditionalProbability 
      (not (located ?LOC1 ?REGION)) (agent ?D ?AGENT) ?NUMBER2))
  (lessThan ?NUMBER2 ?NUMBER1))

;; the origin and destination locations of a delivery service are not equal    
(=>
  (and
    (instance ?D DeliveryService)
    (origin ?D ?LOC1)
    (destination ?D ?LOC2))
  (not (equal ?LOC1 ?LOC2)))

(subclass CateringService ServiceProcess)
(documentation CateringService EnglishLanguage "&%CateringService refers 
to the &%ServiceProcess of an &%AutonomousAgent to prepare food and beverage for 
consumption in a location away from where the agent is located")
(termFormat EnglishLanguage CateringService "catering")

;; a restaurant has to be capable of CateringService for an instance of 
;; CateringService to exist
(=>
  (and
    (instance ?P CateringService)
    (instance ?P ?CLASS)
    (agent ?P ?REST))
  (capability ?CLASS agent ?REST))

(=>
  (and
    (instance ?C CateringService)
    (agent ?C ?AGENT)
    (destination ?C ?CUST)
    (located ?AGENT ?LOC1)
    (customer ?CUST ?AGENT)
    (exists (?S ?FOOD ?E)
      (and
        (instance ?S Cooking)
        (agent ?S ?AGENT)
        (result ?S ?FOOD)
        (patient ?C ?FOOD)
        (instance ?E Eating)
        (agent ?E ?CUST)
        (eventLocated ?E ?LOC2))))
  (not (equal ?LOC1 ?LOC2)))
        
(subclass FoodPickup CateringService)
(documentation FoodPickup EnglishLanguage "&%FoodPickup is a type of 
&%CateringService where the customer has to pick up the food from the 
agent's location with the intent of eating it somewhere else.")
(termFormat EnglishLanguage FoodPickup "food pickup")

(=>
  (and
    (instance ?P FoodPickup)
    (agent ?P ?AGENT)
    (destination ?P ?CUST)
    (patient ?P ?FOOD))
  (and
    (instance ?FOOD (FoodForFn Human))
    (exists (?LOC ?T ?G)
      (and
        (located ?AGENT ?LOC)
        (instance ?T Translocation)
        (agent ?T ?CUST)
        (destination ?T ?LOC)
        (instance ?G Getting)
        (origin ?G ?AGENT)
        (destination ?G ?CUST)
        (patient ?G ?FOOD)))))

(subclass DriveThru FoodPickup)
(documentation DriveThru EnglishLanguage "&%DriveThru is a type of 
&%FoodPickup where the customer uses a vehicle to drive thru a driveway 
and take the food from a window")
(termFormat EnglishLanguage DriveThru "Drive-thru")

;; ----------------------------------------------------------------------------
;; Reservations
;; ----------------------------------------------------------------------------

(subclass Reservation Agreement)
(documentation Reservation EnglishLanguage "a &%Reservation is a type of 
&%Agreement between 2 agents that some resource offered by the one agent 
is allotted for use or consumption by another at a specific bounded time")
(termFormat EnglishLanguage Reservation "reservation")

(=>
  (instance ?R Reservation)
  (exists (?P)
    (and
      (instance ?P Reserving)
      (result ?P ?R))))

(instance reservingEntity BinaryPredicate)
(documentation reservingEntity EnglishLanguage "(&%reservingEntity ?ENTITY 
?RESERVE) means that ?ENTITY is the &%AutonomousAgent reserving a particular resource 
indicated by ?RESERVE")
(domain reservingEntity 1 AutonomousAgent)
(domain reservingEntity 2 Reservation)

(=>
  (reservingEntity ?ENTITY ?RESERVE)
  (exists (?P)
    (and
      (instance ?P Reserving)
      (agent ?P ?ENTITY)
      (result ?P ?RESERVE))))

(instance reservationChannel BinaryPredicate)
(documentation reservationChannel EnglishLanguage "(&%reservationChannel 
?ENTITY ?RESERVE) means that ?ENTITY was used by the &%reservingEntity in 
order to create the reservation, like an intermediary agent.")
(domain reservationChannel 1 Physical)
(domain reservationChannel 2 Reservation)

(=>
  (reservationChannel ?ENTITY ?RESERVE)
  (exists (?P)
    (and
      (instance ?P Reserving)
      (instrument ?P ?ENTITY)
      (result ?P ?RESERVE))))
      
(instance fulfillingEntity BinaryPredicate)
(documentation fulfillingEntity EnglishLanguage "(&%fulfillingEntity 
?ENTITY ?RESERVE) means that ?ENTITY is the &%AutonomousAgent who will execute the 
agreement")
(domain fulfillingEntity 1 AutonomousAgent)
(domain fulfillingEntity 2 Reservation)

(=>
  (fulfillingEntity ?ENTITY ?RESERVE)
  (exists (?P)
    (and
      (instance ?P Reserving)
      (destination ?P ?ENTITY)
      (result ?P ?RESERVE))))

(instance reservationStart BinaryPredicate)
(documentation reservationStart EnglishLanguage "(&%reservationStart ?TIME 
?RESERVE) means that the use of a resource or consumption of a service 
which is the object of ?RESERVE starts at ?TIME")
(domain reservationStart 1 TimePoint)
(domain reservationStart 2 Reservation)

(instance reservationEnd BinaryPredicate)
(documentation reservationEnd EnglishLanguage "(&%reservationEnd ?TIME 
?RESERVE) means that the use of a resource or consumption of a service 
which is the object of ?RESERVE is expected to end at ?TIME")
(domain reservationEnd 1 TimePoint)
(domain reservationEnd 2 Reservation)

(=>
  (and
    (reservationStart ?TIME1 ?R)
    (reservationEnd ?TIME2 ?R)
    (reservingEntity ?CUST ?R)
    (fulfillingEntity ?AGENT ?R))
  (modalAttribute
    (holdsDuring 
      (TimeIntervalFn ?TIME1 ?TIME2)
      (exists (?P)
        (and
          (instance ?P IntentionalProcess)
          (agent ?P ?AGENT)
          (destination ?P ?CUST)))) Likely))

(instance numberOfCustomers BinaryPredicate)
(documentation numberOfCustomers EnglishLanguage "(&%numberOfCustomers ?NUM 
?RESERVE) refers to the number of patrons the reservation is for.")
(domain numberOfCustomers 1 PositiveInteger)
(domain numberOfCustomers 2 Reservation)

(=>
  (and
    (numberOfCustomers ?NUM ?RESERVE)
    (fulfillingEntity ?AGENT ?RESERVE)
    (reservingEntity ?CUST ?RESERVE))
  (exists (?GRP)
    (and
      (potentialCustomer ?GRP ?AGENT)
      (instance ?GRP GroupOfPeople)
      (member ?CUST ?GRP)
      (memberCount ?GRP ?NUM))))
                    
(subclass DiningReservation Reservation)
(documentation DiningReservation EnglishLanguage "a &%DiningReservation is 
a type of &%Reservation intended to reserve seats at a &%Restaurant")     
(termFormat EnglishLanguage DiningReservation "dining reservation")  

(=>
  (instance ?R DiningReservation)
  (exists (?AGENT)
    (and
      (fulfillingEntity ?AGENT ?R)
      (instance ?AGENT Restaurant))))

(subclass Reserving Committing)
(documentation Reserving EnglishLanguage "&%Reserving is a type of 
&%Committing that dedicates a specific object or service to a destination 
resource or service for a specific time interval")
(termFormat EnglishLanguage Reserving "reserving")

(=>
  (and
    (instance ?R Reserving)
    (agent ?R ?CUST)
    (destination ?R ?AGENT))
  (potentialCustomer ?CUST ?AGENT))

;; axiom for 'Requires Reservation' --> if a restaurant requires 
;; reservation, then the probability of a potentialCustomer becoming a 
;; customer if a reservation exists is higher
(=>
  (and
    (instance ?AGENT AutonomousAgent)
    (potentialCustomer ?CUST ?AGENT)
    (modalAttribute
      (and
        (instance ?R Reserving)
        (destination ?R ?AGENT)) Necessity)
    (conditionalProbability
      (exists (?RES1)
        (and
          (instance ?RES1 Reservation)
          (reservingEntity ?CUST ?RES1)
          (fulfillingEntity ?AGENT ?RES1)))
      (customer ?CUST ?AGENT) ?NUM1)
    (conditionalProbability
      (not
        (exists (?RES2)
          (and
            (instance ?RES2 Reservation)
            (reservingEntity ?CUST ?RES2)
            (fulfillingEntity ?AGENT ?RES2))))
      (customer ?CUST ?AGENT) ?NUM2))
  (lessThan ?NUM2 ?NUM1))
      

;; ----------------------------------------------------------------------------
;; General Concepts
;; ----------------------------------------------------------------------------


(instance potentialCustomer BinaryPredicate)
(documentation potentialCustomer EnglishLanguage "(&%potentialCustomer ?CUST ?AGENT) means 
that it is a possibility for ?CUST to participate in a financial transaction 
with ?AGENT in exchange for goods or services")
(domain potentialCustomer 1 CognitiveAgent)
(domain potentialCustomer 2 AutonomousAgent)

(=>
  (potentialCustomer ?CUST ?AGENT)
  (exists (?P ?SELLING)
    (and
      (instance ?SELLING Selling)
      (agent ?SELLING ?AGENT)
      (patient ?SELLING ?P)
      (inScopeOfInterest ?CUST ?P))))
      
(=>
  (potentialCustomer ?CUST ?AGENT)
  (modalAttribute
    (customer ?CUST ?AGENT) Possibility))

(instance Chef SkilledOccupation)
(documentation Chef EnglishLanguage "&%Chef refers to the &%Profession 
of cooking food")
(termFormat EnglishLanguage Chef "chef")

(=>
  (attribute ?X Chef)
  (occupation ?X
    (OccupationFn Cooking)))

   
(subclass BoosterChair Chair)
(documentation BoosterChair EnglishLanguage "&%BoosterChair is a &%Chair that 
is made for children")
(termFormat EnglishLanguage BoosterChair "booster chair")

(=>
  (and
    (instance ?BC BoosterChair)
    (instance ?H HumanChild))
  (hasPurposeForAgent ?BC
    (and
      (attribute ?H Sitting)
      (eventLocated ?H ?BC)) ?H))

;; KJN: Moving all of this to Mid-level-ontology.kif as it seems more appropriate there.      
;;(subclass Disability DiseaseOrSyndrome)
;; english definition taken from Wikipedia
;;(documentation Disability EnglishLanguage "&%Disability is a class of 
;;&%DiseaseOrSyndrome that describes impairments, activity limitations or participation 
;;restriction that may be physical, cognitive, mental, sensory, emotional, 
;;developmental or some combination")
;;(termFormat EnglishLanguage Disability "disability")

;;(subclass PhysicalDisability Disability)
;; english definition taken from Wikipedia
;;(documentation PhysicalDisability EnglishLanguage "&%PhysicalDisability is any 
;;impairment that limits the physical function of limbs or fine or gross motor ability, 
;;or limit the facets of daily living")
;;(termFormat EnglishLanguage PhysicalDisability "physical disability")

;;(subclass SensoryDisability Disability)
;; english definition taken from Wikipedia
;;(documentation SensoryDisability EnglishLanguage "&%SensoryDisability is any 
;;impairement of one of the five senses")
;;(termFormat EnglishLanguage SensoryDisability "sensory disability")

;;(instance Blind SensoryDisability)

;; add predicate for objects of contests in cases where what is being judged is not 
;; physical
(instance contestObject TernaryPredicate)
(documentation contestObject EnglishLanguage "(&%contestObject ?CONTEST ?OBJ ?AGENT) 
refers to the ?OBJ entered by ?AGENT in a ?CONTEST in cases where winning is based
on judging an &%Object instead of some physical process between opponents")
(domain contestObject 1 Contest)
(domain contestObject 2 Object)
(domain contestObject 3 AutonomousAgent)

(=>
  (contestObject ?CONTEST ?OBJ ?AGENT)
  (and
    (contestParticipant ?CONTEST ?AGENT)
    (exists (?MAKE ?JUDGE ?PROC ?AFTR)
      (and
        (instance ?MAKE Making)
        (result ?MAKE ?OBJ)
        (agent ?MAKE ?AGENT)
        (instance ?PROC Judging)
        (agent ?PROC ?JUDGE)
        (patient ?PROC ?OBJ)
        (result ?PROC (subjectiveAttribute ?OBJ ?AFTR ?JUDGE))
        (subProcess ?PROC ?CONTEST)))))

;; axiom for contest attribute Won

(=>
  (and
    (subjectiveAttribute ?X Won ?JUDGE)
    (instance ?X (FoodForFn Human)))
  (exists (?CONTEST ?AGENT ?PROC)
    (and
      (contestObject ?CONTEST ?X ?AGENT)
      (instance ?PROC Judging)
      (agent ?PROC ?JUDGE)
      (subProcess ?PROC ?CONTEST))))

;; add the notion of availability to capability
(instance capabilityDuring QuaternaryPredicate)
(documentation capabilityDuring EnglishLanguage "(&%capabilityDuring ?PROCESS ?ROLE 
?OBJ ?TIMEINT) means that ?OBJ has the ability to play the role of ?ROLE in the
process ?PROCESS during the time indicated by ?TIMEINT")
(termFormat EnglishLanguage capabilityDuring "capable during")
(domainSubclass capabilityDuring 1 Process)
(domain capabilityDuring 2 CaseRole)
(domain capabilityDuring 3 Object)
(domainSubclass capabilityDuring 4 TimeInterval)

(=> 
  (capabilityDuring ?PROCESS ?ROLE ?OBJ ?TIMEINT)
  (exists (?TIME)
    (and
      (instance ?TIME ?TIMEINT)
      (holdsDuring ?TIME
        (capability ?PROCESS ?ROLE ?OBJ)))))

;; ----------------------------------------------------------------------------
;; Other Features
;; ----------------------------------------------------------------------------  

(subclass View VisualContentBearingPhysical)
(documentation View EnglishLanguage "&%View refers to the patient of a 
&%Seeing process")
(termFormat EnglishLanguage View "view")

;; a view represents some physical thing (could be a process, such as "view of the
;; manufacturing process" if a person is sitting at an office overseeing a factory, or
;; could be objects such as "view of the casino" or, the more common "view of the
;; outdoors"
(=>
  (instance ?VIEW View)
  (exists (?ENTITY)
    (and
      (instance ?ENTITY Physical)
      (represents ?VIEW ?ENTITY))))

(instance OpenLayout RelationalAttribute)
(documentation OpenLayout EnglishLanguage "&%OpenLayout refers to different 
functional areas that are adjacent to each other and are visible from one 
area to another")
(termFormat EnglishLanguage OpenLayout "open layout")

(=>
  (attribute ?ROOM OpenLayout)
  (and
    (instance ?ROOM Room)
    (exists (?R1 ?R2)
      (and
        (instance ?R1 Region)
        (instance ?R2 Region)
        (located ?R1 ?ROOM)
        (located ?R2 ?ROOM)
        (not (equal ?R1 ?R2))
        (orientation ?R1 ?R2 Adjacent)
        (exists (?P1 ?P2)
          (and
            (instance ?P1 Process)
            (instance ?P2 Process)
            (hasPurpose ?R1 ?P1)
            (hasPurpose ?R2 ?P2)))
        (=>
          (and
            (instance ?H AutonomousAgent)
            (located ?H ?R2))
          (and
            (capability Seeing agent ?H)
            (capability Seeing patient ?R1)))))))

(subclass PlayArea Region)
(documentation PlayArea EnglishLanguage "&%PlayArea refers to a &%Region 
where children engage in recreational activities")
(termFormat EnglishLanguage PlayArea "playground")

(=>
  (instance ?P PlayArea)
  (hasPurpose ?P
    (exists (?K ?REC)
      (and
        (instance ?REC RecreationOrExercise)
        (eventLocated ?REC ?P)
        (instance ?K HumanChild)
        (agent ?REC ?K)))))

 
;; ----------------------------------------------------------------------------
;; Descriptors / Attributes
;; ----------------------------------------------------------------------------  

(instance Organic NormativeAttribute)
(documentation Organic EnglishLanguage "&%Organic describes the minimal 
use of chemicals in the production of an object")
(termFormat EnglishLanguage Organic "organic")

(instance Favorite SubjectiveAssessmentAttribute)
(documentation Favorite EnglishLanguage "&%Favorite is an attribute that describes
how an agent prefers one thing over another")
(termFormat EnglishLanguage Favorite "favorite")

(=>
  (and
    (subjectiveAttribute ?X Favorite ?AGENT)
    (instance ?X ?CLASS))
  (exists (?Y)
    (and
      (not (subjectiveAttribute ?Y Favorite ?AGENT))
      (instance ?Y ?CLASS)
      (prefers ?AGENT (wants ?AGENT ?X) (wants ?AGENT ?Y)))))

(subclass TimeAttribute SubjectiveAssessmentAttribute)
(documentation TimeAttribute EnglishLanguage "&%TimeAttribute refers to the class of
attributes that include and assessment of how long it takes an agent to do something")

(=>
  (and
    (subjectiveAttribute ?OBJ ?ATTR ?AGENT)
    (instance ?ATTR TimeAttribute))
  (instance ?OBJ AutonomousAgent))

(instance Quick TimeAttribute)
(documentation Quick EnglishLanguage "&%Quick describes how a process takes less 
time than expected")
(termFormat EnglishLanguage Quick "quick") 

(contraryAttribute Quick Slow)

(instance Slow TimeAttribute)
(documentation Slow EnglishLanguage "&%Slow describes how a process takes more 
time than expected")
(termFormat EnglishLanguage Slow "slow")  

(=>
  (and
    (subjectiveAttribute ?AGENT1 Quick ?PERSON)
    (subjectiveAttribute ?AGENT2 Slow ?PERSON)
    (instance ?PROCESS1 ?CLASS)
    (instance ?PROCESS2 ?CLASS)
    (subclass ?CLASS Process)
    (agent ?PROCESS1 ?AGENT1)
    (agent ?PROCESS2 ?AGENT2))
  (and
    (instance ?U UnitOfDuration)
    (duration (WhenFn ?PROCESS1) 
      (MeasureFn ?TIME1 ?U))
    (duration (WhenFn ?PROCESS2) 
      (MeasureFn ?TIME2 ?U))
    (greaterThan ?TIME2 ?TIME1)))
      
(subclass AmbienceAttribute SubjectiveAssessmentAttribute)
(documentation AmbienceAttribute EnglishLanguage "&%AmbienceAttribute describes the 
atmosphere or general feeling that something evokes")
(termFormat EnglishLanguage AmbienceAttribute "ambience")

(=>
  (and
    (attribute ?X ?ATTR)
    (instance ?ATTR AmbienceAttribute))
  (instance ?X Physical))

(instance RomanticAttribute AmbienceAttribute)
(documentation RomanticAttribute EnglishLanguage "&%RomanticAttribute describes that 
something is of an amorous or non-platonic nature")
(termFormat EnglishLanguage RomanticAttribute "romantic")

(instance UnconventionalAttribute AmbienceAttribute)
(documentation UnconventionalAttribute EnglishLanguage "&%UnconventionalAttribute describes 
that something does not conform to the ordinary or the usual")
(termFormat EnglishLanguage UnconventionalAttribute "unconventional")

(instance TrendyAttribute AmbienceAttribute)
(documentation TrendyAttribute EnglishLanguage "&%TrendyAttribute describes that something 
is in accord with the latest fad")
(termFormat EnglishLanguage TrendyAttribute "trendy")

(instance ConventionalAttribute AmbienceAttribute)
(documentation ConventionalAttribute EnglishLanguage "&%ConventionalAttribute describes that 
something conforms to norms and expectations")
(termFormat EnglishLanguage ConventionalAttribute "conventional")
(successorAttributeClosure ConventionalAttribute UnconventionalAttribute)

(instance CasualAttribute AmbienceAttribute)
(documentation CasualAttribute EnglishLanguage "&%CasualAttribute describes that something 
is appropriate for ordinary or routine occasions")
(termFormat EnglishLanguage CasualAttribute "casual") 

(instance FormalAttribute AmbienceAttribute)
(documentation FormalAttribute EnglishLanguage "&%FormalAttribute describes that something 
is refined or meets a certain standard")
(termFormat EnglishLanguage FormalAttribute "formal") 

(instance BusinessCasualAttribute AmbienceAttribute)
(documentation BusinessCasualAttribute EnglishLanguage "&%BusinessCasualAttribute describes 
that something is appropriate for a normal business setting")
(termFormat EnglishLanguage BusinessCasualAttribute "business casual") 

(instance BusinessFormalAttribute AmbienceAttribute)
(documentation BusinessFormalAttribute EnglishLanguage "&%BusinessFormalAttribute describes 
that something is appropriate for a stricter or more refined business setting")
(termFormat EnglishLanguage BusinessFormalAttribute "business formal") 

(instance CasualDressyAttribute AmbienceAttribute)
(documentation CasualDressyAttribute EnglishLanguage "&%CasualDressyAttribute describes that something
is fancier than &%CasualAttribute, normally applied to clothing but can also be applied
to things like the ambience of a club or bar")
(termFormat EnglishLanguage CasualDressyAttribute "casual dressy")

(instance DressyAttribute AmbienceAttribute)
(documentation DressyAttribute EnglishLanguage "&%DressyAttribute describes a less laid-back and fancier
atmosphere, normally applied to clothing but can also be applied to things like the 
ambience of a club, bar or event")
(termFormat EnglishLanguage DressyAttribute "dressy")

(subclass FoodAttribute SubjectiveAssessmentAttribute)
(documentation FoodAttribute EnglishLanguage "&%FoodAttribute are 
descriptors that apply to &%Food but are highly subjective")
(termFormat EnglishLanguage FoodAttribute "food attribute")

(=>
  (and
    (attribute ?OBJ ?ATTR)
    (instance ?ATTR FoodAttribute))
  (instance ?OBJ PreparedFood))

(instance ComfortFood FoodAttribute)
(documentation ComfortFood EnglishLanguage "&%ComfortFood describes 
&%PreparedFood that gives a sense of well-being, typically associated with 
childhood or with home cooking")
(termFormat EnglishLanguage ComfortFood "comfort food")

(instance HeartHealthyFood FoodAttribute)
(documentation HeartHealthyFood EnglishLanguage "&%HeartHealthyFood 
describes &%PreparedFood that has is low in sodium and other ingredients 
that may foster heart disease")
(termFormat EnglishLanguage HeartHealthyFood "heart-healthy food")

(=>
  (and
    (conditionalProbability
      (attribute ?X ComfortFood)
      (attribute ?X HeartHealthyFood) ?NUMBER1)
    (conditionalProbability
      (attribute ?X ComfortFood)
      (not (attribute ?X HeartHealthyFood)) ?NUMBER2))
  (lessThan ?NUMBER1 ?NUMBER2))

(instance FamilyStylePortion FoodAttribute)
(documentation FamilyStylePortion EnglishLanguage "&%FamilyStylePortion means that 
an instance of food can be shared by 3 or more people")
(termFormat EnglishLanguage FamilyStylePortion "family-style portions")

;; prepared food that has family style portion as an attribute has higher measure than
;; those that are not family-sized portions
(=>
  (and
    (attribute ?FOOD1 FamilyStylePortion)
    (measure ?FOOD1 
      (MeasureFn ?MEAS1 ?U))
    (not (attribute ?FOOD2 FamilyStylePortion))
    (measure ?FOOD2 
      (MeasureFn ?MEAS2 ?U))
    (instance ?FOOD1 ?CLASS)
    (instance ?FOOD2 ?CLASS)
    (instance ?U UnitOfMeasure))
  (greaterThan ?MEAS1 ?MEAS2))
 
;; KJN: Moving this to Mid-level-ontology.kif as it seems to be more of a common
;; notion versus one that is solely used in Dining.
;;(instance CommunalAttribute RelationalAttribute)
;;;(documentation CommunalAttribute EnglishLanguage "&%CommunalAttribute 
;;describes how an &%Object is shared by many")
;;(termFormat EnglishLanguage CommunalAttribute "communal")

;;(instance PrivateAttribute RelationalAttribute)
;;(documentation PrivateAttribute EnglishLanguage "&%PrivateAttribute describes how an 
;;object is not available to other people without the consent of the 
;;current owner")

;;(=>
;;  (attribute ?X CommunalAttribute)
;;  (instance ?X Object))

;;(=>
;;  (attribute ?X PrivateAttribute)
;;  (modalAttribute
;;    (not (attribute ?X CommunalAttribute)) Likely))

;;(=>
;;  (attribute ?X CommunalAttribute)
;;  (modalAttribute
;;    (not (attribute ?X PrivateAttribute)) Likely))

;; communal tables    
;; if a table is communal, then it's possible that 2 groups eating at the 
;; same time may do so at the same table
(=>
  (and
    (attribute ?X CommunalAttribute)
    (instance ?X Table)
    (instance ?E1 Eating)
    (agent ?E1 ?GRP1)
    (instance ?GRP1 GroupOfPeople)
    (eventLocated ?E1 ?X))
  (modalAttribute
    (exists (?GRP2 ?E2 ?X2)
      (and
        (instance ?E2 Eating)
        (agent ?E2 ?GRP2)
        (not (equal ?GRP1 ?GRP2))
        (instance ?GRP2 GroupOfPeople)
        (eventLocated ?E2 ?X2)
        (meetsTemporally (WhenFn ?E1) (WhenFn ?E2))
        (equal ?X ?X2))) Possibility))
    
;; private group room
(=>
  (and
    (instance ?REST Restaurant)
    (instance ?DR DiningRoom)
    (attribute ?DR PrivateAttribute)
    (possesses ?REST ?DR)
    (customer ?GRP1 ?REST)
    (instance ?E1 Eating)
    (agent ?E1 ?GRP1)
    (instance ?GRP1 GroupOfPeople))
  (modalAttribute
    (not (exists (?GRP2 ?E2)
      (and
        (customer ?GRP2 ?REST)
        (not (equal ?GRP1 ?GRP2))
        (instance ?E2 Eating)
        (agent ?E2 ?GRP2)
        (holdsDuring
          (WhenFn ?E1)
          (eventLocated ?E2 ?DR))))) Likely))

      
;; ----------------------------------------------------------------------------
;; Cuisine
;; ----------------------------------------------------------------------------      

(subclass Cuisine RelationalAttribute)
(documentation Cuisine EnglishLanguage "Cuisine is an attribute applied to 
classes of PreparedFood to specify that it is typical of a particular region 
or culture.  Note that it cannot be applied to a single Animal or Plant, even 
if a particular such entity is endemic to a particular region. It captures 
not just the reality of a particular combination of ingredients, but also 
the intent of the preparer to conform to a particular style of food and 
food preparation.")

(=>
  (and
    (attribute ?X ?Y)
    (instance ?Y Cuisine))
  (instance ?X PreparedFood))
  
(instance AsianCuisine Cuisine)  
(termFormat EnglishLanguage AsianCuisine "Asian Cuisine")
(instance CaribbeanCuisine Cuisine)  
(termFormat EnglishLanguage CaribbeanCuisine "Caribbean Cuisine")
(instance EuropeanCuisine Cuisine)  
(termFormat EnglishLanguage EuropeanCuisine "European Cuisine")
(instance LatinAmericanCuisine Cuisine)  
(termFormat EnglishLanguage LatinAmericanCuisine "Latin American Cuisine")
(instance AfricanCuisine Cuisine)  
(termFormat EnglishLanguage AfricanCuisine "African Cuisine")
(instance AmericanCuisine Cuisine)  
(termFormat EnglishLanguage AmericanCuisine "American Cuisine")
(instance AustralianCuisine Cuisine)  
(termFormat EnglishLanguage AustralianCuisine "Australian Cuisine")
(instance CanadianCuisine Cuisine)  
(termFormat EnglishLanguage CanadianCuisine "Canadian Cuisine")
(instance FusionCuisine Cuisine)  
(termFormat EnglishLanguage FusionCuisine "Fusion Cuisine")
(instance JewishCuisine Cuisine)  
(termFormat EnglishLanguage JewishCuisine "Jewish Cuisine")
(instance HealthFoodCuisine Cuisine)  
(termFormat EnglishLanguage HealthFoodCuisine "Health Food Cuisine")
(subAttribute CentralAfricanCuisine AfricanCuisine)  
(termFormat EnglishLanguage CentralAfricanCuisine "Central African Cuisine")  
(subAttribute EastAfricanCuisine AfricanCuisine) 
(termFormat EnglishLanguage EastAfricanCuisine "East African Cuisine")  
(subAttribute HornOfAfricaCuisine AfricanCuisine)  
(termFormat EnglishLanguage HornOfAfricaCuisine "Horn of Africa Cuisine")  
(subAttribute NorthAfricanCuisine AfricanCuisine)  
(termFormat EnglishLanguage NorthAfricanCuisine "North African Cuisine")  
(subAttribute SouthernAfricanCuisine AfricanCuisine)  
(termFormat EnglishLanguage SouthernAfricanCuisine "Southern African Cuisine")  
(subAttribute WestAfricanCuisine AfricanCuisine)  
(termFormat EnglishLanguage WestAfricanCuisine "West African Cuisine")  
(subAttribute IndianCuisine AsianCuisine)  
(termFormat EnglishLanguage IndianCuisine "Indian Cuisine")  
(subAttribute SouthAsianCuisine AsianCuisine)  
(termFormat EnglishLanguage SouthAsianCuisine "South Asian Cuisine")  
(subAttribute SoutheastAsianCuisine AsianCuisine)  
(termFormat EnglishLanguage SoutheastAsianCuisine "Southeast Asian Cuisine")  
(subAttribute EastAsianCuisine AsianCuisine)
(termFormat EnglishLanguage EastAsianCuisine "East Asian Cuisine")
(subAttribute WestAsianCuisine AsianCuisine)  
(termFormat EnglishLanguage WestAsianCuisine "West Asian Cuisine")  
(subAttribute ChineseCuisine AsianCuisine)  
(termFormat EnglishLanguage ChineseCuisine "Chinese Cuisine")  
(subAttribute PanAsianCuisine AsianCuisine)  
(termFormat EnglishLanguage PanAsianCuisine "Pan-Asian Cuisine")  
(subAttribute JapaneseCuisine EastAsianCuisine)  
(termFormat EnglishLanguage JapaneseCuisine "Japanese Cuisine")  
(subAttribute EasternEuropeanCuisine EuropeanCuisine)  
(termFormat EnglishLanguage EasternEuropeanCuisine "Eastern European Cuisine")  
(subAttribute MediterraneanCuisine EuropeanCuisine)  
(termFormat EnglishLanguage MediterraneanCuisine "Mediterranean Cuisine")  
(subAttribute NorthernEuropeanCuisine EuropeanCuisine)  
(termFormat EnglishLanguage NorthernEuropeanCuisine "Northern European Cuisine")  
(subAttribute WesternEuropeanCuisine EuropeanCuisine)  
(termFormat EnglishLanguage WesternEuropeanCuisine "Western European Cuisine")  
(subAttribute AlpineCuisine EuropeanCuisine)  
(termFormat EnglishLanguage AlpineCuisine "Alpine Cuisine")  
(subAttribute ContinentalCuisine EuropeanCuisine)  
(termFormat EnglishLanguage ContinentalCuisine "Continental Cuisine")  
(subAttribute ArabCuisine WestAsianCuisine)  
(termFormat EnglishLanguage ArabCuisine "Arab Cuisine")  
(subAttribute BritishCuisine NorthernEuropeanCuisine)  
(termFormat EnglishLanguage BritishCuisine "British Cuisine")  
(subAttribute NordicCuisine NorthernEuropeanCuisine)  
(termFormat EnglishLanguage NordicCuisine "Nordic Cuisine")  
(subAttribute IrishCuisine NorthernEuropeanCuisine)  
(termFormat EnglishLanguage IrishCuisine "Irish Cuisine")  
(subAttribute ScottishCuisine NorthernEuropeanCuisine)  
(termFormat EnglishLanguage ScottishCuisine "Scottish Cuisine")  
(subAttribute IndonesianCuisine SoutheastAsianCuisine)  
(termFormat EnglishLanguage IndonesianCuisine "Indonesian Cuisine")  
(subAttribute SpanishCuisine WesternEuropeanCuisine)  
(termFormat EnglishLanguage SpanishCuisine "Spanish Cuisine")  
(subAttribute AustrianCuisine WesternEuropeanCuisine)  
(termFormat EnglishLanguage AustrianCuisine "Austrian Cuisine")  
(subAttribute GermanCuisine WesternEuropeanCuisine)  
(termFormat EnglishLanguage GermanCuisine "German Cuisine")  
(subAttribute FrenchCuisine WesternEuropeanCuisine)  
(termFormat EnglishLanguage FrenchCuisine "French Cuisine")  
(subAttribute DutchCuisine WesternEuropeanCuisine)  
(termFormat EnglishLanguage DutchCuisine "Dutch Cuisine")  
(subAttribute SwissCuisine WesternEuropeanCuisine)  
(termFormat EnglishLanguage SwissCuisine "Swiss Cuisine")  
(subAttribute VienneseCuisine AustrianCuisine)  
(termFormat EnglishLanguage VienneseCuisine "Viennese Cuisine")  
(subAttribute BosnianCuisine MediterraneanCuisine)  
(termFormat EnglishLanguage BosnianCuisine "Bosnian Cuisine")  
(subAttribute BolivianCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage BolivianCuisine "Bolivian Cuisine")  
(subAttribute BelgianCuisine WesternEuropeanCuisine)  
(termFormat EnglishLanguage BelgianCuisine "Belgian Cuisine")  
(subAttribute NativeAmericanCuisine AmericanCuisine)  
(termFormat EnglishLanguage NativeAmericanCuisine "Native American Cuisine")  
(subAttribute NorthAmericanCuisine AmericanCuisine)  
(termFormat EnglishLanguage NorthAmericanCuisine "North American Cuisine")  
(subAttribute MidwesternCuisine AmericanCuisine)  
(termFormat EnglishLanguage MidwesternCuisine "Midwestern Cuisine")  
(subAttribute AmishCuisine AmericanCuisine)  
(termFormat EnglishLanguage AmishCuisine "Amish Cuisine")  
(subAttribute CreoleCuisine AmericanCuisine)  
(termFormat EnglishLanguage CreoleCuisine "Creole Cuisine")  
(subAttribute SouthernCuisine AmericanCuisine)  
(termFormat EnglishLanguage SouthernCuisine "Southern Cuisine")  
(subAttribute CalifornianCuisine AmericanCuisine)  
(termFormat EnglishLanguage CalifornianCuisine "Californian Cuisine")  
(subAttribute ChesapeakeCuisine AmericanCuisine)  
(termFormat EnglishLanguage ChesapeakeCuisine "Chesapeake Cuisine")  
(subAttribute SouthwesternCuisine AmericanCuisine)  
(termFormat EnglishLanguage SouthwesternCuisine "Southwestern Cuisine")  
(subAttribute FloridianCuisine AmericanCuisine)  
(termFormat EnglishLanguage FloridianCuisine "Floridian Cuisine")  
(subAttribute HawaiianCuisine AmericanCuisine)  
(termFormat EnglishLanguage HawaiianCuisine "Hawaiian Cuisine")  
(subAttribute NewEnglandCuisine AmericanCuisine)  
(termFormat EnglishLanguage NewEnglandCuisine "New England Cuisine")  
(subAttribute NewMexicanCuisine AmericanCuisine)  
(termFormat EnglishLanguage NewMexicanCuisine "New Mexican Cuisine")  
(subAttribute PennsylvaniaDutchCuisine AmericanCuisine)  
(termFormat EnglishLanguage PennsylvaniaDutchCuisine "Pennsylvania Dutch Cuisine")  
(subAttribute YemeniCuisine ArabCuisine)  
(termFormat EnglishLanguage YemeniCuisine "Yemeni Cuisine")  
(subAttribute NewZealandCuisine AustralianCuisine)  
(termFormat EnglishLanguage NewZealandCuisine "New Zealand Cuisine")  
(subAttribute BajanCuisine CaribbeanCuisine)  
(termFormat EnglishLanguage BajanCuisine "Bajan Cuisine")  
(subAttribute CubanCuisine CaribbeanCuisine)  
(termFormat EnglishLanguage CubanCuisine "Cuban Cuisine")  
(subAttribute DominicanCuisine CaribbeanCuisine)  
(termFormat EnglishLanguage DominicanCuisine "Dominican Cuisine")  
(subAttribute HaitianCuisine CaribbeanCuisine)  
(termFormat EnglishLanguage HaitianCuisine "Haitian Cuisine")  
(subAttribute JamaicanCuisine CaribbeanCuisine)  
(termFormat EnglishLanguage JamaicanCuisine "Jamaican Cuisine")  
(subAttribute TinidadianCuisine CaribbeanCuisine)  
(termFormat EnglishLanguage TinidadianCuisine "Trinidadian Cuisine")  
(subAttribute CentralAsianCuisine AsianCuisine)
(subAttribute AfghanCuisine CentralAsianCuisine)  
(termFormat EnglishLanguage AfghanCuisine "Afghan Cuisine")  
(subAttribute MongolianCuisine CentralAsianCuisine)  
(termFormat EnglishLanguage MongolianCuisine "Mongolian Cuisine")
(subAttribute TibetanCuisine CentralAsianCuisine)
(termFormat EnglishLanguage TibetanCuisine "Tibetan Cuisine")
(subAttribute UzbekiCuisine CentralAsianCuisine)  
(termFormat EnglishLanguage UzbekiCuisine "Uzbeki Cuisine")  
(subAttribute CantoneseCuisine ChineseCuisine)  
(termFormat EnglishLanguage CantoneseCuisine "Cantonese Cuisine")  
(subAttribute HunanCuisine ChineseCuisine)  
(termFormat EnglishLanguage HunanCuisine "Hunan Cuisine")  
(subAttribute MandarinCuisine ChineseCuisine)  
(termFormat EnglishLanguage MandarinCuisine "Mandarin Cuisine")  
(subAttribute PekingeseCuisine ChineseCuisine)  
(termFormat EnglishLanguage PekingeseCuisine "Pekingese Cuisine")  
(subAttribute SichuanCuisine ChineseCuisine)  
(termFormat EnglishLanguage SichuanCuisine "Sichuan Cuisine")  
(subAttribute SzechuanCuisine ChineseCuisine)  
(termFormat EnglishLanguage SzechuanCuisine "Szechuan Cuisine")  
(subAttribute KoreanCuisine EastAsianCuisine)  
(termFormat EnglishLanguage KoreanCuisine "Korean Cuisine")  
(subAttribute TaiwaneseCuisine EastAsianCuisine)  
(termFormat EnglishLanguage TaiwaneseCuisine "Taiwanese Cuisine")  
(subAttribute CzechCuisine EasternEuropeanCuisine)  
(termFormat EnglishLanguage CzechCuisine "Czech Cuisine")  
(subAttribute HungarianCuisine EasternEuropeanCuisine)  
(termFormat EnglishLanguage HungarianCuisine "Hungarian Cuisine")  
(subAttribute PolishCuisine EasternEuropeanCuisine)  
(termFormat EnglishLanguage PolishCuisine "Polish Cuisine")  
(subAttribute RomanianCuisine EasternEuropeanCuisine)  
(termFormat EnglishLanguage RomanianCuisine "Romanian Cuisine")  
(subAttribute RussianCuisine EasternEuropeanCuisine)  
(termFormat EnglishLanguage RussianCuisine "Russian Cuisine")  
(subAttribute UkrainianCuisine EasternEuropeanCuisine)  
(termFormat EnglishLanguage UkrainianCuisine "Ukrainian Cuisine")  
(subAttribute AlsatianCuisine FrenchCuisine)  
(termFormat EnglishLanguage AlsatianCuisine "Alsatian Cuisine")  
(subAttribute AuvergneCuisine FrenchCuisine)  
(termFormat EnglishLanguage AuvergneCuisine "Auvergne Cuisine")  
(subAttribute AveyronCuisine FrenchCuisine)  
(termFormat EnglishLanguage AveyronCuisine "Aveyron Cuisine")  
(subAttribute CorsicaCuisine FrenchCuisine)  
(termFormat EnglishLanguage CorsicaCuisine "Corsica Cuisine")  
(subAttribute BrittanyCuisine FrenchCuisine)  
(termFormat EnglishLanguage BrittanyCuisine "Brittany Cuisine")  
(subAttribute BurgundyCuisine FrenchCuisine)  
(termFormat EnglishLanguage BurgundyCuisine "Burgundy Cuisine")  
(subAttribute GasconyCuisine FrenchCuisine)  
(termFormat EnglishLanguage GasconyCuisine "Gascony Cuisine")  
(subAttribute HauteCuisine FrenchCuisine)  
(termFormat EnglishLanguage HauteCuisine "Haute Cuisine")  
(subAttribute LyonCuisine FrenchCuisine)  
(termFormat EnglishLanguage LyonCuisine "Lyon Cuisine")  
(subAttribute ProvencalCuisine FrenchCuisine)  
(termFormat EnglishLanguage ProvencalCuisine "Provencal Cuisine")  
(subAttribute EurasianCuisine FusionCuisine)  
(termFormat EnglishLanguage EurasianCuisine "Eurasian Cuisine") 
(subAttribute EurasianCuisine EuropeanCuisine) 
(subAttribute EurasianCuisine AsianCuisine)
(subAttribute AsianFusionCuisine FusionCuisine)  
(termFormat EnglishLanguage AsianFusionCuisine "Asian Fusion Cuisine") 
(subAttribute AsianFusionCuisine AsianCuisine) 
(subAttribute EuropeanFusionCuisine FusionCuisine)  
(termFormat EnglishLanguage EuropeanFusionCuisine "European Fusion Cuisine") 
(subAttribute EuropeanFusionCuisine EuropeanCuisine) 
(subAttribute FloribbeanCuisine FusionCuisine)  
(termFormat EnglishLanguage FloribbeanCuisine "Floribbean Cuisine") 
(subAttribute FloribbeanCuisine CaribbeanCuisine) 
(subAttribute FloribbeanCuisine AmericanCuisine)
(subAttribute FrenchIndianCuisine FusionCuisine)  
(termFormat EnglishLanguage FrenchIndianCuisine "French Indian Cuisine") 
(subAttribute FrenchIndianCuisine FrenchCuisine) 
(subAttribute FrenchIndianCuisine IndianCuisine)
(subAttribute InternationalCuisine FusionCuisine)  
(termFormat EnglishLanguage InternationalCuisine "International Cuisine")  
(subAttribute GlobalCuisine FusionCuisine)  
(termFormat EnglishLanguage GlobalCuisine "Global Cuisine")  
(subAttribute IslandCuisine FusionCuisine)  
(termFormat EnglishLanguage IslandCuisine "Island Cuisine")  
(subAttribute NewWorldCuisine FusionCuisine)  
(termFormat EnglishLanguage NewWorldCuisine "New World Cuisine")  
(subAttribute PacificRimCuisine FusionCuisine)  
(termFormat EnglishLanguage PacificRimCuisine "Pacific Rim Cuisine")  
(subAttribute SenegambianCuisine FusionCuisine)  
(termFormat EnglishLanguage SenegambianCuisine "Senegambian Cuisine") 
(subAttribute SenegambianCuisine SenegaleseCuisine) 
(subAttribute SenegambianCuisine GambianCuisine)
(subAttribute SeychellesCuisine FusionCuisine)  
(termFormat EnglishLanguage SeychellesCuisine "Seychelles Cuisine") 
(subAttribute SeychellesCuisine FrenchCuisine)
(subAttribute SouthPacificCuisine FusionCuisine)  
(termFormat EnglishLanguage SouthPacificCuisine "South Pacific Cuisine")  
(subAttribute ThaiFrenchCuisine FusionCuisine)  
(termFormat EnglishLanguage ThaiFrenchCuisine "Thai French Cuisine") 
(subAttribute ThaiFrenchCuisine ThaiCuisine) 
(subAttribute ThaiFrenchCuisine FrenchCuisine)
(subAttribute BavarianCuisine GermanCuisine)  
(termFormat EnglishLanguage BavarianCuisine "Bavarian Cuisine")  
(subAttribute EritreanCuisine HornOfAfricaCuisine)  
(termFormat EnglishLanguage EritreanCuisine "Eritrean Cuisine")  
(subAttribute EthiopianCuisine HornOfAfricaCuisine)  
(termFormat EnglishLanguage EthiopianCuisine "Ethiopian Cuisine")  
(subAttribute EastIndianCuisine IndianCuisine)  
(termFormat EnglishLanguage EastIndianCuisine "East Indian Cuisine")  
(subAttribute NorthIndianCuisine IndianCuisine)  
(termFormat EnglishLanguage NorthIndianCuisine "North Indian Cuisine")  
(subAttribute NortheastIndianCuisine IndianCuisine)  
(termFormat EnglishLanguage NortheastIndianCuisine "Northeast Indian Cuisine")  
(subAttribute SouthIndianCuisine IndianCuisine)  
(termFormat EnglishLanguage SouthIndianCuisine "South Indian Cuisine")  
(subAttribute WestIndianCuisine IndianCuisine)  
(termFormat EnglishLanguage WestIndianCuisine "West Indian Cuisine")  
(subAttribute HimalayanCuisine IndianCuisine)  
(termFormat EnglishLanguage HimalayanCuisine "Himalayan Cuisine")  
(subAttribute JavaneseCuisine IndonesianCuisine)  
(termFormat EnglishLanguage JavaneseCuisine "Javanese Cuisine")  
(subAttribute AbruzzeseCuisine ItalianCuisine)  
(termFormat EnglishLanguage AbruzzeseCuisine "Abruzzese Cuisine")  
(subAttribute EmilianCuisine ItalianCuisine)  
(termFormat EnglishLanguage EmilianCuisine "Emilian Cuisine")  
(subAttribute FlorentineCuisine ItalianCuisine)  
(termFormat EnglishLanguage FlorentineCuisine "Florentine Cuisine")  
(subAttribute LigurianCuisine ItalianCuisine)  
(termFormat EnglishLanguage LigurianCuisine "Ligurian Cuisine")  
(subAttribute LombardianCuisine ItalianCuisine)  
(termFormat EnglishLanguage LombardianCuisine "Lombardian Cuisine")  
(subAttribute MarchigianaCuisine ItalianCuisine)  
(termFormat EnglishLanguage MarchigianaCuisine "Marchigiana Cuisine")  
(subAttribute MilaneseCuisine ItalianCuisine)  
(termFormat EnglishLanguage MilaneseCuisine "Milanese Cuisine")  
(subAttribute NeapolitanCuisine ItalianCuisine)  
(termFormat EnglishLanguage NeapolitanCuisine "Neapolitan Cuisine")  
(subAttribute RomanCuisine ItalianCuisine)  
(termFormat EnglishLanguage RomanCuisine "Roman Cuisine")  
(subAttribute PiedmonteseCuisine ItalianCuisine)  
(termFormat EnglishLanguage PiedmonteseCuisine "Piedmontese Cuisine")  
(subAttribute SardinianCuisine ItalianCuisine)  
(termFormat EnglishLanguage SardinianCuisine "Sardinian Cuisine")  
(subAttribute SicilianCuisine ItalianCuisine)  
(termFormat EnglishLanguage SicilianCuisine "Sicilian Cuisine")  
(subAttribute TuscanCuisine ItalianCuisine)  
(termFormat EnglishLanguage TuscanCuisine "Tuscan Cuisine")  
(subAttribute VenetianCuisine ItalianCuisine)  
(termFormat EnglishLanguage VenetianCuisine "Venetian Cuisine")  
(subAttribute ArgentineanCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage ArgentineanCuisine "Argentinean Cuisine")  
(subAttribute BrazilianCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage BrazilianCuisine "Brazilian Cuisine")  
(subAttribute CapeVerdeanCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage CapeVerdeanCuisine "CapeVerdean Cuisine")  
(subAttribute CentralAmericanCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage CentralAmericanCuisine "Central American Cuisine")  
(subAttribute ChileanCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage ChileanCuisine "Chilean Cuisine")  
(subAttribute ColombianCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage ColombianCuisine "Colombian Cuisine")  
(subAttribute MexicanCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage MexicanCuisine "Mexican Cuisine")  
(subAttribute CostaRicanCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage CostaRicanCuisine "Costa Rican Cuisine")  
(subAttribute EcuadorianCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage EcuadorianCuisine "Ecuadorian Cuisine")  
(subAttribute GuatemalanCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage GuatemalanCuisine "Guatemalan Cuisine")  
(subAttribute GuyaneseCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage GuyaneseCuisine "Guyanese Cuisine")  
(subAttribute HonduranCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage HonduranCuisine "Honduran Cuisine")  
(subAttribute NicaraguanCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage NicaraguanCuisine "Nicaraguan Cuisine")  
(subAttribute PanLatinCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage PanLatinCuisine "Pan Latin Cuisine")  
(subAttribute ParaguayanCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage ParaguayanCuisine "Paraguayan Cuisine")  
(subAttribute PeruvianCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage PeruvianCuisine "Peruvian Cuisine")  
(subAttribute PuertoRicanCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage PuertoRicanCuisine "Puerto Rican Cuisine")  
(subAttribute SalvadoranCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage SalvadoranCuisine "Salvadoran Cuisine")  
(subAttribute UruguayanCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage UruguayanCuisine "Uruguayan Cuisine")  
(subAttribute VenezuelanCuisine LatinAmericanCuisine)  
(termFormat EnglishLanguage VenezuelanCuisine "Venezuelan Cuisine")  
(subAttribute PalestinianCuisine LevantineCuisine)  
(termFormat EnglishLanguage PalestinianCuisine "Palestinian Cuisine")  
(subAttribute ItalianCuisine MediterraneanCuisine)  
(termFormat EnglishLanguage ItalianCuisine "Italian Cuisine")  
(subAttribute CypriotCuisine MediterraneanCuisine)  
(termFormat EnglishLanguage CypriotCuisine "Greek Cypriot Cuisine")  
(subAttribute CroatianCuisine MediterraneanCuisine)  
(termFormat EnglishLanguage CroatianCuisine "Croatian Cuisine")  
(subAttribute GreekCuisine MediterraneanCuisine)  
(termFormat EnglishLanguage GreekCuisine "Greek Cuisine")  
(subAttribute SerbianCuisine MediterraneanCuisine)  
(termFormat EnglishLanguage SerbianCuisine "Serbian Cuisine")  
(subAttribute SlavicCuisine MediterraneanCuisine)  
(termFormat EnglishLanguage SlavicCuisine "Slavic Cuisine")  
(subAttribute TurkishCuisine MediterraneanCuisine)  
(termFormat EnglishLanguage TurkishCuisine "Turkish Cuisine")  
(subAttribute MayanCuisine MexicanCuisine)  
(termFormat EnglishLanguage MayanCuisine "Mayan Cuisine")  
(subAttribute ArmenianCuisine EasternEuropeanCuisine)  
(termFormat EnglishLanguage ArmenianCuisine "Armenian Cuisine")  
(subAttribute CaspianCuisine PersianCuisine)  
(termFormat EnglishLanguage CaspianCuisine "Caspian Cuisine")  
(subAttribute IranianCuisine MiddleEasternCuisine)  
(termFormat EnglishLanguage IranianCuisine "Iranian Cuisine")  
(subAttribute IraqiCuisine MiddleEasternCuisine)  
(termFormat EnglishLanguage IraqiCuisine "Iraqi Cuisine")  
(subAttribute IsraeliCuisine LevantineCuisine)  
(termFormat EnglishLanguage IsraeliCuisine "Israeli Cuisine")  
(subAttribute LebaneseCuisine LevantineCuisine)  
(termFormat EnglishLanguage LebaneseCuisine "Lebanese Cuisine")  
(subAttribute MesopotamianCuisine MiddleEasternCuisine)  
(termFormat EnglishLanguage MesopotamianCuisine "Mesopotamian Cuisine")  
(subAttribute PersianCuisine MiddleEasternCuisine)  
(termFormat EnglishLanguage PersianCuisine "Persian Cuisine")  
(subAttribute SyrianCuisine LevantineCuisine)  
(termFormat EnglishLanguage SyrianCuisine "Syrian Cuisine")  
(subAttribute TunisianCuisine MediterraneanCuisine)  
(termFormat EnglishLanguage TunisianCuisine "Tunisian Cuisine")  
(subAttribute DanishCuisine NordicCuisine)  
(termFormat EnglishLanguage DanishCuisine "Danish Cuisine")  
(subAttribute FinnishCuisine NordicCuisine)  
(termFormat EnglishLanguage FinnishCuisine "Finnish Cuisine")  
(subAttribute IcelandicCuisine NordicCuisine)  
(termFormat EnglishLanguage IcelandicCuisine "Icelandic Cuisine")  
(subAttribute NorwegianCuisine NordicCuisine)  
(termFormat EnglishLanguage NorwegianCuisine "Norwegian Cuisine")  
(subAttribute SwedishCuisine NordicCuisine)  
(termFormat EnglishLanguage SwedishCuisine "Swedish Cuisine")  
(subAttribute EgyptianCuisine NorthAfricanCuisine)  
(termFormat EnglishLanguage EgyptianCuisine "Egyptian Cuisine")  
(subAttribute MoroccanCuisine NorthAfricanCuisine)  
(termFormat EnglishLanguage MoroccanCuisine "Moroccan Cuisine")  
(subAttribute BangladeshiCuisine SouthAsianCuisine)  
(termFormat EnglishLanguage BangladeshiCuisine "Bangladeshi Cuisine")  
(subAttribute NepaleseCuisine SouthAsianCuisine)  
(termFormat EnglishLanguage NepaleseCuisine "Nepalese Cuisine")  
(subAttribute PakistaniCuisine SouthAsianCuisine)  
(termFormat EnglishLanguage PakistaniCuisine "Pakistani Cuisine")  
(subAttribute SriLankanCuisine SouthAsianCuisine)  
(termFormat EnglishLanguage SriLankanCuisine "Sri Lankan Cuisine")  
(subAttribute BurmeseCuisine SoutheastAsianCuisine)  
(termFormat EnglishLanguage BurmeseCuisine "Burmese Cuisine")  
(subAttribute CambodianCuisine SoutheastAsianCuisine)  
(termFormat EnglishLanguage CambodianCuisine "Cambodian Cuisine")  
(subAttribute FilipinoCuisine SoutheastAsianCuisine)  
(termFormat EnglishLanguage FilipinoCuisine "Filipino Cuisine")  
(subAttribute MalaysianCuisine SoutheastAsianCuisine)  
(termFormat EnglishLanguage MalaysianCuisine "Malaysian Cuisine")  
(subAttribute LaotianCuisine SoutheastAsianCuisine)  
(termFormat EnglishLanguage LaotianCuisine "Laotian Cuisine")  
(subAttribute SingaporeanCuisine SoutheastAsianCuisine)  
(termFormat EnglishLanguage SingaporeanCuisine "Singaporean Cuisine")  
(subAttribute ThaiCuisine SoutheastAsianCuisine)  
(termFormat EnglishLanguage ThaiCuisine "Thai Cuisine")  
(subAttribute VietnameseCuisine SoutheastAsianCuisine)  
(termFormat EnglishLanguage VietnameseCuisine "Vietnamese Cuisine")  
(subAttribute SouthAfricanCuisine SouthernAfricanCuisine)  
(termFormat EnglishLanguage SouthAfricanCuisine "South African Cuisine")  
(subAttribute TexMexCuisine SouthwesternCuisine)  
(termFormat EnglishLanguage TexMexCuisine "Tex Mex Cuisine")  
(subAttribute BasqueCuisine SpanishCuisine)  
(termFormat EnglishLanguage BasqueCuisine "Basque Cuisine")  
(subAttribute IberianCuisine SpanishCuisine)  
(termFormat EnglishLanguage IberianCuisine "Iberian Cuisine")  
(subAttribute ValencianCuisine SpanishCuisine)  
(termFormat EnglishLanguage ValencianCuisine "Valencian Cuisine")  
(subAttribute AndalusianCuisine SpanishCuisine)  
(termFormat EnglishLanguage AndalusianCuisine "Andalusian Cuisine")  
(subAttribute CantabrianCuisine SpanishCuisine)  
(termFormat EnglishLanguage CantabrianCuisine "Cantabrian Cuisine")  
(subAttribute CastilianCuisine SpanishCuisine)  
(termFormat EnglishLanguage CastilianCuisine "Castillan Cuisine")  
(subAttribute CatalanCuisine SpanishCuisine)  
(termFormat EnglishLanguage CatalanCuisine "Catalan Cuisine")  
(subAttribute GalicianCuisine SpanishCuisine)  
(termFormat EnglishLanguage GalicianCuisine "Galician Cuisine")  
(subAttribute MadrilianCuisine SpanishCuisine)  
(termFormat EnglishLanguage MadrilianCuisine "Madrilian Cuisine")  
(subAttribute NavarraiseCuisine SpanishCuisine)  
(termFormat EnglishLanguage NavarraiseCuisine "Navarraise Cuisine")  
(subAttribute GhanianCuisine WestAfricanCuisine)  
(termFormat EnglishLanguage GhanianCuisine "Ghanian Cuisine")  
(subAttribute SenegaleseCuisine WestAfricanCuisine)  
(termFormat EnglishLanguage SenegaleseCuisine "Senegalese Cuisine")  
(subAttribute GambianCuisine WestAfricanCuisine)  
(termFormat EnglishLanguage GambianCuisine "Gambian Cuisine")  
(subAttribute LevantineCuisine WestAsianCuisine)  
(termFormat EnglishLanguage LevantineCuisine "Levantine Cuisine")  
(subAttribute MiddleEasternCuisine WestAsianCuisine)  
(termFormat EnglishLanguage MiddleEasternCuisine "Middle Eastern Cuisine")  
(subAttribute CajunCuisine CaribbeanCuisine)  
(termFormat EnglishLanguage CajunCuisine "Cajun Cuisine")  
(subAttribute PortugueseCuisine WesternEuropeanCuisine)  
(termFormat EnglishLanguage PortugueseCuisine "Portuguese Cuisine")  
(subAttribute PolynesianCuisine FusionCuisine)  
(termFormat EnglishLanguage PolynesianCuisine "Polynesian Cuisine")  
(subAttribute ShanghaineseCuisine ChineseCuisine)  
(termFormat EnglishLanguage ShanghaineseCuisine "Shanghainese Cuisine")