Python – Machine Learning, kNN and NB Algorithm. Is there a way to make the code more compact and appealing?

Here is my code! I want to reduce the number of lines and make them look neater. This class implements the Naïve Bayes machine learning algorithm. Please help as much as possible. Many Thanks!

I tried to split more functions and then call them to do the work. Is there any way I can do more? Is there also a way to make the for loops more compact?

Import Heapq
Import sys
Import math as m
from the decimal import decimal

Class entry:
def __init __ (self, attributes):
self.attributes = attributes
self.diabetes = "yes" if "yes" in attributes "no" if "no" in attributes ""

def __str __ (self):
string = ""
for attributeNum attribute in enumerate (self.attributes):
if attributeNum == len (self.attributes) - 1:
String + = str (attribute)
otherwise:
String + = str (attribute) + & # 39 ;, & # 39;
Return string

def set_ifdiabetes (self, diabetes):
Auto diabetes = diabetes

defective Euclidean (self, other_entry):
sum = 0.0
for i in range (len (self.attributes)):
sum + = m.pow (float (self.attributes[i]) - float (other_entry.attributes[i]2)
Return m.sqrt (sum)

Class NB:
def __init __ (self, training_data, testing_data):
self.training_data = training_data
self.testing_data = testing_data

self.training_entries = []
        self.testing_entries = []

        self.diabetes_yes = []
        self.diabetes_no = []

        self.mu_diabetesyes = []
        self.mu_diabetesno = []

        self.sigma_diabetesyes = []
        self.sigma_diabetesno = []

        self.num_attributes = 0

self.p_diabetesyes = 0
self.p_diabetesno = 0

self.num_diabetesyes = 0
self.num_diabetesno = 0

def train (self):
self.traincleandata ()
self.get_mus ()
self.get_sigmas ()

def traincleandata (self):
for line in self.training_data:
if self.num_attributes == 0:
self.num_attributes = len (line.split (& # 39 ;, & # 39;))
for i in range (self.num_attributes):
self.diabetes_yes.append ([])
self.diabetes_no.append ([])
self.mu_diabetesyes.append (0.0)
self.mu_diabetesno.append (0.0)
self.sigma_diabetesyes.append (0.0)
self.sigma_diabetesno.append (0.0)
params = line.split (& # 39 ;, & # 39;)
cleanparams = getcleanparams (params)
entry = entry (cleanparams)
self.training_entries.append (entry)

if (entry.diabetes == "yes"):
for i in range (len (entry.attributes) - 1):
self.diabetes_yes[i].append (Decimal (entry.attributes[i]))
self.p_diabetesyes + = 1
self.num_diabetesyes + = 1
otherwise:
for i in range (len (entry.attributes) - 1):
self.diabetes_no[i].append (Decimal (entry.attributes[i]))
self.p_diabetesno + = 1
self.num_diabetesno + = 1

self.p_diabetesyes = decimal (self.p_diabetesyes) / len (self.training_entries)
self.p_diabetesno = decimal (self.p_diabetesno) / len (self.training_entries)

def get_mus (self):
for i in range (self.num_attributes - 1):
self.mu_diabetesyes[i] = sum (self.diabetes_yes[i]) / len (self.diabetes_yes[i])
self.mu_diabetesno[i] = Sum (self.diabetes_no[i]) / len (self.diabetes_no[i])

def get_sigmas (self):

sigSumYes = [0] * self.num_attributes
sigSumNo = [0] * self.num_attributes

for i in range (self.num_attributes - 1):
for j in range (self.num_diabetesyes):
sigSumYes[i] + = m.pow (self.diabetes_yes[i][j]    - self.mu_diabetesyes[i]2)
self.sigma_diabetesyes[i] = m.sqrt (sigSumYes[i] / (len (self.diabetes_yes[i]) - 1))
for j in range (self.num_diabetesno):
sigSumNo[i] + = m.pow (self.diabetes_no[i][j]    - self.mu_diabetesno[i]2)
self.sigma_diabetesno[i] = m.sqrt (sigSumNo[i] / (len (self.diabetes_no[i]) - 1))

Def-test (self):
self.testcleandata ()
self.testalgo ()

def testcleandata (self):
for line in self.testing_data:
params = line.split (& # 39 ;, & # 39;)
cleanparams = getcleanparams (params)
entry = entry (cleanparams)
self.testing_entries.append (entry)

def testalgo (self):
Counter = 1
P_diabetesyes = [0] * self.num_attributes
P_diabetesno = [0] * self.num_attributes
for the entry in self.testing_entries:
pYesEntry = 1
pNoEntry = 1
for i in range (self.num_attributes - 1):
P_diabetesyes[i] = Decimal number ((1 / (self.sigma_diabetesyes[i] * m.sqrt (2 * m.pi)) * m.pow (m.e, (-m.pow (Decimal (entry.attributes[i]) - self.mu_diabetesyes[i], 2) / (2 * m.pow (self.sigma_diabetesyes[i]2)))))
P_diabetesno[i] = Decimal number ((1 / (self.sigma_diabetesno[i] * m.sqrt (2 * m.pi)) * m.pow (m.e, (-m.pow (Decimal (entry.attributes[i]) -self.mu_diabetesno[i], 2) / (2 * m.pow (self.sigma_diabetesno[i]2)))))
pYesEntry * = float (P_diabetesyes[i])
pNoEntry * = float (P_diabetesno[i])

pYesEntry * = float (self.p_diabetesyes)
pNoEntry * = float (self.p_diabetesno)

entry.set_ifdiabetes ("yes") if (pYesEntry / pNoEntry> = 1) else entry.set_ifdiabetes ("no")
Counter + = 1

Class kNN:
def __init __ (self, training_data, testing_data, k):
self.k = k
self.training_data = training_data
self.testing_data = testing_data
self.training_entries = []
        self.testing_entries = []

    def __str __ (self):
string_to_return = & # 39; & # 39;
for the entry in self.training_entries:
string_to_return = string_to_return + str (input) + & # 39;  n & # 39;
return string_to_return

def train (self):
for line in self.training_data:
params = line.split (& # 39 ;, & # 39;)
self.training_entries.append (entry (getcleanparams (params))

Def-test (self):
Counter = 1
for line in self.testing_data:
params = line.split (& # 39 ;, & # 39;)
self.testing_entries.append (entry (getcleanparams (params))
for testEntry in self.testing_entries:
next []
            for trainEntry in self.training_entries:
current_entry = (testEntry.euclidean (trainEntry), str (trainEntry.diabetes), str (trainEntry))
next.append (current_entry)
heapq.heapify (next)
next.sort ()
next = closest[:int(self.k)]
            num_diabetes = 0
for entry in the immediate vicinity:
if (entry[1] == "yes"):
num_diabetes + = 1
testEntry.set_ifdiabetes ("yes") if (num_diabetes> = int (self.k) / 2) else testEntry.set_ifdiabetes ("no")
Counter + = 1

def compare (self):
for the entry in self.testing_entries:
to press("-----------")
print (entry.compare (self.training_entries[0]))
print (entry)
print (self.training_entries[0])


def getcleanparams (params):
params_nospaceortab = []
    for param in params:
params_nospaceortab.append (param.strip ())
return params_nospaceortab


if __name__ == & # 39; __ main __ & # 39 ;:
training_file = open (sys.argv[1])
testing_file = open (sys.argv[2])
classifier_input = sys.argv[3]

    training_lines = training_file.readlines ()
training_cleanlines = getcleanparams (training_lines)

testing_lines = testing_file.readlines ()
testing_cleanlines = getcleanparams (testing_lines)

if classifier_input == "NB":
Classifier = NB (training_cleanlines, testing_cleanlines)
classifier.train ()
classifier.test ()
for the entry in classifier.testing_entries:
print (entry.diabetes)
elif "NN" in classifier_input:
classifier = kNN (training_cleanlines, testing_cleanlines, (classifier_input.index (& # 39; NN & # 39;) - 1))
classifier.train ()
classifier.test ()
for the entry in classifier.testing_entries:
print (entry.diabetes)
otherwise:
print ("Error: unknown classifier type")
sys.exit ()

Compact parser for command-line arguments

So I decided to write my own little command-line argument parser for various other projects I'm working on. I realize that there are many good command-line parser libraries, but I still wrote my own (for exercise and implementation purposes).

The parser works fine, but I feel it can be improved a lot. Mainly I think the following things

  1. Mainly the actual parser, CommandLineParser.cs, It seems to be very poorly structured and I find it difficult to read myself.
  2. Abstraction. I wonder if I can make it a bit more abstract without haunting it. Maybe by introducing some interfaces?
  3. Designation. I went with me possibility for the command line switch and with value for the possible parameters. Are my methods / classes self-explanatory?
  4. Optimizations. I'm sure there are segments that can be done more efficiently, mainly in CommandLineParser.ParseArguments (string[] arguments)

A few things to keep in mind:

  1. I want to keep the structure for that CommandLineValue.cs and CommandLineOption.cs Mostly they are part of a plugin architecture to communicate command line arguments between the plugins and the main application.
  2. No use of attributes to save the command-line options.
  3. I've written a couple of unit tests to check parser functionality. Although they are not the main class to be rated, I am also happy about feedback 🙂

parser:

public class CommandLineParser
{
/// 
    /// Defines all possible command line options that the plugin can handle
/// 
    public list SupportedOptions {get; }

/// 
    /// Initialize the command line parser with a list of command line options provided by the plugin
/// 
    /// 
    
    
    
    public CommandLineParser (List supportedOptions)
{
SupportedOptions = supportedOptions;
}


/// 
    /// Parses the command-line arguments and returns a list of command-line values ​​that can be passed to it
/// plugin for further editing. The function also handles invalid sets and / or formats of options and values
/// and missing required arguments etc
/// 
    /// The arguments to be analyzed
    /// A list of parsed command line values ​​+ options
    /// 
    
    
    
    /// 
    
    
    
    /// 
    
    
    
    /// 
    
    
    
    public IEnumerable ParseArguments (string[] arguments)
{
var result = new list();

if (args.Length == 0)
return Enumerable.Empty();


// process all command line arguments
for (int i = 0; i < args.Length; i++)
        {
            CommandLineOption option = null;
            if (!IsSupportedOption(args[i], out option))
                throw new InvalidCommandLineOptionException($"{args[i]} is not a valid command line option");

            // Verify if the option expects additional values
            if (HasAdditionalValues(option))
            {
                // Check if enough additional values are given
                int additionalValues = option.ParameterTypes.Count;
                if (i + additionalValues + 1 > args.length)
throw new InsquateCommandLineValuesException (
$ "{args[i]} expects {additionalValues} values. ");

// Check if the extra values ​​have the correct format
// ToDo: Find a more elegant solution
var values ​​= args.ToList (). GetRange (i + 1, i + additionalValues) .ToList ();
var types = option.ParameterTypes.ToList ();

var castedValues ​​= values.Zip (types, (value, type) =>
{
To attempt
{
return Convert.ChangeType (value, type);
}
fishing
{
throw new InvalidCommandLineValueException (
$ "Can not switch between value {value} and type {type}");
}
});

result.Add (new CommandLineValue (option, castedValues.ToList ()));

// Increase i to jump to the next option
i + = additionalValues;
}
otherwise
{
result.Add (new CommandLineValue (option, null));
}
}

// Collect required arguments
list requiredOptions = new list();
foreach (var option in SupportedOptions)
{
if (option.Required)
foreach (var tag in option.Tags)
{
requiredOptions.Add (tag);
}
}

// make sure no required arguments are missing (or occur twice)
var missing = GetMissingRequiredArgs(requiredOptions, args.ToList ());
if (missing == null)
Return result;
throw new MissingRequiredCommandLineOptionException (
$ "The required arguments {string.Join (", ", missing)} have occurred several times");
}

/// 
    /// Make sure you have all the necessary options and that they (the required options) do not occur multiple times and are not duplicates
/// 
    /// A list of required options
    /// <The arguments to be checked
    /// Any primitive type
    /// Dispatched when certain required arguments exist more than once
    /// A list of missing required arguments, if any. Zero, if none are missing.
    static list GetMissingRequiredArgs(List required, list arguments)
{
// Convert to a dictionary where we store the required article as a key against the number for an article
var requiredDict = required.ToDictionary (k => k, v => 0);

foreach (var item in arguments)
{
if (! requiredDict.ContainsKey (item))
continue;
requiredDict[item]++; // if we asked, add it
if (requiredDict[item] <= 1)
continue;
throw new DuplicateRequiredCommandLineOptionException (
$ "Required option {item} has occurred several times!");
}

var result = new list();
// Now we are looking for missing items
foreach (var key in requiredDict.Keys)
{
if (requiredDict[key] == 0)
{
result.Add (key);
}
}

Return result. Any ()? Result: zero;
}


/// 
    /// Check if the specified option is part of the supported options
/// 
    /// true if the option is supported, false otherwise
    private bool IsSupportedOption (optionIdentifier string, option out CommandLineOption)
{
for (var index = 0; index < SupportedOptions.Count; index++)
        {
            var supportedOption = SupportedOptions[index];
            if (supportedOption.Tags.Any(tag => tag == optionIdentifier))
{
option = SupportedOptions[index];
return true;
}
}

option = null;
return it incorrectly;
}

/// 
    /// Specifies whether a command-line option has multiple values ​​or is just a flag
/// 
    /// Command line option for checking
    /// true if the option contains multiple values; otherwise, false
    Private Bool HasAdditionalValues ​​(Option CommandLineOption)
{
var noParameters = option.ParameterTypes == null || option.ParameterTypes.Count == 0;
return! noParameters;
}
}

Classes for storing command-line information:

public class CommandLineOption
{
/// 
    /// The identifier of the command line option, for example: -h or --help
/// 
    public i collection Tags {get; }

/// 
    /// Description of the command line option
/// 
    public string Description {get; }

/// 
    /// Specifies whether the argument is optional or required
/// 
    public bool Required {get; }

/// 
    /// Types of additionally provided values ​​like directory paths, values ​​etc.
/// 
    public IList ParameterTypes {get; }

/// 
    /// Create a new true / false command line option
/// 
    /// ID of the command-line option
    /// Description of the command-line option
    /// Indicates whether the command-line option is optional or not
    public CommandLineOption (IEnumerable Tags, string description, bool required = false)
{
Tags = tags.ToList ();
Description = description;
Required = required;
}

/// 
    /// Create a new true / false command line option
/// 
    /// ID of the command-line option
    /// Description of the command-line option
    /// Indicates whether the command-line option is optional or not
    public CommandLineOption (IEnumerable Tags, string description, bool required = false, parameter type[] parameter types):
this (tags, description, required)
{
ParameterTypes = new list(Parameter types);
}

}
public class CommandLineValue: IEqualityComparer
{
/// 
    /// Contains all values ​​specified after a command line option
/// 
    public IList Values ​​{received; }

/// 
    /// The command-line option to which the values ​​belong
/// 
    public CommandLineOption option {get; to adjust; }

/// 
    /// Stores the values ​​that correspond to a command-line option
/// 
    /// The command-line option to which the values ​​refer
    /// The stored values
    public CommandLineValue (CommandLineOption option, IList Values)
{
Option = option;
Values ​​= values;
}


public bool Equals (CommandLineValue x, CommandLineValue y)
{
if (x.option.Description == y.option.Description &&
x.Option.Required == y.Option.Required &&
x.Option.Tags.SequenceEqual (y.Option.Tags) &&
x.Option.ParameterTypes.SequenceEqual (y.Option.ParameterTypes) &&
x.Values.SequenceEqual (x.Values))
return true;
return it incorrectly;
}

public int GetHashCode (CommandLineValue obj)
{
return base.GetHashCode ();
}
}

Custom exception classes:

public class DuplicateRequiredCommandLineOptionException: Exception
{
public DuplicateRequiredCommandLineOptionException (string message): base (message)
{
}
}

public class InsquateCommandLineValuesException: Exception
{
public InsquateCommandLineValuesException (string message): base (message)
{
}
}

public class InvalidCommandLineOptionException: Exception
{
public InvalidCommandLineOptionException (string message): base (message)
{
}
}

public class InvalidCommandLineValueException: Exception
{
public InvalidCommandLineValueException (string message): base (message)
{
}
}

public class MissingRequiredCommandLineOptionException: Exception
{
public MissingRequiredCommandLineOptionException (string message): base (message)
{
}
}

Unit tests:

public class CommandLineParserTests
{     

    [Fact]
    public void ParseDuplicateRequiredArguments ()
{
var args = new[] {"--randomize", "-o", "/ home / user / Documents", "--randomize", "-d"};
var supportedOptions = new list
        {
new CommandLineOption (
New[] {"-r", "- randomize"},
"Random Flag",
true),
new CommandLineOption (
New[] {"-o", "--output-directory"},
"Specifies the output directory",
true,
typeof (string)),
new CommandLineOption (
New[] {"-d", "--dummy"},
"Just another unused flag"),
};

var parser = new CommandLineParser (supportedOptions);
Assert.Throws() =>
parser.ParseArguments (args)
);
}

    [Fact]
    public void ParseMissingRequiredArguments ()
{
var args = new[] {"--randomize", "--output-directory", "/ home / user / Documents"};
var supportedOptions = new list
        {
new CommandLineOption (
New[] {"-r", "- randomize"},
"Random Flag"),
new CommandLineOption (
New[] {"-o", "--output-directory"},
"Specifies the output directory",
true,
typeof (string)),
new CommandLineOption (
New[] {"-d", "--dummy"},
"Just another unused flag"),
};

var parser = new CommandLineParser (supportedOptions);
Assert.Throws() =>
parser.ParseArguments (args)
);
}

    [Fact]
    public void ParseMatchingTypeCommandLineValues ​​()
{
var args = new[] {"--log", "info", "1337", "3.1415"};
var supportedOptions = new list
        {
new CommandLineOption (
New[] {"-l", "--log"},
"Records information from exactly three data sources",
not correct,
typeof (string), typeof (int), typeof (float))
};

var parser = new CommandLineParser (supportedOptions);

var expectedValue = new CommandLineValue (new CommandLineOption (
New[] {"-l", "--log"},
"Records information from exactly three data sources",
not correct,
typeof (string), typeof (int), typeof (float)),
new object[] {"info", 1337, (float) 3.1415});

var actualValue = parser.ParseArguments (args) .ToList ()[0];
Assert.True (expectedValue.Equals (actualValue, expectedValue));

}

    [Fact]
    public void ParseMismatchingTypeCommandLineValues ​​()
{
var args = new[] {"--log", "info", "1337", "3.1415"};
var supportedOptions = new list
        {
new CommandLineOption (
New[] {"-l", "--log"},
"Records information from exactly three data sources",
not correct,
typeof (string), typeof (int), typeof (long)),
};
var parser = new CommandLineParser (supportedOptions);

Assert.Throws() =>
parser.ParseArguments (args)
);
}

    [Fact]
    public void ParseInsquateCommandLineValues ​​()
{
var args = new[] {"-l", "info", "info2"};
var supportedOptions = new list
        {
new CommandLineOption (
New[] {"-l", "--log"},
"Records information from exactly three data sources",
false, typeof (string), typeof (string), typeof (string)),
};
var parser = new CommandLineParser (supportedOptions);

Assert.Throws() =>
parser.ParseArguments (args)
);
}

    [Fact]
    public void ParseInvalidCommandLineOption ()
{
var args = new[] {"--Makes"};
var supportedOptions = new list
        {
new CommandLineOption (new[] {"-h", "--help"}, "Show help menu"),
};
var parser = new CommandLineParser (supportedOptions);

Assert.Throws() =>
parser.ParseArguments (args)
);
}

    [Fact]
    public void ParseNoCommandLineOptions ()
{
var args = new string[] {};
var parser = new CommandLineParser (null);
var result = parser.ParseArguments (args);

Assert.Equal (Enumerable.Empty(), Result);
}
}

I appreciate all suggestions. Feel free to be very picky. 🙂

Open subspaces of compact local spectral spaces

By Prop. 16 of Hochster's paper on spectral spaces we know that locally quasi-separated spectral spaces allow an open topological embedding in a spectral space. The question is, what happens if we drop the quasi-separation hypothesis? Is there a local spectral space that does not allow open topological embedding in a compact local spectral space?

iphone – How can I compare the photo quality of a mirrorless camera with a DSLR camera with a compact camera with a cell phone camera?

Not that I knew, and yes, there are some websites.

This contradiction is due to the fact that the range of topics and situations to which photography can be applied is too great. You can literally spend thousands of hours and get lost.

You have to define

  • What do you want a camera for? Portraits, Landscape, Traveling, Party, Social, Family, Sports, Night Photography, Day Photography, Indoor Photos, Exposure …

  • Print, web, social media, advertising design.

  • What is better? what is good enough

One page where you can find sample images is dpreview.com. However, you can get lost here if you do not define your parameters first. You can find cameras of 50,000 or cameras of 100.

Take a look at the links users posted in the comments.

I posted a link to a similar question. How do photos of the same subject compare between the Nikon D700 and the D70?

On this page, you can go to https://www.dpreview.com/reviews/nikon-d7500-review-speed-and-capability/8 and compare exactly the same destination scene.

A studio scene, however, only shows you a very specific point of view. No portability, no ease of use, no lenses, no bokeh, no style, no flexibility or much else what photography is all about.

Another place to look for is … https://www.youtube.com/ … Searching for specific comparisons … There is a great chance someone has already made a comparison with the devices that you want to compare.

dg.differential geometry РClosed Poincar̩ dual is $ int_M eta_S wedge omega $ and not $ int_M omega wedge eta_S $. What about the compact Poincar̩ dual?

My book is Differential Forms in Algebraic Topology by Loring W. Tu and Raoul Bott. An Introduction to Manifolds by Loring W. Tu is a prequel.

The characterization of the closed Poincaré dual is given here (the "(5.13)") in Section 5.5. That has $ int_M omega wedge eta_S $, from where $ eta_S $ is on rather right than left, The comments here confirm that this is a mistake.

I believe the characterization for the compact Poincaré Dual for the compact $ S $ and $ M $ of the finite type given here (the "(5.14)") agrees $ eta_S & # 39; $ to the right. However, since "(5.13)" is an error, it could affect the compact Poincaré Dual.

Bott and Tu say

If (5.14) holds for any closed k-shape $ omega $Then it applies to any closed k-shape $ omega $ with compact support. So as a form. $ eta_S & # 39; $ is also the closed Poincaré dual, d. H. the natural card $ H ^ {n-k} _c (M) to H ^ {n-k} (M) $ sends the compact Poincaré Dual to the closed Poincaré Dual.

I think the quote implicitly refers to "(5.13)". My question depends on whether such a thought is correct or not:

  1. Is that quote implicit references "(5.13)", what does the error of (5.13) mean for the assertion that the compact Poincaré-Dual is also the closed Poincaré-Dual?

    • A. The claim is still correct and for the same reason.

    • B. The claim is still correct, but for a different reason.

    • C. The claim is wrong now.

  2. Is that quote does not implicitly refer to "(5.13)", then I seem to have misunderstood. As Bott and Tu say, is the compact Poincaré dual also the closed Poincaré dual?

Security – What would be the impact of installing SQL Compact Edition on Bastion servers?

One of my clients uses a very light user interface. Now they are thinking about adding an extra layer of security using the user logon mechanism.
This requires a lightweight but secure database. The filtered list includes MSSQL Compact Edition and SqLite with encryption. For security reasons, SqLite is the second choice compared to the MSSQL Compact Edition.

Now my question is what impact could the installation of the compact version of mssql have on the bastion server.

CSS – compact alternative to bootstrap

I use bootstrap for a few years.

but the main problem I have is the space between all the elemenet
Upholstery, edges etc.

.wrapper-content {
Upholstery: 20px 10px 40px;
}
@media (min-width: 992px)
.navbar-expand-lg .navbar-nav .nav-link {
Fill right: .5rem;
fill left: .5rem;
}

Is there a compact version? or a guide to condense the rooms.

If a functional space with a compact open topology has a countable chain condition?

As in title, when a function space with compact open topology has a countable chain condition? Are there any sufficient and necessary conditions? Who gives references to this topic ??

McCoy and Ntantu [Topological Properties of Spaces of Continuous Functions, Page 68] pointed out that Vidossich proved that $ C_k (X) $ has ccc if $ X $ is submetrable. Who can prove this statement?

Thank you in advance.

ct.category theory – which set of compact objects generates the subcategory of a compactly generated stable model category

I could not find any information about which group of compact objects generated the following subcategory:

To let $ k $ Be a field of positive qualities and leave $ G $ be either a finite group or a finite group scheme over $ k $, Then let $ mathrm {stab} (k[G]) $ a stable model category of finally generated $ k[G]$Modules (Modulo of the projective). It is a subcategory of $ mathrm {stitch} (k[G]) $ – the stable model category of all $ k[G]$Modules (Modulo of the projective). To the $ mathrm {stitch} (k[G]) $It is well known that compact objects are exactly finitely generated modules and generate the simple modules $ mathrm {stitch} (k[G]) $,

Generally leave $ mathcal {K} $ be a compact generated stable model category with a lot $ mathcal {C} $ of compact objects and a lot $ mathcal {G} $ of compact generators. What are the compact generators of the subcategory of $ mathcal {K} $ spanned by objects in $ mathcal {C} $? I realize that this may be unknown, so I'd like some special examples (I'm more interested in cases where the category of the original stable models contains a set of compact generators rather than just one).

For the definitions I use, I'm referring to Swede-Shipley. Of course it makes no difference to replace the term "stable model category" by "triangulated category" in my question.

dg Differential Geometry – A special, non-vanishing vector field on odd-numbered compact manifolds

Accept that $ n $ is an odd integer and $ M subset mathbb {R} ^ {2n} $ is a compact, orientable submanifold.

Is there a non-vanishing smooth vector field? $ X $ on $ M $ with the following property?

$$ forall p in M ​​ quad omega (X (p), V_p) = 0, quad forall V_p in T_pM $$

from where $ omega $ is the default symplectic structure of $ mathbb {R} ^ {2n} $,

Proxy Sites Proxy Tunnels Proxy List Working Proxy Sites Hotproxysite Proxy Sites Proxy Sites Anonymous Proxy Anonymous Proxies Top-Proxies.co.uk http://www.proxysitesnow.com Proxy Servers Free Proxies Free Proxy List Proxy List Zoxy Proxy List PR liste all proxy sites More Proxies netgofree netgofree Hide-MyIp - The Best Proxy List American Proxy List www.proxylisty.com/proxylist Web Proxy Submit Proxies Updated Proxy List Updated Proxy List aproxy.org Bypass Proxy Sites Free Proxies List Evolving Critic Business Web Directory Free Proxy List iShortIt MyProxyList Online Proxies Go Proxies Need Proxies PrivateProxies Proxies4MySchool Proxies4Work Free Proxy List Free Proxy Sites ProxyInside Wiksa Proxy ProxyLister.org Free Proxy List ProxyNoid Proxy List Free Proxy List Proxy Sites Proxy TopList ProxyVille UK Proxy WebProxy List RatedProxy.com - Listing the best Web Proxies Free Proxy List SchoolProxiesList Stay Anonymous Proxy List The Power Of Ninja Proxy List UNubstruct Free proxy sites Free proxy sites