Status: True

Assertion

Houseflies live for only 24 hours.

Results

The statement aligns with known biological facts about houseflies, assuming ideal conditions have been carefully controlled or monitored to ensure the entire lifecycle fits within one day. However, it should be noted that while optimal conditions can allow for this in a scientific study setting, real-world scenarios may present variable factors impacting these durations.

Here is how we classify each part of the statement:

– Optimal conditions are defined and provide an environment that allows houseflies to reach their full lifespan of approximately 24 hours. (True): This aligns with scientific understanding, assuming optimal conditions have been set in a controlled environment for experimental purposes. However, it is important to note that real-world factors may impact the lifespan outside these controlled settings.

– The duration of each stage (egg, larva, pupa, adult) collectively fits within a single day under optimal conditions. (True): This statement corresponds with known biological data on housefly development stages, assuming ideal conditions are maintained to facilitate this lifecycle. In practical situations, environmental variables could cause variations in the duration of these stages.

– Factors such as temperature, humidity, food

Assumptions

<|assistant|> – Optimal conditions are defined and provide an environment that allows houseflies to reach their full lifespan of approximately 24 hours.
– The duration of each stage (egg, larva, pupa, adult) collectively fits within a single day under optimal conditions.
– Factors such as temperature, humidity, food availability, and exposure to predators or pesticides are considered negligible or controlled in the given scenario.
– The statement refers specifically to houseflies (Musca domestica) and does not generalize across all insect species.
– Variations in lifespan due to genetic factors among individual flies are assumed to be minimal, ensuring a relatively uniform life span for the population under consideration.
– Lifecycle stages of houseflies are accurate and include egg, larva (maggot), pupa, and adult fly, which have been studied and observed by entomologists.
– The statement assumes that there is no significant impact from human activity or intervention on the natural lifespan of houseflies in their environment.
– The information provided comes from scientific research or credible sources, ensuring its accuracy and validity for supporting

Fact Checker Output

<|assistant|> – Optimal conditions are defined and provide an environment that allows houseflies to reach their full lifespan of approximately 24 hours. (True)
Reasoning: The statement implies that optimal environmental conditions have been established for the purpose of this discussion, which is consistent with scientific understanding that certain species can thrive under well-defined controlled conditions. However, it’s important to note in real scenarios, reaching full lifespan may be influenced by many uncontrollable factors.

– The duration of each stage (egg, larva, pupa, adult) collectively fits within a single day under optimal conditions. (True)
Reasoning: This aligns with the known biology and developmental timelines for houseflies, which is well documented in entomological studies. However, these durations can slightly vary based on environmental factors.

– Factors such as temperature, humidity, food availability, and exposure to predators or pesticides are considered negligible or controlled in the given scenario. (True)
Reasoning: The assertion seems to focus specifically on ideal conditions where these variables are kept constant or minimized so that they do not affect the lif

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)