Added word derivational relationships (kind of eh at the moment) and moved verbly into its own directory

26 files changed, 579 insertions, 18 deletions

@@ -4,7 +4,3 @@ CMakeCache.txt
 CMakeFiles/
 Makefile
 cmake_install.cmake
-furries
-furries.dSYM/
-generator
-generator.dSYM/
@@ -2,23 +2,14 @@ cmake_minimum_required (VERSION 2.6)
 project (furries)
 
 add_subdirectory(vendor/twitcurl/libtwitcurl)
+add_subdirectory(vendor/verbly)
 
 find_package(PkgConfig)
 pkg_check_modules(YamlCpp yaml-cpp REQUIRED)
 pkg_check_modules(sqlite3 sqlite3 REQUIRED)
-find_package(libxml2 REQUIRED)
 
-add_library(verbly verbly/data.cpp verbly/adjective.cpp verbly/noun.cpp verbly/verb.cpp verbly/adverb.cpp verbly/token.cpp verbly/word.cpp)
-set_property(TARGET verbly PROPERTY CXX_STANDARD 11)
-set_property(TARGET verbly PROPERTY CXX_STANDARD_REQUIRED ON)
-
-include_directories(vendor/twitcurl/libtwitcurl ${LIBXML2_INCLUDE_DIR} ${sqlite3_INCLUDE_DIR})
+include_directories(vendor/twitcurl/libtwitcurl ${sqlite3_INCLUDE_DIR} vendor/verbly/lib)
 add_executable(furries furries.cpp)
 set_property(TARGET furries PROPERTY CXX_STANDARD 11)
 set_property(TARGET furries PROPERTY CXX_STANDARD_REQUIRED ON)
 target_link_libraries(furries ${sqlite3_LIBRARIES} ${YamlCpp_LIBRARIES} twitcurl curl verbly)
-
-add_executable(generator generator.cpp)
-set_property(TARGET generator PROPERTY CXX_STANDARD 11)
-set_property(TARGET generator PROPERTY CXX_STANDARD_REQUIRED ON)
-target_link_libraries(generator ${sqlite3_LIBRARIES} ${LIBXML2_LIBRARIES})
@@ -4,7 +4,7 @@
 #include <ctime>
 #include <sstream>
 #include <twitcurl.h>
-#include "verbly/verbly.h"
+#include <verbly.h>
 
 class fill_blanks {
   private:
@@ -0,0 +1,9 @@
+cmake_minimum_required (VERSION 2.6)
+project (verbly)
+
+find_package(PkgConfig)
+pkg_check_modules(sqlite3 sqlite3 REQUIRED)
+
+add_library(verbly lib/data.cpp lib/adjective.cpp lib/noun.cpp lib/verb.cpp lib/adverb.cpp lib/token.cpp lib/word.cpp)
+set_property(TARGET verbly PROPERTY CXX_STANDARD 11)
+set_property(TARGET verbly PROPERTY CXX_STANDARD_REQUIRED ON)
@@ -0,0 +1,3 @@
+WordNet Release 3.0
+
+This software and database is being provided to you, the LICENSEE, by Princeton University under the following license. By obtaining, using and/or copying this software and database, you agree that you have read, understood, and will comply with these terms and conditions.: Permission to use, copy, modify and distribute this software and database and its documentation for any purpose and without fee or royalty is hereby granted, provided that you agree to comply with the following copyright notice and statements, including the disclaimer, and that the same appear on ALL copies of the software, database and documentation, including modifications that you make for internal use or for distribution. WordNet 3.0 Copyright 2006 by Princeton University. All rights reserved. THIS SOFTWARE AND DATABASE IS PROVIDED "AS IS" AND PRINCETON UNIVERSITY MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PRINCETON UNIVERSITY MAKES NO REPRESENTATIONS OR WARRANTIES OF MERCHANT- ABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE LICENSED SOFTWARE, DATABASE OR DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS. The name of Princeton University or Princeton may not be used in advertising or publicity pertaining to distribution of the software and/or database. Title to copyright in this software, database and any associated documentation shall at all times remain with Princeton University and LICENSEE agrees to preserve same.
\ No newline at end of file
@@ -0,0 +1,12 @@
+cmake_minimum_required (VERSION 2.6)
+project (generator)
+
+find_package(PkgConfig)
+pkg_check_modules(sqlite3 sqlite3 REQUIRED)
+find_package(libxml2 REQUIRED)
+
+include_directories(${sqlite3_INCLUDE_DIR} ${LIBXML2_INCLUDE_DIR})
+add_executable(generator generator.cpp)
+set_property(TARGET generator PROPERTY CXX_STANDARD 11)
+set_property(TARGET generator PROPERTY CXX_STANDARD_REQUIRED ON)
+target_link_libraries(generator ${sqlite3_LIBRARIES} ${LIBXML2_LIBRARIES})
@@ -459,6 +459,7 @@ int main(int argc, char** argv)
   // - s: master list
   // - ant: antonymy (e.g. happy/sad, sad/happy, happiness/sadness)
   // - at: variation (e.g. a measurement can be standard or nonstandard)
+  // - der: derivation (e.g. happy/happily, happily/happy)
   // - hyp: hypernymy/hyponymy (e.g. color/red, color/blue)
   // - ins: instantiation (do we need this? let's see)
   // - mm: member meronymy/holonymy (e.g. family/mother, family/child)
@@ -893,6 +894,148 @@ int main(int argc, char** argv)
     }
   }
   
