name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Array.eraseIdx_insertIdx_self | Init.Data.Array.InsertIdx | ∀ {α : Type u} {a : α} {i : ℕ} {xs : Array α} (h : i ≤ xs.size), (xs.insertIdx i a h).eraseIdx i ⋯ = xs |
OrderDual.instDivisionRing | Mathlib.Algebra.Field.Basic | {K : Type u_1} → [DivisionRing K] → DivisionRing Kᵒᵈ |
Std.DTreeMap.Internal.Impl.Const.get?_insertManyIfNewUnit_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [Std.TransOrd α] [inst : BEq α]
[Std.LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α},
Std.DTreeMap.Internal.Impl.Const.get? (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯)) k =
if k ∈ t ∨ l.contains k = true then some () else none |
Lean.Compiler.LCNF.Simp.DiscrM.Context.mk.sizeOf_spec | Lean.Compiler.LCNF.Simp.DiscrM | ∀ (discrCtorMap : Lean.FVarIdMap Lean.Compiler.LCNF.Simp.CtorInfo) (ctorDiscrMap : Lean.PersistentExprMap Lean.FVarId),
sizeOf { discrCtorMap := discrCtorMap, ctorDiscrMap := ctorDiscrMap } = 1 + sizeOf discrCtorMap + sizeOf ctorDiscrMap |
MeasureTheory.Measure.MeasurableSet.nullMeasurableSet_subtype_coe | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {t : Set ↑s},
MeasureTheory.NullMeasurableSet s μ → MeasurableSet t → MeasureTheory.NullMeasurableSet (Subtype.val '' t) μ |
Ideal.uniqueUnits | Mathlib.RingTheory.Ideal.Operations | {R : Type u} → [inst : CommSemiring R] → Unique (Ideal R)ˣ |
Complex.range_sin | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | Set.range Complex.sin = Set.univ |
instAssociativeMinOnOfIsLinearPreorder | Init.Data.Order.MinMaxOn | ∀ {β : Type u_1} {α : Sort u_2} [inst : LE β] [inst_1 : DecidableLE β] [Std.IsLinearPreorder β] {f : α → β},
Std.Associative (minOn f) |
AddOpposite.instDecidableEq | Mathlib.Algebra.Opposites | {α : Type u_1} → [DecidableEq α] → DecidableEq αᵃᵒᵖ |
Lean.Grind.AC.Context.vars | Init.Grind.AC | {α : Sort u} → Lean.Grind.AC.Context α → Lean.RArray (PLift α) |
ContinuousMap.instRing._proof_8 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Ring β]
[inst_3 : IsTopologicalRing β] (f g : C(α, β)), ⇑(f * g) = ⇑f * ⇑g |
CategoryTheory.InjectiveResolution.extEquivCohomologyClass._proof_6 | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Abelian C]
[CategoryTheory.HasExt C] {Y : C} (R : CategoryTheory.InjectiveResolution Y) (a b : ℤ),
CategoryTheory.Localization.HasSmallLocalizedHom (HomologicalComplex.quasiIso C (ComplexShape.up ℤ))
((CategoryTheory.shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) a).obj
((CochainComplex.singleFunctor C 0).obj Y))
((CategoryTheory.shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) b).obj R.cochainComplex) |
Filter.EventuallyEq.mapClusterPt_iff | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {α : Type u_1} {F : Filter α} {u : α → X} {x : X} {v : α → X},
u =ᶠ[F] v → (MapClusterPt x F u ↔ MapClusterPt x F v) |
sbtw_const_vsub_iff | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] {x y z : P} (p : P), Sbtw R (p -ᵥ x) (p -ᵥ y) (p -ᵥ z) ↔ Sbtw R x y z |
CategoryTheory.sum.inrCompInrCompInverseAssociator_hom_app_down | Mathlib.CategoryTheory.Sums.Associator | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(E : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (X : E),
((CategoryTheory.sum.inrCompInrCompInverseAssociator C D E).hom.app X).down =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (Sum.inr X)).down
(CategoryTheory.CategoryStruct.id (Sum.inr X)).down |
Lean.Parser.Tactic.Grind.finishTrace | Init.Grind.Interactive | Lean.ParserDescr |
_private.Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm.0.PiTensorProduct.wrapped._proof_1._@.Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm.2741663271._hygCtx._hyg.2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | @PiTensorProduct.definition✝ = @PiTensorProduct.definition✝ |
CategoryTheory.Limits.pasteVertIsPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{Y₃ Y₂ Y₁ X₃ : C} →
{g₂ : Y₃ ⟶ Y₂} →
{g₁ : Y₂ ⟶ Y₁} →
{i₃ : Y₃ ⟶ X₃} →
{t₁ : CategoryTheory.Limits.PushoutCocone g₂ i₃} →
{i₂ : Y₂ ⟶ t₁.pt} →
{t₂ : CategoryTheory.Limits.PushoutCocone g₁ i₂} →
(hi₂ : i₂ = t₁.inl) →
CategoryTheory.Limits.IsColimit t₁ →
CategoryTheory.Limits.IsColimit t₂ → CategoryTheory.Limits.IsColimit (t₁.pasteVert t₂ hi₂) |
CategoryTheory.MonoidalClosed.curry.eq_1 | Mathlib.CategoryTheory.LocallyCartesianClosed.Sections | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {A X Y : C}
[inst_2 : CategoryTheory.Closed A],
CategoryTheory.MonoidalClosed.curry = ⇑((CategoryTheory.ihom.adjunction A).homEquiv Y X) |
Lean.Server.Completion.EligibleDecl.recOn | Lean.Server.Completion.EligibleHeaderDecls | {motive : Lean.Server.Completion.EligibleDecl → Sort u} →
(t : Lean.Server.Completion.EligibleDecl) →
((info : Lean.ConstantInfo) →
(kind : Lean.MetaM Lean.Lsp.CompletionItemKind) →
(tags : Lean.MetaM (Array Lean.Lsp.CompletionItemTag)) →
motive { info := info, kind := kind, tags := tags }) →
motive t |
Vector.zip_replicate | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β} {n : ℕ},
(Vector.replicate n a).zip (Vector.replicate n b) = Vector.replicate n (a, b) |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategorySnd._proof_14 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : C) ⦃X_1 Y_1 : CategoryTheory.Over Y⦄ (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp
(({ obj := fun Z => CategoryTheory.Over.mk (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X Z.hom),
map := fun {X_2 Y_2} g =>
CategoryTheory.Over.homMk (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X g.left) ⋯,
map_id := ⋯, map_comp := ⋯ }.comp
(CategoryTheory.Over.map (CategoryTheory.SemiCartesianMonoidalCategory.snd X Y))).map
f)
(CategoryTheory.Over.homMk
(CategoryTheory.SemiCartesianMonoidalCategory.snd X ((CategoryTheory.Functor.id C).obj Y_1.left)) ⋯) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.homMk
(CategoryTheory.SemiCartesianMonoidalCategory.snd X ((CategoryTheory.Functor.id C).obj X_1.left)) ⋯)
((CategoryTheory.Functor.id (CategoryTheory.Over Y)).map f) |
_private.Lean.Data.Lsp.LanguageFeatures.0.Lean.Lsp.instBEqInsertReplaceEdit.beq.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.InsertReplaceEdit → Lean.Lsp.InsertReplaceEdit → Sort u_1) →
(x x_1 : Lean.Lsp.InsertReplaceEdit) →
((a : String) →
(a_1 a_2 : Lean.Lsp.Range) →
(b : String) →
(b_1 b_2 : Lean.Lsp.Range) →
motive { newText := a, insert := a_1, replace := a_2 } { newText := b, insert := b_1, replace := b_2 }) →
((x x_2 : Lean.Lsp.InsertReplaceEdit) → motive x x_2) → motive x x_1 |
ContinuousMap.HomotopicRel.equivalence | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {S : Set X},
Equivalence fun f g => f.HomotopicRel g S |
CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation_I | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q),
(CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation f).I = CategoryTheory.Abelian.coimage f |
_private.Mathlib.RingTheory.Congruence.Hom.0.RingCon.correspondence._simp_5 | Mathlib.RingTheory.Congruence.Hom | ∀ {R : Type u_3} [inst : Add R] [inst_1 : Mul R] {c d : RingCon R}, (c ≤ d) = ∀ {x y : R}, c x y → d x y |
SimpleGraph.Subgraph.IsMatching | Mathlib.Combinatorics.SimpleGraph.Matching | {V : Type u_1} → {G : SimpleGraph V} → G.Subgraph → Prop |
Finset.le_truncatedSup | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : SemilatticeSup α] {s : Finset α} {a : α} [inst_1 : DecidableLE α] [inst_2 : OrderTop α],
a ≤ s.truncatedSup a |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic.0.WeierstrassCurve.Projective.nonsingular_some._simp_1_8 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) |
contDiffPointwiseHolderAt_iff | Mathlib.Analysis.Calculus.ContDiffHolder.Pointwise | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (k : ℕ) (α : ↑unitInterval) (f : E → F) (a : E),
ContDiffPointwiseHolderAt k α f a ↔
ContDiffAt ℝ (↑k) f a ∧ (fun x => iteratedFDeriv ℝ k f x - iteratedFDeriv ℝ k f a) =O[nhds a] fun x => ‖x - a‖ ^ ↑α |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.next_eq_iff.match_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p q : s.Pos} (motive : (p < q ∧ ∀ (q' : s.Pos), p < q' → q ≤ q') → Prop)
(x : p < q ∧ ∀ (q' : s.Pos), p < q' → q ≤ q'),
(∀ (h₁ : p < q) (h₂ : ∀ (q' : s.Pos), p < q' → q ≤ q'), motive ⋯) → motive x |
Set.singleton_union | Mathlib.Data.Set.Insert | ∀ {α : Type u} {s : Set α} {a : α}, {a} ∪ s = insert a s |
Trunc.nonempty | Mathlib.Data.Quot | ∀ {α : Sort u_1} (q : Trunc α), Nonempty α |
_private.Mathlib.CategoryTheory.Monoidal.Mon_.0.CategoryTheory.MonObj.ofIso._simp_1 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u} {𝒞 : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.MonoidalCategory C] {X₁ Y₁ X₂ Y₂ : C}
(f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj Y₁ Y₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f X₂)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Y₁ g) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) h |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.TacticData.mctxBefore | Mathlib.Tactic.Linter.FlexibleLinter | Mathlib.Linter.Flexible.TacticData✝ → Lean.MetavarContext |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.addIncBeforeAux | Lean.Compiler.LCNF.ExplicitRC | Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.impure) →
(ℕ → Bool) →
Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure →
Lean.Compiler.LCNF.RcM✝ (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure) |
ProofWidgets.instToJsonRpcEncodablePacket.toJson._@.ProofWidgets.Data.Html.2463204861._hygCtx._hyg.58 | ProofWidgets.Data.Html | ProofWidgets.RpcEncodablePacket✝ → Lean.Json |
LinearGrowth.linearGrowthInf_iInf | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {ι : Type u_1} [Finite ι] (u : ι → ℕ → EReal),
LinearGrowth.linearGrowthInf (⨅ i, u i) = ⨅ i, LinearGrowth.linearGrowthInf (u i) |
Array.instOrientedOrd | Init.Data.Order.Ord | ∀ {α : Type u_1} [inst : Ord α] [Std.OrientedOrd α], Std.OrientedOrd (Array α) |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.mkHCongrWithArity.mkProof.match_1 | Lean.Meta.CongrTheorems | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) →
((fst lhs fst_1 snd : Lean.Expr) → motive (some (fst, lhs, fst_1, snd))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive x |
_private.Mathlib.Data.Nat.PartENat.0.PartENat.coe_le_iff._simp_1_1 | Mathlib.Data.Nat.PartENat | ∀ (x y : PartENat), (x ≤ y) = ∃ (h : y.Dom → x.Dom), ∀ (hy : y.Dom), x.get ⋯ ≤ y.get hy |
Even.pow_nonneg | Mathlib.Algebra.Order.Ring.Basic | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : LinearOrder R] [IsOrderedRing R] [ExistsAddOfLE R] {n : ℕ},
Even n → ∀ (a : R), 0 ≤ a ^ n |
Lean.Elab.Command.elabInductiveCommand._regBuiltin.Lean.Elab.Command.elabInductiveCommand_3 | Lean.Elab.Inductive | IO Unit |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_66 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (head : α) (tail : List α) {n s : ℕ}
{h : n < (List.idxsOf x (head :: tail) s).length},
(head == x) = true → (List.idxsOf x (head :: tail) s)[0] - s < (head :: tail).length |
selfAdjoint.instNNRatCast._proof_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Field R] [inst_1 : StarRing R] (q : ℚ≥0), IsSelfAdjoint ↑q |
Array.count_eq_zero_of_not_mem | Init.Data.Array.Count | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {xs : Array α}, a ∉ xs → Array.count a xs = 0 |
Set.countable_iUnion_iff._simp_1 | Mathlib.Data.Set.Countable | ∀ {α : Type u} {ι : Sort x} [Countable ι] {t : ι → Set α}, (⋃ i, t i).Countable = ∀ (i : ι), (t i).Countable |
MeasureTheory.Lp._proof_4 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ (E : Type u_1) [inst : NormedAddCommGroup E], IsTopologicalAddGroup E |
Set.Ioo_sub_one_left_eq_Ioc | Mathlib.Algebra.Order.Interval.Set.SuccPred | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : One α] [inst_2 : Sub α] [PredSubOrder α] [NoMinOrder α] (a b : α),
Set.Ioo (a - 1) b = Set.Ico a b |
LieModule.nontrivial_lowerCentralSeriesLast | Mathlib.Algebra.Lie.Nilpotent | ∀ (R : Type u) (L : Type v) (M : Type w) [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] [LieModule R L M] [Nontrivial M]
[LieModule.IsNilpotent L M], Nontrivial ↥(LieModule.lowerCentralSeriesLast R L M) |
FractionalIdeal.map_coeIdeal | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{P' : Type u_3} [inst_3 : CommRing P'] [inst_4 : Algebra R P'] (g : P →ₐ[R] P') (I : Ideal R),
FractionalIdeal.map g ↑I = ↑I |
Std.DHashMap.Internal.Raw₀.get!ₘ_eq_getValueCast! | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α]
{m : Std.DHashMap.Internal.Raw₀ α β},
Std.DHashMap.Internal.Raw.WFImp ↑m →
∀ {a : α} [inst_3 : Inhabited (β a)],
m.get!ₘ a = Std.Internal.List.getValueCast! a (Std.DHashMap.Internal.toListModel (↑m).buckets) |
_private.Init.Data.Array.Find.0.Array.of_findIdx?_eq_some.match_1.splitter | Init.Data.Array.Find | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((a : α) → motive (some a)) → (Unit → motive none) → motive x |
CategoryTheory.Functor.Monoidal.ε_η | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C} {D : Type u₂}
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} {inst_3 : CategoryTheory.MonoidalCategory D}
(F : CategoryTheory.Functor C D) [self : F.Monoidal],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ε F)
(CategoryTheory.Functor.OplaxMonoidal.η F) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit D) |
FirstOrder.Field.FieldAxiom.toSentence.eq_9 | Mathlib.ModelTheory.Algebra.Field.Basic | FirstOrder.Field.FieldAxiom.existsPairNE.toSentence =
(((FirstOrder.Language.var ∘ Sum.inr) 0).bdEqual ((FirstOrder.Language.var ∘ Sum.inr) 1)).not.ex.ex |
SeparationQuotient.t2Space_iff | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u_1} [inst : TopologicalSpace X], T2Space (SeparationQuotient X) ↔ R1Space X |
BitVec.getLsbD_ofBool | Init.Data.BitVec.Lemmas | ∀ (b : Bool) (i : ℕ), (BitVec.ofBool b).getLsbD i = (decide (i = 0) && b) |
Submodule.span_singleton_mul | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A] {x : A}
{p : Submodule R A}, (R ∙ x) * p = x • p |
div_self_eq_one₀._simp_1 | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, (a / a = 1) = (a ≠ 0) |
_private.Mathlib.Probability.Independence.Basic.0.ProbabilityTheory.iIndepFun_iff._simp_1_2 | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} (m : ι → MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.iIndep m μ =
∀ (s : Finset ι) {f : ι → Set Ω}, (∀ i ∈ s, MeasurableSet (f i)) → μ (⋂ i ∈ s, f i) = ∏ i ∈ s, μ (f i) |
Std.Roo.toList_eq_match_rco | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roo α} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.Rxo.IsAlwaysFinite α],
r.toList =
match Std.PRange.succ? r.lower with
| none => []
| some next => (next...r.upper).toList |
Simps.ProjectionData.mk._flat_ctor | Mathlib.Tactic.Simps.Basic | Lean.Name → Lean.Expr → List ℕ → Bool → Bool → Simps.ProjectionData |
SchwartzMap.smulRightCLM._proof_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_1} (F : Type u_2) {G : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G] [inst_5 : NormedSpace ℝ G]
(L : E →L[ℝ] G →L[ℝ] ℝ) (f g : SchwartzMap E F) (x : E),
(fun f x => (L x).smulRight (f x)) (f + g) x =
(fun f x => (L x).smulRight (f x)) f x + (fun f x => (L x).smulRight (f x)) g x |
Complex.instCoeReal | Mathlib.Data.Complex.Basic | Coe ℝ ℂ |
Std.Iterators.Types.FilterMap.mk.inj | Init.Data.Iterators.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} {lift : ⦃α : Type w⦄ → m α → n α}
{f : β → Std.Iterators.PostconditionT n (Option γ)} {inner inner_1 : Std.IterM m β},
{ inner := inner } = { inner := inner_1 } → inner = inner_1 |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.isTypeFormerType.match_1 | Lean.Compiler.LCNF.ToLCNF | (motive : Option Bool → Sort u_1) →
(x : Option Bool) → ((result : Bool) → motive (some result)) → ((x : Option Bool) → motive x) → motive x |
Subalgebra.instSubringClass | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A],
SubringClass (Subalgebra R A) A |
iSupIndep.linearEquiv_symm_apply | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} {N : Type u_6} [inst : DecidableEq ι] [inst_1 : Ring R] [inst_2 : AddCommGroup N]
[inst_3 : Module R N] {p : ι → Submodule R N} (ind : iSupIndep p) (iSup_top : ⨆ i, p i = ⊤) {i : ι} {x : N}
(h : x ∈ p i), (ind.linearEquiv iSup_top).symm x = fun₀ | i => ⟨x, h⟩ |
_private.Mathlib.Topology.UnitInterval.0.unitInterval.image_coe_preimage_symm._simp_1_1 | Mathlib.Topology.UnitInterval | Function.Involutive unitInterval.symm = True |
HahnSeries.SummableFamily.instAddCommGroup | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_1} →
{R : Type u_3} →
{α : Type u_5} →
[inst : PartialOrder Γ] → [inst_1 : AddCommGroup R] → AddCommGroup (HahnSeries.SummableFamily Γ R α) |
withSeminorms_iInf | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕜 : Type u_2} {E : Type u_6} {ι : Type u_9} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
{κ : ι → Type u_11} {p : (i : ι) → SeminormFamily 𝕜 E (κ i)} {t : ι → TopologicalSpace E},
(∀ (i : ι), WithSeminorms (p i)) → WithSeminorms (SeminormFamily.sigma p) |
with_gaugeSeminormFamily | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : Module 𝕜 E] [inst_4 : Module ℝ E] [inst_5 : IsScalarTower ℝ 𝕜 E] [inst_6 : ContinuousSMul ℝ E]
[IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E] [LocallyConvexSpace 𝕜 E], WithSeminorms (gaugeSeminormFamily 𝕜 E) |
CategoryTheory.Functor.mapArrowEquivalence._proof_2 | Mathlib.CategoryTheory.Comma.Arrow | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (e : C ≌ D) (X : CategoryTheory.Arrow C),
CategoryTheory.CategoryStruct.comp
(e.functor.mapArrow.map (((CategoryTheory.Functor.mapArrowFunctor C C).mapIso e.unitIso).hom.app X))
(((CategoryTheory.Functor.mapArrowFunctor D D).mapIso e.counitIso).hom.app (e.functor.mapArrow.obj X)) =
CategoryTheory.CategoryStruct.id (e.functor.mapArrow.obj X) |
_private.Mathlib.Combinatorics.Extremal.RuzsaSzemeredi.0.ruzsaSzemerediNumberNat_asymptotic_lower_bound._simp_1_2 | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ b ≥ a, p b |
Submonoid.unitsEquivUnitsType._proof_6 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) (x x_1 : ↥S.units),
(match x * x_1 with
| ⟨val, h⟩ =>
{ val := ⟨(Units.coeHom M) val, ⋯⟩, inv := ⟨(Units.coeHom M) val⁻¹, ⋯⟩, val_inv := ⋯, inv_val := ⋯ }) =
match x * x_1 with
| ⟨val, h⟩ => { val := ⟨(Units.coeHom M) val, ⋯⟩, inv := ⟨(Units.coeHom M) val⁻¹, ⋯⟩, val_inv := ⋯, inv_val := ⋯ } |
CommBialgCat._sizeOf_1 | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} → {inst : CommRing R} → [SizeOf R] → CommBialgCat R → ℕ |
Int64.ofIntLE_eq_ofIntTruncate | Init.Data.SInt.Lemmas | ∀ {x : ℤ} {h₁ : Int64.minValue.toInt ≤ x} {h₂ : x ≤ Int64.maxValue.toInt}, Int64.ofIntLE x h₁ h₂ = Int64.ofIntTruncate x |
Mathlib.Explode.Entry.type | Mathlib.Tactic.Explode.Datatypes | Mathlib.Explode.Entry → Lean.MessageData |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Basic.0.SkewMonoidAlgebra.instAddGroup._simp_6 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {a b : G →₀ k},
{ toFinsupp := a } + { toFinsupp := b } = { toFinsupp := a + b } |
Lean.Elab.Tactic.Omega.Fact.mk.sizeOf_spec | Lean.Elab.Tactic.Omega.Core | ∀ (coeffs : Lean.Omega.Coeffs) (constraint : Lean.Omega.Constraint)
(justification : Lean.Elab.Tactic.Omega.Justification constraint coeffs),
sizeOf { coeffs := coeffs, constraint := constraint, justification := justification } =
1 + sizeOf coeffs + sizeOf constraint + sizeOf justification |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.nhdsWithin_bot.match_1_1 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ (x : ℝ) (x_1 : EReal) (motive : x_1 ∈ Set.Ioc ⊥ ↑x → Prop) (x_2 : x_1 ∈ Set.Ioc ⊥ ↑x),
(∀ (h1 : ⊥ < x_1) (h2 : x_1 ≤ ↑x), motive ⋯) → motive x_2 |
Lean.Parser.Command.in._regBuiltin.Lean.Parser.Command.in.parenthesizer_11 | Lean.Parser.Command | IO Unit |
WeierstrassCurve.natDegree_Φ_pos | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) [Nontrivial R] {n : ℤ}, n ≠ 0 → 0 < (W.Φ n).natDegree |
_private.Lean.Meta.Sym.Simp.EvalGround.0.Lean.Meta.Sym.Simp.evalUnaryUInt8 | Lean.Meta.Sym.Simp.EvalGround | (UInt8 → UInt8) → Lean.Expr → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkNoConfusion.match_1 | Lean.Meta.AppBuilder | (motive : Option (Lean.ConstructorVal × Array Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.ConstructorVal × Array Lean.Expr)) →
((ctorB : Lean.ConstructorVal) → (ys2 : Array Lean.Expr) → motive (some (ctorB, ys2))) →
((x : Option (Lean.ConstructorVal × Array Lean.Expr)) → motive x) → motive __do_lift |
SSet.Truncated.HomotopyCategory.homMk_comp_homMk_assoc | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {V : SSet.Truncated 2}
{x₀ x₁ x₂ : V.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.OneTruncation₂._proof_1 })}
{e₀₁ : SSet.Truncated.Edge x₀ x₁} {e₁₂ : SSet.Truncated.Edge x₁ x₂} {e₀₂ : SSet.Truncated.Edge x₀ x₂}
(h : e₀₁.CompStruct e₁₂ e₀₂) {Z : V.HomotopyCategory} (h : SSet.Truncated.HomotopyCategory.mk x₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp (SSet.Truncated.HomotopyCategory.homMk e₀₁)
(CategoryTheory.CategoryStruct.comp (SSet.Truncated.HomotopyCategory.homMk e₁₂) h) =
CategoryTheory.CategoryStruct.comp (SSet.Truncated.HomotopyCategory.homMk e₀₂) h |
Algebra.Extension.cotangentComplex | Mathlib.RingTheory.Extension.Cotangent.Basic | {R : Type u} →
{S : Type v} →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → (P : Algebra.Extension R S) → P.Cotangent →ₗ[S] P.CotangentSpace |
MonoidWithZeroHom.fst_apply_coe | Mathlib.Algebra.GroupWithZero.ProdHom | ∀ {G₀ : Type u_1} {H₀ : Type u_2} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero H₀] (x : G₀ˣ × H₀ˣ),
(MonoidWithZeroHom.fst G₀ H₀) ↑x = ↑x.1 |
DoubleCentralizer.natCast_toProd | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] (n : ℕ), (↑n).toProd = ↑n |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.toList_insert_perm._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
CategoryTheory.ComposableArrows.Mk₁.map.eq_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X₀ X₁ : C} (f : X₀ ⟶ X₁) (isLt isLt_1 : 1 < 2)
(x_3 : ⟨1, isLt⟩ ≤ ⟨1, isLt_1⟩),
CategoryTheory.ComposableArrows.Mk₁.map f ⟨1, isLt⟩ ⟨1, isLt_1⟩ x_3 =
CategoryTheory.CategoryStruct.id (CategoryTheory.ComposableArrows.Mk₁.obj X₀ X₁ ⟨1, isLt⟩) |
AbsoluteValue.trivial._proof_3 | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {R : Type u_2} [inst : Semiring R] [inst_1 : DecidablePred fun x => x = 0] {S : Type u_1} [inst_2 : Semiring S]
[Nontrivial S] (x : R), (if x = 0 then 0 else 1) = 0 ↔ x = 0 |
HomologicalComplex.homology.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.Acyclic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K K_1 : HomologicalComplex C c) (e_K : K = K_1) (i i_1 : ι) (e_i : i = i_1)
[inst_2 : K.HasHomology i], K.homology i = K_1.homology i_1 |
CategoryTheory.HasInjectiveResolutions.mk._flat_ctor | 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), CategoryTheory.HasInjectiveResolution Z) → CategoryTheory.HasInjectiveResolutions C |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.shortCircuitPass.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ShortCircuit | (motive : Option (Array Lean.FVarId × Lean.MVarId) → Sort u_1) →
(result? : Option (Array Lean.FVarId × Lean.MVarId)) →
((fst : Array Lean.FVarId) → (newGoal : Lean.MVarId) → motive (some (fst, newGoal))) →
((x : Option (Array Lean.FVarId × Lean.MVarId)) → motive x) → motive result? |
Nat.isSome_getElem?_toArray_ric_eq | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n i : ℕ}, ((*...=n).toArray[i]?.isSome = true) = (i ≤ n) |
Lean.IR.EmitLLVM.getEnv | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} → Lean.IR.EmitLLVM.M llvmctx Lean.Environment |
_private.Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer.0.CategoryTheory.Limits.WalkingMulticospan.instFinCategoryOfLOfDecidableEqR._simp_4 | Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer | ∀ {α : Type u_1} {a : α} {s : Multiset α}, (a ::ₘ s).Nodup = (a ∉ s ∧ s.Nodup) |
Lean.Meta.Grind.Order.Struct.mk.noConfusion | Lean.Meta.Tactic.Grind.Order.Types | {P : Sort u} →
{id : ℕ} →
{type : Lean.Expr} →
{u : Lean.Level} →
{isPreorderInst leInst : Lean.Expr} →
{ltInst? isPartialInst? isLinearPreInst? lawfulOrderLTInst? : Option Lean.Expr} →
{ringId? : Option ℕ} →
{isCommRing : Bool} →
{ringInst? orderedRingInst? : Option Lean.Expr} →
{leFn : Lean.Expr} →
{ltFn? : Option Lean.Expr} →
{nodes : Lean.PArray Lean.Expr} →
{nodeMap : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Grind.Order.NodeId} →
{cnstrs :
Lean.PHashMap Lean.Meta.Sym.ExprPtr
(Lean.Meta.Grind.Order.Cnstr Lean.Meta.Grind.Order.NodeId)} →
{cnstrsOf :
Lean.PHashMap (Lean.Meta.Grind.Order.NodeId × Lean.Meta.Grind.Order.NodeId)
(List (Lean.Meta.Grind.Order.Cnstr Lean.Meta.Grind.Order.NodeId × Lean.Expr))} →
{sources targets :
Lean.PArray
(Lean.AssocList Lean.Meta.Grind.Order.NodeId Lean.Meta.Grind.Order.Weight)} →
{proofs :
Lean.PArray
(Lean.AssocList Lean.Meta.Grind.Order.NodeId Lean.Meta.Grind.Order.ProofInfo)} →
{propagate : List Lean.Meta.Grind.Order.ToPropagate} →
{id' : ℕ} →
{type' : Lean.Expr} →
{u' : Lean.Level} →
{isPreorderInst' leInst' : Lean.Expr} →
{ltInst?' isPartialInst?' isLinearPreInst?' lawfulOrderLTInst?' :
Option Lean.Expr} →
{ringId?' : Option ℕ} →
{isCommRing' : Bool} →
{ringInst?' orderedRingInst?' : Option Lean.Expr} →
{leFn' : Lean.Expr} →
{ltFn?' : Option Lean.Expr} →
{nodes' : Lean.PArray Lean.Expr} →
{nodeMap' :
Lean.PHashMap Lean.Meta.Sym.ExprPtr
Lean.Meta.Grind.Order.NodeId} →
{cnstrs' :
Lean.PHashMap Lean.Meta.Sym.ExprPtr
(Lean.Meta.Grind.Order.Cnstr
Lean.Meta.Grind.Order.NodeId)} →
{cnstrsOf' :
Lean.PHashMap
(Lean.Meta.Grind.Order.NodeId ×
Lean.Meta.Grind.Order.NodeId)
(List
(Lean.Meta.Grind.Order.Cnstr
Lean.Meta.Grind.Order.NodeId ×
Lean.Expr))} →
{sources' targets' :
Lean.PArray
(Lean.AssocList Lean.Meta.Grind.Order.NodeId
Lean.Meta.Grind.Order.Weight)} →
{proofs' :
Lean.PArray
(Lean.AssocList Lean.Meta.Grind.Order.NodeId
Lean.Meta.Grind.Order.ProofInfo)} →
{propagate' :
List Lean.Meta.Grind.Order.ToPropagate} →
{ id := id, type := type, u := u,
isPreorderInst := isPreorderInst,
leInst := leInst, ltInst? := ltInst?,
isPartialInst? := isPartialInst?,
isLinearPreInst? := isLinearPreInst?,
lawfulOrderLTInst? := lawfulOrderLTInst?,
ringId? := ringId?,
isCommRing := isCommRing,
ringInst? := ringInst?,
orderedRingInst? := orderedRingInst?,
leFn := leFn, ltFn? := ltFn?,
nodes := nodes, nodeMap := nodeMap,
cnstrs := cnstrs, cnstrsOf := cnstrsOf,
sources := sources, targets := targets,
proofs := proofs, propagate := propagate } =
{ id := id', type := type', u := u',
isPreorderInst := isPreorderInst',
leInst := leInst', ltInst? := ltInst?',
isPartialInst? := isPartialInst?',
isLinearPreInst? := isLinearPreInst?',
lawfulOrderLTInst? := lawfulOrderLTInst?',
ringId? := ringId?',
isCommRing := isCommRing',
ringInst? := ringInst?',
orderedRingInst? := orderedRingInst?',
leFn := leFn', ltFn? := ltFn?',
nodes := nodes', nodeMap := nodeMap',
cnstrs := cnstrs', cnstrsOf := cnstrsOf',
sources := sources', targets := targets',
proofs := proofs',
propagate := propagate' } →
(id = id' →
type = type' →
u = u' →
isPreorderInst = isPreorderInst' →
leInst = leInst' →
ltInst? = ltInst?' →
isPartialInst? = isPartialInst?' →
isLinearPreInst? =
isLinearPreInst?' →
lawfulOrderLTInst? =
lawfulOrderLTInst?' →
ringId? = ringId?' →
isCommRing = isCommRing' →
ringInst? = ringInst?' →
orderedRingInst? =
orderedRingInst?' →
leFn = leFn' → ⋯) →
P |
Function.Injective.leftCancelMonoid | Mathlib.Algebra.Group.InjSurj | {M₁ : Type u_1} →
{M₂ : Type u_2} →
[inst : Mul M₁] →
[inst_1 : One M₁] →
[inst_2 : Pow M₁ ℕ] →
[inst_3 : LeftCancelMonoid M₂] →
(f : M₁ → M₂) →
Function.Injective f →
f 1 = 1 →
(∀ (x y : M₁), f (x * y) = f x * f y) →
(∀ (x : M₁) (n : ℕ), f (x ^ n) = f x ^ n) → LeftCancelMonoid M₁ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.