name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.PRange.LawfulUpwardEnumerableLE.recOn | Init.Data.Range.Polymorphic.UpwardEnumerable | {α : Type u} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : LE α] →
{motive : Std.PRange.LawfulUpwardEnumerableLE α → Sort u_1} →
(t : Std.PRange.LawfulUpwardEnumerableLE α) →
((le_iff : ∀ (a b : α), a ≤ b ↔ Std.PRange.UpwardEnumerable.LE a b) → motive ⋯) → motive t |
_private.Mathlib.Tactic.GCongr.Core.0.Mathlib.Tactic.GCongr.introN.match_1 | Mathlib.Tactic.GCongr.Core | (motive : List (Lean.TSyntax `Lean.binderIdent) × Array Lean.FVarId × Lean.MVarId → Sort u_1) →
(__discr : List (Lean.TSyntax `Lean.binderIdent) × Array Lean.FVarId × Lean.MVarId) →
((patterns : List (Lean.TSyntax `Lean.binderIdent)) →
(fst : Array Lean.FVarId) → (goal : Lean.MVarId) → motive (patterns, fst, goal)) →
motive __discr |
RingHom.Flat.ofLocalizationSpanTarget | Mathlib.RingTheory.RingHom.Flat | RingHom.OfLocalizationSpanTarget fun {R S} [CommRing R] [CommRing S] => RingHom.Flat |
Num.castNum_shiftLeft | Mathlib.Data.Num.Lemmas | ∀ (m : Num) (n : ℕ), ↑(m <<< n) = ↑m <<< n |
cuspFunction_smul | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {h : ℝ} {f : UpperHalfPlane → ℂ},
ContinuousAt (SlashInvariantFormClass.cuspFunction h f) 0 →
∀ (a : ℂ), SlashInvariantFormClass.cuspFunction h (a • f) = a • SlashInvariantFormClass.cuspFunction h f |
Polynomial.monic_toSubring._simp_1 | Mathlib.RingTheory.Polynomial.Subring | ∀ {R : Type u_1} [inst : Ring R] (p : Polynomial R) (T : Subring R) (hp : ↑p.coeffs ⊆ ↑T),
(p.toSubring T hp).Monic = p.Monic |
IsSymmetricAlgebra.lift.eq_1 | Mathlib.LinearAlgebra.SymmetricAlgebra.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {A : Type u_3}
[inst_3 : CommSemiring A] [inst_4 : Algebra R A] {f : M →ₗ[R] A} (h : IsSymmetricAlgebra f) {A' : Type u_4}
[inst_5 : CommSemiring A'] [inst_6 : Algebra R A'] (g : M →ₗ[R] A'),
h.lift g = (SymmetricAlgebra.lift g).comp ↑h.equiv.symm |
IntermediateField.relrank_mul_relrank | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B C : IntermediateField F E},
A ≤ B → B ≤ C → A.relrank B * B.relrank C = A.relrank C |
HomologicalComplex.XIsoOfEq | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{c : ComplexShape ι} → (K : HomologicalComplex V c) → {p q : ι} → p = q → (K.X p ≅ K.X q) |
Array.filterMap_some_fun | Init.Data.Array.Lemmas | ∀ {α : Type u_1}, (fun as => Array.filterMap some as) = id |
CochainComplex.ιTruncLE_naturality_assoc | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : CategoryTheory.Limits.HasZeroObject C]
[inst_3 : ∀ (i : ℤ), HomologicalComplex.HasHomology K i] [inst_4 : ∀ (i : ℤ), HomologicalComplex.HasHomology L i]
(n : ℤ) {Z : CochainComplex C ℤ} (h : L ⟶ Z),
CategoryTheory.CategoryStruct.comp (CochainComplex.truncLEMap φ n)
(CategoryTheory.CategoryStruct.comp (L.ιTruncLE n) h) =
CategoryTheory.CategoryStruct.comp (K.ιTruncLE n) (CategoryTheory.CategoryStruct.comp φ h) |
LightProfinite.Extend.functorOp_map | Mathlib.Topology.Category.LightProfinite.Extend | ∀ {F : CategoryTheory.Functor ℕᵒᵖ FintypeCat} (c : CategoryTheory.Limits.Cone (F.comp FintypeCat.toLightProfinite))
{X Y : ℕ} (f : X ⟶ Y),
(LightProfinite.Extend.functorOp c).map f = CategoryTheory.CostructuredArrow.homMk (F.map f.op).op ⋯ |
Lean.Grind.AddRightCancel.mk._flat_ctor | Init.Grind.Module.Basic | ∀ {M : Type u} [inst : Add M], (∀ (a b c : M), a + c = b + c → a = b) → Lean.Grind.AddRightCancel M |
Language.mem_add | Mathlib.Computability.Language | ∀ {α : Type u_1} (l m : Language α) (x : List α), x ∈ l + m ↔ x ∈ l ∨ x ∈ m |
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.input.injEq | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ (p p_1 : Lean.Grind.CommRing.Poly),
(Lean.Meta.Grind.Arith.CommRing.PolyDerivation.input p = Lean.Meta.Grind.Arith.CommRing.PolyDerivation.input p_1) =
(p = p_1) |
Part.notMem_none._simp_1 | Mathlib.Data.Part | ∀ {α : Type u_1} (a : α), (a ∈ Part.none) = False |
RingQuot.definition._proof_4._@.Mathlib.Algebra.RingQuot.3469094938._hygCtx._hyg.2 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop) (x y : R),
{ toQuot := Quot.mk (RingQuot.Rel r) (x + y) } =
{ toQuot := Quot.mk (RingQuot.Rel r) x } + { toQuot := Quot.mk (RingQuot.Rel r) y } |
CategoryTheory.Square.toArrowArrowFunctor'._proof_1 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : CategoryTheory.Square C} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp φ.τ₁ Y.f₁₂ = CategoryTheory.CategoryStruct.comp X.f₁₂ φ.τ₂ |
Pell.pellZd_sub | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) {m n : ℕ}, n ≤ m → Pell.pellZd a1 (m - n) = Pell.pellZd a1 m * star (Pell.pellZd a1 n) |
List.pmap_attachWith | Init.Data.List.Attach | ∀ {α : Type u_1} {q : α → Prop} {β : Type u_2} {l : List α} {p : { x // q x } → Prop} {f : (a : { x // q x }) → p a → β}
(H₁ : ∀ x ∈ l, q x) (H₂ : ∀ a ∈ l.attachWith q H₁, p a),
List.pmap f (l.attachWith q H₁) H₂ = List.pmap (fun a h => f ⟨a, ⋯⟩ ⋯) l ⋯ |
Lean.protectedExt | Lean.Modifiers | Lean.TagDeclarationExtension |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.IsTerminal.casesOn | Mathlib.CategoryTheory.Presentable.Directed | {J : Type w} →
[inst : CategoryTheory.SmallCategory J] →
{κ : Cardinal.{w}} →
{D : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ} →
{e : J} →
{motive : D.IsTerminal e → Sort u} →
(t : D.IsTerminal e) →
((prop_id : D.W (CategoryTheory.CategoryStruct.id e)) →
(lift : {j : J} → D.P j → (j ⟶ e)) →
(hlift : ∀ {j : J} (hj : D.P j), D.W (lift hj)) →
(uniq : ∀ {j : J} (hj : D.P j) {φ : j ⟶ e}, D.W φ → lift hj = φ) →
(comm :
∀ {i j : J} (f : i ⟶ j) (hf : D.W f),
CategoryTheory.CategoryStruct.comp f (lift ⋯) = lift ⋯) →
motive { prop_id := prop_id, lift := lift, hlift := hlift, uniq := uniq, comm := comm }) →
motive t |
Std.Do.SPred.and_or_right | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R : Std.Do.SPred σs}, P ∧ Q ∨ R ⊣⊢ₛ (P ∨ R) ∧ (Q ∨ R) |
_private.Mathlib.Topology.Separation.Regular.0.IsCompact.nhdsSet_basis_isCompact_isClosed.match_1_2 | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] {K : Set X} (U : Set X) (motive : IsOpen U ∧ K ⊆ U → Prop)
(h : IsOpen U ∧ K ⊆ U), (∀ (hU : IsOpen U) (h_KU : K ⊆ U), motive ⋯) → motive h |
CategoryTheory.CatCenter.mul_app | Mathlib.CategoryTheory.Center.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x y : CategoryTheory.CatCenter C) (X : C),
(x * y).app X = CategoryTheory.CategoryStruct.comp (x.app X) (y.app X) |
Int8.xor_neg_one | Init.Data.SInt.Bitwise | ∀ {a : Int8}, a ^^^ -1 = ~~~a |
PerfectClosure.instDivisionRing._proof_15 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : Field K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (e : PerfectClosure K p),
e ≠ 0 → e * e⁻¹ = 1 |
Subarray.toArray_mkSlice_rio | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {hi : ℕ},
Std.Slice.toArray (Std.Rio.Sliceable.mkSlice xs *...hi) = (Std.Slice.toArray xs).extract 0 hi |
_private.Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing.0.AlgebraicGeometry.SheafedSpace.GlueData.«term𝖣» | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | Lean.ParserDescr |
_private.Mathlib.Algebra.Lie.LieTheorem.0.LieModule.exists_nontrivial_weightSpace_of_isSolvable.match_1_1 | Mathlib.Algebra.Lie.LieTheorem | ∀ (k : Type u_1) [inst : Field k] (V : Type u_2) [inst_1 : AddCommGroup V] [inst_2 : Module k V]
(imL : LieSubalgebra k (Module.End k V)) (motive : (∃ χ, Nontrivial ↥(LieModule.weightSpace V ⇑χ)) → Prop)
(x : ∃ χ, Nontrivial ↥(LieModule.weightSpace V ⇑χ)),
(∀ (χ : Module.Dual k ↥imL) (h : Nontrivial ↥(LieModule.weightSpace V ⇑χ)), motive ⋯) → motive x |
CategoryTheory.ShortComplex.unop_f | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex Cᵒᵖ), S.unop.f = S.g.unop |
TopologicalSpace.UpgradedIsCompletelyPseudoMetrizableSpace.recOn | Mathlib.Topology.Metrizable.CompletelyMetrizable | {X : Type u_3} →
{motive : TopologicalSpace.UpgradedIsCompletelyPseudoMetrizableSpace X → Sort u} →
(t : TopologicalSpace.UpgradedIsCompletelyPseudoMetrizableSpace X) →
([toPseudoMetricSpace : PseudoMetricSpace X] →
[toCompleteSpace : CompleteSpace X] →
motive { toPseudoMetricSpace := toPseudoMetricSpace, toCompleteSpace := toCompleteSpace }) →
motive t |
Valuation.ltAddSubgroup._proof_3 | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
(γ : Γ₀ˣ) {x y : R}, x ∈ {x | v x < ↑γ} → y ∈ {x | v x < ↑γ} → v (x + y) < ↑γ |
Antitone.rightLim_le | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
[inst_2 : TopologicalSpace β] [OrderTopology β] {f : α → β},
Antitone f → ∀ {x y : α}, x ≤ y → Function.rightLim f y ≤ f x |
ApproximatesLinearOn.toOpenPartialHomeomorph_source | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : E → F)
{f' : E ≃L[𝕜] F} (s : Set E) {c : NNReal} [inst_5 : CompleteSpace E] (hf : ApproximatesLinearOn f (↑f') s c)
(hc : Subsingleton E ∨ c < ‖↑f'.symm‖₊⁻¹) (hs : IsOpen s),
(ApproximatesLinearOn.toOpenPartialHomeomorph f s hf hc hs).source = s |
MeasureTheory.measure_smul_eq_zero_iff | Mathlib.MeasureTheory.Group.Action | ∀ {G : Type u} {α : Type w} {m : MeasurableSpace α} [inst : Group G] [inst_1 : MulAction G α]
{μ : MeasureTheory.Measure α} [MeasureTheory.SMulInvariantMeasure G α μ] {s : Set α} (c : G), μ (c • s) = 0 ↔ μ s = 0 |
Subfield.charP | Mathlib.Algebra.CharP.Algebra | ∀ {R : Type u_1} [inst : DivisionRing R] (L : Subfield R) (p : ℕ) [CharP R p], CharP (↥L) p |
Lean.instToJsonImport.toJson | Lean.Setup | Lean.Import → Lean.Json |
SimplexCategory.orderIsoOfIso.eq_1 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {x y : SimplexCategory} (e : x ≅ y),
SimplexCategory.orderIsoOfIso e =
{ toFun := ⇑(SimplexCategory.Hom.toOrderHom e.hom), invFun := ⇑(SimplexCategory.Hom.toOrderHom e.inv),
left_inv := ⋯, right_inv := ⋯ }.toOrderIso
⋯ ⋯ |
CochainComplex.ConnectData.mk.sizeOf_spec | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} [inst_2 : SizeOf C] (d₀ : K.X 0 ⟶ L.X 0)
(comp_d₀ : CategoryTheory.CategoryStruct.comp (K.d 1 0) d₀ = 0)
(d₀_comp : CategoryTheory.CategoryStruct.comp d₀ (L.d 0 1) = 0),
sizeOf { d₀ := d₀, comp_d₀ := comp_d₀, d₀_comp := d₀_comp } = 1 + sizeOf d₀ + sizeOf comp_d₀ + sizeOf d₀_comp |
ProbabilityTheory.IsGaussianProcess.hasGaussianLaw_fun_add | Mathlib.Probability.Distributions.Gaussian.IsGaussianProcess.Basic | ∀ {T : Type u_2} {Ω : Type u_3} {E : Type u_4} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {X : T → Ω → E}
[inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [BorelSpace E] [inst_3 : NormedSpace ℝ E]
[SecondCountableTopology E],
ProbabilityTheory.IsGaussianProcess X P → ∀ {s t : T}, ProbabilityTheory.HasGaussianLaw (fun ω => X s ω + X t ω) P |
NONote.instMul | Mathlib.SetTheory.Ordinal.Notation | Mul NONote |
MeasureTheory.IsLocallyFiniteMeasure.recOn | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} →
{m0 : MeasurableSpace α} →
[inst : TopologicalSpace α] →
{μ : MeasureTheory.Measure α} →
{motive : MeasureTheory.IsLocallyFiniteMeasure μ → Sort u} →
(t : MeasureTheory.IsLocallyFiniteMeasure μ) →
((finiteAtNhds : ∀ (x : α), μ.FiniteAtFilter (nhds x)) → motive ⋯) → motive t |
Lean.Server.Test.Runner.Client.MsgEmbed.brecOn_3.go | Lean.Server.Test.Runner | {motive_1 : Lean.Server.Test.Runner.Client.MsgEmbed → Sort u} →
{motive_2 : Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed → Sort u} →
{motive_3 :
Lean.Server.Test.Runner.Client.StrictOrLazy
(Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed)) Lean.Lsp.RpcRef →
Sort u} →
{motive_4 : Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed) → Sort u} →
{motive_5 : List (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed) → Sort u} →
(t : Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed)) →
((t : Lean.Server.Test.Runner.Client.MsgEmbed) → t.below → motive_1 t) →
((t : Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed) →
Lean.Server.Test.Runner.Client.MsgEmbed.below_1 t → motive_2 t) →
((t :
Lean.Server.Test.Runner.Client.StrictOrLazy
(Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed)) Lean.Lsp.RpcRef) →
Lean.Server.Test.Runner.Client.MsgEmbed.below_2 t → motive_3 t) →
((t : Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed)) →
Lean.Server.Test.Runner.Client.MsgEmbed.below_3 t → motive_4 t) →
((t : List (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed)) →
Lean.Server.Test.Runner.Client.MsgEmbed.below_4 t → motive_5 t) →
motive_4 t ×' Lean.Server.Test.Runner.Client.MsgEmbed.below_3 t |
UInt32.le_trans | Init.Data.UInt.Lemmas | ∀ {a b c : UInt32}, a ≤ b → b ≤ c → a ≤ c |
HasFDerivWithinAt.finset_prod | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {ι : Type u_5} {𝔸' : Type u_7} [inst_3 : NormedCommRing 𝔸']
[inst_4 : NormedAlgebra 𝕜 𝔸'] {u : Finset ι} {g : ι → E → 𝔸'} {g' : ι → E →L[𝕜] 𝔸'} [inst_5 : DecidableEq ι] {x : E},
(∀ i ∈ u, HasFDerivWithinAt (g i) (g' i) s x) →
HasFDerivWithinAt (fun x => ∏ i ∈ u, g i x) (∑ i ∈ u, (∏ j ∈ u.erase i, g j x) • g' i) s x |
Nat.Linear.Expr.rec | Init.Data.Nat.Linear | {motive : Nat.Linear.Expr → Sort u} →
((v : ℕ) → motive (Nat.Linear.Expr.num v)) →
((i : Nat.Linear.Var) → motive (Nat.Linear.Expr.var i)) →
((a b : Nat.Linear.Expr) → motive a → motive b → motive (a.add b)) →
((k : ℕ) → (a : Nat.Linear.Expr) → motive a → motive (Nat.Linear.Expr.mulL k a)) →
((a : Nat.Linear.Expr) → (k : ℕ) → motive a → motive (a.mulR k)) → (t : Nat.Linear.Expr) → motive t |
Lean.Server.GoToKind.ctorElimType | Lean.Server.GoTo | {motive : Lean.Server.GoToKind → Sort u} → ℕ → Sort (max 1 u) |
AddOpposite.instNonUnitalNonAssocSemiring._proof_4 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] (a : Rᵃᵒᵖ), a * 0 = 0 |
CategoryTheory.ShortComplex.LeftHomologyMapData.mk.inj | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {inst_1 : CategoryTheory.Limits.HasZeroMorphisms C}
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : S₁.LeftHomologyData} {h₂ : S₂.LeftHomologyData}
{φK : h₁.K ⟶ h₂.K} {φH : h₁.H ⟶ h₂.H}
{commi :
autoParam (CategoryTheory.CategoryStruct.comp φK h₂.i = CategoryTheory.CategoryStruct.comp h₁.i φ.τ₂)
CategoryTheory.ShortComplex.LeftHomologyMapData.commi._autoParam}
{commf' :
autoParam (CategoryTheory.CategoryStruct.comp h₁.f' φK = CategoryTheory.CategoryStruct.comp φ.τ₁ h₂.f')
CategoryTheory.ShortComplex.LeftHomologyMapData.commf'._autoParam}
{commπ :
autoParam (CategoryTheory.CategoryStruct.comp h₁.π φH = CategoryTheory.CategoryStruct.comp φK h₂.π)
CategoryTheory.ShortComplex.LeftHomologyMapData.commπ._autoParam}
{φK_1 : h₁.K ⟶ h₂.K} {φH_1 : h₁.H ⟶ h₂.H}
{commi_1 :
autoParam (CategoryTheory.CategoryStruct.comp φK_1 h₂.i = CategoryTheory.CategoryStruct.comp h₁.i φ.τ₂)
CategoryTheory.ShortComplex.LeftHomologyMapData.commi._autoParam}
{commf'_1 :
autoParam (CategoryTheory.CategoryStruct.comp h₁.f' φK_1 = CategoryTheory.CategoryStruct.comp φ.τ₁ h₂.f')
CategoryTheory.ShortComplex.LeftHomologyMapData.commf'._autoParam}
{commπ_1 :
autoParam (CategoryTheory.CategoryStruct.comp h₁.π φH_1 = CategoryTheory.CategoryStruct.comp φK_1 h₂.π)
CategoryTheory.ShortComplex.LeftHomologyMapData.commπ._autoParam},
{ φK := φK, φH := φH, commi := commi, commf' := commf', commπ := commπ } =
{ φK := φK_1, φH := φH_1, commi := commi_1, commf' := commf'_1, commπ := commπ_1 } →
φK = φK_1 ∧ φH = φH_1 |
CategoryTheory.HasCardinalFilteredGenerator.toLocallySmall | Mathlib.CategoryTheory.Presentable.CardinalFilteredPresentation | ∀ {C : Type u} {hC : CategoryTheory.Category.{v, u} C} (κ : Cardinal.{w}) {hκ : Fact κ.IsRegular}
[self : CategoryTheory.HasCardinalFilteredGenerator C κ], CategoryTheory.LocallySmall.{w, v, u} C |
CategoryTheory.Equivalence.symmEquivInverse.eq_1 | Mathlib.CategoryTheory.Equivalence.Symmetry | ∀ (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],
CategoryTheory.Equivalence.symmEquivInverse C D =
{ obj := fun e => Opposite.op e.symm,
map := fun {e f} α =>
(CategoryTheory.Equivalence.mkHom
((CategoryTheory.conjugateEquiv e.symm.toAdjunction f.symm.toAdjunction).invFun
(CategoryTheory.Equivalence.asNatTrans α))).op,
map_id := ⋯, map_comp := ⋯ }.leftOp |
NumberField.mixedEmbedding.instDiscreteTopologySubtypeMixedSpaceMemSubmoduleIntIntegerLattice | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], DiscreteTopology ↥(NumberField.mixedEmbedding.integerLattice K) |
_private.Mathlib.Analysis.InnerProductSpace.Orthonormal.0.Orthonormal.inner_right_finsupp._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) |
CategoryTheory.CountableCategory.recOn | Mathlib.CategoryTheory.Countable | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{motive : CategoryTheory.CountableCategory J → Sort u} →
(t : CategoryTheory.CountableCategory J) →
((countableObj : Countable J) → (countableHom : ∀ (j j' : J), Countable (j ⟶ j')) → motive ⋯) → motive t |
LieAlgebra.SemiDirectSum.neg_eq_mk | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_2} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_3}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ψ : L →ₗ⁅R⁆ LieDerivation R K K) (x : K ⋊⁅ψ⁆ L),
-x = { left := -x.left, right := -x.right } |
Lean.Elab.MacroStackElem.after | Lean.Elab.Util | Lean.Elab.MacroStackElem → Lean.Syntax |
instSubsingletonAddMonoidHom | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : AddZero M] [inst_1 : AddZero N] [Subsingleton M], Subsingleton (M →+ N) |
CategoryTheory.Subobject.mapIsoToOrderIso._proof_1 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (e : X ≅ Y), CategoryTheory.Mono e.hom |
Std.ExtDTreeMap.le_maxKey?_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k km : α} (hc : k ∈ t), t.maxKey?.get ⋯ = km → (cmp k km).isLE = true |
selfAdjoint.val_mul | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonUnitalCommRing R] [inst_1 : StarRing R] (x y : ↥(selfAdjoint R)), ↑(x * y) = ↑x * ↑y |
MvPolynomial.eval_eq' | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : Fintype σ] (X : σ → R) (f : MvPolynomial σ R),
(MvPolynomial.eval X) f = ∑ d ∈ f.support, MvPolynomial.coeff d f * ∏ i, X i ^ d i |
Algebra.TensorProduct.basisAux_map_smul | Mathlib.RingTheory.TensorProduct.Free | ∀ {R : Type u_1} {A : Type u_2} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] (b : Module.Basis ι R M) (a : A)
(x : TensorProduct R A M), (Algebra.TensorProduct.basisAux A b) (a • x) = a • (Algebra.TensorProduct.basisAux A b) x |
IsAlgClosed.mk | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {k : Type u} [inst : Field k], (∀ (p : Polynomial k), p.Splits) → IsAlgClosed k |
Monoid.Coprod.instGroup._proof_3 | Mathlib.GroupTheory.Coprod.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] (n : ℕ) (a : Monoid.Coprod G H),
zpowRec npowRec (↑n.succ) a = zpowRec npowRec (↑n) a * a |
Std.Iterators.HetT.property_bind | Std.Data.Iterators.Lemmas.Equivalence.HetT | ∀ {m : Type w → Type w'} {α : Type u} {β : Type v} [inst : Monad m] [LawfulMonad m] {x : Std.Iterators.HetT m α}
{f : α → Std.Iterators.HetT m β}, (x.bind f).Property = fun b => ∃ a, x.Property a ∧ (f a).Property b |
Lean.Name.toStringWithSep | Init.Data.ToString.Name | String → Bool → Lean.Name → (optParam (String → Bool) fun x => false) → String |
Quaternion.instDivisionRing._proof_4 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] (x : ℚ) (x_1 : Quaternion R), x • x_1 = ↑x * x_1 |
iSup_add_le | Mathlib.Order.CompleteLattice.Group | ∀ {α : Type u_1} {ι : Sort u_2} [inst : CompleteLattice α] [inst_1 : Add α] [AddLeftMono α] [AddRightMono α]
(u v : ι → α), ⨆ i, u i + v i ≤ (⨆ i, u i) + ⨆ i, v i |
Filter.Germ.instRightCancelSemigroup.eq_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_5} [inst : RightCancelSemigroup M],
Filter.Germ.instRightCancelSemigroup = { toSemigroup := Filter.Germ.instSemigroup, toIsRightCancelMul := ⋯ } |
CategoryTheory.ComposableArrows.map'._auto_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax |
ContinuousLinearEquiv.ofBijective_symm_apply_apply | Mathlib.Analysis.Normed.Operator.Banach | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜'] {σ : 𝕜 →+* 𝕜'}
{E : Type u_3} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {F : Type u_4}
[inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace 𝕜' F] {σ' : 𝕜' →+* 𝕜} [inst_6 : RingHomInvPair σ σ']
[inst_7 : RingHomIsometric σ] [inst_8 : RingHomIsometric σ'] [inst_9 : CompleteSpace F] [inst_10 : CompleteSpace E]
[inst_11 : RingHomInvPair σ' σ] (f : E →SL[σ] F) (hinj : (↑f).ker = ⊥) (hsurj : (↑f).range = ⊤) (x : E),
(ContinuousLinearEquiv.ofBijective f hinj hsurj).symm (f x) = x |
OrderHom.prodₘ | Mathlib.Order.Hom.Basic | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : Preorder α] → [inst_1 : Preorder β] → [inst_2 : Preorder γ] → (α →o β) →o (α →o γ) →o α →o β × γ |
Matrix.mem_range_scalar_iff_commute_single' | Mathlib.Data.Matrix.Basis | ∀ {n : Type u_3} {α : Type u_7} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : Semiring α] {M : Matrix n n α},
M ∈ Set.range ⇑(Matrix.scalar n) ↔ ∀ (i j : n), Commute (Matrix.single i j 1) M |
CategoryTheory.extensiveCoverage.eq_1 | Mathlib.CategoryTheory.Sites.Coherent.Comparison | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.FinitaryPreExtensive C],
CategoryTheory.extensiveCoverage C =
{
coverings := fun B =>
{S |
∃ α,
∃ (x : Finite α),
∃ X π,
S = CategoryTheory.Presieve.ofArrows X π ∧ CategoryTheory.IsIso (CategoryTheory.Limits.Sigma.desc π)},
pullback := ⋯ } |
ProbabilityTheory.Kernel.densityProcess_mono_set | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} [inst : MeasurableSpace.CountablyGenerated γ] {κ : ProbabilityTheory.Kernel α (γ × β)}
{ν : ProbabilityTheory.Kernel α γ},
κ.fst ≤ ν →
∀ (n : ℕ) (a : α) (x : γ) {s s' : Set β}, s ⊆ s' → κ.densityProcess ν n a x s ≤ κ.densityProcess ν n a x s' |
_private.Mathlib.Combinatorics.Tiling.Tile.0.DiscreteTiling.PlacedTile.instSMul._simp_1 | Mathlib.Combinatorics.Tiling.Tile | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {a b : α}, (↑a = ↑b) = (a⁻¹ * b ∈ s) |
Subgroup.fg_iff_submonoid_fg | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_3} [inst : Group G] (P : Subgroup G), P.FG ↔ P.FG |
ModularForm.mul_coe | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k_1 k_2 : ℤ} [inst : Γ.HasDetPlusMinusOne] (f : ModularForm Γ k_1)
(g : ModularForm Γ k_2), ⇑(f.mul g) = ⇑f * ⇑g |
Nat.bitwise_of_ne_zero | Mathlib.Data.Nat.Bitwise | ∀ {f : Bool → Bool → Bool} {n m : ℕ},
n ≠ 0 → m ≠ 0 → Nat.bitwise f n m = Nat.bit (f n.bodd m.bodd) (Nat.bitwise f (n / 2) (m / 2)) |
Std.HashSet.Raw.insertMany | Std.Data.HashSet.Raw | {α : Type u} → [BEq α] → [Hashable α] → {ρ : Type v} → [ForIn Id ρ α] → Std.HashSet.Raw α → ρ → Std.HashSet.Raw α |
_private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalExposeNames._regBuiltin._private.Lean.Elab.Tactic.Grind.BuiltinTactic.0.Lean.Elab.Tactic.Grind.evalExposeNames_1 | Lean.Elab.Tactic.Grind.BuiltinTactic | IO Unit |
CategoryTheory.Bicategory.rightZigzag | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
{g : b ⟶ a} →
(CategoryTheory.CategoryStruct.id a ⟶ CategoryTheory.CategoryStruct.comp f g) →
(CategoryTheory.CategoryStruct.comp g f ⟶ CategoryTheory.CategoryStruct.id b) →
(CategoryTheory.CategoryStruct.comp g (CategoryTheory.CategoryStruct.id a) ⟶
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id b) g) |
AddAction.ofQuotientStabilizer_mk | Mathlib.GroupTheory.GroupAction.Quotient | ∀ (α : Type u) {β : Type v} [inst : AddGroup α] [inst_1 : AddAction α β] (x : β) (g : α),
AddAction.ofQuotientStabilizer α x ↑g = g +ᵥ x |
Bool.and_comm | Init.Data.Bool | ∀ (x y : Bool), (x && y) = (y && x) |
Batteries.RBMap.valuesArray | Batteries.Data.RBMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Batteries.RBMap α β cmp → Array β |
Aesop.GoalId.instLT | Aesop.Tree.Data | LT Aesop.GoalId |
_private.Lean.Elab.Tactic.Basic.0.Lean.Elab.Tactic.getMainGoal.loop._unsafe_rec | Lean.Elab.Tactic.Basic | List Lean.MVarId → Lean.Elab.Tactic.TacticM Lean.MVarId |
Set.vadd_Icc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] [AddLeftReflectLE α]
[ExistsAddOfLE α] (a b c : α), a +ᵥ Set.Icc b c = Set.Icc (a + b) (a + c) |
Vector.toArray_mk | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} (h : xs.size = n), (Vector.mk xs h).toArray = xs |
Lean.Compiler.LCNF.instInhabitedSpecState | Lean.Compiler.LCNF.SpecInfo | Inhabited Lean.Compiler.LCNF.SpecState |
Cardinal.isNormal_ord | Mathlib.SetTheory.Ordinal.Basic | Order.IsNormal Cardinal.ord |
NonUnitalSubalgebra.instIsTopologicalSemiring | Mathlib.Topology.Algebra.NonUnitalAlgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : TopologicalSpace A] [inst_2 : NonUnitalSemiring A]
[inst_3 : Module R A] [IsTopologicalSemiring A] (s : NonUnitalSubalgebra R A), IsTopologicalSemiring ↥s |
FirstOrder.Language.BoundedFormula.IsQF.below.rec | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u'} {n : ℕ} {motive : (a : L.BoundedFormula α n) → a.IsQF → Prop}
{motive_1 : {a : L.BoundedFormula α n} → (t : a.IsQF) → FirstOrder.Language.BoundedFormula.IsQF.below t → Prop},
motive_1 ⋯ ⋯ →
(∀ {φ : L.BoundedFormula α n} (h : φ.IsAtomic), motive_1 ⋯ ⋯) →
(∀ {φ₁ φ₂ : L.BoundedFormula α n} (h₁ : φ₁.IsQF) (h₂ : φ₂.IsQF)
(ih : FirstOrder.Language.BoundedFormula.IsQF.below h₁) (h₁_ih : motive φ₁ h₁)
(ih_1 : FirstOrder.Language.BoundedFormula.IsQF.below h₂) (h₂_ih : motive φ₂ h₂),
motive_1 h₁ ih → motive_1 h₂ ih_1 → motive_1 ⋯ ⋯) →
∀ {a : L.BoundedFormula α n} {t : a.IsQF} (t_1 : FirstOrder.Language.BoundedFormula.IsQF.below t),
motive_1 t t_1 |
_private.Qq.Macro.0.Qq.Impl.floatLevelAntiquot'.match_1 | Qq.Macro | (motive : Lean.Syntax → Sort u_1) →
(stx : Lean.Syntax) →
((i : Lean.SourceInfo) →
(k : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive (Lean.Syntax.node i k args)) →
((stx : Lean.Syntax) → motive stx) → motive stx |
CategoryTheory.«term_ᘁ» | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | Lean.TrailingParserDescr |
_private.Lean.Compiler.LCNF.Internalize.0.Lean.Compiler.LCNF.refreshBinderName | Lean.Compiler.LCNF.Internalize | Lean.Name → Lean.Compiler.LCNF.CompilerM Lean.Name |
Submonoid.instMin._proof_1 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : MulOneClass M] (S₁ S₂ : Submonoid M) {a b : M},
a ∈ ↑S₁ ∩ ↑S₂ → b ∈ ↑S₁ ∩ ↑S₂ → a * b ∈ ↑S₁ ∩ ↑S₂ |
_private.Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit.0.CategoryTheory.Limits.colimitLimitToLimitColimit_surjective._simp_1_3 | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z) (a : F.obj X), F.map g (F.map f a) = F.map (CategoryTheory.CategoryStruct.comp f g) a |
CategoryTheory.Limits.pullbackDiagonalMapIso.inv | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : C} →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
{U V₁ V₂ : C} →
(f : X ⟶ Y) →
(i : U ⟶ Y) →
(i₁ : V₁ ⟶ CategoryTheory.Limits.pullback f i) →
(i₂ : V₂ ⟶ CategoryTheory.Limits.pullback f i) →
[inst_2 : CategoryTheory.Limits.HasPullback i₁ i₂] →
CategoryTheory.Limits.pullback i₁ i₂ ⟶
CategoryTheory.Limits.pullback (CategoryTheory.Limits.pullback.diagonal f)
(CategoryTheory.Limits.pullback.map
(CategoryTheory.CategoryStruct.comp i₁ (CategoryTheory.Limits.pullback.snd f i))
(CategoryTheory.CategoryStruct.comp i₂ (CategoryTheory.Limits.pullback.snd f i)) f f
(CategoryTheory.CategoryStruct.comp i₁ (CategoryTheory.Limits.pullback.fst f i))
(CategoryTheory.CategoryStruct.comp i₂ (CategoryTheory.Limits.pullback.fst f i)) i ⋯ ⋯) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.