def repres(seq: NamedOpetope.Sequent) -> NamedOpetope.OCMT:
"""
The :math:`\\textbf{OptSet${}^!$}` :math:`\\texttt{repr}` rule.
"""
if not seq.typing.term.isVariable():
raise DerivationError(
"repr rule",
"Opt! sequent expected to type a variable, typing {term}",
term=repr(seq.typing.term))
res = NamedOpetope.OCMT(deepcopy(seq.theory), deepcopy(seq.context))
# new context
for typing in seq.context:
v = typing.term.variable
if v is None:
raise RuntimeError("[repres rule] The premiss context types an "
"invalid / null term. In valid proof trees, "
"this should not happen")
for i in range(1, v.dimension + 1):
res.context += NamedOpetope.Typing(
NamedOpetope.Term(res.target(v, i)),
NamedOpetope.Type(typing.type.terms[i:]))
# new theory
for tup in seq.context.graftTuples():
b, a = tup
res.theory += (res.target(a), b)
for a in res.context.variables():
if a.dimension >= 2 and not res.source(a).degenerate:
s = res.source(a).variable
if s is None:
raise RuntimeError(
"[repres rule] The premiss context types "
"the variable {a} of dimension {dim}, "
"whose first source is invalid / null. In "
"valid proof trees, this should not happen".format(
a=str(a), dim=a.dimension))
res.theory += (res.target(a, 2), res.target(s))
for a in seq.context.variables():
for k in range(0, a.dimension - 1):
if res.source(res.target(a, k)).degenerate:
c = res.source(res.target(a, k)).variable
if c is None:
raise RuntimeError("[repres rule] The premiss context "
"types the variable {var} of dimension "
"{dim}, whose first source is invalid "
"/ null. In valid proof trees, this "
"should not happen".format(
var=str(res.target(a, k)),
dim=res.target(a, k).dimension))
res.theory += (res.target(a, k + 2), c)
# identification of targets
tmp = deepcopy(res.theory)
for cls in tmp.classes:
elems = list(cls)
dim = elems[0].dimension
for i in range(1, len(cls)):
for k in range(1, dim + 1):
res.theory += (res.target(elems[0],
k), res.target(elems[i], k))
return res
def test___eq__(self):
self.assertEqual(self.tw, self.tw)
self.assertEqual(self.tx, self.tx)
self.assertEqual(self.ty, self.ty)
self.assertEqual(self.tz, self.tz)
self.assertNotEqual(self.tx, self.tz)
self.assertNotEqual(self.tw, NamedOpetope.Term(self.w))
self.assertNotEqual(NamedOpetope.Term(NamedOpetope.Variable("x", 0)),
NamedOpetope.Term(NamedOpetope.Variable("x", 1)))
def pd(ocmt: NamedOpetope.OCMT, name: str) -> NamedOpetope.Sequent:
"""
The :math:`\\textbf{OptSet${}^!_m$}` :math:`\\texttt{pd}` rule.
Introduces the trivial non degenerate pasting diagram on a given variable.
"""
var = ocmt.context[name]
t = NamedOpetope.Typing(NamedOpetope.Term(var), ocmt.context.typeOf(var))
return NamedOpetope.Sequent(deepcopy(ocmt.theory), deepcopy(ocmt.context),
t)
def test_pd(self):
s = NamedOpetopicSetM.point("x")
with self.assertRaises(DerivationError):
NamedOpetopicSetM.pd(s, "y")
s = NamedOpetopicSetM.pd(s, "x")
self.assertTrue(isinstance(s, NamedOpetope.Sequent))
self.assertEqual(len(s.context), 1)
self.assertEqual(len(s.theory.classes), 0)
self.assertEqual(
s.typing.term, NamedOpetope.Term(
NamedOpetope.Variable("x", 0), False))
def degen(ocmt: NamedOpetope.OCMT, name: str) -> NamedOpetope.Sequent:
"""
The :math:`\\textbf{OptSet${}^!_m$}` :math:`\\texttt{degen}` rule.
Introduces the degenerate pasting diagram on a given variable.
"""
var = ocmt.context[name]
type = ocmt.context.typeOf(var)
t = NamedOpetope.Typing(
NamedOpetope.Term(var, True),
NamedOpetope.Type([NamedOpetope.Term(var)] + type.terms))
return NamedOpetope.Sequent(deepcopy(ocmt.theory), deepcopy(ocmt.context),
t)
def test___contains__(self):
self.assertNotIn(self.a, self.t0)
self.assertNotIn(self.f, self.t0)
self.assertNotIn(self.alpha, self.t0)
self.assertIn(self.a, self.t1)
self.assertNotIn(self.f, self.t1)
self.assertNotIn(self.alpha, self.t1)
self.assertIn(self.a, self.t2)
self.assertIn(self.f, self.t2)
self.assertNotIn(self.alpha, self.t2)
self.assertIn(self.a, self.t3)
self.assertIn(self.f, self.t3)
self.assertIn(self.alpha, self.t3)
self.assertNotIn(NamedOpetope.Variable("β", 2), self.t3)
self.assertNotIn(NamedOpetope.Variable("a", 2), self.t3)
def test_sum(self):
a = NamedOpetopicSet.Repr(
NamedOpetope.OpetopicInteger(3, "a", "f", "A")).eval()
b = NamedOpetopicSet.Repr(
NamedOpetope.OpetopicInteger(4, "a", "f", "B")).eval()
c = NamedOpetopicSet.Repr(
NamedOpetope.OpetopicInteger(4, "b", "g", "B")).eval()
with self.assertRaises(DerivationError):
NamedOpetopicSet.sum(a, b)
with self.assertRaises(DerivationError):
NamedOpetopicSet.sum(b, c)
d = NamedOpetopicSet.sum(a, c)
self.assertEqual(len(d.context), len(a.context) + len(c.context))
self.assertEqual(len(d.theory.classes),
len(a.theory.classes) + len(c.theory.classes))
def test___add__(self):
with self.assertRaises(DerivationError):
self.ctx5 + NamedOpetope.Typing(self.term1, self.typing1)
with self.assertRaises(DerivationError):
self.ctx5 + NamedOpetope.Typing(self.term2, self.typing2)
with self.assertRaises(DerivationError):
self.ctx5 + NamedOpetope.Typing(self.term3, self.typing3)
with self.assertRaises(DerivationError):
self.ctx5 + NamedOpetope.Typing(self.term4, self.typing4)
term = NamedOpetope.Term(NamedOpetope.Variable("x", 2))
term[NamedOpetope.Variable("a", 1)] = NamedOpetope.Term(
NamedOpetope.Variable("y", 2))
typing = NamedOpetope.Typing(term, self.typing3)
with self.assertRaises(DerivationError):
self.ctx5 + typing
def test___or__(self):
self.assertFalse((self.th1 | self.th1).equal(self.a0, self.b0))
self.assertFalse((self.th1 | self.th2).equal(self.a0, self.c0))
self.assertTrue((self.th2 | self.th2).equal(self.a0, self.b0))
self.assertTrue(
(self.th2 | (NamedOpetope.EquationalTheory() +
(self.b0, self.e0))).equal(self.e0, self.a0))
def point(name: str) -> NamedOpetope.OCMT:
"""
The :math:`\\textbf{OptSet${}^!_m$}` :math:`\\texttt{point}` rule.
Introduces a :math:`0`-variable with name ``x``.
"""
t = NamedOpetope.Typing(NamedOpetope.Term(NamedOpetope.Variable(name, 0)),
NamedOpetope.Type([NamedOpetope.Term()]))
return NamedOpetope.OCMT(NamedOpetope.EquationalTheory(),
NamedOpetope.Context() + t)
def graft(seqt: NamedOpetope.Sequent, seqx: NamedOpetope.Sequent,
name: str) -> NamedOpetope.Sequent:
"""
The :math:`\\textbf{OptSet${}^!_m$}` :math:`\\texttt{graft}` rule, which is
the same as system :math:`\\textbf{Opt${}^!$}`'s :math:`\\texttt{graft}`
rule.
"""
return NamedOpetope.graft(seqt, seqx, name)
def test_graft(self):
"""
:todo: Test degenerate grafting
"""
self.assertEqual(
NamedOpetope.Term(self.g),
self.sequent.graft(NamedOpetope.Term(self.g), self.c1,
NamedOpetope.Term(self.f)))
self.assertEqual(self.fgh1, self.fgh2)
self.assertEqual(len(self.fgh1.keys()), 1)
self.assertTrue(
self.sequent.theory.equal(list(self.fgh1.keys())[0], self.c1))
t = list(self.fgh1.values())[0]
self.assertTrue(self.sequent.theory.equal(t.variable, self.g))
self.assertEqual(len(t.keys()), 1)
self.assertTrue(self.sequent.theory.equal(list(t.keys())[0], self.b1))
self.assertTrue(
self.sequent.theory.equal(list(t.values())[0].variable, self.f))
with self.assertRaises(DerivationError):
self.sequent.graft(self.fg, self.b1, NamedOpetope.Term(self.f))
def sum(ocmt1: NamedOpetope.OCMT,
ocmt2: NamedOpetope.OCMT) -> NamedOpetope.OCMT:
"""
The :math:`\\textbf{OptSet${}^!$}` :math:`\\texttt{sum}` rule.
"""
if len(ocmt1.context.variables() & ocmt2.context.variables()) != 0:
raise DerivationError(
"sum rule",
"The two premiss OCTM are expected to have disjoint contexts, "
"but intersection types the following variables {inter}",
inter=ocmt1.context.variables() & ocmt2.context.variables())
return NamedOpetope.OCMT(ocmt1.theory | ocmt2.theory,
ocmt1.context | ocmt2.context)
def test_glue(self):
a = NamedOpetopicSet.Repr(NamedOpetope.OpetopicInteger(3)).eval()
with self.assertRaises(DerivationError):
NamedOpetopicSet.glue(a, "a_1", "f_1")
with self.assertRaises(DerivationError):
NamedOpetopicSet.glue(a, "f_1", "f_2")
a = NamedOpetopicSet.glue(a, "a_1", "a_2")
a = NamedOpetopicSet.glue(a, "a_1", "a_3")
a = NamedOpetopicSet.glue(a, "a_1", "ttA")
a = NamedOpetopicSet.glue(a, "f_1", "f_2")
a = NamedOpetopicSet.glue(a, "f_1", "f_3")
a = NamedOpetopicSet.glue(a, "f_1", "tA")
self.assertEqual(len(a.theory.classes), 2)
def test_degen(self):
s = NamedOpetope.point("x")
s = NamedOpetope.degen(s)
self.assertEqual(
s.typing.term,
NamedOpetope.Term(NamedOpetope.Variable("x", 0), True))
self.assertEqual(len(s.context), 1)
with self.assertRaises(DerivationError):
NamedOpetope.degen(s)
def setUp(self):
self.a0 = NamedOpetope.Variable("a", 0)
self.b0 = NamedOpetope.Variable("b", 0)
self.c0 = NamedOpetope.Variable("c", 0)
self.d0 = NamedOpetope.Variable("d", 0)
self.e0 = NamedOpetope.Variable("e", 0)
self.a1 = NamedOpetope.Variable("a", 1)
self.th1 = NamedOpetope.EquationalTheory()
self.th2 = self.th1 + (self.a0, self.b0)
self.th3 = self.th2 + (self.c0, self.d0)
self.th4 = self.th3 + (self.c0, self.e0)
self.th5 = self.th4 + (self.b0, self.a0)
self.th6 = self.th5 + (self.a0, self.e0)
def test___add__(self):
with self.assertRaises(DerivationError):
NamedOpetope.EquationalTheory() + (self.a0, self.a1)
self.assertEqual(len(self.th2.classes), 1)
self.assertEqual(self.th2.classes[0], {self.a0, self.b0})
self.assertEqual(len(self.th3.classes), 2)
self.assertEqual(self.th3.classes[0], {self.a0, self.b0})
self.assertEqual(self.th3.classes[1], {self.c0, self.d0})
self.assertEqual(len(self.th4.classes), 2)
self.assertEqual(self.th4.classes[0], {self.a0, self.b0})
self.assertEqual(self.th4.classes[1], {self.c0, self.d0, self.e0})
self.assertEqual(len(self.th5.classes), 2)
self.assertEqual(self.th5.classes[0], {self.a0, self.b0})
self.assertEqual(self.th5.classes[1], {self.c0, self.d0, self.e0})
self.assertEqual(len(self.th6.classes), 1)
self.assertEqual(self.th6.classes[0],
{self.a0, self.b0, self.c0, self.d0, self.e0})
def shift(seq: NamedOpetope.Sequent, name: str) -> NamedOpetope.OCMT:
"""
The :math:`\\textbf{OptSet${}^!_m$}` :math:`\\texttt{shift}` rule.
Takes a sequent ``seq`` typing a term ``t`` and introduces
a new variable ``x`` having ``t`` as :math:`1`-source.
"""
n = seq.typing.term.dimension
var = NamedOpetope.Variable(name, n + 1)
if var in seq.context:
raise DerivationError(
"shift rule",
"NamedOpetope.Variable {var} already typed in context",
var=name)
typing = NamedOpetope.Typing(
NamedOpetope.Term(var),
NamedOpetope.Type([seq.typing.term] + seq.typing.type.terms))
res = NamedOpetope.OCMT(deepcopy(seq.theory),
deepcopy(seq.context) + typing)
# targets of new variable
for i in range(1, n + 2):
res.context += NamedOpetope.Typing(
NamedOpetope.Term(res.target(var, i)),
NamedOpetope.Type(typing.type.terms[i:]))
# additional theory
termVar = seq.typing.term.variable
if termVar is None:
raise RuntimeError(
"[shift rule] Premiss sequent types an invalid term. In valid "
"proof trees, this should not happen")
if seq.typing.term.degenerate:
for i in range(n):
res.theory += (res.target(var, i + 2), res.target(termVar, i))
elif n >= 1:
seq.theory += (res.target(var, 2), res.target(termVar))
for gt in seq.typing.term.graftTuples():
seq.theory += (res.target(gt[1]), gt[0])
return res
def test_typeOf(self):
with self.assertRaises(DerivationError):
self.ctx1.typeOf(NamedOpetope.Variable("a", 0))
with self.assertRaises(DerivationError):
self.ctx2.typeOf(NamedOpetope.Variable("b", 0))
self.assertEqual(
self.ctx5.typeOf(NamedOpetope.Variable("a", 0)).terms,
self.typing1.terms)
self.assertEqual(
self.ctx5.typeOf(NamedOpetope.Variable("f", 1)).terms,
self.typing2.terms)
self.assertEqual(
self.ctx5.typeOf(NamedOpetope.Variable("α", 2)).terms,
self.typing3.terms)
self.assertEqual(
self.ctx5.typeOf(NamedOpetope.Variable("A", 3)).terms,
self.typing4.terms)
def test_equal(self):
self.assertTrue(self.sequent.equal(self.fgh1, self.fgh2))
self.assertTrue(
self.sequent.equal(NamedOpetope.Term(self.h),
NamedOpetope.Term(self.i)))
self.assertTrue(
self.sequent.equal(
self.sequent.graft(NamedOpetope.Term(self.i), self.c1,
self.fg), self.fgh1))
self.assertTrue(
self.sequent.equal(
self.sequent.graft(NamedOpetope.Term(self.i), self.c1,
self.fg), self.fgh2))
self.assertFalse(self.sequent.equal(self.gh,
NamedOpetope.Term(self.h)))
self.assertFalse(self.sequent.equal(self.gh,
NamedOpetope.Term(self.g)))
self.assertFalse(self.sequent.equal(self.gh, self.fg))
def test___init__(self):
with self.assertRaises(DerivationError):
NamedOpetope.Variable("x", -1)
NamedOpetope.Variable("x", 0)
def setUp(self):
self.w = NamedOpetope.Variable("w", 2)
self.x = NamedOpetope.Variable("x", 2)
self.y = NamedOpetope.Variable("y", 2)
self.z = NamedOpetope.Variable("z", 2)
self.a = NamedOpetope.Variable("a", 1)
self.b = NamedOpetope.Variable("b", 1)
self.c = NamedOpetope.Variable("c", 1)
self.d = NamedOpetope.Variable("d", 1)
self.e = NamedOpetope.Variable("e", 1)
# t = w (a <- x, b <- y (c <- z, d <- _e_))
self.tw = NamedOpetope.Term(self.w)
self.tx = NamedOpetope.Term(self.x)
self.ty = NamedOpetope.Term(self.y)
self.tz = NamedOpetope.Term(self.z)
self.ty[self.c] = self.tz
self.ty[self.d] = NamedOpetope.Term(self.e, True)
self.tw[self.a] = self.tx
self.tw[self.b] = self.ty
def test___init__(self):
with self.assertRaises(DerivationError):
NamedOpetope.Type([
NamedOpetope.Term(NamedOpetope.Variable("α", 3)),
NamedOpetope.Term(self.f),
NamedOpetope.Term(self.a),
NamedOpetope.Term()
])
with self.assertRaises(DerivationError):
NamedOpetope.Type([
NamedOpetope.Term(self.alpha),
NamedOpetope.Term(self.f),
NamedOpetope.Term(NamedOpetope.Variable("a", 1)),
NamedOpetope.Term()
])
with self.assertRaises(DerivationError):
NamedOpetope.Type([])
def test_isIn(self):
self.assertTrue(self.th1.isIn(self.a0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th1.isIn(self.b0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th1.isIn(self.c0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th1.isIn(self.d0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th1.isIn(self.e0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th1.isIn(self.a1, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th2.isIn(self.a0, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th2.isIn(self.b0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th2.isIn(self.c0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th2.isIn(self.d0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th2.isIn(self.e0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th2.isIn(self.a1, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th3.isIn(self.a0, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th3.isIn(self.b0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th3.isIn(self.c0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th3.isIn(self.d0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th3.isIn(self.e0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th3.isIn(self.a1, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th4.isIn(self.a0, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th4.isIn(self.b0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th4.isIn(self.c0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th4.isIn(self.d0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th4.isIn(self.e0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th4.isIn(self.a1, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th5.isIn(self.a0, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th5.isIn(self.b0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th5.isIn(self.c0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th5.isIn(self.d0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th5.isIn(self.e0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th5.isIn(self.a1, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th6.isIn(self.a0, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th6.isIn(self.b0, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th6.isIn(self.c0, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th6.isIn(self.d0, NamedOpetope.Term(self.a0)))
self.assertTrue(self.th6.isIn(self.e0, NamedOpetope.Term(self.a0)))
self.assertFalse(self.th6.isIn(self.a1, NamedOpetope.Term(self.a0)))
def test___init__(self):
NamedOpetope.Typing(NamedOpetope.Term(NamedOpetope.Variable("a", 0)),
NamedOpetope.Type([NamedOpetope.Term()]))
NamedOpetope.Typing(
NamedOpetope.Term(NamedOpetope.Variable("f", 1)),
NamedOpetope.Type([
NamedOpetope.Term(NamedOpetope.Variable("a", 0)),
NamedOpetope.Term()
]))
with self.assertRaises(DerivationError):
NamedOpetope.Typing(
NamedOpetope.Term(NamedOpetope.Variable("a", 1)),
NamedOpetope.Type([NamedOpetope.Term()]))
with self.assertRaises(DerivationError):
NamedOpetope.Typing(
NamedOpetope.Term(NamedOpetope.Variable("f", 2)),
NamedOpetope.Type([
NamedOpetope.Term(NamedOpetope.Variable("a", 0)),
NamedOpetope.Term()
]))
with self.assertRaises(DerivationError):
NamedOpetope.Typing(
NamedOpetope.Term(NamedOpetope.Variable("f", 0)),
NamedOpetope.Type([
NamedOpetope.Term(NamedOpetope.Variable("a", 0)),
NamedOpetope.Term()
]))
def setUp(self):
self.term1 = NamedOpetope.Term(NamedOpetope.Variable("a", 0))
self.term2 = NamedOpetope.Term(NamedOpetope.Variable("f", 1))
self.term3 = NamedOpetope.Term(NamedOpetope.Variable("α", 2))
self.term4 = NamedOpetope.Term(NamedOpetope.Variable("A", 3))
self.typing1 = NamedOpetope.Type([NamedOpetope.Term()])
self.typing2 = NamedOpetope.Type([self.term1, NamedOpetope.Term()])
self.typing3 = NamedOpetope.Type(
[self.term2, self.term1,
NamedOpetope.Term()])
self.typing4 = NamedOpetope.Type(
[self.term3, self.term2, self.term1,
NamedOpetope.Term()])
self.ctx1 = NamedOpetope.Context()
self.ctx2 = self.ctx1 + NamedOpetope.Typing(self.term1, self.typing1)
self.ctx3 = self.ctx2 + NamedOpetope.Typing(self.term2, self.typing2)
self.ctx4 = self.ctx3 + NamedOpetope.Typing(self.term3, self.typing3)
self.ctx5 = self.ctx4 + NamedOpetope.Typing(self.term4, self.typing4)
def setUp(self):
self.a1 = NamedOpetope.Variable("a1", 0)
self.b1 = NamedOpetope.Variable("b1", 0)
self.c1 = NamedOpetope.Variable("c1", 0)
self.a2 = NamedOpetope.Variable("a2", 0)
self.b2 = NamedOpetope.Variable("b2", 0)
self.c2 = NamedOpetope.Variable("c2", 0)
self.f = NamedOpetope.Variable("f", 1)
self.g = NamedOpetope.Variable("g", 1)
self.h = NamedOpetope.Variable("h", 1)
self.i = NamedOpetope.Variable("h", 1)
ctx = NamedOpetope.Context() + \
NamedOpetope.Typing(
NamedOpetope.Term(self.a1),
NamedOpetope.Type([NamedOpetope.Term()])) + \
NamedOpetope.Typing(
NamedOpetope.Term(self.b1),
NamedOpetope.Type([NamedOpetope.Term()])) + \
NamedOpetope.Typing(
NamedOpetope.Term(self.c1),
NamedOpetope.Type([NamedOpetope.Term()])) + \
NamedOpetope.Typing(
NamedOpetope.Term(self.f),
NamedOpetope.Type(
[NamedOpetope.Term(self.a2),
NamedOpetope.Term()])) + \
NamedOpetope.Typing(
NamedOpetope.Term(self.g),
NamedOpetope.Type(
[NamedOpetope.Term(self.b2), NamedOpetope.Term()])) + \
NamedOpetope.Typing(
NamedOpetope.Term(self.h),
NamedOpetope.Type(
[NamedOpetope.Term(self.c2), NamedOpetope.Term()]))
eqth = NamedOpetope.EquationalTheory() + \
(self.b1, self.b2) + \
(self.c1, self.c2) + \
(self.h, self.i)
self.sequent = NamedOpetope.Sequent(eqth, ctx, None)
self.fg = self.sequent.graft(NamedOpetope.Term(self.g), self.b2,
NamedOpetope.Term(self.f))
self.gh = self.sequent.graft(NamedOpetope.Term(self.h), self.c2,
NamedOpetope.Term(self.g))
self.fgh1 = self.sequent.graft(self.gh, self.b2,
NamedOpetope.Term(self.f))
self.fgh2 = self.sequent.graft(NamedOpetope.Term(self.h), self.c2,
self.fg)
def test_point(self):
s = NamedOpetope.point("x")
self.assertEqual(s.typing.term,
NamedOpetope.Term(NamedOpetope.Variable("x", 0)))
self.assertEqual(len(s.context), 1)
def test_substitute(self):
res = self.sequent.substitute(self.fg, self.gh, self.g)
self.assertIs(res[1], None)
self.assertEqual(res[0], self.fgh1)
res = self.sequent.substitute(self.gh, self.fg, self.g)
self.assertEqual(res[0], self.fgh1)
self.assertIs(res[1], None)
res = self.sequent.substitute(NamedOpetope.Term(self.f),
NamedOpetope.Term(self.f), self.f)
self.assertEqual(res[0], NamedOpetope.Term(self.f))
self.assertIs(res[1], None)
res = self.sequent.substitute(NamedOpetope.Term(self.f),
NamedOpetope.Term(self.fg), self.f)
self.assertEqual(res[0], NamedOpetope.Term(self.fg))
self.assertIs(res[1], None)
res = self.sequent.substitute(NamedOpetope.Term(self.f),
NamedOpetope.Term(self.fg), self.g)
self.assertEqual(res[0], NamedOpetope.Term(self.f))
self.assertIs(res[1], None)
res = self.sequent.substitute(NamedOpetope.Term(self.f),
NamedOpetope.Term(self.fgh1), self.f)
self.assertEqual(res[0], NamedOpetope.Term(self.fgh1))
self.assertIs(res[1], None)
res = self.sequent.substitute(self.fgh1,
NamedOpetope.Term(self.c1, True), self.g)
self.assertEqual(
res[0],
self.sequent.graft(NamedOpetope.Term(self.h), self.c2,
NamedOpetope.Term(self.f)))
res = self.sequent.substitute(self.fgh1,
NamedOpetope.Term(self.b1, True), self.f)
self.assertTrue(self.sequent.equal(res[0], self.gh))
def test_source(self):
with self.assertRaises(DerivationError):
self.ctx5.source(NamedOpetope.Variable("A", 3), -1)
with self.assertRaises(DerivationError):
self.ctx5.source(NamedOpetope.Variable("A", 3), 5)
self.assertEqual(self.ctx5.source(NamedOpetope.Variable("A", 3), 0),
NamedOpetope.Term(NamedOpetope.Variable("A", 3)))
self.assertEqual(self.ctx5.source(NamedOpetope.Variable("A", 3), 1),
NamedOpetope.Term(NamedOpetope.Variable("α", 2)))
self.assertEqual(self.ctx5.source(NamedOpetope.Variable("A", 3), 2),
NamedOpetope.Term(NamedOpetope.Variable("f", 1)))
self.assertEqual(self.ctx5.source(NamedOpetope.Variable("A", 3), 3),
NamedOpetope.Term(NamedOpetope.Variable("a", 0)))
self.assertEqual(self.ctx5.source(NamedOpetope.Variable("A", 3), 4),
NamedOpetope.Term())
