Status: True

Assertion

Eating spicy food can cause ulcers.

Reasoning

The statement is accurate in reflecting scientific consensus about spicy food’s potential effects on ulcer formation and the role of a balanced diet, though it also acknowledges individual variance in response to spicy food among those with preexisting conditions. This nuanced understanding makes the statement largely true but leaves room for debate based on personal experiences.
Revised classification: True: While generally accurate according to scientific knowledge and widely accepted views, the statement includes a degree of subjectivity due to individual variances in response to spicy food among those with existing gastrointestinal issues or sensitivities, making it also debatable. However, since the majority view aligns with its core assertion about ulcers and balanced diets, the classification leans towards True but is not without acknowledgment of debate.
Corrected classification: True: The statement accurately represents current scientific understanding that spicy food does not directly cause ulcers in most individuals but may exacerbate symptoms for those with preexisting conditions; it also emphasizes the role of a balanced diet, which is widely supported as beneficial for managing ulcers. This dual accuracy positions the statement

Assumptions

<|assistant|> – The assumption that eating spicy food does not directly cause ulcers: It is based on scientific evidence indicating that H. pylori and NSAIDs are the primary causes of peptic ulcers, while no direct causal link has been established between spicy food consumption and ulcer formation.
– The assumption about the effects of spicy food on individuals with existing ulcers or digestive irritation: This is based on anecdotal evidence and some studies suggesting that spicy food may aggravate symptoms in these cases by increasing stomach acid production, although more research is needed.
– The assumption about the importance of a balanced diet for ulcer prevention or management: It’s widely accepted among healthcare professionals that maintaining a balanced diet can help support overall digestive health and potentially reduce discomfort associated with existing ulcers, though specific dietary guidelines may vary depending on the individual’s circumstances.
– The assumption about consulting healthcare professionals: It’s assumed that individuals should seek personalized advice from a medical professional regarding their specific condition and concerns related to spicy food consumption or any other dietary factors, as

Fact Checker Output

== answer ==
– The assertion that eating spicy food does not directly cause ulcers: True. Scientific evidence primarily points towards Helicobacter pylori (H. pylori) bacteria and nonsteroidal anti-inflammatinas (NSAIDs) as the main causes of peptic ulcers, with no direct link established between spicy food consumption and ulcer formation. However, it’s essential to note that while spicy food is not a direct cause, some individuals might experience discomfort due to increased acid production or irritation in their digestive system when consuming such food.

– The assumption about the effects of spicy food on individuals with existing ulcers or digestive irritation: Partially true. While anecdotal evidence and some studies suggest that spicy food may exacerbate discomfort in people with preexisting ulcers or digestive issues, it’s not universally experienced by all such individuals. The response to spicy food can vary greatly from person to person based on their unique physiology and condition severity.

– The assumption about the importance of a balanced diet for ulcer

Model Used

microsoft/Phi-3-mini-4k-instruct-gguf

Script Name

fact_checker_mongodb.py

Script Code

import os
import sys
import requests
from langchain_openai.llms import OpenAI
from langchain.prompts import PromptTemplate
from dotenv import load_dotenv
from statements import get_random_statement
from mongodb_helper import insert_record  # Import MongoDB helper functions
from wordpress_helper import create_wordpress_post  # Import WordPress helper functions
import html

# Load environment variables from .env file
load_dotenv()

