Statements
---
These are some simple statements.

x=1
y=2 and x=1
y=2 or x=1

Logic programming
---

Styles and Paradigms
---

We'd like to make a distinction between style and paradigms.

x = double(2) //functional
double(2,x) //logic

The first line is written in a functional style. It can be read as "x _is_ the double of 2".

The second is written in logic-style. "The double of x is 2".

Either way, they are equivalent. As far as the language is concerned, it's simple syntax sugar. One is shorthand for the other.

As a multi-paradigm (or logic-functional with objects) language, we bend the distinction between what are considered the "main programming paradigms". 

Logic-procedural
---

and/or
---

They control the flow of statements.

> x=1 and y=2
| x=1 and y=2

_and_ statements are evaluated sequentially. In a procedural language, it's akin to a semicolon. (In a sense, this is the normal form of evaluation we see in any language, whereas...)

> x=1 or x=2
| x=1
| x=2

A simple _or_ statement splits evaluation. Logically, the statement is satisfied if either is true.

Hence, our query has two results.

Relations
---
Whereas most languages have functions, Cosmos has relations.

This is how we encode our previous statements in the form of a relation,

```
rel p(x)
    x=1 or x=2
```

We can then state that,

```
p(x)
```

Or, even,

```
x=p()
```

What this entails is that x can be either 1 or 2. We do not know which. Compare it to the following code.

```
rel p(x)
    x=1 or x=2
    
p(x)
x!=1
io.writeln(x) //2
```

Logically, we're saying that x can be either 1 or 2. This is implied by p(x).

We then say x _is not_ 1. It follows that it is 2.

Thus, when we write the value of x in the last line-- we can be sure that 2 is written.

Procedurally, it's a bit more complicated.

Analogy by quantum cat
---

At the moment our logic engine sees p(x), x has two possible values.

If you've ever heard the parable of the quantum cat--a cat that is both dead and alive, you may think of it in those terms.

x is in a _superposition_ of two values-- furthermore, the value of x-- and consequentially the result of p(x)-- is nondeterministic. There is no determined answer for the query "what is x right now?".

Next, our engine sees x!=1.

Once we know that x is not 1, it can only be 2.

Backtracking
---

# Host language

Pack
---

**cstart/0.**

Opens the interpreter.

**ceval/1.**

Evaluates code then closes the session. e.g.

:- ceval('x=1 or y=3').

**ui/0.**

Graphical swi debugger.

Shorthand for guitracer,trace.

**cmodule/1.**

Compiles module e.g.

:- cmodule('name') ; name.co is a language file