name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Set.Iic.isCompl_iff | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} {a : α} [inst : Lattice α] [inst_1 : OrderBot α] {x y : ↑(Set.Iic a)},
IsCompl x y ↔ Disjoint ↑x ↑y ∧ ↑x ⊔ ↑y = a | null | true |
Std.HashSet.Raw.Equiv.beq_congr | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α]
{m₃ m₄ : Std.HashSet.Raw α}, m₁.WF → m₂.WF → m₃.WF → m₄.WF → m₁.Equiv m₃ → m₂.Equiv m₄ → (m₁ == m₂) = (m₃ == m₄) | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Symmetric.0.Submodule.isSymmetricProjection_projection_iff._simp_1_3 | Mathlib.Analysis.InnerProductSpace.Symmetric | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E}
(hpq : IsCompl p q), IsIdempotentElem (p.projection q hpq) = True | null | false |
RingSeminormClass.toSubmultiplicativeHomClass | Mathlib.Algebra.Order.Hom.RingNorm | ∀ {F : Type u_4} {α : outParam (Type u_5)} {β : outParam (Type u_6)} {inst : NonUnitalNonAssocRing α}
{inst_1 : Semiring β} {inst_2 : PartialOrder β} {inst_3 : FunLike F α β} [self : RingSeminormClass F α β],
SubmultiplicativeHomClass F α β | null | true |
MonadLiftT.noConfusion | Init.Prelude | {P : Sort u_1} →
{m : Type u → Type v} →
{n : Type u → Type w} →
{t : MonadLiftT m n} →
{m' : Type u → Type v} →
{n' : Type u → Type w} →
{t' : MonadLiftT m' n'} → m = m' → n = n' → t ≍ t' → MonadLiftT.noConfusionType P t t' | null | false |
Lean.Meta.Grind.Arith.CommRing.isField | Lean.Meta.Tactic.Grind.Arith.CommRing.RingM | Lean.Meta.Grind.Arith.CommRing.RingM Bool | null | true |
Algebra.instIsStandardSmoothOfSubsingleton | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [Subsingleton S],
Algebra.IsStandardSmooth R S | null | true |
Metric.Snowflaking.mk | Mathlib.Topology.MetricSpace.Snowflaking | {X : Type u_1} → {α : ℝ} → {hα₀ : 0 < α} → {hα₁ : α ≤ 1} → X → Metric.Snowflaking X α hα₀ hα₁ | null | true |
ZSpan.map | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {E : Type u_1} {ι : Type u_2} {K : Type u_3} [inst : NormedField K] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace K E] (b : Module.Basis ι K E) {F : Type u_4} [inst_3 : AddCommGroup F] [inst_4 : Module K F]
(f : E ≃ₗ[K] F),
Submodule.map (↑(LinearEquiv.restrictScalars ℤ f)) (Submodule.span ℤ (Set.range ... | null | true |
ImportGraph.Shake.Needs.HighToLow.ctorIdx | ImportGraph.Shake.Basic | ImportGraph.Shake.Needs.HighToLow → ℕ | null | false |
Set.union_inter_compl_right_subset | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} (s t : Set α), (s ∪ t) ∩ tᶜ ⊆ s | null | true |
QuaternionAlgebra.lift._proof_2 | Mathlib.Algebra.QuaternionBasis | ∀ {R : Type u_2} {A : Type u_1} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {c₁ c₂ c₃ : R}
(q : QuaternionAlgebra.Basis A c₁ c₂ c₃), (QuaternionAlgebra.Basis.self R).compHom q.liftHom = q | null | false |
Complex.addCommGroup._proof_6 | Mathlib.Basic.Complex.Basic | ∀ (a b : ℂ), a - b = a + -b | null | false |
_private.Mathlib.RingTheory.Invariant.Basic.0.fixed_of_fixed1_aux2 | Mathlib.RingTheory.Invariant.Basic | ∀ {B : Type u_2} [inst : CommRing B] (G : Type u_3) [inst_1 : Group G] [Finite G] [inst_3 : MulSemiringAction G B]
(Q : Ideal B) [Q.IsPrime] (b₀ : B),
(∀ (g : G), g • Q = Q → (algebraMap B (B ⧸ Q)) (g • b₀) = (algebraMap B (B ⧸ Q)) b₀) →
∃ a b,
(∀ (g : G), g • a = a) ∧
a ∉ Q ∧ ∀ (g : G), (algebraM... | A technical lemma for `fixed_of_fixed1`. | true |
Homeomorph.coe_sumComm | Mathlib.Topology.Constructions.SumProd | ∀ (X : Type u) (Y : Type v) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
⇑(Homeomorph.sumComm X Y) = Sum.swap | null | true |
Path.delayReflLeft | Mathlib.Topology.Homotopy.HSpaces | {X : Type u} → [inst : TopologicalSpace X] → {x y : X} → ↑unitInterval → Path x y → Path x y | This is the function on p. 475 of [serre1951], defining a homotopy from a path `γ` to the
product path `e ∧ γ`. | true |
VectorField.mpullback_neg_apply | Mathlib.Geometry.Manifold.VectorField.Pullback | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSp... | null | true |
CategoryTheory.coherentTopology.equivalence' | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
[inst_2 : F.PreservesEffectiveEpis] →
[inst_3 : F.ReflectsEffectiveEpis] →
[inst_4 : F.Full] →
... | The equivalence from coherent sheaves on `C` to coherent sheaves on `D`, given a fully faithful
functor `F : C ⥤ D` to an extensive preregular category, which preserves and reflects effective
epimorphisms and satisfies `F.EffectivelyEnough`.
| true |
instFunLikeContMDiffMonoidMorphism._proof_1 | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {n : WithTop ℕ∞} {H : Type u_4} [inst_1 : TopologicalSpace H]
{E : Type u_5} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_1}
[inst_4 : Monoid G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] {H... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_insertMany_list_of_contains_eq_false._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
cfc_add_const._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doLetArrow._regBuiltin.Lean.Parser.Term.doLetArrow.declRange_3 | Lean.Parser.Do | IO Unit | null | false |
panicCore | Init.Prelude | {α : Sort u} → [Inhabited α] → String → α | Auxiliary definition for `panic`. | true |
locallyConvexSpace_iff_exists_convex_subset | Mathlib.Topology.Algebra.Module.LocallyConvex | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E],
LocallyConvexSpace 𝕜 E ↔ ∀ (x : E), ∀ U ∈ nhds x, ∃ S ∈ nhds x, Convex 𝕜 S ∧ S ⊆ U | null | true |
MulChar.inv._proof_1 | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_2} [inst : CommMonoid R] {R' : Type u_1} [inst_1 : CommMonoidWithZero R'] (χ : MulChar R R') (a : R),
¬IsUnit a → MonoidWithZero.inverse (χ a) = 0 | null | false |
Partition.ctorIdx | Mathlib.Order.Partition.Basic | {α : Type u_1} → {inst : CompleteLattice α} → {s : α} → Partition s → ℕ | null | false |
Finset.preimage_neg | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : InvolutiveNeg α] (s : Finset α), s.preimage (fun x => -x) ⋯ = -s | null | true |
exists_covby_infinite_Ici_of_infinite_Ici | Mathlib.Order.Atoms.Finite | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α} [IsStronglyAtomic α],
(Set.Ici a).Infinite → {x | a ⋖ x}.Finite → ∃ b, a ⋖ b ∧ (Set.Ici b).Infinite | null | true |
Matrix.diagonal_kroneckerTMul_diagonal | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ (R : Type u_1) {α : Type u_3} {β : Type u_5} {m : Type u_10} {n : Type u_11} [inst : CommSemiring R]
[inst_1 : AddCommMonoid α] [inst_2 : AddCommMonoid β] [inst_3 : Module R α] [inst_4 : Module R β]
[inst_5 : DecidableEq m] [inst_6 : DecidableEq n] (a : m → α) (b : n → β),
Matrix.kroneckerMap (TensorProduct.tmu... | null | true |
Std.Sat.CNF.Clause.instInhabited | Std.Sat.CNF.Basic | {α : Type u_1} → Inhabited (Std.Sat.CNF.Clause α) | null | true |
TensorProduct.sum_tmul_eq_zero_of_vanishesTrivially | Mathlib.LinearAlgebra.TensorProduct.Vanishing | ∀ (R : Type u_1) [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι : Type u_4} [inst_5 : Fintype ι] {m : ι → M} {n : ι → N},
TensorProduct.VanishesTrivially R m n → ∑ i, m i ⊗ₜ[R] n i = 0 | **Equational criterion for vanishing**
[A. Altman and S. Kleiman, *A term of commutative algebra* (Lemma 8.16)][altman2021term],
backward direction.
If the expression $\sum_i m_i \otimes n_i$ vanishes trivially, then it vanishes.
That is, $\sum_i m_i \otimes n_i = 0$. | true |
Substring.Raw.ValidFor.extract | Batteries.Data.String.Lemmas | ∀ {l m r ml mm mr : List Char} {b e : String.Pos.Raw} {s : Substring.Raw},
Substring.Raw.ValidFor l m r s →
Substring.Raw.ValidFor ml mm mr { str := String.ofList m, startPos := b, stopPos := e } →
∃ l' r', Substring.Raw.ValidFor l' mm r' (s.extract b e) | null | true |
Batteries.HashMap.toArray | Batteries.Data.HashMap.Basic | {α : Type u_1} → {x : BEq α} → {x_1 : Hashable α} → {β : Type u_2} → Batteries.HashMap α β → Array (α × β) | Converts the map into an array of key-value pairs.
```
open List
(ofList [("one", 1), ("two", 2)]).toArray.data ~ #[("one", 1), ("two", 2)].data
```
| true |
_private.Mathlib.Data.List.Basic.0.List.length_eq_four.match_1_3 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} {l : List α} (motive : (∃ a b c d, l = [a, b, c, d]) → Prop) (x : ∃ a b c d, l = [a, b, c, d]),
(∀ (w w_1 w_2 w_3 : α) (e : l = [w, w_1, w_2, w_3]), motive ⋯) → motive x | null | false |
Mathlib.Tactic.FieldSimp.Sign.minus.inj | Mathlib.Tactic.FieldSimp.Lemmas | ∀ {v : Lean.Level} {M : Q(Type v)} {iM iM_1 : Q(Field «$M»)},
Mathlib.Tactic.FieldSimp.Sign.minus iM = Mathlib.Tactic.FieldSimp.Sign.minus iM_1 → iM = iM_1 | null | true |
Valued.noConfusion | Mathlib.Topology.Algebra.Valued.ValuationTopology | {P : Sort u_1} →
{R : Type u} →
{inst : Ring R} →
{Γ₀ : Type v} →
{inst_1 : LinearOrderedCommGroupWithZero Γ₀} →
{t : Valued R Γ₀} →
{R' : Type u} →
{inst' : Ring R'} →
{Γ₀' : Type v} →
{inst'_1 : LinearOrderedCommGroupWithZero Γ₀... | null | false |
PosNum.size._unsafe_rec | Mathlib.Data.Num.Basic | PosNum → PosNum | null | false |
Aesop.Frontend.Feature.builder.sizeOf_spec | Aesop.Frontend.RuleExpr | ∀ (b : Aesop.Frontend.DBuilderName), sizeOf (Aesop.Frontend.Feature.builder b) = 1 + sizeOf b | null | true |
CategoryTheory.ShortComplex.LeftHomologyData.ofIsColimitCokernelCofork | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(S : CategoryTheory.ShortComplex C) →
S.g = 0 →
(c : CategoryTheory.Limits.CokernelCofork S.f) → CategoryTheory.Limits.IsColimit c → S.LeftHomologyData | When the second map `S.g` is zero, this is the left homology data on `S` given
by any colimit cokernel cofork of `S.f` | true |
Lean.MVarId.refl | Lean.Meta.Tactic.Refl | Lean.MVarId → optParam Bool true → Lean.MetaM Unit | Close given goal using `Eq.refl`.
With (`check := false`), the elaborator does not check if the goal is actually a definitionaly
equality.
See `Lean.MVarId.applyRfl` for the variant that also consults `@[refl]` lemmas, and which
backs the `rfl` tactic.
| true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.u₄.congr_simp | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3}
(S S_1 : FermatLastTheoremForThreeGen.Solution✝ hζ),
S = S_1 →
∀ [inst_1 : NumberField K] [inst_2 : IsCyclotomicExtension {3} ℚ K],
FermatLastTheoremForThreeGen.Solution.u₄✝ S = FermatLastTheoremForThreeGen.Solution.u₄✝ S_1 | null | true |
CategoryTheory.MonoOver.mapIso_unitIso | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A B : C} (e : A ≅ B),
(CategoryTheory.MonoOver.mapIso e).unitIso =
((CategoryTheory.MonoOver.mapComp e.hom e.inv).symm ≪≫
CategoryTheory.eqToIso ⋯ ≪≫ CategoryTheory.MonoOver.mapId A).symm | null | true |
Int.decEq.match_1 | Init.Data.Int.Basic | (a b : ℕ) →
(motive : Decidable (a = b) → Sort u_1) →
(x : Decidable (a = b)) →
((h : a = b) → motive { decide := true, reflects_decide := h }) →
((h : ¬a = b) → motive { decide := false, reflects_decide := h }) → motive x | null | false |
Std.ExtDTreeMap.self_le_maxKeyD_insertIfNew | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k} {fallback : α}, (cmp k ((t.insertIfNew k v).maxKeyD fallback)).isLE = true | null | true |
HahnSeries.instRatCast | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{R : Type u_3} → [Zero Γ] → [inst : PartialOrder Γ] → [inst_1 : Zero R] → [RatCast R] → RatCast (HahnSeries Γ R) | null | true |
AlgebraicGeometry.Proj.basicOpenIsoSpec_hom | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | ∀ {σ : Type u_1} {A : Type u} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (f : A) {m : ℕ} (f_deg : f ∈ 𝒜 m) (hm : 0 < m),
(AlgebraicGeometry.Proj.basicOpenIsoSpec 𝒜 f f_deg hm).hom = AlgebraicGeometry.Proj.basicOpenToSpec 𝒜 f | null | true |
CongruenceSubgroup.Gamma0Map._proof_3 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | SubmonoidClass (Subgroup (Matrix.SpecialLinearGroup (Fin 2) ℤ)) (Matrix.SpecialLinearGroup (Fin 2) ℤ) | null | false |
RBTree.RBNode.instDecidableCmpEqOfTransCmp | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → {x y : α} → (cmp : α → α → Ordering) → [Std.TransCmp cmp] → Decidable (RBTree.RBNode.cmpEq cmp x y) | null | true |
Polynomial.prime_C_iff | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u} [inst : CommRing R] {r : R}, Prime (Polynomial.C r) ↔ Prime r | null | true |
AlgebraicGeometry.Scheme.IsGermInjectiveAt.casesOn | Mathlib.AlgebraicGeometry.SpreadingOut | {X : AlgebraicGeometry.Scheme} →
{x : ↥X} →
{motive : X.IsGermInjectiveAt x → Sort u_1} →
(t : X.IsGermInjectiveAt x) →
((cond :
∃ U,
∃ (hx : x ∈ U),
AlgebraicGeometry.IsAffineOpen U ∧
Function.Injective ⇑(CategoryTheory.ConcreteCat... | null | false |
_private.Mathlib.Probability.Kernel.Proper.0.ProbabilityTheory.Kernel.IsProper.lintegral_mul._simp_1_1 | Mathlib.Probability.Kernel.Proper | ∀ {α : Type u_1} {R : Type u_2} [inst : MulZeroOneClass R] (s : Set α) (r : R) (a : α),
s.indicator (fun x => r) a = r • s.indicator 1 a | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.minView._proof_22 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β) (hr : r.Balanced) (size : ℕ)
(k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced)
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot (Std.DTreeMap.I... | null | false |
Equiv.instAssociativeCoeForallForallArrowCongr | Mathlib.Logic.Equiv.Basic | ∀ {α₁ : Type u_10} {β₁ : Type u_11} (e : α₁ ≃ β₁) (f : α₁ → α₁ → α₁) [Std.Associative f],
Std.Associative ((e.arrowCongr (e.arrowCongr e)) f) | null | true |
Lean.Doc.Parser.UnorderedListType.ctorElim | Lean.DocString.Parser | {motive : Lean.Doc.Parser.UnorderedListType → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Doc.Parser.UnorderedListType) →
ctorIdx = t.ctorIdx → Lean.Doc.Parser.UnorderedListType.ctorElimType ctorIdx → motive t | null | false |
SchauderBasis.range_proj_eq_span | Mathlib.Analysis.Normed.Module.Bases | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {X : Type u_2} [inst_1 : NormedAddCommGroup X]
[inst_2 : NormedSpace 𝕜 X] (b : SchauderBasis 𝕜 X) (n : ℕ),
(↑(b.proj n)).range = Submodule.span 𝕜 (↑b '' ↑(Finset.range n)) | The range of the projection is the span of the first `n` basis elements. | true |
AddSubgroup.inf_normalizer_le_normalizer_inf | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G},
AddSubgroup.normalizer ↑H ⊓ AddSubgroup.normalizer ↑K ≤ AddSubgroup.normalizer ↑(H ⊓ K) | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.keys.eq_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} (k : α) (snd : β k) (l : List ((a : α) × β a)),
Std.Internal.List.keys (⟨k, snd⟩ :: l) = k :: Std.Internal.List.keys l | null | true |
instULiftableContTULift | Mathlib.Control.ULiftable | {s : Type u_5} →
{m : Type u_5 → Type u_6} →
{m' : Type (max u_5 u_7) → Type u_8} → [ULiftable m m'] → ULiftable (ContT s m) (ContT (ULift.{u_7, u_5} s) m') | null | true |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.checkSize.go._unsafe_rec | Lean.Meta.Tactic.Grind.EMatch | ℕ → Lean.Expr → OptionT (StateT ℕ Lean.MetaM) Unit | null | false |
Algebra.PreSubmersivePresentation.ofHasCoeffs._proof_3 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_4} {S : Type u_5} {ι : Type u_1} {σ : Type u_3} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.PreSubmersivePresentation R S ι σ) (R₀ : Type u_2) [inst_3 : CommRing R₀]
[inst_4 : Algebra R₀ R] [inst_5 : Algebra R₀ S] [inst_6 : IsScalarTower R₀ R S] [inst_7 : P.HasCoeffs ... | null | false |
GaloisConnection._to_dual_cast_4 | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] (l : α → β) (u : β → α),
GaloisConnection u l = ∀ (a : α) (b : β), b ≤ l a ↔ u b ≤ a | null | false |
ModularGroup.det_coe | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ {g : Matrix.SpecialLinearGroup (Fin 2) ℤ}, (↑↑(ModularGroup.coe g)).det = 1 | null | true |
_private.Mathlib.Data.Set.Constructions.0.FiniteInter.MemFiniteInterClosure.below.rec | Mathlib.Data.Set.Constructions | ∀ {α : Type u_1} {S : Set (Set α)} {motive : (a : Set α) → FiniteInter.MemFiniteInterClosure✝ S a → Prop}
{motive_1 :
{a : Set α} → (t : FiniteInter.MemFiniteInterClosure✝ S a) → FiniteInter.MemFiniteInterClosure.below✝ t → Prop},
(∀ {s : Set α} (a : s ∈ S), motive_1 ⋯ ⋯) →
motive_1 ⋯ ⋯ →
(∀ {s t : Se... | null | false |
RankCondition.mk._flat_ctor | Mathlib.LinearAlgebra.InvariantBasisNumber | ∀ {R : Type u} [inst : Semiring R],
(∀ {n m : ℕ} (f : (Fin n → R) →ₗ[R] Fin m → R), Function.Surjective ⇑f → m ≤ n) → RankCondition R | null | false |
NumberField.isTotallyReal_top_iff._simp_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | ∀ {K : Type u_2} [inst : Field K], NumberField.IsTotallyReal ↥⊤ = NumberField.IsTotallyReal K | null | false |
MeasureTheory.ae_eq_zero_of_forall_setIntegral_eq_of_sigmaFinite | Mathlib.MeasureTheory.Function.AEEqOfIntegral | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [CompleteSpace E] [MeasureTheory.SigmaFinite μ] {f : α → E},
(∀ (s : Set α), MeasurableSet s → μ s < ⊤ → MeasureTheory.IntegrableOn f s μ) →
(∀ (s : Set α), MeasurableS... | null | true |
lt_mul_left | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a b : M₀} [MulPosStrictMono M₀],
0 < a → 1 < b → a < b * a | null | true |
_private.Mathlib.Analysis.Normed.Module.Basic.0.PseudoMetricSpace.ofSeminormedSpaceCore._abel_5 | Mathlib.Analysis.Normed.Module.Basic | ∀ {E : Type u_1} [inst : AddCommGroup E] (x y z : E), -x + z = -x + y + (-y + z) | null | false |
CompareReals.instInhabitedBourbakiℝ._aux_1 | Mathlib.Topology.UniformSpace.CompareReals | CompareReals.Bourbakiℝ | null | false |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.doNotVisitOfScientific | Lean.Meta.Tactic.Simp.Main | Lean.Meta.Simp.DSimproc | Auxiliary `dsimproc` for not visiting `OfScientific.ofScientific` application subterms.
| true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combine.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {c₁ c₂ c₁_1 c₂_1 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr},
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combine c₁ c₂ =
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combine c₁_1 c₂_1 →
c₁ = c₁_1 ∧ c₂ = c₂_1 | null | true |
_private.Mathlib.RingTheory.Ideal.Colon.0.Submodule.bot_colon'._simp_1_1 | Mathlib.RingTheory.Ideal.Colon | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Submodule R M}
{S : Set M} {r : R}, (r ∈ N.colon S) = ∀ s ∈ S, r • s ∈ N | null | false |
ContinuousLinearEquiv.integral_id_map | Mathlib.Probability.Moments.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace ℝ E] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : NormedSpace ℝ F] [CompleteSpace E] [CompleteSpace F] [inst_9 : MeasurableSpace E]
{μ : Mea... | null | true |
Lean.MetavarContext.LevelMVarToParam.Context.mk.noConfusion | Lean.MetavarContext | {P : Sort u} →
{paramNamePrefix : Lean.Name} →
{alreadyUsedPred : Lean.Name → Bool} →
{except : Lean.LMVarId → Bool} →
{paramNamePrefix' : Lean.Name} →
{alreadyUsedPred' : Lean.Name → Bool} →
{except' : Lean.LMVarId → Bool} →
{ paramNamePrefix := paramNamePrefix, ... | null | false |
WittVector.truncate_liftFun | Mathlib.RingTheory.WittVector.Truncated | ∀ {p : ℕ} (n : ℕ) {R : Type u_1} [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] {S : Type u_2} [inst_2 : Semiring S]
{f : (k : ℕ) → S →+* TruncatedWittVector p k R},
(∀ (k₁ k₂ : ℕ) (hk : k₁ ≤ k₂), (TruncatedWittVector.truncate hk).comp (f k₂) = f k₁) →
∀ (s : S), (WittVector.truncate n) (WittVector.liftFun f... | null | true |
AffineMap.map_vectorSpan | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V₁ : Type u_2} {P₁ : Type u_3} {V₂ : Type u_4} {P₂ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : AddCommGroup V₂]
[inst_5 : Module k V₂] [inst_6 : AddTorsor V₂ P₂] (f : P₁ →ᵃ[k] P₂) {s : Set P₁},
Submodule.map f.linear (vectorS... | The affine version of `LinearMap.map_span`. | true |
ZMod.natCast_toNat | Mathlib.Data.ZMod.Basic | ∀ (p : ℕ) {z : ℤ}, 0 ≤ z → ↑z.toNat = ↑z | null | true |
OrthonormalBasis.span._proof_2 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι' : Type u_3} {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : DecidableEq E] {v' : ι' → E} (s : Finset ι'),
Submodule.span 𝕜 ↑(Finset.image v' s) = Submodule.span 𝕜 (Set.range (v' ∘ Subtype.val)) | null | false |
HahnSeries.orderTop_le_orderTop_smul | Mathlib.RingTheory.HahnSeries.Addition | ∀ {R : Type u_3} {V : Type u_8} [inst : Zero V] [inst_1 : SMulZeroClass R V] {Γ : Type u_9} [inst_2 : LinearOrder Γ]
(r : R) (x : HahnSeries Γ V), x.orderTop ≤ (r • x).orderTop | null | true |
ContDiffMapSupportedIn.seminorm._proof_4 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (E : Type u_1) (F : Type u_2) [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (i : ℕ), BoundedAdd (E [×i]→L[ℝ] F) | null | false |
Lean.Elab.Term.getLevelNames | Lean.Elab.Term.TermElabM | Lean.Elab.TermElabM (List Lean.Name) | Return the universe level names explicitly provided by the user.
| true |
_private.Mathlib.Analysis.InnerProductSpace.Basic.0.inner_sum_smul_sum_smul_of_sum_eq_zero._simp_1_3 | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonUnitalNonAssocSemiring R] (s : Finset ι) (f : ι → R) (a : R),
∑ i ∈ s, f i * a = (∑ i ∈ s, f i) * a | null | false |
CoalgEquiv.symm._proof_4 | Mathlib.RingTheory.Coalgebra.Equiv | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid A]
[inst_2 : AddCommMonoid B] [inst_3 : Module R A] [inst_4 : Module R B] [inst_5 : CoalgebraStruct R A]
[inst_6 : CoalgebraStruct R B] (e : A ≃ₗc[R] B),
Function.LeftInverse e.toLinearEquiv.symm.invFun (↑e.toLinearEqui... | null | false |
CategoryTheory.ShortComplex.RightHomologyData.ofAbelian._proof_6 | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C),
CategoryTheory.Limits.HasKernel
(CategoryTheory.Limits.cokernel.π
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι S.g) (CategoryTheory.Limits.cokernel... | null | false |
LinearIsometryEquiv.symm_symm | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_4} {E₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Mo... | null | true |
MonoidHom.pi | Mathlib.Algebra.Group.Pi.Lemmas | {I : Type u} →
{f : I → Type v} →
[inst : (i : I) → MulOneClass (f i)] →
{γ : Type w} → [inst_1 : MulOneClass γ] → ((i : I) → γ →* f i) → γ →* (i : I) → f i | A family of monoid homomorphisms `f a : γ →* β a` defines a monoid homomorphism
`Pi.monoidHom f : γ →* Π a, β a` given by `Pi.monoidHom f x b = f b x`. | true |
MeasureTheory.integrable_zero_measure | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} [inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε]
{f : α → ε}, MeasureTheory.Integrable f 0 | null | true |
Action.FunctorCategoryEquivalence.inverseMonoidal._proof_14 | Mathlib.CategoryTheory.Action.Monoidal | ∀ (V : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} V] (G : Type u_1) [inst_1 : Monoid G]
[inst_2 : CategoryTheory.MonoidalCategory V],
autoParam
(∀ {X Y : CategoryTheory.Functor (CategoryTheory.SingleObj G) V} (f : X ⟶ Y)
(X' : CategoryTheory.Functor (CategoryTheory.SingleObj G) V),
Categor... | null | false |
CategoryTheory.Pretriangulated.rotCompInvRot_hom_app_hom₃ | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
(X : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.Pretriangulated.rotCompInvRot.hom.app X).hom₃ = ... | null | true |
AddSubgroup.rank_congr | Mathlib.GroupTheory.Rank | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G} [inst_1 : AddGroup.FG ↥H] [inst_2 : AddGroup.FG ↥K],
H = K → AddGroup.rank ↥H = AddGroup.rank ↥K | null | true |
CategoryTheory.LaxMonoidalFunctor.isoOfComponents._proof_1 | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_2, u_4} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F G : CategoryTheory.LaxMonoidalFunctor C D} (e : (X : C) → F.obj X ≅ G.obj X)
(naturality :
... | null | false |
Ideal.instInfinite | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] [IsDedekindDomain S] [Module.Free ℤ S], Infinite S | null | true |
Lean.Meta.generalizeIndices | Lean.Meta.Tactic.Cases | Lean.MVarId → Lean.FVarId → Lean.MetaM Lean.Meta.GeneralizeIndicesSubgoal | Similar to `generalizeTargets` but customized for the `casesOn` motive.
Given a metavariable `mvarId` representing the
```
Ctx, h : I A j, D |- T
```
where `fvarId` is `h`s id, and the type `I A j` is an inductive datatype where `A` are parameters,
and `j` the indices. Generate the goal
```
Ctx, h : I A j, D, j' : J, h... | true |
CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.unitIso._proof_6 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(A : CategoryTheory.Mon (CategoryTheory.Functor C D)),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.mul
{
app := fun ... | null | false |
Aesop.checkRootUnprovable | Aesop.Search.Main | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.SearchM Q (Option Lean.MessageData) | null | true |
TwoUniqueSums.recOn | Mathlib.Algebra.Group.UniqueProds.Basic | {G : Type u_1} →
[inst : Add G] →
{motive : TwoUniqueSums G → Sort u} →
(t : TwoUniqueSums G) →
((uniqueAdd_of_one_lt_card :
∀ {A B : Finset G},
1 < A.card * B.card →
∃ p1 ∈ A ×ˢ B, ∃ p2 ∈ A ×ˢ B, p1 ≠ p2 ∧ UniqueAdd A B p1.1 p1.2 ∧ UniqueAdd A B p2.1 ... | null | false |
CategoryTheory.Pseudofunctor.mapComp'₀₁₃_hom_app_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
(F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat) {b₀ b₁ b₂ b₃ : B} (f₀₁ : b₀ ⟶ b₁) (f₁₂ : b₁ ⟶ b₂)
(f₂₃ : b₂ ⟶ b₃) (f₀₂ : b₀ ⟶ b₂) (f₁₃ : b₁ ⟶ b₃) (f : b₀ ⟶ b₃) (h₀₂ : CategoryTheory.CategoryStruct.comp f₀₁ f₁... | null | true |
_private.Mathlib.GroupTheory.Complement.0.Subgroup.IsComplement.equiv_fst_eq_iff_leftCosetEquivalence._simp_1_2 | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
CategoryTheory.WithTerminal.map_map | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(F : CategoryTheory.Functor C D) {X Y : CategoryTheory.WithTerminal C} (f : X ⟶ Y),
(CategoryTheory.WithTerminal.map F).map f =
match X, Y, f with
| CategoryTheory.WithTerminal.of a, Categ... | null | true |
_private.Init.Data.String.Defs.0.String.Slice.getUTF8Byte._simp_1 | Init.Data.String.Defs | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.