Status: True

Assertion

The human body has roughly 96,000 kilometres of blood vessels.

Results

The assumption about an estimated total length provided for all blood vessels in the human body being within a range of 100,000 kilometers or more aligns with scientific literature on circulatory system estimations. However, there may be slight variations depending on the specific study and its methodology, acknowledging that this is still an estimation subject to advancements in medical technology and research techniques.
– True: The statement accurately reflects the inclusion of various types of blood vessels (arteries, veins, capillaries) within the circulatory system when calculating total lengths. While most methods aim for comprehensive coverage, individual variations do occur due to factors like age, health conditions, and genetics.
– True: Scientific models exist that estimate the total length of human blood vessels, although these are approximations because precise measurement is challenging without invasive procedures or advanced imaging technologies. These estimates provide a useful framework for understanding circulatory system complexity but acknowledge inherent limitations.
– False: Although most individuals have a comparable network of blood vessels, individual variations do exist that can affect the total length estimation. The statement oversimplifies this variation by suggesting uniformity across all people with

Assumptions

– The assumption is based on an estimated total length provided for all the blood vessels in the human body, which may vary depending on different sources but generally falls within the range of 100,000 kilometers or more.
– This estimation assumes a comprehensive inclusion of all types of blood vessels (arteries, veins, and capillaries) within the circulatory system.
– The statement implies that there is an accurate method to measure or estimate the total length of blood vessels in the human body.
– It presumes that this extensive network of blood vessels is consistent across different individuals with similar physiological characteristics.
– The assumption also suggests a standardized definition and measurement for what constitutes as “length” within the context of blood vessels, which may encompass both linear dimensions (e.g., total length) and cross-sectional areas.

Note that while these assumptions help support the statement, it’s essential to consider variations in scientific research and methodologies used when estimating the total length of human blood vessels.

Fact Checker Output

<|assistant|> – True: The assumption about an estimated total length provided for all blood vessels in the human body being within a range of 100,000 kilometers or more is generally consistent with scientific literature. However, exact numbers may vary based on different studies and methodologies used to estimate this total length.
– True: This estimation indeed assumes that all types of blood vessels (arteries, veins, capillaries) are included within the circulatory system for calculating the total length. However, there might be minor variations depending on which study or source is referred to.
– True: There are methods and models used by scientists to estimate the total length of human blood vessels, although it’s an estimation rather than precise measurement due to limitations in imaging technologies and methodologies. The accuracy of these estimates may vary based on advancements in technology and research techniques.
– False: While there is a general presumption that this extensive network of blood vessels is consistent across individuals with similar physiological characteristics, individual variations do exist, such as differences due to age, health conditions, or genetic factors. The assumption simplifies the complexity for estimation purposes but does not account for every possible variation.
– True: For scientific

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)