name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
PartENat.instMax | Mathlib.Data.Nat.PartENat | Max PartENat |
Lean.Syntax.getArg | Init.Prelude | Lean.Syntax → ℕ → Lean.Syntax |
_private.Lean.Data.Lsp.Extra.0.Lean.Lsp.instFromJsonDependencyBuildMode.fromJson.match_3 | Lean.Data.Lsp.Extra | (motive : Option String → Sort u_1) →
(x : Option String) → ((tag : String) → motive (some tag)) → (Unit → motive none) → motive x |
MeasurableEquiv.map_measurableEquiv_injective | Mathlib.MeasureTheory.Measure.Map | ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} [inst : MeasurableSpace β] (e : α ≃ᵐ β),
Function.Injective (MeasureTheory.Measure.map ⇑e) |
CategoryTheory.Limits.ReflectsColimitsOfShape | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(J : Type w) → [CategoryTheory.Category.{w', w} J] → CategoryTheory.Functor C D → Prop |
_private.Mathlib.Combinatorics.Enumerative.Catalan.0.gosper_catalan_sub_eq_central_binom_div._simp_1_7 | Mathlib.Combinatorics.Enumerative.Catalan | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False |
CategoryTheory.Limits.PullbackCone.IsLimit.hom_ext | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t) {W : C} {k l : W ⟶ t.pt},
CategoryTheory.CategoryStruct.comp k t.fst = CategoryTheory.CategoryStruct.comp l t.fst →
CategoryTheory.CategoryStruct.comp k t.snd = CategoryTheory.CategoryStruct.comp l t.snd → k = l |
LieAlgebra.lieCharacterEquivLinearDual_symm_apply | Mathlib.Algebra.Lie.Character | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : IsLieAbelian L]
(ψ : Module.Dual R L), LieAlgebra.lieCharacterEquivLinearDual.symm ψ = { toLinearMap := ψ, map_lie' := ⋯ } |
IsReduced.mk._flat_ctor | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_5} [inst : Zero R] [inst_1 : Pow R ℕ], (∀ (x : R), IsNilpotent x → x = 0) → IsReduced R |
CategoryTheory.Limits.FormalCoproduct.evalOpCompInlIsoId._proof_7 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (A : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} A] [inst_2 : CategoryTheory.Limits.HasProducts A]
{X Y : CategoryTheory.Functor Cᵒᵖ A} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Limits.FormalCoproduct.evalOp C A).comp
((CategoryTheory.Functor.whiskeringLeft Cᵒᵖ (CategoryTheory.Limits.FormalCoproduct C)ᵒᵖ A).obj
(CategoryTheory.Limits.FormalCoproduct.incl C).op)).map
f)
((fun F =>
CategoryTheory.NatIso.ofComponents
(fun x =>
{
hom :=
CategoryTheory.Limits.Pi.π
(fun i =>
F.obj
(Opposite.op
((Opposite.unop ((CategoryTheory.Limits.FormalCoproduct.incl C).op.obj x)).obj i)))
PUnit.unit,
inv :=
CategoryTheory.Limits.Pi.lift fun x_1 =>
CategoryTheory.CategoryStruct.id
(((CategoryTheory.Functor.id (CategoryTheory.Functor Cᵒᵖ A)).obj F).obj x),
hom_inv_id := ⋯, inv_hom_id := ⋯ })
⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun F =>
CategoryTheory.NatIso.ofComponents
(fun x =>
{
hom :=
CategoryTheory.Limits.Pi.π
(fun i =>
F.obj
(Opposite.op
((Opposite.unop ((CategoryTheory.Limits.FormalCoproduct.incl C).op.obj x)).obj i)))
PUnit.unit,
inv :=
CategoryTheory.Limits.Pi.lift fun x_1 =>
CategoryTheory.CategoryStruct.id
(((CategoryTheory.Functor.id (CategoryTheory.Functor Cᵒᵖ A)).obj F).obj x),
hom_inv_id := ⋯, inv_hom_id := ⋯ })
⋯)
X).hom
((CategoryTheory.Functor.id (CategoryTheory.Functor Cᵒᵖ A)).map f) |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite.0.SimpleGraph.TripartiteFromTriangles.Graph.in₂₁_iff.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} {t : Finset (α × β × γ)} {b : β} {c : γ}
(motive : (∃ a, (a, b, c) ∈ t) → Prop) (x : ∃ a, (a, b, c) ∈ t), (∀ (w : α) (h : (w, b, c) ∈ t), motive ⋯) → motive x |
Std.Internal.Parsec.instReprParseResult | Std.Internal.Parsec.Basic | {α ι : Type} → [Repr α] → [Repr ι] → Repr (Std.Internal.Parsec.ParseResult α ι) |
Function.mtr | Mathlib.Logic.Basic | ∀ {a b : Prop}, (¬a → ¬b) → b → a |
DFinsupp.equivFunOnFintype_symm_coe | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : Fintype ι] (f : Π₀ (i : ι), β i),
DFinsupp.equivFunOnFintype.symm ⇑f = f |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.derivative_mul._proof_1_1 | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u_1} [inst : Semiring R] (a b : R) (m n : ℕ),
(Polynomial.monomial (m + 1 + (n + 1) - 1)) (a * (b * ↑(m + 1))) +
(Polynomial.monomial (m + 1 + (n + 1) - 1)) (a * (b * ↑(n + 1))) =
(Polynomial.monomial (m + 1 - 1 + (n + 1))) (a * (b * ↑(m + 1))) +
(Polynomial.monomial (m + 1 + (n + 1 - 1))) (a * (b * ↑(n + 1))) |
_private.Mathlib.Algebra.Order.Ring.Ordering.Basic.0.RingPreordering.supportAddSubgroup_eq_bot._simp_1_1 | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {R : Type u_1} [inst : CommRing R] {P : RingPreordering R} {x : R}, (x ∈ P.supportAddSubgroup) = (x ∈ P ∧ -x ∈ P) |
MeasureTheory.LocallyIntegrable | Mathlib.MeasureTheory.Function.LocallyIntegrable | {X : Type u_1} →
{ε : Type u_3} →
[inst : MeasurableSpace X] →
[TopologicalSpace X] →
[inst_2 : TopologicalSpace ε] →
[ContinuousENorm ε] →
(X → ε) → autoParam (MeasureTheory.Measure X) MeasureTheory.LocallyIntegrable._auto_1 → Prop |
IsAlgebraic.nontrivial | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsAlgebraic R a → Nontrivial R |
CategoryTheory.Limits.preservesFiniteLimits_of_op | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesFiniteColimits F.op],
CategoryTheory.Limits.PreservesFiniteLimits F |
IsLocalization.AtPrime.inertiaDeg_map_eq_inertiaDeg | Mathlib.RingTheory.Localization.AtPrime.Extension | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (Rₚ : Type u_3) [inst_4 : CommRing Rₚ] [inst_5 : Algebra R Rₚ] [IsLocalization.AtPrime Rₚ p]
[inst_7 : IsLocalRing Rₚ] (Sₚ : Type u_4) [inst_8 : CommRing Sₚ] [inst_9 : Algebra S Sₚ]
[IsLocalization (Algebra.algebraMapSubmonoid S p.primeCompl) Sₚ] [inst_11 : Algebra Rₚ Sₚ] (P : Ideal S)
[hPp : P.LiesOver p] [inst_12 : Algebra R Sₚ] [IsScalarTower R S Sₚ] [IsScalarTower R Rₚ Sₚ] [p.IsMaximal]
[P.IsMaximal] [(Ideal.map (algebraMap S Sₚ) P).LiesOver (IsLocalRing.maximalIdeal Rₚ)],
(IsLocalRing.maximalIdeal Rₚ).inertiaDeg (Ideal.map (algebraMap S Sₚ) P) = p.inertiaDeg P |
Lean._aux_Lean_Message___macroRules_Lean_termM!__1 | Lean.Message | Lean.Macro |
CategoryTheory.Preadditive.isSeparator_iff | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (G : C),
CategoryTheory.IsSeparator G ↔
∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (h : G ⟶ X), CategoryTheory.CategoryStruct.comp h f = 0) → f = 0 |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable.0.hasSum_nat_jacobiTheta._simp_1_3 | Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b |
List.insert_replicate_self | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {n : ℕ} {a : α},
0 < n → List.insert a (List.replicate n a) = List.replicate n a |
Polynomial.hasStrictDerivAt | Mathlib.Analysis.Calculus.Deriv.Polynomial | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (p : Polynomial 𝕜) (x : 𝕜),
HasStrictDerivAt (fun x => Polynomial.eval x p) (Polynomial.eval x (Polynomial.derivative p)) x |
AlgHom.toOpposite._proof_2 | Mathlib.Algebra.Algebra.Opposite | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (hf : ∀ (x y : A), Commute (f x) (f y)) (x y : A),
(↑↑(f.toOpposite hf)).toFun (x * y) = (↑↑(f.toOpposite hf)).toFun x * (↑↑(f.toOpposite hf)).toFun y |
Subtype.instTotalLE | Init.Data.Subtype.Order | ∀ {α : Type u} [inst : LE α] [i : Std.Total fun x1 x2 => x1 ≤ x2] {P : α → Prop}, Std.Total fun x1 x2 => x1 ≤ x2 |
_private.Mathlib.Data.Setoid.Basic.0.Setoid.mk_eq_bot._simp_1_1 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {r₁ r₂ : Setoid α}, (r₁ = r₂) = (⇑r₁ = ⇑r₂) |
InverseSystem.piSplitLE._proof_14 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} {i : ι} [inst : PartialOrder ι], i ≤ i |
InnerProductSpace.toDual_apply_eq_toDualMap_apply | Mathlib.Analysis.InnerProductSpace.Dual | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] (x : E), (InnerProductSpace.toDual 𝕜 E) x = (InnerProductSpace.toDualMap 𝕜 E) x |
SimpleGraph.Subgraph.coeCopy | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} → {G : SimpleGraph V} → (G' : G.Subgraph) → G'.coe.Copy G |
SimpleGraph.map_neighborFinset_induce_of_neighborSet_subset | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} {s : Set V} [inst : DecidablePred fun x => x ∈ s] [inst_1 : Fintype V] {G : SimpleGraph V}
[inst_2 : DecidableRel G.Adj] {v : ↑s},
G.neighborSet ↑v ⊆ s →
Finset.map (Function.Embedding.subtype fun x => x ∈ s) ((SimpleGraph.induce s G).neighborFinset v) =
G.neighborFinset ↑v |
Polynomial.eraseLead_monomial | Mathlib.Algebra.Polynomial.EraseLead | ∀ {R : Type u_1} [inst : Semiring R] (i : ℕ) (r : R), ((Polynomial.monomial i) r).eraseLead = 0 |
AddSemiconjBy.unop | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Add α] {a x y : αᵃᵒᵖ},
AddSemiconjBy a x y → AddSemiconjBy (AddOpposite.unop a) (AddOpposite.unop y) (AddOpposite.unop x) |
Equiv.sigmaSumDistrib_apply | Mathlib.Logic.Equiv.Sum | ∀ {ι : Type u_11} (α : ι → Type u_9) (β : ι → Type u_10) (p : (i : ι) × (α i ⊕ β i)),
(Equiv.sigmaSumDistrib α β) p = Sum.map (Sigma.mk p.fst) (Sigma.mk p.fst) p.snd |
Num.mod.eq_3 | Mathlib.Data.Num.ZNum | ∀ (a b : PosNum), (Num.pos a).mod (Num.pos b) = a.mod' b |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_726 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)] {g a, g (g a)}.card + 1 ≤
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)] {g a, g (g a)}.card <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length |
CategoryTheory.Limits.prod.map_mono | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z : C} (f : W ⟶ Y) (g : X ⟶ Z)
[CategoryTheory.Mono f] [CategoryTheory.Mono g] [inst_3 : CategoryTheory.Limits.HasBinaryProduct W X]
[inst_4 : CategoryTheory.Limits.HasBinaryProduct Y Z], CategoryTheory.Mono (CategoryTheory.Limits.prod.map f g) |
List.step_iter_cons | Init.Data.Iterators.Lemmas.Producers.List | ∀ {β : Type w} {x : β} {xs : List β}, (x :: xs).iter.step = ⟨Std.IterStep.yield xs.iter x, ⋯⟩ |
CategoryTheory.Square.toArrowArrowFunctor._proof_2 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : CategoryTheory.Square C} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp φ.τ₂ Y.f₂₄ = CategoryTheory.CategoryStruct.comp X.f₂₄ φ.τ₄ |
tacticSimp_wf | Init.WFTactics | Lean.ParserDescr |
preservesBinaryCoproducts_of_preservesInitial_and_pushouts | Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.HasPushouts C]
[CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete PEmpty.{1}) F]
[CategoryTheory.Limits.PreservesColimitsOfShape CategoryTheory.Limits.WalkingSpan F],
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) F |
MeasureTheory.measureReal_union_null | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
μ.real s₁ = 0 → μ.real s₂ = 0 → μ.real (s₁ ∪ s₂) = 0 |
Polynomial.C_mul_X_pow_eq_monomial | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, Polynomial.C a * Polynomial.X ^ n = (Polynomial.monomial n) a |
LeanSearchClient.LoogleResult.noConfusionType | LeanSearchClient.LoogleSyntax | Sort u → LeanSearchClient.LoogleResult → LeanSearchClient.LoogleResult → Sort u |
MvPolynomial.isWeightedHomogeneous_X | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ (R : Type u_1) {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} [inst_1 : AddCommMonoid M] (w : σ → M) (i : σ),
MvPolynomial.IsWeightedHomogeneous w (MvPolynomial.X i) (w i) |
TopologicalLattice.rec | Mathlib.Topology.Order.Lattice | {L : Type u_1} →
[inst : TopologicalSpace L] →
[inst_1 : Lattice L] →
{motive : TopologicalLattice L → Sort u} →
([toContinuousInf : ContinuousInf L] → [toContinuousSup : ContinuousSup L] → motive ⋯) →
(t : TopologicalLattice L) → motive t |
MeasureTheory.FiniteMeasure.restrict_biUnion_finset | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {ι : Type u_3} {μ : MeasureTheory.FiniteMeasure Ω} {T : Finset ι}
{s : ι → Set Ω},
(↑T).Pairwise (Function.onFun Disjoint s) →
(∀ (i : ι), MeasurableSet (s i)) → μ.restrict (⋃ i ∈ T, s i) = ∑ i ∈ T, μ.restrict (s i) |
Prod.mk_le_swap._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x : α × β} {a : α} {b : β},
((b, a) ≤ x.swap) = ((a, b) ≤ x) |
Similar.comp_left_iff | Mathlib.Topology.MetricSpace.Similarity | ∀ {ι : Type u_1} {P₁ : Type u_3} {P₂ : Type u_4} {P₃ : Type u_5} {v₁ : ι → P₁} {v₂ : ι → P₂}
[inst : PseudoEMetricSpace P₁] [inst_1 : PseudoEMetricSpace P₂] [inst_2 : PseudoEMetricSpace P₃] {F : Type u_6}
[inst_3 : FunLike F P₁ P₃] [DilationClass F P₁ P₃] (f : F), Similar (⇑f ∘ v₁) v₂ ↔ Similar v₁ v₂ |
List.set | Init.Prelude | {α : Type u_1} → List α → ℕ → α → List α |
DoResultPRBC.recOn | Init.Core | {α β σ : Type u} →
{motive : DoResultPRBC α β σ → Sort u_1} →
(t : DoResultPRBC α β σ) →
((a : α) → (a_1 : σ) → motive (DoResultPRBC.pure a a_1)) →
((a : β) → (a_1 : σ) → motive (DoResultPRBC.return a a_1)) →
((a : σ) → motive (DoResultPRBC.break a)) → ((a : σ) → motive (DoResultPRBC.continue a)) → motive t |
CondensedMod.ofSheafProfinite | Mathlib.Condensed.Explicit | (R : Type (u + 1)) →
[inst : Ring R] →
(F : CategoryTheory.Functor Profiniteᵒᵖ (ModuleCat R)) →
[CategoryTheory.Limits.PreservesFiniteProducts F] →
CategoryTheory.regularTopology.EqualizerCondition F → CondensedMod R |
CategoryTheory.Limits.WalkingMultispan.Hom.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | Sort u →
{J : CategoryTheory.Limits.MultispanShape} →
{x x_1 : CategoryTheory.Limits.WalkingMultispan J} →
x.Hom x_1 →
{J' : CategoryTheory.Limits.MultispanShape} →
{x' x'_1 : CategoryTheory.Limits.WalkingMultispan J'} → x'.Hom x'_1 → Sort u |
MeasureTheory.Integrable.bdd_mul' | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {𝕜 : Type u_8} [inst : NormedRing 𝕜]
{f g : α → 𝕜} {c : ℝ},
MeasureTheory.Integrable g μ →
MeasureTheory.AEStronglyMeasurable f μ →
(∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ c) → MeasureTheory.Integrable (fun x => f x * g x) μ |
lt_iff_le_and_ne' | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, b < a ↔ b ≤ a ∧ a ≠ b |
DFinsupp.wellFoundedLT | Mathlib.Data.DFinsupp.WellFounded | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → Preorder (α i)]
[∀ (i : ι), WellFoundedLT (α i)], (∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬a < 0) → WellFoundedLT (Π₀ (i : ι), α i) |
CochainComplex.shiftFunctorZero'_inv_app_f | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (n : ℤ) (h : n = 0)
(X : CochainComplex C ℤ) (i : ℤ),
((CochainComplex.shiftFunctorZero' C n h).inv.app X).f i = (HomologicalComplex.XIsoOfEq X ⋯).inv |
MulEquiv.submonoidCongr.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : MulOneClass M] {S T : Submonoid M} (h : S = T),
MulEquiv.submonoidCongr h = { toEquiv := Equiv.setCongr ⋯, map_mul' := ⋯ } |
Rep.coinvariantsTensorIndHom.eq_1 | Mathlib.RepresentationTheory.Induced | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H) (A : Rep k G) (B : Rep k H),
Rep.coinvariantsTensorIndHom φ A B =
ModuleCat.ofHom
(Representation.Coinvariants.lift
(((CategoryTheory.MonoidalCategory.curriedTensor (Rep k H)).obj (Rep.ind φ A)).obj B).ρ
(TensorProduct.lift
(Representation.Coinvariants.lift
(Representation.tprod (MonoidHom.comp (Representation.leftRegular k H) φ) A.ρ)
(TensorProduct.lift
((Finsupp.lift
(↑A.V →ₗ[k]
↑(((Action.functorCategoryEquivalence (ModuleCat k) H).symm.inverse.obj B).obj PUnit.unit) →ₗ[k]
(((CategoryTheory.MonoidalCategory.curriedTensor (Rep k G)).obj A).obj
((Action.res (ModuleCat k) φ).obj B)).ρ.Coinvariants)
k H)
fun g => (A.coinvariantsTensorMk ((Action.res (ModuleCat k) φ).obj B)).compl₂ (B.ρ g)))
⋯))
⋯) |
CategoryTheory.MorphismProperty.Comma.Hom.noConfusionType | Mathlib.CategoryTheory.MorphismProperty.Comma | Sort u →
{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 →
{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' → Sort u |
Std.DTreeMap.Internal.Impl.filterMap._proof_10 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_3} {γ : α → Type u_2} (sz : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced) (v' : γ k) (l' : Std.DTreeMap.Internal.Impl α γ)
(hl' : l'.Balanced) (r' : Std.DTreeMap.Internal.Impl α γ) (hr' : r'.Balanced),
(Std.DTreeMap.Internal.Impl.link k v' l' r' ⋯ ⋯).impl.Balanced |
_private.Mathlib.Topology.Category.Stonean.Basic.0.Stonean.epi_iff_surjective._simp_1_6 | Mathlib.Topology.Category.Stonean.Basic | ∀ {a : Prop}, (¬¬a) = a |
LinearIndependent.Maximal | Mathlib.LinearAlgebra.LinearIndependent.Defs | {ι : Type w} →
{R : Type u} →
[inst : Semiring R] →
{M : Type v} → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → {v : ι → M} → LinearIndependent R v → Prop |
ValuativeRel.instOrderBotValueGroupWithZero._proof_2 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] (t : ValuativeRel.ValueGroupWithZero R), ⊥ ≤ t |
Fin.snocOrderIso | Mathlib.Order.Fin.Tuple | {n : ℕ} →
(α : Fin (n + 1) → Type u_2) →
[inst : (i : Fin (n + 1)) → LE (α i)] → α (Fin.last n) × ((i : Fin n) → α i.castSucc) ≃o ((i : Fin (n + 1)) → α i) |
NumberField.mixedEmbedding.fundamentalCone.integerSetQuotEquivAssociates._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(x x_1 : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)),
x ≈ x_1 →
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K x =
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K x_1 |
Mathlib.Tactic.Translate.elabArgStx | Mathlib.Tactic.Translate.Reorder | Lean.TSyntax [`ident, `num] → Array Lean.Name → Array Lean.Expr → Lean.MessageData → Lean.MetaM ℕ |
Filter.Realizer.rec | Mathlib.Data.Analysis.Filter | {α : Type u_1} →
{f : Filter α} →
{motive : f.Realizer → Sort u} →
((σ : Type u_5) → (F : CFilter (Set α) σ) → (eq : F.toFilter = f) → motive { σ := σ, F := F, eq := eq }) →
(t : f.Realizer) → motive t |
Lean.Meta.ParamInfo.isStrictImplicit | Lean.Meta.Basic | Lean.Meta.ParamInfo → Bool |
Lean.Server.FileWorker.FileSetupResult.ctorElim | Lean.Server.FileWorker.SetupFile | {motive : Lean.Server.FileWorker.FileSetupResult → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Server.FileWorker.FileSetupResult) →
ctorIdx = t.ctorIdx → Lean.Server.FileWorker.FileSetupResult.ctorElimType ctorIdx → motive t |
MonoidWithZeroHom.instMul._proof_2 | Mathlib.Algebra.GroupWithZero.Hom | ∀ {α : Type u_1} [inst : MulZeroOneClass α] {β : Type u_2} [inst_1 : CommMonoidWithZero β], MonoidHomClass (α →*₀ β) α β |
CategoryTheory.Limits.Cocone.extend_pt | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) {Y : C} (f : c.pt ⟶ Y), (c.extend f).pt = Y |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.isZero_of_isStrictlyLE._simp_1_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (p n : ℤ), (∀ (i : ℕ), (ComplexShape.embeddingUpIntLE p).f i ≠ n) = (p < n) |
inv_hausdorffEntourage | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} (U : SetRel α α), (hausdorffEntourage U).inv = hausdorffEntourage U.inv |
Rat.inv_eq_of_mul_eq_one | Init.Data.Rat.Lemmas | ∀ {a b : ℚ}, a * b = 1 → a⁻¹ = b |
MvPolynomial.IsHomogeneous.neg | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {R : Type u_5} {σ : Type u_6} [inst : CommRing R] {φ : MvPolynomial σ R} {n : ℕ},
φ.IsHomogeneous n → (-φ).IsHomogeneous n |
_private.Mathlib.Tactic.Linter.DirectoryDependency.0.Lean.Name.prefixToName | Mathlib.Tactic.Linter.DirectoryDependency | Lean.Name → Array Lean.Name → Option Lean.Name |
CategoryTheory.effectiveEpiStructOfIsColimit.match_1 | Mathlib.CategoryTheory.Sites.EffectiveEpimorphic | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
{X Y : C} →
(f : Y ⟶ X) →
(motive : (CategoryTheory.Sieve.generateSingleton f).arrows.category → Sort u_3) →
(x : (CategoryTheory.Sieve.generateSingleton f).arrows.category) →
((obj : CategoryTheory.Over X) →
(hT : (CategoryTheory.Sieve.generateSingleton f).arrows obj.hom) →
motive { obj := obj, property := hT }) →
motive x |
IsField.toSemifield._proof_9 | Mathlib.Algebra.Field.IsField | ∀ {R : Type u_1} [inst : Semiring R], IsField R → ¬0 = 0 → ∃ b, 0 * b = 1 |
Lean.Meta.Grind.addHypothesis | Lean.Meta.Tactic.Grind.Core | Lean.FVarId → optParam ℕ 0 → Lean.Meta.Grind.GoalM Unit |
Nat.mod_eq_of_modEq | Mathlib.Data.Nat.ModEq | ∀ {a b n : ℕ}, a ≡ b [MOD n] → b < n → a % n = b |
Nat.minFacAux | Mathlib.Data.Nat.Prime.Defs | ℕ → ℕ → ℕ |
CategoryTheory.Limits.WalkingParallelFamily.one.elim | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{motive : CategoryTheory.Limits.WalkingParallelFamily J → Sort u} →
(t : CategoryTheory.Limits.WalkingParallelFamily J) →
t.ctorIdx = 1 → motive CategoryTheory.Limits.WalkingParallelFamily.one → motive t |
BoundedContinuousFunction.charAlgHom | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | {V : Type u_1} →
{W : Type u_2} →
[inst : AddCommGroup V] →
[inst_1 : Module ℝ V] →
[inst_2 : TopologicalSpace V] →
[inst_3 : AddCommGroup W] →
[inst_4 : Module ℝ W] →
[inst_5 : TopologicalSpace W] →
{e : AddChar ℝ Circle} →
{L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ} →
Continuous ⇑e →
(Continuous fun p => (L p.1) p.2) → AddMonoidAlgebra ℂ W →ₐ[ℂ] BoundedContinuousFunction V ℂ |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.compare_maxKey!_modify_eq._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) |
ClosureOperator.closure_sup_closure_left | Mathlib.Order.Closure | ∀ {α : Type u_1} [inst : SemilatticeSup α] (c : ClosureOperator α) (x y : α), c (c x ⊔ y) = c (x ⊔ y) |
Submodule.tensorToSpan._proof_2 | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ (A : Type u_1) {M : Type u_2} [inst : CommSemiring A] [inst_1 : AddCommMonoid M] [inst_2 : Module A M],
IsScalarTower A A M |
CategoryTheory.Cokleisli.Adjunction.fromCokleisli_map | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (U : CategoryTheory.Comonad C)
{X x : CategoryTheory.Cokleisli U} (f : X ⟶ x),
(CategoryTheory.Cokleisli.Adjunction.fromCokleisli U).map f =
CategoryTheory.CategoryStruct.comp (U.δ.app X.of) (U.map f.of) |
Submonoid.unop_eq_bot | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] {S : Submonoid Mᵐᵒᵖ}, S.unop = ⊥ ↔ S = ⊥ |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.arithmeticFolders._proof_32 | Lean.Compiler.LCNF.Simp.ConstantFold | ∀ (a : UInt64), 1 * a = a |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_of_countable._proof_1_3 | Mathlib.Probability.ProductMeasure | ∀ {ι : Type u_1} {X : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (X i)},
s.pi t = s.pi fun i => if i ∈ s then t i else Set.univ |
NNReal.coe_inv._simp_1 | Mathlib.Data.NNReal.Defs | ∀ (r : NNReal), (↑r)⁻¹ = ↑r⁻¹ |
List.find?_eq_head?_dropWhile_not | Mathlib.Data.List.TakeWhile | ∀ {α : Type u_1} (p : α → Bool) (l : List α), List.find? p l = (List.dropWhile (fun x => !p x) l).head? |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabAnonymousCtor._sparseCasesOn_1 | Lean.Elab.BuiltinNotation | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Turing.ToPartrec.Code.comp.injEq | Mathlib.Computability.TMConfig | ∀ (a a_1 a_2 a_3 : Turing.ToPartrec.Code), (a.comp a_1 = a_2.comp a_3) = (a = a_2 ∧ a_1 = a_3) |
Topology.«_aux_Mathlib_Topology_Baire_BaireMeasurable___macroRules_Topology_term∀ᵇ_,__1» | Mathlib.Topology.Baire.BaireMeasurable | Lean.Macro |
HAnd.rec | Init.Prelude | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : HAnd α β γ → Sort u_1} → ((hAnd : α → β → γ) → motive { hAnd := hAnd }) → (t : HAnd α β γ) → motive t |
Algebra.subset_adjoin | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Set A},
s ⊆ ↑(Algebra.adjoin R s) |
TopologicalSpace.CompactOpens.coe_himp._simp_1 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : T2Space α]
(s t : TopologicalSpace.CompactOpens α), ↑s ⇨ ↑t = ↑(s ⇨ t) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.