name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Expr.ProdTree.prod.sizeOf_spec | Mathlib.Tactic.ProdAssoc | ∀ (fst snd : Lean.Expr.ProdTree) (lfst lsnd : Lean.Level),
sizeOf (fst.prod snd lfst lsnd) = 1 + sizeOf fst + sizeOf snd + sizeOf lfst + sizeOf lsnd | true |
Mathlib.Meta.FunProp.FunctionData.getFnConstName? | Mathlib.Tactic.FunProp.FunctionData | Mathlib.Meta.FunProp.FunctionData → Lean.MetaM (Option Lean.Name) | true |
CategoryTheory.Comma.inv_right._simp_1 | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T}
{R : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L R} (e : X ⟶ Y) [inst_3 : CategoryTheory.IsIso e],
CategoryTheory.inv e.right = (CategoryTheory.inv e).right | false |
CategoryTheory.Under.postCongr_hom_app_right | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{X : T} {F G : CategoryTheory.Functor T D} (e : F ≅ G) (X_1 : CategoryTheory.Under X),
((CategoryTheory.Under.postCongr e).hom.app X_1).right = e.hom.app X_1.right | true |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Markov.0.MeasureTheory.ae_eq_of_ae_le_of_lintegral_le._simp_1_2 | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | false |
CategoryTheory.Endofunctor.Algebra.Hom.rec | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C C} →
{A₀ A₁ : CategoryTheory.Endofunctor.Algebra F} →
{motive : A₀.Hom A₁ → Sort u_1} →
((f : A₀.a ⟶ A₁.a) →
(h : CategoryTheory.CategoryStruct.comp (F.map f) A₁.str = CategoryTheory.CategoryStruct.comp A₀.str f) →
motive { f := f, h := h }) →
(t : A₀.Hom A₁) → motive t | false |
Lean.Compiler.LCNF.Decl.ctorIdx | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Decl pu → ℕ | false |
ProbabilityTheory.IndepFun.add_hasPDF | Mathlib.Probability.Density | ∀ {Ω : Type u_1} {G : Type u_2} {mΩ : MeasurableSpace Ω} {ℙ : MeasureTheory.Measure Ω} [inst : AddGroup G]
{mG : MeasurableSpace G} [MeasurableAdd₂ G] [MeasurableNeg G] {μ : MeasureTheory.Measure G} [μ.IsAddLeftInvariant]
{X Y : Ω → G} [MeasureTheory.SFinite μ] [MeasureTheory.HasPDF X ℙ μ] [MeasureTheory.HasPDF Y ℙ μ]
[MeasureTheory.IsFiniteMeasure ℙ], ProbabilityTheory.IndepFun X Y ℙ → MeasureTheory.HasPDF (X + Y) ℙ μ | true |
_private.Mathlib.CategoryTheory.Functor.TypeValuedFlat.0.CategoryTheory.FunctorToTypes.fromOverFunctorElementsEquivalence._proof_2 | Mathlib.CategoryTheory.Functor.TypeValuedFlat | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F : CategoryTheory.Functor C (Type u_1)) {X : C}
(x : F.obj X) {X_1 Y : (CategoryTheory.FunctorToTypes.fromOverFunctor F x).Elements} (f : X_1 ⟶ Y),
↑((CategoryTheory.FunctorToTypes.fromOverFunctor F x).map (↑f) X_1.snd) = ↑Y.snd | false |
Lean.Meta.DefEqContext.noConfusionType | Lean.Meta.Basic | Sort u → Lean.Meta.DefEqContext → Lean.Meta.DefEqContext → Sort u | false |
CochainComplex.mappingCone.desc._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | -1 + 1 = 0 | false |
MeasureTheory.eLpNorm_indicator_const' | Mathlib.MeasureTheory.Function.LpSeminorm.Indicator | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} {ε : Type u_7}
[inst : TopologicalSpace ε] [inst_1 : ESeminormedAddMonoid ε] {c : ε} {s : Set α},
MeasurableSet s → μ s ≠ 0 → p ≠ 0 → MeasureTheory.eLpNorm (s.indicator fun x => c) p μ = ‖c‖ₑ * μ s ^ (1 / p.toReal) | true |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.Iso.app._proof_3 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F G : CategoryTheory.Functor C D} (α : F ≅ G) (X : C),
CategoryTheory.CategoryStruct.comp (α.inv.app X) (α.hom.app X) = CategoryTheory.CategoryStruct.id (G.obj X) | false |
Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof.cancelDen.elim | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_2 : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof) →
t.ctorIdx = 1 →
((c : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstr) →
(val : ℤ) →
(x n : Lean.Grind.Linarith.Var) →
motive_2 (Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof.cancelDen c val x n)) →
motive_2 t | false |
_private.Mathlib.RingTheory.Polynomial.IsIntegral.0.MvPolynomial.isIntegral_iff_isIntegral_coeff._proof_1_1 | Mathlib.RingTheory.Polynomial.IsIntegral | ∀ {S : Type u_2} [inst : CommRing S] {σ : Type u_1} {f : MvPolynomial σ S} (n : σ →₀ ℕ) (g : MvPolynomial (↥f.vars) S),
n ∉ Set.range (Finsupp.mapDomain Subtype.val) →
∀ (u : ↥f.vars →₀ ℕ), Finsupp.mapDomain Subtype.val u = n → MvPolynomial.coeff u g = 0 | false |
Lean.Grind.AC.Seq.insert_k | Init.Grind.AC | Lean.Grind.AC.Var → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq | true |
SingularManifold.instIsEmptyMEmpty | Mathlib.Geometry.Manifold.Bordism | ∀ {X : Type u_1} [inst : TopologicalSpace X] {k : WithTop ℕ∞} {E : Type u_4} {H : Type u_5} {M : Type u_6}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [inst_3 : FiniteDimensional ℝ E]
[inst_4 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} [inst_5 : TopologicalSpace M] [inst_6 : ChartedSpace H M]
[inst_7 : IsManifold I k M] [inst_8 : IsEmpty M], IsEmpty (SingularManifold.empty X M I).M | true |
ValuationSubring.instLinearOrderedCommGroupWithZeroValueGroup._proof_50 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K),
autoParam (∀ (a b : A.ValueGroup), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam | false |
Finsupp.llift._proof_3 | Mathlib.LinearAlgebra.Finsupp.LSum | ∀ (M : Type u_1) (R : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (X : Type u_2),
Function.LeftInverse (Finsupp.lift M R X).invFun (Finsupp.lift M R X).toFun | false |
LinearMap.IsNonneg.mk._flat_ctor | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{I₁ I₂ : R →+* R} [inst_3 : LE R] {B : M →ₛₗ[I₁] M →ₛₗ[I₂] R}, (∀ (x : M), 0 ≤ (B x) x) → B.IsNonneg | false |
Monoid.CoprodI.of_apply | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] {i : ι} (m : M i),
Monoid.CoprodI.of m = (conGen (Monoid.CoprodI.Rel M)).mk' (FreeMonoid.of ⟨i, m⟩) | true |
List.isChain_pair | Mathlib.Data.List.Chain | ∀ {α : Type u} {R : α → α → Prop} {x y : α}, List.IsChain R [x, y] ↔ R x y | true |
Cardinal.add_lt_aleph0_iff | Mathlib.SetTheory.Cardinal.Basic | ∀ {a b : Cardinal.{u_1}}, a + b < Cardinal.aleph0 ↔ a < Cardinal.aleph0 ∧ b < Cardinal.aleph0 | true |
Prod.instAsymmLex_mathlib | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} [Std.Asymm r] [Std.Asymm s],
Std.Asymm (Prod.Lex r s) | true |
EuclideanQuadrant.ext | Mathlib.Geometry.Manifold.Instances.Real | ∀ {n : ℕ} (x y : EuclideanQuadrant n), ↑x = ↑y → x = y | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.Defs.0.hasProd_fintype_support._simp_1_2 | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | false |
USize.toUInt16_div | Init.Data.UInt.Lemmas | ∀ (a b : USize), a < 65536 → b < 65536 → (a / b).toUInt16 = a.toUInt16 / b.toUInt16 | true |
CategoryTheory.Precoverage.toPretopology | Mathlib.CategoryTheory.Sites.Pretopology | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
(J : CategoryTheory.Precoverage C) →
[J.HasIsos] → [J.IsStableUnderBaseChange] → [J.IsStableUnderComposition] → CategoryTheory.Pretopology C | true |
finFunctionFinEquiv | Mathlib.Algebra.BigOperators.Fin | {m n : ℕ} → (Fin n → Fin m) ≃ Fin (m ^ n) | true |
Function.update_one | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {I : Type u} {f : I → Type v} [inst : (i : I) → One (f i)] [inst_1 : DecidableEq I] (i : I), Function.update 1 i 1 = 1 | true |
Lean.Meta.RefinedDiscrTree.PreDiscrTree.mk.injEq | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | ∀ {α : Type} (root : Std.HashMap Lean.Meta.RefinedDiscrTree.Key ℕ)
(tries : Array (Array (Lean.Meta.RefinedDiscrTree.LazyEntry × α)))
(root_1 : Std.HashMap Lean.Meta.RefinedDiscrTree.Key ℕ)
(tries_1 : Array (Array (Lean.Meta.RefinedDiscrTree.LazyEntry × α))),
({ root := root, tries := tries } = { root := root_1, tries := tries_1 }) = (root = root_1 ∧ tries = tries_1) | true |
continuousAddSubmonoid.eq_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) (β : Type u_2) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddZeroClass β]
[inst_3 : ContinuousAdd β],
continuousAddSubmonoid α β = { carrier := {f | Continuous f}, add_mem' := ⋯, zero_mem' := ⋯ } | true |
CategoryTheory.Functor.mapComposableArrowsObjMk₁Iso_hom_app | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (G : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
(i : Fin (1 + 1)),
(G.mapComposableArrowsObjMk₁Iso f).hom.app i =
match i with
| ⟨0, isLt⟩ => CategoryTheory.CategoryStruct.id (G.obj X)
| ⟨1, isLt⟩ => CategoryTheory.CategoryStruct.id (G.obj Y) | true |
Archimedean.mkRat_mem_ratLt | Mathlib.Data.Real.Embedding | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [IsOrderedAddMonoid M] [inst_3 : One M] {num : ℤ}
{den : ℕ}, den ≠ 0 → ∀ {x : M}, mkRat num den ∈ Archimedean.ratLt x ↔ num • 1 < den • x | true |
LucasLehmer.order_ineq | Mathlib.NumberTheory.LucasLehmer | ∀ (p' : ℕ), lucasLehmerResidue (p' + 2) = 0 → 2 ^ (p' + 2) < ↑(LucasLehmer.q (p' + 2)) ^ 2 | true |
RootPairing.coroot'_reflection | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) {i j : ι} (y : M),
(P.coroot' j) ((P.reflection i) y) = (P.coroot' ((P.reflectionPerm i) j)) y | true |
IsAdicComplete.StrictMono.extend_eq | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{N : Type u_5} [inst_3 : AddCommGroup N] [inst_4 : Module R N] {a : ℕ → ℕ} (ha : StrictMono a)
(f : (n : ℕ) → M →ₗ[R] N ⧸ I ^ a n • ⊤),
(∀ {m : ℕ}, Submodule.factorPow I N ⋯ ∘ₗ f (m + 1) = f m) →
∀ (n : ℕ), IsAdicComplete.StrictMono.extend ha f (a n) = f n | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Basic.0.IsPrimitiveRoot.finite_quotient_toInteger_sub_one._simp_1_2 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_insert._proof_1_21 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n)
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n) (l : Std.Tactic.BVDecide.LRAT.Internal.PosFin n),
(f.assignments.modify (↑l) Std.Tactic.BVDecide.LRAT.Internal.Assignment.addPosAssignment).size = n →
∀ (i : Std.Tactic.BVDecide.LRAT.Internal.PosFin n), ↑i < f.assignments.size | false |
TopologicalSpace.Clopens.exists_prod_subset | Mathlib.Topology.ClopenBox | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [CompactSpace Y]
(W : TopologicalSpace.Clopens (X × Y)) {a : X × Y}, a ∈ W → ∃ U, a.1 ∈ U ∧ ∃ V, a.2 ∈ V ∧ U ×ˢ V ≤ W | true |
Num._sizeOf_inst | Mathlib.Data.Num.Basic | SizeOf Num | false |
CategoryTheory.Limits.pushoutIsoUnopPullback_inl_hom | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushout f g],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl f g)
(CategoryTheory.Limits.pushoutIsoUnopPullback f g).hom =
(CategoryTheory.Limits.pullback.fst f.op g.op).unop | true |
NormedAddGroup.ofAddDist.eq_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_5} [inst : Norm E] [inst_1 : AddGroup E] [inst_2 : MetricSpace E] (h₁ : ∀ (x : E), ‖x‖ = dist 0 x)
(h₂ : ∀ (x y z : E), dist x y ≤ dist (z + x) (z + y)),
NormedAddGroup.ofAddDist h₁ h₂ =
{ toNorm := (SeminormedAddGroup.ofAddDist h₁ h₂).toNorm,
toAddGroup := (SeminormedAddGroup.ofAddDist h₁ h₂).toAddGroup,
toPseudoMetricSpace := (SeminormedAddGroup.ofAddDist h₁ h₂).toPseudoMetricSpace, eq_of_dist_eq_zero := ⋯,
dist_eq := ⋯ } | true |
CategoryTheory.Abelian.SpectralObject.leftHomologyDataShortComplex._proof_6 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = n₂),
CategoryTheory.CategoryStruct.comp (X.iCycles f₁ f₂ n₁) (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).g = 0 | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint_preserves_invariant_helper._proof_1_22 | 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)
(j : Fin (List.length acc.2.1)), ↑j < acc.2.1.length | false |
RootPairingCat.category._proof_3 | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | ∀ {R : Type u_2} [inst : CommRing R] {W X Y Z : RootPairingCat R} (f : W.pairing.Hom X.pairing)
(g : X.pairing.Hom Y.pairing) (h : Y.pairing.Hom Z.pairing), h.comp (g.comp f) = (h.comp g).comp f | false |
DenselyNormedField.sub._inherited_default | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_5} →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(zero : α) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
(∀ (x : α), nsmul 0 x = 0) → (∀ (n : ℕ) (x : α), nsmul (n + 1) x = nsmul n x + x) → (α → α) → α → α → α | false |
Module.FaithfullyFlat.iff_zero_iff_rTensor_zero | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u) (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.FaithfullyFlat R M ↔
Module.Flat R M ∧
∀ {N : Type (max u v)} [inst_3 : AddCommGroup N] [inst_4 : Module R N] {N' : Type (max u v)}
[inst_5 : AddCommGroup N'] [inst_6 : Module R N'] (f : N →ₗ[R] N'), LinearMap.rTensor M f = 0 ↔ f = 0 | true |
Order.Ico_succ_right_eq_insert_of_not_isMax | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α},
a ≤ b → ¬IsMax b → Set.Ico a (Order.succ b) = insert b (Set.Ico a b) | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.Drop.0.Std.IterM.step_drop.match_1.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Monadic.Drop | ∀ (motive : ℕ → Sort u_1) (k : ℕ) (h_1 : Unit → motive 0) (h_2 : (k : ℕ) → motive k.succ),
(match k.succ with
| 0 => h_1 ()
| k.succ => h_2 k) =
h_2 k | true |
_private.Mathlib.Data.Nat.Totient.0.Nat.totient_eq_zero._simp_1_4 | Mathlib.Data.Nat.Totient | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α},
(Finset.filter p s = ∅) = ∀ ⦃x : α⦄, x ∈ s → ¬p x | false |
Asymptotics.IsLittleOTVS.trans_isBigOTVS | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} {G : Type u_6} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] [inst_7 : AddCommGroup G] [inst_8 : TopologicalSpace G]
[inst_9 : Module 𝕜 G] {l : Filter α} {f : α → E} {g : α → F} {k : α → G}, f =o[𝕜; l] g → g =O[𝕜; l] k → f =o[𝕜; l] k | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_396 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
CategoryTheory.IsPushout.zero_top | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.BicartesianSq | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.IsPushout 0 0 0 (CategoryTheory.CategoryStruct.id X) | true |
_private.Mathlib.Data.List.Iterate.0.List.mem_iterate._simp_1_1 | Mathlib.Data.List.Iterate | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ l) = ∃ n, l.get n = a | false |
Lean.Grind.Order.le_eq_false_of_le_k | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] [inst_3 : Std.IsPreorder α]
[inst_4 : Lean.Grind.Ring α] [Lean.Grind.OrderedRing α] {a b : α} {k₁ k₂ : ℤ},
(k₂ + k₁).blt' 0 = true → a ≤ b + ↑k₁ → (b ≤ a + ↑k₂) = False | true |
LowerSet.coe_ssubset_coe._simp_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {s t : LowerSet α}, (↑s ⊂ ↑t) = (s < t) | false |
stdOrthonormalBasis_def | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ (𝕜 : Type u_7) [inst : RCLike 𝕜] (E : Type u_8) [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E],
stdOrthonormalBasis 𝕜 E =
have b := Classical.choose ⋯;
⋯.mpr (b.reindex (Fintype.equivFinOfCardEq ⋯)) | true |
AddMonoidHom.comap_ker | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {P : Type u_8} [inst_2 : AddZeroClass P]
(g : N →+ P) (f : G →+ N), AddSubgroup.comap f g.ker = (g.comp f).ker | true |
_private.Mathlib.GroupTheory.SchurZassenhaus.0.Subgroup.SchurZassenhausInduction.step0 | Mathlib.GroupTheory.SchurZassenhaus | ∀ {G : Type u} [inst : Group G] {N : Subgroup G} [N.Normal],
(Nat.card ↥N).Coprime N.index → (∀ (H : Subgroup G), ¬N.IsComplement' H) → N ≠ ⊥ | true |
Std.DTreeMap.Internal.Impl.Const.get_insertMany_list_of_contains_eq_false | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
[inst_1 : BEq α] [inst_2 : Std.LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α}
(h₁ : (List.map Prod.fst l).contains k = false)
{h' : Std.DTreeMap.Internal.Impl.contains k ↑(Std.DTreeMap.Internal.Impl.Const.insertMany t l ⋯) = true},
Std.DTreeMap.Internal.Impl.Const.get (↑(Std.DTreeMap.Internal.Impl.Const.insertMany t l ⋯)) k h' =
Std.DTreeMap.Internal.Impl.Const.get t k ⋯ | true |
BoundedContinuousFunction.measurable_coe_ennreal_comp | Mathlib.MeasureTheory.Integral.BoundedContinuousFunction | ∀ {X : Type u_1} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [OpensMeasurableSpace X]
(f : BoundedContinuousFunction X NNReal), Measurable fun x => ↑(f x) | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.emphLike.noSpaceBefore | Lean.DocString.Parser | Char → Lean.Parser.ParserContext → Lean.Parser.ParserState → Lean.Parser.ParserState | true |
_private.Mathlib.MeasureTheory.Covering.Differentiation.0.VitaliFamily.measure_le_mul_of_subset_limRatioMeas_lt._simp_1_2 | Mathlib.MeasureTheory.Covering.Differentiation | (¬False) = True | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal.0.SSet.Truncated.StrictSegal.spineToSimplex_vertex._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {n : ℕ}, 0 ≤ n + 1 | false |
MeasurableSpace.invariants | Mathlib.MeasureTheory.MeasurableSpace.Invariants | {α : Type u_1} → [m : MeasurableSpace α] → (α → α) → MeasurableSpace α | true |
HasQuotient.mk.noConfusion | Mathlib.Algebra.Quotient | {A : outParam (Type u)} →
{B : Type v} →
{P : Sort u_1} →
{Quotient Quotient' : B → Type (max u v)} →
{ Quotient := Quotient } = { Quotient := Quotient' } → (Quotient ≍ Quotient' → P) → P | false |
CategoryTheory.Abelian.SpectralObject.shortComplexMap._proof_20 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ (n₀ n₁ n₂ : ℤ), 1 < 3 + 1 | false |
instDecidableEqZNum.decEq | Mathlib.Data.Num.Basic | (x x_1 : ZNum) → Decidable (x = x_1) | true |
_private.Mathlib.Analysis.InnerProductSpace.PiL2.0.DirectSum.IsInternal.subordinateOrthonormalBasisIndexFiberEquiv | Mathlib.Analysis.InnerProductSpace.PiL2 | {ι : Type u_1} →
{𝕜 : Type u_3} →
[inst : RCLike 𝕜] →
{E : Type u_4} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : Fintype ι] →
[inst_4 : FiniteDimensional 𝕜 E] →
{n : ℕ} →
(hn : Module.finrank 𝕜 E = n) →
[inst_5 : DecidableEq ι] →
{V : ι → Submodule 𝕜 E} →
(hV : DirectSum.IsInternal V) →
(hV' : OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) →
(i : ι) →
{ a // DirectSum.IsInternal.subordinateOrthonormalBasisIndex hn hV a hV' = i } ≃
Fin (Module.finrank 𝕜 ↥(V i)) | true |
Pi.instFrame._proof_2 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : (i : ι) → Order.Frame (π i)] (a b : (i : ι) → π i), Lattice.inf a b ≤ b | false |
IsometryEquiv.subLeft.eq_1 | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : AddGroup G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsIsometricVAdd G G]
[inst_3 : IsIsometricVAdd Gᵃᵒᵖ G] (c : G),
IsometryEquiv.subLeft c = { toEquiv := Equiv.subLeft c, isometry_toFun := ⋯ } | true |
Order.Ici_succ | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [NoMaxOrder α] (a : α), Set.Ici (Order.succ a) = Set.Ioi a | true |
Submodule.instIdemCommSemiring | Mathlib.Algebra.Algebra.Operations | {R : Type u} →
[inst : CommSemiring R] →
{A : Type v} → [inst_1 : CommSemiring A] → [inst_2 : Algebra R A] → IdemCommSemiring (Submodule R A) | true |
SetRel.equivFixedPoints._proof_6 | Mathlib.Order.Rel.GaloisConnection | ∀ {α : Type u_2} {β : Type u_1} (R : SetRel α β) (I : ↑R.rightFixedPoints),
(fun x =>
match x with
| ⟨J, property⟩ => ⟨R.leftDual J, ⋯⟩)
((fun x =>
match x with
| ⟨I, property⟩ => ⟨R.rightDual I, ⋯⟩)
I) =
I | false |
Lean.Elab.Term.GeneralizeResult.mk.injEq | Lean.Elab.Match | ∀ (discrs : Array Lean.Elab.Term.Discr) (toClear : Array Lean.FVarId) (matchType : Lean.Expr)
(altViews : Array Lean.Elab.Term.TermMatchAltView) (refined : Bool) (discrs_1 : Array Lean.Elab.Term.Discr)
(toClear_1 : Array Lean.FVarId) (matchType_1 : Lean.Expr) (altViews_1 : Array Lean.Elab.Term.TermMatchAltView)
(refined_1 : Bool),
({ discrs := discrs, toClear := toClear, matchType := matchType, altViews := altViews, refined := refined } =
{ discrs := discrs_1, toClear := toClear_1, matchType := matchType_1, altViews := altViews_1,
refined := refined_1 }) =
(discrs = discrs_1 ∧ toClear = toClear_1 ∧ matchType = matchType_1 ∧ altViews = altViews_1 ∧ refined = refined_1) | true |
MvPolynomial.optionEquivLeft_symm_X | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) [inst : CommSemiring R],
(MvPolynomial.optionEquivLeft R S₁).symm Polynomial.X = MvPolynomial.X none | true |
Affine.Simplex.touchpoint_mem_affineSpan | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (signs : Finset (Fin (n + 1)))
(i : Fin (n + 1)), s.touchpoint signs i ∈ affineSpan ℝ (Set.range (s.faceOpposite i).points) | true |
exteriorPower.presentation.relations_G | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ (R : Type u) [inst : CommRing R] (ι : Type u_4) [inst_1 : DecidableEq ι] (M : Type u_5) [inst_2 : AddCommGroup M]
[inst_3 : Module R M], (exteriorPower.presentation.relations R ι M).G = (ι → M) | true |
CategoryTheory.Equivalence.instPowInt | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → Pow (C ≌ C) ℤ | true |
_private.Mathlib.Analysis.Convex.Gauge.0.gauge_closure_zero._simp_1_3 | Mathlib.Analysis.Convex.Gauge | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b = 0) = (a = 0 ∨ b = 0) | false |
CategoryTheory.ChosenPullbacksAlong.pullbackMap_comp._proof_10 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Z X : C} {g : Z ⟶ X} {Z' X' Z'' X'' : C} {g' : Z' ⟶ X'}
{g'' : Z'' ⟶ X''} {γ₂ : Z' ⟶ Z} {γ₃ : X' ⟶ X} {δ₂ : Z'' ⟶ Z'} {δ₃ : X'' ⟶ X'},
autoParam (CategoryTheory.CategoryStruct.comp g' γ₃ = CategoryTheory.CategoryStruct.comp γ₂ g)
CategoryTheory.ChosenPullbacksAlong.pullbackMap_comp._auto_3 →
autoParam (CategoryTheory.CategoryStruct.comp g'' δ₃ = CategoryTheory.CategoryStruct.comp δ₂ g')
CategoryTheory.ChosenPullbacksAlong.pullbackMap_comp._auto_7 →
CategoryTheory.CategoryStruct.comp g'' (CategoryTheory.CategoryStruct.comp δ₃ γ₃) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp δ₂ γ₂) g | false |
CategoryTheory.Subobject.factors_iff | Mathlib.CategoryTheory.Subobject.FactorThru | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (P : CategoryTheory.Subobject Y) (f : X ⟶ Y),
P.Factors f ↔ (CategoryTheory.Subobject.representative.obj P).Factors f | true |
LocalizedModule.map.eq_1 | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {M : Type u_2} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] {N : Type u_3} [inst_3 : AddCommMonoid N] [inst_4 : Module R N],
LocalizedModule.map S =
IsLocalizedModule.mapExtendScalars S (LocalizedModule.mkLinearMap S M) (LocalizedModule.mkLinearMap S N)
(Localization S) | true |
FiniteIndexNormalAddSubgroup.comap._proof_1 | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] {H : Type u_2} [inst_1 : AddGroup H] (f : G →+ H)
(K : FiniteIndexNormalAddSubgroup H), (AddSubgroup.comap f K.toAddSubgroup).Normal | false |
_private.Batteries.Data.List.Lemmas.0.List.beq_iff_exists_findIdxNth._proof_1_3 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {x : α} [inst : BEq α] {xs : List α} {h : i < xs.length},
(xs[i] == x) = true → List.idxOfNth x xs (List.countBefore x xs i) = i | false |
continuous_fst | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y], Continuous Prod.fst | true |
Prod.instCompletelyDistribLattice._proof_6 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : CompletelyDistribLattice α] [inst_1 : CompletelyDistribLattice β] (a : α × β),
a ⇨ ⊥ = aᶜ | false |
LowerSemicontinuousOn.isClosed_re_epigraph | Mathlib.Analysis.Convex.Approximation | ∀ {𝕜 : Type u_1} {E : Type u_2} {s : Set E} {φ : E → ℝ} [inst : RCLike 𝕜] [inst_1 : TopologicalSpace E],
IsClosed s → LowerSemicontinuousOn φ s → IsClosed {p | p.1 ∈ s ∧ φ p.1 ≤ RCLike.re p.2} | true |
LinearOrderedCommGroup.closure_equiv_closure._proof_13 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_1} {G' : Type u_2} [inst : CommGroup G] [inst_1 : LinearOrder G] [inst_2 : CommGroup G']
[inst_3 : LinearOrder G'] (x : G) (y : G'),
Subgroup.closure {x} = Subgroup.closure {max x x⁻¹} →
∀ (hyc : Subgroup.closure {y} = Subgroup.closure {max y y⁻¹}) (a : ↥(Subgroup.closure {y})),
max x x⁻¹ ^ ⋯.choose ∈ Subgroup.closure {x} | false |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionOfMonoidalFunctorToEndofunctorMop._proof_3 | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C (CategoryTheory.Functor D D)ᴹᵒᵖ) (c : C)
(d : D),
(F.obj c).unmop.map (CategoryTheory.CategoryStruct.id d) = CategoryTheory.CategoryStruct.id ((F.obj c).unmop.obj d) | false |
QuadraticModuleCat.concreteCategory._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y : QuadraticModuleCat R} (f : X ⟶ Y), { toIsometry' := f.toIsometry' } = f | false |
SeminormFamily.addGroupFilterBasis | Mathlib.Analysis.LocallyConvex.WithSeminorms | {R : Type u_1} →
{E : Type u_6} →
{ι : Type u_9} →
[inst : SeminormedRing R] →
[inst_1 : AddCommGroup E] → [inst_2 : Module R E] → SeminormFamily R E ι → AddGroupFilterBasis E | true |
CategoryTheory.Sheaf.χ_hom | Mathlib.CategoryTheory.Topos.Sheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
{F G : CategoryTheory.Sheaf J (Type (max u v))} (m : F ⟶ G) [inst_1 : CategoryTheory.Mono m],
(CategoryTheory.Sheaf.χ m).hom = CategoryTheory.Subfunctor.lift (CategoryTheory.Presheaf.χ m.hom) ⋯ | true |
instLatticeTropical._proof_1 | Mathlib.Algebra.Tropical.Lattice | ∀ {R : Type u_1} [inst : Lattice R] (a b : Tropical R), a ≤ SemilatticeSup.sup a b | false |
PrimeSpectrum.ConstructibleSetData.isConstructible_toSet | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} [inst : CommSemiring R] (S : PrimeSpectrum.ConstructibleSetData R), Topology.IsConstructible S.toSet | true |
nnnorm_algebraMap | Mathlib.Analysis.Normed.Module.Basic | ∀ {𝕜 : Type u_1} (𝕜' : Type u_2) [inst : NormedField 𝕜] [inst_1 : SeminormedRing 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜']
(x : 𝕜), ‖(algebraMap 𝕜 𝕜') x‖₊ = ‖x‖₊ * ‖1‖₊ | true |
Monoid.CoprodI.Word.equivPair_tail_eq_inv_smul | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} [inst : DecidableEq ι] {G : ι → Type u_4} [inst_1 : (i : ι) → Group (G i)]
[inst_2 : (i : ι) → DecidableEq (G i)] {i : ι} (w : Monoid.CoprodI.Word G),
((Monoid.CoprodI.Word.equivPair i) w).tail = (Monoid.CoprodI.of ((Monoid.CoprodI.Word.equivPair i) w).head)⁻¹ • w | true |
CategoryTheory.ShortComplex.Hom.id_τ₃ | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C), (CategoryTheory.ShortComplex.Hom.id S).τ₃ = CategoryTheory.CategoryStruct.id S.X₃ | true |
CategoryTheory.Functor.homologicalKernel | Mathlib.CategoryTheory.Triangulated.HomologicalFunctor | {C : Type u_1} →
{A : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.HasShift C ℤ] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] → CategoryTheory.Functor C A → CategoryTheory.ObjectProperty C | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.