<EXAMPLE 1>
<Premises>
Peter Parker is either a superhero or a civilian.
The Hulk is a destroyer.
The Hulk wakes up when he is angry.
If the Hulk wakes up, then he will break a bridge.
Thor is a god.
Thor will break a bridge when he is happy.
A god is not a destroyer.
Peter Parker wears a uniform when he is a superhero.
Peter Parker is not a civilian if a destroyer is breaking a bridge.
If Thor is happy, the Hulk is angry.
</Premises>
<Conclusion>
If Thor is happy, then Peter Parker wears a uniform.
</Conclusion>
<Question>
Is the following statement true, false, or uncertain? If Thor is happy, then Peter Parker wears a uniform.
</Question> 
<Options>
(A) True
(B) False
(C) Uncertain
</Options>
<Reasoning>
<Python>
from typing import Optional

class Entity:
    def is_destroyer(self) -> Optional[bool]:
        return None
    def is_god(self) -> Optional[bool]:
        return None
    def is_superhero(self) -> Optional[bool]:
        return None
    def is_civilian(self) -> Optional[bool]:
        return None
    def breaks_bridge(self) -> Optional[bool]:
        return None
    def wears_uniform(self) -> Optional[bool]:
        return None
    def is_angry(self) -> Optional[bool]:
        return None
    def is_happy(self) -> Optional[bool]:
        return None

    def set_angry(self, state: bool):
        pass
    def set_superhero(self, state: bool):
        pass

class Hulk(Entity):
    def __init__(self, angry: Optional[bool] = None):
        self._angry = angry
        self._destroyer = self.is_destroyer()
        self._wake_up = self.wake_up()
        self._breaks_bridge = self.breaks_bridge()

    def is_destroyer(self) -> Optional[bool]:
        return True

    def is_angry(self) -> Optional[bool]:
        return self._angry

    def set_angry(self, state: bool):
        self._angry = state
        self._wake_up = self.wake_up()
        self._breaks_bridge = self.breaks_bridge()

    def breaks_bridge(self) -> Optional[bool]:
        if self._wake_up is True:
            return True
        elif self._wake_up is False:
            return False
        else:
            return None

    def wake_up(self) -> Optional[bool]:
        if self._angry is True:
            return True
        elif self._angry is False:
            return False
        else:
            return None

class Thor(Entity):
    def __init__(self, happy: Optional[bool] = None):
        self._happy = happy
        self._god = self.is_god()
        self._destroyer = self.is_destroyer()
        self._break_bridge = self.breaks_bridge()

    def is_god(self) -> Optional[bool]:
        return True

    def is_destroyer(self) -> Optional[bool]:
        if self._god:
            return False
        else:
            return None

    def is_happy(self) -> Optional[bool]:
        return self._happy

    def breaks_bridge(self) -> Optional[bool]:
        if self._happy is True:
            return True
        else:
            return None

class PeterParker(Entity):
    def __init__(self, superhero: Optional[bool] = None):
        self._is_superhero = superhero

    def is_superhero(self) -> Optional[bool]:
        return self._is_superhero

    def set_superhero(self, state: bool):
        self._is_superhero = state

    def is_civilian(self) -> Optional[bool]:
        if self._is_superhero is True:
            return False
        elif self._is_superhero is False:
            return True
        else:
            return None

    def wears_uniform(self) -> Optional[bool]:
        if self._is_superhero is True:
            return True
        elif self._is_superhero is False:
            return False
        else:
            return None

def apply_premises(thor: Thor, hulk: Hulk, peter: PeterParker) -> bool:
    updated = False
    if thor.is_happy() is True and hulk.is_angry() is not True:
        hulk.set_angry(True)
        updated = True
    if hulk.is_destroyer() is True and hulk.breaks_bridge() is True:
        if peter.is_superhero() is not True:
            peter.set_superhero(True)
            updated = True
    return updated

def run_inference(thor: Thor, hulk: Hulk, peter: PeterParker):
    while True:
        changed = apply_premises(thor, hulk, peter)
        if not changed:
            break

def check_if_thor_happy_then_peter_uniform(thor: Thor, hulk: Hulk, peter: PeterParker) -> str:
    run_inference(thor, hulk, peter)
    thor_happy = thor.is_happy()
    if thor_happy is False:
        return "A"
    if thor_happy is None:
        return "C"
    pu = peter.wears_uniform()
    if pu is True:
        return "A"
    elif pu is False:
        return "B"
    else:
        return "C"

def main():
    thor = Thor(happy=True)
    hulk = Hulk(angry=True)
    peter = PeterParker(True)
    result = check_if_thor_happy_then_peter_uniform(thor, hulk, peter)

if __name__ == "__main__":
    main()
</Python>
Therefore, the Answer is (A).
</Reasoning>
<Answer>
The final answer is (A).
</Answer>
</EXAMPLE 1>

