//Generates a new premise as a result of performing Modus Tolens on the two input premises.
public Premise ModusTolens(Premise a, Premise b)
{
Premise negated;
switch (a.type)
{
case 5:
if (a.negated._Equals(b.cons))
{
negated = new Premise(b.anti);
return(negated);
}
else
{
return(null);
}
case 1:
if (b.negated._Equals(a.cons))
{
negated = new Premise(a.anti);
return(negated);
}
else
{
return(null);
}
default:
return(null);
}
}
//Generates a new premise as the result of performing a DNI on the input premise.
public Premise DNI(Premise a)
{
var newPremiseInner = new Premise(a);
var newPremiseOuter = new Premise(newPremiseInner);
return(newPremiseOuter);
}
//Takes the input tokens and generates premise array;
public Premise[] SetInputPremises(string[] tokens, Argument argument)
{
var premises = new Premise[tokens.Length - 1];
for (var i = 1; i < tokens.Length; i++)
{
try
{
premises[i - 1] = inventory[Convert.ToInt32(tokens[i])];
}
catch (Exception)
{
try
{
if (tokens[i].Substring(0, 2).Equals("PR", StringComparison.CurrentCultureIgnoreCase))
{
premises[i - 1] = argument.premises[Convert.ToInt32(tokens[i].Substring(2)) - 1];
}
}
catch (Exception)
{
Console.WriteLine("Premise input must begin with 'PR' or be an integer.");
return(null);
}
}
}
return(premises);
}
public Premise MTP(Premise a, Premise b)
{
Premise returnPremise = null;
if (a.type == 5 && b.type == 4)
{
if (a.negated._Equals(b.child1))
{
returnPremise = b.child2;
}
else if (a.negated._Equals(b.child2))
{
returnPremise = b.child1;
}
return(returnPremise);
}
else if (a.type == 4 && b.type == 5)
{
if (b.negated._Equals(a.child1))
{
returnPremise = a.child2;
}
else if (b.negated._Equals(a.child2))
{
returnPremise = a.child1;
}
return(returnPremise);
}
else
{
return(returnPremise);
}
}
public Premise MC1(Premise a, string b)
{
var MCAnticedent = problemConstructor.MakeCustom(b);
var newPremise = new Premise(1, MCAnticedent, a);
return(newPremise);
}
//Prints the Show statement with a list of currently generated premises at the users disposal.
public void ListSheet(Premise Prem)
{
Console.WriteLine("Show: " + Prem.GetPremise());
for (var i = 0; i < inventory.Count; i++)
{
Console.WriteLine(Convert.ToString(i) + ": " + inventory[i].GetPremise());
}
}
public Premise MC2(Premise a, string b)
{
var MCConsequent = problemConstructor.MakeCustom(b);
var MCAnticedent = a.negated;
var newPremise = new Premise(1, MCAnticedent, MCConsequent);
return(newPremise);
}
//Checks to make sure that DNE can be performed on the particular premise.
public bool DNECheck(Premise a)
{
if (a.type == 5 && a.negated.type == 5)
{
return(true);
}
return(false);
}
//Makes sure that a generated premise is the same as the show premise.
public bool DDCheck(Premise a, Premise b)
{
if (a._Equals(b))
{
return(true);
}
return(false);
}
//Checks to make sure that MP can be performed on these particular premises.
public bool MPCheck(Premise a, Premise b)
{
if (a.type == 1 || b.type == 1)
{
return(true);
}
return(false);
}
//Checks to make sure that MT can be performed on these particular premises.
public bool MTCheck(Premise a, Premise b)
{
if ((a.type == 5 && b.type == 1) || (a.type == 1 && b.type == 5))
{
return(true);
}
return(false);
}
public Premise BCR(Premise a)
{
if (a.type != 2)
{
return(null);
}
else
{
var newPremise = new Premise(1, a.child2, a.child1);
return(newPremise);
}
}
public Premise AddL(Premise a)
{
Console.Write("New Addition:");
var inString = Console.ReadLine();
var newAddition = problemConstructor.MakeCustom(inString);
if (newAddition == null)
{
return(null);
}
else
{
var newPremise = new Premise(4, newAddition, a);
return(newPremise);
}
}
public Premise CB(Premise a, Premise b)
{
if (a.type != 1 || b.type != 1)
{
return(null);
}
else if (a.anti._Equals(b.cons) && b.anti._Equals(a.cons))
{
var newPremise = new Premise(2, a.anti, b.anti);
return(newPremise);
}
else
{
return(null);
}
}
//Recursively compares two premises to make sure their contents are equal.
public bool _Equals(Premise a)
{
if (this.type == a.type)
{
switch (this.type)
{
case 0:
if (this.atomic == a.atomic)
{
return(true);
}
break;
case 1:
if (this.anti._Equals(a.anti) && this.cons._Equals(a.cons))
{
return(true);
}
break;
case 2:
case 3:
case 4:
if (this.child1._Equals(a.child1) && this.child2._Equals(a.child2))
{
return(true);
}
break;
case 5:
if (this.negated._Equals(a.negated))
{
return(true);
}
break;
default:
return(false);
}
}
else
{
return(false);
}
return(false);
}
//Conditional, biconditional, AND, and OR constructor.
//1: Conditional, 2:Biconditional, 3:AND, 4:OR
public Premise(int typeInput, Premise a, Premise b)
{
type = typeInput;
switch (type)
{
case 1:
anti = a;
cons = b;
break;
case 2:
case 3:
case 4:
child1 = a;
child2 = b;
break;
}
}
//Makes sure that their is a proper contradiction.
public bool IDCheck(Premise a, Premise b)
{
switch (a.type)
{
case 5:
if (a.negated._Equals(b))
{
return(true);
}
return(false);
default:
if (a._Equals(b.negated))
{
return(true);
}
return(false);
}
}
//Generates a new premise as a result of performing Modus Ponens on the two input presmises.
public Premise ModusPonens(Premise a, Premise b)
{
switch (a.type)
{
case 0:
case 2:
case 3:
case 4:
case 5:
if (a._Equals(b.anti))
{
return(b.cons);
}
else
{
return(null);
}
case 1:
if (b.type == 1 && a._Equals(b.anti))
{
return(b.cons);
}
else if (b._Equals(a.anti))
{
return(a.cons);
}
else
{
return(null);
}
default:
return(null);
}
}
public Premise Adj(Premise a, Premise b)
{
var newPremise = new Premise(3, a, b);
return(newPremise);
}
//Generates a new premise as the result of performing a DNE on the input premise.
public Premise DNE(Premise a)
{
var newPremise = a.negated.negated;
return(newPremise);
}
//Main loop for derivation of the argument's conclusion.
public bool ShowPremise(Argument argument, Premise toShow, List <Premise> mainInv)
{
redo = false;
for (var j = 0; j < mainInv.Count; j++)
{
inventory.Add(mainInv[j]);
}
for (var i = 0; i < argument.premises.Count; i++)
{
argumentPremises.Add(argument.premises[i]);
}
MainShow:
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
var notSolved = true;
string command;
while (notSolved)
{
Console.Write("Command: ");
string[] tokens = Console.ReadLine().Split(' ');
command = tokens[0];
switch (command)
{
case "help":
writer.ReadWholeFile("textFiles/helpShow.txt");
goto MainShow;
case "exit":
inventory.Clear();
assumeCounter = 0;
return(false);
case "redo":
inventory.Clear();
assumeCounter = 0;
redo = true;
return(false);
//Modus Ponens
case "MP":
case "mp":
var inMP = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 3))
{
break;
}
inMP = this.SetInputPremises(tokens, argument);
if (inMP == null)
{
break;
}
if (!rules.MPCheck(inMP[0], inMP[1]))
{
Console.WriteLine("Cannot perform this rule on these premises");
break;
}
var resultPremise = rules.ModusPonens(inMP[0], inMP[1]);
if (resultPremise == null)
{
break;
}
inventory.Add(resultPremise);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
//Modus Tolens
case "MT":
case "mt":
var inMT = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 3))
{
break;
}
inMT = this.SetInputPremises(tokens, argument);
if (inMT == null)
{
break;
}
if (!rules.MTCheck(inMT[0], inMT[1]))
{
Console.WriteLine("Cannot perform this rule on these premises");
break;
}
var MTresultPremise = rules.ModusTolens(inMT[0], inMT[1]);
if (MTresultPremise == null)
{
break;
}
inventory.Add(MTresultPremise);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
//Double Negation generic
case "DN":
case "dn":
var inDN = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
inDN = this.SetInputPremises(tokens, argument);
if (inDN == null)
{
break;
}
if (rules.DNECheck(inDN[0]))
{
inventory.Add(rules.DNE(inDN[0]));
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
}
else
{
inventory.Add(rules.DNI(inDN[0]));
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
}
//DNE specific
case "DNE":
case "dne":
var inDNE = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
inDNE = this.SetInputPremises(tokens, argument);
if (inDNE == null)
{
break;
}
if (rules.DNECheck(inDNE[0]))
{
inventory.Add(rules.DNE(inDNE[0]));
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
}
else
{
Console.WriteLine("DNE cannot be performed on that premise. Type 'help' for rule info.");
break;
}
//DNI specific
case "DNI":
case "dni":
var inDNI = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
inDNI = this.SetInputPremises(tokens, argument);
if (inDNI == null)
{
break;
}
inventory.Add(rules.DNI(inDNI[0]));
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
case "SR":
case "sr":
var inSR = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
inSR = this.SetInputPremises(tokens, argument);
if (inSR == null)
{
break;
}
inventory.Add(inSR[0].child2);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
case "SL":
case "sl":
var inSL = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
inSL = this.SetInputPremises(tokens, argument);
if (inSL == null)
{
break;
}
inventory.Add(inSL[0].child1);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
case "S":
case "s":
var inS = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
inS = this.SetInputPremises(tokens, argument);
if (inS == null)
{
break;
}
inventory.Add(inS[0].child2);
inventory.Add(inS[0].child1);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
case "AddR":
case "addr":
AddR:
var inAddR = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
inAddR = this.SetInputPremises(tokens, argument);
if (inAddR == null)
{
break;
}
var AddRPremise = rules.AddR(inAddR[0]);
if (AddRPremise == null)
{
Console.WriteLine("That is not a valid addition.");
break;
}
else
{
inventory.Add(AddRPremise);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
}
case "AddL":
case "addl":
var inAddL = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
inAddL = this.SetInputPremises(tokens, argument);
if (inAddL == null)
{
break;
}
var AddLPremise = rules.AddL(inAddL[0]);
if (AddLPremise == null)
{
Console.WriteLine("That is not a valid addition.");
break;
}
else
{
inventory.Add(AddLPremise);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
}
case "Add":
case "add":
goto AddR;
case "Adj":
case "adj":
var inAdj = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 3))
{
break;
}
inAdj = this.SetInputPremises(tokens, argument);
if (inAdj == null)
{
break;
}
inventory.Add(rules.Adj(inAdj[0], inAdj[1]));
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
case "MTP":
case "mtp":
var inMTP = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 3))
{
break;
}
inMTP = this.SetInputPremises(tokens, argument);
if (inMTP == null)
{
break;
}
var MTPPremise = rules.MTP(inMTP[0], inMTP[1]);
if (MTPPremise == null)
{
Console.WriteLine("Cannot perform this rule on these premises.");
break;
}
else
{
inventory.Add(MTPPremise);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
}
case "BCL":
case "bcl":
var inBCL = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
inBCL = this.SetInputPremises(tokens, argument);
if (inBCL == null)
{
break;
}
var BCLPremise = rules.BCL(inBCL[0]);
if (BCLPremise == null)
{
Console.WriteLine("This rule cannot be performed on that premise.");
break;
}
else
{
inventory.Add(BCLPremise);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
}
case "BCR":
case "bcr":
var inBCR = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
inBCR = this.SetInputPremises(tokens, argument);
if (inBCR == null)
{
break;
}
var BCRPremise = rules.BCR(inBCR[0]);
if (BCRPremise == null)
{
Console.WriteLine("This rule cannot be performed on that premise.");
break;
}
else
{
inventory.Add(BCRPremise);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
}
case "BC":
case "bc":
var inBC = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
inBC = this.SetInputPremises(tokens, argument);
if (inBC == null)
{
break;
}
var BCPremise1 = rules.BCL(inBC[0]);
var BCPremise2 = rules.BCR(inBC[0]);
if (BCPremise1 == null || BCPremise2 == null)
{
Console.WriteLine("This rule cannot be performed on that premise.");
break;
}
else
{
inventory.Add(BCPremise1);
inventory.Add(BCPremise2);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
}
case "CB":
case "cb":
var inCB = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 3))
{
break;
}
inCB = this.SetInputPremises(tokens, argument);
if (inCB == null)
{
break;
}
var CBPremise = rules.CB(inCB[0], inCB[1]);
if (CBPremise == null)
{
Console.WriteLine("This rule cannot be performed on that premise.");
break;
}
else
{
inventory.Add(CBPremise);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
}
case "MC1":
case "mc1":
MC1:
if (!MC1Unlocked)
{
Console.WriteLine("Solve derivation 1 of problem set 2 to unlock this rule.");
break;
}
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
var inMC1 = this.SetInputPremises(tokens, argument);
if (inMC1 == null)
{
break;
}
Console.Write("New Anticedent:");
var MC1String = Console.ReadLine();
inventory.Add(rules.MC1(inMC1[0], MC1String));
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
case "MC2":
case "mc2":
MC2:
if (!MC2Unlocked)
{
Console.WriteLine("Solve derivation 17 of problem set 2 to unlock this rule.");
break;
}
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
var inMC2 = this.SetInputPremises(tokens, argument);
if (inMC2 == null)
{
break;
}
Console.Write("New Consequent:");
var MC2String = Console.ReadLine();
inventory.Add(rules.MC2(inMC2[0], MC2String));
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
case "MC":
case "mc":
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
var inMC = this.SetInputPremises(tokens, argument);
if (inMC == null)
{
break;
}
if (inMC[0].type == 5)
{
goto MC2;
}
else
{
goto MC1;
}
case "Show":
Show:
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
var problemConstructor = new ProblemConstructor();
var newPremise = problemConstructor.MakeCustom(tokens[1]);
if (newPremise == null)
{
Console.WriteLine("Invalid premise");
break;
}
var newShow = new Show(userID);
if (newShow.ShowPremise(argument, newPremise, inventory))
{
inventory.Add(newPremise);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
break;
}
else if (newShow.GetRedo())
{
inventory.Clear();
assumeCounter = 0;
redo = true;
return(false);
}
break;
//Assume CD or ID
case "ASS":
case "ass":
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
if (assumeCounter > 0)
{
Console.WriteLine("Only 1 assume statement can be made per Show statement.");
break;
}
if (tokens[1].Equals("ID", StringComparison.CurrentCultureIgnoreCase))
{
inventory.Add(new Premise(toShow));
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
assumeCounter++;
break;
}
else if (tokens[1].Equals("CD", StringComparison.CurrentCultureIgnoreCase))
{
if (toShow.type == 1)
{
inventory.Add(toShow.anti);
Console.WriteLine(argument.GetArgument());
this.ListSheet(toShow);
assumeCounter++;
break;
}
else
{
Console.WriteLine("Argument's conlusion must be conditional in order to perform a conditional derivation");
break;
}
}
else
{
Console.WriteLine("ASS must be followed by CD or ID only.");
break;
}
//closing the ID
case "ID":
case "id":
//decides whether input is from lines or argument
var inID = new Premise[tokens.Length - 1];
if (!this.CheckTokenLength(tokens, 3))
{
break;
}
inID = this.SetInputPremises(tokens, argument);
if (inID == null)
{
break;
}
if (rules.IDCheck(inID[0], inID[1]))
{
assumeCounter--;
inventory.Clear();
return(true);
}
else
{
Console.WriteLine("Nope! Try again.");
break;
}
//direct derivation
case "DD":
case "dd":
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
try
{
var temp = Convert.ToInt32(tokens[1]);
if (inventory[temp]._Equals(toShow))
{
inventory.Clear();
return(true);
}
else
{
Console.WriteLine("Nope! Try again.");
break;
}
}
catch (Exception)
{
Console.WriteLine("Error: Premise must be a reference to a line");
break;
}
case "CD":
case "cd":
if (!this.CheckTokenLength(tokens, 2))
{
break;
}
try
{
var temp = Convert.ToInt32(tokens[1]);
if (inventory[temp]._Equals(toShow.cons))
{
assumeCounter--;
inventory.Clear();
return(true);
}
else
{
Console.WriteLine("Nope! Try again.");
break;
}
}
catch (Exception)
{
if (tokens[1].Contains("PR"))
{
try
{
if (argument.premises[Convert.ToInt32(tokens[1].Substring(2)) - 1]._Equals(toShow.cons))
{
return(true);
}
}
catch (Exception e)
{
Console.WriteLine("That is not a premise.");
Console.WriteLine(e);
break;
}
}
Console.WriteLine("Error: Premise must be a reference to a line");
break;
}
default:
if (command.Equals("show", StringComparison.CurrentCultureIgnoreCase))
{
goto Show;
}
Console.WriteLine("bad input: enter 'help' for more information.");
break;
}
}
return(true);
}
//Parses the input string and makes nested Premises out of string.
public Premise MakeCustom(string inputString)
{
var objectString = new List <string>();
var count = 0;
var unbracketed = "";
Premise newPremise;
if (inputString.Length == 1)
{
if (this.IsValidAtomic(inputString))
{
newPremise = new Premise(inputString);
return(newPremise);
}
else
{
return(null);
}
}
else
{
if (inputString.Contains("("))
{
var _object = "";
for (var i = 0; i < inputString.Length; i++)
{
if (inputString[i] == ')' && count == 1)
{
objectString.Add(_object);
_object = "";
count--;
unbracketed += inputString[i];
}
else if (count > 0 && inputString[i] == ')')
{
count--;
_object += inputString[i];
}
else if (inputString[i] == '(' && count == 0)
{
unbracketed += inputString[i];
count++;
}
else if (count > 0 && inputString[i] == '(')
{
count++;
_object += inputString[i];
}
else if (count > 0)
{
_object += inputString[i];
}
else if (count == 0)
{
unbracketed += inputString[i];
}
}
//For testing.
/*for (var i = 0; i < objectString.Count; i++)
* {
* Console.WriteLine(objectString[i]);
* }*/
if (unbracketed == "()")
{
return(this.MakeCustom(objectString[0]));
}
if (unbracketed.Contains("<->"))
{
var objectStringTemp = this.ConstructObjectString(inputString, unbracketed, objectString, "<->");
objectString.Clear();
objectString.Add(objectStringTemp[0]);
objectString.Add(objectStringTemp[1]);
}
else if (unbracketed.Contains("->"))
{
var objectStringTemp = this.ConstructObjectString(inputString, unbracketed, objectString, "->");
objectString.Clear();
objectString.Add(objectStringTemp[0]);
objectString.Add(objectStringTemp[1]);
}
else if (unbracketed.Contains("v"))
{
var objectStringTemp = this.ConstructObjectString(inputString, unbracketed, objectString, "v");
objectString.Clear();
objectString.Add(objectStringTemp[0]);
objectString.Add(objectStringTemp[1]);
}
else if (unbracketed.Contains("^"))
{
var objectStringTemp = this.ConstructObjectString(inputString, unbracketed, objectString, "^");
objectString.Clear();
objectString.Add(objectStringTemp[0]);
objectString.Add(objectStringTemp[1]);
}
}
else
{
string[] tokens;
if (inputString.Contains("<->"))
{
tokens = inputString.Split("<->");
objectString.Add(tokens[0]);
objectString.Add(tokens[1]);
unbracketed = "<->";
}
else if (inputString.Contains("->"))
{
tokens = inputString.Split("->");
objectString.Add(tokens[0]);
objectString.Add(tokens[1]);
unbracketed = "->";
}
else if (inputString.Contains("v"))
{
tokens = inputString.Split("v");
objectString.Add(tokens[0]);
objectString.Add(tokens[1]);
unbracketed = "v";
}
else if (inputString.Contains("^"))
{
tokens = inputString.Split("^");
objectString.Add(tokens[0]);
objectString.Add(tokens[1]);
unbracketed = "^";
}
else if (inputString.Contains("~"))
{
objectString.Add(inputString.Substring(inputString.Length - 1));
for (var i = 0; i < inputString.Length - 1; i++)
{
unbracketed += inputString[i];
}
}
}
}
//Testing
/*
* for (var i = 0; i < objectString.Count; i++)
* {
* Console.WriteLine(objectString[i]);
* }
* Console.WriteLine(unbracketed);
* Console.WriteLine(objectString.Count);*/
//Deal with basic negation cases
if (objectString.Count == 1 && unbracketed.Contains("~"))
{
var negationCounter = 0;
for (var i = 0; i < unbracketed.Length; i++)
{
if (unbracketed[i] == '~')
{
negationCounter++;
}
}
if (negationCounter == 1 && (unbracketed.Contains("(") || unbracketed.Length == 1))
{
var negatedPremise = MakeCustom(objectString[0]);
newPremise = new Premise(negatedPremise);
return(newPremise);
}
else if (negationCounter > 1 && unbracketed.Contains("("))
{
objectString[0] = "(" + objectString[0] + ")";
for (var i = negationCounter - 1; i > 0; i--)
{
objectString[0] = "~" + objectString[0];
}
var negatedPremise = MakeCustom(objectString[0]);
newPremise = new Premise(negatedPremise);
return(newPremise);
}
else
{
for (var i = negationCounter - 1; i > 0; i--)
{
objectString[0] = "~" + objectString[0];
}
var negatedPremise = MakeCustom(objectString[0]);
newPremise = new Premise(negatedPremise);
return(newPremise);
}
}
//More Testing
/*for (var i=0;i<objectString.Count;i++)
* {
* Console.WriteLine(objectString[i]);
* }*/
//testing
//Console.WriteLine(objectString[1]);
//Deal with conditional, biconditional, AND, and OR
if (unbracketed.Contains("<->"))
{
var childA = MakeCustom(objectString[0]);
var childB = MakeCustom(objectString[1]);
newPremise = new Premise(2, childA, childB);
return(newPremise);
}
else if (unbracketed.Contains("->"))
{
var anticedent = MakeCustom(objectString[0]);
var consequent = MakeCustom(objectString[1]);
newPremise = new Premise(1, anticedent, consequent);
return(newPremise);
}
else if (unbracketed.Contains("^"))
{
var childA = MakeCustom(objectString[0]);
var childB = MakeCustom(objectString[1]);
newPremise = new Premise(3, childA, childB);
return(newPremise);
}
else if (unbracketed.Contains("v"))
{
var childA = MakeCustom(objectString[0]);
var childB = MakeCustom(objectString[1]);
newPremise = new Premise(4, childA, childB);
return(newPremise);
}
Console.WriteLine("Bad Premise.");
return(null);
//For testing purposes
/*for (var i = 0; i < objectString.Count; i++)
* {
* Console.WriteLine(objectString[i]);
* }
* Console.WriteLine(unbracketed);*/
} //End of MakeCustom method.
//Negation constructor.
public Premise(Premise a)
{
type = 5;
negated = a;
}
public ProblemSet(int problemSet, string userID)
{
show = new Show(userID);
WorkingWithConditionals:
while (stillRunning)
{
var solved = saveCloud.GetSolved(problemSet, userID, saveCloud.GetArgumentListLength(problemSet));
Console.WriteLine("Choose an argument to derive:");
Loop1:
var argumentDisplay = saveCloud.GetArgumentDisplay(problemSet);
var upTo = argumentDisplay.Length - 1;
for (var i = 0; i <= upTo; i++)
{
if (problemSet == 2 && i == 1)
{
Console.WriteLine("Material Conditional 1: Solve the following derivation to unlock the MC1 rule.");
}
if (problemSet == 2 && i == 17)
{
Console.WriteLine("Material Conditional 2: Solve the following derivation to unlock the MC2 rule.");
}
if (solved[i] == true)
{
Console.WriteLine(i + ": " + argumentDisplay[i] + " (Solved)");
}
else
{
Console.WriteLine(i + ": " + argumentDisplay[i]);
}
}
Console.Write("Choice:");
var choice = Console.ReadLine();
var choiceInt = 0;
try
{
choiceInt = Convert.ToInt32(choice);
}
catch (Exception)
{
switch (choice)
{
case "help":
writer.ReadWholeFile("textFiles/helpShow.txt");
goto Loop1;
case "exit":
stillRunning = false;
goto Done;
//For constructing levels during development
case "make-argument":
Console.WriteLine("Into which problem Set?");
Console.Write("Choice:");
saveCloud.InsertArgument(Convert.ToInt32(Console.ReadLine()));
goto WorkingWithConditionals;
default:
Console.WriteLine("That is not a valid choice. Try again.");
//Console.WriteLine(e); //testing
goto Loop1;
}
}
problemConstructor = new ProblemConstructor(problemSet, choiceInt);
currentArgument = problemConstructor.argument;
Console.WriteLine("Type 'help' at any time to read about commands.");
Console.WriteLine("Type 'redo' to restart the derivation at any time.");
Console.WriteLine("Type 'exit' at any time to exit.");
Console.WriteLine(currentArgument.GetArgument());
Console.Write("Command: ");
string[] tokens = Console.ReadLine().Split(' ');
var command = tokens[0];
switch (command)
{
case "help":
writer.ReadWholeFile("textFiles/helpShow.txt");
break;
case "exit":
break;
case "Show":
Show:
if (!show.CheckTokenLength(tokens, 2))
{
Console.WriteLine("Show statement must be followed by one command.");
break;
}
switch (tokens[1])
{
case "C":
case "c":
Redo:
if (show.ShowPremise(currentArgument, currentArgument.conclusion, mainInventory))
{
Console.WriteLine("Solved!");
solved[Convert.ToInt32(choice)] = true;
saveCloud.MakeSolvedTrue(problemSet, userID, Convert.ToInt32(choice));
show.CheckRuleLocks();
mainInventory.Clear();
break;
}
else if (show.GetRedo())
{
goto Redo;
}
else
{
stillRunning = false;
break;
}
default:
Premise custom = problemConstructor.MakeCustom(tokens[1]);
if (custom == null)
{
Console.WriteLine("Bad Premise. Try again.");
break;
}
if (show.ShowPremise(currentArgument, custom, mainInventory))
{
if (custom._Equals(currentArgument.conclusion))
{
Console.WriteLine("Solved!");
solved[Convert.ToInt32(choice)] = true;
saveCloud.MakeSolvedTrue(problemSet, userID, Convert.ToInt32(choice));
show.CheckRuleLocks();
mainInventory.Clear();
break;
}
else
{
mainInventory.Add(custom);
Console.WriteLine(custom.GetPremise() + " " + currentArgument.conclusion.GetPremise());
break;
}
}
break;
}
break;
default:
if (command.Equals("show", StringComparison.CurrentCultureIgnoreCase))
{
goto Show;
}
Console.WriteLine("Unrecognized input. type 'help' for more information.");
break;
}
}
Done :;
}
public Argument(List <Premise> premisesInput, Premise conclusionInput)
{
premises = premisesInput;
conclusion = conclusionInput;
}
