Status: True

Assertion

Capital punishment deters crime.

Results

The first two assertions align with rational choice theory in criminology, but they are subject to ongoing research and debate. The third assertion generally holds true based on this theoretical framework, though it may not apply uniformly across all criminal behaviors. The fourth assumption is false as the inconsistencies exist worldwide due to various factors like different legal systems, societal norms, corruption, etc.

– Debatable: This classification acknowledges that while some aspects of the statement align with rational choice theory and criminology research (first two assertions), others are debated within this field or have empirical evidence that’s mixed (third assertion). The fourth assumption is undoubtedly false, but its potential impact on public perception may introduce a level of debate.

– False: Although the first three assertions align with some aspects of rational choice theory in criminology and research findings, none of these statements can be universally accepted as true without caveats or exceptions (e.g., individual differences among offenders). The fourth assertion is factually false due to documented inconsistencies, but it’s not directly related to the truthfulness of the first three assertions about rational choice theory

Assumptions

Here are some of the key assumptions underlying the argument that capital punishment deters crime:

– Individuals contemplating serious crimes, particularly murder, are rational actors who weigh the potential consequences before acting.
– The prospect of facing a death sentence is an effective deterrent for these individuals due to fear or moral opposition against taking another’s life.
– There exists a significant number of criminals who would consider their actions differently if they were aware of capital punishment as a possible consequence, indicating the influence of potential consequences on decision-making processes.
– Capital punishment is consistently and fairly applied in jurisdictions where it is legal, ensuring that its deterrent effect is not undermined by perceived or actual inconsistencies in the justice system.
– The certainty of being caught and convicted for a crime outweighs other factors (such as peer influence or mental illness) when individuals consider committing serious crimes, suggesting capital punishment can compete with these influences.
– There is reliable empirical evidence demonstrating the correlation between regions/countries where capital punishment exists and lower rates of certain types of crime; this relationship holds true even after controlling for

Fact Checker Output

<|assistant|> – True: The first assertion assumes that individuals are rational actors who consider potential consequences before committing crimes. This is generally supported by psychological and sociological studies showing people’s capacity to evaluate risks and benefits prior to their actions, though the degree of this effect can vary widely among individuals.

– False (but debatable): The second assumption that capital punishment effectively deters crime based on fear or moral opposition isn’t universally accepted as true because its deterrent effect is difficult to measure directly. Some studies suggest a deterrent effect, while others do not find significant evidence supporting this claim.

– True: This third assertion is also generally supported by the rational choice theory in criminology which suggests that potential criminals will consider the consequences of their actions before committing offenses. However, it’s important to note that for many crimes (especially those driven by emotional factors or mental illness), this consideration might not be as pronounced.

– False: The fourth assumption is overly optimistic and doesn’t hold true in practice across jurisdictions worldwide. There are numerous documented cases of perceived or actual inconsistencies in the application of capital punishment, which can

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)