name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
Orientation.definition._proof_9._@.Mathlib.Analysis.InnerProductSpace.TwoDim.2341759032._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.TwoDim | [
"IsModuleTopology.toContinuousSMul",
"NormedCommRing.toSeminormedCommRing",
"Real",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"IsTopologicalRing.toIsTopologicalSemiring",
"Real.denselyNormedField",
"Real.instRCLike",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAdd... | false |
CategoryTheory.DifferentialObject.d_squared._autoParam | Mathlib.CategoryTheory.DifferentialObject | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Algebra.IsStandardSmooth.relativeDimension._proof_2 | Mathlib.RingTheory.Smooth.StandardSmooth | [
"Exists.choose_spec",
"CommRing",
"Algebra.IsStandardSmooth",
"CommSemiring.toSemiring",
"Finite",
"Algebra.IsStandardSmooth.relativeDimension._proof_1",
"Algebra",
"Exists",
"And",
"CommRing.toCommSemiring",
"Algebra.SubmersivePresentation",
"Algebra.IsStandardSmooth.out",
"Nonempty",
"Ex... | false |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.mk | Lean.Meta.Tactic.Grind.Theorems | [
"_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.mk",
"Lean.PHashMap",
"Lean.Meta.Grind.Theorems",
"Lean.PHashSet",
"Lean.Meta.Grind.instBEqOrigin",
"List",
"Lean.Meta.Grind.Origin",
"Lean.Meta.Grind.instHashableOrigin",
"Lean.Name",
"Lean.Name.instBEq",
"Lean.instHashableNam... | true |
GradedMonoid.GradeZero.commMonoid | Mathlib.Algebra.GradedMonoid | [
"instPowNat",
"MulOne.toOne",
"GradedMonoid.instNatPowOfNat",
"GradedMonoid.GradeZero.commMonoid._proof_4",
"Monoid.toMulOneClass",
"AddMonoid.toAddZeroClass",
"GradedMonoid.GCommMonoid.toGMonoid",
"AddZeroClass.toAddZero",
"MulOne.toMul",
"GradedMonoid.GCommMonoid.toCommMonoid",
"GradedMonoid.G... | true |
truncOfNonemptyFintype._proof_1 | Mathlib.Data.Fintype.Basic | [
"Finset.univ",
"congrArg",
"Finset",
"exists_const._simp_1",
"Membership.mem",
"Exists",
"Multiset",
"Finset.val",
"Multiset.instMembership",
"funext",
"Fintype",
"Finset.instSetLike",
"True",
"of_eq_true",
"Nonempty",
"Finset.mem_univ._simp_1",
"SetLike.instMembership",
"Eq.trans"... | false |
CentroidHom.instIsCentralScalar | Mathlib.Algebra.Ring.CentroidHom | [
"Monoid",
"CentroidHom.ext",
"instHSMul",
"instSMulOfMul",
"AddMonoidHomClass.toAddMonoidHom",
"DistribMulAction.toDistribSMul",
"IsScalarTower",
"AddMonoid.toAddZeroClass",
"MulOpposite",
"SMulCommClass.op_left",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"NonUnitalNonAssocSem... | true |
instPseudoMetricSpaceNNReal._proof_16 | Mathlib.Topology.MetricSpace.Pseudo.Constructions | [
"Real.instLE",
"Real",
"Real.instZero",
"PseudoMetricSpace.toUniformSpace",
"Subtype",
"NNReal",
"LE.le",
"Filter.Tendsto",
"instPseudoMetricSpaceNNReal._aux_14",
"Zero.toOfNat0",
"Real.pseudoMetricSpace",
"Prod.swap",
"Prod",
"OfNat.ofNat",
"Subtype.val",
"UniformSpace.comap._proof_2"... | false |
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.reduce_fold_fn.match_1.congr_eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | [
"Unit.unit",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment.neg",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned",
"id",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment.pos",
"heq_of_eq",
"Unit",
"Eq.ndrec",
"Std.Tactic.BVDecide.LRAT.Internal.Assignment",
"Std.Tactic.BVDecide.LRAT.Internal.... | true |
TopologicalSpace.Closeds.isClopen_singleton_bot | Mathlib.Topology.UniformSpace.Closeds | [
"Set.ext",
"UniformSpace",
"Eq.mpr",
"UniformSpace.hausdorff.isClopen_singleton_empty",
"Lattice.toSemilatticeSup",
"TopologicalSpace.Closeds.uniformSpace",
"CompleteLattice.toLattice",
"congrArg",
"HEq.refl",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
... | true |
hyperoperation_ge_four_zero | Mathlib.Data.Nat.Hyperoperation | [
"Nat.recAux",
"hyperoperation",
"_private.Mathlib.Data.Nat.Hyperoperation.0.hyperoperation_ge_four_zero._proof_1_1",
"instOfNatNat",
"Nat.instDecidablePredEven",
"instHAdd",
"HAdd.hAdd",
"Nat",
"Even",
"instAddNat",
"OfNat.ofNat",
"Eq",
"_private.Mathlib.Data.Nat.Hyperoperation.0.hyperoperat... | true |
Lean.Elab.Command.ElabHeaderResult.toPreElabHeaderResult | Lean.Elab.MutualInductive | [
"Lean.Elab.Command.PreElabHeaderResult",
"Lean.Elab.Command.ElabHeaderResult"
] | true |
_private.Init.Data.Ord.Array.0.Array.compareLex.match_1.splitter | Init.Data.Ord.Array | [
"Ordering.gt",
"Ordering",
"Ordering.eq",
"Unit",
"Ordering.lt",
"_private.Init.Data.Ord.Array.0.Array.compareLex.match_1"
] | true |
NonUnitalAlgEquivClass.mk._flat_ctor | Mathlib.Algebra.Star.StarAlgHom | [
"instHSMul",
"HMul.hMul",
"outParam",
"SMul",
"RingEquivClass.mk",
"Mul",
"id",
"instHAdd",
"EquivLike",
"HAdd.hAdd",
"NonUnitalAlgEquivClass.mk",
"HSMul.hSMul",
"NonUnitalAlgEquivClass",
"Eq",
"DFunLike.coe",
"Add",
"MulEquivClass.mk",
"EquivLike.toFunLike",
"instHMul",
"MulAc... | false |
Lean.Parser.Term.isIdent | Lean.Parser.Term | [
"Lean.Syntax",
"Lean.Syntax.isAntiquot",
"Lean.Syntax.isIdent",
"Bool",
"Bool.or"
] | true |
Set.subtypeInsertEquivOption._proof_4 | Mathlib.Data.Set.Insert | [
"Membership.mem",
"Subtype",
"Insert.insert",
"_private.Mathlib.Data.Set.Insert.0.Set.subtypeInsertEquivOption._proof_3",
"Set.instInsert",
"Subtype.val",
"Set.instMembership",
"Set"
] | false |
LowerAdjoint.idempotent | Mathlib.Order.Closure | [
"LowerAdjoint.closureOperator",
"PartialOrder.toPreorder",
"PartialOrder",
"LowerAdjoint.toFun",
"LowerAdjoint",
"Eq",
"ClosureOperator.idempotent",
"Preorder"
] | true |
ContT.monadLift_bind | Mathlib.Control.Monad.Cont | [
"congrArg",
"LawfulMonad.bind_assoc",
"MonadLiftT.monadLift",
"instMonadLiftT",
"Function.comp",
"ContT.instMonadLiftOfMonad",
"LawfulMonad",
"ContT.ext",
"ContT.run",
"ContT.instMonad",
"True",
"eq_self",
"of_eq_true",
"Monad.toBind",
"Bind.bind",
"congrFun'",
"instMonadLiftTOfMonad... | true |
HomotopicalAlgebra.leftHomotopyClassEquivRightHomotopyClass._proof_4 | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | [
"CategoryTheory.Limits.hasFiniteCoproducts_of_hasFiniteColimits",
"HomotopicalAlgebra.LeftHomotopyClass.mk",
"HomotopicalAlgebra.ModelCategory.cm1a",
"HomotopicalAlgebra.ModelCategory.cm1b",
"CategoryTheory.CategoryStruct.toQuiver",
"HomotopicalAlgebra.IsCofibrant",
"Quiver.Hom",
"HomotopicalAlgebra.L... | false |
_private.Mathlib.Topology.Connected.PathConnected.0.IsPathConnected.exists_path_through_family._simp_1_1 | Mathlib.Topology.Connected.PathConnected | [
"instOfNatNat",
"instHAdd",
"And",
"HAdd.hAdd",
"Nat",
"Fin.last",
"propext",
"instAddNat",
"Fin.castSucc",
"OfNat.ofNat",
"Fin",
"Eq",
"Fin.forall_fin_succ'"
] | false |
AddSubgroup.closure_nsmul_le | Mathlib.Algebra.Group.Subgroup.Pointwise | [
"AddSubgroup.nsmul_subset",
"AddGroup.toSubtractionMonoid",
"instHSMul",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"AddSubgroup.instPartialOrder",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"HasSubset.Subset",
"SubtractionMonoid.toSubNegZeroMonoid",
"LE.le",
"SubNegZeroMonoid.toNe... | true |
_private.Mathlib.Data.List.Defs.0.List.map₂Left'.match_1.splitter | Mathlib.Data.List.Defs | [
"List.map₂Left'.match_1",
"List.cons",
"List",
"List.nil"
] | true |
TopologicalSpace.Opens.instCompleteLattice._proof_11 | Mathlib.Topology.Sets.Opens | [
"TopologicalSpace.Opens",
"Set.instUnion",
"TopologicalSpace.Opens.instSetLike",
"TopologicalSpace.Opens.carrier",
"TopologicalSpace",
"IsOpen.union",
"SetLike.coe",
"IsOpen",
"TopologicalSpace.Opens.is_open'",
"Union.union",
"Set"
] | false |
Lean.Meta.Grind.EMatch.Context.recOn | Lean.Meta.Tactic.Grind.EMatch | [
"Lean.Meta.Grind.EMatchTheorem",
"Lean.Expr",
"Lean.Meta.Grind.EMatch.Context",
"Lean.Meta.Grind.EMatch.Context.mk",
"Lean.Meta.Grind.EMatch.Context.rec",
"Bool"
] | false |
Lean.Meta.markSmartUnfoldingMatch | Lean.Meta.WHNF | [
"Lean.Expr",
"Lean.mkAnnotation",
"Lean.Name.mkStr1"
] | true |
Lean.Data.AC.instBEqExpr | Init.Data.AC | [
"Lean.Data.AC.instBEqExpr.beq",
"BEq.mk",
"Lean.Data.AC.Expr",
"BEq"
] | true |
CategoryTheory.Abelian.FunctorCategory.imageObjIso._proof_5 | Mathlib.CategoryTheory.Abelian.FunctorCategory | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Functor.category",
"CategoryTheory.Abelian",
"CategoryTheory.Limits.HasCokernels.has_colimit",
"CategoryTheory.Limits.HasCokernel",
"CategoryTheory.Abelian.has_co... | false |
Lean.Meta.Simp.Simprocs.noConfusion | Lean.Meta.Tactic.Simp.Types | [
"Lean.PHashSet",
"Lean.Meta.Simp.SimprocTree",
"Lean.Meta.Simp.Simprocs",
"Eq.ndrec",
"Lean.Name",
"Eq.refl",
"Lean.Meta.Simp.Simprocs.noConfusionType",
"Eq",
"Lean.Name.instBEq",
"Lean.Meta.Simp.Simprocs.casesOn",
"Lean.instHashableName"
] | false |
RingHom.isIntegral_ofLocalizationSpan | Mathlib.RingTheory.RingHom.Integral | [
"Iff.mpr",
"Submodule.mem_of_span_eq_top_of_smul_pow_mem",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Submodule",
"RingHom.instRingHomClass",
"Polynomial.instOne",
"Submodule.addSubmonoidClass",
"Nat.instOrderedSub",
"Semigroup.toMul",
"CommRing",
... | true |
MultilinearMap.instAdd._proof_1 | Mathlib.LinearAlgebra.Multilinear.Basic | [
"MultilinearMap.map_update_add",
"Function.update",
"AddMonoid.toAddSemigroup",
"add_left_comm",
"congrArg",
"add_assoc",
"MultilinearMap",
"AddCommMonoid",
"instHAdd",
"AddSemigroup.toAdd",
"HAdd.hAdd",
"MultilinearMap.instFunLikeForall",
"congr",
"True",
"eq_self",
"of_eq_true",
"S... | false |
_private.Lean.Environment.0.Lean.Environment.RealizeConstKey.noConfusionType | Lean.Environment | [
"_private.Lean.Environment.0.Lean.Environment.RealizeConstKey",
"_private.Lean.Environment.0.Lean.Environment.RealizeConstKey.casesOn",
"Lean.Name",
"Eq"
] | false |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.initFn._@.Lean.Linter.UnusedVariables.2270162977._hygCtx._hyg.2 | Lean.Linter.UnusedVariables | [
"Lean.Linter.LinterOptions",
"IO",
"Option.some",
"Lean.Syntax",
"Lean.Syntax.Stack.matches",
"List.cons",
"Unit",
"Lean.Linter.addBuiltinUnusedVariablesIgnoreFn",
"Lean.Name",
"Lean.Syntax.Stack",
"Lean.SyntaxNodeKind",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"List.nil",
"Option"
] | false |
CategoryTheory.Quotient.linear_functor | Mathlib.CategoryTheory.Quotient.Linear | [
"instHSMul",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Quotient",
"Quiver.Hom",
"CategoryTheory.Functor.Linear",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"CategoryTheory.Quotient.category",
"CategoryTheory.Functor.Additive",
"AddMonoid.toAddZeroClass",
"C... | true |
CategoryTheory.yonedaAddMon_map_app | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | [
"CategoryTheory.Functor",
"CategoryTheory.yonedaAddMonObj",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Hom.addMonoid",
"CategoryTheory.Functor.category",
"AddMonCat.ofHom",
"CategoryTheory.AddMon.instCategory",
"CategoryTheory.yonedaAddMon._proof_1",
"Cat... | true |
_private.Mathlib.Combinatorics.Hall.Finite.0.HallMarriageTheorem.hall_hard_inductive_step_B._proof_1_6 | Mathlib.Combinatorics.Hall.Finite | [
"Lean.Grind.eq_false_of_not_eq_true",
"of_eq_false",
"False",
"forall_not_of_not_exists",
"Lean.Grind.not_not",
"Lean.Grind.nestedProof",
"Lean.Grind.not_and",
"Lean.Grind.iff_eq",
"_private.Mathlib.Combinatorics.Hall.Finite.0.HallMarriageTheorem.hall_hard_inductive_step_B._proof_1_3",
"congrArg",... | false |
Qq.Impl.MVarSynth.type.elim | Qq.Macro | [
"PULift.up",
"Qq.Impl.MVarSynth.type",
"Lean.MVarId",
"Qq.Impl.MVarSynth.ctorElim",
"Nat",
"Qq.Impl.MVarSynth.ctorIdx",
"Eq.symm",
"Eq",
"Qq.Impl.MVarSynth"
] | false |
MulAut.applyMulAction._proof_2 | Mathlib.Algebra.Group.Action.End | [
"Monoid",
"MulOne.toOne",
"instHSMul",
"MulEquiv.instEquivLike",
"Monoid.toMulOneClass",
"MulAut.instGroup",
"MulAut",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
"SMul.mk",
"Group.toDivInvMonoid",
"MulOneClass.toMulOne",
"One.toOfNat1",
"MulEquiv",
"HSMul.hSMul",
"OfNat.ofNat",
"Eq",
... | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopLayer.go.eq_def | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | [
"Std.Sat.AIG.Decl",
"instHDiv",
"HMul.hMul",
"Std.Tactic.BVDecide.BVExpr.bitblast.ExtractTarget.mk",
"Std.Sat.AIG.RefVecEntry.vec",
"Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopLayer.go",
"HSub.hSub",
"Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopLayer.go._unary.eq_def",
"Eq.rec",
"id",
"HDiv.h... | true |
_private.Mathlib.Data.Set.Sigma.0.Set.empty_sigma._proof_1_1 | Mathlib.Data.Set.Sigma | [
"Set.ext",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"eq_false",
"Lean.Grind.iff_eq",
"congrArg",
"Classical.byContradiction",
"Membership.mem",
"Exists",
"Set.mem_sigma_iff",
"Eq.mp",
"id",
"Lean.Grind.forall_imp_eq_or",
"Sigma.fst",
"Lean.Grind.not_eq_of_eq_false",
"funext",
"... | false |
FractionalIdeal.eq_spanSingleton_mul | Mathlib.RingTheory.FractionalIdeal.Operations | [
"CommRing",
"FractionalIdeal.spanSingleton",
"HMul.hMul",
"IsLocalization",
"congrArg",
"CommSemiring.toSemiring",
"_private.Mathlib.RingTheory.FractionalIdeal.Operations.0.FractionalIdeal.eq_spanSingleton_mul._simp_1_2",
"PartialOrder.toPreorder",
"Algebra",
"Preorder.toLE",
"Membership.mem",
... | true |
Mathlib.Tactic.BicategoryLike.NormalExpr.leftUnitorInvM | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | [
"Mathlib.Tactic.BicategoryLike.NormalExpr",
"Mathlib.Tactic.BicategoryLike.Mor₂Iso",
"Mathlib.Tactic.BicategoryLike.Mor₂Iso.structuralAtom",
"Mathlib.Tactic.BicategoryLike.MonadNormalExpr",
"Mathlib.Tactic.BicategoryLike.StructuralAtom",
"Mathlib.Tactic.BicategoryLike.Mor₁",
"Mathlib.Tactic.BicategoryLi... | true |
AList.insert_singleton_eq | Mathlib.Data.List.AList | [
"congrArg",
"AList.insert",
"List.kerase_cons_eq",
"List.kerase",
"AList.singleton",
"List.cons",
"List",
"AList.ext",
"AList",
"True",
"eq_self",
"of_eq_true",
"congrFun'",
"Sigma.mk",
"Eq",
"Sigma",
"Eq.trans",
"List.nil",
"DecidableEq",
"AList.entries"
] | true |
RootPairing.Base.cartanMatrix_apply_eq_zero_iff_pairing | Mathlib.LinearAlgebra.RootSystem.CartanMatrix | [
"Eq.mpr",
"RootPairing.Base.cartanMatrixIn_def",
"RingHom.instRingHomClass",
"RootPairing.pairing",
"CommRing",
"Algebra.algebraMap",
"RootPairing.Base.cartanMatrixIn",
"congrArg",
"CommSemiring.toSemiring",
"RootPairing.Base",
"AddCommGroup.toAddCommMonoid",
"Matrix",
"Finset",
"Iff.rfl",... | true |
DividedPowers.SubDPIdeal.instCompleteLattice._simp_5 | Mathlib.RingTheory.DividedPowers.SubDPIdeal | [
"LE.le",
"OrderTop",
"LE",
"OrderTop.toTop",
"le_top",
"True",
"eq_true",
"Top.top",
"Eq"
] | false |
ApplicativeTransformation.instCoeFunForallForall | Mathlib.Control.Traversable.Basic | [
"ApplicativeTransformation",
"CoeFun.mk",
"Applicative",
"ApplicativeTransformation.app",
"CoeFun"
] | true |
CategoryTheory.Limits.WalkingPair.ctorElim | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | [
"CategoryTheory.Limits.WalkingPair.ctorElimType",
"CategoryTheory.Limits.WalkingPair.right",
"CategoryTheory.Limits.WalkingPair",
"Nat",
"Eq.ndrec",
"CategoryTheory.Limits.WalkingPair.casesOn",
"PULift.down",
"CategoryTheory.Limits.WalkingPair.left",
"Eq",
"CategoryTheory.Limits.WalkingPair.ctorId... | false |
Concept.isUpperSet_intent_le | Mathlib.Order.Concept | [
"IsUpperSet",
"Preorder.toLE",
"Concept.intent",
"LE.le",
"instIsTransLe",
"Concept",
"Concept.mem_intent_of_intent_rel",
"Preorder"
] | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndHyp._sizeOf_1 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten | [
"Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndHyp.rec",
"Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndHyp",
"Lean.FVarId._sizeOf_inst",
"Lean.FVarId",
"instOfNatNat",
"Lean.Meta.Hypothesis",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"OfNat.ofNat",
"Lean.Meta.Hypoth... | false |
_private.Mathlib.Logic.Basic.0.exists_exists_eq_and.match_1_3 | Mathlib.Logic.Basic | [
"Exists",
"Exists.casesOn",
"Exists.intro"
] | false |
TestFunction.instModuleOfSMulCommClassRealOfContinuousConstSMul | Mathlib.Analysis.Distribution.TestFunction | [
"Real",
"NormedSpace",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"TestFunction.instModuleOfSMulCommClassRealOfContinuousConstSMul._proof_6",
"NormedSpace.toModule",
"AddMonoid.toAddZeroClass",
"PseudoMetricSpace.toUniformSpace",
"TopologicalSpace.Opens",
"Module.mk",
"Add... | true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.elabTranslationAttr.match_9 | Mathlib.Tactic.Translate.Core | [
"Lean.TSyntax",
"Lean.NameMap",
"MProd.casesOn",
"MProd.mk",
"List.cons",
"Array",
"List",
"Nat",
"Mathlib.Tactic.Translate.RelevantArg",
"Lean.Name",
"MProd",
"Lean.SyntaxNodeKind",
"Mathlib.Tactic.Translate.ArgReorder",
"Lean.Name.mkStr4",
"List.nil",
"Option"
] | false |
ProbabilityTheory.aestronglyMeasurable_integral_condDistrib | Mathlib.Probability.Kernel.CondDistrib | [
"MeasureTheory.AEStronglyMeasurable.integral_condDistrib_map",
"StandardBorelSpace",
"Real",
"MeasureTheory.Measure",
"MeasurableSpace.comap",
"NormedSpace",
"AEMeasurable",
"PseudoMetricSpace.toUniformSpace",
"ProbabilityTheory.Kernel.instFunLike",
"ProbabilityTheory.condDistrib",
"Prod.mk",
... | true |
CategoryTheory.MorphismProperty.MapFactorizationData.op._proof_1 | Mathlib.CategoryTheory.MorphismProperty.Factorization | [
"CategoryTheory.MorphismProperty",
"CategoryTheory.MorphismProperty.MapFactorizationData.Z",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"Quiver.Hom.op",
"CategoryTheory.MorphismProperty.MapFactorizationData.p",
"Quiver.Hom.unop",
"CategoryTheory.MorphismPropert... | false |
LinearIsometryEquiv.withLpProdAssoc._proof_2 | Mathlib.Analysis.Normed.Lp.ProdLp | [
"WithLp",
"instHSMul",
"SeminormedAddCommGroup",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"AddMonoid.toAddZeroClass",
"IsometryEquiv.toEquiv",
"WithLp.instProdPseudoEMetricSpace",
"IsometryEquiv.withLpProdAssoc",
"WithLp.instAddCommGroup",
"Fact",
"AddZeroClass.toAddZe... | false |
instDecidableEqAdditive | Mathlib.Algebra.Group.TypeTags.Basic | [
"Additive",
"DecidableEq"
] | true |
MeasureTheory.Lp.simpleFunc.stronglyMeasurable | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | [
"MeasureTheory.Measure",
"MeasureTheory.Lp.simpleFunc.toSimpleFunc",
"PseudoMetricSpace.toUniformSpace",
"AddCommGroup.toAddGroup",
"AddSubgroup.toAddGroup",
"MeasureTheory.SimpleFunc",
"Membership.mem",
"Subtype",
"MeasureTheory.Lp",
"MeasureTheory.AEEqFun",
"MeasureTheory.SimpleFunc.instFunLik... | true |
UniformSpace.Completion.ring._proof_5 | Mathlib.Topology.Algebra.UniformRing | [
"Continuous.comp'",
"UniformSpace",
"Continuous",
"HMul.hMul",
"UniformSpace.Completion.mul",
"Ring.toNonAssocRing",
"AddGroupWithOne.toAddGroup",
"Continuous.snd",
"continuous_mul",
"continuous_id'",
"instTopologicalSpaceProd",
"Mul",
"UniformSpace.Completion.instContinuousMul",
"inferIns... | false |
Fin.castSucc_lt_or_lt_succ | Mathlib.Data.Fin.SuccPred | [
"Eq.mpr",
"_private.Mathlib.Data.Fin.SuccPred.0.Fin.castSucc_lt_or_lt_succ._simp_1_1",
"Fin.succ",
"congrArg",
"id",
"instOfNatNat",
"Fin.val",
"_private.Mathlib.Data.Fin.SuccPred.0.Fin.castSucc_lt_or_lt_succ._proof_1_2",
"instHAdd",
"HAdd.hAdd",
"Nat",
"congr",
"LT.lt",
"instLTFin",
"in... | true |
CategoryTheory.ShortComplex.instSubHom._proof_4 | Mathlib.Algebra.Homology.ShortComplex.Preadditive | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ShortComplex",
"HSub.hSub",
"AddCommGroup.toAddGroup",
"CategoryTheory.ShortComplex.instCategory",
"CategoryTheory.ShortComplex.Hom.τ₂",
"CategoryTheory.Preadditive",
"SubNegMonoid.toSub",
"instHSub",
"AddGroup... | false |
String.Slice.Pos.instLawfulOrderLT | Init.Data.String.OrderInstances | [
"_private.Init.Data.String.OrderInstances.0.String.Pos.Raw.instLTCiOfNatInt._simp_1",
"Eq.mpr",
"String.instLTRaw",
"String.instLEPos_1",
"congrArg",
"String.Slice.Pos.offset",
"_private.Init.Data.String.OrderInstances.0.String.Pos.Raw.instTotalLe._simp_4",
"String.Slice",
"iff_and_self._simp_1",
... | true |
Lean.Elab.Tactic.Do.Fuel.casesOn | Lean.Elab.Tactic.Do.VCGen.Basic | [
"Lean.Elab.Tactic.Do.Fuel",
"Lean.Elab.Tactic.Do.Fuel.limited",
"Lean.Elab.Tactic.Do.Fuel.rec",
"Nat",
"Lean.Elab.Tactic.Do.Fuel.unlimited"
] | false |
instRingCliffordAlgebra._proof_15 | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | [
"RingQuot.instMonoidWithZero._proof_1",
"CommRing",
"CliffordAlgebra.Rel",
"HMul.hMul",
"CommSemiring.toSemiring",
"AddCommGroup.toAddCommMonoid",
"CliffordAlgebra",
"QuadraticForm",
"AddCommGroup",
"TensorAlgebra",
"instRingCliffordAlgebra._aux_13",
"TensorAlgebra.instRing",
"CommRing.toCom... | false |
Submodule.reflection_orthogonal_apply | Mathlib.Analysis.InnerProductSpace.Projection.Reflection | [
"LinearIsometryEquiv.instEquivLike",
"Eq.mpr",
"InnerProductSpace.toNormedSpace",
"NegZeroClass.toNeg",
"Submodule",
"instHSMul",
"neg_sub",
"Submodule.starProjection",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"ContinuousLinearMap.funLike",
"NormedSpace.toModule",
"HSub.hSub",
"AddMonoi... | true |
CategoryTheory.PreOneHypercover.sigmaOfIsColimit_Y | Mathlib.CategoryTheory.Sites.Hypercover.One | [
"CategoryTheory.Limits.Cofan",
"CategoryTheory.PreOneHypercover",
"CategoryTheory.PreOneHypercover.toPreZeroHypercover",
"CategoryTheory.PreZeroHypercover.sigmaOfIsColimit",
"CategoryTheory.Discrete.functor",
"CategoryTheory.Limits.IsColimit",
"CategoryTheory.PreZeroHypercover.X",
"CategoryTheory.PreO... | true |
ZFSet.image.mk | Mathlib.SetTheory.ZFC.Basic | [
"ZFSet.Definable₁.out_equiv",
"Eq.mpr",
"congrArg",
"ZFSet",
"PSet.Func",
"Membership.mem",
"id",
"ZFSet.Definable₁",
"ZFSet.mk",
"ZFSet.Definable₁.out",
"PSet.mk",
"_private.Mathlib.SetTheory.ZFC.Basic.0.ZFSet.image.mk.match_1_3",
"Quotient.mk",
"PSet",
"PSet.setoid",
"Quotient.induct... | true |
Lean.Meta.Simp.ConfigCtx.memoize._inherited_default | Init.MetaTypes | [
"id",
"Bool.true",
"Bool"
] | false |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.exists_kerSquareLift_comp_eq_id | Mathlib.RingTheory.Smooth.NoetherianDescent | [
"Algebra.Presentation.relationOfHasCoeffs",
"Subalgebra.instSetLike",
"Iff.mpr",
"Finsupp.instAddZeroClass",
"Eq.mpr",
"_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.algebra₁",
"_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.exists_ker... | true |
Mathlib.Tactic.ExtendDocs.commandExtend_docs__Before__After_ | Mathlib.Tactic.ExtendDoc | [
"Lean.ParserDescr.nonReservedSymbol",
"instOfNatNat",
"Lean.ParserDescr.binary",
"Lean.ParserDescr",
"Lean.ParserDescr.unary",
"Lean.ParserDescr.node",
"Nat",
"Lean.ParserDescr.symbol",
"Lean.ParserDescr.const",
"OfNat.ofNat",
"Bool.false",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4"
] | true |
_private.Mathlib.Data.Finset.Image.0.Finset.image_singleton._proof_1_1 | Mathlib.Data.Finset.Image | [
"Lean.Grind.of_eq_eq_true",
"Lean.Grind.eq_false_of_not_eq_true",
"Finset.mem_singleton",
"of_eq_false",
"False",
"forall_not_of_not_exists",
"Lean.Grind.not_not",
"Lean.Grind.not_and",
"eq_false",
"Lean.Grind.iff_eq",
"Finset.mem_image",
"congrArg",
"HEq.refl",
"Finset",
"Classical.byCo... | false |
Std.Time.Hour.instDecidableLtOrdinal._aux_1 | Std.Time.Time.Unit.Hour | [
"HSub.hSub",
"Decidable",
"Int",
"LE.le",
"Int.decNonneg",
"instHAdd",
"And",
"instHSub",
"instOfNat",
"HAdd.hAdd",
"LT.lt",
"Int.instAdd",
"Int.instSub",
"OfNat.ofNat",
"Subtype.val",
"Std.Time.Hour.instLTOrdinal",
"Std.Time.Hour.Ordinal",
"Int.instLEInt"
] | false |
ENNReal.exists_inv_nat_lt | Mathlib.Data.ENNReal.Inv | [
"Iff.mpr",
"Preorder.toLT",
"congrArg",
"ENNReal.exists_nat_gt",
"InvolutiveInv.toInv",
"PartialOrder.toPreorder",
"ENNReal.inv_ne_top",
"Exists",
"Eq.rec",
"AddMonoidWithOne.toNatCast",
"Ne",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"ENNReal.inv_lt_inv._simp_1",
"Nat.cast",
"funext",
... | true |
instCommCStarAlgebraForall._proof_5 | Mathlib.Analysis.CStarAlgebra.Classes | [
"Semigroup.toMul",
"NormedRing.toRing",
"HMul.hMul",
"AddMonoid.toZero",
"CStarAlgebra.toNormedRing",
"Semiring.zero_mul",
"CommCStarAlgebra",
"Fintype",
"Semiring.toMonoid",
"Monoid.toSemigroup",
"Zero.toOfNat0",
"AddCommMonoid.toAddMonoid",
"instCStarAlgebraForall",
"OfNat.ofNat",
"Rin... | false |
CategoryTheory.Cokleisli.Hom.noConfusion | Mathlib.CategoryTheory.Monad.Kleisli | [
"CategoryTheory.Comonad",
"CategoryTheory.Cokleisli.Hom.casesOn",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"HEq.refl",
"CategoryTheory.Cokleisli.Hom.noConfusionType",
"CategoryTheory.Comonad.toFunctor",
"eq_of_heq",
"Eq.ndrec",
"HEq",
"CategoryTheory.Category.toCategoryStruct",
... | false |
Algebra.Extension.self_σ | Mathlib.RingTheory.Extension.Basic | [
"CommRing",
"CommSemiring.toSemiring",
"Algebra",
"id",
"CommRing.toCommSemiring",
"Algebra.Extension.self",
"Eq.refl",
"Eq",
"Algebra.Extension.σ"
] | true |
Valuation.RankOne.rec | Mathlib.RingTheory.Valuation.RankOne | [
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"Valuation.RankOne.mk",
"Valuation.RankOne",
"LinearOrderedCommGroupWithZero",
"Valuation.IsNontrivial",
"Valuation.RankLeOne",
"Ring",
"Valuation"
] | false |
ProbabilityTheory.Kernel.iIndepFun.indepFun_sub_left | Mathlib.Probability.Independence.Kernel.IndepFun | [
"MeasureTheory.Measure",
"congrArg",
"measurable_id",
"CompTriple.instId_comp",
"Measurable",
"HSub.hSub",
"CompTriple.instIsIdId",
"Measurable.sub",
"MeasurableSub₂",
"Function.comp",
"Eq.mp",
"id",
"Prod.mk",
"Ne",
"ProbabilityTheory.Kernel.IndepFun.comp",
"autoParam",
"Probability... | true |
Eq.propIntro | Init.Core | [
"Iff.intro",
"propext",
"Eq"
] | true |
_private.Mathlib.CategoryTheory.Galois.EssSurj.0.CategoryTheory.PreGaloisCategory.coconeQuotientDiagIsColimit | Mathlib.CategoryTheory.Galois.EssSurj | [
"CategoryTheory.GaloisCategory.toPreGaloisCategory",
"CategoryTheory.Functor",
"OpenSubgroup",
"CategoryTheory.PreGaloisCategory.instContinuousMulAutFunctorFintypeCat",
"Subgroup.subgroupOf",
"Monoid.toMulOneClass",
"Finite",
"FintypeCat",
"_private.Mathlib.CategoryTheory.Galois.EssSurj.0.CategoryTh... | true |
Int.lcm_one_left | Init.Data.Int.Gcd | [
"Int.lcm",
"congrArg",
"Int",
"Int.one_lcm",
"instOfNat",
"Nat",
"True",
"Int.natAbs",
"eq_self",
"of_eq_true",
"congrFun'",
"OfNat.ofNat",
"Eq",
"Eq.trans"
] | true |
Finset.inf_one | Mathlib.Algebra.Group.Pointwise.Finset.Basic | [
"One",
"Finset",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"OrderTop",
"SemilatticeInf",
"One.toOfNat1",
"Finset.inf_singleton",
"Finset.inf",
"OfNat.ofNat",
"Eq",
"Finset.one"
] | true |
CategoryTheory.WithTerminal.noConfusion | Mathlib.CategoryTheory.WithTerminal.Basic | [
"HEq.refl",
"CategoryTheory.WithTerminal",
"eq_of_heq",
"Eq.ndrec",
"HEq",
"CategoryTheory.WithTerminal.casesOn",
"CategoryTheory.WithTerminal.noConfusionType",
"Eq"
] | false |
Nat.mul_add_mod_of_lt | Init.Data.Nat.Lemmas | [
"Eq.mpr",
"HMul.hMul",
"Nat.mul_add_mod'",
"congrArg",
"id",
"Nat.instMod",
"instHMod",
"instMulNat",
"Nat.mod_eq_of_lt",
"instHAdd",
"HMod.hMod",
"HAdd.hAdd",
"Nat",
"LT.lt",
"instAddNat",
"Eq.refl",
"instLTNat",
"Eq",
"instHMul"
] | true |
regularSpace_induced | Mathlib.Topology.Separation.Regular | [
"RegularSpace",
"TopologicalSpace",
"TopologicalSpace.induced",
"Topology.IsInducing.regularSpace",
"Topology.IsInducing.induced"
] | true |
IntermediateField.coe_inf | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | [
"IntermediateField",
"Algebra",
"CompleteLattice.toConditionallyCompleteLattice",
"SemilatticeInf.toMin",
"Set.instInter",
"Field.toSemifield",
"Inter.inter",
"Semifield.toDivisionSemiring",
"SetLike.coe",
"DivisionSemiring.toSemiring",
"IntermediateField.instSetLike",
"Semifield.toCommSemirin... | true |
Batteries.UFNode._sizeOf_1 | Batteries.Data.UnionFind.Basic | [
"Batteries.UFNode",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"instSizeOfNat",
"Batteries.UFNode.rec",
"OfNat.ofNat"
] | false |
OptionT.orElse.match_1 | Init.Control.Option | [
"Option.casesOn",
"Option.some",
"Option.none",
"Option"
] | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_415 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
AhlswedeZhang.infSum_eq_one | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | [
"Rat.addCommMonoid",
"Rat.instOfNat",
"Eq.mpr",
"Rat.instMul",
"HMul.hMul",
"Finset.univ",
"Finset.mem_compls._simp_1",
"congrArg",
"add_sub_cancel_left",
"Compl.compl",
"eq_sub_of_add_eq",
"Finset",
"AddMonoid.toAddZeroClass",
"Rat",
"HSub.hSub",
"Finset.compls",
"AddCommGroup.toAdd... | true |
ContinuousMap.HomotopyEquiv.refl_apply | Mathlib.Topology.Homotopy.Equiv | [
"ContinuousMap",
"TopologicalSpace",
"ContinuousMap.HomotopyEquiv.refl",
"ContinuousMap.HomotopyEquiv.toFun",
"Eq.refl",
"Eq",
"ContinuousMap.instFunLike",
"DFunLike.coe"
] | true |
Polynomial.IsSplittingField.instIsTorsionFreeSplittingField | Mathlib.FieldTheory.SplittingField.Construction | [
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"instIsTorsionFreeOfIsDomainOfNoZeroSMulDivisors",
"AddCommGroup.toAddCommMonoid",
"Module.IsTorsionFree",
"Polynomial.SplittingField",
"DivisionSemiring.toGroupWithZero",
"Field.toDivisionRing",
"inferInstance",
"Alg... | true |
CommRingCat.adj._proof_3 | Mathlib.Algebra.Category.Ring.Adjunctions | [
"Finsupp.instAddZeroClass",
"Nat.instMulZeroClass",
"CommRingCat.Hom.hom",
"Equiv.instEquivLike",
"CommRingCat.carrier",
"MvPolynomial.homEquiv",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"AddMonoidAlgebra.commRing",
"congrArg",
"CommSemiring.toSemiring",
"CategoryTheory.Concrete... | false |
Std.DTreeMap.Internal.Impl.erase.induct | Std.Data.DTreeMap.Internal.Model | [
"Std.DTreeMap.Internal.Impl.minView._proof_9",
"Ordering.gt",
"Eq.mpr",
"Ord",
"Std.DTreeMap.Internal.Impl.minView._proof_11",
"HSub.hSub",
"Std.DTreeMap.Internal.Impl.Balanced",
"Std.DTreeMap.Internal.Impl.erase",
"Ordering",
"Ordering.eq",
"Std.DTreeMap.Internal.Impl.size",
"Std.DTreeMap.Int... | true |
Filter.EventuallyConst.mulIndicator_const_iff | Mathlib.Order.Filter.EventuallyConst | [
"False",
"One",
"eq_false",
"congrArg",
"true_or",
"Set.mulIndicator",
"Filter.EventuallyConst",
"Ne",
"false_or",
"Filter.EventuallyConst.const._simp_1",
"Or.casesOn",
"iff_self",
"Iff",
"congr",
"True",
"eq_self",
"of_eq_true",
"Eq.ndrec",
"One.toOfNat1",
"_private.Mathlib.Or... | true |
CategoryTheory.ChosenPullbacksAlong.lift_snd_assoc | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | [
"CategoryTheory.Category.assoc",
"CategoryTheory.ChosenPullbacksAlong",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ChosenPullbacksAlong.lift_snd",
"CategoryTheory.ChosenPullbacksAlong.snd",
"Eq.mp",
"id",
"Mathlib.Tactic.Reassoc.eq_whisker'",
"CategoryThe... | true |
Turing.TM2to1.addBottom.eq_1 | Mathlib.Computability.TuringMachine.StackTuringMachine | [
"Turing.TM2to1.addBottom",
"Turing.TM2to1.Γ'",
"Prod.mk",
"Turing.TM2to1.Γ'.inhabited",
"Pi.instInhabited",
"Turing.ListBlank.tail",
"Bool.true",
"instInhabitedOption",
"Turing.TM2to1.addBottom._proof_1",
"Turing.PointedMap.mk",
"Turing.ListBlank.cons",
"Turing.ListBlank",
"Bool",
"Eq.refl... | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.mkAddNat | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | [
"Lean.mkAppN",
"Lean.Expr",
"Lean.Level",
"List.toArray",
"Lean.mkConst",
"List.cons",
"Lean.Level.zero",
"Lean.Name.mkStr2",
"Lean.Name.mkStr1",
"List.nil"
] | true |
RestrictScalars.module | Mathlib.Algebra.Algebra.RestrictScalars | [
"CommSemiring.toSemiring",
"Algebra",
"AddCommMonoid",
"CommSemiring",
"RestrictScalars",
"Module.restrictScalars",
"Semiring",
"instAddCommMonoidRestrictScalars",
"Module"
] | true |
_private.Mathlib.CategoryTheory.Monoidal.Comon_.0.CategoryTheory.Comon.Hom.ext.match_1 | Mathlib.CategoryTheory.Monoidal.Comon_ | [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.IsComonHom",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Comon.Hom",
"CategoryTheory.Comon.Hom.casesOn",
"CategoryTheory.Category.toCategoryStruct",
"CategoryTheory.Comon.Hom.mk",
"CategoryTheory.Comon.comon",
"Category... | false |
Std.DHashMap.Raw.Const.getKey!_unitOfList_of_contains_eq_false | Std.Data.DHashMap.RawLemmas | [
"Eq.mpr",
"Inhabited.default",
"congrArg",
"instForInOfForIn'",
"List.contains",
"Std.DHashMap.Raw",
"inferInstance",
"Std.DHashMap.Raw.getKey!",
"id",
"Std.DHashMap.Raw.Const.unitOfList",
"instOfNatNat",
"Std.DHashMap.Raw.WF.size_buckets_pos",
"Std.DHashMap.Internal.Raw.Const.unitOfList_eq"... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.le_maxKey_of_contains._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | [
"Ord",
"Ordering",
"Ordering.eq",
"Ord.compare",
"Bool.true",
"BEq.beq",
"propext",
"Bool",
"Std.LawfulBEqOrd",
"BEq",
"Eq",
"Std.LawfulBEqOrd.compare_eq_iff_beq"
] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.