name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
CovBy | Mathlib.Order.Defs.PartialOrder | [
"And",
"LT.lt",
"Not",
"LT"
] | true |
_private.Mathlib.Order.ConditionallyCompleteLattice.Indexed.0.cbiSup_of_not_bddAbove.match_1_3 | Mathlib.Order.ConditionallyCompleteLattice.Indexed | [
"iSup",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"upperBounds",
"ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice",
"BddAbove",
"Exists.casesOn",
"Exists.intro",
"ConditionallyCompletePartialOrderSup.toPartialOrder",
"ConditionallyCompleteLattice.toConditional... | false |
CategoryTheory.PreOneHypercover.cylinderHomotopy._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | [
"CategoryTheory.Presieve.instHasPullbacksOfArrowsOfHasPullback",
"Eq.mpr",
"CategoryTheory.PreZeroHypercover.Hom.h₀",
"CategoryTheory.Limits.pullback",
"CategoryTheory.PreOneHypercover.cylinder",
"CategoryTheory.Presieve.instHasPullbackOfHasPairwisePullbacksOfArrows",
"CategoryTheory.PreOneHypercover.cy... | false |
instBooleanAlgebraAsBoolAlg._proof_4 | Mathlib.Algebra.Ring.BooleanRing | [
"LT.mk",
"BooleanRing.sup",
"Preorder.toLE",
"Preorder.mk",
"AsBoolAlg",
"instBooleanAlgebraAsBoolAlg._proof_2",
"SemilatticeSup.mk'._proof_3",
"instBooleanAlgebraAsBoolAlg._proof_1",
"LE.le",
"And",
"Max.max",
"BooleanRing.sup_comm",
"LE.mk",
"instBooleanAlgebraAsBoolAlg._proof_3",
"Eq"... | false |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | [
"Eq.mpr",
"CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.Hom.snd",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.instCategory",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.NatTrans.ext'",
"Quiver.Hom",
"Cat... | false |
PreAbstractSimplicialComplex.map._proof_2 | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | [
"Iff.mpr",
"Eq.mpr",
"congrArg",
"PreAbstractSimplicialComplex.faces",
"Finset",
"Finset.image_nonempty",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Exists",
"Eq.mp",
"id",
"_private.Mathlib.AlgebraicTopology.SimplicialComplex.Basic.0.PreAbstractSimplicialComplex.map._sim... | false |
IntermediateField.intermediateFieldMap_apply_coe | Mathlib.FieldTheory.IntermediateField.Basic | [
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"instSMulOfMul",
"CommRing.toNonUnitalCommRing",
"AlgEquiv.toAlgHom",
"IntermediateField",
"IntermediateField.toField",
"Algebra",
"IntermediateField.intermediateFieldMap",
"Membership.mem",
"Algebra.toModule",
"Subtype",
"NonUnitalNonAssocRing.... | true |
GradedObject.eulerChar_eq_sum_finSet_of_finrankSupport_subset | Mathlib.Algebra.Homology.EulerCharacteristic | [
"Units.val",
"Eq.mpr",
"Int.instAddCommMonoid",
"HMul.hMul",
"ModuleCat",
"GradedObject.finrankSupport",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"Finset",
"finsum",
"Eq.rec",
"id",
"HasSubset.Subset",
"Int",
"ComplexShape",
"Nat.cast",
"ComplexShape.EulerCharSigns",
"ComplexSha... | true |
Cardinal.powerlt_mono_left | Mathlib.SetTheory.Cardinal.Basic | [
"Cardinal",
"Cardinal.powerlt_le_powerlt_left",
"PartialOrder.toPreorder",
"Monotone",
"Cardinal.powerlt",
"Cardinal.partialOrder"
] | true |
Lean.Expr.FindStep.done | Lean.Util.FindExpr | [
"Lean.Expr.FindStep.done",
"Lean.Expr.FindStep"
] | true |
AlgebraicGeometry.Scheme.irreducibleComponentOpen._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.IrreducibleComponent | [
"isClosed_of_mem_irreducibleComponents",
"Eq.mpr",
"irreducibleComponents",
"AlgebraicGeometry.SheafedSpace.instTopologicalSpaceCarrierCarrier",
"AlgebraicGeometry.Scheme",
"AlgebraicGeometry.PresheafedSpace.carrier",
"congrArg",
"CommRingCat",
"Compl.compl",
"AlgebraicGeometry.IsNoetherian.noethe... | false |
midpoint_eq_midpoint_iff_vsub_eq_vsub | Mathlib.LinearAlgebra.AffineSpace.Midpoint | [
"Eq.mpr",
"SubtractionMonoid.toInvolutiveNeg",
"AddMonoid.toAddSemigroup",
"instVAddOfAdd",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"Nat.instAtLeastTwoHAddOfNat",
"vsub_eq_zero_iff_eq",
"AddGroupWithOne.toAddMonoidWithOne",
"HSub.hSub",
"AffineEquiv... | true |
CategoryTheory.Limits.MultispanShape.ctorIdx | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | [
"CategoryTheory.Limits.MultispanShape",
"Nat"
] | false |
_private.Mathlib.Data.Int.CardIntervalMod.0.Nat.Ico_filter_modEq_cast._simp_1_4 | Mathlib.Data.Int.CardIntervalMod | [
"Exists",
"forall_exists_index",
"propext",
"Exists.intro",
"Eq"
] | false |
IsLowerSet.vadd | Mathlib.Algebra.Order.UpperLower | [
"instVAddOfAdd",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"AddZeroClass.toAddZero",
"AddCommGroup",
"Set.vaddSet",
"HVAdd.hVAdd",
"AddGroup.toSubNegMonoid",
"IsLowerSet",
"instHVAdd",
"AddZero.toAdd",
"SubNegMonoid.toAddMonoid"... | true |
PrimeSpectrum.noConfusion | Mathlib.RingTheory.Spectrum.Prime.Defs | [
"CommSemiring.toSemiring",
"PrimeSpectrum.casesOn",
"HEq.refl",
"Ideal",
"CommSemiring",
"Ideal.IsPrime",
"PrimeSpectrum",
"eq_of_heq",
"Eq.ndrec",
"PrimeSpectrum.noConfusionType",
"HEq",
"Eq"
] | false |
CategoryTheory.ObjectProperty.shiftClosure_le_iff | Mathlib.CategoryTheory.ObjectProperty.Shift | [
"Eq.mpr",
"le_refl",
"CategoryTheory.ObjectProperty.shiftClosure_eq_self",
"CategoryTheory.ObjectProperty.le_shiftClosure",
"Pi.preorder",
"congrArg",
"Prop.le",
"PartialOrder.toPreorder",
"Preorder.toLE",
"id",
"LE.le",
"Pi.hasLe",
"CategoryTheory.ObjectProperty.monotone_shiftClosure",
"I... | true |
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.ContinuousLinearMap.isPositive_iff_eq_sum_rankOne._simp_1_4 | Mathlib.Analysis.InnerProductSpace.Positive | [
"Real",
"HMul.hMul",
"RCLike.ofReal_mul",
"NormedField.toField",
"RCLike.ofReal",
"Field.toSemifield",
"RCLike.toDenselyNormedField",
"instDistribOfSemiring",
"RCLike",
"Semifield.toDivisionSemiring",
"Distrib.toMul",
"Real.instMul",
"DivisionSemiring.toSemiring",
"Eq.symm",
"DenselyNorm... | false |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview.rpcRequest.elim | Lean.Server.ProtocolOverview | [
"PULift.up",
"_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview.ctorElim",
"_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview.ctorIdx",
"_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview",
"_private.Lean.Server.ProtocolOverview... | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateRight._proof_12 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight | [
"_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateRight.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateRight._proof_11",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat",
"Decidable.byContradiction",
"OfNat.ofNat",
"Not",
"Nat.decLe"
] | false |
CategoryTheory.Limits.HasCokernels.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Kernels | [
"CategoryTheory.Limits.HasCokernels.has_colimit._autoParam",
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.HasCokernel",
"CategoryTheory.Limits.HasCokernels",
"autoParam",
"CategoryTheory.Limits.HasCokernels.mk",
"CategoryThe... | false |
_private.Mathlib.NumberTheory.Padics.MahlerBasis.0.PadicInt.mahlerSeries_apply_nat._proof_1_1 | Mathlib.NumberTheory.Padics.MahlerBasis | [
"Lean.RArray.leaf",
"False",
"congrArg",
"Int.Linear.le_norm_expr",
"Int.Linear.le_unsat",
"Classical.byContradiction",
"Nat.not_le_eq",
"Nat.ToInt.add_congr",
"Lean.Grind.Nat.lt_eq",
"Lean.RArray.branch",
"Nat.ToInt.natCast_ofNat",
"Int.Linear.Expr.add",
"Nat.Linear.ExprCnstr.eq_of_toNormPo... | false |
Lean.Meta.RefinedDiscrTree.Trie.node._flat_ctor | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | [
"Lean.Meta.RefinedDiscrTree.instHashableKey",
"Lean.Meta.RefinedDiscrTree.Trie.node",
"Std.HashMap",
"instHashableNat",
"Lean.Meta.RefinedDiscrTree.Key",
"Lean.Meta.RefinedDiscrTree.TrieIndex",
"instBEqOfDecidableEq",
"Array",
"Lean.Meta.RefinedDiscrTree.LazyEntry",
"Nat",
"instDecidableEqNat",
... | false |
Lean.Lsp.WorkspaceSymbolParams.noConfusionType | Lean.Data.Lsp.LanguageFeatures | [
"String",
"Lean.Lsp.WorkspaceSymbolParams.casesOn",
"Eq",
"Lean.Lsp.WorkspaceSymbolParams"
] | false |
NumberField.mixedEmbedding.fundamentalCone.realSpaceToLogSpace._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | [
"Real",
"NumberField.mixedEmbedding.realSpace",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Pi.addCommMonoid",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"Finset.univ",
"Real.instInv",
"Real.instSub",
"Rat",
"NumberField.InfinitePlace.mult",
"HSub.hSub",
"Rat.commSemiring",
"Field.... | false |
Int.lcm_mul_right_right | Init.Data.Int.Gcd | [
"Nat.lcm",
"Nat.lcm_mul_right_right",
"Int.lcm",
"HMul.hMul",
"Int.natAbs_mul",
"congrArg",
"instMulNat",
"Int",
"Int.instMul",
"Nat",
"True",
"Int.natAbs",
"eq_self",
"of_eq_true",
"congrFun'",
"Eq",
"Eq.trans",
"instHMul"
] | true |
UInt32.lt_add_one | Init.Data.UInt.Lemmas | [
"Iff.mpr",
"UInt32.toBitVec",
"congrArg",
"UInt32.eq_iff_toBitVec_eq._simp_1",
"BitVec.allOnes",
"BitVec",
"Eq.mp",
"UInt32.toBitVec_ofNat",
"id",
"Ne",
"instOfNatNat",
"instAddUInt32",
"BitVec.ofNat",
"BitVec.instNeg",
"instNegUInt32",
"UInt32.toBitVec_neg",
"instHAdd",
"HAdd.hAdd... | true |
PrimeMultiset.prod | Mathlib.Data.PNat.Factors | [
"Multiset.prod",
"PrimeMultiset.toPNatMultiset",
"instCommMonoidPNat",
"PrimeMultiset",
"PNat"
] | true |
String.Slice.Pattern.ToForwardSearcher.mk | Init.Data.String.Pattern.Basic | [
"outParam",
"String.Slice.Pattern.SearchStep",
"String.Slice",
"String.Slice.Pattern.ToForwardSearcher",
"Std.Iter",
"String.Slice.Pattern.ToForwardSearcher.mk"
] | true |
UpperHalfPlane.num._proof_1 | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | [
"Zero.ofOfNat0",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat.instNeZeroSucc",
"Nat",
"instAddNat",
"NeZero",
"OfNat.ofNat"
] | false |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getEqIffEnumToBitVecEqFor | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | [
"Pure.pure",
"Lean.getConstInfo",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.LocalDeclKind.default",
"_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.mkCondChain",
"Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getEnumToB... | true |
IntermediateField.isSeparable_of_mem_isSeparable | Mathlib.FieldTheory.SeparableDegree | [
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"instSMulOfMul",
"Algebra.IsSeparable.isSeparable",
"CommRing.toNonUnitalCommRing",
"congrArg",
"CommSemiring.toSemiring",
"IntermediateField",
"IntermediateField.toField",
"Algebra",
"Membership.mem",
"Field.toDivisionRing",
"Algebra.toModule",... | true |
RootPairing.nsmul_notMem_range_root | Mathlib.LinearAlgebra.RootSystem.Reduced | [
"Eq.mpr",
"add_neg_cancel",
"RootPairing.IsReduced",
"NegZeroClass.toNeg",
"_private.Mathlib.LinearAlgebra.RootSystem.Reduced.0.RootPairing.nsmul_notMem_range_root._simp_1_3",
"MulOne.toOne",
"False",
"neg_smul",
"CommRing",
"instHSMul",
"Int.instIsCancelMulZero",
"RootPairing.ne_zero",
"Cha... | true |
Aesop.GoalId.casesOn | Aesop.Tree.Data | [
"Aesop.GoalId.rec",
"Aesop.GoalId",
"Nat",
"Aesop.GoalId.mk"
] | false |
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.toOplax | Mathlib.CategoryTheory.Bicategory.Monad.Basic | [
"CategoryTheory.Bicategory.OplaxTrans.ComonadBicat",
"CategoryTheory.locallyDiscreteBicategory",
"CategoryTheory.LocallyDiscrete",
"CategoryTheory.Bicategory",
"CategoryTheory.discreteCategory",
"PUnit",
"CategoryTheory.OplaxFunctor",
"CategoryTheory.Discrete"
] | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.isCongruent.goEq | Lean.Meta.Tactic.Grind.Types | [
"Lean.Expr",
"Bool.and",
"_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.hasSameRoot",
"Lean.Meta.Grind.ENodeMap",
"Bool",
"Bool.or"
] | true |
_private.Lean.Data.Lsp.Internal.0.Lean.Lsp.instBEqRefIdent.beq.match_1 | Lean.Data.Lsp.Internal | [
"Lean.Lsp.RefIdent.casesOn",
"String",
"Nat.hasNotBit",
"Lean.Lsp.RefIdent.const",
"_private.Lean.Data.Lsp.Internal.0.Lean.Lsp.instBEqRefIdent.beq._sparseCasesOn_2",
"_private.Lean.Data.Lsp.Internal.0.Lean.Lsp.instBEqRefIdent.beq._sparseCasesOn_1",
"Lean.Lsp.RefIdent",
"Lean.Lsp.RefIdent.ctorIdx",
"... | false |
Unitization.inrNonUnitalAlgHom._proof_1 | Mathlib.Algebra.Algebra.Unitization | [
"Unitization.instSMul",
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHSMul",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"instDistribSMul",
"AddMonoid.toAddZeroClass",
"Unitization.inr",
"AddZeroClass.toAddZero",
"Unitization.inr_smul",
"DistribSMul.toSMulZeroClass",
"NonUn... | false |
_private.Lean.Meta.LitValues.0.Lean.Meta.normLitValue.match_13 | Lean.Meta.LitValues | [
"_private.Lean.Meta.LitValues.0.Lean.Meta.getNatValue?._sparseCasesOn_1",
"Option.ctorIdx",
"Option.some",
"Nat.hasNotBit",
"UInt16",
"Option"
] | false |
_private.Init.Data.Int.Order.0.Int.toNat_sub''.match_1_1 | Init.Data.Int.Order | [
"HEq.refl",
"Exists",
"Eq.casesOn",
"Int",
"LE.le",
"Nat.cast",
"Exists.casesOn",
"instOfNat",
"Nat",
"Exists.intro",
"eq_of_heq",
"Eq.ndrec",
"Eq.refl",
"HEq",
"instNatCastInt",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"Int.instLEInt"
] | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.PSigma.casesOn._arg_pusher | Std.Data.DTreeMap.Internal.Operations | [
"PSigma.casesOn",
"PSigma.mk",
"Eq.refl",
"PSigma",
"Eq"
] | false |
_private.Mathlib.RingTheory.Flat.Basic.0.Module.Flat.directSum_iff._simp_1_3 | Mathlib.RingTheory.Flat.Basic | [
"LinearMap.instFunLike",
"RingHom",
"Function.comp",
"RingHomCompTriple",
"LinearMap",
"AddCommMonoid",
"LinearMap.comp",
"LinearMap.coe_comp",
"Semiring",
"Module",
"Eq.symm",
"Semiring.toNonAssocSemiring",
"Eq",
"DFunLike.coe"
] | false |
PresentedAddMonoid.instAddMonoid._proof_11 | Mathlib.Algebra.PresentedMonoid.Basic | [
"addConGen",
"Add.mk",
"AddMonoid.toAddZeroClass",
"FreeAddMonoid.instAddCancelMonoid",
"AddCancelMonoid.toAddRightCancelMonoid",
"AddZeroClass.toAddZero",
"PresentedAddMonoid",
"instOfNatNat",
"AddSemigroup.mk",
"autoParam",
"PresentedAddMonoid.instAddMonoid._aux_8",
"instHAdd",
"AddSemigro... | false |
CategoryTheory.Over.left | Mathlib.CategoryTheory.Comma.Over.Basic | [
"CategoryTheory.Over",
"CategoryTheory.Comma.left",
"CategoryTheory.Functor.id",
"CategoryTheory.discreteCategory",
"PUnit",
"CategoryTheory.Functor.fromPUnit",
"CategoryTheory.Category",
"CategoryTheory.Discrete"
] | true |
Std.DHashMap.Internal.Raw₀.Const.insertMany_nil | Std.Data.DHashMap.Internal.RawLemmas | [
"Pure.pure",
"congrArg",
"instForInOfForIn'",
"Monad.toApplicative",
"inferInstance",
"Subtype",
"ForIn.forIn",
"Id.run",
"Id",
"Applicative.toPure",
"Membership",
"ForInStep",
"bind_pure",
"Prod.fst",
"Subtype.mk",
"List",
"_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Int... | true |
List.dropLast_append_cons | Init.Data.List.Lemmas | [
"List.dropLast_append_of_ne_nil",
"False",
"congrArg",
"False.elim",
"noConfusion_of_Nat",
"List.dropLast",
"List.cons",
"instHAppendOfAppend",
"List",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"List.instAppend",
"not_false_eq_true",
"eq_false'",
"Eq",
"List.ctorIdx",
"Not",
... | true |
Subarray.scanlM.eq_1 | Batteries.Data.Array.Scan | [
"Subarray",
"Array.scanlM",
"Subarray.stop",
"Array",
"Subarray.scanlM",
"Eq.refl",
"Monad",
"Subarray.start",
"Eq",
"Subarray.array"
] | true |
MeasureTheory.Measure.sum_fintype | Mathlib.MeasureTheory.Measure.MeasureSpace | [
"MeasureTheory.Measure",
"MeasurableSet",
"Finset.univ",
"ENNReal.instAddCommMonoid",
"congrArg",
"MeasureTheory.Measure.sum_apply",
"SummationFilter.instLeAtTopUnconditional",
"MeasurableSpace",
"MeasureTheory.Measure.instAddCommMonoid",
"Fintype",
"tsum",
"congr",
"True",
"tsum_fintype",... | true |
LightCondensed.instMonoidalClosedFunctorOppositeLightProfiniteModuleCat._proof_1 | Mathlib.Condensed.Light.Monoidal | [
"CategoryTheory.Functor",
"CommRing",
"Opposite",
"ModuleCat",
"CategoryTheory.Equivalence.congrLeft",
"SecondCountableTopology",
"CategoryTheory.Functor.category",
"CategoryTheory.Equivalence.op",
"CategoryTheory.Equivalence.functor",
"TotallyDisconnectedSpace",
"TopCat.str",
"And",
"instEs... | false |
Finset.preimage_add_right_zero' | Mathlib.Algebra.Group.Pointwise.Finset.Basic | [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"SubtractionMonoid.toInvolutiveNeg",
"congrArg",
"Function.Injective.injOn",
"Finset",
"AddMonoid.toAddZeroClass",
"AddCancelMonoid.toAddRightCancelMonoid",
"AddZeroClass.toAddZero",
"neg_neg",
"id",
"SubtractionMonoid.toSubNegZ... | true |
FreeAddMagma.add | Mathlib.Algebra.Free | [
"FreeAddMagma.add",
"FreeAddMagma"
] | true |
Lean.Meta.FindSplitImpl.Context.recOn | Lean.Meta.Tactic.SplitIf | [
"Lean.Meta.FindSplitImpl.Context.rec",
"Lean.Meta.SplitKind",
"Lean.ExprSet",
"Lean.Meta.FindSplitImpl.Context.mk",
"Lean.Meta.FindSplitImpl.Context"
] | false |
Lean.Lsp.FoldingRange.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | [
"Lean.Lsp.FoldingRange.noConfusion",
"Lean.Lsp.FoldingRange",
"id",
"Lean.Lsp.FoldingRangeKind",
"Nat",
"Eq",
"Lean.Lsp.FoldingRange.mk",
"Option"
] | false |
Lean.Meta.AC.PreExpr.brecOn.go | Lean.Meta.Tactic.AC.Main | [
"PProd.mk",
"Lean.Meta.AC.PreExpr",
"Lean.Expr",
"Lean.Meta.AC.PreExpr.op",
"Lean.Meta.AC.PreExpr.var",
"Lean.Meta.AC.PreExpr.rec",
"PProd",
"PUnit",
"Lean.Meta.AC.PreExpr.below",
"PUnit.unit"
] | true |
Set.opEquiv_self | Mathlib.Data.Set.Opposite | [
"Set.opEquiv_self._proof_1",
"Opposite",
"Membership.mem",
"Equiv.mk",
"Set.Elem",
"Equiv",
"Set.opEquiv_self._proof_4",
"Subtype.mk",
"Set.opEquiv_self._proof_6",
"Opposite.op",
"Set.opEquiv_self._proof_2",
"Subtype.val",
"Set.instMembership",
"Opposite.unop",
"Set.op",
"Set"
] | true |
Bundle.Pretrivialization.continuousAlternatingMapCoordChange._proof_4 | Mathlib.Topology.VectorBundle.ContinuousAlternatingMap | [
"NormedCommRing.toSeminormedCommRing",
"NormedSpace.toIsBoundedSMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"NormedSpace",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"AddMonoid.toAddZeroClass",
"IsBoundedSMul.toUniformContinuousConstSMul"... | false |
Complex.sin_surjective | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | [
"instHDiv",
"Real.pi",
"Complex.cos",
"Complex.sin",
"Nat.instAtLeastTwoHAddOfNat",
"Complex.instDivInvMonoid",
"Exists",
"HDiv.hDiv",
"instOfNatNat",
"Complex.cos_surjective",
"Complex.instNatCast",
"Complex.ofReal",
"instHAdd",
"Exists.casesOn",
"HAdd.hAdd",
"Nat.instNeZeroSucc",
"... | true |
Module.FinitePresentation.linearEquivMap._proof_3 | Mathlib.Algebra.Module.FinitePresentation | [
"CommRing",
"instSMulOfMul",
"IsScalarTower.right",
"CommSemiring.toSemiring",
"IsScalarTower",
"Algebra.toSMul",
"Algebra.id",
"instDistribOfSemiring",
"CommRing.toCommSemiring",
"Distrib.toMul"
] | false |
Algebra.IsAlgebraic.algHomEquivAlgHomOfSplits._proof_1 | Mathlib.FieldTheory.IsAlgClosed.Basic | [
"Nontrivial",
"Field.instIsLocalRing",
"Field.toSemifield",
"Semifield.toDivisionSemiring",
"IsLocalRing.toNontrivial",
"DivisionSemiring.toSemiring",
"Field"
] | false |
AddCon.ker.congr_simp | Mathlib.Algebra.Colimit.Module | [
"AddCon",
"Eq.rec",
"AddHomClass",
"Eq.refl",
"Eq",
"AddCon.ker",
"Add",
"FunLike"
] | true |
CategoryTheory.Functor.chosenProd.fst | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | [
"CategoryTheory.SemiCartesianMonoidalCategory",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.SemiCartesianMonoidalCategory.toMonoidalCategory",
"CategoryTheory.MonoidalCategoryStruct.tensorObj",
"CategoryTheory.MonoidalCategory.toMonoidalCategoryStruct",
"CategoryTheory.Catego... | true |
FinBoolAlg.hasForgetToFinBddDistLat._proof_4 | Mathlib.Order.Category.FinBoolAlg | [
"FinBddDistLat.ofHom",
"CategoryTheory.Functor",
"FinBoolAlg",
"FinBoolAlg.largeCategory",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"BoolAlg.carrier",
"FinBddDistLat.instBoundedOrderCarrier",
"CategoryTheory.Functor.mk",
"BoundedLatticeHom.instFunLike",
"BoolAlg.Hom.hom",
"Categ... | false |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.image_sub_const_Ico._proof_1_3 | Mathlib.Order.Interval.Finset.Nat | [
"Int.Linear.eq_of_core",
"Int.Linear.not_eq_norm_expr",
"Lean.RArray.leaf",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"Preorder.toLT",
"HMul.hMul",
"Int.Linear.norm_le",
"Lean.Grind.not_and",
"eq_false",
"Int.Linear.Expr.eq_of_norm_eq",
"congrArg",
"Int.Linear.le_norm_expr",
"Int.Line... | false |
ENNReal.add_halves | Mathlib.Data.ENNReal.Inv | [
"Distrib.leftDistribClass",
"Eq.mpr",
"ENNReal.instAdd",
"MulOne.toOne",
"DivInvMonoid.toInv",
"instHDiv",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"Nat.instAtLeastTwoHAddOfNat",
"id",
"MulOne.toMul",
"HDiv.hDiv",
"DivInvMonoid.toMonoid",
"AddMonoidWi... | true |
Finset.map_insert | Mathlib.Data.Finset.Image | [
"Finset.instUnion",
"congrArg",
"Finset",
"Finset.map",
"Insert.insert",
"Finset.instInsert",
"Function.Embedding",
"True",
"Finset.map_singleton",
"eq_self",
"of_eq_true",
"congrFun'",
"Union.union",
"Function.instFunLikeEmbedding",
"Finset.instSingleton",
"Singleton.singleton",
"Fi... | true |
_private.Init.Data.Array.InsertionSort.0.Array.insertionSort.swapLoop.match_1 | Init.Data.Array.InsertionSort | [
"instOfNatNat",
"Nat",
"Eq.refl",
"OfNat.ofNat",
"Nat.succ",
"Eq",
"Nat.casesOn"
] | false |
NNReal.instLinearOrder._aux_6 | Mathlib.Data.NNReal.Defs | [
"Real.instLE",
"Real",
"decidable_of_iff",
"LinearOrder.toDecidableEq",
"Real.instZero",
"Subtype",
"NNReal",
"LE.le",
"Zero.toOfNat0",
"OfNat.ofNat",
"Subtype.val",
"Subtype.instLinearOrder._proof_7",
"Eq",
"Real.linearOrder",
"DecidableEq"
] | false |
RingHomId.eq_id | Mathlib.Algebra.Ring.CompTypeclasses | [
"RingHom",
"Semiring",
"RingHomId",
"RingHom.id",
"Semiring.toNonAssocSemiring",
"Eq"
] | true |
LinearEquiv.piRing | Mathlib.LinearAlgebra.Pi | [
"Pi.Function.module",
"LinearEquiv.symm",
"Semiring.toModule",
"Pi.addCommMonoid",
"LinearMap.piMap._proof_1",
"DistribMulAction.toDistribSMul",
"LinearMap.ringLmapEquivSelf",
"Pi.module",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"LinearMap.module",
... | true |
Std.Internal.List.maxKeyD_le_maxKeyD_insertEntry | Std.Data.Internal.List.Associative | [
"Std.Internal.List.DistinctKeys",
"Ord",
"Std.TransOrd",
"Std.OrientedOrd.opposite",
"Std.TransOrd.opposite",
"inferInstance",
"Std.Internal.List.insertEntry",
"Ord.compare",
"Bool.true",
"Std.Internal.List.maxKeyD",
"List",
"List.isEmpty",
"Ord.opposite",
"Bool",
"Std.LawfulBEqOrd",
"... | true |
Finset.prod_ite_of_false | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | [
"Finset.univ",
"Finset",
"Membership.mem",
"Subtype",
"dite",
"Finset.prod",
"Finset.prod_dite_of_false",
"Finset.instSetLike",
"DecidablePred",
"Finset.Subtype.fintype",
"Finset.prod_attach",
"Subtype.val",
"Eq",
"CommMonoid",
"Not",
"SetLike.instMembership",
"Eq.trans",
"ite"
] | true |
_private.Lean.Meta.ExprTraverse.0.Lean.Meta.traverseForallWithPos.visit.match_1 | Lean.Meta.ExprTraverse | [
"Lean.Expr",
"Nat.hasNotBit",
"Lean.Expr.forallE",
"Lean.Name",
"Lean.BinderInfo",
"Lean.Expr.ctorIdx",
"_private.Lean.Meta.ExprTraverse.0.Lean.Meta.traverseForallWithPos.visit._sparseCasesOn_1"
] | false |
Equiv.recOn | Mathlib.Logic.Equiv.Defs | [
"Function.LeftInverse",
"Equiv.rec",
"Equiv.mk",
"Equiv",
"Function.RightInverse"
] | false |
Continuous.cfcₙ_nnreal'._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
topologicalAddGroup_inf | Mathlib.Topology.Algebra.Group.Basic | [
"cond",
"Eq.mpr",
"iInf",
"inf_eq_iInf",
"CompleteLattice.toLattice",
"congrArg",
"CompleteLattice.toConditionallyCompleteLattice",
"TopologicalSpace.instCompleteLattice",
"id",
"SemilatticeInf.toMin",
"CompleteLattice.toCompleteSemilatticeInf",
"TopologicalSpace",
"Bool.true",
"AddGroup",... | true |
Acc.casesOn | Init.WF | [
"Acc",
"Acc.rec",
"Acc.intro"
] | false |
Function.Embedding.instAddAction._proof_1 | Mathlib.GroupTheory.GroupAction.Embedding | [
"Function.Embedding",
"DFunLike.coe_injective",
"Function.Injective",
"Function.instFunLikeEmbedding",
"DFunLike.coe"
] | false |
Multiset.powerset._proof_1 | Mathlib.Data.Multiset.Powerset | [
"Quot.sound",
"Multiset",
"List",
"Quot",
"Multiset.powersetAux_perm",
"List.isSetoid",
"Eq",
"Multiset.powersetAux",
"Setoid.r",
"Quot.mk"
] | false |
ZFSet.Insert.match_5 | Mathlib.SetTheory.ZFC.Basic | [
"Exists",
"PSet.mk",
"PSet",
"Exists.casesOn",
"Exists.intro",
"PSet.Type",
"PSet.Equiv"
] | false |
List.Sublist.flatMap | Mathlib.Data.List.Flatten | [
"List.map",
"List.Sublist.map",
"List.Sublist.flatten",
"List",
"List.Sublist",
"List.flatMap"
] | true |
Ring.zsmul | Mathlib.Algebra.Ring.Defs | [
"Int",
"Ring"
] | true |
MeasureTheory.StronglyAdapted.progMeasurable_of_continuous | Mathlib.Probability.Process.Adapted | [
"TopologicalSpace.PseudoMetrizableSpace",
"Continuous",
"TopologicalSpace.MetrizableSpace",
"SecondCountableTopology",
"MeasureTheory.IsStronglyProgressive",
"MeasureTheory.Filtration",
"MeasureTheory.StronglyAdapted.isStronglyProgressive_of_continuous",
"MeasurableSpace",
"TopologicalSpace",
"Mea... | true |
Equiv.simpleGraph | Mathlib.Combinatorics.SimpleGraph.Maps | [
"Equiv.instEquivLike",
"Equiv.simpleGraph._proof_2",
"Equiv.mk",
"Equiv",
"SimpleGraph",
"SimpleGraph.comap",
"Equiv.simpleGraph._proof_1",
"Equiv.symm",
"DFunLike.coe",
"EquivLike.toFunLike"
] | true |
Lean.Compiler.LCNF.getLocalImpureDecls | Lean.Compiler.LCNF.PhaseExt | [
"Pure.pure",
"Lean.Core.instMonadEnvCoreM",
"Lean.Compiler.LCNF.impureExt",
"Array.map",
"Lean.Compiler.LCNF.Decl",
"IO.RealWorld",
"EIO",
"instMonadEIO",
"Applicative.toPure",
"Prod.fst",
"Lean.Name.anonymous",
"Array",
"Lean.Core.State",
"Lean.Core.CoreM",
"Lean.Compiler.LCNF.Purity.im... | true |
Std.Internal.List.minKey!_insertEntryIfNew_le_minKey! | Std.Data.Internal.List.Associative | [
"Std.Internal.List.DistinctKeys",
"Ord",
"congrArg",
"Std.TransOrd",
"Std.Internal.List.insertEntryIfNew",
"Ordering",
"Eq.mp",
"Ord.compare",
"Bool.true",
"Std.Internal.List.minKey!",
"List",
"List.isEmpty",
"congr",
"Bool",
"Std.Internal.List.minKey_eq_minKey!",
"Inhabited",
"Std.L... | true |
QuadraticAlgebra.instNonUnitalNonAssocSemiring | Mathlib.Algebra.QuadraticAlgebra.Defs | [
"QuadraticAlgebra.instMul",
"QuadraticAlgebra.instNonUnitalNonAssocSemiring._proof_3",
"QuadraticAlgebra",
"QuadraticAlgebra.instNonUnitalNonAssocSemiring._proof_8",
"Distrib.toAdd",
"NonUnitalNonAssocSemiring.mk",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"QuadraticAlgebra.instNonUnitalNonAssocSem... | true |
CompactlySupportedContinuousMap.smulc_apply | Mathlib.Topology.ContinuousMap.CompactlySupported | [
"instHSMul",
"ContinuousSMul",
"SMulZeroClass",
"CompactlySupportedContinuousMap",
"ContinuousMapClass",
"TopologicalSpace",
"CompactlySupportedContinuousMap.instFunLike",
"CompactlySupportedContinuousMap.instSMulOfContinuousSMulOfContinuousMapClass",
"HSMul.hSMul",
"SMulZeroClass.toSMul",
"Eq",... | true |
Lean.Meta.Grind.SplitInfo.arg | Lean.Meta.Tactic.Grind.Types | [
"Lean.Expr",
"Lean.Meta.Grind.SplitSource",
"Nat",
"Lean.Meta.Grind.SplitInfo",
"Lean.Meta.Grind.SplitInfo.arg"
] | true |
_private.Mathlib.Data.PFun.0.PFun.mem_prodLift._simp_1_6 | Mathlib.Data.PFun | [
"Exists",
"exists_and_right",
"And",
"propext",
"Eq"
] | false |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.pullbackConeOfLeftIsLimit | Mathlib.Geometry.RingedSpace.OpenImmersion | [
"CategoryTheory.Limits.PullbackCone.isLimitAux'",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CommRingCat",
"AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.pullbackConeOfLeft",
"AlgebraicGeometry.LocallyRingedSpace.instQuiver",
"CategoryTheory.Limits.WidePullbackShape.category",
"Al... | true |
List.dropWhile.eq_def | Init.Data.List.TakeDrop | [
"List.brecOn",
"Eq.mpr",
"List.brecOn.go",
"List.brecOn.eq",
"congrArg",
"List.filter.match_1",
"id",
"List.rec",
"List.cons",
"List",
"Unit",
"PProd",
"PUnit",
"List.dropWhile._f",
"Bool",
"Eq.ndrec",
"List.below",
"_private.Init.Data.List.TakeDrop.0.List.getLast?.match_1.splitter... | true |
Finsupp.mem_submodule_iff | Mathlib.LinearAlgebra.Finsupp.Pi | [
"Finsupp.instFunLike",
"Submodule",
"Finsupp.module",
"Iff.rfl",
"AddMonoid.toAddZeroClass",
"Membership.mem",
"AddZeroClass.toAddZero",
"Finsupp.submodule",
"AddCommMonoid",
"Finsupp.instAddCommMonoid",
"AddZero.toZero",
"Iff",
"Submodule.setLike",
"Semiring",
"AddCommMonoid.toAddMonoid... | true |
Submonoid.val_mem_of_mem_units | Mathlib.Algebra.Group.Submonoid.Units | [
"Monoid",
"Units.val",
"Submonoid.inv",
"MonoidHom.instFunLike",
"Units.coeHom",
"MonoidHom",
"Monoid.toMulOneClass",
"Submonoid.units",
"Membership.mem",
"Units",
"DivInvMonoid.toMonoid",
"Subgroup",
"Units.instGroup",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"Inv.inv",
"Subm... | true |
Finsupp.mem_neLocus | Mathlib.Data.Finsupp.NeLocus | [
"Finsupp.instFunLike",
"Eq.mpr",
"instDecidableNot",
"Finset.instUnion",
"congrArg",
"_private.Mathlib.Data.Finsupp.NeLocus.0.Finsupp.mem_neLocus._simp_1_2",
"Finsupp.neLocus",
"Finset",
"Finsupp.support",
"Membership.mem",
"id",
"Ne",
"_private.Mathlib.Data.Finsupp.NeLocus.0.Finsupp.mem_neL... | true |
Std.DTreeMap.isSome_minKey?_of_mem | Std.Data.DTreeMap.Lemmas | [
"Std.DTreeMap.Internal.Impl.isSome_minKey?_of_mem",
"Std.DTreeMap",
"Ord.mk",
"Membership.mem",
"Ordering",
"Std.DTreeMap.inner",
"Std.TransCmp",
"Std.DTreeMap.instMembership",
"Bool.true",
"Std.DTreeMap.wf",
"Std.DTreeMap.minKey?",
"Bool",
"Option.isSome",
"Eq"
] | true |
CategoryTheory.Functor.mapTriangleCommShiftIso_inv_app_hom₁ | Mathlib.CategoryTheory.Triangulated.Functor | [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.Additive",
"CategoryTheory.Pretriangulated.Triangle.obj₁",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.shiftFunctor",
"Int",
"Int.instAddMonoid",
"Categ... | true |
Nat.Partrec.Code.ofNatCode.eq_4 | Mathlib.Computability.PartrecCode | [
"Nat.Partrec.Code.right",
"Nat.Partrec.Code",
"instOfNatNat",
"Nat",
"Eq.refl",
"Nat.Partrec.Code.ofNatCode",
"OfNat.ofNat",
"Eq"
] | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fdiv_fmod_unique'._proof_1_1 | Init.Data.Int.DivMod.Lemmas | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"Lean.Omega.Int.le_of_not_lt",
"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.add_congr",
"Lean.Omega.LinearCombo.eval",
"Op... | false |
Lean.Doc.Syntax.directive._regBuiltin.Lean.Doc.Syntax.directive.docString_1 | Lean.DocString.Syntax | [
"Lean.addBuiltinDocString",
"IO",
"Unit",
"Lean.Name.mkStr4"
] | false |
String.Slice.Pattern.Model.IsRevMatch | Init.Data.String.Lemmas.Pattern.Basic | [
"String.Slice",
"String.Slice.Pattern.Model.IsRevMatch.mk",
"String.Slice.Pattern.Model.PatternModel",
"String.Slice.Pos"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.