name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SkewMonoidAlgebra.lift_unique | Mathlib.Algebra.SkewMonoidAlgebra.Lift | ∀ {k : Type u_1} {G : Type u_2} [inst : CommSemiring k] [inst_1 : Monoid G] {A : Type u_4} [inst_2 : Semiring A]
[inst_3 : Algebra k A] [inst_4 : MulSemiringAction G k] [inst_5 : SMulCommClass G k k]
(F : SkewMonoidAlgebra k G →ₐ[k] A) (f : SkewMonoidAlgebra k G),
F f = f.coeff.sum fun a b => b • F (SkewMonoidAlg... | Decomposition of a `k`-algebra homomorphism from `SkewMonoidAlgebra k G` by
its values on `F (single a 1)`. | true |
Lean.LLVM.instNonemptyModule | Lean.Compiler.IR.LLVMBindings | ∀ {ctx : Lean.LLVM.Context}, Nonempty (Lean.LLVM.Module ctx) | null | true |
_private.Std.Async.Signal.0.Std.Async.Signal.Waiter.ofNative | Std.Async.Signal | Std.Internal.UV.Signal → Std.Async.Signal.Waiter | null | true |
SemiNormedGrp₁.Hom.recOn | Mathlib.Analysis.Normed.Group.SemiNormedGrp | {M N : SemiNormedGrp₁} →
{motive : M.Hom N → Sort u_1} →
(t : M.Hom N) →
((hom' : NormedAddGroupHom M.carrier N.carrier) →
(normNoninc : hom'.NormNoninc) → motive { hom' := hom', normNoninc := normNoninc }) →
motive t | null | false |
Aesop.SearchM.Context._sizeOf_inst | Aesop.Search.SearchM | SizeOf Aesop.SearchM.Context | null | false |
_private.Mathlib.Topology.Inseparable.0.inseparable_iff_forall_isOpen._simp_1_1 | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, Inseparable x y = (x ⤳ y ∧ y ⤳ x) | null | false |
Nat.zero_max | Init.Data.Nat.MinMax | ∀ (a : ℕ), max 0 a = a | null | true |
Topology.ContinuousMapGeneratedBy.noConfusionType | Mathlib.Topology.Convenient.ContinuousMapGeneratedBy | Sort u_1 →
{ι : Type t} →
{X : ι → Type u} →
[inst : (i : ι) → TopologicalSpace (X i)] →
{Y : Type v} →
[inst_1 : TopologicalSpace Y] →
{Z : Type v'} →
[inst_2 : TopologicalSpace Z] →
Topology.ContinuousMapGeneratedBy X Y Z →
{ι' ... | null | false |
_private.Mathlib.Order.KrullDimension.0.Order.krullDim_pos_iff_of_orderBot._simp_1_1 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α], (0 ≤ Order.krullDim α) = True | null | false |
Matrix.instPreOrder._proof_2 | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_2} {n : Type u_1} [inst : RCLike 𝕜] (A : Matrix n n 𝕜), (A - A).PosSemidef | null | false |
IsMulFreimanHom.casesOn | Mathlib.Combinatorics.Additive.FreimanHom | {α : Type u_2} →
{β : Type u_3} →
[inst : CommMonoid α] →
[inst_1 : CommMonoid β] →
{n : ℕ} →
{A : Set α} →
{B : Set β} →
{f : α → β} →
{motive : IsMulFreimanHom n A B f → Sort u} →
(t : IsMulFreimanHom n A B f) →
... | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt16.reduceSub._regBuiltin.UInt16.reduceSub.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.3273093604._hygCtx._hyg.92 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
Std.Http.Protocol.H1.Event.noConfusion | Std.Http.Protocol.H1.Event | {P : Sort u} →
{dir : Std.Http.Protocol.H1.Direction} →
{t : Std.Http.Protocol.H1.Event dir} →
{dir' : Std.Http.Protocol.H1.Direction} →
{t' : Std.Http.Protocol.H1.Event dir'} → dir = dir' → t ≍ t' → Std.Http.Protocol.H1.Event.noConfusionType P t t' | null | false |
CategoryTheory.Limits.isKernelCompMono_lift | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
{f : X ⟶ Y} {c : CategoryTheory.Limits.KernelFork f} (i : CategoryTheory.Limits.IsLimit c) {Z : C} (g : Y ⟶ Z)
[hg : CategoryTheory.Mono g] {h : X ⟶ Z} (hh : h = CategoryTheory.CategoryStruct.comp ... | null | true |
Std.HashMap.unitOfList_nil | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α}, Std.HashMap.unitOfList [] = ∅ | null | true |
_private.Mathlib.NumberTheory.Divisors.0.Nat.mem_divisorsAntidiagonal._simp_1_9 | Mathlib.NumberTheory.Divisors | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, a = a' ∧ p a) = p a' | null | false |
Std.Sat.AIG.mkXorCached._proof_2 | Std.Sat.AIG.CachedGates | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (input : aig.BinaryInput),
(aig.mkGateCached input).aig.decls.size ≤
((aig.mkGateCached input).aig.mkGateCached ((input.cast ⋯).invert true true)).aig.decls.size | null | false |
Inclusion.instInhabitedHypArg | Mathlib.Tactic.Inclusion.ExtensionAPI.Attr | Inhabited Inclusion.HypArg | null | true |
Diffeology.IsContDiffCompatible.recOn | Mathlib.Geometry.Diffeology.Basic | {X : Type u_1} →
[inst : NormedAddCommGroup X] →
[inst_1 : NormedSpace ℝ X] →
[inst_2 : DiffeologicalSpace X] →
{motive : Diffeology.IsContDiffCompatible X → Sort u} →
(t : Diffeology.IsContDiffCompatible X) →
((isPlot_iff : ∀ {n : ℕ} {p : EuclideanSpace ℝ (Fin n) → X}, Diffeol... | null | false |
_private.Mathlib.Order.Disjointed.0.Fintype.sup_disjointed._simp_1_1 | Mathlib.Order.Disjointed | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [inst : DecidableEq β] {b : β},
(b ∈ s.biUnion t) = ∃ a ∈ s, b ∈ t a | null | false |
Ring.inverse_invertible | Mathlib.Algebra.GroupWithZero.Invertible | ∀ {α : Type u} [inst : MonoidWithZero α] (x : α) [inst_1 : Invertible x], Ring.inverse x = ⅟x | A variant of `Ring.inverse_unit`. | true |
CategoryTheory.ObjectProperty.ofObj_le_iff | Mathlib.CategoryTheory.ObjectProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {ι : Type u'} (X : ι → C)
(P : CategoryTheory.ObjectProperty C), CategoryTheory.ObjectProperty.ofObj X ≤ P ↔ ∀ (i : ι), P (X i) | null | true |
CategoryTheory.IsPushout.paste_vert | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X₁₁ X₁₂ X₂₁ X₂₂ X₃₁ X₃₂ : C} {h₁₁ : X₁₁ ⟶ X₁₂}
{h₂₁ : X₂₁ ⟶ X₂₂} {h₃₁ : X₃₁ ⟶ X₃₂} {v₁₁ : X₁₁ ⟶ X₂₁} {v₁₂ : X₁₂ ⟶ X₂₂} {v₂₁ : X₂₁ ⟶ X₃₁} {v₂₂ : X₂₂ ⟶ X₃₂},
CategoryTheory.IsPushout h₁₁ v₁₁ v₁₂ h₂₁ →
CategoryTheory.IsPushout h₂₁ v₂₁ v₂₂ h₃₁ →
Cat... | Paste two pushout squares "vertically" to obtain another pushout square.
The objects in the statement fit into the following diagram:
```
X₁₁ - h₁₁ -> X₁₂
| |
v₁₁ v₁₂
↓ ↓
X₂₁ - h₂₁ -> X₂₂
| |
v₂₁ v₂₂
↓ ↓
X₃₁ - h₃₁ -> X₃₂
```
| true |
SaturatedAddSubmonoid.mem_top | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : AddZeroClass M] {x : M}, x ∈ ⊤ | null | true |
ProbabilityTheory.Kernel.instAddCommMonoid._proof_4 | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β},
autoParam (∀ (x : ProbabilityTheory.Kernel α β), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
QuadraticAlgebra.algebraMap_re | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} (r : R) [inst : CommSemiring R], ((algebraMap R (QuadraticAlgebra R a b)) r).re = r | null | true |
OrderMonoidHom.cancel_left._simp_2 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : MulOneClass α] [inst_4 : MulOneClass β] [inst_5 : MulOneClass γ] {g : β →*o γ} {f₁ f₂ : α →*o β},
Function.Injective ⇑g → (g.comp f₁ = g.comp f₂) = (f₁ = f₂) | null | false |
ISize.toInt8_neg | Init.Data.SInt.Lemmas | ∀ (x : ISize), (-x).toInt8 = -x.toInt8 | null | true |
_private.Mathlib.Tactic.ModuleNF.0.Mathlib.Tactic.ModuleNF._aux_Mathlib_Tactic_ModuleNF___elabRules_Mathlib_Tactic_ModuleNF_moduleNF_1._sparseCasesOn_1 | Mathlib.Tactic.ModuleNF | {α : Type u} →
{motive : Lean.LOption α → Sort u_1} →
(t : Lean.LOption α) → ((a : α) → motive (Lean.LOption.some a)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
IsOrderedSMul.casesOn | Mathlib.Algebra.Order.AddTorsor | {G : Type u_3} →
{P : Type u_4} →
[inst : LE G] →
[inst_1 : LE P] →
[inst_2 : SMul G P] →
{motive : IsOrderedSMul G P → Sort u} →
(t : IsOrderedSMul G P) →
((smul_le_smul_left : ∀ (a b : P), a ≤ b → ∀ (c : G), c • a ≤ c • b) →
(smul_le_smul_right... | null | false |
Mathlib.Meta.Multiset.ProveZeroOrConsResult.noConfusion | Mathlib.Tactic.NormNum.BigOperators | {P : Sort u} →
{u : Lean.Level} →
{α : Q(Type u)} →
{s : Q(Multiset «$α»)} →
{t : Mathlib.Meta.Multiset.ProveZeroOrConsResult s} →
{u' : Lean.Level} →
{α' : Q(Type u')} →
{s' : Q(Multiset «$α'»)} →
{t' : Mathlib.Meta.Multiset.ProveZeroOrConsResult ... | null | false |
_private.Lean.Compiler.LCNF.ExpandResetReuse.0.Lean.Compiler.LCNF.isSelfUset._sparseCasesOn_1 | Lean.Compiler.LCNF.ExpandResetReuse | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((i : ℕ) →
(var : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.LetValue.uproj i var h)) →
(Nat.hasNotBit 128... | null | false |
RingHom.CodescendsAlong.and | Mathlib.RingTheory.RingHomProperties | ∀ {P Q P' : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
(RingHom.CodescendsAlong (fun {R S} [CommRing R] [CommRing S] => P) fun {R S} [CommRing R] [CommRing S] => Q) →
(RingHom.CodescendsAlong (fun {R S} [CommRing R] [CommRing S] => P') fun {R S} [CommRing R] [CommRing S] => ... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get_congr._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) | null | false |
Lean.Elab.GoalsAtResult.mk._flat_ctor | Lean.Elab.InfoTree.Util | Lean.Elab.ContextInfo → Lean.Elab.TacticInfo → Bool → Bool → Bool → ℕ → Lean.Elab.GoalsAtResult | null | false |
_private.Mathlib.Algebra.Homology.TotalComplexShift.0.HomologicalComplex₂.D₁_totalShift₂XIso_hom._proof_1_2 | Mathlib.Algebra.Homology.TotalComplexShift | ∀ (y n₀ n₁ n₀' n₁' : ℤ), n₀ + y = n₀' → n₁ + y = n₁' → n₀ + 1 = n₁ → ∀ (p q : ℤ), p + q = n₀ → p + 1 + (q + y) = n₁' | null | false |
MeasureTheory.VectorMeasure.integral_continuousLinearMap_comp | Mathlib.MeasureTheory.VectorMeasure.SetIntegral | ∀ {X : Type u_2} {E : Type u_3} {F : Type u_4} {G : Type u_5} {H : Type u_6} {mX : MeasurableSpace X}
[inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] [inst_2 : NormedAddCommGroup G]
[inst_3 : NormedAddCommGroup H] {μ : MeasureTheory.VectorMeasure X F} [inst_4 : NormedSpace ℝ E]
[inst_5 : NormedSpace... | null | true |
FirstOrder.Ring.CompatibleRing.mk._flat_ctor | Mathlib.ModelTheory.Algebra.Ring.Basic | {R : Type u_2} →
[inst : Add R] →
[inst_1 : Mul R] →
[inst_2 : Neg R] →
[inst_3 : One R] →
[inst_4 : Zero R] →
(funMap :
autoParam ({n : ℕ} → FirstOrder.Language.ring.Functions n → (Fin n → R) → R)
FirstOrder.Language.Structure.funMap._autoPara... | null | false |
MinTropical.tropOrderIso._proof_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : Preorder R] {a b : R},
MinTropical.untrop (MinTropical.tropEquiv a) ≤ MinTropical.untrop (MinTropical.tropEquiv b) ↔
MinTropical.tropEquiv a ≤ MinTropical.tropEquiv b | null | false |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis.0.Tactic.ComputeAsymptotics.WellFormedBasis.pow_isLittleO_pow_of_log.match_1_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | ∀ {f g : ℝ → ℝ} (x : ℝ) (motive : 0 < f x ∧ 0 < g x → Prop) (x_1 : 0 < f x ∧ 0 < g x),
(∀ (hf : 0 < f x) (hg : 0 < g x), motive ⋯) → motive x_1 | null | false |
ZeroAtInftyContinuousMap.coe_add | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddZeroClass β]
[inst_3 : ContinuousAdd β] (f g : ZeroAtInftyContinuousMap α β), ⇑(f + g) = ⇑f + ⇑g | null | true |
TensorProduct.lid'._proof_8 | Mathlib.Algebra.Algebra.Epi | ∀ (A : Type u_1) [inst : CommSemiring A], RingHomInvPair (RingHom.id A) (RingHom.id A) | null | false |
ModuleCat.FreeMonoidal.μIso_inv_freeMk | Mathlib.Algebra.Category.ModuleCat.Adjunctions | ∀ (R : Type u) [inst : CommRing R] {X Y : Type u} (z : CategoryTheory.MonoidalCategoryStruct.tensorObj X Y),
(CategoryTheory.ConcreteCategory.hom (ModuleCat.FreeMonoidal.μIso R X Y).inv) (ModuleCat.freeMk z) =
ModuleCat.freeMk z.1 ⊗ₜ[R] ModuleCat.freeMk z.2 | null | true |
BEq.casesOn | Init.Prelude | {α : Type u} → {motive : BEq α → Sort u_1} → (t : BEq α) → ((beq : α → α → Bool) → motive { beq := beq }) → motive t | null | false |
List.getD_default_eq_getI | Mathlib.Data.List.GetD | ∀ {α : Type u} (l : List α) [inst : Inhabited α] {n : ℕ}, l.getD n default = l.getI n | null | true |
TopCat.Presheaf.presieveOfCoveringAux | Mathlib.Topology.Sheaves.SheafCondition.Sites | {X : TopCat} →
{ι : Type v} → (ι → TopologicalSpace.Opens ↑X) → (Y : TopologicalSpace.Opens ↑X) → CategoryTheory.Presieve Y | Given a family of opens `U : ι → Opens X` and any open `Y : Opens X`, we obtain a presieve
on `Y` by declaring that a morphism `f : V ⟶ Y` is a member of the presieve if and only if
there exists an index `i : ι` such that `V = U i`.
| true |
CategoryTheory.Under.pushout._proof_8 | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushoutsAlong f] {X_1 Y_1 Z : CategoryTheory.Under X} (f_1 : X_1 ⟶ Y_1)
(g : Y_1 ⟶ Z),
CategoryTheory.Under.homMk
(CategoryTheory.Limits.pushout.desc
(CategoryTheory.CategoryStruct... | null | false |
Lean.Grind.OrderConfig.extAll._inherited_default | Init.Grind.Config | Bool | null | false |
Lean.Meta.ArgsPacker.unpack | Lean.Meta.ArgsPacker | Lean.Meta.ArgsPacker → Lean.Expr → Option (ℕ × Array Lean.Expr) | Given the packed argument of a (possibly) mutual and (possibly) nary call,
return the function index that is called and the arguments individually.
We expect precisely the expressions produced by `pack`, with manifest
`PSum.inr`, `PSum.inl` and `PSigma.mk` constructors, and thus take them apart
rather than using proje... | true |
schnirelmannDensity_congr | Mathlib.Combinatorics.Schnirelmann | ∀ {A : Set ℕ} [inst : DecidablePred fun x => x ∈ A] {B : Set ℕ} [inst_1 : DecidablePred fun x => x ∈ B],
A = B → schnirelmannDensity A = schnirelmannDensity B | null | true |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.add_nfBelow.match_1_1 | Mathlib.SetTheory.Ordinal.Notation | ∀ {b : Ordinal.{0}} (motive : (x x_1 : ONote) → x.NFBelow b → x_1.NFBelow b → Prop) (x x_1 : ONote) (x_2 : x.NFBelow b)
(x_3 : x_1.NFBelow b),
(∀ (x : ONote) (x_4 : ONote.NFBelow 0 b) (h₂ : x.NFBelow b), motive ONote.zero x x_4 h₂) →
(∀ (e : ONote) (n : ℕ+) (a o : ONote) (h₁ : (e.oadd n a).NFBelow b) (h₂ : o.NF... | null | false |
ContinuousMap.continuous_precomp | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] (f : C(X, Y)), Continuous fun g => g.comp f | `C(·, Z)` is a functor. | true |
imp.swap | Init.Core | ∀ {a b c : Prop}, a → b → c ↔ b → a → c | null | true |
_private.Mathlib.Analysis.Polynomial.Fourier.0.Polynomial.sum_sq_norm_coeff_eq_circleAverage._simp_1_1 | Mathlib.Analysis.Polynomial.Fourier | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] (n : ℕ), (0 ≤ ↑n) = True | null | false |
Std.Do.PostShape.except.injEq | Std.Do.PostCond | ∀ (ε : Type u) (a : Std.Do.PostShape) (ε_1 : Type u) (a_1 : Std.Do.PostShape),
(Std.Do.PostShape.except ε a = Std.Do.PostShape.except ε_1 a_1) = (ε = ε_1 ∧ a = a_1) | null | true |
ModuleCat.instModuleCarrierObjRestrictScalars._proof_8 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_2} {S : Type u_3} [inst : Ring R] [inst_1 : Ring S] {f : R →+* S} {M : ModuleCat S}
(x : ↑((ModuleCat.restrictScalars f).obj M)), 0 • x = 0 | null | false |
CategoryTheory.SmallObject.FunctorObjIndex.t | 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} → (self : CategoryTheory.SmallObject.FunctorObjIndex f πX) → A self.i ⟶ X | the top morphism in the square | true |
instAddCommGroupPadic._proof_10 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)],
autoParam (∀ (a b : ℚ_[p]), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
_private.Batteries.Recycling.RBTree.WF.0.RBTree.RBNode.Balanced.append.match_1_15 | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} (c : RBTree.RBNode α) (y : α) (d : RBTree.RBNode α) (n : ℕ)
(motive : (c₂ : RBTree.RBColor) → (RBTree.RBNode.node RBTree.RBColor.black c y d).Balanced c₂ (n + 1) → Prop)
(c₂ : RBTree.RBColor) (hr : (RBTree.RBNode.node RBTree.RBColor.black c y d).Balanced c₂ (n + 1)),
(∀ (c₁ c₂ : RBTree.RBColor) (... | null | false |
CategoryTheory.cartesianClosedOfReflective'._proof_1 | Mathlib.CategoryTheory.Monoidal.Closed.Ideal | ∀ {C : Type u_3} {D : Type u_2} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (i : CategoryTheory.Functor D C)
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.MonoidalClosed C]
[CategoryTheory.ExponentialIdeal i] (B X : D), i.essImage ... | null | false |
Lean.Meta.Sym.Config.mk._flat_ctor | Lean.Meta.Sym.SymM | Bool → Bool → Bool → Lean.Meta.Sym.Config | null | false |
ENNReal.le_iInf_mul_iInf | Mathlib.Basic.ENNReal.Inv | ∀ {ι : Sort u_1} {κ : Sort u_2} {f : ι → ENNReal} {a : ENNReal} {g : κ → ENNReal},
(∃ i, f i ≠ ⊤) → (∃ j, g j ≠ ⊤) → (∀ (i : ι) (j : κ), a ≤ f i * g j) → a ≤ (⨅ i, f i) * ⨅ j, g j | null | true |
Simps.Config.nameStem._default | Mathlib.Tactic.Simps.Basic | Option String | null | false |
_private.Mathlib.SetTheory.Cardinal.Subfield.0.Subfield.surjective_ofWType | Mathlib.SetTheory.Cardinal.Subfield | ∀ {α : Type u} (s : Set α) [inst : DivisionRing α],
Function.Surjective (WType.elim (↥(Subfield.closure s)) (Subfield.operate✝ s)) | null | true |
BitVec.getElem?_eq_some_getElem | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (l : BitVec w) (i : ℕ) (h : i < w), l[i]? = some l[i] ↔ True | null | true |
Lean.Expr.getAppFn._unsafe_rec | Lean.Expr | Lean.Expr → Lean.Expr | null | false |
groupCohomology.cocycles₁_map_inv | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u_1, u, u} k G} (f : ↥(groupCohomology.cocycles₁ A))
(g : G), (A.ρ g) (f g⁻¹) = -f g | null | true |
ValuationSubring.instLinearOrderedCommGroupWithZeroValueGroup._proof_53 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K),
autoParam (∀ (a : A.ValueGroup), a ^ 0 = 1) DivInvMonoid.zpow_zero'._autoParam | null | false |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.eq_of_head_mem_of_getLast_mem_of_infix._proof_1_15 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} {l₁ l₂ : List α},
l₁ <:+: l₂ →
∀ {hne : l₂ ≠ []},
l₂.head hne ∈ l₁ →
∀ (w w_1 : List α),
w ++ l₁ ++ w_1 = l₂ → ¬l₂.length - 1 + 1 ≤ w.length → l₂.length - (w.length + 1) < (l₁ ++ w_1).length | null | false |
CategoryTheory.GaloisCategory.recOn | Mathlib.CategoryTheory.Galois.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{motive : CategoryTheory.GaloisCategory C → Sort u} →
(t : CategoryTheory.GaloisCategory C) →
([toPreGaloisCategory : CategoryTheory.PreGaloisCategory C] →
(hasFiberFunctor : ∃ F, CategoryTheory.PreGaloisCategory.FiberFunctor ... | null | false |
Set.Ico.semilatticeInf.eq_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : SemilatticeInf α] {a b : α}, Set.Ico.semilatticeInf = Subtype.semilatticeInf ⋯ | null | true |
Equiv.subtypeEquiv.eq_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_4} {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ (a : α), p a ↔ q (e a)),
e.subtypeEquiv h = { toFun := fun a => ⟨e ↑a, ⋯⟩, invFun := fun b => ⟨e.symm ↑b, ⋯⟩, left_inv := ⋯, right_inv := ⋯ } | null | true |
EsakiaHom.coe_id | Mathlib.Topology.Order.Hom.Esakia | ∀ (α : Type u_2) [inst : TopologicalSpace α] [inst_1 : Preorder α], ⇑(EsakiaHom.id α) = id | null | true |
KaehlerDifferential.mapBaseChange._proof_6 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_1) [inst : CommRing R] (B : Type u_2) [inst_1 : CommRing B] [inst_2 : Algebra R B], IsScalarTower R R B | null | false |
FiniteIndexNormalSubgroup.casesOn | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | {G : Type u_1} →
[inst : Group G] →
{motive : FiniteIndexNormalSubgroup G → Sort u} →
(t : FiniteIndexNormalSubgroup G) →
((toSubgroup : Subgroup G) →
(isNormal' : toSubgroup.Normal) →
(isFiniteIndex' : toSubgroup.FiniteIndex) →
motive { toSubgroup := toSubg... | null | false |
Nat.totient_gcd_mul_totient_mul | Mathlib.Data.Nat.Totient | ∀ (a b : ℕ), (a.gcd b).totient * (a * b).totient = a.totient * b.totient * a.gcd b | null | true |
CategoryTheory.SimplicialObject.Homotopy.h_comp_σ_castSucc_of_le | Mathlib.AlgebraicTopology.SimplicialObject.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject C} {f g : X ⟶ Y}
(self : CategoryTheory.SimplicialObject.Homotopy f g) {n : ℕ} (i j : Fin (n + 1)),
i ≤ j →
CategoryTheory.CategoryStruct.comp (self.h j) (Y.σ i.castSucc) =
CategoryTheory.CategoryStruct.comp (X... | null | true |
Std.Http.Body.Length.chunked.sizeOf_spec | Std.Http.Data.Body.Length | sizeOf Std.Http.Body.Length.chunked = 1 | null | true |
TopCat.Presheaf.pushforward_map_app | Mathlib.Topology.Sheaves.Presheaf | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {X Y : TopCat} (f : X ⟶ Y)
{X_1 Y_1 : CategoryTheory.Functor (TopologicalSpace.Opens ↑X)ᵒᵖ C} (α : X_1 ⟶ Y_1)
(X_2 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
((TopCat.Presheaf.pushforward C f).map α).app X_2 =
α.app (Opposite.op ((TopologicalSpace.Opens.map f).o... | null | true |
instPreservesColimitsOfShapeSheafTypeYonedaOfPreservesLimitsOfShapeOppositeObjFunctorIsSheaf | Mathlib.CategoryTheory.Sites.PreservesLimits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
[inst_1 : J.Subcanonical] {K : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} K]
[∀ (X : CategoryTheory.Sheaf J (Type v)), CategoryTheory.Limits.PreservesLimitsOfShape Kᵒᵖ X.obj],
CategoryTheory.Limits.Pre... | null | true |
Subalgebra.equivOfEq._proof_6 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S T : Subalgebra R A) (h : S = T),
Function.RightInverse (LinearEquiv.ofEq (Subalgebra.toSubmodule S) (Subalgebra.toSubmodule T) ⋯).invFun
(↑(LinearEquiv.ofEq (Subalgebra.toSubmodule S) (Subalgebra.toSubmodule ... | null | false |
IsLocalization.isLocalization_of_submonoid_le | Mathlib.RingTheory.Localization.LocalizationLocalization | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Type u_2) [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (T : Type u_3)
[inst_3 : CommSemiring T] [inst_4 : Algebra R T] (M N : Submonoid R),
M ≤ N →
∀ [IsLocalization M S] [IsLocalization N T] [inst_7 : Algebra S T] [IsScalarTower R S T],
IsLocalization (Su... | If `M ≤ N` are submonoids of `R`, then `N⁻¹S` is also the localization of `M⁻¹S` at `N`. | true |
CategoryTheory.Pretriangulated.invRotCompRot_hom_app_hom₁ | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
(X : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.Pretriangulated.invRotCompRot.hom.app X).hom₁ = ... | null | true |
MeasureTheory.setLIntegral_tilted' | Mathlib.MeasureTheory.Measure.Tilted | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : α → ℝ) (g : α → ENNReal) {s : Set α},
MeasurableSet s →
∫⁻ (x : α) in s, g x ∂μ.tilted f =
∫⁻ (x : α) in s, ENNReal.ofReal (Real.exp (f x) / ∫ (x : α), Real.exp (f x) ∂μ) * g x ∂μ | null | true |
CategoryTheory.Limits.CreatesFiniteCoproducts.recOn | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : CategoryTheory.Limits.CreatesFiniteCoproducts F → Sort u} →
(t : CategoryTheory.Limits.CreatesFiniteCoprodu... | null | false |
Lean.Widget.PanelWidgetInstance.noConfusionType | Lean.Widget.UserWidget | Sort u → Lean.Widget.PanelWidgetInstance → Lean.Widget.PanelWidgetInstance → Sort u | null | false |
CochainComplex.trianglehOfDegreewiseSplitRotateRotateIso | Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
(S : CategoryTheory.ShortComplex (CochainComplex C ℤ)) →
(σ : (n : ℤ) → (S.map (HomologicalComplex.eval C (ComplexShape.up ℤ) n)).Splitting) →
[inst_2 : CategoryTheory.Limits.HasBinaryB... | The canonical isomorphism between `(trianglehOfDegreewiseSplit S σ).rotate.rotate` and
`mappingCone.triangleh (homOfDegreewiseSplit S σ)` when `S` is a degreewise split
short exact sequence of cochain complexes. | true |
Finset.map_filter' | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} (p : α → Prop) [inst : DecidablePred p] (f : α ↪ β) (s : Finset α)
[inst_1 : DecidablePred fun x => ∃ a, p a ∧ f a = x],
Finset.map f (Finset.filter p s) = {b ∈ Finset.map f s | ∃ a, p a ∧ f a = b} | null | true |
Mathlib.Tactic.Abel.unfold_smulg | Mathlib.Tactic.Abel | ∀ {α : Type u_1} [inst : AddCommGroup α] (n : ℕ) (x y : α), Mathlib.Tactic.Abel.smulg (Int.ofNat n) x = y → ↑n • x = y | null | true |
Lean.Order.iInf_apply | Std.Internal.Order.Lemmas | ∀ {ι : Type vₗ} {σ : Type wₗ} {β : Type uₗ} [inst : Lean.Order.CompleteLattice β] (f : ι → σ → β) (s : σ),
Lean.Order.iInf f s = Lean.Order.iInf fun i => f i s | Pointwise characterization of indexed infimum on function lattices. | true |
_private.Lean.Exception.0.Lean.Exception.toMessageData.match_1 | Lean.Exception | (motive : Lean.Exception → Sort u_1) →
(x : Lean.Exception) →
((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive (Lean.Exception.error ref msg)) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) → motive x | null | false |
CategoryTheory.Limits.limitFlipIsoCompLim._proof_2 | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {J : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} J] {K : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} K]
[inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C] (F : CategoryTheory.Functor K (CategoryTheory.Functor J C))
{X Y : K} (... | null | false |
Monotone.le_map_iSup₂ | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} {κ : ι → Sort u_6} [inst : CompleteLattice α]
[inst_1 : CompleteLattice β] {f : α → β},
Monotone f → ∀ (s : (i : ι) → κ i → α), ⨆ i, ⨆ j, f (s i j) ≤ f (⨆ i, ⨆ j, s i j) | null | true |
alternatingGroup.index_eq_one | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] [Subsingleton α], (alternatingGroup α).index = 1 | null | true |
List.sum_lt_sum | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {ι : Type u_1} {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [AddLeftStrictMono M] [AddLeftMono M]
[AddRightStrictMono M] [AddRightMono M] {l : List ι} (f g : ι → M),
(∀ i ∈ l, f i ≤ g i) → (∃ i ∈ l, f i < g i) → (List.map f l).sum < (List.map g l).sum | null | true |
CategoryTheory.WithTerminal.isLimitEquiv_symm_apply_lift | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type w} [inst_1 : CategoryTheory.Category.{w', w} J]
{X : C} {K : CategoryTheory.Functor J (CategoryTheory.Over X)} {t : CategoryTheory.Limits.Cone K}
(t_1 : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.Cone (CategoryTheory.WithTermin... | null | true |
NNRat.bddAbove_coe | Mathlib.Data.NNRat.Defs | ∀ {s : Set ℚ≥0}, BddAbove (NNRat.cast '' s) ↔ BddAbove s | null | true |
CategoryTheory.abelianOfAdjunction._proof_2 | Mathlib.CategoryTheory.Abelian.Transfer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} D] [inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D C) [inst_4 : G.PreservesZeroMorphisms]
[inst_5 : ... | null | false |
Module.End.genEigenspace_le_genEigenspace_finrank | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {K : Type v} {V : Type w} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] [FiniteDimensional K V]
(f : Module.End K V) (μ : K) (k : ℕ∞), (f.genEigenspace μ) k ≤ (f.genEigenspace μ) ↑(Module.finrank K V) | Every generalized eigenvector is a generalized eigenvector for exponent `finrank K V`.
(Lemma 8.20 of [axler2024]) | true |
Lean.Elab.Tactic.filterOutImplementationDetails | Mathlib.Tactic.Core | Lean.LocalContext → Array Lean.FVarId → Array Lean.FVarId | Given a local context and an array of `FVarIds` assumed to be in that local context, remove all
implementation details. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.