Status: True

Assertion

The Earth revolves around the Sun.

Reasoning

All four parts of the given statement align with scientifically accepted knowledge. The Sun’s existence, Earth’s location within our solar system, gravitational forces between celestial objects like stars and planets, as well as Kepler’s Laws of Planetary Motion are all confirmed by extensive research and observations in the field of astronomy and physics:

5. Describe how each part of the statement supports its classification:
– The first part states that “The Sun exists,” which is a widely accepted truth, backed by numerous scientific studies and experimental evidence regarding solar existence and its influence on Earth’s motion.

– The second point explains that “Earth is located in our solar system around the Sun.” This has been repeatedly confirmed through astronomical measurements and observations of planetary orbits within our galaxy, as well as many other galaxies with similar structures.

– For the third part, it states that there are gravitational forces between massive objects like stars (the Sun) and smaller ones like planets (Earth). This is supported by Newton’s law of universal gravitation, which describes how every mass attracts every other mass around them with a force directly

Assumptions

<|assistant|> – The Sun exists and has an influence on objects in space, particularly Earth.
– Our planet, Earth, is located within the solar system that includes other planets and celestial bodies orbiting around the Sun.
– Gravitational forces exist between massive objects such as stars (the Sun) and smaller objects like planets (Earth).
– The laws of physics apply in space, particularly Kepler’s Laws of Planetary Motion which describe how planets move within a solar system.
– Earth’s orbital characteristics have been studied and verified through scientific observation and data collection, such as the revolution around the Sun causing day/night cycles and seasons.
– The concept of an orbiting celestial body can be accepted based on accumulated evidence from multiple sources in astronomy and physics disciplines.
– Time progresses linearly which allows for measurements to track Earth’s movement over different periods (e.g., a year).
– Observational technology, such as telescopes, has been developed to study celestial bodies and their movements accurately.

Fact Checker Output

explanation: 1. The Sun exists and has an influence on objects in space, particularly Earth. – True. The existence of the Sun is well-documented through observations and experiments over centuries. Its gravitational pull significantly impacts Earth’s motion, creating phenomena like tides and influencing climate patterns.

2. Our planet, Earth, is located within the solar system that includes other planets and celestial bodies orbiting around the Sun. – True. Earth is one of eight planets in our solar system, all revolving around the Sun due to its gravitational pull. This has been confirmed through countless astronomical observations and measurements.

3. Gravitational forces exist between massive objects such as stars (the Sun) and smaller objects like planets (Earth). – True. The law of universal gravitation, first described by Sir Isaac Newton in the 17th century, explains how every mass exerts an attractive force on all other masses around it. This is evidenced by Earth’s orbit around the Sun and the Moon’s orbit around Earth.

4. The laws of physics apply in space, particularly Kepler’s Laws of Planetary Mot

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
from wordpress_helper import create_wordpress_post  # Import WordPress helper functions
import html

# Load environment variables from .env file
load_dotenv()

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):
    llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))
    
    extraction_template = """
    Here is a final output of a fact-checking process:
    {final_output}
    
    Based on the above text, what is the classification of the statement? Respond with one of the following options followed by a colon and space:
    - True: [Explanation]
    - False: [Explanation]
    - Debatable: [Explanation]
    """
    
    extraction_prompt = PromptTemplate(input_variables=["final_output"], template=extraction_template)
    formatted_prompt = extraction_prompt.format_prompt(final_output=final_output).text
    extraction_output = llm.invoke(formatted_prompt).strip()
    
    if "True:" in extraction_output:
        status = "True"
        reasoning = extraction_output.split("True:", 1)[1].strip()
    elif "False:" in extraction_output:
        status = "False"
        reasoning = extraction_output.split("False:", 1)[1].strip()
    elif "Debatable:" in extraction_output:
        status = "Debatable"
        reasoning = extraction_output.split("Debatable:", 1)[1].strip()
    else:
        status = "Unknown"
        reasoning = extraction_output
    
    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)
    
    # Print the final status and reasoning
    print(final_output)
    print(f"Status: {status}")
    print(f"Reasoning: {reasoning}")

    # Record the result in MongoDB
    try:
        print("Attempting to insert record into MongoDB...")
        insert_record(
            script_name=__file__,
            script_code=html.escape(open(__file__).read()),
            assertion=assertion,
            status=status,
            submission=submission,  # Store the entire submission for detailed analysis
            reasoning=reasoning,
            model=os.getenv("MODEL_NAME")
        )
        print("Record inserted into MongoDB successfully.")
    except Exception as e:
        print(f"Failed to insert record into MongoDB: {e}")
    
    # 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>Reasoning</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)