Status: True

Assertion

The human body has 206 bones.

Reasoning

The assertion takes into consideration an average adult human body, excluding children or elderly individuals whose bone counts may differ due to age-related changes. It acknowledges the typical number of 206 true bones in a mature human skeleton while recognizing that individual variations can occur.

– True: By using “individual,” the statement allows for exceptions and variations from the average count, which is realistic given potential medical conditions or congenital anomalies impacting bone number. The phrase indicates an understanding of general patterns rather than absolute rule.

– True: It specifies true bones to exclude accessory structures like sesamoid bones or cartilage from the total count, which are often considered separately and can vary among individuals. This ensures focus on primary skeletal framework when discussing human bone count.

– True: The statement acknowledges that while 206 true bones is common in adult humans, it isn’t universal due to individual differences and potential variations resulting from systemic issues or other factors affecting the body as a whole.

– False: [No explanation needed; this classification was provided earlier]
<|assistant|> Based on

Assumptions

<|assistant|> – The individual being referred to is an average adult human, not a child or elderly person whose bone count may differ due to growth plates closing in children and osteoporosis-related changes in older adults.
– The reference to “individual” implies that the statement does not apply to people with certain medical conditions or congenital anomalies which can result in a different number of bones, such as those born with more than 206 bones due to supernumerary bones.
– The definition of “bones” is limited to structural elements that form part of the skeletal system; thus excluding small accessory structures like sesamoid bones or certain types of cartilage, which are not typically counted as true bones but may still be present in some individuals.
– There’s an assumption that “individual human bodies” follow a general pattern where there are 206 bones and variations exist due to individual differences rather than systemic issues affecting the majority of the population.
– The statement does not account for rare conditions or diseases affecting the number of bones, such as certain genetic disorders that can alter skeletal an

Fact Checker Output

<|assistant|> – True: The assertion takes into consideration a typical adult human body and does not include children or elderly individuals who may have different bone counts due to their developmental stage or age-related changes. This helps establish the context for average bone count in an “individual human.”

– True: By referring to an “individual,” it acknowledges that there could be exceptions due to medical conditions, congenital anomalies, etc., which can result in variations from the typical 206 bones. This assumption is realistic as not every person has exactly 206 bones.

– True: The statement focuses on true bones, meaning that it excludes accessory structures like sesamoid bones or cartilage which are often considered separately from the primary skeletal framework and may vary between individuals.

– True: It assumes a general pattern for human bodies regarding the number of bones, with variations acknowledged but not systemic issues affecting most people’s bone count. This allows readers to understand that while 206 bones is common, it isn’t universal and can be influenced by individual differences.

– True: The statement does not account

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)