name string | module string | deps list |
|---|---|---|
LinearEquiv.ofEq.congr_simp | Mathlib.LinearAlgebra.Basis.Submodule | [
"Submodule",
"Submodule.addCommMonoid",
"Membership.mem",
"Subtype",
"Submodule.module",
"LinearEquiv.ofEq",
"AddCommMonoid",
"RingHomInvPair.ids",
"Submodule.setLike",
"LinearEquiv",
"Semiring",
"Eq.refl",
"Module",
"RingHom.id",
"Semiring.toNonAssocSemiring",
"Eq",
"SetLike.instMem... |
RCLike.im_eq_zero | Mathlib.Analysis.RCLike.Basic | [
"Eq.mpr",
"RCLike.re_add_im",
"Real",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"Real.instZero",
"Real.instAddMonoid",
"congrArg",
"AddMonoid.toAddZeroClass",
"AddMonoid.toZero",
"PseudoMetricSpace.toUniformSpace",
"NonUnitalNonAssocSemiring.to... |
CategoryTheory.Limits.BinaryBicone.isBilimitOfCokernelFst._proof_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | [
"CategoryTheory.Limits.BinaryBicone.fst",
"CategoryTheory.Functor",
"CategoryTheory.Limits.BinaryBicone.inl_fst_assoc",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"CategoryTheory.Limits.BinaryBicone.inl",
"CategoryTheory.Limits.BinaryBicone.in... |
_private.Mathlib.NumberTheory.FLT.Polynomial.0.Polynomial.flt_catalan_aux._simp_1_5 | Mathlib.NumberTheory.FLT.Polynomial | [
"map_add",
"instHAdd",
"HAdd.hAdd",
"AddHomClass",
"Eq.symm",
"Eq",
"DFunLike.coe",
"Add",
"FunLike"
] |
Std.Format.tag.sizeOf_spec | Init.Data.Format.Basic | [
"Std.Format.tag",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"Std.Format._sizeOf_inst",
"Std.Format",
"instAddNat",
"Eq.refl",
"instSizeOfNat",
"OfNat.ofNat",
"Eq"
] |
Filter.EventuallyEq.nhdsNE_deriv | Mathlib.Analysis.Calculus.Deriv.Basic | [
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"NormedSpace",
"congrArg",
"Compl.compl",
"Filter.EventuallyEq.deriv",
"deriv",
"nhdsWithin",
"Filter.Eventually",
"NormedSpace.toModule",
"EMetricSpace.metrizableSpace",
"setOf",
"PseudoMetricSpace.toUniformSpace",
"Membership.mem",
"nhds... |
List.le_nil._simp_1 | Init.Data.List.Lex | [
"List.le_nil",
"LE.le",
"List",
"propext",
"List.instLE",
"Eq",
"LT",
"List.nil"
] |
_private.Lean.Meta.RecursorInfo.0.Lean.Meta.getMotiveLevel._sparseCasesOn_1 | Lean.Meta.RecursorInfo | [
"Nat.ne_of_beq_eq_false",
"Lean.Expr.const",
"Lean.Expr.letE",
"Lean.Expr.mvar",
"Nat.shiftRight",
"Lean.MVarId",
"Lean.Expr",
"Lean.FVarId",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Expr.sort",
"Lean.Expr.bvar",
"Lean.Level",
"Lean.Literal",
"Lean.Expr.mdata",
"Lean.Expr.fvar",
"Lean.... |
_private.Aesop.Tree.Data.0.Aesop.GoalId.succ.match_1 | Aesop.Tree.Data | [
"Aesop.GoalId.casesOn",
"Aesop.GoalId",
"Nat",
"Aesop.GoalId.mk"
] |
Std.HashMap.Equiv.getElem!_eq | Std.Data.HashMap.Lemmas | [
"Membership.mem",
"Std.DHashMap.Equiv.constGet!_eq",
"Std.HashMap",
"LawfulHashable",
"EquivBEq",
"Std.HashMap.Equiv",
"Std.HashMap.Equiv.inner",
"Inhabited",
"Hashable",
"Std.HashMap.instGetElem?Mem",
"Std.HashMap.inner",
"BEq",
"Eq",
"GetElem?.getElem!",
"Std.HashMap.instMembership"
] |
BooleanSubalgebra.topEquiv._proof_1 | Mathlib.Order.BooleanSubalgebra | [
"BooleanAlgebra",
"BooleanSubalgebra",
"Equiv.instEquivLike",
"Iff.rfl",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"SemilatticeInf.toPartialOrder",
"Equiv",
"Subtype",
"BiheytingAlgebra.toCoheytingAlgebra",
"LE.le",
"BooleanAlgebra.toBiheytingAlgebra",
"Iff",
"Boolean... |
Int.Linear.Poly.mul_minus_one_getConst_eq | Init.Data.Int.Linear | [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"Int.neg_one_mul",
"Bool.false_eq_true",
"Int.instDecidableEq",
"Int.Linear.Poly.rec",
"id",
"Int.Linear.Poly.mul'",
"instDecidableEqBool",
"Int.instNegInt",
"Int",
"Int.Linear.Var",
"Int.Linear.Poly.num",
"instBEqOfDecidableEq",
"Int.Linear.Poly.mul"... |
NumberField.InfinitePlace.one_le_of_lt_one | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | [
"Subalgebra.instSetLike",
"Iff.mpr",
"NormedCommRing.toNormedRing",
"Real.instIsOrderedRing",
"Int.cast",
"NumberField.InfinitePlace.instFunLikeReal",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"Int.cast_abs",
"pow_pos",
"Rat.cast_intCast",
"Real.partialOrder",
"N... |
CategoryTheory.Core.functorToCore._proof_4 | Mathlib.CategoryTheory.Core | [
"CategoryTheory.Functor",
"CategoryTheory.Core.mk",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Groupoid.inv",
"CategoryTheory.IsIso.inv_hom_id",
"CategoryTheory.CategoryStruct.id",
"CategoryTheory.Groupoid",
"CategoryTheory.Functor.map_inv",
"CategoryTheo... |
Lean.CollectMVars.State.mk._flat_ctor | Lean.Util.CollectMVars | [
"Lean.MVarId",
"Lean.ExprSet",
"Array",
"Lean.CollectMVars.State",
"Lean.CollectMVars.State.mk"
] |
WType.toList._sunfold | Mathlib.Data.W.Constructions | [
"WType",
"WType.toList",
"WType.Listβ",
"WType.Listα",
"WType.Listα.cons",
"List.cons",
"List",
"PUnit.unit",
"WType.toList.match_1",
"WType.Listα.nil",
"List.nil"
] |
Std.TreeMap.getEntryGE | Std.Data.TreeMap.AdditionalOperations | [
"Std.TreeMap.inner",
"Membership.mem",
"Exists",
"Ordering",
"Std.TransCmp",
"Bool.true",
"And",
"Std.TreeMap.instMembership",
"Bool",
"Ordering.isGE",
"Prod",
"Eq",
"Std.DTreeMap.Const.getEntryGE",
"Std.TreeMap"
] |
Lean.Compiler.LCNF.JoinPointFinder.FindState.mk.noConfusion | Lean.Compiler.LCNF.JoinPoints | [
"Lean.instBEqFVarId",
"Lean.Compiler.LCNF.JoinPointFinder.FindState.mk",
"Lean.Compiler.LCNF.JoinPointFinder.FindState.noConfusion",
"id",
"Lean.FVarId",
"Std.HashMap",
"Lean.Compiler.LCNF.JoinPointFinder.CandidateInfo",
"Lean.instHashableFVarId",
"Lean.Compiler.LCNF.JoinPointFinder.FindState",
"E... |
CategoryTheory.Quotient.linear._proof_2 | Mathlib.CategoryTheory.Quotient.Linear | [
"Eq.mpr",
"instHSMul",
"CategoryTheory.Quotient.Linear.smul_eq",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.Quotient",
"Quiver.Hom",
"congrArg",
"DistribMulAction.toDistribSMul",
"AddCommGroup.toAddCommMonoid",
"CategoryTheory.Quotient.full_functor",
"CategoryTheory.Quotient.categ... |
Std.Tactic.BVDecide.BVExpr.Cache.insert.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | [
"Std.Sat.AIG.Decl",
"Std.Sat.AIG.Fanin.gate",
"Std.Tactic.BVDecide.BVExpr.Cache.Key",
"instLawfulBEq",
"Vector",
"Vector.instGetElemNatLt",
"Membership.mem",
"Std.DHashMap.instMembership",
"Std.Tactic.BVDecide.BVExpr.Cache.casesOn",
"instBEqOfDecidableEq",
"Std.Tactic.BVDecide.BVExpr.Cache.instD... |
_private.Mathlib.Tactic.CasesM.0.Mathlib.Tactic.matchPatterns.match_1 | Mathlib.Tactic.CasesM | [
"_private.Mathlib.Tactic.CasesM.0.Mathlib.Tactic.matchPatterns._sparseCasesOn_1",
"Option.ctorIdx",
"Option.some",
"Lean.Expr",
"Nat.hasNotBit",
"Prod.mk",
"instOfNatNat",
"dite",
"List.toArray",
"Array",
"Nat",
"Eq.ndrec",
"Eq.refl",
"instDecidableEqNat",
"Prod",
"Prod.casesOn",
"Of... |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.initFn._@.Lean.Linter.UnusedVariables.727354328._hygCtx._hyg.2 | Lean.Linter.UnusedVariables | [
"Lean.Linter.LinterOptions",
"Bool.not",
"Lean.Syntax.isOfKind",
"IO",
"Lean.Syntax",
"Lean.Linter.getLinterUnusedVariablesPatternVars",
"Bool.and",
"instOfNatNat",
"instBEqOfDecidableEq",
"BEq.beq",
"Unit",
"Lean.Linter.addBuiltinUnusedVariablesIgnoreFn",
"_private.Lean.Linter.UnusedVariabl... |
Submodule.quotientEquivDirectSum._proof_3 | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | [
"Ideal.Quotient.isScalarTower",
"Submodule",
"IsDomain",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"Semiring.toModule",
"Pi.addCommMonoid",
"IsScalarTower.right",
"CommRing.toNonUnitalCommRing",
"Ring.toNonAssocRing",
"Submodule.Quotient.addCommGroup",
"CommSemiring.toSemiri... |
ContinuousMap.equivFnOfDiscrete_symm_apply | Mathlib.Topology.ContinuousMap.Basic | [
"Equiv.instEquivLike",
"DiscreteTopology",
"ContinuousMap",
"ContinuousMap.equivFnOfDiscrete",
"Equiv",
"TopologicalSpace",
"Equiv.symm",
"Eq",
"ContinuousMap.instFunLike",
"DFunLike.coe",
"rfl",
"EquivLike.toFunLike"
] |
Lean.Meta.Sym.Simp.instOrElseSimproc | Lean.Meta.Sym.Simp.Simproc | [
"Unit.unit",
"OrElse.mk",
"OrElse",
"Lean.Meta.Sym.Simp.Simproc",
"Lean.Meta.Sym.Simp.Simproc.orElse",
"Unit"
] |
bot_lt_isotypicComponent | Mathlib.RingTheory.SimpleModule.Isotypic | [
"Nontrivial",
"Iff.mpr",
"Submodule",
"Preorder.toLT",
"IsSimpleModule.nontrivial",
"AddCommGroup.toAddCommMonoid",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"AddCommGroup",
"bot_lt_iff_ne_bot",
"Subtype",
"IsSimpleModule",
"Ne",
"Submodule.instPar... |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_inter._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"
] |
_private.Mathlib.Analysis.Calculus.UniformLimitsDeriv.0.hasFDerivAt_of_tendstoLocallyUniformlyOn._simp_1_2 | Mathlib.Analysis.Calculus.UniformLimitsDeriv | [
"Filter.instMembership",
"Set.univ",
"Membership.mem",
"True",
"eq_true",
"Filter.univ_mem",
"Eq",
"Filter",
"Set"
] |
Int.emod_minus_one | Init.Data.Int.DivMod.Lemmas | [
"congrArg",
"Int.emod_neg",
"instHMod",
"Int.instNegInt",
"Int.emod_one",
"Int",
"HMod.hMod",
"instOfNat",
"True",
"eq_self",
"of_eq_true",
"Int.instMod",
"congrFun'",
"OfNat.ofNat",
"Eq",
"Neg.neg",
"Eq.trans"
] |
CategoryTheory.StructuredArrow.mapIso | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | [
"CategoryTheory.Functor",
"CategoryTheory.Comma.mapLeftIso",
"CategoryTheory.Functor.category",
"CategoryTheory.Equivalence",
"CategoryTheory.Iso",
"CategoryTheory.discreteCategory",
"PUnit",
"CategoryTheory.Functor.const",
"CategoryTheory.instCategoryStructuredArrow",
"CategoryTheory.Functor.from... |
starL.congr_simp | Mathlib.Analysis.Calculus.FDeriv.Star | [
"starL",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
"ContinuousStar",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"RingHomInvPair.instStarRingEnd",
"StarAddMonoid.toInvolutiveStar",
"AddCommMonoid",
"CommSemiring",
"NonUnitalNonAssocSe... |
npow_one | Mathlib.Algebra.Group.NatPowAssoc | [
"NatPowAssoc.npow_one",
"Pow",
"instOfNatNat",
"HPow.hPow",
"Nat",
"instHPow",
"MulOneClass",
"OfNat.ofNat",
"Eq",
"NatPowAssoc"
] |
_private.Lean.Elab.Tactic.Conv.Simp.0.Lean.Elab.Tactic.Conv.evalSimp.match_1 | Lean.Elab.Tactic.Conv.Simp | [
"Lean.Meta.Simp.Result",
"Prod.mk",
"Prod",
"Prod.casesOn",
"Lean.Meta.Simp.Stats"
] |
_private.Mathlib.LinearAlgebra.Dimension.Finite.0.Module.exists_nontrivial_relation_sum_zero_of_finrank_succ_lt_card._simp_1_3 | Mathlib.LinearAlgebra.Dimension.Finite | [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"add_neg_eq_zero",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"SubtractionMonoid.toSubNegZeroMonoid",
"SubNegZeroMonoid.toNegZeroClass",
"instHAdd",
"AddGroup",
"AddGroup.toSubNegMonoid",
"HAdd.hAdd",
"propext",
"AddZero.toAdd"... |
Equiv.Perm.IsSwap.congr_simp | Mathlib.GroupTheory.Perm.Sign | [
"instSubsingletonDecidable",
"Decidable",
"Equiv.Perm.IsSwap",
"Eq.rec",
"Pi.instSubsingleton",
"Equiv.Perm",
"Eq.ndrec",
"Eq.refl",
"Subsingleton.elim",
"Eq",
"DecidableEq"
] |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.exists_subset_restrict_nonpos'._simp_1_2 | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | [
"False",
"Membership.mem",
"propext",
"Set.instEmptyCollection",
"Set.mem_empty_iff_false",
"EmptyCollection.emptyCollection",
"Eq",
"Set.instMembership",
"Set"
] |
Std.DHashMap.Raw.Const.getThenInsertIfNew? | Std.Data.DHashMap.Raw | [
"Std.DHashMap.Internal.Raw₀.Const.getThenInsertIfNew?",
"Std.DHashMap.Raw",
"Prod.mk",
"instOfNatNat",
"dite",
"Subtype.mk",
"Option.none",
"Nat",
"Std.DHashMap.Raw.buckets",
"LT.lt",
"Nat.decLt",
"Std.DHashMap.Internal.AssocList",
"Hashable",
"instLTNat",
"Prod",
"_private.Std.Data.DH... |
Lean.Parser.Command.declVal.parenthesizer | Lean.Parser.Command | [
"Lean.Parser.mkAntiquot.parenthesizer",
"Lean.PrettyPrinter.Parenthesizer",
"Bool.true",
"Lean.Parser.Command.declValSimple.parenthesizer",
"Lean.PrettyPrinter.Parenthesizer.withAntiquot.parenthesizer",
"Lean.PrettyPrinter.Parenthesizer.orelse.parenthesizer",
"Lean.Parser.Command.whereStructInst.parenth... |
instLawfulCommIdentityInt64HOrOfNat | Init.Data.SInt.Bitwise | [
"instHOrOfOrOp",
"Std.Identity.mk",
"Std.LeftIdentity.mk",
"Int64",
"Int64.or_zero",
"instOrOpInt64",
"Std.LawfulCommIdentity.mk",
"instCommutativeInt64HOr",
"HOr.hOr",
"Int64.instOfNat",
"Std.LawfulRightIdentity.mk",
"Std.LawfulCommIdentity",
"Std.Commutative.comm",
"OfNat.ofNat",
"Std.... |
StarAlgHom.prodEquiv._proof_1 | Mathlib.Algebra.Star.StarAlgHom | [
"Function.LeftInverse",
"StarAlgHom.snd",
"Algebra",
"Prod.instSemiring",
"Prod.mk",
"StarAlgHom",
"Prod.algebra",
"Prod.fst",
"CommSemiring",
"Prod.instStar",
"Star",
"Semiring",
"Eq.refl",
"StarAlgHom.fst",
"StarAlgHom.prod",
"Prod",
"StarAlgHom.comp",
"Prod.snd"
] |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Data.Html.2686543190._hygCtx._hyg.1.ctorElimType | ProofWidgets.Data.Html | [
"cond",
"ProofWidgets.RpcEncodablePacket.component._@.ProofWidgets.Data.Html.2686543190._hygCtx._hyg.1",
"Lean.Json",
"Nat.ble",
"ProofWidgets.RpcEncodablePacket.text._@.ProofWidgets.Data.Html.2686543190._hygCtx._hyg.1",
"PULift",
"Nat",
"ProofWidgets.RpcEncodablePacket.element._@.ProofWidgets.Data.Ht... |
InnerProductGeometry.norm_add_eq_add_norm_of_angle_eq_zero | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | [
"Mathlib.Tactic.Ring.mul_pp_pf_overlap",
"Real.instIsOrderedRing",
"Norm.norm",
"SeminormedAddGroup.toNorm",
"Eq.mpr",
"Mathlib.Tactic.Ring.pow_one",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tactic.Ring.single_pow",
"Mathlib.Meta.NormNum.isNat_add",
"Real.partialOrder",
"Real",
"HMu... |
Ordering.swap | Init.Data.Ord.Basic | [
"Ordering.gt",
"Ordering.swap.match_1",
"Ordering",
"Ordering.eq",
"Unit",
"Ordering.lt"
] |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateAltImp | Lean.Compiler.LCNF.Basic | [
"Lean.Compiler.LCNF.instInhabitedAlt",
"panicWithPosWithDecl",
"ptrEq",
"Bool.and",
"instDecidableEqBool",
"instOfNatNat",
"Lean.Compiler.LCNF.Purity",
"Lean.Compiler.LCNF.Purity.pure",
"Array",
"Bool.true",
"Lean.Compiler.LCNF.Code",
"Lean.Compiler.LCNF.Alt.alt",
"Nat",
"Bool",
"Lean.Na... |
Std.DHashMap.Raw.insert | Std.Data.DHashMap.Raw | [
"Std.DHashMap.Raw",
"instOfNatNat",
"dite",
"Subtype.mk",
"Std.DHashMap.Internal.Raw₀.insert",
"Nat",
"Std.DHashMap.Raw.buckets",
"LT.lt",
"Nat.decLt",
"Std.DHashMap.Internal.AssocList",
"Hashable",
"instLTNat",
"OfNat.ofNat",
"Subtype.val",
"BEq",
"Array.size",
"Not"
] |
Subsemigroup.map_injective_of_injective | Mathlib.Algebra.Group.Subsemigroup.Operations | [
"MulHom",
"Subsemigroup.map",
"GaloisCoinsertion.l_injective",
"Subsemigroup.comap",
"PartialOrder.toPreorder",
"Subsemigroup.instPartialOrder",
"Mul",
"Subsemigroup.gciMapComap",
"Subsemigroup",
"MulHom.funLike",
"Function.Injective",
"DFunLike.coe"
] |
Std.Internal.IO.Async.System.UserId.mk._flat_ctor | Std.Internal.Async.System | [
"Nat",
"Std.Internal.IO.Async.System.UserId.mk",
"Std.Internal.IO.Async.System.UserId"
] |
CategoryTheory.Limits.preservesLimitsOfSize_of_leftOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | [
"CategoryTheory.Limits.PreservesColimitsOfSize",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.Limits.PreservesLimitsOfSize.mk",
"CategoryTheory.Limits.PreservesColimitsOfSize.preservesColimitsOfShape",
"CategoryTheory.Limits.PreservesLimitsOfSize",
"CategoryTheory.Category.opposite",
"Categor... |
FirstOrder.Language.Term.substFunc._sunfold | Mathlib.ModelTheory.Syntax | [
"FirstOrder.Language.Term.subst",
"FirstOrder.Language.Term",
"FirstOrder.Language.Term.var",
"FirstOrder.Language.Term.substFunc",
"Nat",
"FirstOrder.Language.Functions",
"FirstOrder.Language.Term.substFunc.match_1",
"FirstOrder.Language",
"Fin"
] |
ZMod.χ₈'_eq_χ₄_mul_χ₈ | Mathlib.NumberTheory.LegendreSymbol.ZModChar | [
"ZMod.χ₈",
"HMul.hMul",
"ZMod.cast",
"ZMod.χ₄",
"of_decide_eq_true",
"ZMod.commRing",
"ZMod.fintype",
"CommSemiring.toCommMonoidWithZero",
"Int.instDecidableEq",
"id",
"MulChar",
"MulChar.instFunLike",
"instOfNatNat",
"Int",
"ZMod",
"Int.instMul",
"Bool.true",
"Nat.instNeZeroSucc",... |
Std.IterM.mk.inj | Init.Data.Iterators.Basic | [
"Std.IterM.mk",
"eq_of_heq",
"HEq",
"Std.IterM",
"Std.IterM.mk.noConfusion",
"Eq"
] |
_private.Mathlib.Logic.Equiv.Basic.0.Equiv.piCongrLeft'._proof_1 | Mathlib.Logic.Equiv.Basic | [
"False",
"Equiv.instEquivLike",
"Lean.Grind.nestedProof",
"eq_false",
"Equiv.symm_apply_apply",
"HEq.refl",
"Classical.byContradiction",
"HEq.trans",
"Exists",
"Eq.rec",
"Eq.mp",
"id",
"Equiv",
"Lean.Grind.forall_imp_eq_or",
"Lean.Grind.eqRec_heq",
"funext",
"Exists.casesOn",
"True... |
RingHom.FormallyUnramified.holdsForLocalization | Mathlib.RingTheory.RingHom.Unramified | [
"Eq.mpr",
"CommRing",
"IsLocalization",
"congrArg",
"CommSemiring.toSemiring",
"Algebra",
"Algebra.FormallyUnramified",
"algebraMap",
"RingHom.formallyUnramified_algebraMap",
"id",
"RingHom.HoldsForLocalization",
"NonAssocSemiring.toMulZeroOneClass",
"MulZeroOneClass.toMulOneClass",
"CommR... |
leftCoset_mem_leftCoset | Mathlib.GroupTheory.Coset.Basic | [
"Set.ext",
"SetLike.mem_coe._simp_1",
"instHSMul",
"Subgroup.instSubgroupClass",
"HMul.hMul",
"DivInvOneMonoid.toInvOneClass",
"Monoid.toMulOneClass",
"congrArg",
"Group",
"Group.toDivisionMonoid",
"Membership.mem",
"DivisionMonoid.toDivInvOneMonoid",
"MulOne.toMul",
"DivInvMonoid.toMonoid... |
Int8.minValue_le_toInt | Init.Data.SInt.Lemmas | [
"Int8.minValue",
"Int8",
"Int8.toInt",
"Int",
"LE.le",
"Int8.le_toInt",
"Int.instLEInt"
] |
_private.Init.Data.Char.Ordinal.0.Char.lt_iff_ofOrdinal_lt._simp_1_1 | Init.Data.Char.Ordinal | [
"LE.le",
"Std.LawfulOrderLT",
"LE",
"And",
"Std.lt_iff_le_and_not_ge",
"LT.lt",
"propext",
"Eq",
"Not",
"LT"
] |
Continuous.homeoOfEquivCompactToT2 | Mathlib.Topology.Homeomorph.Lemmas | [
"Homeomorph.mk",
"Continuous",
"Equiv.instEquivLike",
"Continuous.continuous_symm_of_equiv_compact_to_t2",
"Equiv",
"CompactSpace",
"TopologicalSpace",
"T2Space",
"Homeomorph",
"DFunLike.coe",
"EquivLike.toFunLike"
] |
Filter.EventuallyEq.hasFDerivWithinAt_iff | Mathlib.Analysis.Calculus.FDeriv.Congr | [
"Pure.pure",
"SProd.sprod",
"AddCommGroup.toAddCommMonoid",
"ContinuousLinearMap.funLike",
"nhdsWithin",
"HasFDerivWithinAt",
"NormedField.toField",
"AddCommGroup",
"Filter.EventuallyEq",
"Field.toSemifield",
"ContinuousLinearMap",
"TopologicalSpace",
"Filter.instPure",
"Iff",
"Semifield... |
_private.Mathlib.Analysis.SumIntegralComparisons.0.sum_mul_Ico_le_integral_of_monotone_antitone._proof_1_6 | Mathlib.Analysis.SumIntegralComparisons | [
"Lean.RArray.leaf",
"False",
"Lean.Grind.and_eq_of_eq_true_right",
"Preorder.toLT",
"congrArg",
"Int.Linear.le_norm_expr",
"Int.Linear.le_unsat",
"Classical.byContradiction",
"Nat.not_le_eq",
"Nat.ToInt.add_congr",
"Lean.Grind.Nat.lt_eq",
"Preorder.toLE",
"Eq.mp",
"Lean.RArray.branch",
"... |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple.0.RootPairing.GeckConstruction.instIsIrreducible._simp_1 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple | [
"CommRing",
"CommSemiring.toSemiring",
"Matrix",
"RingHom",
"Matrix.nonAssocSemiring",
"CommRing.toCommSemiring",
"RingHom.instFunLike",
"Fintype",
"RingHom.map_det",
"RingHom.mapMatrix",
"Eq.symm",
"Semiring.toNonAssocSemiring",
"Eq",
"DFunLike.coe",
"Matrix.det",
"DecidableEq"
] |
LaurentSeries.LaurentSeries_coe | Mathlib.RingTheory.LaurentSeries | [
"Int.instAddCommGroup",
"RatFunc.instFaithfulSMulPolynomialLaurentSeries",
"Int.instAddCommMonoid",
"Multiplicative.linearOrder",
"Int.instIsStrictOrderedRing",
"HahnSeries.instSemiring",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"CommSemiring.toSemiring",
"I... |
Holor.assocRight | Mathlib.Data.Holor | [
"cast",
"instHAppendOfAppend",
"List",
"Nat",
"Holor.assocRight._proof_1",
"Holor",
"List.instAppend",
"HAppend.hAppend"
] |
isStarProjection_iff' | Mathlib.Algebra.Star.StarProjection | [
"HMul.hMul",
"Mul",
"isStarProjection_iff",
"And",
"Iff",
"Star",
"Eq",
"IsStarProjection",
"instHMul",
"Star.star"
] |
_private.Mathlib.Logic.Equiv.Multiset.0.Denumerable.lower.match_1.eq_1 | Mathlib.Logic.Equiv.Multiset | [
"List.cons",
"List",
"Nat",
"Eq.refl",
"Denumerable.lower.match_1",
"Eq",
"List.nil"
] |
PresheafOfModules.epi_of_surjective | Mathlib.Algebra.Category.ModuleCat.Presheaf.EpiMono | [
"PresheafOfModules.evaluation",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.Epi",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"ModuleCat",
"LinearMap.ext",
"CategoryTheory.ConcreteCategory.hom",
"AddCommGroup.toAddCommMonoid",
"LinearMap.instFunLike",
"RingCat.ring",
"C... |
CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | [
"WithBotTop.coe",
"WithBot.instPreorder",
"CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat._proof_12",
"ComplexShape.spectralSequenceNat",
"CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat._proof_7",
"WithTop.instPreorder",
"CategoryTheory.Abelian.SpectralObject.coreE₂HomologicalNat... |
Interval.mulOneClass._proof_1 | Mathlib.Algebra.Order.Interval.Basic | [
"MulOne.toOne",
"WithBot.some",
"WithBot",
"HMul.hMul",
"CommMonoid.toCommSemigroup",
"Interval.mulOneClass._proof_2",
"IsOrderedMonoid",
"Monoid.toMulOneClass",
"Preorder.toLE",
"WithBot.map₂_coe_left",
"MulOne.toMul",
"NonemptyInterval.commMonoid._proof_1",
"Interval",
"LE.le",
"MulOne... |
AddCommMonoidWithOne.mk | Mathlib.Data.Nat.Cast.Defs | [
"AddMonoid.toAddSemigroup",
"AddCommMonoidWithOne",
"instHAdd",
"AddSemigroup.toAdd",
"AddCommMonoidWithOne.mk",
"HAdd.hAdd",
"AddMonoidWithOne.toAddMonoid",
"Eq",
"AddMonoidWithOne"
] |
Lean.Parser.Term.liftMethod._regBuiltin.Lean.Parser.Term.liftMethod.parenthesizer_15 | Lean.Parser.Do | [
"Lean.Name.mkStr5",
"IO",
"Lean.PrettyPrinter.Parenthesizer",
"Lean.PrettyPrinter.parenthesizerAttribute",
"Unit",
"Lean.Name.mkStr4",
"Lean.Parser.Term.liftMethod.parenthesizer",
"Lean.KeyedDeclsAttribute.addBuiltin"
] |
VAdd.ctorIdx | Mathlib.Algebra.Notation.Defs | [
"VAdd",
"Nat"
] |
_private.Mathlib.Analysis.Convex.Side.0.Affine.Simplex.sSameSide_affineSpan_faceOpposite_iff.match_1_1 | Mathlib.Analysis.Convex.Side | [
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"LinearOrder",
"PartialOrder.toPreorder",
"SignType.instLinearOrder",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"SemilatticeInf.toPartialOrder",
"DistribLattice.toLattice",
"NonUnitalNonAssocRing.toNonUnitalNonAssocSe... |
Std.DTreeMap.Internal.Impl.maxEntry?.eq_2 | Std.Data.DTreeMap.Internal.Model | [
"Std.DTreeMap.Internal.Impl.maxEntry?.eq_def",
"Std.DTreeMap.Internal.Impl.maxEntry?.match_1",
"Option.some",
"Std.DTreeMap.Internal.Impl.inner",
"Std.DTreeMap.Internal.Impl.maxEntry?",
"Option.none",
"Unit",
"Std.DTreeMap.Internal.Impl.leaf",
"Nat",
"Eq.refl",
"Sigma.mk",
"Eq",
"Std.DTreeMa... |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_countPBefore_of_lt_length_of_pos._proof_1_1 | Batteries.Data.List.Lemmas | [
"Lean.Grind.Nat.lt_eq",
"instOfNatNat",
"LE.le",
"instLENat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"LT.lt",
"Eq.substr",
"instAddNat",
"instLTNat",
"OfNat.ofNat",
"List.length",
"List.nil"
] |
Std.Roo._sizeOf_1 | Init.Data.Range.Polymorphic.PRange | [
"instOfNatNat",
"Std.Roo.rec",
"instHAdd",
"HAdd.hAdd",
"Nat",
"SizeOf.sizeOf",
"instAddNat",
"SizeOf",
"OfNat.ofNat",
"Std.Roo"
] |
_private.Mathlib.SetTheory.Cardinal.SchroederBernstein.0.Function.Embedding.total.match_1_3 | Mathlib.SetTheory.Cardinal.SchroederBernstein | [
"cond",
"ULift",
"Function.Embedding.mk",
"Function.Embedding",
"Bool.true",
"Function.Embedding.casesOn",
"Function.Injective",
"Bool.false"
] |
IsPrimitiveRoot.powerBasis_dim | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | [
"IsDomain",
"Nat.instMulZeroClass",
"CommRing",
"PowerBasis.dim",
"CommSemiring.toSemiring",
"Algebra",
"Set.instSingletonSet",
"IsCyclotomicExtension",
"Field.toSemifield",
"minpoly",
"CommRing.toCommSemiring",
"Nat",
"IsPrimitiveRoot.powerBasis",
"Eq.refl",
"Semifield.toCommSemiring",
... |
Pi.instCeilDiv._proof_3 | Mathlib.Algebra.Order.Floor.Div | [
"instHSMul",
"Preorder.toLT",
"Pi.addCommMonoid",
"SMulZeroClass",
"Pi.smulZeroClass",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddZeroClass.toAddZero",
"PartialOrder",
"LE.le",
"AddCommMonoid",
"CeilDiv.ceilDiv",
"AddZero.toZero",
"CeilDiv",
"Iff",
"L... |
Lean.Compiler.LCNF.Simp.CtorInfo._sizeOf_inst | Lean.Compiler.LCNF.Simp.DiscrM | [
"SizeOf.mk",
"Lean.Compiler.LCNF.Simp.CtorInfo",
"SizeOf",
"Lean.Compiler.LCNF.Simp.CtorInfo._sizeOf_1"
] |
FormalMultilinearSeries.congr_simp | Mathlib.Analysis.Analytic.Basic | [
"FormalMultilinearSeries",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"ContinuousConstSMul",
"AddCommMonoid",
"TopologicalSpace",
"AddZero.toZero",
"Semiring",
"Eq.refl",
"Module.toDistribMulAction",
"SMulZeroClass.t... |
Combinatorics.Line.ColorFocused.distinct_colors | Mathlib.Combinatorics.HalesJewett | [
"Multiset.Nodup",
"Multiset.map",
"Combinatorics.Line.AlmostMono.color",
"Combinatorics.Line.AlmostMono",
"Combinatorics.Line.ColorFocused.lines",
"Combinatorics.Line.ColorFocused",
"Option"
] |
WittVector.IsPoly₂.comp | Mathlib.RingTheory.WittVector.IsPoly | [
"WittVector.IsPoly₂.casesOn",
"Eq.mpr",
"instNeZeroNatHAdd_1",
"CommRing",
"Fintype.elems",
"MvPolynomial.algebra",
"MvPolynomial.aeval",
"WittVector.IsPoly",
"Nat.le_refl",
"Ring.toNonAssocRing",
"WittVector.peval",
"congrArg",
"CommSemiring.toSemiring",
"HEq.refl",
"AlgHom",
"Finset"... |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure.mk._flat_ctor | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | [
"_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure",
"_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure.mk",
"Lean.Name",
"Lean.Exception"
] |
CategoryTheory.Adjunction.commShiftIso_hom_app_counit_app_shift_assoc | Mathlib.CategoryTheory.Shift.Adjunction | [
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.comp",
"CategoryTheory.shiftFunctor",
"CategoryTheory.Functor.id",
"Eq.mp",
"id",
"Mathlib.Tactic.Reassoc.eq... |
Topology.WithUpper | Mathlib.Topology.Order.LowerUpperTopology | [] |
PFunctor.M.Agree'.recOn | Mathlib.Data.PFunctor.Univariate.M | [
"PFunctor",
"PFunctor.A",
"PFunctor.M",
"PFunctor.B",
"PFunctor.M.Agree'.step",
"PFunctor.M.Agree'.rec",
"PFunctor.M.Agree'",
"instOfNatNat",
"Nat",
"Sigma.mk",
"OfNat.ofNat",
"Nat.succ",
"Eq",
"PFunctor.M.Agree'.trivial",
"PFunctor.M.mk"
] |
Option.merge_none_left | Init.Data.Option.Lemmas | [
"Option.casesOn",
"Option.some",
"Option.merge",
"Option.none",
"Eq.ndrec",
"Eq.refl",
"Eq.symm",
"Eq",
"Option"
] |
CategoryTheory.Pi.instBraidedForallEval._proof_2 | Mathlib.CategoryTheory.Pi.Monoidal | [
"CategoryTheory.Pi.instMonoidalForallEval",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Pi.monoidalCategory",
"congrArg",
"CategoryTheory.MonoidalCategory",
"CategoryTheory.Pi.eval",
"CategoryTheory.Category.comp_id",
"CategoryTheory.pi",
"CategoryTheory.Functor.map",
... |
Aesop.BaseRuleSet.mk.injEq | Aesop.RuleSet | [
"Aesop.BaseRuleSet.mk.inj",
"Aesop.RuleName",
"Aesop.SafeRuleInfo",
"Eq.propIntro",
"Aesop.RulePatternIndex",
"Lean.PHashMap",
"Lean.injEq_helper",
"Aesop.UnsafeRuleInfo",
"Aesop.BaseRuleSet.mk",
"Lean.PHashSet",
"Aesop.RuleName.instBEq",
"Aesop.ForwardIndex",
"And",
"Aesop.Index",
"Aeso... |
_private.Mathlib.Util.Notation3.0.Mathlib.Notation3.exprToMatcher.match_12 | Mathlib.Util.Notation3 | [
"Lean.TSyntax",
"Prod.mk",
"Mathlib.Notation3.DelabKey",
"List.cons",
"List",
"Lean.SyntaxNodeKind",
"Prod",
"Prod.casesOn",
"Lean.Name.mkStr1",
"List.nil"
] |
Std.Time.Month.instLawfulEqOrdOffset | Std.Time.Date.Unit.Month | [
"Std.Time.Month.instOrdOffset",
"_private.Std.Time.Date.Unit.Month.0.Std.Time.Month.instLawfulEqOrdOffset._proof_1",
"Std.Time.Month.Offset",
"Std.LawfulEqOrd"
] |
BitVec.instRxcIsAlwaysFinite | Init.Data.Range.Polymorphic.BitVec | [
"BitVec.instRxcLawfulHasSize",
"BitVec",
"inferInstance",
"BitVec.instUpwardEnumerable",
"BitVec.instLawfulUpwardEnumerable",
"Std.Rxc.IsAlwaysFinite",
"Nat",
"instLEBitVec",
"Std.Rxc.instIsAlwaysFiniteOfLawfulHasSize",
"BitVec.instRxcHasSize"
] |
BddOrd.Iso.mk | Mathlib.Order.Category.BddOrd | [
"BddOrd.Iso.mk._proof_4",
"PartOrd.str",
"PartialOrder.toPreorder",
"Preorder.toLE",
"BddOrd.toPartOrd",
"CategoryTheory.Iso",
"BddOrd",
"OrderIso",
"CategoryTheory.Iso.mk",
"BddOrd.isBoundedOrder",
"BddOrd.Iso.mk._proof_3",
"OrderIso.symm",
"BddOrd.ofHom",
"instFunLikeOrderIso",
"BddOrd... |
_private.Mathlib.RingTheory.Smooth.StandardSmoothCotangent.0.Algebra.SubmersivePresentation.sectionCotangent_zero_of_notMem_range._proof_1_1 | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"of_eq_false",
"False",
"Set.mem_range",
"forall_not_of_not_exists",
"CommRing",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"Lean.Grind.nestedProof",
"eq_false",
"Lean.Grind.iff_eq",
"CommSemiring.toSemiring",
"... |
IsDiscrete.mono | Mathlib.Topology.Constructions | [
"IsDiscrete.to_subtype",
"HasSubset.Subset",
"TopologicalSpace",
"IsDiscrete.mk",
"IsDiscrete",
"DiscreteTopology.of_subset",
"Set.instHasSubset",
"Set"
] |
_private.Std.Time.Date.Basic.0.Std.Time.Millisecond.Offset.ofDays._proof_1 | Std.Time.Date.Basic | [
"Rat.instOfNat",
"Int.cast",
"instHDiv",
"of_decide_eq_true",
"Rat",
"Rat.instIntCast",
"id",
"HDiv.hDiv",
"Int",
"Bool.true",
"instOfNat",
"Bool",
"Eq.refl",
"OfNat.ofNat",
"instDecidableEqRat",
"Decidable.decide",
"Eq",
"Rat.instDiv"
] |
instAddCommMonoidWithOneENNReal._proof_16 | Mathlib.Data.ENNReal.Basic | [
"instAddCommMonoidWithOneENNReal._proof_5",
"NonAssocSemiring.toAddCommMonoidWithOne",
"AddMonoidWithOne.mk",
"One.mk",
"AddMonoid.toAddSemigroup",
"instAddCommMonoidWithOneENNReal._proof_10",
"Add.mk",
"instAddCommMonoidWithOneENNReal._proof_11",
"instAddCommMonoidWithOneENNReal._aux_3",
"instAdd... |
Option.bind_eq_none' | Init.Data.Option.Lemmas | [
"False",
"Option.ctorIdx",
"congrArg",
"False.elim",
"Option.casesOn",
"noConfusion_of_Nat",
"Option.some.injEq",
"Option.some",
"Option.bind",
"Ne",
"false_implies",
"forall_eq'._simp_1",
"iff_self",
"Option.none",
"Iff",
"_private.Init.Data.Option.Lemmas.0.Option.bind_eq_none'._simp_... |
_private.Mathlib.Data.Real.Archimedean.0.Real.exists_isLUB.match_1_4 | Mathlib.Data.Real.Archimedean | [
"Int.cast",
"Real.instLE",
"Real",
"instHDiv",
"Real.instRatCast",
"Rat",
"Membership.mem",
"Exists",
"Rat.instIntCast",
"HDiv.hDiv",
"Rat.cast",
"Int",
"LE.le",
"Nat.cast",
"And.casesOn",
"And",
"Exists.casesOn",
"Nat",
"And.intro",
"Exists.intro",
"Set.instMembership",
"R... |
MvQPF.Comp | Mathlib.Data.QPF.Multivariate.Constructions.Comp | [
"Nat",
"Fin2",
"TypeVec"
] |
AddMonoidHom.toMultiplicative | Mathlib.Algebra.Group.TypeTags.Hom | [
"MulOne.toOne",
"MonoidHom.instFunLike",
"Equiv.instEquivLike",
"AddMonoidHom.toMultiplicative._proof_1",
"MonoidHom",
"OneHom.mk",
"AddMonoidHom.toMultiplicative._proof_5",
"AddZeroClass.toAddZero",
"Equiv.mk",
"AddMonoidHom.mk",
"Multiplicative.mulOneClass",
"Equiv",
"MonoidHom.mk",
"Add... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.