Status: True

Assertion

Alcohol kills brain cells.

Results

The statement is generally true but requires additional details to fully capture its complexity. Chronic heavy drinking, particularly when it involves prolonged duration and potentially excessive amounts of alcohol consumption (though specifics are needed), can have significant negative effects on the brain including potential cell death over time. However, factors such as age at initiation and overall health status also play critical roles in how an individual’s brain might be affected by chronic heavy drinking.

– False: [Explanation] This classification would not apply given that the statement is true based on current scientific understanding but requires additional context for a comprehensive understanding.

– Debatable: [Explanation] While there is evidence suggesting chronic heavy drinking can have negative effects, this might vary greatly depending on individual factors such as genetic predisposition to alcohol use disorders and other coexisting health conditions or lifestyle choices. Therefore, the statement could be considered debatable when these variables are taken into account.

Based on the above explanation, I would classify the statement as: True: The statement is generally true but requires additional details (specific amounts/patterns of consumption, age at initiation, overall health status

Assumptions

– Definition of “killing” cells: The phrase may imply immediate and direct cell death, which is not typically how chronic alcohol exposure affects the brain. A more accurate description might be neurodegeneration or damage over time.
– Amount of alcohol consumed: Chronic heavy drinking with high levels of alcohol consumption is implied but needs to be specified.
– Duration and pattern of alcohol use: The statement would need to specify the length of exposure to alcohol and whether it’s chronic or occasional.
– Age and overall health status: These factors can influence how an individual’s brain responds to alcohol consumption.
– Genetic predisposition: Some individuals may be more susceptible to the negative effects of alcohol on the brain due to their genetics.
– Neurological function assessment: The statement assumes that there are measurable changes in brain tissue or neurotransmitter function associated with heavy drinking, though this would need empirical evidence.
– Absence of other factors: Other lifestyle choices, environmental influences, and health conditions could also contribute to the observed effects on the brain, so these should

Fact Checker Output

<|assistant|> – Definition of “killing” cells: True (with clarification needed). The term “killing” cells can be misleading because chronic alcohol exposure typically leads to neurodegeneration rather than immediate cell death. However, prolonged and excessive alcohol consumption may eventually result in the death of some brain cells through mechanisms such as apoptosis or necrosis over time.

– Amount of alcohol consumed: True but needs specificity. The assertion is true; chronic heavy drinking can lead to negative consequences, including on the brain. However, specifying what constitutes “heavy” drinking (e.g., daily consumption of 6+ standard drinks) would make this point clearer.

– Duration and pattern of alcohol use: True but requires detail. The effects of chronic alcohol exposure on the brain are indeed influenced by both duration and patterns of consumption; however, providing specific details (e.g., long-term daily use versus binge drinking) would make this statement more accurate.

– Age and overall health status: True but context-dependent. The age at which alcohol is consumed and the general health status can influence

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)