OrdussianPoliticalSystemMtWriter.java

Go to the documentation of this file.

/**
 * Copyright (c) Dmitri Pissarenko
 * http://dapissarenko.com
 * 
 * Created on 05.09.2005
 */
package com.dapissarenko.hierarchy;

import java.io.IOException;
import java.util.ArrayList;

import org.opencyc.api.CycAccess;
import org.opencyc.api.CycApiException;
import org.opencyc.cycobject.CycConstant;
import org.opencyc.cycobject.CycFort;

/**
 * @author Dmitri Pissarenko
 *
 */
public class OrdussianPoliticalSystemMtWriter {
    private static final String COLLECTION = "Collection";
    public OrdussianPoliticalSystemMtWriter()
    {
    }
    public CycConstant writeMicroTheoryToCyc(CycAccess cyc) throws IOException, CycApiException
    {
        CycConstant ordus=null;
        CycConstant department=null;
        CycConstant mt=null;
        CycConstant depIntAff=null;
        CycConstant depEthSup=null;
        CycConstant fieldOfWork=null;
        CycConstant headOfDepartment=null;
        CycConstant alimagomedov=null;
        CycConstant civilServant=null;
        CycConstant lobo=null;
        CycConstant ouiantsevSu=null;
        CycConstant rabinovich=null;
        CycFort givenNames=null;
        CycFort familyName=null;
        CycFort superiors=null;
        
        
        /**
         * create microtheory
         */
        mt=cyc.createMicrotheory("OrdussianPoliticalSystemMt", 
                                "This microtheory describes the political system of Ordus'",
                                "Microtheory",
                                new ArrayList());
     
        /**
         * Enter some countries
         * (#$isa #$Russia #$Country)
         * (#$isa #$Belarus #$Country)
         * (#$isa #$Austria #$Country)
         * (#$isa #$Germany #$Country)
         */
        this.createCountry("Russia", "Russian Federation", cyc, mt);
        this.createCountry("Belarus", "Belorussia", cyc, mt);
        this.createCountry("Austria", "Republic of Austria", cyc, mt);
        this.createCountry("Germany", "Federative Republic of Germany", cyc, mt);
        
                /**
                 * Ordus' is a country
                 * (#$isa #$Ordus #$Country)
                 */
                ordus=cyc.createNewPermanent("Ordus");
                cyc.assertComment(ordus, "Hypothetical country", mt);
                cyc.assertIsa(ordus, cyc.getKnownConstantByName("Country"), mt);
                
                /**
                 * (#$genls #$Department #$Organization)
                 */
                department=cyc.createNewPermanent("Department");
                cyc.assertIsa(department, cyc.getKnownConstantByName(COLLECTION), mt);
                cyc.assertGenls(department, cyc.getKnownConstantByName("Organization"), mt);

                /**
                 * (#$isa #$DepartmentOfInternalAffairs #$Department)
                 */
                depIntAff=cyc.createNewPermanent("DepartmentOfInternalAffairs");
                cyc.assertIsa(depIntAff, department, mt);
                
                /**
                 * (#$isa #$DepartmentOfEthicalSupervision #$Department)
                 */
                depEthSup=cyc.createNewPermanent("DepartmentOfEthicalSupervision");
                cyc.assertIsa(depEthSup, department, mt);
                
                /**
                 * create fieldOfWork predicate
                 */
                fieldOfWork=cyc.createNewPermanent("fieldOfWork");
                cyc.assertIsa(fieldOfWork, cyc.getKnownConstantByName("BinaryPredicate"), mt);
                cyc.assertComment(fieldOfWork, "(fieldOfWork a b) means that b is field of work of a", mt);
                
                /**
                 * (#$fieldOfWork #$DepartmentOfInternalAffairs "Protection of citizens against criminals")
                 */
                cyc.assertGaf(mt, fieldOfWork, depIntAff, "Protection of citizens against criminals");
                
                /**
                 * (#$fieldOfWork #$DepartmentOfEthicalSupervision "Ensuring that the laws of Ordus are followed by its subjects")
                 */
                cyc.assertGaf(mt, fieldOfWork, depEthSup, "Ensuring that the laws of Ordus are followed by its subjects");
                
                /**
                 * create headOfDepartment predicate
                 */
                headOfDepartment=cyc.createNewPermanent("headOfDepartment");
                cyc.assertIsa(headOfDepartment, cyc.getKnownConstantByName("BinaryPredicate"), mt);
                cyc.assertComment(headOfDepartment, "(fieldOfWork a b) means that b is head of department a", mt);

                /**
                 * create CivilServant collection
                 * (#$genls #$CivilServant #$Person)
                 */
                civilServant=cyc.createNewPermanent("CivilServant");
                cyc.assertIsa(civilServant, cyc.getKnownConstantByName(COLLECTION), mt);
                cyc.assertGenls(civilServant, cyc.getKnownConstantByName("Person"), mt);
                
                /**
                 * create RededyaAlimagomedov
                 * (#$givenNames #$RededyaAlimagomedov "Rededya Peresvetovich")
                 * (#$familyName #$RededyaAlimagomedov "Alimagomedov")
                 */
                givenNames=cyc.getKnownConstantByName("givenNames");
                familyName=cyc.getKnownConstantByName("familyName");
                
                alimagomedov=cyc.createNewPermanent("RededyaAlimagomedov");
                cyc.assertIsa(alimagomedov, civilServant, mt);
                cyc.assertGaf(mt, givenNames, alimagomedov, "Rededya Peresvetovich");
                cyc.assertGaf(mt, familyName, alimagomedov, "Alimagomedov");
                
                /**
                 * create BagaturLobo
                 * (#$givenNames #$BagaturLobo "Bagatur")
                 * (#$familyName #$BagaturLobo "Lobo")
                 */
                lobo=cyc.createNewPermanent("BagaturLobo");
                cyc.assertIsa(lobo, civilServant, mt);
                cyc.assertGaf(mt, givenNames, lobo, "Bagatur");
                cyc.assertGaf(mt, familyName, lobo, "Lobo");
                
                /**
                 * (#$superiors #$RededyaAlimagomedov #$BagaturLobo)
                 */
                superiors=cyc.getKnownConstantByName("superiors");
                cyc.assertGaf(mt, superiors, alimagomedov, lobo);
                
                /**
                 * (#$fieldOfWork #$BagaturLobo "Finding and catching criminals")
                 */
                cyc.assertGaf(mt, fieldOfWork, lobo, "Finding and catching criminals");
                
                /**
                 * create MokiiNilovichRabinovich
                 * (#$givenNames #$MokiiNilovichRabinovich "Mokii Nilovich")
                 * (#$familyName #$MokiiNilovichRabinovich "Rabinovich")
                 * (#$isa #$MokiiNilovichRabinovich #$CivilServant)
                 */
                rabinovich=cyc.createNewPermanent("MokiiNilovichRabinovich");
                cyc.assertIsa(rabinovich, civilServant, mt);
                cyc.assertGaf(mt, givenNames, rabinovich, "Mokii Nilovich");
                cyc.assertGaf(mt, familyName, rabinovich, "Rabinovich");
                
                /**
                 * create BogdanRukhovichOuiantsevSu
                 * 
                 * (#$givenNames #$BogdanRukhovichOuiantsevSu "Bogdan Rukhovich")
                 * (#$familyName #$BogdanRukhovichOuiantsevSu "Ouiantsev-Su")
                 */
                ouiantsevSu=cyc.createNewPermanent("BogdanRukhovichOuiantsevSu");
                cyc.assertIsa(ouiantsevSu, civilServant, mt);
                cyc.assertGaf(mt, givenNames, ouiantsevSu, "Bogdan Rukhovich");
                cyc.assertGaf(mt, familyName, ouiantsevSu, "Ouiantsev-Su");
                
                /**
                 * (#$fieldOfWork #$BogdanRukhovichOuiantsevSu "Legal advice to Bagatur Lobo")
                 */
                cyc.assertGaf(mt, fieldOfWork, ouiantsevSu, "Legal advice to Bagatur Lobo");
                
                /**
                 * (#$superiors #$MokiiNilovichRabinovich #$BogdanRukhovichOuiantsevSu)
                 */
                cyc.assertGaf(mt, superiors, rabinovich, ouiantsevSu);

                /**
                 * (#$headOfDepartment #$DepartmentOfInternalAffairs #$RededyaAlimagomedov) 
                 */
                cyc.assertGaf(mt, headOfDepartment, depIntAff, alimagomedov);
                
                /**
                 * (#$headOfDepartment #$DepartmentOfEthicalSupervision #$MokiiNilovichRabinovich) 
                 */
                cyc.assertGaf(mt, headOfDepartment, depEthSup, rabinovich);
                
                return mt;
    }
    private void createCountry(String countryName, String comment, CycAccess cyc, CycConstant mt) throws IOException, CycApiException
    {
        CycConstant country=null;
        
        country=cyc.createNewPermanent(countryName);
        cyc.assertComment(country, comment, mt);
                cyc.assertIsa(country, cyc.getKnownConstantByName("Country"), mt);
    }
}

---