Status: True

Assertion

The Earth’s largest mountain range, the mid-ocean ridge, is underwater.

Results

The reader being familiar with basic geological concepts is essential for understanding discussions on mid-ocean ridges because these topics involve specific terminology and complex processes that require a foundational knowledge of Earth sciences. This statement aligns with the given information, which emphasizes the importance of having prior knowledge in Earth sciences to comprehend the intricacies related to mid-ocean ridges.
<|assistant|> True: The extensive length of the Mid-Ocean Ridge is widely accepted among scientists due to abundant evidence, such as seismic data, ocean floor mapping, and geological studies corroborating its size and continuity across the world’s oceans. This statement reflects the information provided about how scientific research supports our understanding of mid-ocean ridges’ length and structure.
<|assistant|> True: The Mid-Ocean Ridge significantly influences Earth’s geography through tectonic activity and plate movement by driving processes like seafloor spreading, which affects the formation of continents and ocean basins over time. This statement is consistent with the information given on how mid-ocean ridges impact global geography via various geological mechanisms.
<|assistant|> True: Magma plays

Assumptions

* The reader is familiar with basic geological concepts and terminology (e.g., tectonic plates, seafloor spreading).
* The Mid-Ocean Ridge’s extensive length is widely accepted among scientists based on current research and evidence.
* The Mid-Ocean Ridge plays a significant role in shaping the Earth’s geography due to its influence on tectonic activity and plate movement.
* Magma from deep within the Earth contributes to the formation of new crust at divergent plate boundaries, creating the continuous mountain range characteristic of the Mid-Ocean Ridge.
* The reader understands that the underwater landscape can have significant impacts on both global geography and biodiversity due to its interconnectedness with various oceanic processes and marine life habitats.
===<|assistant|> * Scientific consensus supports the idea that submerged mountain ranges exist beneath the oceans, even if they are not visible from land.
* The Mid-Ocean Ridge is recognized as Earth’s most extensive underwater mountain range.
* Divergent plate boundaries and tectonic forces play a crucial role in shaping the ocean floor and creating features such as

Fact Checker Output

True: The reader being familiar with basic geological concepts is essential for understanding discussions on mid-ocean ridges because these topics involve specific terminology and complex processes that require a foundational knowledge of Earth sciences.

True: The extensive length of the Mid-Ocean Ridge is widely accepted among scientists due to abundant evidence, such as seismic data, ocean floor mapping, and geological studies corroborating its size and continuity across the world’s oceans.

True: The Mid-Ocean Ridge significantly influences Earth’s geography through tectonic activity and plate movement by driving processes like seafloor spreading, which affects the formation of continents and ocean basins over time.

True: Magma plays a crucial role in forming new crust along divergent plate boundaries at mid-ocean ridges due to upwelling mantle material that solidifies as it cools, contributing to the continuous growth of these underwater mountain ranges.

True: The reader’s understanding of how submerged landscapes impact global geography and biodiversity is essential because such features influence various oceanic processes (e.g., nutri

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)