sunserver1[102] neoclassic
neoclassic
NeoClassic> (reinitCollection)
(reinitCollection)
[none]
NeoClassic> (createDisjointGroup classic-thing-type)
(createDisjointGroup classic-thing-type)
classic-thing-type
NeoClassic> (createConcept WINE-PROPERTY ClassicThing classic-thing-type)
(createConcept WINE-PROPERTY ClassicThing classic-thing-type)
WINE-PROPERTY
NeoClassic> (createConcept CONSUMABLE-THING ClassicThing classic-thing-type)
(createConcept CONSUMABLE-THING ClassicThing classic-thing-type)
CONSUMABLE-THING
NeoClassic> (createConcept WINERY ClassicThing classic-thing-type)
(createConcept WINERY ClassicThing classic-thing-type)
WINERY
NeoClassic> (createConcept WINE-REGION ClassicThing classic-thing-type)
(createConcept WINE-REGION ClassicThing classic-thing-type)
WINE-REGION
NeoClassic> (createConcept C(and WINE-PROPERTY WINE-REGION))
(createConcept C(and WINE-PROPERTY WINE-REGION))
Incoherent concept returned: C
Reason:  DisjointPrimsConflict: WINE-PROPERTY, WINE-REGION 
C
NeoClassic> (createIndividual Ind(and WINERY WINE-REGION))
(createIndividual Ind(and WINERY WINE-REGION))
Inconsistent individual returned: Ind
Reason:  DisjointPrimsConflict: WINERY, WINE-REGION 
Ind
NeoClassic> (concept WINERY)
(concept WINERY)
WINERY
NeoClassic> (printInfo WINE-REGION)
(printInfo WINE-REGION)
======================== ClassicConcept ========================
|| Name:                   WINE-REGION
||    Primitive:           {classic-thing-type}
||    Primitives:          {WINE-REGION}
||    Rules:               {}
|| Ingredients:
||    Told Parents:        {TOP}
|| Taxonomy:
||    Parents:             {TOP}
||    Children:            {}
||    DirectInstances      {}
|| Soup:
||    Primitive Ancestors: {}
||    One of:              {}
||    RoleRestrictions:    {}
||    Tests:               {}
||    Incoherent?          0
================================================================

[none]
NeoClassic> (getPrimitive WINE-REGION)
(getPrimitive WINE-REGION)
{classic-thing-type}
NeoClassic> (getChildren ClassicThing)
(getChildren ClassicThing)
{WINE-PROPERTY, CONSUMABLE-THING, WINERY, WINE-REGION}
NeoClassic> (getChildren HostThing)
(getChildren HostThing)
{NUMBER, STRING}
NeoClassic> (getDescendants NUMBER)
(getDescendants NUMBER)
{INTEGER, FLOAT}
NeoClassic> (getPrimitive INTEGER)
(getPrimitive INTEGER)
0
NeoClassic> (getChildren INTEGER)
(getChildren INTEGER)
{}
NeoClassic> (getParents WINE-REGION)
(getParents WINE-REGION)
{TOP}
NeoClassic> (getAncestors WINE-REGION)
(getAncestors WINE-REGION)
{TOP}
NeoClassic> (getAncestors WINERY)
(getAncestors WINERY)
{TOP}
NeoClassic> (getPrimitive TOP)
(getPrimitive TOP)
0
NeoClassic> (createDisjointGroup consumable-thing-type)
(createDisjointGroup consumable-thing-type)
consumable-thing-type
NeoClassic> (createConcept EDIBLE-THING CONSUMABLE-THING consumable-thing-type)
(createConcept EDIBLE-THING CONSUMABLE-THING consumable-thing-type)
EDIBLE-THING
NeoClassic> (createConcept POTABLE-LIQUID CONSUMABLE-THING consumable-thing-type)
(createConcept POTABLE-LIQUID CONSUMABLE-THING consumable-thing-type)
POTABLE-LIQUID
NeoClassic> (printInfo CONSUMABLE-THING)
(printInfo CONSUMABLE-THING)
======================== ClassicConcept ========================
|| Name:                   CONSUMABLE-THING
||    Primitive:           {classic-thing-type}
||    Primitives:          {CONSUMABLE-THING}
||    Rules:               {}
|| Ingredients:
||    Told Parents:        {TOP}
|| Taxonomy:
||    Parents:             {TOP}
||    Children:            {EDIBLE-THING, POTABLE-LIQUID}
||    DirectInstances      {}
|| Soup:
||    Primitive Ancestors: {}
||    One of:              {}
||    RoleRestrictions:    {}
||    Tests:               {}
||    Incoherent?          0
================================================================

