Exemplo n.º 1
0
    def type_of(
            self,
            term: Term,
    ) -> Type:
        if term.token() == '__v':
            assert type(term.right.value) is Type
            return term.right.value

        if term.token() == '__c':
            assert type(term.right.value) is Type
            return term.right.value

        if term.token() == '__C':
            ty = self.type_of(term.left)
            assert ty.token() == '__c'
            assert ty.left.token() == 'fun'
            assert ty.right.token() == '__a'
            assert ty.right.right.token() == '__a'
            assert ty.right.right.left is not None
            return ty.right.right.left

        if term.token() == '__A':
            return self.fun_type(
                self.type_of(term.left),
                self.type_of(term.right),
            )
Exemplo n.º 2
0
    def ABS(
            self,
            idx1: int,
            v: Term,
            fake: bool = False,
    ) -> Thm:
        assume(v.token() == '__v')

        assume(idx1 in self._theorems)
        thm1 = self._theorems[idx1]
        c1 = thm1.concl()

        assume(c1.token() == '__C')
        assume(c1.left.token() == '__C')
        assume(c1.left.left.token() == '__c')
        assume(c1.left.left.left.token() == '=')

        l1 = c1.left.right
        r1 = c1.right

        assume(len(list(filter(
            lambda t: self.free_in(v, t),
            thm1.hyp(),
        ))) == 0)

        return self._theorem(
            thm1.hyp(),
            self.safe_mk_eq(
                Term(1, v, l1, '__A'),
                Term(1, v, r1, '__A'),
            ),
            fake,
        )
Exemplo n.º 3
0
    def free_in(
            self,
            v: Term,
            term: Term,
    ) -> bool:
        assume(v.token() == '__v')

        def vfree_in(v, tm):
            if tm.token() == '__A':
                return v.term_string() != tm.left.term_string() and \
                    vfree_in(v, tm.right)
            if tm.token() == '__C':
                return vfree_in(v, tm.left) or vfree_in(v, tm.right)
            return v.term_string() == tm.term_string()

        return vfree_in(v, term)
Exemplo n.º 4
0
    def BETA(
            self,
            term: Term,
            fake: bool = False,
    ) -> Thm:
        assume(term.token() == '__C')
        assume(term.left.token() == '__A')

        v = term.left.left
        bod = term.left.right
        arg = term.right

        assume(v.term_string() == arg.term_string())

        return self._theorem(
            [],
            self.safe_mk_eq(term, bod),
            fake,
        )
Exemplo n.º 5
0
    def variant(
            self,
            avoid: typing.List[Term],
            v: Term,
    ):
        assume(v.token() == '__v')

        if len(list(filter(
            lambda t: self.free_in(v, t),
            avoid,
        ))) == 0:
            return v

        token = v.left.token() + '\''

        if token not in self._t._term_tokens:
            self._t._term_tokens[token] = len(self._t._term_tokens)

        return self.variant(
            avoid,
            Term(3, Term(
                self._t._term_tokens[token], None, None, token
            ), v.right, '__v'),
        )