Overview The NL2FOL class is the primary interface for translating natural language sentences into first-order logic (FOL) expressions. It orchestrates the entire translation pipeline, from claim extraction to logical formula generation.
Class Definition class NL2FOL : def __init__ ( self , sentence , model_type , pipeline , tokenizer , nli_model , nli_tokenizer , debug = False , direct = False )
Parameters The natural language sentence to convert to first-order logic
Type of language model to use. Supported values: 'llama' or 'gpt'
HuggingFace text generation pipeline (required for LLaMA models, None for GPT)
Tokenizer for the generation model (required for LLaMA models, None for GPT)
nli_model
transformers.PreTrainedModel
required
Natural Language Inference model for entity relationship detection
nli_tokenizer
transformers.Tokenizer
required
Tokenizer for the NLI model
Enable debug output to print intermediate results
Use direct FOL conversion (experimental)
Instance Attributes After initialization and conversion, the following attributes are populated:
Extracted claim from the input sentence
Extracted implication from the input sentence
Referring expressions identified in the claim
Referring expressions identified in the implication
List of tuples containing entities that are semantically equal
List of tuples where first entity is a subset of the second
Mapping from entity names to logical variables (a, b, c, …)
Properties extracted from the claim
Properties extracted from the implication
List of tuples representing property-level implications
Logical form of the claim
Logical form of the implication
Final first-order logic formula (claim → implication)
Alternative final formula with different quantifier handling
Methods convert_to_first_order_logic def convert_to_first_order_logic ()
Main method to execute the complete NL to FOL conversion pipeline.
Returns: tuple[str, str] - A tuple containing (final_lf, final_lf2)Pipeline Steps:
Extract claim and implication
Get referring expressions
Determine entity relations
Create entity mappings
Extract properties
Generate logical forms
Apply heuristics
Generate final formulas
from transformers import AutoModelForSequenceClassification, AutoTokenizer import transformers # Initialize models tokenizer = AutoTokenizer.from_pretrained( "meta-llama/Llama-2-7b-hf" ) pipeline = transformers.pipeline( "text-generation" , model = "meta-llama/Llama-2-7b-hf" , torch_dtype = torch.float16, device_map = "auto" ) nli_tokenizer = AutoTokenizer.from_pretrained( "microsoft/deberta-v3-base" ) nli_model = AutoModelForSequenceClassification.from_pretrained( "microsoft/deberta-v3-base" ) # Create NL2FOL instance sentence = "All cats are mammals, therefore my pet is a mammal." nl2fol = NL2FOL( sentence = sentence, model_type = 'llama' , pipeline = pipeline, tokenizer = tokenizer, nli_model = nli_model, nli_tokenizer = nli_tokenizer, debug = True ) # Convert to FOL final_lf, final_lf2 = nl2fol.convert_to_first_order_logic() print ( f "Formula 1: { final_lf } " ) print ( f "Formula 2: { final_lf2 } " )
extract_claim_and_implication def extract_claim_and_implication ()
Extracts the claim and implication components from the input sentence using an LLM.
Side Effects: Populates self.claim and self.implication attributesget_referring_expressions def get_referring_expressions ()
Identifies referring expressions (entities) in both claim and implication.
Side Effects: Populates self.claim_ref_exp and self.implication_ref_expget_entity_relations def get_entity_relations ()
Determines relationships between entities (equality, subset) across claim and implication.
Side Effects: Populates self.equal_entities and self.subset_entitiesget_entity_mapping Creates a mapping from entity strings to logical variables (a, b, c, …).
Side Effects: Populates self.entity_mappings dictionaryget_properties Extracts properties associated with the referring expressions.
Side Effects: Populates self.claim_properties and self.implication_propertiesget_properties_relations def get_properties_relations ()
Determines entailment relationships between properties using NLI.
Side Effects: Populates self.property_implicationscheck_entailment def check_entailment ( clause1 , clause2 )
Checks if clause1 entails clause2 using GPT-based prompting.
Parameters:
clause1 (str): First clauseclause2 (str): Second clause
Returns: bool - True if entailment exists, False otherwiseget_fol Generates first-order logic representations for claim and implication.
Side Effects: Populates self.claim_lf and self.implication_lfget_direct_fol Generates FOL directly from the sentence without intermediate steps (experimental).
apply_heuristics Applies post-processing heuristics to normalize logical operators:
Replaces -> with &
Normalizes & to and
Normalizes | to or
get_final_lf Generates the final logical formula with proper quantifiers based on entity relationships.
Side Effects: Populates self.final_lfget_final_lf2 Generates an alternative final formula with existential quantifiers for all symbols.
Side Effects: Populates self.final_lf2get_llm_result def get_llm_result ( prompt , model_type = None )
Internal method to get LLM responses based on configured model type.
Parameters:
prompt (str): Input prompt for the LLMmodel_type (str, optional): Override default model type
Returns: str - LLM response textget_nli_prob def get_nli_prob ( premise , hypothesis )
Calculates NLI entailment probability for a premise-hypothesis pair.
Parameters:
premise (str): Premise texthypothesis (str): Hypothesis text
Returns: float - Probability of entailment (0-100)get_nli_prob_list def get_nli_prob_list ( premise , hypothesis_list )
Calculates NLI probabilities for multiple hypotheses.
Parameters:
premise (str): Premise texthypothesis_list (list[str]): List of hypothesis texts
Returns: list[float] - List of entailment probabilitiesUtility Functions setup_dataset def setup_dataset ( fallacy_set = 'logic' , length = 100 )
Sets up evaluation datasets for fallacy detection.
Parameters:
fallacy_set (str): Dataset type - 'logic', 'logicclimate', 'nli', or 'folio'length (int): Number of samples to load
Returns: pandas.DataFrame - Dataset with articles and label columnsThe setup_dataset function is typically used in evaluation scripts to prepare test data for batch processing.
Example Usage GPT-4 Backend
Batch Processing
from nl_to_fol import NL2FOL from transformers import AutoModelForSequenceClassification, AutoTokenizer # Initialize NLI model nli_tokenizer = AutoTokenizer.from_pretrained( "microsoft/deberta-v3-base" ) nli_model = AutoModelForSequenceClassification.from_pretrained( "microsoft/deberta-v3-base" ) # Create NL2FOL instance with GPT sentence = "If all birds can fly, then penguins can fly." nl2fol = NL2FOL( sentence = sentence, model_type = 'gpt' , pipeline = None , tokenizer = None , nli_model = nli_model, nli_tokenizer = nli_tokenizer, debug = True ) # Convert and access results final_lf, final_lf2 = nl2fol.convert_to_first_order_logic() print ( "Claim:" , nl2fol.claim) print ( "Implication:" , nl2fol.implication) print ( "Entity Mappings:" , nl2fol.entity_mappings) print ( "Final Formula:" , final_lf)
See Also 