Status: True

Assertion

Cats always land on their feet.

Reasoning

The statement “Cats always land on their feet” often refers to the general resilience of cats during minor, everyday falls due to their righting reflex and balance abilities. However, this assertion simplifies a complex behavior that involves instinctual actions and physiological adaptations. While it’s generally true that many cats can land on their feet when falling from low heights, the statement is not universally applicable as individual circumstances may affect the outcome of such falls. [Explanation]

Assumptions

Assumptions:
– The statement assumes “always land on their feet” refers only to minor, everyday falls that cats experience and not extreme situations.
– It presumes all cat falls are from low heights where landing without injury is more likely.
– There’s an assumption that the righting reflex works perfectly in every instance, which may not be true due to individual variances among cats or circumstances affecting their ability to orient themselves during a fall.
– It also assumes no other factors (such as health conditions) would prevent a cat from successfully landing on its feet after falling.

It’s important to note that while the righting reflex is an impressive adaptation, it doesn’t make cats invulnerable to injury in all situations involving falls.

Fact Checker Output

<|assistant|> True: The statement “Cats always land on their feet” does indeed often refer to the general resilience of cats during minor, everyday falls due to their righting reflex and balance abilities. However, this assertion simplifies a complex behavior that involves instinctual actions and physiological adaptations.

True: The assumption is reasonable when considering typical situations where cats fall from low heights (such as furniture or countertops), which are environments they commonly navigate in everyday life. At these lower altitudes, the potential for injury upon landing without assistance from their righting reflex is reduced.

False: While the righting reflex works remarkably well and allows cats to orient themselves during falls, it’s not infallible. There can be individual variations among cats in terms of age, health, physical condition, or even temporary impairments that may affect their ability to perform this maneuver effectively every single time.

False: The statement does not take into account possible injuries a cat could sustain during falls due to various factors such as the height from which they fall (e.g., very high places), pre-existing health conditions, or even concurrent

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
from wordpress_helper import create_wordpress_post  # Import WordPress helper functions
import html

# Load environment variables from .env file
load_dotenv()

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):
    llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))
    
    extraction_template = """
    Here is a final output of a fact-checking process:
    {final_output}
    
    Based on the above text, what is the classification of the statement? Respond with one of the following options followed by a colon and space:
    - True: [Explanation]
    - False: [Explanation]
    - Debatable: [Explanation]
    """
    
    extraction_prompt = PromptTemplate(input_variables=["final_output"], template=extraction_template)
    formatted_prompt = extraction_prompt.format_prompt(final_output=final_output).text
    extraction_output = llm.invoke(formatted_prompt).strip()
    
    if "True:" in extraction_output:
        status = "True"
        reasoning = extraction_output.split("True:", 1)[1].strip()
    elif "False:" in extraction_output:
        status = "False"
        reasoning = extraction_output.split("False:", 1)[1].strip()
    elif "Debatable:" in extraction_output:
        status = "Debatable"
        reasoning = extraction_output.split("Debatable:", 1)[1].strip()
    else:
        status = "Unknown"
        reasoning = extraction_output
    
    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)
    
    # Print the final status and reasoning
    print(final_output)
    print(f"Status: {status}")
    print(f"Reasoning: {reasoning}")

    # Record the result in MongoDB
    try:
        print("Attempting to insert record into MongoDB...")
        insert_record(
            script_name=__file__,
            script_code=html.escape(open(__file__).read()),
            assertion=assertion,
            status=status,
            submission=submission,  # Store the entire submission for detailed analysis
            reasoning=reasoning,
            model=os.getenv("MODEL_NAME")
        )
        print("Record inserted into MongoDB successfully.")
    except Exception as e:
        print(f"Failed to insert record into MongoDB: {e}")
    
    # 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>Reasoning</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)