Overview

This part is about advanced topics in CG theory. We will treat three topics in some detail:

1. Referents
2. Coreferents
3. Nested graphs

Referents

Whereas types are groups of individuals, referents refer to the individuals themselves:

```  [Type: Referent]
```

Coreferents

Concepts that refer to the same individual(s) may be linked with coreference links to show that they refer to the same concepts:

```   [Person: #you]- - -[Person: Peter]
"You are Peter"
```

Nested graphs

Concepts and conceptual graphs may be nested inside other concepts. For example, in the following graph, the graph denoting "The Sun is shining" is nested inside the Proposition concept:

```   [Proposition:
[Sun: #]<-(Agnt)<-[Shine]
]
"The Sun is shining"
```

Referents

Referents are a complex subject area. Therefore, we will only give examples of some of the most important ones, and then refer more interested readers to the full material on referents. The full material is not required reading.

Recall that a concept has a type and a referent, separated by a colon:

```   [Type: Referent]
```

In the following, we list some of the more important kinds of referents:

Finally, we will say a little about counts of sets used in referents.

Blank referents (Existential quantifier)

Example

A referent may be blank. For example:

```   [Bus]
"There is a bus"
```

Meaning

When the referent of a concept is blank, it simply means "there is a". We haven't specified what the referent is, only that it exists.

Existential quantifier

What the blank referent really means is that we have an invisible "existential quantifier", usually denoted "". This quantifier just means "there exists a", and is part of predicate logic. Fuller explanations can be found in all introductions to predicate logic.

The referent need not be blank

The referent need not be blank in order to mean "there exists". If there is no quantifier, then the existential quantifier is assumed. Thus, the following concept:

```   [Rhino: Otto]
```

means "there exists a Rhino called Otto". This is equivalent to:

```   [Rhino:
<!--
var agt=navigator.userAgent.toLowerCase();
var is_win = ( (agt.indexOf("win")!=-1) || (agt.indexOf("16bit")!=-1) );
var is_gecko = (agt.indexOf('gecko') != -1);
if (is_win && !is_gecko) {
document.write("<FONT FACE=\"Symbol\">\$</FONT>");
} else {
document.write("&exist;");
}
-->
Otto]
```

Universal quantifier

The other quantifier is the universal quantifier, , meaning "for all". It is the opposite of the existential quantifier.

Locators: Individual markers (Named referents)

Definition of locators

A locator is a referent which tells us where we can find the individual referred to by the referent, either in the physical world or in a catalog of individuals.

Two kinds of locators

There are two kinds of locators:

1. Individual markers, and
2. Indexicals.

Definition of individual markers

Individual markers are names of persons, places, organizations, etc.

Examples of individual markers

Two examples:

```   [Person: John]<-(Expr)<-[Live]->(Loc)->[City: Aalborg]
"John lives in Aalborg"
```

Here, "John" and "Aalborg" are locators.

Locators: Indexicals

Definition

Indexical referents are used to refer to individuals whose indentity can be recovered or inferred from some context.

Indexical referents are a special kind of locator. The locators we have already seen, "John", "Aalborg", etc., are called "individual markers".

Special kinds, plus examples

• "#" means "the"
```   [Milk: #]<-(Thme)<-[Drink]->(Agnt)->[Cat: #]
"The cat drinks the milk."
```
• "#it", "#you", "#he", "#she", "#them", "#they", etc.

These are pronouns in the general sense of the word. For example:

```   [Person: #he]<-(Agnt)<-[Kiss]->(Benf)->[Person: #her]
"He is kissing her (and she is a benefactor :-) )"
```
• "#2.3", "#42"

These are indexicals which refer to individuals in some implementation-dependent manner. For example:

```   [Person: Arthur]<-(Agnt)<-[Brew]->(Rslt)->[CupOfTea: #42]
"Arthur brews cup of tea '42'"
```

Here, it is assumed that we can find out, by a search in a list or the like, which cup of tea is referred to by the indexical "#42".

Sets of things

Example

We may use sets of things as referents. For example:

