I was trying to find the right syntax for allocating holdings within a rebalancing strategy.

class ModulatedMultidimensionalContainmentField(QCAlgorithm):

def Initialize(self):
self.SetStartDate(2009, 6, 20) # 2013/12/01 Earliest start date for all ETFs in universe 2/1/10
self.SetEndDate(2020, 6, 20)
self.SetCash(250000000)
self.SetBenchmark("ABC")
self.SetWarmup(400)
self.AddEquity("ABC", Resolution.Minute)
self.AddEquity("XYZ", Resolution.Minute)
self.AddEquity("SAM", Resolution.Minute)
self.Strategies = [self.Strategy_1, self.Strategy_2, self.Strategy_3, self.Strategy_4]
self.Strategy_1_Size = self.Portfolio[self.Strategy_1]/self.Portfolio.TotalPortfolioValue
self.Strategy_2_Size = self.Portfolio[self.Strategy_2]/self.Portfolio.TotalPortfolioValue
self.Strategy_3_Size = self.Portfolio[self.Strategy_3]/self.Portfolio.TotalPortfolioValue
self.Strategy_4_Size = self.Portfolio[self.Strategy_4]/self.Portfolio.TotalPortfolioValue

#This is where I am confused. How can I find how much of the portfolio is dedicated to a particular strategy at any given time?

self.strategy_1_portion = 0.25
self.strategy_2_portion = 0.25
self.strategy_3_portion = 0.25
self.strategy_4_portion = 0.1

#would like to do something like this if possible:

self.Schedule.On(
self.DateRules.MonthStart("ABC"),
self.TimeRules.AfterMarketOpen("ABC", 120),
self.AllocationStation
)
self.Schedule.On(
self.DateRules.EveryDay("ABC"),
self.TimeRules.AfterMarketOpen("ABC", 150),
self.Strategies
)

def AllocationStation(self):
self.SetHoldings(self.Strategy_1, self.strategy_1_portion)
self.SetHoldings(self.Strategy_2, self.strategy_2_portion)
self.SetHoldings(self.Strategy_3, self.strategy_3_portion)
self.SetHoldings(self.Strategy_4, self.strategy_4_portion)

def Strategy_1(self):
{Random Strategy}
if something happens, then:
self.SetHoldings("ABC", 0.4*(self.Strategy_1_Size))
self.SetHoldings("XYZ", 0.6*(self.Strategy_1_Size))
elif something happens:
self.SetHoldings("ABC", 0.25*(self.Strategy_1_Size))
self.SetHoldings("XYZ", 0.75*(self.Strategy_1_Size))
else:
self.SetHoldings("ABC", 0*(self.Strategy_1_Size))
self.SetHoldings("XYZ", 0*(self.Strategy_1_Size))

def Strategy_2(self):
{Random Strategy}
if something happens, then:
self.SetHoldings("ABC", 0.1*(self.Strategy_1_Size))
self.SetHoldings("XYZ", 0.9*(self.Strategy_1_Size))

def Strategy_3(self):
{Random Strategy}
if something happens, then:
self.SetHoldings("ABC", 0.2*(self.Strategy_1_Size))
self.SetHoldings("SAM", 0.7*(self.Strategy_1_Size))

def Strategy_4(self):
{Random Strategy}
if something happens, then:
self.SetHoldings("SAM", 0.9*(self.Strategy_1_Size))
self.SetHoldings("XYZ", 0.1*(self.Strategy_1_Size))


#I want to set a regular rebalancing between multiple strategies referencing the same portfolio
#If this is possible I would assume that my strategies would have to be rewritten to reference
#the respective strategy's portion of the portfolio itself, rather than simply SetHoldings()