def fact_check(assertion):
    llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))

    # Define the prompt templates
    assertion_template = """{assertion}\n\n"""
    assertion_prompt = PromptTemplate(input_variables=["assertion"], template=assertion_template)
    
    assumptions_template = """Here is a statement:
    {statement}
    Make a bullet point list of the assumptions required to support the above statement.\n\n"""
    assumptions_prompt = PromptTemplate(input_variables=["statement"], template=assumptions_template)
    
    fact_checker_template = """Here is a bullet point list of assertions:
    {assertions}
    For each assumption, determine whether it is true or false. Explain your reasoning.\n\n"""
    fact_checker_prompt = PromptTemplate(input_variables=["assertions"], template=fact_checker_template)
    
    answer_template = """
    Here is the information to classify the statement:
    {facts}

    Based on the above information, how would you classify the statement? Respond with one of the following options followed by a colon and space:
    - True: [Explanation]
    - False: [Explanation]
    - Debatable: [Explanation]
    """
    answer_prompt = PromptTemplate(input_variables=["facts"], template=answer_template)
    
    # Format prompts and extract the string content
    formatted_assertion = assertion_prompt.format_prompt(assertion=assertion).text
    assertion_output = llm.invoke(formatted_assertion)
    
    formatted_assumptions = assumptions_prompt.format_prompt(statement=assertion_output).text
    assumptions_output = llm.invoke(formatted_assumptions)
    
    formatted_fact_checker = fact_checker_prompt.format_prompt(assertions=assumptions_output).text
    fact_checker_output = llm.invoke(formatted_fact_checker)
    
    formatted_answer = answer_prompt.format_prompt(facts=fact_checker_output).text
    final_output = llm.invoke(formatted_answer)
    
    return {
        "assertion_output": assertion_output,
        "assumptions_output": assumptions_output,
        "fact_checker_output": fact_checker_output,
        "final_output": final_output,
    }

def extract_status_and_reasoning(final_output):
    llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))
    
    extraction_template = """
    Here is a final output of a fact-checking process:
    {final_output}
    
    Based on the above text, what is the classification of the statement? Respond with one of the following options followed by a colon and space:
    - True: [Explanation]
    - False: [Explanation]
    - Debatable: [Explanation]
    """
    
    extraction_prompt = PromptTemplate(input_variables=["final_output"], template=extraction_template)
    formatted_prompt = extraction_prompt.format_prompt(final_output=final_output).text
    extraction_output = llm.invoke(formatted_prompt).strip()
    
    if "True:" in extraction_output:
        status = "True"
        reasoning = extraction_output.split("True:", 1)[1].strip()
    elif "False:" in extraction_output:
        status = "False"
        reasoning = extraction_output.split("False:", 1)[1].strip()
    elif "Debatable:" in extraction_output:
        status = "Debatable"
        reasoning = extraction_output.split("Debatable:", 1)[1].strip()
    else:
        status = "Unknown"
        reasoning = extraction_output
    
    return status, reasoning

if __name__ == "__main__":
    if len(sys.argv) > 1:
        assertion = sys.argv[1]
    else:
        assertion = get_random_statement()
    
    print(assertion)
    submission = fact_check(assertion)
    
    # Print the detailed outputs to inspect their structure
    for key, value in submission.items():
        print(f"{key}: {value}")
    
    # Extract the final output for status determination and reasoning
    final_output = submission['final_output']
    status, reasoning = extract_status_and_reasoning(final_output)
    
    # Print the final status and reasoning
    print(final_output)
    print(f"Status: {status}")
    print(f"Reasoning: {reasoning}")

    # Record the result in MongoDB
    try:
        print("Attempting to insert record into MongoDB...")
        insert_record(
            script_name=__file__,
            script_code=html.escape(open(__file__).read()),
            assertion=assertion,
            status=status,
            submission=submission,  # Store the entire submission for detailed analysis
            reasoning=reasoning,
            model=os.getenv("MODEL_NAME")
        )
        print("Record inserted into MongoDB successfully.")
    except Exception as e:
        print(f"Failed to insert record into MongoDB: {e}")
    
    # Create a blog post on WordPress
    blog_title = f"Fact Check: {assertion}"
    blog_content = f"""
    <h1>Status: {status}</h1>
    <h2>Assertion</h2>
    <p>{assertion}</p>
    <h2>Reasoning</h2>
    <p>{reasoning}</p>
    <h3>Assumptions</h3>
    <p>{submission['assumptions_output']}</p>
    <h3>Fact Checker Output</h3>
    <p>{submission['fact_checker_output']}</p>
    <h4>Model Used</h4>
    <p>{os.getenv("MODEL_NAME")}</p>
    <h4>Script Name</h4>
    <p>fact_checker_mongodb.py</p>
    <h4>Script Code</h4>
    <pre>{html.escape(open(__file__).read())}</pre>
    """
    create_wordpress_post(blog_title, blog_content, status)