application.conf

deepdive {

  db.default: {
    driver: "org.postgresql.Driver"
    url: "jdbc:postgresql://"${PGHOST}":"${PGPORT}/${DBNAME}
    user: ${PGUSER}
    password: ${DBPASSWORD}
    dbname:${DBNAME}
    port:${PGPORT}
    host:${PGHOST}
  }

  calibration: {
    holdout_fraction: 0.5
  }

  schema.variables:{

  	entity_formation.is_correct: Boolean
  	entity_taxon.is_correct: Boolean
  	entity_location.is_correct: Boolean
  	entity_temporal.is_correct: Boolean

    relation_taxonomy.is_correct: Boolean
    relation_formation.is_correct: Boolean
    relation_formationtemporal.is_correct: Boolean
    relation_formationlocation.is_correct: Boolean

    relation_taxonomy_global.is_correct: Boolean
    relation_formation_global.is_correct: Boolean
    relation_formationtemporal_global.is_correct: Boolean
    relation_formationlocation_global.is_correct: Boolean

  }

  extraction.extractors: { 
  #comments : {


    ext_entity_formation_local : {
  		output_relation : "entity_formation"
        input           : """
        				   SELECT docid as docid,
        						  sentid as sentid,
        						  wordidxs as wordidxs,
        						  words as words,
        						  poses as poses,
        						  ners as ners,
        						  lemmas as lemmas,
        						  dep_paths as dep_paths,
        						  dep_parents as dep_parents,
        						  bounding_boxes as bounding_boxes
        				   FROM sentences
        				  """
        udf             : ${PALEO_HOME}"/udf/ext_formation_local.py"
	parallelism     : 46
  	}

  	ext_entity_formation_global : {
  		output_relation : "entity_formation"
        input           : """
        				   WITH local_entity_names AS (
        				   	 SELECT docid, array_agg(entity) AS entities, array_agg(type) AS types 
        				   	 FROM entity_formation 
        				   	 GROUP BY docid
        				   )
        				   SELECT t0.docid as docid,
        						  array_agg((t0.sentid) ORDER BY t0.sentid::int) as sentids,
        						  array_stack_int((t0.wordidxs || 0) ORDER BY t0.sentid::int) as wordidxs,
        						  array_stack_text((t0.words) ORDER BY t0.sentid::int) as words,
        						  array_stack_text((t0.poses) ORDER BY t0.sentid::int) as poses,
        						  array_stack_text((t0.ners) ORDER BY t0.sentid::int) as ners,
        						  array_stack_text((t0.lemmas) ORDER BY t0.sentid::int) as lemmas,
        						  array_stack_text((t0.dep_paths) ORDER BY t0.sentid::int) as dep_paths,
        						  array_stack_int((t0.dep_parents) ORDER BY t0.sentid::int) as dep_parents,
        						  array_stack_text((t0.bounding_boxes) ORDER BY t0.sentid::int) as bounding_boxes,
        						  max(t1.entities) as local_entities,
        						  max(t1.types) as local_entity_types
        				   FROM sentences t0, local_entity_names t1
        				   WHERE t0.docid = t1.docid
        				   GROUP BY t0.docid
        				  """
        udf             : ${PALEO_HOME}"/udf/ext_formation_global.py"
        dependencies    : ["ext_entity_formation_local"]
        parallelism     : 46
  	}

  	ext_entity_temporal_local : {
  		output_relation : "entity_temporal"
        input           : """
        				   SELECT docid as docid,
        						  sentid as sentid,
        						  wordidxs as wordidxs,
        						  words as words,
        						  poses as poses,
        						  ners as ners,
        						  lemmas as lemmas,
        						  dep_paths as dep_paths,
        						  dep_parents as dep_parents,
        						  bounding_boxes as bounding_boxes
        				   FROM sentences
        				  """
        udf             : ${PALEO_HOME}"/udf/ext_temporal_local.py"
        parallelism     : 46
  	}

    ext_entity_taxon_local : {
  		output_relation : "entity_taxon"
        input           : """
        				   SELECT docid as docid,
        						  sentid as sentid,
        						  wordidxs as wordidxs,
        						  words as words,
        						  poses as poses,
        						  ners as ners,
        						  lemmas as lemmas,
        						  dep_paths as dep_paths,
        						  dep_parents as dep_parents,
        						  bounding_boxes as bounding_boxes
        				   FROM sentences
        				  """
        udf             : ${PALEO_HOME}"/udf/ext_taxon_local.py"
        parallelism     : 46
  	}

    ext_entity_taxon_global : {
  		output_relation : "entity_taxon"
        input           : """
        				   WITH local_entity_names AS (
        				   	 SELECT docid, array_agg(entity) AS entities, array_agg(type) AS types 
        				   	 FROM entity_taxon 
        				   	 GROUP BY docid
        				   )
        				   SELECT t0.docid as docid,
        						  array_agg((t0.sentid) ORDER BY t0.sentid::int) as sentids,
        						  array_stack_int((t0.wordidxs || 0) ORDER BY t0.sentid::int) as wordidxs,
        						  array_stack_text((t0.words) ORDER BY t0.sentid::int) as words,
        						  array_stack_text((t0.poses) ORDER BY t0.sentid::int) as poses,
        						  array_stack_text((t0.ners) ORDER BY t0.sentid::int) as ners,
        						  array_stack_text((t0.lemmas) ORDER BY t0.sentid::int) as lemmas,
        						  array_stack_text((t0.dep_paths) ORDER BY t0.sentid::int) as dep_paths,
        						  array_stack_int((t0.dep_parents) ORDER BY t0.sentid::int) as dep_parents,
        						  array_stack_text((t0.bounding_boxes) ORDER BY t0.sentid::int) as bounding_boxes,
        						  max(t1.entities) as local_entities,
        						  max(t1.types) as local_entity_types
        				   FROM sentences t0, local_entity_names t1
        				   WHERE t0.docid = t1.docid
        				   GROUP BY t0.docid
        				  """
        udf             : ${PALEO_HOME}"/udf/ext_taxon_global.py"
        dependencies    : ["ext_entity_taxon_local"]
        parallelism     : 46
  	}

   	ext_relation_same_sent : {
  		output_relation : "relation_candidates"
        input           : """
        				   WITH entities AS (
	        				   SELECT docid, 
	        				   		  array_agg(entity) as entities,
	        				   		  array_agg(type) as types, 
	        				   		  array_agg(eid) as eids, 
	        				   		  array_stack_text(array[array[prov[1],prov[2],prov[3],prov[4]]]) as provs 
	        				   FROM
	        				   	(
	        				   	 (SELECT docid, 'FORMATION' as type, eid, entity, prov FROM entity_formation)
	        				   	 UNION ALL
	        				   	 (SELECT docid, 'TAXON-' || type as type, eid, entity, prov FROM entity_taxon)
	        				   	 UNION ALL
	        				   	 (SELECT docid, 'INTERVAL' as type, eid, entity, prov FROM entity_temporal)
	        				   	 UNION ALL
	        				   	 (SELECT docid, 'LOCATION' as type, eid, entity, prov FROM entity_location)
	        				   	) nt
	        				   GROUP BY docid
        				   )
        				   SELECT t0.docid as docid,
        						  array_agg((t0.sentid) ORDER BY t0.sentid::int) as sentids,
        						  array_stack_int((t0.wordidxs || 0) ORDER BY t0.sentid::int) as wordidxs,
        						  array_stack_text((t0.words) ORDER BY t0.sentid::int) as words,
        						  array_stack_text((t0.poses) ORDER BY t0.sentid::int) as poses,
        						  array_stack_text((t0.ners) ORDER BY t0.sentid::int) as ners,
        						  array_stack_text((t0.lemmas) ORDER BY t0.sentid::int) as lemmas,
        						  array_stack_text((t0.dep_paths) ORDER BY t0.sentid::int) as dep_paths,
        						  array_stack_int((t0.dep_parents) ORDER BY t0.sentid::int) as dep_parents,
        						  array_stack_text((t0.bounding_boxes) ORDER BY t0.sentid::int) as bounding_boxes,
        						  max(t1.entities) as entities,
        						  max(t1.types) as entity_types,
        						  max(t1.eids) as entity_eids,
        						  max(t1.provs) as entity_provs
        				   FROM sentences t0, entities t1
        				   WHERE t0.docid = t1.docid
        				   GROUP BY t0.docid
        				  """
        #udf: util/extractor_input_writer.py /tmp/dd-sample-features.txt
	udf             : ${PALEO_HOME}"/udf/ext_relation_samesent.py"
        dependencies    : ["ext_entity_taxon_global","ext_entity_taxon_local","ext_entity_temporal_local","ext_entity_formation_global","ext_entity_formation_local"]
        parallelism     : 1
  	}


   	ext_relation_section_header : {
  		output_relation : "relation_candidates"
        input           : """
        				   WITH entities AS (
	        				   SELECT docid, 
	        				   		  array_agg(entity) as entities,
	        				   		  array_agg(type) as types, 
	        				   		  array_agg(eid) as eids, 
	        				   		  array_stack_text(array[array[prov[1],prov[2],prov[3],prov[4]]]) as provs 
	        				   FROM
	        				   	(
	        				   	 (SELECT docid, 'FORMATION' as type, eid, entity, prov FROM entity_formation)
	        				   	 UNION ALL
	        				   	 (SELECT docid, 'TAXON-' || type as type, eid, entity, prov FROM entity_taxon)
	        				   	 UNION ALL
	        				   	 (SELECT docid, 'INTERVAL' as type, eid, entity, prov FROM entity_temporal)
	        				   	 UNION ALL
	        				   	 (SELECT docid, 'LOCATION' as type, eid, entity, prov FROM entity_location)
	        				   	) nt
	        				   GROUP BY docid
        				   ), layouts AS (
        				   		SELECT docid, 
        				   			   array_agg(property) as properties, 
        				   			   array_stack_int(array[array[pageid,left_margin,top_margin,right_margin,bottom_margin]]) as boxes
        				   	    FROM layout_align 
        				   	    GROUP BY docid
        				   )
        				   SELECT t0.docid as docid,
        						  array_agg((t0.sentid) ORDER BY t0.sentid::int) as sentids,
        						  array_stack_int((t0.wordidxs || 0) ORDER BY t0.sentid::int) as wordidxs,
        						  array_stack_text((t0.words) ORDER BY t0.sentid::int) as words,
        						  array_stack_text((t0.poses) ORDER BY t0.sentid::int) as poses,
        						  array_stack_text((t0.ners) ORDER BY t0.sentid::int) as ners,
        						  array_stack_text((t0.lemmas) ORDER BY t0.sentid::int) as lemmas,
        						  array_stack_text((t0.dep_paths) ORDER BY t0.sentid::int) as dep_paths,
        						  array_stack_int((t0.dep_parents) ORDER BY t0.sentid::int) as dep_parents,
        						  array_stack_text((t0.bounding_boxes) ORDER BY t0.sentid::int) as bounding_boxes,
        						  max(t1.entities) as entities,
        						  max(t1.types) as entity_types,
        						  max(t1.eids) as entity_eids,
        						  max(t1.provs) as entity_provs,
        						  max(t2.properties) as layout_properties,
        						  max(t2.boxes) as layout_boxes
        				   FROM sentences t0, entities t1, layouts t2
        				   WHERE t0.docid = t1.docid AND t0.docid = t2.docid
        				   GROUP BY t0.docid
        				  """
        #udf              : "util/extractor_input_writer.py /tmp/bbbbbbb"
        udf             : ${PALEO_HOME}"/udf/ext_relation_sectionheader.py"
        dependencies    : ["ext_entity_taxon_global","ext_entity_taxon_local","ext_entity_temporal_local","ext_entity_formation_global","ext_entity_formation_local"]
        parallelism     : 46
  	}



    ext_relation_variable_formationtemporal :{
        output_relation : "relation_formationtemporal"
        input           : """
                            SELECT DISTINCT docid AS docid, 
                                            type AS type, 
                                            eid1 AS eid1, 
                                            eid2 AS eid2, 
                                            entity1 AS entity1, 
                                            entity2 AS entity2
                            FROM relation_candidates
                            WHERE type = 'FORMATIONINTERVAL'
                          """
        udf             : ${PALEO_HOME}"/udf/supervise_formationtemporal.py"
        dependencies    : ["ext_relation_same_sent", "ext_relation_section_header","ext_relation_from_table"]
        parallelism     : 46
    }

    ext_relation_variable_taxonomy :{
        output_relation : "relation_taxonomy"
        input           : """
                            SELECT DISTINCT docid AS docid, 
                                            type AS type, 
                                            eid1 AS eid1, 
                                            eid2 AS eid2, 
                                            entity1 AS entity1, 
                                            entity2 AS entity2
                            FROM relation_candidates
                            WHERE type = 'TAXONOMY' or type = 'TAXONOMY2'
                          """
        udf             : ${PALEO_HOME}"/udf/supervise_taxonomy.py"
        dependencies    : ["ext_relation_same_sent", "ext_relation_section_header","ext_relation_from_table"]
        parallelism     : 46
    }

    ext_relation_variable_formation :{
        output_relation : "relation_formation"
        input           : """
                            SELECT DISTINCT docid AS docid, 
                                            type AS type, 
                                            eid1 AS eid1, 
                                            eid2 AS eid2, 
                                            entity1 AS entity1, 
                                            entity2 AS entity2
                            FROM relation_candidates
                            WHERE type = 'FORMATION'
                          """
        udf             : ${PALEO_HOME}"/udf/supervise_formation.py"
        dependencies    : ["ext_relation_same_sent", "ext_relation_section_header,"ext_relation_from_table""]
        parallelism     : 46
    }

    ext_relation_variable_formation_false :{
    	style : "sql_extractor"
        sql           : """
        					INSERT INTO relation_formation(docid, type, eid1, eid2, entity1, entity2, is_correct)
                            SELECT DISTINCT docid,
                                            'FORMATION',
                                            eid1,
                                            eid2,
                                            entity1,
                                            entity2,
                                            false
                            FROM relation_candidates
                            WHERE type = 'FORMATIONINTERVAL' or type = 'FORMATIONLOCATION' LIMIT 1000000 
                          """
        dependencies    : ["ext_relation_same_sent", "ext_relation_section_header","ext_relation_variable_formationtemporal", "ext_relation_variable_taxonomy", "ext_relation_variable_formation","ext_relation_from_table"]
    }


   	ext_relation_from_table : {
  		output_relation : "relation_candidates"
        input           : """
        				   WITH entities AS (
	        				   SELECT docid, 
	        				   		  array_agg(entity) as entities,
	        				   		  array_agg(type) as types, 
	        				   		  array_agg(eid) as eids, 
	        				   		  array_stack_text(array[array[prov[1],prov[2],prov[3],prov[4]]]) as provs 
	        				   FROM
	        				   	(
	        				   	 (SELECT docid, 'FORMATION' as type, eid, entity, prov FROM entity_formation)
	        				   	 UNION ALL
	        				   	 (SELECT docid, 'TAXON-' || type as type, eid, entity, prov FROM entity_taxon)
	        				   	 UNION ALL
	        				   	 (SELECT docid, 'INTERVAL' as type, eid, entity, prov FROM entity_temporal)
	        				   	 UNION ALL
	        				   	 (SELECT docid, 'LOCATION' as type, eid, entity, prov FROM entity_location)
	        				   	) nt
	        				   GROUP BY docid
        				   ), table_structures AS (
        				   		SELECT docid, 
        				   			   array_agg(tableid) as table_ids, 
        				   			   array_agg(type) as line_types,
        				   			   array_agg(sentid) as line_sentids
        				   	    FROM ddtables 
        				   	    GROUP BY docid
        				   )
        				   SELECT t0.docid as docid,
        						  array_agg((t0.sentid) ORDER BY t0.sentid::int) as sentids,
        						  array_stack_int((t0.wordidxs || 0) ORDER BY t0.sentid::int) as wordidxs,
        						  array_stack_text((t0.words) ORDER BY t0.sentid::int) as words,
        						  array_stack_text((t0.poses) ORDER BY t0.sentid::int) as poses,
        						  array_stack_text((t0.ners) ORDER BY t0.sentid::int) as ners,
        						  array_stack_text((t0.lemmas) ORDER BY t0.sentid::int) as lemmas,
        						  array_stack_text((t0.dep_paths) ORDER BY t0.sentid::int) as dep_paths,
        						  array_stack_int((t0.dep_parents) ORDER BY t0.sentid::int) as dep_parents,
        						  array_stack_text((t0.bounding_boxes) ORDER BY t0.sentid::int) as bounding_boxes,
        						  max(t1.entities) as entities,
        						  max(t1.types) as entity_types,
        						  max(t1.eids) as entity_eids,
        						  max(t1.provs) as entity_provs,
        						  max(t2.table_ids) as table_ids,
        						  max(t2.line_types) as line_types,
        						  max(t2.line_sentids) as line_sentids
        				   FROM sentences t0, entities t1, table_structures t2
        				   WHERE t0.docid = t1.docid AND t0.docid = t2.docid
        				   GROUP BY t0.docid
        				  """
        #udf              : "util/extractor_input_writer.py /tmp/dddddddd"
        udf             : ${PALEO_HOME}"/udf/ext_relation_from_table.py"
        dependencies    : ["ext_entity_taxon_global","ext_entity_taxon_local","ext_entity_temporal_local","ext_entity_formation_global","ext_entity_formation_local"]
        parallelism     : 46
  	}

    global_temporal_containment:{
        output_relation : "interval_containments"
        input           : """
        					SELECT DISTINCT
        							t0.entity1 as formation,
        							t0.entity2 as interval1,
        							t1.entity2 as interval2
        					FROM    relation_formationtemporal t0,
        							relation_formationtemporal t1
        					WHERE	t0.entity1=t1.entity1 AND t0.entity2 <> t1.entity2
                          """
        udf             : ${PALEO_HOME}"/udf/interval_containment.py"
        parallelism     : 46
    }

    global_temporal_not_that_possible:{
        output_relation : "interval_not_that_possible"
        input           : """
        					SELECT DISTINCT
        							t0.entity1 as formation,
        							t0.entity2 as interval1,
        							t1.entity2 as interval2
        					FROM    relation_formationtemporal t0,
        							relation_formationtemporal t1
        					WHERE	t0.entity1=t1.entity1 AND t0.entity2 <> t1.entity2
                          """
        udf             : ${PALEO_HOME}"/udf/interval_not_that_possible.py"
        parallelism     : 46
    }

  	ext_global_variables : {
  		style : "sql_extractor"
  		sql   : """
  					INSERT INTO relation_taxonomy_global(docid, type, eid1, eid2, entity1, entity2, is_correct)
  					SELECT DISTINCT docid, type, eid1, eid2, entity1, entity2, NULL::boolean 
  					FROM   relation_taxonomy;

  					INSERT INTO relation_formation_global(docid, type, eid1, eid2, entity1, entity2, is_correct)
  					SELECT DISTINCT docid, type, eid1, eid2, entity1, entity2, NULL::boolean 
  					FROM   relation_formation;

  				  	INSERT INTO relation_formationtemporal_global(docid, type, eid1, eid2, entity1, entity2, is_correct)
  					SELECT DISTINCT docid, type, eid1, eid2, entity1, entity2, NULL::boolean 
  					FROM   relation_formationtemporal;

  				  	INSERT INTO relation_formationlocation_global(docid, type, eid1, eid2, entity1, entity2, is_correct)
  					SELECT DISTINCT docid, type, eid1, eid2, entity1, entity2, NULL::boolean 
  					FROM   relation_formationlocation;
  				""" 
  		dependencies : ["ext_relation_variable_formationtemporal","ext_relation_variable_taxonomy","ext_relation_variable_formation"]
  	}

  }

  #extraction.extractors: {



  #}




  comments : {

    ext_relation_variable_formationlocation :{
        output_relation : "relations_formationlocation"
        input           : """
                            SELECT DISTINCT docid AS "relation_candidates.docid", 
                                            type AS "relation_candidates.type", 
                                            eid1 AS "relation_candidates.eid1", 
                                            eid2 AS "relation_candidates.eid2", 
                                            entity1 AS "relation_candidates.entity1", 
                                            entity2 AS "relation_candidates.entity2"
                            FROM relation_candidates
                            WHERE type = 'FORMATIONLOCATION'
                          """
        udf             : ${PALEO_HOME}"/udf/supervise_relations.py"
        output_batch_size: 1000000
        parallelism     : 40
    }

  }

  inference.factors: {

    inference_rule_formationinterval : {
        input_query: """
	        	SELECT t0.features, 
	        		   t1.id as "relation_formationtemporal.id", 
	        		   t1.is_correct as "relation_formationtemporal.is_correct"
	        	FROM relation_candidates t0, relation_formationtemporal t1 
	        	WHERE t0.docid=t1.docid AND t0.eid1=t1.eid1 AND t0.eid2=t1.eid2
        	"""
        function: "Imply(relation_formationtemporal.is_correct)"
        weight: "?(features)"
    }

    inference_rule_taxonomy: {
        input_query: """
	        	SELECT t0.features, 
	        		   t1.id as "relation_taxonomy.id", 
	        		   t1.is_correct as "relation_taxonomy.is_correct"
	        	FROM relation_candidates t0, relation_taxonomy t1 
	        	WHERE t0.docid=t1.docid AND t0.eid1=t1.eid1 AND t0.eid2=t1.eid2
        	"""
        function: "Imply(relation_taxonomy.is_correct)"
        weight: "?(features)"
    }

    inference_rule_formationlocation : {
        input_query: """
	        	SELECT t0.features, 
	        		   t1.id as "relation_formationlocation.id", 
	        		   t1.is_correct as "relation_formationlocation.is_correct"
	        	FROM relation_candidates t0, relation_formationlocation t1 
	        	WHERE t0.docid=t1.docid AND t0.eid1=t1.eid1 AND t0.eid2=t1.eid2
        	"""
        function: "Imply(relation_formationlocation.is_correct)"
        weight: "?(features)"
    }

    inference_rule_formation : {
        input_query: """
	        	SELECT t0.features, 
	        		   t1.id as "relation_formation.id", 
	        		   t1.is_correct as "relation_formation.is_correct"
	        	FROM relation_candidates t0, relation_formation t1 
	        	WHERE t0.docid=t1.docid AND t0.eid1=t1.eid1 AND t0.eid2=t1.eid2
        	"""
        function: "Imply(relation_formation.is_correct)"
        weight: "?(features)"
    }


    inference_rule_formation_global : {
        input_query: """
        		SELECT  t0.id as "relation_formation.id", 
        				t1.id as "relation_formation_global.id",
        				t0.is_correct as "relation_formation.is_correct",
        				t1.is_correct as "relation_formation_global.is_correct",
        				t2.id as "entity_taxon.id",
        				t2.is_correct as "entity_taxon.is_correct",
        				t3.id as "entity_formation.id",
        				t3.is_correct as "entity_formation.is_correct"
        		FROM    relation_formation t0,
        				relation_formation_global t1,
        				entity_taxon t2,
        				entity_formation t3
        		WHERE   t0.docid=t1.docid AND t0.eid1=t1.eid1 AND t0.eid2=t1.eid2
        		    AND t0.eid1=t2.eid AND t0.eid2=t3.eid
        	"""
        function: "Imply(entity_taxon.is_correct, entity_formation.is_correct, relation_formation.is_correct, relation_formation_global.is_correct)"
        weight: "10"
    }

    inference_rule_formationtemporal_global : {
        input_query: """
        		SELECT  t0.id as "relation_formationtemporal.id", 
        				t1.id as "relation_formationtemporal_global.id",
        				t0.is_correct as "relation_formationtemporal.is_correct",
        				t1.is_correct as "relation_formationtemporal_global.is_correct",
        				t2.id as "entity_formation.id",
        				t2.is_correct as "entity_formation.is_correct",
        				t3.id as "entity_temporal.id",
        				t3.is_correct as "entity_temporal.is_correct"
        		FROM    relation_formationtemporal t0,
        				relation_formationtemporal_global t1,
        				entity_formation t2,
        				entity_temporal t3
        		WHERE   t0.docid=t1.docid AND t0.eid1=t1.eid1 AND t0.eid2=t1.eid2
        		    AND t0.eid1=t2.eid AND t0.eid2=t3.eid
        	"""
        function: "Imply(entity_formation.is_correct, entity_temporal.is_correct, relation_formationtemporal.is_correct, relation_formationtemporal_global.is_correct)"
        weight: "10"
    }

    inference_rule_formationlocation_global : {
        input_query: """
        		SELECT  t0.id as "relation_formationlocation.id", 
        				t1.id as "relation_formationlocation_global.id",
        				t0.is_correct as "relation_formationlocation.is_correct",
        				t1.is_correct as "relation_formationlocation_global.is_correct",
        				t2.id as "entity_formation.id",
        				t2.is_correct as "entity_formation.is_correct",
        				t3.id as "entity_location.id",
        				t3.is_correct as "entity_location.is_correct"
        		FROM    relation_formationlocation t0,
        				relation_formationlocation_global t1,
        				entity_formation t2,
        				entity_location t3
        		WHERE   t0.docid=t1.docid AND t0.eid1=t1.eid1 AND t0.eid2=t1.eid2
        		    AND t0.eid1=t2.eid AND t0.eid2=t3.eid
        	"""
        function: "Imply(entity_formation.is_correct, entity_location.is_correct, relation_formationlocation.is_correct, relation_formationlocation_global.is_correct)"
        weight: "10"
    }

    inference_rule_taxonomy_global : {
        input_query: """
        		SELECT  t0.id as "relation_taxonomy.id", 
        				t1.id as "relation_taxonomy_global.id",
        				t0.is_correct as "relation_taxonomy.is_correct",
        				t1.is_correct as "relation_taxonomy_global.is_correct",
        				t2.id as "entity_taxon1.id",
        				t2.is_correct as "entity_taxon1.is_correct",
        				t3.id as "entity_taxon2.id",
        				t3.is_correct as "entity_taxon2.is_correct"
        		FROM    relation_taxonomy t0,
        				relation_taxonomy_global t1,
        				entity_taxon t2,
        				entity_taxon t3
        		WHERE   t0.docid=t1.docid AND t0.eid1=t1.eid1 AND t0.eid2=t1.eid2
        		    AND t0.eid1=t2.eid AND t0.eid2=t3.eid
        	"""
        function: "Imply(entity_taxon1.is_correct, entity_taxon2.is_correct, relation_taxonomy.is_correct, relation_taxonomy_global.is_correct)"
        weight: "10"
    }

    inference_entity_formation : {
        input_query: """
        		SELECT  id as "entity_formation.id", 
        				is_correct as "entity_formation.is_correct"
        		FROM    entity_formation
        	"""
        function: "Imply(entity_formation.is_correct)"
        weight: "10"
    }

    inference_entity_taxon : {
        input_query: """
        		SELECT  id as "entity_taxon.id", 
        				is_correct as "entity_taxon.is_correct"
        		FROM    entity_taxon
        	"""
        function: "Imply(entity_taxon.is_correct)"
        weight: "10"
    }

    inference_entity_location : {
        input_query: """
        		SELECT  id as "entity_location.id", 
        				is_correct as "entity_location.is_correct"
        		FROM    entity_location
        	"""
        function: "Imply(entity_location.is_correct)"
        weight: "10"
    }

    inference_entity_temporal : {
        input_query: """
        		SELECT  id as "entity_temporal.id", 
        				is_correct as "entity_temporal.is_correct"
        		FROM    entity_temporal
        	"""
        function: "Imply(entity_temporal.is_correct)"
        weight: "10"
    }


    inference_rule_formationtemporal_global1 : {
        input_query: """
        		SELECT  t0.id as "global1.id", 
        				t1.id as "global2.id",
        				t0.is_correct as "global1.is_correct",
        				t1.is_correct as "global2.is_correct"
        		FROM    relation_formationtemporal_global t0,
        				relation_formationtemporal_global t1,
        				interval_containments t2
        		WHERE   t0.docid=t1.docid AND t0.entity1=t1.entity1 AND t0.entity1=t2.formation
        		    AND t0.entity2=t2.child AND t1.entity2=t2.parent
        	"""
        function: "Imply(global1.is_correct, !global2.is_correct)"
        weight: "10"
    }

    inference_rule_formationtemporal_global2 : {
        input_query: """
        		SELECT  t0.id as "global1.id", 
        				t1.id as "global2.id",
        				t0.is_correct as "global1.is_correct",
        				t1.is_correct as "global2.is_correct"
        		FROM    relation_formationtemporal_global t0,
        				relation_formationtemporal_global t1,
        				interval_not_that_possible t2
        		WHERE   t0.docid=t1.docid AND t0.entity1=t1.entity1 AND t0.entity1=t2.formation
        		    AND t0.entity2=t2.interval1 AND t1.entity2=t2.interval2
        	"""
        function: "AND(global1.is_correct, global2.is_correct)"
        weight: "-10"
    }

  }

  sampler.sampler_args: "-l 1000 -s 1 -i 1000 --alpha 0.1"

}