<EXAMPLE 2>
<Premises>
All philosophers reason.
Some sophists reason.
All who can reason can distinguish truth from falsehood.
Nobody who can distinguish truth from falsehood is morally perfect.
The theistic God is morally perfect.
The theistic God is a sophist.
</Premises>
<Conclusion>
The theistic God is a sophist and a philosopher.
</Conclusion>
<Question>
Is the following statement true, false, or uncertain? The theistic God is a sophist and a philosopher.
</Question>
<Options>
(A) True
(B) False
(C) Uncertain
</Options>
<Reasoning>
<Python>
class Entity:
    def is_philosopher(self) -> bool:
        raise NotImplementedError

    def is_sophist(self) -> bool:
        raise NotImplementedError

    def can_reason(self) -> bool:
        raise NotImplementedError

    def can_distinguish_truth_from_falsehood(self) -> bool:
        raise NotImplementedError

    def is_morally_perfect(self) -> bool:
        raise NotImplementedError


class GodEntity(Entity):
    def is_philosopher(self) -> bool:
        return False

    def is_sophist(self) -> bool:
        return False

    def can_reason(self) -> bool:
        return False

    def can_distinguish_truth_from_falsehood(self) -> bool:
        return False

    def is_morally_perfect(self) -> bool:
        return True


class SophistEntity(Entity):
    def is_philosopher(self) -> bool:
        return False

    def is_sophist(self) -> bool:
        return True

    def can_reason(self) -> bool:
        return True

    def can_distinguish_truth_from_falsehood(self) -> bool:
        return True

    def is_morally_perfect(self) -> bool:
        return False


def check_theistic_god_is_sophist_and_philosopher(god: Entity) -> bool:
    return god.is_sophist() and god.is_philosopher()


def main():
    theisticGod = GodEntity()
    statement_truth_value = check_theistic_god_is_sophist_and_philosopher(theisticGod)

if __name__ == "__main__":
    main()
</Python>
Therefore, the Answer is (B).
</Reasoning>
<Answer>
The final answer is (B).
</Answer>
</EXAMPLE 2>

<EXAMPLE 3>
<Premises>
William Dickinson was a British politician who sat in the House of Commons William Dickinson attended Westminster school for high school and then the University of Edinburgh. 
The University of Edinburgh is a university located in the United Kingdom. 
William Dickinson supported the Portland Whigs. 
People who supported the Portland Whigs did not get a seat in the Parliament.
</Premises>
<Conclusion>
William Dickinson went to schools located in the United Kingdom for both high school and university.
</Conclusion>
<Question>
Is the following statement true, false, or uncertain? William Dickinson went to schools located in the United Kingdom for both high school and university.
</Question> 
<Options>
(A) True
(B) False
(C) Uncertain
</Options>
<Reasoning>
<Python>
from typing import Optional

class Entity:
    def attended_westminster_school(self) -> Optional[bool]:
        raise NotImplementedError

    def attended_university_of_edinburgh(self) -> Optional[bool]:
        raise NotImplementedError

    def westminster_school_in_uk(self) -> Optional[bool]:
        raise NotImplementedError

    def university_of_edinburgh_in_uk(self) -> Optional[bool]:
        raise NotImplementedError


class DickinsonEntity(Entity):
    def attended_westminster_school(self) -> Optional[bool]:
        return True 

    def attended_university_of_edinburgh(self) -> Optional[bool]:
        return True  

    def westminster_school_in_uk(self) -> Optional[bool]:
        return None

    def university_of_edinburgh_in_uk(self) -> Optional[bool]:
        return True


def went_to_uk_schools_for_HS_and_uni(d: Entity) -> str:
    attended_ws = d.attended_westminster_school()
    if attended_ws is False:
        return "False" 

    attended_ue = d.attended_university_of_edinburgh()
    if attended_ue is False:
        return "False"

    if attended_ws is None or attended_ue is None:
        return "Uncertain"

    ws_in_uk = d.westminster_school_in_uk()
    if ws_in_uk is False:
        return "False"
    ue_in_uk = d.university_of_edinburgh_in_uk()
    if ue_in_uk is False:
        return "False"
    if ws_in_uk is None or ue_in_uk is None:
        return "Uncertain"
    return "True"

def main():
    dickinson = DickinsonEntity()
    conclusion = went_to_uk_schools_for_HS_and_uni(dickinson)

if __name__ == "__main__":
    main()
</Python>
Therefore, the answer is (C).
</Reasoning>
<Answer>
The final answer is (C).
</Answer>
</EXAMPLE 3>

The following is the problem you need to solve.

<Premises>
{Premises}
</Premises>
<Conclusion>
{Conclusions}
</Conclusion>
<Question>
Is the following statement true, false, or uncertain? {Conclusions}
</Question> 
<Options>
(A) True
(B) False
(C) Uncertain
</Options>
<Reasoning>


