name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.isUniformInducing_pi_restrict._simp_1_2 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {uγ : UniformSpace γ} {f : α → β} {g : β → γ},
UniformSpace.comap f (UniformSpace.comap g uγ) = UniformSpace.comap (g ∘ f) uγ | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.withNewLocalInstancesImpAux | Lean.Meta.Basic | {n : Type → Type u_1} → [MonadControlT Lean.MetaM n] → [Monad n] → {α : Type} → Array Lean.Expr → ℕ → n α → n α | null | true |
Lean.Meta.Sym.ExprPtr.mk.inj | Lean.Meta.Sym.ExprPtr | ∀ {expr expr_1 : Lean.Expr}, { expr := expr } = { expr := expr_1 } → expr = expr_1 | null | true |
Filter.Frequently.mp | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∃ᶠ (x : α) in f, p x) → (∀ᶠ (x : α) in f, p x → q x) → ∃ᶠ (x : α) in f, q x | null | true |
RestrictedProduct.instZSMul._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → SubNegMonoid (R i)] [∀ (i : ι), AddSubgroupClass (S i) (R i)]
(x : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕) (n : ℤ), ∀ᶠ (x_1 : ι) in 𝓕, n • x x_1 ∈ ↑(B... | null | false |
ComplexShape.down' | Mathlib.Algebra.Homology.ComplexShape | {α : Type u_2} → [inst : Add α] → [IsRightCancelAdd α] → α → ComplexShape α | The `ComplexShape` allowing differentials from `X (j+a)` to `X j`.
(For example when `a = 1`, a homology theory indexed by `ℕ` or `ℤ`)
| true |
CategoryTheory.CatEnrichedOrdinary.Hom.ext | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] {X Y : CategoryTheory.CatEnrichedOrdinary C}
{f g : X ⟶ Y} (α β : f ⟶ g),
CategoryTheory.CatEnrichedOrdinary.Hom.base α = CategoryTheory.CatEnrichedOrdinary.Hom.base β → α = β | null | true |
CoeT.rec | Init.Coe | {α : Sort u} →
{x : α} →
{β : Sort v} → {motive : CoeT α x β → Sort u_1} → ((coe : β) → motive { coe := coe }) → (t : CoeT α x β) → motive t | null | false |
CategoryTheory.Limits.pushoutCoconeOfLeftIso_ι_app_none | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
[inst_1 : CategoryTheory.IsIso f], (CategoryTheory.Limits.pushoutCoconeOfLeftIso f g).ι.app none = g | null | true |
LinearMap.lTensor_ker_subtype_tensorKerEquiv_symm | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N]... | null | true |
_private.Mathlib.Order.UpperLower.Basic.0.IsUpperSet.top_mem.match_1_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} {s : Set α} (motive : s.Nonempty → Prop) (x : s.Nonempty),
(∀ (_a : α) (ha : _a ∈ s), motive ⋯) → motive x | null | false |
LieAlgebra.zeroRootSubalgebra_eq_iff_is_cartan | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) [inst_3 : LieRing.IsNilpotent ↥H] [IsNoetherian R L],
LieAlgebra.zeroRootSubalgebra R L H = H ↔ H.IsCartanSubalgebra | null | true |
CategoryTheory.Limits.ChosenPullback.LiftStruct.mk.inj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X₁ X₂ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S}
{h : CategoryTheory.Limits.ChosenPullback f₁ f₂} {Y : C} {g₁ : Y ⟶ X₁} {g₂ : Y ⟶ X₂} {b : Y ⟶ S} {f : Y ⟶ h.pullback}
{f_p₁ :
autoParam (CategoryTheory.CategoryStruct.comp f h.p₁ = g₁)
CategoryTheory.Limits.... | null | true |
PointedCone.mem_dual | Mathlib.Geometry.Convex.Cone.Dual | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {N : Type u_3} [inst_5 : AddCommMonoid N] [inst_6 : Module R N]
{p : M →ₗ[R] N →ₗ[R] R} {s : Set M} {y : N}, y ∈ PointedCone.dual p s ↔ ∀ ⦃x : M⦄, x ∈ s → 0 ≤... | null | true |
MulSemiringActionHomClass.toMulSemiringActionHom._proof_6 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_4} [inst : Monoid M] {N : Type u_5} [inst_1 : Monoid N] {φ : M →* N} {R : Type u_2} [inst_2 : Semiring R]
[inst_3 : MulSemiringAction M R] {S : Type u_1} [inst_4 : Semiring S] [inst_5 : MulSemiringAction N S] {F : Type u_3}
[inst_6 : FunLike F R S] [inst_7 : MulSemiringActionSemiHomClass F (⇑φ) R S] (... | null | false |
String.Pos.Raw.byteIdx_unoffsetBy | Init.Data.String.PosRaw | ∀ {p offset : String.Pos.Raw}, (p.unoffsetBy offset).byteIdx = p.byteIdx - offset.byteIdx | null | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.mapsTo_restrict_maxGenEigenspace_restrict_of_mapsTo._simp_1_1 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
CategoryTheory.ShortComplex.leftHomologyMapIso._proof_2 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) [inst_2 : S₁.HasLeftHomology] [inst_3 : S₂.HasLeftHomology],
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.leftHomologyMap e.inv)... | null | false |
Std.Sat.AIG.RefVec.fold.go_decl_eq._unary | Std.Sat.AIG.RefVecOperator.Fold | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ}
(f : (aig : Std.Sat.AIG α) → aig.BinaryInput → Std.Sat.AIG.Entrypoint α)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.BinaryInput f]
(_x : (aig : Std.Sat.AIG α) ×' (_ : aig.Ref) ×' (_ : ℕ) ×' aig.RefVec len) (idx : ℕ) (h1 : idx < _x.1.decls... | null | false |
Lean.Meta.Tactic.Cbv.CbvSimprocOLeanEntry.ctorIdx | Lean.Meta.Tactic.Cbv.CbvSimproc | Lean.Meta.Tactic.Cbv.CbvSimprocOLeanEntry → ℕ | null | false |
Aesop.preTraverseUp | Aesop.Tree.Traversal | {m : Type → Type} →
[Monad m] →
[MonadLiftT (ST IO.RealWorld) m] →
(Aesop.GoalRef → m Bool) → (Aesop.RappRef → m Bool) → (Aesop.MVarClusterRef → m Bool) → Aesop.TreeRef → m Unit | null | true |
Array._aux_Init_Data_Array_Mem___macroRules_tacticDecreasing_trivial_2 | Init.Data.Array.Mem | Lean.Macro | null | false |
Ordinal.iSup_eq_lsub_or_succ_iSup_eq_lsub | Mathlib.SetTheory.Ordinal.Family | ∀ {ι : Type u_3} (f : ι → Ordinal.{max u_4 u_3}), iSup f = Ordinal.lsub f ∨ Order.succ (iSup f) = Ordinal.lsub f | null | true |
one_div_lt_of_neg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b : α},
a < 0 → b < 0 → (1 / a < b ↔ 1 / b < a) | null | true |
PUnit.instCompleteLinearOrder._proof_3 | Mathlib.Order.CompleteLattice.Lemmas | ∀ (a b c : PUnit.{u_1 + 1}), a \ b ≤ c ↔ a ≤ max b c | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.tacticC_simp | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | Lean.ParserDescr | null | true |
WithConv.toConv_ofConv | Mathlib.Algebra.WithConv | ∀ {A : Type u_2} (x : WithConv A), WithConv.toConv x.ofConv = x | null | true |
Finset.ite_prod_one | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : CommMonoid M] (p : Prop) [inst_1 : Decidable p] (s : Finset ι) (f : ι → M),
(if p then ∏ x ∈ s, f x else 1) = ∏ x ∈ s, if p then f x else 1 | null | true |
DifferentiableWithinAt.insert' | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E} {s : Set E} [T1Space E] {y : E},
DifferentiableWithi... | **Alias** of the reverse direction of `differentiableWithinAt_insert`. | true |
Metric.unitBall.instSemigroup._proof_3 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NonUnitalSeminormedRing 𝕜] (a b c : ↑(Metric.ball 0 1)), a * b * c = a * (b * c) | null | false |
SemidirectProduct.lift | Mathlib.GroupTheory.SemidirectProduct | {N : Type u_1} →
{G : Type u_2} →
{H : Type u_3} →
[inst : Group N] →
[inst_1 : Group G] →
[inst_2 : Group H] →
{φ : G →* MulAut N} →
(fn : N →* H) →
(fg : G →* H) →
(∀ (g : G),
fn.comp (MulEquiv.toMonoidHom ... | Define a group hom `N ⋊[φ] G →* H`, by defining maps `N →* H` and `G →* H` | true |
Lean.Meta.Grind.CasesEntry.casesOn | Lean.Meta.Tactic.Grind.Cases | {motive : Lean.Meta.Grind.CasesEntry → Sort u} →
(t : Lean.Meta.Grind.CasesEntry) →
((declName : Lean.Name) → (eager : Bool) → motive { declName := declName, eager := eager }) → motive t | null | false |
CategoryTheory.Limits.CategoricalPullback.mkIso._proof_5 | 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 y : CategoryTheory.Limits.CategoricalPullback F G} (eₗ :... | null | false |
Field.sepDegree | Mathlib.FieldTheory.SeparableClosure | (F : Type u) → (E : Type v) → [inst : Field F] → [inst_1 : Field E] → [Algebra F E] → Cardinal.{v} | The (infinite) separable degree for a general field extension `E / F` is defined
to be the degree of `separableClosure F E / F`. | true |
List.getLast_replicate_succ | Mathlib.Data.List.Basic | ∀ {α : Type u} (m : ℕ) (a : α), (List.replicate (m + 1) a).getLast ⋯ = a | null | true |
FiberBundleCore.localTriv_symm_apply | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (i : ι) (p : B × F),
↑(Z.localTriv i).symm p = ⟨p.1, Z.coordChange i (Z.indexAt p.1) p.1 p.2⟩ | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_insert_self._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 |
Finset.sum_range_tsub | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [inst_2 : Sub M] [OrderedSub M] [AddLeftMono M]
[AddLeftReflectLE M] [ExistsAddOfLE M] {f : ℕ → M},
Monotone f → ∀ (n : ℕ), ∑ i ∈ Finset.range n, (f (i + 1) - f i) = f n - f 0 | A telescoping sum along `{0, ..., n-1}` of an `ℕ`-valued function reduces to the difference of
the last and first terms when the function we are summing is monotone. | true |
HasProdUniformly.multipliableUniformly | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α}
[inst_1 : UniformSpace α], HasProdUniformly f g → MultipliableUniformly f | null | true |
Associates.instCommMonoid._proof_5 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : M), ⟦a * 1⟧ = ⟦a⟧ | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.isPath_iff_isSubwalk_imp_nil._proof_1_6 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} (i j : ℕ),
j < p.support.length → i < j → min j i < p.support.length | null | false |
Set.Finite.exists_finset | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α}, s.Finite → ∃ s', ∀ (a : α), a ∈ s' ↔ a ∈ s | null | true |
CategoryTheory.Over.monObjMkPullbackSnd_mul | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{X R S : C} {f : R ⟶ X} {g : S ⟶ X} [inst_2 : CategoryTheory.MonObj (CategoryTheory.Over.mk f)],
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal... | null | true |
CategoryTheory.isPreconnected_op | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.IsPreconnected J],
CategoryTheory.IsPreconnected Jᵒᵖ | If `J` is preconnected, then `Jᵒᵖ` is preconnected as well. | true |
Real.eq_one_of_pos_of_log_eq_zero | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ {x : ℝ}, 0 < x → Real.log x = 0 → x = 1 | null | true |
CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj._proof_1 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {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] [inst_2 : CategoryTheory.MonoidalCategory D]
(A : CategoryTheory.Functor C D) [inst_3 : CategoryTheory.ComonObj A] {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (A.map f) Categ... | null | false |
Module.Presentation.cokernel_relation | Mathlib.Algebra.Module.Presentation.Cokernel | ∀ {A : Type u} [inst : Ring A] {M₁ : Type v₁} {M₂ : Type v₂} [inst_1 : AddCommGroup M₁] [inst_2 : Module A M₁]
[inst_3 : AddCommGroup M₂] [inst_4 : Module A M₂] (pres₂ : Module.Presentation A M₂) {f : M₁ →ₗ[A] M₂} {ι : Type w₁}
{g₁ : ι → M₁} (data : pres₂.CokernelData f g₁) (hg₁ : Submodule.span A (Set.range g₁) = ... | null | true |
SubAddAction.SMulMemClass.subtype._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_3} {M : Type u_1} [inst : AddMonoid R] [inst_1 : AddAction R M] {A : Type u_2} [inst_2 : SetLike A M]
[hA : VAddMemClass A R M] (S' : A) (x : R) (x_1 : ↥S'), ↑(x +ᵥ x_1) = ↑(x +ᵥ x_1) | null | false |
Real.smoothTransition.one_of_one_le | Mathlib.Analysis.SpecialFunctions.SmoothTransition | ∀ {x : ℝ}, 1 ≤ x → x.smoothTransition = 1 | null | true |
CategoryTheory.Limits.biprod.add_eq_lift_id_desc | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C} (f g : X ⟶ Y)
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X X],
f + g =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.biprod.lift (CategoryTheory.CategoryStruct.id X) (CategoryTheo... | The existence of binary biproducts implies that there is at most one preadditive structure. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.triple_eq_triple_of_mem._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.toPrenex.match_1.eq_2 | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x : ℕ)
(t₁ t₂ : L.Term (α ⊕ Fin x)) (h_1 : (x : ℕ) → motive x FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.BoundedFormula.equal t₁ t₂))
(h_3 ... | null | true |
MeasureTheory.measure_lt_top_of_isCompact_of_isAddLeftInvariant' | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : AddGroup G] [IsTopologicalAddGroup G] [μ.IsAddLeftInvariant] {U : Set G},
(interior U).Nonempty → μ U ≠ ⊤ → ∀ {K : Set G}, IsCompact K → μ K < ⊤ | If a left-invariant measure gives finite mass to a set with nonempty interior, then it gives
finite mass to any compact set. | true |
_private.Mathlib.Analysis.Complex.Conformal.0.isConformalMap_complex_linear._simp_1_6 | Mathlib.Analysis.Complex.Conformal | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
Polynomial.trailingDegree_eq_zero._simp_1 | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.trailingDegree = 0) = (p.coeff 0 ≠ 0) | null | false |
isStablyFiniteRing_iff | Mathlib.Data.Matrix.Mul | ∀ (R : Type u_10) [inst : MulOne R] [inst_1 : AddCommMonoid R],
IsStablyFiniteRing R ↔ ∀ (n : ℕ), IsDedekindFiniteMonoid (Matrix (Fin n) (Fin n) R) | null | true |
CompareReals.instCommRingQ._proof_7 | Mathlib.Topology.UniformSpace.CompareReals | ∀ (a : CompareReals.Q), a + 0 = a | null | false |
groupCohomology.mapShortComplex₁_exact | Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {X : CategoryTheory.ShortComplex (Rep.{u, u, u} k G)}
(hX : X.ShortExact) {i j : ℕ} (hij : i + 1 = j), (groupCohomology.mapShortComplex₁ hX hij).Exact | Exactness of `Hⁱ(G, X₃) ⟶ Hʲ(G, X₁) ⟶ Hʲ(G, X₂)`. | true |
TopCat.isColimitCoconeOfForget | Mathlib.Topology.Category.TopCat.Limits.Basic | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
{F : CategoryTheory.Functor J TopCat} →
(c : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.forget TopCat))) →
CategoryTheory.Limits.IsColimit c → CategoryTheory.Limits.IsColimit (TopCat.coconeOfCoconeForget c) | Given a functor `F : J ⥤ TopCat` and a cocone `c : Cocone (F ⋙ forget)`
of the underlying cocone of types, the colimit of `F` is `c.pt` equipped
with the supremum of the coinduced topologies by the maps `c.ι.app j`. | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.let._regBuiltin.Lean.Parser.Term.let.parenthesizer_141 | Lean.Parser.Term | IO Unit | null | false |
_private.Mathlib.Combinatorics.Graph.Delete.0.Graph.deleteEdges_isLoopAt._simp_1_2 | Mathlib.Combinatorics.Graph.Delete | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
TopCommRingCat.forgetToTopCatCommRing | Mathlib.Topology.Category.TopCommRingCat | (R : TopCommRingCat) → CommRing ↑((CategoryTheory.forget₂ TopCommRingCat TopCat).obj R) | null | true |
_private.Mathlib.Topology.Compactness.CompactSystem.0.IsCompactSystem.insert_univ._proof_1_2 | Mathlib.Topology.Compactness.CompactSystem | ∀ {α : Type u_1} {S : Set (Set α)} (s : ℕ → Set α),
(∀ (i : ℕ), s i ∈ insert Set.univ S) →
∀ (h₀ : ∃ n, s n ∈ S) (x : α),
(∀ (i : ℕ), x ∈ s i) ↔ ∀ (i : ℕ), x ∈ (fun i => if s i ∈ S then s i else s (Nat.find h₀)) i | null | false |
SlashInvariantForm.coe_const | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [inst : Γ.HasDetOne] (x : ℂ),
⇑(SlashInvariantForm.const x) = Function.const UpperHalfPlane x | null | true |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.neg.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {c c_1 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr},
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.neg c = Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.neg c_1 → c = c_1 | null | true |
Std.Time.TimeZone.TZif.TZifV2.mk.noConfusion | Std.Time.Zoned.Database.TzIf | {P : Sort u} →
{toTZifV1 : Std.Time.TimeZone.TZif.TZifV1} →
{footer : Option String} →
{toTZifV1' : Std.Time.TimeZone.TZif.TZifV1} →
{footer' : Option String} →
{ toTZifV1 := toTZifV1, footer := footer } = { toTZifV1 := toTZifV1', footer := footer' } →
(toTZifV1 = toTZifV1' → f... | null | false |
_private.Std.Time.Time.PlainTime.0.Std.Time.instDecidableEqPlainTime.decEq.match_1 | Std.Time.Time.PlainTime | (motive : Std.Time.PlainTime → Std.Time.PlainTime → Sort u_1) →
(x x_1 : Std.Time.PlainTime) →
((a : Std.Time.Hour.Ordinal) →
(a_1 : Std.Time.Minute.Ordinal) →
(a_2 : Std.Time.Second.Ordinal true) →
(a_3 : Std.Time.Nanosecond.Ordinal) →
(b : Std.Time.Hour.Ordinal) →
... | null | false |
instBialgebraCarrierUnopCommAlgCatOfMonObjOpposite._proof_10 | Mathlib.Algebra.Category.CommBialgCat | ∀ {R : Type u_1} [inst : CommRing R] (A : (CommAlgCat R)ᵒᵖ) [inst_1 : CategoryTheory.MonObj A],
(Algebra.TensorProduct.map (CommAlgCat.Hom.hom CategoryTheory.MonObj.one.unop) (AlgHom.id R ↑(Opposite.unop A))).comp
(CommAlgCat.Hom.hom CategoryTheory.MonObj.mul.unop) =
↑(Algebra.TensorProduct.lid R ↑(Opposite... | null | false |
_private.Lean.Meta.Tactic.Grind.CollectParams.0.Lean.Meta.Grind.collectParams.match_1 | Lean.Meta.Tactic.Grind.CollectParams | (motive : Bool × Array Lean.Meta.Grind.TParam × Array Lean.Meta.Grind.TParam → Sort u_1) →
(x : Bool × Array Lean.Meta.Grind.TParam × Array Lean.Meta.Grind.TParam) →
((fst : Bool) → (params anchors : Array Lean.Meta.Grind.TParam) → motive (fst, params, anchors)) → motive x | null | false |
AddAction.zmultiplesQuotientStabilizerEquiv._proof_4 | Mathlib.Data.ZMod.QuotientGroup | ∀ {α : Type u_2} {β : Type u_1} [inst : AddGroup α] (a : α) [inst_1 : AddAction α β] (b : β),
AddSubgroup.zmultiples ↑(Function.minimalPeriod (fun x => a +ᵥ x) b) ≤
AddSubgroup.comap ((zmultiplesHom ↥(AddSubgroup.zmultiples a)) ⟨a, ⋯⟩)
(AddAction.stabilizer (↥(AddSubgroup.zmultiples a)) b) | null | false |
UInt32.toNat_toBitVec | Init.Data.UInt.Lemmas | ∀ (x : UInt32), x.toBitVec.toNat = x.toNat | null | true |
FormalMultilinearSeries.rightInv._proof_14 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E], ContinuousConstSMul 𝕜 E | null | false |
CategoryTheory.Functor.instLaxMonoidalActionMapAction._proof_2 | Mathlib.CategoryTheory.Action.Monoidal | ∀ {V : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} V] {G : Type u_2} [inst_1 : Monoid G] {W : Type u_3}
[inst_2 : CategoryTheory.Category.{u_1, u_3} W] [inst_3 : CategoryTheory.MonoidalCategory V]
[inst_4 : CategoryTheory.MonoidalCategory W] (F : CategoryTheory.Functor V W) [inst_5 : F.LaxMonoidal]
{X Y ... | null | false |
ValuationRing.mk._flat_ctor | Mathlib.RingTheory.Valuation.ValuationRing | ∀ {A : Type u} [inst : CommRing A] [inst_1 : IsDomain A], (∀ (a b : A), ∃ c, a * c = b ∨ b * c = a) → ValuationRing A | null | false |
Int32.toInt_toInt64 | Init.Data.SInt.Lemmas | ∀ (x : Int32), x.toInt64.toInt = x.toInt | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_insertRatUnits._proof_1_6 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddResult | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n)
(units : Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n))
(w : Fin (f.insertRatUnits units).1.ratUnits.size),
↑w + 1 ≤ (f.insertRatUnits units).1.ratUnits.size → ↑w < (f.insertRatUnits units).1.ratUnits.size | null | false |
Lean.Lsp.instOrdPosition | Lean.Data.Lsp.BasicAux | Ord Lean.Lsp.Position | null | true |
_private.Mathlib.Topology.Sheaves.EtaleSpace.0.TopCat.Presheaf.EtaleSpace.homeomorph._simp_10 | Mathlib.Topology.Sheaves.EtaleSpace | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : β → γ} {a : Filter α} {c : Filter γ},
Filter.Tendsto f a (Filter.comap g c) = Filter.Tendsto (g ∘ f) a c | null | false |
CategoryTheory.ObjectProperty.full_ιOfLE | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P P' : CategoryTheory.ObjectProperty C} (h : P ≤ P'),
(CategoryTheory.ObjectProperty.ιOfLE h).Full | null | true |
NonemptyFinLinOrd.dualEquiv._proof_3 | Mathlib.Order.Category.NonemptyFinLinOrd | ∀ (X : NonemptyFinLinOrd),
CategoryTheory.CategoryStruct.comp
(NonemptyFinLinOrd.dual.map
((CategoryTheory.NatIso.ofComponents (fun X => NonemptyFinLinOrd.Iso.mk (OrderIso.dualDual ↑X.toLinOrd))
@NonemptyFinLinOrd.dualEquiv._proof_1).hom.app
X))
((CategoryTheory.NatIso.of... | null | false |
Std.HashMap.getElem!_filter' | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [LawfulBEq α] [inst : Inhabited β]
{f : α → β → Bool} {k : α}, (Std.HashMap.filter f m)[k]! = (Option.filter (f k) m[k]?).get! | Simpler variant of `getElem!_filter` when `LawfulBEq` is available. | true |
MeasureTheory.condExpL2_comp_continuousLinearMap | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL2 | ∀ {α : Type u_1} {E' : Type u_3} (𝕜 : Type u_7) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E']
[inst_2 : InnerProductSpace 𝕜 E'] [inst_3 : CompleteSpace E'] [inst_4 : NormedSpace ℝ E'] {m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {E'' : Type u_8} (𝕜' : Type u_9) [inst_5 : RCLike 𝕜'] [inst_6 : N... | null | true |
Lean.Server.RequestCancellation.ctorIdx | Lean.Server.RequestCancellation | Lean.Server.RequestCancellation → ℕ | null | false |
Int.one_ne_zero | Init.Data.Int.Order | 1 ≠ 0 | null | true |
IO.Error.instToString | Init.System.IOError | ToString IO.Error | null | true |
CategoryTheory.Bicategory.Adjunction.isAbsoluteLeftKan._proof_1 | Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {u : b ⟶ a}
(adj : CategoryTheory.Bicategory.Adjunction f u) {x : B} (h : a ⟶ x)
(s :
CategoryTheory.Bicategory.LeftExtension f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) h)),
CategoryTheory.Categor... | null | false |
DerivedCategory.singleFunctorsPostcompQIso | Mathlib.Algebra.Homology.DerivedCategory.Basic | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : HasDerivedCategory C] →
DerivedCategory.singleFunctors C ≅ (CochainComplex.singleFunctors C).postcomp DerivedCategory.Q | The isomorphism
`DerivedCategory.singleFunctors C ≅ (CochainComplex.singleFunctors C).postcomp Q`. | true |
CategoryTheory.MorphismProperty.ofHoms_iff | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_3} {X Y : ι → C} (f : (i : ι) → X i ⟶ Y i)
{A B : C} (g : A ⟶ B),
CategoryTheory.MorphismProperty.ofHoms f g ↔ ∃ i, CategoryTheory.Arrow.mk g = CategoryTheory.Arrow.mk (f i) | null | true |
MonoidWithZeroHom.snd.eq_1 | Mathlib.Algebra.GroupWithZero.ProdHom | ∀ (G₀ : Type u_1) (H₀ : Type u_2) [inst : GroupWithZero G₀] [inst_1 : GroupWithZero H₀],
MonoidWithZeroHom.snd G₀ H₀ = WithZero.lift' ((Units.coeHom H₀).comp (MonoidHom.snd G₀ˣ H₀ˣ)) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.rpow_zero._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ⊤ = none | null | false |
Std.DHashMap.Equiv.casesOn | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} →
{x : BEq α} →
{x_1 : Hashable α} →
{m₁ m₂ : Std.DHashMap α β} →
{motive : m₁.Equiv m₂ → Sort u_1} →
(t : m₁.Equiv m₂) → ((inner : m₁.inner.Equiv m₂.inner) → motive ⋯) → motive t | null | false |
_private.Aesop.Search.ExpandSafePrefix.0.Aesop.isSafeExpansionFailedException.match_1 | Aesop.Search.ExpandSafePrefix | (motive : Lean.Exception → Sort u_1) →
(x : Lean.Exception) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) →
((x : Lean.Exception) → motive x) → motive x | null | false |
Fin.attachFin_Ioo | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (a b : Fin n), (Finset.Ioo ↑a ↑b).attachFin ⋯ = Finset.Ioo a b | null | true |
Submodule.LinearDisjoint.one_left | Mathlib.LinearAlgebra.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (N : Submodule R S),
Submodule.LinearDisjoint 1 N | The image of `R` in `S` is linearly disjoint with any other submodules. | true |
Units.instMul | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : Monoid α] → Mul αˣ | Units of a monoid have an induced multiplication. | true |
CategoryTheory.MorphismProperty.instIsStableUnderBaseChangeTop | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C], ⊤.IsStableUnderBaseChange | null | true |
LinearMap.toSpanSingleton | Mathlib.LinearAlgebra.Span.Basic | (R : Type u_1) →
(M : Type u_4) → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → M → R →ₗ[R] M | Given an element `x` of a module `M` over `R`, the natural map from
`R` to scalar multiples of `x`. See also `LinearMap.ringLmapEquivSelf`. | true |
AlgebraNorm.ctorIdx | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | {R : Type u_1} →
{inst : SeminormedCommRing R} → {S : Type u_2} → {inst_1 : Ring S} → {inst_2 : Algebra R S} → AlgebraNorm R S → ℕ | null | false |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities.weight_add_weight_pairMap | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ (σ : Type u_1) (R : Type u_2) [inst : CommRing R] [inst_1 : DecidableEq σ] [inst_2 : Fintype σ] {k : ℕ},
∀ t ∈ MvPolynomial.NewtonIdentities.pairs✝ σ k,
MvPolynomial.NewtonIdentities.weight✝ σ R k t +
MvPolynomial.NewtonIdentities.weight✝ σ R k (MvPolynomial.NewtonIdentities.pairMap✝ σ t) =
0 | null | true |
CategoryTheory.MorphismProperty.LeftFraction₃.mk.inj | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {W : CategoryTheory.MorphismProperty C} {X Y Y' : C}
{f f' f'' : X ⟶ Y'} {s : Y ⟶ Y'} {hs : W s} {Y'_1 : C} {f_1 f'_1 f''_1 : X ⟶ Y'_1} {s_1 : Y ⟶ Y'_1} {hs_1 : W s_1},
{ Y' := Y', f := f, f' := f', f'' := f'', s := s, hs := hs } =
{ Y' := Y'_1, f... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.