Status: True

Assertion

Cats always land on their feet.

Results

The statement is true because cats possess an innate sense of balance due to their vestibular apparatus, have the ability to contort their bodies in mid-air, react quickly during falls, and generally can land on their feet unless facing extreme circumstances or pre-existing health conditions.
However, it’s important to note that while most cats are able to utilize their natural abilities to land on their feet when falling from a certain height, very high falls could still result in injury or death regardless of these abilities. Also, individual differences among cats and the impact of pre-existing health conditions should be considered. Therefore, this statement can also be seen as debatable due to potential exceptions. Thus:
– True: Cats have various adaptations and reflexes that generally allow them to land on their feet when falling from a height within their natural capabilities; however, there may be exceptional cases or individual differences among cats which could lead to injury or death regardless of these abilities.

Assumptions

Assumptions supporting the statement “cats always land on their feet”:

1. Cats possess an innate sense of balance: The vestibular apparatus in cats’ ears helps them maintain orientation and coordination during falls, allowing for better mid-air adjustments.
2. Cat physiology allows for righting reflexes: Cats have the ability to twist their bodies while falling due to spinal flexibility and muscular control.
3. Adequate reaction time: When faced with a fall, cats react quickly enough to employ their body contortion abilities.
4. Fall heights within manageable range: The statement assumes that falls are typically not from extremely high places where landing safely is impossible.
5. No pre-existing injuries or health issues: A cat’s ability to land on its feet may be compromised if it has an injury, disability, or health condition affecting its balance or coordination.
6. Absence of external factors: Cats are assumed not to fall into objects, water bodies, or terrain that would prevent them from landing safely.
7. Natural instincts and behavior: The statement presumes that cats naturally attempt

Fact Checker Output

<|assistant|> 1. True – Cats possess an innate sense of balance due to their highly developed vestibular apparatus in the inner ear which plays a crucial role in maintaining equilibrium and spatial orientation during unexpected falls.
2. True – Cats have a unique spinal flexibility, combined with strong muscles that allow for quick contortions while falling, enabling them to twist their bodies into a position where they can land on their feet.
3. True – Studies suggest that cats react very quickly when in danger of falling; this rapid reaction time is essential for utilizing their righting reflex effectively.
4. Generally true – While there may be extreme cases, most falls experienced by cats (e.g., jumping from furniture) are within a range where the cat can still land on its feet due to their natural agility and body contortion capabilities. However, it’s important to note that very high falls could still result in injury or death regardless of these abilities.
5. True – Cats with pre-existing injuries, disabilities, or health conditions affecting balance, coordination, or muscle control may not always be able to land on their feet if

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)