[none]
NeoClassic> (printInfo EDIBLE-THING)
(printInfo EDIBLE-THING)
======================== ClassicConcept ========================
|| Name:                   EDIBLE-THING
||    Primitive:           {consumable-thing-type}
||    Primitives:          {EDIBLE-THING, CONSUMABLE-THING}
||    Rules:               {}
|| Ingredients:
||    Told Parents:        {CONSUMABLE-THING}
|| Taxonomy:
||    Parents:             {CONSUMABLE-THING}
||    Children:            {}
||    DirectInstances      {}
|| Soup:
||    Primitive Ancestors: {}
||    One of:              {}
||    RoleRestrictions:    {}
||    Tests:               {}
||    Incoherent?          0
================================================================

[none]
NeoClassic> (and WINE-COLOR WINE-PROPERTY
(and WINE-COLOR WINE-PROPERTY
NeoClassic 1> (oneOf White Rose Red))
(oneOf White Rose Red))
 
Line 26: ERROR: no compatible definition found for and
      in form [and, WINE-COLOR, WINE-PROPERTY, (oneOf Red Rose White)]
      with argument types <Symbol> <Symbol> <Classic Construct> 
Usage: (and <Description>...)
      Problem: Cannot convert argument 1
Usage: (and )
      Problem: Too Many Arguments
[none]
NeoClassic> (and WINE-COLOR WINE-PROPERTY (oneOf Red Rose White))
(and WINE-COLOR WINE-PROPERTY (oneOf Red Rose White))
 
Line 28: ERROR: no compatible definition found for and
      in form [and, WINE-COLOR, WINE-PROPERTY, (oneOf White Rose Red)]
      with argument types <Symbol> <Symbol> <Classic Construct> 
Usage: (and <Description>...)
      Problem: Cannot convert argument 1
Usage: (and )
      Problem: Too Many Arguments
[none]
NeoClassic> (and WINE-COLOR (and WINE-PROPERTY (oneOf White Rose Red)))
(and WINE-COLOR (and WINE-PROPERTY (oneOf White Rose Red)))
 
Line 29: ERROR: no compatible definition found for and
      in form [and, WINE-COLOR, (and WINE-PROPERTY (oneOf Red Rose White))]
      with argument types <Symbol> <Classic Construct> 
Usage: (and <Description>...)
      Problem: Cannot convert argument 1
Usage: (and )
      Problem: Too Many Arguments
[none]
NeoClassic> (and WINE-COLOR (and WINE-PROPERTY (and (oneOf White Rose Red))))
(and WINE-COLOR (and WINE-PROPERTY (and (oneOf White Rose Red))))
 
Line 30: ERROR: no compatible definition found for and
      in form [and, WINE-COLOR, (and WINE-PROPERTY (oneOf Red Rose White))]
      with argument types <Symbol> <Classic Construct> 
Usage: (and <Description>...)
      Problem: Cannot convert argument 1
Usage: (and )
      Problem: Too Many Arguments
[none]
NeoClassic> (getInfo WINE-PROPERTY)
(getInfo WINE-PROPERTY)
 
Line 31: ERROR: no function definitions found for getInfo
      in form [getInfo, WINE-PROPERTY]
      with argument types <Symbol> 
