name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Meta.Grind.Arith.CommRing.instMonadRingOfMonadLift | Lean.Meta.Tactic.Grind.Arith.CommRing.MonadRing | (m n : Type → Type) →
[MonadLift m n] → [Lean.Meta.Grind.Arith.CommRing.MonadRing m] → Lean.Meta.Grind.Arith.CommRing.MonadRing n | null | true |
Lean.Grind.CommRing.Var | Init.Grind.Ring.CommSolver | Type | null | true |
CategoryTheory.toSheafify_naturality | Mathlib.CategoryTheory.Sites.Sheafification | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] [inst_2 : CategoryTheory.HasWeakSheafify J D]
{P Q : CategoryTheory.Functor Cᵒᵖ D} (η : P ⟶ Q),
CategoryTheory.CategoryStruct.comp η (CategoryTheor... | null | true |
AlgEquiv.restrictScalars | Mathlib.Algebra.Algebra.Tower | (R : Type u) →
{S : Type v} →
{A : Type w} →
{B : Type u₁} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : Semiring A] →
[inst_3 : Semiring B] →
[inst_4 : Algebra R S] →
[inst_5 : Algebra S A] →
... | R ⟶ S induces S-Alg ⥤ R-Alg | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.f | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{S : C} → (self : F.PreOneHypercoverDenseData S) → (i : self.I₀) → F.obj (self.X i) ⟶ S | the morphisms in the covering of `S` | true |
MeasureTheory.SimpleFunc.coe_sup | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Max β] (f g : MeasureTheory.SimpleFunc α β),
⇑(f ⊔ g) = ⇑f ⊔ ⇑g | null | true |
MvPolynomial.coeffAddMonoidHom._proof_2 | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u_2} {σ : Type u_1} [inst : CommSemiring R] (m : σ →₀ ℕ) (x y : MvPolynomial σ R),
(x + y).coeff m = x.coeff m + y.coeff m | null | false |
ArithmeticFunction.smul_map | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid S] [inst_2 : Module R S] (x : R)
(f : ArithmeticFunction S) (n : ℕ), (x • f) n = x • f n | null | true |
Circle.path._proof_1 | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ (x : Circle), x = Circle.exp (↑x).arg | null | false |
_private.Init.Data.Vector.Zip.0.Array.getElem?_zipWith.match_1.eq_2 | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} (motive : Option α → Option β → Sort u_3) (x : Option α) (x_1 : Option β)
(h_1 : (a : α) → (b : β) → motive (some a) (some b)) (h_2 : (x : Option α) → (x_2 : Option β) → motive x x_2),
(∀ (a : α) (b : β), x = some a → x_1 = some b → False) →
(match x, x_1 with
| some a, som... | null | true |
CategoryTheory.FreeMonoidalCategory.categoryFreeMonoidalCategory._proof_3 | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u_1} {W X Y Z : CategoryTheory.FreeMonoidalCategory C} (f : Quotient (W.setoidHom X))
(g : Quotient (X.setoidHom Y)) (h : Quotient (Y.setoidHom Z)),
Quotient.map₂ CategoryTheory.FreeMonoidalCategory.Hom.comp ⋯
(Quotient.map₂ CategoryTheory.FreeMonoidalCategory.Hom.comp ⋯ f g) h =
Quotient.map₂... | null | false |
_private.Init.Data.List.Basic.0.List.beq.match_1.splitter | Init.Data.List.Basic | {α : Type u_1} →
(motive : List α → List α → Sort u_2) →
(x x_1 : List α) →
(Unit → motive [] []) →
((head : α) → (tail : List α) → motive (head :: tail) []) →
((head : α) → (tail : List α) → motive [] (head :: tail)) →
((a : α) → (as : List α) → (b : α) → (bs : List α) → motiv... | null | true |
Bundle.Pretrivialization.continuousLinearMap._proof_4 | Mathlib.Topology.VectorBundle.Hom | ∀ {𝕜₁ : Type u_4} [inst : NontriviallyNormedField 𝕜₁] {𝕜₂ : Type u_5} [inst_1 : NontriviallyNormedField 𝕜₂]
(σ : 𝕜₁ →+* 𝕜₂) {B : Type u_1} {F₁ : Type u_2} [inst_2 : NormedAddCommGroup F₁] [inst_3 : NormedSpace 𝕜₁ F₁]
{E₁ : B → Type u_6} [inst_4 : (x : B) → AddCommGroup (E₁ x)] [inst_5 : (x : B) → Module 𝕜₁ ... | null | false |
Lean.Parser.Term.matchExprPat | Lean.Parser.Term | Lean.Parser.Parser | null | true |
_private.Mathlib.Data.Multiset.DershowitzManna.0.Multiset.OneStep | Mathlib.Data.Multiset.DershowitzManna | {α : Type u_1} → [Preorder α] → Multiset α → Multiset α → Prop | A special case of `IsDershowitzMannaLT`. The transitive closure of it is used to define
an equivalent (proved later) version of the ordering. | true |
SymmetricAlgebra.rank_eq | Mathlib.LinearAlgebra.SymmetricAlgebra.Basis | ∀ {R : Type uR} {M : Type uM} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Nontrivial M]
[Module.Free R M],
Module.rank R (SymmetricAlgebra R M) = Cardinal.lift.{uR, uM} (max (Module.rank R M) Cardinal.aleph0) | null | true |
_private.Lean.Meta.Basic.0.Lean.Meta.realizeValue.match_3 | Lean.Meta.Basic | (motive : Option Lean.Language.SnapshotTree → Sort u_1) →
(x : Option Lean.Language.SnapshotTree) →
((snap : Lean.Language.SnapshotTree) → motive (some snap)) →
((x : Option Lean.Language.SnapshotTree) → motive x) → motive x | null | false |
AddCommGroup.equiv_directSum_zmod_of_finite | Mathlib.GroupTheory.FiniteAbelian.Basic | ∀ (G : Type u) [inst : AddCommGroup G] [Finite G],
∃ ι x p, ∃ (_ : ∀ (i : ι), Nat.Prime (p i)), ∃ e, Nonempty (G ≃+ DirectSum ι fun i => ZMod (p i ^ e i)) | **Structure theorem of finite abelian groups** : Any finite abelian group is a direct sum of
some `ZMod (p i ^ e i)` for some prime powers `p i ^ e i`. | true |
IsField.isPrincipalIdealRing | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {R : Type u_1} [inst : Ring R], IsField R → IsPrincipalIdealRing R | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus.0.intervalIntegral.intervalIntegrable_deriv_of_nonneg._simp_1_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {α : Type u_1} {ε : Type u_3} {mα : MeasurableSpace α} {f : α → ε} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε], MeasureTheory.IntegrableOn f ∅ μ = True | null | false |
CategoryTheory.PreOneHypercover.p₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
(self : CategoryTheory.PreOneHypercover S) → ⦃i₁ i₂ : self.I₀⦄ → (j : self.I₁ i₁ i₂) → self.Y j ⟶ self.X i₁ | the first projection `Y j ⟶ X i₁` | true |
_private.Init.Data.Vector.Range.0.Vector.fst_eq_of_mem_zipIdx._proof_1 | Init.Data.Vector.Range | ∀ {α : Type u_1} {n : ℕ} {x : α × ℕ} {k : ℕ}, k ≤ x.2 → x.2 < k + n → ¬x.2 - k < n → False | null | false |
HomologicalComplex.Hom.fAddMonoidHom | Mathlib.Algebra.Homology.Additive | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{c : ComplexShape ι} → {C₁ C₂ : HomologicalComplex V c} → (i : ι) → (C₁ ⟶ C₂) →+ (C₁.X i ⟶ C₂.X i) | The `i`-th component of a chain map, as an additive map from chain maps to morphisms. | true |
Lean.Parser.Tactic.MRefinePat.hole.sizeOf_spec | Std.Tactic.Do.Syntax | ∀ (name : Lean.TSyntax `Lean.binderIdent), sizeOf (Lean.Parser.Tactic.MRefinePat.hole name) = 1 + sizeOf name | null | true |
_private.Mathlib.Algebra.Homology.Embedding.AreComplementary.0.ComplexShape.Embedding.embeddingUpInt_areComplementary._proof_1_2 | Mathlib.Algebra.Homology.Embedding.AreComplementary | ∀ (i : ℤ) (k : ℕ), i + ↑k - ↑k = i | null | false |
Real.instContinuousMapUniqueHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {A : Type u_2} [inst : TopologicalSpace A] [T2Space A] [inst_2 : Ring A] [inst_3 : StarRing A] [inst_4 : Algebra ℝ A],
ContinuousMap.UniqueHom ℝ A | null | true |
PowerSeries.constantCoeff.eq_1 | Mathlib.RingTheory.MvPowerSeries.Equiv | ∀ {R : Type u_1} [inst : Semiring R], PowerSeries.constantCoeff = MvPowerSeries.constantCoeff | null | true |
Fintype.card_punit | Mathlib.Data.Fintype.Card | Fintype.card PUnit.{u_3 + 1} = 1 | null | true |
_private.Mathlib.RingTheory.Invariant.Basic.0.fixed_of_fixed1_aux3 | Mathlib.RingTheory.Invariant.Basic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [NoZeroDivisors B]
{b : B} {i j : ℕ} {p : Polynomial A},
Polynomial.map (algebraMap A B) p = (Polynomial.X - Polynomial.C b) ^ i * Polynomial.X ^ j →
∀ (f : B ≃ₐ[A] B), i ≠ 0 → f b = b | A technical lemma for `fixed_of_fixed1`. | true |
mul_eq_of_eq_inv_mul | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, b = a⁻¹ * c → a * b = c | null | true |
Lean.instInhabitedDefinitionVal.default | Lean.Declaration | Lean.DefinitionVal | null | true |
IsSubApply.sub_apply | Mathlib.Algebra.Group.IsApply | ∀ {F : Type u_1} {α : outParam (Type u_2)} {β : outParam (Type u_3)} {inst : FunLike F α β} {inst_1 : Sub β}
{inst_2 : Sub F} [self : IsSubApply F α β] (f g : F) (x : α), (f - g) x = f x - g x | null | true |
_private.Mathlib.CategoryTheory.Subobject.Basic.0.CategoryTheory.Subobject.exists_le_exists_iff_of_mono.match_1_3 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X : C} (x x_1 : CategoryTheory.MonoOver X)
(motive : Quotient.mk'' x ≤ Quotient.mk'' x_1 → Prop) (x_2 : Quotient.mk'' x ≤ Quotient.mk'' x_1),
(∀ (h : x ⟶ x_1), motive ⋯) → motive x_2 | null | false |
PrimitiveSpectrum.hull.eq_1 | Mathlib.Topology.Order.HullKernel | ∀ {α : Type u_1} [inst : SemilatticeInf α] (T : Set α) (a : α), PrimitiveSpectrum.hull T a = Subtype.val ⁻¹' Set.Ici a | null | true |
_private.Mathlib.Tactic.NormNum.Ordinal.0.Mathlib.Meta.NormNum.evalOrdinalNPow.match_1 | Mathlib.Tactic.NormNum.Ordinal | (b : Q(ℕ)) →
(motive : (lit : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsNat «$b» «$lit») → Sort u_1) →
(x : (lit : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsNat «$b» «$lit»)) →
((bn : Q(ℕ)) → (pb : Q(Mathlib.Meta.NormNum.IsNat «$b» «$bn»)) → motive ⟨bn, pb⟩) → motive x | null | false |
Aesop.Tree.mk._flat_ctor | Aesop.Tree.TreeM | Aesop.MVarClusterRef → Lean.Meta.SavedState → ℕ → ℕ → Aesop.GoalId → Aesop.RappId → Std.HashSet Lean.MVarId → Aesop.Tree | null | false |
_private.Mathlib.CategoryTheory.Abelian.Projective.Dimension.0.CategoryTheory.hasProjectiveDimensionLT_of_enoughInjectives._proof_1_5 | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] ⦃Y : C⦄
(p : CategoryTheory.InjectivePresentation Y),
CategoryTheory.CategoryStruct.comp p.f (CategoryTheory.Limits.cokernel.π p.f) = 0 | null | false |
Std.DHashMap.Internal.Raw₀.contains_insertIfNew_self | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], (↑m).WF → ∀ {k : α} {v : β k}, (m.insertIfNew k v).contains k = true | null | true |
AddMonoidAlgebra.divOfHom | Mathlib.Algebra.MonoidAlgebra.Division | {k : Type u_1} →
{G : Type u_2} →
[inst : Semiring k] →
[inst_1 : AddCommMonoid G] → [IsCancelAdd G] → Multiplicative G →* AddMonoid.End (AddMonoidAlgebra k G) | A bundled version of `AddMonoidAlgebra.divOf`. | true |
_private.Aesop.Tree.ExtractProof.0.Aesop.SafePrefixState.goals._default | Aesop.Tree.ExtractProof | Array Lean.MVarId | null | false |
Submodule.IsPrimary.radical_colon_singleton_eq_ite | Mathlib.RingTheory.IsPrimary | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{S : Submodule R M},
S.IsPrimary →
∀ (m : M) [inst_3 : Decidable (m ∈ S)], (S.colon {m}).radical = if m ∈ S then ⊤ else (S.colon Set.univ).radical | null | true |
IO.Process.SpawnArgs.stdout._inherited_default | Init.System.IO | IO.Process.Stdio | null | false |
RingEquiv.quotientBot._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R : Type u_1) [inst : Ring R], RingHomClass (R ≃+* R) R R | null | false |
_private.Mathlib.Algebra.Order.Field.Power.0.Mathlib.Meta.Positivity.evalZPow._proof_3 | Mathlib.Algebra.Order.Field.Power | ∀ {u : Lean.Level} {α : Q(Type u)} (pα : Q(PartialOrder «$α»)) (_a : Q(LinearOrder «$α»)),
«$pα» =Q instDistribLatticeOfLinearOrder.toSemilatticeInf.toPartialOrder | null | false |
ContinuousLinearMapWOT.toCLM_comp | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_5} {𝕜₂ : Type u_6} {𝕜₃ : Type u_7} {E : Type u_9} {F : Type u_10} {G : Type u_11} [inst : NormedField 𝕜₁]
[inst_1 : NormedField 𝕜₂] [inst_2 : NormedField 𝕜₃] {σ₁₂ : 𝕜₁ →+* 𝕜₂} {σ₁₃ : 𝕜₁ →+* 𝕜₃} {σ₂₃ : 𝕜₂ →+* 𝕜₃}
[inst_3 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] [inst_4 : AddCommGroup E] [inst_5 : ... | null | true |
_private.ImportGraph.Tools.FindHome.0.ImportGraph.Shake._aux_ImportGraph_Tools_FindHome___elabRules_ImportGraph_Shake_findHomeStx_1.match_14 | ImportGraph.Tools.FindHome | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) →
((cmdRange : Lean.Syntax.Range) → motive (some cmdRange)) → ((x : Option Lean.Syntax.Range) → motive x) → motive x | null | false |
CategoryTheory.IsUniversalColimit.nonempty_isColimit_of_isPullback_right._auto_3 | Mathlib.CategoryTheory.Limits.VanKampen | Lean.Syntax | null | false |
PiTensorProduct.instSemiring._proof_1 | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_2} {A : ι → Type u_3} [inst : CommSemiring R] [inst_1 : (i : ι) → Semiring (A i)]
[inst_2 : (i : ι) → Algebra R (A i)] (x : PiTensorProduct R fun i => A i), x ^ 0 = 1 | null | false |
Std.TreeSet.get!_inter_of_not_mem_left | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
k ∉ t₁ → (t₁ ∩ t₂).get! k = default | null | true |
Finset.orderEmbOfCardLe | Mathlib.Data.Finset.Sort | {α : Type u_1} → [inst : LinearOrder α] → (s : Finset α) → {k : ℕ} → k ≤ s.card → Fin k ↪o α | Given a finset `s` of size at least `k` in a linear order `α`, the map `orderEmbOfCardLe`
is an order embedding from `Fin k` to `α` whose image is contained in `s`. Specifically, it maps
`Fin k` to an initial segment of `s`. | true |
_private.Mathlib.Algebra.CharP.Defs.0.ExpChar.exists_unique.match_1_1 | Mathlib.Algebra.CharP.Defs | ∀ (R : Type u_1) [inst : Ring R] (motive : (∃ q, ExpChar R q) → Prop) (x : ∃ q, ExpChar R q),
(∀ (q : ℕ) (H : ExpChar R q), motive ⋯) → motive x | null | false |
_private.Aesop.Script.SpecificTactics.0.Aesop.introsS.tacticBuilder | Aesop.Script.SpecificTactics | Lean.MVarId × Array Lean.FVarId → Aesop.Script.TacticBuilder | null | true |
SimpleGraph.isBridge_iff_adj_and_forall_cycle_notMem | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {e : Sym2 V},
e ∈ G.edgeSet → (G.IsBridge e ↔ ∀ ⦃u : V⦄ (p : G.Walk u u), p.IsCycle → e ∉ p.edges) | **Alias** of `SimpleGraph.isBridge_iff_forall_cycle_notMem`. | true |
LinearMap.HasFiniteRange.smul | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V : Type u_2} {V₂ : Type u_3} [inst : CommRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] {f : V →ₗ[K] V₂},
f.HasFiniteRange → ∀ (c : K), (c • f).HasFiniteRange | null | true |
Ordnode.Bounded.weak_left._f | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : Preorder α] (x : Ordnode α)
(f : Ordnode.below (motive := fun x => ∀ (x_1 : WithBot α) (x_2 : WithTop α), x.Bounded x_1 x_2 → x.Bounded ⊥ x_2) x)
(x_1 : WithBot α) (x_2 : WithTop α), x.Bounded x_1 x_2 → x.Bounded ⊥ x_2 | null | false |
pointedToBipointedCompBipointedToPointedFst._proof_4 | Mathlib.CategoryTheory.Category.Bipointed | ∀ (X : Pointed),
id ((pointedToBipointed.comp bipointedToPointedFst).obj X).point =
id ((pointedToBipointed.comp bipointedToPointedFst).obj X).point | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.i₃_le._proof_5 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {r₀ : ℤ} (r r' : ℤ),
autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.i₃_le._auto_1 →
autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.i₃_le._auto_3 → r₀ ≤ r | null | false |
CategoryTheory.Discrete.as | Mathlib.CategoryTheory.Discrete.Basic | {α : Type u₁} → CategoryTheory.Discrete α → α | A wrapper for promoting any type to a category,
with the only morphisms being equalities. | true |
Module.Finite.iff_addGroup_fg | Mathlib.RingTheory.Finiteness.Defs | ∀ {G : Type u_4} [inst : AddCommGroup G], Module.Finite ℤ G ↔ AddGroup.FG G | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.cast_append_right._proof_1 | Init.Data.BitVec.Lemmas | ∀ {w v v' : ℕ}, w + v = w + v' → ¬v = v' → False | null | false |
_private.Init.Data.String.Lemmas.Iter.0.Std.Iter.intercalateString_eq._simp_1_7 | Init.Data.String.Lemmas.Iter | ∀ {α : Type u_1} {p q : List α}, (p ++ q = []) = (p = [] ∧ q = []) | null | false |
MeasureTheory.SimpleFunc.instCommGroup._proof_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : CommGroup β] (a b : MeasureTheory.SimpleFunc α β),
a * b = b * a | null | false |
ContinuousLinearMap.comp_toSpanSingleton | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₁ : Type u_4} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
{M₂ : Type u_6} [inst_3 : TopologicalSpace M₂] [inst_4 : AddCommMonoid M₂] [inst_5 : Module R₁ M₁]
[inst_6 : Module R₁ M₂] [inst_7 : TopologicalSpace R₁] [inst_8 : ContinuousSMul R₁ M₂] [inst_9 : Contin... | null | true |
Lean.Compiler.LCNF.Simp.CtorInfo.getNumParams | Lean.Compiler.LCNF.Simp.DiscrM | Lean.Compiler.LCNF.Simp.CtorInfo → ℕ | null | true |
Std.WP.WP.Frames.mk._flat_ctor | Std.WP.Frame | ∀ {Prog : Type u} {Value : Type v} {Pred : Type w} {EPred : Type z} [inst : Std.WP.Assertion Pred]
[inst_1 : Std.WP.Assertion EPred] [inst_2 : Std.WP.WP Prog Value Pred EPred] {R : Type t} {op : R → Pred → Pred}
{x : Prog} {F : R},
(∀ (Q : Value → Pred) (E : EPred),
Lean.Order.PartialOrder.rel (op F (Std.WP... | null | false |
Std.Time.instInhabitedFormatConfig.default | Std.Time.Format.Basic | Std.Time.FormatConfig | null | true |
Int8.decLe._aux_1 | Init.Data.SInt.Basic | (a b : Int8) → Decidable (a ≤ b) | null | false |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcycles_X₂ | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n : ... | null | true |
Lean.Expr.getNumHeadForalls._f | Lean.Expr | (x : Lean.Expr) → Lean.Expr.below x → ℕ | null | false |
IsIntegrallyClosedIn.exists_algebraMap_eq_of_pow_mem_subalgebra | Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra R A] {S : Subalgebra R A}
[IsIntegrallyClosedIn (↥S) A] {x : A} {n : ℕ}, 0 < n → x ^ n ∈ S → ∃ y, (algebraMap (↥S) A) y = x | null | true |
Mathlib.Tactic.Ring.Common.ExBaseNat.ctorElimType | Mathlib.Tactic.Ring.Common | {motive_1 : (e : Q(ℕ)) → Mathlib.Tactic.Ring.Common.ExBaseNat e → Sort u} → ℕ → Sort (max 1 u) | null | false |
_private.Mathlib.Combinatorics.Tiling.Tile.0.DiscreteTiling.PlacedTile.instSMul._simp_2 | Mathlib.Combinatorics.Tiling.Tile | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
_private.Mathlib.Algebra.GroupWithZero.Units.Basic.0.Ring.not_isUnit_iff_inverse_eq_zero._proof_1_1 | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] [Nontrivial M₀] {x : M₀}, ¬IsUnit x ↔ Ring.inverse x = 0 | null | false |
Matrix.mulAction | Mathlib.LinearAlgebra.Matrix.Defs | {m : Type u_2} →
{n : Type u_3} → {R : Type u_5} → {α : Type v} → [inst : Monoid R] → [MulAction R α] → MulAction R (Matrix m n α) | null | true |
_private.Init.Data.List.Zip.0.List.unzip_eq_map.match_1_1 | Init.Data.List.Zip | ∀ {α : Type u_2} {β : Type u_1} (motive : List (α × β) → Prop) (x : List (α × β)),
(∀ (_ : Unit), motive []) → (∀ (a : α) (b : β) (l : List (α × β)), motive ((a, b) :: l)) → motive x | null | false |
Module.End.IsNilpotent.mapQ | Mathlib.RingTheory.Nilpotent.Lemmas | ∀ {R : Type u_1} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{p : Submodule R M} (hp : p ≤ Submodule.comap f p), IsNilpotent f → IsNilpotent (p.mapQ p f hp) | null | true |
_private.Lake.Util.Version.0.Lake.VerRange.parseM | Lake.Util.Version | (s : String) → EStateM String s.Pos Lake.VerRange | null | true |
WithTopology.instSemilatticeInf.eq_1 | Mathlib.Topology.WithTopology | ∀ {X : Type u_1} (t : TopologicalSpace X) [inst : SemilatticeInf X],
WithTopology.instSemilatticeInf t = Function.Injective.semilatticeInf WithTopology.ofTopology ⋯ ⋯ ⋯ ⋯ | null | true |
AlternatingMap.mkContinuousAlternating._proof_1 | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u_4} {E : Type u_6} {F : Type u_2} {G : Type u_3} {ι : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : SeminormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : ... | null | false |
List.zipIdx_map | Init.Data.List.Nat.Range | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {k : ℕ} {f : α → β},
(List.map f l).zipIdx k = List.map (Prod.map f id) (l.zipIdx k) | null | true |
Function.IsPartialInv.eq | Mathlib.Logic.Function.Basic | ∀ {α : Type u_4} {β : Sort u_5} {f : α → β} {g : β → Option α}, Function.IsPartialInv f g → ∀ (x : α), g (f x) = some x | null | true |
StarAlgEquiv.toAlgEquiv._proof_3 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_3} {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 : Star A] [inst_6 : Star B] (f : A ≃⋆ₐ[R] B) (x y : A),
f.toFun (x + y) = f.toFun x + f.toFun y | null | false |
MulDistribMulActionHom.mk.injEq | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : Monoid A]
[inst_3 : MulDistribMulAction M A] {B : Type u_5} [inst_4 : Monoid B] [inst_5 : MulDistribMulAction N B]
(toMulActionHom : A →ₑ[⇑φ] B) (map_one' : toMulActionHom.toFun 1 = 1)
(map_mul' : ∀ (x y : ... | null | true |
Affine.Simplex.orthogonalProjectionSpan_restrict | Mathlib.Geometry.Euclidean.Projection | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : MetricSpace P] [inst_4 : NormedAddTorsor V P] {n : ℕ}
(s : Affine.Simplex 𝕜 P n) (S : AffineSubspace 𝕜 P) (hS : affineSpan 𝕜 (Set.range s.points) ≤ S) (p : ↥S),
↑↑((s.r... | null | true |
SheafOfModules.createsLimit._proof_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Limits | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_6, u_3} C] {J : CategoryTheory.GrothendieckTopology C}
{D : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} D] {R : CategoryTheory.Sheaf J RingCat}
(F : CategoryTheory.Functor D (SheafOfModules R))
[∀ (X : Cᵒᵖ),
Small.{u_4, max u_2 u_4}
↑((F... | null | false |
GenLoop.copy.congr_simp | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} (f f_1 : ↑(GenLoop N X x)) (e_f : f = f_1)
(g g_1 : (N → ↑unitInterval) → X) (e_g : g = g_1) (h : g = ⇑f), GenLoop.copy f g h = GenLoop.copy f_1 g_1 ⋯ | null | true |
Polynomial.map_mem_nthRootsFinset_one | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} {n : ℕ} [inst : CommRing R] [inst_1 : IsDomain R] {S : Type u_1} {F : Type u_2} [inst_2 : CommRing S]
[inst_3 : IsDomain S] [inst_4 : FunLike F R S] [RingHomClass F R S] {x : R},
x ∈ Polynomial.nthRootsFinset n 1 → ∀ (f : F), f x ∈ Polynomial.nthRootsFinset n 1 | null | true |
Std.Sat.CNF.maxLiteral | Std.Sat.CNF.RelabelFin | Std.Sat.CNF ℕ → Option ℕ | Obtain the literal with the largest identifier in `f`.
| true |
Set.preimage_comp_eq | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : β → γ},
Set.preimage (g ∘ f) = Set.preimage f ∘ Set.preimage g | null | true |
AlgebraicTopology.DoldKan.instReflectsIsomorphismsSimplicialObjectKaroubiChainComplexNatN₁ | Mathlib.AlgebraicTopology.DoldKan.NReflectsIso | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C],
AlgebraicTopology.DoldKan.N₁.ReflectsIsomorphisms | null | true |
Std.Rio.toList_eq_if_roo | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rio α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [inst_6 : Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_7 : Std.Rxo.IsAlwaysFinite... | null | true |
Int.shiftRight_trailingZeros_mod_two | Init.Data.Dyadic.Basic | ∀ {i : ℤ}, i ≠ 0 → i >>> i.trailingZeros % 2 = 1 | null | true |
Function.Antiperiodic.periodic_two_mul | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : NonAssocSemiring α] [inst_1 : InvolutiveNeg β],
Function.Antiperiodic f c → Function.Periodic f (2 * c) | If a function is `antiperiodic` with antiperiod `c`, then it is also `Periodic` with period
`2 * c`. | true |
Lean.Meta.DiscrTree.Trie.recOn | Lean.Meta.DiscrTree.Types | {α : Type} →
{motive_1 : Lean.Meta.DiscrTree.Trie α → Sort u} →
{motive_2 : Array (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) → Sort u} →
{motive_3 : List (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) → Sort u} →
{motive_4 : Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α → ... | null | false |
Std.DTreeMap.Internal.Impl.explore._sunfold | Std.Data.DTreeMap.Internal.Model | {α : Type u} →
{β : α → Type v} →
{γ : Type w} →
[inst : Ord α] →
(k : α → Ordering) →
γ → (γ → Std.DTreeMap.Internal.Impl.ExplorationStep α β k → γ) → Std.DTreeMap.Internal.Impl α β → γ | null | false |
WithZeroTopology.isClosed_iff | Mathlib.Topology.Algebra.WithZeroTopology | ∀ {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {s : Set Γ₀},
IsClosed s ↔ 0 ∈ s ∨ ∃ γ, γ ≠ 0 ∧ s ⊆ Set.Ici γ | null | true |
hasProdLocallyUniformlyOn_of_of_forall_exists_nhds | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β],
(∀ x ∈ s, ∃ t ∈ nhdsWithin x s, HasProdUniformlyOn f g t) → HasProdLocallyUniformlyOn f g s | If every `x ∈ s` has a neighbourhood within `s` on which `b ↦ ∏' i, f i b` converges uniformly
to `g`, then the product converges locally uniformly on `s` to `g`. Note that this is not a
tautology, and the converse is only true if the domain is locally compact. | true |
CategoryTheory.Sheaf.adjunction_unit_app_hom | Mathlib.CategoryTheory.Sites.Adjunction | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] {E : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} E]
{F : CategoryTheory.Functor D E} {G : CategoryTheory.Functor E D} [inst_3 : CategoryTheor... | null | true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5b.0.CochainComplex.cm5b.i._proof_1 | Mathlib.Algebra.Homology.Factorizations.CM5b | 1 + 1 = 2 | null | false |
CategoryTheory.Idempotents.instAddCommGroupHom._proof_11 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{P Q : CategoryTheory.Idempotents.Karoubi C} (f g : P ⟶ Q), f + g = g + f | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.