```   [Guest: {Tom,Julia,Brad}]<-(Agnt)<-[Sing]-
->(Thme)->[Song: HappyBirthdayToYou]
->(To)->[Person: Alfred]
"The guests, Tom, Julia, and Brad, sing a song, 'Happy Birthday
to you,' to Alfred".
```

Here, "{Tom, Julia, Brad}" is a set of entities which fill the referent of the concept with the type "Guest".

"{*}": A "set of things"

A special set, "{*}" is used to say "a (plural) set of things".

For example:

```   [Bird: {*}]
```

means "There are some birds" or simply "Birds".

With this definition, we can finally represent the real line from "Dream a little dream of me":

```   [Sing]->(Agnt)->[Bird: {*}]->(In)->[SycamoreTree]
"Birds singing in a sycamore tree"
```

Notice that by saying "{*}", we haven't specified how many there are, only that it is plural. A little later, we will learn how to say how many there are.

Descriptors

Whole graphs can be used as referents. For example:

```  (Past)->[Situation:
[Person: John]<-(Agnt)<-[Kiss]-
->(Benf)->[Person: Mary]
]
"John kissed Mary."
```

Here, the conceptual graph

```   [Person: John]<-(Agnt)<-[Kiss]->(Benf)->[Person: Mary]
```

is the referent of the concept with the type "Situation". Thus a graph can be used to fill the slot of the referent. This is called a descriptor because it is used to describe the concept.

Counts

We can say how many individuals there are in the referent by using the '@' symbol:

```   [Person]->(Has)->[Leg: @2]
"There exists a person who has two legs"
```

Here, '@2' is used to say that there are two entities of type "Leg".

Another example:

```   [Guest: {*}@40]<-(Agnt)<-[Give]-
->(Rcpt)->[Person: Alfred],
->(Thme)->[Present: {*}@37]
"Forty guests give Alfred 37 presents"
```

the count may also have units, such as seconds or kilograms:

```   [Song: HappyBirthdayToYou]->(Dur)->[Interval: @18 sec]
"The song "Happy Birthday To You" has a duration
which is an interval
which has length 18 seconds"
"Happy Birthday To You lasts 18 seconds"
```

Thus the '@' symbol can be used to say how many things there are in the set which makes up the referent.

The universal quantifier

The quantifier means "for all". It is also called the "universal quantifier", since it means that the referent refers to all instances of the given type. For example:

```   [LivingFish:
<!--
var agt=navigator.userAgent.toLowerCase();
var is_win = ( (agt.indexOf("win")!=-1) || (agt.indexOf("16bit")!=-1) );
var is_gecko = (agt.indexOf('gecko') != -1);
if (is_win && !is_gecko) {
document.write("<FONT FACE=\"Symbol\">\"</FONT>");
} else {
document.write("&forall;");
}
-->
]->(Attr)->[Wet]
"All living fish have an attribute which is wet"
"All living fish are wet"
```

Use the symbol to say "all", or "every".

Referents (optional)

Introduction

This is optional material, provided for those who are interested in knowing the full story about referents. It is not required reading. You can skip it by using the navigation-bar on the left.

Recall that a concept has a type and a referent, separated by a colon:

```   [Type: Referent]
```

In this section, we define what a referent is, and also give some examples.

Definition of referent

A referent is made up of two things:

1. Its quantifier, and
2. Its designator.

These are placed immediately after each other.

Quantifiers

A quantifier may be either:

1. The existential quantifier, or
2. A defined quantifier.

Designators

A designator may be either:

1. A literal,
2. A locator, or
3. A descriptor.

Next

Next, we discuss quantifiers first, then designators.

Quantifier

Overview

As will be recalled, there are two types of quantifiers:

1. The existential quantifier, or
2. A defined quantifier.

The existential quantifier

The existential quantifier is represented either by a blank (i.e., by nothing) or by the symbol . It may be paraphrased as "There is a" or simply "a". For example:

```   [Cat]->(On)->[Mat]
"A cat is on a mat"
```

