jadb/lib/util/lemmatizer/rules/godan_verbs.dart

import 'package:jadb/util/lemmatizer/lemmatizer.dart';

final LemmatizationRule godanVerbBase = LemmatizationRule(
  name: 'Godan verb - base form',
  terminal: true,
  pattern: AllomorphPattern(
    patterns: {
      'う': ['う'],
      'く': ['く'],
      'ぐ': ['ぐ'],
      'す': ['す'],
      'つ': ['つ'],
      'ぬ': ['ぬ'],
      'ぶ': ['ぶ'],
      'む': ['む'],
      'る': ['る'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbNegative = LemmatizationRule(
  name: 'Godan verb - negative form',
  pattern: AllomorphPattern(
    patterns: {
      'わない': ['う'],
      'かない': ['く'],
      'がない': ['ぐ'],
      'さない': ['す'],
      'たない': ['つ'],
      'なない': ['ぬ'],
      'ばない': ['ぶ'],
      'まない': ['む'],
      'らない': ['る'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbPast = LemmatizationRule(
  name: 'Godan verb - past form',
  pattern: AllomorphPattern(
    patterns: {
      'した': ['す'],
      'った': ['る', 'つ', 'う'],
      'んだ': ['む', 'ぬ', 'ぶ'],
      'いだ': ['ぐ'],
      'いた': ['く'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbTe = LemmatizationRule(
  name: 'Godan verb - te-form',
  pattern: AllomorphPattern(
    patterns: {
      'いて': ['く', 'ぐ'],
      'して': ['す'],
      'って': ['る', 'つ', 'う'],
      'んで': ['む', 'ぬ', 'ぶ'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbTeiru = LemmatizationRule(
  name: 'Godan verb - te-form with いる',
  pattern: AllomorphPattern(
    patterns: {
      'いている': ['く', 'ぐ'],
      'している': ['す'],
      'っている': ['る', 'つ', 'う'],
      'んでいる': ['む', 'ぬ', 'ぶ'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbTeita = LemmatizationRule(
  name: 'Godan verb - te-form with いた',
  pattern: AllomorphPattern(
    patterns: {
      'いていた': ['く', 'ぐ'],
      'していた': ['す'],
      'っていた': ['る', 'つ', 'う'],
      'んでいた': ['む', 'ぬ', 'ぶ'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbConditional = LemmatizationRule(
  name: 'Godan verb - conditional form',
  pattern: AllomorphPattern(
    patterns: {
      'けば': ['く'],
      'げば': ['ぐ'],
      'せば': ['す'],
      'てば': ['つ', 'る', 'う'],
      'ねば': ['ぬ'],
      'べば': ['ぶ'],
      'めば': ['む'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbVolitional = LemmatizationRule(
  name: 'Godan verb - volitional form',
  pattern: AllomorphPattern(
    patterns: {
      'おう': ['う'],
      'こう': ['く'],
      'ごう': ['ぐ'],
      'そう': ['す'],
      'とう': ['つ', 'る', 'う'],
      'のう': ['ぬ'],
      'ぼう': ['ぶ'],
      'もう': ['む'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbPotential = LemmatizationRule(
  name: 'Godan verb - potential form',
  pattern: AllomorphPattern(
    patterns: {
      'ける': ['く'],
      'げる': ['ぐ'],
      'せる': ['す'],
      'てる': ['つ', 'る', 'う'],
      'ねる': ['ぬ'],
      'べる': ['ぶ'],
      'める': ['む'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbPassive = LemmatizationRule(
  name: 'Godan verb - passive form',
  pattern: AllomorphPattern(
    patterns: {
      'かれる': ['く'],
      'がれる': ['ぐ'],
      'される': ['す'],
      'たれる': ['つ', 'る', 'う'],
      'なれる': ['ぬ'],
      'ばれる': ['ぶ'],
      'まれる': ['む'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbCausative = LemmatizationRule(
  name: 'Godan verb - causative form',
  pattern: AllomorphPattern(
    patterns: {
      'かせる': ['く'],
      'がせる': ['ぐ'],
      'させる': ['す'],
      'たせる': ['つ', 'る', 'う'],
      'なせる': ['ぬ'],
      'ばせる': ['ぶ'],
      'ませる': ['む'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbCausativePassive = LemmatizationRule(
  name: 'Godan verb - causative-passive form',
  pattern: AllomorphPattern(
    patterns: {
      'かされる': ['く'],
      'がされる': ['ぐ'],
      'される': ['す'],
      'たされる': ['つ', 'る', 'う'],
      'なされる': ['ぬ'],
      'ばされる': ['ぶ'],
      'まされる': ['む'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbImperative = LemmatizationRule(
  name: 'Godan verb - imperative form',
  pattern: AllomorphPattern(
    patterns: {
      'え': ['う'],
      'け': ['く'],
      'げ': ['ぐ'],
      'せ': ['す'],
      'て': ['つ', 'る', 'う'],
      'ね': ['ぬ'],
      'べ': ['ぶ'],
      'め': ['む'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbNegativePast = LemmatizationRule(
  name: 'Godan verb - negative past form',
  pattern: AllomorphPattern(
    patterns: {
      'わなかった': ['う'],
      'かなかった': ['く'],
      'がなかった': ['ぐ'],
      'さなかった': ['す'],
      'たなかった': ['つ'],
      'ななかった': ['ぬ'],
      'ばなかった': ['ぶ'],
      'まなかった': ['む'],
      'らなかった': ['る'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbNegativeTe = LemmatizationRule(
  name: 'Godan verb - negative te-form',
  pattern: AllomorphPattern(
    patterns: {
      'わなくて': ['う'],
      'かなくて': ['く'],
      'がなくて': ['ぐ'],
      'さなくて': ['す'],
      'たなくて': ['つ'],
      'ななくて': ['ぬ'],
      'ばなくて': ['ぶ'],
      'まなくて': ['む'],
      'らなくて': ['る'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbNegativeConditional = LemmatizationRule(
  name: 'Godan verb - negative conditional form',
  pattern: AllomorphPattern(
    patterns: {
      'わなければ': ['う'],
      'かなければ': ['く'],
      'がなければ': ['ぐ'],
      'さなければ': ['す'],
      'たなければ': ['つ'],
      'ななければ': ['ぬ'],
      'ばなければ': ['ぶ'],
      'まなければ': ['む'],
      'らなければ': ['る'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbNegativeVolitional = LemmatizationRule(
  name: 'Godan verb - negative volitional form',
  pattern: AllomorphPattern(
    patterns: {
      'うまい': ['う'],
      'くまい': ['く'],
      'ぐまい': ['ぐ'],
      'すまい': ['す'],
      'つまい': ['つ', 'る', 'う'],
      'ぬまい': ['ぬ'],
      'ぶまい': ['ぶ'],
      'むまい': ['む'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbNegativePotential = LemmatizationRule(
  name: 'Godan verb - negative potential form',
  pattern: AllomorphPattern(
    patterns: {
      'けない': ['く'],
      'げない': ['ぐ'],
      'せない': ['す'],
      'てない': ['つ', 'る', 'う'],
      'ねない': ['ぬ'],
      'べない': ['ぶ'],
      'めない': ['む'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbNegativePassive = LemmatizationRule(
  name: 'Godan verb - negative passive form',
  pattern: AllomorphPattern(
    patterns: {
      'かれない': ['く'],
      'がれない': ['ぐ'],
      'されない': ['す'],
      'たれない': ['つ', 'る', 'う'],
      'なれない': ['ぬ'],
      'ばれない': ['ぶ'],
      'まれない': ['む'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbNegativeCausative = LemmatizationRule(
  name: 'Godan verb - negative causative form',
  pattern: AllomorphPattern(
    patterns: {
      'かせない': ['く'],
      'がせない': ['ぐ'],
      'させない': ['す'],
      'たせない': ['つ', 'る', 'う'],
      'なせない': ['ぬ'],
      'ばせない': ['ぶ'],
      'ませない': ['む'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbNegativeCausativePassive = LemmatizationRule(
  name: 'Godan verb - negative causative-passive form',
  pattern: AllomorphPattern(
    patterns: {
      'かされない': ['く'],
      'がされない': ['ぐ'],
      'されない': ['す'],
      'たされない': ['つ', 'る', 'う'],
      'なされない': ['ぬ'],
      'ばされない': ['ぶ'],
      'まされない': ['む'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbNegativeImperative = LemmatizationRule(
  name: 'Godan verb - negative imperative form',
  pattern: AllomorphPattern(
    patterns: {
      'うな': ['う'],
      'くな': ['く'],
      'ぐな': ['ぐ'],
      'すな': ['す'],
      'つな': ['つ'],
      'ぬな': ['ぬ'],
      'ぶな': ['ぶ'],
      'むな': ['む'],
      'るな': ['る'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbDesire = LemmatizationRule(
  name: 'Godan verb - desire form',
  pattern: AllomorphPattern(
    patterns: {
      'きたい': ['く'],
      'ぎたい': ['ぐ'],
      'したい': ['す'],
      'ちたい': ['つ'],
      'にたい': ['ぬ'],
      'びたい': ['ぶ'],
      'みたい': ['む'],
      'りたい': ['る'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbNegativeDesire = LemmatizationRule(
  name: 'Godan verb - negative desire form',
  pattern: AllomorphPattern(
    patterns: {
      'いたくない': ['う'],
      'きたくない': ['く'],
      'ぎたくない': ['ぐ'],
      'したくない': ['す'],
      'ちたくない': ['つ'],
      'にたくない': ['ぬ'],
      'びたくない': ['ぶ'],
      'みたくない': ['む'],
      'りたくない': ['る'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbPastDesire = LemmatizationRule(
  name: 'Godan verb - past desire form',
  pattern: AllomorphPattern(
    patterns: {
      'きたかった': ['く'],
      'ぎたかった': ['ぐ'],
      'したかった': ['す'],
      'ちたかった': ['つ'],
      'にたかった': ['ぬ'],
      'びたかった': ['ぶ'],
      'みたかった': ['む'],
      'りたかった': ['る'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final LemmatizationRule godanVerbNegativePastDesire = LemmatizationRule(
  name: 'Godan verb - negative past desire form',
  pattern: AllomorphPattern(
    patterns: {
      'いたくなかった': ['う'],
      'きたくなかった': ['く'],
      'ぎたくなかった': ['ぐ'],
      'したくなかった': ['す'],
      'ちたくなかった': ['つ'],
      'にたくなかった': ['ぬ'],
      'びたくなかった': ['ぶ'],
      'みたくなかった': ['む'],
      'りたくなかった': ['る'],
    },
    type: LemmatizationRuleType.suffix,
  ),
  validChildClasses: {WordClass.godanVerb},
  wordClass: WordClass.godanVerb,
);

final List<LemmatizationRule> godanVerbLemmatizationRules = List.unmodifiable([
  godanVerbBase,
  godanVerbNegative,
  godanVerbPast,
  godanVerbTe,
  godanVerbTeiru,
  godanVerbTeita,
  godanVerbConditional,
  godanVerbVolitional,
  godanVerbPotential,
  godanVerbPassive,
  godanVerbCausative,
  godanVerbCausativePassive,
  godanVerbImperative,
  godanVerbNegativePast,
  godanVerbNegativeTe,
  godanVerbNegativeConditional,
  godanVerbNegativeVolitional,
  godanVerbNegativePotential,
  godanVerbNegativePassive,
  godanVerbNegativeCausative,
  godanVerbNegativeCausativePassive,
  godanVerbNegativeImperative,
  godanVerbDesire,
  godanVerbNegativeDesire,
  godanVerbPastDesire,
  godanVerbNegativePastDesire,
]);