Status: True

Assertion

The Earth revolves around the Sun.

Reasoning

The solar system indeed has planets that move in elliptical orbits around the Sun as described by Johannes Kepler’s laws of planetary motion. Earth’s orbital period accounts for a ‘year,’ and leap years are added every four years to keep our calendar aligned with Earth’s orbit. The heliocentric model, wherein planets revolve around the Sun, accurately represents our solar system. Lastly, Earth’s axial tilt of approximately 23.5 degrees is responsible for seasonal variations due to differential heating as it orbits the Sun.

– True: The statement aligns with scientific knowledge and understanding about planetary motion within our solar system. It incorporates fundamental aspects from Kepler’s laws, Earth’s orbital period and leap years, the heliocentric model of our solar system, and seasonal changes due to axial tilt. All these components are well-established facts in astronomy.

– Debatable: None of the elements within this statement can be disputed based on current scientific understanding. Each aspect mentioned is supported by extensive evidence and research over centuries. However, it’s always possible

Assumptions

<|assistant|> – The solar system has planets that move in elliptical orbits around the Sun, following Kepler’s laws of planetary motion.

– Earth’s orbital period is approximately 365.25 days as it completes one full orbit around the Sun.

– Our calendar year is based on this approximate orbital duration, defining a ‘year.’

– The heliocentric model correctly describes our solar system structure with the Sun at its center and planets, including Earth, revolving around it.

– Earth’s axis of rotation is tilted relative to its orbit around the Sun, causing seasonal variations due to differential heating as it orbits.

– Observational evidence supporting heliocentrism includes historical astronomical records from Copernicus and Galileo’s telescopic observations.

– The elliptical nature of Earth’s orbit is consistent with Kepler’s first law, which states that the path of each planet around the Sun is an ellipse with the Sun at one focus.

– Seasonal changes are not caused solely by distance from the Sun but also significantly influenced by axial tilt and its relationship

Fact Checker Output

[Assistant]: – True: The solar system indeed has planets that move in elliptical orbits around the Sun as described by Johannes Kepler’s laws of planetary motion. These laws accurately predict and explain how celestits move, with each planet orbiting the sun in a path shaped like an ellipse (Kepler’s first law).

– True: Earth’s orbital period is approximately 365.25 days, which accounts for leap years being introduced every four years to maintain calendar alignment with Earth’s position around the Sun. This duration defines a ‘year.’

– True: The heliocentric model correctly describes our solar system as having the Sun at its center and planets revolving around it. This model was first proposed by Nicolaus Copernicus in the 16th century, revolutionizing astronomy from the geocentric view that placed Earth at the universe’s center.

– True: The axial tilt of Earth (approximately 23.5 degrees) relative to its orbital plane around the Sun is responsible for seasonal variations due to differential heating as Earth orbits the Sun. This tilt causes

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)