name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
NonemptyInterval.mem_def | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : NonemptyInterval α} {a : α}, a ∈ s ↔ s.toProd.1 ≤ a ∧ a ≤ s.toProd.2 |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_insertIfNew_le_minKey!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
_private.Mathlib.Data.List.Sort.0.List.orderedInsert.match_1.eq_2 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} (motive : List α → Sort u_2) (b : α) (l : List α) (h_1 : Unit → motive [])
(h_2 : (b : α) → (l : List α) → motive (b :: l)),
(match b :: l with
| [] => h_1 ()
| b :: l => h_2 b l) =
h_2 b l |
Aesop.ForwardRuleMatches.eraseHyps | Aesop.Tree.Data.ForwardRuleMatches | Std.HashSet Lean.FVarId → Aesop.ForwardRuleMatches → Aesop.ForwardRuleMatches |
List.IsSuffix.isInfix | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → l₁ <:+: l₂ |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.ofNat_dvd.match_1_3 | Init.Data.Int.DivMod.Bootstrap | ∀ {m n : ℕ} (motive : m ∣ n → Prop) (x : m ∣ n), (∀ (k : ℕ) (e : n = m * k), motive ⋯) → motive x |
FP.FloatCfg.mk | Mathlib.Data.FP.Basic | (prec emax : ℕ) → 0 < prec → prec ≤ emax → FP.FloatCfg |
CategoryTheory.Functor.mem_inducedTopology_sieves_iff._simp_1 | Mathlib.CategoryTheory.Sites.DenseSubsite.InducedTopology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (G : CategoryTheory.Functor C D)
(K : CategoryTheory.GrothendieckTopology D) [inst_2 : G.LocallyCoverDense K] [inst_3 : G.IsLocallyFull K]
[inst_4 : G.IsLocallyFaithful K] {X : C} (S : CategoryTheory.Sieve X),
(S ∈ (G.inducedTopology K) X) = (CategoryTheory.Sieve.functorPushforward G S ∈ K (G.obj X)) |
_private.Init.Data.Nat.Div.Basic.0.Nat.sub_mul_div_of_le.match_1_1 | Init.Data.Nat.Div.Basic | ∀ (n : ℕ) (motive : n = 0 ∨ n > 0 → Prop) (x : n = 0 ∨ n > 0),
(∀ (h₀ : n = 0), motive ⋯) → (∀ (h₀ : n > 0), motive ⋯) → motive x |
CategoryTheory.Classifier.SubobjectRepresentableBy.uniq | Mathlib.CategoryTheory.Topos.Classifier | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {Ω : C}
(h : CategoryTheory.Classifier.SubobjectRepresentableBy Ω) {U X : C} {m : U ⟶ X} [inst_2 : CategoryTheory.Mono m]
{χ' : X ⟶ Ω} {π : U ⟶ CategoryTheory.Subobject.underlying.obj h.Ω₀},
CategoryTheory.IsPullback m π χ' h.Ω₀.arrow → χ' = h.χ m |
Std.ExtTreeMap.get!_eq_getElem! | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited β] {a : α}, t.get! a = t[a]! |
Lean.MetavarContext.MkBindingM.Context.ctorIdx | Lean.MetavarContext | Lean.MetavarContext.MkBindingM.Context → ℕ |
RelIso.apply_faithfulSMul | Mathlib.Algebra.Order.Group.Action.End | ∀ {α : Type u_1} {r : α → α → Prop}, FaithfulSMul (r ≃r r) α |
ClusterPt | Mathlib.Topology.Defs.Filter | {X : Type u_1} → [TopologicalSpace X] → X → Filter X → Prop |
CategoryTheory.Functor.lanUnit_app_whiskerLeft_lanAdjunction_counit_app_assoc | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {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] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] [inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasLeftKanExtension F]
(G : CategoryTheory.Functor D H) {Z : CategoryTheory.Functor C H} (h : L.comp G ⟶ Z),
CategoryTheory.CategoryStruct.comp (L.lanUnit.app (L.comp G))
(CategoryTheory.CategoryStruct.comp (L.whiskerLeft ((L.lanAdjunction H).counit.app G)) h) =
h |
_private.Mathlib.Data.Vector.MapLemmas.0.List.Vector.mapAccumr_redundant_pair.match_1_1 | Mathlib.Data.Vector.MapLemmas | {σ : Type u_1} → (motive : σ × σ → Sort u_2) → (x : σ × σ) → ((s₁ s₂ : σ) → motive (s₁, s₂)) → motive x |
HasProdUniformlyOn.eq_1 | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] (f : ι → β → α) (g : β → α) (s : Set β)
[inst_1 : UniformSpace α],
HasProdUniformlyOn f g s = HasProd (⇑(UniformOnFun.ofFun {s}) ∘ f) ((UniformOnFun.ofFun {s}) g) |
Lean.Elab.PartialFixpointType.inductiveFixpoint | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.PartialFixpointType |
AddGroupSeminormClass.toSeminormedAddCommGroup_norm_eq | Mathlib.Analysis.Normed.Order.Hom.Basic | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α ℝ] [inst_1 : AddCommGroup α] [inst_2 : AddGroupSeminormClass F α ℝ]
(f : F) (x : α), ‖x‖ = f x |
Lean.Widget.HighlightedSubexprInfo.highlighted.sizeOf_spec | Lean.Server.FileWorker.WidgetRequests | sizeOf Lean.Widget.HighlightedSubexprInfo.highlighted = 1 |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.div._unary._proof_4 | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} (a₁ : ℤ) (x₁ : Q(«$M»)) (k₁ : ℕ) (t₁ : List ((ℤ × Q(«$M»)) × ℕ)) (a₂ : ℤ)
(x₂ : Q(«$M»)) (k₂ : ℕ) (t₂ : List ((ℤ × Q(«$M»)) × ℕ)),
(invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1 ⟨((a₁, x₁), k₁) :: t₁, t₂⟩
⟨((a₁, x₁), k₁) :: t₁, ((a₂, x₂), k₂) :: t₂⟩ |
_private.Mathlib.CategoryTheory.Subobject.Limits.0.CategoryTheory.Limits.kernelOrderHom._simp_1 | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.hom g = f) = (g = CategoryTheory.CategoryStruct.comp α.inv f) |
_private.Lean.Elab.PreDefinition.PartialFixpoint.Eqns.0.Lean.Elab.PartialFixpoint.deltaLHSUntilFix | Lean.Elab.PreDefinition.PartialFixpoint.Eqns | Lean.Name → Lean.Name → Lean.MVarId → Lean.MetaM Lean.MVarId |
Submodule.finiteQuotientOfFreeOfRankEq | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | ∀ {M : Type u_3} [inst : AddCommGroup M] [Module.Free ℤ M] [Module.Finite ℤ M] (N : Submodule ℤ M),
Module.finrank ℤ ↥N = Module.finrank ℤ M → Finite (M ⧸ N) |
Mathlib.Tactic.FieldSimp.NF.one_eq_eval | Mathlib.Tactic.FieldSimp.Lemmas | ∀ (M : Type u_1) [inst : GroupWithZero M], 1 = Mathlib.Tactic.FieldSimp.NF.eval [] |
Alexandrov.self_mem_principalOpen | Mathlib.Topology.Sheaves.Alexandrov | ∀ {X : Type v} [inst : TopologicalSpace X] [inst_1 : Preorder X] [inst_2 : Topology.IsUpperSet X] (x : X),
x ∈ Alexandrov.principalOpen x |
Std.Rxc.size_pos_iff_le | Init.Data.Range.Polymorphic.Basic | ∀ {α : Type u} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxc.HasSize α]
[Std.Rxc.LawfulHasSize α] {lo hi : α}, 0 < Std.Rxc.HasSize.size lo hi ↔ lo ≤ hi |
Std.HashMap.Raw.getKeyD_empty | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {a fallback : α}, ∅.getKeyD a fallback = fallback |
CauchyFilter.mem_uniformity | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u} [inst : UniformSpace α] {s : Set (CauchyFilter α × CauchyFilter α)},
s ∈ uniformity (CauchyFilter α) ↔ ∃ t ∈ uniformity α, CauchyFilter.gen t ⊆ s |
Matroid.isNonloop_of_not_isLoop._auto_1 | Mathlib.Combinatorics.Matroid.Loop | Lean.Syntax |
CategoryTheory.Precoverage.toGrothendieck_le_iff_le_toPrecoverage | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {K : CategoryTheory.Precoverage C}
{J : CategoryTheory.GrothendieckTopology C} [K.HasPullbacks] [K.IsStableUnderBaseChange],
K.toGrothendieck ≤ J ↔ K ≤ J.toPrecoverage |
Sublattice.instCompleteLattice._proof_9 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} [inst : Lattice α] (_S : Sublattice α) (_a : α), False → _a ∈ _S |
Lean.Elab.Tactic.nonempty_prop_to_inhabited | Mathlib.Tactic.Inhabit | (α : Prop) → Nonempty α → Inhabited α |
Order.pred_covBy | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] [NoMinOrder α] (a : α), Order.pred a ⋖ a |
ArithmeticFunction.vonMangoldt.LFunctionResidueClassAux.congr_simp | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {q : ℕ} (a a_1 : ZMod q),
a = a_1 →
∀ [inst : NeZero q] (s s_1 : ℂ),
s = s_1 →
ArithmeticFunction.vonMangoldt.LFunctionResidueClassAux a s =
ArithmeticFunction.vonMangoldt.LFunctionResidueClassAux a_1 s_1 |
Module.Baer.ExtensionOfMaxAdjoin.fst | Mathlib.Algebra.Module.Injective | {R : Type u} →
[inst : Ring R] →
{Q : Type v} →
[inst_1 : AddCommGroup Q] →
[inst_2 : Module R Q] →
{M : Type u_1} →
{N : Type u_2} →
[inst_3 : AddCommGroup M] →
[inst_4 : AddCommGroup N] →
[inst_5 : Module R M] →
[inst_6 : Module R N] →
(i : M →ₗ[R] N) →
{f : M →ₗ[R] Q} →
[inst_7 : Fact (Function.Injective ⇑i)] →
{y : N} →
↥(Module.Baer.supExtensionOfMaxSingleton i f y) → ↥(Module.Baer.extensionOfMax i f).domain |
Batteries.TotalBLE.recOn | Batteries.Classes.Order | {α : Sort u_1} →
{le : α → α → Bool} →
{motive : Batteries.TotalBLE le → Sort u} →
(t : Batteries.TotalBLE le) → ((total : ∀ {a b : α}, le a b = true ∨ le b a = true) → motive ⋯) → motive t |
Lean.Grind.AC.Seq.subseq | Lean.Meta.Tactic.Grind.AC.Seq | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.SubseqResult |
Order.Ioc_pred_left | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] [NoMinOrder α] (a b : α),
Set.Ioc (Order.pred a) b = Set.Icc a b |
Std.ExtTreeMap.getEntryGED | Std.Data.ExtTreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeMap α β cmp → α → α × β → α × β |
_private.Mathlib.MeasureTheory.Measure.Portmanteau.0.MeasureTheory.limsup_measure_closed_le_of_forall_tendsto_measure._simp_1_7 | Mathlib.MeasureTheory.Measure.Portmanteau | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) |
Mathlib.Tactic.LibraryRewrite.RewriteInterface.tactic | Mathlib.Tactic.Widget.LibraryRewrite | Mathlib.Tactic.LibraryRewrite.RewriteInterface → String |
of_isDiscreteValuationRing | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ (A : Type u) [inst : CommRing A] [inst_1 : IsDomain A] [IsDiscreteValuationRing A], ValuationRing A |
and_congr_left' | Init.PropLemmas | ∀ {a b c : Prop}, (a ↔ b) → (a ∧ c ↔ b ∧ c) |
ContinuousMapZero.instNonUnitalCommRing._proof_9 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : CommRing R]
[inst_3 : TopologicalSpace R] [inst_4 : IsTopologicalRing R] (x : ℕ) (x_1 : ContinuousMapZero X R),
↑(x • x_1) = ↑(x • x_1) |
Lean.Lsp.instToJsonDeclarationParams.toJson | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.DeclarationParams → Lean.Json |
List.Nodup.append | Mathlib.Data.List.Nodup | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.Nodup → l₂.Nodup → l₁.Disjoint l₂ → (l₁ ++ l₂).Nodup |
Lean.Grind.CommRing.eq_normS_cert | Init.Grind.Ring.CommSemiringAdapter | Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Expr → Bool |
StarSubalgebra.toNonUnitalStarSubalgebra._proof_1 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (S : StarSubalgebra R A) {a b : A},
a ∈ S.carrier → b ∈ S.carrier → a + b ∈ S.carrier |
Metric.packingNumber_pos_iff._simp_1 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {A : Set X} {ε : NNReal}, (0 < Metric.packingNumber ε A) = A.Nonempty |
CategoryTheory.Adjunction.leftAdjointUniq | Mathlib.CategoryTheory.Adjunction.Unique | {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] →
{F F' : CategoryTheory.Functor C D} → {G : CategoryTheory.Functor D C} → (F ⊣ G) → (F' ⊣ G) → (F ≅ F') |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.Metric.infEDist_le_infEDist_add_hausdorffEDist._simp_1_1 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] {a : α}, (0 < a) = (a ≠ 0) |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.collectUnassignedMVars.go.match_1 | Lean.Elab.Term.TermElabM | (motive : List Lean.MVarId → Sort u_1) →
(mvarIds : List Lean.MVarId) →
(Unit → motive []) →
((mvarId : Lean.MVarId) → (mvarIds : List Lean.MVarId) → motive (mvarId :: mvarIds)) → motive mvarIds |
AddEquiv.toLinearEquiv._proof_3 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {M : Type u_1} {M₂ : Type u_2} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid M₂] (e : M ≃+ M₂),
Function.RightInverse e.invFun e.toFun |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.Drop.0.Std.IterM.step_drop.match_1.eq_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.Drop | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (k : ℕ) → motive k.succ),
(match 0 with
| 0 => h_1 ()
| k.succ => h_2 k) =
h_1 () |
Std.Internal.List.maxKey?_le_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : BEq α] [inst_3 : Std.LawfulBEqOrd α]
{k km : α} {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ (hc : Std.Internal.List.containsKey k l = true),
(Std.Internal.List.maxKey? l).get ⋯ = km → (compare k km).isLE = true |
_private.Lean.Elab.Tactic.Grind.Param.0.Lean.Meta.Grind.Params.containsEMatch | Lean.Elab.Tactic.Grind.Param | Lean.Meta.Grind.Params → Lean.Name → Bool |
AlgebraicGeometry.isAffineHom_of_isAffine | Mathlib.AlgebraicGeometry.Morphisms.Affine | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsAffine X] [AlgebraicGeometry.IsAffine Y],
AlgebraicGeometry.IsAffineHom f |
FirstOrder.Language.IsExtensionPair.definedAtLeft | Mathlib.ModelTheory.PartialEquiv | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type w'} →
[inst : L.Structure M] → [inst_1 : L.Structure N] → L.IsExtensionPair M N → M → Order.Cofinal (L.FGEquiv M N) |
Equiv.transPartialEquiv_source | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f' : PartialEquiv β γ),
(e.transPartialEquiv f').source = ⇑e ⁻¹' f'.source |
SSet.Subcomplex.Pairing.instIsWellFoundedElemNIIAncestralRel | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing) [P.IsRegular], IsWellFounded (↑P.II) P.AncestralRel |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey_modify._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
Lean.Elab.Term.elabDepArrow._regBuiltin.Lean.Elab.Term.elabDepArrow.docString_3 | Lean.Elab.Binders | IO Unit |
Subalgebra.ofRestrictScalars._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Tower | ∀ (R : Type u_1) {S : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [inst_6 : IsScalarTower R S A]
(U : Subalgebra S A), IsScalarTower R S ↥U |
Std.Tactic.BVDecide.BVExpr.PackedBitVec.mk.inj | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} {bv : BitVec w} {w_1 : ℕ} {bv_1 : BitVec w_1},
{ w := w, bv := bv } = { w := w_1, bv := bv_1 } → w = w_1 ∧ bv ≍ bv_1 |
SimpleGraph.cliqueFree_of_card_lt | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} {n : ℕ} [inst : Fintype α], Fintype.card α < n → G.CliqueFree n |
MvPowerSeries.subst_X | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommRing R] {τ : Type u_4} {S : Type u_5} [inst_1 : CommRing S]
[inst_2 : Algebra R S] {a : σ → MvPowerSeries τ S},
MvPowerSeries.HasSubst a → ∀ (s : σ), MvPowerSeries.subst a (MvPowerSeries.X s) = a s |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Definability.0.FirstOrder.Language.presburger.mul_not_definable._proof_1_6 | Mathlib.ModelTheory.Arithmetic.Presburger.Definability | ∀ (k p : ℕ), p > 0 → ∀ (x : ℕ), x * x = max k p * max k p + p → x * x ≤ max k p * max k p → False |
have_body_congr_dep' | Init.SimpLemmas | ∀ {α : Sort u} {β : α → Sort v} (a : α) {f f' : (x : α) → β x}, (∀ (x : α), f x = f' x) → f a = f' a |
commGrpTypeEquivalenceCommGrp._proof_2 | Mathlib.CategoryTheory.Monoidal.Internal.Types.CommGrp_ | ∀ (X : CategoryTheory.CommGrp (Type u_1)),
CategoryTheory.CategoryStruct.comp
(CommGrpTypeEquivalenceCommGrp.functor.map
((CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.CommGrp (Type u_1)))).hom.app X))
((CategoryTheory.NatIso.ofComponents
(fun A =>
(let __src :=
Equiv.refl
↑((CommGrpTypeEquivalenceCommGrp.inverse.comp CommGrpTypeEquivalenceCommGrp.functor).obj A);
{ toEquiv := __src, map_mul' := ⋯ }).toCommGrpIso)
@commGrpTypeEquivalenceCommGrp._proof_1).hom.app
(CommGrpTypeEquivalenceCommGrp.functor.obj X)) =
CategoryTheory.CategoryStruct.id (CommGrpTypeEquivalenceCommGrp.functor.obj X) |
CompactlyGeneratedSpace.isClosed | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | ∀ {X : Type u} [inst : TopologicalSpace X] [CompactlyGeneratedSpace X] {s : Set X},
(∀ ⦃K : Set X⦄, IsCompact K → IsClosed (s ∩ K)) → IsClosed s |
Std.HashMap.mem_keys | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [LawfulBEq α] {k : α},
k ∈ m.keys ↔ k ∈ m |
isInducing_stoneCechUnit | Mathlib.Topology.Separation.CompletelyRegular | ∀ {X : Type u} [inst : TopologicalSpace X] [CompletelyRegularSpace X], Topology.IsInducing stoneCechUnit |
Lean.Doc.PostponedImport.name | Lean.Elab.DocString.Builtin.Postponed | Lean.Doc.PostponedImport → Lean.Name |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.Adapted.isStoppingTime_hittingBtwn_isStoppingTime._simp_1_13 | Mathlib.Probability.Process.HittingTime | ∀ {α : Type u_1} {a b : α} [inst : LE α], (↑b ≤ ↑a) = (b ≤ a) |
Lean.Doc.State._sizeOf_inst | Lean.Elab.DocString | SizeOf Lean.Doc.State |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.two_nsmul_eq_iff._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {ψ θ : Real.Angle}, (2 • ψ = 2 • θ) = (ψ = θ ∨ ψ = θ + ↑Real.pi) |
Part.Fix.approx._unsafe_rec | Mathlib.Control.Fix | {α : Type u_1} → {β : α → Type u_2} → (((a : α) → Part (β a)) → (a : α) → Part (β a)) → Stream' ((a : α) → Part (β a)) |
CategoryTheory.GradedObject.mapTrifunctorMap_obj | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_7}
{I₂ : Type u_8} {I₃ : Type u_9} {J : Type u_10} (p : I₁ × I₂ × I₃ → J)
[inst_4 :
∀ (X₁ : CategoryTheory.GradedObject I₁ C₁) (X₂ : CategoryTheory.GradedObject I₂ C₂)
(X₃ : CategoryTheory.GradedObject I₃ C₃),
((((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃).HasMap p]
(X₁ : CategoryTheory.GradedObject I₁ C₁),
(CategoryTheory.GradedObject.mapTrifunctorMap F p).obj X₁ =
CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj F p X₁ |
FiniteDimensional.of_locallyCompactSpace | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ (𝕜 : Type u) [inst : NontriviallyNormedField 𝕜] {E : Type v} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [CompleteSpace 𝕜] [LocallyCompactSpace E], FiniteDimensional 𝕜 E |
ProjectiveSpectrum.ctorIdx | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | {A : Type u_1} →
{σ : Type u_2} →
{inst : CommRing A} →
{inst_1 : SetLike σ A} →
{inst_2 : AddSubmonoidClass σ A} → {𝒜 : ℕ → σ} → {inst_3 : GradedRing 𝒜} → ProjectiveSpectrum 𝒜 → ℕ |
rTensor.inverse_apply | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_5) [inst_7 : AddCommGroup Q] [inst_8 : Module R Q]
(hfg : Function.Exact ⇑f ⇑g) (hg : Function.Surjective ⇑g) (y : TensorProduct R N Q),
(rTensor.inverse Q hfg hg) ((LinearMap.rTensor Q g) y) = Submodule.Quotient.mk y |
TopologicalSpace.NonemptyCompacts.instPartialOrder | Mathlib.Topology.Sets.Compacts | {α : Type u_1} → [inst : TopologicalSpace α] → PartialOrder (TopologicalSpace.NonemptyCompacts α) |
Lean.Expr.fvar.inj | Lean.Expr | ∀ {fvarId fvarId_1 : Lean.FVarId}, Lean.Expr.fvar fvarId = Lean.Expr.fvar fvarId_1 → fvarId = fvarId_1 |
OpenNormalAddSubgroup.toFiniteIndexNormalAddSubgroup._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [CompactSpace G] [ContinuousAdd G]
(H : OpenNormalAddSubgroup G), (↑H.toOpenAddSubgroup).FiniteIndex |
CategoryTheory.WithTerminal.comp.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : CategoryTheory.WithTerminal C) (_X : C),
CategoryTheory.WithTerminal.comp = fun _f _g => PUnit.unit |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.PresentationOfFreeCotangent.Aux.tensorCotangentInv._proof_2 | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {ι : Type u_2}
{P : Algebra.Generators R S ι} {σ : Type u_4} {b : Module.Basis σ S P.toExtension.Cotangent}
(D : Algebra.Generators.PresentationOfFreeCotangent.Aux✝ P b),
SMulCommClass (Algebra.Generators.PresentationOfFreeCotangent.Aux.T✝ D) S S |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mkGrindEqnParams | Lean.Elab.Tactic.Try | Array Lean.Name → Lean.MetaM (Array (Lean.TSyntax `Lean.Parser.Tactic.grindParam)) |
Subtype.restrict_def | Mathlib.Data.Subtype | ∀ {α : Sort u_4} {β : Type u_5} (f : α → β) (p : α → Prop), Subtype.restrict p f = f ∘ fun a => ↑a |
String.Pos.ofToSlice_comp_toSlice | Init.Data.String.Basic | ∀ {s : String}, String.Pos.ofToSlice ∘ String.Pos.toSlice = id |
Prod.mk_dvd_mk._simp_1 | Mathlib.Algebra.Divisibility.Prod | ∀ {G₁ : Type u_2} {G₂ : Type u_3} [inst : Semigroup G₁] [inst_1 : Semigroup G₂] {x₁ y₁ : G₁} {x₂ y₂ : G₂},
((x₁, x₂) ∣ (y₁, y₂)) = (x₁ ∣ y₁ ∧ x₂ ∣ y₂) |
RelEmbedding.mul_apply | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (e₁ e₂ : r ↪r r) (x : α), (e₁ * e₂) x = e₁ (e₂ x) |
_private.Mathlib.Topology.Separation.Regular.0.regularSpace_TFAE.match_1_7 | Mathlib.Topology.Separation.Regular | ∀ (X : Type u_1) [inst : TopologicalSpace X]
(motive : (∀ (x : X), (nhds x).lift' closure = nhds x) → (x : X) → (x_1 : Set X) → x_1 ∈ nhds x → Prop)
(x : ∀ (x : X), (nhds x).lift' closure = nhds x) (x_1 : X) (x_2 : Set X) (x_3 : x_2 ∈ nhds x_1),
(∀ (H : ∀ (x : X), (nhds x).lift' closure = nhds x) (a : X) (s : Set X) (hs : s ∈ nhds a), motive H a s hs) →
motive x x_1 x_2 x_3 |
Int.natCast_le_zero._simp_1 | Init.Data.Int.LemmasAux | ∀ {n : ℕ}, (↑n ≤ 0) = (n = 0) |
Finset.one_le_prod' | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {N : Type u_5} [inst : CommMonoid N] [inst_1 : Preorder N] {f : ι → N} {s : Finset ι} [MulLeftMono N],
(∀ i ∈ s, 1 ≤ f i) → 1 ≤ ∏ i ∈ s, f i |
Lean.Grind.OrderedRing.mul_le_mul_of_nonneg_left | Init.Grind.Ordered.Ring | ∀ {R : Type u} [inst : Lean.Grind.Ring R] [inst_1 : LE R] [inst_2 : LT R] [inst_3 : Std.IsPartialOrder R]
[Lean.Grind.OrderedRing R] [Std.LawfulOrderLT R] {a b c : R}, a ≤ b → 0 ≤ c → c * a ≤ c * b |
CategoryTheory.ComposableArrows.Precomp.map._proof_7 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (i : ℕ) (hi : i + 1 < n + 1 + 1) (j : ℕ) (hj : j + 1 < n + 1 + 1), ⟨i + 1, hi⟩ ≤ ⟨j + 1, hj⟩ → i ≤ j |
_private.Mathlib.Topology.Homotopy.Product.0.Path.Homotopic.«_aux_Mathlib_Topology_Homotopy_Product___macroRules__private_Mathlib_Topology_Homotopy_Product_0_Path_Homotopic_term_⬝__1» | Mathlib.Topology.Homotopy.Product | Lean.Macro |
contDiffOn_of_analyticOn_of_fderivWithin | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {n : WithTop ℕ∞}, AnalyticOn 𝕜 f s → ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f s y) s → ContDiffOn 𝕜 n f s |
RootPairing.Hom.mk.injEq | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Module R N₂]
{P : RootPairing ι R M N} {Q : RootPairing ι₂ R M₂ N₂} (weightMap : M →ₗ[R] M₂) (coweightMap : N₂ →ₗ[R] N)
(indexEquiv : ι ≃ ι₂)
(weight_coweight_transpose : weightMap.dualMap ∘ₗ ↑Q.flip.toPerfPair = ↑P.flip.toPerfPair ∘ₗ coweightMap)
(root_weightMap : ⇑weightMap ∘ ⇑P.root = ⇑Q.root ∘ ⇑indexEquiv)
(coroot_coweightMap : ⇑coweightMap ∘ ⇑Q.coroot = ⇑P.coroot ∘ ⇑indexEquiv.symm) (weightMap_1 : M →ₗ[R] M₂)
(coweightMap_1 : N₂ →ₗ[R] N) (indexEquiv_1 : ι ≃ ι₂)
(weight_coweight_transpose_1 : weightMap_1.dualMap ∘ₗ ↑Q.flip.toPerfPair = ↑P.flip.toPerfPair ∘ₗ coweightMap_1)
(root_weightMap_1 : ⇑weightMap_1 ∘ ⇑P.root = ⇑Q.root ∘ ⇑indexEquiv_1)
(coroot_coweightMap_1 : ⇑coweightMap_1 ∘ ⇑Q.coroot = ⇑P.coroot ∘ ⇑indexEquiv_1.symm),
({ weightMap := weightMap, coweightMap := coweightMap, indexEquiv := indexEquiv,
weight_coweight_transpose := weight_coweight_transpose, root_weightMap := root_weightMap,
coroot_coweightMap := coroot_coweightMap } =
{ weightMap := weightMap_1, coweightMap := coweightMap_1, indexEquiv := indexEquiv_1,
weight_coweight_transpose := weight_coweight_transpose_1, root_weightMap := root_weightMap_1,
coroot_coweightMap := coroot_coweightMap_1 }) =
(weightMap = weightMap_1 ∧ coweightMap = coweightMap_1 ∧ indexEquiv = indexEquiv_1) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.