name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.DHashMap.Const.isEmpty_of_isEmpty_insertManyIfNewUnit | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α fun x => Unit} {ρ : Type w} [inst : ForIn Id ρ α]
[EquivBEq α] [LawfulHashable α] {l : ρ},
(Std.DHashMap.Const.insertManyIfNewUnit m l).isEmpty = true → m.isEmpty = true |
EStateM.run_throw | Init.Control.Lawful.Instances | ∀ {ε σ : Type u_1} (e : ε) (s : σ), (throw e).run s = EStateM.Result.error e s |
ConvexBody.ext_iff | Mathlib.Analysis.Convex.Body | ∀ {V : Type u_1} [inst : TopologicalSpace V] [inst_1 : AddCommGroup V] [inst_2 : Module ℝ V] {K L : ConvexBody V},
K = L ↔ ↑K = ↑L |
Equiv.swapCore_self | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] (r a : α), Equiv.swapCore a a r = r |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations.0.RootPairing.GeckConstruction.lie_e_f_ne._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b |
CategoryTheory.monoidalOfHasFiniteProducts.associator_inv_snd | Mathlib.CategoryTheory.Monoidal.OfHasFiniteProducts | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasTerminal C]
[inst_2 : CategoryTheory.Limits.HasBinaryProducts C] (X Y Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv
CategoryTheory.Limits.prod.snd =
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd CategoryTheory.Limits.prod.snd |
Lean.Elab.Tactic.instInhabitedState | Lean.Elab.Term.TermElabM | Inhabited Lean.Elab.Tactic.State |
instRightDistribClassOrderDual | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [inst : Mul R] [inst_1 : Add R] [h : RightDistribClass R], RightDistribClass Rᵒᵈ |
_private.Mathlib.Data.Finset.Card.0.Finset.card_insert_le._proof_1_1 | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), (insert a s).card ≤ s.card + 1 |
Affine.Simplex.centroidWeightsWithCircumcenter.eq_2 | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {n : ℕ} (fs : Finset (Fin (n + 1))),
Affine.Simplex.centroidWeightsWithCircumcenter fs Affine.Simplex.PointsWithCircumcenterIndex.circumcenterIndex = 0 |
IsPreconnected.eq_or_eq_neg_of_sq_eq | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_2} {𝕜 : Type u_3} {f g : α → 𝕜} {S : Set α} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace 𝕜]
[T1Space 𝕜] [inst_3 : Field 𝕜] [ContinuousInv₀ 𝕜] [ContinuousMul 𝕜],
IsPreconnected S →
ContinuousOn f S →
ContinuousOn g S → Set.EqOn (f ^ 2) (g ^ 2) S → (∀ {x : α}, x ∈ S → g x ≠ 0) → Set.EqOn f g S ∨ Set.EqOn f (-g) S |
CategoryTheory.SimplicialObject.Augmented.whiskering._proof_3 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {X Y : CategoryTheory.Functor C D} (η : X ⟶ Y)
⦃X_1 Y_1 : CategoryTheory.SimplicialObject.Augmented C⦄ (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.SimplicialObject.Augmented.whiskeringObj C D X).map f)
{ left := CategoryTheory.Functor.whiskerLeft (CategoryTheory.SimplicialObject.Augmented.drop.obj Y_1) η,
right := η.app (CategoryTheory.SimplicialObject.Augmented.point.obj Y_1), w := ⋯ } =
CategoryTheory.CategoryStruct.comp
{ left := CategoryTheory.Functor.whiskerLeft (CategoryTheory.SimplicialObject.Augmented.drop.obj X_1) η,
right := η.app (CategoryTheory.SimplicialObject.Augmented.point.obj X_1), w := ⋯ }
((CategoryTheory.SimplicialObject.Augmented.whiskeringObj C D Y).map f) |
Lean.Grind.instLEUSizeUintNumBits | Init.GrindInstances.ToInt | Lean.Grind.ToInt.LE USize (Lean.Grind.IntInterval.uint System.Platform.numBits) |
AbsoluteValue._sizeOf_1 | Mathlib.Algebra.Order.AbsoluteValue.Basic | {R : Type u_5} →
{S : Type u_6} →
{inst : Semiring R} →
{inst_1 : Semiring S} → {inst_2 : PartialOrder S} → [SizeOf R] → [SizeOf S] → AbsoluteValue R S → ℕ |
String.Pos.Raw.offsetBy_sliceRawEndPos_left | Init.Data.String.Defs | ∀ {p : String.Pos.Raw} {s : String.Slice}, s.rawEndPos.offsetBy p = p + s |
HasDerivWithinAt.lhopital_zero_nhdsWithin_convex | Mathlib.Analysis.Calculus.LHopital | ∀ {a : ℝ} {l : Filter ℝ} {f f' g g' : ℝ → ℝ} {s : Set ℝ},
Convex ℝ s →
(∀ᶠ (x : ℝ) in nhdsWithin a (s \ {a}), HasDerivWithinAt f (f' x) (s \ {a}) x) →
(∀ᶠ (x : ℝ) in nhdsWithin a (s \ {a}), HasDerivWithinAt g (g' x) (s \ {a}) x) →
(∀ᶠ (x : ℝ) in nhdsWithin a (s \ {a}), g' x ≠ 0) →
Filter.Tendsto f (nhdsWithin a (s \ {a})) (nhds 0) →
Filter.Tendsto g (nhdsWithin a (s \ {a})) (nhds 0) →
Filter.Tendsto (fun x => f' x / g' x) (nhdsWithin a (s \ {a})) l →
Filter.Tendsto (fun x => f x / g x) (nhdsWithin a (s \ {a})) l |
_private.Mathlib.NumberTheory.ArithmeticFunction.Misc.0.ArithmeticFunction.sum_Ioc_mul_eq_sum_sum._simp_1_2 | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α} {a : α}, (a ∈ Finset.filter p s) = (a ∈ s ∧ p a) |
_private.Lean.Linter.UnusedSimpArgs.0.Lean.Linter.unusedSimpArgs.match_4 | Lean.Linter.UnusedSimpArgs | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) →
((range : Lean.Syntax.Range) → motive (some range)) → ((x : Option Lean.Syntax.Range) → motive x) → motive x |
CategoryTheory.instAdditiveObjFunctorAdditiveFunctor | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.Preadditive D] (F : C ⥤+ D), F.obj.Additive |
_private.Mathlib.Combinatorics.SimpleGraph.StronglyRegular.0.SimpleGraph.IsSRGWith.param_eq._simp_1_8 | Mathlib.Combinatorics.SimpleGraph.StronglyRegular | ∀ {α : Sort u} (a b : α), (¬a = b) = (a ≠ b) |
Aesop.CasesTarget.patterns | Aesop.RuleTac.Basic | Array Aesop.CasesPattern → Aesop.CasesTarget |
Lean.Parser.Command.tactic_extension | Lean.Parser.Command | Lean.Parser.Parser |
Stream'.Seq.zipWith_map_right | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} {β' : Type v'} (s₁ : Stream'.Seq α) (s₂ : Stream'.Seq β) (f : β → β')
(g : α → β' → γ), Stream'.Seq.zipWith g s₁ (Stream'.Seq.map f s₂) = Stream'.Seq.zipWith (fun a b => g a (f b)) s₁ s₂ |
_private.Init.Data.List.Erase.0.List.filterMap.match_1.eq_1 | Init.Data.List.Erase | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match none with
| none => h_1 ()
| some b => h_2 b) =
h_1 () |
LinearMap.tracePositiveLinearMap._proof_1 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
SMulCommClass 𝕜 𝕜 E |
Lean.Meta.Sym.ProofInstArgInfo.noConfusion | Lean.Meta.Sym.SymM | {P : Sort u} → {t t' : Lean.Meta.Sym.ProofInstArgInfo} → t = t' → Lean.Meta.Sym.ProofInstArgInfo.noConfusionType P t t' |
OrderIso.dualAntisymmetrization._proof_6 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u_1) [inst : Preorder α] (a : (Antisymmetrization α fun x1 x2 => x1 ≤ x2)ᵒᵈ),
Quotient.map' id ⋯ (Quotient.map' id ⋯ a) = a |
RingHom.ENatMap._proof_1 | Mathlib.Data.ENat.Basic | ∀ {S : Type u_1} [inst : CommSemiring S] [inst_1 : DecidableEq S] [inst_2 : Nontrivial S] (f : ℕ →+* S)
(hf : Function.Injective ⇑f), (↑(f.toMonoidWithZeroHom.ENatMap hf)).toFun 1 = 1 |
CompactExhaustion.iUnion_eq | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] (K : CompactExhaustion X), ⋃ n, K n = Set.univ |
MeasureTheory.measureReal_diff._auto_1 | Mathlib.MeasureTheory.Measure.Real | Lean.Syntax |
SimpleGraph.Walk.getVert_eq_support_getElem? | Mathlib.Combinatorics.SimpleGraph.Walks.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {n : ℕ} (p : G.Walk u v), n ≤ p.length → some (p.getVert n) = p.support[n]? |
Metric.ediam_pos_iff' | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} {s : Set X} [inst : EMetricSpace X], 0 < Metric.ediam s ↔ ∃ x ∈ s, ∃ y ∈ s, x ≠ y |
Std.ExtDHashMap.get?_eq_none_of_contains_eq_false | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {a : α},
m.contains a = false → m.get? a = none |
Pi.distrib | Mathlib.Algebra.Ring.Pi | {I : Type u} → {f : I → Type v} → [(i : I) → Distrib (f i)] → Distrib ((i : I) → f i) |
Subsemiring.mem_unop | Mathlib.Algebra.Ring.Subsemiring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocSemiring R] {x : R} {S : Subsemiring Rᵐᵒᵖ}, x ∈ S.unop ↔ MulOpposite.op x ∈ S |
LieAlgebra.Extension.casesOn | Mathlib.Algebra.Lie.Extension | {R : Type u_1} →
{N : Type u_2} →
{M : Type u_4} →
[inst : CommRing R] →
[inst_1 : LieRing N] →
[inst_2 : LieAlgebra R N] →
[inst_3 : LieRing M] →
[inst_4 : LieAlgebra R M] →
{motive : LieAlgebra.Extension R N M → Sort u} →
(t : LieAlgebra.Extension R N M) →
((L : Type u_5) →
(instLieRing : LieRing L) →
(instLieAlgebra : LieAlgebra R L) →
(incl : N →ₗ⁅R⁆ L) →
(proj : L →ₗ⁅R⁆ M) →
(IsExtension : LieAlgebra.IsExtension incl proj) →
motive
{ L := L, instLieRing := instLieRing, instLieAlgebra := instLieAlgebra,
incl := incl, proj := proj, IsExtension := IsExtension }) →
motive t |
SSet.Truncated.HomotopyCategory.homToNerveMk_app_edge | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | ∀ {X : SSet.Truncated 2} {C : Type u} [inst : CategoryTheory.SmallCategory C]
(F : CategoryTheory.Functor X.HomotopyCategory C)
{x y : X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := _proof_11✝ })} (e : SSet.Truncated.Edge x y),
(SSet.Truncated.HomotopyCategory.homToNerveMk F).app
(Opposite.op { obj := SimplexCategory.mk 1, property := SSet.Truncated.Edge._proof_2 }) e.edge =
CategoryTheory.ComposableArrows.mk₁ (F.map (SSet.Truncated.HomotopyCategory.homMk e)) |
PFunctor.M.IsPath.cons | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} (xs : PFunctor.Approx.Path F) {a : F.A} (x : F.M) (f : F.B a → F.M) (i : F.B a),
x = PFunctor.M.mk ⟨a, f⟩ → PFunctor.M.IsPath xs (f i) → PFunctor.M.IsPath (⟨a, i⟩ :: xs) x |
Std.ExtDHashMap.Const.size_alter_le_size | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β}, (Std.ExtDHashMap.Const.alter m k f).size ≤ m.size + 1 |
RingEquiv.map_sub | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S] (f : R ≃+* S)
(x y : R), f (x - y) = f x - f y |
Std.Internal.List.getKey?_filter_containsKey_of_containsKey_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((a : α) × β a)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = true →
Std.Internal.List.getKey? k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) =
Std.Internal.List.getKey? k l₁ |
HomotopicalAlgebra.Precylinder.LeftHomotopy.refl._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (P : HomotopicalAlgebra.Precylinder X) {Y : C}
(f : X ⟶ Y), CategoryTheory.CategoryStruct.comp P.i₀ (CategoryTheory.CategoryStruct.comp P.π f) = f |
CategoryTheory.yoneda_preservesLimits | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
CategoryTheory.Limits.PreservesLimitsOfSize.{t, w, v, v, u, v + 1} (CategoryTheory.yoneda.obj X) |
ZFSet.mem_pairSep._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ {p : ZFSet.{u} → ZFSet.{u} → Prop} {x y z : ZFSet.{u}},
(z ∈ ZFSet.pairSep p x y) = ∃ a ∈ x, ∃ b ∈ y, z = a.pair b ∧ p a b |
Finpartition.mem_part_self | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (P : Finpartition s) {a : α}, a ∈ P.part a ↔ a ∈ s |
AddUnits.recOn | Mathlib.Algebra.Group.Units.Defs | {α : Type u} →
[inst : AddMonoid α] →
{motive : AddUnits α → Sort u_1} →
(t : AddUnits α) →
((val neg : α) →
(val_neg : val + neg = 0) →
(neg_val : neg + val = 0) → motive { val := val, neg := neg, val_neg := val_neg, neg_val := neg_val }) →
motive t |
SimplexCategory.Truncated.δ₂_one_comp_σ₂_zero._auto_3 | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | Lean.Syntax |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.Filter.totallyBounded_iSup._simp_1_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {s : Set α} {f : Filter α}, (s ∈ f) = (f ≤ Filter.principal s) |
Homeomorph.sumArrowHomeomorphProdArrow._proof_4 | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X] {ι : Type u_2} {ι' : Type u_3} (i : ι),
Continuous fun a => (Equiv.sumArrowEquivProdArrow ι ι' X).invFun a (Sum.inl i) |
CategoryTheory.Functor.ext_of_iso | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (e : F ≅ G) (hobj : ∀ (X : C), F.obj X = G.obj X),
autoParam (∀ (X : C), e.hom.app X = CategoryTheory.eqToHom ⋯) CategoryTheory.Functor.ext_of_iso._auto_1 → F = G |
CategoryTheory.ReflQuiv.isoOfQuivIso._proof_1 | Mathlib.CategoryTheory.Category.ReflQuiv | ∀ {V W : Type u_2} [inst : CategoryTheory.ReflQuiver V] [inst_1 : CategoryTheory.ReflQuiver W]
(e : CategoryTheory.Quiv.of V ≅ CategoryTheory.Quiv.of W),
(∀ (X : V), e.hom.map (CategoryTheory.ReflQuiver.id X) = CategoryTheory.ReflQuiver.id (e.hom.obj X)) →
∀ (Y : ↑(CategoryTheory.ReflQuiv.of W)),
(CategoryTheory.Quiv.homEquivOfIso e) (e.inv.map (CategoryTheory.ReflQuiver.id Y)) =
(CategoryTheory.Quiv.homEquivOfIso e) (CategoryTheory.ReflQuiver.id (e.inv.obj Y)) |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.subset_union_prime._simp_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
MeasureTheory.OuterMeasure.comap_iInf | Mathlib.MeasureTheory.OuterMeasure.OfFunction | ∀ {α : Type u_1} {ι : Sort u_2} {β : Type u_3} (f : α → β) (m : ι → MeasureTheory.OuterMeasure β),
(MeasureTheory.OuterMeasure.comap f) (⨅ i, m i) = ⨅ i, (MeasureTheory.OuterMeasure.comap f) (m i) |
Configuration.HasLines.toNondegenerate | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} {inst : Membership P L} [self : Configuration.HasLines P L],
Configuration.Nondegenerate P L |
CategoryTheory.uliftCategory._proof_4 | Mathlib.CategoryTheory.Category.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_3, u_2} C] {X Y : ULift.{u_1, u_2} C} (f : X.down ⟶ Y.down),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y.down) = f |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.integrable_gaussianPDFReal._simp_1_12 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False |
CompHausLike.LocallyConstant.counitApp.eq_1 | Mathlib.Condensed.Discrete.Colimit | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
[inst_1 : CompHausLike.HasProp P PUnit.{u + 1}] [inst_2 : CompHausLike.HasExplicitFiniteCoproducts P]
(Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w)))
[inst_3 : CategoryTheory.Limits.PreservesFiniteProducts Y],
CompHausLike.LocallyConstant.counitApp Y =
{
app := fun x =>
match x with
| Opposite.op S => CompHausLike.LocallyConstant.counitAppApp S Y,
naturality := ⋯ } |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.synthesizeInstMVarCore._sparseCasesOn_4 | Lean.Elab.Term.TermElabM | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t |
PolynomialLaw.instSMul | Mathlib.RingTheory.PolynomialLaw.Basic | {R : Type u} →
[inst : CommSemiring R] →
{M : Type u_1} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{N : Type u_2} → [inst_3 : AddCommMonoid N] → [inst_4 : Module R N] → SMul R (M →ₚₗ[R] N) |
Subfield.relrank_eq_of_inf_eq | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {A B C : Subfield E}, A ⊓ C = B ⊓ C → A.relrank C = B.relrank C |
TannakaDuality.FiniteGroup.rightFDRep._proof_1 | Mathlib.RepresentationTheory.Tannaka | ∀ {k G : Type u_1} [inst : CommRing k] [Finite G], Module.Finite k (G → k) |
Std.TreeMap.Equiv.maxKey_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp]
{h' : t₁.isEmpty = false} (h : t₁.Equiv t₂), t₁.maxKey h' = t₂.maxKey ⋯ |
CategoryTheory.Pretriangulated.contractibleTriangleFunctor._proof_2 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Pretriangulated.contractibleTriangle X).mor₁ f =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Pretriangulated.contractibleTriangle Y).mor₁ |
IsCompact.exists_infEdist_eq_edist | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s : Set α},
IsCompact s → s.Nonempty → ∀ (x : α), ∃ y ∈ s, Metric.infEDist x s = edist x y |
_private.Mathlib.Topology.LocallyFinite.0.LocallyFinite.closure_iUnion._simp_1_3 | Mathlib.Topology.LocallyFinite | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i |
LowerSet.ctorIdx | Mathlib.Order.Defs.Unbundled | {α : Type u_1} → {inst : LE α} → LowerSet α → ℕ |
CategoryTheory.Limits.isLimitConeOfAdj | Mathlib.CategoryTheory.Limits.HasLimits | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{L : CategoryTheory.Functor (CategoryTheory.Functor J C) C} →
(adj : CategoryTheory.Functor.const J ⊣ L) →
(F : CategoryTheory.Functor J C) → CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneOfAdj adj F) |
Std.Internal.List.getValueCast?_filter_not_contains_of_contains_eq_false_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l₁ : List ((a : α) × β a)} {l₂ : List α} {k : α},
Std.Internal.List.DistinctKeys l₁ →
l₂.contains k = false →
Std.Internal.List.getValueCast? k (List.filter (fun p => !l₂.contains p.fst) l₁) =
Std.Internal.List.getValueCast? k l₁ |
AddSubmonoid.instSetLike.eq_1 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : AddZeroClass M], AddSubmonoid.instSetLike = { coe := fun s => s.carrier, coe_injective' := ⋯ } |
Prefunctor.symmetrify_map | Mathlib.Combinatorics.Quiver.Symmetric | ∀ {U : Type u_1} {V : Type u_2} [inst : Quiver U] [inst_1 : Quiver V] (φ : U ⥤q V) {X Y : Quiver.Symmetrify U}
(a : (X ⟶ Y) ⊕ (Y ⟶ X)), φ.symmetrify.map a = Sum.map φ.map φ.map a |
TopologicalSpace.denseRange_denseSeq | Mathlib.Topology.Bases | ∀ (α : Type u) [t : TopologicalSpace α] [inst : TopologicalSpace.SeparableSpace α] [inst_1 : Nonempty α],
DenseRange (TopologicalSpace.denseSeq α) |
ProbabilityTheory.gaussianReal_sub_const | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {X : Ω → ℝ},
ProbabilityTheory.HasLaw X (ProbabilityTheory.gaussianReal μ v) P →
∀ (y : ℝ), ProbabilityTheory.HasLaw (fun ω => X ω - y) (ProbabilityTheory.gaussianReal (μ - y) v) P |
CategoryTheory.Limits.WalkingMultispan.proxyType | Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer | CategoryTheory.Limits.MultispanShape → Type (max w w') |
Set.countable_iff_exists_surjective | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s : Set α}, s.Nonempty → (s.Countable ↔ ∃ f, Function.Surjective f) |
LocallyConstant.instAddZeroClass.eq_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddZeroClass Y],
LocallyConstant.instAddZeroClass = Function.Injective.addZeroClass DFunLike.coe ⋯ ⋯ ⋯ |
Fin.instUpwardEnumerable | Init.Data.Range.Polymorphic.Fin | {n : ℕ} → Std.PRange.UpwardEnumerable (Fin n) |
SimpleGraph.isVertexCover_empty._simp_1 | Mathlib.Combinatorics.SimpleGraph.VertexCover | ∀ {V : Type u_1} {G : SimpleGraph V}, G.IsVertexCover ∅ = (G = ⊥) |
_private.Mathlib.Probability.Distributions.Fernique.0.ProbabilityTheory.Fernique.lintegral_exp_mul_sq_norm_le_mul._simp_1_13 | Mathlib.Probability.Distributions.Fernique | ∀ {a : ENNReal}, (0 < a.toReal) = (0 < a ∧ a < ⊤) |
Aesop.instInhabitedRuleBuilderOptions | Aesop.Builder.Basic | Inhabited Aesop.RuleBuilderOptions |
LieModuleEquiv.mk._flat_ctor | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{M : Type w} →
{N : Type w₁} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
[inst_6 : LieRingModule L M] →
[inst_7 : LieRingModule L N] →
(toFun : M → N) →
(∀ (x y : M), toFun (x + y) = toFun x + toFun y) →
(∀ (m : R) (x : M), toFun (m • x) = (RingHom.id R) m • toFun x) →
(∀ {x : L} {m : M}, toFun ⁅x, m⁆ = ⁅x, toFun m⁆) →
(invFun : N → M) →
Function.LeftInverse invFun toFun → Function.RightInverse invFun toFun → M ≃ₗ⁅R,L⁆ N |
DFinsupp.equivFunOnFintype._proof_3 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → Zero (β i)] [inst_1 : Fintype ι] (x : Π₀ (i : ι), β i) (x_1 : ι),
x_1 ∈ Finset.univ.val ∨ x x_1 = 0 |
CategoryTheory.ShrinkHoms.comp_def | Mathlib.CategoryTheory.EssentiallySmall | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C]
{X Y Z : CategoryTheory.ShrinkHoms.{u} C} (f : Shrink.{w, v} (X.fromShrinkHoms ⟶ Y.fromShrinkHoms))
(g : Shrink.{w, v} (Y.fromShrinkHoms ⟶ Z.fromShrinkHoms)),
CategoryTheory.CategoryStruct.comp f g =
(equivShrink (X.fromShrinkHoms ⟶ Z.fromShrinkHoms))
(CategoryTheory.CategoryStruct.comp ((equivShrink (X.fromShrinkHoms ⟶ Y.fromShrinkHoms)).symm f)
((equivShrink (Y.fromShrinkHoms ⟶ Z.fromShrinkHoms)).symm g)) |
ProbabilityTheory.IndepSets.union | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s₁ s₂ s' : Set (Set Ω)},
ProbabilityTheory.IndepSets s₁ s' μ → ProbabilityTheory.IndepSets s₂ s' μ → ProbabilityTheory.IndepSets (s₁ ∪ s₂) s' μ |
CategoryTheory.Limits.FormalCoproduct.eval_obj_obj | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (A : Type u₁) [inst_1 : CategoryTheory.Category.{v₁, u₁} A]
[inst_2 : CategoryTheory.Limits.HasCoproducts A] (F : CategoryTheory.Functor C A)
(X : CategoryTheory.Limits.FormalCoproduct C),
((CategoryTheory.Limits.FormalCoproduct.eval C A).obj F).obj X = ∐ fun i => F.obj (X.obj i) |
ShrinkingLemma.PartialRefinement.instCoeFunForallSet | Mathlib.Topology.ShrinkingLemma | {ι : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace X] →
{u : ι → Set X} →
{s : Set X} → {p : Set X → Prop} → CoeFun (ShrinkingLemma.PartialRefinement u s p) fun x => ι → Set X |
Equiv.swap_apply_eq_iff | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] {x y z w : α}, (Equiv.swap x y) z = w ↔ z = (Equiv.swap x y) w |
TopologicalSpace.Compacts.lipschitz_prod | Mathlib.Topology.MetricSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : EMetricSpace α] [inst_1 : EMetricSpace β], LipschitzWith 1 fun p => p.1 ×ˢ p.2 |
_private.Mathlib.Analysis.Convex.DoublyStochasticMatrix.0.convex_doublyStochastic._simp_1_1 | Mathlib.Analysis.Convex.DoublyStochasticMatrix | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) |
Mathlib.Meta.FunProp.TheoremForm.comp | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.TheoremForm |
IsAntichain.preimage_relIso | Mathlib.Order.Antichain | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {r' : β → β → Prop} {t : Set β},
IsAntichain r' t → ∀ (φ : r ≃r r'), IsAntichain r (⇑φ ⁻¹' t) |
NonemptyInterval.fst_sub | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [inst_3 : OrderedSub α]
[inst_4 : AddLeftMono α] (s t : NonemptyInterval α), (s - t).toProd.1 = s.toProd.1 - t.toProd.2 |
Bipointed.hasForget._proof_7 | Mathlib.CategoryTheory.Category.Bipointed | ∀ {X Y : Bipointed} (f : X.HomSubtype Y), ↑f X.toProd.2 = Y.toProd.2 |
SimpleGraph.Walk.Nil.rec | Mathlib.Combinatorics.SimpleGraph.Walks.Basic | {V : Type u} →
{G : SimpleGraph V} →
{v : V} →
{motive : {w : V} → (a : G.Walk v w) → a.Nil → Sort u_1} →
motive SimpleGraph.Walk.nil ⋯ → {w : V} → {a : G.Walk v w} → (t : a.Nil) → motive a t |
IsCyclotomicExtension.Rat.Three.eq_one_or_neg_one_of_unit_of_congruent | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} (hζ : IsPrimitiveRoot ζ 3) (u : (NumberField.RingOfIntegers K)ˣ)
[inst_1 : NumberField K] [IsCyclotomicExtension {3} ℚ K], (∃ n, (hζ.toInteger - 1) ^ 2 ∣ ↑u - ↑n) → u = 1 ∨ u = -1 |
Lean.Linter.LinterOptions.ctorIdx | Lean.Linter.Basic | Lean.Linter.LinterOptions → ℕ |
SummationFilter.hasSum_symmetricIcc_iff | Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt | ∀ {α : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : ℤ → α} {a : α},
HasSum f a (SummationFilter.symmetricIcc ℤ) ↔
Filter.Tendsto (fun N => ∑ n ∈ Finset.Icc (-↑N) ↑N, f n) Filter.atTop (nhds a) |
Lean.Server.FileWorker.InlayHintState.mk | Lean.Server.FileWorker.InlayHints | Array Lean.Elab.InlayHintInfo → ℕ → Option ℕ → Bool → Lean.Server.FileWorker.InlayHintState |
Polynomial.monic_zero_iff_subsingleton' | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R], Polynomial.Monic 0 ↔ (∀ (f g : Polynomial R), f = g) ∧ ∀ (a b : R), a = b |
Submodule.dualCoannihilator_bot | Mathlib.LinearAlgebra.Dual.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
⊥.dualCoannihilator = ⊤ |
Filter.add_bot | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Add α] {f : Filter α}, f + ⊥ = ⊥ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.