name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Parser.Tactic.appendConfig | Init.Meta.Defs | Lean.Syntax → Lean.Syntax → Lean.TSyntax `Lean.Parser.Tactic.optConfig |
RightCancelSemigroup.toSemigroup | Mathlib.Algebra.Group.Defs | {G : Type u} → [self : RightCancelSemigroup G] → Semigroup G |
Subfield.extendScalars_self | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {L : Type u_2} [inst : Field L] (F : Subfield L), Subfield.extendScalars ⋯ = ⊥ |
MeasureTheory.diracProbaEquiv.congr_simp | Mathlib.MeasureTheory.Measure.DiracProba | ∀ {X : Type u_1} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : OpensMeasurableSpace X]
[inst_3 : T0Space X], MeasureTheory.diracProbaEquiv = MeasureTheory.diracProbaEquiv |
HomologicalComplex.HomologySequence.snakeInput._proof_33 | Mathlib.Algebra.Homology.HomologySequence | 2 < 3 + 1 |
Mathlib.Deriving.Fintype.«_aux_Mathlib_Tactic_DeriveFintype___macroRules_Mathlib_Deriving_Fintype_termDerive_fintype%__1» | Mathlib.Tactic.DeriveFintype | Lean.Macro |
_private.Lean.Elab.DocString.0.Lean.Doc.InternalState.mk.injEq | Lean.Elab.DocString | ∀ (footnotes : Std.HashMap String (Lean.Doc.Ref✝ (Lean.Doc.Inline Lean.ElabInline)))
(urls : Std.HashMap String (Lean.Doc.Ref✝¹ String))
(footnotes_1 : Std.HashMap String (Lean.Doc.Ref✝² (Lean.Doc.Inline Lean.ElabInline)))
(urls_1 : Std.HashMap String (Lean.Doc.Ref✝³ String)),
({ footnotes := footnotes, urls := urls } = { footnotes := footnotes_1, urls := urls_1 }) =
(footnotes = footnotes_1 ∧ urls = urls_1) |
CategoryTheory.Limits.ReflectsLimitsOfSize | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop |
Matroid.Indep.exists_insert_of_not_maximal | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} (M : Matroid α) ⦃I B : Set α⦄,
M.Indep I → ¬Maximal M.Indep I → Maximal M.Indep B → ∃ x ∈ B \ I, M.Indep (insert x I) |
LieModule.iSupIndep_genWeightSpace | Mathlib.Algebra.Lie.Weights.Basic | ∀ (R : Type u_2) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [IsDomain R] [Module.IsTorsionFree R M],
iSupIndep fun χ => LieModule.genWeightSpace M χ |
Submodule.comapSubtypeEquivOfLe._proof_3 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} (x : ↥(Submodule.comap q.subtype p)), ↑x ∈ Submodule.comap q.subtype p |
Aesop.TreeM.Context.mk.noConfusion | Aesop.Tree.TreeM | {P : Sort u} →
{currentIteration : Aesop.Iteration} →
{ruleSet : Aesop.LocalRuleSet} →
{currentIteration' : Aesop.Iteration} →
{ruleSet' : Aesop.LocalRuleSet} →
{ currentIteration := currentIteration, ruleSet := ruleSet } =
{ currentIteration := currentIteration', ruleSet := ruleSet' } →
(currentIteration = currentIteration' → ruleSet = ruleSet' → P) → P |
_private.Mathlib.NumberTheory.ModularForms.QExpansion.0.ModularFormClass.qExpansion_coeff_eq_intervalIntegral._simp_1_1 | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} (f : ℝ → E) (c : ℝ),
∫ (x : ℝ) in a * c..b * c, f x = c • ∫ (x : ℝ) in a..b, f (x * c) |
CategoryTheory.ShortComplex.LeftHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork._proof_3 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0) (c : CategoryTheory.Limits.CokernelCofork S.f)
(hc : CategoryTheory.Limits.IsColimit c),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.LeftHomologyData.ofZeros S hf hg).f'
(CategoryTheory.CategoryStruct.id (CategoryTheory.ShortComplex.LeftHomologyData.ofZeros S hf hg).K) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id S).τ₁
(CategoryTheory.ShortComplex.LeftHomologyData.ofIsColimitCokernelCofork S hg c hc).f' |
Std.IterM.DefaultConsumers.forIn'_eq_forIn'._unary | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {m : Type w → Type w'} {α β : Type w} [inst : Std.Iterator α m β] {n : Type x → Type x'} [inst_1 : Monad n]
[LawfulMonad n] {lift : (γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ} {γ : Type x} {P Q : β → Prop}
(Pl : β → γ → ForInStep γ → Prop) {f : (b : β) → P b → (c : γ) → n (Subtype (Pl b c))}
{g : (b : β) → Q b → (c : γ) → n (Subtype (Pl b c))},
Std.IteratorLoop.WellFounded α m Pl →
(∀ (b : β) (c : γ) (hPb : P b) (hQb : Q b), f b hPb c = g b hQb c) →
∀
(_x :
(it : Std.IterM m β) ×'
(_ : γ) ×'
(_ : ∀ (b : β), it.IsPlausibleIndirectOutput b → P b) ×' ∀ (b : β), it.IsPlausibleIndirectOutput b → Q b),
Std.IterM.DefaultConsumers.forIn' lift γ Pl _x.1 _x.2.1 P ⋯ f =
Std.IterM.DefaultConsumers.forIn' lift γ Pl _x.1 _x.2.1 Q ⋯ g |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IicProdIoc_preimage._simp_1_2 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (α i)} {f : (i : ι) → α i},
(f ∈ s.pi t) = ∀ i ∈ s, f i ∈ t i |
FormalMultilinearSeries.applyComposition_ones | Mathlib.Analysis.Analytic.Composition | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : CommRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : AddCommGroup F]
[inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] [inst_5 : TopologicalSpace E] [inst_6 : TopologicalSpace F]
[inst_7 : IsTopologicalAddGroup E] [inst_8 : ContinuousConstSMul 𝕜 E] [inst_9 : IsTopologicalAddGroup F]
[inst_10 : ContinuousConstSMul 𝕜 F] (p : FormalMultilinearSeries 𝕜 E F) (n : ℕ),
p.applyComposition (Composition.ones n) = fun v i => (p 1) fun x => v (Fin.castLE ⋯ i) |
_private.Mathlib.Analysis.Convex.Integral.0.Convex.integral_mem._simp_1_3 | Mathlib.Analysis.Convex.Integral | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {f : MeasureTheory.SimpleFunc α β} {b : β},
(b ∈ f.range) = (b ∈ Set.range ⇑f) |
CategoryTheory.Bicategory.LeftLift.whiskering | Mathlib.CategoryTheory.Bicategory.Extension | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
{f : b ⟶ a} →
{g : c ⟶ a} →
{x : B} →
(h : x ⟶ c) →
CategoryTheory.Functor (CategoryTheory.Bicategory.LeftLift f g)
(CategoryTheory.Bicategory.LeftLift f (CategoryTheory.CategoryStruct.comp h g)) |
Lean.Elab.Tactic.liftMetaTacticAux | Lean.Elab.Tactic.Basic | {α : Type} → (Lean.MVarId → Lean.MetaM (α × List Lean.MVarId)) → Lean.Elab.Tactic.TacticM α |
Bool.recOn._@.Mathlib.Util.CompileInductive.3618634379._hygCtx._hyg.5 | Mathlib.Util.CompileInductive | {motive : Bool → Sort u} → (t : Bool) → motive false → motive true → motive t |
Topology.IsInducing.isOpenMap | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
Topology.IsInducing f → IsOpen (Set.range f) → IsOpenMap f |
CategoryTheory.CartesianMonoidalCategory.whiskerRight_toUnit_comp_leftUnitor_hom_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] (X Y : C)
{Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.SemiCartesianMonoidalCategory.toUnit X) Y)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.leftUnitor Y).hom h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.SemiCartesianMonoidalCategory.snd X Y) h |
CategoryTheory.Limits.ker._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasKernels C] {X Y Z : CategoryTheory.Arrow C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Limits.kernel.lift Z.hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι X.hom)
(CategoryTheory.CategoryStruct.comp f g).left)
⋯ =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.kernel.lift Y.hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι X.hom) f.left) ⋯)
(CategoryTheory.Limits.kernel.lift Z.hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι Y.hom) g.left) ⋯) |
MeasureTheory.Measure.ext_of_generateFrom_of_iUnion | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (C : Set (Set α)) (B : ℕ → Set α),
m0 = MeasurableSpace.generateFrom C →
IsPiSystem C → ⋃ i, B i = Set.univ → (∀ (i : ℕ), B i ∈ C) → (∀ (i : ℕ), μ (B i) ≠ ⊤) → (∀ s ∈ C, μ s = ν s) → μ = ν |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.fac_app | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) {f : CategoryTheory.Arrow C},
CategoryTheory.CategoryStruct.comp (data.i.app f) (data.p.app f) = f.hom |
Submonoid.unitsTypeEquivIsUnitSubmonoid._proof_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : Monoid M] (x : ↥(IsUnit.submonoid M)), (fun x => ⟨↑x, ⋯⟩) ((fun x => IsUnit.unit ⋯) x) = x |
TrivSqZeroExt.kerIdeal._proof_2 | Mathlib.Algebra.TrivSqZeroExt.Ideal | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
IsScalarTower R R M |
Std.HashSet.erase_emptyWithCapacity | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {a : α} {c : ℕ},
(Std.HashSet.emptyWithCapacity c).erase a = Std.HashSet.emptyWithCapacity c |
Set.vadd_set_univ_pi | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {M : Type u_5} {ι : Type u_6} {π : ι → Type u_7} [inst : (i : ι) → VAdd M (π i)] (c : M) (s : (i : ι) → Set (π i)),
c +ᵥ Set.univ.pi s = Set.univ.pi (c +ᵥ s) |
HomologicalComplex.cyclesFunctor_map | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} (c : ComplexShape ι) (i : ι) [inst_2 : CategoryTheory.CategoryWithHomology C]
{X Y : HomologicalComplex C c} (f : X ⟶ Y),
(HomologicalComplex.cyclesFunctor C c i).map f = HomologicalComplex.cyclesMap f i |
Nat.Partrec.Code.zero.elim | Mathlib.Computability.PartrecCode | {motive : Nat.Partrec.Code → Sort u} → (t : Nat.Partrec.Code) → t.ctorIdx = 0 → motive Nat.Partrec.Code.zero → motive t |
AlgebraicTopology.NormalizedMooreComplex.objD._proof_1 | Mathlib.AlgebraicTopology.MooreComplex | ∀ (n : ℕ) (i : Fin (n + 1)), i.succ ∈ Finset.univ |
ComplexShape.Embedding.not_boundaryGE_next' | Mathlib.Algebra.Homology.Embedding.Boundary | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} (e : c.Embedding c') [e.IsRelIff]
{j k : ι}, ¬e.BoundaryGE j → c.next j = k → ¬e.BoundaryGE k |
_private.Batteries.Data.MLList.Basic.0.MLList.Spec.noConfusion | Batteries.Data.MLList.Basic | {P : Sort u_1} →
{m : Type u → Type u} →
{t : MLList.Spec✝ m} →
{m' : Type u → Type u} → {t' : MLList.Spec✝¹ m'} → m = m' → t ≍ t' → MLList.Spec.noConfusionType✝ P t t' |
Rat.cast_min | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] (p q : ℚ), ↑(min p q) = min ↑p ↑q |
Mathlib.Meta.FunProp.Config.mk | Mathlib.Tactic.FunProp.Types | ℕ → ℕ → Mathlib.Meta.FunProp.Config |
ZMod.val_le | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} [NeZero n] (a : ZMod n), a.val ≤ n |
_private.Lean.Data.KVMap.0.Lean.KVMap.insert.match_1 | Lean.Data.KVMap | (motive : Lean.KVMap → Lean.Name → Lean.DataValue → Sort u_1) →
(x : Lean.KVMap) →
(x_1 : Lean.Name) →
(x_2 : Lean.DataValue) →
((m : List (Lean.Name × Lean.DataValue)) →
(k : Lean.Name) → (v : Lean.DataValue) → motive { entries := m } k v) →
motive x x_1 x_2 |
HomologicalComplex.truncLE'ToRestriction_naturality | Mathlib.Algebra.Homology.Embedding.TruncLE | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K L : HomologicalComplex C c'} (φ : K ⟶ L) (e : c.Embedding c') [inst_2 : e.IsTruncLE]
[inst_3 : ∀ (i' : ι'), K.HasHomology i'] [inst_4 : ∀ (i' : ι'), L.HasHomology i'],
CategoryTheory.CategoryStruct.comp (HomologicalComplex.truncLE'Map φ e) (L.truncLE'ToRestriction e) =
CategoryTheory.CategoryStruct.comp (K.truncLE'ToRestriction e) (HomologicalComplex.restrictionMap φ e) |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_val_Iio._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) |
_private.Mathlib.RingTheory.Extension.Presentation.Submersive.0.Algebra.PreSubmersivePresentation.jacobian_reindex._simp_1_4 | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {A : Type v} {B : Type w} {C : Type u₁} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Semiring C] [inst_4 : Algebra R A] [inst_5 : Algebra R B] [inst_6 : Algebra R C]
(φ₁ : B →ₐ[R] C) (φ₂ : A →ₐ[R] B), ⇑φ₁ ∘ ⇑φ₂ = ⇑(φ₁.comp φ₂) |
Lean.AttributeImpl.applicationTime._inherited_default | Lean.Attributes | Lean.AttributeApplicationTime |
ProbabilityTheory.setBernoulli._proof_1 | Mathlib.Probability.Distributions.SetBernoulli | IsScalarTower NNReal ENNReal ENNReal |
instCoeSortProfiniteGrpType | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | CoeSort ProfiniteGrp.{u} (Type u) |
Topology.IsQuotientMap.trivializationOfSMulDisjoint._proof_9 | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_2} {G : Type u_1} [inst : Group G] [inst_1 : MulAction G E] (U : Set E),
(∀ (g : G), ((fun x => g • x) '' U ∩ U).Nonempty → g = 1) →
∀ {g₁ g₂ : G}, g₁ ≠ g₂ → Disjoint ((fun x => g₁ • x) ⁻¹' U) ((fun x => g₂ • x) ⁻¹' U) |
Order.krullDim_int | Mathlib.Order.KrullDimension | Order.krullDim ℤ = ⊤ |
MvPolynomial.support_rename_killCompl_subset | Mathlib.Algebra.MvPolynomial.Rename | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] {p : MvPolynomial τ R} {f : σ → τ}
(hf : Function.Injective f), ((MvPolynomial.rename f) ((MvPolynomial.killCompl hf) p)).support ⊆ p.support |
MeasureTheory.Measure.rnDeriv_withDensity_withDensity_rnDeriv_left | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_1} {m : MeasurableSpace α} {f : α → ENNReal} (μ ν : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ]
[MeasureTheory.SigmaFinite ν],
(∀ᵐ (x : α) ∂μ, f x ≠ ⊤) → ((ν.withDensity (μ.rnDeriv ν)).withDensity f).rnDeriv ν =ᵐ[ν] (μ.withDensity f).rnDeriv ν |
AdicCompletion.instCommRingAdicCauchySequence | Mathlib.RingTheory.AdicCompletion.Algebra | {R : Type u_1} → [inst : CommRing R] → (I : Ideal R) → CommRing (AdicCompletion.AdicCauchySequence I R) |
CochainComplex.homOfDegreewiseSplit | 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) →
(S.X₃ ⟶ (CategoryTheory.shiftFunctor (CochainComplex C ℤ) 1).obj S.X₁) |
_private.Mathlib.Tactic.NormNum.ModEq.0.Mathlib.Meta.NormNum.evalNatModEq.match_1 | Mathlib.Tactic.NormNum.ModEq | (αP : Q(Type)) →
(e : Q(«$αP»)) →
(motive : (b : Bool) × Mathlib.Meta.NormNum.BoolResult e b → Sort u_1) →
(__discr : (b : Bool) × Mathlib.Meta.NormNum.BoolResult e b) →
((b : Bool) → (pb : Mathlib.Meta.NormNum.BoolResult e b) → motive ⟨b, pb⟩) → motive __discr |
upperSemicontinuous_biInf | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {ι : Sort u_4} {δ : Type u_5} [inst_1 : CompleteLinearOrder δ]
{p : ι → Prop} {f : (i : ι) → p i → α → δ},
(∀ (i : ι) (hi : p i), UpperSemicontinuous (f i hi)) → UpperSemicontinuous fun x' => ⨅ i, ⨅ (hi : p i), f i hi x' |
_private.Std.Time.Time.HourMarker.0.Std.Time.HourMarker.toAbsolute._proof_1 | Std.Time.Time.HourMarker | 12 ≤ 23 |
Equiv.Perm.one_lt_of_mem_cycleType | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {σ : Equiv.Perm α} {n : ℕ}, n ∈ σ.cycleType → 1 < n |
Nat.two_pow_pred_mul_two | Init.Data.Nat.Lemmas | ∀ {w : ℕ}, 0 < w → 2 ^ (w - 1) * 2 = 2 ^ w |
Lean.Meta.Config.ctxApprox._default | Lean.Meta.Basic | Bool |
_private.Mathlib.Algebra.Group.Defs.0.npowBinRec.go_spec._proof_1_6 | Mathlib.Algebra.Group.Defs | ∀ (k' : ℕ), k' ≠ 0 → ¬2 * k' = 0 |
AddGroupNormClass.toAddGroupSeminormClass | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} {inst : AddGroup α} {inst_1 : AddCommMonoid β}
{inst_2 : PartialOrder β} {inst_3 : FunLike F α β} [self : AddGroupNormClass F α β], AddGroupSeminormClass F α β |
_private.Mathlib.Analysis.Convex.Deriv.0.bddBelow_slope_lt_of_mem_interior.match_1_1 | Mathlib.Analysis.Convex.Deriv | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] {s : Set 𝕜} {f : 𝕜 → 𝕜} {x : 𝕜} (y' : 𝕜)
(motive : y' ∈ slope f x '' {y | y ∈ s ∧ x < y} → Prop) (x_1 : y' ∈ slope f x '' {y | y ∈ s ∧ x < y}),
(∀ (z : 𝕜) (hz : z ∈ {y | y ∈ s ∧ x < y}) (hz' : slope f x z = y'), motive ⋯) → motive x_1 |
NonUnitalSubring.instSetLike | Mathlib.RingTheory.NonUnitalSubring.Defs | {R : Type u} → [inst : NonUnitalNonAssocRing R] → SetLike (NonUnitalSubring R) R |
Filter.Germ.instDivisionRing._proof_6 | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u_2} {β : Type u_1} {φ : Ultrafilter α} [DivisionRing β], Nontrivial ((↑φ).Germ β) |
LinearMap.shortComplexKer._proof_1 | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u_2} [inst : Ring R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_1}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N),
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom f.ker.subtype) (ModuleCat.ofHom f) = 0 |
MulOpposite.instSemifield._proof_2 | Mathlib.Algebra.Field.Opposite | ∀ {α : Type u_1} [inst : Semifield α] (a : αᵐᵒᵖ), DivisionSemiring.zpow 0 a = 1 |
StarMulEquiv.coe_trans | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : Mul A] [inst_1 : Mul B] [inst_2 : Mul C] [inst_3 : Star A]
[inst_4 : Star B] [inst_5 : Star C] (e₁ : A ≃⋆* B) (e₂ : B ≃⋆* C), ⇑(e₁.trans e₂) = ⇑e₂ ∘ ⇑e₁ |
AlgebraicClosure.instGroupWithZero._proof_8 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k] (a b : MvPolynomial (AlgebraicClosure.Vars k) k ⧸ AlgebraicClosure.maxIdeal k),
a / b = a * b⁻¹ |
TensorProduct.quotientTensorQuotientEquiv._proof_9 | Mathlib.LinearAlgebra.TensorProduct.Quotient | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N], IsScalarTower R R (TensorProduct R M N) |
CategoryTheory.Functor.whiskeringLeft₃ObjObjMap_app | Mathlib.CategoryTheory.Whiskering | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {D₁ : Type u_4} {D₂ : Type u_5} {D₃ : 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_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} D₁]
[inst_4 : CategoryTheory.Category.{v_5, u_5} D₂] [inst_5 : CategoryTheory.Category.{v_6, u_6} D₃] (E : Type u_7)
[inst_6 : CategoryTheory.Category.{v_7, u_7} E] (F₁ : CategoryTheory.Functor C₁ D₁)
(F₂ : CategoryTheory.Functor C₂ D₂) {F₃ F₃' : CategoryTheory.Functor C₃ D₃} (τ₃ : F₃ ⟶ F₃')
(F : CategoryTheory.Functor D₁ (CategoryTheory.Functor D₂ (CategoryTheory.Functor D₃ E))),
(CategoryTheory.Functor.whiskeringLeft₃ObjObjMap E F₁ F₂ τ₃).app F =
F₁.whiskerLeft (F.whiskerLeft (((CategoryTheory.Functor.whiskeringLeft₂ E).obj F₂).map τ₃)) |
PolynomialLaw.instZero._proof_2 | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {S : Type u_1} [inst_5 : CommSemiring S] [inst_6 : Algebra R S]
{S' : Type u_1} [inst_7 : CommSemiring S'] [inst_8 : Algebra R S'] (φ : S →ₐ[R] S'),
⇑(LinearMap.rTensor N φ.toLinearMap) ∘ 0 = 0 ∘ ⇑(LinearMap.rTensor M φ.toLinearMap) |
FirstOrder.Language.isFraisse_finite_linear_order | Mathlib.ModelTheory.Order | FirstOrder.Language.IsFraisse {M | Finite ↑M ∧ ↑M ⊨ FirstOrder.Language.order.linearOrderTheory} |
CategoryTheory.Cat.freeMapIdIso | Mathlib.CategoryTheory.Category.Quiv | (V : Type u_1) →
[inst : Quiver V] → CategoryTheory.Cat.freeMap (𝟭q V) ≅ CategoryTheory.Functor.id (CategoryTheory.Paths V) |
ULift.addGroup._proof_4 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : AddGroup α] (x x_1 : ULift.{u_1, u_2} α), Equiv.ulift (x - x_1) = Equiv.ulift (x - x_1) |
CategoryTheory.Limits.Types.colimitCocone | Mathlib.CategoryTheory.Limits.Types.Colimits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J (Type u)) → [Small.{u, max u v} F.ColimitType] → CategoryTheory.Limits.Cocone F |
Nat.recOnPrimePow._proof_2 | Mathlib.Data.Nat.Factorization.Induction | ∀ (k : ℕ), Nat.Prime (k + 2).minFac |
Lean.Meta.instInhabitedCaseArraySizesSubgoal.default | Lean.Meta.Match.CaseArraySizes | Lean.Meta.CaseArraySizesSubgoal |
CategoryTheory.Limits.SequentialProduct.functorObj_eq_neg | Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct | ∀ {C : Type u_1} {M N : ℕ → C} {n m : ℕ}, ¬m < n → (fun i => if x : i < n then M i else N i) m = N m |
AddAction.vadd_mem_fixedBy_iff_mem_fixedBy | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {a : α} {g : G},
g +ᵥ a ∈ AddAction.fixedBy α g ↔ a ∈ AddAction.fixedBy α g |
Lean.Parser.Term.binrel._regBuiltin.Lean.Parser.Term.binrel_1 | Lean.Parser.Term | IO Unit |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.LFunction_apply_zero_of_even._simp_1_2 | Mathlib.NumberTheory.LSeries.ZMod | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True |
_private.Plausible.Gen.0.Plausible.Gen.runUntil.repeatGen.match_1 | Plausible.Gen | (motive : Option ℕ → Sort u_1) →
(attempts : Option ℕ) → (Unit → motive (some 0)) → ((x : Option ℕ) → motive x) → motive attempts |
LieModule.Weight.mk | Mathlib.Algebra.Lie.Weights.Basic | {R : Type u_2} →
{L : Type u_3} →
{M : Type u_4} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : LieRingModule L M] →
[inst_6 : LieModule R L M] →
[inst_7 : LieRing.IsNilpotent L] →
(toFun : L → R) → LieModule.genWeightSpace M toFun ≠ ⊥ → LieModule.Weight R L M |
MeasureTheory.FiniteMeasure.restrict_apply | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ : MeasureTheory.FiniteMeasure Ω) (A : Set Ω) {s : Set Ω},
MeasurableSet s → (μ.restrict A) s = μ (s ∩ A) |
Rep.FiniteCyclicGroup.groupCohomologyIsoEven._proof_4 | Mathlib.RepresentationTheory.Homological.GroupCohomology.FiniteCyclic | ∀ (i : ℕ) [h₀ : NeZero i], Even i → (ComplexShape.up ℕ).Rel ((ComplexShape.up ℕ).prev i) i |
_private.Mathlib.CategoryTheory.Limits.Shapes.Countable.0.CategoryTheory.Limits.IsFiltered.sequentialFunctor_final._simp_3 | Mathlib.CategoryTheory.Limits.Shapes.Countable | ∀ {α : Type u} {R : α → α → Prop} (a : α), List.IsChain R [a] = True |
NumberField.mixedEmbedding.negAt_apply_isComplex | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] {s : Set { w // w.IsReal }} (x : NumberField.mixedEmbedding.mixedSpace K)
(w : { w // w.IsComplex }), ((NumberField.mixedEmbedding.negAt s) x).2 w = x.2 w |
_private.Mathlib.NumberTheory.ArithmeticFunction.Misc.0.ArithmeticFunction.sum_Ioc_sigma0_eq_sum_div._proof_1_1 | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ (N x : ℕ), x ∈ Finset.Ioc 0 N → N / x = if x = 0 then 0 else N / x |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Goal.getEqc.go._unsafe_rec | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Goal → Lean.Expr → Lean.Expr → Array Lean.Expr → Array Lean.Expr |
LocalSubring.instPartialOrder._proof_2 | Mathlib.RingTheory.LocalRing.LocalSubring | ∀ {R : Type u_1} [inst : CommRing R] (a : LocalSubring R),
∃ (h : a.toSubring ≤ a.toSubring), IsLocalHom (Subring.inclusion h) |
Lean.Compiler.LCNF.MonadFVarSubstState.recOn | Lean.Compiler.LCNF.CompilerM | {m : Type → Type} →
{pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.MonadFVarSubstState m pu → Sort u} →
(t : Lean.Compiler.LCNF.MonadFVarSubstState m pu) →
((modifySubst : (Lean.Compiler.LCNF.FVarSubst pu → Lean.Compiler.LCNF.FVarSubst pu) → m Unit) →
motive { modifySubst := modifySubst }) →
motive t |
PadicComplex.instRankOneNNRealV._proof_6 | Mathlib.NumberTheory.Padics.Complex | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], CompletableTopField (PadicAlgCl p) |
_private.Mathlib.Data.Finset.Image.0.Finset.coe_map_subset_range._proof_1_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_2} {β : Type u_1} (f : α ↪ β) (s : Finset α), ↑(Finset.map f s) ⊆ Set.range ⇑f |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform.0.EisensteinSeries.G2_slash_action._simp_1_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Transform | ∀ {α : Type u} {a b : α}, (a ∈ {b}) = (a = b) |
List.Vector.ofFn | Mathlib.Data.Vector.Defs | {α : Type u_1} → {n : ℕ} → (Fin n → α) → List.Vector α n |
_private.Mathlib.SetTheory.Cardinal.Pigeonhole.0.Cardinal.le_range_of_union_finset_eq_univ._simp_1_1 | Mathlib.SetTheory.Cardinal.Pigeonhole | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) |
Localization.mkHom_surjective | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M}, Function.Surjective ⇑Localization.mkHom |
MonoidHom.toAdditive._proof_5 | Mathlib.Algebra.Group.TypeTags.Hom | ∀ {α : Type u_2} {β : Type u_1} [inst : MulOneClass α] [inst_1 : MulOneClass β] (f : Additive α →+ Additive β), f 0 = 0 |
AddGroupSeminormClass.toSeminormedAddGroup.congr_simp | Mathlib.Analysis.Normed.Order.Hom.Ultra | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α ℝ] [inst_1 : AddGroup α] [inst_2 : AddGroupSeminormClass F α ℝ]
(f f_1 : F), f = f_1 → AddGroupSeminormClass.toSeminormedAddGroup f = AddGroupSeminormClass.toSeminormedAddGroup f_1 |
_private.Mathlib.NumberTheory.LSeries.HurwitzZetaOdd.0.HurwitzZeta.hasSum_int_completedSinZeta._simp_1_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : ℤ}, |↑a| = ↑|a| |
instFinitePresentation | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} [inst : Ring R], Module.FinitePresentation R R |
Lean.Meta.Simp.Arith.Int.ToLinear.State.noConfusion | Lean.Meta.Tactic.Simp.Arith.Int.Basic | {P : Sort u} →
{t t' : Lean.Meta.Simp.Arith.Int.ToLinear.State} →
t = t' → Lean.Meta.Simp.Arith.Int.ToLinear.State.noConfusionType P t t' |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.