[none]
NeoClassic> (printInfo WINE-PROPERTY)
(printInfo WINE-PROPERTY)
======================== ClassicConcept ========================
|| Name:                   WINE-PROPERTY
||    Primitive:           {classic-thing-type}
||    Primitives:          {WINE-PROPERTY}
||    Rules:               {}
|| Ingredients:
||    Told Parents:        {TOP}
|| Taxonomy:
||    Parents:             {TOP}
||    Children:            {}
||    DirectInstances      {}
|| Soup:
||    Primitive Ancestors: {}
||    One of:              {}
||    RoleRestrictions:    {}
||    Tests:               {}
||    Incoherent?          0
================================================================

[none]
NeoClassic> (createConcept WINE-COLOR WINE-PROPERTY (and oneOf White Rose Red))
(createConcept WINE-COLOR WINE-PROPERTY (and oneOf White Rose Red))
 
Line 33: ERROR: no compatible definition found for and
      in form [and, oneOf, White, Rose, Red]
      with argument types <Symbol> <Symbol> <Symbol> <Symbol> 
Usage: (and <Description>...)
      Problem: Cannot convert argument 1
Usage: (and )
      Problem: Too Many Arguments
[none]
NeoClassic> (createConcept WINE-COLOR WINE-PROPERTY (oneOf White Rose Red))
(createConcept WINE-COLOR WINE-PROPERTY (oneOf White Rose Red))
 
Line 34: ERROR: no compatible definition found for createConcept
      in form [createConcept, WINE-COLOR, WINE-PROPERTY, (oneOf Red Rose White)]
      with argument types <Symbol> <Symbol> <Classic Construct> 
Usage: (createConcept <Symbol> <Host Description>)
      Problem: Too Many Arguments
Usage: (createConcept <Symbol> <Classic Description> <Symbol>...)
      Problem: Cannot convert argument 3
Usage: (createConcept <Symbol> <Classic Description> [ <Boolean> ])
      Problem: Cannot convert argument 3
[none]
NeoClassic> (createConcept WINE-COLOR (and WINE-PROPERTY (oneOf White Rose Red)))
(createConcept WINE-COLOR (and WINE-PROPERTY (oneOf White Rose Red)))
WINE-COLOR
NeoClassic> (getInstances WINE-COLOR)
(getInstances WINE-COLOR)
{}
NeoClassic> (printInfo WINE-PROPERTY)
(printInfo WINE-PROPERTY)
======================== ClassicConcept ========================
|| Name:                   WINE-PROPERTY
||    Primitive:           {classic-thing-type}
||    Primitives:          {WINE-PROPERTY}
||    Rules:               {}
|| Ingredients:
||    Told Parents:        {TOP}
|| Taxonomy:
||    Parents:             {TOP}
||    Children:            {WINE-COLOR}
||    DirectInstances      {}
|| Soup:
||    Primitive Ancestors: {}
||    One of:              {}
||    RoleRestrictions:    {}
||    Tests:               {}
||    Incoherent?          0
================================================================

[none]
NeoClassic> (createConcept WINE-BODY (and WINE-PROPERTY (oneOf Full Medium Light)))
(createConcept WINE-BODY (and WINE-PROPERTY (oneOf Full Medium Light)))
WINE-BODY
NeoClassic> (createConcept WINE-SUGAR (and WINE-PROPERTY (oneOf Dry Off-dry Sweet)))
(createConcept WINE-SUGAR (and WINE-PROPERTY (oneOf Dry Off-dry Sweet)))
WINE-SUGAR
NeoClassic> (createConcept WINE-FLAVOR (and WINE-PROPERTY (oneOf Delicate Moderate Strong)))
(createConcept WINE-FLAVOR (and WINE-PROPERTY (oneOf Delicate Moderate Strong)))
WINE-FLAVOR
NeoClassic> (printInfo WINE-PROPERTY)
 (printInfo WINE-PROPERTY)
======================== ClassicConcept ========================
|| Name:                   WINE-PROPERTY
||    Primitive:           {classic-thing-type}
||    Primitives:          {WINE-PROPERTY}
||    Rules:               {}
|| Ingredients:
||    Told Parents:        {TOP}
|| Taxonomy:
||    Parents:             {TOP}
||    Children:            {WINE-COLOR, WINE-BODY, WINE-SUGAR, WINE-FLAVOR}
||    DirectInstances      {}
|| Soup:
||    Primitive Ancestors: {}
||    One of:              {}
||    RoleRestrictions:    {}
||    Tests:               {}
||    Incoherent?          0
================================================================

