name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex._proof_8 | 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 = ... | null | false |
Algebra.FormallySmooth.iff_injective_lTensor_residueField | Mathlib.RingTheory.Smooth.Local | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsLocalRing S]
[inst_3 : Algebra R S] (P : Algebra.Extension R S) [Algebra.FormallySmooth R P.Ring] [Module.Free P.Ring Ω[P.Ring⁄R]]
[Module.Finite P.Ring Ω[P.Ring⁄R]],
P.ker.FG →
(Algebra.FormallySmooth R S ↔
Function.I... | The **Jacobian criterion** for smoothness of local algebras.
Suppose `S` is a local `R`-algebra, and `0 → I → P → S → 0` is a presentation such that
`P` is formally-smooth over `R`, `Ω[P⁄R]` is finite free over `P`,
(typically satisfied when `P` is the localization of a polynomial ring of finite type)
and `I` is finite... | true |
CategoryTheory.Limits.biprod.braiding | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] → (P Q : C) → P ⊞ Q ≅ Q ⊞ P | The braiding isomorphism which swaps a binary biproduct. | true |
Representation.IntertwiningMap.instSemiring._proof_3 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module A V] (ρ : Representation A G V) (a : ρ.IntertwiningMap ρ), a * 0 = 0 | null | false |
AddEquiv.coe_toAddHom | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] {f : M ≃+ N}, ⇑f.toAddHom = ⇑f | null | true |
WittVector.mul_coeff_zero | Mathlib.RingTheory.WittVector.Defs | ∀ {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [inst : CommRing R] (x y : WittVector p R),
(x * y).coeff 0 = x.coeff 0 * y.coeff 0 | null | true |
exteriorPower.coe_map | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {n : ℕ} {M : Type u_1} {N : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N) (x : ↥(⋀[R]^n M)),
↑((exteriorPower.map n f) x) = (ExteriorAlgebra.map f) ↑x | null | true |
_private.Lean.Util.Trace.0.Lean.initFn._@.Lean.Util.Trace.1925802394._hygCtx._hyg.4 | Lean.Util.Trace | IO (Lean.Option Bool) | null | false |
Nat.dfoldRev_zero._auto_1 | Init.Data.Nat.Fold | Lean.Syntax | null | false |
CategoryTheory.Comon.Hom.mk.congr_simp | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N : CategoryTheory.Comon C} (hom hom_1 : M.X ⟶ N.X) (e_hom : hom = hom_1)
[isComonHom_hom : CategoryTheory.IsComonHom hom],
{ hom := hom, isComonHom_hom := isComonHom_hom } = { hom := hom_1, isComonHom_hom ... | null | true |
CategoryTheory.Bicategory.RightLift.whiskerIdCancel_left | Mathlib.CategoryTheory.Bicategory.Extension | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a}
(t :
CategoryTheory.Bicategory.RightLift f (CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id c) g))
{s : CategoryTheory.Bicategory.RightLift f g} (τ : s.whisker (CategoryTheory.CategoryStruct.id c) ⟶ t),
... | null | true |
Lean.Elab.GoalsAtResult.casesOn | Lean.Elab.InfoTree.Util | {motive : Lean.Elab.GoalsAtResult → Sort u} →
(t : Lean.Elab.GoalsAtResult) →
((ctxInfo : Lean.Elab.ContextInfo) →
(tacticInfo : Lean.Elab.TacticInfo) →
(useAfter indented hangingBy : Bool) →
(priority : ℕ) →
motive
{ ctxInfo := ctxInfo, tacticInfo := ta... | null | false |
CompHausLike.sigmaComparison | Mathlib.Topology.Category.CompHausLike.SigmaComparison | {P : TopCat → Prop} →
[inst : CompHausLike.HasExplicitFiniteCoproducts P] →
(X : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))) →
{α : Type u} →
[inst_1 : Finite α] →
(σ : α → Type u) →
[inst_2 : (a : α) → TopologicalSpace (σ a)] →
[inst_3 : ∀ (a : α)... | The comparison map from the value of a condensed set on a finite coproduct to the product of the
values on the components.
| true |
NonUnitalSubring.instTop._proof_1 | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] {a b : R}, a ∈ ⊤.carrier → b ∈ ⊤.carrier → a + b ∈ ⊤.carrier | null | false |
Order.IsSuccPrelimit.mid | Mathlib.Order.SuccPred.Limit | {α : Type u_1} → [inst : Preorder α] → {i j : α} → Order.IsSuccPrelimit i → j < i → ↑(Set.Ioo j i) | Given `j < i` with `i` a successor pre-limit, `IsSuccPrelimit.mid` picks an arbitrary element
strictly between `j` and `i`. | true |
DividedPowers.dpow | Mathlib.RingTheory.DividedPowers.Basic | {A : Type u_1} → [inst : CommSemiring A] → {I : Ideal A} → DividedPowers I → ℕ → A → A | The divided power function underlying a divided power structure | true |
IsUnital.toCommRing._proof_8 | Mathlib.Algebra.Ring.Defs | ∀ {A : Type u_1} [inst : NonUnitalCommRing A] (a b c : A), a * b * c = a * (b * c) | null | false |
SkewMonoidAlgebra.coeff_erase_ne | Mathlib.Algebra.SkewMonoidAlgebra.Single | ∀ {M : Type u_4} {α : Type u_5} [inst : AddCommMonoid M] {a a' : α} (f : SkewMonoidAlgebra M α),
a' ≠ a → ((SkewMonoidAlgebra.erase a) f).coeff a' = f.coeff a' | null | true |
ChainComplex.single₀_map_f_zero | Mathlib.Algebra.Homology.Single | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
[inst_2 : CategoryTheory.Limits.HasZeroObject V] {A B : V} (f : A ⟶ B), ((ChainComplex.single₀ V).map f).f 0 = f | null | true |
_private.Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree.0.Polynomial.isMonicOfDegree_two_iff'._simp_1_3 | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {α : Type u} [inst : Mul α] [inst_1 : HasDistribNeg α] (a b : α), -(a * b) = -a * b | null | false |
Lean.instHashableFVarId | Lean.Expr | Hashable Lean.FVarId | null | true |
Associates.mk_ne_zero | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : MonoidWithZero M] {a : M}, Associates.mk a ≠ 0 ↔ a ≠ 0 | null | true |
lipschitzWith_homothety | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {V : Type u_1} {P : Type u_2} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
[inst_2 : NormedAddTorsor V P] {𝕜 : Type u_5} [inst_3 : NormedField 𝕜] [inst_4 : NormedSpace 𝕜 V] (p : P) (c : 𝕜),
LipschitzWith ‖c‖₊ ⇑(AffineMap.homothety p c) | null | true |
Std.LawfulOrderInf.recOn | Init.Data.Order.Classes | {α : Type u} →
[inst : Min α] →
[inst_1 : LE α] →
{motive : Std.LawfulOrderInf α → Sort u_1} →
(t : Std.LawfulOrderInf α) → ((le_min_iff : ∀ (a b c : α), a ≤ b ⊓ c ↔ a ≤ b ∧ a ≤ c) → motive ⋯) → motive t | null | false |
Nat.factorization_ordCompl | Mathlib.Data.Nat.Factorization.Basic | ∀ (n p : ℕ), (n / p ^ n.factorization p).factorization = Finsupp.erase p n.factorization | null | true |
CategoryTheory.Limits.instFintypeWalkingParallelPairHom._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits | ∀ (j j' : CategoryTheory.Limits.WalkingParallelPair) (x : CategoryTheory.Limits.WalkingParallelPairHom j j'),
x ∈
CategoryTheory.Limits.WalkingParallelPair.recOn j
(CategoryTheory.Limits.WalkingParallelPair.recOn j'
[CategoryTheory.Limits.WalkingParallelPairHom.id CategoryTheory.Limits.WalkingParall... | null | false |
MeasureTheory.«_aux_Mathlib_MeasureTheory_Measure_MutuallySingular___macroRules_MeasureTheory_term_⟂ₘ__1» | Mathlib.MeasureTheory.Measure.MutuallySingular | Lean.Macro | null | false |
PseudoMetricSpace.ofPreNNDist._proof_4 | Mathlib.Topology.Metrizable.Uniformity | ∀ {X : Type u_1} (d : X → X → NNReal) (dist_self : ∀ (x : X), d x x = 0) (dist_comm : ∀ (x y : X), d x y = d y x)
(x y : X),
↑(NNReal.mk ((fun x y => ↑(⨅ l, (List.zipWith d (x :: l) (l ++ [y])).sum)) x y) ⋯) =
ENNReal.ofReal ↑(⨅ l, (List.zipWith d (x :: l) (l ++ [y])).sum) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.sign_two_nsmul_eq_sign_iff._simp_1_7 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, (0 < θ.cos) = (|θ.toReal| < Real.pi / 2) | null | false |
MeasurableEmbedding.map_comap | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} {m1 : MeasurableSpace β} {f : α → β},
MeasurableEmbedding f →
∀ (μ : MeasureTheory.Measure β),
MeasureTheory.Measure.map f (MeasureTheory.Measure.comap f μ) = μ.restrict (Set.range f) | null | true |
FinVec.Forall.eq_2 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_1} (n : ℕ) (P : (Fin (n + 1) → α) → Prop),
FinVec.Forall P = ∀ (x : α), FinVec.Forall fun v => P (Matrix.vecCons x v) | null | true |
List.splitWrtCompositionAux._f | Mathlib.Combinatorics.Enumerative.Composition | {α : Type u_1} → (x : List ℕ) → List.below (motive := fun x => List α → List (List α)) x → List α → List (List α) | null | false |
IsCompact.adherence_nhdset | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X} {f : Filter X},
IsCompact s → f ≤ Filter.principal s → IsOpen t → (∀ x ∈ s, ClusterPt x f → x ∈ t) → t ∈ f | null | true |
Submodule.reflectionLinearEquiv._proof_2 | Mathlib.Analysis.InnerProductSpace.Projection.Reflection | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
Polynomial.IsSplittingField.map | Mathlib.FieldTheory.SplittingField.IsSplittingField | ∀ {F : Type u} {K : Type v} (L : Type w) [inst : Field K] [inst_1 : Field L] [inst_2 : Field F] [inst_3 : Algebra K L]
[inst_4 : Algebra F K] [inst_5 : Algebra F L] [IsScalarTower F K L] (f : Polynomial F)
[Polynomial.IsSplittingField F L f], Polynomial.IsSplittingField K L (Polynomial.map (algebraMap F K) f) | null | true |
Homeomorph.toEquiv_injective | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
Function.Injective Homeomorph.toEquiv | null | true |
DiscreteTiling.PlacedTile.mem_smul_iff_smul_inv_mem | Mathlib.Combinatorics.Tiling.Tile | ∀ {G : Type u_1} {X : Type u_2} {ιₚ : Type u_3} [inst : Group G] [inst_1 : MulAction G X]
{ps : DiscreteTiling.Protoset G X ιₚ} {g : G} {x : X} {pt : DiscreteTiling.PlacedTile ps}, x ∈ g • pt ↔ g⁻¹ • x ∈ pt | null | true |
CompleteLattice.rec | Mathlib.Order.CompleteLattice.Defs | {α : Type u_4} →
{motive : CompleteLattice α → Sort u} →
([toLattice : Lattice α] →
[toSupSet : SupSet α] →
(isLUB_sSup : ∀ (s : Set α), IsLUB s (sSup s)) →
[toInfSet : InfSet α] →
(isGLB_sInf : ∀ (s : Set α), IsGLB s (sInf s)) →
[toBoundedOrder : Bounde... | null | false |
AlgEquiv.ofClass._proof_1 | Mathlib.Algebra.Algebra.Equiv | ∀ {F : Type u_3} {R : Type u_4} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : EquivLike F A B]
[inst_6 : AlgEquivClass F R A B] (f : F) (x y : A), (↑f).toFun (x * y) = (↑f).toFun x * (↑f).toFun y | null | false |
CategoryTheory.FreeMonoidalCategory.projectObj.match_1 | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u_1} →
(motive : CategoryTheory.FreeMonoidalCategory C → Sort u_2) →
(x : CategoryTheory.FreeMonoidalCategory C) →
((X : C) → motive (CategoryTheory.FreeMonoidalCategory.of X)) →
(Unit → motive CategoryTheory.FreeMonoidalCategory.unit) →
((X Y : CategoryTheory.FreeMonoidalCategor... | null | false |
CategoryTheory.NatTrans.rightDerivedFunctorPlus_neg | Mathlib.Algebra.Homology.DerivedCategory.RightDerivedFunctorPlus | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] [inst_4 : HasDerivedCategory C] [inst_5 : HasDerivedCategory D]
[inst_6 : CategoryTheory.EnoughInjectives C] {F₁ F₂ ... | null | true |
support_iteratedFDeriv_subset | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
(n : ℕ), Function.support (iteratedFDeriv 𝕜 n f) ⊆ tsupport f | null | true |
Set.preimage_image_eq | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} (s : Set α), Function.Injective f → f ⁻¹' f '' s = s | null | true |
Mathlib.Tactic.DepRewrite.depRwSeq | Mathlib.Tactic.DepRewrite | Lean.ParserDescr | `rw!` is like `rewrite!`, but also cleans up introduced refl-casts after every substitution.
It is available as an ordinary tactic and a `conv` tactic.
| true |
String.append_assoc | Init.Data.String.Defs | ∀ {s₁ s₂ s₃ : String}, s₁ ++ s₂ ++ s₃ = s₁ ++ (s₂ ++ s₃) | null | true |
Fin.val_ne_iff | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {a b : Fin n}, ↑a ≠ ↑b ↔ a ≠ b | null | true |
upperSemicontinuous_const | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder β] {z : β},
UpperSemicontinuous fun _x => z | null | true |
ContinuousLinearMap.range_prod_eq | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.PiProd | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {M₂ : Type u_3} [inst_4 : TopologicalSpace M₂] [inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂]
{M₃ : Type u_4} [inst_7 : TopologicalSpace M₃] [inst_8 : AddCommGroup M₃] [inst_9 : Module R ... | null | true |
Std.DTreeMap.Internal.Impl.inter | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
[Ord α] →
(m₁ : Std.DTreeMap.Internal.Impl α β) →
Std.DTreeMap.Internal.Impl α β → m₁.Balanced → Std.DTreeMap.Internal.Impl α β | Internal implementation detail of the hash map | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Defs.0.linearIndepOn_finset_iff._simp_1_2 | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{v : ι → M} [inst_3 : Fintype ι], LinearIndependent R v = ∀ (g : ι → R), ∑ i, g i • v i = 0 → ∀ (i : ι), g i = 0 | null | false |
Std.TreeSet.Raw.maxD_erase_le_maxD | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α},
(t.erase k).isEmpty = false → ∀ {fallback : α}, (cmp ((t.erase k).maxD fallback) (t.maxD fallback)).isLE = true | null | true |
Besicovitch.TauPackage.index.eq_1 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
(x : Ordinal.{u}),
p.index x =
Classical.epsilon fun b =>
p.c b ∉ ⋃ j, Metric.ball (p.c (p.index ↑j)) (p.r (p.index ↑j)) ∧ ⨆ b, p.r ↑b ≤ p.τ * p.r b | null | true |
Polynomial.monomial_eq_zero_iff._simp_1 | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (t : R) (n : ℕ), ((Polynomial.monomial n) t = 0) = (t = 0) | null | false |
RelHom.instMonoid._proof_5 | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (x : r →r r), x * 1 = x * 1 | null | false |
AlgebraicGeometry.Scheme.LocalRepresentability.glueData_V | Mathlib.AlgebraicGeometry.Sites.Representability | ∀ {F : CategoryTheory.Sheaf AlgebraicGeometry.Scheme.zariskiTopology (Type u)} {ι : Type u}
{X : ι → AlgebraicGeometry.Scheme} {f : (i : ι) → CategoryTheory.yoneda.obj (X i) ⟶ F.obj}
(hf : ∀ (i : ι), AlgebraicGeometry.IsOpenImmersion.presheaf (f i)) (x : ι × ι),
(AlgebraicGeometry.Scheme.LocalRepresentability.glu... | null | true |
AddGroup.IsVirtuallyAddCyclic.rec | Mathlib.GroupTheory.SpecificGroups.VirtuallyCyclic | {G : Type u_3} →
[inst : AddGroup G] →
{motive : AddGroup.IsVirtuallyAddCyclic G → Sort u} →
((exists_isAddCyclic_and_finiteIndex : ∃ H, IsAddCyclic ↥H ∧ H.FiniteIndex) → motive ⋯) →
(t : AddGroup.IsVirtuallyAddCyclic G) → motive t | null | false |
RootPairing.Equiv.mk.congr_simp | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : 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] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Mod... | null | true |
RingCon.comapQuotientEquivOfSurj._proof_4 | Mathlib.RingTheory.Congruence.Hom | ∀ {N : Type u_1} [inst : NonAssocSemiring N], MulHomClass (N ≃+* N) N N | null | false |
Algebra.SubmersivePresentation.sectionCotangent._proof_2 | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_1} {S : Type u_3} {ι : Type u_2} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ),
SMulCommClass P.toExtension.Ring S S | null | false |
AddGroupSeminorm.instOne.eq_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] [inst_1 : DecidableEq E],
AddGroupSeminorm.instOne =
{ one := { toFun := fun x => if x = 0 then 0 else 1, map_zero' := ⋯, add_le' := ⋯, neg' := ⋯ } } | null | true |
C_p_pow_dvd_bind₁_rename_wittPolynomial_sub_sum | Mathlib.RingTheory.WittVector.StructurePolynomial | ∀ {p : ℕ} {idx : Type u_2} [hp : Fact (Nat.Prime p)] (Φ : MvPolynomial idx ℤ) (n : ℕ),
(∀ m < n,
(MvPolynomial.map (Int.castRingHom ℚ)) (wittStructureInt p Φ m) =
wittStructureRat p ((MvPolynomial.map (Int.castRingHom ℚ)) Φ) m) →
MvPolynomial.C ↑(p ^ n) ∣
(MvPolynomial.bind₁ fun b => (MvPolyno... | null | true |
Std.Time.PlainDateTime.mk.noConfusion | Std.Time.DateTime.PlainDateTime | {P : Sort u} →
{date : Std.Time.PlainDate} →
{time : Std.Time.PlainTime} →
{date' : Std.Time.PlainDate} →
{time' : Std.Time.PlainTime} →
{ date := date, time := time } = { date := date', time := time' } → (date = date' → time = time' → P) → P | null | false |
Aesop.SimpTheorems.addSimpEntry | Aesop.Util.Basic | Lean.Meta.SimpTheorems → Lean.Meta.SimpEntry → Lean.Meta.SimpTheorems | null | true |
instSMulCommClassMatrixFinOfNatNatProd | Mathlib.Topology.Compactification.OnePoint.ProjectiveLine | ∀ {R : Type u_1} [inst : Semiring R] {S : Type u_2} [inst_1 : DistribSMul S R] [SMulCommClass R S R],
SMulCommClass (Matrix (Fin 2) (Fin 2) R) S (R × R) | null | true |
EMetric.dense_iff | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u_2} [inst : PseudoEMetricSpace α] {s : Set α},
Dense s ↔ ∀ (x : α), ∀ r > 0, (Metric.eball x r ∩ s).Nonempty | null | true |
Mathlib.Tactic.GCongr.addGCongrLemmaEntry | Mathlib.Tactic.GCongr.Core | Mathlib.Tactic.GCongr.GCongrLemmas → Mathlib.Tactic.GCongr.GCongrLemma → Mathlib.Tactic.GCongr.GCongrLemmas | Insert a `GCongrLemma` in a collection of lemmas, making sure they are sorted by priority. | true |
IsLocalExtrOn.isLocalExtr | Mathlib.Topology.Order.LocalExtr | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β} {s : Set α} {a : α},
IsLocalExtrOn f s a → s ∈ nhds a → IsLocalExtr f a | null | true |
CompHaus.limitCone | Mathlib.Topology.Category.CompHaus.Basic | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] → (F : CategoryTheory.Functor J CompHaus) → CategoryTheory.Limits.Cone F | An explicit limit cone for a functor `F : J ⥤ CompHaus`, defined in terms of
`TopCat.limitCone`. | true |
CategoryTheory.Sieve.pushforward_le_bind_of_mem | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (S : CategoryTheory.Presieve X)
(R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Sieve Y) (f : Y ⟶ X) (h : S f),
CategoryTheory.Sieve.pushforward f (R h) ≤ CategoryTheory.Sieve.bind S R | null | true |
CategoryTheory.Limits.biproduct.lift_desc | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_1}
[inst_2 : Fintype J] {f : J → C} [inst_3 : CategoryTheory.Limits.HasBiproduct f] {T U : C} {g : (j : J) → T ⟶ f j}
{h : (j : J) → f j ⟶ U},
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.bipr... | null | true |
Std.DTreeMap.Internal.RocSliceData.rec | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.RocSliceData α β → Sort u_1} →
((treeMap : Std.DTreeMap.Internal.Impl α β) →
(range : Std.Roc α) → motive { treeMap := treeMap, range := range }) →
(t : Std.DTreeMap.Internal.RocSliceData α β) → ... | null | false |
IterateAddAct.rec | Mathlib.GroupTheory.GroupAction.IterateAct | {α : Type u_1} →
{f : α → α} →
{motive : IterateAddAct f → Sort u} → ((val : ℕ) → motive { val := val }) → (t : IterateAddAct f) → motive t | null | false |
LawfulMonadStateOf.map_pure._inherited_default | Batteries.Control.LawfulMonadState | ∀ {σ : semiOutParam (Type u_1)} {m : Type u_1 → Type u_2} {inst : Monad m} {inst_1 : MonadStateOf σ m},
(∀ {α β : Type u_1} (f : α → β) (x : m α),
(do
let a ← x
pure (f a)) =
f <$> x) →
(∀ {α β : Type u_1} (x : α) (f : α → m β), pure x >>= f = f x) →
∀ {α β : Type u_1} (g :... | null | false |
Set.insert_def | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} (x : α) (s : Set α), insert x s = {y | y = x ∨ y ∈ s} | null | true |
Vector.swap._proof_1 | Init.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n) (i j : ℕ) (hi : i < n) (hj : j < n), (xs.toArray.swap i j ⋯ ⋯).size = n | null | false |
Fin.preimage_cast_Ioc | Mathlib.Order.Interval.Set.Fin | ∀ {m n : ℕ} (h : m = n) (i j : Fin n), Fin.cast h ⁻¹' Set.Ioc i j = Set.Ioc (Fin.cast ⋯ i) (Fin.cast ⋯ j) | null | true |
Matrix.det_eq_prod_roots_charpoly_of_splits | Mathlib.LinearAlgebra.Matrix.Charpoly.Eigs | ∀ {n : Type u_1} [inst : Fintype n] [inst_1 : DecidableEq n] {R : Type u_2} [inst_2 : CommRing R] {B : Matrix n n R}
[inst_3 : IsDomain R], B.charpoly.Splits → B.det = B.charpoly.roots.prod | null | true |
Nat.two_pow_add_eq_or_of_lt | Init.Data.Nat.Bitwise.Lemmas | ∀ {i b : ℕ}, b < 2 ^ i → ∀ (a : ℕ), 2 ^ i * a + b = 2 ^ i * a ||| b | null | true |
_private.Init.Data.Fin.Iterate.0.Fin.hIterateFrom._unary.eq_def | Init.Data.Fin.Iterate | ∀ (P : ℕ → Sort u_1) {n : ℕ} (f : (i : Fin n) → P ↑i → P (↑i + 1)) (_x : (i : ℕ) ×' (_ : i ≤ n) ×' P i),
Fin.hIterateFrom._unary P f _x =
PSigma.casesOn _x fun i ubnd =>
PSigma.casesOn ubnd fun ubnd a =>
if g : i < n then Fin.hIterateFrom._unary P f ⟨i + 1, ⟨g, f ⟨i, g⟩ a⟩⟩
else
ha... | null | false |
MulDistribMulActionHom.map_sub | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} (A' : Type u_8) [inst_2 : Group A']
[inst_3 : MulDistribMulAction M A'] (B' : Type u_9) [inst_4 : Group B'] [inst_5 : MulDistribMulAction N B']
(f : A' →ₑ*[φ] B') (x y : A'), f (x / y) = f x / f y | null | true |
uniformity_eq_comap_add_neg_nhds_zero_swapped | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (Gᵣ : Type u_3) [inst : UniformSpace Gᵣ] [inst_1 : AddGroup Gᵣ] [IsRightUniformAddGroup Gᵣ],
uniformity Gᵣ = Filter.comap (fun x => x.1 + -x.2) (nhds 0) | null | true |
Lean.Compiler.LCNF.Param._sizeOf_inst | Lean.Compiler.LCNF.Basic | (pu : Lean.Compiler.LCNF.Purity) → SizeOf (Lean.Compiler.LCNF.Param pu) | null | false |
Std.DHashMap.Raw.contains_insert_self | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β k}, (m.insert k v).contains k = true | null | true |
LinearIndependent.fin_cons | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {x : V} {n : ℕ}
{v : Fin n → V}, LinearIndependent K v → x ∉ Submodule.span K (Set.range v) → LinearIndependent K (Fin.cons x v) | **Alias** of `LinearIndependent.finCons`.
---
See `LinearIndependent.finCons'` for an uglier version that works if you
only have a module over a semiring. | true |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.filter_eq_self_iff._simp_1_3 | Mathlib.Data.Finsupp.Basic | ∀ {a b : Prop}, (¬a → b) = (¬b → a) | null | false |
Equiv.completeDistribLattice._proof_9 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CompleteDistribLattice β] (a : α), e (e.symm (e a)ᶜ) = (e a)ᶜ | null | false |
CategoryTheory.Abelian.SpectralObject.d._auto_5 | Mathlib.Algebra.Homology.SpectralObject.Differentials | Lean.Syntax | null | false |
_private.Mathlib.Topology.Separation.AlexandrovDiscrete.0.nhdsKer_eq_of_t1Space._simp_1_1 | Mathlib.Topology.Separation.AlexandrovDiscrete | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s : Set X} {x : X}, (x ∈ nhdsKer s) = ∃ y ∈ s, x ⤳ y | null | false |
CategoryTheory.IsIso.Iso.inv_hom | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ≅ Y), CategoryTheory.inv f.hom = f.inv | null | true |
Std.Time.PlainTime.ctorIdx | Std.Time.Time.PlainTime | Std.Time.PlainTime → ℕ | null | false |
Lean.Omega.IntList.dot_sdiv_left | Init.Omega.IntList | ∀ (xs ys : Lean.Omega.IntList) {d : ℤ}, d ∣ ↑xs.gcd → (xs.sdiv d).dot ys = xs.dot ys / d | null | true |
Mathlib.Tactic.ITauto.Proof.curry₂ | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.AndKind → Mathlib.Tactic.ITauto.Proof → Mathlib.Tactic.ITauto.Proof → Mathlib.Tactic.ITauto.Proof | This is a partial application of curry.
* `ak = .and`: `(p: A ∧ B → C) (q : A) ⊢ B → C`
* `ak = .iff`: `(p: (A ↔ B) → C) (q: A → B) ⊢ (B → A) → C`
* `ak = .eq`: `(p: (A ↔ B) → C) (q: A → B) ⊢ (B → A) → C`
| true |
MvPolynomial.instAddCommGroupR._aux_16 | Mathlib.FieldTheory.Finite.Polynomial | (σ K : Type u_1) → [inst : Fintype K] → [inst_1 : CommRing K] → ℤ → MvPolynomial.R σ K → MvPolynomial.R σ K | null | false |
Lean.Parser.ParserContextCore.endPos._inherited_default | Lean.Parser.Types | String → String.Pos.Raw | null | false |
_private.Mathlib.GroupTheory.FreeGroup.CyclicallyReduced.0.FreeGroup.instHasUniqueRoots._proof_2 | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u_1} (n : ℕ) (x y : FreeGroup α),
(fun a n =>
(FreeGroup.reduceCyclically.conjugator a.toWord).length +
(n * (FreeGroup.reduceCyclically a.toWord).length +
(FreeGroup.reduceCyclically.conjugator a.toWord).length))
x n =
(fun a n =>
(FreeGroup.red... | null | false |
MeasureTheory.Measure.absolutelyContinuous_of_le | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α}, μ ≤ ν → μ.AbsolutelyContinuous ν | null | true |
Set.uIcc_prod_uIcc | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : Lattice β] (a₁ a₂ : α) (b₁ b₂ : β),
Set.uIcc a₁ a₂ ×ˢ Set.uIcc b₁ b₂ = Set.uIcc (a₁, b₁) (a₂, b₂) | null | true |
Set.insert_diff_singleton | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s : Set α} {a : α}, insert a (s \ {a}) = insert a s | **Alias** of `Set.insert_sdiff_singleton`. | true |
ENat.toENNReal_iInf | Mathlib.Algebra.Order.Floor.Extended | ∀ {ι : Sort u_1} (f : ι → ℕ∞), ↑(⨅ i, f i) = ⨅ i, ↑(f i) | null | true |
RatFunc.liftRingHom._proof_3 | Mathlib.FieldTheory.RatFunc.Basic | ∀ {L : Type u_2} {R : Type u_1} [inst : Field L] [inst_1 : CommRing R] (φ : Polynomial R →+* L)
(hφ : nonZeroDivisors (Polynomial R) ≤ Submonoid.comap φ (nonZeroDivisors L)) (x y : RatFunc R),
(↑(RatFunc.liftMonoidWithZeroHom (↑φ) hφ)).toFun (x * y) =
(↑(RatFunc.liftMonoidWithZeroHom (↑φ) hφ)).toFun x * (↑(RatF... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.