Status: True

Assertion

There are 24 hours in a day.

Results

The concept of time is indeed divided into consistent units for measurement, facilitating synchronized activities globally. An hour consists typically of 24 hours based on Earth’s rotation period under average conditions, a minute contains 60 seconds as per the widely accepted standard system, and these definitions are used universally to ensure consistency in timekeeping across various fields such as science, industry, and daily life.
– True: A day is commonly accepted to be made up of 24 hours due to Earth’s rotation period from one solar noon to the next under average conditions, although slight variations can occur because of astronomical phenomena like leap seconds and changes in Earth’s rotational speed.
– True: An hour is conventionally divided into 60 minutes for ease of calculation and consistency in time measurements worldwide, a practice that aligns with the sexagesimal (base-60) system used historically.
– True: A minute consists of 60 seconds as per standard definitions based on the historical use of the base-60 numerical system for dividing time into smaller units. This division is ubiquitously accepted and applied in daily life, scientific research, and

Assumptions

<|assistant|> – The concept of time is divided into consistent units for measurement.
– A day is universally accepted as consisting of 24 hours.
– Each hour can be precisely measured and defined by dividing it into equal parts, which are minutes in this context.
– Minutes are a recognized unit of time division within an hour, with each minute containing the same consistent duration.
– The value for one minute is universally accepted to contain 60 seconds.
– Time measurements (hours, minutes, and seconds) can be consistently applied across different cultures and systems around the world without variation in their definitions or divisions.
– Accurate timekeeping devices are available and capable of measuring these units with precision.
– The statement assumes a standard Earth rotation period to define one day, which may not hold true for all celestial bodies in other contexts (e.g., planetary rotations on different planets).
– It disregards any variations or anomalies that could affect time measurement, such as leap seconds and the slight differences between solar time and standard timekeeping methods.

Fact Checker Output

<|assistant|> – True: The concept of time is indeed divided into consistent units for measurement (seconds, minutes, hours) to facilitate easy comprehension and usage across various fields such as science, industry, and daily life. This standardization allows for synchronized activities globally.
– True: A day is commonly accepted to consist of 24 hours based on Earth’s rotation period from one noon (solar time) to the next noon under average conditions, although this can vary slightly with astronomical events like leap seconds and due to variations in Earth’s rotational speed.
– True: Each hour is defined as consisting of 60 minutes by convention, which has been adopted worldwide for consistency and ease of calculation; however, some cultures or historical timekeeping systems may have used different divisions (e.g., sexagesimal system).
– True: Minutes are a recognized subdivision of an hour with each minute containing 60 seconds by standard definitions, facilitating easy calculations involving durations in hours and minutes.
– True: The value for one minute is universally accepted to contain 60 seconds, based on the sexagesimal (base-60) system used historically

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)