Status: True

Assertion

People in the Middle Ages believed the Earth was flat.

Results

The common misconception arises from a simplified view of the historical context and scientific understanding of medieval people, without considering their actual knowledge and sources they had access to.

– True: Historical evidence indicates that educated individuals in the Middle Ages did understand Earth as spherical, based on the works of scholars like Ptolemy and Bacon who referenced such models.

– True: While medieval people may not have had modern scientific standards, their approach was still grounded in observation, critical thinking within their means, and knowledge from ancient texts.

– True: The flat Earth misconception has been perpetuated by conspiracy theories rather than a factual representation of the historical beliefs held during that time period.

– True: An accurate understanding requires avoiding oversimplifications and basing conclusions on well-researched evidence, considering various perspectives and sources available from the era.

– True: The supportive writings by notable medieval scholars showcase a level of scientific understanding among educated individuals during that time, although it’s essential to recognize diversity in beliefs across different societies within the period.

Assumptions

<|assistant|> – The common misconception that medieval people believed in a flat Earth is based on an oversimplification of their scientific understanding and historical context.

– Historical evidence from various sources indicates that educated individuals during the Middle Ages understood the concept of a spherical Earth, contrary to the popular belief.

– Medieval people’s access to contemporary scientific knowledge was limited compared to modern standards; however, this does not imply they held onto outdated beliefs without questioning or understanding them critically.

– The association between medieval thought and flat Earth is often linked to conspiracy theories or misinterpretations rather than an accurate reflection of historical reality.

– Critical analysis should be applied when studying past societies, avoiding oversimplifications and unfounded assertions about people’s beliefs.

– The understanding of a round Earth among educated medieval individuals is supported by writings from scholars such as Ptolemy, Roger Bacon, and Hildegard von Bingen, who referenced spherical models in their works.

– Recognizing the diversity within medieval societies helps avoid generalizations about beliefs held by all individuals during that time period. Not everyone would have

Fact Checker Output

output: – True. The common misconception arises from a simplified view of the historical context and scientific understanding of medieval people, without considering their actual knowledge and sources they had access to.

– True. Historical evidence indicates that educated individuals in the Middle Ages did understand Earth as spherical, based on the works of scholars like Ptolemy and Bacon who referenced such models.

– True. While medieval people may not have had modern scientific standards, their approach was still grounded in observation, critical thinking within their means, and knowledge from ancient texts.

– True. The flat Earth misconception has been perpetuated by conspiracy theories rather than a factual representation of the historical beliefs held during that time period.

– True. An accurate understanding requires avoiding oversimplifications and basing conclusions on well-researched evidence, considering various perspectives and sources available from the era.

– True. The supportive writings by notable medieval scholars showcase a level of scientific understanding among educated individuals during that time, although it’s essential to recognize diversity in beliefs across different societies within the period.

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)