name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
IsNonstrictStrictOrder.right_iff_left_not_left | Mathlib.Order.RelClasses | ∀ {α : Type u_1} {r : semiOutParam (α → α → Prop)} {s : α → α → Prop} [self : IsNonstrictStrictOrder α r s] (a b : α),
s a b ↔ r a b ∧ ¬r b a |
Ideal.isLocal_of_isMaximal_radical | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u} [inst : CommRing R] {I : Ideal R}, I.radical.IsMaximal → I.IsLocal |
CategoryTheory.SmallObject.FunctorObjIndex.i | Mathlib.CategoryTheory.SmallObject.Construction | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I : Type w} →
{A B : I → C} →
{f : (i : I) → A i ⟶ B i} → {S X : C} → {πX : X ⟶ S} → CategoryTheory.SmallObject.FunctorObjIndex f πX → I |
star_finsuppSum | Mathlib.Algebra.Star.BigOperators | ∀ {R : Type u_1} {ι : Type u_2} {M : Type u_3} [inst : Zero M] [inst_1 : AddCommMonoid R] [inst_2 : StarAddMonoid R]
(s : ι →₀ M) (f : ι → M → R), star (s.sum f) = s.sum fun i m => star f i m |
AlgebraicGeometry.StructureSheaf.instAlgebraCarrierStalkCommRingCatObjPresheafTopObjPushforwardTopMapObjFunctorOppositeOpensCarrierTopIsSheafGrothendieckTopologyStructureSheaf | Mathlib.AlgebraicGeometry.Spec | {R S : CommRingCat} →
(f : R ⟶ S) →
(p : PrimeSpectrum ↑R) →
Algebra ↑R
↑(((TopCat.Presheaf.pushforward CommRingCat (AlgebraicGeometry.Spec.topMap f)).obj
(AlgebraicGeometry.Spec.structureSheaf ↑S).obj).stalk
p) |
_private.Lean.Parser.Extension.0.Lean.Parser.ParserExtension.OLeanEntry.toEntry | Lean.Parser.Extension | Lean.Parser.ParserExtension.State →
Lean.Parser.ParserExtension.OLeanEntry → Lean.ImportM Lean.Parser.ParserExtension.Entry |
AddCircle.measurableEquivIoc | Mathlib.MeasureTheory.Integral.IntervalIntegral.Periodic | (T : ℝ) → [hT : Fact (0 < T)] → (a : ℝ) → AddCircle T ≃ᵐ ↑(Set.Ioc a (a + T)) |
CategoryTheory.functorProdFunctorEquivCounitIso._proof_4 | Mathlib.CategoryTheory.Products.Basic | ∀ (A : Type u_4) [inst : CategoryTheory.Category.{u_1, u_4} A] (B : Type u_6)
[inst_1 : CategoryTheory.Category.{u_2, u_6} B] (C : Type u_5) [inst_2 : CategoryTheory.Category.{u_3, u_5} C]
{X Y : CategoryTheory.Functor A (B × C)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.functorProdToProdFunctor A B C).comp (CategoryTheory.prodFunctorToFunctorProd A B C)).map f)
((fun F => CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.prod.etaIso (F.obj X)) ⋯) Y).hom =
CategoryTheory.CategoryStruct.comp
((fun F => CategoryTheory.NatIso.ofComponents (fun X => CategoryTheory.prod.etaIso (F.obj X)) ⋯) X).hom
((CategoryTheory.Functor.id (CategoryTheory.Functor A (B × C))).map f) |
BoundedContinuousFunction.tendsto_integral_of_forall_integral_le_liminf_integral | Mathlib.MeasureTheory.Integral.BoundedContinuousFunction | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] [OpensMeasurableSpace X] {ι : Type u_2}
{L : Filter ι} {μ : MeasureTheory.Measure X} [MeasureTheory.IsProbabilityMeasure μ] {μs : ι → MeasureTheory.Measure X}
[∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μs i)],
(∀ (f : BoundedContinuousFunction X ℝ), 0 ≤ f → ∫ (x : X), f x ∂μ ≤ Filter.liminf (fun i => ∫ (x : X), f x ∂μs i) L) →
∀ (f : BoundedContinuousFunction X ℝ), Filter.Tendsto (fun i => ∫ (x : X), f x ∂μs i) L (nhds (∫ (x : X), f x ∂μ)) |
finprod_mem_union | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M} {s t : Set α},
Disjoint s t →
s.Finite → t.Finite → ∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i = (∏ᶠ (i : α) (_ : i ∈ s), f i) * ∏ᶠ (i : α) (_ : i ∈ t), f i |
Quiver.HasInvolutiveReverse.rec | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_2} →
[inst : Quiver V] →
{motive : Quiver.HasInvolutiveReverse V → Sort u} →
([toHasReverse : Quiver.HasReverse V] →
(inv' : ∀ {a b : V} (f : a ⟶ b), Quiver.reverse (Quiver.reverse f) = f) →
motive { toHasReverse := toHasReverse, inv' := inv' }) →
(t : Quiver.HasInvolutiveReverse V) → motive t |
_private.Aesop.Forward.State.0.Aesop.InstMap.insertMatch.match_1 | Aesop.Forward.State | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((inst : Lean.Expr) → motive (some inst)) → ((x : Option Lean.Expr) → motive x) → motive x |
Finset.prod_Ioc_succ_top | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_3} [inst : CommMonoid M] {a b : ℕ},
a ≤ b → ∀ (f : ℕ → M), ∏ k ∈ Finset.Ioc a (b + 1), f k = (∏ k ∈ Finset.Ioc a b, f k) * f (b + 1) |
Finset.biUnion_image_sup_left | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : SemilatticeSup α] (s t : Finset α),
(s.biUnion fun a => Finset.image (fun x => a ⊔ x) t) = s ⊻ t |
_private.Lean.Elab.DeclNameGen.0.PSum.casesOn._arg_pusher | Lean.Elab.DeclNameGen | ∀ {α : Sort u} {β : Sort v} {motive : α ⊕' β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x)
(rel : α ⊕' β → α_1 → Prop) (t : α ⊕' β)
(inl : (val : α) → ((y : α_1) → rel (PSum.inl val) y → β_1 y) → motive (PSum.inl val))
(inr : (val : β) → ((y : α_1) → rel (PSum.inr val) y → β_1 y) → motive (PSum.inr val)),
(PSum.casesOn (motive := fun t => ((y : α_1) → rel t y → β_1 y) → motive t) t inl inr fun y h => f y) =
PSum.casesOn t (fun val => inl val fun y h => f y) fun val => inr val fun y h => f y |
Real.tendsto_logb_atTop_of_base_lt_one | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b : ℝ}, 0 < b → b < 1 → Filter.Tendsto (Real.logb b) Filter.atTop Filter.atBot |
tensorKaehlerQuotKerSqEquiv._proof_3 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (R : Type u_1) (P : Type u_2) (S : Type u_3) [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S],
SMulCommClass R (P ⧸ RingHom.ker (algebraMap P S) ^ 2) (P ⧸ RingHom.ker (algebraMap P S) ^ 2) |
Lean.Compiler.LCNF.JoinPointFinder.find | Lean.Compiler.LCNF.JoinPoints | Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.CompilerM Lean.Compiler.LCNF.JoinPointFinder.FindState |
Asymptotics.IsEquivalent | Mathlib.Analysis.Asymptotics.Defs | {α : Type u_1} → {E' : Type u_6} → [SeminormedAddCommGroup E'] → Filter α → (α → E') → (α → E') → Prop |
AffineSubspace.subtype_linear | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : AffineSubspace k P) [inst_4 : Nonempty ↥s], s.subtype.linear = s.direction.subtype |
MonoidHom.instCommMonoid._proof_8 | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : CommMonoid N] (n : ℕ) (x : M →* N),
x ^ (n + 1) = x ^ n * x |
_private.Batteries.Data.List.Basic.0.List.next?.match_1.eq_2 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (l : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (l : List α) → motive (a :: l)),
(match a :: l with
| [] => h_1 ()
| a :: l => h_2 a l) =
h_2 a l |
Set.mulIndicator_eq_one_or_self | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : One M] (s : Set α) (f : α → M) (a : α),
s.mulIndicator f a = 1 ∨ s.mulIndicator f a = f a |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.ErrorContext.recOn | Mathlib.Tactic.Linter.TextBased | {motive : Mathlib.Linter.TextBased.ErrorContext✝ → Sort u} →
(t : Mathlib.Linter.TextBased.ErrorContext✝¹) →
((error : Mathlib.Linter.TextBased.StyleError✝) →
(lineNumber : ℕ) →
(path : System.FilePath) → motive { error := error, lineNumber := lineNumber, path := path }) →
motive t |
_private.Init.Data.Nat.ToString.0.Nat.length_toDigits_le_iff._simp_1_4 | Init.Data.Nat.ToString | ∀ {n : ℕ}, (n ≠ 0) = (0 < n) |
Lean.Elab.Tactic.RCases.instCoeIdentTSyntaxConsSyntaxNodeKindMkStr1Nil_lean | Lean.Elab.Tactic.RCases | Coe Lean.Ident (Lean.TSyntax `rcasesPat) |
ContinuousMultilinearMap.norm_mkPiAlgebraFin_zero | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {A : Type u_1} [inst_1 : SeminormedRing A]
[inst_2 : NormedAlgebra 𝕜 A], ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 0 A‖ = ‖1‖ |
FirstOrder.Ring.genericPolyMap.eq_1 | Mathlib.RingTheory.MvPolynomial.FreeCommRing | ∀ {ι : Type u_1} {κ : Type u_2} (monoms : ι → Finset (κ →₀ ℕ)) (i : ι),
FirstOrder.Ring.genericPolyMap monoms i =
∑ m ∈ (monoms i).attach, FreeCommRing.of (Sum.inl ⟨i, m⟩) * (↑m).prod fun j n => FreeCommRing.of (Sum.inr j) ^ n |
_private.Mathlib.Algebra.Order.Ring.WithTop.0.WithTop.pow_right_strictMono.match_1_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0),
(∀ (h : 0 ≠ 0), motive 0 h) →
(∀ (x : 1 ≠ 0), motive 1 x) → (∀ (n : ℕ) (x : n + 2 ≠ 0), motive n.succ.succ x) → motive x x_1 |
Sylow.normal_of_normalizerCondition | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G],
NormalizerCondition G → ∀ {p : ℕ} [Fact (Nat.Prime p)] [Finite (Sylow p G)] (P : Sylow p G), (↑P).Normal |
ContinuousAddMonoidHom.instAddCommMonoid._proof_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_1} {E : Type u_2} [inst : AddMonoid A] [inst_1 : TopologicalSpace A] [inst_2 : AddCommMonoid E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] (x : A →ₜ+ E), nsmulRecAuto 0 x = 0 |
NNReal.coe_real_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ↑NNReal.pi = Real.pi |
FiniteDimensional.RCLike.properSpace_submodule | Mathlib.Analysis.RCLike.Lemmas | ∀ (K : Type u_1) {E : Type u_2} [inst : RCLike K] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace K E]
(S : Submodule K E) [FiniteDimensional K ↥S], ProperSpace ↥S |
IsPrimitiveRoot.neZero' | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} {ζ : R} [inst : CommRing R] [IsDomain R] {n : ℕ} [NeZero n], IsPrimitiveRoot ζ n → NeZero ↑n |
MeasureTheory.setIntegral_indicatorConstLp | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{s t : Set X} {μ : MeasureTheory.Measure X} [CompleteSpace E] {p : ENNReal},
MeasurableSet s →
∀ (ht : MeasurableSet t) (hμt : μ t ≠ ⊤) (e : E),
∫ (x : X) in s, ↑↑(MeasureTheory.indicatorConstLp p ht hμt e) x ∂μ = μ.real (t ∩ s) • e |
Polynomial.degree_map_le | Mathlib.Algebra.Polynomial.Eval.Degree | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {f : R →+* S} {p : Polynomial R},
(Polynomial.map f p).degree ≤ p.degree |
LinearMap.flip._proof_5 | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_6} [inst : Semiring R] {S : Type u_3} [inst_1 : Semiring S] {R₂ : Type u_7} [inst_2 : Semiring R₂]
{S₂ : Type u_4} [inst_3 : Semiring S₂] {M : Type u_5} {N : Type u_2} {P : Type u_1} [inst_4 : AddCommMonoid M]
[inst_5 : AddCommMonoid N] [inst_6 : AddCommMonoid P] [inst_7 : Module R M] [inst_8 : Module S N]
[inst_9 : Module R₂ P] [inst_10 : Module S₂ P] [inst_11 : SMulCommClass S₂ R₂ P] {ρ₁₂ : R →+* R₂} {σ₁₂ : S →+* S₂}
(f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (x : S) (x_1 : N) (m : M), (f m) (x • x_1) = σ₁₂ x • (f m) x_1 |
AddSemiconjBy.map._simp_1 | Mathlib.Algebra.Group.Commute.Hom | ∀ {F : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Add M] [inst_1 : Add N] {a x y : M} [inst_2 : FunLike F M N]
[AddHomClass F M N], AddSemiconjBy a x y → ∀ (f : F), AddSemiconjBy (f a) (f x) (f y) = True |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_14 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α), a ∈ x :: y :: tail → x :: y :: tail ≠ [] |
_private.Lean.Meta.Tactic.Replace.0.Lean.MVarId.withReverted.match_1 | Lean.Meta.Tactic.Replace | (motive : Option Lean.FVarId → Sort u_1) →
(x? : Option Lean.FVarId) → ((x : Lean.FVarId) → motive (some x)) → ((x : Option Lean.FVarId) → motive x) → motive x? |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.toList_eq._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) |
Order.IsPredLimit.ne_top | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : OrderTop α], Order.IsPredLimit a → a ≠ ⊤ |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_left_le_size_union._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) |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.aux_IsBigO_mul | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ (k l : ℕ) (p : ℝ) {f : ℕ → ℂ},
(f =O[Filter.atTop] fun n => ↑n ^ l) →
(fun n => f n * (2 * ↑Real.pi * Complex.I * ↑n / ↑p) ^ k) =O[Filter.atTop] fun n => ↑(n ^ (l + k)) |
ProbabilityTheory.Kernel.compProd_prodMkLeft_eq_comp | Mathlib.Probability.Kernel.Composition.KernelLemmas | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {mX : MeasurableSpace X} {mY : MeasurableSpace Y}
{mZ : MeasurableSpace Z} (κ : ProbabilityTheory.Kernel X Y) [ProbabilityTheory.IsSFiniteKernel κ]
(η : ProbabilityTheory.Kernel Y Z) [ProbabilityTheory.IsSFiniteKernel η],
κ.compProd (ProbabilityTheory.Kernel.prodMkLeft X η) = (ProbabilityTheory.Kernel.id.prod η).comp κ |
_private.Mathlib.MeasureTheory.Measure.Lebesgue.Basic.0.nullMeasurableSet_region_between_co._simp_1_2 | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) |
MonadSatisfying.instStateRefT'._proof_2 | Batteries.Classes.SatisfiesM | ∀ {m : Type → Type} {ω σ : Type} [inst : Monad m] [LawfulMonad m], LawfulFunctor (StateRefT' ω σ m) |
BEq.rfl | Init.Core | ∀ {α : Type u_1} [inst : BEq α] [ReflBEq α] {a : α}, (a == a) = true |
IsLUB | Mathlib.Order.Bounds.Defs | {α : Type u_1} → [LE α] → Set α → α → Prop |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.mkCongrSimpCore?.mkProof.go._unsafe_rec | Lean.Meta.CongrTheorems | Array Lean.Meta.CongrArgKind → ℕ → Lean.Expr → Lean.MetaM Lean.Expr |
Multiset.instDistribLattice | Mathlib.Data.Multiset.UnionInter | {α : Type u_1} → [DecidableEq α] → DistribLattice (Multiset α) |
_private.Mathlib.RingTheory.AdjoinRoot.0.AdjoinRoot.map._simp_1 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u} {S : Type v} {T : Type w} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] (f : R →+* S)
[inst_2 : Semiring T] (g : S →+* T) (x : T),
Polynomial.eval₂ (g.comp f) x p = Polynomial.eval₂ g x (Polynomial.map f p) |
ENat.smul_sSup | Mathlib.Data.ENat.Lattice | ∀ {R : Type u_4} [inst : SMul R ℕ∞] [IsScalarTower R ℕ∞ ℕ∞] (s : Set ℕ∞) (c : R), c • sSup s = ⨆ a ∈ s, c • a |
Preorder.piCongrLeft_comp_restrictLe | Mathlib.Order.Restriction | ∀ {α : Type u_1} [inst : Preorder α] {π : α → Type u_2} [inst_1 : LocallyFiniteOrderBot α] {a : α},
⇑(Equiv.piCongrLeft (fun i => π ↑i) (Equiv.IicFinsetSet a).symm) ∘ Preorder.restrictLe a = Preorder.frestrictLe a |
Part.get_eq_get_of_eq | Mathlib.Data.Part | ∀ {α : Type u_1} (a : Part α) (ha : a.Dom) {b : Part α} (h : a = b), a.get ha = b.get ⋯ |
_private.Lean.Elab.Import.0.Lean.Elab.printImports.match_1 | Lean.Elab.Import | (motive : Array Lean.Import × Lean.Position × Lean.MessageLog → Sort u_1) →
(__discr : Array Lean.Import × Lean.Position × Lean.MessageLog) →
((deps : Array Lean.Import) → (fst : Lean.Position) → (snd : Lean.MessageLog) → motive (deps, fst, snd)) →
motive __discr |
CategoryTheory.Arrow.leftFunc_obj | Mathlib.CategoryTheory.Comma.Arrow | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(X : CategoryTheory.Comma (CategoryTheory.Functor.id C) (CategoryTheory.Functor.id C)),
CategoryTheory.Arrow.leftFunc.obj X = X.left |
Filter.Realizer.ofEquiv_F | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_1} {τ : Type u_4} {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) (s : τ),
(F.ofEquiv E).F.f s = F.F.f (E.symm s) |
CategoryTheory.GrothendieckTopology.PreservesSheafification.transport | Mathlib.CategoryTheory.Sites.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D)
(G : CategoryTheory.Functor D C) {A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] (B : Type u₄)
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor A B) [G.IsCoverDense J] [G.Full]
[inst_6 : G.IsContinuous K J] [inst_7 : G.IsContinuous K J] [(G.sheafPushforwardContinuous B K J).EssSurj]
[(G.sheafPushforwardContinuous A K J).EssSurj] [K.PreservesSheafification F], J.PreservesSheafification F |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone.0.CochainComplex.mappingCocone.δ_descCochain._proof_1_7 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {M : CochainComplex C ℤ}
{m : ℤ} (α : CochainComplex.HomComplex.Cochain K M m) (p q : ℤ) (β : CochainComplex.HomComplex.Cochain L M (m + 1))
(hpq : p + (m + 1) = q),
CategoryTheory.CategoryStruct.comp ((CochainComplex.mappingCone.snd φ).v (p + -1) (p + -1) ⋯)
((CochainComplex.HomComplex.δ (m + 1) (m + 2) β).v (p + -1) q ⋯) +
(m.negOnePow •
CategoryTheory.CategoryStruct.comp ((↑(CochainComplex.mappingCone.fst φ)).v (p + -1) p ⋯)
(CategoryTheory.CategoryStruct.comp (φ.f p) (β.v p q hpq)) +
CategoryTheory.CategoryStruct.comp ((↑(CochainComplex.mappingCone.fst φ)).v (p + -1) p ⋯)
((CochainComplex.HomComplex.δ m (m + 1) α).v p q hpq)) =
CategoryTheory.CategoryStruct.comp ((↑(CochainComplex.mappingCone.fst φ)).v (p + -1) p ⋯)
((CochainComplex.HomComplex.δ m (m + 1) α).v p q hpq) +
m.negOnePow •
CategoryTheory.CategoryStruct.comp ((↑(CochainComplex.mappingCone.fst φ)).v (p + -1) p ⋯)
(CategoryTheory.CategoryStruct.comp (φ.f p) (β.v p q hpq)) +
CategoryTheory.CategoryStruct.comp ((CochainComplex.mappingCone.snd φ).v (p + -1) (p + -1) ⋯)
((CochainComplex.HomComplex.δ (m + 1) (m + 2) β).v (p + -1) q ⋯) |
CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux._proof_1 | Mathlib.CategoryTheory.Sites.CoverLifting | ∀ {C : Type u_1} {D : Type u_4} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {G : CategoryTheory.Functor C D}
{J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D} [G.IsCocontinuous J K] {X : D}
{S : K.Cover X} {Y : C} (f : G.obj Y ⟶ X),
CategoryTheory.Sieve.functorPullback G (CategoryTheory.Sieve.pullback f ↑S) ∈ J Y |
IntermediateField.lift_relrank_comap_comap_eq_lift_relrank_of_surjective | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : Type w} [inst_3 : Field L]
[inst_4 : Algebra F L] (A B : IntermediateField F E) (f : L →ₐ[F] E),
Function.Surjective ⇑f →
Cardinal.lift.{v, w} ((IntermediateField.comap f A).relrank (IntermediateField.comap f B)) =
Cardinal.lift.{w, v} (A.relrank B) |
_private.Mathlib.Data.Set.Image.0.Set.imageFactorization_surjective.match_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_2} {β : Type u_1} {f : α → β} {s : Set α} (motive : ↑(f '' s) → Prop) (x : ↑(f '' s)),
(∀ (a : α) (ha : a ∈ s), motive ⟨f a, ⋯⟩) → motive x |
iSup_inf_eq | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} [inst : Order.Frame α] (f : ι → α) (a : α), (⨆ i, f i) ⊓ a = ⨆ i, f i ⊓ a |
Lean.Parser.Term.throwNamedErrorMacro | Lean.Parser.Term | Lean.Parser.Parser |
QuaternionAlgebra.coe_natCast | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} {c₁ c₂ c₃ : R} [inst : AddCommGroupWithOne R] (n : ℕ), ↑↑n = ↑n |
CategoryTheory.IndParallelPairPresentation.parallelPairIsoParallelPairCompYoneda._proof_4 | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
{f g : A ⟶ B} (P : CategoryTheory.IndParallelPairPresentation f g),
CategoryTheory.Limits.HasColimit
(((CategoryTheory.Functor.whiskeringRight P.I C (CategoryTheory.Functor Cᵒᵖ (Type u_1))).obj
CategoryTheory.yoneda).obj
((CategoryTheory.Limits.parallelPair P.φ P.ψ).obj CategoryTheory.Limits.WalkingParallelPair.zero)) |
Std.Sat.AIG.RefVec.MapTarget.recOn | Std.Sat.AIG.RefVecOperator.Map | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{len : ℕ} →
{motive : Std.Sat.AIG.RefVec.MapTarget aig len → Sort u} →
(t : Std.Sat.AIG.RefVec.MapTarget aig len) →
((vec : aig.RefVec len) →
(func : (aig : Std.Sat.AIG α) → aig.Ref → Std.Sat.AIG.Entrypoint α) →
[lawful : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.Ref func] →
[chainable : Std.Sat.AIG.RefVec.LawfulMapOperator α func] →
motive { vec := vec, func := func, lawful := lawful, chainable := chainable }) →
motive t |
Std.DTreeMap.Internal.Impl.getKeyD_union!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k fallback : α},
Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.union! m₂).getKeyD k fallback = m₂.getKeyD k fallback |
Sat.Fmla.reify.mk | Mathlib.Tactic.Sat.FromLRAT | ∀ {v : Sat.Valuation} {f : Sat.Fmla} {p : Prop}, (¬v.satisfies_fmla f → p) → Sat.Fmla.reify v f p |
Std.ExtHashMap.ext_getKey_getElem?_iff | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{m₁ m₂ : Std.ExtHashMap α β},
m₁ = m₂ ↔ (∀ (k : α) (hk : k ∈ m₁) (hk' : k ∈ m₂), m₁.getKey k hk = m₂.getKey k hk') ∧ ∀ (k : α), m₁[k]? = m₂[k]? |
CategoryTheory.Limits.spanCompIso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
{X_1 Y_1 : CategoryTheory.Limits.WalkingSpan} (f_1 : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Limits.span f g).comp F).map f_1)
(Option.casesOn Y_1 (CategoryTheory.Iso.refl (((CategoryTheory.Limits.span f g).comp F).obj none)) fun val =>
CategoryTheory.Limits.WalkingPair.casesOn val
(CategoryTheory.Iso.refl
(((CategoryTheory.Limits.span f g).comp F).obj (some CategoryTheory.Limits.WalkingPair.left)))
(CategoryTheory.Iso.refl
(((CategoryTheory.Limits.span f g).comp F).obj (some CategoryTheory.Limits.WalkingPair.right)))).hom =
CategoryTheory.CategoryStruct.comp
(Option.casesOn X_1 (CategoryTheory.Iso.refl (((CategoryTheory.Limits.span f g).comp F).obj none)) fun val =>
CategoryTheory.Limits.WalkingPair.casesOn val
(CategoryTheory.Iso.refl
(((CategoryTheory.Limits.span f g).comp F).obj (some CategoryTheory.Limits.WalkingPair.left)))
(CategoryTheory.Iso.refl
(((CategoryTheory.Limits.span f g).comp F).obj (some CategoryTheory.Limits.WalkingPair.right)))).hom
((CategoryTheory.Limits.span (F.map f) (F.map g)).map f_1) |
Lean.Elab.TerminationMeasure.mk.noConfusion | Lean.Elab.PreDefinition.TerminationMeasure | {P : Sort u} →
{ref : Lean.Syntax} →
{structural : Bool} →
{fn : Lean.Expr} →
{ref' : Lean.Syntax} →
{structural' : Bool} →
{fn' : Lean.Expr} →
{ ref := ref, structural := structural, fn := fn } =
{ ref := ref', structural := structural', fn := fn' } →
(ref = ref' → structural = structural' → fn = fn' → P) → P |
Lean.Elab.MonadParentDecl.noConfusionType | Lean.Elab.InfoTree.Types | Sort u → {m : Type → Type} → Lean.Elab.MonadParentDecl m → {m' : Type → Type} → Lean.Elab.MonadParentDecl m' → Sort u |
CategoryTheory.Abelian.Ext.bilinearComp | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : CategoryTheory.HasExt C] →
(X Y Z : C) →
(a b c : ℕ) →
a + b = c →
CategoryTheory.Abelian.Ext X Y a →+ CategoryTheory.Abelian.Ext Y Z b →+ CategoryTheory.Abelian.Ext X Z c |
Lean.Meta.Match.State.mk.injEq | Lean.Meta.Match.Match | ∀ (used : Std.HashSet ℕ) (overlaps : Lean.Meta.Match.Overlaps) (counterExamples : List (List Lean.Meta.Match.Example))
(used_1 : Std.HashSet ℕ) (overlaps_1 : Lean.Meta.Match.Overlaps)
(counterExamples_1 : List (List Lean.Meta.Match.Example)),
({ used := used, overlaps := overlaps, counterExamples := counterExamples } =
{ used := used_1, overlaps := overlaps_1, counterExamples := counterExamples_1 }) =
(used = used_1 ∧ overlaps = overlaps_1 ∧ counterExamples = counterExamples_1) |
CategoryTheory.Limits.preservesProduct_of_preservesBiproduct | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] {J : Type u_1} [Finite J] {f : J → C}
[CategoryTheory.Limits.PreservesBiproduct f F],
CategoryTheory.Limits.PreservesLimit (CategoryTheory.Discrete.functor f) F |
_private.Lean.Meta.CtorRecognizer.0.Lean.Meta.isConstructorApp'?.match_5 | Lean.Meta.CtorRecognizer | (motive : Option (Lean.Expr × ℕ) → Sort u_1) →
(__do_lift : Option (Lean.Expr × ℕ)) →
((fst : Lean.Expr) → (k : ℕ) → motive (some (fst, k))) →
((x : Option (Lean.Expr × ℕ)) → motive x) → motive __do_lift |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme.0.AlgebraicGeometry.Scheme.IdealSheafData.glueDataT._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (U V : ↑X.affineOpens), ↑U ⊓ ↑V ≤ ↑V |
ENat.coe_lt_coe | Mathlib.Data.ENat.Basic | ∀ {n m : ℕ}, ↑n < ↑m ↔ n < m |
CategoryTheory.CountableAB4Star.of_hasExactLimitsOfShape_nat | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasFiniteBiproducts C] [CategoryTheory.Limits.HasFiniteColimits C]
[inst_4 : CategoryTheory.Limits.HasCountableProducts C]
[CategoryTheory.HasExactLimitsOfShape (CategoryTheory.Discrete ℕ) C], CategoryTheory.CountableAB4Star C |
Std.ExtHashMap.getElem?_filter' | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
{f : α → β → Bool} {k : α}, (Std.ExtHashMap.filter f m)[k]? = Option.filter (f k) m[k]? |
IsAzumaya.recOn | Mathlib.Algebra.Azumaya.Defs | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
{motive : IsAzumaya R A → Sort u} →
(t : IsAzumaya R A) →
([toProjective : Module.Projective R A] →
[toFaithfulSMul : FaithfulSMul R A] →
[toFinite : Module.Finite R A] → (bij : Function.Bijective ⇑(AlgHom.mulLeftRight R A)) → motive ⋯) →
motive t |
CommMonoidWithZero.zero_mul | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_2} [self : CommMonoidWithZero M₀] (a : M₀), 0 * a = 0 |
Frm.hom_ext_iff | Mathlib.Order.Category.Frm | ∀ {X Y : Frm} {f g : X ⟶ Y}, f = g ↔ Frm.Hom.hom f = Frm.Hom.hom g |
Nat.choose_mul_factorial_mul_factorial | Mathlib.Data.Nat.Choose.Basic | ∀ {n k : ℕ}, k ≤ n → n.choose k * k.factorial * (n - k).factorial = n.factorial |
Subring.op_top | Mathlib.Algebra.Ring.Subring.MulOpposite | ∀ {R : Type u_2} [inst : Ring R], ⊤.op = ⊤ |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.mem_lattice._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x y z : M},
(z ∈ Submodule.span R {x, y}) = ∃ a b, a • x + b • y = z |
ZFSet.Definable | Mathlib.SetTheory.ZFC.Basic | (n : ℕ) → ((Fin n → ZFSet.{u}) → ZFSet.{u}) → Type (u + 1) |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.toFunctorToCategoricalPullback._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_3} {B : Type u_6} {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} A]
[inst_1 : CategoryTheory.Category.{u_5, u_6} B] [inst_2 : CategoryTheory.Category.{u_2, u_4} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) (X : Type u_8)
[inst_3 : CategoryTheory.Category.{u_7, u_8} X] (S : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G X)
(X_1 : X),
{ fst := S.fst.map (CategoryTheory.CategoryStruct.id X_1), snd := S.snd.map (CategoryTheory.CategoryStruct.id X_1),
w := ⋯ } =
CategoryTheory.CategoryStruct.id { fst := S.fst.obj X_1, snd := S.snd.obj X_1, iso := S.iso.app X_1 } |
Finset.notMem_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {a b : α}, a ∉ {b} ↔ a ≠ b |
Plausible.SampleableExt.sample | Plausible.Sampleable | {α : Sort u} → [self : Plausible.SampleableExt α] → Plausible.Arbitrary (Plausible.SampleableExt.proxy α) |
NNReal.coe_sInf | Mathlib.Data.NNReal.Defs | ∀ (s : Set NNReal), ↑(sInf s) = sInf (NNReal.toReal '' s) |
Measurable.of_discrete | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [DiscreteMeasurableSpace α]
{f : α → β}, Measurable f |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.instRxcLawfulHasSize.match_5 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (motive : (n : ℕ) → BitVec n → BitVec n → BitVec n → Prop) (n : ℕ) (lo hi lo_1 : BitVec n),
(∀ (lo hi lo_2 : BitVec 0), motive 0 lo hi lo_2) →
(∀ (n : ℕ) (lo hi lo_2 : BitVec (n + 1)), motive n.succ lo hi lo_2) → motive n lo hi lo_1 |
LinearEquiv.toContinuousLinearEquivOfBounds | Mathlib.Analysis.Normed.Operator.ContinuousLinearMap | {𝕜 : Type u_1} →
{𝕜₂ : Type u_2} →
{E : Type u_3} →
{F : Type u_4} →
[inst : Ring 𝕜] →
[inst_1 : Ring 𝕜₂] →
[inst_2 : SeminormedAddCommGroup E] →
[inst_3 : SeminormedAddCommGroup F] →
[inst_4 : Module 𝕜 E] →
[inst_5 : Module 𝕜₂ F] →
{σ : 𝕜 →+* 𝕜₂} →
{σ₂₁ : 𝕜₂ →+* 𝕜} →
[inst_6 : RingHomInvPair σ σ₂₁] →
[inst_7 : RingHomInvPair σ₂₁ σ] →
(e : E ≃ₛₗ[σ] F) →
(C_to C_inv : ℝ) →
(∀ (x : E), ‖e x‖ ≤ C_to * ‖x‖) → (∀ (x : F), ‖e.symm x‖ ≤ C_inv * ‖x‖) → E ≃SL[σ] F |
_private.Mathlib.Analysis.SumIntegralComparisons.0.integral_le_sum_mul_Ico_of_antitone_monotone._proof_1_3 | Mathlib.Analysis.SumIntegralComparisons | ∀ {a b : ℕ} (i : ℕ), a ≤ i ∧ i < b → i + 1 ≤ b |
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.leftRightAnnihilator._auto_1 | Lean.Compiler.LCNF.Simp.ConstantFold | Lean.Syntax |
UniformEquiv.piCongrRight | Mathlib.Topology.UniformSpace.Equiv | {ι : Type u_4} →
{β₁ : ι → Type u_5} →
{β₂ : ι → Type u_6} →
[inst : (i : ι) → UniformSpace (β₁ i)] →
[inst_1 : (i : ι) → UniformSpace (β₂ i)] → ((i : ι) → β₁ i ≃ᵤ β₂ i) → ((i : ι) → β₁ i) ≃ᵤ ((i : ι) → β₂ i) |
AlgebraicGeometry.Scheme.isAffine_affineBasisCover | Mathlib.AlgebraicGeometry.AffineScheme | ∀ (X : AlgebraicGeometry.Scheme) (i : X.affineBasisCover.I₀), AlgebraicGeometry.IsAffine (X.affineBasisCover.X i) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.