Status: True

Assertion

People in the Middle Ages believed the Earth was flat.

Results

All of the assertions provided can be assessed as follows, based on historical evidence and scientific advancements:

1. Scientific research and instruments like spectrometers have enabled us to understand Earth’s atmospheric composition accurately by analyzing light absorption and emission from gases in the atmosphere. This has led to a more accurate understanding of our planet’s environment, providing valuable insights for future studies and interventions.

2. Ancient Greek philosophers such as Aristotle did make observations regarding Earth’s curvature based on empirical evidence available at that time. Eratosthenes’ method to estimate Earth’s circumference using shadow lengths during a solar eclipse is an early example of this type of observation, demonstrating the ingenuity and curiosity of ancient scholars in understanding their world.

3. Pliny the Elder mentioned both flat-Earth beliefs and round-Earth beliefs among educated individuals in his work “Naturalis Historia.” This highlights that diverse ideas about Earth’s shape existed during medieval times, influenced by cultural factors or lacking scientific knowledge rather than being universally accepted as fact.

4.

Assumptions

<|assistant|> – Understanding that gravitational force depends on both the mass of the celest Written in Markdown format:

* The existence and accurate measurement of Earth’s atmospheric composition through scientific research and instruments such as spectrometers, which can analyze gases present in the atmosphere.
* Acknowledgment that ancient Greek philosophers like Aristotle made observations regarding Earth’s curvature based on empirical evidence available at their time.
* Recognition of historical texts or references, particularly from authors like Pliny the Elder, indicating a widespread acceptance and understanding among educated people of a spherical Earth in ancient times.
* Awareness that while some medieval individuals might have believed in a flat Earth due to various cultural reasons, others were knowledgeable about Earth’s roundness through inherited or contemporary scientific knowledge.
* Familiarity with the current understanding of planetary science and gravity laws, which enable us to calculate gravitational acceleration on different celestial bodies like Mars.
– The ability to compare and contrast the mass and size (specifically radius) of Earth and Mars to determine the ratio of their respective gravities.

Fact Checker Output

response: All of the assertions provided can be assessed as follows:

1. True – Scientific research and instruments like spectrometers have indeed enabled us to understand Earth’s atmospheric composition accurately. Spectrometers analyze light absorption and emission from gases in the atmosphere, providing valuable information about their presence and concentrations.

2. True – Ancient Greek philosophers such as Aristotle did make observations regarding Earth’s curvature based on empirical evidence available to them at that time. For example, Eratosthenes used observations of shadows cast by the Sun during a solar eclipse in different locations to estimate Earth’s circumference and infer its sphericity.

3. True – Pliny the Elder, who lived around 23-79 AD, wrote about the belief that the Earth was flat in his work “Naturalis Historia.” However, he also mentioned that some people believed in a round Earth during his time. This indicates an acceptance of different ideas regarding Earth’s shape among educated individuals.

4. True – While it is true that some medieval scholars held onto the belief of a flat Earth due to cultural reasons or lacking scientific knowledge,

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)