[none]
NeoClassic> (addToldInformation White WINE-COLOR)
(addToldInformation White WINE-COLOR)
White
NeoClassic> (getInstances WINE-COLOR)
(getInstances WINE-COLOR)
{White}
NeoClassic> (getDescendents WINE-PROPERTY)
(getDescendents WINE-PROPERTY)
 
Line 44: ERROR: no function definitions found for getDescendents
      in form [getDescendents, WINE-PROPERTY]
      with argument types <Symbol> 
[none]
NeoClassic> (getDescendants WINE-PROPERTY)
(getDescendants WINE-PROPERTY)
{WINE-COLOR, WINE-BODY, WINE-SUGAR, WINE-FLAVOR}
NeoClassic> (getDescendants classic-thing-type)
(getDescendants classic-thing-type)
 
Line 46: ERROR: no compatible definition found for getDescendants
      in form [getDescendants, classic-thing-type]
      with argument types <Symbol> 
Usage: (getDescendants <Host Concept>)
      Problem: Cannot convert argument 1
Usage: (getDescendants <Classic Concept>)
      Problem: Cannot convert argument 1
[none]
NeoClassic> (getDescendants classic-thing-type)
(getDescendants classic-thing-type)
 
Line 47: ERROR: no compatible definition found for getDescendants
      in form [getDescendants, classic-thing-type]
      with argument types <Symbol> 
Usage: (getDescendants <Host Concept>)
      Problem: Cannot convert argument 1
Usage: (getDescendants <Classic Concept>)
      Problem: Cannot convert argument 1
[none]
NeoClassic> (printInfo WINE-BODY)
(printInfo WINE-BODY)
======================== ClassicConcept ========================
|| Name:                   WINE-BODY
||    Primitive:           0
||    Primitives:          {WINE-PROPERTY}
||    Rules:               {}
|| Ingredients:
||    Told Parents:        {WINE-PROPERTY}
||    Components:          {(oneOf Light Medium Full)}
|| Taxonomy:
||    Parents:             {WINE-PROPERTY}
||    Children:            {}
||    DirectInstances      {}
|| Soup:
||    Primitive Ancestors: {WINE-PROPERTY}
||    One of:              {Light, Medium, Full}
||    RoleRestrictions:    {}
||    Tests:               {}
||    Incoherent?          0
================================================================

[none]
NeoClassic> (getChildren WINE-COLOR)
(getChildren WINE-COLOR)
{}
NeoClassic> (getDirectInstances ClassicThing)
(getDirectInstances ClassicThing)
{Strong, Moderate, Delicate, Sweet, Off-dry, Dry, Light, Medium, Full, Red, Rose}
NeoClassic> (getDirectInstances WINE-PROPERTY)
(getDirectInstances WINE-PROPERTY)
{}
NeoClassic> (getDirectInstances WINE-COLOR)
(getDirectInstances WINE-COLOR)
{White}
NeoClassic> (getParents Sweet)
(getParents Sweet)
{TOP}
NeoClassic> (getAncestors Strong)
(getAncestors Strong)
{TOP}
NeoClassic> 

NeoClassic> (addToldInformation Rose WINE-COLOR)
(addToldInformation Rose WINE-COLOR)
Rose
NeoClassic> (addToldInformation Red WINE-COLOR)
(addToldInformation Red WINE-COLOR)
Red
NeoClassic> (addToldInformation Full WINE-BODY)
(addToldInformation Full WINE-BODY)
Full
NeoClassic> (addToldInformation Medium WINE-BODY)
(addToldInformation Medium WINE-BODY)
Medium
NeoClassic> (addToldInformation Light WINE-BODY)
(addToldInformation Light WINE-BODY)
Light
NeoClassic> (addToldInformation Delicate WINE-FLAVOR)
(addToldInformation Delicate WINE-FLAVOR)
Delicate
NeoClassic> (addToldInformation Moderate WINE-FLAVOR)
(addToldInformation Moderate WINE-FLAVOR)
Moderate
NeoClassic> (addToldInformation Strong WINE-FLAVOR)
(addToldInformation Strong WINE-FLAVOR)
Strong
NeoClassic> (addToldInformation Dry WINE-SUGAR)
(addToldInformation Dry WINE-SUGAR)
Dry
NeoClassic> (addToldInformation Off-dry WINE-SURGAR)
(addToldInformation Off-dry WINE-SURGAR)
 
