name string | module string | deps list | allowCompletion bool |
|---|---|---|---|
EquivFunctor.mapEquiv_apply | Mathlib.Control.EquivFunctor | [
"Equiv.instEquivLike",
"EquivFunctor.mapEquiv",
"Equiv",
"EquivFunctor",
"Eq",
"DFunLike.coe",
"EquivFunctor.map",
"rfl",
"EquivLike.toFunLike"
] | true |
PosNum.testBit.eq_5 | Mathlib.Data.Num.Lemmas | [
"PosNum.bit1",
"instOfNatNat",
"Bool.true",
"Nat",
"Bool",
"Eq.refl",
"PosNum.testBit",
"PosNum",
"OfNat.ofNat",
"Eq"
] | true |
_private.Lean.Elab.Import.0.Lean.Elab.parseImports.match_1 | Lean.Elab.Import | [
"Lean.TSyntax",
"Prod.mk",
"Lean.Parser.ModuleParserState",
"List.cons",
"Lean.SyntaxNodeKind",
"Prod",
"Prod.casesOn",
"Lean.Name.mkStr4",
"Lean.MessageLog",
"List.nil"
] | false |
CategoryTheory.Epi.left_cancellation | Mathlib.CategoryTheory.Category.Basic | [
"CategoryTheory.Epi",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.comp",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"CategoryTheory.Category"
] | true |
Std.Time.Hour.instLEOffset._aux_1 | Std.Time.Time.Unit.Hour | [
"Rat.instOfNat",
"Std.Time.Hour.Offset",
"Rat",
"Std.Time.Internal.UnitVal",
"Int",
"LE.le",
"Std.Time.Internal.UnitVal.val",
"OfNat.ofNat",
"Int.instLEInt"
] | false |
Vector.findFinIdx?_subtype | Init.Data.Vector.Find | [
"Eq.mpr",
"Vector.findFinIdx?",
"Vector",
"congrArg",
"Array.findFinIdx?_subtype",
"Vector.casesOn",
"Function.comp",
"Vector.unattach_mk",
"Eq.rec",
"Array.findFinIdx?_subtype._proof_1",
"id",
"Subtype",
"Vector.unattach",
"Vector.findFinIdx?_congr",
"Subtype.mk",
"Array",
"Fin.cast... | true |
AffineIsometryEquiv._sizeOf_1 | Mathlib.Analysis.Normed.Affine.Isometry | [
"NormedCommRing.toNormedRing",
"Norm.norm",
"AffineEquiv.linear",
"Real",
"SeminormedAddCommGroup",
"NormedRing.toRing",
"NormedSpace",
"AddCommGroup.toAddCommMonoid",
"NormedSpace.toModule",
"instOfNatNat",
"AffineIsometryEquiv",
"NormedField",
"SeminormedAddCommGroup.toNorm",
"instHAdd",... | false |
String.startsWith_toSlice | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | [
"String.toSlice",
"String",
"String.Slice.startsWith",
"String.startsWith",
"String.Slice.Pattern.ForwardPattern",
"Bool",
"Eq",
"rfl"
] | true |
MeasureTheory.convolution_zero | Mathlib.Analysis.Convolution | [
"Eq.mpr",
"NormedCommRing.toSeminormedCommRing",
"Real",
"MeasureTheory.Measure",
"ContinuousLinearMap.map_zero",
"NormedSpace.toIsBoundedSMul",
"UniformContinuousConstSMul.to_continuousConstSMul",
"NormedSpace",
"ContinuousLinearMap.topologicalSpace",
"congrArg",
"DistribMulAction.toDistribSMul... | true |
CategoryTheory.Subobject.ofLEMk.eq_1 | Mathlib.CategoryTheory.Subobject.Basic | [
"CategoryTheory.Subobject.underlying",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"PartialOrder.toPreorder",
"CategoryTheory.Subobject.ofLE",
"Preorder.toLE",
"CategoryTheory.Subobject.underlyingIso",
"Preorder.smallCategory",
"LE.le",
"CategoryTheory.instPart... | true |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.initFn._@.Lean.Meta.Tactic.Simp.SimpTheorems.2970893097._hygCtx._hyg.2 | Lean.Meta.Tactic.Simp.SimpTheorems | [
"IO.mkRef",
"instMonadLiftT",
"IO",
"EIO",
"liftM",
"Std.HashMap.instEmptyCollection",
"Lean.Meta.SimpExtensionMap",
"Lean.Meta.SimpExtension",
"Lean.Name",
"IO.Error",
"IO.Ref",
"instMonadLiftTOfMonadLift",
"EmptyCollection.emptyCollection",
"BaseIO",
"Lean.Name.instBEq",
"instMonadLi... | false |
String.Slice.Pos.ofSlice_le_ofSlice_iff | Init.Data.String.Basic | [
"String.Slice.slice",
"_private.Init.Data.String.Basic.0.String.Slice.Pos.ofSlice_le_ofSlice_iff._simp_1_1",
"String.instLEPos_1",
"congrArg",
"String.Slice.Pos.offset",
"String.Slice",
"String.Slice.Pos.ofSlice",
"LE.le",
"instLENat",
"String.Pos.Raw",
"String.Pos.Raw.byteIdx_offsetBy",
"Nat.... | true |
Mathlib.Tactic.DefEqAbuse._aux_Mathlib_Tactic_DefEqAbuse___elabRules_Mathlib_Tactic_DefEqAbuse_defeqAbuseCmd_1 | Mathlib.Tactic.DefEqAbuse | [
"Pure.pure",
"Lean.TSyntax",
"Lean.MessageData",
"Unit.unit",
"Lean.Exception.internal",
"Lean.Elab.Command.Scope.header",
"Lean.Elab.Command.CommandElab",
"Std.instToFormatString",
"Except.ok",
"Lean.Elab.Command.Scope.mk",
"Lean.Elab.Command.Scope.currNamespace",
"instMonadExceptOfMonadExcep... | false |
Lean.Lsp.DocumentFilter.rec | Lean.Data.Lsp.Basic | [
"String",
"Lean.Lsp.DocumentFilter.mk",
"Lean.Lsp.DocumentFilter",
"Option"
] | false |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic.0.vectorSpan_range_eq_span_range_vsub_right_ne._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | [
"Set.mem_range",
"Membership.mem",
"Exists",
"propext",
"Set.range",
"Eq",
"Set.instMembership",
"Set"
] | false |
_private.Mathlib.GroupTheory.Index.0.Subgroup.finiteIndex_iInf'.match_1_1 | Mathlib.GroupTheory.Index | [
"Finset",
"Subtype.casesOn",
"Membership.mem",
"Subtype",
"Subtype.mk",
"Finset.instSetLike",
"SetLike.instMembership"
] | false |
Inner.noConfusionType | Mathlib.Analysis.InnerProductSpace.Defs | [
"Inner.casesOn",
"Inner",
"HEq"
] | false |
PUnit.mulActionWithZero._proof_1 | Mathlib.Algebra.Module.PUnit | [
"instHSMul",
"SMulWithZero.toSMulZeroClass",
"PUnit.smulWithZero",
"MonoidWithZero",
"MonoidWithZero.toMulZeroOneClass",
"PUnit",
"PUnit.instZero_mathlib",
"Zero.toOfNat0",
"HSMul.hSMul",
"SMulZeroClass.toSMul",
"MulZeroOneClass.toMulZeroClass",
"OfNat.ofNat",
"SMulZeroClass.smul_zero",
"E... | false |
Std.DTreeMap.keys | Std.Data.DTreeMap.Basic | [
"Std.DTreeMap",
"Ordering",
"Std.DTreeMap.inner",
"List",
"Std.DTreeMap.Internal.Impl.keys"
] | true |
_private.Mathlib.Algebra.Group.Units.Opposite.0.IsAddUnit.op.match_1_1 | Mathlib.Algebra.Group.Units.Opposite | [
"AddUnits.val",
"IsAddUnit",
"Exists.casesOn",
"AddMonoid",
"Exists.intro",
"Eq",
"AddUnits"
] | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.codeBlock.withIndentColumn._sparseCasesOn_4 | Lean.DocString.Parser | [
"Lean.Name.rec",
"Nat.ne_of_beq_eq_false",
"String",
"Nat.shiftRight",
"Nat.hasNotBit",
"instOfNatNat",
"Lean.Name.num",
"Lean.Name.ctorIdx",
"Lean.Name.str",
"Lean.Name.anonymous",
"Nat.land",
"Nat",
"Bool",
"Lean.Name",
"Eq.refl",
"OfNat.ofNat",
"Bool.false"
] | false |
ULift.divInvMonoid.eq_1 | Mathlib.Algebra.Group.ULift | [
"MulOne.toOne",
"ULift.inv",
"DivInvMonoid.toInv",
"Equiv.instEquivLike",
"Monoid.toMulOneClass",
"ULift.commSemigroup._proof_1",
"ULift.divInvMonoid._proof_2",
"ULift",
"DivInvMonoid.toZPow",
"ULift.divInvMonoid._proof_1",
"Equiv.ulift",
"Equiv",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
... | true |
RestrictedProduct.mapAlong_continuous | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | [
"Filter.instMembership",
"Iff.mpr",
"Eq.mpr",
"RestrictedProduct.continuous_rng_of_principal",
"Continuous",
"Filter.le_principal_iff",
"Pi.topologicalSpace",
"congrArg",
"Filter.eventually_principal._simp_1",
"RestrictedProduct.inclusion",
"Filter.Eventually",
"Filter.inter_mem",
"Continuou... | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.Ici_nsmul_eq.match_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | [
"False",
"False.elim",
"Ne",
"instOfNatNat",
"instHAdd",
"absurd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"Nat.zero",
"Eq.refl",
"OfNat.ofNat",
"Nat.succ",
"Eq",
"Nat.casesOn"
] | false |
Int8.shiftLeft | Init.Data.SInt.Basic | [
"BitVec.instOfNat",
"HShiftLeft.hShiftLeft",
"Int8",
"BitVec",
"instOfNatNat",
"Nat",
"BitVec.instHShiftLeft",
"Int8.ofUInt8",
"Int8.toBitVec",
"BitVec.smod",
"OfNat.ofNat",
"UInt8.ofBitVec"
] | true |
_private.Mathlib.Analysis.Analytic.CPolynomialDef.0.HasFiniteFPowerSeriesOnBall.eq_partialSum._simp_1_1 | Mathlib.Analysis.Analytic.CPolynomialDef | [
"Finset",
"Membership.mem",
"Finset.mem_range",
"Finset.range",
"Finset.instSetLike",
"Nat",
"LT.lt",
"propext",
"instLTNat",
"Eq",
"SetLike.instMembership"
] | false |
Quiver.zigzagSetoid.match_1 | Mathlib.Combinatorics.Quiver.ConnectedComponent | [
"Quiver.symmetrifyQuiver",
"Nonempty.intro",
"Quiver.Path",
"Quiver.Symmetrify",
"Nonempty.casesOn",
"Quiver",
"Nonempty"
] | false |
IsInvariantSubfield.mk._flat_ctor | Mathlib.FieldTheory.Fixed | [
"Monoid",
"IsInvariantSubfield.mk",
"instHSMul",
"DistribMulAction.toDistribSMul",
"AddMonoid.toAddZeroClass",
"AddGroupWithOne.toAddMonoidWithOne",
"Membership.mem",
"Field.toDivisionRing",
"AddZeroClass.toAddZero",
"DistribSMul.toSMulZeroClass",
"DivisionRing.toRing",
"Subfield.instSetLike",... | false |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.rcases.match_8 | Lean.Elab.Tactic.RCases | [
"Lean.Syntax.Ident",
"Lean.Syntax",
"Prod.mk",
"Prod",
"Prod.casesOn",
"Option"
] | false |
MeasureTheory.withDensityᵥ_add | Mathlib.MeasureTheory.VectorMeasure.WithDensity | [
"Eq.mpr",
"Real",
"MeasureTheory.Measure",
"MeasureTheory.Measure.withDensityᵥ",
"MeasurableSet",
"NormedSpace",
"AddMonoid.toAddSemigroup",
"congrArg",
"MeasureTheory.VectorMeasure.ext",
"AddCommGroup.toAddCommMonoid",
"MeasureTheory.VectorMeasure.measureOf'",
"PseudoMetricSpace.toUniformSpac... | true |
Set.fintypeOfFintypeImage | Mathlib.Data.Set.Finite.Basic | [
"Multiset.filterMap",
"Function.IsPartialInv",
"Set.fintypeOfFintypeImage._proof_1",
"Set.Elem",
"Fintype.ofFinset",
"Set.toFinset",
"Finset.val",
"Fintype",
"Set.image",
"Finset.mk",
"Set.fintypeOfFintypeImage._proof_2",
"Option",
"Set"
] | true |
_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.0.VectorField.mpullbackWithin_mlieBracketWithin_aux | Mathlib.Geometry.Manifold.VectorField.LieBracket | [
"ContinuousLinearMap.comp",
"Filter.instMembership",
"MDifferentiableAt.comp_mdifferentiableWithinAt",
"Set.mem_range_self",
"Eq.mpr",
"ContMDiffWithinAt.comp_of_eq",
"MDifferentiableWithinAt.differentiableWithinAt_mpullbackWithin_vectorField",
"ContMDiffWithinAt.mono",
"Set.inter_subset_inter_right... | true |
Aesop.LocalRuleSet.mk.sizeOf_spec | Aesop.RuleSet | [
"Aesop.LocalNormSimpRule._sizeOf_inst",
"Aesop.LocalRuleSet._sizeOf_inst",
"Aesop.LocalRuleSet.mk",
"instSizeOfDefault",
"Lean.Meta.Simp.Simprocs._sizeOf_inst",
"instOfNatNat",
"Aesop.BaseRuleSet._sizeOf_inst",
"Array._sizeOf_inst",
"Array",
"Aesop.LocalRuleSet",
"Lean.Meta.Simp.Simprocs",
"in... | true |
CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence_inverse_map_hom | Mathlib.CategoryTheory.Sites.Descent.DescentDataAsCoalgebra | [
"CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence._proof_3",
"CategoryTheory.Comonad.Coalgebra.a",
"Opposite",
"CategoryTheory.LocallyDiscrete.mk",
"CategoryTheory.Pseudofunctor.DescentDataAsCoalgebra.coalgebraEquivalence",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheor... | true |
AlgebraicGeometry.Scheme.range_fromSpecResidueField | Mathlib.AlgebraicGeometry.ResidueField | [
"AlgebraicGeometry.Spec",
"AlgebraicGeometry.Scheme",
"CommRingCat.carrier",
"AlgebraicGeometry.PresheafedSpace.carrier",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"CommRingCat",
"TopCat.instCategory",
"ContinuousMap",
"CommRingCat.instCategory",
"Set.instSingletonSet",
"Set.range_eq_... | true |
MonoidAlgebra.mapDomainRingEquiv_apply | Mathlib.Algebra.MonoidAlgebra.MapDomain | [
"MonoidAlgebra.semiring",
"Finsupp.instFunLike",
"Monoid",
"MulEquiv.instEquivLike",
"Monoid.toMulOneClass",
"RingEquiv.instEquivLike",
"MonoidAlgebra.instMul",
"MulOne.toMul",
"Distrib.toAdd",
"MulEquiv.toEquiv",
"instDistribOfSemiring",
"MulOneClass.toMulOne",
"MonoidAlgebra",
"Semiring"... | true |
Matroid.cRk_map_image._auto_1 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.Name.mkStr2",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
VectorAll._unsafe_rec | Mathlib.Data.Vector3 | [
"VectorAll._unsafe_rec",
"instOfNatNat",
"Vector3.nil",
"Vector3.cons",
"Vector3",
"Nat",
"OfNat.ofNat",
"Nat.succ",
"VectorEx.match_1"
] | false |
Std.DTreeMap.Raw.minKeyD_erase_eq_of_not_compare_minKeyD_eq | Std.Data.DTreeMap.Raw.Lemmas | [
"Std.DTreeMap.Raw.minKeyD",
"Std.DTreeMap.Raw.erase",
"Std.DTreeMap.Internal.Impl.minKeyD_erase!_eq_of_not_compare_minKeyD_eq",
"Ord.mk",
"Ordering",
"Ordering.eq",
"Std.DTreeMap.Raw.isEmpty",
"Std.TransCmp",
"Std.DTreeMap.Raw.WF.out",
"Std.DTreeMap.Raw.inner",
"Bool",
"Bool.false",
"Eq",
... | true |
CategoryTheory.MonoOver.mapIso._proof_5 | Mathlib.CategoryTheory.Subobject.MonoOver | [
"Eq.mpr",
"CategoryTheory.Over",
"CategoryTheory.Functor",
"CategoryTheory.MonoOver.mapIso._proof_3",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.eqToHom",
"CategoryTheory.eqToHom_app",
"CategoryTheory.Functor.category",
"CategoryTheory.Functor.congr_obj",... | false |
pow_nonneg._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Basic | [
"MulOne.toOne",
"pow_nonneg",
"MulZeroClass.toMul",
"Preorder.toLE",
"ZeroLEOneClass",
"LE.le",
"MulZeroOneClass.toMulOneClass",
"Monoid.toPow",
"MulOneClass.toMulOne",
"MonoidWithZero",
"PosMulMono",
"MonoidWithZero.toMulZeroOneClass",
"HPow.hPow",
"Nat",
"True",
"eq_true",
"Zero.to... | false |
Filter.Germ.coeRingHom | Mathlib.Order.Filter.Germ.Basic | [
"Filter.Germ.coeRingHom._proof_3",
"Filter.Germ.ofFun",
"NonAssocSemiring.toAddCommMonoidWithOne",
"MulOne.toOne",
"RingHom.mk",
"MonoidHom",
"Monoid.toMulOneClass",
"OneHom.mk",
"AddMonoid.toAddZeroClass",
"RingHom",
"Filter.Germ.coeRingHom._proof_4",
"AddZeroClass.toAddZero",
"MonoidHom.mk... | true |
Lean.Data.AC.evalList._sparseCasesOn_1.else_eq | Init.Data.AC | [
"Nat.shiftRight",
"Lean.Data.AC.evalList._sparseCasesOn_1",
"Nat.hasNotBit",
"instOfNatNat",
"List.cons",
"Bool.true",
"Nat.land",
"List",
"absurd",
"Nat",
"List.casesOn",
"Bool",
"Eq.ndrec",
"Nat.eq_of_beq_eq_true",
"Eq.refl",
"OfNat.ofNat",
"Eq.symm",
"Eq",
"List.ctorIdx",
"L... | false |
LSeries.logMul | Mathlib.NumberTheory.LSeries.Deriv | [
"Complex.log",
"HMul.hMul",
"Complex.instMul",
"Complex.instNatCast",
"Nat.cast",
"Nat",
"Complex",
"instHMul"
] | true |
Int.le_of_not_le | Init.Data.Int.Order | [
"Int.le_total",
"Or.resolve_left",
"Int",
"LE.le",
"Not",
"Int.instLEInt"
] | true |
Finset.card_inter_smul_inv | Mathlib.Combinatorics.Additive.Convolution | [
"instHSMul",
"instSMulOfMul",
"DivInvOneMonoid.toInvOneClass",
"Finset.divisionMonoid",
"Monoid.toMulOneClass",
"congrArg",
"Finset",
"Group",
"Group.toDivisionMonoid",
"DivisionMonoid.toDivInvOneMonoid",
"Finset.smulFinset",
"Finset.convolution",
"MulOne.toMul",
"DivInvMonoid.toMonoid",
... | true |
Topology.IsLowerSet.WithLowerSetHomeomorph | Mathlib.Topology.Order.UpperLowerSetTopology | [
"Topology.IsLowerSet.WithLowerSetHomeomorph._proof_1",
"Topology.WithLowerSet.ofLowerSet",
"Topology.WithLowerSet.instTopologicalSpace",
"Topology.IsLowerSet",
"TopologicalSpace",
"Homeomorph",
"Equiv.toHomeomorphOfIsInducing",
"Topology.WithLowerSet",
"Preorder"
] | true |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.eq_zero_of_comapDomain_eq_zero._simp_1_2 | Mathlib.Data.Finsupp.Basic | [
"Finset",
"Membership.mem",
"Finset.ext_iff",
"Iff",
"Finset.instSetLike",
"propext",
"Eq",
"SetLike.instMembership"
] | false |
intervalIntegral.intervalIntegral_pos_of_pos_on | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | [
"MeasureTheory.ae",
"Iff.mpr",
"Eq.mpr",
"Set.Ioc",
"InnerProductSpace.toNormedSpace",
"Real.partialOrder",
"Real.instLE",
"Real",
"MeasureTheory.Measure",
"Preorder.toLT",
"instIsAddHaarMeasureVolume",
"Real.lattice",
"MulZeroClass.toMul",
"Real.instZero",
"Real.instRCLike",
"congrArg... | true |
Nat.eq_or_lt_of_le._unsafe_rec | Init.Prelude | [
"Nat.zero_le",
"Nat.eq_or_lt_of_le._unsafe_rec",
"Eq.rec",
"instOfNatNat",
"LE.le",
"instLENat",
"instHAdd",
"Nat.not_succ_le_zero",
"absurd",
"Nat.le_of_succ_le_succ",
"HAdd.hAdd",
"Nat",
"LT.lt",
"instAddNat",
"Nat.zero",
"Or.inl",
"Or",
"instLTNat",
"OfNat.ofNat",
"Nat.eq_or... | false |
Std.instCoeDepAnyAsyncStreamOfAsyncStream | Std.Sync.StreamMap | [
"Std.AnyAsyncStream.mk",
"Std.AnyAsyncStream",
"CoeDep.mk",
"CoeDep",
"Std.Async.IO.AsyncStream"
] | true |
ShareCommon.StateFactoryImpl.setFind? | Init.ShareCommon | [
"ShareCommon.StateFactoryImpl.Set",
"ShareCommon.Object",
"ShareCommon.StateFactoryImpl",
"Option"
] | true |
List.forall₂_nil_left_iff._simp_1 | Mathlib.Data.List.Forall2 | [
"List.forall₂_nil_left_iff",
"List",
"propext",
"List.Forall₂",
"Eq",
"List.nil"
] | false |
AddMonoidAlgebra.nonAssocSemiring.eq_1 | Mathlib.Algebra.MonoidAlgebra.Defs | [
"NonAssocSemiring.mk",
"NonAssocSemiring.toAddCommMonoidWithOne",
"AddMonoidAlgebra.nonUnitalNonAssocSemiring",
"AddZeroClass.toAddZero",
"AddMonoidWithOne.toNatCast",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Nat.cast",
"AddMonoidAlgebra.nonAssocSemiring._proof_4",
"AddZero.toZero",
"AddZeroCla... | true |
Equiv.Perm.isCycleOn_swap | Mathlib.GroupTheory.Perm.Cycle.Basic | [
"Eq.mpr",
"MulOne.toOne",
"id.eq_1",
"Equiv.instEquivLike",
"Equiv.Perm.instOne",
"Monoid.toMulOneClass",
"congrArg",
"true_or",
"zpow_zero",
"Equiv.swap",
"DivInvMonoid.toZPow",
"Membership.mem",
"Eq.mp",
"zpow_one",
"Set.instSingletonSet",
"id",
"Insert.insert",
"Equiv.Perm.SameC... | true |
_private.Mathlib.Data.List.Lattice.0.List.bagInter_sublist_left._proof_1_4 | Mathlib.Data.List.Lattice | [
"False",
"eq_false",
"Lean.Grind.iff_eq",
"Classical.byContradiction",
"Eq.mp",
"id",
"instBEqOfDecidableEq",
"List.cons",
"List",
"Iff",
"List.erase",
"True",
"eq_true",
"List.Sublist",
"List.cons_sublist_cons",
"Eq.symm",
"Eq",
"Not",
"Eq.trans",
"List.bagInter",
"True.intr... | false |
CategoryTheory.ShortComplex.SnakeInput.mono_L₀_f | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | [
"CategoryTheory.Abelian.toPreadditive",
"Eq.mpr",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"CategoryTheory.ShortComplex.Hom.comm₁₂",
"Quiver.Hom",
"congrArg",
"CategoryTheory.ShortComplex.Hom.τ₁",
"CategoryTheory.ShortComplex.SnakeInput.L₀",
"CategoryTheory.ShortComplex.Sna... | true |
Localization.mk_eq_monoidOf_mk' | Mathlib.GroupTheory.MonoidLocalization.Basic | [
"Localization.mk",
"Monoid.toMulOneClass",
"Submonoid.LocalizationMap.mk'",
"Membership.mem",
"Subtype",
"Localization",
"Localization.mk_eq_monoidOf_mk'_apply",
"OreLocalization.instCommMonoid",
"funext",
"OreLocalization.oreSetComm",
"CommMonoid.toMonoid",
"Submonoid.instSetLike",
"Localiz... | true |
Mathlib.Tactic.ComputeDegree.natDegree_natCast_le | Mathlib.Tactic.ComputeDegree | [
"Eq.le",
"instOfNatNat",
"LE.le",
"instLENat",
"Nat.cast",
"Polynomial",
"Nat.instPreorder",
"Nat",
"Polynomial.natDegree_natCast",
"Semiring",
"Polynomial.natDegree",
"OfNat.ofNat",
"Polynomial.instNatCast"
] | true |
PresheafOfModules.evaluationJointlyReflectsColimits._proof_2 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | [
"PresheafOfModules.map",
"PresheafOfModules.evaluation",
"Eq.mpr",
"CategoryTheory.Limits.IsColimit.fac",
"CategoryTheory.Category.assoc",
"CategoryTheory.Functor",
"CategoryTheory.Limits.Cocone",
"CategoryTheory.Functor.mapCocone",
"Opposite",
"_private.Mathlib.Algebra.Category.ModuleCat.Presheaf... | false |
lt_add_iff_pos_left._simp_1 | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | [
"AddRightStrictMono",
"AddZeroClass.toAddZero",
"AddZero.toZero",
"instHAdd",
"AddZeroClass",
"AddRightReflectLT",
"HAdd.hAdd",
"LT.lt",
"propext",
"AddZero.toAdd",
"Zero.toOfNat0",
"OfNat.ofNat",
"Eq",
"lt_add_iff_pos_left",
"LT"
] | false |
Specialization.map_id | Mathlib.Topology.Specialization | [
"OrderHom.id",
"Specialization.instPreorder",
"TopologicalSpace",
"ContinuousMap.id",
"Specialization",
"Specialization.map",
"Eq",
"OrderHom",
"rfl"
] | true |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.modify_eq_empty_iff._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | [
"Bool.coe_iff_coe",
"Bool.true",
"Iff",
"propext",
"Bool",
"Eq"
] | false |
CategoryTheory.MorphismProperty.Over.mapPullbackAdj._proof_6 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | [
"CategoryTheory.MorphismProperty.IsStableUnderBaseChangeAlong",
"CategoryTheory.MorphismProperty",
"CategoryTheory.Limits.pullback",
"CategoryTheory.MorphismProperty.instIsStableUnderBaseChangeAlongOfIsStableUnderBaseChange",
"CategoryTheory.Comma.right",
"CategoryTheory.CategoryStruct.toQuiver",
"Quive... | false |
Matrix.IsSymm.fromBlocks | Mathlib.LinearAlgebra.Matrix.Symmetric | [
"Eq.mpr",
"Matrix.fromBlocks",
"Matrix.transpose_transpose",
"congrArg",
"Matrix",
"Sum",
"id",
"Matrix.fromBlocks_transpose",
"Matrix.transpose",
"True",
"eq_self",
"Matrix.IsSymm",
"of_eq_true",
"Eq.refl",
"congrFun'",
"Eq.symm",
"Eq",
"Eq.trans"
] | true |
ContinuousMapZero.nonUnitalStarAlgHom_postcomp._proof_3 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"instHSMul",
"Continuous",
"MonoidHom.instFunLike",
"SemilinearMapClass.toMulActionSemiHomClass",
"MonoidHom",
"NonUnitalAlgHomClass.instLinearMapClass",
"Monoid.toMulOneClass",
"congrArg",
"CommSemiring.toSemiring",
"DistribMulAction.toDistribSMul",
... | false |
Lean.Server.Reference.ci | Lean.Server.References | [
"Lean.Server.Reference",
"Lean.Elab.ContextInfo"
] | true |
_private.Mathlib.Combinatorics.Colex.0.Finset.Colex.singleton_le_singleton._simp_1_1 | Mathlib.Combinatorics.Colex | [
"Finset.Colex.toColex_le_singleton",
"Equiv.instEquivLike",
"Colex",
"Finset.Colex.instLE",
"Finset",
"PartialOrder.toPreorder",
"Preorder.toLE",
"Membership.mem",
"PartialOrder",
"Equiv",
"LE.le",
"And",
"Finset.instSetLike",
"propext",
"toColex",
"Finset.instSingleton",
"Singleton.... | false |
Mathlib.pp.mathlib.binderPredicates | Mathlib.Util.PPOptions | [
"Inhabited.default",
"instInhabitedBool",
"Lean.Option",
"Lean.instInhabitedOption",
"Bool"
] | true |
Set.iUnion_comm | Mathlib.Data.Set.Lattice | [
"iSup_comm",
"CompleteBooleanAlgebra.toCompleteLattice",
"Eq",
"Set.iUnion",
"CompleteAtomicBooleanAlgebra.toCompleteBooleanAlgebra",
"Set.instCompleteAtomicBooleanAlgebra",
"Set"
] | true |
CategoryTheory.mono_iff_isIso_fst | Mathlib.CategoryTheory.Limits.EpiMono | [
"Eq.mpr",
"CategoryTheory.Category.assoc",
"CategoryTheory.IsIso",
"CategoryTheory.Mono",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"congrArg",
"CategoryTheory.IsSplitEpi",
"Subtype.casesOn",
"CategoryTheory.Limits.WidePullbackShape.category",
"CategoryTheory.CategoryStruct.id",
... | true |
Mathlib.Tactic.AtomM.Context.mk._flat_ctor | Mathlib.Util.AtomM | [
"Lean.Expr",
"Lean.Meta.MetaM",
"Lean.Meta.Simp.Result",
"Lean.Meta.TransparencyMode",
"Mathlib.Tactic.AtomM.Context.mk",
"Mathlib.Tactic.AtomM.Context"
] | false |
Units.val_eq_neg_one | Mathlib.Algebra.Ring.Units | [
"Monoid",
"Units.val",
"Eq.mpr",
"MulOne.toOne",
"Monoid.toMulOneClass",
"Units.coe_neg_one",
"congrArg",
"Iff.rfl",
"Units.instNeg",
"Units",
"id",
"MulOne.toMul",
"Units.instOne",
"Units.val_inj",
"MulOneClass.toMulOne",
"Iff",
"propext",
"HasDistribNeg",
"One.toOfNat1",
"Has... | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.liftWith_trans._simp_1_1 | Std.Do.Triple.SpecLemmas | [
"Std.Do.SPred.entails",
"Std.Do.PostCond",
"Std.Do.Assertion",
"Std.Do.PostShape",
"Std.Do.WP",
"Std.Do.Triple.iff",
"Std.Do.PredTrans.apply",
"Std.Do.Triple",
"propext",
"Std.Do.PostShape.args",
"Eq",
"Std.Do.WP.wp"
] | false |
_private.Mathlib.Data.Finset.Lattice.Basic.0.Finset.instDistribLattice._simp_1 | Mathlib.Data.Finset.Lattice.Basic | [
"Finset",
"Membership.mem",
"HasSubset.Subset",
"Finset.instSetLike",
"Finset.subset_iff",
"propext",
"Finset.instHasSubset",
"Eq",
"SetLike.instMembership"
] | false |
TwoUniqueProds.instForall | Mathlib.Algebra.Group.UniqueProds.Basic | [
"Iff.mpr",
"Eq.mpr",
"exists_or",
"UniqueMul.of_image_filter",
"Finset.exists_of_one_lt_card_pi",
"UniqueMul",
"Pi.evalMulHom",
"HMul.hMul",
"Finset.Nonempty.image",
"SProd.sprod",
"_private.Mathlib.Algebra.Group.UniqueProds.Basic.0.TwoUniqueProds.instForall._simp_1",
"congrArg",
"Finset",
... | true |
Std.HashMap.Raw.mem_of_mem_filterMap | Std.Data.HashMap.RawLemmas | [
"Std.HashMap.Raw.WF.out",
"Membership.mem",
"Std.HashMap.Raw.WF",
"LawfulHashable",
"Std.HashMap.Raw",
"EquivBEq",
"Std.HashMap.Raw.filterMap",
"Std.HashMap.Raw.inner",
"Std.HashMap.Raw.instMembershipOfBEqOfHashable",
"Hashable",
"Std.DHashMap.Raw.mem_of_mem_filterMap",
"BEq",
"Option"
] | true |
MulRingNorm.toAddGroupNorm | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | [
"AddGroupWithOne.toAddGroup",
"MulRingNorm.toMulRingSeminorm",
"MulRingNorm",
"NonAssocRing",
"MulRingSeminorm.toAddGroupSeminorm",
"NonAssocRing.toAddCommGroupWithOne",
"MulRingNorm.eq_zero_of_map_eq_zero'",
"AddGroupNorm",
"AddCommGroupWithOne.toAddGroupWithOne",
"AddGroupNorm.mk"
] | true |
nnnorm_apply_le_nnnorm_cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | [
"Lean.Syntax.node",
"Array.push",
"Lean.Syntax",
"Array.empty",
"Lean.SourceInfo.none",
"Lean.Name.mkStr1",
"Lean.Name.mkStr4",
"Lean.mkAtom"
] | false |
CategoryTheory.InducedWideCategory.congr_simp | Mathlib.CategoryTheory.Widesubcategory | [
"CategoryTheory.MorphismProperty",
"Eq.rec",
"CategoryTheory.InducedWideCategory",
"Eq.ndrec",
"Eq.refl",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"CategoryTheory.MorphismProperty.IsMultiplicative",
"CategoryTheory.Category"
] | true |
Algebra.IsInvariant.exists_smul_of_under_eq_of_profinite | Mathlib.RingTheory.Invariant.Profinite | [
"Subalgebra.instSetLike",
"MulSemiringAction.toRingAut",
"QuotientGroup.map",
"Monoid",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"RingHom.instRingHomClass",
"CategoryTheory.isCofilteredOrEmpty_of_directed_ge",
"Submodule.instAddCommMonoidWithOne",
"CategoryTheory.Functor",
"CommRing"... | true |
Algebra.Extension.Hom.mk.inj | Mathlib.RingTheory.Extension.Basic | [
"Algebra.Extension.Hom.mk",
"CommRing",
"Algebra.Extension.commRing",
"Algebra.algebraMap",
"CommSemiring.toSemiring",
"Algebra",
"RingHom",
"Algebra.toModule",
"Algebra.id",
"Algebra.Extension.Hom.mk.noConfusion",
"Algebra.Extension.Ring",
"IsScalarTower.left",
"CommRing.toCommSemiring",
... | true |
Lean.Meta.Grind.Arith.Linear.geAvoiding._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Linear.Search | [
"Rat.instOfNat",
"Rat",
"instDecidableEqBool",
"Array",
"Lean.Meta.Grind.Arith.Linear.inDiseqValues",
"Bool.true",
"instHAdd",
"HAdd.hAdd",
"Rat.instAdd",
"Bool",
"Lean.Meta.Grind.Arith.Linear.geAvoiding._unsafe_rec",
"Prod",
"OfNat.ofNat",
"Eq",
"Lean.Meta.Grind.Arith.Linear.DiseqCnstr"... | false |
Std.HashMap.Raw.getElem?_insert | Std.Data.HashMap.RawLemmas | [
"Std.HashMap.Raw.WF.out",
"Option.some",
"Membership.mem",
"instDecidableEqBool",
"Std.HashMap.Raw.WF",
"LawfulHashable",
"Std.HashMap.Raw",
"Std.DHashMap.Raw.Const.get?_insert",
"Bool.true",
"BEq.beq",
"EquivBEq",
"Std.HashMap.Raw.instGetElem?Mem",
"Std.HashMap.Raw.insert",
"Bool",
"Std... | true |
_private.Mathlib.Analysis.Real.Sqrt.0.Real.sq_le._simp_1_1 | Mathlib.Analysis.Real.Sqrt | [
"NegZeroClass.toNeg",
"abs",
"AddCommGroup.toAddCommMonoid",
"abs_le",
"LinearOrder",
"PartialOrder.toPreorder",
"Preorder.toLE",
"AddCommGroup.toAddGroup",
"SemilatticeInf.toPartialOrder",
"AddCommGroup",
"DistribLattice.toLattice",
"SubtractionMonoid.toSubNegZeroMonoid",
"LE.le",
"SubNeg... | false |
Perfection.coeff_mk | Mathlib.RingTheory.Perfection | [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.Prime",
"Perfection",
"CommSemiring.toSemiring",
"RingHom",
"Fact",
"instOfNatNat",
"AddCommMonoidWithOne.toAddMonoidWithOne",
"Subtype.mk",
"Monoid.toPow",
"CommSemiring",
"instHAdd",
"RingHom.instFunLike",
"HPow.hPow",
"HAdd.hAdd",
"Per... | true |
Function.Semiconj.comp_eq | Mathlib.Logic.Function.Conjugate | [
"Function.comp",
"Iff.mp",
"Function.Semiconj",
"Eq",
"Function.semiconj_iff_comp_eq"
] | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.recv.match_1 | Std.Sync.Channel | [
"Option.ctorIdx",
"_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.trySend._sparseCasesOn_1",
"Option.some",
"Nat.hasNotBit",
"Option"
] | false |
_private.Mathlib.Data.DFinsupp.Multiset.0.DFinsupp.toMultiset_le_toMultiset._simp_1_1 | Mathlib.Data.DFinsupp.Multiset | [
"Nat.instMulZeroClass",
"AddMonoid.toAddZeroClass",
"PartialOrder.toPreorder",
"DFinsupp.addZeroClass'",
"Multiset.instAddCancelCommMonoid",
"Preorder.toLE",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"Multiset",
"LE.le",
"instLENat",
"Nat",
"AddCancelCommMonoid.toAddCommMonoid",
"prop... | false |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.mkBaseNameCore.visit.eq_def | Lean.Elab.DeclNameGen | [
"Pure.pure",
"_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.mkBaseNameCore.visit",
"StateRefT'.instAlternativeOfMonad",
"Lean.Core.instMonadLiftIOCoreM",
"IO.instMonadLiftSTRealWorldBaseIO",
"modify",
"Lean.Expr.instBEq",
"String",
"Lean.Meta.State",
"instMonadLiftT",
"MonadState.ge... | true |
_private.Mathlib.Data.DFinsupp.Lex.0.DFinsupp.lt_trichotomy_rec._proof_2 | Mathlib.Data.DFinsupp.Lex | [
"Equiv.instEquivLike",
"LinearOrder.toDecidableEq",
"Lex",
"Finset",
"LinearOrder",
"Finset.min",
"Equiv",
"Finset.instEmptyCollection",
"Finset.min_eq_top",
"WithTop.top",
"DFinsupp.neLocus",
"Iff.mp",
"DFinsupp",
"EmptyCollection.emptyCollection",
"Top.top",
"Eq",
"DFunLike.coe",
... | false |
Lean.Meta.Simp.Arith.Int.ToLinear.State.varMap._default | Lean.Meta.Tactic.Simp.Arith.Int.Basic | [
"Lean.Meta.KExprMap.mk",
"Lean.instBEqHeadIndex",
"Lean.Expr",
"id",
"Lean.PersistentHashMap.Node.entries",
"Lean.PersistentHashMap.mk",
"Lean.instHashableHeadIndex",
"Nat",
"Lean.AssocList",
"Lean.PersistentHashMap.mkEmptyEntriesArray",
"Lean.Meta.KExprMap",
"Lean.HeadIndex"
] | false |
_private.Lean.Elab.DocString.0.Lean.Doc.checkUnsolvedDocMVars.match_1 | Lean.Elab.DocString | [
"Option.ctorIdx",
"_private.Lean.Elab.DocString.0.Lean.Doc.getModState._sparseCasesOn_1",
"Option.some",
"Lean.Expr",
"Nat.hasNotBit",
"Option"
] | false |
Set.Definable.image_comp_equiv | Mathlib.ModelTheory.Definability | [
"Eq.mpr",
"Equiv.apply_symm_apply",
"Equiv.instEquivLike",
"Set.Definable",
"congrArg",
"Equiv.symm_apply_apply",
"Set.Definable.preimage_comp",
"Function.comp",
"Eq.mp",
"id",
"Equiv",
"funext",
"FirstOrder.Language.Structure",
"Set.preimage",
"Set.image_eq_preimage_of_inverse",
"cong... | true |
_private.Init.Data.Array.Lemmas.0.Array.back?_eq_none_iff._proof_1_3 | Init.Data.Array.Lemmas | [
"False",
"Lean.Omega.Constraint.not_sat'_of_isImpossible",
"of_decide_eq_true",
"le_of_le_of_eq",
"Lean.Omega.Constraint.mk",
"Lean.Omega.Constraint.combine_sat'",
"Int.add_one_le_of_lt",
"HSub.hSub",
"Lean.Omega.Int.ofNat_sub_dichotomy",
"Lean.Omega.Int.add_congr",
"Classical.propDecidable",
... | false |
Std.ExtDTreeMap.Const.mem_toList_iff_get?_eq_some | Std.Data.ExtDTreeMap.Lemmas | [
"Std.ExtDTreeMap.Const.toList",
"Std.DTreeMap.Const.mem_toList_iff_get?_eq_some",
"Std.DTreeMap",
"Option.some",
"Membership.mem",
"Ordering",
"Prod.mk",
"Std.TransCmp",
"Std.ExtDTreeMap.Const.get?",
"List",
"Iff",
"List.instMembership",
"Std.LawfulEqCmp",
"Std.ExtDTreeMap.inductionOn",
... | true |
MeasureTheory.DominatedFinMeasAdditive.of_le | Mathlib.MeasureTheory.Integral.FinMeasAdditive | [
"Real.instIsOrderedRing",
"Norm.norm",
"Real.partialOrder",
"Real.instLE",
"Real",
"MeasureTheory.Measure",
"Preorder.toLT",
"SeminormedAddCommGroup",
"HMul.hMul",
"MeasurableSet",
"Real.instZero",
"PartialOrder.toPreorder",
"MeasureTheory.measureReal_nonneg",
"MeasureTheory.Measure.real",... | true |
prod_properSpace | Mathlib.Topology.MetricSpace.ProperSpace | [
"Set.instSProd",
"Eq.mpr",
"Real",
"SProd.sprod",
"congrArg",
"IsCompact.prod",
"PseudoMetricSpace.toUniformSpace",
"id",
"Prod.mk",
"ProperSpace",
"closedBall_prod_same",
"PseudoMetricSpace",
"PseudoEMetricSpace.toUniformSpace",
"Prod.pseudoMetricSpaceMax",
"ProperSpace.mk",
"ProperSp... | true |
Lean.Meta.SolveByElim.saturateSymm | Lean.Meta.Tactic.SolveByElim | [
"Pure.pure",
"Lean.MonadError.mk",
"Lean.instMonadExceptOfExceptionCoreM",
"instMonadExceptOfMonadExceptOf",
"Lean.MonadError.toMonadExceptOf",
"Lean.Meta.State",
"Lean.instAddErrorMessageContextOfAddMessageContextOfMonad",
"Option.some",
"Lean.MonadQuotation.toMonadRef",
"Lean.Expr",
"Lean.Meta... | true |
Preord.ofHom_id | Mathlib.Order.Category.Preord | [
"OrderHom.id",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.id",
"Preord.instCategory",
"Preord",
"Preord.ofHom",
"CategoryTheory.Category.toCategoryStruct",
"Eq",
"rfl",
"Preorder",
"Preord.of"
] | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.