Status: True

Assertion

The human body has roughly 640 muscles.

Results

The statement is consistent with commonly accepted definitions, references credible sources, acknowledges variation in opinions, and provides useful information about the musculoskeletal system. It accurately reflects that there are differing estimates on the total number of muscles in the human body but cites a reliable source for its claim.

However, it is important to note that while the statement may be generally accurate, exact counts can vary based on different interpretations and classifications within medical literature, so some individuals might consider this information debatable or open to further discussion. In light of that possibility:

– True: The statement aligns with accepted definitions, cites a credible source, acknowledges variation in opinions, and provides valuable insights into the musculoskeletal system’s composition. While there may be differing views on the precise count of human body muscles, the reference to Gray’s Anatomy adds weight to the claim.

Given that it is widely recognized within medical communities as a foundational resource and acknowledges varying perspectives without asserting definitive certainty:

– Debatable: The statement aligns with broadly accepted definitions of the muscul

Assumptions

Here are the assumptions necessary to support the given statement:

* Assumption 1: The musculoskeletal system is accurately defined as including all the muscles in the human body, based on widely accepted anatomical definitions and consensus among medical professionals.
* Assumption 2: There are reliable and comprehensive sources of information on human anatomy that provide a count or classification of muscles (e.g., “Gray’s Anatomy”).
* Assumption 3: The source used for the estimate is credible, well-respected in the field of medical science, and based on consensus among experts rather than individual opinion.
* Assumption 4: Variations in muscle count due to different opinions are acknowledged but considered less relevant for general knowledge purposes (e.g., distinguishing between facial expression muscles).
* Assumption 5: The statement is intended to provide a widely accepted estimate of the number of muscles, rather than an exact and universally agreed-upon figure. This allows for some flexibility in accommodating minor variations across different sources or interpretations while still offering useful information for general understanding.

By considering these assumptions,

Fact Checker Output

<|assistant|> 1. True – The musculoskeletal system is commonly defined as including all the muscles in the human body based on widely accepted anatomical definitions and consensus among medical professionals. This definition helps to provide a clear understanding of what the musculoskeletal system comprises, which is essential for discussing its functions and related topics such as the number of muscles it contains.

2. True – There are reliable and comprehensive sources of information on human anatomy that offer classifications or estimates regarding the count of muscles in the body, one notable example being “Gray’s Anatomy.” These resources serve as foundations for various medical research, education, and general knowledge about human anatomy.

3. True – The statement references a source (presumably Gray’s Anatomy) that is credible within the field of medical science, respected among experts, and based on consensus rather than individual opinion. This lends authority to the estimate provided in the statement while acknowledging there might be differing opinions or interpretations.

4. True – Acknowledging variations in muscle count due to different opinions is essential for maintaining a balanced

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)