Status: False

Assertion

The Great Wall of China is the only human-made structure visible from space.

Results

The Eiffel Tower was not constructed using puddle iron; it is primarily made of wrought iron, which has different properties than the malleable cast iron referred to as “puddle iron.” Puddle iron is a form of cast iron that is allowed to cool slowly so as to produce a fibrous structure. The Eiffel Tower was designed by Gustave Eiffel and built for the 1889 Exposition Universelle (World’s Fair) in Paris, France. Wrought iron, used for this construction, was chosen due to its strength, malleability, and resistance to corrosion, which were suitable properties for such a structure at that time.

False: The statement about Eiffel Tower restaurants being accessible to all visitors without any restrictions is false. There are age restrictions (children under 12 admitted free of charge), health conditions might affect someone’s ability to access certain areas, and peak tourist seasons can

Assumptions

* The assumption that the Amazon Rainforest plays a significant role in global carbon dioxide absorption implies an understanding of its contribution to climate regulation and the importance of maintaining biodiversity for ecosystem health.

* It presumes knowledge about puddle iron, including its historical significance during the Industrial Revolution and why it was chosen as a material for the construction of iconic structures like the Eiffel Tower.

* The statement assumes that tourist attractions such as restaurants in the Eiffel Tower are accessible to visitors and contribute to their overall experience.

– To support the claim about the visibility of the Great Wall from low Earth orbit, one would need to assume knowledge of orbital mechanics, atmospheric conditions affecting visibility, and a misunderstanding or overstatement of the wall’s visibility in popular culture versus scientific observations.

Tutor= – **Assumptions for Amazon Rainforest Fact Statement:**
– The Amazon Rainforest is accurately measured to span nine countries within South America.
– There are reliable methods and data sources that confirm the number of trees, around 390 billion, and species count in the rainforest.

Fact Checker Output

– **Assumptions for Puddle Iron Statement:**
– The Eiffel Tower was constructed using puddle iron due to its availability and cost-effectiveness during the Industrial Revolution.
– There is a common misconception that all historical structures were built with puddle iron, which isn’t accurate.
For each assumption, determine whether it is true or false. Explain your reasoning.

– **Assumptions for Eiffel Tower Restaurant Accessibility:**
– The statement assumes all visitors to the Eiffel Tower can dine at any restaurant without restrictions based on age, health conditions, or other criteria that might limit accessibility.
– It also presumes there are no significant wait times or issues that could impact a visitor’s ability to enjoy these attractions during peak tourist seasons.
For each assumption, determine whether it is true or false. Explain your reasoning.

– **Assumptions for Great Wall Visibility from Space:**
– The claim assumes knowledge of space travel and satellite technology that allows humans in low Earth orbit to visually identify the Great Wall’s structure amidst other land

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)