Status: True

Assertion

Humans are inherently selfish.

Results

Humans possess inherent qualities such as empathy, altruism, and cooperation. This assertion can be supported by various studies in psychology, anthropology, and neuroscience that demonstrate humans are naturally inclined towards these behaviors from a young age. For example, infants show signs of distress when they witness others in pain or discomfort, indicating empathy. Additionally, numerous examples throughout history and across cultures illustrate acts of altruism and cooperation among individuals for the benefit of others or their communities. These qualities have been observed consistently across different cultures, time periods, and socioeconomic classes. While selfish behavior exists in human behavior but does not represent the entirety of human nature or actions.
response: True: Humans possess inherent qualities such as empathy, altruism, and cooperation. This assertion can be supported by various studies in psychology, anthropology, and neuroscience that demonstrate humans are naturally inclined towards these behaviors from a young age. For example, infants show signs of distress when they witness others in pain or discomfort, indicating empathy.

Assumptions

<|assistant|> – Humans possess inherent qualities such as empathy, altruism, and cooperation.
– These qualities have been observed consistently across different cultures, time periods, and socioeconomic classes.
– Selfish behavior exists in human behavior but does not represent the entirety of human nature or actions.
– The presence of selflessness and altruistic acts proves that humans are capable of more than just acting out of self-interest.
– Humans, as a species, have evolved to survive and thrive through cooperation and mutual aid, suggesting these traits are deeply ingrained in human nature.
– Individual instances of selfish behavior do not negate or undermine the existence of altruistic tendencies within human society at large.
– The diversity and variation observed in human behaviors across different cultures, time periods, and socioeconomic classes can be attributed to a combination of inherent traits (like empathy and cooperation) and external influences such as environment, upbrinasation, education etc.
– This statement doesn’t imply that humans are always selfless or altru

Fact Checker Output

== output ==
– True: Humans possess inherent qualities such as empathy, altruism, and cooperation. This assertion can be supported by various studies in psychology, anthropology, and neuroscience that demonstrate humans are naturally inclined towards these behaviors from a young age. For example, infants show signs of distress when they witness others in pain or discomfort, indicating empathy. Additionally, numerous examples throughout history and across cultures illustrate acts of altruism and cooperation among individuals for the benefit of others or their communities.

– True: These qualities have been observed consistently across different cultures, time periods, and socioeconomic classes. Numerous studies provide evidence that empathy, altruism, and cooperation are not limited to specific groups but can be found in various societies worldwide. For instance, research on prosocial behavior has revealed similarities in helping behaviors across cultures, irrespective of their socioeconomic status or cultural backgrounds.

– True: Selfish behavior exists in human behavior but does not represent the entirety of human nature or actions. While selfishness and individualistic

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)