@Override
public Transform visit(FQLProgram env, Whisker e) {
Functor F = e.func.accept(env, this);
Transform T = e.trans.accept(env, this);
if (e.left) {
return Transform.leftWhisker(F, T);
} else {
return Transform.rightWhisker(F, T);
}
}
@Override
public Transform visit(FQLProgram env, fql_lib.decl.TransExp.Comp e) {
Transform l = e.l.accept(env, this);
Transform r = e.r.accept(env, this);
return Transform.compose(l, r);
}
@Override
public Transform visit(FQLProgram env, fql_lib.decl.TransExp.Id e) {
Functor ff = e.t.accept(env, this);
return Transform.id(ff);
}
@Override
public Functor visit(FQLProgram env, Pushout e) {
Transform l = ENV.trans.get(e.l);
if (l == null) {
throw new RuntimeException("Missing transform: " + e.l);
}
Transform r = ENV.trans.get(e.r);
if (r == null) {
throw new RuntimeException("Missing transform: " + e.r);
}
if (!l.source.equals(r.source)) {
throw new RuntimeException("Source functors do not match.");
}
Category<Object, Object> D = l.source.source;
Set<String> objects = new HashSet<>();
objects.add("A");
objects.add("B");
objects.add("C");
Set<String> arrows = new HashSet<>();
arrows.add("f");
arrows.add("g");
arrows.add("a");
arrows.add("b");
arrows.add("c");
Map<String, String> sources = new HashMap<>();
sources.put("f", "A");
sources.put("g", "A");
sources.put("a", "A");
sources.put("b", "B");
sources.put("c", "C");
Map<String, String> targets = new HashMap<>();
targets.put("f", "B");
targets.put("g", "C");
targets.put("a", "A");
targets.put("b", "B");
targets.put("c", "C");
Map<Pair<String, String>, String> composition = new HashMap<>();
composition.put(new Pair<>("a", "a"), "a");
composition.put(new Pair<>("b", "b"), "b");
composition.put(new Pair<>("c", "c"), "c");
composition.put(new Pair<>("a", "f"), "f");
composition.put(new Pair<>("a", "g"), "g");
composition.put(new Pair<>("f", "b"), "f");
composition.put(new Pair<>("g", "c"), "g");
Map<String, String> identities = new HashMap<>();
identities.put("A", "a");
identities.put("B", "b");
identities.put("C", "c");
Category<String, String> span =
new FiniteCategory<>(objects, arrows, sources, targets, composition, identities);
Category<Pair<Object, String>, Pair<Object, String>> Dspan = FinCat.FinCat.product(D, span);
Functor<Pair<Object, String>, Pair<Object, String>, Object, Object> fst =
FinCat.FinCat.first(D, span);
FUNCTION<Pair<Object, String>, Set> o =
p -> {
if (p.second.equals("A")) {
return (Set) l.source.applyO(p.first);
} else if (p.second.equals("B")) {
return (Set) l.target.applyO(p.first);
} else if (p.second.equals("C")) {
return (Set) r.target.applyO(p.first);
} else {
throw new RuntimeException();
}
};
FUNCTION<Pair<Object, String>, Fn> x =
fp -> {
Object f = fp.first;
String p = fp.second;
Object a = D.source(f);
Object b = D.target(f);
String i = span.source(p);
String j = span.target(p);
Functor I = i == "A" ? l.source : i == "B" ? l.target : r.target;
Functor J = j == "A" ? l.source : j == "B" ? l.target : r.target;
Fn If = (Fn) I.applyA(f);
Fn Jf = (Fn) J.applyA(f);
Transform P =
p == "f"
? l
: p == "g"
? r
: p == "a"
? Transform.id(l.source)
: p == "b" ? Transform.id(l.target) : Transform.id(r.target);
Fn Pb = (Fn) P.apply(b);
Fn Pa = (Fn) P.apply(a);
return Fn.compose(Pa, Jf);
/* if (p.second.equals("f")) {
return (Fn) l.apply(p.first);
} else if (p.second.equals("g")) {
return (Fn) r.apply(p.first);
} else if (p.second.equals("a")) {
return (Fn) l.source.applyA(p.first); //Fn.id(o.apply(new Pair<>(p.first, "A")));
} else if (p.second.equals("b")) {
return (Fn) l.target.applyA(p.first); //Fn.id(o.apply(new Pair<>(p.first, "B")));
} else if (p.second.equals("c")) {
return (Fn) r.target.applyA(p.first); //Fn.id(o.apply(new Pair<>(p.first, "C")));
} else {
throw new RuntimeException();
} */
};
Functor I = new Functor(Dspan, FinSet.FinSet(), o, x);
return FDM.sigmaF(fst).applyO(I);
}
@Override
public Transform visit(FQLProgram env, PeterApply e) {
Transform t = e.t.accept(env, this);
Signature.Node n = t.source.source.toSig().new Node(e.node);
return (Transform) t.apply(n);
}
@Override
public Transform visit(FQLProgram env, ApplyTrans e) {
Transform F = e.F.accept(env, this);
Functor I = e.I.accept(env, this);
return (Transform) F.apply(I);
}