Since the referent is blank for both of these concepts, the quantifier is also blank. Since a blank quantifier is the existential quantifier, this means that we can paraphrase this graph as "There is a cat, and there is a mat, and the cat is on the mat".

Defined quantifiers

A "defined quantifier" is defined as "a quantifier which can be defined in terms of the existential quantifier." This definition does not help much in understanding what it is, of course, so instead we give some examples:

Universal quantifier

The quantifier means "for all". It is also called the "universal quantifier", since it means that the referent refers to all instances of the given type. For example:

```   [LivingFish:
<!--
var agt=navigator.userAgent.toLowerCase();
var is_win = ( (agt.indexOf("win")!=-1) || (agt.indexOf("16bit")!=-1) );
var is_gecko = (agt.indexOf('gecko') != -1);
if (is_win && !is_gecko) {
document.write("<FONT FACE=\"Symbol\">\"</FONT>");
} else {
document.write("&forall;");
}
-->
]->(Attr)->[Wet]
"All living fish have an attribute which is wet"
"All living fish are wet"
```

Unspecified set-quantifier

The "{*}" quantifier means "a set of things". It can be used to indicate plural. For example:

```   [Bird: {*}]
```

means "There are some birds" or simply "Birds".

With this definition, we can finally represent the real line from "Dream a little dream of me":

```   [Sing]->(Agnt)->[Bird: {*}]->(In)->[SycamoreTree]
"Some birds are the agent of sing.  The birds are in a sycamore
tree"
"Birds singing in a sycamore tree"
```

Quantities with {*}

This notation can also be extended with the count of elements in the set:

```   [Guest: {*}@40]<-(Agnt)<-[Give]-
->(Rcpt)->[Person: Alfred],
->(Thme)->[Present: {*}@37]
"Forty guests give Alfred 37 presents"
```

Quantities on their own

Quantities may also be on their own, without the {*} set notation, and they may have units, such as seconds or kgs:

```   [Person]->(Has)->[Leg: @2]
"There exists a person who has two legs"
```

```   [Song: HappyBirthdayToYou]->(Dur)->[Interval: @18 sec]
"Happy Birthday To You has a duration which is an interval which
has length 18 seconds"
"Happy Birthday To You lasts 18 seconds"
```

Collections

Collections, such as {1,2,5} or {Tom,Julia,Brad}, may also be used as quantifiers:

```   [Guest: {Tom,Julia,Brad}]<-(Agnt)<-[Sing]-
->(Thme)->[Song: HappyBirthdayToYou]
->(To)->[Person: Alfred]
"The guests, Tom, Julia, and Brad, sing a song,
'Happy Birthday to you,'
to Alfred".
```

Designators

Summary of things learned so far

First, we give a little summary of what we have learned so far.

Now we have learned that a concept has a type and a referent:

```   [Type: Referent]
```

and that the referent is made up of two parts:

1. A quantifier
2. A designator

The quantifier-part of a referent can be one of two kinds:

1. The existential quantifier (blank or ""), maning "There exists...", or
2. A defined quantifier.

The defined quantifiers can be one of the following kinds:

• The universal quantifier, , meaning "Every" or "All",
• The "unspecified set", "{*}", meaning "plural",
• A quantity, such as "@2", "@18 seconds", or "@100 grams".
• Collections, such as "{Romeo,Juliet}".

Designators

We have already described quantifiers, and now we describe designators. Recall that a designator can be one of the following:

1. A literal,
2. A locator, or
3. A descriptor.

In brief:

1. A literal is "a syntactic representation of the form of the referent" (e.g., 'This is a sentence');
2. A locator is a symbol that specifies how the referent may be located (e.g., John); and
3. A descriptor is a conceptual graph which describes the referent.

These will be exemplified in more detail below.

Literal

Definition and examples

A literal is "a syntactic representation of the form of the referent". That is, it shows the form of the referent. For example:

```   [Number: 18]
[String: 'abcdefg']
[Measure: <18, cm>]
```

The three kinds of literals

There are three kinds of literals:

1. A number
2. A string
3. An encoded literal