Line 65: ERROR: no compatible definition found for addToldInformation
      in form [addToldInformation, Off-dry, WINE-SURGAR]
      with argument types <Symbol> <Symbol> 
Usage: (addToldInformation <Classic Individual> <Classic Description>)
      Problem: Cannot convert argument 2
[none]
NeoClassic> (addToldInformation Off-dry WINE-SUGAR)
(addToldInformation Off-dry WINE-SUGAR)
Off-dry
NeoClassic> (addToldInformation Sweet WINE-SUGAR)
(addToldInformation Sweet WINE-SUGAR)
Sweet
NeoClassic> (getDirectInstances ClassicThing)
(getDirectInstances ClassicThing)
{}
NeoClassic> (getDirectInstances WINE-PROPERTY)
(getDirectInstances WINE-PROPERTY)
{}
NeoClassic> (getDirectInstances WINE-COLOR)
(getDirectInstances WINE-COLOR)
{Red, Rose, White}
NeoClassic> (getParents Sweet)
(getParents Sweet)
{WINE-SUGAR}
NeoClassic> (getAncestors Strong)
(getAncestors Strong)
{TOP, WINE-PROPERTY, WINE-FLAVOR}
NeoClassic> (createRole color true)
(createRole color true)
color
NeoClassic> (createRole body true)
(createRole body true)
body
NeoClassic> (createRole flavor true)
(createRole flavor true)
flavor
NeoClassic> (createRole sugar true)
(createRole sugar true)
sugar
NeoClassic> (createRole grape true)
(createRole grape true)
grape
NeoClassic> (createConcept Wine (and POTABLE-LIQUID
(createConcept Wine (and POTABLE-LIQUID
NeoClassic 2>       (all color WINE-COLOR) (atLeast 1 color)
      (all color WINE-COLOR) (atLeast 1 color)
NeoClassic 2>       (all body WINE-BODY) (atLeast 1 body)
      (all body WINE-BODY) (atLeast 1 body)
NeoClassic 2>       (all flavor WINE-FLAVOR) (atLeast 1 flavor)
      (all flavor WINE-FLAVOR) (atLeast 1 flavor)
NeoClassic 2>       (all sugar WINE-SUGAR) (atLeast 1 sugar)
      (all sugar WINE-SUGAR) (atLeast 1 sugar)
NeoClassic 2>       (all grape EDIBLE-THING) (atLeast 1 grape)))
      (all grape EDIBLE-THING) (atLeast 1 grape)))
Wine
NeoClassic> (getTold Wine)
(getTold Wine)
 
Line 84: ERROR: no function definitions found for getTold
      in form [getTold, Wine]
      with argument types <Symbol> 
[none]
NeoClassic> (toldParents WINE)
(toldParents WINE)
 
Line 85: ERROR: no compatible definition found for toldParents
      in form [toldParents, WINE]
      with argument types <Symbol> 
Usage: (toldParents <Classic Individual>)
      Problem: Cannot convert argument 1
Usage: (toldParents <Host Description>)
      Problem: Cannot convert argument 1
Usage: (toldParents <Classic Description>)
      Problem: Cannot convert argument 1
[none]
NeoClassic> (concept-told-parents WINE)
(concept-told-parents WINE)
 
Line 86: ERROR: no compatible definition found for concept-told-parents
      in form [concept-told-parents, WINE]
      with argument types <Symbol> 
Usage: (concept-told-parents <Host Description>)
      Problem: Cannot convert argument 1
