Status: True

Assertion

Affirmative action is reverse discrimination.

Results

The statement aligns with Assumption 3 by acknowledging affirmative action’s role in addressing historical disparities and systemic barriers. However, the classification also considers the broader context provided by other assumptions, which acknowledge that fairness can vary across cultures (Assumption 4) and that there is potential for nuanced discussions on implementation (Assumption 5). Therefore, while the statement supports affirmative action’s intent to achieve social justice, it does not encapsulate all complexities and diverse perspectives on what constitutes fairness or how its effectiveness should be evaluated. Hence, a classification of “Debatable” is more appropriate as it reflects an understanding that there are multiple valid viewpoints regarding the role and impact of affirmative action in achieving social justice.

– Debatable: The statement acknowledges the intent behind affirmative action to correct historical imbalances but does not fully address Assumption 4, which points out cultural differences in

Assumptions

* Assumption 1: Affirmative action creates reverse discrimination against majority groups who are not covered by such policies.
* Assumption 2: The perception of affirmative action as unfair is universally held and reflects a consensus on fairness in society.
* Assumption 3: Affirmative action does not effectively address historical disparities or systemic barriers faced by underrepresented groups.
* Assumption 4: Fairness can be uniformly defined across different societal contexts, without considering diverse cultural norms and values.
* Assumption 5: The complexities of affirmative action’s conceptualization and implementation are insurmountable or unimportant in the debate against it.
===
– Assumption 1: Affirmative action creates reverse discrimination against majority groups who are not covered by such policies, suggesting a binary understanding of disadvantage that overlooks other forms of inequality.
– Assumption 2: The perception of affirmative action as unfair is universally held and reflects a consensus on fairness in society, ignoring the plurality of opinions and cultural differences regarding justice and equity.
–

Fact Checker Output

* Assumption 3: Affirmative action does not effectively address historical disparities or systemic barriers faced by underrepresented groups, which is an oversimplification as the effectiveness can vary based on implementation and context.
– Assumption 4: Fairness can be uniformly defined across different societal contexts, without considering diverse cultural norms and values, is a flawed assumption because fairness often requires adapting to varying social norms and expectations.
– Assumption 5: The complexities of affirmative action’s conceptualization and implementation are insurmountable or unimportant in the debate against it, as this undervalues the potential for nuanced discussion that can lead to more effective policies and understanding.

True/False explanations:

– Assumption 1 is largely considered false because while affirmative action aims at providing opportunities to historically disadvantaged groups, its impact on majority groups varies depending on the specific policy and context, and it does not inherently imply reverse discrimination.
– Assumption 2 is mostly false as perceptions of fairness are diverse across different societies and individuals; there’s no universal consensus on

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)