Status: True

Assertion

Yawning is contagious.

Results

Humans exhibit empathetic behaviors through actions like contagious yawning, which can foster social bonding and communication. The phenomenon of contagious yawning demonstrates humans’ ability to mirror others’ emotions or actions, serving as a potential means for enhancing interpersonal connections. Additionally, while the primary trigger is visual cues, other factors like stress levels could contribute to shared physiological states, further promoting social cohesion among individuals.

– True: Contagious yawning in humans not only serves as an observable phenomenon but also plays a role in strengthening social bonds and communication through mirroring behaviors and potential sensory or emotional stimuli. This shared experience may contribute to deeper connections between people, highlighting the importance of empathy and understanding in human relationships.

– Debatable: The relationship between contagious yawning and its impact on social bonding among humans is complex and multifacited. While evidence supports the concept of mirroring behaviors as a form of social connection, further research may be needed to fully understand the extent to which these empathetic actions contribute to human relationships. Additionally, other factors

Assumptions

– [output]: – Humans have empathetic capabilities that allow them to understand and mirror the emotions or actions of others.

– Contagious yawning is an observable phenomenon where one individual’s yawn triggers a similar response in observers, even if they haven’t initiated it themselves.

– The act of contagious yawning is not solely based on visual cues but may involve other sensory or emotional stimuli that humans can empathetically respond to.

– Social bonding and communication among humans are facilitated by shared physiological states, which could extend beyond verbal or nonverbal actions.

– The contagious nature of yawning in humans suggests a potential evolutionary advantage for this behavior within social groups.

– Research on the phenomenon may reveal insights into neurological conditions, such as autism spectrum disorders, and their impact on empathetic responses.

– There is existing scientific evidence supporting the concept of contagious yawning in humans through observational studies, experiments, and cross-species comparisons.

Fact Checker Output

<|assistant|> – Humans have empathetic capabilities that allow them to understand and mirror the emotions or actions of others. [True] – This assertion is widely supported by psychological research which demonstrates humans’ ability to experience empathy through mirroring behaviors, such as facial expressions and body language.

– Contagious yawning is an observable phenomenon where one individual’s yawn triggers a similar response in observers, even if they haven’t initiated it themselves. [True] – Numerous studies have documented contagious yawning across different cultures and age groups, indicating its widespread occurrence among humans.

– The act of contagious yawning is not solely based on visual cues but may involve other sensory or emotional stimuli that humans can empathetically respond to. [True] – While the primary trigger for contagious yawning appears to be visual, some research suggests that factors like stress, tiredness, and social context might also play a role in the phenomenon.

– Social bonding and communication among humans are facilitated by shared physiological states, which could extend beyond verbal or nonverbal actions.

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)