https://github.com/tsoding/Noq

Simple expression transformer that is not Coq.
https://github.com/tsoding/Noq

Last synced: about 1 month ago
JSON representation

Simple expression transformer that is not Coq.

• Host: GitHub
• URL: https://github.com/tsoding/Noq
• Owner: tsoding
• License: mit
• Created: 2022-03-22T17:51:20.000Z (over 2 years ago)
• Default Branch: master
• Last Pushed: 2023-11-02T09:06:08.000Z (8 months ago)
• Last Synced: 2024-02-11T12:37:06.075Z (5 months ago)
• Language: Rust
• Size: 183 KB
• Stars: 251
• Watchers: 7
• Forks: 22
• Open Issues: 15
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Lists

• awesome-rust-formalized-reasoning - Noq - Dvs8t0VZVE64QKPf6y_TIUwj5nKQ7):star: - Not Coq. Simple expression transformer that is not Coq. (Projects / Provers and Solvers)

README

        
# Noq

**EXTREMELY IMPORTANT! THIS LANGUAGE IS A WORK IN PROGRESS! ANYTHING CAN CHANGE AT ANY MOMENT WITHOUT ANY NOTICE! USE THIS LANGUAGE AT YOUR OWN RISK!**

Not [Coq](https://coq.inria.fr/). Simple expression transformer that is NOT Coq.

## Quick Start

```console

$ cargo run ./examples/peano.noq

```

## Main Idea

The Main Idea is being able to define transformation rules of symbolic algebraic expressions and sequentially applying them.

## Expression

Current expression syntax can be defined roughly like this:

```

 ::= 

 ::=  ((`+` | `-`) )*

 ::=  ((`*` | `/`) )*

 ::=  (`^` )*

 ::= (`(`  `)`) |  |  | 

 ::= ( | ) ()+

 ::= [a-z0-9][_a-zA-Z0-9]*

 ::= [_A-Z][_a-zA-Z0-9]*

 ::= `(` (),* `)`

```

## Rules and Shapes

The two main entities of the language are Rules and Shapes. A rule defines pattern (head) and it's corresponding substitution (body). The rule definition has the following syntax:

```

 ::  = 

```

Here is an example of a rule that swaps elements of a pair:

```

swap :: swap(pair(A, B)) = pair(B, A)

```

Shaping is a process of sequential applying of rules to an expression transforming it into a different expression. Shaping has the following syntax:

```

 {

  ... sequence of rule applications ...

}

```

For example here is how you shape expression `swap(pair(f(a), g(b)))` with the `swap` rule defined above:

```

swap(pair(f(a), g(b))) {

  swap | all

}

```

The result of this shaping is `pair(g(b), f(a))`.

### Anonymous rules

You don't have to define a rule to use it in shaping:

```

swap(pair(f(a), g(b))) {

  swap(pair(A, B)) = pair(B, A) | all

}

```