Status: True

Assertion

Lightning never strikes the same place twice.

Results

The phrase “When it rains, it pours” reflects limited knowledge about meteorological phenomena in historical context due to the lack of scientific understanding at the time. It also highlights a skewed perception of rarity and an omission or misunderstanding regarding natural events like lightning strikes, which contributes to its continued use as an idiom. The simplification aspect is inherent to any phrase that distills complex occurrences into everyday language for ease of communication.
solution: True: The statement “When it rains, it pours” can be classified based on the following points:

– Limited Knowledge: This reflects a historical lack of scientific understanding about natural phenomena like multiple lightning strikes in one location due to the absence of modern meteorological knowledge.
– Skewed Perception of Rarity: The phrase captures the statistical rarity of such events while also highlighting an ongoing misunderstanding or underestimation by those who use it as a common saying.
– Omitted Information/Misunderstanding: This phrase likely evolved from misconceptions about natural occurrences, simplifying complex phenomena for general usage and understanding

Assumptions

To understand why this phrase persists, let’s break it down into its underlying assumptions based on historical beliefs:

– **Limited Knowledge**: In ancient times and before modern scientific understanding, natural phenomena like lightning were often attributed to supernatural causes rather than being explained by science.

2. **Skewed Perception of Rarity**: The actual probability of a single location experiencing multiple lightning strikes is rare but not negligible when considering long periods or large geographical areas. However, the perception that it’s an extraordinary event contributes to its persistence as an idiom.

3. Omitted Information/Misunderstanding: The phrase may have originated from a misunderstanding of lightning behavior and has been perpetuated through cultural transmission without correction or scientific clarification.

4. **Simplification**: It serves the purpose of simplifying complex natural phenomena into an easily-graspable, albeit incorrect, concept. This makes it more accessible to people with limited knowledge on the topic.

5. **Entertainment Value**: The phrase has been used in various forms of media and storytelling, which can

Fact Checker Output

<|assistant|> – **Limited Knowledge**: True. In ancient times and before the development of modern science, many natural phenomena such as lightning were indeed explained through superstition or attributed to the actions of gods, spirits, or other non-scientific causes due to a lack of scientific knowledge and understanding.

– **Skewed Perception of Rarity**: True but with clarification needed. While it’s true that experiencing multiple lightning strikes in one location is statistically rare, the perception that it’s an extraordinary event persists due to a lack of awareness about the actual probabilities involved. This can contribute to the phrase’s persistence as an idiom.

– **Omitted Information/Misunderstanding**: Likely True. The origin and perpetuation of this phrase suggest that it may have stemmed from misunderstandings or incomplete knowledge regarding lightning behavior, which has been passed down through generations without proper scientific explanation. However, specific historical evidence to confirm its origin is challenging due to the nature of idiomatic expressions.

– **Simplification**: True. The phrase does simplify a complex natural phenomenon like multiple

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)