Status: True

Assertion

Cryptocurrencies will replace traditional currencies.

Results

Based on the provided information, the statement can be classified as true. Central banks are historically pivotal in managing economies and ensuring financial stability (Assumption 1), cryptocurrencies’ volatility has been partly due to a lack of regulatory frameworks (Assumption 2), and the complexity of cryptocurrency technology contributes to its unfamiliarity among people (Assumption 3). Therefore, while these factors have influenced the rise of decentralized finance (DeFi) platforms, they also underscore the reasons why central banks might need to adapt their roles in response to this new financial landscape.

– True: Central banks historically play a crucial role in managing economies and ensuring stability through monetary policy and regulation, which is essential for understanding how DeFi platforms may affect traditional finance systems. The lack of regulatory frameworks specifically tailored for cryptocurrencies has led to their high volatility, highlighting the potential need for central banks’ involvement in creating a more stable environment for digital assets. Lastly, while many are unfamiliar with cryptocurrency technology, this underscores the necessity for clear guidance and understanding from

Assumptions

* Assumption 1: Central banks continue to play an essential role in regulating economies and maintaining stability.
* Assumption 2: The absence or limited regulatory oversight on cryptocurrencies contributes to their volatility.
* Assumption 3: A significant portion of the population remains unfamiliar with, or skeptical about, the technology behind cryptocurrencies and its associated risks.
* Assumption 4: Legal restrictions vary across jurisdictions and may impact the adoption rate of cryptocurrencies in certain regions.
* Assumption 5: The existing global financial infrastructure is heavily reliant on traditional fiat currencies, making a significant transition to alternative systems challenging.
===
* Assumption 6: Technological advancements required for integrating cryptocurrencies into the current financial system are not yet fully realized or widely adopted.
* Assumption 7: The global economy is interconnected and relies on standardized currency exchanges, making a complete shift from traditional fiat currencies to cryptocurrencies improbable in the near future.
* Assumption 8: Scalability issues associated with blockchain technology may

Fact Checker Output

For Assumption 1: True, central banks have historically played a crucial role in managing economies and ensuring financial stability through monetary policy and regulation. They influence interest rates, control inflation, manage exchange rates, and oversee the banking system to prevent financial crises. While their roles may evolve with new technologies such as cryptocurrencies, they are likely to remain key players in economic oversight for the time being.

For Assumption 2: True, the lack of regulatory frameworks specifically tailored to cryptocurrencies has contributed to their high volatility. Cryptocurrencies have experienced significant price fluctuations due to speculation, market sentiment, and sometimes even isolated events like hacks or exchanges’ outages without immediate intervention from central authorities.

For Assumption 3: True, many people are still unfamiliar with cryptocurrency technology due to its relatively recent emergence and complexity of concepts such as blockchain and smart contracts. Additionally, the risks associated with investing in cryptocurrencies can deter potential users who may not fully understand these risks or how they compare to traditional financial products.

For Ass

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)