Status: True

Assertion

Bats are blind.

Results

Bats rely on echolocation primarily for navigation and locating prey, but they also use visual information during flight. This showcases their multifaceted approach to interacting with the environment. Additionally, animals’ ability to see is not exclusively dependent on daylight; many have evolved adaptations for low light or nocturnal conditions. Furthermore, bats are mammals with a highly developed sensory system designed specifically for their night-active lifestyle. Lastly, having the capability to see in low light does not equate to blindness but rather reflects an evolutionary adaptation suited to certain ecological niches, highlighting the variety of visual adaptations among species.
– True: While bats predominantly use echolocation for navigation and hunting, they also utilize their vision during flight. This illustrates how bats employ multiple sensory modalities in various situations. Moreover, many animals are not solely reliant on daylight to see; numerous adaptations exist that enable effective functioning under low light conditions. Bats belong to mammals with advanced sensory systems tailored for their nocturnal activities. Additionally, the

Assumptions

– Bats rely on echolocation for navigation and locating prey in low light conditions, which requires some level of visual acuity during flight.
– The ability to see is not solely dependent on daylight; many animals have adaptations that allow them to function effectively at night or under various environmental conditions.
– Bats are mammals with highly developed sensory systems, including vision, tailored to their nocturnal lifestyle and ecological niche.
===<|assistant|> – Echolocation is used for navigation rather than solely for finding food; bats also rely on visual cues during flight.
– Bats’ eyes are adapted for low light environments, which suggests they possess functional vision capabilities even in dim conditions.
– The statement implies that the ability to see at night does not equate to being blind, as many nocturnal animals have well-developed vision despite reduced overall lighting conditions.
– Bats’ reliance on echolocation is a common trait among species within their order (Chiroptera), and this does not inherently indicate poorer or non-existent eyesight compared to diurnal creatures of similar size and complexity.

Fact Checker Output

Response:

– True. Bats do rely on echolocation for navigation and locating prey; however, they also use visual information during flight to aid in their activities. This assertion recognizes the multifaceted approach bats take to interact with their environment.
– True. The ability to see is not exclusively dependent on daylight conditions. Many animals have evolved adaptations that enable them to function effectively under low light or nocturnal circumstances, such as improved night vision and heightened sensory perception.
– True. Bats are indeed mammals with highly developed sensory systems. Their vision has evolved specifically for their nocturnal lifestyle, which involves activities that occur after dark and requires adaptation to various environmental conditions.
– True. The capability of seeing in low light doesn’t imply blindness; it indicates an evolutionary adaptation to specific ecological niches. Many animals have developed efficient vision tailored to their active periods or specialized environments, emphasizing the diversity of visual adaptations across species.

It is important to note that while bats use echolocation extensively, particularly for hunting and navigation in darkness, they do possess functional

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)