All three kinds are exemplified in the above examples. The string is "'abcdefg'", while the encoded literal is "<18, cm>".

Encoded literals

The encoded literal has the following form:

```   <literal, string>
```

where the string designates the unit of the literal. Other examples include:

```   [Temperature: <37.5, DegreesCelsius> ]
"There is a temperature, which is 37.5 degrees Celsius."
```
```   [Number: <12, Rhino>]
"There is a number, which is 12 rhinos."
```
```   [Measure: <2.54, cm> ]
"There is a measure, which is 2.54 cm."
```

Difference between "18" and "@18"

Note how there is a difference between the designator "18" and the quantifier "@18". To illustrate the difference, we show two different concepts:

```   [Number: 18]
"There is a number, which is 18"
```
```   [Number: @18]
"There are 18 numbers (and we haven't specified what they are)"
```

The designator "18" tells us what the number is, while the quantifier "@18" tells us how many numbers there are.

To drive home the point, let us show this example:

```   [Number: @18 18]
"There are 18 numbers.  Each of these numbers is the number 18."
```

Locator

Definition

A locator indicates a way of finding the referent, either in the real world or in our catalog of entities associated with the conceptual graph.

Examples

Here are some examples:
```   [Person: Arthur]
[City: Aalborg]
[Student: #you]
[Person: #him]
[Cake: #it]
[CupOfTea: #42]
[Book: #ISBN-0517149257]
```

Two major kinds of locators

There are two major kinds of locators:

1. Individual markers, and
2. Indexicals.

Individual markers

An individual marker specifies a name of an individual and unique concept in our catalog of concepts. Examples include "Arthur" and "Aalborg" above.

Indexicals

An indexical specifies an implementation-defined way of finding the referent. Indexicals are prefixed by the "#"-sign.

For example,

```   [CupOfTea: #42]
```

could specify that the particular cup of tea which we were talking about is the one that has number 42 in our catalog of entities.

Likewise, we can use pronouns (you, he, him, she, her, it, etc.) to indicate which individual we are talking about:

```   [Idea: #it]->(Attr)->[Good]
"It is a good idea."

[Person: #she]->(Attr)->[Beauty]
"She has beauty"
```

The # symbol is commonly used by itself to mean "the":

```   [Rose: #]->(Chrc)->[Smell: Sweet]
"The rose has a characteristic which is a Smell which is Sweet."
"The rose is smelling sweet"
```

Next

We have now discussed two of the three kinds of designators, namely literals and locators. Next, we discuss the third kind of designator, namely 'descriptor'.

Descriptor

Definition

A descriptor is a designator which is a conceptual graph. The conceptual graph is said to describe the referent.

Examples

Here is an example:

```   [PartyLight: [PartyLight]->(Chrc)->[Color: Blue] ]-
"There is a party light,
which can be described as
a partylight
having a characteristic
which is a color
which is blue,
and the party light
is the agent
"A blue party light is blinking."
```

Another example:

```   [Proposition: [Man:
<!--
var agt=navigator.userAgent.toLowerCase();
var is_win = ( (agt.indexOf("win")!=-1) || (agt.indexOf("16bit")!=-1) );
var is_gecko = (agt.indexOf('gecko') != -1);
if (is_win && !is_gecko) {
document.write("<FONT FACE=\"Symbol\">\"</FONT>");
} else {
document.write("&forall;");
}
-->
]->(Attr)->[Mortal] ]
"There is a proposition, which is 'All men are mortal'"
```

As we see, the conceptual graph

```   [Man:
<!--
var agt=navigator.userAgent.toLowerCase();
var is_win = ( (agt.indexOf("win")!=-1) || (agt.indexOf("16bit")!=-1) );
var is_gecko = (agt.indexOf('gecko') != -1);
if (is_win && !is_gecko) {
document.write("<FONT FACE=\"Symbol\">\"</FONT>");
} else {
document.write("&forall;");
}
-->
]->(Attr)->[Mortal]
```

fills the slot of the referent of the concept with the type "Proposition". This conceptual graph is the descriptor.

