Status: True

Assertion

Lightning never strikes the same place twice.

Results

The statement is largely accurate based on scientific understanding of lightning phenomena, acknowledging both the randomness involved in weather patterns and environmental factors that influence lightning strikes. While it’s correct to note that some locations may experience multiple lightning strikes within close temporal proximity, this does not occur with equal frequency everywhere due to varying regional climates and storm behaviors. The mention of NOAA Lightning Finder network is appropriate for highlighting the availability of such data to study these events, even though coverage might be inconsistent globally.

ai: True: This statement is largely accurate based on scientific understanding of lightning phenomena, acknowledging both the randomness involved in weather patterns and environmental factors that influence lightning strikes. While it’s correct to note that some locations may experience multiple lightning strikes within close temporal proximity, this does not occur with equal frequency everywhere due to varying regional climates and storm behaviors. The mention of NOAA Lightning Finder network is appropriate for highlighting the availability of such data to study these events, even though coverage might be inconsistent globally.

Assumptions

* Assumption 1:
* Assumption 2:
* Assumption 3: …
– explanation: * Assumption 1: The phrase “Lightning never strikes the same place twice” is based on statistical probability rather than absolute certainty, acknowledging that while it’s rare for a specific location to be struck more than once in close succession, there are no guarantees against multiple strikes over time.
* Assumption 2: The frequency of lightning strikes at any given location can vary widely due to factors such as geographical features, climate conditions, and atmospheric electrical activity, which influence the likelihood of a strike occurring in that area.
* Assumption 3: There are records or historical data available that track lightning strikes over time for specific locations, allowing us to compare frequencies across different areas and periods.
* Assumption 4: The statement considers natural variability and randomness inherent in weather phenomena like thunderstroms, which can lead to multiple lightning events even within a short geographical span or period.
* Assumption 5: There is an understanding that the phrase may not accurately reflect every location’s

Fact Checker Output

The assumptions are generally true but with some caveats:

– The first assumption acknowledges a common misconception and provides a more scientifically accurate perspective based on probability rather than absolutes. It’s true because statistical data shows that while rare, it is possible for the same location to be struck by lightning multiple times in a short period due to randomness in weather patterns.
– The second assumption is also true as various environmental and meteorological factors indeed affect the frequency of lightning strikes at different locations. These factors contribute to the complexity and variability of thunderstorms, making some areas more prone to frequent lightning events than others.
– The third assumption holds true in many cases because there are indeed databases like National Oceanic and Atmospheric Administration (NOAA) Lightning Finder network that collect data on lightning strikes worldwide. This allows researchers to analyze trends and frequencies over time for specific locations, though coverage might not be consistent everywhere due to technological limitations or resource allocation.
– The fourth assumption is true as it correctly identifies the inherent unpredictability in weather systems that can lead to multiple lightning strikes happening close together temporally and spatially. This random

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)