name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
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 |
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' → footer = footer' → P) → P |
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 |
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 : Action V G} (x : X ⟶ Y) (x_1 : Action V G),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight ((F.mapAction G).map x) ((F.mapAction G).obj x_1))
{ hom := CategoryTheory.Functor.LaxMonoidal.μ F Y.V x_1.V, comm := ⋯ } =
CategoryTheory.CategoryStruct.comp { hom := CategoryTheory.Functor.LaxMonoidal.μ F X.V x_1.V, comm := ⋯ }
((F.mapAction G).map (CategoryTheory.MonoidalCategoryStruct.whiskerRight x x_1)) |
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 |
_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 |
Lean.Lsp.instOrdPosition | Lean.Data.Lsp.BasicAux | Ord Lean.Lsp.Position |
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 : NormedAddCommGroup E'']
[inst_7 : InnerProductSpace 𝕜' E''] [inst_8 : CompleteSpace E''] [inst_9 : NormedSpace ℝ E''] (hm : m ≤ m0)
(T : E' →L[ℝ] E'') (f : ↥(MeasureTheory.Lp E' 2 μ)),
↑↑↑((MeasureTheory.condExpL2 E'' 𝕜' hm) (T.compLp f)) =ᵐ[μ] ↑↑(T.compLp ↑((MeasureTheory.condExpL2 E' 𝕜 hm) f)) |
Int.one_ne_zero | Init.Data.Int.Order | 1 ≠ 0 |
CategoryTheory.MorphismProperty.ofHoms_iff | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_2} {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) |
_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 |
Fin.attachFin_Ioo | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (a b : Fin n), (Finset.Ioo ↑a ↑b).attachFin ⋯ = Finset.Ioo a b |
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 |
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 |
_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 |
Aesop.RuleResult._sizeOf_1 | Aesop.Search.Expansion | Aesop.RuleResult → ℕ |
List.map_injective_iff._simp_1 | Mathlib.Data.List.Basic | ∀ {α : Type u} {β : Type v} {f : α → β}, Function.Injective (List.map f) = Function.Injective f |
Finsupp.instZero._proof_1 | Mathlib.Data.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] (x : α), x ∈ ∅ ↔ 0 x ≠ 0 |
continuousSubring._proof_5 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) (R : Type u_2) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace R] [inst_2 : Ring R]
[inst_3 : IsTopologicalRing R] {a b : α → R},
a ∈ (continuousAddSubgroup α R).carrier →
b ∈ (continuousAddSubgroup α R).carrier → a + b ∈ (continuousAddSubgroup α R).carrier |
FundamentalGroupoid.termπₘ | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | Lean.ParserDescr |
Lean.Parser.checkSimpFailure | Init.Notation | Lean.ParserDescr |
Lean.Server.Test.Runner.Client.MsgEmbed._sizeOf_4_eq | Lean.Server.Test.Runner | ∀ (x : Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed)),
Lean.Server.Test.Runner.Client.MsgEmbed._sizeOf_4 x = sizeOf x |
Metric.unitSphere.coe_pow | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : SeminormedRing 𝕜] [inst_1 : NormMulClass 𝕜] [inst_2 : NormOneClass 𝕜]
(x : ↑(Metric.sphere 0 1)) (n : ℕ), ↑(x ^ n) = ↑x ^ n |
SimpleGraph.deleteIncidenceSet | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | {V : Type u_1} → SimpleGraph V → V → SimpleGraph V |
ExistsContDiffBumpBase.y | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] → [FiniteDimensional ℝ E] → [inst_3 : MeasurableSpace E] → [BorelSpace E] → ℝ → E → ℝ |
Finset.mem_map'._simp_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} (f : α ↪ β) {a : α} {s : Finset α}, (f a ∈ Finset.map f s) = (a ∈ s) |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear.0.RootPairing.rootFormIn_self_smul_coroot._simp_1_3 | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (self : RootPairing ι R M N) (i j : ι),
self.coroot ((self.reflectionPerm i) j) =
self.coroot j - (self.toLinearMap (self.root i)) (self.coroot j) • self.coroot i |
CategoryTheory.Precoverage.RespectsIso | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Precoverage C → Prop |
Complex.equivRealProdAddHom_symm_apply_re | Mathlib.Data.Complex.Basic | ∀ (p : ℝ × ℝ), (Complex.equivRealProdAddHom.symm p).re = p.1 |
List.dropPrefix?_eq_some_iff._unary | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] {s : List α} (_x : (_ : List α) ×' List α),
_x.1.dropPrefix? _x.2 = some s ↔ ∃ p', _x.1 = p' ++ s ∧ (p' == _x.2) = true |
_private.Mathlib.Order.Category.HeytAlg.0.HeytAlg.Hom.mk._flat_ctor | Mathlib.Order.Category.HeytAlg | {X Y : HeytAlg} → HeytingHom ↑X ↑Y → X.Hom Y |
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedTotalDegree'_eq_bot_iff._simp_1_2 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] [inst_1 : OrderBot α] (f : β → α) (S : Finset β),
(S.sup f = ⊥) = ∀ s ∈ S, f s = ⊥ |
Sylow.normal_of_normalizer_normal | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G] {p : ℕ} [Fact (Nat.Prime p)] [Finite (Sylow p G)] (P : Sylow p G),
(↑P).normalizer.Normal → (↑P).Normal |
_private.Mathlib.RingTheory.MvPowerSeries.LexOrder.0.MvPowerSeries.coeff_ne_zero_of_lexOrder._simp_1_5 | Mathlib.RingTheory.MvPowerSeries.LexOrder | ∀ {α : Type u_3} {β : Type u_4} {S : Set α} {f : α ≃ β} {x : β}, (x ∈ ⇑f '' S) = (f.symm x ∈ S) |
MeasureTheory.SimpleFunc.instAddMonoid._proof_6 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : AddMonoid β] (x : MeasureTheory.SimpleFunc α β),
0 • x = 0 |
BoxIntegral.Prepartition.splitMany_le_split | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι) {s : Finset (ι × ℝ)} {p : ι × ℝ},
p ∈ s → BoxIntegral.Prepartition.splitMany I s ≤ BoxIntegral.Prepartition.split I p.1 p.2 |
UInt64.zero_add | Init.Data.UInt.Lemmas | ∀ (a : UInt64), 0 + a = a |
Submodule.one | Mathlib.Algebra.Algebra.Operations | {R : Type u} → [inst : Semiring R] → {A : Type v} → [inst_1 : Semiring A] → [inst_2 : Module R A] → One (Submodule R A) |
AlgebraicGeometry.instIsIsoSchemeCoprodComparisonOppositeCommRingCatSpec | Mathlib.AlgebraicGeometry.Limits | ∀ (R S : CommRingCatᵒᵖ), CategoryTheory.IsIso (CategoryTheory.Limits.coprodComparison AlgebraicGeometry.Scheme.Spec R S) |
LieRingModule.toEnd_apply_apply | Mathlib.Algebra.Lie.Basic | ∀ (L : Type v) (M : Type w) [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M] (x : L) (m : M),
((LieRingModule.toEnd L M) x) m = ⁅x, m⁆ |
Lean.CodeAction.FindTacticResult.tactic.elim | Lean.Server.CodeActions.Provider | {motive : Lean.CodeAction.FindTacticResult → Sort u} →
(t : Lean.CodeAction.FindTacticResult) →
t.ctorIdx = 0 → ((a : Lean.Syntax.Stack) → motive (Lean.CodeAction.FindTacticResult.tactic a)) → motive t |
Aesop.BaseRuleSetMember.normForwardRule.sizeOf_spec | Aesop.RuleSet.Member | ∀ (r₁ : Aesop.ForwardRule) (r₂ : Aesop.NormRule),
sizeOf (Aesop.BaseRuleSetMember.normForwardRule r₁ r₂) = 1 + sizeOf r₁ + sizeOf r₂ |
Complex.cpow_zero | Mathlib.Analysis.SpecialFunctions.Pow.Complex | ∀ (x : ℂ), x ^ 0 = 1 |
Polynomial.root_right_of_root_gcd | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} {k : Type y} [inst : Field R] [inst_1 : CommSemiring k] [inst_2 : DecidableEq R] {ϕ : R →+* k}
{f g : Polynomial R} {α : k}, Polynomial.eval₂ ϕ α (EuclideanDomain.gcd f g) = 0 → Polynomial.eval₂ ϕ α g = 0 |
Stream'.get_map | Mathlib.Data.Stream.Init | ∀ {α : Type u} {β : Type v} (f : α → β) (n : ℕ) (s : Stream' α), (Stream'.map f s).get n = f (s.get n) |
Subsingleton.intro._flat_ctor | Init.Core | ∀ {α : Sort u}, (∀ (a b : α), a = b) → Subsingleton α |
Char.toString_eq_singleton | Init.Data.Char.Lemmas | ∀ {c : Char}, c.toString = String.singleton c |
Ideal.ramificationIdx_eq_of_isGaloisGroup | Mathlib.NumberTheory.RamificationInertia.Galois | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] (p : Ideal A)
(P Q : Ideal B) [hPp : P.IsPrime] [hp : P.LiesOver p] [hQp : Q.IsPrime] [Q.LiesOver p] (G : Type u_3)
[inst_4 : Group G] [Finite G] [inst_6 : MulSemiringAction G B] [IsGaloisGroup G A B],
Ideal.ramificationIdx (algebraMap A B) p P = Ideal.ramificationIdx (algebraMap A B) p Q |
Lean.Elab.Tactic.Do.SpecAttr.SpecProof.noConfusion | Lean.Elab.Tactic.Do.Attr | {P : Sort u} →
{t t' : Lean.Elab.Tactic.Do.SpecAttr.SpecProof} →
t = t' → Lean.Elab.Tactic.Do.SpecAttr.SpecProof.noConfusionType P t t' |
Lean.Elab.Command.CoinductiveElabData.ref | Lean.Elab.Coinductive | Lean.Elab.Command.CoinductiveElabData → Lean.Syntax |
Lean.Lsp.Range.mk.sizeOf_spec | Lean.Data.Lsp.BasicAux | ∀ (start «end» : Lean.Lsp.Position), sizeOf { start := start, «end» := «end» } = 1 + sizeOf start + sizeOf «end» |
Monotone.mapsTo_Icc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : Preorder α] [inst_1 : Preorder β] {a b : α},
Monotone f → Set.MapsTo f (Set.Icc a b) (Set.Icc (f a) (f b)) |
Std.DTreeMap.Internal.Impl.Const.getEntryGE.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] (k : α)
(x_3 : Std.DTreeMap.Internal.Impl.leaf.Ordered)
(he : ∃ a ∈ Std.DTreeMap.Internal.Impl.leaf, (compare a k).isGE = true),
Std.DTreeMap.Internal.Impl.Const.getEntryGE k Std.DTreeMap.Internal.Impl.leaf x_3 he = ⋯.elim |
Std.Do.SPred.Tactic.instHasFrameAndOfSimpAnd_1 | Std.Do.SPred.DerivedLaws | ∀ {φ : Prop} (σs : List (Type u_1)) (P P' Q' PQ : Std.Do.SPred σs) [Std.Do.SPred.Tactic.HasFrame P' Q' φ]
[Std.Do.SPred.Tactic.SimpAnd P Q' PQ], Std.Do.SPred.Tactic.HasFrame spred(P ∧ P') PQ φ |
CategoryTheory.MorphismProperty.Comma.Hom.ctorIdx | 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.MorphismProperty A} →
{W : CategoryTheory.MorphismProperty B} →
{X Y : CategoryTheory.MorphismProperty.Comma L R P Q W} → X.Hom Y → ℕ |
CategoryTheory.SymmetricCategory.mk | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[toBraidedCategory : CategoryTheory.BraidedCategory C] →
autoParam
(∀ (X Y : C),
CategoryTheory.CategoryStruct.comp (β_ X Y).hom (β_ Y X).hom =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))
CategoryTheory.SymmetricCategory.symmetry._autoParam →
CategoryTheory.SymmetricCategory C |
AddSubgroup.forall_mem_sup | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {C : Type u_2} [inst : AddCommGroup C] {s t : AddSubgroup C} {P : C → Prop},
(∀ x ∈ s ⊔ t, P x) ↔ ∀ x₁ ∈ s, ∀ x₂ ∈ t, P (x₁ + x₂) |
Homotopy.noConfusion | Mathlib.Algebra.Homology.Homotopy | {P : Sort u_2} →
{ι : 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} →
{t : Homotopy f g} →
{ι' : 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'} →
{t' : Homotopy f' g'} →
ι = ι' →
V = V' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
c ≍ c' →
C ≍ C' → D ≍ D' → f ≍ f' → g ≍ g' → t ≍ t' → Homotopy.noConfusionType P t t' |
MulAction.IsMinimal.rec | Mathlib.Dynamics.Minimal | {M : Type u_1} →
{α : Type u_2} →
[inst : Monoid M] →
[inst_1 : TopologicalSpace α] →
[inst_2 : MulAction M α] →
{motive : MulAction.IsMinimal M α → Sort u} →
((dense_orbit : ∀ (x : α), Dense (MulAction.orbit M x)) → motive ⋯) →
(t : MulAction.IsMinimal M α) → motive t |
Complex.equivRealProdLm_symm_apply_im | Mathlib.LinearAlgebra.Complex.Module | ∀ (a : ℝ × ℝ), (Complex.equivRealProdLm.symm a).im = a.2 |
Set.mem_ite_empty_right._simp_1 | Mathlib.Data.Set.Basic | ∀ {α : Type u} (p : Prop) [inst : Decidable p] (t : Set α) (x : α), (x ∈ if p then t else ∅) = (p ∧ x ∈ t) |
Function.Exact.of_ladder_linearEquiv_of_exact | Mathlib.Algebra.Exact | ∀ {R : Type u_1} {M : Type u_2} {M' : Type u_3} {N : Type u_4} {N' : Type u_5} {P : Type u_6} {P' : Type u_7}
[inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M'] [inst_3 : AddCommMonoid N]
[inst_4 : AddCommMonoid N'] [inst_5 : AddCommMonoid P] [inst_6 : AddCommMonoid P'] [inst_7 : Module R M]
[inst_8 : Module R M'] [inst_9 : Module R N] [inst_10 : Module R N'] [inst_11 : Module R P] [inst_12 : Module R P']
{f₁₂ : M →ₗ[R] N} {f₂₃ : N →ₗ[R] P} {g₁₂ : M' →ₗ[R] N'} {g₂₃ : N' →ₗ[R] P'} {e₁ : M ≃ₗ[R] M'} {e₂ : N ≃ₗ[R] N'}
{e₃ : P ≃ₗ[R] P'},
g₁₂ ∘ₗ ↑e₁ = ↑e₂ ∘ₗ f₁₂ → g₂₃ ∘ₗ ↑e₂ = ↑e₃ ∘ₗ f₂₃ → Function.Exact ⇑f₁₂ ⇑f₂₃ → Function.Exact ⇑g₁₂ ⇑g₂₃ |
MeasureTheory.Measure.MutuallySingular.measure_compl_nullSet | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ.MutuallySingular ν), ν h.nullSetᶜ = 0 |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._proof_11 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {n : ℕ}
{S : CategoryTheory.ComposableArrows C (n + 3)},
S.Exact →
∀ (k : ℕ) (hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._auto_1),
CategoryTheory.CategoryStruct.comp (S.map' k (k + 1) ⋯ ⋯) (S.map' (k + 1) (k + 2) ⋯ ⋯) = 0 |
_private.Lean.Meta.Tactic.Grind.Arith.FieldNormNum.0.Lean.Meta.Grind.Arith.FieldNormNum.Context.noConfusion | Lean.Meta.Tactic.Grind.Arith.FieldNormNum | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.FieldNormNum.Context✝} →
t = t' → Lean.Meta.Grind.Arith.FieldNormNum.Context.noConfusionType✝ P t t' |
MeasureTheory.SimpleFunc.lintegralₗ._proof_1 | Mathlib.MeasureTheory.Function.SimpleFunc | IsScalarTower ENNReal ENNReal ENNReal |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Zipper.FinitenessRelation._simp_10 | Std.Data.DTreeMap.Internal.Zipper | ∀ (n : ℕ), (n < n + 1) = True |
CategoryTheory.Monad.instInhabitedAlgebra | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → (T : CategoryTheory.Monad C) → [Inhabited C] → Inhabited T.Algebra |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.balance2_All._simp_1_2 | Batteries.Data.RBMap.WF | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) |
Sym | Mathlib.Data.Sym.Basic | Type u_1 → ℕ → Type (max 0 u_1) |
Lean.Server.RefInfo.casesOn | Lean.Server.References | {motive : Lean.Server.RefInfo → Sort u} →
(t : Lean.Server.RefInfo) →
((definition : Option Lean.Server.Reference) →
(usages : Array Lean.Server.Reference) → motive { definition := definition, usages := usages }) →
motive t |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits.termI₃_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.ParserDescr |
RelSeries.step | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (self : RelSeries r) (i : Fin self.length),
(self.toFun i.castSucc, self.toFun i.succ) ∈ r |
Submonoid.pi_top | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {ι : Type u_4} {M : ι → Type u_5} [inst : (i : ι) → MulOneClass (M i)] (I : Set ι), (Submonoid.pi I fun i => ⊤) = ⊤ |
Equiv.Perm.ext | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {σ τ : Equiv.Perm α}, (∀ (x : α), σ x = τ x) → σ = τ |
Quaternion.normSq_le_zero._simp_1 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {a : Quaternion R},
(Quaternion.normSq a ≤ 0) = (a = 0) |
Lean.Doc.DocHighlight._sizeOf_1 | Lean.Elab.DocString.Builtin | Lean.Doc.DocHighlight → ℕ |
Rat.natCast_le_cast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℕ} {n : ℚ}, (↑m ≤ ↑n) = (↑m ≤ n) |
ONote._sizeOf_1 | Mathlib.SetTheory.Ordinal.Notation | ONote → ℕ |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.caching.unsafe_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | {α : Type u_1} → α → UInt64 |
_private.Mathlib.FieldTheory.Separable.0.Polynomial.separable_of_subsingleton._simp_1_2 | Mathlib.FieldTheory.Separable | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True |
Fin.Value.mk.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | ∀ (n : ℕ) (value : Fin n) (n_1 : ℕ) (value_1 : Fin n_1),
({ n := n, value := value } = { n := n_1, value := value_1 }) = (n = n_1 ∧ value ≍ value_1) |
NonemptyFinLinOrd._sizeOf_1 | Mathlib.Order.Category.NonemptyFinLinOrd | NonemptyFinLinOrd → ℕ |
Equiv.vadd | Mathlib.Algebra.Group.TransferInstance | (M : Type u_1) → {α : Type u_2} → {β : Type u_3} → α ≃ β → [VAdd M β] → VAdd M α |
CategoryTheory.ShortComplex.homologyι_naturality | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology],
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.homologyMap φ) S₂.homologyι =
CategoryTheory.CategoryStruct.comp S₁.homologyι (CategoryTheory.ShortComplex.opcyclesMap φ) |
Lean.JsonRpc.MessageDirection.toCtorIdx | Lean.Data.JsonRpc | Lean.JsonRpc.MessageDirection → ℕ |
isCoprime_mul_units_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {u v : R},
IsUnit u → IsUnit v → ∀ (y z : R), IsCoprime (y * u) (z * v) ↔ IsCoprime y z |
Path.Homotopy.reflTransSymmAux_mem_I | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ (x : ↑unitInterval × ↑unitInterval), Path.Homotopy.reflTransSymmAux x ∈ unitInterval |
IsStrictOrder.toIsTrans | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {r : α → α → Prop} [self : IsStrictOrder α r], IsTrans α r |
_private.Mathlib.Analysis.Complex.Polynomial.GaussLucas.0.Polynomial.eq_centerMass_of_eval_derivative_eq_zero._simp_1_12 | Mathlib.Analysis.Complex.Polynomial.GaussLucas | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False |
Set.powersetCard.addAction_faithful | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {α : Type u_2} [inst : DecidableEq α] {G : Type u_3} [inst_1 : AddGroup G] [inst_2 : AddAction G α] {n : ℕ},
1 ≤ n → ↑n < ENat.card α → ∀ {g : G}, AddAction.toPerm g = 1 ↔ AddAction.toPerm g = 1 |
_private.Mathlib.RingTheory.MvPowerSeries.LinearTopology.0.MvPowerSeries.LinearTopology.isTopologicallyNilpotent_of_constantCoeff._simp_1_5 | Mathlib.RingTheory.MvPowerSeries.LinearTopology | ∀ {σ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (n : σ →₀ ℕ)
(φ : MvPowerSeries σ R), f ((MvPowerSeries.coeff n) φ) = (MvPowerSeries.coeff n) ((MvPowerSeries.map f) φ) |
Set.mapsTo_id | Mathlib.Data.Set.Function | ∀ {α : Type u_1} (s : Set α), Set.MapsTo id s s |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.isColimitGluedCocone._proof_6 | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative] {S : AlgebraicGeometry.Scheme} {J : Type u_5}
[inst_2 : CategoryTheory.Category.{u_4, u_5} J] {D : CategoryTheory.Functor J (P.Over ⊤ S)} {𝒰 : S.OpenCover}
[inst_3 : CategoryTheory.Category.{u_3, u_1} 𝒰.I₀] [inst_4 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰]
(d : AlgebraicGeometry.Scheme.Cover.ColimitGluingData D 𝒰)
[inst_5 :
∀ {i j : 𝒰.I₀} (hij : i ⟶ j),
CategoryTheory.Limits.PreservesColimitsOfShape J
(CategoryTheory.MorphismProperty.Over.pullback P ⊤ (AlgebraicGeometry.Scheme.Cover.trans 𝒰 hij))]
[inst_6 : Quiver.IsThin 𝒰.I₀] [inst_7 : Small.{u_2, u_1} 𝒰.I₀] [inst_8 : AlgebraicGeometry.IsZariskiLocalAtTarget P]
(s : CategoryTheory.Limits.Cocone D) (i : d.relativeGluingData.cover.I₀),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
((d.isColimit i).desc ((CategoryTheory.MorphismProperty.Over.pullback P ⊤ (𝒰.f i)).mapCocone s)).left
(CategoryTheory.Limits.pullback.fst s.pt.hom (𝒰.f i)))
s.pt.hom =
CategoryTheory.CategoryStruct.comp (d.relativeGluingData.cover.f i) d.glued.hom |
Std.Time.Week.Offset.toHours | Std.Time.Date.Unit.Week | Std.Time.Week.Offset → Std.Time.Hour.Offset |
CategoryTheory.Lax.LaxTrans.id | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → (F : CategoryTheory.LaxFunctor B C) → CategoryTheory.Lax.LaxTrans F F |
Lean.Elab.Modifiers.mk | Lean.Elab.DeclModifiers | Lean.TSyntax `Lean.Parser.Command.declModifiers →
Option (Lean.TSyntax `Lean.Parser.Command.docComment × Bool) →
Lean.Elab.Visibility →
Bool → Lean.Elab.ComputeKind → Lean.Elab.RecKind → Bool → Array Lean.Elab.Attribute → Lean.Elab.Modifiers |
TensorProduct.leftHasSMul | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
{R' : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : Monoid R'] →
{M : Type u_7} →
{N : Type u_8} →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : DistribMulAction R' M] →
[inst_5 : Module R M] → [inst_6 : Module R N] → [SMulCommClass R R' M] → SMul R' (TensorProduct R M N) |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.mvarsOutputParams.sizeOf_spec | Lean.Meta.SynthInstance | sizeOf Lean.Meta.PreprocessKind.mvarsOutputParams✝ = 1 |
TestFunctionClass.noConfusionType | Mathlib.Analysis.Distribution.TestFunction | Sort u →
{B : Type u_6} →
{E : Type u_7} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{Ω : TopologicalSpace.Opens E} →
{F : Type u_8} →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
TestFunctionClass B Ω F n →
{B' : Type u_6} →
{E' : Type u_7} →
[inst' : NormedAddCommGroup E'] →
[inst'_1 : NormedSpace ℝ E'] →
{Ω' : TopologicalSpace.Opens E'} →
{F' : Type u_8} →
[inst'_2 : NormedAddCommGroup F'] →
[inst'_3 : NormedSpace ℝ F'] → {n' : ℕ∞} → TestFunctionClass B' Ω' F' n' → Sort u |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.