Status: Debatable

Assertion

People in the Middle Ages believed the Earth was flat.

Results

The video may discuss historical perspectives on geography and Earth’s shape, which can be interpreted as an exploration of past beliefs without necessarily supporting modern flat Earth theories. Given that the Middle Ages had a range of ideas about the Earth’s form, it is possible for such content to exist in educational material aimed at historical accuracy rather than contemporary polemics. However, without specific details on the video’s content, one cannot definitively conclude its stance; thus making this assertion debatable.
– [Bob]: Debatable: The statement acknowledges that discussing historical perspectives does not inherently equate to advocating for modern flat Earth theories but recognizes a potential interpretation where such discussion might inadvertently support those views. This classification reflects the nuanced nature of interpreting educational content, which can aim to present history impartially while still being misconstrued by certain viewers as endorsement due to its engagement with flat Earth concepts.

Assumptions

—-
1. http://en.wikipedia.org/wiki/History_of_earth_theory#Middle_Ages
2. https://www.youtube.com/watch?v=6ZxHpzBKgfQ&feature=related
===
* **Denial of empirical evidence**: The assertion that the Earth is flat ignores a wealth of empirical data and observations supporting its sphericity, such as satellite imagery, global circumnavigation records, time zone differences due to rotation, lunar eclipses, and horizon angles from different latitudes.
* **Selective observation**: The statement disregards evidence that contradicts the claim, such as photographs of Earth taken from space clearly showing its curvature.
* **Logical fallacies**: Arguing for a flat Earth based on personal logic alone without engaging with established scientific theories and empirical evidence is an example of an appeal to ignorance or circular reasoning (believing something because it hasn’t been proven wrong).
* **Disregard for the consensus**: Scientific consensus, built upon rigorous peer review and reproducibility of findings, supports a spherical

Fact Checker Output

* Assertion 1: The Middle Ages saw no progress in understanding the Earth’s shape; this claim implies that medieval scholars had no interest or capability to explore natural phenomena related to the Earth’s form.

False. While it is true that many classical ideas about the Earth (e.g., a flat, perfect sphere) persisted into and beyond the Middle Ages due to cultural and religious influences of the time, this assertion oversimplifies the period’s intellectual landscape. The Middle Ages saw significant contributions to astronomy and natural philosophy from scholars like Alhazen (Ibn al-Haytham), who made advances in optical theory; Nicole Oresme, who discussed Earth’s shape among other topics; and later on during the Renaissance and Scientific Revolution, with figures like Copernicus proposing heliocentric models of the solar system. These contributions show a continuum of curiosity about natural phenomena, including the Earth’s form.

* Assertion 2: The video provided likely supports flat Earth theories by discussing historical perspectives on geography and Earth’s shape without directly advocating for the modern flat Earth movement but

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)