name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MeasureTheory.measure_symmDiff_eq_zero_iff._simp_1 | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, (μ (symmDiff s t) = 0) = (s =ᵐ[μ] t) | null | false |
Mathlib.Meta.FunProp.instInhabitedConfig.default | Mathlib.Tactic.FunProp.Types | Mathlib.Meta.FunProp.Config | null | true |
AlgHom.IsArithFrobAt.isArithFrobAt_localize | Mathlib.RingTheory.Frobenius | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {φ : S →ₐ[R] S}
{Q : Ideal S} (H : φ.IsArithFrobAt Q) [inst_3 : Q.IsPrime],
H.localize.IsArithFrobAt (IsLocalRing.maximalIdeal (Localization.AtPrime Q)) | null | true |
Lean.Linter.isDeprecated | Lean.Linter.Deprecated | Lean.Environment → Lean.Name → Bool | null | true |
IsLocalization.orderIsoOfPrime | Mathlib.RingTheory.Localization.Ideal | {R : Type u_1} →
[inst : CommSemiring R] →
(M : Submonoid R) →
(S : Type u_2) →
[inst_1 : CommSemiring S] →
[inst_2 : Algebra R S] → [IsLocalization M S] → { p // p.IsPrime } ≃o { p // p.IsPrime ∧ Disjoint ↑M ↑p } | If `R` is a ring, then prime ideals in the localization at `M`
correspond to prime ideals in the original ring `R` that are disjoint from `M` | true |
Subrepresentation.instLattice._proof_2 | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {W : Type u_3} [inst : Semiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid W]
[inst_3 : Module A W] {ρ : Representation A G W} {x y : Subrepresentation ρ},
x.toSubmodule < y.toSubmodule ↔ x.toSubmodule < y.toSubmodule | null | false |
Aesop.Frontend.BuilderOption.pattern.noConfusion | Aesop.Frontend.RuleExpr | {P : Sort u} →
{stx stx' : Lean.Term} →
Aesop.Frontend.BuilderOption.pattern stx = Aesop.Frontend.BuilderOption.pattern stx' → (stx = stx' → P) → P | null | false |
Ordinal.opow_lt_opow_left_of_succ | Mathlib.SetTheory.Ordinal.Exponential | ∀ {a b c : Ordinal.{u_1}}, a < b → a ^ Order.succ c < b ^ Order.succ c | null | true |
NumberField.instCommRingInfiniteAdeleRing._proof_11 | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | ∀ (K : Type u_1) [inst : Field K],
autoParam (∀ (n : ℕ) (x : NumberField.InfiniteAdeleRing K), (n + 1) • x = n • x + x) AddMonoid.nsmul_succ._autoParam | null | false |
ContinuousAffineMap.ext_iff | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] {f g : P →ᴬ[R] Q}... | null | true |
Aesop.RulePatternIndex.getCore | Aesop.Index.RulePattern | Lean.Expr → Aesop.RulePatternIndex → Aesop.BaseM (Array (Aesop.RuleName × Aesop.Substitution)) | Get all substitutions of the rule patterns that match a subexpression of
`e`. Subexpressions containing bound variables are not considered. The returned
array may contain duplicates. | true |
Std.DTreeMap.Internal.Impl.find?_toArray_eq_some_iff_get?_eq_some | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] {k : α} {v : β k},
t.WF → (Array.find? (fun x => compare x.fst k == Ordering.eq) t.toArray = some ⟨k, v⟩ ↔ t.get? k = some v) | null | true |
Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries.noConfusion | Mathlib.Tactic.Translate.UnfoldBoundary | {P : Sort u} →
{t t' : Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries} →
t = t' → Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries.noConfusionType P t t' | null | false |
«_aux_Mathlib_Topology_Algebra_Module_ContinuousLinearMap_Positive___macroRules_term_→P[_]__1» | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Positive | Lean.Macro | null | false |
Turing.TM1to0.tr.eq_2 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} [inst : Inhabited Λ] {σ : Type u_3} [inst_1 : Inhabited σ]
(M : Λ → Turing.TM1.Stmt Γ Λ σ) (x : Γ) (q : Turing.TM1.Stmt Γ Λ σ) (v : σ),
Turing.TM1to0.tr M (some q, v) x = some (Turing.TM1to0.trAux M x q v) | null | true |
CategoryTheory.Functor.CoconeTypes.precompose_ι | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} (c : F.CoconeTypes)
{G : CategoryTheory.Functor J (Type w₀')} (app : (j : J) → G.obj j → F.obj j)
(naturality :
∀ {j j' : J} (f : j ⟶ j'),
app j' ∘ ⇑(CategoryTheory.ConcreteCategory.hom (G.map f)) =
⇑... | null | true |
MagmaCat.of.eq_1 | Mathlib.Algebra.Category.Semigrp.Basic | ∀ (M : Type u) [inst : Mul M], ↧M = { carrier := M, str := inst } | null | true |
ContMDiffWithinAt.compContinuousAlternatingMapCLM | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : 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] {F₁ : Type u_8} [inst_6 : NormedAddComm... | null | true |
LipschitzWith.mul_edist_le | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
LipschitzWith K f → ∀ (x y : α), (↑K)⁻¹ * edist (f x) (f y) ≤ edist x y | null | true |
Path.Homotopic.hpath_hext | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u} [inst : TopologicalSpace X] {x₀ x₁ x₂ x₃ : X} {p₁ : Path x₀ x₁} {p₂ : Path x₂ x₃},
(∀ (t : ↑unitInterval), p₁ t = p₂ t) → ⟦p₁⟧ ≍ ⟦p₂⟧ | null | true |
String.Slice.Pattern.Model.CharPred.Decidable.isRevMatch_iff_isRevMatch_decide | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsRevMatch p pos ↔ String.Slice.Pattern.Model.IsRevMatch (fun x => decide (p x)) pos | null | true |
MeasureTheory.Measure.Regular.smul | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace α] [μ.Regular]
{x : ENNReal}, x ≠ ⊤ → (x • μ).Regular | null | true |
PiTensorProduct.tprodMonoidHom._proof_1 | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} (R : Type u_2) {A : ι → Type u_3} [inst : CommSemiring R] [inst_1 : (i : ι) → NonAssocSemiring (A i)]
[inst_2 : (i : ι) → Module R (A i)], (PiTensorProduct.tprod R) 1 = (PiTensorProduct.tprod R) 1 | null | false |
CochainComplex.mkHom_f_succ_succ | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(P Q : CochainComplex V ℕ) (zero : P.X 0 ⟶ Q.X 0) (one : P.X 1 ⟶ Q.X 1)
(one_zero_comm : CategoryTheory.CategoryStruct.comp zero (Q.d 0 1) = CategoryTheory.CategoryStruct.comp (P.d 0 1) one)
(succ :
(n... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Copy.0.SimpleGraph.isContained_iff_exists_iso_subgraph.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {H : SimpleGraph W} (motive : H.IsContained G → Prop)
(x : H.IsContained G), (∀ (f : H.Copy G), motive ⋯) → motive x | null | false |
CategoryTheory.ChosenPullbacksAlong.ofHasPullbacksAlong | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{Y X : C} → (f : Y ⟶ X) → [CategoryTheory.Limits.HasPullbacksAlong f] → CategoryTheory.ChosenPullbacksAlong f | Relating the existing noncomputable `HasPullbacksAlong` typeclass to `ChosenPullbacksAlong`. | true |
NumberField.RingOfIntegers.coe_mk | Mathlib.NumberTheory.NumberField.Basic | ∀ {K : Type u_1} [inst : Field K] {x : K} (hx : x ∈ integralClosure ℤ K), ↑⟨x, hx⟩ = x | null | true |
IsLocalizedModule.instIsTorsionFreeLocalizationLocalizedModuleOfIsDomain | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [IsDomain R]
(S : Submonoid R) [Module.IsTorsionFree R M], Module.IsTorsionFree (Localization S) (LocalizedModule S M) | null | true |
WeierstrassCurve.ΨSq_two | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R), W.ΨSq 2 = W.Ψ₂Sq | null | true |
Filter.map_eq_comap_of_inverse | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {n : β → α},
m ∘ n = id → n ∘ m = id → Filter.map m f = Filter.comap n f | null | true |
MeasureTheory.OuterMeasure.instSMul._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_2} {R : Type u_1} [inst : SMul R ENNReal] [IsScalarTower R ENNReal ENNReal] (c : R)
(m : MeasureTheory.OuterMeasure α), c • m ∅ = 0 | null | false |
Int16.ofIntClamp_int8ToInt | Init.Data.SInt.Lemmas | ∀ (x : Int8), Int16.ofIntClamp x.toInt = x.toInt16 | null | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.StyleError.unwantedUnicode.inj | Mathlib.Tactic.Linter.TextBased | ∀ {c c_1 : Char},
Mathlib.Linter.TextBased.StyleError.unwantedUnicode✝ c = Mathlib.Linter.TextBased.StyleError.unwantedUnicode✝ c_1 →
c = c_1 | null | true |
Matrix.addMonoidHomMulLeft | Mathlib.Data.Matrix.Mul | {l : Type u_1} →
{m : Type u_2} →
{n : Type u_3} →
{α : Type v} → [inst : NonUnitalNonAssocSemiring α] → [Fintype m] → Matrix l m α → Matrix m n α →+ Matrix l n α | Left multiplication by a matrix, as an `AddMonoidHom` from matrices to matrices. | true |
Array.range'_eq_append_iff | Init.Data.Array.Range | ∀ {s n : ℕ} {xs ys : Array ℕ},
Array.range' s n = xs ++ ys ↔ ∃ k ≤ n, xs = Array.range' s k ∧ ys = Array.range' (s + k) (n - k) | null | true |
Multiset.cons_product | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} {β : Type v} (a : α) (s : Multiset α) (t : Multiset β),
(a ::ₘ s) ×ˢ t = Multiset.map (Prod.mk a) t + s ×ˢ t | null | true |
LinearMap.BilinForm.tensorDistrib._proof_3 | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ (R : Type u_2) (A : Type u_1) {M₁ : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M₁] [inst_3 : Algebra R A] [inst_4 : Module A M₁], SMulCommClass A R (M₁ →ₗ[A] A) | null | false |
IsLocalRing.map_mkQ_eq | Mathlib.RingTheory.LocalRing.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsLocalRing R] {N₁ N₂ : Submodule R M},
N₁ ≤ N₂ →
N₂.FG →
(Submodule.map (IsLocalRing.maximalIdeal R • N₂).mkQ N₁ = Submodule.map (IsLocalRing.maximalIdeal R • N₂).mkQ N₂ ↔
N₁ = N₂) | null | true |
Lake.ComputeHash.computeHash | Lake.Build.Trace | {α : Type u} → {m : outParam (Type → Type v)} → [self : Lake.ComputeHash α m] → α → m Lake.Hash | Compute the hash of an object in its preferred monad. | true |
CategoryTheory.ShiftedHom.id_map | Mathlib.CategoryTheory.Shift.ShiftedHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {M : Type u_4} [inst_1 : AddMonoid M]
[inst_2 : CategoryTheory.HasShift C M] {X Y : C} {a : M} (f : CategoryTheory.ShiftedHom X Y a),
f.map (CategoryTheory.Functor.id C) = f | null | true |
CategoryTheory.GrothendieckTopology.le_canonical | Mathlib.CategoryTheory.Sites.Canonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) [J.Subcanonical],
J ≤ CategoryTheory.Sheaf.canonicalTopology C | null | true |
Algebra.Extension.Hom.algebraMap_toRingHom | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
{R' : Type u_1} {S' : Type u_2} [inst_3 : CommRing R'] [inst_4 : CommRing S'] [inst_5 : Algebra R' S']
{P' : Algebra.Extension R' S'} [inst_6 : Algebra R R'] [inst_7 : Algebra S S'] (self : P.Hom... | null | true |
Lean.Grind.CutsatConfig.maxSuggestions._inherited_default | Init.Grind.Config | Option ℕ | null | false |
Submodule.botEquivPUnit_apply | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : ↥⊥),
Submodule.botEquivPUnit x = PUnit.unit | null | true |
CliffordAlgebra.lift._proof_6 | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) {A : Type u_3} [inst_3 : Semiring A] [inst_4 : Algebra R A] (F : CliffordAlgebra Q →ₐ[R] A),
(CliffordAlgebra.ringCon Q).liftₐ ((TensorAlgebra.lift R) ↑⟨F.toLinearMap ∘ₗ CliffordAlgebra.ι Q, ⋯... | null | false |
WeakFEPair.noConfusion | Mathlib.NumberTheory.LSeries.AbstractFuncEq | {P : Sort u} →
{E : Type u_1} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℂ E} →
{t : WeakFEPair E} →
{E' : Type u_1} →
{inst' : NormedAddCommGroup E'} →
{inst'_1 : NormedSpace ℂ E'} →
{t' : WeakFEPair E'} →
E = E' → i... | null | false |
Subalgebra.instCommRingSubtypeMemCenter._proof_14 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Ring A] [inst_2 : Algebra R A],
autoParam (∀ (n : ℕ), IntCast.intCast ↑n = ↑n) AddGroupWithOne.intCast_ofNat._autoParam | null | false |
OrderAddMonoidIso.map_le_map_iff' | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_6} {β : Type u_7} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Add α] [inst_3 : Add β]
(self : α ≃+o β) {a b : α}, self.toFun a ≤ self.toFun b ↔ a ≤ b | An `OrderAddMonoidIso` respects `≤`. | true |
Subgroup.ofUnits_bot | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M], ⊥.ofUnits = ⊥ | null | true |
Ordinal.uniqueToTypeOne._proof_3 | Mathlib.SetTheory.Ordinal.Basic | ∀ (a : Ordinal.ToType 1), a = (Ordinal.enum fun x1 x2 => x1 < x2) ⟨0, Ordinal.uniqueToTypeOne._proof_2⟩ | null | false |
Std.Time.Month.Ordinal.ofNat | Std.Time.Date.Unit.Month | (data : ℕ) → autoParam (data ≥ 1 ∧ data ≤ 12) Std.Time.Month.Ordinal.ofNat._auto_1 → Std.Time.Month.Ordinal | Creates an `Ordinal` from a `Nat`, ensuring the value is within bounds.
| true |
CauSeq.coe_inf._simp_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] (f g : CauSeq α abs),
↑f ⊓ ↑g = ↑(f ⊓ g) | null | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.Code.explicitRc.match_3 | Lean.Compiler.LCNF.ExplicitRC | (motive : Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.impure → Sort u_1) →
(alt : Lean.Compiler.LCNF.Alt Lean.Compiler.LCNF.Purity.impure) →
((c : Lean.Compiler.LCNF.CtorInfo) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.Alt.ctorAlt c k ⋯)) →... | null | false |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_6 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a b : Array α},
j ≤ a.size →
-1 * ↑i + ↑a.size ≤ 0 →
¬-1 * ↑j + ↑a.size ≤ 0 →
¬↑i + -1 * ↑(min j (a ++ b).size) ≤ 0 →
∀ (w : ℕ), w + 1 ≤ ((a ++ b).extract i j).size → w < (a.extract i j).size | null | false |
_private.Mathlib.Tactic.NormNum.NatSqrt.0.Mathlib.Meta.NormNum.evalNatSqrt.match_1 | Mathlib.Tactic.NormNum.NatSqrt | (ex : Q(ℕ)) →
(motive : (ey : Q(ℕ)) × Q(«$ex».sqrt = «$ey») → Sort u_1) →
(x : (ey : Q(ℕ)) × Q(«$ex».sqrt = «$ey»)) →
((ey : Q(ℕ)) → (pf : Q(«$ex».sqrt = «$ey»)) → motive ⟨ey, pf⟩) → motive x | null | false |
ModelWithCorners.MfldCat.diffeomorphOfIso._proof_4 | Mathlib.Geometry.Manifold.Category.MfldCat.OfModel | ∀ {𝕜 : 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} {n : WithTop ℕ∞}
{M N : I.MfldCat n} (i : M ≅ N), ContMDiff I I n ⇑(ModelWithCorners.MfldCat.Hom.hom i.inv) | null | false |
Fin.rec0 | Mathlib.Data.Fin.Basic | {α : Fin 0 → Sort u_1} → (i : Fin 0) → α i | A dependent variant of `Fin.elim0`. | true |
_private.Mathlib.Topology.LocallyClosed.0.isLocallyClosedAt_iff_exists_eq_inter_closure._proof_1_2 | Mathlib.Topology.LocallyClosed | 4 ≠ 0 | null | false |
Lean.Server.instInhabitedRequestError.default | Lean.Server.Requests | Lean.Server.RequestError | null | true |
AlgebraicGeometry.IsZariskiLocalAtSource.of_iSup_eq_top | Mathlib.AlgebraicGeometry.Morphisms.Basic | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsZariskiLocalAtSource P]
{X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {ι : Sort u_1} (U : ι → X.Opens),
iSup U = ⊤ → (∀ (i : ι), P (CategoryTheory.CategoryStruct.comp (U i).ι f)) → P f | null | true |
IsGaloisGroup.fixedPoints_eq_range_algebraMap | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_1) (K : Type u_3) (L : Type u_4) [inst : Group G] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] [inst_4 : MulSemiringAction G L] (H : Subgroup G) [hGKL : IsGaloisGroup G K L] (B : Type u_5)
[inst_5 : CommSemiring B] [inst_6 : Algebra B L] [IsGaloisGroup (↥H) B L],
↑(FixedPoints.interm... | If `G` acts as a Galois group on `L/K` and the subgroup `H` acts as a Galois group on `L/B`,
then the fixed points of `H` equals the range of `algebraMap B L`. | true |
List.splitOnP_cons_eq_if_modifyHead | Init.Data.List.SplitOn.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (x : α) (xs : List α),
List.splitOnP p (x :: xs) =
if p x = true then [] :: List.splitOnP p xs else List.modifyHead (List.cons x) (List.splitOnP p xs) | null | true |
IsMulCentral.left_assoc | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M] {z : M}, IsMulCentral z → ∀ (b c : M), z * (b * c) = z * b * c | associative property for left multiplication | true |
Finpartition.parts_subset_extendOfLE | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] [inst_1 : DecidableEq α] {a b : α} (P : Finpartition a)
(hab : a ≤ b), P.parts ⊆ (P.extendOfLE hab).parts | null | true |
QuaternionAlgebra.imIₗ | Mathlib.Algebra.Quaternion | {R : Type u_3} → (c₁ c₂ c₃ : R) → [inst : CommRing R] → QuaternionAlgebra R c₁ c₂ c₃ →ₗ[R] R | `QuaternionAlgebra.imI` as a `LinearMap` | true |
RestrictedProduct.instT2Space | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)} {𝓕 : Filter ι} [inst : (i : ι) → TopologicalSpace (R i)]
[∀ (i : ι), T2Space (R i)], T2Space (RestrictedProduct (fun i => R i) (fun i => A i) 𝓕) | null | true |
_private.Mathlib.RingTheory.AdicCompletion.Completeness.0.AdicCompletion.pow_smul_top_eq_ker_eval._simp_1_1 | Mathlib.RingTheory.AdicCompletion.Completeness | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ ... | null | false |
Nat.Partrec.Code.rfind'.noConfusion | Mathlib.Computability.PartrecCode | {P : Sort u} → {a a' : Nat.Partrec.Code} → a.rfind' = a'.rfind' → (a = a' → P) → P | null | false |
WellFounded.isWellOrder_iff_exists_not_lt_and_eq_or_gt | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {r : α → α → Prop},
IsWellOrder α r ↔ ∀ (s : Set α), s.Nonempty → ∃ m ∈ s, ∀ x ∈ s, ¬r x m ∧ (m = x ∨ r m x) | null | true |
Pi.instConvexSpaceForall._proof_1 | Mathlib.Geometry.Convex.ConvexSpace.Prod | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {ι : Type u_1}
{X : ι → Type u_2} [inst_3 : (i : ι) → Convexity.ConvexSpace R (X i)] (x : (i : ι) → X i),
(fun i => Convexity.iConvexComb (Convexity.StdSimplex.single x) fun x => x i) = x | null | false |
UInt64.lt_iff_toBitVec_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a < b ↔ a.toBitVec < b.toBitVec | null | true |
Lean.Meta.DefEqCacheKey | Lean.Meta.Basic | Type | null | true |
IsWeakLowerModularLattice.casesOn | Mathlib.Order.ModularLattice | {α : Type u_2} →
[inst : Lattice α] →
{motive : IsWeakLowerModularLattice α → Sort u} →
(t : IsWeakLowerModularLattice α) →
((inf_covBy_of_covBy_covBy_sup : ∀ {a b : α}, a ⋖ a ⊔ b → b ⋖ a ⊔ b → a ⊓ b ⋖ a) → motive ⋯) → motive t | null | false |
Module.Finite.kerRepr | Mathlib.RingTheory.Finiteness.Cardinality | (R : Type u) →
(M : Type u_1) →
[inst : Ring R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → [inst_3 : Module.Finite R M] → Submodule R (Fin ⋯.choose → R) | The kernel of a random surjective linear map from a finite free module
to a given finite module. | true |
TwoP.largeCategory._aux_3 | Mathlib.CategoryTheory.Category.TwoP | (X : TwoP) → X ⟶ X | null | false |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.reduceProjFn?.match_5 | Lean.Meta.Tactic.Simp.Main | (motive : Option Lean.ProjectionFunctionInfo → Sort u_1) →
(__do_lift : Option Lean.ProjectionFunctionInfo) →
(Unit → motive none) → ((projInfo : Lean.ProjectionFunctionInfo) → motive (some projInfo)) → motive __do_lift | null | false |
Lean.Lsp.LeanImport.ctorIdx | Lean.Data.Lsp.Extra | Lean.Lsp.LeanImport → ℕ | null | false |
ComplexShape.Embedding.truncLE'Functor._proof_1 | Mathlib.Algebra.Homology.Embedding.TruncLE | ∀ {ι' : Type u_3} {c' : ComplexShape ι'} (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.CategoryWithHomology C]
(K : HomologicalComplex C c') (i' : ι'), (K.sc i').HasHomology | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.ofIdealTop._proof_7 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (I : Ideal ↑(X.presheaf.obj (Opposite.op ⊤))) (U : ↑X.affineOpens),
∀ x ∈ ↑U,
x ∈ X.zeroLocus ↑I ↔
x ∈ X.zeroLocus ↑(Ideal.map (CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.homOfLE ⋯).op)) I) | null | false |
_private.Init.Data.Int.Order.0.Int.ofNat_le.match_1_1 | Init.Data.Int.Order | ∀ {m n : ℕ} (motive : (∃ n_1, ↑m + ↑n_1 = ↑n) → Prop) (x : ∃ n_1, ↑m + ↑n_1 = ↑n),
(∀ (k : ℕ) (hk : ↑m + ↑k = ↑n), motive ⋯) → motive x | null | false |
_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.SimpleGroundValue.uint8 | Lean.Compiler.LCNF.SimpleGroundExpr | UInt8 → Lean.Compiler.LCNF.SimpleGroundValue✝ | null | true |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.map_f' | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} {X Y : C} {p : X ⟶ Y} {f : F.obj ⊥ ⟶ X}
{g : c.pt ⟶ Y} {j : J} (sq' : CategoryTheory.HasLiftingProperty.transfiniteComposition.Sq... | null | true |
pow_le_pow_right' | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftMono M] {a : M} {n m : ℕ},
1 ≤ a → n ≤ m → a ^ n ≤ a ^ m | null | true |
CategoryTheory.Precoverage.isSheafFor_subsheafify | Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {K : CategoryTheory.Precoverage C}
{F : CategoryTheory.Functor Cᵒᵖ (Type w)} (𝒮 : (Z : C) → Set (F.obj (Opposite.op Z))) {X : C}
{R : CategoryTheory.Presieve X},
R ∈ K.coverings X →
CategoryTheory.Presieve.IsSheafFor F R → CategoryTheory.Presieve.IsShe... | If `F` is a sheaf for `R` and `R ∈ K X`, then the `K`-sheafification of `𝒮` is a
sheaf for `R`. | true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.forall_iff.match_1_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_2} {ι : Sort u_1} {p : ι → Prop} {s : ι → Set α} (_s : Set α) (motive : (∃ i, p i ∧ s i ⊆ _s) → Prop)
(x : ∃ i, p i ∧ s i ⊆ _s), (∀ (i : ι) (hi : p i) (his : s i ⊆ _s), motive ⋯) → motive x | null | false |
Set.Ici.isAtom_iff | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α] {a : α} {b : ↑(Set.Ici a)}, IsAtom b ↔ a ⋖ ↑b | null | true |
CategoryTheory.Functor.homEquivOfIsRightKanExtension._proof_3 | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_3} {H : Type u_4} {D : Type u_1} [inst : CategoryTheory.Category.{u_6, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} H] [inst_2 : CategoryTheory.Category.{u_5, u_1} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : L.comp F' ⟶ F) [inst... | null | false |
RBTree.RBNode.balLeft | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → RBTree.RBNode α → α → RBTree.RBNode α → RBTree.RBNode α | Rebalancing a tree which has shrunk on the left. | true |
mulRightLinearMap_apply | Mathlib.LinearAlgebra.Matrix.Bilinear | ∀ (l : Type u_1) {m : Type u_2} {n : Type u_3} (R : Type u_5) {A : Type u_6} [inst : Fintype m] [inst_1 : Semiring R]
[inst_2 : NonUnitalNonAssocSemiring A] [inst_3 : Module R A] [inst_4 : IsScalarTower R A A] (Y : Matrix m n A)
(x : Matrix l m A), (mulRightLinearMap l R Y) x = x * Y | null | true |
CategoryTheory.CostructuredArrow.toStructuredArrow_obj | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) (d : D) (X : (CategoryTheory.CostructuredArrow F d)ᵒᵖ),
(CategoryTheory.CostructuredArrow.toStructuredArrow F d).obj X =
CategoryTheory.StructuredArrow.mk (Opp... | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Reflexive.0.CategoryTheory.Limits.WalkingParallelPair.inclusionWalkingReflexivePair.match_1.splitter | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | (motive : CategoryTheory.Limits.WalkingParallelPair → Sort u_1) →
(x : CategoryTheory.Limits.WalkingParallelPair) →
(Unit → motive CategoryTheory.Limits.WalkingParallelPair.one) →
(Unit → motive CategoryTheory.Limits.WalkingParallelPair.zero) → motive x | null | true |
_private.Std.Sat.CNF.Basic.0.Std.Sat.CNF.Clause.VarMem_add._simp_1_2 | Std.Sat.CNF.Basic | ∀ {α : Type u_1} {pol : Bool} {c : Std.Sat.CNF.Clause α} {atom1 atom2 : α},
atom1 ≠ atom2 → Std.Sat.CNF.Clause.VarMem atom1 (c.add atom2 pol) = Std.Sat.CNF.Clause.VarMem atom1 c | null | false |
_private.Init.Data.Nat.Div.Basic.0.Nat.mod.match_1.splitter | Init.Data.Nat.Div.Basic | (motive : ℕ → ℕ → Sort u_1) → (x x_1 : ℕ) → ((x : ℕ) → motive 0 x) → ((n m : ℕ) → motive n.succ m) → motive x x_1 | null | true |
Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go.eq_def | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] (k : α) (best : Option (α × β))
(a : Std.DTreeMap.Internal.Impl α fun x => β),
Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go k best a =
match a with
| Std.DTreeMap.Internal.Impl.leaf => best
| Std.DTreeMap.Internal.Impl.inner size ky y l r =>
match comp... | null | true |
Lean.Doc.Parser.UnorderedListType.ofNat | Lean.DocString.Parser | ℕ → Lean.Doc.Parser.UnorderedListType | null | true |
Array.attachWith_eq_map_attach | Init.Data.Array.Attach | ∀ {α : Type u_1} {xs : Array α} {P : α → Prop} {H : ∀ a ∈ xs, P a},
xs.attachWith P H =
Array.map
(fun x =>
match x with
| ⟨x, h⟩ => ⟨x, ⋯⟩)
xs.attach | null | true |
LinearMap.toMatrixOrthonormal._proof_3 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{n : Type u_3} [inst_3 : Fintype n] [inst_4 : DecidableEq n] (v₁ : OrthonormalBasis n 𝕜 E),
Function.RightInverse (LinearMap.toMatrix v₁.toBasis v₁.toBasis).invFun
(↑(LinearMap.toMatrix v₁.toBa... | null | false |
List.suffix_iff_eq_drop | Init.Data.List.Nat.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ ↔ l₁ = List.drop (l₂.length - l₁.length) l₂ | null | true |
Set.sUnion_powerset_gc | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1}, GaloisConnection (fun x => ⋃₀ x) fun x => 𝒫 x | `⋃₀` and `𝒫` form a Galois connection. | true |
_private.Mathlib.NumberTheory.EllipticDivisibilitySequence.0.preNormEDS'._proof_3 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ (n : ℕ), ¬Even n → n / 2 + 5 < n + 5 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.