name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Subgroup.zpow._proof_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) (a : ↥H) (n : ℤ), ↑a ^ n ∈ H |
Std.ExtDHashMap.Const.getKey?_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → (Std.ExtDHashMap.Const.insertManyIfNewUnit m l).getKey? k' = some k |
Array.PrefixTable.step._proof_12 | Batteries.Data.Array.Match | ∀ {α : Type u_1} (t : Array.PrefixTable α) (k : ℕ),
k + 1 < t.size + 1 → ∀ (h2 : k < t.size), t.toArray[k].2 < k + 1 → t.toArray[k].2 < t.size + 1 |
Matrix.PosSemidef.kronecker | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜] [Finite n] {m : Type u_3} [Finite m] {x : Matrix n n 𝕜}
{y : Matrix m m 𝕜}, x.PosSemidef → y.PosSemidef → (Matrix.kroneckerMap (fun x1 x2 => x1 * x2) x y).PosSemidef |
_private.Mathlib.Data.Nat.Factorial.DoubleFactorial.0.Nat.doubleFactorial.match_1.eq_2 | Mathlib.Data.Nat.Factorial.DoubleFactorial | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (k : ℕ) → motive k.succ.succ),
(match 1 with
| 0 => h_1 ()
| 1 => h_2 ()
| k.succ.succ => h_3 k) =
h_2 () |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero.0.CategoryTheory.Functor.map_isZero._simp_1_1 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.Limits.IsZero X = (CategoryTheory.CategoryStruct.id X = 0) |
Multiset.sup_eq_union | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), s ⊔ t = s ∪ t |
Aesop.ForwardRuleStateStats._sizeOf_1 | Aesop.Stats.Basic | Aesop.ForwardRuleStateStats → ℕ |
MonoidHom.id._proof_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_1) [inst : MulOne M], 1 = 1 |
Ideal.comap._proof_3 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
(f : F) [RingHomClass F R S] (I : Ideal S) {x y : R}, x ∈ ⇑f ⁻¹' ↑I → y ∈ ⇑f ⁻¹' ↑I → x + y ∈ ⇑f ⁻¹' ↑I |
NormedCommRing.toNonUnitalNormedCommRing._proof_12 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : NormedCommRing α] (x y : α), dist x y = ‖-x + y‖ |
Homotopy.symm._proof_1 | Mathlib.Algebra.Homology.Homotopy | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} {f g : C ⟶ D} (h : Homotopy f g) (i j : ι),
¬c.Rel j i → (-h.hom) i j = 0 |
IsAddQuotientCoveringMap.homeomorph_comp_iff | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {G : Type u_3}
[inst_2 : AddGroup G] [inst_3 : AddAction G E] {Y : Type u_4} [inst_4 : TopologicalSpace Y] (φ : X ≃ₜ Y),
IsAddQuotientCoveringMap (⇑φ ∘ f) G ↔ IsAddQuotientCoveringMap f G |
Valued.integer.norm_unit | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {K : Type u_1} [inst : NontriviallyNormedField K] [inst_1 : IsUltrametricDist K] (u : (↥(Valued.integer K))ˣ),
‖↑u‖ = 1 |
_private.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.addUsedFVars._unsafe_rec | Lean.Meta.Tactic.Cleanup | Lean.Expr → StateRefT' IO.RealWorld (Bool × Lean.FVarIdSet) Lean.MetaM Unit |
CategoryTheory.GradedObject.CofanMapObjFun.inj_iso_hom | Mathlib.CategoryTheory.GradedObject | ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{v_1, u_4} C]
{X : CategoryTheory.GradedObject I C} {p : I → J} {j : J} [inst_1 : X.HasMap p] {c : X.CofanMapObjFun p j}
(hc : CategoryTheory.Limits.IsColimit c) (i : I) (hi : p i = j),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofan.inj c ⟨i, hi⟩)
(CategoryTheory.GradedObject.CofanMapObjFun.iso hc).hom =
X.ιMapObj p i j hi |
Std.Sat.CNF.Clause.Mem | Std.Sat.CNF.Basic | {α : Type u_1} → α → Std.Sat.CNF.Clause α → Prop |
geom_sum₂_Ico | Mathlib.Algebra.Field.GeomSum | ∀ {K : Type u_2} [inst : Field K] {x y : K},
x ≠ y → ∀ {m n : ℕ}, m ≤ n → ∑ i ∈ Finset.Ico m n, x ^ i * y ^ (n - 1 - i) = (x ^ n - y ^ (n - m) * x ^ m) / (x - y) |
Lean.Parser.Term.binderTactic.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer |
CategoryTheory.Triangulated.TStructure.ge | Mathlib.CategoryTheory.Triangulated.TStructure.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : CategoryTheory.Pretriangulated C] →
CategoryTheory.Triangulated.TStructure C → ℤ → CategoryTheory.ObjectProperty C |
_private.Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace.0.RestrictedProduct.continuous_dom_pi._simp_1_1 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f = ∀ (x : X), ContinuousAt f x |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.mkIgnoreFnImpl.match_3 | Lean.Linter.UnusedVariables | (motive : Lean.ImportM.Context → Sort u_1) →
(__discr : Lean.ImportM.Context) →
((env : Lean.Environment) → (opts : Lean.Options) → motive { env := env, opts := opts }) → motive __discr |
BoundedContinuousFunction.instAddCommGroup._proof_10 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β]
(a : BoundedContinuousFunction α β), SubNegMonoid.zsmul 0 a = 0 |
Polynomial.resultant_taylor | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (r : R),
((Polynomial.taylor r) f).resultant ((Polynomial.taylor r) g) = f.resultant g |
TestFunction.toBoundedContinuousFunctionCLM._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F], IsBoundedSMul ℝ F |
List.mkSlice_rii_eq_mkSlice_rci | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, Std.Rii.Sliceable.mkSlice xs *...* = Std.Rci.Sliceable.mkSlice xs 0...* |
Int8.toNatClampNeg_eq_zero_iff._simp_1 | Init.Data.SInt.Lemmas | ∀ {n : Int8}, (n.toNatClampNeg = 0) = (n ≤ 0) |
USize.eq_of_toFin_eq | Init.Data.UInt.Lemmas | ∀ {a b : USize}, a.toFin = b.toFin → a = b |
Std.TreeSet.getD_maxD | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp],
t.isEmpty = false → ∀ {fallback fallback' : α}, t.getD (t.maxD fallback) fallback' = t.maxD fallback |
_private.Mathlib.Data.Sym.Basic.0.Sym.count_coe_fill_of_ne._simp_1_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {a b : α} {n : ℕ}, (b ∈ Multiset.replicate n a) = (n ≠ 0 ∧ b = a) |
Nat.chineseRemainderOfList.match_1 | Mathlib.Data.Nat.ChineseRemainder | {ι : Type u_1} →
(s : ι → ℕ) →
(motive : (x : List ι) → List.Pairwise (Function.onFun Nat.Coprime s) x → Sort u_2) →
(x : List ι) →
(x_1 : List.Pairwise (Function.onFun Nat.Coprime s) x) →
((x : List.Pairwise (Function.onFun Nat.Coprime s) []) → motive [] x) →
((i : ι) →
(l : List ι) → (co : List.Pairwise (Function.onFun Nat.Coprime s) (i :: l)) → motive (i :: l) co) →
motive x x_1 |
AddConstEquiv.instPowInt._proof_1 | Mathlib.Algebra.AddConstMap.Equiv | ∀ {G : Type u_1} [inst : Add G] {a : G} (e : AddConstEquiv G G a a) (n : ℤ) (x : G),
(↑e ^ n).toFun (x + a) = (↑e ^ n).toFun x + a |
IsCoxeterGroup | Mathlib.GroupTheory.Coxeter.Basic | (W : Type u) → [Group W] → Prop |
Real.HolderTriple.holderConjugate_div_div | Mathlib.Data.Real.ConjExponents | ∀ {p q r : ℝ}, p.HolderTriple q r → (p / r).HolderConjugate (q / r) |
_private.Lean.Compiler.LCNF.Main.0.Lean.Compiler.LCNF.PassManager.run.match_3 | Lean.Compiler.LCNF.Main | (motive : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Phase.mono.toPurity) → Sort u_1) →
(__do_lift : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Phase.mono.toPurity)) →
((decl : Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Phase.mono.toPurity) → motive (some decl)) →
((x : Option (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Phase.mono.toPurity)) → motive x) → motive __do_lift |
HasStrictFDerivAt.log | Mathlib.Analysis.SpecialFunctions.Log.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {f' : StrongDual ℝ E},
HasStrictFDerivAt f f' x → f x ≠ 0 → HasStrictFDerivAt (fun x => Real.log (f x)) ((f x)⁻¹ • f') x |
LinearMap.vecEmpty | Mathlib.LinearAlgebra.Pi | {R : Type u} →
{M : Type v} →
{M₃ : Type y} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₃] → [inst_3 : Module R M] → [inst_4 : Module R M₃] → M →ₗ[R] Fin 0 → M₃ |
_private.Mathlib.NumberTheory.RamificationInertia.Basic.0.Ideal.FinrankQuotientMap.linearIndependent_of_nontrivial._simp_1_7 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] {G : Type u_7}
[inst_2 : FunLike G M N] [AddMonoidHomClass G M N] (g : G) (f : ι → M) (s : Finset ι),
∑ x ∈ s, g (f x) = g (∑ x ∈ s, f x) |
_private.Init.Data.Dyadic.Round.0.Dyadic.precision_roundDown.match_1_1 | Init.Data.Dyadic.Round | ∀ (motive : Dyadic → Prop) (x : Dyadic),
(∀ (a : Unit), motive Dyadic.zero) → (∀ (n k : ℤ) (hn : n % 2 = 1), motive (Dyadic.ofOdd n k hn)) → motive x |
Finset.pimage_eq_image_filter | Mathlib.Data.Finset.PImage | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α →. β} [inst_1 : (x : α) → Decidable (f x).Dom]
{s : Finset α}, Finset.pimage f s = Finset.image (fun x => (f ↑x).get ⋯) {x ∈ s | (f x).Dom}.attach |
AlgebraicGeometry.PrimeSpectrum.Top.eq_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R : Type u) [inst : CommRing R],
AlgebraicGeometry.PrimeSpectrum.Top R = { carrier := PrimeSpectrum R, str := PrimeSpectrum.zariskiTopology } |
AlgebraicGeometry.Scheme.Hom.normalizationCoprodIso._proof_4 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f] {U V : AlgebraicGeometry.Scheme} {iU : U ⟶ X} {iV : V ⟶ X}
(e : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk iU iV))
[inst_2 : AlgebraicGeometry.QuasiCompact iU] [inst_3 : AlgebraicGeometry.QuasiSeparated iU]
[inst_4 : AlgebraicGeometry.QuasiCompact iV] [inst_5 : AlgebraicGeometry.QuasiSeparated iV],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.coprod.desc
(AlgebraicGeometry.Scheme.Hom.normalizationDesc (CategoryTheory.CategoryStruct.comp iU f)
(CategoryTheory.CategoryStruct.comp iU (AlgebraicGeometry.Scheme.Hom.toNormalization f))
(AlgebraicGeometry.Scheme.Hom.fromNormalization f) ⋯)
(AlgebraicGeometry.Scheme.Hom.normalizationDesc (CategoryTheory.CategoryStruct.comp iV f)
(CategoryTheory.CategoryStruct.comp iV (AlgebraicGeometry.Scheme.Hom.toNormalization f))
(AlgebraicGeometry.Scheme.Hom.fromNormalization f) ⋯))
(AlgebraicGeometry.Scheme.Hom.normalizationDesc f
(CategoryTheory.CategoryStruct.comp
(e.coconePointUniqueUpToIso (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Limits.pair U V))).hom
(CategoryTheory.Limits.coprod.map
(AlgebraicGeometry.Scheme.Hom.toNormalization (CategoryTheory.CategoryStruct.comp iU f))
(AlgebraicGeometry.Scheme.Hom.toNormalization (CategoryTheory.CategoryStruct.comp iV f))))
(CategoryTheory.Limits.coprod.desc
(AlgebraicGeometry.Scheme.Hom.fromNormalization (CategoryTheory.CategoryStruct.comp iU f))
(AlgebraicGeometry.Scheme.Hom.fromNormalization (CategoryTheory.CategoryStruct.comp iV f)))
⋯) =
CategoryTheory.CategoryStruct.id
(AlgebraicGeometry.Scheme.Hom.normalization (CategoryTheory.CategoryStruct.comp iU f) ⨿
AlgebraicGeometry.Scheme.Hom.normalization (CategoryTheory.CategoryStruct.comp iV f)) |
ENNReal.mulRightOrderIso._proof_2 | Mathlib.Data.ENNReal.Inv | ∀ (a : ENNReal) (ha : IsUnit a) {a_1 b : ENNReal}, ha.unit.mulRight a_1 ≤ ha.unit.mulRight b ↔ a_1 ≤ b |
CategoryTheory.MonoidalCategory.DayConvolution.unit_uniqueUpToIso_hom_assoc | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
{F G : CategoryTheory.Functor C V} (h h' : CategoryTheory.MonoidalCategory.DayConvolution F G)
{Z : CategoryTheory.Functor (C × C) V}
(h_1 :
(CategoryTheory.MonoidalCategory.tensor C).comp (CategoryTheory.MonoidalCategory.DayConvolution.convolution F G) ⟶
Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.DayConvolution.unit F G)
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategory.tensor C).whiskerLeft (h.uniqueUpToIso h').hom) h_1) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.DayConvolution.unit F G) h_1 |
Asymptotics.isLittleOTVS_fun_neg_right | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [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] {l : Filter α} {f : α → E} {g : α → F} [ContinuousNeg F],
(f =o[𝕜; l] fun x => -g x) ↔ f =o[𝕜; l] g |
aemeasurable_inv_iff._simp_2 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {α : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {G : Type u_4} [inst : InvolutiveInv G]
[inst_1 : MeasurableSpace G] [MeasurableInv G] {f : α → G}, AEMeasurable (fun x => (f x)⁻¹) μ = AEMeasurable f μ |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.Combination.0.Set.powersetCard.stabilizer_coe._simp_1_3 | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) |
MDifferentiableWithinAt.neg | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {z : M} {f : M → E'} {s : Set M},
MDifferentiableWithinAt I (modelWithCornersSelf 𝕜 E') f s z →
MDifferentiableWithinAt I (modelWithCornersSelf 𝕜 E') (-f) s z |
IO.Process.Output.stderr | Init.System.IO | IO.Process.Output → String |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.getLitAux.match_1 | Lean.Compiler.LCNF.Simp.ConstantFold | (motive : Option ℕ → Sort u_1) →
(__discr : Option ℕ) → ((natLit : ℕ) → motive (some natLit)) → ((x : Option ℕ) → motive x) → motive __discr |
Equiv.subRight.eq_1 | Mathlib.Algebra.Group.Units.Equiv | ∀ {G : Type u_5} [inst : AddGroup G] (a : G),
Equiv.subRight a = { toFun := fun b => b - a, invFun := fun b => b + a, left_inv := ⋯, right_inv := ⋯ } |
Lean.Elab.Attribute.kind | Lean.Elab.Attributes | Lean.Elab.Attribute → Lean.AttributeKind |
RingPreordering.support.congr_simp | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {R : Type u_1} [inst : CommRing R] (P P_1 : RingPreordering R) (e_P : P = P_1) [inst_1 : P.HasIdealSupport],
P.support = P_1.support |
MeasurableEmbedding.measurable | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : α → β},
MeasurableEmbedding f → Measurable f |
CategoryTheory.HasProjectiveResolution | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasZeroObject C] → [CategoryTheory.Limits.HasZeroMorphisms C] → C → Prop |
TrivialLieModule.instLieRingModule._proof_1 | Mathlib.Algebra.Lie.Abelian | ∀ (R : Type u_1) (L : Type u_2) (M : Type u_3) [inst : AddCommGroup M] (x y : L) (m : TrivialLieModule R L M), 0 = 0 + 0 |
CategoryTheory.IsSplitEpi.mk | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y},
Nonempty (CategoryTheory.SplitEpi f) → CategoryTheory.IsSplitEpi f |
instContMDiffVectorBundleOfNatWithTopENat_1 | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {𝕜 : Type u_1} {B : Type u_2} (F : Type u_4) (E : B → Type u_6) [inst : NontriviallyNormedField 𝕜] {EB : Type u_7}
[inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB] {HB : Type u_8} [inst_3 : TopologicalSpace HB]
{IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSpace B] [inst_5 : ChartedSpace HB B]
[inst_6 : (x : B) → AddCommMonoid (E x)] [inst_7 : (x : B) → Module 𝕜 (E x)] [inst_8 : NormedAddCommGroup F]
[inst_9 : NormedSpace 𝕜 F] [inst_10 : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_11 : (x : B) → TopologicalSpace (E x)] [inst_12 : FiberBundle F E] [inst_13 : VectorBundle 𝕜 F E],
ContMDiffVectorBundle 0 F E IB |
FreeAddGroup.reduceCyclically.conj_conjugator_reduceCyclically | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u} [inst : DecidableEq α] (L : List (α × Bool)),
FreeAddGroup.reduceCyclically.conjugator L ++ FreeAddGroup.reduceCyclically L ++
FreeAddGroup.negRev (FreeAddGroup.reduceCyclically.conjugator L) =
L |
Finset.bipartiteAbove_swap | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) (s : Finset α) (b : β) [inst : (a : α) → Decidable (r a b)],
Finset.bipartiteAbove (Function.swap r) s b = Finset.bipartiteBelow r s b |
PSet.Equiv._unsafe_rec | Mathlib.SetTheory.ZFC.PSet | PSet.{u_1} → PSet.{u_2} → Prop |
AddCommute.add_left._simp_1 | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : AddSemigroup S] {a b c : S}, AddCommute a c → AddCommute b c → AddCommute (a + b) c = True |
Lean.Meta.FVarSubst.mk.injEq | Lean.Meta.Tactic.FVarSubst | ∀ (map map_1 : Lean.AssocList Lean.FVarId Lean.Expr), ({ map := map } = { map := map_1 }) = (map = map_1) |
Fin.range_castLE | Mathlib.Data.Fin.SuccPred | ∀ {n k : ℕ} (h : n ≤ k), Set.range (Fin.castLE h) = {i | ↑i < n} |
_private.Lean.Meta.Match.SolveOverlap.0.Lean.Meta.Match.injectionAny.match_1 | Lean.Meta.Match.SolveOverlap | (motive : Lean.Meta.InjectionResult → Sort u_1) →
(__do_lift : Lean.Meta.InjectionResult) →
(Unit → motive Lean.Meta.InjectionResult.solved) →
((mvarId : Lean.MVarId) →
(newEqs : Array Lean.FVarId) →
(remainingNames : List Lean.Name) →
motive (Lean.Meta.InjectionResult.subgoal mvarId newEqs remainingNames)) →
motive __do_lift |
DistribSMul.compFun | Mathlib.Algebra.GroupWithZero.Action.Defs | {M : Type u_1} →
{N : Type u_6} → (A : Type u_7) → [inst : AddZeroClass A] → [DistribSMul M A] → (N → M) → DistribSMul N A |
Polynomial.reverse_add_C | Mathlib.Algebra.Polynomial.Reverse | ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (t : R),
(p + Polynomial.C t).reverse = p.reverse + Polynomial.C t * Polynomial.X ^ p.natDegree |
RingNorm.eq_zero_of_map_eq_zero' | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_2} [inst : NonUnitalNonAssocRing R] (self : RingNorm R) (x : R), self.toFun x = 0 → x = 0 |
Lean.Parser.Tactic.pushCast | Init.Tactics | Lean.ParserDescr |
NonUnitalRingHom.codRestrict | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
{F : Type u_1} →
[inst_1 : FunLike F R S] →
[inst_2 : NonUnitalNonAssocSemiring S] →
[NonUnitalRingHomClass F R S] →
{S' : Type u_2} →
[inst_4 : SetLike S' S] →
[inst_5 : NonUnitalSubsemiringClass S' S] → (f : F) → (s : S') → (∀ (x : R), f x ∈ s) → R →ₙ+* ↥s |
String.instDecidableIsValidForSlice | Init.Data.String.Basic | {s : String.Slice} → {p : String.Pos.Raw} → Decidable (String.Pos.Raw.IsValidForSlice s p) |
Matrix.transpose_replicateCol | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {α : Type v} {ι : Type u_6} (v : m → α), (Matrix.replicateCol ι v).transpose = Matrix.replicateRow ι v |
Prod.swap_eq_iff_eq_swap | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α × β} {y : β × α}, x.swap = y ↔ x = y.swap |
Matrix.equiv_GL_linearindependent | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Card | {𝔽 : Type u_1} → [inst : Field 𝔽] → [Fintype 𝔽] → (n : ℕ) → GL (Fin n) 𝔽 ≃ { s // LinearIndependent 𝔽 s } |
dvd_sub_comm | Mathlib.Algebra.Ring.Divisibility.Basic | ∀ {α : Type u_1} [inst : NonUnitalRing α] {a b c : α}, a ∣ b - c ↔ a ∣ c - b |
_private.Init.Data.BitVec.Bitblast.0.BitVec.carry_succ._proof_1_4 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (i : ℕ) (x y : BitVec w) (c : Bool),
¬(2 * 2 ^ i ≤ x.toNat % 2 ^ i + (2 ^ i + y.toNat % 2 ^ i) + c.toNat ↔
2 ^ i ≤ x.toNat % 2 ^ i + y.toNat % 2 ^ i + c.toNat) →
False |
_private.Mathlib.Combinatorics.SetFamily.Shatter.0.Finset.card_le_card_shatterer._simp_1_9 | Mathlib.Combinatorics.SetFamily.Shatter | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) |
HomotopicalAlgebra.CofibrantObject.HoCat.localizerMorphismResolution_functor | Mathlib.AlgebraicTopology.ModelCategory.CofibrantObjectHomotopy | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : HomotopicalAlgebra.ModelCategory C],
(HomotopicalAlgebra.CofibrantObject.HoCat.localizerMorphismResolution C).functor =
HomotopicalAlgebra.CofibrantObject.HoCat.resolution |
CategoryTheory.LocalizerMorphism.LeftResolution.op | Mathlib.CategoryTheory.Localization.Resolution | {C₁ : Type u_1} →
{C₂ : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{Φ : CategoryTheory.LocalizerMorphism W₁ W₂} →
{X₂ : C₂} → Φ.LeftResolution X₂ → Φ.op.RightResolution (Opposite.op X₂) |
ContMDiffOn.of_succ | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {s : Set M}
{n : WithTop ℕ∞}, ContMDiffOn I I' (n + 1) f s → ContMDiffOn I I' n f s |
BoxIntegral.Prepartition.splitMany_insert | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {ι : Type u_1} (I : BoxIntegral.Box ι) (s : Finset (ι × ℝ)) (p : ι × ℝ),
BoxIntegral.Prepartition.splitMany I (insert p s) =
BoxIntegral.Prepartition.splitMany I s ⊓ BoxIntegral.Prepartition.split I p.1 p.2 |
DilationEquiv.smulTorsor._proof_1 | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedDivisionRing 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module 𝕜 E]
{P : Type u_3} [inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor E P] (c : P) {k : 𝕜},
k ≠ 0 → ∀ (x : E), (k⁻¹ • fun x => x -ᵥ c) ((fun x => k • x +ᵥ c) x) = x |
continuousAt_pi | Mathlib.Topology.Constructions | ∀ {X : Type u} {ι : Type u_5} {A : ι → Type u_6} [inst : TopologicalSpace X] [T : (i : ι) → TopologicalSpace (A i)]
{f : X → (i : ι) → A i} {x : X}, ContinuousAt f x ↔ ∀ (i : ι), ContinuousAt (fun y => f y i) x |
Filter.Tendsto.inf_nhds | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} [inst : TopologicalSpace L] {α : Type u_3} {l : Filter α} {f g : α → L} {x y : L} [inst_1 : Min L]
[ContinuousInf L],
Filter.Tendsto f l (nhds x) → Filter.Tendsto g l (nhds y) → Filter.Tendsto (fun i => f i ⊓ g i) l (nhds (x ⊓ y)) |
Lean.Parser.Tactic.tacticSeq1Indented | Lean.Parser.Term.Basic | Lean.Parser.Parser |
Order.PFilter.sInf_gc | Mathlib.Order.PFilter | ∀ {P : Type u_1} [inst : CompleteSemilatticeInf P],
GaloisConnection (fun x => OrderDual.toDual (Order.PFilter.principal x)) fun F => sInf ↑(OrderDual.ofDual F) |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ToArrowResult._sizeOf_inst | Lean.Meta.Sym.Simp.Forall | SizeOf Lean.Meta.Sym.Simp.ToArrowResult✝ |
Lean.Elab.Tactic.Grind.saveTacticInfoForToken | Lean.Elab.Tactic.Grind.Basic | Lean.Syntax → Lean.Elab.Tactic.Grind.GrindTacticM Unit |
TestFunction.coe_sub | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_4}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞} (f g : TestFunction Ω F n), ⇑(f - g) = ⇑f - ⇑g |
Rack.instDivInvMonoidEnvelGroup._proof_2 | Mathlib.Algebra.Quandle | ∀ (R : Type u_1) [inst : Rack R] (a b c : Rack.EnvelGroup R), a * b * c = a * (b * c) |
ContinuousLinearMap.prodₗᵢ | Mathlib.Analysis.Normed.Operator.Prod | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
{G : Type u_4} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] →
[inst_2 : SeminormedAddCommGroup F] →
[inst_3 : SeminormedAddCommGroup G] →
[inst_4 : NormedSpace 𝕜 E] →
[inst_5 : NormedSpace 𝕜 F] →
[inst_6 : NormedSpace 𝕜 G] →
(R : Type u_5) →
[inst_7 : Semiring R] →
[inst_8 : Module R F] →
[inst_9 : Module R G] →
[inst_10 : ContinuousConstSMul R F] →
[inst_11 : ContinuousConstSMul R G] →
[inst_12 : SMulCommClass 𝕜 R F] →
[inst_13 : SMulCommClass 𝕜 R G] → (E →L[𝕜] F) × (E →L[𝕜] G) ≃ₗᵢ[R] E →L[𝕜] F × G |
instSubInt16 | Init.Data.SInt.Basic | Sub Int16 |
ContinuousLinearEquiv.comp_differentiableAt_iff | Mathlib.Analysis.Calculus.FDeriv.Equiv | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (iso : E ≃L[𝕜] F) {f : G → E} {x : G},
DifferentiableAt 𝕜 (⇑iso ∘ f) x ↔ DifferentiableAt 𝕜 f x |
mul_self_sub_one | Mathlib.Algebra.Ring.Commute | ∀ {R : Type u} [inst : NonAssocRing R] (a : R), a * a - 1 = (a + 1) * (a - 1) |
CategoryTheory.SymmetricCategory.recOn | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{motive : CategoryTheory.SymmetricCategory C → Sort u_1} →
(t : CategoryTheory.SymmetricCategory C) →
([toBraidedCategory : CategoryTheory.BraidedCategory C] →
(symmetry :
∀ (X Y : C),
CategoryTheory.CategoryStruct.comp (β_ X Y).hom (β_ Y X).hom =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)) →
motive { toBraidedCategory := toBraidedCategory, symmetry := symmetry }) →
motive t |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.isNonTrivialRegular.match_1 | Lean.Meta.ExprDefEq | (motive : Option Lean.ProjectionFunctionInfo → Sort u_1) →
(__do_lift : Option Lean.ProjectionFunctionInfo) →
((projInfo : Lean.ProjectionFunctionInfo) → motive (some projInfo)) →
((x : Option Lean.ProjectionFunctionInfo) → motive x) → motive __do_lift |
ContDiffOn.inv | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {n : WithTop ℕ∞} {𝕜' : Type u_4} [inst_3 : NormedField 𝕜']
[inst_4 : NormedAlgebra 𝕜 𝕜'] {f : E → 𝕜'},
ContDiffOn 𝕜 n f s → (∀ x ∈ s, f x ≠ 0) → ContDiffOn 𝕜 n (fun x => (f x)⁻¹) s |
TensorPower.multilinearMapToDual._proof_4 | Mathlib.LinearAlgebra.TensorPower.Pairing | ∀ (R : Type u_1) [inst : CommSemiring R], SMulCommClass R R R |
CategoryTheory.Limits.filteredColimitsModule._proof_1 | Mathlib.Algebra.Category.ModuleCat.Stalk | ∀ {C : Type u_1} [inst : CategoryTheory.SmallCategory C] [inst_1 : CategoryTheory.IsFiltered C]
(R : CategoryTheory.Functor C RingCat) (M : CategoryTheory.Functor C Ab)
[inst_2 : (i : C) → Module ↑(R.obj i) ↑(M.obj i)]
(H :
∀ {i j : C} (f : i ⟶ j) (r : ↑(R.obj i)) (m : ↑(M.obj i)),
(CategoryTheory.ConcreteCategory.hom (M.map f)) (r • m) =
(CategoryTheory.ConcreteCategory.hom (R.map f)) r • (CategoryTheory.ConcreteCategory.hom (M.map f)) m)
(r s : ↑(RingCat.FilteredColimits.colimit R)) (m : ↑(AddCommGrpCat.FilteredColimits.colimit M)),
(r * s) • m = r • s • m |
HeytAlg.ofHom_id | Mathlib.Order.Category.HeytAlg | ∀ {X : Type u} [inst : HeytingAlgebra X],
HeytAlg.ofHom (HeytingHom.id X) = CategoryTheory.CategoryStruct.id (HeytAlg.of X) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.