Status: True

Assertion

The Earth revolves around the Sun.

Reasoning

The elliptical nature of celestial orbits, as described by Kepler’s laws, can have an impact on tidal forces exerted over time. This is because the varying distances between Earth and Moon during their respective orbits could lead to subtle changes in gravitational pull strength. However, these effects are generally less significant than those directly caused by the positions of the Moon relative to the Sun (e.g., spring and neap tides).

– True: The lunar cycle significantly influences tidal patterns due to the gravitational interactions between the Moon and Earth. This is well-documented, as the position of the Moon in its orbit around Earth directly correlates with the heights of high and low tides experienced on Earth’s oceans.

– True: The Sun contributes to creating spring and neap tides through its gravitational interaction with both the Earth and the Moon during specific alignments. This phenomenon is a fundamental aspect of tidal dynamics, where combined solar and lunar gravitation leads to higher high tides (spring tides) and lower low tides (neap tides).

– True: The elliptical nature of cel

Assumptions

<|assistant|> – Assumption 1: The lunar cycle does not influence tidal patterns, which contradicts our understanding that tides follow a semi-diurnal pattern linked to the Moon’s orbit around Earth.

– Assumption 2: The Sun has no effect on creating spring and neap tides, which goes against astronomical observations showing that when the Sun, Moon, and Earth form a right angle (during quarter moons), we experience neap tides; conversely, during full or new moon phases, when the Sun and Moon’s gravitational forces align, we witness spring tides.

– Assumption 3: The influence of the Moon’s orbit on its gravitational effects is negligible over time, which does not hold true as per Kepler’s laws of planetary motion indicating that the relative positions of celestinas and the Sun change due to the elliptical nature of orbits.

– Assumption 4: Earth’s axial tilt has no bearing on variations in tide heights throughout the year, which is incorrect since Earth’s axial tilt causes seasonal changes that can affect tidal ranges slightly.

– Assumption 5

Fact Checker Output

<|assistant|> – True/False: The lunar cycle significantly influences tidal patterns due to the gravitational interactions between the Moon and Earth.
**True**. Tidal patterns are indeed influenced by the lunar cycle because of the Moon’s gravitational pull on Earth’s oceans, causing tides that follow a semi-diurnal pattern in most coastal regions.

– True/False: The Sun contributes to creating spring and neap tides through its gravitational interaction with both the Earth and the Moon during specific alignments.
**True**. Spring tides occur when the Sun, Earth, and Moon are aligned (during full or new moon), while neap tides happen when the Sun and Moon are at right angles relative to each other and the Earth (during quarter moons). These alignments significantly influence the magnitude of tides due to combined gravitational effects.

– True/False: The elliptical nature of celestial orbits, as described by Kepler’s laws, has a noticeable impact on tidal forces exerted over time.
**True**. While Earth’s orbit around the Sun and Moon’

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)