name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Functor.EssImageSubcategory | Mathlib.CategoryTheory.EssentialImage | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Type u₂ | true |
Finsupp.comul_comp_lapply | Mathlib.RingTheory.Coalgebra.Basic | ∀ (R : Type u) (ι : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : CoalgebraStruct R A] (i : ι),
CoalgebraStruct.comul ∘ₗ Finsupp.lapply i =
TensorProduct.map (Finsupp.lapply i) (Finsupp.lapply i) ∘ₗ CoalgebraStruct.comul | true |
Std.Http.Status.paymentRequired | Std.Internal.Http.Data.Status | Std.Http.Status | true |
Matroid.«term_≤r_» | Mathlib.Combinatorics.Matroid.Minor.Restrict | Lean.TrailingParserDescr | true |
CategoryTheory.Limits.coprod.rightUnitor_naturality | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
[inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C] [inst_2 : CategoryTheory.Limits.HasInitial C] (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.map f (CategoryTheory.CategoryStruct.id (⊥_ C)))
(CategoryTheory... | true |
irreducible_mul_units | Mathlib.Algebra.Group.Irreducible.Lemmas | ∀ {M : Type u_2} [inst : Monoid M] {y : M} (u : Mˣ), Irreducible (y * ↑u) ↔ Irreducible y | true |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.expandNonAtomicExplicitSources.go._unsafe_rec | Lean.Elab.StructInst | Lean.Syntax → List Lean.Syntax → Array Lean.Syntax → Lean.Elab.TermElabM Lean.Syntax | false |
_private.Mathlib.ModelTheory.DirectLimit.0.FirstOrder.Language.«_aux_Mathlib_ModelTheory_DirectLimit___macroRules__private_Mathlib_ModelTheory_DirectLimit_0_FirstOrder_Language_termΣˣ_1» | Mathlib.ModelTheory.DirectLimit | Lean.Macro | false |
_private.Mathlib.Combinatorics.SimpleGraph.EdgeLabeling.0.SimpleGraph.toTopEdgeLabeling_labelGraph._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.EdgeLabeling | ∀ {a : Prop}, (a → False) = ¬a | false |
_private.Init.Data.Nat.Fold.0.Nat.fold.eq_2 | Init.Data.Nat.Fold | ∀ {α : Type u} (x : α) (n : ℕ) (f : (i : ℕ) → i < n.succ → α → α), n.succ.fold f x = f n ⋯ (n.fold (fun i h => f i ⋯) x) | true |
ArchimedeanClass.instAddCommMonoid | Mathlib.Algebra.Order.Ring.Archimedean | {R : Type u_1} →
[inst : LinearOrder R] → [inst_1 : CommRing R] → [inst_2 : IsStrictOrderedRing R] → AddCommMonoid (ArchimedeanClass R) | true |
CategoryTheory.Hom.addMonoid._proof_6 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M X : C} [inst_2 : CategoryTheory.AddMonObj M] (n : ℕ) (x : X ⟶ M), nsmulRecAuto (n + 1) x = nsmulRecAuto n x + x | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas.0.RootPairing.RootPositiveForm.rootLength_le_of_pairingIn_eq._simp_1_5 | Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas | ∀ {M : Type u_3} {N : Type u_4} [inst : One M] [inst_1 : One N] {x : M} {y : N}, ((x, y) = 1) = (x = 1 ∧ y = 1) | false |
MeasureTheory.condExpInd.congr_simp | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL1 | ∀ {α : Type u_1} (G : Type u_4) [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m m0 : MeasurableSpace α}
(hm : m ≤ m0) (μ : MeasureTheory.Measure α) [inst_2 : MeasureTheory.SigmaFinite (μ.trim hm)] (s s_1 : Set α),
s = s_1 → MeasureTheory.condExpInd G hm μ s = MeasureTheory.condExpInd G hm μ s_1 | true |
_private.Mathlib.RingTheory.DividedPowers.Basic.0.DividedPowers.ext._proof_1_2 | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} (hI : ℕ → A → A) (h₀ : ∀ {n : ℕ} {x : A}, x ∉ I → hI n x = 0)
(dpow_zero : ∀ {x : A}, x ∈ I → hI 0 x = 1) (dpow_one : ∀ {x : A}, x ∈ I → hI 1 x = x)
(dpow_mem : ∀ {n : ℕ} {x : A}, n ≠ 0 → x ∈ I → hI n x ∈ I)
(dpow_add : ∀ {n : ℕ} {x y : A}, x ∈ I → y ∈ I → hI... | false |
Lean.Parser.Term.structInst | Lean.Parser.Term | Lean.Parser.Parser | true |
ModuleCat.MonoidalCategory.associator_def | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommRing R] (M N K : ModuleCat R),
CategoryTheory.MonoidalCategoryStruct.associator M N K = (TensorProduct.assoc R ↑M ↑N ↑K).toModuleIso | true |
contMDiff_model | Mathlib.Geometry.Manifold.ContMDiff.Atlas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {n : WithTop ℕ∞},
ContMDiff I (modelWithCornersSelf 𝕜 E) n ↑I | true |
AddMonoidHom.ergodic_of_dense_iUnion_preimage_zero | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] [SecondCountableTopology G]
[inst_4 : MeasurableSpace G] [BorelSpace G] [CompactSpace G] {μ : MeasureTheory.Measure G} [μ.IsAddHaarMeasure]
(f : G →+ G), Dense (⋃ n, (⇑f)^[n] ⁻¹' 0) → Continuous ⇑f → Function.Surjective ⇑f ... | true |
instGroupPresentedGroup._proof_10 | Mathlib.GroupTheory.PresentedGroup | ∀ {α : Type u_1} (rels : Set (FreeGroup α)),
autoParam (∀ (x : PresentedGroup rels), instGroupPresentedGroup._aux_8 rels 0 x = 1) Monoid.npow_zero._autoParam | false |
FirstOrder.Language.Hom | Mathlib.ModelTheory.Basic | (L : FirstOrder.Language) → (M : Type w) → (N : Type w') → [L.Structure M] → [L.Structure N] → Type (max w w') | true |
SubfieldClass.toDivisionRing._proof_8 | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u_1} [inst : DivisionRing K] (S : Type u_2) [inst_1 : SetLike S K] [h : SubfieldClass S K] (s : S),
autoParam (∀ (q : ℚ≥0), ↑q = ↑q.num / ↑q.den) DivisionRing.nnratCast_def._autoParam | false |
Finset.eq_of_mem_of_notMem_erase | Mathlib.Data.Finset.Erase | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, b ∈ s → b ∉ s.erase a → b = a | true |
Lean.Lsp.instToJsonChangeAnnotation | Lean.Data.Lsp.Basic | Lean.ToJson Lean.Lsp.ChangeAnnotation | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.TakeWhile.0.Std.Iterators.Types.TakeWhile.instIterator.match_1.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Monadic.TakeWhile | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {P : β → Std.Iterators.PostconditionT m (ULift.{u_1, 0} Bool)} (out : β)
(motive : Subtype (P out).Property → Sort u_3) (h' : (P out).Property { down := false })
(h_1 : (h' : (P out).Property { down := true }) → motive ⟨{ down := true }, h'⟩)
(h_2 : (h' : (P out).Propert... | true |
Lean.Meta.initFn._@.Lean.Meta.WHNF.499182354._hygCtx._hyg.4 | Lean.Meta.WHNF | IO (Lean.Option Bool) | false |
CategoryTheory.Limits.BinaryBiconeMorphism.winr | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} {A B : CategoryTheory.Limits.BinaryBicone P Q} (self : CategoryTheory.Limits.BinaryBiconeMorphism A B),
CategoryTheory.CategoryStruct.comp A.inr self.hom = B.inr | true |
HasFPowerSeriesOnBall.mk | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : 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] {f : E → F}
{p : FormalMultilinearSeries 𝕜 E F} {x : E} {r : ENNReal},
r ≤ p.radius →
0 < r →
(∀ {y... | true |
PowerSeries.map_cos | Mathlib.RingTheory.PowerSeries.WellKnown | ∀ {A : Type u_1} {A' : Type u_2} [inst : Ring A] [inst_1 : Ring A'] [inst_2 : Algebra ℚ A] [inst_3 : Algebra ℚ A']
(f : A →+* A'), (PowerSeries.map f) (PowerSeries.cos A) = PowerSeries.cos A' | true |
Vector.getElem?_attach | Init.Data.Vector.Attach | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ}, xs.attach[i]? = Option.pmap Subtype.mk xs[i]? ⋯ | true |
instMulSemiringActionQuotientSubgroupSubtypeMemSubringSubring | Mathlib.RingTheory.Invariant.Basic | {B : Type u_2} →
[inst : CommRing B] →
{G : Type u_3} →
[inst_1 : Group G] →
[inst_2 : MulSemiringAction G B] →
(H : Subgroup G) → [inst_3 : H.Normal] → MulSemiringAction (G ⧸ H) ↥(FixedPoints.subring B ↥H) | true |
_private.Mathlib.Algebra.GroupWithZero.Action.Defs.0.DistribMulAction.ext.match_1 | Mathlib.Algebra.GroupWithZero.Action.Defs | ∀ {M : Type u_1} {A : Type u_2} {inst : Monoid M} {inst_1 : AddMonoid A} (motive : DistribMulAction M A → Prop)
(h : DistribMulAction M A),
(∀ (smul : M → A → A) (mul_smul : ∀ (x y : M) (b : A), (x * y) • b = x • y • b) (one_smul : ∀ (b : A), 1 • b = b)
(smul_zero : ∀ (a : M), a • 0 = 0) (smul_add : ∀ (a : M)... | false |
CategoryTheory.Triangulated.TStructure.triangleLEGT_obj_obj₁ | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | true |
String.Slice.Pattern.SearchStep.endPos_rejected | Init.Data.String.Pattern.Basic | ∀ {s : String.Slice} {p q : s.Pos}, (String.Slice.Pattern.SearchStep.rejected p q).endPos = q | true |
_private.Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM.0.UniformConvergenceCLM.instContinuousSemilinearMapClass._proof_1 | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {𝕜₁ : Type u_3} {𝕜₂ : Type u_4} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_2}
(F : Type u_1) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : TopologicalSpace F] (𝔖 : Set (Set E)),
... | false |
Lean.Grind.CommRing.Poly.combine.go.match_1 | Init.Grind.Ring.CommSolver | (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Sort u_1) →
(p₁ p₂ : Lean.Grind.CommRing.Poly) →
((k₁ k₂ : ℤ) → motive (Lean.Grind.CommRing.Poly.num k₁) (Lean.Grind.CommRing.Poly.num k₂)) →
((k₁ k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) →
(p₂ : Lean.Grind.CommRing.Poly) ... | false |
CategoryTheory.Abelian.SpectralObject.spectralSequenceHomologyData_right_p._proof_6 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ (n₀ n₁ : ℤ),
autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.spectralSequenceHomologyData_right_p._auto_1 →
n₀ + 1 = n₁ | false |
FreeRing.coe_surjective | Mathlib.RingTheory.FreeCommRing | ∀ (α : Type u), Function.Surjective FreeRing.castFreeCommRing | true |
CategoryTheory.categoryForgetEnrichment._proof_2 | Mathlib.CategoryTheory.Enriched.Basic | ∀ {C : Type u_3} (W : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} W]
[inst_1 : CategoryTheory.MonoidalCategory W] [inst_2 : CategoryTheory.EnrichedCategory W C],
autoParam
(∀ (X Y : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.rightUnitor
(... | false |
CategoryTheory.Limits.hasCoproductsOfShape_of_small | Mathlib.CategoryTheory.Limits.EssentiallySmall | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (β : Type w₂) [Small.{w₁, w₂} β]
[CategoryTheory.Limits.HasCoproducts C], CategoryTheory.Limits.HasCoproductsOfShape β C | true |
Std.ExtTreeMap.getEntryLE? | Std.Data.ExtTreeMap.Basic | {α : Type u} →
{β : Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeMap α β cmp → α → Option (α × β) | true |
CategoryTheory.Pseudofunctor.CoGrothendieck.mapCompIso._proof_1 | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} 𝒮]
{F G H : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮ᵒᵖ) CategoryTheory.Cat} (α : F ⟶ G) (β : G ⟶ H)
(x : F.CoGrothendieck),
(CategoryTheory.Pseudofunctor.CoGrothendieck.map (CategoryTheory.CategoryStruct.comp α β)).obj x =
((... | false |
CategoryTheory.FinCategory.asTypeToObjAsType_obj | Mathlib.CategoryTheory.FinCategory.AsType | ∀ (α : Type u_1) [inst : Fintype α] [inst_1 : CategoryTheory.SmallCategory α] [inst_2 : CategoryTheory.FinCategory α]
(a : CategoryTheory.FinCategory.AsType α), (CategoryTheory.FinCategory.asTypeToObjAsType α).obj a = id a | true |
Cardinal.ofENat_le_one | Mathlib.SetTheory.Cardinal.ENat | ∀ {m : ℕ∞}, ↑m ≤ 1 ↔ m ≤ 1 | true |
Lean.Meta.Sym.Simp.simpLambda' | Lean.Meta.Sym.Simp.Lambda | Lean.Meta.Sym.Simp.Simproc → Lean.Expr → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result | true |
SaturatedAddSubmonoid.instCompleteSemilatticeInf | Mathlib.Algebra.Group.Submonoid.Saturation | (M : Type u_1) → [inst : AddZeroClass M] → CompleteSemilatticeInf (SaturatedAddSubmonoid M) | true |
CoalgEquiv.Simps.symm_apply | Mathlib.RingTheory.Coalgebra.Equiv | {R : Type u_5} →
[inst : CommSemiring R] →
{A : Type u_6} →
{B : Type u_7} →
[inst_1 : AddCommMonoid A] →
[inst_2 : AddCommMonoid B] →
[inst_3 : Module R A] →
[inst_4 : Module R B] →
[inst_5 : CoalgebraStruct R A] → [inst_6 : CoalgebraStruct R B] →... | true |
tendsto_intCast_atBot_sup_atTop_cobounded | Mathlib.Analysis.SpecificLimits.Normed | ∀ {α : Type u_1} [inst : NormedRing α] [NormSMulClass ℤ α] [Nontrivial α],
Filter.Tendsto Int.cast (Filter.atBot ⊔ Filter.atTop) (Bornology.cobounded α) | true |
GradeMaxOrder.liftRight._proof_1 | Mathlib.Order.Grade | ∀ {𝕆 : Type u_2} {α : Type u_1} {β : Type u_3} [inst : Preorder 𝕆] [inst_1 : Preorder α] [inst_2 : Preorder β]
[inst_3 : GradeMaxOrder 𝕆 β] (f : α → β),
(∀ (a : α), IsMax a → IsMax (f a)) → ∀ (x : α), IsMax x → IsMax (grade 𝕆 (f x)) | false |
_private.Init.Data.Rat.Lemmas.0.Rat.ceil_lt._simp_1_1 | Init.Data.Rat.Lemmas | ∀ {a b : ℚ}, (-a < b) = (-b < a) | false |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.find_nat_lt._proof_1_2 | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} {p : ℕ → Prop} (h : ∃ k < n, p k), h.choose < n ∧ p h.choose → p (Classical.choose h) | false |
Aesop.Check.rec | Aesop.Check | {motive : Aesop.Check → Sort u} →
((toOption : Lean.Option Bool) → motive { toOption := toOption }) → (t : Aesop.Check) → motive t | false |
Lean.Meta.Simp.Config.rec | Init.MetaTypes | {motive : Lean.Meta.Simp.Config → Sort u} →
((maxSteps maxDischargeDepth : ℕ) →
(contextual memoize singlePass zeta beta eta : Bool) →
(etaStruct : Lean.Meta.EtaStructMode) →
(iota proj decide arith autoUnfold dsimp failIfUnchanged ground unfoldPartialApp zetaDelta index
implicit... | false |
CategoryTheory.MonoidalClosed.noConfusionType | Mathlib.CategoryTheory.Monoidal.Closed.Basic | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.MonoidalClosed C →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
[inst'_1 : CategoryTheory.MonoidalCategory C'] → Ca... | false |
CategoryTheory.FreeGroupoid.lift_map_homMk | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {E : Type u₂} [inst_1 : CategoryTheory.Groupoid E]
(φ : CategoryTheory.Functor C E) {X Y : C} (f : X ⟶ Y),
(CategoryTheory.FreeGroupoid.lift φ).map (CategoryTheory.FreeGroupoid.homMk f) = φ.map f | true |
CategoryTheory.CreatesColimit.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | false |
Complex.two_cos | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℂ), 2 * Complex.cos x = Complex.exp (x * Complex.I) + Complex.exp (-x * Complex.I) | true |
Int.Linear.Poly.getGeneration | Lean.Meta.Tactic.Grind.Arith.Cutsat.CommRing | Int.Linear.Poly → Lean.Meta.Grind.GoalM ℕ | true |
_private.Mathlib.Data.PEquiv.0.PEquiv.instSemilatticeInfOfDecidableEq._simp_1 | Mathlib.Data.PEquiv | ∀ {α : Type u_1} {a : α} {b : Option α}, (a ∈ b) = (b = some a) | false |
Set.iInter₂_comm | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} {ι' : Sort u_6} {κ : ι → Sort u_8} {κ' : ι' → Sort u_11}
(s : (i : ι) → κ i → (i' : ι') → κ' i' → Set α), ⋂ i, ⋂ j, ⋂ i', ⋂ j', s i j i' j' = ⋂ i', ⋂ j', ⋂ i, ⋂ j, s i j i' j' | true |
String.LE.eq_1 | Mathlib.Data.String.Basic | String.LE = { le := fun s₁ s₂ => ¬s₂ < s₁ } | true |
Aesop.EqualUpToIds.equalCommonMVars? | Aesop.Util.EqualUpToIds | Lean.MVarId → Lean.MVarId → Aesop.EqualUpToIdsM (Option Bool) | true |
groupCohomology.cocycles₁IsoOfIsTrivial_inv_hom_apply_coe | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u, u} k G) [hA : A.IsTrivial]
(a : Additive G →+ ↑A) (a_1 : Additive G),
↑((ModuleCat.Hom.hom (groupCohomology.cocycles₁IsoOfIsTrivial A).inv) a) a_1 = a a_1 | true |
Lean.AttributeExtensionOLeanEntry.mk.inj | Lean.Attributes | ∀ {builderId ref : Lean.Name} {args : List Lean.DataValue} {builderId_1 ref_1 : Lean.Name}
{args_1 : List Lean.DataValue},
{ builderId := builderId, ref := ref, args := args } = { builderId := builderId_1, ref := ref_1, args := args_1 } →
builderId = builderId_1 ∧ ref = ref_1 ∧ args = args_1 | true |
_private.Mathlib.RingTheory.Ideal.Norm.AbsNorm.0.Ideal.span_singleton_absNorm_le._simp_1_1 | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {α : Type u} [inst : Semiring α] {s : Set α} {I : Ideal α}, (Ideal.span s ≤ I) = (s ⊆ ↑I) | false |
Std.DTreeMap.minKey_modify | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k : α} {f : β k → β k} {he : (t.modify k f).isEmpty = false},
(t.modify k f).minKey he = t.minKey ⋯ | true |
Algebra.Extension.tensorCotangentSpaceOfFormallyEtale._proof_17 | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u_3} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{P : Algebra.Extension R S}, LinearMap.CompatibleSMul Ω[P.Ring⁄R] (TensorProduct P.Ring S Ω[P.Ring⁄R]) P.Ring P.Ring | false |
Ordinal.gamma0_eq_nfp | Mathlib.SetTheory.Ordinal.Veblen | Ordinal.gamma 0 = Ordinal.nfp (fun x => Ordinal.veblen x 0) 0 | true |
ModularForm.toSlashInvariantForm_intCast | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [inst : Γ.HasDetPlusMinusOne] (z : ℤ), (↑z).toSlashInvariantForm = ↑z | true |
CategoryTheory.SmallObject.SuccStruct.transfiniteCompositionOfShapeιIteration_F | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (Φ : CategoryTheory.SmallObject.SuccStruct C) (J : Type w)
[inst_1 : LinearOrder J] [inst_2 : OrderBot J] [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J]
[inst_5 : CategoryTheory.Limits.HasIterationOfShape J C],
(Φ.transfiniteCompositionOfShapeιIteration ... | true |
CategoryTheory.Pretriangulated.Triangle.functorIsoMk._proof_2 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
[inst_2 : CategoryTheory.Category.{u_3, u_1} J]
(A B : CategoryTheory.Functor J (CategoryTheory.Pretriangulated.Triangle C))
(iso₂ : A.comp CategoryTheory.Pretriangulated.Triangle.π₂ ≅ B.comp Categ... | false |
CategoryTheory.Limits.mapPair.match_3 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ (X Y : CategoryTheory.Limits.WalkingPair) (motive : ({ as := X } ⟶ { as := Y }) → Prop)
(x : { as := X } ⟶ { as := Y }),
(∀ (u : { as := X }.as = { as := Y }.as), motive { down := { down := u } }) → motive x | false |
AddMonoidHom.toAddHom | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} → {N : Type u_11} → [inst : AddZero M] → [inst_1 : AddZero N] → (M →+ N) → M →ₙ+ N | true |
PowerBasis.AlgHom.fintype | Mathlib.RingTheory.PowerBasis | {S : Type u_2} →
[inst : Ring S] →
{A : Type u_4} →
{B : Type u_5} →
[inst_1 : CommRing A] →
[inst_2 : CommRing B] →
[inst_3 : Algebra A B] → [inst_4 : Algebra A S] → [IsDomain B] → PowerBasis A S → Fintype (S →ₐ[A] B) | true |
_private.Init.PropLemmas.0.exists_or_eq_imp._simp_1_1 | Init.PropLemmas | ∀ {a b c : Prop}, ((a ∨ b) ∧ c) = (a ∧ c ∨ b ∧ c) | false |
CategoryTheory.TransfiniteCompositionOfShape.map | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} D] →
{J : Type w} →
[inst_2 : LinearOrder J] →
[inst_3 : OrderBot J] →
{X Y : C} →
{f : X ⟶ Y} →
[inst_4 : SuccO... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey?_le_maxKey?_insert._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) | false |
_private.Lean.Util.CollectLevelParams.0.Lean.CollectLevelParams.collect._sparseCasesOn_1 | Lean.Util.CollectLevelParams | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
((a : Lean.Level) → motive a.succ) →
((a a_1 : Lean.Level) → motive (a.max a_1)) →
((a a_1 : Lean.Level) → motive (a.imax a_1)) →
((a : Lean.Name) → motive (Lean.Level.param a)) → (Nat.hasNotBit 30 t.ctorIdx → motive t) → motive t | false |
Std.TreeSet.min_le_of_contains | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
(hc : t.contains k = true), (cmp (t.min ⋯) k).isLE = true | true |
ENat.recTopCoe_one | Mathlib.Data.ENat.Basic | ∀ {C : ℕ∞ → Sort u_1} (d : C ⊤) (f : (a : ℕ) → C ↑a), ENat.recTopCoe d f 1 = f 1 | true |
Submodule.set_smul_le_iff | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {S : Type u_4}
[inst_3 : Monoid S] [inst_4 : DistribMulAction S M] (s : Set S) (N p : Submodule R M),
s • N ≤ p ↔ ∀ ⦃r : S⦄ ⦃n : M⦄, r ∈ s → n ∈ N → r • n ∈ p | true |
UInt8.instLawfulHasSize | Init.Data.Range.Polymorphic.UInt | Std.Rxc.LawfulHasSize UInt8 | true |
Lean.Elab.Do.getLetRecDeclsVars | Lean.Elab.Do.PatternVar | Lean.TSyntax `Lean.Parser.Term.letRecDecls → Lean.Elab.TermElabM (Array Lean.Ident) | true |
iInf_union | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α} {s t : Set β},
⨅ x ∈ s ∪ t, f x = (⨅ x ∈ s, f x) ⊓ ⨅ x ∈ t, f x | true |
MeasureTheory.Lp.edist_eq_eLpNorm_neg_add | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] (f g : ↥(MeasureTheory.Lp E p μ)), edist f g = MeasureTheory.eLpNorm (-↑↑f + ↑↑g) p μ | true |
AlgebraicClosure.instField._proof_13 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k], IsScalarTower ℚ k k | false |
Set.sInter_image | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} (f : α → Set β) (s : Set α), ⋂₀ (f '' s) = ⋂ a ∈ s, f a | true |
CategoryTheory.Idempotents.toKaroubi_map_f | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} (f : X ⟶ Y),
((CategoryTheory.Idempotents.toKaroubi C).map f).f = f | true |
_private.Mathlib.Analysis.LocallyConvex.Polar.0.LinearMap.sInter_polar_finite_subset_eq_polar._simp_1_2 | Mathlib.Analysis.LocallyConvex.Polar | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
Mathlib.Tactic.ITauto.Proof.decidableElim.sizeOf_spec | Mathlib.Tactic.ITauto | ∀ (classical : Bool) (p₁ x : Lean.Name) (p₂ p₃ : Mathlib.Tactic.ITauto.Proof),
sizeOf (Mathlib.Tactic.ITauto.Proof.decidableElim classical p₁ x p₂ p₃) =
1 + sizeOf classical + sizeOf p₁ + sizeOf x + sizeOf p₂ + sizeOf p₃ | true |
TopologicalSpace.Compacts.equiv_trans | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (f : α ≃ₜ β) (g : β ≃ₜ γ),
TopologicalSpace.Compacts.equiv (f.trans g) =
(TopologicalSpace.Compacts.equiv f).trans (TopologicalSpace.Compacts.equiv g) | true |
Lean.Lsp.SymbolKind.module.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SymbolKind.module = 1 | true |
ProbabilityTheory.Kernel.indep_limsup_atTop_self | Mathlib.Probability.Independence.ZeroOne | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {s : ι → MeasurableSpace Ω}
{m0 : MeasurableSpace Ω} {κ : ProbabilityTheory.Kernel α Ω} {μα : MeasureTheory.Measure α} [inst : SemilatticeSup ι]
[NoMaxOrder ι] [Nonempty ι],
(∀ (n : ι), s n ≤ m0) →
ProbabilityTheory.Kernel.iIndep s κ μα ... | true |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.Basic.0.UpperHalfPlane.vadd_right_cancel_iff._simp_1_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ {x y : UpperHalfPlane}, (x = y) = (↑x = ↑y) | false |
CategoryTheory.injective_iff_rlp_monomorphisms_zero | Mathlib.CategoryTheory.Preadditive.Injective.LiftingProperties | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] (I : C),
CategoryTheory.Injective I ↔ (CategoryTheory.MorphismProperty.monomorphisms C).rlp 0 | true |
seminormFromBounded_neg | Mathlib.Analysis.Normed.Unbundled.SeminormFromBounded | ∀ {R : Type u_1} [inst : CommRing R] {f : R → ℝ},
(∀ (x : R), f (-x) = f x) → ∀ (x : R), seminormFromBounded' f (-x) = seminormFromBounded' f x | true |
IsAddCommutative.instAddCommGroup | Mathlib.Algebra.Group.Defs | {G : Type u_2} → [inst : AddGroup G] → [IsAddCommutative G] → AddCommGroup G | true |
_private.Mathlib.Geometry.Euclidean.Angle.Sphere.0.EuclideanGeometry.cospherical_of_two_zsmul_oangle_eq_of_not_collinear._simp_1_1 | Mathlib.Geometry.Euclidean.Angle.Sphere | ∀ {α : Type u_1} {s t : Set α} {a : α}, (insert a s ⊆ t) = (a ∈ t ∧ s ⊆ t) | false |
Lean.Parser.Command.importPath._regBuiltin.Lean.Parser.Command.importPath.formatter_7 | Lean.Parser.Command | IO Unit | false |
Subalgebra.starClosure_le | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] {S₁ : Subalgebra R A}
{S₂ : StarSubalgebra R A}, S₁ ≤ S₂.toSubalgebra → S₁.starClosure ≤ S₂ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.