Status: True

Assertion

The human heart beats roughly 3 billion times in an average lifespan.

Results

The average human lifespan is commonly estimated at approximately 80 years, which serves as a standard figure for calculations in various scientific and policy planning contexts. Although individual lifespans can greatly vary due to numerous factors such as genetics, healthcare quality, lifestyle choices, and historical events like pandemics, using an average of 80 years provides a useful approximation.

– True: The division of the day into 24 hours is widely accepted for calculations involving time intervals in various scientific disciplines. This standardization facilitates computations related to human physiology or other phenomena that occur on an hourly basis, by providing a consistent and universally understood unit of time measurement.

– True: An average resting heart rate for adults generally falls between 60 and 100 beats per minute. Utilizing the median value of 80 beats per minute is reasonable as it approximates this range while allowing simplified calculations, though individual variations may exist based on factors like fitness level, age, and other personal attributes.

– True: Stroke volume refers to the amount of blood pumped by

Assumptions

<|assistant|> – The average human lifespan is approximately 80 years; this figure can vary based on factors such as health, genetics, and lifestyle but will serve as an estimation for calculations.

– One day consists of 24 hours, which allows us to calculate the number of heartbeats per day.

– A human’s resting heart rate is typically between 60 and 100 beats per minute; using a median value can provide a more generalized estimate for calculations (e.g., 80 beats per minute).

– Each beat pumps an average volume of blood, known as the stroke volume, which in adults ranges from about 70 to 100 milliliters; we’ll use 75 ml/beat for our calculation.

– The individual’s heart beats consistently throughout their life without major cardiac events that could alter these numbers significantly.

– All calculations are based on the assumption of consistent lifestyle and health conditions, with no extreme exercise or illness affecting the average daily heart rate and stroke volume over a lifetime.

– The conversion from liters to gallons is

Fact Checker Output

explanation: – True. While the exact lifespan can vary based on numerous factors such as genetics, healthcare quality, lifestyle choices, and historical contexts (e.g., pandemics), an average human lifespan of approximately 80 years is commonly used for calculations in various fields including biology, demographics, and public policy planning.

– True. The division of a day into 24 hours provides a standard framework to calculate rates or frequencies over daily intervals, such as heartbeats per day. This time frame is universally accepted and helps simplify computations related to human physiology and other phenomena measured on an hourly basis.

– True. A resting heart rate typically ranges between 60 and 100 beats per minute for adults. Using a median value like 80 beats per minute is a reasonable approximation that simplifies calculations while still capturing the general variability across different individuals. It’s important to note, however, that this can vary significantly based on fitness level, age, and other factors.

– True. The stroke volume (the amount of blood pumped by the heart with each beat)

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)