Blank designators

A blank designator is taken as a descriptor which is a blank conceptual graph. Thus it says nothing about the referent.

Blank designator, blank quantifier

If both the quantifier and the designator are blank, it simply means "There is a", e.g.:

```   [Cat]
"There is a cat"

[Mortal]
"There is a property, Mortal"
```

Blank designator, non-blank quantifier

We can also have a non-blank quantifier with a blank designator:

```   [Man:
<!--
var agt=navigator.userAgent.toLowerCase();
var is_win = ( (agt.indexOf("win")!=-1) || (agt.indexOf("16bit")!=-1) );
var is_gecko = (agt.indexOf('gecko') != -1);
if (is_win && !is_gecko) {
document.write("<FONT FACE=\"Symbol\">\"</FONT>");
} else {
document.write("&forall;");
}
-->
]
"All men"

[Number: @18]
"There are 18 numbers"
```

Here, the quantifier is "" and "@18" respectively, while the designator is a descriptor which is a blank conceptual graph.

Next

Next, we give a summary which will hopefully help you get the big picture of referents.

Summary

Concepts

A concept has a type and a referent:

```   [Type: Referent]
```

Referents

A referent is made up of two parts:

1. Its quantifier
2. Its designator

Quantifiers

The quantifier tells us, e.g.:

• whether the referent merely exists (blank or ),
• whether the referent refers to all instances of the type of the concept ()
• whether there is more than one instance of the referent
• possibly how many (e.g., "@18")
• possibly which ones (e.g., "{Peter,Paul,Mary}")

Designators

The designator tells us which particular individual the referent is referring to. A designator is either:

• a literal, such as "18", "'abcdefg'", or "<37.5, DegreesCelsius>".
• a locator, such as "John", "Aalborg", "#42", "#it", or "#".
• a descriptor, such as "[PartyLight]->(Attr)->[Blue]".

Blank quantifiers and designators

If the quantifier is left blank, the quantifier is the existential quantifier, "there is". If the designator is left blank, it is a descriptor which is a blank conceptual graph, saying nothing about the referent.

Coreferents

Definition

Two or more concepts in a conceptual graph may refer to the same individual. This is shown by a dotted line. The dotted line is called a "coreference link".

Examples

E.g.:

```   [Person: #you]- - - -[Person: Peter]
"There is a person, you, and a person, Peter, and these two
concepts are coreferential (i.e., are the same)."
"You are Peter."
```

Another example:

```   [Person: Socrates]- - -[Man]->(Attr)->[Mortal]
"There is a Man who has an attribute which is mortal.  This man is
the same as the person Socrates"
"Socrates is a mortal man"
```

In the graphical notation, the first example would look like this:

```
"Tu es Petrus"
```

When we can't draw dotted lines in the linear notation

If the two concepts are not located next to each other, it is not easy to draw dotted lines in the linear notation. There is a solution, however. For example, the following graph:

```
"There is a situation which can be described as follows.  There is
a Rhino, Otto, which has a characteristic, which is a Color which
is Orange.  And there is a Rhino in the living room.  Otto is that
rhino."

"There is the following situation: Otto the orange rhino is in the
living room."
```

could look like this in linear notation:

```   [Situation:

[Rhino: Otto *x]->(Chrc)->[Color: Orange]

[Rhino: ?x]->(In)->[Room: LivingRoom]

]
"There is this situation: There is a Rhino, Otto, and let us call
this Rhino 'x'.  Otto has the color orange.  'x' is in the living
room."
```

Unconnected graphs are related by 'and'

Note how we have two conceptual graphs nested in the Situation concept. Note also these two subgraphs are not connected:

```     [Rhino: Otto *x]->(Chrc)->[Color: Orange]
```

and

```     [Rhino: ?x]->(In)->[Room: LivingRoom]
```

When two graphs are not connected, the relationship between them is interpreted as "and". In the above example, it is both true that Otto the rhino is orange and that Otto is in the living room.

Defining label, bound label

