Status: True

Assertion

The Earth is the third planet from the Sun.

Results

The gravitational forces from both stars, along with the planets’ distances to their respective stars, allow for stable, circular orbits due to the balance of centripetal force required for a circular orbit and the gravitational pull exerted by the stars.

– **Assertion about mass influence on gravity:** True: The lesser mass of Star 2 means it has a weaker gravitational attraction compared to Star 1, which affects the orbits and potential orbital resonance patterns of surrounding planets.

– **Assertion about orbital resonance:** True: Given that Planet C completes an orbit in a simple integer ratio with Planet A’s period (e.g., one orbit for every two of Planet A), this indicates an orbital resonance between the two planets, as described by their respective periods being in a small whole number ratio.

– **Assertion about atmospheric stripping:** True: The influence of tidal forces exerted by Star 2 on Planet D can lead to significant atmospheric loss, resulting in a thinner atmosphere. This process is known as atmospheric

Assumptions

<|assistant|> – Earth is part of the solar system and orbits around the Sun.

– The Sun is the central star within our solar system.

– There are three celestial bodies in orbit around the Sun, with Earth being one of them.

– The order of these planets is defined as follows: Mercury (1st), Venus (2nd), Earth (3rd).

– Life on Earth requires specific conditions that are a direct result of its position and characteristics within this solar system arrangement.

– These life-sustaining conditions are not uniformly distributed across all celestial bodies in the solar system, highlighting the uniqueness of Earth’s habitability.

– The statement assumes current scientific understanding regarding our planetary classification and hierarchy based on observation and astronomical data.

## Follow Up Question 1:
What would change if we consider a hypothetical scenario where another celestial body is closer to the Sun than Mercury?

<|assistant|> If there were an additional celestial body that was closer to the Sun than Mercury, several implications for our understanding of Earth’s position and its unique characteristics would arise:

– The solar system hierarchy would

Fact Checker Output

**Assertions about a hypothetical planetary system with five planets orbiting around two stars (a binary star system):**

– Planet A is closer to Star 1 than Planet B.

– All planets in the system maintain stable, circular orbits due to their distances from the stars and gravitational forces involved.

– The second star, Star 2, has less mass than Star 1, which means it exerts a weaker gravitational pull on the surrounding celestial bodies.

– Planet C is in an orbital resonance with Planet A, meaning they have periods that are simple integer ratios of each other (e.g., if Planet A completes two orbits while Planet C completes one orbit).

– Due to tidal forces from the proximity of Star 2, Planet D experiences significant atmospheric stripping and has a thin atmosphere as a result.

– The orbital period of Planet E is greater than that of Planet A because it resides further away from both stars in its respective orbit.

### Solution to Instruction 1:

– **Assertion about proximity:** True, assuming we are

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)