Odd Chordless Cycle

Author

Eric W. Weisstein
February 12, 2024

This notebook downloaded from http://mathworld.wolfram.com/notebooks/GraphTheory/OddChordlessCycle.nb.

For more information, see Eric's MathWorld entry http://mathworld.wolfram.com/OddChordlessCycle.html.

©2024 Wolfram Research, Inc. except for portions noted otherwise

Table

GraphDataCountTable["OddChordlessCycleCount",{"Andrasfai"->301771,"Antiprism"->301772,"DiagonalIntersection"->362544,"Flower"->362545,"Goldberg"->362546,"HalvedCube"->362510,"King"->362511,"MoebiusLadder"->301773,"Mycielski"->362512,"Prism"->301774,"Queen"->362513,"Tetrahedral"->362547,"Triangular"->303505,"TriangualrGrid"->362514,"Web"->301775}]

Parametrized families

<<MathWorld`Graphs`

Andrasfai

A301771

seq=Table[GraphData[{"Andrasfai",n},"OddChordlessCycleCount"],{n,20}]

FindSequenceFunction[Rest@DeleteMissing@seq,n]//Factor

Table[((n (1+n) (2+n) (2+3 n) (120+53 n-6 (n^2)+(n^3)))/5040),{n,20}]

coef=FindLinearRecurrence[seq]

Length@coef

Take[seq,Length@coef]

LinearRecurrence[{8,-28,56,-70,56,-28,8,-1},{0,1,8,33,100,255,584,1242},20]

gf=x FindGeneratingFunction[DeleteMissing@seq,x]

SeriesCoefficient[gf,{x,0,n}]

Table[((n (60-112 n-273 (n^2)+140 (n^3)+210 (n^4)-28 (n^5)+3 (n^6)))/5040),{n,35}]==BFileSequence[301771]

seq=CoefficientList[Series[((x-3 (x^3)+4 (x^4)+(x^5))/(((x-1))^8)),{x,0,20}],x]

FindLinearRecurrence[seq]