The label '*x' is called the defining label, while the label '?x' is called the bound label. We could use '?x' more than once in the same context to refer to the concept '*x'. However, we could only have one '*x' in the same context.

This is because '*x' is used as the "anchor point" for the definition of the coreferent, while all the '?x's "bind to" the single instance of '*x'. Hence the names defining label and bound label.

Nested graphs

Definition

When a conceptual graph G1 is nested inside a concept C, it means that:
• either G1 is directly part of the referent of C,
• or G1 is directly part of the referent of a concept C2 which is nested inside C.

This is a recursive definition

Note that this is a recursive definition. We define the notion "nested" first in terms of a base case: "directly part of the referent of C", and then in terms of a recursive case: "part of the referent of a concept which is nested inside C".

Example

An example of a conceptual graph nested in another conceptual graph could be:

```   [Proposition: [Professor: Alfred]->(Attr)->[Good] ]
"There is a proposition, which is
'Alfred is a good professor'"
```

Here, the sub-graph

```   [Professor: Alfred]->(Attr)->[Good]
```

is nested within the concept with concept type 'Proposition'.

Next

Two concepts are key when talking about nested graphs. One is the concept of context, while the other is the concept of nesting. In the following, we discuss contexts first and then nesting.

Contexts

Definition

A context C is a concept whose designator is a non-blank conceptual graph G.

Examples

For examle, the following are examples in which contexts occur:

```   [Proposition: [Rhino:
<!--
var agt=navigator.userAgent.toLowerCase();
var is_win = ( (agt.indexOf("win")!=-1) || (agt.indexOf("16bit")!=-1) );
var is_gecko = (agt.indexOf('gecko') != -1);
if (is_win && !is_gecko) {
document.write("<FONT FACE=\"Symbol\">\"</FONT>");
} else {
document.write("&forall;");
}
-->
]->(Chrc)->[Color: Grey]  ]
"All rhinos are grey"
```

```   [Proposition: [Rhino: Otto]->(Chrc)->[Color: Orange] ]
"Otto is an orange rhino"
```

```   [Situation: [Rhino: Otto]->(In)->[Room: LivingRoom] ]
"Otto the rhino is in the living room"
```

Here, "[Proposition]" and "[Situation]" are the contexts in which the other graphs, called the subgraphs, occur.

Nesting

Definition

If a conceptual graph G is inside the referent of a concept C, then G is said to be nested in C.

This can be done to any depth: G can be nested inside C, which can be nested inside a third context C2. Thus G need not be immediately nested in C, i.e., C need not be the nearest containing concept. We might be able to work our way outwards through several contexts (i.e., containing concepts) before we reach the outermost level.

Let us see an example.

Example

```   [Situation: [PartyLight: [PartyLight]->(Attr)->[Blue] ]-
"There is this situation:
There is a partylight,
which can be described as
a partylight
which has an attribute
which is blue,
and the party light
is the agent of an act
"A blue party light is blinking"
```

Here, we have two levels of nesting: The PartyLight is described by the graph

```   [PartyLight]->(Attr)->[Blue]
```

. This graph is nested inside the concept (context):

```   [PartyLight: [PartyLight]->(Attr)->[Blue] ]
```

. This concept is then part of a larger graph:

```   [PartyLight: [PartyLight]->(Attr)->[Blue] ]<-(Agnt)<-[Blink]
```

which is then nested inside the "[Situation]" concept (context):

```   [Situation: [PartyLight: [PartyLight]->(Attr)->[Blue] ]-
```

Thus we have two levels of nesting.

Immediately nested graphs are referents

It is very important that you understand that the nested graph is the referent of the containing concept. For example,

```   [PartyLight]->(Attr)->[Blue]
```

is the referent of the concept with the type 'PartyLight'. You will remember that this kind of referent is called a descriptor.

Co-nesting

Introduction

We have learned what it means for a concept to be nested or immediately nested in another concept. Now we apply these notions to define what it means for two concepts to be co-nested.

Definition

Two concepts A and B are said to be co-nested if:

