Status: True

Assertion

The death penalty is a deterrent to crime.

Results

The given statement can be considered true based on points 1, 2, 3, and 4 provided in the information. All these factors play a crucial role in ensuring that online learning becomes effective for students, as they collectively contribute to creating an engaging, accessible, and technologically-enabled educational environment. The fifth point is incomplete but implies the importance of self-motivation or self-regulation among learners which also impacts the effectiveness of online learning experiences. However, without further details, it’s hard to directly classify this part; nonetheless, a learner’s attitude and self-discipline are critical for successful online engagement.

– True: The widespread adoption and usage of technology by students indicates that they have the necessary access and skills to participate effectively in their courses through digital platforms.
– False: The statement is incorrect as technology alone cannot guarantee effective online learning without other essential factors like reliable internet, proficient educators, and a robust infrastructure.
– Debatable: While technology plays an important role, its effectiveness can be subjective based on individual student needs, preferences, and the

Assumptions

Supporting Assumptions:
– The use of technology and digital platforms is widespread among students, ensuring accessibility and ease of participation during virtual learning sessions.
– Students have access to reliable internet connectivity and necessary devices (computers/tablets) for seamless online engagement in the classroom setting.
– Educators are proficient with digital tools and platforms that facilitate remote teaching, allowing them to effectively deliver lessons and manage student participation virtually.
– The school or educational institution has robust infrastructure in place (e.g., network capabilities, virtual learning environment) to support online learning activities without technical disruptions.
– Students are capable of self-discipline and motivation when engaging with digital content independently, contributing to successful participation during virtual classes.

# Answer
To support the statement that technology facilitates student participation in a classroom setting, these assumptions can be considered:

– Widespread adoption and usage of technology by students for educational purposes.
– Availability of necessary resources (e.g., internet connectivity, devices) to support online learning.
– Proficiency among educators with digital tools that

Fact Checker Output

1. True: Widespread adoption and usage of technology by students for educational purposes imply that a majority of the student population can access and effectively utilize various technologies such as learning management systems, online discussion boards, and virtual classrooms to participate in their courses actively.
2. True: Reliable internet connectivity and devices are prerequisites for any successful digital engagement; students need stable connections and functional tools like computers or tablets to access educational content and communicate with peers and teachers online seamlessly.
3. True: Proficiency among educators in utilizing technology is crucial for ensuring that they can effectively deliver lessons, manage student participation during virtual classes, and create an interactive learning environment using digital tools. This proficiency allows them to leverage various technological resources, making online education more engaging and effective.
4. True: A robust infrastructure at the school level is essential for supporting online learning activities without technical disruptions. High-quality network capabilities and well-equipped virtual learning environments (VLEs) can help ensure that students have access to necessary technologies, resources, and support when participating in remote classes.
5. True: Self

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)