Do[Print[{{"Andrasfai",{n,n}},OddChordlessCyclePolynomial[AndrasfaiGraph[n],x]//Timing}],{n,100}]

seq={0,1,8,33,100,255,584,1242,2496,4785,8800,15587,26676,44239,71280,111860,171360,256785,377112,543685,770660,1075503,1479544,2008590,2693600,3571425,4685616,6087303,7836148,10001375,12662880,15912424,19854912,24609761,30312360,37115625,45191652,54733471,65956904,79102530,94437760,112259025};

gf=x FindGeneratingFunction[seq,x]

BFile[seq,301771]

Antelope n×n

seq=Table[GraphData[{"Antelope",{n,n}},"OddChordlessCycleCount"],{n,15}]

Antiprism

Cell[TextData[ButtonBox["A301772",
 BaseStyle->"Hyperlink",
 ButtonData->{
   URL["https://oeis.org/A301772"], None},
 ButtonNote->"https://oeis.org/A301772"]], "Text"]

Entity["Graph",{"Antiprism",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Antiprism",n},"OddChordlessCycleCount"],{n,3,25}]

seq=Table[(RootSum[-1+#1-2 ((#1)^2)+((#1)^3)&,((#1)^n)&]-RootSum[-1+#1+2 ((#1)^2)+((#1)^3)&,((#1)^n)&])/2,{n,0,20}]

FindLinearRecurrence[seq]

LinearRecurrence[{0,2,2,-1,2,-1},{0,2,0,2,8,2},40]

gf=FindGeneratingFunction[seq,x]

InputForm[gf]

CoefficientList[Series[((2 x (1-(x^2)+2 (x^3)))/(1-2 (x^2)-2 (x^3)+(x^4)-2 (x^5)+(x^6))),{x,0,20}],x]

Simplify[SeriesCoefficient[gf,{x,0,n}],n≥0]//RootReduce

Apollonian

seq=Table[GraphData[{"Apollonian",n},"OddChordlessCycleCount"],{n,6}]

Barbell

seq=Table[GraphData[{"Barbell",n},"OddChordlessCycleCount"],{n,3,20}]

Bishop n×n

seq=Table[GraphData[{"Bishop",{n,n}},"OddChordlessCycleCount"],{n,2,10}]

BlackBishop n×n

seq=Table[GraphData[{"WhiteBishop",{n,n}},"OddChordlessCycleCount"],{n,2,10}]

Book

seq=Table[GraphData[{"Book",n},"OddChordlessCycleCount"],{n,20}]

Centipede

seq=Table[GraphData[{"Centipede",n},"OddChordlessCycleCount"],{n,10}]

CocktailParty

seq=Table[GraphData[{"CocktailParty",n},"OddChordlessCycleCount"],{n,20}]

Complete

Entity["Graph",{"Complete",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Complete",n},"OddChordlessCycleCount"],{n,20}]

CompleteBipartite m×n

Entity["Graph",{"CompleteBipartite",{m,n}}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"CompleteBipartite",{m,n}},"OddChordlessCycleCount"],{n,10},{m,n}]//Column

CompleteBipartite n×n

Entity["Graph",{"CompleteBipartite",{n,n}}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"CompleteBipartite",{n,n}},"OddChordlessCycleCount"],{n,20}]

CompleteTripartite k×m×n

Entity["Graph",{"CompleteTripartite",{k,m,n}}]["OddChordlessCycleCount"]

CompleteTripartite n×n×n

Entity["Graph",{"CompleteTripartite",{n,n,n}}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"CompleteTripartite",{n,n,n}},"OddChordlessCycleCount"],{n,10}]

Crown

seq=Table[GraphData[{"Crown",n},"OddChordlessCycleCount"],{n,3,20}]

Cycle

Entity["Graph",{"Cycle",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Cycle",n},"OddChordlessCycleCount"],{n,3,20}]

DiagonalIntersection

A362544

seq=Table[GraphData[{"DiagonalIntersection",n},"OddChordlessCycleCount"],{n,3,14}]

Empty

Entity["Graph",{"Empty",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Empty",n},"OddChordlessCycleCount"],{n,30}]

FibonacciCube

seq=Table[GraphData[{"FibonacciCube",n},"OddChordlessCycleCount"],{n,15}]

Fiveleaper n×n

seq=Table[GraphData[{"Fiveleaper",{n,n}},"OddChordlessCycleCount"],{n,10}]

Flower

A362545

seq=Table[GraphData[{"Flower",n},"OddChordlessCycleCount"],{n,5,20}]

FindLinearRecurrence[DeleteMissing@seq[[1;;;;2]]]

FindSequenceFunction[DeleteMissing@seq[[1;;;;2]],n]//FullSimplify

Table[(((1+ (Sqrt[2])))^n),{n,8}]//Expand

Table[(((1+2 (Sqrt[2])))^n),{n,4}]//Expand

Table[(((2+2 (Sqrt[2])))^n),{n,4}]//Expand

Table[(((3+2 (Sqrt[2])))^n),{n,4}]//Expand

gf=FindGeneratingFunction[DeleteMissing@seq[[1;;;;2]],x]//Factor

FullSimplify[SeriesCoefficient[gf,{x,0,n}],n>0]

Table[-1+(41-29 (Sqrt[2])) (((3-2 (Sqrt[2])))^n)+(((3+2 (Sqrt[2])))^n) (41+29 (Sqrt[2])),{n,0,5}]//Expand

Table[(((1- (Sqrt[2])))^5)(((3-2 (Sqrt[2])))^n)+(((3+2 (Sqrt[2])))^n) (((1+ (Sqrt[2])))^5)-1,{n,0,5}]//Expand

Table[(((1- (Sqrt[2])))^5)(((1- (Sqrt[2])))^(2n))+(((1+ (Sqrt[2])))^(2n)) (((1+ (Sqrt[2])))^5)-1,{n,0,5}]//Expand

Table[(((1- (Sqrt[2])))^(2n+5))+(((1+ (Sqrt[2])))^(2n+5)) -1,{n,0,5}]//Expand

Table[(((1- (Sqrt[2])))^n)+(((1+ (Sqrt[2])))^n),{n,10}]//Expand

Which is A002203

Solve[2n+5==k,n]

Table[LucasL[2n+1,2]-1,{n,0,25}]

seq=LucasL[2Range[0,20]+1,2]-1

FindLinearRecurrence[seq]

LinearRecurrence[{7,-7,1},{1,13,81},20]

gf=FindGeneratingFunction[seq,x]//Factor

ToString[gf,InputForm]

CoefficientList[Series[((-1-6 x+3 (x^2))/((-1+x) (1-6 x+(x^2)))),{x,0,20}],x]

FoldedCube

seq=Table[GraphData[{"FoldedCube",n},"OddChordlessCycleCount"],{n,2,10}]

Gear

seq=Table[GraphData[{"Gear",n},"OddChordlessCycleCount"],{n,3,20}]

Goldberg

A362546

seq=Table[GraphData[{"Goldberg",n},"OddChordlessCycleCount"],{n,3,20}]

FindLinearRecurrence[DeleteMissing@seq]//Head//Timing

FindSequenceFunction[DeleteMissing@seq,n-2]//Head//Timing

FindGeneratingFunction[DeleteMissing@seq,x]//Head//Timing

Grid m×n

Entity["Graph",{"Grid",{m,n}}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Grid",{m,n}},"OddChordlessCycleCount"],{n,10},{m,n}]//Column

Grid n×n

Entity["Graph",{"Grid",{n,n}}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Grid",{n,n}},"OddChordlessCycleCount"],{n,10}]

Grid k×m×n

Entity["Graph",{"Grid",{k,m,n}}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Grid",{k,m,n}},"OddChordlessCycleCount"],{n,5},{m,n},{k,m}]//Column

Grid n×n×n

Entity["Graph",{"Grid",{n,n,n}}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Grid",{n,n,n}},"OddChordlessCycleCount"],{n,10}]

HalvedCube

A362510

seq=Table[GraphData[{"HalvedCube",n},"OddChordlessCycleCount"],{n,10}]

Hanoi

seq=Table[GraphData[{"Hanoi",n},"OddChordlessCycleCount"],{n,5}]

Helm

seq=Table[GraphData[{"Helm",n},"OddChordlessCycleCount"],{n,3,20}]

Hypercube

Entity["Graph",{"Hypercube",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Hypercube",n},"OddChordlessCycleCount"],{n,0,10}]

Keller

Entity["Graph",{"Keller",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Keller",n},"OddChordlessCycleCount"],{n,5}]

King m×n

seq=Table[GraphData[{"King",{m,n}},"OddChordlessCycleCount"],{n,10},{m,n}]//Column

King n×n

A362511

seq=Table[GraphData[{"King",{n,n}},"OddChordlessCycleCount"],{n,10}]

Knight m×n

Entity["Graph",{"Knight",{m,n}}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Knight",{m,n}},"OddChordlessCycleCount"],{n,10},{m,n}]//Column

Knight n×n

Entity["Graph",{"Knight",{n,n}}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Knight",{n,n}},"OddChordlessCycleCount"],{n,20}]

Ladder

Entity["Graph",{"Ladder",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Ladder",n},"OddChordlessCycleCount"],{n,20}]

LadderRung

seq=Table[GraphData[{"LadderRung",n},"OddChordlessCycleCount"],{n,20}]

MengerSponge

seq=Table[GraphData[{"MengerSponge",n},"OddChordlessCycleCount"],{n,3}]

MoebiusLadder

A301773

Entity["Graph",{"MoebiusLadder",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"MoebiusLadder",n},"OddChordlessCycleCount"],{n,3,25}]

seq[[2;;;;2]]

seq=Table[LucasL[2n]-2 Cos[((2n π)/3)],{n,0,40}]

FindLinearRecurrence[seq]

LinearRecurrence[{2,1,2,-1},{0,4,8,16},20]

gf=FindGeneratingFunction[seq,x]

InputForm[gf]

CoefficientList[Series[-((4 x (-1+(x^2)))/(1-2 x-(x^2)-2 (x^3)+(x^4))),{x,0,20}],x]

Mycielski

A362512

Entity["Graph",{"Mycielski",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Mycielski",n},"OddChordlessCycleCount"],{n,11}]

Odd

Entity["Graph",{"Odd",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Odd",n},"OddChordlessCycleCount"],{n,7}]

Pan

seq=Table[GraphData[{"Pan",n},"OddChordlessCycleCount"],{n,3,20}]

Path

Entity["Graph",{"Path",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Path",n},"OddChordlessCycleCount"],{n,20}]

PathComplement

seq=Table[GraphData[{"PathComplement",n},"OddChordlessCycleCount"],{n,20}]

Prism

A301774

Entity["Graph",{"Prism",n}]["OddChordlessCycleCount"]

Table[LucasL[2n+1]+2Cos[(2n+1)Pi/3],{n,25}]

seq=Table[GraphData[{"Prism",n},"OddChordlessCycleCount"],{n,3,25}]

seq[[;;;;2]]

FindLinearRecurrence[Rest@%]

seq=LinearRecurrence[{2,1,2,-1},{2,12,30,74},20]

gf=FindGeneratingFunction[seq,x]

InputForm[gf]

CoefficientList[Series[-((2 (-1-4 x-2 (x^2)+(x^3)))/(1-2 x-(x^2)-2 (x^3)+(x^4))),{x,0,20}],x]

Queen n×n

A362513

seq=Table[GraphData[{"Queen",{n,n}},"OddChordlessCycleCount"],{n,10}]

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing@seq,k],n-k]//Head//Timing}],{k,0,4}]

Do[Print[{k,FindLinearRecurrence[Drop[DeleteMissing@seq,k]]//Head//Timing}],{k,0,4}]

FindGeneratingFunction[DeleteMissing@seq,n]//Head//Timing

Rook n×n

seq=Table[GraphData[{"Rook",{n,n}},"OddChordlessCycleCount"],{n,10}]

RookComplement n×n

seq=Table[GraphData[{"RookComplement",{n,n}},"OddChordlessCycleCount"],{n,10}]

SierpinskiCarpet

seq=Table[GraphData[{"SierpinskiCarpet",n},"OddChordlessCycleCount"],{n,4}]

SierpinskiSieve

seq=Table[GraphData[{"SierpinskiSieve",n},"OddChordlessCycleCount"],{n,5}]

SierpinskiTetrahedron

seq=Table[GraphData[{"SierpinskiTetrahedron",n},"OddChordlessCycleCount"],{n,6}]

Star

Entity["Graph",{"Star",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Star",n},"OddChordlessCycleCount"],{n,20}]

Sun

seq=Table[GraphData[{"Sun",n},"OddChordlessCycleCount"],{n,3,20}]

Sunlet

seq=Table[GraphData[{"Sunlet",n},"OddChordlessCycleCount"],{n,3,20}]

Tetrahedral

A362547

seq=Table[GraphData[{"Tetrahedral",n},"OddChordlessCycleCount"],{n,6,10}]

TorusGrid n×n

seq=Table[GraphData[{"TorusGrid",{n,n}},"OddChordlessCycleCount"],{n,3,10}]

GraphData[{"TorusGrid",{5,5}},"#"]

Transposition

Entity["Graph",{"Transposition",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Transposition",n},"OddChordlessCycleCount"],{n,6}]

Triangular

A303505

seq=Table[GraphData[{"Triangular",n},"OddChordlessCycleCount"],{n,2,20}]

seq=Table[Sum[Binomial[n,2 k+1](2 k)!/2,{k,2,Ceiling[n/2]-1}],{n,2,20}]

Sum[Binomial[n,2 k+1](2 k)!/2,{k,2,Ceiling[n/2]-1}]

Sum[Binomial[n,2 k+1](2 k)!/2,{k,2,Ceiling[n/2]-1}]

Sum[Binomial[n,2 k+1](2 k)!/2,{k,2,n/2-1}]

Sum[Binomial[n,2 k+1](2 k)!/2,{k,2,n/2-1/2}]

Table[(1/10) (-4+n) (-3+n) (-2+n) (-1+n) n HypergeometricPFQ[{1,(5/2),(5/2)-(n/2),3-(n/2)},{(7/2)},4],{n,5,20}]

FullSimplify[(1/10) (-4+n) (-3+n) (-2+n) (-1+n) n HypergeometricPFQ[{1,(5/2),(5/2)-(n/2),3-(n/2)},{(7/2)},4]]

Binomial[n,5]

Table[12Binomial[n,5]HypergeometricPFQ[{1,(5/2),(5/2)-(n/2),3-(n/2)},{(7/2)},4],{n,5,20}]

FindSequenceFunction[Drop[seq,2],n-3]//Head//Timing

FindLinearRecurrence[Drop[seq,3]]//Head//Timing

FindGeneratingFunction[seq,x]//Head//Timing

TriangularGrid

A362514

seq=Table[GraphData[{"TriangularGrid",n},"OddChordlessCycleCount"],{n,20}]

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing@seq,k],n-k]//Head//Timing}],{k,0,4}]

Do[Print[{k,FindLinearRecurrence[Drop[DeleteMissing@seq,k]]//Head//Timing}],{k,0,4}]

FindGeneratingFunction[DeleteMissing@seq,n]//Head//Timing

Do[Print[{{"TriangularGrid",{n,n}},OddChordlessCyclePolynomial[TriangularGridGraph[n],1]//Timing}],{n,10}]

TriangularHoneycombAcuteKnight

seq=Table[GraphData[{"TriangularHoneycombAcuteKnight",n},"OddChordlessCycleCount"],{n,20}]

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing@seq,k],n-k]//Head//Timing}],{k,0,4}]

Do[Print[{k,FindLinearRecurrence[Drop[DeleteMissing@seq,k]]//Head//Timing}],{k,0,4}]

FindGeneratingFunction[DeleteMissing@seq,n]//Head//Timing

TriangularHoneycombBishop

seq=Table[GraphData[{"TriangularHoneycombBishop",n},"OddChordlessCycleCount"],{n,20}]

TriangularHoneycombKing

seq=Table[GraphData[{"TriangularHoneycombKing",n},"OddChordlessCycleCount"],{n,11}]

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing@seq,k],n-k]//Head//Timing}],{k,0,4}]

Do[Print[{k,FindLinearRecurrence[Drop[DeleteMissing@seq,k]]//Head//Timing}],{k,0,4}]

FindGeneratingFunction[DeleteMissing@seq,n]//Head//Timing

TriangularHoneycombObtuseKnight

seq=Table[GraphData[{"TriangularHoneycombObtuseKnight",n},"OddChordlessCycleCount"],{n,10}]

Do[Print[{k,FindSequenceFunction[Drop[DeleteMissing@seq,k],n-k]//Head//Timing}],{k,0,4}]

Do[Print[{k,FindLinearRecurrence[Drop[DeleteMissing@seq,k]]//Head//Timing}],{k,0,4}]

FindGeneratingFunction[DeleteMissing@seq,n]//Head//Timing

TriangularHoneycombQueen

seq=Table[GraphData[{"TriangularHoneycombQueen",n},"OddChordlessCycleCount"],{n,20}]

FindGeneratingFunction[DeleteMissing@seq,n]//Head//Timing

Do[Print[{{"TriangularHoneycombQueen",n},OddChordlessCyclePolynomial[TriangularHoneycombQueenGraph[n],x]//Timing}],{n,100}]

seq={0,0,0,6,78,450,2640,16902,120714,958074,8644920};

TriangularHoneycombRook

seq=Table[GraphData[{"TriangularHoneycombRook",n},"OddChordlessCycleCount"],{n,10}]

Web

A301775

seq=Table[GraphData[{"Web",n},"OddChordlessCycleCount"],{n,3,20}]

seq[[1;;;;2]]

FindGeneratingFunction[%,x]

FindSequenceFunction[seq[[3;;;;2]],n]

FindLinearRecurrence[seq[[3;;;;2]]]

Series[2*x^2*(6+3*x+x^2-x^3)/((1-3*x+x^2)*(1+x+x^2)),{x,0,20}]

FullSimplify[SeriesCoefficient[2*x^2*(6+3*x+x^2-x^3)/((1-3*x+x^2)*(1+x+x^2)),{x,0,n}],n>0&&Element[n,Integers]]

Table[-((((1/2) (3-(Sqrt[5]))))^n) (-1+(Sqrt[5]))+(1+(Sqrt[5])) ((((1/2) (3+(Sqrt[5]))))^n),{n,20}]/2//FullSimplify

Table[LucasL[2n+1]+Cos[2n Pi/3]-(Sqrt[3])Sin[2n Pi/3],{n,20}]

Wheel

Entity["Graph",{"Wheel",n}]["OddChordlessCycleCount"]

seq=Table[GraphData[{"Wheel",n},"OddChordlessCycleCount"],{n,4,20}]

WhiteBishop n×n

seq=Table[GraphData[{"WhiteBishop",{n,n}},"OddChordlessCycleCount"],{n,2,10}]

Compute

{“AlternatingGroupGraph”,7}

GraphData[{"AlternatingGroupGraph",7},"Symmetric"]

GraphData[{"AlternatingGroupGraph",7},"VertexTransitive"]

edge=(edges=GraphData[{"AlternatingGroupGraph",7},"EdgeIndices"])[[1]]

(cycle=FindOddChordlessCycle[g=GraphData["TruncatedWittGraph"],Method->"Paths","InitialVertices"->{1,421},"MaxLength"->5,Debug->True])//Timing

ChordlessCycleQ[g,cycle]

Stan’s

cycle=FindHamiltonianCycle[Subgraph[g=GraphData[{"AlternatingGroupGraph",7}],{2226,66,499,935,1358,1794,1854}]][[1,All,1]]

ChordlessCycleQ[g,cycle]

Antiprism

Odd

Table[ChordlessCycleQ[GraphData[{"Antiprism",n}],Range[n]],{n,4,20}]

l=Table[{{"Antiprism",n},{0,Range[n]}},{n,5,20,2}];

Table[ChordlessCycleQ[GraphData[{"Antiprism",n}],Join[Range[n-1],{2n-1,2n}]],{n,4,20,2}]

l=Table[{{"Antiprism",n},{0,Join[Range[n-1],{2n-1,2n}]}},{n,4,20,2}];

Even

{“Arrangement”,{6,4}}

GraphData[{"Arrangement",{6,4}},"Symmetric"]

edge=(edges=GraphData[{"Arrangement",{6,4}},"EdgeIndices"])[[1]]

GraphData[{"Arrangement",{6,4}},"IndependenceNumber"]

With[{gn={"Arrangement",{6,4}}},{gn,(cycle=FindOddChordlessCycle[g=GraphData[gn],Method->"Paths","InitialVertices"->{1,2},"MaxLength"->9,Debug->True])//Timing}]

ChordlessCycleQ[g,cycle]

{“Cage”,{5,12}}}

GraphData[{"Cage",{5,12}},{"VT","EdgeTransitive","IndependenceNumber"}]

Function[gn,Print[{gn,(cycle=FindChordlessCycle[g=GraphData[gn],Method->"Paths","InitialVertices"->GraphData[gn,"EdgeIndices"][[1]],Debug->True,"MaxLength"->20])//Timing}]]/@{{"Cage",{5,12}}};

DisdyakisDodecahedralGraph

GraphData[gn="DisdyakisDodecahedralGraph"]

alpha=GraphData["DisdyakisDodecahedralGraph","IndependenceNumber"]

cyc=FindOddChordlessCycle[GraphData[gn],"IndependenceNumber"->alpha,Method->"Paths",Debug->True]

DisdyakisTriacontahedralGraph

GraphData[gn="DisdyakisTriacontahedralGraph"]

GraphData[gn,{"Symmetric","VT","ET"}]

alpha=GraphData[gn,"IndependenceNumber"]

{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[GraphData[gn],"IndependenceNumber"->alpha,Method->"Paths",Debug->True],30*^9])//Timing}

{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[GraphData[gn],"IndependenceNumber"->alpha,Method->"Paths",Debug->True],80*^9])//Timing}

{“Doob”,{1,2}}

GraphData[gn={"Doob",{1,2}},{"V","Symmetric","VT","EdgeTransitive","Perfect"}]

edge=(edges=GraphData[gn,"EdgeIndices"])[[1]]

Select[Rest[edges],!FreeQ[#,edge[[2]]]&][[All,2]]

alpha=GraphData[gn,"IndependenceNumber"]

{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],Method->"Paths","MaxLength"->9,Debug->True],30*^9])//Timing}

ChordlessCycleQ[g,cycle]

{“FoldedCube”,9}

GraphData[{"FoldedCube",9},"Symmetric"]

edge=(edges=GraphData[{"FoldedCube",9},"EdgeIndices"])[[1]]

Select[Rest[edges],!FreeQ[#,edge[[2]]]&][[All,2]]

{{"FoldedCube",9},(cycle=FindOddChordlessCycle[g=GraphData[{"FoldedCube",9}],Method->"Paths","InitialVertices"->{1,2,3},Debug->True])//Timing}

ChordlessCycleQ[g,cycle]

Foster

Select[GraphData["Foster*"],!GraphData[#,"Bipartite"]&]

BipartiteQ@Graph["Foster026A"]

Select[GraphData["Foster*"],GraphData[#,"Perfect"]&]

Select[missing,StringQ[#[[2]]]&&StringMatchQ[#[[2]],"Foster*"]&]

{{480,"Foster480C"},{500,"Foster500A"},{504,"Foster504E"},{620,"Foster620A"},{672,"Foster672C"},{680,"Foster680A"},{680,"Foster680B"},{816,"Foster816A"},{816,"Foster816E"},{816,"Foster816G"},{936,"Foster936C"}}[[All,2]]

Select[GraphData["Foster*"],GraphData[#,"Imperfect"]&]

GraphData[#,"OddChordlessCycles"]&/@{"Foster056B","Foster060A","Foster084A"}

firstedge[g_]:=Module[{},
edge=(edges=List@@@EdgeLsit[g])[[1]];
nextedge=Select[Rest[edges],!FreeQ[#,edge[[2]]]&][[All,2]];
Append[edge,nextedge[[1]]]
]

With[{gn=#},Print[{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],"MaxLength"->20,Method->"Paths","InitialVertices"->firstedge[g]],20*^9])//Timing}]]&/@{"Foster480C","Foster500A","Foster504E","Foster620A","Foster672C","Foster680A","Foster680B","Foster816A","Foster816E","Foster816G","Foster936C"}

G24Graph

FindOddChordlessCycle[GraphData["G24Graph"],"Partial"->10^5,Debug->True]//Timing

ChordlessCycleQ[GraphData["G24Graph"],{1,2,4,33,3}]//Timing

HallJankoNearOctagon

GraphData["HallJankoNearOctagon","Symmetric"]

edge=GraphData["HallJankoNearOctagon","EdgeIndices"][[1]]

(cycle=FindOddChordlessCycle[g=GraphData["HallJankoNearOctagon"],Method->"Paths","InitialVertices"->edge,"MaxLength"->7,Debug->True])//Timing

ChordlessCycleQ[g,cycle]

The cycle from stan

cycle=FindHamiltonianCycle[Subgraph[g=GraphData["HallJankoNearOctagon"],{113,89,190,309,9,252,161}]][[1,All,1]]

ChordlessCycleQ[g,cycle]

HalvedCube

missing=GraphData["HalvedCube"]

GraphData[#,"Symmetric"]&/@missing

Print[{#,FindOddChordlessCycle[g=GraphData[#],Method->"Paths","InitialVertices"->GraphData[#,"EdgeIndices"][[1]],"MaxLength"->7]//Timing}]&/@missing;

Hamming

missing=SortBy[GraphData["Hamming*"],GraphData[#,"V"]&]

GraphData[#,"Symmetric"]&/@missing

Print[{#,FindOddChordlessCycle[g=GraphData[#],Method->"Paths","InitialVertices"->GraphData[#,"EdgeIndices"][[1]],"MaxLength"->7]//Timing}]&/@missing;

{“Johnson”,{10,4}}

GraphData[{"Johnson",{10,4}},"Symmetric"]

edge=GraphData[{"Johnson",{10,4}},"EdgeIndices"][[1]]

(cycle=FindOddChordlessCycle[g=GraphData[{"Johnson",{10,4}}],Method->"Paths","InitialVertices"->edge,Debug->True])//Timing

ChordlessCycleQ[g,cycle]

The cycle from stan

cycle=FindHamiltonianCycle[Subgraph[g,{1,2,15,19,9}]][[1,All,1]]

ChordlessCycleQ[g,cycle]

K6ReplacedDoubledCubicalGraph

(cycle=FindOddChordlessCycle[g=GraphData["K6ReplacedDoubledCubicalGraph"],Method->"Paths",Debug->True])//Timing

ChordlessCycleQ[g,cycle]

K6ReplacedDoubledMoebiusKantorGraph

(cycle=FindOddChordlessCycle[g=GraphData["K6ReplacedDoubledMoebiusKantorGraph"],Method->"Paths",Debug->True])//Timing

ChordlessCycleQ[g,cycle]

K18ReplacedSextupledCubicalGraph

(cycle=FindOddChordlessCycle[g=GraphData["K18ReplacedSextupledCubicalGraph"],Method->"Paths",Debug->True])//Timing

ChordlessCycleQ[g,cycle]

Keller

GraphData[{"Keller",2},"OddChordlessCycles"][[1]]

GraphData[gn={"Keller",3},{"Symmetric","VT"}]

edge=GraphData[gn,"EdgeIndices"][[1]]

{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],Method->"Paths","MaxLength"->5,"InitialVertices"->edge,Debug->True],1*^9])//Timing}

{gn={"Keller",4},(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],"MaxLength"->5,"InitialVertices"->GraphData[gn,"EdgeIndices"][[1]],Debug->True],1*^9])//Timing}

GraphData[{"Keller",5},"EdgeIndices"][[1]]

{gn={"Keller",5},(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],"MaxLength"->5,"InitialVertices"->GraphData[gn,"EdgeIndices"][[1]],Debug->True],20*^9])//Timing}

GraphData["Keller",4^3;;]

ChordlessCycleQ[GraphData[#],{1,7,9,2,11}]&/@GraphData["Keller",4^3;;]

GraphData[{"Keller",5},"IndependenceNumber"]

{gn={"Keller",5},(cycle=MemoryConstrained[FindChordlessCycle[g=GraphData[gn],Method->"Paths","InitialVertices"->{},"IndependenceNumber"->GraphData[gn,"IndependenceNumber"],Debug->True],20*^9])//Timing}

King

kings={{"King",{10,10}}};

Function[gn,Print[{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],"InitialVertices"->{2,3},"IndependenceNumber"->GraphData[gn,"IndependenceNumber"],Debug->True],20*^9])//Timing}]]/@kings;

Function[gn,Print[{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],"InitialVertices"->{2,3},"IndependenceNumber"->GraphData[gn,"IndependenceNumber"],Method->"Paths",Debug->True],20*^9])//Timing}]]/@kings;

Kneser

kneser=SortBy[Select[GraphData["Kneser"],GraphData[#,"OddChordlessCycles"]===Missing["NotAvailable"]&],GraphData[#,"V"]&]

kneser={{"Kneser",{13,3}},{"Kneser",{11,4}},{"Kneser",{14,3}},{"Kneser",{15,3}},{"Kneser",{12,4}},{"Kneser",{13,4}},{"Kneser",{12,5}},{"Kneser",{14,4}},{"Kneser",{13,5}},{"Kneser",{15,4}},{"Kneser",{14,5}},{"Kneser",{14,6}}};

GraphData[#,"Symmetric"]&/@kneser

GraphData[#,"EdgeIndices"][[1]]&/@kneser

gn=kneser[[1]];

edge=(edges=GraphData[gn,"EdgeIndices"])[[1]]

Select[Rest[edges],!FreeQ[#,edge[[2]]]&][[All,1]]

smallestpath[gn_,n_:1]:=Module[{edges=GraphData[gn,"EdgeIndices"],edge,verts},
edge=edges[[1]];
If[n===All,
verts=Complement[Flatten[Select[Rest[edges],!FreeQ[#,edge[[2]]]&]],edge];
Append[edge,#]&/@verts,
Append[edge,Complement[Flatten[Select[Rest[edges],!FreeQ[#,edge[[2]]]&]],edge][[n]]]
]
]

smallestpath[gn,All]

Direct

Function[gn,Print[{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],Method->"Paths","InitialVertices"->smallestpath[gn],"IndependenceNumber"->GraphData[gn,"IndependenceNumber"]],80*^9])//Timing}]]/@kneser;

With[{gn={"Kneser",{12,5}}},Print[{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[GraphData[gn],Method->"Paths","InitialVertices"->#,"IndependenceNumber"->GraphData[gn,"IndependenceNumber"]],80*^9])//Timing}]]&/@smallestpath[{"Kneser",{12,5}},All];

Direct on bigger

Function[gn,Print[{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],Method->"Paths",Debug->True,"MaxLength"->7,"InitialVertices"->{1,1232,7,1162},"IndependenceNumber"->GraphData[gn,"IndependenceNumber"]],80*^9])//Timing}]]/@{{"Kneser",{13,5}}};

Function[gn,Print[{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],Method->"Paths",Debug->True,"MaxLength"->7,"InitialVertices"->{1,1877,7,1751},"IndependenceNumber"->GraphData[gn,"IndependenceNumber"]],80*^9])//Timing}]]/@{{"Kneser",{14,5}}};

Function[gn,Print[{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],Method->"Paths",Debug->True,"MaxLength"->7,"InitialVertices"->{1,1036,6,871},"IndependenceNumber"->GraphData[gn,"IndependenceNumber"]],80*^9])//Timing}]]/@{{"Kneser",{15,4}}};

Function[gn,Print[{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],Method->"Paths",Debug->True,"MaxLength"->9,"InitialVertices"->{1,2976,8,2920},"IndependenceNumber"->GraphData[gn,"IndependenceNumber"]],80*^9])//Timing}]]/@{{"Kneser",{14,6}}};

Function[gn,Print[{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],Method->"Paths",Debug->True,"MaxLength"->11,"InitialVertices"->{1,2976,8,2920,7},"IndependenceNumber"->GraphData[gn,"IndependenceNumber"]],80*^9])//Timing}]]/@{{"Kneser",{14,6}}};

d=GraphDistanceMatrix[g=GraphData@{"Kneser",{14,6}}];

Length[p1=Position[d[[1]],_?(#<3&)]//Flatten]

Length[p2=Position[d[[2976]],_?(#<3&)]//Flatten]

(i=Intersection[p1,p2])//Length

g2=Subgraph[g,i]

FindOddChordlessCycle[IndexGraph[g2],Method->"Paths",Debug->True]//Timing

LargeWittGraph

GraphData["LargeWittGraph","Symmetric"]

edge=GraphData["LargeWittGraph","EdgeIndices"][[1]]

(cycle=FindOddChordlessCycle[g=GraphData["LargeWittGraph"],Method->"Paths","InitialVertices"->edge,Debug->True])//Timing

ChordlessCycleQ[g,cycle]

The cycle from stan

cycle=FindHamiltonianCycle[Subgraph[g=GraphData["LargeWittGraph"],{1,74,163,50,146}]][[1,All,1]]

ChordlessCycleQ[g,cycle]

MeredithGraph

GraphData[gn="MeredithGraph",{"Symmetric","VT","EdgeTransitive"}]

edge=(edges=GraphData[gn,"EdgeIndices"])[[1]]

Select[Rest[edges],!FreeQ[#,edge[[2]]]&][[All,1]]

alpha=GraphData["MeredithGraph","IndependenceNumber"]

With[{gn="MeredithGraph"},{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],Method->"Paths","InitialVertices"->{1,5,2},"MaxLength"->20,Debug->True],20*^9])//Timing}]

With[{gn="MeredithGraph"},{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],Method->"Paths","InitialVertices"->{1,5,3},"MaxLength"->20,Debug->True],20*^9])//Timing}]

With[{gn="MeredithGraph"},{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],Method->"Paths","InitialVertices"->{1,5,4},"MaxLength"->20,Debug->True],20*^9])//Timing}]

Mycielski

GraphData[gn={"Mycielski",7},{"V","Symmetric","VT","EdgeTransitive"}]

edge=(edges=GraphData[gn,"EdgeIndices"])[[1]]

alpha=GraphData[gn,"IndependenceNumber"]

Function[gn,Print[{gn,(cycle=FindOddChordlessCycle[g=GraphData[gn],Method->"Paths","InitialVertices"->{1,2},"MaxLength"->7])//Timing}]]/@Table[{"Mycielski",n},{n,3,8}];

Table[ChordlessCycleQ[GraphData[{"Mycielski",n}],{1,2,4,5,3}],{n,4,10}]

{“Odd”,6}

Length/@Table[cc=GraphData[{"Odd",n},"OddChordlessCycles"];Switch[cc,{},cc,_List,cc[[1]],Missing["NotAvailable"],{},Missing["NotAvailable",_],cc[[2]],_,cc],{n,7}]

GraphData[gn={"Odd",6},"Symmetric"]

edge=(edges=GraphData[gn,"EdgeIndices"])[[1]]

Select[Rest[edges],!FreeQ[#,edge[[2]]]&][[All,1]]

alpha=GraphData[{"Odd",6},"IndependenceNumber"]

{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],"MaxLength"->11,Method->"Paths","InitialVertices"->{1,457},Debug->True],50*^9])//Timing}

{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],"MaxLength"->11,Method->"Paths","InitialVertices"->{1,457,7},Debug->True],20*^9])//Timing}

ChordlessCycleQ[g,cycle]

{“Odd”,7}

Length/@Table[cc=GraphData[{"Odd",n},"OddChordlessCycles"];Switch[cc,{},cc,_List,cc[[1]],Missing["NotAvailable"],{},Missing["NotAvailable",_],cc[[2]],_,cc],{n,7}]

GraphData[gn={"Odd",7},{"Symmetric","Bipartite"}]

edge=(edges=GraphData[gn,"EdgeIndices"])[[1]]

Select[Rest[edges],!FreeQ[#,edge[[2]]]&][[All,1]]

Select[edges,!FreeQ[#,8]&][[All,2]]

alpha=GraphData[{"Odd",7},"IndependenceNumber"]

{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],"MaxLength"->13,Method->"Paths","InitialVertices"->{1,1710,8},Debug->True],50*^9])//Timing}

{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],"MaxLength"->13,Method->"Paths","InitialVertices"->{1,1710,8,1689},Debug->True],50*^9])//Timing}

{“Paley”, 81}

(cycle=FindOddChordlessCycle[g=GraphData[{"Paley",81}],"Partial"->10^7,Debug->True])//Timing

ChordlessCycleQ[g,cycle]

{“Paley”, 121}

(cycle=FindOddChordlessCycle[g=GraphData[{"Paley",121}],"Partial"->10^7,Debug->True])//Timing

ChordlessCycleQ[g,cycle]

{“Paley”, 169}

(cycle=FindOddChordlessCycle[g=GraphData[{"Paley",169}],"Partial"->10^7,Debug->True])//Timing

ChordlessCycleQ[g,cycle]

Queen

queens={{"Queen",{5,10}},{"Queen",{6,9}},{"Queen",{7,8}},{"Queen",{6,10}},{"Queen",{7,9}},{"Queen",{8,8}},{"Queen",{7,10}},{"Queen",{8,9}},{"Queen",{8,10}},{"Queen",{9,9}},{"Queen",{9,10}},{"Queen",{10,10}}};

Direct

Function[gn,Print[{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData[gn],"IndependenceNumber"->GraphData[gn,"IndependenceNumber"]],20*^9])//Timing}]]/@queens;

Complement

Function[gn,Print[{gn,(cycle=MemoryConstrained[FindOddChordlessCycle[gc=System`GraphComplement[GraphData[gn]],"IndependenceNumber"->IndependenceNumber[gc]],20*^9])//Timing}]]/@queens;

SuzukiGraph

GraphData["SuzukiGraph","Symmetric"]

edge=(edges=GraphData["SuzukiGraph","EdgeIndices"])[[1]]

Select[Rest[edges],!FreeQ[#,edge[[2]]]&][[All,2]]

(cycle=FindOddChordlessCycle[g=GraphData["SuzukiGraph"],Method->"Paths","InitialVertices"->{1,2,3},"MaxLength"->5,Debug->True])//Timing

(cycle=FindOddChordlessCycle[g=GraphData["SuzukiGraph"],Method->"Paths","InitialVertices"->{1,2,4},"MaxLength"->5,Debug->True])//Timing

ChordlessCycleQ[g,cycle]

From Stan

ChordlessCycleQ[GraphData["SuzukiGraph"],{1,2,81,14,6}]//Timing

TetrahedronReplacedCoxeterLineGraph

(cycle=FindOddChordlessCycle[g=GraphData["TetrahedronReplacedCoxeterLineGraph"],Method->"Paths",Debug->True])//Timing

ChordlessCycleQ[g,cycle]

TetrahedronReplacedPetersenLineGraph

(cycle=FindOddChordlessCycle[g=GraphData["TetrahedronReplacedPetersenLineGraph"],Method->"Paths",Debug->True])//Timing

ChordlessCycleQ[g,cycle]

TriangleReplacedCoxeterGraph

GraphData["TriangleReplacedCoxeterGraph",{"Symmetric","VT"}]

edge=(edges=GraphData["TriangleReplacedCoxeterGraph","EdgeIndices"])[[1]]

Select[Rest[edges],!FreeQ[#,edge[[2]]]&][[All,2]]

alpha=GraphData["TriangleReplacedCoxeterGraph","IndependenceNumber"]

{"TriangleReplacedCoxeterGraph",(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData["TriangleReplacedCoxeterGraph"],Method->"Paths","IndependenceNumber"->alpha,Debug->True],30*^9])//Timing}

{"TriangleReplacedCoxeterGraph",(cycle=MemoryConstrained[FindOddChordlessCycle[g=GraphData["TriangleReplacedCoxeterGraph"],Method->"Paths","InitialVertices"->{1,2,3},"IndependenceNumber"->alpha,Debug->True],30*^9])//Timing}

ChordlessCycleQ[g,cycle]

TruncatedDodecahedralGraph

GraphData["TruncatedDodecahedralGraph","LabeledImage"]

GraphData["TruncatedDodecahedralGraph",{"Perfect","Bipartite","Symmetric","VertexTransitive"}]

GraphData["TruncatedDodecahedralGraph","ComplementGraphName"]

Select[GraphData[All],GraphData[#,"LineGraphName"]==="TruncatedDodecahedralGraph"&]

edge=(edges=GraphData["TruncatedDodecahedralGraph","EdgeIndices"])[[1]]

Select[Rest[edges],!FreeQ[#,edge[[2]]]&][[All,2]]

alpha=GraphData["TruncatedDodecahedralGraph","IndependenceNumber"]

cyc=FindOddChordlessCycle[GraphData["TruncatedDodecahedralGraph"],"IndependenceNumber"->alpha,Method->"Paths",Debug->True]

Complement

gc=System`GraphComplement[GraphData["TruncatedDodecahedralGraph"]];

(alpha=IndependenceNumber[gc])//Timing

(cycle=MemoryConstrained[FindOddChordlessCycle[gc,"IndependenceNumber"->alpha,Debug->True],20*^9])//Timing

TruncatedWittGraph

GraphData["TruncatedWittGraph","Symmetric"]

edge=(edges=GraphData["TruncatedWittGraph","EdgeIndices"])[[1]]

Select[Rest[edges],!FreeQ[#,edge[[2]]]&][[All,2]]

{"TruncatedWittGraph",(cycle=FindOddChordlessCycle[g=GraphData["TruncatedWittGraph"],Method->"Paths","InitialVertices"->{1,130,131},"MaxLength"->5,Debug->True])//Timing}

ChordlessCycleQ[g,cycle]

Symmetric

new={{"NoncayleyTransitive",{28,9}},{"Kneser",{9,2}},{"Paley",41},{"Kneser",{10,2}},{"Paley",49},"HoffmanSingletonComplementGraph",{"Paley",53},{"Kneser",{11,2}},{"Triangular",11},"GossetGraph",{"Cyclotomic",61},{"Paley",61},{"StronglyRegular",{{63,32,16,16},1}},{"Cyclotomic",64},{"HalvedCube",7},{"Kneser",{12,2}},{"Triangular",12},{"Cyclotomic",67},{"Johnson",{8,4}},{"Cyclotomic",73},{"Paley",73},"M22Graph",{"Kneser",{13,2}},{"Triangular",13},{"Cyclotomic",79},"BrouwerHaemersGraph",{"Kneser",{9,3}},{"Tetrahedral",9},{"Paley",89},{"Kneser",{14,2}},{"Triangular",14},{"Cyclotomic",97},{"Paley",97},"HallJankoGraph","HigmanSimsGraph",{"Paley",101},{"Kneser",{15,2}},{"Triangular",15},{"Paley",109},{"GeneralizedQuadrangle",{3,9}},{"Paley",113},{"Arrangement",{6,3}},{"Kneser",{10,3}},{"StronglyRegular",{{120,56,28,24},1}},{"StronglyRegular",{{120,63,30,36},1}},{"Tetrahedral",10},{"Triangular",16},{"Paley",125},{"Johnson",{9,4}},{"Odd",5},{"Triangular",17},{"Paley",137},{"Paley",149},{"Triangular",18},{"Paley",157},"LocalMcLaughlinGraph",{"Kneser",{11,3}},{"Triangular",19},{"Triangular",20},{"Kneser",{10,4}},{"Kneser",{12,3}},{"Johnson",{10,5}},{"StronglyRegular",{{253,112,36,60},1}},{"FoldedCube",9},{"HalvedCube",9},"McLaughlinGraph",{"Kneser",{13,3}},{"Kneser",{11,4}},{"Arrangement",{6,4}},{"Kneser",{14,3}},{"Kneser",{15,3}},{"Odd",6},"Foster480C",{"Kneser",{12,4}},"Foster500A","Foster504E",{"HalvedCube",10},"Foster620A","Foster672C","Foster680A","Foster680B",{"Kneser",{13,4}},{"Kneser",{12,5}},"Foster816A","Foster816E","Foster816G","Foster936C",{"Kneser",{14,4}},{"Kneser",{13,5}},{"Kneser",{15,4}},{"Odd",7},{"Kneser",{14,5}},{"Kneser",{14,6}}};

Print[{#,FindOddChordlessCycle[GraphData[#],Method->"Paths","InitialVertices"->GraphData[#,"EdgeIndices"][[1]],"MaxLength"->7]/.{}->$Failed//Timing}]&/@new;

Select[l,!FreeQ[#,$Failed]&][[All,1]]

failed={{"NoncayleyTransitive",{28,9}},{"Odd",5},{"FoldedCube",9}}

Print[{#,FindOddChordlessCycle[GraphData[#],Method->"Paths","InitialVertices"->GraphData[#,"EdgeIndices"][[1]],"IndependenceNumber"->GraphData[#,"IndependenceNumber"]]//Timing}]&/@Rest@failed;