name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 686 | allowCompletion bool 2
classes |
|---|---|---|---|
AEMeasurable.snd | Mathlib.MeasureTheory.Measure.AEMeasurable | [
"MeasureTheory.Measure",
"AEMeasurable",
"MeasurableSpace",
"measurable_snd",
"Measurable.comp_aemeasurable",
"Prod",
"Prod.snd",
"Prod.instMeasurableSpace"
] | true |
not_injective_infinite_finite | Mathlib.Data.Fintype.EquivFin | [
"Finite",
"Finite.false",
"Infinite",
"Function.Injective",
"Not",
"Finite.of_injective"
] | true |
Lean.Parser.Command.importPath | Lean.Parser.Command | [
"Lean.Parser.Parser",
"HAndThen.hAndThen",
"Lean.Parser.leadingNode",
"instHAndThenOfAndThen",
"instOfNatNat",
"Lean.Parser.symbol",
"Lean.Parser.withAntiquot",
"Bool.true",
"Unit",
"Nat",
"Lean.Parser.ident",
"Lean.Parser.withCache",
"OfNat.ofNat",
"Lean.Parser.mkAntiquot",
"Bool.false"... | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRight.go._unary._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | [
"Unit.unit",
"Lean.Omega.LinearCombo.coordinate_eval_6",
"Std.Sat.AIG.Decl",
"False",
"Mul.mk",
"List.zipWith",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"HMul.hMul",
"Int.natCast_add",
"Nat.ne_of_beq_eq_false",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Le... | false |
IsSl2Triple.HasPrimitiveVectorWith.mk._flat_ctor | Mathlib.Algebra.Lie.Sl2 | [
"CommRing",
"instHSMul",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"Bracket.bracket",
"AddCommGroup.toAddGroup",
"AddZeroClass.toAddZero",
"AddCommGroup",
"DistribSMul.toSMulZeroClass",
"Ne",
"SubtractionMonoid.to... | false |
toIcoDiv_ofNat_mul_add | Mathlib.Algebra.Order.ToIntervalMod | [
"Preorder.toLT",
"HMul.hMul",
"LinearOrder",
"NonUnitalNonAssocRing.toAddCommGroup",
"PartialOrder.toPreorder",
"AddGroupWithOne.toAddMonoidWithOne",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Distrib.toAdd",
"NonUnitalNonAssocRing.t... | true |
Stream'.Seq.BisimO._sparseCasesOn_2.else_eq | Mathlib.Data.Seq.Defs | [
"Option.ctorIdx",
"Option.casesOn",
"Nat.shiftRight",
"Option.some",
"Nat.hasNotBit",
"instOfNatNat",
"Bool.true",
"Nat.land",
"Option.none",
"absurd",
"Stream'.Seq.BisimO._sparseCasesOn_2",
"Nat",
"Bool",
"Eq.ndrec",
"Nat.eq_of_beq_eq_true",
"Eq.refl",
"OfNat.ofNat",
"Eq.symm",
... | false |
FreeAddGroup.instAddGroup._proof_8 | Mathlib.GroupTheory.FreeGroup.Basic | [
"Zero.zero",
"Add.mk",
"Neg.mk",
"Add.add",
"Int",
"zsmulRec",
"FreeAddGroup.instZero",
"Nat.cast",
"FreeAddGroup.instAdd",
"instHAdd",
"HAdd.hAdd",
"nsmulRec",
"Nat",
"Zero.mk",
"Eq.refl",
"FreeAddGroup.instNeg",
"instNatCastInt",
"FreeAddGroup",
"Nat.succ",
"Eq",
"Neg.neg"
... | false |
_private.Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification.0.NumberField.InfinitePlace._aux_Mathlib_NumberTheory_NumberField_InfinitePlace_Ramification___unexpand_MulAction_stabilizer_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | [
"Pure.pure",
"cond",
"Lean.TSyntax",
"Unit.unit",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Syntax.matchesIdent",
"Lean.Name.mkNum",
"instMonadExceptOfMonadExceptOf",
"Lean.SourceInfo",
"Lean.PrettyPrinter.UnexpandM",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Sy... | false |
ZSpan.quotientEquiv_apply_mk | Mathlib.Algebra.Module.ZLattice.Basic | [
"NormedCommRing.toNormedRing",
"Submodule",
"NormedRing.toRing",
"Equiv.instEquivLike",
"NormedSpace",
"Submodule.Quotient.mk",
"LinearOrder",
"NormedSpace.toModule",
"PseudoMetricSpace.toUniformSpace",
"IsStrictOrderedRing",
"Submodule.hasQuotient",
"NormedField.toField",
"SemilatticeInf.to... | true |
iteratedDeriv_fun_const_zero | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | [
"NormedSpace",
"congrArg",
"ite_self",
"Eq.mp",
"SubtractionMonoid.toSubNegZeroMonoid",
"instOfNatNat",
"SubNegZeroMonoid.toNegZeroClass",
"SubtractionCommMonoid.toSubtractionMonoid",
"Nat",
"NontriviallyNormedField",
"Zero.toOfNat0",
"NormedAddCommGroup.toAddCommGroup",
"NontriviallyNormedF... | true |
SeparationQuotient.instCommSemigroup._proof_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | [
"HMul.hMul",
"SeparationQuotient.instMul",
"SeparationQuotient.mk_mul",
"CommMagma.toMul",
"TopologicalSpace",
"CommSemigroup",
"ContinuousMul",
"SeparationQuotient",
"SeparationQuotient.mk",
"CommSemigroup.toCommMagma",
"Eq",
"instHMul"
] | false |
Bornology.isCobounded_compl_iff | Mathlib.Topology.Bornology.Basic | [
"Compl.compl",
"Iff.rfl",
"Bornology.IsBounded",
"Set.instCompl",
"Iff",
"Bornology.IsCobounded",
"Bornology",
"Set"
] | true |
Lean.Elab.Do.ControlStack.mk.injEq | Lean.Elab.Do.Control | [
"Lean.MessageData",
"Eq.propIntro",
"Lean.injEq_helper",
"Lean.Elab.Do.ControlStack.mk.inj",
"Lean.Elab.Do.ControlStack",
"Lean.Expr",
"Lean.Elab.Do.DoElemCont",
"And",
"Unit",
"Lean.Elab.Do.ControlStack.mk",
"Lean.Elab.Do.DoElabM",
"Eq.ndrec",
"Eq.refl",
"Eq"
] | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitQuotLift | Lean.Compiler.LCNF.ToLCNF | [
"Inhabited.default",
"Lean.Compiler.LCNF.ToLCNF.State",
"Lean.Compiler.LCNF.Arg",
"Lean.Compiler.LCNF.ToLCNF.M",
"instInhabitedOfMonad",
"Lean.Expr",
"IO.RealWorld",
"Lean.Compiler.LCNF.Purity.pure",
"Lean.Compiler.LCNF.instInhabitedArg",
"StateRefT'",
"Lean.Compiler.LCNF.instMonadCompilerM",
... | true |
Batteries.Tactic.tactic_ | Batteries.Tactic.Init | [
"Lean.ParserDescr.nonReservedSymbol",
"Lean.Name.mkStr3",
"instOfNatNat",
"Lean.ParserDescr",
"Lean.ParserDescr.node",
"Nat",
"OfNat.ofNat",
"Bool.false"
] | true |
Lean.Compiler.LCNF.Check.Pure.checkParams | Lean.Compiler.LCNF.Check | [
"ReaderT.instMonad",
"IO.RealWorld",
"instOfNatNat",
"Lean.Compiler.LCNF.Purity.pure",
"Array",
"Unit",
"Array.forM",
"StateRefT'",
"Lean.Compiler.LCNF.instMonadCompilerM",
"StateRefT'.instMonad",
"Lean.Compiler.LCNF.Check.Pure.State",
"Nat",
"Lean.Compiler.LCNF.CompilerM",
"Lean.Compiler.... | true |
ArithmeticFunction.instAlgebra._proof_3 | Mathlib.NumberTheory.ArithmeticFunction.Defs | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"ArithmeticFunction.ext",
"instHSMul",
"ArithmeticFunction.instSemiring",
"HMul.hMul",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"Algebra",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"ArithmeticFunction.in... | false |
Valuation.leSubmodule_zero | Mathlib.RingTheory.Valuation.Integers | [
"GroupWithZero.toMonoidWithZero",
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"Submodule",
"Semiring.toModule",
"Subring.instSetLike",
"ValuationClass.toMonoidWithZeroHomClass",
"Ring.toNonAssocRing",
"congrArg",
"Valuation.mem_leSubmodule_iff._simp_1",
"AddMonoid.toAddZero... | true |
CategoryTheory.ReflQuiver.mk | Mathlib.Combinatorics.Quiver.ReflQuiver | [
"Quiver.Hom",
"Quiver",
"CategoryTheory.ReflQuiver",
"CategoryTheory.ReflQuiver.mk"
] | true |
CochainComplex.HomComplex.instAddCommGroupCochain._aux_12 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | [
"CochainComplex.HomComplex.Cochain._proof_1",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"AddGroupWithOne.toAddMonoidWithOne",
"AddRightCancelSemigroup.toAddSemigroup",
"AddCancelMonoid.toAddRightCancelMonoid",
"CochainComplex.HomComplex.Triplet",
"AddCommGroup.toAddGroup",
"Int",
"Ca... | false |
Real.arsinh_bijective | Mathlib.Analysis.SpecialFunctions.Arsinh | [
"Real",
"Equiv.bijective",
"Real.arsinh",
"Function.Bijective",
"Real.sinhEquiv",
"Equiv.symm"
] | true |
SchwartzMap.fourierMultiplierCLM_fourierMultiplierCLM_apply | Mathlib.Analysis.Distribution.FourierMultiplier | [
"NormedCommRing.toNormedRing",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"Real",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CompleteSpace",
"NormedRing.toRing",
"NormedSpace.toIsBoundedSMul",
"RCLike.toNormedAlgebra",
"HMul.hMul",
"NormedSpace",
"Schwartz... | true |
AddMonoidHom.op_symm_apply_apply | Mathlib.Algebra.Group.Equiv.Opposite | [
"Equiv.instEquivLike",
"Function.comp",
"AddZeroClass.toAddZero",
"AddOpposite",
"Equiv",
"AddOpposite.instAddZero",
"AddZeroClass",
"Eq.refl",
"AddOpposite.unop",
"Equiv.symm",
"AddMonoidHom",
"AddMonoidHom.instFunLike",
"Eq",
"DFunLike.coe",
"AddMonoidHom.op",
"AddOpposite.op",
"Eq... | true |
Submonoid.mk_eq_top._simp_2 | Mathlib.Algebra.Group.Submonoid.Defs | [
"MulOne.toOne",
"Membership.mem",
"MulOne.toMul",
"Submonoid.instTop",
"MulOneClass.toMulOne",
"Subsemigroup.instTop",
"Subsemigroup",
"propext",
"Subsemigroup.carrier",
"One.toOfNat1",
"Submonoid.mk",
"MulOneClass",
"Top.top",
"OfNat.ofNat",
"Eq",
"Set.instMembership",
"Submonoid.mk... | false |
Lean.Compiler.LCNF.CtorFieldInfo.object.inj | Lean.Compiler.LCNF.ToImpureType | [
"Lean.Compiler.LCNF.CtorFieldInfo.object",
"Lean.Expr",
"And",
"Lean.Compiler.LCNF.CtorFieldInfo",
"Nat",
"Lean.Compiler.LCNF.CtorFieldInfo.object.noConfusion",
"And.intro",
"Eq"
] | true |
Std.Internal.List.Const.containsKey_filterMap | Std.Data.Internal.List.Associative | [
"cond",
"dite_cond_eq_true",
"Eq.mpr",
"Std.Internal.List.DistinctKeys",
"False",
"dite_congr",
"congrArg",
"_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getKey._proof_1",
"Bool.false_eq_true",
"Option.some",
"Std.Internal.List.getValue",
"Option.bind",
"Eq.mp",
"Option.... | true |
Lean.Parser.Command.notationItem.formatter | Lean.Parser.Syntax | [
"Lean.PrettyPrinter.Formatter",
"Lean.PrettyPrinter.Formatter.orelse.formatter",
"Lean.Parser.strLit.formatter",
"Lean.PrettyPrinter.Formatter.withAntiquot.formatter",
"Bool.true",
"Lean.Parser.Command.identPrec.formatter",
"Lean.Parser.Syntax.unicodeAtom.formatter",
"Lean.Parser.mkAntiquot.formatter"... | true |
CategoryTheory.Limits.LimitPresentation.noConfusionType | Mathlib.CategoryTheory.Limits.Presentation | [
"CategoryTheory.Functor",
"CategoryTheory.Limits.LimitPresentation.casesOn",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Limits.LimitPresentation",
"CategoryTheory.Functor.category",
"CategoryTheory.Limits.IsLimit",
"HEq",
"CategoryTheory.Category.toCategoryStruct",
"Ca... | false |
Cardinal.lt_one_iff_zero | Mathlib.SetTheory.Cardinal.Basic | [
"Preorder.toLT",
"Cardinal.instOne",
"Cardinal",
"PartialOrder.toPreorder",
"Cardinal.lt_one_iff",
"Cardinal.partialOrder",
"Iff",
"LT.lt",
"One.toOfNat1",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"Cardinal.instZero"
] | true |
_private.Mathlib.Analysis.Normed.Algebra.Spectrum.0.SpectrumRestricts.nnreal_iff_spectralRadius_le._simp_1_2 | Mathlib.Analysis.Normed.Algebra.Spectrum | [
"iSup",
"PartialOrder.toPreorder",
"Preorder.toLE",
"LE.le",
"CompleteLattice.toCompleteSemilatticeInf",
"CompleteSemilatticeInf.toPartialOrder",
"iSup₂_le_iff",
"propext",
"CompleteSemilatticeSup.toSupSet",
"CompleteLattice.toCompleteSemilatticeSup",
"CompleteLattice",
"Eq"
] | false |
IsLocalization.exist_integer_multiples_of_finite | Mathlib.RingTheory.Localization.Integer | [
"IsLocalization.IsInteger",
"Finset.mem_univ",
"instHSMul",
"Finset.univ",
"IsLocalization",
"CommSemiring.toSemiring",
"Finset",
"Finite",
"Algebra",
"Algebra.toSMul",
"Membership.mem",
"Exists",
"Subtype",
"NonAssocSemiring.toMulZeroOneClass",
"Nonempty.intro",
"MulZeroOneClass.toMul... | true |
_private.Mathlib.Data.Set.List.0.Option.getD.match_1.eq_1 | Mathlib.Data.Set.List | [
"Option.getD.match_1",
"Option.some",
"Option.none",
"Unit",
"Eq.refl",
"Eq",
"Option"
] | true |
CategoryTheory.Functor.exact_tfae | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | [
"CategoryTheory.Functor.preservesFiniteLimits_of_preservesHomology",
"Iff.mpr",
"CategoryTheory.Abelian.toPreadditive",
"List.IsChain.cons_cons",
"CategoryTheory.Limits.hasFiniteCoproducts_of_hasFiniteColimits",
"CategoryTheory.Functor.PreservesHomology.preservesRightHomologyOf",
"CategoryTheory.Functor... | true |
Std.IterM.step_intermediateDropWhile | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | [
"Pure.pure",
"Eq.mpr",
"Std.Shrink.deflate",
"False",
"Subtype.mk.congr_simp",
"Decidable.casesOn",
"Std.Iterators.Types.DropWhile.PlausibleStep.start",
"dite_congr",
"bind_congr",
"Std.Iterators.PostconditionT.operation_pure",
"Std.IterStep",
"Std.Iterators.Types.DropWhile.PlausibleStep.dropp... | true |
Filter.Germ.instAddMonoid._proof_6 | Mathlib.Order.Filter.Germ.Basic | [
"Filter.Germ.ofFun",
"AddMonoid.toAddSemigroup",
"Filter.Germ.instAddMonoid._proof_3",
"AddMonoid.toAddZeroClass",
"AddMonoid.toZero",
"AddMonoid.add_zero",
"AddMonoid.toNSMul",
"Function.Surjective.addMonoid",
"AddZeroClass.toAddZero",
"Filter.Germ.instAdd",
"AddZero.toZero",
"instHAdd",
"A... | false |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.elabUsingElabFnsAux._sunfold | Lean.Elab.Term.TermElabM | [
"Lean.MessageData",
"Lean.Elab.Term.TermElab",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Elab.Term.instAddErrorMessageContextTermElabM",
"Lean.indentD",
"Lean.KeyedDeclsAttribute.AttributeEntry.value",
"instMonadExceptOfMonadExceptOf",
"instMonadReaderOfReaderTOfMonad",
"... | false |
Isometry.preimage_closedBall | Mathlib.Topology.MetricSpace.Isometry | [
"Real.instLE",
"Real",
"LE.le",
"Isometry.preimage_setOf_dist",
"PseudoMetricSpace",
"Set.preimage",
"Metric.closedBall",
"Eq",
"Isometry",
"PseudoMetricSpace.toPseudoEMetricSpace",
"Set"
] | true |
Lean.Lsp.FileEvent.noConfusion | Lean.Data.Lsp.Workspace | [
"Lean.Lsp.DocumentUri",
"Lean.Lsp.FileEvent.noConfusionType",
"Lean.Lsp.FileEvent.casesOn",
"Eq.ndrec",
"Eq.refl",
"Lean.Lsp.FileEvent",
"Lean.Lsp.FileChangeType",
"Eq"
] | false |
Nat.ascFactorial._sunfold | Mathlib.Data.Nat.Factorial.Basic | [
"HMul.hMul",
"Nat.ascFactorial",
"instMulNat",
"instOfNatNat",
"instHAdd",
"Unit",
"HAdd.hAdd",
"Nat",
"instAddNat",
"OfNat.ofNat",
"Nat.factorial.match_1",
"instHMul"
] | false |
CategoryTheory.GrothendieckTopology.rec | Mathlib.CategoryTheory.Sites.Grothendieck | [
"Lattice.toSemilatticeSup",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CompleteLattice.toLattice",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"CompleteLattice.toBoundedOrder",
"CategoryTheory.Sieve.arrows",
"CategoryTheory.Sieve",
"CategoryTheory.GrothendieckTopo... | false |
Lean.Elab.Tactic.evalSimpAllArith._regBuiltin.Lean.Elab.Tactic.evalSimpAllArith_1 | Lean.Elab.Tactic.SimpArith | [
"Lean.Elab.Tactic.tacticElabAttribute",
"IO",
"Unit",
"Lean.Elab.Tactic.Tactic",
"Lean.Name.mkStr4",
"Lean.KeyedDeclsAttribute.addBuiltin",
"Lean.Elab.Tactic.evalSimpAllArith"
] | false |
UpperSet.completeLattice._proof_8 | Mathlib.Order.UpperLower.CompleteLattice | [
"OrderDual.toDual",
"Equiv.instEquivLike",
"UpperSet",
"UpperSet.instSetLike",
"Function.comp",
"Equiv",
"Bot.bot",
"LE",
"UpperSet.instBot",
"SetLike.coe",
"OrderDual",
"Eq",
"DFunLike.coe",
"rfl",
"EquivLike.toFunLike",
"Set"
] | false |
Std.Sat.CNF.sat_relabel | Std.Sat.CNF.Relabel | [
"Std.Sat.CNF.relabel",
"Std.Sat.CNF",
"_private.Std.Sat.CNF.Relabel.0.Std.Sat.CNF.sat_relabel._simp_1_1",
"congrArg",
"Std.Sat.CNF.eval_relabel",
"Std.Sat.CNF.eval",
"Function.comp",
"Eq.mp",
"id",
"Bool.true",
"True",
"eq_self",
"Bool",
"of_eq_true",
"congrFun'",
"Std.Sat.CNF.Sat",
... | true |
Fin.castLE._proof_1 | Init.Data.Fin.Basic | [
"Fin.isLt",
"LE.le",
"instLENat",
"Fin.val",
"Nat",
"LT.lt",
"instLTNat",
"Fin",
"Nat.lt_of_lt_of_le"
] | false |
CoheytingHom.instFunLike._proof_1 | Mathlib.Order.Heyting.Hom | [
"CoheytingHom.casesOn",
"Lattice",
"Lattice.toSemilatticeSup",
"SupHom.toFun",
"SupHom.casesOn",
"CoheytingHom.toLatticeHom",
"PartialOrder.toPreorder",
"Preorder.toLE",
"CoheytingAlgebra.toOrderTop",
"Eq.rec",
"SemilatticeSup.toMax",
"Max",
"CoheytingHom.mk",
"CoheytingHom",
"CoheytingA... | false |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.instReprCongrArgKind.repr.match_1 | Lean.Meta.CongrTheorems | [
"Unit.unit",
"Lean.Meta.CongrArgKind.fixedNoParam",
"Lean.Meta.CongrArgKind.subsingletonInst",
"Lean.Meta.CongrArgKind.heq",
"Lean.Meta.CongrArgKind",
"Unit",
"Lean.Meta.CongrArgKind.casesOn",
"Lean.Meta.CongrArgKind.eq",
"Lean.Meta.CongrArgKind.cast",
"Lean.Meta.CongrArgKind.fixed"
] | false |
Set.Countable.setOf_finite | Mathlib.Data.Set.Countable | [
"and_true",
"congrArg",
"Set.univ",
"setOf",
"Set.Finite",
"Eq.mp",
"HasSubset.Subset",
"funext",
"Set.countable_univ",
"And",
"True",
"Countable",
"Set.subset_univ._simp_1",
"Set.Countable",
"Eq.trans",
"Set.countable_setOf_finite_subset",
"Set.instHasSubset",
"Set"
] | true |
_private.Mathlib.Combinatorics.SetFamily.LYM.0.Finset.slice_union_shadow_falling_succ._simp_1_1 | Mathlib.Combinatorics.SetFamily.LYM | [
"Finset.instUnion",
"Finset",
"Membership.mem",
"Finset.instSetLike",
"propext",
"Finset.mem_union",
"Or",
"Union.union",
"Eq",
"SetLike.instMembership",
"DecidableEq"
] | false |
Lean.Exception.isInterrupt | Lean.Exception | [
"BEq.beq",
"_private.Lean.Exception.0.Lean.Exception.isInterrupt.match_1",
"Lean.instBEqInternalExceptionId",
"Bool",
"Lean.InternalExceptionId",
"Lean.KVMap",
"Bool.false",
"Lean.Exception",
"Lean.interruptExceptionId"
] | true |
Lean.Grind.isLE | Init.Grind.Offset | [
"LE.le",
"instLENat",
"Nat",
"Bool",
"Decidable.decide",
"Nat.decLe"
] | true |
ValuationSubring.principalUnitGroupEquiv._proof_2 | Mathlib.RingTheory.Valuation.ValuationSubring | [
"ValuationSubring.coe_mem_principalUnitGroup_iff",
"Subtype.mk.congr_simp",
"ValuationSubring.unitGroup",
"MulEquiv.instEquivLike",
"congrArg",
"ValuationSubring.unitGroupMulEquiv",
"CommSemiring.toSemiring",
"ValuationSubring.isLocalRing",
"Subgroup.mul",
"IsLocalRing.residue",
"Membership.mem"... | false |
Aesop.Frontend.RuleExpr | Aesop.Frontend.RuleExpr | [
"Aesop.Frontend.RuleExpr.node"
] | true |
GroupTopology.instTop | Mathlib.Topology.Algebra.Group.GroupTopology | [
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"PartialOrder.toPreorder",
"Group",
"Preorder.toLE",
"TopologicalSpace.instCompleteLattice",
"CompleteLattice.toBoundedOrder",
"GroupTopology.instTop._proof_1",
"Top.mk",
"TopologicalSpace",
"OrderTop.toTop",
"BoundedOrder.toOrderTop",
... | true |
PartitionOfUnity.le_one | Mathlib.Topology.PartitionOfUnity | [
"single_le_finsum",
"Real.instLE",
"Real",
"Real.instZero",
"PartitionOfUnity.locallyFinite",
"PartitionOfUnity",
"ContinuousMap",
"finsum",
"PseudoMetricSpace.toUniformSpace",
"PartitionOfUnity.nonneg",
"LE.le",
"Real.instOne",
"PartitionOfUnity.instFunLikeContinuousMapReal",
"Topological... | true |
ContDiffMapSupportedIn.toBoundedContinuousFunctionLM._proof_5 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | [
"Real",
"Continuous",
"NormedSpace",
"BoundedContinuousFunction.instCoeTC._proof_1",
"PseudoMetricSpace.toUniformSpace",
"ContDiffMapSupportedIn.toContDiffMapSupportedInClass",
"ContDiffMapSupportedIn",
"ContDiffMapSupportedInClass.toDFunLike",
"SeminormedAddCommGroup.toPseudoMetricSpace",
"ContDi... | false |
MeasureTheory.MemLp.norm_rpow_div | Mathlib.MeasureTheory.Function.LpSpace.Basic | [
"ENNReal.div_top",
"AEMeasurable.aestronglyMeasurable",
"Real.hasMeasurablePow",
"Norm.norm",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"MulOne.toOne",
"AEMeasurable.pow_const",
"Real.instPow",
"MeasureTheory.AEStronglyMeasurable.aemeasurable",
"Semigroup.toMul",
"Real",
"DivInvMonoid... | true |
_private.Mathlib.LinearAlgebra.QuadraticForm.Basic.0.QuadraticMap.map_sum._simp_1_2 | Mathlib.LinearAlgebra.QuadraticForm.Basic | [
"False",
"True",
"propext",
"not_true",
"Eq",
"Not"
] | false |
Std.Iter.toList_drop | Std.Data.Iterators.Lemmas.Combinators.Drop | [
"Eq.mpr",
"Std.Iter.atIdxSlow?_drop",
"Std.Iter.getElem?_toList_eq_atIdxSlow?",
"List.getElem?_drop",
"congrArg",
"Iff.rfl",
"List.instGetElem?NatLtLength",
"Option.some",
"Std.Iterators.Finite",
"id",
"Std.Iterators.instProductiveOfFinte",
"Id",
"Option.ext",
"Std.Iterator",
"Std.Iter.d... | true |
ContDiffMapSupportedInClass.instContinuousMapClass | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | [
"ContDiffMapSupportedInClass.map_contDiff",
"Real",
"NormedSpace",
"outParam",
"Real.denselyNormedField",
"ContDiffMapSupportedInClass",
"ContDiff.continuous",
"PseudoMetricSpace.toUniformSpace",
"ContinuousMapClass",
"WithTop.some",
"ContDiffMapSupportedInClass.toDFunLike",
"ContinuousMapClas... | true |
tsum_setProd_singleton_left | Mathlib.Topology.Algebra.InfiniteSum.Constructions | [
"Set.instSProd",
"Eq.mpr",
"SProd.sprod",
"congrArg",
"Function.Injective.injOn",
"Membership.mem",
"tsum_image",
"Set.Elem",
"Set.instSingletonSet",
"id",
"Set.singleton_prod",
"Prod.mk",
"tsum_congr_set_coe",
"AddCommMonoid",
"TopologicalSpace",
"tsum",
"Eq.refl",
"Set.image",
... | true |
Set.centralizer_centralizer_centralizer | Mathlib.Algebra.Group.Center | [
"Set.Subset.antisymm",
"Mul",
"Membership.mem",
"Set.centralizer",
"Set.subset_centralizer_centralizer",
"Eq",
"Set.instMembership",
"Set"
] | true |
instIsBoundedSMulSeparationQuotient | Mathlib.Topology.MetricSpace.Algebra | [
"Real.instLE",
"Real",
"instHSMul",
"HMul.hMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"dist_pair_smul",
"SMul",
"IsBoundedSMul.toUniformContinuousConstSMul",
"PseudoMetricSpace.toUniformSpace",
"IsBoundedSMul",
"inseparableSetoid",
"Quotient.ind₂",
"Quotient.ind",
"LE.le",
... | true |
CategoryTheory.Monad.algebraFunctorOfMonadHomId._proof_5 | Mathlib.CategoryTheory.Monad.Algebra | [
"CategoryTheory.Monad",
"CategoryTheory.Monad.Algebra.isoMk",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Monad.Algebra.a",
"congrArg",
"CategoryTheory.Monad.algebraFunctorOfMonadHomId._proof_2",
"CategoryTheory.Functor.id",
"CategoryTheory.CategoryStruct.id",
"Category... | false |
Std.TreeSet.Raw.get?_eq_some_getD | Std.Data.TreeSet.Raw.Lemmas | [
"Std.TreeSet.Raw.getD",
"Std.TreeSet.Raw.WF.out",
"Option.some",
"Membership.mem",
"Ordering",
"Std.TreeSet.Raw.instMembership",
"Std.TransCmp",
"Std.TreeMap.Raw.getKey?_eq_some_getKeyD",
"Std.TreeSet.Raw",
"Unit",
"Std.TreeSet.Raw.inner",
"Eq",
"Std.TreeSet.Raw.get?",
"Option",
"Std.Tre... | true |
CategoryTheory.AsSmall.abelian | Mathlib.CategoryTheory.Abelian.Transfer | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.AsSmall.abelian._proof_1",
"CategoryTheory.Abelian",
"CategoryTheory.AsSmall.preadditive",
"CategoryTheory.instSmallCategoryAsSmall",
"CategoryTheory.abelianOfEquivalence",
"CategoryTheory.AsSmall.equiv",
"CategoryTheory.AsSmall.abelian._proof_2"... | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rco.size_eq_if_roo._simp_1_2 | Init.Data.Range.Polymorphic.Lemmas | [
"Std.PRange.UpwardEnumerable",
"Std.Rxo.LawfulHasSize",
"instOfNatNat",
"Nat",
"LT.lt",
"propext",
"Std.Rxo.HasSize",
"Std.Rxo.size_eq_zero_iff_not_le",
"OfNat.ofNat",
"Std.Rxo.HasSize.size",
"Eq",
"Not",
"LT"
] | false |
Finset.truncatedInf_union | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | [
"Iff.mpr",
"Eq.mpr",
"UpperSet",
"Finset.instUnion",
"Finset.inf'",
"Finset.truncatedInf",
"congrArg",
"Finset.inf'_congr",
"Finset",
"UpperSet.instSetLike",
"upperClosure",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Eq.rec",
"id",... | true |
GenContFract.succ_succ_nth_conv'Aux_eq_succ_nth_conv'Aux_squashSeq | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | [
"Eq.mpr",
"Stream'.Seq",
"Nat.zero_le",
"Nat.instMulZeroClass",
"GenContFract.Pair.b",
"Nat.recAux",
"instHDiv",
"GenContFract.Pair.a",
"Nat.instOne",
"GenContFract.squashSeq",
"GenContFract.convs'Aux",
"Ring.toNonAssocRing",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddGroupWithOne.toAdd... | true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.matchAtomic | Lean.Server.Completion.CompletionCollectors | [
"String",
"instDecidableEqBool",
"String.charactersIn",
"Bool.true",
"Bool",
"Lean.Name",
"Bool.false",
"Eq",
"_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.matchAtomic.match_1",
"ite"
] | true |
UniformSpace.Completion.instNormedRing._proof_15 | Mathlib.Analysis.Normed.Module.Completion | [
"HMul.hMul",
"Semiring.npow",
"PseudoMetricSpace.toUniformSpace",
"SeminormedRing.toRing",
"inferInstance",
"NonUnitalNonAssocSemiring.toMul",
"NonUnitalSemiring.toNonUnitalNonAssocSemiring",
"instOfNatNat",
"Semiring.npow_succ",
"instHAdd",
"UniformSpace.Completion.ring",
"HAdd.hAdd",
"Nat"... | false |
ByteArray.extract_eq_extract_iff_getElem | Init.Data.ByteArray.Lemmas | [
"ByteArray.extract_eq_extract_iff_getElem._proof_2",
"Eq.mpr",
"False",
"Nat.recAux",
"ByteArray.extract_add_one",
"and_true",
"_private.Init.Data.ByteArray.Lemmas.0.ByteArray.extract_eq_extract_iff_getElem._proof_1_2",
"_private.Init.Data.ByteArray.Lemmas.0.ByteArray.extract_eq_extract_iff_getElem._p... | true |
Std.Tactic.BVDecide.BVBinPred.eval | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | [
"Std.Tactic.BVDecide.BVBinPred.toString.match_1",
"BitVec",
"instBEqOfDecidableEq",
"instDecidableEqBitVec",
"BEq.beq",
"Unit",
"Nat",
"Bool",
"Std.Tactic.BVDecide.BVBinPred",
"BitVec.ult"
] | true |
expandLemma | Mathlib.Tactic.Lemma | [
"Pure.pure",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.Syntax",
"instOfNatNat",
"Lean.MacroM",
"Applicative.toPure",
"Lean.Macro.Context",
"Bool.true",
"Lean.Macro.State",
"Nat",
"EStateM",
"OfNat.ofNat",
"Lean.Name.mkStr4",
"ReaderT.instApplicativeOfMonad",
"Lean.Syntax.setKi... | true |
ByteArray.toList.loop._unary.eq_def | Init.Data.ByteArray.Basic | [
"List.unattach",
"Eq.mpr",
"instSubsingletonDecidable",
"congrArg",
"InvImage",
"HSub.hSub",
"Decidable",
"WellFounded.Nat.fix",
"Membership.mem",
"WellFounded.Nat.fix_eq",
"ByteArray.toList.loop._unary._proof_1",
"Eq.rec",
"PSigma.casesOn",
"id",
"Subtype",
"ByteArray.toList.loop._una... | false |
TwoUniqueSums.instForall | Mathlib.Algebra.Group.UniqueProds.Basic | [
"Iff.mpr",
"Eq.mpr",
"exists_or",
"Finset.exists_of_one_lt_card_pi",
"HMul.hMul",
"Finset.mem_image",
"Finset.Nonempty.image",
"SProd.sprod",
"congrArg",
"Finset.filter_nonempty_iff",
"Finset",
"uniqueAdd_of_twoUniqueAdd",
"Finset.isWellFounded_ssubset",
"HasSSubset.SSubset",
"Classical.... | true |
EuclideanGeometry.Sphere.IsExtTangentAt.mem_left | Mathlib.Geometry.Euclidean.Sphere.Tangent | [
"Real",
"Real.instRCLike",
"EuclideanGeometry.Sphere",
"Membership.mem",
"MetricSpace",
"MetricSpace.toPseudoMetricSpace",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"InnerProductSpace",
"NormedAddCommGroup",
"EuclideanGeometry.Sphere.IsExtTangentAt",
"NormedAddTorsor",
"EuclideanGeometry.... | true |
Qq.Impl.isIrrefutablePattern | Qq.Match | [
"Inhabited.default",
"instInhabitedBool",
"Lean.Syntax.Term",
"Bool"
] | true |
_private.Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated.0.MeasurableSpace.CountablySeparated.mono._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | [
"MeasurableSet",
"MeasurableSpace.countablySeparated_def",
"Set.univ",
"MeasurableSpace",
"MeasurableSpace.CountablySeparated",
"HasCountableSeparatingOn",
"propext",
"Eq"
] | false |
Int.getElem!_toArray_roo | Init.Data.Range.Polymorphic.IntLemmas | [
"Eq.mpr",
"Inhabited.default",
"Decidable.casesOn",
"Int.instInhabited",
"congrArg",
"Std.PRange.instUpwardEnumerableInt",
"HSub.hSub",
"Decidable",
"Option.getD",
"Option.some",
"id",
"Int",
"if_pos",
"Nat.cast",
"Int.getElem?_toArray_roo",
"Std.PRange.instIsAlwaysFiniteInt_1",
"Arr... | true |
_private.Init.Data.String.FindPos.0.String.Slice.posGE._unary._proof_1 | Init.Data.String.FindPos | [
"String.instLTRaw",
"String.Slice.rawEndPos",
"String.Slice",
"String.Pos.Raw.instLawfulOrderLT",
"Eq.rec",
"LE.le",
"String.Pos.Raw",
"String.Pos.Raw.IsValidForSlice",
"String.Pos.Raw.isValidForSlice_rawEndPos",
"Std.not_le",
"String.Pos.Raw.instAntisymmLe",
"LT.lt",
"String.instLERaw",
"... | false |
Subrepresentation.mk._flat_ctor | Mathlib.RepresentationTheory.Subrepresentation | [
"Monoid",
"Submodule",
"Representation",
"MonoidHom.instFunLike",
"Monoid.toMulOneClass",
"Module.End.instSemiring",
"LinearMap.instFunLike",
"Membership.mem",
"NonAssocSemiring.toMulZeroOneClass",
"Subrepresentation",
"LinearMap",
"AddCommMonoid",
"MulZeroOneClass.toMulOneClass",
"MulOneC... | false |
Lean.VersoModuleDocs.Snippet.mk.injEq | Lean.DocString.Extension | [
"Eq.propIntro",
"Lean.Doc.Block",
"Lean.injEq_helper",
"Array",
"Lean.DeclarationRange",
"Empty",
"And",
"Nat",
"Eq.ndrec",
"Lean.Doc.Part",
"Eq.refl",
"Lean.ElabBlock",
"Prod",
"Lean.ElabInline",
"Lean.VersoModuleDocs.Snippet.mk",
"Eq",
"Lean.VersoModuleDocs.Snippet",
"Lean.VersoM... | true |
Mathlib.Tactic.DepRewrite.instDecidableLECastMode._proof_1 | Mathlib.Tactic.DepRewrite | [
"Nat.le_of_ble_eq_true",
"Nat.ble",
"LE.le",
"instLENat",
"Bool.true",
"Mathlib.Tactic.DepRewrite.CastMode.toNat",
"Nat",
"Mathlib.Tactic.DepRewrite.CastMode",
"Bool",
"Eq"
] | false |
Aesop.ScriptGenerated.perfect | Aesop.Stats.Basic | [
"Aesop.ScriptGenerated",
"Bool"
] | true |
Filter.liminf_bot | Mathlib.Order.LiminfLimsup | [
"Filter.limsInf",
"Lattice.toSemilatticeSup",
"Filter.map_bot",
"Filter.liminf",
"CompleteLattice.toLattice",
"congrArg",
"Filter.map",
"PartialOrder.toPreorder",
"Preorder.toLE",
"CompleteLattice.toConditionallyCompleteLattice",
"CompleteLattice.toBoundedOrder",
"Bot.bot",
"OrderTop.toTop",... | true |
_private.Mathlib.Topology.Compactness.LocallyCompact.0.LocallyCompactSpace.of_hasBasis.match_1_1 | Mathlib.Topology.Compactness.LocallyCompact | [
"Exists",
"HasSubset.Subset",
"And.casesOn",
"And",
"Exists.casesOn",
"And.intro",
"Exists.intro",
"Set.instHasSubset",
"Set"
] | false |
Lean.Grind.toInt_bitVec | Init.GrindInstances.ToInt | [
"Lean.Grind.ToInt.toInt",
"Lean.Grind.instToIntBitVecUint",
"BitVec",
"Lean.Grind.IntInterval.uint",
"Int",
"BitVec.toNat",
"Nat.cast",
"Nat",
"instNatCastInt",
"Eq",
"rfl"
] | true |
Int.natAbs_dvd_natAbs._simp_1 | Init.Data.Int.DivMod.Bootstrap | [
"Dvd.dvd",
"Int",
"Int.instDvd",
"Int.natAbs_dvd_natAbs",
"Nat.instDvd",
"Nat",
"Int.natAbs",
"propext",
"Eq"
] | false |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._proof_1_1 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | [
"Lean.RArray.leaf",
"False",
"congrArg",
"Classical.byContradiction",
"Lean.RArray.branch",
"id",
"Lean.RArray",
"Int.instNegInt",
"instOfNatNat",
"Int",
"Int.Linear.Poly.num",
"Int.Linear.Poly.add",
"Int.Linear.norm_eq",
"Int.Linear.diseq_unsat",
"Bool.true",
"instHAdd",
"instOfNat"... | false |
ModelWithCorners.continuousOn_symm | Mathlib.Geometry.Manifold.IsManifold.Basic | [
"Continuous.continuousOn",
"NormedSpace",
"PseudoMetricSpace.toUniformSpace",
"TopologicalSpace",
"ModelWithCorners",
"SeminormedAddCommGroup.toPseudoMetricSpace",
"ModelWithCorners.continuous_symm",
"ModelWithCorners.symm",
"NontriviallyNormedField",
"ContinuousOn",
"NontriviallyNormedField.toN... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.toList_insert_perm._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | [
"List.Perm",
"Std.DTreeMap.Internal.Impl.Equiv",
"propext",
"Std.DTreeMap.Internal.Impl.toListModel",
"Std.DTreeMap.Internal.Impl.equiv_iff_toListModel_perm",
"Eq",
"Std.DTreeMap.Internal.Impl",
"Sigma"
] | false |
_private.Mathlib.GroupTheory.QuotientGroup.Basic.0.QuotientGroup.quotientInfEquivProdNormalizerQuotient._simp_4 | Mathlib.GroupTheory.QuotientGroup.Basic | [
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"Group",
"Group.toDivisionMonoid",
"Membership.mem",
"DivisionMonoid.toDivInvOneMonoid",
"QuotientGroup.leftRel",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"Subgroup",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"Inv.... | false |
AddOpposite.instRightCancelSemigroup | Mathlib.Algebra.Group.Opposite | [
"Semigroup.toMul",
"AddOpposite",
"RightCancelSemigroup.toSemigroup",
"AddOpposite.instRightCancelSemigroup._proof_1",
"AddOpposite.unop",
"Function.Injective.rightCancelSemigroup",
"AddOpposite.unop_injective",
"RightCancelSemigroup",
"AddOpposite.instMul"
] | true |
Vector.toArray_reverse | Init.Data.Vector.Lemmas | [
"Vector",
"Array.reverse",
"Vector.reverse",
"Array",
"Nat",
"Eq",
"Vector.toArray",
"rfl"
] | true |
Lean.Elab.FieldInfo.noConfusion | Lean.Elab.InfoTree.Types | [
"Lean.Syntax",
"Lean.Expr",
"Lean.Elab.FieldInfo",
"Lean.Elab.FieldInfo.casesOn",
"Eq.ndrec",
"Lean.Name",
"Eq.refl",
"Lean.Elab.FieldInfo.noConfusionType",
"Eq",
"Lean.LocalContext"
] | false |
_private.Mathlib.Topology.Order.LowerUpperTopology.0.Topology.IsLower.isTopologicalSpace_basis._simp_1_6 | Mathlib.Topology.Order.LowerUpperTopology | [
"Set.iInter",
"Membership.mem",
"Set.mem_iInter",
"propext",
"Eq",
"Set.instMembership",
"Set"
] | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.processExplicitArg._sparseCasesOn_1 | Lean.Elab.App | [
"Nat.ne_of_beq_eq_false",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Bool.ctorIdx",
"Bool.true",
"Nat.land",
"Nat",
"Bool.rec",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"Bool.false"
] | false |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exists_closedBall_covering_tsum_measure_le._simp_1_16 | Mathlib.MeasureTheory.Covering.Besicovitch | [
"Set.mem_image",
"Membership.mem",
"Exists",
"And",
"propext",
"Set.image",
"Eq",
"Set.instMembership",
"Set"
] | false |
_private.Mathlib.Data.List.Sym.0.List.Nodup.sym2._simp_1_8 | Mathlib.Data.List.Sym | [
"Exists",
"exists_eq_right",
"And",
"propext",
"Eq"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.