name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Equalizer.Sieve.SecondObj.ext | Mathlib.CategoryTheory.Sites.EqualizerSheafCondition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.Functor Cᵒᵖ (Type (max v u))} {X : C}
{S : CategoryTheory.Sieve X} (z₁ z₂ : CategoryTheory.Equalizer.Sieve.SecondObj P S),
(∀ (Y Z : C) (g : Z ⟶ Y) (f : Y ⟶ X) (hf : S.arrows f),
CategoryTheory.Limits.Pi.π (fun f => P.obj (Opposite.op f.snd.fst)) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₁ =
CategoryTheory.Limits.Pi.π (fun f => P.obj (Opposite.op f.snd.fst)) ⟨Y, ⟨Z, ⟨g, ⟨f, hf⟩⟩⟩⟩ z₂) →
z₁ = z₂ |
_private.Mathlib.RingTheory.MvPowerSeries.Order.0.MvPowerSeries.coeff_mul_prod_one_sub_of_lt_weightedOrder._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) |
NumberField.Units.instFintypeSubtypeUnitsRingOfIntegersMemSubgroupTorsion._proof_1 | Mathlib.NumberTheory.NumberField.Units.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], Finite ↑↑(NumberField.Units.torsion K) |
ZFSet.instReflSubset | Mathlib.SetTheory.ZFC.Basic | Std.Refl fun x1 x2 => x1 ⊆ x2 |
Ideal.mulQuot | Mathlib.RingTheory.OrderOfVanishing | {R : Type u_1} → [inst : CommRing R] → (a : R) → (I : Ideal R) → R ⧸ I →ₗ[R] R ⧸ a • I |
Filter.comap_lift_eq | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {g : Set α → Filter β} {m : γ → β},
Filter.comap m (f.lift g) = f.lift (Filter.comap m ∘ g) |
Filter.Germ.const_lt_iff | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {β : Type v} {φ : Ultrafilter α} [inst : Preorder β] {x y : β}, ↑x < ↑y ↔ x < y |
FormalMultilinearSeries.rightInv._proof_16 | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], ContinuousConstSMul 𝕜 F |
CategoryTheory.Comonad.ForgetCreatesLimits'.newCone_pt | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
{T : CategoryTheory.Comonad C} {D : CategoryTheory.Functor J T.Coalgebra}
(c : CategoryTheory.Limits.Cone (D.comp T.forget)), (CategoryTheory.Comonad.ForgetCreatesLimits'.newCone c).pt = c.pt |
_private.Mathlib.RingTheory.PowerSeries.Schroder.0.PowerSeries.coeff_X_mul_largeSchroderSeries._simp_1_1 | Mathlib.RingTheory.PowerSeries.Schroder | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) |
Lean.Grind.Linarith.Poly.NonnegCoeffs.brecOn | Init.Grind.Module.NatModuleNorm | ∀ {motive : (a : Lean.Grind.Linarith.Poly) → a.NonnegCoeffs → Prop} {a : Lean.Grind.Linarith.Poly} (t : a.NonnegCoeffs),
(∀ (a : Lean.Grind.Linarith.Poly) (t : a.NonnegCoeffs), Lean.Grind.Linarith.Poly.NonnegCoeffs.below t → motive a t) →
motive a t |
MeasureTheory.lintegral_prod_mul | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] {f : α → ENNReal} {g : β → ENNReal},
AEMeasurable f μ →
AEMeasurable g ν → ∫⁻ (z : α × β), f z.1 * g z.2 ∂μ.prod ν = (∫⁻ (x : α), f x ∂μ) * ∫⁻ (y : β), g y ∂ν |
Asymptotics.isBigO_const_mul_self | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {R : Type u_13} [inst : SeminormedRing R] (c : R) (f : α → R) (l : Filter α),
(fun x => c * f x) =O[l] f |
Batteries.Tactic.Lint.LintVerbosity._sizeOf_1 | Batteries.Tactic.Lint.Frontend | Batteries.Tactic.Lint.LintVerbosity → ℕ |
_private.Mathlib.RingTheory.Ideal.NatInt.0.Nat.one_mem_span_iff._simp_1_4 | Mathlib.RingTheory.Ideal.NatInt | {1}ᶜ = ↑(IsLocalRing.maximalIdeal ℕ) |
_private.Mathlib.CategoryTheory.Triangulated.Orthogonal.0.CategoryTheory.ObjectProperty.isLocal_trW._simp_1_3 | Mathlib.CategoryTheory.Triangulated.Orthogonal | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) |
completeBipartiteGraph | Mathlib.Combinatorics.SimpleGraph.Basic | (V : Type u_1) → (W : Type u_2) → SimpleGraph (V ⊕ W) |
Int.neg_add_le_right_of_le_add | Init.Data.Int.Order | ∀ {a b c : ℤ}, a ≤ b + c → -c + a ≤ b |
_private.Init.Data.Array.Basic.0.Array.mapM.map._unary._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_2} {β : Type u_1} (as : Array α) (i : ℕ) (bs : Array β),
i < as.size →
∀ (__do_lift : β),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i bs => as.size - i) ⟨i + 1, bs.push __do_lift⟩
⟨i, bs⟩ |
_private.Init.Data.Option.Monadic.0.Option.instForIn'InferInstanceMembershipOfMonad.match_1.splitter | Init.Data.Option.Monadic | {β : Type u_1} →
(motive : ForInStep β → Sort u_2) →
(__do_lift : ForInStep β) →
((r : β) → motive (ForInStep.done r)) → ((r : β) → motive (ForInStep.yield r)) → motive __do_lift |
Aesop.PostponedSafeRule.ctorIdx | Aesop.Tree.UnsafeQueue | Aesop.PostponedSafeRule → ℕ |
_private.Mathlib.Topology.Order.LeftRightLim.0.tendsto_atTop_of_mapClusterPt._simp_1_1 | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ b ≥ a, p b |
Mathlib.Tactic.IntervalCases.Bound.lt.injEq | Mathlib.Tactic.IntervalCases | ∀ (n n_1 : ℤ), (Mathlib.Tactic.IntervalCases.Bound.lt n = Mathlib.Tactic.IntervalCases.Bound.lt n_1) = (n = n_1) |
CategoryTheory.Grothendieck.Hom.noConfusionType | Mathlib.CategoryTheory.Grothendieck | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C CategoryTheory.Cat} →
{X Y : CategoryTheory.Grothendieck F} →
X.Hom Y →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{F' : CategoryTheory.Functor C' CategoryTheory.Cat} →
{X' Y' : CategoryTheory.Grothendieck F'} → X'.Hom Y' → Sort u_1 |
_private.Mathlib.RingTheory.Filtration.0.Ideal.Filtration.Stable.exists_pow_smul_eq._proof_1_1 | Mathlib.RingTheory.Filtration | ∀ (n₀ n : ℕ), n₀ ≤ n₀ + n |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go._proof_1 | Init.Data.Nat.Power2.Basic | ∀ power > 0, 0 < power * 2 |
WithZero.instCoeTC.eq_1 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u}, WithZero.instCoeTC = { coe := WithZero.coe } |
MeasureTheory.eLpNorm_le_eLpNorm_mul_eLpNorm_of_nnnorm | Mathlib.MeasureTheory.Function.LpSeminorm.CompareExp | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} {m : MeasurableSpace α} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedAddCommGroup G] {μ : MeasureTheory.Measure α} {f : α → E} {g : α → F}
{p q r : ENNReal},
MeasureTheory.AEStronglyMeasurable f μ →
MeasureTheory.AEStronglyMeasurable g μ →
∀ (b : E → F → G) (c : NNReal),
(∀ᵐ (x : α) ∂μ, ‖b (f x) (g x)‖₊ ≤ c * ‖f x‖₊ * ‖g x‖₊) →
∀ [hpqr : p.HolderTriple q r],
MeasureTheory.eLpNorm (fun x => b (f x) (g x)) r μ ≤
↑c * MeasureTheory.eLpNorm f p μ * MeasureTheory.eLpNorm g q μ |
AffineSubspace.mem_perpBisector_iff_inner_eq_inner | Mathlib.Geometry.Euclidean.PerpBisector | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c p₁ p₂ : P},
c ∈ AffineSubspace.perpBisector p₁ p₂ ↔ inner ℝ (c -ᵥ p₁) (p₂ -ᵥ p₁) = inner ℝ (c -ᵥ p₂) (p₁ -ᵥ p₂) |
Part.some_sdiff_some | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : SDiff α] (a b : α), Part.some a \ Part.some b = Part.some (a \ b) |
AlgCat.instMonoidalCategory.tensorHom._proof_1 | Mathlib.Algebra.Category.AlgCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R] {W : AlgCat R}, IsScalarTower R R ↑W |
_private.Mathlib.Order.CountableDenseLinearOrder.0.Order.exists_orderEmbedding_insert._simp_1_3 | Mathlib.Order.CountableDenseLinearOrder | ∀ {α : Type u_1} (s : Finset α) (x : ↥s), (x ∈ s.attach) = True |
Sum.bnot_isRight | Init.Data.Sum.Lemmas | ∀ {α : Type u_1} {β : Type u_2} (x : α ⊕ β), (!x.isRight) = x.isLeft |
Valuation.norm._proof_1 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {L : Type u_1} [inst : Field L] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀],
MonoidWithZeroHomClass (Valuation L Γ₀) L Γ₀ |
Std.DTreeMap.Raw.get!.congr_simp | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [inst : Std.LawfulEqCmp cmp]
(t t_1 : Std.DTreeMap.Raw α β cmp), t = t_1 → ∀ (a : α) [inst_1 : Inhabited (β a)], t.get! a = t_1.get! a |
_private.Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral.0._aux_Mathlib_RingTheory_Polynomial_Eisenstein_IsIntegral___macroRules__private_Mathlib_RingTheory_Polynomial_Eisenstein_IsIntegral_0_term𝓟_1_1 | Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral | Lean.Macro |
_private.Mathlib.Topology.MetricSpace.Pseudo.Constructions.0.sphere_prod._simp_1_5 | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (max a b = c) = (a = c ∧ b ≤ a ∨ b = c ∧ a ≤ b) |
Batteries.Tactic.TransRelation.implies.elim | Batteries.Tactic.Trans | {motive : Batteries.Tactic.TransRelation → Sort u} →
(t : Batteries.Tactic.TransRelation) →
t.ctorIdx = 1 →
((name : Lean.Name) → (bi : Lean.BinderInfo) → motive (Batteries.Tactic.TransRelation.implies name bi)) → motive t |
IncidenceAlgebra.lambda_apply | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ (𝕜 : Type u_2) {α : Type u_5} [inst : Zero 𝕜] [inst_1 : One 𝕜] [inst_2 : Preorder α]
[inst_3 : DecidableRel fun x1 x2 => x1 ⩿ x2] (a b : α), (IncidenceAlgebra.lambda 𝕜) a b = if a ⩿ b then 1 else 0 |
_private.Lean.ToExpr.0.Lean.Name.toExprAux.isSimple._unsafe_rec | Lean.ToExpr | Lean.Name → ℕ → Bool |
Valuation.RankOne.toRankLeOne | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
{inst : Ring R} →
{inst_1 : LinearOrderedCommGroupWithZero Γ₀} → {v : Valuation R Γ₀} → [self : v.RankOne] → v.RankLeOne |
Ordinal.lt_add_iff | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {a b c : Ordinal.{u_4}}, c ≠ 0 → (a < b + c ↔ ∃ d < c, a ≤ b + d) |
FreeMonoid.count_apply | Mathlib.Algebra.FreeMonoid.Count | ∀ {α : Type u_1} [inst : DecidableEq α] (x : α) (l : FreeAddMonoid α),
(FreeMonoid.count x) l = Multiplicative.ofAdd (List.count x (FreeAddMonoid.toList l)) |
AddGroupWithOne.noConfusionType | Mathlib.Data.Int.Cast.Defs | Sort u_1 → {R : Type u} → AddGroupWithOne R → {R' : Type u} → AddGroupWithOne R' → Sort u_1 |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_diff_of_contains_eq_false_right._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) |
Complex.cosh_ofReal_im | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), (Complex.cosh ↑x).im = 0 |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory._proof_4 | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) (J : Type u_1) [inst_1 : CategoryTheory.Category.{u_4, u_1} J]
⦃X Y : CategoryTheory.Arrow (CategoryTheory.Functor J C)⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.leftFunc.map f)
{ app := fun j => (data.factorizationData (Y.hom.app j)).i, naturality := ⋯ } =
CategoryTheory.CategoryStruct.comp { app := fun j => (data.factorizationData (X.hom.app j)).i, naturality := ⋯ }
((CategoryTheory.MorphismProperty.FunctorialFactorizationData.functorCategory.Z data J).map f) |
Std.HashMap.getKey_eq_getKeyD | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{a fallback : α} {h' : a ∈ m}, m.getKey a h' = m.getKeyD a fallback |
Fin.orderPred_zero | Mathlib.Data.Fin.SuccPredOrder | ∀ (n : ℕ), Order.pred 0 = 0 |
CoxeterMatrix.recOn | Mathlib.GroupTheory.Coxeter.Matrix | {B : Type u_1} →
{motive : CoxeterMatrix B → Sort u} →
(t : CoxeterMatrix B) →
((M : Matrix B B ℕ) →
(isSymm : M.IsSymm) →
(diagonal : ∀ (i : B), M i i = 1) →
(off_diagonal : ∀ (i i' : B), i ≠ i' → M i i' ≠ 1) →
motive { M := M, isSymm := isSymm, diagonal := diagonal, off_diagonal := off_diagonal }) →
motive t |
CategoryTheory.Mat_.instPreadditive._proof_2 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(M N K : CategoryTheory.Mat_ C) (f : M ⟶ N) (g g' : N ⟶ K),
CategoryTheory.CategoryStruct.comp f (g + g') =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStruct.comp f g' |
Std.CloseableChannel.Flavors._sizeOf_1 | Std.Sync.Channel | {α : Type} → [SizeOf α] → Std.CloseableChannel.Flavors α → ℕ |
Matrix._aux_Mathlib_LinearAlgebra_Matrix_GeneralLinearGroup_Defs___unexpand_Matrix_GeneralLinearGroup_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Defs | Lean.PrettyPrinter.Unexpander |
_private.Mathlib.Order.OmegaCompletePartialOrder.0.OmegaCompletePartialOrder.isLUB_range_ωSup._simp_1_2 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ |
Array.map_eq_append_iff | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {ys zs : Array β} {f : α → β},
Array.map f xs = ys ++ zs ↔ ∃ as bs, xs = as ++ bs ∧ Array.map f as = ys ∧ Array.map f bs = zs |
MeasureTheory.eLpNormLESNormFDerivOfEqInnerConst.eq_1 | Mathlib.Analysis.FunctionalSpaces.SobolevInequality | ∀ {E : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E]
[inst_3 : BorelSpace E] [inst_4 : FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [inst_5 : μ.IsAddHaarMeasure]
(p : ℝ),
MeasureTheory.eLpNormLESNormFDerivOfEqInnerConst μ p =
MeasureTheory.eLpNormLESNormFDerivOneConst μ ↑(↑(Module.finrank ℝ E)).conjExponent *
(p * (↑(Module.finrank ℝ E) - 1) / (↑(Module.finrank ℝ E) - p)).toNNReal |
CategoryTheory.Limits.ReflectsFilteredColimitsOfSize.casesOn | Mathlib.CategoryTheory.Limits.Preserves.Filtered | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : CategoryTheory.Limits.ReflectsFilteredColimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F → Sort u} →
(t : CategoryTheory.Limits.ReflectsFilteredColimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F) →
((reflects_filtered_colimits :
∀ (J : Type w) [inst_2 : CategoryTheory.Category.{w', w} J] [CategoryTheory.IsFiltered J],
CategoryTheory.Limits.ReflectsColimitsOfShape J F) →
motive ⋯) →
motive t |
instDecidableStrictAntiOnOfForallForallMemSetForallForallForallLt | Mathlib.Order.Monotone.Defs | {α : Type u} →
{β : Type v} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
{f : α → β} → {s : Set α} → [i : Decidable (∀ a ∈ s, ∀ b ∈ s, a < b → f b < f a)] → Decidable (StrictAntiOn f s) |
Std.TreeMap.getElem?_insertMany_list.match_1 | Std.Data.TreeMap.Lemmas | {α : Type u_1} →
{β : Type u_2} → (motive : α × β → Sort u_3) → (x : α × β) → ((a : α) → (b : β) → motive (a, b)) → motive x |
MeasureTheory.memLp_congr_norm | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {E : Type u_4} {F : Type u_5} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] {f : α → E} {g : α → F},
MeasureTheory.AEStronglyMeasurable f μ →
MeasureTheory.AEStronglyMeasurable g μ →
(∀ᵐ (a : α) ∂μ, ‖f a‖ = ‖g a‖) → (MeasureTheory.MemLp f p μ ↔ MeasureTheory.MemLp g p μ) |
Filter.iSup_inf_principal | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {ι : Sort x} (f : ι → Filter α) (s : Set α),
⨆ i, f i ⊓ Filter.principal s = (⨆ i, f i) ⊓ Filter.principal s |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.LinearMap.iSupIndep_map.match_1_3 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {ι : Type u_4} {R : Type u_2} {M : Type u_3} {M' : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M') {m : ι → Submodule R M}
(i : ι) (x : M) (motive : f x ∈ ↑(Submodule.map f (⨆ i_1, ⨆ (_ : i_1 ≠ i), m i_1)) → Prop)
(hx : f x ∈ ↑(Submodule.map f (⨆ i_1, ⨆ (_ : i_1 ≠ i), m i_1))),
(∀ (y : M) (hy : y ∈ ↑(⨆ i_1, ⨆ (_ : i_1 ≠ i), m i_1)) (eq : f y = f x), motive ⋯) → motive hx |
Quiver.Path.rec.eq._@.Mathlib.Combinatorics.Quiver.Path.3963176020._hygCtx._hyg.4 | Mathlib.Combinatorics.Quiver.Path | @Quiver.Path.rec = @Quiver.Path.rec✝ |
Units.ctorIdx | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → {inst : Monoid α} → αˣ → ℕ |
Aesop.UnsafeQueueEntry.unsafeRule.elim | Aesop.Tree.UnsafeQueue | {motive : Aesop.UnsafeQueueEntry → Sort u} →
(t : Aesop.UnsafeQueueEntry) →
t.ctorIdx = 0 →
((r : Aesop.IndexMatchResult Aesop.UnsafeRule) → motive (Aesop.UnsafeQueueEntry.unsafeRule r)) → motive t |
Function.Embedding.toEmbedding_equivOfFiniteSelfEmbedding | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} [inst : Finite α] (e : α ↪ α), e.equivOfFiniteSelfEmbedding.toEmbedding = e |
Interval.length.match_1 | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_1} →
[inst : PartialOrder α] →
(motive : Interval α → Sort u_2) →
(x : Interval α) → (Unit → motive none) → ((s : NonemptyInterval α) → motive (some s)) → motive x |
Std.TreeMap.Raw.foldl | Std.Data.TreeMap.Raw.Basic | {α : Type u} →
{β : Type v} → {cmp : α → α → Ordering} → {δ : Type w} → (δ → α → β → δ) → δ → Std.TreeMap.Raw α β cmp → δ |
CategoryTheory.InjectiveResolution.ι | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
{Z : C} → (self : CategoryTheory.InjectiveResolution Z) → (CochainComplex.single₀ C).obj Z ⟶ self.cocomplex |
Ordinal.veblen_right_strictMono | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), StrictMono (Ordinal.veblen o) |
ModuleFilterBasis.instInhabitedOfDiscreteTopology | Mathlib.Topology.Algebra.FilterBasis | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : TopologicalSpace R] →
[inst_2 : AddCommGroup M] → [inst_3 : Module R M] → [DiscreteTopology R] → Inhabited (ModuleFilterBasis R M) |
Function.Injective.coframeMinimalAxioms | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} →
{β : Type v} →
[inst : Max α] →
[inst_1 : Min α] →
[inst_2 : LE α] →
[inst_3 : LT α] →
[inst_4 : SupSet α] →
[inst_5 : InfSet α] →
[inst_6 : Top α] →
[inst_7 : Bot α] →
(minAx : Order.Coframe.MinimalAxioms β) →
(f : α → β) →
Function.Injective f →
(∀ {x y : α}, f x ≤ f y ↔ x ≤ y) →
(∀ {x y : α}, f x < f y ↔ x < y) →
(∀ (a b : α), f (a ⊔ b) = f a ⊔ f b) →
(∀ (a b : α), f (a ⊓ b) = f a ⊓ f b) →
(∀ (s : Set α), f (sSup s) = ⨆ a ∈ s, f a) →
(∀ (s : Set α), f (sInf s) = ⨅ a ∈ s, f a) →
f ⊤ = ⊤ → f ⊥ = ⊥ → Order.Coframe.MinimalAxioms α |
CategoryTheory.Abelian.SpectralObject.δToCycles_cyclesIso_inv_assoc | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.δToCycles_cyclesIso_inv._auto_1)
(hn₂ : autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.δToCycles_cyclesIso_inv._auto_3) {Z : C}
(h : (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).cycles ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.δToCycles f₁ f₂ f₃ n₀ n₁ hn₁)
(CategoryTheory.CategoryStruct.comp (X.cyclesIso f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).inv h) =
CategoryTheory.CategoryStruct.comp (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).toCycles h |
Std.ExtTreeSet.max?_eq_none_iff._simp_1 | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp], (t.max? = none) = (t = ∅) |
CategoryTheory.TwoSquare.structuredArrowRightwardsOpEquivalence.functor._proof_5 | Mathlib.CategoryTheory.GuitartExact.Opposite | ∀ {C₁ : Type u_8} {C₂ : Type u_4} {C₃ : Type u_6} {C₄ : Type u_2} [inst : CategoryTheory.Category.{u_7, u_8} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} C₃]
[inst_3 : CategoryTheory.Category.{u_1, u_2} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃}
{R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B)
{X₃ : C₃ᵒᵖ} {X₂ : C₂ᵒᵖ} (g : B.op.obj X₃ ⟶ R.op.obj X₂) (f : (w.op.StructuredArrowRightwards g)ᵒᵖ),
CategoryTheory.CategoryStruct.comp (R.map (Opposite.unop f).right.hom.unop)
(CategoryTheory.CategoryStruct.comp (w.app (Opposite.unop (Opposite.unop f).right.left))
(B.map (Opposite.unop f).hom.left.unop)) =
g.unop |
MonadState.mk | Init.Prelude | {σ : outParam (Type u)} →
{m : Type u → Type v} → m σ → (σ → m PUnit.{u + 1}) → ({α : Type u} → (σ → α × σ) → m α) → MonadState σ m |
_private.Mathlib.RingTheory.MvPolynomial.Homogeneous.0.Ideal.span_eq_map_homogeneousSubmodule._simp_1_1 | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) |
CategoryTheory.Cat.Hom.toNatIso._proof_2 | Mathlib.CategoryTheory.Category.Cat | ∀ {X Y : CategoryTheory.Cat} {F G : X ⟶ Y} (e : F ≅ G),
{ toNatTrans := CategoryTheory.CategoryStruct.comp e.inv.toNatTrans e.hom.toNatTrans }.toNatTrans =
{ toNatTrans := CategoryTheory.CategoryStruct.id G.toFunctor }.toNatTrans |
DirectSum.gMulLHom._proof_3 | Mathlib.Algebra.DirectSum.Algebra | ∀ {ι : Type u_3} (R : Type u_1) (A : ι → Type u_2) [inst : CommSemiring R] [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : (i : ι) → Module R (A i)] [inst_3 : AddMonoid ι] {i j : ι}, SMulCommClass R R (A (i + j)) |
_private.Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv.0.GenContFract.squashSeq.match_1.splitter | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | {K : Type u_1} →
(motive : Option (GenContFract.Pair K) × Option (GenContFract.Pair K) → Sort u_2) →
(x : Option (GenContFract.Pair K) × Option (GenContFract.Pair K)) →
((gp_n gp_succ_n : GenContFract.Pair K) → motive (some gp_n, some gp_succ_n)) →
((x : Option (GenContFract.Pair K) × Option (GenContFract.Pair K)) →
(∀ (gp_n gp_succ_n : GenContFract.Pair K), x = (some gp_n, some gp_succ_n) → False) → motive x) →
motive x |
QuadraticAlgebra.instAddCommGroupWithOne._proof_2 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : AddCommGroupWithOne R] (n : ℕ), QuadraticAlgebra.C ↑(Int.negSucc n) = -↑(n + 1) |
LieAlgebra.LieEquiv.ofCoboundary._proof_5 | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_3} {L : Type u_1} {M : Type u_2} [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]
(c c' : ↥(LieModule.Cohomology.twoCocycle R L M)) (x : LieModule.Cohomology.oneCochain R L M),
↑c' = ↑c + (LieModule.Cohomology.d₁₂ R L M) x →
∀ {x_1 y : LieAlgebra.ofTwoCocycle c},
(((LieAlgebra.ofProd c).symm ⁅x_1, y⁆).1,
((LieAlgebra.ofProd c).symm ⁅x_1, y⁆).2 - x ((LieAlgebra.ofProd c).symm ⁅x_1, y⁆).1) =
(LieAlgebra.ofProd c').symm
⁅(LieAlgebra.ofProd c')
(((LieAlgebra.ofProd c).symm x_1).1,
((LieAlgebra.ofProd c).symm x_1).2 - x ((LieAlgebra.ofProd c).symm x_1).1),
(LieAlgebra.ofProd c')
(((LieAlgebra.ofProd c).symm y).1, ((LieAlgebra.ofProd c).symm y).2 - x ((LieAlgebra.ofProd c).symm y).1)⁆ |
List.reverse_ne_nil_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, xs.reverse ≠ [] ↔ xs ≠ [] |
Lean.Compiler.LCNF.TrivialStructureInfo.noConfusion | Lean.Compiler.LCNF.Irrelevant | {P : Sort u} →
{t t' : Lean.Compiler.LCNF.TrivialStructureInfo} →
t = t' → Lean.Compiler.LCNF.TrivialStructureInfo.noConfusionType P t t' |
nilpotencyClass_zero_iff_subsingleton | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] [Group.IsNilpotent G], Group.nilpotencyClass G = 0 ↔ Subsingleton G |
_private.Mathlib.Combinatorics.Additive.FreimanHom.0.isMulFreimanHom_two._simp_1_1 | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_1} {s : Multiset α}, (s.card = 2) = ∃ x y, s = {x, y} |
instHasLimitsOfSizeLightCondMod | Mathlib.Condensed.Light.Limits | ∀ (R : Type u) [inst : Ring R], CategoryTheory.Limits.HasLimitsOfSize.{u, u, u + 1, u + 1} (LightCondMod R) |
CategoryTheory.FreeBicategory.Hom₂.mk | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{a b : CategoryTheory.FreeBicategory B} → {f g : a ⟶ b} → CategoryTheory.FreeBicategory.Hom₂ f g → (f ⟶ g) |
_private.Mathlib.Analysis.Convex.Between.0.Wbtw.trans_left_right._simp_1_4 | Mathlib.Analysis.Convex.Between | ∀ {G : Type u_1} {P : Type u_2} [inst : AddGroup G] [T : AddTorsor G P] {g₁ g₂ : G} (p : P),
(g₁ +ᵥ p = g₂ +ᵥ p) = (g₁ = g₂) |
Algebra.Generators.ofAlgHom.congr_simp | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {I : Type u_1}
(f f_1 : MvPolynomial I R →ₐ[R] S) (e_f : f = f_1) (h : Function.Surjective ⇑f),
Algebra.Generators.ofAlgHom f h = Algebra.Generators.ofAlgHom f_1 ⋯ |
ModuleCat.ExtendRestrictScalarsAdj.Unit.map | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | {R : Type u₁} →
{S : Type u₂} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
(f : R →+* S) → {X : ModuleCat R} → X ⟶ ((ModuleCat.extendScalars f).comp (ModuleCat.restrictScalars f)).obj X |
TestFunction.mkCLM.congr_simp | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_4} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {n : ℕ∞} {V : Type u_6} [inst_6 : AddCommGroup V]
[inst_7 : Module ℝ V] [t : TopologicalSpace V] [inst_8 : IsTopologicalAddGroup V] [inst_9 : ContinuousSMul ℝ V]
[inst_10 : LocallyConvexSpace ℝ V] [inst_11 : Algebra ℝ 𝕜] [inst_12 : IsScalarTower ℝ 𝕜 F] [inst_13 : Module 𝕜 V]
[inst_14 : IsScalarTower ℝ 𝕜 V] (toFun toFun_1 : TestFunction Ω F n → V) (e_toFun : toFun = toFun_1)
(map_add : ∀ (f g : TestFunction Ω F n), toFun (f + g) = toFun f + toFun g)
(map_smul : ∀ (c : 𝕜) (f : TestFunction Ω F n), toFun (c • f) = c • toFun f)
(cont :
∀ (K : TopologicalSpace.Compacts E) (K_sub_Ω : ↑K ⊆ ↑Ω), Continuous (toFun ∘ TestFunction.ofSupportedIn K_sub_Ω)),
TestFunction.mkCLM 𝕜 toFun map_add map_smul cont = TestFunction.mkCLM 𝕜 toFun_1 ⋯ ⋯ ⋯ |
CategoryTheory.HalfBraiding.naturality._autoParam | Mathlib.CategoryTheory.Monoidal.Center | Lean.Syntax |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.RCasesPatt.tuple₁Core.match_1 | Lean.Elab.Tactic.RCases | (motive : List Lean.Elab.Tactic.RCases.RCasesPatt → Sort u_1) →
(x : List Lean.Elab.Tactic.RCases.RCasesPatt) →
(Unit → motive []) →
((ref : Lean.Syntax) → motive [Lean.Elab.Tactic.RCases.RCasesPatt.tuple ref []]) →
((ref : Lean.Syntax) →
(ps : List Lean.Elab.Tactic.RCases.RCasesPatt) → motive [Lean.Elab.Tactic.RCases.RCasesPatt.tuple ref ps]) →
((p : Lean.Elab.Tactic.RCases.RCasesPatt) →
(ps : List Lean.Elab.Tactic.RCases.RCasesPatt) → motive (p :: ps)) →
motive x |
Lean.Server.RequestCancellationToken.ctorIdx | Lean.Server.RequestCancellation | Lean.Server.RequestCancellationToken → ℕ |
Convex.integral_mem | Mathlib.Analysis.Convex.Integral | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[CompleteSpace E] {μ : MeasureTheory.Measure α} {s : Set E} {f : α → E} [MeasureTheory.IsProbabilityMeasure μ],
Convex ℝ s → IsClosed s → (∀ᵐ (x : α) ∂μ, f x ∈ s) → MeasureTheory.Integrable f μ → ∫ (x : α), f x ∂μ ∈ s |
UpperHalfPlane.coe_J_smul | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (τ : UpperHalfPlane), ↑(UpperHalfPlane.J • τ) = -(starRingEnd ℂ) ↑τ |
ZFSet.nonempty_of_mem | Mathlib.SetTheory.ZFC.Basic | ∀ {x u : ZFSet.{u_1}}, x ∈ u → u.Nonempty |
Equiv.sigmaSubtype._proof_5 | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_2} {β : α → Type u_1} (a : α) (x : { s // s.fst = a }) (a_1 : Sigma β) (h : a_1.fst = a),
(fun b => ⟨⟨a, b⟩, ⋯⟩)
((fun x =>
match x with
| ⟨⟨fst, b⟩, h⟩ => h ▸ b)
⟨a_1, h⟩) =
⟨a_1, h⟩ |
finsum_mul' | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {R : Type u_7} [inst : NonUnitalNonAssocSemiring R] (f : α → R) (r : R),
Function.HasFiniteSupport f → (∑ᶠ (a : α), f a) * r = ∑ᶠ (a : α), f a * r |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.