name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Lsp.instFromJsonCommand.fromJson | Lean.Data.Lsp.Basic | Lean.Json → Except String Lean.Lsp.Command |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeContext.mk.noConfusion | Lean.Elab.MutualInductive | {P : Sort u} →
{elabs : Array Lean.Elab.Command.InductiveElabStep2} →
{mctx : Lean.MetavarContext} →
{levelParams : List Lean.Name} →
{params : Array Lean.Expr} →
{lctx : Lean.LocalContext} →
{localInsts : Lean.LocalInstances} →
{replaceIndFVars : Lean.Expr → Lean.MetaM Lean.Expr} →
{elabs' : Array Lean.Elab.Command.InductiveElabStep2} →
{mctx' : Lean.MetavarContext} →
{levelParams' : List Lean.Name} →
{params' : Array Lean.Expr} →
{lctx' : Lean.LocalContext} →
{localInsts' : Lean.LocalInstances} →
{replaceIndFVars' : Lean.Expr → Lean.MetaM Lean.Expr} →
{ elabs := elabs, mctx := mctx, levelParams := levelParams, params := params,
lctx := lctx, localInsts := localInsts, replaceIndFVars := replaceIndFVars } =
{ elabs := elabs', mctx := mctx', levelParams := levelParams', params := params',
lctx := lctx', localInsts := localInsts', replaceIndFVars := replaceIndFVars' } →
(elabs = elabs' →
mctx = mctx' →
levelParams = levelParams' →
params = params' →
lctx = lctx' →
localInsts = localInsts' → replaceIndFVars = replaceIndFVars' → P) →
P |
AddSubmonoid.mk_eq_top | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : AddZeroClass M] (toSubsemigroup : AddSubsemigroup M) (zero_mem' : 0 ∈ toSubsemigroup.carrier),
{ toAddSubsemigroup := toSubsemigroup, zero_mem' := zero_mem' } = ⊤ ↔ toSubsemigroup = ⊤ |
RingNorm.toAddGroupNorm | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → [inst : NonUnitalNonAssocRing R] → RingNorm R → AddGroupNorm R |
Std.Time.ZonedDateTime.subMonthsClip | Std.Time.Zoned.ZonedDateTime | Std.Time.ZonedDateTime → Std.Time.Month.Offset → Std.Time.ZonedDateTime |
Lean.Lsp.WorkspaceEdit.mk.inj | Lean.Data.Lsp.Basic | ∀ {changes? : Option (Std.TreeMap Lean.Lsp.DocumentUri Lean.Lsp.TextEditBatch compare)}
{documentChanges? : Option (Array Lean.Lsp.DocumentChange)}
{changeAnnotations? : Option (Std.TreeMap String Lean.Lsp.ChangeAnnotation compare)}
{changes?_1 : Option (Std.TreeMap Lean.Lsp.DocumentUri Lean.Lsp.TextEditBatch compare)}
{documentChanges?_1 : Option (Array Lean.Lsp.DocumentChange)}
{changeAnnotations?_1 : Option (Std.TreeMap String Lean.Lsp.ChangeAnnotation compare)},
{ changes? := changes?, documentChanges? := documentChanges?, changeAnnotations? := changeAnnotations? } =
{ changes? := changes?_1, documentChanges? := documentChanges?_1, changeAnnotations? := changeAnnotations?_1 } →
changes? = changes?_1 ∧ documentChanges? = documentChanges?_1 ∧ changeAnnotations? = changeAnnotations?_1 |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.noConfusion | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{J : Type w} →
{inst_1 : LinearOrder J} →
{inst_2 : OrderBot J} →
{F : CategoryTheory.Functor J C} →
{c : CategoryTheory.Limits.Cocone F} →
{X Y : C} →
{p : X ⟶ Y} →
{f : F.obj ⊥ ⟶ X} →
{g : c.pt ⟶ Y} →
{j : J} →
{t : CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct c p f g j} →
{C' : Type u} →
{inst' : CategoryTheory.Category.{v, u} C'} →
{J' : Type w} →
{inst'_1 : LinearOrder J'} →
{inst'_2 : OrderBot J'} →
{F' : CategoryTheory.Functor J' C'} →
{c' : CategoryTheory.Limits.Cocone F'} →
{X' Y' : C'} →
{p' : X' ⟶ Y'} →
{f' : F'.obj ⊥ ⟶ X'} →
{g' : c'.pt ⟶ Y'} →
{j' : J'} →
{t' :
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct
c' p' f' g' j'} →
C = C' →
inst ≍ inst' →
J = J' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 →
F ≍ F' →
c ≍ c' →
X ≍ X' →
Y ≍ Y' →
p ≍ p' →
f ≍ f' →
g ≍ g' →
j ≍ j' →
t ≍ t' →
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.noConfusionType
P t t' |
_private.Mathlib.Data.List.Sublists.0.List.Pairwise.sublists'._simp_1_5 | Mathlib.Data.List.Sublists | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : List α}, (b ∈ List.map f l) = ∃ a ∈ l, f a = b |
Topology.IsOpenEmbedding.matrix_map | Mathlib.Topology.Instances.Matrix | ∀ {m : Type u_11} {n : Type u_12} {R : Type u_13} {S : Type u_14} [inst : TopologicalSpace R]
[inst_1 : TopologicalSpace S] {f : R → S} [Finite m] [Finite n],
Topology.IsOpenEmbedding f → Topology.IsOpenEmbedding fun x => x.map f |
Lean.Parser.Command.macroRhs.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer |
Representation.prod_apply_apply | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring k] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : Module k V] [inst_4 : AddCommMonoid W] [inst_5 : Module k W]
(ρV : Representation k G V) (ρW : Representation k G W) (g : G) (i : V × W),
((ρV.prod ρW) g) i = ((ρV g) i.1, (ρW g) i.2) |
Lean.Elab.Term.Do.Alt.mk._flat_ctor | Lean.Elab.Do.Legacy | {σ : Type} → Lean.Syntax → Array Lean.Elab.Term.Do.Var → Lean.Syntax → σ → Lean.Elab.Term.Do.Alt σ |
StarRingEquiv.refl_symm | Mathlib.Algebra.Star.StarRingHom | ∀ {A : Type u_1} [inst : Add A] [inst_1 : Mul A] [inst_2 : Star A], StarRingEquiv.refl.symm = StarRingEquiv.refl |
Topology.RelCWComplex.FiniteType.mk | Mathlib.Topology.CWComplex.Classical.Finite | ∀ {X : Type u} [inst : TopologicalSpace X] {C D : Set X} [inst_1 : Topology.RelCWComplex C D],
(∀ (n : ℕ), Finite (Topology.RelCWComplex.cell C n)) → Topology.RelCWComplex.FiniteType C |
_private.Mathlib.GroupTheory.Nilpotent.0.isNilpotent_of_finite_tfae.match_1_3 | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [hG : Group G]
(motive : (∀ (H : Subgroup G), IsCoatom H → H.Normal) → (x : ℕ) → Fact (Nat.Prime x) → Sylow x G → Prop)
(x : ∀ (H : Subgroup G), IsCoatom H → H.Normal) (x_1 : ℕ) (x_2 : Fact (Nat.Prime x_1)) (x_3 : Sylow x_1 G),
(∀ (h : ∀ (H : Subgroup G), IsCoatom H → H.Normal) (p : ℕ) (x : Fact (Nat.Prime p)) (P : Sylow p G), motive h p x P) →
motive x x_1 x_2 x_3 |
groupHomology.single_mem_cycles₁_iff | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep k G} (g : G) (a : ↑A.V),
(fun₀ | g => a) ∈ groupHomology.cycles₁ A ↔ (A.ρ g) a = a |
Set.vadd_set_mono | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : VAdd α β] {s t : Set β} {a : α}, s ⊆ t → a +ᵥ s ⊆ a +ᵥ t |
Subgroup.quotientEquivProdOfLE_symm_apply | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {s t : Subgroup α} (h_le : s ≤ t) (a : (α ⧸ t) × ↥t ⧸ s.subgroupOf t),
(Subgroup.quotientEquivProdOfLE h_le).symm a = Quotient.map' (fun b => Quotient.out a.1 * ↑b) ⋯ a.2 |
Lean.Meta.instBEqInfoCacheKey.beq | Lean.Meta.Basic | Lean.Meta.InfoCacheKey → Lean.Meta.InfoCacheKey → Bool |
Nat.Partrec.Code.evaln._unary._proof_1 | Mathlib.Computability.PartrecCode | WellFounded (invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1 |
NonUnitalSubring.prodEquiv._proof_2 | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S]
(s : NonUnitalSubring R) (t : NonUnitalSubring S) (x x_1 : ↥(s.prod t)),
(Equiv.Set.prod ↑s ↑t).toFun (x * x_1) = (Equiv.Set.prod ↑s ↑t).toFun (x * x_1) |
Mathlib.Tactic.Order.AtomicFact.isSup.inj | Mathlib.Tactic.Order.CollectFacts | ∀ {lhs rhs res lhs_1 rhs_1 res_1 : ℕ},
Mathlib.Tactic.Order.AtomicFact.isSup lhs rhs res = Mathlib.Tactic.Order.AtomicFact.isSup lhs_1 rhs_1 res_1 →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ res = res_1 |
HahnSeries.recOn | Mathlib.RingTheory.HahnSeries.Basic | {Γ : Type u_1} →
{R : Type u_2} →
[inst : PartialOrder Γ] →
[inst_1 : Zero R] →
{motive : HahnSeries Γ R → Sort u} →
(t : HahnSeries Γ R) →
((coeff : Γ → R) →
(isPWO_support' : (Function.support coeff).IsPWO) →
motive { coeff := coeff, isPWO_support' := isPWO_support' }) →
motive t |
Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.example.parenthesizer_289 | Lean.Parser.Command | IO Unit |
Finset.image_add_left_Ioc | Mathlib.Algebra.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [IsOrderedCancelAddMonoid α] [ExistsAddOfLE α]
[inst_4 : LocallyFiniteOrder α] [inst_5 : DecidableEq α] (a b c : α),
Finset.image (fun x => c + x) (Finset.Ioc a b) = Finset.Ioc (c + a) (c + b) |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.Convex.smul_vadd_mem_of_mem_nhds_of_mem_asymptoticCone.match_1_1 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} (motive : k × V → Prop) (h : k × V), (∀ (t : k) (u : V), motive (t, u)) → motive h |
CategoryTheory.instIsCardinalFilteredToTypeOrd | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ (κ : Cardinal.{w}) [hκ : Fact κ.IsRegular], CategoryTheory.IsCardinalFiltered κ.ord.ToType κ |
Homeomorph.coe_prodComm | Mathlib.Topology.Constructions.SumProd | ∀ (X : Type u) (Y : Type v) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
⇑(Homeomorph.prodComm X Y) = Prod.swap |
QuotSMulTop.equivQuotTensor._proof_1 | Mathlib.RingTheory.QuotSMulTop | ∀ {R : Type u_1} [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower R R M |
lightProfiniteToLightCondSetIsoTopCatToLightCondSet._proof_1 | Mathlib.Condensed.Light.Functors | ∀ (X : LightProfinite) (S : LightProfiniteᵒᵖ)
(f :
((CategoryTheory.sheafToPresheaf (CategoryTheory.coherentTopology LightProfinite) (Type u_1)).obj
(lightProfiniteToLightCondSet.obj X)).obj
S),
Continuous ⇑(CategoryTheory.ConcreteCategory.hom f.hom) |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.kindHasAtoms | Lean.Elab.DocString.Builtin.Keywords | Lean.Name → List String → Lean.Elab.TermElabM Bool |
CategoryTheory.Bicategory.Adjunction.homEquiv₁._proof_5 | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {b c d : B} {l : b ⟶ c} {r : c ⟶ b}
(adj : CategoryTheory.Bicategory.Adjunction l r) {g : b ⟶ d} {h : c ⟶ d}
(γ : g ⟶ CategoryTheory.CategoryStruct.comp l h),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor g).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight adj.unit g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator l r g).hom
(CategoryTheory.Bicategory.whiskerLeft l
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft r γ)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator r l h).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight adj.counit h)
(CategoryTheory.Bicategory.leftUnitor h).hom)))))) =
γ |
CategoryTheory.GrothendieckTopology.pointBotFunctor | Mathlib.CategoryTheory.Sites.Point.Presheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.LocallySmall.{w, v, u} C] → CategoryTheory.Functor C ⊥.Point |
Set.BijOn.subset_left | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} {r : Set α},
Set.BijOn f s t → r ⊆ s → Set.BijOn f r (f '' r) |
hasDerivWithinAt_iff_isLittleO | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
HasDerivWithinAt f f' s x ↔ (fun x' => f x' - f x - (x' - x) • f') =o[nhdsWithin x s] fun x' => x' - x |
CompHaus.limitConeIsLimit._proof_2 | Mathlib.Topology.Category.CompHaus.Basic | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CompHaus)
(S : CategoryTheory.Limits.Cone F) (m : S.pt ⟶ (CompHaus.limitCone F).pt),
(∀ (j : J), CategoryTheory.CategoryStruct.comp m ((CompHaus.limitCone F).π.app j) = S.π.app j) →
∀ (j : J),
CategoryTheory.CategoryStruct.comp m.hom ((TopCat.limitCone (F.comp compHausToTop)).π.app j) =
(compHausToTop.mapCone S).π.app j |
nnnorm_ofDual | Mathlib.Analysis.Normed.Group.Constructions | ∀ {E : Type u_2} [inst : NNNorm E] (x : Eᵒᵈ), ‖OrderDual.ofDual x‖₊ = ‖x‖₊ |
_private.Std.Data.DHashMap.Internal.Model.0.Std.DHashMap.Internal.exists_bucket_of_uset._proof_1_5 | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Hashable α] (self : Array (Std.DHashMap.Internal.AssocList α β)) (i : USize)
(hi : i.toNat < self.size) (h₀ : 0 < self.size) (l₁ l₂ : List (Std.DHashMap.Internal.AssocList α β)),
l₁.length = i.toNat →
∀ (k : α),
(↑(Std.DHashMap.Internal.mkIdx self.size ⋯ (hash k))).toNat = i.toNat →
∀ (j : ℕ), (↑(Std.DHashMap.Internal.mkIdx self.size h₀ (hash k))).toNat = j + 1 + l₁.length → False |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_filter_iff._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
HurwitzZeta.hurwitzOddFEPair._proof_9 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : UnitAddCircle) (r : ℝ),
(fun x => (Complex.ofReal ∘ HurwitzZeta.sinKernel a) x - 0) =O[Filter.atTop] fun x => x ^ r |
Fintype.coe_finsetEquivSet | Mathlib.Data.Fintype.Sets | ∀ {α : Type u_1} [inst : Fintype α], ⇑Fintype.finsetEquivSet = SetLike.coe |
SBtw.recOn | Mathlib.Order.Circular | {α : Type u_1} →
{motive : SBtw α → Sort u} → (t : SBtw α) → ((sbtw : α → α → α → Prop) → motive { sbtw := sbtw }) → motive t |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.Ioc_succ_singleton._proof_1_1 | Mathlib.Order.Interval.Finset.Nat | ∀ (b : ℕ), Finset.Ioc b (b + 1) = {b + 1} |
_private.Init.Data.Array.Lemmas.0.Array.size_reverse.go | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (as : Array α) (i : ℕ) (j : Fin as.size), (Array.reverse.loop as i j).size = as.size |
_private.Mathlib.Topology.Instances.AddCircle.Defs.0.AddCircle.liftIoc_eq_liftIco._simp_1_1 | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y |
CategoryTheory.Functor.ranges_directed | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C]
(F : CategoryTheory.Functor C (Type u_1)) (j : C), Directed (fun x1 x2 => x1 ⊇ x2) fun f => Set.range (F.map f.snd) |
_private.Mathlib.MeasureTheory.Function.AEMeasurableOrder.0.MeasureTheory.aemeasurable_of_exist_almost_disjoint_supersets._proof_1_1 | Mathlib.MeasureTheory.Function.AEMeasurableOrder | ∀ {α : Type u_2} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) {β : Type u_1} [inst : CompleteLinearOrder β]
(s : Set β) (f : α → β) (u v : β → β → Set α),
(∀ (p q : β),
MeasurableSet (u p q) ∧
MeasurableSet (v p q) ∧
{x | f x < p} ⊆ u p q ∧ {x | q < f x} ⊆ v p q ∧ (p ∈ s → q ∈ s → p < q → μ (u p q ∩ v p q) = 0)) →
∑' (p : { x // x ∈ s }) (q : { x // x ∈ s ∩ Set.Ioi ↑p }), μ (u ↑p ↑q ∩ v ↑p ↑q) =
∑' (p : { x // x ∈ s }) (x : { x // x ∈ s ∩ Set.Ioi ↑p }), 0 |
List.Cursor.tail.eq_1 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} (s : l.Cursor) (h : 0 < s.suffix.length),
s.tail h = { «prefix» := s.prefix ++ [s.current h], suffix := s.suffix.tail, property := ⋯ } |
CategoryTheory.MonoidalClosed.whiskerLeft_curry'_ihom_ev_app | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
[inst_2 : CategoryTheory.Closed X] (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalClosed.curry' f))
((CategoryTheory.ihom.ev X).app Y) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom f |
PosNum.commMonoid._proof_6 | Mathlib.Data.Num.Lemmas | ∀ (a b : PosNum), a * b = b * a |
Std.ExtHashMap.getD_diff_of_not_mem_left | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β}, k ∉ m₁ → (m₁ \ m₂).getD k fallback = fallback |
Std.DTreeMap.Raw.maxKeyD_insert | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {v : β k} {fallback : α},
(t.insert k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k' |
_private.Mathlib.LinearAlgebra.Matrix.Nondegenerate.0.LinearIndependent.sum_smul_of_nondegenerate._simp_1_3 | Mathlib.LinearAlgebra.Matrix.Nondegenerate | ∀ {α : Type u_5} {M : Type u_9} {N : Type u_10} [inst : SMul M N] [inst_1 : SMul N α] [inst_2 : SMul M α]
[IsScalarTower M N α] (x : M) (y : N) (z : α), x • y • z = (x • y) • z |
AlgebraicGeometry.Scheme.Cover.pushforwardIso | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
[P.RespectsIso] →
[P.ContainsIdentities] →
[P.IsStableUnderComposition] →
{X Y : AlgebraicGeometry.Scheme} →
AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X →
(f : X ⟶ Y) →
[CategoryTheory.IsIso f] → AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) Y |
CategoryTheory.Oplax.LaxTrans.Modification.instInhabited | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} →
{η : F ⟶ G} → Inhabited (CategoryTheory.Oplax.LaxTrans.Modification η η) |
Set.Pairwise.imp_on | Mathlib.Logic.Pairwise | ∀ {α : Type u_1} {r p : α → α → Prop} {s : Set α}, s.Pairwise r → (s.Pairwise fun ⦃a b⦄ => r a b → p a b) → s.Pairwise p |
_private.Mathlib.Data.List.Defs.0.List.map₂Left'.match_1.eq_1 | Mathlib.Data.List.Defs | ∀ {α : Type u_1} {β : Type u_2} (motive : List α → List β → Sort u_3) (bs : List β) (h_1 : (bs : List β) → motive [] bs)
(h_2 : (a : α) → (as : List α) → motive (a :: as) [])
(h_3 : (a : α) → (as : List α) → (b : β) → (bs : List β) → motive (a :: as) (b :: bs)),
(match [], bs with
| [], bs => h_1 bs
| a :: as, [] => h_2 a as
| a :: as, b :: bs => h_3 a as b bs) =
h_1 bs |
MDifferentiableOn.congr_mono | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f f₁ : M → M'} {s t : Set M},
MDiff[s] f → (∀ x ∈ t, f₁ x = f x) → t ⊆ s → MDiff[t] f₁ |
_private.Mathlib.Order.Category.PartOrdEmb.0.PartOrdEmb.Hom.ext.match_1 | Mathlib.Order.Category.PartOrdEmb | ∀ {X Y : PartOrdEmb} (motive : X.Hom Y → Prop) (h : X.Hom Y), (∀ (hom' : ↑X ↪o ↑Y), motive { hom' := hom' }) → motive h |
CategoryTheory.Functor.coconeTypesEquiv_symm_apply_ι | Mathlib.CategoryTheory.Limits.Types.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J (Type u))
(c : CategoryTheory.Limits.Cocone F) (j : J) (a : F.obj j), (F.coconeTypesEquiv.symm c).ι j a = c.ι.app j a |
InfiniteGalois.normalAutEquivQuotient._proof_3 | Mathlib.FieldTheory.Galois.Infinite | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K]
(H : ClosedSubgroup Gal(K/k)), IsScalarTower k (↥(IntermediateField.fixedField ↑H)) K |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.artanh_eq_half_log._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ {x : ℝ}, x ∈ Set.Icc (-1) 1 → 0 ≤ 1 + x |
ModelWithCorners.compl_boundary | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M],
(ModelWithCorners.boundary M)ᶜ = ModelWithCorners.interior M |
Std.Rii.mk.sizeOf_spec | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} [inst : SizeOf α], sizeOf *...* = 1 |
AddCommMonCat.coyonedaObjIsoForget._proof_1 | Mathlib.Algebra.Category.MonCat.ForgetCorepresentable | ∀ {X Y : AddCommMonCat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.coyoneda.obj (Opposite.op (AddCommMonCat.of (ULift.{u_1, 0} ℕ)))).map f)
((fun M => (CategoryTheory.ConcreteCategory.homEquiv.trans (uliftMultiplesHom ↑M).symm).toIso) Y).hom =
CategoryTheory.CategoryStruct.comp
((fun M => (CategoryTheory.ConcreteCategory.homEquiv.trans (uliftMultiplesHom ↑M).symm).toIso) X).hom
((CategoryTheory.forget AddCommMonCat).map f) |
CharTwo.add_eq_iff_eq_add | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} [inst : Ring R] [CharP R 2] {a b c : R}, a + b = c ↔ a = c + b |
WeierstrassCurve.Jacobian.dblU_ne_zero_of_Y_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P Q : Fin 3 → F},
W.Nonsingular P →
P 2 ≠ 0 →
Q 2 ≠ 0 →
P 0 * Q 2 ^ 2 = Q 0 * P 2 ^ 2 →
P 1 * Q 2 ^ 3 = Q 1 * P 2 ^ 3 → P 1 * Q 2 ^ 3 = W.negY Q * P 2 ^ 3 → W.dblU P ≠ 0 |
MeasureTheory.condExp_stronglyMeasurable_simpleFunc_mul | Mathlib.MeasureTheory.Function.ConditionalExpectation.PullOut | ∀ {Ω : Type u_1} {m mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω},
m ≤ mΩ →
∀ (f : MeasureTheory.SimpleFunc Ω ℝ) {g : Ω → ℝ}, MeasureTheory.Integrable g μ → μ[⇑f * g | m] =ᵐ[μ] ⇑f * μ[g | m] |
CategoryTheory.Presieve.map.casesOn | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X : C} {s : CategoryTheory.Presieve X}
{motive : ⦃Y : D⦄ → (a : Y ⟶ F.obj X) → CategoryTheory.Presieve.map F s a → Prop} ⦃Y : D⦄ {a : Y ⟶ F.obj X}
(t : CategoryTheory.Presieve.map F s a), (∀ {Y : C} {u : Y ⟶ X} (h : s u), motive (F.map u) ⋯) → motive a t |
_private.Mathlib.Topology.Algebra.InfiniteSum.ENNReal.0.Summable.toNNReal._simp_1_1 | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] (a : α), (a ≤ |a|) = True |
Lean.AttributeImpl._sizeOf_inst | Lean.Attributes | SizeOf Lean.AttributeImpl |
IsLocalization.map_smul | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [inst_4 : IsLocalization M S] {g : R →+* P}
{T : Submonoid P} {Q : Type u_4} [inst_5 : CommSemiring Q] [inst_6 : Algebra P Q] [inst_7 : IsLocalization T Q]
(hy : M ≤ Submonoid.comap g T) (x : S) (z : R),
(IsLocalization.map Q g hy) (z • x) = g z • (IsLocalization.map Q g hy) x |
MulHom.prodMap_def | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} {M' : Type u_6} {N' : Type u_7} [inst : Mul M] [inst_1 : Mul N] [inst_2 : Mul M']
[inst_3 : Mul N'] (f : M →ₙ* M') (g : N →ₙ* N'),
f.prodMap g = (f.comp (MulHom.fst M N)).prod (g.comp (MulHom.snd M N)) |
TopologicalSpace.Opens.inclusion'_top_functor | Mathlib.Topology.Category.TopCat.Opens | ∀ (X : TopCat), ⋯.functor = TopologicalSpace.Opens.map (TopologicalSpace.Opens.inclusionTopIso X).inv |
_private.Mathlib.Analysis.Complex.Order.0.Mathlib.Meta.Positivity.evalComplexOfReal.match_7 | Mathlib.Analysis.Complex.Order | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(x : Q(Zero «$α»)) →
(x_1 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) → Sort u_1) →
(u : Lean.Level) →
{α : Q(Type u)} →
(x : Q(Zero «$α»)) →
(x_1 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_1 __alt_2 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e)) →
((α : Q(Type)) →
(x : Q(Zero «$α»)) →
(x_2 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_3 __alt_4 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_2 e)) →
motive Lean.Level.zero x x_2 e __alt __alt_3 __alt_4) →
((x : Lean.Level) →
(α : Q(Type x)) →
(x_2 : Q(Zero «$α»)) →
(x_3 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
(__alt __alt_3 __alt_4 : Lean.MetaM (Mathlib.Meta.Positivity.Strictness x_2 x_3 e)) →
motive x x_2 x_3 e __alt __alt_3 __alt_4) →
motive u x x_1 e __alt __alt_1 __alt_2 |
Real.two_mul_sin_mul_sin | Mathlib.Analysis.Complex.Trigonometric | ∀ (x y : ℝ), 2 * Real.sin x * Real.sin y = Real.cos (x - y) - Real.cos (x + y) |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.repr_opow_aux₂._simp_1_7 | Mathlib.SetTheory.Ordinal.Notation | ∀ {x y : ONote}, (x < y) = (x.repr < y.repr) |
Subgroup.instHasDetOneMapSpecialLinearGroupGeneralLinearGroupMapGL | Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups | ∀ {n : Type u_1} [inst : Fintype n] [inst_1 : DecidableEq n] {R : Type u_2} [inst_2 : CommRing R] {S : Type u_3}
[inst_3 : CommRing S] [inst_4 : Algebra R S] (Γ : Subgroup (Matrix.SpecialLinearGroup n R)),
(Subgroup.map (Matrix.SpecialLinearGroup.mapGL S) Γ).HasDetOne |
Std.Sat.AIG.unsat_relabel | Std.Sat.AIG.Relabel | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {β : Type} [inst_2 : Hashable β] [inst_3 : DecidableEq β]
{idx : ℕ} {invert : Bool} {aig : Std.Sat.AIG α} (r : α → β) {hidx : idx < aig.decls.size},
aig.UnsatAt idx invert hidx → (Std.Sat.AIG.relabel r aig).UnsatAt idx invert ⋯ |
retractionKerCotangentToTensorEquivSection._proof_18 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_3} {P : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R P S],
KaehlerDifferential.kerCotangentToTensor R P S =
↑(LinearEquiv.restrictScalars P (tensorKaehlerQuotKerSqEquiv R P S)) ∘ₗ
↑P (KaehlerDifferential.kerToTensor R (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S) ∘ₗ
↑((RingHom.ker (algebraMap P S)).cotangentEquivIdeal.trans
(LinearEquiv.restrictScalars P
(LinearEquiv.ofEq (RingHom.ker (IsScalarTower.toAlgHom R P S).toRingHom).cotangentIdeal
(RingHom.ker (IsScalarTower.toAlgHom R P S).kerSquareLift.toRingHom) ⋯))) →
∀
(l :
TensorProduct (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S
Ω[P ⧸ RingHom.ker (algebraMap P S) ^ 2⁄R] →ₗ[P ⧸ RingHom.ker (algebraMap P S) ^ 2]
↥(RingHom.ker (algebraMap (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S))),
l ∘ₗ KaehlerDifferential.kerToTensor R (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S = LinearMap.id →
(↑((RingHom.ker (algebraMap P S)).cotangentEquivIdeal.trans
(LinearEquiv.restrictScalars P
(LinearEquiv.ofEq (RingHom.ker (IsScalarTower.toAlgHom R P S).toRingHom).cotangentIdeal
(RingHom.ker (IsScalarTower.toAlgHom R P S).kerSquareLift.toRingHom) ⋯))).symm ∘ₗ
↑P l ∘ₗ ↑(LinearEquiv.restrictScalars P (tensorKaehlerQuotKerSqEquiv R P S)).symm) ∘ₗ
KaehlerDifferential.kerCotangentToTensor R P S =
LinearMap.id |
WittVector.frobenius_zmodp | Mathlib.RingTheory.WittVector.Frobenius | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (x : WittVector p (ZMod p)), WittVector.frobenius x = x |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_union_of_not_mem._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
PLift.instNonempty_mathlib | Mathlib.Data.ULift | ∀ {α : Sort u} [Nonempty α], Nonempty (PLift α) |
_private.Mathlib.Data.ZMod.Basic.0.ZModModule.two_le_char._proof_1_1 | Mathlib.Data.ZMod.Basic | ∀ (n : ℕ), n ≠ 0 → n ≠ 1 → 2 ≤ n |
Nat.factorization_choose_eq_zero_of_lt | Mathlib.Data.Nat.Choose.Factorization | ∀ {p n k : ℕ}, n < p → (n.choose k).factorization p = 0 |
Nonneg.instIsOrderedModule | Mathlib.Algebra.Order.Nonneg.Module | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : PartialOrder M] [inst_4 : SMulWithZero R M] [hM : IsOrderedModule R M], IsOrderedModule { c // 0 ≤ c } M |
Real.tanh_arsinh | Mathlib.Analysis.SpecialFunctions.Arsinh | ∀ (x : ℝ), Real.tanh (Real.arsinh x) = x / √(1 + x ^ 2) |
Lean.Literal.type | Lean.Expr | Lean.Literal → Lean.Expr |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionAssocNatIso_hom_app_app_app | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (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.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (X X_1 : C) (X_2 : D),
(((CategoryTheory.MonoidalCategory.MonoidalRightAction.actionAssocNatIso C D).hom.app X).app X_1).app X_2 =
(CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionAssocIso X_2 X X_1).hom |
Set.Icc_eq_empty_of_lt | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b < a → Set.Icc a b = ∅ |
Lean.Meta.Grind.closeGoal | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Lean.Meta.Grind.GoalM Unit |
HasFDerivAt.of_isLittleOTVS | Mathlib.Analysis.Calculus.FDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {f' : E →L[𝕜] F} {x : E},
((fun x' => f x' - f x - f' (x' - x)) =o[𝕜; nhds x] fun x' => x' - x) → HasFDerivAt f f' x |
Mathlib.Tactic.FieldSimp.Sign.div | Mathlib.Tactic.FieldSimp.Lemmas | {v : Lean.Level} →
{M : Q(Type v)} →
(iM : Q(CommGroupWithZero «$M»)) →
(y₁ y₂ : Q(«$M»)) →
(g₁ g₂ : Mathlib.Tactic.FieldSimp.Sign M) →
Lean.MetaM
((G : Mathlib.Tactic.FieldSimp.Sign M) ×
have a := G.expr q(«$y₁» / «$y₂»);
have a_1 := g₂.expr y₂;
have a_2 := g₁.expr y₁;
Q(«$a_2» / «$a_1» = «$a»)) |
CategoryTheory.Oplax.StrongTrans.Modification.casesOn | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} →
{motive : CategoryTheory.Oplax.StrongTrans.Modification η θ → Sort u} →
(t : CategoryTheory.Oplax.StrongTrans.Modification η θ) →
((app : (a : B) → η.app a ⟶ θ.app a) →
(naturality :
∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (app b))
(θ.naturality f).hom =
CategoryTheory.CategoryStruct.comp (η.naturality f).hom
(CategoryTheory.Bicategory.whiskerRight (app a) (G.map f))) →
motive { app := app, naturality := naturality }) →
motive t |
Bipointed.X | Mathlib.CategoryTheory.Category.Bipointed | Bipointed → Type u |
Std.DTreeMap.Raw.Equiv.getKeyGTD_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
{k fallback : α}, t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.getKeyGTD k fallback = t₂.getKeyGTD k fallback |
CategoryTheory.Abelian.SpectralObject.isoMapFourδ₁Toδ₀'._auto_1 | Mathlib.Algebra.Homology.SpectralObject.EpiMono | Lean.Syntax |
Subgroup.strictPeriods_eq_zmultiples_one_of_T_mem | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {Γ : Subgroup (Matrix.SpecialLinearGroup (Fin 2) ℤ)},
ModularGroup.T ∈ Γ → (Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) Γ).strictPeriods = AddSubgroup.zmultiples 1 |
AlgebraicGeometry.Scheme.coprodPresheafObjIso._proof_2 | Mathlib.AlgebraicGeometry.Limits | ∀ {X Y : AlgebraicGeometry.Scheme} (U : (X ⨿ Y).Opens),
(AlgebraicGeometry.Scheme.Hom.opensFunctor CategoryTheory.Limits.coprod.inl).obj
((TopologicalSpace.Opens.map CategoryTheory.Limits.coprod.inl.base).obj U) ⊓
(AlgebraicGeometry.Scheme.Hom.opensFunctor CategoryTheory.Limits.coprod.inr).obj
((TopologicalSpace.Opens.map CategoryTheory.Limits.coprod.inr.base).obj U) =
⊥ |
SimpleGraph.chromaticNumber_bddBelow | Mathlib.Combinatorics.SimpleGraph.Coloring | ∀ {V : Type u} {G : SimpleGraph V}, BddBelow {n | G.Colorable n} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.