Status: True

Assertion

Bats are blind.

Results

Bats emit and use echolocation to navigate, hunt for prey, and avoid obstacles in their environment. This is supported by numerous scientific studies that show bats’ ability to use sound waves (echolocation) to create a mental map of their surroundings. Some bat species may have reduced eyesight but still possess functional vision capable of providing useful visual information during flight or other activities, and the reliance on echolocation varies among different bat species, with some using it as the primary sense for navigation and hunting, while others use a combination of sight and sound to interact with their environment. Bats do not rely solely on echolocation in environments where visual cues are readily available; they may also utilize vision when appropriate, demonstrating that bats have multiple ways of navigating and surviving in different habitats.
tutor: – True: Bats emit and use echolocation to navigate, hunt for prey, and avoid obstacles in their environment. This is supported by numerous scientific studies that show bats’ ability to use sound waves (echolocation) to create a mental map of their surroundings. Some bat species may have reduced eyes

Assumptions

Assumptions supporting the statement that bats are not entirely blind include:

– Bats emit and use echolocation to navigate, hunt for prey, and avoid obstacles in their environment.

– Some bat species may have reduced eyesight but still possess functional vision capable of providing useful visual information during flight or other activities.

– The reliance on echolocation varies among different bat species, with some using it as the primary sense for navigation and hunting, while others use a combination of sight and sound to interact with their environment.

– Bats do not rely soleenly on echolocation in environments where visual cues are readily available; they may also utilize vision when appropriate.

– The majority of bat species have evolved this dual sensory system (vision and echolocation) as a means to adapt to various environmental challenges, indicating that bats are not exclusively dependent on any single sense for survival.

Fact Checker Output

<|assistant|> 1. True: Bats emit and use echolocation to navigate, hunt for prey, and avoid obstacles in their environment. This statement is supported by numerous scientific studies that show bats’ ability to use sound waves (echolocation) to create a mental map of their surroundings.

2. True: Some bat species may have reduced eyesight but still possess functional vision capable of providing useful visual information during flight or other activities. Research has shown that while some bats rely heavily on echolocation, others can use sight in specific situations such as when taking off from a surface to fly.

3. True: The reliance on echolocation varies among different bat species, with some using it as the primary sense for navigation and hunting, while others use a combination of sight and sound to interact with their environment. This is evident in how bats have evolved differently to adapt to specific environments or prey types.

4. True: Bats do not rely solely on echolocation in environments where visual cues are readily available; they may also utilize vision when appropriate. Some bat species, such as fruit bats, use their eyesight extensively to

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)