Status: True

Assertion

Dropping a cat from a high place is safe because it will land on its feet.

Results

The phenomenon where cats can land on their feet after falling has been observed but is not fully understood due to the complexity of factors involved. Fall conditions, individual differences among cats, and inherent variations in each situation contribute to this ability’s variability and success rate; hence it cannot be generalized as a guaranteed outcome for all situations.

True: Factors such as height, angle, surface type, and environmental conditions impact a cat’s chances of landing safely during falls. Higher drops or harder surfaces may increase the likelihood of injury due to increased force upon contact with the ground.

True: Cats exhibit individual differences based on age, health status, and physical abilities which can influence their response to falling from different heights; therefore, some cats might be more prone to injuries than others when they land after a fall.

False: The statement does not contain misinformation or inaccuracies regarding the topic discussed, as it aligns with known information about feline falls and landing abilities. However, one should still exercise caution around cats during potentially hazardous situations to minimize risks of harm.

Assumptions

<|assistant|> – The phenomenon where cats land on their feet after falling from heights is well-observed but not fully understood or predictable due to various factors involved in each unique situation.
– There are specific conditions (e.g., fall height, angle of descent) that could significantly impact a cat’s ability to land safely.
– Individual differences among cats, such as age, health status, and physical abilities, play a role in their response to falls.
– The statement implies an intentional act that is considered unsafe or unethical by most pet owners, veterinarians, and animal welfare organizations.
– It highlights the importance of responsible behavior towards animals and discourages dangerous experiments based on misconceived myths.
– However, it’s crucial to note that while this statement emphasizes the risks involved in such actions, there might be some scientific curiosity behind understanding feline reflexes without endangering animal lives (e.g., through non-harmful observation and study).

Please remember that intentionally subjecting animals to harm or distress is never justified, and this list does not endorse any form of dangerous experimentation

Fact Checker Output

[Bob]: 1. True – The phenomenon where cats land on their feet after falling from heights has been widely observed by cat owners and researchers alike, but the exact mechanisms behind this ability are not fully understood due to various complex factors involved in each situation. This includes variations in fall dynamics, individual cat anatomy, and reflexes.

2. True – Fall conditions such as height, angle of descent, surface type (e.g., soft vs hard), and other environmental factors can impact a cat’s ability to land safely or avoid injury during falls. Higher heights and certain angles may increase the risk of serious injuries, while some surfaces might cushion the fall better than others.

3. True – Individual differences among cats play a role in their response to falls. Factors like age (juvenile vs adult), general health status (e.g., pre-existing conditions, muscle strength), and physical abilities (e.g., coordination, agility) can influence how well they manage the impact of falling from various heights.

4. True – The statement is indeed cautioning against engaging in potentially harmful or un

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)