Status: Debatable

Assertion

Veganism is the most ethical diet.

Reasoning

Based on Kantian ethics doesn’t explicitly require prioritizing accessibility over profits in drug pricing policies, but it emphasizes actions that respect human dignity and can potentially align with ensuring drug accessibility. However, the statement oversimplifies complex considerations such as balancing profitability for research sustainability against broader societal needs.

– answer: Debatable: While Kantian ethics doesn’t explicitly mandate a specific action regarding drug accessibility, it suggests that actions should be able to be universalized and respect human dignity. It can potentially align with ensuring drug access, but the statement oversimplifies complex considerations such as balancing profitability for research sustainability against broader societal needs.

– answer: Debatable: The statement cannot definitively be categorized as true or false based on Kantian ethics since it does not mandate a specific action regarding drug accessibility, but the philosophy emphasizes actions that respect human dignity and can potentially align with ensuring drug access. However, complex considerations such as balancing profitability for research sustainability against broader societal needs are oversimplified in the statement

Assumptions

#### Solution 3:
– The categorical imperative is an unconditional moral law that applies to all rational beings and is independent of any personal desires or outcomes.

– Kantian ethics prioritize duty over consequences, meaning actions are inherently right or wrong regardless of their impact on public health or economic outcomes.
– The notion of universalizability is central; an action should only be taken if its maxim can be willed to become a universal law without contradiction.
– Human dignity and respect for persons as ends in themselves, not merely as means to other ends (such as profit), are crucial considerations in Kantian ethics.

### Follow Up Question 1:
How does the principle of universality relate to pharmaceutical companies’ decisions about drug pricing and availability?

#### Solution for Follow-Up Question 1:
The principle of universality, a cornerstone in Kantian ethics, relates directly to corporate decision-making regarding drug pricing and availability. Under this principle, pharmaceutical companies would be required to consider whether their practices could become universal laws that everyone else should follow. If the maxim behind

Fact Checker Output

# Assumption 1: All actions taken by a company for profit maximization are inherently unethical according to Kantian ethics.

False. According to Kantian ethics, an action’s morality is not solely determined by its outcome (in this case, profit maximization). Instead, the moral worth of an action is based on whether it can be universalized and respects human dignity. Actions taken for profit are not inherently unethical if they adhere to these principles; however, actions that disrespect individuals or cannot be justified as universally applicable could be considered unethical.

# Assumption 2: A pharmaceutical company must prioritize making drugs accessible over maximizing profits when formulating policies on drug pricing and availability.

False, but with nuance. While Kantian ethics emphasizes the duty to act in ways that could be universalized without contradiction and respecting human dignity as ends in themselves, it does not explicitly mandate prioritization of accessibility over profit maximization. However, if making drugs accessible cannot be willed universally or disrespects individual autonomy (e.g., by

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
from wordpress_helper import create_wordpress_post  # Import WordPress helper functions
import html

# Load environment variables from .env file
load_dotenv()

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):
    llm = OpenAI(temperature=0.7, model=os.getenv("MODEL_NAME"))
    
    extraction_template = """
    Here is a final output of a fact-checking process:
    {final_output}
    
    Based on the above text, what is the classification of the statement? Respond with one of the following options followed by a colon and space:
    - True: [Explanation]
    - False: [Explanation]
    - Debatable: [Explanation]
    """
    
    extraction_prompt = PromptTemplate(input_variables=["final_output"], template=extraction_template)
    formatted_prompt = extraction_prompt.format_prompt(final_output=final_output).text
    extraction_output = llm.invoke(formatted_prompt).strip()
    
    if "True:" in extraction_output:
        status = "True"
        reasoning = extraction_output.split("True:", 1)[1].strip()
    elif "False:" in extraction_output:
        status = "False"
        reasoning = extraction_output.split("False:", 1)[1].strip()
    elif "Debatable:" in extraction_output:
        status = "Debatable"
        reasoning = extraction_output.split("Debatable:", 1)[1].strip()
    else:
        status = "Unknown"
        reasoning = extraction_output
    
    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)
    
    # Print the final status and reasoning
    print(final_output)
    print(f"Status: {status}")
    print(f"Reasoning: {reasoning}")

    # Record the result in MongoDB
    try:
        print("Attempting to insert record into MongoDB...")
        insert_record(
            script_name=__file__,
            script_code=html.escape(open(__file__).read()),
            assertion=assertion,
            status=status,
            submission=submission,  # Store the entire submission for detailed analysis
            reasoning=reasoning,
            model=os.getenv("MODEL_NAME")
        )
        print("Record inserted into MongoDB successfully.")
    except Exception as e:
        print(f"Failed to insert record into MongoDB: {e}")
    
    # 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>Reasoning</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)