Status: Debatable

Assertion

Eating late at night makes you gain weight.

Reasoning

[Explanation] The impact of eating late at night on weight gain varies among individuals due to differences in metabolism, sleep quality, and energy expenditure. While some may experience negative effects from late-night eating, others might not be affected as significantly.

10. False/Uncertain – A balanced diet is important for overall health and can contribute to maintaining a healthy weight, but it does not guarantee immunity against obesity or other health issues due to the multifactorial nature of these conditions (e.g., genetic factors, physical activity levels, etc.).

11. Uncertain – While there may be some correlation between sleep quality and energy expenditure, making a direct causal relationship between them is uncertain as it could vary greatly among individuals based on other lifestyle factors and metabolism.

12. False/Uncertain – Avoiding late-night snacks might help prevent weight gain for some people who are sensitive to eating close to bedtime, but not everyone will experience the same effect due to varying individual circumstances such as their metabolism or lifestyle habits.

13. Un

Assumptions

1. Individual metabolic rates are uniform across different times of the day and do not significantly fluctuate, which might affect how late-night eating influences weight gain.
2. There is no significant difference in energy expenditure between consuming food early or late at night for most people.
3. Eating late at night leads to indigestion or discomfort that can disrupt sleep patterns across the population.
4. Disrupted sleep has a direct and consistent impact on weight gain for all individuals who eat late at night.
5. All calories consumed are stored equally throughout the day, regardless of when they were eaten, which might not be accurate due to factors like hormonal changes during fasting periods overnight.
6. There is a direct causal relationship between late-night eating and weight gain that applies universally across all individuals.

It’s important to note that individual lifestyle choices, metabolism, genetics, and overall dietary habits play significant roles in how one’s body responds to eating at different times of the day. While some people may experience weight gain from late-night eating due to these factors, others

Fact Checker Output

<|assistant|> 1. False – Individual metabolic rates can vary significantly across individuals and even within an individual over different times of the day (circadian rhythms). This variation might influence how late-night eating affects weight gain for some people, but not uniformly for all.

2. Uncertain – While there may be minimal differences in energy expenditure between consuming food at different times for some individuals, it’s uncertain and varies greatly among the population due to factors such as metabolism, activity levels, and lifestyle choices.

3. False/Uncertain – Indigestion or discomfort from eating late may affect sleep quality for some people; however, not everyone experiences these symptoms, making this assertion uncertain on a universal level.

4. Uncertain – Disrupted sleep can influence weight gain due to hormonal changes and alterations in appetite regulation, but the extent of its impact varies among individuals based on their metabolism and lifestyle factors.

5. False/Uncertain – Caloric storage throughout the day might not be equal for everyone because it is influenced by various factors such as hormone levels, physical activity,

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)