Status: Debatable

Assertion

Nuclear energy is the safest form of energy.

Results

<|assistant|> While nuclear energy has advanced in terms of safety technologies and regulations, it’s important to recognize that no energy source is completely without risk. The classification of ‘nuclear energy as the safest form of energy’ could be debated based on different criteria such as environmental impact, risk profile, or accident frequency relative to other energy sources like fossil fuels. However, considering safety improvements and strict regulations in place specifically for nuclear energy, it can be said that from a regulatory and technological standpoint, modern nuclear power plants are designed with strong emphasis on safety measures, which may make them among the safer options available compared to some others when assessed properly.

However, one must also consider potential catastrophic events (albeit extremely rare) as well as long-term issues like waste management and decommissioning. Therefore, while nuclear energy can be seen as having a strong safety record under controlled conditions with current technology, its classification as the safest form of energy is subjective and should take into account comprehensive risk assessment including all factors involved in energy production and usage.

Assumptions

The following are some key assumptions that would need to be considered in order for the statement “Nuclear energy is the safest form of energy” to be supported:

1. Advanced Safety Technologies and Infrastructure: Assumption that modern nuclear power plants incorporate state-of-the-art safety measures, redundant systems, and robust containment structures to prevent accidents and mitigate their impacts.
2. Strict Regulatory Frameworks: Assumption of strong oversight by regulatory bodies at national and international levels, ensuring consistent adherence to safety standards for nuclear facilities worldwide.
3. Skilled Personnel: The assumption that there is a well-trained workforce with expertise in handling nuclear technology, maintaining operational integrity, and responding effectively to emergencies or malfunctions.
4. Effective Emergency Preparedness and Response Plans: Assumption that appropriate contingency plans are in place for addressing potential accidents, including evacuation procedures, medical response strategies, and environmental remediation measures.
5. Minimal Proliferation Risks: Assumption that nuclear energy technology is used solely for peaceful purposes

Fact Checker Output

<|assistant|> 1. Advanced Safety Technologies and Infrastructure – True. Modern nuclear power plants are designed with multiple layers of safety systems such as passive cooling, containment structures capable of withstanding extreme conditions, and emergency shutdown mechanisms (SCRAM). These technologies have evolved significantly since the Chernobyl and Fukushima accidents, making them safer today.

2. Strict Regulatory Frameworks – True. Many countries around the world have strict regulations in place for nuclear power plants, such as the Nuclear Regulatory Commission (NRC) in the United States and the International Atomic Energy Agency (IAEA). These organizations set safety standards that are enforced through regular inspections and reviews, ensuring consistent adherence to safety protocols.

3. Skilled Personnel – True. Operating nuclear power plants requires highly trained staff with expertise in various disciplines including engineering, physics, chemistry, and safety operations. Nuclear workforces undergo extensive training, and the industry continues to improve education programs aimed at developing future talent. However, it is essential that human error does not compromise safety, which underscenas importance

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
}

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)

    # 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 = """In light of the above information, how would you classify the statement? (True / False) '{}'""".format(assertion)
    answer_template = """{facts}\n""" + answer_template
    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,
    }

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
    final_output = submission['final_output']
    
    # Determine the status based on the final output text
    status = "True" if "true" in final_output.lower() else "False" if "false" in final_output.lower() else "Debatable"
    
    # 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>{final_output}</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)