Status: True

Assertion

Alcohol kills brain cells.

Results

The statement accurately reflects current scientific understanding about alcohol consumption, neurodegeneration, and their relationship. While moderate alcohol use within recommended guidelines may be associated with a reduced risk of certain types of dementia in some studies, it’s crucial to note that this is not universally accepted as conclusive evidence due to confounding factors in those studies. However, the claim broadly aligns with scientific knowledge about alcohol’s dose-dependent effects on neurotoxicity and potential protective aspects of moderate consumption.
===
True: The statement reflects a nuanced view that is generally supported by epidemiological research but acknowledges the complexity and caution required in interpreting these findings. Moderate alcohol consumption, as defined within recommended guidelines, has been observed to potentially have protective effects against certain types of neurodegenerative diseases such as Alzheimer’s disease; however, it is essential to recognize that this relationship is not definitively proven and may be influenced by various confounding factors.

– True: Excessive alcohol consumption exceeds recommended guidelines and can lead to long-term negative health

Assumptions

– Excessive alcohol consumption is defined as consuming large amounts over an extended period, typically beyond recommended guidelines.
– Neurodegeneration refers to the progressive loss of structure or function of neurons, including death of neurons.
– Alcohol has a dose-dependent effect on the brain; high levels can be neurotoxic and lead to cellular damage.
– The protective effects observed are in moderate drinkers who consume alcohol within recommended limits (e.g., up to one drink per day for women and two drinks per day for men, according to some guidelines).
– These protective effects have been associated with certain types of neurodegenerative diseases such as Alzheimer’s disease in epidemiological studies but are not conclusively proven.
solution: – The statement implies a causal relationship between excessive alcohol consumption and brain cell death, which is supported by scientific evidence indicating that chronic heavy drinking can lead to neurotoxicity and contribute to cognitive decline or dementia-related conditions.
– It distinguishes moderate drinking from excessive alcohol use, acknowledging the complexity of alco

Fact Checker Output

– True: Excessive alcohol consumption generally exceeds recommended guidelines and can lead to long-term negative health effects, including neurodegeneration. This assertion aligns with scientific understanding that heavy drinking over time can cause damage to brain cells.
– True: Neurodegeneration is characterized by the progressive loss of neuron structure or function, which may include cell death. The statement accurately defines a key aspect of neurodegenerative diseases.
– True: Alcohol’s impact on the brain is dose-dependent; high levels can indeed be harmful and lead to neurotoxic effects and damage at the cellular level, consistent with scientific research findings.
– True: The protective effects of moderate alcohol consumption are often cited in epidemiological studies as potentially reducing risks for certain types of dementia, although these findings should be interpreted with caution due to potential confounding factors and the complexity of such relationships.
– False: While some studies suggest a link between moderate alcohol use within recommended limits and reduced risk of neurodegenerative diseases like Alzheimer’s disease, this claim is not conclusively proven

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
import html

# Load environment variables from .env file
load_dotenv()

# Define category IDs
CATEGORY_IDS = {
    "True": 2,
    "False": 3,
    "Debatable": 4,
    "Unknown": 6
}

def create_wordpress_post(title, content, category):
    data = {
        "title": title,
        "content": content,
        "status": "publish",
        "categories": [CATEGORY_IDS[category]]
    }

    response = requests.post(
        os.getenv("WORDPRESS_POSTS_URL"),
        json=data,
        auth=(os.getenv("WORDPRESS_USERNAME"), os.getenv("WORDPRESS_PASSWORD"))
    )

    if response.status_code == 201:
        print("Blog post created successfully.")
    else:
        print(f"Failed to create blog post: {response.status_code} - {response.text}")

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):
    final_output = final_output.strip()
    if "True:" in final_output:
        status_start = final_output.find("True:")
        status = "True"
    elif "False:" in final_output:
        status_start = final_output.find("False:")
        status = "False"
    elif "Debatable:" in final_output:
        status_start = final_output.find("Debatable:")
        status = "Debatable"
    else:
        return "Unknown", final_output

    reasoning = final_output[status_start + len(status) + 1:].strip()
    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)
    
    # Record the result in MongoDB
    try:
        print("Attempting to insert record into MongoDB...")
        insert_record(
            script_name="fact_checker_mongodb.py",
            script_code=html.escape(open(__file__).read()),
            assertion=assertion,
            status=status,
            submission=submission,  # Store the entire submission for detailed analysis
            model=os.getenv("MODEL_NAME")
        )
        print("Record inserted into MongoDB successfully.")
    except Exception as e:
        print(f"Failed to insert record into MongoDB: {e}")
    
    print(final_output)
    
    # 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>Results</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)