name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
PadicInt.residueField._proof_5 | Mathlib.NumberTheory.Padics.RingHoms | ∀ {p : ℕ} [hp_prime : Fact (Nat.Prime p)], Function.Surjective ⇑PadicInt.toZMod | false |
PosNum.commMonoid._proof_1 | Mathlib.Data.Num.Lemmas | ∀ (a b c : PosNum), a * b * c = a * (b * c) | false |
Padic.mk_eq | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] {f g : PadicSeq p}, Padic.mk f = Padic.mk g ↔ f ≈ g | true |
RCLike.norm_of_nonneg' | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] {x : K}, 0 ≤ x → ↑‖x‖ = x | true |
CategoryTheory.Idempotents.KaroubiKaroubi.counitIso_hom_app_f_f | Mathlib.CategoryTheory.Idempotents.KaroubiKaroubi | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C]
(P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Idempotents.Karoubi C)),
((CategoryTheory.Idempotents.KaroubiKaroubi.counitIso C).hom.app P).f.f = P.p.f | true |
UInt8.add_left_neg | Init.Data.UInt.Lemmas | ∀ (a : UInt8), -a + a = 0 | true |
Lean.Elab.Term.instAddErrorMessageContextTermElabM | Lean.Elab.Term.TermElabM | Lean.AddErrorMessageContext Lean.Elab.TermElabM | true |
Prod.totallyDisconnectedSpace | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [TotallyDisconnectedSpace α]
[TotallyDisconnectedSpace β], TotallyDisconnectedSpace (α × β) | true |
_private.Mathlib.Analysis.Asymptotics.Defs.0.Asymptotics.IsBigO.comp_snd._simp_1_1 | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F} {l : Filter α},
f =O[l] g = ∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ | false |
Lean.Lsp.ServerCapabilities.renameProvider? | Lean.Data.Lsp.Capabilities | Lean.Lsp.ServerCapabilities → Option Lean.Lsp.RenameOptions | true |
_private.Mathlib.Data.Erased.0.Erased.mk_out.match_1_1 | Mathlib.Data.Erased | ∀ {α : Sort u_1} (motive : Erased α → Prop) (x : Erased α),
(∀ (s : α → Prop) (h : ∃ a, (fun x => a = x) = s), motive ⟨s, h⟩) → motive x | false |
_private.Batteries.Data.List.Perm.0.List.cons_subperm_of_not_mem_of_mem.match_1_3 | Batteries.Data.List.Perm | ∀ {α : Type u_1} {a : α} {l₂ l₁ : List α} (motive : (a :: l₁).Subperm l₂ → Prop) (x : (a :: l₁).Subperm l₂),
(∀ (t : List α) (p' : t.Perm (a :: l₁)) (s' : t.Sublist l₂), motive ⋯) → motive x | false |
Subbimodule.mk._proof_2 | Mathlib.Algebra.Module.Bimodule | ∀ {M : Type u_1} [inst : AddCommMonoid M] (p : AddSubmonoid M), 0 ∈ p.carrier | false |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.trans._proof_4 | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [P.IsStableUnderBaseChange]
{S : AlgebraicGeometry.Scheme} {𝒰 : S.OpenCover} {i : 𝒰.I₀}, P.IsStableUnderBaseChangeAlong (𝒰.f i) | false |
Ideal.comap_map_of_bijective | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
[inst_3 : RingHomClass F R S], Function.Bijective ⇑f → ∀ {I : Ideal R}, Ideal.comap f (Ideal.map f I) = I | true |
MeasureTheory.ae_ball_iff | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {ι : Type u_4} {S : Set ι},
S.Countable →
∀ {p : α → (i : ι) → i ∈ S → Prop},
(∀ᵐ (x : α) ∂μ, ∀ (i : ι) (hi : i ∈ S), p x i hi) ↔ ∀ (i : ι) (hi : i ∈ S), ∀ᵐ (x : α) ∂μ, p x i hi | true |
_private.Batteries.Data.List.Lemmas.0.List.forIn'_cons.match_1.eq_1 | Batteries.Data.List.Lemmas | ∀ {β : Type u_1} (motive : ForInStep β → Sort u_2) (b : β) (h_1 : (b : β) → motive (ForInStep.done b))
(h_2 : (b : β) → motive (ForInStep.yield b)),
(match ForInStep.done b with
| ForInStep.done b => h_1 b
| ForInStep.yield b => h_2 b) =
h_1 b | true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.IsTuranMaximal.not_adj_trans._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | false |
MeasureTheory.addMeasure_map_restrict_apply | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α]
(μ : MeasureTheory.Measure α) (s : Set α) {U : Set (Quotient (AddAction.orbitRel G α))},
MeasurableSet U →
(MeasureTheory.Measure.map (Quotient.mk (AddAction.orbitRel G α)) (μ.restrict s)) U =
μ (Quotient.mk (AddAction.orbitRel G α) ⁻¹' U ∩ s) | true |
HahnSeries.embDomain | Mathlib.RingTheory.HahnSeries.Basic | {Γ : Type u_1} →
{Γ' : Type u_2} →
{R : Type u_3} →
[inst : PartialOrder Γ] →
[inst_1 : Zero R] → [inst_2 : PartialOrder Γ'] → Γ ↪o Γ' → HahnSeries Γ R → HahnSeries Γ' R | true |
Std.DTreeMap.Internal.Impl.Const.getKey?_alter | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α] (h : t.WF)
{k k' : α} {f : Option β → Option β},
(Std.DTreeMap.Internal.Impl.Const.alter k f t ⋯).impl.getKey? k' =
if compare k k' = Ordering.eq then
if (f (Std.DTreeMap.Internal.Impl.Const.get? t k)).isSome = true then some k else none
else t.getKey? k' | true |
OrderIso.emptySumLex_apply_inr | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] [inst_2 : IsEmpty β] (x : α),
OrderIso.emptySumLex (toLex (Sum.inr x)) = x | true |
Pi.addCancelCommMonoid | Mathlib.Algebra.Group.Pi.Basic | {I : Type u} → {f : I → Type v₁} → [(i : I) → AddCancelCommMonoid (f i)] → AddCancelCommMonoid ((i : I) → f i) | true |
Std.Time.instReprDuration | Std.Time.Duration | Repr Std.Time.Duration | true |
Lean.Doc.Block._sizeOf_2_eq | Lean.DocString.Types | ∀ {i : Type u} {b : Type v} [inst : SizeOf i] [inst_1 : SizeOf b] (x : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))),
Lean.Doc.Block._sizeOf_2 x = sizeOf x | false |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.reduceProjFn?.match_3 | Lean.Meta.Tactic.Simp.Main | (motive : Option Lean.Expr → Sort u_1) →
(e? : Option Lean.Expr) → (Unit → motive none) → ((e : Lean.Expr) → motive (some e)) → motive e? | false |
_private.Mathlib.AlgebraicTopology.SimplicialObject.Basic.0.CategoryTheory.SimplicialObject.δ_comp_δ''._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op | false |
ModuleCat.instModuleElemForallObjCompForgetLinearMapIdCarrierSections._proof_8 | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u_4} [inst : Ring R] {J : Type u_1} [inst_1 : CategoryTheory.Category.{u_3, u_1} J]
(F : CategoryTheory.Functor J (ModuleCat R)) (x : ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections), 0 • x = 0 | false |
_private.Mathlib.Tactic.Linarith.Frontend.0.Mathlib.Tactic.elabLinarithConfig.match_1 | Mathlib.Tactic.Linarith.Frontend | (motive :
DoResultPR Mathlib.Tactic.Linarith.LinarithConfig Mathlib.Tactic.Linarith.LinarithConfig PUnit.{1} → Sort u_1) →
(r : DoResultPR Mathlib.Tactic.Linarith.LinarithConfig Mathlib.Tactic.Linarith.LinarithConfig PUnit.{1}) →
((a : Mathlib.Tactic.Linarith.LinarithConfig) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Mathlib.Tactic.Linarith.LinarithConfig) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r | false |
Submonoid.LocalizationMap.mk' | Mathlib.GroupTheory.MonoidLocalization.Basic | {M : Type u_1} →
[inst : CommMonoid M] →
{S : Submonoid M} → {N : Type u_2} → [inst_1 : CommMonoid N] → S.LocalizationMap N → M → ↥S → N | true |
CategoryTheory.ShortComplex.LeftHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork_φH | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0) (c : CategoryTheory.Limits.CokernelCofork S.f)
(hc : CategoryTheory.Limits.IsColimit c),
(CategoryTheory.ShortComplex.LeftHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork S hf hg c hc).φH =
CategoryTheory.Limits.Cofork.π c | true |
powCardSubgroup._proof_3 | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Group G] [inst_1 : Fintype G] (S : Set G),
1 ∈ S ^ Fintype.card G → S ^ Fintype.card G * S ^ Fintype.card G = S ^ Fintype.card G | false |
_private.ImportGraph.Tools.FindHome.0.Lean.Name.findHome.match_1 | ImportGraph.Tools.FindHome | (motive : Option Lean.Environment → Sort u_1) →
(env : Option Lean.Environment) →
((env : Lean.Environment) → motive (some env)) → ((x : Option Lean.Environment) → motive x) → motive env | false |
Lean.Grind.CommRing.Expr.toPolyS._sunfold | Init.Grind.Ring.CommSemiringAdapter | Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Poly | false |
Lean.instBEqAttributeKind.beq | Lean.Attributes | Lean.AttributeKind → Lean.AttributeKind → Bool | true |
CategoryTheory.Subgroupoid.mk.injEq | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (arrows : (c d : C) → Set (c ⟶ d))
(inv : ∀ {c d : C} {p : c ⟶ d}, p ∈ arrows c d → CategoryTheory.Groupoid.inv p ∈ arrows d c)
(mul :
∀ {c d e : C} {p : c ⟶ d},
p ∈ arrows c d → ∀ {q : d ⟶ e}, q ∈ arrows d e → CategoryTheory.CategoryStruct.comp p q ∈ arrows c e)
(arrows_1 : (c d : C) → Set (c ⟶ d))
(inv_1 : ∀ {c d : C} {p : c ⟶ d}, p ∈ arrows_1 c d → CategoryTheory.Groupoid.inv p ∈ arrows_1 d c)
(mul_1 :
∀ {c d e : C} {p : c ⟶ d},
p ∈ arrows_1 c d → ∀ {q : d ⟶ e}, q ∈ arrows_1 d e → CategoryTheory.CategoryStruct.comp p q ∈ arrows_1 c e),
({ arrows := arrows, inv := inv, mul := mul } = { arrows := arrows_1, inv := inv_1, mul := mul_1 }) =
(arrows = arrows_1) | true |
DFinsupp.Lex.orderBot._proof_1 | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → AddCommMonoid (α i)] (x : ι), x ∈ ∅ ∨ 0 x = 0 | false |
Batteries.RBNode.find?.eq_2 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} (cut : α → Ordering) (c : Batteries.RBColor) (l : Batteries.RBNode α) (v : α) (r : Batteries.RBNode α),
Batteries.RBNode.find? cut (Batteries.RBNode.node c l v r) =
match cut v with
| Ordering.lt => Batteries.RBNode.find? cut l
| Ordering.gt => Batteries.RBNode.find? cut r
| Ordering.eq => some v | true |
NFA.Path.ctorElimType | Mathlib.Computability.NFA | {α : Type u} →
{σ : Type v} →
{M : NFA α σ} →
{motive : (a a_1 : σ) → (a_2 : List α) → M.Path a a_1 a_2 → Sort u_1} →
ℕ → Sort (max 1 (imax (v + 1) u_1) (imax (v + 1) (v + 1) (v + 1) (u + 1) (u + 1) (max (u + 1) (v + 1)) u_1)) | false |
_private.Mathlib.Computability.TuringMachine.Config.0.Turing.ToPartrec.Code.eval.match_1.eq_1 | Mathlib.Computability.TuringMachine.Config | ∀ (motive : Turing.ToPartrec.Code → Sort u_1) (h_1 : Unit → motive Turing.ToPartrec.Code.zero')
(h_2 : Unit → motive Turing.ToPartrec.Code.succ) (h_3 : Unit → motive Turing.ToPartrec.Code.tail)
(h_4 : (f fs : Turing.ToPartrec.Code) → motive (f.cons fs)) (h_5 : (f g : Turing.ToPartrec.Code) → motive (f.comp g))
(h_6 : (f g : Turing.ToPartrec.Code) → motive (f.case g)) (h_7 : (f : Turing.ToPartrec.Code) → motive f.fix),
(match Turing.ToPartrec.Code.zero' with
| Turing.ToPartrec.Code.zero' => h_1 ()
| Turing.ToPartrec.Code.succ => h_2 ()
| Turing.ToPartrec.Code.tail => h_3 ()
| f.cons fs => h_4 f fs
| f.comp g => h_5 f g
| f.case g => h_6 f g
| f.fix => h_7 f) =
h_1 () | true |
_private.Lean.Meta.Basic.0.Lean.Meta.DefEqCacheKey.mk.inj | Lean.Meta.Basic | ∀ {lhs rhs : Lean.Expr} {configKey : UInt64} {lhs_1 rhs_1 : Lean.Expr} {configKey_1 : UInt64},
{ lhs := lhs, rhs := rhs, configKey := configKey } = { lhs := lhs_1, rhs := rhs_1, configKey := configKey_1 } →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ configKey = configKey_1 | true |
AlgebraicGeometry.locallyQuasiFinite_iff_isFinite_fiber | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [AlgebraicGeometry.QuasiCompact f],
AlgebraicGeometry.LocallyQuasiFinite f ↔
∀ (x : ↥Y), AlgebraicGeometry.IsFinite (AlgebraicGeometry.Scheme.Hom.fiberToSpecResidueField f x) | true |
MeasureTheory.TendstoInDistribution.add_of_tendstoInMeasure_const | Mathlib.MeasureTheory.Function.ConvergenceInDistribution | ∀ {ι : Type u_1} {E : Type u_2} {Ω' : Type u_3} {Ω'' : Type u_4} {m' : MeasurableSpace Ω'}
{μ' : MeasureTheory.Measure Ω'} [inst : MeasureTheory.IsProbabilityMeasure μ'] {m'' : MeasurableSpace Ω''}
{μ'' : MeasureTheory.Measure Ω''} [inst_1 : MeasureTheory.IsProbabilityMeasure μ''] {mE : MeasurableSpace E}
{Z : Ω' → E} {l : Filter ι} [inst_2 : SeminormedAddCommGroup E] [SecondCountableTopology E] [inst_4 : BorelSpace E]
{X Y : ι → Ω'' → E} [l.IsCountablyGenerated] {c : E},
MeasureTheory.TendstoInDistribution X l Z (fun x => μ'') μ' →
(MeasureTheory.TendstoInMeasure μ'' Y l fun x => c) →
(∀ (i : ι), AEMeasurable (Y i) μ'') →
MeasureTheory.TendstoInDistribution (fun n => X n + Y n) l (fun ω => Z ω + c) (fun x => μ'') μ' | true |
WithTop.decidableEq._aux_1 | Mathlib.Order.WithBot | {α : Type u_1} → [DecidableEq α] → DecidableEq (WithTop α) | false |
Std.DTreeMap.Raw.Equiv.constInsertMany_list | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
t₁.WF →
t₂.WF →
t₁.Equiv t₂ →
∀ (l : List (α × β)), (Std.DTreeMap.Raw.Const.insertMany t₁ l).Equiv (Std.DTreeMap.Raw.Const.insertMany t₂ l) | true |
BoolAlg.Iso.mk._proof_9 | Mathlib.Order.Category.BoolAlg | ∀ {α β : BoolAlg} (e : ↑α ≃o ↑β) (a b : ↑β), e.symm (a ⊔ b) = e.symm a ⊔ e.symm b | false |
CategoryTheory.GradedObject.TriangleIndexData.casesOn | Mathlib.CategoryTheory.GradedObject.Unitor | {I₁ : Type u_1} →
{I₂ : Type u_2} →
{I₃ : Type u_3} →
{J : Type u_4} →
[inst : Zero I₂] →
{r : I₁ × I₂ × I₃ → J} →
{π : I₁ × I₃ → J} →
{motive : CategoryTheory.GradedObject.TriangleIndexData r π → Sort u} →
(t : CategoryTheory.GradedObject.TriangleIndexData r π) →
((p₁₂ : I₁ × I₂ → I₁) →
(hp₁₂ : ∀ (i : I₁ × I₂ × I₃), π (p₁₂ (i.1, i.2.1), i.2.2) = r i) →
(p₂₃ : I₂ × I₃ → I₃) →
(hp₂₃ : ∀ (i : I₁ × I₂ × I₃), π (i.1, p₂₃ i.2) = r i) →
(h₁ : ∀ (i₁ : I₁), p₁₂ (i₁, 0) = i₁) →
(h₃ : ∀ (i₃ : I₃), p₂₃ (0, i₃) = i₃) →
motive { p₁₂ := p₁₂, hp₁₂ := hp₁₂, p₂₃ := p₂₃, hp₂₃ := hp₂₃, h₁ := h₁, h₃ := h₃ }) →
motive t | false |
cauchySeq_of_controlled | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : SemilatticeSup β] [Nonempty β] (U : β → SetRel α α),
(∀ s ∈ uniformity α, ∃ n, U n ⊆ s) → ∀ {f : β → α}, (∀ ⦃N m n : β⦄, N ≤ m → N ≤ n → (f m, f n) ∈ U N) → CauchySeq f | true |
_private.Mathlib.Logic.Relation.0.Relation.onFun_map_eq_of_injective.match_1_1 | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {β : Sort u_2} {r : α → α → Prop} {f : α → β} (x y : α)
(motive : Function.onFun (Relation.Map r f f) f x y → Prop) (x_1 : Function.onFun (Relation.Map r f f) f x y),
(∀ (x' y' : α) (hr : r x' y') (hx : f x' = f x) (hy : f y' = f y), motive ⋯) → motive x_1 | false |
VectorField.mlieBracketWithin_eq_zero_of_eq_zero | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {x : M} {V W : (x : M) → TangentSpace I x},
V x = 0 → W x = 0 → VectorField.mlieBracketWithin I V W s x = 0 | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_neg._simp_1_3 | Init.Data.BitVec.Bitblast | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | false |
groupCohomology.H1π_comp_H1IsoOfIsTrivial_hom_assoc | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) [inst_2 : A.IsTrivial] {Z : ModuleCat k}
(h : ModuleCat.of k (Additive G →+ ↑A) ⟶ Z),
CategoryTheory.CategoryStruct.comp (groupCohomology.H1π A)
(CategoryTheory.CategoryStruct.comp (groupCohomology.H1IsoOfIsTrivial A).hom h) =
CategoryTheory.CategoryStruct.comp (groupCohomology.cocycles₁IsoOfIsTrivial A).hom h | true |
SemimoduleCat.ofHom₂ | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u_1} →
[inst : CommSemiring R] → {M N P : SemimoduleCat R} → (↑M →ₗ[R] ↑N →ₗ[R] ↑P) → (M ⟶ SemimoduleCat.of R (N ⟶ P)) | true |
CategoryTheory.Join.mapPairEquiv._proof_1 | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u_7} [inst : CategoryTheory.Category.{u_5, u_7} C] {D : Type u_8}
[inst_1 : CategoryTheory.Category.{u_6, u_8} D] {C' : Type u_3} [inst_2 : CategoryTheory.Category.{u_1, u_3} C']
{D' : Type u_4} [inst_3 : CategoryTheory.Category.{u_2, u_4} D'] (e : C ≌ C') (e' : D ≌ D')
(x : CategoryTheory.Join C D),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Join.mapPair e.functor e'.functor).map
((CategoryTheory.Join.mapPairId.symm ≪≫
CategoryTheory.Join.mapIsoWhiskerRight e.unitIso (CategoryTheory.Functor.id D) ≪≫
CategoryTheory.Join.mapIsoWhiskerLeft (e.functor.comp e.inverse) e'.unitIso ≪≫
CategoryTheory.Join.mapPairComp e.functor e'.functor e.inverse e'.inverse).hom.app
x))
(((CategoryTheory.Join.mapPairComp e.inverse e'.inverse e.functor e'.functor).symm ≪≫
CategoryTheory.Join.mapIsoWhiskerRight e.counitIso (e'.inverse.comp e'.functor) ≪≫
CategoryTheory.Join.mapIsoWhiskerLeft (CategoryTheory.Functor.id C') e'.counitIso ≪≫
CategoryTheory.Join.mapPairId).hom.app
((CategoryTheory.Join.mapPair e.functor e'.functor).obj x)) =
CategoryTheory.CategoryStruct.id ((CategoryTheory.Join.mapPair e.functor e'.functor).obj x) | false |
LinearPMap.eq_of_eq_graph | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {f g : E →ₗ.[R] F}, f.graph = g.graph → f = g | true |
Lean.Lsp.LeanLocationLink.ctorIdx | Lean.Data.Lsp.Internal | Lean.Lsp.LeanLocationLink → ℕ | false |
WeakDual.isClosed_closedBall | Mathlib.Analysis.Normed.Module.WeakDual | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : SeminormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (x' : StrongDual 𝕜 E) (r : ℝ), IsClosed (⇑WeakDual.toStrongDual ⁻¹' Metric.closedBall x' r) | true |
Real.volume_real_ball | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {a r : ℝ}, 0 ≤ r → MeasureTheory.volume.real (Metric.ball a r) = 2 * r | true |
CategoryTheory.MorphismProperty.exists_map_eq_of_presieve | Mathlib.CategoryTheory.MorphismProperty.CommaSites | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.MorphismProperty C} {S : C}
[P.IsStableUnderComposition],
∀ K ≤ P.precoverage,
∀ {X : P.Over ⊤ S} {R : CategoryTheory.Presieve ((CategoryTheory.MorphismProperty.Over.forget P ⊤ S).obj X)},
R ∈
(CategoryTheory.Precoverage.comap (CategoryTheory.Over.forget S) K).coverings
((CategoryTheory.MorphismProperty.Over.forget P ⊤ S).obj X) →
∃ T, CategoryTheory.Presieve.map (CategoryTheory.MorphismProperty.Over.forget P ⊤ S) T = R | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.bvNormalize.go._sparseCasesOn_1 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
AddSubmonoid.closure_induction | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : AddZeroClass M] {s : Set M} {motive : (x : M) → x ∈ AddSubmonoid.closure s → Prop},
(∀ (x : M) (h : x ∈ s), motive x ⋯) →
motive 0 ⋯ →
(∀ (x y : M) (hx : x ∈ AddSubmonoid.closure s) (hy : y ∈ AddSubmonoid.closure s),
motive x hx → motive y hy → motive (x + y) ⋯) →
∀ {x : M} (hx : x ∈ AddSubmonoid.closure s), motive x hx | true |
Lean.Server.Watchdog.LogData.noConfusion | Lean.Server.Watchdog | {P : Sort u} → {t t' : Lean.Server.Watchdog.LogData} → t = t' → Lean.Server.Watchdog.LogData.noConfusionType P t t' | false |
Int.testBit_lnot | Mathlib.Data.Int.Bitwise | ∀ (n : ℤ) (k : ℕ), n.lnot.testBit k = !n.testBit k | true |
ExistsContDiffBumpBase.w._proof_1 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | false |
SzemerediRegularity.initialBound._proof_1 | Mathlib.Combinatorics.SimpleGraph.Regularity.Bound | (99 + 1).AtLeastTwo | false |
Pi.lex_lt_of_lt | Mathlib.Order.PiLex | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → PartialOrder (β i)] {r : ι → ι → Prop},
WellFounded r → ∀ {x y : (i : ι) → β i}, x < y → Pi.Lex r (fun {i} x1 x2 => x1 < x2) x y | true |
Lean.Lsp.CodeActionLiteralSupportValueSet | Lean.Data.Lsp.CodeActions | Type | true |
hasBasis_nhdsSet_Ici_Ioi | Mathlib.Topology.Order.NhdsSet | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α] (a : α) [Nonempty ↑(Set.Iio a)],
(nhdsSet (Set.Ici a)).HasBasis (fun x => x < a) Set.Ioi | true |
_private.Mathlib.Data.Real.ConjExponents.0.ENNReal.HolderConjugate.toNNReal_iff._simp_1_1 | Mathlib.Data.Real.ConjExponents | ∀ {p q r : NNReal}, p.HolderTriple q r = (↑p).HolderTriple ↑q ↑r | false |
Aesop.MVarCluster.state | Aesop.Tree.Data | Aesop.MVarCluster → Aesop.NodeState | true |
Primrec.eq | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : Primcodable α], PrimrecRel Eq | true |
OrderDual.mulLeftMono | Mathlib.Algebra.Order.Monoid.Unbundled.OrderDual | ∀ {α : Type u} [inst : LE α] [inst_1 : Mul α] [c : MulLeftMono α], MulLeftMono αᵒᵈ | true |
eventually_mem_nhds_iff | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (∀ᶠ (x' : X) in nhds x, s ∈ nhds x') ↔ s ∈ nhds x | true |
Subgroup.quotientiInfSubgroupOfEmbedding_apply | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {ι : Type u_2} (f : ι → Subgroup α) (H : Subgroup α)
(q : ↥H ⧸ (⨅ i, f i).subgroupOf H) (i : ι),
(Subgroup.quotientiInfSubgroupOfEmbedding f H) q i = Subgroup.quotientSubgroupOfMapOfLE H ⋯ q | true |
_private.Lean.Compiler.LCNF.ReduceArity.0.Lean.Compiler.LCNF.Decl.reduceArity.match_3 | Lean.Compiler.LCNF.ReduceArity | (motive :
MProd (Subarray (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure))
(Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
Sort u_1) →
(r :
MProd (Subarray (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure))
(Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure))) →
((__s : Subarray (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) →
(args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) → motive ⟨__s, args⟩) →
motive r | false |
dotProduct_star_self_nonneg | Mathlib.LinearAlgebra.Matrix.DotProduct | ∀ {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : PartialOrder R] [inst_2 : NonUnitalRing R]
[inst_3 : StarRing R] [StarOrderedRing R] (v : n → R), 0 ≤ star v ⬝ᵥ v | true |
Plausible.TotalFunction.noConfusionType | Plausible.Functions | Sort u_1 →
{α : Type u} →
{β : Type v} →
Plausible.TotalFunction α β → {α' : Type u} → {β' : Type v} → Plausible.TotalFunction α' β' → Sort u_1 | false |
MeasureTheory.TendstoInDistribution.casesOn | Mathlib.MeasureTheory.Function.ConvergenceInDistribution | {ι : Type u_1} →
{E : Type u_2} →
{Ω' : Type u_3} →
{Ω : ι → Type u_5} →
{m : (i : ι) → MeasurableSpace (Ω i)} →
{m' : MeasurableSpace Ω'} →
{mE : MeasurableSpace E} →
[inst : TopologicalSpace E] →
[inst_1 : OpensMeasurableSpace E] →
{X : (i : ι) → Ω i → E} →
{l : Filter ι} →
{Z : Ω' → E} →
{μ : (i : ι) → MeasureTheory.Measure (Ω i)} →
[inst_2 : ∀ (i : ι), MeasureTheory.IsProbabilityMeasure (μ i)] →
{μ' : MeasureTheory.Measure Ω'} →
[inst_3 : MeasureTheory.IsProbabilityMeasure μ'] →
{motive : MeasureTheory.TendstoInDistribution X l Z μ μ' → Sort u} →
(t : MeasureTheory.TendstoInDistribution X l Z μ μ') →
((forall_aemeasurable : ∀ (i : ι), AEMeasurable (X i) (μ i)) →
(aemeasurable_limit : AEMeasurable Z μ') →
(tendsto :
Filter.Tendsto (fun n => ⟨MeasureTheory.Measure.map (X n) (μ n), ⋯⟩) l
(nhds ⟨MeasureTheory.Measure.map Z μ', ⋯⟩)) →
motive ⋯) →
motive t | false |
LinearMap.baseChange_add | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid N] [inst_5 : Module R M]
[inst_6 : Module R N] (f g : M →ₗ[R] N),
LinearMap.baseChange A (f + g) = LinearMap.baseChange A f + LinearMap.baseChange A g | true |
FreeSimplexQuiver.homRel.σ_comp_σ | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {n : ℕ} {i j : Fin (n + 1)},
i ≤ j →
FreeSimplexQuiver.homRel
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i))) | true |
nndist_comm | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), nndist x y = nndist y x | true |
Std.DTreeMap.Raw.get_insertMany_list_of_contains_eq_false | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] [inst_2 : BEq α] [inst_3 : Std.LawfulBEqCmp cmp] (h : t.WF) {l : List ((a : α) × β a)}
{k : α} (contains : (List.map Sigma.fst l).contains k = false) {h' : k ∈ t.insertMany l},
(t.insertMany l).get k h' = t.get k ⋯ | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.addSplitCandidatesForFunext | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → ℕ → optParam (Option Lean.Expr) none → Lean.Meta.Grind.GoalM Unit | true |
Equiv.cast_eq_iff_heq | Mathlib.Logic.Equiv.Defs | ∀ {α β : Sort u_1} (h : α = β) {a : α} {b : β}, (Equiv.cast h) a = b ↔ a ≍ b | true |
Lean.Parser.Attr.tactic_name._regBuiltin.Lean.Parser.Attr.tactic_name_1 | Lean.Parser.Attr | IO Unit | false |
_private.Mathlib.Data.Sum.Basic.0.Sum.getLeft_eq_getLeft?._proof_1_2 | Mathlib.Data.Sum.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α ⊕ β},
x.getLeft?.isSome = true → ∀ (val : α), Sum.inl val = x → (some val).isSome = true | false |
Matrix.cons_vecAlt1 | Mathlib.Data.Fin.VecNotation | ∀ {α : Type u} {m n : ℕ} (h : m + 1 + 1 = n + 1 + (n + 1)) (x y : α) (u : Fin m → α),
Matrix.vecAlt1 h (Matrix.vecCons x (Matrix.vecCons y u)) = Matrix.vecCons y (Matrix.vecAlt1 ⋯ u) | true |
ENNReal.lintegral_mul_le_Lp_mul_Lq | Mathlib.MeasureTheory.Integral.MeanInequalities | ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) {p q : ℝ},
p.HolderConjugate q →
∀ {f g : α → ENNReal},
AEMeasurable f μ →
AEMeasurable g μ →
∫⁻ (a : α), (f * g) a ∂μ ≤ (∫⁻ (a : α), f a ^ p ∂μ) ^ (1 / p) * (∫⁻ (a : α), g a ^ q ∂μ) ^ (1 / q) | true |
MulRingSeminorm.toFun_eq_coe | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_1} [inst : NonAssocRing R] (p : MulRingSeminorm R), ⇑p.toAddGroupSeminorm = ⇑p | true |
Lean.Server.Test.Runner.Client.NormalizeState.knownPtrs | Lean.Server.Test.Runner | Lean.Server.Test.Runner.Client.NormalizeState → Std.TreeMap USize USize compare | true |
HahnSeries.SummableFamily.smul_eq | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} {β : Type u_6} [inst : PartialOrder Γ]
[inst_1 : PartialOrder Γ'] [inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid R] [inst_4 : SMulWithZero R V]
[inst_5 : VAdd Γ Γ'] [inst_6 : IsOrderedCancelVAdd Γ Γ'] {x : HahnSeries Γ R} {t : HahnSeries.SummableFamily Γ' V β},
x • t = HahnSeries.SummableFamily.Equiv (Equiv.punitProd β) ((HahnSeries.SummableFamily.const Unit x).smul t) | true |
Metric.tendsto_nhds | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] {f : Filter β} {u : β → α} {a : α},
Filter.Tendsto u f (nhds a) ↔ ∀ ε > 0, ∀ᶠ (x : β) in f, dist (u x) a < ε | true |
_private.Mathlib.Data.Matrix.Invertible.0.Matrix.add_mul_mul_invOf_mul_eq_one._simp_1_1 | Mathlib.Data.Matrix.Invertible | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : NonUnitalSemiring α]
[inst_1 : Fintype m] [inst_2 : Fintype n] (L : Matrix l m α) (M : Matrix m n α) (N : Matrix n o α),
L * (M * N) = L * M * N | false |
CategoryTheory.Abelian.SpectralObject.dHomologyData_left_K | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{i₀ i₁ i₂ i₃ i₄ i₅ i₆ i₇ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅)
(f₆ : i₅ ⟶ i₆) (f₇ : i₆ ⟶ i₇) (f₂₃ : i₁ ⟶ i₃) (h₂₃ : CategoryTheory.CategoryStruct.comp f₂ f₃ = f₂₃) (f₅₆ : i₄ ⟶ i₆)
(h₅₆ : CategoryTheory.CategoryStruct.comp f₅ f₆ = f₅₆) (n₀ n₁ n₂ n₃ n₄ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.dHomologyData._auto_1)
(hn₂ : autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.dHomologyData._auto_3)
(hn₃ : autoParam (n₂ + 1 = n₃) CategoryTheory.Abelian.SpectralObject.dHomologyData._auto_5)
(hn₄ : autoParam (n₃ + 1 = n₄) CategoryTheory.Abelian.SpectralObject.dHomologyData._auto_7),
(X.dHomologyData f₁ f₂ f₃ f₄ f₅ f₆ f₇ f₂₃ h₂₃ f₅₆ h₅₆ n₀ n₁ n₂ n₃ n₄ hn₁ hn₂ hn₃ hn₄).left.K =
X.E f₂₃ f₄ f₅ n₁ n₂ n₃ ⋯ ⋯ | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint_preserves_invariant_helper._proof_1_19 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ}
(acc :
Array Std.Tactic.BVDecide.LRAT.Internal.Assignment ×
Std.Sat.CNF.Clause (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) × Bool × Bool)
(l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) (i : Fin n),
↑i + 1 ≤ (acc.1.modify (↑l.1) (Std.Tactic.BVDecide.LRAT.Internal.Assignment.addAssignment l.2)).size →
↑i < (acc.1.modify (↑l.1) (Std.Tactic.BVDecide.LRAT.Internal.Assignment.addAssignment l.2)).size | false |
Vector.toArray_swapIfInBounds | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i j : ℕ}, (xs.swapIfInBounds i j).toArray = xs.toArray.swapIfInBounds i j | true |
LocallyConstant.congrLeftₗ_symm_apply_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {Z : Type u_6} (R : Type u_7)
[inst_2 : Semiring R] [inst_3 : AddCommMonoid Z] [inst_4 : Module R Z] (e : X ≃ₜ Y) (a : LocallyConstant Y Z)
(a_1 : X), ((LocallyConstant.congrLeftₗ R e).symm a) a_1 = a (e a_1) | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.instIteratorIdSearchStep._simp_32 | Init.Data.String.Pattern.String | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
AddOpposite.instAddMonoid._proof_4 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : AddMonoid α] (x : ℕ) (x_1 : αᵃᵒᵖ),
AddOpposite.op ((x + 1) • AddOpposite.unop x_1) = AddOpposite.op (x • AddOpposite.unop x_1) + x_1 | false |
Lean.Lsp.LeanDidOpenTextDocumentParams._sizeOf_1 | Lean.Data.Lsp.Extra | Lean.Lsp.LeanDidOpenTextDocumentParams → ℕ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.