Status: True

Assertion

A coin dropped from a tall building can kill someone.

Results

The statement can be considered true based on the understanding that dropping objects from significant heights poses risks due to acceleration caused by gravity. However, it’s important to note that in practical scenarios, a coin is unlikely to cause serious injury simply through its fall, and factors such as surrounding environment and individual circumstances are crucial for assessing actual risk.

– True: In populated areas or places where people might be present at the ground level from which an object could fall, there’s indeed an increased concern for potential harm due to falling objects like coins. However, this doesn’t guarantee injury will occur in all cases—it merely suggests a heightened risk that warrants caution.

– True: While coins are unlikely to cause severe injuries upon impact given their material properties and general usage, the statement holds true when considering various scenarios where an object could fall from a considerable height or land on someone unexpectedly, potentially leading to injury. The primary focus here is acknowledging that while extremely rare, such incidents can happen under specific circumstances, making this classification reasonable based on the information provided.

Given these explanations, we classify the statement as follows: True: Dropping objects

Assumptions

### Assumptions Supporting the Statement:

– **Human Height and Environment**: The assumption that the building is tall enough (typically over 10 meters or about 32 feet) for a coin dropped from it to reach a speed capable of causing injury upon landing.
– **Populated Area**: Assuming there’s a dense population in close proximity to where the coin could land, increasing the likelihood of potential harm if someone is present below when the coin hits the ground.
– **Coin Material and Shape**: The assumption that the coin (usually made of metal) can retain its shape upon impact without shattering into small pieces, which might reduce but not eliminate the risk of injury depending on where it lands.
– **Lack of Protective Measures**: Assuming no safety measures are in place to prevent an accidental drop from occurring or mitigate its consequences (e.g., airbags, barriers).
– **Coin Weight and Size**: The assumption that the coin’s weight (typically around 10 grams for a US quarter) is sufficient to cause injury upon impact if it were to strike someone

Fact Checker Output

<|assistant|> – **Human Height and Environment**: True. Buildings over 10 meters tall can indeed allow objects dropped from them to reach speeds that could potentially cause injury upon impact with a person on the ground due to gravitational acceleration (approximately 9.8 m/s^2). This is because, without significant air resistance and assuming free fall for simplicity, an object’s speed increases linearly as it falls.

– **Populated Area**: True. The risk of injury from a falling coin indeed becomes more concerning in populated areas where there might be people present below the height from which the coin is dropped. However, whether someone gets injured depends on many factors including their location and alertness when the coin hits the ground.

– **Coin Material and Shape**: True. Coins are typically made of metal (e.g., copper, nickel, or a combination thereof in modern currency), which retains its shape upon impact under normal conditions due to its ductility. While it’s unlikely for a coin to cause severe injury just by falling from a height, the assumption is generally valid as other factors could contribute to potential harm (e.g., landing on someone or causing

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)