Status: True

Assertion

Bats are blind.

Results

<|assistant|> True. The given assumptions provide valid reasons for variation in sensory systems among different bat species based on their visual capabilities and adaptations to specific feeding habits or environmental conditions. These variations are consistent with known scientific knowledge about bats, making the statement true.

Assumptions

– Assumption 1: Some bat species rely solely on echolocation for navigation, while others use both visual cues and echolocation.
– Assumption 2: The level of vision in bats varies across different species, with some having better eyesight than others depending on their feeding habits (e.g., fruit-eating bats).
– Assumption 3: Bats do not all use echolocation to navigate and hunt for food; the extent of reliance on this sensory system varies between species, with some having better vision than others.
– Assumption 4: The ability of a bat species to rely more heavily on either visual cues or echolocation is influenced by their specific feeding habits and environmental conditions in which they live.
– Assumption 5: Echolocation does not entirely replace the need for vision in bats; it serves as an additional navigational tool, rather than being a complete substitute for eyesight.
– Assumption 6: The statement is based on general knowledge about bat species and their behaviors, though there may be exceptions or variations within specific species.

These assumptions support the claim

Fact Checker Output

<|assistant|> True/False explanations for each assumption:

– Assumption 1: True. It is known that some bat species, like vampire bats (Desmodus rotundus), rely mainly on echolocation while others, such as fruit bats, use both visual cues and echolocation to navigate and find food sources. This assumption acknowledges the diversity in sensory adaptations among different bat species.

– Assumption 2: True. Vision capability varies across bat species due to their diverse feeding habits. For example, fruit bats (family Frugivora) have good eyesight as they rely on visual cues for identifying ripe fruits in dim light conditions, whereas insectivorous bats like the common noctule (Nyctalus noctula) may not require such advanced vision due to their echolocation-based hunting techniques.

– Assumption 3: True. The use of sensory systems can differ among bat species based on various factors, including habitat and feeding habits. For example, some bats that forage in open areas (such as the free-tailed bat) rely more heavily on

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
}

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)

    # 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:
    - True
    - False
    - Debatable
    """
    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(final_output):
    final_output = final_output.lower().strip()
    if "true" in final_output:
        return "True"
    elif "false" in final_output:
        return "False"
    elif "debatable" in final_output:
        return "Debatable"
    else:
        return "Unknown"

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
    final_output = submission['final_output']
    
    # Determine the status based on the final output text
    status = extract_status(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>{final_output}</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)