/// <summary>
/// Initializes a new instance of the <see cref="LoadedProblemGeneratorInput"/> class.
/// </summary>
/// <inheritdoc cref="ProblemGeneratorInput(Configuration, IReadOnlyHashSet{Construction}, int, IReadOnlyDictionary{ConfigurationObjectType, int}, bool)"/>
/// <param name="filePath"><inheritdoc cref="FilePath" path="/summary"/></param>
/// <param name="id"><inheritdoc cref="Id" path="/summary"/></param>
public LoadedProblemGeneratorInput(Configuration initialConfiguration,
IReadOnlyHashSet <Construction> constructions,
int numberOfIterations,
IReadOnlyDictionary <ConfigurationObjectType, int> maximalNumbersOfObjectsToAdd,
SymmetryGenerationMode symmetryGenerationMode,
string filePath,
string id)
: base(initialConfiguration, constructions, numberOfIterations, maximalNumbersOfObjectsToAdd, symmetryGenerationMode)
{
FilePath = filePath ?? throw new ArgumentNullException(nameof(filePath));
Id = id ?? throw new ArgumentNullException(nameof(id));
}
/// <summary>
/// Initializes a new instance of the <see cref="ProblemGeneratorInput"/> class.
/// </summary>
/// <param name="initialConfiguration"><inheritdoc cref="InitialConfiguration" path="/summary"/></param>
/// <param name="constructions"><inheritdoc cref="Constructions" path="/summary"/></param>
/// <param name="numberOfIterations"><inheritdoc cref="NumberOfIterations" path="/summary"/></param>
/// <param name="maximalNumbersOfObjectsToAdd"><inheritdoc cref="MaximalNumbersOfObjectsToAdd" path="/summary"/></param>
/// <param name="symmetryGenerationMode"><inheritdoc cref="SymmetryGenerationMode" path="/summary"/></param>
public ProblemGeneratorInput(Configuration initialConfiguration,
IReadOnlyHashSet <Construction> constructions,
int numberOfIterations,
IReadOnlyDictionary <ConfigurationObjectType, int> maximalNumbersOfObjectsToAdd,
SymmetryGenerationMode symmetryGenerationMode)
{
InitialConfiguration = initialConfiguration ?? throw new ArgumentNullException(nameof(initialConfiguration));
Constructions = constructions ?? throw new ArgumentNullException(nameof(constructions));
NumberOfIterations = numberOfIterations;
MaximalNumbersOfObjectsToAdd = maximalNumbersOfObjectsToAdd ?? throw new ArgumentNullException(nameof(maximalNumbersOfObjectsToAdd));
SymmetryGenerationMode = symmetryGenerationMode;
}
/// <summary>
/// Performs the analysis of a given generator output.
/// </summary>
/// <param name="output">The generator output to be analyzed.</param>
/// <param name="mode">Indicates how we handle asymmetric problems with regards to generation.</param>
/// <param name="constructProofs">Indicates whether we should construct proofs or not, which affects the type of result.</param>
/// <returns>The result depending on whether we're constructing proofs or not.</returns>
private dynamic Analyze(ProblemGeneratorOutput output, SymmetryGenerationMode mode, bool constructProofs)
{
// Call the prover
var proverOutput = constructProofs
// If we should construct proofs, do so
? (object)_prover.ProveTheoremsAndConstructProofs(output.OldTheorems, output.NewTheorems, output.ContextualPicture)
// If we shouldn't construct proofs, don't do it
: _prover.ProveTheorems(output.OldTheorems, output.NewTheorems, output.ContextualPicture);
// Find the proved theorems
var provedTheorems = constructProofs
// If we have constructed proofs, there is a dictionary
? (IReadOnlyCollection <Theorem>)((IReadOnlyDictionary <Theorem, TheoremProof>)proverOutput).Keys
// Otherwise there is a collection directly
: (IReadOnlyCollection <Theorem>)proverOutput;
// Get the unproven theorems by taking all the new theorems
var interestingTheorems = output.NewTheorems.AllObjects
// Excluding those that are proven
.Where(theorem => !provedTheorems.Contains(theorem))
// Enumerate
.ToArray();
// Find the problems that should excluded based on symmetry
var notInterestingTheorems = mode switch
{
// No restrictions
SymmetryGenerationMode.GenerateBothSymmetricAndAsymmetric => (IReadOnlyList <Theorem>)Array.Empty <Theorem>(),
// Detect symmetric theorems
SymmetryGenerationMode.GenerateOnlySymmetric => interestingTheorems.Where(theorem => !theorem.IsSymmetric(output.Configuration)).ToArray(),
// Detect fully symmetric theorems
SymmetryGenerationMode.GenerateOnlyFullySymmetric => interestingTheorems.Where(theorem => !theorem.IsFullySymmetric(output.Configuration)).ToArray(),
// Unhandled cases
_ => throw new GeoGenException($"Unhandled value of {nameof(SymmetryGenerationMode)}: {mode}"),
};
// Interesting theorems can now be reseted
interestingTheorems = interestingTheorems
// By the exclusion of not interesting asymmetric ones
.Except(notInterestingTheorems)
// Enumerate
.ToArray();
// Prepare the map of all theorems
var allTheorems = new TheoremMap(output.OldTheorems.AllObjects.Concat(output.NewTheorems.AllObjects));
// Rank the interesting theorems
var rankedInterestingTheorems = interestingTheorems
// Rank given one
.Select(theorem => _ranker.Rank(theorem, output.Configuration, allTheorems))
// By rankings ASC (that's why -)
.OrderBy(rankedTheorem => - rankedTheorem.Ranking.TotalRanking)
// Enumerate
.ToArray();
// Now we can finally return the result
return(constructProofs
// If we're constructing proofs, then we have a proof dictionary
? new GeneratedProblemAnalyzerOutputWithProofs(rankedInterestingTheorems, notInterestingTheorems, (IReadOnlyDictionary <Theorem, TheoremProof>)proverOutput)
// If we're not constructing proofs, then we have just a proved theorem collection
: (GeneratedProblemAnalyzerOutputBase) new GeneratedProblemAnalyzerOutputWithoutProofs(rankedInterestingTheorems, notInterestingTheorems, (IReadOnlyCollection <Theorem>)proverOutput));
}
/// <inheritdoc/> public GeneratedProblemAnalyzerOutputWithoutProofs AnalyzeWithoutProofConstruction(ProblemGeneratorOutput generatorOutput, SymmetryGenerationMode mode) // Delegate the call to the general method => Analyze(generatorOutput, mode, constructProofs: false);