Usage: (concept-told-parents <Classic Description>)
      Problem: Cannot convert argument 1
[none]
NeoClassic> (getDescendants ClassicThing)
(getDescendants ClassicThing)
{WINE-COLOR, WINE-BODY, WINE-SUGAR, WINE-FLAVOR, WINE-PROPERTY, EDIBLE-THING, Wine, POTABLE-LIQUID, CONSUMABLE-THING, WINERY, WINE-REGION}
NeoClassic> (toldParents Wine)
(toldParents Wine)
{POTABLE-LIQUID}
NeoClassic> (getAncestors Wine)
(getAncestors Wine)
{TOP, CONSUMABLE-THING, POTABLE-LIQUID}
NeoClassic> (printInfo Wine)
(printInfo Wine)
======================== ClassicConcept ========================
|| Name:                   Wine
||    Primitive:           0
||    Primitives:          {POTABLE-LIQUID, CONSUMABLE-THING}
||    Rules:               {}
|| Ingredients:
||    Told Parents:        {POTABLE-LIQUID}
||    Components:          {(atLeast 1 grape), (all grape EDIBLE-THING), (atLeast 1 sugar), (all sugar WINE-SUGAR), (atLeast 1 flavor), (all flavor WINE-FLAVOR), (atLeast 1 body), (all body WINE-BODY), (atLeast 1 color), (all color WINE-COLOR)}
|| Taxonomy:
||    Parents:             {POTABLE-LIQUID}
||    Children:            {}
||    DirectInstances      {}
|| Soup:
||    Primitive Ancestors: {POTABLE-LIQUID, CONSUMABLE-THING}
||    One of:              {}
||    RoleRestrictions:    {<color 1-1 {} WINE-COLOR>, <body 1-1 {} WINE-BODY>, <flavor 1-1 {} WINE-FLAVOR>, <sugar 1-1 {} WINE-SUGAR>, <grape 1-1 {} EDIBLE-THING>}
||    Tests:               {}
||    Incoherent?          0
================================================================

[none]
NeoClassic>  (toldAtMost Wine)
(toldAtMost Wine)
 
Line 91: ERROR: no compatible definition found for toldAtMost
      in form [toldAtMost, Wine]
      with argument types <Symbol> 
Usage: (toldAtMost <Classic Individual> <Role>)
      Problem: Too Few Arguments
Usage: (toldAtMost <Description> <Role>)
      Problem: Too Few Arguments
[none]
NeoClassic> (toldAtMost Wine color)
(toldAtMost Wine color)
2147483647
NeoClassic> (toldAtMosts Wine color)
(toldAtMosts Wine color)
{}
NeoClassic> (toldAtLeast Wine color)
(toldAtLeast Wine color)
1
NeoClassic> (getChildren Wine)
(getChildren Wine)
{}
NeoClassic> (getInstances Wine)
(getInstances Wine)
{}
NeoClassic> (createRoll appropriate-drink true)
(createRoll appropriate-drink true)
 
Line 97: ERROR: no function definitions found for createRoll
      in form [createRoll, appropriate-drink, 1]
      with argument types <Symbol> <Boolean> 
[none]
NeoClassic> (createRole appropriate-drink true)
(createRole appropriate-drink true)
appropriate-drink
NeoClassic> (createConcept MEAL-FOOD (and EDIBLE-THING
(createConcept MEAL-FOOD (and EDIBLE-THING
NeoClassic 2>            (all appropriate-drink)(atLeast 1 appropriate-drink)
           (all appropriate-drink)(atLeast 1 appropriate-drink)
NeoClassic 2>            (all appropriate-drink Wine)))
           (all appropriate-drink Wine)))
 
Line 100: ERROR: no compatible definition found for all
      in form [all, appropriate-drink]
      with argument types <Symbol> 
Usage: (all <Role> <Description>)
      Problem: Too Few Arguments
[none]
NeoClassic> (createConcept MEAL-FOOD (and EDIBILE-THING
(createConcept MEAL-FOOD (and EDIBILE-THING
NeoClassic 2>            (all appropriate-drink Wine) (atLeast 1 appropriate-drink)))
           (all appropriate-drink Wine) (atLeast 1 appropriate-drink)))
 
