name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
PairReduction.finset_logSizeBallSeq_subset_logSizeBallSeq_init | Mathlib.Topology.EMetricSpace.PairReduction | ∀ {T : Type u_1} [inst : TopologicalSpace T] [inst_1 : WeakPseudoEMetricSpace T] {a c : ENNReal} {J : Finset T}
[inst_2 : DecidableEq T] (hJ : J.Nonempty) (i : ℕ), (PairReduction.logSizeBallSeq J hJ a c i).finset ⊆ J | null | true |
_private.Mathlib.Tactic.GCongr.Core.0.Lean.MVarId.gcongr._sparseCasesOn_7 | Mathlib.Tactic.GCongr.Core | {motive : ℕ → Sort u} → (t : ℕ) → ((n : ℕ) → motive n.succ) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.CompStruct.0.SSet.Edge.InvStruct.ext.match_1 | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | ∀ {X : SSet} {x₀ x₁ : X.obj (Opposite.op { len := 0 })} {hom : SSet.Edge x₀ x₁} (motive : hom.InvStruct → Prop)
(h : hom.InvStruct),
(∀ (inv : SSet.Edge x₁ x₀) (homInvId : hom.CompStruct inv (SSet.Edge.id x₀))
(invHomId : inv.CompStruct hom (SSet.Edge.id x₁)),
motive { inv := inv, homInvId := homInvId, ... | null | false |
RootPairing.coroot_eq_neg_iff | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) {i j : ι},
P.coroot i = -P.coroot j ↔ i = (P.reflectionPerm j) j | null | true |
IsQuotientCoveringMap.commute_monodromyPerm_toPermFiber | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X} {G : Type u_4}
[inst_2 : Group G] [inst_3 : MulAction G E] (hp : IsQuotientCoveringMap p G) {g : G} {x : X}
{γ : FundamentalGroup X x}, Commute ((⋯.monodromyPerm x) γ) ((hp.toPermFiber x) g) | null | true |
UInt8.ext | Batteries.Data.UInt | ∀ {x y : UInt8}, x.toNat = y.toNat → x = y | null | true |
Std.Roo.size_eq_match_roc | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roo α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxo.HasSize α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[Std.Rxo.IsAlwaysFinite α] [Std.Rxo.LawfulHasSize α],
r.size =
match Std.PRange.succ? r.lowe... | null | true |
_private.Mathlib.Data.Nat.Dist.0.Nat.dist_zero_right._proof_1_1 | Mathlib.Data.Nat.Dist | ∀ (n : ℕ), n - 0 + (0 - n) = n | null | false |
NNRat.divNat_zero | Mathlib.Data.NNRat.Defs | ∀ (n : ℕ), NNRat.divNat n 0 = 0 | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.activateNextGuard.go.match_1 | Lean.Meta.Tactic.Grind.Types | (motive : Lean.Meta.Simp.Result → Sort u_1) →
(x : Lean.Meta.Simp.Result) →
((e : Lean.Expr) →
(proof? : Option Lean.Expr) → (cache : Bool) → motive { expr := e, proof? := proof?, cache := cache }) →
motive x | null | false |
Lean.Grind.CommRing.Poly.noConfusion | Init.Grind.Ring.CommSolver | {P : Sort u} → {t t' : Lean.Grind.CommRing.Poly} → t = t' → Lean.Grind.CommRing.Poly.noConfusionType P t t' | null | false |
RingHom.CodescendsAlong.algebraMap_tensorProduct | Mathlib.RingTheory.RingHomProperties | ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
(Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) (R S T : Type u)
[inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T],
(RingHom.Cod... | null | true |
star_pow | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] (x : R) (n : ℕ), star (x ^ n) = star x ^ n | null | true |
Std.Sat.CNF.eval_empty | Std.Sat.CNF.Sat | ∀ {α : Type u_1} (a : α → Bool), Std.Sat.CNF.eval a Std.Sat.CNF.empty = true | null | true |
DiscreteMeasurableSpace.mk | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_6} [inst : MeasurableSpace α], (∀ (s : Set α), MeasurableSet s) → DiscreteMeasurableSpace α | null | true |
LocallyConstant.instCommGroup._proof_6 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : CommGroup Y] (x : LocallyConstant X Y) (x_1 : ℤ),
⇑(x ^ x_1) = ⇑(x ^ x_1) | null | false |
Set.OrdConnected.isSuccArchimedean | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] (s : Set α)
[inst_3 : s.OrdConnected], IsSuccArchimedean ↑s | null | true |
Lean.Parser.Term.falseVal.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
String.Slice.takeWhile_char_eq_takeWhile_beq | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice}, s.takeWhile c = s.takeWhile fun x => x == c | null | true |
_private.Mathlib.Order.Sublattice.0.Sublattice.map_symm_eq_iff_eq_map._simp_1_3 | Mathlib.Order.Sublattice | ∀ {α : Type u_2} [inst : Lattice α] {L M : Sublattice α}, (L = M) = (↑L = ↑M) | null | false |
Set.image_affine_Ico | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {K : Type u_2} [inst : DivisionSemiring K] [inst_1 : PartialOrder K] [PosMulReflectLT K] [IsOrderedCancelAddMonoid K]
[ExistsAddOfLE K] {a : K},
0 < a → ∀ (b c d : K), (fun x => a * x + b) '' Set.Ico c d = Set.Ico (a * c + b) (a * d + b) | null | true |
AlgebraicGeometry.Scheme.Modules.pullback._proof_1 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
(SheafOfModules.pushforward (AlgebraicGeometry.Scheme.Hom.toRingCatSheafHom f)).IsRightAdjoint | null | false |
Std.HashMap.contains_modify | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k k' : α} {f : β → β}, (m.modify k f).contains k' = m.contains k' | null | true |
Algebra.IsIntegral.comap_surjective | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.IsIntegral R S] [FaithfulSMul R S], Function.Surjective (PrimeSpectrum.comap (algebraMap R S)) | null | true |
CategoryTheory.MonoidalCategory.instMonoidalFunctorTensoringRight._proof_6 | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y Z : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.MonoidalCategory.curriedAssociatorNatIso... | null | false |
Lean.PrettyPrinter.Formatter.State.noConfusionType | Lean.PrettyPrinter.Formatter | Sort u → Lean.PrettyPrinter.Formatter.State → Lean.PrettyPrinter.Formatter.State → Sort u | null | false |
Lean.Meta.MatcherApp.remaining | Lean.Meta.Match.MatcherApp.Basic | Lean.Meta.MatcherApp → Array Lean.Expr | null | true |
inv_eq_one_divp | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (u : αˣ), ↑u⁻¹ = 1 /ₚ u | null | true |
_private.Mathlib.NumberTheory.SmoothNumbers.0.Nat.mem_factoredNumbers_iff_forall_le.match_1_3 | Mathlib.NumberTheory.SmoothNumbers | ∀ {s : Finset ℕ} {m : ℕ} (motive : (m ≠ 0 ∧ ∀ (p : ℕ), Nat.Prime p ∧ p ∣ m ∧ m ≠ 0 → p ∈ s) → Prop)
(x : m ≠ 0 ∧ ∀ (p : ℕ), Nat.Prime p ∧ p ∣ m ∧ m ≠ 0 → p ∈ s),
(∀ (H₀ : m ≠ 0) (H₁ : ∀ (p : ℕ), Nat.Prime p ∧ p ∣ m ∧ m ≠ 0 → p ∈ s), motive ⋯) → motive x | null | false |
PNat.XgcdType.y | Mathlib.Data.PNat.Xgcd | PNat.XgcdType → ℕ | `y` satisfies `b / d = z + y` at the final step. | true |
ContinuousLinearMap.coe_projKerOfRightInverse_apply | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Restrict | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Ring R₁] [inst_1 : Ring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] {M₁ : Type u_3} {M₂ : Type u_4} [inst_3 : TopologicalSpace M₁]
[inst_4 : AddCommGroup M₁] [inst_5 : Module R₁ M₁] [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommGroup M₂]
[i... | null | true |
PseudoMetricSpace.toUniformSpace | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u} → [self : PseudoMetricSpace α] → UniformSpace α | null | true |
CategoryTheory.MorphismProperty.llp_rlp_of_hasSmallObjectArgument' | Mathlib.CategoryTheory.SmallObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C)
[inst_1 : I.HasSmallObjectArgument],
I.rlp.llp =
((CategoryTheory.MorphismProperty.coproducts.{w, v, u} I).pushouts.transfiniteCompositionsOfShape
I.smallObjectκ.ord.ToType).retracts | If `I : MorphismProperty C` permits the small object argument,
then the class of morphisms that have the left lifting property with respect to
the maps that have the right lifting property with respect to `I` are
exactly the retracts of transfinite compositions (indexed by `I.smallObjectκ.ord.ToType`)
of pushouts of co... | true |
Submonoid.LocalizationMap.mulEquivOfLocalizations_right_inv | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) (k : S.LocalizationMap P),
f.ofMulEquivOfLocalizations (f.mulEquivOfLocalizations k) = k | null | true |
Besicovitch.TauPackage.color.eq_1 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
(x : Ordinal.{u}),
p.color x =
sInf
(Set.univ \
⋃ j,
⋃ (_ :
(Metric.closedBall (p.c (p.index ↑j)) (p.r (p.index ↑j)) ∩
Metric.closedBall (p.c (p.index x... | null | true |
PiTensorProduct.dualDistribEquivOfBasis_symm_apply | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {ι : Type u_1} {R : Type u_2} {κ : ι → Type u_3} {M : ι → Type u_4} [inst : CommRing R]
[inst_1 : (i : ι) → AddCommGroup (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : Finite ι]
[inst_4 : ∀ (i : ι), Finite (κ i)] (b : (i : ι) → Module.Basis (κ i) R (M i))
(a : Module.Dual R (PiTensorProduct R fun i => M i... | null | true |
FractionalIdeal.ne_zero_of_mul_eq_one | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R₁ : Type u_3} [inst : CommRing R₁] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra R₁ K]
(I J : FractionalIdeal (nonZeroDivisors R₁) K), I * J = 1 → I ≠ 0 | null | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.x_mul_y_mul_z_eq_u_mul_w_cube._simp_1_8 | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution✝ hζ)
[inst_1 : NumberField K] [inst_2 : IsCyclotomicExtension {3} ℚ K],
(hζ.toInteger - 1) ^ (3 * FermatLastTheoremForThreeGen.Solution.multiplicity✝ S - 2) *
FermatLastTheoremForThreeGen.Solution.x... | null | false |
Matrix.isUnit_charpolyRev_of_isNilpotent | Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff | ∀ {R : Type u} [inst : CommRing R] {n : Type v} [inst_1 : DecidableEq n] [inst_2 : Fintype n] {M : Matrix n n R},
IsNilpotent M → IsUnit M.charpolyRev | null | true |
Polynomial.natDegree_mul_C_eq_of_mul_ne_zero | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R},
p.leadingCoeff * a ≠ 0 → (p * Polynomial.C a).natDegree = p.natDegree | Although not explicitly stated, the assumptions of lemma `natDegree_mul_C_eq_of_mul_ne_zero`
force the polynomial `p` to be non-zero, via `p.leadingCoeff ≠ 0`.
| true |
_private.Mathlib.Order.Setoid.Partition.Card.0.Setoid.IsPartition.ncard_eq_finsum._simp_1_11 | Mathlib.Order.Setoid.Partition.Card | ∀ {α : Type u_1} {β : α → Type u_4} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂}, (⟨a₁, b₁⟩ = ⟨a₂, b₂⟩) = (a₁ = a₂ ∧ b₁ ≍ b₂) | null | false |
PartialEquiv.transEquiv._proof_2 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} (e : PartialEquiv α β) (f' : β ≃ γ),
↑(e.trans f'.toPartialEquiv).symm = ↑(e.trans f'.toPartialEquiv).symm | null | false |
Lean.Meta.Simp.Stats.diag | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Stats → Lean.Meta.Simp.Diagnostics | null | true |
Homeomorph.toEquiv_piCongrLeft | Mathlib.Topology.Homeomorph.Lemmas | ∀ {ι : Type u_5} {ι' : Type u_6} {Y : ι' → Type u_7} [inst : (j : ι') → TopologicalSpace (Y j)] (e : ι ≃ ι'),
(Homeomorph.piCongrLeft e).toEquiv = Equiv.piCongrLeft Y e | null | true |
Stream'.cons_injective2 | Mathlib.Data.Stream.Init | ∀ {α : Type u}, Function.Injective2 Stream'.cons | null | true |
Lean.Grind.CommRing.Poly.combine.go.match_1.congr_eq_4 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Sort u_1) (p₁ p₂ : Lean.Grind.CommRing.Poly)
(h_1 : (k₁ k₂ : ℤ) → motive (Lean.Grind.CommRing.Poly.num k₁) (Lean.Grind.CommRing.Poly.num k₂))
(h_2 :
(k₁ k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) →
(p₂ : Lean.Grind.CommRing.Poly) →
... | null | true |
DirectSum.decomposeLinearEquiv_apply | Mathlib.Algebra.DirectSum.Decomposition | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} [inst : DecidableEq ι] [inst_1 : Semiring R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] (ℳ : ι → Submodule R M) [inst_4 : DirectSum.Decomposition ℳ] (m : M),
(DirectSum.decomposeLinearEquiv ℳ) m = (DirectSum.decompose ℳ) m | null | true |
ContinuousLinearMap.compContinuousMultilinearMapL._proof_1 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ (𝕜 : Type u_4) {ι : Type u_1} (E : ι → Type u_2) (F : Type u_5) (G : Type u_3) [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : TopologicalSpace F]
[inst_7 ... | null | false |
Rep.instLinearResFunctor | Mathlib.RepresentationTheory.Rep.Res | ∀ {G : Type v1} {H : Type v2} [inst : Monoid G] [inst_1 : Monoid H] (f : H →* G) {k : Type u} [inst_2 : CommSemiring k],
CategoryTheory.Functor.Linear k (Rep.resFunctor f) | null | true |
SeparationQuotient.instAddSemigroup.eq_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddSemigroup M] [inst_2 : ContinuousAdd M],
SeparationQuotient.instAddSemigroup = { toAdd := SeparationQuotient.instAdd, add_assoc := ⋯ } | null | true |
Flow.mk | Mathlib.Dynamics.Flow | {τ : Type u_1} →
{α : Type u_2} →
[inst : TopologicalSpace τ] →
[inst_1 : TopologicalSpace α] →
[inst_2 : AddZero τ] →
(toFun : τ → α → α) →
Continuous (Function.uncurry toFun) →
(∀ (t₁ t₂ : τ) (x : α), toFun (t₁ + t₂) x = toFun t₁ (toFun t₂ x)) → (∀ (x : α), toFu... | null | true |
BitVec.getMsbD_or | Init.Data.BitVec.Lemmas | ∀ {w i : ℕ} {x y : BitVec w}, (x ||| y).getMsbD i = (x.getMsbD i || y.getMsbD i) | null | true |
CategoryTheory.Limits.colimit.isoColimitCocone.eq_1 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F]
(t : CategoryTheory.Limits.ColimitCocone F),
CategoryTheory.Limits.colimit.isoColimitCocone t =
(CategoryTheory.Li... | null | true |
Submodule.toLocalizedQuotient' | Mathlib.Algebra.Module.LocalizedModule.Submodule | {R : Type u_5} →
(S : Type u_6) →
{M : Type u_7} →
{N : Type u_8} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : AddCommGroup M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
... | The localization map of a quotient module. | true |
Quantale.noConfusion | Mathlib.Algebra.Order.Quantale | {P : Sort u} →
{α : Type u_1} →
{inst : Semigroup α} →
{inst_1 : CompleteLattice α} →
{inst_2 : IsQuantale α} →
{t : Quantale α} →
{α' : Type u_1} →
{inst' : Semigroup α'} →
{inst'_1 : CompleteLattice α'} →
{inst'_2 : IsQuantale α... | null | false |
MoritaEquivalence.mk.inj | Mathlib.RingTheory.Morita.Basic | ∀ {R : Type u₀} {inst : CommSemiring R} {A : Type u₁} {inst_1 : Ring A} {inst_2 : Algebra R A} {B : Type u₂}
{inst_3 : Ring B} {inst_4 : Algebra R B} {eqv : ModuleCat A ≌ ModuleCat B}
{linear : autoParam (CategoryTheory.Functor.Linear R eqv.functor) MoritaEquivalence.linear._autoParam}
{eqv_1 : ModuleCat A ≌ Modu... | null | true |
NNReal.natCast_iSup | Mathlib.Basic.NNReal.Basic | ∀ {ι : Sort u_4} (f : ι → ℕ), ↑(⨆ i, f i) = ⨆ i, ↑(f i) | null | true |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.instBEqKey.beq._sparseCasesOn_3 | Lean.Meta.LazyDiscrTree | {motive : Lean.Meta.LazyDiscrTree.Key → Sort u} →
(t : Lean.Meta.LazyDiscrTree.Key) →
((a : Lean.Literal) → motive (Lean.Meta.LazyDiscrTree.Key.lit a)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
LieAlgebra.IsKilling.restr_invtSubmoduleToLieIdeal_eq_iSup | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : FiniteDimensional K L] [inst_5 : LieAlgebra.IsKilling K L] {H : LieSubalgebra K L}
[inst_6 : H.IsCartanSubalgebra] [inst_7 : LieModule.IsTriangularizable K (↥H) L] (q : Submodule K (Module... | null | true |
Subgroup.mulSingle_mem_pi | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_5} {f : η → Type u_6} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → Subgroup (f i)} (i : η) (x : f i), Pi.mulSingle i x ∈ Subgroup.pi I H ↔ i ∈ I → x ∈ H i | null | true |
_private.Mathlib.CategoryTheory.EssentialImage.0.CategoryTheory.Functor.essImage_comp_apply_of_essSurj.match_1_3 | Mathlib.CategoryTheory.EssentialImage | ∀ {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {F : CategoryTheory.Functor C D} (Y : D)
(motive : F.essImage Y → Prop) (x : F.essImage Y), (∀ (Z : C) (e' : F.obj Z ≅ Y), motive ⋯) → motive x | null | false |
Lean.Meta.Instances._sizeOf_1 | Lean.Meta.Instances | Lean.Meta.Instances → ℕ | null | false |
Rep.FiniteCyclicGroup.chainComplexFunctor_map_f | Mathlib.RepresentationTheory.Homological.FiniteCyclic | ∀ (k : Type u) {G : Type u} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (g : G)
{X Y : Rep.{u_1, u, u} k G} (f : X ⟶ Y) (i : ℕ), ((Rep.FiniteCyclicGroup.chainComplexFunctor k g).map f).f i = f | null | true |
Matrix.card_SL_field | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.Card | ∀ {𝔽 : Type u_1} [inst : Field 𝔽] [inst_1 : Fintype 𝔽] (n : ℕ) [NeZero n],
Nat.card (Matrix.SpecialLinearGroup (Fin n) 𝔽) =
(∏ i, (Fintype.card 𝔽 ^ n - Fintype.card 𝔽 ^ ↑i)) / (Fintype.card 𝔽 - 1) | The cardinal of the special linear group over a finite field. | true |
CategoryTheory.Monoidal.leftRigidFunctorCategory | Mathlib.CategoryTheory.Monoidal.Rigid.FunctorCategory | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Groupoid C] →
[inst_1 : CategoryTheory.Category.{v_1, u_2} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
[CategoryTheory.LeftRigidCategory D] → CategoryTheory.LeftRigidCategory (CategoryTheory.Functor C D) | null | true |
_private.Mathlib.Algebra.Category.ModuleCat.Ext.Basic.0.CategoryTheory.Abelian.Ext.postcomp_smul_id_mono_iff._simp_1_1 | Mathlib.Algebra.Category.ModuleCat.Ext.Basic | ∀ {A B : AddCommGrpCat} (f : A ⟶ B), CategoryTheory.Mono f = Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom f) | null | false |
Submodule.orthogonal_orthogonal | Mathlib.Analysis.InnerProductSpace.Projection.Submodule | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [K.HasOrthogonalProjection], Kᗮᗮ = K | If `K` admits an orthogonal projection, then the orthogonal complement of its orthogonal
complement is itself. | true |
instReprAtomBool | Init.Data.Repr | ReprAtom Bool | null | true |
AddMonoidAlgebra.exists_supDegree_mem_support | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : Semiring R] [inst_1 : LinearOrder B] [inst_2 : OrderBot B]
{p : AddMonoidAlgebra R A} (D : A → B), p ≠ 0 → ∃ a ∈ p.coeff.support, AddMonoidAlgebra.supDegree D p = D a | null | true |
Ideal.quotEquivPowQuotPowSucc._proof_2 | Mathlib.RingTheory.Ideal.IsPrincipalPowQuotient | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R | null | false |
smooth_functions_tower | Mathlib.Geometry.Manifold.DerivationBundle | ∀ (𝕜 : 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],
IsScalarTower 𝕜 (ContMDiffMap I (mo... | null | true |
uniformContinuousOn_iff_restrict | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β} {s : Set α},
UniformContinuousOn f s ↔ UniformContinuous (s.domRestrict f) | null | true |
Int.ediv_dvd_iff_dvd_mul._simp_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, b ∣ a → b ≠ 0 → (a / b ∣ c) = (a ∣ b * c) | null | false |
ContinuousMap.compStarAlgHom._proof_6 | Mathlib.Topology.ContinuousMap.Star | ∀ (X : Type u_1) {𝕜 : Type u_4} {A : Type u_2} {B : Type u_3} [inst : TopologicalSpace X] [inst_1 : CommSemiring 𝕜]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring A] [inst_4 : Star A] [inst_5 : ContinuousStar A]
[inst_6 : Algebra 𝕜 A] [inst_7 : TopologicalSpace B] [inst_8 : Semiring B] [inst_9 : Star B]
[ins... | null | false |
WellFounded.partialExtrinsicFix₂ | Init.WFExtrinsicFix | {α : Sort u_1} →
{β : α → Sort u_2} →
{C₂ : (a : α) → β a → Sort u_3} →
[∀ (a : α) (b : β a), Nonempty (C₂ a b)] →
(R : (a : α) ×' β a → (a : α) ×' β a → Prop) →
((a : α) → (b : β a) → ((a' : α) → (b' : β a') → R ⟨a', b'⟩ ⟨a, b⟩ → C₂ a' b') → C₂ a b) →
(a : α) → (b : β a) → C₂ ... | A 2-ary fixpoint combinator that can be used to construct recursive functions with an
**extrinsic, partial** proof of termination.
Given a relation `R` and a fixpoint functional `F` which must be decreasing with respect
to `R`, `partialExtrinsicFix₂ R F` is the recursive function obtained by having `F` call
itself rec... | true |
AugmentedSimplexCategory.inr_comp_associator_assoc | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (x y z : AugmentedSimplexCategory) {Z : AugmentedSimplexCategory}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj x (CategoryTheory.MonoidalCategoryStruct.tensorObj y z) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalCategoryStruct.tensorObj x y).inr z)
(CategoryTheory.CategoryStruct... | null | true |
Lean.IndirectModUse.recOn | Lean.ExtraModUses | {motive : Lean.IndirectModUse → Sort u} →
(t : Lean.IndirectModUse) →
((kind : String) → (declName : Lean.Name) → motive { kind := kind, declName := declName }) → motive t | null | false |
CategoryTheory.effectiveEpiFamilyStructOfIsColimit._proof_1 | Mathlib.CategoryTheory.Sites.EffectiveEpimorphic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} {α : Type u_3} (X : α → C)
(π : (a : α) → X a ⟶ B) (obj : CategoryTheory.Over B) (hT : (CategoryTheory.Sieve.generateFamily X π).arrows obj.hom),
∃ g, CategoryTheory.CategoryStruct.comp g (π (Exists.choose hT)) = obj.hom | null | false |
Bool.instDecidableLe | Init.Data.Bool | (x y : Bool) → Decidable (x ≤ y) | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache._sizeOf_1 | Std.Sat.AIG.CNF | {aig : Std.Sat.AIG ℕ} → {cnf : Std.Sat.CNF ℕ} → Std.Sat.AIG.toCNF.Cache✝ aig cnf → ℕ | null | false |
PredOrder.prelimitRecOn._proof_2 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] (a : α),
¬Order.IsPredPrelimit a → ∃ b, ¬IsMin b ∧ Order.pred b = a | null | false |
Lean.Doc.Syntax.footnote_ref | Lean.DocString.Syntax | Lean.ParserDescr | A footnote definition.
| true |
Batteries.Tactic.tacticSplit_ands | Batteries.Tactic.Init | Lean.ParserDescr | `split_ands` applies `And.intro` on all goals until it does not make progress. | true |
_private.Batteries.Data.UnionFind.Lemmas.0.Batteries.UnionFind.equiv_union._simp_1_4 | Batteries.Data.UnionFind.Lemmas | ∀ {a b : ℕ} {self : Batteries.UnionFind} {x : Fin self.size}, (self.find x).fst.Equiv a b = self.Equiv a b | null | false |
Lean.Meta.Grind.Goal.ppENodeRef | Lean.Meta.Tactic.Grind.PP | Lean.Meta.Grind.Goal → Lean.Expr → Lean.MetaM Lean.MessageData | Helper function for pretty printing the state for debugging purposes. | true |
_private.Mathlib.Analysis.Meromorphic.Divisor.0.MeromorphicOn.divisor._simp_13 | Mathlib.Analysis.Meromorphic.Divisor | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∃ a, p a ∧ q a ∧ a = a') = (p a' ∧ q a') | null | false |
_private.Mathlib.Util.PrintSorries.0.Mathlib.PrintSorries.collect._sparseCasesOn_1 | Mathlib.Util.PrintSorries | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Group.Generators.ofFreeGroupHom_lift | Mathlib.GroupTheory.Generators | ∀ {G : Type u_1} {ι : Type u_3} [inst : Group G] (φ : FreeGroup ι →* G) (hφ : Function.Surjective ⇑φ),
(Group.Generators.ofFreeGroupHom φ hφ).lift = φ | The canonical surjection attached to `ofFreeGroupHom φ hφ` is `φ`. | true |
CategoryTheory.ComposableArrows.ext | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C n}
(h : ∀ (i : Fin (n + 1)), F.obj i = G.obj i),
(∀ (i : ℕ) (hi : i < n),
F.map' i (i + 1) ⋯ hi =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheory.Cate... | null | true |
Subgroup.normalizer_eq_top | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [h : H.Normal], Subgroup.normalizer ↑H = ⊤ | null | true |
CategoryTheory.Sheaf.instMonoidalFunctorOppositePresheafToSheaf._proof_19 | Mathlib.CategoryTheory.Sites.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_3) [inst_1 : CategoryTheory.Category.{u_2, u_3} A] [inst_2 : CategoryTheory.MonoidalCategory A]
[inst_3 : J.W.IsMonoidal] [inst_4 : CategoryTheory.HasWeakSheafify J A],
autoParam
(CategoryThe... | null | false |
circleMap_zero_zpow | Mathlib.Analysis.SpecialFunctions.Complex.CircleMap | ∀ (n : ℤ) (R θ : ℝ), circleMap 0 R θ ^ n = circleMap 0 (R ^ n) (↑n * θ) | null | true |
Lean.Grind.Linarith.Expr.intMul | Init.Grind.Ordered.Linarith | ℤ → Lean.Grind.Linarith.Expr → Lean.Grind.Linarith.Expr | null | true |
_private.Init.Data.String.Lemmas.IsEmpty.0.String.Slice.startPos_eq_endPos_iff._simp_1_1 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
Equiv.piUnique | Mathlib.Logic.Equiv.Defs | {α : Sort u} → [inst : Unique α] → (β : α → Sort u_1) → ((i : α) → β i) ≃ β default | The equivalence `(∀ i, β i) ≃ β ⋆` when the domain of `β` only contains `⋆` | true |
_private.Mathlib.CategoryTheory.Triangulated.Orthogonal.0.CategoryTheory.ObjectProperty.isLocal_trW.match_1_1 | Mathlib.CategoryTheory.Triangulated.Orthogonal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.ObjectProperty C)
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.Preadditive C] [inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_5 : CategoryTh... | null | false |
ENat.add_lt_add | Mathlib.Data.ENat.Basic | ∀ {a b c d : ℕ∞}, a < c → b < d → a + b < c + d | null | true |
EuclideanGeometry.Sphere._sizeOf_inst | Mathlib.Geometry.Euclidean.Sphere.Basic | (P : Type u_2) → {inst : MetricSpace P} → [SizeOf P] → SizeOf (EuclideanGeometry.Sphere P) | null | false |
Mathlib.Meta.NormNum.deriveBool | Mathlib.Tactic.NormNum.Core | (p : Q(Prop)) → Lean.MetaM ((b : Bool) × Mathlib.Meta.NormNum.BoolResult p b) | Run each registered `norm_num` extension on a typed expression `p : Prop`,
and returning the truth or falsity of `p' : Prop` from an equivalence `p ↔ p'`. | true |
Filter.zeroAtFilterSubmodule | Mathlib.Order.Filter.ZeroAndBoundedAtFilter | (𝕜 : Type u_1) →
{α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace β] →
[inst_1 : Semiring 𝕜] →
[inst_2 : AddCommMonoid β] →
[inst_3 : Module 𝕜 β] → [ContinuousAdd β] → [ContinuousConstSMul 𝕜 β] → Filter α → Submodule 𝕜 (α → β) | `zeroAtFilterSubmodule l` is the submodule of `f : α → β` which
tend to zero along `l`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.