name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Inv.mk | Init.Prelude | {α : Type u} → (α → α) → Inv α |
AddSubgroup.relIindex_dvd_two_iff' | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G}, H.relIndex K ∣ 2 ↔ ∃ a ∈ K, ∀ b ∈ K, a + b ∈ H ∨ b ∈ H |
Int.fdiv.eq_5 | Init.Data.Int.DivMod.Basic | ∀ (m n : ℕ), (Int.negSucc m).fdiv (Int.ofNat n.succ) = Int.negSucc (m / n.succ) |
LinearIsometryEquiv.toSpanUnitSingleton._proof_4 | Mathlib.Analysis.Normed.Module.Span | ∀ {𝕜 : Type u_1} [inst : NormedDivisionRing 𝕜], IsDomain 𝕜 |
String.Slice.instDecidableEqPos.decEq | Init.Data.String.Defs | {s : String.Slice} → (x x_1 : s.Pos) → Decidable (x = x_1) |
_private.Lean.Util.Diff.0.Lean.Diff.diff.match_1 | Lean.Util.Diff | {α : Type} →
(motive : MProd ℕ (Array (Lean.Diff.Action × α)) → Sort u_1) →
(r : MProd ℕ (Array (Lean.Diff.Action × α))) →
((j : ℕ) → (out : Array (Lean.Diff.Action × α)) → motive ⟨j, out⟩) → motive r |
tsum_geometric_of_lt_one | Mathlib.Analysis.SpecificLimits.Basic | ∀ {r : ℝ}, 0 ≤ r → r < 1 → ∑' (n : ℕ), r ^ n = (1 - r)⁻¹ |
IsSimpleRing.exists_algEquiv_matrix_of_isAlgClosed | Mathlib.RingTheory.SimpleModule.IsAlgClosed | ∀ (F : Type u_1) (R : Type u_2) [inst : Field F] [IsAlgClosed F] [inst_2 : Ring R] [inst_3 : Algebra F R]
[IsSimpleRing R] [FiniteDimensional F R], ∃ n, ∃ (_ : NeZero n), Nonempty (R ≃ₐ[F] Matrix (Fin n) (Fin n) F) |
ProbabilityTheory.condExp_prod_ae_eq_integral_condDistrib₀ | Mathlib.Probability.Kernel.CondDistrib | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {F : Type u_4} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
[inst_2 : Nonempty Ω] [inst_3 : NormedAddCommGroup F] {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : MeasureTheory.IsFiniteMeasure μ] {X : α → β} {Y : α → Ω} {mβ : MeasurableSpace β} {f : β × Ω → F}
[inst_5 : NormedSpace ℝ F] [inst_6 : CompleteSpace F],
Measurable X →
AEMeasurable Y μ →
MeasureTheory.AEStronglyMeasurable f (MeasureTheory.Measure.map (fun a => (X a, Y a)) μ) →
MeasureTheory.Integrable (fun a => f (X a, Y a)) μ →
μ[fun a => f (X a, Y a) | MeasurableSpace.comap X mβ] =ᵐ[μ] fun a =>
∫ (y : Ω), f (X a, y) ∂(ProbabilityTheory.condDistrib Y X μ) (X a) |
MeasureTheory.SimpleFunc.instRing._proof_10 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Ring β] (a b : MeasureTheory.SimpleFunc α β),
a - b = a + -b |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.q | Mathlib.RingTheory.Smooth.NoetherianDescent | {A : Type u} →
{B : Type u_2} →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
(self : Algebra.Smooth.DescentAux✝ A B) →
Algebra.Smooth.DescentAux.vars✝ self →
MvPolynomial (Algebra.Smooth.DescentAux.rels✝ self) (Algebra.Smooth.DescentAux.P✝ self).Ring |
TopCat.coe_of_of | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : Type u} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : C(X, Y)}
{x : (CategoryTheory.forget TopCat).obj (TopCat.of X)}, (TopCat.ofHom f) x = f x |
_private.Mathlib.Algebra.Module.ZLattice.Covolume.0._auto_28 | Mathlib.Algebra.Module.ZLattice.Covolume | Lean.Syntax |
Rep.equivalenceModuleMonoidAlgebra | Mathlib.RepresentationTheory.Rep | {k G : Type u} → [inst : CommRing k] → [inst_1 : Monoid G] → Rep k G ≌ ModuleCat (MonoidAlgebra k G) |
Turing.ListBlank.modifyNth._unsafe_rec | Mathlib.Computability.Tape | {Γ : Type u_1} → [inst : Inhabited Γ] → (Γ → Γ) → ℕ → Turing.ListBlank Γ → Turing.ListBlank Γ |
CategoryTheory.NonPreadditiveAbelian.isIso_factorThruImage | Mathlib.CategoryTheory.Abelian.NonPreadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C] {P Q : C}
(f : P ⟶ Q) [CategoryTheory.Mono f], CategoryTheory.IsIso (CategoryTheory.Abelian.factorThruImage f) |
Matroid.comap_indep_iff._simp_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {I : Set α} {N : Matroid β},
(N.comap f).Indep I = (N.Indep (f '' I) ∧ Set.InjOn f I) |
Multiset.sym2_mono | Mathlib.Data.Multiset.Sym | ∀ {α : Type u_1} {m m' : Multiset α}, m ≤ m' → m.sym2 ≤ m'.sym2 |
Real.Angle.toReal_le_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ (θ : Real.Angle), θ.toReal ≤ Real.pi |
_private.Mathlib.FieldTheory.RatFunc.Luroth.0.RatFunc.Luroth.q | Mathlib.FieldTheory.RatFunc.Luroth | {K : Type u_1} → [inst : Field K] → (E : IntermediateField K (RatFunc K)) → Polynomial ↥E |
Set.inter_self | Mathlib.Data.Set.Basic | ∀ {α : Type u} (a : Set α), a ∩ a = a |
Std.DHashMap.Raw.getKeyD_erase | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k a fallback : α}, (m.erase k).getKeyD a fallback = if (k == a) = true then fallback else m.getKeyD a fallback |
Nat.ofDigits_div_pow_eq_ofDigits_drop | Mathlib.Data.Nat.Digits.Defs | ∀ {p : ℕ} (i : ℕ),
0 < p →
∀ (digits : List ℕ), (∀ l ∈ digits, l < p) → Nat.ofDigits p digits / p ^ i = Nat.ofDigits p (List.drop i digits) |
instIsDirectedOrder | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] [Archimedean R], IsDirectedOrder R |
Submonoid.closure_eq_one_union | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : MulOneClass M] (s : Set M), ↑(Submonoid.closure s) = {1} ∪ ↑(Subsemigroup.closure s) |
ZSpan.ceil | Mathlib.Algebra.Module.ZLattice.Basic | {E : Type u_1} →
{ι : Type u_2} →
{K : Type u_3} →
[inst : NormedField K] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace K E] →
(b : Module.Basis ι K E) →
[inst_3 : LinearOrder K] →
[IsStrictOrderedRing K] → [FloorRing K] → [Fintype ι] → E → ↥(Submodule.span ℤ (Set.range ⇑b)) |
Mathlib.Meta.FunProp.Mor.isCoeFun | Mathlib.Tactic.FunProp.Mor | Lean.Expr → Lean.MetaM Bool |
eq_zero_of_sameRay_neg_smul_right | Mathlib.LinearAlgebra.Ray | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {x : M} [IsDomain R] [Module.IsTorsionFree R M] {r : R},
r < 0 → SameRay R x (r • x) → x = 0 |
SupHom.dual_comp | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Max α] [inst_1 : Max β] [inst_2 : Max γ] (g : SupHom β γ)
(f : SupHom α β), SupHom.dual (g.comp f) = (SupHom.dual g).comp (SupHom.dual f) |
LocallyFiniteOrder.addMonoidHom._proof_1 | Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder | ∀ (G : Type u_1) [inst : AddCommGroup G] [inst_1 : LinearOrder G] [inst_2 : LocallyFiniteOrder G],
↑(Finset.Ico 0 0).card - ↑(Finset.Ico 0 (-0)).card = 0 |
TopologicalSpace.Opens.mapComp_hom_app | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : TopologicalSpace.Opens ↑Z),
(TopologicalSpace.Opens.mapComp f g).hom.app U = CategoryTheory.eqToHom ⋯ |
CentroidHom.centerToCentroid_apply | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] (z : ↥(NonUnitalSubsemiring.center α)) (a : α),
(CentroidHom.centerToCentroid z) a = ↑z * a |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.quadrant_II._simp_1_3 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a : α}, (-a < 0) = (0 < a) |
_private.Lean.Meta.Sym.AlphaShareBuilder.0.Lean.Expr.updateLetS!._sparseCasesOn_1 | Lean.Meta.Sym.AlphaShareBuilder | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t |
CategoryTheory.Functor.preservesFiniteColimits_of_preservesHomology | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | ∀ {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 : CategoryTheory.Functor C D) [inst_4 : F.Additive] [F.PreservesHomology]
[CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasFiniteCoproducts C]
[CategoryTheory.Limits.HasCokernels C], CategoryTheory.Limits.PreservesFiniteColimits F |
LinearMap.submoduleComap_apply_coe | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₁] [inst_3 : Module R M] [inst_4 : Module R M₁] (f : M →ₗ[R] M₁) (q : Submodule R M₁)
(c : ↥(Submodule.comap f q)), ↑((f.submoduleComap q) c) = f ↑c |
Profinite.NobelingProof.π | Mathlib.Topology.Category.Profinite.Nobeling.Basic | {I : Type u} → Set (I → Bool) → (J : I → Prop) → [(i : I) → Decidable (J i)] → Set (I → Bool) |
AlgebraicTopology.DoldKan.N₁_obj_X | Mathlib.AlgebraicTopology.DoldKan.FunctorN | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.SimplicialObject C),
(AlgebraicTopology.DoldKan.N₁.obj X).X = AlgebraicTopology.AlternatingFaceMapComplex.obj X |
isSigmaCompact_iff_isSigmaCompact_univ | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsSigmaCompact s ↔ IsSigmaCompact Set.univ |
PowerBasis.finite | Mathlib.RingTheory.PowerBasis | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (pb : PowerBasis R S),
Module.Finite R S |
List.sum_le_sum | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [AddRightMono M] [AddLeftMono M] {l : List ι}
{f g : ι → M}, (∀ i ∈ l, f i ≤ g i) → (List.map f l).sum ≤ (List.map g l).sum |
Lean.PrettyPrinter.Formatter.checkNoWsBefore.formatter | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter |
MeasureTheory.Lp.instNormedAddCommGroup._proof_5 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (r : ↥(MeasureTheory.Lp E p μ)), ‖-r‖ = ‖r‖ |
exists_pow_lt₀ | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_1} [inst : LinearOrderedCommGroupWithZero G] [MulArchimedean G] {a : G},
a < 1 → ∀ (b : Gˣ), ∃ n, a ^ n < ↑b |
MvPolynomial.pderiv_C | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u} {σ : Type v} {a : R} [inst : CommSemiring R] {i : σ}, (MvPolynomial.pderiv i) (MvPolynomial.C a) = 0 |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.removeAssignment.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | ∀ (b : Bool) (a : Std.Tactic.BVDecide.LRAT.Internal.Assignment),
Std.Tactic.BVDecide.LRAT.Internal.Assignment.removeAssignment b a =
if b = true then a.removePosAssignment else a.removeNegAssignment |
_private.Mathlib.Analysis.InnerProductSpace.Projection.Reflection.0.Submodule.«_aux_Mathlib_Analysis_InnerProductSpace_Projection_Reflection___macroRules__private_Mathlib_Analysis_InnerProductSpace_Projection_Reflection_0_Submodule_term⟪_,_⟫_1» | Mathlib.Analysis.InnerProductSpace.Projection.Reflection | Lean.Macro |
_private.Mathlib.NumberTheory.Bernoulli.0.sum_bernoulli'._simp_1_1 | Mathlib.NumberTheory.Bernoulli | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c |
MeasureTheory.vaddInvariantMeasure_map_vadd | Mathlib.MeasureTheory.Group.Action | ∀ {M : Type uM} {N : Type uN} {α : Type uα} [inst : MeasurableSpace α] [inst_1 : VAdd M α] [inst_2 : VAdd N α]
[VAddCommClass N M α] [MeasurableConstVAdd M α] [MeasurableConstVAdd N α] (μ : MeasureTheory.Measure α)
[MeasureTheory.VAddInvariantMeasure M α μ] (n : N),
MeasureTheory.VAddInvariantMeasure M α (MeasureTheory.Measure.map (fun x => n +ᵥ x) μ) |
CategoryTheory.Limits.Types.coneOfSection | Mathlib.CategoryTheory.Limits.Types.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
{F : CategoryTheory.Functor J (Type u)} → {s : (j : J) → F.obj j} → s ∈ F.sections → CategoryTheory.Limits.Cone F |
CategoryTheory.Iso.toIsometryEquiv_toFun | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u} [inst : CommRing R] {X Y : QuadraticModuleCat R} (i : X ≅ Y) (a : ↑X.toModuleCat),
i.toIsometryEquiv a = (QuadraticModuleCat.Hom.toIsometry i.hom) a |
StieltjesFunction.add_apply | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f g : StieltjesFunction R) (x : R),
↑(f + g) x = ↑f x + ↑g x |
Array.instLE | Init.Data.Array.Basic | {α : Type u} → [LT α] → LE (Array α) |
Nat.not_dvd_ordCompl | Mathlib.Data.Nat.Factorization.Basic | ∀ {n p : ℕ}, Nat.Prime p → n ≠ 0 → ¬p ∣ n / p ^ n.factorization p |
MulLEAddHomClass.rec | Mathlib.Algebra.Order.Hom.Basic | {F : Type u_7} →
{α : Type u_8} →
{β : Type u_9} →
[inst : Mul α] →
[inst_1 : Add β] →
[inst_2 : LE β] →
[inst_3 : FunLike F α β] →
{motive : MulLEAddHomClass F α β → Sort u} →
((map_mul_le_add : ∀ (f : F) (a b : α), f (a * b) ≤ f a + f b) → motive ⋯) →
(t : MulLEAddHomClass F α β) → motive t |
Std.LawfulRightIdentity.mk | Init.Core | ∀ {α : Sort u} {β : Sort u_1} {op : α → β → α} {o : outParam β} [toRightIdentity : Std.RightIdentity op o],
(∀ (a : α), op a o = a) → Std.LawfulRightIdentity op o |
ChainComplex.of._proof_3 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
{α : Type u_3} [inst_2 : AddRightCancelSemigroup α] [inst_3 : One α] [inst_4 : DecidableEq α] (X : α → V)
(d : (n : α) → X (n + 1) ⟶ X n),
(∀ (n : α), CategoryTheory.CategoryStruct.comp (d (n + 1)) (d n) = 0) →
∀ (i j k : α),
(ComplexShape.down α).Rel i j →
(ComplexShape.down α).Rel j k →
CategoryTheory.CategoryStruct.comp
(if h : i = j + 1 then CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (d j) else 0)
(if h : j = k + 1 then CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (d k) else 0) =
0 |
CategoryTheory.Functor.mapAction_obj_V | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {W : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} W] (F : CategoryTheory.Functor V W) (G : Type u_3) [inst_2 : Monoid G]
(M : Action V G), ((F.mapAction G).obj M).V = F.obj M.V |
Lean.Meta.Grind.setENode | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Lean.Meta.Grind.ENode → Lean.Meta.Grind.GoalM Unit |
List.foldr_range_eq_of_range_eq | Mathlib.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : β → α → α} {g : γ → α → α},
Set.range f = Set.range g → ∀ (a : α), Set.range (List.foldr f a) = Set.range (List.foldr g a) |
ENat.mul_iInf' | Mathlib.Data.ENat.Lattice | ∀ {ι : Sort u_2} {f : ι → ℕ∞} {a : ℕ∞}, (a = 0 → Nonempty ι) → a * ⨅ i, f i = ⨅ i, a * f i |
NonUnitalSubalgebra.topologicalClosure._proof_1 | Mathlib.Topology.Algebra.NonUnitalAlgebra | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : NonUnitalSemiring A] [IsTopologicalSemiring A], ContinuousAdd A |
UniqueFactorizationMonoid | Mathlib.RingTheory.UniqueFactorizationDomain.Defs | (α : Type u_2) → [CommMonoidWithZero α] → Prop |
TrivSqZeroExt.inr_injective | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {M : Type v} [inst : Zero R], Function.Injective TrivSqZeroExt.inr |
ClosedSubmodule.orthogonal_orthogonal_eq | Mathlib.Analysis.InnerProductSpace.Projection.Submodule | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : ClosedSubmodule 𝕜 E) [(↑K).HasOrthogonalProjection], Kᗮᗮ = K |
HomologicalComplex.mapBifunctor₁₂.d₁ | Mathlib.Algebra.Homology.BifunctorAssociator | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₁₂ : Type u_3} →
{C₃ : Type u_5} →
{C₄ : Type u_6} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] →
[inst_3 : CategoryTheory.Category.{v_4, u_6} C₄] →
[inst_4 : CategoryTheory.Category.{v_5, u_3} C₁₂] →
[inst_5 : CategoryTheory.Limits.HasZeroMorphisms C₁] →
[inst_6 : CategoryTheory.Limits.HasZeroMorphisms C₂] →
[inst_7 : CategoryTheory.Limits.HasZeroMorphisms C₃] →
[inst_8 : CategoryTheory.Preadditive C₁₂] →
[inst_9 : CategoryTheory.Preadditive C₄] →
(F₁₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂)) →
(G : CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄)) →
[inst_10 : F₁₂.PreservesZeroMorphisms] →
[inst_11 : ∀ (X₁ : C₁), (F₁₂.obj X₁).PreservesZeroMorphisms] →
[inst_12 : G.Additive] →
[inst_13 : ∀ (X₁₂ : C₁₂), (G.obj X₁₂).PreservesZeroMorphisms] →
{ι₁ : Type u_7} →
{ι₂ : Type u_8} →
{ι₃ : Type u_9} →
{ι₁₂ : Type u_10} →
{ι₄ : Type u_12} →
[inst_14 : DecidableEq ι₄] →
{c₁ : ComplexShape ι₁} →
{c₂ : ComplexShape ι₂} →
{c₃ : ComplexShape ι₃} →
(K₁ : HomologicalComplex C₁ c₁) →
(K₂ : HomologicalComplex C₂ c₂) →
(K₃ : HomologicalComplex C₃ c₃) →
(c₁₂ : ComplexShape ι₁₂) →
(c₄ : ComplexShape ι₄) →
[inst_15 : TotalComplexShape c₁ c₂ c₁₂] →
[inst_16 : TotalComplexShape c₁₂ c₃ c₄] →
[inst_17 : K₁.HasMapBifunctor K₂ F₁₂ c₁₂] →
[inst_18 : DecidableEq ι₁₂] →
[inst_19 :
(K₁.mapBifunctor K₂ F₁₂
c₁₂).HasMapBifunctor
K₃ G c₄] →
(i₁ : ι₁) →
(i₂ : ι₂) →
(i₃ : ι₃) →
(j : ι₄) →
(G.obj
((F₁₂.obj (K₁.X i₁)).obj
(K₂.X i₂))).obj
(K₃.X i₃) ⟶
((K₁.mapBifunctor K₂ F₁₂
c₁₂).mapBifunctor
K₃ G c₄).X
j |
SSet.skeletonOfMono_obj_eq_top | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | ∀ {X Y : SSet} (i : X ⟶ Y) [inst : CategoryTheory.Mono i] {d n : ℕ},
d < n → ((SSet.skeletonOfMono i) n).obj (Opposite.op (SimplexCategory.mk d)) = ⊤ |
CategoryTheory.GrothendieckTopology.mk.noConfusion | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{P : Sort u_1} →
{sieves : (X : C) → Set (CategoryTheory.Sieve X)} →
{top_mem' : ∀ (X : C), ⊤ ∈ sieves X} →
{pullback_stable' :
∀ ⦃X Y : C⦄ ⦃S : CategoryTheory.Sieve X⦄ (f : Y ⟶ X),
S ∈ sieves X → CategoryTheory.Sieve.pullback f S ∈ sieves Y} →
{transitive' :
∀ ⦃X : C⦄ ⦃S : CategoryTheory.Sieve X⦄,
S ∈ sieves X →
∀ (R : CategoryTheory.Sieve X),
(∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → CategoryTheory.Sieve.pullback f R ∈ sieves Y) →
R ∈ sieves X} →
{sieves' : (X : C) → Set (CategoryTheory.Sieve X)} →
{top_mem'' : ∀ (X : C), ⊤ ∈ sieves' X} →
{pullback_stable'' :
∀ ⦃X Y : C⦄ ⦃S : CategoryTheory.Sieve X⦄ (f : Y ⟶ X),
S ∈ sieves' X → CategoryTheory.Sieve.pullback f S ∈ sieves' Y} →
{transitive'' :
∀ ⦃X : C⦄ ⦃S : CategoryTheory.Sieve X⦄,
S ∈ sieves' X →
∀ (R : CategoryTheory.Sieve X),
(∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → CategoryTheory.Sieve.pullback f R ∈ sieves' Y) →
R ∈ sieves' X} →
{ sieves := sieves, top_mem' := top_mem', pullback_stable' := pullback_stable',
transitive' := transitive' } =
{ sieves := sieves', top_mem' := top_mem'', pullback_stable' := pullback_stable'',
transitive' := transitive'' } →
(sieves ≍ sieves' → P) → P |
IsUniformAddGroup.to_topologicalAddGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α], IsTopologicalAddGroup α |
Birkhoff_inequalities | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α] [AddLeftMono α] (a b c : α),
|a ⊔ c - b ⊔ c| ⊔ |a ⊓ c - b ⊓ c| ≤ |a - b| |
AbsoluteValue.instSetoid | Mathlib.Analysis.AbsoluteValue.Equivalence | {R : Type u_1} →
[inst : Semiring R] → {S : Type u_2} → [inst_1 : Semiring S] → [inst_2 : PartialOrder S] → Setoid (AbsoluteValue R S) |
BddLat.Hom.casesOn | Mathlib.Order.Category.BddLat | {X Y : BddLat} →
{motive : X.Hom Y → Sort u_1} →
(t : X.Hom Y) → ((hom' : BoundedLatticeHom ↑X.toLat ↑Y.toLat) → motive { hom' := hom' }) → motive t |
FormalMultilinearSeries.le_radius_of_summable_norm | Mathlib.Analysis.Analytic.ConvergenceRadius | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {r : NNReal}
(p : FormalMultilinearSeries 𝕜 E F), (Summable fun n => ‖p n‖ * ↑r ^ n) → ↑r ≤ p.radius |
Std.Sat.AIG.BinaryRefVec.rhs_get_cast | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig1 aig2 : Std.Sat.AIG α}
(s : aig1.BinaryRefVec len) (idx : ℕ) (hidx : idx < len) (hcast : aig1.decls.size ≤ aig2.decls.size),
(s.cast hcast).rhs.get idx hidx = (s.rhs.get idx hidx).cast hcast |
Ordinal.veblenWith.match_1 | Mathlib.SetTheory.Ordinal.Veblen | (o : Ordinal.{u_1}) →
(motive : { x // x ∈ Set.Iio o } → Sort u_2) →
(x : { x // x ∈ Set.Iio o }) → ((x : Ordinal.{u_1}) → (property : x ∈ Set.Iio o) → motive ⟨x, property⟩) → motive x |
gal_zero_isSolvable | Mathlib.FieldTheory.AbelRuffini | ∀ {F : Type u_1} [inst : Field F], IsSolvable (Polynomial.Gal 0) |
Lean.Server.Test.Runner.logRpcResponse | Lean.Server.Test.Runner | {α : Type u_1} →
Lean.Name →
[Lean.ToJson α] →
α →
(β : optParam Type Lean.Json) →
[Lean.FromJson β] →
[Lean.ToJson β] →
optParam Bool true →
optParam (β → Lean.Server.Test.Runner.Client.NormalizeM β) pure → Lean.Server.Test.Runner.RunnerM Unit |
hnot_le_iff_codisjoint_right | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] {a b : α}, ￢a ≤ b ↔ Codisjoint a b |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.Decl.extractClosed.match_1 | Lean.Compiler.LCNF.ExtractClosed | (motive : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure × Lean.Compiler.LCNF.ExtractClosed.State → Sort u_1) →
(__discr : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure × Lean.Compiler.LCNF.ExtractClosed.State) →
((decl : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure) →
(s : Lean.Compiler.LCNF.ExtractClosed.State) → motive (decl, s)) →
motive __discr |
LinearMap.instModuleDomMulActOfSMulCommClass._proof_1 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_2} {R' : Type u_3} {S : Type u_1} {M : Type u_4} {M' : Type u_5} [inst : Semiring R]
[inst_1 : Semiring R'] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M]
[inst_5 : Module R' M'] {σ₁₂ : R →+* R'} [inst_6 : Semiring S] [inst_7 : Module S M] [inst_8 : SMulCommClass R S M]
(x x_1 : Sᵈᵐᵃ) (x_2 : M →ₛₗ[σ₁₂] M'), (x + x_1) • x_2 = x • x_2 + x_1 • x_2 |
Finite.Set.finite_replacement | Mathlib.Data.Set.Finite.Range | ∀ {α : Type u} {β : Type v} [Finite α] (f : α → β), Finite ↑{x | ∃ x_1, f x_1 = x} |
SSet.Subcomplex.Pairing.pairingCore._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing) [inst : P.IsProper] {s t : ↑P.II},
{ dim := (↑s).dim + 1, simplex := ((↑(P.p s)).cast ⋯).simplex } =
{ dim := (↑t).dim + 1, simplex := ((↑(P.p t)).cast ⋯).simplex } →
s = t |
convexOn_norm | Mathlib.Analysis.Normed.Module.Convex | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E},
Convex ℝ s → ConvexOn ℝ s norm |
_private.Mathlib.Probability.Kernel.RadonNikodym.0.ProbabilityTheory.Kernel.singularPart_compl_mutuallySingularSetSlice._simp_1_8 | Mathlib.Probability.Kernel.RadonNikodym | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
TopologicalSpace.OpenNhdsOf.instMax | Mathlib.Topology.Sets.Opens | {α : Type u_2} → [inst : TopologicalSpace α] → {x : α} → Max (TopologicalSpace.OpenNhdsOf x) |
AddGroupExtension.Equiv.Simps.symm_apply.eq_1 | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : AddGroup N] [inst_1 : AddGroup E] [inst_2 : AddGroup G]
{S : AddGroupExtension N E G} {E' : Type u_4} [inst_3 : AddGroup E'] {S' : AddGroupExtension N E' G}
(equiv : S.Equiv S'), AddGroupExtension.Equiv.Simps.symm_apply equiv = ⇑equiv.symm |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (p : Int.Linear.Poly) (h : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof),
sizeOf { p := p, h := h } = 1 + sizeOf p + sizeOf h |
ZeroHom.ctorIdx | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} → {N : Type u_11} → {inst : Zero M} → {inst_1 : Zero N} → ZeroHom M N → ℕ |
Std.HashSet.Raw.any_eq_not_all_not | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] {p : α → Bool},
m.WF → m.any p = !m.all fun a => !p a |
Std.DTreeMap.Internal.Cell.of | Std.Data.DTreeMap.Internal.Cell | {α : Type u} → {β : α → Type v} → [inst : Ord α] → (k : α) → β k → Std.DTreeMap.Internal.Cell α β (compare k) |
Lean.Elab.Tactic.Do.Uses.casesOn | Lean.Elab.Tactic.Do.LetElim | {motive : Lean.Elab.Tactic.Do.Uses → Sort u} →
(t : Lean.Elab.Tactic.Do.Uses) →
motive Lean.Elab.Tactic.Do.Uses.zero →
motive Lean.Elab.Tactic.Do.Uses.one → motive Lean.Elab.Tactic.Do.Uses.many → motive t |
MeasureTheory.AddContent.mk.injEq | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} {G : Type u_2} [inst : AddCommMonoid G] {C : Set (Set α)} (toFun : Set α → G) (empty' : toFun ∅ = 0)
(sUnion' : ∀ (I : Finset (Set α)), ↑I ⊆ C → (↑I).PairwiseDisjoint id → ⋃₀ ↑I ∈ C → toFun (⋃₀ ↑I) = ∑ u ∈ I, toFun u)
(toFun_1 : Set α → G) (empty'_1 : toFun_1 ∅ = 0)
(sUnion'_1 :
∀ (I : Finset (Set α)), ↑I ⊆ C → (↑I).PairwiseDisjoint id → ⋃₀ ↑I ∈ C → toFun_1 (⋃₀ ↑I) = ∑ u ∈ I, toFun_1 u),
({ toFun := toFun, empty' := empty', sUnion' := sUnion' } =
{ toFun := toFun_1, empty' := empty'_1, sUnion' := sUnion'_1 }) =
(toFun = toFun_1) |
Filter.mem_comap._simp_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {g : Filter β} {m : α → β} {s : Set α}, (s ∈ Filter.comap m g) = ∃ t ∈ g, m ⁻¹' t ⊆ s |
_private.Lean.Meta.Tactic.Constructor.0.Lean.MVarId.existsIntro._sparseCasesOn_2 | Lean.Meta.Tactic.Constructor | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Graded.equiv_symm_apply_coe | Mathlib.Data.FunLike.Graded | ∀ {E : Type u_1} {A : Type u_2} {B : Type u_3} {σ : Type u_4} {τ : Type u_5} {ι : Type u_6} [inst : SetLike σ A]
[inst_1 : SetLike τ B] {𝒜 : ι → σ} {ℬ : ι → τ} [inst_2 : EquivLike E A B] [inst_3 : GradedEquivLike E 𝒜 ℬ] (e : E)
(i : ι) (y : ↥(ℬ i)), ↑((Graded.equiv e i).symm y) = EquivLike.inv e ↑y |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition'.match_1.splitter | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | {γ : Type u_1} →
(motive : Option γ → Sort u_2) →
(__do_lift : Option γ) → (Unit → motive none) → ((fb : γ) → motive (some fb)) → motive __do_lift |
CategoryTheory.inhabitedLiftableCocone | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type w} →
[inst_1 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
(c : CategoryTheory.Limits.Cocone (K.comp (CategoryTheory.Functor.id C))) →
Inhabited (CategoryTheory.LiftableCocone K (CategoryTheory.Functor.id C) c) |
_private.Mathlib.Algebra.Homology.DerivedCategory.TStructure.0.DerivedCategory.TStructure.t._proof_6 | Mathlib.Algebra.Homology.DerivedCategory.TStructure | 0 ≤ 1 |
R1Space.specializes_or_disjoint_nhds | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_3} {inst : TopologicalSpace X} [self : R1Space X] (x y : X), x ⤳ y ∨ Disjoint (nhds x) (nhds y) |
Aesop.Frontend.Feature.elab._unsafe_rec | Aesop.Frontend.RuleExpr | Lean.Syntax → Aesop.ElabM Aesop.Frontend.Feature |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.