name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Sbtw.left_mem_image_Ioi | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R]
[inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P] {x y z : P},
Sbtw R x y z → x ∈ ⇑(AffineMap.lineMap z y) '' Set.Ioi 1 | true |
FractionalIdeal.coeIdeal_span_singleton | 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]
[inst_3 : IsLocalization S P] (x : R), ↑(Ideal.span {x}) = FractionalIdeal.spanSingleton S ((algebraMap R P) x) | true |
sSupHom.cancel_left._simp_2 | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SupSet α] [inst_1 : SupSet β] [inst_2 : SupSet γ]
{g : sSupHom β γ} {f₁ f₂ : sSupHom α β}, Function.Injective ⇑g → (g.comp f₁ = g.comp f₂) = (f₁ = f₂) | false |
Lean.Server.Test.Runner.processWaitForILeans | Lean.Server.Test.Runner | Lean.Server.Test.Runner.RunnerM Unit | true |
div_lt_div_right_of_neg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b c : α},
c < 0 → (a / c < b / c ↔ b < a) | true |
SemilatInfCat._sizeOf_inst | Mathlib.Order.Category.Semilat | SizeOf SemilatInfCat | false |
LinearEquiv.smul_id_of_finrank_eq_one.eq_1 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_2} [inst : CommSemiring R] [inst_1 : StrongRankCondition R] {M : Type u_3} [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] [inst_4 : Module.Free R M] (d1 : Module.finrank R M = 1),
LinearEquiv.smul_id_of_finrank_eq_one d1 =
{ toFun := fun c => c • LinearMap.id, map_add' := ⋯, map_smul' := ⋯, invFun := fun u => Exists.choose ⋯,
left_inv := ⋯, right_inv := ⋯ } | true |
MagmaCat.coe_id | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X : MagmaCat}, ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) = id | true |
Subgroup.IsSubnormal.below.rec | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : Group G] {motive : (a : Subgroup G) → a.IsSubnormal → Prop}
{motive_1 : {a : Subgroup G} → (t : a.IsSubnormal) → Subgroup.IsSubnormal.below t → Prop},
motive_1 ⋯ ⋯ →
(∀ (H K : Subgroup G) (h_le : H ≤ K) (hSubn : K.IsSubnormal) (hN : (H.subgroupOf K).Normal)
(ih : Subgroup.IsSubnormal.below hSubn) (hSubn_ih : motive K hSubn), motive_1 hSubn ih → motive_1 ⋯ ⋯) →
∀ {a : Subgroup G} {t : a.IsSubnormal} (t_1 : Subgroup.IsSubnormal.below t), motive_1 t t_1 | false |
_private.Mathlib.Algebra.Polynomial.EraseLead.0.Polynomial.card_support_eq'._simp_1_1 | Mathlib.Algebra.Polynomial.EraseLead | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ | false |
MeasureTheory.Measure.MutuallySingular.restrict_nullSet | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} (h : μ.MutuallySingular ν),
μ.restrict h.nullSet = 0 | true |
Set.eqOn_mulIndicator | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : One M] {s : Set α} {f : α → M}, Set.EqOn (s.mulIndicator f) f s | true |
HVertexOperator.coeff_inj_iff | Mathlib.Algebra.Vertex.HVertexOperator | ∀ {Γ : Type u_1} [inst : PartialOrder Γ] {R : Type u_2} {V : Type u_3} {W : Type u_4} [inst_1 : CommRing R]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [inst_4 : AddCommGroup W] [inst_5 : Module R W]
{a₁ a₂ : HVertexOperator Γ R V W}, a₁ = a₂ ↔ HVertexOperator.coeff a₁ = HVertexOperator.coeff a₂ | true |
Lean.Elab.Term.Do.ToTerm.Kind.forIn.elim | Lean.Elab.Do.Legacy | {motive : Lean.Elab.Term.Do.ToTerm.Kind → Sort u} →
(t : Lean.Elab.Term.Do.ToTerm.Kind) → t.ctorIdx = 1 → motive Lean.Elab.Term.Do.ToTerm.Kind.forIn → motive t | false |
Lean.Import.mk.injEq | Lean.Setup | ∀ (module : Lean.Name) (importAll isExported isMeta : Bool) (module_1 : Lean.Name)
(importAll_1 isExported_1 isMeta_1 : Bool),
({ module := module, importAll := importAll, isExported := isExported, isMeta := isMeta } =
{ module := module_1, importAll := importAll_1, isExported := isExported_1, isMeta := isMeta_1 }) =
(module = module_1 ∧ importAll = importAll_1 ∧ isExported = isExported_1 ∧ isMeta = isMeta_1) | true |
CategoryTheory.Limits.colimit.toCostructuredArrow | Mathlib.CategoryTheory.Limits.ConeCategory | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor J C) →
[inst_2 : CategoryTheory.Limits.HasColimit F] →
CategoryTheory.Functor J (CategoryTheory.CostructuredArrow F (CategoryTheory.Limits.colimit F)) | true |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.part_mem._simp_1_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (l : Finset α) (hp : ∃! a, a ∈ l ∧ p a),
(Finset.choose p l hp ∈ l) = True | false |
Mathlib.Tactic.Linarith.CompSource.noConfusionType | Mathlib.Tactic.Linarith.Oracle.FourierMotzkin | Sort u → Mathlib.Tactic.Linarith.CompSource → Mathlib.Tactic.Linarith.CompSource → Sort u | false |
_private.Std.Tactic.Do.Syntax.0.Lean.Parser.Tactic.instReprMCasesPat.repr.match_1 | Std.Tactic.Do.Syntax | (motive : Lean.Parser.Tactic.MCasesPat → Sort u_1) →
(x : Lean.Parser.Tactic.MCasesPat) →
((a : Lean.TSyntax `Lean.binderIdent) → motive (Lean.Parser.Tactic.MCasesPat.one a)) →
(Unit → motive Lean.Parser.Tactic.MCasesPat.clear) →
((a : List Lean.Parser.Tactic.MCasesPat) → motive (Lean.Parser.Tactic.MCasesPat.tuple a)) →
((a : List Lean.Parser.Tactic.MCasesPat) → motive (Lean.Parser.Tactic.MCasesPat.alts a)) →
((a : Lean.TSyntax `Lean.binderIdent) → motive (Lean.Parser.Tactic.MCasesPat.pure a)) →
((a : Lean.TSyntax `Lean.binderIdent) → motive (Lean.Parser.Tactic.MCasesPat.stateful a)) → motive x | false |
Qq.Impl.MVarSynth.term.elim | Qq.Macro | {motive : Qq.Impl.MVarSynth → Sort u} →
(t : Qq.Impl.MVarSynth) →
t.ctorIdx = 0 →
((quotedType : Lean.Expr) →
(unquotedMVar : Lean.MVarId) → motive (Qq.Impl.MVarSynth.term quotedType unquotedMVar)) →
motive t | false |
Filter.map_add_atTop_eq_nat | Mathlib.Order.Filter.AtTopBot.Basic | ∀ (k : ℕ), Filter.map (fun a => a + k) Filter.atTop = Filter.atTop | true |
IsLUB.inter_Ici_of_mem | Mathlib.Order.Bounds.Basic | ∀ {γ : Type u_3} [inst : LinearOrder γ] {s : Set γ} {a b : γ}, IsLUB s a → b ∈ s → IsLUB (s ∩ Set.Ici b) a | true |
Setoid.mapOfSurjective_eq_map | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : Setoid α} {f : α → β} (h : Setoid.ker f ≤ r) (hf : Function.Surjective f),
r.map f = r.mapOfSurjective f h hf | true |
Std.Iterators.ProductivenessRelation.mk.noConfusion | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{inst : Std.Iterator α m β} →
{P : Sort u} →
{Rel : Std.IterM m β → Std.IterM m β → Prop} →
{wf : WellFounded Rel} →
{subrelation : ∀ {it it' : Std.IterM m β}, it'.IsPlausibleSkipSuccessorOf it → Rel it' it} →
{Rel' : Std.IterM m β → Std.IterM m β → Prop} →
{wf' : WellFounded Rel'} →
{subrelation' : ∀ {it it' : Std.IterM m β}, it'.IsPlausibleSkipSuccessorOf it → Rel' it' it} →
{ Rel := Rel, wf := wf, subrelation := subrelation } =
{ Rel := Rel', wf := wf', subrelation := subrelation' } →
(Rel ≍ Rel' → P) → P | false |
ZeroAtInftyContinuousMap.instIsCentralScalar | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β] {R : Type u_2}
[inst_3 : Zero R] [inst_4 : SMulWithZero R β] [inst_5 : SMulWithZero Rᵐᵒᵖ β] [inst_6 : ContinuousConstSMul R β]
[inst_7 : IsCentralScalar R β], IsCentralScalar R (ZeroAtInftyContinuousMap α β) | true |
_private.Mathlib.Data.Finset.Union.0.Finset.mem_disjiUnion._simp_1_1 | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ s) = (a ∈ s.val) | false |
CategoryTheory.instAbelianOpposite._proof_4 | Mathlib.CategoryTheory.Abelian.Opposite | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
CategoryTheory.Limits.HasKernels Cᵒᵖ | false |
NonUnitalSubsemiring.toSubsemiring | Mathlib.Algebra.Ring.Subsemiring.Defs | {R : Type u} → [inst : NonAssocSemiring R] → (S : NonUnitalSubsemiring R) → 1 ∈ S → Subsemiring R | true |
exists_nonarchimedean_pow_mul_seminorm_of_finiteDimensional | Mathlib.Analysis.Normed.Unbundled.FiniteExtension | ∀ {K : Type u_1} {L : Type u_2} [inst : NormedField K] [inst_1 : Field L] [inst_2 : Algebra K L],
FiniteDimensional K L →
IsNonarchimedean norm → ∃ f, IsPowMul ⇑f ∧ (∀ (x : K), f ((algebraMap K L) x) = ‖x‖) ∧ IsNonarchimedean ⇑f | true |
CategoryTheory.CosimplicialObject.δ_comp_σ_self'_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.CosimplicialObject C) {n : ℕ}
{j : Fin (n + 2)} {i : Fin (n + 1)},
j = i.castSucc →
∀ {Z : C} (h : X.obj (SimplexCategory.mk n) ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.δ j) (CategoryTheory.CategoryStruct.comp (X.σ i) h) = h | true |
Std.Time.Internal.UnitVal.recOn | Std.Time.Internal.UnitVal | {α : ℚ} →
{motive : Std.Time.Internal.UnitVal α → Sort u} →
(t : Std.Time.Internal.UnitVal α) → ((val : ℤ) → motive { val := val }) → motive t | false |
CategoryTheory.ObjectProperty.InheritedFromSource.of_hom_of_source | Mathlib.CategoryTheory.ObjectProperty.InheritedFromHom | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {P : CategoryTheory.ObjectProperty C}
{Q : CategoryTheory.MorphismProperty C} [self : P.InheritedFromSource Q] {X Y : C} (f : X ⟶ Y), Q f → P X → P Y | true |
Vector.isNone_finIdxOf? | Batteries.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] [PartialEquivBEq α] {v : Vector α n} {a : α},
(v.finIdxOf? a).isNone = !v.contains a | true |
SetLike.exists_of_lt | Mathlib.Data.SetLike.Basic | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : PartialOrder A] [IsConcreteLE A B] {p q : A},
p < q → ∃ x ∈ q, x ∉ p | true |
ConjAct.Subgroup.val_conj_smul | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ {G : Type u_3} [inst : Group G] {H : Subgroup G} [inst_1 : H.Normal] (g : ConjAct G) (h : ↥H), ↑(g • h) = g • ↑h | true |
OpenPartialHomeomorph.MDifferentiable | Mathlib.Geometry.Manifold.MFDeriv.Defs | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
ModelWithCorners 𝕜 E H →
{M : Type u_4} →
[inst_4 : TopologicalSpace M] →
[ChartedSpace H M] →
{E' : Type u_5} →
[inst_6 : NormedAddCommGroup E'] →
[inst_7 : NormedSpace 𝕜 E'] →
{H' : Type u_6} →
[inst_8 : TopologicalSpace H'] →
ModelWithCorners 𝕜 E' H' →
{M' : Type u_7} →
[inst : TopologicalSpace M'] →
[ChartedSpace H' M'] → OpenPartialHomeomorph M M' → Prop | true |
HasFibers.Fib.isoMk | Mathlib.CategoryTheory.FiberedCategory.HasFibers | {𝒮 : Type u₁} →
{𝒳 : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳] →
{p : CategoryTheory.Functor 𝒳 𝒮} →
[inst_2 : HasFibers p] →
{S : 𝒮} →
{a b : HasFibers.Fib p S} →
(Φ : (HasFibers.ι S).obj a ≅ (HasFibers.ι S).obj b) →
p.IsHomLift (CategoryTheory.CategoryStruct.id S) Φ.hom → (a ≅ b) | true |
groupCohomology.isoCocycles₁ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep.{u, u, u} k G) → groupCohomology.cocycles A 1 ≅ ModuleCat.of k ↥(groupCohomology.cocycles₁ A) | true |
RightCancelSemigroup.ctorIdx | Mathlib.Algebra.Group.Defs | {G : Type u} → RightCancelSemigroup G → ℕ | false |
Set.inter_eq_right | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, s ∩ t = t ↔ t ⊆ s | true |
AddCancelMonoid.toIsCancelAdd | Mathlib.Algebra.Group.Defs | ∀ (M : Type u) [inst : AddCancelMonoid M], IsCancelAdd M | true |
_private.Mathlib.FieldTheory.Finite.Valuation.0.FiniteField.valuation_algebraMap_le_one._proof_1_1 | Mathlib.FieldTheory.Finite.Valuation | ∀ {Fq : Type u_3} {A : Type u_2} {Γ : Type u_1} [inst : Field Fq] [inst_1 : Ring A] [inst_2 : Algebra Fq A]
[inst_3 : LinearOrderedCommMonoidWithZero Γ] (v : Valuation A Γ) (a : Fq), a = 0 → v ((algebraMap Fq A) a) ≤ 1 | false |
AddCon.instDecidableEqQuotientOfDecidableCoeForallProp | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_1} → [inst : Add M] → (c : AddCon M) → [(a b : M) → Decidable (c a b)] → DecidableEq c.Quotient | true |
CategoryTheory.SmallObject.SuccStruct.ιIterationFunctor | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(Φ : CategoryTheory.SmallObject.SuccStruct C) →
(J : Type w) →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
[inst_5 : CategoryTheory.Limits.HasIterationOfShape J C] →
(CategoryTheory.Functor.const J).obj Φ.X₀ ⟶ Φ.iterationFunctor J | true |
CategoryTheory.ObjectProperty.prop_X₁_of_shortExact | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderSubobjects] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {S : CategoryTheory.ShortComplex C},
S.ShortExact → P S.X₂ → P S.X₁ | true |
WithTop.zero.eq_1 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α], WithTop.zero = { zero := ↑0 } | true |
Polynomial.IsDistinguishedAt.casesOn | Mathlib.RingTheory.Polynomial.Eisenstein.Distinguished | {R : Type u_1} →
[inst : CommRing R] →
{f : Polynomial R} →
{I : Ideal R} →
{motive : f.IsDistinguishedAt I → Sort u} →
(t : f.IsDistinguishedAt I) →
((toIsWeaklyEisensteinAt : f.IsWeaklyEisensteinAt I) → (monic : f.Monic) → motive ⋯) → motive t | false |
Lean.Elab.Tactic.withMacroExpansion | Lean.Elab.Tactic.Basic | {α : Type} → Lean.Syntax → Lean.Syntax → Lean.Elab.Tactic.TacticM α → Lean.Elab.Tactic.TacticM α | true |
Measure.eq_prod_of_integral_mul_boundedContinuousFunction | Mathlib.MeasureTheory.Measure.HasOuterApproxClosedProd | ∀ {Z : Type u_3} {T : Type u_4} {mZ : MeasurableSpace Z} [inst : TopologicalSpace Z] [BorelSpace Z]
[HasOuterApproxClosed Z] {mT : MeasurableSpace T} [inst_3 : TopologicalSpace T] [BorelSpace T]
[HasOuterApproxClosed T] {μ : MeasureTheory.Measure Z} {ν : MeasureTheory.Measure T}
{ξ : MeasureTheory.Measure (Z × T)} [MeasureTheory.IsFiniteMeasure μ] [MeasureTheory.IsFiniteMeasure ν]
[MeasureTheory.IsFiniteMeasure ξ],
(∀ (f : BoundedContinuousFunction Z ℝ) (g : BoundedContinuousFunction T ℝ),
∫ (p : Z × T), f p.1 * g p.2 ∂ξ = (∫ (z : Z), f z ∂μ) * ∫ (t : T), g t ∂ν) →
ξ = μ.prod ν | true |
RingTheory.Sequence.IsWeaklyRegular.recIterModByRegularWithRing._unary._proof_29 | Mathlib.RingTheory.Regular.RegularSequence | ∀
(_x :
(x : Type u_1) ×'
(x_1 : CommRing x) ×'
(x_2 : Type u_2) ×'
(x_3 : AddCommGroup x_2) ×'
(x_4 : Module x x_2) ×' (x_5 : List x) ×' RingTheory.Sequence.IsWeaklyRegular x_2 x_5),
RingTheory.Sequence.IsWeaklyRegular _x.2.2.1 _x.2.2.2.2.2.1 | false |
Prod.map_comp_swap | Init.Data.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ),
Prod.map f g ∘ Prod.swap = Prod.swap ∘ Prod.map g f | true |
Std.ExtTreeMap.contains_unitOfList | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [inst_1 : BEq α] [Std.LawfulBEqCmp cmp] {l : List α}
{k : α}, (Std.ExtTreeMap.unitOfList l cmp).contains k = l.contains k | true |
Lean.Compiler.LCNF.Simp.ConstantFold.applyFolders | Lean.Compiler.LCNF.Simp.ConstantFold | Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure →
Lean.SMap Lean.Name Lean.Compiler.LCNF.Simp.ConstantFold.Folder →
Lean.Compiler.LCNF.CompilerM (Option (Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure))) | true |
_private.Lean.Elab.Tactic.Omega.MinNatAbs.0.Lean.Elab.Tactic.Omega.List.nonzeroMinimum_eq_zero_iff._simp_1_3 | Lean.Elab.Tactic.Omega.MinNatAbs | ∀ {α : Type u_1} {xs : List α} [inst : Min α], (xs.min? = none) = (xs = []) | false |
SummableLocallyUniformly | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | {α : Type u_1} →
{β : Type u_2} → {ι : Type u_3} → [AddCommMonoid α] → (ι → β → α) → [UniformSpace α] → [TopologicalSpace β] → Prop | true |
PNat.coe_toPNat' | Mathlib.Data.PNat.Defs | ∀ (n : ℕ+), (↑n).toPNat' = n | true |
Mathlib.Tactic.PNatToNat.tacticPnat_positivity | Mathlib.Tactic.PNatToNat | Lean.ParserDescr | true |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.ProtocolExtensionKind.recOn | Lean.Server.ProtocolOverview | {motive : Lean.Server.Overview.ProtocolExtensionKind✝ → Sort u} →
(t : Lean.Server.Overview.ProtocolExtensionKind✝¹) →
motive Lean.Server.Overview.ProtocolExtensionKind.standard✝ →
motive Lean.Server.Overview.ProtocolExtensionKind.leanSpecificMethod✝ →
((fieldNames : Array Lean.Name) →
motive (Lean.Server.Overview.ProtocolExtensionKind.extendedParameterType✝ fieldNames)) →
((fieldNames : Array Lean.Name) →
motive (Lean.Server.Overview.ProtocolExtensionKind.extendedResponseType✝ fieldNames)) →
((parameterFieldNames responseFieldNames : Array Lean.Name) →
motive
(Lean.Server.Overview.ProtocolExtensionKind.extendedParameterAndResponseType✝ parameterFieldNames
responseFieldNames)) →
((description : String) →
motive (Lean.Server.Overview.ProtocolExtensionKind.standardViolation✝ description)) →
motive t | false |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_10 | Lean.Compiler.NameMangling | ∀ (s : String) (p₀ : s.Pos) (res : Lean.Name) (acc : String) (ucount : ℕ) (hp₀ : ¬p₀ = s.endPos),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun p res => PSigma.casesOn res fun res n => p) fun _x =>
PSum.casesOn _x (fun _x => PSigma.casesOn _x fun p res => p) fun _x =>
PSigma.casesOn _x fun p₀ res => PSigma.casesOn res fun res acc => PSigma.casesOn acc fun acc ucount => p₀)
String.Pos.instWellFoundedRelation).1
(PSum.inr (PSum.inr ⟨p₀.next hp₀, ⟨res, ⟨acc, ucount + 1⟩⟩⟩)) (PSum.inr (PSum.inr ⟨p₀, ⟨res, ⟨acc, ucount⟩⟩⟩)) | false |
Order.isPredPrelimitRecOn._proof_3 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} (b : α) [inst : PartialOrder α] [inst_1 : PredOrder α] (hb : ¬Order.IsPredPrelimit b),
¬IsMin (Classical.choose ⋯) | false |
Lean.Parser.Tactic.Doc.tacticAlternativeExt | Lean.Parser.Tactic.Doc | Lean.PersistentEnvExtension (Lean.Name × Lean.Name) (Lean.Name × Lean.Name) (Lean.NameMap Lean.Name) | true |
Std.DTreeMap.Internal.Const.RicSliceData.range | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} → {β : Type v} → [inst : Ord α] → Std.DTreeMap.Internal.Const.RicSliceData α β → Std.Ric α | true |
MeasurableSpace.comap_bot | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} {g : β → α}, MeasurableSpace.comap g ⊥ = ⊥ | true |
ComplementedLattice.instOrderDual | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] [ComplementedLattice α], ComplementedLattice αᵒᵈ | true |
AlgebraicGeometry.Proj.basicOpenIsoSpec._proof_2 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | ∀ {σ : Type u_2} {A : Type u_1} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (f : A) {m : ℕ},
f ∈ 𝒜 m → 0 < m → CategoryTheory.IsIso (AlgebraicGeometry.Proj.basicOpenToSpec 𝒜 f) | false |
_private.Mathlib.Analysis.Analytic.IsolatedZeros.0.AnalyticOnNhd.eqOn_or_eventually_ne_of_preconnected._simp_1_1 | Mathlib.Analysis.Analytic.IsolatedZeros | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
Lean.Constructor.noConfusionType | Lean.Declaration | Sort u → Lean.Constructor → Lean.Constructor → Sort u | false |
Matrix.cramer_apply | Mathlib.LinearAlgebra.Matrix.Adjugate | ∀ {n : Type v} {α : Type w} [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommRing α] (A : Matrix n n α)
(b : n → α) (i : n), A.cramer b i = (A.updateCol i b).det | true |
IsUniformAddGroup.cauchy_iff_tendsto_swapped | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {G : Type u_4} [inst : AddGroup G] [inst_1 : UniformSpace G] [IsUniformAddGroup G] (𝓕 : Filter G),
Cauchy 𝓕 ↔ 𝓕.NeBot ∧ Filter.Tendsto (fun p => p.2 - p.1) (𝓕 ×ˢ 𝓕) (nhds 0) | true |
Float.isNaN | Init.Data.Float | Float → Bool | true |
Lean.Doc.PostponedCheck.ctorIdx | Lean.Elab.DocString.Builtin.Postponed | Lean.Doc.PostponedCheck → ℕ | false |
Set.preimage_div_const_Iio | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a b : α),
(fun x => x / a) ⁻¹' Set.Iio b = Set.Iio (b * a) | true |
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.functor.congr_simp | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {G G_1 : C} (e_G : G = G_1) [inst_1 : CategoryTheory.Abelian C]
(hG : CategoryTheory.IsSeparator G) {X : C} [inst_2 : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C]
(A₀ A₀_1 : CategoryTheory.Subobject X),
A₀ = A₀_1 →
∀ (J : Type w) [inst_3 : LinearOrder J] [inst_4 : OrderBot J] [inst_5 : SuccOrder J] [inst_6 : WellFoundedLT J],
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.functor hG A₀ J =
CategoryTheory.IsGrothendieckAbelian.generatingMonomorphisms.functor ⋯ A₀_1 J | true |
Lean.Lsp.instToJsonCodeActionLiteralSupportValueSet.toJson | Lean.Data.Lsp.CodeActions | Lean.Lsp.CodeActionLiteralSupportValueSet → Lean.Json | true |
selfAdjoint.instMulSubtypeMemAddSubgroup._proof_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonUnitalCommRing R] [inst_1 : StarRing R] (x y : ↥(selfAdjoint R)), IsSelfAdjoint (↑x * ↑y) | false |
Lean.MonadStateCacheT.instMonadFinally._aux_1 | Lean.Util.MonadCache | {α β : Type} →
{m : Type → Type} →
[inst : BEq α] →
[inst_1 : Hashable α] →
[Monad m] →
[MonadFinally m] →
{α_1 β_1 : Type} →
Lean.MonadStateCacheT α β m α_1 →
(Option α_1 → Lean.MonadStateCacheT α β m β_1) → Lean.MonadStateCacheT α β m (α_1 × β_1) | false |
MeasureTheory.Measure.IsAddHaarMeasure.toIsFiniteMeasureOnCompacts | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_3} {inst : AddGroup G} {inst_1 : TopologicalSpace G} {inst_2 : MeasurableSpace G}
{μ : MeasureTheory.Measure G} [self : μ.IsAddHaarMeasure], MeasureTheory.IsFiniteMeasureOnCompacts μ | true |
Lean.Meta.Grind.AC.ProofM.State.recOn | Lean.Meta.Tactic.Grind.AC.Proof | {motive : Lean.Meta.Grind.AC.ProofM.State → Sort u} →
(t : Lean.Meta.Grind.AC.ProofM.State) →
((cache : Std.HashMap UInt64 Lean.Expr) →
(varDecls : Std.HashMap Lean.Grind.AC.Var Lean.Expr) →
(exprDecls : Std.HashMap Lean.Grind.AC.Expr Lean.Expr) →
(seqDecls : Std.HashMap Lean.Grind.AC.Seq Lean.Expr) →
motive { cache := cache, varDecls := varDecls, exprDecls := exprDecls, seqDecls := seqDecls }) →
motive t | false |
_private.Mathlib.Topology.Order.ScottTopology.0.dirSupInacc_compl._simp_1_5 | Mathlib.Topology.Order.ScottTopology | ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], Disjoint x yᶜ = (x ≤ y) | false |
_private.Batteries.Linter.UnnecessarySeqFocus.0.Batteries.Linter.UnnecessarySeqFocus.unnecessarySeqFocusLinter.match_3 | Batteries.Linter.UnnecessarySeqFocus | (motive : Lean.Syntax.Range × Lean.Syntax → Sort u_1) →
(x : Lean.Syntax.Range × Lean.Syntax) → ((r : Lean.Syntax.Range) → (stx : Lean.Syntax) → motive (r, stx)) → motive x | false |
Std.ExtDHashMap.get!_inter_of_not_mem_left | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{k : α} [inst_1 : Inhabited (β k)], k ∉ m₁ → (m₁ ∩ m₂).get! k = default | true |
Lean.Compiler.LCNF.ToLCNF.Element.casesOn | Lean.Compiler.LCNF.ToLCNF | {motive : Lean.Compiler.LCNF.ToLCNF.Element → Sort u} →
(t : Lean.Compiler.LCNF.ToLCNF.Element) →
((decl : Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.jp decl)) →
((decl : Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.fun decl)) →
((decl : Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.let decl)) →
((p : Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
(cases : Lean.Compiler.LCNF.Cases Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.cases p cases)) →
((p : Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.unreach p)) →
motive t | false |
MulOpposite.isCancelMulZero_iff._simp_1 | Mathlib.Algebra.GroupWithZero.Opposite | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α], IsCancelMulZero αᵐᵒᵖ = IsCancelMulZero α | false |
AddGroupSeminorm.toOne._proof_3 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] [inst_1 : DecidableEq E] (x : E),
(if -x = 0 then 0 else 1) = if x = 0 then 0 else 1 | false |
CategoryTheory.Abelian.AbelianStruct.mk.sizeOf_spec | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{f : X ⟶ Y} [inst_2 : SizeOf C] (kernelFork : CategoryTheory.Limits.KernelFork f)
(isLimitKernelFork : CategoryTheory.Limits.IsLimit kernelFork)
(cokernelCofork : CategoryTheory.Limits.CokernelCofork f)
(isColimitCokernelCofork : CategoryTheory.Limits.IsColimit cokernelCofork) (image : C) (imageπ : X ⟶ image)
(ι_imageπ :
autoParam (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι kernelFork) imageπ = 0)
CategoryTheory.Abelian.AbelianStruct.ι_imageπ._autoParam)
(imageIsCokernel : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ imageπ ι_imageπ))
(imageι : image ⟶ Y)
(imageι_π :
autoParam (CategoryTheory.CategoryStruct.comp imageι (CategoryTheory.Limits.Cofork.π cokernelCofork) = 0)
CategoryTheory.Abelian.AbelianStruct.imageι_π._autoParam)
(imageIsKernel : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι imageι imageι_π))
(fac :
autoParam (CategoryTheory.CategoryStruct.comp imageπ imageι = f)
CategoryTheory.Abelian.AbelianStruct.fac._autoParam),
sizeOf
{ kernelFork := kernelFork, isLimitKernelFork := isLimitKernelFork, cokernelCofork := cokernelCofork,
isColimitCokernelCofork := isColimitCokernelCofork, image := image, imageπ := imageπ, ι_imageπ := ι_imageπ,
imageIsCokernel := imageIsCokernel, imageι := imageι, imageι_π := imageι_π, imageIsKernel := imageIsKernel,
fac := fac } =
1 + sizeOf kernelFork + sizeOf isLimitKernelFork + sizeOf cokernelCofork + sizeOf isColimitCokernelCofork +
sizeOf image +
sizeOf imageπ +
sizeOf ι_imageπ +
sizeOf imageIsCokernel +
sizeOf imageι +
sizeOf imageι_π +
sizeOf imageIsKernel +
sizeOf fac | true |
Std.Internal.IO.Process.constrainedMemory | Std.Internal.Async.Process | IO UInt64 | true |
Matrix.IsAdjMatrix.zero_or_one._autoParam | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | Lean.Syntax | false |
instFieldGaloisField._proof_26 | Mathlib.FieldTheory.Finite.GaloisField | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (n : ℕ), autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | false |
CategoryTheory.Limits.Cofork.ext.congr_simp | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
{s t : CategoryTheory.Limits.Cofork f g} (i i_1 : s.pt ≅ t.pt) (e_i : i = i_1)
(w : CategoryTheory.CategoryStruct.comp s.π i.hom = t.π),
CategoryTheory.Limits.Cofork.ext i w = CategoryTheory.Limits.Cofork.ext i_1 ⋯ | true |
le_sdiff_right._simp_1 | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], (x ≤ y \ x) = (x = ⊥) | false |
MulOpposite.instStarOrderedRing | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : StarRing R] [inst_2 : PartialOrder R] [StarOrderedRing R],
StarOrderedRing Rᵐᵒᵖ | true |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.gaussianReal_add_gaussianReal_of_indepFun._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {R : Type u_1} [inst : Zero R] (n : R) [h : NeZero n], (n = 0) = False | false |
_private.Mathlib.Combinatorics.Configuration.0.Configuration.HasLines.card_le._simp_1_3 | Mathlib.Combinatorics.Configuration | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | false |
Denumerable.ofEquiv._proof_1 | Mathlib.Logic.Denumerable | ∀ (α : Type u_2) {β : Type u_1} [inst : Denumerable α] (e : β ≃ α) (n : ℕ),
∃ a ∈ Encodable.decode n, Encodable.encode a = n | false |
HomogeneousSubsemiring.mk | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Subsemiring | {ι : Type u_1} →
{σ : Type u_2} →
{A : Type u_3} →
[inst : AddMonoid ι] →
[inst_1 : Semiring A] →
[inst_2 : SetLike σ A] →
[inst_3 : AddSubmonoidClass σ A] →
{𝒜 : ι → σ} →
[inst_4 : DecidableEq ι] →
[inst_5 : GradedRing 𝒜] →
(toSubsemiring : Subsemiring A) →
DirectSum.SetLike.IsHomogeneous 𝒜 toSubsemiring → HomogeneousSubsemiring 𝒜 | true |
PhragmenLindelof.eq_zero_on_horizontal_strip | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {a b : ℝ} {f : ℂ → E},
DiffContOnCl ℂ f (Complex.im ⁻¹' Set.Ioo a b) →
(∃ c < Real.pi / (b - a),
∃ B,
f =O[Filter.comap (abs ∘ Complex.re) Filter.atTop ⊓ Filter.principal (Complex.im ⁻¹' Set.Ioo a b)] fun z =>
Real.exp (B * Real.exp (c * |z.re|))) →
(∀ (z : ℂ), z.im = a → f z = 0) → (∀ (z : ℂ), z.im = b → f z = 0) → Set.EqOn f 0 (Complex.im ⁻¹' Set.Icc a b) | true |
_private.Mathlib.Data.Fin.Tuple.NatAntidiagonal.0.List.Nat.antidiagonalTuple_pairwise_pi_lex._simp_1_12 | Mathlib.Data.Fin.Tuple.NatAntidiagonal | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) | false |
Lean.Elab.Do.SavedState._sizeOf_1 | Lean.Elab.Do.Basic | Lean.Elab.Do.SavedState → ℕ | false |
CategoryTheory.Limits.Cofork.isColimitCoforkPushoutEquivIsColimitForkUnopPullback._proof_12 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : Cᵒᵖ} {f : X ⟶ Y}, f.unop = f.unop | false |
AddSubmonoid.addGroupMultiples._proof_5 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : AddMonoid M] {x : M} {n : ℕ},
n • x = 0 →
∀ (m : ℕ) (x_1 : ↥(AddSubmonoid.multiples x)), ↑((↑m.succ).natMod ↑n • x_1) = ↑((↑m).natMod ↑n • x_1 + x_1) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.