• Either A=B (that is, a concept is co-nested with itself)
• Or there exists some concept C in which both A and B are immediately nested. That is, both must be at the same level of nesting.

Example

Consider the following graph:

```   [Situation: [PartyLight: [PartyLight]->(Attr)->[Blue] ]-
```

Here, the concept [Blink] and the outermost [PartyLight] concept are co-nested. And the innermost [PartyLight] and [Blue] are co-nested. However, [Blue] is not co-nested with [Blink] because they are not both immediately nested in the same concept.

Next

Next, we look at scope rules. Scope rules are important for understanding how much of a graph a quantifier or coreference link applies to. We will use the notion of co-nesting when we define the scope rules.

Scope rules

Introduction

Nesting gives rise to something called scope rules. Scope refers to the area of a graph in which something holds true, e.g., a universal quantifier, an existential quantifier, or a coreference link.

Definition

That is, a quantifier or a coreference link need not apply to all parts of a graph. Let us say that a quantifier or coreference link is defined in the referent of a certain concept C. Then that quantifier or coreference link only applies to:

• The concept C.
• The graphs nested inside the concept C (to any depth).
• The concepts which are co-nested with the concept C.
• The graphs which are nested (to any depth) inside the concepts which are co-nested with C.

Example

Consider the following graph:

```   [If:
[If:
[Rhino:
<!--
var agt=navigator.userAgent.toLowerCase();
var is_win = ( (agt.indexOf("win")!=-1) || (agt.indexOf("16bit")!=-1) );
var is_gecko = (agt.indexOf('gecko') != -1);
if (is_win && !is_gecko) {
document.write("<FONT FACE=\"Symbol\">\"</FONT>");
} else {
document.write("&forall;");
}
-->
*x]
[Then:
[Mammal: ?x]
]
]
[If:
[Mammal:
<!--
var agt=navigator.userAgent.toLowerCase();
var is_win = ( (agt.indexOf("win")!=-1) || (agt.indexOf("16bit")!=-1) );
var is_gecko = (agt.indexOf('gecko') != -1);
if (is_win && !is_gecko) {
document.write("<FONT FACE=\"Symbol\">\"</FONT>");
} else {
document.write("&forall;");
}
-->
*y]
[Then:
[Animal: ?y]
]
]
[Then:
[If:
[Rhino:
<!--
var agt=navigator.userAgent.toLowerCase();
var is_win = ( (agt.indexOf("win")!=-1) || (agt.indexOf("16bit")!=-1) );
var is_gecko = (agt.indexOf('gecko') != -1);
if (is_win && !is_gecko) {
document.write("<FONT FACE=\"Symbol\">\"</FONT>");
} else {
document.write("&forall;");
}
-->
*x]
[Then:
[Animal: ?x]
]
]
]
]
```

Same scope

The defining label "*y" is in the same scope as the bound label "?y". This is because the bound label "?y" is in the referent of a concept ([Animal]) which is nested inside a concept [Then] which is co-nested with the concept ([Mammal]) in which the defining label "*y" occurs.

Likewise, the first occurrence of "*x" is in the same scope as the first occurrence of "?x" because the defining label "*x" occurs in the referent of a concept ([Rhino]) which is co-nested with a concept ([Then]) inside which we find the nested concept ([Mammal]) in whose referent we find the bound label "?x".

Different scope

Because of the scope rules, the first occurrence of "*x" is distinct from the second occurrence of "*x". That is, the two do not refer to the same coreference link. This is the same as saying that they occur in different scopes.

This is because the first "*x" occurs inside a concept ([Rhino]) which is not co-nested with the concept in which the second "*x" occurs.

Instead, there is a so-called export-barrier, namely the concept [If] (first occurrence) outside of which the first defining label "*x" does not have scope.

This amounts to saying that quantifiers and coreference-links have scope over everything in the immediately surrounding context (i.e., over those concepts that are co-nested with the concept in which the quantifier or defining label occurs), but not outside the immediately surrounding context.

Two types of quantifier

There are two types of quantifiers: The universal quantifier, and the existential quantifier. The scope rules apply to both.