name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
AddChar.coe_mul._simp_1 | Mathlib.Algebra.Group.AddChar | [
"AddChar.coe_mul",
"HMul.hMul",
"Monoid.toMulOneClass",
"AddChar",
"MulOne.toMul",
"MulOneClass.toMulOne",
"CommMonoid.toMonoid",
"AddMonoid",
"AddChar.instCommMonoid",
"Pi.instMul",
"Eq.symm",
"Eq",
"CommMonoid",
"DFunLike.coe",
"AddChar.instFunLike",
"instHMul"
] | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Operations.0.SimpleGraph.Walk.concatRecAux.match_1.eq_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | [
"Unit.unit",
"SimpleGraph.Walk.concatRecAux.match_1",
"SimpleGraph.Adj",
"SimpleGraph.Walk",
"SimpleGraph",
"SimpleGraph.Walk.cons",
"Unit",
"SimpleGraph.Walk.nil",
"Eq.refl",
"Eq"
] | true |
Std.DTreeMap.Internal.Const.RiiSliceData.mk.noConfusion | Std.Data.DTreeMap.Internal.Zipper | [
"Std.DTreeMap.Internal.Const.RiiSliceData",
"Std.DTreeMap.Internal.Const.RiiSliceData.mk",
"id",
"Std.DTreeMap.Internal.Const.RiiSliceData.noConfusion",
"heq_of_eq",
"Eq.refl",
"HEq",
"Std.Rii",
"Eq",
"Std.DTreeMap.Internal.Impl"
] | false |
ProbabilityTheory.iIndepFun.indepFun_mul_left | Mathlib.Probability.Independence.Basic | [
"Unit.unit",
"MeasureTheory.Measure",
"HMul.hMul",
"Measurable",
"Mul",
"Ne",
"MeasureTheory.Measure.dirac",
"ProbabilityTheory.iIndepFun",
"ProbabilityTheory.Kernel.iIndepFun.indepFun_mul_left",
"MeasurableSpace",
"Unit",
"PUnit.instMeasurableSpace",
"Pi.instMul",
"ProbabilityTheory.Indep... | true |
Mathlib.Linter.Style.initFn._@.Mathlib.Tactic.Linter.DeprecatedSyntaxLinter.3986038175._hygCtx._hyg.4 | Mathlib.Tactic.Linter.DeprecatedSyntaxLinter | [
"Lean.Option",
"IO",
"Lean.Name.mkStr3",
"Lean.Option.Decl.mk",
"Lean.KVMap.instValueBool",
"Lean.Option.register",
"Lean.Name.mkStr6",
"Bool",
"Bool.false"
] | false |
LowerSet.map | Mathlib.Order.UpperLower.CompleteLattice | [
"Equiv.instEquivLike",
"RelIso.mk",
"PartialOrder.toPreorder",
"LowerSet.map._proof_4",
"Preorder.toLE",
"Equiv.mk",
"LowerSet.map._proof_2",
"Equiv",
"OrderIso",
"LE.le",
"LowerSet.map._proof_1",
"LowerSet.instPartialOrder",
"RelIso",
"Iff",
"LowerSet.map._proof_6",
"SetLike.coe",
"... | true |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.le_sliceTo_iff._simp_1_2 | Init.Data.String.Lemmas.Order | [
"String",
"String.Pos.sliceTo_lt_iff",
"LE.le",
"String.instLTPos",
"LT.lt",
"String.instLTPos_1",
"propext",
"String.Pos",
"String.instLEPos",
"String.sliceTo",
"String.Slice.Pos",
"String.Pos.sliceTo",
"Eq",
"String.Pos.ofSliceTo"
] | false |
_private.Mathlib.AlgebraicTopology.ModelCategory.Over.0.HomotopicalAlgebra.fibrations_over_iff._simp_1_2 | Mathlib.AlgebraicTopology.ModelCategory.Over | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.Over",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Over.Hom.left",
"CategoryTheory.instCategoryOver",
"CategoryTheory.Over.left",
"CategoryTheory.MorphismProperty.over_iff",
"propext",
"CategoryTheory.Category.toCategor... | false |
CategoryTheory.ShortComplex.X₃ | Mathlib.Algebra.Homology.ShortComplex.Basic | [
"CategoryTheory.Limits.HasZeroMorphisms",
"CategoryTheory.ShortComplex",
"CategoryTheory.Category"
] | true |
Function.LeftInverse.eq | Mathlib.Logic.Function.Basic | [
"Function.LeftInverse",
"Eq"
] | true |
Aesop.ForwardHypData.mk.inj | Aesop.RuleTac.Forward.Basic | [
"Lean.instBEqFVarId",
"Aesop.ForwardHypData.mk.noConfusion",
"Aesop.ForwardHypData.mk",
"Lean.FVarId",
"Std.HashMap",
"Lean.instHashableFVarId",
"Nat",
"Aesop.ForwardHypData",
"Eq"
] | true |
DirectSum.coe_decompose_mul_of_right_mem_of_le | Mathlib.RingTheory.GradedAlgebra.Basic | [
"GradedRing.toGradedMonoid",
"SetLike",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Equiv.instEquivLike",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"instAddCommMonoidDirectSum",
"congrArg",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"HSub.hSub",
"Preorder.toLE",
"Membe... | true |
_private.Mathlib.Data.Ordmap.Ordset.0.Ordnode.adjustWith.match_1.splitter | Mathlib.Data.Ordmap.Ordset | [
"Unit.unit",
"Ordnode",
"Ordnode.node",
"Unit",
"Ordnode.casesOn",
"Nat",
"Ordnode.nil"
] | true |
Submodule.toBaseChange_surjective' | Mathlib.LinearAlgebra.TensorProduct.Tower | [
"Submodule",
"Algebra.to_smulCommClass",
"Semiring.toModule",
"congrArg",
"CommSemiring.toSemiring",
"Submodule.addCommMonoid",
"TensorProduct.addCommMonoid",
"LinearMap.instFunLike",
"Submodule.toBaseChange_surjective",
"Algebra",
"Membership.mem",
"Exists",
"Algebra.toModule",
"id",
"S... | true |
Subalgebra.topologicalClosure_comap_homeomorph | Mathlib.Topology.Algebra.Algebra | [
"Subalgebra.instSetLike",
"Eq.mpr",
"Subsemiring.instSetLike",
"Ring.toNonAssocRing",
"congrArg",
"AlgHom",
"IsSemitopologicalRing.toIsSemitopologicalSemiring",
"AlgHom.funLike",
"Algebra",
"id",
"Subalgebra.toSubsemiring",
"IsSemitopologicalRing",
"Subsemiring",
"NonAssocRing.toNonUnitalN... | true |
ScottContinuous.inf₂.match_1 | Mathlib.Order.ScottContinuity.Complete | [
"Prod.mk",
"Prod",
"Prod.casesOn"
] | false |
Set.MapsTo.mem_iff | Mathlib.Data.Set.Function | [
"Compl.compl",
"Membership.mem",
"Set.instCompl",
"Iff",
"Set.MapsTo",
"Iff.intro",
"by_contra",
"Set.instMembership",
"Not",
"Set"
] | true |
_private.Lean.Elab.Tactic.Grind.SimprocDSLBuiltin.0.Lean.Elab.Tactic.Grind.elabSimprocAndThen._regBuiltin._private.Lean.Elab.Tactic.Grind.SimprocDSLBuiltin.0.Lean.Elab.Tactic.Grind.elabSimprocAndThen_1 | Lean.Elab.Tactic.Grind.SimprocDSLBuiltin | [
"Lean.Name.mkStr5",
"IO",
"Lean.Elab.Tactic.Grind.symSimprocElabAttribute",
"instOfNatNat",
"Lean.Name.num",
"Lean.Name.str",
"Lean.Name.anonymous",
"Unit",
"_private.Lean.Elab.Tactic.Grind.SimprocDSLBuiltin.0.Lean.Elab.Tactic.Grind.elabSimprocAndThen",
"Nat",
"Lean.Elab.Tactic.Grind.SymSimprocE... | false |
LinearMap.lflip._proof_1 | Mathlib.LinearAlgebra.BilinearMap | [
"DistribMulAction.toDistribSMul",
"LinearMap.instSMulCommClass",
"AddMonoid.toAddZeroClass",
"RingHom",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"LinearMap",
"AddCommMonoid",
"AddZero.toZero",
"LinearMap.instSMul",
"Semiring.toMonoid",
"Semiring",
"Module.toDistribMulAction",... | false |
Semigrp.hom_inv_apply | Mathlib.Algebra.Category.Semigrp.Basic | [
"MulHom",
"Semigroup.toMul",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"CategoryTheory.Iso",
"Semigrp.instConcreteCategoryMulHomCarrier",
"Semigrp.str",
"Semigrp",
"Semigrp.instCategory",
"True",
"eq_self",
"MulHom.funLike",
"of_eq_true",
"congrFun'",
"Semigrp.carrier",
"Categ... | true |
Ideal.Quotient.tower_quotient_map_quotient | Mathlib.RingTheory.Ideal.Over | [
"Ideal.Quotient.commSemiring",
"Eq.mpr",
"CommRing",
"Semiring.toModule",
"IsScalarTower.right",
"Algebra.algebraMap",
"congrArg",
"CommSemiring.toSemiring",
"Ideal.Quotient.mk",
"IsScalarTower",
"Ideal.Quotient.algebraMap_eq",
"Ideal.Quotient.algebraMap_quotient_map_quotient",
"Algebra",
... | true |
CategoryTheory.Functor.CoreMonoidal.mk | Mathlib.CategoryTheory.Monoidal.Functor | [
"CategoryTheory.Functor.CoreMonoidal.right_unitality._autoParam",
"CategoryTheory.Functor",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.MonoidalCategoryStruct.rightUnitor",
"CategoryTheory.MonoidalCategory",
"CategoryTheo... | true |
Lean.Lsp.RpcConnected.mk.inj | Lean.Data.Lsp.Extra | [
"Lean.Lsp.RpcConnected.mk",
"UInt64",
"Lean.Lsp.RpcConnected.mk.noConfusion",
"Lean.Lsp.RpcConnected",
"Eq"
] | true |
_private.Mathlib.Logic.Function.Iterate.0.Function.iterate_add.match_1_1 | Mathlib.Logic.Function.Iterate | [
"Unit.unit",
"instOfNatNat",
"Unit",
"Nat",
"OfNat.ofNat",
"Nat.succ",
"Nat.casesOn"
] | false |
_private.Mathlib.MeasureTheory.Measure.Tight.0.MeasureTheory.IsTightMeasureSet.map._simp_1_5 | Mathlib.MeasureTheory.Measure.Tight | [
"Compl.compl",
"HasSubset.Subset",
"Set.instCompl",
"Set.compl_subset_compl",
"propext",
"Eq",
"Set.instHasSubset",
"Set"
] | false |
Lean.Elab.PartialTermInfo.toElabInfo | Lean.Elab.InfoTree.Types | [
"Lean.Elab.PartialTermInfo",
"Lean.Elab.ElabInfo"
] | true |
AddCommute.zero_left | Mathlib.Algebra.Group.Commute.Defs | [
"AddZeroClass.toAddZero",
"AddCommute",
"AddZero.toZero",
"AddZeroClass",
"AddZero.toAdd",
"Zero.toOfNat0",
"AddSemiconjBy.zero_left",
"OfNat.ofNat"
] | true |
_aux_Mathlib_LinearAlgebra_SModEq_Basic___unexpand_SModEq_1 | Mathlib.LinearAlgebra.SModEq.Basic | [
"Pure.pure",
"cond",
"Lean.TSyntax",
"Unit.unit",
"Lean.MonadRef.mkInfoFromRefPos",
"instMonadExceptOfMonadExceptOf",
"Lean.SourceInfo",
"Lean.PrettyPrinter.UnexpandM",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Syntax.atom",
"Lean.TSyntax.mk",
"Lean.Syntax",
... | false |
Tactic.ReduceModChar.TypeToCharPResult.ctorElim | Mathlib.Tactic.ReduceModChar | [
"Tactic.ReduceModChar.TypeToCharPResult.failure",
"Lean.Expr.const",
"Lean.Expr.sort",
"Lean.Level",
"Tactic.ReduceModChar.TypeToCharPResult.intLike",
"List.cons",
"Qq.Quoted",
"Tactic.ReduceModChar.TypeToCharPResult.casesOn",
"Nat",
"Eq.ndrec",
"Lean.Name.mkStr2",
"Lean.Expr.app",
"Lean.Lev... | false |
CommRingCat | Mathlib.Algebra.Category.Ring.Basic | [
"CommRingCat.of"
] | true |
Mathlib.Tactic.Find.«_aux_Mathlib_Tactic_Find___elabRules_Mathlib_Tactic_Find_command#find__1» | Mathlib.Tactic.Find | [
"Lean.TSyntax",
"Lean.Elab.Command.CommandElab",
"Lean.Elab.Command.liftTermElabM",
"Lean.Elab.Term.synthesizeSyntheticMVars",
"Lean.Elab.Term.elabTerm",
"Lean.Elab.Term.instMonadTermElabM",
"Lean.Syntax.isOfKind",
"Lean.TSyntax.mk",
"Lean.Syntax",
"Lean.TSyntax.raw",
"Lean.Expr",
"instDecidab... | false |
Std.Internal.instInhabitedIndexMultiMap | Std.Internal.Http.Internal.IndexMultiMap | [
"Std.Internal.IndexMultiMap.mk",
"instOfNatNat",
"List.toArray",
"Array",
"Nat",
"Inhabited",
"Hashable",
"Std.Internal.IndexMultiMap",
"Std.Internal.instInhabitedIndexMultiMap._proof_1",
"Std.HashMap.emptyWithCapacity",
"Prod",
"OfNat.ofNat",
"BEq",
"Inhabited.mk",
"List.nil"
] | true |
_private.Mathlib.Data.Nat.Multiplicity.0.Nat.Prime.emultiplicity_choose_prime_pow_add_emultiplicity._simp_1_1 | Mathlib.Data.Nat.Multiplicity | [
"Finset",
"Disjoint",
"Membership.mem",
"Finset.partialOrder",
"Finset.instSetLike",
"propext",
"Finset.disjoint_right",
"Finset.instOrderBot",
"Eq",
"Not",
"SetLike.instMembership"
] | false |
AffineEquiv.toAffineMap_injective | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | [
"AffineMap.mk",
"AffineEquiv.mk.congr_simp",
"Equiv.instEquivLike",
"AddMonoid.toAddSemigroup",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"AddCommGroup.toAddGroup",
"AddCommGroup",
"Eq.mp",
"AffineEquiv.casesOn",
"id",
"Equiv",
"AffineEquiv.mk",
"LinearEquiv.toLinearMap_inj._simp_1",
"... | true |
Computation.Bind.f.match_1 | Mathlib.Data.Seq.Computation | [
"Sum.casesOn",
"Sum",
"Sum.inl",
"Computation",
"Sum.inr"
] | false |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesEIso._proof_2 | Mathlib.Algebra.Homology.SpectralObject.Page | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.ShortComplex.opcycles",
"CategoryTheory.Abelian.SpectralObject.E",
"CategoryTheory.Abelian.SpectralObject.opcyclesIso",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyc... | false |
Std.ExtTreeSet.minD_empty | Std.Data.ExtTreeSet.Lemmas | [
"Ordering",
"Std.ExtTreeSet.minD",
"Std.TransCmp",
"Unit",
"Std.ExtTreeSet",
"Std.ExtTreeMap.minKeyD_empty",
"Std.ExtTreeSet.instEmptyCollection",
"EmptyCollection.emptyCollection",
"Eq"
] | true |
RatFunc.CompletionAtInfty.instField._proof_19 | Mathlib.FieldTheory.RatFunc.Valuation | [
"RatFunc.CompletionAtInfty",
"Int.instAddCommGroup",
"Multiplicative.linearOrder",
"Mul.mk",
"Semigroup.toMul",
"One.mk",
"HMul.hMul",
"Int.instLinearOrder",
"Semigroup.mk",
"Field.toDivisionRing",
"WithZero.instLinearOrderedCommGroupWithZero",
"Valued.toIsUniformAddGroup",
"DivisionRing.toR... | false |
HahnSeries.instSMulZeroClass | Mathlib.RingTheory.HahnSeries.Addition | [
"SMulZeroClass",
"PartialOrder",
"HahnSeries.instZero",
"SMulZeroClass.mk",
"HahnSeries.instSMul",
"HahnSeries.instSMulZeroClass._proof_1",
"HahnSeries",
"Zero"
] | true |
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.unfoldMessageDataTracesContaining._unsafe_rec | Lean.Server.FileWorker.WidgetRequests | [
"Pure.pure",
"Std.Format.pretty",
"Lean.MessageData",
"_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.unfoldMessageDataTracesContaining._unsafe_rec",
"Monad.toApplicative",
"String",
"Lean.TraceData.stopTime",
"Option.some",
"Array.map",
"Lean.TraceData.result?",
"Array.any",
"in... | false |
Ideal.inertiaDeg'._proof_3 | Mathlib.RingTheory.RamificationInertia.Inertia | [
"CommRing",
"CommSemiring.toSemiring",
"Algebra",
"Ideal.LiesOver",
"Ideal",
"CommRing.toCommSemiring",
"Ideal.over_under",
"Ideal.under"
] | false |
birkhoffAverage_apply_sub_birkhoffAverage | Mathlib.Dynamics.BirkhoffSum.Average | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHSMul",
"GroupWithZero.toDivisionMonoid",
"DivInvOneMonoid.toInvOneClass",
"congrArg",
"DistribMulAction.toDistribSMul",
"birkhoffSum_apply_sub_birkhoffSum",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"HSub.hSub",
"DivisionSemiring... | true |
String.Slice.skipPrefix?_string_eq_some_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.String | [
"String.toSlice",
"congrArg",
"String",
"String.Slice.skipPrefix?_string_eq_skipPrefix?_toSlice",
"Option.some",
"String.Slice",
"Exists",
"String.Slice.skipPrefix?_slice_eq_some_iff._simp_1",
"String.Slice.Pattern.ForwardSliceSearcher.instForwardPattern",
"String.Slice.skipPrefix?",
"iff_self",... | true |
Representation.IntertwiningMap.instAddCommMonoid._proof_6 | Mathlib.RepresentationTheory.Intertwining | [
"Monoid",
"instHSMul",
"Representation",
"Pi.addCommMonoid",
"Representation.IntertwiningMap.instAdd",
"AddMonoid.toNSMul",
"Representation.IntertwiningMap.instSMulNat",
"Function.Injective.addMonoid._proof_4",
"Representation.IntertwiningMap.instFunLike",
"instOfNatNat",
"Representation.Intertw... | false |
Partrec.optionCasesOn_right | Mathlib.Computability.Partrec | [
"Iff.mpr",
"Part",
"Computable.encode_iff",
"PFun",
"congrArg",
"Part.bind",
"Primcodable.ofDenumerable",
"Computable.decode",
"Part.some",
"Part.bind_some",
"Partrec.bind",
"Option.casesOn",
"Option.some",
"Option.encodable",
"Computable.snd",
"Partrec₂.comp",
"Computable.ofOption",... | true |
Lean.InductiveVal.ctors | Lean.Declaration | [
"List",
"Lean.Name",
"Lean.InductiveVal"
] | true |
EMetric.exists_ball_subset_ball | Mathlib.Topology.EMetricSpace.Defs | [
"Preorder.toLT",
"PartialOrder.toPreorder",
"Membership.mem",
"Exists",
"HasSubset.Subset",
"Metric.exists_eball_subset_eball",
"Metric.eball",
"PseudoEMetricSpace",
"GT.gt",
"And",
"PseudoEMetricSpace.toEDist",
"ENNReal",
"ENNReal.instPartialOrder",
"Zero.toOfNat0",
"ENNReal.instZero",
... | true |
Lean.Elab.Term.UseImplicitLambdaResult.yes.inj | Lean.Elab.Term.TermElabM | [
"Lean.Elab.Term.UseImplicitLambdaResult",
"Lean.Elab.Term.UseImplicitLambdaResult.yes.noConfusion",
"Lean.Elab.Term.UseImplicitLambdaResult.yes",
"Lean.Expr",
"Eq"
] | true |
RightDerivMeasurableAux.B | Mathlib.Analysis.Calculus.FDeriv.Measurable | [
"Real",
"NormedSpace",
"Membership.mem",
"Set.instInter",
"Inter.inter",
"RightDerivMeasurableAux.A",
"Real.normedField",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"Set.instMembership",
"Set.iUnion",
"NormedAddCommGroup",
"Set"
] | true |
Finset.mem_mul | Mathlib.Algebra.Group.Pointwise.Finset.Basic | [
"HMul.hMul",
"Finset",
"Mul",
"Membership.mem",
"Exists",
"Finset.mem_image₂",
"And",
"Iff",
"Finset.mul",
"Finset.instSetLike",
"Eq",
"SetLike.instMembership",
"instHMul",
"DecidableEq"
] | true |
Lean.Lsp.WorkspaceEdit._sizeOf_1 | Lean.Data.Lsp.Basic | [
"Lean.Lsp.DocumentChange._sizeOf_inst",
"Lean.Lsp.WorkspaceEdit.rec",
"Lean.Lsp.WorkspaceEdit",
"Option._sizeOf_inst",
"String",
"Lean.Lsp.TextEditBatch",
"instSizeOfDefault",
"Std.TreeMap._sizeOf_inst",
"instOfNatNat",
"Lean.Lsp.DocumentChange",
"Ord.compare",
"Array._sizeOf_inst",
"Array",... | false |
Filter.limsSup_top | Mathlib.Order.LiminfLimsup | [
"Filter.limsSup",
"Eq.mpr",
"Lattice.toSemilatticeSup",
"CompleteLattice.toLattice",
"congrArg",
"Filter.eventually_top._simp_1",
"Filter.Eventually",
"PartialOrder.toPreorder",
"setOf",
"Preorder.toLE",
"Membership.mem",
"CompleteLattice.toConditionallyCompleteLattice",
"CompleteLattice.toB... | true |
AlgebraicGeometry.Scheme.IdealSheafData.radical_sup | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | [
"Ideal.radical_sup",
"AlgebraicGeometry.Scheme",
"Opposite",
"CommRingCat.carrier",
"AlgebraicGeometry.PresheafedSpace.carrier",
"TopologicalSpace.Opens.instPartialOrder",
"CommSemiring.toSemiring",
"CommRingCat",
"PartialOrder.toPreorder",
"TopologicalSpace.Opens",
"Membership.mem",
"Semilatt... | true |
AffineSubspace.sOppSide_pointReflection | Mathlib.Analysis.Convex.Side | [
"Eq.mpr",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"LinearOrder",
"AffineEquiv.equivLike",
"IsStrictOrderedRing",
"AddCommGroup.toAddGroup",
"Membership.mem",
"Field.toDivisionRing",
"SemilatticeInf.toPartialOrder",
"AddCommGroup",
"DistribLattice.toLattice",
"id",
"DivisionRing.toRing"... | true |
CommGrpCat.ctorIdx | Mathlib.Algebra.Category.Grp.Basic | [
"Nat",
"CommGrpCat"
] | false |
UInt8.mul_def | Init.Data.UInt.Lemmas | [
"HMul.hMul",
"BitVec",
"instOfNatNat",
"UInt8.toBitVec",
"Nat",
"instMulUInt8",
"OfNat.ofNat",
"UInt8.ofBitVec",
"UInt8",
"Eq",
"BitVec.instMul",
"rfl",
"instHMul"
] | true |
Matrix.toLinearEquiv'_symm_apply | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | [
"Pi.Function.module",
"LinearEquiv.symm",
"CommRing",
"Algebra.to_smulCommClass",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"Pi.addCommMonoid",
"CommRing.toNonUnitalCommRing",
"Matrix.module",
"CommSemiring.toSemiring",
"Matrix.instMulOfFintypeOfAddCommMonoid",
"Mat... | true |
_private.Mathlib.RingTheory.Polynomial.IsIntegral.0.IsIntegral.coeff._proof_1_2 | Mathlib.RingTheory.Polynomial.IsIntegral | [
"Polynomial.algebra._proof_1",
"CommRing",
"HMul.hMul",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"Algebra",
"RingHom",
"Polynomial",
"instDistribOfSemiring",
"CommRing.toCommSemiring",
"RingHom.instFunLike",
"Distrib.toMul",
"Polynomial.mapRingHom",
"Polynomial.semiring",
"Polyno... | false |
AddMonoidHom.add._proof_1 | Mathlib.Algebra.Group.Hom.Basic | [
"AddMonoidHom.instAddMonoidHomClass",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"map_zero",
"AddCommMonoid",
"AddZero.toZero",
"instHAdd",
"AddZeroClass",
"HAdd.hAdd",
"congr",
"True",
"eq_self",
"of_eq_true",
"AddZero.toAdd",
"Zero.toOfNat0",
"congrFun'",
"... | false |
Lean.Meta.Sym.BackwardRule.expr | Lean.Meta.Sym.Apply | [
"Lean.Expr",
"Lean.Meta.Sym.BackwardRule"
] | true |
Computation.LiftRel.symm | Mathlib.Data.Seq.Computation | [
"Symmetric",
"Membership.mem",
"Exists",
"_private.Mathlib.Data.Seq.Computation.0.Computation.LiftRel.symm.match_1_5",
"Computation",
"And",
"And.intro",
"Exists.intro",
"Computation.instMembership",
"_private.Mathlib.Data.Seq.Computation.0.Computation.LiftRel.symm.match_1_1",
"Computation.LiftR... | true |
MeasureTheory.Measure.nullMeasurable_comp_snd | Mathlib.MeasureTheory.Measure.Prod | [
"MeasureTheory.Measure",
"MeasurableSet",
"MeasureTheory.NullMeasurableSet",
"Function.comp",
"MeasureTheory.Measure.instZero",
"MeasurableSpace",
"Iff",
"MeasureTheory.SFinite",
"forall₂_congr",
"MeasureTheory.Measure.prod",
"Set.preimage",
"MeasureTheory.Measure.nullMeasurableSet_preimage_sn... | true |
Set.inter_mul_union_subset_union | Mathlib.Algebra.Group.Pointwise.Set.Basic | [
"HMul.hMul",
"Set.image2_inter_union_subset_union",
"Mul",
"Set.instUnion",
"HasSubset.Subset",
"Set.instInter",
"Inter.inter",
"Union.union",
"Set.mul",
"Set.instHasSubset",
"instHMul",
"Set"
] | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.count_support._proof_1_9 | Mathlib.Combinatorics.SimpleGraph.Paths | [
"Lean.Grind.Nat.lt_eq",
"SimpleGraph.Walk.support",
"SimpleGraph.Walk",
"instOfNatNat",
"LE.le",
"instLENat",
"List.tail",
"SimpleGraph",
"List.findIdxs",
"Nat",
"LT.lt",
"Eq.substr",
"instLTNat",
"OfNat.ofNat",
"Decidable.decide",
"Eq",
"List.length",
"DecidableEq"
] | false |
UInt64.toUSize_ofFin | Init.Data.UInt.Lemmas | [
"UInt64.size",
"UInt64.toUSize",
"USize.ofNat",
"Fin.val",
"UInt64.ofFin",
"Fin",
"Eq",
"rfl",
"USize"
] | true |
WithZero.map'_comp | Mathlib.Algebra.GroupWithZero.WithZero | [
"MonoidWithZeroHom.ext",
"MonoidHom",
"MonoidWithZeroHom.funLike",
"WithZero.instMulZeroOneClass",
"MonoidHom.comp",
"MonoidWithZeroHom.comp",
"MulOneClass.toMulOne",
"MonoidWithZeroHom",
"WithZero",
"WithZero.map'",
"MulOneClass",
"Eq.symm",
"Eq",
"DFunLike.coe",
"WithZero.map'_map'"
] | true |
Filter.disjoint_prod | Mathlib.Order.Filter.Prod | [
"CompleteLattice.toLattice",
"SProd.sprod",
"congrArg",
"Filter.prod_inf_prod",
"Filter.instCompleteLatticeFilter",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Disjoint",
"SemilatticeInf.toPartialOrder",
"CompleteLattice.toBoundedOrder",
"_private.Mathlib.Order.Filter.Prod.0... | true |
GaloisConnection.u_eq_top | Mathlib.Order.GaloisConnection.Defs | [
"PartialOrder.toPreorder",
"GaloisConnection.le_iff_le",
"Preorder.toLE",
"PartialOrder",
"LE.le",
"OrderTop",
"Iff",
"OrderTop.toTop",
"top_le_iff",
"Iff.trans",
"Top.top",
"Eq",
"Iff.symm",
"Preorder",
"GaloisConnection"
] | true |
instDistribPNat | Mathlib.Data.PNat.Basic | [
"instMulPNat",
"instDistribPNat._proof_1",
"Distrib",
"instDistribPNat._proof_2",
"Distrib.mk",
"instAddPNat",
"PNat"
] | true |
_private.Lean.Elab.Tactic.Decide.0.Lean.Elab.Tactic.preprocessPropToDecide | Lean.Elab.Tactic.Decide | [
"Pure.pure",
"Lean.instantiateMVars",
"Lean.MessageData",
"Lean.MonadError.mk",
"Unit.unit",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Elab.Term.instAddErrorMessageContextTermElabM",
"Lean.Elab.Term.instMonadMacroAdapterTermElabM",
"Lean.instMonadMCtxOfMonadLift",
"Lean.MessageData.hint'",
"... | true |
_private.Lean.Compiler.LCNF.SpecInfo.0.Lean.Compiler.LCNF.isWeakSpecType._f | Lean.Compiler.LCNF.SpecInfo | [
"_private.Lean.Compiler.LCNF.SpecInfo.0.Lean.Compiler.LCNF.isNoSpecType.match_1",
"_private.Lean.Compiler.LCNF.SpecInfo.0.Lean.Compiler.LCNF.isNoSpecType.match_4",
"Lean.Expr",
"Lean.Level",
"Lean.Expr.forallE",
"List",
"Bool",
"Lean.Name",
"Lean.Expr.getAppFn",
"Lean.Compiler.hasWeakSpecializeAtt... | false |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.isFullyInvariant_iff_le_imp_isotypicComponent_le.match_1_5 | Mathlib.RingTheory.SimpleModule.Isotypic | [
"Submodule",
"LinearEquiv.symm",
"AddCommGroup.toAddCommMonoid",
"Submodule.addCommMonoid",
"IsIsotypicOfType._proof_1",
"Membership.mem",
"Exists",
"AddCommGroup",
"Subtype",
"Submodule.module",
"LinearMap",
"LinearMap.comp",
"Exists.casesOn",
"LinearEquiv.toLinearMap",
"Submodule.addCo... | false |
Representation.mem_invariants_iff_of_forall_mem_zpowers | Mathlib.RepresentationTheory.Invariants | [
"Int.instAddCommGroup",
"zpow_natCast",
"Eq.mpr",
"NegZeroClass.toNeg",
"Submodule",
"MonoidHom.instMonoidHomClass",
"MulOne.toOne",
"CommRing",
"Representation",
"MonoidHom.instFunLike",
"Module.End.instMonoid",
"HMul.hMul",
"Int.induction_on",
"DivInvOneMonoid.toInvOneClass",
"Monoid.t... | true |
Lean.Parser.Command.structFields.formatter | Lean.Parser.Command | [
"Lean.PrettyPrinter.Formatter",
"Lean.Parser.Command.structImplicitBinder.formatter",
"Lean.PrettyPrinter.Formatter.orelse.formatter",
"Lean.ppLine.formatter",
"Lean.Parser.withCache.formatter",
"Lean.Parser.leadingNode.formatter",
"Lean.Parser.Command.structSimpleBinder.formatter",
"instOfNatNat",
... | true |
Lean.Grind.CommRing.Poly.combine.go.eq_def | Init.Grind.Ring.CommSolver | [
"cond",
"Eq.mpr",
"Lean.Grind.CommRing.Poly.combine.go._f",
"Lean.Grind.CommRing.Poly",
"Lean.Grind.CommRing.Poly.combine.go",
"Lean.Grind.CommRing.Poly.add",
"congrArg",
"Ordering",
"Int.instDecidableEq",
"Nat.brecOn.go",
"Lean.Grind.CommRing.Mon.mul.go.match_3",
"Nat.rec",
"Nat.brecOn",
... | true |
Mathlib.Tactic.IntervalCases.Methods.bisect | Mathlib.Tactic.IntervalCases | [
"Inhabited.default",
"Subarray",
"Mathlib.Tactic.IntervalCases.Bound",
"Lean.MVarId",
"Lean.Expr",
"Lean.Meta.MetaM",
"Unit",
"Lean.Meta.instInhabitedMetaM",
"Mathlib.Tactic.IntervalCases.IntervalCasesSubgoal",
"Mathlib.Tactic.IntervalCases.Methods"
] | true |
CategoryTheory.finCategoryOpposite | Mathlib.CategoryTheory.FinCategory.Basic | [
"CategoryTheory.opEquiv",
"Opposite",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.FinCategory.fintypeHom",
"CategoryTheory.FinCategory.fintypeObj",
"Opposite.equivToOpposite",
"CategoryTheory.SmallCategory",
"Fintype.ofEquiv",
"CategoryTheory.FinCat... | true |
Mathlib.Tactic.rflTac | Mathlib.Tactic.Relation.Rfl | [
"Lean.MVarId",
"Unit",
"Lean.Elab.Tactic.withMainContext",
"Lean.MVarId.applyRfl",
"Lean.Elab.Tactic.TacticM",
"Lean.Elab.Tactic.liftMetaFinishingTactic"
] | true |
IsCompact.lt_sInf_iff_of_continuous | Mathlib.Topology.Order.Compact | [
"Preorder.toLT",
"IsCompact.sSup_lt_iff_of_continuous",
"PartialOrder.toPreorder",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"instClosedIciTopologyOrderDual",
"ConditionallyCompleteLinearOrder.toConditionallyCompleteLattice",
"ClosedIicTopology",
"TopologicalSpace",
"Iff",
"Set.Nonempty... | true |
_private.Lean.Compiler.IR.LLVMBindings.0.LLVM.Builder.mk._flat_ctor | Lean.Compiler.IR.LLVMBindings | [
"_private.Lean.Compiler.IR.LLVMBindings.0.LLVM.Builder.mk",
"LLVM.Builder",
"USize"
] | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract._proof_6 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | [
"LE.le",
"instLENat",
"Nat",
"LT.lt",
"Decidable.byContradiction",
"instDecidableEqNat",
"instLTNat",
"_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract._proof_5",
"Eq",
"Not"
] | false |
VAddAssocClass.opposite_mid | Mathlib.Algebra.Group.Action.Opposite | [
"Add.toVAddAddOpposite",
"add_vadd_comm",
"instVAddOfAdd",
"AddOpposite",
"VAdd",
"VAddAssocClass.mk",
"AddOpposite.unop",
"AddOpposite.instVAdd",
"VAddCommClass",
"Add",
"VAddAssocClass"
] | true |
znumCoe | Mathlib.Data.Num.Basic | [
"CoeHTCT.mk",
"castZNum",
"One",
"ZNum",
"Neg",
"CoeHTCT",
"Add",
"Zero"
] | true |
Vector.countP_toList | Init.Data.Vector.Lemmas | [
"List.countP",
"Vector",
"congrArg",
"Array.countP_toList",
"Vector.casesOn",
"Array",
"Vector.mk",
"Vector.countP",
"Array.countP",
"Nat",
"True",
"eq_self",
"Bool",
"of_eq_true",
"Eq.ndrec",
"Eq.refl",
"congrFun'",
"Eq.symm",
"Vector.toList",
"Eq",
"Array.size",
"Eq.trans... | true |
CStarMatrix.add_mul | Mathlib.Analysis.CStarAlgebra.CStarMatrix | [
"HMul.hMul",
"Distrib.toAdd",
"CStarMatrix.instHMulOfFintypeOfMulOfAddCommMonoid",
"CStarMatrix",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"Matrix.add_mul",
"instHAdd",
"Fintype",
"Distrib.toMul",
"HAdd.hAdd",
"NonUnitalNonAssocSemiring.toDistrib",
"CStarMatrix.instAdd",
"NonUnitalNonAss... | true |
MonoidAlgebra.instFree | Mathlib.LinearAlgebra.Finsupp.VectorSpace | [
"Module.Free.finsupp",
"MonoidAlgebra.addCommMonoid",
"Module.Free",
"NonUnitalNonAssocSemiring.toAddCommMonoid",
"NonAssocSemiring.toNonUnitalNonAssocSemiring",
"MonoidAlgebra",
"Semiring",
"Module",
"Semiring.toNonAssocSemiring",
"MonoidAlgebra.module"
] | true |
CategoryTheory.IndParallelPairPresentation | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | [
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.types",
"CategoryTheory.Category.opposite",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.IndParallelPairPresentation.mk",
"CategoryTheory.... | true |
_private.Lean.Expr.0.Lean.Expr.isLet.match_1 | Lean.Expr | [
"_private.Lean.Expr.0.Lean.Expr.isLet._sparseCasesOn_1",
"Lean.Expr.letE",
"Lean.Expr",
"Nat.hasNotBit",
"Bool",
"Lean.Name",
"Lean.Expr.ctorIdx"
] | false |
ProfiniteGrp.instHasForget₂ContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteProfiniteContinuousMap._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | [
"Continuous",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.ConcreteCategory.hom",
"ProfiniteGrp.group",
"ProfiniteGrp",
"DivInvMonoid.toMonoid",
"TotallyDisconnectedSpace",
"ContinuousMonoidHom.instContinuousMapClass",
"Group.toDivInvMonoid",
"TopCat.str",
"TopCat.ca... | false |
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.inner_le_weight_mul_Lp_of_nonneg._simp_1_4 | Mathlib.Analysis.MeanInequalities | [
"not_or",
"And",
"propext",
"Or",
"Eq",
"Not"
] | false |
CategoryTheory.Functor.WellOrderInductionData.lift | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | [
"CategoryTheory.Functor.op",
"CategoryTheory.Functor",
"CategoryTheory.Functor.WellOrderInductionData",
"Opposite",
"OrderHom.monotone",
"LinearOrder",
"PartialOrder.toPreorder",
"CategoryTheory.Functor.comp",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Set.Elem",
"DistribLattice.toLat... | true |
AList | Mathlib.Data.List.AList | [
"AList.mk"
] | true |
_private.Lean.Parser.Basic.0.Lean.Parser.strAux.parse._unsafe_rec | Lean.Parser.Basic | [
"_private.Lean.Parser.Basic.0.Lean.Parser.strAux.parse._unsafe_rec",
"bne",
"String",
"Lean.Parser.ParserContext.toParserContextCore",
"instDecidableEqBool",
"Lean.Parser.InputContext.atEnd",
"Lean.Parser.ParserState.pos",
"instBEqOfDecidableEq",
"String.Pos.Raw",
"dite",
"Lean.Parser.ParserCont... | false |
Int.toArray_rcc_ne_empty_iff | Init.Data.Range.Polymorphic.IntLemmas | [
"Std.Rcc.toArray",
"Std.Rco.toArray",
"congrArg",
"Std.PRange.instUpwardEnumerableInt",
"Int.decLe",
"Ne",
"Int",
"LE.le",
"List.toArray",
"Std.PRange.instIsAlwaysFiniteInt_1",
"Array",
"iff_self",
"Int.instLTInt",
"instHAdd",
"Int.toArray_rcc_eq_toArray_rco",
"Iff",
"instOfNat",
"... | true |
Std.Time.TimeZone.ZoneRules.mk._flat_ctor | Std.Time.Zoned.ZoneRules | [
"Std.Time.TimeZone.LocalTimeType",
"Std.Time.TimeZone.ZoneRules.mk",
"Array",
"Std.Time.TimeZone.Transition",
"Std.Time.TimeZone.ZoneRules"
] | false |
Encodable.encodeSubtype | Mathlib.Logic.Encodable.Basic | [
"Subtype",
"Encodable.encodeSubtype.match_1",
"Nat",
"Encodable.encode",
"Encodable"
] | true |
_private.Batteries.Lean.Meta.UnusedNames.0.Lean.LocalContext.getUnusedUserNameIndex.match_1 | Batteries.Lean.Meta.UnusedNames | [
"Unit.unit",
"Lean.Name.MatchUpToIndexSuffix.exactMatch",
"Unit",
"Lean.Name.MatchUpToIndexSuffix",
"Lean.Name.MatchUpToIndexSuffix.casesOn",
"Nat",
"Lean.Name.MatchUpToIndexSuffix.noMatch",
"Lean.Name.MatchUpToIndexSuffix.suffixMatch"
] | false |
List.bidirectionalRec._proof_2 | Mathlib.Data.List.Induction | [
"List.getLast",
"List.dropLast_concat_getLast",
"List.dropLast",
"List.cons",
"instHAppendOfAppend",
"List",
"List.cons_ne_nil",
"List.instAppend",
"Eq",
"HAppend.hAppend",
"List.nil"
] | false |
Topology.WithLower.toLower_lt_toLower | Mathlib.Topology.Order.LowerUpperTopology | [
"Preorder.toLT",
"Equiv.instEquivLike",
"Topology.WithLower.instPreorder",
"Iff.rfl",
"Equiv",
"Topology.WithLower",
"Iff",
"Topology.WithLower.toLower",
"LT.lt",
"DFunLike.coe",
"Preorder",
"EquivLike.toFunLike"
] | true |
Set.instDistribLattice._proof_3 | Mathlib.Data.Set.Basic | [
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"PartialOrder.toPreorder",
"Preorder.toLE",
"inferInstance",
"DistribLattice.toLattice",
"LE.le",
"Pi.instDistribLattice",
"DistribLattice",
"And",
"Iff",
"Preorder.lt_iff_le_not_ge",
"Prop.instDistribLattice",
"LT.lt",
"SemilatticeSup.toParti... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.