name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.DHashMap.Raw.Const.all_keys | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [LawfulHashable α]
[EquivBEq α] {p : α → Bool}, m.WF → m.keys.all p = m.all fun a x => p a | null | true |
Int.fmod_fmod | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a.fmod b).fmod b = a.fmod b | null | true |
CategoryTheory.Presieve.FamilyOfElements.isCompatible_map_smul_aux | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ R : CategoryTheory.Functor Cᵒᵖ RingCat} (α : R₀ ⟶ R) [CategoryTheory.Presheaf.IsLocallyInjective J α]
{M₀ : PresheafOfModules R₀} {A : CategoryTheory.Functor Cᵒᵖ AddCommGrpCat} (φ : M₀.presheaf ⟶ A)
[Catego... | null | true |
_private.Mathlib.RingTheory.Invariant.Basic.0.Ideal.map_stabilizer_of_surjective._simp_1_3 | Mathlib.RingTheory.Invariant.Basic | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Group G] [inst_2 : DivisionMonoid H]
[MonoidHomClass F G H] (f : F) (a : G), (f a)⁻¹ = f a⁻¹ | null | false |
CategoryTheory.Pseudofunctor.StrongTrans.naturality_comp | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.Pseudofunctor B C} (self : F.StrongTrans G) {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp (self.naturality (CategoryTheory.CategoryStruct.comp f g)).hom
(Ca... | Oplax functoriality. | true |
CategoryTheory.ShortComplex.Splitting.ofIsIsoOfIsZero._proof_4 | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(S : CategoryTheory.ShortComplex C) (hf : CategoryTheory.IsIso S.f),
CategoryTheory.CategoryStruct.comp (CategoryTheory.inv S.f) S.f + CategoryTheory.CategoryStruct.comp S.g 0 =
CategoryTheory.CategoryStruct.i... | null | false |
_private.Lean.Compiler.LCNF.StructProjCases.0.Lean.Compiler.LCNF.StructProjCases.findStructCtorInfo?._sparseCasesOn_9 | Lean.Compiler.LCNF.StructProjCases | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
(Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.MorphismProperty.Comma.Hom.ext' | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
{L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory... | Alternative `ext` lemma for `Comma.Hom`. | true |
Finset.filter_le_eq_Ici | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] {a : α} [inst_2 : Fintype α]
[inst_3 : DecidablePred fun x => a ≤ x], {x | a ≤ x} = Finset.Ici a | null | true |
SzemerediRegularity.stepBound_mono | Mathlib.Combinatorics.SimpleGraph.Regularity.Bound | Monotone SzemerediRegularity.stepBound | null | true |
contDiff_id | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : WithTop ℕ∞}, ContDiff 𝕜 n id | The identity is `C^n`. | true |
_private.Mathlib.Algebra.ContinuedFractions.Computation.Approximations.0.GenContFract.fib_le_of_contsAux_b._proof_1_1 | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ (n : ℕ), ¬n + 2 ≤ 1 | null | false |
Std.DTreeMap.getKey!_eq_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited α] {k : α}, k ∈ t → t.getKey! k = k | null | true |
_private.Lean.Elab.App.0.Lean.Elab.Term.elabAsElim._regBuiltin.Lean.Elab.Term.elabAsElim.declRange_3 | Lean.Elab.App | IO Unit | null | false |
Subring.copy._proof_4 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u_1} [inst : NonAssocRing R] (S : Subring R) (s : Set R) (hs : s = ↑S), 0 ∈ (S.copy s hs).carrier | null | false |
HNNExtension.toSubgroup_neg_one | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] (A B : Subgroup G), HNNExtension.toSubgroup A B (-1) = B | null | true |
ZMod.val_neg_of_ne_zero | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} [nz : NeZero n] (a : ZMod n) [na : NeZero a], (-a).val = n - a.val | null | true |
String.ofList_eq_empty_iff | Init.Data.String.Basic | ∀ {l : List Char}, String.ofList l = "" ↔ l = [] | null | true |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.Valid.prevn.match_1_3 | Batteries.Data.String.Lemmas | ∀ (x : Substring.Raw) (motive : (∃ l m r, Substring.Raw.ValidFor l m r x) → Prop)
(x_1 : ∃ l m r, Substring.Raw.ValidFor l m r x),
(∀ (l m r : List Char) (h : Substring.Raw.ValidFor l m r x), motive ⋯) → motive x_1 | null | false |
Module.End.instDivisionRing._proof_12 | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : DecidableEq (Module.End R M)] [inst_4 : IsSimpleModule R M] (x : ℚ≥0) (x_1 : Module.End R M),
↑x * x_1 = ↑x * x_1 | null | false |
CompleteDistribLattice.toSDiff | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} → [self : CompleteDistribLattice α] → SDiff α | null | true |
CategoryTheory.Limits.IsLimit.whiskerEquivalence | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{K : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} K] →
{C : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{s : CategoryTheory.Limits.Cone F} →
... | If `s : Cone F` is a limit cone, so is `s` whiskered by an equivalence `e`. | true |
Lean.Meta.Grind.AC.EqCnstrProof.core.injEq | Lean.Meta.Tactic.Grind.AC.Types | ∀ (a b : Lean.Expr) (ea eb : Lean.Grind.AC.Expr) (a_1 b_1 : Lean.Expr) (ea_1 eb_1 : Lean.Grind.AC.Expr),
(Lean.Meta.Grind.AC.EqCnstrProof.core a b ea eb = Lean.Meta.Grind.AC.EqCnstrProof.core a_1 b_1 ea_1 eb_1) =
(a = a_1 ∧ b = b_1 ∧ ea = ea_1 ∧ eb = eb_1) | null | true |
instFintypeAddEquivInt._proof_2 | Mathlib.GroupTheory.ArchimedeanDensely | AddEquiv.neg ℤ ∉ {AddEquiv.refl ℤ} | null | false |
ProperSpace.mk._flat_ctor | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {α : Type u} [inst : PseudoMetricSpace α], (∀ (x : α) (r : ℝ), IsCompact (Metric.closedBall x r)) → ProperSpace α | null | false |
isRelLowerSet_self._simp_1 | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {s : Set α} [inst : LE α], (IsRelLowerSet s fun x => x ∈ s) = True | null | false |
Equiv.commSemigroup.eq_1 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_3} (e : α ≃ β) [inst : CommSemigroup β],
e.commSemigroup = Function.Injective.commSemigroup ⇑e ⋯ ⋯ | null | true |
tsum_eq_sum' | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f : β → α}
{L : SummationFilter β} [L.LeAtTop] {s : Finset β}, Function.support f ⊆ ↑s → ∑'[L] (b : β), f b = ∑ b ∈ s, f b | null | true |
AlgebraicGeometry.Scheme.germToFunctionField._proof_1 | Mathlib.AlgebraicGeometry.FunctionField | ∀ (X : AlgebraicGeometry.Scheme) (U : X.Opens) [h : Nonempty ↥↑U], (Set.univ ∩ ↑U).Nonempty | null | false |
Finset.Nonempty.norm_prod_le_sup'_norm | Mathlib.Analysis.Normed.Group.Ultra | ∀ {M : Type u_1} {ι : Type u_2} [inst : SeminormedCommGroup M] [IsUltrametricDist M] {s : Finset ι} (hs : s.Nonempty)
(f : ι → M), ‖∏ i ∈ s, f i‖ ≤ s.sup' hs fun x => ‖f x‖ | Nonarchimedean norm of a product is less than or equal the norm of any term in the product.
This version is phrased using `Finset.sup'` and `Finset.Nonempty` due to `Finset.sup`
operating over an `OrderBot`, which `ℝ` is not. | true |
Prefunctor.IsCovering.comp | Mathlib.Combinatorics.Quiver.Covering | ∀ {U : Type u_1} [inst : Quiver U] {V : Type u_2} [inst_1 : Quiver V] (φ : U ⥤q V) {W : Type u_3} [inst_2 : Quiver W]
(ψ : V ⥤q W), φ.IsCovering → ψ.IsCovering → (φ ⋙q ψ).IsCovering | null | true |
Int.existsUnique_equiv | Mathlib.Data.Int.ModEq | ∀ (a : ℤ) {b : ℤ}, 0 < b → ∃ z, 0 ≤ z ∧ z < b ∧ z ≡ a [ZMOD b] | null | true |
padicNormE._proof_4 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ_[p]), 0 ≤ Quotient.lift PadicSeq.norm ⋯ q | null | false |
_private.Mathlib.RingTheory.Congruence.Star.0.RingConGen.Rel.star.match_1_1 | Mathlib.RingTheory.Congruence.Star | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {r : R → R → Prop}
(motive : (a b : R) → RingConGen.Rel r a b → Prop) (a b : R) (x : RingConGen.Rel r a b),
(∀ (a : R), motive a a ⋯) →
(∀ (a b : R) (h : RingConGen.Rel r b a), motive a b ⋯) →
(∀ (a b y : R) (h1 : RingConGen.Rel r a y) (h2 : RingConGen... | null | false |
List.head?_range' | Init.Data.List.Range | ∀ {s n : ℕ}, (List.range' s n).head? = if n = 0 then none else some s | null | true |
RCLike.nnnorm_nsmul | Mathlib.Analysis.RCLike.Basic | ∀ (K : Type u_1) {E : Type u_2} [inst : RCLike K] [inst_1 : NormedAddCommGroup E] [NormedSpace K E] (n : ℕ) (x : E),
‖n • x‖₊ = n • ‖x‖₊ | null | true |
HomologicalComplex.mapBifunctor₁₂.ι_D₂_assoc | 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_... | null | true |
LieRinehartAlgebra.Hom.apply_lie | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {R : Type u_1} {A₁ : Type u_2} {L₁ : Type u_3} {A₂ : Type u_4} {L₂ : Type u_5} [inst : CommRing R]
[inst_1 : CommRing A₁] [inst_2 : LieRing L₁] [inst_3 : Module A₁ L₁] [inst_4 : LieRingModule L₁ A₁]
[inst_5 : CommRing A₂] [inst_6 : LieRing L₂] [inst_7 : Module A₂ L₂] [inst_8 : LieRingModule L₂ A₂]
[inst_9 : Alg... | This is `LieRinehartAlgebra.Hom.apply_lie'` restated using the coercion to function rather
than `LieRinehartAlgebra.Hom.toLieHom`. | true |
TopologicalSpace.NonemptyCompacts.discreteTopology_iff | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α],
DiscreteTopology (TopologicalSpace.NonemptyCompacts α) ↔ DiscreteTopology α | null | true |
Batteries.UnionFind.FindAux.mk.congr_simp | Batteries.Data.UnionFind.Basic | ∀ {n : ℕ} (s s_1 : Array Batteries.UFNode) (e_s : s = s_1) (root root_1 : Fin n),
root = root_1 →
∀ (size_eq : s.size = n), { s := s, root := root, size_eq := size_eq } = { s := s_1, root := root_1, size_eq := ⋯ } | null | true |
UniformOnFun.hasBasis_uniformity_of_basis_aux₁ | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ (α : Type u_1) (β : Type u_2) {ι : Type u_4} [inst : UniformSpace β] (𝔖 : Set (Set α)) {p : ι → Prop}
{s : ι → Set (β × β)},
(uniformity β).HasBasis p s →
∀ (S : Set α), (uniformity (UniformOnFun α β 𝔖)).HasBasis p fun i => UniformOnFun.gen 𝔖 S (s i) | null | true |
Set.mem_nsmul._simp_1 | Mathlib.Algebra.Group.Pointwise.Set.ListOfFn | ∀ {α : Type u_1} [inst : AddMonoid α] {s : Set α} {a : α} {n : ℕ},
(a ∈ n • s) = ∃ f, (List.ofFn fun i => ↑(f i)).sum = a | null | false |
_private.Mathlib.Topology.DerivedSet.0.isClosed_derivedSet._simp_1_1 | Mathlib.Topology.DerivedSet | ∀ {X : Type u_1} [inst : TopologicalSpace X] (A : Set X), (derivedSet A ⊆ A) = IsClosed A | null | false |
Complement.rec | Init.Prelude | {α : Type u} →
{motive : Complement α → Sort u_1} →
((complement : α → α) → motive { complement := complement }) → (t : Complement α) → motive t | null | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Raw.fold.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} (f : δ → (a : α) → β a → δ) (init : δ) (b : Std.DHashMap.Raw α β),
Std.DHashMap.Raw.fold f init b = (Std.DHashMap.Raw.foldM (fun x1 x2 x3 => pure (f x1 x2 x3)) init b).run | null | true |
CategoryTheory.Limits.Sigma.π | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasZeroMorphisms C] →
{β : Type w} →
[DecidableEq β] → (f : β → C) → [inst_3 : CategoryTheory.Limits.HasCoproduct f] → (b : β) → ∐ f ⟶ f b | In the presence of 0-morphisms we can define a projection morphism from any coproduct. | true |
LowerSet.Iic_sup_erase | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : LowerSet α} {a : α},
a ∈ s → (∀ b ∈ s, a ≤ b → b = a) → LowerSet.Iic a ⊔ s.erase a = s | null | true |
Mathlib.Tactic.BicategoryCoherence.LiftHom₂.casesOn | Mathlib.Tactic.CategoryTheory.BicategoryCoherence | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f g : a ⟶ b} →
[inst_1 : Mathlib.Tactic.BicategoryCoherence.LiftHom f] →
[inst_2 : Mathlib.Tactic.BicategoryCoherence.LiftHom g] →
{η : f ⟶ g} →
{motive : Mathlib.Tactic.BicategoryCoherence.LiftHom... | null | false |
instIsTransOfIsWellOrder | Mathlib.Order.RelClasses | ∀ {α : Type u} (r : α → α → Prop) [IsWellOrder α r], IsTrans α r | null | true |
Path.add_apply | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : Add X] [inst_2 : ContinuousAdd X] {a₁ b₁ a₂ b₂ : X}
(γ₁ : Path a₁ b₁) (γ₂ : Path a₂ b₂) (a : ↑unitInterval), (γ₁.add γ₂) a = γ₁ a + γ₂ a | null | true |
QuadraticAlgebra.instMul | Mathlib.Algebra.QuadraticAlgebra.Defs | {R : Type u_1} → {a b : R} → [Mul R] → [Add R] → Mul (QuadraticAlgebra R a b) | null | true |
AddConstEquiv._sizeOf_inst | Mathlib.Algebra.AddConstMap.Equiv | (G : Type u_1) →
(H : Type u_2) →
{inst : Add G} → {inst_1 : Add H} → (a : G) → (b : H) → [SizeOf G] → [SizeOf H] → SizeOf (AddConstEquiv G H a b) | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Coalgebra.0.InnerProductSpace.ringOfCoalgebra._simp_2 | Mathlib.Analysis.InnerProductSpace.Coalgebra | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ ... | null | false |
MeasureTheory.uniformIntegrable_average | Mathlib.MeasureTheory.Function.UniformIntegrable | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p : ENNReal} {E : Type u_4}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E],
1 ≤ p →
∀ {f : ℕ → α → E},
MeasureTheory.UniformIntegrable f p μ →
MeasureTheory.UniformIntegrable (fun n => (↑n)⁻¹ • ∑ i ∈ Finset.range n, ... | The averaging of a uniformly integrable sequence is also uniformly integrable. | true |
MonoidHom.mker_inr | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N], MonoidHom.mker (MonoidHom.inr M N) = ⊥ | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.saddOverflow_eq._simp_1_3 | Init.Data.BitVec.Bitblast | ∀ (p q : Prop) [dpq : Decidable (p ∧ q)] [dp : Decidable p] [dq : Decidable q], (decide p && decide q) = decide (p ∧ q) | null | false |
PFunctor.Approx.AllAgree | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → ((n : ℕ) → PFunctor.Approx.CofixA F n) → Prop | Given an infinite series of approximations `approx`,
`AllAgree approx` states that they are all consistent with each other.
| true |
ComplexShape.decidableRelSymm | Mathlib.Algebra.Homology.ComplexShape | {α : Type u_2} → (c : ComplexShape α) → [DecidableRel c.Rel] → DecidableRel c.symm.Rel | If `c : ComplexShape α` is such that `c.Rel` is decidable, it is also the
case of `c.symm.Rel`. | true |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.elabSimpConfig.match_1 | Lean.Elab.Tactic.Simp | (motive : Lean.Elab.Tactic.SimpKind → Sort u_1) →
(kind : Lean.Elab.Tactic.SimpKind) →
(Unit → motive Lean.Elab.Tactic.SimpKind.simp) →
(Unit → motive Lean.Elab.Tactic.SimpKind.simpAll) → (Unit → motive Lean.Elab.Tactic.SimpKind.dsimp) → motive kind | null | false |
CategoryTheory.Functor.instIsEquivalenceOppositeOp | Mathlib.CategoryTheory.Opposites | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} [F.IsEquivalence], F.op.IsEquivalence | null | true |
Std.Sat.AIG.relabel | Std.Sat.AIG.Relabel | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{β : Type} → [inst_2 : Hashable β] → [inst_3 : DecidableEq β] → (α → β) → Std.Sat.AIG α → Std.Sat.AIG β | null | true |
CategoryTheory.Profunctor.associatorInvFun | Mathlib.CategoryTheory.Profunctor.Comp | {C D E F : Type u} →
[inst : CategoryTheory.Category.{v_1, u} C] →
[inst_1 : CategoryTheory.Category.{v_2, u} D] →
[inst_2 : CategoryTheory.Category.{v_3, u} E] →
[inst_3 : CategoryTheory.Category.{v_4, u} F] →
(P : CategoryTheory.Profunctor.{max w u, v_1, v_2, u, u} C D) →
(Q ... | The map on representatives underlying `associatorInv`. | true |
_private.Lean.Meta.Sym.Arith.Poly.0.Lean.Grind.CommRing.Mon.coprime._unary._proof_3 | Lean.Meta.Sym.Arith.Poly | ∀ (pw₁ : Lean.Grind.CommRing.Power) (m₁ : Lean.Grind.CommRing.Mon) (pw₂ : Lean.Grind.CommRing.Power)
(m₂ : Lean.Grind.CommRing.Mon),
(invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1
⟨Lean.Grind.CommRing.Mon.mult pw₁ m₁, m₂⟩ ⟨Lean.Grind.CommRing.Mon.mult pw₁ m₁, Lean.Gr... | null | false |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.HasFirstPageComputation.recOn | Mathlib.Algebra.Homology.SpectralObject.FirstPage | {ι : Type u_2} →
{κ : Type u_3} →
[inst : Preorder ι] →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
{data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀} →
{motive : data.HasFirstPageComputation → Sort u} →
(t : data.HasFirstPageComputation) →
... | null | false |
CoalgCat.instMonoidalCategoryStruct._proof_1 | Mathlib.Algebra.Category.CoalgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (X : CoalgCat R), IsScalarTower R R ↑X.toModuleCat | null | false |
HomotopicalAlgebra.fibrations_eq_unop | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C],
HomotopicalAlgebra.fibrations C = (HomotopicalAlgebra.cofibrations Cᵒᵖ).unop | null | true |
isEmpty_fintype._simp_1 | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_3}, IsEmpty (Fintype α) = Infinite α | null | false |
Std.DTreeMap.Internal.Impl.link2._proof_19 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l r : Std.DTreeMap.Internal.Impl α β) (szl : ℕ) (k' : α) (v' : β k')
(l' r' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner szl k' v' l' r').Balanced →
l = Std.DTreeMap.Internal.Impl.inner szl k' v' l' r' →
∀ (szr : ℕ) (k'' : α) (v'' : β k'') (l'' ... | null | false |
Homotopy.ext | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_1} {V : Type u} {inst : CategoryTheory.Category.{v, u} V} {inst_1 : CategoryTheory.Preadditive V}
{c : ComplexShape ι} {C D : HomologicalComplex V c} {f g : C ⟶ D} {x y : Homotopy f g}, x.hom = y.hom → x = y | null | true |
ContinuousLinearMap.cont._autoParam | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | Lean.Syntax | null | false |
_private.Lean.Data.Json.Printer.0.Lean.Json.needEscape.go._proof_3 | Lean.Data.Json.Printer | ∀ (s : String), ∀ i < s.utf8ByteSize, InvImage (fun x1 x2 => x1 < x2) (fun x => s.utf8ByteSize - x) (i + 1) i | null | false |
Lean.Elab.ComputedFields.Context.compFieldVars | Lean.Elab.ComputedFields | Lean.Elab.ComputedFields.Context → Array Lean.Expr | null | true |
Lake.Hash.rec | Lake.Build.Trace | {motive : Lake.Hash → Sort u} → ((val : UInt64) → motive { val := val }) → (t : Lake.Hash) → motive t | null | false |
WithTop.instOrderedSub | Mathlib.Algebra.Order.Sub.WithTop | ∀ {α : Type u_1} [inst : Add α] [inst_1 : LE α] [inst_2 : OrderBot α] [inst_3 : Sub α] [OrderedSub α],
OrderedSub (WithTop α) | null | true |
CoalgCat.Hom.casesOn | Mathlib.Algebra.Category.CoalgCat.Basic | {R : Type u} →
[inst : CommRing R] →
{V W : CoalgCat R} →
{motive : V.Hom W → Sort u_1} →
(t : V.Hom W) →
((toCoalgHom' : ↑V.toModuleCat →ₗc[R] ↑W.toModuleCat) → motive { toCoalgHom' := toCoalgHom' }) → motive t | null | false |
AddSemigroupIdeal.coe_closure' | Mathlib.Algebra.Group.Ideal | ∀ {M : Type u_1} [inst : AddMonoid M] {s : Set M}, ↑(AddSemigroupIdeal.closure s) = Set.univ + s | In an additive monoid, the semigroup ideal generated by `s` is `Set.univ + s`. | true |
zpow_natCast | Mathlib.Algebra.Group.DivInvMonoid | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ ↑n = a ^ n | null | true |
Lean.Meta.TransparencyMode.reducible | Init.MetaTypes | Lean.Meta.TransparencyMode | Unfolds only constants tagged with the `@[reducible]` attribute. Used for speculative
`isDefEq` in proof automation (`simp`, `rw`, type class resolution) where most checks fail
and we must not try too hard. | true |
intervalIntegral.integral_mono_on_of_le_Ioo | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {f g : ℝ → ℝ} {a b : ℝ} {μ : MeasureTheory.Measure ℝ},
a ≤ b →
IntervalIntegrable f μ a b →
IntervalIntegrable g μ a b →
∀ [MeasureTheory.NullSingletonClass μ],
(∀ x ∈ Set.Ioo a b, f x ≤ g x) → ∫ (u : ℝ) in a..b, f u ∂μ ≤ ∫ (u : ℝ) in a..b, g u ∂μ | null | true |
CategoryTheory.locallyDiscreteBicategory._proof_17 | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] {a b c d : CategoryTheory.LocallyDiscrete C}
{f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c) (h : c ⟶ d),
CategoryTheory.eqToHom ⋯ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToIso ⋯).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.... | null | false |
Aesop.instInhabitedRulePattern | Aesop.RulePattern | Inhabited Aesop.RulePattern | null | true |
Lean.Meta.getCoeFnInfo? | Lean.Meta.CoeAttr | Lean.Name → Lean.CoreM (Option Lean.Meta.CoeFnInfo) | Lookup the coercion information for a given function | true |
AddEquiv.symm_map_add | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_9} {N : Type u_10} [inst : Add M] [inst_1 : Add N] (h : M ≃+ N) (x y : N),
h.symm (x + y) = h.symm x + h.symm y | null | true |
MvPolynomial.instIsPushout | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ {R : Type u} [inst : CommSemiring R] {σ : Type u_1} {S : Type u_3} [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
Algebra.IsPushout R S (MvPolynomial σ R) (MvPolynomial σ S) | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.idbg._regBuiltin.Lean.Parser.Term.idbg_1 | Lean.Parser.Term | IO Unit | null | false |
PointedCone.IsFaceOf.mem_of_smul_add_smul_mem_left | Mathlib.Geometry.Convex.Cone.Face.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {C F : PointedCone R M} {x y : M} {a b : R},
F.IsFaceOf C → x ∈ C → y ∈ C → 0 < a → 0 < b → a • x + b • y ∈ F → x ∈ F | null | true |
Aesop.UnsafeRuleInfo.mk.injEq | Aesop.Rule | ∀ (successProbability successProbability_1 : Aesop.Percent),
({ successProbability := successProbability } = { successProbability := successProbability_1 }) =
(successProbability = successProbability_1) | null | true |
QuadraticAlgebra.mk_eq_add_smul_omega | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u_2} {a b : R} [inst : CommSemiring R] (x y : R),
{ re := x, im := y } = (algebraMap R (QuadraticAlgebra R a b)) x + y • QuadraticAlgebra.omega | null | true |
UniformFun.uniformCore.match_7 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ (β : Type u_1) [inst : UniformSpace β] (w : Set (β × β)) (motive : (∃ t ∈ uniformity β, SetRel.comp t t ⊆ w) → Prop)
(x : ∃ t ∈ uniformity β, SetRel.comp t t ⊆ w),
(∀ (W : Set (β × β)) (hW : W ∈ uniformity β) (hWV : SetRel.comp W W ⊆ w), motive ⋯) → motive x | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKey!_alter._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
tsum_geometric_two' | Mathlib.Analysis.SpecificLimits.Basic | ∀ (a : ℝ), ∑' (n : ℕ), a / 2 / 2 ^ n = a | null | true |
_private.Init.Internal.Order.While.0.Lean.Loop.forIn_eq_of_monadTail.match_1_1 | Init.Internal.Order.While | ∀ {β : Type u_1} (motive : ForInStep β → Prop) (x : ForInStep β),
(∀ (a : β), motive (ForInStep.done a)) → (∀ (a : β), motive (ForInStep.yield a)) → motive x | null | false |
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.insert._proof_3 | Std.Data.DHashMap.Internal.Defs | ∀ {α : Type u_1} {β : α → Type u_2} (a : α) (b : β a) (size : ℕ)
(buckets : Array (Std.DHashMap.Internal.AssocList α β)),
0 < { size := size, buckets := buckets }.buckets.size →
∀ (i : USize) (h : i.toNat < buckets.size),
0 <
{ size := size + 1,
buckets := buckets.uset i (Std.DHashMa... | null | false |
Lean.instReprDefinitionSafety | Lean.Declaration | Repr Lean.DefinitionSafety | null | true |
Aesop.Script.StaticStructureM.Context._sizeOf_1 | Aesop.Script.StructureStatic | Aesop.Script.StaticStructureM.Context → ℕ | null | false |
Lean.VersoModuleDocs.isEmpty | Lean.DocString.Extension | Lean.VersoModuleDocs → Bool | null | true |
Set.Finite.encard_biUnion_le | Mathlib.Data.Set.Card.Arithmetic | ∀ {α : Type u_1} {ι : Type u_2} {t : Set ι},
t.Finite → ∀ (s : ι → Set α), (⋃ i ∈ t, s i).encard ≤ ∑ᶠ (i : ι) (_ : i ∈ t), (s i).encard | null | true |
Pi.counit_single | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u_1} {n : Type u_2} [inst : CommSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {A : n → Type u_3}
[inst_3 : (i : n) → AddCommMonoid (A i)] [inst_4 : (i : n) → Module R (A i)]
[inst_5 : (i : n) → CoalgebraStruct R (A i)] (i : n) (a : A i),
CoalgebraStruct.counit (Pi.single i a) = CoalgebraSt... | null | true |
Set.prod_add_prod_comm | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Add α] [inst_1 : Add β] (s₁ s₂ : Set α) (t₁ t₂ : Set β),
s₁ ×ˢ t₁ + s₂ ×ˢ t₂ = (s₁ + s₂) ×ˢ (t₁ + t₂) | null | true |
SpectrumRestricts.compactSpace | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : Semifield R] [inst_1 : Semifield S] [inst_2 : Ring A]
[inst_3 : Algebra R S] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [IsScalarTower R S A]
[inst_7 : TopologicalSpace R] [inst_8 : TopologicalSpace S] {a : A} (f : C(S, R)),
SpectrumRestricts a ⇑f → ∀ [h_c... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.