name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Topology.Algebra.InfiniteSum.ENNReal.0.ENNReal.hasSum_coe._simp_1_1 | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {s : Finset α} {f : α → NNReal}, ∑ a ∈ s, ↑(f a) = ↑(∑ a ∈ s, f a) | false |
Equiv.Perm.permMatrix | Mathlib.LinearAlgebra.Matrix.Permutation | {n : Type u_1} → (R : Type u_2) → [DecidableEq n] → Equiv.Perm n → [Zero R] → [One R] → Matrix n n R | true |
HomogeneousLocalization.NumDenSameDeg.mk | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | {ι : Type u_1} →
{A : Type u_2} →
{σ : Type u_3} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
{𝒜 : ι → σ} →
{x : Submonoid A} →
(deg : ι) → ↥(𝒜 deg) → (den : ↥(𝒜 deg)) → ↑den ∈ x → HomogeneousLocalization.NumDenSameDeg 𝒜 x | true |
Lean.Grind.CommRing.Poly.denote_pow | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.CommRing α] (ctx : Lean.Grind.CommRing.Context α) (p : Lean.Grind.CommRing.Poly)
(k : ℕ), Lean.Grind.CommRing.Poly.denote ctx (p.pow k) = Lean.Grind.CommRing.Poly.denote ctx p ^ k | true |
CategoryTheory.GrothendieckTopology.instInfSet._proof_3 | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (T : Set (CategoryTheory.GrothendieckTopology C)) ⦃X : C⦄
⦃S : CategoryTheory.Sieve X⦄,
S ∈ sInf (CategoryTheory.GrothendieckTopology.sieves '' T) X →
∀ (R : CategoryTheory.Sieve X),
(∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄,
S.arrows f → CategoryTheor... | false |
Aesop.LocalRuleSetMember._sizeOf_1 | Aesop.RuleSet.Member | Aesop.LocalRuleSetMember → ℕ | false |
CategoryTheory.AddGrp.ofHom.eq_1 | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.AddGrpObj A] [inst_3 : CategoryTheory.AddGrpObj B] (f : A ⟶ B)
[inst_4 : CategoryTheory.IsAddMonHom f], CategoryTheory.AddGrp.ofHom f = CategoryTheory.AddGrp.homMk f | true |
AlgebraicGeometry.Scheme.Hom.stalkMap_inv_hom._proof_1 | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (e : X ≅ Y) (x : ↥X), e.inv (e.hom x) = x | false |
Mathlib.Meta.FunProp.TheoremForm.comp.elim | Mathlib.Tactic.FunProp.Theorems | {motive : Mathlib.Meta.FunProp.TheoremForm → Sort u} →
(t : Mathlib.Meta.FunProp.TheoremForm) → t.ctorIdx = 1 → motive Mathlib.Meta.FunProp.TheoremForm.comp → motive t | false |
AndThen.ctorIdx | Init.Prelude | {α : Type u} → AndThen α → ℕ | false |
Mathlib.TacticAnalysis.TriggerCondition.continue | Mathlib.Tactic.TacticAnalysis | {ctx : Type u_1} → ctx → Mathlib.TacticAnalysis.TriggerCondition ctx | true |
convex_list_sum | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] {l : List (Set E)}, (∀ i ∈ l, Convex 𝕜 i) → Convex 𝕜 l.sum | true |
Real.cos_pi_over_two_pow | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (n : ℕ), Real.cos (Real.pi / 2 ^ (n + 1)) = Real.sqrtTwoAddSeries 0 n / 2 | true |
LinearGrowth.linearGrowthInf_const_mul_self | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {a : EReal}, (LinearGrowth.linearGrowthInf fun n => a * ↑n) = a | true |
CategoryTheory.ComonadIso.mk_inv_toNatTrans | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Comonad C}
(f : M.toFunctor ≅ N.toFunctor)
(f_ε :
autoParam (∀ (X : C), CategoryTheory.CategoryStruct.comp (f.hom.app X) (N.ε.app X) = M.ε.app X)
CategoryTheory.ComonadIso.mk._auto_1)
(f_δ :
autoParam
(∀ (X : C),... | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.seqToCode.go.match_3 | Lean.Compiler.LCNF.ToLCNF | (motive : Lean.Compiler.LCNF.ToLCNF.Element → Sort u_1) →
(x : 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) →
... | false |
directedOn_singleton | Mathlib.Order.Directed | ∀ {α : Type u} {r : α → α → Prop}, Reflexive r → ∀ (a : α), DirectedOn r {a} | true |
WeierstrassCurve.Jacobian.dblY | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | {R : Type r} → [CommRing R] → WeierstrassCurve.Jacobian R → (Fin 3 → R) → R | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_insertIfNew._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
Function.locallyFinsuppWithin.logCounting._proof_7 | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [ProperSpace E] (D₁ D₂ : Function.locallyFinsupp E ℤ),
(fun r =>
∑ᶠ (z : E), ↑(((Function.locallyFinsuppWithin.toClosedBall r) (D₁ + D₂)) z) * Real.log (r * ‖z‖⁻¹) +
↑((D₁ + D₂) 0) * Real.log r) =
(fun r =>
∑ᶠ (z : E), ↑(((Function.locallyFinsup... | false |
SkewMonoidAlgebra.toFinsupp_smul | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {S : Type u_3} [inst_1 : SMulZeroClass S k] (a : S)
(b : SkewMonoidAlgebra k G), (a • b).toFinsupp = a • b.toFinsupp | true |
_private.Lean.Elab.Tactic.ElabTerm.0.Lean.Elab.Tactic.getFVarId._sparseCasesOn_1 | Lean.Elab.Tactic.ElabTerm | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Lean.MonadCacheT.instAlternative._aux_3 | Lean.Util.MonadCache | {ω α β : Type} →
{m : Type → Type} →
[inst : STWorld ω m] →
[inst_1 : BEq α] →
[inst_2 : Hashable α] →
[Alternative m] →
{α_1 : Type} → Lean.MonadCacheT α β m α_1 → (Unit → Lean.MonadCacheT α β m α_1) → Lean.MonadCacheT α β m α_1 | false |
_private.Mathlib.Analysis.Distribution.ContDiffMapSupportedIn.0.ContDiffMapSupportedIn.structureMapLM_zero_injective._simp_1_2 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
{f f' : ContinuousMultilin... | false |
_private.Mathlib.NumberTheory.SumFourSquares.0.Nat.Prime.sum_four_squares._simp_1_6 | Mathlib.NumberTheory.SumFourSquares | ∀ {R : Type u_1} [inst : CommRing R] (a b c d x y z w : R),
(a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2) * (x ^ 2 + y ^ 2 + z ^ 2 + w ^ 2) =
(a * x - b * y - c * z - d * w) ^ 2 + (a * y + b * x + c * w - d * z) ^ 2 + (a * z - b * w + c * x + d * y) ^ 2 +
(a * w + b * z - c * y + d * x) ^ 2 | false |
OpenPartialHomeomorph.ofSet_toPartialEquiv | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} (hs : IsOpen s),
(OpenPartialHomeomorph.ofSet s hs).toPartialEquiv = PartialEquiv.ofSet s | true |
Irreducible.of_map | Mathlib.Algebra.Group.Irreducible.Lemmas | ∀ {F : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Monoid M] [inst_1 : Monoid N] {f : F} {x : M}
[inst_2 : FunLike F M N] [MonoidHomClass F M N] [IsLocalHom f], Irreducible (f x) → Irreducible x | true |
CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim._proof_2 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_2} {K : Type u_1} [inst : CategoryTheory.Category.{u_3, u_2} J]
[inst_1 : CategoryTheory.Category.{u_4, u_1} K] {C : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) {X Y : K × J} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
... | false |
HomologicalComplex.HomologySequence.composableArrows₅_exact | Mathlib.Algebra.Homology.HomologySequenceLemmas | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} {S₁ : CategoryTheory.ShortComplex (HomologicalComplex C c)} (hS₁ : S₁.ShortExact) (i j : ι)
(hij : c.Rel i j), (HomologicalComplex.HomologySequence.composableArrows₅ hS₁ i j hij).Ex... | true |
MonomialOrder.image_leadingTerm_insert_zero | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] (B : Set (MvPolynomial σ R)),
m.leadingTerm '' insert 0 B = insert 0 (m.leadingTerm '' B) | true |
Vector.unattach_attach | Init.Data.Vector.Attach | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n}, xs.attach.unattach = xs | true |
Std.DHashMap.Internal.Raw₀.length_keys | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], (↑m).WF → (↑m).keys.length = (↑m).size | true |
Std.Rci.toArray_eq_toArray_Roi | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} {r : Std.Rci α} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.Rxi.IsAlwaysFinite α], r.toArray = #[r.lower] ++ r.lower<...*.toArray | true |
EuclideanDomain.mul_sub_div_left | Mathlib.Algebra.EuclideanDomain.Basic | ∀ {R : Type u} [inst : EuclideanDomain R] (x y z : R), z ≠ 0 → z ∣ y → (z * x - y) / z = x - y / z | true |
Nat.toList_rio_eq_singleton_iff._simp_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {k n : ℕ}, ((*...n).toList = [k]) = (n = 1 ∧ 0 = k) | false |
UniformSpace.Completion.algebra | Mathlib.Topology.Algebra.UniformRing | (A : Type u_2) →
[inst : Ring A] →
[inst_1 : UniformSpace A] →
[inst_2 : IsUniformAddGroup A] →
[inst_3 : IsTopologicalRing A] →
(R : Type u_3) →
[inst_4 : CommSemiring R] →
[inst_5 : Algebra R A] → [UniformContinuousConstSMul R A] → Algebra R (UniformSpace.Comple... | true |
MeasurableSpace.exists_countablyGenerated_le_of_countablySeparated | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ (α : Type u_1) [m : MeasurableSpace α] [h : MeasurableSpace.CountablySeparated α],
∃ m', MeasurableSpace.CountablyGenerated α ∧ MeasurableSpace.SeparatesPoints α ∧ m' ≤ m | true |
LinearMap.toFun_eq_coe | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_1} {S : Type u_5} {M : Type u_8} {M₃ : Type u_11} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
{f : M →ₛₗ[σ] M₃}, f.toFun = ⇑f | true |
IntermediateField.mk._flat_ctor | Mathlib.FieldTheory.IntermediateField.Basic | {K : Type u_1} →
{L : Type u_2} →
[inst : Field K] →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
(carrier : Set L) →
(∀ {a b : L}, a ∈ carrier → b ∈ carrier → a * b ∈ carrier) →
1 ∈ carrier →
(∀ {a b : L}, a ∈ carrier → b ∈ carrier → a + b ∈ carr... | false |
Batteries.CodeAction.TacticCodeActionEntry | Batteries.CodeAction.Attr | Type | true |
FGAlgCat.equivUnder._proof_1 | Mathlib.Algebra.Category.CommAlgCat.FiniteType | ∀ (R : CommRingCat) (X : FGAlgCat ↑R),
{ toCommaMorphism := (commAlgCatEquivUnder R).functor.map (CategoryTheory.CategoryStruct.id X).hom,
prop_hom_left := trivial, prop_hom_right := trivial } =
CategoryTheory.CategoryStruct.id { toComma := (commAlgCatEquivUnder R).functor.obj X.obj, prop := ⋯ } | false |
CategoryTheory.Cat.Hom.toNatTrans_comp | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : CategoryTheory.Cat} {F G H : C ⟶ D} (η₁ : F ⟶ G) (η₂ : G ⟶ H),
(CategoryTheory.CategoryStruct.comp η₁ η₂).toNatTrans = CategoryTheory.CategoryStruct.comp η₁.toNatTrans η₂.toNatTrans | true |
iSup_Prop_eq | Mathlib.Order.CompleteLattice.Basic | ∀ {ι : Sort u_4} {p : ι → Prop}, ⨆ i, p i = ∃ i, p i | true |
Algebra.Extension.instAddCommGroupH1Cotangent | Mathlib.RingTheory.Extension.Cotangent.Basic | {R : Type u} →
{S : Type v} →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → {P : Algebra.Extension R S} → AddCommGroup P.H1Cotangent | true |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves.0.CategoryTheory.regularTopology.equalizerCondition_precomp_of_preservesPullback._simp_1_2 | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op | false |
CategoryTheory.ReflQuiv.adj.homEquiv_symm_apply | Mathlib.CategoryTheory.Category.ReflQuiv | ∀ {V : Type u_1} [inst : CategoryTheory.ReflQuiver V] {C : Type u_3} [inst_1 : CategoryTheory.Category.{v_1, u_3} C]
(F : V ⥤rq C), CategoryTheory.ReflQuiv.adj.homEquiv.symm F = CategoryTheory.Cat.FreeRefl.lift F | true |
_private.Mathlib.RingTheory.ZMod.UnitsCyclic.0.ZMod.isCyclic_units_iff._simp_1_4 | Mathlib.RingTheory.ZMod.UnitsCyclic | IsCyclic (ZMod 4)ˣ = True | false |
List.getLast_append | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l' l : List α} (h : l ++ l' ≠ []),
(l ++ l').getLast h = if h' : l'.isEmpty = true then l.getLast ⋯ else l'.getLast ⋯ | true |
Aesop.Script.Tactic.mk.inj | Aesop.Script.Tactic | ∀ {uTactic : Aesop.Script.UTactic} {sTactic? : Option Aesop.Script.STactic} {uTactic_1 : Aesop.Script.UTactic}
{sTactic?_1 : Option Aesop.Script.STactic},
{ uTactic := uTactic, sTactic? := sTactic? } = { uTactic := uTactic_1, sTactic? := sTactic?_1 } →
uTactic = uTactic_1 ∧ sTactic? = sTactic?_1 | true |
_private.Lean.Meta.Transform.0.Lean.Meta.erasePatternRefAnnotations.match_1 | Lean.Meta.Transform | (motive : Option (Lean.Syntax × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Syntax × Lean.Expr)) →
((fst : Lean.Syntax) → (e : Lean.Expr) → motive (some (fst, e))) →
((x : Option (Lean.Syntax × Lean.Expr)) → motive x) → motive x | false |
IntermediateField.LinearDisjoint.finrank_left_eq_finrank | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B : IntermediateField F E}
[Module.Finite F ↥A], A.LinearDisjoint ↥B → A ⊔ B = ⊤ → Module.finrank (↥A) E = Module.finrank F ↥B | true |
CommRingCat.tensorProdIsoPushout._proof_2 | Mathlib.Algebra.Category.Ring.Under.Basic | ∀ (R S : CommRingCat) [inst : Algebra ↑R ↑S] {W : CommRingCat} (h : R ⟶ W),
CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.span h (CommRingCat.ofHom (algebraMap ↑R ↑S))) | false |
AlgebraicGeometry.quasiCompact_iff_spectral | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y}, AlgebraicGeometry.QuasiCompact f ↔ IsSpectralMap ⇑f | true |
Cardinal.dvd_of_le_of_aleph0_le | Mathlib.SetTheory.Cardinal.Divisibility | ∀ {a b : Cardinal.{u}}, a ≠ 0 → a ≤ b → Cardinal.aleph0 ≤ b → a ∣ b | true |
CategoryTheory.Over.liftCone_pt | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {J : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] (D : CategoryTheory.Functor J T) {X : T}
(s : D ⟶ (CategoryTheory.Functor.const J).obj X) (c : CategoryTheory.Limits.Cone D) (p : c.pt ⟶ X)
(hp : ∀ (j : J), CategoryTheory.CategoryStruct.comp... | true |
Std.Do.SPred.entails_true_intro | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} (P Q : Std.Do.SPred σs), ⊢ₛ P → Q ↔ P ⊢ₛ Q | true |
groupCohomology.cocyclesMk.congr_simp | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u, u, u} k G} {n : ℕ} (f f_1 : (Fin n → G) → ↑A)
(e_f : f = f_1) (h : (CategoryTheory.ConcreteCategory.hom (inhomogeneousCochains.d A n)) f = 0),
groupCohomology.cocyclesMk f h = groupCohomology.cocyclesMk f_1 ⋯ | true |
CategoryTheory.Equivalence.faithful_functor | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {E : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} E]
(e : C ≌ E), e.functor.Faithful | true |
CategoryTheory.Precoverage.IsStableUnderBaseChange.mk._flat_ctor | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C},
(∀ {ι : Type (max u v)} {S : C} {X : ι → C} (f : (i : ι) → X i ⟶ S),
CategoryTheory.Presieve.ofArrows X f ∈ J.coverings S →
∀ {Y : C} (g : Y ⟶ S) {P : ι → C} (p₁ : (i : ι) → P i ⟶ Y) (p₂ : (i : ι) → P i ⟶ X i),
... | false |
Std.HashMap.Raw.Equiv.refl | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} (m : Std.HashMap.Raw α β), m.Equiv m | true |
Finset.finsuppAntidiagEquiv.eq_1 | Mathlib.Algebra.Order.Antidiag.FinsuppEquiv | ∀ {ι : Type u_1} [inst : DecidableEq ι] (s : Finset ι) (n : ℕ),
s.finsuppAntidiagEquiv n = (s.finsuppAntidiagEquivSubtype n).trans (Sym.equivNatSum (↥s) n).symm | true |
finite_of_fin_dim_affineIndependent | Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} {ι : Type u_4} [inst : DivisionRing k] [inst_1 : AddCommGroup V]
[inst_2 : Module k V] [inst_3 : AddTorsor V P] [FiniteDimensional k V] {p : ι → P}, AffineIndependent k p → Finite ι | true |
Module.IsTorsionBySet.semilinearMap._proof_2 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : R) (x_1 : M),
id (x • x_1) = id (x • x_1) | false |
MvPolynomial.instIsPushout_1 | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ {R : Type u} [inst : CommSemiring R] {σ : Type u_1} {S : Type u_3} [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
Algebra.IsPushout R (MvPolynomial σ R) S (MvPolynomial σ S) | true |
SymAlg.instNontrivial | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [Nontrivial α], Nontrivial αˢʸᵐ | true |
_private.Mathlib.Topology.Category.TopCat.Sphere.0.TopCat.instMonoDiskBoundaryInclusion.match_1 | Mathlib.Topology.Category.TopCat.Sphere | ∀ {n : ℕ} (motive : ↑(TopCat.diskBoundary n) → Prop) (h : ↑(TopCat.diskBoundary n)),
(∀ (x : EuclideanSpace ℝ (Fin n)) (hx : x ∈ Metric.sphere 0 1), motive { down := ⟨x, hx⟩ }) → motive h | false |
FreeRing.toFreeCommRing | Mathlib.RingTheory.FreeCommRing | {α : Type u_1} → FreeRing α →+* FreeCommRing α | true |
PiNat.dist_eq_of_ne | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} {x y : (n : ℕ) → E n}, x ≠ y → dist x y = (1 / 2) ^ PiNat.firstDiff x y | true |
Std.Internal.List.find?_eq_none_iff_containsKey_eq_false | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l : List ((a : α) × β a)} {k : α},
List.find? (fun x => x.fst == k) l = none ↔ Std.Internal.List.containsKey k l = false | true |
Matroid.dep_of_not_indep._auto_1 | Mathlib.Combinatorics.Matroid.Basic | Lean.Syntax | false |
AddCommGrpCat.coyonedaObjIsoForget._proof_1 | Mathlib.Algebra.Category.Grp.ForgetCorepresentable | ∀ {X Y : AddCommGrpCat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.coyoneda.obj (Opposite.op (AddCommGrpCat.of (ULift.{u_1, 0} ℤ)))).map f)
((fun M => (CategoryTheory.ConcreteCategory.homEquiv.trans (uliftZMultiplesHom ↑M).symm).toIso) Y).hom =
CategoryTheory.CategoryStruct.comp
... | false |
Std.DTreeMap.mem_of_mem_insertIfNew' | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k a : α}
{v : β k}, a ∈ t.insertIfNew k v → ¬(cmp k a = Ordering.eq ∧ k ∉ t) → a ∈ t | true |
PythagoreanTriple.isPrimitiveClassified_of_coprime_of_zero_left | Mathlib.NumberTheory.PythagoreanTriples | ∀ {x y z : ℤ} (h : PythagoreanTriple x y z), x.gcd y = 1 → x = 0 → h.IsPrimitiveClassified | true |
wbtw_neg_iff | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] {x y z : V}, Wbtw R (-x) (-y) (-z) ↔ Wbtw R x y z | true |
MvPolynomial.aeval_eq_eval₂Hom | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] [inst_2 : Algebra R S₁]
(f : σ → S₁) (p : MvPolynomial σ R), (MvPolynomial.aeval f) p = (MvPolynomial.eval₂Hom (algebraMap R S₁) f) p | true |
Lean.MetavarContext.MkBindingM.Context.mk | Lean.MetavarContext | Lean.Name → Lean.LocalContext → Lean.MetavarContext.MkBindingM.Context | true |
_private.Std.Time.Time.Unit.Basic.0.Std.Time.Nanosecond.Offset.ofMilliseconds._proof_1 | Std.Time.Time.Unit.Basic | 1 / 1000 / ↑1000000 = 1 / 1000000000 | false |
Subalgebra.rank_eq_one_iff._simp_1 | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ {F : Type u_1} {E : Type u_2} [inst : CommRing F] [StrongRankCondition F] [inst_2 : Ring E] [inst_3 : Algebra F E]
{S : Subalgebra F E} [Nontrivial E] [Module.Free F ↥S], (Module.rank F ↥S = 1) = (S = ⊥) | false |
String.instLT | Init.Data.String.Basic | LT String | true |
AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr_symm | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} {x y : AlgebraicGeometry.Scheme.Pullback.Triplet f g}
(e : x = y),
(AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr e).symm =
AlgebraicGeometry.Scheme.Pullback.Triplet.tensorCongr ⋯ | true |
Set.semigroup | Mathlib.Algebra.Group.Pointwise.Set.Basic | {α : Type u_2} → [Semigroup α] → Semigroup (Set α) | true |
zpowers_mabs | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] (g : G),
Subgroup.zpowers |g|ₘ = Subgroup.zpowers g | true |
_private.Lean.Meta.Tactic.Cbv.BuiltinCbvSimprocs.String.0.Lean.Meta.Tactic.Cbv.simpStringAppend._regBuiltin._private.Lean.Meta.Tactic.Cbv.BuiltinCbvSimprocs.String.0.Lean.Meta.Tactic.Cbv.simpStringAppend.declare_1._@.Lean.Meta.Tactic.Cbv.BuiltinCbvSimprocs.String.3001824805._hygCtx._hyg.19 | Lean.Meta.Tactic.Cbv.BuiltinCbvSimprocs.String | IO Unit | false |
CategoryTheory.Functor.Final.coconesEquiv._proof_9 | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (F : CategoryTheory.Functor C D) [inst_2 : F.Final] {E : Type u_4}
[inst_3 : CategoryTheory.Category.{u_2, u_4} E] (G : CategoryTheory.Functor D E)
{X Y : CategoryTheory.Limits.Cocone G} (... | false |
AlgebraicGeometry.instIsOverHomOfLE | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} {U V : X.Opens} (h : U ≤ V), AlgebraicGeometry.Scheme.Hom.IsOver (X.homOfLE h) X | true |
UInt32.not_lt_zero._simp_1 | Init.Data.UInt.Lemmas | ∀ {a : UInt32}, (a < 0) = False | false |
HomotopicalAlgebra.CofibrantObject.HoCat.resolutionMap_fac | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (HomotopicalAlgebra.CofibrantObject.HoCat.resolutionMap f)
(HomotopicalAlgebra.CofibrantObject.HoCat.pResolutionObj Y) =
CategoryTheory.Cat... | true |
List.getElem?_take_of_succ | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {l : List α} {i : ℕ}, (List.take (i + 1) l)[i]? = l[i]? | true |
Submodule.orderIsoMapComapOfBijective._proof_2 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_3} {R₂ : Type u_1} {M : Type u_4} {M₂ : Type u_2} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective σ₁₂] (f : M →ₛₗ[σ₁₂] M₂),
Function.Bijective ⇑f → ∀ (p : Subm... | false |
_private.Mathlib.GroupTheory.Archimedean.0.Subgroup.cyclic_of_min._simp_1_1 | Mathlib.GroupTheory.Archimedean | ∀ {α : Type u} [inst : CommGroup α] [inst_1 : LT α] [MulLeftStrictMono α] {a b c : α}, (a / b < c) = (a < b * c) | false |
AffineMap.restrict.linear_aux | Mathlib.LinearAlgebra.AffineSpace.Restrict | ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} {V₂ : Type u_4} {P₂ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂] {φ : P₁ →ᵃ[k] P₂} {E : AffineSubspace k P₁}
{F : AffineSubspace... | true |
NumberField.isUnit_iff_norm | Mathlib.NumberTheory.NumberField.Units.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] {x : NumberField.RingOfIntegers K},
IsUnit x ↔ |↑((RingOfIntegers.norm ℚ) x)| = 1 | true |
ite_smul | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : SMul β α] (p : Prop) [inst_1 : Decidable p] (a : α) (b c : β),
(if p then b else c) • a = if p then b • a else c • a | true |
HasStrictFDerivAt.pt_implicitFunctionDataOfProdDomain | Mathlib.Analysis.Calculus.ImplicitFunction.ProdDomain | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E₁ : Type u_2} [inst_1 : NormedAddCommGroup E₁]
[inst_2 : NormedSpace 𝕜 E₁] [inst_3 : CompleteSpace E₁] {E₂ : Type u_3} [inst_4 : NormedAddCommGroup E₂]
[inst_5 : NormedSpace 𝕜 E₂] [inst_6 : CompleteSpace E₂] {F : Type u_4} [inst_7 : NormedAddCommGroup F]
[... | true |
CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_inv | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)),
CategoryTheory.CategoryStruct.comp CategoryTheory.FunctorToTypes.coprod.inl
(CategoryTheory.FunctorToTypes.binaryCoproductIso F G).inv =
CategoryTheory.Limits.coprod.inl | true |
PriestleySpace.toTotallySeparatedSpace | Mathlib.Topology.Order.Priestley | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : PartialOrder α] [PriestleySpace α], TotallySeparatedSpace α | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.commRingNorm.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) (e : Lean.Meta.Grind.Arith.CommRing.RingExpr)
(p : Lean.Grind.CommRing.Poly),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.commRingNorm c e p) = 1 + sizeOf c + sizeOf e + sizeOf p | true |
RingCat._sizeOf_1 | Mathlib.Algebra.Category.Ring.Basic | RingCat → ℕ | false |
YoungDiagram.coe_inf._simp_1 | Mathlib.Combinatorics.Young.YoungDiagram | ∀ (μ ν : YoungDiagram), ↑μ ∩ ↑ν = ↑(μ ⊓ ν) | false |
hyperoperation.match_1 | Mathlib.Data.Nat.Hyperoperation | (motive : ℕ → ℕ → ℕ → Sort u_1) →
(x x_1 x_2 : ℕ) →
((x k : ℕ) → motive 0 x k) →
((m : ℕ) → motive 1 m 0) →
((x : ℕ) → motive 2 x 0) →
((n x : ℕ) → motive n.succ.succ.succ x 0) → ((n m k : ℕ) → motive n.succ m k.succ) → motive x x_1 x_2 | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.