Status: True

Assertion

The Pacific Ocean is the largest ocean on Earth.

Results

The definition of “largest” typically includes both surface area and volume, with a common emphasis on surface area when comparing oceans due to its direct impact on habitation and ecosystems (30% Earth’s total). This assumption is supported by general scientific consensus. Assumptions about the accuracy of measurements for the Pacific Ocean are generally based on peer-reviewed research and studies that have been conducted over time, which support a consensus within the scientific community regarding its size relative to other oceans. It is widely accepted in the scientific community that all major oceans have undergone measurement using various techniques (e.g., satellite altimetry) and methodologies, allowing for accurate comparison to confirm the Pacific Ocean’s status as the largest. The term “deepest” indeed refers to ocean depth, which is measured from sea level downward to the deepest point in an ocean. This assumption aligns with standard scientific terminology. Based on this information, I would classify the statement as True: The Pacific Ocean is not only Earth’s largest but also has been accurately measured and compared using a variety of techniques, while being known for both its surface area and depth (Mar

Assumptions

Here are the assumptions required to support the statement that the Pacific Ocean holds the title of the world’s largest and deepest ocean:

* The definition of “largest” includes both surface area and volume, with the majority of emphasis on surface area given in this context (30% of Earth’s total).
* Measurements provided for the Pacific Ocean are accurate and represent a consensus within the scientific community.
* Other oceans have been measured accurately, allowing for comparison to determine that the Pacific is indeed larger than them.
* The term “deepest” refers specifically to ocean depth (i.e., vertical distance from sea level), not horizontal length or width.
* The Mariana Trench has been correctly identified as the deepest part of Earth’s oceans, and its measurements are accurate.
* Other notable underwater features have been measured accurately for comparison purposes when considering ocean depth.
* Oceanographic data used to determine volume, including salinity and density factors, is reliable and validated by scientific consensus.
* The geography of the world’s oceans has not drastinasically changed over time, which could impact comparative measurements.
* Data

Fact Checker Output

<|assistant|> – True: The definition of “largest” typically includes both surface area and volume, with a common emphasis on surface area when comparing oceans due to its direct impact on habitation and ecosystems (30% Earth’s total). This assumption is supported by general scientific consensus.

– True: Assumptions about the accuracy of measurements for the Pacific Ocean are generally based on peer-reviewed research and studies that have been conducted over time, which support a consensus within the scientific community regarding its size relative to other oceans.

– True: It is widely accepted in the scientific community that all major oceans have undergone measurement using various techniques (e.g., satellite altimetry) and methodologies, allowing for accurate comparison to confirm the Pacific Ocean’s status as the largest.

– True: The term “deepest” indeed refers to ocean depth, which is measured from sea level downward to the deepest point in an ocean. This assumption aligns with standard scientific terminology.

– True: The Mariana Trench has been identified and measured using a combination of sonar mapping and direct measurements, leading to its recognition as Earth’s deepest

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)