name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Std.ExtDTreeMap.getKey?_insert_self | Std.Data.ExtDTreeMap.Lemmas | [
"Std.ExtDTreeMap.getKey?",
"Std.DTreeMap",
"Std.DTreeMap.getKey?_insert_self",
"Std.ExtDTreeMap.insert",
"Option.some",
"Ordering",
"Std.TransCmp",
"Std.ExtDTreeMap.inductionOn",
"Std.ExtDTreeMap",
"Eq",
"Option"
] | true |
Qq.Impl.floatExprAntiquot | Qq.Macro | [
"Pure.pure",
"Lean.identKind",
"Monad.toApplicative",
"_private.Qq.Macro.0.Qq.Impl.floatExprAntiquot.match_5",
"_private.Qq.Macro.0.Qq.Impl.floatExprAntiquot.match_3",
"Lean.Syntax.Ident",
"_private.Qq.Macro.0.Qq.Impl.floatExprAntiquot.match_1",
"Lean.TSyntax.mk",
"Lean.Syntax",
"Array.map",
"Le... | true |
MeasureTheory.Measure.IsHaarMeasure.sigmaFinite | Mathlib.MeasureTheory.Group.Measure | [
"compactCovering",
"MeasureTheory.Measure.IsHaarMeasure",
"MeasureTheory.Measure",
"Set.univ",
"MeasureTheory.SigmaFinite",
"iUnion_compactCovering",
"Group",
"MeasureTheory.Measure.FiniteSpanningSetsIn.mk",
"MeasureTheory.Measure.IsHaarMeasure.toIsFiniteMeasureOnCompacts",
"isCompact_compactCover... | true |
LucasLehmer.X.left_distrib | Mathlib.NumberTheory.LucasLehmer | [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.Ring.Common.mul_congr",
"HMul.hMul",
"Nat.rawCast",
"ZMod.commRing",
"LucasLehmer.X.instMul",
"congrArg",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"Nat.instAtLeastTw... | true |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse_obj_mon_one_app | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | [
"CategoryTheory.CommMon.instCategory",
"CategoryTheory.Monoidal.monFunctorCategoryEquivalence",
"CategoryTheory.Functor",
"CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.inverse",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Func... | true |
FreeAddGroup.map._proof_1 | Mathlib.GroupTheory.FreeGroup.Basic | [
"Bool.not",
"congrArg",
"HEq.refl",
"List.map",
"Prod.mk",
"FreeAddGroup.Red.Step.casesOn",
"Prod.fst",
"List.cons",
"instHAppendOfAppend",
"List",
"FreeAddGroup.Red.Step",
"congr",
"True",
"eq_true",
"Bool",
"of_eq_true",
"Eq.ndrec",
"Eq.refl",
"HEq",
"List.map_append",
"Fre... | false |
Lean.Parser.Command.protected.parenthesizer | Lean.Parser.Command | [
"Lean.Parser.withCache.parenthesizer",
"Lean.Parser.mkAntiquot.parenthesizer",
"Lean.PrettyPrinter.Parenthesizer",
"instOfNatNat",
"Lean.PrettyPrinter.Parenthesizer.leadingNode.parenthesizer",
"Bool.true",
"Lean.Parser.symbol.parenthesizer",
"Nat",
"Lean.PrettyPrinter.Parenthesizer.withAntiquot.pare... | true |
AddOpposite.instMulZeroClass._proof_1 | Mathlib.Algebra.GroupWithZero.Opposite | [
"HMul.hMul",
"MulZeroClass.toMul",
"MulZeroClass.zero_mul",
"MulZeroClass",
"AddOpposite.instZero",
"AddOpposite",
"Zero.toOfNat0",
"AddOpposite.unop",
"AddOpposite.unop_injective",
"OfNat.ofNat",
"Eq",
"AddOpposite.instMul",
"MulZeroClass.toZero",
"instHMul"
] | false |
CategoryTheory.Limits.isLimitMapConeForkEquiv' | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Kernels | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.Functor",
"CategoryTheory.Limits.KernelFork.ofι",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.WalkingParallelPair",
"CategoryTheory.Functor.comp",
"CategoryTheory.Limits.walkingParallelPairHomCategory",
"Equ... | true |
Lean.Parser.Tactic.Grind.ring | Init.Grind.Interactive | [
"Lean.ParserDescr.nonReservedSymbol",
"Lean.Name.mkStr5",
"instOfNatNat",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"OfNat.ofNat",
"Bool.false"
] | true |
CompactlySupportedContinuousMapClass.hasCompactSupport | Mathlib.Topology.ContinuousMap.CompactlySupported | [
"outParam",
"CompactlySupportedContinuousMapClass",
"TopologicalSpace",
"DFunLike.coe",
"FunLike",
"HasCompactSupport",
"Zero"
] | true |
_private.Init.Data.Vector.OfFn.0.Vector.ofFn_succ._simp_1_1 | Init.Data.Vector.OfFn | [
"Decidable",
"left_eq_dite_iff",
"dite",
"propext",
"Eq",
"Not"
] | false |
_private.Mathlib.Topology.Algebra.Module.LinearPMap.0.LinearPMap.closureHasCore._simp_1_2 | Mathlib.Topology.Algebra.Module.LinearPMap | [
"And",
"Iff",
"propext",
"Eq",
"and_iff_left_iff_imp"
] | false |
AddAction.orbitRel.Quotient.addSubgroup_quotient_eq_iff | Mathlib.GroupTheory.GroupAction.Defs | [
"Eq.mpr",
"AddAction.orbit",
"AddMonoid.toAddSemigroup",
"AddAction.orbitRel.Quotient.orbit",
"congrArg",
"AddAction.instElemOrbit_1",
"Quotient.eq''",
"AddSubgroup.toAddGroup",
"Quotient.mk''",
"Membership.mem",
"AddAction.instAddAction",
"Set.Elem",
"id",
"Subtype",
"AddAction.orbitRel... | true |
Nat.sorted_divisorsAntidiagonalList_snd | Mathlib.NumberTheory.Divisors | [
"Nat.divisorsAntidiagonalList",
"List.Pairwise",
"GT.gt",
"Nat",
"instLTNat",
"Nat.pairwise_divisorsAntidiagonalList_snd",
"Prod",
"Prod.snd"
] | true |
Mathlib.Tactic.BicategoryLike.Normalize.Result.recOn | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | [
"Mathlib.Tactic.BicategoryLike.Normalize.Result.mk",
"Mathlib.Tactic.BicategoryLike.NormalizedHom",
"Mathlib.Tactic.BicategoryLike.Mor₂Iso",
"Mathlib.Tactic.BicategoryLike.Normalize.Result",
"Mathlib.Tactic.BicategoryLike.Normalize.Result.rec"
] | false |
DirectLimit.instNonAssocRingOfRingHomClass._proof_7 | Mathlib.Algebra.Colimit.DirectLimit | [
"RingHomClass.toAddMonoidHomClass",
"IntCast.intCast",
"Preorder.toLE",
"DirectLimit.instNonAssocRingOfRingHomClass._proof_6",
"NonAssocRing",
"Int",
"LE.le",
"Nat.cast",
"DirectLimit",
"DirectLimit.instAddCommGroupWithOneOfAddMonoidHomClass",
"NonAssocRing.toAddCommGroupWithOne",
"Nat",
"Is... | false |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeSortTR₂.run'.eq_3 | Init.Data.List.Sort.Impl | [
"instHDiv",
"List.MergeSort.Internal.mergeTR",
"List.MergeSort.Internal.splitRevInTwo'",
"Subtype",
"HDiv.hDiv",
"instOfNatNat",
"_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeSortTR₂.run'.eq_def",
"List.cons",
"List",
"instHAdd",
"_private.Init.Data.List.Sort.Impl.0.List.Merg... | true |
CategoryTheory.Subgroupoid.full | Mathlib.CategoryTheory.Groupoid.Subgroupoid | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"setOf",
"Membership.mem",
"CategoryTheory.Groupoid",
"CategoryTheory.Subgroupoid.full._proof_2",
"And",
"CategoryTheory.Subgroupoid",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Groupoid.toCategory",
"CategoryTheory.Subgrou... | true |
TensorialAt.mkHom₂._proof_4 | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | [
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"instHSMul",
"Prod.normedSpace",
"CompleteSpace",
"instAddMonoidWithOneENat",
"chartedSpaceSelf",
"Prod.normedAddCommGroup",
"NormedSpace",
"mdifferentiable_const",
"FiberBundle",
"congrArg",
"CommSemiring.toSemiring",
"DistribMulAction.toDi... | false |
CategoryTheory.hasSeparator_op_iff._simp_1 | Mathlib.CategoryTheory.Generator.Basic | [
"CategoryTheory.HasSeparator",
"Opposite",
"CategoryTheory.HasCoseparator",
"propext",
"CategoryTheory.Category.opposite",
"Eq",
"CategoryTheory.hasSeparator_op_iff",
"CategoryTheory.Category"
] | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.count_support._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Paths | [
"Lean.Grind.Nat.lt_eq",
"SimpleGraph.Walk.support",
"SimpleGraph.Walk",
"instOfNatNat",
"LE.le",
"instLENat",
"List.tail",
"SimpleGraph",
"GetElem.getElem",
"List.getElem_filter_eq_getElem_getElem_findIdxs._proof_5",
"List.findIdxs",
"List",
"Nat",
"List.filter",
"LT.lt",
"Eq.substr",
... | false |
WithConv.instAddAction | Mathlib.Algebra.WithConv | [
"AddAction.mk",
"Equiv.instEquivLike",
"AddMonoid.toAddSemigroup",
"Equiv",
"VAdd.mk",
"HVAdd.hVAdd",
"AddAction",
"AddAction.toAddSemigroupAction",
"AddSemigroupAction.mk",
"AddSemigroupAction.toVAdd",
"WithConv.equiv",
"WithConv.instAddAction._proof_1",
"WithConv.instAddAction._proof_2",
... | true |
HomologicalComplex.homotopyCofiber.inlX_d' | Mathlib.Algebra.Homology.HomotopyCofiber | [
"CategoryTheory.Category.assoc",
"HomologicalComplex.instCategory",
"HomologicalComplex.homotopyCofiber.X",
"HomologicalComplex.Hom.f",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"HomologicalComplex.homotopyCofiber.ext_to_X'",
"AddMonoid.toA... | true |
Finset.empty_sups | Mathlib.Data.Finset.Sups | [
"Finset.hasSups",
"Finset",
"SemilatticeSup.toMax",
"Finset.instEmptyCollection",
"Finset.image₂_empty_left",
"Max.max",
"EmptyCollection.emptyCollection",
"Eq",
"SemilatticeSup",
"HasSups.sups",
"DecidableEq"
] | true |
Polynomial.mapAlgEquiv._proof_2 | Mathlib.Algebra.Polynomial.AlgebraMap | [
"AlgEquiv.toAlgHom",
"AlgEquiv.symm",
"congrArg",
"AlgHom",
"Polynomial.algebraOfAlgebra",
"AlgHom.id",
"Algebra",
"Polynomial.mapAlgHom",
"AlgEquiv.symm_comp",
"Polynomial",
"CommSemiring",
"AlgEquiv",
"Polynomial.semiring",
"True",
"eq_self",
"of_eq_true",
"Semiring",
"congrFun'"... | false |
ContDiffMapSupportedIn.toBoundedContinuousFunctionCLM._proof_1 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | [
"ContDiffMapSupportedIn.toBoundedContinuousFunctionLM._proof_4",
"NormedCommRing.toSeminormedCommRing",
"Real",
"Continuous",
"NormedSpace.toIsBoundedSMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"NormedSpace",
"ContDiffMapSupportedIn.toBoundedContinuousFunctionLM",
"DistribMulAction.t... | false |
Matrix.SpecialLinearGroup.toGLPos._proof_4 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Defs | [
"CommRing",
"Matrix.SpecialLinearGroup",
"Preorder.toLT",
"HMul.hMul",
"Monoid.toMulOneClass",
"CommSemiring.toSemiring",
"Matrix",
"NeZero.charZero_one",
"LinearOrder",
"PartialOrder.toPreorder",
"AddGroupWithOne.toAddMonoidWithOne",
"IsStrictOrderedRing",
"SemilatticeInf.toPartialOrder",
... | false |
Function.Injective.noZeroSMulDivisors | Mathlib.Algebra.NoZeroSMulDivisors.Defs | [
"Eq.mpr",
"instHSMul",
"congrArg",
"NoZeroSMulDivisors.eq_zero_or_eq_zero_of_smul_eq_zero",
"SMul",
"Eq.rec",
"id",
"NoZeroSMulDivisors.mk",
"NoZeroSMulDivisors",
"Zero.toOfNat0",
"Eq.refl",
"HSMul.hSMul",
"Or",
"Function.Injective",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"Or.imp_right",
... | true |
Matrix.IsAdjMatrix.symm | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | [
"One",
"Matrix",
"Matrix.IsAdjMatrix",
"Matrix.IsSymm",
"Zero"
] | true |
Multiset.sup_cons | Mathlib.Data.Multiset.Lattice | [
"Multiset.fold_cons_left",
"instCommutativeMax_mathlib",
"instAssociativeMax_mathlib",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"OrderBot",
"SemilatticeSup.toMax",
"Multiset",
"Multiset.cons",
"Bot.bot",
"Max.max",
"SemilatticeSup.toPartialOrder",
"Multiset.sup",
"Eq... | true |
Std.Do.SVal.getThe_here | Std.Do.SPred.SVal | [
"Std.Do.SVal.instGetTyCons",
"Std.Do.SVal.StateTuple",
"List.cons",
"List",
"Std.Do.SVal",
"Std.Do.SVal.getThe",
"Std.Do.SVal.curry",
"Eq",
"rfl"
] | true |
Lean.Doc.PostponedCheck._sizeOf_inst | Lean.Elab.DocString.Builtin.Postponed | [
"Lean.Doc.PostponedCheck",
"SizeOf.mk",
"SizeOf",
"Lean.Doc.PostponedCheck._sizeOf_1"
] | false |
subsetConditionallyCompleteLinearOrder._proof_3 | Mathlib.Order.CompleteLatticeIntervals | [
"Inhabited.default",
"False",
"Lattice.toSemilatticeSup",
"eq_false",
"congrArg",
"PartialOrder.toPreorder",
"Subtype.instLinearOrder",
"false_and",
"Classical.propDecidable",
"Preorder.toLE",
"Membership.mem",
"bddAbove_empty._simp_2",
"Set.Elem",
"DistribLattice.toLattice",
"Conditiona... | false |
isUpperSet_setOf | Mathlib.Order.UpperLower.Basic | [
"Iff.rfl",
"PartialOrder.toPreorder",
"Monotone",
"setOf",
"IsUpperSet",
"Preorder.toLE",
"Iff",
"Prop.partialOrder",
"Preorder"
] | true |
Lean.Level.PP.Result.offset.elim | Lean.Level | [
"PULift.up",
"Lean.Level.PP.Result.ctorElim",
"Lean.Level.PP.Result.ctorIdx",
"Lean.Level.PP.Result",
"Nat",
"Eq.symm",
"Eq",
"Lean.Level.PP.Result.offset"
] | false |
_private.Lean.Elab.BuiltinDo.Let.0.Lean.Elab.Do.elabDoLetOrReassign.match_1 | Lean.Elab.BuiltinDo.Let | [
"Unit.unit",
"Lean.Elab.Do.LetOrReassign.ctorIdx",
"Nat.hasNotBit",
"Lean.Elab.Do.LetOrReassign.have",
"Unit",
"_private.Lean.Elab.BuiltinDo.Let.0.Lean.Elab.Do.elabDoLetOrReassign._sparseCasesOn_1",
"Lean.Elab.Do.LetOrReassign"
] | false |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_9 | Mathlib.Data.List.Cycle | [
"List.head",
"False",
"Lean.Grind.nestedProof",
"eq_false",
"_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_5",
"Lean.Grind.iff_eq",
"Classical.byContradiction",
"HSub.hSub",
"List.instGetElem?NatLtLength",
"Option.some",
"Membership.mem",
"List.ne_nil_... | false |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score.isAwful | Lean.Data.FuzzyMatching | [
"Int16.decLe",
"Int16",
"instLEInt16",
"LE.le",
"_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score.awful",
"_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score.inner",
"Bool",
"_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score",
"Decidable.decide"
] | true |
FreeAddMonoid.lift_ofList | Mathlib.Algebra.FreeMonoid.Basic | [
"FreeAddMonoid.ofList",
"FreeAddMonoid.toList",
"Equiv.instEquivLike",
"List.map",
"AddMonoid.toAddZeroClass",
"List.sum",
"FreeAddMonoid.instAddCancelMonoid",
"AddCancelMonoid.toAddRightCancelMonoid",
"AddZeroClass.toAddZero",
"Equiv",
"AddZero.toZero",
"FreeAddMonoid.sumAux_eq",
"List",
... | true |
Array.findIdxM? | Init.Data.Array.Basic | [
"Pure.pure",
"instForInOfForIn'",
"Monad.toApplicative",
"Array.instMembership",
"Option.some",
"ForInStep.done",
"inferInstance",
"instDecidableEqBool",
"Prod.mk",
"ForIn.forIn",
"instOfNatNat",
"Applicative.toPure",
"Membership",
"ForInStep",
"Prod.fst",
"Array",
"Bool.true",
"Op... | true |
_private.Init.Data.Array.Erase.0.Array.eraseIdx_set_lt._proof_2 | Init.Data.Array.Erase | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.ofNat_sub_dichotomy",
"Lean.Omega.Int.add_congr",
"Lean.Omega.LinearCombo.eval"... | false |
CategoryTheory.GlueData.recOn | Mathlib.CategoryTheory.GlueData | [
"CategoryTheory.GlueData.mk",
"CategoryTheory.Limits.pullback",
"CategoryTheory.IsIso",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.pullback.snd",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Limits.HasPullback",
"Prod.mk",
"Catego... | false |
Submodule.mkQL | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Quotient | [
"Submodule",
"Submodule.Quotient.addCommMonoid",
"QuotientModule.Quotient.topologicalSpace",
"AddCommGroup.toAddCommMonoid",
"ContinuousLinearMap.mk",
"Submodule.hasQuotient",
"AddCommGroup",
"Submodule.Quotient.module",
"LinearMap",
"ContinuousLinearMap",
"TopologicalSpace",
"HasQuotient.Quot... | true |
Lean.Widget.RpcEncodablePacket.type._@.Lean.Server.FileWorker.WidgetRequests.2734021171._hygCtx._hyg.1 | Lean.Server.FileWorker.WidgetRequests | [
"Lean.Json",
"Lean.Widget.RpcEncodablePacket._@.Lean.Server.FileWorker.WidgetRequests.2734021171._hygCtx._hyg.1"
] | false |
Std.DTreeMap.Internal.Impl.min?_keys | Std.Data.DTreeMap.Internal.Lemmas | [
"Std.LawfulOrderOrd",
"Eq.mpr",
"List.min?",
"Std.Internal.List.min?_keys",
"Ord",
"congrArg",
"Std.TransOrd",
"Std.LawfulOrderMin",
"Std.LawfulOrderLeftLeaningMin",
"Std.Internal.List.minKey?",
"Std.DTreeMap.Internal.Impl.WF.ordered",
"id",
"Std.DTreeMap.Internal.Impl.minKey?",
"Std.DTree... | true |
FractionalIdeal.mem_coeSubmodule._simp_1 | Mathlib.RingTheory.FractionalIdeal.Basic | [
"Submodule",
"CommRing",
"Semiring.toModule",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"FractionalIdeal.mem_coeSubmodule",
"Algebra",
"RingHom",
"Membership.mem",
"Exists",
"Algebra.toModule",
"Ideal",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"And",
"CommRing.toCommSemiring",... | false |
MeasureTheory.Measure.sInf_caratheodory | Mathlib.MeasureTheory.Measure.MeasureSpace | [
"Eq.mpr",
"ENNReal.instAdd",
"MeasureTheory.OuterMeasure.boundedBy_caratheodory",
"MeasureTheory.Measure",
"iInf",
"MeasureTheory.OuterMeasure.caratheodory",
"MeasureTheory.OuterMeasure.boundedBy",
"MeasurableSet",
"ENNReal.instAddCommMonoid",
"congrArg",
"CompletelyDistribLattice.toCompleteLatt... | true |
Filter.add_neBot_iff | Mathlib.Order.Filter.Pointwise | [
"Filter.instAdd",
"Filter.map₂_neBot_iff",
"Filter.NeBot",
"instHAdd",
"And",
"Iff",
"HAdd.hAdd",
"Filter",
"Add"
] | true |
Nat.fold_congr._proof_2 | Init.Data.Nat.Fold | [
"_private.Init.Data.Nat.Fold.0.Nat.fold_congr._proof_1",
"Nat",
"LT.lt",
"Decidable.byContradiction",
"Nat.decLt",
"instLTNat",
"Eq",
"Not"
] | false |
_private.Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn.0.ApproximatesLinearOn.surjOn_closedBall_of_nonlinearRightInverse._simp_1_1 | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | [
"Real.instLE",
"Real",
"Real.instZero",
"dist_le_zero",
"LE.le",
"MetricSpace",
"propext",
"Zero.toOfNat0",
"MetricSpace.toPseudoMetricSpace",
"Dist.dist",
"PseudoMetricSpace.toDist",
"OfNat.ofNat",
"Eq"
] | false |
SimpleGraph.exists_isAcyclic_reachable_eq_le_of_le_of_isAcyclic | Mathlib.Combinatorics.SimpleGraph.Acyclic | [
"SimpleGraph.IsAcyclic",
"Exists",
"LE.le",
"_private.Mathlib.Combinatorics.SimpleGraph.Acyclic.0.SimpleGraph.exists_isAcyclic_reachable_eq_le_of_le_of_isAcyclic._proof_1_1",
"SimpleGraph",
"And",
"Exists.casesOn",
"Maximal",
"SimpleGraph.exists_maximal_isAcyclic_of_le_isAcyclic",
"Eq",
"SimpleG... | true |
CategoryTheory.ComposableArrows.sc'Map_τ₃ | Mathlib.Algebra.Homology.ExactSequence | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.ComposableArrows.sc'Map._auto_3",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ComposableArrows.IsComplex",
"CategoryTheory.ComposableArrows.map'._proof_8",
"PartialOrder.toPreorder",
"CategoryTheory.Functor.category"... | true |
PNat.pos_of_div_pos | Mathlib.Data.PNat.Basic | [
"PNat.val",
"Iff.mpr",
"Nat.instMulZeroClass",
"Preorder.toLT",
"Dvd.dvd",
"LinearOrderedCommMonoidWithZero.toIsBotZeroClass",
"Nat.instSemigroupWithZero",
"congrArg",
"PartialOrder.toPreorder",
"PNat.ne_zero",
"Eq.mp",
"Ne",
"instOfNatNat",
"Nat.instDvd",
"Nat",
"LT.lt",
"Nat.instPa... | true |
Scott.isOpen_univ | Mathlib.Topology.OmegaCompletePartialOrder | [
"Set.univ",
"Prop.instCompleteLattice",
"OmegaCompletePartialOrder",
"CompleteLattice.ωScottContinuous.top",
"Scott.IsOpen"
] | true |
NormedRing.inverse_one_sub_norm | Mathlib.Analysis.Normed.Ring.Units | [
"AddGroup.toSubtractionMonoid",
"Real.instIsOrderedRing",
"Norm.norm",
"Mathlib.Tactic.Ring.Common.neg_zero",
"Units.val",
"SeminormedAddGroup.toNorm",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.Ring.Common.neg_mul... | true |
CategoryTheory.Grpd.forgetToCat._proof_1 | Mathlib.CategoryTheory.Groupoid.Grpd.Basic | [
"CategoryTheory.Cat.category",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.toCatHom",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Cat.of",
"CategoryTheory.Groupoid",
"id",
"CategoryTheory.Cat",
"CategoryTheory.Grpd.str'",
"CategoryTheory.Grpd.category"... | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.isLevelDefEqS.match_1.eq_6 | Lean.Meta.Sym.Pattern | [
"Lean.Level.param",
"Lean.Level.imax",
"Lean.Level",
"Unit",
"Lean.Level.zero",
"Lean.Name",
"Eq.refl",
"Lean.Level.succ",
"Eq",
"Lean.Level.max",
"_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.isLevelDefEqS.match_1"
] | true |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic.0.MeasureTheory.simpleFuncAux.congr_simp | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | [
"MeasurableSingletonClass",
"_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic.0.MeasureTheory.simpleFuncAux",
"MeasureTheory.SimpleFunc",
"Eq.rec",
"MeasurableSpace",
"Nat",
"Eq.refl",
"Eq"
] | true |
CategoryTheory.WithTerminal.commaFromOver | Mathlib.CategoryTheory.WithTerminal.Cone | [
"CategoryTheory.Over",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.WithTerminal.commaFromOver._proof_7",
"Quiver.Hom",
"CategoryTheory.WithTerminal.commaFromOver._proof_5",
"CategoryTheory.Functor.mk",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor... | true |
CategoryTheory.StrictPseudofunctor.mk.noConfusion | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | [
"CategoryTheory.StrictlyUnitaryPseudofunctor.toPseudofunctor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.StrictPseudofunctor.map_comp._autoParam",
"HEq.refl",
"CategoryTheory.eqToIso",
"CategoryTheory.StrictPseudofunctor.mk",
"id",
"CategoryTheory.Iso",
"CategoryTheor... | false |
Lean.Widget.TaggedText.instRpcEncodable | Lean.Widget.TaggedText | [
"Lean.Json",
"ReaderT",
"Monad.toApplicative",
"String",
"instMonadLiftT",
"Lean.FromJson.fromJson?",
"Lean.Widget.instToJsonTaggedText",
"ReaderT.instMonad",
"Lean.ToJson.toJson",
"liftM",
"Id",
"Lean.instToJsonJson",
"Lean.Widget.TaggedText",
"ExceptT",
"Lean.Server.RpcEncodable.rpcDec... | true |
Rel.interedges_eq_biUnion | Mathlib.Combinatorics.SimpleGraph.Density | [
"Finset.mem_filter._simp_1",
"Rel.interedges",
"instDecidableEqProd",
"congrArg",
"Finset",
"Finset.mem_biUnion._simp_1",
"Finset.ext",
"Finset.map",
"Membership.mem",
"Exists",
"Function.Embedding.mk",
"Prod.mk",
"_private.Mathlib.Combinatorics.SimpleGraph.Density.0.Rel.interedges_eq_biUnio... | true |
_private.Mathlib.Algebra.Group.Subsemigroup.Membership.0.Subsemigroup.mem_iSup_of_directed.match_1_1 | Mathlib.Algebra.Group.Subsemigroup.Membership | [
"Mul",
"Membership.mem",
"Exists",
"Exists.casesOn",
"Subsemigroup",
"Exists.intro",
"Subsemigroup.instSetLike",
"SetLike.instMembership"
] | false |
sub_add_eq_sub_sub | Mathlib.Algebra.Group.Basic | [
"neg_add_rev",
"AddMonoid.toAddSemigroup",
"congrArg",
"add_assoc",
"AddMonoid.toAddZeroClass",
"sub_eq_add_neg",
"HSub.hSub",
"AddZeroClass.toAddZero",
"SubtractionMonoid.toSubNegMonoid",
"SubtractionCommMonoid.toSubtractionMonoid",
"add_comm",
"SubtractionCommMonoid.toAddCommMonoid",
"SubN... | true |
AddGroup.rank_le_of_surjective | Mathlib.GroupTheory.Rank | [
"Eq.mpr",
"LE.le.trans_eq",
"AddGroup.rank_le",
"congrArg",
"Finset",
"AddMonoid.toAddZeroClass",
"AddSubgroup.map_top_of_surjective",
"Classical.propDecidable",
"Exists",
"AddMonoidHom.map_closure",
"AddZeroClass.toAddZero",
"Finset.coe_image",
"AddGroup.rank_spec",
"id",
"LE.le",
"in... | true |
CategoryTheory.prod.associator._proof_1 | Mathlib.CategoryTheory.Products.Associator | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Prod.mkHom",
"CategoryTheory.CategoryStruct.id",
"id",
"Prod.mk",
"Prod.fst",
"CategoryTheory.prod'",
"Eq.refl",
"CategoryTheory.Category.toCategoryStruct",
"Prod",
"Eq",
"Prod.snd",
"CategoryTheory.Category"
] | false |
RingCon.smulCommClass | Mathlib.RingTheory.Congruence.Basic | [
"RingCon.toCon",
"RingCon.instSMulQuotient",
"instHSMul",
"instSMulOfMul",
"HMul.hMul",
"IsScalarTower",
"RingCon.instMulQuotient",
"SMul",
"Quotient.mk''",
"RingCon",
"Quotient.ind₂'",
"MulOne.toMul",
"RingCon.Quotient",
"congr_arg",
"MulOneClass.toMulOne",
"Quotient",
"Con.toSetoid... | true |
List.form_perm_zpow_apply_mem_imp_mem | Mathlib.GroupTheory.Perm.List | [
"Eq.mpr",
"Equiv.instEquivLike",
"Equiv.Perm.set_support_zpow_subset",
"congrArg",
"Finset",
"List.coe_toFinset",
"setOf",
"DivInvMonoid.toZPow",
"Membership.mem",
"Eq.mp",
"id",
"Ne",
"Int",
"List.toFinset",
"dite",
"List.formPerm",
"Group.toDivInvMonoid",
"Equiv.Perm.permGroup",
... | true |
Std.IterM.toListRev.go.eq_1 | Init.Data.Iterators.Lemmas.Consumers.Monadic.Collect | [
"Pure.pure",
"Std.Shrink",
"Monad.toApplicative",
"Std.IterM.TerminationMeasures.Finite",
"InvImage",
"Std.IterM.finitelyManySteps!",
"Std.IterM.toListRev.go",
"Std.IterM.IsPlausibleStep",
"Std.IterStep.skip",
"Applicative.toPure",
"Std.IterM.toListRev.go._proof_2",
"Std.Iterator",
"List.con... | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.ctorElim | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Basic | [
"Lean.ConstructorVal",
"Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.simpleEnum",
"Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.casesOn",
"Array",
"Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind.enumWithDefault",
"Lean.Elab.Tactic.BVDecide.Frontend.Normalize.MatchKind",
"Nat"... | false |
ModuleCat.CoextendScalars.instCoeFunCarrierObjCoextendScalarsForall | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | [
"Semiring.toModule",
"ModuleCat.coextendScalars",
"ModuleCat",
"AddCommGroup.toAddCommMonoid",
"LinearMap.instFunLike",
"RingHom",
"CoeFun.mk",
"ModuleCat.CoextendScalars.equiv",
"ModuleCat.restrictScalars",
"LinearMap",
"ModuleCat.of",
"ModuleCat.isAddCommGroup",
"Ring.toAddCommGroup",
"M... | true |
Topology.IsLower.closure_singleton | Mathlib.Topology.Order.LowerUpperTopology | [
"Set.Subset.antisymm",
"Eq.ge",
"Set.Ici",
"subset_closure",
"closure_minimal",
"Topology.IsLower.instClosedIciTopology",
"Membership.mem",
"IsUpperSet.Ici_subset",
"Set.instSingletonSet",
"Topology.IsLower",
"TopologicalSpace",
"closure",
"Topology.IsLower.isUpperSet_of_isClosed",
"Single... | true |
CategoryTheory.Pseudofunctor.toLax._proof_7 | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.Iso.comp_inv_eq",
"CategoryTheory.Bicategory.inv_hom_whiskerRight_assoc",
"CategoryTheory.Pseudofunctor.mapId",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Pseudofunctor.map₂_left_unitor",
"Quiver.Hom",
"congrArg",
"CategoryT... | false |
Sublattice.pi_univ_bot | Mathlib.Order.Sublattice | [
"Sublattice",
"Lattice",
"Sublattice.instBot",
"Set.univ_nonempty._simp_1",
"congrArg",
"Set.univ",
"Bot.bot",
"Pi.instLattice",
"Set.Nonempty",
"Sublattice.pi",
"Sublattice.pi_bot",
"True",
"eq_self",
"of_eq_true",
"Nonempty",
"congrFun'",
"Eq",
"Eq.trans"
] | true |
ContinuousMap.HomotopyWith.noConfusionType | Mathlib.Topology.Homotopy.Basic | [
"Real",
"ContinuousMap.HomotopyWith.casesOn",
"ContinuousMap.mk",
"ContinuousMap",
"Continuous.comp",
"PseudoMetricSpace.toUniformSpace",
"instTopologicalSpaceProd",
"Membership.mem",
"ContinuousMap.Homotopy.toContinuousMap",
"Set.Elem",
"Prod.mk",
"ContinuousMap.HomotopyWith",
"TopologicalS... | false |
Nat.Partition.card_restricted_eq_card_countRestricted | Mathlib.Combinatorics.Enumerative.Partition.Glaisher | [
"instDecidableNot",
"Int.instIsStrictOrderedRing",
"Dvd.dvd",
"Semiring.toModule",
"Nat.Partition.restricted",
"congrArg",
"CommSemiring.toSemiring",
"Int.instLinearOrder",
"Nat.decidable_dvd",
"PartialOrder.toPreorder",
"AddGroupWithOne.toAddMonoidWithOne",
"LinearMap.instFunLike",
"Preorde... | true |
Cubic.coeff_eq_b | Mathlib.Algebra.CubicDiscriminant | [
"Cubic.c",
"instOfNatNat",
"Cubic.toPoly",
"Cubic.d",
"Polynomial.coeff",
"GT.gt",
"And",
"And.right",
"And.left",
"Cubic.b",
"Nat",
"Cubic.a",
"Semiring",
"Cubic",
"_private.Mathlib.Algebra.CubicDiscriminant.0.Cubic.coeffs",
"Zero.toOfNat0",
"instLTNat",
"OfNat.ofNat",
"Eq",
"... | true |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pos.revSkipWhile.match_1.eq_2 | Init.Data.String.Lemmas.Pattern.Char | [
"Eq.mpr",
"False",
"Nat.ne_of_beq_eq_false",
"_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pos.revSkipWhile.match_1.splitter._sparseCasesOn_2",
"Option.ctorIdx",
"congrArg",
"False.elim",
"Nat.shiftRight",
"Option.some",
"String.Slice",
"id",
"Nat.hasNotBit",
"Option.rec",
... | true |
Std.DTreeMap.Const.get?_unitOfList | Std.Data.DTreeMap.Lemmas | [
"Unit.unit",
"List.contains",
"Ord.mk",
"Option.some",
"Ordering",
"Std.DTreeMap.Const.get?",
"instDecidableEqBool",
"Std.TransCmp",
"Bool.true",
"Option.none",
"List",
"Unit",
"Std.LawfulBEqCmp",
"Std.DTreeMap.Const.unitOfList",
"Bool",
"Std.DTreeMap.Internal.Impl.Const.get?_insertMan... | true |
_private.Mathlib.Analysis.Normed.Field.Approximation.0.Polynomial.exists_monic_and_natDegree_eq_and_norm_map_algebraMap_coeff_sub_lt._simp_1_1 | Mathlib.Analysis.Normed.Field.Approximation | [
"Polynomial.instOne",
"Polynomial",
"Polynomial.Monic",
"True",
"eq_true",
"Semiring",
"One.toOfNat1",
"Polynomial.monic_one",
"OfNat.ofNat",
"Eq"
] | false |
NonUnitalAlgebra.instIsMulCommutative_adjoin | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | [
"SetLike",
"Semigroup.toMul",
"NonUnitalSubalgebra",
"instSMulOfMul",
"NonUnitalSubalgebra.toNonUnitalNonAssocSemiring",
"MulMemClass.toSemigroup",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"IsScalarTower",
"setLike_mul_comm",
"AddMonoid.toAddZeroClass",
"MulMemClass",
"No... | true |
LibraryNote.RCLike_instance | Mathlib.Analysis.RCLike.Lemmas | [
"Inhabited.default",
"Batteries.Util.instInhabitedLibraryNote",
"Batteries.Util.LibraryNote"
] | true |
ZMod.euler_criterion | Mathlib.NumberTheory.LegendreSymbol.Basic | [
"Units.val",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"MulOne.toOne",
"False",
"Nat.Prime",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"iff_congr",
"False.elim",
"AddGroupWithOne.toAddMonoidWithOne",
"DivisionSemiring.toGroupWithZero",
"_private.Mathlib.NumberTheory.... | true |
_private.Mathlib.MeasureTheory.Measure.MeasureSpace.0.MeasureTheory.Measure.measure_sInf_le | Mathlib.MeasureTheory.Measure.MeasureSpace | [
"Iff.mpr",
"Eq.mpr",
"MeasureTheory.Measure",
"MeasurableSet",
"congrArg",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"CompleteLattice.toConditionallyCompleteLattice",
"MeasureTheory.OuterMeasure",
"id",
"LE.le",
"MeasureTheory.Measure.sInf_apply",
"MeasurableSpace",
"... | true |
TopCat.Presheaf.stalkSpecializes_stalkFunctor_map_assoc | Mathlib.Topology.Sheaves.Stalks | [
"CategoryTheory.Category.assoc",
"Specializes",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"TopCat.instCategoryPresheaf",
"TopCat.Presheaf.stalkSpecializes",
"Eq.mp",
"TopCat.Presheaf",
"id",
"Mathlib.Tactic.Reassoc.eq_whisker'",
"TopCat.Presheaf.stalk",
"CategoryThe... | true |
List.Nodup.not_mem_erase | Init.Data.List.Erase | [
"False",
"congrArg",
"False.elim",
"LawfulBEq",
"Membership.mem",
"Eq.mp",
"not_true_eq_false",
"Ne",
"List.Nodup",
"List",
"And",
"List.erase",
"List.instMembership",
"And.left",
"True",
"eq_self",
"Iff.mp",
"List.Nodup.mem_erase_iff",
"BEq",
"Eq",
"Not",
"Eq.trans"
] | true |
Summable.mono_filter | Mathlib.Topology.Algebra.InfiniteSum.Defs | [
"Finset",
"SummationFilter",
"PartialOrder.toPreorder",
"Preorder.toLE",
"nhds",
"LE.le",
"AddCommMonoid",
"TopologicalSpace",
"HasSum",
"Exists.intro",
"SummationFilter.filter",
"Filter.Tendsto.mono_left",
"Summable",
"_private.Mathlib.Topology.Algebra.InfiniteSum.Defs.0.Summable.mono_fil... | true |
Matroid.IsNonloop.mem_ground | Mathlib.Combinatorics.Matroid.Loop | [
"Matroid.E",
"Membership.mem",
"Matroid.IsNonloop",
"Set.instMembership",
"Matroid",
"Set"
] | true |
Frm.hasForgetToLat._proof_1 | Mathlib.Order.Category.Frm | [
"FrameHom",
"Lattice.toSemilatticeSup",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CompleteLattice.toLattice",
"FrameHomClass.toBoundedLatticeHomClass",
"Lat.of",
"CategoryTheory.CategoryStruct.id",
"SemilatticeSup.toMax",
"CompleteLattice.toBoundedOrder",
"id",
"Frm.Hom.hom",
... | false |
Batteries.Tactic.casePattArg | Batteries.Tactic.Case | [
"Lean.Name.mkStr3",
"instOfNatNat",
"Lean.ParserDescr.nodeWithAntiquot",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.unary",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.ParserDescr.cat",
"Lean.Parser.Tactic.caseArg",
"OfNat.ofNat",
"Lean.Name.mkStr1"
] | true |
Int32.neg_eq_not_add | Init.Data.SInt.Bitwise | [
"Int32.toBitVec",
"BitVec.neg_eq_not_add",
"Int32.toBitVec_inj",
"BitVec",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Complement.complement",
"Iff.mp",
"Int32.instOfNat",
"instComplementInt32",
"instAddInt32",
"OfNat.ofNat",
"Eq",
"Int32.instNeg",
"Neg.neg",
"Int32"
] | true |
WeierstrassCurve.Affine.CoordinateRing.basis_one | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | [
"Eq.mpr",
"WeierstrassCurve.Affine.monic_polynomial",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"WeierstrassCurve.Affine.CoordinateRing.mk",
"AdjoinRoot",
"congrArg",
"CommSemiring.toSemiring",
"PowerBasis.gen",
"RingHom",
"Algebra.toModule",
... | true |
NonAssocCommRing.intCast._inherited_default | Mathlib.Algebra.Ring.Defs | [
"Neg.mk",
"id",
"Int",
"Nat",
"NatCast.mk",
"Int.castDef"
] | false |
Turing.PartrecToTM2.Γ'.enumList_getElem?_ctorIdx_eq | Mathlib.Computability.TuringMachine.ToPartrec | [
"Turing.PartrecToTM2.Γ'.ctorIdx",
"Turing.PartrecToTM2.Γ'",
"List.instGetElem?NatLtLength",
"Option.some",
"_private.Mathlib.Computability.TuringMachine.ToPartrec.0._proof_23",
"List",
"Turing.PartrecToTM2.Γ'.enumList",
"Nat",
"LT.lt",
"instLTNat",
"GetElem?.getElem?",
"Eq",
"List.length",
... | true |
Submonoid.LocalizationMap.ofMulEquivOfLocalizations_apply | Mathlib.GroupTheory.MonoidLocalization.Maps | [
"MulEquiv.instEquivLike",
"Monoid.toMulOneClass",
"MulOne.toMul",
"MulOneClass.toMulOne",
"CommMonoid.toMonoid",
"Submonoid.LocalizationMap",
"Submonoid.LocalizationMap.instFunLike",
"MulEquiv",
"Eq",
"CommMonoid",
"DFunLike.coe",
"Submonoid",
"rfl",
"Submonoid.LocalizationMap.ofMulEquivOf... | true |
_private.Mathlib.NumberTheory.ModularForms.LevelOne.GradedRing.0.ModularForm.E₄CubeSubE₆SqForm_isCuspForm._simp_1_1 | Mathlib.NumberTheory.ModularForms.LevelOne.GradedRing | [
"ModularForm.IsCuspForm",
"ModularForm",
"Subgroup.instHasDetOneRangeSpecialLinearGroupGeneralLinearGroupMapGL",
"MonoidHom.range",
"Real",
"Matrix.SpecialLinearGroup",
"Semiring.toModule",
"UpperHalfPlane.qExpansion",
"Matrix",
"ModularForm.isCuspForm_iff_coeffZero_eq_zero",
"instDecidableEqFin... | false |
CategoryTheory.Functor.Monoidal.ext_iff | Mathlib.CategoryTheory.Monoidal.Functor | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"HEq.refl",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Functor.LaxMonoidal.ε",
"Eq.casesOn",
"CategoryTheory.Functor.OplaxMonoidal.δ",
"And.casesOn",
"CategoryTheory.Functor.Monoidal.toOplaxMonoidal",
"And"... | true |
Batteries.PairingHeapImp.Heap.noConfusionType | Batteries.Data.PairingHeap | [
"Batteries.PairingHeapImp.Heap.casesOn",
"Batteries.PairingHeapImp.Heap",
"HEq"
] | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.matchAt?_eq._simp_1_1 | Init.Data.String.Lemmas.Pattern.Char | [
"String.Slice",
"Exists",
"String.Slice.Pos.next",
"String.Slice.Pattern.Model.Char.isLongestMatchAt_iff",
"Ne",
"String.Slice.endPos",
"And",
"String.Slice.Pattern.Model.Char.instPatternModelChar",
"propext",
"String.Slice.Pos.get",
"String.Slice.Pos",
"Char",
"String.Slice.Pattern.Model.Is... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.