# Concept Blending

NOTE: 2016-12-15 the opencog python library has been refactored - need to fix this before fixing tutorials

## Theory

In the language of cognitive psychology, 'Conceptual blending' (also called conceptual integration or view application) is a theory of cognition developed by Gilles Fauconnier and Mark Turner. According to this theory, elements and vital relations from diverse scenarios are "blended" in a subconscious process, which is assumed to be ubiquitous to everyday thought and language. (See Concept Blending on Wikipedia).

Mark Turner, in 'The Literary Mind' defines concept blending as 'a fundamental instrument of the every day mind, used in our basic construal of all our realities, from the social to the scientific.' He argues that concept blending is key to many aspects of human creativity.

[Blending | Conceptual Blending] is an aspect of declarative knowledge creation in OpenCog (see Knowledge Creation in OpenCogPrime).

How is concept blending useful for concept formation in OpenCog? In a universe of sets where intensional similarity and extensional similarity are well-correlated, if two sets ${\displaystyle A}$ and ${\displaystyle B}$ are often useful in proving theorems of the form "${\displaystyle C}$ is a (probabilistic) subset of ${\displaystyle D}$", then "blends" of ${\displaystyle A}$ and ${\displaystyle B}$ will often be useful for proving such theorems as well. ref

New concept formation (the creation of new mental forms) involves inferring from previous experience of 'good tricks' or successful mental forms - though basic inference from experience of whats been useful in the past may be necessary, it may not be enough. (TODO: add explanation of how extrapolation and intercombination is different from inference). Concept Blending is one of the various hypotheses to do extrapolation and intercombination. In OpenCog, there are a variety of non-logical heuristics that are used for speculative concept formation (TODO: add explanation of speculative concept formation and its usefulness).

Where could concept blending fit? An interesting cog-sci/bio experiment would be to try out concept blending on Gene Ontology concepts. What kind of blends will cog-blend come up with? How does the interaction information measure need to be tweaked to make this work?

It has been suggested that concept blending may help in areas of computing rational behavior (including a way out of the Conjunction fallacy) by giving an intuitive and comparatively simple explanation to classical challenges of theories of rationality. Also concept blending may aid in providing extra functionality in language understanding and generation (i.e. in making sense of neologisms in contrast with some existing natural language systems which struggle to understand combined terms (despite knowing the meaning of each term). (see book: Theoretical Foundations of Artificial General Intelligence)

Concept blending may be a formal step towards a computable theory of creativity in Artificial Intelligence.

Nico Potyka, Danny Gómez-Ramírez and Kai-Uwe Kühnberger on '(paper) Towards a Computational Framework for Function-Driven Concept Invention'. Also see the video lecture that covers some ideas of concept blending '(Video) AGI-16 Nico Potyka - Towards a Computational Framework for Function-Driven Concept Invention'

Also see this wiki page: Speculative Concept Formation (Though it's Deprecated :D).

## Practice

### A Simple Blend Example

Blend with default config. See complete file `blend_simple.py`.

#### Initialize Opencog

```a = AtomSpace()
initialize_opencog(a)```

#### Make example concept network

```car = ConceptNode("car")
man = ConceptNode("man")
a.set_av(car.h, 17)
a.set_av(man.h, 13)
print "Source data:\n" + \
str(car) + \
str(man)```

#### Start Conceptual Blending.

```result = ConceptualBlending(a).run()
print "Newly blended node: \n" + \
str(result)```

#### Output

The output will look like:

```--------Start first example--------
Source data:
(ConceptNode "car") ; [2]
(ConceptNode "man") ; [3]
Newly blended node:
[(ConceptNode "car-man" (av 0 0 0) (stv 1.000000 0.000000)) ; [307]
]
```

### Conceptual Blending Examples

Git repository here: https://github.com/opencog/opencog/tree/master/examples/conceptual_blending Examples using the Conceptual Blending API.

Files:

• `blend_simple.py`: Simple example to use blend API.
• `blend_with_config.py`: Request to blend API with custom config.

Atoms that have STI value above 12 will be considered to blend. Force to start blend, and choose 2 nodes randomly.

• `blend_with_conflict_links.py`: Simple example describes conflict input case.

Force to start blend, and choose 2 nodes have highest STI value. Make 2^k available(viable) new blend atoms if there exists k conflicts, - If two similarity links strength value have difference above 0.3 and confidence value both above 0.7, blender thinks they conflict to each other.

• `blend_with_information_interaction.py`: Simple 'bat-man' example using Interaction Information theory to make new blend.

Choose one link set which has largest interaction information, and connect them to new blend.

### Issues

#### Error 1

tried `python blend_simple.py` - error output:

```Traceback (most recent call last):
File "blend_simple.py", line 20, in <module>
from blending.blend import ConceptualBlending
ImportError: No module named blending.blend
```

### Notes

Contat:(Dawit) there exists code on Github, get it to run. Markdown file steps though a simple example

• would be cool to show the input and results of blending in the Visualizer