Status: Unknown

Assertion

The human body’s fastest muscles are in the eye.

Results

<|assistant|> – **True**: The statement “The fastest muscle in our body is capable of contracting at unbelievable speeds” can generally be considered true if we are speaking about skeletal muscles, as they have the capability to contract very rapidly. However, it’s worth noting that when comparing types of muscles within the human body, this statement may overlook the fact that smooth and cardiac muscles do not operate at comparable speeds. Therefore, while true in a general context concerning skeletal muscle speed, one should clarify which type of muscle is being referred to for precision.

– **False**: This classification would be incorrect based on the information provided, as it’s well established that certain types of skeletal muscles can contract at very high speeds, although these may not represent “unbelievable” in absolute terms when compared across different organisms or biological systems.

– **Debatable**: This classification might be chosen if there is ambiguity around what is considered the “fastest,” as this could refer to speed relative to human capabilities versus other animals, or within various types of muscles (skeletal vs. smooth). However,

Assumptions

– The statement might be referring to rapid movements or contractions associated with eye function.
– It assumes there is no clear distinction between “muscle” types when discussing speed of movement.
– It may assume that all muscles in the human body are capable of similar rates of contraction, which is not accurate.
– The statement overlooks the fact that different types of muscles (smooth vs. skeletal) have different functions and speeds.
– Assumes rapid eye movement equates to fastest overall muscle function in the human body.

Given these points, a more nuanced explanation is necessary when discussing the speed of muscle contractions in the human body:

**Assumptions for Discussing Rapid Muscle Movements Related to Eye Function:**
– The context refers specifically to rapid movements or contractions.
– There might be an implicit comparison between eye movement speeds and other types of muscle contractions, which requires clarification.
– Recognition that there are different classifications of muscles (e.g., skeletal vs. smooth) with distinct roles and contraction speeds.
– Acknowledgment that the fast

Fact Checker Output

<|assistant|> – **Assumption 1: The statement might be referring to rapid movements or contractions associated with eye function.**
* True. It’s common in discussions about muscle speed to compare the fastest known muscle actions, such as those found in eye movement, which are indeed very quick (e.g., blinking involves a few milliseconds of muscle contraction).

– **Assumption 2: There is no clear distinction between “muscle” types when discussing speed of movement.**
* False. In the human body, there are different types of muscles with varying functions and speeds. For example, skeletal muscles usually contract faster than smooth muscles.

– **Assumption 3: It may assume that all muscles in the human body are capable of similar rates of contraction.**
* False. Not all muscles have the same capabilities for speed and strength; this is a fundamental biological principle, with skeletal muscles generally being faster than smooth or cardiac muscles.

– **Assumption 4: The statement overlooks the fact that different types of muscles (smooth vs. skeletal) have

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)