name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Meta.Grind.AC.EqCnstrProof.core.noConfusion | Lean.Meta.Tactic.Grind.AC.Types | {P : Sort u} →
{a b : Lean.Expr} →
{ea eb : Lean.Grind.AC.Expr} →
{a' b' : Lean.Expr} →
{ea' eb' : Lean.Grind.AC.Expr} →
Lean.Meta.Grind.AC.EqCnstrProof.core a b ea eb = Lean.Meta.Grind.AC.EqCnstrProof.core a' b' ea' eb' →
(a = a' → b = b' → ea = ea' → eb = eb' → P) → P | false |
CategoryTheory.Idempotents.instFaithfulKaroubiFunctorKaroubiFunctorCategoryEmbedding | Mathlib.CategoryTheory.Idempotents.FunctorCategories | ∀ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C],
(CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding J C).Faithful | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan.0.Real.tan_sub._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {z w : ℝ}, (z = w) = (↑z = ↑w) | false |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile.0.Std.Iterators.Types.DropWhile.instIterator.match_1.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {P : β → Std.Iterators.PostconditionT m (ULift.{u_1, 0} Bool)} (out : β)
(motive : Subtype (P out).Property → Sort u_3) (h'' : (P out).Property { down := false })
(h_1 : (h'' : (P out).Property { down := true }) → motive ⟨{ down := true }, h''⟩)
(h_2 : (h'' : (P out).Property { down := false }) → motive ⟨{ down := false }, h''⟩),
(match ⟨{ down := false }, h''⟩ with
| ⟨{ down := true }, h''⟩ => h_1 h''
| ⟨{ down := false }, h''⟩ => h_2 h'') =
h_2 h'' | true |
MeasureTheory.L1.SimpleFunc.negPart_toSimpleFunc | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : ↥(MeasureTheory.Lp.simpleFunc ℝ 1 μ)),
⇑(MeasureTheory.Lp.simpleFunc.toSimpleFunc (MeasureTheory.L1.SimpleFunc.negPart f)) =ᵐ[μ]
⇑(MeasureTheory.Lp.simpleFunc.toSimpleFunc f).negPart | true |
_private.Batteries.Data.List.Lemmas.0.List.countPBefore_cons._proof_1_8 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} {a : α},
List.countPBefore p (a :: xs) 0 =
if 0 = 0 then 0 else if p a = true then List.countPBefore p xs (0 - 1) + 1 else List.countPBefore p xs (0 - 1) | false |
_private.Mathlib.SetTheory.Ordinal.FundamentalSequence.0.Ordinal.IsFundamentalSeq.iSup_add_one_eq._simp_1_2 | Mathlib.SetTheory.Ordinal.FundamentalSequence | ∀ {α : Type u_1} {x y : α} [inst : Preorder α] [inst_1 : Add α] [inst_2 : One α] [SuccAddOrder α] [NoMaxOrder α],
(x + 1 ≤ y) = (x < y) | false |
FirstOrder.presburgerFunc.one.elim | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | {motive : (a : ℕ) → FirstOrder.presburgerFunc a → Sort u} →
{a : ℕ} → (t : FirstOrder.presburgerFunc a) → t.ctorIdx = 1 → motive 0 FirstOrder.presburgerFunc.one → motive a t | false |
_private.Init.Data.List.Find.0.List.finIdxOf?_eq_some_iff._simp_1_2 | Init.Data.List.Find | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | false |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90.0.groupCohomology.exists_div_of_norm_eq_one._simp_1_4 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | false |
Rack.toEnvelGroup.mapAux.eq_3 | Mathlib.Algebra.Quandle | ∀ {R : Type u_1} [inst : Rack R] {G : Type u_2} [inst_1 : Group G] (f : ShelfHom R (Quandle.Conj G))
(a b : Rack.PreEnvelGroup R),
Rack.toEnvelGroup.mapAux f (a.mul b) = Rack.toEnvelGroup.mapAux f a * Rack.toEnvelGroup.mapAux f b | true |
Filter.frequently_atTop | Mathlib.Order.Filter.AtTopBot.Basic | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∃ᶠ (x : α) in Filter.atTop, p x) ↔ ∀ (a : α), ∃ b ≥ a, p b | true |
groupCohomology.mapShortComplexH2._proof_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k G H : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u_2, u_1, u_1} k H}
{B : Rep.{u_2, u_1, u_1} k G} (f : G →* H) (φ : Rep.res f A ⟶ B),
CategoryTheory.CategoryStruct.comp (groupCohomology.cochainsMap₁ f φ) (groupCohomology.shortComplexH2 B).f =
CategoryTheory.CategoryStruct.comp (groupCohomology.shortComplexH2 A).f (groupCohomology.cochainsMap₂ f φ) | false |
QuadraticMap.Isometry.comp._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.Isometry | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
balancedCore_subset_balancedCoreAux | Mathlib.Analysis.LocallyConvex.BalancedCoreHull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NormedDivisionRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
{s : Set E}, balancedCore 𝕜 s ⊆ balancedCoreAux 𝕜 s | true |
Lean.Server.Test.Runner.requestWithLoggedResponse | Lean.Server.Test.Runner | {α : Type u_1} →
String →
[Lean.ToJson α] →
α → (β : Type) → [Lean.FromJson β] → [Lean.ToJson β] → optParam Bool true → Lean.Server.Test.Runner.RunnerM β | true |
CategoryTheory.ParametrizedAdjunction.unit_whiskerRight_map_assoc | Mathlib.CategoryTheory.Adjunction.Parametrized | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)}
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} (self : F ⊣₂ G) {X₁ Y₁ : C₁} (f : X₁ ⟶ Y₁)
{Z : CategoryTheory.Functor C₂ C₂} (h : (F.obj Y₁).comp (G.obj (Opposite.op X₁)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.adj X₁).unit
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.whiskerRight (F.map f) (G.obj (Opposite.op X₁))) h) =
CategoryTheory.CategoryStruct.comp (self.adj Y₁).unit
(CategoryTheory.CategoryStruct.comp ((F.obj Y₁).whiskerLeft (G.map f.op)) h) | true |
CategoryTheory.Functor.commShift₂_comm_assoc | Mathlib.CategoryTheory.Shift.CommShiftTwo | ∀ {C₁ : Type u_1} {C₂ : Type u_3} {D : Type u_5} {inst : CategoryTheory.Category.{v_1, u_1} C₁}
{inst_1 : CategoryTheory.Category.{v_3, u_3} C₂} {inst_2 : CategoryTheory.Category.{v_5, u_5} D} {M : Type u_6}
{inst_3 : AddCommMonoid M} {inst_4 : CategoryTheory.HasShift C₁ M} {inst_5 : CategoryTheory.HasShift C₂ M}
{inst_6 : CategoryTheory.HasShift D M} (G : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ D))
(h : CategoryTheory.CommShift₂Setup D M) [self : G.CommShift₂ h] (X₁ : C₁) (X₂ : C₂) (m n : M) {Z : D}
(h_1 : (CategoryTheory.shiftFunctor D n).obj ((CategoryTheory.shiftFunctor D m).obj ((G.flip.obj X₂).obj X₁)) ⟶ Z),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.commShiftIso (G.obj ((CategoryTheory.shiftFunctor C₁ m).obj X₁)) n).hom.app X₂)
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.shiftFunctor D n).map ((CategoryTheory.Functor.commShiftIso (G.flip.obj X₂) m).hom.app X₁))
h_1) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.commShiftIso (G.flip.obj ((CategoryTheory.shiftFunctor C₂ n).obj X₂)) m).hom.app X₁)
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.shiftFunctor D m).map ((CategoryTheory.Functor.commShiftIso (G.obj X₁) n).hom.app X₂))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.shiftComm ((G.obj X₁).obj X₂) m n).inv
((↑(h.ε m n)).app
((CategoryTheory.shiftFunctor D n).obj ((CategoryTheory.shiftFunctor D m).obj ((G.obj X₁).obj X₂)))))))
h_1 | true |
GradedMonoid.GMulAction.mk._flat_ctor | Mathlib.Algebra.GradedMulAction | {ιA : Type u_1} →
{ιM : Type u_3} →
{A : ιA → Type u_4} →
{M : ιM → Type u_5} →
[inst : AddMonoid ιA] →
[inst_1 : VAdd ιA ιM] →
[inst_2 : GradedMonoid.GMonoid A] →
(smul : {i : ιA} → {j : ιM} → A i → M j → M (i +ᵥ j)) →
(∀ (b : GradedMonoid M), 1 • b = b) →
(∀ (a a' : GradedMonoid A) (b : GradedMonoid M), (a * a') • b = a • a' • b) →
GradedMonoid.GMulAction A M | false |
_private.Lean.Elab.Tactic.Do.ProofMode.Exfalso.0.Lean.Elab.Tactic.Do.ProofMode.elabMExfalso.match_4 | Lean.Elab.Tactic.Do.ProofMode.Exfalso | (motive : Lean.Syntax → Sort u_1) → (x : Lean.Syntax) → ((x : Lean.Syntax) → motive x) → motive x | false |
_private.Mathlib.NumberTheory.ModularForms.QExpansion.0._aux_Mathlib_NumberTheory_ModularForms_QExpansion___unexpand_Function_Periodic_qParam_1 | Mathlib.NumberTheory.ModularForms.QExpansion | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Basic.0.AlgebraicGeometry.Scheme.ker_ideal_of_isPullback_of_isOpenImmersion._simp_1_2 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {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}
{K : Ideal S} [inst_3 : RingHomClass F R S] {x : R}, (x ∈ Ideal.comap f K) = (f x ∈ K) | false |
StarAlgebra.elemental.instNormedCommRingSubtypeMemStarSubalgebraOfIsStarNormal | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | {R : Type u_2} →
{A : Type u_3} →
[inst : CommRing R] →
[inst_1 : StarRing R] →
[inst_2 : NormedRing A] →
[inst_3 : Algebra R A] →
[inst_4 : StarRing A] →
[inst_5 : ContinuousStar A] →
[inst_6 : StarModule R A] → (a : A) → [IsStarNormal a] → NormedCommRing ↥(StarAlgebra.elemental R a) | true |
CategoryTheory.ShortComplex.LeftHomologyData.π_comp_homologyIso_inv_assoc | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology] (h : S.LeftHomologyData) {Z : C} (h_1 : S.homology ⟶ Z),
CategoryTheory.CategoryStruct.comp h.π (CategoryTheory.CategoryStruct.comp h.homologyIso.inv h_1) =
CategoryTheory.CategoryStruct.comp h.cyclesIso.inv (CategoryTheory.CategoryStruct.comp S.homologyπ h_1) | true |
AddMonoid.End.coe_pow | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_4) [inst : AddZero M] (f : AddMonoid.End M) (n : ℕ), ⇑(f ^ n) = (⇑f)^[n] | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.code.takeBackticksFn | Lean.DocString.Parser | ℕ → Lean.Parser.ParserFn | true |
ContinuousMap.specializes_coe._simp_1 | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f g : C(X, Y)},
⇑f ⤳ ⇑g = f ⤳ g | false |
SkewMonoidAlgebra.liftNCAlgHom._proof_2 | Mathlib.Algebra.SkewMonoidAlgebra.Lift | ∀ {k : Type u_4} {G : Type u_2} [inst : CommSemiring k] [inst_1 : Monoid G] {A : Type u_3} {B : Type u_1}
[inst_2 : Semiring A] [inst_3 : Algebra k A] [inst_4 : Semiring B] [inst_5 : Algebra k B]
[inst_6 : MulSemiringAction G A] [inst_7 : SMulCommClass G k A] (f : A →ₐ[k] B) (g : G →* B)
(h_comm : ∀ {x : A} {y : G}, f (y • x) * g y = g y * f x) (r : k),
(↑↑(SkewMonoidAlgebra.liftNCRingHom (↑f) g ⋯)).toFun ((algebraMap k (SkewMonoidAlgebra A G)) r) = (algebraMap k B) r | false |
Std.TransCmp.gt_of_eq_of_gt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {a b c : α},
cmp a b = Ordering.eq → cmp b c = Ordering.gt → cmp a c = Ordering.gt | true |
AlgebraicGeometry.StructureSheaf.toStalkₗ._proof_2 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R M : Type u_1) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) (x_1 y : M),
(CategoryTheory.ConcreteCategory.hom
(TopCat.Presheaf.germ (AlgebraicGeometry.moduleStructurePresheaf R M).presheaf ⊤ x ⋯))
((AlgebraicGeometry.StructureSheaf.toOpenₗ R M ⊤) (x_1 + y)) =
(CategoryTheory.ConcreteCategory.hom
(TopCat.Presheaf.germ (AlgebraicGeometry.moduleStructurePresheaf R M).presheaf ⊤ x ⋯))
((AlgebraicGeometry.StructureSheaf.toOpenₗ R M ⊤) x_1) +
(CategoryTheory.ConcreteCategory.hom
(TopCat.Presheaf.germ (AlgebraicGeometry.moduleStructurePresheaf R M).presheaf ⊤ x ⋯))
((AlgebraicGeometry.StructureSheaf.toOpenₗ R M ⊤) y) | false |
Lean.Compiler.LCNF.CacheAuxDeclResult.rec | Lean.Compiler.LCNF.AuxDeclCache | {motive : Lean.Compiler.LCNF.CacheAuxDeclResult → Sort u} →
motive Lean.Compiler.LCNF.CacheAuxDeclResult.new →
((declName : Lean.Name) → motive (Lean.Compiler.LCNF.CacheAuxDeclResult.alreadyCached declName)) →
(t : Lean.Compiler.LCNF.CacheAuxDeclResult) → motive t | false |
Real.arccos_of_le_neg_one | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x : ℝ}, x ≤ -1 → Real.arccos x = Real.pi | true |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift₁ | Mathlib.CategoryTheory.Localization.Prod | {C₁ : Type u₁} →
{C₂ : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{E : Type u₅} →
[inst_2 : CategoryTheory.Category.{v₅, u₅} E] →
(F : CategoryTheory.Functor (C₁ × C₂) E) →
[W₂.ContainsIdentities] →
(W₁.prod W₂).IsInvertedBy F → CategoryTheory.Functor W₁.Localization (CategoryTheory.Functor C₂ E) | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get_union_of_contains_right._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Multiset.noncommFold | Mathlib.Data.Finset.NoncommProd | {α : Type u_3} →
(op : α → α → α) →
[assoc : Std.Associative op] → (s : Multiset α) → ({x | x ∈ s}.Pairwise fun x y => op x y = op y x) → α → α | true |
ContinuousLinearMap.monoidWithZero._proof_5 | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₁ : Type u_2} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] (x : M₁ →L[R₁] M₁), x * 1 = x | false |
AlgebraicGeometry.Scheme.zeroLocus_eq_univ_iff_subset_nilradical | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ {X : AlgebraicGeometry.Scheme} [CompactSpace ↥X] (s : Set ↑(X.presheaf.obj (Opposite.op ⊤))),
X.zeroLocus s = Set.univ ↔ s ⊆ ↑(nilradical ↑(X.presheaf.obj (Opposite.op ⊤))) | true |
CategoryTheory.Functor.id_hcomp | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
{G H : CategoryTheory.Functor D E} (α : G ⟶ H), CategoryTheory.CategoryStruct.id F ◫ α = F.whiskerLeft α | true |
GradedAlgebra.instAlgebraSubtypeTensorProductMemSubmoduleBaseChangeOfNat_1._proof_1 | Mathlib.RingTheory.GradedAlgebra.TensorProduct | ∀ {ι : Type u_1} {R : Type u_4} {A : Type u_2} {S : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : DecidableEq ι] [inst_4 : AddCommMonoid ι] [inst_5 : CommSemiring A]
[inst_6 : Algebra R A] (𝒜 : ι → Submodule R A) [GradedAlgebra 𝒜],
SetLike.GradedMonoid fun i => Submodule.baseChange S (𝒜 i) | false |
Finset.filter_inter_distrib | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] [inst_1 : DecidableEq α] (s t : Finset α),
Finset.filter p (s ∩ t) = Finset.filter p s ∩ Finset.filter p t | true |
TopCat.of.noConfusion | Mathlib.Topology.Category.TopCat.Basic | {P : Sort u_1} →
{carrier : Type u} →
{str : TopologicalSpace carrier} →
{carrier' : Type u} →
{str' : TopologicalSpace carrier'} →
TopCat.of carrier = TopCat.of carrier' → (carrier = carrier' → str ≍ str' → P) → P | false |
Con.subgroup._proof_1 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (c : Con G) {a b : G}, a ∈ {x | c x 1} → b ∈ {x | c x 1} → a * b ∈ {x | c x 1} | false |
irrational_pi._simp_1 | Mathlib.Analysis.Real.Pi.Irrational | Irrational Real.pi = True | false |
Lean.Meta.Iterator.head | Lean.Meta.Iterator | {α : Type} → Lean.Meta.Iterator α → Lean.MetaM α | true |
_private.Mathlib.RingTheory.Filtration.0.Ideal.Filtration.submodule_eq_span_le_iff_stable_ge._simp_1_3 | Mathlib.RingTheory.Filtration | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
Int32.toBitVec.inj | Init.Data.SInt.Basic | ∀ {x y : Int32}, x.toBitVec = y.toBitVec → x = y | true |
threeAPFree_pi | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {ι : Type u_4} {α : ι → Type u_5} [inst : (i : ι) → AddMonoid (α i)] {s : (i : ι) → Set (α i)},
(∀ (i : ι), ThreeAPFree (s i)) → ThreeAPFree (Set.univ.pi s) | true |
TypeVec.casesCons | Mathlib.Data.TypeVec | (n : ℕ) →
{β : TypeVec.{u_2} (n + 1) → Sort u_1} →
((t : Type u_2) → (v : TypeVec.{u_2} n) → β (v ::: t)) → (v : TypeVec.{u_2} (n + 1)) → β v | true |
BoundedContinuousFunction.norm_integral_le_norm | Mathlib.MeasureTheory.Integral.BoundedContinuousFunction | ∀ {X : Type u_1} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] (μ : MeasureTheory.Measure X) {E : Type u_2}
[inst_2 : NormedAddCommGroup E] [OpensMeasurableSpace X] [SecondCountableTopology E] [inst_5 : MeasurableSpace E]
[BorelSpace E] [inst_7 : NormedSpace ℝ E] [MeasureTheory.IsProbabilityMeasure μ] (f : BoundedContinuousFunction X E),
‖∫ (x : X), f x ∂μ‖ ≤ ‖f‖ | true |
_private.Init.Data.Array.BasicAux.0.Array.of_push_eq_push.match_1_1 | Init.Data.Array.BasicAux | ∀ {α : Type u_1} {a b : α} {as bs : Array α} (motive : as.toList = bs.toList ∧ a = b → Prop)
(x : as.toList = bs.toList ∧ a = b), (∀ (h₁ : as.toList = bs.toList) (h₂ : a = b), motive ⋯) → motive x | false |
Stream'.WSeq.join_ret | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} (s : Stream'.WSeq α), (Stream'.WSeq.ret s).join ~ʷ s | true |
Std.Sat.AIG.RefVec.ite.go._unary._proof_2 | Std.Sat.AIG.If | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (curr : ℕ) (hcurr : curr ≤ w)
(discr : aig.Ref) (lhs rhs : aig.RefVec w) (s : aig.RefVec curr) (hcurr_1 : curr < w)
(this :
aig.decls.size ≤
(aig.mkIfCached { discr := discr, lhs := lhs.get curr hcurr_1, rhs := rhs.get curr hcurr_1 }).aig.decls.size),
InvImage (fun x1 x2 => x1 < x2)
(fun x =>
PSigma.casesOn x fun aig curr =>
PSigma.casesOn curr fun curr hcurr =>
PSigma.casesOn hcurr fun hcurr discr =>
PSigma.casesOn discr fun discr lhs =>
PSigma.casesOn lhs fun lhs rhs => PSigma.casesOn rhs fun rhs s => w - curr)
⟨(aig.mkIfCached { discr := discr, lhs := lhs.get curr hcurr_1, rhs := rhs.get curr hcurr_1 }).aig,
⟨curr + 1,
⟨⋯,
⟨discr.cast this,
⟨lhs.cast this,
⟨rhs.cast this,
(s.cast this).push
(aig.mkIfCached
{ discr := discr, lhs := lhs.get curr hcurr_1, rhs := rhs.get curr hcurr_1 }).ref⟩⟩⟩⟩⟩⟩
⟨aig, ⟨curr, ⟨hcurr, ⟨discr, ⟨lhs, ⟨rhs, s⟩⟩⟩⟩⟩⟩ | false |
ModularForm.instGCommRing | Mathlib.NumberTheory.ModularForms.Basic | (Γ : Subgroup (GL (Fin 2) ℝ)) → [Γ.HasDetPlusMinusOne] → DirectSum.GCommRing (ModularForm Γ) | true |
Mathlib.Tactic.BicategoryLike.MonadNormalExpr.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {P : Sort u} →
{m : Type → Type} →
{t : Mathlib.Tactic.BicategoryLike.MonadNormalExpr m} →
{m' : Type → Type} →
{t' : Mathlib.Tactic.BicategoryLike.MonadNormalExpr m'} →
m = m' → t ≍ t' → Mathlib.Tactic.BicategoryLike.MonadNormalExpr.noConfusionType P t t' | false |
_private.Mathlib.Topology.Order.LeftRightNhds.0.mem_nhdsGT_iff_exists_Ioo_subset.match_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α} (motive : (∃ b, a < b) → Prop) (x : ∃ b, a < b),
(∀ (_u' : α) (hu' : a < _u'), motive ⋯) → motive x | false |
FreeAddMonoid.length.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} (a : FreeAddMonoid α), a.length = (FreeAddMonoid.toList a).length | true |
Std.DTreeMap.Equiv.constMinEntryD_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{fallback : α × β}, t₁.Equiv t₂ → Std.DTreeMap.Const.minEntryD t₁ fallback = Std.DTreeMap.Const.minEntryD t₂ fallback | true |
Batteries.RBNode.Path.fill'.match_1 | Batteries.Data.RBMap.Alter | {α : Type u_1} →
(motive : Batteries.RBNode α × Batteries.RBNode.Path α → Sort u_2) →
(x : Batteries.RBNode α × Batteries.RBNode.Path α) →
((t : Batteries.RBNode α) → (path : Batteries.RBNode.Path α) → motive (t, path)) → motive x | false |
BotHom.instOrderBot | Mathlib.Order.Hom.Bounded | {α : Type u_2} → {β : Type u_3} → [inst : Bot α] → [inst_1 : LE β] → [inst_2 : OrderBot β] → OrderBot (BotHom α β) | true |
Set.Iio_subset_Iio | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ≤ b → Set.Iio a ⊆ Set.Iio b | true |
_private.Lean.Environment.0.Lean.Environment.asyncConstsMap | Lean.Environment | Lean.Environment → Lean.VisibilityMap✝ Lean.AsyncConsts✝ | true |
Lean.Meta.CaseValuesSubgoal.mk.sizeOf_spec | Lean.Meta.Match.CaseValues | ∀ (mvarId : Lean.MVarId) (newHs : Array Lean.FVarId) (subst : Lean.Meta.FVarSubst),
sizeOf { mvarId := mvarId, newHs := newHs, subst := subst } = 1 + sizeOf mvarId + sizeOf newHs + sizeOf subst | true |
IsUpperModularLattice | Mathlib.Order.ModularLattice | (α : Type u_2) → [Lattice α] → Prop | true |
CategoryTheory.MonoidalCategory.ofTensorHom | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategoryStruct C] →
autoParam
(∀ (X₁ X₂ : C),
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X₁)
(CategoryTheory.CategoryStruct.id X₂) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X₁ X₂))
CategoryTheory.MonoidalCategory.ofTensorHom._auto_1 →
autoParam
(∀ (X : C) {Y₁ Y₂ : C} (f : Y₁ ⟶ Y₂),
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X) f =
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f)
CategoryTheory.MonoidalCategory.ofTensorHom._auto_3 →
autoParam
(∀ {X₁ X₂ : C} (f : X₁ ⟶ X₂) (Y : C),
CategoryTheory.MonoidalCategoryStruct.tensorHom f (CategoryTheory.CategoryStruct.id Y) =
CategoryTheory.MonoidalCategoryStruct.whiskerRight f Y)
CategoryTheory.MonoidalCategory.ofTensorHom._auto_5 →
autoParam
(∀ {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁) (g₂ : Y₂ ⟶ Z₂),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ f₂)
(CategoryTheory.MonoidalCategoryStruct.tensorHom g₁ g₂) =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.comp f₁ g₁)
(CategoryTheory.CategoryStruct.comp f₂ g₂))
CategoryTheory.MonoidalCategory.ofTensorHom._auto_7 →
autoParam
(∀ {X₁ X₂ X₃ Y₁ Y₂ Y₃ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom
(CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ f₂) f₃)
(CategoryTheory.MonoidalCategoryStruct.associator Y₁ Y₂ Y₃).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X₁ X₂ X₃).hom
(CategoryTheory.MonoidalCategoryStruct.tensorHom f₁
(CategoryTheory.MonoidalCategoryStruct.tensorHom f₂ f₃)))
CategoryTheory.MonoidalCategory.ofTensorHom._auto_9 →
autoParam
(∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom
(CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)) f)
(CategoryTheory.MonoidalCategoryStruct.leftUnitor Y).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom f)
CategoryTheory.MonoidalCategory.ofTensorHom._auto_11 →
autoParam
(∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom f
(CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)))
(CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom
f)
CategoryTheory.MonoidalCategory.ofTensorHom._auto_13 →
autoParam
(∀ (W X Y Z : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom
(CategoryTheory.MonoidalCategoryStruct.associator W X Y).hom
(CategoryTheory.CategoryStruct.id Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator W
(CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z).hom
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id W)
(CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator
(CategoryTheory.MonoidalCategoryStruct.tensorObj W X) Y Z).hom
(CategoryTheory.MonoidalCategoryStruct.associator W X
(CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z)).hom)
CategoryTheory.MonoidalCategory.ofTensorHom._auto_15 →
autoParam
(∀ (X Y : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X
(CategoryTheory.MonoidalCategoryStruct.tensorUnit C) Y).hom
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X)
(CategoryTheory.MonoidalCategoryStruct.leftUnitor Y).hom) =
CategoryTheory.MonoidalCategoryStruct.tensorHom
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom
(CategoryTheory.CategoryStruct.id Y))
CategoryTheory.MonoidalCategory.ofTensorHom._auto_17 →
CategoryTheory.MonoidalCategory C | true |
TopologicalSpace.OpenNhds.val_apply | Mathlib.Topology.Category.TopCat.OpenNhds | ∀ {X : TopCat} {x : ↑X} {U V : TopologicalSpace.OpenNhds x} (f : U ⟶ V) (y : ↥↑U), ↑(f y) = ↑y | true |
Finset.map_swap_product | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} (s : Finset α) (t : Finset β),
Finset.map { toFun := Prod.swap, inj' := ⋯ } (t ×ˢ s) = s ×ˢ t | true |
Std.Sat.AIG.mkBEqCached._proof_1 | Std.Sat.AIG.CachedGates | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (input : aig.BinaryInput),
aig.decls.size ≤ (aig.mkGateCached (input.invert false true)).aig.decls.size | false |
Subgroup.pi_empty | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → Group (f i)] (H : (i : η) → Subgroup (f i)), Subgroup.pi ∅ H = ⊤ | true |
LowerSemicontinuousAt.add' | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {γ : Type u_5} [inst_1 : AddCommMonoid γ] [inst_2 : LinearOrder γ]
[IsOrderedAddMonoid γ] [inst_4 : TopologicalSpace γ] [OrderTopology γ] {f g : α → γ},
LowerSemicontinuousAt f x →
LowerSemicontinuousAt g x →
ContinuousAt (fun p => p.1 + p.2) (f x, g x) → LowerSemicontinuousAt (fun z => f z + g z) x | true |
LinearMap.pi_comp | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {M₂ : Type w} {M₃ : Type y} {ι : Type x} [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : Module R M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M₃] {φ : ι → Type i}
[inst_5 : (i : ι) → AddCommMonoid (φ i)] [inst_6 : (i : ι) → Module R (φ i)] (f : (i : ι) → M₂ →ₗ[R] φ i)
(g : M₃ →ₗ[R] M₂), LinearMap.pi f ∘ₗ g = LinearMap.pi fun i => f i ∘ₗ g | true |
WittVector.mk | Mathlib.RingTheory.WittVector.Defs | (p : ℕ) → {R : Type u_1} → (ℕ → R) → WittVector p R | true |
SetLike.gring._proof_1 | Mathlib.Algebra.DirectSum.Internal | ∀ {σ : Type u_1} {R : Type u_2} [inst : Ring R] [inst_1 : SetLike σ R] [AddSubgroupClass σ R], AddSubmonoidClass σ R | false |
AddCommMonCat.coyonedaForget_inv_app_app | Mathlib.Algebra.Category.MonCat.Yoneda | ∀ (X : AddCommMonCatᵒᵖ) (X_1 : AddCommMonCat) (a : (CategoryTheory.coyoneda.obj X).obj X_1),
(AddCommMonCat.coyonedaForget.inv.app X).app X_1 a = AddCommMonCat.Hom.hom a | true |
_private.Mathlib.AlgebraicGeometry.OpenImmersion.0.AlgebraicGeometry.IsOpenImmersion.instIsIsoCommRingCatStalkMap._proof_1 | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f] (x : ↥X),
CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.stalkMap f x) | false |
ContinuousMap.instNonAssocRingOfIsTopologicalRing._proof_2 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {β : Type u_1} [inst : TopologicalSpace β] [inst_1 : NonAssocRing β] [IsTopologicalRing β], ContinuousMul β | false |
AffineMap.lineMap_mem_affineSpan_pair | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (r : k) (p₁ p₂ : P), (AffineMap.lineMap p₁ p₂) r ∈ affineSpan k {p₁, p₂} | true |
OptionT.run_lift | Init.Control.Lawful.Instances | ∀ {m : Type u → Type v} {α : Type u} [inst : Monad m] (x : m α),
(OptionT.lift x).run = do
let __do_lift ← x
pure (some __do_lift) | true |
Set.iUnionLift._proof_1 | Mathlib.Data.Set.UnionLift | ∀ {α : Type u_2} {ι : Sort u_1} (S : ι → Set α), ∀ T ⊆ Set.iUnion S, ∀ (x : ↑T), ∃ i, ↑x ∈ S i | false |
CategoryTheory.FunctorToTypes.prod.fst_app | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)} (x : C)
(a : (CategoryTheory.FunctorToTypes.prod F G).obj x), CategoryTheory.FunctorToTypes.prod.fst.app x a = a.1 | true |
CompactlySupportedContinuousMap.instNonUnitalRingOfIsTopologicalRing._proof_9 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : NonUnitalRing β]
[inst_3 : IsTopologicalRing β] (f g : CompactlySupportedContinuousMap α β), ⇑(f - g) = ⇑f - ⇑g | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula.0.WeierstrassCurve.Jacobian.addU_smul._simp_1_10 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.foldl_eq_foldl_toList._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
HasStrictFDerivAt.restrictScalars | Mathlib.Analysis.Calculus.FDeriv.RestrictScalars | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_2} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {E : Type u_3} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E]
[inst_5 : NormedSpace 𝕜' E] [inst_6 : IsScalarTower 𝕜 𝕜' E] {F : Type u_4} [inst_7 : NormedAddCommGroup F]
[inst_8 : NormedSpace 𝕜 F] [inst_9 : NormedSpace 𝕜' F] [inst_10 : IsScalarTower 𝕜 𝕜' F] {f : E → F} {f' : E →L[𝕜'] F}
{x : E}, HasStrictFDerivAt f f' x → HasStrictFDerivAt f (ContinuousLinearMap.restrictScalars 𝕜 f') x | true |
List.pmap._proof_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {P : α → Prop} (a : α) (l : List α), (∀ a_1 ∈ a :: l, P a_1) → P a | false |
ContinuousLinearMap.IsIdempotentElem.commute_iff | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {f T : M →L[R] M},
IsIdempotentElem f → (Commute f T ↔ (↑f).range ∈ Module.End.invtSubmodule ↑T ∧ (↑f).ker ∈ Module.End.invtSubmodule ↑T) | true |
Nat.pred_le_of_le_succ | Init.Data.Nat.Basic | ∀ {n m : ℕ}, n ≤ m.succ → n.pred ≤ m | true |
Mathlib.Tactic.BicategoryLike.NormalExpr.rec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {motive : Mathlib.Tactic.BicategoryLike.NormalExpr → Sort u} →
((e : Mathlib.Tactic.BicategoryLike.Mor₂) →
(α : Mathlib.Tactic.BicategoryLike.Structural) → motive (Mathlib.Tactic.BicategoryLike.NormalExpr.nil e α)) →
((e : Mathlib.Tactic.BicategoryLike.Mor₂) →
(α : Mathlib.Tactic.BicategoryLike.Structural) →
(η : Mathlib.Tactic.BicategoryLike.WhiskerLeft) →
(ηs : Mathlib.Tactic.BicategoryLike.NormalExpr) →
motive ηs → motive (Mathlib.Tactic.BicategoryLike.NormalExpr.cons e α η ηs)) →
(t : Mathlib.Tactic.BicategoryLike.NormalExpr) → motive t | false |
_private.Lean.Meta.Basic.0.Lean.Meta.orelseMergeErrorsImp | Lean.Meta.Basic | {α : Type} →
Lean.MetaM α →
Lean.MetaM α →
(optParam (Lean.Syntax → Lean.Syntax → Lean.Syntax) fun r₁ x => r₁) →
(optParam (Lean.MessageData → Lean.MessageData → Lean.MessageData) fun m₁ m₂ =>
m₁ ++ Lean.MessageData.ofFormat Std.Format.line ++ m₂) →
Lean.MetaM α | true |
ODE.FunSpace.dist_iterate_next_le | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E → E} {tmin tmax : ℝ}
{t₀ : ↑(Set.Icc tmin tmax)} {x₀ x : E} {a r L K : NNReal} (hf : IsPicardLindelof f t₀ x₀ a r L K)
(hx : x ∈ Metric.closedBall x₀ ↑r) (α : ODE.FunSpace t₀ x₀ r L) (n : ℕ),
dist α ((ODE.FunSpace.next hf hx)^[n] α) ≤
(∑ i ∈ Finset.range n, (↑K * max (tmax - ↑t₀) (↑t₀ - tmin)) ^ i / ↑i.factorial) * dist α (ODE.FunSpace.next hf hx α) | true |
List.pmap_reverse._proof_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {xs : List α}, ∀ a ∈ xs, a ∈ xs.reverse | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₁._auto_1 | Mathlib.Algebra.Homology.Factorizations.CM5a | Lean.Syntax | false |
DFinsupp.lt_of_forall_lt_of_lt | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : LinearOrder ι]
[inst_2 : (i : ι) → PartialOrder (α i)] (a b : Lex (Π₀ (i : ι), α i)) (i : ι),
(∀ j < i, (ofLex a) j = (ofLex b) j) → (ofLex a) i < (ofLex b) i → a < b | true |
Module.Basis.dualBasis_repr | Mathlib.LinearAlgebra.Dual.Basis | ∀ {R : Type uR} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq ι] (b : Module.Basis ι R M) [inst_4 : Finite ι] (l : Module.Dual R M) (i : ι),
(b.dualBasis.repr l) i = l (b i) | true |
CategoryTheory.Subgroupoid.mem_iff | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C) (F : (c : C) × (d : C) × (c ⟶ d)),
F ∈ S ↔ F.snd.snd ∈ S.arrows F.fst F.snd.fst | true |
AlgebraicGeometry.Scheme.GlueData.oneHypercover_p₁ | Mathlib.AlgebraicGeometry.GluingOneHypercover | ∀ (D : AlgebraicGeometry.Scheme.GlueData) (i₁ i₂ : D.J) (x : PUnit.{u + 1}), D.oneHypercover.p₁ x = D.f i₁ i₂ | true |
Mathlib.Meta.FunProp.withIncreasedTransitionDepth | Mathlib.Tactic.FunProp.Types | {α : Type} → Mathlib.Meta.FunProp.FunPropM (Option α) → Mathlib.Meta.FunProp.FunPropM (Option α) | true |
AddCon.instPartialOrder._proof_3 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] (x x_1 x_2 : AddCon M), x ≤ x_1 → x_1 ≤ x_2 → ∀ (x_3 x_4 : M), x x_3 x_4 → x_2 x_3 x_4 | false |
Lean.Compiler.LCNF.CtorFieldInfo | Lean.Compiler.LCNF.ToImpureType | Type | true |
Nat.add_right_inj | Init.Data.Nat.Lemmas | ∀ {m k n : ℕ}, n + m = n + k ↔ m = k | true |
CategoryTheory.ComonadHom.recOn | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{M N : CategoryTheory.Comonad C} →
{motive : CategoryTheory.ComonadHom M N → Sort u} →
(t : CategoryTheory.ComonadHom M N) →
((toNatTrans : CategoryTheory.NatTrans M.toFunctor N.toFunctor) →
(app_ε : ∀ (X : C), CategoryTheory.CategoryStruct.comp (toNatTrans.app X) (N.ε.app X) = M.ε.app X) →
(app_δ :
∀ (X : C),
CategoryTheory.CategoryStruct.comp (toNatTrans.app X) (N.δ.app X) =
CategoryTheory.CategoryStruct.comp (M.δ.app X)
(CategoryTheory.CategoryStruct.comp (toNatTrans.app (M.obj X)) (N.map (toNatTrans.app X)))) →
motive { toNatTrans := toNatTrans, app_ε := app_ε, app_δ := app_δ }) →
motive t | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.