Status: False

Assertion

Eating turkey makes you sleepy.

Results

The claim that turkey alone is responsible for causing sleepiness overlooks other contributing factors such as overall diet, physical activity levels, and metabolic rates. While tryptophan in turkey may contribute to relaxation and slight drowsiness after a meal due to its role in serotonin production, it does not solely cause sleepiness. The misconception is based on the exaggerated effects of consuming turkey as an isolated factor for inducing drowsiness.

– False: While turkey contains tryptophan which can contribute to relaxation and slight drowsiness after a meal, it does not directly cause sleepiness in isolation. The claim that turkey is the primary reason for sleepiness neglects other lifestyle choices such as diet and physical activity levels that play significant roles in influencing one’s level of drowsiness.

– False: This statement suggests a direct causality between consuming turkey (specifically its tryptophan content) and causing sleepiness, which oversimplifies the complex nature of factors contributing to drowsiness. Sleepiness is influenced by various elements including overall dietary int

Assumptions

Assumptions:

– The consumption of foods high in tryptophan leads directly to feelings of sleepiness or drowsiness.
– Turkey contains significantly more tryptophan than other protein sources, which contributes to its association with causing sleepiness.
– Sleepiness is primarily caused by the intake of turkey and not influenced by a combination of factors such as overall diet, physical activity levels, metabolic rates, etc.
– The effects on drowsiness occur immediately after consuming turkey or other foods high in tryptophan.
– There are no significant side effects from the consumption of these protein sources that could counteract potential sleepiness.
– Individual reactions to dietary components like tryptophan can vary widely, but generally result in a similar outcome across different people (i.e., feeling drowsy).
– The statement assumes causation rather than correlation between turkey consumption and feelings of sleepiness.

Remember, the above assumptions are based on the misconceptions that often surround this topic. In reality, while tryptophan might contribute to relaxation after a meal, its effects are modest compared to other factors

Fact Checker Output

<|assistant|> – True: The consumption of foods high in tryptophan leads directly to feelings of sleepiness or drowsiness. While the direct causation might be overstated, research indicates that tryptophan can contribute to relaxation and slight drowsiness after a meal due to its role as a precursor for serotonin production. However, it is not the sole factor responsible for such feelings.

– False: Turkey contains significantly more tryptophan than other protein sources, which contributes to its association with causing sleepiness. While turkey does have higher levels of tryptophan compared to many other foods, this is not a uniquely high amount when considering all protein sources. Additionally, the misconception arises from exaggerating its impact on inducing drowsiness.

– False: Sleepiness is primarily caused by the intake of turkey and not influenced by a combination of factors such as overall diet, physical activity levels, metabolic rates, etc. The assertion oversimplifies sleepiness’s multifactorial nature, ignoring various lifestyle choices that play significant roles in influencing one’s level of drowsiness.

– False

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)