Line 102: ERROR: no compatible definition found for and
      in form [and, EDIBILE-THING, (all appropriate-drink Wine), (atLeast 1 appropriate-drink)]
      with argument types <Symbol> <Classic Construct> <Classic Construct> 
Usage: (and <Description>...)
      Problem: Cannot convert argument 1
Usage: (and )
      Problem: Too Many Arguments
[none]
NeoClassic> (createConcept MEAL-FOOD (and EDIBLE-THING
(createConcept MEAL-FOOD (and EDIBLE-THING
NeoClassic 2>            (all appropriate-drink Wine) (atLeast 1 appropriate-drink)))
           (all appropriate-drink Wine) (atLeast 1 appropriate-drink)))
MEAL-FOOD
NeoClassic> (createIndividual W1(and Wine (and sugar Dry)))
(createIndividual W1(and Wine (and sugar Dry)))
 
Line 106: ERROR: no compatible definition found for and
      in form [and, sugar, Dry]
      with argument types <Symbol> <Symbol> 
Usage: (and <Description>...)
      Problem: Cannot convert argument 1
Usage: (and )
      Problem: Too Many Arguments
[none]
NeoClassic> (createIndividual W1(and Wine (fills sugar Dry)))
(createIndividual W1(and Wine (fills sugar Dry)))
W1
NeoClassic> (createIndividual W2(and Wine (fills grape semillon and riesling)))
(createIndividual W2(and Wine (fills grape semillon and riesling)))
Inconsistent individual returned: W2
Reason:  InconsistentRoleBoundsConflict: grape, 3, 1 
W2
NeoClassic> (printInfo $)
(printInfo $)
********************* ClassicIndividual ********************
* Name:                   W2
* Ingredients:
*    Told Parents:        {Wine}
*    Components:          {(fills grape riesling and semillon)}
*    Closed Roles:        {}
*    Rules:               {}
*    In Propagations:     {}
* Parents:                {}
* Inconsistent:           1
* Out Propagations:       {}
* Soup:
*    Primitive Ancestors: {POTABLE-LIQUID, CONSUMABLE-THING}
*    One of:              {}
*    RoleRestrictions:    {<color 1-1 {} WINE-COLOR>, <body 1-1 {} WINE-BODY>, <flavor 1-1 {} WINE-FLAVOR>, <sugar 1-1 {} WINE-SUGAR>, <grape 3-1 {riesling, and, semillon} EDIBLE-THING>}
*    Tests:               {}
************************************************************

[none]
NeoClassic> (createIndividual W2(and Wine (fills grape semillon)))
(createIndividual W2(and Wine (fills grape semillon)))
W2
NeoClassic> (printInfo W2)
(printInfo W2)
********************* ClassicIndividual ********************
* Name:                   W2
* Ingredients:
*    Told Parents:        {Wine}
*    Components:          {(fills grape semillon)}
*    Closed Roles:        {}
*    Rules:               {}
*    In Propagations:     {}
* Parents:                {Wine}
* Inconsistent:           0
* Out Propagations:       {Propagation(W2 semillon (and EDIBLE-THING (oneOf semillon)))}
* Soup:
*    Primitive Ancestors: {POTABLE-LIQUID, CONSUMABLE-THING}
*    One of:              {}
*    RoleRestrictions:    {<color 1-1 {} WINE-COLOR>, <body 1-1 {} WINE-BODY>, <flavor 1-1 {} WINE-FLAVOR>, <sugar 1-1 {} WINE-SUGAR>, <grape 1-1 {semillon} (and EDIBLE-THING (oneOf semillon))>}
*    Tests:               {}
************************************************************

[none]
NeoClassic> (closeRole W2 color)
(closeRole W2 color)
Inconsistent individual returned: W2
Reason:  InconsistentRoleBoundsConflict: color, 1, 0 
W2
NeoClassic> sunserver1[103] exit
exit
sunserver1[104] 
Process shell finished