public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal[] outputs = new Signal[manipulatedInputs.Count];
ReadOnlySignalSet squares = b.Square(port.OutputSignals);
Signal one = IntegerValue.ConstantOne(context);
for(int i = 0; i < outputs.Length; i++)
outputs[i] = (one + squares[i]) * manipulatedInputs[i];
return b.Negate(outputs);
});
theorems[1] = new BasicTransformation("CotangentTrigonometricSusbtitute", "Std", "TrigonometricSubstitute", "Std",
delegate(Port port) { return port.Entity.EntityId.Equals("Cotangent", "Std"); },
delegate(Port port) { return ManipulationPlan.DoAlter; },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
Signal[] ret = new Signal[transformedInputs.Count];
for(int i = 0; i < ret.Length; i++)
ret[i] = Std.Cosine(port.Context, transformedInputs[i]) / Std.Sine(port.Context, transformedInputs[i]);
return ret;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal[] outputs = new Signal[manipulatedInputs.Count];
ReadOnlySignalSet cotangents = Std.Cotangent(context, port.InputSignals);
for(int i = 0; i < outputs.Length; i++)
outputs[i] = b.MultiplySimplified(port.OutputSignals[i], cotangents[i], manipulatedInputs[i]);
return b.Negate(outputs);
});
theorems[1] = new BasicTransformation(_entityId.DerivePostfix("TrigonometricSubstitute"), new MathIdentifier("TrigonometricSubstitute", "Std"),
delegate() { return new Pattern(new EntityCondition(_entityId)); },
delegate(Port port) { return ManipulationPlan.DoAlter; },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
return port.Context.Builder.Invert(Std.Sine(port.Context, transformedInputs));
//Signal[] ret = new Signal[transformedInputs.Count];
//for(int i = 0; i < ret.Length; i++)
// ret[i] = port.Context.Builder.Invert(Std.Sine(port.Context, transformedInputs[i]));
//return ret;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal[] outputs = new Signal[manipulatedInputs.Count];
ReadOnlySignalSet cotangents = Std.Cotangent(context, port.InputSignals);
for (int i = 0; i < outputs.Length; i++)
{
outputs[i] = b.MultiplySimplified(port.OutputSignals[i], cotangents[i], manipulatedInputs[i]);
}
return(b.Negate(outputs));
});
theorems[1] = new BasicTransformation("CosecantTrigonometricSusbtitute", "Std", "TrigonometricSubstitute", "Std",
delegate(Port port) { return(port.Entity.EntityId.Equals("Cosecant", "Std")); },
delegate(Port port) { return(ManipulationPlan.DoAlter); },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
return(port.Context.Builder.Invert(Std.Sine(port.Context, transformedInputs)));
//Signal[] ret = new Signal[transformedInputs.Count];
//for(int i = 0; i < ret.Length; i++)
// ret[i] = port.Context.Builder.Invert(Std.Sine(port.Context, transformedInputs[i]));
//return ret;
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
ReadOnlySignalSet squares = b.Square(port.OutputSignals);
Signal one = IntegerValue.ConstantOne(context);
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add((one + squares[i]) * manipulatedInputs[i]);
return outputs;
});
theorems[1] = new BasicTransformation(_entityId.DerivePostfix("TrigonometricSubstitute"), new MathIdentifier("TrigonometricSubstitute", "Std"),
delegate() { return new Pattern(new EntityCondition(_entityId)); },
delegate(Port port) { return ManipulationPlan.DoAlter; },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
Signal[] ret = new Signal[transformedInputs.Count];
for(int i = 0; i < ret.Length; i++)
ret[i] = Std.Sine(port.Context, transformedInputs[i]) / Std.Cosine(port.Context, transformedInputs[i]);
return ret;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal[] outputs = new Signal[manipulatedInputs.Count];
ReadOnlySignalSet squares = b.Square(port.OutputSignals);
Signal one = IntegerValue.ConstantOne(context);
for (int i = 0; i < outputs.Length; i++)
{
outputs[i] = (one + squares[i]) * manipulatedInputs[i];
}
return(b.Negate(outputs));
});
theorems[1] = new BasicTransformation("CotangentTrigonometricSusbtitute", "Std", "TrigonometricSubstitute", "Std",
delegate(Port port) { return(port.Entity.EntityId.Equals("Cotangent", "Std")); },
delegate(Port port) { return(ManipulationPlan.DoAlter); },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
Signal[] ret = new Signal[transformedInputs.Count];
for (int i = 0; i < ret.Length; i++)
{
ret[i] = Std.Cosine(port.Context, transformedInputs[i]) / Std.Sine(port.Context, transformedInputs[i]);
}
return(ret);
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
return new SignalSet(context.Builder.SubtractSimplified(manipulatedInputs));
});
theorems[1] = new Algebra.AutoSimplifyTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port)
{
// TODO
return ManipulationPlan.DoAlter;
},
delegate(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs)
{
if(SimplifySummands(manipulatedInputs) || hasManipulatedInputs)
{
if(manipulatedInputs.Count == 0)
return new SignalSet(StdPackage.Structures.IntegerValue.ConstantAdditiveIdentity(context));
if(manipulatedInputs.Count == 1)
return manipulatedInputs;
return new SignalSet(context.Builder.Subtract(manipulatedInputs));
}
else
return port.OutputSignals;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
ReadOnlySignalSet squares = b.Square(port.OutputSignals);
Signal one = IntegerValue.ConstantOne(context);
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add((one + squares[i]) * manipulatedInputs[i]);
}
return(outputs);
});
theorems[1] = new BasicTransformation(_entityId.DerivePostfix("TrigonometricSubstitute"), new MathIdentifier("TrigonometricSubstitute", "Std"),
delegate() { return(new Pattern(new EntityCondition(_entityId))); },
delegate(Port port) { return(ManipulationPlan.DoAlter); },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
Signal[] ret = new Signal[transformedInputs.Count];
for (int i = 0; i < ret.Length; i++)
{
ret[i] = Std.Sine(port.Context, transformedInputs[i]) / Std.Cosine(port.Context, transformedInputs[i]);
}
return(ret);
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
int cnt = manipulatedInputs.Count - 1;
Builder b = context.Builder;
Signal[] multiplySignals = new Signal[cnt];
Signal[] addSignals = new Signal[cnt];
for (int i = 0; i < cnt; i++)
{
multiplySignals[i] = port.InputSignals[i + 1];
}
Signal left = b.DivideSimplified(manipulatedInputs[0], multiplySignals);
for (int i = 0; i < cnt; i++)
{
for (int j = 0; j < cnt; j++)
{
multiplySignals[j] = i == j ? b.Square(port.InputSignals[j + 1]) : port.InputSignals[j + 1];
}
Signal num = b.MultiplySimplified(port.InputSignals[0], manipulatedInputs[i + 1]);
addSignals[i] = b.DivideSimplified(num, multiplySignals);
}
return(new SignalSet(b.SubtractSimplified(left, addSignals)));
});
theorems[1] = new Algebra.AutoSimplifyTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port)
{
// TODO
return(ManipulationPlan.DoAlter);
},
delegate(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs)
{
if (SimplifyFactors(manipulatedInputs) || hasManipulatedInputs)
{
if (manipulatedInputs.Count == 0)
{
return(new SignalSet(StdPackage.Structures.IntegerValue.ConstantMultiplicativeIdentity(context)));
}
if (manipulatedInputs.Count == 1)
{
return(manipulatedInputs);
}
return(new SignalSet(context.Builder.Divide(manipulatedInputs)));
}
else
{
return(port.OutputSignals);
}
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
ReadOnlySignalSet tangents = Std.Tangent(context, port.InputSignals);
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(b.MultiplySimplified(port.OutputSignals[i], tangents[i], manipulatedInputs[i]));
}
return(outputs);
});
theorems[1] = new BasicTransformation(_entityId.DerivePostfix("TrigonometricSubstitute"), new MathIdentifier("TrigonometricSubstitute", "Std"),
delegate() { return(new Pattern(new EntityCondition(_entityId))); },
delegate(Port port) { return(ManipulationPlan.DoAlter); },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
return(port.Context.Builder.Invert(Std.Cosine(port.Context, transformedInputs)));
//Signal[] ret = new Signal[transformedInputs.Length];
//for(int i = 0; i < ret.Length; i++)
// ret[i] = port.Context.Builder.Invert(Std.Cosine(port.Context, transformedInputs[i]));
//return ret;
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
return context.Builder.Negate(manipulatedInputs);
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
return(context.Builder.Negate(manipulatedInputs));
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
int cnt = manipulatedInputs.Count;
Signal[] addSignals = new Signal[cnt];
Signal[] multiplySignals = new Signal[cnt];
for (int i = 0; i < cnt; i++)
{
for (int j = 0; j < cnt; j++)
{
multiplySignals[j] = i == j ? manipulatedInputs[j] : port.InputSignals[j];
}
addSignals[i] = context.Builder.MultiplySimplified(multiplySignals);
}
return(new SignalSet(context.Builder.AddSimplified(addSignals)));
});
theorems[1] = new Algebra.AutoSimplifyTransformation(_entityId,
delegate(Port port)
{
// TODO
return(ManipulationPlan.DoAlter);
},
delegate(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs)
{
if (SimplifyFactors(manipulatedInputs) || hasManipulatedInputs)
{
if (manipulatedInputs.Count == 0)
{
return(new SignalSet(StdPackage.Structures.IntegerValue.ConstantMultiplicativeIdentity(context)));
}
if (manipulatedInputs.Count == 1)
{
return(manipulatedInputs);
}
return(new SignalSet(context.Builder.Multiply(manipulatedInputs)));
}
else
{
return(port.OutputSignals);
}
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(manipulatedInputs[i] / port.InputSignals[i]);
return outputs;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
ReadOnlySignalSet cosines = Std.Cosine(context, port.InputSignals);
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(cosines[i] * manipulatedInputs[i]);
return outputs;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal[] outputs = new Signal[manipulatedInputs.Count];
ReadOnlySignalSet sines = Std.Sine(context, port.InputSignals);
for(int i = 0; i < outputs.Length; i++)
outputs[i] = sines[i] * manipulatedInputs[i];
return b.Negate(outputs);
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(b.Negate(b.DivideSimplified(manipulatedInputs[i], b.Square(port.InputSignals[i]))));
}
return(outputs);
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(manipulatedInputs[i] / port.InputSignals[i]);
}
return(outputs);
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
ReadOnlySignalSet cosines = Std.Cosine(context, port.InputSignals);
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(cosines[i] * manipulatedInputs[i]);
}
return(outputs);
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal[] outputs = new Signal[manipulatedInputs.Count];
ReadOnlySignalSet sines = Std.Sine(context, port.InputSignals);
for (int i = 0; i < outputs.Length; i++)
{
outputs[i] = sines[i] * manipulatedInputs[i];
}
return(b.Negate(outputs));
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal two = IntegerValue.ConstantTwo(context);
SignalSet outputs = new SignalSet();
for (int i = 0; i < manipulatedInputs.Count; i++)
{
outputs.Add(b.MultiplySimplified(two, port.InputSignals[i], manipulatedInputs[i]));
}
return(outputs);
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
return new SignalSet(manipulatedInputs);
});
theorems[1] = new Algebra.AutoSimplifyTransformation(_entityId,
delegate(Port port)
{
return ManipulationPlan.DoAlter;
},
delegate(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs)
{
return new SignalSet(manipulatedInputs);
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
return(new SignalSet(manipulatedInputs));
});
theorems[1] = new Algebra.AutoSimplifyTransformation(context.Library.LookupEntity(_entityId),
delegate(Port port)
{
return(ManipulationPlan.DoAlter);
},
delegate(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs)
{
return(new SignalSet(manipulatedInputs));
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
return(new SignalSet(context.Builder.AddSimplified(manipulatedInputs)));
});
theorems[1] = new Algebra.AutoSimplifyTransformation(_entityId,
delegate(Port port)
{
// TODO
return(ManipulationPlan.DoAlter);
},
delegate(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs)
{
if (SimplifySummands(manipulatedInputs) || hasManipulatedInputs)
{
if (manipulatedInputs.Count == 0)
{
return(new SignalSet(StdPackage.Structures.IntegerValue.ConstantAdditiveIdentity(context)));
}
if (manipulatedInputs.Count == 1)
{
return(manipulatedInputs);
}
return(new SignalSet(context.Builder.Add(manipulatedInputs)));
}
else
{
return(port.OutputSignals);
}
});
return(theorems);
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
Signal two = IntegerValue.ConstantTwo(context);
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(b.MultiplySimplified(two, port.InputSignals[i], manipulatedInputs[i]));
return outputs;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[1];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Builder b = context.Builder;
SignalSet outputs = new SignalSet();
for(int i = 0; i < manipulatedInputs.Count; i++)
outputs.Add(b.Negate(b.DivideSimplified(manipulatedInputs[i], b.Square(port.InputSignals[i]))));
return outputs;
});
return theorems;
}
public static ITheorem[] BuildTheorems(Context context)
{
ITheorem[] theorems = new ITheorem[2];
theorems[0] = new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
int cnt = manipulatedInputs.Count;
Signal[] addSignals = new Signal[cnt];
Signal[] multiplySignals = new Signal[cnt];
for(int i = 0; i < cnt; i++)
{
for(int j = 0; j < cnt; j++)
multiplySignals[j] = i == j ? manipulatedInputs[j] : port.InputSignals[j];
addSignals[i] = context.Builder.MultiplySimplified(multiplySignals);
}
return new SignalSet(context.Builder.AddSimplified(addSignals));
});
theorems[1] = new Algebra.AutoSimplifyTransformation(_entityId,
delegate(Port port)
{
// TODO
return ManipulationPlan.DoAlter;
},
delegate(Port port, SignalSet manipulatedInputs, bool hasManipulatedInputs)
{
if(SimplifyFactors(manipulatedInputs) || hasManipulatedInputs)
{
if(manipulatedInputs.Count == 0)
return new SignalSet(StdPackage.Structures.IntegerValue.ConstantMultiplicativeIdentity(context));
if(manipulatedInputs.Count == 1)
return manipulatedInputs;
return new SignalSet(context.Builder.Multiply(manipulatedInputs));
}
else
return port.OutputSignals;
});
return theorems;
}
