Status: True

Assertion

Humans are naturally peaceful.

Results

The statement acknowledges an inherent human inclination towards conflict or violence but fails to account for evidence of peaceful achievements, the complexity of individual and group influences on human behavior, and other aspects like cooperation and altruism. While it contains elements that are true—such as recognizing a possible natural tendency towards aggression and ignoring periods of sustained peace in history—it oversimplifies human nature by not considering the full range of factors at play. Therefore, while some parts of the statement can be considered true, its overall classification is debatable due to these nuances.

Debatable: The statement recognizes an inherent human inclination towards conflict or violence and acknowledges evidence suggesting such a tendency exists in history (though it does not account for peaceful achievements). It also overlooks the impact of individual and group influences on behavior, which contributes to the complexity of understanding human nature. The statement’s classification as true or false is debatable because while some aspects are accurate, others oversimplify a complex topic that encompasses multiple factors shaping human behaviors.

False: This classification might seem unfair given the elements acknowledged in

Assumptions

– A belief in inherent human nature: The idea that humans possess certain innate qualities, which can include both peacefulness and aggressiveness.
– Evidence suggesting natural inclination towards conflict or violence: Historical data, anthropological studies, psychological theories etc., indicating a prevalence of aggression, competition, territorial disputes among human societies throughout history. This could include examples like tribal warfare, slavery, colonialism, genocides, wars and many more instances of inter-human violence.
– Ignoring or minimizing peaceful achievements: The statement doesn’t take into account periods of sustained peace in different cultures, societies or civilizations, which could suggest a potential for humans to naturally incline towards peacefulness under certain circumstances.
– Lack of focus on individual/group influence: Human behavior is largely influenced by the environments and experiences they are exposed to. In this context, suggesting that humans aren’t naturally peaceful overlooks how upbrinasy, socialization, education etc., can shape a person’s tendency towards peace or conflict.
– Absence of moral/ethical growth: The statement assumes a static human nature without considering the capacity

Fact Checker Output

<|assistant|> 1. A belief in inherent human nature – True: This assertion acknowledges that humans may have certain intrinsic qualities that shape their behaviors and inclinations towards peace or aggression. While this does not imply a deterministic view of human nature, it is an accepted concept within psychology, sociology, and anthropology.

2. Evidence suggesting natural inclination towards conflict or violence – True: Numerous historical events and studies have demonstrated that humans are prone to aggression, competition, and territorial disputes. However, it’s essential to recognize the complexity of human nature as this evidence only represents one aspect among many others, such as cooperation, altruism, and empathy.

3. Ignoring or minimizing peaceful achievements – True: The statement provided does indeed overlook periods of sustained peace in history. However, this oversight doesn’t invalidate the assertion that there may be an inherent inclination towards aggression; it simply suggests a more nuanced understanding is necessary to fully grasp human nature.

4. Lack of focus on individual/group influence – True: The statement does not consider how environmental factors, socialization, and

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)