Status: True

Assertion

The Earth’s inner core is roughly 2,400 kilometres in diameter.

Results

The inner core is predominantly composed of iron and nickel alloy, seismic waves behave differently when they encounter solid or liquid states within the Earth’s layers, extreme pressures at depth are sufficient to maintain a solid state for iron-nickel alloy in Earth’s interior, and the inner core has an approximate diameter of 2,400 kilometers. These assertions align with current scientific understanding based on geophysical research, elemental analysis, observations of seismic wave behavior, and estimations derived from various sources.
reply: – True: The inner core is predominantly composed of iron and nickel alloy, as supported by elemental analysis and the high-pressure conditions that maintain its solid state; seismic waves exhibit different behaviors when transitioning between states in Earth’s layers due to varying densities and elastic properties; extreme pressures at depth are indeed sufficient for the iron-nickel alloy within the inner core to remain solid, despite high temperatures. The diameter of approximately 2,400 kilometers is a scientifically accepted estimate based on seismic data interpretation.

Assumptions

<|assistant|> – The inner core is predominantly composed of iron and nickel alloy.
– Seismic waves behave differently when they encounter solid or liquid states within the Earth’s layers.
– Extreme pressures at depth are sufficient to maintain a solid state for iron-nickel alloy in Earth’s interior.
– The inner core has an approximate diameter of 2,400 kilometers.
– Heat transfer processes and magnetic field generation play significant roles in determining the habitability of Earth.
– There is a direct correlation between seismic wave propagation data, magnetic field measurements, and heat transfer mechanisms with the properties and dimensions of the inner core.
– Scientific research on geophysical phenomena relies on accurate knowledge of the Earth’s internal structure, including its size and composition.
– The understanding of these geophysical processes has a profound impact on our comprehension of Earth’inas habitability.
– There are established scientific methods to measure and study the dimensions and properties of the inner core.
– Numerous studies have corroborated the existence, size, and composition of Earth’s inner core through indirect evidence such as seismic wave

Fact Checker Output

<|assistant|> – True: The inner core is predominantly composed of iron and nickel alloy. This assertion is based on geophysical research and elemental analysis that suggest the presence of these elements in large quantities within Earth’s deep interior, where pressure conditions are high enough to keep them in a solid state.

– True: Seismic waves behave differently when they encounter solid or liquid states within the Earth’s layers. This is true as seismic waves can be refracted (bent), reflected, and slow down when passing through different materials with varying densities and elastic properties, like transitioning from solid to liquid in the outer core.

– True: Extreme pressures at depth are sufficient to maintain a solid state for iron-nickel alloy in Earth’s interior. The extreme pressure conditions found within the Earth’s inner core (estimated around 3 million times atmospheres) indeed help keep the iron and nickel alloy in a solid state despite high temperatures, which would typically favor melting under surface pressures.

– True: The inner core has an approximate diameter of 2,400 kilometers. This assertion is based on scientific estimates derived from

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)