Montague

KO | EN

gitlite — search

#android #rust #linux #docker #java #windows #awesome #cli #vue #awesome-list #pytorch #security #mcp #open-source

(★ 18)

A library for non-deterministically parsing natural language expressions into a structured form.

Montague 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Montague

> "I reject the contention that an important theoretical difference exists between formal and natural languages." 
 >       
 >    -- Richard Montague

Montague (named in honor of mathematician and philosopher [Richard Montague](https://en.wikipedia.org/wiki/Richard_Montague)) is a library and domain specific language for non-deterministically parsing natural language expressions into a structured form, so that they can be analyzed, or so that inferences may be made from them.

It is loosely based on the general ideas of [Montague Semantics](https://plato.stanford.edu/entries/montague-semantics/#ComMonSem), and uses a simple [lambek calculus](https://en.wikipedia.org/wiki/Categorial_grammar) equipped with subtyping, together with a user-provided lexicon translating from strings of text (possibly nondeterministically) to a term of a particular type of the configured lambek grammar.

To try it out for yorself, see [montague-reflex](https://github.com/Sintrastes/montague-reflex) for a web and mobile interface for Montague.

**Note**: Montague was originally prototyped in Haskell, but is currently in the process of being re-written in Rust. While Haskell is a great language, I think that Rust is the better choice for this project in the long term, as it makes it a lot easier to integrate Montague into various potential end-user applications.

Inspiration
-----------

This (as far as I know of) novel approach was first formulated in 2018 when I 
 was in grad school studying type theory and categorial grammar. 
 The idea was, rather than having a small number of basic types (such as 
 `noun`, `verb`, `noun phrase`, and `sentence`) combined with the two "lambek arrows"
 `/` and `\` to denote grammatical categories (which allows for nonsense productions
 such as `colorless green ideas sleep furiously`), we could extend this system with subtyping, and
 more apecific semantic categories such as `person <: noun`.
 
 Prohibiting such 
 "nonsense productions" with this idea then both simplifies the process of parsing a 
 sequence of words into a structured representation by pruning the possible 
 search space, as well as facilitates transforming such structured output 
 into a meaningful logical format (for instance, queries in a typed logic programming 
 language). Montague is an attempt to put these ideas in practice.

Montague in The AI Era
-----------------------

I originally developed Montague right before the explosion in interest in generative AI, the transformer architecture, and LLMs. My goal with the project was to accomplish things that [LLMs can now very readily do](https://github.com/safishamsi/graphify). So what now is the point of Montague?

One of the major concerns people have over the rise of AI systems is their large resource requirements. Another concern (though this is becoming less and less of a concern with each generation of frontier models) are things like inaccuracies and "hallucinations".

I think that one way we might work to address these concerns, but still build useful AI systems for everyday people and knowledge workers designed to enchance (rather than replace) intellegence is to incorporate small language models with "good-old-fashioned AI" (i.e. logic programming, symbolic reasoning).

Moving forward, I think Montague (or something like it) could prove incredibly useful as a "first pass" for AI-based query engines (e.x. first try to use Montague to parse and analyze a sentence, if it fails, invoke an LLM, or use a small language model to refine the grammatical schema based on the failed query). There are other fascinating possibilities as well (for instance, the use of Montague to encourage AI agents to be more percise in analyzing user queries, prompting them to ask clarifying questions to the user if Montague determines an important sentence ambiguity).

There are probably hundreds of other potentially interesting applications and techniques riffing on the techniques from Montague. I hope at the very least this project inspires other to build bigger and better things!

**AI Disclosure**: As much as I enjoy software development for it's own sake, and appreciate some good human-written hand-crafted code -- I'm also a fan of getting things done, and have limited free time to work on this (and other) projects. The ideas in this project (unless otherwise cited) are all my own, but I make use of agentic AI to help assist me in the development of Montague.

Domain specific language
------------------------

Although Montague has a set of Rust (and Haskell) APIs to work with directly, Montague also provides a domain-specific language (similar to happy or alex) for defining schemas for parsing natural language syntax into structured formated for a specific domain. Schemas can be defined in `.mont` files, and are formatted by providing a header section with definitions of types and atoms, followed by a list of sequents denoting which strings map to whics atoms:

```
% example.mont
% types

Person :< Noun.
Place :< Noun.
DefiniteNoun :< Noun.
Question :< Noun.

% atoms

Nate: Person.
Berlin: Place.
Apple: DefiniteNoun.
Mother: Noun.

% productions

like, love  --> Like.
i           --> I.
killed      --> Killed.
the         --> The.
man, person --> Man. 
with        --> With.
spoon       --> Spoon.
```

Todo
----

Montague is in it's early stages and I am not an expert, so there is much that 
remains to be done. All contributions, both from experts in the field, or interested 
beginners/novices are welcome.

* The type system of Montague is pretty simple, and does not support 
   some very important features of montague semantics such as quantifiers.
  * Indexicals probably deserve specail treatement.
  * Add support for better error reporting.
  * Needs support for associativity.
  * The examples are all in English. Add some more examples in other languages. Particularly 
    interesting to me is the encoding of case-heavy languages like Polish. This may require some more advanced type system features in order to implement.

Montague

Montague 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Montague

Montague 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README