name stringlengths 2 347 | module stringlengths 6 90 | deps listlengths 0 692 | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Compiler.LCNF.LiveVars.0.Lean.Compiler.LCNF.State.rec | Lean.Compiler.LCNF.LiveVars | [
"_private.Lean.Compiler.LCNF.LiveVars.0.Lean.Compiler.LCNF.State",
"Lean.FVarIdHashSet",
"_private.Lean.Compiler.LCNF.LiveVars.0.Lean.Compiler.LCNF.State.mk"
] | false |
Complex.norm_log_one_add_sub_self_le | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | [
"CharP.cast_eq_zero",
"one_pow",
"Norm.norm",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"Complex.log",
"MulOne.toOne",
"Mathlib.Meta.NormNum.isNat_add",
"Real.instLE",
"Real",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"even_two._simp_1",
"Mathlib.Meta.No... | true |
AddCommute.addUnits_neg_right | Mathlib.Algebra.Group.Commute.Units | [
"AddUnits.val",
"AddSemiconjBy.addUnits_neg_right",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"AddCommute",
"AddMonoid",
"AddZero.toAdd",
"AddUnits.instNeg",
"Neg.neg",
"AddUnits"
] | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Cell.Const.alter.match_1.eq_2 | Std.Data.DTreeMap.Internal.WF.Lemmas | [
"Std.DTreeMap.Internal.Cell.Const.alter.match_1",
"Option.some",
"Option.none",
"Unit",
"Eq.refl",
"Sigma.mk",
"Eq",
"Sigma",
"Option"
] | true |
_private.Mathlib.Tactic.Linter.UnusedTactic.0.Mathlib.Linter.UnusedTactic.eraseUsedTactics | Mathlib.Tactic.Linter.UnusedTactic | [
"Lean.Syntax.Range",
"Inhabited.default",
"_private.Mathlib.Tactic.Linter.UnusedTactic.0.Mathlib.Linter.UnusedTactic.M",
"instInhabitedOfMonad",
"Std.HashSet",
"IO",
"instInhabitedPUnit",
"Lean.Elab.InfoTree",
"Lean.Syntax",
"IO.RealWorld",
"Std.HashMap",
"instMonadEIO",
"Lean.Syntax.instHas... | true |
Bornology.IsBounded.snd_of_prod | Mathlib.Topology.Bornology.Constructions | [
"Set.instSProd",
"SProd.sprod",
"Bornology.IsBounded.image_snd",
"Eq.rec",
"Bornology.IsBounded",
"Set.Nonempty",
"Prod.instBornology",
"Set.image",
"Set.snd_image_prod",
"Prod",
"Eq",
"Prod.snd",
"Bornology",
"Set"
] | true |
continuous_sigmaMk | Mathlib.Topology.Constructions | [
"Continuous",
"instTopologicalSpaceSigma",
"TopologicalSpace.coinduced",
"TopologicalSpace",
"continuous_iSup_rng",
"Sigma.mk",
"Sigma",
"continuous_coinduced_rng"
] | true |
PadicInt.toZMod._proof_2 | Mathlib.NumberTheory.Padics.RingHoms | [
"NormedCommRing.toNormedRing",
"Eq.mpr",
"Nat.Prime",
"Semiring.toModule",
"NormedRing.toRing",
"ZMod.commRing",
"PadicInt",
"AddGroupWithOne.toAddGroup",
"congrArg",
"CommSemiring.toSemiring",
"PadicInt.maximalIdeal_eq_span_p",
"PadicInt.instIsLocalRing",
"AddGroupWithOne.toAddMonoidWithOne... | false |
Lean.Elab.Tactic.evalDone._regBuiltin.Lean.Elab.Tactic.evalDone.declRange_3 | Lean.Elab.Tactic.BuiltinTactic | [
"Lean.addBuiltinDeclarationRanges",
"Lean.DeclarationRange.mk",
"IO",
"instOfNatNat",
"Unit",
"Lean.Position.mk",
"Nat",
"OfNat.ofNat",
"Lean.DeclarationRanges.mk",
"Lean.Name.mkStr4"
] | false |
_private.Mathlib.RingTheory.Algebraic.Defs.0.Algebra.isAlgebraic_iff._simp_1_3 | Mathlib.RingTheory.Algebraic.Defs | [
"forall_prop_of_true",
"propext",
"Eq"
] | false |
_private.Lean.Elab.LetRec.0.Lean.Elab.Term.mkLetRecDeclView | Lean.Elab.LetRec | [
"Pure.pure",
"Lean.Core.instMonadTraceCoreM",
"Lean.instMonadEnvOfMonadLift",
"Lean.TSyntax",
"Lean.MessageData",
"Lean.MonadError.mk",
"Unit.unit",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.EnvironmentHeader.isModule",
"Std.instToFormatString",
"Lean.Elab.Term.instAddErrorMessageContextTerm... | true |
Vector.swap._auto_3 | Init.Data.Vector.Basic | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
WithVal.instNumberField | Mathlib.Topology.Algebra.Valued.WithVal | [
"LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero",
"WithVal.instCharZero",
"Rat",
"Rat.commSemiring",
"Field.toDivisionRing",
"Algebra.toModule",
"Rat.instDivisionRing",
"DivisionRing.toRing",
"NumberField.to_finiteDimensional",
"LinearOrderedCommGroupWithZero",
"Field.toSemifie... | true |
Topology.IsEmbedding.comp | Mathlib.Topology.Maps.Basic | [
"Topology.IsInducing.comp",
"Function.comp",
"Topology.IsInducing",
"Topology.IsEmbedding.isInducing",
"TopologicalSpace",
"Topology.IsEmbedding.injective",
"Topology.IsEmbedding",
"Eq",
"Topology.IsEmbedding.mk"
] | true |
IsOpen.stronglyLocallyContractibleSpace | Mathlib.Topology.Homotopy.LocallyContractible | [
"IsOpen.isOpenEmbedding_subtypeVal",
"Topology.IsOpenEmbedding.stronglyLocallyContractibleSpace",
"StronglyLocallyContractibleSpace",
"Membership.mem",
"Set.Elem",
"Subtype",
"TopologicalSpace",
"IsOpen",
"instTopologicalSpaceSubtype",
"Subtype.val",
"Set.instMembership",
"Set"
] | true |
ModuleCat.CoextendScalars.map' | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | [
"ModuleCat.CoextendScalars.map'._proof_1",
"Semiring.toModule",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"AddCommGroup.toAddCommMonoid",
"LinearMap.addCommGroup",
"RingHom",
"ModuleCat.CoextendScalars.map'._proof_3",
"ModuleCat.CoextendScalars.obj'",
"ModuleCat.restri... | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getMatchEqCondForAux | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | [
"Pure.pure",
"Lean.ConstructorVal",
"_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.getMatchEqCondForAux.handleEnumWithDefault",
"ReaderT",
"Lean.Meta.State",
"instMonadLiftT",
"Lean.Elab.Tactic.BVDecide.Frontend.Normalize.matchEqCondSuffix",
... | true |
Equiv.prodEmbeddingDisjointEquivSigmaEmbeddingRestricted._proof_1 | Mathlib.Logic.Equiv.Embedding | [
"Eq.mpr",
"congrArg",
"Compl.compl",
"Set.subset_compl_iff_disjoint_right",
"Iff.rfl",
"Disjoint",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"disjoint_comm",
"id",
"BiheytingAlgebra.toHeytingAlgebra",
"HasSubset.Subset",
"BiheytingAlgebra.toCoheytingAlgebra",
"Set.instCompl",
"F... | false |
Ordinal.lt_one_iff_zero | Mathlib.SetTheory.Ordinal.Basic | [
"Ordinal.instLinearOrder",
"Preorder.toLT",
"Ordinal.partialOrder",
"instIsBotZeroClass",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"Ordinal.instSuccAddOrder",
"Ordinal.addMonoidWithOne",
"Ordinal.one",
... | true |
_private.Mathlib.Logic.Equiv.Prod.0.Equiv.piEquivPiSubtypeProd._proof_7 | Mathlib.Logic.Equiv.Prod | [
"False",
"dite_congr",
"Lean.Grind.nestedProof",
"_private.Mathlib.Logic.Equiv.Prod.0.Equiv.piEquivPiSubtypeProd._proof_5",
"eq_false",
"congrArg",
"HEq.refl",
"Classical.byContradiction",
"Subtype.casesOn",
"Exists",
"_private.Mathlib.Logic.Equiv.Prod.0.Equiv.piEquivPiSubtypeProd._proof_3",
"... | false |
Eq.trans_ssubset | Mathlib.Order.RelClasses | [
"HasSSubset",
"HasSSubset.SSubset",
"ssubset_of_eq_of_ssubset",
"Eq"
] | true |
Std.DTreeMap.isEmpty | Std.Data.DTreeMap.Basic | [
"Std.DTreeMap",
"Ordering",
"Std.DTreeMap.inner",
"Std.DTreeMap.Internal.Impl.isEmpty",
"Bool"
] | true |
Lean.Elab.Tactic.BVDecide.Frontend.M.simplifyTernaryProof | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | [
"Option.some",
"Lean.Expr",
"Prod.mk",
"Option.none",
"Unit",
"Lean.Elab.Tactic.BVDecide.Frontend.M.simplifyBinaryProof",
"_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect.0.Lean.Elab.Tactic.BVDecide.Frontend.M.simplifyTernaryProof.match_1",
"Prod",
"Option"
] | true |
CategoryTheory.PreOneHypercover.Hom.ext'_iff | Mathlib.CategoryTheory.Sites.Hypercover.One | [
"CategoryTheory.PreOneHypercover.Hom.s₁",
"CategoryTheory.PreZeroHypercover.Hom.h₀",
"Equiv.instEquivLike",
"CategoryTheory.PreOneHypercover.Hom.ext'._proof_1",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Iff.of_eq",
"congrArg",
"CategoryTheory.PreOneHypercover",
"CategoryTheory.PreOn... | true |
Set.projIcc_of_le_left | Mathlib.Order.Interval.Set.ProjIcc | [
"Iff.mpr",
"Subtype.mk.congr_simp",
"Lattice.toSemilatticeSup",
"congrArg",
"LinearOrder",
"PartialOrder.toPreorder",
"Set.projIcc",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"SemilatticeSup.toMax",
"inf_of_le_right",
"Set.Elem",
"DistribLattice.toLattice",
"Sub... | true |
CategoryTheory.Category.comp_id._autoParam | Mathlib.CategoryTheory.Category.Basic | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
Std.DHashMap.Internal.Raw₀.getEntry?_eq_getEntry? | Std.Data.DHashMap.Internal.WF | [
"Eq.mpr",
"congrArg",
"Std.DHashMap.Raw",
"id",
"instOfNatNat",
"Std.DHashMap.Internal.Raw.WFImp",
"Std.DHashMap.Internal.Raw₀.getEntry?_eq_getEntry?ₘ",
"LawfulHashable",
"Std.DHashMap.Internal.Raw₀.getEntry?ₘ_eq_getEntry?",
"Nat",
"Std.DHashMap.Raw.buckets",
"LT.lt",
"Std.DHashMap.Internal.... | true |
Std.Format.bracket | Init.Data.Format.Basic | [
"Std.Format.instAppend",
"String",
"String.Internal.length",
"Std.Format.group",
"Int",
"Nat.cast",
"instHAppendOfAppend",
"Std.Format",
"instNatCastInt",
"HAppend.hAppend",
"Std.Format.nest",
"Std.Format.text",
"Std.Format.FlattenBehavior.allOrNone"
] | true |
Lean.Meta.Grind.Context.cheapCases._default | Lean.Meta.Tactic.Grind.Types | [
"id",
"Bool",
"Bool.false"
] | false |
linearIndependent_fin_cons | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | [
"Submodule",
"AddCommGroup.toAddCommMonoid",
"linearIndependent_finCons",
"Fin.cons",
"Membership.mem",
"DivisionRing.toDivisionSemiring",
"AddCommGroup",
"instOfNatNat",
"instHAdd",
"And",
"Iff",
"HAdd.hAdd",
"Nat",
"Submodule.setLike",
"LinearIndependent",
"Submodule.span",
"Divisi... | true |
WeierstrassCurve.Projective.PointClass | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | [
"Units.instMulAction",
"CommRing",
"CommSemiring.toSemiring",
"Units",
"instOfNatNat",
"Units.instGroup",
"CommRing.toCommSemiring",
"MulAction.orbitRel.Quotient",
"Nat",
"Pi.mulAction",
"Semiring.toMonoid",
"Monoid.toMulAction",
"OfNat.ofNat",
"Fin"
] | true |
eq_zero_or_one_of_sq_eq_self | Mathlib.Algebra.GroupWithZero.Defs | [
"Iff.mpr",
"Eq.mpr",
"MulOne.toOne",
"HMul.hMul",
"MulZeroClass.toMul",
"Monoid.toMulOneClass",
"congrArg",
"mul_left_injective₀",
"Eq.mp",
"id",
"MulOne.toMul",
"instOfNatNat",
"sq",
"MulZeroOneClass.toMulOneClass",
"Monoid.toPow",
"MulOneClass.toMulOne",
"MonoidWithZero",
"Monoid... | true |
IsOpen.add_closure | Mathlib.Topology.Algebra.Group.Pointwise | [
"mem_closure_iff",
"Iff.mpr",
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"SubtractionMonoid.toInvolutiveNeg",
"Set.add_subset_add_left",
"instSeparatelyContinuousAddOfContinuousAdd",
"congrArg",
"subset_closure",
"AddMonoid.toAddZeroClass",
"IsOpen.add_right",
"Membership.mem",
"E... | true |
Set.IsWF.min_add | Mathlib.Data.Finset.MulAntidiagonal | [
"Iff.mpr",
"Eq.mpr",
"Preorder.toLT",
"congrArg",
"LinearOrder",
"covariant_swap_add_of_covariant_add",
"AddMonoid.toAddZeroClass",
"add_le_add",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"Set.IsWF.min_mem",
"Exists",
"SemilatticeInf.toPartialOrder",
"AddZeroClass.toA... | true |
Order.not_isSuccLimit_add_one | Mathlib.Algebra.Order.SuccPred | [
"Preorder.toLT",
"One",
"Order.succ",
"Order.succ_eq_add_one",
"NoMaxOrder",
"SuccAddOrder",
"PartialOrder.toPreorder",
"Eq.rec",
"PartialOrder",
"Order.IsSuccLimit",
"instHAdd",
"HAdd.hAdd",
"One.toOfNat1",
"SuccAddOrder.toSuccOrder",
"OfNat.ofNat",
"Eq",
"Not",
"Add",
"Order.no... | true |
UInt16.pow | Init.Data.UInt.Basic | [
"Nat.brecOn",
"UInt16.pow._f",
"UInt16",
"Nat"
] | true |
ModuleCat.smulNatTrans._proof_8 | Mathlib.Algebra.Category.ModuleCat.Basic | [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomClass",
"CategoryTheory.Functor",
"RingHomClass.toAddMonoidHomClass",
"CategoryTheory.CategoryStruct.toQuiver",
"AddCommGrpCat.instCategory",
"Quiver.Hom",
"ModuleCat",
"ModuleCat.smul",
"congrArg",
"CategoryTheory.NatTra... | false |
Function.Surjective.smulCommClass | Mathlib.Algebra.Group.Action.Defs | [
"Iff.mpr",
"instHSMul",
"Function.Surjective.forall",
"congrArg",
"SMul",
"congr",
"True",
"eq_self",
"of_eq_true",
"HSMul.hSMul",
"SMulCommClass.smul_comm",
"SMulCommClass.mk",
"Eq.symm",
"Eq",
"Function.Surjective",
"SMulCommClass",
"Eq.trans"
] | true |
CompHausLike.LocallyConstant.sigmaIso._proof_3 | Mathlib.Condensed.Discrete.LocallyConstant | [
"CompHausLike.LocallyConstant.fiber",
"Subtype",
"LocallyConstant",
"CompHausLike",
"instTopologicalSpaceSigma",
"CompactSpace",
"TopCat.str",
"CompHausLike.is_compact",
"TopCat.carrier",
"TopologicalSpace.Fiber.instFiniteFiberCoeLocallyConstant",
"CompHausLike.finiteCoproduct._proof_1",
"Loca... | false |
extChartAt_self_apply | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | [
"extChartAt",
"chartedSpaceSelf",
"NormedSpace",
"ModelWithCorners.toFun'",
"TopologicalSpace",
"ModelWithCorners",
"NontriviallyNormedField",
"NontriviallyNormedField.toNormedField",
"PartialEquiv.toFun",
"NormedAddCommGroup.toSeminormedAddCommGroup",
"Eq",
"rfl",
"NormedAddCommGroup"
] | true |
CategoryTheory.InjectiveResolution.definition._@.Mathlib.CategoryTheory.Abelian.Injective.Resolution.4211954440._hygCtx._hyg.8 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | [
"CategoryTheory.Abelian.toPreadditive",
"HomologicalComplex.instCategory",
"Equiv.instEquivLike",
"Nat.instOne",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CochainComplex.single₀",
"CategoryTheory.InjectiveResolution.ofCocomplex",
"AddRightCancelSemigroup.toAddSemigroup",
"AddCancelM... | false |
Lean.Elab.Info.ofChoiceInfo.elim | Lean.Elab.InfoTree.Types | [
"Lean.Elab.Info.ctorElim",
"PULift.up",
"Lean.Elab.ChoiceInfo",
"Nat",
"Lean.Elab.Info.ctorIdx",
"Eq.symm",
"Lean.Elab.Info",
"Eq",
"Lean.Elab.Info.ofChoiceInfo"
] | false |
one_half_le_sum_primes_ge_one_div | Mathlib.NumberTheory.SumPrimeReciprocals | [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"Nat.cast_mul._simp_1",
"Iff.mpr",
"instPowNat",
"Real.instIsOrderedRing",
"Mathlib.Tactic.Ring.Common.neg_zero",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.Ring.Common.neg_mul",
"Mathlib.Tactic.Ring.Common... | true |
List.isEmpty_eq_false_iff._simp_1 | Init.Data.List.Lemmas | [
"Ne",
"List",
"List.isEmpty",
"propext",
"Bool",
"List.isEmpty_eq_false_iff",
"Bool.false",
"Eq",
"List.nil"
] | false |
_private.Mathlib.Order.Interval.Set.Fin.0.Fin.preimage_rev_Ico._simp_1_2 | Mathlib.Order.Interval.Set.Fin | [
"Fin.rev",
"Nat",
"LT.lt",
"instLTFin",
"propext",
"Fin.rev_lt_iff",
"Fin",
"Eq"
] | false |
Stream'.Seq.update._proof_2 | Mathlib.Data.Seq.Defs | [
"dite_cond_eq_true",
"Eq.mpr",
"Stream'.Seq",
"Function.update",
"eq_false",
"congrArg",
"id",
"instOfNatNat",
"dite",
"iff_self",
"Stream'",
"Option.none",
"instHAdd",
"Option.map",
"Iff",
"Stream'.IsSeq",
"HAdd.hAdd",
"implies_congr",
"Nat",
"Subtype.prop",
"Option.map_eq_n... | false |
Complex.continuousWithinAt_log_of_re_neg_of_im_zero | Mathlib.Analysis.SpecialFunctions.Complex.Log | [
"AddGroup.toSubtractionMonoid",
"Norm.norm",
"SeminormedAddGroup.toNorm",
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"Complex.log",
"Complex.continuousWithinAt_arg_of_re_neg_of_im_zero",
"Real.instLE",
"Real",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"ContinuousWithinAt",
"HMul.h... | true |
FreeGroup.Red.Step.cons_not | Mathlib.GroupTheory.FreeGroup.Basic | [
"FreeGroup.Red.Step",
"Bool.not",
"FreeGroup.Red.Step.not",
"Prod.mk",
"List.cons",
"List",
"Bool",
"Prod",
"List.nil"
] | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform.0.SimpleGraph.unreduced_edges_subset._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | [
"not_le",
"Preorder.toLT",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"LE.le",
"LT.lt",
"propext",
"LinearOrder.toPartialOrder",
"Eq",
"Not"
] | false |
Complementeds.disjoint_coe._simp_1 | Mathlib.Order.Disjoint | [
"PartialOrder.toPreorder",
"Preorder.toLE",
"Disjoint",
"Complementeds",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"DistribLattice",
"BoundedOrder.toOrderBot",
"propext",
"Subtype.partialOrder",
"BoundedOrder",
"Subtype.val",
"Complementeds.instBoundedOrder",
"Eq",
"Co... | false |
_private.Mathlib.Order.CompleteLattice.PiLex.0.Pi.Colex.instInfSetColexForall._proof_1 | Mathlib.Order.CompleteLattice.PiLex | [
"Preorder.toLT",
"isWellOrder_lt",
"LinearOrder",
"WellFoundedGT",
"PartialOrder.toPreorder",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"instWellFoundedLTOrderDualOfWellFoundedGT",
"IsWellOrder.toIsWellFounded",
"LT.lt",
"OrderDual",
"OrderDual.instLinearOrder",
"LinearOrd... | false |
StrictConcaveOn.lt_map_sum | Mathlib.Analysis.Convex.Jensen | [
"OrderDual.toDual",
"StrictConcaveOn",
"instHSMul",
"Preorder.toLT",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Equiv.instEquivLike",
"CommRing.toNonUnitalCommRing",
"OrderDual.instIsStrictOrderedModule",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"Finset",
"Linea... | true |
Lean.PrettyPrinter.Formatter.pushToken | Lean.PrettyPrinter.Formatter | [
"Pure.pure",
"String.toSlice",
"Lean.PrettyPrinter.Formatter.State.mustBeGrouped",
"String.endsWith",
"bne",
"Lean.PrettyPrinter.Formatter.parseToken",
"Substring.Raw.str",
"Lean.PrettyPrinter.Formatter.State.stack",
"Bool.not",
"Lean.PrettyPrinter.Formatter.State.leadWordIdent",
"Substring.Raw.... | true |
Lean.Meta.instReduceEvalLiteral_qq | Qq.ForLean.ReduceEval | [
"Pure.pure",
"Lean.Meta.whnf",
"Lean.Literal.strVal",
"Lean.Expr.isAppOfArity",
"String",
"Lean.Meta.State",
"Lean.Name.mkStr3",
"Lean.Meta.ReduceEval",
"Lean.Expr",
"Lean.Meta.MetaM",
"IO.RealWorld",
"instDecidableEqBool",
"Lean.Meta.instReduceEvalString",
"instOfNatNat",
"Lean.Literal"... | true |
BitVec.getLsb'_ofFnBE | Batteries.Data.BitVec.Lemmas | [
"BitVec.getLsb",
"Fin.rev",
"BitVec.getLsb_ofFnBE",
"Nat",
"Bool",
"Fin",
"Eq",
"BitVec.ofFnBE"
] | true |
Set.Icc.mul_le_right | Mathlib.Algebra.Order.Interval.Set.Instances | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"HMul.hMul",
"LE.le.trans_eq",
"IsOrderedRing",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"PartialOrder",
"Set.Elem",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"LE.le",
"MulZeroOneClass.toMulOneClass",
"instDistribOfSemiring",
... | true |
_private.Init.Omega.IntList.0.List.getElem?_map.match_1_1 | Init.Omega.IntList | [
"instOfNatNat",
"List.cons",
"List",
"Nat",
"List.casesOn",
"OfNat.ofNat",
"Nat.succ",
"Nat.casesOn",
"List.nil"
] | false |
FunLike.ring | Mathlib.Data.FunLike.Ring | [
"Ring.mk",
"FunLike.ring._proof_7",
"NegZeroClass.toNeg",
"FunLike.ring._proof_6",
"FunLike.ring._proof_5",
"One",
"Pi.addCommMonoid",
"FunLike.ring._proof_3",
"IsZeroApply",
"IsSMulApply",
"AddCommGroup.toAddCommMonoid",
"FunLike.ring._proof_2",
"SMul",
"AddMonoid.toAddZeroClass",
"AddM... | true |
StarRingEquiv.trans | Mathlib.Algebra.Star.StarRingHom | [
"StarRingEquiv.toRingEquiv",
"StarRingEquiv.mk",
"Mul",
"Star",
"RingEquiv.trans",
"StarRingEquiv.trans._proof_1",
"RingEquiv",
"StarRingEquiv",
"Add"
] | true |
_private.Mathlib.LinearAlgebra.BilinearForm.Orthogonal.0.LinearMap.BilinForm.ker_restrict_eq_of_codisjoint._simp_1_2 | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | [
"Submodule",
"Submodule.mem_comap",
"LinearMap.instFunLike",
"RingHom",
"Membership.mem",
"LinearMap",
"AddCommMonoid",
"Submodule.comap",
"Submodule.setLike",
"propext",
"Semiring",
"Module",
"Semiring.toNonAssocSemiring",
"Eq",
"DFunLike.coe",
"SetLike.instMembership"
] | false |
IsPRadical.injective_comp | Mathlib.FieldTheory.IsPerfectClosure | [
"CommRing",
"Semiring.toModule",
"nilradical_eq_zero",
"CommSemiring.toSemiring",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"AddGroupWithOne.toAddMonoidWithOne",
"Preorder.toLE",
"RingHom",
"ExpChar",
"Eq.le",
"Submodule.instPartialOrder",
"pNilradical",
"Bot.bot",
"Ideal",
"Monoid.... | true |
Algebra.FinitePresentation.mvPolynomial_of_finitePresentation | Mathlib.RingTheory.FinitePresentation | [
"AlgEquiv.toAlgHom_toRingHom",
"Finsupp.instAddZeroClass",
"Eq.mpr",
"AlgEquiv.instEquivLike",
"RingHom.instRingHomClass",
"MvPolynomial.ker_map",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
"CommRing",
"Semiring.toModule",
"AlgHom.algHomClass",
"AlgHom.toMonoidHom'._proof_2",
"AlgE... | true |
_private.Lean.Meta.Tactic.Grind.Action.0.Lean.Meta.Grind.Action.loop.match_1 | Lean.Meta.Tactic.Grind.Action | [
"Unit.unit",
"instOfNatNat",
"Unit",
"Nat",
"OfNat.ofNat",
"Nat.succ",
"Nat.casesOn"
] | false |
isAddRegular_unop | Mathlib.Algebra.Regular.Opposite | [
"AddOpposite",
"AddOpposite.instAdd",
"Iff",
"IsAddRegular",
"AddOpposite.unop",
"Iff.symm",
"AddOpposite.op",
"Add",
"isAddRegular_op"
] | true |
Lean.Meta.CheckAssignment.Context.rec | Lean.Meta.ExprDefEq | [
"Lean.MVarId",
"Lean.Expr",
"Array",
"Bool",
"Lean.MetavarDecl",
"Lean.Meta.CheckAssignment.Context",
"Lean.Meta.CheckAssignment.Context.mk"
] | false |
Polynomial.add_modByMonic | Mathlib.Algebra.Polynomial.Div | [
"Nontrivial",
"Distrib.leftDistribClass",
"WithBot.instPreorder",
"Eq.mpr",
"CommRing",
"WithBot",
"Preorder.toLT",
"Lattice.toSemilatticeSup",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"instDistribLatticeNat",
"CommRing.toNonUnitalCommRing",
"AddMonoid.toAddSemigroup",
... | true |
Nat.maxPowDvdDiv.eq_1 | Mathlib.Data.Nat.MaxPowDiv | [
"instDecidableNot",
"Prod.mk",
"Ne",
"instOfNatNat",
"Nat.maxPowDvdDiv",
"dite",
"And",
"Nat",
"LT.lt",
"Nat.decLt",
"Eq.refl",
"instDecidableEqNat",
"instLTNat",
"instDecidableAnd",
"Prod",
"OfNat.ofNat",
"Eq",
"Not",
"Nat.maxPowDvdDiv.go"
] | true |
SSet.Subcomplex.PairingCore.pairing._proof_9 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | [
"SSet.Subcomplex.PairingCore.ι",
"SSet.Subcomplex.PairingCore.II",
"Set.ext",
"Eq.mpr",
"_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore.0.SSet.Subcomplex.PairingCore.pairing._simp_3",
"False",
"SSet.Subcomplex.PairingCore",
"iff_false",
"_private.Mathlib.AlgebraicTopo... | false |
_private.Init.Data.Nat.Gcd.0.Nat.gcd_pos_iff._simp_1_2 | Init.Data.Nat.Gcd | [
"Decidable",
"And",
"Decidable.not_and_iff_or_not",
"propext",
"Or",
"Eq",
"Not"
] | false |
Function.OfArity.curry_two_eq_curry | Mathlib.Data.Fin.Tuple.Curry | [
"Equiv.instEquivLike",
"Function.FromTypes.curry_two_eq_curry",
"Function.OfArity.curry",
"Function.comp",
"Equiv",
"instOfNatNat",
"Function.OfArity",
"Function.curry",
"Nat",
"Equiv.symm",
"Prod",
"OfNat.ofNat",
"Fin",
"Eq",
"DFunLike.coe",
"finTwoArrowEquiv",
"EquivLike.toFunLike"... | true |
Turing.TM2.stepAux.eq_1 | Mathlib.Computability.TuringMachine.StackTuringMachine | [
"Turing.TM2.stepAux",
"Function.update",
"List.cons",
"List",
"Eq.refl",
"Turing.TM2.Cfg",
"Eq",
"Turing.TM2.Stmt.push",
"Turing.TM2.Stmt",
"DecidableEq"
] | true |
_private.Lean.Compiler.LCNF.Simp.DiscrM.0.Lean.Compiler.LCNF.Simp.withDiscrCtorImp.updateCtx.match_1 | Lean.Compiler.LCNF.Simp.DiscrM | [
"Lean.Compiler.LCNF.Arg",
"Option.ctorIdx",
"Option.some",
"Nat.hasNotBit",
"Prod.mk",
"Lean.Level",
"Lean.Compiler.LCNF.Purity.pure",
"Array",
"List",
"Prod",
"Prod.casesOn",
"_private.Lean.Compiler.LCNF.Simp.DiscrM.0.Lean.Compiler.LCNF.Simp.findCtor?._sparseCasesOn_1",
"Option"
] | false |
addMonoidHomOfMemClosureRangeCoe_apply | Mathlib.Topology.Algebra.Monoid | [
"Pi.topologicalSpace",
"addMonoidHomOfMemClosureRangeCoe",
"Membership.mem",
"AddZeroClass.toAddZero",
"AddMonoidHomClass",
"TopologicalSpace",
"AddZeroClass",
"closure",
"T2Space",
"AddZero.toAdd",
"Eq.refl",
"Set.range",
"ContinuousAdd",
"AddMonoidHom",
"AddMonoidHom.instFunLike",
"E... | true |
ExpChar.zero | Mathlib.Algebra.CharP.Defs | [
"ExpChar.zero",
"ExpChar",
"instOfNatNat",
"CharZero",
"Nat",
"OfNat.ofNat",
"AddMonoidWithOne"
] | true |
UInt8.toUInt16_div | Init.Data.UInt.Lemmas | [
"instHDiv",
"HDiv.hDiv",
"UInt8.toUInt16",
"UInt16",
"instDivUInt16",
"UInt8",
"Eq",
"instDivUInt8",
"rfl"
] | true |
Rat.instSemilatticeInf | Mathlib.Algebra.Order.Ring.Unbundled.Rat | [
"Rat",
"inferInstance",
"Rat.instLattice",
"SemilatticeInf",
"Lattice.toSemilatticeInf"
] | true |
CategoryTheory.Subfunctor.range_eq_top | Mathlib.CategoryTheory.Subfunctor.Image | [
"Eq.mpr",
"CategoryTheory.Functor",
"Lattice.toSemilatticeSup",
"CategoryTheory.Epi",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CompleteLattice.toLattice",
"congrArg",
"PartialOrder.toPreorder",
"CategoryTheory.Functor.category",
"Preorder.toLE",
"CompleteLattice.toBoundedOrder"... | true |
Associates.instCommMonoidWithZero._proof_1 | Mathlib.Algebra.GroupWithZero.Associated | [
"CommMonoidWithZero.toCommMonoid",
"Eq.mpr",
"Associates.mk",
"Semigroup.toMul",
"Associates.instCommMonoid",
"HMul.hMul",
"MulZeroClass.toMul",
"Monoid.toMulOneClass",
"Associates.mk_zero",
"congrArg",
"MulZeroClass.zero_mul",
"Associates.instZero",
"id",
"MulOne.toMul",
"CommMonoidWith... | false |
ISize.minValue_le_toInt | Init.Data.SInt.Lemmas | [
"instPowNat",
"Eq.mpr",
"ISize.minValue",
"ISize.ofInt",
"congrArg",
"Std.IsLinearPreorder.toIsPreorder",
"Std.instReflLeOfIsPreorder",
"HSub.hSub",
"Std.le_refl._simp_1",
"id",
"Int.instNegInt",
"instSubNat",
"instOfNatNat",
"Int",
"Int.instNatPow",
"LE.le",
"ISize.toInt_ofInt_of_tw... | true |
ContinuousLinearMap.isPositive_self_comp_adjoint | Mathlib.Analysis.InnerProductSpace.Positive | [
"ContinuousLinearMap.comp",
"LinearIsometryEquiv.instEquivLike",
"InnerProductSpace.toNormedSpace",
"NormedCommRing.toSeminormedCommRing",
"CompleteSpace",
"NormedSpace.toIsBoundedSMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMon... | true |
Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit!_list_of_not_mem_of_mem | Std.Data.DTreeMap.Internal.Lemmas | [
"Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit!",
"Unit.unit",
"Std.DTreeMap.Internal.Impl.SizedBalancedTree.impl",
"List.Pairwise",
"Ord",
"congrArg",
"instForInOfForIn'",
"Std.TransOrd",
"Std.DTreeMap.Internal.Impl.Balanced",
"Membership.mem",
"Ordering",
"inferInstance",
"Ordering.... | true |
Aesop.Frontend.AttrConfig.noConfusionType | Aesop.Frontend.Attribute | [
"Aesop.Frontend.AttrConfig.casesOn",
"Aesop.Frontend.AttrConfig",
"Array",
"Aesop.Frontend.RuleExpr",
"Eq"
] | false |
Std.TreeSet.le_max!_of_mem | Std.Data.TreeSet.Lemmas | [
"Std.TreeSet",
"Std.TreeSet.max!",
"Membership.mem",
"Ordering",
"Std.TreeSet.inner",
"Std.TransCmp",
"Bool.true",
"Unit",
"Bool",
"Inhabited",
"Std.TreeMap.le_maxKey!_of_mem",
"Ordering.isLE",
"Eq",
"Std.TreeSet.instMembership"
] | true |
CategoryTheory.Abelian.SpectralObject.homologyDataIdId_right_p | Mathlib.Algebra.Homology.SpectralObject.Page | [
"CategoryTheory.Abelian.toPreadditive",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Abelian.SpectralObject.H",
"PartialOrder.toPreorder",
"CategoryTheory.Functor.category",
"CategoryTheory.Abelian",
"CategoryTheory.ComposableArrows",
"CategoryTheory.CategoryStruct.id",
... | true |
Std.ExtHashSet.ext_mem | Std.Data.ExtHashSet.Lemmas | [
"Std.ExtHashMap.ext_mem_unit",
"instLawfulHashableOfLawfulBEq",
"Std.ExtHashSet",
"LawfulBEq",
"Membership.mem",
"_private.Std.Data.ExtHashSet.Lemmas.0.Std.ExtHashSet.ext",
"Iff",
"Std.ExtHashSet.inner",
"Hashable",
"Std.ExtHashSet.instMembershipOfEquivBEqOfLawfulHashable",
"instEquivBEqOfLawful... | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.EMatchTheoremKind.toAttributeCore.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | [
"Lean.Meta.Grind.EMatchTheoremKind.user",
"Unit.unit",
"Lean.Meta.Grind.EMatchTheoremKind.eqBwd",
"Lean.Meta.Grind.EMatchTheoremKind.bwd",
"Lean.Meta.Grind.EMatchTheoremKind.fwd",
"Bool.true",
"Lean.Meta.Grind.EMatchTheoremKind",
"Lean.Meta.Grind.EMatchTheoremKind.casesOn",
"Unit",
"Bool.casesOn",... | false |
Sigma.forall | Mathlib.Data.Sigma.Basic | [
"_private.Mathlib.Data.Sigma.Basic.0.Sigma.forall.match_1_1",
"Iff",
"Iff.intro",
"Sigma.mk",
"Sigma"
] | true |
Lean._aux_Init_Meta___macroRules_Lean_Parser_Syntax_addPrio_1 | Init.Meta | [
"Pure.pure",
"Lean.evalPrio",
"Lean.TSyntax",
"Lean.MonadRef.mkInfoFromRefPos",
"Lean.Quote.quote",
"instMonadExceptOfMonadExceptOf",
"Lean.SourceInfo",
"MonadExcept.throw",
"Lean.Syntax.isOfKind",
"EStateM.instMonad",
"Lean.Macro.Exception",
"Lean.TSyntax.mk",
"Lean.Syntax",
"ReaderT.inst... | false |
SchwartzMap.instIsUniformAddGroup | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | [
"NormedCommRing.toSeminormedCommRing",
"Real",
"NormedSpace",
"SchwartzMap.instModule",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"AddCommGroup.toAddGroup",
"SchwartzMap.instUniformSpace",
"Real.semiring",
"SchwartzMap",
"IsUniformAddGroup",
"smulCommClass_self",
"CommMonoid.to... | true |
ChainComplex.truncateAugment._proof_3 | Mathlib.Algebra.Homology.Augment | [
"CategoryTheory.Limits.HasZeroMorphisms",
"ChainComplex",
"HomologicalComplex.instCategory",
"Nat.instOne",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddRightCancelSemigroup.toAddSemigroup",
"AddCancelMonoid.toAddRightCancelMonoid",
"Nat.ins... | false |
Lean.Elab.Tactic.Do.ProofMode.ensureMGoal | Lean.Elab.Tactic.Do.ProofMode.MGoal | [
"Pure.pure",
"Lean.instantiateMVars",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"Lean.Elab.Term.instMonadMacroAdapterTermElabM",
"Lean.instMonadMCtxOfMonadLift",
"Lean.Elab.Term.instMonadTermElabM",
"ReaderT",
"String",
"Lean.Elab.Tactic.getMainGoal",
"Lean.Meta.State",
"Le... | true |
NumberField.CMExtension.algebraMap_equivMaximalRealSubfield_symm_apply | Mathlib.NumberTheory.NumberField.CMField | [
"RingEquiv.apply_symm_apply",
"Subfield.toAlgebra",
"Algebra.algebraMap",
"NumberField.maximalRealSubfield",
"congrArg",
"CommSemiring.toSemiring",
"NumberField.IsTotallyComplex",
"RingEquiv.instEquivLike",
"Subfield.instSubfieldClass",
"Rat",
"AddGroupWithOne.toAddMonoidWithOne",
"Algebra",
... | true |
IsLocalization.Away.awayToAwayRight_eq | Mathlib.RingTheory.Localization.Away.Basic | [
"IsLocalization.Away.awayToAwayRight._proof_1",
"HMul.hMul",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"IsLocalization.Away",
"Algebra",
"RingHom",
"IsLocalization.Away.lift_eq",
"instDistribOfSemiring",
"CommSemiring",
"RingHom.instFunLike",
"Distrib.toMul",
"IsLocalization.Away.away... | true |
Int.mul_le_mul_left._simp_1 | Init.Data.Int.DivMod.Lemmas | [
"HMul.hMul",
"Int",
"LE.le",
"Int.instMul",
"Int.instLTInt",
"instOfNat",
"LT.lt",
"Int.mul_le_mul_left",
"propext",
"OfNat.ofNat",
"Eq",
"Int.instLEInt",
"instHMul"
] | false |
EReal.Tendsto.const_mul | Mathlib.Topology.Instances.EReal.Lemmas | [
"EReal.Tendsto.mul",
"HMul.hMul",
"EReal.instMulZeroOneClass",
"congrArg",
"tendsto_const_nhds",
"EReal.instTopologicalSpace",
"MulZeroClass.zero_mul",
"by_cases",
"EReal",
"nhds",
"instTopEReal",
"Ne",
"Bot.bot",
"instZeroEReal",
"funext",
"Filter.Tendsto",
"congr",
"True",
"of_... | true |
Lean.Elab.Command.AssertExists._sizeOf_1 | Lean.Elab.AssertExists | [
"Lean.Elab.Command.AssertExists.rec",
"instOfNatNat",
"instHAdd",
"Lean.Elab.Command.AssertExists",
"HAdd.hAdd",
"Lean.instSizeOfName",
"Nat",
"SizeOf.sizeOf",
"Bool",
"instAddNat",
"Lean.Name",
"OfNat.ofNat",
"Bool._sizeOf_inst"
] | false |
CategoryTheory.Discrete.monoidalFunctorMonoidal._proof_10 | Mathlib.CategoryTheory.Monoidal.Discrete | [
"Monoid",
"Eq.mpr",
"MulOne.toOne",
"CategoryTheory.MonoidalCategory.whiskerLeft_eqToHom",
"CategoryTheory.MonoidalCategoryStruct.whiskerLeft",
"MonoidHom.instFunLike",
"HMul.hMul",
"CategoryTheory.CategoryStruct.toQuiver",
"MonoidHom",
"Quiver.Hom",
"Monoid.toMulOneClass",
"congrArg",
"Cate... | false |
_private.Mathlib.Topology.Bornology.BoundedOperation.0.isBounded_pow._simp_1_2 | Mathlib.Topology.Bornology.BoundedOperation | [
"Set.mem_image",
"Membership.mem",
"Exists",
"And",
"propext",
"Set.image",
"Eq",
"Set.instMembership",
"Set"
] | false |
Multiset.le_union_left | Mathlib.Data.Multiset.UnionInter | [
"PartialOrder.toPreorder",
"Preorder.toLE",
"Multiset",
"LE.le",
"Multiset.instUnion",
"Multiset.le_sub_add",
"Union.union",
"Multiset.instPartialOrder",
"DecidableEq"
] | true |
SzemerediRegularity.coe_stepBound | Mathlib.Combinatorics.SimpleGraph.Regularity.Bound | [
"Nat.cast_mul._simp_1",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"SzemerediRegularity.stepBound",
"HMul.hMul",
"congrArg",
"Nat.instMonoid",
"Nat.instAtLeastTwoHAddOfNat",
"id",
"AddMonoidWithOne.toNatCast",
"instMulNat",
"instOfNatNat",
"AddCommMonoidWithOne.toAddMonoidWithOne",... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.