+  // der table
+  {
+    std::ifstream wnderfile(wnpref + "wn_der.pl");
+    if (!wnderfile.is_open())
+    {
+      std::cout << "Invalid WordNet data directory." << std::endl;
+      print_usage();
+    }
+    
+    std::list<std::string> lines;
+    for (;;)
+    {
+      std::string line;
+      if (!getline(wnderfile, line))
+      {
+        break;
+      }
+    
+      if (line.back() == '\r')
+      {
+        line.pop_back();
+      }
+      
+      lines.push_back(line);
+    }
+    
+    progress ppgs("Writing morphological derivation...", lines.size());
+    for (auto line : lines)
+    {
+      ppgs.update();
+      
+      std::regex relation("^der\\(([134]\\d{8}),(\\d+),([134]\\d{8}),(\\d+)\\)\\.");
+      std::smatch relation_data;
+      if (!std::regex_search(line, relation_data, relation))
+      {
+        continue;
+      }
+      
+      int synset_id_1 = stoi(relation_data[1]);
+      int wnum_1 = stoi(relation_data[2]);
+      int synset_id_2 = stoi(relation_data[3]);
+      int wnum_2 = stoi(relation_data[4]);
+      std::string query;
+      switch (synset_id_1 / 100000000)
+      {
+        case 1: // Noun
+        {
+          switch (synset_id_2 / 100000000)
+          {
+            case 1: // Noun
+            {
+              query = "INSERT INTO noun_noun_derivation (noun_1_id, noun_2_id) VALUES (?, ?)";
+              break;
+            }
+            
+            case 3: // Adjective
+            {
+              query = "INSERT INTO noun_adjective_derivation (noun_id, adjective_id) VALUES (?, ?)";
+              break;
+            }
+            
+            case 4: // Adverb
+            {
+              query = "INSERT INTO noun_adverb_derivation (noun_id, adverb_id) VALUES (?, ?)";
+              break;
+            }
+          }
+          
+          break;
+        }
+        
+        case 3: // Adjective
+        {
+          switch (synset_id_2 / 100000000)
+          {
+            case 1: // Noun
+            {
+              query = "INSERT INTO noun_adjective_derivation (adjective_id, noun_id) VALUES (?, ?)";
+              break;
+            }
+            
+            case 3: // Adjective
+            {
+              query = "INSERT INTO adjective_adjective_derivation (adjective_id, adjective_id) VALUES (?, ?)";
+              break;
+            }
+            
+            case 4: // Adverb
+            {
+              query = "INSERT INTO adjective_adverb_derivation (adjective_id, adverb_id) VALUES (?, ?)";
+              break;
+            }
+          }
+          
+          break;
+        }
+        
+        case 4: // Adverb
+        {
+          switch (synset_id_2 / 100000000)
+          {
+            case 1: // Noun
+            {
+              query = "INSERT INTO noun_adverb_derivation (adverb_id, noun_id) VALUES (?, ?)";
+              break;
+            }
+            
+            case 3: // Adjective
+            {
+              query = "INSERT INTO adjective_adverb_derivation (adverb_id, adjective_id) VALUES (?, ?)";
+              break;
+            }
+            
+            case 4: // Adverb
+            {
+              query = "INSERT INTO adverb_adverb_derivation (adverb_1_id, adverb_2_id) VALUES (?, ?)";
+              break;
+            }
+          }
+          
+          break;
+        }
+      }
+      
+      sqlite3_stmt* ppstmt;
+      if (sqlite3_prepare_v2(ppdb, query.c_str(), query.size(), &ppstmt, NULL) != SQLITE_OK)
+      {
+        db_error(ppdb, query);
+      }
+      
+      sqlite3_bind_int(ppstmt, 1, wn[synset_id_1][wnum_1]);
+      sqlite3_bind_int(ppstmt, 2, wn[synset_id_2][wnum_2]);
+      
+      if (sqlite3_step(ppstmt) != SQLITE_DONE)
+      {
+        db_error(ppdb, query);
+      }
+      
+      sqlite3_finalize(ppstmt);
+    }
+  }
+  
   // hyp table
   {
     std::ifstream wnhypfile(wnpref + "wn_hyp.pl");
@@ -1375,7 +1518,7 @@ int main(int argc, char** argv)
       sqlite3_finalize(ppstmt);
     }
   }
-  /*
+
   // sim table
   {
     std::ifstream wnsimfile(wnpref + "wn_sim.pl");
@@ -1452,7 +1595,7 @@ int main(int argc, char** argv)
       }
     }
   }
-  */
+  
   // syntax table
   {
     std::ifstream wnsyntaxfile(wnpref + "wn_syntax.pl");
@@ -202,3 +202,51 @@ CREATE TABLE `adverb_pronunciations` (
   `pronunciation` VARCHAR(64) NOT NULL,
   FOREIGN KEY (`adverb_id`) REFERENCES `adverbs`(`adverb_id`)
 );
+
+DROP TABLE IF EXISTS `noun_noun_derivation`;
+CREATE TABLE `noun_noun_derivation` (
+  `noun_1_id` INTEGER NOT NULL,
+  `noun_2_id` INTEGER NOT NULL,
+  FOREIGN KEY (`noun_1_id`) REFERENCES `nouns`(`noun_id`),
+  FOREIGN KEY (`noun_2_id`) REFERENCES `nouns`(`noun_id`)
+);
+
+DROP TABLE IF EXISTS `noun_adjective_derivation`;
+CREATE TABLE `noun_adjective_derivation` (
+  `noun_id` INTEGER NOT NULL,
+  `adjective_id` INTEGER NOT NULL,
+  FOREIGN KEY (`noun_id`) REFERENCES `nouns`(`noun_id`),
+  FOREIGN KEY (`adjective_id`) REFERENCES `adjectives`(`adjective_id`)
+);
+
+DROP TABLE IF EXISTS `noun_adverb_derivation`;
+CREATE TABLE `noun_adverb_derivation` (
+  `noun_id` INTEGER NOT NULL,
+  `adverb_id` INTEGER NOT NULL,
+  FOREIGN KEY (`noun_id`) REFERENCES `nouns`(`noun_id`),
+  FOREIGN KEY (`adverb_id`) REFERENCES `adverbs`(`adverb_id`)
+);
+
+DROP TABLE IF EXISTS `adjective_adjective_derivation`;
+CREATE TABLE `adjective_adjective_derivation` (
+  `adjective_1_id` INTEGER NOT NULL,
+  `adjective_2_id` INTEGER NOT NULL,
+  FOREIGN KEY (`adjective_1_id`) REFERENCES `adjectives`(`adjective_id`),
+  FOREIGN KEY (`adjective_2_id`) REFERENCES `adjectives`(`adjective_id`)
+);
+
+DROP TABLE IF EXISTS `adjective_adverb_derivation`;
+CREATE TABLE `adjective_adverb_derivation` (
+  `adjective_id` INTEGER NOT NULL,
+  `adverb_id` INTEGER NOT NULL,
+  FOREIGN KEY (`adjective_id`) REFERENCES `adjectives`(`adjective_id`),
+  FOREIGN KEY (`adverb_id`) REFERENCES `adverbs`(`adjective_id`)
+);
+
+DROP TABLE IF EXISTS `adverb_adverb_derivation`;
+CREATE TABLE `adverb_adverb_derivation` (
+  `adverb_1_id` INTEGER NOT NULL,
+  `adverb_2_id` INTEGER NOT NULL,
+  FOREIGN KEY (`adverb_1_id`) REFERENCES `adverbs`(`adverb_id`),
+  FOREIGN KEY (`adverb_2_id`) REFERENCES `adverbs`(`adverb_id`)
+);
@@ -261,6 +261,38 @@ namespace verbly {
     return *this;
   }
   
+  adjective_query& adjective_query::derived_from(const word& _w)
+  {
+    if (dynamic_cast<const adjective*>(&_w) != nullptr)
+    {
+      _derived_from_adjective.push_back(dynamic_cast<const adjective&>(_w));
+    } else if (dynamic_cast<const adverb*>(&_w) != nullptr)
+    {
+      _derived_from_adverb.push_back(dynamic_cast<const adverb&>(_w));
+    } else if (dynamic_cast<const noun*>(&_w) != nullptr)
+    {
+      _derived_from_noun.push_back(dynamic_cast<const noun&>(_w));
+    }
+    
+    return *this;
+  }
+  
+  adjective_query& adjective_query::not_derived_from(const word& _w)
+  {
+    if (dynamic_cast<const adjective*>(&_w) != nullptr)
+    {
+      _not_derived_from_adjective.push_back(dynamic_cast<const adjective&>(_w));
+    } else if (dynamic_cast<const adverb*>(&_w) != nullptr)
+    {
+      _not_derived_from_adverb.push_back(dynamic_cast<const adverb&>(_w));
+    } else if (dynamic_cast<const noun*>(&_w) != nullptr)
+    {
+      _not_derived_from_noun.push_back(dynamic_cast<const noun&>(_w));
+    }
+    
+    return *this;
+  }
+  
   std::list<adjective> adjective_query::run() const
   {
     std::stringstream construct;
@@ -423,6 +455,48 @@ namespace verbly {
       conditions.push_back(cond);
     }
     
+    if (!_derived_from_adjective.empty())
+    {
+      std::list<std::string> clauses(_derived_from_adjective.size(), "adjective_2_id = @DERADJ");
+      std::string cond = "adjective_id IN (SELECT adjective_1_id FROM adjective_adjective_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_derived_from_adjective.empty())
+    {
+      std::list<std::string> clauses(_not_derived_from_adjective.size(), "adjective_2_id = @NDERADJ");
+      std::string cond = "adjective_id NOT IN (SELECT adjective_1_id FROM adjective_adjective_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_derived_from_adverb.empty())
+    {
+      std::list<std::string> clauses(_derived_from_adverb.size(), "adverb_id = @DERADV");
+      std::string cond = "adjective_id IN (SELECT adjective_id FROM adjective_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_derived_from_adverb.empty())
+    {
+      std::list<std::string> clauses(_not_derived_from_adverb.size(), "adverb_id = @NDERADV");
+      std::string cond = "adjective_id NOT IN (SELECT adjective_id FROM adjective_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_derived_from_noun.empty())
+    {
+      std::list<std::string> clauses(_derived_from_noun.size(), "noun_id = @DERN");
+      std::string cond = "adjective_id IN (SELECT adjective_id FROM noun_adjective_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_derived_from_noun.empty())
+    {
+      std::list<std::string> clauses(_not_derived_from_noun.size(), "noun_id = @NDERN");
+      std::string cond = "adjective_id NOT IN (SELECT adjective_id FROM noun_adjective_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
     if (!conditions.empty())
     {
       construct << " WHERE ";
@@ -522,6 +596,36 @@ namespace verbly {
     {
       sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@MANID"), mannernym._id);
     }
+    
+    for (auto adj : _derived_from_adjective)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERADJ"), adj._id);
+    }
+    
+    for (auto adj : _not_derived_from_adjective)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERADJ"), adj._id);
+    }
+    
+    for (auto adv : _derived_from_adverb)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERADV"), adv._id);
+    }
+    
+    for (auto adv : _not_derived_from_adverb)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERADV"), adv._id);
+    }
+    
+    for (auto n : _derived_from_noun)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERN"), n._id);
+    }
+    
+    for (auto n : _not_derived_from_noun)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERN"), n._id);
+    }
 
     std::list<adjective> output;
     while (sqlite3_step(ppstmt) == SQLITE_ROW)
@@ -85,6 +85,9 @@ namespace verbly {
       adjective_query& is_mannernymic(bool _is_mannernymic);
       adjective_query& anti_mannernym_of(const adverb& _adv);
       
+      adjective_query& derived_from(const word& _w);
+      adjective_query& not_derived_from(const word& _w);
+      
       std::list<adjective> run() const;
       
       const static int unlimited = -1;
@@ -126,6 +129,13 @@ namespace verbly {
       
       bool _is_mannernymic = false;
       std::list<adverb> _anti_mannernym_of;
+      
+      std::list<adjective> _derived_from_adjective;
+      std::list<adjective> _not_derived_from_adjective;
+      std::list<adverb> _derived_from_adverb;
+      std::list<adverb> _not_derived_from_adverb;
+      std::list<noun> _derived_from_noun;
+      std::list<noun> _not_derived_from_noun;
   };
   
 };
@@ -168,6 +168,38 @@ namespace verbly {
     return *this;
   }
   
+  adverb_query& adverb_query::derived_from(const word& _w)
+  {
+    if (dynamic_cast<const adjective*>(&_w) != nullptr)
+    {
+      _derived_from_adjective.push_back(dynamic_cast<const adjective&>(_w));
+    } else if (dynamic_cast<const adverb*>(&_w) != nullptr)
+    {
+      _derived_from_adverb.push_back(dynamic_cast<const adverb&>(_w));
+    } else if (dynamic_cast<const noun*>(&_w) != nullptr)
+    {
+      _derived_from_noun.push_back(dynamic_cast<const noun&>(_w));
+    }
+    
+    return *this;
+  }
+  
+  adverb_query& adverb_query::not_derived_from(const word& _w)
+  {
+    if (dynamic_cast<const adjective*>(&_w) != nullptr)
+    {
+      _not_derived_from_adjective.push_back(dynamic_cast<const adjective&>(_w));
+    } else if (dynamic_cast<const adverb*>(&_w) != nullptr)
+    {
+      _not_derived_from_adverb.push_back(dynamic_cast<const adverb&>(_w));
+    } else if (dynamic_cast<const noun*>(&_w) != nullptr)
+    {
+      _not_derived_from_noun.push_back(dynamic_cast<const noun&>(_w));
+    }
+    
+    return *this;
+  }
+  
   std::list<adverb> adverb_query::run() const
   {
     std::stringstream construct;
@@ -251,6 +283,48 @@ namespace verbly {
       conditions.push_back(cond);
     }
     
+    if (!_derived_from_adjective.empty())
+    {
+      std::list<std::string> clauses(_derived_from_adjective.size(), "adjective_id = @DERADJ");
+      std::string cond = "adverb_id IN (SELECT adverb_id FROM adjective_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_derived_from_adjective.empty())
+    {
+      std::list<std::string> clauses(_not_derived_from_adjective.size(), "adjective_id = @NDERADJ");
+      std::string cond = "adverb_id NOT IN (SELECT adverb_id FROM adjective_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_derived_from_adverb.empty())
+    {
+      std::list<std::string> clauses(_derived_from_adverb.size(), "adverb_2_id = @DERADV");
+      std::string cond = "adverb_id IN (SELECT adverb_1_id FROM adverb_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_derived_from_adverb.empty())
+    {
+      std::list<std::string> clauses(_not_derived_from_adverb.size(), "adverb_2_id = @NDERADV");
+      std::string cond = "adverb_id NOT IN (SELECT adverb_1_id FROM adverb_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_derived_from_noun.empty())
+    {
+      std::list<std::string> clauses(_derived_from_noun.size(), "noun_id = @DERN");
+      std::string cond = "adverb_id IN (SELECT adverb_id FROM noun_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_derived_from_noun.empty())
+    {
+      std::list<std::string> clauses(_not_derived_from_noun.size(), "noun_id = @NDERN");
+      std::string cond = "adverb_id NOT IN (SELECT adverb_id FROM noun_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
     if (!conditions.empty())
     {
       construct << " WHERE ";
@@ -315,6 +389,36 @@ namespace verbly {
     {
       sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@AMANID"), adj._id);
     }
+    
+    for (auto adj : _derived_from_adjective)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERADJ"), adj._id);
+    }
+    
+    for (auto adj : _not_derived_from_adjective)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERADJ"), adj._id);
+    }
+    
+    for (auto adv : _derived_from_adverb)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERADV"), adv._id);
+    }
+    
+    for (auto adv : _not_derived_from_adverb)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERADV"), adv._id);
+    }
+    
+    for (auto n : _derived_from_noun)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERN"), n._id);
+    }
+    
+    for (auto n : _not_derived_from_noun)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERN"), n._id);
+    }
 
     std::list<adverb> output;
     while (sqlite3_step(ppstmt) == SQLITE_ROW)
@@ -24,6 +24,9 @@ namespace verbly {
       adverb_query antonyms() const;
       adverb_query synonyms() const;
       adjective_query anti_mannernyms() const;
+      
+      adverb_query& derived_from(const word& _w);
+      adverb_query& not_derived_from(const word& _w);
   };
   
   class adverb_query {
@@ -50,6 +53,9 @@ namespace verbly {
       adverb_query& is_mannernymic(bool _arg);
       adverb_query& mannernym_of(const adjective& _adj);
       
+      adverb_query& derived_from(const word& _w);
+      adverb_query& not_derived_from(const word& _w);
+      
       std::list<adverb> run() const;
       
       const static int unlimited = -1;
@@ -75,6 +81,13 @@ namespace verbly {
       
       bool _is_mannernymic = false;
       std::list<adjective> _mannernym_of;
+      
+      std::list<adjective> _derived_from_adjective;
+      std::list<adjective> _not_derived_from_adjective;
+      std::list<adverb> _derived_from_adverb;
+      std::list<adverb> _not_derived_from_adverb;
+      std::list<noun> _derived_from_noun;
+      std::list<noun> _not_derived_from_noun;
   };
   
 };
@@ -323,6 +323,13 @@ namespace verbly {
     return *this;
   }
   
+  noun_query& noun_query::is_not_proper(bool _arg)
+  {
+    _is_not_proper = _arg;
+    
+    return *this;
+  }
+  
   noun_query& noun_query::instance_of(const noun& _noun)
   {
     _instance_of.push_back(_noun);
@@ -428,6 +435,38 @@ namespace verbly {
     return *this;
   }
   
+  noun_query& noun_query::derived_from(const word& _w)
+  {
+    if (dynamic_cast<const adjective*>(&_w) != nullptr)
+    {
+      _derived_from_adjective.push_back(dynamic_cast<const adjective&>(_w));
+    } else if (dynamic_cast<const adverb*>(&_w) != nullptr)
+    {
+      _derived_from_adverb.push_back(dynamic_cast<const adverb&>(_w));
+    } else if (dynamic_cast<const noun*>(&_w) != nullptr)
+    {
+      _derived_from_noun.push_back(dynamic_cast<const noun&>(_w));
+    }
+    
+    return *this;
+  }
+  
+  noun_query& noun_query::not_derived_from(const word& _w)
+  {
+    if (dynamic_cast<const adjective*>(&_w) != nullptr)
+    {
+      _not_derived_from_adjective.push_back(dynamic_cast<const adjective&>(_w));
+    } else if (dynamic_cast<const adverb*>(&_w) != nullptr)
+    {
+      _not_derived_from_adverb.push_back(dynamic_cast<const adverb&>(_w));
+    } else if (dynamic_cast<const noun*>(&_w) != nullptr)
+    {
+      _not_derived_from_noun.push_back(dynamic_cast<const noun&>(_w));
+    }
+    
+    return *this;
+  }
+  
   std::list<noun> noun_query::run() const
   {
     std::stringstream construct;
@@ -608,6 +647,11 @@ namespace verbly {
       conditions.push_back("noun_id IN (SELECT instance_id FROM instantiation)");
     }
     
+    if (_is_not_proper)
+    {
+      conditions.push_back("noun_id NOT IN (SELECT instance_id FROM instantiation)");
+    }
+    
     if (!_instance_of.empty())
     {
       std::list<std::string> clauses(_instance_of.size(), "class_id = @CLSID");
@@ -703,6 +747,48 @@ namespace verbly {
       conditions.push_back(cond);
     }
     
+    if (!_derived_from_adjective.empty())
+    {
+      std::list<std::string> clauses(_derived_from_adjective.size(), "adjective_id = @DERADJ");
+      std::string cond = "noun_id IN (SELECT noun_id FROM noun_adjective_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_derived_from_adjective.empty())
+    {
+      std::list<std::string> clauses(_not_derived_from_adjective.size(), "adjective_id = @NDERADJ");
+      std::string cond = "noun_id NOT IN (SELECT noun_id FROM noun_adjective_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_derived_from_adverb.empty())
+    {
+      std::list<std::string> clauses(_derived_from_adverb.size(), "adverb_id = @DERADV");
+      std::string cond = "noun_id IN (SELECT noun_id FROM noun_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_derived_from_adverb.empty())
+    {
+      std::list<std::string> clauses(_not_derived_from_adverb.size(), "adverb_id = @NDERADV");
+      std::string cond = "noun_id NOT IN (SELECT noun_id FROM noun_adverb_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_derived_from_noun.empty())
+    {
+      std::list<std::string> clauses(_derived_from_noun.size(), "noun_2_id = @DERN");
+      std::string cond = "noun_id IN (SELECT noun_1_id FROM noun_noun_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
+    if (!_not_derived_from_noun.empty())
+    {
+      std::list<std::string> clauses(_not_derived_from_noun.size(), "noun_2_id = @NDERN");
+      std::string cond = "noun_id NOT IN (SELECT noun_1_id FROM noun_noun_derivation WHERE " + verbly::implode(std::begin(clauses), std::end(clauses), " OR ") + ")";
+      conditions.push_back(cond);
+    }
+    
     if (!conditions.empty())
     {
       construct << " WHERE ";
@@ -872,6 +958,36 @@ namespace verbly {
     {
       sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@VALID"), value._id);
     }
+    
+    for (auto adj : _derived_from_adjective)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERADJ"), adj._id);
+    }
+    
+    for (auto adj : _not_derived_from_adjective)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERADJ"), adj._id);
+    }
+    
+    for (auto adv : _derived_from_adverb)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERADV"), adv._id);
+    }
+    
+    for (auto adv : _not_derived_from_adverb)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERADV"), adv._id);
+    }
+    
+    for (auto n : _derived_from_noun)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@DERN"), n._id);
+    }
+    
+    for (auto n : _not_derived_from_noun)
+    {
+      sqlite3_bind_int(ppstmt, sqlite3_bind_parameter_index(ppstmt, "@NDERN"), n._id);
+    }
 
     std::list<noun> output;
     while (sqlite3_step(ppstmt) == SQLITE_ROW)
@@ -78,6 +78,7 @@ namespace verbly {
       noun_query& not_member_holonym_of(const noun& _noun);
       
       noun_query& is_proper(bool _arg);
+      noun_query& is_not_proper(bool _arg);
       noun_query& instance_of(const noun& _noun);
       noun_query& not_instance_of(const noun& _noun);
       
@@ -99,6 +100,9 @@ namespace verbly {
       noun_query& is_attribute(bool _arg);
       noun_query& attribute_of(const adjective& _adj);
       
+      noun_query& derived_from(const word& _w);
+      noun_query& not_derived_from(const word& _w);
+      
       std::list<noun> run() const;
       
       const static int unlimited = -1;
@@ -144,6 +148,7 @@ namespace verbly {
       std::list<noun> _not_member_holonym_of;
       
       bool _is_proper = false;
+      bool _is_not_proper = false;
       std::list<noun> _instance_of;
       std::list<noun> _not_instance_of;
       
@@ -164,6 +169,13 @@ namespace verbly {
       
       bool _is_attribute = false;
       std::list<adjective> _attribute_of;
+      
+      std::list<adjective> _derived_from_adjective;
+      std::list<adjective> _not_derived_from_adjective;
+      std::list<adverb> _derived_from_adverb;
+      std::list<adverb> _not_derived_from_adverb;
+      std::list<noun> _derived_from_noun;
+      std::list<noun> _not_derived_from_noun;
   };
   
 };